Support partial graph execution

Patch version increment to 1.48.2

**Base branch:** `main`

---------

Co-authored-by: christian-byrne <72887196+christian-byrne@users.noreply.github.com>
Co-authored-by: github-actions <github-actions@github.com>
Co-authored-by: Christian Byrne <cbyrne@comfy.org>

.github/workflows/ci-website-build.yaml

@@ -40,3 +40,6 @@ jobs:
           WEBSITE_ASHBY_API_KEY: ${{ secrets.WEBSITE_ASHBY_API_KEY }}
           WEBSITE_ASHBY_JOB_BOARD_NAME: ${{ secrets.WEBSITE_ASHBY_JOB_BOARD_NAME }}
         run: pnpm --filter @comfyorg/website build
+
+      - name: Validate JSON-LD structured data
+        run: pnpm --filter @comfyorg/website validate:jsonld

.github/workflows/cla.yml

@@ -38,9 +38,11 @@ jobs:
           PR_NUMBER: ${{ github.event.pull_request.number || github.event.issue.number }}
           PR_AUTHOR: ${{ github.event.pull_request.user.login || github.event.issue.user.login }}
           BASE_ALLOWLIST: action@github.com,actions-user,ampagent,claude,comfy-pr-bot,GitHub Action,github-actions,github-actions[bot],Glary Bot,Glary-Bot,*[bot]
+        # For each commit emit the GitHub login when the author/committer email resolves to a GitHub account
+        # otherwise fall back to the raw git name.
         run: |
           others=$(gh api "repos/${{ github.repository }}/pulls/${PR_NUMBER}/commits" --paginate \
-            --jq '.[] | (.author.login // empty), (.committer.login // empty)' \
+            --jq '.[] | (.author.login // .commit.author.name // empty), (.committer.login // .commit.committer.name // empty)' \
             | sort -u | grep -vix "${PR_AUTHOR}" | paste -sd, -)
           if [ -n "$others" ]; then
             echo "allowlist=${BASE_ALLOWLIST},${others}" >> "$GITHUB_OUTPUT"

.github/workflows/pr-backport.yaml

@@ -278,32 +278,49 @@ jobs:
               continue
             fi
 
-            # Create backport branch
-            git checkout -b "${BACKPORT_BRANCH}" "origin/${TARGET_BRANCH}"
+            # Create backport branch. A failure here (e.g. dirty state left
+            # by a prior target) must not abort the loop and skip remaining
+            # targets, so fall back to a clean checkout and record the error.
+            if ! git checkout -B "${BACKPORT_BRANCH}" "origin/${TARGET_BRANCH}"; then
+              echo "::error::Failed to create branch ${BACKPORT_BRANCH} for ${TARGET_BRANCH}"
+              FAILED="${FAILED}${TARGET_BRANCH}:branch-create-failed "
+              git checkout main || git checkout -f main
+              echo "::endgroup::"
+              continue
+            fi
 
             # Try cherry-pick
             if git cherry-pick "${MERGE_COMMIT}"; then
               if [ "$REMOTE_BACKPORT_EXISTS" = true ]; then
-                git push --force-with-lease origin "${BACKPORT_BRANCH}"
+                PUSH_CMD=(git push --force-with-lease origin "${BACKPORT_BRANCH}")
               else
-                git push origin "${BACKPORT_BRANCH}"
+                PUSH_CMD=(git push origin "${BACKPORT_BRANCH}")
               fi
-              echo "${BACKPORT_BRANCH}" >> "$CREATED_BRANCHES_FILE"
-              SUCCESS="${SUCCESS}${TARGET_BRANCH}:${BACKPORT_BRANCH} "
-              echo "Successfully created backport branch: ${BACKPORT_BRANCH}"
+
+              # A push failure for one target must not abort the loop and
+              # prevent remaining targets from being attempted.
+              if "${PUSH_CMD[@]}"; then
+                echo "${BACKPORT_BRANCH}" >> "$CREATED_BRANCHES_FILE"
+                SUCCESS="${SUCCESS}${TARGET_BRANCH}:${BACKPORT_BRANCH} "
+                echo "Successfully created backport branch: ${BACKPORT_BRANCH}"
+              else
+                echo "::error::Failed to push ${BACKPORT_BRANCH} for ${TARGET_BRANCH}"
+                FAILED="${FAILED}${TARGET_BRANCH}:push-failed "
+              fi
+
               # Return to main (keep the branch, we need it for PR)
-              git checkout main
+              git checkout main || git checkout -f main
             else
               # Get conflict info
               CONFLICTS=$(git diff --name-only --diff-filter=U | tr '\n' ',')
-              git cherry-pick --abort
+              git cherry-pick --abort || true
 
               echo "::error::Cherry-pick failed due to conflicts"
               FAILED="${FAILED}${TARGET_BRANCH}:conflicts:${CONFLICTS} "
 
               # Clean up the failed branch
-              git checkout main
-              git branch -D "${BACKPORT_BRANCH}"
+              git checkout main || git checkout -f main
+              git branch -D "${BACKPORT_BRANCH}" || true
             fi
 
             echo "::endgroup::"
@@ -384,6 +401,10 @@ jobs:
 
             **Reason:** Merge conflicts detected during cherry-pick of `${MERGE_COMMIT_SHORT}`
 
+            The auto-backport could not be completed automatically. Please backport
+            manually onto branch `${BACKPORT_BRANCH}` (from `origin/${target}`) and
+            open a PR to `${target}`.
+
             <details>
             <summary>📄 Conflicting files</summary>
 
@@ -416,19 +437,37 @@ jobs:
             MERGE_COMMIT=$(jq -r '.pull_request.merge_commit_sha' "$GITHUB_EVENT_PATH")
           fi
 
+          # Post a comment without letting a single failed `gh pr comment` (e.g.
+          # a locked issue, as happened for PR #13359, or a transient API error)
+          # abort the step under `set -e` and swallow the remaining failures.
+          post_comment() {
+            local body="$1"
+            local context="$2"
+            if ! gh pr comment "${PR_NUMBER}" --body "${body}"; then
+              echo "::warning::Could not comment on PR #${PR_NUMBER} about ${context}. Manual backport required."
+            fi
+          }
+
           for failure in ${{ steps.backport.outputs.failed }}; do
             IFS=':' read -r target reason conflicts <<< "${failure}"
 
+            SAFE_TARGET=$(echo "$target" | tr '/' '-')
+            BACKPORT_BRANCH="backport-${PR_NUMBER}-to-${SAFE_TARGET}"
+
             if [ "${reason}" = "branch-missing" ]; then
-              gh pr comment "${PR_NUMBER}" --body "@${PR_AUTHOR} Backport failed: Branch \`${target}\` does not exist"
+              post_comment "@${PR_AUTHOR} Backport failed: Branch \`${target}\` does not exist" "missing branch ${target}"
 
             elif [ "${reason}" = "already-exists" ]; then
-              gh pr comment "${PR_NUMBER}" --body "@${PR_AUTHOR} Commit \`${MERGE_COMMIT}\` already exists on branch \`${target}\`. No backport needed."
+              post_comment "@${PR_AUTHOR} Commit \`${MERGE_COMMIT}\` already exists on branch \`${target}\`. No backport needed." "already-backported ${target}"
+
+            elif [ "${reason}" = "branch-create-failed" ]; then
+              gh pr comment "${PR_NUMBER}" --body "@${PR_AUTHOR} Backport to \`${target}\` failed: could not create the backport branch. Please retry or backport manually."
+
+            elif [ "${reason}" = "push-failed" ]; then
+              gh pr comment "${PR_NUMBER}" --body "@${PR_AUTHOR} Backport to \`${target}\` cherry-picked cleanly but the push failed. Please retry or push the backport branch manually."
 
             elif [ "${reason}" = "conflicts" ]; then
               CONFLICTS_INLINE=$(echo "${conflicts}" | tr ',' ' ')
-              SAFE_TARGET=$(echo "$target" | tr '/' '-')
-              BACKPORT_BRANCH="backport-${PR_NUMBER}-to-${SAFE_TARGET}"
               PR_URL="${GITHUB_SERVER_URL}/${GITHUB_REPOSITORY}/pull/${PR_NUMBER}"
 
               export PR_NUMBER PR_URL MERGE_COMMIT target BACKPORT_BRANCH CONFLICTS_INLINE
@@ -444,10 +483,10 @@ jobs:
               CONFLICTS_BLOCK=$(echo "${conflicts}" | tr ',' '\n')
               MERGE_COMMIT_SHORT="${MERGE_COMMIT:0:7}"
 
-              export target MERGE_COMMIT_SHORT CONFLICTS_BLOCK AGENT_PROMPT PR_AUTHOR
-              COMMENT_BODY=$(envsubst '${target} ${MERGE_COMMIT_SHORT} ${CONFLICTS_BLOCK} ${AGENT_PROMPT} ${PR_AUTHOR}' <<<"$COMMENT_BODY_TEMPLATE")
+              export target MERGE_COMMIT_SHORT BACKPORT_BRANCH CONFLICTS_BLOCK AGENT_PROMPT PR_AUTHOR
+              COMMENT_BODY=$(envsubst '${target} ${MERGE_COMMIT_SHORT} ${BACKPORT_BRANCH} ${CONFLICTS_BLOCK} ${AGENT_PROMPT} ${PR_AUTHOR}' <<<"$COMMENT_BODY_TEMPLATE")
 
-              gh pr comment "${PR_NUMBER}" --body "${COMMENT_BODY}"
+              post_comment "${COMMENT_BODY}" "cherry-pick conflict on ${target} (backport manually onto ${BACKPORT_BRANCH})"
             fi
           done
 

.github/workflows/release-biweekly-comfyui.yaml

@@ -23,10 +23,6 @@ on:
         required: false
         default: 'Comfy-Org/ComfyUI'
         type: string
-      target_branch:
-        description: 'Optional: force a specific release branch, e.g. core/1.47 or core/2.0. Overrides the pin-derived target — use to skip a dead minor or do an out-of-cadence / major release.'
-        required: false
-        type: string
 
 jobs:
   check-release-week:
@@ -53,15 +49,12 @@ jobs:
           fi
 
       - name: Summary
-        env:
-          TARGET_BRANCH_OVERRIDE: ${{ inputs.target_branch }}
         run: |
           echo "## Release Check" >> $GITHUB_STEP_SUMMARY
           echo "" >> $GITHUB_STEP_SUMMARY
           echo "- Is release week: ${{ steps.check.outputs.is_release_week }}" >> $GITHUB_STEP_SUMMARY
           echo "- Manual trigger: ${{ github.event_name == 'workflow_dispatch' }}" >> $GITHUB_STEP_SUMMARY
           echo "- Release type: ${{ inputs.release_type || 'minor (scheduled)' }}" >> $GITHUB_STEP_SUMMARY
-          echo "- Target branch override: ${TARGET_BRANCH_OVERRIDE:-(none — pin-derived)}" >> $GITHUB_STEP_SUMMARY
 
   resolve-version:
     needs: check-release-week
@@ -110,7 +103,6 @@ jobs:
         working-directory: frontend
         env:
           RELEASE_TYPE: ${{ inputs.release_type || 'minor' }}
-          TARGET_BRANCH: ${{ inputs.target_branch }}
         run: |
           set -euo pipefail
 

apps/desktop-ui/src/components/install/DesktopSettingsConfiguration.vue

@@ -108,7 +108,7 @@
         </ul>
 
         <div class="mt-4">
-          <a href="https://comfy.org/privacy-policy" target="_blank">
+          <a href="https://comfy.org/privacy" target="_blank">
             {{ $t('install.settings.dataCollectionDialog.viewFullPolicy') }}
           </a>
         </div>

apps/desktop-ui/src/views/MetricsConsentView.vue

@@ -13,7 +13,7 @@
         <p class="text-neutral-400">
           {{ $t('install.moreInfo') }}
           <a
-            href="https://comfy.org/privacy-policy"
+            href="https://comfy.org/privacy"
             target="_blank"
             class="text-blue-400 underline hover:text-blue-300"
           >

apps/website/e2e/affiliates.spec.ts

@@ -76,10 +76,14 @@ test.describe('Affiliates landing — desktop interactions', () => {
       return match?.textContent ?? null
     })
     expect(faqJsonLd, 'FAQ JSON-LD script').not.toBeNull()
-    const parsed = JSON.parse(faqJsonLd!)
-    expect(parsed['@type']).toBe('FAQPage')
-    expect(Array.isArray(parsed.mainEntity)).toBe(true)
-    expect(parsed.mainEntity.length).toBe(FAQ_COUNT)
+    const graph = JSON.parse(faqJsonLd!)['@graph'] as {
+      '@type': string
+      mainEntity?: unknown[]
+    }[]
+    const faqPage = graph.find((node) => node['@type'] === 'FAQPage')
+    expect(faqPage, 'FAQPage node in @graph').toBeDefined()
+    expect(Array.isArray(faqPage!.mainEntity)).toBe(true)
+    expect(faqPage!.mainEntity!.length).toBe(FAQ_COUNT)
   })
 
   test('Apply Now CTA opens the application form in a new tab', async ({

apps/website/e2e/learning.spec.ts

@@ -0,0 +1,158 @@
+import { expect } from '@playwright/test'
+
+import { learningTutorials } from '../src/data/learningTutorials'
+import { t } from '../src/i18n/translations'
+import { test } from './fixtures/blockExternalMedia'
+
+const tutorialButtonName = (title: string, locale: 'en' | 'zh-CN') =>
+  `${t('learning.tutorials.titlePrefix', locale)} ${title}`
+
+test.describe('Learning page @smoke', () => {
+  test.beforeEach(async ({ page }) => {
+    await page.goto('/learning')
+  })
+
+  test('has correct title', async ({ page }) => {
+    await expect(page).toHaveTitle('Learning — Comfy')
+  })
+
+  test('hero headline references ComfyUI', async ({ page }) => {
+    const heading = page.getByRole('heading', { level: 1 })
+    await expect(heading).toBeVisible()
+    await expect(heading).toContainText(t('learning.heroTitle.before', 'en'))
+    await expect(heading).toContainText('ComfyUI')
+    await expect(heading).toContainText(t('learning.heroTitle.line2', 'en'))
+  })
+
+  test('featured workflow section shows title and author', async ({ page }) => {
+    await expect(
+      page.getByRole('heading', {
+        name: t('learning.featured.title', 'en'),
+        level: 2
+      })
+    ).toBeVisible()
+    await expect(
+      page.getByText(t('learning.featured.author', 'en'))
+    ).toBeVisible()
+  })
+
+  test('renders every tutorial from the data source', async ({ page }) => {
+    await expect(
+      page.getByRole('heading', {
+        name: t('learning.tutorials.heading', 'en'),
+        level: 2
+      })
+    ).toBeVisible()
+
+    for (const tutorial of learningTutorials) {
+      await expect(
+        page.getByRole('button', {
+          name: tutorialButtonName(tutorial.title.en, 'en')
+        })
+      ).toBeVisible()
+    }
+  })
+
+  test('tutorials with a workflow link expose an external Try Workflow link', async ({
+    page
+  }) => {
+    const linkedTutorials = learningTutorials.filter(
+      (tutorial) => tutorial.href
+    )
+    const workflowLinks = page.getByRole('link', {
+      name: t('cta.tryWorkflow', 'en')
+    })
+    const hrefs = await workflowLinks.evaluateAll((links) =>
+      links.map((link) => link.getAttribute('href'))
+    )
+    for (const tutorial of linkedTutorials) {
+      expect(hrefs).toContain(tutorial.href)
+    }
+  })
+
+  test('call to action links to contact sales', async ({ page }) => {
+    await expect(
+      page.getByRole('heading', {
+        name: t('learning.cta.heading', 'en'),
+        level: 2
+      })
+    ).toBeVisible()
+    await expect(
+      page.getByRole('link', { name: t('learning.cta.contactSales', 'en') })
+    ).toHaveAttribute('href', '/contact')
+  })
+})
+
+test.describe('Learning tutorial dialog', () => {
+  test('opens a tutorial video and dismisses via the close button', async ({
+    page
+  }) => {
+    const [firstTutorial] = learningTutorials
+    await page.goto('/learning')
+
+    const openButton = page.getByRole('button', {
+      name: tutorialButtonName(firstTutorial.title.en, 'en')
+    })
+    await openButton.scrollIntoViewIfNeeded()
+
+    const dialog = page.getByRole('dialog', { name: firstTutorial.title.en })
+    // TutorialsSection is hydrated via `client:visible`; retry the click until
+    // Vue responds by opening the dialog.
+    await expect(async () => {
+      await openButton.click()
+      await expect(dialog).toBeVisible({ timeout: 1_000 })
+    }).toPass({ timeout: 10_000 })
+
+    await expect(
+      dialog.getByRole('heading', { level: 2, name: firstTutorial.title.en })
+    ).toBeVisible()
+
+    await dialog
+      .getByRole('button', { name: t('gallery.detail.close', 'en') })
+      .click()
+    await expect(dialog).toBeHidden()
+  })
+
+  test('dismisses the dialog with the Escape key', async ({ page }) => {
+    const [firstTutorial] = learningTutorials
+    await page.goto('/learning')
+
+    const openButton = page.getByRole('button', {
+      name: tutorialButtonName(firstTutorial.title.en, 'en')
+    })
+    await openButton.scrollIntoViewIfNeeded()
+
+    const dialog = page.getByRole('dialog', { name: firstTutorial.title.en })
+    await expect(async () => {
+      await openButton.click()
+      await expect(dialog).toBeVisible({ timeout: 1_000 })
+    }).toPass({ timeout: 10_000 })
+
+    await page.keyboard.press('Escape')
+    await expect(dialog).toBeHidden()
+  })
+})
+
+test.describe('Learning page (zh-CN) @smoke', () => {
+  test('renders localized title, headings, and tutorials', async ({ page }) => {
+    await page.goto('/zh-CN/learning')
+
+    await expect(page).toHaveTitle('学习 — Comfy')
+    await expect(page.getByRole('heading', { level: 1 })).toContainText(
+      /[一-鿿]/
+    )
+    await expect(
+      page.getByRole('heading', {
+        name: t('learning.tutorials.heading', 'zh-CN'),
+        level: 2
+      })
+    ).toBeVisible()
+
+    const [firstTutorial] = learningTutorials
+    await expect(
+      page.getByRole('button', {
+        name: tutorialButtonName(firstTutorial.title['zh-CN'], 'zh-CN')
+      })
+    ).toBeVisible()
+  })
+})

apps/website/package.json

@@ -17,7 +17,8 @@
     "test:visual:update": "playwright test --project visual --update-snapshots",
     "ashby:refresh-snapshot": "tsx ./scripts/refresh-ashby-snapshot.ts",
     "cloud-nodes:refresh-snapshot": "tsx ./scripts/refresh-cloud-nodes-snapshot.ts",
-    "generate:models": "tsx ./scripts/generate-models.ts"
+    "generate:models": "tsx ./scripts/generate-models.ts",
+    "validate:jsonld": "tsx ./scripts/validate-jsonld.ts"
   },
   "dependencies": {
     "@astrojs/sitemap": "catalog:",

apps/website/scripts/validate-jsonld.ts

@@ -0,0 +1,129 @@
+import { readFileSync, readdirSync } from 'node:fs'
+import { join } from 'node:path'
+
+import { collectGraphIds } from '../src/utils/jsonLd'
+
+const DIST_DIR = join(process.cwd(), 'dist')
+const JSON_LD_BLOCK =
+  /<script[^>]*type=["']application\/ld\+json["'][^>]*>([\s\S]*?)<\/script>/gi
+
+interface Violation {
+  file: string
+  message: string
+}
+
+function htmlFiles(dir: string): string[] {
+  return readdirSync(dir, { recursive: true })
+    .map(String)
+    .filter((entry) => entry.endsWith('.html'))
+    .map((entry) => join(dir, entry))
+}
+
+function typesOf(node: Record<string, unknown>): string[] {
+  const type = node['@type']
+  if (typeof type === 'string') return [type]
+  if (Array.isArray(type)) {
+    return type.filter((t): t is string => typeof t === 'string')
+  }
+  return []
+}
+
+function hasValidPrice(node: Record<string, unknown>): boolean {
+  const price = node.price
+  const priceStr = price == null ? '' : String(price).trim()
+  return priceStr !== '' && !Number.isNaN(Number(priceStr))
+}
+
+function checkHonesty(
+  value: unknown,
+  file: string,
+  violations: Violation[]
+): void {
+  const walk = (node: unknown): void => {
+    if (Array.isArray(node)) {
+      node.forEach(walk)
+      return
+    }
+    if (!node || typeof node !== 'object') return
+    const record = node as Record<string, unknown>
+    const types = typesOf(record)
+    if (types.includes('Review') || types.includes('AggregateRating')) {
+      violations.push({
+        file,
+        message: `dishonest node type ${types.join('/')}`
+      })
+    }
+    if ('aggregateRating' in record || 'review' in record) {
+      violations.push({
+        file,
+        message: 'node carries a review/aggregateRating'
+      })
+    }
+    if (
+      types.includes('Offer') &&
+      (!hasValidPrice(record) || !record.priceCurrency)
+    ) {
+      violations.push({
+        file,
+        message: 'Offer missing priceCurrency or a concrete price'
+      })
+    }
+    Object.values(record).forEach(walk)
+  }
+  walk(value)
+}
+
+function validateFile(file: string): Violation[] {
+  const html = readFileSync(file, 'utf8')
+  const violations: Violation[] = []
+  const definedIds = new Set<string>()
+  const referencedIds: string[] = []
+
+  for (const match of html.matchAll(JSON_LD_BLOCK)) {
+    let parsed: unknown
+    try {
+      parsed = JSON.parse(match[1])
+    } catch (error) {
+      violations.push({ file, message: `invalid JSON-LD: ${String(error)}` })
+      continue
+    }
+    checkHonesty(parsed, file, violations)
+    const { defined, references } = collectGraphIds(parsed)
+    defined.forEach((id) => definedIds.add(id))
+    referencedIds.push(...references)
+  }
+
+  for (const id of referencedIds) {
+    if (!definedIds.has(id)) {
+      violations.push({ file, message: `unresolved @id reference: ${id}` })
+    }
+  }
+
+  return violations
+}
+
+function main(): void {
+  const files = htmlFiles(DIST_DIR)
+
+  if (files.length === 0) {
+    console.error(
+      `JSON-LD validation found no HTML in ${DIST_DIR} — build first.`
+    )
+    process.exit(1)
+  }
+
+  const violations = files.flatMap(validateFile)
+  if (violations.length > 0) {
+    console.error(`JSON-LD validation failed (${violations.length} issue(s)):`)
+    for (const { file, message } of violations) {
+      console.error(`  ${file.replace(DIST_DIR, 'dist')}: ${message}`)
+    }
+    process.exit(1)
+  }
+
+  process.stdout.write(
+    `JSON-LD validation passed across ${files.length} page(s).\n`
+  )
+}
+
+main()

apps/website/src/components/blocks/HeroBackdrop01.stories.ts

@@ -0,0 +1,41 @@
+import type { Meta, StoryObj } from '@storybook/vue3-vite'
+
+import HeroBackdrop01 from './HeroBackdrop01.vue'
+
+const sampleImage =
+  'https://images.unsplash.com/photo-1451187580459-43490279c0fa?auto=format&fit=crop&w=1600&q=80'
+
+const meta: Meta<typeof HeroBackdrop01> = {
+  title: 'Website/Blocks/HeroBackdrop01',
+  component: HeroBackdrop01,
+  tags: ['autodocs'],
+  args: {
+    backdrop: { type: 'image', src: sampleImage, alt: 'Abstract gradient' },
+    title: 'Build anything\nwith ComfyUI',
+    subtitle:
+      'A powerful, modular visual interface for building and running AI workflows.'
+  }
+}
+
+export default meta
+type Story = StoryObj<typeof meta>
+
+export const Default: Story = {}
+
+export const WithBadge: Story = {
+  args: {
+    badgeText: 'New'
+  }
+}
+
+export const WithFootnote: Story = {
+  args: {
+    footnote: 'Available on Windows, macOS, and Linux.'
+  }
+}
+
+export const NoBackdrop: Story = {
+  args: {
+    backdrop: undefined
+  }
+}

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

@@ -0,0 +1,193 @@
+<script setup lang="ts">
+import { cn } from '@comfyorg/tailwind-utils'
+
+import { computed } from 'vue'
+import type { HTMLAttributes } from 'vue'
+
+import { prefersReducedMotion } from '../../composables/useReducedMotion'
+import ProductHeroBadge from '../common/ProductHeroBadge.vue'
+
+type Backdrop =
+  | { type: 'image'; src: string; alt?: string }
+  | { type: 'video'; src: string; poster?: string; alt?: string }
+
+const {
+  backdrop,
+  mobileBackdrop,
+  badgeText,
+  badgeLogoSrc,
+  badgeLogoAlt,
+  title,
+  subtitle,
+  footnote,
+  class: className
+} = defineProps<{
+  backdrop?: Backdrop
+  mobileBackdrop?: Backdrop
+  badgeText?: string
+  badgeLogoSrc?: string
+  badgeLogoAlt?: string
+  title: string
+  subtitle?: string
+  footnote?: string
+  class?: HTMLAttributes['class']
+}>()
+
+// Respect prefers-reduced-motion: don't autoplay the looping backdrop video
+// (WCAG 2.2.2). The paused video falls back to its poster/first frame.
+const reduceMotion = computed(() => prefersReducedMotion())
+
+// Removing the reactive `autoplay` attribute only suppresses the *initial*
+// play; it can't pause a video the browser has already started. That is
+// exactly the SSR case: the server renders `autoplay` (it can't read the
+// client's motion preference), the browser begins playback on parse, and the
+// post-hydration attribute removal is too late. Pause on mount so
+// reduced-motion users get the poster frame instead of a looping video.
+const pauseIfReduced = (el: unknown) => {
+  if (el instanceof HTMLVideoElement && reduceMotion.value) el.pause()
+}
+
+// On mobile the backdrop is an in-flow rounded card above the content; on
+// desktop it is the full-bleed background behind it. A single element serves
+// both roles via responsive classes — mobileBackdrop only swaps the source.
+const sharedBackdropClass =
+  'relative aspect-3/2 w-full rounded-3xl object-cover lg:absolute lg:inset-0 lg:aspect-auto lg:size-full lg:rounded-none'
+
+// When both breakpoints use images, serve them from a single responsive <img>
+// so the browser fetches only the source matching the viewport. Two
+// `hidden`/`lg:hidden`-toggled <img> layers would each download (display:none
+// does not stop the fetch), doubling the high-priority load on an
+// LCP-critical hero. Videos or a mixed image/video pair can't collapse this
+// way and fall back to breakpoint-toggled layers below.
+const responsiveImage = computed(() => {
+  if (backdrop?.type !== 'image') return null
+  if (mobileBackdrop && mobileBackdrop.type !== 'image') return null
+  const base = mobileBackdrop ?? backdrop
+  return {
+    src: base.src,
+    alt: backdrop.alt ?? mobileBackdrop?.alt ?? '',
+    // Larger-viewport source; omitted when one image serves both breakpoints.
+    desktopSrc: mobileBackdrop ? backdrop.src : undefined
+  }
+})
+
+// Fallback for videos and mixed image/video pairs: toggle assets by breakpoint.
+const backdropLayers = computed(() => {
+  if (!backdrop) return []
+  if (mobileBackdrop) {
+    return [
+      {
+        backdrop: mobileBackdrop,
+        class: 'relative aspect-3/2 w-full rounded-3xl object-cover lg:hidden'
+      },
+      {
+        backdrop,
+        class: 'absolute inset-0 hidden size-full object-cover lg:block'
+      }
+    ]
+  }
+  return [{ backdrop, class: sharedBackdropClass }]
+})
+
+const scrimShape = 'farthest-side at 50% 50%'
+const scrimStyle = {
+  background: `radial-gradient(${scrimShape}, color-mix(in srgb, var(--color-primary-warm-white) 80%, transparent) 0%, transparent 80%)`,
+  maskImage: `radial-gradient(${scrimShape}, #000 45%, transparent 90%)`,
+  WebkitMaskImage: `radial-gradient(${scrimShape}, #000 45%, transparent 90%)`
+}
+</script>
+
+<template>
+  <section
+    :class="cn('max-w-9xl mx-auto px-4 pt-4 lg:px-6 lg:pt-6', className)"
+  >
+    <div class="relative overflow-hidden rounded-3xl">
+      <slot name="backdrop">
+        <picture v-if="responsiveImage" class="contents">
+          <source
+            v-if="responsiveImage.desktopSrc"
+            :srcset="responsiveImage.desktopSrc"
+            media="(min-width: 1024px)"
+          />
+          <img
+            :src="responsiveImage.src"
+            :alt="responsiveImage.alt"
+            fetchpriority="high"
+            decoding="async"
+            :class="sharedBackdropClass"
+          />
+        </picture>
+
+        <template v-else>
+          <template v-for="(layer, i) in backdropLayers" :key="i">
+            <video
+              v-if="layer.backdrop.type === 'video'"
+              :ref="pauseIfReduced"
+              :src="layer.backdrop.src"
+              :poster="layer.backdrop.poster"
+              :aria-label="layer.backdrop.alt"
+              :aria-hidden="layer.backdrop.alt ? undefined : true"
+              :autoplay="!reduceMotion"
+              loop
+              muted
+              playsinline
+              preload="metadata"
+              :class="layer.class"
+            />
+            <img
+              v-else
+              :src="layer.backdrop.src"
+              :alt="layer.backdrop.alt ?? ''"
+              fetchpriority="high"
+              decoding="async"
+              :class="layer.class"
+            />
+          </template>
+        </template>
+      </slot>
+
+      <div
+        class="relative flex flex-col justify-center px-0 pt-6 pb-8 lg:min-h-176 lg:px-16 lg:py-24"
+      >
+        <div class="relative w-full max-w-xl">
+          <div
+            aria-hidden="true"
+            class="pointer-events-none absolute -inset-12 hidden backdrop-blur-md lg:-inset-16 lg:block"
+            :style="scrimStyle"
+          />
+
+          <div class="relative">
+            <ProductHeroBadge
+              v-if="badgeText"
+              :text="badgeText"
+              :logo-src="badgeLogoSrc"
+              :logo-alt="badgeLogoAlt"
+            />
+
+            <h1
+              class="mt-10 text-4xl/tight font-light tracking-tight whitespace-pre-line text-primary-comfy-canvas lg:text-6xl/tight lg:text-primary-comfy-ink"
+            >
+              {{ title }}
+            </h1>
+
+            <p
+              v-if="subtitle"
+              class="mt-8 max-w-md text-base text-primary-comfy-canvas lg:text-lg lg:text-primary-comfy-ink"
+            >
+              {{ subtitle }}
+            </p>
+
+            <p
+              v-if="footnote"
+              class="mt-10 text-sm text-primary-comfy-canvas lg:text-primary-comfy-ink"
+            >
+              {{ footnote }}
+            </p>
+
+            <slot />
+          </div>
+        </div>
+      </div>
+    </div>
+  </section>
+</template>

apps/website/src/components/common/JsonLdGraph.astro

@@ -0,0 +1,12 @@
+---
+import type { JsonLdGraph } from '../../utils/jsonLd'
+import { escapeJsonLd } from '../../utils/escapeJsonLd'
+
+interface Props {
+  graph: JsonLdGraph
+}
+
+const { graph } = Astro.props
+---
+
+<script is:inline type="application/ld+json" set:html={escapeJsonLd(graph)} />

apps/website/src/config/pricing.ts

@@ -0,0 +1,53 @@
+import { t } from '../i18n/translations'
+import type { Locale, TranslationKey } from '../i18n/translations'
+import { externalLinks } from './routes'
+
+interface PricingTier {
+  slug: string
+  labelKey: TranslationKey
+  priceKey: TranslationKey
+}
+
+const tiers: PricingTier[] = [
+  {
+    slug: 'standard',
+    labelKey: 'pricing.plan.standard.label',
+    priceKey: 'pricing.plan.standard.price'
+  },
+  {
+    slug: 'creator',
+    labelKey: 'pricing.plan.creator.label',
+    priceKey: 'pricing.plan.creator.price'
+  },
+  {
+    slug: 'pro',
+    labelKey: 'pricing.plan.pro.label',
+    priceKey: 'pricing.plan.pro.price'
+  }
+]
+
+export interface PricingOffer {
+  name: string
+  price: string
+  url: string
+}
+
+export function pricingOffers(locale: Locale): PricingOffer[] {
+  return tiers.flatMap((tier) => {
+    const display = t(tier.priceKey, locale).trim()
+    const match = /^\$(\d+(?:\.\d+)?)$/.exec(display)
+    if (!match) {
+      console.warn(
+        `pricingOffers: skipping tier "${tier.slug}" (${locale}) — price "${display}" is not a plain USD amount`
+      )
+      return []
+    }
+    return [
+      {
+        name: t(tier.labelKey, locale),
+        price: match[1],
+        url: `${externalLinks.cloud}/cloud/subscribe?tier=${tier.slug}&cycle=monthly`
+      }
+    ]
+  })
+}

apps/website/src/config/routes.ts

@@ -82,14 +82,19 @@ export const externalLinks = {
   docsApi: 'https://docs.comfy.org/development/cloud/overview#quick-start',
   docsMcp: 'https://docs.comfy.org/agent-tools/cloud',
   docsSubscription: 'https://docs.comfy.org/support/subscription/subscribing',
+  g2ComfyUi: 'https://www.g2.com/products/comfyui',
   github: 'https://github.com/Comfy-Org/ComfyUI',
   githubInstall: 'https://github.com/Comfy-Org/ComfyUI#installing',
   instagram: 'https://www.instagram.com/comfyui/',
+  linkedin: 'https://www.linkedin.com/company/comfyui',
   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/',
   support: 'https://support.comfy.org/hc/en-us',
+  wikidataComfyOrg: 'https://www.wikidata.org/wiki/Q130598554',
+  wikidataComfyUi: 'https://www.wikidata.org/wiki/Q127798647',
+  wikipediaComfyUi: 'https://en.wikipedia.org/wiki/ComfyUI',
   workflows: 'https://comfy.org/workflows',
   x: 'https://x.com/ComfyUI',
   youtube: 'https://www.youtube.com/@ComfyOrg'

apps/website/src/i18n/translations.ts

@@ -2190,6 +2190,13 @@ const translations = {
   'nav.ctaCloudPrefix': { en: 'LAUNCH', 'zh-CN': '启动' },
   'nav.ctaCloudCore': { en: 'CLOUD', 'zh-CN': '云端' },
   'nav.home': { en: 'Comfy home', 'zh-CN': 'Comfy 首页' },
+  'breadcrumb.home': { en: 'Home', 'zh-CN': '首页' },
+  'breadcrumb.about': { en: 'About Us', 'zh-CN': '关于我们' },
+  'breadcrumb.contact': { en: 'Contact', 'zh-CN': '联系我们' },
+  'breadcrumb.download': { en: 'Download', 'zh-CN': '下载' },
+  'breadcrumb.careers': { en: 'Careers', 'zh-CN': '招聘' },
+  'breadcrumb.pricing': { en: 'Pricing', 'zh-CN': '定价' },
+  'breadcrumb.supportedNodes': { en: 'Supported Nodes', 'zh-CN': '支持的节点' },
   'nav.menu': { en: 'Menu', 'zh-CN': '菜单' },
   'nav.toggleMenu': { en: 'Toggle menu', 'zh-CN': '切换菜单' },
   'nav.close': { en: 'Close', 'zh-CN': '关闭' },
@@ -4061,7 +4068,6 @@ const translations = {
     en: 'This page is being redesigned. Check back soon.',
     'zh-CN': '此页面正在重新设计中，请稍后再来。'
   },
-  'demos.breadcrumb.home': { en: 'Home', 'zh-CN': '首页' },
   'demos.breadcrumb.demos': { en: 'Demos', 'zh-CN': '演示' },
 
   'customers.story.whatsNext': {
@@ -4157,10 +4163,6 @@ const translations = {
     en: "Run the world's leading AI models in ComfyUI",
     'zh-CN': '在 ComfyUI 中运行世界领先的 AI 模型'
   },
-  'models.breadcrumb.home': {
-    en: 'Home',
-    'zh-CN': '首页'
-  },
   'models.breadcrumb.models': {
     en: 'Supported Models',
     'zh-CN': '支持的模型'

apps/website/src/layouts/BaseLayout.astro

@@ -14,8 +14,10 @@ import {
   createBannerVersion,
   evaluateBannerVisibility
 } from '../utils/banner'
-import { escapeJsonLd } from '../utils/escapeJsonLd'
 import { fetchGitHubStars, formatStarCount } from '../utils/github'
+import { buildPageGraph, pageContext } from '../utils/jsonLd'
+import type { Crumb, JsonLdNode, WebPageType } from '../utils/jsonLd'
+import JsonLdGraph from '../components/common/JsonLdGraph.astro'
 
 interface Props {
   title: string
@@ -23,6 +25,10 @@ interface Props {
   keywords?: string[]
   ogImage?: string
   noindex?: boolean
+  pageType?: WebPageType
+  breadcrumbs?: Crumb[]
+  mainEntityId?: string
+  extraJsonLd?: (JsonLdNode | null | undefined)[]
 }
 
 const {
@@ -31,15 +37,21 @@ const {
   keywords,
   ogImage = 'https://media.comfy.org/website/comfy.webp',
   noindex = false,
+  pageType,
+  breadcrumbs,
+  mainEntityId,
+  extraJsonLd,
 } = Astro.props
 
 const keywordsContent = keywords && keywords.length > 0 ? keywords.join(', ') : undefined
 
-const siteBase = Astro.site ?? 'https://comfy.org'
-const canonicalURL = new URL(Astro.url.pathname, siteBase)
-const ogImageURL = new URL(ogImage, siteBase)
-const rawLocale = Astro.currentLocale ?? 'en'
-const locale: Locale = rawLocale === 'zh-CN' ? 'zh-CN' : 'en'
+const { siteUrl, locale, url } = pageContext(
+  Astro.site,
+  Astro.url.pathname,
+  Astro.currentLocale,
+)
+const canonicalURL = new URL(url)
+const ogImageURL = new URL(ogImage, Astro.site ?? 'https://comfy.org')
 const rawStars = await fetchGitHubStars('Comfy-Org', 'ComfyUI')
 const githubStars = rawStars ? formatStarCount(rawStars) : ''
 
@@ -58,28 +70,21 @@ const bannerVersion = createBannerVersion(bannerData, locale)
 const gtmId = 'GTM-NP9JM6K7'
 const gtmEnabled = import.meta.env.PROD
 
-const organizationJsonLd = {
-  '@context': 'https://schema.org',
-  '@type': 'Organization',
-  name: 'Comfy Org',
-  url: 'https://comfy.org',
-  logo: 'https://comfy.org/icons/logomark.svg',
-  sameAs: [
-    'https://github.com/comfyanonymous/ComfyUI',
-    'https://discord.gg/comfyorg',
-    'https://x.com/comaboratory',
-    'https://reddit.com/r/comfyui',
-    'https://linkedin.com/company/comfyorg',
-    'https://instagram.com/comfyorg',
-  ],
-}
-
-const websiteJsonLd = {
-  '@context': 'https://schema.org',
-  '@type': 'WebSite',
-  name: 'Comfy',
-  url: 'https://comfy.org',
-}
+const structuredData = noindex
+  ? undefined
+  : buildPageGraph(
+      { siteUrl, locale },
+      {
+        url,
+        name: title,
+        description,
+        imageUrl: ogImageURL.href,
+        type: pageType,
+        crumbs: breadcrumbs,
+        mainEntityId,
+      },
+      ...(extraJsonLd ?? []),
+    )
 ---
 
 <!doctype html>
@@ -121,10 +126,7 @@ const websiteJsonLd = {
     <meta name="twitter:image" content={ogImageURL.href} />
 
     <!-- Structured Data -->
-    <script is:inline type="application/ld+json" set:html={escapeJsonLd(organizationJsonLd)} />
-    <script is:inline type="application/ld+json" set:html={escapeJsonLd(websiteJsonLd)} />
-    <slot name="head" />
-
+    {structuredData && <JsonLdGraph graph={structuredData} />}
     <slot name="head" />
 
     <!-- Google Tag Manager -->
@@ -144,7 +146,6 @@ const websiteJsonLd = {
     )}
 
     <ClientRouter />
-    <slot name="head" />
 
     <!-- Hide an already-dismissed announcement banner before first paint (no flash/shift). -->
     {bannerVisible && (

apps/website/src/pages/about.astro

@@ -5,9 +5,25 @@ import StorySection from '../components/about/StorySection.vue'
 import OurValuesSection from '../components/about/OurValuesSection.vue'
 import ValuesSection from '../components/about/ValuesSection.vue'
 import CareersSection from '../components/about/CareersSection.vue'
+import { t } from '../i18n/translations'
+import { absoluteUrl, organizationId, pageContext } from '../utils/jsonLd'
+
+const { siteUrl, locale } = pageContext(
+  Astro.site,
+  Astro.url.pathname,
+  Astro.currentLocale,
+)
 ---
 
-<BaseLayout title="About Us — Comfy">
+<BaseLayout
+  title="About Us — Comfy"
+  pageType="AboutPage"
+  mainEntityId={organizationId(siteUrl)}
+  breadcrumbs={[
+    { name: t('breadcrumb.home', locale), url: absoluteUrl(Astro.site, '/') },
+    { name: t('breadcrumb.about', locale) },
+  ]}
+>
   <HeroSection client:load />
   <StorySection />
   <OurValuesSection />

apps/website/src/pages/affiliates/index.astro

@@ -9,34 +9,36 @@ import HeroSection from '../../templates/affiliate/HeroSection.vue'
 import HowItWorksSection from '../../templates/affiliate/HowItWorksSection.vue'
 import { affiliateFaqs } from '../../data/affiliateFaq'
 import { t } from '../../i18n/translations'
+import type { JsonLdNode } from '../../utils/jsonLd'
+import { absoluteUrl, jsonLdId, pageContext } from '../../utils/jsonLd'
 
-const locale = 'en' as const
-
-const faqJsonLd = {
-  '@context': 'https://schema.org',
+const pageTitle = t('affiliate.page.title', 'en')
+const pageDescription = t('affiliate.page.description', 'en')
+const { locale, url } = pageContext(
+  Astro.site,
+  Astro.url.pathname,
+  Astro.currentLocale,
+)
+const faqPage: JsonLdNode = {
   '@type': 'FAQPage',
+  '@id': jsonLdId(url, 'faq'),
   mainEntity: affiliateFaqs.map((faq) => ({
     '@type': 'Question',
     name: faq.question[locale],
-    acceptedAnswer: {
-      '@type': 'Answer',
-      text: faq.answer[locale]
-    }
-  }))
+    acceptedAnswer: { '@type': 'Answer', text: faq.answer[locale] },
+  })),
 }
 ---
 
 <BaseLayout
-  title={t('affiliate.page.title', locale)}
-  description={t('affiliate.page.description', locale)}
+  title={pageTitle}
+  description={pageDescription}
+  breadcrumbs={[
+    { name: t('breadcrumb.home', locale), url: absoluteUrl(Astro.site, '/') },
+    { name: pageTitle },
+  ]}
+  extraJsonLd={[faqPage]}
 >
-  <Fragment slot="head">
-    <script
-      is:inline
-      type="application/ld+json"
-      set:html={JSON.stringify(faqJsonLd)}
-    />
-  </Fragment>
 
   <HeroSection />
   <HowItWorksSection />

apps/website/src/pages/careers.astro

@@ -7,6 +7,13 @@ import TeamPhotosSection from '../components/careers/TeamPhotosSection.vue'
 import FAQSection from '../components/common/FAQSection.vue'
 import { fetchRolesForBuild } from '../utils/ashby'
 import { reportAshbyOutcome } from '../utils/ashby.ci'
+import { t } from '../i18n/translations'
+import {
+  absoluteUrl,
+  itemListNode,
+  jsonLdId,
+  pageContext,
+} from '../utils/jsonLd'
 
 const outcome = await fetchRolesForBuild()
 reportAshbyOutcome(outcome)
@@ -19,11 +26,31 @@ if (outcome.status === 'failed') {
 }
 
 const departments = outcome.snapshot.departments
+
+const { siteUrl, locale, url } = pageContext(
+  Astro.site,
+  Astro.url.pathname,
+  Astro.currentLocale,
+)
+const roles = itemListNode(
+  url,
+  t('breadcrumb.careers', locale),
+  departments.flatMap((department) =>
+    department.roles.map((role) => ({ name: role.title, url: role.jobUrl })),
+  ),
+)
 ---
 
 <BaseLayout
   title="Careers — Comfy"
   description="Join the team building the operating system for generative AI. Open roles in engineering, design, marketing, and more."
+  pageType="CollectionPage"
+  mainEntityId={jsonLdId(url, 'itemlist')}
+  breadcrumbs={[
+    { name: t('breadcrumb.home', locale), url: absoluteUrl(Astro.site, '/') },
+    { name: t('breadcrumb.careers', locale) },
+  ]}
+  extraJsonLd={[roles]}
 >
   <HeroSection />
   <RolesSection departments={departments} client:visible />

apps/website/src/pages/cloud/pricing.astro

@@ -2,9 +2,41 @@
 import BaseLayout from '../../layouts/BaseLayout.astro'
 import PriceSection from '../../components/pricing/PriceSection.vue'
 import WhatsIncludedSection from '../../components/pricing/WhatsIncludedSection.vue'
+import { pricingOffers } from '../../config/pricing'
+import { t } from '../../i18n/translations'
+import {
+  absoluteUrl,
+  jsonLdId,
+  pageContext,
+  productNode,
+} from '../../utils/jsonLd'
+
+const { siteUrl, locale, url } = pageContext(
+  Astro.site,
+  Astro.url.pathname,
+  Astro.currentLocale,
+)
+const productId = jsonLdId(url, 'product')
 ---
 
-<BaseLayout title="Pricing — Comfy Cloud">
+<BaseLayout
+  title="Pricing — Comfy Cloud"
+  mainEntityId={productId}
+  breadcrumbs={[
+    { name: t('breadcrumb.home', locale), url: absoluteUrl(Astro.site, '/') },
+    { name: 'Comfy Cloud', url: absoluteUrl(Astro.site, '/cloud') },
+    { name: t('breadcrumb.pricing', locale) },
+  ]}
+  extraJsonLd={[
+    productNode({
+      siteUrl,
+      id: productId,
+      name: 'Comfy Cloud',
+      url,
+      offers: pricingOffers(locale),
+    }),
+  ]}
+>
   <PriceSection client:load />
   <WhatsIncludedSection />
 </BaseLayout>

apps/website/src/pages/cloud/supported-nodes.astro

@@ -4,39 +4,44 @@ import HeroSection from '../../components/cloud-nodes/HeroSection.vue'
 import PackGridSection from '../../components/cloud-nodes/PackGridSection.vue'
 import { t } from '../../i18n/translations'
 import { loadPacksForBuild } from '../../utils/cloudNodes.build'
-import { escapeJsonLd } from '../../utils/escapeJsonLd'
+import {
+  absoluteUrl,
+  itemListNode,
+  jsonLdId,
+  pageContext,
+} from '../../utils/jsonLd'
 
 const packs = await loadPacksForBuild()
 
-const siteBase = Astro.site ?? new URL('https://comfy.org')
-const pageUrl = new URL('/cloud/supported-nodes', siteBase).href
-
-const itemListJsonLd = {
-  '@context': 'https://schema.org',
-  '@type': 'ItemList',
-  name: 'Custom-node packs supported on Comfy Cloud',
-  url: pageUrl,
-  numberOfItems: packs.length,
-  itemListElement: packs.map((pack, index) => ({
-    '@type': 'ListItem',
-    position: index + 1,
-    url: new URL(`/cloud/supported-nodes/${pack.id}`, siteBase).href,
+const title = t('cloudNodes.meta.title', 'en')
+const description = t('cloudNodes.meta.description', 'en')
+const { url, locale } = pageContext(
+  Astro.site,
+  Astro.url.pathname,
+  Astro.currentLocale,
+)
+const packList = itemListNode(
+  url,
+  title,
+  packs.map((pack) => ({
     name: pack.displayName,
-    image: pack.bannerUrl || pack.iconUrl
-  }))
-}
+    url: absoluteUrl(Astro.site, `/cloud/supported-nodes/${pack.id}`),
+  })),
+)
 ---
 
 <BaseLayout
-  title={t('cloudNodes.meta.title', 'en')}
-  description={t('cloudNodes.meta.description', 'en')}
+  title={title}
+  description={description}
+  pageType="CollectionPage"
+  mainEntityId={jsonLdId(url, 'itemlist')}
+  breadcrumbs={[
+    { name: t('breadcrumb.home', locale), url: absoluteUrl(Astro.site, '/') },
+    { name: 'Comfy Cloud', url: absoluteUrl(Astro.site, '/cloud') },
+    { name: t('breadcrumb.supportedNodes', locale) },
+  ]}
+  extraJsonLd={[packList]}
 >
-  <script
-    is:inline
-    slot="head"
-    type="application/ld+json"
-    set:html={escapeJsonLd(itemListJsonLd)}
-  />
   <HeroSection client:visible />
   <PackGridSection packs={packs} client:visible />
 </BaseLayout>

apps/website/src/pages/cloud/supported-nodes/[pack].astro

@@ -7,7 +7,12 @@ import PackDetail from '../../../components/cloud-nodes/PackDetail.vue'
 import BaseLayout from '../../../layouts/BaseLayout.astro'
 import { t } from '../../../i18n/translations'
 import { loadPacksForBuild } from '../../../utils/cloudNodes.build'
-import { escapeJsonLd } from '../../../utils/escapeJsonLd'
+import {
+  absoluteUrl,
+  jsonLdId,
+  pageContext,
+  softwareApplicationNode,
+} from '../../../utils/jsonLd'
 
 export const getStaticPaths: GetStaticPaths = async () => {
   const packs = await loadPacksForBuild()
@@ -29,35 +34,45 @@ const metaDescription = t('cloudNodes.detail.metaDescription', 'en')
   .replace('{nodeCount}', String(pack.nodes.length))
   .replace('{description}', description)
 
-const siteBase = Astro.site ?? new URL('https://comfy.org')
-const pageUrl = new URL(`/cloud/supported-nodes/${pack.id}`, siteBase).href
-
-const softwareJsonLd = {
-  '@context': 'https://schema.org',
-  '@type': 'SoftwareApplication',
+const { siteUrl, locale, url } = pageContext(
+  Astro.site,
+  Astro.url.pathname,
+  Astro.currentLocale,
+)
+const softwareId = jsonLdId(url, 'software')
+const software = softwareApplicationNode({
+  siteUrl,
+  id: softwareId,
   name: pack.displayName,
+  url,
   applicationCategory: 'DeveloperApplication',
   applicationSubCategory: 'ComfyUI custom-node pack',
   operatingSystem: 'Comfy Cloud (managed)',
-  url: pageUrl,
-  description,
+  description: pack.description || undefined,
   image: pack.bannerUrl || pack.iconUrl,
   softwareVersion: pack.latestVersion,
   license: pack.license,
   codeRepository: pack.repoUrl,
-  author: pack.publisher?.name
-    ? { '@type': 'Person', name: pack.publisher.name }
-    : undefined,
-  offers: { '@type': 'Offer', price: 0, priceCurrency: 'USD' }
-}
+  authorName: pack.publisher?.name,
+  isFree: true,
+})
 ---
 
-<BaseLayout title={title} description={metaDescription} ogImage={pack.bannerUrl}>
-  <script
-    is:inline
-    slot="head"
-    type="application/ld+json"
-    set:html={escapeJsonLd(softwareJsonLd)}
-  />
+<BaseLayout
+  title={title}
+  description={metaDescription}
+  ogImage={pack.bannerUrl}
+  mainEntityId={softwareId}
+  breadcrumbs={[
+    { name: t('breadcrumb.home', locale), url: absoluteUrl(Astro.site, '/') },
+    { name: 'Comfy Cloud', url: absoluteUrl(Astro.site, '/cloud') },
+    {
+      name: t('breadcrumb.supportedNodes', locale),
+      url: absoluteUrl(Astro.site, '/cloud/supported-nodes'),
+    },
+    { name: pack.displayName },
+  ]}
+  extraJsonLd={[software]}
+>
   <PackDetail pack={pack} />
 </BaseLayout>

apps/website/src/pages/contact.astro

@@ -2,9 +2,25 @@
 import BaseLayout from '../layouts/BaseLayout.astro'
 import FormSection from '../components/contact/FormSection.vue'
 import SocialProofBarSection from '../components/common/SocialProofBarSection.vue'
+import { t } from '../i18n/translations'
+import { absoluteUrl, organizationId, pageContext } from '../utils/jsonLd'
+
+const { siteUrl, locale } = pageContext(
+  Astro.site,
+  Astro.url.pathname,
+  Astro.currentLocale,
+)
 ---
 
-<BaseLayout title="Contact — Comfy">
+<BaseLayout
+  title="Contact — Comfy"
+  pageType="ContactPage"
+  mainEntityId={organizationId(siteUrl)}
+  breadcrumbs={[
+    { name: t('breadcrumb.home', locale), url: absoluteUrl(Astro.site, '/') },
+    { name: t('breadcrumb.contact', locale) },
+  ]}
+>
   <FormSection client:load />
   <SocialProofBarSection />
 </BaseLayout>

apps/website/src/pages/demos/[slug].astro

@@ -7,6 +7,13 @@ import DemoTranscript from '../../components/demos/DemoTranscript.vue'
 import DemoNavSection from '../../components/demos/DemoNavSection.vue'
 import { demos, getDemoBySlug, getNextDemo } from '../../config/demos'
 import { t } from '../../i18n/translations'
+import type { JsonLdNode } from '../../utils/jsonLd'
+import {
+  absoluteUrl,
+  jsonLdId,
+  organizationId,
+  pageContext,
+} from '../../utils/jsonLd'
 
 export const getStaticPaths: GetStaticPaths = () => {
   return demos.map((demo) => ({
@@ -19,68 +26,34 @@ const demo = getDemoBySlug(slug as string)!
 const nextDemo = getNextDemo(slug as string)
 const title = t(demo.title)
 const description = t(demo.description)
-const canonicalURL = new URL(`/demos/${demo.slug}`, Astro.site)
 
-const howToJsonLd = {
-  '@context': 'https://schema.org',
-  '@type': 'HowTo',
-  name: title,
-  description,
-  image: new URL(demo.ogImage, Astro.site).href,
-  totalTime: demo.durationIso,
-  datePublished: demo.publishedDate,
-  dateModified: demo.modifiedDate,
-  author: {
-    '@type': 'Organization',
-    name: 'Comfy Org',
-    url: 'https://comfy.org'
-  }
-}
-
-const learningResourceJsonLd = {
-  '@context': 'https://schema.org',
-  '@type': 'LearningResource',
-  name: title,
-  description,
-  learningResourceType: 'interactive tutorial',
-  interactivityType: 'active',
-  educationalLevel: demo.difficulty === 'beginner'
+const { siteUrl, locale, url } = pageContext(
+  Astro.site,
+  Astro.url.pathname,
+  Astro.currentLocale,
+)
+const educationalLevel =
+  demo.difficulty === 'beginner'
     ? 'Beginner'
     : demo.difficulty === 'intermediate'
       ? 'Intermediate'
-      : 'Advanced',
-  url: canonicalURL.href,
+      : 'Advanced'
+const learningId = jsonLdId(url, 'learning')
+const learningResource: JsonLdNode = {
+  '@type': 'LearningResource',
+  '@id': learningId,
+  name: title,
+  description,
+  url,
+  image: new URL(demo.ogImage, Astro.site).href,
+  learningResourceType: 'interactive tutorial',
+  interactivityType: 'active',
+  educationalLevel,
+  timeRequired: demo.durationIso,
   datePublished: demo.publishedDate,
   dateModified: demo.modifiedDate,
-  author: {
-    '@type': 'Organization',
-    name: 'Comfy Org',
-    url: 'https://comfy.org'
-  }
-}
-
-const breadcrumbJsonLd = {
-  '@context': 'https://schema.org',
-  '@type': 'BreadcrumbList',
-  itemListElement: [
-    {
-      '@type': 'ListItem',
-      position: 1,
-      name: t('demos.breadcrumb.home'),
-      item: 'https://comfy.org'
-    },
-    {
-      '@type': 'ListItem',
-      position: 2,
-      name: t('demos.breadcrumb.demos'),
-      item: 'https://comfy.org/demos'
-    },
-    {
-      '@type': 'ListItem',
-      position: 3,
-      name: title
-    }
-  ]
+  isPartOf: { '@id': jsonLdId(url, 'webpage') },
+  author: { '@id': organizationId(siteUrl) },
 }
 ---
 
@@ -88,25 +61,20 @@ const breadcrumbJsonLd = {
   title={`${title} — Comfy`}
   description={description}
   ogImage={demo.ogImage}
+  mainEntityId={learningId}
+  breadcrumbs={[
+    { name: t('breadcrumb.home', locale), url: absoluteUrl(Astro.site, '/') },
+    {
+      name: t('demos.breadcrumb.demos', locale),
+      url: absoluteUrl(Astro.site, '/demos'),
+    },
+    { name: title },
+  ]}
+  extraJsonLd={[learningResource]}
 >
   <Fragment slot="head">
     <meta property="article:published_time" content={demo.publishedDate} />
     <meta property="article:modified_time" content={demo.modifiedDate} />
-    <script
-      is:inline
-      type="application/ld+json"
-      set:html={JSON.stringify(howToJsonLd)}
-    />
-    <script
-      is:inline
-      type="application/ld+json"
-      set:html={JSON.stringify(learningResourceJsonLd)}
-    />
-    <script
-      is:inline
-      type="application/ld+json"
-      set:html={JSON.stringify(breadcrumbJsonLd)}
-    />
     <link rel="preconnect" href="https://demo.arcade.software" />
   </Fragment>
 

apps/website/src/pages/download.astro

@@ -8,11 +8,29 @@ import EcoSystemSection from '../components/product/local/EcoSystemSection.vue'
 import ProductCardsSection from '../components/product/local/ProductCardsSection.vue'
 import FAQSection from '../components/product/local/FAQSection.vue'
 import { t } from '../i18n/translations'
+import {
+  absoluteUrl,
+  comfyUiApplicationNode,
+  comfyUiSoftwareId,
+  pageContext,
+} from '../utils/jsonLd'
+
+const { siteUrl, locale } = pageContext(
+  Astro.site,
+  Astro.url.pathname,
+  Astro.currentLocale,
+)
 ---
 
 <BaseLayout
   title="Download Comfy Desktop — Run AI on Your Hardware"
   description={t('download.hero.subtitle', 'en')}
+  mainEntityId={comfyUiSoftwareId(siteUrl)}
+  breadcrumbs={[
+    { name: t('breadcrumb.home', locale), url: absoluteUrl(Astro.site, '/') },
+    { name: t('breadcrumb.download', locale) },
+  ]}
+  extraJsonLd={[comfyUiApplicationNode(siteUrl)]}
   keywords={['comfyui app', 'comfyui desktop app', 'comfyui desktop', 'comfy ui application', 'comfyui download', 'download comfyui', 'comfyui windows', 'comfyui mac', 'comfyui linux']}
 >
   <CloudBannerSection />

apps/website/src/pages/index.astro

@@ -9,11 +9,28 @@ import CaseStudySpotlightSection from "../components/home/CaseStudySpotlightSect
 import GetStartedSection from "../components/home/GetStartedSection.vue";
 import BuildWhatSection from "../components/home/BuildWhatSection.vue";
 import { t } from "../i18n/translations";
+import {
+  comfyUiApplicationNode,
+  comfyUiSoftwareId,
+  comfyUiSourceCodeNode,
+  pageContext,
+} from "../utils/jsonLd";
+
+const { siteUrl } = pageContext(
+  Astro.site,
+  Astro.url.pathname,
+  Astro.currentLocale,
+);
 ---
 
 <BaseLayout
   title="Comfy — Professional Control of Visual AI"
   description={t("hero.subtitle", "en")}
+  mainEntityId={comfyUiSoftwareId(siteUrl)}
+  extraJsonLd={[
+    comfyUiApplicationNode(siteUrl),
+    comfyUiSourceCodeNode(siteUrl),
+  ]}
   keywords={[
     "comfyui app",
     "comfyui web app",

apps/website/src/pages/p/supported-models/[slug].astro

@@ -4,6 +4,13 @@ import BaseLayout from '../../../layouts/BaseLayout.astro'
 import ModelHeroSection from '../../../components/models/ModelHeroSection.vue'
 import { models, getModelBySlug } from '../../../config/models'
 import { t } from '../../../i18n/translations'
+import type { JsonLdNode } from '../../../utils/jsonLd'
+import {
+  absoluteUrl,
+  jsonLdId,
+  pageContext,
+  softwareApplicationNode,
+} from '../../../utils/jsonLd'
 
 export const getStaticPaths: GetStaticPaths = () => {
   return models.map((model) => ({
@@ -19,7 +26,6 @@ if (model.canonicalSlug) {
 }
 
 const { displayName } = model
-const canonicalURL = new URL(`/p/supported-models/${model.slug}`, Astro.site)
 
 const dirDescriptions: Record<string, string> = {
   diffusion_models: 'a diffusion model that generates images or video from text and image prompts',
@@ -40,55 +46,31 @@ const dirDescriptions: Record<string, string> = {
 const dirDesc = dirDescriptions[model.directory] ?? 'an AI model'
 const whatIsDescription = `${displayName} is ${dirDesc}. You can run it locally in ComfyUI with full control over every parameter, or access it through Comfy Cloud. ComfyUI's node-based workflow editor lets you connect ${displayName} with ControlNets, LoRAs, upscalers, and custom nodes to build any pipeline you need. There are ${model.workflowCount} community workflow templates using ${displayName} on Comfy Hub, ready to load and customize.`
 
-const softwareAppJsonLd = {
-  '@context': 'https://schema.org',
-  '@type': 'SoftwareApplication',
+const pageTitle = `${displayName} in ComfyUI`
+const pageDescription = `Run ${displayName} in ComfyUI with full parameter control. ${model.workflowCount} community workflow templates, step-by-step tutorials, and free local inference.`
+
+const { siteUrl, locale, url } = pageContext(
+  Astro.site,
+  Astro.url.pathname,
+  Astro.currentLocale,
+)
+const softwareId = jsonLdId(url, 'software')
+const software = softwareApplicationNode({
+  siteUrl,
+  id: softwareId,
   name: displayName,
+  url,
   applicationCategory: 'MultimediaApplication',
   operatingSystem: 'Any',
-  url: canonicalURL.href,
-  author: {
-    '@type': 'Organization',
-    name: 'Comfy Org',
-    url: 'https://comfy.org'
-  }
-}
-
-const breadcrumbJsonLd = {
-  '@context': 'https://schema.org',
-  '@type': 'BreadcrumbList',
-  itemListElement: [
-    {
-      '@type': 'ListItem',
-      position: 1,
-      name: t('models.breadcrumb.home'),
-      item: 'https://comfy.org'
-    },
-    {
-      '@type': 'ListItem',
-      position: 2,
-      name: t('models.breadcrumb.models'),
-      item: 'https://comfy.org/p/supported-models'
-    },
-    {
-      '@type': 'ListItem',
-      position: 3,
-      name: displayName
-    }
-  ]
-}
-
-const faqJsonLd = {
-  '@context': 'https://schema.org',
+})
+const faqPage: JsonLdNode = {
   '@type': 'FAQPage',
+  '@id': jsonLdId(url, 'faq'),
   mainEntity: [
     {
       '@type': 'Question',
       name: `What is ${displayName}?`,
-      acceptedAnswer: {
-        '@type': 'Answer',
-        text: whatIsDescription
-      }
+      acceptedAnswer: { '@type': 'Answer', text: whatIsDescription },
     },
     {
       '@type': 'Question',
@@ -97,54 +79,44 @@ const faqJsonLd = {
         '@type': 'Answer',
         text: model.docsUrl
           ? `Follow the step-by-step tutorial at ${model.docsUrl}. You can also load any of the ${model.workflowCount} community workflow templates that use ${displayName} directly in ComfyUI.`
-          : `Open ComfyUI and browse the ${model.workflowCount} community workflow templates that use ${displayName}. Load one as a starting point, then customize the nodes and parameters to fit your use case.`
-      }
+          : `Open ComfyUI and browse the ${model.workflowCount} community workflow templates that use ${displayName}. Load one as a starting point, then customize the nodes and parameters to fit your use case.`,
+      },
     },
     {
       '@type': 'Question',
       name: `How many ComfyUI workflows use ${displayName}?`,
       acceptedAnswer: {
         '@type': 'Answer',
-        text: `There are ${model.workflowCount} community workflow templates that use ${displayName} on Comfy Hub. Each template is ready to run in ComfyUI and can be customized to suit your project.`
-      }
+        text: `There are ${model.workflowCount} community workflow templates that use ${displayName} on Comfy Hub. Each template is ready to run in ComfyUI and can be customized to suit your project.`,
+      },
     },
     {
       '@type': 'Question',
       name: `Is ${displayName} free to use in ComfyUI?`,
       acceptedAnswer: {
         '@type': 'Answer',
-        text: `ComfyUI is free and open source. ${model.huggingFaceUrl ? `${displayName} weights are available to download from Hugging Face.` : `${displayName} is available as a cloud API through Comfy Cloud.`} You only pay for compute when running on Comfy Cloud; local inference on your own hardware is always free.`
-      }
-    }
-  ]
+        text: `ComfyUI is free and open source. ${model.huggingFaceUrl ? `${displayName} weights are available to download from Hugging Face.` : `${displayName} is available as a cloud API through Comfy Cloud.`} You only pay for compute when running on Comfy Cloud; local inference on your own hardware is always free.`,
+      },
+    },
+  ],
 }
-
-const pageTitle = `${displayName} in ComfyUI`
-const pageDescription = `Run ${displayName} in ComfyUI with full parameter control. ${model.workflowCount} community workflow templates, step-by-step tutorials, and free local inference.`
 ---
 
 <BaseLayout
   title={`${pageTitle} — Comfy`}
   description={pageDescription}
   ogImage={model.thumbnailUrl}
+  mainEntityId={softwareId}
+  breadcrumbs={[
+    { name: t('breadcrumb.home', locale), url: absoluteUrl(Astro.site, '/') },
+    {
+      name: t('models.breadcrumb.models', locale),
+      url: absoluteUrl(Astro.site, '/p/supported-models'),
+    },
+    { name: displayName },
+  ]}
+  extraJsonLd={[software, faqPage]}
 >
-  <Fragment slot="head">
-    <script
-      is:inline
-      type="application/ld+json"
-      set:html={JSON.stringify(softwareAppJsonLd)}
-    />
-    <script
-      is:inline
-      type="application/ld+json"
-      set:html={JSON.stringify(breadcrumbJsonLd)}
-    />
-    <script
-      is:inline
-      type="application/ld+json"
-      set:html={JSON.stringify(faqJsonLd)}
-    />
-  </Fragment>
 
   <ModelHeroSection
     displayName={displayName}

apps/website/src/pages/p/supported-models/index.astro

@@ -2,10 +2,29 @@
 import BaseLayout from '../../../layouts/BaseLayout.astro'
 import { models } from '../../../config/models'
 import { t } from '../../../i18n/translations'
+import {
+  absoluteUrl,
+  itemListNode,
+  jsonLdId,
+  pageContext,
+} from '../../../utils/jsonLd'
 
 const title = t('models.index.title')
 const subtitle = t('models.index.subtitle')
 
+const { url, locale } = pageContext(
+  Astro.site,
+  Astro.url.pathname,
+  Astro.currentLocale,
+)
+const modelList = itemListNode(
+  url,
+  title,
+  models.map((model) => ({
+    url: absoluteUrl(Astro.site, `/p/supported-models/${model.slug}`),
+  })),
+)
+
 const dirLabel: Record<string, string> = {
   diffusion_models: 'Diffusion',
   checkpoints: 'Checkpoint',
@@ -26,6 +45,13 @@ const dirLabel: Record<string, string> = {
 <BaseLayout
   title={`${title} — Comfy`}
   description={subtitle}
+  pageType="CollectionPage"
+  mainEntityId={jsonLdId(url, 'itemlist')}
+  breadcrumbs={[
+    { name: t('breadcrumb.home', locale), url: absoluteUrl(Astro.site, '/') },
+    { name: title },
+  ]}
+  extraJsonLd={[modelList]}
 >
   <div class="mx-auto max-w-7xl px-6 py-16 lg:px-8 lg:py-24">
     <header class="mb-12">

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

@@ -5,9 +5,29 @@ import StorySection from '../../components/about/StorySection.vue'
 import OurValuesSection from '../../components/about/OurValuesSection.vue'
 import ValuesSection from '../../components/about/ValuesSection.vue'
 import CareersSection from '../../components/about/CareersSection.vue'
+import { t } from '../../i18n/translations'
+import { absoluteUrl, organizationId, pageContext } from '../../utils/jsonLd'
+
+const { siteUrl, locale } = pageContext(
+  Astro.site,
+  Astro.url.pathname,
+  Astro.currentLocale,
+)
 ---
 
-<BaseLayout title="关于我们 — Comfy" description="了解 ComfyUI 背后的团队和使命——开源的生成式 AI 平台。">
+<BaseLayout
+  title="关于我们 — Comfy"
+  description="了解 ComfyUI 背后的团队和使命——开源的生成式 AI 平台。"
+  pageType="AboutPage"
+  mainEntityId={organizationId(siteUrl)}
+  breadcrumbs={[
+    {
+      name: t('breadcrumb.home', locale),
+      url: absoluteUrl(Astro.site, '/zh-CN'),
+    },
+    { name: t('breadcrumb.about', locale) },
+  ]}
+>
   <HeroSection locale="zh-CN" client:load />
   <StorySection locale="zh-CN" />
   <OurValuesSection locale="zh-CN" />

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

@@ -7,6 +7,13 @@ import TeamPhotosSection from '../../components/careers/TeamPhotosSection.vue'
 import FAQSection from '../../components/common/FAQSection.vue'
 import { fetchRolesForBuild } from '../../utils/ashby'
 import { reportAshbyOutcome } from '../../utils/ashby.ci'
+import { t } from '../../i18n/translations'
+import {
+  absoluteUrl,
+  itemListNode,
+  jsonLdId,
+  pageContext,
+} from '../../utils/jsonLd'
 
 const outcome = await fetchRolesForBuild()
 reportAshbyOutcome(outcome)
@@ -19,11 +26,34 @@ if (outcome.status === 'failed') {
 }
 
 const departments = outcome.snapshot.departments
+
+const { siteUrl, locale, url } = pageContext(
+  Astro.site,
+  Astro.url.pathname,
+  Astro.currentLocale,
+)
+const roles = itemListNode(
+  url,
+  t('breadcrumb.careers', locale),
+  departments.flatMap((department) =>
+    department.roles.map((role) => ({ name: role.title, url: role.jobUrl })),
+  ),
+)
 ---
 
 <BaseLayout
   title="招聘 — Comfy"
   description="加入构建生成式 AI 操作系统的团队。工程、设计、市场营销等岗位开放招聘中。"
+  pageType="CollectionPage"
+  mainEntityId={jsonLdId(url, 'itemlist')}
+  breadcrumbs={[
+    {
+      name: t('breadcrumb.home', locale),
+      url: absoluteUrl(Astro.site, '/zh-CN'),
+    },
+    { name: t('breadcrumb.careers', locale) },
+  ]}
+  extraJsonLd={[roles]}
 >
   <HeroSection locale="zh-CN" />
   <RolesSection locale="zh-CN" departments={departments} client:visible />

apps/website/src/pages/zh-CN/cloud/pricing.astro

@@ -2,9 +2,44 @@
 import BaseLayout from '../../../layouts/BaseLayout.astro'
 import PriceSection from '../../../components/pricing/PriceSection.vue'
 import WhatsIncludedSection from '../../../components/pricing/WhatsIncludedSection.vue'
+import { pricingOffers } from '../../../config/pricing'
+import { t } from '../../../i18n/translations'
+import {
+  absoluteUrl,
+  jsonLdId,
+  pageContext,
+  productNode,
+} from '../../../utils/jsonLd'
+
+const { siteUrl, locale, url } = pageContext(
+  Astro.site,
+  Astro.url.pathname,
+  Astro.currentLocale,
+)
+const productId = jsonLdId(url, 'product')
 ---
 
-<BaseLayout title="定价 — Comfy Cloud">
+<BaseLayout
+  title="定价 — Comfy Cloud"
+  mainEntityId={productId}
+  breadcrumbs={[
+    {
+      name: t('breadcrumb.home', locale),
+      url: absoluteUrl(Astro.site, '/zh-CN'),
+    },
+    { name: 'Comfy Cloud', url: absoluteUrl(Astro.site, '/zh-CN/cloud') },
+    { name: t('breadcrumb.pricing', locale) },
+  ]}
+  extraJsonLd={[
+    productNode({
+      siteUrl,
+      id: productId,
+      name: 'Comfy Cloud',
+      url,
+      offers: pricingOffers(locale),
+    }),
+  ]}
+>
   <PriceSection locale="zh-CN" client:load />
   <WhatsIncludedSection locale="zh-CN" />
 </BaseLayout>

apps/website/src/pages/zh-CN/cloud/supported-nodes.astro

@@ -4,39 +4,47 @@ import HeroSection from '../../../components/cloud-nodes/HeroSection.vue'
 import PackGridSection from '../../../components/cloud-nodes/PackGridSection.vue'
 import { t } from '../../../i18n/translations'
 import { loadPacksForBuild } from '../../../utils/cloudNodes.build'
-import { escapeJsonLd } from '../../../utils/escapeJsonLd'
+import {
+  absoluteUrl,
+  itemListNode,
+  jsonLdId,
+  pageContext,
+} from '../../../utils/jsonLd'
 
 const packs = await loadPacksForBuild()
 
-const siteBase = Astro.site ?? new URL('https://comfy.org')
-const pageUrl = new URL('/zh-CN/cloud/supported-nodes', siteBase).href
-
-const itemListJsonLd = {
-  '@context': 'https://schema.org',
-  '@type': 'ItemList',
-  name: 'Comfy Cloud 支持的自定义节点包',
-  url: pageUrl,
-  numberOfItems: packs.length,
-  itemListElement: packs.map((pack, index) => ({
-    '@type': 'ListItem',
-    position: index + 1,
-    url: new URL(`/zh-CN/cloud/supported-nodes/${pack.id}`, siteBase).href,
+const title = t('cloudNodes.meta.title', 'zh-CN')
+const description = t('cloudNodes.meta.description', 'zh-CN')
+const { url, locale } = pageContext(
+  Astro.site,
+  Astro.url.pathname,
+  Astro.currentLocale,
+)
+const packList = itemListNode(
+  url,
+  title,
+  packs.map((pack) => ({
     name: pack.displayName,
-    image: pack.bannerUrl || pack.iconUrl
-  }))
-}
+    url: absoluteUrl(Astro.site, `/zh-CN/cloud/supported-nodes/${pack.id}`),
+  })),
+)
 ---
 
 <BaseLayout
-  title={t('cloudNodes.meta.title', 'zh-CN')}
-  description={t('cloudNodes.meta.description', 'zh-CN')}
+  title={title}
+  description={description}
+  pageType="CollectionPage"
+  mainEntityId={jsonLdId(url, 'itemlist')}
+  breadcrumbs={[
+    {
+      name: t('breadcrumb.home', locale),
+      url: absoluteUrl(Astro.site, '/zh-CN'),
+    },
+    { name: 'Comfy Cloud', url: absoluteUrl(Astro.site, '/zh-CN/cloud') },
+    { name: t('breadcrumb.supportedNodes', locale) },
+  ]}
+  extraJsonLd={[packList]}
 >
-  <script
-    is:inline
-    slot="head"
-    type="application/ld+json"
-    set:html={escapeJsonLd(itemListJsonLd)}
-  />
   <HeroSection locale="zh-CN" client:visible />
   <PackGridSection locale="zh-CN" packs={packs} client:visible />
 </BaseLayout>

apps/website/src/pages/zh-CN/cloud/supported-nodes/[pack].astro

@@ -7,7 +7,12 @@ import PackDetail from '../../../../components/cloud-nodes/PackDetail.vue'
 import BaseLayout from '../../../../layouts/BaseLayout.astro'
 import { t } from '../../../../i18n/translations'
 import { loadPacksForBuild } from '../../../../utils/cloudNodes.build'
-import { escapeJsonLd } from '../../../../utils/escapeJsonLd'
+import {
+  absoluteUrl,
+  jsonLdId,
+  pageContext,
+  softwareApplicationNode,
+} from '../../../../utils/jsonLd'
 
 export const getStaticPaths: GetStaticPaths = async () => {
   const packs = await loadPacksForBuild()
@@ -29,35 +34,48 @@ const metaDescription = t('cloudNodes.detail.metaDescription', 'zh-CN')
   .replace('{nodeCount}', String(pack.nodes.length))
   .replace('{description}', description)
 
-const siteBase = Astro.site ?? new URL('https://comfy.org')
-const pageUrl = new URL(`/zh-CN/cloud/supported-nodes/${pack.id}`, siteBase).href
-
-const softwareJsonLd = {
-  '@context': 'https://schema.org',
-  '@type': 'SoftwareApplication',
+const { siteUrl, locale, url } = pageContext(
+  Astro.site,
+  Astro.url.pathname,
+  Astro.currentLocale,
+)
+const softwareId = jsonLdId(url, 'software')
+const software = softwareApplicationNode({
+  siteUrl,
+  id: softwareId,
   name: pack.displayName,
+  url,
   applicationCategory: 'DeveloperApplication',
   applicationSubCategory: 'ComfyUI custom-node pack',
   operatingSystem: 'Comfy Cloud (managed)',
-  url: pageUrl,
-  description,
+  description: pack.description || undefined,
   image: pack.bannerUrl || pack.iconUrl,
   softwareVersion: pack.latestVersion,
   license: pack.license,
   codeRepository: pack.repoUrl,
-  author: pack.publisher?.name
-    ? { '@type': 'Person', name: pack.publisher.name }
-    : undefined,
-  offers: { '@type': 'Offer', price: 0, priceCurrency: 'USD' }
-}
+  authorName: pack.publisher?.name,
+  isFree: true,
+})
 ---
 
-<BaseLayout title={title} description={metaDescription} ogImage={pack.bannerUrl}>
-  <script
-    is:inline
-    slot="head"
-    type="application/ld+json"
-    set:html={escapeJsonLd(softwareJsonLd)}
-  />
+<BaseLayout
+  title={title}
+  description={metaDescription}
+  ogImage={pack.bannerUrl}
+  mainEntityId={softwareId}
+  breadcrumbs={[
+    {
+      name: t('breadcrumb.home', locale),
+      url: absoluteUrl(Astro.site, '/zh-CN'),
+    },
+    { name: 'Comfy Cloud', url: absoluteUrl(Astro.site, '/zh-CN/cloud') },
+    {
+      name: t('breadcrumb.supportedNodes', locale),
+      url: absoluteUrl(Astro.site, '/zh-CN/cloud/supported-nodes'),
+    },
+    { name: pack.displayName },
+  ]}
+  extraJsonLd={[software]}
+>
   <PackDetail pack={pack} locale="zh-CN" />
 </BaseLayout>

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

@@ -2,9 +2,28 @@
 import BaseLayout from '../../layouts/BaseLayout.astro'
 import FormSection from '../../components/contact/FormSection.vue'
 import SocialProofBarSection from '../../components/common/SocialProofBarSection.vue'
+import { t } from '../../i18n/translations'
+import { absoluteUrl, organizationId, pageContext } from '../../utils/jsonLd'
+
+const { siteUrl, locale } = pageContext(
+  Astro.site,
+  Astro.url.pathname,
+  Astro.currentLocale,
+)
 ---
 
-<BaseLayout title="联系我们 — Comfy">
+<BaseLayout
+  title="联系我们 — Comfy"
+  pageType="ContactPage"
+  mainEntityId={organizationId(siteUrl)}
+  breadcrumbs={[
+    {
+      name: t('breadcrumb.home', locale),
+      url: absoluteUrl(Astro.site, '/zh-CN'),
+    },
+    { name: t('breadcrumb.contact', locale) },
+  ]}
+>
   <FormSection locale="zh-CN" client:load />
   <SocialProofBarSection />
 </BaseLayout>

apps/website/src/pages/zh-CN/demos/[slug].astro

@@ -7,6 +7,13 @@ import DemoTranscript from '../../../components/demos/DemoTranscript.vue'
 import DemoNavSection from '../../../components/demos/DemoNavSection.vue'
 import { demos, getDemoBySlug, getNextDemo } from '../../../config/demos'
 import { t } from '../../../i18n/translations'
+import type { JsonLdNode } from '../../../utils/jsonLd'
+import {
+  absoluteUrl,
+  jsonLdId,
+  organizationId,
+  pageContext,
+} from '../../../utils/jsonLd'
 
 export const getStaticPaths: GetStaticPaths = () => {
   return demos.map((demo) => ({
@@ -19,68 +26,34 @@ const demo = getDemoBySlug(slug as string)!
 const nextDemo = getNextDemo(slug as string)
 const title = t(demo.title, 'zh-CN')
 const description = t(demo.description, 'zh-CN')
-const canonicalURL = new URL(`/zh-CN/demos/${demo.slug}`, Astro.site)
 
-const howToJsonLd = {
-  '@context': 'https://schema.org',
-  '@type': 'HowTo',
-  name: title,
-  description,
-  image: new URL(demo.ogImage, Astro.site).href,
-  totalTime: demo.durationIso,
-  datePublished: demo.publishedDate,
-  dateModified: demo.modifiedDate,
-  author: {
-    '@type': 'Organization',
-    name: 'Comfy Org',
-    url: 'https://comfy.org'
-  }
-}
-
-const learningResourceJsonLd = {
-  '@context': 'https://schema.org',
-  '@type': 'LearningResource',
-  name: title,
-  description,
-  learningResourceType: 'interactive tutorial',
-  interactivityType: 'active',
-  educationalLevel: demo.difficulty === 'beginner'
+const { siteUrl, locale, url } = pageContext(
+  Astro.site,
+  Astro.url.pathname,
+  Astro.currentLocale,
+)
+const educationalLevel =
+  demo.difficulty === 'beginner'
     ? 'Beginner'
     : demo.difficulty === 'intermediate'
       ? 'Intermediate'
-      : 'Advanced',
-  url: canonicalURL.href,
+      : 'Advanced'
+const learningId = jsonLdId(url, 'learning')
+const learningResource: JsonLdNode = {
+  '@type': 'LearningResource',
+  '@id': learningId,
+  name: title,
+  description,
+  url,
+  image: new URL(demo.ogImage, Astro.site).href,
+  learningResourceType: 'interactive tutorial',
+  interactivityType: 'active',
+  educationalLevel,
+  timeRequired: demo.durationIso,
   datePublished: demo.publishedDate,
   dateModified: demo.modifiedDate,
-  author: {
-    '@type': 'Organization',
-    name: 'Comfy Org',
-    url: 'https://comfy.org'
-  }
-}
-
-const breadcrumbJsonLd = {
-  '@context': 'https://schema.org',
-  '@type': 'BreadcrumbList',
-  itemListElement: [
-    {
-      '@type': 'ListItem',
-      position: 1,
-      name: t('demos.breadcrumb.home', 'zh-CN'),
-      item: 'https://comfy.org/zh-CN'
-    },
-    {
-      '@type': 'ListItem',
-      position: 2,
-      name: t('demos.breadcrumb.demos', 'zh-CN'),
-      item: 'https://comfy.org/zh-CN/demos'
-    },
-    {
-      '@type': 'ListItem',
-      position: 3,
-      name: title
-    }
-  ]
+  isPartOf: { '@id': jsonLdId(url, 'webpage') },
+  author: { '@id': organizationId(siteUrl) },
 }
 ---
 
@@ -88,25 +61,23 @@ const breadcrumbJsonLd = {
   title={`${title} — Comfy`}
   description={description}
   ogImage={demo.ogImage}
+  mainEntityId={learningId}
+  breadcrumbs={[
+    {
+      name: t('breadcrumb.home', locale),
+      url: absoluteUrl(Astro.site, '/zh-CN'),
+    },
+    {
+      name: t('demos.breadcrumb.demos', locale),
+      url: absoluteUrl(Astro.site, '/zh-CN/demos'),
+    },
+    { name: title },
+  ]}
+  extraJsonLd={[learningResource]}
 >
   <Fragment slot="head">
     <meta property="article:published_time" content={demo.publishedDate} />
     <meta property="article:modified_time" content={demo.modifiedDate} />
-    <script
-      is:inline
-      type="application/ld+json"
-      set:html={JSON.stringify(howToJsonLd)}
-    />
-    <script
-      is:inline
-      type="application/ld+json"
-      set:html={JSON.stringify(learningResourceJsonLd)}
-    />
-    <script
-      is:inline
-      type="application/ld+json"
-      set:html={JSON.stringify(breadcrumbJsonLd)}
-    />
     <link rel="preconnect" href="https://demo.arcade.software" />
   </Fragment>
 

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

@@ -8,11 +8,32 @@ import EcoSystemSection from '../../components/product/local/EcoSystemSection.vu
 import ProductCardsSection from '../../components/product/local/ProductCardsSection.vue'
 import FAQSection from '../../components/product/local/FAQSection.vue'
 import { t } from '../../i18n/translations'
+import {
+  absoluteUrl,
+  comfyUiApplicationNode,
+  comfyUiSoftwareId,
+  pageContext,
+} from '../../utils/jsonLd'
+
+const { siteUrl, locale } = pageContext(
+  Astro.site,
+  Astro.url.pathname,
+  Astro.currentLocale,
+)
 ---
 
 <BaseLayout
   title="下载 Comfy 桌面版 — 在您的硬件上运行 AI"
   description={t('download.hero.subtitle', 'zh-CN')}
+  mainEntityId={comfyUiSoftwareId(siteUrl)}
+  breadcrumbs={[
+    {
+      name: t('breadcrumb.home', locale),
+      url: absoluteUrl(Astro.site, '/zh-CN'),
+    },
+    { name: t('breadcrumb.download', locale) },
+  ]}
+  extraJsonLd={[comfyUiApplicationNode(siteUrl)]}
   keywords={['comfyui app', 'comfyui desktop app', 'comfyui download', 'ComfyUI 下载', 'ComfyUI 桌面应用', 'ComfyUI 应用', 'ComfyUI Windows', 'ComfyUI macOS', 'ComfyUI Linux']}
 >
   <CloudBannerSection locale="zh-CN" />

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

@@ -9,11 +9,25 @@ import CaseStudySpotlightSection from '../../components/home/CaseStudySpotlightS
 import GetStartedSection from '../../components/home/GetStartedSection.vue'
 import BuildWhatSection from '../../components/home/BuildWhatSection.vue'
 import { t } from '../../i18n/translations'
+import {
+  comfyUiApplicationNode,
+  comfyUiSoftwareId,
+  comfyUiSourceCodeNode,
+  pageContext,
+} from '../../utils/jsonLd'
+
+const { siteUrl } = pageContext(
+  Astro.site,
+  Astro.url.pathname,
+  Astro.currentLocale,
+)
 ---
 
 <BaseLayout
   title="Comfy — 视觉 AI 的最强可控性"
   description={t('hero.subtitle', 'zh-CN')}
+  mainEntityId={comfyUiSoftwareId(siteUrl)}
+  extraJsonLd={[comfyUiApplicationNode(siteUrl), comfyUiSourceCodeNode(siteUrl)]}
   keywords={['comfyui app', 'comfyui web app', 'comfyui application', 'ComfyUI 应用', 'ComfyUI 网页版', 'ComfyUI 桌面应用', 'ComfyUI 下载', '可视化 AI', '节点式 AI', '生成式 AI 工作流']}
 >
   <HeroSection locale="zh-CN" client:load />

apps/website/src/utils/jsonLd.test.ts

@@ -0,0 +1,212 @@
+import { describe, expect, it } from 'vitest'
+
+import { externalLinks } from '../config/routes'
+import { escapeJsonLd } from './escapeJsonLd'
+import type { JsonLdGraph } from './jsonLd'
+import {
+  absoluteUrl,
+  buildPageGraph,
+  collectGraphIds,
+  comfyUiApplicationNode,
+  comfyUiSoftwareId,
+  comfyUiSourceCodeNode,
+  itemListNode,
+  jsonLdId,
+  organizationId,
+  pageContext,
+  productNode,
+  softwareApplicationNode
+} from './jsonLd'
+
+const siteUrl = 'https://comfy.org'
+const site = new URL('https://comfy.org/')
+
+function typeNames(graph: JsonLdGraph): string[] {
+  return graph['@graph'].map((node) => node['@type'])
+}
+
+describe('absoluteUrl', () => {
+  it('resolves internal paths to their trailing-slash canonical form', () => {
+    expect(absoluteUrl(site, '/cloud')).toBe('https://comfy.org/cloud/')
+    expect(absoluteUrl(site, '/about/')).toBe('https://comfy.org/about/')
+    expect(absoluteUrl(site, '/')).toBe('https://comfy.org/')
+  })
+})
+
+describe('pageContext', () => {
+  it('derives siteUrl, locale and canonical url from the Astro globals', () => {
+    expect(pageContext(site, '/about/', undefined)).toEqual({
+      siteUrl,
+      locale: 'en',
+      url: 'https://comfy.org/about/'
+    })
+    expect(pageContext(site, '/zh-CN/', 'zh-CN').locale).toBe('zh-CN')
+  })
+})
+
+describe('itemListNode', () => {
+  it('counts items and omits per-item names when not supplied', () => {
+    const node = itemListNode('https://comfy.org/careers/', 'Careers', [
+      { url: 'https://jobs.example/1' },
+      { url: 'https://jobs.example/2', name: 'Designer' }
+    ])
+    expect(node.numberOfItems).toBe(2)
+    const items = node.itemListElement as Record<string, unknown>[]
+    expect('name' in items[0]).toBe(false)
+    expect(items[1].name).toBe('Designer')
+  })
+})
+
+describe('softwareApplicationNode', () => {
+  it('claims Comfy Org as author and publisher only when first-party', () => {
+    const node = softwareApplicationNode({
+      siteUrl,
+      id: jsonLdId(siteUrl, 'software'),
+      name: 'ComfyUI',
+      url: siteUrl,
+      firstParty: true,
+      applicationCategory: 'MultimediaApplication',
+      isFree: true
+    })
+    const orgRef = { '@id': organizationId(siteUrl) }
+    expect(node.author).toEqual(orgRef)
+    expect(node.publisher).toEqual(orgRef)
+    expect(node.offers).toEqual({
+      '@type': 'Offer',
+      price: 0,
+      priceCurrency: 'USD',
+      seller: orgRef
+    })
+  })
+
+  it('does not name Comfy Org as seller on a third-party free offer', () => {
+    const node = softwareApplicationNode({
+      siteUrl,
+      id: 'https://comfy.org/cloud/supported-nodes/foo/#software',
+      name: 'Foo Pack',
+      url: 'https://comfy.org/cloud/supported-nodes/foo/',
+      applicationCategory: 'DeveloperApplication',
+      isFree: true
+    })
+    expect((node.offers as Record<string, unknown>).seller).toBeUndefined()
+  })
+
+  it('credits a known third-party author without claiming to publish it', () => {
+    const node = softwareApplicationNode({
+      siteUrl,
+      id: 'https://comfy.org/cloud/supported-nodes/foo/#software',
+      name: 'Foo Pack',
+      url: 'https://comfy.org/cloud/supported-nodes/foo/',
+      applicationCategory: 'DeveloperApplication',
+      authorName: 'Jane Dev'
+    })
+    expect(node.author).toEqual({ '@type': 'Person', name: 'Jane Dev' })
+    expect(node.publisher).toBeUndefined()
+  })
+
+  it('claims no author or publisher for third-party software with no author', () => {
+    const node = softwareApplicationNode({
+      siteUrl,
+      id: 'https://comfy.org/p/supported-models/foo/#software',
+      name: 'Foo Model',
+      url: 'https://comfy.org/p/supported-models/foo/',
+      applicationCategory: 'MultimediaApplication'
+    })
+    expect(node.author).toBeUndefined()
+    expect(node.publisher).toBeUndefined()
+  })
+})
+
+describe('sameAs encyclopedic references', () => {
+  it('links the organization to its Wikidata entity', () => {
+    const graph = buildPageGraph(
+      { siteUrl, locale: 'en' },
+      { url: `${siteUrl}/`, name: 'Home' }
+    )
+    const org = graph['@graph'].find((node) => node['@type'] === 'Organization')
+    expect(org?.sameAs).toContain(externalLinks.wikidataComfyOrg)
+  })
+
+  it('links the ComfyUI application to its Wikidata, Wikipedia and G2 entities', () => {
+    const node = comfyUiApplicationNode(siteUrl)
+    expect(node.sameAs).toEqual([
+      externalLinks.wikidataComfyUi,
+      externalLinks.wikipediaComfyUi,
+      externalLinks.g2ComfyUi
+    ])
+  })
+
+  it('omits sameAs for third-party software', () => {
+    const node = softwareApplicationNode({
+      siteUrl,
+      id: 'https://comfy.org/p/supported-models/foo/#software',
+      name: 'Foo Model',
+      url: 'https://comfy.org/p/supported-models/foo/',
+      applicationCategory: 'MultimediaApplication'
+    })
+    expect(node.sameAs).toBeUndefined()
+  })
+})
+
+describe('productNode', () => {
+  it('gives every offer a currency and price', () => {
+    const node = productNode({
+      siteUrl,
+      id: 'https://comfy.org/cloud/pricing/#product',
+      name: 'Comfy Cloud',
+      url: 'https://comfy.org/cloud/pricing/',
+      offers: [{ name: 'Standard', price: '20' }]
+    })
+    const offers = node.offers as Record<string, unknown>[]
+    expect(offers[0].price).toBe('20')
+    expect(offers[0].priceCurrency).toBe('USD')
+    expect(offers[0].seller).toEqual({ '@id': organizationId(siteUrl) })
+  })
+})
+
+describe('comfyUiSourceCodeNode', () => {
+  it('links the source code to the ComfyUI application via targetProduct', () => {
+    const node = comfyUiSourceCodeNode(siteUrl)
+    expect(node.targetProduct).toEqual({ '@id': comfyUiSoftwareId(siteUrl) })
+  })
+})
+
+describe('buildPageGraph', () => {
+  const url = 'https://comfy.org/cloud/pricing/'
+  const graph = buildPageGraph(
+    { siteUrl, locale: 'en' },
+    {
+      url,
+      name: 'Pricing',
+      type: 'CollectionPage',
+      mainEntityId: jsonLdId(url, 'itemlist'),
+      crumbs: [{ name: 'Home', url: `${siteUrl}/` }, { name: 'Pricing' }]
+    },
+    itemListNode(url, 'Plans', [{ url: `${siteUrl}/one/` }])
+  )
+
+  it('always includes the site-wide organization, website and page entity', () => {
+    expect(typeNames(graph)).toContain('Organization')
+    expect(typeNames(graph)).toContain('WebSite')
+    expect(typeNames(graph)).toContain('CollectionPage')
+  })
+
+  it('produces a graph where every @id reference resolves', () => {
+    const { defined, references } = collectGraphIds(graph)
+    for (const reference of references) {
+      expect(defined.has(reference)).toBe(true)
+    }
+  })
+})
+
+describe('escapeJsonLd on a built graph', () => {
+  it('neutralizes a </script> breakout in a page name', () => {
+    const graph = buildPageGraph(
+      { siteUrl, locale: 'en' },
+      { url: `${siteUrl}/x/`, name: '</script><script>alert(1)</script>' }
+    )
+    const serialized = escapeJsonLd(graph)
+    expect(serialized).not.toContain('</script>')
+    expect(serialized).toContain('\\u003c')
+  })
+})

apps/website/src/utils/jsonLd.ts

@@ -0,0 +1,377 @@
+import { externalLinks } from '../config/routes'
+import type { Locale } from '../i18n/translations'
+
+export type JsonLdNode = Record<string, unknown> & { '@type': string }
+
+export interface JsonLdGraph {
+  '@context': 'https://schema.org'
+  '@graph': JsonLdNode[]
+}
+
+export interface PageContext {
+  siteUrl: string
+  locale: Locale
+}
+
+export type WebPageType =
+  | 'WebPage'
+  | 'AboutPage'
+  | 'ContactPage'
+  | 'CollectionPage'
+
+export interface Crumb {
+  name: string
+  url?: string
+}
+
+const sameAs = [
+  externalLinks.github,
+  externalLinks.x,
+  externalLinks.youtube,
+  externalLinks.discord,
+  externalLinks.instagram,
+  externalLinks.reddit,
+  externalLinks.linkedin,
+  // Wikidata entity for the organization, so the Knowledge Graph can resolve it.
+  externalLinks.wikidataComfyOrg
+]
+
+// Authoritative encyclopedic and review-platform references for the ComfyUI software entity.
+const comfyUiSameAs = [
+  externalLinks.wikidataComfyUi,
+  externalLinks.wikipediaComfyUi,
+  externalLinks.g2ComfyUi
+]
+
+function siteUrlFrom(site: URL | undefined): string {
+  return (site?.href ?? 'https://comfy.org/').replace(/\/$/, '')
+}
+
+export function absoluteUrl(site: URL | undefined, path: string): string {
+  const resolved = new URL(path, site ?? 'https://comfy.org').href
+  return resolved.endsWith('/') ? resolved : `${resolved}/`
+}
+
+export function pageContext(
+  site: URL | undefined,
+  pathname: string,
+  currentLocale: string | undefined
+): PageContext & { url: string } {
+  return {
+    siteUrl: siteUrlFrom(site),
+    locale: currentLocale === 'zh-CN' ? 'zh-CN' : 'en',
+    url: absoluteUrl(site, pathname)
+  }
+}
+
+export function jsonLdId(pageUrl: string, fragment: string): string {
+  return `${pageUrl}#${fragment}`
+}
+
+export function organizationId(siteUrl: string): string {
+  return `${siteUrl}/#organization`
+}
+
+function websiteId(siteUrl: string): string {
+  return `${siteUrl}/#website`
+}
+
+function buildGraph(...nodes: (JsonLdNode | null | undefined)[]): JsonLdGraph {
+  return {
+    '@context': 'https://schema.org',
+    '@graph': nodes.filter((node): node is JsonLdNode => Boolean(node))
+  }
+}
+
+function organizationNode(siteUrl: string): JsonLdNode {
+  return {
+    '@type': 'Organization',
+    '@id': organizationId(siteUrl),
+    name: 'Comfy Org',
+    url: siteUrl,
+    logo: {
+      '@type': 'ImageObject',
+      url: `${siteUrl}/web-app-manifest-512x512.png`,
+      width: 512,
+      height: 512
+    },
+    sameAs
+  }
+}
+
+function websiteNode(siteUrl: string): JsonLdNode {
+  return {
+    '@type': 'WebSite',
+    '@id': websiteId(siteUrl),
+    name: 'Comfy',
+    url: siteUrl,
+    publisher: { '@id': organizationId(siteUrl) }
+  }
+}
+
+function breadcrumbNode(pageUrl: string, crumbs: Crumb[]): JsonLdNode {
+  return {
+    '@type': 'BreadcrumbList',
+    '@id': jsonLdId(pageUrl, 'breadcrumb'),
+    itemListElement: crumbs.map((crumb, index) => {
+      const isLast = index === crumbs.length - 1
+      return isLast || !crumb.url
+        ? { '@type': 'ListItem', position: index + 1, name: crumb.name }
+        : {
+            '@type': 'ListItem',
+            position: index + 1,
+            name: crumb.name,
+            item: crumb.url
+          }
+    })
+  }
+}
+
+export function itemListNode(
+  pageUrl: string,
+  name: string,
+  items: { url: string; name?: string }[]
+): JsonLdNode {
+  return {
+    '@type': 'ItemList',
+    '@id': jsonLdId(pageUrl, 'itemlist'),
+    name,
+    numberOfItems: items.length,
+    itemListElement: items.map((item, index) => ({
+      '@type': 'ListItem',
+      position: index + 1,
+      url: item.url,
+      ...(item.name ? { name: item.name } : {})
+    }))
+  }
+}
+
+interface WebPageInput {
+  siteUrl: string
+  locale: Locale
+  url: string
+  name: string
+  description?: string
+  imageUrl?: string
+  crumbs?: Crumb[]
+  mainEntityId?: string
+}
+
+function webPageNode(input: WebPageInput, type: WebPageType): JsonLdNode {
+  const hasCrumbs = Boolean(input.crumbs && input.crumbs.length > 0)
+  return {
+    '@type': type,
+    '@id': jsonLdId(input.url, 'webpage'),
+    url: input.url,
+    name: input.name,
+    description: input.description,
+    isPartOf: { '@id': websiteId(input.siteUrl) },
+    primaryImageOfPage: input.imageUrl
+      ? { '@type': 'ImageObject', url: input.imageUrl }
+      : undefined,
+    breadcrumb: hasCrumbs
+      ? { '@id': jsonLdId(input.url, 'breadcrumb') }
+      : undefined,
+    mainEntity: input.mainEntityId ? { '@id': input.mainEntityId } : undefined,
+    inLanguage: input.locale
+  }
+}
+
+export interface SoftwareAppInput {
+  siteUrl: string
+  id: string
+  name: string
+  url: string
+  applicationCategory: string
+  firstParty?: boolean
+  applicationSubCategory?: string
+  description?: string
+  operatingSystem?: string
+  image?: string
+  softwareVersion?: string
+  license?: string
+  codeRepository?: string
+  authorName?: string
+  isFree?: boolean
+  sameAs?: string[]
+}
+
+export function softwareApplicationNode(input: SoftwareAppInput): JsonLdNode {
+  const orgRef = { '@id': organizationId(input.siteUrl) }
+  const author = input.firstParty
+    ? orgRef
+    : input.authorName
+      ? { '@type': 'Person', name: input.authorName }
+      : undefined
+  return {
+    '@type': 'SoftwareApplication',
+    '@id': input.id,
+    name: input.name,
+    url: input.url,
+    applicationCategory: input.applicationCategory,
+    applicationSubCategory: input.applicationSubCategory,
+    description: input.description,
+    operatingSystem: input.operatingSystem,
+    image: input.image,
+    softwareVersion: input.softwareVersion,
+    license: input.license,
+    codeRepository: input.codeRepository,
+    author,
+    publisher: input.firstParty ? orgRef : undefined,
+    sameAs: input.sameAs,
+    offers: input.isFree
+      ? {
+          '@type': 'Offer',
+          price: 0,
+          priceCurrency: 'USD',
+          seller: input.firstParty ? orgRef : undefined
+        }
+      : undefined
+  }
+}
+
+interface SourceCodeInput {
+  siteUrl: string
+  id: string
+  name: string
+  codeRepository: string
+  programmingLanguage?: string
+  targetProductId?: string
+}
+
+function softwareSourceCodeNode(input: SourceCodeInput): JsonLdNode {
+  return {
+    '@type': 'SoftwareSourceCode',
+    '@id': input.id,
+    name: input.name,
+    codeRepository: input.codeRepository,
+    programmingLanguage: input.programmingLanguage,
+    targetProduct: input.targetProductId
+      ? { '@id': input.targetProductId }
+      : undefined,
+    author: { '@id': organizationId(input.siteUrl) }
+  }
+}
+
+export function comfyUiSoftwareId(siteUrl: string): string {
+  return `${siteUrl}/#software`
+}
+
+export function comfyUiApplicationNode(siteUrl: string): JsonLdNode {
+  return softwareApplicationNode({
+    siteUrl,
+    id: comfyUiSoftwareId(siteUrl),
+    name: 'ComfyUI',
+    url: siteUrl,
+    firstParty: true,
+    applicationCategory: 'MultimediaApplication',
+    operatingSystem: 'Windows, macOS, Linux',
+    isFree: true,
+    sameAs: comfyUiSameAs
+  })
+}
+
+export function comfyUiSourceCodeNode(siteUrl: string): JsonLdNode {
+  return softwareSourceCodeNode({
+    siteUrl,
+    id: `${siteUrl}/#sourcecode`,
+    name: 'ComfyUI',
+    codeRepository: externalLinks.github,
+    programmingLanguage: 'Python',
+    targetProductId: comfyUiSoftwareId(siteUrl)
+  })
+}
+
+interface OfferInput {
+  name: string
+  price: string | number
+  url?: string
+}
+
+export interface ProductInput {
+  siteUrl: string
+  id: string
+  name: string
+  url: string
+  offers: OfferInput[]
+}
+
+export function productNode(input: ProductInput): JsonLdNode {
+  return {
+    '@type': 'Product',
+    '@id': input.id,
+    name: input.name,
+    url: input.url,
+    brand: { '@id': organizationId(input.siteUrl) },
+    offers: input.offers.map((offer) => ({
+      '@type': 'Offer',
+      name: offer.name,
+      price: offer.price,
+      priceCurrency: 'USD',
+      url: offer.url,
+      seller: { '@id': organizationId(input.siteUrl) },
+      priceSpecification: {
+        '@type': 'UnitPriceSpecification',
+        price: offer.price,
+        priceCurrency: 'USD',
+        unitText: 'MONTH'
+      }
+    }))
+  }
+}
+
+export interface PageGraphInput {
+  url: string
+  name: string
+  type?: WebPageType
+  description?: string
+  imageUrl?: string
+  crumbs?: Crumb[]
+  mainEntityId?: string
+}
+
+export function buildPageGraph(
+  ctx: PageContext,
+  page: PageGraphInput,
+  ...extraNodes: (JsonLdNode | null | undefined)[]
+): JsonLdGraph {
+  const { type = 'WebPage', ...rest } = page
+  const input: WebPageInput = {
+    ...rest,
+    siteUrl: ctx.siteUrl,
+    locale: ctx.locale
+  }
+  const hasCrumbs = Boolean(page.crumbs && page.crumbs.length > 0)
+  return buildGraph(
+    organizationNode(ctx.siteUrl),
+    websiteNode(ctx.siteUrl),
+    webPageNode(input, type),
+    hasCrumbs ? breadcrumbNode(page.url, page.crumbs!) : undefined,
+    ...extraNodes
+  )
+}
+
+export function collectGraphIds(value: unknown): {
+  defined: Set<string>
+  references: string[]
+} {
+  const defined = new Set<string>()
+  const references: string[] = []
+  const walk = (node: unknown): void => {
+    if (Array.isArray(node)) {
+      node.forEach(walk)
+      return
+    }
+    if (node && typeof node === 'object') {
+      const record = node as Record<string, unknown>
+      const id = record['@id']
+      if (typeof id === 'string') {
+        if (Object.keys(record).length === 1) references.push(id)
+        else defined.add(id)
+      }
+      Object.values(record).forEach(walk)
+    }
+  }
+  walk(value)
+  return { defined, references }
+}

browser_tests/fixtures/components/Actionbar.ts

@@ -8,13 +8,11 @@ export class ComfyActionbar {
   public readonly root: Locator
   public readonly queueButton: ComfyQueueButton
   public readonly propertiesButton: Locator
-  public readonly dragHandle: Locator
 
   constructor(public readonly page: Page) {
     this.root = page.locator('.actionbar-container')
     this.queueButton = new ComfyQueueButton(this)
     this.propertiesButton = this.root.getByLabel('Toggle properties panel')
-    this.dragHandle = this.root.locator('.drag-handle')
   }
 
   async isDocked() {

browser_tests/fixtures/components/FreeTierQuota.ts

@@ -1,21 +0,0 @@
-import type { Locator } from '@playwright/test'
-
-import type { ComfyPage } from '@e2e/fixtures/ComfyPage'
-import { TestIds } from '@e2e/fixtures/selectors'
-
-export class FreeTierQuota {
-  readonly root: Locator
-
-  constructor(comfyPage: ComfyPage) {
-    this.root = comfyPage.page.getByTestId(TestIds.topbar.freeTierQuota)
-  }
-
-  async getMax() {
-    const text = await this.root.textContent()
-    return text?.match(/(\d+) \/ (\d+)/)?.[2]
-  }
-  async getAvailable() {
-    const text = await this.root.textContent()
-    return text?.match(/(\d+) \/ (\d+)/)?.[1]
-  }
-}

browser_tests/fixtures/helpers/MaskEditorHelper.ts

@@ -58,17 +58,6 @@ class MaskEditorHelper {
     return dialog
   }
 
-  async reopenDialog(): Promise<Locator> {
-    const imagePreview = this.page.locator('.image-preview').first()
-    await imagePreview.getByRole('region').hover()
-    await this.page.getByLabel('Edit or mask image').click()
-
-    const dialog = this.page.locator('.mask-editor-dialog')
-    await expect(dialog).toBeVisible()
-
-    return dialog
-  }
-
   async drawStrokeOnPointerZone(dialog: Locator) {
     const pointerZone = dialog.getByTestId('pointer-zone')
     await expect(pointerZone).toBeVisible()

browser_tests/fixtures/selectors.ts

@@ -103,8 +103,7 @@ export const TestIds = {
     loginButtonPopoverLearnMore: 'login-button-popover-learn-more',
     workflowTabs: 'topbar-workflow-tabs',
     integratedTabBarActions: 'integrated-tab-bar-actions',
-    actionBarButtons: 'action-bar-buttons',
-    freeTierQuota: 'free-tier-quota'
+    actionBarButtons: 'action-bar-buttons'
   },
   nodeLibrary: {
     bookmarksSection: 'node-library-bookmarks-section'

browser_tests/tests/dialogs/signInDialog.spec.ts

@@ -68,7 +68,7 @@ test.describe('Sign In dialog', { tag: '@ui' }, () => {
     await expect(dialog.privacyLink).toBeVisible()
     await expect(dialog.privacyLink).toHaveAttribute(
       'href',
-      'https://www.comfy.org/privacy-policy'
+      'https://www.comfy.org/privacy'
     )
   })
 

browser_tests/tests/freeTierQuota.spec.ts

@@ -1,63 +0,0 @@
-import { expect, mergeTests } from '@playwright/test'
-
-import { comfyPageFixture as test } from '@e2e/fixtures/ComfyPage'
-import { jsonRoute } from '@e2e/fixtures/utils/jsonRoute'
-import { FreeTierQuota } from '@e2e/fixtures/components/FreeTierQuota'
-import { ExecutionHelper } from '@e2e/fixtures/helpers/ExecutionHelper'
-import { webSocketFixture } from '@e2e/fixtures/ws'
-
-const wstest = mergeTests(test, webSocketFixture)
-
-test.describe('Free Tier Quota', { tag: ['@cloud', '@vue-nodes'] }, () => {
-  test.beforeEach(async ({ page }) => {
-    const features = {
-      free_tier_job_allowance_enabled: true,
-      free_tier_balance: { allowance: 5, remaining: 3, used: 0 }
-    }
-    await page.route('**/api/features', (r) => r.fulfill(jsonRoute(features)))
-  })
-
-  wstest('Free Tier Quota', async ({ comfyPage, comfyMouse, getWebSocket }) => {
-    const execution = new ExecutionHelper(comfyPage, await getWebSocket())
-    const freeTierQuota = new FreeTierQuota(comfyPage)
-
-    await test.step('Populates initial state from config', async () => {
-      await expect.poll(() => freeTierQuota.getAvailable()).toBe('3')
-      expect(await freeTierQuota.getMax()).toBe('5')
-    })
-
-    await test.step('available decrements on run', async () => {
-      await execution.run()
-      await expect.poll(() => freeTierQuota.getAvailable()).toBe('2')
-    })
-
-    await test.step('connects to detached run button', async () => {
-      const handle = comfyPage.actionbar.dragHandle
-      await comfyMouse.dragElementBy(handle, { x: -100, y: 100 })
-      await expect.poll(() => comfyPage.actionbar.isDocked()).toBe(false)
-      expect(await freeTierQuota.getAvailable()).toBe('2')
-      await comfyMouse.dragElementBy(handle, { x: 100, y: -100 })
-      await expect.poll(() => comfyPage.actionbar.isDocked()).toBe(true)
-    })
-
-    await test.step('Detects workflows with Partner nodes', async () => {
-      await comfyPage.searchBoxV2.addNode('Node With Price Badge')
-      const node = await comfyPage.vueNodes.getFixtureByTitle('Price Badge')
-      await expect.poll(() => freeTierQuota.getAvailable()).toBe(undefined)
-      await node.delete()
-      await expect.poll(() => freeTierQuota.getAvailable()).toBe('2')
-    })
-
-    await test.step('Does not decrease past 0', async () => {
-      await execution.run()
-      await expect.poll(() => freeTierQuota.getAvailable()).toBe('1')
-      await execution.run()
-      await expect.poll(() => freeTierQuota.getAvailable()).toBe(undefined)
-      await execution.run()
-      await execution.run()
-      await execution.run()
-      await comfyPage.nextFrame()
-      expect(await freeTierQuota.getAvailable()).toBe(undefined)
-    })
-  })
-})

browser_tests/tests/helpCenter.spec.ts

@@ -77,15 +77,15 @@ test.describe('Help Center', () => {
       expect(url.pathname).toBe('/')
     })
 
-    test('Discord item opens the Discord invite in a new tab', async ({
+    test('Discord item opens comfy.org/discord in a new tab', async ({
       helpCenter
     }) => {
       const url = await waitForPopup(helpCenter.page, () =>
         helpCenter.menuItem('discord').click()
       )
 
-      expect(url.hostname).toBe('discord.com')
-      expect(url.pathname).toBe('/invite/comfyorg')
+      expect(url.hostname).toBe('www.comfy.org')
+      expect(url.pathname).toBe('/discord')
     })
 
     test('Github item opens the ComfyUI repo in a new tab', async ({

browser_tests/tests/maskEditorLoadSave.spec.ts

@@ -67,22 +67,6 @@ test.describe('Mask Editor load/save', { tag: '@vue-nodes' }, () => {
     await expect(dialog).toBeVisible()
   })
 
-  test('Reopening the editor after save restores the drawn mask', async ({
-    maskEditor
-  }) => {
-    const dialog = await maskEditor.openDialog()
-    await maskEditor.drawStrokeAndExpectPixels(dialog)
-    const savedMask = await maskEditor.getCanvasSnapshot(MASK_CANVAS_INDEX)
-
-    await dialog.getByRole('button', { name: 'Save' }).click()
-    await expect(dialog).toBeHidden()
-
-    await maskEditor.reopenDialog()
-    await expect
-      .poll(() => maskEditor.getCanvasSnapshot(MASK_CANVAS_INDEX))
-      .toBe(savedMask)
-  })
-
   test('Save failure keeps dialog open', async ({ comfyPage, maskEditor }) => {
     const dialog = await maskEditor.openDialog()
     await maskEditor.drawStrokeAndExpectPixels(dialog)

browser_tests/tests/minimap.spec.ts

@@ -476,6 +476,37 @@ test.describe('Minimap', { tag: '@canvas' }, () => {
       })
       .toBe(true)
   })
+
+  test(
+    'Closing minimap after subgraph navigation keeps Vue render in sync',
+    { tag: '@vue-nodes' },
+    async ({ comfyPage }) => {
+      await comfyPage.workflow.loadWorkflow('subgraphs/basic-subgraph')
+
+      const subgraphNodeId = await comfyPage.subgraph.findSubgraphNodeId()
+
+      // Round-trip layers Vue's onNodeAdded wrapper on top of the minimap's.
+      await comfyPage.vueNodes.enterSubgraph(subgraphNodeId)
+      await comfyPage.subgraph.exitViaBreadcrumb()
+
+      // Minimap unmount must not clobber the Vue wrapper layered above it.
+      await comfyPage.page
+        .getByTestId(TestIds.canvas.closeMinimapButton)
+        .click()
+
+      const subgraphFixture =
+        await comfyPage.vueNodes.getFixtureByTitle('New Subgraph')
+      await comfyPage.contextMenu.openForVueNode(subgraphFixture.header)
+      await comfyPage.contextMenu.clickMenuItemExact('Unpack Subgraph')
+      await comfyPage.contextMenu.waitForHidden()
+
+      await expect.poll(() => comfyPage.nodeOps.getGraphNodesCount()).toBe(2)
+      await expect.poll(() => comfyPage.vueNodes.getNodeCount()).toBe(2)
+      await expect(
+        comfyPage.vueNodes.getNodeLocator(subgraphNodeId)
+      ).toHaveCount(0)
+    }
+  )
 })
 
 test.describe('Minimap mobile', { tag: ['@mobile', '@canvas'] }, () => {

browser_tests/tests/vueNodes/nodeStates/error.spec.ts

@@ -23,7 +23,6 @@ import { webSocketFixture } from '@e2e/fixtures/ws'
 const test = mergeTests(comfyPageFixture, webSocketFixture)
 
 const ERROR_CLASS = /ring-destructive-background/
-const SLOT_ERROR_CLASS = /before:ring-error/
 const UNKNOWN_NODE_ID = '1'
 const INNER_EXECUTION_ID = '2:1'
 const KSAMPLER_MODEL_INPUT_NAME = 'model'
@@ -70,25 +69,6 @@ async function selectLoadImageNodeForPaste(
   }, localLoadImageId)
 }
 
-async function getInputSlotIndexByName(
-  comfyPage: ComfyPage,
-  nodeId: string,
-  inputName: string
-): Promise<number> {
-  return comfyPage.page.evaluate(
-    ({ inputName, nodeId }) => {
-      const graph = window.app!.canvas.graph ?? window.app!.graph
-      const node = graph.getNodeById(nodeId)
-      const index = node?.findInputSlot(inputName) ?? -1
-      if (index < 0) {
-        throw new Error(`Input slot "${inputName}" not found`)
-      }
-      return index
-    },
-    { inputName, nodeId: toNodeId(nodeId) }
-  )
-}
-
 async function setupLoadImageErrorScenario(comfyPage: ComfyPage) {
   await comfyPage.workflow.loadWorkflow('widgets/load_image_widget')
   const loadImageNode = (
@@ -159,10 +139,17 @@ test.describe('Vue Node Error', { tag: '@vue-nodes' }, () => {
       async ({ comfyPage }) => {
         const ksamplerId = await comfyPage.vueNodes.getNodeIdByTitle('KSampler')
         const ksamplerNode = comfyPage.vueNodes.getNodeLocator(ksamplerId)
-        const modelInputIndex = await getInputSlotIndexByName(
-          comfyPage,
-          ksamplerId,
-          KSAMPLER_MODEL_INPUT_NAME
+        const modelInputIndex = await comfyPage.page.evaluate(
+          ({ nodeId, inputName }) => {
+            const node = window.app!.graph.getNodeById(nodeId)
+            const index =
+              node?.inputs?.findIndex((input) => input.name === inputName) ?? -1
+            if (index < 0) {
+              throw new Error(`Input slot "${inputName}" not found`)
+            }
+            return index
+          },
+          { nodeId: toNodeId(ksamplerId), inputName: KSAMPLER_MODEL_INPUT_NAME }
         )
         const modelInputSlotRow = comfyPage.vueNodes.getInputSlotRow(
           ksamplerId,
@@ -188,7 +175,7 @@ test.describe('Vue Node Error', { tag: '@vue-nodes' }, () => {
 
         await expect(modelInputSlotRow).toBeVisible()
         await expect(modelInputSlotRow).toBeInViewport()
-        await expect(modelInputSlotHighlight).toHaveClass(SLOT_ERROR_CLASS)
+        await expect(modelInputSlotHighlight).toHaveClass(/before:ring-error/)
         await expect(
           comfyPage.vueNodes.getNodeInnerWrapper(ksamplerId)
         ).toHaveClass(ERROR_CLASS)
@@ -420,76 +407,5 @@ test.describe('Vue Node Error', { tag: '@vue-nodes' }, () => {
 
       await expect(innerWrapper).toHaveClass(ERROR_CLASS)
     })
-
-    test('boundary-linked validation error surfaces on the subgraph host', async ({
-      comfyPage
-    }) => {
-      await comfyPage.workflow.loadWorkflow('subgraphs/basic-subgraph')
-      const subgraphParentId =
-        await comfyPage.vueNodes.getNodeIdByTitle('New Subgraph')
-      const innerWrapper =
-        comfyPage.vueNodes.getNodeInnerWrapper(subgraphParentId)
-      const hostInputIndex = await getInputSlotIndexByName(
-        comfyPage,
-        subgraphParentId,
-        'positive'
-      )
-      const hostInputSlotHighlight =
-        comfyPage.vueNodes.getInputSlotConnectionDot(
-          subgraphParentId,
-          hostInputIndex
-        )
-      await expect(
-        innerWrapper,
-        'subgraph host must mount before injecting validation errors'
-      ).toBeVisible()
-      await expect(
-        innerWrapper,
-        'subgraph host should start without an error ring'
-      ).not.toHaveClass(ERROR_CLASS)
-
-      await test.step('surface the boundary-linked error on the host', async () => {
-        const exec = new ExecutionHelper(comfyPage)
-        await exec.mockValidationFailure({
-          [INNER_EXECUTION_ID]: buildKSamplerError(
-            'required_input_missing',
-            'positive',
-            'Required input is missing: positive'
-          )
-        })
-        await comfyPage.runButton.click()
-        await dismissErrorOverlay(comfyPage)
-
-        await expect(innerWrapper).toHaveClass(ERROR_CLASS)
-        await expect(hostInputSlotHighlight).toHaveClass(SLOT_ERROR_CLASS)
-      })
-
-      await test.step('confirm the interior node does not show the surfaced ring', async () => {
-        await comfyPage.vueNodes.enterSubgraph(subgraphParentId)
-        await comfyPage.nextFrame()
-        await expect.poll(() => comfyPage.subgraph.isInSubgraph()).toBe(true)
-        const interiorKSamplerId =
-          await comfyPage.vueNodes.getNodeIdByTitle('KSampler')
-        const interiorPositiveInputIndex = await getInputSlotIndexByName(
-          comfyPage,
-          interiorKSamplerId,
-          'positive'
-        )
-        const interiorPositiveSlotHighlight =
-          comfyPage.vueNodes.getInputSlotConnectionDot(
-            interiorKSamplerId,
-            interiorPositiveInputIndex
-          )
-        const interiorInnerWrapper =
-          comfyPage.vueNodes.getNodeInnerWrapper(interiorKSamplerId)
-
-        await expect(interiorInnerWrapper).toBeVisible()
-        await expect(interiorInnerWrapper).not.toHaveClass(ERROR_CLASS)
-        await expect(interiorPositiveSlotHighlight).toBeVisible()
-        await expect(interiorPositiveSlotHighlight).not.toHaveClass(
-          SLOT_ERROR_CLASS
-        )
-      })
-    })
   })
 })

browser_tests/tests/vueNodes/widgets/emptyNameWidget.spec.ts

@@ -1,61 +0,0 @@
-import {
-  comfyExpect as expect,
-  comfyPageFixture as test
-} from '@e2e/fixtures/ComfyPage'
-import { TestIds } from '@e2e/fixtures/selectors'
-
-const HOST_NODE_TYPE = 'KSampler'
-const HOST_NODE_TITLE = 'KSampler'
-
-/**
- * Regression for #13773: a custom node that registers a client-side widget with
- * an empty/placeholder name produces an un-keyable widget id (empty name
- * segment). Before the fix, `parseWidgetId` threw on that id, which tripped the
- * Vue `NodeWidgets` error boundary and blanked the node's ENTIRE widget grid
- * (e.g. rgthree Power Lora Loader rendered no widgets). The un-storable widget
- * must not take down its schema-declared siblings.
- */
-test.describe(
-  'Empty-name custom widget',
-  { tag: ['@vue-nodes', '@widget'] },
-  () => {
-    test.beforeEach(async ({ comfyPage }) => {
-      // Emulate a custom node registering an extra, un-keyable widget
-      await comfyPage.nodeOps.clearGraph()
-      await comfyPage.nodeOps.addNode(HOST_NODE_TITLE, undefined, {
-        x: 400,
-        y: 200
-      })
-      await comfyPage.page.evaluate(() =>
-        graph!.nodes[0].addWidget('text', '', '', () => {})
-      )
-    })
-
-    test('renders schema widgets despite an un-keyable sibling', async ({
-      comfyPage
-    }) => {
-      const node = comfyPage.vueNodes.getNodeByTitle(HOST_NODE_TITLE)
-      await expect(node).toBeVisible()
-
-      // Precondition: the un-keyable empty-name widget really is on the node, so
-      // this test exercises the regression rather than passing vacuously.
-      await expect
-        .poll(() =>
-          comfyPage.page.evaluate((type) => {
-            const host = window.app!.graph.nodes.find((n) => n.type === type)
-            return host?.widgets?.some((w) => w.name === '') ?? false
-          }, HOST_NODE_TYPE)
-        )
-        .toBe(true)
-
-      // The widget grid must render (v-else branch), not the error boundary.
-      await expect(node.getByTestId(TestIds.widgets.container)).toBeVisible()
-      await expect(node.locator('.node-error')).toHaveCount(0)
-
-      // Schema-declared siblings must still render and be interactable.
-      await expect(node.getByLabel('seed', { exact: true })).toBeVisible()
-      await expect(node.getByLabel('steps', { exact: true })).toBeVisible()
-      await expect(node.getByLabel('cfg', { exact: true })).toBeVisible()
-    })
-  }
-)

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@comfyorg/comfyui-frontend",
-  "version": "1.47.7",
+  "version": "1.48.2",
   "private": true,
   "description": "Official front-end implementation of ComfyUI",
   "homepage": "https://comfy.org",
@@ -114,6 +114,7 @@
     "jsonata": "catalog:",
     "loglevel": "^1.9.2",
     "marked": "^15.0.11",
+    "minisearch": "catalog:",
     "pinia": "catalog:",
     "posthog-js": "catalog:",
     "primeicons": "catalog:",

packages/comfyui-desktop-bridge-types/comfyDesktopBridge.d.ts

@@ -40,11 +40,6 @@ export type ComfyDesktop2TelemetryProperties = Record<
   ComfyDesktop2TelemetryValue | ComfyDesktop2TelemetryValue[]
 >
 
-export type ComfyDesktop2FirebaseAuthState =
-  | { status: 'pending' }
-  | { status: 'signed_out' }
-  | { status: 'signed_in'; userId: string }
-
 export interface ComfyDesktop2TerminalBridge {
   subscribe(installationId?: string): Promise<TerminalRestore>
   unsubscribe(installationId?: string): Promise<void>
@@ -65,7 +60,6 @@ export interface ComfyDesktop2LogsBridge {
 
 export interface ComfyDesktop2TelemetryBridge {
   capture(event: string, properties?: ComfyDesktop2TelemetryProperties): void
-  reportFirebaseAuthState?(state: ComfyDesktop2FirebaseAuthState): void
 }
 
 export interface ComfyDesktop2Bridge {

packages/comfyui-desktop-bridge-types/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@comfyorg/comfyui-desktop-bridge-types",
-  "version": "0.1.3",
+  "version": "0.1.2",
   "description": "TypeScript definitions for the Comfy Desktop hosted frontend bridge",
   "homepage": "https://comfy.org",
   "license": "MIT",

packages/design-system/src/css/style.css

@@ -49,7 +49,7 @@
   --color-gold-500: #fdab34;
   --color-gold-600: #fd9903;
 
-  --color-credit: #ddbd31;
+  --color-credit: #fabc25;
 
   --color-coral-500: #f75951;
   --color-coral-600: #e04e48;
@@ -140,6 +140,26 @@
   --button-surface: var(--color-white);
   --button-surface-contrast: var(--color-black);
 
+  --subscription-button-gradient:
+    linear-gradient(
+      315deg,
+      rgb(105 230 255 / 0.15) 0%,
+      rgb(99 73 233 / 0.5) 100%
+    ),
+    radial-gradient(
+      70.71% 70.71% at 50% 50%,
+      rgb(62 99 222 / 0.15) 0.01%,
+      rgb(66 0 123 / 0.5) 100%
+    ),
+    linear-gradient(
+      92deg,
+      #d000ff 0.38%,
+      #b009fe 37.07%,
+      #3e1ffc 65.17%,
+      #009dff 103.86%
+    ),
+    linear-gradient(var(--color-button-surface, #2d2e32));
+
   /* Code styling colors for help menu*/
   --code-text-color: rgb(0 122 255 / 1);
   --code-bg-color: rgb(96 165 250 / 0.2);

packages/shared-frontend-utils/src/formatUtil.test.ts

@@ -3,7 +3,6 @@ import { describe, expect, it } from 'vitest'
 import {
   appendWorkflowJsonExt,
   ensureWorkflowSuffix,
-  escapeVueI18nMessageSyntax,
   formatLocalizedMediumDate,
   formatLocalizedNumber,
   getFilePathSeparatorVariants,
@@ -478,49 +477,4 @@ describe('formatUtil', () => {
       expect(formatLocalizedMediumDate('not a date', 'en')).toBe('—')
     })
   })
-
-  describe('escapeVueI18nMessageSyntax', () => {
-    it('escapes a literal @ that would break linked-message compilation', () => {
-      expect(
-        escapeVueI18nMessageSyntax('clips (tagged @Audio1-3 in the prompt)')
-      ).toBe("clips (tagged {'@'}Audio1-3 in the prompt)")
-    })
-
-    it('escapes @ in an email address', () => {
-      expect(escapeVueI18nMessageSyntax('support@comfy.org')).toBe(
-        "support{'@'}comfy.org"
-      )
-    })
-
-    it('escapes interpolation braces', () => {
-      expect(escapeVueI18nMessageSyntax('size {w}x{h}')).toBe(
-        "size {'{'}w{'}'}x{'{'}h{'}'}"
-      )
-    })
-
-    it('escapes the plural pipe separator', () => {
-      expect(escapeVueI18nMessageSyntax('foreground | background')).toBe(
-        "foreground {'|'} background"
-      )
-    })
-
-    it('escapes the modulo percent so it cannot re-form %{', () => {
-      expect(escapeVueI18nMessageSyntax('50%{done}')).toBe(
-        "50{'%'}{'{'}done{'}'}"
-      )
-    })
-
-    it('escapes every occurrence in a single pass', () => {
-      expect(escapeVueI18nMessageSyntax('@a @b @c')).toBe(
-        "{'@'}a {'@'}b {'@'}c"
-      )
-    })
-
-    it('leaves strings without syntax characters unchanged', () => {
-      expect(escapeVueI18nMessageSyntax('no special chars here')).toBe(
-        'no special chars here'
-      )
-      expect(escapeVueI18nMessageSyntax('')).toBe('')
-    })
-  })
 })

packages/shared-frontend-utils/src/formatUtil.ts

@@ -178,40 +178,6 @@ export function normalizeI18nKey(key: string) {
   return typeof key === 'string' ? key.replace(/\./g, '_') : ''
 }
 
-/**
- * Characters that vue-i18n's message compiler treats as syntax in message text,
- * so plain text has to escape them to render verbatim through `t()`/`st()`:
- *
- * - `@` starts a linked-message reference (`@:key`); malformed usage throws
- *   `Invalid linked format`.
- * - `{` / `}` delimit interpolation (`{name}`, `{'literal'}`); an unbalanced
- *   brace throws `Unterminated/Unbalanced closing brace`.
- * - `|` separates plural branches, so `a | b` silently renders as one branch.
- * - `%` forms modulo interpolation when immediately followed by `{` (`%{name}`);
- *   it must be escaped too, otherwise escaping a following `{` re-forms `%{`.
- *
- * The set is a build-inlined `const enum` (`TokenChars`) in
- * `@intlify/message-compiler` and is not exported, so it is hardcoded here.
- *
- * @see https://vue-i18n.intlify.dev/guide/essentials/syntax (Special Characters, Literal interpolation)
- * @see https://vue-i18n.intlify.dev/guide/essentials/pluralization
- */
-const VUE_I18N_SYNTAX_CHARS = /[@{}|%]/g
-
-/**
- * Escapes vue-i18n message-syntax characters as literal interpolations (`{'x'}`)
- * so arbitrary text renders verbatim instead of being parsed as syntax. This is
- * the only escape vue-i18n supports; see {@link VUE_I18N_SYNTAX_CHARS}.
- *
- * Only apply to values read through the compiler (`t()`/`st()`). Values read raw
- * via `tm()`/`stRaw()` (e.g. node tooltips) must be left untouched, or the
- * literal `{'x'}` would surface to users. Apply exactly once to raw text: the
- * escape output itself contains `{`/`}`, so it is not idempotent.
- */
-export function escapeVueI18nMessageSyntax(text: string): string {
-  return text.replace(VUE_I18N_SYNTAX_CHARS, (char) => `{'${char}'}`)
-}
-
 /**
  * Takes a dynamic prompt in the format {opt1|opt2|{optA|optB}|} and randomly replaces groups. Supports C style comments.
  * @param input The dynamic prompt to process

pnpm-lock.yaml

@@ -282,6 +282,9 @@ catalogs:
     markdown-table:
       specifier: ^3.0.4
       version: 3.0.4
+    minisearch:
+      specifier: ^7.2.0
+      version: 7.2.0
     mixpanel-browser:
       specifier: ^2.71.0
       version: 2.71.0
@@ -591,6 +594,9 @@ importers:
       marked:
         specifier: ^15.0.11
         version: 15.0.11
+      minisearch:
+        specifier: 'catalog:'
+        version: 7.2.0
       pinia:
         specifier: 'catalog:'
         version: 3.0.4(typescript@5.9.3)(vue@3.5.34(typescript@5.9.3))
@@ -7024,6 +7030,9 @@ packages:
     resolution: {integrity: sha512-tEBHqDnIoM/1rXME1zgka9g6Q2lcoCkxHLuc7ODJ5BxbP5d4c2Z5cGgtXAku59200Cx7diuHTOYfSBD8n6mm8A==}
     engines: {node: '>=16 || 14 >=14.17'}
 
+  minisearch@7.2.0:
+    resolution: {integrity: sha512-dqT2XBYUOZOiC5t2HRnwADjhNS2cecp9u+TJRiJ1Qp/f5qjkeT5APcGPjHw+bz89Ms8Jp+cG4AlE+QZ/QnDglg==}
+
   mitt@3.0.1:
     resolution: {integrity: sha512-vKivATfr97l2/QBCYAkXYDbrIWPM2IIKEl7YPhjCvKlG3kE2gm+uBo6nEXK3M5/Ffh/FLpKExzOQ3JJoJGFKBw==}
 
@@ -8884,8 +8893,8 @@ packages:
   vue-component-type-helpers@3.3.2:
     resolution: {integrity: sha512-l4Z2Y34m7nFMlx8vrslJaVtXxUpzgDMSESC7TakG/c5kwjYT/do+E0NcT2/vWDzaoIhsShg/2OKwX7Q4nbzC0g==}
 
-  vue-component-type-helpers@3.3.5:
-    resolution: {integrity: sha512-Fe1jyPJoUGpJOYKOri44jduR7My4yYINOMJISuMAbmrs+L5LbIDUc8NTWZYY3EJLK0yPLuCmcd5zoCsE4k2/KA==}
+  vue-component-type-helpers@3.3.6:
+    resolution: {integrity: sha512-FkljacAwJ9BUoSUdpFe3VDy0sGigNlTH9+2zcXUWmZOjN8swiCkl3t48wOJun0OsUd2cEIda1l04tsxMiKIIrQ==}
 
   vue-demi@0.14.10:
     resolution: {integrity: sha512-nMZBOwuzabUO0nLgIcc6rycZEebF6eeUfaiQx9+WSk8e29IbLvPU9feI6tqW4kTo3hvoYAJkMh8n8D0fuISphg==}
@@ -11668,7 +11677,7 @@ snapshots:
       storybook: 10.2.10(@testing-library/dom@10.4.1)(prettier@3.7.4)(react-dom@19.2.4(react@19.2.4))(react@19.2.4)
       type-fest: 2.19.0
       vue: 3.5.34(typescript@5.9.3)
-      vue-component-type-helpers: 3.3.5
+      vue-component-type-helpers: 3.3.6
 
   '@swc/helpers@0.5.21':
     dependencies:
@@ -15817,6 +15826,8 @@ snapshots:
 
   minipass@7.1.3: {}
 
+  minisearch@7.2.0: {}
+
   mitt@3.0.1: {}
 
   mixpanel-browser@2.71.0:
@@ -18138,7 +18149,7 @@ snapshots:
 
   vue-component-type-helpers@3.3.2: {}
 
-  vue-component-type-helpers@3.3.5: {}
+  vue-component-type-helpers@3.3.6: {}
 
   vue-demi@0.14.10(vue@3.5.34(typescript@5.9.3)):
     dependencies:

pnpm-workspace.yaml

@@ -103,6 +103,7 @@ catalog:
   lenis: ^1.3.21
   lint-staged: ^16.2.7
   markdown-table: ^3.0.4
+  minisearch: ^7.2.0
   mixpanel-browser: ^2.71.0
   monocart-coverage-reports: ^2.12.9
   oxfmt: ^0.54.0

scripts/cicd/resolve-comfyui-release.test.ts

@@ -1,120 +0,0 @@
-import fs from 'fs'
-import os from 'os'
-import path from 'path'
-import { afterEach, beforeEach, describe, expect, it } from 'vitest'
-
-import {
-  computeTargetVersion,
-  isValidSemver,
-  parseRequirementsVersion,
-  parseTargetBranchOverride
-} from './resolve-comfyui-release'
-
-describe('parseRequirementsVersion', () => {
-  let dir: string
-
-  beforeEach(() => {
-    dir = fs.mkdtempSync(path.join(os.tmpdir(), 'resolve-release-'))
-  })
-
-  afterEach(() => {
-    fs.rmSync(dir, { recursive: true, force: true })
-  })
-
-  function writeRequirements(content: string): string {
-    const filePath = path.join(dir, 'requirements.txt')
-    fs.writeFileSync(filePath, content)
-    return filePath
-  }
-
-  it('parses a pinned == version', () => {
-    const file = writeRequirements(
-      'torch\ncomfyui-frontend-package==1.45.20\nnumpy'
-    )
-    expect(parseRequirementsVersion(file)).toBe('1.45.20')
-  })
-
-  it('parses a >= constraint', () => {
-    const file = writeRequirements('comfyui-frontend-package>=2.0.3')
-    expect(parseRequirementsVersion(file)).toBe('2.0.3')
-  })
-
-  it('returns null when the package is absent', () => {
-    const file = writeRequirements('torch\nnumpy')
-    expect(parseRequirementsVersion(file)).toBeNull()
-  })
-
-  it('returns null when the file is missing', () => {
-    expect(parseRequirementsVersion(path.join(dir, 'nope.txt'))).toBeNull()
-  })
-})
-
-describe('isValidSemver', () => {
-  it('accepts a valid X.Y.Z', () => {
-    expect(isValidSemver('1.45.20')).toBe(true)
-    expect(isValidSemver('2.0.0')).toBe(true)
-  })
-
-  it('rejects non-three-part versions', () => {
-    expect(isValidSemver('1.45')).toBe(false)
-    expect(isValidSemver('1.45.20.1')).toBe(false)
-  })
-
-  it('rejects non-numeric or leading-zero-padded parts', () => {
-    expect(isValidSemver('1.x.0')).toBe(false)
-    expect(isValidSemver('v1.45.20')).toBe(false)
-    expect(isValidSemver('1.045.20')).toBe(false)
-  })
-
-  it('rejects empty / non-string input', () => {
-    expect(isValidSemver('')).toBe(false)
-    // @ts-expect-error exercising runtime guard
-    expect(isValidSemver(undefined)).toBe(false)
-  })
-})
-
-describe('parseTargetBranchOverride', () => {
-  it('parses core/1.47', () => {
-    expect(parseTargetBranchOverride('core/1.47')).toEqual({
-      major: 1,
-      minor: 47,
-      branch: 'core/1.47'
-    })
-  })
-
-  it('parses a major bump core/2.0', () => {
-    expect(parseTargetBranchOverride('core/2.0')).toEqual({
-      major: 2,
-      minor: 0,
-      branch: 'core/2.0'
-    })
-  })
-
-  it('rejects malformed overrides', () => {
-    expect(parseTargetBranchOverride('core/1')).toBeNull()
-    expect(parseTargetBranchOverride('1.47')).toBeNull()
-    expect(parseTargetBranchOverride('core/1.47.0')).toBeNull()
-    expect(parseTargetBranchOverride('release/1.47')).toBeNull()
-    expect(parseTargetBranchOverride('core/v1.47')).toBeNull()
-    expect(parseTargetBranchOverride('')).toBeNull()
-  })
-})
-
-describe('computeTargetVersion', () => {
-  it('bumps patch on a 2.x line when commits exist', () => {
-    expect(computeTargetVersion(2, 0, 'v2.0.3', true)).toBe('2.0.4')
-  })
-
-  it('keeps the tag version when no new commits exist', () => {
-    expect(computeTargetVersion(2, 0, 'v2.0.3', false)).toBe('2.0.3')
-  })
-
-  it('starts a fresh major.minor line at .0 when no tag exists', () => {
-    expect(computeTargetVersion(2, 0, null, true)).toBe('2.0.0')
-    expect(computeTargetVersion(1, 47, null, true)).toBe('1.47.0')
-  })
-
-  it('returns null for a malformed tag', () => {
-    expect(computeTargetVersion(1, 47, 'v1.47', true)).toBeNull()
-  })
-})

scripts/cicd/resolve-comfyui-release.ts

@@ -81,72 +81,15 @@ function isValidSemver(version: string): boolean {
 }
 
 /**
- * Parse a target branch override of the form `core/<major>.<minor>`.
- * Returns the parsed major/minor and normalized branch, or null if malformed.
+ * Get the latest patch tag for a given minor version
  */
-function parseTargetBranchOverride(
-  branch: string
-): { major: number; minor: number; branch: string } | null {
-  const match = branch.match(/^core\/(\d+)\.(\d+)$/)
-  if (!match) {
-    return null
-  }
-  return {
-    major: Number(match[1]),
-    minor: Number(match[2]),
-    branch
-  }
-}
-
-/**
- * Compute the next release version for a target major.minor line.
- *
- * With no prior tag, the line starts at `.0`. With a prior tag, the patch is
- * bumped when there are pending commits, otherwise the tagged version stands.
- * Returns null if the tag is not valid semver.
- */
-function computeTargetVersion(
-  targetMajor: number,
-  targetMinor: number,
-  latestPatchTag: string | null,
-  hasPendingCommits: boolean
-): string | null {
-  if (!latestPatchTag) {
-    return `${targetMajor}.${targetMinor}.0`
-  }
-
-  const tagVersion = latestPatchTag.replace('v', '')
-  if (!isValidSemver(tagVersion)) {
-    return null
-  }
-
-  const existingPatch = Number(tagVersion.split('.')[2])
-  return hasPendingCommits
-    ? `${targetMajor}.${targetMinor}.${existingPatch + 1}`
-    : tagVersion
-}
-
-/**
- * Check whether a branch exists on origin in the given repo.
- */
-function branchExists(branch: string, repoPath: string): boolean {
-  return Boolean(exec(`git rev-parse --verify origin/${branch}`, repoPath))
-}
-
-/**
- * Get the latest patch tag for a given major.minor version
- */
-function getLatestPatchTag(
-  repoPath: string,
-  major: number,
-  minor: number
-): string | null {
+function getLatestPatchTag(repoPath: string, minor: number): string | null {
   // Fetch all tags
   exec('git fetch --tags', repoPath)
 
   // Use git's native version sorting to get the latest tag
   const latestTag = exec(
-    `git tag -l 'v${major}.${minor}.*' --sort=-version:refname | head -n 1`,
+    `git tag -l 'v1.${minor}.*' --sort=-version:refname | head -n 1`,
     repoPath
   )
 
@@ -158,7 +101,7 @@ function getLatestPatchTag(
   const validTagRegex = /^v\d+\.\d+\.\d+$/
   if (!validTagRegex.test(latestTag)) {
     console.error(
-      `Latest tag for version ${major}.${minor} is not valid semver: ${latestTag}`
+      `Latest tag for minor version ${minor} is not valid semver: ${latestTag}`
     )
     return null
   }
@@ -189,106 +132,85 @@ function resolveRelease(
     return null
   }
 
-  const [currentMajor, currentMinor] = currentVersion.split('.').map(Number)
+  const [major, currentMinor, patch] = currentVersion.split('.').map(Number)
 
   // Fetch all branches
   exec('git fetch origin', frontendRepoPath)
 
-  // Target major defaults to the current pin's major, but a TARGET_BRANCH
-  // override (below) can retarget both major and minor.
-  let targetMajor = currentMajor
+  // Determine target branch based on release type:
+  //   'patch' → target current minor (hotfix for production version)
+  //   'minor' → try next minor, fall back to current minor (bi-weekly cadence)
+  const releaseTypeInput =
+    process.env.RELEASE_TYPE?.trim().toLowerCase() || 'minor'
+  if (releaseTypeInput !== 'minor' && releaseTypeInput !== 'patch') {
+    console.error(
+      `Invalid RELEASE_TYPE: "${releaseTypeInput}". Expected "minor" or "patch"`
+    )
+    return null
+  }
+  const releaseType: 'minor' | 'patch' = releaseTypeInput
   let targetMinor: number
   let targetBranch: string
 
-  const targetBranchOverride = process.env.TARGET_BRANCH?.trim()
+  if (releaseType === 'patch') {
+    targetMinor = currentMinor
+    targetBranch = `core/1.${targetMinor}`
 
-  if (targetBranchOverride) {
-    // Manual override takes precedence over RELEASE_TYPE / pin-derived selection.
-    const parsed = parseTargetBranchOverride(targetBranchOverride)
-    if (!parsed) {
+    const branchExists = exec(
+      `git rev-parse --verify origin/${targetBranch}`,
+      frontendRepoPath
+    )
+
+    if (!branchExists) {
       console.error(
-        `Invalid TARGET_BRANCH: "${targetBranchOverride}". Expected format: core/<major>.<minor> (e.g. core/1.47 or core/2.0)`
-      )
-      return null
-    }
-
-    targetMajor = parsed.major
-    targetMinor = parsed.minor
-    targetBranch = parsed.branch
-
-    if (!branchExists(targetBranch, frontendRepoPath)) {
-      console.error(
-        `Manual override branch ${targetBranch} does not exist in frontend repo`
+        `Patch release requested but branch ${targetBranch} does not exist`
       )
       return null
     }
 
     console.error(
-      `Manual override: targeting ${targetBranch} (ignoring release_type)`
+      `Patch release: targeting current production branch ${targetBranch}`
     )
   } else {
-    // Determine target branch based on release type:
-    //   'patch' → target current minor (hotfix for production version)
-    //   'minor' → try next minor, fall back to current minor (bi-weekly cadence)
-    const releaseTypeInput =
-      process.env.RELEASE_TYPE?.trim().toLowerCase() || 'minor'
-    if (releaseTypeInput !== 'minor' && releaseTypeInput !== 'patch') {
-      console.error(
-        `Invalid RELEASE_TYPE: "${releaseTypeInput}". Expected "minor" or "patch"`
-      )
-      return null
-    }
-    const releaseType: 'minor' | 'patch' = releaseTypeInput
+    // Try next minor first, fall back to current minor if not available
+    targetMinor = currentMinor + 1
+    targetBranch = `core/1.${targetMinor}`
 
-    if (releaseType === 'patch') {
+    const nextMinorExists = exec(
+      `git rev-parse --verify origin/${targetBranch}`,
+      frontendRepoPath
+    )
+
+    if (!nextMinorExists) {
+      // Fall back to current minor for minor release
       targetMinor = currentMinor
-      targetBranch = `core/${targetMajor}.${targetMinor}`
+      targetBranch = `core/1.${targetMinor}`
 
-      if (!branchExists(targetBranch, frontendRepoPath)) {
+      const currentMinorExists = exec(
+        `git rev-parse --verify origin/${targetBranch}`,
+        frontendRepoPath
+      )
+
+      if (!currentMinorExists) {
         console.error(
-          `Patch release requested but branch ${targetBranch} does not exist`
+          `Neither core/1.${currentMinor + 1} nor core/1.${currentMinor} branches exist in frontend repo`
         )
         return null
       }
 
       console.error(
-        `Patch release: targeting current production branch ${targetBranch}`
+        `Next minor branch core/1.${currentMinor + 1} not found, falling back to core/1.${currentMinor} for minor release`
       )
-    } else {
-      // Try next minor first, fall back to current minor if not available
-      targetMinor = currentMinor + 1
-      targetBranch = `core/${targetMajor}.${targetMinor}`
-
-      if (!branchExists(targetBranch, frontendRepoPath)) {
-        // Fall back to current minor for minor release
-        targetMinor = currentMinor
-        targetBranch = `core/${targetMajor}.${targetMinor}`
-
-        if (!branchExists(targetBranch, frontendRepoPath)) {
-          console.error(
-            `Neither core/${targetMajor}.${currentMinor + 1} nor core/${targetMajor}.${currentMinor} branches exist in frontend repo`
-          )
-          return null
-        }
-
-        console.error(
-          `Next minor branch core/${targetMajor}.${currentMinor + 1} not found, falling back to core/${targetMajor}.${currentMinor} for minor release`
-        )
-      }
     }
   }
 
-  // Get latest patch tag for target major.minor
-  const latestPatchTag = getLatestPatchTag(
-    frontendRepoPath,
-    targetMajor,
-    targetMinor
-  )
+  // Get latest patch tag for target minor
+  const latestPatchTag = getLatestPatchTag(frontendRepoPath, targetMinor)
 
-  let needsRelease: boolean
-  let branchHeadSha: string | null
+  let needsRelease = false
+  let branchHeadSha: string | null = null
   let tagCommitSha: string | null = null
-  let targetVersion: string
+  let targetVersion = currentVersion
 
   if (latestPatchTag) {
     // Get commit SHA for the tag
@@ -309,23 +231,34 @@ function resolveRelease(
     const commitCount = parseInt(commitsBetween, 10)
     needsRelease = !isNaN(commitCount) && commitCount > 0
 
-    const nextVersion = computeTargetVersion(
-      targetMajor,
-      targetMinor,
-      latestPatchTag,
-      needsRelease
-    )
-    if (!nextVersion) {
+    // Parse existing patch number and increment if needed
+    const tagVersion = latestPatchTag.replace('v', '')
+
+    // Validate tag version format
+    if (!isValidSemver(tagVersion)) {
       console.error(
-        `Invalid tag version format: ${latestPatchTag}. Expected format: vX.Y.Z`
+        `Invalid tag version format: ${tagVersion}. Expected format: X.Y.Z`
       )
       return null
     }
-    targetVersion = nextVersion
+
+    const [, , existingPatch] = tagVersion.split('.').map(Number)
+
+    // Validate existingPatch is a valid number
+    if (!Number.isFinite(existingPatch) || existingPatch < 0) {
+      console.error(`Invalid patch number in tag: ${existingPatch}`)
+      return null
+    }
+
+    if (needsRelease) {
+      targetVersion = `1.${targetMinor}.${existingPatch + 1}`
+    } else {
+      targetVersion = tagVersion
+    }
   } else {
-    // No tags exist for this major.minor version, need to create the .0 patch
+    // No tags exist for this minor version, need to create v1.{targetMinor}.0
     needsRelease = true
-    targetVersion = `${targetMajor}.${targetMinor}.0`
+    targetVersion = `1.${targetMinor}.0`
     branchHeadSha = exec(
       `git rev-parse origin/${targetBranch}`,
       frontendRepoPath
@@ -348,41 +281,26 @@ function resolveRelease(
   }
 }
 
-/**
- * Main execution: parse args, resolve, and print the JSON result.
- */
-function main(): void {
-  const comfyuiRepoPath = process.argv[2]
-  const frontendRepoPath = process.argv[3] || process.cwd()
+// Main execution
+const comfyuiRepoPath = process.argv[2]
+const frontendRepoPath = process.argv[3] || process.cwd()
 
-  if (!comfyuiRepoPath) {
-    console.error(
-      'Usage: resolve-comfyui-release.ts <comfyui-repo-path> [frontend-repo-path]'
-    )
-    process.exit(1)
-  }
-
-  const releaseInfo = resolveRelease(comfyuiRepoPath, frontendRepoPath)
-
-  if (!releaseInfo) {
-    console.error('Failed to resolve release information')
-    process.exit(1)
-  }
-
-  // Output as JSON for GitHub Actions
-  // oxlint-disable-next-line no-console -- stdout is captured by the workflow
-  console.log(JSON.stringify(releaseInfo, null, 2))
+if (!comfyuiRepoPath) {
+  console.error(
+    'Usage: resolve-comfyui-release.ts <comfyui-repo-path> [frontend-repo-path]'
+  )
+  process.exit(1)
 }
 
-// Only run when invoked directly, not when imported by tests.
-if (process.argv[1] && import.meta.url === `file://${process.argv[1]}`) {
-  main()
+const releaseInfo = resolveRelease(comfyuiRepoPath, frontendRepoPath)
+
+if (!releaseInfo) {
+  console.error('Failed to resolve release information')
+  process.exit(1)
 }
 
-export {
-  computeTargetVersion,
-  isValidSemver,
-  parseRequirementsVersion,
-  parseTargetBranchOverride,
-  resolveRelease
-}
+// Output as JSON for GitHub Actions
+// oxlint-disable-next-line no-console -- stdout is captured by the workflow
+console.log(JSON.stringify(releaseInfo, null, 2))
+
+export { resolveRelease }

scripts/collect-i18n-node-defs.ts

@@ -3,10 +3,7 @@ import * as fs from 'fs'
 import type { ComfyNodeDef } from '@/schemas/nodeDefSchema'
 
 import { comfyPageFixture as test } from '../browser_tests/fixtures/ComfyPage'
-import {
-  escapeVueI18nMessageSyntax,
-  normalizeI18nKey
-} from '@/utils/formatUtil'
+import { normalizeI18nKey } from '../packages/shared-frontend-utils/src/formatUtil'
 import type { ComfyNodeDefImpl } from '../src/stores/nodeDefStore'
 
 const localePath = './src/locales/en/main.json'
@@ -47,6 +44,8 @@ test('collect-i18n-node-defs', async ({ comfyPage }) => {
     }
   )
 
+  console.log(`Collected ${nodeDefs.length} node definitions`)
+
   const allDataTypesLocale = Object.fromEntries(
     nodeDefs
       .flatMap((nodeDef) => {
@@ -61,7 +60,7 @@ test('collect-i18n-node-defs', async ({ comfyPage }) => {
         )
         return allDataTypes.map((dataType) => [
           normalizeI18nKey(dataType),
-          escapeVueI18nMessageSyntax(dataType)
+          dataType
         ])
       })
       .sort((a, b) => a[0].localeCompare(b[0]))
@@ -99,10 +98,7 @@ test('collect-i18n-node-defs', async ({ comfyPage }) => {
         const runtimeWidgets = Object.fromEntries(
           Object.entries(widgetsMappings)
             .sort((a, b) => a[0].localeCompare(b[0]))
-            .map(([key, value]) => [
-              normalizeI18nKey(key),
-              { name: value ? escapeVueI18nMessageSyntax(value) : value }
-            ])
+            .map(([key, value]) => [normalizeI18nKey(key), { name: value }])
         )
 
         if (Object.keys(runtimeWidgets).length > 0) {
@@ -125,10 +121,7 @@ test('collect-i18n-node-defs', async ({ comfyPage }) => {
   function extractInputs(nodeDef: ComfyNodeDefImpl) {
     const inputs = Object.fromEntries(
       Object.values(nodeDef.inputs).flatMap((input) => {
-        const name =
-          input.name === undefined
-            ? undefined
-            : escapeVueI18nMessageSyntax(input.name)
+        const name = input.name
         const tooltip = input.tooltip
 
         if (name === undefined && tooltip === undefined) {
@@ -153,10 +146,7 @@ test('collect-i18n-node-defs', async ({ comfyPage }) => {
     const outputs = Object.fromEntries(
       nodeDef.outputs.flatMap((output, i) => {
         // Ignore data types if they are already translated in allDataTypesLocale.
-        const name =
-          output.name === undefined || output.name in allDataTypesLocale
-            ? undefined
-            : escapeVueI18nMessageSyntax(output.name)
+        const name = output.name in allDataTypesLocale ? undefined : output.name
         const tooltip = output.tooltip
 
         if (name === undefined && tooltip === undefined) {
@@ -189,12 +179,8 @@ test('collect-i18n-node-defs', async ({ comfyPage }) => {
         return [
           normalizeI18nKey(nodeDef.name),
           {
-            display_name: escapeVueI18nMessageSyntax(
-              nodeDef.display_name ?? nodeDef.name
-            ),
-            description: nodeDef.description
-              ? escapeVueI18nMessageSyntax(nodeDef.description)
-              : undefined,
+            display_name: nodeDef.display_name ?? nodeDef.name,
+            description: nodeDef.description || undefined,
             inputs: Object.keys(inputs).length > 0 ? inputs : undefined,
             outputs: extractOutputs(nodeDef)
           }
@@ -206,10 +192,7 @@ test('collect-i18n-node-defs', async ({ comfyPage }) => {
     nodeDefs.flatMap((nodeDef) =>
       nodeDef.category
         .split('/')
-        .map((category) => [
-          normalizeI18nKey(category),
-          escapeVueI18nMessageSyntax(category)
-        ])
+        .map((category) => [normalizeI18nKey(category), category])
     )
   )
 

src/components/TopMenuSection.test.ts

@@ -629,7 +629,7 @@ describe('TopMenuSection', () => {
       await nextTick()
 
       expect(querySpy).toHaveBeenCalledTimes(1)
-      expect(actionbarContainer!.classList).not.toContain('w-0')
+      expect(actionbarContainer!.classList).toContain('px-2')
     } finally {
       unmount()
       vi.unstubAllGlobals()

src/components/TopMenuSection.vue

@@ -11,7 +11,7 @@
       </div>
 
       <div class="mx-1 flex flex-col items-end gap-1">
-        <div class="flex items-start gap-2">
+        <div class="flex items-center gap-2">
           <div
             v-if="managerState.shouldShowManagerButtons.value || isCloud"
             class="pointer-events-auto flex h-12 shrink-0 items-center rounded-lg border border-interface-stroke bg-comfy-menu-bg px-2 shadow-interface"
@@ -34,75 +34,61 @@
             </Button>
           </div>
 
-          <div
-            class="pointer-events-auto z-1 flex flex-col rounded-lg border border-interface-stroke bg-comfy-menu-bg px-2 py-1.75 shadow-interface"
-          >
+          <div ref="actionbarContainerRef" :class="actionbarContainerClass">
+            <ActionBarButtons />
+            <!-- Support for legacy topbar elements attached by custom scripts, hidden if no elements present -->
             <div
-              ref="actionbarContainerRef"
-              :class="
-                cn(
-                  'actionbar-container relative flex items-center gap-2',
-                  isActionbarContainerEmpty &&
-                    '-ml-2 w-0 min-w-0 border-transparent shadow-none has-[.border-dashed]:ml-0 has-[.border-dashed]:w-auto has-[.border-dashed]:min-w-auto has-[.border-dashed]:border-interface-stroke has-[.border-dashed]:pl-2 has-[.border-dashed]:shadow-interface'
-                )
-              "
-            >
-              <ActionBarButtons />
-              <!-- Support for legacy topbar elements attached by custom scripts, hidden if no elements present -->
-              <div
-                ref="legacyCommandsContainerRef"
-                data-testid="legacy-topbar-container"
-                class="[&:not(:has(*>*:not(:empty)))]:hidden"
-              ></div>
+              ref="legacyCommandsContainerRef"
+              data-testid="legacy-topbar-container"
+              class="[&:not(:has(*>*:not(:empty)))]:hidden"
+            ></div>
 
-              <ComfyActionbar
-                :top-menu-container="actionbarContainerRef"
-                :queue-overlay-expanded="isQueueOverlayExpanded"
-                @update:progress-target="updateProgressTarget"
-              />
-              <CurrentUserButton
-                v-if="isLoggedIn && !isIntegratedTabBar"
-                class="shrink-0"
-              />
-              <LoginButton v-else-if="isDesktop && !isIntegratedTabBar" />
+            <ComfyActionbar
+              :top-menu-container="actionbarContainerRef"
+              :queue-overlay-expanded="isQueueOverlayExpanded"
+              @update:progress-target="updateProgressTarget"
+            />
+            <CurrentUserButton
+              v-if="isLoggedIn && !isIntegratedTabBar"
+              class="shrink-0"
+            />
+            <LoginButton v-else-if="isDesktop && !isIntegratedTabBar" />
+            <Button
+              v-if="isCloud && flags.workflowSharingEnabled"
+              v-tooltip.bottom="shareTooltipConfig"
+              variant="secondary"
+              :aria-label="t('actionbar.shareTooltip')"
+              @click="() => openShareDialog().catch(toastErrorHandler)"
+              @pointerenter="prefetchShareDialog"
+            >
+              <i class="icon-[comfy--send] size-4" />
+              <span class="not-md:hidden">
+                {{ t('actionbar.share') }}
+              </span>
+            </Button>
+            <div v-if="!isRightSidePanelOpen" class="relative">
               <Button
-                v-if="isCloud && flags.workflowSharingEnabled"
-                v-tooltip.bottom="shareTooltipConfig"
+                v-tooltip.bottom="rightSidePanelTooltipConfig"
+                :class="
+                  cn(
+                    showErrorIndicatorOnPanelButton &&
+                      'outline-1 outline-destructive-background'
+                  )
+                "
                 variant="secondary"
-                :aria-label="t('actionbar.shareTooltip')"
-                @click="() => openShareDialog().catch(toastErrorHandler)"
-                @pointerenter="prefetchShareDialog"
+                size="icon"
+                :aria-label="t('rightSidePanel.togglePanel')"
+                @click="openRightSidePanel"
               >
-                <i class="icon-[comfy--send] size-4" />
-                <span class="not-md:hidden">
-                  {{ t('actionbar.share') }}
-                </span>
+                <i class="icon-[lucide--panel-right] size-4" />
               </Button>
-              <div v-if="!isRightSidePanelOpen" class="relative">
-                <Button
-                  v-tooltip.bottom="rightSidePanelTooltipConfig"
-                  :class="
-                    cn(
-                      showErrorIndicatorOnPanelButton &&
-                        'outline-1 outline-destructive-background'
-                    )
-                  "
-                  variant="secondary"
-                  size="icon"
-                  :aria-label="t('rightSidePanel.togglePanel')"
-                  @click="openRightSidePanel"
-                >
-                  <i class="icon-[lucide--panel-right] size-4" />
-                </Button>
-                <StatusBadge
-                  v-if="showErrorIndicatorOnPanelButton"
-                  variant="dot"
-                  severity="danger"
-                  class="absolute -top-1 -right-1"
-                />
-              </div>
+              <StatusBadge
+                v-if="showErrorIndicatorOnPanelButton"
+                variant="dot"
+                severity="danger"
+                class="absolute -top-1 -right-1"
+              />
             </div>
-            <FreeTierQuota v-if="!isActionbarFloating" />
           </div>
         </div>
         <ErrorOverlay />
@@ -161,7 +147,6 @@ import { useCurrentUser } from '@/composables/auth/useCurrentUser'
 import { useQueueFeatureFlags } from '@/composables/queue/useQueueFeatureFlags'
 import { useErrorHandling } from '@/composables/useErrorHandling'
 import { buildTooltipConfig } from '@/composables/useTooltipConfig'
-import FreeTierQuota from '@/platform/cloud/subscription/components/FreeTierQuota.vue'
 import { useSettingStore } from '@/platform/settings/settingStore'
 import { useTelemetry } from '@/platform/telemetry'
 import { app } from '@/scripts/app'
@@ -224,6 +209,21 @@ const hasDockedButtons = computed(() => {
 const isActionbarContainerEmpty = computed(
   () => isActionbarFloating.value && !hasDockedButtons.value
 )
+const actionbarContainerClass = computed(() => {
+  const base =
+    'actionbar-container pointer-events-auto relative flex h-12 items-center gap-2 rounded-lg border bg-comfy-menu-bg shadow-interface'
+
+  if (isActionbarContainerEmpty.value) {
+    return cn(
+      base,
+      '-ml-2 w-0 min-w-0 border-transparent shadow-none',
+      'has-[.border-dashed]:ml-0 has-[.border-dashed]:w-auto has-[.border-dashed]:min-w-auto',
+      'has-[.border-dashed]:border-interface-stroke has-[.border-dashed]:pl-2 has-[.border-dashed]:shadow-interface'
+    )
+  }
+
+  return cn(base, 'px-2', 'border-interface-stroke')
+})
 const isIntegratedTabBar = computed(
   () => settingStore.get('Comfy.UI.TabBarLayout') !== 'Legacy'
 )

src/components/actionbar/ComfyActionbar.vue

@@ -75,7 +75,6 @@
         </Button>
         <ContextMenu ref="queueContextMenu" :model="queueContextMenuItems" />
       </div>
-      <FreeTierQuota v-if="!isDocked" />
     </Panel>
 
     <Teleport v-if="inlineProgressTarget" :to="inlineProgressTarget">
@@ -110,7 +109,6 @@ import QueueInlineProgress from '@/components/queue/QueueInlineProgress.vue'
 import Button from '@/components/ui/button/Button.vue'
 import { useQueueFeatureFlags } from '@/composables/queue/useQueueFeatureFlags'
 import { buildTooltipConfig } from '@/composables/useTooltipConfig'
-import FreeTierQuota from '@/platform/cloud/subscription/components/FreeTierQuota.vue'
 import { useSettingStore } from '@/platform/settings/settingStore'
 import { useTelemetry } from '@/platform/telemetry'
 import { useCommandStore } from '@/stores/commandStore'

src/components/actionbar/ComfyRunButton/CloudRunButtonWrapper.test.ts

@@ -4,11 +4,11 @@ import { nextTick, ref } from 'vue'
 
 import CloudRunButtonWrapper from './CloudRunButtonWrapper.vue'
 
-const mockCanRunWorkflows = ref(true)
+const mockIsActiveSubscription = ref(true)
 
 vi.mock('@/composables/billing/useBillingContext', () => ({
   useBillingContext: () => ({
-    canRunWorkflows: mockCanRunWorkflows
+    isActiveSubscription: mockIsActiveSubscription
   })
 }))
 
@@ -32,7 +32,7 @@ function renderWrapper() {
 
 describe('CloudRunButtonWrapper', () => {
   beforeEach(() => {
-    mockCanRunWorkflows.value = true
+    mockIsActiveSubscription.value = true
   })
 
   it('renders the runnable queue button when the subscription is active', () => {
@@ -45,7 +45,7 @@ describe('CloudRunButtonWrapper', () => {
   })
 
   it('locks the run button when the subscription is inactive', () => {
-    mockCanRunWorkflows.value = false
+    mockIsActiveSubscription.value = false
     renderWrapper()
 
     expect(screen.getByTestId('subscribe-to-run-button')).toBeInTheDocument()
@@ -53,12 +53,12 @@ describe('CloudRunButtonWrapper', () => {
   })
 
   it('unlocks the run button once the subscription becomes active again', async () => {
-    mockCanRunWorkflows.value = false
+    mockIsActiveSubscription.value = false
     renderWrapper()
 
     expect(screen.getByTestId('subscribe-to-run-button')).toBeInTheDocument()
 
-    mockCanRunWorkflows.value = true
+    mockIsActiveSubscription.value = true
     await nextTick()
 
     expect(screen.getByTestId('queue-button')).toBeInTheDocument()

src/components/actionbar/ComfyRunButton/CloudRunButtonWrapper.vue

@@ -1,7 +1,7 @@
 <template>
   <component
     :is="currentButton"
-    :key="canRunWorkflows ? 'queue' : 'subscribe'"
+    :key="isActiveSubscription ? 'queue' : 'subscribe'"
   />
 </template>
 <script setup lang="ts">
@@ -11,9 +11,9 @@ import ComfyQueueButton from '@/components/actionbar/ComfyRunButton/ComfyQueueBu
 import { useBillingContext } from '@/composables/billing/useBillingContext'
 import SubscribeToRunButton from '@/platform/cloud/subscription/components/SubscribeToRun.vue'
 
-const { canRunWorkflows } = useBillingContext()
+const { isActiveSubscription } = useBillingContext()
 
 const currentButton = computed(() =>
-  canRunWorkflows.value ? ComfyQueueButton : SubscribeToRunButton
+  isActiveSubscription.value ? ComfyQueueButton : SubscribeToRunButton
 )
 </script>

src/components/actionbar/ComfyRunButton/ComfyQueueButton.test.ts

@@ -8,6 +8,7 @@ import type {
   JobStatus
 } from '@/platform/remote/comfyui/jobs/jobTypes'
 import { useCommandStore } from '@/stores/commandStore'
+import { api } from '@/scripts/api'
 import {
   TaskItemImpl,
   useQueueSettingsStore,
@@ -53,6 +54,8 @@ const i18n = createI18n({
     en: {
       menu: {
         run: 'Run',
+        continueIndependentBranches:
+          'Continue independent branches if a node fails',
         disabledTooltip: 'Disabled tooltip',
         onChange: 'On Change',
         onChangeTooltip: 'On change tooltip',
@@ -85,7 +88,9 @@ const stubs = {
   DropdownMenuTrigger: { template: '<div><slot /></div>' },
   DropdownMenuPortal: { template: '<div><slot /></div>' },
   DropdownMenuContent: { template: '<div><slot /></div>' },
-  DropdownMenuItem: { template: '<div><slot /></div>' }
+  DropdownMenuItem: { template: '<div><slot /></div>' },
+  DropdownMenuCheckboxItem: { template: '<div><slot /></div>' },
+  DropdownMenuItemIndicator: { template: '<span><slot /></span>' }
 }
 
 function renderQueueButton() {
@@ -106,6 +111,19 @@ function renderQueueButton() {
 }
 
 describe('ComfyQueueButton', () => {
+  it('only offers continuing independent branches when supported', async () => {
+    renderQueueButton()
+    expect(
+      screen.queryByTestId('continue-independent-branches')
+    ).not.toBeInTheDocument()
+
+    api.serverFeatureFlags.value = { supports_node_failure_policy: true }
+    await nextTick()
+
+    expect(
+      screen.getByTestId('continue-independent-branches')
+    ).toHaveTextContent('Continue independent branches if a node fails')
+  })
   it('renders the batch count control before the run button', () => {
     renderQueueButton()
     const controls = screen.getAllByTestId(/batch-count-edit|queue-button/)

src/components/actionbar/ComfyRunButton/ComfyQueueButton.vue

@@ -56,6 +56,20 @@
               {{ item.label }}
             </Button>
           </DropdownMenuItem>
+          <DropdownMenuCheckboxItem
+            v-if="supportsNodeFailurePolicy"
+            v-model:checked="continueIndependentBranches"
+            class="flex cursor-pointer items-center gap-2 rounded-md px-2 py-1.5 text-sm text-text-primary outline-none hover:bg-secondary-background-hover"
+            data-testid="continue-independent-branches"
+            @select.prevent
+          >
+            <span class="flex size-4 items-center justify-center">
+              <DropdownMenuItemIndicator>
+                <i class="icon-[lucide--check] size-4" />
+              </DropdownMenuItemIndicator>
+            </span>
+            {{ t('menu.continueIndependentBranches') }}
+          </DropdownMenuCheckboxItem>
         </DropdownMenuContent>
       </DropdownMenuPortal>
     </DropdownMenuRoot>
@@ -64,8 +78,10 @@
 
 <script setup lang="ts">
 import {
+  DropdownMenuCheckboxItem,
   DropdownMenuContent,
   DropdownMenuItem,
+  DropdownMenuItemIndicator,
   DropdownMenuPortal,
   DropdownMenuRoot,
   DropdownMenuTrigger
@@ -78,6 +94,7 @@ import BatchCountEdit from '@/components/actionbar/BatchCountEdit.vue'
 import TinyChevronIcon from '@/components/actionbar/TinyChevronIcon.vue'
 import Button from '@/components/ui/button/Button.vue'
 import ButtonGroup from '@/components/ui/button-group/ButtonGroup.vue'
+import { useFeatureFlags } from '@/composables/useFeatureFlags'
 import { isCloud } from '@/platform/distribution/types'
 import { useTelemetry } from '@/platform/telemetry'
 import { app } from '@/scripts/app'
@@ -93,7 +110,15 @@ import { cn } from '@comfyorg/tailwind-utils'
 import { graphHasMissingNodes } from '@/workbench/extensions/manager/utils/graphHasMissingNodes'
 
 const workspaceStore = useWorkspaceStore()
-const { mode: queueMode, batchCount } = storeToRefs(useQueueSettingsStore())
+const {
+  mode: queueMode,
+  batchCount,
+  continueIndependentBranches
+} = storeToRefs(useQueueSettingsStore())
+const { flags } = useFeatureFlags()
+const supportsNodeFailurePolicy = computed(
+  () => flags.supportsNodeFailurePolicy
+)
 
 const nodeDefStore = useNodeDefStore()
 const hasMissingNodes = computed(() =>

src/components/builder/AppModeWidgetList.vue

@@ -126,7 +126,7 @@ function nodeToNodeData(node: LGraphNode) {
 
   return {
     ...nodeData,
-    hasErrors: !!executionErrorStore.surfacedNodeErrors?.[node.id],
+    hasErrors: !!executionErrorStore.lastNodeErrors?.[node.id],
     dropIndicator,
     onDragDrop: node.onDragDrop,
     onDragOver: node.onDragOver

src/components/common/DropdownItem.vue

@@ -10,7 +10,6 @@ import {
 } from 'reka-ui'
 import { useI18n } from 'vue-i18n'
 import { toValue } from 'vue'
-import type { StyleValue } from 'vue'
 
 import { cn } from '@comfyorg/tailwind-utils'
 
@@ -20,12 +19,7 @@ defineOptions({
   inheritAttrs: false
 })
 
-defineProps<{
-  itemClass: string
-  contentClass: string
-  contentStyle?: StyleValue
-  item: MenuItem
-}>()
+defineProps<{ itemClass: string; contentClass: string; item: MenuItem }>()
 </script>
 <template>
   <DropdownMenuSeparator
@@ -43,7 +37,6 @@ defineProps<{
     <DropdownMenuPortal>
       <DropdownMenuSubContent
         :class="contentClass"
-        :style="contentStyle"
         :side-offset="2"
         :align-offset="-5"
       >
@@ -53,7 +46,6 @@ defineProps<{
           :item="subitem"
           :item-class
           :content-class
-          :content-style
         />
       </DropdownMenuSubContent>
     </DropdownMenuPortal>

src/components/common/DropdownMenu.vue

@@ -72,7 +72,6 @@ const contentStyle = useModalLiftedZIndex(open)
             :key="toValue(item.label) ?? index"
             :item-class
             :content-class
-            :content-style
             :item
           />
         </slot>

src/components/common/DropdownMenu.zindex.test.ts

@@ -1,8 +1,7 @@
 import { ZIndex } from '@primeuix/utils/zindex'
-import { render, screen, within } from '@testing-library/vue'
+import { render, screen } from '@testing-library/vue'
 import userEvent from '@testing-library/user-event'
-import type { MenuItem } from 'primevue/menuitem'
-import { afterEach, describe, expect, it, vi } from 'vitest'
+import { afterEach, describe, expect, it } from 'vitest'
 import { createI18n } from 'vue-i18n'
 
 import enMessages from '@/locales/en/main.json'
@@ -15,9 +14,9 @@ const i18n = createI18n({
   messages: { en: enMessages }
 })
 
-function renderMenu(entries: MenuItem[] = [{ label: 'Item A' }]) {
+function renderMenu() {
   return render(DropdownMenu, {
-    props: { entries },
+    props: { entries: [{ label: 'Item A' }] },
     global: { plugins: [i18n], directives: { tooltip: {} } }
   })
 }
@@ -54,32 +53,4 @@ describe('DropdownMenu z-index', () => {
     expect(menu.style.zIndex).toBe('')
     expect(menu.className).toContain('z-1700')
   })
-
-  it('opens a nested menu above a registered dialog', async () => {
-    openModal = document.createElement('div')
-    ZIndex.set('modal', openModal, 1700)
-    const dialogZ = Number(openModal.style.zIndex)
-    const command = vi.fn()
-    const user = userEvent.setup()
-    renderMenu([
-      {
-        label: 'Change role',
-        items: [
-          { label: 'Owner', command },
-          { label: 'Member', command }
-        ]
-      }
-    ])
-
-    await user.click(screen.getByRole('button'))
-    await user.click(screen.getByRole('menuitem', { name: 'Change role' }))
-
-    expect(await screen.findByRole('menuitem', { name: 'Owner' })).toBeVisible()
-    expect(screen.getByRole('menuitem', { name: 'Member' })).toBeVisible()
-    const submenu = screen
-      .getAllByRole('menu')
-      .find((menu) => within(menu).queryByRole('menuitem', { name: 'Owner' }))
-    expect(submenu).toBeDefined()
-    expect(Number(submenu?.style.zIndex)).toBeGreaterThan(dialogZ)
-  })
 })

src/components/custom/widget/WorkflowTemplateSelectorDialog.vue

@@ -97,7 +97,7 @@
         <!-- Sort Options -->
         <div>
           <SingleSelect
-            v-model="sortBy"
+            v-model="sortSelection"
             :label="$t('templateWorkflows.sorting', 'Sort by')"
             :options="sortOptions"
             :content-style="selectContentStyle"
@@ -556,7 +556,8 @@ const {
   selectedModels,
   selectedUseCases,
   selectedRunsOn,
-  sortBy,
+  sortSelection,
+  hasActiveQuery,
   activeModels,
   activeUseCases,
   filteredTemplates,
@@ -565,14 +566,13 @@ const {
   availableRunsOn,
   filteredCount,
   totalCount,
-  resetFilters,
-  loadFuseOptions
+  resetFilters
 } = useTemplateFiltering(navigationFilteredTemplates)
 
 /**
  * Raw search input bound to the search box. The actual `searchQuery` consumed
  * by the filtering composable is only updated via `applySearchQuery` after the
- * debounce settles, keeping Fuse/grid re-renders off the keystroke critical path.
+ * debounce settles, keeping search/grid re-renders off the keystroke critical path.
  */
 const searchInput = ref(searchQuery.value)
 
@@ -595,15 +595,13 @@ watch(searchQuery, (value) => {
  */
 const coordinateNavAndSort = (source: 'nav' | 'sort') => {
   const isPopularNav = selectedNavItem.value === 'popular'
-  const isPopularSort = sortBy.value === 'popular'
+  const isPopularSort = sortSelection.value === 'popular'
 
   if (source === 'nav') {
     if (isPopularNav && !isPopularSort) {
-      // When navigating to 'Popular' category, automatically set sort to 'Popular'.
-      sortBy.value = 'popular'
+      sortSelection.value = 'popular'
     } else if (!isPopularNav && isPopularSort) {
-      // When navigating away from 'Popular' category while sort is 'Popular', reset sort to default.
-      sortBy.value = 'default'
+      sortSelection.value = 'default'
     }
   } else if (source === 'sort') {
     // When sort is changed away from 'Popular' while in the 'Popular' category,
@@ -616,7 +614,7 @@ const coordinateNavAndSort = (source: 'nav' | 'sort') => {
 
 // Watch for changes from the two sources ('nav' and 'sort') and trigger the coordinator.
 watch(selectedNavItem, () => coordinateNavAndSort('nav'))
-watch(sortBy, () => coordinateNavAndSort('sort'))
+watch(sortSelection, () => coordinateNavAndSort('sort'))
 
 // Convert between string array and object array for MultiSelect component
 // Only show selected items that exist in the current scope
@@ -726,8 +724,15 @@ const runsOnFilterLabel = computed(() => {
   }
 })
 
-// Sort options
 const sortOptions = computed(() => [
+  ...(hasActiveQuery.value
+    ? [
+        {
+          name: t('templateWorkflows.sort.relevance', 'Relevance'),
+          value: 'relevance'
+        }
+      ]
+    : []),
   {
     name: t('templateWorkflows.sort.default', 'Default'),
     value: 'default'
@@ -789,7 +794,7 @@ watch(
   [
     filteredTemplates,
     selectedNavItem,
-    sortBy,
+    sortSelection,
     selectedModels,
     selectedUseCases,
     selectedRunsOn
@@ -839,8 +844,7 @@ const { isLoading } = useAsyncState(
   async () => {
     await Promise.all([
       loadTemplates(),
-      workflowTemplatesStore.loadWorkflowTemplates(),
-      loadFuseOptions()
+      workflowTemplatesStore.loadWorkflowTemplates()
     ])
     return true
   },

src/components/dialog/content/SignInContent.vue

@@ -126,7 +126,7 @@
         </a>
         {{ t('auth.login.andText') }}
         <a
-          href="https://www.comfy.org/privacy-policy"
+          href="https://www.comfy.org/privacy"
           target="_blank"
           class="cursor-pointer text-blue-500"
         >

src/components/queue/job/JobAssetsList.test.ts

@@ -160,6 +160,8 @@ type TestPreviewOutput = {
 type TestTaskRef = {
   workflowId?: string
   previewOutput?: TestPreviewOutput
+  isPartialSuccess?: boolean
+  executionErrorCount?: number
 }
 
 type TestJobListItem = Omit<JobListItem, 'taskRef'> & {
@@ -310,6 +312,23 @@ describe('JobAssetsList', () => {
     expect(stubRoot.getAttribute('data-preview-url')).not.toBe(preview.url)
   })
 
+  it('shows a warning badge for completed jobs with node errors', () => {
+    const job = buildJob({
+      taskRef: {
+        ...createTaskRef(createPreviewOutput('job-1.png')),
+        isPartialSuccess: true,
+        executionErrorCount: 2
+      }
+    })
+
+    renderJobAssetsList({ jobs: [job] })
+
+    expect(screen.getByTestId('partial-success-badge')).toHaveAttribute(
+      'aria-label',
+      'queue.jobDetails.completedWithErrors'
+    )
+  })
+
   it('emits viewItem on double-click for completed jobs with preview', async () => {
     const job = buildJob()
     const onViewItem = vi.fn()

src/components/queue/job/JobAssetsList.vue

@@ -22,7 +22,7 @@
         >
           <div
             :data-job-id="row.job.id"
-            class="h-12"
+            class="relative h-12"
             @mouseenter="onJobEnter(row.job, $event)"
             @mouseleave="onJobLeave(row.job.id)"
           >
@@ -84,6 +84,18 @@
                 </Button>
               </template>
             </AssetsListItem>
+            <span
+              v-if="row.job.taskRef?.isPartialSuccess"
+              data-testid="partial-success-badge"
+              class="pointer-events-none absolute bottom-1 left-7 z-2 flex size-4 items-center justify-center rounded-full bg-interface-panel-surface"
+              :aria-label="getPartialSuccessLabel(row.job)"
+              :title="getPartialSuccessLabel(row.job)"
+            >
+              <i
+                aria-hidden="true"
+                class="icon-[lucide--triangle-alert] size-3 text-warning-background"
+              />
+            </span>
           </div>
         </div>
       </template>
@@ -394,6 +406,11 @@ function getJobIconClass(job: JobListItem): string | undefined {
   return undefined
 }
 
+function getPartialSuccessLabel(job: JobListItem): string {
+  const count = job.taskRef?.executionErrorCount ?? 0
+  return t('queue.jobDetails.completedWithErrors', { count }, count)
+}
+
 watch(
   () => displayedJobGroups,
   () => {

src/components/queue/job/JobDetailsPopover.vue

@@ -83,12 +83,54 @@
           {{ errorMessageValue }}
         </div>
       </div>
+      <div
+        v-if="taskForJob?.isPartialSuccess"
+        class="rounded-sm border border-warning-background/30 bg-warning-background/10 p-3 text-xs/normal text-text-primary"
+      >
+        <div class="flex items-center gap-2 font-medium">
+          <i
+            aria-hidden="true"
+            class="icon-[lucide--triangle-alert] size-4 shrink-0 text-warning-background"
+          />
+          {{
+            t(
+              'queue.jobDetails.completedWithErrors',
+              { count: taskForJob.executionErrorCount },
+              taskForJob.executionErrorCount
+            )
+          }}
+        </div>
+        <div
+          v-if="recoverableExecutionErrors.length"
+          class="mt-3 flex max-h-64 flex-col gap-2 overflow-y-auto"
+        >
+          <div
+            v-for="(error, index) in recoverableExecutionErrors"
+            :key="`${error.node_id}-${index}`"
+            class="rounded-sm bg-interface-panel-hover-surface px-3 py-2"
+          >
+            <div class="font-medium text-text-primary">
+              {{
+                t('queue.jobDetails.nodeError', {
+                  nodeType: error.node_type,
+                  nodeId: error.node_id
+                })
+              }}
+            </div>
+            <div
+              class="mt-1 wrap-break-word whitespace-pre-wrap text-text-secondary"
+            >
+              {{ error.exception_message }}
+            </div>
+          </div>
+        </div>
+      </div>
     </div>
   </div>
 </template>
 
 <script setup lang="ts">
-import { computed, onMounted, onUnmounted, ref } from 'vue'
+import { computed, onMounted, onUnmounted, ref, watch } from 'vue'
 import { useI18n } from 'vue-i18n'
 
 import Button from '@/components/ui/button/Button.vue'
@@ -96,6 +138,7 @@ import { useCopyToClipboard } from '@/composables/useCopyToClipboard'
 import { isCloud } from '@/platform/distribution/types'
 import { useWorkflowStore } from '@/platform/workflow/management/stores/workflowStore'
 import { useDialogService } from '@/services/dialogService'
+import { getJobDetail } from '@/services/jobOutputCache'
 import { useExecutionStore } from '@/stores/executionStore'
 import { useQueueStore } from '@/stores/queueStore'
 import type { TaskItemImpl } from '@/stores/queueStore'
@@ -151,6 +194,33 @@ const jobState = computed(() => {
   return jobStateFromTask(task, isInitializing)
 })
 
+type RecoverableExecutionError = {
+  node_id: string | number
+  node_type: string
+  exception_message: string
+}
+
+const storedExecutionErrors = ref<RecoverableExecutionError[]>([])
+const recoverableExecutionErrors = computed<RecoverableExecutionError[]>(() =>
+  storedExecutionErrors.value.length
+    ? storedExecutionErrors.value
+    : (executionStore.executionErrorsByJob[props.jobId] ?? [])
+)
+
+watch(
+  () => [props.jobId, taskForJob.value?.isPartialSuccess] as const,
+  async ([jobId, isPartialSuccess]) => {
+    storedExecutionErrors.value = []
+    if (!isPartialSuccess) return
+
+    const detail = await getJobDetail(jobId)
+    if (props.jobId === jobId) {
+      storedExecutionErrors.value = detail?.execution_errors ?? []
+    }
+  },
+  { immediate: true }
+)
+
 const firstSeenTs = computed<number | undefined>(() => {
   const task = taskForJob.value
   return task?.createTime

src/components/rightSidePanel/errors/ErrorGroupList.test.ts

@@ -236,27 +236,4 @@ describe('ErrorGroupList selection emphasis', () => {
       expect(strip).toHaveTextContent('2 nodes — 2 errors')
     })
   })
-
-  it('preserves special characters in execution item accessible names', () => {
-    const nodeDisplayName = 'A & B <C>'
-    vi.mocked(getNodeByExecutionId).mockImplementation((_, nodeId) =>
-      fromAny<LGraphNode, unknown>(
-        String(nodeId) === '1'
-          ? { ...SAMPLER_NODE, title: nodeDisplayName }
-          : LOADER_NODE
-      )
-    )
-    const pinia = createPinia()
-    seedTwoErrorGroups(pinia)
-
-    renderList(pinia)
-
-    expect(
-      screen.getByRole('button', { name: /Info for A & B <C>/ })
-    ).toBeInTheDocument()
-    expect(
-      screen.getByRole('button', { name: /Locate A & B <C>/ })
-    ).toBeInTheDocument()
-    expect(screen.queryAllByLabelText(/&(?:amp|lt|gt);/)).toHaveLength(0)
-  })
 })

src/components/rightSidePanel/errors/ErrorGroupList.vue

@@ -239,11 +239,7 @@
                           )
                         "
                         :aria-label="
-                          t(
-                            'rightSidePanel.infoFor',
-                            { item: item.label },
-                            { escapeParameter: false }
-                          )
+                          t('rightSidePanel.infoFor', { item: item.label })
                         "
                         :aria-controls="getExecutionItemDetailId(item.key)"
                         :aria-expanded="isExecutionItemDetailExpanded(item.key)"
@@ -257,13 +253,9 @@
                       size="icon-sm"
                       class="size-8 shrink-0 text-muted-foreground hover:text-base-foreground focus-visible:ring-inset"
                       :aria-label="
-                        t(
-                          'rightSidePanel.locateNodeFor',
-                          {
-                            item: item.label
-                          },
-                          { escapeParameter: false }
-                        )
+                        t('rightSidePanel.locateNodeFor', {
+                          item: item.label
+                        })
                       "
                       @click.stop="handleLocateNode(item.nodeId)"
                     >

src/components/rightSidePanel/errors/ErrorNodeCard.test.ts

@@ -6,10 +6,8 @@ import { beforeEach, describe, expect, it, vi } from 'vitest'
 import { createI18n } from 'vue-i18n'
 import ErrorNodeCard from './ErrorNodeCard.vue'
 import type { ErrorCardData } from './types'
-import { resolveRunErrorMessage } from '@/platform/errorCatalog/errorMessageResolver'
 import { createNodeExecutionId } from '@/types/nodeIdentification'
 import { toNodeId } from '@/types/nodeId'
-import { validationError } from '@/utils/__tests__/nodeErrorHelpers'
 
 const mockGetLogs = vi.fn(() => Promise.resolve('mock server logs'))
 const mockSerialize = vi.fn(() => ({ nodes: [] }))
@@ -102,7 +100,7 @@ describe('ErrorNodeCard.vue', () => {
     const user = userEvent.setup()
     const onCopyToClipboard = vi.fn()
     const onLocateNode = vi.fn()
-    const { container } = render(ErrorNodeCard, {
+    render(ErrorNodeCard, {
       props: { card, onCopyToClipboard, onLocateNode },
       global: {
         plugins: [
@@ -144,7 +142,7 @@ describe('ErrorNodeCard.vue', () => {
         }
       }
     })
-    return { container, user, onCopyToClipboard, onLocateNode }
+    return { user, onCopyToClipboard, onLocateNode }
   }
 
   async function toggleRuntimeDetails(
@@ -187,32 +185,6 @@ describe('ErrorNodeCard.vue', () => {
     }
   }
 
-  function makeValidationErrorCard(nodeDisplayName: string): ErrorCardData {
-    const error = validationError(
-      'required_input_missing',
-      'model',
-      {},
-      'Required input is missing',
-      'model'
-    )
-
-    return {
-      id: `validation-${++cardIdCounter}`,
-      title: 'Validation error',
-      errors: [
-        {
-          message: error.message,
-          details: error.details,
-          ...resolveRunErrorMessage({
-            kind: 'node_validation',
-            error,
-            nodeDisplayName
-          })
-        }
-      ]
-    }
-  }
-
   it('shows runtime details by default and can collapse them', async () => {
     const reportText =
       '# ComfyUI Error Report\n## System Information\n- OS: Linux'
@@ -308,21 +280,6 @@ describe('ErrorNodeCard.vue', () => {
     ).not.toBeInTheDocument()
   })
 
-  it('renders catalog copy with literal special characters', () => {
-    const { container } = renderCard(makeValidationErrorCard('Foo & Bar <C>'))
-
-    expect(container.textContent).toContain('Foo & Bar <C>')
-    expect(container.textContent).not.toMatch(/&(?:amp|lt|gt);/)
-  })
-
-  it('renders script-like node names as literal text', () => {
-    const { container } = renderCard(
-      makeValidationErrorCard('<script>x</script>')
-    )
-
-    expect(container.textContent).toContain('<script>x</script>')
-  })
-
   it('copies enriched report when copy button is clicked for runtime error', async () => {
     const reportText = '# Full Report Content'
     mockGenerateErrorReport.mockReturnValue(reportText)

src/components/rightSidePanel/errors/useErrorGroups.test.ts

@@ -5,11 +5,9 @@ import { beforeEach, describe, expect, it, vi } from 'vitest'
 
 import type { MissingNodeType } from '@/types/comfy'
 import type { NodeExecutionId } from '@/types/nodeIdentification'
-import type * as GraphTraversalUtil from '@/utils/graphTraversalUtil'
 
 vi.mock('@/scripts/app', () => ({
   app: {
-    isGraphReady: true,
     rootGraph: {
       serialize: vi.fn(() => ({})),
       getNodeById: vi.fn()
@@ -129,8 +127,6 @@ import { useCanvasStore } from '@/renderer/core/canvas/canvasStore'
 import { useExecutionErrorStore } from '@/stores/executionErrorStore'
 import { useMissingNodesErrorStore } from '@/platform/nodeReplacement/missingNodesErrorStore'
 import { isLGraphNode } from '@/utils/litegraphUtil'
-import { nodeError, validationError } from '@/utils/__tests__/nodeErrorHelpers'
-import { createBoundaryLinkedSubgraph } from '@/lib/litegraph/src/subgraph/__fixtures__/subgraphHelpers'
 import {
   getExecutionIdByNode,
   getNodeByExecutionId
@@ -497,47 +493,6 @@ describe('useErrorGroups', () => {
       )
     })
 
-    it('groups lifted boundary errors under the host node card', async () => {
-      const { store, groups } = createErrorGroups()
-      const { rootGraph, host } = createBoundaryLinkedSubgraph({
-        interiorType: 'InteriorClass'
-      })
-      const { getNodeByExecutionId: actualGetNodeByExecutionId } =
-        await vi.importActual<typeof GraphTraversalUtil>(
-          '@/utils/graphTraversalUtil'
-        )
-      vi.mocked(getNodeByExecutionId).mockImplementation((_, nodeId) => {
-        return actualGetNodeByExecutionId(rootGraph, String(nodeId))
-      })
-      store.lastNodeErrors = {
-        '12:5': nodeError(
-          [
-            validationError(
-              'required_input_missing',
-              'seed_input',
-              {},
-              'Required input is missing'
-            )
-          ],
-          'InteriorClass'
-        )
-      }
-      await nextTick()
-
-      const execGroup = groups.allErrorGroups.value.find(
-        (g) => g.type === 'execution'
-      )
-      expect(execGroup?.type).toBe('execution')
-      if (execGroup?.type !== 'execution') return
-
-      const card = execGroup.cards[0]
-      expect(card.nodeId).toBe('12')
-      expect(card.title).toBe(host.title)
-      expect(card.errors[0].displayDetails).toBe(
-        `${host.title} is missing a required input: seed`
-      )
-    })
-
     it('groups node validation errors by catalog id across node types', async () => {
       const { store, groups } = createErrorGroups()
       store.lastNodeErrors = {

src/components/rightSidePanel/errors/useErrorGroups.ts

@@ -382,10 +382,10 @@ export function useErrorGroups(searchQuery: MaybeRefOrGetter<string>) {
     groupsMap: Map<string, GroupEntry>,
     filterBySelection = false
   ) {
-    if (!executionErrorStore.surfacedNodeErrors) return
+    if (!executionErrorStore.lastNodeErrors) return
 
     for (const [rawNodeId, nodeError] of Object.entries(
-      executionErrorStore.surfacedNodeErrors
+      executionErrorStore.lastNodeErrors
     )) {
       const nodeId = tryNormalizeNodeExecutionId(rawNodeId)
       if (!nodeId) continue

src/components/searchbox/v2/__test__/testUtils.ts

@@ -34,7 +34,6 @@ export function setupTestPinia() {
 export const testI18n = createI18n({
   legacy: false,
   locale: 'en',
-  escapeParameter: true,
   messages: { en: enMessages }
 })
 

src/components/topbar/CurrentUserPopoverLegacy.vue

@@ -31,7 +31,7 @@
 
     <!-- Credits Section -->
     <div v-if="isActiveSubscription" class="flex items-center gap-2 px-4 py-2">
-      <i class="icon-[lucide--component] text-sm text-credit" />
+      <i class="icon-[lucide--component] text-sm text-amber-400" />
       <Skeleton v-if="isLoading" width="4rem" height="1.25rem" class="w-full" />
       <span v-else class="text-base font-semibold text-base-foreground">{{
         formattedBalance
@@ -48,7 +48,7 @@
       </Button>
       <Button
         v-if="isCloud && isFreeTier"
-        variant="subscribe"
+        variant="gradient"
         size="sm"
         data-testid="upgrade-to-add-credits-button"
         @click="handleUpgradeToAddCredits"
@@ -72,7 +72,7 @@
         :fluid="false"
         :label="$t('subscription.subscribeToComfyCloud')"
         size="sm"
-        button-variant="subscribe"
+        button-variant="gradient"
         @subscribed="handleSubscribed"
       />
     </div>

src/components/topbar/TopbarSubscribeButton.vue

@@ -2,7 +2,7 @@
   <Button
     v-if="isCloud && isFreeTier"
     class="mr-2 shrink-0 whitespace-nowrap"
-    variant="subscribe"
+    variant="gradient"
     size="sm"
     data-testid="topbar-subscribe-button"
     @click="handleClick"

src/components/ui/button/button.variants.ts

@@ -24,8 +24,8 @@ export const buttonVariants = cva({
       base: 'bg-base-background text-base-foreground hover:bg-secondary-background-hover',
       tertiary:
         'bg-tertiary-background text-base-foreground hover:bg-tertiary-background-hover',
-      subscribe:
-        'border-transparent bg-credit text-charcoal-800 hover:opacity-80'
+      gradient:
+        'border-transparent bg-(image:--subscription-button-gradient) text-white hover:opacity-90'
     },
     size: {
       sm: 'h-6 rounded-sm px-2 py-1 text-xs',
@@ -58,7 +58,7 @@ const variants = [
   'base',
   'tertiary',
   'overlay-white',
-  'subscribe'
+  'gradient'
 ] as const satisfies Array<ButtonVariants['variant']>
 const sizes = [
   'sm',

src/composables/auth/useAuthActions.test.ts

@@ -8,10 +8,6 @@ import type { ComfyWorkflow } from '@/platform/workflow/management/stores/workfl
 type ModifiedWorkflow = Pick<ComfyWorkflow, 'path' | 'isModified'>
 
 const mockAuthStore = vi.hoisted(() => ({
-  login: vi.fn().mockResolvedValue(undefined),
-  loginWithGoogle: vi.fn().mockResolvedValue(undefined),
-  loginWithGithub: vi.fn().mockResolvedValue(undefined),
-  register: vi.fn().mockResolvedValue(undefined),
   logout: vi.fn().mockResolvedValue(undefined)
 }))
 
@@ -32,12 +28,10 @@ const mockDialogService = vi.hoisted(() => ({
 }))
 
 const mockToastErrorHandler = vi.hoisted(() => vi.fn())
-const mockTrackAuthFailed = vi.hoisted(() => vi.fn())
 
 const knownAuthErrorCodes = new Set([
   'auth/invalid-credential',
-  'auth/email-already-in-use',
-  'auth/user-not-found'
+  'auth/email-already-in-use'
 ])
 
 vi.mock('@/i18n', () => ({
@@ -54,9 +48,7 @@ vi.mock('@/platform/distribution/types', () => ({
 }))
 
 vi.mock('@/platform/telemetry', () => ({
-  useTelemetry: vi.fn(() => ({
-    trackAuthFailed: mockTrackAuthFailed
-  }))
+  useTelemetry: vi.fn(() => undefined)
 }))
 
 vi.mock('@/platform/updates/common/toastStore', () => ({
@@ -89,19 +81,9 @@ vi.mock('@/composables/billing/useBillingContext', () => ({
 
 vi.mock('@/composables/useErrorHandling', () => ({
   useErrorHandling: () => ({
-    wrapWithErrorHandlingAsync:
-      <TArgs extends unknown[], TReturn>(
-        action: (...args: TArgs) => Promise<TReturn> | TReturn,
-        errorHandler?: (error: unknown) => void
-      ) =>
-      async (...args: TArgs) => {
-        try {
-          return await action(...args)
-        } catch (error) {
-          ;(errorHandler ?? mockToastErrorHandler)(error)
-          return undefined
-        }
-      },
+    wrapWithErrorHandlingAsync: <TArgs extends unknown[], TReturn>(
+      action: (...args: TArgs) => Promise<TReturn> | TReturn
+    ) => action,
     toastErrorHandler: mockToastErrorHandler
   })
 }))
@@ -174,13 +156,10 @@ describe('useAuthActions.logout', () => {
     )
     const { logout } = useAuthActions()
 
-    await logout()
+    await expect(logout()).rejects.toThrow('auth.signOut.saveFailed:a.json')
 
     expect(mockWorkflowService.saveWorkflow).toHaveBeenCalledTimes(1)
     expect(mockAuthStore.logout).not.toHaveBeenCalled()
-    expect(mockToastErrorHandler).toHaveBeenCalledExactlyOnceWith(
-      new Error('auth.signOut.saveFailed:a.json')
-    )
   })
 
   it('saves every modified workflow before signing out when user picks Save (true)', async () => {
@@ -227,85 +206,6 @@ describe('useAuthActions.logout', () => {
   })
 })
 
-describe('useAuthActions auth flow error telemetry', () => {
-  beforeEach(() => {
-    setActivePinia(createPinia())
-    vi.clearAllMocks()
-    mockWorkflowStore.modifiedWorkflows = []
-  })
-
-  it('tracks email sign-in Firebase failures and still shows the error toast', async () => {
-    const error = new FirebaseError('auth/user-not-found', 'msg')
-    mockAuthStore.login.mockRejectedValueOnce(error)
-    const { signInWithEmail } = useAuthActions()
-
-    await expect(
-      signInWithEmail('user@example.com', 'password')
-    ).resolves.toBeUndefined()
-
-    expect(mockTrackAuthFailed).toHaveBeenCalledExactlyOnceWith({
-      error_code: 'auth/user-not-found',
-      auth_action: 'email_sign_in'
-    })
-    expect(mockToastStore.add).toHaveBeenCalledWith({
-      severity: 'error',
-      summary: 'g.error',
-      detail: 'auth.errors.auth/user-not-found'
-    })
-  })
-
-  it('tracks unknown errors for email sign-up failures', async () => {
-    const error = new Error('network failed')
-    mockAuthStore.register.mockRejectedValueOnce(error)
-    const { signUpWithEmail } = useAuthActions()
-
-    await expect(
-      signUpWithEmail('user@example.com', 'password')
-    ).resolves.toBeUndefined()
-
-    expect(mockTrackAuthFailed).toHaveBeenCalledExactlyOnceWith({
-      error_code: 'unknown',
-      auth_action: 'email_sign_up'
-    })
-  })
-
-  it('tracks Google sign-up failures separately from sign-in failures', async () => {
-    const error = new FirebaseError('auth/popup-closed-by-user', 'msg')
-    mockAuthStore.loginWithGoogle.mockRejectedValueOnce(error)
-    const { signInWithGoogle } = useAuthActions()
-
-    await expect(signInWithGoogle({ isNewUser: true })).resolves.toBeUndefined()
-
-    expect(mockTrackAuthFailed).toHaveBeenCalledExactlyOnceWith({
-      error_code: 'auth/popup-closed-by-user',
-      auth_action: 'google_sign_up'
-    })
-  })
-
-  it('tracks GitHub sign-up failures separately from sign-in failures', async () => {
-    const error = new FirebaseError('auth/popup-closed-by-user', 'msg')
-    mockAuthStore.loginWithGithub.mockRejectedValueOnce(error)
-    const { signInWithGithub } = useAuthActions()
-
-    await expect(signInWithGithub({ isNewUser: true })).resolves.toBeUndefined()
-
-    expect(mockTrackAuthFailed).toHaveBeenCalledExactlyOnceWith({
-      error_code: 'auth/popup-closed-by-user',
-      auth_action: 'github_sign_up'
-    })
-  })
-
-  it('does not track auth failures for logout failures', async () => {
-    const error = new FirebaseError('auth/network-request-failed', 'msg')
-    mockAuthStore.logout.mockRejectedValueOnce(error)
-    const { logout } = useAuthActions()
-
-    await logout()
-
-    expect(mockTrackAuthFailed).not.toHaveBeenCalled()
-  })
-})
-
 describe('useAuthActions.reportError', () => {
   beforeEach(() => {
     setActivePinia(createPinia())

src/composables/auth/useAuthActions.ts

@@ -8,7 +8,6 @@ import type { ErrorRecoveryStrategy } from '@/composables/useErrorHandling'
 import { st, t } from '@/i18n'
 import { isCloud } from '@/platform/distribution/types'
 import { useTelemetry } from '@/platform/telemetry'
-import type { AuthFlowAction } from '@/platform/telemetry/types'
 import { useToastStore } from '@/platform/updates/common/toastStore'
 import { useWorkflowService } from '@/platform/workflow/core/services/workflowService'
 import { useWorkflowStore } from '@/platform/workflow/management/stores/workflowStore'
@@ -29,15 +28,6 @@ export const useAuthActions = () => {
 
   const accessError = ref(false)
 
-  const reportAuthFlowError =
-    (authAction: AuthFlowAction) => (error: unknown) => {
-      useTelemetry()?.trackAuthFailed({
-        error_code: error instanceof FirebaseError ? error.code : 'unknown',
-        auth_action: authAction
-      })
-      reportError(error)
-    }
-
   const reportError = (error: unknown) => {
     // Ref: https://firebase.google.com/docs/auth/admin/errors
     if (
@@ -137,7 +127,7 @@ export const useAuthActions = () => {
         life: 5000
       })
     },
-    reportAuthFlowError('password_reset')
+    reportError
   )
 
   const purchaseCredits = wrapWithErrorHandlingAsync(async (amount: number) => {
@@ -187,34 +177,32 @@ export const useAuthActions = () => {
     return result
   }, reportError)
 
-  const signInWithGoogle = async (options?: { isNewUser?: boolean }) =>
-    await wrapWithErrorHandlingAsync(
-      async () => await authStore.loginWithGoogle(options),
-      reportAuthFlowError(
-        options?.isNewUser ? 'google_sign_up' : 'google_sign_in'
-      )
-    )()
+  const signInWithGoogle = wrapWithErrorHandlingAsync(
+    async (options?: { isNewUser?: boolean }) => {
+      return await authStore.loginWithGoogle(options)
+    },
+    reportError
+  )
 
-  const signInWithGithub = async (options?: { isNewUser?: boolean }) =>
-    await wrapWithErrorHandlingAsync(
-      async () => await authStore.loginWithGithub(options),
-      reportAuthFlowError(
-        options?.isNewUser ? 'github_sign_up' : 'github_sign_in'
-      )
-    )()
+  const signInWithGithub = wrapWithErrorHandlingAsync(
+    async (options?: { isNewUser?: boolean }) => {
+      return await authStore.loginWithGithub(options)
+    },
+    reportError
+  )
 
   const signInWithEmail = wrapWithErrorHandlingAsync(
     async (email: string, password: string) => {
       return await authStore.login(email, password)
     },
-    reportAuthFlowError('email_sign_in')
+    reportError
   )
 
   const signUpWithEmail = wrapWithErrorHandlingAsync(
     async (email: string, password: string, turnstileToken?: string) => {
       return await authStore.register(email, password, turnstileToken)
     },
-    reportAuthFlowError('email_sign_up')
+    reportError
   )
 
   /**

src/composables/billing/types.ts

@@ -112,7 +112,5 @@ export interface BillingContext extends BillingState, BillingActions {
    * (legacy) per-member tier plan, which keeps the old team pricing table.
    */
   isLegacyTeamPlan: ComputedRef<boolean>
-  isTeamPlan: ComputedRef<boolean>
   getMaxSeats: (tierKey: TierKey) => number
-  canRunWorkflows: ComputedRef<boolean>
 }

src/composables/billing/useBillingContext.test.ts

@@ -555,119 +555,4 @@ describe('useBillingContext', () => {
       expect(isLegacyTeamPlan.value).toBe(true)
     })
   })
-
-  describe('isTeamPlan', () => {
-    it('is false for a personal workspace', () => {
-      const { isTeamPlan } = useBillingContext()
-      expect(isTeamPlan.value).toBe(false)
-    })
-
-    it('is true for a credit-slider team sub, which carries a credit stop', async () => {
-      mockTeamWorkspacesEnabled.value = true
-      mockIsPersonal.value = false
-      mockBillingStatus.value = {
-        is_active: true,
-        has_funds: true,
-        plan_slug: 'team_per_credit_monthly',
-        team_credit_stop: {
-          id: 'team_700',
-          credits_monthly: 700,
-          stop_usd: 332
-        }
-      }
-
-      const { initialize, isTeamPlan } = useBillingContext()
-      await initialize()
-
-      expect(isTeamPlan.value).toBe(true)
-    })
-
-    it('is true for a per-credit Team plan in a personal workspace before its credit stop is populated', async () => {
-      mockTeamWorkspacesEnabled.value = true
-      mockConsolidatedBillingEnabled.value = true
-      mockIsPersonal.value = true
-      mockBillingStatus.value = {
-        is_active: true,
-        has_funds: true,
-        subscription_status: 'active',
-        subscription_duration: 'ANNUAL',
-        plan_slug: 'team_per_credit_annual'
-      }
-
-      const { initialize, isTeamPlan } = useBillingContext()
-      await initialize()
-
-      expect(isTeamPlan.value).toBe(true)
-    })
-
-    it('is true for a legacy team sub, identified by slug rather than credit stop', async () => {
-      mockTeamWorkspacesEnabled.value = true
-      mockIsPersonal.value = false
-      mockBillingStatus.value = {
-        is_active: true,
-        has_funds: true,
-        subscription_tier: 'STANDARD',
-        plan_slug: 'team-standard-annual'
-      }
-
-      const { initialize, isTeamPlan } = useBillingContext()
-      await initialize()
-
-      expect(isTeamPlan.value).toBe(true)
-    })
-
-    it('stays true for an inactive per-credit Team plan', async () => {
-      mockTeamWorkspacesEnabled.value = true
-      mockIsPersonal.value = false
-      mockBillingStatus.value = {
-        is_active: false,
-        has_funds: true,
-        billing_status: 'inactive',
-        plan_slug: 'team_per_credit_monthly',
-        team_credit_stop: {
-          id: 'team_700',
-          credits_monthly: 700,
-          stop_usd: 332
-        }
-      }
-
-      const { initialize, isTeamPlan } = useBillingContext()
-      await initialize()
-
-      expect(isTeamPlan.value).toBe(true)
-    })
-
-    it('stays true for a legacy team plan whose payment failed', async () => {
-      mockTeamWorkspacesEnabled.value = true
-      mockIsPersonal.value = false
-      mockBillingStatus.value = {
-        is_active: false,
-        has_funds: true,
-        billing_status: 'payment_failed',
-        subscription_tier: 'STANDARD',
-        plan_slug: 'team-standard-annual'
-      }
-
-      const { initialize, isTeamPlan } = useBillingContext()
-      await initialize()
-
-      expect(isTeamPlan.value).toBe(true)
-    })
-
-    it('is false for a team workspace on a personal-tier plan', async () => {
-      mockTeamWorkspacesEnabled.value = true
-      mockIsPersonal.value = false
-      mockBillingStatus.value = {
-        is_active: true,
-        has_funds: true,
-        subscription_tier: 'PRO',
-        plan_slug: 'pro-monthly'
-      }
-
-      const { initialize, isTeamPlan } = useBillingContext()
-      await initialize()
-
-      expect(isTeamPlan.value).toBe(false)
-    })
-  })
 })

src/composables/billing/useBillingContext.ts

@@ -6,7 +6,6 @@ import {
   getTierFeatures
 } from '@/platform/cloud/subscription/constants/tierPricing'
 import type { TierKey } from '@/platform/cloud/subscription/constants/tierPricing'
-import { useFreeTierQuota } from '@/platform/cloud/subscription/composables/useFreeTierQuota'
 import type { SubscriptionDialogOptions } from '@/platform/cloud/subscription/composables/useSubscriptionDialog'
 import type {
   PreviewSubscribeOptions,
@@ -30,15 +29,6 @@ import { useWorkspaceBilling } from '@/platform/workspace/composables/useWorkspa
 // carries a team_credit_stop. The hyphen prefix alone separates the two, so a
 // new sub is never misrouted even before its credit stop is populated.
 const LEGACY_TEAM_PLAN_SLUG_PREFIX = 'team-'
-const PER_CREDIT_TEAM_PLAN_SLUG_PREFIX = 'team_per_credit_'
-
-function isTeamPlanSlug(planSlug: string | null | undefined): boolean {
-  const normalizedSlug = planSlug?.toLowerCase()
-  return (
-    normalizedSlug?.startsWith(LEGACY_TEAM_PLAN_SLUG_PREFIX) === true ||
-    normalizedSlug?.startsWith(PER_CREDIT_TEAM_PLAN_SLUG_PREFIX) === true
-  )
-}
 
 /**
  * Unified billing context that selects the billing implementation by build/flag.
@@ -139,16 +129,6 @@ function useBillingContextInternal(): BillingContext {
 
   const isFreeTier = computed(() => subscription.value?.tier === 'FREE')
 
-  const freeTierQuota = useFreeTierQuota()
-
-  const canRunWorkflows = computed(
-    () =>
-      isActiveSubscription.value &&
-      (!isFreeTier.value ||
-        !freeTierQuota.quotaEnabled.value ||
-        freeTierQuota.freeTierExecutionPermitted.value)
-  )
-
   const isLegacyTeamPlan = computed(
     () =>
       type.value === 'workspace' &&
@@ -161,13 +141,6 @@ function useBillingContextInternal(): BillingContext {
         false)
   )
 
-  const isTeamPlan = computed(
-    () =>
-      type.value === 'workspace' &&
-      (currentTeamCreditStop.value !== null ||
-        isTeamPlanSlug(currentPlanSlug.value))
-  )
-
   const billingStatus = computed(() =>
     toValue(activeContext.value.billingStatus)
   )
@@ -324,10 +297,8 @@ function useBillingContextInternal(): BillingContext {
     isLoading,
     error,
     isActiveSubscription,
-    canRunWorkflows,
     isFreeTier,
     isLegacyTeamPlan,
-    isTeamPlan,
     billingStatus,
     subscriptionStatus,
     tier,

src/composables/graph/useNodeErrorFlagSync.ts

@@ -84,7 +84,7 @@ function reconcileNodeErrorFlags(
 }
 
 export function useNodeErrorFlagSync(
-  nodeErrors: Ref<Record<string, NodeError> | null>,
+  lastNodeErrors: Ref<Record<string, NodeError> | null>,
   missingModelStore: ReturnType<typeof useMissingModelStore>,
   missingMediaStore: ReturnType<typeof useMissingMediaStore>
 ): () => void {
@@ -95,7 +95,7 @@ export function useNodeErrorFlagSync(
 
   const stop = watch(
     [
-      nodeErrors,
+      lastNodeErrors,
       () => missingModelStore.missingModelNodeIds,
       () => missingMediaStore.missingMediaNodeIds,
       showErrorsTab
@@ -108,7 +108,7 @@ export function useNodeErrorFlagSync(
       // Vue nodes compute hasAnyError independently and are unaffected.
       reconcileNodeErrorFlags(
         app.rootGraph,
-        nodeErrors.value,
+        lastNodeErrors.value,
         showErrorsTab.value
           ? missingModelStore.missingModelAncestorExecutionIds
           : new Set(),

src/composables/maskeditor/useMaskEditorLoader.test.ts

@@ -1,193 +0,0 @@
-import { fromAny } from '@total-typescript/shoehorn'
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
-
-import type { LGraphNode } from '@/lib/litegraph/src/litegraph'
-import { api } from '@/scripts/api'
-import { useMaskEditorLoader } from './useMaskEditorLoader'
-
-// ---- Module Mocks ----
-
-const mockDataStore: Record<string, unknown> = {
-  inputData: null,
-  sourceNode: null,
-  setLoading: vi.fn()
-}
-
-vi.mock('@/stores/maskEditorDataStore', () => ({
-  useMaskEditorDataStore: vi.fn(() => mockDataStore)
-}))
-
-vi.mock('@/stores/nodeOutputStore', () => ({
-  useNodeOutputStore: vi.fn(() => ({
-    getNodeOutputs: vi.fn(() => undefined)
-  }))
-}))
-
-const distribution = vi.hoisted(() => ({ isCloud: false }))
-
-vi.mock('@/platform/distribution/types', () => ({
-  get isCloud() {
-    return distribution.isCloud
-  }
-}))
-
-vi.mock('@/scripts/api', () => ({
-  api: {
-    fetchApi: vi.fn(),
-    apiURL: vi.fn((route: string) => `http://localhost:8188/api${route}`)
-  }
-}))
-
-vi.mock('@/scripts/app', () => ({
-  app: {
-    getPreviewFormatParam: vi.fn(() => ''),
-    getRandParam: vi.fn(() => '')
-  }
-}))
-
-// Mock Image constructor so the loader's image fetches resolve without a
-// network. Records every requested URL; URLs matching failUrlPattern reject
-// like a 404 would (reset per test in beforeEach).
-const requestedUrls: string[] = []
-let failUrlPattern: RegExp | null = null
-
-class MockImage {
-  crossOrigin = ''
-  onload: ((ev: Event) => void) | null = null
-  onerror: ((ev: unknown) => void) | null = null
-  private _src = ''
-  get src() {
-    return this._src
-  }
-  set src(value: string) {
-    this._src = value
-    requestedUrls.push(value)
-    queueMicrotask(() => {
-      if (failUrlPattern?.test(value)) this.onerror?.(new Event('error'))
-      else this.onload?.(new Event('load'))
-    })
-  }
-}
-
-function createLoadImageNode(widgetValue: string): LGraphNode {
-  return fromAny<LGraphNode, unknown>({
-    id: 7,
-    type: 'LoadImage',
-    imgs: [{ src: 'http://localhost:8188/api/view?filename=whatever.png' }],
-    images: undefined,
-    widgets: [{ name: 'image', value: widgetValue }]
-  })
-}
-
-function subfolderOf(url: string): string | null {
-  return new URL(url).searchParams.get('subfolder')
-}
-
-function requestedLayerUrls(layerFilename: string): string[] {
-  return requestedUrls.filter((url) => url.includes(layerFilename))
-}
-
-describe('useMaskEditorLoader', () => {
-  beforeEach(() => {
-    vi.clearAllMocks()
-    requestedUrls.length = 0
-    failUrlPattern = null
-    distribution.isCloud = false
-    mockDataStore.inputData = null
-    mockDataStore.sourceNode = null
-    vi.stubGlobal('Image', MockImage)
-  })
-
-  afterEach(() => {
-    vi.unstubAllGlobals()
-  })
-
-  it('loads layer files from the input root for saves without a subfolder prefix', async () => {
-    const node = createLoadImageNode('clipspace-painted-masked-123.png [input]')
-
-    await useMaskEditorLoader().loadFromNode(node)
-
-    for (const layerFilename of [
-      'clipspace-mask-123.png',
-      'clipspace-paint-123.png'
-    ]) {
-      const layerUrls = requestedLayerUrls(layerFilename)
-      expect(layerUrls.length).toBeGreaterThan(0)
-      for (const url of layerUrls) {
-        expect(subfolderOf(url)).toBeNull()
-      }
-    }
-    expect(mockDataStore.inputData).toMatchObject({
-      sourceRef: { filename: 'clipspace-mask-123.png', type: 'input' },
-      nodeId: 7
-    })
-  })
-
-  it('loads layer files from the clipspace subfolder for legacy saves', async () => {
-    const node = createLoadImageNode(
-      'clipspace/clipspace-painted-masked-123.png [input]'
-    )
-
-    await useMaskEditorLoader().loadFromNode(node)
-
-    for (const layerFilename of [
-      'clipspace-mask-123.png',
-      'clipspace-paint-123.png'
-    ]) {
-      const layerUrls = requestedLayerUrls(layerFilename)
-      expect(layerUrls.length).toBeGreaterThan(0)
-      for (const url of layerUrls) {
-        expect(subfolderOf(url)).toBe('clipspace')
-      }
-    }
-  })
-
-  it('keeps the clipspace subfolder for cloud-resolved layer files', async () => {
-    distribution.isCloud = true
-    vi.mocked(api.fetchApi).mockResolvedValue({
-      ok: true,
-      json: () =>
-        Promise.resolve({
-          painted_masked: 'hash-painted-masked.png',
-          painted: 'hash-painted.png',
-          paint: 'hash-paint.png',
-          mask: 'hash-mask.png'
-        })
-    } as Response)
-    const node = createLoadImageNode('clipspace-painted-masked-123.png [input]')
-
-    await useMaskEditorLoader().loadFromNode(node)
-
-    for (const layerFilename of ['hash-painted-masked.png', 'hash-paint.png']) {
-      const layerUrls = requestedLayerUrls(layerFilename)
-      expect(layerUrls.length).toBeGreaterThan(0)
-      for (const url of layerUrls) {
-        expect(subfolderOf(url)).toBe('clipspace')
-      }
-    }
-  })
-
-  it('falls back to the node image when layer files are missing', async () => {
-    failUrlPattern = /clipspace-(mask|paint)-123\.png/
-    const node = createLoadImageNode('clipspace-painted-masked-123.png [input]')
-
-    await useMaskEditorLoader().loadFromNode(node)
-
-    expect(mockDataStore.inputData).toMatchObject({
-      sourceRef: { filename: 'clipspace-painted-masked-123.png' },
-      paintLayer: undefined,
-      nodeId: 7
-    })
-  })
-
-  it('still fails when the node image itself cannot be loaded', async () => {
-    failUrlPattern = /./
-    const node = createLoadImageNode('some-regular-image.png [input]')
-
-    await expect(useMaskEditorLoader().loadFromNode(node)).rejects.toThrow()
-    expect(mockDataStore.setLoading).toHaveBeenLastCalledWith(
-      false,
-      expect.any(String)
-    )
-  })
-})

src/composables/maskeditor/useMaskEditorLoader.ts

@@ -53,10 +53,10 @@ function imageLayerFilenamesIfApplicable(
   }
 }
 
-function toRef(filename: string, subfolder: string): ImageRef {
+function toRef(filename: string): ImageRef {
   return {
     filename,
-    subfolder,
+    subfolder: 'clipspace',
     type: 'input'
   }
 }
@@ -150,72 +150,34 @@ export function useMaskEditorLoader() {
         }
       }
 
-      // Pattern-matched layer files live next to the painted-masked image the
-      // widget points at: the input root for saves under the unified upload
-      // contract (#12318), or the clipspace subfolder for saves made before
-      // it. Cloud resolves the hash filenames from its mask-layers API
-      // server-side, so its refs keep the subfolder they always used.
-      const layerSubfolder = maskLayersFromApi
-        ? 'clipspace'
-        : (nodeImageRef.subfolder ?? '')
+      const baseImageUrl = imageLayerFilenames?.maskedImage
+        ? mkFileUrl({ ref: toRef(imageLayerFilenames.maskedImage) })
+        : nodeImageUrl
 
-      const layeredBaseUrl = imageLayerFilenames?.maskedImage
-        ? mkFileUrl({
-            ref: toRef(imageLayerFilenames.maskedImage, layerSubfolder)
-          })
-        : undefined
-      const baseImageUrl = layeredBaseUrl ?? nodeImageUrl
+      const sourceRef = imageLayerFilenames?.maskedImage
+        ? parseImageRef(baseImageUrl)
+        : nodeImageRef
 
       let paintLayerUrl: string | null = null
       if (maskLayersFromApi?.paint) {
-        paintLayerUrl = mkFileUrl({
-          ref: toRef(maskLayersFromApi.paint, layerSubfolder)
-        })
+        paintLayerUrl = mkFileUrl({ ref: toRef(maskLayersFromApi.paint) })
       } else if (imageLayerFilenames?.paint) {
-        paintLayerUrl = mkFileUrl({
-          ref: toRef(imageLayerFilenames.paint, layerSubfolder)
-        })
+        paintLayerUrl = mkFileUrl({ ref: toRef(imageLayerFilenames.paint) })
       }
 
-      const loadLayers = (baseUrl: string, paintUrl: string | null) =>
-        Promise.all([
-          loadImageLayer(baseUrl, 'rgb'),
-          loadImageLayer(baseUrl, 'a'),
-          paintUrl ? loadPaintLayer(paintUrl) : Promise.resolve(undefined)
-        ])
-
-      const loadInputData = async () => {
-        try {
-          const [baseLayer, maskLayer, paintLayer] = await loadLayers(
-            baseImageUrl,
-            paintLayerUrl
-          )
-          return {
-            baseLayer,
-            maskLayer,
-            paintLayer,
-            sourceRef: layeredBaseUrl
-              ? parseImageRef(baseImageUrl)
-              : nodeImageRef
-          }
-        } catch (error) {
-          if (!layeredBaseUrl) throw error
-          console.warn(
-            '[MaskEditorLoader] Failed to load editor layer files, falling back to the node image',
-            error
-          )
-          const [baseLayer, maskLayer] = await loadLayers(nodeImageUrl, null)
-          return {
-            baseLayer,
-            maskLayer,
-            paintLayer: undefined,
-            sourceRef: nodeImageRef
-          }
-        }
-      }
+      const [baseLayer, maskLayer, paintLayer] = await Promise.all([
+        loadImageLayer(baseImageUrl, 'rgb'),
+        loadImageLayer(baseImageUrl, 'a'),
+        paintLayerUrl
+          ? loadPaintLayer(paintLayerUrl)
+          : Promise.resolve(undefined)
+      ])
 
       dataStore.inputData = {
-        ...(await loadInputData()),
+        baseLayer,
+        maskLayer,
+        paintLayer,
+        sourceRef,
         nodeId: node.id
       }
 

src/composables/node/usePriceBadge.ts

@@ -1,19 +1,12 @@
-import { createSharedComposable } from '@vueuse/core'
-import { computed, toValue } from 'vue'
-
 import type { LGraph, LGraphNode } from '@/lib/litegraph/src/litegraph'
 import { LGraphBadge } from '@/lib/litegraph/src/litegraph'
 
-import { useVueNodeLifecycle } from '@/composables/graph/useVueNodeLifecycle'
 import { useNodePricing } from '@/composables/node/useNodePricing'
 import type { INodeInputSlot } from '@/lib/litegraph/src/interfaces'
 import type { SubgraphInput } from '@/lib/litegraph/src/subgraph/SubgraphInput'
-import { trackNodePrice } from '@/renderer/extensions/vueNodes/composables/usePartitionedBadges'
-import { app } from '@/scripts/app'
-import { useWidgetValueStore } from '@/stores/widgetValueStore'
 import { useColorPaletteStore } from '@/stores/workspace/colorPaletteStore'
 import { adjustColor } from '@/utils/colorUtil'
-import { mapAllNodes } from '@/utils/graphTraversalUtil'
+import { useWidgetValueStore } from '@/stores/widgetValueStore'
 
 type LinkedWidgetInput = INodeInputSlot & {
   _subgraphSlot?: SubgraphInput
@@ -157,20 +150,3 @@ export const usePriceBadge = () => {
     updateSubgraphCredits
   }
 }
-export const useCreditsBadgesInGraph = createSharedComposable(() => {
-  const { isCreditsBadge } = usePriceBadge()
-  const vueNodeLifecycle = useVueNodeLifecycle()
-  return computed(() => {
-    void vueNodeLifecycle.nodeManager.value?.vueNodeData.size
-    if (!app.graph) return []
-    return mapAllNodes(app.graph, (node) => {
-      if (node.isSubgraphNode()) return
-
-      const priceBadge = node.badges.find(isCreditsBadge)
-      if (!priceBadge) return
-
-      trackNodePrice(node)
-      return [node.title, toValue(priceBadge).text, node.id] as const
-    })
-  })
-})

src/composables/templateSearchConfig.test.ts

@@ -0,0 +1,316 @@
+import { describe, expect, it } from 'vitest'
+
+import type { SearchResult } from 'minisearch'
+
+import {
+  createTemplateSearchIndex,
+  expandAbbreviation,
+  expandQuery,
+  rankByRelevanceThenUsage,
+  searchTemplates,
+  termFuzziness,
+  tokenize
+} from '@/composables/templateSearchConfig'
+import type { TemplateInfo } from '@/platform/workflow/templates/types/template'
+
+const buildTemplate = (
+  overrides: Partial<TemplateInfo> & { name: string }
+): TemplateInfo => ({
+  description: '',
+  mediaType: 'image',
+  mediaSubtype: 'png',
+  ...overrides
+})
+
+describe('tokenize', () => {
+  it('splits identifiers on hyphen and underscore', () => {
+    expect(tokenize('video_ltx2_3_t2v')).toEqual([
+      'video_ltx2_3_t2v',
+      'video',
+      'ltx2',
+      '3',
+      't2v'
+    ])
+  })
+
+  it('splits a trailing version off its name so "wan 2.7" matches "wan2.7"', () => {
+    expect(tokenize('wan2.7')).toEqual(['wan2.7', 'wan', '2.7'])
+  })
+
+  it('keeps a mid-digit abbreviation whole', () => {
+    expect(tokenize('t2v')).toEqual(['t2v'])
+  })
+
+  it('emits a unigram and bigram for each char of an unspaced CJK run', () => {
+    expect(tokenize('图像放大')).toEqual([
+      '图',
+      '像',
+      '放',
+      '大',
+      '图像',
+      '像放',
+      '放大'
+    ])
+  })
+
+  it('grams katakana including the prolonged-sound mark', () => {
+    expect(tokenize('データ')).toEqual(['デ', 'ー', 'タ', 'デー', 'ータ'])
+  })
+
+  it('treats Korean as a spaced script, not an unspaced CJK run', () => {
+    expect(tokenize('업스케일')).toEqual(['업스케일'])
+  })
+
+  it('grams the CJK part of a word glued to latin, keeping the whole word', () => {
+    expect(tokenize('flux图像')).toEqual(['图', '像', '图像', 'flux图像'])
+  })
+
+  it('lowercases and drops empty tokens', () => {
+    expect(tokenize('  Flux   Kontext ')).toEqual(['flux', 'kontext'])
+  })
+})
+
+describe('termFuzziness', () => {
+  it('is exact for short terms (≤3 chars)', () => {
+    expect(termFuzziness('t2v')).toBe(false)
+    expect(termFuzziness('cn')).toBe(false)
+  })
+
+  it('is exact for any term containing a digit so versions do not blur', () => {
+    expect(termFuzziness('2.5')).toBe(false)
+    expect(termFuzziness('flux2')).toBe(false)
+  })
+
+  it('allows edits for longer alphabetic terms', () => {
+    expect(termFuzziness('control')).not.toBe(false)
+  })
+})
+
+describe('expandAbbreviation', () => {
+  it('expands cross-modality shorthand', () => {
+    expect(expandAbbreviation('t2i')).toBe('text image')
+    expect(expandAbbreviation('i2v')).toBe('image video')
+    expect(expandAbbreviation('txt2img')).toBe('text image')
+  })
+
+  it('expands same-modality transforms to editing', () => {
+    expect(expandAbbreviation('img2img')).toBe('image edit')
+    expect(expandAbbreviation('v2v')).toBe('video edit')
+  })
+
+  it('expands known acronyms', () => {
+    expect(expandAbbreviation('cn')).toBe('controlnet')
+  })
+
+  it('returns null for unknown tokens and unknown modalities', () => {
+    expect(expandAbbreviation('flux')).toBeNull()
+    expect(expandAbbreviation('x2y')).toBeNull()
+  })
+})
+
+describe('expandQuery', () => {
+  it('expands shorthand tokens within a multi-word query', () => {
+    expect(expandQuery('wan i2v')).toBe('wan image video')
+  })
+
+  it('returns null when nothing expands', () => {
+    expect(expandQuery('flux upscale')).toBeNull()
+  })
+})
+
+describe('searchTemplates', () => {
+  const buildIndex = (templates: TemplateInfo[]) =>
+    createTemplateSearchIndex(templates)
+
+  it('returns an empty array for a blank query without touching the index', () => {
+    const index = buildIndex([buildTemplate({ name: 'a', title: 'Alpha' })])
+    expect(searchTemplates(index, '   ')).toEqual([])
+  })
+
+  it('matches a prefix ("vid" → "video")', () => {
+    const index = buildIndex([
+      buildTemplate({ name: 'video', title: 'Video Generator' }),
+      buildTemplate({ name: 'audio', title: 'Audio Studio' })
+    ])
+    expect(searchTemplates(index, 'vid')).toContain('video')
+    expect(searchTemplates(index, 'vid')).not.toContain('audio')
+  })
+
+  it('tolerates a typo in a longer term ("contorlnet")', () => {
+    const index = buildIndex([
+      buildTemplate({
+        name: 'cn',
+        title: 'Union ControlNet',
+        tags: ['ControlNet']
+      })
+    ])
+    expect(searchTemplates(index, 'contorlnet')).toContain('cn')
+  })
+
+  it('does not fuzzy-match a long word onto its shorter substring', () => {
+    const index = buildIndex([
+      buildTemplate({ name: 'real', title: 'SeedVR2 Image Upscale' }),
+      buildTemplate({
+        name: 'junk',
+        title: 'Anime Text to Image',
+        description: 'configure CFG scale and steps'
+      })
+    ])
+    expect(searchTemplates(index, 'upscale')).toContain('real')
+    expect(searchTemplates(index, 'upscale')).not.toContain('junk')
+  })
+
+  it('matches a CJK term inside an unspaced CJK title', () => {
+    const index = buildIndex([
+      buildTemplate({ name: 'zh_upscale', title: '图像放大' }), // "image upscale"
+      buildTemplate({ name: 'zh_video', title: '视频补帧' }) // "video interpolation"
+    ])
+    // 放大 = "upscale"
+    expect(searchTemplates(index, '放大')).toContain('zh_upscale')
+    expect(searchTemplates(index, '放大')).not.toContain('zh_video')
+  })
+
+  it('matches a single CJK character that ends an unspaced run', () => {
+    const index = buildIndex([buildTemplate({ name: 'zh', title: '图像放大' })])
+    // 大 is only the trailing half of the last bigram; the unigram reaches it.
+    expect(searchTemplates(index, '大')).toContain('zh')
+  })
+
+  it('requires all words to match (AND) before falling back to OR', () => {
+    const index = buildIndex([
+      buildTemplate({
+        name: 'both',
+        title: 'Flux Upscale',
+        models: ['Flux'],
+        tags: ['Upscale']
+      }),
+      buildTemplate({ name: 'flux_only', title: 'Flux Text to Image' })
+    ])
+    expect(searchTemplates(index, 'flux upscale')[0]).toBe('both')
+  })
+
+  it('breaks a near-tie by higher usage', () => {
+    const index = buildIndex([
+      buildTemplate({ name: 'low', title: 'Alpha Upscale', usage: 1 }),
+      buildTemplate({ name: 'high', title: 'Beta Upscale', usage: 5000 })
+    ])
+    expect(searchTemplates(index, 'upscale')[0]).toBe('high')
+  })
+
+  it('does not let usage override a clearly stronger text match', () => {
+    const index = buildIndex([
+      buildTemplate({ name: 'exact', title: 'Outpaint', usage: 1 }),
+      buildTemplate({
+        name: 'weak',
+        title: 'Portrait',
+        description: 'has an outpaint option somewhere',
+        usage: 9000
+      })
+    ])
+    expect(searchTemplates(index, 'outpaint')[0]).toBe('exact')
+  })
+
+  it('deduplicates literal and expansion matches, keeping the literal first', () => {
+    const index = buildIndex([
+      buildTemplate({ name: 'literal', title: 'Wan T2V', tags: ['T2V'] }),
+      buildTemplate({ name: 'expanded', title: 'Text to Video Studio' })
+    ])
+    const results = searchTemplates(index, 't2v')
+    expect(results[0]).toBe('literal')
+    expect(new Set(results).size).toBe(results.length)
+  })
+
+  it('indexes localized title/description over raw english', () => {
+    const index = buildIndex([
+      buildTemplate({
+        name: 'localized',
+        title: 'raw',
+        localizedTitle: 'aquarela',
+        description: 'raw',
+        localizedDescription: 'pintura'
+      })
+    ])
+    expect(searchTemplates(index, 'aquarela')).toEqual(['localized'])
+    expect(searchTemplates(index, 'pintura')).toEqual(['localized'])
+  })
+
+  it('falls back to the name when a template has no title or description', () => {
+    const index = buildIndex([buildTemplate({ name: 'flux_kontext_edit' })])
+    expect(searchTemplates(index, 'kontext')).toEqual(['flux_kontext_edit'])
+  })
+
+  it('ranks an editing template above text-to-image for "img2img"', () => {
+    const index = buildIndex([
+      buildTemplate({
+        name: 'text_to_image',
+        title: 'Qwen Text to Image',
+        tags: ['Text to Image']
+      }),
+      buildTemplate({
+        name: 'image_edit',
+        title: 'Qwen Image Edit',
+        tags: ['Image Edit']
+      })
+    ])
+    expect(searchTemplates(index, 'img2img')[0]).toBe('image_edit')
+  })
+
+  it('ranks a title match above a tag match above a description-only match', () => {
+    const index = buildIndex([
+      buildTemplate({
+        name: 'in_description',
+        title: 'Something Else',
+        description: 'mentions upscale in passing'
+      }),
+      buildTemplate({ name: 'in_tag', title: 'Something', tags: ['Upscale'] }),
+      buildTemplate({ name: 'in_title', title: 'Upscale Studio' })
+    ])
+    expect(searchTemplates(index, 'upscale')).toEqual([
+      'in_title',
+      'in_tag',
+      'in_description'
+    ])
+  })
+
+  it('ranks an exact title above a title with extra words', () => {
+    const index = buildIndex([
+      buildTemplate({ name: 'with_extra', title: 'ControlNet Guidance' }),
+      buildTemplate({ name: 'exact', title: 'ControlNet' })
+    ])
+    expect(searchTemplates(index, 'controlnet')[0]).toBe('exact')
+  })
+})
+
+describe('rankByRelevanceThenUsage', () => {
+  const hit = (id: string, score: number, usage: number): SearchResult =>
+    ({ id, score, usage }) as unknown as SearchResult
+
+  // Scores 0.93/0.965/1.0 with usages 100/50/1 form an intransitive cycle under
+  // a pairwise relative-band compare (A>B, B>C, but A<C), which makes Array.sort
+  // input-order-dependent. Bucketing must give one stable order for any input.
+  it('produces a stable order for an intransitive cluster', () => {
+    const a = hit('a', 0.93, 100)
+    const b = hit('b', 0.965, 50)
+    const c = hit('c', 1.0, 1)
+
+    const order = (hits: SearchResult[]) =>
+      rankByRelevanceThenUsage(hits).map((h) => h.id)
+
+    const expected = order([a, b, c])
+    expect(order([c, b, a])).toEqual(expected)
+    expect(order([b, a, c])).toEqual(expected)
+    expect(order([c, a, b])).toEqual(expected)
+  })
+
+  it('breaks ties within a band by usage but not across bands', () => {
+    const strong = hit('strong', 1.0, 1)
+    const nearStrong = hit('near', 0.98, 500)
+    const weak = hit('weak', 0.5, 9000)
+
+    const ids = rankByRelevanceThenUsage([weak, strong, nearStrong]).map(
+      (h) => h.id
+    )
+    // near (higher usage, same band as strong) leads; weak stays last on score.
+    expect(ids).toEqual(['near', 'strong', 'weak'])
+  })
+})

src/composables/templateSearchConfig.ts

@@ -0,0 +1,204 @@
+import MiniSearch from 'minisearch'
+import type { SearchResult } from 'minisearch'
+
+import type { TemplateInfo } from '@/platform/workflow/templates/types/template'
+
+// MiniSearch serializes the index but not the search options, so the tokenizer
+// and field list live here and are used at both index and query time.
+
+const SEARCH_FIELDS = [
+  'title',
+  'description',
+  'tags',
+  'models',
+  'name'
+] as const
+
+// Usage only reorders hits within this fraction of the top score, so popularity
+// never overrides a clearly-better text match. 5% tuned empirically.
+const USAGE_TIEBREAK_BAND = 0.05
+
+// Script-matched so spaced neighbors like Korean fall to the word tokenizer.
+const CJK = /[\p{scx=Han}\p{scx=Hiragana}\p{scx=Katakana}]/u
+const CJK_RUN = new RegExp(`${CJK.source}+`, 'gu')
+
+// Unigrams + bigrams so any substring of an unspaced run lands on a token.
+function cjkGrams(word: string): string[] {
+  const grams: string[] = []
+  for (const run of word.match(CJK_RUN) ?? []) {
+    const characters = run.split('')
+    grams.push(...characters)
+    for (let i = 1; i < characters.length; i++) {
+      grams.push(characters[i - 1] + characters[i])
+    }
+  }
+  return grams
+}
+
+/**
+ * Emits sub-parts so a term matches however it's typed: `-`/`_` splits, a
+ * trailing version (`wan2.7` → `wan`, `2.7`), and CJK character grams.
+ */
+export function tokenize(text: string): string[] {
+  const tokens = new Set<string>()
+  for (const word of text.toLowerCase().split(/\s+/).filter(Boolean)) {
+    for (const gram of cjkGrams(word)) tokens.add(gram)
+    // A pure-CJK run has no whole-word token — its grams already cover it.
+    if (CJK.test(word) && !/[a-z0-9]/.test(word)) continue
+    tokens.add(word)
+    for (const part of word.split(/[-_]/)) {
+      if (part) tokens.add(part)
+    }
+    const version = word.match(/^([a-z][a-z.]*?)(\d+(?:\.\d+)*)$/)
+    if (version) {
+      tokens.add(version[1].replace(/\.$/, ''))
+      tokens.add(version[2])
+    }
+  }
+  return [...tokens]
+}
+
+// Exact for ≤3-char and digit-bearing terms; otherwise 20% of length, so a typo
+// is forgiven but `upscale` can't fuzzy-match the shorter `scale`.
+export function termFuzziness(term: string): number | false {
+  return term.length <= 3 || /\d/.test(term) ? false : 0.2
+}
+
+function searchOptions(combineWith: 'AND' | 'OR' = 'AND') {
+  // Description demoted below default so an incidental prose mention never
+  // outranks a real title/model match.
+  return {
+    boost: { title: 3, models: 2, tags: 2, description: 0.5 },
+    prefix: true,
+    fuzzy: termFuzziness,
+    combineWith,
+    tokenize
+  }
+}
+
+// `{X}2{Y}` shorthand expanded by structure (t2i, txt2img, …) rather than one
+// entry per spelling.
+const MODALITY_STEMS: Record<string, string> = {
+  t: 'text',
+  txt: 'text',
+  text: 'text',
+  i: 'image',
+  img: 'image',
+  image: 'image',
+  v: 'video',
+  vid: 'video',
+  video: 'video',
+  a: 'audio',
+  s: 'audio',
+  m: 'music'
+}
+
+const SAME_MODALITY_EDIT: Record<string, string> = {
+  image: 'image edit',
+  video: 'video edit',
+  audio: 'audio edit'
+}
+
+const ACRONYMS: Record<string, string> = {
+  cn: 'controlnet'
+}
+
+export function expandAbbreviation(token: string): string | null {
+  const lower = token.trim().toLowerCase()
+  if (ACRONYMS[lower]) return ACRONYMS[lower]
+
+  const match = lower.match(/^([a-z]+)2([a-z]+)$/)
+  if (!match) return null
+  const left = MODALITY_STEMS[match[1]]
+  const right = MODALITY_STEMS[match[2]]
+  if (!left || !right) return null
+  if (left === right) return SAME_MODALITY_EDIT[left] ?? left
+  return `${left} ${right}`
+}
+
+/** Expands shorthand tokens (`wan i2v` → `wan image video`); null if none expand. */
+export function expandQuery(query: string): string | null {
+  let changed = false
+  const out = query
+    .split(/\s+/)
+    .filter(Boolean)
+    .map((token) => {
+      const expansion = expandAbbreviation(token.toLowerCase())
+      if (expansion) changed = true
+      return expansion ?? token
+    })
+    .join(' ')
+  return changed ? out : null
+}
+
+export function createTemplateSearchIndex(
+  templates: TemplateInfo[]
+): MiniSearch<TemplateInfo> {
+  const index = new MiniSearch<TemplateInfo>({
+    idField: 'name',
+    fields: [...SEARCH_FIELDS],
+    // Returned on each hit so the tiebreak can read usage without a second lookup.
+    storeFields: ['usage'],
+    // Index the localized strings the card actually shows, so a match explains
+    // a visible result.
+    extractField: (template, field) => {
+      if (field === 'title') return template.localizedTitle ?? template.title
+      if (field === 'description') {
+        return template.localizedDescription ?? template.description ?? ''
+      }
+      const value = template[field as keyof TemplateInfo]
+      return Array.isArray(value) ? value.join(' ') : ((value as string) ?? '')
+    },
+    tokenize,
+    searchOptions: searchOptions('AND')
+  })
+  index.addAll(templates)
+  return index
+}
+
+// Rank by relevance, with usage breaking ties inside a score band. Scores are
+// bucketed so the ordering is a stable total order (a pairwise relative-band
+// compare is intransitive). log1p dampens heavy-tailed usage.
+export function rankByRelevanceThenUsage(hits: SearchResult[]): SearchResult[] {
+  const bandSize =
+    hits.reduce((max, hit) => Math.max(max, hit.score), 0) * USAGE_TIEBREAK_BAND
+  const bucket = (score: number) =>
+    bandSize > 0 ? Math.round(score / bandSize) : 0
+  return [...hits].sort((a, b) => {
+    if (bucket(a.score) !== bucket(b.score)) return b.score - a.score
+    return Math.log1p(Number(b.usage ?? 0)) - Math.log1p(Number(a.usage ?? 0))
+  })
+}
+
+/** Ordered template names for a query: literal matches first, then dedup'd expansion matches. */
+export function searchTemplates(
+  index: MiniSearch<TemplateInfo>,
+  query: string
+): string[] {
+  const trimmed = query.trim()
+  if (!trimmed) return []
+
+  const andThenOr = (q: string): SearchResult[] => {
+    const and = index.search(q, searchOptions('AND'))
+    const hits = and.length > 0 ? and : index.search(q, searchOptions('OR'))
+    return rankByRelevanceThenUsage(hits)
+  }
+
+  const ordered: string[] = []
+  const seen = new Set<string>()
+  const collect = (hits: SearchResult[]) => {
+    for (const hit of hits) {
+      const id = String(hit.id)
+      if (!seen.has(id)) {
+        seen.add(id)
+        ordered.push(id)
+      }
+    }
+  }
+
+  collect(andThenOr(trimmed))
+  const expanded = expandQuery(trimmed)
+  if (expanded) collect(andThenOr(expanded))
+
+  return ordered
+}

src/composables/useCoreCommands.test.ts

@@ -6,7 +6,6 @@ import { useCoreCommands } from '@/composables/useCoreCommands'
 import { useExternalLink } from '@/composables/useExternalLink'
 import type { LGraphNode } from '@/lib/litegraph/src/litegraph'
 import type { AssetItem } from '@/platform/assets/schemas/assetSchema'
-import type * as DistributionModule from '@/platform/distribution/types'
 import { useSettingStore } from '@/platform/settings/settingStore'
 import { api } from '@/scripts/api'
 import { app } from '@/scripts/app'
@@ -80,23 +79,6 @@ vi.mock('@/stores/modelStore', async (importOriginal) => {
   }
 })
 
-const mockDistributionState = vi.hoisted(() => ({ isCloud: false }))
-vi.mock('@/platform/distribution/types', async (importOriginal) => ({
-  ...(await importOriginal<typeof DistributionModule>()),
-  get isCloud() {
-    return mockDistributionState.isCloud
-  }
-}))
-
-const mockMissingModelStoreRefresh = vi.hoisted(() =>
-  vi.fn().mockResolvedValue(undefined)
-)
-vi.mock('@/platform/missingModel/missingModelStore', () => ({
-  useMissingModelStore: () => ({
-    refreshMissingModels: mockMissingModelStoreRefresh
-  })
-}))
-
 vi.mock('@/platform/settings/settingStore')
 
 vi.mock('@/stores/authStore', () => ({
@@ -310,10 +292,6 @@ describe('useCoreCommands', () => {
 
   beforeEach(() => {
     vi.clearAllMocks()
-    mockDistributionState.isCloud = false
-    vi.mocked(app.refreshComboInNodes).mockResolvedValue(undefined)
-    mockModelStoreRefresh.mockResolvedValue(undefined)
-    mockMissingModelStoreRefresh.mockResolvedValue(undefined)
 
     // Set up Pinia
     setActivePinia(createPinia())
@@ -609,56 +587,11 @@ describe('useCoreCommands', () => {
       expect(app.openClipspace).toHaveBeenCalled()
     })
 
-    it('Comfy.RefreshNodeDefinitions rescans missing models after refreshing combos', async () => {
-      const order: string[] = []
-      let resolveComboRefresh: () => void = () => {}
-      vi.mocked(app.refreshComboInNodes).mockImplementation(async () => {
-        order.push('combo:start')
-        await new Promise<void>((resolve) => {
-          resolveComboRefresh = resolve
-        })
-        order.push('combo:end')
-      })
-      mockModelStoreRefresh.mockImplementation(async () => {
-        order.push('models')
-      })
-      mockMissingModelStoreRefresh.mockImplementation(async () => {
-        order.push('missing')
-      })
-
-      const commandPromise = findCmd('Comfy.RefreshNodeDefinitions').function()
-
-      expect(mockMissingModelStoreRefresh).not.toHaveBeenCalled()
-      resolveComboRefresh()
-      await commandPromise
-
-      expect(app.refreshComboInNodes).toHaveBeenCalled()
-      expect(mockModelStoreRefresh).toHaveBeenCalled()
-      expect(mockMissingModelStoreRefresh).toHaveBeenCalledWith({
-        reloadDefs: false
-      })
-      expect(order.indexOf('missing')).toBeGreaterThan(
-        order.indexOf('combo:end')
-      )
-    })
-
-    it('Comfy.RefreshNodeDefinitions skips the rescan when combo refresh fails', async () => {
-      vi.mocked(app.refreshComboInNodes).mockRejectedValue(new Error('boom'))
-
-      await expect(
-        findCmd('Comfy.RefreshNodeDefinitions').function()
-      ).rejects.toThrow('boom')
-      expect(mockMissingModelStoreRefresh).not.toHaveBeenCalled()
-    })
-
-    it('Comfy.RefreshNodeDefinitions skips missing model refresh on cloud', async () => {
-      mockDistributionState.isCloud = true
-
+    it('Comfy.RefreshNodeDefinitions refreshes combos and the model library', async () => {
       await findCmd('Comfy.RefreshNodeDefinitions').function()
 
       expect(app.refreshComboInNodes).toHaveBeenCalled()
       expect(mockModelStoreRefresh).toHaveBeenCalled()
-      expect(mockMissingModelStoreRefresh).not.toHaveBeenCalled()
     })
   })
 

src/composables/useCoreCommands.ts

@@ -22,8 +22,6 @@ import {
 import type { Point } from '@/lib/litegraph/src/litegraph'
 import { useBillingContext } from '@/composables/billing/useBillingContext'
 import { useAssetBrowserDialog } from '@/platform/assets/composables/useAssetBrowserDialog'
-import { isCloud } from '@/platform/distribution/types'
-import { useMissingModelStore } from '@/platform/missingModel/missingModelStore'
 import { useSettingStore } from '@/platform/settings/settingStore'
 import { buildSupportUrl } from '@/platform/support/config'
 import { useTelemetry } from '@/platform/telemetry'
@@ -87,7 +85,6 @@ export function useCoreCommands(): ComfyCommand[] {
   const canvasStore = useCanvasStore()
   const executionStore = useExecutionStore()
   const modelStore = useModelStore()
-  const missingModelStore = useMissingModelStore()
   const telemetry = useTelemetry()
   const { trackRunButton } = useRunButtonTelemetry()
   const { staticUrls, buildDocsUrl } = useExternalLink()
@@ -314,9 +311,6 @@ export function useCoreCommands(): ComfyCommand[] {
       category: 'essentials' as const,
       function: async () => {
         await Promise.all([app.refreshComboInNodes(), modelStore.refresh()])
-        if (!isCloud) {
-          await missingModelStore.refreshMissingModels({ reloadDefs: false })
-        }
       }
     },
     {