ci: skip chromatic deploy for fork PRs

## Summary

Reworks the Comfy MCP page's **"Set up Comfy MCP in three steps"**
section to match the new design, and adds a per-action button `variant`
option to `FeatureGrid01`.

The three steps are now:

| Step | Title | Action |
| --- | --- | --- |
| 1 | Copy the MCP URL | Copy field showing
`https://cloud.comfy.org/mcp` |
| 2 | Add the connector | Filled button **"COMFY CLOUD MCP DOCS" ↗** →
MCP docs |
| 3 | Connect and sign in | Filled button **"COMFY CLOUD SKILLS" ↗** →
comfy-skills repo |

## Changes

- **`FeatureGrid01.vue`** — add `variant?: 'default' | 'outline'` to the
link card action; button now uses `card.action.variant ?? 'outline'`
instead of a hardcoded outline, so callers can opt into the filled
style.
- **`config/routes.ts`** — add `mcpSkills` external link
(`https://github.com/Comfy-Org/comfy-skills`).
- **`i18n/translations.ts`** — refresh the `mcp.setup.*` copy (en +
zh-CN): new subtitle, reworded steps, new `step2.cta` / `step3.cta`,
drop the now-unused `step1.cta`.
- **`SetupSection.vue`** — re-map cards: step 1 → copy field, steps 2 &
3 → filled link buttons.

## Test plan

- [x] `pnpm typecheck` — 0 errors
- [x] Pre-commit hooks (stylelint, oxfmt, oxlint, eslint, typecheck)
pass
- [ ] Visual check on `/mcp` and `/zh-CN/mcp` (copy field on step 1; two
filled yellow CTAs with up-right arrows on steps 2 & 3)

🤖 Generated with [Claude Code](https://claude.com/claude-code)

---------

Co-authored-by: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

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

@@ -95,6 +95,7 @@ jobs:
     if: |
       github.event_name == 'workflow_dispatch'
       || (github.event_name == 'pull_request'
+          && github.event.pull_request.head.repo.fork == false
           && startsWith(github.head_ref, 'version-bump-')
           && (needs.changes.outputs.storybook-changes == 'true'
               || needs.changes.outputs.app-frontend-changes == 'true'

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

@@ -35,8 +35,8 @@ jobs:
       - name: Setup frontend
         uses: ./.github/actions/setup-frontend
 
-      - name: Run Vitest critical coverage gate
-        run: pnpm test:coverage:critical
+      - name: Run Vitest tests with coverage
+        run: pnpm test:coverage
 
       - name: Upload unit coverage artifact
         if: always() && github.event_name == 'push'

.github/workflows/ci-vercel-website-preview.yaml

@@ -30,7 +30,7 @@ concurrency:
 
 jobs:
   deploy-preview:
-    if: github.event_name == 'pull_request'
+    if: github.event_name == 'pull_request' && github.event.pull_request.head.repo.fork == false
     runs-on: ubuntu-latest
     permissions:
       contents: read

.github/workflows/cloud-dispatch-build.yaml

@@ -32,12 +32,13 @@ jobs:
     if: >
       github.repository == 'Comfy-Org/ComfyUI_frontend' &&
       (github.event_name != 'pull_request' ||
-       (github.event.action == 'labeled' &&
-        contains(fromJSON('["preview","preview-cpu","preview-gpu"]'), github.event.label.name)) ||
-       (github.event.action == 'synchronize' &&
-        (contains(github.event.pull_request.labels.*.name, 'preview') ||
-         contains(github.event.pull_request.labels.*.name, 'preview-cpu') ||
-         contains(github.event.pull_request.labels.*.name, 'preview-gpu'))))
+       (github.event.pull_request.head.repo.fork == false &&
+        ((github.event.action == 'labeled' &&
+          contains(fromJSON('["preview","preview-cpu","preview-gpu"]'), github.event.label.name)) ||
+         (github.event.action == 'synchronize' &&
+          (contains(github.event.pull_request.labels.*.name, 'preview') ||
+           contains(github.event.pull_request.labels.*.name, 'preview-cpu') ||
+           contains(github.event.pull_request.labels.*.name, 'preview-gpu'))))))
     runs-on: ubuntu-latest
     steps:
       - name: Build client payload

.github/workflows/cloud-dispatch-cleanup.yaml

@@ -21,6 +21,7 @@ jobs:
     # - Preview label specifically removed
     if: >
       github.repository == 'Comfy-Org/ComfyUI_frontend' &&
+      github.event.pull_request.head.repo.fork == false &&
       ((github.event.action == 'closed' &&
         (contains(github.event.pull_request.labels.*.name, 'preview') ||
          contains(github.event.pull_request.labels.*.name, 'preview-cpu') ||

apps/website/public/icons/node-link.svg

@@ -1,3 +1,3 @@
-<svg width="20" height="32" viewBox="0 0 20 32" fill="none" xmlns="http://www.w3.org/2000/svg">
-<path d="M20 32V0C20 5.39616 15.5172 9.78053 10 9.78053C4.48276 9.78053 0 5.416 0 0V32C0 26.6038 4.48276 22.2195 10 22.2195C15.5172 22.2195 20 26.6038 20 32Z" fill="#F2FF59"/>
+<svg preserveAspectRatio="none" width="100%" height="100%" overflow="visible" style="display: block;" viewBox="0 0 20 32" fill="none" xmlns="http://www.w3.org/2000/svg">
+<path id="Vector" d="M20 32V0C20 5.39616 15.5172 9.78053 10 9.78053C4.48276 9.78053 0 5.416 0 0V32C0 26.6038 4.48276 22.2195 10 22.2195C15.5172 22.2195 20 26.6038 20 32Z" fill="var(--fill-0, #F2FF59)"/>
 </svg>

apps/website/src/components/blocks/FAQSplit01.vue

@@ -26,7 +26,7 @@ function toggle(index: number) {
 </script>
 
 <template>
-  <section class="max-w-9xl mx-auto px-4 py-24 md:px-20 md:py-40">
+  <section class="max-w-9xl mx-auto px-6 py-16 lg:py-24">
     <div class="flex flex-col gap-6 md:flex-row md:gap-16">
       <!-- Left heading -->
       <div

apps/website/src/components/blocks/FeatureGrid01.vue

@@ -0,0 +1,120 @@
+<script setup lang="ts">
+import { cn } from '@comfyorg/tailwind-utils'
+
+import type { Component } from 'vue'
+
+import Button from '@/components/ui/button/Button.vue'
+import CopyableField from '@/components/ui/copyable-field/CopyableField.vue'
+
+import SectionHeader from '../common/SectionHeader.vue'
+
+type CardAction =
+  | {
+      type: 'link'
+      label: string
+      href: string
+      target?: '_blank'
+      icon?: Component
+      variant?: 'default' | 'outline'
+    }
+  | { type: 'code'; value: string }
+
+export interface FeatureCard {
+  id: string
+  label?: string
+  title: string
+  description: string
+  action?: CardAction
+}
+
+type ColumnCount = 2 | 3 | 4
+
+const {
+  cards,
+  columns = 3,
+  copiedLabel,
+  copyLabel,
+  eyebrow,
+  heading,
+  subtitle
+} = defineProps<{
+  cards: readonly FeatureCard[]
+  columns?: ColumnCount
+  copiedLabel?: string
+  copyLabel?: string
+  eyebrow?: string
+  heading: string
+  subtitle?: string
+}>()
+
+const columnClass: Record<ColumnCount, string> = {
+  2: 'lg:grid-cols-2',
+  3: 'lg:grid-cols-3',
+  4: 'lg:grid-cols-4'
+}
+</script>
+
+<template>
+  <section class="max-w-9xl mx-auto px-6 py-16 lg:py-24">
+    <SectionHeader :label="eyebrow" align="start">
+      {{ heading }}
+      <template v-if="subtitle" #subtitle>
+        <p class="mt-4 max-w-xl text-sm text-smoke-700 lg:text-base">
+          {{ subtitle }}
+        </p>
+      </template>
+    </SectionHeader>
+
+    <div :class="cn('mt-16 grid grid-cols-1 gap-6', columnClass[columns])">
+      <div
+        v-for="card in cards"
+        :key="card.id"
+        class="bg-transparency-white-t4 flex flex-col rounded-3xl p-6 lg:p-8"
+      >
+        <p
+          v-if="card.label"
+          class="text-primary-comfy-yellow text-xs font-bold tracking-widest uppercase"
+        >
+          {{ card.label }}
+        </p>
+        <h3
+          :class="
+            cn(
+              'text-xl font-light text-primary-comfy-canvas lg:text-2xl',
+              card.label && 'mt-3'
+            )
+          "
+        >
+          {{ card.title }}
+        </h3>
+        <p class="mt-3 text-sm text-smoke-700">
+          {{ card.description }}
+        </p>
+
+        <div v-if="card.action" class="mt-6">
+          <Button
+            v-if="card.action.type === 'link'"
+            as="a"
+            :href="card.action.href"
+            :target="card.action.target"
+            :rel="
+              card.action.target === '_blank'
+                ? 'noopener noreferrer'
+                : undefined
+            "
+            :variant="card.action.variant ?? 'outline'"
+            :append-icon="card.action.icon"
+          >
+            {{ card.action.label }}
+          </Button>
+          <CopyableField
+            v-else
+            :value="card.action.value"
+            :copy-label="copyLabel"
+            :copied-label="copiedLabel"
+          />
+        </div>
+      </div>
+    </div>
+  </section>
+</template>

apps/website/src/components/blocks/FeatureGrid02.vue

@@ -0,0 +1,100 @@
+<script setup lang="ts">
+import Button from '@/components/ui/button/Button.vue'
+
+import SectionHeader from '../common/SectionHeader.vue'
+import NodeUnionIcon from '../icons/NodeUnionIcon.vue'
+
+type Cta = { label: string; href: string; target?: '_blank' }
+
+export interface FeatureStep {
+  id: string
+  number: string
+  title: string
+  description: string
+}
+
+defineProps<{
+  heading: string
+  steps: readonly FeatureStep[]
+  primaryCta?: Cta
+  secondaryCta?: Cta
+}>()
+</script>
+
+<template>
+  <section class="max-w-9xl mx-auto px-6 py-16 lg:py-24">
+    <SectionHeader>{{ heading }}</SectionHeader>
+
+    <!-- Step cards in a row, joined by node-union connectors on desktop -->
+    <div
+      class="mt-12 flex flex-col gap-4 lg:flex-row lg:items-stretch lg:gap-0"
+    >
+      <template v-for="(step, i) in steps" :key="step.id">
+        <div
+          v-if="i > 0"
+          class="relative z-10 -mx-px hidden shrink-0 items-center justify-center self-stretch lg:flex"
+          aria-hidden="true"
+        >
+          <NodeUnionIcon
+            class="text-primary-comfy-yellow size-4 scale-x-150 rotate-90"
+          />
+        </div>
+
+        <div
+          class="border-primary-comfy-yellow flex flex-1 flex-col rounded-[40px] border-2 bg-primary-comfy-ink p-2"
+        >
+          <div class="flex flex-1 flex-col gap-4 p-8">
+            <div>
+              <p
+                class="text-primary-comfy-yellow text-xs font-bold tracking-widest uppercase"
+              >
+                {{ step.number }}
+              </p>
+              <h3
+                class="mt-1 text-2xl font-medium tracking-widest text-primary-comfy-canvas uppercase"
+              >
+                {{ step.title }}
+              </h3>
+            </div>
+            <p class="text-primary-comfy-canvas">
+              {{ step.description }}
+            </p>
+          </div>
+        </div>
+      </template>
+    </div>
+
+    <div
+      v-if="primaryCta || secondaryCta"
+      class="mt-12 flex flex-col items-center gap-4 lg:flex-row lg:justify-center"
+    >
+      <Button
+        v-if="primaryCta"
+        as="a"
+        :href="primaryCta.href"
+        :target="primaryCta.target"
+        :rel="
+          primaryCta.target === '_blank' ? 'noopener noreferrer' : undefined
+        "
+        size="lg"
+        class="w-full lg:w-auto lg:min-w-48"
+      >
+        {{ primaryCta.label }}
+      </Button>
+      <Button
+        v-if="secondaryCta"
+        as="a"
+        :href="secondaryCta.href"
+        :target="secondaryCta.target"
+        :rel="
+          secondaryCta.target === '_blank' ? 'noopener noreferrer' : undefined
+        "
+        variant="outline"
+        size="lg"
+        class="w-full lg:w-auto lg:min-w-48"
+      >
+        {{ secondaryCta.label }}
+      </Button>
+    </div>
+  </section>
+</template>

apps/website/src/components/blocks/FeatureRows01.vue

@@ -0,0 +1,108 @@
+<script setup lang="ts">
+import { cn } from '@comfyorg/tailwind-utils'
+
+import type { Locale } from '../../i18n/translations'
+import GlassCard from '../common/GlassCard.vue'
+import SectionHeader from '../common/SectionHeader.vue'
+import VideoPlayer from '../common/VideoPlayer.vue'
+import type { VideoTrack } from '../common/VideoPlayer.vue'
+
+type RowMedia =
+  | { type: 'image'; src: string; alt?: string }
+  | {
+      type: 'video'
+      src: string
+      // <video> has no native alt; used as the player's accessible label.
+      alt?: string
+      poster?: string
+      tracks?: readonly VideoTrack[]
+      autoplay?: boolean
+      loop?: boolean
+      minimal?: boolean
+      hideControls?: boolean
+    }
+
+export interface FeatureRow {
+  id: string
+  title: string
+  description: string
+  media: RowMedia
+}
+
+const {
+  heading,
+  eyebrow,
+  locale = 'en',
+  rows
+} = defineProps<{
+  heading: string
+  eyebrow?: string
+  locale?: Locale
+  rows: readonly FeatureRow[]
+}>()
+</script>
+
+<template>
+  <section class="max-w-9xl mx-auto px-6 py-16 lg:py-24">
+    <SectionHeader :label="eyebrow" max-width="xl">
+      {{ heading }}
+    </SectionHeader>
+
+    <div class="mt-16 flex flex-col gap-4 lg:gap-6">
+      <GlassCard
+        v-for="(row, i) in rows"
+        :key="row.id"
+        class="flex flex-col gap-8 lg:flex-row lg:items-stretch lg:gap-0"
+      >
+        <!-- Text -->
+        <div
+          :class="
+            cn(
+              'order-2 flex flex-col justify-center gap-4 p-6 lg:w-1/2 lg:p-12',
+              i % 2 === 0 ? 'lg:order-1' : 'lg:order-2'
+            )
+          "
+        >
+          <h3 class="text-2xl font-light text-primary-comfy-canvas lg:text-3xl">
+            {{ row.title }}
+          </h3>
+          <p class="text-sm text-smoke-700 lg:text-base">
+            {{ row.description }}
+          </p>
+        </div>
+
+        <!-- Media: image or video -->
+        <div
+          :class="
+            cn(
+              'order-1 flex lg:w-1/2',
+              i % 2 === 0 ? 'lg:order-2' : 'lg:order-1'
+            )
+          "
+        >
+          <img
+            v-if="row.media.type === 'image'"
+            :src="row.media.src"
+            :alt="row.media.alt ?? row.title"
+            loading="lazy"
+            decoding="async"
+            class="aspect-4/3 w-full rounded-4xl object-cover"
+          />
+          <VideoPlayer
+            v-else
+            :locale="locale"
+            :aria-label="row.media.alt ?? row.title"
+            :src="row.media.src"
+            :poster="row.media.poster"
+            :tracks="row.media.tracks"
+            :autoplay="row.media.autoplay"
+            :loop="row.media.loop"
+            :minimal="row.media.minimal"
+            :hide-controls="row.media.hideControls"
+            class="w-full"
+          />
+        </div>
+      </GlassCard>
+    </div>
+  </section>
+</template>

apps/website/src/components/blocks/HeroSplit01.vue

@@ -1,6 +1,8 @@
 <script setup lang="ts">
 import { cn } from '@comfyorg/tailwind-utils'
 
+import type { HTMLAttributes } from 'vue'
+
 import type { Locale } from '../../i18n/translations'
 import BrandButton from '../common/BrandButton.vue'
 import ProductHeroBadge from '../common/ProductHeroBadge.vue'
@@ -27,6 +29,7 @@ const {
   badgeLogoAlt,
   title,
   titleHighlight,
+  subtitle,
   features = [],
   primaryCta,
   secondaryCta,
@@ -41,14 +44,17 @@ const {
   videoAutoplay = false,
   videoLoop = false,
   videoMinimal = false,
-  videoHideControls = false
+  videoHideControls = false,
+  class: className
 } = defineProps<{
   locale?: Locale
+  class?: HTMLAttributes['class']
   badgeText: string
   badgeLogoSrc?: string
   badgeLogoAlt?: string
   title: string
   titleHighlight?: string
+  subtitle?: string
   features?: string[]
   primaryCta: Cta
   secondaryCta?: Cta
@@ -72,7 +78,8 @@ const {
     :class="
       cn(
         'max-w-9xl relative mx-auto flex flex-col items-center gap-12 px-6 pt-20 pb-16 md:pt-28 md:pb-24 lg:items-center lg:gap-16 lg:px-16',
-        imagePosition === 'right' ? 'lg:flex-row' : 'lg:flex-row-reverse'
+        imagePosition === 'right' ? 'lg:flex-row' : 'lg:flex-row-reverse',
+        className
       )
     "
   >
@@ -84,7 +91,7 @@ const {
       />
 
       <h1
-        class="mt-8 text-2xl leading-[125%] font-light tracking-[-1.44px] text-primary-comfy-canvas md:text-4xl lg:text-5xl"
+        class="mt-8 text-2xl leading-[125%] font-light tracking-[-1.44px] whitespace-pre-line text-primary-comfy-canvas md:text-4xl lg:text-5xl"
       >
         <template v-if="titleHighlight">
           <span class="text-primary-warm-white">{{ titleHighlight }}</span>
@@ -93,6 +100,13 @@ const {
         <template v-else>{{ title }}</template>
       </h1>
 
+      <p
+        v-if="subtitle"
+        class="mt-6 max-w-xl text-base text-primary-comfy-canvas/80"
+      >
+        {{ subtitle }}
+      </p>
+
       <ul v-if="features.length" class="mt-8 space-y-3">
         <li
           v-for="feature in features"
@@ -127,27 +141,29 @@ const {
     </div>
 
     <div class="order-first w-full lg:order-last lg:flex-1">
-      <VideoPlayer
-        v-if="videoSrc"
-        :locale
-        :src="videoSrc"
-        :poster="videoPoster"
-        :tracks="videoTracks"
-        :autoplay="videoAutoplay"
-        :loop="videoLoop"
-        :minimal="videoMinimal"
-        :hide-controls="videoHideControls"
-      />
-      <img
-        v-else-if="imageSrc"
-        :src="imageSrc"
-        :alt="imageAlt"
-        :width="imageWidth"
-        :height="imageHeight"
-        fetchpriority="high"
-        decoding="async"
-        class="aspect-4/3 w-full rounded-3xl object-cover"
-      />
+      <slot name="media">
+        <VideoPlayer
+          v-if="videoSrc"
+          :locale
+          :src="videoSrc"
+          :poster="videoPoster"
+          :tracks="videoTracks"
+          :autoplay="videoAutoplay"
+          :loop="videoLoop"
+          :minimal="videoMinimal"
+          :hide-controls="videoHideControls"
+        />
+        <img
+          v-else-if="imageSrc"
+          :src="imageSrc"
+          :alt="imageAlt"
+          :width="imageWidth"
+          :height="imageHeight"
+          fetchpriority="high"
+          decoding="async"
+          class="aspect-4/3 w-full rounded-3xl object-cover"
+        />
+      </slot>
     </div>
   </section>
 </template>

apps/website/src/components/blocks/ReasonsSplit01.vue

@@ -0,0 +1,59 @@
+<script setup lang="ts">
+export interface Reason {
+  id: string
+  title: string
+  description: string
+}
+
+const { highlightClass = 'text-white' } = defineProps<{
+  heading: string
+  headingHighlight?: string
+  highlightClass?: string
+  subtitle?: string
+  reasons: readonly Reason[]
+}>()
+</script>
+
+<template>
+  <section
+    class="max-w-9xl mx-auto flex flex-col gap-4 px-6 py-16 lg:flex-row lg:gap-16 lg:py-24"
+  >
+    <!-- Left heading -->
+    <div
+      class="sticky top-20 z-10 w-full shrink-0 self-start bg-primary-comfy-ink py-4 lg:top-28 lg:w-115 lg:py-0"
+    >
+      <h2
+        class="text-4xl/16 font-light whitespace-pre-line text-primary-comfy-canvas lg:text-5xl/16"
+      >
+        {{ heading
+        }}<span v-if="headingHighlight" :class="highlightClass">{{
+          headingHighlight
+        }}</span>
+      </h2>
+      <p v-if="subtitle" class="mt-6 text-sm text-primary-comfy-canvas/70">
+        {{ subtitle }}
+      </p>
+    </div>
+
+    <!-- Right reasons list -->
+    <div class="flex-1">
+      <div
+        v-for="reason in reasons"
+        :key="reason.id"
+        class="flex flex-col gap-4 border-b border-primary-comfy-canvas/20 py-10 first:pt-0 lg:gap-12 xl:flex-row"
+      >
+        <div class="shrink-0 xl:w-84">
+          <h3
+            class="text-2xl font-light whitespace-pre-line text-primary-comfy-canvas"
+          >
+            {{ reason.title }}
+          </h3>
+          <slot name="reason-extra" :reason="reason" />
+        </div>
+        <p class="flex-1 text-sm text-primary-comfy-canvas/70">
+          {{ reason.description }}
+        </p>
+      </div>
+    </div>
+  </section>
+</template>

apps/website/src/components/common/SectionHeader.vue

@@ -7,12 +7,14 @@ const {
   label,
   headingTag = 'h2',
   maxWidth = 'lg',
-  headingSize = 'section'
+  headingSize = 'section',
+  align = 'center'
 } = defineProps<{
   label?: string
   headingTag?: 'h1' | 'h2' | 'h3'
   maxWidth?: 'md' | 'lg' | 'xl'
   headingSize?: 'section' | 'hero'
+  align?: 'center' | 'start'
 }>()
 
 const maxWidthClass = {
@@ -28,7 +30,14 @@ const headingSizeClass = {
 </script>
 
 <template>
-  <div :class="cn('mx-auto text-center', maxWidthClass[maxWidth])">
+  <div
+    :class="
+      cn(
+        maxWidthClass[maxWidth],
+        align === 'center' ? 'mx-auto text-center' : 'text-left'
+      )
+    "
+  >
     <SectionLabel v-if="label">{{ label }}</SectionLabel>
     <component
       :is="headingTag"

apps/website/src/components/common/SiteFooter.vue

@@ -37,7 +37,8 @@ const topColumns: { title: string; links: FooterLink[] }[] = [
       { label: t('nav.comfyLocal', locale), href: routes.download },
       { label: t('nav.comfyCloud', locale), href: routes.cloud },
       { label: t('nav.comfyApi', locale), href: routes.api },
-      { label: t('nav.comfyEnterprise', locale), href: routes.cloudEnterprise }
+      { label: t('nav.comfyEnterprise', locale), href: routes.cloudEnterprise },
+      { label: t('nav.mcpServer', locale), href: routes.mcp }
     ]
   },
   {

apps/website/src/components/ui/copyable-field/CopyableField.vue

@@ -0,0 +1,37 @@
+<script setup lang="ts">
+import { Check, Copy } from '@lucide/vue'
+import { useClipboard } from '@vueuse/core'
+
+// Interactive: the copy button is inert until its host island is hydrated.
+// Render under a `client:*` directive (e.g. `client:visible`) when the page
+// needs it to work.
+const {
+  value,
+  copyLabel = 'Copy',
+  copiedLabel = 'Copied'
+} = defineProps<{ value: string; copyLabel?: string; copiedLabel?: string }>()
+
+const { copy, copied } = useClipboard({ copiedDuring: 2000 })
+
+function handleCopy() {
+  void copy(value)
+}
+</script>
+
+<template>
+  <div
+    class="bg-transparency-white-t4 border-primary-warm-gray flex items-center gap-2 rounded-xl border px-4 py-3"
+  >
+    <span class="flex-1 truncate font-mono text-xs text-primary-comfy-canvas">
+      {{ value }}
+    </span>
+    <button
+      type="button"
+      :aria-label="copied ? copiedLabel : copyLabel"
+      class="text-primary-warm-gray shrink-0 cursor-pointer transition-colors hover:text-primary-comfy-canvas"
+      @click="handleCopy"
+    >
+      <component :is="copied ? Check : Copy" class="size-4" />
+    </button>
+  </div>
+</template>

apps/website/src/config/routes.ts

@@ -19,7 +19,8 @@ const baseRoutes = {
   affiliates: '/affiliates',
   affiliateTerms: '/affiliates/terms',
   contact: '/contact',
-  models: '/p/supported-models'
+  models: '/p/supported-models',
+  mcp: '/mcp'
 } as const
 
 type Routes = typeof baseRoutes
@@ -65,6 +66,8 @@ export const externalLinks = {
   github: 'https://github.com/Comfy-Org/ComfyUI',
   githubInstall: 'https://github.com/Comfy-Org/ComfyUI#installing',
   instagram: 'https://www.instagram.com/comfyui/',
+  mcpServer: 'https://cloud.comfy.org/mcp',
+  mcpSkills: 'https://github.com/Comfy-Org/comfy-skills',
   platform: 'https://platform.comfy.org',
   platformUsage: 'https://platform.comfy.org/profile/usage',
   reddit: 'https://www.reddit.com/r/comfyui/',

apps/website/src/data/learningTutorials.ts

@@ -38,7 +38,7 @@ export const learningTutorials: readonly LearningTutorial[] = [
         label: 'English'
       }
     ],
-    // href: '#',
+    href: 'https://comfy.org/workflows/8f2cf0df5da6-8f2cf0df5da6/',
     tags: [partnerNodesTag, imageToVideoTag]
   },
   {

apps/website/src/data/mainNavigation.ts

@@ -69,10 +69,19 @@ export function getMainNavigation(locale: Locale): NavItem[] {
         {
           header: t('nav.colFeatures', locale),
           items: [
+            {
+              label: t('nav.mcpServer', locale),
+              href: routes.mcp,
+              badge: 'new'
+            },
             // TODO: no page yet — re-enable when landing pages ship
-            // { label: t('nav.mcpServer', locale), href: '#', badge: 'new' },
             // { label: t('nav.appMode', locale), href: '#' },
             // { label: t('nav.agentSkills', locale), href: '#' },
+            {
+              label: t('nav.launches', locale),
+              href: routes.launches,
+              badge: 'new'
+            },
             {
               label: t('nav.docs', locale),
               href: externalLinks.docs,
@@ -180,11 +189,6 @@ export function getMainNavigation(locale: Locale): NavItem[] {
             },
             // TODO: no /brand page yet
             // { label: t('nav.brand', locale), href: '#' },
-            {
-              label: t('nav.launches', locale),
-              href: routes.launches,
-              badge: 'new'
-            },
             {
               label: t('nav.blogs', locale),
               href: externalLinks.blog,

apps/website/src/i18n/translations.ts

@@ -11,6 +11,16 @@ const translations = {
     'zh-CN': '图像生成视频'
   },
 
+  // UI (global, reusable across sections)
+  'ui.copy': {
+    en: 'Copy',
+    'zh-CN': '复制'
+  },
+  'ui.copied': {
+    en: 'Copied',
+    'zh-CN': '已复制'
+  },
+
   // CTAs (global, reusable across sections)
   'cta.tryWorkflow': {
     en: 'Try Workflow',
@@ -1825,6 +1835,311 @@ const translations = {
       '我们尽力为经历面试流程的候选人提供有意义的反馈。由于申请量较大，在简历筛选阶段可能无法提供详细反馈。'
   },
 
+  // MCP – Meta
+  'mcp.meta.title': {
+    en: 'Comfy MCP — Drive ComfyUI from any AI agent',
+    'zh-CN': 'Comfy MCP — 让任何 AI 智能体驱动 ComfyUI'
+  },
+  'mcp.meta.description': {
+    en: 'Comfy MCP exposes the full ComfyUI engine over the Model Context Protocol. Generate images, video, audio, and 3D from Claude Code, Claude Desktop, and any MCP-compatible client.',
+    'zh-CN':
+      'Comfy MCP 通过模型上下文协议暴露完整的 ComfyUI 引擎，可在 Claude Code、Claude Desktop 及任何兼容 MCP 的客户端中生成图像、视频、音频和 3D 内容。'
+  },
+
+  // MCP – HeroSection
+  'mcp.hero.heading': {
+    en: 'Drive ComfyUI from\nany AI agent.',
+    'zh-CN': '让任何 AI 智能体\n驱动 ComfyUI。'
+  },
+  'mcp.hero.subtitle': {
+    en: 'Comfy MCP exposes the full ComfyUI engine over the Model Context Protocol — so your assistant can access the ecosystem, build workflows, and generate images, video, audio, or 3D.',
+    'zh-CN':
+      'Comfy MCP 通过模型上下文协议暴露完整的 ComfyUI 引擎——让你的助手能够接入生态系统、构建工作流，并生成图像、视频、音频或 3D 内容。'
+  },
+  'mcp.hero.demoPrompt': {
+    en: "match this frame's palette, make the hero key art",
+    'zh-CN': '匹配这一帧的配色，生成主视觉关键画面'
+  },
+  'mcp.hero.viewDocs': {
+    en: 'VIEW DOCS',
+    'zh-CN': '查看文档'
+  },
+  'mcp.hero.runWorkflow': {
+    en: 'RUN A WORKFLOW',
+    'zh-CN': '运行工作流'
+  },
+  'mcp.hero.demoGenerate': {
+    en: 'GENERATE',
+    'zh-CN': '生成'
+  },
+  'mcp.hero.demoActionGenerateImage': {
+    en: 'GENERATE-IMAGE',
+    'zh-CN': '生成图像'
+  },
+  'mcp.hero.demoActionGenerate3d': {
+    en: 'GENERATE-3D ASSET',
+    'zh-CN': '生成 3D 资产'
+  },
+  'mcp.hero.demoActionUpscale': {
+    en: 'UPSCALE-IMAGE',
+    'zh-CN': '放大图像'
+  },
+
+  // MCP – SetupStepsSection
+  'mcp.setup.label': {
+    en: 'GET STARTED',
+    'zh-CN': '快速开始'
+  },
+  'mcp.setup.heading': {
+    en: 'Set up Comfy MCP in three steps',
+    'zh-CN': '三步完成 Comfy MCP 配置'
+  },
+  'mcp.setup.subtitle': {
+    en: 'Add Comfy Cloud as a custom connector in Claude, Cursor, Codex, or any MCP-compatible client. Sign in once, and the full ComfyUI toolset is available right in your chat.',
+    'zh-CN':
+      '将 Comfy Cloud 添加为 Claude、Cursor、Codex 或任意兼容 MCP 客户端的自定义连接器。登录一次，ComfyUI 全套工具即可直接在对话中使用。'
+  },
+  'mcp.setup.step1.label': { en: 'STEP 1', 'zh-CN': '第 1 步' },
+  'mcp.setup.step1.title': {
+    en: 'Copy the MCP URL',
+    'zh-CN': '复制 MCP URL'
+  },
+  'mcp.setup.step1.description': {
+    en: "Click the copy button below. You'll paste it into your client in the next step.",
+    'zh-CN': '点击下方的复制按钮，下一步将其粘贴到你的客户端中。'
+  },
+  'mcp.setup.step2.label': { en: 'STEP 2', 'zh-CN': '第 2 步' },
+  'mcp.setup.step2.title': {
+    en: 'Add the connector',
+    'zh-CN': '添加连接器'
+  },
+  'mcp.setup.step2.description': {
+    en: 'Name it Comfy Cloud and paste the URL. The docs below cover every client.',
+    'zh-CN': '将其命名为 Comfy Cloud 并粘贴 URL。下方文档涵盖各类客户端。'
+  },
+  'mcp.setup.step2.cta': {
+    en: 'COMFY CLOUD MCP DOCS',
+    'zh-CN': 'COMFY CLOUD MCP 文档'
+  },
+  'mcp.setup.step3.label': { en: 'STEP 3', 'zh-CN': '第 3 步' },
+  'mcp.setup.step3.title': {
+    en: 'Connect and sign in',
+    'zh-CN': '连接并登录'
+  },
+  'mcp.setup.step3.description': {
+    en: 'Click Connect, sign in, and every Comfy Cloud skill is ready in your client.',
+    'zh-CN': '点击"连接"并登录，所有 Comfy Cloud 技能即可在你的客户端中使用。'
+  },
+  'mcp.setup.step3.cta': {
+    en: 'COMFY CLOUD SKILLS',
+    'zh-CN': 'COMFY CLOUD 技能'
+  },
+
+  // MCP – WhyBuildSection
+  'mcp.why.heading': {
+    en: 'Why build on\n',
+    'zh-CN': '为什么选择\n'
+  },
+  'mcp.why.headingHighlight': {
+    en: 'Comfy MCP?',
+    'zh-CN': 'Comfy MCP？'
+  },
+  'mcp.why.subtitle': {
+    en: 'A trusted infrastructure that lets engineers and professionals ship faster.',
+    'zh-CN': '一套值得信赖的基础设施，让工程师和专业人士交付更快。'
+  },
+  'mcp.why.1.title': {
+    en: 'Open protocol,\nany client.',
+    'zh-CN': '开放协议，\n任意客户端。'
+  },
+  'mcp.why.1.description': {
+    en: 'MCP is an open standard, so any MCP-compatible client can connect. Today Comfy supports Claude Code and Claude Desktop, with more clients coming.',
+    'zh-CN':
+      'MCP 是开放标准，因此任何兼容 MCP 的客户端都能接入。目前 Comfy 支持 Claude Code 和 Claude Desktop，更多客户端即将推出。'
+  },
+  'mcp.why.2.title': {
+    en: 'The full engine,\nnot a sandbox.',
+    'zh-CN': '完整引擎，\n非沙箱环境。'
+  },
+  'mcp.why.2.description': {
+    en: 'Same tool your team uses. Fully connected multi-step, multi-GPU workflows. Everything available now and in the future.',
+    'zh-CN':
+      '与你团队使用的相同工具。完整连接的多步骤、多 GPU 工作流。当前及未来的所有功能均可使用。'
+  },
+  'mcp.why.3.title': {
+    en: 'Outputs you keep.',
+    'zh-CN': '输出归你所有。'
+  },
+  'mcp.why.3.description': {
+    en: 'Downloads go to your Comfy library — store, reuse, remix, and share without leaving the ecosystem.',
+    'zh-CN':
+      '下载内容保存到你的 Comfy 库——在生态系统内存储、复用、二次创作和分享。'
+  },
+  'mcp.why.4.title': {
+    en: 'Powered by\nComfy Cloud.',
+    'zh-CN': '由 Comfy Cloud\n提供支持。'
+  },
+  'mcp.why.4.description': {
+    en: 'Run without a local GPU through the same infrastructure your team already trusts.',
+    'zh-CN': '无需本地 GPU，通过你团队信赖的相同基础设施运行。'
+  },
+
+  // MCP – ToolsSection
+  'mcp.tools.heading': {
+    en: 'Everything ComfyUI can do,\nnow available as tools.',
+    'zh-CN': 'ComfyUI 能做的一切，\n现在都可作为工具调用。'
+  },
+  'mcp.tools.1.title': {
+    en: 'Generate anything',
+    'zh-CN': '生成任意内容'
+  },
+  'mcp.tools.1.description': {
+    en: 'Generate images, video, audio, 3D, upscale, or remove backgrounds. Add or remove elements in images, create or modify any visual, audio, or 3D asset at any scale.',
+    'zh-CN':
+      '生成图像、视频、音频、3D 内容，放大分辨率或移除背景。添加或删除图像元素，以任意规模创建或修改任何视觉、音频或 3D 资产。'
+  },
+  'mcp.tools.1.alt': {
+    en: 'Comfy MCP generating images, video, audio, and 3D assets from a single prompt',
+    'zh-CN': 'Comfy MCP 通过单个提示生成图像、视频、音频和 3D 资产'
+  },
+  'mcp.tools.2.title': {
+    en: 'Search the ecosystem',
+    'zh-CN': '搜索生态系统'
+  },
+  'mcp.tools.2.description': {
+    en: 'Query thousands of models, browse rankings, and choose workflow templates straight from your response.',
+    'zh-CN': '查询数千个模型，浏览排名，直接在对话中选择工作流模板。'
+  },
+  'mcp.tools.2.alt': {
+    en: 'Comfy MCP searching the ecosystem of models, rankings, and workflow templates',
+    'zh-CN': 'Comfy MCP 搜索模型、排名和工作流模板的生态系统'
+  },
+  'mcp.tools.3.title': {
+    en: 'Run real workflows',
+    'zh-CN': '运行真实工作流'
+  },
+  'mcp.tools.3.description': {
+    en: 'Turn any ComfyUI workflow into a callable tool. The full power of the engine, driven by your agent.',
+    'zh-CN':
+      '将任何 ComfyUI 工作流转换为可调用的工具。由你的智能体驱动完整的引擎能力。'
+  },
+  'mcp.tools.3.alt': {
+    en: 'Comfy MCP running a ComfyUI workflow as a callable tool from a chat',
+    'zh-CN': 'Comfy MCP 在对话中将 ComfyUI 工作流作为可调用工具运行'
+  },
+
+  // MCP – HowItWorksSection
+  'mcp.howItWorks.heading': {
+    en: 'How it works',
+    'zh-CN': '工作原理'
+  },
+  'mcp.howItWorks.step1.number': { en: '01', 'zh-CN': '01' },
+  'mcp.howItWorks.step1.title': {
+    en: 'CONNECT',
+    'zh-CN': '连接'
+  },
+  'mcp.howItWorks.step1.description': {
+    en: 'Add the Comfy Cloud MCP server to Claude Code or Claude Desktop and sign in once with OAuth. No API keys to manage.',
+    'zh-CN':
+      '将 Comfy Cloud MCP 服务器添加到 Claude Code 或 Claude Desktop，通过 OAuth 一次性登录。无需管理 API 密钥。'
+  },
+  'mcp.howItWorks.step2.number': { en: '02', 'zh-CN': '02' },
+  'mcp.howItWorks.step2.title': {
+    en: 'DISCOVER',
+    'zh-CN': '发现'
+  },
+  'mcp.howItWorks.step2.description': {
+    en: "Your agent gets Comfy's tools: search, generate, submit, and retrieve — everything it needs to create.",
+    'zh-CN':
+      '你的智能体获得 Comfy 的工具：搜索、生成、提交和获取——一切所需，应有尽有。'
+  },
+  'mcp.howItWorks.step3.number': { en: '03', 'zh-CN': '03' },
+  'mcp.howItWorks.step3.title': {
+    en: 'CREATE',
+    'zh-CN': '创作'
+  },
+  'mcp.howItWorks.step3.description': {
+    en: 'Request what you want, the agent queues and runs the workflow, and returns the finished result.',
+    'zh-CN': '描述你的需求，智能体排队执行工作流，并返回最终结果。'
+  },
+
+  // MCP – FAQSection
+  'mcp.faq.heading': {
+    en: 'Q&As',
+    'zh-CN': '常见问答'
+  },
+  'mcp.faq.1.q': {
+    en: 'Which clients are supported?',
+    'zh-CN': '支持哪些客户端？'
+  },
+  'mcp.faq.1.a': {
+    en: 'Claude Code and Claude Desktop today, both signing in with OAuth. Support for more clients is coming.',
+    'zh-CN':
+      '目前支持 Claude Code 和 Claude Desktop，均通过 OAuth 登录。更多客户端的支持即将推出。'
+  },
+  'mcp.faq.2.q': {
+    en: 'Do I need an API key?',
+    'zh-CN': '我需要 API 密钥吗？'
+  },
+  'mcp.faq.2.a': {
+    en: 'Not for Claude Code or Claude Desktop. They use OAuth. An API key is only needed for headless or CI setups with no browser.',
+    'zh-CN':
+      'Claude Code 和 Claude Desktop 不需要，它们使用 OAuth。仅在没有浏览器的无头或 CI 环境中才需要 API 密钥。'
+  },
+  'mcp.faq.3.q': {
+    en: 'Do the slash commands work in Claude Desktop?',
+    'zh-CN': '斜杠命令在 Claude Desktop 中可以使用吗？'
+  },
+  'mcp.faq.3.a': {
+    en: 'No. They ship in the Claude Code plugin. Desktop connects to the same MCP server, so the tools work; just ask in plain language.',
+    'zh-CN':
+      '不可以。斜杠命令包含在 Claude Code 插件中。Claude Desktop 连接的是同一个 MCP 服务器，因此工具可以正常使用；直接用自然语言提问即可。'
+  },
+  'mcp.faq.4.q': {
+    en: "The sign-in didn't open a browser.",
+    'zh-CN': '登录时没有打开浏览器。'
+  },
+  'mcp.faq.4.a': {
+    en: 'In Claude Code, run /mcp, select comfy-cloud, and choose Authenticate. In Claude Desktop, reopen the connector from Customize → Connectors.',
+    'zh-CN':
+      '在 Claude Code 中，运行 /mcp，选择 comfy-cloud，然后选择 Authenticate（授权）。在 Claude Desktop 中，从“自定义 → 连接器”重新打开该连接器。'
+  },
+  'mcp.faq.5.q': {
+    en: 'How do I connect in Claude Code?',
+    'zh-CN': '如何在 Claude Code 中连接？'
+  },
+  'mcp.faq.5.a': {
+    en: 'Add the marketplace and install the comfy-cloud plugin, then run /mcp → comfy-cloud → Authenticate. It adds the connection and slash commands in one step.',
+    'zh-CN':
+      '添加插件市场并安装 comfy-cloud 插件，然后运行 /mcp → comfy-cloud → Authenticate（授权）。一步即可添加连接和斜杠命令。'
+  },
+  'mcp.faq.6.q': {
+    en: "What's the server URL for Claude Desktop?",
+    'zh-CN': 'Claude Desktop 的服务器 URL 是什么？'
+  },
+  'mcp.faq.6.a': {
+    en: 'Add a custom connector in Customize → Connectors pointing to https://cloud.comfy.org/mcp, then sign in when prompted.',
+    'zh-CN':
+      '在“自定义 → 连接器”中添加一个指向 https://cloud.comfy.org/mcp 的自定义连接器，然后在提示时登录。'
+  },
+  'mcp.faq.7.q': {
+    en: 'What can my agent do once connected?',
+    'zh-CN': '连接后我的智能体能做什么？'
+  },
+  'mcp.faq.7.a': {
+    en: 'Generate images, video, audio, and 3D; search models, nodes, and templates; and run ComfyUI workflows, all from a chat.',
+    'zh-CN':
+      '生成图像、视频、音频和 3D；搜索模型、节点和模板；并运行 ComfyUI 工作流——全部在对话中完成。'
+  },
+  'mcp.faq.8.q': {
+    en: 'Is it generally available?',
+    'zh-CN': '现已正式发布了吗？'
+  },
+  'mcp.faq.8.a': {
+    en: 'Comfy Cloud MCP is in open beta and available to everyone.',
+    'zh-CN': 'Comfy Cloud MCP 目前处于公开测试阶段，所有人均可使用。'
+  },
+
   // SiteNav
   'nav.products': { en: 'Products', 'zh-CN': '产品' },
   'nav.pricing': { en: 'Pricing', 'zh-CN': '价格' },
@@ -1867,6 +2182,7 @@ const translations = {
   'nav.back': { en: 'BACK', 'zh-CN': '返回' },
   'nav.badgeNew': { en: 'NEW', 'zh-CN': '新' },
   // Column headers used in HeaderMainDesktop dropdowns
+  'nav.mcpServer': { en: 'Comfy MCP', 'zh-CN': 'Comfy MCP' },
   'nav.colFeatures': { en: 'Features', 'zh-CN': '功能' },
   'nav.colPrograms': { en: 'Programs', 'zh-CN': '项目' },
   'nav.colConnect': { en: 'Connect', 'zh-CN': '联系' },

apps/website/src/pages/mcp.astro

@@ -0,0 +1,24 @@
+---
+import BaseLayout from '../layouts/BaseLayout.astro'
+import ProductCardsSection from '../components/common/ProductCardsSection.vue'
+import HeroSection from '../templates/mcp/HeroSection.vue'
+import SetupSection from '../templates/mcp/SetupSection.vue'
+import WhySection from '../templates/mcp/WhySection.vue'
+import ToolsSection from '../templates/mcp/ToolsSection.vue'
+import HowItWorksSection from '../templates/mcp/HowItWorksSection.vue'
+import FAQSection from '../templates/mcp/FAQSection.vue'
+import { t } from '../i18n/translations'
+---
+
+<BaseLayout
+  title={t('mcp.meta.title', 'en')}
+  description={t('mcp.meta.description', 'en')}
+>
+  <HeroSection locale="en" client:load />
+  <SetupSection locale="en" client:visible />
+  <WhySection locale="en" />
+  <ToolsSection locale="en" />
+  <HowItWorksSection locale="en" />
+  <ProductCardsSection locale="en" label-key="products.labelProducts" />
+  <FAQSection client:visible locale="en" />
+</BaseLayout>

apps/website/src/pages/zh-CN/mcp.astro

@@ -0,0 +1,24 @@
+---
+import BaseLayout from '../../layouts/BaseLayout.astro'
+import ProductCardsSection from '../../components/common/ProductCardsSection.vue'
+import HeroSection from '../../templates/mcp/HeroSection.vue'
+import SetupSection from '../../templates/mcp/SetupSection.vue'
+import WhySection from '../../templates/mcp/WhySection.vue'
+import ToolsSection from '../../templates/mcp/ToolsSection.vue'
+import HowItWorksSection from '../../templates/mcp/HowItWorksSection.vue'
+import FAQSection from '../../templates/mcp/FAQSection.vue'
+import { t } from '../../i18n/translations'
+---
+
+<BaseLayout
+  title={t('mcp.meta.title', 'zh-CN')}
+  description={t('mcp.meta.description', 'zh-CN')}
+>
+  <HeroSection locale="zh-CN" client:load />
+  <SetupSection locale="zh-CN" client:visible />
+  <WhySection locale="zh-CN" />
+  <ToolsSection locale="zh-CN" />
+  <HowItWorksSection locale="zh-CN" />
+  <ProductCardsSection locale="zh-CN" label-key="products.labelProducts" />
+  <FAQSection client:visible locale="zh-CN" />
+</BaseLayout>

apps/website/src/styles/global.css

@@ -162,6 +162,45 @@
   animation: ripple-effect 4s linear infinite;
 }
 
+@keyframes cursor-blink {
+  0%,
+  100% {
+    opacity: 1;
+  }
+
+  50% {
+    opacity: 0;
+  }
+}
+
+@utility animate-cursor-blink {
+  animation: cursor-blink 1s step-end infinite;
+}
+
+.card-slide-enter-active {
+  transition:
+    transform 0.4s cubic-bezier(0.25, 0.46, 0.45, 0.94),
+    opacity 0.4s ease;
+}
+
+.card-slide-enter-from {
+  transform: translateX(56px);
+  opacity: 0;
+}
+
+/* Existing cards slide down smoothly when a new card is prepended. */
+.card-slide-move {
+  transition: transform 0.4s cubic-bezier(0.25, 0.46, 0.45, 0.94);
+}
+
+.card-slide-leave-active {
+  transition: opacity 0.2s ease;
+}
+
+.card-slide-leave-to {
+  opacity: 0;
+}
+
 @utility animate-delay-* {
   animation-delay: --value([*]);
 }

apps/website/src/templates/mcp/ComfyMcpDemo.vue

@@ -0,0 +1,195 @@
+<script setup lang="ts">
+import { Check } from '@lucide/vue'
+import { computed, onMounted, onUnmounted, ref } from 'vue'
+
+import type { Locale } from '../../i18n/translations'
+import { t } from '../../i18n/translations'
+
+const { locale = 'en' } = defineProps<{ locale?: Locale }>()
+
+const PROMPT = t('mcp.hero.demoPrompt', locale)
+const generateLabel = t('mcp.hero.demoGenerate', locale)
+
+const cards = [
+  {
+    actionKey: 'mcp.hero.demoActionGenerateImage',
+    file: 'moodboard_v1.png · 6-up',
+    tag: 'Gmail',
+    thumb: '/images/mcp/mcp-thumb-moodboard.webp'
+  },
+  {
+    actionKey: 'mcp.hero.demoActionGenerateImage',
+    file: 'concepts_01–03.png',
+    tag: 'Notion',
+    thumb: '/images/mcp/mcp-thumb-concepts.webp'
+  },
+  {
+    actionKey: 'mcp.hero.demoActionGenerateImage',
+    file: 'hero_keyart.png',
+    tag: 'Figma',
+    thumb: '/images/mcp/mcp-thumb-keyart.webp'
+  },
+  {
+    actionKey: 'mcp.hero.demoActionGenerate3d',
+    file: 'asphalt_pbr/ · 5 maps',
+    tag: 'Blender',
+    thumb: '/images/mcp/mcp-thumb-asphalt.webp'
+  },
+  {
+    actionKey: 'mcp.hero.demoActionUpscale',
+    file: 'kaiju_neon_4k.png · 4096',
+    tag: null,
+    thumb: '/images/mcp/mcp-thumb-kaiju.webp'
+  }
+] as const
+
+const visibleCount = ref(0)
+const displayedPrompt = ref('')
+const promptDone = ref(false)
+
+const displayedCards = computed(() =>
+  cards
+    .slice(0, visibleCount.value)
+    .map((card) => ({ ...card, action: t(card.actionKey, locale) }))
+    // Newest card first — it slides in right below the prompt box and pushes
+    // the rest down.
+    .reverse()
+)
+
+let timer: ReturnType<typeof setTimeout> | null = null
+let active = false
+
+function schedule(fn: () => void, ms: number) {
+  timer = setTimeout(() => {
+    if (active) fn()
+  }, ms)
+}
+
+function typePrompt(onDone: () => void) {
+  displayedPrompt.value = ''
+  promptDone.value = false
+  let i = 0
+
+  function step() {
+    i++
+    displayedPrompt.value = PROMPT.slice(0, i)
+    if (i < PROMPT.length) {
+      schedule(step, 35)
+    } else {
+      promptDone.value = true
+      schedule(onDone, 350)
+    }
+  }
+
+  schedule(step, 50)
+}
+
+function revealNextCard() {
+  if (visibleCount.value >= cards.length) {
+    // All done — pause then reset
+    schedule(() => {
+      visibleCount.value = 0
+      schedule(revealNextCard, 500)
+    }, 2500)
+    return
+  }
+
+  // Type the prompt, then slide in the next card
+  typePrompt(() => {
+    visibleCount.value++
+    schedule(revealNextCard, 400)
+  })
+}
+
+onMounted(() => {
+  active = true
+  schedule(revealNextCard, 600)
+})
+
+onUnmounted(() => {
+  active = false
+  if (timer) clearTimeout(timer)
+})
+</script>
+
+<template>
+  <div class="flex flex-col gap-6 max-lg:h-[50vh]">
+    <!-- Prompt panel -->
+    <div
+      class="rounded-5xl flex flex-col justify-between gap-8 overflow-hidden bg-white/4 p-8"
+    >
+      <p
+        class="font-formula text-[17px] leading-relaxed font-light text-primary-comfy-canvas"
+      >
+        {{ displayedPrompt
+        }}<span
+          class="bg-primary-comfy-yellow ml-0.5 inline-block h-5.5 w-2 translate-y-0.5"
+          :class="promptDone ? 'animate-cursor-blink' : ''"
+        />
+      </p>
+
+      <div class="flex items-center gap-3">
+        <div class="h-px flex-1 bg-white/10" />
+        <div
+          class="bg-primary-comfy-yellow font-formula rounded-2xl px-4 py-3 text-sm font-extrabold tracking-[0.7px] text-primary-comfy-ink uppercase"
+        >
+          {{ generateLabel }}
+        </div>
+      </div>
+    </div>
+
+    <!-- Cards accumulate — each slides in from the right after its prompt cycle -->
+    <div class="relative overflow-hidden max-lg:min-h-0 max-lg:flex-1">
+      <TransitionGroup
+        name="card-slide"
+        tag="div"
+        class="flex flex-col gap-2.5 max-lg:absolute max-lg:inset-x-0 max-lg:top-0"
+      >
+        <div
+          v-for="(card, i) in displayedCards"
+          :key="card.file"
+          class="flex items-center gap-3.5 overflow-hidden rounded-3xl px-4 py-3.5"
+          :class="i === 0 ? 'bg-white/8' : 'bg-white/4'"
+        >
+          <img
+            :src="card.thumb"
+            :alt="card.action"
+            class="size-13.5 shrink-0 rounded-[14px] object-cover"
+          />
+
+          <div class="flex min-w-0 flex-1 flex-col gap-1">
+            <p
+              class="font-formula text-primary-comfy-yellow text-xs font-extrabold tracking-[0.7px] uppercase"
+            >
+              {{ card.action }}
+            </p>
+            <p
+              class="font-formula truncate text-sm font-light text-primary-comfy-canvas"
+            >
+              {{ card.file }}
+            </p>
+          </div>
+
+          <span
+            v-if="card.tag"
+            class="font-formula relative isolate inline-flex h-8 shrink-0 items-center justify-center overflow-visible bg-transparent px-5 text-sm font-extrabold tracking-[0.7px] text-white/60 uppercase before:absolute before:inset-0 before:-z-10 before:-skew-x-12 before:rounded-sm before:bg-white/20"
+          >
+            <span class="ppformula-text-center">
+              {{ card.tag }}
+            </span>
+          </span>
+
+          <Check
+            class="size-4 shrink-0 text-primary-comfy-canvas/60"
+            :stroke-width="1.5"
+          />
+        </div>
+      </TransitionGroup>
+
+      <!-- Bottom fade so accumulating cards dissolve into the page background -->
+      <div
+        class="pointer-events-none absolute inset-x-0 bottom-0 z-10 h-32 bg-linear-to-t from-primary-comfy-ink to-transparent lg:hidden"
+      />
+    </div>
+  </div>
+</template>

apps/website/src/templates/mcp/FAQSection.vue

@@ -0,0 +1,19 @@
+<script setup lang="ts">
+import FAQSplit01 from '../../components/blocks/FAQSplit01.vue'
+import type { Locale } from '../../i18n/translations'
+import { t } from '../../i18n/translations'
+
+const { locale = 'en' } = defineProps<{ locale?: Locale }>()
+
+const faqNumbers = [1, 2, 3, 4, 5, 6, 7, 8] as const
+
+const faqs = faqNumbers.map((n) => ({
+  id: String(n),
+  question: t(`mcp.faq.${n}.q`, locale),
+  answer: t(`mcp.faq.${n}.a`, locale)
+}))
+</script>
+
+<template>
+  <FAQSplit01 :heading="t('mcp.faq.heading', locale)" :faqs="faqs" />
+</template>

apps/website/src/templates/mcp/HeroSection.vue

@@ -0,0 +1,27 @@
+<script setup lang="ts">
+import HeroSplit01 from '../../components/blocks/HeroSplit01.vue'
+import type { Locale } from '../../i18n/translations'
+import { t } from '../../i18n/translations'
+import ComfyMcpDemo from './ComfyMcpDemo.vue'
+import { mcpCtas } from './ctas'
+
+const { locale = 'en' } = defineProps<{ locale?: Locale }>()
+
+const ctas = mcpCtas(locale)
+</script>
+
+<template>
+  <HeroSplit01
+    :locale="locale"
+    class="min-h-screen"
+    badge-text="MCP"
+    :title="t('mcp.hero.heading', locale)"
+    :subtitle="t('mcp.hero.subtitle', locale)"
+    :primary-cta="ctas.runWorkflow"
+    :secondary-cta="ctas.docs"
+  >
+    <template #media>
+      <ComfyMcpDemo :locale="locale" />
+    </template>
+  </HeroSplit01>
+</template>

apps/website/src/templates/mcp/HowItWorksSection.vue

@@ -0,0 +1,29 @@
+<script setup lang="ts">
+import FeatureGrid02 from '../../components/blocks/FeatureGrid02.vue'
+import type { FeatureStep } from '../../components/blocks/FeatureGrid02.vue'
+import type { Locale } from '../../i18n/translations'
+import { t } from '../../i18n/translations'
+import { mcpCtas } from './ctas'
+
+const { locale = 'en' } = defineProps<{ locale?: Locale }>()
+
+const ctas = mcpCtas(locale)
+
+const stepNumbers = [1, 2, 3] as const
+
+const steps: FeatureStep[] = stepNumbers.map((n) => ({
+  id: String(n),
+  number: t(`mcp.howItWorks.step${n}.number`, locale),
+  title: t(`mcp.howItWorks.step${n}.title`, locale),
+  description: t(`mcp.howItWorks.step${n}.description`, locale)
+}))
+</script>
+
+<template>
+  <FeatureGrid02
+    :heading="t('mcp.howItWorks.heading', locale)"
+    :steps="steps"
+    :primary-cta="ctas.runWorkflow"
+    :secondary-cta="ctas.docs"
+  />
+</template>

apps/website/src/templates/mcp/SetupSection.vue

@@ -0,0 +1,64 @@
+<script setup lang="ts">
+import { ArrowUpRight } from '@lucide/vue'
+
+import FeatureGrid01 from '../../components/blocks/FeatureGrid01.vue'
+import type { FeatureCard } from '../../components/blocks/FeatureGrid01.vue'
+import { externalLinks } from '../../config/routes'
+import type { Locale } from '../../i18n/translations'
+import { t } from '../../i18n/translations'
+
+const { locale = 'en' } = defineProps<{ locale?: Locale }>()
+
+const cards: FeatureCard[] = [
+  {
+    id: 'step1',
+    label: t('mcp.setup.step1.label', locale),
+    title: t('mcp.setup.step1.title', locale),
+    description: t('mcp.setup.step1.description', locale),
+    action: {
+      type: 'code',
+      value: externalLinks.mcpServer
+    }
+  },
+  {
+    id: 'step2',
+    label: t('mcp.setup.step2.label', locale),
+    title: t('mcp.setup.step2.title', locale),
+    description: t('mcp.setup.step2.description', locale),
+    action: {
+      type: 'link',
+      label: t('mcp.setup.step2.cta', locale),
+      href: externalLinks.docsMcp,
+      target: '_blank',
+      icon: ArrowUpRight,
+      variant: 'default'
+    }
+  },
+  {
+    id: 'step3',
+    label: t('mcp.setup.step3.label', locale),
+    title: t('mcp.setup.step3.title', locale),
+    description: t('mcp.setup.step3.description', locale),
+    action: {
+      type: 'link',
+      label: t('mcp.setup.step3.cta', locale),
+      href: externalLinks.mcpSkills,
+      target: '_blank',
+      icon: ArrowUpRight,
+      variant: 'default'
+    }
+  }
+]
+</script>
+
+<template>
+  <FeatureGrid01
+    :eyebrow="t('mcp.setup.label', locale)"
+    :heading="t('mcp.setup.heading', locale)"
+    :subtitle="t('mcp.setup.subtitle', locale)"
+    :columns="3"
+    :cards="cards"
+    :copy-label="t('ui.copy', locale)"
+    :copied-label="t('ui.copied', locale)"
+  />
+</template>

apps/website/src/templates/mcp/ToolsSection.vue

@@ -0,0 +1,66 @@
+<script setup lang="ts">
+import FeatureRows01 from '../../components/blocks/FeatureRows01.vue'
+import type { FeatureRow } from '../../components/blocks/FeatureRows01.vue'
+import type { Locale, TranslationKey } from '../../i18n/translations'
+import { t } from '../../i18n/translations'
+
+const { locale = 'en' } = defineProps<{ locale?: Locale }>()
+
+type ToolMedia =
+  | { type: 'image'; src: string }
+  | {
+      type: 'video'
+      src: string
+      autoplay?: boolean
+      loop?: boolean
+      hideControls?: boolean
+    }
+
+const tools: { n: 1 | 2 | 3; media: ToolMedia; altKey?: TranslationKey }[] = [
+  {
+    n: 1,
+    media: {
+      type: 'image',
+      src: 'https://media.comfy.org/website/mcp/generate-everything.gif'
+    },
+    altKey: 'mcp.tools.1.alt'
+  },
+  {
+    n: 2,
+    media: {
+      type: 'image',
+      src: 'https://media.comfy.org/website/mcp/search-ecosystem.png'
+    },
+    altKey: 'mcp.tools.2.alt'
+  },
+  {
+    n: 3,
+    media: {
+      type: 'video',
+      src: 'https://media.comfy.org/website/mcp/run-real-workflows.mp4',
+      autoplay: true,
+      loop: true,
+      hideControls: true
+    },
+    altKey: 'mcp.tools.3.alt'
+  }
+]
+
+const rows: FeatureRow[] = tools.map(({ n, media, altKey }) => {
+  const alt = altKey ? t(altKey, locale) : undefined
+  return {
+    id: String(n),
+    title: t(`mcp.tools.${n}.title`, locale),
+    description: t(`mcp.tools.${n}.description`, locale),
+    media: { ...media, alt }
+  }
+})
+</script>
+
+<template>
+  <FeatureRows01
+    :locale="locale"
+    :heading="t('mcp.tools.heading', locale)"
+    :rows="rows"
+  />
+</template>

apps/website/src/templates/mcp/WhySection.vue

@@ -0,0 +1,26 @@
+<script setup lang="ts">
+import ReasonsSplit01 from '../../components/blocks/ReasonsSplit01.vue'
+import type { Reason } from '../../components/blocks/ReasonsSplit01.vue'
+import type { Locale } from '../../i18n/translations'
+import { t } from '../../i18n/translations'
+
+const { locale = 'en' } = defineProps<{ locale?: Locale }>()
+
+const reasonNumbers = [1, 2, 3, 4] as const
+
+const reasons: Reason[] = reasonNumbers.map((n) => ({
+  id: String(n),
+  title: t(`mcp.why.${n}.title`, locale),
+  description: t(`mcp.why.${n}.description`, locale)
+}))
+</script>
+
+<template>
+  <ReasonsSplit01
+    :heading="t('mcp.why.heading', locale)"
+    :heading-highlight="t('mcp.why.headingHighlight', locale)"
+    highlight-class="text-primary-comfy-yellow"
+    :subtitle="t('mcp.why.subtitle', locale)"
+    :reasons="reasons"
+  />
+</template>

apps/website/src/templates/mcp/ctas.ts

@@ -0,0 +1,27 @@
+import { externalLinks, getRoutes } from '../../config/routes'
+import type { Locale } from '../../i18n/translations'
+import { t } from '../../i18n/translations'
+
+export interface McpCta {
+  label: string
+  href: string
+  target?: '_blank'
+}
+
+/**
+ * The two calls-to-action shared by the MCP hero and "how it works" sections:
+ * view the docs, or run a workflow in the cloud.
+ */
+export function mcpCtas(locale: Locale): { docs: McpCta; runWorkflow: McpCta } {
+  return {
+    docs: {
+      label: t('mcp.hero.viewDocs', locale),
+      href: externalLinks.docsMcp,
+      target: '_blank'
+    },
+    runWorkflow: {
+      label: t('mcp.hero.runWorkflow', locale),
+      href: getRoutes(locale).cloud
+    }
+  }
+}

browser_tests/tests/cloud.spec.ts

@@ -14,44 +14,36 @@ const SHARE_AUTH_STORAGE_KEY = 'Comfy.PreservedQuery.share_auth'
  * routes and elements.
  */
 test.describe('Cloud distribution UI', { tag: '@cloud' }, () => {
-  test(
-    'cloud build redirects unauthenticated users to login',
-    { tag: '@critical' },
-    async ({ page }) => {
-      await page.goto(APP_URL)
-      // Cloud build has an auth guard that redirects to /cloud/login.
-      // This route only exists in the cloud distribution — it's tree-shaken
-      // in the OSS build. Its presence confirms the cloud build is active.
-      await expect(page).toHaveURL(/\/cloud\/login/, { timeout: 10_000 })
-    }
-  )
+  test('cloud build redirects unauthenticated users to login', async ({
+    page
+  }) => {
+    await page.goto(APP_URL)
+    // Cloud build has an auth guard that redirects to /cloud/login.
+    // This route only exists in the cloud distribution — it's tree-shaken
+    // in the OSS build. Its presence confirms the cloud build is active.
+    await expect(page).toHaveURL(/\/cloud\/login/, { timeout: 10_000 })
+  })
 
-  test(
-    'preserves share auth attribution before redirecting logged-out users',
-    { tag: '@critical' },
-    async ({ page }) => {
-      await page.goto(new URL('/?share=abc', APP_URL).toString())
+  test('preserves share auth attribution before redirecting logged-out users', async ({
+    page
+  }) => {
+    await page.goto(new URL('/?share=abc', APP_URL).toString())
 
-      await expect(page).toHaveURL(/\/cloud\/login/, { timeout: 10_000 })
-      await expect
-        .poll(() =>
-          page.evaluate(
-            (key) => sessionStorage.getItem(key),
-            SHARE_AUTH_STORAGE_KEY
-          )
+    await expect(page).toHaveURL(/\/cloud\/login/, { timeout: 10_000 })
+    await expect
+      .poll(() =>
+        page.evaluate(
+          (key) => sessionStorage.getItem(key),
+          SHARE_AUTH_STORAGE_KEY
         )
-        .toBe(JSON.stringify({ share: 'abc' }))
-    }
-  )
+      )
+      .toBe(JSON.stringify({ share: 'abc' }))
+  })
 
-  test(
-    'cloud login page renders sign-in options',
-    { tag: '@critical' },
-    async ({ page }) => {
-      await page.goto(APP_URL)
-      await expect(page).toHaveURL(/\/cloud\/login/, { timeout: 10_000 })
-      // Verify cloud-specific login UI is rendered
-      await expect(page.getByRole('button', { name: /google/i })).toBeVisible()
-    }
-  )
+  test('cloud login page renders sign-in options', async ({ page }) => {
+    await page.goto(APP_URL)
+    await expect(page).toHaveURL(/\/cloud\/login/, { timeout: 10_000 })
+    // Verify cloud-specific login UI is rendered
+    await expect(page.getByRole('button', { name: /google/i })).toBeVisible()
+  })
 })

browser_tests/tests/execution.spec.ts

@@ -97,38 +97,34 @@ test.describe(
   'Execute to selected output nodes',
   { tag: ['@smoke', '@workflow'] },
   () => {
-    test(
-      'Execute to selected output nodes',
-      { tag: '@critical' },
-      async ({ comfyPage }) => {
-        await comfyPage.workflow.loadWorkflow('execution/partial_execution')
-        const input = await comfyPage.nodeOps.getNodeRefById(3)
-        const output1 = await comfyPage.nodeOps.getNodeRefById(1)
-        const output2 = await comfyPage.nodeOps.getNodeRefById(4)
-        await expect
-          .poll(async () => (await input.getWidget(0)).getValue())
-          .toBe('foo')
-        await expect
-          .poll(async () => (await output1.getWidget(0)).getValue())
-          .toBe('')
-        await expect
-          .poll(async () => (await output2.getWidget(0)).getValue())
-          .toBe('')
+    test('Execute to selected output nodes', async ({ comfyPage }) => {
+      await comfyPage.workflow.loadWorkflow('execution/partial_execution')
+      const input = await comfyPage.nodeOps.getNodeRefById(3)
+      const output1 = await comfyPage.nodeOps.getNodeRefById(1)
+      const output2 = await comfyPage.nodeOps.getNodeRefById(4)
+      await expect
+        .poll(async () => (await input.getWidget(0)).getValue())
+        .toBe('foo')
+      await expect
+        .poll(async () => (await output1.getWidget(0)).getValue())
+        .toBe('')
+      await expect
+        .poll(async () => (await output2.getWidget(0)).getValue())
+        .toBe('')
 
-        await output1.click('title')
+      await output1.click('title')
 
-        await comfyPage.command.executeCommand('Comfy.QueueSelectedOutputNodes')
-        await expect
-          .poll(async () => (await input.getWidget(0)).getValue())
-          .toBe('foo')
-        await expect
-          .poll(async () => (await output1.getWidget(0)).getValue())
-          .toBe('foo')
-        await expect
-          .poll(async () => (await output2.getWidget(0)).getValue())
-          .toBe('')
-      }
-    )
+      await comfyPage.command.executeCommand('Comfy.QueueSelectedOutputNodes')
+      await expect
+        .poll(async () => (await input.getWidget(0)).getValue())
+        .toBe('foo')
+      await expect
+        .poll(async () => (await output1.getWidget(0)).getValue())
+        .toBe('foo')
+      await expect
+        .poll(async () => (await output2.getWidget(0)).getValue())
+        .toBe('')
+    })
   }
 )
 

browser_tests/tests/extensionAPI.spec.ts

@@ -13,37 +13,33 @@ import { comfyPageFixture as test } from '@e2e/fixtures/ComfyPage'
 type TestSettingId = keyof Settings
 
 test.describe('Topbar commands', () => {
-  test(
-    'Should allow registering topbar commands',
-    { tag: '@critical' },
-    async ({ comfyPage }) => {
-      await comfyPage.page.evaluate(() => {
-        window.app!.registerExtension({
-          name: 'TestExtension1',
-          commands: [
-            {
-              id: 'foo',
-              label: 'foo-command',
-              function: () => {
-                window.foo = true
-              }
+  test('Should allow registering topbar commands', async ({ comfyPage }) => {
+    await comfyPage.page.evaluate(() => {
+      window.app!.registerExtension({
+        name: 'TestExtension1',
+        commands: [
+          {
+            id: 'foo',
+            label: 'foo-command',
+            function: () => {
+              window.foo = true
             }
-          ],
-          menuCommands: [
-            {
-              path: ['ext'],
-              commands: ['foo']
-            }
-          ]
-        })
+          }
+        ],
+        menuCommands: [
+          {
+            path: ['ext'],
+            commands: ['foo']
+          }
+        ]
       })
+    })
 
-      await comfyPage.menu.topbar.triggerTopbarCommand(['ext', 'foo-command'])
-      await expect
-        .poll(() => comfyPage.page.evaluate(() => window.foo))
-        .toBe(true)
-    }
-  )
+    await comfyPage.menu.topbar.triggerTopbarCommand(['ext', 'foo-command'])
+    await expect
+      .poll(() => comfyPage.page.evaluate(() => window.foo))
+      .toBe(true)
+  })
 
   test('Should not allow register command defined in other extension', async ({
     comfyPage

browser_tests/tests/graph.spec.ts

@@ -22,15 +22,11 @@ test.describe('Graph', { tag: ['@smoke', '@canvas'] }, () => {
       .toBe(1)
   })
 
-  test(
-    'Validate workflow links',
-    { tag: '@critical' },
-    async ({ comfyPage }) => {
-      await comfyPage.settings.setSetting('Comfy.Validation.Workflows', true)
-      await comfyPage.workflow.loadWorkflow('links/bad_link')
-      await expect(comfyPage.toast.visibleToasts).toHaveCount(2)
-    }
-  )
+  test('Validate workflow links', async ({ comfyPage }) => {
+    await comfyPage.settings.setSetting('Comfy.Validation.Workflows', true)
+    await comfyPage.workflow.loadWorkflow('links/bad_link')
+    await expect(comfyPage.toast.visibleToasts).toHaveCount(2)
+  })
 
   // Regression: duplicate links with shifted target_slot (widget-to-input
   // conversion) caused the wrong link to survive during deduplication.

browser_tests/tests/nodeSearchBoxV2.spec.ts

@@ -8,24 +8,20 @@ test.describe('Node search box V2', { tag: '@node' }, () => {
     await comfyPage.searchBoxV2.setup()
   })
 
-  test(
-    'Can open search and add node',
-    { tag: '@critical' },
-    async ({ comfyPage }) => {
-      const { searchBoxV2 } = comfyPage
-      const initialCount = await comfyPage.nodeOps.getGraphNodesCount()
+  test('Can open search and add node', async ({ comfyPage }) => {
+    const { searchBoxV2 } = comfyPage
+    const initialCount = await comfyPage.nodeOps.getGraphNodesCount()
 
-      await searchBoxV2.open()
-      await searchBoxV2.input.fill('KSampler')
-      await expect(searchBoxV2.results.first()).toBeVisible()
+    await searchBoxV2.open()
+    await searchBoxV2.input.fill('KSampler')
+    await expect(searchBoxV2.results.first()).toBeVisible()
 
-      await comfyPage.page.keyboard.press('Enter')
-      await expect(searchBoxV2.input).toBeHidden()
-      await expect
-        .poll(() => comfyPage.nodeOps.getGraphNodesCount())
-        .toBe(initialCount + 1)
-    }
-  )
+    await comfyPage.page.keyboard.press('Enter')
+    await expect(searchBoxV2.input).toBeHidden()
+    await expect
+      .poll(() => comfyPage.nodeOps.getGraphNodesCount())
+      .toBe(initialCount + 1)
+  })
 
   test('Can add first default result with Enter', async ({ comfyPage }) => {
     const { searchBoxV2 } = comfyPage

browser_tests/tests/propertiesPanel/errorsTabMissingModels.spec.ts

@@ -33,21 +33,19 @@ test.describe('Errors tab - Missing models', { tag: '@ui' }, () => {
     await cleanupFakeModel(comfyPage)
   })
 
-  test(
-    'Should show missing models group in errors tab',
-    { tag: '@critical' },
-    async ({ comfyPage }) => {
-      await loadWorkflowAndOpenErrorsTab(comfyPage, 'missing/missing_models')
+  test('Should show missing models group in errors tab', async ({
+    comfyPage
+  }) => {
+    await loadWorkflowAndOpenErrorsTab(comfyPage, 'missing/missing_models')
 
-      const missingModelsGroup = comfyPage.page.getByTestId(
-        TestIds.dialogs.missingModelsGroup
-      )
-      await expect(missingModelsGroup).toBeVisible()
-      await expect(
-        missingModelsGroup.getByTestId(TestIds.dialogs.errorGroupDisplayMessage)
-      ).toHaveText(/\S/)
-    }
-  )
+    const missingModelsGroup = comfyPage.page.getByTestId(
+      TestIds.dialogs.missingModelsGroup
+    )
+    await expect(missingModelsGroup).toBeVisible()
+    await expect(
+      missingModelsGroup.getByTestId(TestIds.dialogs.errorGroupDisplayMessage)
+    ).toHaveText(/\S/)
+  })
 
   test('Should display model name and metadata', async ({ comfyPage }) => {
     await loadWorkflowAndOpenErrorsTab(comfyPage, 'missing/missing_models')

browser_tests/tests/propertiesPanel/errorsTabMissingNodes.spec.ts

@@ -12,25 +12,23 @@ test.describe('Errors tab - Missing nodes', { tag: ['@ui', '@canvas'] }, () => {
     )
   })
 
-  test(
-    'Should show missing node pack card with guidance',
-    { tag: '@critical' },
-    async ({ comfyPage }) => {
-      await loadWorkflowAndOpenErrorsTab(comfyPage, 'missing/missing_nodes')
+  test('Should show missing node pack card with guidance', async ({
+    comfyPage
+  }) => {
+    await loadWorkflowAndOpenErrorsTab(comfyPage, 'missing/missing_nodes')
 
-      const missingNodeGroup = comfyPage.page.getByTestId(
-        TestIds.dialogs.missingNodePacksGroup
-      )
+    const missingNodeGroup = comfyPage.page.getByTestId(
+      TestIds.dialogs.missingNodePacksGroup
+    )
 
-      await expect(
-        comfyPage.page.getByTestId(TestIds.dialogs.missingNodeCard)
-      ).toBeVisible()
-      await expect(missingNodeGroup).toBeVisible()
-      await expect(
-        missingNodeGroup.getByTestId(TestIds.dialogs.errorGroupDisplayMessage)
-      ).toHaveText(/\S/)
-    }
-  )
+    await expect(
+      comfyPage.page.getByTestId(TestIds.dialogs.missingNodeCard)
+    ).toBeVisible()
+    await expect(missingNodeGroup).toBeVisible()
+    await expect(
+      missingNodeGroup.getByTestId(TestIds.dialogs.errorGroupDisplayMessage)
+    ).toHaveText(/\S/)
+  })
 
   test('Should show unknown pack node rows by default', async ({
     comfyPage

browser_tests/tests/queue/queueOverlay.spec.ts

@@ -54,19 +54,13 @@ test.describe('Queue overlay', () => {
     await comfyPage.setup()
   })
 
-  test(
-    'Toggle button opens expanded queue overlay',
-    { tag: '@critical' },
-    async ({ comfyPage }) => {
-      const toggle = comfyPage.page.getByTestId(TestIds.queue.overlayToggle)
-      await toggle.click()
+  test('Toggle button opens expanded queue overlay', async ({ comfyPage }) => {
+    const toggle = comfyPage.page.getByTestId(TestIds.queue.overlayToggle)
+    await toggle.click()
 
-      // Expanded overlay should show job items
-      await expect(
-        comfyPage.page.locator('[data-job-id]').first()
-      ).toBeVisible()
-    }
-  )
+    // Expanded overlay should show job items
+    await expect(comfyPage.page.locator('[data-job-id]').first()).toBeVisible()
+  })
 
   test('Overlay shows filter tabs (All, Completed)', async ({ comfyPage }) => {
     const toggle = comfyPage.page.getByTestId(TestIds.queue.overlayToggle)

browser_tests/tests/subgraph/subgraphSerialization.spec.ts

@@ -129,7 +129,7 @@ async function expectPromotedWidgetsToResolveToInteriorNodes(
 test.describe('Subgraph Serialization', { tag: ['@subgraph'] }, () => {
   test(
     'Legacy primitive proxy widgets migrate to host inputs without proxyWidgets round-trip',
-    { tag: ['@vue-nodes', '@critical'] },
+    { tag: ['@vue-nodes'] },
     async ({ comfyPage }) => {
       await comfyPage.workflow.loadWorkflow(
         'subgraphs/subgraph-with-link-and-proxied-primitive'

package.json

@@ -51,11 +51,8 @@
     "stylelint": "stylelint --cache '{apps,packages,src}/**/*.{css,vue}'",
     "test:browser": "pnpm exec playwright test",
     "test:browser:coverage": "cross-env COLLECT_COVERAGE=true pnpm test:browser",
-    "test:browser:critical": "pnpm exec playwright test --project=chromium --grep @critical",
-    "test:browser:cloud-critical": "pnpm exec playwright test --project=cloud --grep @critical",
     "test:browser:local": "cross-env PLAYWRIGHT_LOCAL=1 PLAYWRIGHT_TEST_URL=http://localhost:5173 pnpm test:browser",
     "test:coverage": "vitest run --coverage",
-    "test:coverage:critical": "cross-env COVERAGE_CRITICAL=true vitest run --coverage",
     "test:unit": "vitest run",
     "typecheck": "vue-tsc --noEmit",
     "typecheck:browser": "vue-tsc --project browser_tests/tsconfig.json",

src/base/common/async.test.ts

@@ -1,75 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
-
-describe('runWhenGlobalIdle', () => {
-  beforeEach(() => {
-    vi.resetModules()
-  })
-
-  afterEach(() => {
-    vi.useRealTimers()
-    vi.unstubAllGlobals()
-  })
-
-  it('falls back to a timeout when idle callbacks are unavailable', async () => {
-    vi.useFakeTimers()
-    vi.stubGlobal('requestIdleCallback', undefined)
-    vi.stubGlobal('cancelIdleCallback', undefined)
-    const { runWhenGlobalIdle } = await import('./async')
-    const runner = vi.fn()
-
-    const disposable = runWhenGlobalIdle(runner)
-    await vi.runAllTimersAsync()
-
-    expect(runner).toHaveBeenCalledOnce()
-    const deadline = runner.mock.calls[0][0]
-    expect(deadline.didTimeout).toBe(true)
-    expect(deadline.timeRemaining()).toBeGreaterThanOrEqual(0)
-
-    disposable.dispose()
-    disposable.dispose()
-  })
-
-  it('cancels fallback idle work before it runs', async () => {
-    vi.useFakeTimers()
-    vi.stubGlobal('requestIdleCallback', undefined)
-    vi.stubGlobal('cancelIdleCallback', undefined)
-    const { runWhenGlobalIdle } = await import('./async')
-    const runner = vi.fn()
-
-    runWhenGlobalIdle(runner).dispose()
-    await vi.runAllTimersAsync()
-
-    expect(runner).not.toHaveBeenCalled()
-  })
-
-  it('uses native idle callbacks when available', async () => {
-    const requestIdleCallback = vi.fn(() => 42)
-    const cancelIdleCallback = vi.fn()
-    vi.stubGlobal('requestIdleCallback', requestIdleCallback)
-    vi.stubGlobal('cancelIdleCallback', cancelIdleCallback)
-    const { runWhenGlobalIdle } = await import('./async')
-    const runner = vi.fn()
-
-    const disposable = runWhenGlobalIdle(runner, 250)
-
-    expect(requestIdleCallback).toHaveBeenCalledWith(runner, { timeout: 250 })
-
-    disposable.dispose()
-    disposable.dispose()
-
-    expect(cancelIdleCallback).toHaveBeenCalledOnce()
-    expect(cancelIdleCallback).toHaveBeenCalledWith(42)
-  })
-
-  it('omits native idle timeout options when no timeout is supplied', async () => {
-    const requestIdleCallback = vi.fn(() => 7)
-    vi.stubGlobal('requestIdleCallback', requestIdleCallback)
-    vi.stubGlobal('cancelIdleCallback', vi.fn())
-    const { runWhenGlobalIdle } = await import('./async')
-    const runner = vi.fn()
-
-    runWhenGlobalIdle(runner)
-
-    expect(requestIdleCallback).toHaveBeenCalledWith(runner, undefined)
-  })
-})

src/base/credits/comfyCredits.test.ts

@@ -4,7 +4,6 @@ import {
   CREDITS_PER_USD,
   COMFY_CREDIT_RATE_CENTS,
   centsToCredits,
-  clampUsd,
   creditsToCents,
   creditsToUsd,
   formatCredits,
@@ -44,21 +43,4 @@ describe('comfyCredits helpers', () => {
     expect(formatCreditsFromUsd({ usd: 1, locale })).toBe('211.00')
     expect(formatUsd({ value: 4.2, locale })).toBe('4.20')
   })
-
-  test('formats with compatible fraction digit bounds', () => {
-    expect(
-      formatCredits({
-        value: 12.345,
-        locale: 'en-US',
-        numberOptions: { minimumFractionDigits: 4, maximumFractionDigits: 2 }
-      })
-    ).toBe('12.35')
-  })
-
-  test('clamps USD purchase values into the supported range', () => {
-    expect(clampUsd(Number.NaN)).toBe(0)
-    expect(clampUsd(-5)).toBe(1)
-    expect(clampUsd(42)).toBe(42)
-    expect(clampUsd(5000)).toBe(1000)
-  })
 })

src/composables/canvas/useSelectionToolboxPosition.test.ts

@@ -34,22 +34,17 @@ describe('useSelectionToolboxPosition', () => {
     canvasStore = useCanvasStore()
   })
 
-  function renderToolboxForSelection(
-    items: Iterable<Positionable>,
-    state: Partial<LGraphCanvas['state']> = {},
-    ds: Partial<LGraphCanvas['ds']> = {}
-  ) {
+  function renderToolboxForSelection(item: Positionable) {
     canvasStore.canvas = markRaw({
       canvas: document.createElement('canvas'),
       ds: {
-        offset: ds.offset ?? [0, 0],
-        scale: ds.scale ?? 1
+        offset: [0, 0],
+        scale: 1
       },
-      selectedItems: new Set(items),
+      selectedItems: new Set([item]),
       state: {
         draggingItems: false,
-        selectionChanged: true,
-        ...state
+        selectionChanged: true
       }
     } as Partial<LGraphCanvas> as LGraphCanvas)
 
@@ -74,7 +69,7 @@ describe('useSelectionToolboxPosition', () => {
     group.pos = [100, 200]
     group.size = [160, 80]
 
-    const { toolbox, unmount } = renderToolboxForSelection([group])
+    const { toolbox, unmount } = renderToolboxForSelection(group)
 
     expect(toolbox.style.getPropertyValue('--tb-y')).toBe('190px')
     unmount()
@@ -86,64 +81,11 @@ describe('useSelectionToolboxPosition', () => {
     node.pos = [100, 200]
     node.size = [160, 80]
 
-    const { toolbox, unmount } = renderToolboxForSelection([node])
+    const { toolbox, unmount } = renderToolboxForSelection(node)
 
     expect(toolbox.style.getPropertyValue('--tb-y')).toBe(
       `${190 - LiteGraph.NODE_TITLE_HEIGHT}px`
     )
     unmount()
   })
-
-  it('does not set coordinates when selection is empty', () => {
-    const { toolbox, unmount } = renderToolboxForSelection([])
-
-    expect(toolbox.style.getPropertyValue('--tb-x')).toBe('')
-    expect(toolbox.style.getPropertyValue('--tb-y')).toBe('')
-    unmount()
-  })
-
-  it('does not set coordinates while selected items are being dragged', () => {
-    const group = new LGraphGroup('Group', 1)
-    group.pos = [100, 200]
-    group.size = [160, 80]
-
-    const { toolbox, unmount } = renderToolboxForSelection([group], {
-      draggingItems: true
-    })
-
-    expect(toolbox.style.getPropertyValue('--tb-x')).toBe('')
-    expect(toolbox.style.getPropertyValue('--tb-y')).toBe('')
-    unmount()
-  })
-
-  it('positions multiple selected items from their union bounds', () => {
-    const first = new LGraphGroup('First', 1)
-    first.pos = [100, 200]
-    first.size = [100, 40]
-    const second = new LGraphGroup('Second', 2)
-    second.pos = [300, 260]
-    second.size = [50, 40]
-
-    const { toolbox, unmount } = renderToolboxForSelection([first, second])
-
-    expect(toolbox.style.getPropertyValue('--tb-x')).toBe('270px')
-    expect(toolbox.style.getPropertyValue('--tb-y')).toBe('190px')
-    unmount()
-  })
-
-  it('applies canvas scale and offset to screen coordinates', () => {
-    const group = new LGraphGroup('Group', 1)
-    group.pos = [100, 200]
-    group.size = [100, 40]
-
-    const { toolbox, unmount } = renderToolboxForSelection(
-      [group],
-      {},
-      { offset: [10, 20], scale: 2 }
-    )
-
-    expect(toolbox.style.getPropertyValue('--tb-x')).toBe('360px')
-    expect(toolbox.style.getPropertyValue('--tb-y')).toBe('420px')
-    unmount()
-  })
 })

src/composables/graph/useGroupMenuOptions.test.ts

@@ -1,215 +0,0 @@
-import type * as VueI18n from 'vue-i18n'
-import { beforeEach, describe, expect, it, vi } from 'vitest'
-
-import type { LGraphGroup } from '@/lib/litegraph/src/litegraph'
-import { LGraphEventMode } from '@/lib/litegraph/src/litegraph'
-import { useGroupMenuOptions } from '@/composables/graph/useGroupMenuOptions'
-
-const { canvas, captureCanvasState, isLightTheme, refreshCanvas, settings } =
-  vi.hoisted(() => ({
-    canvas: { setDirty: vi.fn() },
-    captureCanvasState: vi.fn(),
-    isLightTheme: { value: false },
-    refreshCanvas: vi.fn(),
-    settings: { 'Comfy.GroupSelectedNodes.Padding': 10 } as Record<
-      string,
-      unknown
-    >
-  }))
-
-vi.mock('vue-i18n', async (importOriginal) => ({
-  ...(await importOriginal<typeof VueI18n>()),
-  useI18n: () => ({ t: (key: string) => key })
-}))
-vi.mock('@/platform/settings/settingStore', () => ({
-  useSettingStore: () => ({ get: (k: string) => settings[k] })
-}))
-vi.mock('@/platform/workflow/management/stores/workflowStore', () => ({
-  useWorkflowStore: () => ({
-    activeWorkflow: { changeTracker: { captureCanvasState } }
-  })
-}))
-vi.mock('@/renderer/core/canvas/canvasStore', () => ({
-  useCanvasStore: () => ({ canvas })
-}))
-vi.mock('@/composables/graph/useCanvasRefresh', () => ({
-  useCanvasRefresh: () => ({ refreshCanvas })
-}))
-vi.mock('@/composables/graph/useNodeCustomization', () => ({
-  useNodeCustomization: () => ({
-    shapeOptions: [{ value: 1, localizedName: 'Box' }],
-    colorOptions: [
-      { value: { dark: '#111', light: '#eee' }, localizedName: 'Red' }
-    ],
-    isLightTheme
-  })
-}))
-
-function group(over: Record<string, unknown> = {}): LGraphGroup {
-  return {
-    recomputeInsideNodes: vi.fn(),
-    resizeTo: vi.fn(),
-    children: [],
-    graph: { change: vi.fn() },
-    nodes: [],
-    ...over
-  } as unknown as LGraphGroup
-}
-
-beforeEach(() => {
-  canvas.setDirty.mockReset()
-  captureCanvasState.mockReset()
-  isLightTheme.value = false
-  refreshCanvas.mockReset()
-})
-
-describe('useGroupMenuOptions', () => {
-  it('fits a group to its nodes, resizing with the configured padding', () => {
-    const g = group()
-    useGroupMenuOptions().getFitGroupToNodesOption(g).action?.()
-
-    expect(g.recomputeInsideNodes).toHaveBeenCalled()
-    expect(g.resizeTo).toHaveBeenCalledWith(g.children, 10)
-    expect(canvas.setDirty).toHaveBeenCalledWith(true, true)
-    expect(captureCanvasState).toHaveBeenCalled()
-  })
-
-  it('aborts the fit action when recompute throws', () => {
-    const g = group({
-      recomputeInsideNodes: vi.fn(() => {
-        throw new Error('boom')
-      })
-    })
-    useGroupMenuOptions().getFitGroupToNodesOption(g).action?.()
-
-    expect(g.resizeTo).not.toHaveBeenCalled()
-  })
-
-  it('applies a shape to all group nodes via the shape submenu', () => {
-    const node = { shape: 0, mode: LGraphEventMode.ALWAYS }
-    const bump = vi.fn()
-    const option = useGroupMenuOptions().getGroupShapeOptions(
-      group({ nodes: [node] }),
-      bump
-    )
-    option.submenu?.[0].action?.()
-
-    expect(node.shape).toBe(1)
-    expect(refreshCanvas).toHaveBeenCalled()
-    expect(bump).toHaveBeenCalled()
-  })
-
-  it('handles shape actions when a group has no nodes array', () => {
-    const bump = vi.fn()
-    useGroupMenuOptions()
-      .getGroupShapeOptions(group({ nodes: undefined }), bump)
-      .submenu?.[0].action?.()
-
-    expect(refreshCanvas).toHaveBeenCalled()
-    expect(bump).toHaveBeenCalled()
-  })
-
-  it('applies a color to the group via the color submenu (dark theme)', () => {
-    const g = group()
-    const bump = vi.fn()
-    useGroupMenuOptions().getGroupColorOptions(g, bump).submenu?.[0].action?.()
-
-    expect((g as unknown as { color: string }).color).toBe('#111')
-    expect(bump).toHaveBeenCalled()
-  })
-
-  it('applies a light-theme color to the group via the color submenu', () => {
-    const g = group()
-    const bump = vi.fn()
-    isLightTheme.value = true
-    useGroupMenuOptions().getGroupColorOptions(g, bump).submenu?.[0].action?.()
-
-    expect((g as unknown as { color: string }).color).toBe('#eee')
-    expect(bump).toHaveBeenCalled()
-  })
-
-  it('returns no mode options for an empty group', () => {
-    expect(useGroupMenuOptions().getGroupModeOptions(group(), vi.fn())).toEqual(
-      []
-    )
-  })
-
-  it('returns no mode options when a group has no nodes array', () => {
-    expect(
-      useGroupMenuOptions().getGroupModeOptions(
-        group({ nodes: undefined }),
-        vi.fn()
-      )
-    ).toEqual([])
-  })
-
-  it('returns no mode options when recomputing group nodes fails', () => {
-    const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {})
-    const options = useGroupMenuOptions().getGroupModeOptions(
-      group({
-        recomputeInsideNodes: vi.fn(() => {
-          throw new Error('boom')
-        })
-      }),
-      vi.fn()
-    )
-
-    expect(options).toEqual([])
-    expect(warnSpy).toHaveBeenCalledWith(
-      'Failed to recompute nodes in group for mode options:',
-      expect.any(Error)
-    )
-  })
-
-  it('builds mode options for uniform nodes and applies the new mode', () => {
-    const node = { shape: 0, mode: LGraphEventMode.ALWAYS }
-    const bump = vi.fn()
-    const options = useGroupMenuOptions().getGroupModeOptions(
-      group({ nodes: [node] }),
-      bump
-    )
-
-    expect(options.length).toBeGreaterThan(0)
-    options[0].action?.()
-    expect(node.mode).not.toBe(LGraphEventMode.ALWAYS)
-    expect(canvas.setDirty).toHaveBeenCalledWith(true, true)
-    expect(bump).toHaveBeenCalled()
-  })
-
-  it('offers two alternate modes when all nodes are NEVER', () => {
-    const options = useGroupMenuOptions().getGroupModeOptions(
-      group({ nodes: [{ mode: LGraphEventMode.NEVER }] }),
-      vi.fn()
-    )
-    expect(options).toHaveLength(2)
-  })
-
-  it('offers two alternate modes when all nodes are BYPASS', () => {
-    const options = useGroupMenuOptions().getGroupModeOptions(
-      group({ nodes: [{ mode: LGraphEventMode.BYPASS }] }),
-      vi.fn()
-    )
-    expect(options).toHaveLength(2)
-  })
-
-  it('offers all three modes when nodes have mixed modes', () => {
-    const options = useGroupMenuOptions().getGroupModeOptions(
-      group({
-        nodes: [
-          { mode: LGraphEventMode.ALWAYS },
-          { mode: LGraphEventMode.NEVER }
-        ]
-      }),
-      vi.fn()
-    )
-    expect(options).toHaveLength(3)
-  })
-
-  it('offers all three modes when the uniform mode is unknown', () => {
-    const options = useGroupMenuOptions().getGroupModeOptions(
-      group({ nodes: [{ mode: 999 }] }),
-      vi.fn()
-    )
-    expect(options).toHaveLength(3)
-  })
-})

src/composables/graph/useImageMenuOptions.test.ts

@@ -1,7 +1,6 @@
 import { fromPartial } from '@total-typescript/shoehorn'
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+import { afterEach, describe, expect, it, vi } from 'vitest'
 
-import { downloadFile, openFileInNewTab } from '@/base/common/downloadUtil'
 import type { LGraphNode } from '@/lib/litegraph/src/LGraphNode'
 import { createMockLGraphNode } from '@/utils/__tests__/litegraphTestUtils'
 import { useImageMenuOptions } from './useImageMenuOptions'
@@ -20,11 +19,6 @@ vi.mock('@/stores/commandStore', () => ({
   useCommandStore: () => ({ execute: vi.fn() })
 }))
 
-vi.mock('@/base/common/downloadUtil', () => ({
-  downloadFile: vi.fn(),
-  openFileInNewTab: vi.fn()
-}))
-
 function mockClipboard(clipboard: Partial<Clipboard> | undefined) {
   Object.defineProperty(navigator, 'clipboard', {
     value: clipboard,
@@ -33,15 +27,6 @@ function mockClipboard(clipboard: Partial<Clipboard> | undefined) {
   })
 }
 
-function stubClipboardItem() {
-  vi.stubGlobal(
-    'ClipboardItem',
-    class ClipboardItemStub {
-      constructor(public readonly items: Record<string, Blob>) {}
-    }
-  )
-}
-
 function createImageNode(
   overrides: Partial<LGraphNode> | Record<string, unknown> = {}
 ): LGraphNode {
@@ -60,13 +45,8 @@ function createImageNode(
 }
 
 describe('useImageMenuOptions', () => {
-  beforeEach(() => {
-    vi.clearAllMocks()
-  })
-
   afterEach(() => {
     vi.restoreAllMocks()
-    vi.unstubAllGlobals()
   })
 
   describe('getImageMenuOptions', () => {
@@ -202,141 +182,4 @@ describe('useImageMenuOptions', () => {
       expect(node.pasteFiles).not.toHaveBeenCalled()
     })
   })
-
-  describe('image actions', () => {
-    it('opens the selected image without preview query params', () => {
-      const node = createImageNode()
-      node.imgs![0].src = 'http://localhost/test.png?preview=1&foo=bar'
-
-      const { getImageMenuOptions } = useImageMenuOptions()
-      const openOption = getImageMenuOptions(node).find(
-        (o) => o.label === 'Open Image'
-      )
-      openOption?.action?.()
-
-      expect(openFileInNewTab).toHaveBeenCalledWith(
-        'http://localhost/test.png?foo=bar'
-      )
-    })
-
-    it('saves the selected image without preview query params', () => {
-      const node = createImageNode()
-      node.imgs![0].src = 'http://localhost/test.png?preview=1&foo=bar'
-
-      const { getImageMenuOptions } = useImageMenuOptions()
-      const saveOption = getImageMenuOptions(node).find(
-        (o) => o.label === 'Save Image'
-      )
-      saveOption?.action?.()
-
-      expect(downloadFile).toHaveBeenCalledWith(
-        'http://localhost/test.png?foo=bar'
-      )
-    })
-
-    it('does not open or save when the active image is missing', () => {
-      const node = createImageNode({ imageIndex: 1 })
-
-      const { getImageMenuOptions } = useImageMenuOptions()
-      const options = getImageMenuOptions(node)
-      options.find((o) => o.label === 'Open Image')?.action?.()
-      options.find((o) => o.label === 'Save Image')?.action?.()
-
-      expect(openFileInNewTab).not.toHaveBeenCalled()
-      expect(downloadFile).not.toHaveBeenCalled()
-    })
-
-    it('logs save failures for invalid image URLs', () => {
-      const errorSpy = vi.spyOn(console, 'error').mockImplementation(() => {})
-      const node = createImageNode()
-      Object.defineProperty(node.imgs![0], 'src', {
-        value: 'http://[',
-        configurable: true
-      })
-
-      const { getImageMenuOptions } = useImageMenuOptions()
-      getImageMenuOptions(node)
-        .find((o) => o.label === 'Save Image')
-        ?.action?.()
-
-      expect(errorSpy).toHaveBeenCalledWith(
-        'Failed to save image:',
-        expect.any(TypeError)
-      )
-      expect(downloadFile).not.toHaveBeenCalled()
-    })
-
-    it('copies the selected image to clipboard', async () => {
-      const node = createImageNode()
-      const drawImage = vi.fn()
-      const write = vi.fn().mockResolvedValue(undefined)
-      stubClipboardItem()
-      mockClipboard(fromPartial<Clipboard>({ write }))
-      vi.spyOn(HTMLCanvasElement.prototype, 'getContext').mockImplementation(
-        (() =>
-          fromPartial<CanvasRenderingContext2D>({
-            drawImage
-          })) as unknown as HTMLCanvasElement['getContext']
-      )
-      vi.spyOn(HTMLCanvasElement.prototype, 'toBlob').mockImplementation(
-        (callback: BlobCallback) => {
-          callback(new Blob(['image'], { type: 'image/png' }))
-        }
-      )
-
-      const { getImageMenuOptions } = useImageMenuOptions()
-      await getImageMenuOptions(node)
-        .find((o) => o.label === 'Copy Image')
-        ?.action?.()
-
-      expect(drawImage).toHaveBeenCalledWith(node.imgs![0], 0, 0)
-      expect(write).toHaveBeenCalledWith([
-        expect.objectContaining({
-          items: { 'image/png': expect.any(Blob) }
-        })
-      ])
-    })
-
-    it('does not copy when canvas context is unavailable', async () => {
-      const node = createImageNode()
-      const write = vi.fn()
-      mockClipboard(fromPartial<Clipboard>({ write }))
-      vi.spyOn(HTMLCanvasElement.prototype, 'getContext').mockImplementation(
-        (() => null) as HTMLCanvasElement['getContext']
-      )
-
-      const { getImageMenuOptions } = useImageMenuOptions()
-      await getImageMenuOptions(node)
-        .find((o) => o.label === 'Copy Image')
-        ?.action?.()
-
-      expect(write).not.toHaveBeenCalled()
-    })
-
-    it('does not copy when canvas blob creation fails', async () => {
-      const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {})
-      const node = createImageNode()
-      const write = vi.fn()
-      mockClipboard(fromPartial<Clipboard>({ write }))
-      vi.spyOn(HTMLCanvasElement.prototype, 'getContext').mockImplementation(
-        (() =>
-          fromPartial<CanvasRenderingContext2D>({
-            drawImage: vi.fn()
-          })) as unknown as HTMLCanvasElement['getContext']
-      )
-      vi.spyOn(HTMLCanvasElement.prototype, 'toBlob').mockImplementation(
-        (callback: BlobCallback) => {
-          callback(null)
-        }
-      )
-
-      const { getImageMenuOptions } = useImageMenuOptions()
-      await getImageMenuOptions(node)
-        .find((o) => o.label === 'Copy Image')
-        ?.action?.()
-
-      expect(warnSpy).toHaveBeenCalledWith('Failed to create image blob')
-      expect(write).not.toHaveBeenCalled()
-    })
-  })
 })

src/composables/graph/useMoreOptionsMenu.test.ts

@@ -1,292 +0,0 @@
-import { ref } from 'vue'
-import { beforeEach, describe, expect, it, vi } from 'vitest'
-
-import { LGraphGroup } from '@/lib/litegraph/src/litegraph'
-import {
-  isNodeOptionsOpen,
-  registerNodeOptionsInstance,
-  showNodeOptions,
-  toggleNodeOptions,
-  useMoreOptionsMenu
-} from '@/composables/graph/useMoreOptionsMenu'
-
-const {
-  canvasState,
-  extraWidgetOptions,
-  imageOptions,
-  nodeMenu,
-  selectionMenu,
-  selectionState
-} = vi.hoisted(() => ({
-  canvasState: {
-    canvas: undefined as
-      | undefined
-      | {
-          getNodeMenuOptions: ReturnType<typeof vi.fn>
-        }
-  },
-  extraWidgetOptions: {
-    value: [] as Array<{ content: string; callback?: () => void }>
-  },
-  imageOptions: {
-    value: [] as Array<{ label: string; hasSubmenu?: boolean; submenu?: [] }>
-  },
-  nodeMenu: {
-    visualOptions: {
-      value: [] as Array<{
-        label: string
-        hasSubmenu?: boolean
-        submenu?: Array<{ label: string; action: () => void }>
-      }>
-    }
-  },
-  selectionMenu: {
-    basicOptions: { value: [{ label: 'Copy' }] },
-    multipleOptions: { value: [{ label: 'Align' }] },
-    subgraphOptions: { value: [] as Array<{ label: string }> }
-  },
-  selectionState: {
-    selectedItems: { value: [] as unknown[] },
-    selectedNodes: { value: [] as unknown[] },
-    canOpenNodeInfo: { value: false },
-    openNodeInfo: vi.fn(() => true),
-    hasSubgraphs: { value: false },
-    hasImageNode: { value: false },
-    hasOutputNodesSelected: { value: false },
-    hasMultipleSelection: { value: false },
-    computeSelectionFlags: vi.fn(() => ({
-      collapsed: false,
-      pinned: false
-    }))
-  }
-}))
-
-vi.mock('@/composables/graph/useSelectionState', () => ({
-  useSelectionState: () => selectionState
-}))
-vi.mock('@/renderer/core/canvas/canvasStore', () => ({
-  useCanvasStore: () => canvasState
-}))
-vi.mock('@/services/litegraphService', () => ({
-  getExtraOptionsForWidget: () => extraWidgetOptions.value
-}))
-vi.mock('@/composables/graph/useImageMenuOptions', () => ({
-  useImageMenuOptions: () => ({
-    getImageMenuOptions: () => imageOptions.value
-  })
-}))
-vi.mock('@/composables/graph/useNodeMenuOptions', () => ({
-  useNodeMenuOptions: () => ({
-    getNodeInfoOption: (openNodeInfo: () => boolean) => ({
-      label: 'Node Info',
-      action: openNodeInfo
-    }),
-    getNodeVisualOptions: () => nodeMenu.visualOptions.value,
-    getPinOption: () => ({ label: 'Pin' }),
-    getBypassOption: () => ({ label: 'Bypass' }),
-    getRunBranchOption: () => ({ label: 'Run Branch' })
-  })
-}))
-vi.mock('@/composables/graph/useGroupMenuOptions', () => ({
-  useGroupMenuOptions: () => ({
-    getFitGroupToNodesOption: () => ({ label: 'Fit' }),
-    getGroupColorOptions: () => ({ label: 'Group Color' }),
-    getGroupModeOptions: () => [{ label: 'Group Mode' }]
-  })
-}))
-vi.mock('@/composables/graph/useSelectionMenuOptions', () => ({
-  useSelectionMenuOptions: () => ({
-    getBasicSelectionOptions: () => selectionMenu.basicOptions.value,
-    getMultipleNodesOptions: () => selectionMenu.multipleOptions.value,
-    getSubgraphOptions: () => selectionMenu.subgraphOptions.value
-  })
-}))
-
-beforeEach(() => {
-  vi.clearAllMocks()
-  registerNodeOptionsInstance(null)
-  canvasState.canvas = undefined
-  extraWidgetOptions.value = []
-  imageOptions.value = []
-  nodeMenu.visualOptions.value = []
-  selectionMenu.basicOptions.value = [{ label: 'Copy' }]
-  selectionMenu.multipleOptions.value = [{ label: 'Align' }]
-  selectionMenu.subgraphOptions.value = []
-  selectionState.selectedItems.value = []
-  selectionState.selectedNodes.value = []
-  selectionState.canOpenNodeInfo.value = false
-  selectionState.hasSubgraphs.value = false
-  selectionState.hasImageNode.value = false
-  selectionState.hasOutputNodesSelected.value = false
-  selectionState.hasMultipleSelection.value = false
-  selectionState.computeSelectionFlags.mockReturnValue({
-    collapsed: false,
-    pinned: false
-  })
-})
-
-function labels() {
-  return useMoreOptionsMenu()
-    .menuOptions.value.map((o) => o.label)
-    .filter(Boolean)
-}
-
-describe('node options popover instance', () => {
-  it('reports closed when no instance is registered', () => {
-    expect(isNodeOptionsOpen()).toBe(false)
-  })
-
-  it('reflects the registered instance open state and forwards toggle/show', () => {
-    const toggle = vi.fn()
-    const show = vi.fn()
-    registerNodeOptionsInstance({
-      toggle,
-      show,
-      hide: vi.fn(),
-      isOpen: ref(true)
-    })
-
-    expect(isNodeOptionsOpen()).toBe(true)
-    toggleNodeOptions(new Event('click'))
-    showNodeOptions(new MouseEvent('contextmenu'))
-    expect(toggle).toHaveBeenCalled()
-    expect(show).toHaveBeenCalled()
-  })
-})
-
-describe('useMoreOptionsMenu', () => {
-  it('assembles a non-empty menu for a single selected node', () => {
-    const node = { id: 1, widgets: [] }
-    selectionState.selectedItems.value = [node]
-    selectionState.selectedNodes.value = [node]
-
-    expect(labels()).toContain('Copy')
-    expect(labels()).toContain('Pin')
-  })
-
-  it('includes run-branch and multiple-node options for output selections', () => {
-    const nodes = [
-      { id: 1, widgets: [] },
-      { id: 2, widgets: [] }
-    ]
-    selectionState.selectedItems.value = nodes
-    selectionState.selectedNodes.value = nodes
-    selectionState.hasOutputNodesSelected.value = true
-    selectionState.hasMultipleSelection.value = true
-
-    const menuLabels = labels()
-    expect(menuLabels).toContain('Run Branch')
-    expect(menuLabels).toContain('Align')
-  })
-
-  it('recomputes menu flags after a manual bump', () => {
-    const { bump, menuOptions } = useMoreOptionsMenu()
-    void menuOptions.value
-    expect(selectionState.computeSelectionFlags).toHaveBeenCalledTimes(1)
-
-    bump()
-    void menuOptions.value
-    expect(selectionState.computeSelectionFlags).toHaveBeenCalledTimes(2)
-  })
-
-  it('assembles group-context options for a single selected group', () => {
-    const group = new LGraphGroup('Group')
-    selectionState.selectedItems.value = [group]
-    selectionState.selectedNodes.value = []
-
-    const menuLabels = labels()
-    expect(menuLabels).toContain('Group Mode')
-    expect(menuLabels).toContain('Fit')
-    expect(menuLabels).toContain('Group Color')
-  })
-
-  it('includes node info and visual options for a single node', () => {
-    const node = { id: 1, widgets: [] }
-    selectionState.selectedItems.value = [node]
-    selectionState.selectedNodes.value = [node]
-    selectionState.canOpenNodeInfo.value = true
-    nodeMenu.visualOptions.value = [
-      { label: 'Minimize Node' },
-      { label: 'Shape', hasSubmenu: true, submenu: [] },
-      { label: 'Color', hasSubmenu: true, submenu: [] }
-    ]
-
-    const menu = useMoreOptionsMenu().menuOptions.value
-    expect(menu.map((o) => o.label)).toEqual(
-      expect.arrayContaining(['Node Info', 'Minimize Node', 'Shape', 'Color'])
-    )
-    menu.find((o) => o.label === 'Node Info')?.action?.()
-    expect(selectionState.openNodeInfo).toHaveBeenCalled()
-  })
-
-  it('returns only entries that have populated submenus', () => {
-    const node = { id: 1, widgets: [] }
-    selectionState.selectedItems.value = [node]
-    selectionState.selectedNodes.value = [node]
-    nodeMenu.visualOptions.value = [
-      { label: 'Minimize Node' },
-      {
-        label: 'Shape',
-        hasSubmenu: true,
-        submenu: [{ label: 'Box', action: vi.fn() }]
-      },
-      { label: 'Color', hasSubmenu: true }
-    ]
-
-    expect(
-      useMoreOptionsMenu().menuOptionsWithSubmenu.value.map((o) => o.label)
-    ).toEqual(['Shape'])
-  })
-
-  it('includes image menu options for a selected image node', () => {
-    const node = { id: 1, widgets: [] }
-    selectionState.selectedItems.value = [node]
-    selectionState.selectedNodes.value = [node]
-    selectionState.hasImageNode.value = true
-    imageOptions.value = [{ label: 'Open Image' }]
-
-    expect(labels()).toContain('Open Image')
-  })
-
-  it('merges LiteGraph menu options for a single selected node', () => {
-    const node = { id: 1, widgets: [] }
-    const getNodeMenuOptions = vi.fn(() => [
-      { content: 'Extension Action', callback: vi.fn() }
-    ])
-    selectionState.selectedItems.value = [node]
-    selectionState.selectedNodes.value = [node]
-    canvasState.canvas = { getNodeMenuOptions }
-
-    expect(labels()).toContain('Extension Action')
-    expect(getNodeMenuOptions).toHaveBeenCalledWith(node)
-  })
-
-  it('keeps Vue options when LiteGraph menu construction throws', () => {
-    const errorSpy = vi.spyOn(console, 'error').mockImplementation(() => {})
-    const node = { id: 1, widgets: [] }
-    selectionState.selectedItems.value = [node]
-    selectionState.selectedNodes.value = [node]
-    canvasState.canvas = {
-      getNodeMenuOptions: vi.fn(() => {
-        throw new Error('boom')
-      })
-    }
-
-    expect(labels()).toContain('Copy')
-    expect(errorSpy).toHaveBeenCalledWith(
-      'Error getting LiteGraph menu items:',
-      expect.any(Error)
-    )
-  })
-
-  it('adds hovered widget options to the selected node menu', () => {
-    const node = { id: 1, widgets: [{ name: 'image' }] }
-    selectionState.selectedItems.value = [node]
-    selectionState.selectedNodes.value = [node]
-    extraWidgetOptions.value = [{ content: 'Widget Extra', callback: vi.fn() }]
-
-    showNodeOptions(new MouseEvent('contextmenu'), 'image')
-
-    expect(labels()).toContain('Widget Extra')
-  })
-})

src/composables/graph/useNodeCustomization.test.ts

@@ -1,175 +0,0 @@
-import type * as VueI18n from 'vue-i18n'
-import { beforeEach, describe, expect, it, vi } from 'vitest'
-
-import { LGraphNode } from '@/lib/litegraph/src/litegraph'
-
-import { useNodeCustomization } from '@/composables/graph/useNodeCustomization'
-
-const { selection, refreshCanvas, palette } = vi.hoisted(() => ({
-  selection: { items: [] as unknown[] },
-  refreshCanvas: vi.fn(),
-  palette: { light_theme: false }
-}))
-
-vi.mock('vue-i18n', async (importOriginal) => ({
-  ...(await importOriginal<typeof VueI18n>()),
-  useI18n: () => ({ t: (key: string) => key })
-}))
-
-vi.mock('@/renderer/core/canvas/canvasStore', () => ({
-  useCanvasStore: () => ({
-    get selectedItems() {
-      return selection.items
-    }
-  })
-}))
-
-vi.mock('@/stores/workspace/colorPaletteStore', () => ({
-  useColorPaletteStore: () => ({
-    get completedActivePalette() {
-      return { light_theme: palette.light_theme }
-    }
-  })
-}))
-
-vi.mock('@/composables/graph/useCanvasRefresh', () => ({
-  useCanvasRefresh: () => ({ refreshCanvas })
-}))
-
-function colorable(bgcolor?: string) {
-  return {
-    setColorOption: vi.fn(),
-    getColorOption: () => (bgcolor ? { bgcolor } : null)
-  }
-}
-
-beforeEach(() => {
-  selection.items = []
-  refreshCanvas.mockReset()
-  palette.light_theme = false
-})
-
-describe('useNodeCustomization', () => {
-  it('exposes color and shape option lists', () => {
-    const { colorOptions, shapeOptions } = useNodeCustomization()
-    expect(colorOptions.length).toBeGreaterThan(1)
-    expect(shapeOptions.length).toBeGreaterThan(0)
-  })
-
-  it('reflects the active palette light-theme flag', () => {
-    palette.light_theme = true
-    expect(useNodeCustomization().isLightTheme.value).toBe(true)
-  })
-
-  it('clears color on all colorable items for the no-color option', () => {
-    const item = colorable()
-    selection.items = [item]
-    useNodeCustomization().applyColor(null)
-
-    expect(item.setColorOption).toHaveBeenCalledWith(null)
-    expect(refreshCanvas).toHaveBeenCalled()
-  })
-
-  it('applies a named color option to colorable items', () => {
-    const item = colorable()
-    selection.items = [item]
-    const { colorOptions, applyColor } = useNodeCustomization()
-    const named = colorOptions.at(-1)!
-
-    applyColor(named)
-
-    expect(item.setColorOption).toHaveBeenCalledTimes(1)
-    expect(item.setColorOption.mock.calls[0][0]).not.toBeNull()
-  })
-
-  it('skips non-colorable items when applying colors', () => {
-    const item = colorable()
-    selection.items = [{}, item]
-
-    useNodeCustomization().applyColor(null)
-
-    expect(item.setColorOption).toHaveBeenCalledWith(null)
-    expect(refreshCanvas).toHaveBeenCalled()
-  })
-
-  it('returns null current color for an empty selection', () => {
-    expect(useNodeCustomization().getCurrentColor()).toBeNull()
-  })
-
-  it('returns null current color when no selected item is colorable', () => {
-    selection.items = [{}]
-    expect(useNodeCustomization().getCurrentColor()).toBeNull()
-  })
-
-  it('reports a recognized current color', () => {
-    const { colorOptions, getCurrentColor } = useNodeCustomization()
-    const named = colorOptions.at(-1)!
-    selection.items = [colorable(named.value.dark)]
-
-    expect(getCurrentColor()?.name).toBe(named.name)
-  })
-
-  it('falls back to the no-color option for an unrecognized current color', () => {
-    selection.items = [colorable('#not-a-known-color')]
-    const result = useNodeCustomization().getCurrentColor()
-    expect(result?.name).toBe('noColor')
-  })
-
-  it('no-ops shape changes when no graph nodes are selected', () => {
-    selection.items = [colorable()]
-    const { applyShape, shapeOptions } = useNodeCustomization()
-    applyShape(shapeOptions[0])
-    expect(refreshCanvas).not.toHaveBeenCalled()
-  })
-
-  it('returns null current shape with no nodes selected', () => {
-    expect(useNodeCustomization().getCurrentShape()).toBeNull()
-  })
-
-  it('applies a shape to selected graph nodes and refreshes', () => {
-    const node = new LGraphNode('Test')
-    selection.items = [node]
-    const { applyShape, shapeOptions } = useNodeCustomization()
-    const target = shapeOptions[0]
-
-    applyShape(target)
-
-    expect(node.shape).toBe(target.value)
-    expect(refreshCanvas).toHaveBeenCalled()
-  })
-
-  it('reports the current shape of a selected node', () => {
-    const node = new LGraphNode('Test')
-    const { shapeOptions, getCurrentShape } = useNodeCustomization()
-    node.shape = shapeOptions[0].value
-    selection.items = [node]
-
-    expect(getCurrentShape()?.value).toBe(shapeOptions[0].value)
-  })
-
-  it('uses the default shape when a selected node has no shape', () => {
-    const node = new LGraphNode('Test')
-    Object.defineProperty(node, 'shape', {
-      value: undefined,
-      writable: true,
-      configurable: true
-    })
-    const { shapeOptions, getCurrentShape } = useNodeCustomization()
-    selection.items = [node]
-
-    expect(getCurrentShape()?.value).toBe(shapeOptions[0].value)
-  })
-
-  it('falls back to the default shape for an unknown node shape', () => {
-    const node = new LGraphNode('Test')
-    Object.defineProperty(node, 'shape', {
-      value: 999,
-      writable: true,
-      configurable: true
-    })
-    const { shapeOptions, getCurrentShape } = useNodeCustomization()
-    selection.items = [node]
-
-    expect(getCurrentShape()?.value).toBe(shapeOptions[0].value)
-  })
-})

src/composables/graph/useNodeMenuOptions.test.ts

@@ -10,43 +10,30 @@ import { LGraphEventMode, LGraphNode } from '@/lib/litegraph/src/litegraph'
 import { useCanvasStore } from '@/renderer/core/canvas/canvasStore'
 import { toNodeId } from '@/types/nodeId'
 
-const { actions, customization } = vi.hoisted(() => ({
-  actions: {
-    adjustNodeSize: vi.fn(),
-    toggleNodeCollapse: vi.fn(),
-    toggleNodePin: vi.fn(),
-    toggleNodeBypass: vi.fn(),
-    runBranch: vi.fn()
-  },
-  customization: {
-    shapeOptions: [] as Array<{ localizedName: string; value: string }>,
-    colorOptions: [] as Array<{
-      name: string
-      localizedName: string
-      value: { dark: string; light: string }
-    }>,
-    applyShape: vi.fn(),
-    applyColor: vi.fn(),
-    isLightTheme: { value: false }
-  }
-}))
-
+// canvasStore transitively imports the app singleton; stub it so the real
+// ComfyApp module never loads during these unit tests.
 vi.mock('@/scripts/app', () => ({
   app: { canvas: { selected_nodes: null } }
 }))
 
 vi.mock('@/composables/graph/useNodeCustomization', () => ({
   useNodeCustomization: () => ({
-    shapeOptions: customization.shapeOptions,
-    applyShape: customization.applyShape,
-    applyColor: customization.applyColor,
-    colorOptions: customization.colorOptions,
-    isLightTheme: customization.isLightTheme
+    shapeOptions: [],
+    applyShape: vi.fn(),
+    applyColor: vi.fn(),
+    colorOptions: [],
+    isLightTheme: { value: false }
   })
 }))
 
 vi.mock('@/composables/graph/useSelectedNodeActions', () => ({
-  useSelectedNodeActions: () => actions
+  useSelectedNodeActions: () => ({
+    adjustNodeSize: vi.fn(),
+    toggleNodeCollapse: vi.fn(),
+    toggleNodePin: vi.fn(),
+    toggleNodeBypass: vi.fn(),
+    runBranch: vi.fn()
+  })
 }))
 
 const i18n = createI18n({
@@ -82,29 +69,9 @@ const getBypassLabel = (selected: LGraphNode[]): string => {
   return label
 }
 
-function readNodeMenuOptions<T>(
-  read: (options: ReturnType<typeof useNodeMenuOptions>) => T
-): T {
-  const unread = Symbol('unread')
-  const result: { value: T | typeof unread } = { value: unread }
-  const Wrapper = defineComponent({
-    setup() {
-      result.value = read(useNodeMenuOptions())
-      return () => null
-    }
-  })
-  render(Wrapper, { global: { plugins: [i18n] } })
-  if (result.value === unread) throw new Error('Composable was not read')
-  return result.value
-}
-
-describe('useNodeMenuOptions', () => {
+describe('useNodeMenuOptions.getBypassOption', () => {
   beforeEach(() => {
-    vi.clearAllMocks()
     setActivePinia(createPinia())
-    customization.shapeOptions = []
-    customization.colorOptions = []
-    customization.isLightTheme.value = false
   })
 
   it('labels as "Bypass" when no node is bypassed', () => {
@@ -130,109 +97,4 @@ describe('useNodeMenuOptions', () => {
       ])
     ).toBe('contextMenu.Bypass')
   })
-
-  it('labels visual node options from the collapsed state and bumps after action', () => {
-    const expandBump = vi.fn()
-    const expand = readNodeMenuOptions(
-      ({ getNodeVisualOptions }) =>
-        getNodeVisualOptions({ collapsed: true, pinned: false }, expandBump)[0]
-    )
-    expect(expand).toMatchObject({
-      label: 'contextMenu.Expand Node',
-      icon: 'icon-[lucide--maximize-2]'
-    })
-    expand.action?.()
-    expect(actions.toggleNodeCollapse).toHaveBeenCalledTimes(1)
-    expect(expandBump).toHaveBeenCalledTimes(1)
-
-    const minimize = readNodeMenuOptions(
-      ({ getNodeVisualOptions }) =>
-        getNodeVisualOptions({ collapsed: false, pinned: false }, vi.fn())[0]
-    )
-    expect(minimize).toMatchObject({
-      label: 'contextMenu.Minimize Node',
-      icon: 'icon-[lucide--minimize-2]'
-    })
-  })
-
-  it('labels pin options from the pinned state and bumps after action', () => {
-    const bump = vi.fn()
-    const unpin = readNodeMenuOptions(({ getPinOption }) =>
-      getPinOption({ collapsed: false, pinned: true }, bump)
-    )
-    expect(unpin).toMatchObject({
-      label: 'contextMenu.Unpin',
-      icon: 'icon-[lucide--pin-off]'
-    })
-    unpin.action?.()
-    expect(actions.toggleNodePin).toHaveBeenCalledTimes(1)
-    expect(bump).toHaveBeenCalledTimes(1)
-
-    const pin = readNodeMenuOptions(({ getPinOption }) =>
-      getPinOption({ collapsed: false, pinned: false }, vi.fn())
-    )
-    expect(pin).toMatchObject({
-      label: 'contextMenu.Pin',
-      icon: 'icon-[lucide--pin]'
-    })
-  })
-
-  it('builds shape and color submenus and applies selected values', () => {
-    customization.shapeOptions = [{ localizedName: 'Box', value: 'box' }]
-    customization.colorOptions = [
-      {
-        name: 'noColor',
-        localizedName: 'No Color',
-        value: { dark: '#000', light: '#fff' }
-      },
-      {
-        name: 'red',
-        localizedName: 'Red',
-        value: { dark: '#111', light: '#eee' }
-      }
-    ]
-
-    const { visualOptions, colorSubmenu } = readNodeMenuOptions((options) => ({
-      visualOptions: options.getNodeVisualOptions(
-        { collapsed: false, pinned: false },
-        vi.fn()
-      ),
-      colorSubmenu: options.colorSubmenu.value
-    }))
-
-    expect(visualOptions[1].submenu).toEqual([
-      expect.objectContaining({ label: 'Box' })
-    ])
-    visualOptions[1].submenu?.[0].action()
-    expect(customization.applyShape).toHaveBeenCalledWith(
-      customization.shapeOptions[0]
-    )
-
-    expect(colorSubmenu).toEqual([
-      expect.objectContaining({ label: 'No Color', color: '#000' }),
-      expect.objectContaining({ label: 'Red', color: '#111' })
-    ])
-    colorSubmenu[0].action()
-    colorSubmenu[1].action()
-    expect(customization.applyColor).toHaveBeenNthCalledWith(1, null)
-    expect(customization.applyColor).toHaveBeenNthCalledWith(
-      2,
-      customization.colorOptions[1]
-    )
-  })
-
-  it('uses light-theme colors for the color submenu', () => {
-    customization.isLightTheme.value = true
-    customization.colorOptions = [
-      {
-        name: 'red',
-        localizedName: 'Red',
-        value: { dark: '#111', light: '#eee' }
-      }
-    ]
-
-    expect(
-      readNodeMenuOptions((options) => options.colorSubmenu.value[0].color)
-    ).toBe('#eee')
-  })
 })

src/composables/graph/useSelectionOperations.test.ts

@@ -1,221 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from 'vitest'
-
-import { LGraphNode } from '@/lib/litegraph/src/litegraph'
-import { useSelectionOperations } from '@/composables/graph/useSelectionOperations'
-
-const {
-  canvas,
-  toastAdd,
-  captureCanvasState,
-  updateSelectedItems,
-  prompt,
-  titleEditor,
-  store
-} = vi.hoisted(() => ({
-  canvas: {
-    selectedItems: new Set<unknown>(),
-    copyToClipboard: vi.fn(),
-    pasteFromClipboard: vi.fn(),
-    deleteSelected: vi.fn(),
-    setDirty: vi.fn()
-  },
-  toastAdd: vi.fn(),
-  captureCanvasState: vi.fn(),
-  updateSelectedItems: vi.fn(),
-  prompt: vi.fn(),
-  titleEditor: { titleEditorTarget: null as unknown },
-  store: { selectedItems: [] as unknown[] }
-}))
-
-vi.mock('@/scripts/app', () => ({ app: { canvas } }))
-vi.mock('@/i18n', () => ({ t: (key: string) => key }))
-vi.mock('@/platform/updates/common/toastStore', () => ({
-  useToastStore: () => ({ add: toastAdd })
-}))
-vi.mock('@/platform/workflow/management/stores/workflowStore', () => ({
-  useWorkflowStore: () => ({
-    activeWorkflow: { changeTracker: { captureCanvasState } }
-  })
-}))
-vi.mock('@/renderer/core/canvas/canvasStore', () => ({
-  useCanvasStore: () => ({
-    updateSelectedItems,
-    get selectedItems() {
-      return store.selectedItems
-    }
-  }),
-  useTitleEditorStore: () => titleEditor
-}))
-vi.mock('@/services/dialogService', () => ({
-  useDialogService: () => ({ prompt })
-}))
-
-beforeEach(() => {
-  canvas.selectedItems = new Set()
-  canvas.copyToClipboard.mockReset()
-  canvas.pasteFromClipboard.mockReset()
-  canvas.deleteSelected.mockReset()
-  canvas.setDirty.mockReset()
-  toastAdd.mockReset()
-  captureCanvasState.mockReset()
-  updateSelectedItems.mockReset()
-  prompt.mockReset()
-  titleEditor.titleEditorTarget = null
-  store.selectedItems = []
-})
-
-describe('useSelectionOperations', () => {
-  it('warns and does nothing when copying an empty selection', () => {
-    useSelectionOperations().copySelection()
-    expect(canvas.copyToClipboard).not.toHaveBeenCalled()
-    expect(toastAdd).toHaveBeenCalledWith(
-      expect.objectContaining({ severity: 'warn' })
-    )
-  })
-
-  it('copies a non-empty selection and reports success', () => {
-    canvas.selectedItems = new Set(['a'])
-    useSelectionOperations().copySelection()
-    expect(canvas.copyToClipboard).toHaveBeenCalled()
-    expect(toastAdd).toHaveBeenCalledWith(
-      expect.objectContaining({ severity: 'success' })
-    )
-  })
-
-  it('pastes from clipboard and captures canvas state', () => {
-    useSelectionOperations().pasteSelection()
-    expect(canvas.pasteFromClipboard).toHaveBeenCalledWith({
-      connectInputs: false
-    })
-    expect(captureCanvasState).toHaveBeenCalled()
-  })
-
-  it('duplicates by copy, clear, paste', () => {
-    canvas.selectedItems = new Set(['a'])
-    useSelectionOperations().duplicateSelection()
-    expect(canvas.copyToClipboard).toHaveBeenCalled()
-    expect(canvas.selectedItems.size).toBe(0)
-    expect(updateSelectedItems).toHaveBeenCalled()
-    expect(canvas.pasteFromClipboard).toHaveBeenCalled()
-    expect(captureCanvasState).toHaveBeenCalled()
-  })
-
-  it('warns when duplicating nothing', () => {
-    useSelectionOperations().duplicateSelection()
-    expect(canvas.copyToClipboard).not.toHaveBeenCalled()
-    expect(toastAdd).toHaveBeenCalledWith(
-      expect.objectContaining({ severity: 'warn' })
-    )
-  })
-
-  it('deletes a non-empty selection and marks the canvas dirty', () => {
-    canvas.selectedItems = new Set(['a'])
-    useSelectionOperations().deleteSelection()
-    expect(canvas.deleteSelected).toHaveBeenCalled()
-    expect(canvas.setDirty).toHaveBeenCalledWith(true, true)
-    expect(captureCanvasState).toHaveBeenCalled()
-  })
-
-  it('warns when deleting nothing', () => {
-    useSelectionOperations().deleteSelection()
-    expect(canvas.deleteSelected).not.toHaveBeenCalled()
-    expect(toastAdd).toHaveBeenCalledWith(
-      expect.objectContaining({ severity: 'warn' })
-    )
-  })
-
-  it('routes a single node rename to the title editor', async () => {
-    const node = new LGraphNode('Test')
-    store.selectedItems = [node]
-
-    await useSelectionOperations().renameSelection()
-
-    expect(titleEditor.titleEditorTarget).toBe(node)
-    expect(prompt).not.toHaveBeenCalled()
-  })
-
-  it('renames a single non-node item via the prompt dialog', async () => {
-    const group = { title: 'Old' }
-    store.selectedItems = [group]
-    prompt.mockResolvedValue('New')
-
-    await useSelectionOperations().renameSelection()
-
-    expect(group.title).toBe('New')
-    expect(canvas.setDirty).toHaveBeenCalledWith(true, true)
-    expect(captureCanvasState).toHaveBeenCalled()
-  })
-
-  it('leaves a single titled item unchanged when the prompt returns the same title', async () => {
-    const group = { title: 'Old' }
-    store.selectedItems = [group]
-    prompt.mockResolvedValue('Old')
-
-    await useSelectionOperations().renameSelection()
-
-    expect(group.title).toBe('Old')
-    expect(canvas.setDirty).not.toHaveBeenCalled()
-    expect(captureCanvasState).not.toHaveBeenCalled()
-  })
-
-  it('does not assign a title to a selected item without a title property', async () => {
-    const item = {}
-    store.selectedItems = [item]
-    prompt.mockResolvedValue('New')
-
-    await useSelectionOperations().renameSelection()
-
-    expect(item).toEqual({})
-    expect(canvas.setDirty).not.toHaveBeenCalled()
-    expect(captureCanvasState).not.toHaveBeenCalled()
-  })
-
-  it('batch-renames multiple items with an indexed base name', async () => {
-    const a = { title: 'a' }
-    const b = { title: 'b' }
-    store.selectedItems = [a, b]
-    prompt.mockResolvedValue('Item')
-
-    await useSelectionOperations().renameSelection()
-
-    expect(a.title).toBe('Item 1')
-    expect(b.title).toBe('Item 2')
-    expect(canvas.setDirty).toHaveBeenCalledWith(true, true)
-    expect(captureCanvasState).toHaveBeenCalled()
-  })
-
-  it('skips untitled items during batch rename', async () => {
-    const a = { title: 'a' }
-    const b = {}
-    store.selectedItems = [a, b]
-    prompt.mockResolvedValue('Item')
-
-    await useSelectionOperations().renameSelection()
-
-    expect(a.title).toBe('Item 1')
-    expect(b).toEqual({})
-    expect(canvas.setDirty).toHaveBeenCalledWith(true, true)
-    expect(captureCanvasState).toHaveBeenCalled()
-  })
-
-  it('leaves a multiple selection unchanged when batch rename is cancelled', async () => {
-    const a = { title: 'a' }
-    const b = { title: 'b' }
-    store.selectedItems = [a, b]
-    prompt.mockResolvedValue('')
-
-    await useSelectionOperations().renameSelection()
-
-    expect(a.title).toBe('a')
-    expect(b.title).toBe('b')
-    expect(canvas.setDirty).not.toHaveBeenCalled()
-    expect(captureCanvasState).not.toHaveBeenCalled()
-  })
-
-  it('warns when renaming an empty selection', async () => {
-    await useSelectionOperations().renameSelection()
-    expect(toastAdd).toHaveBeenCalledWith(
-      expect.objectContaining({ severity: 'warn' })
-    )
-  })
-})

src/composables/graph/useSelectionState.test.ts

@@ -8,12 +8,7 @@ import { useSettingStore } from '@/platform/settings/settingStore'
 import { useCanvasStore } from '@/renderer/core/canvas/canvasStore'
 import { ComfyNodeDefImpl, useNodeDefStore } from '@/stores/nodeDefStore'
 import { useRightSidePanelStore } from '@/stores/workspace/rightSidePanelStore'
-import {
-  isImageNode,
-  isLGraphGroup,
-  isLGraphNode,
-  isLoad3dNode
-} from '@/utils/litegraphUtil'
+import { isImageNode, isLGraphNode } from '@/utils/litegraphUtil'
 import { filterOutputNodes } from '@/utils/nodeFilterUtil'
 import {
   createMockLGraphNode,
@@ -22,9 +17,7 @@ import {
 
 vi.mock('@/utils/litegraphUtil', () => ({
   isLGraphNode: vi.fn(),
-  isImageNode: vi.fn(),
-  isLGraphGroup: vi.fn(),
-  isLoad3dNode: vi.fn()
+  isImageNode: vi.fn()
 }))
 
 vi.mock('@/utils/nodeFilterUtil', () => ({
@@ -103,14 +96,6 @@ describe('useSelectionState', () => {
       const typedNode = node as { type?: string }
       return typedNode?.type === 'ImageNode'
     })
-    vi.mocked(isLGraphGroup).mockImplementation((item: unknown) => {
-      const typedItem = item as { isGroup?: boolean }
-      return typedItem?.isGroup === true
-    })
-    vi.mocked(isLoad3dNode).mockImplementation((node: unknown) => {
-      const typedNode = node as { type?: string }
-      return typedNode?.type === 'Load3D'
-    })
     vi.mocked(filterOutputNodes).mockImplementation((nodes) =>
       nodes.filter((n) => n.type === 'OutputNode')
     )
@@ -150,21 +135,6 @@ describe('useSelectionState', () => {
       const { hasMultipleSelection } = useSelectionState()
       expect(hasMultipleSelection.value).toBe(false)
     })
-
-    test('hasGroupedNodesSelection should detect a group containing nodes', () => {
-      const canvasStore = useCanvasStore()
-      const graphNode = createMockLGraphNode({ id: 2 })
-      const group = createMockPositionable({ id: 2000 })
-      Object.assign(group, {
-        isGroup: true,
-        isNode: false,
-        children: new Set([graphNode])
-      })
-      canvasStore.$state.selectedItems = [group]
-
-      const { hasGroupedNodesSelection } = useSelectionState()
-      expect(hasGroupedNodesSelection.value).toBe(true)
-    })
   })
 
   describe('Node Type Filtering', () => {
@@ -245,13 +215,6 @@ describe('useSelectionState', () => {
       const newIsPinned = newSelectedNodes.value.some((n) => n.pinned === true)
       expect(newIsPinned).toBe(false)
     })
-
-    test('should compute default flags for an empty node selection', () => {
-      expect(useSelectionState().computeSelectionFlags()).toEqual({
-        collapsed: false,
-        pinned: false
-      })
-    })
   })
 
   describe('Node Info', () => {

src/composables/node/useNodeBadge.test.ts

@@ -1,315 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
-import { createApp, defineComponent, h, nextTick } from 'vue'
-import type { App as VueApp } from 'vue'
-
-import { useNodeBadge } from '@/composables/node/useNodeBadge'
-import { BadgePosition, LGraphNode } from '@/lib/litegraph/src/litegraph'
-import type { LGraphBadge } from '@/lib/litegraph/src/litegraph'
-import type { ComfyExtension } from '@/types/comfy'
-import { toNodeId } from '@/types/nodeId'
-import { NodeBadgeMode } from '@/types/nodeSource'
-
-const {
-  settings,
-  appState,
-  extensionState,
-  nodeDefState,
-  pricingState,
-  setDirtyMock,
-  addEventListenerMock,
-  registerExtensionMock,
-  getCreditsBadgeMock,
-  updateSubgraphCreditsMock,
-  getNodePricingConfigMock,
-  getNodeDisplayPriceMock,
-  getRelevantWidgetNamesMock,
-  triggerPriceRecalculationMock,
-  useComputedWithWidgetWatchMock
-} = vi.hoisted(() => ({
-  settings: {} as Record<string, unknown>,
-  appState: {
-    graph: {
-      nodes: [] as unknown[]
-    }
-  },
-  extensionState: {
-    installed: false,
-    registered: undefined as ComfyExtension | undefined
-  },
-  nodeDefState: {
-    value: null as Record<string, unknown> | null
-  },
-  pricingState: {
-    revision: { value: 0 },
-    config: undefined as
-      | {
-          depends_on?: {
-            widgets?: string[]
-            inputs?: string[]
-            input_groups?: string[]
-          }
-        }
-      | undefined,
-    label: '1 credit'
-  },
-  setDirtyMock: vi.fn(),
-  addEventListenerMock: vi.fn(),
-  registerExtensionMock: vi.fn((extension: ComfyExtension) => {
-    extensionState.registered = extension
-  }),
-  getCreditsBadgeMock: vi.fn((text: string) => ({ text })),
-  updateSubgraphCreditsMock: vi.fn(),
-  getNodePricingConfigMock: vi.fn(() => pricingState.config),
-  getNodeDisplayPriceMock: vi.fn(() => pricingState.label),
-  getRelevantWidgetNamesMock: vi.fn(() => ['seed']),
-  triggerPriceRecalculationMock: vi.fn(),
-  useComputedWithWidgetWatchMock: vi.fn(() => vi.fn())
-}))
-
-vi.mock('@/scripts/app', () => ({
-  app: {
-    canvas: {
-      setDirty: setDirtyMock,
-      canvas: {
-        addEventListener: addEventListenerMock
-      },
-      graph: appState.graph
-    }
-  }
-}))
-
-vi.mock('@/platform/settings/settingStore', () => ({
-  useSettingStore: () => ({
-    get: (key: string) => settings[key]
-  })
-}))
-
-vi.mock('@/stores/extensionStore', () => ({
-  useExtensionStore: () => ({
-    isExtensionInstalled: () => extensionState.installed,
-    registerExtension: registerExtensionMock
-  })
-}))
-
-vi.mock('@/stores/nodeDefStore', () => ({
-  useNodeDefStore: () => ({
-    fromLGraphNode: () => nodeDefState.value
-  })
-}))
-
-vi.mock('@/stores/workspace/colorPaletteStore', () => ({
-  useColorPaletteStore: () => ({
-    completedActivePalette: {
-      colors: {
-        litegraph_base: {
-          BADGE_FG_COLOR: '#fff',
-          BADGE_BG_COLOR: '#000'
-        }
-      }
-    }
-  })
-}))
-
-vi.mock('@/composables/node/useNodePricing', () => ({
-  useNodePricing: () => ({
-    pricingRevision: pricingState.revision,
-    getNodePricingConfig: getNodePricingConfigMock,
-    getNodeDisplayPrice: getNodeDisplayPriceMock,
-    getRelevantWidgetNames: getRelevantWidgetNamesMock,
-    triggerPriceRecalculation: triggerPriceRecalculationMock
-  })
-}))
-
-vi.mock('@/composables/node/usePriceBadge', () => ({
-  usePriceBadge: () => ({
-    getCreditsBadge: getCreditsBadgeMock,
-    updateSubgraphCredits: updateSubgraphCreditsMock
-  })
-}))
-
-vi.mock('@/composables/node/useWatchWidget', () => ({
-  useComputedWithWidgetWatch: useComputedWithWidgetWatchMock
-}))
-
-class ApiNode extends LGraphNode {
-  static override nodeData = { name: 'ApiNode', api_node: true }
-}
-
-function mountBadge(): VueApp {
-  const app = createApp(
-    defineComponent({
-      setup() {
-        useNodeBadge()
-        return () => h('div')
-      }
-    })
-  )
-  app.mount(document.createElement('div'))
-  return app
-}
-
-function registeredExtension(): ComfyExtension {
-  if (!extensionState.registered)
-    throw new Error('Missing registered extension')
-  return extensionState.registered
-}
-
-function comfyApp(): Parameters<NonNullable<ComfyExtension['init']>>[0] {
-  return {} as Parameters<NonNullable<ComfyExtension['init']>>[0]
-}
-
-function callNodeCreated(node: LGraphNode) {
-  registeredExtension().nodeCreated?.(node, comfyApp())
-}
-
-function inputSlot(name: string) {
-  return new LGraphNode('slot').addInput(name, '*')
-}
-
-function defaultSettings() {
-  settings['Comfy.NodeBadge.NodeSourceBadgeMode'] = NodeBadgeMode.None
-  settings['Comfy.NodeBadge.NodeIdBadgeMode'] = NodeBadgeMode.None
-  settings['Comfy.NodeBadge.NodeLifeCycleBadgeMode'] = NodeBadgeMode.None
-  settings['Comfy.NodeBadge.ShowApiPricing'] = false
-}
-
-describe('useNodeBadge', () => {
-  let mountedApp: VueApp | undefined
-
-  beforeEach(() => {
-    defaultSettings()
-    extensionState.installed = false
-    extensionState.registered = undefined
-    appState.graph.nodes = []
-    nodeDefState.value = null
-    pricingState.revision.value = 0
-    pricingState.config = undefined
-    pricingState.label = '1 credit'
-    setDirtyMock.mockClear()
-    addEventListenerMock.mockClear()
-    registerExtensionMock.mockClear()
-    getCreditsBadgeMock.mockClear()
-    updateSubgraphCreditsMock.mockClear()
-    getNodePricingConfigMock.mockClear()
-    getNodeDisplayPriceMock.mockClear()
-    getRelevantWidgetNamesMock.mockClear()
-    triggerPriceRecalculationMock.mockClear()
-    useComputedWithWidgetWatchMock.mockClear()
-  })
-
-  afterEach(() => {
-    mountedApp?.unmount()
-    mountedApp = undefined
-  })
-
-  it('does not register the badge extension twice', async () => {
-    extensionState.installed = true
-    mountedApp = mountBadge()
-    await nextTick()
-
-    expect(registerExtensionMock).not.toHaveBeenCalled()
-  })
-
-  it('adds the configured node identity badge', async () => {
-    settings['Comfy.NodeBadge.NodeSourceBadgeMode'] = NodeBadgeMode.ShowAll
-    settings['Comfy.NodeBadge.NodeIdBadgeMode'] = NodeBadgeMode.ShowAll
-    settings['Comfy.NodeBadge.NodeLifeCycleBadgeMode'] =
-      NodeBadgeMode.HideBuiltIn
-    nodeDefState.value = {
-      isCoreNode: false,
-      nodeLifeCycleBadgeText: 'Beta',
-      nodeSource: { badgeText: 'Pack' }
-    }
-    const node = new LGraphNode('Test')
-    node.id = toNodeId('7')
-
-    mountedApp = mountBadge()
-    await nextTick()
-    callNodeCreated(node)
-    const badge = node.badges[0] as () => LGraphBadge
-
-    expect(node.badgePosition).toBe(BadgePosition.TopRight)
-    expect(badge().text).toBe('#7 Beta Pack')
-  })
-
-  it('hides built-in badge text when the mode excludes core nodes', async () => {
-    settings['Comfy.NodeBadge.NodeSourceBadgeMode'] = NodeBadgeMode.HideBuiltIn
-    settings['Comfy.NodeBadge.NodeIdBadgeMode'] = NodeBadgeMode.ShowAll
-    settings['Comfy.NodeBadge.NodeLifeCycleBadgeMode'] =
-      NodeBadgeMode.HideBuiltIn
-    nodeDefState.value = {
-      isCoreNode: true,
-      nodeLifeCycleBadgeText: 'Core',
-      nodeSource: { badgeText: 'Built-in' }
-    }
-    const node = new LGraphNode('Core')
-    node.id = toNodeId('11')
-
-    mountedApp = mountBadge()
-    await nextTick()
-    callNodeCreated(node)
-    const badge = node.badges[0] as () => LGraphBadge
-
-    expect(badge().text).toBe('#11')
-  })
-
-  it('adds dynamic API pricing badges and refreshes relevant input changes', async () => {
-    settings['Comfy.NodeBadge.ShowApiPricing'] = true
-    pricingState.config = {
-      depends_on: {
-        widgets: ['seed'],
-        inputs: ['image'],
-        input_groups: ['lora']
-      }
-    }
-    const originalOnConnectionsChange = vi.fn()
-    const node = new ApiNode('API')
-    node.onConnectionsChange = originalOnConnectionsChange
-
-    mountedApp = mountBadge()
-    await nextTick()
-    callNodeCreated(node)
-
-    expect(useComputedWithWidgetWatchMock).toHaveBeenCalledWith(node, {
-      widgetNames: ['seed'],
-      triggerCanvasRedraw: true
-    })
-    expect(getCreditsBadgeMock).toHaveBeenCalledWith('1 credit')
-
-    const priceBadge = node.badges[1] as () => { text: string }
-    expect(priceBadge().text).toBe('1 credit')
-    pricingState.label = '2 credits'
-    expect(priceBadge().text).toBe('2 credits')
-
-    node.onConnectionsChange?.(1, 0, true, undefined, inputSlot('image'))
-    node.onConnectionsChange?.(1, 0, true, undefined, inputSlot('lora.0'))
-    node.onConnectionsChange?.(1, 0, true, undefined, inputSlot('clip'))
-    node.onConnectionsChange?.(1, 0, true, undefined, inputSlot(''))
-
-    expect(originalOnConnectionsChange).toHaveBeenCalledTimes(4)
-    expect(triggerPriceRecalculationMock).toHaveBeenCalledTimes(2)
-    expect(triggerPriceRecalculationMock).toHaveBeenCalledWith(node)
-  })
-
-  it('updates subgraph credit badges from registered extension hooks', async () => {
-    const nodes = [new LGraphNode('one'), new LGraphNode('two')]
-    appState.graph.nodes = nodes
-
-    mountedApp = mountBadge()
-    await nextTick()
-    await registeredExtension().init?.(comfyApp())
-    await registeredExtension().afterConfigureGraph?.([], comfyApp())
-
-    const setGraphHandler = addEventListenerMock.mock.calls.find(
-      ([event]) => event === 'litegraph:set-graph'
-    )?.[1]
-    const convertedHandler = addEventListenerMock.mock.calls.find(
-      ([event]) => event === 'subgraph-converted'
-    )?.[1]
-    setGraphHandler?.()
-    convertedHandler?.({ detail: { subgraphNode: nodes[0] } })
-
-    expect(updateSubgraphCreditsMock).toHaveBeenCalledWith(nodes[0])
-    expect(updateSubgraphCreditsMock).toHaveBeenCalledWith(nodes[1])
-  })
-})

src/composables/node/useNodePricing.test.ts

@@ -1,6 +1,4 @@
-import { createTestingPinia } from '@pinia/testing'
-import { setActivePinia } from 'pinia'
-import { beforeEach, describe, expect, it } from 'vitest'
+import { describe, expect, it } from 'vitest'
 
 import { CREDITS_PER_USD, formatCredits } from '@/base/credits/comfyCredits'
 import {
@@ -14,7 +12,6 @@ import {
 import type { LGraphNode } from '@/lib/litegraph/src/litegraph'
 import { LiteGraph } from '@/lib/litegraph/src/litegraph'
 import type { ComfyNodeDef, PriceBadge } from '@/schemas/nodeDefSchema'
-import { useNodeDefStore } from '@/stores/nodeDefStore'
 import { toNodeId } from '@/types/nodeId'
 import { createMockLGraphNode } from '@/utils/__tests__/litegraphTestUtils'
 
@@ -126,35 +123,6 @@ function createMockNode(
   })
 }
 
-async function resolveDisplayPrice(
-  node: LGraphNode,
-  widgetOverrides?: ReadonlyMap<string, unknown>
-): Promise<string> {
-  const { getNodeDisplayPrice } = useNodePricing()
-  getNodeDisplayPrice(node, widgetOverrides)
-  await new Promise((resolve) => setTimeout(resolve, 50))
-  return getNodeDisplayPrice(node, widgetOverrides)
-}
-
-function createStoredNodeDef(
-  name: string,
-  price_badge?: PriceBadge
-): ComfyNodeDef {
-  return {
-    name,
-    display_name: name,
-    description: '',
-    category: 'test',
-    input: { required: {}, optional: {} },
-    output: [],
-    output_name: [],
-    output_is_list: [],
-    output_node: false,
-    python_module: 'test',
-    price_badge
-  } as ComfyNodeDef
-}
-
 // -----------------------------------------------------------------------------
 // Tests
 // -----------------------------------------------------------------------------
@@ -221,32 +189,6 @@ describe('useNodePricing', () => {
       expect(price).toBe(creditsLabel(0.5))
     })
 
-    it('should parse numeric strings and reject blank or invalid numbers', async () => {
-      const expression =
-        '{"type":"usd","usd": (widgets.count != null) ? widgets.count * 0.01 : 0.20}'
-      const badge = priceBadge(expression, [{ name: 'count', type: 'INT' }])
-
-      const parsedNode = createMockNodeWithPriceBadge(
-        'TestNumericStringNode',
-        badge,
-        [{ name: 'count', value: ' 5 ' }]
-      )
-      const blankNode = createMockNodeWithPriceBadge(
-        'TestBlankNumericStringNode',
-        badge,
-        [{ name: 'count', value: '   ' }]
-      )
-      const invalidNode = createMockNodeWithPriceBadge(
-        'TestInvalidNumericStringNode',
-        badge,
-        [{ name: 'count', value: 'five' }]
-      )
-
-      expect(await resolveDisplayPrice(parsedNode)).toBe(creditsLabel(0.05))
-      expect(await resolveDisplayPrice(blankNode)).toBe(creditsLabel(0.2))
-      expect(await resolveDisplayPrice(invalidNode)).toBe(creditsLabel(0.2))
-    })
-
     it('should handle COMBO widget with numeric value', async () => {
       const { getNodeDisplayPrice } = useNodePricing()
       const node = createMockNodeWithPriceBadge(
@@ -280,19 +222,6 @@ describe('useNodePricing', () => {
       expect(price).toBe(creditsLabel(0.1))
     })
 
-    it('should preserve boolean combo values', async () => {
-      const node = createMockNodeWithPriceBadge(
-        'TestComboBooleanNode',
-        priceBadge(
-          '(widgets.enabled = false) ? {"type":"usd","usd":0.04} : {"type":"usd","usd":0.08}',
-          [{ name: 'enabled', type: 'COMBO' }]
-        ),
-        [{ name: 'enabled', value: false }]
-      )
-
-      expect(await resolveDisplayPrice(node)).toBe(creditsLabel(0.04))
-    })
-
     it('should handle BOOLEAN widget', async () => {
       const { getNodeDisplayPrice } = useNodePricing()
       const node = createMockNodeWithPriceBadge(
@@ -309,51 +238,6 @@ describe('useNodePricing', () => {
       expect(price).toBe(creditsLabel(0.1))
     })
 
-    it('should parse BOOLEAN widget string values', async () => {
-      const badge = priceBadge(
-        '{"type":"usd","usd": widgets.premium ? 0.10 : 0.05}',
-        [{ name: 'premium', type: 'BOOLEAN' }]
-      )
-      const enabledNode = createMockNodeWithPriceBadge(
-        'TestBooleanStringTrueNode',
-        badge,
-        [{ name: 'premium', value: ' TRUE ' }]
-      )
-      const disabledNode = createMockNodeWithPriceBadge(
-        'TestBooleanStringFalseNode',
-        badge,
-        [{ name: 'premium', value: 'false' }]
-      )
-
-      expect(await resolveDisplayPrice(enabledNode)).toBe(creditsLabel(0.1))
-      expect(await resolveDisplayPrice(disabledNode)).toBe(creditsLabel(0.05))
-    })
-
-    it('should reject invalid BOOLEAN strings', async () => {
-      const node = createMockNodeWithPriceBadge(
-        'TestInvalidBooleanStringNode',
-        priceBadge(
-          '{"type":"usd","usd": widgets.premium = null ? 0.05 : 0.10}',
-          [{ name: 'premium', type: 'BOOLEAN' }]
-        ),
-        [{ name: 'premium', value: 'sometimes' }]
-      )
-
-      expect(await resolveDisplayPrice(node)).toBe(creditsLabel(0.05))
-    })
-
-    it('should reject object values for numeric widgets', async () => {
-      const node = createMockNodeWithPriceBadge(
-        'TestObjectNumericNode',
-        priceBadge('{"type":"usd","usd": widgets.count = null ? 0.05 : 0.10}', [
-          { name: 'count', type: 'INT' }
-        ]),
-        [{ name: 'count', value: { count: 5 } }]
-      )
-
-      expect(await resolveDisplayPrice(node)).toBe(creditsLabel(0.05))
-    })
-
     it('should handle STRING widget (lowercased)', async () => {
       const { getNodeDisplayPrice } = useNodePricing()
       const node = createMockNodeWithPriceBadge(
@@ -584,42 +468,6 @@ describe('useNodePricing', () => {
     })
   })
 
-  describe('dependency context', () => {
-    it('should prefer widget overrides over node widget values', async () => {
-      const node = createMockNodeWithPriceBadge(
-        'TestWidgetOverrideNode',
-        priceBadge('{"type":"usd","usd": widgets.count * 0.01}', [
-          { name: 'count', type: 'INT' }
-        ]),
-        [{ name: 'count', value: 2 }]
-      )
-
-      const price = await resolveDisplayPrice(node, new Map([['count', '7']]))
-
-      expect(price).toBe(creditsLabel(0.07))
-    })
-
-    it('should treat missing input group arrays as zero connected inputs', async () => {
-      const node = Object.assign(createMockLGraphNode(), {
-        widgets: [],
-        constructor: {
-          nodeData: {
-            name: 'TestMissingInputGroupArrayNode',
-            api_node: true,
-            price_badge: priceBadge(
-              '{"type":"usd","usd": (inputGroups.images = 0) ? 0.05 : 0.10}',
-              [],
-              [],
-              ['images']
-            )
-          }
-        }
-      })
-
-      expect(await resolveDisplayPrice(node)).toBe(creditsLabel(0.05))
-    })
-  })
-
   describe('edge cases', () => {
     it('should return empty string for non-API nodes', () => {
       const { getNodeDisplayPrice } = useNodePricing()
@@ -747,86 +595,6 @@ describe('useNodePricing', () => {
     })
   })
 
-  describe('node type pricing dependencies', () => {
-    beforeEach(() => {
-      setActivePinia(createTestingPinia({ stubActions: false }))
-    })
-
-    it('returns empty dependency metadata for node types without pricing', () => {
-      const store = useNodeDefStore()
-      store.addNodeDef(createStoredNodeDef('UnpricedNode'))
-      const {
-        getInputGroupPrefixes,
-        getInputNames,
-        getRelevantWidgetNames,
-        hasDynamicPricing
-      } = useNodePricing()
-
-      expect(getRelevantWidgetNames('UnpricedNode')).toEqual([])
-      expect(hasDynamicPricing('UnpricedNode')).toBe(false)
-      expect(getInputGroupPrefixes('UnpricedNode')).toEqual([])
-      expect(getInputNames('UnpricedNode')).toEqual([])
-    })
-
-    it('dedupes dynamic pricing dependencies while preserving order', () => {
-      const store = useNodeDefStore()
-      store.addNodeDef(
-        createStoredNodeDef(
-          'DynamicPricingNode',
-          priceBadge(
-            '{"type":"usd","usd":0.05}',
-            [
-              { name: 'seed', type: 'INT' },
-              { name: 'quality', type: 'COMBO' }
-            ],
-            ['image', 'seed'],
-            ['clips', 'image']
-          )
-        )
-      )
-      const {
-        getInputGroupPrefixes,
-        getInputNames,
-        getRelevantWidgetNames,
-        hasDynamicPricing
-      } = useNodePricing()
-
-      expect(getRelevantWidgetNames('DynamicPricingNode')).toEqual([
-        'seed',
-        'quality',
-        'image',
-        'clips'
-      ])
-      expect(hasDynamicPricing('DynamicPricingNode')).toBe(true)
-      expect(getInputGroupPrefixes('DynamicPricingNode')).toEqual([
-        'clips',
-        'image'
-      ])
-      expect(getInputNames('DynamicPricingNode')).toEqual(['image', 'seed'])
-    })
-
-    it('handles fixed pricing metadata without dependencies', () => {
-      const store = useNodeDefStore()
-      store.addNodeDef(
-        createStoredNodeDef(
-          'FixedPricingNode',
-          priceBadge('{"type":"usd","usd":0.05}')
-        )
-      )
-      const {
-        getInputGroupPrefixes,
-        getInputNames,
-        getRelevantWidgetNames,
-        hasDynamicPricing
-      } = useNodePricing()
-
-      expect(getRelevantWidgetNames('FixedPricingNode')).toEqual([])
-      expect(hasDynamicPricing('FixedPricingNode')).toBe(false)
-      expect(getInputGroupPrefixes('FixedPricingNode')).toEqual([])
-      expect(getInputNames('FixedPricingNode')).toEqual([])
-    })
-  })
-
   describe('reactive revision', () => {
     it('bumps pricingRevision after an async evaluation resolves (Nodes 1.0 mode)', async () => {
       const { getNodeDisplayPrice, pricingRevision } = useNodePricing()
@@ -975,16 +743,6 @@ describe('useNodePricing', () => {
       expect(price).toBe('')
     })
 
-    it('should reuse the cached empty label after runtime failures', async () => {
-      const node = createMockNodeWithPriceBadge(
-        'TestCachedRuntimeErrorNode',
-        priceBadge('$lookup(undefined, "key")')
-      )
-
-      expect(await resolveDisplayPrice(node)).toBe('')
-      expect(await resolveDisplayPrice(node)).toBe('')
-    })
-
     it('should return empty string for invalid PricingResult type', async () => {
       const { getNodeDisplayPrice } = useNodePricing()
       const node = createMockNodeWithPriceBadge(
@@ -1210,21 +968,8 @@ describe('formatPricingResult', () => {
       expect(result).toBe('~10.6')
     })
 
-    it('should parse string usd values with default approximate formatting', () => {
-      const result = formatPricingResult(
-        { type: 'usd', usd: '0.05' },
-        { valueOnly: true, defaults: { approximate: true } }
-      )
-      expect(result).toBe('~10.6')
-    })
-
     it('should return empty for null usd', () => {
-      const result = formatPricingResult({ type: 'usd', usd: null })
-      expect(result).toBe('')
-    })
-
-    it('should return empty for blank string usd', () => {
-      const result = formatPricingResult({ type: 'usd', usd: '   ' })
+      const result = formatPricingResult({ type: 'usd', usd: null as never })
       expect(result).toBe('')
     })
   })
@@ -1254,14 +999,6 @@ describe('formatPricingResult', () => {
       )
       expect(result).toBe('10.6')
     })
-
-    it('should parse string range values with default approximate formatting', () => {
-      const result = formatPricingResult(
-        { type: 'range_usd', min_usd: '0.05', max_usd: '0.1' },
-        { valueOnly: true, defaults: { approximate: true } }
-      )
-      expect(result).toBe('~10.6-21.1')
-    })
   })
 
   describe('type: list_usd', () => {
@@ -1280,22 +1017,6 @@ describe('formatPricingResult', () => {
       )
       expect(result).toBe('10.6/21.1')
     })
-
-    it('should return valueOnly format with approximate prefix', () => {
-      const result = formatPricingResult(
-        { type: 'list_usd', usd: [0.05, 0.1] },
-        { valueOnly: true, defaults: { approximate: true } }
-      )
-      expect(result).toBe('~10.6/21.1')
-    })
-
-    it('should return empty when list value is not an array', () => {
-      const result = formatPricingResult({
-        type: 'list_usd',
-        usd: 'not-a-list'
-      })
-      expect(result).toBe('')
-    })
   })
 
   describe('type: text', () => {
@@ -1303,11 +1024,6 @@ describe('formatPricingResult', () => {
       const result = formatPricingResult({ type: 'text', text: 'Free' })
       expect(result).toBe('Free')
     })
-
-    it('should return empty when text is missing', () => {
-      const result = formatPricingResult({ type: 'text' })
-      expect(result).toBe('')
-    })
   })
 
   describe('legacy format', () => {
@@ -1474,29 +1190,6 @@ describe('evaluateNodeDefPricing', () => {
     expect(result).toBe('21.1') // 10 * 0.01 = 0.1 USD = 21.1 credits
   })
 
-  it('should use default value from optional input spec', async () => {
-    const nodeDef = createMockNodeDef({
-      name: 'OptionalDefaultValueNode',
-      price_badge: {
-        engine: 'jsonata',
-        expr: '{"type":"usd","usd": widgets.count * 0.01}',
-        depends_on: {
-          widgets: [{ name: 'count', type: 'INT' }],
-          inputs: [],
-          input_groups: []
-        }
-      },
-      input: {
-        required: {},
-        optional: {
-          count: ['INT', { default: 4 }]
-        }
-      }
-    })
-    const result = await evaluateNodeDefPricing(nodeDef)
-    expect(result).toBe('8.4')
-  })
-
   it('should use first option for COMBO without default', async () => {
     const nodeDef = createMockNodeDef({
       name: 'ComboNode',
@@ -1572,30 +1265,6 @@ describe('evaluateNodeDefPricing', () => {
     expect(result).toBe('10.6')
   })
 
-  it('should handle combo option arrays with primitive values', async () => {
-    const nodeDef = createMockNodeDef({
-      name: 'PrimitiveOptionsNode',
-      price_badge: {
-        engine: 'jsonata',
-        expr: '{"type":"usd","usd": widgets.mode = "fast" ? 0.05 : 0.10}',
-        depends_on: {
-          widgets: [{ name: 'mode', type: 'COMBO' }],
-          inputs: [],
-          input_groups: []
-        }
-      },
-      input: {
-        required: {
-          mode: ['COMBO', { options: ['fast', 'slow'] }]
-        }
-      }
-    })
-
-    const result = await evaluateNodeDefPricing(nodeDef)
-
-    expect(result).toBe('10.6')
-  })
-
   it('should assume inputs disconnected in preview', async () => {
     const nodeDef = createMockNodeDef({
       name: 'InputConnectedNode',

src/composables/useTreeExpansion.test.ts

@@ -1,102 +0,0 @@
-import { ref } from 'vue'
-import { describe, expect, it } from 'vitest'
-
-import { useTreeExpansion } from '@/composables/useTreeExpansion'
-import type { TreeNode } from '@/types/treeExplorerTypes'
-
-function node(over: Partial<TreeNode>): TreeNode {
-  return over as TreeNode
-}
-
-// root ─┬─ a ── a1 (leaf)
-//       └─ b (leaf)
-function sampleTree() {
-  const a1 = node({ key: 'a1', leaf: true })
-  const a = node({ key: 'a', leaf: false, children: [a1] })
-  const b = node({ key: 'b', leaf: true })
-  const root = node({ key: 'root', leaf: false, children: [a, b] })
-  return { root, a, a1, b }
-}
-
-describe('useTreeExpansion', () => {
-  it('toggleNode adds then removes a node key', () => {
-    const expandedKeys = ref<Record<string, boolean>>({})
-    const { toggleNode } = useTreeExpansion(expandedKeys)
-    const n = node({ key: 'x' })
-
-    toggleNode(n)
-    expect(expandedKeys.value).toEqual({ x: true })
-
-    toggleNode(n)
-    expect(expandedKeys.value).toEqual({})
-  })
-
-  it('toggleNode ignores nodes without a string key', () => {
-    const expandedKeys = ref<Record<string, boolean>>({})
-    const { toggleNode } = useTreeExpansion(expandedKeys)
-
-    toggleNode(node({ key: undefined }))
-    toggleNode(node({ key: 42 as unknown as string }))
-
-    expect(expandedKeys.value).toEqual({})
-  })
-
-  it('expandNode expands the node and all non-leaf descendants only', () => {
-    const expandedKeys = ref<Record<string, boolean>>({})
-    const { expandNode } = useTreeExpansion(expandedKeys)
-    const { root } = sampleTree()
-
-    expandNode(root)
-
-    // root and a are folders; a1 and b are leaves and must be skipped
-    expect(expandedKeys.value).toEqual({ root: true, a: true })
-  })
-
-  it('expandNode does nothing for a leaf node', () => {
-    const expandedKeys = ref<Record<string, boolean>>({})
-    const { expandNode } = useTreeExpansion(expandedKeys)
-
-    expandNode(node({ key: 'leaf', leaf: true }))
-
-    expect(expandedKeys.value).toEqual({})
-  })
-
-  it('collapseNode removes the node and its non-leaf descendants', () => {
-    const expandedKeys = ref<Record<string, boolean>>({
-      root: true,
-      a: true,
-      stray: true
-    })
-    const { collapseNode } = useTreeExpansion(expandedKeys)
-    const { root } = sampleTree()
-
-    collapseNode(root)
-
-    expect(expandedKeys.value).toEqual({ stray: true })
-  })
-
-  it('toggleNodeRecursive expands when collapsed and collapses when expanded', () => {
-    const expandedKeys = ref<Record<string, boolean>>({})
-    const { toggleNodeRecursive } = useTreeExpansion(expandedKeys)
-    const { root } = sampleTree()
-
-    toggleNodeRecursive(root)
-    expect(expandedKeys.value).toEqual({ root: true, a: true })
-
-    toggleNodeRecursive(root)
-    expect(expandedKeys.value).toEqual({})
-  })
-
-  it('toggleNodeOnEvent toggles recursively with ctrl and singly without', () => {
-    const expandedKeys = ref<Record<string, boolean>>({})
-    const { toggleNodeOnEvent } = useTreeExpansion(expandedKeys)
-    const { root } = sampleTree()
-
-    toggleNodeOnEvent(new KeyboardEvent('keydown', { ctrlKey: true }), root)
-    expect(expandedKeys.value).toEqual({ root: true, a: true })
-
-    // Plain toggle removes only the node's own key, leaving descendants
-    toggleNodeOnEvent(new MouseEvent('click'), root)
-    expect(expandedKeys.value).toEqual({ a: true })
-  })
-})

src/extensions/core/groupNode.test.ts

@@ -1,46 +1,14 @@
-import { createTestingPinia } from '@pinia/testing'
-import { setActivePinia } from 'pinia'
-import { beforeEach, describe, expect, it, vi } from 'vitest'
+import { describe, expect, it, vi } from 'vitest'
 
 import type { SerialisedLLinkArray } from '@/lib/litegraph/src/LLink'
-import { LGraphNode, LiteGraph } from '@/lib/litegraph/src/litegraph'
 import type { ComfyNode } from '@/platform/workflow/validation/schemas/workflowSchema'
-import type { ComfyNodeDef } from '@/schemas/nodeDefSchema'
-import type { ComfyApp } from '@/scripts/app'
-import type { ComfyExtension } from '@/types/comfy'
 
 import type { GroupNodeWorkflowData } from './groupNode'
 
-const appMock = vi.hoisted(() => ({
-  canvas: {
-    emitAfterChange: vi.fn(),
-    emitBeforeChange: vi.fn(),
-    selected_nodes: {}
-  },
-  registerExtension: vi.fn(),
-  registerNodeDef: vi.fn(),
-  rootGraph: {
-    convertToSubgraph: vi.fn(),
-    extra: {},
-    getNodeById: vi.fn(),
-    links: {},
-    nodes: [],
-    remove: vi.fn()
-  }
-}))
-
-const widgetStoreMock = vi.hoisted(() => ({
-  inputIsWidget: vi.fn((spec: unknown[]) =>
-    ['BOOLEAN', 'COMBO', 'FLOAT', 'INT', 'STRING'].includes(String(spec[0]))
-  )
-}))
-
 vi.mock('@/scripts/app', () => ({
-  app: appMock
-}))
-
-vi.mock('@/stores/widgetStore', () => ({
-  useWidgetStore: () => widgetStoreMock
+  app: {
+    registerExtension: vi.fn()
+  }
 }))
 
 import { GroupNodeConfig, replaceLegacySeparators } from './groupNode'
@@ -58,42 +26,6 @@ function makeNode(type: string): ComfyNode {
   }
 }
 
-function makeNodeDef(overrides: Partial<ComfyNodeDef> = {}): ComfyNodeDef {
-  return {
-    name: 'TestNode',
-    display_name: 'Test Node',
-    description: '',
-    category: 'test',
-    input: { required: {}, optional: {} },
-    output: [],
-    output_name: [],
-    output_is_list: [],
-    output_node: false,
-    python_module: 'test',
-    ...overrides
-  } as ComfyNodeDef
-}
-
-function extension(): ComfyExtension {
-  const groupExtension = appMock.registerExtension.mock.calls.find(
-    ([registered]) => registered.name === 'Comfy.GroupNode'
-  )?.[0]
-  if (!groupExtension) throw new Error('GroupNode extension was not registered')
-  return groupExtension as ComfyExtension
-}
-
-function addCustomNodeDefs(defs: Record<string, ComfyNodeDef>) {
-  extension().addCustomNodeDefs?.(defs, appMock as unknown as ComfyApp)
-}
-
-beforeEach(() => {
-  setActivePinia(createTestingPinia({ stubActions: false }))
-  appMock.registerNodeDef.mockReset()
-  widgetStoreMock.inputIsWidget.mockClear()
-  LiteGraph.registered_node_types = {}
-  addCustomNodeDefs({})
-})
-
 describe('replaceLegacySeparators', () => {
   it('rewrites the legacy "workflow/" prefix to "workflow>"', () => {
     const nodes = [makeNode('workflow/My Group')]
@@ -172,389 +104,4 @@ describe('GroupNodeConfig.getLinks', () => {
     const config = configFrom([], [[0, 1, 'IMAGE']])
     expect(config.externalFrom[0][1]).toBe('IMAGE')
   })
-
-  it('ignores external links without a type and accumulates multiple slots', () => {
-    const config = configFrom(
-      [],
-      [
-        [0, 1, null as unknown as string],
-        [0, 2, 'LATENT'],
-        [0, 3, 'IMAGE']
-      ]
-    )
-
-    expect(config.externalFrom[0]).toEqual({ 2: 'LATENT', 3: 'IMAGE' })
-  })
-})
-
-describe('GroupNodeConfig.getNodeDef', () => {
-  const imageNodeDef = makeNodeDef({
-    name: 'ImageNode',
-    input: {
-      required: {
-        image: ['IMAGE', {}],
-        mode: [['fast', 'slow'], {}]
-      },
-      optional: {
-        strength: ['FLOAT', { default: 1 }]
-      }
-    },
-    output: ['IMAGE'],
-    output_name: ['image'],
-    output_is_list: [false]
-  })
-
-  beforeEach(() => {
-    addCustomNodeDefs({ ImageNode: imageNodeDef })
-  })
-
-  it('returns registered definitions for normal node types', () => {
-    const config = new GroupNodeConfig('group', {
-      nodes: [{ index: 0, type: 'ImageNode' }],
-      links: [],
-      external: []
-    })
-
-    expect(config.getNodeDef({ index: 0, type: 'ImageNode' })).toBe(
-      imageNodeDef
-    )
-  })
-
-  it('returns undefined for nodes without an index or a known type', () => {
-    const config = new GroupNodeConfig('group', {
-      nodes: [{ type: 'UnknownNode' }],
-      links: [],
-      external: []
-    })
-
-    expect(config.getNodeDef({ type: 'UnknownNode' })).toBeUndefined()
-  })
-
-  it('skips unlinked primitive nodes', () => {
-    const config = new GroupNodeConfig('group', {
-      nodes: [{ index: 0, type: 'PrimitiveNode' }],
-      links: [],
-      external: []
-    })
-
-    expect(
-      config.getNodeDef({ index: 0, type: 'PrimitiveNode' })
-    ).toBeUndefined()
-  })
-
-  it('derives primitive node type from the outgoing link type', () => {
-    const config = new GroupNodeConfig('group', {
-      nodes: [
-        { index: 0, type: 'PrimitiveNode' },
-        { index: 1, type: 'ImageNode' }
-      ],
-      links: [[0, 0, 1, 0, 1, 'IMAGE'] as SerialisedLLinkArray],
-      external: []
-    })
-
-    expect(
-      config.getNodeDef({ index: 0, type: 'PrimitiveNode' })
-    ).toMatchObject({
-      input: { required: { value: ['IMAGE', {}] } },
-      output: ['IMAGE']
-    })
-  })
-
-  it('falls back to null when primitive combo target spec is not primitive', () => {
-    const config = new GroupNodeConfig('group', {
-      nodes: [
-        {
-          index: 0,
-          type: 'PrimitiveNode',
-          outputs: [{ name: 'mode', widget: { name: 'mode' } }]
-        },
-        { index: 1, type: 'ImageNode' }
-      ],
-      links: [[0, 0, 1, 0, 1, 'COMBO'] as SerialisedLLinkArray],
-      external: []
-    })
-
-    expect(config.getNodeDef(config.nodeData.nodes[0])).toMatchObject({
-      input: { required: { value: [null, {}] } },
-      output: [null]
-    })
-  })
-
-  it('returns null for reroutes used only inside the group', () => {
-    const config = new GroupNodeConfig('group', {
-      nodes: [
-        { index: 0, type: 'ImageNode' },
-        { index: 1, type: 'Reroute' },
-        { index: 2, type: 'ImageNode' }
-      ],
-      links: [
-        [0, 0, 1, 0, 1, 'IMAGE'],
-        [1, 0, 2, 0, 2, 'IMAGE']
-      ] as SerialisedLLinkArray[],
-      external: []
-    })
-
-    expect(config.getNodeDef({ index: 1, type: 'Reroute' })).toBeNull()
-  })
-
-  it('derives reroute type from outgoing target inputs', () => {
-    const config = new GroupNodeConfig('group', {
-      nodes: [
-        { index: 0, type: 'Reroute' },
-        {
-          index: 1,
-          type: 'ImageNode',
-          inputs: [{ name: 'image', type: 'IMAGE' }]
-        }
-      ],
-      links: [[0, 0, 1, 0, 1, 'IMAGE'] as SerialisedLLinkArray],
-      external: [[0, 0, 'IMAGE']]
-    })
-
-    expect(config.getNodeDef({ index: 0, type: 'Reroute' })).toMatchObject({
-      input: { required: { IMAGE: ['IMAGE', { forceInput: true }] } },
-      output: ['IMAGE']
-    })
-  })
-
-  it('derives reroute type from incoming output metadata', () => {
-    const config = new GroupNodeConfig('group', {
-      nodes: [
-        { index: 0, type: 'ImageNode', outputs: [{ type: 'LATENT' }] },
-        { index: 1, type: 'Reroute' }
-      ],
-      links: [[0, 0, 1, 0, 1, 'LATENT'] as SerialisedLLinkArray],
-      external: [[1, 0, 'LATENT']]
-    })
-
-    expect(config.getNodeDef({ index: 1, type: 'Reroute' })).toMatchObject({
-      input: { required: { LATENT: ['LATENT', { forceInput: true }] } },
-      output: ['LATENT']
-    })
-  })
-
-  it('derives pipe reroute type from external metadata when links omit it', () => {
-    const config = new GroupNodeConfig('group', {
-      nodes: [{ index: 0, type: 'Reroute' }],
-      links: [],
-      external: [[0, 0, 'MASK']]
-    })
-
-    expect(config.getNodeDef({ index: 0, type: 'Reroute' })).toMatchObject({
-      input: { required: { MASK: ['MASK', { forceInput: true }] } },
-      output: ['MASK']
-    })
-  })
-})
-
-describe('GroupNodeConfig input and output mapping', () => {
-  function configWithNode(node: GroupNodeWorkflowData['nodes'][number]) {
-    const config = new GroupNodeConfig('group', {
-      nodes: [node],
-      links: [],
-      external: [],
-      config: {
-        0: {
-          input: {
-            hidden: { visible: false },
-            renamed: { name: 'Custom Name' }
-          },
-          output: {
-            1: { name: 'Custom Output' },
-            2: { visible: false }
-          }
-        }
-      }
-    })
-    config.nodeDef = makeNodeDef({
-      input: { required: {} },
-      output: [],
-      output_name: [],
-      output_is_list: []
-    })
-    return config
-  }
-
-  it('renames duplicate inputs and adds seed control metadata', () => {
-    const config = configWithNode({
-      index: 0,
-      type: 'Sampler',
-      title: 'Sampler A',
-      inputs: [{ name: 'seed', label: 'Seed Label' }]
-    })
-    const seenInputs = { seed: 1, 'Sampler A seed': 1 }
-    const result = config.getInputConfig(
-      { index: 0, type: 'Sampler', title: 'Sampler A' },
-      'seed',
-      seenInputs,
-      ['INT', {}]
-    )
-
-    expect(result.name).toBe('Sampler A 1 seed')
-    expect(result.config).toEqual([
-      'INT',
-      { control_after_generate: 'Sampler A control_after_generate' }
-    ])
-  })
-
-  it('maps image upload widget aliases through converted widget names', () => {
-    const config = configWithNode({ index: 0, type: 'LoadImage' })
-    config.oldToNewWidgetMap[0] = { customImage: 'Uploaded Image' }
-
-    expect(
-      config.getInputConfig({ index: 0, type: 'LoadImage' }, 'renamed', {}, [
-        'IMAGEUPLOAD',
-        { widget: 'customImage' }
-      ])
-    ).toMatchObject({
-      name: 'Custom Name',
-      config: ['IMAGEUPLOAD', { widget: 'Uploaded Image' }]
-    })
-  })
-
-  it('splits widget inputs, socket inputs, and converted widget slots', () => {
-    const config = configWithNode({
-      index: 0,
-      type: 'MixedNode',
-      inputs: [{ name: 'mode', widget: { name: 'mode' } }]
-    })
-
-    const result = config.processWidgetInputs(
-      {
-        mode: ['COMBO', {}],
-        image: ['IMAGE', {}]
-      },
-      {
-        index: 0,
-        type: 'MixedNode',
-        inputs: [{ name: 'mode', widget: { name: 'mode' } }]
-      },
-      ['mode', 'image'],
-      {}
-    )
-
-    expect(result.slots).toEqual(['image'])
-    expect(result.converted.get(0)).toBe('mode')
-    expect(config.oldToNewWidgetMap[0].mode).toBeNull()
-  })
-
-  it('adds visible unlinked input slots and skips hidden configured inputs', () => {
-    const config = configWithNode({
-      index: 0,
-      type: 'InputNode'
-    })
-    const inputMap: Record<number, number> = {}
-    config.processInputSlots(
-      {
-        image: ['IMAGE', {}],
-        hidden: ['LATENT', {}]
-      },
-      { index: 0, type: 'InputNode' },
-      ['image', 'hidden'],
-      {},
-      inputMap,
-      {}
-    )
-
-    expect(config.nodeDef?.input?.required).toEqual({ image: ['IMAGE', {}] })
-    expect(inputMap).toEqual({ 0: 0 })
-  })
-
-  it('adds output metadata, hides linked/internal outputs, and dedupes labels', () => {
-    const config = configWithNode({
-      index: 0,
-      type: 'OutputNode',
-      title: 'Output A',
-      outputs: [{ name: 'image', label: 'Rendered' }]
-    })
-    config.linksFrom[0] = {
-      0: [[0, 0, 1, 0, 1, 'IMAGE'] as SerialisedLLinkArray]
-    }
-    config.processNodeOutputs(
-      { index: 0, type: 'OutputNode', title: 'Output A' },
-      { Rendered: 1 },
-      {
-        input: { required: {} },
-        output: ['IMAGE', 'LATENT', 'MASK'],
-        output_name: ['image', 'latent', 'mask'],
-        output_is_list: [false, true, false]
-      }
-    )
-
-    expect(config.outputVisibility).toEqual([false, true, false])
-    expect(config.nodeDef?.output).toEqual(['LATENT'])
-    expect(config.nodeDef?.output_is_list).toEqual([true])
-    expect(config.nodeDef?.output_name).toEqual(['Custom Output'])
-  })
-})
-
-describe('GroupNodeConfig.registerFromWorkflow', () => {
-  it('adds missing type actions and skips registration for incomplete groups', async () => {
-    const groupNodes: Record<string, GroupNodeWorkflowData> = {
-      Broken: {
-        nodes: [{ index: 0, type: 'MissingNode' }],
-        links: [],
-        external: []
-      }
-    }
-    const missingNodeTypes: Parameters<
-      typeof GroupNodeConfig.registerFromWorkflow
-    >[1] = []
-
-    await GroupNodeConfig.registerFromWorkflow(groupNodes, missingNodeTypes)
-
-    expect(appMock.registerNodeDef).not.toHaveBeenCalled()
-    expect(missingNodeTypes).toHaveLength(2)
-    expect(missingNodeTypes[0]).toMatchObject({
-      type: 'MissingNode',
-      hint: " (In group node 'workflow>Broken')"
-    })
-
-    const action = missingNodeTypes[1]
-    if (typeof action !== 'string') {
-      const target = document.createElement('button')
-      const { callback } = action.action as {
-        callback: (event: MouseEvent) => void
-      }
-      const event = new MouseEvent('click')
-      Object.defineProperty(event, 'target', { value: target })
-      callback(event)
-      expect(groupNodes.Broken).toBeUndefined()
-      expect(target.textContent).toBe('Removed')
-      expect(target.style.pointerEvents).toBe('none')
-    }
-  })
-
-  it('registers complete group node types and stores their generated node defs', async () => {
-    addCustomNodeDefs({
-      ImageNode: makeNodeDef({
-        name: 'ImageNode',
-        input: { required: { image: ['IMAGE', {}] } },
-        output: ['IMAGE'],
-        output_name: ['image'],
-        output_is_list: [false]
-      })
-    })
-    LiteGraph.registered_node_types.ImageNode = class extends LGraphNode {}
-
-    await GroupNodeConfig.registerFromWorkflow(
-      {
-        Complete: {
-          nodes: [{ index: 0, type: 'ImageNode' }],
-          links: [],
-          external: [[0, 0, 'IMAGE']]
-        }
-      },
-      []
-    )
-
-    expect(appMock.registerNodeDef).toHaveBeenCalledWith(
-      'workflow>Complete',
-      expect.objectContaining({
-        category: 'group nodes>workflow',
-        display_name: 'Complete',
-        name: 'workflow>Complete'
-      })
-    )
-  })
 })

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

@@ -1,6 +1,7 @@
 import { createTestingPinia } from '@pinia/testing'
 import { setActivePinia } from 'pinia'
 import { beforeEach, describe, expect, it, vi } from 'vitest'
+import { ref } from 'vue'
 
 import {
   getSettingInfo,
@@ -10,47 +11,31 @@ import type { SettingTreeNode } from '@/platform/settings/settingStore'
 
 import { useSettingUI } from './useSettingUI'
 
-const { auth, billing, dist, featureFlags, vueFlags } = vi.hoisted(() => ({
-  auth: { isLoggedIn: { value: false } },
-  billing: { isActiveSubscription: { value: false } },
-  dist: { isCloud: false, isDesktop: false },
-  featureFlags: { teamWorkspacesEnabled: false, userSecretsEnabled: false },
-  vueFlags: { shouldRenderVueNodes: { value: false } }
-}))
-
 vi.mock('vue-i18n', () => ({
   useI18n: () => ({ t: (_: string, fallback: string) => fallback })
 }))
 
 vi.mock('@/composables/auth/useCurrentUser', () => ({
-  useCurrentUser: () => ({ isLoggedIn: auth.isLoggedIn })
+  useCurrentUser: () => ({ isLoggedIn: ref(false) })
 }))
 
 vi.mock('@/composables/billing/useBillingContext', () => ({
-  useBillingContext: () => ({
-    isActiveSubscription: billing.isActiveSubscription
-  })
+  useBillingContext: () => ({ isActiveSubscription: ref(false) })
 }))
 
 vi.mock('@/composables/useFeatureFlags', () => ({
   useFeatureFlags: () => ({
-    flags: featureFlags
+    flags: { teamWorkspacesEnabled: false, userSecretsEnabled: false }
   })
 }))
 
 vi.mock('@/composables/useVueFeatureFlags', () => ({
-  useVueFeatureFlags: () => ({
-    shouldRenderVueNodes: vueFlags.shouldRenderVueNodes
-  })
+  useVueFeatureFlags: () => ({ shouldRenderVueNodes: ref(false) })
 }))
 
 vi.mock('@/platform/distribution/types', () => ({
-  get isCloud() {
-    return dist.isCloud
-  },
-  get isDesktop() {
-    return dist.isDesktop
-  }
+  isCloud: false,
+  isDesktop: false
 }))
 
 vi.mock('@/platform/settings/settingStore', () => ({
@@ -64,7 +49,6 @@ interface MockSettingParams {
   type: string
   defaultValue: unknown
   category?: string[]
-  hideInVueNodes?: boolean
 }
 
 describe('useSettingUI', () => {
@@ -88,23 +72,13 @@ describe('useSettingUI', () => {
       defaultValue: 'dark'
     }
   }
-  let settingsById: Record<string, MockSettingParams>
 
   beforeEach(() => {
     setActivePinia(createTestingPinia())
     vi.clearAllMocks()
-    auth.isLoggedIn.value = false
-    billing.isActiveSubscription.value = false
-    dist.isCloud = false
-    dist.isDesktop = false
-    featureFlags.teamWorkspacesEnabled = false
-    featureFlags.userSecretsEnabled = false
-    vueFlags.shouldRenderVueNodes.value = false
-    Object.assign(window, { __CONFIG__: {} })
 
-    settingsById = mockSettings
     vi.mocked(useSettingStore).mockReturnValue({
-      settingsById
+      settingsById: mockSettings
     } as ReturnType<typeof useSettingStore>)
 
     vi.mocked(getSettingInfo).mockImplementation((setting) => {
@@ -133,9 +107,9 @@ describe('useSettingUI', () => {
       undefined,
       'Comfy.Locale'
     )
-    expect(defaultCategory.value).toBe(
-      findCategory(settingCategories.value, 'Comfy')
-    )
+    const comfyCategory = findCategory(settingCategories.value, 'Comfy')
+    expect(comfyCategory).toBeDefined()
+    expect(defaultCategory.value).toBe(comfyCategory)
   })
 
   it('resolves different category from scrollToSettingId', () => {
@@ -147,6 +121,7 @@ describe('useSettingUI', () => {
       settingCategories.value,
       'Appearance'
     )
+    expect(appearanceCategory).toBeDefined()
     expect(defaultCategory.value).toBe(appearanceCategory)
   })
 
@@ -162,82 +137,4 @@ describe('useSettingUI', () => {
     const { defaultCategory } = useSettingUI('about', 'Comfy.Locale')
     expect(defaultCategory.value.key).toBe('about')
   })
-
-  it('falls back when defaultPanel is not in the menu', () => {
-    const missingPanel = 'missing' as unknown as Parameters<
-      typeof useSettingUI
-    >[0]
-    const { defaultCategory, settingCategories } = useSettingUI(missingPanel)
-    expect(defaultCategory.value).toBe(settingCategories.value[0])
-  })
-
-  it('moves floating settings into Other and hides Vue-node-only settings', () => {
-    settingsById = {
-      Floating: {
-        id: 'Floating',
-        name: 'Floating',
-        type: 'boolean',
-        defaultValue: false
-      },
-      'Hidden.Setting': {
-        id: 'Hidden.Setting',
-        name: 'Hidden',
-        type: 'hidden',
-        defaultValue: false
-      },
-      'Vue.Hidden': {
-        id: 'Vue.Hidden',
-        name: 'Vue Hidden',
-        type: 'boolean',
-        defaultValue: false,
-        hideInVueNodes: true
-      }
-    }
-    vi.mocked(useSettingStore).mockReturnValue({
-      settingsById
-    } as ReturnType<typeof useSettingStore>)
-    vueFlags.shouldRenderVueNodes.value = true
-
-    const { settingCategories } = useSettingUI()
-
-    expect(settingCategories.value.map((category) => category.label)).toEqual([
-      'Other'
-    ])
-    expect(
-      settingCategories.value[0].children?.map((node) => node.key)
-    ).toEqual(['root/Floating'])
-  })
-
-  it('adds gated cloud, desktop, workspace, and secrets panels', () => {
-    auth.isLoggedIn.value = true
-    billing.isActiveSubscription.value = true
-    dist.isCloud = true
-    dist.isDesktop = true
-    featureFlags.teamWorkspacesEnabled = true
-    featureFlags.userSecretsEnabled = true
-    Object.assign(window, { __CONFIG__: { subscription_required: true } })
-
-    const { findCategoryByKey, findPanelByKey, navGroups, panels } =
-      useSettingUI()
-
-    expect(panels.value.map((panel) => panel.node.key)).toEqual([
-      'about',
-      'credits',
-      'user',
-      'workspace',
-      'keybinding',
-      'extension',
-      'server-config',
-      'subscription',
-      'secrets'
-    ])
-    expect(navGroups.value.map((group) => group.title)).toEqual([
-      'Workspace',
-      'General'
-    ])
-    expect(findCategoryByKey('secrets')?.key).toBe('secrets')
-    expect(findCategoryByKey('missing')).toBeNull()
-    expect(findPanelByKey('subscription')?.node.key).toBe('subscription')
-    expect(findPanelByKey('missing')).toBeNull()
-  })
 })

src/platform/workflow/management/stores/workflowLists.test.ts

@@ -1,81 +0,0 @@
-import { createPinia, setActivePinia } from 'pinia'
-import { beforeEach, describe, expect, it, vi } from 'vitest'
-
-import type { ComfyWorkflow } from '@/platform/workflow/management/stores/workflowStore'
-import { useWorkflowStore } from '@/platform/workflow/management/stores/workflowStore'
-
-vi.mock('@/scripts/app', () => ({ app: {} }))
-
-vi.mock('@/scripts/api', () => ({
-  api: {
-    addEventListener: () => {},
-    getUserData: async () => ({ status: 404 }),
-    storeUserData: async () => {}
-  }
-}))
-
-vi.mock('@/renderer/core/thumbnail/useWorkflowThumbnail', () => ({
-  useWorkflowThumbnail: () => ({
-    moveWorkflowThumbnail: () => {},
-    clearThumbnail: () => {}
-  })
-}))
-
-vi.mock('@/platform/workflow/persistence/stores/workflowDraftStoreV2', () => ({
-  useWorkflowDraftStoreV2: () => ({
-    getDraft: () => null,
-    saveDraft: () => {},
-    deleteDraft: () => {}
-  })
-}))
-
-interface WorkflowFlags {
-  path: string
-  isPersisted?: boolean
-  isModified?: boolean
-}
-
-function wf(flags: WorkflowFlags): ComfyWorkflow {
-  return flags as unknown as ComfyWorkflow
-}
-
-function paths(workflows: ComfyWorkflow[]) {
-  return workflows.map((w) => w.path)
-}
-
-beforeEach(() => {
-  setActivePinia(createPinia())
-})
-
-describe('workflowStore workflow lists', () => {
-  it('persistedWorkflows excludes unpersisted and subgraph entries', () => {
-    const store = useWorkflowStore()
-    store.attachWorkflow(wf({ path: 'a.json', isPersisted: true }))
-    store.attachWorkflow(wf({ path: 'b.json', isPersisted: false }))
-    store.attachWorkflow(wf({ path: 'subgraphs/c.json', isPersisted: true }))
-
-    expect(paths(store.persistedWorkflows)).toEqual(['a.json'])
-  })
-
-  it('modifiedWorkflows includes only modified workflows', () => {
-    const store = useWorkflowStore()
-    store.attachWorkflow(wf({ path: 'a.json', isModified: true }))
-    store.attachWorkflow(wf({ path: 'b.json', isModified: false }))
-
-    expect(paths(store.modifiedWorkflows)).toEqual(['a.json'])
-  })
-
-  it('bookmarkedWorkflows is empty when nothing is bookmarked', () => {
-    const store = useWorkflowStore()
-    store.attachWorkflow(wf({ path: 'a.json' }))
-
-    expect(store.bookmarkedWorkflows).toEqual([])
-  })
-
-  it('openedWorkflowIndexShift returns null when no workflow is active', () => {
-    const store = useWorkflowStore()
-    store.attachWorkflow(wf({ path: 'a.json' }), 0)
-
-    expect(store.openedWorkflowIndexShift(1)).toBeNull()
-  })
-})

src/platform/workflow/management/stores/workflowNodeLocator.test.ts

@@ -1,87 +0,0 @@
-import { createPinia, setActivePinia } from 'pinia'
-import { beforeEach, describe, expect, it, vi } from 'vitest'
-
-import type { Subgraph, LGraphNode } from '@/lib/litegraph/src/litegraph'
-import { useWorkflowStore } from '@/platform/workflow/management/stores/workflowStore'
-import { createNodeLocatorId } from '@/types/nodeIdentification'
-import { toNodeId } from '@/types/nodeId'
-
-vi.mock('@/scripts/app', () => ({ app: {} }))
-
-vi.mock('@/scripts/api', () => ({
-  api: {
-    addEventListener: () => {},
-    getUserData: async () => ({ status: 404 }),
-    storeUserData: async () => {}
-  }
-}))
-
-vi.mock('@/renderer/core/thumbnail/useWorkflowThumbnail', () => ({
-  useWorkflowThumbnail: () => ({
-    moveWorkflowThumbnail: () => {},
-    clearThumbnail: () => {}
-  })
-}))
-
-vi.mock('@/platform/workflow/persistence/stores/workflowDraftStoreV2', () => ({
-  useWorkflowDraftStoreV2: () => ({
-    getDraft: () => null,
-    saveDraft: () => {},
-    deleteDraft: () => {}
-  })
-}))
-
-const SUBGRAPH_UUID = 'a1b2c3d4-e5f6-7890-abcd-ef1234567890'
-
-beforeEach(() => {
-  setActivePinia(createPinia())
-})
-
-describe('workflowStore node locator translation', () => {
-  it('treats a node as a root-graph node when no subgraph is active', () => {
-    const store = useWorkflowStore()
-    expect(store.nodeIdToNodeLocatorId(toNodeId(5))).toBe('5')
-  })
-
-  it('prefixes the locator with an explicit subgraph uuid', () => {
-    const store = useWorkflowStore()
-    const subgraph = { id: SUBGRAPH_UUID } as unknown as Subgraph
-
-    expect(store.nodeIdToNodeLocatorId(toNodeId(5), subgraph)).toBe(
-      `${SUBGRAPH_UUID}:5`
-    )
-  })
-
-  it('derives a locator from a node based on whether its graph is a subgraph', () => {
-    const store = useWorkflowStore()
-    const rootNode = { id: toNodeId(7), graph: {} } as unknown as LGraphNode
-    expect(store.nodeToNodeLocatorId(rootNode)).toBe('7')
-  })
-
-  it('extracts the local node id from a locator', () => {
-    const store = useWorkflowStore()
-    expect(
-      store.nodeLocatorIdToNodeId(
-        createNodeLocatorId(SUBGRAPH_UUID, toNodeId(5))
-      )
-    ).toBe(toNodeId(5))
-    expect(
-      store.nodeLocatorIdToNodeId(createNodeLocatorId(null, toNodeId(9)))
-    ).toBe(toNodeId(9))
-  })
-
-  it('round-trips a root node id through locator translation', () => {
-    const store = useWorkflowStore()
-    const locator = store.nodeIdToNodeLocatorId(toNodeId(42))
-    expect(store.nodeLocatorIdToNodeId(locator)).toBe(toNodeId(42))
-  })
-
-  it('maps a root locator to a single-segment execution id', () => {
-    const store = useWorkflowStore()
-    expect(
-      store.nodeLocatorIdToNodeExecutionId(
-        createNodeLocatorId(null, toNodeId(5))
-      )
-    ).toBe('5')
-  })
-})

src/platform/workflow/management/stores/workflowTabs.test.ts

@@ -1,99 +0,0 @@
-import { createPinia, setActivePinia } from 'pinia'
-import { beforeEach, describe, expect, it, vi } from 'vitest'
-
-import type { ComfyWorkflow } from '@/platform/workflow/management/stores/workflowStore'
-import { useWorkflowStore } from '@/platform/workflow/management/stores/workflowStore'
-
-vi.mock('@/scripts/app', () => ({ app: {} }))
-
-vi.mock('@/scripts/api', () => ({
-  api: {
-    addEventListener: () => {},
-    getUserData: async () => ({ status: 404 }),
-    storeUserData: async () => {}
-  }
-}))
-
-vi.mock('@/renderer/core/thumbnail/useWorkflowThumbnail', () => ({
-  useWorkflowThumbnail: () => ({
-    moveWorkflowThumbnail: () => {},
-    clearThumbnail: () => {}
-  })
-}))
-
-vi.mock('@/platform/workflow/persistence/stores/workflowDraftStoreV2', () => ({
-  useWorkflowDraftStoreV2: () => ({
-    getDraft: () => null,
-    saveDraft: () => {},
-    deleteDraft: () => {}
-  })
-}))
-
-function wf(path: string): ComfyWorkflow {
-  return { path } as unknown as ComfyWorkflow
-}
-
-beforeEach(() => {
-  setActivePinia(createPinia())
-})
-
-describe('workflowStore tab management', () => {
-  it('attaches workflows into the lookup and finds them by path', () => {
-    const store = useWorkflowStore()
-    const a = wf('a.json')
-    store.attachWorkflow(a)
-
-    // Pinia wraps stored objects in reactive proxies, so compare structurally.
-    expect(store.getWorkflowByPath('a.json')).toEqual(a)
-    expect(store.getWorkflowByPath('missing.json')).toBeNull()
-    expect(store.workflows).toContainEqual(a)
-  })
-
-  it('tracks which workflows are open', () => {
-    const store = useWorkflowStore()
-    const open = wf('open.json')
-    const closed = wf('closed.json')
-    store.attachWorkflow(open, 0)
-    store.attachWorkflow(closed)
-
-    expect(store.isOpen(open)).toBe(true)
-    expect(store.isOpen(closed)).toBe(false)
-    expect(store.openWorkflows).toEqual([open])
-  })
-
-  it('reorders open workflow tabs', () => {
-    const store = useWorkflowStore()
-    const a = wf('a.json')
-    const b = wf('b.json')
-    const c = wf('c.json')
-    store.attachWorkflow(a, 0)
-    store.attachWorkflow(b, 1)
-    store.attachWorkflow(c, 2)
-
-    store.reorderWorkflows(0, 2)
-
-    expect(store.openWorkflows).toEqual([b, c, a])
-  })
-
-  it('opens background workflows on the requested side, ignoring unknown paths', () => {
-    const store = useWorkflowStore()
-    const left = wf('left.json')
-    const mid = wf('mid.json')
-    const right = wf('right.json')
-    store.attachWorkflow(left)
-    store.attachWorkflow(mid, 0)
-    store.attachWorkflow(right)
-
-    store.openWorkflowsInBackground({
-      left: ['left.json', 'unknown.json'],
-      right: ['right.json']
-    })
-
-    expect(store.openWorkflows).toEqual([left, mid, right])
-  })
-
-  it('reports no active workflow before one is opened', () => {
-    const store = useWorkflowStore()
-    expect(store.isActive(wf('a.json'))).toBe(false)
-  })
-})

src/platform/workflow/templates/repositories/workflowTemplatesStore.test.ts

@@ -1,240 +0,0 @@
-import { createPinia, setActivePinia } from 'pinia'
-import { beforeEach, describe, expect, it, vi } from 'vitest'
-
-import { useWorkflowTemplatesStore } from '@/platform/workflow/templates/repositories/workflowTemplatesStore'
-import type { WorkflowTemplates } from '@/platform/workflow/templates/types/template'
-import type { NavGroupData, NavItemData } from '@/types/navTypes'
-
-const { coreByLocale, coreResult, customResult, dist, locale } = vi.hoisted(
-  () => ({
-    coreByLocale: { value: {} as Record<string, unknown[]> },
-    coreResult: { value: [] as unknown[] },
-    customResult: { value: {} as Record<string, string[]> },
-    dist: { isCloud: false },
-    locale: { value: 'en' }
-  })
-)
-
-const baseTemplate = {
-  name: 'default',
-  title: 'Default',
-  description: 'A basic template',
-  mediaType: 'image',
-  mediaSubtype: 'webp'
-}
-
-vi.mock('@/scripts/api', () => ({
-  api: {
-    getWorkflowTemplates: async () => customResult.value,
-    getCoreWorkflowTemplates: async (locale: string) =>
-      coreByLocale.value[locale] ?? coreResult.value,
-    fileURL: (p: string) => p
-  }
-}))
-
-vi.mock('@/i18n', () => ({
-  i18n: { global: { locale } },
-  st: (_key: string, fallback: string) => fallback
-}))
-
-vi.mock('@/platform/distribution/types', () => ({
-  get isCloud() {
-    return dist.isCloud
-  }
-}))
-
-function coreCategory(
-  overrides: Partial<WorkflowTemplates> = {}
-): WorkflowTemplates {
-  return {
-    moduleName: 'default',
-    title: 'Basics',
-    type: 'image',
-    templates: [baseTemplate],
-    ...overrides
-  }
-}
-
-function navItems(items: (NavItemData | NavGroupData)[]) {
-  return items.flatMap((item) => ('items' in item ? item.items : [item]))
-}
-
-beforeEach(() => {
-  setActivePinia(createPinia())
-  coreByLocale.value = {}
-  coreResult.value = [coreCategory()]
-  customResult.value = {}
-  dist.isCloud = false
-  locale.value = 'en'
-  vi.stubGlobal(
-    'fetch',
-    vi.fn(
-      async () => new Response('', { headers: { 'content-type': 'text/html' } })
-    )
-  )
-})
-
-describe('workflowTemplatesStore', () => {
-  it('loads core templates and indexes their names', async () => {
-    const store = useWorkflowTemplatesStore()
-    expect(store.isLoaded).toBe(false)
-
-    await store.loadWorkflowTemplates()
-
-    expect(store.isLoaded).toBe(true)
-    expect(store.knownTemplateNames.has('default')).toBe(true)
-    expect(store.getTemplateByName('default')?.name).toBe('default')
-    expect(store.getTemplateByName('missing')).toBeUndefined()
-  })
-
-  it('exposes grouped templates with localized titles', async () => {
-    const store = useWorkflowTemplatesStore()
-    await store.loadWorkflowTemplates()
-
-    expect(store.groupedTemplates.length).toBeGreaterThan(0)
-    const allNames = store.groupedTemplates.flatMap((g) =>
-      (g.modules ?? []).flatMap((m) => (m.templates ?? []).map((t) => t.name))
-    )
-    expect(allNames).toContain('default')
-  })
-
-  it('filters nav categories from loaded template metadata', async () => {
-    coreResult.value = [
-      coreCategory({
-        title: 'Getting Started',
-        isEssential: true,
-        templates: [{ ...baseTemplate, name: 'starter', title: 'Starter' }]
-      }),
-      coreCategory({
-        title: 'Image Tools',
-        category: 'GENERATION TYPE',
-        templates: [
-          {
-            ...baseTemplate,
-            name: 'partner-upscale',
-            title: 'Partner Upscale',
-            openSource: false
-          },
-          {
-            ...baseTemplate,
-            name: 'local-only',
-            requiresCustomNodes: ['custom-node']
-          }
-        ]
-      })
-    ]
-    customResult.value = { CustomPack: ['custom-flow'] }
-    const store = useWorkflowTemplatesStore()
-
-    await store.loadWorkflowTemplates()
-
-    const allItems = navItems(store.navGroupedTemplates)
-    const basicsId = allItems.find(
-      (item) => item.label === 'Getting Started'
-    )?.id
-    const categoryId = allItems.find((item) => item.label === 'Image Tools')?.id
-
-    expect(store.filterTemplatesByCategory('all').map((t) => t.name)).toEqual([
-      'starter',
-      'partner-upscale',
-      'custom-flow'
-    ])
-    expect(
-      store.filterTemplatesByCategory('popular').map((t) => t.name)
-    ).toEqual(['starter', 'partner-upscale', 'custom-flow'])
-    expect(
-      store.filterTemplatesByCategory(basicsId ?? '').map((t) => t.name)
-    ).toEqual(['starter'])
-    expect(
-      store.filterTemplatesByCategory(categoryId ?? '').map((t) => t.name)
-    ).toEqual(['partner-upscale'])
-    expect(
-      store.filterTemplatesByCategory('partner-nodes').map((t) => t.name)
-    ).toEqual(['partner-upscale'])
-    expect(
-      store.filterTemplatesByCategory('extension-CustomPack').map((t) => t.name)
-    ).toEqual(['custom-flow'])
-    expect(
-      store.filterTemplatesByCategory('unknown').map((t) => t.name)
-    ).toEqual(['starter', 'partner-upscale', 'custom-flow'])
-  })
-
-  it('loads logo indexes and rejects unsafe logo paths', async () => {
-    vi.mocked(fetch).mockResolvedValueOnce(
-      new Response(
-        JSON.stringify({
-          valid: 'logos/valid.svg',
-          missingExtension: 'logos/valid',
-          parent: '../secret.svg',
-          rooted: '/logos/rooted.svg'
-        }),
-        { headers: { 'content-type': 'application/json' } }
-      )
-    )
-    const store = useWorkflowTemplatesStore()
-
-    await store.loadWorkflowTemplates()
-
-    expect(store.getLogoUrl('valid')).toBe('/templates/logos/valid.svg')
-    expect(store.getLogoUrl('missing')).toBe('')
-    expect(store.getLogoUrl('missingExtension')).toBe('')
-    expect(store.getLogoUrl('parent')).toBe('')
-    expect(store.getLogoUrl('rooted')).toBe('')
-  })
-
-  it('returns english metadata when cloud loads a non-english locale', async () => {
-    dist.isCloud = true
-    locale.value = 'fr'
-    coreByLocale.value = {
-      fr: [
-        coreCategory({
-          templates: [{ ...baseTemplate, name: 'localized', title: 'Localise' }]
-        })
-      ],
-      en: [
-        coreCategory({
-          title: 'English Category',
-          templates: [
-            {
-              ...baseTemplate,
-              name: 'localized',
-              tags: ['tag'],
-              useCase: 'test',
-              models: ['model'],
-              license: 'MIT'
-            }
-          ]
-        })
-      ]
-    }
-    const store = useWorkflowTemplatesStore()
-
-    await store.loadWorkflowTemplates()
-
-    expect(store.getEnglishMetadata('localized')).toEqual({
-      tags: ['tag'],
-      category: 'English Category',
-      useCase: 'test',
-      models: ['model'],
-      license: 'MIT'
-    })
-    expect(store.getEnglishMetadata('missing')).toBeNull()
-  })
-
-  it('does not refetch once loaded', async () => {
-    const store = useWorkflowTemplatesStore()
-    await store.loadWorkflowTemplates()
-
-    coreResult.value = []
-    await store.loadWorkflowTemplates()
-
-    expect(store.knownTemplateNames.has('default')).toBe(true)
-  })
-
-  it('returns null english metadata when no english templates are loaded', async () => {
-    const store = useWorkflowTemplatesStore()
-    await store.loadWorkflowTemplates()
-
-    expect(store.getEnglishMetadata('default')).toBeNull()
-  })
-})

src/renderer/extensions/vueNodes/composables/usePartitionedBadges.test.ts

@@ -1,225 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from 'vitest'
-
-import type { VueNodeData } from '@/composables/graph/useGraphNodeManager'
-import { LGraphBadge } from '@/lib/litegraph/src/litegraph'
-import type { INodeInputSlot } from '@/lib/litegraph/src/interfaces'
-import {
-  trackNodePrice,
-  usePartitionedBadges
-} from '@/renderer/extensions/vueNodes/composables/usePartitionedBadges'
-import { toNodeId } from '@/types/nodeId'
-import { NodeBadgeMode } from '@/types/nodeSource'
-
-const { settings, nodeDefs, pricing, getNodeRevisionRefMock, getWidgetMock } =
-  vi.hoisted(() => ({
-    settings: {} as Record<string, unknown>,
-    nodeDefs: {} as Record<string, unknown>,
-    pricing: {
-      dynamic: false,
-      widgets: [] as string[],
-      inputs: [] as string[],
-      groups: [] as string[]
-    },
-    getNodeRevisionRefMock: vi.fn(() => ({ value: 0 })),
-    getWidgetMock: vi.fn(() => ({ value: 'widget-value' }))
-  }))
-
-vi.mock('@/scripts/app', () => ({
-  app: {
-    canvas: { graph: { getNodeById: () => null, rootGraph: { id: 'g1' } } }
-  }
-}))
-
-vi.mock('@/composables/node/useNodePricing', () => ({
-  useNodePricing: () => ({
-    getRelevantWidgetNames: () => pricing.widgets,
-    hasDynamicPricing: () => pricing.dynamic,
-    getInputGroupPrefixes: () => pricing.groups,
-    getInputNames: () => pricing.inputs,
-    getNodeRevisionRef: getNodeRevisionRefMock
-  })
-}))
-
-vi.mock('@/composables/node/usePriceBadge', () => ({
-  usePriceBadge: () => ({
-    isCreditsBadge: (b: { text?: string }) => b.text?.startsWith('$') ?? false
-  })
-}))
-
-vi.mock('@/platform/settings/settingStore', () => ({
-  useSettingStore: () => ({ get: (key: string) => settings[key] })
-}))
-
-vi.mock('@/stores/nodeDefStore', () => ({
-  useNodeDefStore: () => ({ nodeDefsByName: nodeDefs })
-}))
-
-vi.mock('@/stores/widgetValueStore', () => ({
-  useWidgetValueStore: () => ({ getWidget: getWidgetMock })
-}))
-
-function nodeData(overrides: Partial<VueNodeData> = {}): VueNodeData {
-  return {
-    executing: false,
-    id: toNodeId(1),
-    mode: 0,
-    selected: false,
-    title: 'Test node',
-    type: 'TestNode',
-    apiNode: false,
-    badges: [],
-    inputs: [],
-    ...overrides
-  } satisfies VueNodeData
-}
-
-function inputSlot(
-  name: string,
-  readLink: () => number | null
-): INodeInputSlot {
-  return {
-    name,
-    type: '*',
-    boundingRect: [0, 0, 0, 0],
-    get link() {
-      return readLink()
-    },
-    set link(_value: number | null) {}
-  } as INodeInputSlot
-}
-
-function badge(text: string): LGraphBadge {
-  return new LGraphBadge({ text })
-}
-
-beforeEach(() => {
-  settings['Comfy.NodeBadge.NodeSourceBadgeMode'] = NodeBadgeMode.None
-  settings['Comfy.NodeBadge.NodeLifeCycleBadgeMode'] = NodeBadgeMode.None
-  settings['Comfy.NodeBadge.NodeIdBadgeMode'] = NodeBadgeMode.None
-  for (const k of Object.keys(nodeDefs)) delete nodeDefs[k]
-  nodeDefs['TestNode'] = { isCoreNode: false }
-  pricing.dynamic = false
-  pricing.widgets = []
-  pricing.inputs = []
-  pricing.groups = []
-  getNodeRevisionRefMock.mockClear()
-  getWidgetMock.mockClear()
-})
-
-describe('usePartitionedBadges', () => {
-  it('emits no core badges when every badge mode is None', () => {
-    const result = usePartitionedBadges(nodeData()).value
-    expect(result.core).toEqual([])
-  })
-
-  it('tracks dynamic-pricing dependencies for an api node without throwing', () => {
-    pricing.dynamic = true
-    pricing.widgets = ['seed']
-    pricing.inputs = ['model']
-    pricing.groups = ['lora']
-    const result = usePartitionedBadges(
-      nodeData({
-        apiNode: true,
-        inputs: [
-          inputSlot('model', () => 1),
-          inputSlot('lora.0', () => 2),
-          inputSlot('unrelated', () => null)
-        ]
-      })
-    ).value
-
-    expect(result).toHaveProperty('core')
-    expect(result).toHaveProperty('extension')
-  })
-
-  it('adds an id badge when the id mode is enabled', () => {
-    settings['Comfy.NodeBadge.NodeIdBadgeMode'] = NodeBadgeMode.ShowAll
-    const result = usePartitionedBadges(nodeData({ id: toNodeId(7) })).value
-    expect(result.core).toContainEqual({ text: '#7' })
-  })
-
-  it('adds a lifecycle badge, trimmed of brackets', () => {
-    settings['Comfy.NodeBadge.NodeLifeCycleBadgeMode'] = NodeBadgeMode.ShowAll
-    nodeDefs['TestNode'] = {
-      isCoreNode: false,
-      nodeLifeCycleBadgeText: '[BETA]'
-    }
-    const result = usePartitionedBadges(nodeData()).value
-    expect(result.core).toContainEqual({ text: 'BETA' })
-  })
-
-  it('adds a source badge for non-core nodes when source mode is on', () => {
-    settings['Comfy.NodeBadge.NodeSourceBadgeMode'] = NodeBadgeMode.ShowAll
-    nodeDefs['TestNode'] = {
-      isCoreNode: false,
-      nodeSource: { badgeText: 'my-pack' }
-    }
-    const result = usePartitionedBadges(nodeData()).value
-    expect(result.core).toContainEqual({ text: 'my-pack' })
-  })
-
-  it('partitions extension badges (skipping the first) from credits badges', () => {
-    const result = usePartitionedBadges(
-      nodeData({
-        badges: [badge('skipped'), badge('ext-badge'), badge('$5 per run')]
-      })
-    ).value
-
-    expect(result.extension.map((badge) => badge.text)).toEqual(['ext-badge'])
-    expect(result.pricing).toEqual([{ required: '$5', rest: 'per run' }])
-  })
-
-  it('flags hasComfyBadge for a core node with source ShowAll and no pricing', () => {
-    settings['Comfy.NodeBadge.NodeSourceBadgeMode'] = NodeBadgeMode.ShowAll
-    nodeDefs['TestNode'] = { isCoreNode: true }
-    const result = usePartitionedBadges(
-      nodeData({ badges: [badge('x')] })
-    ).value
-    expect(result.hasComfyBadge).toBe(true)
-  })
-})
-
-describe('trackNodePrice', () => {
-  it('no-ops for a node without dynamic pricing', () => {
-    pricing.dynamic = false
-    trackNodePrice({ id: '1', type: 'Static', inputs: [] })
-
-    expect(getNodeRevisionRefMock).toHaveBeenCalledWith(toNodeId('1'))
-    expect(getWidgetMock).not.toHaveBeenCalled()
-  })
-
-  it('touches widget, input, and input-group pricing dependencies', () => {
-    pricing.dynamic = true
-    pricing.widgets = ['seed']
-    pricing.inputs = ['model']
-    pricing.groups = ['lora']
-    let modelReads = 0
-    let groupReads = 0
-    let unrelatedReads = 0
-
-    trackNodePrice({
-      id: '2',
-      type: 'Dynamic',
-      inputs: [
-        inputSlot('model', () => {
-          modelReads += 1
-          return 1
-        }),
-        inputSlot('lora.0', () => {
-          groupReads += 1
-          return 2
-        }),
-        inputSlot('unrelated', () => {
-          unrelatedReads += 1
-          return null
-        })
-      ]
-    })
-
-    expect(getNodeRevisionRefMock).toHaveBeenCalledWith(toNodeId('2'))
-    expect(getWidgetMock).toHaveBeenCalled()
-    expect(modelReads).toBe(1)
-    expect(groupReads).toBe(1)
-    expect(unrelatedReads).toBe(0)
-  })
-})

src/scripts/metadata/parser.test.ts

@@ -1,127 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from 'vitest'
-
-import { getFromWebmFile } from '@/scripts/metadata/ebml'
-import { getGltfBinaryMetadata } from '@/scripts/metadata/gltf'
-import { getFromIsobmffFile } from '@/scripts/metadata/isobmff'
-import { getDataFromJSON } from '@/scripts/metadata/json'
-import { getMp3Metadata } from '@/scripts/metadata/mp3'
-import { getOggMetadata } from '@/scripts/metadata/ogg'
-import { getWorkflowDataFromFile } from '@/scripts/metadata/parser'
-import { getSvgMetadata } from '@/scripts/metadata/svg'
-import {
-  getAvifMetadata,
-  getFlacMetadata,
-  getLatentMetadata,
-  getPngMetadata,
-  getWebpMetadata
-} from '@/scripts/pnginfo'
-
-vi.mock('@/scripts/metadata/ebml', () => ({ getFromWebmFile: vi.fn() }))
-vi.mock('@/scripts/metadata/gltf', () => ({ getGltfBinaryMetadata: vi.fn() }))
-vi.mock('@/scripts/metadata/isobmff', () => ({ getFromIsobmffFile: vi.fn() }))
-vi.mock('@/scripts/metadata/json', () => ({ getDataFromJSON: vi.fn() }))
-vi.mock('@/scripts/metadata/mp3', () => ({ getMp3Metadata: vi.fn() }))
-vi.mock('@/scripts/metadata/ogg', () => ({ getOggMetadata: vi.fn() }))
-vi.mock('@/scripts/metadata/svg', () => ({ getSvgMetadata: vi.fn() }))
-vi.mock('@/scripts/pnginfo', () => ({
-  getAvifMetadata: vi.fn(),
-  getFlacMetadata: vi.fn(),
-  getLatentMetadata: vi.fn(),
-  getPngMetadata: vi.fn(),
-  getWebpMetadata: vi.fn()
-}))
-
-function file(type: string, name = 'file') {
-  return new File(['data'], name, { type })
-}
-
-beforeEach(() => {
-  vi.clearAllMocks()
-})
-
-describe('getWorkflowDataFromFile', () => {
-  it('routes png/avif/mp3/ogg/webm to their parsers and returns the result', async () => {
-    vi.mocked(getPngMetadata).mockResolvedValue({ a: 1 } as never)
-    expect(await getWorkflowDataFromFile(file('image/png'))).toEqual({ a: 1 })
-    expect(getPngMetadata).toHaveBeenCalled()
-
-    await getWorkflowDataFromFile(file('image/avif'))
-    expect(getAvifMetadata).toHaveBeenCalled()
-
-    await getWorkflowDataFromFile(file('audio/mpeg'))
-    expect(getMp3Metadata).toHaveBeenCalled()
-
-    await getWorkflowDataFromFile(file('audio/ogg'))
-    expect(getOggMetadata).toHaveBeenCalled()
-
-    await getWorkflowDataFromFile(file('video/webm'))
-    expect(getFromWebmFile).toHaveBeenCalled()
-  })
-
-  it('extracts workflow/prompt from webp, preferring lowercase keys', async () => {
-    vi.mocked(getWebpMetadata).mockResolvedValue({
-      workflow: 'wf',
-      prompt: 'pr'
-    } as never)
-    expect(await getWorkflowDataFromFile(file('image/webp'))).toEqual({
-      workflow: 'wf',
-      prompt: 'pr'
-    })
-  })
-
-  it('falls back to capitalized webp keys when lowercase are absent', async () => {
-    vi.mocked(getWebpMetadata).mockResolvedValue({
-      Workflow: 'WF',
-      Prompt: 'PR'
-    } as never)
-    expect(await getWorkflowDataFromFile(file('image/webp'))).toEqual({
-      workflow: 'WF',
-      prompt: 'PR'
-    })
-  })
-
-  it('handles both flac mime types and extracts workflow/prompt', async () => {
-    vi.mocked(getFlacMetadata).mockResolvedValue({ workflow: 'w' } as never)
-    expect(await getWorkflowDataFromFile(file('audio/flac'))).toEqual({
-      workflow: 'w',
-      prompt: undefined
-    })
-    expect(await getWorkflowDataFromFile(file('audio/x-flac'))).toEqual({
-      workflow: 'w',
-      prompt: undefined
-    })
-  })
-
-  it('routes isobmff by mime type and by file extension', async () => {
-    await getWorkflowDataFromFile(file('video/mp4'))
-    await getWorkflowDataFromFile(file('', 'clip.mov'))
-    await getWorkflowDataFromFile(file('', 'clip.m4v'))
-    expect(getFromIsobmffFile).toHaveBeenCalledTimes(3)
-  })
-
-  it('routes svg and gltf by mime type or extension', async () => {
-    await getWorkflowDataFromFile(file('image/svg+xml'))
-    await getWorkflowDataFromFile(file('', 'icon.svg'))
-    expect(getSvgMetadata).toHaveBeenCalledTimes(2)
-
-    await getWorkflowDataFromFile(file('model/gltf-binary'))
-    await getWorkflowDataFromFile(file('', 'model.glb'))
-    expect(getGltfBinaryMetadata).toHaveBeenCalledTimes(2)
-  })
-
-  it('routes latent/safetensors and json by extension or mime type', async () => {
-    await getWorkflowDataFromFile(file('', 'x.latent'))
-    await getWorkflowDataFromFile(file('', 'x.safetensors'))
-    expect(getLatentMetadata).toHaveBeenCalledTimes(2)
-
-    await getWorkflowDataFromFile(file('application/json'))
-    await getWorkflowDataFromFile(file('', 'x.json'))
-    expect(getDataFromJSON).toHaveBeenCalledTimes(2)
-  })
-
-  it('returns undefined for an unrecognized file', async () => {
-    expect(
-      await getWorkflowDataFromFile(file('application/zip', 'a.zip'))
-    ).toBe(undefined)
-  })
-})

src/stores/aboutPanelStore.test.ts

@@ -1,135 +0,0 @@
-import { createPinia, setActivePinia } from 'pinia'
-import { beforeEach, describe, expect, it, vi } from 'vitest'
-
-import type { AboutPageBadge } from '@/types/comfy'
-import { useAboutPanelStore } from '@/stores/aboutPanelStore'
-
-interface SystemInfo {
-  comfyui_version?: string
-  installed_templates_version?: string
-  required_templates_version?: string
-}
-
-const { dist, stats, exts } = vi.hoisted(() => ({
-  dist: { isCloud: false, isDesktop: false },
-  stats: { system: {} as SystemInfo },
-  exts: { list: [] as { aboutPageBadges?: AboutPageBadge[] }[] }
-}))
-
-vi.mock('@/platform/distribution/types', () => ({
-  get isCloud() {
-    return dist.isCloud
-  },
-  get isDesktop() {
-    return dist.isDesktop
-  }
-}))
-
-vi.mock('@/composables/useExternalLink', () => ({
-  useExternalLink: () => ({
-    staticUrls: {
-      github: 'https://github.com/comfyanonymous/ComfyUI',
-      githubFrontend: 'https://github.com/Comfy-Org/ComfyUI_frontend',
-      comfyOrg: 'https://comfy.org',
-      discord: 'https://discord.com'
-    }
-  })
-}))
-
-vi.mock('@/utils/envUtil', () => ({
-  electronAPI: () => ({ getComfyUIVersion: () => '9.9.9' })
-}))
-
-vi.mock('@/stores/extensionStore', () => ({
-  useExtensionStore: () => ({ extensions: exts.list })
-}))
-
-vi.mock('@/stores/systemStatsStore', () => ({
-  useSystemStatsStore: () => ({ systemStats: stats })
-}))
-
-function label(badges: AboutPageBadge[], includes: string) {
-  return badges.find((b) => b.label.includes(includes))
-}
-
-beforeEach(() => {
-  setActivePinia(createPinia())
-  dist.isCloud = false
-  dist.isDesktop = false
-  stats.system = {}
-  exts.list = []
-})
-
-describe('aboutPanelStore', () => {
-  it('builds the default desktop-less, non-cloud core badges', () => {
-    stats.system = { comfyui_version: 'abc1234' }
-    const store = useAboutPanelStore()
-
-    const core = label(store.badges, 'ComfyUI ')!
-    expect(core.icon).toBe('pi pi-github')
-    expect(core.url).toContain('github.com/comfyanonymous')
-    expect(label(store.badges, 'ComfyUI_frontend')).toBeDefined()
-    expect(label(store.badges, 'Discord')).toBeDefined()
-    expect(label(store.badges, 'Templates')).toBeUndefined()
-  })
-
-  it('uses cloud url and icon for the core badge when running on cloud', () => {
-    dist.isCloud = true
-    const store = useAboutPanelStore()
-
-    const core = label(store.badges, 'ComfyUI ')!
-    expect(core.icon).toBe('pi pi-cloud')
-    expect(core.url).toBe('https://comfy.org')
-  })
-
-  it('uses the electron-reported version label on desktop', () => {
-    dist.isDesktop = true
-    const store = useAboutPanelStore()
-
-    expect(label(store.badges, 'ComfyUI v9.9.9')).toBeDefined()
-  })
-
-  it('adds a danger templates badge when the installed version is outdated', () => {
-    stats.system = {
-      installed_templates_version: '1.0.0',
-      required_templates_version: '1.1.0'
-    }
-    const store = useAboutPanelStore()
-
-    const templates = label(store.badges, 'Templates v1.0.0')!
-    expect(templates.severity).toBe('danger')
-  })
-
-  it('adds a templates badge without severity when versions match', () => {
-    stats.system = {
-      installed_templates_version: '1.1.0',
-      required_templates_version: '1.1.0'
-    }
-    const store = useAboutPanelStore()
-
-    const templates = label(store.badges, 'Templates v1.1.0')!
-    expect(templates.severity).toBeUndefined()
-  })
-
-  it('does not mark templates outdated when the required version is missing', () => {
-    stats.system = {
-      installed_templates_version: '1.1.0'
-    }
-    const store = useAboutPanelStore()
-
-    const templates = label(store.badges, 'Templates v1.1.0')!
-    expect(templates.severity).toBeUndefined()
-  })
-
-  it('appends extension badges and tolerates extensions without any', () => {
-    exts.list = [
-      {
-        aboutPageBadges: [{ label: 'My Ext', url: 'https://ext', icon: 'pi' }]
-      },
-      {} // extension without aboutPageBadges -> ?? [] branch
-    ]
-    const store = useAboutPanelStore()
-
-    expect(label(store.badges, 'My Ext')).toBeDefined()
-  })
-})

src/stores/actionBarButtonStore.test.ts

@@ -1,26 +0,0 @@
-import { createTestingPinia } from '@pinia/testing'
-import { setActivePinia } from 'pinia'
-import { beforeEach, describe, expect, it, vi } from 'vitest'
-
-import { useActionBarButtonStore } from '@/stores/actionBarButtonStore'
-import { useExtensionStore } from '@/stores/extensionStore'
-
-describe('actionBarButtonStore', () => {
-  beforeEach(() => {
-    setActivePinia(createTestingPinia({ stubActions: false }))
-  })
-
-  it('collects action bar buttons from registered extensions', () => {
-    const extensionStore = useExtensionStore()
-    const onClick = vi.fn()
-    extensionStore.registerExtension({
-      name: 'buttons',
-      actionBarButtons: [{ icon: 'icon-[lucide--plus]', onClick }]
-    })
-    extensionStore.registerExtension({ name: 'plain' })
-
-    const store = useActionBarButtonStore()
-
-    expect(store.buttons).toEqual([{ icon: 'icon-[lucide--plus]', onClick }])
-  })
-})

src/stores/apiKeyAuthStore.test.ts

@@ -1,133 +0,0 @@
-import { createTestingPinia } from '@pinia/testing'
-import { setActivePinia } from 'pinia'
-import { beforeEach, describe, expect, it, vi } from 'vitest'
-
-import { useApiKeyAuthStore } from '@/stores/apiKeyAuthStore'
-
-const authStoreMock = vi.hoisted(() => ({
-  createCustomer: vi.fn()
-}))
-
-const toastStoreMock = vi.hoisted(() => ({
-  add: vi.fn()
-}))
-
-const errorHandlingMock = vi.hoisted(() => ({
-  toastErrorHandler: vi.fn(),
-  forceGenericFailure: false,
-  forceStorageFailure: false
-}))
-
-vi.mock('@/stores/authStore', () => ({
-  useAuthStore: () => authStoreMock
-}))
-
-vi.mock('@/platform/updates/common/toastStore', () => ({
-  useToastStore: () => toastStoreMock
-}))
-
-vi.mock('@/composables/useErrorHandling', () => ({
-  useErrorHandling: () => ({
-    toastErrorHandler: errorHandlingMock.toastErrorHandler,
-    wrapWithErrorHandlingAsync:
-      (
-        fn: (value?: string) => Promise<boolean>,
-        onError: (e: unknown) => void
-      ) =>
-      async (value?: string) => {
-        try {
-          if (errorHandlingMock.forceStorageFailure) {
-            throw new Error('STORAGE_FAILED')
-          }
-          if (errorHandlingMock.forceGenericFailure) {
-            throw new Error('OTHER_FAILED')
-          }
-          return await fn(value)
-        } catch (e) {
-          onError(e)
-          return false
-        }
-      }
-  })
-}))
-
-vi.mock('@/i18n', () => ({
-  t: (key: string) => key
-}))
-
-describe('apiKeyAuthStore', () => {
-  beforeEach(() => {
-    localStorage.clear()
-    setActivePinia(createTestingPinia({ stubActions: false }))
-    authStoreMock.createCustomer.mockReset()
-    toastStoreMock.add.mockClear()
-    errorHandlingMock.toastErrorHandler.mockClear()
-    errorHandlingMock.forceGenericFailure = false
-    errorHandlingMock.forceStorageFailure = false
-  })
-
-  it('stores an API key, initializes the user, and returns an auth header', async () => {
-    authStoreMock.createCustomer.mockResolvedValue({ id: 'user-1' })
-    const store = useApiKeyAuthStore()
-
-    await expect(store.storeApiKey('secret')).resolves.toBe(true)
-    await vi.waitFor(() => expect(store.currentUser).toEqual({ id: 'user-1' }))
-
-    expect(store.isAuthenticated).toBe(true)
-    expect(store.getApiKey()).toBe('secret')
-    expect(store.getAuthHeader()).toEqual({ 'X-API-KEY': 'secret' })
-    expect(toastStoreMock.add).toHaveBeenCalledWith(
-      expect.objectContaining({ severity: 'success' })
-    )
-  })
-
-  it('clears the user when the API key is cleared', async () => {
-    authStoreMock.createCustomer.mockResolvedValue({ id: 'user-1' })
-    const store = useApiKeyAuthStore()
-
-    await store.storeApiKey('secret')
-    await vi.waitFor(() => expect(store.currentUser).toEqual({ id: 'user-1' }))
-    await expect(store.clearStoredApiKey()).resolves.toBe(true)
-
-    expect(store.currentUser).toBeNull()
-    expect(store.isAuthenticated).toBe(false)
-    expect(store.getAuthHeader()).toBeNull()
-  })
-
-  it('clears an API key when no associated user is found', async () => {
-    authStoreMock.createCustomer.mockResolvedValue(undefined)
-    const store = useApiKeyAuthStore()
-
-    await expect(store.storeApiKey('orphaned-secret')).resolves.toBe(true)
-    await vi.waitFor(() => expect(store.getApiKey()).toBeNull())
-
-    expect(errorHandlingMock.toastErrorHandler).toHaveBeenCalledWith(
-      expect.objectContaining({ message: 'auth.login.noAssociatedUser' })
-    )
-  })
-
-  it('reports storage failures through the API-key toast copy', async () => {
-    errorHandlingMock.forceStorageFailure = true
-    const store = useApiKeyAuthStore()
-
-    await expect(store.storeApiKey('secret')).resolves.toBe(false)
-
-    expect(toastStoreMock.add).toHaveBeenCalledWith({
-      severity: 'error',
-      summary: 'auth.apiKey.storageFailed',
-      detail: 'auth.apiKey.storageFailedDetail'
-    })
-    expect(errorHandlingMock.toastErrorHandler).not.toHaveBeenCalled()
-  })
-
-  it('reports non-storage failures through the generic toast handler', async () => {
-    errorHandlingMock.forceGenericFailure = true
-    const store = useApiKeyAuthStore()
-
-    await expect(store.storeApiKey('secret')).resolves.toBe(false)
-
-    expect(errorHandlingMock.toastErrorHandler).toHaveBeenCalledWith(
-      expect.any(Error)
-    )
-  })
-})

src/stores/apiKeyAuthStore.ts

@@ -37,6 +37,20 @@ export const useApiKeyAuthStore = defineStore('apiKeyAuth', () => {
     currentUser.value = createCustomerResponse
   }
 
+  watch(
+    apiKey,
+    () => {
+      if (apiKey.value) {
+        // IF API key is set, initialize user
+        void initializeUserFromApiKey()
+      } else {
+        // IF API key is cleared, clear user
+        currentUser.value = null
+      }
+    },
+    { immediate: true }
+  )
+
   const reportError = (error: unknown) => {
     if (error instanceof Error && error.message === 'STORAGE_FAILED') {
       toastStore.add({
@@ -49,20 +63,6 @@ export const useApiKeyAuthStore = defineStore('apiKeyAuth', () => {
     }
   }
 
-  watch(
-    apiKey,
-    () => {
-      if (apiKey.value) {
-        // IF API key is set, initialize user
-        void initializeUserFromApiKey().catch(reportError)
-      } else {
-        // IF API key is cleared, clear user
-        currentUser.value = null
-      }
-    },
-    { immediate: true }
-  )
-
   const storeApiKey = wrapWithErrorHandlingAsync(async (newApiKey: string) => {
     apiKey.value = newApiKey
     toastStore.add({

src/stores/appModeStore.test.ts

@@ -1,7 +1,7 @@
 import { createTestingPinia } from '@pinia/testing'
 import { fromAny, fromPartial } from '@total-typescript/shoehorn'
 import { setActivePinia } from 'pinia'
-import { nextTick, reactive } from 'vue'
+import { nextTick } from 'vue'
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
 
 import type { LGraphNode } from '@/lib/litegraph/src/LGraphNode'
@@ -56,13 +56,9 @@ vi.mock('@/utils/litegraphUtil', async (importOriginal) => ({
   resolveNode: mockResolveNode
 }))
 
-const mockCanvas = vi.hoisted(() => ({
-  state: undefined as { readOnly: boolean } | undefined
-}))
-
 vi.mock('@/renderer/core/canvas/canvasStore', () => ({
   useCanvasStore: () => ({
-    getCanvas: () => ({ state: mockCanvas.state })
+    getCanvas: () => ({ read_only: false })
   })
 }))
 
@@ -166,7 +162,6 @@ describe('appModeStore', () => {
     ChangeTracker.isLoadingGraph = false
     mockResolveNode.mockReturnValue(undefined)
     mockSettings.reset()
-    mockCanvas.state = undefined
     vi.mocked(app.rootGraph).nodes = [{ id: toNodeId(1) } as LGraphNode]
     workflowStore = useWorkflowStore()
     store = useAppModeStore()
@@ -370,83 +365,6 @@ describe('appModeStore', () => {
       expect(store.selectedInputs).toEqual([[entityPrompt, 'prompt']])
     })
 
-    it('keeps canonical entity ids when the node still exists', () => {
-      const node1 = nodeWithWidgets(1, [])
-      vi.mocked(app.rootGraph).nodes = [node1]
-      vi.mocked(app.rootGraph).getNodeById = vi.fn((id) =>
-        id === toNodeId(1) ? node1 : null
-      )
-
-      store.loadSelections({
-        inputs: [[entityPrompt, 'prompt']]
-      })
-
-      expect(store.selectedInputs).toEqual([[entityPrompt, 'prompt']])
-    })
-
-    it('drops canonical entity ids when their node is gone', () => {
-      vi.mocked(app.rootGraph).nodes = []
-      vi.mocked(app.rootGraph).getNodeById = vi.fn(() => null)
-
-      store.loadSelections({
-        inputs: [[entityPrompt, 'prompt']]
-      })
-
-      expect(store.selectedInputs).toEqual([])
-    })
-
-    it('drops locator inputs when the widget does not resolve', () => {
-      const hostLocator = `${rootGraphId}:5`
-      const hostNode = fromAny<LGraphNode, unknown>({
-        id: 5,
-        isSubgraphNode: () => false,
-        widgets: [{ name: 'other' }]
-      })
-      vi.mocked(app.rootGraph).nodes = [hostNode]
-      vi.mocked(app.rootGraph).getNodeById = vi.fn((id) =>
-        id === toNodeId(5) ? hostNode : null
-      )
-
-      store.loadSelections({
-        inputs: [[hostLocator, 'prompt']]
-      })
-
-      expect(store.selectedInputs).toEqual([])
-    })
-
-    it('drops malformed legacy input ids', () => {
-      const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {})
-      vi.mocked(app.rootGraph).nodes = []
-
-      store.loadSelections({
-        inputs: [[fromAny<SerializedNodeId, unknown>(null), 'prompt']]
-      })
-
-      expect(store.selectedInputs).toEqual([])
-      expect(warnSpy).toHaveBeenCalledWith(
-        expect.stringContaining('legacy selectedInput tuple'),
-        expect.objectContaining({ storedId: null, widgetName: 'prompt' })
-      )
-      warnSpy.mockRestore()
-    })
-
-    it('drops direct node inputs when the widget is missing', () => {
-      const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {})
-      const node1 = nodeWithWidgets(1, [])
-      vi.mocked(app.rootGraph).nodes = [node1]
-      vi.mocked(app.rootGraph).getNodeById = vi.fn((id) =>
-        id === toNodeId(1) ? node1 : null
-      )
-
-      store.loadSelections({
-        inputs: [[1, 'prompt']]
-      })
-
-      expect(store.selectedInputs).toEqual([])
-      expect(warnSpy).toHaveBeenCalled()
-      warnSpy.mockRestore()
-    })
-
     it('drops legacy entries whose widget no longer exists', () => {
       const node1 = nodeWithWidgets(1, ['prompt'])
       vi.mocked(app.rootGraph).nodes = [node1]
@@ -481,32 +399,6 @@ describe('appModeStore', () => {
       expect(store.selectedOutputs).toEqual([toNodeId(1)])
     })
 
-    it('drops malformed output ids on load', () => {
-      store.loadSelections({
-        outputs: [fromAny<SerializedNodeId, unknown>('')]
-      })
-
-      expect(store.selectedOutputs).toEqual([])
-    })
-
-    it('drops legacy subgraph input slots without widget ids', () => {
-      const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {})
-      const hostNode = Object.assign(Object.create(SubgraphNode.prototype), {
-        id: 5,
-        inputs: [{ name: 'Prompt' }]
-      })
-      vi.mocked(app.rootGraph).nodes = [hostNode]
-      vi.mocked(app.rootGraph).getNodeById = vi.fn(() => null)
-
-      store.loadSelections({
-        inputs: [[1, 'prompt']]
-      })
-
-      expect(store.selectedInputs).toEqual([])
-      expect(warnSpy).toHaveBeenCalled()
-      warnSpy.mockRestore()
-    })
-
     it('reloads selections on configured event', async () => {
       const node1 = nodeWithWidgets(1, ['seed'])
 
@@ -589,7 +481,7 @@ describe('appModeStore', () => {
         expect(
           store.pruneLinearData({
             inputs: [[1, 'seed']],
-            outputs: [toNodeId(1), fromAny<SerializedNodeId, unknown>('')]
+            outputs: [toNodeId(1)]
           })
         ).toEqual({
           inputs: [[1, 'seed']],
@@ -749,17 +641,6 @@ describe('appModeStore', () => {
       expect(originalRootGraph.extra.linearData).toEqual(dataBefore)
     })
 
-    it('does not write while graph loading is in progress', async () => {
-      workflowStore.activeWorkflow = createBuilderWorkflow()
-      ChangeTracker.isLoadingGraph = true
-      await nextTick()
-
-      store.selectedOutputs.push(toNodeId(1))
-      await nextTick()
-
-      expect(app.rootGraph.extra.linearData).toBeUndefined()
-    })
-
     it('calls captureCanvasState when input is selected', async () => {
       const workflow = createBuilderWorkflow()
       workflowStore.activeWorkflow = workflow
@@ -874,24 +755,6 @@ describe('appModeStore', () => {
 
       expect(store.selectedInputs).toEqual([[promptEntity, 'prompt']])
     })
-
-    it('ignores widgets without ids', () => {
-      store.selectedInputs.push(['g:1:prompt' as WidgetId, 'prompt'])
-
-      store.removeSelectedInput(fromAny<IBaseWidget, unknown>({}))
-
-      expect(store.selectedInputs).toEqual([['g:1:prompt', 'prompt']])
-    })
-
-    it('ignores missing input ids', () => {
-      store.selectedInputs.push(['g:1:prompt' as WidgetId, 'prompt'])
-
-      store.removeSelectedInput(
-        fromAny<IBaseWidget, unknown>({ widgetId: 'g:2:prompt' })
-      )
-
-      expect(store.selectedInputs).toEqual([['g:1:prompt', 'prompt']])
-    })
   })
 
   describe('autoEnableVueNodes', () => {
@@ -956,47 +819,6 @@ describe('appModeStore', () => {
         expect.anything()
       )
     })
-
-    it('does not enable Vue nodes after leaving select mode', async () => {
-      mockSettings.store['Comfy.VueNodes.Enabled'] = false
-      workflowStore.activeWorkflow = createBuilderWorkflow('graph')
-
-      store.enterBuilder()
-      await nextTick()
-      mockSettings.set.mockClear()
-      store.exitBuilder()
-      await nextTick()
-
-      expect(mockSettings.set).not.toHaveBeenCalled()
-    })
-  })
-
-  describe('read only canvas sync', () => {
-    it('keeps canvas read-only while in select mode', async () => {
-      mockCanvas.state = reactive({ readOnly: false })
-      workflowStore.activeWorkflow = createBuilderWorkflow('graph')
-
-      store.enterBuilder()
-      await nextTick()
-      mockCanvas.state.readOnly = false
-      await nextTick()
-
-      expect(mockCanvas.state.readOnly).toBe(true)
-    })
-
-    it('stops enforcing read-only after leaving select mode', async () => {
-      mockCanvas.state = reactive({ readOnly: false })
-      workflowStore.activeWorkflow = createBuilderWorkflow('graph')
-
-      store.enterBuilder()
-      await nextTick()
-      store.exitBuilder()
-      await nextTick()
-      mockCanvas.state.readOnly = true
-      await nextTick()
-
-      expect(mockCanvas.state.readOnly).toBe(true)
-    })
   })
 
   describe('legacy selectedInput tuple migration', () => {
@@ -1085,121 +907,6 @@ describe('appModeStore', () => {
       ])
     })
 
-    it('drops direct root-node widgets that cannot produce an entity id', () => {
-      const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {})
-      const sourceNodeId = 42
-      const sourceWidgetName = 'text'
-      const rootNode = fromAny<LGraphNode, unknown>({
-        id: sourceNodeId,
-        widgets: [{ name: sourceWidgetName }]
-      })
-      vi.mocked(app.rootGraph).id = rootGraphId
-      vi.mocked(app.rootGraph).nodes = [rootNode]
-      vi.mocked(app.rootGraph).getNodeById = vi.fn(
-        (id: SerializedNodeId | null | undefined) =>
-          id == sourceNodeId ? rootNode : null
-      )
-
-      const result = store.pruneLinearData({
-        inputs: [[sourceNodeId, sourceWidgetName, { height: 120 }]],
-        outputs: []
-      })
-
-      expect(result.inputs).toEqual([])
-      expect(warnSpy).toHaveBeenCalledWith(
-        expect.stringContaining('legacy selectedInput tuple'),
-        expect.objectContaining({
-          storedId: sourceNodeId,
-          widgetName: sourceWidgetName
-        })
-      )
-      warnSpy.mockRestore()
-    })
-
-    it('drops promoted inputs whose source target no longer matches', () => {
-      const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {})
-      const subgraphInputName = 'Prompt'
-      const sourceWidgetName = 'text'
-
-      const subgraph = createTestSubgraph({
-        inputs: [{ name: subgraphInputName, type: 'STRING' }]
-      })
-      const interior = new LGraphNodeClass('Interior')
-      const interiorInput = interior.addInput(subgraphInputName, 'STRING')
-      interior.addWidget('string', sourceWidgetName, '', () => undefined)
-      interiorInput.widget = { name: sourceWidgetName }
-      subgraph.add(interior)
-      subgraph.inputNode.slots[0].connect(interiorInput, interior)
-
-      const host = createTestSubgraphNode(subgraph, { id: 5 })
-      const rootGraph = host.graph as LGraph
-      rootGraph.add(host)
-      host._internalConfigureAfterSlots()
-
-      vi.mocked(app.rootGraph).id = rootGraph.id
-      vi.mocked(app.rootGraph).nodes = rootGraph.nodes
-      vi.mocked(app.rootGraph).getNodeById = vi.fn((id) =>
-        rootGraph.getNodeById(id)
-      )
-
-      const result = store.pruneLinearData({
-        inputs: [[interior.id, 'other-widget', { height: 120 }]],
-        outputs: []
-      })
-
-      expect(result.inputs).toEqual([])
-      expect(warnSpy).toHaveBeenCalled()
-      warnSpy.mockRestore()
-    })
-
-    it('drops legacy inputs when multiple promoted inputs match', () => {
-      const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {})
-      const subgraphInputName = 'Prompt'
-      const sourceWidgetName = 'text'
-
-      const subgraph = createTestSubgraph({
-        inputs: [{ name: subgraphInputName, type: 'STRING' }]
-      })
-      const interior = new LGraphNodeClass('Interior')
-      const interiorInput = interior.addInput(subgraphInputName, 'STRING')
-      interior.addWidget('string', sourceWidgetName, '', () => undefined)
-      interiorInput.widget = { name: sourceWidgetName }
-      subgraph.add(interior)
-      subgraph.inputNode.slots[0].connect(interiorInput, interior)
-
-      const firstHost = createTestSubgraphNode(subgraph, { id: 5 })
-      const rootGraph = firstHost.graph as LGraph
-      const secondHost = createTestSubgraphNode(subgraph, {
-        id: 6,
-        parentGraph: rootGraph
-      })
-      rootGraph.add(firstHost)
-      rootGraph.add(secondHost)
-      firstHost._internalConfigureAfterSlots()
-      secondHost._internalConfigureAfterSlots()
-
-      vi.mocked(app.rootGraph).id = rootGraph.id
-      vi.mocked(app.rootGraph).nodes = rootGraph.nodes
-      vi.mocked(app.rootGraph).getNodeById = vi.fn((id) =>
-        rootGraph.getNodeById(id)
-      )
-
-      const result = store.pruneLinearData({
-        inputs: [[interior.id, sourceWidgetName, { height: 120 }]],
-        outputs: []
-      })
-
-      expect(result.inputs).toEqual([])
-      expect(warnSpy).toHaveBeenCalledWith(
-        expect.stringContaining('ambiguous legacy selectedInput tuple'),
-        expect.objectContaining({
-          storedId: interior.id,
-          widgetName: sourceWidgetName
-        })
-      )
-      warnSpy.mockRestore()
-    })
-
     it('warns and drops a tuple whose target widget no longer resolves', () => {
       const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {})
       vi.mocked(app.rootGraph).id = rootGraphId

src/stores/assetDownloadStore.test.ts

@@ -126,19 +126,6 @@ describe('useAssetDownloadStore', () => {
       })
     })
 
-    it('keeps the first placeholder when the same task is tracked twice', () => {
-      const store = useAssetDownloadStore()
-
-      store.trackDownload('task-123', 'checkpoints', 'first.safetensors')
-      store.trackDownload('task-123', 'loras', 'second.safetensors')
-
-      expect(store.downloadList).toHaveLength(1)
-      expect(store.downloadList[0]).toMatchObject({
-        modelType: 'checkpoints',
-        assetName: 'first.safetensors'
-      })
-    })
-
     it('handles out-of-order messages where completed arrives before progress', () => {
       const store = useAssetDownloadStore()
 
@@ -192,19 +179,6 @@ describe('useAssetDownloadStore', () => {
       expect(store.finishedDownloads[0].status).toBe('completed')
     })
 
-    it('skips polling when active downloads have fresh progress', async () => {
-      const store = useAssetDownloadStore()
-
-      dispatch(createDownloadMessage({ status: 'running' }))
-      await vi.advanceTimersByTimeAsync(9_999)
-      dispatch(createDownloadMessage({ status: 'running', progress: 75 }))
-      await vi.advanceTimersByTimeAsync(1)
-
-      expect(taskService.getTask).not.toHaveBeenCalled()
-      expect(store.activeDownloads).toHaveLength(1)
-      expect(store.activeDownloads[0].progress).toBe(75)
-    })
-
     it('polls and marks failed downloads', async () => {
       const store = useAssetDownloadStore()
 
@@ -337,22 +311,5 @@ describe('useAssetDownloadStore', () => {
       expect(store.sessionDownloadCount).toBe(0)
       expect(store.isDownloadedThisSession('asset-456')).toBe(false)
     })
-
-    it('does not acknowledge unrelated completed downloads', () => {
-      const store = useAssetDownloadStore()
-
-      dispatch(
-        createDownloadMessage({
-          status: 'completed',
-          progress: 100,
-          asset_id: 'asset-456'
-        })
-      )
-
-      store.acknowledgeAsset('other-asset')
-
-      expect(store.sessionDownloadCount).toBe(1)
-      expect(store.isDownloadedThisSession('asset-456')).toBe(true)
-    })
   })
 })

src/stores/assetExportStore.test.ts

@@ -1,300 +0,0 @@
-import { createPinia, setActivePinia } from 'pinia'
-import { beforeEach, describe, expect, it, vi } from 'vitest'
-
-import type * as VueUse from '@vueuse/core'
-
-import type { AssetExportWsMessage } from '@/schemas/apiSchema'
-import { api } from '@/scripts/api'
-import type { TaskId } from '@/platform/tasks/services/taskService'
-import { useAssetExportStore } from '@/stores/assetExportStore'
-
-const { getExportDownloadUrl, getTask, toastAdd, intervalState } = vi.hoisted(
-  () => ({
-    getExportDownloadUrl: vi.fn(),
-    getTask: vi.fn(),
-    toastAdd: vi.fn(),
-    intervalState: { cb: null as null | (() => void) }
-  })
-)
-
-vi.mock('@vueuse/core', async (importOriginal) => ({
-  ...(await importOriginal<typeof VueUse>()),
-  useIntervalFn: (cb: () => void) => {
-    intervalState.cb = cb
-    return { pause: vi.fn(), resume: vi.fn() }
-  }
-}))
-
-vi.mock('@/scripts/api', () => ({
-  api: { addEventListener: vi.fn() }
-}))
-
-vi.mock('@/platform/assets/services/assetService', () => ({
-  assetService: { getExportDownloadUrl }
-}))
-
-vi.mock('@/platform/tasks/services/taskService', () => ({
-  taskService: { getTask }
-}))
-
-vi.mock('@/platform/updates/common/toastStore', () => ({
-  useToastStore: () => ({ add: toastAdd })
-}))
-
-vi.mock('@/i18n', () => ({
-  t: (key: string) => key
-}))
-
-function wsMessage(
-  over: Partial<AssetExportWsMessage> = {}
-): AssetExportWsMessage {
-  return {
-    task_id: 'task-1',
-    export_name: 'export.zip',
-    assets_total: 10,
-    assets_attempted: 5,
-    assets_failed: 0,
-    bytes_total: 1000,
-    bytes_processed: 500,
-    progress: 0.5,
-    status: 'running',
-    ...over
-  }
-}
-
-const taskId = (id: string) => id as TaskId
-
-/**
- * Build a store and an `emit` bound to the real `asset_export` listener the
- * store registers on `api`, so tests drive the state machine through its
- * actual entry point rather than a private method.
- */
-function setup() {
-  const store = useAssetExportStore()
-  const entry = vi
-    .mocked(api.addEventListener)
-    .mock.calls.find((c) => c[0] === 'asset_export')
-  const handler = entry![1] as (e: { detail: AssetExportWsMessage }) => void
-  const emit = (msg: AssetExportWsMessage) => handler({ detail: msg })
-  // Run the polling tick that `useIntervalFn` would normally fire, and let its
-  // async work settle.
-  const runPoll = async () => {
-    intervalState.cb?.()
-    await new Promise((resolve) => setTimeout(resolve, 0))
-  }
-  return { store, emit, runPoll }
-}
-
-const STALE_AGO_MS = 20_000
-
-beforeEach(() => {
-  setActivePinia(createPinia())
-  vi.mocked(api.addEventListener).mockClear()
-  getExportDownloadUrl
-    .mockReset()
-    .mockResolvedValue({ url: 'https://example.com/export.zip' })
-  getTask.mockReset()
-  toastAdd.mockReset()
-})
-
-describe('assetExportStore', () => {
-  it('tracks a new export as created and is idempotent', () => {
-    const { store } = setup()
-
-    store.trackExport(taskId('t1'))
-    store.trackExport(taskId('t1'))
-
-    expect(store.exportList).toHaveLength(1)
-    expect(store.exportList[0].status).toBe('created')
-    expect(store.hasExports).toBe(true)
-    expect(store.hasActiveExports).toBe(true)
-  })
-
-  it('separates active from finished exports by status', () => {
-    const { store, emit } = setup()
-
-    emit(wsMessage({ task_id: 'running', status: 'running' }))
-    emit(
-      wsMessage({ task_id: 'failed', status: 'failed', export_name: 'f.zip' })
-    )
-
-    expect(store.activeExports.map((e) => e.taskId)).toEqual(['running'])
-    expect(store.finishedExports.map((e) => e.taskId)).toEqual(['failed'])
-  })
-
-  it('updates an export from successive websocket messages', () => {
-    const { store, emit } = setup()
-
-    emit(wsMessage({ progress: 0.5, status: 'running' }))
-    emit(wsMessage({ progress: 0.9, status: 'running' }))
-
-    expect(store.exportList).toHaveLength(1)
-    expect(store.exportList[0].progress).toBe(0.9)
-  })
-
-  it('ignores updates for an export already completed and downloaded', async () => {
-    const { store, emit } = setup()
-
-    emit(wsMessage({ status: 'completed' }))
-    await Promise.resolve()
-    const triggeredCalls = getExportDownloadUrl.mock.calls.length
-
-    // A late 'running' message must not revive a completed+downloaded export
-    emit(wsMessage({ status: 'running', progress: 0.1 }))
-
-    expect(store.exportList[0].status).toBe('completed')
-    expect(getExportDownloadUrl).toHaveBeenCalledTimes(triggeredCalls)
-  })
-
-  it('falls back to the prior export name when a message omits it', async () => {
-    const { store, emit } = setup()
-
-    emit(wsMessage({ status: 'running', progress: 0.4 }))
-    emit(
-      wsMessage({ status: 'running', export_name: undefined, progress: 0.6 })
-    )
-
-    expect(store.exportList[0].exportName).toBe('export.zip')
-  })
-
-  it('falls back to a blank export name when no message has named it', () => {
-    const { store, emit } = setup()
-
-    emit(wsMessage({ export_name: undefined, status: 'running' }))
-
-    expect(store.exportList[0].exportName).toBe('')
-  })
-
-  it('triggers a download for a named export and clears prior errors', async () => {
-    const { store, emit } = setup()
-    emit(wsMessage({ status: 'running' }))
-    const [exp] = store.exportList
-
-    await store.triggerDownload(exp)
-
-    expect(getExportDownloadUrl).toHaveBeenCalledWith('export.zip')
-    expect(exp.downloadTriggered).toBe(true)
-    expect(exp.downloadError).toBeUndefined()
-  })
-
-  it('does not re-trigger a download unless forced', async () => {
-    const { store, emit } = setup()
-    emit(wsMessage({ status: 'running' }))
-    const [exp] = store.exportList
-    exp.downloadTriggered = true
-
-    await store.triggerDownload(exp)
-    expect(getExportDownloadUrl).not.toHaveBeenCalled()
-
-    await store.triggerDownload(exp, true)
-    expect(getExportDownloadUrl).toHaveBeenCalledTimes(1)
-  })
-
-  it('records a download error and surfaces a toast on failure', async () => {
-    getExportDownloadUrl.mockRejectedValueOnce(new Error('network down'))
-    const { store, emit } = setup()
-    emit(wsMessage({ status: 'running' }))
-    const [exp] = store.exportList
-
-    await store.triggerDownload(exp)
-
-    expect(exp.downloadError).toBe('network down')
-    expect(exp.downloadTriggered).toBe(false)
-    expect(toastAdd).toHaveBeenCalledWith(
-      expect.objectContaining({ severity: 'error' })
-    )
-  })
-
-  it('records a string download error', async () => {
-    getExportDownloadUrl.mockRejectedValueOnce('offline')
-    const { store, emit } = setup()
-    emit(wsMessage({ status: 'running' }))
-    const [exp] = store.exportList
-
-    await store.triggerDownload(exp)
-
-    expect(exp.downloadError).toBe('offline')
-  })
-
-  it('clears finished exports while keeping active ones', () => {
-    const { store, emit } = setup()
-    emit(wsMessage({ task_id: 'a', status: 'running' }))
-    emit(wsMessage({ task_id: 'b', status: 'failed', export_name: 'b.zip' }))
-
-    store.clearFinishedExports()
-
-    expect(store.exportList.map((e) => e.taskId)).toEqual(['a'])
-  })
-
-  it('does not poll when no active export is stale', async () => {
-    const { emit, runPoll } = setup()
-    emit(wsMessage({ status: 'running' }))
-
-    await runPoll()
-
-    expect(getTask).not.toHaveBeenCalled()
-  })
-
-  it('reconciles a stale export from the task service result', async () => {
-    const { store, emit, runPoll } = setup()
-    emit(wsMessage({ status: 'running' }))
-    store.exportList[0].lastUpdate = Date.now() - STALE_AGO_MS
-    getTask.mockResolvedValue({
-      status: 'completed',
-      result: { export_name: 'reconciled.zip', assets_total: 10 }
-    })
-
-    await runPoll()
-
-    expect(getTask).toHaveBeenCalledWith('task-1')
-    expect(store.exportList[0].status).toBe('completed')
-    expect(store.exportList[0].exportName).toBe('reconciled.zip')
-  })
-
-  it('leaves a stale export active when the task is still running', async () => {
-    const { store, emit, runPoll } = setup()
-    emit(wsMessage({ status: 'running' }))
-    store.exportList[0].lastUpdate = Date.now() - STALE_AGO_MS
-    getTask.mockResolvedValue({ status: 'running' })
-
-    await runPoll()
-
-    expect(store.exportList[0].status).toBe('running')
-  })
-
-  it('reconciles a stale failed export using existing counters', async () => {
-    const { store, emit, runPoll } = setup()
-    emit(
-      wsMessage({
-        assets_attempted: 4,
-        assets_failed: 1,
-        status: 'running'
-      })
-    )
-    store.exportList[0].lastUpdate = Date.now() - STALE_AGO_MS
-    getTask.mockResolvedValue({
-      status: 'failed',
-      result: { error: 'failed in result' }
-    })
-
-    await runPoll()
-
-    expect(store.exportList[0]).toMatchObject({
-      assetsAttempted: 4,
-      assetsFailed: 1,
-      error: 'failed in result',
-      status: 'failed'
-    })
-  })
-
-  it('leaves a stale export untouched when the task lookup fails', async () => {
-    const { store, emit, runPoll } = setup()
-    emit(wsMessage({ status: 'running' }))
-    store.exportList[0].lastUpdate = Date.now() - STALE_AGO_MS
-    getTask.mockRejectedValue(new Error('task not found'))
-
-    await runPoll()
-
-    expect(store.exportList[0].status).toBe('running')
-  })
-})

src/stores/assetsStore.test.ts

@@ -1,5 +1,4 @@
 import { createTestingPinia } from '@pinia/testing'
-import { fromAny } from '@total-typescript/shoehorn'
 import { setActivePinia } from 'pinia'
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
 import { nextTick, watch } from 'vue'
@@ -12,7 +11,6 @@ import type {
 } from '@/platform/assets/schemas/assetSchema'
 import type { JobListItem } from '@/platform/remote/comfyui/jobs/jobTypes'
 import { assetService } from '@/platform/assets/services/assetService'
-import { useAssetDownloadStore } from '@/stores/assetDownloadStore'
 
 // Mock the api module
 vi.mock('@/scripts/api', () => ({
@@ -98,10 +96,6 @@ const mockOutputOverrides = vi.hoisted(() => ({
   value: null as MockOutput[] | null
 }))
 
-const mockAssetMapperOptions = vi.hoisted(() => ({
-  omitCreatedAtForIds: new Set<string>()
-}))
-
 // Mock TaskItemImpl
 const PREVIEWABLE_MEDIA_TYPES = new Set(['images', 'video', 'audio'])
 
@@ -175,14 +169,11 @@ vi.mock('@/platform/assets/composables/media/assetMappers', () => ({
   })),
   mapTaskOutputToAssetItem: vi.fn((task, output) => {
     const index = parseInt(task.jobId.split('_')[1]) || 0
-    const createdAt = new Date(Date.now() - index * 1000).toISOString()
     return {
       id: task.jobId,
       name: output.filename,
       size: 0,
-      ...(!mockAssetMapperOptions.omitCreatedAtForIds.has(task.jobId) && {
-        created_at: createdAt
-      }),
+      created_at: new Date(Date.now() - index * 1000).toISOString(),
       tags: ['output'],
       preview_url: output.url,
       user_metadata: {}
@@ -214,7 +205,6 @@ describe('assetsStore - Refactored (Option A)', () => {
     setActivePinia(createTestingPinia({ stubActions: false }))
     store = useAssetsStore()
     vi.clearAllMocks()
-    mockAssetMapperOptions.omitCreatedAtForIds.clear()
   })
 
   describe('Initial Load', () => {
@@ -282,17 +272,6 @@ describe('assetsStore - Refactored (Option A)', () => {
         'prompt_2'
       ])
     })
-
-    it('should skip unfinished jobs and completed jobs without previews', async () => {
-      vi.mocked(api.getHistory).mockResolvedValue([
-        { ...createMockJobItem(0), status: 'in_progress' },
-        { ...createMockJobItem(1), preview_output: undefined }
-      ])
-
-      await store.updateHistory()
-
-      expect(store.historyAssets).toEqual([])
-    })
   })
 
   describe('Pagination', () => {
@@ -349,46 +328,6 @@ describe('assetsStore - Refactored (Option A)', () => {
       expect(uniqueAssetIds.size).toBe(store.historyAssets.length)
     })
 
-    it('should insert newer paginated items in sorted order', async () => {
-      vi.mocked(api.getHistory).mockResolvedValueOnce(
-        Array.from({ length: 200 }, (_, i) => createMockJobItem(i))
-      )
-      await store.updateHistory()
-
-      vi.mocked(api.getHistory).mockResolvedValueOnce([createMockJobItem(-1)])
-      await store.loadMoreHistory()
-
-      expect(store.historyAssets[0].id).toBe('prompt_-1')
-    })
-
-    it('sorts paginated items when the incoming asset has no timestamp', async () => {
-      vi.mocked(api.getHistory).mockResolvedValueOnce(
-        Array.from({ length: 200 }, (_, i) => createMockJobItem(i))
-      )
-      await store.updateHistory()
-      mockAssetMapperOptions.omitCreatedAtForIds.add('prompt_200')
-      vi.mocked(api.getHistory).mockResolvedValueOnce([createMockJobItem(200)])
-
-      await store.loadMoreHistory()
-
-      expect(store.historyAssets.at(-1)?.id).toBe('prompt_200')
-    })
-
-    it('sorts paginated items when an existing asset has no timestamp', async () => {
-      for (let i = 0; i < 200; i++) {
-        mockAssetMapperOptions.omitCreatedAtForIds.add(`prompt_${i}`)
-      }
-      vi.mocked(api.getHistory).mockResolvedValueOnce(
-        Array.from({ length: 200 }, (_, i) => createMockJobItem(i))
-      )
-      await store.updateHistory()
-      vi.mocked(api.getHistory).mockResolvedValueOnce([createMockJobItem(-1)])
-
-      await store.loadMoreHistory()
-
-      expect(store.historyAssets[0].id).toBe('prompt_-1')
-    })
-
     it('should stop loading when no more items', async () => {
       // First batch - less than BATCH_SIZE
       const firstBatch = Array.from({ length: 50 }, (_, i) =>
@@ -555,29 +494,6 @@ describe('assetsStore - Refactored (Option A)', () => {
       expect(store.historyLoading).toBe(false)
       expect(store.historyError).toBe(error)
     })
-
-    it('should preserve existing history when refresh fails', async () => {
-      vi.mocked(api.getHistory).mockResolvedValueOnce([createMockJobItem(0)])
-      await store.updateHistory()
-
-      const error = new Error('API error')
-      vi.mocked(api.getHistory).mockRejectedValueOnce(error)
-
-      await store.updateHistory()
-
-      expect(store.historyAssets).toHaveLength(1)
-      expect(store.historyError).toBe(error)
-    })
-
-    it('should keep empty history when loadMore fails before any load', async () => {
-      const error = new Error('API error')
-      vi.mocked(api.getHistory).mockRejectedValueOnce(error)
-
-      await store.loadMoreHistory()
-
-      expect(store.historyAssets).toEqual([])
-      expect(store.historyError).toBe(error)
-    })
   })
 
   describe('Memory Management', () => {
@@ -1008,43 +924,6 @@ describe('assetsStore - Model Assets Cache (Cloud)', () => {
         vi.mocked(assetService.getAssetsForNodeType)
       ).toHaveBeenCalledTimes(2)
     })
-
-    it('ignores a model response after the category is invalidated', async () => {
-      const store = useAssetsStore()
-      let resolveFetch!: (assets: AssetItem[]) => void
-      vi.mocked(assetService.getAssetsForNodeType).mockReturnValueOnce(
-        new Promise((resolve) => {
-          resolveFetch = resolve
-        })
-      )
-
-      const request = store.updateModelsForNodeType('CheckpointLoaderSimple')
-      store.invalidateCategory('checkpoints')
-      resolveFetch([createMockAsset('stale-response')])
-      await request
-
-      expect(store.getAssets('CheckpointLoaderSimple')).toEqual([])
-    })
-
-    it('ignores a model rejection after the category is invalidated', async () => {
-      const store = useAssetsStore()
-      const consoleSpy = vi.spyOn(console, 'error').mockImplementation(() => {})
-      let rejectFetch!: (error: Error) => void
-      vi.mocked(assetService.getAssetsForNodeType).mockReturnValueOnce(
-        new Promise((_resolve, reject) => {
-          rejectFetch = reject
-        })
-      )
-
-      const request = store.updateModelsForNodeType('CheckpointLoaderSimple')
-      store.invalidateCategory('checkpoints')
-      rejectFetch(new Error('stale rejection'))
-      await request
-
-      expect(store.getError('CheckpointLoaderSimple')).toBeUndefined()
-      expect(consoleSpy).not.toHaveBeenCalled()
-      consoleSpy.mockRestore()
-    })
   })
 
   describe('shallowReactive state reactivity', () => {
@@ -1087,10 +966,6 @@ describe('assetsStore - Model Assets Cache (Cloud)', () => {
     it('should return empty array for unknown node types', () => {
       const store = useAssetsStore()
       expect(store.getAssets('UnknownNodeType')).toEqual([])
-      expect(store.isModelLoading('UnknownNodeType')).toBe(false)
-      expect(store.getError('UnknownNodeType')).toBeUndefined()
-      expect(store.hasMore('UnknownNodeType')).toBe(false)
-      expect(store.hasAssetKey('UnknownNodeType')).toBe(false)
     })
 
     it('should not fetch for unknown node types', async () => {
@@ -1100,63 +975,6 @@ describe('assetsStore - Model Assets Cache (Cloud)', () => {
         vi.mocked(assetService.getAssetsForNodeType)
       ).not.toHaveBeenCalled()
     })
-
-    it('should refresh an already loaded category', async () => {
-      const store = useAssetsStore()
-      const nodeType = 'CheckpointLoaderSimple'
-
-      vi.mocked(assetService.getAssetsForNodeType).mockResolvedValueOnce([
-        createMockAsset('first')
-      ])
-      await store.updateModelsForNodeType(nodeType)
-
-      vi.mocked(assetService.getAssetsForNodeType).mockResolvedValueOnce([
-        createMockAsset('second')
-      ])
-      await store.updateModelsForNodeType(nodeType)
-
-      expect(store.getAssets(nodeType).map((asset) => asset.id)).toEqual([
-        'second'
-      ])
-    })
-
-    it('reports hasMore for a loaded category', async () => {
-      const store = useAssetsStore()
-      const nodeType = 'CheckpointLoaderSimple'
-
-      expect(store.hasMore(nodeType)).toBe(false)
-      vi.mocked(assetService.getAssetsForNodeType).mockResolvedValueOnce([
-        createMockAsset('only-page')
-      ])
-
-      await store.updateModelsForNodeType(nodeType)
-
-      expect(store.hasMore(nodeType)).toBe(false)
-    })
-
-    it('should record model loading errors', async () => {
-      const store = useAssetsStore()
-      const error = new Error('model fetch failed')
-      const consoleSpy = vi.spyOn(console, 'error').mockImplementation(() => {})
-      vi.mocked(assetService.getAssetsForNodeType).mockRejectedValueOnce(error)
-
-      await store.updateModelsForNodeType('CheckpointLoaderSimple')
-
-      expect(store.getError('CheckpointLoaderSimple')).toBe(error)
-      expect(store.isModelLoading('CheckpointLoaderSimple')).toBe(false)
-      consoleSpy.mockRestore()
-    })
-
-    it('should wrap non-error model loading failures', async () => {
-      const store = useAssetsStore()
-      const consoleSpy = vi.spyOn(console, 'error').mockImplementation(() => {})
-      vi.mocked(assetService.getAssetsForNodeType).mockRejectedValueOnce('boom')
-
-      await store.updateModelsForNodeType('CheckpointLoaderSimple')
-
-      expect(store.getError('CheckpointLoaderSimple')?.message).toBe('boom')
-      consoleSpy.mockRestore()
-    })
   })
 
   describe('invalidateCategory', () => {
@@ -1311,140 +1129,7 @@ describe('assetsStore - Model Assets Cache (Cloud)', () => {
     })
   })
 
-  describe('completed download refresh', () => {
-    it('refreshes provider and tag caches for the completed model type', async () => {
-      const store = useAssetsStore()
-      const downloadStore = useAssetDownloadStore()
-      vi.mocked(assetService.getAssetsForNodeType).mockResolvedValue([])
-      vi.mocked(assetService.getAssetsByTag).mockResolvedValue([])
-
-      downloadStore.lastCompletedDownload = {
-        taskId: 'task-1',
-        modelType: 'checkpoints',
-        timestamp: 1
-      }
-
-      await vi.waitFor(() =>
-        expect(assetService.getAssetsByTag).toHaveBeenCalledWith(
-          'models',
-          true,
-          expect.objectContaining({ limit: 500, offset: 0 })
-        )
-      )
-
-      expect(assetService.getAssetsForNodeType).toHaveBeenCalledWith(
-        'CheckpointLoaderSimple',
-        expect.objectContaining({ limit: 500, offset: 0 })
-      )
-      expect(assetService.getAssetsForNodeType).toHaveBeenCalledTimes(1)
-      expect(assetService.getAssetsByTag).toHaveBeenCalledWith(
-        'checkpoints',
-        true,
-        expect.objectContaining({ limit: 500, offset: 0 })
-      )
-      expect(store.hasCategory('tag:models')).toBe(true)
-    })
-  })
-
   describe('updateAssetMetadata optimistic cache', () => {
-    it('still writes metadata when a cache key is unresolved', async () => {
-      const store = useAssetsStore()
-      const original = {
-        ...createMockAsset('opt-unknown'),
-        user_metadata: { note: 'before' } as Record<string, unknown>
-      }
-      vi.mocked(assetService.updateAsset).mockResolvedValueOnce({
-        ...original,
-        user_metadata: { note: 'after' }
-      })
-
-      await store.updateAssetMetadata(
-        original,
-        { note: 'after' },
-        'UnknownNodeType'
-      )
-
-      expect(vi.mocked(assetService.updateAsset)).toHaveBeenCalledWith(
-        'opt-unknown',
-        { user_metadata: { note: 'after' } }
-      )
-    })
-
-    it('still updates the server when the asset is not cached', async () => {
-      const store = useAssetsStore()
-      const original = {
-        ...createMockAsset('opt-missing'),
-        user_metadata: { note: 'before' } as Record<string, unknown>
-      }
-      vi.mocked(assetService.updateAsset).mockResolvedValueOnce({
-        ...original,
-        user_metadata: { note: 'server' }
-      })
-
-      await store.updateAssetMetadata(original, { note: 'after' })
-
-      expect(vi.mocked(assetService.updateAsset)).toHaveBeenCalledWith(
-        'opt-missing',
-        { user_metadata: { note: 'after' } }
-      )
-    })
-
-    it('still updates the server when a resolved cache key has not loaded yet', async () => {
-      const store = useAssetsStore()
-      const original = {
-        ...createMockAsset('opt-unloaded'),
-        user_metadata: { note: 'before' } as Record<string, unknown>
-      }
-      vi.mocked(assetService.updateAsset).mockResolvedValueOnce({
-        ...original,
-        user_metadata: { note: 'server' }
-      })
-
-      await store.updateAssetMetadata(
-        original,
-        { note: 'after' },
-        'CheckpointLoaderSimple'
-      )
-
-      expect(vi.mocked(assetService.updateAsset)).toHaveBeenCalledWith(
-        'opt-unloaded',
-        { user_metadata: { note: 'after' } }
-      )
-    })
-
-    it('leaves unrelated cached assets alone during optimistic metadata update', async () => {
-      const store = useAssetsStore()
-      const cached = {
-        ...createMockAsset('opt-cached'),
-        user_metadata: { note: 'cached' } as Record<string, unknown>
-      }
-      const missing = {
-        ...createMockAsset('opt-missing-from-cache'),
-        user_metadata: { note: 'before' } as Record<string, unknown>
-      }
-
-      vi.mocked(assetService.getAssetsForNodeType).mockResolvedValueOnce([
-        cached
-      ])
-      await store.updateModelsForNodeType('CheckpointLoaderSimple')
-      vi.mocked(assetService.updateAsset).mockResolvedValueOnce({
-        ...missing,
-        user_metadata: { note: 'server' }
-      })
-
-      await store.updateAssetMetadata(
-        missing,
-        { note: 'after' },
-        'CheckpointLoaderSimple'
-      )
-
-      expect(
-        store.getAssets('CheckpointLoaderSimple')[0].user_metadata
-      ).toEqual({
-        note: 'cached'
-      })
-    })
-
     it('reflects the server response in the cache after a successful update', async () => {
       const store = useAssetsStore()
       const original = {
@@ -1552,31 +1237,6 @@ describe('assetsStore - Model Assets Cache (Cloud)', () => {
         'featured'
       ])
     })
-
-    it('calls only the remove endpoint when there are no tags to add', async () => {
-      const store = useAssetsStore()
-      const asset = createMockAsset('tags-remove-only', ['models', 'archived'])
-
-      vi.mocked(assetService.getAssetsForNodeType).mockResolvedValueOnce([
-        asset
-      ])
-      await store.updateModelsForNodeType('CheckpointLoaderSimple')
-
-      vi.mocked(assetService.removeAssetTags).mockResolvedValueOnce({
-        total_tags: ['models']
-      })
-
-      await store.updateAssetTags(asset, ['models'], 'CheckpointLoaderSimple')
-
-      expect(vi.mocked(assetService.removeAssetTags)).toHaveBeenCalledWith(
-        'tags-remove-only',
-        ['archived']
-      )
-      expect(vi.mocked(assetService.addAssetTags)).not.toHaveBeenCalled()
-      expect(store.getAssets('CheckpointLoaderSimple')[0].tags).toEqual([
-        'models'
-      ])
-    })
   })
 
   describe('updateAssetTags partial-failure compensation', () => {
@@ -1691,36 +1351,6 @@ describe('assetsStore - Model Assets Cache (Cloud)', () => {
       expect(store.hasCategory('tag:models')).toBe(false)
     })
 
-    it('keeps unrelated tag caches when compensation fails with a cache key', async () => {
-      const store = useAssetsStore()
-      const asset = createMockAsset('tags-target-fail', ['models', 'loras'])
-      const otherAsset = createMockAsset('tags-other', ['models'])
-
-      vi.mocked(assetService.getAssetsForNodeType).mockResolvedValueOnce([
-        asset
-      ])
-      await store.updateModelsForNodeType('LoraLoader')
-      vi.mocked(assetService.getAssetsByTag).mockResolvedValueOnce([otherAsset])
-      await store.updateModelsForTag('models')
-
-      vi.mocked(assetService.removeAssetTags).mockResolvedValueOnce({
-        removed: ['loras'],
-        total_tags: ['models']
-      })
-      vi.mocked(assetService.addAssetTags)
-        .mockRejectedValueOnce(new Error('500 add failed'))
-        .mockRejectedValueOnce(new Error('503 compensation failed'))
-
-      await store.updateAssetTags(
-        asset,
-        ['models', 'checkpoints'],
-        'LoraLoader'
-      )
-
-      expect(store.hasCategory('loras')).toBe(false)
-      expect(store.hasCategory('tag:models')).toBe(true)
-    })
-
     it('does not attempt compensation when only the add was attempted', async () => {
       const store = useAssetsStore()
       const asset = createMockAsset('tags-add-only-fail', ['models'])
@@ -1853,78 +1483,9 @@ describe('assetsStore - Deletion State and Input Mapping', () => {
       const store = useAssetsStore()
       expect(store.getInputName('unknown.png')).toBe('unknown.png')
     })
-
-    it('ignores input assets without hashes', async () => {
-      mockIsCloud.value = true
-      try {
-        setActivePinia(createTestingPinia({ stubActions: false }))
-        const store = useAssetsStore()
-
-        vi.mocked(assetService.getAssetsByTag).mockResolvedValueOnce([
-          {
-            id: 'input-1',
-            name: 'plain.png',
-            tags: ['input']
-          }
-        ])
-        await store.updateInputs()
-
-        expect(store.getInputName('plain.png')).toBe('plain.png')
-      } finally {
-        mockIsCloud.value = false
-      }
-    })
   })
 
   describe('updateInputs cloud routing', () => {
-    it('reads input files from the internal API when isCloud is false', async () => {
-      const fetchMock = vi.fn().mockResolvedValue(
-        fromAny<Response, unknown>({
-          ok: true,
-          json: async () => ['input-a.png', 'input-b.png']
-        })
-      )
-      vi.stubGlobal('fetch', fetchMock)
-      try {
-        const store = useAssetsStore()
-
-        await store.updateInputs()
-
-        expect(fetchMock).toHaveBeenCalledWith(
-          'http://localhost:3000/files/input',
-          { headers: { 'Comfy-User': 'test-user' } }
-        )
-        expect(store.inputAssets.map((asset) => asset.name)).toEqual([
-          'input-a.png',
-          'input-b.png'
-        ])
-      } finally {
-        vi.unstubAllGlobals()
-      }
-    })
-
-    it('records internal input API failures', async () => {
-      const fetchMock = vi.fn().mockResolvedValue(
-        fromAny<Response, unknown>({
-          ok: false
-        })
-      )
-      vi.stubGlobal('fetch', fetchMock)
-      try {
-        const consoleSpy = vi
-          .spyOn(console, 'error')
-          .mockImplementation(() => {})
-        const store = useAssetsStore()
-
-        await store.updateInputs()
-
-        expect(store.inputError).toBeInstanceOf(Error)
-        consoleSpy.mockRestore()
-      } finally {
-        vi.unstubAllGlobals()
-      }
-    })
-
     it('reads from assetService.getAssetsByTag with limit 100 when isCloud is true', async () => {
       mockIsCloud.value = true
       try {
@@ -2025,18 +1586,6 @@ describe('assetsStore - Flat Output Assets (cloud-only)', () => {
     expect(store.flatOutputHasMore).toBe(false)
   })
 
-  it('does not load more flat outputs when there are no more pages', async () => {
-    vi.mocked(assetService.getAssetsPageByTag).mockResolvedValueOnce(
-      makePage([makeAsset('a1', 'one.png')])
-    )
-
-    const store = useAssetsStore()
-    await store.updateFlatOutputs()
-    await store.loadMoreFlatOutputs()
-
-    expect(assetService.getAssetsPageByTag).toHaveBeenCalledTimes(1)
-  })
-
   it('threads the minted cursor into after on loadMore and omits offset', async () => {
     vi.mocked(assetService.getAssetsPageByTag)
       .mockResolvedValueOnce(
@@ -2251,26 +1800,4 @@ describe('assetsStore - Flat Output Assets (cloud-only)', () => {
 
     expect(store.flatOutputAssets.map((x) => x.id)).toEqual(['shared-1'])
   })
-
-  it('ignores concurrent load more calls while one is active', async () => {
-    vi.mocked(assetService.getAssetsPageByTag).mockResolvedValueOnce(
-      makePage([makeAsset('a1', 'f1.png')], { hasMore: true })
-    )
-    const store = useAssetsStore()
-    await store.updateFlatOutputs()
-
-    let resolvePage!: (page: AssetResponse) => void
-    vi.mocked(assetService.getAssetsPageByTag).mockReturnValueOnce(
-      new Promise<AssetResponse>((resolve) => {
-        resolvePage = resolve
-      })
-    )
-
-    const first = store.loadMoreFlatOutputs()
-    const second = store.loadMoreFlatOutputs()
-    resolvePage(makePage([makeAsset('a2', 'f2.png')]))
-    await Promise.all([first, second])
-
-    expect(assetService.getAssetsPageByTag).toHaveBeenCalledTimes(2)
-  })
 })

src/stores/assetsStore.ts

@@ -849,15 +849,18 @@ export const useAssetsStore = defineStore('assets', () => {
         updateModelsForTag('models')
       ]
 
-      await Promise.all(
-        [...nodeTypeUpdates, ...tagUpdates].map((update) =>
-          update.catch((reason) => {
-            console.error(
-              `Failed to refresh model cache for provider: ${reason}`
-            )
-          })
-        )
-      )
+      const results = await Promise.allSettled([
+        ...nodeTypeUpdates,
+        ...tagUpdates
+      ])
+
+      for (const result of results) {
+        if (result.status === 'rejected') {
+          console.error(
+            `Failed to refresh model cache for provider: ${result.reason}`
+          )
+        }
+      }
     }
   )
 

src/stores/authStore.test.ts

@@ -90,7 +90,6 @@ vi.mock('firebase/auth', async (importOriginal) => {
     onAuthStateChanged: vi.fn(),
     onIdTokenChanged: vi.fn(),
     signInWithPopup: vi.fn(),
-    sendPasswordResetEmail: vi.fn(),
     GoogleAuthProvider: class {
       addScope = vi.fn()
       setCustomParameters = vi.fn()
@@ -100,8 +99,7 @@ vi.mock('firebase/auth', async (importOriginal) => {
       setCustomParameters = vi.fn()
     },
     getAdditionalUserInfo: vi.fn(),
-    setPersistence: vi.fn().mockResolvedValue(undefined),
-    updatePassword: vi.fn()
+    setPersistence: vi.fn().mockResolvedValue(undefined)
   }
 })
 
@@ -129,18 +127,6 @@ vi.mock('@/composables/useFeatureFlags', () => ({
   })
 }))
 
-const mockWorkspaceAuthStore = vi.hoisted(() => ({
-  unifiedToken: null as string | null,
-  clearWorkspaceContext: vi.fn(),
-  mintAtLogin: vi.fn(),
-  getWorkspaceAuthHeader: vi.fn(),
-  getWorkspaceToken: vi.fn()
-}))
-
-vi.mock('@/platform/workspace/stores/workspaceAuthStore', () => ({
-  useWorkspaceAuthStore: () => mockWorkspaceAuthStore
-}))
-
 // Mock apiKeyAuthStore
 const mockApiKeyGetAuthHeader = vi.fn().mockReturnValue(null)
 vi.mock('@/stores/apiKeyAuthStore', () => ({
@@ -177,9 +163,6 @@ describe('useAuthStore', () => {
 
     mockFeatureFlags.teamWorkspacesEnabled = false
     mockFeatureFlags.unifiedCloudAuthEnabled = false
-    mockWorkspaceAuthStore.unifiedToken = null
-    mockWorkspaceAuthStore.getWorkspaceAuthHeader.mockReturnValue(null)
-    mockWorkspaceAuthStore.getWorkspaceToken.mockReturnValue(undefined)
 
     // Setup dialog service mock
     vi.mocked(useDialogService, { partial: true }).mockReturnValue({
@@ -292,11 +275,6 @@ describe('useAuthStore', () => {
       store.notifyTokenRefreshed()
       expect(store.tokenRefreshTrigger).toBe(1)
     })
-
-    it('ignores null ID token events', () => {
-      idTokenCallback?.(null)
-      expect(store.tokenRefreshTrigger).toBe(0)
-    })
   })
 
   it('should initialize with the current user', () => {
@@ -314,24 +292,6 @@ describe('useAuthStore', () => {
     )
   })
 
-  it('mints workspace auth on cloud login and clears it on logout state', () => {
-    expect(mockWorkspaceAuthStore.mintAtLogin).toHaveBeenCalledOnce()
-
-    authStateCallback(null)
-
-    expect(mockWorkspaceAuthStore.clearWorkspaceContext).toHaveBeenCalledOnce()
-  })
-
-  it('does not mint workspace auth outside cloud', () => {
-    mockWorkspaceAuthStore.mintAtLogin.mockClear()
-    mockDistributionTypes.isCloud = false
-
-    authStateCallback(mockUser)
-
-    expect(mockWorkspaceAuthStore.mintAtLogin).not.toHaveBeenCalled()
-    mockDistributionTypes.isCloud = true
-  })
-
   it('should properly clean up error state between operations', async () => {
     // First, cause an error
     const mockError = new Error('Invalid password')
@@ -389,30 +349,6 @@ describe('useAuthStore', () => {
       expect(store.loading).toBe(false)
     })
 
-    it('tracks login when Firebase returns no email', async () => {
-      const userWithoutEmail = { ...mockUser, email: null }
-      vi.mocked(firebaseAuth.signInWithEmailAndPassword).mockResolvedValue({
-        user: userWithoutEmail
-      } as Partial<UserCredential> as UserCredential)
-
-      await store.login('test@example.com', 'password')
-
-      expect(mockTrackAuth).toHaveBeenCalledWith(
-        expect.objectContaining({ email: undefined })
-      )
-    })
-
-    it('fails customer creation when the signed-in user has no token yet', async () => {
-      authStateCallback(null)
-      vi.mocked(firebaseAuth.signInWithEmailAndPassword).mockResolvedValue({
-        user: mockUser
-      } as Partial<UserCredential> as UserCredential)
-
-      await expect(store.login('test@example.com', 'password')).rejects.toThrow(
-        'Cannot create customer: User not authenticated'
-      )
-    })
-
     it('should handle concurrent login attempts correctly', async () => {
       // Set up multiple login promises
       const mockUserCredential = { user: mockUser }
@@ -550,19 +486,6 @@ describe('useAuthStore', () => {
       ).rejects.toThrow()
       expect(mockUser.delete).not.toHaveBeenCalled()
     })
-
-    it('tracks registration when Firebase returns no email', async () => {
-      const userWithoutEmail = { ...mockUser, email: null }
-      vi.mocked(firebaseAuth.createUserWithEmailAndPassword).mockResolvedValue({
-        user: userWithoutEmail
-      } as Partial<UserCredential> as UserCredential)
-
-      await store.register('new@example.com', 'password')
-
-      expect(mockTrackAuth).toHaveBeenCalledWith(
-        expect.objectContaining({ email: undefined })
-      )
-    })
   })
 
   describe('logout', () => {
@@ -696,54 +619,6 @@ describe('useAuthStore', () => {
       const authHeader = await store.getAuthHeader()
       expect(authHeader).toBeNull() // Should fallback gracefully
     })
-
-    it('uses the unified cloud token when enabled', async () => {
-      mockFeatureFlags.unifiedCloudAuthEnabled = true
-      mockWorkspaceAuthStore.unifiedToken = 'unified-token'
-
-      await expect(store.getAuthHeader()).resolves.toEqual({
-        Authorization: 'Bearer unified-token'
-      })
-      await expect(store.getAuthToken()).resolves.toBe('unified-token')
-    })
-
-    it('returns no unified auth when the unified token is missing', async () => {
-      mockFeatureFlags.unifiedCloudAuthEnabled = true
-      mockWorkspaceAuthStore.unifiedToken = null
-
-      await expect(store.getAuthHeader()).resolves.toBeNull()
-      await expect(store.getAuthToken()).resolves.toBeUndefined()
-    })
-
-    it('prefers workspace auth when team workspaces are enabled', async () => {
-      mockFeatureFlags.teamWorkspacesEnabled = true
-      mockWorkspaceAuthStore.getWorkspaceAuthHeader.mockReturnValue({
-        Authorization: 'Bearer workspace-header'
-      })
-      mockWorkspaceAuthStore.getWorkspaceToken.mockReturnValue(
-        'workspace-token'
-      )
-
-      await expect(store.getAuthHeader()).resolves.toEqual({
-        Authorization: 'Bearer workspace-header'
-      })
-      await expect(store.getAuthToken()).resolves.toBe('workspace-token')
-    })
-
-    it('falls back to Firebase when workspace auth is unavailable', async () => {
-      mockFeatureFlags.teamWorkspacesEnabled = true
-      mockWorkspaceAuthStore.getWorkspaceAuthHeader.mockReturnValue(null)
-      mockWorkspaceAuthStore.getWorkspaceToken.mockReturnValue(undefined)
-
-      await expect(store.getAuthHeader()).resolves.toEqual({
-        Authorization: 'Bearer mock-id-token'
-      })
-      await expect(store.getAuthToken()).resolves.toBe('mock-id-token')
-    })
-
-    it('returns the Firebase token by default', async () => {
-      await expect(store.getAuthToken()).resolves.toBe('mock-id-token')
-    })
   })
 
   describe('social authentication', () => {
@@ -929,22 +804,6 @@ describe('useAuthStore', () => {
           )
         }
       )
-
-      it.for(['loginWithGoogle', 'loginWithGithub'] as const)(
-        '%s should track undefined email when Firebase returns no email',
-        async (method) => {
-          const userWithoutEmail = { ...mockUser, email: null }
-          vi.mocked(firebaseAuth.signInWithPopup).mockResolvedValue({
-            user: userWithoutEmail
-          } as Partial<UserCredential> as UserCredential)
-
-          await store[method]()
-
-          expect(mockTrackAuth).toHaveBeenCalledWith(
-            expect.objectContaining({ email: undefined })
-          )
-        }
-      )
     })
   })
 
@@ -1116,61 +975,6 @@ describe('useAuthStore', () => {
 
       await expect(store.accessBillingPortal()).rejects.toThrow()
     })
-
-    it('throws when no auth method is available', async () => {
-      authStateCallback(null)
-      mockApiKeyGetAuthHeader.mockReturnValue(null)
-
-      await expect(store.accessBillingPortal()).rejects.toMatchObject({
-        name: 'AuthStoreError',
-        message: 'toastMessages.userNotAuthenticated'
-      })
-    })
-  })
-
-  describe('fetchBalance', () => {
-    it('stores the balance and update time when fetching succeeds', async () => {
-      await expect(store.fetchBalance()).resolves.toEqual({ balance: 0 })
-
-      expect(store.balance).toEqual({ balance: 0 })
-      expect(store.lastBalanceUpdateTime).toBeInstanceOf(Date)
-      expect(store.isFetchingBalance).toBe(false)
-    })
-
-    it('throws when no auth method is available', async () => {
-      authStateCallback(null)
-      mockApiKeyGetAuthHeader.mockReturnValue(null)
-
-      await expect(store.fetchBalance()).rejects.toMatchObject({
-        name: 'AuthStoreError',
-        message: 'toastMessages.userNotAuthenticated'
-      })
-      expect(store.isFetchingBalance).toBe(false)
-    })
-
-    it('returns null when the customer balance is missing', async () => {
-      mockFetch.mockResolvedValueOnce({
-        ok: false,
-        status: 404
-      })
-
-      await expect(store.fetchBalance()).resolves.toBeNull()
-      expect(store.balance).toBeNull()
-      expect(store.isFetchingBalance).toBe(false)
-    })
-
-    it('throws API errors when fetching balance fails', async () => {
-      mockFetch.mockResolvedValueOnce({
-        ok: false,
-        status: 500,
-        json: () => Promise.resolve({ message: 'Balance unavailable' })
-      })
-
-      await expect(store.fetchBalance()).rejects.toThrow(
-        'toastMessages.failedToFetchBalance'
-      )
-      expect(store.isFetchingBalance).toBe(false)
-    })
   })
 
   describe('getAuthHeaderOrThrow', () => {
@@ -1258,117 +1062,5 @@ describe('useAuthStore', () => {
       expect(error).toBeInstanceOf(AuthStoreError)
       expect((error as AuthStoreError).status).toBe(422)
     })
-
-    it('throws when the response has no customer id', async () => {
-      mockFetch.mockResolvedValueOnce({
-        ok: true,
-        json: () => Promise.resolve({})
-      })
-
-      await expect(store.createCustomer()).rejects.toThrow(
-        'toastMessages.failedToCreateCustomer'
-      )
-    })
-  })
-
-  describe('password actions', () => {
-    it('sends password reset emails', async () => {
-      vi.mocked(firebaseAuth.sendPasswordResetEmail).mockResolvedValue()
-
-      await store.sendPasswordReset('test@example.com')
-
-      expect(firebaseAuth.sendPasswordResetEmail).toHaveBeenCalledWith(
-        mockAuth,
-        'test@example.com'
-      )
-    })
-
-    it('updates the current user password', async () => {
-      vi.mocked(firebaseAuth.updatePassword).mockResolvedValue()
-
-      await store.updatePassword('new-password')
-
-      expect(firebaseAuth.updatePassword).toHaveBeenCalledWith(
-        mockUser,
-        'new-password'
-      )
-    })
-
-    it('throws when updating password without a user', async () => {
-      authStateCallback(null)
-
-      await expect(store.updatePassword('new-password')).rejects.toMatchObject({
-        name: 'AuthStoreError',
-        message: 'toastMessages.userNotAuthenticated'
-      })
-    })
-  })
-
-  describe('initiateCreditPurchase', () => {
-    it('creates the customer once before adding credits', async () => {
-      mockFetch.mockImplementation((url: string) => {
-        if (url.endsWith('/customers')) {
-          return Promise.resolve(mockCreateCustomerResponse)
-        }
-        if (url.endsWith('/customers/credit')) {
-          return Promise.resolve({
-            ok: true,
-            json: () => Promise.resolve({ redirect_url: 'https://stripe.test' })
-          })
-        }
-        return Promise.reject(new Error('Unexpected API call'))
-      })
-
-      await store.initiateCreditPurchase({
-        amount_micros: 10_000_000,
-        currency: 'usd'
-      })
-      await store.initiateCreditPurchase({
-        amount_micros: 10_000_000,
-        currency: 'usd'
-      })
-
-      const customerCalls = mockFetch.mock.calls.filter(([url]) =>
-        String(url).endsWith('/customers')
-      )
-      expect(customerCalls).toHaveLength(1)
-    })
-
-    it('throws when credit purchase fails', async () => {
-      mockFetch.mockImplementation((url: string) => {
-        if (url.endsWith('/customers')) {
-          return Promise.resolve(mockCreateCustomerResponse)
-        }
-        if (url.endsWith('/customers/credit')) {
-          return Promise.resolve({
-            ok: false,
-            json: () => Promise.resolve({ message: 'Checkout unavailable' })
-          })
-        }
-        return Promise.reject(new Error('Unexpected API call'))
-      })
-
-      await expect(
-        store.initiateCreditPurchase({
-          amount_micros: 10_000_000,
-          currency: 'usd'
-        })
-      ).rejects.toThrow('toastMessages.failedToInitiateCreditPurchase')
-    })
-
-    it('throws when no auth method is available', async () => {
-      authStateCallback(null)
-      mockApiKeyGetAuthHeader.mockReturnValue(null)
-
-      await expect(
-        store.initiateCreditPurchase({
-          amount_micros: 10_000_000,
-          currency: 'usd'
-        })
-      ).rejects.toMatchObject({
-        name: 'AuthStoreError',
-        message: 'toastMessages.userNotAuthenticated'
-      })
-    })
   })
 })

src/stores/bootstrapStore.test.ts

@@ -93,17 +93,6 @@ describe('bootstrapStore', () => {
     })
   })
 
-  it('does not reload authenticated stores after bootstrap already ran', async () => {
-    const store = useBootstrapStore()
-
-    await store.startStoreBootstrap()
-    await store.startStoreBootstrap()
-
-    await vi.waitFor(() => {
-      expect(store.isI18nReady).toBe(true)
-    })
-  })
-
   describe('cloud mode', () => {
     beforeEach(() => {
       mockDistributionTypes.isCloud = true

src/stores/comfyRegistryStore.test.ts

@@ -1,5 +1,4 @@
 import { createTestingPinia } from '@pinia/testing'
-import { fromAny } from '@total-typescript/shoehorn'
 import { setActivePinia } from 'pinia'
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
 import { ref } from 'vue'
@@ -178,10 +177,9 @@ describe('useComfyRegistryStore', () => {
 
   it('should return null when fetching a pack with null ID', async () => {
     const store = useComfyRegistryStore()
+    vi.spyOn(store.getPackById, 'call').mockResolvedValueOnce(null)
 
-    const result = await store.getPackById.call(
-      fromAny<Parameters<typeof store.getPackById.call>[0], unknown>(null)
-    )
+    const result = await store.getPackById.call(null!)
 
     expect(result).toBeNull()
     expect(mockRegistryService.getPackById).not.toHaveBeenCalled()
@@ -208,56 +206,6 @@ describe('useComfyRegistryStore', () => {
     )
   })
 
-  it('should reuse cached packs by ID', async () => {
-    const store = useComfyRegistryStore()
-
-    await store.getPacksByIds.call(['test-pack-id'])
-    const result = await store.getPacksByIds.call(['test-pack-id'])
-
-    expect(result).toEqual([mockNodePack])
-    expect(mockRegistryService.listAllPacks).toHaveBeenCalledTimes(1)
-  })
-
-  it('should ignore missing packs by ID', async () => {
-    mockRegistryService.listAllPacks.mockResolvedValueOnce({
-      nodes: [fromAny<components['schemas']['Node'], unknown>({ name: 'bad' })],
-      total: 1,
-      page: 1,
-      limit: 10
-    })
-    const store = useComfyRegistryStore()
-
-    const result = await store.getPacksByIds.call(['unknown-pack-id'])
-
-    expect(result).toEqual([])
-  })
-
-  it('should handle empty pack lookup responses', async () => {
-    mockRegistryService.listAllPacks.mockResolvedValueOnce(null)
-    const store = useComfyRegistryStore()
-
-    const result = await store.getPacksByIds.call(['unknown-pack-id'])
-
-    expect(result).toEqual([])
-  })
-
-  it('should filter undefined pack IDs before lookup', async () => {
-    const store = useComfyRegistryStore()
-
-    const result = await store.getPacksByIds.call(
-      fromAny<components['schemas']['Node']['id'][], unknown>([
-        'test-pack-id',
-        undefined
-      ])
-    )
-
-    expect(result).toEqual([mockNodePack])
-    expect(mockRegistryService.listAllPacks).toHaveBeenCalledWith(
-      { node_id: ['test-pack-id'] },
-      expect.any(Object)
-    )
-  })
-
   describe('inferPackFromNodeName', () => {
     it('should fetch a pack by comfy node name', async () => {
       const store = useComfyRegistryStore()

src/stores/commandStore.test.ts

@@ -4,10 +4,6 @@ import { beforeEach, describe, expect, it, vi } from 'vitest'
 
 import { useCommandStore } from '@/stores/commandStore'
 
-const keybindingMock = vi.hoisted(() => ({
-  value: null as null | { combo: { getKeySequences: () => string[] } }
-}))
-
 vi.mock('@/composables/useErrorHandling', () => ({
   useErrorHandling: () => ({
     wrapWithErrorHandlingAsync:
@@ -25,13 +21,12 @@ vi.mock('@/composables/useErrorHandling', () => ({
 
 vi.mock('@/platform/keybindings/keybindingStore', () => ({
   useKeybindingStore: () => ({
-    getKeybindingByCommandId: () => keybindingMock.value
+    getKeybindingByCommandId: () => null
   })
 }))
 
 describe('commandStore', () => {
   beforeEach(() => {
-    keybindingMock.value = null
     setActivePinia(createTestingPinia({ stubActions: false }))
   })
 
@@ -169,16 +164,6 @@ describe('commandStore', () => {
       expect(store.getCommand('tip.fn')?.tooltip).toBe('Dynamic tip')
     })
 
-    it('resolves icon as function', () => {
-      const store = useCommandStore()
-      store.registerCommand({
-        id: 'icon.fn',
-        function: vi.fn(),
-        icon: () => 'pi pi-bolt'
-      })
-      expect(store.getCommand('icon.fn')?.icon).toBe('pi pi-bolt')
-    })
-
     it('uses explicit menubarLabel over label', () => {
       const store = useCommandStore()
       store.registerCommand({
@@ -199,16 +184,6 @@ describe('commandStore', () => {
       })
       expect(store.getCommand('mbl.default')?.menubarLabel).toBe('My Label')
     })
-
-    it('resolves menubarLabel as function', () => {
-      const store = useCommandStore()
-      store.registerCommand({
-        id: 'mbl.fn',
-        function: vi.fn(),
-        menubarLabel: () => 'Dynamic menu'
-      })
-      expect(store.getCommand('mbl.fn')?.menubarLabel).toBe('Dynamic menu')
-    })
   })
 
   describe('formatKeySequence', () => {
@@ -218,17 +193,5 @@ describe('commandStore', () => {
       const cmd = store.getCommand('no.kb')!
       expect(store.formatKeySequence(cmd)).toBe('')
     })
-
-    it('formats keybinding sequences', () => {
-      const store = useCommandStore()
-      keybindingMock.value = {
-        combo: { getKeySequences: () => ['Control+A', 'Shift+B'] }
-      }
-      store.registerCommand({ id: 'with.kb', function: vi.fn() })
-
-      const cmd = store.getCommand('with.kb')!
-
-      expect(store.formatKeySequence(cmd)).toBe('Ctrl+A + Shift+B')
-    })
   })
 })

src/stores/dialogStore.test.ts

@@ -1,6 +1,6 @@
 import { createTestingPinia } from '@pinia/testing'
 import { setActivePinia } from 'pinia'
-import { beforeEach, describe, expect, it, vi } from 'vitest'
+import { beforeEach, describe, expect, it } from 'vitest'
 import { defineComponent } from 'vue'
 
 import { useDialogStore } from '@/stores/dialogStore'
@@ -141,110 +141,6 @@ describe('dialogStore', () => {
   })
 
   describe('basic dialog operations', () => {
-    it('generates a key when none is provided', () => {
-      const store = useDialogStore()
-
-      const dialog = store.showDialog({ component: MockComponent })
-
-      expect(dialog.key).toMatch(/^dialog-/)
-      expect(store.isDialogOpen(dialog.key)).toBe(true)
-    })
-
-    it('evicts the first stack entry when the stack is full', () => {
-      const store = useDialogStore()
-
-      for (let i = 0; i < 11; i++) {
-        store.showDialog({
-          key: `dialog-${i}`,
-          component: MockComponent,
-          priority: i
-        })
-      }
-
-      expect(store.dialogStack).toHaveLength(10)
-      expect(store.isDialogOpen('dialog-9')).toBe(false)
-    })
-
-    it('stores optional header and footer components and props', () => {
-      const store = useDialogStore()
-
-      const dialog = store.showDialog({
-        key: 'with-slots',
-        component: MockComponent,
-        headerComponent: MockComponent,
-        footerComponent: MockComponent,
-        headerProps: { title: 'Header' },
-        footerProps: { action: 'Save' }
-      })
-
-      expect(dialog.headerComponent).toBeDefined()
-      expect(dialog.footerComponent).toBeDefined()
-      expect(dialog.headerProps).toEqual({ title: 'Header' })
-      expect(dialog.footerProps).toEqual({ action: 'Save' })
-    })
-
-    it('runs dialog lifecycle handlers', () => {
-      const store = useDialogStore()
-      const onClose = vi.fn()
-      const dialog = store.showDialog({
-        key: 'lifecycle',
-        component: MockComponent,
-        dialogComponentProps: { onClose }
-      })
-      const props =
-        dialog.dialogComponentProps as typeof dialog.dialogComponentProps & {
-          onAfterHide: () => void
-          onMaximize: () => void
-          onUnmaximize: () => void
-          pt: { root: { onMousedown: () => void } }
-        }
-
-      props.onMaximize()
-      expect(dialog.dialogComponentProps.maximized).toBe(true)
-
-      props.onUnmaximize()
-      expect(dialog.dialogComponentProps.maximized).toBe(false)
-
-      props.pt.root.onMousedown()
-      expect(store.activeKey).toBe('lifecycle')
-
-      props.onAfterHide()
-      expect(onClose).toHaveBeenCalledOnce()
-      expect(store.isDialogOpen('lifecycle')).toBe(false)
-    })
-
-    it('does nothing when rising or closing a missing dialog', () => {
-      const store = useDialogStore()
-
-      store.riseDialog({ key: 'missing' })
-      store.closeDialog({ key: 'missing' })
-
-      expect(store.dialogStack).toEqual([])
-      expect(store.activeKey).toBeNull()
-    })
-
-    it('closes the active dialog when no key is provided', () => {
-      const store = useDialogStore()
-
-      store.showDialog({ key: 'active', component: MockComponent })
-      store.closeDialog()
-
-      expect(store.isDialogOpen('active')).toBe(false)
-      expect(store.activeKey).toBeNull()
-    })
-
-    it('disables escape closing for a non-closable active dialog', () => {
-      const store = useDialogStore()
-
-      const dialog = store.showDialog({
-        key: 'locked',
-        component: MockComponent,
-        dialogComponentProps: { closable: false }
-      })
-
-      expect(dialog.dialogComponentProps.closeOnEscape).toBe(false)
-    })
-
     it('should show and close dialogs', () => {
       const store = useDialogStore()
 
@@ -312,86 +208,6 @@ describe('dialogStore', () => {
         false
       )
     })
-
-    it('updates only content props when dialog component props are omitted', () => {
-      const store = useDialogStore()
-
-      store.showDialog({
-        key: 'content-only',
-        component: MockContentPropsComponent,
-        props: { openingAction: null }
-      })
-
-      expect(
-        store.updateDialog({
-          key: 'content-only',
-          contentProps: { openingAction: 'open' }
-        })
-      ).toBe(true)
-      expect(store.dialogStack[0].contentProps.openingAction).toBe('open')
-    })
-
-    it('updates only dialog component props when content props are omitted', () => {
-      const store = useDialogStore()
-
-      store.showDialog({
-        key: 'dialog-props-only',
-        component: MockContentPropsComponent,
-        dialogComponentProps: { dismissableMask: true }
-      })
-
-      expect(
-        store.updateDialog({
-          key: 'dialog-props-only',
-          dialogComponentProps: { dismissableMask: false }
-        })
-      ).toBe(true)
-      expect(store.dialogStack[0].dialogComponentProps.dismissableMask).toBe(
-        false
-      )
-    })
-
-    it('returns false when updating a missing dialog', () => {
-      const store = useDialogStore()
-
-      expect(
-        store.updateDialog({
-          key: 'missing',
-          contentProps: { openingAction: 'open' }
-        })
-      ).toBe(false)
-    })
-
-    it('creates and reuses extension dialogs with extension-prefixed keys', () => {
-      const store = useDialogStore()
-
-      const first = store.showExtensionDialog({
-        key: 'external',
-        component: MockComponent
-      })
-      const second = store.showExtensionDialog({
-        key: 'extension-external',
-        component: MockComponent
-      })
-
-      expect(first?.key).toBe('extension-external')
-      expect(second?.key).toBe(first?.key)
-      expect(store.dialogStack).toHaveLength(1)
-    })
-
-    it('rejects extension dialogs without keys', () => {
-      const store = useDialogStore()
-      const error = vi.spyOn(console, 'error').mockImplementation(() => {})
-
-      const dialog = store.showExtensionDialog({
-        key: '',
-        component: MockComponent
-      })
-
-      expect(dialog).toBeUndefined()
-      expect(error).toHaveBeenCalledWith('Extension dialog key is required')
-      error.mockRestore()
-    })
   })
 
   describe('ESC key behavior with multiple dialogs', () => {

src/stores/domWidgetStore.test.ts

@@ -112,36 +112,6 @@ describe('domWidgetStore', () => {
         store.activateWidget('non-existent')
       }).not.toThrow()
     })
-
-    it('should ignore deactivating non-existent widgets', () => {
-      store.deactivateWidget('non-existent')
-
-      expect(store.widgetStates.size).toBe(0)
-    })
-
-    it('should replace registered widgets', () => {
-      const widget = createMockDOMWidget('widget-1')
-      const replacement = {
-        ...createMockDOMWidget('widget-1'),
-        value: 'replacement'
-      }
-      store.registerWidget(widget)
-      store.deactivateWidget('widget-1')
-
-      store.setWidget(replacement)
-
-      const state = store.widgetStates.get('widget-1')
-      expect(state?.widget.value).toBe('replacement')
-      expect(state?.active).toBe(true)
-    })
-
-    it('should ignore missing widgets when replacing', () => {
-      const widget = createMockDOMWidget('widget-1')
-
-      store.setWidget(widget)
-
-      expect(store.widgetStates.size).toBe(0)
-    })
   })
 
   describe('computed states', () => {

src/stores/electronDownloadStore.nonDesktop.test.ts

@@ -1,26 +0,0 @@
-import { createTestingPinia } from '@pinia/testing'
-import { setActivePinia } from 'pinia'
-import { beforeEach, describe, expect, it, vi } from 'vitest'
-
-import { useElectronDownloadStore } from '@/stores/electronDownloadStore'
-
-const electronAPI = vi.hoisted(() => vi.fn())
-
-vi.mock('@/platform/distribution/types', () => ({ isDesktop: false }))
-vi.mock('@/utils/envUtil', () => ({ electronAPI }))
-
-describe('electronDownloadStore outside desktop', () => {
-  beforeEach(() => {
-    setActivePinia(createTestingPinia({ stubActions: false }))
-    electronAPI.mockClear()
-  })
-
-  it('skips the Electron bridge when not running on desktop', async () => {
-    const store = useElectronDownloadStore()
-
-    await store.initialize()
-
-    expect(electronAPI).not.toHaveBeenCalled()
-    expect(store.downloads).toEqual([])
-  })
-})

src/stores/electronDownloadStore.test.ts

@@ -1,103 +0,0 @@
-import { DownloadStatus } from '@comfyorg/comfyui-electron-types'
-import { createTestingPinia } from '@pinia/testing'
-import { setActivePinia } from 'pinia'
-import { beforeEach, describe, expect, it, vi } from 'vitest'
-
-import { useElectronDownloadStore } from '@/stores/electronDownloadStore'
-
-const downloadManagerMock = vi.hoisted(() => ({
-  cancelDownload: vi.fn(),
-  getAllDownloads: vi.fn(),
-  onDownloadProgress: vi.fn(),
-  pauseDownload: vi.fn(),
-  resumeDownload: vi.fn(),
-  startDownload: vi.fn()
-}))
-
-vi.mock('@/platform/distribution/types', () => ({
-  isDesktop: true
-}))
-
-vi.mock('@/utils/envUtil', () => ({
-  electronAPI: () => ({
-    DownloadManager: downloadManagerMock
-  })
-}))
-
-describe('electronDownloadStore', () => {
-  beforeEach(() => {
-    setActivePinia(createTestingPinia({ stubActions: false }))
-    Object.values(downloadManagerMock).forEach((mock) => mock.mockReset())
-    downloadManagerMock.getAllDownloads.mockResolvedValue([
-      {
-        filename: 'done.bin',
-        status: DownloadStatus.COMPLETED,
-        url: 'https://example.com/done.bin'
-      }
-    ])
-  })
-
-  it('loads existing downloads and applies progress updates by URL', async () => {
-    let progressCallback:
-      | Parameters<typeof downloadManagerMock.onDownloadProgress>[0]
-      | undefined
-    downloadManagerMock.onDownloadProgress.mockImplementation((callback) => {
-      progressCallback = callback
-    })
-    const store = useElectronDownloadStore()
-
-    await store.initialize()
-    progressCallback?.({
-      filename: 'model.bin',
-      progress: 25,
-      savePath: '/tmp/model.bin',
-      status: DownloadStatus.IN_PROGRESS,
-      url: 'https://example.com/model.bin'
-    })
-    progressCallback?.({
-      filename: 'model.bin',
-      progress: 50,
-      savePath: '/tmp/model.bin',
-      status: DownloadStatus.IN_PROGRESS,
-      url: 'https://example.com/model.bin'
-    })
-
-    expect(store.findByUrl('https://example.com/done.bin')?.status).toBe(
-      DownloadStatus.COMPLETED
-    )
-    expect(store.findByUrl('https://example.com/model.bin')).toMatchObject({
-      filename: 'model.bin',
-      progress: 50,
-      status: DownloadStatus.IN_PROGRESS
-    })
-    expect(store.inProgressDownloads).toHaveLength(1)
-  })
-
-  it('delegates download controls to the Electron bridge', async () => {
-    const store = useElectronDownloadStore()
-
-    await store.start({
-      filename: 'model.bin',
-      savePath: '/tmp/model.bin',
-      url: 'https://example.com/model.bin'
-    })
-    await store.pause('https://example.com/model.bin')
-    await store.resume('https://example.com/model.bin')
-    await store.cancel('https://example.com/model.bin')
-
-    expect(downloadManagerMock.startDownload).toHaveBeenCalledWith(
-      'https://example.com/model.bin',
-      '/tmp/model.bin',
-      'model.bin'
-    )
-    expect(downloadManagerMock.pauseDownload).toHaveBeenCalledWith(
-      'https://example.com/model.bin'
-    )
-    expect(downloadManagerMock.resumeDownload).toHaveBeenCalledWith(
-      'https://example.com/model.bin'
-    )
-    expect(downloadManagerMock.cancelDownload).toHaveBeenCalledWith(
-      'https://example.com/model.bin'
-    )
-  })
-})

src/stores/electronDownloadStore.ts

@@ -33,15 +33,18 @@ export const useElectronDownloadStore = defineStore('downloads', () => {
     }
 
     DownloadManager.onDownloadProgress((data) => {
-      const download = findByUrl(data.url)
-      if (!download) {
+      if (!findByUrl(data.url)) {
         downloads.value.push(data)
-        return
       }
-      download.progress = data.progress
-      download.status = data.status
-      download.filename = data.filename
-      download.savePath = data.savePath
+
+      const download = findByUrl(data.url)
+
+      if (download) {
+        download.progress = data.progress
+        download.status = data.status
+        download.filename = data.filename
+        download.savePath = data.savePath
+      }
     })
   }
 

src/stores/executionError.test.ts

@@ -1,188 +0,0 @@
-import { createPinia, setActivePinia } from 'pinia'
-import { beforeEach, describe, expect, it, vi } from 'vitest'
-import { ref } from 'vue'
-
-import type { ComfyWorkflow } from '@/platform/workflow/management/stores/workflowStore'
-import type { ComfyApiWorkflow } from '@/platform/workflow/validation/schemas/workflowSchema'
-import { useExecutionStore } from '@/stores/executionStore'
-
-const {
-  handlers,
-  openSet,
-  errorStore,
-  dist,
-  resolvePrecondition,
-  classifyCloud
-} = vi.hoisted(() => ({
-  handlers: {} as Record<string, (e: { detail: unknown }) => void>,
-  openSet: new Set<unknown>(),
-  errorStore: {
-    clearExecutionStartErrors: () => {},
-    clearPromptError: () => {}
-  } as Record<string, unknown>,
-  dist: { isCloud: false },
-  resolvePrecondition: vi.fn(),
-  classifyCloud: vi.fn()
-}))
-
-vi.mock('@/scripts/app', () => ({ app: { rootGraph: {} } }))
-
-vi.mock('@/scripts/api', () => ({
-  api: {
-    addEventListener: (name: string, fn: (e: { detail: unknown }) => void) => {
-      handlers[name] = fn
-    },
-    removeEventListener: () => {}
-  }
-}))
-
-vi.mock('@/platform/workflow/management/stores/workflowStore', () => ({
-  useWorkflowStore: () => ({
-    isOpen: (workflow: unknown) => openSet.has(workflow),
-    openWorkflows: [],
-    nodeLocatorIdToNodeExecutionId: () => null
-  })
-}))
-
-vi.mock('@/renderer/core/canvas/canvasStore', () => ({
-  useCanvasStore: () => ({ canvas: undefined })
-}))
-
-vi.mock('@/stores/executionErrorStore', () => ({
-  useExecutionErrorStore: () => errorStore
-}))
-
-vi.mock('@/composables/useAppMode', () => ({
-  useAppMode: () => ({ mode: ref('default'), isAppMode: ref(false) })
-}))
-
-vi.mock('@/platform/telemetry', () => ({ useTelemetry: () => undefined }))
-
-vi.mock('@/utils/appMode', () => ({
-  getWorkflowMode: () => 'workflow',
-  isAppModeValue: () => false
-}))
-
-vi.mock('@/platform/distribution/types', () => ({
-  get isCloud() {
-    return dist.isCloud
-  }
-}))
-
-vi.mock('@/platform/errorCatalog/accountPreconditionRouting', () => ({
-  resolveAccountPrecondition: resolvePrecondition
-}))
-
-vi.mock('@/utils/executionErrorUtil', () => ({
-  classifyCloudValidationError: classifyCloud
-}))
-
-function workflow(path: string): ComfyWorkflow {
-  return { path } as unknown as ComfyWorkflow
-}
-
-function promptOutput(): ComfyApiWorkflow {
-  return {}
-}
-
-function setup() {
-  const store = useExecutionStore()
-  store.bindExecutionEvents()
-  return store
-}
-
-function fireError(detail: Record<string, unknown>) {
-  handlers['execution_error']?.({ detail })
-}
-
-beforeEach(() => {
-  setActivePinia(createPinia())
-  for (const key of Object.keys(handlers)) delete handlers[key]
-  openSet.clear()
-  dist.isCloud = false
-  resolvePrecondition.mockReturnValue(null)
-  classifyCloud.mockReturnValue(null)
-  for (const key of ['lastExecutionError', 'lastPromptError', 'lastNodeErrors'])
-    delete errorStore[key]
-})
-
-describe('executionStore error handling', () => {
-  it('marks an open workflow failed and records the raw execution error', () => {
-    const store = setup()
-    const wf = workflow('a.json')
-    openSet.add(wf)
-    store.storeJob({
-      nodes: [],
-      id: 'job-1',
-      promptOutput: promptOutput(),
-      workflow: wf
-    })
-
-    const detail = {
-      prompt_id: 'job-1',
-      node_id: '5',
-      exception_message: 'boom'
-    }
-    fireError(detail)
-
-    expect(store.getWorkflowStatus(wf)).toBe('failed')
-    expect(errorStore.lastExecutionError).toBe(detail)
-  })
-
-  it('routes account-precondition errors away from the failed badge', () => {
-    resolvePrecondition.mockReturnValue({ type: 'credits' })
-    const store = setup()
-    const wf = workflow('b.json')
-    openSet.add(wf)
-    store.storeJob({
-      nodes: [],
-      id: 'job-2',
-      promptOutput: promptOutput(),
-      workflow: wf
-    })
-
-    fireError({ prompt_id: 'job-2', exception_type: 'AccountError' })
-
-    expect(store.getWorkflowStatus(wf)).toBeUndefined()
-    expect(errorStore.lastExecutionError).toBeUndefined()
-  })
-
-  it('records a node-less service-level error as a prompt error', () => {
-    setup()
-
-    fireError({
-      prompt_id: 'job-3',
-      exception_type: 'StagnationError',
-      exception_message: 'stuck',
-      traceback: ['line1', 'line2']
-    })
-
-    expect(errorStore.lastPromptError).toEqual({
-      type: 'StagnationError',
-      message: 'StagnationError: stuck',
-      details: 'line1\nline2'
-    })
-  })
-
-  it('records classified cloud validation node errors without a failed badge', () => {
-    dist.isCloud = true
-    classifyCloud.mockReturnValue({
-      kind: 'nodeErrors',
-      nodeErrors: { '5': { errors: [] } }
-    })
-    const store = setup()
-    const wf = workflow('c.json')
-    openSet.add(wf)
-    store.storeJob({
-      nodes: [],
-      id: 'job-4',
-      promptOutput: promptOutput(),
-      workflow: wf
-    })
-
-    fireError({ prompt_id: 'job-4', exception_message: '{"nodeErrors":{}}' })
-
-    expect(store.getWorkflowStatus(wf)).toBeUndefined()
-    expect(errorStore.lastNodeErrors).toEqual({ '5': { errors: [] } })
-  })
-})

src/stores/executionErrorStore.test.ts

@@ -2,10 +2,8 @@ import { fromAny } from '@total-typescript/shoehorn'
 import { createPinia, setActivePinia } from 'pinia'
 import { beforeEach, describe, expect, it, vi } from 'vitest'
 
-import type { LGraphNode } from '@/lib/litegraph/src/litegraph'
 import type { MissingNodeType } from '@/types/comfy'
 import { createNodeExecutionId } from '@/types/nodeIdentification'
-import type { NodeLocatorId } from '@/types/nodeIdentification'
 
 // Mock dependencies
 vi.mock('@/i18n', () => ({
@@ -17,53 +15,6 @@ vi.mock('@/platform/distribution/types', () => ({
 }))
 
 const mockShowErrorsTab = vi.hoisted(() => ({ value: false }))
-const {
-  mockApp,
-  mockCanvasStore,
-  mockExecutionIdToNodeLocatorId,
-  mockGetExecutionIdByNode,
-  mockGetNodeByExecutionId,
-  mockWorkflowStore
-} = vi.hoisted(() => ({
-  mockApp: {
-    isGraphReady: true,
-    rootGraph: {}
-  },
-  mockCanvasStore: {
-    currentGraph: undefined as object | undefined
-  },
-  mockExecutionIdToNodeLocatorId: vi.fn(
-    (_rootGraph: unknown, id: string) => id as NodeLocatorId
-  ),
-  mockGetExecutionIdByNode: vi.fn(),
-  mockGetNodeByExecutionId: vi.fn(),
-  mockWorkflowStore: {
-    nodeLocatorIdToNodeId: vi.fn()
-  }
-}))
-
-vi.mock('@/scripts/app', () => ({ app: mockApp }))
-
-vi.mock('@/renderer/core/canvas/canvasStore', () => ({
-  useCanvasStore: () => mockCanvasStore
-}))
-
-vi.mock('@/platform/workflow/management/stores/workflowStore', () => ({
-  useWorkflowStore: () => mockWorkflowStore
-}))
-
-vi.mock('@/utils/graphTraversalUtil', () => ({
-  executionIdToNodeLocatorId: (
-    ...args: Parameters<typeof mockExecutionIdToNodeLocatorId>
-  ) => mockExecutionIdToNodeLocatorId(...args),
-  forEachNode: vi.fn(),
-  getExecutionIdByNode: (
-    ...args: Parameters<typeof mockGetExecutionIdByNode>
-  ) => mockGetExecutionIdByNode(...args),
-  getNodeByExecutionId: (
-    ...args: Parameters<typeof mockGetNodeByExecutionId>
-  ) => mockGetNodeByExecutionId(...args)
-}))
 
 vi.mock('@/stores/settingStore', () => ({
   useSettingStore: vi.fn(() => ({
@@ -88,21 +39,6 @@ import { useExecutionErrorStore } from './executionErrorStore'
 import { useMissingNodesErrorStore } from '@/platform/nodeReplacement/missingNodesErrorStore'
 import { toNodeId } from '@/types/nodeId'
 
-beforeEach(() => {
-  mockShowErrorsTab.value = false
-  mockApp.isGraphReady = true
-  mockCanvasStore.currentGraph = undefined
-  mockExecutionIdToNodeLocatorId.mockImplementation(
-    (_rootGraph: unknown, id: string) => id as NodeLocatorId
-  )
-  mockGetExecutionIdByNode.mockReset()
-  mockGetNodeByExecutionId.mockReset()
-  mockWorkflowStore.nodeLocatorIdToNodeId.mockImplementation(
-    (locator: NodeLocatorId) =>
-      toNodeId(String(locator).split(':').at(-1) ?? locator)
-  )
-})
-
 describe('executionErrorStore — node error operations', () => {
   beforeEach(() => {
     setActivePinia(createPinia())
@@ -208,31 +144,6 @@ describe('executionErrorStore — node error operations', () => {
       expect(store.lastNodeErrors?.['123'].errors).toHaveLength(1)
     })
 
-    it('does nothing when the requested slot has no errors', () => {
-      const store = useExecutionErrorStore()
-      store.lastNodeErrors = {
-        '123': {
-          errors: [
-            {
-              type: 'value_bigger_than_max',
-              message: 'Max exceeded',
-              details: '',
-              extra_info: { input_name: 'otherSlot' }
-            }
-          ],
-          dependent_outputs: [],
-          class_type: 'TestNode'
-        }
-      }
-
-      store.clearSimpleNodeErrors(
-        createNodeExecutionId([toNodeId(123)]),
-        'testSlot'
-      )
-
-      expect(store.lastNodeErrors?.['123'].errors).toHaveLength(1)
-    })
-
     it('preserves complex errors when slot has both simple and complex errors', () => {
       const store = useExecutionErrorStore()
       store.lastNodeErrors = {
@@ -477,358 +388,6 @@ describe('executionErrorStore — node error operations', () => {
       expect(store.lastNodeErrors).not.toBeNull()
       expect(store.lastNodeErrors?.['123'].errors).toHaveLength(1)
     })
-
-    it('keeps numeric range errors when no range options prove them valid', () => {
-      const store = useExecutionErrorStore()
-      store.lastNodeErrors = {
-        '123': {
-          errors: [
-            {
-              type: 'value_bigger_than_max',
-              message: '...',
-              details: '',
-              extra_info: { input_name: 'testWidget' }
-            }
-          ],
-          dependent_outputs: [],
-          class_type: 'TestNode'
-        }
-      }
-
-      store.clearWidgetRelatedErrors(
-        createNodeExecutionId([toNodeId(123)]),
-        'testWidget',
-        'testWidget',
-        15
-      )
-
-      expect(store.lastNodeErrors?.['123'].errors).toHaveLength(1)
-    })
-
-    it('clears simple widget errors when the numeric value has no node error entry', () => {
-      const store = useExecutionErrorStore()
-      store.lastNodeErrors = {
-        '999': {
-          errors: [
-            {
-              type: 'value_bigger_than_max',
-              message: '...',
-              details: '',
-              extra_info: { input_name: 'testWidget' }
-            }
-          ],
-          dependent_outputs: [],
-          class_type: 'TestNode'
-        }
-      }
-
-      store.clearWidgetRelatedErrors(
-        createNodeExecutionId([toNodeId(123)]),
-        'testWidget',
-        'testWidget',
-        15,
-        { max: 10 }
-      )
-
-      expect(store.lastNodeErrors?.['999'].errors).toHaveLength(1)
-    })
-  })
-
-  describe('startup clearing', () => {
-    it('clears execution-start errors and closes the overlay when node errors are empty', () => {
-      const store = useExecutionErrorStore()
-      store.lastExecutionError = fromAny({ node_id: '1' })
-      store.lastPromptError = fromAny({ message: 'prompt failed' })
-      store.lastNodeErrors = {}
-      store.showErrorOverlay()
-
-      store.clearExecutionStartErrors()
-
-      expect(store.lastExecutionError).toBeNull()
-      expect(store.lastPromptError).toBeNull()
-      expect(store.isErrorOverlayOpen).toBe(false)
-    })
-
-    it('keeps the overlay open when node errors remain after execution start', () => {
-      const store = useExecutionErrorStore()
-      store.lastExecutionError = fromAny({ node_id: '1' })
-      store.lastPromptError = fromAny({ message: 'prompt failed' })
-      store.lastNodeErrors = {
-        '1': {
-          errors: [
-            {
-              type: 'required_input_missing',
-              message: 'Missing',
-              details: '',
-              extra_info: { input_name: 'x' }
-            }
-          ],
-          dependent_outputs: [],
-          class_type: 'Test'
-        }
-      }
-      store.showErrorOverlay()
-
-      store.clearExecutionStartErrors()
-
-      expect(store.isErrorOverlayOpen).toBe(true)
-    })
-  })
-})
-
-describe('executionErrorStore derived graph state', () => {
-  beforeEach(() => {
-    setActivePinia(createPinia())
-  })
-
-  it('derives execution error node ids through locator mapping', () => {
-    const store = useExecutionErrorStore()
-    mockExecutionIdToNodeLocatorId.mockReturnValue(
-      fromAny<NodeLocatorId, string>('graph:7')
-    )
-    store.lastExecutionError = fromAny({ node_id: '7' })
-
-    expect(store.lastExecutionErrorNodeId).toBe(toNodeId(7))
-  })
-
-  it('returns null when there is no execution error locator', () => {
-    const store = useExecutionErrorStore()
-    store.lastExecutionError = fromAny({ node_id: '7' })
-    mockExecutionIdToNodeLocatorId.mockReturnValue(
-      fromAny<NodeLocatorId, undefined>(undefined)
-    )
-
-    expect(store.lastExecutionErrorNodeId).toBeNull()
-  })
-
-  it('returns null when there is no execution error', () => {
-    const store = useExecutionErrorStore()
-
-    expect(store.lastExecutionErrorNodeId).toBeNull()
-  })
-
-  it('combines prompt, node, execution, and missing-node error counts', () => {
-    const store = useExecutionErrorStore()
-    const missingNodesStore = useMissingNodesErrorStore()
-    store.lastPromptError = fromAny({ message: 'prompt failed' })
-    store.lastExecutionError = fromAny({ node_id: null })
-    store.lastNodeErrors = {
-      '1': {
-        errors: [
-          {
-            type: 'required_input_missing',
-            message: 'Missing',
-            details: '',
-            extra_info: { input_name: 'x' }
-          },
-          {
-            type: 'value_bigger_than_max',
-            message: 'Too large',
-            details: '',
-            extra_info: { input_name: 'y' }
-          }
-        ],
-        dependent_outputs: [],
-        class_type: 'Test'
-      }
-    }
-    missingNodesStore.setMissingNodeTypes(
-      fromAny<MissingNodeType[], unknown>([{ type: 'MissingNode', hint: '' }])
-    )
-
-    expect(store.hasPromptError).toBe(true)
-    expect(store.hasNodeError).toBe(true)
-    expect(store.hasExecutionError).toBe(true)
-    expect(store.hasAnyError).toBe(true)
-    expect(store.allErrorExecutionIds).toEqual(['1'])
-    expect(store.totalErrorCount).toBe(5)
-  })
-
-  it('reports empty derived state when there are no errors', () => {
-    const store = useExecutionErrorStore()
-
-    expect(store.hasNodeError).toBe(false)
-    expect(store.allErrorExecutionIds).toEqual([])
-    expect(store.totalErrorCount).toBe(0)
-  })
-
-  it('includes defined execution node ids in the error id list', () => {
-    const store = useExecutionErrorStore()
-    store.lastExecutionError = fromAny({ node_id: '2' })
-
-    expect(store.allErrorExecutionIds).toEqual(['2'])
-  })
-
-  it('excludes undefined execution node ids from the error id list', () => {
-    const store = useExecutionErrorStore()
-    store.lastExecutionError = fromAny({ node_id: undefined })
-
-    expect(store.allErrorExecutionIds).toEqual([])
-  })
-
-  it('collects active graph node ids for validation and execution errors', () => {
-    const store = useExecutionErrorStore()
-    const activeGraph = {}
-    mockCanvasStore.currentGraph = activeGraph
-    mockGetNodeByExecutionId.mockImplementation((_rootGraph, id: string) => ({
-      id: toNodeId(id),
-      graph: activeGraph
-    }))
-    store.lastNodeErrors = {
-      '1': {
-        errors: [
-          {
-            type: 'required_input_missing',
-            message: 'Missing',
-            details: '',
-            extra_info: { input_name: 'x' }
-          }
-        ],
-        dependent_outputs: [],
-        class_type: 'Test'
-      }
-    }
-    store.lastExecutionError = fromAny({ node_id: '2' })
-
-    expect([...store.activeGraphErrorNodeIds].sort()).toEqual(['1', '2'])
-  })
-
-  it('falls back to the root graph when there is no current canvas graph', () => {
-    const store = useExecutionErrorStore()
-    mockCanvasStore.currentGraph = undefined
-    mockGetNodeByExecutionId.mockReturnValue({
-      id: toNodeId(1),
-      graph: mockApp.rootGraph
-    })
-    store.lastNodeErrors = {
-      '1': {
-        errors: [
-          {
-            type: 'required_input_missing',
-            message: 'Missing',
-            details: '',
-            extra_info: { input_name: 'x' }
-          }
-        ],
-        dependent_outputs: [],
-        class_type: 'Test'
-      }
-    }
-
-    expect([...store.activeGraphErrorNodeIds]).toEqual(['1'])
-  })
-
-  it('ignores graph errors outside the active graph', () => {
-    const store = useExecutionErrorStore()
-    const activeGraph = {}
-    mockCanvasStore.currentGraph = activeGraph
-    mockGetNodeByExecutionId.mockReturnValue({
-      id: toNodeId(1),
-      graph: {}
-    })
-    store.lastNodeErrors = {
-      '1': {
-        errors: [
-          {
-            type: 'required_input_missing',
-            message: 'Missing',
-            details: '',
-            extra_info: { input_name: 'x' }
-          }
-        ],
-        dependent_outputs: [],
-        class_type: 'Test'
-      }
-    }
-    store.lastExecutionError = fromAny({ node_id: '1' })
-
-    expect(store.activeGraphErrorNodeIds.size).toBe(0)
-  })
-
-  it('returns no active graph node ids before the graph is ready', () => {
-    const store = useExecutionErrorStore()
-    mockApp.isGraphReady = false
-    store.lastExecutionError = fromAny({ node_id: '2' })
-
-    expect(store.activeGraphErrorNodeIds.size).toBe(0)
-  })
-
-  it('maps node errors by locator and checks slots', () => {
-    const store = useExecutionErrorStore()
-    const nodeError = {
-      errors: [
-        {
-          type: 'required_input_missing',
-          message: 'Missing',
-          details: '',
-          extra_info: { input_name: 'x' }
-        }
-      ],
-      dependent_outputs: [],
-      class_type: 'Test'
-    }
-    mockExecutionIdToNodeLocatorId.mockImplementation((_rootGraph, id) =>
-      id === 'missing'
-        ? fromAny<NodeLocatorId, undefined>(undefined)
-        : fromAny<NodeLocatorId, string>(`locator:${id}`)
-    )
-    store.lastNodeErrors = {
-      '1': nodeError,
-      missing: nodeError
-    }
-
-    const locator = fromAny<NodeLocatorId, string>('locator:1')
-    expect(store.getNodeErrors(locator)).toEqual(nodeError)
-    expect(store.slotHasError(locator, 'x')).toBe(true)
-    expect(store.slotHasError(locator, 'y')).toBe(false)
-    expect(
-      store.getNodeErrors(fromAny<NodeLocatorId, string>('locator:missing'))
-    ).toBeUndefined()
-  })
-
-  it('returns no slot error when there are no node errors', () => {
-    const store = useExecutionErrorStore()
-
-    expect(
-      store.slotHasError(fromAny<NodeLocatorId, string>('locator:1'), 'x')
-    ).toBe(false)
-  })
-
-  it('detects container nodes with internal errors', () => {
-    const store = useExecutionErrorStore()
-    const node = fromAny<LGraphNode, unknown>({})
-    mockGetExecutionIdByNode.mockReturnValueOnce(undefined)
-
-    expect(store.isContainerWithInternalError(node)).toBe(false)
-
-    store.lastNodeErrors = {
-      '1:2': {
-        errors: [
-          {
-            type: 'required_input_missing',
-            message: 'Missing',
-            details: '',
-            extra_info: { input_name: 'x' }
-          }
-        ],
-        dependent_outputs: [],
-        class_type: 'Test'
-      }
-    }
-    mockGetExecutionIdByNode.mockReturnValue(
-      createNodeExecutionId([toNodeId(1)])
-    )
-
-    expect(store.isContainerWithInternalError(node)).toBe(true)
-  })
-
-  it('does not report container errors before the graph is ready', () => {
-    const store = useExecutionErrorStore()
-    mockApp.isGraphReady = false
-
-    expect(
-      store.isContainerWithInternalError(fromAny<LGraphNode, unknown>({}))
-    ).toBe(false)
   })
 })
 
@@ -898,23 +457,6 @@ describe('surfaceMissingModels — silent option', () => {
 
     expect(store.isErrorOverlayOpen).toBe(false)
   })
-
-  it('does NOT open error overlay when the setting is disabled', () => {
-    const store = useExecutionErrorStore()
-    mockShowErrorsTab.value = false
-    store.surfaceMissingModels([
-      fromAny({
-        name: 'model.safetensors',
-        nodeId: toNodeId('1'),
-        nodeType: 'Loader',
-        widgetName: 'ckpt',
-        isMissing: true,
-        isAssetSupported: false
-      })
-    ])
-
-    expect(store.isErrorOverlayOpen).toBe(false)
-  })
 })
 
 describe('surfaceMissingMedia — silent option', () => {
@@ -983,23 +525,6 @@ describe('surfaceMissingMedia — silent option', () => {
 
     expect(store.isErrorOverlayOpen).toBe(false)
   })
-
-  it('does NOT open error overlay when the setting is disabled', () => {
-    const store = useExecutionErrorStore()
-    mockShowErrorsTab.value = false
-    store.surfaceMissingMedia([
-      fromAny({
-        name: 'photo.png',
-        nodeId: toNodeId('1'),
-        nodeType: 'LoadImage',
-        widgetName: 'image',
-        mediaType: 'image',
-        isMissing: true
-      })
-    ])
-
-    expect(store.isErrorOverlayOpen).toBe(false)
-  })
 })
 
 describe('clearAllErrors', () => {

src/stores/executionInterrupt.test.ts

@@ -1,120 +0,0 @@
-import { createPinia, setActivePinia } from 'pinia'
-import { beforeEach, describe, expect, it, vi } from 'vitest'
-import { ref } from 'vue'
-
-import type { ComfyWorkflow } from '@/platform/workflow/management/stores/workflowStore'
-import type { ComfyApiWorkflow } from '@/platform/workflow/validation/schemas/workflowSchema'
-import { useExecutionStore } from '@/stores/executionStore'
-
-const { handlers, openSet } = vi.hoisted(() => ({
-  handlers: {} as Record<string, (e: { detail: unknown }) => void>,
-  openSet: new Set<unknown>()
-}))
-
-vi.mock('@/scripts/app', () => ({ app: { rootGraph: {} } }))
-
-vi.mock('@/scripts/api', () => ({
-  api: {
-    addEventListener: (name: string, fn: (e: { detail: unknown }) => void) => {
-      handlers[name] = fn
-    },
-    removeEventListener: () => {}
-  }
-}))
-
-vi.mock('@/platform/workflow/management/stores/workflowStore', () => ({
-  useWorkflowStore: () => ({
-    isOpen: (workflow: unknown) => openSet.has(workflow),
-    openWorkflows: [],
-    nodeLocatorIdToNodeExecutionId: () => null
-  })
-}))
-
-vi.mock('@/renderer/core/canvas/canvasStore', () => ({
-  useCanvasStore: () => ({ canvas: undefined })
-}))
-
-vi.mock('@/stores/executionErrorStore', () => ({
-  useExecutionErrorStore: () => ({
-    clearExecutionStartErrors: () => {},
-    clearPromptError: () => {}
-  })
-}))
-
-vi.mock('@/composables/useAppMode', () => ({
-  useAppMode: () => ({ mode: ref('default'), isAppMode: ref(false) })
-}))
-
-vi.mock('@/platform/telemetry', () => ({ useTelemetry: () => undefined }))
-
-vi.mock('@/utils/appMode', () => ({
-  getWorkflowMode: () => 'workflow',
-  isAppModeValue: () => false
-}))
-
-function workflow(path: string): ComfyWorkflow {
-  return { path } as unknown as ComfyWorkflow
-}
-
-function setup() {
-  const store = useExecutionStore()
-  store.bindExecutionEvents()
-  return store
-}
-
-function promptOutput(): ComfyApiWorkflow {
-  return {}
-}
-
-function startJob(
-  store: ReturnType<typeof useExecutionStore>,
-  id: string,
-  wf: ComfyWorkflow,
-  nodes: string[] = []
-) {
-  openSet.add(wf)
-  store.storeJob({ nodes, id, promptOutput: promptOutput(), workflow: wf })
-  handlers['execution_start']?.({ detail: { prompt_id: id } })
-}
-
-beforeEach(() => {
-  setActivePinia(createPinia())
-  for (const key of Object.keys(handlers)) delete handlers[key]
-  openSet.clear()
-})
-
-describe('executionStore interrupt and cached', () => {
-  it('drops the workflow badge and goes idle on interruption', () => {
-    const store = setup()
-    const wf = workflow('a.json')
-    startJob(store, 'job-1', wf)
-    expect(store.getWorkflowStatus(wf)).toBe('running')
-
-    handlers['execution_interrupted']?.({ detail: { prompt_id: 'job-1' } })
-
-    expect(store.getWorkflowStatus(wf)).toBeUndefined()
-    expect(store.isIdle).toBe(true)
-  })
-
-  it('ends the active job when executing resolves to null', () => {
-    const store = setup()
-    startJob(store, 'job-2', workflow('b.json'))
-    expect(store.isIdle).toBe(false)
-
-    handlers['executing']?.({ detail: null })
-
-    expect(store.isIdle).toBe(true)
-  })
-
-  it('marks cached nodes as executed', () => {
-    const store = setup()
-    startJob(store, 'job-3', workflow('c.json'), ['a', 'b', 'c'])
-    expect(store.nodesExecuted).toBe(0)
-
-    handlers['execution_cached']?.({
-      detail: { prompt_id: 'job-3', nodes: ['a', 'b'] }
-    })
-
-    expect(store.nodesExecuted).toBe(2)
-  })
-})

src/stores/executionLifecycle.test.ts

@@ -1,119 +0,0 @@
-import { createPinia, setActivePinia } from 'pinia'
-import { beforeEach, describe, expect, it, vi } from 'vitest'
-import { ref } from 'vue'
-
-import type { ComfyWorkflow } from '@/platform/workflow/management/stores/workflowStore'
-import type { ComfyApiWorkflow } from '@/platform/workflow/validation/schemas/workflowSchema'
-import { useExecutionStore } from '@/stores/executionStore'
-
-const { handlers } = vi.hoisted(() => ({
-  handlers: {} as Record<string, (e: { detail: unknown }) => void>
-}))
-
-vi.mock('@/scripts/app', () => ({ app: { rootGraph: {} } }))
-
-vi.mock('@/scripts/api', () => ({
-  api: {
-    addEventListener: (name: string, fn: (e: { detail: unknown }) => void) => {
-      handlers[name] = fn
-    },
-    removeEventListener: () => {}
-  }
-}))
-
-vi.mock('@/platform/workflow/management/stores/workflowStore', () => ({
-  useWorkflowStore: () => ({
-    isOpen: () => false,
-    openWorkflows: [],
-    nodeLocatorIdToNodeExecutionId: () => null
-  })
-}))
-
-vi.mock('@/renderer/core/canvas/canvasStore', () => ({
-  useCanvasStore: () => ({ canvas: undefined })
-}))
-
-vi.mock('@/stores/executionErrorStore', () => ({
-  useExecutionErrorStore: () => ({
-    clearExecutionStartErrors: () => {},
-    clearPromptError: () => {}
-  })
-}))
-
-vi.mock('@/composables/useAppMode', () => ({
-  useAppMode: () => ({ mode: ref('default'), isAppMode: ref(false) })
-}))
-
-vi.mock('@/platform/telemetry', () => ({ useTelemetry: () => undefined }))
-
-vi.mock('@/utils/appMode', () => ({
-  getWorkflowMode: () => 'workflow',
-  isAppModeValue: () => false
-}))
-
-function setup() {
-  const store = useExecutionStore()
-  store.bindExecutionEvents()
-  return store
-}
-
-function promptOutput(): ComfyApiWorkflow {
-  return {}
-}
-
-function startJob(
-  store: ReturnType<typeof useExecutionStore>,
-  id: string,
-  nodes: string[]
-) {
-  store.storeJob({
-    nodes,
-    id,
-    promptOutput: promptOutput(),
-    workflow: { path: `${id}.json` } as unknown as ComfyWorkflow
-  })
-  handlers['execution_start']?.({ detail: { prompt_id: id } })
-}
-
-beforeEach(() => {
-  setActivePinia(createPinia())
-  for (const key of Object.keys(handlers)) delete handlers[key]
-})
-
-describe('executionStore execution lifecycle', () => {
-  it('reports zero progress while idle', () => {
-    const store = setup()
-    expect(store.totalNodesToExecute).toBe(0)
-    expect(store.nodesExecuted).toBe(0)
-    expect(store.executionProgress).toBe(0)
-  })
-
-  it('counts the queued nodes once a job starts', () => {
-    const store = setup()
-    startJob(store, 'job-1', ['a', 'b', 'c'])
-
-    expect(store.totalNodesToExecute).toBe(3)
-    expect(store.nodesExecuted).toBe(0)
-    expect(store.executionProgress).toBe(0)
-  })
-
-  it('advances progress as executed events arrive', () => {
-    const store = setup()
-    startJob(store, 'job-1', ['a', 'b', 'c'])
-
-    handlers['executed']?.({ detail: { node: 'a' } })
-    expect(store.nodesExecuted).toBe(1)
-    expect(store.executionProgress).toBeCloseTo(1 / 3)
-
-    handlers['executed']?.({ detail: { node: 'b' } })
-    handlers['executed']?.({ detail: { node: 'c' } })
-    expect(store.nodesExecuted).toBe(3)
-    expect(store.executionProgress).toBe(1)
-  })
-
-  it('ignores executed events when there is no active job', () => {
-    const store = setup()
-    handlers['executed']?.({ detail: { node: 'a' } })
-    expect(store.nodesExecuted).toBe(0)
-  })
-})

src/stores/executionNodeProgress.test.ts

@@ -1,131 +0,0 @@
-import { createPinia, setActivePinia } from 'pinia'
-import { beforeEach, describe, expect, it, vi } from 'vitest'
-import { ref } from 'vue'
-
-import { useExecutionStore } from '@/stores/executionStore'
-
-const { handlers } = vi.hoisted(() => ({
-  handlers: {} as Record<string, (e: { detail: unknown }) => void>
-}))
-
-vi.mock('@/scripts/app', () => ({ app: { rootGraph: {} } }))
-
-vi.mock('@/scripts/api', () => ({
-  api: {
-    addEventListener: (name: string, fn: (e: { detail: unknown }) => void) => {
-      handlers[name] = fn
-    },
-    removeEventListener: () => {}
-  }
-}))
-
-vi.mock('@/platform/workflow/management/stores/workflowStore', () => ({
-  useWorkflowStore: () => ({
-    isOpen: () => false,
-    openWorkflows: [],
-    nodeLocatorIdToNodeExecutionId: () => null
-  })
-}))
-
-vi.mock('@/renderer/core/canvas/canvasStore', () => ({
-  useCanvasStore: () => ({ canvas: undefined })
-}))
-
-vi.mock('@/stores/executionErrorStore', () => ({
-  useExecutionErrorStore: () => ({
-    clearExecutionStartErrors: () => {},
-    clearPromptError: () => {}
-  })
-}))
-
-vi.mock('@/stores/nodeOutputStore', () => ({
-  useNodeOutputStore: () => ({ revokePreviewsByExecutionId: () => {} })
-}))
-
-vi.mock('@/composables/useAppMode', () => ({
-  useAppMode: () => ({ mode: ref('default'), isAppMode: ref(false) })
-}))
-
-vi.mock('@/platform/telemetry', () => ({ useTelemetry: () => undefined }))
-
-vi.mock('@/utils/appMode', () => ({
-  getWorkflowMode: () => 'workflow',
-  isAppModeValue: () => false
-}))
-
-interface NodeState {
-  state: string
-  value?: number
-  max?: number
-  node_id?: string
-}
-
-function progressState(jobId: string, nodes: Record<string, NodeState>) {
-  handlers['progress_state']?.({ detail: { prompt_id: jobId, nodes } })
-}
-
-function setup() {
-  const store = useExecutionStore()
-  store.bindExecutionEvents()
-  return store
-}
-
-beforeEach(() => {
-  setActivePinia(createPinia())
-  for (const key of Object.keys(handlers)) delete handlers[key]
-})
-
-describe('executionStore node progress', () => {
-  it('is idle until an execution starts', () => {
-    const store = setup()
-    expect(store.isIdle).toBe(true)
-
-    handlers['execution_start']?.({ detail: { prompt_id: 'job-1' } })
-    expect(store.isIdle).toBe(false)
-  })
-
-  it('derives the running node ids from a progress_state event', () => {
-    const store = setup()
-
-    progressState('job-1', {
-      n1: { state: 'running', value: 1, max: 4 },
-      n2: { state: 'finished' },
-      n3: { state: 'pending' }
-    })
-
-    expect(store.executingNodeIds).toEqual(['n1'])
-    expect(store.executingNodeId).toBe('n1')
-  })
-
-  it('exposes fractional progress for the executing node', () => {
-    const store = setup()
-
-    progressState('job-1', {
-      n1: { state: 'running', value: 1, max: 4 }
-    })
-
-    expect(store.executingNodeProgress).toBe(0.25)
-  })
-
-  it('reports no executing node when none are running', () => {
-    const store = setup()
-
-    progressState('job-1', {
-      n1: { state: 'finished' },
-      n2: { state: 'pending' }
-    })
-
-    expect(store.executingNodeIds).toEqual([])
-    expect(store.executingNodeId).toBeNull()
-  })
-
-  it('replaces progress state on each progress_state event', () => {
-    const store = setup()
-
-    progressState('job-1', { n1: { state: 'running', value: 1, max: 4 } })
-    expect(store.executingNodeId).toBe('n1')
-
-    progressState('job-1', { n2: { state: 'running', value: 2, max: 2 } })
-    expect(store.executingNodeIds).toEqual(['n2'])
-  })
-})

src/stores/executionRunningState.test.ts

@@ -1,173 +0,0 @@
-import { createPinia, setActivePinia } from 'pinia'
-import { beforeEach, describe, expect, it, vi } from 'vitest'
-import { ref } from 'vue'
-
-import type { ComfyWorkflow } from '@/platform/workflow/management/stores/workflowStore'
-import type { ComfyApiWorkflow } from '@/platform/workflow/validation/schemas/workflowSchema'
-import { useExecutionStore } from '@/stores/executionStore'
-import type { classifyCloudValidationError } from '@/utils/executionErrorUtil'
-
-type CloudValidationResult = ReturnType<typeof classifyCloudValidationError>
-
-const { handlers, errorStore, activeWorkflow, dist, classifyCloud } =
-  vi.hoisted(() => ({
-    handlers: {} as Record<string, (e: { detail: unknown }) => void>,
-    errorStore: {
-      clearExecutionStartErrors: () => {},
-      clearPromptError: () => {}
-    } as Record<string, unknown>,
-    activeWorkflow: { value: null as { path: string } | null },
-    dist: { isCloud: false },
-    classifyCloud: vi.fn<(_: string) => CloudValidationResult>(() => null)
-  }))
-
-vi.mock('@/scripts/app', () => ({ app: { rootGraph: {} } }))
-vi.mock('@/scripts/api', () => ({
-  api: {
-    addEventListener: (name: string, fn: (e: { detail: unknown }) => void) => {
-      handlers[name] = fn
-    },
-    removeEventListener: () => {}
-  }
-}))
-vi.mock('@/platform/workflow/management/stores/workflowStore', () => ({
-  useWorkflowStore: () => ({
-    isOpen: () => true,
-    openWorkflows: [],
-    nodeLocatorIdToNodeExecutionId: () => null,
-    get activeWorkflow() {
-      return activeWorkflow.value
-    }
-  })
-}))
-vi.mock('@/renderer/core/canvas/canvasStore', () => ({
-  useCanvasStore: () => ({ canvas: undefined })
-}))
-vi.mock('@/stores/executionErrorStore', () => ({
-  useExecutionErrorStore: () => errorStore
-}))
-vi.mock('@/stores/nodeOutputStore', () => ({
-  useNodeOutputStore: () => ({ revokePreviewsByExecutionId: () => {} })
-}))
-vi.mock('@/composables/useAppMode', () => ({
-  useAppMode: () => ({ mode: ref('default'), isAppMode: ref(false) })
-}))
-vi.mock('@/platform/telemetry', () => ({ useTelemetry: () => undefined }))
-vi.mock('@/utils/appMode', () => ({
-  getWorkflowMode: () => 'workflow',
-  isAppModeValue: () => false
-}))
-vi.mock('@/platform/distribution/types', () => ({
-  get isCloud() {
-    return dist.isCloud
-  }
-}))
-vi.mock('@/platform/errorCatalog/accountPreconditionRouting', () => ({
-  resolveAccountPrecondition: () => null
-}))
-vi.mock('@/utils/executionErrorUtil', () => ({
-  classifyCloudValidationError: classifyCloud
-}))
-
-function setup() {
-  const store = useExecutionStore()
-  store.bindExecutionEvents()
-  return store
-}
-
-function workflow(path: string): ComfyWorkflow {
-  return { path } as unknown as ComfyWorkflow
-}
-
-function promptOutput(): ComfyApiWorkflow {
-  return {}
-}
-
-beforeEach(() => {
-  setActivePinia(createPinia())
-  for (const key of Object.keys(handlers)) delete handlers[key]
-  activeWorkflow.value = null
-  dist.isCloud = false
-  classifyCloud.mockReturnValue(null)
-  for (const k of ['lastPromptError', 'lastNodeErrors', 'lastExecutionError'])
-    delete errorStore[k]
-})
-
-describe('executionStore running state and error edges', () => {
-  it('lists jobs with a running node and counts running workflows', () => {
-    const store = setup()
-    handlers['progress_state']?.({
-      detail: {
-        prompt_id: 'job-1',
-        nodes: { n1: { state: 'running', value: 1, max: 2 } }
-      }
-    })
-
-    expect(store.runningJobIds).toEqual(['job-1'])
-    expect(store.runningWorkflowCount).toBe(1)
-  })
-
-  it('does not report the active workflow as running when the path differs', () => {
-    const store = setup()
-    expect(store.isActiveWorkflowRunning).toBe(false)
-
-    const wf = workflow('w.json')
-    activeWorkflow.value = { path: 'other.json' }
-    store.storeJob({
-      nodes: [],
-      id: 'job-2',
-      promptOutput: promptOutput(),
-      workflow: wf
-    })
-    handlers['execution_start']?.({ detail: { prompt_id: 'job-2' } })
-
-    expect(store.isActiveWorkflowRunning).toBe(false)
-  })
-
-  it('reports the active workflow as running when job, path and session agree', () => {
-    const store = setup()
-    const wf = workflow('w.json')
-    activeWorkflow.value = { path: 'w.json' }
-    store.storeJob({
-      nodes: [],
-      id: 'job-2',
-      promptOutput: promptOutput(),
-      workflow: wf
-    })
-    handlers['execution_start']?.({ detail: { prompt_id: 'job-2' } })
-
-    expect(store.isActiveWorkflowRunning).toBe(true)
-  })
-
-  it('formats a service-level error message from the exception message alone', () => {
-    setup()
-    handlers['execution_error']?.({
-      detail: { prompt_id: 'job-3', exception_message: 'Job has stagnated' }
-    })
-
-    expect(errorStore.lastPromptError).toEqual({
-      type: 'error',
-      message: 'Job has stagnated',
-      details: ''
-    })
-  })
-
-  it('stores a classified cloud prompt error on the prompt-error branch', () => {
-    dist.isCloud = true
-    classifyCloud.mockReturnValue({
-      kind: 'promptError',
-      promptError: { type: 'validation', message: 'bad input', details: '' }
-    })
-    setup()
-
-    handlers['execution_error']?.({
-      detail: { prompt_id: 'job-4', exception_message: '{}' }
-    })
-
-    expect(errorStore.lastPromptError).toEqual({
-      type: 'validation',
-      message: 'bad input',
-      details: ''
-    })
-  })
-})

src/stores/executionStore.test.ts

@@ -423,124 +423,6 @@ describe('useExecutionStore - nodeLocationProgressStates caching', () => {
       'running'
     )
   })
-
-  it('keeps an existing error state when later progress maps to the same locator', () => {
-    store.nodeProgressStates = {
-      node1: {
-        display_node_id: '123',
-        state: 'error',
-        value: 0,
-        max: 100,
-        prompt_id: 'test',
-        node_id: 'node1'
-      },
-      node2: {
-        display_node_id: '123:456',
-        state: 'running',
-        value: 50,
-        max: 100,
-        prompt_id: 'test',
-        node_id: 'node2'
-      }
-    }
-
-    expect(
-      store.nodeLocationProgressStates[createNodeLocatorId(null, toNodeId(123))]
-        .state
-    ).toBe('error')
-  })
-
-  it('ignores finished progress when current state is already running', () => {
-    store.nodeProgressStates = {
-      node1: {
-        display_node_id: '123',
-        state: 'running',
-        value: 5,
-        max: 10,
-        prompt_id: 'test',
-        node_id: 'node1'
-      },
-      node2: {
-        display_node_id: '123',
-        state: 'finished',
-        value: 10,
-        max: 10,
-        prompt_id: 'test',
-        node_id: 'node2'
-      }
-    }
-
-    expect(
-      store.nodeLocationProgressStates[createNodeLocatorId(null, toNodeId(123))]
-    ).toMatchObject({ state: 'running', value: 5 })
-  })
-
-  it('keeps later running progress from moving a locator backwards', () => {
-    store.nodeProgressStates = {
-      node1: {
-        display_node_id: '123',
-        state: 'running',
-        value: 6,
-        max: 10,
-        prompt_id: 'test',
-        node_id: 'node1'
-      },
-      node2: {
-        display_node_id: '123',
-        state: 'running',
-        value: 8,
-        max: 10,
-        prompt_id: 'test',
-        node_id: 'node2'
-      }
-    }
-
-    expect(
-      store.nodeLocationProgressStates[createNodeLocatorId(null, toNodeId(123))]
-    ).toMatchObject({ state: 'running', value: 6, max: 10 })
-  })
-
-  it('merges zero-max running progress without dividing by zero', () => {
-    store.nodeProgressStates = {
-      node1: {
-        display_node_id: '123',
-        state: 'pending',
-        value: 0,
-        max: 0,
-        prompt_id: 'test',
-        node_id: 'node1'
-      },
-      node2: {
-        display_node_id: '123',
-        state: 'running',
-        value: 0,
-        max: 0,
-        prompt_id: 'test',
-        node_id: 'node2'
-      }
-    }
-
-    expect(
-      store.nodeLocationProgressStates[createNodeLocatorId(null, toNodeId(123))]
-    ).toMatchObject({ state: 'running', value: 0, max: 0 })
-  })
-
-  it('skips nested progress when the execution id cannot be resolved', () => {
-    vi.mocked(app.rootGraph.getNodeById).mockReturnValue(null)
-    store.nodeProgressStates = {
-      node1: {
-        display_node_id: '404:1',
-        state: 'running',
-        value: 5,
-        max: 10,
-        prompt_id: 'test',
-        node_id: 'node1'
-      }
-    }
-
-    expect(store.nodeLocationProgressStates).toHaveProperty('404')
-    expect(store.nodeLocationProgressStates).not.toHaveProperty('404:1')
-  })
 })
 
 describe('useExecutionStore - nodeProgressStatesByJob eviction', () => {
@@ -669,31 +551,6 @@ describe('useExecutionStore - reconcileInitializingJobs', () => {
 
     expect(store.initializingJobIds).toEqual(new Set())
   })
-
-  it('clears initialization ids directly', () => {
-    store.initializingJobIds = new Set(['job-1'])
-
-    store.clearInitializationByJobId(null)
-    store.clearInitializationByJobId('missing')
-    store.clearInitializationByJobId('job-1')
-
-    expect(store.initializingJobIds).toEqual(new Set())
-  })
-
-  it('checks initializing jobs by stringified id', () => {
-    store.initializingJobIds = new Set(['7'])
-
-    expect(store.isJobInitializing(undefined)).toBe(false)
-    expect(store.isJobInitializing(7)).toBe(true)
-  })
-
-  it('does not rewrite initializing state when no requested ids are tracked', () => {
-    store.initializingJobIds = new Set(['job-1'])
-
-    store.clearInitializationByJobIds(['missing'])
-
-    expect(store.initializingJobIds).toEqual(new Set(['job-1']))
-  })
 })
 
 describe('useExecutionStore - workflowStatus', () => {
@@ -818,16 +675,6 @@ describe('useExecutionStore - workflowStatus', () => {
     expect(store.getWorkflowStatus(workflowA)).toBe('completed')
   })
 
-  it('leaves workflowStatus unchanged when open workflows are unchanged', async () => {
-    callStoreJob('job-a', workflowA)
-    fireExecutionSuccess('job-a')
-
-    mockOpenWorkflows.value = [workflowA, workflowB]
-    await nextTick()
-
-    expect(store.getWorkflowStatus(workflowA)).toBe('completed')
-  })
-
   it('sets failed on execution_error', () => {
     callStoreJob('job-1', workflowA)
     fireExecutionStart('job-1')
@@ -844,14 +691,6 @@ describe('useExecutionStore - workflowStatus', () => {
     expect(store.getWorkflowStatus(workflowA)).toBeUndefined()
   })
 
-  it('handles interrupt for a queued workflow with no active job', () => {
-    callStoreJob('job-1', workflowA)
-
-    fireExecutionInterrupted('job-1')
-
-    expect(store.getWorkflowStatus(workflowA)).toBeUndefined()
-  })
-
   it('evicts the oldest pending status once the buffer cap is exceeded', () => {
     // Each start with no matching storeJob buffers a 'running' status. One
     // past the cap evicts the oldest so the buffer can't grow unbounded.
@@ -1061,35 +900,6 @@ describe('useExecutionStore - progress_text startup guard', () => {
 
     expect(mockShowTextPreview).toHaveBeenCalledWith(mockNode, 'warming up')
   })
-
-  it('should ignore progress_text for another active prompt', async () => {
-    const mockNode = createMockLGraphNode({ id: 1 })
-    const { useCanvasStore } =
-      await import('@/renderer/core/canvas/canvasStore')
-    useCanvasStore().canvas = {
-      graph: { getNodeById: vi.fn(() => mockNode) }
-    } as unknown as LGraphCanvas
-    store.activeJobId = 'job-1'
-
-    fireProgressText({
-      nodeId: toNodeId('1'),
-      text: 'warming up',
-      prompt_id: 'job-2'
-    })
-
-    expect(mockShowTextPreview).not.toHaveBeenCalled()
-  })
-
-  it('should ignore progress_text without text or node id', () => {
-    fireProgressText({ nodeId: toNodeId('1'), text: '' })
-    fireProgressText({
-      nodeId: '' as ReturnType<typeof toNodeId>,
-      text: 'warming up'
-    })
-
-    expect(mockShowTextPreview).not.toHaveBeenCalled()
-  })
-
   it('should ignore nested progress_text when the execution ID cannot be mapped', async () => {
     const { useCanvasStore } =
       await import('@/renderer/core/canvas/canvasStore')
@@ -1105,19 +915,6 @@ describe('useExecutionStore - progress_text startup guard', () => {
     expect(mockExecutionIdToCurrentId).toHaveBeenCalledWith('1:2')
     expect(mockShowTextPreview).not.toHaveBeenCalled()
   })
-
-  it('should ignore progress_text when the current node id cannot be parsed', async () => {
-    const { useCanvasStore } =
-      await import('@/renderer/core/canvas/canvasStore')
-    useCanvasStore().canvas = {
-      graph: { getNodeById: vi.fn() }
-    } as unknown as LGraphCanvas
-    mockExecutionIdToCurrentId.mockReturnValue({})
-
-    fireProgressText({ nodeId: toNodeId('1:2'), text: 'warming up' })
-
-    expect(mockShowTextPreview).not.toHaveBeenCalled()
-  })
 })
 
 describe('useExecutionErrorStore - Node Error Lookups', () => {
@@ -1578,21 +1375,6 @@ describe('useExecutionStore - WebSocket event handlers', () => {
       expect(store.initializingJobIds.has('job-1')).toBe(false)
       expect(store.initializingJobIds.has('job-2')).toBe(true)
     })
-
-    it('captures a queued workflow path when the start event wins the race', () => {
-      store.queuedJobs = {
-        'job-1': {
-          nodes: {},
-          workflow: createQueuedWorkflow('/workflows/race.json')
-        }
-      }
-
-      fire('execution_start', { prompt_id: 'job-1', timestamp: 0 })
-
-      expect(store.jobIdToSessionWorkflowPath.get('job-1')).toBe(
-        '/workflows/race.json'
-      )
-    })
   })
 
   describe('execution_cached', () => {
@@ -1780,35 +1562,9 @@ describe('useExecutionStore - WebSocket event handlers', () => {
         is_app_mode: true
       })
     })
-
-    it('uses current mode when shared queued job has no queued mode snapshot', () => {
-      mockAppModeState.mode.value = 'app'
-      mockAppModeState.isAppMode.value = true
-      store.queuedJobs = {
-        'job-1': {
-          nodes: {},
-          shareId: 'share-1'
-        }
-      }
-
-      fire('execution_success', { prompt_id: 'job-1', timestamp: 0 })
-
-      expect(mockTrackSharedWorkflowRun).toHaveBeenCalledWith({
-        job_id: 'job-1',
-        share_id: 'share-1',
-        view_mode: 'app',
-        is_app_mode: true
-      })
-    })
   })
 
   describe('executing', () => {
-    it('is a no-op when there is no active job', () => {
-      fire('executing', null)
-
-      expect(store.activeJobId).toBeNull()
-    })
-
     it('clears _executingNodeProgress and activeJobId when detail is null', () => {
       fire('execution_start', { prompt_id: 'job-1', timestamp: 0 })
       store._executingNodeProgress = {
@@ -1834,31 +1590,7 @@ describe('useExecutionStore - WebSocket event handlers', () => {
     })
   })
 
-  describe('progress_state', () => {
-    it('does not revoke previews when the node execution id is invalid', () => {
-      fire('progress_state', {
-        prompt_id: 'job-1',
-        nodes: {
-          '': {
-            value: 1,
-            max: 2,
-            state: 'running',
-            node_id: '',
-            display_node_id: '',
-            prompt_id: 'job-1'
-          }
-        }
-      })
-
-      expect(store.nodeProgressStates).toHaveProperty('')
-    })
-  })
-
   describe('progress', () => {
-    it('reports null executing node progress before progress events arrive', () => {
-      expect(store.executingNodeProgress).toBeNull()
-    })
-
     it('sets _executingNodeProgress from the event payload', () => {
       const payload = { value: 3, max: 10, prompt_id: 'job-1', node: 'n1' }
 
@@ -1878,18 +1610,6 @@ describe('useExecutionStore - WebSocket event handlers', () => {
       expect(store.clientId).toBe('test-client')
       expect(removeSpy).toHaveBeenCalledWith('status', expect.any(Function))
     })
-
-    it('keeps listening when status arrives before clientId is available', async () => {
-      const apiModule = await import('@/scripts/api')
-      const removeSpy = vi.mocked(apiModule.api.removeEventListener)
-      apiModule.api.clientId = ''
-
-      fire('status', { exec_info: { queue_remaining: 0 } })
-
-      expect(store.clientId).toBeNull()
-      expect(removeSpy).not.toHaveBeenCalledWith('status', expect.any(Function))
-      apiModule.api.clientId = 'test-client'
-    })
   })
 
   describe('execution_error', () => {
@@ -1911,39 +1631,6 @@ describe('useExecutionStore - WebSocket event handlers', () => {
       })
     })
 
-    it('uses the message directly for service-level errors without a type', () => {
-      const errorStore = useExecutionErrorStore()
-
-      fire('execution_error', {
-        prompt_id: 'job-1',
-        node_id: null,
-        exception_message: 'Job failed before node execution',
-        traceback: []
-      })
-
-      expect(errorStore.lastPromptError).toMatchObject({
-        type: 'error',
-        message: 'Job failed before node execution',
-        details: ''
-      })
-    })
-
-    it('uses an empty prompt message for service-level errors without backend copy', () => {
-      const errorStore = useExecutionErrorStore()
-
-      fire('execution_error', {
-        prompt_id: 'job-1',
-        node_id: null,
-        traceback: []
-      })
-
-      expect(errorStore.lastPromptError).toMatchObject({
-        type: 'error',
-        message: '',
-        details: ''
-      })
-    })
-
     it('routes a runtime error (with node_id) to lastExecutionError', () => {
       const errorStore = useExecutionErrorStore()
 
@@ -2057,12 +1744,6 @@ describe('useExecutionStore - WebSocket event handlers', () => {
 
       expect(store.initializingJobIds.has('job-9')).toBe(false)
     })
-
-    it('ignores notifications without text', () => {
-      fire('notification', { id: 'job-9' })
-
-      expect(store.initializingJobIds.has('job-9')).toBe(false)
-    })
   })
 
   describe('unbindExecutionEvents', () => {
@@ -2132,45 +1813,6 @@ describe('useExecutionStore - storeJob and workflow path tracking', () => {
     )
   })
 
-  it('storeJob works without workflow metadata', () => {
-    const workflow = {} as Parameters<typeof store.storeJob>[0]['workflow']
-    const missingWorkflow = undefined as unknown as Parameters<
-      typeof store.storeJob
-    >[0]['workflow']
-
-    store.storeJob({
-      nodes: ['a'],
-      id: 'job-1',
-      promptOutput: {
-        a: createPromptNode('Node A', 'NodeA')
-      },
-      workflow
-    })
-
-    expect(store.queuedJobs['job-1']?.nodes).toEqual({ a: false })
-    expect(store.jobIdToWorkflowId.has('job-1')).toBe(false)
-    expect(store.jobIdToSessionWorkflowPath.has('job-1')).toBe(false)
-
-    store.storeJob({
-      nodes: ['b'],
-      id: 'job-2',
-      promptOutput: {
-        b: createPromptNode('Node B', 'NodeB')
-      },
-      workflow: missingWorkflow
-    })
-
-    expect(store.queuedJobs['job-2']?.nodes).toEqual({ b: false })
-    expect(store.queuedJobs['job-2']?.workflow).toBeUndefined()
-  })
-
-  it('reports zero execution progress for an active job with no nodes', () => {
-    store.activeJobId = 'job-1'
-    store.queuedJobs = { 'job-1': { nodes: {} } }
-
-    expect(store.executionProgress).toBe(0)
-  })
-
   it('registerJobWorkflowIdMapping ignores empty inputs', () => {
     store.registerJobWorkflowIdMapping('job-1', 'wf-1')
     store.registerJobWorkflowIdMapping('', 'wf-2')
@@ -2187,58 +1829,4 @@ describe('useExecutionStore - storeJob and workflow path tracking', () => {
 
     expect(store.jobIdToSessionWorkflowPath.get('job-1')).toBe('/b.json')
   })
-
-  it('evicts the oldest workflow paths when the session map exceeds capacity', () => {
-    for (let i = 0; i < 4001; i++) {
-      store.ensureSessionWorkflowPath(`job-${i}`, `/workflow-${i}.json`)
-    }
-
-    expect(store.jobIdToSessionWorkflowPath.size).toBe(4000)
-    expect(store.jobIdToSessionWorkflowPath.has('job-0')).toBe(false)
-    expect(store.jobIdToSessionWorkflowPath.get('job-4000')).toBe(
-      '/workflow-4000.json'
-    )
-  })
-
-  it('reports whether the active workflow is running', () => {
-    mockActiveWorkflow.value = { path: '/workflows/foo.json' }
-    store.activeJobId = 'job-1'
-    store.ensureSessionWorkflowPath('job-1', '/workflows/foo.json')
-
-    expect(store.isActiveWorkflowRunning).toBe(true)
-
-    store.ensureSessionWorkflowPath('job-1', '/workflows/bar.json')
-    expect(store.isActiveWorkflowRunning).toBe(false)
-
-    mockActiveWorkflow.value = {}
-    expect(store.isActiveWorkflowRunning).toBe(false)
-  })
-
-  it('counts running jobs from progress state', () => {
-    store.nodeProgressStatesByJob = {
-      'job-1': {
-        a: {
-          value: 1,
-          max: 10,
-          state: 'running',
-          node_id: 'a',
-          display_node_id: 'a',
-          prompt_id: 'job-1'
-        }
-      },
-      'job-2': {
-        b: {
-          value: 10,
-          max: 10,
-          state: 'finished',
-          node_id: 'b',
-          display_node_id: 'b',
-          prompt_id: 'job-2'
-        }
-      }
-    }
-
-    expect(store.runningJobIds).toEqual(['job-1'])
-    expect(store.runningWorkflowCount).toBe(1)
-  })
 })

src/stores/executionStore.ts

@@ -153,9 +153,9 @@ export const useExecutionStore = defineStore('execution', () => {
     pendingWorkflowStatusByJobId.delete(jobId)
     pendingWorkflowStatusByJobId.set(jobId, status)
     while (pendingWorkflowStatusByJobId.size > MAX_PROGRESS_JOBS) {
-      pendingWorkflowStatusByJobId.delete(
-        pendingWorkflowStatusByJobId.keys().next().value as string
-      )
+      const oldest = pendingWorkflowStatusByJobId.keys().next().value
+      if (oldest === undefined) break
+      pendingWorkflowStatusByJobId.delete(oldest)
     }
   }
 
@@ -314,8 +314,8 @@ export const useExecutionStore = defineStore('execution', () => {
       : null
   )
 
-  const activeJob = computed<QueuedJob | undefined>(() =>
-    activeJobId.value ? queuedJobs.value[activeJobId.value] : undefined
+  const activeJob = computed<QueuedJob | undefined>(
+    () => queuedJobs.value[activeJobId.value ?? '']
   )
 
   const totalNodesToExecute = computed<number>(() => {
@@ -440,7 +440,9 @@ export const useExecutionStore = defineStore('execution', () => {
 
     // Update the executing nodes list
     if (e.detail == null) {
-      delete queuedJobs.value[activeJobId.value as JobId]
+      if (activeJobId.value) {
+        delete queuedJobs.value[activeJobId.value]
+      }
       activeJobId.value = null
     }
   }
@@ -591,7 +593,7 @@ export const useExecutionStore = defineStore('execution', () => {
   function handleCloudValidationError(
     detail: ExecutionErrorWsMessage
   ): boolean {
-    const result = classifyCloudValidationError(detail.exception_message ?? '')
+    const result = classifyCloudValidationError(detail.exception_message)
     if (!result) return false
 
     clearInitializationByJobId(detail.prompt_id)
@@ -667,14 +669,17 @@ export const useExecutionStore = defineStore('execution', () => {
   /**
    * Reset execution-related state after a run completes or is stopped.
    */
-  function resetExecutionState(jobId: JobId) {
+  function resetExecutionState(jobIdParam?: JobId | null) {
     executionIdToLocatorCache.clear()
     nodeProgressStates.value = {}
-    const map = { ...nodeProgressStatesByJob.value }
-    delete map[jobId]
-    nodeProgressStatesByJob.value = map
-    useJobPreviewStore().clearPreview(jobId)
-    jobIdToWorkflow.delete(jobId)
+    const jobId = jobIdParam ?? activeJobId.value ?? null
+    if (jobId) {
+      const map = { ...nodeProgressStatesByJob.value }
+      delete map[jobId]
+      nodeProgressStatesByJob.value = map
+      useJobPreviewStore().clearPreview(jobId)
+      jobIdToWorkflow.delete(jobId)
+    }
     if (activeJobId.value) {
       delete queuedJobs.value[activeJobId.value]
     }
@@ -766,7 +771,9 @@ export const useExecutionStore = defineStore('execution', () => {
     const next = new Map(jobIdToSessionWorkflowPath.value)
     next.set(jobId, path)
     while (next.size > MAX_SESSION_PATH_ENTRIES) {
-      next.delete(next.keys().next().value as JobId)
+      const oldest = next.keys().next().value
+      if (oldest !== undefined) next.delete(oldest)
+      else break
     }
     jobIdToSessionWorkflowPath.value = next
   }

src/stores/executionWorkflowStatus.test.ts

@@ -1,153 +0,0 @@
-import { createPinia, setActivePinia } from 'pinia'
-import { beforeEach, describe, expect, it, vi } from 'vitest'
-import { ref } from 'vue'
-
-import type { ComfyWorkflow } from '@/platform/workflow/management/stores/workflowStore'
-import type { ComfyApiWorkflow } from '@/platform/workflow/validation/schemas/workflowSchema'
-import { useExecutionStore } from '@/stores/executionStore'
-
-const { handlers, openSet } = vi.hoisted(() => ({
-  handlers: {} as Record<string, (e: { detail: unknown }) => void>,
-  openSet: new Set<unknown>()
-}))
-
-vi.mock('@/scripts/app', () => ({ app: { rootGraph: {} } }))
-
-vi.mock('@/scripts/api', () => ({
-  api: {
-    addEventListener: (name: string, fn: (e: { detail: unknown }) => void) => {
-      handlers[name] = fn
-    },
-    removeEventListener: () => {}
-  }
-}))
-
-vi.mock('@/platform/workflow/management/stores/workflowStore', () => ({
-  useWorkflowStore: () => ({
-    isOpen: (workflow: unknown) => openSet.has(workflow),
-    openWorkflows: [],
-    nodeLocatorIdToNodeExecutionId: () => null
-  })
-}))
-
-vi.mock('@/renderer/core/canvas/canvasStore', () => ({
-  useCanvasStore: () => ({ canvas: undefined })
-}))
-
-vi.mock('@/stores/executionErrorStore', () => ({
-  useExecutionErrorStore: () => ({
-    clearExecutionStartErrors: () => {},
-    clearPromptError: () => {}
-  })
-}))
-
-vi.mock('@/composables/useAppMode', () => ({
-  useAppMode: () => ({ mode: ref('default'), isAppMode: ref(false) })
-}))
-
-vi.mock('@/platform/telemetry', () => ({ useTelemetry: () => undefined }))
-
-vi.mock('@/utils/appMode', () => ({
-  getWorkflowMode: () => 'workflow',
-  isAppModeValue: () => false
-}))
-
-function workflow(path: string): ComfyWorkflow {
-  return { path } as unknown as ComfyWorkflow
-}
-
-function promptOutput(): ComfyApiWorkflow {
-  return {}
-}
-
-function storeJob(
-  store: ReturnType<typeof useExecutionStore>,
-  id: string,
-  wf: ComfyWorkflow
-) {
-  store.storeJob({ nodes: [], id, promptOutput: promptOutput(), workflow: wf })
-}
-
-function fire(event: string, jobId: string) {
-  handlers[event]?.({ detail: { prompt_id: jobId } })
-}
-
-function setup() {
-  const store = useExecutionStore()
-  store.bindExecutionEvents()
-  return store
-}
-
-beforeEach(() => {
-  setActivePinia(createPinia())
-  for (const key of Object.keys(handlers)) delete handlers[key]
-  openSet.clear()
-})
-
-describe('executionStore workflow status', () => {
-  it('marks an open workflow running on execution_start and completed on success', () => {
-    const store = setup()
-    const wf = workflow('a.json')
-    openSet.add(wf)
-    storeJob(store, 'job-1', wf)
-
-    fire('execution_start', 'job-1')
-    expect(store.getWorkflowStatus(wf)).toBe('running')
-
-    fire('execution_success', 'job-1')
-    expect(store.getWorkflowStatus(wf)).toBe('completed')
-  })
-
-  it('buffers a status that arrives before the job is attached, then flushes on storeJob', () => {
-    const store = setup()
-    const wf = workflow('b.json')
-    openSet.add(wf)
-
-    fire('execution_start', 'job-2')
-    expect(store.getWorkflowStatus(wf)).toBeUndefined()
-
-    storeJob(store, 'job-2', wf)
-    expect(store.getWorkflowStatus(wf)).toBe('running')
-  })
-
-  it('does not apply status to a workflow that is not open', () => {
-    const store = setup()
-    const wf = workflow('c.json')
-    storeJob(store, 'job-3', wf)
-
-    fire('execution_start', 'job-3')
-    expect(store.getWorkflowStatus(wf)).toBeUndefined()
-  })
-
-  it('clears a workflow status', () => {
-    const store = setup()
-    const wf = workflow('d.json')
-    openSet.add(wf)
-    storeJob(store, 'job-4', wf)
-    fire('execution_start', 'job-4')
-    expect(store.getWorkflowStatus(wf)).toBe('running')
-
-    store.clearWorkflowStatus(wf)
-    expect(store.getWorkflowStatus(wf)).toBeUndefined()
-  })
-
-  it('does not let a late buffered running overwrite a terminal status', () => {
-    const store = setup()
-    const wf = workflow('e.json')
-    openSet.add(wf)
-
-    storeJob(store, 'job-5', wf)
-    fire('execution_success', 'job-5')
-    expect(store.getWorkflowStatus(wf)).toBe('completed')
-
-    fire('execution_start', 'job-6')
-    storeJob(store, 'job-6', wf)
-    expect(store.getWorkflowStatus(wf)).toBe('completed')
-  })
-
-  it('returns undefined for a null or unknown workflow', () => {
-    const store = setup()
-    expect(store.getWorkflowStatus(null)).toBeUndefined()
-    expect(store.getWorkflowStatus(workflow('unknown.json'))).toBeUndefined()
-  })
-})

src/stores/jobPreviewStore.test.ts

@@ -1,6 +1,6 @@
 import { createPinia, setActivePinia } from 'pinia'
 import { beforeEach, describe, expect, it, vi } from 'vitest'
-import { nextTick, ref } from 'vue'
+import { ref } from 'vue'
 
 import { useJobPreviewStore } from '@/stores/jobPreviewStore'
 import { releaseSharedObjectUrl } from '@/utils/objectUrlUtil'
@@ -71,14 +71,6 @@ describe('jobPreviewStore', () => {
     expect(store.previewsByPromptId).toEqual({ p2: 'blob:b' })
   })
 
-  it('ignores clearPreview without a prompt id', () => {
-    const store = useJobPreviewStore()
-
-    store.clearPreview(undefined)
-
-    expect(store.nodePreviewsByPromptId).toEqual({})
-  })
-
   it('clears all previews', () => {
     const store = useJobPreviewStore()
     store.setPreviewUrl('p1', 'blob:a', 'node-1')
@@ -99,24 +91,6 @@ describe('jobPreviewStore', () => {
     expect(releaseSharedObjectUrl).not.toHaveBeenCalled()
   })
 
-  it('ignores missing prompt ids', () => {
-    const store = useJobPreviewStore()
-
-    store.setPreviewUrl(undefined, 'blob:a', 'node-1')
-
-    expect(store.nodePreviewsByPromptId).toEqual({})
-  })
-
-  it('releases the old url when replacing a preview', () => {
-    const store = useJobPreviewStore()
-    store.setPreviewUrl('p1', 'blob:a', 'node-1')
-
-    store.setPreviewUrl('p1', 'blob:b', 'node-1')
-
-    expect(releaseSharedObjectUrl).toHaveBeenCalledWith('blob:a')
-    expect(store.nodePreviewsByPromptId['p1']?.url).toBe('blob:b')
-  })
-
   it('ignores setPreviewUrl when previews are disabled', () => {
     previewMethodRef.value = 'none'
     const store = useJobPreviewStore()
@@ -125,15 +99,4 @@ describe('jobPreviewStore', () => {
 
     expect(store.nodePreviewsByPromptId).toEqual({})
   })
-
-  it('clears previews when previews are disabled after storage', async () => {
-    const store = useJobPreviewStore()
-    store.setPreviewUrl('p1', 'blob:a', 'node-1')
-
-    previewMethodRef.value = 'none'
-    await nextTick()
-
-    expect(store.nodePreviewsByPromptId).toEqual({})
-    expect(releaseSharedObjectUrl).toHaveBeenCalledWith('blob:a')
-  })
 })

src/stores/menuItemStore.test.ts

@@ -1,149 +0,0 @@
-import { createTestingPinia } from '@pinia/testing'
-import { setActivePinia } from 'pinia'
-import type { MenuItem } from 'primevue/menuitem'
-import { beforeEach, describe, expect, it, vi } from 'vitest'
-
-import { useCommandStore } from '@/stores/commandStore'
-import { useMenuItemStore } from '@/stores/menuItemStore'
-
-const canvasStoreMock = vi.hoisted(() => ({ linearMode: false }))
-
-vi.mock('@/constants/coreMenuCommands', () => ({
-  CORE_MENU_COMMANDS: [[['Core'], ['core.command']]]
-}))
-
-vi.mock('@/composables/useErrorHandling', () => ({
-  useErrorHandling: () => ({
-    wrapWithErrorHandlingAsync:
-      (fn: () => Promise<void>, errorHandler?: (e: unknown) => void) =>
-      async () => {
-        try {
-          await fn()
-        } catch (e) {
-          if (errorHandler) errorHandler(e)
-          else throw e
-        }
-      }
-  })
-}))
-
-vi.mock('@/platform/keybindings/keybindingStore', () => ({
-  useKeybindingStore: () => ({
-    getKeybindingByCommandId: () => null
-  })
-}))
-
-vi.mock('@/renderer/core/canvas/canvasStore', () => ({
-  useCanvasStore: () => canvasStoreMock
-}))
-
-describe('menuItemStore', () => {
-  beforeEach(() => {
-    setActivePinia(createTestingPinia({ stubActions: false }))
-    canvasStoreMock.linearMode = false
-  })
-
-  it('records that linear mode has been seen', () => {
-    canvasStoreMock.linearMode = true
-
-    const store = useMenuItemStore()
-
-    expect(store.hasSeenLinear).toBe(true)
-  })
-
-  it('creates nested groups, separators, and active-state metadata', () => {
-    const store = useMenuItemStore()
-    const activeItem: MenuItem = {
-      label: 'Active',
-      comfyCommand: { id: 'active', function: vi.fn(), active: () => true }
-    }
-    const plainItem: MenuItem = { label: 'Plain' }
-
-    store.registerMenuGroup(['File', 'Export'], [activeItem])
-    store.registerMenuGroup(['File', 'Export'], [plainItem])
-
-    const file = store.menuItems[0]
-    const exportGroup = file.items?.[0]
-
-    expect(file.label).toBe('File')
-    expect(exportGroup?.items).toEqual([
-      activeItem,
-      { separator: true },
-      plainItem
-    ])
-    expect(store.menuItemHasActiveStateChildren['File.Export']).toBe(true)
-  })
-
-  it('repairs existing group items before appending children', () => {
-    const store = useMenuItemStore()
-    store.menuItems.push({ label: 'Tools' })
-
-    store.registerMenuGroup(['Tools'], [{ label: 'Child' }])
-
-    expect(store.menuItems[0].items).toEqual([{ label: 'Child' }])
-  })
-
-  it('maps command ids to executable menu items', async () => {
-    const commandStore = useCommandStore()
-    const fn = vi.fn()
-    commandStore.registerCommand({
-      id: 'test.command',
-      function: fn,
-      icon: 'icon-[lucide--test]',
-      label: 'Label',
-      menubarLabel: 'Menu Label',
-      tooltip: 'Tip'
-    })
-
-    const store = useMenuItemStore()
-    const item = store.commandIdToMenuItem('test.command', ['Tools'])
-    await item.command?.({ originalEvent: new Event('click'), item })
-
-    expect(fn).toHaveBeenCalled()
-    expect(item).toMatchObject({
-      label: 'Menu Label',
-      icon: 'icon-[lucide--test]',
-      tooltip: 'Tip',
-      parentPath: 'Tools'
-    })
-  })
-
-  it('loads extension menu commands only for commands owned by the extension', () => {
-    const commandStore = useCommandStore()
-    commandStore.registerCommand({
-      id: 'owned',
-      function: vi.fn(),
-      menubarLabel: 'Owned'
-    })
-
-    const store = useMenuItemStore()
-    store.loadExtensionMenuCommands({
-      name: 'extension',
-      commands: [{ id: 'owned', function: vi.fn() }],
-      menuCommands: [{ path: ['Tools'], commands: ['owned', 'external'] }]
-    })
-    store.loadExtensionMenuCommands({ name: 'plain' })
-    store.loadExtensionMenuCommands({
-      name: 'empty',
-      menuCommands: [{ path: ['Tools'], commands: ['missing'] }]
-    })
-
-    expect(store.menuItems[0].items?.map((item) => item.label)).toEqual([
-      'Owned'
-    ])
-  })
-
-  it('registers core menu commands', () => {
-    const commandStore = useCommandStore()
-    commandStore.registerCommand({
-      id: 'core.command',
-      function: vi.fn(),
-      menubarLabel: 'Core Command'
-    })
-
-    const store = useMenuItemStore()
-    store.registerCoreMenuCommands()
-
-    expect(store.menuItems[0].items?.[0].label).toBe('Core Command')
-  })
-})

src/stores/modelStore.test.ts

@@ -137,88 +137,6 @@ describe('useModelStore', () => {
     expect(model.resolution).toBe('')
   })
 
-  it('keeps the default model metadata when the server returns null', async () => {
-    enableMocks()
-    vi.mocked(api.viewMetadata).mockResolvedValueOnce(null)
-    store = useModelStore()
-    await store.loadModelFolders()
-    const folderStore = await store.getLoadedModelFolder('checkpoints')
-    const model = folderStore!.models['0/sdxl.safetensors']
-
-    await model.load()
-
-    expect(model.title).toBe('sdxl')
-    expect(model.has_loaded_metadata).toBe(false)
-  })
-
-  it('loads model metadata once', async () => {
-    enableMocks()
-    store = useModelStore()
-    await store.loadModelFolders()
-    const folderStore = await store.getLoadedModelFolder('checkpoints')
-    const model = folderStore!.models['0/sdxl.safetensors']
-
-    await model.load()
-    await model.load()
-
-    expect(api.viewMetadata).toHaveBeenCalledTimes(1)
-  })
-
-  it('keeps the default title when the first metadata key is empty', async () => {
-    enableMocks()
-    vi.mocked(api.viewMetadata).mockResolvedValueOnce({
-      'modelspec.title': '',
-      display_name: 'Fallback title'
-    })
-    store = useModelStore()
-    await store.loadModelFolders()
-    const folderStore = await store.getLoadedModelFolder('checkpoints')
-    const model = folderStore!.models['0/sdxl.safetensors']
-
-    await model.load()
-
-    expect(model.title).toBe('sdxl')
-  })
-
-  it('returns null for unknown loaded model folders', async () => {
-    enableMocks()
-    store = useModelStore()
-    await store.loadModelFolders()
-
-    await expect(store.getLoadedModelFolder('missing')).resolves.toBeNull()
-  })
-
-  it('should read metadata from suffixed keys and ignore null values', async () => {
-    enableMocks()
-    vi.mocked(api.viewMetadata).mockResolvedValueOnce({
-      'custom.modelspec.title': 'Namespaced title',
-      'custom.modelspec.author': null,
-      'custom.modelspec.tags': null
-    })
-    store = useModelStore()
-    await store.loadModelFolders()
-    const folderStore = await store.getLoadedModelFolder('checkpoints')
-    const model = folderStore!.models['0/sdxl.safetensors']
-
-    await model.load()
-
-    expect(model.title).toBe('Namespaced title')
-    expect(model.author).toBe('')
-    expect(model.tags).toEqual([''])
-  })
-
-  it('should keep extensions for non-safetensors files', async () => {
-    enableMocks()
-    vi.mocked(api.getModels).mockResolvedValueOnce([
-      { name: 'notes.txt', pathIndex: 0 }
-    ])
-    store = useModelStore()
-    await store.loadModelFolders()
-    const folderStore = await store.getLoadedModelFolder('checkpoints')
-
-    expect(folderStore!.models['0/notes.txt'].title).toBe('notes.txt')
-  })
-
   it('should cache model information', async () => {
     enableMocks()
     store = useModelStore()
@@ -291,23 +209,6 @@ describe('useModelStore', () => {
       expect(api.getModelFolders).toHaveBeenCalledTimes(2)
       expect(api.getModels).not.toHaveBeenCalled()
     })
-
-    it('does not reload previously loaded folders that disappear', async () => {
-      enableMocks()
-      store = useModelStore()
-      await store.loadModelFolders()
-      await store.getLoadedModelFolder('checkpoints')
-      vi.mocked(api.getModelFolders).mockResolvedValueOnce([
-        { name: 'vae', folders: ['/path/to/vae'] }
-      ])
-
-      await store.refresh()
-
-      expect(store.modelFolders.map((folder) => folder.directory)).toEqual([
-        'vae'
-      ])
-      expect(api.getModels).toHaveBeenCalledTimes(1)
-    })
   })
 
   describe('API switching functionality', () => {

src/stores/modelStore.ts

@@ -69,9 +69,7 @@ export class ComfyModelDef {
     this.path_index = pathIndex
     this.file_name = name
     this.normalized_file_name = name.replaceAll('\\', '/')
-    this.simplified_file_name = this.normalized_file_name.slice(
-      this.normalized_file_name.lastIndexOf('/') + 1
-    )
+    this.simplified_file_name = this.normalized_file_name.split('/').pop() ?? ''
     if (this.simplified_file_name.endsWith('.safetensors')) {
       this.simplified_file_name = this.simplified_file_name.slice(
         0,

src/stores/modelToNodeStore.test.ts

@@ -138,22 +138,6 @@ describe('useModelToNodeStore', () => {
       expect(provider?.key).toBe('ckpt_name')
     })
 
-    it('omits providers whose node definition is unavailable from reverse lookup', () => {
-      const modelToNodeStore = useModelToNodeStore()
-      modelToNodeStore.modelToNodeMap = {
-        missing: [
-          new ModelNodeProvider(
-            undefined as unknown as ComfyNodeDefImpl,
-            'model'
-          )
-        ]
-      }
-
-      expect(modelToNodeStore.getRegisteredNodeTypes()).not.toHaveProperty(
-        'undefined'
-      )
-    })
-
     it('should return undefined for unregistered model type', () => {
       const modelToNodeStore = useModelToNodeStore()
       modelToNodeStore.registerDefaults()
@@ -593,22 +577,6 @@ describe('useModelToNodeStore', () => {
       expect(modelToNodeStore.getCategoryForNodeType('')).toBeUndefined()
     })
 
-    it('skips providers without node definitions during category lookup', () => {
-      const modelToNodeStore = useModelToNodeStore()
-      modelToNodeStore.modelToNodeMap = {
-        missing: [
-          new ModelNodeProvider(
-            undefined as unknown as ComfyNodeDefImpl,
-            'model'
-          )
-        ]
-      }
-
-      expect(
-        modelToNodeStore.getCategoryForNodeType('MissingNode')
-      ).toBeUndefined()
-    })
-
     it('maps the IC-LoRA Loader Model Only node to loras so its lora_name dropdown uses the cloud asset browser (FE-838)', () => {
       const modelToNodeStore = useModelToNodeStore()
       modelToNodeStore.registerDefaults()