fix(website): localize models hero title connector

Hardcoded English "in" in the H1 broke the zh-CN render. Repurpose the
unused models.list.heroTitle.before key and add a matching .after so the
connector lands on the correct side of the highlighted ComfyUI span per
locale.

apps/website/scripts/generate-models.ts

@@ -58,7 +58,7 @@ const API_PROVIDER_MAP: Record<string, { name: string; slug: string }> = {
   runway: { name: 'Runway', slug: 'runway' },
   vidu: { name: 'Vidu', slug: 'vidu' },
   bfl: { name: 'Flux (API)', slug: 'flux-api' },
-  grok: { name: 'Grok Image', slug: 'grok-image' },
+  grok: { name: 'Grok Imagine', slug: 'grok-imagine' },
   stability: { name: 'Stability AI', slug: 'stability-ai' },
   bytedance: { name: 'Seedance (ByteDance)', slug: 'seedance-bytedance' },
   bytedace: { name: 'Seedance (ByteDance)', slug: 'seedance-bytedance' },
@@ -86,6 +86,20 @@ const API_PROVIDER_MAP: Record<string, { name: string; slug: string }> = {
   wavespped: { name: 'Wavespeed', slug: 'wavespeed' }
 }
 
+// Stub entries that exist only to issue 301 redirects from old slugs to
+// their new canonical slugs. Keeps renames reproducible across regenerations.
+const LEGACY_SLUG_REDIRECTS: OutputModel[] = [
+  {
+    slug: 'grok-image',
+    canonicalSlug: 'grok-imagine',
+    name: 'Grok Image',
+    displayName: 'Grok Image',
+    directory: 'partner_nodes',
+    huggingFaceUrl: '',
+    workflowCount: 0
+  }
+]
+
 function stripExt(name: string): string {
   return name.replace(/\.(safetensors|ckpt|pt|bin)$/, '')
 }
@@ -299,7 +313,8 @@ function run(): void {
       throw new Error(
         `Failed to parse ${file}: ${
           error instanceof Error ? error.message : String(error)
-        }`
+        }`,
+        { cause: error }
       )
     }
   }
@@ -367,7 +382,7 @@ function run(): void {
       displayName: m.name
     }))
 
-  const combined = [...apiOutput, ...output]
+  const combined = [...apiOutput, ...output, ...LEGACY_SLUG_REDIRECTS]
 
   const withThumbs = combined.filter((m) => m.thumbnailUrl).length
   process.stdout.write(

apps/website/src/components/gallery/GalleryCard.vue

@@ -7,12 +7,16 @@ const {
   item,
   locale = 'en',
   aspect = 'var(--aspect-ratio-gallery-card)',
-  mobile = false
+  mobile = false,
+  objectPosition = 'center',
+  objectFit = 'cover'
 } = defineProps<{
   item: GalleryItem
   locale?: Locale
   aspect?: string
   mobile?: boolean
+  objectPosition?: string
+  objectFit?: string
 }>()
 
 defineEmits<{ click: [] }>()
@@ -31,13 +35,15 @@ defineEmits<{ click: [] }>()
         loop
         muted
         playsinline
-        class="size-full object-cover transition-transform duration-300 group-hover:scale-105"
+        class="size-full transition-transform duration-300 group-hover:scale-105"
+        :style="{ objectPosition, objectFit }"
       />
       <img
         v-else
         :src="item.image"
         :alt="item.title"
-        class="size-full object-cover transition-transform duration-300 group-hover:scale-105"
+        class="size-full transition-transform duration-300 group-hover:scale-105"
+        :style="{ objectPosition, objectFit }"
       />
       <!-- Desktop hover overlay -->
       <div

apps/website/src/components/models/ModelCreationsSection.vue

@@ -0,0 +1,152 @@
+<script setup lang="ts">
+import { ref } from 'vue'
+
+import type { GalleryItem } from '../../data/gallery'
+import type { Locale } from '../../i18n/translations'
+
+import { t } from '../../i18n/translations'
+import BrandButton from '../common/BrandButton.vue'
+import GalleryCard from '../gallery/GalleryCard.vue'
+import GalleryDetailModal from '../gallery/GalleryDetailModal.vue'
+
+const { locale = 'en' } = defineProps<{ locale?: Locale }>()
+
+const modelName = 'Grok'
+const ctaHref = 'https://comfy.org/workflows/model/grok'
+
+const items: GalleryItem[] = [
+  {
+    id: 'subway-swan',
+    image: 'https://media.comfy.org/website/gallery/subway-swan_compressed.png',
+    title: 'Subway Swan',
+    userAlias: 'Purz Beats',
+    teamAlias: 'Comfy',
+    tool: 'Grok Imagine',
+    href: 'https://www.youtube.com/@PurzBeats'
+  },
+  {
+    id: 'milos-little-wonder',
+    video:
+      'https://media.comfy.org/website/gallery/milos-little-wonder_compressed.mp4',
+    title: 'Milos Little Wonder',
+    userAlias: 'Purz Beats',
+    teamAlias: 'Comfy',
+    tool: 'Grok Imagine',
+    href: 'https://www.youtube.com/@PurzBeats'
+  },
+  {
+    id: 'amber-passage',
+    image:
+      'https://media.comfy.org/website/gallery/amber-passage_compressed.jpg',
+    title: 'Amber Passage',
+    userAlias: 'Purz Beats',
+    teamAlias: 'Comfy',
+    tool: 'Grok Imagine',
+    href: 'https://www.youtube.com/@PurzBeats',
+    objectPosition: 'bottom'
+  },
+  {
+    id: 'neon-revenant',
+    video:
+      'https://media.comfy.org/website/gallery/neon-revenant_compressed.mp4',
+    title: 'Neon Revenant',
+    userAlias: 'Eric Solorio',
+    teamAlias: 'Comfy',
+    tool: 'Grok Imagine',
+    href: 'https://www.instagram.com/enigmatic_e'
+  },
+  {
+    id: 'midnight-umami',
+    image:
+      'https://media.comfy.org/website/gallery/midnight_umami_compressed.png',
+    title: 'Midnight Umami',
+    userAlias: 'Purz Beats',
+    teamAlias: 'Comfy',
+    tool: 'Grok Imagine',
+    href: 'https://www.youtube.com/@PurzBeats'
+  }
+]
+
+const modalOpen = ref(false)
+const modalIndex = ref(0)
+
+function openDetail(index: number) {
+  modalIndex.value = index
+  modalOpen.value = true
+}
+
+const title = t('models.list.creations.title', locale).replace(
+  '{name}',
+  modelName
+)
+const ctaLabel = t('models.list.creations.cta', locale)
+</script>
+
+<template>
+  <section
+    data-testid="model-creations"
+    class="flex flex-col items-center px-4 py-16 lg:px-20 lg:pt-36"
+  >
+    <h2
+      class="max-w-4xl text-center text-3xl font-light tracking-tight text-primary-comfy-canvas lg:text-5xl"
+    >
+      {{ title }}
+    </h2>
+    <BrandButton
+      :href="ctaHref"
+      variant="solid"
+      size="lg"
+      class="mt-16 px-8 py-4 uppercase"
+    >
+      {{ ctaLabel }}
+    </BrandButton>
+
+    <div class="mt-20 hidden w-full flex-col gap-2 lg:flex">
+      <div class="grid grid-cols-2 gap-2">
+        <GalleryCard
+          v-for="(item, i) in items.slice(0, 2)"
+          :key="i"
+          :item
+          :locale
+          :object-position="item.objectPosition"
+          :object-fit="item.objectFit"
+          @click="openDetail(i)"
+        />
+      </div>
+      <div v-if="items.length > 2" class="grid grid-cols-3 gap-2">
+        <GalleryCard
+          v-for="(item, i) in items.slice(2, 5)"
+          :key="i + 2"
+          :item
+          :locale
+          :object-position="item.objectPosition"
+          :object-fit="item.objectFit"
+          @click="openDetail(i + 2)"
+        />
+      </div>
+    </div>
+
+    <div
+      class="rounded-5xl bg-transparency-white-t4 mt-12 flex w-full flex-col gap-6 p-2 max-lg:pb-6 lg:hidden"
+    >
+      <GalleryCard
+        v-for="(item, i) in items"
+        :key="i"
+        :item
+        :locale
+        :object-position="item.objectPosition"
+        :object-fit="item.objectFit"
+        mobile
+        @click="openDetail(i)"
+      />
+    </div>
+
+    <GalleryDetailModal
+      v-if="modalOpen"
+      :items
+      :initial-index="modalIndex"
+      :locale
+      @close="modalOpen = false"
+    />
+  </section>
+</template>

apps/website/src/components/models/ModelsHeroSection.vue

@@ -0,0 +1,62 @@
+<script setup lang="ts">
+import type { Locale } from '../../i18n/translations'
+
+import { t } from '../../i18n/translations'
+import BrandButton from '../common/BrandButton.vue'
+
+const {
+  locale = 'en',
+  modelName,
+  ctaHref,
+  videoSrc,
+  videoAriaLabel
+} = defineProps<{
+  locale?: Locale
+  modelName: string
+  ctaHref: string
+  videoSrc: string
+  videoAriaLabel?: string
+}>()
+</script>
+
+<template>
+  <section class="flex flex-col items-center px-6 pt-16 text-center lg:pt-36">
+    <h1
+      class="max-w-4xl text-4xl font-light tracking-tight text-primary-comfy-canvas lg:text-6xl"
+    >
+      {{
+        t('models.list.heroTitle.before', locale).replace('{name}', modelName)
+      }}
+      <span class="text-primary-comfy-yellow">ComfyUI</span>
+      {{
+        t('models.list.heroTitle.after', locale).replace('{name}', modelName)
+      }}
+    </h1>
+    <p
+      class="mt-6 max-w-2xl text-sm text-pretty text-primary-comfy-canvas lg:text-base"
+    >
+      {{ t('hero.subtitle', locale) }}
+    </p>
+    <BrandButton
+      :href="ctaHref"
+      variant="solid"
+      size="lg"
+      class="mt-10 px-8 py-4 uppercase"
+    >
+      {{ t('models.list.heroCta', locale).replace('{name}', modelName) }}
+    </BrandButton>
+    <div class="mt-16 w-full max-w-5xl">
+      <video
+        :src="videoSrc"
+        :aria-label="videoAriaLabel || undefined"
+        :aria-hidden="videoAriaLabel ? undefined : true"
+        autoplay
+        loop
+        muted
+        playsinline
+        preload="metadata"
+        class="rounded-4.5xl size-full object-cover"
+      />
+    </div>
+  </section>
+</template>

apps/website/src/components/product/shared/AIModelsSection.vue

@@ -78,7 +78,7 @@ function getCardClass(layoutClass: string): string {
 
 <template>
   <section
-    class="bg-primary-comfy-ink max-w-9xl mx-auto px-4 py-24 lg:px-20 lg:py-40"
+    class="max-w-9xl mx-auto bg-primary-comfy-ink px-4 py-16 lg:px-20 lg:py-40"
   >
     <div class="mx-auto flex w-full max-w-7xl flex-col items-center">
       <p
@@ -88,18 +88,18 @@ function getCardClass(layoutClass: string): string {
       </p>
 
       <h2
-        class="text-primary-comfy-canvas text-3.5xl/tight mt-8 max-w-4xl text-center font-light lg:text-5xl"
+        class="text-3.5xl/tight mt-8 max-w-4xl text-center font-light text-primary-comfy-canvas lg:text-5xl"
       >
         {{ t('cloud.aiModels.heading', locale) }}
       </h2>
 
       <p
-        class="text-primary-comfy-canvas mt-8 max-w-xl text-center text-sm font-light lg:text-base/snug"
+        class="mt-8 max-w-xl text-center text-sm font-light text-primary-comfy-canvas lg:text-base/snug"
       >
         {{ t('cloud.aiModels.subtitle', locale) }}
       </p>
 
-      <div class="mt-24 w-full">
+      <div class="mt-16 w-full lg:mt-24">
         <div class="rounded-4xl border border-white/12 p-2 lg:p-1.5">
           <div class="grid grid-cols-1 gap-2 lg:grid-cols-12">
             <a
@@ -180,14 +180,15 @@ function getCardClass(layoutClass: string): string {
       <BrandButton
         :href="externalLinks.workflows"
         variant="outline"
-        class="mt-4 w-full max-w-md text-center lg:mt-8 lg:w-auto"
+        size="lg"
+        class="mt-4 w-full max-w-md px-8 py-4 text-center lg:mt-8 lg:w-auto"
       >
-        <span class="lg:hidden">{{
-          t('cloud.aiModels.ctaMobile', locale)
-        }}</span>
-        <span class="hidden lg:inline">{{
+        <!-- <span class="lg:hidden"> -->
+        {{ t('cloud.aiModels.ctaMobile', locale) }}
+        <!-- </span> -->
+        <!-- <span class="hidden lg:inline">{{
           t('cloud.aiModels.ctaDesktop', locale)
-        }}</span>
+        }}</span> -->
       </BrandButton>
     </div>
   </section>

apps/website/src/config/model-metadata.ts

@@ -90,7 +90,7 @@ export const modelMetadata: Record<string, ModelOverride> = {
     hubSlug: 'seedance',
     featured: true
   },
-  'grok-image': {
+  'grok-imagine': {
     hubSlug: 'grok',
     featured: false
   },

apps/website/src/data/gallery.ts

@@ -7,6 +7,8 @@ export interface GalleryItem {
   teamAlias: string
   tool: string
   href?: string
+  objectPosition?: string
+  objectFit?: string
   /** Defaults to true. Set to false to hide this item from rendered lists. */
   visible?: boolean
 }

apps/website/src/i18n/translations.ts

@@ -4458,6 +4458,80 @@ const translations = {
     'zh-CN': '支持的模型'
   },
 
+  // Models list page (/models)
+  'models.list.label': { en: 'MODELS', 'zh-CN': '模型' },
+  'models.list.heroCta': {
+    en: 'Try {name} Now',
+    'zh-CN': '立即试用 {name}'
+  },
+  'models.list.creations.title': {
+    en: '{name} Image and Video Creations',
+    'zh-CN': '{name} 图像与视频创作'
+  },
+  'models.list.creations.cta': {
+    en: 'Explore Workflows',
+    'zh-CN': '探索工作流'
+  },
+  'models.list.heroTitle.before': {
+    en: '{name} in',
+    'zh-CN': ''
+  },
+  'models.list.heroTitle.after': {
+    en: '',
+    'zh-CN': ' 中的 {name}'
+  },
+  'models.list.heroSubtitle': {
+    en: 'From open-source diffusion checkpoints to partner APIs — every major model, with community workflow templates ready to run.',
+    'zh-CN':
+      '从开源扩散模型到合作伙伴 API，涵盖每一个主流模型，并附带可直接运行的社区工作流模板。'
+  },
+  'models.list.card.workflows': {
+    en: '{count} workflows',
+    'zh-CN': '{count} 个工作流'
+  },
+  'models.list.contact.label': {
+    en: 'COMFY HUB',
+    'zh-CN': 'COMFY HUB'
+  },
+  'models.showcase.label': { en: 'AI MODELS', 'zh-CN': 'AI 模型' },
+  'models.showcase.heading': {
+    en: 'Run the world’s\nleading AI models',
+    'zh-CN': '运行全球领先的\nAI 模型'
+  },
+  'models.showcase.subtitle': {
+    en: 'New models are added as they launch.',
+    'zh-CN': '新模型发布后会第一时间上线。'
+  },
+  'models.showcase.cta': {
+    en: 'EXPLORE WORKFLOWS',
+    'zh-CN': '探索工作流'
+  },
+  'models.showcase.card.grokImagine': {
+    en: 'Grok Imagine',
+    'zh-CN': 'Grok Imagine'
+  },
+  'models.showcase.card.nanoBananaPro': {
+    en: 'Nano Banana Pro',
+    'zh-CN': 'Nano Banana Pro'
+  },
+  'models.showcase.card.ltx23': {
+    en: 'LTX 2.3',
+    'zh-CN': 'LTX 2.3'
+  },
+  'models.showcase.card.qwenAdvancedEdit': {
+    en: 'Advanced image\nediting with Qwen',
+    'zh-CN': '使用 Qwen 进行\n高级图像编辑'
+  },
+  'models.showcase.card.wan22TextToVideo': {
+    en: 'Wan 2.2\ntext to video',
+    'zh-CN': 'Wan 2.2\n文字转视频'
+  },
+  'models.list.contact.heading': {
+    en: 'Pick a model and explore what the community has built. <a href="https://comfy.org/workflows" target="_blank" rel="noopener noreferrer" class="text-primary-comfy-yellow underline">Browse Comfy Hub</a> for the newest workflows.',
+    'zh-CN':
+      '选择一个模型，浏览社区的创作成果。<a href="https://comfy.org/workflows" target="_blank" rel="noopener noreferrer" class="text-primary-comfy-yellow underline">访问 Comfy Hub</a> 查看最新工作流。'
+  },
+
   // Payment status pages
   'payment.success.label': {
     en: 'PAYMENT',

apps/website/src/pages/models.astro

@@ -0,0 +1,22 @@
+---
+import BaseLayout from '../layouts/BaseLayout.astro'
+import ModelsHeroSection from '../components/models/ModelsHeroSection.vue'
+import ModelCreationsSection from '../components/models/ModelCreationsSection.vue'
+import AIModelsSection from '../components/product/shared/AIModelsSection.vue'
+import ProductShowcaseSection from '../components/home/ProductShowcaseSection.vue' 
+---
+
+<BaseLayout
+  title="Models — Comfy"
+  description="Run the world's leading AI models in ComfyUI. Browse every supported model with community workflow templates ready to run."
+>
+  <ModelsHeroSection
+    modelName="Grok Imagine"
+    ctaHref="/p/supported-models/grok-imagine"
+    videoSrc="https://media.comfy.org/website/models/video_ComfdyUI_00001_.mp4"
+    videoAriaLabel="Grok Imagine output created with ComfyUI"
+  />
+  <ModelCreationsSection client:load />
+  <AIModelsSection client:load />
+  <ProductShowcaseSection client:load />
+</BaseLayout>

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

@@ -0,0 +1,23 @@
+---
+import BaseLayout from '../../layouts/BaseLayout.astro'
+import ModelsHeroSection from '../../components/models/ModelsHeroSection.vue'
+import ModelCreationsSection from '../../components/models/ModelCreationsSection.vue'
+import AIModelsSection from '../../components/product/shared/AIModelsSection.vue'
+import ProductShowcaseSection from '../../components/home/ProductShowcaseSection.vue'
+---
+
+<BaseLayout
+  title="模型 — Comfy"
+  description="在 ComfyUI 中运行世界领先的 AI 模型。浏览所有支持的模型及社区工作流模板。"
+>
+  <ModelsHeroSection
+    locale="zh-CN"
+    modelName="Grok Imagine"
+    ctaHref="/zh-CN/p/supported-models/grok-imagine"
+    videoSrc="https://media.comfy.org/website/models/video_ComfdyUI_00001_.mp4"
+    videoAriaLabel="使用 ComfyUI 创建的 Grok Imagine 作品"
+  />
+  <ModelCreationsSection client:load locale="zh-CN" />
+  <AIModelsSection client:load locale="zh-CN" />
+  <ProductShowcaseSection client:load locale="zh-CN" />
+</BaseLayout>

browser_tests/fixtures/utils/boundsUtils.ts

@@ -1,4 +1,4 @@
-import type { Locator, Page } from '@playwright/test'
+import type { Page } from '@playwright/test'
 
 import { SELECTION_BOUNDS_PADDING } from '@/base/common/selectionBounds'
 import type { CanvasRect } from '@/base/common/selectionBounds'
@@ -91,21 +91,3 @@ export async function measureSelectionBounds(
     { ids: nodeIds, padding: SELECTION_BOUNDS_PADDING }
   ) as Promise<MeasureResult>
 }
-
-export async function intersection(a: Locator, b: Locator) {
-  const aBounds = await a.boundingBox()
-  const bBounds = await b.boundingBox()
-  if (!aBounds || !bBounds) return undefined
-
-  const y = Math.max(aBounds.y, bBounds.y)
-  const x = Math.max(aBounds.x, bBounds.x)
-  const bot = Math.min(aBounds.y + aBounds.height, bBounds.y + bBounds.height)
-  const right = Math.min(aBounds.x + aBounds.width, bBounds.x + bBounds.width)
-
-  if (y > bot || x > right) return undefined
-
-  const width = right - x
-  const height = bot - y
-
-  return { x, y, width, height }
-}

browser_tests/tests/load3d/load3dSerializeCache.spec.ts

@@ -1,63 +0,0 @@
-import { expect } from '@playwright/test'
-
-import { ExecutionHelper } from '@e2e/fixtures/helpers/ExecutionHelper'
-import { load3dTest as test } from '@e2e/fixtures/helpers/Load3DFixtures'
-
-type Load3dImageInput = {
-  image: string
-  mask: string
-  normal: string
-  recording: string
-}
-
-type PromptBody = {
-  prompt?: Record<
-    string,
-    { class_type?: string; inputs?: Record<string, unknown> }
-  >
-}
-
-function getLoad3dImageInput(body: unknown, nodeId: string): Load3dImageInput {
-  const prompt = (body as PromptBody).prompt ?? {}
-  const node = prompt[nodeId]
-  expect(node?.class_type, `node ${nodeId} should be Load3D`).toBe('Load3D')
-  const input = node!.inputs!.image as Load3dImageInput
-  expect(typeof input.image).toBe('string')
-  expect(typeof input.recording).toBe('string')
-  return input
-}
-
-test.describe('Load3D serialize cache', () => {
-  test('starting a recording forces the next queue to re-capture (FE-905)', async ({
-    comfyPage,
-    load3d
-  }) => {
-    const exec = new ExecutionHelper(comfyPage)
-
-    let firstBody: unknown
-    await exec.run({
-      onPromptRequest: (body) => {
-        firstBody = body
-      }
-    })
-    const firstInput = getLoad3dImageInput(firstBody, '1')
-    expect(firstInput.recording).toBe('')
-
-    await load3d.recordingButton.click()
-    await expect(load3d.stopRecordingButton).toBeVisible()
-
-    let secondBody: unknown
-    await exec.run({
-      onPromptRequest: (body) => {
-        secondBody = body
-      }
-    })
-    const secondInput = getLoad3dImageInput(secondBody, '1')
-
-    expect(
-      secondInput.image,
-      'after starting a recording, the next queue must re-capture ' +
-        '(image filename must change) so the recording is not dropped'
-    ).not.toBe(firstInput.image)
-  })
-})

browser_tests/tests/textareaWidgetFontSize.spec.ts

@@ -1,30 +0,0 @@
-import { expect } from '@playwright/test'
-
-import { comfyPageFixture as test } from '@e2e/fixtures/ComfyPage'
-
-test.describe(
-  'Textarea widget font size',
-  { tag: ['@widget', '@vue-nodes'] },
-  () => {
-    test.beforeEach(async ({ comfyPage }) => {
-      await comfyPage.workflow.loadWorkflow('default')
-    })
-
-    test('applies Comfy.TextareaWidget.FontSize to Vue Nodes 2.0 textarea widget', async ({
-      comfyPage
-    }) => {
-      const textarea = comfyPage.vueNodes.nodes.locator('textarea').first()
-      await expect(textarea).toBeVisible()
-
-      await comfyPage.settings.setSetting('Comfy.TextareaWidget.FontSize', 14)
-      await expect
-        .poll(() => textarea.evaluate((el) => getComputedStyle(el).fontSize))
-        .toBe('14px')
-
-      await comfyPage.settings.setSetting('Comfy.TextareaWidget.FontSize', 22)
-      await expect
-        .poll(() => textarea.evaluate((el) => getComputedStyle(el).fontSize))
-        .toBe('22px')
-    })
-  }
-)

browser_tests/tests/vueNodes/widgets/combo/comboWidget.spec.ts

@@ -1,12 +1,10 @@
-import type { Locator } from '@playwright/test'
-
 import {
   comfyExpect as expect,
   comfyPageFixture as test
 } from '@e2e/fixtures/ComfyPage'
 import { TestIds } from '@e2e/fixtures/selectors'
 import type { ComfyPage } from '@e2e/fixtures/ComfyPage'
-import { intersection } from '@e2e/fixtures/utils/boundsUtils'
+import type { Locator } from '@playwright/test'
 
 test.describe('Vue Combo Widget', { tag: ['@vue-nodes', '@widget'] }, () => {
   async function openSamplerDropdown(comfyPage: ComfyPage) {
@@ -280,31 +278,4 @@ test.describe('Vue Combo Widget', { tag: ['@vue-nodes', '@widget'] }, () => {
       .getByRole('combobox', { name: 'scheduler', exact: true })
     await expect(schedulerComboAfterReload).toContainText('karras')
   })
-
-  test('Dropdown displays over Selection Toolbox', async ({ comfyPage }) => {
-    await comfyPage.settings.setSetting('Comfy.Canvas.SelectionToolbox', true)
-
-    const nodeName = 'Resize Image/Mask'
-    await comfyPage.searchBoxV2.addNode(nodeName, {
-      position: { x: 200, y: 630 }
-    })
-    const node = await comfyPage.vueNodes.getFixtureByTitle(nodeName)
-    await node.select()
-    await expect(comfyPage.selectionToolbox).toBeVisible()
-
-    const combo = comfyPage.vueNodes.getWidgetByName(nodeName, 'resize_type')
-    await combo.click()
-    const dropdown = comfyPage.page.getByTestId(
-      TestIds.widgets.selectDefaultViewport
-    )
-    await expect(dropdown).toBeVisible()
-
-    const bounds = (await intersection(dropdown, comfyPage.selectionToolbox))!
-    expect(bounds, 'toolbox and dropdown overlap').toBeDefined()
-    const cX = bounds.x + bounds.width / 2
-    const cY = bounds.y + bounds.height / 2
-    const dropdownBounds = (await dropdown.boundingBox())!
-    const position = { x: cX - dropdownBounds.x, y: cY - dropdownBounds.y }
-    await dropdown.click({ position, trial: true })
-  })
 })

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

@@ -121,7 +121,6 @@
   --comfy-topbar-height: 2.5rem;
   --workflow-tabs-height: 2.375rem;
   --comfy-input-bg: #222;
-  --comfy-textarea-font-size: 10px;
   --input-text: #ddd;
   --descrip-text: #999;
   --drag-text: #ccc;

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

@@ -111,7 +111,6 @@ describe('formatUtil', () => {
         expect(getMediaTypeFromFilename('scene.fbx')).toBe('3D')
         expect(getMediaTypeFromFilename('asset.gltf')).toBe('3D')
         expect(getMediaTypeFromFilename('binary.glb')).toBe('3D')
-        expect(getMediaTypeFromFilename('print.stl')).toBe('3D')
         expect(getMediaTypeFromFilename('apple.usdz')).toBe('3D')
         expect(getMediaTypeFromFilename('scan.ply')).toBe('3D')
       })

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

@@ -591,15 +591,7 @@ const IMAGE_EXTENSIONS = [
 ] as const
 const VIDEO_EXTENSIONS = ['mp4', 'm4v', 'webm', 'mov', 'avi', 'mkv'] as const
 const AUDIO_EXTENSIONS = ['mp3', 'wav', 'ogg', 'flac'] as const
-const THREE_D_EXTENSIONS = [
-  'obj',
-  'fbx',
-  'gltf',
-  'glb',
-  'stl',
-  'usdz',
-  'ply'
-] as const
+const THREE_D_EXTENSIONS = ['obj', 'fbx', 'gltf', 'glb', 'usdz', 'ply'] as const
 const TEXT_EXTENSIONS = [
   'txt',
   'md',

src/components/builder/AppModeWidgetList.vue

@@ -8,6 +8,7 @@ import { useI18n } from 'vue-i18n'
 import Popover from '@/components/ui/Popover.vue'
 import Button from '@/components/ui/button/Button.vue'
 import { extractVueNodeData } from '@/composables/graph/useGraphNodeManager'
+import { OverlayAppendToKey } from '@/composables/useTransformCompatOverlayProps'
 import type { LGraphNode } from '@/lib/litegraph/src/LGraphNode'
 import { LGraphEventMode } from '@/lib/litegraph/src/types/globalEnums'
 import type { IBaseWidget } from '@/lib/litegraph/src/types/widgets'
@@ -49,6 +50,7 @@ const { onPointerDown } = useAppModeWidgetResizing((widget, config) =>
 )
 
 provide(HideLayoutFieldKey, true)
+provide(OverlayAppendToKey, 'body')
 
 const resolvedInputs = useResolvedSelectedInputs()
 

src/components/graph/SelectionToolbox.vue

@@ -20,7 +20,6 @@
         <InfoButton v-if="canOpenNodeInfo" />
 
         <ColorPickerButton v-if="showColorPicker" />
-        <ArrangeButton v-if="showArrange" />
         <FrameNodes v-if="showFrameNodes" />
         <ConvertToSubgraphButton v-if="showConvertToSubgraph" />
         <ConfigureSubgraph v-if="showSubgraphButtons" />
@@ -50,7 +49,6 @@
 import Panel from 'primevue/panel'
 import { computed, ref } from 'vue'
 
-import ArrangeButton from '@/components/graph/selectionToolbox/ArrangeButton.vue'
 import BypassButton from '@/components/graph/selectionToolbox/BypassButton.vue'
 import ColorPickerButton from '@/components/graph/selectionToolbox/ColorPickerButton.vue'
 import ConfigureSubgraph from '@/components/graph/selectionToolbox/ConfigureSubgraph.vue'
@@ -112,7 +110,6 @@ const {
 
 const showColorPicker = computed(() => hasAnySelection.value)
 const showConvertToSubgraph = computed(() => hasAnySelection.value)
-const showArrange = computed(() => hasMultipleSelection.value)
 const showFrameNodes = computed(() => hasMultipleSelection.value)
 const showSubgraphButtons = computed(() => isSingleSubgraph.value)
 
@@ -131,7 +128,6 @@ const showAnyPrimaryActions = computed(
   () =>
     showColorPicker.value ||
     showConvertToSubgraph.value ||
-    showArrange.value ||
     showFrameNodes.value ||
     showSubgraphButtons.value
 )

src/components/graph/selectionToolbox/ArrangeButton.vue

@@ -1,115 +0,0 @@
-<template>
-  <PopoverRoot v-model:open="isOpen">
-    <PopoverTrigger as-child>
-      <Button
-        v-tooltip.top="{ value: t('g.arrange'), showDelay: 1000 }"
-        variant="muted-textonly"
-        :aria-label="t('g.arrange')"
-      >
-        <div class="flex items-center gap-1 px-0">
-          <i class="icon-[lucide--layout-grid]" />
-          <i class="icon-[lucide--chevron-down]" />
-        </div>
-      </Button>
-    </PopoverTrigger>
-    <PopoverPortal>
-      <PopoverContent
-        side="bottom"
-        :side-offset="5"
-        :collision-padding="10"
-        class="data-[state=open]:data-[side=top]:animate-slideDownAndFade data-[state=open]:data-[side=right]:animate-slideLeftAndFade data-[state=open]:data-[side=bottom]:animate-slideUpAndFade data-[state=open]:data-[side=left]:animate-slideRightAndFade z-1700 rounded-lg border border-border-subtle bg-base-background p-2 shadow-sm will-change-[transform,opacity]"
-      >
-        <div
-          v-if="activeLayout"
-          class="flex w-32 flex-row items-center px-2 py-1"
-        >
-          <Slider
-            :model-value="[gap]"
-            :min="MIN_ARRANGE_GAP"
-            :max="MAX_ARRANGE_GAP"
-            :step="1"
-            :aria-label="t('g.arrangeSpacing')"
-            @update:model-value="onSliderUpdate"
-            @value-commit="onSliderCommit"
-          />
-        </div>
-        <div v-else class="flex flex-row gap-1">
-          <Button
-            v-tooltip.top="{
-              value: t('g.arrangeVertically'),
-              showDelay: 1000
-            }"
-            variant="muted-textonly"
-            :aria-label="t('g.arrangeVertically')"
-            @click="start('vertical')"
-          >
-            <i class="icon-[lucide--stretch-horizontal]" />
-          </Button>
-          <Button
-            v-tooltip.top="{
-              value: t('g.arrangeHorizontally'),
-              showDelay: 1000
-            }"
-            variant="muted-textonly"
-            :aria-label="t('g.arrangeHorizontally')"
-            @click="start('horizontal')"
-          >
-            <i class="icon-[lucide--stretch-vertical]" />
-          </Button>
-          <Button
-            v-tooltip.top="{ value: t('g.arrangeAsGrid'), showDelay: 1000 }"
-            variant="muted-textonly"
-            :aria-label="t('g.arrangeAsGrid')"
-            @click="start('grid')"
-          >
-            <i class="icon-[lucide--grid-3x3]" />
-          </Button>
-        </div>
-        <PopoverArrow class="fill-base-background stroke-border-subtle" />
-      </PopoverContent>
-    </PopoverPortal>
-  </PopoverRoot>
-</template>
-
-<script setup lang="ts">
-import {
-  PopoverArrow,
-  PopoverContent,
-  PopoverPortal,
-  PopoverRoot,
-  PopoverTrigger
-} from 'reka-ui'
-import { ref, watch } from 'vue'
-import { useI18n } from 'vue-i18n'
-
-import Button from '@/components/ui/button/Button.vue'
-import Slider from '@/components/ui/slider/Slider.vue'
-import {
-  MAX_ARRANGE_GAP,
-  MIN_ARRANGE_GAP
-} from '@/composables/graph/useArrangeNodes'
-import { useArrangeSession } from '@/composables/graph/useArrangeSession'
-
-const { t } = useI18n()
-const { activeLayout, gap, start, previewGap, commitGap, reset } =
-  useArrangeSession()
-
-const isOpen = ref(false)
-
-watch(isOpen, (open) => {
-  if (!open) reset()
-})
-
-const firstValue = (value: number[] | undefined): number | undefined =>
-  value?.[0]
-
-const onSliderUpdate = (value: number[] | undefined) => {
-  const next = firstValue(value)
-  if (next !== undefined) previewGap(next)
-}
-
-const onSliderCommit = (value: number[]) => {
-  const next = firstValue(value)
-  if (next !== undefined) commitGap(next)
-}
-</script>

src/components/load3d/Load3D.vue

@@ -23,8 +23,6 @@
         :can-use-gizmo="canUseGizmo"
         :can-use-lighting="canUseLighting"
         :can-export="canExport"
-        :can-use-hdri="canUseHdri"
-        :can-use-background-image="canUseBackgroundImage"
         :material-modes="materialModes"
         :has-skeleton="hasSkeleton"
         @update-background-image="handleBackgroundImageUpdate"
@@ -88,7 +86,7 @@
       />
 
       <RecordingControls
-        v-if="canUseRecording && !isPreview"
+        v-if="!isPreview"
         v-model:is-recording="isRecording"
         v-model:has-recording="hasRecording"
         v-model:recording-duration="recordingDuration"
@@ -119,18 +117,9 @@ import { resolveNode } from '@/utils/litegraphUtil'
 import type { ComponentWidget } from '@/scripts/domWidget'
 import type { SimplifiedWidget } from '@/types/simplifiedWidget'
 
-const {
-  widget,
-  nodeId,
-  canUseRecording = true,
-  canUseHdri = true,
-  canUseBackgroundImage = true
-} = defineProps<{
+const props = defineProps<{
   widget: ComponentWidget<string[]> | SimplifiedWidget
   nodeId?: NodeId
-  canUseRecording?: boolean
-  canUseHdri?: boolean
-  canUseBackgroundImage?: boolean
 }>()
 
 function isComponentWidget(
@@ -141,11 +130,11 @@ function isComponentWidget(
 
 const node = ref<LGraphNode | null>(null)
 
-if (isComponentWidget(widget)) {
-  node.value = widget.node
-} else if (nodeId) {
+if (isComponentWidget(props.widget)) {
+  node.value = props.widget.node
+} else if (props.nodeId) {
   onMounted(() => {
-    node.value = resolveNode(nodeId) ?? null
+    node.value = resolveNode(props.nodeId!) ?? null
   })
 }
 

src/components/load3d/Load3DAdvanced.test.ts

@@ -1,47 +0,0 @@
-import { render } from '@testing-library/vue'
-import { describe, expect, it, vi } from 'vitest'
-import { defineComponent, h, ref } from 'vue'
-
-const lastProps = ref<Record<string, unknown> | null>(null)
-
-vi.mock('@/components/load3d/Load3D.vue', () => ({
-  default: defineComponent({
-    name: 'Load3D',
-    props: {
-      widget: { type: null, required: false, default: undefined },
-      nodeId: { type: null, required: false, default: undefined },
-      canUseRecording: { type: Boolean, default: true },
-      canUseHdri: { type: Boolean, default: true },
-      canUseBackgroundImage: { type: Boolean, default: true }
-    },
-    setup(props: Record<string, unknown>) {
-      lastProps.value = { ...props }
-      return () => h('div', { 'data-testid': 'load3d-stub' })
-    }
-  })
-}))
-
-import Load3DAdvanced from '@/components/load3d/Load3DAdvanced.vue'
-
-describe('Load3DAdvanced', () => {
-  it('renders the inner Load3D with all expressive features disabled', () => {
-    const MOCK_NODE = { id: 'node', type: 'Load3DAdvanced' }
-    render(Load3DAdvanced, {
-      props: {
-        widget: { node: MOCK_NODE } as never
-      }
-    })
-    expect(lastProps.value).toMatchObject({
-      canUseRecording: false,
-      canUseHdri: false,
-      canUseBackgroundImage: false
-    })
-  })
-
-  it('forwards widget and nodeId to the inner Load3D', () => {
-    const widget = { node: { id: 'a', type: 'Load3DAdvanced' } }
-    render(Load3DAdvanced, { props: { widget: widget as never, nodeId: 'a' } })
-    expect(lastProps.value?.widget).toEqual(widget)
-    expect(lastProps.value?.nodeId).toBe('a')
-  })
-})

src/components/load3d/Load3DAdvanced.vue

@@ -1,21 +0,0 @@
-<template>
-  <Load3D
-    :widget="widget"
-    :node-id="nodeId"
-    :can-use-recording="false"
-    :can-use-hdri="false"
-    :can-use-background-image="false"
-  />
-</template>
-
-<script setup lang="ts">
-import Load3D from '@/components/load3d/Load3D.vue'
-import type { NodeId } from '@/platform/workflow/validation/schemas/workflowSchema'
-import type { ComponentWidget } from '@/scripts/domWidget'
-import type { SimplifiedWidget } from '@/types/simplifiedWidget'
-
-defineProps<{
-  widget: ComponentWidget<string[]> | SimplifiedWidget
-  nodeId?: NodeId
-}>()
-</script>

src/components/load3d/Load3DControls.vue

@@ -52,7 +52,6 @@
         v-model:background-image="sceneConfig!.backgroundImage"
         v-model:background-render-mode="sceneConfig!.backgroundRenderMode"
         v-model:fov="cameraConfig!.fov"
-        :show-background-image="canUseBackgroundImage"
         :hdri-active="
           !!lightConfig?.hdri?.hdriPath && !!lightConfig?.hdri?.enabled
         "
@@ -82,7 +81,6 @@
         />
 
         <HDRIControls
-          v-if="canUseHdri"
           v-model:hdri-config="lightConfig!.hdri"
           :has-background-image="!!sceneConfig?.backgroundImage"
           @update-hdri-file="handleHDRIFileUpdate"
@@ -131,16 +129,12 @@ const {
   canUseGizmo = true,
   canUseLighting = true,
   canExport = true,
-  canUseHdri = true,
-  canUseBackgroundImage = true,
   materialModes = ['original', 'normal', 'wireframe'],
   hasSkeleton = false
 } = defineProps<{
   canUseGizmo?: boolean
   canUseLighting?: boolean
   canExport?: boolean
-  canUseHdri?: boolean
-  canUseBackgroundImage?: boolean
   materialModes?: readonly MaterialMode[]
   hasSkeleton?: boolean
 }>()

src/components/load3d/controls/SceneControls.vue

@@ -37,7 +37,7 @@
         </Button>
       </div>
 
-      <div v-if="showBackgroundImage && !hasBackgroundImage">
+      <div v-if="!hasBackgroundImage">
         <Button
           v-tooltip.right="{
             value: $t('load3d.uploadBackgroundImage'),
@@ -61,7 +61,7 @@
       </div>
     </template>
 
-    <div v-if="showBackgroundImage && hasBackgroundImage">
+    <div v-if="hasBackgroundImage">
       <Button
         v-tooltip.right="{
           value: $t('load3d.panoramaMode'),
@@ -83,16 +83,12 @@
     </div>
 
     <PopupSlider
-      v-if="
-        showBackgroundImage &&
-        hasBackgroundImage &&
-        backgroundRenderMode === 'panorama'
-      "
+      v-if="hasBackgroundImage && backgroundRenderMode === 'panorama'"
       v-model="fov"
       :tooltip-text="$t('load3d.fov')"
     />
 
-    <div v-if="showBackgroundImage && hasBackgroundImage">
+    <div v-if="hasBackgroundImage">
       <Button
         v-tooltip.right="{
           value: $t('load3d.removeBackgroundImage'),
@@ -118,9 +114,8 @@ import Button from '@/components/ui/button/Button.vue'
 import type { BackgroundRenderModeType } from '@/extensions/core/load3d/interfaces'
 import { cn } from '@comfyorg/tailwind-utils'
 
-const { hdriActive = false, showBackgroundImage = true } = defineProps<{
+const { hdriActive = false } = defineProps<{
   hdriActive?: boolean
-  showBackgroundImage?: boolean
 }>()
 
 const emit = defineEmits<{

src/composables/graph/useArrangeNodes.test.ts

@@ -1,182 +0,0 @@
-import { describe, expect, it } from 'vitest'
-
-import { computeArrangement } from '@/composables/graph/useArrangeNodes'
-import type { LGraphNode } from '@/lib/litegraph/src/litegraph'
-import { TitleMode } from '@/lib/litegraph/src/types/globalEnums'
-
-interface MockNodeSpec {
-  id: number | string
-  pos: [number, number]
-  size: [number, number]
-  title_mode?: TitleMode
-}
-
-const makeNode = (spec: MockNodeSpec): LGraphNode =>
-  ({
-    id: spec.id,
-    pos: spec.pos,
-    size: spec.size,
-    title_mode: spec.title_mode
-  }) as unknown as LGraphNode
-
-const GAP = 12
-const TITLE = 30 // LiteGraph.NODE_TITLE_HEIGHT default
-
-describe('computeArrangement', () => {
-  it('returns no updates when fewer than 2 nodes are selected', () => {
-    expect(computeArrangement([], 'vertical')).toEqual([])
-    expect(
-      computeArrangement(
-        [makeNode({ id: 1, pos: [0, 0], size: [100, 50] })],
-        'grid'
-      )
-    ).toEqual([])
-  })
-
-  describe('vertical', () => {
-    it('left-aligns to anchor x and stacks downward sorted by current y', () => {
-      const nodes = [
-        makeNode({ id: 'a', pos: [10, 100], size: [100, 50] }),
-        makeNode({ id: 'b', pos: [200, 0], size: [80, 30] }),
-        makeNode({ id: 'c', pos: [50, 200], size: [120, 40] })
-      ]
-      // Anchor: 'a' has smallest x+y (110). Sort by Y: b(0), a(100), c(200).
-      // Visual top of layout = anchor.posY - TITLE = 100 - 30 = 70.
-      // Each node's pos.y = visualTop + its titleHeight (30).
-      // b: pos.y = 70+30 = 100; visualTop += (30+30)+12 = 142
-      // a: pos.y = 142+30 = 172; visualTop += (50+30)+12 = 234
-      // c: pos.y = 234+30 = 264
-      const result = computeArrangement(nodes, 'vertical')
-      expect(result).toEqual([
-        { nodeId: 'b', position: { x: 10, y: 100 } },
-        { nodeId: 'a', position: { x: 10, y: 172 } },
-        { nodeId: 'c', position: { x: 10, y: 264 } }
-      ])
-    })
-
-    it('omits the title-height contribution for NO_TITLE nodes', () => {
-      const nodes = [
-        makeNode({
-          id: 1,
-          pos: [0, 0],
-          size: [100, 100],
-          title_mode: TitleMode.NO_TITLE
-        }),
-        makeNode({
-          id: 2,
-          pos: [0, 200],
-          size: [100, 100],
-          title_mode: TitleMode.NO_TITLE
-        })
-      ]
-      // No titles: visualHeight = size[1] = 100. visualTop = 0. Gap = 12.
-      // 1: pos.y = 0; visualTop = 0 + 100 + 12 = 112.
-      // 2: pos.y = 112.
-      const result = computeArrangement(nodes, 'vertical')
-      expect(result).toEqual([
-        { nodeId: 1, position: { x: 0, y: 0 } },
-        { nodeId: 2, position: { x: 0, y: 100 + GAP } }
-      ])
-    })
-
-    it('preserves heterogeneous heights when computing gaps', () => {
-      const nodes = [
-        makeNode({ id: 1, pos: [0, 0], size: [100, 200] }),
-        makeNode({ id: 2, pos: [0, 50], size: [100, 50] })
-      ]
-      // visualTop=-30. 1: pos.y=0; visualTop += (200+30)+12 = 212.
-      // 2: pos.y = 212+30 = 242.
-      const result = computeArrangement(nodes, 'vertical')
-      expect(result).toEqual([
-        { nodeId: 1, position: { x: 0, y: 0 } },
-        { nodeId: 2, position: { x: 0, y: 200 + TITLE + GAP } }
-      ])
-    })
-  })
-
-  describe('horizontal', () => {
-    it('top-aligns to anchor y and lays out rightward sorted by current x', () => {
-      const nodes = [
-        makeNode({ id: 'a', pos: [100, 50], size: [80, 40] }),
-        makeNode({ id: 'b', pos: [0, 200], size: [60, 30] }),
-        makeNode({ id: 'c', pos: [300, 80], size: [50, 50] })
-      ]
-      // Anchor: smallest x+y → a(150), b(200), c(380) → anchor 'a' at (100, 50).
-      // Sort by X: b(0), a(100), c(300)
-      // Lay out from (100, 50):
-      //   b at (100, 50)
-      //   a at (100 + 60 + 12, 50) = (172, 50)
-      //   c at (172 + 80 + 12, 50) = (264, 50)
-      const result = computeArrangement(nodes, 'horizontal')
-      expect(result).toEqual([
-        { nodeId: 'b', position: { x: 100, y: 50 } },
-        { nodeId: 'a', position: { x: 172, y: 50 } },
-        { nodeId: 'c', position: { x: 264, y: 50 } }
-      ])
-    })
-  })
-
-  describe('grid', () => {
-    it('lays out 4 nodes as 2x2 with column/row sizes from max width/height', () => {
-      const nodes = [
-        makeNode({ id: 1, pos: [0, 0], size: [100, 50] }),
-        makeNode({ id: 2, pos: [200, 0], size: [80, 60] }),
-        makeNode({ id: 3, pos: [0, 100], size: [120, 40] }),
-        makeNode({ id: 4, pos: [200, 100], size: [90, 30] })
-      ]
-      // Anchor: 1 at (0,0). Sort by Y then X: 1, 2, 3, 4. cols=2, rows=2.
-      // Col widths: col0=max(100,120)=120; col1=max(80,90)=90.
-      // Row visual heights: row0=max(50+30,60+30)=90; row1=max(40+30,30+30)=70.
-      // colX=[0, 132]. rowVisualTop=[-30, -30+90+12=72].
-      // pos.y = rowVisualTop + 30 (titleHeight).
-      const result = computeArrangement(nodes, 'grid')
-      expect(result).toEqual([
-        { nodeId: 1, position: { x: 0, y: 0 } },
-        { nodeId: 2, position: { x: 132, y: 0 } },
-        { nodeId: 3, position: { x: 0, y: 102 } },
-        { nodeId: 4, position: { x: 132, y: 102 } }
-      ])
-    })
-
-    it('uses ceil(sqrt(n)) columns for non-square counts', () => {
-      // 5 nodes → ceil(sqrt(5))=3 cols, 2 rows. Last cell empty.
-      const nodes = Array.from({ length: 5 }, (_, i) =>
-        makeNode({
-          id: i + 1,
-          pos: [i * 50, i * 50],
-          size: [40, 40]
-        })
-      )
-      const result = computeArrangement(nodes, 'grid')
-      expect(result).toHaveLength(5)
-      // Sorted by Y then X = original order. Anchor = node 1 at (0,0).
-      // colWidths=[40,40,40]. rowVisualHeight = 40+30 = 70 each.
-      // colX=[0,52,104]. rowVisualTop=[-30, -30+70+12=52]. pos.y = visualTop+30.
-      expect(result[0].position).toEqual({ x: 0, y: 0 })
-      expect(result[1].position).toEqual({ x: 52, y: 0 })
-      expect(result[2].position).toEqual({ x: 104, y: 0 })
-      expect(result[3].position).toEqual({ x: 0, y: 82 })
-      expect(result[4].position).toEqual({ x: 52, y: 82 })
-    })
-  })
-
-  describe('anchor selection', () => {
-    it('picks the node with smallest x+y, not min-x or min-y alone', () => {
-      const nodes = [
-        // min y but large x: x+y = 1000
-        makeNode({ id: 'minY', pos: [1000, 0], size: [50, 50] }),
-        // min x but large y: x+y = 1000
-        makeNode({ id: 'minX', pos: [0, 1000], size: [50, 50] }),
-        // smallest x+y: 600
-        makeNode({ id: 'anchor', pos: [300, 300], size: [50, 50] })
-      ]
-      const result = computeArrangement(nodes, 'vertical')
-      // All updates left-align to anchor.x = 300. First in sort = minY (y=0).
-      expect(result[0]).toEqual({
-        nodeId: 'minY',
-        position: { x: 300, y: 300 }
-      })
-      expect(result.every((u) => u.position.x === 300)).toBe(true)
-    })
-  })
-})

src/composables/graph/useArrangeNodes.ts

@@ -1,186 +0,0 @@
-import { useSelectionState } from '@/composables/graph/useSelectionState'
-import { LiteGraph } from '@/lib/litegraph/src/litegraph'
-import type { LGraphNode, NodeId } from '@/lib/litegraph/src/litegraph'
-import { TitleMode } from '@/lib/litegraph/src/types/globalEnums'
-import { useWorkflowStore } from '@/platform/workflow/management/stores/workflowStore'
-import { useLayoutMutations } from '@/renderer/core/layout/operations/layoutMutations'
-import { LayoutSource } from '@/renderer/core/layout/types'
-import type { Point } from '@/renderer/core/layout/types'
-import { app } from '@/scripts/app'
-
-export type ArrangeLayout = 'vertical' | 'horizontal' | 'grid'
-
-export const DEFAULT_ARRANGE_GAP = 12
-export const MIN_ARRANGE_GAP = 0
-export const MAX_ARRANGE_GAP = 48
-
-interface NodeBox {
-  id: NodeId
-  posX: number
-  posY: number
-  visualWidth: number
-  visualHeight: number
-  titleHeight: number
-}
-
-interface ArrangeUpdate {
-  nodeId: NodeId
-  position: Point
-}
-
-const titleHeightOf = (node: LGraphNode): number => {
-  const mode = node.title_mode
-  if (mode === TitleMode.TRANSPARENT_TITLE || mode === TitleMode.NO_TITLE) {
-    return 0
-  }
-  return LiteGraph.NODE_TITLE_HEIGHT
-}
-
-const toBox = (node: LGraphNode): NodeBox => {
-  const titleHeight = titleHeightOf(node)
-  return {
-    id: node.id,
-    posX: node.pos[0],
-    posY: node.pos[1],
-    visualWidth: node.size[0],
-    visualHeight: node.size[1] + titleHeight,
-    titleHeight
-  }
-}
-
-const byTopDown = (a: NodeBox, b: NodeBox) => a.posY - b.posY || a.posX - b.posX
-
-const byLeftRight = (a: NodeBox, b: NodeBox) =>
-  a.posX - b.posX || a.posY - b.posY
-
-const findAnchor = (boxes: NodeBox[]): NodeBox =>
-  boxes.reduce((best, box) =>
-    box.posX + box.posY < best.posX + best.posY ? box : best
-  )
-
-const cumulativeOffsets = (
-  sizes: number[],
-  origin: number,
-  gap: number
-): number[] => {
-  const offsets: number[] = [origin]
-  for (let i = 1; i < sizes.length; i++) {
-    offsets.push(offsets[i - 1] + sizes[i - 1] + gap)
-  }
-  return offsets
-}
-
-const arrangeVertical = (
-  boxes: NodeBox[],
-  anchor: NodeBox,
-  gap: number
-): ArrangeUpdate[] => {
-  const sorted = [...boxes].sort(byTopDown)
-  let visualTop = anchor.posY - anchor.titleHeight
-  return sorted.map((box) => {
-    const update: ArrangeUpdate = {
-      nodeId: box.id,
-      position: { x: anchor.posX, y: visualTop + box.titleHeight }
-    }
-    visualTop += box.visualHeight + gap
-    return update
-  })
-}
-
-const arrangeHorizontal = (
-  boxes: NodeBox[],
-  anchor: NodeBox,
-  gap: number
-): ArrangeUpdate[] => {
-  const sorted = [...boxes].sort(byLeftRight)
-  const visualTop = anchor.posY - anchor.titleHeight
-  let cursorX = anchor.posX
-  return sorted.map((box) => {
-    const update: ArrangeUpdate = {
-      nodeId: box.id,
-      position: { x: cursorX, y: visualTop + box.titleHeight }
-    }
-    cursorX += box.visualWidth + gap
-    return update
-  })
-}
-
-const arrangeGrid = (
-  boxes: NodeBox[],
-  anchor: NodeBox,
-  gap: number
-): ArrangeUpdate[] => {
-  const sorted = [...boxes].sort(byTopDown)
-  const cols = Math.ceil(Math.sqrt(sorted.length))
-  const rows = Math.ceil(sorted.length / cols)
-
-  const colWidths = new Array<number>(cols).fill(0)
-  const rowHeights = new Array<number>(rows).fill(0)
-  sorted.forEach((box, i) => {
-    const col = i % cols
-    const row = Math.floor(i / cols)
-    if (box.visualWidth > colWidths[col]) colWidths[col] = box.visualWidth
-    if (box.visualHeight > rowHeights[row]) rowHeights[row] = box.visualHeight
-  })
-
-  const colX = cumulativeOffsets(colWidths, anchor.posX, gap)
-  const rowVisualTop = cumulativeOffsets(
-    rowHeights,
-    anchor.posY - anchor.titleHeight,
-    gap
-  )
-
-  return sorted.map((box, i) => {
-    const col = i % cols
-    const row = Math.floor(i / cols)
-    return {
-      nodeId: box.id,
-      position: {
-        x: colX[col],
-        y: rowVisualTop[row] + box.titleHeight
-      }
-    }
-  })
-}
-
-export function computeArrangement(
-  nodes: LGraphNode[],
-  layout: ArrangeLayout,
-  gap: number = DEFAULT_ARRANGE_GAP
-): ArrangeUpdate[] {
-  if (nodes.length < 2) return []
-  const boxes = nodes.map(toBox)
-  const anchor = findAnchor(boxes)
-  if (layout === 'vertical') return arrangeVertical(boxes, anchor, gap)
-  if (layout === 'horizontal') return arrangeHorizontal(boxes, anchor, gap)
-  return arrangeGrid(boxes, anchor, gap)
-}
-
-interface ArrangeOptions {
-  gap?: number
-  captureUndo?: boolean
-}
-
-export function useArrangeNodes() {
-  const { selectedNodes, hasMultipleSelection } = useSelectionState()
-  const mutations = useLayoutMutations()
-  const workflowStore = useWorkflowStore()
-
-  const arrangeNodes = (
-    layout: ArrangeLayout,
-    { gap = DEFAULT_ARRANGE_GAP, captureUndo = true }: ArrangeOptions = {}
-  ) => {
-    if (!hasMultipleSelection.value) return
-    const updates = computeArrangement(selectedNodes.value, layout, gap)
-    if (updates.length === 0) return
-
-    mutations.setSource(LayoutSource.Canvas)
-    mutations.batchMoveNodes(updates)
-    app.canvas?.setDirty(true, true)
-    if (captureUndo) {
-      workflowStore.activeWorkflow?.changeTracker?.captureCanvasState()
-    }
-  }
-
-  return { arrangeNodes, canArrange: hasMultipleSelection }
-}

src/composables/graph/useArrangeSession.test.ts

@@ -1,115 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
-
-import type * as ArrangeNodesModule from '@/composables/graph/useArrangeNodes'
-import { useArrangeSession } from '@/composables/graph/useArrangeSession'
-
-const mockArrangeNodes = vi.fn()
-
-vi.mock('@/composables/graph/useArrangeNodes', async () => {
-  const actual = await vi.importActual<typeof ArrangeNodesModule>(
-    '@/composables/graph/useArrangeNodes'
-  )
-  return {
-    ...actual,
-    useArrangeNodes: () => ({ arrangeNodes: mockArrangeNodes })
-  }
-})
-
-describe('useArrangeSession', () => {
-  let frameCallbacks: Array<FrameRequestCallback>
-  let nextHandle: number
-
-  beforeEach(() => {
-    mockArrangeNodes.mockReset()
-    frameCallbacks = []
-    nextHandle = 1
-    vi.spyOn(globalThis, 'requestAnimationFrame').mockImplementation(
-      (cb: FrameRequestCallback) => {
-        frameCallbacks.push(cb)
-        return nextHandle++
-      }
-    )
-    vi.spyOn(globalThis, 'cancelAnimationFrame').mockImplementation((id) => {
-      frameCallbacks[id - 1] = () => {}
-    })
-  })
-
-  afterEach(() => {
-    vi.restoreAllMocks()
-  })
-
-  const flushFrames = () => {
-    const callbacks = frameCallbacks
-    frameCallbacks = []
-    callbacks.forEach((cb) => cb(performance.now()))
-  }
-
-  it('start() applies layout immediately and captures undo', () => {
-    const session = useArrangeSession()
-    session.start('vertical')
-
-    expect(mockArrangeNodes).toHaveBeenCalledTimes(1)
-    expect(mockArrangeNodes).toHaveBeenCalledWith('vertical', {
-      gap: 12,
-      captureUndo: true
-    })
-    expect(session.activeLayout.value).toBe('vertical')
-    expect(session.gap.value).toBe(12)
-  })
-
-  it('previewGap() throttles repeated calls into a single frame', () => {
-    const session = useArrangeSession()
-    session.start('grid')
-    mockArrangeNodes.mockClear()
-
-    session.previewGap(20)
-    session.previewGap(30)
-    session.previewGap(40)
-
-    expect(mockArrangeNodes).not.toHaveBeenCalled()
-    flushFrames()
-
-    expect(mockArrangeNodes).toHaveBeenCalledTimes(1)
-    expect(mockArrangeNodes).toHaveBeenCalledWith('grid', {
-      gap: 40,
-      captureUndo: false
-    })
-  })
-
-  it('previewGap() is a no-op outside an active session', () => {
-    const session = useArrangeSession()
-    session.previewGap(20)
-    flushFrames()
-    expect(mockArrangeNodes).not.toHaveBeenCalled()
-  })
-
-  it('commitGap() cancels any pending preview frame', () => {
-    const session = useArrangeSession()
-    session.start('horizontal')
-    mockArrangeNodes.mockClear()
-
-    session.previewGap(25)
-    session.commitGap(36)
-    flushFrames()
-
-    expect(mockArrangeNodes).toHaveBeenCalledTimes(1)
-    expect(mockArrangeNodes).toHaveBeenCalledWith('horizontal', {
-      gap: 36,
-      captureUndo: true
-    })
-  })
-
-  it('reset() ends the session and prevents pending frames from arranging', () => {
-    const session = useArrangeSession()
-    session.start('vertical')
-    mockArrangeNodes.mockClear()
-
-    session.previewGap(40)
-    session.reset()
-    flushFrames()
-
-    expect(mockArrangeNodes).not.toHaveBeenCalled()
-    expect(session.activeLayout.value).toBeNull()
-    expect(session.gap.value).toBe(12)
-  })
-})

src/composables/graph/useArrangeSession.ts

@@ -1,60 +0,0 @@
-import { readonly, ref } from 'vue'
-
-import {
-  DEFAULT_ARRANGE_GAP,
-  useArrangeNodes
-} from '@/composables/graph/useArrangeNodes'
-import type { ArrangeLayout } from '@/composables/graph/useArrangeNodes'
-
-export function useArrangeSession() {
-  const { arrangeNodes } = useArrangeNodes()
-
-  const activeLayout = ref<ArrangeLayout | null>(null)
-  const gap = ref(DEFAULT_ARRANGE_GAP)
-  let pendingFrame: number | null = null
-
-  const cancelPendingFrame = () => {
-    if (pendingFrame === null) return
-    cancelAnimationFrame(pendingFrame)
-    pendingFrame = null
-  }
-
-  const reset = () => {
-    cancelPendingFrame()
-    activeLayout.value = null
-    gap.value = DEFAULT_ARRANGE_GAP
-  }
-
-  const start = (layout: ArrangeLayout) => {
-    gap.value = DEFAULT_ARRANGE_GAP
-    activeLayout.value = layout
-    arrangeNodes(layout, { gap: gap.value, captureUndo: true })
-  }
-
-  const previewGap = (nextGap: number) => {
-    if (activeLayout.value === null) return
-    gap.value = nextGap
-    cancelPendingFrame()
-    pendingFrame = requestAnimationFrame(() => {
-      pendingFrame = null
-      if (activeLayout.value === null) return
-      arrangeNodes(activeLayout.value, { gap: nextGap, captureUndo: false })
-    })
-  }
-
-  const commitGap = (nextGap: number) => {
-    if (activeLayout.value === null) return
-    cancelPendingFrame()
-    gap.value = nextGap
-    arrangeNodes(activeLayout.value, { gap: nextGap, captureUndo: true })
-  }
-
-  return {
-    activeLayout: readonly(activeLayout),
-    gap: readonly(gap),
-    start,
-    previewGap,
-    commitGap,
-    reset
-  }
-}

src/composables/useLoad3d.test.ts

@@ -3,14 +3,7 @@ import { nextTick, reactive, ref, shallowRef } from 'vue'
 import type { Pinia } from 'pinia'
 import { getActivePinia } from 'pinia'
 
-import {
-  getLoad3dOutputCache,
-  isLoad3dSceneDirty,
-  markLoad3dSceneDirty,
-  nodeToLoad3dMap,
-  setLoad3dOutputCache,
-  useLoad3d
-} from '@/composables/useLoad3d'
+import { nodeToLoad3dMap, useLoad3d } from '@/composables/useLoad3d'
 import Load3d from '@/extensions/core/load3d/Load3d'
 import Load3dUtils from '@/extensions/core/load3d/Load3dUtils'
 import { createLoad3d } from '@/extensions/core/load3d/createLoad3d'
@@ -193,7 +186,6 @@ describe('useLoad3d', () => {
       resetGizmoTransform: vi.fn(),
       applyGizmoTransform: vi.fn(),
       fitToViewer: vi.fn(),
-      centerCameraOnModel: vi.fn(),
       getGizmoTransform: vi.fn().mockReturnValue({
         position: { x: 0, y: 0, z: 0 },
         rotation: { x: 0, y: 0, z: 0 },
@@ -1750,184 +1742,4 @@ describe('useLoad3d', () => {
       expect(originalOnRemoved).toHaveBeenCalledTimes(1)
     })
   })
-
-  describe('scene dirty tracking', () => {
-    const fakeCache = {
-      image: 'threed/scene-1.png [temp]',
-      mask: 'threed/scene_mask-1.png [temp]',
-      normal: 'threed/scene_normal-1.png [temp]',
-      camera_info: null,
-      recording: '',
-      model_3d_info: []
-    }
-
-    it('treats an unseen node as dirty by default', () => {
-      const fresh = createMockLGraphNode({ properties: {} })
-      expect(isLoad3dSceneDirty(fresh)).toBe(true)
-    })
-
-    it('markLoad3dSceneDirty sets the node dirty', () => {
-      const fresh = createMockLGraphNode({ properties: {} })
-      setLoad3dOutputCache(fresh, fakeCache)
-      expect(isLoad3dSceneDirty(fresh)).toBe(false)
-
-      markLoad3dSceneDirty(fresh)
-      expect(isLoad3dSceneDirty(fresh)).toBe(true)
-    })
-
-    it('setLoad3dOutputCache stores the output and clears dirty', () => {
-      const fresh = createMockLGraphNode({ properties: {} })
-      setLoad3dOutputCache(fresh, fakeCache)
-
-      expect(getLoad3dOutputCache(fresh)).toBe(fakeCache)
-      expect(isLoad3dSceneDirty(fresh)).toBe(false)
-    })
-
-    it('two nodes keep independent dirty state', () => {
-      const a = createMockLGraphNode({ properties: {} })
-      const b = createMockLGraphNode({ properties: {} })
-
-      setLoad3dOutputCache(a, fakeCache)
-      expect(isLoad3dSceneDirty(a)).toBe(false)
-      expect(isLoad3dSceneDirty(b)).toBe(true)
-
-      markLoad3dSceneDirty(a)
-      expect(isLoad3dSceneDirty(a)).toBe(true)
-      expect(isLoad3dSceneDirty(b)).toBe(true)
-    })
-
-    it('markLoad3dSceneDirty on null is a no-op', () => {
-      expect(() => markLoad3dSceneDirty(null)).not.toThrow()
-    })
-
-    it('sceneConfig changes flip the node dirty', async () => {
-      const composable = useLoad3d(mockNode)
-      const containerRef = document.createElement('div')
-      await composable.initializeLoad3d(containerRef)
-      await nextTick()
-
-      setLoad3dOutputCache(mockNode, fakeCache)
-      expect(isLoad3dSceneDirty(mockNode)).toBe(false)
-
-      composable.sceneConfig.value.backgroundColor = '#ffffff'
-      await nextTick()
-
-      expect(isLoad3dSceneDirty(mockNode)).toBe(true)
-    })
-
-    it('cameraChanged event marks the node dirty', async () => {
-      let cameraChangedHandler: ((state: unknown) => void) | undefined
-      vi.mocked(mockLoad3d.addEventListener!).mockImplementation(
-        (event: string, handler: unknown) => {
-          if (event === 'cameraChanged') {
-            cameraChangedHandler = handler as (state: unknown) => void
-          }
-        }
-      )
-
-      const composable = useLoad3d(mockNode)
-      const containerRef = document.createElement('div')
-      await composable.initializeLoad3d(containerRef)
-      await nextTick()
-
-      setLoad3dOutputCache(mockNode, fakeCache)
-      expect(isLoad3dSceneDirty(mockNode)).toBe(false)
-
-      cameraChangedHandler!({ position: { x: 1, y: 2, z: 3 } })
-
-      expect(isLoad3dSceneDirty(mockNode)).toBe(true)
-    })
-
-    it('handleStopRecording marks dirty when a recording was produced', async () => {
-      const composable = useLoad3d(mockNode)
-      const containerRef = document.createElement('div')
-      await composable.initializeLoad3d(containerRef)
-      await nextTick()
-
-      setLoad3dOutputCache(mockNode, fakeCache)
-
-      vi.mocked(mockLoad3d.getRecordingDuration!).mockReturnValue(5)
-      composable.handleStopRecording()
-
-      expect(isLoad3dSceneDirty(mockNode)).toBe(true)
-    })
-
-    it('handleStopRecording leaves dirty alone when no recording was produced', async () => {
-      const composable = useLoad3d(mockNode)
-      const containerRef = document.createElement('div')
-      await composable.initializeLoad3d(containerRef)
-      await nextTick()
-
-      setLoad3dOutputCache(mockNode, fakeCache)
-
-      vi.mocked(mockLoad3d.getRecordingDuration!).mockReturnValue(0)
-      composable.handleStopRecording()
-
-      expect(isLoad3dSceneDirty(mockNode)).toBe(false)
-    })
-
-    it('handleClearRecording marks dirty', async () => {
-      const composable = useLoad3d(mockNode)
-      const containerRef = document.createElement('div')
-      await composable.initializeLoad3d(containerRef)
-      await nextTick()
-
-      setLoad3dOutputCache(mockNode, fakeCache)
-      composable.handleClearRecording()
-
-      expect(isLoad3dSceneDirty(mockNode)).toBe(true)
-    })
-
-    it('handleStartRecording marks dirty so an in-progress recording forces a re-capture', async () => {
-      const composable = useLoad3d(mockNode)
-      const containerRef = document.createElement('div')
-      await composable.initializeLoad3d(containerRef)
-      await nextTick()
-
-      setLoad3dOutputCache(mockNode, fakeCache)
-      expect(isLoad3dSceneDirty(mockNode)).toBe(false)
-
-      await composable.handleStartRecording()
-
-      expect(mockLoad3d.startRecording).toHaveBeenCalledTimes(1)
-      expect(isLoad3dSceneDirty(mockNode)).toBe(true)
-    })
-
-    it('handleCenterCameraOnModel marks dirty', async () => {
-      const composable = useLoad3d(mockNode)
-      const containerRef = document.createElement('div')
-      await composable.initializeLoad3d(containerRef)
-      await nextTick()
-
-      setLoad3dOutputCache(mockNode, fakeCache)
-      expect(isLoad3dSceneDirty(mockNode)).toBe(false)
-
-      composable.handleCenterCameraOnModel()
-
-      expect(mockLoad3d.centerCameraOnModel).toHaveBeenCalledTimes(1)
-      expect(isLoad3dSceneDirty(mockNode)).toBe(true)
-    })
-
-    it('handleSeek marks dirty when the animation has a duration', async () => {
-      const composable = useLoad3d(mockNode)
-      const containerRef = document.createElement('div')
-      await composable.initializeLoad3d(containerRef)
-      await nextTick()
-
-      const calls = vi.mocked(mockLoad3d.addEventListener!).mock.calls
-      const match = calls.find(([event]) => event === 'animationProgressChange')
-      const animationProgressHandler = match![1] as (d: {
-        progress: number
-        currentTime: number
-        duration: number
-      }) => void
-
-      animationProgressHandler({ progress: 0, currentTime: 0, duration: 10 })
-      setLoad3dOutputCache(mockNode, fakeCache)
-
-      composable.handleSeek(50)
-
-      expect(isLoad3dSceneDirty(mockNode)).toBe(true)
-    })
-  })
 })

src/composables/useLoad3d.ts

@@ -22,7 +22,6 @@ import type {
   GizmoMode,
   LightConfig,
   MaterialMode,
-  Model3DInfo,
   ModelConfig,
   SceneConfig,
   UpDirection
@@ -39,38 +38,6 @@ import { useLoad3dService } from '@/services/load3dService'
 
 type Load3dReadyCallback = (load3d: Load3d) => void
 export const nodeToLoad3dMap = new Map<LGraphNode, Load3d>()
-
-export type Load3dCachedOutput = {
-  image: string
-  mask: string
-  normal: string
-  camera_info: CameraState | null
-  recording: string
-  model_3d_info: Model3DInfo
-}
-
-const load3dSceneDirty = new WeakMap<LGraphNode, boolean>()
-const load3dOutputCache = new WeakMap<LGraphNode, Load3dCachedOutput>()
-
-export const markLoad3dSceneDirty = (node: LGraphNode | null): void => {
-  if (!node) return
-  load3dSceneDirty.set(node, true)
-}
-
-export const isLoad3dSceneDirty = (node: LGraphNode): boolean =>
-  load3dSceneDirty.get(node) !== false
-
-export const getLoad3dOutputCache = (
-  node: LGraphNode
-): Load3dCachedOutput | undefined => load3dOutputCache.get(node)
-
-export const setLoad3dOutputCache = (
-  node: LGraphNode,
-  output: Load3dCachedOutput
-): void => {
-  load3dOutputCache.set(node, output)
-  load3dSceneDirty.set(node, false)
-}
 const pendingCallbacks = new Map<LGraphNode, Load3dReadyCallback[]>()
 const persistentReadyCallbacks = new Map<LGraphNode, Load3dReadyCallback[]>()
 
@@ -102,11 +69,6 @@ export const useLoad3d = (nodeOrRef: MaybeRef<LGraphNode | null>) => {
   let load3d: Load3d | null = null
   let isFirstModelLoad = true
 
-  const markDirty = () => {
-    const rawNode = toRaw(nodeRef.value)
-    if (rawNode) markLoad3dSceneDirty(rawNode as LGraphNode)
-  }
-
   const debouncedHandleResize = useDebounceFn(() => {
     load3d?.handleResize()
   }, 150)
@@ -409,7 +371,6 @@ export const useLoad3d = (nodeOrRef: MaybeRef<LGraphNode | null>) => {
     if (n) {
       n.properties['Light Config'] = lightConfig.value
     }
-    markDirty()
   }
 
   const waitForLoad3d = (callback: Load3dReadyCallback) => {
@@ -454,7 +415,6 @@ export const useLoad3d = (nodeOrRef: MaybeRef<LGraphNode | null>) => {
       if (nodeRef.value) {
         nodeRef.value.properties['Scene Config'] = newValue
       }
-      markDirty()
     },
     { deep: true }
   )
@@ -495,7 +455,6 @@ export const useLoad3d = (nodeOrRef: MaybeRef<LGraphNode | null>) => {
       if (nodeRef.value) {
         nodeRef.value.properties['Model Config'] = newValue
       }
-      markDirty()
     },
     { deep: true }
   )
@@ -529,7 +488,6 @@ export const useLoad3d = (nodeOrRef: MaybeRef<LGraphNode | null>) => {
         load3d.toggleCamera(newValue.cameraType)
         load3d.setFOV(newValue.fov)
       }
-      markDirty()
     },
     { deep: true }
   )
@@ -589,21 +547,18 @@ export const useLoad3d = (nodeOrRef: MaybeRef<LGraphNode | null>) => {
     if (load3d) {
       load3d.toggleAnimation(newValue)
     }
-    markDirty()
   })
 
   watch(selectedSpeed, (newValue) => {
     if (load3d && newValue) {
       load3d.setAnimationSpeed(newValue)
     }
-    markDirty()
   })
 
   watch(selectedAnimation, (newValue) => {
     if (load3d && newValue !== undefined) {
       load3d.updateSelectedAnimation(newValue)
     }
-    markDirty()
   })
 
   const handleMouseEnter = () => {
@@ -618,7 +573,6 @@ export const useLoad3d = (nodeOrRef: MaybeRef<LGraphNode | null>) => {
     if (load3d) {
       await load3d.startRecording()
       isRecording.value = true
-      markDirty()
     }
   }
 
@@ -628,7 +582,6 @@ export const useLoad3d = (nodeOrRef: MaybeRef<LGraphNode | null>) => {
       isRecording.value = false
       recordingDuration.value = load3d.getRecordingDuration()
       hasRecording.value = recordingDuration.value > 0
-      if (hasRecording.value) markDirty()
     }
   }
 
@@ -645,7 +598,6 @@ export const useLoad3d = (nodeOrRef: MaybeRef<LGraphNode | null>) => {
       load3d.clearRecording()
       hasRecording.value = false
       recordingDuration.value = 0
-      markDirty()
     }
   }
 
@@ -653,7 +605,6 @@ export const useLoad3d = (nodeOrRef: MaybeRef<LGraphNode | null>) => {
     if (load3d && animationDuration.value > 0) {
       const time = (progress / 100) * animationDuration.value
       load3d.setAnimationTime(time)
-      markDirty()
     }
   }
 
@@ -985,7 +936,6 @@ export const useLoad3d = (nodeOrRef: MaybeRef<LGraphNode | null>) => {
             state: cameraState
           }
         }
-        markLoad3dSceneDirty(node)
       }
     },
     gizmoTransformChange: (data: GizmoConfig) => {
@@ -1026,9 +976,7 @@ export const useLoad3d = (nodeOrRef: MaybeRef<LGraphNode | null>) => {
   }
 
   const handleCenterCameraOnModel = () => {
-    if (!load3d) return
-    load3d.centerCameraOnModel()
-    markDirty()
+    load3d?.centerCameraOnModel()
   }
 
   const handleResetGizmoTransform = () => {

src/composables/useTransformCompatOverlayProps.ts

@@ -0,0 +1,55 @@
+import type { HintedString } from '@primevue/core'
+import type { InjectionKey } from 'vue'
+import { computed, inject } from 'vue'
+
+/**
+ * Options for configuring transform-compatible overlay props
+ */
+interface TransformCompatOverlayOptions {
+  /**
+   * Where to append the overlay. 'self' keeps overlay within component
+   * for proper transform inheritance, 'body' teleports to document body
+   */
+  appendTo?: HintedString<'body' | 'self'> | undefined | HTMLElement
+  // Future: other props needed for transform compatibility
+  // scrollTarget?: string | HTMLElement
+  // autoZIndex?: boolean
+}
+
+export const OverlayAppendToKey: InjectionKey<
+  HintedString<'body' | 'self'> | undefined | HTMLElement
+> = Symbol('OverlayAppendTo')
+
+/**
+ * Composable that provides props to make PrimeVue overlay components
+ * compatible with CSS-transformed parent elements.
+ *
+ * Vue nodes use CSS transforms for positioning/scaling. PrimeVue overlay
+ * components (Select, MultiSelect, TreeSelect, etc.) teleport to document
+ * body by default, breaking transform inheritance. This composable provides
+ * the necessary props to keep overlays within their component elements.
+ *
+ * @param overrides - Optional overrides for specific use cases
+ * @returns Computed props object to spread on PrimeVue overlay components
+ *
+ * @example
+ * ```vue
+ * <template>
+ *   <Select v-bind="overlayProps" />
+ * </template>
+ *
+ * <script setup>
+ * const overlayProps = useTransformCompatOverlayProps()
+ * </script>
+ * ```
+ */
+export function useTransformCompatOverlayProps(
+  overrides: TransformCompatOverlayOptions = {}
+) {
+  const injectedAppendTo = inject(OverlayAppendToKey, undefined)
+
+  return computed(() => ({
+    appendTo: injectedAppendTo ?? ('self' as const),
+    ...overrides
+  }))
+}

src/extensions/core/load3d.test.ts

@@ -38,27 +38,13 @@ vi.mock('@/services/load3dService', () => ({
   })
 }))
 
-vi.mock('@/composables/useLoad3d', () => {
-  const sceneDirty = new WeakMap<LGraphNode, boolean>()
-  const outputCache = new WeakMap<LGraphNode, unknown>()
-  return {
-    useLoad3d: () => ({
-      waitForLoad3d: waitForLoad3dMock,
-      onLoad3dReady: onLoad3dReadyMock
-    }),
-    nodeToLoad3dMap,
-    markLoad3dSceneDirty: (node: LGraphNode | null) => {
-      if (!node) return
-      sceneDirty.set(node, true)
-    },
-    isLoad3dSceneDirty: (node: LGraphNode) => sceneDirty.get(node) !== false,
-    getLoad3dOutputCache: (node: LGraphNode) => outputCache.get(node),
-    setLoad3dOutputCache: (node: LGraphNode, value: unknown) => {
-      outputCache.set(node, value)
-      sceneDirty.set(node, false)
-    }
-  }
-})
+vi.mock('@/composables/useLoad3d', () => ({
+  useLoad3d: () => ({
+    waitForLoad3d: waitForLoad3dMock,
+    onLoad3dReady: onLoad3dReadyMock
+  }),
+  nodeToLoad3dMap
+}))
 
 vi.mock('@/extensions/core/load3d/Load3DConfiguration', () => ({
   default: class {
@@ -187,7 +173,7 @@ function makePreview3DAdvancedNode(
     constructor: { comfyClass: overrides.comfyClass ?? 'Preview3DAdvanced' },
     size: [400, 550],
     setSize: vi.fn(),
-    widgets: overrides.widgets ?? [{ name: 'viewport_state', value: '' }],
+    widgets: overrides.widgets ?? [{ name: 'image', value: '' }],
     properties: overrides.properties ?? {}
   } as unknown as LGraphNode
 }
@@ -496,16 +482,13 @@ describe('Comfy.Load3D.nodeCreated', () => {
 
     await load3DExt.nodeCreated(node)
 
-    expect(configureMock).toHaveBeenCalledWith(
-      expect.objectContaining({
-        loadFolder: 'input',
-        modelWidget: widgets[0],
-        cameraState: undefined,
-        width: widgets[1],
-        height: widgets[2],
-        onSceneInvalidated: expect.any(Function)
-      })
-    )
+    expect(configureMock).toHaveBeenCalledWith({
+      loadFolder: 'input',
+      modelWidget: widgets[0],
+      cameraState: undefined,
+      width: widgets[1],
+      height: widgets[2]
+    })
   })
 
   it('attaches a serializeValue function to the scene widget', async () => {
@@ -800,9 +783,9 @@ describe('Comfy.Preview3DAdvanced.nodeCreated', () => {
     expect(load3dInstance.setCameraState).not.toHaveBeenCalled()
   })
 
-  it('attaches a camera-only serializeValue to the viewport_state widget', async () => {
+  it('attaches a camera-only serializeValue to the image widget', async () => {
     const { preview3DAdvancedExt } = await loadExtensionsFresh()
-    const widgets: FakeWidget[] = [{ name: 'viewport_state', value: '' }]
+    const widgets: FakeWidget[] = [{ name: 'image', value: '' }]
     const node = makePreview3DAdvancedNode({ widgets })
 
     await preview3DAdvancedExt.nodeCreated(node)
@@ -812,7 +795,7 @@ describe('Comfy.Preview3DAdvanced.nodeCreated', () => {
 
   it('serializeValue returns live camera_info plus empty media fields, omitting model_3d_info when none', async () => {
     const { preview3DAdvancedExt } = await loadExtensionsFresh()
-    const widgets: FakeWidget[] = [{ name: 'viewport_state', value: '' }]
+    const widgets: FakeWidget[] = [{ name: 'image', value: '' }]
     const node = makePreview3DAdvancedNode({ widgets })
 
     const load3d = makeLoad3dMock()
@@ -836,7 +819,7 @@ describe('Comfy.Preview3DAdvanced.nodeCreated', () => {
 
   it('serializeValue wraps a present getModelInfo result in a single-element list', async () => {
     const { preview3DAdvancedExt } = await loadExtensionsFresh()
-    const widgets: FakeWidget[] = [{ name: 'viewport_state', value: '' }]
+    const widgets: FakeWidget[] = [{ name: 'image', value: '' }]
     const node = makePreview3DAdvancedNode({ widgets })
 
     const load3d = makeLoad3dMock()
@@ -1031,95 +1014,3 @@ describe('Comfy.Preview3DAdvanced.getNodeMenuItems', () => {
     ])
   })
 })
-
-describe('Comfy.Load3D scene widget serializeValue caching', () => {
-  beforeEach(setupBaseMocks)
-
-  function makeFullFakeLoad3d() {
-    return {
-      getCurrentCameraType: vi.fn(() => 'perspective'),
-      cameraManager: { perspectiveCamera: { fov: 35 } },
-      getCameraState: vi.fn(() => ({ position: { x: 0, y: 0, z: 0 } })),
-      stopRecording: vi.fn(),
-      captureScene: vi.fn(async () => ({
-        scene: 'scene-data',
-        mask: 'mask-data',
-        normal: 'normal-data'
-      })),
-      handleResize: vi.fn(),
-      getModelInfo: vi.fn(() => null),
-      getRecordingData: vi.fn(() => null)
-    }
-  }
-
-  async function setup() {
-    const { load3DExt } = await loadExtensionsFresh()
-    const useLoad3dModule = await import('@/composables/useLoad3d')
-    const utilsModule = await import('@/extensions/core/load3d/Load3dUtils')
-    const uploadTempImage = utilsModule.default.uploadTempImage as ReturnType<
-      typeof vi.fn
-    >
-    let counter = 0
-    uploadTempImage.mockImplementation(
-      async (_data: unknown, kind: string) => ({
-        name: `${kind}-${++counter}.png`
-      })
-    )
-
-    const widgets: FakeWidget[] = [
-      { name: 'model_file', value: 'm.glb' },
-      { name: 'width', value: 256 },
-      { name: 'height', value: 256 },
-      { name: 'image', value: '' }
-    ]
-    const node = makeLoad3DNode({ widgets, properties: {} })
-    useLoad3dModule.nodeToLoad3dMap.set(node, makeFullFakeLoad3d() as never)
-
-    await load3DExt.nodeCreated(node)
-    const serialize = widgets[3].serializeValue! as () => Promise<{
-      image: string
-    } | null>
-
-    return { node, serialize, uploadTempImage, useLoad3dModule }
-  }
-
-  it('reuses the cached output when the scene has not been dirtied', async () => {
-    const { node, serialize, uploadTempImage, useLoad3dModule } = await setup()
-
-    const first = await serialize()
-    expect(uploadTempImage).toHaveBeenCalledTimes(3)
-    expect(first?.image).toBe('threed/scene-1.png [temp]')
-    expect(useLoad3dModule.isLoad3dSceneDirty(node)).toBe(false)
-    expect(useLoad3dModule.getLoad3dOutputCache(node)).toBe(first)
-
-    const second = await serialize()
-    expect(uploadTempImage).toHaveBeenCalledTimes(3)
-    expect(second).toBe(first)
-  })
-
-  it('re-captures after the scene is marked dirty', async () => {
-    const { node, serialize, uploadTempImage, useLoad3dModule } = await setup()
-
-    await serialize()
-    expect(uploadTempImage).toHaveBeenCalledTimes(3)
-
-    useLoad3dModule.markLoad3dSceneDirty(node)
-
-    const refreshed = await serialize()
-    expect(uploadTempImage).toHaveBeenCalledTimes(6)
-    expect(refreshed?.image).toBe('threed/scene-4.png [temp]')
-  })
-
-  it('returns null when no load3d instance is registered for the node', async () => {
-    const { load3DExt } = await loadExtensionsFresh()
-    const widgets: FakeWidget[] = [
-      { name: 'model_file', value: 'm.glb' },
-      { name: 'width', value: 256 },
-      { name: 'height', value: 256 },
-      { name: 'image', value: '' }
-    ]
-    const node = makeLoad3DNode({ widgets })
-    await load3DExt.nodeCreated(node)
-    expect(await widgets[3].serializeValue!()).toBeNull()
-  })
-})

src/extensions/core/load3d.ts

@@ -2,15 +2,7 @@ import { nextTick } from 'vue'
 
 import Load3D from '@/components/load3d/Load3D.vue'
 import Load3DViewerContent from '@/components/load3d/Load3dViewerContent.vue'
-import {
-  type Load3dCachedOutput,
-  getLoad3dOutputCache,
-  isLoad3dSceneDirty,
-  markLoad3dSceneDirty,
-  nodeToLoad3dMap,
-  setLoad3dOutputCache,
-  useLoad3d
-} from '@/composables/useLoad3d'
+import { nodeToLoad3dMap, useLoad3d } from '@/composables/useLoad3d'
 import { createExportMenuItems } from '@/extensions/core/load3d/exportMenuHelper'
 import type {
   CameraConfig,
@@ -22,7 +14,6 @@ import {
   LOAD3D_NONE_MODEL,
   SUPPORTED_EXTENSIONS_ACCEPT
 } from '@/extensions/core/load3d/constants'
-import { snapshotLoad3dState } from '@/extensions/core/load3d/load3dSerialize'
 import Load3dUtils from '@/extensions/core/load3d/Load3dUtils'
 import { t } from '@/i18n'
 import type { LGraphNode } from '@/lib/litegraph/src/LGraphNode'
@@ -105,8 +96,6 @@ async function handleModelUpload(files: FileList, node: LGraphNode) {
 
       modelWidget.value = uploadPath
     }
-
-    markLoad3dSceneDirty(node)
   } catch (error) {
     console.error('Model upload failed:', error)
     useToastStore().addAlert(t('toastMessages.fileUploadFailed'))
@@ -124,7 +113,6 @@ async function handleResourcesUpload(files: FileList, node: LGraphNode) {
       : '3d'
 
     await Load3dUtils.uploadMultipleFiles(files, subfolder)
-    markLoad3dSceneDirty(node)
   } catch (error) {
     console.error('Extra resources upload failed:', error)
     useToastStore().addAlert(t('toastMessages.extraResourcesUploadFailed'))
@@ -282,16 +270,8 @@ useExtensionService().registerExtension({
     }
   ],
   getCustomWidgets() {
-    const VIEWPORT_STATE_NODES = new Set([
-      'Preview3DAdvanced',
-      'PreviewGaussianSplat',
-      'PreviewPointCloud'
-    ])
     return {
       LOAD_3D(node) {
-        const inputName = VIEWPORT_STATE_NODES.has(node.constructor.comfyClass)
-          ? 'viewport_state'
-          : 'image'
         const hasModelFileWidget = node.widgets?.some(
           (w) => w.name === 'model_file'
         )
@@ -331,15 +311,14 @@ useExtensionService().registerExtension({
             if (modelWidget) {
               modelWidget.value = LOAD3D_NONE_MODEL
             }
-            markLoad3dSceneDirty(node)
           })
         }
 
         const widget = new ComponentWidgetImpl({
           node: node,
-          name: inputName,
+          name: 'image',
           component: Load3D,
-          inputSpec: { ...inputSpecLoad3D, name: inputName },
+          inputSpec: inputSpecLoad3D,
           options: {}
         })
 
@@ -390,8 +369,7 @@ useExtensionService().registerExtension({
         modelWidget,
         cameraState,
         width,
-        height,
-        onSceneInvalidated: () => markLoad3dSceneDirty(node)
+        height
       })
     })
 
@@ -409,15 +387,16 @@ useExtensionService().registerExtension({
             return null
           }
 
-          if (!isLoad3dSceneDirty(node)) {
-            const cached = getLoad3dOutputCache(node)
-            if (cached) return cached
+          const cameraConfig: CameraConfig = (node.properties[
+            'Camera Config'
+          ] as CameraConfig | undefined) || {
+            cameraType: currentLoad3d.getCurrentCameraType(),
+            fov: currentLoad3d.cameraManager.perspectiveCamera.fov
           }
+          cameraConfig.state = currentLoad3d.getCameraState()
+          node.properties['Camera Config'] = cameraConfig
 
-          const { camera_info, model_3d_info } = snapshotLoad3dState(
-            node,
-            currentLoad3d
-          )
+          currentLoad3d.stopRecording()
 
           const {
             scene: imageData,
@@ -436,11 +415,16 @@ useExtensionService().registerExtension({
 
           currentLoad3d.handleResize()
 
-          const returnVal: Load3dCachedOutput = {
+          const modelInfo = currentLoad3d.getModelInfo()
+          const model_3d_info: Model3DInfo = modelInfo ? [modelInfo] : []
+
+          const returnVal = {
             image: `threed/${data.name} [temp]`,
             mask: `threed/${dataMask.name} [temp]`,
             normal: `threed/${dataNormal.name} [temp]`,
-            camera_info,
+            camera_info:
+              (node.properties['Camera Config'] as CameraConfig | undefined)
+                ?.state || null,
             recording: '',
             model_3d_info
           }
@@ -451,11 +435,9 @@ useExtensionService().registerExtension({
             const [recording] = await Promise.all([
               Load3dUtils.uploadTempImage(recordingData, 'recording', 'mp4')
             ])
-            returnVal.recording = `threed/${recording.name} [temp]`
+            returnVal['recording'] = `threed/${recording.name} [temp]`
           }
 
-          setLoad3dOutputCache(node, returnVal)
-
           return returnVal
         }
       }
@@ -733,7 +715,7 @@ useExtensionService().registerExtension({
     })
 
     useLoad3d(node).waitForLoad3d((load3d) => {
-      const sceneWidget = node.widgets?.find((w) => w.name === 'viewport_state')
+      const sceneWidget = node.widgets?.find((w) => w.name === 'image')
       if (!sceneWidget) return
 
       const resolveLoad3d = () => nodeToLoad3dMap.get(node) ?? load3d

src/extensions/core/load3d/Load3DConfiguration.test.ts

@@ -682,138 +682,3 @@ describe('Load3DConfiguration "none" model handling', () => {
     })
   })
 })
-
-describe('Load3DConfiguration.onSceneInvalidated', () => {
-  function makeLoad3dMock(): Load3d {
-    return {
-      loadModel: vi.fn().mockResolvedValue(undefined),
-      clearModel: vi.fn(),
-      setUpDirection: vi.fn(),
-      setMaterialMode: vi.fn(),
-      setTargetSize: vi.fn(),
-      setCameraState: vi.fn(),
-      toggleGrid: vi.fn(),
-      setBackgroundColor: vi.fn(),
-      setBackgroundImage: vi.fn().mockResolvedValue(undefined),
-      setBackgroundRenderMode: vi.fn(),
-      toggleCamera: vi.fn(),
-      setFOV: vi.fn(),
-      setLightIntensity: vi.fn(),
-      setHDRIIntensity: vi.fn(),
-      setHDRIAsBackground: vi.fn(),
-      setHDRIEnabled: vi.fn(),
-      emitModelReady: vi.fn()
-    } as unknown as Load3d
-  }
-
-  async function flush() {
-    await new Promise<void>((resolve) => setTimeout(resolve, 0))
-  }
-
-  beforeEach(() => {
-    vi.mocked(Load3dUtils.splitFilePath).mockReturnValue(['', 'model.glb'])
-    vi.mocked(Load3dUtils.getResourceURL).mockReturnValue('/view')
-  })
-
-  it('width.callback invokes onSceneInvalidated', async () => {
-    const onSceneInvalidated = vi.fn()
-    const width = { value: 1024 } as unknown as IBaseWidget
-    const height = { value: 1024 } as unknown as IBaseWidget
-    const config = new Load3DConfiguration(makeLoad3dMock())
-
-    config.configure({
-      modelWidget: { value: 'none' } as unknown as IBaseWidget,
-      loadFolder: 'input',
-      width,
-      height,
-      onSceneInvalidated
-    })
-    await flush()
-
-    width.callback!(2048)
-
-    expect(onSceneInvalidated).toHaveBeenCalledTimes(1)
-  })
-
-  it('height.callback invokes onSceneInvalidated', async () => {
-    const onSceneInvalidated = vi.fn()
-    const width = { value: 1024 } as unknown as IBaseWidget
-    const height = { value: 1024 } as unknown as IBaseWidget
-    const config = new Load3DConfiguration(makeLoad3dMock())
-
-    config.configure({
-      modelWidget: { value: 'none' } as unknown as IBaseWidget,
-      loadFolder: 'input',
-      width,
-      height,
-      onSceneInvalidated
-    })
-    await flush()
-
-    height.callback!(2048)
-
-    expect(onSceneInvalidated).toHaveBeenCalledTimes(1)
-  })
-
-  it('model_file widget callback invokes onSceneInvalidated after the model loads', async () => {
-    const onSceneInvalidated = vi.fn()
-    const modelWidget = { value: 'none' } as unknown as IBaseWidget
-    const config = new Load3DConfiguration(makeLoad3dMock())
-
-    config.configure({
-      modelWidget,
-      loadFolder: 'input',
-      onSceneInvalidated
-    })
-    await flush()
-
-    modelWidget.value = 'model.glb'
-    await flush()
-
-    expect(onSceneInvalidated).toHaveBeenCalled()
-  })
-
-  it('preserves any pre-existing model widget callback alongside the invalidation hook', async () => {
-    const onSceneInvalidated = vi.fn()
-    const original = vi.fn()
-    const modelWidget = {
-      value: 'none',
-      callback: original
-    } as unknown as IBaseWidget
-    const config = new Load3DConfiguration(makeLoad3dMock())
-
-    config.configure({
-      modelWidget,
-      loadFolder: 'input',
-      onSceneInvalidated
-    })
-    await flush()
-
-    modelWidget.value = 'model.glb'
-    await flush()
-
-    expect(original).toHaveBeenCalledWith('model.glb')
-    expect(onSceneInvalidated).toHaveBeenCalled()
-  })
-
-  it('callbacks remain safe when onSceneInvalidated is omitted', async () => {
-    const width = { value: 1024 } as unknown as IBaseWidget
-    const height = { value: 1024 } as unknown as IBaseWidget
-    const modelWidget = { value: 'none' } as unknown as IBaseWidget
-    const config = new Load3DConfiguration(makeLoad3dMock())
-
-    config.configure({
-      modelWidget,
-      loadFolder: 'input',
-      width,
-      height
-    })
-    await flush()
-
-    expect(() => width.callback!(2048)).not.toThrow()
-    expect(() => height.callback!(2048)).not.toThrow()
-    expect(() => {
-      modelWidget.value = 'model.glb'
-    }).not.toThrow()
-  })
-})

src/extensions/core/load3d/Load3DConfiguration.ts

@@ -23,14 +23,6 @@ type Load3DConfigurationSettings = {
   height?: IBaseWidget
   bgImagePath?: string
   silentOnNotFound?: boolean
-  /**
-   * Called when a user-driven change to one of the wired widgets
-   * (model_file, width, height) makes the previously captured scene stale.
-   * Backend caching covers these inputs by themselves; this hook lets the
-   * caller invalidate any frontend-side capture cache so the next serialize
-   * re-renders at the new state.
-   */
-  onSceneInvalidated?: () => void
 }
 
 const ANNOTATED_FILENAME_PATTERN = / \[(input|output|temp)\]$/
@@ -71,33 +63,22 @@ class Load3DConfiguration {
       setting.modelWidget,
       setting.loadFolder,
       setting.cameraState,
-      setting.silentOnNotFound ?? false,
-      setting.onSceneInvalidated
-    )
-    this.setupTargetSize(
-      setting.width,
-      setting.height,
-      setting.onSceneInvalidated
+      setting.silentOnNotFound ?? false
     )
+    this.setupTargetSize(setting.width, setting.height)
     this.setupDefaultProperties(setting.bgImagePath)
   }
 
-  private setupTargetSize(
-    width?: IBaseWidget,
-    height?: IBaseWidget,
-    onSceneInvalidated?: () => void
-  ) {
+  private setupTargetSize(width?: IBaseWidget, height?: IBaseWidget) {
     if (width && height) {
       this.load3d.setTargetSize(width.value as number, height.value as number)
 
       width.callback = (value: number) => {
         this.load3d.setTargetSize(value, height.value as number)
-        onSceneInvalidated?.()
       }
 
       height.callback = (value: number) => {
         this.load3d.setTargetSize(width.value as number, value)
-        onSceneInvalidated?.()
       }
     }
   }
@@ -122,8 +103,7 @@ class Load3DConfiguration {
     modelWidget: IBaseWidget,
     loadFolder: string,
     cameraState?: CameraState,
-    silentOnNotFound: boolean = false,
-    onSceneInvalidated?: () => void
+    silentOnNotFound: boolean = false
   ) {
     const onModelWidgetUpdate = this.createModelUpdateHandler(
       loadFolder,
@@ -157,8 +137,6 @@ class Load3DConfiguration {
       if (originalCallback) {
         originalCallback(value)
       }
-
-      onSceneInvalidated?.()
     }
   }
 

src/extensions/core/load3d/MeshModelAdapter.test.ts

@@ -23,7 +23,6 @@ const mtlLoaderStub = {
 const objLoaderStub = {
   setWorkerUrl: vi.fn(),
   setMaterials: vi.fn(),
-  setBaseObject3d: vi.fn(),
   loadAsync: vi.fn<(url: string) => Promise<THREE.Object3D>>()
 }
 
@@ -59,7 +58,6 @@ vi.mock('wwobjloader2', () => ({
   OBJLoader2Parallel: class {
     setWorkerUrl = objLoaderStub.setWorkerUrl
     setMaterials = objLoaderStub.setMaterials
-    setBaseObject3d = objLoaderStub.setBaseObject3d
     loadAsync = objLoaderStub.loadAsync
   },
   MtlObjBridge: {
@@ -249,24 +247,6 @@ describe('MeshModelAdapter', () => {
 
       expect(ctx.registerOriginalMaterial).toHaveBeenCalledTimes(1)
     })
-
-    it('resets baseObject3d on every load so meshes do not accumulate across calls', async () => {
-      objLoaderStub.loadAsync.mockResolvedValue(makeFbxLikeGroup())
-
-      const adapter = new MeshModelAdapter()
-      const ctx = makeContext('wireframe')
-      await adapter.load(ctx, '/api/view/', 'first.obj')
-      await adapter.load(ctx, '/api/view/', 'second.obj')
-
-      expect(objLoaderStub.setBaseObject3d).toHaveBeenCalledTimes(2)
-      const bases = objLoaderStub.setBaseObject3d.mock.calls.map(
-        ([base]) => base
-      )
-      expect(bases[0]).toBeInstanceOf(THREE.Object3D)
-      expect(bases[1]).toBeInstanceOf(THREE.Object3D)
-      // Each call should hand the loader a fresh container, not the same one.
-      expect(bases[0]).not.toBe(bases[1])
-    })
   })
 
   describe('GLTF loader path', () => {

src/extensions/core/load3d/MeshModelAdapter.ts

@@ -102,8 +102,6 @@ export class MeshModelAdapter implements ModelAdapter {
     path: string,
     filename: string
   ): Promise<THREE.Object3D> {
-    this.objLoader.setBaseObject3d(new THREE.Object3D())
-
     if (ctx.materialMode === 'original') {
       try {
         this.mtlLoader.setPath(path)

src/extensions/core/load3d/load3dSerialize.test.ts

@@ -1,87 +0,0 @@
-import { describe, expect, it, vi } from 'vitest'
-
-import type Load3d from '@/extensions/core/load3d/Load3d'
-import { snapshotLoad3dState } from '@/extensions/core/load3d/load3dSerialize'
-import type { CameraState } from '@/extensions/core/load3d/interfaces'
-import type { LGraphNode } from '@/lib/litegraph/src/LGraphNode'
-
-function makeNode(props: Record<string, unknown> = {}): LGraphNode {
-  return { properties: { ...props } } as unknown as LGraphNode
-}
-
-const baseCameraState: CameraState = {
-  position: { x: 1, y: 2, z: 3 },
-  target: { x: 0, y: 0, z: 0 },
-  zoom: 1,
-  cameraType: 'perspective'
-} as unknown as CameraState
-
-function makeLoad3d({
-  cameraType = 'perspective',
-  fov = 35,
-  modelInfo = { transform: { position: [0, 0, 0] } } as unknown
-}: {
-  cameraType?: string
-  fov?: number
-  modelInfo?: unknown
-} = {}) {
-  return {
-    getCurrentCameraType: vi.fn(() => cameraType),
-    cameraManager: { perspectiveCamera: { fov } },
-    getCameraState: vi.fn(() => baseCameraState),
-    stopRecording: vi.fn(),
-    getModelInfo: vi.fn(() => modelInfo)
-  } as unknown as Load3d
-}
-
-describe('snapshotLoad3dState', () => {
-  it('returns only camera_info and model_3d_info', () => {
-    const result = snapshotLoad3dState(makeNode(), makeLoad3d())
-    expect(Object.keys(result).sort()).toEqual(['camera_info', 'model_3d_info'])
-  })
-
-  it('writes the camera state into properties["Camera Config"]', () => {
-    const node = makeNode()
-    snapshotLoad3dState(node, makeLoad3d({ fov: 42 }))
-    const cfg = node.properties['Camera Config'] as Record<string, unknown>
-    expect(cfg).toMatchObject({
-      cameraType: 'perspective',
-      fov: 42,
-      state: baseCameraState
-    })
-  })
-
-  it('preserves an existing Camera Config object instead of replacing it', () => {
-    const existing = { cameraType: 'orthographic', fov: 99 }
-    const node = makeNode({ 'Camera Config': existing })
-    snapshotLoad3dState(node, makeLoad3d())
-    // Same object reference (mutated in place), with state attached.
-    expect(node.properties['Camera Config']).toBe(existing)
-    expect(
-      (node.properties['Camera Config'] as Record<string, unknown>).state
-    ).toBe(baseCameraState)
-  })
-
-  it('stops in-progress recording as a side effect', () => {
-    const load3d = makeLoad3d()
-    snapshotLoad3dState(makeNode(), load3d)
-    expect(load3d.stopRecording).toHaveBeenCalledOnce()
-  })
-
-  it('returns model_3d_info as a single-element list when a model is loaded', () => {
-    const info = { transform: { position: [1, 2, 3] } }
-    const result = snapshotLoad3dState(
-      makeNode(),
-      makeLoad3d({ modelInfo: info })
-    )
-    expect(result.model_3d_info).toEqual([info])
-  })
-
-  it('returns an empty model_3d_info list when no model is loaded', () => {
-    const result = snapshotLoad3dState(
-      makeNode(),
-      makeLoad3d({ modelInfo: null })
-    )
-    expect(result.model_3d_info).toEqual([])
-  })
-})

src/extensions/core/load3d/load3dSerialize.ts

@@ -1,36 +0,0 @@
-import type Load3d from '@/extensions/core/load3d/Load3d'
-import type {
-  CameraConfig,
-  CameraState,
-  Model3DInfo
-} from '@/extensions/core/load3d/interfaces'
-import type { LGraphNode } from '@/lib/litegraph/src/LGraphNode'
-
-export type Load3dSerializedBase = {
-  camera_info: CameraState | null
-  model_3d_info: Model3DInfo
-}
-
-export function snapshotLoad3dState(
-  node: LGraphNode,
-  load3d: Load3d
-): Load3dSerializedBase {
-  const cameraConfig: CameraConfig = (node.properties['Camera Config'] as
-    | CameraConfig
-    | undefined) || {
-    cameraType: load3d.getCurrentCameraType(),
-    fov: load3d.cameraManager.perspectiveCamera.fov
-  }
-  cameraConfig.state = load3d.getCameraState()
-  node.properties['Camera Config'] = cameraConfig
-
-  load3d.stopRecording()
-
-  const modelInfo = load3d.getModelInfo()
-  const model_3d_info: Model3DInfo = modelInfo ? [modelInfo] : []
-
-  return {
-    camera_info: cameraConfig.state ?? null,
-    model_3d_info
-  }
-}

src/extensions/core/load3d/nodeTypes.ts

@@ -9,12 +9,7 @@ const LOAD3D_PREVIEW_NODES = new Set([
   'PreviewPointCloud'
 ])
 
-const LOAD3D_ALL_NODES = new Set([
-  ...LOAD3D_PREVIEW_NODES,
-  'Load3D',
-  'Load3DAdvanced',
-  'SaveGLB'
-])
+const LOAD3D_ALL_NODES = new Set([...LOAD3D_PREVIEW_NODES, 'Load3D', 'SaveGLB'])
 
 export const isLoad3dPreviewNode = (nodeType: string): boolean =>
   LOAD3D_PREVIEW_NODES.has(nodeType)

src/extensions/core/load3dAdvanced.ts

@@ -1,103 +0,0 @@
-import { nextTick } from 'vue'
-
-import Load3DAdvanced from '@/components/load3d/Load3DAdvanced.vue'
-import { nodeToLoad3dMap, useLoad3d } from '@/composables/useLoad3d'
-import { createExportMenuItems } from '@/extensions/core/load3d/exportMenuHelper'
-import type { CameraConfig } from '@/extensions/core/load3d/interfaces'
-import Load3DConfiguration from '@/extensions/core/load3d/Load3DConfiguration'
-import { snapshotLoad3dState } from '@/extensions/core/load3d/load3dSerialize'
-import type { LGraphNode } from '@/lib/litegraph/src/LGraphNode'
-import type { IContextMenuValue } from '@/lib/litegraph/src/interfaces'
-import type { CustomInputSpec } from '@/schemas/nodeDef/nodeDefSchemaV2'
-import { ComponentWidgetImpl, addWidget } from '@/scripts/domWidget'
-import { useExtensionService } from '@/services/extensionService'
-import { useLoad3dService } from '@/services/load3dService'
-
-const inputSpecLoad3DAdvanced: CustomInputSpec = {
-  name: 'viewport_state',
-  type: 'LOAD_3D_ADVANCED',
-  isPreview: false
-}
-
-useExtensionService().registerExtension({
-  name: 'Comfy.Load3DAdvanced',
-
-  beforeRegisterNodeDef(_nodeType, nodeData) {
-    if (nodeData.name !== 'Load3DAdvanced') return
-    if (!nodeData.input?.required) return
-    nodeData.input.required.viewport_state = ['LOAD_3D_ADVANCED', {}]
-  },
-
-  getNodeMenuItems(node: LGraphNode): (IContextMenuValue | null)[] {
-    if (node.constructor.comfyClass !== 'Load3DAdvanced') return []
-
-    const load3d = useLoad3dService().getLoad3d(node)
-    if (!load3d) return []
-
-    return createExportMenuItems(load3d)
-  },
-
-  getCustomWidgets() {
-    return {
-      LOAD_3D_ADVANCED(node) {
-        const widget = new ComponentWidgetImpl({
-          node,
-          name: 'viewport_state',
-          component: Load3DAdvanced,
-          inputSpec: inputSpecLoad3DAdvanced,
-          options: {}
-        })
-
-        widget.type = 'load3DAdvanced'
-
-        addWidget(node, widget)
-
-        return { widget }
-      }
-    }
-  },
-
-  async nodeCreated(node: LGraphNode) {
-    if (node.constructor.comfyClass !== 'Load3DAdvanced') return
-
-    const [oldWidth, oldHeight] = node.size
-    node.setSize([Math.max(oldWidth, 300), Math.max(oldHeight, 600)])
-
-    await nextTick()
-
-    useLoad3d(node).onLoad3dReady((load3d) => {
-      const modelWidget = node.widgets?.find((w) => w.name === 'model_file')
-      const width = node.widgets?.find((w) => w.name === 'width')
-      const height = node.widgets?.find((w) => w.name === 'height')
-      if (!modelWidget || !width || !height) return
-
-      const cameraConfig = node.properties['Camera Config'] as
-        | CameraConfig
-        | undefined
-      const cameraState = cameraConfig?.state
-
-      const config = new Load3DConfiguration(load3d, node.properties)
-      config.configure({
-        loadFolder: 'input',
-        modelWidget,
-        cameraState,
-        width,
-        height
-      })
-    })
-
-    useLoad3d(node).waitForLoad3d(() => {
-      const sceneWidget = node.widgets?.find((w) => w.name === 'viewport_state')
-      if (!sceneWidget) return
-
-      sceneWidget.serializeValue = async () => {
-        const currentLoad3d = nodeToLoad3dMap.get(node)
-        if (!currentLoad3d) {
-          console.error('No load3d instance found for node')
-          return null
-        }
-        return snapshotLoad3dState(node, currentLoad3d)
-      }
-    })
-  }
-})

src/extensions/core/load3dLazy.ts

@@ -37,7 +37,6 @@ async function loadLoad3dExtensions(): Promise<ComfyExtension[]> {
     // Import extensions - they self-register via useExtensionService()
     await Promise.all([
       import('./load3d'),
-      import('./load3dAdvanced'),
       import('./load3dPreviewExtensions'),
       import('./saveMesh')
     ])
@@ -67,12 +66,6 @@ useExtensionService().registerExtension({
           modelFile[1].mesh_upload = true
           modelFile[1].upload_subfolder = '3d'
         }
-      } else if (nodeData.name === 'Load3DAdvanced') {
-        const modelFile = nodeData.input?.required?.model_file
-        if (modelFile?.[1]) {
-          modelFile[1].mesh_upload = true
-          modelFile[1].upload_subfolder = ''
-        }
       }
 
       // Load the 3D extensions and replay their beforeRegisterNodeDef hooks,

src/extensions/core/load3dPreviewExtensions.test.ts

@@ -186,7 +186,7 @@ describe('Comfy.PreviewGaussianSplat.nodeCreated', () => {
 
     expect(node.properties['Last Time Model File']).toBe('scene.ply')
     expect(configureForSaveMeshMock).toHaveBeenLastCalledWith(
-      'temp',
+      'output',
       'scene.ply',
       expect.objectContaining({ silentOnNotFound: true })
     )
@@ -231,7 +231,7 @@ describe('Comfy.PreviewGaussianSplat.nodeCreated', () => {
     const node = makePreviewNode({
       widgets: [
         { name: 'model_file', value: '' },
-        { name: 'viewport_state', value: '' },
+        { name: 'image', value: '' },
         widthWidget,
         heightWidget
       ]
@@ -262,7 +262,7 @@ describe('Comfy.PreviewGaussianSplat.nodeCreated', () => {
     )
     const sceneWidget: FakeWidget & {
       serializeValue?: () => Promise<unknown>
-    } = { name: 'viewport_state', value: '' }
+    } = { name: 'image', value: '' }
     const node = makePreviewNode({
       widgets: [{ name: 'model_file', value: '' }, sceneWidget]
     })
@@ -318,7 +318,7 @@ describe('Comfy.PreviewPointCloud.nodeCreated', () => {
 
     expect(node.properties['Last Time Model File']).toBe('pointcloud.ply')
     expect(configureForSaveMeshMock).toHaveBeenLastCalledWith(
-      'temp',
+      'output',
       'pointcloud.ply',
       expect.objectContaining({ silentOnNotFound: true })
     )

src/extensions/core/load3dPreviewExtensions.ts

@@ -46,7 +46,7 @@ function applyResultToLoad3d(
   }
 
   const config = new Load3DConfiguration(load3d, node.properties)
-  config.configureForSaveMesh('temp', normalizedPath, {
+  config.configureForSaveMesh('output', normalizedPath, {
     silentOnNotFound: true
   })
 
@@ -119,7 +119,7 @@ function createPreview3DExtension(
         if (!lastTimeModelFile) return
 
         const config = new Load3DConfiguration(load3d, node.properties)
-        config.configureForSaveMesh('temp', lastTimeModelFile as string, {
+        config.configureForSaveMesh('output', lastTimeModelFile as string, {
           silentOnNotFound: true
         })
 
@@ -136,9 +136,7 @@ function createPreview3DExtension(
       })
 
       waitForLoad3d((load3d) => {
-        const sceneWidget = node.widgets?.find(
-          (w) => w.name === 'viewport_state'
-        )
+        const sceneWidget = node.widgets?.find((w) => w.name === 'image')
         const widthWidget = node.widgets?.find((w) => w.name === 'width')
         const heightWidget = node.widgets?.find((w) => w.name === 'height')
 

src/locales/en/main.json

@@ -350,11 +350,6 @@
     "nodeSlotsError": "Node Slots Error",
     "nodeWidgetsError": "Node Widgets Error",
     "frameNodes": "Frame Nodes",
-    "arrange": "Arrange",
-    "arrangeVertically": "Arrange vertically",
-    "arrangeHorizontally": "Arrange horizontally",
-    "arrangeAsGrid": "Arrange as grid",
-    "arrangeSpacing": "Arrangement spacing",
     "listening": "Listening...",
     "ready": "Ready",
     "play": "Play",

src/renderer/extensions/vueNodes/widgets/components/WidgetSelectDefault.vue

@@ -60,7 +60,7 @@
         </ComboboxTrigger>
       </ComboboxAnchor>
 
-      <ComboboxPortal>
+      <ComboboxPortal :to="portalTarget" :disabled="isPortalDisabled">
         <ComboboxContent
           data-capture-wheel="true"
           data-testid="widget-select-default-overlay"
@@ -161,6 +161,7 @@ import {
 import { computed, ref } from 'vue'
 import type { CSSProperties } from 'vue'
 
+import { useTransformCompatOverlayProps } from '@/composables/useTransformCompatOverlayProps'
 import { useRestoreFocusOnViewportPointer } from '@/renderer/extensions/vueNodes/widgets/composables/useRestoreFocusOnViewportPointer'
 import type { SimplifiedWidget } from '@/types/simplifiedWidget'
 import { cn } from '@comfyorg/tailwind-utils'
@@ -241,10 +242,19 @@ const searchInputContainerRef = ref<HTMLElement>()
 const { handleFocusOutside, handleViewportPointerDown } =
   useRestoreFocusOnViewportPointer(focusSearchInput)
 
+const transformCompatProps = useTransformCompatOverlayProps()
+
 const widgetOptions = computed(
   () => widget.options as SelectWidgetOptions | undefined
 )
 
+const portalTarget = computed(() => {
+  const appendTo = transformCompatProps.value.appendTo
+  return appendTo === 'self' ? undefined : appendTo
+})
+
+const isPortalDisabled = computed(() => !portalTarget.value)
+
 const disabled = computed(() => Boolean(widgetOptions.value?.disabled))
 const placeholder = computed(() => widgetOptions.value?.placeholder ?? '')
 const filterPlaceholder = computed(

src/renderer/extensions/vueNodes/widgets/components/WidgetSelectDropdown.vue

@@ -2,6 +2,7 @@
 import { computed, provide, ref, toRef } from 'vue'
 import { useI18n } from 'vue-i18n'
 
+import { useTransformCompatOverlayProps } from '@/composables/useTransformCompatOverlayProps'
 import { SUPPORTED_EXTENSIONS_ACCEPT } from '@/extensions/core/load3d/constants'
 import { useAssetsApi } from '@/platform/assets/composables/media/useAssetsApi'
 import { useFlatOutputAssets } from '@/platform/assets/composables/media/useFlatOutputAssets'
@@ -52,9 +53,12 @@ const outputMediaAssets = isCloud
   ? useFlatOutputAssets()
   : useAssetsApi('output')
 
-const combinedProps = computed(() =>
-  filterWidgetProps(props.widget.options, PANEL_EXCLUDED_PROPS)
-)
+const transformCompatProps = useTransformCompatOverlayProps()
+
+const combinedProps = computed(() => ({
+  ...filterWidgetProps(props.widget.options, PANEL_EXCLUDED_PROPS),
+  ...transformCompatProps.value
+}))
 
 const getAssetData = () => {
   const nodeType: string | undefined =

src/renderer/extensions/vueNodes/widgets/components/WidgetTextarea.vue

@@ -22,7 +22,7 @@
       :class="
         cn(
           WidgetInputBaseClass,
-          'size-full resize-none text-(length:--comfy-textarea-font-size) leading-normal',
+          'size-full resize-none text-xs',
           !hideLayoutField && 'pt-5',
           // Avoid overflow-auto when idle to prevent per-textarea compositing layers.
           'overflow-hidden hover:overflow-auto focus:overflow-auto'

src/renderer/extensions/vueNodes/widgets/registry/widgetRegistry.ts

@@ -51,9 +51,6 @@ const AudioPreviewPlayer = defineAsyncComponent(
 const Load3D = defineAsyncComponent(
   () => import('@/components/load3d/Load3D.vue')
 )
-const Load3DAdvanced = defineAsyncComponent(
-  () => import('@/components/load3d/Load3DAdvanced.vue')
-)
 const WidgetImageCrop = defineAsyncComponent(
   () => import('@/components/imagecrop/WidgetImageCrop.vue')
 )
@@ -172,14 +169,6 @@ const coreWidgetDefinitions: Array<[string, WidgetDefinition]> = [
     }
   ],
   ['load3D', { component: Load3D, aliases: ['LOAD_3D'], essential: false }],
-  [
-    'load3DAdvanced',
-    {
-      component: Load3DAdvanced,
-      aliases: ['LOAD_3D_ADVANCED'],
-      essential: false
-    }
-  ],
   [
     'imagecrop',
     {
@@ -254,7 +243,6 @@ const EXPANDING_TYPES = [
   'textarea',
   'markdown',
   'load3D',
-  'load3DAdvanced',
   'curve',
   'painter',
   'imagecompare',