test: stabilize every-node auto-run across environments; document the tiers

The cannotRunAlone baseline (per pack, in the manifest) records nodes
that cannot execute standalone on a bare backend, asserted both ways so
entries cannot rot: an unlisted failure is a regression, a listed node
that runs clean must be removed. queuePrompt rejection is retried once
before classifying VALIDATION_FAIL - pack JS hooking the queue path can
refuse transiently, and the backend log proved several apparent rejects
never reached the server. Nodes whose execution depends on their own
pack JS preprocessing widget values (rgthree Power widgets, KJ editors)
are excluded unconditionally with the mechanism recorded, since whether
a page applies pack JS varies by serving setup; ML-session initializers
and unstable executed-set reporters join them. ADDING_PACKS and the
README document the every-node tiers and all five exception ledgers.

Verified 65/65 in both documented environments: dev server and
dist-serving CI parity, twice consecutively on the latter.

.github/workflows/ci-tests-custom-nodes.yaml

@@ -0,0 +1,154 @@
+# Runs the custom-node regression suite against a backend that has the manifest
+# packs actually installed, so the load/run tiers execute for real. This is a
+# GATING check: if a pack fails to install or any tier is skipped, the job goes
+# red - a regression gate that let a broken pack through as a "skip" would be
+# pointless. Mark `custom-nodes-e2e` as a required status check in branch
+# protection to block merges on failure.
+name: 'CI: Tests Custom Nodes'
+
+on:
+  pull_request:
+    branches-ignore: [wip/*, draft/*, temp/*]
+  push:
+    branches: [main, master]
+  merge_group:
+  workflow_dispatch:
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
+
+jobs:
+  # Path gating lives here, not in a trigger-level `paths:` filter: a required
+  # check gated by trigger paths never creates a check run on an unrelated PR
+  # and leaves branch protection stuck Pending. A job-level `if:` still creates
+  # the check and marks it Skipped (= passing). Mirrors ci-tests-unit.yaml.
+  changes:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+    outputs:
+      should-run: ${{ steps.changes.outputs.should-run }}
+    steps:
+      - uses: actions/checkout@v6
+      - id: changes
+        uses: ./.github/actions/changes-filter
+
+  custom-nodes-e2e:
+    needs: changes
+    # Run only when non-docs code changed AND the PR is same-repo. Fork PRs can
+    # edit the manifest's repo/pin URLs, and this job clones and pip-installs
+    # whatever they point at (setup.py runs at install time), so an untrusted
+    # fork must not be able to aim the clone at an attacker-controlled repo.
+    # Fork PRs still get the environment-agnostic coverage via the main e2e
+    # shards. A skipped job counts as passing, so this stays required-safe.
+    if: >-
+      needs.changes.outputs.should-run == 'true' &&
+      (github.event_name != 'pull_request' ||
+      github.event.pull_request.head.repo.full_name == github.repository)
+    runs-on: ubuntu-latest
+    timeout-minutes: 30
+    permissions:
+      contents: read
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v6
+
+      - name: Setup frontend
+        uses: ./.github/actions/setup-frontend
+        with:
+          include_build_step: true
+
+      - name: Setup Playwright
+        uses: ./.github/actions/setup-playwright
+
+      # Checks out ComfyUI, installs Python/torch/requirements and ComfyUI_devtools.
+      # launch_server:false so we can add the manifest packs before booting.
+      - name: Setup ComfyUI server
+        uses: ./.github/actions/setup-comfyui-server
+        with:
+          launch_server: 'false'
+
+      # Install every pack the manifest declares (DRY: a new pack row installs
+      # itself here, no workflow change). A clone or dependency failure fails the
+      # job - if a pack can't be installed, its coverage can't run, and that is a
+      # gate failure, not something to paper over. The `jq | while` pipe hides
+      # failures in a subshell, so read into an array and loop with `set -e`.
+      - name: Install manifest custom nodes
+        shell: bash
+        run: |
+          set -euo pipefail
+          # Pin the CPU torch stack that setup-comfyui-server installed so no
+          # pack's requirements.txt can pull a GPU/incompatible torch onto this
+          # --cpu runner. A pack that genuinely needs a different torch fails
+          # the constrained install loudly rather than silently swapping it.
+          pip freeze | grep -iE '^(torch|torchvision|torchaudio)==' \
+            > /tmp/torch-constraints.txt || true
+          manifest=browser_tests/fixtures/data/customNodeManifest.json
+          mapfile -t entries < <(jq -c '.[]' "$manifest")
+          for entry in "${entries[@]}"; do
+            repo=$(jq -r '.repo' <<<"$entry")
+            pin=$(jq -r '.pin' <<<"$entry")
+            name=$(basename "$repo")
+            dir="ComfyUI/custom_nodes/$name"
+            echo "::group::install $name"
+            git clone --depth 1 "$repo" "$dir"
+            if [ -n "$pin" ]; then
+              git -C "$dir" fetch --depth 1 origin "$pin"
+              git -C "$dir" checkout "$pin"
+            fi
+            if [ -f "$dir/requirements.txt" ]; then
+              pip install -r "$dir/requirements.txt" -c /tmp/torch-constraints.txt
+            fi
+            echo "::endgroup::"
+          done
+
+      # The VHS run-tier workflow reads input/plain_video.mp4.
+      - name: Stage run-tier assets
+        shell: bash
+        run: cp browser_tests/assets/plain_video.mp4 ComfyUI/input/plain_video.mp4
+
+      # --cache-none so retried run-tier tests re-execute every node (a cached
+      # node emits no `executing` event and would false-fail PARTIAL).
+      - name: Start ComfyUI server
+        shell: bash
+        working-directory: ComfyUI
+        run: |
+          python main.py --cpu --multi-user --cache-none --front-end-root ../dist &
+          wait-for-it --service 127.0.0.1:8188 -t 600
+
+      - name: Run custom-node suite
+        env:
+          PLAYWRIGHT_JSON_OUTPUT_NAME: custom-nodes-results.json
+        run: |
+          pnpm exec playwright test browser_tests/tests/customNodes/ \
+            --project=chromium --reporter=list,json
+
+      # A skip here means a pack or devtools did not load: on this backend every
+      # tier is meant to run, so a skip is a gate failure, not an honest pass.
+      - name: Forbid skipped tests
+        if: always()
+        shell: bash
+        run: |
+          set -euo pipefail
+          skipped=$(jq '.stats.skipped' custom-nodes-results.json)
+          echo "skipped tests: $skipped"
+          if [ "$skipped" != "0" ]; then
+            echo "::error::$skipped test(s) skipped - a manifest pack or devtools failed to load; skips are not acceptable in the gating job"
+            # Recurse so specs nested under describe() blocks are found, and
+            # print only the specs that actually skipped.
+            jq -r '.. | objects
+                     | select(has("title") and has("tests"))
+                     | select(any(.tests[]?; .status == "skipped"))
+                     | .title' custom-nodes-results.json | sort -u | head -40
+            exit 1
+          fi
+
+      - name: Upload Playwright report
+        if: always()
+        uses: actions/upload-artifact@v6
+        with:
+          name: playwright-report-custom-nodes
+          path: playwright-report/
+          retention-days: 7
+          if-no-files-found: warn

apps/website/e2e/customers-detail.spec.ts

@@ -70,39 +70,4 @@ test.describe('Customer story detail @smoke', () => {
       '/customers/series-entertainment'
     )
   })
-
-  test('renders a Creative Campus story with its education blocks', async ({
-    page
-  }) => {
-    await page.goto('/customers/xindi-zhang')
-
-    await expect(
-      page.getByRole('heading', {
-        level: 1,
-        name: /The tool that expands my art/i
-      })
-    ).toBeVisible()
-
-    const nav = page.getByRole('navigation', { name: 'Category filter' })
-    await expect(nav.getByRole('button', { name: 'INTRO' })).toBeVisible()
-    await expect(nav.getByRole('button', { name: 'AT A GLANCE' })).toBeVisible()
-
-    // At a glance block (AtAGlance component) with its spec rows.
-    await expect(
-      page.getByRole('heading', { name: 'At a glance' })
-    ).toBeVisible()
-    await expect(page.getByText('Program', { exact: true })).toBeVisible()
-
-    // Workflow download button (Download component).
-    await expect(
-      page.getByRole('link', {
-        name: /Download Xindi's style transfer workflow/i
-      })
-    ).toBeVisible()
-
-    // Shared education call to action (EducationCta component).
-    await expect(
-      page.getByRole('link', { name: /Explore the Education Program/i })
-    ).toBeVisible()
-  })
 })

apps/website/src/components/customers/CustomerArticle.astro

@@ -4,24 +4,16 @@ import { render } from 'astro:content'
 import type { Locale } from '../../i18n/translations'
 import type { CustomerStoryEntry } from '../../utils/customers'
 import ArticleNav from './ArticleNav.vue'
-import AtAGlance from './content/AtAGlance.astro'
-import AuthorBio from './content/AuthorBio.astro'
 import BulletList from './content/BulletList.astro'
 import Contributors from './content/Contributors.astro'
-import Download from './content/Download.astro'
-import EducationCta from './content/EducationCta.astro'
-import Embed from './content/Embed.astro'
 import Figure from './content/Figure.astro'
 import Heading from './content/Heading.astro'
-import Heading4 from './content/Heading4.astro'
-import Link from './content/Link.astro'
 import ListItem from './content/ListItem.astro'
 import Paragraph from './content/Paragraph.astro'
 import Quote from './content/Quote.astro'
 import ReadMore from './content/ReadMore.vue'
 import Section from './content/Section.astro'
 import Steps from './content/Steps.astro'
-import Video from './content/Video.astro'
 
 interface Props {
   entry: CustomerStoryEntry
@@ -42,26 +34,18 @@ const categories = entry.data.sections.map((section) => ({
 // components (Section, Figure, ...) are used directly inside the MDX body.
 const contentComponents = {
   p: Paragraph,
-  a: Link,
   h3: Heading,
-  h4: Heading4,
   ul: BulletList,
   li: ListItem,
   Section,
   Figure,
   Quote,
   Contributors,
-  Steps,
-  AtAGlance,
-  AuthorBio,
-  Download,
-  EducationCta,
-  Embed,
-  Video
+  Steps
 }
 ---
 
-<section class="max-w-9xl mx-auto px-4 pt-8 pb-24 lg:px-20 lg:pt-24 lg:pb-40">
+<section class="px-4 pt-8 pb-24 lg:px-20 lg:pt-24 lg:pb-40">
   <div class="lg:flex lg:gap-16">
     <aside class="hidden scrollbar-none lg:block lg:w-48 lg:shrink-0">
       <div class="sticky top-32">

apps/website/src/components/customers/content/AtAGlance.astro

@@ -1,29 +0,0 @@
----
-interface Row {
-  label: string
-  value: string
-}
-
-interface Props {
-  rows: Row[]
-}
-
-const { rows } = Astro.props
----
-
-<div
-  class="my-8 overflow-hidden rounded-2xl border border-white/10 bg-site-bg-soft"
->
-  <dl class="divide-y divide-white/10">
-    {
-      rows.map((row) => (
-        <div class="flex flex-col gap-1 p-5 sm:flex-row sm:gap-6">
-          <dt class="text-primary-comfy-yellow shrink-0 text-xs font-bold tracking-widest uppercase sm:w-44">
-            {row.label}
-          </dt>
-          <dd class="text-sm/relaxed text-primary-comfy-canvas">{row.value}</dd>
-        </div>
-      ))
-    }
-  </dl>
-</div>

apps/website/src/components/customers/content/AuthorBio.astro

@@ -1,60 +0,0 @@
----
-interface Author {
-  name?: string
-  role?: string
-  photo?: string
-  bio?: string
-}
-
-interface Props {
-  label?: string
-  people: Author[]
-}
-
-const { label, people } = Astro.props
-const hasBioSlot = Astro.slots.has('default')
----
-
-<div class="mt-12 border-t border-white/10 pt-8">
-  {
-    label && (
-      <span class="text-primary-comfy-yellow text-xs font-bold tracking-widest uppercase">
-        {label}
-      </span>
-    )
-  }
-  <div class="mt-4 space-y-8">
-    {
-      people.map((person) => (
-        <div class="flex flex-col gap-4 sm:flex-row sm:items-start sm:gap-6">
-          {person.photo && (
-            <img
-              src={person.photo}
-              alt={person.name ?? ''}
-              class="size-20 shrink-0 rounded-full object-cover"
-            />
-          )}
-          <div>
-            {person.name && (
-              <p class="text-sm font-semibold text-primary-comfy-canvas">
-                {person.name}
-                {person.role && (
-                  <span class="text-primary-warm-gray"> · {person.role}</span>
-                )}
-              </p>
-            )}
-            {person.bio ? (
-              <p class="mt-2 text-sm/relaxed text-primary-comfy-canvas italic">
-                {person.bio}
-              </p>
-            ) : hasBioSlot ? (
-              <p class="mt-2 text-sm/relaxed text-primary-comfy-canvas italic">
-                <slot />
-              </p>
-            ) : null}
-          </div>
-        </div>
-      ))
-    }
-  </div>
-</div>

apps/website/src/components/customers/content/Contributors.astro

@@ -14,7 +14,7 @@ interface Props {
 const { label, people } = Astro.props
 ---
 
-<div class="mt-8 rounded-2xl bg-site-bg-soft p-6">
+<div class="mt-8 rounded-2xl bg-(--site-bg-soft) p-6">
   <span
     class="text-primary-comfy-yellow text-xs font-bold tracking-widest uppercase"
   >

apps/website/src/components/customers/content/Download.astro

@@ -1,19 +0,0 @@
----
-interface Props {
-  href: string
-  label: string
-  newTab?: boolean
-}
-
-const { href, label, newTab = false } = Astro.props
----
-
-<a
-  href={href}
-  download={newTab ? undefined : true}
-  target={newTab ? '_blank' : undefined}
-  rel={newTab ? 'noopener noreferrer' : undefined}
-  class="text-primary-comfy-yellow my-4 inline-block text-sm font-semibold underline underline-offset-2 transition-opacity hover:opacity-80"
->
-  {label}
-</a>

apps/website/src/components/customers/content/EducationCta.astro

@@ -1,15 +0,0 @@
----
-import Link from './Link.astro'
----
-
-<div
-  class="border-primary-comfy-yellow mt-12 rounded-2xl border-l-4 bg-site-bg-soft p-8"
->
-  <p class="text-base/relaxed text-primary-comfy-canvas">
-    <strong class="font-semibold">Teaching with ComfyUI?</strong> The Comfy Education
-    Program is live: educational pricing, classroom cloud accounts on one invoice,
-    <Link href="https://comfy.org/education">Explore the Education Program</Link> or
-    <Link href="https://tally.so/r/Xx97lL">apply to be a part of the Creative
-    Campus program</Link> if you're interested in exploring a deeper partnership with Comfy.
-  </p>
-</div>

apps/website/src/components/customers/content/Embed.astro

@@ -1,22 +0,0 @@
----
-interface Props {
-  src: string
-  title: string
-}
-
-const { src, title } = Astro.props
----
-
-<div
-  class="my-8 aspect-video overflow-hidden rounded-2xl border border-white/10 bg-black"
->
-  <iframe
-    src={src}
-    title={title}
-    class="size-full"
-    loading="lazy"
-    allow="autoplay; fullscreen; picture-in-picture; clipboard-write"
-    referrerpolicy="strict-origin-when-cross-origin"
-    sandbox="allow-scripts allow-same-origin allow-presentation allow-popups"
-  ></iframe>
-</div>

apps/website/src/components/customers/content/Figure.astro

@@ -6,15 +6,14 @@ interface Props {
 }
 
 const { src, alt, caption } = Astro.props
-const hasCaptionSlot = Astro.slots.has('default')
 ---
 
 <figure class="my-8">
   <img src={src} alt={alt} class="w-full rounded-2xl object-cover" />
   {
-    (hasCaptionSlot || caption) && (
+    caption && (
       <figcaption class="mt-3 text-xs text-primary-comfy-canvas">
-        {hasCaptionSlot ? <slot /> : caption}
+        {caption}
       </figcaption>
     )
   }

apps/website/src/components/customers/content/Heading4.astro

@@ -1,6 +0,0 @@
----
----
-
-<h4 class="mt-6 mb-2 text-base font-semibold text-primary-comfy-canvas">
-  <slot />
-</h4>

apps/website/src/components/customers/content/Link.astro

@@ -1,15 +0,0 @@
----
-interface Props {
-  href: string
-}
-
-const { href } = Astro.props
-const isExternal = /^https?:\/\//.test(href)
----
-
-<a
-  href={href}
-  target={isExternal ? '_blank' : undefined}
-  rel={isExternal ? 'noopener noreferrer' : undefined}
-  class="text-primary-comfy-yellow underline underline-offset-2 transition-opacity hover:opacity-80"
-><slot /></a>

apps/website/src/components/customers/content/Quote.astro

@@ -1,20 +1,16 @@
 ---
 interface Props {
-  name?: string
+  name: string
 }
 
 const { name } = Astro.props
 ---
 
 <blockquote
-  class="border-primary-comfy-yellow my-8 rounded-2xl border-l-4 bg-site-bg-soft p-8"
+  class="border-primary-comfy-yellow my-8 rounded-2xl border-l-4 bg-(--site-bg-soft) p-8"
 >
   <p class="text-lg/relaxed font-light text-primary-comfy-canvas italic">
     "<slot />"
   </p>
-  {
-    name && (
-      <p class="text-primary-comfy-yellow mt-4 text-sm font-semibold">{name}</p>
-    )
-  }
+  <p class="text-primary-comfy-yellow mt-4 text-sm font-semibold">{name}</p>
 </blockquote>

apps/website/src/components/customers/content/Video.astro

@@ -1,22 +0,0 @@
----
-import VideoPlayer from '../../common/VideoPlayer.vue'
-
-interface Props {
-  src: string
-  poster?: string
-  caption?: string
-}
-
-const { src, poster, caption } = Astro.props
----
-
-<figure class="my-8">
-  <VideoPlayer src={src} poster={poster} client:visible />
-  {
-    caption && (
-      <figcaption class="mt-3 text-xs text-primary-comfy-canvas">
-        {caption}
-      </figcaption>
-    )
-  }
-</figure>

apps/website/src/content/customers.content.test.ts

@@ -63,12 +63,8 @@ function bodySectionIds(body: string): string[] {
 
 const stories = loadStories()
 
-it('finds customer stories in every locale', () => {
-  for (const locale of locales) {
-    const prefix = `${locale}/`
-    const inLocale = stories.filter((story) => story.file.startsWith(prefix))
-    expect(inLocale.length).toBeGreaterThan(0)
-  }
+it('finds all ten customer stories', () => {
+  expect(stories).toHaveLength(10)
 })
 
 describe.for(stories)('$file', ({ frontmatter, body }) => {

apps/website/src/content/customers/en/golan-levin.mdx

@@ -1,148 +0,0 @@
----
-title: "Seeing the world in new ways: how Prof. Golan Levin teaches with ComfyUI at Carnegie Mellon University"
-category: "CREATIVE CAMPUS SHOWCASE"
-description: "\"For me, ComfyUI is not just about generative AI. It's an image-processing workstation for completely new kinds of work.\""
-cover: "https://media.comfy.org/website/customers/golan-levin/cover.png"
-order: 7
-sections:
-  - id: topic-1
-    label: "INTRO"
-  - id: topic-2
-    label: "WHERE COMFYUI FITS"
-  - id: topic-3
-    label: "IMAGE SYNTHESIS"
-  - id: topic-4
-    label: "IMAGE ANALYSIS"
-  - id: topic-5
-    label: "THE CV LAB"
-  - id: topic-6
-    label: "AT A GLANCE"
-  - id: topic-7
-    label: "STUDENT WORK"
----
-
-<Section id="topic-1">
-
-<Figure src="https://media.comfy.org/website/customers/golan-levin/augmented-hand.jpg" alt="Golan Levin, Augmented Hand Series" caption="Golan Levin, Augmented Hand Series (2014), with Chris Sugrue and Kyle McDonald. Photo: Gerlinde de Geus, courtesy Cinekid." />
-
-For many people, AI in the arts means image generation. But Levin has spent much of the past two decades teaching artists how computers can interpret, analyze, and measure the visual world. His own artworks have long explored machine perception through real-time computer vision systems, and since 2024 he has increasingly used ComfyUI to teach these principles.
-
-For Levin, ComfyUI is less an image generator than an image-processing workbench. Students use it to assemble custom workflows for segmentation, tracking, depth estimation, and other forms of computational perception. The result is an environment where artists can experiment directly with research-grade machine learning tools and combine them into systems of their own design.
-
-</Section>
-
-<Section id="topic-2">
-
-### Where does ComfyUI fit in what you're trying to do?
-
-I'm training creative technologists and technologically literate artists. The typical student in my Creative Coding class is a true hybrid: an art or design undergraduate who is also studying computer science, human-computer interaction, or information science. They have strong visual abilities, strong cultural literacy, and strong algorithmic thinking skills, but my course may be the first time they've had the opportunity to bring those together.
-
-To me, that means giving students tools they can understand, modify, and remix to make systems of their own design, rather than treating creative software as a fixed given. That's why I'm such a proponent of community-driven, open-source software development toolkits for the arts.
-
-<Quote>ComfyUI is the first AI tool I've found with both a low floor and a high ceiling. It's incredibly powerful and flexible, in terms of allowing artists to design their own AI workflows with the latest cutting-edge algorithms. But it also leapfrogs the headaches of coping with quirky GitHub repos and obsolete Colab notebooks.</Quote>
-
-### What were students stuck on before?
-
-Students often found themselves caught between two worlds. On one side were commercial AI tools that produced impressive results but offered limited opportunities for customization. On the other side were research projects published by universities and laboratories, where the software was often difficult to install, poorly documented, or already out of date.
-
-ComfyUI bridges that gap. It gives students access to state-of-the-art algorithms through an environment they can understand, modify, and extend. Instead of adapting their ideas to fit a tool's built-in workflow, they can build workflows that reflect their own interests and questions.
-
-<Quote>My students are explorers. They're artists who can write code and want to build systems that haven't existed before.</Quote>
-
-</Section>
-
-<Section id="topic-3">
-
-### The first exercise: a p5.js sketch driving image synthesis, inside ComfyUI
-
-In one of Levin's introductory exercises — students' first exposure to the ComfyUI environment — they write a simple p5.js sketch directly inside ComfyUI, then use the shapes they draw, plus a text prompt, to guide a Stable Diffusion image synthesis. They document the pairs of images it produces: their JavaScript canvas drawing on the left, and the AI synthesis on the right. Having already spent a few weeks fighting to get nuance out of p5.js, they're tickled to get these results from simple shapes, and they learn a lot about how Stable Diffusion works.
-
-<Figure src="https://media.comfy.org/website/customers/golan-levin/p5-landscape.png" alt="p5.js ellipses guiding a Stable Diffusion synthesis" caption={`Some wide ellipses drawn in p5.js (left) guiding a Stable Diffusion synthesis with the prompt "rolling hills, foggy day" (right).`} />
-
-It runs on a node-based canvas that art students pick up quickly, because it works like tools they already know.
-
-<Figure src="https://media.comfy.org/website/customers/golan-levin/p5-workflow.png" alt="Template ComfyUI workflow using the ComfyUI-p5js-node" caption="The template ComfyUI workflow students receive. It uses the custom ComfyUI-p5js-node by Ben Fox. From Levin's 60-212 course repo." />
-
-*Try it yourself: [json file](https://media.comfy.org/website/customers/golan-levin/p5-in-comfy.json) (Comfy Local only)*
-
-</Section>
-
-<Section id="topic-4">
-
-### Many artists start off by using ComfyUI for generative AI. You use it differently.
-
-Maybe so. I'm interested in AI as a framework for expanded perception, so a lot of how I've used machine learning and computer vision over the past 25 years has been for image analysis, rather than image synthesis. Essentially, I use computer vision to understand video and images, and then use the information I extract to create new kinds of interactive experiences. In the classroom, I use ComfyUI to help teach students how to "see like a machine." So I have students use ComfyUI as a framework for analyzing images, not just generating them. For example, I ask them to take an input image and then use AI to compute new ones from it, such as a semantic segmentation ("which pixels belong to the elephant?") and a monocular depth estimate ("how far away is each pixel?"). Then the students build an interactive piece that interprets the original image, but using five channels of information instead of three: the usual red, green, and blue, plus depth, plus segmentation. In my demo project, the segmentation colors the elephant pink, and the background pixels change size based on how far away the AI thinks they are.
-
-<Figure src="https://media.comfy.org/website/customers/golan-levin/depth-segmentation.png" alt="Semantic segmentation and monocular depth analysis in ComfyUI" caption={`An input image analyzed inside ComfyUI: semantic segmentation and monocular depth, feeding a five-channel "Custom Pixel" exercise. From Levin's 60-212 course repo.`} />
-
-*Try it yourself: [demo project](https://editor.p5js.org/golan/sketches/-_cFmLtoP) · [lesson plan & workflow](https://github.com/golanlevin/60-212/tree/main/lectures/comfy/image_analysis#3-segment-the-image-with-ai)*
-
-*Workflow files: download the [.json](https://media.comfy.org/website/customers/golan-levin/image-analysis-workflow.json), or the [.png with the workflow embedded in its metadata](https://media.comfy.org/website/customers/golan-levin/image-analysis-workflow.png) (drag it into ComfyUI to load the graph).*
-
-<Quote>I want students to understand that AI is not only a tool for generating images. It's also a tool for perception, measurement, and analysis.</Quote>
-
-The computer vision tools built for this are usually aimed at developers and enterprises. They assume an engineering workflow. I wanted my art students to get to segmentation, depth, and tracking inside an environment they already think in, without standing up a production pipeline first.
-
-### What changed once ComfyUI was in the workflow?
-
-Two things. First, it runs on a node-based canvas that many art students already understand from environments like TouchDesigner, Max/MSP, and Grasshopper — except it runs in a browser and it's for AI. As a result, students can focus on the ideas behind machine learning workflows instead of first learning an entirely new interaction paradigm. Second, it collapses the distance between a research lab and a classroom.
-
-<Quote>There's a fast pipeline from the lab to your classroom. It's become commonplace for enthusiasts to convert AI research code into Comfy nodes, often within days of their release.</Quote>
-
-One of the most remarkable things about the ComfyUI ecosystem is how quickly new research becomes accessible. A computer-vision paper might appear at CVPR or ICCV, and within days someone in the community has wrapped it as a reusable ComfyUI node. For educators, that dramatically shortens the distance between a research laboratory and a classroom. Instead of spending weeks reconstructing an experimental software environment, students can begin exploring the underlying ideas almost immediately.
-
-The cloud matters for accessibility and equity, too. Most of my students don't have big GPU workstations, and I don't want their access to advanced tools to depend on the caliber of their personal hardware. Cloud platforms make it possible for everyone in a class to work in the same environment, with the same models, regardless of what laptop they happen to own.
-
-</Section>
-
-<Section id="topic-5">
-
-### In your advanced Experimental Capture studio, you've turned ComfyUI into a computer-vision lab.
-
-The goal of this course is to use technologies to help us see the world in new ways: the very fast, the very slow, the very small, the very large, and in spectra beyond human perception, like IR and UV. It's about cultivating the students' curiosity. But the limitation in this studio is hardware. We have one camera that can shoot 100,000 frames per second, one high-resolution thermal camera, and access to one electron microscope — but we've got 20 students. We can't always queue them all up for one exotic camera; it's a bottleneck.
-
-<Quote>I need to give them tools they can use to see the world in new ways, that they can all run on their own hardware.</Quote>
-
-ComfyUI allows students to use their own phones to ask questions they couldn't before. So they duct-tape their phone camera to a window, record the world going by, and then track things with the LocateAnything and SAM3 ComfyUI nodes, producing data files that distill what the camera saw. ComfyUI becomes a laboratory for computational observation, allowing students to ask questions of images and videos that would otherwise be difficult to formulate.
-
-### You also wrap niche research libraries into ComfyUI nodes yourself.
-
-One of the remarkable things about the ComfyUI ecosystem is the community that forms around it. There's a hero of mine on GitHub, Kijai, who keeps taking libraries from computer vision labs and turning them into ComfyUI nodes. He's made hundreds, probably doing more than anyone to turn lab-grade models into tools anyone can use. My students and I are starting to do this too. Niche is the right word. Right now I have my eye on a zoology lab that released a good library for tracking insect legs. The people who made it probably don't even know what ComfyUI is. But I want that algorithm for my students, and there's gotta be someone else out there who would love it too.
-
-### What's the bigger pattern you see in your students?
-
-My students are explorers. They see a new tool and immediately start wondering what else it could be connected to. They explore: I should be able to combine this thing with that other thing. That's the whole reason to give them a system they can build on, instead of a tool that tells them what they're allowed to do.
-
-<Quote>We're educating students who want to invent new forms and experiences, not just reproduce existing ones.</Quote>
-
-</Section>
-
-<Section id="topic-6" title="At a glance">
-
-<AtAGlance rows={[
-  { label: "Courses", value: "Intermediate Studio: Creative Coding (60-212); Experimental Capture (co-taught with Nica Ross)" },
-  { label: "Level", value: "Undergraduate (sophomore studio + advanced studio, ~20 students)" },
-  { label: "Setup", value: "Cloud-hosted ComfyUI; runs on students' own laptops" },
-  { label: "Core techniques", value: "p5.js-driven synthesis; semantic segmentation; monocular depth; LocateAnything + SAM3 tracking" },
-  { label: "Distinctive angle", value: "ComfyUI as computer-vision lab, not just a generator" }
-]} />
-
-</Section>
-
-<Section id="topic-7" title="Student work">
-
-<Figure src="https://media.comfy.org/website/customers/golan-levin/student-tippi.png" alt="Student work by Tippi Li" caption={`"nuclear explosion" by Tippi Li`} />
-
-<Figure src="https://media.comfy.org/website/customers/golan-levin/student-xiao.png" alt="Student work by Xiao Yuan" caption={`"Chinese painting, plants, ink, transparent" by Xiao Yuan`} />
-
-<Figure src="https://media.comfy.org/website/customers/golan-levin/student-aarnav.png" alt="Student work by Aarnav Patel" caption={`"NASA space image of a new cosmos detected" by Aarnav Patel`} />
-
-<Figure src="https://media.comfy.org/website/customers/golan-levin/student-jeffrey.png" alt="Student work by Jeffrey Wang" caption={`"Dream Scene Painting" by Jeffrey Wang`} />
-
-<Figure src="https://media.comfy.org/website/customers/golan-levin/student-kai.gif" alt="Student work by Kai Okorodudu" caption={`"Electric hand" by Kai Okorodudu`} />
-
-</Section>
-
-<AuthorBio people={[{ name: "Golan Levin", photo: "https://media.comfy.org/website/customers/golan-levin/author-golan.png" }]}>Golan Levin is a Professor of Computational Art at Carnegie Mellon University and co-author, with Tega Brain, of "Code as Creative Medium." This fall he is teaching two CMU courses with ComfyUI: "Intermediate Studio: Creative Coding" (60-212), built around p5.js, and "Experimental Capture," a studio in computational and expanded photography he co-teaches with Nica Ross. Levin is also widely known for interactive art installations driven by real-time machine vision, such as his [Augmented Hand Series](https://flong.com/archive/projects/augmented-hand-series/index.html) (2014), created with Kyle McDonald and Christine Sugrue.</AuthorBio>
-
-<EducationCta />

apps/website/src/content/customers/en/ina-conradi.mdx

@@ -1,149 +0,0 @@
----
-title: "From Node Graph to Building Façade: how Ina Conradi's NTU students compose architectural-scale public art with ComfyUI"
-category: "CREATIVE CAMPUS SHOWCASE"
-description: "At NTU in Singapore, Ina Conradi's students compose 90-second films for building-sized LED walls that prompt boxes cannot render but ComfyUI can, work that travels from campus to Hangzhou's West Lake Media Façade and a million viewers a day."
-cover: "https://media.comfy.org/website/customers/ina-conradi/cover.png"
-order: 6
-sections:
-  - id: topic-1
-    label: "INTRO"
-  - id: topic-2
-    label: "THE CANVAS"
-  - id: topic-3
-    label: "WHY COMFYUI"
-  - id: topic-4
-    label: "THE 2026 BRIEF"
-  - id: topic-5
-    label: "STUDENT WORK"
-  - id: topic-6
-    label: "PUBLIC SCREENS"
-  - id: topic-7
-    label: "AT A GLANCE"
----
-
-<Section id="topic-1">
-
-<Figure src="https://media.comfy.org/website/customers/ina-conradi/fig1-quantum-logos.jpg" alt="Quantum Logos (Vision Serpent) on the Media Art Nexus LED screen" caption="Quantum Logos (Vision Serpent), Mark Chavez and Ina Conradi. Experimental animation, Media Art Nexus LED screen (15 m × 2 m), Singapore. Photo: Quek Jia Liang." />
-
-### Building an AI art pipeline from studio to screen
-
-Ina Conradi has written and taught NTU's two AI courses since 2022: DM2012, Explorations in AI-Generated Art (undergraduate), and AP7055, Art in the Age of the Creative Machine (postgraduate). Each runs about 30 students a semester. Working alongside her on the production pipeline is Mark Chavez, an animation veteran (DreamWorks, Rhythm & Hues) and early ComfyUI adopter. Together they co-curate the platform those courses build for: a 15-metre by 2-metre LED wall installed at NTU's North Spine in 2016 as Media Art Nexus, now run by NTU Museum as NTU Index and still taking new work each semester.
-
-Work from the wall has travelled to giant public screens in Singapore (Ten Square), Hangzhou, and Chongqing, and into collaborations with Bauhaus University, the University of the Arts Berlin, and the Elbphilharmonie in Hamburg.
-
-<Figure src="https://media.comfy.org/website/customers/ina-conradi/fig2-nature-sanctuary.jpg" alt="Nature Sanctuary 3000 on the West Lake Media Façade" caption="Nature Sanctuary 3000, Sowmya Sreeshna. Experimental animation, West Lake Media Façade (170 m × 18 m), Hangzhou, China. Photo: Limpid Art." />
-
-</Section>
-
-<Section id="topic-2">
-
-### Ina, your students don't make films for laptops. Why screens the size of buildings?
-
-Because the format teaches. A 90-second film at 6K across, in an 8:1 panorama, cannot be a lucky prompt. It has to be composed. And the screens are real: the strongest student work plays on NTU Index, our 15-metre by 2-metre wall on campus, and travels to urban façades in China and Europe through the City Digital Skin Art Festival (CDSA). When a student knows a million people a day might walk past their film in Hangzhou, the conversation about craft changes.
-
-### Mark, describe the canvas.
-
-Basically, we do compositions for really large media LED screens in Singapore and China. We have a screen that's eight by one in Singapore. It's 5,888 by 768 pixels.Students create images in the class, usually about 6K resolution across, a long landscape panorama. The output is 90-second short films. Two minutes, 90 seconds. I'm not going to change. I love that format because it's manageable within the class.
-
-</Section>
-
-<Section id="topic-3">
-
-### That format breaks most AI tools. What happened?
-
-Runway is one of the tools we use, on an educational plan that has worked well for the school. The constraint we hit is format: Runway works in 16:9, and our 6K panoramas fall outside that. Last semester Midjourney gave us trouble at our resolution, and the upscale was difficult. So we're expanding the palette and bringing in ComfyUI alongside what we already run.
-
-<Quote>ComfyUI gave the cleanest results. Upscaling to 8K at a 1-by-8 panorama after composition is genuinely hard, and ComfyUI is the only pipeline that lets students compose image, motion, and upscale models together.</Quote>
-
-### What about the budget side?
-
-Budget will keep being an issue. The school supports us well, but new tools arrive every semester and students want to try them and build their own pipelines. Monthly per-seat licenses don't fit how a semester runs. Running ComfyUI locally is hard for students: most laptops don't have a GPU with enough VRAM, and getting it working takes real trial and error. Many would rather work from home, but the hardware blocks them, so they come into the lab. Others used Comfy Cloud. It charges a subscription, but it still cost significantly less than the prepaid tools, and the results were better. Either way they're chasing the same thing: a pipeline they can keep working on, wherever they are.
-
-### Ina, you insist these courses are not about tools. What are they about?
-
-My class isn’t about teaching a single tool. It is the responsive system students interact with across platforms, directing, critiquing, and shaping outputs through ongoing dialogue. ComfyUI fits this: a node graph is an argument you can read, question, and rebuild. A prompt box is not. Singaporean students become technically fluent very fast. What they need from arts education is the language to question what they're making, not just the skill to make it.
-
-</Section>
-
-<Section id="topic-4">
-
-### Ina, the 2026 brief sends students to the ocean. What's the assignment?
-
-The project is The Liquid Commons: Bringing Ocean Science into Global Media Architecture, developed in dialogue with OceanX, the organization behind the OceanXplorer research vessel, and the CDSA 2026 festival theme. The brief is strict: do not illustrate the science, translate it. The 2026 cohort is the first to build these films in ComfyUI with Topaz upscaling, working towards two real deadlines at once. Their pieces are in consideration for the OceanX Summit in Singapore this October, and jury-selected works will screen during the City Digital Skin Art Festival on Hangzhou's West Lake Media Façade: 170 metres by 18 metres, around a million viewers a day.
-
-<Quote>The delivery spec tells you why the tooling matters: final exports at 5,888 × 768 px, 8K where required. That's the brief no prompt box can fill.</Quote>
-
-</Section>
-
-<Section id="topic-5">
-
-### Mark, what does the student work look like?
-
-About eight students have built their films through Comfy so far, and they're all pretty cool. They're surprising and insightful, because they're not limited by game-engine graphics. One student was the standout: he tried every model in Comfy and pushed the furthest.
-
-Three projects from the 2026 cohort show the range.
-
-**The Tao of Water** (Wang Zilin, AP7055) reads the ocean through the Tao Te Ching, a three-part arc from water to marine plant to void and back to origin. The pipeline moves from Pinterest research boards through Midjourney into ComfyUI, where Nano Banana extends single frames into seamless panoramas and Kling 3.0 animates first-frame-to-last-frame motion at full 5,888-pixel width, before a Premiere edit.
-
-<Figure src="https://media.comfy.org/website/customers/ina-conradi/fig3-tao-of-water.jpg" alt="The Tao of Water on the NTU Index screen" caption="The Tao of Water, Wang Zilin. Experimental animation, NTU Index screen (15 m × 2 m), Singapore. Photo: Quek Jia Liang." />
-
-**microscophony** (Jiin Ko, AP7055) fuses *microscopic* and *micropolyphony*, Ligeti's term for dense webs of voices that blur into a single cloud of sound. The source is based on OceanX microscope footage of deep-sea microbes, translated into the visual logic of graphic notation (Ligeti, Xenakis, Cardew) so the panorama becomes a listening score. Images ran through Midjourney and Nano Banana, video through ComfyUI with Vidu Q2, sound design in Ableton Live, with distinct sonic textures mapped to distinct visual forms.
-
-<Figure src="https://media.comfy.org/website/customers/ina-conradi/fig4-microscophony.jpg" alt="microscophony on the NTU Index screen" caption="microscophony, Jiin Ko. Experimental animation, NTU Index screen (15 m × 2 m), Singapore. Photo: Quek Jia Liang." />
-
-**GO! PLASTIC** (Jianwei Hoe, DM2012) is an ocean-plastics piece whose production log reads like studio paperwork, not prompt history. It opens with a one-line art direction (every project states its idea in a single line, with embedded irony, before a frame is generated), then walks through model selection, a platform-versus-local cost comparison (cost per clip and per scene on an RTX 5090 against a cloud B200, render times included), and a shot-by-shot sheet pairing every source image with its full prompt and settings.
-
-<Figure src="https://media.comfy.org/website/customers/ina-conradi/fig5-go-plastic.jpg" alt="GO! PLASTIC on the NTU Index screen" caption="GO! PLASTIC, Hoe Jianwei. Experimental animation, NTU Index screen (15 m × 2 m), Singapore. Photo: Quek Jia Liang." />
-
-</Section>
-
-<Section id="topic-6">
-
-### Ina, where does the work go after the classroom?
-
-Onto public screens, and into juried international competition. The City Digital Skin Art Festival was established in 2023, initiated by the China Academy of Art's School of Sculpture and Public Art and co-curated with Public Art Lab Berlin, MEET Digital Culture Center Milan, and NTU ADM, with a network of more than 29 art academies across China and Europe.
-
-<Figure src="https://media.comfy.org/website/customers/ina-conradi/fig6-cdsa-awards.jpg" alt="CDSA Festival award winners on the West Lake Media Façade" caption="CDSA Festival award winners, curators, and organizers. West Lake Media Façade (170 m × 18 m), Hangzhou, China. Photo: Limpid Art. Asia's largest high-definition outdoor screen" />
-
-The 2024 edition ran across 11 LED screens in 9 cities in 5 countries and reached over 100 million views. The 2025–2026 edition, themed Memory Coexistence, drew over 200 international submissions, with the top 40 selected by a 16-member jury. I curate the Singapore programme across NTU Index and the Ten Square landmark façade. A student composing at 6K in our classroom is composing for that circuit.
-
-<Figure src="https://media.comfy.org/website/customers/ina-conradi/fig7-crispr.jpg" alt="Crispr on the Ten Square Landmark Façade" caption="Crispr, Lee Chaewon. Experimental animation, Ten Square Landmark Façade (21.2 m × 14.4 m), Singapore. Photo: Quek Jia Liang." />
-
-NTU ADM students have already won at this level. At CDSA 2025, the majority of the top awards went to students from these two courses: Gold (Sun Yutong, *Echoes of Her*), Silver (Tan Yu Yan Cheerie, *Eternal Flux*), Bronze (Shah Pranjal Kirti, *Mumbai Miniatures*), Business (Ong Sze Ching, *Nuwa*), and Creative (Leah Chakola, *Caravan of Memory*). The courses have also taken NTU to Ars Electronica in Linz as the only Singapore campus partner since 2023, first with *Butterfly's Dreams* (2023, "Who Owns the Truth?") and then in 2025 with *Beyond the Screen*, a joint exhibition with the China Academy of Art and Bauhaus-Universität Weimar.
-
-### Mark, you spent a decade at DreamWorks. Why does this tool fit art students?
-
-I come from visual effects. I was at DreamWorks about ten years, then Rhythm & Hues, then the game industry and big interactive installations. I'm not a programmer, so I love ComfyUI.
-
-<Quote>Everybody I know who does graphics now is using this, because it's so adaptable. Sometimes we use Comfy as just a back end. That's what everybody's doing.</Quote>
-
-We got this large 15-metre by 2-metre screen in an art installation at the university, and it let us explore media and different techniques. We found students weren't technical enough to handle TouchDesigner, so they just started making movies. Then I started playing with AI, and now everything's AI. What I'd love next is templates custom-made for these screens.
-
-Take *Echoes, Whispers and Memories*, the piece Ina and I made. We don't use Comfy to spit out finished illustrations. We build workflows that keep recomposing the image, breaking it apart and putting it back together so it evolves on screen, which is the whole point: entropy, memory, things falling apart and reforming. Then we push those outputs into real-time and projection systems for big rooms, places like Ars Electronica's Deep Space 8K and MEET in Milan.
-
-<Figure src="https://media.comfy.org/website/customers/ina-conradi/fig8-echoes.jpg" alt="Echoes, Whispers and Memories at Ars Electronica Deep Space 8K" caption="Echoes, Whispers and Memories, Mark Chavez and Ina Conradi. AI-generated immersive installation using ComfyUI, Deep Space 8K, Ars Electronica, Linz, Austria. Photo: Wolfgang Simlinger." />
-
-### The signal from the industry
-
-<Quote>I hear from my students looking for internships or jobs that the first question over there is, "Do you know Comfy?" Because they want to hire kids who know the pipeline.</Quote>
-
-</Section>
-
-<Section id="topic-7" title="At a glance">
-
-<AtAGlance rows={[
-  { label: "Institution", value: "Nanyang Technological University, School of Art, Design and Media (Singapore)" },
-  { label: "Courses", value: "DM2012: Explorations in AI-Generated Art (UG) and AP7055: Art in the Age of the Creative Machine (PG), written and taught by Ina Conradi since 2022; ~30 students/semester" },
-  { label: "The canvas", value: "6K-wide, 8:1 LED walls in Singapore and China; NTU Index wall on campus (15 m × 2 m, 5,888 × 768 px)" },
-  { label: "Core technique", value: "ComfyUI compositions with Topaz upscaling for ultra-wide panoramic output; production logs with per-clip cost and prompt sheets" },
-  { label: "Why Comfy won", value: "Hosted tools locked to 16:9; upscaling to 8K at a 1-by-8 panorama after composition needed a multi-model pipeline; per-seat monthly renewals didn't fit the semester" }
-]} />
-
-</Section>
-
-<AuthorBio label="About the authors" people={[
-  { name: "Ina Conradi", photo: "https://media.comfy.org/website/customers/ina-conradi/author-ina.jpg", bio: `Ina Conradi is an artist and curator based between Singapore and Los Angeles. She is founding faculty at NTU's School of Art, Design and Media (est. 2005), where she has written and taught the school's AI courses since 2022. Her film Moirai: Thread of Life won Best in Show at the SIGGRAPH Asia Computer Animation Festival 2023, a first for Singapore.` },
-  { name: "Mark Chavez", photo: "https://media.comfy.org/website/customers/ina-conradi/author-mark.jpg", bio: `Mark Chavez is an animator, director, and founding faculty at NTU's School of Art, Design and Media in Singapore. After a decade at DreamWorks Animation and visual effects work at the original Rhythm & Hues Studios, he established NTU's Digital Animation area (2005) and an animation research think-tank funded by Singapore's National Research Foundation and the Media Development Authority.` }
-]} />
-
-<EducationCta />

apps/website/src/content/customers/en/kathy-smith.mdx

@@ -1,138 +0,0 @@
----
-title: "Built for AI: Prof. Kathy Smith on USC's Expanded Animation program and ComfyUI"
-category: "CREATIVE CAMPUS SHOWCASE"
-description: "Inside the experimental USC MFA that put AI into animation pedagogy from day one, and the student pipelines it produced."
-cover: "https://media.comfy.org/website/customers/kathy-smith/cover.png"
-order: 8
-sections:
-  - id: topic-1
-    label: "THE PROGRAM"
-  - id: topic-2
-    label: "TEACHING WITH AI"
-  - id: topic-3
-    label: "WHY COMFYUI"
-  - id: topic-4
-    label: "STUDENT WORK"
-  - id: topic-5
-    label: "AT A GLANCE"
-  - id: topic-6
-    label: "WHAT'S NEXT"
----
-
-<Section id="topic-1">
-
-### You built the Expanded Animation program in 2022 specifically to put AI into the curriculum from day one. What did you see that other programs missed?
-
-We created Expanded Animation: Research and Practice specifically to focus on creative process and AI as part of how animators learn to make work. The thesis at the start was that AI was going to reshape animation as a medium, and the question was not whether to teach it but how to embed it in the curriculum so students learn it as part of their creative process rather than as a separate technical specialty.
-
-USC's School of Cinematic Arts already had decades of cinematic storytelling tradition. What we did with XA was put AI inside that tradition. The conceptual thinking, the storytelling, the cinematic history come first. AI is one of the many tools available to them, sitting alongside hand-drawing, paint, 3D, and live-action footage. Students do not learn AI in one course and animation in another. They learn both side by side.
-
-The students who arrive at the program are usually self-selected for it. They show up technically fluent, with their own GPU-equipped laptops. What we offer them is the storytelling, the cinematic history, and the conceptual frame. They bring the technical nimbleness.
-
-<Quote>They are way ahead of the curve. They are ahead of the faculty in the way they work, technically, but not so much artistically. That is what we are there to deliver.</Quote>
-
-<Figure src="https://media.comfy.org/website/customers/kathy-smith/usc-campus.png" alt="USC School of Cinematic Arts" caption="USC School of Cinematic Arts. Source: USC Today" />
-
-</Section>
-
-<Section id="topic-2">
-
-### How do you actually structure an AI assignment? Walk us through one.
-
-In my Animation, Dreams, and Consciousness class, I have the students document their dreams and then use the dream as the source. Some of them draw, some of them write. The dream becomes the prompt, and they generate the image and emotion of the dream. I love when you get six fingers and weird stuff happening in the algorithms. Our human perception in dreams is often doing the same thing. Therefore, AI is evolving and dreaming with us.
-
-That structure is deliberate. The students are not asking the model to produce work for them. They are using it as a layer of their process, alongside hand-drawing and painting and 3D rendering and live-action footage. The work that comes out is theirs because the creative decisions are theirs. The tool just gives them new ways to reach what they were trying to make.
-
-There is a fear factor around AI, and I understand it. There has been a lot of scraping of artists' work, and that conversation is real and is going to take time to resolve. But I have been working with AI conceptually since 1998, and the way I describe the data sets to my students is that they are a repository of all of our creation. It is like the collective unconscious of the human mind. Artists have always drawn from everything around them.
-
-<Quote>What really matters is what the artist does with it, *intentionality*.</Quote>
-
-</Section>
-
-<Section id="topic-3">
-
-### Why does ComfyUI specifically fit the way your students work?
-
-It is the node-based system. Those who have done Houdini feel very at home in Comfy. You can work with the prompts, but it is very visual. That is what they are used to. They are not asking a black box for an output. They are building a workflow.
-
-And it stays in its lane. The students are not using Comfy to make AI art. They are using Comfy as one node graph alongside Blender, hand-drawn frames, paint, and live-action footage. The reason it fits is that it does not try to be the whole pipeline. It is one stage of a creative practice that still has cinema at its core.
-
-What also matters is that Comfy is open and inspectable. The students can see what the model is doing at each step, fork a workflow, swap a sampler, drop in a custom node, and share what they built with the next cohort. That is closer to how an animation studio tradition has always behaved, with techniques passed along and improved rather than hidden behind a paywall.
-
-They also work across whatever hardware they have: Comfy Cloud at home and when they are mobile, the portable version on their personal laptops, and the research computer in my office for the high-end runs. Animation students do not sit in one cubicle for a thesis project. They work everywhere.
-
-</Section>
-
-<Section id="topic-4">
-
-### Tell us about the work coming out of the program.
-
-The pattern shows up across the cohort: the AI is in service of the cinematic story, not in place of it. Three students walked us through how Comfy actually sits inside their pipelines.
-
-#### Sijia Zheng — Ori & Kiddo
-
-<Figure src="https://media.comfy.org/website/customers/kathy-smith/ori-kiddo.png" alt="Sijia Zheng, Ori & Kiddo" />
-
-**What Comfy enabled:** an oil-paint, brush-stroke dream look that "other AI tools cannot possibly make," held consistent across shots with IP-Adapter style transfer and a custom LoRA.
-
-*Ori & Kiddo* follows two ghosts who, after the universe dies, search for old human memories, rediscover love, and reverse the universe back into being. Most of the film is hand-drawn 2D. Comfy enters in the dream sequences, where the ghost Kiddo dreams of past lives and the look had to be unlike anything else in the film. Sijia drew stylized reference images first, then used them as the style reference over video clips through an IP-Adapter workflow to produce long, oil-painted, brush-stroke sequences. The same control shows up in shots where Sijia appears on screen: real footage, masked in Comfy to change the haircut and swap the background. For a look that has to stay locked, Sijia trains a LoRA and runs it through Comfy.
-
-Sijia found Comfy in early 2025 while hunting for a style-transfer tool that Midjourney and DALL-E could not deliver, testing it on a stylized animated-film-look conversion.
-
-<Quote>It totally broke my mind. Most of the time, I think I'll just stand on other people's shoulders. The workflows are already pretty amazing, and I'll base on the workflows and add something that I want.</Quote>
-
-Since *Ori & Kiddo*, Sijia has taken the same Comfy-anchored workflow into professional commercial video work, on deadlines as tight as four days.
-
-#### Ion Yunyang Li — L1LY
-
-<Figure src="https://media.comfy.org/website/customers/kathy-smith/l1ly.gif" alt="Ion Yunyang Li, L1LY" />
-
-**What Comfy enabled:** a repeatable multi-step pipeline that drops the filmmaker into a photorealistic world, because "a sequence of a prompt is not the only thing you need."
-
-Ion taught himself ComfyUI in early 2025, from tutorials in the generative-AI community, and built his most distinctive Comfy work in a body-and-environment project: start from 3D-model stills, convert them to a pencil-sketch style so the model would not over-study the original 3D aesthetic, generate photorealistic frames from the sketches, build character T-poses, composite himself into the scene, and animate the stills with a video model.
-
-<Quote>A sequence of a prompt is not the only thing you need. You need many different settings, and it is very hard to redo those settings every time.</Quote>
-
-What he values as much as the pipeline is where it can run: the same Comfy setup moves across a workstation in his school cubicle, a remote session from his apartment laptop, and fully cloud-based instances, depending on where he is.
-
-#### Sihan Wu — Scary Coaster
-
-<Figure src="https://media.comfy.org/website/customers/kathy-smith/scary-coaster.gif" alt="Sihan Wu, Scary Coaster" />
-
-**What Comfy enabled:** roughly 100 hand-drawn keyframes carried through a single workflow so a two-to-three-minute film stays visually consistent, on his first-ever AI project.
-
-*Scary Coaster* (December 2024) was Sihan's first project ever made with AI. Coming from a digital-media and game-development undergrad, Sihan joined Professor Smith's Expanded Animation class and wanted something more controllable than the prompt-only tools on offer. The workflow he built: draw roughly 100 rough keyframes by hand, run them through Comfy to find a stylized Chinese-horror look, pick the favorite, then generate the in-betweens to produce the full sequence.
-
-<Quote>I want to have a more controllable flow. I don't want to just use prompts and generate random images. I just use one workflow to create the whole two or three minutes, and I can make everything look very consistent.</Quote>
-
-Sihan is honest that the on-ramp was steep: learning from the official ComfyUI GitHub workflows, combining them, and debugging Python environments along the way. His ask was specific: an official, beginner-to-advanced tutorial series. And his view on where AI should head next was equally specific: aim it at "the very time-consuming but not that creative process, like creating in-betweens," and leave the creative decisions to the artist.
-
-</Section>
-
-<Section id="topic-5" title="At a glance">
-
-<AtAGlance rows={[
-  { label: "Program", value: "Expanded Animation: Research + Practice (XA), USC School of Cinematic Arts" },
-  { label: "Founded", value: "2022, AI embedded in the MFA curriculum from day one" },
-  { label: "Setup", value: "Students' own GPU laptops + Comfy Cloud + lab research machine" },
-  { label: "Core techniques", value: "IP-Adapter style transfer, custom LoRAs, masked compositing, keyframe-to-in-between pipelines" },
-  { label: "Outcomes", value: "Amazing student works from Sihan, and Ion, Sijia" }
-]} />
-
-</Section>
-
-<Section id="topic-6">
-
-### What excites you about where this is going?
-
-I have a philosophy that everyone is an artist. They just forget that they are an artist. Creativity drives everything, and the tools we are getting now make it possible for more people to find that capacity in themselves. ComfyUI, because it is node-based and visual and open, gives non-programmers a way forward that is honest about how the model works. It does not pretend the AI is doing something magical. It shows the artist what is happening at each step.
-
-The two basic rights of human life are health and education. The work Comfy is doing on the education side is touching something integral. The students who came through XA are already extending the work in directions the program did not anticipate, and the next generation of educators and students will keep doing the same.
-
-<Quote>Everyone is an artist. They just forget that they are an artist.</Quote>
-
-</Section>
-
-<AuthorBio people={[{ name: "Kathy Smith", photo: "https://media.comfy.org/website/customers/kathy-smith/kathy-smith.jpg", bio: `Kathy Smith is Professor of Cinematic Arts at USC's School of Cinematic Arts and inaugural director (2022-2023) of Expanded Animation: Research + Practice (XA), the experimental MFA program she helped found in 2022 to integrate AI into animation pedagogy from the first day of the degree. To date she is the longest-serving chair of combined USC animation programs and has been exploring concepts of AI in her creative practice since 1998.` }]} />
-
-<EducationCta />

apps/website/src/content/customers/en/ual-cci.mdx

@@ -1,56 +0,0 @@
----
-title: "Comfy and UAL's Creative Computing Institute Announce Creative Campus Partnership"
-category: "CREATIVE CAMPUS PARTNERSHIP"
-description: "Comfy announces Creative Campus Partnership to support teaching and research across UAL CCI's masters, PhD, and industry programmes"
-cover: "https://media.comfy.org/website/customers/ual-cci/cover.png"
-order: 9
-sections:
-  - id: topic-1
-    label: "INTRO"
-  - id: topic-2
-    label: "WHAT CCI DOES"
-  - id: topic-3
-    label: "THE PARTNERSHIP"
-  - id: topic-4
-    label: "ABOUT CCI"
----
-
-<Section id="topic-1">
-
-Comfy Org, the team behind ComfyUI, the open-source node-based interface for generative AI, and the Creative Computing Institute (CCI) at University of the Arts London today announced a Creative Campus partnership, making CCI a founding partner of the [Comfy Education Initiative](https://comfy.org/education).
-
-</Section>
-
-<Section id="topic-2">
-
-CCI already runs ComfyUI at every level of the institute. On the Applied Machine Learning for Creatives masters course, students build image, video, audio, and text workflows, train their own models, and construct interactive pipelines. PhD researchers use Comfy for fine-tuning, custom datasets, and custom node development. The institute also uses ComfyUI in industry training, where its node-based interface gives non-technical collaborators a way into generative AI that code alone does not.
-
-<Quote name="Prof Mick Grierson, Research Leader, UAL Creative Computing Institute">ComfyUI has become part of how we teach, research, and work with industry. It is one of the few generative AI environments where the workflows our students build are portable, inspectable, and forkable, and that open-source foundation is exactly what a university should be teaching on.</Quote>
-
-</Section>
-
-<Section id="topic-3">
-
-Through the partnership, CCI educators and students gain access to classroom licenses with central billing & administration, educational discounts, early access to upcoming team features, a dedicated educator community with direct support from the Comfy team, and a voice in shaping the future of the education program.
-
-Creative Campus partnerships are the deepest tier of the program: a direct, ongoing collaboration in which an institution works hand in hand with the Comfy team to roll out ComfyUI across teaching, research, and industry training.
-
-<Quote name="The Comfy Team">CCI is the model we hope every creative campus follows: ComfyUI in the masters classroom, in PhD research, and in industry collaboration, all at once. As our first Creative Campus Partner, they are helping us design an education program that works the way universities actually work.</Quote>
-
-<Figure src="https://media.comfy.org/website/customers/ual-cci/cci-camberwell.jpg" alt="Creative Computing Institute campus at UAL" caption="Creative Computing Institute Campus. Photo: Ana Escobar, courtesy UAL." />
-
-The institute is leading a major £1.5 million publicly funded research programme developing copyright-compliant audiovisual foundation models for the UK's creative industries. Bringing together expertise in sound, image, and artificial intelligence, the project is building open tools and responsible AI national infrastructure designed to support UK creative production, research, and experimentation across the sector.
-
-The outputs of the research will explore wider dissemination and adoption through open, node-based tools such as ComfyUI to support experimentation, workflows, and collaboration around emerging multimodal AI systems.
-
-UAL CCI joins a founding cohort of educators and institutions featured at the launch of the Comfy Education Initiative, alongside researchers such as CCI co-founder Dr. Phoenix Perry, whose Antigravity Machine project Comfy supports as an industry partner.
-
-</Section>
-
-<Section id="topic-4" title="About the Creative Computing Institute at UAL">
-
-The Creative Computing Institute at University of the Arts London applies computing to creativity and social impact, operating at the intersection of computational technologies and creative practice, teaching undergraduate, postgraduate, and PhD students alongside research and industry collaboration.
-
-</Section>
-
-<EducationCta />

apps/website/src/content/customers/en/xindi-zhang.mdx

@@ -1,103 +0,0 @@
----
-title: "The tool that expands my art: Xindi Zhang's Oscar-shortlisted thesis, built in ComfyUI"
-category: "CREATIVE CAMPUS SHOWCASE"
-description: "How a USC Expanded Animation thesis became a Student Academy Award winner, an Oscar shortlist entry, and helped land a job at Amazon — with the artist's own illustrations as the style guide."
-cover: "https://media.comfy.org/website/customers/xindi-zhang/cover.webp"
-order: 5
-sections:
-  - id: topic-1
-    label: "INTRO"
-  - id: topic-2
-    label: "WHY COMFYUI"
-  - id: topic-3
-    label: "THE PIPELINE"
-  - id: topic-4
-    label: "AT A GLANCE"
-  - id: topic-5
-    label: "WHAT'S NEXT"
----
-
-<Section id="topic-1">
-
-<Embed src="https://player.vimeo.com/video/1131160045" title="The Song of Drifters by Xindi Zhang" />
-
-*From The Song of Drifters. Film images: Xindi Zhang.*
-
-### Tell us about The Song of Drifters. What is it about, and where did it start?
-
-The Song of Drifters is a documentary animation about people caught between leaving and returning, wanderers who drift through unfamiliar cities, holding onto memories of a homeland out of reach and searching for a sense of belonging. The title is a direct translation from an ancient Chinese poem about a mother's love for a child who leaves her hometown. My version takes the opposite point of view, from the child's perspective.
-
-I built the film in ComfyUI. When I started, I was not trying to show what AI could do. I was trying to prove something almost opposite.
-
-<Quote>It started as a challenge to the stereotype that AI-generated work is generic and cheap. I wanted to prove that AI could be an amplifier for personal vision, not a replacement for it.</Quote>
-
-</Section>
-
-<Section id="topic-2">
-
-### You came to this from illustration, not engineering. How did you end up in ComfyUI?
-
-I started as an illustrator. I earned my BFA in illustration at the Rhode Island School of Design, then worked as a game concept artist, where I picked up shaders, Unity, and Unreal. That technical side made me a fast learner with new tools. Later I went to USC's School of Cinematic Arts for an MFA in Expanded Animation, where I studied with Professor Kathy Smith.
-
-By my thesis year I had moved from Stable Diffusion's standard interfaces to ComfyUI, because I think in node-based structures and I wanted to control every step. Most AI tools are one click: you prompt, you click, you get a result. That is not what I wanted.
-
-<Quote>I want to control the process, and the process is even more important than the result itself. For artists like me, I don't want to automate anything. I want to participate in every single stage of designing the workflow. That's the fun part of it.</Quote>
-
-</Section>
-
-<Section id="topic-3">
-
-### Walk us through the pipeline. What were you actually feeding the model?
-
-<Figure src="https://media.comfy.org/website/customers/xindi-zhang/balloon-workflow.png" alt="Xindi's ComfyUI workflow for the balloon sequence">Xindi's ComfyUI workflow for the balloon sequence. Source: [xindizhangart.com](https://xindizhangart.com).</Figure>
-
-My core technique was style transfer in Stable Diffusion 1.5, driven by IP-Adapter and ControlNet. What mattered most was what I fed it: my own work. The base materials were live-action footage I shot on an iPhone 15 Pro and 3D animation I built in Blender. The AI restyled imagery I had already made. It did not invent it.
-
-<Figure src="https://media.comfy.org/website/customers/xindi-zhang/film-still.jpg" alt="Style-guide still from The Song of Drifters">Style-guide still from The Song of Drifters. Source: [xindizhangart.com](https://xindizhangart.com).</Figure>
-
-<Quote>Unlike most AI-generated videos, which use other artists' works from the model, I use my own illustrations as the style guide.</Quote>
-
-<Download href="https://media.comfy.org/website/customers/xindi-zhang/workflows/style-transfer-workflow.json" label="Download Xindi's style transfer workflow (json) on ComfyUI" />
-
-I also trained custom LoRAs on my own video, footage of the cities I had lived in. Capturing that footage became a vital part of the documentary process. Wandering through the streets where I once lived let me reconnect with those cities. Most of it never appears in the final cut, but it lives in the visuals as training data. The hybrid pipeline made rendering the final look more efficient and saved more time for ideation.
-
-For the dream sequences I combined animated 3D with AI morphing, moving from abstract to concrete to mimic the feeling of being half awake.
-
-<Video src="https://media.comfy.org/website/customers/xindi-zhang/bts-clip.mp4" poster="https://media.comfy.org/website/customers/xindi-zhang/bts-poster.jpg" caption="BTS clip, AI morphing. Source: Xindi Zhang." />
-
-<Download href="https://media.comfy.org/website/customers/xindi-zhang/workflows/morphing-workflow.json" label="Download Xindi's AI morphing workflow (json) on ComfyUI" />
-
-</Section>
-
-<Section id="topic-4" title="At a glance">
-
-<AtAGlance rows={[
-  { label: "Program", value: "USC School of Cinematic Arts — MFA Expanded Animation (thesis)" },
-  { label: "Base materials", value: "iPhone 15 Pro live-action; her own Blender 3D animation" },
-  { label: "Core technique", value: "Style transfer in SD 1.5 via IP-Adapter + ControlNet, in ComfyUI" },
-  { label: "Style source", value: "Her own illustrations + custom LoRAs trained on her own city footage" },
-  { label: "Finishing", value: "Depth, mask, and fade passes in After Effects; heavy compositing" },
-  { label: "Outcome", value: "Student Academy Awards Golden Award (2025); 98th Academy Awards shortlist; AI Creative role at Amazon AI Studio" }
-]} />
-
-</Section>
-
-<Section id="topic-5">
-
-### The film won gold at the Student Academy Awards and was shortlisted for the Oscars. What's next?
-
-I made the film for creative reasons, not career ones. I honestly did not expect it to connect to a job at all. Then it won the Golden Award at the 2025 Student Academy Awards and was shortlisted for the Oscars, and the calls started.
-
-<Figure src="https://media.comfy.org/website/customers/xindi-zhang/awards.png" alt="Xindi Zhang at the 2025 Student Academy Awards" caption="Xindi Zhang at the 2025 Student Academy Awards. Source: Oscars Press Office." />
-
-What people wanted was the combination: someone who understands both traditional craft and AI tools. I now work as an AI Creative at Amazon AI Studio building custom production pipelines. I see that same demand across the industry, with ComfyUI experience starting to show up as a requirement in job postings at major studios and design agencies.
-
-<Quote>It's not the tool that steals my art. It's the tool that expands my art.</Quote>
-
-My advice to other students is not really about software. AI is just another tool to convey ideas, but nothing is more important than the story itself. If you use AI, use it on purpose. The more you understand it, the more freedom you have to make work that is genuinely yours.
-
-</Section>
-
-<AuthorBio people={[{ name: "Xindi Zhang", photo: "https://media.comfy.org/website/customers/xindi-zhang/profile.jpg", bio: `Xindi Zhang is a Chinese animation director and visual artist (RISD BFA in illustration, 2020; USC MFA in Expanded Animation, 2025). The Song of Drifters won the Golden Award at the 2025 Student Academy Awards and was shortlisted for the 98th Academy Awards. She works as an AI Creative at Amazon AI Studio, has collaborated with Sony Music's immersive studio, and is now on the faculty at the University of South Florida.` }]} />
-
-<EducationCta />

apps/website/src/styles/global.css

@@ -61,11 +61,6 @@
 
 @theme {
   --color-site-dropdown: #332b38;
-  --color-site-bg-soft: color-mix(
-    in srgb,
-    var(--color-primary-comfy-ink) 88%,
-    black 12%
-  );
   --color-primary-comfy-yellow: #f2ff59;
   --color-primary-comfy-ink: #211927;
   --color-primary-comfy-ink-light: #2a2330;
@@ -266,6 +261,6 @@ video::-webkit-media-controls-panel {
 
 :root {
   --site-bg: var(--color-primary-comfy-ink);
-  --site-bg-soft: var(--color-site-bg-soft);
+  --site-bg-soft: color-mix(in srgb, var(--site-bg) 88%, black 12%);
   --site-border-subtle: rgb(255 255 255 / 0.1);
 }

browser_tests/README.md

@@ -123,6 +123,15 @@ Browser tests in this project follow a specific organization pattern:
 - **Utilities**: Located in `utils/` - Common utility functions
   - `litegraphUtils.ts` - Utilities for working with LiteGraph nodes
 
+### Custom-node regression suite
+
+`tests/customNodes/` holds the manifest-driven suite that proves community
+custom-node packs load, render in both renderers (LiteGraph canvas and Vue
+Nodes 2.0), and execute real workflows. It has its own prerequisites, pnpm
+scripts (`pnpm test:custom-nodes` and per-pack variants), and a
+one-JSON-row process for adding packs - see
+[tests/customNodes/README.md](tests/customNodes/README.md).
+
 ## Writing Effective Tests
 
 When writing new tests, follow these patterns:

browser_tests/assets/customNodes/core_smoke.json

@@ -0,0 +1,53 @@
+{
+  "last_node_id": 2,
+  "last_link_id": 1,
+  "nodes": [
+    {
+      "id": 1,
+      "type": "PrimitiveInt",
+      "pos": { "0": 20, "1": 60 },
+      "size": { "0": 250, "1": 80 },
+      "flags": {},
+      "order": 0,
+      "mode": 0,
+      "inputs": [],
+      "outputs": [
+        {
+          "name": "INT",
+          "type": "INT",
+          "links": [1],
+          "slot_index": 0
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "PrimitiveInt"
+      },
+      "widgets_values": [42, "fixed"]
+    },
+    {
+      "id": 2,
+      "type": "PreviewAny",
+      "pos": { "0": 340, "1": 60 },
+      "size": { "0": 220, "1": 60 },
+      "flags": {},
+      "order": 1,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "source",
+          "type": "*",
+          "link": 1
+        }
+      ],
+      "outputs": [],
+      "properties": {
+        "Node name for S&R": "PreviewAny"
+      }
+    }
+  ],
+  "links": [[1, 1, 0, 2, 0, "INT"]],
+  "groups": [],
+  "config": {},
+  "extra": {},
+  "version": 0.4
+}

browser_tests/assets/customNodes/customscripts_string_show_run.json

@@ -0,0 +1,60 @@
+{
+  "last_node_id": 2,
+  "last_link_id": 1,
+  "nodes": [
+    {
+      "id": 1,
+      "type": "StringFunction|pysssss",
+      "pos": { "0": 20, "1": 60 },
+      "size": { "0": 300, "1": 240 },
+      "flags": {},
+      "order": 0,
+      "mode": 0,
+      "inputs": [],
+      "outputs": [
+        {
+          "name": "STRING",
+          "type": "STRING",
+          "links": [1],
+          "slot_index": 0
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "StringFunction|pysssss"
+      },
+      "widgets_values": ["append", "yes", "hello", " world", ""]
+    },
+    {
+      "id": 2,
+      "type": "ShowText|pysssss",
+      "pos": { "0": 380, "1": 60 },
+      "size": { "0": 220, "1": 80 },
+      "flags": {},
+      "order": 1,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "text",
+          "type": "STRING",
+          "link": 1
+        }
+      ],
+      "outputs": [
+        {
+          "name": "STRING",
+          "type": "STRING",
+          "links": null,
+          "slot_index": 0
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "ShowText|pysssss"
+      }
+    }
+  ],
+  "links": [[1, 1, 0, 2, 0, "STRING"]],
+  "groups": [],
+  "config": {},
+  "extra": {},
+  "version": 0.4
+}

browser_tests/assets/customNodes/essentials_math_display_run.json

@@ -0,0 +1,61 @@
+{
+  "last_node_id": 2,
+  "last_link_id": 1,
+  "nodes": [
+    {
+      "id": 1,
+      "type": "SimpleMathInt+",
+      "pos": { "0": 20, "1": 60 },
+      "size": { "0": 250, "1": 60 },
+      "flags": {},
+      "order": 0,
+      "mode": 0,
+      "inputs": [],
+      "outputs": [
+        {
+          "name": "INT",
+          "type": "INT",
+          "links": [1],
+          "slot_index": 0
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "SimpleMathInt+"
+      },
+      "widgets_values": [5]
+    },
+    {
+      "id": 2,
+      "type": "DisplayAny",
+      "pos": { "0": 340, "1": 60 },
+      "size": { "0": 220, "1": 80 },
+      "flags": {},
+      "order": 1,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "input",
+          "type": "*",
+          "link": 1
+        }
+      ],
+      "outputs": [
+        {
+          "name": "STRING",
+          "type": "STRING",
+          "links": null,
+          "slot_index": 0
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "DisplayAny"
+      },
+      "widgets_values": ["raw value"]
+    }
+  ],
+  "links": [[1, 1, 0, 2, 0, "INT"]],
+  "groups": [],
+  "config": {},
+  "extra": {},
+  "version": 0.4
+}

browser_tests/assets/customNodes/impact_primitives_run.json

@@ -0,0 +1,98 @@
+{
+  "last_node_id": 4,
+  "last_link_id": 2,
+  "nodes": [
+    {
+      "id": 1,
+      "type": "ImpactInt",
+      "pos": { "0": 20, "1": 60 },
+      "size": { "0": 250, "1": 60 },
+      "flags": {},
+      "order": 0,
+      "mode": 0,
+      "inputs": [],
+      "outputs": [
+        {
+          "name": "INT",
+          "type": "INT",
+          "links": [1],
+          "slot_index": 0
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "ImpactInt"
+      },
+      "widgets_values": [42]
+    },
+    {
+      "id": 2,
+      "type": "PreviewAny",
+      "pos": { "0": 340, "1": 60 },
+      "size": { "0": 220, "1": 60 },
+      "flags": {},
+      "order": 2,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "source",
+          "type": "*",
+          "link": 1
+        }
+      ],
+      "outputs": [],
+      "properties": {
+        "Node name for S&R": "PreviewAny"
+      }
+    },
+    {
+      "id": 3,
+      "type": "ImpactFloat",
+      "pos": { "0": 20, "1": 220 },
+      "size": { "0": 250, "1": 60 },
+      "flags": {},
+      "order": 1,
+      "mode": 0,
+      "inputs": [],
+      "outputs": [
+        {
+          "name": "FLOAT",
+          "type": "FLOAT",
+          "links": [2],
+          "slot_index": 0
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "ImpactFloat"
+      },
+      "widgets_values": [3.14]
+    },
+    {
+      "id": 4,
+      "type": "PreviewAny",
+      "pos": { "0": 340, "1": 220 },
+      "size": { "0": 220, "1": 60 },
+      "flags": {},
+      "order": 3,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "source",
+          "type": "*",
+          "link": 2
+        }
+      ],
+      "outputs": [],
+      "properties": {
+        "Node name for S&R": "PreviewAny"
+      }
+    }
+  ],
+  "links": [
+    [1, 1, 0, 2, 0, "INT"],
+    [2, 3, 0, 4, 0, "FLOAT"]
+  ],
+  "groups": [],
+  "config": {},
+  "extra": {},
+  "version": 0.4
+}

browser_tests/assets/customNodes/kjnodes_constants_run.json

@@ -0,0 +1,98 @@
+{
+  "last_node_id": 4,
+  "last_link_id": 2,
+  "nodes": [
+    {
+      "id": 1,
+      "type": "INTConstant",
+      "pos": { "0": 20, "1": 60 },
+      "size": { "0": 250, "1": 60 },
+      "flags": {},
+      "order": 0,
+      "mode": 0,
+      "inputs": [],
+      "outputs": [
+        {
+          "name": "value",
+          "type": "INT",
+          "links": [1],
+          "slot_index": 0
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "INTConstant"
+      },
+      "widgets_values": [42]
+    },
+    {
+      "id": 2,
+      "type": "PreviewAny",
+      "pos": { "0": 340, "1": 60 },
+      "size": { "0": 220, "1": 60 },
+      "flags": {},
+      "order": 2,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "source",
+          "type": "*",
+          "link": 1
+        }
+      ],
+      "outputs": [],
+      "properties": {
+        "Node name for S&R": "PreviewAny"
+      }
+    },
+    {
+      "id": 3,
+      "type": "FloatConstant",
+      "pos": { "0": 20, "1": 220 },
+      "size": { "0": 250, "1": 60 },
+      "flags": {},
+      "order": 1,
+      "mode": 0,
+      "inputs": [],
+      "outputs": [
+        {
+          "name": "value",
+          "type": "FLOAT",
+          "links": [2],
+          "slot_index": 0
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "FloatConstant"
+      },
+      "widgets_values": [3.14]
+    },
+    {
+      "id": 4,
+      "type": "PreviewAny",
+      "pos": { "0": 340, "1": 220 },
+      "size": { "0": 220, "1": 60 },
+      "flags": {},
+      "order": 3,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "source",
+          "type": "*",
+          "link": 2
+        }
+      ],
+      "outputs": [],
+      "properties": {
+        "Node name for S&R": "PreviewAny"
+      }
+    }
+  ],
+  "links": [
+    [1, 1, 0, 2, 0, "INT"],
+    [2, 3, 0, 4, 0, "FLOAT"]
+  ],
+  "groups": [],
+  "config": {},
+  "extra": {},
+  "version": 0.4
+}

browser_tests/assets/customNodes/rgthree_seed_display_run.json

@@ -0,0 +1,53 @@
+{
+  "last_node_id": 2,
+  "last_link_id": 1,
+  "nodes": [
+    {
+      "id": 1,
+      "type": "Seed (rgthree)",
+      "pos": { "0": 20, "1": 60 },
+      "size": { "0": 250, "1": 130 },
+      "flags": {},
+      "order": 0,
+      "mode": 0,
+      "inputs": [],
+      "outputs": [
+        {
+          "name": "SEED",
+          "type": "INT",
+          "links": [1],
+          "slot_index": 0
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "Seed (rgthree)"
+      },
+      "widgets_values": [12345]
+    },
+    {
+      "id": 2,
+      "type": "Display Any (rgthree)",
+      "pos": { "0": 340, "1": 60 },
+      "size": { "0": 220, "1": 60 },
+      "flags": {},
+      "order": 1,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "source",
+          "type": "*",
+          "link": 1
+        }
+      ],
+      "outputs": [],
+      "properties": {
+        "Node name for S&R": "Display Any (rgthree)"
+      }
+    }
+  ],
+  "links": [[1, 1, 0, 2, 0, "INT"]],
+  "groups": [],
+  "config": {},
+  "extra": {},
+  "version": 0.4
+}

browser_tests/assets/customNodes/vhs_video_pipeline_run.json

@@ -0,0 +1,107 @@
+{
+  "last_node_id": 3,
+  "last_link_id": 2,
+  "nodes": [
+    {
+      "id": 1,
+      "type": "VHS_LoadVideoPath",
+      "pos": { "0": 20, "1": 60 },
+      "size": { "0": 320, "1": 260 },
+      "flags": {},
+      "order": 0,
+      "mode": 0,
+      "inputs": [],
+      "outputs": [
+        {
+          "name": "IMAGE",
+          "type": "IMAGE",
+          "links": null
+        },
+        {
+          "name": "frame_count",
+          "type": "INT",
+          "links": null
+        },
+        {
+          "name": "audio",
+          "type": "AUDIO",
+          "links": null
+        },
+        {
+          "name": "video_info",
+          "type": "VHS_VIDEOINFO",
+          "links": [1],
+          "slot_index": 3
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "VHS_LoadVideoPath"
+      },
+      "widgets_values": ["input/plain_video.mp4", 0, 0, 0, 0, 0, 1]
+    },
+    {
+      "id": 2,
+      "type": "VHS_VideoInfo",
+      "pos": { "0": 400, "1": 60 },
+      "size": { "0": 240, "1": 260 },
+      "flags": {},
+      "order": 1,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "video_info",
+          "type": "VHS_VIDEOINFO",
+          "link": 1
+        }
+      ],
+      "outputs": [
+        {
+          "name": "source_fps🟨",
+          "type": "FLOAT",
+          "links": [2],
+          "slot_index": 0
+        },
+        { "name": "source_frame_count🟨", "type": "INT", "links": null },
+        { "name": "source_duration🟨", "type": "FLOAT", "links": null },
+        { "name": "source_width🟨", "type": "INT", "links": null },
+        { "name": "source_height🟨", "type": "INT", "links": null },
+        { "name": "loaded_fps🟦", "type": "FLOAT", "links": null },
+        { "name": "loaded_frame_count🟦", "type": "INT", "links": null },
+        { "name": "loaded_duration🟦", "type": "FLOAT", "links": null },
+        { "name": "loaded_width🟦", "type": "INT", "links": null },
+        { "name": "loaded_height🟦", "type": "INT", "links": null }
+      ],
+      "properties": {
+        "Node name for S&R": "VHS_VideoInfo"
+      }
+    },
+    {
+      "id": 3,
+      "type": "PreviewAny",
+      "pos": { "0": 700, "1": 60 },
+      "size": { "0": 220, "1": 60 },
+      "flags": {},
+      "order": 2,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "source",
+          "type": "*",
+          "link": 2
+        }
+      ],
+      "outputs": [],
+      "properties": {
+        "Node name for S&R": "PreviewAny"
+      }
+    }
+  ],
+  "links": [
+    [1, 1, 3, 2, 0, "VHS_VIDEOINFO"],
+    [2, 2, 0, 3, 0, "FLOAT"]
+  ],
+  "groups": [],
+  "config": {},
+  "extra": {},
+  "version": 0.4
+}

browser_tests/assets/customNodes/was_number_text_run.json

@@ -0,0 +1,103 @@
+{
+  "last_node_id": 3,
+  "last_link_id": 2,
+  "nodes": [
+    {
+      "id": 1,
+      "type": "Constant Number",
+      "pos": { "0": 20, "1": 60 },
+      "size": { "0": 250, "1": 100 },
+      "flags": {},
+      "order": 0,
+      "mode": 0,
+      "inputs": [],
+      "outputs": [
+        {
+          "name": "NUMBER",
+          "type": "NUMBER",
+          "links": [1],
+          "slot_index": 0
+        },
+        {
+          "name": "FLOAT",
+          "type": "FLOAT",
+          "links": null,
+          "slot_index": 1
+        },
+        {
+          "name": "INT",
+          "type": "INT",
+          "links": null,
+          "slot_index": 2
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "Constant Number"
+      },
+      "widgets_values": ["integer", 7]
+    },
+    {
+      "id": 2,
+      "type": "Number to Text",
+      "pos": { "0": 340, "1": 60 },
+      "size": { "0": 220, "1": 60 },
+      "flags": {},
+      "order": 1,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "number",
+          "type": "NUMBER",
+          "link": 1
+        }
+      ],
+      "outputs": [
+        {
+          "name": "STRING",
+          "type": "STRING",
+          "links": [2],
+          "slot_index": 0
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "Number to Text"
+      }
+    },
+    {
+      "id": 3,
+      "type": "Text to Console",
+      "pos": { "0": 640, "1": 60 },
+      "size": { "0": 250, "1": 80 },
+      "flags": {},
+      "order": 2,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "text",
+          "type": "STRING",
+          "link": 2
+        }
+      ],
+      "outputs": [
+        {
+          "name": "STRING",
+          "type": "STRING",
+          "links": null,
+          "slot_index": 0
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "Text to Console"
+      },
+      "widgets_values": ["Text Output"]
+    }
+  ],
+  "links": [
+    [1, 1, 0, 2, 0, "NUMBER"],
+    [2, 2, 0, 3, 0, "STRING"]
+  ],
+  "groups": [],
+  "config": {},
+  "extra": {},
+  "version": 0.4
+}

browser_tests/fixtures/ComfyPage.ts

@@ -268,8 +268,16 @@ export class ComfyPage {
       data: { username }
     })
 
-    if (resp.status() !== 200)
-      throw new Error(`Failed to create user: ${await resp.text()}`)
+    if (resp.status() !== 200) {
+      const body = await resp.text()
+      // Persistent backends (Comfy Desktop server user storage) keep the user
+      // across runs and do not list it via GET /api/users, so a duplicate means
+      // it already exists. Returns the username since the generated id is not
+      // retrievable here; only reached on single-user / default-resolving backends.
+      if (resp.status() === 400 && body.includes('Duplicate username.'))
+        return username
+      throw new Error(`Failed to create user: ${body}`)
+    }
 
     return await resp.json()
   }

browser_tests/fixtures/customNode/ComfyTarget.ts

@@ -0,0 +1,141 @@
+import type { Page } from '@playwright/test'
+
+import type { ObjectInfo } from '@e2e/fixtures/customNode/objectInfoValidator'
+import type {
+  ExecutionError,
+  PromptEvent,
+  RunResult
+} from '@e2e/fixtures/customNode/runResult'
+import { classifyRun } from '@e2e/fixtures/customNode/runResult'
+
+interface RawEvent {
+  type: string
+  node?: string | null
+  exception_type?: string
+  node_id?: string
+  node_type?: string
+  traceback?: string[]
+}
+
+const TERMINAL = [
+  'execution_success',
+  'execution_error',
+  'execution_interrupted'
+]
+
+function toPromptEvent(raw: RawEvent): PromptEvent {
+  if (raw.type === 'executing')
+    return { type: 'executing', node: raw.node ?? null }
+  if (raw.type === 'execution_error' || raw.type === 'execution_interrupted') {
+    const error: ExecutionError = {
+      exceptionType: raw.exception_type,
+      nodeId: raw.node_id,
+      nodeType: raw.node_type,
+      traceback: raw.traceback
+    }
+    return { type: raw.type, error }
+  }
+  return { type: raw.type as 'execution_start' | 'execution_success' }
+}
+
+/**
+ * Drives a real ComfyUI backend through the running frontend. The verdict logic
+ * lives in the pure `classifyRun`; this class is only the in-page IO plumbing.
+ */
+export class LocalDesktopTarget {
+  async getObjectInfo(page: Page): Promise<ObjectInfo> {
+    return await page.evaluate(async () => {
+      const defs = await window.app!.api.getNodeDefs()
+      const out: Record<
+        string,
+        { input?: { required?: Record<string, unknown> } }
+      > = {}
+      for (const [name, def] of Object.entries(defs)) {
+        const required = (
+          def as { input?: { required?: Record<string, unknown> } }
+        ).input?.required
+        out[name] = { input: { required } }
+      }
+      return out
+    })
+  }
+
+  async runWorkflow(
+    page: Page,
+    opts: { expectedNodeIds: string[]; timeoutMs: number }
+  ): Promise<RunResult> {
+    await page.evaluate(
+      (types) => {
+        const sink = window as unknown as {
+          __cnEvents: RawEvent[]
+          __cnTapInstalled?: boolean
+        }
+        sink.__cnEvents = []
+        if (sink.__cnTapInstalled) return
+        sink.__cnTapInstalled = true
+        for (const type of types)
+          (window.app!.api as EventTarget).addEventListener(
+            type,
+            (event: Event) => {
+              const detail: unknown = (event as CustomEvent).detail
+              // `executing` dispatches a bare node-id string (api.ts
+              // dispatchCustomEvent('executing', msg.data.node)); the other
+              // events dispatch object payloads.
+              sink.__cnEvents.push(
+                detail !== null && typeof detail === 'object'
+                  ? { type, ...(detail as Record<string, unknown>) }
+                  : { type, node: (detail as string | undefined) ?? null }
+              )
+            }
+          )
+      },
+      ['execution_start', ...TERMINAL, 'executing']
+    )
+
+    // Browser path: app.queuePrompt runs graphToPrompt internally. Do NOT call
+    // app.api.queuePrompt, which submits an already-serialized (empty) prompt.
+    // A backend validation reject emits NO events at all - without checking the
+    // queue result, every rejected prompt would burn the full wait and
+    // masquerade as TIMEOUT. But a false return is NOT proof of a backend
+    // reject: pack JS hooking the queue path (Impact's wildcard processing)
+    // can refuse transiently right after nodes are created. Retry once -
+    // genuine backend rejects are deterministic and fail both attempts.
+    let queued = await page.evaluate(() => window.app!.queuePrompt(0))
+    if (queued === false) {
+      await page.evaluate(
+        () => new Promise((resolve) => setTimeout(resolve, 250))
+      )
+      queued = await page.evaluate(() => window.app!.queuePrompt(0))
+      if (queued === false)
+        return { outcome: 'VALIDATION_FAIL', executedNodes: [] }
+    }
+
+    await page
+      .waitForFunction(
+        (terminal) => {
+          const events =
+            (window as unknown as { __cnEvents?: { type: string }[] })
+              .__cnEvents ?? []
+          return events.some((event) => terminal.includes(event.type))
+        },
+        TERMINAL,
+        { timeout: opts.timeoutMs }
+      )
+      .catch((error: unknown) => {
+        // Only a Playwright wait timeout means "no terminal event"; surface any
+        // other fault instead of masquerading it as a run TIMEOUT.
+        if (error instanceof Error && error.name === 'TimeoutError') return
+        throw error
+      })
+
+    const raw = await page.evaluate(
+      () => (window as unknown as { __cnEvents?: RawEvent[] }).__cnEvents ?? []
+    )
+    const timedOut = !raw.some((event) => TERMINAL.includes(event.type))
+    return classifyRun({
+      events: raw.map(toPromptEvent),
+      expectedNodeIds: opts.expectedNodeIds,
+      timedOut
+    })
+  }
+}

browser_tests/fixtures/customNode/autoRun.ts

@@ -0,0 +1,108 @@
+// Classifies which registered nodes can execute with zero hand-authored
+// fixtures: every required input satisfiable by a widget default, plus an
+// observable terminus (the node is an OUTPUT_NODE, or an output we can wire
+// to core PreviewAny). Those run for real on the backend; the rest are
+// recorded with the reason they cannot run alone - never silently dropped.
+import type { RawNodeDef } from './typePairing'
+
+export type AutoRunClass =
+  // Runs alone: widgets cover every required input, terminus available.
+  | 'AUTO_RUNNABLE'
+  // A required input is a socket (custom type or forceInput); execution
+  // needs wiring, which the curated run workflows cover instead.
+  | 'NEEDS_WIRES'
+  // A required combo has zero options on this backend - a model/file scan
+  // came back empty, so no valid default exists (CPU gate has no models).
+  | 'NEEDS_MODELS'
+  // Widgets suffice but nothing observable to queue: no outputs and not an
+  // OUTPUT_NODE, so the executor would never touch it.
+  | 'NO_SINK'
+
+export interface AutoRunVerdict {
+  key: string
+  verdict: AutoRunClass
+  // Set for AUTO_RUNNABLE: wire output 0 to PreviewAny (false = the node is
+  // its own OUTPUT_NODE terminus and runs standalone).
+  needsPreviewSink?: boolean
+  reason: string
+}
+
+const WIDGET_TYPES = new Set(['INT', 'FLOAT', 'STRING', 'BOOLEAN'])
+
+type InputSpec = [unknown, Record<string, unknown>?] | unknown
+
+function classifyInput(
+  name: string,
+  spec: InputSpec
+): 'widget' | 'socket' | 'empty-combo' {
+  const specArray = Array.isArray(spec) ? spec : [spec]
+  const rawType = specArray[0]
+  const options = specArray[1] as { forceInput?: boolean } | undefined
+  if (Array.isArray(rawType))
+    return rawType.length > 0 ? 'widget' : 'empty-combo'
+  if (typeof rawType !== 'string') return 'socket'
+  if (options?.forceInput) return 'socket'
+  return WIDGET_TYPES.has(rawType) ? 'widget' : 'socket'
+}
+
+export function classifyAutoRunnable(
+  key: string,
+  def: RawNodeDef & { output_node?: boolean }
+): AutoRunVerdict {
+  for (const [name, spec] of Object.entries(def.input?.required ?? {})) {
+    const kind = classifyInput(name, spec)
+    if (kind === 'socket')
+      return {
+        key,
+        verdict: 'NEEDS_WIRES',
+        reason: `required input "${name}" is a socket`
+      }
+    if (kind === 'empty-combo')
+      return {
+        key,
+        verdict: 'NEEDS_MODELS',
+        reason: `required combo "${name}" has no options on this backend`
+      }
+  }
+  if (def.output_node === true)
+    return {
+      key,
+      verdict: 'AUTO_RUNNABLE',
+      needsPreviewSink: false,
+      reason: 'widgets satisfy all required inputs; node is its own terminus'
+    }
+  if ((def.output ?? []).length > 0)
+    return {
+      key,
+      verdict: 'AUTO_RUNNABLE',
+      needsPreviewSink: true,
+      reason: 'widgets satisfy all required inputs; output 0 -> PreviewAny'
+    }
+  return {
+    key,
+    verdict: 'NO_SINK',
+    reason: 'no outputs and not an OUTPUT_NODE - nothing observable to queue'
+  }
+}
+
+export function planAutoRuns(
+  defs: Record<string, RawNodeDef & { output_node?: boolean }>,
+  packNodeKeys: string[]
+): AutoRunVerdict[] {
+  return packNodeKeys.map((key) => classifyAutoRunnable(key, defs[key]))
+}
+
+// Independent single-node chains per prompt; one bad node fails its batch,
+// not the whole tier, and the executed-set check still attributes per node.
+export function batchAutoRunnable(
+  verdicts: AutoRunVerdict[],
+  batchSize: number
+): AutoRunVerdict[][] {
+  const runnable = verdicts.filter(
+    (verdict) => verdict.verdict === 'AUTO_RUNNABLE'
+  )
+  const batches: AutoRunVerdict[][] = []
+  for (let offset = 0; offset < runnable.length; offset += batchSize)
+    batches.push(runnable.slice(offset, offset + batchSize))
+  return batches
+}

browser_tests/fixtures/customNode/manifest.ts

@@ -0,0 +1,124 @@
+import { readFileSync } from 'node:fs'
+import { fileURLToPath } from 'node:url'
+
+const MANIFEST_PATH = fileURLToPath(
+  new URL('../data/customNodeManifest.json', import.meta.url)
+)
+
+const VALID_TIERS = ['load', 'run', 'connectivity', 'io'] as const
+
+type CustomNodeTier = (typeof VALID_TIERS)[number]
+
+export interface CustomNodeManifestEntry {
+  pack: string
+  repo: string
+  pin: string
+  tiers: CustomNodeTier[]
+  // Frontend-format workflow (path relative to browser_tests/) loaded and queued
+  // by the run/io tiers; empty or absent file = tier skips. Run the backend with
+  // --cache-none, or repeat runs classify PARTIAL when cached nodes skip executing.
+  workflow: string
+  // Runtime class_type / object_info keys, NOT Python class names (e.g. rgthree
+  // registers "Power Primitive (rgthree)", not RgthreePowerPrimitive).
+  expectedNodes: string[]
+  requiresGpu: boolean
+  requiresModels: string[]
+  timeoutMs: number
+  // Optional; absent means true. Set false ONLY with evidence that the pack's
+  // nodes fail to mount under Vue Nodes 2.0 (probe it - a README grumble is
+  // not evidence). When false, renderer-specific Vue assertions are not
+  // applied to this pack: its tests still run and pass their LiteGraph-canvas
+  // assertions, so the zero-skip gate is preserved.
+  vueNodesCompatible?: boolean
+  // Per-node Vue Nodes 2.0 incompatibility ledger: node key -> reason with
+  // evidence (author statement or reproduced mount failure; a run failure
+  // alone is NOT evidence - it may be our own fixture error). Ledgered nodes
+  // keep every canvas assertion; only their Vue mount assertion is withheld.
+  // A key that stops existing on the backend fails the suite, so entries
+  // cannot silently rot.
+  vueIncompatibleNodes?: Record<string, string>
+  // Auto-run baseline: nodes observed unable to execute standalone on a bare
+  // backend (validation reject or execution error on pure defaults - empty
+  // expressions, empty folders, no webcam). Asserted BOTH ways: a failing
+  // node missing from this list is a regression, and a listed node that now
+  // runs clean must be removed. Weak-signal territory by design - a wrong
+  // entry here means a fixture gap, never a skipped test.
+  cannotRunAlone?: string[]
+}
+
+function assertEntry(entry: CustomNodeManifestEntry, index: number): void {
+  const missing: string[] = []
+  if (typeof entry.pack !== 'string' || entry.pack.length === 0)
+    missing.push('pack')
+  // CI clones from repo, so an empty value must fail here, not mid-clone.
+  // pin stays optional ("" = default branch head).
+  if (typeof entry.repo !== 'string' || entry.repo.length === 0)
+    missing.push('repo')
+  // workflow may be an empty string until the pack gains a run-tier fixture.
+  if (typeof entry.workflow !== 'string') missing.push('workflow')
+  // A run-tier row with no workflow would otherwise skip locally, leaving
+  // only CI's skip gate to notice the lost coverage. Fail at load instead.
+  else if (
+    entry.workflow === '' &&
+    Array.isArray(entry.tiers) &&
+    entry.tiers.includes('run')
+  )
+    missing.push('workflow (required when tiers includes "run")')
+  if (!Array.isArray(entry.expectedNodes) || entry.expectedNodes.length === 0)
+    missing.push('expectedNodes')
+  if (!Array.isArray(entry.tiers) || entry.tiers.length === 0)
+    missing.push('tiers')
+  // A typo like "connectivty" would otherwise pass and silently drop that
+  // tier's coverage - the exact drift this manifest exists to catch.
+  else if (entry.tiers.some((tier) => !VALID_TIERS.includes(tier)))
+    missing.push(`tiers (unknown value; allowed: ${VALID_TIERS.join(', ')})`)
+  if (!Array.isArray(entry.requiresModels)) missing.push('requiresModels')
+  if (typeof entry.requiresGpu !== 'boolean') missing.push('requiresGpu')
+  if (!Number.isFinite(entry.timeoutMs) || entry.timeoutMs <= 0)
+    missing.push('timeoutMs')
+  if (
+    entry.vueNodesCompatible !== undefined &&
+    typeof entry.vueNodesCompatible !== 'boolean'
+  )
+    missing.push('vueNodesCompatible')
+  if (
+    entry.vueIncompatibleNodes !== undefined &&
+    (typeof entry.vueIncompatibleNodes !== 'object' ||
+      entry.vueIncompatibleNodes === null ||
+      Array.isArray(entry.vueIncompatibleNodes) ||
+      Object.values(entry.vueIncompatibleNodes).some(
+        (reason) => typeof reason !== 'string' || reason.length === 0
+      ))
+  )
+    missing.push('vueIncompatibleNodes (node key -> non-empty reason string)')
+  if (
+    entry.cannotRunAlone !== undefined &&
+    (!Array.isArray(entry.cannotRunAlone) ||
+      entry.cannotRunAlone.some(
+        (key) => typeof key !== 'string' || key.length === 0
+      ) ||
+      new Set(entry.cannotRunAlone).size !== entry.cannotRunAlone.length)
+  )
+    missing.push('cannotRunAlone (unique non-empty node keys)')
+  if (missing.length > 0)
+    throw new Error(
+      `custom-node manifest entry ${index} (${entry.pack ?? '?'}) missing: ${missing.join(', ')}`
+    )
+}
+
+// Renderer passes for the load tier: LiteGraph canvas always, Vue Nodes 2.0
+// unless the pack declares itself incompatible. Conditional coverage, never a
+// test.skip - the caller still runs and gates on the returned passes.
+export function rendererPassesFor(
+  entry: Pick<CustomNodeManifestEntry, 'vueNodesCompatible'>
+): boolean[] {
+  return entry.vueNodesCompatible === false ? [false] : [false, true]
+}
+
+export function loadManifest(): CustomNodeManifestEntry[] {
+  const entries = JSON.parse(
+    readFileSync(MANIFEST_PATH, 'utf-8')
+  ) as CustomNodeManifestEntry[]
+  entries.forEach(assertEntry)
+  return entries
+}

browser_tests/fixtures/customNode/objectInfoValidator.ts

@@ -0,0 +1,54 @@
+import type { CustomNodeOutcome } from '@e2e/fixtures/customNode/runResult'
+
+interface ObjectInfoNode {
+  input?: { required?: Record<string, unknown> }
+}
+export type ObjectInfo = Record<string, ObjectInfoNode>
+
+export interface ApiPromptNode {
+  id: string
+  classType: string
+  inputs: Record<string, unknown>
+}
+
+export function expectedNodesPresent(
+  objectInfo: ObjectInfo,
+  expectedNodes: string[]
+): { present: string[]; missing: string[] } {
+  const present: string[] = []
+  const missing: string[] = []
+  for (const name of expectedNodes) {
+    if (name in objectInfo) present.push(name)
+    else missing.push(name)
+  }
+  return { present, missing }
+}
+
+export interface PreValidationFailure {
+  outcome: Extract<CustomNodeOutcome, 'MISSING_NODE' | 'VALIDATION_FAIL'>
+  message: string
+}
+
+// Turns an opaque backend 400 into a precise infra error before submit (BE-401):
+// every required input declared in object_info must be present in the fixture node.
+export function preValidate(
+  objectInfo: ObjectInfo,
+  nodes: ApiPromptNode[]
+): PreValidationFailure | null {
+  for (const node of nodes) {
+    const def = objectInfo[node.classType]
+    if (!def)
+      return {
+        outcome: 'MISSING_NODE',
+        message: `node ${node.id} ${node.classType} missing from object_info`
+      }
+    for (const name of Object.keys(def.input?.required ?? {})) {
+      if (!(name in node.inputs))
+        return {
+          outcome: 'VALIDATION_FAIL',
+          message: `node ${node.id} ${node.classType} missing required input "${name}"`
+        }
+    }
+  }
+  return null
+}

browser_tests/fixtures/customNode/runResult.ts

@@ -0,0 +1,72 @@
+export type CustomNodeOutcome =
+  | 'NOT_INSTALLED'
+  | 'IMPORT_ERROR'
+  | 'MISSING_NODE'
+  | 'VALIDATION_FAIL'
+  | 'EXECUTION_ERROR'
+  | 'PARTIAL'
+  | 'TIMEOUT'
+  | 'PASS'
+
+export interface ExecutionError {
+  exceptionType?: string
+  nodeId?: string
+  nodeType?: string
+  traceback?: string[]
+}
+
+export type PromptEvent =
+  | { type: 'execution_start' }
+  | { type: 'executing'; node: string | null }
+  | { type: 'execution_success' }
+  | { type: 'execution_error'; error: ExecutionError }
+  | { type: 'execution_interrupted'; error?: ExecutionError }
+
+export interface RunResult {
+  outcome: CustomNodeOutcome
+  executedNodes: string[]
+  error?: ExecutionError
+}
+
+// `executing` with a non-null node is the only cache-safe "this node actually ran"
+// signal: ComfyUI emits it solely for non-cached nodes (execution.py:493), while the
+// `executed` message and /history outputs are replayed for cached nodes too.
+function executedNodesFrom(events: PromptEvent[]): string[] {
+  const executed = new Set<string>()
+  for (const event of events) {
+    if (event.type === 'executing' && event.node !== null)
+      executed.add(event.node)
+  }
+  return [...executed]
+}
+
+export function classifyRun(input: {
+  events: PromptEvent[]
+  expectedNodeIds: string[]
+  timedOut?: boolean
+}): RunResult {
+  const { events, expectedNodeIds, timedOut = false } = input
+  const executedNodes = executedNodesFrom(events)
+
+  if (timedOut) return { outcome: 'TIMEOUT', executedNodes }
+
+  const failure = events.find(
+    (
+      event
+    ): event is Extract<
+      PromptEvent,
+      { type: 'execution_error' | 'execution_interrupted' }
+    > =>
+      event.type === 'execution_error' || event.type === 'execution_interrupted'
+  )
+  if (failure)
+    return { outcome: 'EXECUTION_ERROR', executedNodes, error: failure.error }
+
+  if (!events.some((event) => event.type === 'execution_success'))
+    return { outcome: 'TIMEOUT', executedNodes }
+
+  const ranEveryExpected = expectedNodeIds.every((node) =>
+    executedNodes.includes(node)
+  )
+  return { outcome: ranEveryExpected ? 'PASS' : 'PARTIAL', executedNodes }
+}

browser_tests/fixtures/customNode/typePairing.ts

@@ -0,0 +1,216 @@
+// Type-driven pairing generator for the connectivity (contract) tier.
+// Wildcard `*` slots are excluded from pairing: LiteGraph.isValidConnection
+// short-circuits on `*` before the real type compare, so a wildcard link
+// proves reachability, not type interop.
+
+export interface RawNodeDef {
+  input?: {
+    required?: Record<string, unknown>
+    optional?: Record<string, unknown>
+  }
+  output?: unknown[]
+  output_name?: string[]
+  python_module?: string
+}
+
+interface NormalizedSlot {
+  name: string
+  type: string
+}
+
+export interface NormalizedNode {
+  type: string
+  pack: string
+  inputs: NormalizedSlot[]
+  outputs: NormalizedSlot[]
+}
+
+interface SlotRef {
+  nodeType: string
+  pack: string
+  slotName: string
+  slotType: string
+}
+
+export interface PlannedPair {
+  producer: SlotRef
+  consumer: SlotRef
+}
+
+export interface PairingPlan {
+  pairs: PlannedPair[]
+  // No compatible partner in the loaded corpus: a health signal, not a failure.
+  orphans: Array<SlotRef & { dir: 'in' | 'out' }>
+  // `*` / empty-typed slots, excluded by design (false confidence).
+  wildcards: Array<SlotRef & { dir: 'in' | 'out' }>
+  // COMBO-literal slots, excluded by design: isValidConnection only compares
+  // the string COMBO while each slot carries its own option set, so a
+  // type-level pairing proves nothing (a checkpoint dropdown would "connect"
+  // to a scheduler dropdown). Targeted fixtures cover combo behavior.
+  combos: Array<SlotRef & { dir: 'in' | 'out' }>
+}
+
+// Extends the shared outcome taxonomy (runResult.ts); ORPHAN_TYPE is a
+// plan-time skip so it never reaches the executor.
+// WIDGET_ONLY_ON_INSTANCE: the pack's own frontend JS rebuilt a declared
+// input as a widget-only control, so there is no socket to wire - excluded
+// like wildcards, never a failure and never a silent pass.
+export type ConnectivityOutcome =
+  | 'PASS'
+  | 'CONNECT_REJECTED'
+  | 'ROUNDTRIP_LOST'
+  | 'SLOT_CONTRACT_MISMATCH'
+  | 'WIDGET_ONLY_ON_INSTANCE'
+
+export function packOf(pythonModule: string | undefined): string {
+  if (pythonModule?.startsWith('custom_nodes.'))
+    return pythonModule.slice('custom_nodes.'.length)
+  return 'core'
+}
+
+export function isWildcard(type: string): boolean {
+  return type === '' || type === '*'
+}
+
+// COMBO list literals are arrays; their connectable socket type is COMBO.
+function slotTypeOf(rawType: unknown): string | null {
+  if (Array.isArray(rawType)) return 'COMBO'
+  return typeof rawType === 'string' ? rawType : null
+}
+
+function inputSlots(
+  entries: Record<string, unknown> | undefined
+): NormalizedSlot[] {
+  if (!entries) return []
+  const slots: NormalizedSlot[] = []
+  for (const [name, spec] of Object.entries(entries)) {
+    const specArray = Array.isArray(spec) ? spec : [spec]
+    const type = slotTypeOf(specArray[0])
+    if (type === null) continue
+    const opts = specArray[1] as { socketless?: boolean } | undefined
+    // socketless = widget only, no slot: not connectable, out of the matrix.
+    if (opts?.socketless) continue
+    slots.push({ name, type })
+  }
+  return slots
+}
+
+export function normalizeNodeDefs(
+  defs: Record<string, RawNodeDef>
+): NormalizedNode[] {
+  return Object.entries(defs).map(([type, def]) => ({
+    type,
+    pack: packOf(def.python_module),
+    inputs: [
+      ...inputSlots(def.input?.required),
+      ...inputSlots(def.input?.optional)
+    ],
+    outputs: (def.output ?? []).flatMap((rawType, index) => {
+      const slotType = slotTypeOf(rawType)
+      if (slotType === null) return []
+      // output_name entries can be non-strings (COMBO literals repeat the
+      // option array); the slot name must stay a string.
+      const rawName = def.output_name?.[index]
+      return [
+        {
+          name: typeof rawName === 'string' ? rawName : slotType,
+          type: slotType
+        }
+      ]
+    })
+  }))
+}
+
+// Faithful mirror of LiteGraph.isValidConnection (LiteGraphGlobal.ts):
+// wildcard/empty always match, comparison is case-insensitive, comma-unions
+// match if any member pair matches. The live sweep still connects through the
+// REAL validator, so any drift here surfaces as CONNECT_REJECTED, not a
+// silent false green.
+export function isTypeCompatible(a: string, b: string): boolean {
+  if (isWildcard(a) || isWildcard(b)) return true
+  const typeA = a.toLowerCase()
+  const typeB = b.toLowerCase()
+  if (typeA === typeB) return true
+  if (!typeA.includes(',') && !typeB.includes(',')) return false
+  return typeA
+    .split(',')
+    .some((memberA) =>
+      typeB.split(',').some((memberB) => isTypeCompatible(memberA, memberB))
+    )
+}
+
+function slotRef(node: NormalizedNode, slot: NormalizedSlot): SlotRef {
+  return {
+    nodeType: node.type,
+    pack: node.pack,
+    slotName: slot.name,
+    slotType: slot.type
+  }
+}
+
+// One representative compatible edge per slot, deterministically the first
+// partner in (nodeType, slotName) order. This bounds cost to O(slots) but
+// does NOT prove every pair; a full cross-product is an opt-in deep mode.
+export function planPairs(
+  all: NormalizedNode[],
+  corpusTypes: string[]
+): PairingPlan {
+  const sorted = [...all].sort((a, b) => a.type.localeCompare(b.type))
+  const pairable = (slot: NormalizedSlot) =>
+    !isWildcard(slot.type) && slot.type !== 'COMBO'
+  const producers: Array<SlotRef> = sorted.flatMap((node) =>
+    node.outputs.filter(pairable).map((slot) => slotRef(node, slot))
+  )
+  const consumers: Array<SlotRef> = sorted.flatMap((node) =>
+    node.inputs.filter(pairable).map((slot) => slotRef(node, slot))
+  )
+
+  const plan: PairingPlan = {
+    pairs: [],
+    orphans: [],
+    wildcards: [],
+    combos: []
+  }
+  const seen = new Set<string>()
+  const addPair = (producer: SlotRef, consumer: SlotRef) => {
+    const key = `${producer.nodeType}.${producer.slotName}->${consumer.nodeType}.${consumer.slotName}`
+    if (seen.has(key)) return
+    seen.add(key)
+    plan.pairs.push({ producer, consumer })
+  }
+
+  const corpus = all.filter((node) => corpusTypes.includes(node.type))
+  for (const node of corpus) {
+    for (const slot of node.inputs) {
+      if (isWildcard(slot.type)) {
+        plan.wildcards.push({ ...slotRef(node, slot), dir: 'in' })
+        continue
+      }
+      if (slot.type === 'COMBO') {
+        plan.combos.push({ ...slotRef(node, slot), dir: 'in' })
+        continue
+      }
+      const producer = producers.find((candidate) =>
+        isTypeCompatible(candidate.slotType, slot.type)
+      )
+      if (producer) addPair(producer, slotRef(node, slot))
+      else plan.orphans.push({ ...slotRef(node, slot), dir: 'in' })
+    }
+    for (const slot of node.outputs) {
+      if (isWildcard(slot.type)) {
+        plan.wildcards.push({ ...slotRef(node, slot), dir: 'out' })
+        continue
+      }
+      if (slot.type === 'COMBO') {
+        plan.combos.push({ ...slotRef(node, slot), dir: 'out' })
+        continue
+      }
+      const consumer = consumers.find((candidate) =>
+        isTypeCompatible(slot.type, candidate.slotType)
+      )
+      if (consumer) addPair(slotRef(node, slot), consumer)
+      else plan.orphans.push({ ...slotRef(node, slot), dir: 'out' })
+    }
+  }
+  return plan
+}

browser_tests/fixtures/data/customNodeManifest.json

@@ -0,0 +1,132 @@
+[
+  {
+    "pack": "ComfyUI-Impact-Pack",
+    "repo": "https://github.com/ltdrdata/ComfyUI-Impact-Pack",
+    "pin": "",
+    "tiers": ["load", "connectivity", "run"],
+    "workflow": "assets/customNodes/impact_primitives_run.json",
+    "expectedNodes": ["ImpactInt", "ImpactFloat"],
+    "requiresGpu": false,
+    "requiresModels": [],
+    "timeoutMs": 30000,
+    "cannotRunAlone": [
+      "CLIPSegDetectorProvider",
+      "ImpactMakeImageBatch",
+      "ImpactMakeMaskBatch",
+      "MasksToMaskList",
+      "NoiseInjectionDetailerHookProvider"
+    ]
+  },
+  {
+    "pack": "ComfyUI-VideoHelperSuite",
+    "repo": "https://github.com/Kosinkadink/ComfyUI-VideoHelperSuite",
+    "pin": "",
+    "tiers": ["load", "connectivity", "run"],
+    "workflow": "assets/customNodes/vhs_video_pipeline_run.json",
+    "expectedNodes": ["VHS_LoadVideoPath", "VHS_VideoInfo"],
+    "requiresGpu": false,
+    "requiresModels": [],
+    "timeoutMs": 90000,
+    "cannotRunAlone": [
+      "VHS_LoadAudio",
+      "VHS_LoadImagePath",
+      "VHS_LoadImages",
+      "VHS_LoadImagesPath",
+      "VHS_LoadVideoFFmpegPath",
+      "VHS_LoadVideoPath",
+      "VHS_SelectLatest"
+    ]
+  },
+  {
+    "pack": "rgthree-comfy",
+    "repo": "https://github.com/rgthree/rgthree-comfy",
+    "pin": "",
+    "tiers": ["load", "connectivity", "run"],
+    "workflow": "assets/customNodes/rgthree_seed_display_run.json",
+    "expectedNodes": ["Seed (rgthree)", "Display Any (rgthree)"],
+    "requiresGpu": false,
+    "requiresModels": [],
+    "timeoutMs": 30000,
+    "cannotRunAlone": ["Image or Latent Size (rgthree)"]
+  },
+  {
+    "pack": "ComfyUI_essentials",
+    "repo": "https://github.com/cubiq/ComfyUI_essentials",
+    "pin": "",
+    "tiers": ["load", "connectivity", "run"],
+    "workflow": "assets/customNodes/essentials_math_display_run.json",
+    "expectedNodes": ["SimpleMathInt+", "DisplayAny"],
+    "requiresGpu": false,
+    "requiresModels": [],
+    "timeoutMs": 30000,
+    "cannotRunAlone": [
+      "MaskFromList+",
+      "SimpleMath+",
+      "SimpleMathDual+",
+      "SimpleMathFloat+",
+      "SimpleMathInt+",
+      "SimpleMathPercent+",
+      "SimpleMathSlider+",
+      "SimpleMathSliderLowRes+"
+    ]
+  },
+  {
+    "pack": "ComfyUI-KJNodes",
+    "repo": "https://github.com/kijai/ComfyUI-KJNodes",
+    "pin": "",
+    "tiers": ["load", "connectivity", "run"],
+    "workflow": "assets/customNodes/kjnodes_constants_run.json",
+    "expectedNodes": ["INTConstant", "FloatConstant"],
+    "requiresGpu": false,
+    "requiresModels": [],
+    "timeoutMs": 30000,
+    "cannotRunAlone": [
+      "CameraPoseVisualizer",
+      "CreateAudioMask",
+      "CreateMagicMask",
+      "CreateVoronoiMask",
+      "GenerateNoise",
+      "ImageAndMaskPreview",
+      "LoadImagesFromFolderKJ",
+      "LoadVideosFromFolder",
+      "MaskOrImageToWeight",
+      "VisualizeCUDAMemoryHistory",
+      "WebcamCaptureCV2",
+      "WidgetToString"
+    ]
+  },
+  {
+    "pack": "ComfyUI-Custom-Scripts",
+    "repo": "https://github.com/pythongosssss/ComfyUI-Custom-Scripts",
+    "pin": "",
+    "tiers": ["load", "connectivity", "run"],
+    "workflow": "assets/customNodes/customscripts_string_show_run.json",
+    "expectedNodes": ["StringFunction|pysssss", "ShowText|pysssss"],
+    "requiresGpu": false,
+    "requiresModels": [],
+    "timeoutMs": 30000,
+    "cannotRunAlone": ["LoadText|pysssss", "MathExpression|pysssss"]
+  },
+  {
+    "pack": "was-node-suite-comfyui",
+    "repo": "https://github.com/WASasquatch/was-node-suite-comfyui",
+    "pin": "",
+    "tiers": ["load", "connectivity", "run"],
+    "workflow": "assets/customNodes/was_number_text_run.json",
+    "expectedNodes": ["Constant Number", "Number to Text", "Text to Console"],
+    "requiresGpu": false,
+    "requiresModels": [],
+    "timeoutMs": 30000,
+    "cannotRunAlone": [
+      "Bus Node",
+      "Diffusers Hub Model Down-Loader",
+      "Image Aspect Ratio",
+      "Image Batch",
+      "Latent Batch",
+      "Mask Batch",
+      "Mask Rect Area",
+      "Number Counter",
+      "Random Number"
+    ]
+  }
+]

browser_tests/fixtures/utils/consoleErrorCollector.ts

@@ -0,0 +1,17 @@
+import type { ConsoleMessage, Page } from '@playwright/test'
+
+export function collectConsoleErrors(page: Page): {
+  errors: string[]
+  stop: () => void
+} {
+  const errors: string[] = []
+  const listener = (message: ConsoleMessage) => {
+    if (message.type() !== 'error') return
+    // Resource errors ("Failed to load resource: 404") are useless without
+    // the URL, which lives in the message location, not the text.
+    const url = message.location().url
+    errors.push(url ? `${message.text()} [${url}]` : message.text())
+  }
+  page.on('console', listener)
+  return { errors, stop: () => page.off('console', listener) }
+}

browser_tests/fixtures/utils/customNodeSuite.ts

@@ -0,0 +1,27 @@
+import type { ComfyPage } from '@e2e/fixtures/ComfyPage'
+import { TestIds } from '@e2e/fixtures/selectors'
+
+// Boot every session with a blank graph (loadBlankWorkflow) instead of the
+// bundled default template, whose model references error on a model-less
+// harness backend and would trip the zero-visible-errors invariant. The
+// backend must run --multi-user (the repo-wide prerequisite for browser
+// tests): the fixture then writes these settings to the same per-worker
+// user the session reads, on CI and locally alike.
+// The shared fixture disables the errors tab to hide missing-model
+// indicators in unrelated suites; this suite exists to SEE errors, so every
+// error surface stays live.
+export const customNodeSuiteSettings = {
+  'Comfy.TutorialCompleted': false,
+  'Comfy.RightSidePanel.ShowErrorsTab': true
+}
+
+// The tutorial path auto-opens the templates browser over the blank graph.
+// Dismiss it deterministically so no window ever shows unexpected UI.
+export async function dismissTemplatesDialog(
+  comfyPage: ComfyPage
+): Promise<void> {
+  const templates = comfyPage.page.getByTestId(TestIds.templates.content)
+  await templates.waitFor({ state: 'visible' })
+  await comfyPage.page.keyboard.press('Escape')
+  await templates.waitFor({ state: 'hidden' })
+}

browser_tests/fixtures/utils/errorSurfaces.ts

@@ -0,0 +1,16 @@
+import type { Locator, Page } from '@playwright/test'
+
+import { TestIds } from '@e2e/fixtures/selectors'
+
+// The app's user-visible error surfaces. A regression run is green only if a
+// human looking at the screen would see zero errors - not merely a clean
+// console. The harness self-check asserts the overlay IS visible after a
+// forced execution error, so these selectors are permanently proven live.
+export function errorSurfaces(page: Page): Record<string, Locator> {
+  return {
+    errorOverlay: page.getByTestId(TestIds.dialogs.errorOverlay),
+    errorDialog: page.getByTestId(TestIds.dialogs.errorDialog),
+    nodeRenderErrors: page.locator('.node-error'),
+    errorToasts: page.locator('.p-toast-message-error')
+  }
+}

browser_tests/fixtures/utils/litegraphUtils.ts

@@ -119,6 +119,14 @@ class NodeSlotReference {
         const rawPos = node.getConnectionPos(type === 'input', index)
         const convertedPos =
           window.app!.canvas.ds!.convertOffsetToCanvas(rawPos)
+        // convertOffsetToCanvas is canvas-relative; page.mouse needs page
+        // coordinates. Identical when the canvas sits at (0,0), but custom-node
+        // JS can inject page chrome above it (e.g. rgthree's progress bar
+        // shifts the canvas 16px down), which silently turned every slot drag
+        // into a title-bar node drag.
+        const rect = window.app!.canvas.canvas.getBoundingClientRect()
+        convertedPos[0] += rect.left
+        convertedPos[1] += rect.top
 
         // Debug logging - convert Float64Arrays to regular arrays for visibility
         console.warn(

browser_tests/tests/customNodes/ADDING_CUSTOM_NODES.md

@@ -0,0 +1,332 @@
+# Adding a custom-node pack to the regression suite
+
+The authoritative, step-by-step process for onboarding a new pack. Written to
+be followable by a human or an agent with no prior context. The suite itself
+(what it asserts, how to run it) is documented in [README.md](README.md);
+this file is only about adding coverage for a new pack.
+
+The short version: install the pack on a local test backend, read the pack's
+real node keys out of `/object_info`, author one small model-free workflow,
+add one row to the manifest, prove it green locally, push. No new test code
+is ever needed - the specs iterate the manifest.
+
+## What a manifest row buys you (the tiers)
+
+Adding the one row enrolls the pack in two kinds of coverage:
+
+- **Every-node tiers (automatic, zero configuration).** The suite reads the
+  pack's FULL node list from the live backend and, for every registered
+  node: mounts it in both renderers, round-trips it through save/reload,
+  plans typed connections for all its concrete slots, and executes it for
+  real when it is self-sufficient (every required input is a widget with a
+  valid default; output wired to `PreviewAny` or the node is its own
+  terminus). Nodes that cannot run alone are classified and logged, never
+  silently dropped: `NEEDS_WIRES` (required socket inputs), `NEEDS_MODELS`
+  (empty model/file combo on the bare backend), `NO_SINK` (nothing
+  observable to queue), or "rejected at validation on defaults" (needs a
+  curated fixture).
+- **Curated tiers (the row's fields).** `expectedNodes` + `workflow` drive
+  the hand-authored run-tier chain (Step 4) proving a real multi-node
+  wiring executes end to end, and serve as must-exist sentinels.
+
+Every-node coverage means a pack update is tested the moment CI installs
+it - including nodes you never listed.
+
+## Step 0 - prerequisites
+
+- A local test backend and dev server set up exactly per the
+  [README prerequisites](README.md#prerequisites). Do not skip `--multi-user`
+  or `--cache-none`.
+- The pack's GitHub URL. The CI job clones and pip-installs it, so the repo
+  must be public and its `requirements.txt` must install on a CPU-only
+  runner. Packs that hard-require CUDA at import time cannot be onboarded
+  until they guard that import.
+
+## Step 1 - install the pack on the test backend
+
+```bash
+cd <test-backend>/custom_nodes
+git clone https://github.com/<owner>/<pack>
+pip install -r <pack>/requirements.txt   # if the pack has one
+```
+
+If you run a CPU-only backend, constrain pip so the pack cannot swap in a
+different torch (CI does the same):
+
+```bash
+pip freeze | grep -iE '^(torch|torchvision|torchaudio)==' > /tmp/torch-constraints.txt
+pip install -r <pack>/requirements.txt -c /tmp/torch-constraints.txt
+```
+
+Restart the backend and check its log: the `Import times for custom nodes`
+block must list the pack with no `IMPORT FAILED` marker. An import failure is
+a pack bug or a missing dependency - fix that first; nothing downstream can
+work without a clean import.
+
+While you are here, note whether the pack ships frontend JS:
+
+```bash
+curl -s http://127.0.0.1:8288/extensions | python3 -c '
+import json, sys
+print(sum(1 for p in json.load(sys.stdin) if p.startswith("/extensions/<pack-dir-name>/")))
+'
+```
+
+Non-zero means the pack patches the frontend at runtime (restyled nodes,
+rebuilt widgets, injected page chrome). Write that down - it decides whether
+Step 6 needs the CI-parity run. Both "green locally, red on CI" failures in
+the first 5-pack onboarding came from exactly this.
+
+## Step 2 - read the pack's real node keys
+
+The manifest's `expectedNodes` are the pack's `object_info` keys (the same
+strings the API uses as `class_type`). They are NOT Python class names and
+NOT display names. Get them from the running backend:
+
+```bash
+curl -s http://127.0.0.1:8288/object_info | python3 -c '
+import json, sys
+d = json.load(sys.stdin)
+for key, node in sorted(d.items()):
+    if node.get("python_module") == "custom_nodes.<pack-dir-name>":
+        print(key)
+'
+```
+
+Real traps this step catches (each one shipped in a real pack):
+
+| Pack                   | Correct key         | Wrong guesses that look right                                                   |
+| ---------------------- | ------------------- | ------------------------------------------------------------------------------- |
+| ComfyUI_essentials     | `SimpleMathInt+`    | `SimpleMathInt` (keys carry a trailing `+`, except `DisplayAny` which has none) |
+| ComfyUI-KJNodes        | `INTConstant`       | `INT Constant` (that is the display name)                                       |
+| ComfyUI-Custom-Scripts | `ShowText\|pysssss` | `ShowText` (keys carry a `\|pysssss` suffix)                                    |
+| rgthree-comfy          | `Seed (rgthree)`    | `RgthreeSeed` (the Python class name)                                           |
+
+## Step 3 - pick the expected nodes
+
+Choose 2-3 nodes that are:
+
+- **Model-free**: no checkpoint / VAE / CLIP inputs, no file downloads. The
+  gate runs on CPU with no models installed. Constants, math, text, and
+  display nodes are ideal.
+- **Wireable into a chain**: at least one producer (has a typed output) and
+  one terminal node. A terminal node either has `output_node: true` in
+  `/object_info` (it terminates a workflow by itself) or you end the chain in
+  the core `PreviewAny` node, which accepts any type.
+
+Check a candidate's inputs, outputs, and `output_node` flag:
+
+```bash
+curl -s http://127.0.0.1:8288/object_info | python3 -c '
+import json, sys
+node = json.load(sys.stdin)["<exact key>"]
+print(json.dumps({k: node[k] for k in ("input", "output", "output_name", "output_node")}, indent=1))
+'
+```
+
+Every node you list in `expectedNodes` must appear in the run workflow: the
+run tier asserts each one actually executes on the backend.
+
+## Step 4 - author the run-tier workflow
+
+Add one JSON file under `browser_tests/assets/customNodes/`, named
+`<pack>_<what it does>_run.json`. Copy an existing asset as the template
+(`rgthree_seed_display_run.json` is the simplest two-node example;
+`was_number_text_run.json` shows a 3-node chain). It is the frontend
+workflow format, hand-authorable:
+
+- `nodes[].type` is the exact `object_info` key from Step 2.
+- `widgets_values` is an array in the node's widget order: the `input`
+  entries from `/object_info` in declaration order (`required` first, then
+  `optional`), keeping only widget-type inputs (INT, FLOAT, STRING, BOOLEAN,
+  and combo lists) and skipping any input whose options say
+  `"forceInput": true` (those are sockets, never widgets). A required input
+  that is neither a widget type nor `forceInput` (a custom type like
+  `NUMBER`) is also a socket: wire a link into it or the run fails on a
+  missing required input.
+- A link is one row in `links`: `[link_id, from_node_id, from_slot,
+to_node_id, to_slot, "TYPE"]`, plus the matching `link`/`links` ids on the
+  two nodes' `inputs`/`outputs` entries.
+- To wire INTO an input that would normally be a widget (no `forceInput`),
+  the input entry also needs a `"widget": { "name": "<input name>" }` key -
+  see `browser_tests/assets/vueNodes/linked-int-widget.json`.
+- Keep it tiny. Two to four nodes proving "this pack executes" is the whole
+  job; feature-depth testing belongs to the pack's own repo.
+- If the workflow needs a media file, reuse something already under
+  `browser_tests/assets/` (e.g. `plain_video.mp4`) - never commit new binary
+  assets. CI stages `plain_video.mp4` into the backend's `input/` dir; if
+  your workflow needs a different existing asset staged, extend the
+  `Stage run-tier assets` step in
+  `.github/workflows/ci-tests-custom-nodes.yaml`.
+- A media path in the workflow (e.g. `input/plain_video.mp4`) resolves
+  against the backend process's working directory, not the repo. Locally,
+  copy the file into the `input/` dir of the directory you launched
+  `main.py` from, or the run tier fails validation with
+  `Invalid file path` and the test reports `TIMEOUT`.
+
+## Step 5 - add the manifest row
+
+Append one object to `browser_tests/fixtures/data/customNodeManifest.json`:
+
+| Field                | Meaning                                                                                                                                                                                            |
+| -------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `pack`               | The pack's directory name under `custom_nodes/` (what `git clone` creates).                                                                                                                        |
+| `repo`               | The GitHub URL CI clones. Required non-empty.                                                                                                                                                      |
+| `pin`                | Commit SHA or tag CI checks out after cloning; `""` = default branch head. Pin when a pack breaks often; `""` also means new upstream regressions surface here first.                              |
+| `tiers`              | Which tiers run: `load` (registers + renders in both renderers), `connectivity` (typed links + slot drags), `run` (executes the workflow). Use all three unless a tier is impossible for the pack. |
+| `workflow`           | Path relative to `browser_tests/` of the Step 4 file. `""` only while the pack has no `run` tier.                                                                                                  |
+| `expectedNodes`      | The Step 2/3 keys. The load tier mounts each in both renderers; the run tier asserts each executes.                                                                                                |
+| `requiresGpu`        | `true` only if execution genuinely needs CUDA. Such packs cannot use the `run` tier on the CPU gate.                                                                                               |
+| `requiresModels`     | Model files the workflow needs (`[]` for the packs onboarded so far - keep it that way whenever possible).                                                                                         |
+| `timeoutMs`          | Per-test budget. `30000` unless the workflow does real work (video decode uses `90000`).                                                                                                           |
+| `vueNodesCompatible` | Optional, default `true`. See the policy below. Only ever set `false`, and only with evidence.                                                                                                     |
+
+`loadManifest()` (`browser_tests/fixtures/customNode/manifest.ts`) validates
+every row and fails loudly on a missing field, an empty `repo`, a misspelled
+tier, or a `run` tier with an empty `workflow`.
+
+## Step 6 - prove it green locally, in both environments
+
+### 6a - fast loop (dev server)
+
+```bash
+pnpm test:custom-nodes
+```
+
+Green means: every tier for every pack passes, zero skips, and the suite's
+zero-visible-errors invariant held (no error overlay, dialog, node error, or
+error toast at any point). Iterate here - it is the fastest loop.
+
+### 6b - CI-parity run (required if the pack ships frontend JS)
+
+The dev server never loads pack frontend JS (its `/extensions` list is
+core-only), so 6a exercises vanilla nodes. If Step 1 found frontend JS, a
+6a green proves nothing about the pack's real runtime behavior. CI serves
+the built frontend from the backend, so reproduce that exactly:
+
+```bash
+pnpm build
+# relaunch the test backend with the same flags plus:
+#   --front-end-root <repo>/dist
+# and make sure any run-tier media is in that process's input/ dir
+PLAYWRIGHT_TEST_URL=http://127.0.0.1:8288 pnpm exec playwright test \
+  browser_tests/tests/customNodes/ --config playwright.chrome.config.ts --workers=1
+```
+
+Both real failures during the first 5-pack onboarding only existed here:
+rgthree's progress bar shifted the canvas and broke slot-drag coordinates,
+and rgthree's Seed rebuilt a declared input as widget-only. Skipping 6b
+means discovering that class of problem one CI round at a time.
+
+### Failure classes and what they mean
+
+- **T0 fails only in the Vue Nodes pass** (the LiteGraph pass is green):
+  suspected Vue Nodes 2.0 incompatibility. Follow the policy below - do not
+  delete the pack, do not skip the test.
+- **Run tier fails with `PARTIAL`** (some expected nodes never executed):
+  either the backend is missing `--cache-none` (cached nodes emit no
+  `executing` event) or an expected node is not actually in the workflow.
+- **Run tier fails with an execution error**: the workflow JSON is wrong
+  (bad key, wrong `widgets_values` order, type-mismatched link) or the pack
+  cannot execute model-free. Fix the workflow or drop the node for a
+  simpler one.
+- **Connectivity reports zero planned pairs**: the pack's slots are all
+  wildcard or combo typed (both are excluded from pairing by design because
+  they bypass the real type compare). The pack still gets load/run coverage.
+- **Connectivity logs `widget-only on instance` exclusions**: the pack's own
+  frontend JS rebuilt a declared input as a widget-only control (rgthree's
+  Seed does this to `seed`), so there is no socket to wire. Recorded and
+  excluded, like wildcards - pack design, not a regression.
+- **Auto-run reports a node "not in cannotRunAlone"**: the node failed to
+  execute on pure defaults (validation reject, or a real exception from
+  degenerate defaults - empty expression, empty folder, no webcam). If the
+  node USED to run clean this is a regression; otherwise add it to the
+  row's `cannotRunAlone` baseline with the run log in the PR. The check is
+  two-way: a listed node that starts running clean fails the suite until
+  the stale entry is removed.
+- **Auto-run fails with `HUNG_BACKEND`**: a node blocked forever during
+  execution (the canonical case downloads a model at runtime and hangs
+  without network). The failure names the suspects and the remedy: add the
+  offender to `AUTO_RUN_EXCLUDE` in `allNodes.spec.ts` with its mechanism,
+  and restart the test backend (the hang is non-interruptible).
+- **Mount test fails on console errors**: a pack's JS logged real errors
+  while its nodes mounted. If it is pack-attributed noise with no visible
+  error surface (KJNodes' loader previews fetching `filename=undefined`),
+  add a scoped `CONSOLE_ERROR_ALLOWLIST` entry with the mechanism;
+  otherwise it is a finding.
+
+### The exception ledgers (all reasons on the record)
+
+Every escape hatch is a reviewed list whose entries carry the mechanism, so
+the gate stays honest and none can grow silently:
+
+| Ledger                       | Lives in               | Covers                                                                                     |
+| ---------------------------- | ---------------------- | ------------------------------------------------------------------------------------------ |
+| `vueIncompatibleNodes`       | manifest row           | node cannot mount under Vue Nodes 2.0 (evidence rule below)                                |
+| `cannotRunAlone`             | manifest row           | node cannot execute standalone on a bare backend; asserted both ways so entries cannot rot |
+| `AUTO_RUN_EXCLUDE`           | `allNodes.spec.ts`     | executing the node is unsafe on a bare backend (runtime downloads, hangs)                  |
+| `CONSOLE_ERROR_ALLOWLIST`    | `allNodes.spec.ts`     | pack-attributed console noise with no visible error surface                                |
+| `CONNECT_REJECTED_ALLOWLIST` | `connectivity.spec.ts` | pack JS legitimately vetoes a planned wiring                                               |
+| `ROUNDTRIP_LOST_ALLOWLIST`   | `connectivity.spec.ts` | pack's own serialize/configure drops links it manages itself                               |
+
+## Step 7 - push and watch CI
+
+The `CI: Tests Custom Nodes` job (gating) re-does Steps 1-6 from scratch on
+every PR: clones every manifest `repo` at its `pin`, pip-installs under CPU
+torch constraints, boots the backend, runs the suite, and fails on any
+install error, any test failure, or any skipped test. A new pack row is
+automatically picked up; no workflow edit is needed unless you must stage an
+extra asset (Step 4).
+
+If CI goes red where local was green, reproduce under the Step 6b
+environment before changing anything - the first such failure looked like
+upstream drift but was actually pack frontend JS that never loads under
+the dev server. Only after 6b reproduces it, decide: adjust the suite's
+expectation honestly (the way widget-only instance slots became a recorded
+exclusion) or, for genuine upstream drift (`pin: ""` tracks the pack's
+default branch head), pin the pack to its last good commit. Never paper
+over it with a skip.
+
+## Vue Nodes 2.0 compatibility policy
+
+Some packs only work under the LiteGraph canvas renderer and fail to mount
+under Vue Nodes 2.0. The suite must state that fact without producing false
+failures and without skipping tests:
+
+1. **Default**: every pack is assumed compatible. New rows omit
+   `vueNodesCompatible`.
+2. **Evidence rule**: set `"vueNodesCompatible": false` ONLY after the T0
+   Vue pass fails for the pack locally while the LiteGraph pass is green,
+   and the failure reproduces on a retry. A README grumble, a hunch, or an
+   old forum thread is not evidence. Record the evidence (the failing
+   assertion and the pack version) in the PR description of the change that
+   sets the flag. When only SOME of a pack's nodes fail to mount, use the
+   per-node `vueIncompatibleNodes` ledger in the manifest row instead of
+   flagging the whole pack - compatibility is per-node, not per-pack (all
+   823 nodes across the first 7 packs mount clean, so both mechanisms ship
+   unused; the every-node mount tier is what earns an entry).
+3. **Effect of `false`**: the load tier runs its LiteGraph pass only, and
+   the connectivity drag test does not drag that pack's edges under Vue
+   Nodes. The tests still run and pass their canvas assertions - nothing is
+   `test.skip`ped, so the CI skip gate stays honest. The run tier and the
+   connectivity contract sweep are renderer-independent (they never toggle
+   the Vue Nodes setting) and run for the pack regardless of the flag - a
+   flagged pack must still execute and wire cleanly there.
+4. **Un-flagging**: if a pack ships Vue Nodes support later, delete the flag
+   and prove T0 green in both passes locally.
+
+## Checklist
+
+- [ ] Pack installs clean on the test backend (no `IMPORT FAILED`)
+- [ ] Checked whether the pack ships frontend JS (Step 1 `/extensions` probe)
+- [ ] `expectedNodes` copied exactly from `/object_info` (Step 2 traps checked)
+- [ ] All expected nodes are model-free and present in the run workflow
+- [ ] Workflow JSON under `browser_tests/assets/customNodes/`, no new binaries
+- [ ] Any media staged into the backend's own `input/` dir locally (Step 4)
+- [ ] Manifest row appended with every field (Step 5 table)
+- [ ] `vueNodesCompatible` omitted, or set `false` with recorded evidence
+- [ ] 6a green: `pnpm test:custom-nodes` against the dev server, zero skips
+- [ ] 6b green when the pack ships frontend JS: built dist + backend-served run
+- [ ] Every-node tiers green: no unexplained mount/save-reload/auto-run
+      failures; any new ledger entry carries its mechanism
+- [ ] Pushed; `CI: Tests Custom Nodes` green on the PR

browser_tests/tests/customNodes/README.md

@@ -0,0 +1,115 @@
+# Custom-node regression suite
+
+Proves community custom-node packs work against this frontend across both
+renderers: nodes register, render under LiteGraph (canvas) AND Vue Nodes 2.0
+(DOM), and execute real workflows end to end. Manifest-driven: adding a pack
+is one JSON row, no new test code.
+
+## Prerequisites
+
+1. A ComfyUI backend on `127.0.0.1:8288` with every manifest pack (the
+   `pack` entries in `browser_tests/fixtures/data/customNodeManifest.json`)
+   and ComfyUI_devtools
+   installed. Launch it with `--multi-user` (the repo-wide browser-test
+   prerequisite; the fixture writes per-worker user settings and the suite
+   depends on them landing), `--cache-none` (repeat runs must re-execute
+   every node or the executed-set check fails honestly with `PARTIAL`), and
+   with `browser_tests/assets/plain_video.mp4` copied into its `input/` dir.
+2. The dev server proxying that backend:
+   `DEV_SERVER_COMFYUI_URL=http://127.0.0.1:8288 pnpm dev`
+
+## Running
+
+| Script                                 | What it does                                                                          |
+| -------------------------------------- | ------------------------------------------------------------------------------------- |
+| `pnpm test:custom-nodes`               | whole suite headless - the pass/fail gate (every tier passes, zero skips)             |
+| `pnpm test:custom-nodes:watch`         | headed slow-motion run of the browser tiers, hands-off watching                       |
+| `pnpm test:custom-nodes:debug`         | step through the browser tiers in the Playwright Inspector (F10 step, F8 resume)      |
+| `pnpm test:custom-nodes:impact-render` | Impact nodes render in both renderers (Inspector)                                     |
+| `pnpm test:custom-nodes:impact-run`    | Impact group workflow executes on the backend (Inspector)                             |
+| `pnpm test:custom-nodes:vhs-render`    | VHS nodes render in both renderers (Inspector)                                        |
+| `pnpm test:custom-nodes:vhs-run`       | VHS decodes a real video through its node chain (Inspector)                           |
+| `pnpm test:custom-nodes:connectivity`  | slot/type contract: type-paired links + real slot drags in both renderers (Inspector) |
+| `pnpm test:custom-nodes:self-check`    | watches the harness catch a deliberate execution error                                |
+
+Example - watch the VHS video-decode run step by step:
+
+```bash
+pnpm test:custom-nodes:vhs-run
+```
+
+Two windows open: the app under test and the Playwright Inspector. Press F10
+to execute one robot action at a time (workflow loads, queue fires, backend
+decodes the video), F8 to run to the end. While paused, look but do not click
+inside the app window - your clicks change the state the next assertion
+checks.
+
+Any `-g` pattern works against the generic scripts, e.g.
+`pnpm test:custom-nodes:debug -g "Impact-Pack.*T0"`.
+
+## What the tests assert
+
+- **T0 load**: pack nodes are registered in `/object_info`, added to a
+  cleared graph, counted exactly, and each added node's own `[data-node-id]`
+  element mounts under Vue Nodes 2.0. Both renderer passes - unless the pack
+  declares `vueNodesCompatible: false` in the manifest (evidence required;
+  see [ADDING_CUSTOM_NODES.md](ADDING_CUSTOM_NODES.md)), in which case its tests run their
+  LiteGraph-canvas assertions only. Never a skip.
+- **T1 run**: the manifest workflow is loaded and queued; the backend's
+  `executing` event stream must contain every expected node id, and the run
+  must end in `execution_success`.
+- **Every-node tiers** (`allNodes.spec.ts`): the pack's FULL node list,
+  discovered live from `/object_info`, is exercised with zero
+  configuration - every registered node mounts in both renderers (chunked
+  at an empirically calibrated batch size), survives a serialize/configure
+  save-reload round-trip, and executes for real on the backend when
+  self-sufficient (all required inputs are widgets with valid defaults).
+  Nodes that cannot run alone are classified and logged
+  (`NEEDS_WIRES` / `NEEDS_MODELS` / `NO_SINK` / rejected-at-validation),
+  never silently dropped; the documented exception ledgers (see
+  [ADDING_CUSTOM_NODES.md](ADDING_CUSTOM_NODES.md)) carry a written mechanism for every
+  escape hatch.
+- **connectivity (contract)**: wiring-only, no execution. A
+  type-pairing generator (`fixtures/customNode/typePairing.ts`) indexes
+  `/object_info` producers/consumers and plans one representative typed edge
+  per slot (wildcard `*` slots excluded - they bypass the real type compare
+  and prove nothing). Each planned edge must connect through the real
+  `isValidConnection` veto, then survive `serialize()` -> `configure()` and
+  appear in `graphToPrompt()` output. A curated subset is additionally
+  dragged for real - slot dot to slot dot - under both renderers. Orphan
+  types (no partner in the corpus) are reported, never fake-failed. One
+  representative edge per slot bounds cost; it does not prove all pairs.
+- **Zero visible errors, always**: every browser test asserts the app's
+  error surfaces (error overlay, error dialog, node render errors, error
+  toasts) are absent at start and after every pass. A run is green only if a
+  human watching the screen sees no errors. The self-check inverts this: it
+  forces a real execution error and asserts the overlay IS visible, proving
+  the selectors stay live.
+
+## Adding a pack
+
+One manifest row plus one small workflow JSON - no new test code. The
+authoritative step-by-step process (verifying the pack's real node keys,
+authoring the run workflow, the `vueNodesCompatible` evidence rule, what CI
+does with the row) lives in [ADDING_CUSTOM_NODES.md](ADDING_CUSTOM_NODES.md). Follow it
+exactly; the traps it lists all shipped in real packs.
+
+## Gotchas
+
+- **Pack frontend JS does not load under the Vite dev server.** The dev
+  server's `/extensions` endpoint lists core extensions only, so nodes render
+  vanilla locally even when the backend has the packs installed. CI serves
+  the built frontend from the backend, where every pack's JS loads and can
+  restyle nodes, rebuild widgets, or inject page chrome. Before pushing
+  changes that could interact with pack JS, reproduce CI locally:
+  `pnpm build`, relaunch the backend with `--front-end-root <repo>/dist`,
+  and run the suite with `PLAYWRIGHT_TEST_URL` pointed at the backend.
+- Do not run with `--trace on` against system Chrome
+  (`playwright.chrome.config.ts` pins trace off): the trace recorder crashes
+  pages under the branded Chrome channel and every test reports a bogus 15s
+  timeout.
+- In a git worktree whose `node_modules` is symlinked from another checkout,
+  prefix scripts with `pnpm --config.verify-deps-before-run=false ...` to
+  skip pnpm's auto-install check.
+- First run against a cold dev server can exceed the 15s per-test setup
+  budget while Vite compiles; just run again.

browser_tests/tests/customNodes/allNodes.spec.ts

@@ -0,0 +1,449 @@
+/* oxlint-disable playwright/no-skipped-test -- tiers conditionally skip when the target backend lacks the required packs; environment gating, not a disabled test */
+// Every-node coverage: the suite's core contract (mounts, survives
+// save/reload, executes when self-sufficient) applied to ALL nodes a pack
+// registers - not just the curated expectedNodes sentinels. Node lists come
+// from the live backend, so a pack update is covered the moment it installs.
+import type { Page } from '@playwright/test'
+
+import {
+  comfyExpect as expect,
+  comfyPageFixture as test
+} from '@e2e/fixtures/ComfyPage'
+import {
+  batchAutoRunnable,
+  planAutoRuns
+} from '@e2e/fixtures/customNode/autoRun'
+import { LocalDesktopTarget } from '@e2e/fixtures/customNode/ComfyTarget'
+import { loadManifest } from '@e2e/fixtures/customNode/manifest'
+import type { RawNodeDef } from '@e2e/fixtures/customNode/typePairing'
+import { normalizeNodeDefs } from '@e2e/fixtures/customNode/typePairing'
+import { collectConsoleErrors } from '@e2e/fixtures/utils/consoleErrorCollector'
+import {
+  customNodeSuiteSettings,
+  dismissTemplatesDialog
+} from '@e2e/fixtures/utils/customNodeSuite'
+import { errorSurfaces } from '@e2e/fixtures/utils/errorSurfaces'
+
+const target = new LocalDesktopTarget()
+
+// Empirically calibrated (browser_tests/tools/batchCalibration.spec.ts):
+// 24 was the largest chunk size with deterministic results across repeats
+// and the best per-node cost (6.6ms/node; smaller chunks pay per-chunk
+// overhead, larger ones pay fit-view and DOM density).
+const BATCH_SIZE = 24
+const AUTO_RUN_BATCH = 10
+const GRID_SPACING = { x: 420, y: 360 }
+
+// Nodes whose EXECUTION is unsafe on a bare sandboxed backend even though
+// their inputs classify as auto-runnable. Every entry names the mechanism.
+// The canonical case: a node that downloads a model at execution time hangs
+// a network-restricted backend in a non-interruptible call, jamming the
+// prompt queue for everything after it.
+const AUTO_RUN_EXCLUDE: Record<string, Record<string, string>> = {
+  'rgthree-comfy': {
+    'Power Primitive (rgthree)':
+      'requires its pack JS to build the primitive value at queue time; raw defaults KeyError. Whether a page applies pack JS varies by serving setup, so excluded unconditionally - curated-workflow candidate',
+    'Power Puter (rgthree)':
+      'requires its pack JS to compile the expression at queue time; raw defaults KeyError. Excluded unconditionally - curated-workflow candidate'
+  },
+  'ComfyUI-KJNodes': {
+    PointsEditor:
+      'requires its pack JS to inject the points JSON at queue time; raw defaults JSONDecodeError. Excluded unconditionally - curated-workflow candidate',
+    SplineEditor:
+      'requires its pack JS to inject the spline JSON at queue time; raw defaults JSONDecodeError. Excluded unconditionally - curated-workflow candidate',
+    StringToFloatList:
+      'requires its pack JS to normalize the list string at queue time; raw defaults ValueError. Excluded unconditionally - curated-workflow candidate'
+  },
+  ComfyUI_essentials: {
+    'RemBGSession+':
+      'initializes a rembg session that downloads its ONNX model at execution; hangs (non-interruptibly) on a backend without network/model access',
+    'TransitionMask+':
+      'list-expanded execution emits no per-node executing event on some runs, so the executed-set signal flip-flops between PASS and PARTIAL; mount/save-reload/connectivity tiers still cover it',
+    'TransparentBGSession+':
+      'ML-session initializer like RemBGSession+; sets up/downloads a background-removal model at execution, unstable on a bare backend'
+  }
+}
+
+// Pack-attributed console noise with no visible error surface. Every entry
+// names the mechanism; anything not matching stays a hard failure.
+const CONSOLE_ERROR_ALLOWLIST: Record<
+  string,
+  Array<{ pattern: RegExp; reason: string }>
+> = {
+  'ComfyUI-KJNodes': [
+    {
+      // Image/video loader previews fetch their combo value at creation;
+      // on a backend with an empty input dir the value is undefined and the
+      // preview 404s (and retries with a fresh rand). Console-only noise,
+      // no visible error; upstream-report candidate.
+      pattern:
+        /Failed to load resource.*\/api\/view\?type=input&filename=undefined/,
+      reason: 'loader preview fetches undefined filename on empty input dir'
+    }
+  ]
+}
+
+test.use({ initialSettings: customNodeSuiteSettings })
+
+test.beforeEach(async ({ comfyPage }) => {
+  await dismissTemplatesDialog(comfyPage)
+})
+
+async function expectNoVisibleErrors(
+  page: Page,
+  context: string
+): Promise<void> {
+  for (const [surface, locator] of Object.entries(errorSurfaces(page)))
+    await expect(locator, `${context}: ${surface}`).toHaveCount(0)
+}
+
+// One in-page round-trip per chunk: batch-add on a grid, fit the viewport.
+// Returns ids aligned with `types` (null = createNode failed).
+function addChunk(page: Page, types: string[]): Promise<Array<string | null>> {
+  return page.evaluate(
+    ([chunk, spacingX, spacingY]) => {
+      window.app!.graph.clear()
+      const cols = Math.ceil(Math.sqrt(chunk.length))
+      const ids: Array<string | null> = []
+      for (const [index, type] of chunk.entries()) {
+        const node = window.LiteGraph!.createNode(type)
+        if (!node) {
+          ids.push(null)
+          continue
+        }
+        node.pos = [
+          (index % cols) * (spacingX as number),
+          Math.floor(index / cols) * (spacingY as number)
+        ]
+        window.app!.graph.add(node)
+        ids.push(String(node.id))
+      }
+      const canvas = window.app!.canvas
+      const rect = canvas.canvas.getBoundingClientRect()
+      const width = cols * (spacingX as number)
+      const height = Math.ceil(chunk.length / cols) * (spacingY as number)
+      const scale = Math.min(
+        (rect.width / Math.max(width, 1)) * 0.9,
+        (rect.height / Math.max(height, 1)) * 0.9,
+        1
+      )
+      canvas.ds.scale = scale
+      canvas.ds.offset = [60 / scale, 60 / scale]
+      canvas.setDirty(true, true)
+      return ids
+    },
+    [types, GRID_SPACING.x, GRID_SPACING.y] as const
+  )
+}
+
+async function packNodeKeys(
+  page: Page,
+  pack: string
+): Promise<{ keys: string[]; defs: Record<string, RawNodeDef> }> {
+  const defs = (await page.evaluate(() =>
+    window.app!.api.getNodeDefs()
+  )) as unknown as Record<string, RawNodeDef>
+  const keys = normalizeNodeDefs(defs)
+    .filter((node) => node.pack === pack)
+    .map((node) => node.type)
+    .sort()
+  return { keys, defs }
+}
+
+for (const entry of loadManifest()) {
+  test.describe(`all nodes: ${entry.pack}`, () => {
+    test('every registered node mounts in both renderers', async ({
+      comfyPage
+    }) => {
+      test.setTimeout(240_000)
+      const { keys } = await packNodeKeys(comfyPage.page, entry.pack)
+      test.skip(
+        keys.length === 0,
+        `${entry.pack} not installed on this backend`
+      )
+      const ledger = entry.vueIncompatibleNodes ?? {}
+      for (const ledgered of Object.keys(ledger))
+        expect(
+          keys,
+          `stale ledger entry: ${ledgered} is not registered by ${entry.pack}`
+        ).toContain(ledgered)
+
+      for (const vueNodesEnabled of [false, true]) {
+        const consoleErrors = collectConsoleErrors(comfyPage.page)
+        await comfyPage.settings.setSetting(
+          'Comfy.VueNodes.Enabled',
+          vueNodesEnabled
+        )
+        const failures: string[] = []
+        for (let offset = 0; offset < keys.length; offset += BATCH_SIZE) {
+          const chunk = keys.slice(offset, offset + BATCH_SIZE)
+          const ids = await addChunk(comfyPage.page, chunk)
+          await comfyPage.nextFrame()
+          const count = await comfyPage.nodeOps.getGraphNodesCount()
+          if (count !== chunk.length)
+            failures.push(
+              `chunk@${offset}: graph has ${count} of ${chunk.length} nodes`
+            )
+          for (const [index, id] of ids.entries()) {
+            const key = chunk[index]
+            if (id === null) {
+              failures.push(`${key}: createNode returned null`)
+              continue
+            }
+            if (!vueNodesEnabled) continue
+            if (key in ledger) continue
+            const visible = await comfyPage.page
+              .locator(`[data-node-id="${id}"]`)
+              .isVisible({ timeout: 2_000 })
+              .catch(() => false)
+            if (!visible) failures.push(`${key}: no Vue mount`)
+          }
+        }
+        if (vueNodesEnabled && Object.keys(ledger).length > 0)
+          console.log(
+            `${entry.pack}: ${Object.keys(ledger).length} node(s) ledgered Vue-incompatible; Vue mount not asserted for them`
+          )
+        consoleErrors.stop()
+        expect(
+          failures,
+          `VueNodes=${vueNodesEnabled}: ${JSON.stringify(failures, null, 1)}`
+        ).toEqual([])
+        const allowlist = CONSOLE_ERROR_ALLOWLIST[entry.pack] ?? []
+        const allowed = consoleErrors.errors.filter((error) =>
+          allowlist.some((rule) => rule.pattern.test(error))
+        )
+        if (allowed.length > 0)
+          console.log(
+            `${entry.pack}: ${allowed.length} console error(s) matched the pack's allowlist (${allowlist.map((rule) => rule.reason).join('; ')})`
+          )
+        expect(
+          consoleErrors.errors.filter(
+            (error) => !allowlist.some((rule) => rule.pattern.test(error))
+          ),
+          `console errors with VueNodes=${vueNodesEnabled}`
+        ).toEqual([])
+        await expectNoVisibleErrors(
+          comfyPage.page,
+          `after all-nodes VueNodes=${vueNodesEnabled} pass`
+        )
+      }
+    })
+
+    test('every registered node survives save/reload', async ({
+      comfyPage
+    }) => {
+      test.setTimeout(240_000)
+      const { keys } = await packNodeKeys(comfyPage.page, entry.pack)
+      test.skip(
+        keys.length === 0,
+        `${entry.pack} not installed on this backend`
+      )
+      await comfyPage.settings.setSetting('Comfy.VueNodes.Enabled', false)
+
+      const mismatches: string[] = []
+      for (let offset = 0; offset < keys.length; offset += BATCH_SIZE) {
+        const chunk = keys.slice(offset, offset + BATCH_SIZE)
+        const chunkMismatches = await comfyPage.page.evaluate((types) => {
+          window.app!.graph.clear()
+          const before = new Map<
+            string,
+            { type: string; widgetValues: number }
+          >()
+          for (const type of types) {
+            const node = window.LiteGraph!.createNode(type)
+            if (!node) continue
+            window.app!.graph.add(node)
+            before.set(String(node.id), {
+              type,
+              widgetValues: (node.widgets ?? []).length
+            })
+          }
+          const serialized = window.app!.graph.serialize()
+          window.app!.graph.configure(serialized)
+          const problems: string[] = []
+          for (const [id, expected] of before) {
+            const restored = window.app!.graph.getNodeById(Number(id))
+            if (!restored) {
+              problems.push(`${expected.type}: lost on reload`)
+              continue
+            }
+            if (restored.type !== expected.type)
+              problems.push(
+                `${expected.type}: type became ${String(restored.type)}`
+              )
+            const widgets = (restored.widgets ?? []).length
+            if (widgets !== expected.widgetValues)
+              problems.push(
+                `${expected.type}: widgets ${expected.widgetValues} -> ${widgets}`
+              )
+          }
+          window.app!.graph.clear()
+          return problems
+        }, chunk)
+        mismatches.push(...chunkMismatches)
+      }
+      expect(mismatches, JSON.stringify(mismatches, null, 1)).toEqual([])
+      await expectNoVisibleErrors(comfyPage.page, 'after save/reload sweep')
+    })
+
+    test('every auto-runnable node executes without error', async ({
+      comfyPage
+    }) => {
+      test.setTimeout(900_000)
+      const { keys, defs } = await packNodeKeys(comfyPage.page, entry.pack)
+      test.skip(
+        keys.length === 0,
+        `${entry.pack} not installed on this backend`
+      )
+      await comfyPage.settings.setSetting('Comfy.VueNodes.Enabled', false)
+
+      // A hung execution from an earlier test would make every run below
+      // false-timeout; fail fast with the real cause instead.
+      const queueBusy = await comfyPage.page.evaluate(async () => {
+        const queue = (await window.app!.api.getQueue()) as {
+          Running?: unknown[]
+        }
+        return (queue.Running ?? []).length
+      })
+      expect(
+        queueBusy,
+        'backend queue already has a running prompt (earlier hung execution?) - restart the test backend'
+      ).toBe(0)
+
+      const excluded = AUTO_RUN_EXCLUDE[entry.pack] ?? {}
+      for (const [key, reason] of Object.entries(excluded))
+        console.log(`${entry.pack}: ${key} excluded from auto-run (${reason})`)
+      const verdicts = planAutoRuns(
+        defs,
+        keys.filter((key) => !(key in excluded))
+      )
+      const counts = new Map<string, number>()
+      for (const verdict of verdicts)
+        counts.set(verdict.verdict, (counts.get(verdict.verdict) ?? 0) + 1)
+      console.log(
+        `${entry.pack} auto-run plan: ${[...counts.entries()]
+          .map(([verdict, count]) => `${verdict}=${count}`)
+          .join(' ')}`
+      )
+
+      const batches = batchAutoRunnable(verdicts, AUTO_RUN_BATCH)
+      const hardFailures: string[] = []
+      // Nodes observed unable to run standalone: backend validation rejects
+      // their defaults, or execution errors on them (empty expressions,
+      // empty folders, no webcam). Reconciled against the committed
+      // cannotRunAlone baseline below - never silently dropped.
+      const cannotRun = new Map<string, string>()
+      const ranClean = new Set<string>()
+      for (const batch of batches) {
+        const outcome = await runBatch(comfyPage.page, batch)
+        if (outcome === 'PASS') {
+          for (const verdict of batch) ranClean.add(verdict.key)
+          continue
+        }
+        // A jammed queue makes every further run a false timeout - stop and
+        // name the suspects instead of bisecting through poisoned results.
+        if (outcome.startsWith('HUNG_BACKEND')) {
+          hardFailures.push(
+            `[${batch.map((verdict) => verdict.key).join(', ')}]: ${outcome} - add the offender to AUTO_RUN_EXCLUDE with its mechanism`
+          )
+          break
+        }
+        // Isolate: rerun each node alone so one bad node names itself
+        // instead of implicating its nine batch-mates.
+        for (const verdict of batch) {
+          const single = await runBatch(comfyPage.page, [verdict])
+          if (single === 'PASS') ranClean.add(verdict.key)
+          else if (single.startsWith('HUNG_BACKEND')) {
+            hardFailures.push(
+              `${verdict.key}: ${single} - add to AUTO_RUN_EXCLUDE with its mechanism`
+            )
+            break
+          } else cannotRun.set(verdict.key, single)
+        }
+      }
+      // Two-way baseline reconciliation. A failure missing from the baseline
+      // is a regression (a node that used to run clean broke); a baseline
+      // entry that now runs clean, or names a node that is not even
+      // auto-runnable, is stale and must be removed - the list cannot rot.
+      const baseline = new Set(entry.cannotRunAlone ?? [])
+      const runnable = new Set(
+        batches.flatMap((batch) => batch.map((verdict) => verdict.key))
+      )
+      for (const [key, detail] of cannotRun)
+        if (!baseline.has(key))
+          hardFailures.push(
+            `${key}: ${detail} - not in cannotRunAlone; a regression, or a new baseline entry (attach the run log)`
+          )
+      for (const key of baseline) {
+        if (ranClean.has(key))
+          hardFailures.push(
+            `${key}: ran clean but is listed in cannotRunAlone - remove the stale entry`
+          )
+        else if (!runnable.has(key))
+          hardFailures.push(
+            `${key}: listed in cannotRunAlone but is not auto-runnable on this backend - remove the stale entry`
+          )
+      }
+      console.log(
+        `${entry.pack} auto-ran ${ranClean.size} node(s) clean; ${cannotRun.size} cannot run alone (baseline ${baseline.size})`
+      )
+      expect(hardFailures, JSON.stringify(hardFailures, null, 1)).toEqual([])
+    })
+  })
+}
+
+async function runBatch(
+  page: Page,
+  batch: Array<{ key: string; needsPreviewSink?: boolean }>
+): Promise<string> {
+  const ids = await page.evaluate(
+    ([nodes, spacingY]) => {
+      window.app!.graph.clear()
+      const ids: string[] = []
+      for (const [index, spec] of nodes.entries()) {
+        const node = window.LiteGraph!.createNode(spec.key)
+        if (!node) continue
+        node.pos = [0, index * (spacingY as number)]
+        window.app!.graph.add(node)
+        ids.push(String(node.id))
+        if (spec.needsPreviewSink) {
+          const sink = window.LiteGraph!.createNode('PreviewAny')!
+          sink.pos = [460, index * (spacingY as number)]
+          window.app!.graph.add(sink)
+          node.connect(0, sink, 0)
+        }
+      }
+      return ids
+    },
+    [batch, GRID_SPACING.y] as const
+  )
+  // Auto-runnable nodes are widget-only and CPU-trivial; anything that has
+  // not finished in 20s is hung, and validation rejects return instantly.
+  const result = await target.runWorkflow(page, {
+    expectedNodeIds: ids,
+    timeoutMs: 20_000
+  })
+  if (result.outcome === 'TIMEOUT') {
+    // Leave no execution behind: an abandoned run jams the single prompt
+    // queue and every later run false-timeouts behind it. Interrupt, then
+    // verify the queue actually drained - a non-interruptible hang (e.g. a
+    // node blocked in a network download) can only be cleared by a backend
+    // restart, so name it instead of letting it poison the rest.
+    const drained = await page.evaluate(async () => {
+      await window.app!.api.interrupt()
+      for (let attempt = 0; attempt < 10; attempt++) {
+        await new Promise((resolve) => setTimeout(resolve, 500))
+        const queue = (await window.app!.api.getQueue()) as {
+          Running?: unknown[]
+        }
+        if ((queue.Running ?? []).length === 0) return true
+      }
+      return false
+    })
+    if (!drained)
+      return 'HUNG_BACKEND (non-interruptible execution; backend restart required)'
+  }
+  return result.outcome === 'PASS'
+    ? 'PASS'
+    : `${result.outcome}${result.error?.nodeType ? ` (${result.error.nodeType}: ${result.error.exceptionType ?? ''})` : ''}`
+}

browser_tests/tests/customNodes/autoRun.pure.spec.ts

@@ -0,0 +1,115 @@
+import {
+  comfyExpect as expect,
+  comfyPageFixture as test
+} from '@e2e/fixtures/ComfyPage'
+import {
+  batchAutoRunnable,
+  classifyAutoRunnable,
+  planAutoRuns
+} from '@e2e/fixtures/customNode/autoRun'
+
+test.describe('autoRun classifier', () => {
+  test('widget-only node with outputs is runnable via a PreviewAny sink', () => {
+    const verdict = classifyAutoRunnable('IntConstant', {
+      input: { required: { value: ['INT', { default: 0 }] } },
+      output: ['INT'],
+      output_node: false
+    })
+    expect(verdict.verdict).toBe('AUTO_RUNNABLE')
+    expect(verdict.needsPreviewSink).toBe(true)
+  })
+
+  test('widget-only OUTPUT_NODE runs standalone', () => {
+    const verdict = classifyAutoRunnable('ShowValue', {
+      input: {
+        required: {
+          text: ['STRING', {}],
+          mode: [['raw value', 'tensor shape']]
+        }
+      },
+      output: [],
+      output_node: true
+    })
+    expect(verdict.verdict).toBe('AUTO_RUNNABLE')
+    expect(verdict.needsPreviewSink).toBe(false)
+  })
+
+  test('a required socket input means NEEDS_WIRES', () => {
+    const verdict = classifyAutoRunnable('VaeDecode', {
+      input: { required: { samples: ['LATENT'], vae: ['VAE'] } },
+      output: ['IMAGE'],
+      output_node: false
+    })
+    expect(verdict.verdict).toBe('NEEDS_WIRES')
+    expect(verdict.reason).toContain('samples')
+  })
+
+  test('forceInput STRING is a socket, not a widget', () => {
+    const verdict = classifyAutoRunnable('TextSink', {
+      input: { required: { text: ['STRING', { forceInput: true }] } },
+      output: ['STRING'],
+      output_node: true
+    })
+    expect(verdict.verdict).toBe('NEEDS_WIRES')
+  })
+
+  test('an empty required combo means NEEDS_MODELS', () => {
+    const verdict = classifyAutoRunnable('CheckpointLoader', {
+      input: { required: { ckpt_name: [[]] } },
+      output: ['MODEL'],
+      output_node: false
+    })
+    expect(verdict.verdict).toBe('NEEDS_MODELS')
+    expect(verdict.reason).toContain('ckpt_name')
+  })
+
+  test('no outputs and not an OUTPUT_NODE means NO_SINK', () => {
+    const verdict = classifyAutoRunnable('SideEffectOnly', {
+      input: { required: { value: ['INT', {}] } },
+      output: [],
+      output_node: false
+    })
+    expect(verdict.verdict).toBe('NO_SINK')
+  })
+
+  test('optional socket inputs do not block auto-running', () => {
+    const verdict = classifyAutoRunnable('MathWithOptionalAny', {
+      input: {
+        required: { expression: ['STRING', {}] },
+        optional: { a: ['*'] }
+      },
+      output: ['INT', 'FLOAT'],
+      output_node: true
+    })
+    expect(verdict.verdict).toBe('AUTO_RUNNABLE')
+  })
+
+  test('planAutoRuns maps keys and batchAutoRunnable chunks only runnables', () => {
+    const defs = {
+      A: {
+        input: { required: { v: ['INT', {}] } },
+        output: ['INT'],
+        output_node: false
+      },
+      B: {
+        input: { required: { x: ['LATENT'] } },
+        output: ['LATENT'],
+        output_node: false
+      },
+      C: {
+        input: { required: { v: ['FLOAT', {}] } },
+        output: ['FLOAT'],
+        output_node: false
+      }
+    }
+    const verdicts = planAutoRuns(defs, ['A', 'B', 'C'])
+    expect(verdicts.map((verdict) => verdict.verdict)).toEqual([
+      'AUTO_RUNNABLE',
+      'NEEDS_WIRES',
+      'AUTO_RUNNABLE'
+    ])
+    const batches = batchAutoRunnable(verdicts, 1)
+    expect(batches).toHaveLength(2)
+    expect(batches[0][0].key).toBe('A')
+  })
+})

browser_tests/tests/customNodes/connectivity.spec.ts

@@ -0,0 +1,478 @@
+import type { Page } from '@playwright/test'
+
+import {
+  comfyExpect as expect,
+  comfyPageFixture as test
+} from '@e2e/fixtures/ComfyPage'
+import {
+  customNodeSuiteSettings,
+  dismissTemplatesDialog
+} from '@e2e/fixtures/utils/customNodeSuite'
+import { loadManifest } from '@e2e/fixtures/customNode/manifest'
+import type {
+  ConnectivityOutcome,
+  PlannedPair,
+  RawNodeDef
+} from '@e2e/fixtures/customNode/typePairing'
+import {
+  isWildcard,
+  normalizeNodeDefs,
+  planPairs
+} from '@e2e/fixtures/customNode/typePairing'
+import { collectConsoleErrors } from '@e2e/fixtures/utils/consoleErrorCollector'
+import { errorSurfaces } from '@e2e/fixtures/utils/errorSurfaces'
+
+const CORE_PROOF_NODE_COUNT = 16
+// A node may legitimately veto a wiring via onConnectInput; committed
+// entries here must name the veto. Green means actual rejections are a
+// subset of this list.
+const CONNECT_REJECTED_ALLOWLIST: string[] = [
+  // pysssss MathExpression only accepts INT/FLOAT-producing links into its
+  // expression variables; its JS vetoes text-list producers.
+  'AddTextPrefix.texts -> MathExpression|pysssss.expression'
+]
+// A pack's own serialize/configure hooks may drop inbound links it manages
+// itself; each committed entry must name the pack behavior. These reproduce
+// in manual use of those packs (wire, save, reload: the link is gone), so
+// they are pack behavior on record, not frontend regressions.
+const ROUNDTRIP_LOST_ALLOWLIST: string[] = [
+  // rgthree SDXL Power Prompt rebuilds its dimension widget-inputs during
+  // configure and drops inbound links to them.
+  'BatchCount+.INT -> SDXL Power Prompt - Positive (rgthree).target_width',
+  'BatchCount+.INT -> SDXL Power Prompt - Positive (rgthree).target_height',
+  'BatchCount+.INT -> SDXL Power Prompt - Positive (rgthree).crop_width',
+  'BatchCount+.INT -> SDXL Power Prompt - Positive (rgthree).crop_height',
+  'BatchCount+.INT -> SDXL Power Prompt - Simple / Negative (rgthree).target_width',
+  'BatchCount+.INT -> SDXL Power Prompt - Simple / Negative (rgthree).target_height',
+  'BatchCount+.INT -> SDXL Power Prompt - Simple / Negative (rgthree).crop_width',
+  'BatchCount+.INT -> SDXL Power Prompt - Simple / Negative (rgthree).crop_height',
+  // VHS_SelectLatest rebuilds its dynamic slots on configure, detaching
+  // links on both its inputs and outputs.
+  'AddTextPrefix.texts -> VHS_SelectLatest.filename_prefix',
+  'AddTextPrefix.texts -> VHS_SelectLatest.filename_postfix',
+  'VHS_SelectLatest.Filename -> AddLabel.font_color'
+]
+
+test.use({ initialSettings: customNodeSuiteSettings })
+
+test.beforeEach(async ({ comfyPage }) => {
+  await dismissTemplatesDialog(comfyPage)
+})
+
+async function expectNoVisibleErrors(
+  page: Page,
+  context: string
+): Promise<void> {
+  for (const [surface, locator] of Object.entries(errorSurfaces(page)))
+    await expect(locator, `${context}: ${surface}`).toHaveCount(0)
+}
+
+function concrete(slot: { type: string }): boolean {
+  return !isWildcard(slot.type)
+}
+
+function isEntryInstalled(
+  nodeTypes: Set<string>,
+  entry: { expectedNodes: string[] }
+): boolean {
+  return entry.expectedNodes.every((type) => nodeTypes.has(type))
+}
+
+const connectivityEntries = loadManifest().filter((entry) =>
+  entry.tiers.includes('connectivity')
+)
+
+test('connectivity: every type-paired link survives model, serialize, and prompt round-trips', async ({
+  comfyPage
+}) => {
+  test.setTimeout(120_000)
+  const defs = (await comfyPage.page.evaluate(() =>
+    window.app!.api.getNodeDefs()
+  )) as unknown as Record<string, RawNodeDef>
+  const nodes = normalizeNodeDefs(defs)
+
+  // Pack-specific expectations apply only where the pack is installed; on a
+  // backend without it (e.g. a generic CI runner) the core sweep still runs
+  // and the absence is reported, never fake-failed or fake-passed.
+  const nodeTypes = new Set(nodes.map((node) => node.type))
+  const installedEntries = connectivityEntries.filter((entry) =>
+    isEntryInstalled(nodeTypes, entry)
+  )
+  for (const entry of connectivityEntries)
+    if (!installedEntries.includes(entry))
+      console.log(`connectivity: ${entry.pack} not installed on this backend`)
+  // Sweep EVERY node the installed packs register, not just the curated
+  // expectedNodes sentinels - the corpus comes from the live backend, so a
+  // pack update is covered the moment it installs.
+  const installedPacks = new Set(installedEntries.map((entry) => entry.pack))
+  const packTypes = nodes
+    .filter((node) => installedPacks.has(node.pack))
+    .map((node) => node.type)
+  const coreProof = nodes
+    .filter(
+      (node) =>
+        node.pack === 'core' &&
+        node.inputs.some(concrete) &&
+        node.outputs.some(concrete)
+    )
+    .map((node) => node.type)
+    .sort()
+    .slice(0, CORE_PROOF_NODE_COUNT)
+  const plan = planPairs(nodes, [...packTypes, ...coreProof])
+
+  expect(plan.pairs.length, 'pairing produced no edges').toBeGreaterThan(0)
+  console.log(
+    `connectivity plan: ${plan.pairs.length} pairs, ${plan.orphans.length} orphan slots, ${plan.wildcards.length} wildcard + ${plan.combos.length} combo slots (excluded by design)`
+  )
+
+  for (const entry of installedEntries) {
+    expect(
+      plan.pairs.some(
+        (pair) =>
+          pair.producer.pack === entry.pack || pair.consumer.pack === entry.pack
+      ),
+      `${entry.pack} contributes no pairs - corpus or pack attribution broke`
+    ).toBe(true)
+  }
+
+  const consoleErrors = collectConsoleErrors(comfyPage.page)
+  const results = await runPairsInPage(comfyPage.page, plan.pairs)
+  consoleErrors.stop()
+  expect(consoleErrors.errors, 'console errors during breadth sweep').toEqual(
+    []
+  )
+
+  const widgetOnly = results.filter(
+    (result) =>
+      result.outcome ===
+      ('WIDGET_ONLY_ON_INSTANCE' satisfies ConnectivityOutcome)
+  )
+  if (widgetOnly.length > 0)
+    console.log(
+      `connectivity sweep: ${widgetOnly.length} pair(s) excluded - pack JS made the declared input widget-only: ${widgetOnly.map((result) => result.key).join('; ')}`
+    )
+  const failures = results.filter(
+    (result) =>
+      result.outcome !== ('PASS' satisfies ConnectivityOutcome) &&
+      result.outcome !==
+        ('WIDGET_ONLY_ON_INSTANCE' satisfies ConnectivityOutcome) &&
+      !(
+        result.outcome === ('CONNECT_REJECTED' satisfies ConnectivityOutcome) &&
+        CONNECT_REJECTED_ALLOWLIST.includes(result.key)
+      ) &&
+      !(
+        result.outcome === ('ROUNDTRIP_LOST' satisfies ConnectivityOutcome) &&
+        ROUNDTRIP_LOST_ALLOWLIST.includes(result.key)
+      )
+  )
+  const passed = results.filter((result) => result.outcome === 'PASS').length
+  console.log(`connectivity sweep: ${passed}/${results.length} pairs PASS`)
+  expect(failures, JSON.stringify(failures, null, 1)).toEqual([])
+  expect(passed).toBeGreaterThan(0)
+  await expectNoVisibleErrors(comfyPage.page, 'after breadth sweep')
+})
+
+// Instance-level probe for the drag test: the first planned pair whose
+// producer output AND consumer input both exist on freshly created node
+// instances (pack JS can rebuild declared inputs as widget-only controls).
+function firstMaterializedPair(
+  page: Page,
+  pairs: PlannedPair[]
+): Promise<PlannedPair | null> {
+  return page.evaluate((pairsInPage) => {
+    for (const pair of pairsInPage) {
+      const producer = window.LiteGraph!.createNode(pair.producer.nodeType)
+      const consumer = window.LiteGraph!.createNode(pair.consumer.nodeType)
+      const outFound = producer?.outputs.some(
+        (slot) => slot.name === pair.producer.slotName
+      )
+      const inFound = consumer?.inputs.some(
+        (slot) => slot.name === pair.consumer.slotName
+      )
+      if (outFound && inFound) return pair
+    }
+    return null
+  }, pairs)
+}
+
+// The self-check below runs THIS SAME executor on poisoned pairs; if it stops
+// being able to reject, every green sweep above is meaningless.
+function runPairsInPage(
+  page: Page,
+  pairs: PlannedPair[]
+): Promise<Array<{ key: string; outcome: string; detail?: string }>> {
+  return page.evaluate(async (pairsInPage) => {
+    const graph = window.app!.graph
+    const report: Array<{
+      key: string
+      outcome: string
+      detail?: string
+    }> = []
+    for (const pair of pairsInPage) {
+      const key = `${pair.producer.nodeType}.${pair.producer.slotName} -> ${pair.consumer.nodeType}.${pair.consumer.slotName}`
+      try {
+        graph.clear()
+        const producer = window.LiteGraph!.createNode(pair.producer.nodeType)
+        const consumer = window.LiteGraph!.createNode(pair.consumer.nodeType)
+        if (!producer || !consumer) {
+          report.push({
+            key,
+            outcome: 'SLOT_CONTRACT_MISMATCH',
+            detail: 'createNode returned null for a registered type'
+          })
+          continue
+        }
+        graph.add(producer)
+        graph.add(consumer)
+        const outIndex = producer.outputs.findIndex(
+          (slot) => slot.name === pair.producer.slotName
+        )
+        const inIndex = consumer.inputs.findIndex(
+          (slot) => slot.name === pair.consumer.slotName
+        )
+        if (outIndex < 0 || inIndex < 0) {
+          // A pack's own frontend JS may rebuild a declared input as a
+          // widget-only control (rgthree's Seed does this to `seed`). That is
+          // pack design, not a wiring regression - excluded like wildcards.
+          // A name that exists NEITHER as slot nor widget stays a hard fail.
+          const widgetOnly =
+            outIndex >= 0 &&
+            (consumer.widgets ?? []).some(
+              (widget) => widget.name === pair.consumer.slotName
+            )
+          report.push({
+            key,
+            outcome: widgetOnly
+              ? 'WIDGET_ONLY_ON_INSTANCE'
+              : 'SLOT_CONTRACT_MISMATCH',
+            detail: `declared slot missing on instance (out=${outIndex}, in=${inIndex})`
+          })
+          continue
+        }
+        const link = producer.connect(outIndex, consumer, inIndex)
+        if (!link || consumer.inputs[inIndex]?.link == null) {
+          report.push({ key, outcome: 'CONNECT_REJECTED' })
+          continue
+        }
+        const serialized = graph.serialize()
+        graph.configure(serialized)
+        const restored = graph.getNodeById(consumer.id)
+        if (restored?.inputs?.[inIndex]?.link == null) {
+          report.push({
+            key,
+            outcome: 'ROUNDTRIP_LOST',
+            detail: 'serialize/configure dropped the link'
+          })
+          continue
+        }
+        const prompt = (await window.app!.graphToPrompt()) as {
+          output?: Record<string, { inputs?: Record<string, unknown> }>
+        }
+        const promptInput =
+          prompt.output?.[String(consumer.id)]?.inputs?.[pair.consumer.slotName]
+        if (!Array.isArray(promptInput)) {
+          report.push({
+            key,
+            outcome: 'ROUNDTRIP_LOST',
+            detail: 'link missing from graphToPrompt output'
+          })
+          continue
+        }
+        report.push({ key, outcome: 'PASS' })
+      } catch (error) {
+        report.push({
+          key,
+          outcome: 'SLOT_CONTRACT_MISMATCH',
+          detail: `threw: ${String(error)}`
+        })
+      }
+    }
+    graph.clear()
+    return report
+  }, pairs)
+}
+
+test('connectivity self-check: the executor rejects broken pairs', async ({
+  comfyPage
+}) => {
+  const slot = (nodeType: string, slotName: string, slotType: string) => ({
+    nodeType,
+    pack: 'core',
+    slotName,
+    slotType
+  })
+  const results = await runPairsInPage(comfyPage.page, [
+    {
+      producer: slot('CheckpointLoaderSimple', 'MODEL', 'MODEL'),
+      consumer: slot('KSampler', 'latent_image', 'LATENT')
+    },
+    {
+      producer: slot('EmptyLatentImage', 'LATENT', 'LATENT'),
+      consumer: slot('KSampler', 'does_not_exist', 'LATENT')
+    }
+  ])
+  expect(results.map((result) => result.outcome)).toEqual([
+    'CONNECT_REJECTED',
+    'SLOT_CONTRACT_MISMATCH'
+  ])
+})
+
+test('connectivity drags: curated slot-to-slot wires connect under both renderers', async ({
+  comfyPage
+}) => {
+  test.setTimeout(120_000)
+  const defs = (await comfyPage.page.evaluate(() =>
+    window.app!.api.getNodeDefs()
+  )) as unknown as Record<string, RawNodeDef>
+  const nodes = normalizeNodeDefs(defs)
+
+  // Native anchor pair plus one in-pack, link-typed pair per connectivity
+  // pack (derived from the same generator the breadth sweep uses).
+  const dragEdges: PlannedPair[] = [
+    {
+      producer: {
+        nodeType: 'EmptyLatentImage',
+        pack: 'core',
+        slotName: 'LATENT',
+        slotType: 'LATENT'
+      },
+      consumer: {
+        nodeType: 'KSampler',
+        pack: 'core',
+        slotName: 'latent_image',
+        slotType: 'LATENT'
+      }
+    }
+  ]
+  const nodeTypes = new Set(nodes.map((node) => node.type))
+  for (const entry of connectivityEntries) {
+    if (!isEntryInstalled(nodeTypes, entry)) {
+      console.log(
+        `connectivity drag: ${entry.pack} not installed on this backend`
+      )
+      continue
+    }
+    // Restrict the partner pool to the pack itself so the drag proves an
+    // in-pack wiring; widget-backed primitive inputs render real slot dots
+    // in Vue (verified empirically), so no slot type is excluded at plan time.
+    const packPlan = planPairs(
+      nodes.filter((node) => node.pack === entry.pack),
+      entry.expectedNodes
+    )
+    expect(
+      packPlan.pairs.length,
+      `${entry.pack} has no in-pack draggable pair - drag coverage lost`
+    ).toBeGreaterThan(0)
+    // The plan comes from object_info, but a pack's own JS can rebuild a
+    // declared input as widget-only on the instance (rgthree's Seed does).
+    // Drag the first pair whose slots actually materialize; a pack whose
+    // every planned pair is customized away has no socket contract to drag.
+    const inPack = await firstMaterializedPair(comfyPage.page, packPlan.pairs)
+    if (!inPack) {
+      console.log(
+        `connectivity drag: ${entry.pack} planned pairs are widget-only on instances; drag not applicable`
+      )
+      continue
+    }
+    dragEdges.push(inPack)
+  }
+
+  const vueIncompatiblePacks = new Set(
+    connectivityEntries
+      .filter((entry) => entry.vueNodesCompatible === false)
+      .map((entry) => entry.pack)
+  )
+  for (const vueNodesEnabled of [false, true]) {
+    const consoleErrors = collectConsoleErrors(comfyPage.page)
+    await comfyPage.settings.setSetting(
+      'Comfy.VueNodes.Enabled',
+      vueNodesEnabled
+    )
+
+    for (const edge of dragEdges) {
+      if (vueNodesEnabled && vueIncompatiblePacks.has(edge.producer.pack)) {
+        console.log(
+          `connectivity drag: ${edge.producer.pack} declares vueNodesCompatible=false; Vue drag not applicable`
+        )
+        continue
+      }
+      await comfyPage.nodeOps.clearGraph()
+      const producer = await comfyPage.nodeOps.addNode(
+        edge.producer.nodeType,
+        undefined,
+        { x: 150, y: 200 }
+      )
+      const consumer = await comfyPage.nodeOps.addNode(
+        edge.consumer.nodeType,
+        undefined,
+        { x: 700, y: 200 }
+      )
+      await comfyPage.nextFrame()
+
+      const [outIndex, inIndex] = await comfyPage.page.evaluate(
+        ([producerId, consumerId, outName, inName]) => {
+          const byId = (id: string) =>
+            window.app!.graph.nodes.find((node) => String(node.id) === id)!
+          const src = byId(producerId)
+          const dst = byId(consumerId)
+          return [
+            src.outputs.findIndex((slot) => slot.name === outName),
+            dst.inputs.findIndex((slot) => slot.name === inName)
+          ]
+        },
+        [
+          String(producer.id),
+          String(consumer.id),
+          edge.producer.slotName,
+          edge.consumer.slotName
+        ] as const
+      )
+      const key = `${edge.producer.nodeType}.${edge.producer.slotName} -> ${edge.consumer.nodeType}.${edge.consumer.slotName}`
+      expect(outIndex, `${key}: producer slot on instance`).toBeGreaterThan(-1)
+      expect(inIndex, `${key}: consumer slot on instance`).toBeGreaterThan(-1)
+
+      if (vueNodesEnabled) {
+        await comfyPage.vueNodes.waitForNodes(2)
+        // Output-side mirror of getInputSlotConnectionDot, addressed by
+        // data-slot-key so shared-label ambiguity cannot misfire the drag.
+        const outDot = comfyPage.page
+          .locator(`[data-node-id="${String(producer.id)}"]`)
+          .locator('.lg-slot--output')
+          .filter({
+            has: comfyPage.page.locator(
+              `[data-slot-key="${String(producer.id)}-out-${outIndex}"]`
+            )
+          })
+          .getByTestId('slot-connection-dot')
+        const inDot = comfyPage.vueNodes.getInputSlotConnectionDot(
+          String(consumer.id),
+          inIndex
+        )
+        await outDot.dragTo(inDot)
+      } else {
+        await producer.connectOutput(outIndex, consumer, inIndex)
+      }
+
+      const linked = await comfyPage.page.evaluate(
+        ([consumerId, index]) => {
+          const node = window.app!.graph.nodes.find(
+            (candidate) => String(candidate.id) === consumerId
+          )
+          return node?.inputs?.[Number(index)]?.link != null
+        },
+        [String(consumer.id), String(inIndex)] as const
+      )
+      expect(linked, `${key} with VueNodes=${vueNodesEnabled}`).toBe(true)
+    }
+
+    consoleErrors.stop()
+    expect(
+      consoleErrors.errors,
+      `console errors with VueNodes=${vueNodesEnabled}`
+    ).toEqual([])
+    await expectNoVisibleErrors(
+      comfyPage.page,
+      `after drag pass VueNodes=${vueNodesEnabled}`
+    )
+  }
+})

browser_tests/tests/customNodes/coreSmoke.spec.ts

@@ -0,0 +1,58 @@
+import { readFileSync } from 'node:fs'
+import { resolve } from 'node:path'
+
+import type { ComfyWorkflowJSON } from '@/platform/workflow/validation/schemas/workflowSchema'
+import {
+  comfyExpect as expect,
+  comfyPageFixture as test
+} from '@e2e/fixtures/ComfyPage'
+import {
+  customNodeSuiteSettings,
+  dismissTemplatesDialog
+} from '@e2e/fixtures/utils/customNodeSuite'
+import { collectConsoleErrors } from '@e2e/fixtures/utils/consoleErrorCollector'
+import { errorSurfaces } from '@e2e/fixtures/utils/errorSurfaces'
+import { assetPath } from '@e2e/fixtures/utils/paths'
+
+// Core-only, model-free workflow: the bundled default template references
+// model files a scoped test backend does not have, which rightly trips the
+// error surfaces this suite asserts are clean.
+const smokeWorkflow = JSON.parse(
+  readFileSync(resolve(assetPath('customNodes/core_smoke.json')), 'utf-8')
+) as ComfyWorkflowJSON
+
+test.use({ initialSettings: customNodeSuiteSettings })
+
+test.beforeEach(async ({ comfyPage }) => {
+  await dismissTemplatesDialog(comfyPage)
+})
+
+test.describe('smoke: core workflow', () => {
+  test('loads without console errors in both renderers', async ({
+    comfyPage
+  }) => {
+    for (const vueNodesEnabled of [false, true]) {
+      const consoleErrors = collectConsoleErrors(comfyPage.page)
+      await comfyPage.settings.setSetting(
+        'Comfy.VueNodes.Enabled',
+        vueNodesEnabled
+      )
+      await comfyPage.workflow.loadGraphData(smokeWorkflow)
+      await comfyPage.nextFrame()
+      consoleErrors.stop()
+
+      expect(await comfyPage.nodeOps.getGraphNodesCount()).toBeGreaterThan(0)
+      expect(
+        consoleErrors.errors,
+        `console errors (VueNodes=${vueNodesEnabled})`
+      ).toEqual([])
+      for (const [surface, locator] of Object.entries(
+        errorSurfaces(comfyPage.page)
+      ))
+        await expect(
+          locator,
+          `${surface} (VueNodes=${vueNodesEnabled})`
+        ).toHaveCount(0)
+    }
+  })
+})

browser_tests/tests/customNodes/customNode.regression.spec.ts

@@ -0,0 +1,191 @@
+/* oxlint-disable playwright/no-skipped-test -- tiers conditionally skip when the target backend lacks the required packs (installed custom nodes or devtools); this is the framework's designed environment gating, not a disabled test */
+import { existsSync, readFileSync } from 'node:fs'
+import { resolve } from 'node:path'
+
+import type { Page } from '@playwright/test'
+
+import type { ComfyWorkflowJSON } from '@/platform/workflow/validation/schemas/workflowSchema'
+import {
+  comfyExpect as expect,
+  comfyPageFixture as test
+} from '@e2e/fixtures/ComfyPage'
+import {
+  customNodeSuiteSettings,
+  dismissTemplatesDialog
+} from '@e2e/fixtures/utils/customNodeSuite'
+import { LocalDesktopTarget } from '@e2e/fixtures/customNode/ComfyTarget'
+import {
+  loadManifest,
+  rendererPassesFor
+} from '@e2e/fixtures/customNode/manifest'
+import { expectedNodesPresent } from '@e2e/fixtures/customNode/objectInfoValidator'
+import { collectConsoleErrors } from '@e2e/fixtures/utils/consoleErrorCollector'
+import { errorSurfaces } from '@e2e/fixtures/utils/errorSurfaces'
+import { assetPath } from '@e2e/fixtures/utils/paths'
+
+const target = new LocalDesktopTarget()
+const OBJECT_INFO_SANITY_FLOOR = 50
+
+test.use({ initialSettings: customNodeSuiteSettings })
+
+test.beforeEach(async ({ comfyPage }) => {
+  await dismissTemplatesDialog(comfyPage)
+})
+
+async function expectNoVisibleErrors(
+  page: Page,
+  context: string
+): Promise<void> {
+  for (const [surface, locator] of Object.entries(errorSurfaces(page)))
+    await expect(locator, `${context}: ${surface}`).toHaveCount(0)
+}
+
+function readWorkflow(relativePath: string): ComfyWorkflowJSON {
+  return JSON.parse(
+    readFileSync(resolve(relativePath), 'utf-8')
+  ) as ComfyWorkflowJSON
+}
+
+async function nodeIdsByType(
+  page: Page,
+  classTypes: string[]
+): Promise<string[]> {
+  return await page.evaluate((types) => {
+    const nodes = window.app!.graph.nodes ?? []
+    return nodes
+      .filter((node) => {
+        const n = node as { comfyClass?: string; type?: string }
+        return types.includes(n.comfyClass ?? n.type ?? '')
+      })
+      .map((node) => String(node.id))
+  }, classTypes)
+}
+
+for (const entry of loadManifest()) {
+  const workflowRelative = `browser_tests/${entry.workflow}`
+
+  test.describe(`custom node: ${entry.pack}`, () => {
+    test('T0 load: expected nodes register and render in both renderers', async ({
+      comfyPage
+    }) => {
+      test.setTimeout(entry.timeoutMs)
+      const objectInfo = await target.getObjectInfo(comfyPage.page)
+      expect(
+        Object.keys(objectInfo).length,
+        'object_info sanity floor'
+      ).toBeGreaterThan(OBJECT_INFO_SANITY_FLOOR)
+      const { missing } = expectedNodesPresent(objectInfo, entry.expectedNodes)
+      test.skip(
+        missing.length > 0,
+        `${entry.pack} not installed on this backend (missing: ${missing.join(', ')})`
+      )
+      await expectNoVisibleErrors(comfyPage.page, 'at startup')
+
+      // A pack that declares vueNodesCompatible: false is exercised under the
+      // LiteGraph canvas only - rendering its nodes under Vue Nodes 2.0 would
+      // fail for a known pack limitation, not a frontend regression. This is
+      // conditional coverage, not a test skip: the test still runs and gates.
+      const rendererPasses = rendererPassesFor(entry)
+      if (entry.vueNodesCompatible === false)
+        console.log(
+          `${entry.pack} declares vueNodesCompatible=false; Vue Nodes pass not applicable`
+        )
+      for (const vueNodesEnabled of rendererPasses) {
+        const consoleErrors = collectConsoleErrors(comfyPage.page)
+        await comfyPage.settings.setSetting(
+          'Comfy.VueNodes.Enabled',
+          vueNodesEnabled
+        )
+        await comfyPage.nodeOps.clearGraph()
+
+        const addedIds: string[] = []
+        for (const classType of entry.expectedNodes) {
+          const node = await comfyPage.nodeOps.addNode(classType)
+          addedIds.push(String(node.id))
+        }
+        await comfyPage.nextFrame()
+
+        expect(await comfyPage.nodeOps.getGraphNodesCount()).toBe(
+          entry.expectedNodes.length
+        )
+        // Vue Nodes 2.0 mounts each node as a [data-node-id] element; assert
+        // the pack's own nodes rendered, not just any node count.
+        if (vueNodesEnabled)
+          for (const id of addedIds)
+            await expect(comfyPage.vueNodes.getNodeLocator(id)).toBeVisible()
+
+        consoleErrors.stop()
+        expect(
+          consoleErrors.errors,
+          `console errors with VueNodes=${vueNodesEnabled}`
+        ).toEqual([])
+        await expectNoVisibleErrors(
+          comfyPage.page,
+          `after VueNodes=${vueNodesEnabled} pass`
+        )
+      }
+    })
+
+    test('T1 run: workflow executes without error', async ({ comfyPage }) => {
+      test.setTimeout(entry.timeoutMs + 15_000)
+      const objectInfo = await target.getObjectInfo(comfyPage.page)
+      const { missing } = expectedNodesPresent(objectInfo, entry.expectedNodes)
+      test.skip(
+        !entry.tiers.includes('run') ||
+          missing.length > 0 ||
+          entry.requiresGpu ||
+          entry.requiresModels.length > 0 ||
+          !entry.workflow ||
+          !existsSync(resolve(workflowRelative)),
+        `run tier unavailable for ${entry.pack}`
+      )
+      await expectNoVisibleErrors(comfyPage.page, 'at startup')
+
+      await comfyPage.workflow.loadGraphData(readWorkflow(workflowRelative))
+      const result = await target.runWorkflow(comfyPage.page, {
+        expectedNodeIds: await nodeIdsByType(
+          comfyPage.page,
+          entry.expectedNodes
+        ),
+        timeoutMs: entry.timeoutMs
+      })
+
+      expect(result.outcome, JSON.stringify(result.error ?? {})).toBe('PASS')
+      await expectNoVisibleErrors(comfyPage.page, 'after run')
+    })
+  })
+}
+
+test('harness self-check: captures a real execution error', async ({
+  comfyPage
+}) => {
+  test.setTimeout(30_000)
+  const objectInfo = await target.getObjectInfo(comfyPage.page)
+  expect(
+    Object.keys(objectInfo).length,
+    'object_info sanity floor'
+  ).toBeGreaterThan(OBJECT_INFO_SANITY_FLOOR)
+  test.skip(
+    !('DevToolsErrorRaiseNode' in objectInfo),
+    'ComfyUI_devtools not installed on this backend'
+  )
+
+  await comfyPage.workflow.loadGraphData(
+    readWorkflow(assetPath('nodes/execution_error.json'))
+  )
+  const result = await target.runWorkflow(comfyPage.page, {
+    expectedNodeIds: [],
+    timeoutMs: 15000
+  })
+
+  expect(result.outcome).toBe('EXECUTION_ERROR')
+  expect(result.error?.exceptionType).toBeTruthy()
+  // Proves the event tap captures node ids from the live `executing` stream
+  // (its detail is a bare string): the failing node starts before it raises.
+  expect(result.executedNodes.length).toBeGreaterThan(0)
+  // Positive control for the zero-visible-errors invariant: a real execution
+  // error MUST surface in the app's error overlay. If this fails, the
+  // expectNoVisibleErrors selectors have rotted and every clean assertion in
+  // this suite is meaningless.
+  await expect(errorSurfaces(comfyPage.page).errorOverlay).toBeVisible()
+})

browser_tests/tests/customNodes/manifest.pure.spec.ts

@@ -0,0 +1,29 @@
+import {
+  comfyExpect as expect,
+  comfyPageFixture as test
+} from '@e2e/fixtures/ComfyPage'
+import {
+  loadManifest,
+  rendererPassesFor
+} from '@e2e/fixtures/customNode/manifest'
+
+test.describe('customNode manifest', () => {
+  test('loads entries with the shape the regression spec depends on', () => {
+    const entries = loadManifest()
+    expect(entries.length).toBeGreaterThan(0)
+    for (const entry of entries) {
+      expect(entry.pack).toBeTruthy()
+      expect(entry.expectedNodes.length).toBeGreaterThan(0)
+      expect(entry.tiers.length).toBeGreaterThan(0)
+    }
+  })
+
+  test('rendererPassesFor drops only the Vue pass, only on an explicit false', () => {
+    expect(rendererPassesFor({})).toEqual([false, true])
+    expect(rendererPassesFor({ vueNodesCompatible: true })).toEqual([
+      false,
+      true
+    ])
+    expect(rendererPassesFor({ vueNodesCompatible: false })).toEqual([false])
+  })
+})

browser_tests/tests/customNodes/objectInfoValidator.pure.spec.ts

@@ -0,0 +1,47 @@
+import {
+  comfyExpect as expect,
+  comfyPageFixture as test
+} from '@e2e/fixtures/ComfyPage'
+import type { ObjectInfo } from '@e2e/fixtures/customNode/objectInfoValidator'
+import {
+  expectedNodesPresent,
+  preValidate
+} from '@e2e/fixtures/customNode/objectInfoValidator'
+
+const objectInfo: ObjectInfo = {
+  KSampler: { input: { required: { model: {}, seed: {} } } }
+}
+
+test.describe('objectInfoValidator', () => {
+  test('expectedNodesPresent splits present from missing', () => {
+    const { present, missing } = expectedNodesPresent(objectInfo, [
+      'KSampler',
+      'Missing (rgthree)'
+    ])
+    expect(present).toEqual(['KSampler'])
+    expect(missing).toEqual(['Missing (rgthree)'])
+  })
+
+  test('preValidate returns MISSING_NODE for an unregistered class', () => {
+    const failure = preValidate(objectInfo, [
+      { id: '1', classType: 'Ghost', inputs: {} }
+    ])
+    expect(failure?.outcome).toBe('MISSING_NODE')
+  })
+
+  test('preValidate returns VALIDATION_FAIL naming the missing required input', () => {
+    const failure = preValidate(objectInfo, [
+      { id: '3', classType: 'KSampler', inputs: { model: 0 } }
+    ])
+    expect(failure?.outcome).toBe('VALIDATION_FAIL')
+    expect(failure?.message).toContain('missing required input "seed"')
+  })
+
+  test('preValidate passes when every required input is present', () => {
+    expect(
+      preValidate(objectInfo, [
+        { id: '3', classType: 'KSampler', inputs: { model: 0, seed: 1 } }
+      ])
+    ).toBeNull()
+  })
+})

browser_tests/tests/customNodes/runResult.pure.spec.ts

@@ -0,0 +1,71 @@
+import {
+  comfyExpect as expect,
+  comfyPageFixture as test
+} from '@e2e/fixtures/ComfyPage'
+import { classifyRun } from '@e2e/fixtures/customNode/runResult'
+
+test.describe('classifyRun', () => {
+  test('PASS when every expected node appears in the executing stream', () => {
+    const result = classifyRun({
+      events: [
+        { type: 'execution_start' },
+        { type: 'executing', node: '1' },
+        { type: 'executing', node: '2' },
+        { type: 'executing', node: null },
+        { type: 'execution_success' }
+      ],
+      expectedNodeIds: ['1', '2']
+    })
+    expect(result.outcome).toBe('PASS')
+    expect(result.executedNodes).toEqual(['1', '2'])
+  })
+
+  test('PARTIAL when a succeeding run replays a cached node that never emitted executing', () => {
+    const result = classifyRun({
+      events: [{ type: 'executing', node: '1' }, { type: 'execution_success' }],
+      expectedNodeIds: ['1', '2']
+    })
+    expect(result.outcome).toBe('PARTIAL')
+    expect(result.executedNodes).toEqual(['1'])
+  })
+
+  test('EXECUTION_ERROR captures the failing node details', () => {
+    const result = classifyRun({
+      events: [
+        { type: 'executing', node: '1' },
+        {
+          type: 'execution_error',
+          error: { exceptionType: 'ValueError', nodeId: '1' }
+        }
+      ],
+      expectedNodeIds: ['1']
+    })
+    expect(result.outcome).toBe('EXECUTION_ERROR')
+    expect(result.error?.exceptionType).toBe('ValueError')
+  })
+
+  test('EXECUTION_ERROR when the run is interrupted', () => {
+    const result = classifyRun({
+      events: [
+        { type: 'executing', node: '1' },
+        { type: 'execution_interrupted' }
+      ],
+      expectedNodeIds: ['1']
+    })
+    expect(result.outcome).toBe('EXECUTION_ERROR')
+  })
+
+  test('TIMEOUT when flagged or when no terminal event arrived', () => {
+    const flagged = classifyRun({
+      events: [{ type: 'executing', node: '1' }],
+      expectedNodeIds: ['1'],
+      timedOut: true
+    })
+    const noTerminal = classifyRun({
+      events: [{ type: 'executing', node: '1' }],
+      expectedNodeIds: ['1']
+    })
+    expect(flagged.outcome).toBe('TIMEOUT')
+    expect(noTerminal.outcome).toBe('TIMEOUT')
+  })
+})

browser_tests/tests/customNodes/typePairing.pure.spec.ts

@@ -0,0 +1,139 @@
+import {
+  comfyExpect as expect,
+  comfyPageFixture as test
+} from '@e2e/fixtures/ComfyPage'
+import type { RawNodeDef } from '@e2e/fixtures/customNode/typePairing'
+import {
+  isTypeCompatible,
+  normalizeNodeDefs,
+  packOf,
+  planPairs
+} from '@e2e/fixtures/customNode/typePairing'
+
+const DEFS: Record<string, RawNodeDef> = {
+  LatentSource: {
+    input: { required: {} },
+    output: ['LATENT'],
+    output_name: ['LATENT'],
+    python_module: 'nodes'
+  },
+  LatentSink: {
+    input: { required: { latent: ['LATENT', {}] } },
+    output: [],
+    python_module: 'custom_nodes.SomePack'
+  },
+  UnionSource: {
+    input: { required: {} },
+    output: ['STRING,INT'],
+    output_name: ['value'],
+    python_module: 'nodes'
+  },
+  IntSink: {
+    input: { required: { value: ['int', {}] } },
+    output: [],
+    python_module: 'nodes'
+  },
+  ComboNode: {
+    input: { required: { choice: [['a', 'b'], {}] } },
+    output: [],
+    python_module: 'nodes'
+  },
+  SocketlessNode: {
+    input: { required: { hidden: ['STRING', { socketless: true }] } },
+    output: [],
+    python_module: 'nodes'
+  },
+  WildcardNode: {
+    input: { required: { anything: ['*', {}] } },
+    output: ['*'],
+    output_name: ['out'],
+    python_module: 'nodes'
+  },
+  OrphanNode: {
+    input: { required: {} },
+    output: ['NOBODY_CONSUMES_THIS'],
+    output_name: ['orphan'],
+    python_module: 'custom_nodes.OrphanPack'
+  }
+}
+
+test.describe('typePairing', () => {
+  test('isTypeCompatible mirrors the real validator semantics', () => {
+    expect(isTypeCompatible('LATENT', 'LATENT')).toBe(true)
+    expect(isTypeCompatible('latent', 'LATENT')).toBe(true)
+    expect(isTypeCompatible('LATENT', 'IMAGE')).toBe(false)
+    expect(isTypeCompatible('STRING,INT', 'INT')).toBe(true)
+    expect(isTypeCompatible('STRING,INT', 'FLOAT')).toBe(false)
+    expect(isTypeCompatible('*', 'ANYTHING')).toBe(true)
+    expect(isTypeCompatible('', 'ANYTHING')).toBe(true)
+  })
+
+  test('packOf attributes core vs custom pack', () => {
+    expect(packOf('nodes')).toBe('core')
+    expect(packOf('comfy_extras.nodes_x')).toBe('core')
+    expect(packOf('custom_nodes.ComfyUI-Impact-Pack')).toBe(
+      'ComfyUI-Impact-Pack'
+    )
+    expect(packOf(undefined)).toBe('core')
+  })
+
+  test('normalize maps COMBO literals and drops socketless inputs', () => {
+    const nodes = normalizeNodeDefs(DEFS)
+    const combo = nodes.find((n) => n.type === 'ComboNode')!
+    expect(combo.inputs).toEqual([{ name: 'choice', type: 'COMBO' }])
+    const socketless = nodes.find((n) => n.type === 'SocketlessNode')!
+    expect(socketless.inputs).toEqual([])
+  })
+
+  test('planPairs pairs exact and union types, deterministically', () => {
+    const nodes = normalizeNodeDefs(DEFS)
+    const plan = planPairs(nodes, ['LatentSink', 'IntSink'])
+    const keys = plan.pairs.map(
+      (p) =>
+        `${p.producer.nodeType}.${p.producer.slotName}->${p.consumer.nodeType}.${p.consumer.slotName}`
+    )
+    expect(keys).toContain('LatentSource.LATENT->LatentSink.latent')
+    expect(keys).toContain('UnionSource.value->IntSink.value')
+    const again = planPairs(nodes, ['LatentSink', 'IntSink'])
+    expect(again.pairs).toEqual(plan.pairs)
+  })
+
+  test('COMBO literals are excluded from pairing with names coerced to strings', () => {
+    const nodes = normalizeNodeDefs({
+      ComboSource: {
+        input: { required: {} },
+        output: [['A', 'B', 'C']],
+        output_name: [['A', 'B', 'C'] as unknown as string],
+        python_module: 'nodes'
+      },
+      ...DEFS
+    })
+    const source = nodes.find((n) => n.type === 'ComboSource')!
+    expect(source.outputs).toEqual([{ name: 'COMBO', type: 'COMBO' }])
+    const plan = planPairs(nodes, ['ComboSource', 'ComboNode'])
+    expect(plan.pairs).toEqual([])
+    expect(plan.combos.map((s) => `${s.nodeType}.${s.slotName}`)).toEqual([
+      'ComboSource.COMBO',
+      'ComboNode.choice'
+    ])
+  })
+
+  test('wildcard slots are excluded, orphan types recorded not failed', () => {
+    const nodes = normalizeNodeDefs(DEFS)
+    const plan = planPairs(nodes, ['WildcardNode', 'OrphanNode'])
+    expect(plan.wildcards.map((w) => w.nodeType)).toEqual([
+      'WildcardNode',
+      'WildcardNode'
+    ])
+    expect(plan.orphans).toEqual([
+      {
+        nodeType: 'OrphanNode',
+        pack: 'OrphanPack',
+        slotName: 'orphan',
+        slotType: 'NOBODY_CONSUMES_THIS',
+        dir: 'out'
+      }
+    ])
+    expect(plan.pairs).toEqual([])
+  })
+})

browser_tests/tests/dialogs/pricingTableDeepLink.spec.ts

@@ -28,12 +28,7 @@ const APP_URL = process.env.PLAYWRIGHT_TEST_URL || 'http://localhost:8188'
 // matches it against the members self-row.
 const SELF_EMAIL = 'e2e@test.comfy.org'
 
-// consolidated_billing_enabled routes personal workspaces to the unified
-// pricing table asserted here; without it they fall back to the legacy table.
-const BOOT_FEATURES = {
-  team_workspaces_enabled: true,
-  consolidated_billing_enabled: true
-} satisfies RemoteConfig
+const BOOT_FEATURES = { team_workspaces_enabled: true } satisfies RemoteConfig
 // Disable the experimental Asset API: with it on (cloud default) the unmocked
 // asset endpoints 403 and workflow restore throws uncaught, aborting the
 // GraphCanvas onMounted chain before the deep-link loader.

browser_tests/tools/batchCalibration.spec.ts

@@ -0,0 +1,171 @@
+// Measurement tool, not a gate: finds the largest mount-check batch size that
+// is deterministic (identical results across repeats) and fast, for the
+// all-nodes load tier. Run explicitly against a backend with the manifest
+// packs installed and pack JS loaded (dist-serving; see ADDING_CUSTOM_NODES 6b):
+//   CN_CALIBRATE=1 PLAYWRIGHT_TEST_URL=http://127.0.0.1:8288 \
+//     pnpm exec playwright test browser_tests/tools/batchCalibration.spec.ts \
+//     --config playwright.chrome.config.ts --workers=1
+// Skipped everywhere else; the gating custom-nodes CI job is path-scoped to
+// tests/customNodes/ and never sees this file.
+/* oxlint-disable playwright/no-skipped-test -- opt-in measurement tool */
+import {
+  comfyExpect as expect,
+  comfyPageFixture as test
+} from '@e2e/fixtures/ComfyPage'
+import type { RawNodeDef } from '@e2e/fixtures/customNode/typePairing'
+import { normalizeNodeDefs } from '@e2e/fixtures/customNode/typePairing'
+import {
+  customNodeSuiteSettings,
+  dismissTemplatesDialog
+} from '@e2e/fixtures/utils/customNodeSuite'
+
+const CALIBRATION_PACKS = [
+  'ComfyUI-Impact-Pack',
+  'ComfyUI-VideoHelperSuite',
+  'rgthree-comfy',
+  'ComfyUI_essentials',
+  'ComfyUI-KJNodes',
+  'ComfyUI-Custom-Scripts',
+  'was-node-suite-comfyui'
+]
+const SAMPLE_SIZE = 120
+// Divisors of SAMPLE_SIZE so every size covers the identical node set.
+const CHUNK_SIZES = [4, 8, 12, 24, 40, 60]
+const REPEATS = 3
+const GRID_SPACING = { x: 420, y: 360 }
+const VISIBLE_TIMEOUT_MS = 500
+
+test.use({ initialSettings: customNodeSuiteSettings })
+
+test.beforeEach(async ({ comfyPage }) => {
+  await dismissTemplatesDialog(comfyPage)
+})
+
+test('batch-size calibration for all-nodes mount checks', async ({
+  comfyPage
+}) => {
+  test.skip(
+    process.env.CN_CALIBRATE !== '1',
+    'calibration tool - set CN_CALIBRATE=1 and run against a pack-loaded backend'
+  )
+  test.setTimeout(1_800_000)
+
+  const defs = (await comfyPage.page.evaluate(() =>
+    window.app!.api.getNodeDefs()
+  )) as unknown as Record<string, RawNodeDef>
+  const packNodes = normalizeNodeDefs(defs)
+    .filter((node) => CALIBRATION_PACKS.includes(node.pack))
+    .sort((a, b) => a.type.localeCompare(b.type))
+
+  // Round-robin across packs so the sample mixes heavy-JS nodes (rgthree,
+  // pysssss) with bulk packs instead of alphabetically front-loading one pack.
+  const byPack = new Map<string, string[]>()
+  for (const node of packNodes) {
+    const list = byPack.get(node.pack) ?? []
+    list.push(node.type)
+    byPack.set(node.pack, list)
+  }
+  const sample: string[] = []
+  for (let i = 0; sample.length < SAMPLE_SIZE; i++) {
+    let took = false
+    for (const pack of CALIBRATION_PACKS) {
+      const list = byPack.get(pack) ?? []
+      if (i < list.length && sample.length < SAMPLE_SIZE) {
+        sample.push(list[i])
+        took = true
+      }
+    }
+    if (!took) break
+  }
+  expect(sample, 'sample size').toHaveLength(SAMPLE_SIZE)
+
+  await comfyPage.settings.setSetting('Comfy.VueNodes.Enabled', true)
+
+  const results: Array<{
+    size: number
+    repeat: number
+    msPerNode: number
+    missing: string[]
+  }> = []
+
+  for (const size of CHUNK_SIZES) {
+    for (let repeat = 0; repeat < REPEATS; repeat++) {
+      const started = Date.now()
+      const missing: string[] = []
+      for (let offset = 0; offset < sample.length; offset += size) {
+        const chunk = sample.slice(offset, offset + size)
+        const ids = await comfyPage.page.evaluate(
+          ([types, spacingX, spacingY]) => {
+            window.app!.graph.clear()
+            const cols = Math.ceil(Math.sqrt(types.length))
+            const ids: Array<string | null> = []
+            for (const [index, type] of types.entries()) {
+              const node = window.LiteGraph!.createNode(type)
+              if (!node) {
+                ids.push(null)
+                continue
+              }
+              node.pos = [
+                (index % cols) * (spacingX as number),
+                Math.floor(index / cols) * (spacingY as number)
+              ]
+              window.app!.graph.add(node)
+              ids.push(String(node.id))
+            }
+            // Fit the whole grid into the viewport so an off-screen node is a
+            // culling result we measure, not a guaranteed miss.
+            const canvas = window.app!.canvas
+            const rect = canvas.canvas.getBoundingClientRect()
+            const width = cols * (spacingX as number)
+            const height = Math.ceil(types.length / cols) * (spacingY as number)
+            const scale = Math.min(
+              (rect.width / Math.max(width, 1)) * 0.9,
+              (rect.height / Math.max(height, 1)) * 0.9,
+              1
+            )
+            canvas.ds.scale = scale
+            canvas.ds.offset = [60 / scale, 60 / scale]
+            canvas.setDirty(true, true)
+            return ids
+          },
+          [chunk, GRID_SPACING.x, GRID_SPACING.y] as const
+        )
+        await comfyPage.nextFrame()
+        for (const [index, id] of ids.entries()) {
+          if (id === null) {
+            missing.push(`${chunk[index]} (createNode null)`)
+            continue
+          }
+          const visible = await comfyPage.page
+            .locator(`[data-node-id="${id}"]`)
+            .isVisible({ timeout: VISIBLE_TIMEOUT_MS })
+            .catch(() => false)
+          if (!visible) missing.push(chunk[index])
+        }
+      }
+      const msPerNode = (Date.now() - started) / sample.length
+      results.push({
+        size,
+        repeat,
+        msPerNode: Math.round(msPerNode * 10) / 10,
+        missing: missing.sort()
+      })
+      console.log(
+        `CALIB size=${size} repeat=${repeat} msPerNode=${msPerNode.toFixed(1)} missing=${missing.length}`
+      )
+    }
+  }
+
+  // Determinism verdict per size: the missing-set must be identical across
+  // repeats. Report everything; selection happens in the PR, from this data.
+  for (const size of CHUNK_SIZES) {
+    const runs = results.filter((result) => result.size === size)
+    const signatures = new Set(runs.map((run) => run.missing.join('|')))
+    const avg = runs.reduce((sum, run) => sum + run.msPerNode, 0) / runs.length
+    console.log(
+      `CALIB-SUMMARY size=${size} deterministic=${signatures.size === 1} avgMsPerNode=${avg.toFixed(1)} missing=${runs[0].missing.length}`
+    )
+  }
+  console.log('CALIB-MISSING ' + JSON.stringify(results[0].missing))
+  expect(results).toHaveLength(CHUNK_SIZES.length * REPEATS)
+})

package.json

@@ -52,6 +52,15 @@
     "test:browser": "pnpm exec playwright test",
     "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:custom-nodes": "cross-env PLAYWRIGHT_TEST_URL=http://localhost:5173 pnpm exec playwright test browser_tests/tests/customNodes/ --config playwright.chrome.config.ts --workers=1",
+    "test:custom-nodes:watch": "cross-env PLAYWRIGHT_TEST_URL=http://localhost:5173 PLAYWRIGHT_LOCAL=1 SLOW_MO=300 pnpm exec playwright test browser_tests/tests/customNodes/customNode.regression.spec.ts browser_tests/tests/customNodes/connectivity.spec.ts --config playwright.chrome.config.ts --workers=1 --headed",
+    "test:custom-nodes:debug": "cross-env PLAYWRIGHT_TEST_URL=http://localhost:5173 pnpm exec playwright test browser_tests/tests/customNodes/customNode.regression.spec.ts browser_tests/tests/customNodes/connectivity.spec.ts --config playwright.chrome.config.ts --workers=1 --debug",
+    "test:custom-nodes:impact-render": "pnpm test:custom-nodes:debug -g \"ComfyUI-Impact-Pack.*T0\"",
+    "test:custom-nodes:impact-run": "pnpm test:custom-nodes:debug -g \"ComfyUI-Impact-Pack.*T1\"",
+    "test:custom-nodes:vhs-render": "pnpm test:custom-nodes:debug -g \"VideoHelperSuite.*T0\"",
+    "test:custom-nodes:vhs-run": "pnpm test:custom-nodes:debug -g \"VideoHelperSuite.*T1\"",
+    "test:custom-nodes:connectivity": "pnpm test:custom-nodes:debug -g \"connectivity\"",
+    "test:custom-nodes:self-check": "pnpm test:custom-nodes:watch -g \"self-check\"",
     "test:coverage": "vitest run --coverage",
     "test:coverage:critical": "cross-env COVERAGE_CRITICAL=true vitest run --coverage",
     "test:unit": "vitest run",

playwright.chrome.config.ts

@@ -0,0 +1,10 @@
+import { defineConfig } from '@playwright/test'
+
+import base from './playwright.config'
+
+// Run against the system-installed Google Chrome (no bundled-chromium download).
+// trace stays off: Playwright's trace recorder crashes pages under the branded
+// Chrome channel on this machine (instant browser close, reported as timeout).
+export default defineConfig(base, {
+  use: { channel: 'chrome', video: 'off', trace: 'off' }
+})

src/components/dialog/content/TopUpCreditsDialogContentLegacy.vue

@@ -158,8 +158,8 @@ import { creditsToUsd, usdToCredits } from '@/base/credits/comfyCredits'
 import Button from '@/components/ui/button/Button.vue'
 import FormattedNumberStepper from '@/components/ui/stepper/FormattedNumberStepper.vue'
 import { useAuthActions } from '@/composables/auth/useAuthActions'
-import { useBillingRouting } from '@/composables/billing/useBillingRouting'
 import { useExternalLink } from '@/composables/useExternalLink'
+import { useFeatureFlags } from '@/composables/useFeatureFlags'
 import { useSubscription } from '@/platform/cloud/subscription/composables/useSubscription'
 import { useTelemetry } from '@/platform/telemetry'
 import { clearTopupTracking } from '@/platform/telemetry/topupTracker'
@@ -178,7 +178,7 @@ const settingsDialog = useSettingsDialog()
 const telemetry = useTelemetry()
 const toast = useToast()
 const { buildDocsUrl, docsPaths } = useExternalLink()
-const { shouldUseWorkspaceBilling } = useBillingRouting()
+const { flags } = useFeatureFlags()
 
 const { isSubscriptionEnabled } = useSubscription()
 // Constants
@@ -260,9 +260,9 @@ async function handleBuy() {
     // Close top-up dialog (keep tracking) and open credits panel to show updated balance
     handleClose(false)
 
-    // On the consolidated (workspace) billing flow, show the workspace settings
-    // panel; otherwise show the legacy subscription/credits panel.
-    const settingsPanel = shouldUseWorkspaceBilling.value
+    // In workspace mode (personal workspace), show workspace settings panel
+    // Otherwise, show legacy subscription/credits panel
+    const settingsPanel = flags.teamWorkspacesEnabled
       ? 'workspace'
       : isSubscriptionEnabled()
         ? 'subscription'

src/components/dialog/content/setting/UsageLogsTable.test.ts

@@ -2,11 +2,12 @@ import { createTestingPinia } from '@pinia/testing'
 import PrimeVue from 'primevue/config'
 import Tooltip from 'primevue/tooltip'
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
-import { defineComponent, nextTick, onMounted, ref } from 'vue'
+import { defineComponent, onMounted, ref } from 'vue'
 import { createI18n } from 'vue-i18n'
 
 import { render, screen, waitFor } from '@testing-library/vue'
 
+import type * as DistributionTypes from '@/platform/distribution/types'
 import type { AuditLog } from '@/services/customerEventsService'
 import { EventType } from '@/services/customerEventsService'
 
@@ -34,29 +35,19 @@ vi.mock('@/services/customerEventsService', () => ({
   }
 }))
 
-const mockTelemetry = vi.hoisted(() => ({
-  checkForCompletedTopup: vi.fn()
-}))
 vi.mock('@/platform/telemetry', () => ({
-  useTelemetry: () => mockTelemetry
+  useTelemetry: () => null
 }))
 
-const mockBillingRouting = vi.hoisted(() => ({
-  shouldUseWorkspaceBilling: false
+const mockFlags = vi.hoisted(() => ({ teamWorkspacesEnabled: false }))
+vi.mock('@/composables/useFeatureFlags', () => ({
+  useFeatureFlags: () => ({ flags: mockFlags })
+}))
+
+vi.mock('@/platform/distribution/types', async (importOriginal) => ({
+  ...(await importOriginal<typeof DistributionTypes>()),
+  isCloud: true
 }))
-vi.mock('@/composables/billing/useBillingRouting', async () => {
-  const { ref } = await import('vue')
-  const shouldUseWorkspaceBilling = ref(false)
-  Object.defineProperty(mockBillingRouting, 'shouldUseWorkspaceBilling', {
-    get: () => shouldUseWorkspaceBilling.value,
-    set: (value: boolean) => {
-      shouldUseWorkspaceBilling.value = value
-    }
-  })
-  return {
-    useBillingRouting: () => ({ shouldUseWorkspaceBilling })
-  }
-})
 
 const mockWorkspaceApi = vi.hoisted(() => ({
   getBillingEvents: vi.fn()
@@ -77,10 +68,7 @@ const i18n = createI18n({
         additionalInfo: 'Additional Info',
         added: 'Added',
         accountInitialized: 'Account initialized',
-        model: 'Model',
-        loadEventsError: 'Failed to load activity. Please try again.',
-        loadEventsUnknownError:
-          'Something went wrong while loading activity. Please refresh and try again.'
+        model: 'Model'
       }
     }
   }
@@ -107,11 +95,6 @@ const AutoRefreshWrapper = defineComponent({
   template: '<UsageLogsTable ref="tableRef" />'
 })
 
-async function flushMicrotasks() {
-  await new Promise((resolve) => setTimeout(resolve, 0))
-  await nextTick()
-}
-
 function makeEventsResponse(
   events: Partial<AuditLog>[],
   overrides: Record<string, unknown> = {}
@@ -154,7 +137,7 @@ describe('UsageLogsTable', () => {
 
     mockCustomerEventsService.getMyEvents.mockResolvedValue(mockEventsResponse)
     mockWorkspaceApi.getBillingEvents.mockResolvedValue(mockEventsResponse)
-    mockBillingRouting.shouldUseWorkspaceBilling = false
+    mockFlags.teamWorkspacesEnabled = false
     mockCustomerEventsService.formatEventType.mockImplementation(
       (type: string) => {
         switch (type) {
@@ -245,7 +228,7 @@ describe('UsageLogsTable', () => {
       })
     })
 
-    it('shows a localized fallback instead of a raw Error message', async () => {
+    it('shows error message when service throws', async () => {
       mockCustomerEventsService.getMyEvents.mockRejectedValue(
         new Error('Network error')
       )
@@ -253,25 +236,7 @@ describe('UsageLogsTable', () => {
       renderWithAutoRefresh()
 
       await waitFor(() => {
-        expect(
-          screen.getByText(
-            'Something went wrong while loading activity. Please refresh and try again.'
-          )
-        ).toBeInTheDocument()
-      })
-      expect(screen.queryByText('Network error')).not.toBeInTheDocument()
-    })
-
-    it('shows a localized fallback when the service reports no message', async () => {
-      mockCustomerEventsService.getMyEvents.mockResolvedValue(null)
-      mockCustomerEventsService.error.value = null
-
-      renderWithAutoRefresh()
-
-      await waitFor(() => {
-        expect(
-          screen.getByText('Failed to load activity. Please try again.')
-        ).toBeInTheDocument()
+        expect(screen.getByText('Network error')).toBeInTheDocument()
       })
     })
 
@@ -376,8 +341,8 @@ describe('UsageLogsTable', () => {
   })
 
   describe('billing events source', () => {
-    it('uses workspaceApi.getBillingEvents on the workspace billing flow', async () => {
-      mockBillingRouting.shouldUseWorkspaceBilling = true
+    it('uses workspaceApi.getBillingEvents when teamWorkspacesEnabled is on', async () => {
+      mockFlags.teamWorkspacesEnabled = true
 
       await renderLoaded()
 
@@ -387,90 +352,6 @@ describe('UsageLogsTable', () => {
       })
       expect(mockCustomerEventsService.getMyEvents).not.toHaveBeenCalled()
     })
-
-    it('discards a stale legacy response when routing flips mid-fetch', async () => {
-      let resolveLegacy!: (value: ReturnType<typeof makeEventsResponse>) => void
-      mockCustomerEventsService.getMyEvents.mockReturnValue(
-        new Promise((resolve) => {
-          resolveLegacy = resolve
-        })
-      )
-      mockWorkspaceApi.getBillingEvents.mockResolvedValue(
-        makeEventsResponse([
-          {
-            event_id: 'workspace-1',
-            event_type: EventType.API_USAGE_COMPLETED,
-            params: { api_name: 'WorkspaceAPI', model: 'workspace-model' },
-            createdAt: '2024-02-01T10:00:00Z'
-          }
-        ])
-      )
-
-      renderWithAutoRefresh()
-
-      mockBillingRouting.shouldUseWorkspaceBilling = true
-      await waitFor(() => {
-        expect(screen.getByText('WorkspaceAPI')).toBeInTheDocument()
-      })
-
-      resolveLegacy(
-        makeEventsResponse([
-          {
-            event_id: 'legacy-1',
-            event_type: EventType.API_USAGE_COMPLETED,
-            params: { api_name: 'LegacyAPI', model: 'legacy-model' },
-            createdAt: '2024-01-01T10:00:00Z'
-          }
-        ])
-      )
-
-      await flushMicrotasks()
-
-      expect(screen.getByText('WorkspaceAPI')).toBeInTheDocument()
-      expect(screen.queryByText('LegacyAPI')).not.toBeInTheDocument()
-    })
-
-    it('runs top-up completion telemetry for a superseded response', async () => {
-      let resolveLegacy!: (value: ReturnType<typeof makeEventsResponse>) => void
-      mockCustomerEventsService.getMyEvents.mockReturnValue(
-        new Promise((resolve) => {
-          resolveLegacy = resolve
-        })
-      )
-      mockWorkspaceApi.getBillingEvents.mockResolvedValue(
-        makeEventsResponse([
-          {
-            event_id: 'workspace-1',
-            event_type: EventType.API_USAGE_COMPLETED,
-            params: { api_name: 'WorkspaceAPI', model: 'workspace-model' },
-            createdAt: '2024-02-01T10:00:00Z'
-          }
-        ])
-      )
-
-      renderWithAutoRefresh()
-
-      mockBillingRouting.shouldUseWorkspaceBilling = true
-      await waitFor(() => {
-        expect(screen.getByText('WorkspaceAPI')).toBeInTheDocument()
-      })
-
-      const legacyResponse = makeEventsResponse([
-        {
-          event_id: 'legacy-1',
-          event_type: EventType.CREDIT_ADDED,
-          params: { amount: 1000 },
-          createdAt: '2024-01-01T10:00:00Z'
-        }
-      ])
-      resolveLegacy(legacyResponse)
-
-      await waitFor(() => {
-        expect(mockTelemetry.checkForCompletedTopup).toHaveBeenCalledWith(
-          legacyResponse.events
-        )
-      })
-    })
   })
 
   describe('EventType integration', () => {

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

@@ -96,11 +96,11 @@ import Column from 'primevue/column'
 import DataTable from 'primevue/datatable'
 import Message from 'primevue/message'
 import ProgressSpinner from 'primevue/progressspinner'
-import { computed, ref, watch } from 'vue'
-import { useI18n } from 'vue-i18n'
+import { computed, ref } from 'vue'
 
 import Button from '@/components/ui/button/Button.vue'
-import { useBillingRouting } from '@/composables/billing/useBillingRouting'
+import { useFeatureFlags } from '@/composables/useFeatureFlags'
+import { isCloud } from '@/platform/distribution/types'
 import { useTelemetry } from '@/platform/telemetry'
 import { workspaceApi } from '@/platform/workspace/api/workspaceApi'
 import type { AuditLog } from '@/services/customerEventsService'
@@ -109,15 +109,14 @@ import {
   useCustomerEventsService
 } from '@/services/customerEventsService'
 
-const { t } = useI18n()
-
 const events = ref<AuditLog[]>([])
 const loading = ref(true)
 const error = ref<string | null>(null)
 
 const customerEventService = useCustomerEventsService()
 
-const { shouldUseWorkspaceBilling } = useBillingRouting()
+const { flags } = useFeatureFlags()
+const useBillingApi = computed(() => isCloud && flags.teamWorkspacesEnabled)
 
 const pagination = ref({
   page: 1,
@@ -140,12 +139,7 @@ const tooltipContentMap = computed(() => {
   return map
 })
 
-// A billing-route flip can overlap two loads against different backends; only
-// the latest may mutate state, so a superseded response is discarded.
-let latestLoadToken = 0
-
 const loadEvents = async () => {
-  const loadToken = ++latestLoadToken
   loading.value = true
   error.value = null
 
@@ -154,17 +148,10 @@ const loadEvents = async () => {
       page: pagination.value.page,
       limit: pagination.value.limit
     }
-    const response = shouldUseWorkspaceBilling.value
+    const response = useBillingApi.value
       ? await workspaceApi.getBillingEvents(params)
       : await customerEventService.getMyEvents(params)
 
-    // Completion telemetry must run even when a mid-checkout route flip
-    // supersedes this load, since legacy and workspace backends emit different
-    // top-up events and the winning fetch may not carry the completion yet.
-    useTelemetry()?.checkForCompletedTopup(response?.events)
-
-    if (loadToken !== latestLoadToken) return
-
     if (response) {
       if (response.events) {
         events.value = response.events
@@ -178,25 +165,24 @@ const loadEvents = async () => {
         pagination.value.limit = response.limit
       }
 
-      if (response.total != null) {
+      if (response.total) {
         pagination.value.total = response.total
       }
 
-      if (response.totalPages != null) {
+      if (response.totalPages) {
         pagination.value.totalPages = response.totalPages
       }
+
+      // Check if a pending top-up has completed
+      useTelemetry()?.checkForCompletedTopup(response.events)
     } else {
-      const legacyError = shouldUseWorkspaceBilling.value
-        ? null
-        : customerEventService.error.value
-      error.value = legacyError || t('credits.loadEventsError')
+      error.value = customerEventService.error.value || 'Failed to load events'
     }
   } catch (err) {
-    if (loadToken !== latestLoadToken) return
-    error.value = t('credits.loadEventsUnknownError')
+    error.value = err instanceof Error ? err.message : 'Unknown error'
     console.error('Error loading events:', err)
   } finally {
-    if (loadToken === latestLoadToken) loading.value = false
+    loading.value = false
   }
 }
 
@@ -212,12 +198,6 @@ const refresh = async () => {
   await loadEvents()
 }
 
-watch(shouldUseWorkspaceBilling, () => {
-  refresh().catch((error) => {
-    console.error('Error loading events:', error)
-  })
-})
-
 defineExpose({
   refresh
 })

src/composables/billing/useBillingContext.test.ts

@@ -19,7 +19,6 @@ const DEFAULT_BILLING_STATUS: BillingStatusResponse = {
 
 const {
   mockTeamWorkspacesEnabled,
-  mockConsolidatedBillingEnabled,
   mockIsPersonal,
   mockPlans,
   mockPurchaseCredits,
@@ -27,7 +26,6 @@ const {
   mockBillingStatus
 } = vi.hoisted(() => ({
   mockTeamWorkspacesEnabled: { value: false },
-  mockConsolidatedBillingEnabled: { value: false },
   mockIsPersonal: { value: true },
   mockPlans: { value: [] as Plan[] },
   mockPurchaseCredits: vi.fn(),
@@ -59,23 +57,11 @@ vi.mock('@/composables/useFeatureFlags', async () => {
       teamWorkspacesEnabledRef.value = value
     }
   })
-  const consolidatedBillingEnabledRef = ref(
-    mockConsolidatedBillingEnabled.value
-  )
-  Object.defineProperty(mockConsolidatedBillingEnabled, 'value', {
-    get: () => consolidatedBillingEnabledRef.value,
-    set: (value: boolean) => {
-      consolidatedBillingEnabledRef.value = value
-    }
-  })
   return {
     useFeatureFlags: () => ({
       flags: {
         get teamWorkspacesEnabled() {
           return mockTeamWorkspacesEnabled.value
-        },
-        get consolidatedBillingEnabled() {
-          return mockConsolidatedBillingEnabled.value
         }
       }
     })
@@ -165,7 +151,6 @@ describe('useBillingContext', () => {
     setActivePinia(createPinia())
     vi.clearAllMocks()
     mockTeamWorkspacesEnabled.value = false
-    mockConsolidatedBillingEnabled.value = false
     mockIsPersonal.value = true
     mockPlans.value = []
     mockBillingStatus.value = { ...DEFAULT_BILLING_STATUS }
@@ -177,27 +162,16 @@ describe('useBillingContext', () => {
     expect(type.value).toBe('legacy')
   })
 
-  it('keeps personal on legacy when consolidated billing is disabled', () => {
+  it('selects workspace type for personal when team workspaces are enabled', () => {
     mockTeamWorkspacesEnabled.value = true
-    mockConsolidatedBillingEnabled.value = false
-    mockIsPersonal.value = true
-
-    const { type } = useBillingContext()
-    expect(type.value).toBe('legacy')
-  })
-
-  it('selects workspace type for personal when consolidated billing is enabled', () => {
-    mockTeamWorkspacesEnabled.value = true
-    mockConsolidatedBillingEnabled.value = true
     mockIsPersonal.value = true
 
     const { type } = useBillingContext()
     expect(type.value).toBe('workspace')
   })
 
-  it('selects workspace type for team regardless of consolidated billing', () => {
+  it('selects workspace type for team when team workspaces are enabled', () => {
     mockTeamWorkspacesEnabled.value = true
-    mockConsolidatedBillingEnabled.value = false
     mockIsPersonal.value = false
 
     const { type } = useBillingContext()
@@ -298,7 +272,6 @@ describe('useBillingContext', () => {
     expect(workspaceApi.getBillingStatus).not.toHaveBeenCalled()
 
     // Authenticated remote config resolves the flag on for the same workspace
-    mockConsolidatedBillingEnabled.value = true
     mockTeamWorkspacesEnabled.value = true
 
     await vi.waitFor(() => {
@@ -307,27 +280,9 @@ describe('useBillingContext', () => {
     })
   })
 
-  it('moves a personal workspace to workspace billing when consolidated billing flips on', async () => {
-    mockTeamWorkspacesEnabled.value = true
-    mockConsolidatedBillingEnabled.value = false
-    mockIsPersonal.value = true
-
-    const { type } = useBillingContext()
-    await nextTick()
-    expect(type.value).toBe('legacy')
-
-    mockConsolidatedBillingEnabled.value = true
-
-    await vi.waitFor(() => {
-      expect(type.value).toBe('workspace')
-      expect(workspaceApi.getBillingStatus).toHaveBeenCalled()
-    })
-  })
-
   describe('subscription mirror to workspace store', () => {
-    it('mirrors subscription for personal workspaces on the consolidated billing flow', async () => {
+    it('mirrors subscription for personal workspaces when team workspaces are enabled', async () => {
       mockTeamWorkspacesEnabled.value = true
-      mockConsolidatedBillingEnabled.value = true
       mockIsPersonal.value = true
 
       const { initialize } = useBillingContext()
@@ -339,20 +294,6 @@ describe('useBillingContext', () => {
         subscriptionPlan: null
       })
     })
-
-    it('never clobbers the list-derived store when a subscription is absent', async () => {
-      mockTeamWorkspacesEnabled.value = true
-      mockIsPersonal.value = false
-
-      const { initialize } = useBillingContext()
-      await initialize()
-      await nextTick()
-
-      expect(mockUpdateActiveWorkspace).not.toHaveBeenCalledWith({
-        isSubscribed: false,
-        subscriptionPlan: null
-      })
-    })
   })
 
   describe('getMaxSeats', () => {

src/composables/billing/useBillingContext.ts

@@ -1,6 +1,7 @@
 import { computed, ref, shallowRef, toValue, watch } from 'vue'
 import { createSharedComposable } from '@vueuse/core'
 
+import { useFeatureFlags } from '@/composables/useFeatureFlags'
 import {
   KEY_TO_TIER,
   getTierFeatures
@@ -17,10 +18,10 @@ import type {
   BalanceInfo,
   BillingActions,
   BillingContext,
+  BillingType,
   BillingState,
   SubscriptionInfo
 } from './types'
-import { useBillingRouting } from './useBillingRouting'
 import { useLegacyBilling } from './useLegacyBilling'
 import { useWorkspaceBilling } from '@/platform/workspace/composables/useWorkspaceBilling'
 
@@ -34,9 +35,8 @@ const LEGACY_TEAM_PLAN_SLUG_PREFIX = 'team-'
  * Unified billing context that selects the billing implementation by build/flag.
  *
  * - Team workspaces disabled (OSS/Desktop): legacy billing via /customers/*
- * - Team workspaces enabled: workspace billing via /api/billing/* for team
- *   workspaces, and for personal workspaces once consolidated billing is
- *   enabled; personal workspaces otherwise stay on legacy billing
+ * - Team workspaces enabled: workspace billing via /api/billing/* for both
+ *   personal (single-seat workspace) and team workspaces
  *
  * The context automatically initializes when the workspace changes and provides
  * a unified interface for subscription status, balance, and billing actions.
@@ -69,7 +69,7 @@ const LEGACY_TEAM_PLAN_SLUG_PREFIX = 'team-'
  */
 function useBillingContextInternal(): BillingContext {
   const store = useTeamWorkspaceStore()
-  const { type } = useBillingRouting()
+  const { flags } = useFeatureFlags()
 
   const legacyBillingRef = shallowRef<(BillingState & BillingActions) | null>(
     null
@@ -96,6 +96,16 @@ function useBillingContextInternal(): BillingContext {
   const isLoading = ref(false)
   const error = ref<string | null>(null)
 
+  /**
+   * Determines which billing type to use, keyed only on the build/flag:
+   * - Team workspaces feature disabled (OSS/Desktop): legacy (/customers)
+   * - Team workspaces feature enabled: workspace (/api/billing), for both
+   *   personal (single-seat workspace) and team workspaces
+   */
+  const type = computed<BillingType>(() =>
+    flags.teamWorkspacesEnabled ? 'workspace' : 'legacy'
+  )
+
   const activeContext = computed(() =>
     type.value === 'legacy' ? getLegacyBilling() : getWorkspaceBilling()
   )
@@ -160,12 +170,9 @@ function useBillingContextInternal(): BillingContext {
     return plan?.max_seats ?? getTierFeatures(tierKey).maxMembers
   }
 
-  // Sync subscription info to workspace store for display in workspace switcher.
-  // Subscribed means active AND not cancelled, so the delete button enables
-  // after cancellation, even before the period ends. A null subscription means
-  // "not loaded yet" (adapters are discarded on every workspace/type switch);
-  // skip it so the transient reinit gap can't clobber the list-derived baseline
-  // (personal workspaces and subscribed teams already read subscribed there).
+  // Sync subscription info to workspace store for display in workspace switcher
+  // A subscription is considered "subscribed" for workspace purposes if it's active AND not cancelled
+  // This ensures the delete button is enabled after cancellation, even before the period ends
   watch(
     subscription,
     (sub) => {
@@ -179,27 +186,24 @@ function useBillingContextInternal(): BillingContext {
     { immediate: true }
   )
 
-  // Discarding the adapter instances forces a fresh fetch and lets an in-flight
-  // init detect that it was superseded (its captured adapter is no longer the
-  // active one), so a stale response can't resolve into a ready state for the
-  // wrong workspace.
   function resetBillingState() {
-    legacyBillingRef.value = null
-    workspaceBillingRef.value = null
     isInitialized.value = false
-    isLoading.value = false
     error.value = null
   }
 
-  // type flips when the team-workspaces or consolidated-billing flag resolves
-  // from authenticated config, swapping the active backend. Reset then reinit
-  // on every workspace-id or type change.
+  // type can flip after setup when the team-workspaces flag resolves from
+  // authenticated config, swapping the active backend; a fresh init is needed.
+  // The watch fires only when id or type actually changes, so any fire with a
+  // workspace selected warrants a reinit.
   watch(
     [() => store.activeWorkspace?.id, () => type.value],
     async ([newWorkspaceId]) => {
-      resetBillingState()
-      if (!newWorkspaceId) return
+      if (!newWorkspaceId) {
+        resetBillingState()
+        return
+      }
 
+      isInitialized.value = false
       try {
         await initialize()
       } catch (err) {
@@ -212,20 +216,17 @@ function useBillingContextInternal(): BillingContext {
   async function initialize(): Promise<void> {
     if (isInitialized.value) return
 
-    const adapter = activeContext.value
     isLoading.value = true
     error.value = null
     try {
-      await adapter.initialize()
-      if (activeContext.value !== adapter) return
+      await activeContext.value.initialize()
       isInitialized.value = true
     } catch (err) {
-      if (activeContext.value !== adapter) return
       error.value =
         err instanceof Error ? err.message : 'Failed to initialize billing'
       throw err
     } finally {
-      if (activeContext.value === adapter) isLoading.value = false
+      isLoading.value = false
     }
   }
 

src/composables/billing/useBillingRouting.test.ts

@@ -1,99 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from 'vitest'
-
-import { useBillingRouting } from './useBillingRouting'
-
-const { mockFlags, mockActiveWorkspace } = vi.hoisted(() => ({
-  mockFlags: {
-    teamWorkspacesEnabled: false,
-    consolidatedBillingEnabled: false
-  },
-  mockActiveWorkspace: {
-    value: null as { id: string; type: 'personal' | 'team' } | null
-  }
-}))
-
-vi.mock('@/composables/useFeatureFlags', () => ({
-  useFeatureFlags: () => ({ flags: mockFlags })
-}))
-
-vi.mock('@/platform/workspace/stores/teamWorkspaceStore', () => ({
-  useTeamWorkspaceStore: () => ({
-    get activeWorkspace() {
-      return mockActiveWorkspace.value
-    }
-  })
-}))
-
-const personal = { id: 'w-personal', type: 'personal' as const }
-const team = { id: 'w-team', type: 'team' as const }
-
-describe('useBillingRouting', () => {
-  beforeEach(() => {
-    mockFlags.teamWorkspacesEnabled = false
-    mockFlags.consolidatedBillingEnabled = false
-    mockActiveWorkspace.value = personal
-  })
-
-  it('uses legacy billing when team workspaces are disabled', () => {
-    mockFlags.teamWorkspacesEnabled = false
-    mockActiveWorkspace.value = team
-
-    const { type, shouldUseWorkspaceBilling } = useBillingRouting()
-
-    expect(type.value).toBe('legacy')
-    expect(shouldUseWorkspaceBilling.value).toBe(false)
-  })
-
-  it('keeps personal on legacy when consolidated billing is disabled', () => {
-    mockFlags.teamWorkspacesEnabled = true
-    mockFlags.consolidatedBillingEnabled = false
-    mockActiveWorkspace.value = personal
-
-    const { type } = useBillingRouting()
-
-    expect(type.value).toBe('legacy')
-  })
-
-  it('moves personal to workspace billing when consolidated billing is enabled', () => {
-    mockFlags.teamWorkspacesEnabled = true
-    mockFlags.consolidatedBillingEnabled = true
-    mockActiveWorkspace.value = personal
-
-    const { type, shouldUseWorkspaceBilling } = useBillingRouting()
-
-    expect(type.value).toBe('workspace')
-    expect(shouldUseWorkspaceBilling.value).toBe(true)
-  })
-
-  it('uses workspace billing for team workspaces regardless of consolidated billing', () => {
-    mockFlags.teamWorkspacesEnabled = true
-    mockFlags.consolidatedBillingEnabled = false
-    mockActiveWorkspace.value = team
-
-    const { type, shouldUseWorkspaceBilling } = useBillingRouting()
-
-    expect(type.value).toBe('workspace')
-    expect(shouldUseWorkspaceBilling.value).toBe(true)
-  })
-
-  it('uses workspace billing for team workspaces with consolidated billing enabled', () => {
-    mockFlags.teamWorkspacesEnabled = true
-    mockFlags.consolidatedBillingEnabled = true
-    mockActiveWorkspace.value = team
-
-    const { type, shouldUseWorkspaceBilling } = useBillingRouting()
-
-    expect(type.value).toBe('workspace')
-    expect(shouldUseWorkspaceBilling.value).toBe(true)
-  })
-
-  it('defaults to legacy while the workspace has not loaded', () => {
-    mockFlags.teamWorkspacesEnabled = true
-    mockFlags.consolidatedBillingEnabled = true
-    mockActiveWorkspace.value = null
-
-    const { type } = useBillingRouting()
-
-    expect(type.value).toBe('legacy')
-  })
-})

src/composables/billing/useBillingRouting.ts

@@ -1,36 +0,0 @@
-import { computed } from 'vue'
-
-import { useFeatureFlags } from '@/composables/useFeatureFlags'
-import { useTeamWorkspaceStore } from '@/platform/workspace/stores/teamWorkspaceStore'
-
-import type { BillingType } from './types'
-
-/**
- * Selects the billing backend for the active workspace: legacy user-scoped
- * (`/customers/*`) or workspace-scoped (`/api/billing/*`). Personal workspaces
- * stay legacy until `consolidatedBillingEnabled`; team workspaces are always
- * workspace-scoped. The routing matrix is covered in useBillingRouting.test.ts.
- */
-export function useBillingRouting() {
-  const { flags } = useFeatureFlags()
-  const workspaceStore = useTeamWorkspaceStore()
-
-  const type = computed<BillingType>(() => {
-    if (!flags.teamWorkspacesEnabled) return 'legacy'
-
-    // An unloaded workspace has no type yet; stay legacy so bootstrap never
-    // eagerly routes to workspace billing.
-    const workspaceType = workspaceStore.activeWorkspace?.type
-    if (!workspaceType) return 'legacy'
-
-    if (workspaceType === 'personal' && !flags.consolidatedBillingEnabled) {
-      return 'legacy'
-    }
-
-    return 'workspace'
-  })
-
-  const shouldUseWorkspaceBilling = computed(() => type.value === 'workspace')
-
-  return { type, shouldUseWorkspaceBilling }
-}

src/composables/useFeatureFlags.test.ts

@@ -6,12 +6,6 @@ import {
   useFeatureFlags
 } from '@/composables/useFeatureFlags'
 import * as distributionTypes from '@/platform/distribution/types'
-import {
-  cachedConsolidatedBillingEnabled,
-  cachedTeamWorkspacesEnabled,
-  remoteConfig,
-  remoteConfigState
-} from '@/platform/remoteConfig/remoteConfig'
 import { api } from '@/scripts/api'
 
 // Mock the API module
@@ -225,86 +219,6 @@ describe('useFeatureFlags', () => {
       const { flags } = useFeatureFlags()
       expect(flags.teamWorkspacesEnabled).toBe(true)
     })
-
-    it('consolidatedBillingEnabled override bypasses isCloud and isAuthenticatedConfigLoaded guards', () => {
-      vi.mocked(distributionTypes).isCloud = false
-      localStorage.setItem('ff:consolidated_billing_enabled', 'true')
-
-      const { flags } = useFeatureFlags()
-      expect(flags.consolidatedBillingEnabled).toBe(true)
-    })
-
-    it('consolidatedBillingEnabled is false off-cloud even without an override', () => {
-      vi.mocked(distributionTypes).isCloud = false
-
-      const { flags } = useFeatureFlags()
-      expect(flags.consolidatedBillingEnabled).toBe(false)
-    })
-  })
-
-  describe('auth-gated flags on cloud', () => {
-    beforeEach(() => {
-      vi.mocked(distributionTypes).isCloud = true
-      remoteConfigState.value = 'unloaded'
-      remoteConfig.value = {}
-      cachedTeamWorkspacesEnabled.value = undefined
-      cachedConsolidatedBillingEnabled.value = undefined
-      localStorage.clear()
-    })
-
-    afterEach(() => {
-      vi.mocked(distributionTypes).isCloud = false
-      remoteConfigState.value = 'unloaded'
-      remoteConfig.value = {}
-      cachedTeamWorkspacesEnabled.value = undefined
-      cachedConsolidatedBillingEnabled.value = undefined
-      localStorage.clear()
-    })
-
-    it('returns the cached session value during the auth window', () => {
-      cachedTeamWorkspacesEnabled.value = false
-      cachedConsolidatedBillingEnabled.value = true
-
-      const { flags } = useFeatureFlags()
-      expect(flags.teamWorkspacesEnabled).toBe(false)
-      expect(flags.consolidatedBillingEnabled).toBe(true)
-    })
-
-    it('defaults to false during the auth window when nothing is cached', () => {
-      const { flags } = useFeatureFlags()
-      expect(flags.teamWorkspacesEnabled).toBe(false)
-      expect(flags.consolidatedBillingEnabled).toBe(false)
-    })
-
-    it('prefers authenticated remoteConfig over the server feature fallback', () => {
-      remoteConfigState.value = 'authenticated'
-      remoteConfig.value = {
-        team_workspaces_enabled: true,
-        consolidated_billing_enabled: true
-      }
-      vi.mocked(api.getServerFeature).mockReturnValue(false)
-
-      const { flags } = useFeatureFlags()
-      expect(flags.teamWorkspacesEnabled).toBe(true)
-      expect(flags.consolidatedBillingEnabled).toBe(true)
-    })
-
-    it('falls back to api.getServerFeature when authenticated config omits the flag', () => {
-      remoteConfigState.value = 'authenticated'
-      remoteConfig.value = {}
-      vi.mocked(api.getServerFeature).mockImplementation(
-        (path, defaultValue) => {
-          if (path === ServerFeatureFlag.TEAM_WORKSPACES_ENABLED) return true
-          if (path === ServerFeatureFlag.CONSOLIDATED_BILLING_ENABLED)
-            return true
-          return defaultValue
-        }
-      )
-
-      const { flags } = useFeatureFlags()
-      expect(flags.teamWorkspacesEnabled).toBe(true)
-      expect(flags.consolidatedBillingEnabled).toBe(true)
-    })
   })
 
   describe('signupTurnstileMode', () => {

src/composables/useFeatureFlags.ts

@@ -1,9 +1,7 @@
 import { computed, reactive, readonly } from 'vue'
-import type { Ref } from 'vue'
 
 import { isCloud, isNightly } from '@/platform/distribution/types'
 import {
-  cachedConsolidatedBillingEnabled,
   cachedTeamWorkspacesEnabled,
   isAuthenticatedConfigLoaded,
   remoteConfig
@@ -32,7 +30,6 @@ export enum ServerFeatureFlag {
   COMFYHUB_PROFILE_GATE_ENABLED = 'comfyhub_profile_gate_enabled',
   SHOW_SIGNIN_BUTTON = 'show_signin_button',
   UNIFIED_CLOUD_AUTH = 'unified_cloud_auth',
-  CONSOLIDATED_BILLING_ENABLED = 'consolidated_billing_enabled',
   SIGNUP_TURNSTILE = 'signup_turnstile'
 }
 
@@ -49,26 +46,6 @@ function resolveFlag<T>(
   return remoteConfigValue ?? api.getServerFeature(flagKey, defaultValue)
 }
 
-/**
- * Resolves a per-user, Cloud-only flag that selects backend behavior. Off the
- * Cloud build it is always false; during the auth window it falls back to the
- * cached session value so anonymous bootstrap config cannot route the user to
- * the wrong backend before authenticated config confirms the flag.
- */
-function resolveAuthGatedFlag(
-  flagKey: string,
-  remoteConfigValue: boolean | undefined,
-  cachedValue: Ref<boolean | undefined>
-): boolean {
-  const override = getDevOverride<boolean>(flagKey)
-  if (override !== undefined) return override
-
-  if (!isCloud) return false
-  if (!isAuthenticatedConfigLoaded.value) return cachedValue.value ?? false
-
-  return remoteConfigValue ?? api.getServerFeature(flagKey, false)
-}
-
 /**
  * Composable for reactive access to server-side feature flags
  */
@@ -127,10 +104,18 @@ export function useFeatureFlags() {
      * and prevents race conditions during initialization.
      */
     get teamWorkspacesEnabled() {
-      return resolveAuthGatedFlag(
-        ServerFeatureFlag.TEAM_WORKSPACES_ENABLED,
-        remoteConfig.value.team_workspaces_enabled,
-        cachedTeamWorkspacesEnabled
+      const override = getDevOverride<boolean>(
+        ServerFeatureFlag.TEAM_WORKSPACES_ENABLED
+      )
+      if (override !== undefined) return override
+
+      if (!isCloud) return false
+      if (!isAuthenticatedConfigLoaded.value)
+        return cachedTeamWorkspacesEnabled.value ?? false
+
+      return (
+        remoteConfig.value.team_workspaces_enabled ??
+        api.getServerFeature(ServerFeatureFlag.TEAM_WORKSPACES_ENABLED, false)
       )
     },
     get userSecretsEnabled() {
@@ -190,18 +175,6 @@ export function useFeatureFlags() {
         false
       )
     },
-    /**
-     * Whether personal workspaces use the consolidated (workspace-scoped)
-     * billing flow. While false (default), personal workspaces stay on the
-     * legacy per-user billing flow; team workspaces are unaffected.
-     */
-    get consolidatedBillingEnabled() {
-      return resolveAuthGatedFlag(
-        ServerFeatureFlag.CONSOLIDATED_BILLING_ENABLED,
-        remoteConfig.value.consolidated_billing_enabled,
-        cachedConsolidatedBillingEnabled
-      )
-    },
     get signupTurnstileMode() {
       return resolveFlag(
         ServerFeatureFlag.SIGNUP_TURNSTILE,

src/locales/en/main.json

@@ -2484,8 +2484,6 @@
     "model": "Model",
     "added": "Added",
     "accountInitialized": "Account initialized",
-    "loadEventsError": "Failed to load activity. Please try again.",
-    "loadEventsUnknownError": "Something went wrong while loading activity. Please refresh and try again.",
     "eventTypes": {
       "creditAdded": "Credits Added",
       "accountCreated": "Account Created",

src/platform/cloud/subscription/components/SubscriptionPanel.vue

@@ -18,7 +18,7 @@
       </div>
 
       <!-- Workspace mode: workspace-aware subscription content (renders its own footer) -->
-      <SubscriptionPanelContentWorkspace v-if="shouldUseWorkspaceBilling" />
+      <SubscriptionPanelContentWorkspace v-if="teamWorkspacesEnabled" />
       <!-- Legacy mode: user-level subscription content -->
       <template v-else>
         <SubscriptionPanelContentLegacy />
@@ -29,20 +29,24 @@
 </template>
 
 <script setup lang="ts">
-import { defineAsyncComponent } from 'vue'
+import { computed, defineAsyncComponent } from 'vue'
 
 import CloudBadge from '@/components/topbar/CloudBadge.vue'
 import { useBillingContext } from '@/composables/billing/useBillingContext'
-import { useBillingRouting } from '@/composables/billing/useBillingRouting'
+import { useFeatureFlags } from '@/composables/useFeatureFlags'
 import SubscriptionFooterLinks from '@/platform/cloud/subscription/components/SubscriptionFooterLinks.vue'
 import SubscriptionPanelContentLegacy from '@/platform/cloud/subscription/components/SubscriptionPanelContentLegacy.vue'
+import { isCloud } from '@/platform/distribution/types'
 
 const SubscriptionPanelContentWorkspace = defineAsyncComponent(
   () =>
     import('@/platform/workspace/components/SubscriptionPanelContentWorkspace.vue')
 )
 
-const { shouldUseWorkspaceBilling } = useBillingRouting()
+const { flags } = useFeatureFlags()
+const teamWorkspacesEnabled = computed(
+  () => isCloud && flags.teamWorkspacesEnabled
+)
 
 const { isActiveSubscription } = useBillingContext()
 </script>

src/platform/cloud/subscription/composables/useSubscriptionDialog.test.ts

@@ -9,7 +9,7 @@ const mockTrackSubscription = vi.hoisted(() => vi.fn())
 const mockIsInPersonalWorkspace = vi.hoisted(() => ({ value: true }))
 const mockIsFreeTier = vi.hoisted(() => ({ value: false }))
 const mockTier = vi.hoisted(() => ({ value: 'FREE' as string | null }))
-const mockShouldUseWorkspaceBilling = vi.hoisted(() => ({ value: false }))
+const mockTeamWorkspacesEnabled = vi.hoisted(() => ({ value: false }))
 const mockIsCloud = vi.hoisted(() => ({ value: true }))
 const mockIsLegacyTeamPlan = vi.hoisted(() => ({ value: false }))
 const mockCanManageSubscription = vi.hoisted(() => ({ value: true }))
@@ -35,10 +35,12 @@ vi.mock('@/services/dialogService', () => ({
   })
 }))
 
-vi.mock('@/composables/billing/useBillingRouting', () => ({
-  useBillingRouting: () => ({
-    get shouldUseWorkspaceBilling() {
-      return mockShouldUseWorkspaceBilling
+vi.mock('@/composables/useFeatureFlags', () => ({
+  useFeatureFlags: () => ({
+    flags: {
+      get teamWorkspacesEnabled() {
+        return mockTeamWorkspacesEnabled.value
+      }
     }
   })
 }))
@@ -86,7 +88,7 @@ describe('useSubscriptionDialog', () => {
     mockIsInPersonalWorkspace.value = true
     mockIsFreeTier.value = false
     mockTier.value = 'FREE'
-    mockShouldUseWorkspaceBilling.value = false
+    mockTeamWorkspacesEnabled.value = false
     mockIsLegacyTeamPlan.value = false
     mockCanManageSubscription.value = true
 
@@ -117,7 +119,7 @@ describe('useSubscriptionDialog', () => {
     })
 
     it('does not wire onChooseTeam on the unified table (personal subscribes directly)', () => {
-      mockShouldUseWorkspaceBilling.value = true
+      mockTeamWorkspacesEnabled.value = true
       mockIsInPersonalWorkspace.value = true
       const { showPricingTable } = useSubscriptionDialog()
 
@@ -129,7 +131,7 @@ describe('useSubscriptionDialog', () => {
     })
 
     it('sizes the unified pricing dialog via the Reka contentClass, not the ignored PrimeVue style', () => {
-      mockShouldUseWorkspaceBilling.value = true
+      mockTeamWorkspacesEnabled.value = true
       mockIsInPersonalWorkspace.value = true
       const { showPricingTable } = useSubscriptionDialog()
 
@@ -144,7 +146,7 @@ describe('useSubscriptionDialog', () => {
     })
 
     it('defaults to the personal tab in a personal workspace', () => {
-      mockShouldUseWorkspaceBilling.value = true
+      mockTeamWorkspacesEnabled.value = true
       mockIsInPersonalWorkspace.value = true
       const { showPricingTable } = useSubscriptionDialog()
 
@@ -155,7 +157,7 @@ describe('useSubscriptionDialog', () => {
     })
 
     it('opens the team tab when planMode is forced from a personal workspace', () => {
-      mockShouldUseWorkspaceBilling.value = true
+      mockTeamWorkspacesEnabled.value = true
       mockIsInPersonalWorkspace.value = true
       const { showPricingTable } = useSubscriptionDialog()
 
@@ -165,9 +167,8 @@ describe('useSubscriptionDialog', () => {
       expect(props.initialPlanMode).toBe('team')
     })
 
-    it('uses the legacy table (with onChooseTeam) on the legacy billing flow', () => {
-      mockShouldUseWorkspaceBilling.value = false
-      mockIsInPersonalWorkspace.value = true
+    it('uses the legacy table (with onChooseTeam) when team workspaces are disabled', () => {
+      mockTeamWorkspacesEnabled.value = false
       const { showPricingTable } = useSubscriptionDialog()
 
       showPricingTable()
@@ -177,7 +178,7 @@ describe('useSubscriptionDialog', () => {
     })
 
     it('routes an existing per-member (legacy) team subscriber to the old team table', () => {
-      mockShouldUseWorkspaceBilling.value = true
+      mockTeamWorkspacesEnabled.value = true
       mockIsInPersonalWorkspace.value = false
       mockIsLegacyTeamPlan.value = true
       const { showPricingTable } = useSubscriptionDialog()
@@ -195,7 +196,7 @@ describe('useSubscriptionDialog', () => {
     })
 
     it('keeps a non-legacy (credit-slider) team subscriber on the unified table', () => {
-      mockShouldUseWorkspaceBilling.value = true
+      mockTeamWorkspacesEnabled.value = true
       mockIsInPersonalWorkspace.value = false
       mockIsLegacyTeamPlan.value = false
       const { showPricingTable } = useSubscriptionDialog()
@@ -219,7 +220,7 @@ describe('useSubscriptionDialog', () => {
     })
 
     it('tracks modal_opened on the workspace (unified) path too', () => {
-      mockShouldUseWorkspaceBilling.value = true
+      mockTeamWorkspacesEnabled.value = true
       const { showPricingTable } = useSubscriptionDialog()
 
       showPricingTable({ reason: 'subscribe_to_run' })
@@ -231,7 +232,7 @@ describe('useSubscriptionDialog', () => {
     })
 
     it('does not track modal_opened for the inactive member dialog', () => {
-      mockShouldUseWorkspaceBilling.value = true
+      mockTeamWorkspacesEnabled.value = true
       mockIsInPersonalWorkspace.value = false
       mockCanManageSubscription.value = false
       const { showPricingTable } = useSubscriptionDialog()

src/platform/cloud/subscription/composables/useSubscriptionDialog.ts

@@ -2,7 +2,7 @@ import { defineAsyncComponent } from 'vue'
 import { useDialogService } from '@/services/dialogService'
 import { useDialogStore } from '@/stores/dialogStore'
 import { useBillingContext } from '@/composables/billing/useBillingContext'
-import { useBillingRouting } from '@/composables/billing/useBillingRouting'
+import { useFeatureFlags } from '@/composables/useFeatureFlags'
 import { isCloud } from '@/platform/distribution/types'
 import { useTelemetry } from '@/platform/telemetry'
 import type { PaymentIntentSource } from '@/platform/telemetry/types'
@@ -24,7 +24,7 @@ export interface SubscriptionDialogOptions {
 }
 
 export const useSubscriptionDialog = () => {
-  const { shouldUseWorkspaceBilling } = useBillingRouting()
+  const { flags } = useFeatureFlags()
   const dialogService = useDialogService()
   const dialogStore = useDialogStore()
   const workspaceStore = useTeamWorkspaceStore()
@@ -57,7 +57,7 @@ export const useSubscriptionDialog = () => {
     // small read-only "ask your owner to reactivate" modal instead of the
     // pricing table. Out-of-credits still routes everyone to the credits flow.
     if (
-      shouldUseWorkspaceBilling.value &&
+      flags.teamWorkspacesEnabled &&
       !workspaceStore.isInPersonalWorkspace &&
       !permissions.value.canManageSubscription &&
       options?.reason !== 'out_of_credits'
@@ -95,10 +95,9 @@ export const useSubscriptionDialog = () => {
     }
 
     // Jun-5 model: a single unified pricing table (personal/team plan toggle on
-    // one workspace) for workspaces on the consolidated billing flow. Replaces
-    // the old personal-vs-team workspace fork. Personal workspaces still on the
-    // legacy flow (consolidated billing disabled) get the legacy table.
-    if (shouldUseWorkspaceBilling.value) {
+    // one workspace) when team workspaces are enabled. Replaces the old
+    // personal-vs-team workspace fork. Flag-off keeps the legacy table.
+    if (flags.teamWorkspacesEnabled) {
       // Existing per-member (legacy) team subscribers keep the old tier-based
       // team table; the unified credit-slider table is for everyone else.
       // Resolved lazily (not at composable setup): these three composables form

src/platform/remoteConfig/refreshRemoteConfig.ts

@@ -1,5 +1,4 @@
 import {
-  cachedConsolidatedBillingEnabled,
   cachedTeamWorkspacesEnabled,
   remoteConfig,
   remoteConfigState
@@ -56,14 +55,10 @@ export async function refreshRemoteConfig(
       window.__CONFIG__ = config
       remoteConfig.value = config
       remoteConfigState.value = useAuth ? 'authenticated' : 'anonymous'
-      if (useAuth) {
+      if (useAuth)
         cachedTeamWorkspacesEnabled.value = Boolean(
           config.team_workspaces_enabled
         )
-        cachedConsolidatedBillingEnabled.value = Boolean(
-          config.consolidated_billing_enabled
-        )
-      }
       return
     }
 

src/platform/remoteConfig/remoteConfig.ts

@@ -59,8 +59,3 @@ export const cachedTeamWorkspacesEnabled = useStorage<boolean | undefined>(
   'team_workspaces_enabled' satisfies `${ServerFeatureFlag.TEAM_WORKSPACES_ENABLED}`,
   undefined
 )
-
-export const cachedConsolidatedBillingEnabled = useStorage<boolean | undefined>(
-  'consolidated_billing_enabled' satisfies `${ServerFeatureFlag.CONSOLIDATED_BILLING_ENABLED}`,
-  undefined
-)

src/platform/remoteConfig/types.ts

@@ -111,7 +111,6 @@ export type RemoteConfig = {
   comfyhub_upload_enabled?: boolean
   comfyhub_profile_gate_enabled?: boolean
   unified_cloud_auth?: boolean
-  consolidated_billing_enabled?: boolean
   sentry_dsn?: string
   turnstile_sitekey?: string
   // Raw, unvalidated wire value (a server typo like 'enfroce' is possible).

src/platform/settings/composables/useSettingUI.test.ts

@@ -11,49 +11,21 @@ import type { SettingTreeNode } from '@/platform/settings/settingStore'
 
 import { useSettingUI } from './useSettingUI'
 
-const env = vi.hoisted(() => {
-  const state = {
-    isCloud: false,
-    isDesktop: false,
-    isLoggedIn: false,
-    teamWorkspacesEnabled: false,
-    userSecretsEnabled: false,
-    isActiveSubscription: false,
-    billingType: 'legacy' as 'legacy' | 'workspace'
-  }
-  const fakeRef = <K extends keyof typeof state>(key: K) => ({
-    get value() {
-      return state[key]
-    }
-  })
-  return { state, fakeRef }
-})
-
 vi.mock('vue-i18n', () => ({
   useI18n: () => ({ t: (_: string, fallback: string) => fallback })
 }))
 
 vi.mock('@/composables/auth/useCurrentUser', () => ({
-  useCurrentUser: () => ({ isLoggedIn: env.fakeRef('isLoggedIn') })
+  useCurrentUser: () => ({ isLoggedIn: ref(false) })
 }))
 
 vi.mock('@/composables/billing/useBillingContext', () => ({
-  useBillingContext: () => ({
-    isActiveSubscription: env.fakeRef('isActiveSubscription'),
-    type: env.fakeRef('billingType')
-  })
+  useBillingContext: () => ({ isActiveSubscription: ref(false) })
 }))
 
 vi.mock('@/composables/useFeatureFlags', () => ({
   useFeatureFlags: () => ({
-    flags: {
-      get teamWorkspacesEnabled() {
-        return env.state.teamWorkspacesEnabled
-      },
-      get userSecretsEnabled() {
-        return env.state.userSecretsEnabled
-      }
-    }
+    flags: { teamWorkspacesEnabled: false, userSecretsEnabled: false }
   })
 }))
 
@@ -62,12 +34,8 @@ vi.mock('@/composables/useVueFeatureFlags', () => ({
 }))
 
 vi.mock('@/platform/distribution/types', () => ({
-  get isCloud() {
-    return env.state.isCloud
-  },
-  get isDesktop() {
-    return env.state.isDesktop
-  }
+  isCloud: false,
+  isDesktop: false
 }))
 
 vi.mock('@/platform/settings/settingStore', () => ({
@@ -109,16 +77,6 @@ describe('useSettingUI', () => {
     setActivePinia(createTestingPinia())
     vi.clearAllMocks()
 
-    Object.assign(env.state, {
-      isCloud: false,
-      isDesktop: false,
-      isLoggedIn: false,
-      teamWorkspacesEnabled: false,
-      userSecretsEnabled: false,
-      isActiveSubscription: false,
-      billingType: 'legacy'
-    })
-
     vi.mocked(useSettingStore).mockReturnValue({
       settingsById: mockSettings
     } as ReturnType<typeof useSettingStore>)
@@ -179,59 +137,4 @@ describe('useSettingUI', () => {
     const { defaultCategory } = useSettingUI('about', 'Comfy.Locale')
     expect(defaultCategory.value.key).toBe('about')
   })
-
-  describe('legacy billing in the workspace layout', () => {
-    const navKeys = (groups: { items: { id: string }[] }[]) =>
-      groups.flatMap((group) => group.items.map((item) => item.id))
-
-    beforeEach(() => {
-      Object.assign(env.state, {
-        isCloud: true,
-        isLoggedIn: true,
-        teamWorkspacesEnabled: true,
-        isActiveSubscription: true
-      })
-      window.__CONFIG__ = {
-        subscription_required: true
-      } as typeof window.__CONFIG__
-    })
-
-    it('exposes the legacy plan panel when billing is legacy', () => {
-      env.state.billingType = 'legacy'
-      const { defaultCategory, navGroups } = useSettingUI('subscription')
-
-      expect(defaultCategory.value.key).toBe('subscription')
-      expect(navKeys(navGroups.value)).toContain('subscription')
-      expect(navKeys(navGroups.value)).toContain('workspace')
-    })
-
-    it('hides the legacy plan panel when billing is workspace', () => {
-      env.state.billingType = 'workspace'
-      const { navGroups } = useSettingUI()
-
-      expect(navKeys(navGroups.value)).not.toContain('subscription')
-      expect(navKeys(navGroups.value)).toContain('workspace')
-    })
-
-    it('never renders the plan panel in more than one tab', () => {
-      const countSubscription = () => {
-        const { navGroups } = useSettingUI()
-        return navKeys(navGroups.value).filter((id) => id === 'subscription')
-          .length
-      }
-
-      for (const teamWorkspacesEnabled of [true, false]) {
-        for (const billingType of ['legacy', 'workspace'] as const) {
-          for (const isLoggedIn of [true, false]) {
-            Object.assign(env.state, {
-              teamWorkspacesEnabled,
-              billingType,
-              isLoggedIn
-            })
-            expect(countSubscription()).toBeLessThanOrEqual(1)
-          }
-        }
-      }
-    })
-  })
 })

src/platform/settings/composables/useSettingUI.ts

@@ -53,7 +53,7 @@ export function useSettingUI(
 
   const { flags } = useFeatureFlags()
   const { shouldRenderVueNodes } = useVueFeatureFlags()
-  const { isActiveSubscription, type: billingType } = useBillingContext()
+  const { isActiveSubscription } = useBillingContext()
 
   const teamWorkspacesEnabled = computed(
     () => isCloud && flags.teamWorkspacesEnabled
@@ -157,13 +157,6 @@ export function useSettingUI(
     return isActiveSubscription.value
   })
 
-  const shouldShowLegacyPlanCreditsPanel = computed(
-    () =>
-      isLoggedIn.value &&
-      billingType.value === 'legacy' &&
-      shouldShowPlanCreditsPanel.value
-  )
-
   const userPanel: SettingPanelItem = {
     node: {
       key: 'user',
@@ -308,9 +301,6 @@ export function useSettingUI(
       label: 'General',
       children: [
         translateCategory(userPanel.node),
-        ...(shouldShowLegacyPlanCreditsPanel.value && subscriptionPanel
-          ? [translateCategory(subscriptionPanel.node)]
-          : []),
         ...coreSettingCategories.value.slice(0, 1).map(translateCategory),
         ...(shouldShowSecretsPanel.value
           ? [translateCategory(secretsPanel.node)]
@@ -342,7 +332,9 @@ export function useSettingUI(
       label: 'Account',
       children: [
         userPanel.node,
-        ...(shouldShowLegacyPlanCreditsPanel.value && subscriptionPanel
+        ...(isLoggedIn.value &&
+        shouldShowPlanCreditsPanel.value &&
+        subscriptionPanel
           ? [subscriptionPanel.node]
           : []),
         ...(shouldShowSecretsPanel.value ? [secretsPanel.node] : []),

src/storybook/mocks/useFeatureFlags.ts

@@ -25,15 +25,13 @@ export enum ServerFeatureFlag {
   COMFYHUB_UPLOAD_ENABLED = 'comfyhub_upload_enabled',
   COMFYHUB_PROFILE_GATE_ENABLED = 'comfyhub_profile_gate_enabled',
   SHOW_SIGNIN_BUTTON = 'show_signin_button',
-  UNIFIED_CLOUD_AUTH = 'unified_cloud_auth',
-  CONSOLIDATED_BILLING_ENABLED = 'consolidated_billing_enabled'
+  UNIFIED_CLOUD_AUTH = 'unified_cloud_auth'
 }
 
 export function useFeatureFlags() {
   return {
     flags: {
-      teamWorkspacesEnabled: true,
-      consolidatedBillingEnabled: true
+      teamWorkspacesEnabled: true
     }
   }
 }

src/workbench/extensions/manager/composables/useConflictDetection.test.ts

@@ -14,7 +14,6 @@ import { useComfyManagerService } from '@/workbench/extensions/manager/services/
 import { useComfyManagerStore } from '@/workbench/extensions/manager/stores/comfyManagerStore'
 import { useConflictDetectionStore } from '@/workbench/extensions/manager/stores/conflictDetectionStore'
 import type { ConflictDetectionResult } from '@/workbench/extensions/manager/types/conflictDetectionTypes'
-import type * as ConflictUtils from '@/workbench/extensions/manager/utils/conflictUtils'
 import { checkVersionCompatibility } from '@/workbench/extensions/manager/utils/versionUtil'
 
 // Mock @vueuse/core until function
@@ -52,15 +51,41 @@ vi.mock('@/workbench/extensions/manager/utils/systemCompatibility', () => ({
   normalizeOSList: vi.fn((list) => list)
 }))
 
-vi.mock('@/workbench/extensions/manager/utils/conflictUtils', async () => {
-  const actual = await vi.importActual<typeof ConflictUtils>(
-    '@/workbench/extensions/manager/utils/conflictUtils'
-  )
-  return {
-    ...actual,
-    consolidateConflictsByPackage: vi.fn((results) => results)
-  }
-})
+vi.mock('@/workbench/extensions/manager/utils/conflictUtils', () => ({
+  consolidateConflictsByPackage: vi.fn((results) => results),
+  createBannedConflict: vi.fn((isBanned) =>
+    isBanned
+      ? {
+          type: 'banned',
+          current_value: 'installed',
+          required_value: 'not_banned'
+        }
+      : null
+  ),
+  createPendingConflict: vi.fn((isPending) =>
+    isPending
+      ? {
+          type: 'pending',
+          current_value: 'installed',
+          required_value: 'not_pending'
+        }
+      : null
+  ),
+  generateConflictSummary: vi.fn((results, duration) => ({
+    total_packages: results.length,
+    compatible_packages: results.filter(
+      (r: ConflictDetectionResult) => r.is_compatible
+    ).length,
+    conflicted_packages: results.filter(
+      (r: ConflictDetectionResult) => r.has_conflict
+    ).length,
+    banned_packages: 0,
+    pending_packages: 0,
+    conflicts_by_type_details: {},
+    last_check_timestamp: new Date().toISOString(),
+    check_duration_ms: duration
+  }))
+}))
 
 vi.mock(
   '@/workbench/extensions/manager/composables/useConflictAcknowledgment',
@@ -423,37 +448,6 @@ describe('useConflictDetection', () => {
     })
   })
 
-  describe('checkNodeCompatibility status derivation', () => {
-    it('flags a banned conflict for a Node with NodeStatusBanned', () => {
-      const { checkNodeCompatibility } = useConflictDetection()
-      const { conflicts } = checkNodeCompatibility({
-        status: 'NodeStatusBanned'
-      } as components['schemas']['Node'])
-
-      expect(conflicts.map((c) => c.type)).toContain('banned')
-    })
-
-    it('flags a banned conflict for a NodeVersion with NodeVersionStatusBanned', () => {
-      const { checkNodeCompatibility } = useConflictDetection()
-      const { conflicts } = checkNodeCompatibility({
-        status: 'NodeVersionStatusBanned'
-      } as components['schemas']['NodeVersion'])
-
-      expect(conflicts.map((c) => c.type)).toContain('banned')
-    })
-
-    it('flags a pending conflict for a NodeVersion with NodeVersionStatusPending', () => {
-      const { checkNodeCompatibility } = useConflictDetection()
-      const { conflicts } = checkNodeCompatibility({
-        status: 'NodeVersionStatusPending'
-      } as components['schemas']['NodeVersion'])
-
-      const types = conflicts.map((c) => c.type)
-      expect(types).toContain('pending')
-      expect(types).not.toContain('banned')
-    })
-  })
-
   describe('computed properties', () => {
     it('should expose conflict status from store', () => {
       mockConflictedPackages = [

src/workbench/extensions/manager/composables/useConflictDetection.ts

@@ -16,6 +16,7 @@ import type {
   RegistryOS
 } from '@/workbench/extensions/manager/types/compatibility.types'
 import type {
+  ConflictDetail,
   ConflictDetectionResponse,
   ConflictDetectionResult,
   ImportFailureMap,
@@ -25,10 +26,18 @@ import type {
 } from '@/workbench/extensions/manager/types/conflictDetectionTypes'
 import {
   consolidateConflictsByPackage,
-  evaluateCompatibility
+  createBannedConflict,
+  createPendingConflict
 } from '@/workbench/extensions/manager/utils/conflictUtils'
-import { normalizeOSList } from '@/workbench/extensions/manager/utils/systemCompatibility'
-import { getFrontendVersion } from '@/workbench/extensions/manager/utils/versionUtil'
+import {
+  checkAcceleratorCompatibility,
+  checkOSCompatibility,
+  normalizeOSList
+} from '@/workbench/extensions/manager/utils/systemCompatibility'
+import {
+  checkVersionCompatibility,
+  getFrontendVersion
+} from '@/workbench/extensions/manager/utils/versionUtil'
 
 /**
  * Composable for conflict detection system.
@@ -267,21 +276,51 @@ export function useConflictDetection() {
     packageReq: NodeRequirements,
     systemEnvInfo: SystemEnvironment
   ): ConflictDetectionResult {
-    const conflicts = evaluateCompatibility(
-      {
-        supported_os: packageReq.supported_os as RegistryOS[] | undefined,
-        supported_accelerators: packageReq.supported_accelerators as
-          | RegistryAccelerator[]
-          | undefined,
-        supported_comfyui_version: packageReq.supported_comfyui_version,
-        supported_comfyui_frontend_version:
-          packageReq.supported_comfyui_frontend_version,
-        isBanned: packageReq.is_banned,
-        isPending: packageReq.is_pending
-      },
-      systemEnvInfo
-    )
+    const conflicts: ConflictDetail[] = []
 
+    // 1. ComfyUI version conflict check
+    const versionConflict = checkVersionCompatibility(
+      'comfyui_version',
+      systemEnvInfo.comfyui_version,
+      packageReq.supported_comfyui_version
+    )
+    if (versionConflict) conflicts.push(versionConflict)
+
+    // 2. Frontend version conflict check
+    const frontendConflict = checkVersionCompatibility(
+      'frontend_version',
+      systemEnvInfo.frontend_version,
+      packageReq.supported_comfyui_frontend_version
+    )
+    if (frontendConflict) conflicts.push(frontendConflict)
+
+    // 3. OS compatibility check
+    const osConflict = checkOSCompatibility(
+      packageReq.supported_os as RegistryOS[] | undefined,
+      systemEnvInfo.os
+    )
+    if (osConflict) conflicts.push(osConflict)
+
+    // 4. Accelerator compatibility check
+    const acceleratorConflict = checkAcceleratorCompatibility(
+      packageReq.supported_accelerators as RegistryAccelerator[] | undefined,
+      systemEnvInfo.accelerator
+    )
+    if (acceleratorConflict) conflicts.push(acceleratorConflict)
+
+    // 5. Banned package check using shared logic
+    const bannedConflict = createBannedConflict(packageReq.is_banned)
+    if (bannedConflict) {
+      conflicts.push(bannedConflict)
+    }
+
+    // 6. Registry data availability check using shared logic
+    const pendingConflict = createPendingConflict(packageReq.is_pending)
+    if (pendingConflict) {
+      conflicts.push(pendingConflict)
+    }
+
+    // Generate result
     const hasConflict = conflicts.length > 0
 
     return {
@@ -576,26 +615,63 @@ export function useConflictDetection() {
   function checkNodeCompatibility(
     node: Node | components['schemas']['NodeVersion']
   ) {
-    const conflicts = evaluateCompatibility(
-      {
-        supported_os: normalizeOSList(node.supported_os),
-        supported_accelerators:
-          node.supported_accelerators as RegistryAccelerator[],
-        supported_comfyui_version: node.supported_comfyui_version,
-        supported_comfyui_frontend_version:
-          node.supported_comfyui_frontend_version,
-        isBanned:
-          node.status === 'NodeStatusBanned' ||
-          node.status === 'NodeVersionStatusBanned',
-        isPending: node.status === 'NodeVersionStatusPending'
-      },
-      {
-        comfyui_version: systemEnvironment.value?.comfyui_version,
-        frontend_version: getFrontendVersion(),
-        os: systemEnvironment.value?.os,
-        accelerator: systemEnvironment.value?.accelerator
-      }
+    const conflicts: ConflictDetail[] = []
+
+    // Check OS compatibility
+    const osConflict = checkOSCompatibility(
+      normalizeOSList(node.supported_os),
+      systemEnvironment.value?.os
     )
+    if (osConflict) {
+      conflicts.push(osConflict)
+    }
+
+    // Check Accelerator compatibility
+    const acceleratorConflict = checkAcceleratorCompatibility(
+      node.supported_accelerators as RegistryAccelerator[],
+      systemEnvironment.value?.accelerator
+    )
+    if (acceleratorConflict) {
+      conflicts.push(acceleratorConflict)
+    }
+
+    // Check ComfyUI version compatibility
+    const comfyUIVersionConflict = checkVersionCompatibility(
+      'comfyui_version',
+      systemEnvironment.value?.comfyui_version,
+      node.supported_comfyui_version
+    )
+    if (comfyUIVersionConflict) {
+      conflicts.push(comfyUIVersionConflict)
+    }
+
+    // Check ComfyUI Frontend version compatibility
+    const currentFrontendVersion = getFrontendVersion()
+    const frontendVersionConflict = checkVersionCompatibility(
+      'frontend_version',
+      currentFrontendVersion,
+      node.supported_comfyui_frontend_version
+    )
+    if (frontendVersionConflict) {
+      conflicts.push(frontendVersionConflict)
+    }
+
+    // Check banned package status using shared logic
+    const bannedConflict = createBannedConflict(
+      node.status === 'NodeStatusBanned' ||
+        node.status === 'NodeVersionStatusBanned'
+    )
+    if (bannedConflict) {
+      conflicts.push(bannedConflict)
+    }
+
+    // Check pending status using shared logic
+    const pendingConflict = createPendingConflict(
+      node.status === 'NodeVersionStatusPending'
+    )
+    if (pendingConflict) {
+      conflicts.push(pendingConflict)
+    }
 
     return {
       hasConflict: conflicts.length > 0,

src/workbench/extensions/manager/utils/conflictUtils.test.ts

@@ -7,71 +7,10 @@ import type {
 import {
   consolidateConflictsByPackage,
   createBannedConflict,
-  createPendingConflict,
-  evaluateCompatibility
+  createPendingConflict
 } from '@/workbench/extensions/manager/utils/conflictUtils'
 
 describe('conflictUtils', () => {
-  describe('evaluateCompatibility', () => {
-    const incompatibleEnv = {
-      comfyui_version: '0.3.0',
-      frontend_version: '1.0.0',
-      os: 'darwin',
-      accelerator: 'mps'
-    }
-
-    it('emits conflicts in canonical order when all six checks fail', () => {
-      const conflicts = evaluateCompatibility(
-        {
-          supported_comfyui_version: '>=1.0.0',
-          supported_comfyui_frontend_version: '>=2.0.0',
-          supported_os: ['Linux'],
-          supported_accelerators: ['CUDA'],
-          isBanned: true,
-          isPending: true
-        },
-        incompatibleEnv
-      )
-
-      expect(conflicts.map((conflict) => conflict.type)).toEqual([
-        'comfyui_version',
-        'frontend_version',
-        'os',
-        'accelerator',
-        'banned',
-        'pending'
-      ])
-    })
-
-    it('adds a banned conflict only when isBanned is true', () => {
-      const compatibleInput = {
-        supported_comfyui_version: undefined,
-        supported_comfyui_frontend_version: undefined,
-        supported_os: undefined,
-        supported_accelerators: undefined,
-        isPending: false
-      }
-
-      const withoutBan = evaluateCompatibility(
-        { ...compatibleInput, isBanned: false },
-        incompatibleEnv
-      )
-      expect(withoutBan).toEqual([])
-
-      const withBan = evaluateCompatibility(
-        { ...compatibleInput, isBanned: true },
-        incompatibleEnv
-      )
-      expect(withBan).toEqual([
-        {
-          type: 'banned',
-          current_value: 'installed',
-          required_value: 'not_banned'
-        }
-      ])
-    })
-  })
-
   describe('createBannedConflict', () => {
     it('should return banned conflict when isBanned is true', () => {
       const result = createBannedConflict(true)

src/workbench/extensions/manager/utils/conflictUtils.ts

@@ -1,20 +1,10 @@
 import { groupBy, uniqBy } from 'es-toolkit/compat'
 
 import { normalizePackId } from '@/utils/packUtils'
-import type {
-  RegistryAccelerator,
-  RegistryOS
-} from '@/workbench/extensions/manager/types/compatibility.types'
 import type {
   ConflictDetail,
-  ConflictDetectionResult,
-  SystemEnvironment
+  ConflictDetectionResult
 } from '@/workbench/extensions/manager/types/conflictDetectionTypes'
-import {
-  checkAcceleratorCompatibility,
-  checkOSCompatibility
-} from '@/workbench/extensions/manager/utils/systemCompatibility'
-import { checkVersionCompatibility } from '@/workbench/extensions/manager/utils/versionUtil'
 
 /**
  * Checks for banned package status conflicts.
@@ -48,69 +38,6 @@ export function createPendingConflict(
   return null
 }
 
-/**
- * Normalized compatibility inputs for a single package, produced by each call
- * site from its own source shape. Banned/pending are pre-derived booleans
- * because the two callers read different enums (see {@link evaluateCompatibility}).
- */
-export interface CompatibilityInput {
-  supported_os?: RegistryOS[]
-  supported_accelerators?: RegistryAccelerator[]
-  supported_comfyui_version?: string
-  supported_comfyui_frontend_version?: string
-  isBanned: boolean
-  isPending: boolean
-}
-
-/**
- * Runs the six compatibility leaf checks and collects the conflicts that fire.
- *
- * Canonical order = comfyui_version → frontend_version → OS → accelerator →
- * banned → pending. This is the order surfaced by the primary conflict dialog
- * (analyzePackageConflicts → runFullConflictAnalysis → WarningTabPanel); every
- * consumer filters conflicts by `.type`, so the order is cosmetic only.
- */
-export function evaluateCompatibility(
-  input: CompatibilityInput,
-  env: Pick<
-    SystemEnvironment,
-    'comfyui_version' | 'frontend_version' | 'os' | 'accelerator'
-  >
-): ConflictDetail[] {
-  const conflicts: ConflictDetail[] = []
-
-  const versionConflict = checkVersionCompatibility(
-    'comfyui_version',
-    env.comfyui_version,
-    input.supported_comfyui_version
-  )
-  if (versionConflict) conflicts.push(versionConflict)
-
-  const frontendConflict = checkVersionCompatibility(
-    'frontend_version',
-    env.frontend_version,
-    input.supported_comfyui_frontend_version
-  )
-  if (frontendConflict) conflicts.push(frontendConflict)
-
-  const osConflict = checkOSCompatibility(input.supported_os, env.os)
-  if (osConflict) conflicts.push(osConflict)
-
-  const acceleratorConflict = checkAcceleratorCompatibility(
-    input.supported_accelerators,
-    env.accelerator
-  )
-  if (acceleratorConflict) conflicts.push(acceleratorConflict)
-
-  const bannedConflict = createBannedConflict(input.isBanned)
-  if (bannedConflict) conflicts.push(bannedConflict)
-
-  const pendingConflict = createPendingConflict(input.isPending)
-  if (pendingConflict) conflicts.push(pendingConflict)
-
-  return conflicts
-}
-
 /**
  * Groups and deduplicates conflicts by normalized package name.
  * Consolidates multiple conflict sources (registry checks, import failures, disabled packages with version suffix)