[automated] Apply ESLint and Oxfmt fixes

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

browser_tests/fixtures/selectors.ts

@@ -27,7 +27,6 @@ export const TestIds = {
     settingsContainer: 'settings-container',
     settingsTabAbout: 'settings-tab-about',
     confirm: 'confirm-dialog',
-    missingNodes: 'missing-nodes-warning',
     about: 'about-panel',
     whatsNewSection: 'whats-new-section'
   },

browser_tests/tests/dialog.spec.ts

@@ -4,71 +4,11 @@ import { expect } from '@playwright/test'
 import type { Keybinding } from '../../src/platform/keybindings/types'
 import { comfyPageFixture as test } from '../fixtures/ComfyPage'
 import { DefaultGraphPositions } from '../fixtures/constants/defaultGraphPositions'
-import { TestIds } from '../fixtures/selectors'
 
 test.beforeEach(async ({ comfyPage }) => {
   await comfyPage.settings.setSetting('Comfy.UseNewMenu', 'Disabled')
 })
 
-test.describe('Load workflow warning', { tag: '@ui' }, () => {
-  test('Should display a warning when loading a workflow with missing nodes', async ({
-    comfyPage
-  }) => {
-    await comfyPage.workflow.loadWorkflow('missing/missing_nodes')
-
-    const missingNodesWarning = comfyPage.page.getByTestId(
-      TestIds.dialogs.missingNodes
-    )
-    await expect(missingNodesWarning).toBeVisible()
-  })
-
-  test('Should display a warning when loading a workflow with missing nodes in subgraphs', async ({
-    comfyPage
-  }) => {
-    await comfyPage.workflow.loadWorkflow('missing/missing_nodes_in_subgraph')
-
-    const missingNodesWarning = comfyPage.page.getByTestId(
-      TestIds.dialogs.missingNodes
-    )
-    await expect(missingNodesWarning).toBeVisible()
-
-    // Verify the missing node text includes subgraph context
-    const warningText = await missingNodesWarning.textContent()
-    expect(warningText).toContain('MISSING_NODE_TYPE_IN_SUBGRAPH')
-    expect(warningText).toContain('in subgraph')
-  })
-})
-
-test('Does not report warning on undo/redo', async ({ comfyPage }) => {
-  await comfyPage.settings.setSetting('Comfy.NodeSearchBoxImpl', 'v1 (legacy)')
-  const missingNodesWarning = comfyPage.page.getByTestId(
-    TestIds.dialogs.missingNodes
-  )
-
-  await comfyPage.workflow.loadWorkflow('missing/missing_nodes')
-  await expect(missingNodesWarning).toBeVisible()
-  await comfyPage.page.keyboard.press('Escape')
-  await expect(missingNodesWarning).not.toBeVisible()
-
-  // Wait for any async operations to complete after dialog closes
-  await comfyPage.nextFrame()
-
-  // Make a change to the graph
-  await comfyPage.canvasOps.doubleClick()
-  await comfyPage.searchBox.fillAndSelectFirstNode('KSampler')
-
-  // Undo and redo the change
-  await comfyPage.keyboard.undo()
-  await expect(async () => {
-    await expect(missingNodesWarning).not.toBeVisible()
-  }).toPass({ timeout: 5000 })
-
-  await comfyPage.keyboard.redo()
-  await expect(async () => {
-    await expect(missingNodesWarning).not.toBeVisible()
-  }).toPass({ timeout: 5000 })
-})
-
 test.describe('Execution error', () => {
   test.beforeEach(async ({ comfyPage }) => {
     await comfyPage.settings.setSetting('Comfy.UseNewMenu', 'Top')

browser_tests/tests/nodeDisplay.spec.ts

@@ -73,10 +73,6 @@ test.describe('Optional input', { tag: ['@screenshot', '@node'] }, () => {
     await expect(comfyPage.canvas).toHaveScreenshot('simple_slider.png')
   })
   test('unknown converted widget', async ({ comfyPage }) => {
-    await comfyPage.settings.setSetting(
-      'Comfy.Workflow.ShowMissingNodesWarning',
-      false
-    )
     await comfyPage.workflow.loadWorkflow(
       'missing/missing_nodes_converted_widget'
     )

browser_tests/tests/primitiveNode.spec.ts

@@ -57,15 +57,4 @@ test.describe('Primitive Node', { tag: ['@screenshot', '@node'] }, () => {
       'static_primitive_connected.png'
     )
   })
-
-  test('Report missing nodes when connect to missing node', async ({
-    comfyPage
-  }) => {
-    await comfyPage.workflow.loadWorkflow(
-      'primitive/primitive_node_connect_missing_node'
-    )
-    // Wait for the element with the .comfy-missing-nodes selector to be visible
-    const missingNodesWarning = comfyPage.page.locator('.comfy-missing-nodes')
-    await expect(missingNodesWarning).toBeVisible()
-  })
 })

src/components/custom/widget/WorkflowTemplateSelectorDialog.vue

@@ -178,7 +178,7 @@
             v-show="isTemplateVisibleOnDistribution(template)"
             :key="template.name"
             ref="cardRefs"
-            size="compact"
+            size="tall"
             variant="ghost"
             rounded="lg"
             :data-testid="`template-workflow-${template.name}`"
@@ -318,6 +318,20 @@
                       </Button>
                     </div>
                   </div>
+                  <div class="flex">
+                    <span
+                      class="text-neutral flex items-center gap-1.5 text-xs font-bold"
+                    >
+                      <template v-if="isAppTemplate(template)">
+                        <i class="icon-[lucide--panels-top-left]" />
+                        {{ $t('builderToolbar.app', 'App') }}
+                      </template>
+                      <template v-else>
+                        <i class="icon-[lucide--workflow]" />
+                        {{ $t('builderToolbar.nodeGraph', 'Node Graph') }}
+                      </template>
+                    </span>
+                  </div>
                 </div>
               </CardBottom>
             </template>
@@ -483,6 +497,8 @@ const {
 const getEffectiveSourceModule = (template: TemplateInfo) =>
   template.sourceModule || 'default'
 
+const isAppTemplate = (template: TemplateInfo) => template.name.endsWith('.app')
+
 const getBaseThumbnailSrc = (template: TemplateInfo) => {
   const sm = getEffectiveSourceModule(template)
   return getTemplateThumbnailUrl(template, sm, sm === 'default' ? '1' : '')

src/components/dialog/content/MissingCoreNodesMessage.test.ts

@@ -1,199 +0,0 @@
-import { mount } from '@vue/test-utils'
-import PrimeVue from 'primevue/config'
-import Message from 'primevue/message'
-import { beforeEach, describe, expect, it, vi } from 'vitest'
-import { nextTick } from 'vue'
-
-import MissingCoreNodesMessage from '@/components/dialog/content/MissingCoreNodesMessage.vue'
-import type { LGraphNode } from '@/lib/litegraph/src/litegraph'
-import { useSystemStatsStore } from '@/stores/systemStatsStore'
-
-// Mock the stores
-vi.mock('@/stores/systemStatsStore', () => ({
-  useSystemStatsStore: vi.fn()
-}))
-
-const createMockNode = (type: string, version?: string): LGraphNode =>
-  // @ts-expect-error - Creating a partial mock of LGraphNode for testing purposes.
-  // We only need specific properties for our tests, not the full LGraphNode interface.
-  ({
-    type,
-    properties: { cnr_id: 'comfy-core', ver: version },
-    id: 1,
-    title: type,
-    pos: [0, 0],
-    size: [100, 100],
-    flags: {},
-    graph: null,
-    mode: 0,
-    inputs: [],
-    outputs: []
-  })
-
-describe('MissingCoreNodesMessage', () => {
-  const mockSystemStatsStore = {
-    systemStats: null as { system?: { comfyui_version?: string } } | null,
-    refetchSystemStats: vi.fn()
-  }
-
-  beforeEach(() => {
-    vi.clearAllMocks()
-    // Reset the mock store state
-    mockSystemStatsStore.systemStats = null
-    mockSystemStatsStore.refetchSystemStats = vi.fn()
-    // @ts-expect-error - Mocking the return value of useSystemStatsStore for testing.
-    // The actual store has more properties, but we only need these for our tests.
-    useSystemStatsStore.mockReturnValue(mockSystemStatsStore)
-  })
-
-  const mountComponent = (props = {}) => {
-    return mount(MissingCoreNodesMessage, {
-      global: {
-        plugins: [PrimeVue],
-        components: { Message },
-        mocks: {
-          $t: (key: string, params?: { version?: string }) => {
-            const translations: Record<string, string> = {
-              'loadWorkflowWarning.outdatedVersion': `Some nodes require a newer version of ComfyUI (current: ${params?.version}). Please update to use all nodes.`,
-              'loadWorkflowWarning.outdatedVersionGeneric':
-                'Some nodes require a newer version of ComfyUI. Please update to use all nodes.',
-              'loadWorkflowWarning.coreNodesFromVersion': `Requires ComfyUI ${params?.version}:`
-            }
-            return translations[key] || key
-          }
-        }
-      },
-      props: {
-        missingCoreNodes: {},
-        ...props
-      }
-    })
-  }
-
-  it('does not render when there are no missing core nodes', () => {
-    const wrapper = mountComponent()
-    expect(wrapper.findComponent(Message).exists()).toBe(false)
-  })
-
-  it('renders message when there are missing core nodes', async () => {
-    const missingCoreNodes = {
-      '1.2.0': [createMockNode('TestNode', '1.2.0')]
-    }
-
-    const wrapper = mountComponent({ missingCoreNodes })
-    await nextTick()
-
-    expect(wrapper.findComponent(Message).exists()).toBe(true)
-  })
-
-  it('displays current ComfyUI version when available', async () => {
-    // Set systemStats directly (store auto-fetches with useAsyncState)
-    mockSystemStatsStore.systemStats = {
-      system: { comfyui_version: '1.0.0' }
-    }
-
-    const missingCoreNodes = {
-      '1.2.0': [createMockNode('TestNode', '1.2.0')]
-    }
-
-    const wrapper = mountComponent({ missingCoreNodes })
-
-    // Wait for component to render
-    await nextTick()
-
-    // No need to check if fetchSystemStats was called since useAsyncState auto-fetches
-    expect(wrapper.text()).toContain(
-      'Some nodes require a newer version of ComfyUI (current: 1.0.0)'
-    )
-  })
-
-  it('displays generic message when version is unavailable', async () => {
-    // No systemStats set - version unavailable
-    mockSystemStatsStore.systemStats = null
-
-    const missingCoreNodes = {
-      '1.2.0': [createMockNode('TestNode', '1.2.0')]
-    }
-
-    const wrapper = mountComponent({ missingCoreNodes })
-
-    // Wait for the async operations to complete
-    await nextTick()
-    await new Promise((resolve) => setTimeout(resolve, 0))
-    await nextTick()
-
-    expect(wrapper.text()).toContain(
-      'Some nodes require a newer version of ComfyUI. Please update to use all nodes.'
-    )
-  })
-
-  it('groups nodes by version and displays them', async () => {
-    const missingCoreNodes = {
-      '1.2.0': [
-        createMockNode('NodeA', '1.2.0'),
-        createMockNode('NodeB', '1.2.0')
-      ],
-      '1.3.0': [createMockNode('NodeC', '1.3.0')]
-    }
-
-    const wrapper = mountComponent({ missingCoreNodes })
-    await nextTick()
-
-    const text = wrapper.text()
-    expect(text).toContain('Requires ComfyUI 1.3.0:')
-    expect(text).toContain('NodeC')
-    expect(text).toContain('Requires ComfyUI 1.2.0:')
-    expect(text).toContain('NodeA, NodeB')
-  })
-
-  it('sorts versions in descending order', async () => {
-    const missingCoreNodes = {
-      '1.1.0': [createMockNode('Node1', '1.1.0')],
-      '1.3.0': [createMockNode('Node3', '1.3.0')],
-      '1.2.0': [createMockNode('Node2', '1.2.0')]
-    }
-
-    const wrapper = mountComponent({ missingCoreNodes })
-    await nextTick()
-
-    const text = wrapper.text()
-    const version13Index = text.indexOf('1.3.0')
-    const version12Index = text.indexOf('1.2.0')
-    const version11Index = text.indexOf('1.1.0')
-
-    expect(version13Index).toBeLessThan(version12Index)
-    expect(version12Index).toBeLessThan(version11Index)
-  })
-
-  it('removes duplicate node names within the same version', async () => {
-    const missingCoreNodes = {
-      '1.2.0': [
-        createMockNode('DuplicateNode', '1.2.0'),
-        createMockNode('DuplicateNode', '1.2.0'),
-        createMockNode('UniqueNode', '1.2.0')
-      ]
-    }
-
-    const wrapper = mountComponent({ missingCoreNodes })
-    await nextTick()
-
-    const text = wrapper.text()
-    // Should only appear once in the sorted list
-    expect(text).toContain('DuplicateNode, UniqueNode')
-    // Count occurrences of 'DuplicateNode' - should be only 1
-    const matches = text.match(/DuplicateNode/g) || []
-    expect(matches.length).toBe(1)
-  })
-
-  it('handles nodes with missing version info', async () => {
-    const missingCoreNodes = {
-      '': [createMockNode('NoVersionNode')]
-    }
-
-    const wrapper = mountComponent({ missingCoreNodes })
-    await nextTick()
-
-    expect(wrapper.text()).toContain('Requires ComfyUI unknown:')
-    expect(wrapper.text()).toContain('NoVersionNode')
-  })
-})

src/components/dialog/content/MissingCoreNodesMessage.vue

@@ -1,83 +0,0 @@
-<template>
-  <Message
-    v-if="hasMissingCoreNodes"
-    severity="info"
-    icon="pi pi-info-circle"
-    class="m-2"
-    :pt="{
-      root: { class: 'flex-col' },
-      text: { class: 'flex-1' }
-    }"
-  >
-    <div class="flex flex-col gap-2">
-      <div>
-        {{
-          currentComfyUIVersion
-            ? $t('loadWorkflowWarning.outdatedVersion', {
-                version: currentComfyUIVersion
-              })
-            : $t('loadWorkflowWarning.outdatedVersionGeneric')
-        }}
-      </div>
-      <div
-        v-for="[version, nodes] in sortedMissingCoreNodes"
-        :key="version"
-        class="ml-4"
-      >
-        <div class="text-sm font-medium text-surface-600">
-          {{
-            $t('loadWorkflowWarning.coreNodesFromVersion', {
-              version: version || 'unknown'
-            })
-          }}
-        </div>
-        <div class="ml-4 text-sm text-surface-500">
-          {{ getUniqueNodeNames(nodes).join(', ') }}
-        </div>
-      </div>
-    </div>
-  </Message>
-</template>
-
-<script setup lang="ts">
-import Message from 'primevue/message'
-import { compare } from 'semver'
-import { computed } from 'vue'
-
-import type { LGraphNode } from '@/lib/litegraph/src/litegraph'
-import { useSystemStatsStore } from '@/stores/systemStatsStore'
-
-const { missingCoreNodes } = defineProps<{
-  missingCoreNodes: Record<string, LGraphNode[]>
-}>()
-
-const systemStatsStore = useSystemStatsStore()
-
-const hasMissingCoreNodes = computed(() => {
-  return Object.keys(missingCoreNodes).length > 0
-})
-
-// Use computed for reactive version tracking
-const currentComfyUIVersion = computed<string | null>(() => {
-  if (!hasMissingCoreNodes.value) return null
-  return systemStatsStore.systemStats?.system?.comfyui_version ?? null
-})
-
-const sortedMissingCoreNodes = computed(() => {
-  return Object.entries(missingCoreNodes).sort(([a], [b]) => {
-    // Sort by version in descending order (newest first)
-    return compare(b, a) // Reversed for descending order
-  })
-})
-
-const getUniqueNodeNames = (nodes: LGraphNode[]): string[] => {
-  return nodes
-    .reduce<string[]>((acc, node) => {
-      if (node.type && !acc.includes(node.type)) {
-        acc.push(node.type)
-      }
-      return acc
-    }, [])
-    .sort()
-}
-</script>

src/components/dialog/content/MissingNodesContent.vue

@@ -1,360 +0,0 @@
-<template>
-  <div
-    data-testid="missing-nodes-warning"
-    class="comfy-missing-nodes flex w-[490px] flex-col border-t border-border-default"
-    :class="isCloud ? 'border-b' : ''"
-  >
-    <div class="flex size-full flex-col gap-4 p-4">
-      <!-- Description -->
-      <div>
-        <p class="m-0 text-sm/5 text-muted-foreground">
-          {{
-            isCloud
-              ? $t('missingNodes.cloud.description')
-              : $t('missingNodes.oss.description')
-          }}
-        </p>
-      </div>
-
-      <MissingCoreNodesMessage v-if="!isCloud" :missing-core-nodes />
-
-      <!-- QUICK FIX AVAILABLE Section -->
-      <div v-if="replaceableNodes.length > 0" class="flex flex-col gap-2">
-        <!-- Section header with Replace button -->
-        <div class="flex items-center justify-between">
-          <div class="flex items-center gap-2">
-            <span class="text-xs font-semibold text-primary uppercase">
-              {{ $t('nodeReplacement.quickFixAvailable') }}
-            </span>
-            <div class="size-2 rounded-full bg-primary" />
-          </div>
-          <Button
-            v-tooltip.top="$t('nodeReplacement.replaceWarning')"
-            variant="primary"
-            size="md"
-            :disabled="selectedTypes.size === 0"
-            @click="handleReplaceSelected"
-          >
-            <i class="mr-1.5 icon-[lucide--refresh-cw] size-4" />
-            {{
-              $t('nodeReplacement.replaceSelected', {
-                count: selectedTypes.size
-              })
-            }}
-          </Button>
-        </div>
-
-        <!-- Replaceable nodes list -->
-        <div
-          class="flex scrollbar-custom max-h-[200px] flex-col overflow-y-auto rounded-lg bg-secondary-background"
-        >
-          <!-- Select All row (sticky header) -->
-          <div
-            :class="
-              cn(
-                'sticky top-0 z-10 flex items-center gap-3 border-b border-border-default bg-secondary-background px-3 py-2',
-                pendingNodes.length > 0
-                  ? 'cursor-pointer hover:bg-secondary-background-hover'
-                  : 'pointer-events-none opacity-50'
-              )
-            "
-            tabindex="0"
-            role="checkbox"
-            :aria-checked="
-              isAllSelected ? 'true' : isSomeSelected ? 'mixed' : 'false'
-            "
-            @click="toggleSelectAll"
-            @keydown.enter.prevent="toggleSelectAll"
-            @keydown.space.prevent="toggleSelectAll"
-          >
-            <div
-              class="flex size-4 shrink-0 items-center justify-center rounded-sm p-0.5 transition-all duration-200"
-              :class="
-                isAllSelected || isSomeSelected
-                  ? 'bg-primary-background'
-                  : 'bg-secondary-background'
-              "
-            >
-              <i
-                v-if="isAllSelected"
-                class="text-bold icon-[lucide--check] text-xs text-base-foreground"
-              />
-              <i
-                v-else-if="isSomeSelected"
-                class="text-bold icon-[lucide--minus] text-xs text-base-foreground"
-              />
-            </div>
-            <span class="text-xs font-medium text-muted-foreground uppercase">
-              {{ $t('nodeReplacement.compatibleAlternatives') }}
-            </span>
-          </div>
-
-          <!-- Replaceable node items -->
-          <div
-            v-for="node in replaceableNodes"
-            :key="node.label"
-            :class="
-              cn(
-                'flex items-center gap-3 px-3 py-2',
-                replacedTypes.has(node.label)
-                  ? 'pointer-events-none opacity-50'
-                  : 'cursor-pointer hover:bg-secondary-background-hover'
-              )
-            "
-            tabindex="0"
-            role="checkbox"
-            :aria-checked="
-              replacedTypes.has(node.label) || selectedTypes.has(node.label)
-                ? 'true'
-                : 'false'
-            "
-            @click="toggleNode(node.label)"
-            @keydown.enter.prevent="toggleNode(node.label)"
-            @keydown.space.prevent="toggleNode(node.label)"
-          >
-            <div
-              class="flex size-4 shrink-0 items-center justify-center rounded-sm p-0.5 transition-all duration-200"
-              :class="
-                replacedTypes.has(node.label) || selectedTypes.has(node.label)
-                  ? 'bg-primary-background'
-                  : 'bg-secondary-background'
-              "
-            >
-              <i
-                v-if="
-                  replacedTypes.has(node.label) || selectedTypes.has(node.label)
-                "
-                class="text-bold icon-[lucide--check] text-xs text-base-foreground"
-              />
-            </div>
-            <div class="flex flex-col gap-0.5">
-              <div class="flex items-center gap-2">
-                <span
-                  v-if="replacedTypes.has(node.label)"
-                  class="border-success bg-success/10 text-success inline-flex h-4 items-center rounded-full border px-1.5 text-xxxs font-semibold uppercase"
-                >
-                  {{ $t('nodeReplacement.replaced') }}
-                </span>
-                <span
-                  v-else
-                  class="inline-flex h-4 items-center rounded-full border border-primary bg-primary/10 px-1.5 text-xxxs font-semibold text-primary uppercase"
-                >
-                  {{ $t('nodeReplacement.replaceable') }}
-                </span>
-                <span class="text-foreground text-sm">
-                  {{ node.label }}
-                </span>
-              </div>
-              <span class="text-xs text-muted-foreground">
-                {{ node.replacement?.new_node_id ?? node.hint ?? '' }}
-              </span>
-            </div>
-          </div>
-        </div>
-      </div>
-
-      <!-- MANUAL INSTALLATION REQUIRED Section -->
-      <div
-        v-if="nonReplaceableNodes.length > 0"
-        class="flex max-h-[200px] flex-col gap-2"
-      >
-        <!-- Section header -->
-        <div class="flex items-center gap-2">
-          <span class="text-xs font-semibold text-error uppercase">
-            {{ $t('nodeReplacement.installationRequired') }}
-          </span>
-          <i class="icon-[lucide--info] text-xs text-error" />
-        </div>
-
-        <!-- Non-replaceable nodes list -->
-        <div
-          class="flex scrollbar-custom flex-col overflow-y-auto rounded-lg bg-secondary-background"
-        >
-          <div
-            v-for="node in nonReplaceableNodes"
-            :key="node.label"
-            class="flex items-center justify-between px-4 py-3"
-          >
-            <div class="flex items-center gap-3">
-              <div class="flex flex-col gap-0.5">
-                <div class="flex items-center gap-2">
-                  <span
-                    class="inline-flex h-4 items-center rounded-full border border-error bg-error/10 px-1.5 text-xxxs font-semibold text-error uppercase"
-                  >
-                    {{ $t('nodeReplacement.notReplaceable') }}
-                  </span>
-                  <span class="text-foreground text-sm">
-                    {{ node.label }}
-                  </span>
-                </div>
-                <span v-if="node.hint" class="text-xs text-muted-foreground">
-                  {{ node.hint }}
-                </span>
-              </div>
-            </div>
-            <Button
-              v-if="node.action"
-              variant="destructive-textonly"
-              size="sm"
-              @click="node.action.callback"
-            >
-              {{ node.action.text }}
-            </Button>
-          </div>
-        </div>
-      </div>
-
-      <!-- Bottom instruction box -->
-      <div
-        class="flex gap-3 rounded-lg border border-warning-background bg-warning-background/10 p-3"
-      >
-        <i
-          class="mt-0.5 icon-[lucide--triangle-alert] size-4 shrink-0 text-warning-background"
-        />
-        <p class="text-neutral-foreground m-0 text-xs/5">
-          <i18n-t keypath="nodeReplacement.instructionMessage">
-            <template #red>
-              <span class="text-error">{{
-                $t('nodeReplacement.redHighlight')
-              }}</span>
-            </template>
-          </i18n-t>
-        </p>
-      </div>
-    </div>
-  </div>
-</template>
-
-<script setup lang="ts">
-import { computed, ref } from 'vue'
-
-import MissingCoreNodesMessage from '@/components/dialog/content/MissingCoreNodesMessage.vue'
-import Button from '@/components/ui/button/Button.vue'
-import { isCloud } from '@/platform/distribution/types'
-import type { NodeReplacement } from '@/platform/nodeReplacement/types'
-import { useNodeReplacement } from '@/platform/nodeReplacement/useNodeReplacement'
-import { useDialogStore } from '@/stores/dialogStore'
-import { useExecutionErrorStore } from '@/stores/executionErrorStore'
-import type { MissingNodeType } from '@/types/comfy'
-import { cn } from '@/utils/tailwindUtil'
-import { useMissingNodes } from '@/workbench/extensions/manager/composables/nodePack/useMissingNodes'
-
-const { missingNodeTypes } = defineProps<{
-  missingNodeTypes: MissingNodeType[]
-}>()
-
-const { missingCoreNodes } = useMissingNodes()
-const { replaceNodesInPlace } = useNodeReplacement()
-const dialogStore = useDialogStore()
-const executionErrorStore = useExecutionErrorStore()
-
-interface ProcessedNode {
-  label: string
-  hint?: string
-  action?: { text: string; callback: () => void }
-  isReplaceable: boolean
-  replacement?: NodeReplacement
-}
-
-const replacedTypes = ref<Set<string>>(new Set())
-
-const uniqueNodes = computed<ProcessedNode[]>(() => {
-  const seenTypes = new Set<string>()
-  return missingNodeTypes
-    .filter((node) => {
-      const type = typeof node === 'object' ? node.type : node
-      if (seenTypes.has(type)) return false
-      seenTypes.add(type)
-      return true
-    })
-    .map((node) => {
-      if (typeof node === 'object') {
-        return {
-          label: node.type,
-          hint: node.hint,
-          action: node.action,
-          isReplaceable: node.isReplaceable ?? false,
-          replacement: node.replacement
-        }
-      }
-      return { label: node, isReplaceable: false }
-    })
-})
-
-const replaceableNodes = computed(() =>
-  uniqueNodes.value.filter((n) => n.isReplaceable)
-)
-
-const pendingNodes = computed(() =>
-  replaceableNodes.value.filter((n) => !replacedTypes.value.has(n.label))
-)
-
-const nonReplaceableNodes = computed(() =>
-  uniqueNodes.value.filter((n) => !n.isReplaceable)
-)
-
-// Selection state - all pending nodes selected by default
-const selectedTypes = ref(new Set(pendingNodes.value.map((n) => n.label)))
-
-const isAllSelected = computed(
-  () =>
-    pendingNodes.value.length > 0 &&
-    pendingNodes.value.every((n) => selectedTypes.value.has(n.label))
-)
-
-const isSomeSelected = computed(
-  () => selectedTypes.value.size > 0 && !isAllSelected.value
-)
-
-function toggleNode(label: string) {
-  if (replacedTypes.value.has(label)) return
-  const next = new Set(selectedTypes.value)
-  if (next.has(label)) {
-    next.delete(label)
-  } else {
-    next.add(label)
-  }
-  selectedTypes.value = next
-}
-
-function toggleSelectAll() {
-  if (isAllSelected.value) {
-    selectedTypes.value = new Set()
-  } else {
-    selectedTypes.value = new Set(pendingNodes.value.map((n) => n.label))
-  }
-}
-
-function handleReplaceSelected() {
-  const selected = missingNodeTypes.filter((node) => {
-    const type = typeof node === 'object' ? node.type : node
-    return selectedTypes.value.has(type)
-  })
-
-  const result = replaceNodesInPlace(selected)
-  const nextReplaced = new Set(replacedTypes.value)
-  const nextSelected = new Set(selectedTypes.value)
-  for (const type of result) {
-    nextReplaced.add(type)
-    nextSelected.delete(type)
-  }
-  replacedTypes.value = nextReplaced
-  selectedTypes.value = nextSelected
-
-  // replaceNodesInPlace() handles canvas rendering via onNodeAdded(),
-  // but the modal only updates its own local UI state above.
-  // Without this call the Errors Tab would still list the replaced nodes
-  // as missing because executionErrorStore is not aware of the replacement.
-  if (result.length > 0) {
-    executionErrorStore.removeMissingNodesByType(result)
-  }
-
-  // Auto-close when all replaceable nodes replaced and no non-replaceable remain
-  const allReplaced = replaceableNodes.value.every((n) =>
-    nextReplaced.has(n.label)
-  )
-  if (allReplaced && nonReplaceableNodes.value.length === 0) {
-    dialogStore.closeDialog({ key: 'global-missing-nodes' })
-  }
-}
-</script>

src/components/dialog/content/MissingNodesFooter.vue

@@ -1,199 +0,0 @@
-<template>
-  <div class="flex w-full flex-col gap-2 px-4 py-2">
-    <div class="flex flex-col gap-1 text-sm text-muted-foreground">
-      <div class="flex items-center gap-1">
-        <input
-          id="doNotAskAgainNodes"
-          v-model="doNotAskAgain"
-          type="checkbox"
-          class="size-4 cursor-pointer"
-        />
-        <label for="doNotAskAgainNodes">{{
-          $t('missingModelsDialog.doNotAskAgain')
-        }}</label>
-      </div>
-      <i18n-t
-        v-if="doNotAskAgain"
-        keypath="missingModelsDialog.reEnableInSettings"
-        tag="span"
-        class="ml-6 text-sm text-muted-foreground"
-      >
-        <template #link>
-          <Button
-            variant="textonly"
-            class="cursor-pointer p-0 text-sm text-muted-foreground underline hover:bg-transparent"
-            @click="openShowMissingNodesSetting"
-          >
-            {{ $t('missingModelsDialog.reEnableInSettingsLink') }}
-          </Button>
-        </template>
-      </i18n-t>
-    </div>
-
-    <!-- All nodes replaceable: Skip button (cloud + OSS) -->
-    <div v-if="!hasNonReplaceableNodes" class="flex justify-end gap-1">
-      <Button variant="secondary" size="md" @click="handleGotItClick">
-        {{ $t('nodeReplacement.skipForNow') }}
-      </Button>
-    </div>
-
-    <!-- Cloud mode: Learn More + Got It buttons -->
-    <div
-      v-else-if="isCloud"
-      class="flex w-full items-center justify-between gap-2"
-    >
-      <Button
-        variant="textonly"
-        size="sm"
-        as="a"
-        href="https://www.comfy.org/cloud"
-        target="_blank"
-        rel="noopener noreferrer"
-      >
-        <i class="icon-[lucide--info]"></i>
-        <span>{{ $t('missingNodes.cloud.learnMore') }}</span>
-      </Button>
-      <Button variant="secondary" size="md" @click="handleGotItClick">{{
-        $t('missingNodes.cloud.gotIt')
-      }}</Button>
-    </div>
-
-    <!-- OSS mode: Manager buttons -->
-    <div v-else-if="showManagerButtons" class="flex justify-end gap-1">
-      <Button variant="textonly" @click="handleOpenManager">{{
-        $t('g.openManager')
-      }}</Button>
-      <PackInstallButton
-        v-if="showInstallAllButton"
-        type="secondary"
-        size="md"
-        :disabled="
-          isLoading || !!error || missingNodePacks.length === 0 || isInstalling
-        "
-        :is-loading="isLoading"
-        :node-packs="missingNodePacks"
-        :label="
-          isLoading
-            ? $t('manager.gettingInfo')
-            : $t('manager.installAllMissingNodes')
-        "
-      />
-    </div>
-  </div>
-</template>
-
-<script setup lang="ts">
-import { computed, nextTick, ref, watch } from 'vue'
-import { useI18n } from 'vue-i18n'
-
-import Button from '@/components/ui/button/Button.vue'
-import { isCloud } from '@/platform/distribution/types'
-import { useSettingStore } from '@/platform/settings/settingStore'
-import { useToastStore } from '@/platform/updates/common/toastStore'
-import { useSettingsDialog } from '@/platform/settings/composables/useSettingsDialog'
-import { useDialogStore } from '@/stores/dialogStore'
-import type { MissingNodeType } from '@/types/comfy'
-import PackInstallButton from '@/workbench/extensions/manager/components/manager/button/PackInstallButton.vue'
-import { useMissingNodes } from '@/workbench/extensions/manager/composables/nodePack/useMissingNodes'
-import { useManagerState } from '@/workbench/extensions/manager/composables/useManagerState'
-import { useComfyManagerStore } from '@/workbench/extensions/manager/stores/comfyManagerStore'
-import { ManagerTab } from '@/workbench/extensions/manager/types/comfyManagerTypes'
-
-const { missingNodeTypes } = defineProps<{
-  missingNodeTypes?: MissingNodeType[]
-}>()
-
-const dialogStore = useDialogStore()
-const { t } = useI18n()
-
-const doNotAskAgain = ref(false)
-
-watch(doNotAskAgain, (value) => {
-  void useSettingStore().set('Comfy.Workflow.ShowMissingNodesWarning', !value)
-})
-
-const handleGotItClick = () => {
-  dialogStore.closeDialog({ key: 'global-missing-nodes' })
-}
-
-function openShowMissingNodesSetting() {
-  dialogStore.closeDialog({ key: 'global-missing-nodes' })
-  useSettingsDialog().show(undefined, 'Comfy.Workflow.ShowMissingNodesWarning')
-}
-
-const { missingNodePacks, isLoading, error } = useMissingNodes()
-const comfyManagerStore = useComfyManagerStore()
-const managerState = useManagerState()
-function handleOpenManager() {
-  managerState.openManager({
-    initialTab: ManagerTab.Missing,
-    showToastOnLegacyError: true
-  })
-}
-
-// Check if any of the missing packs are currently being installed
-const isInstalling = computed(() => {
-  if (!missingNodePacks.value?.length) return false
-  return missingNodePacks.value.some((pack) =>
-    comfyManagerStore.isPackInstalling(pack.id)
-  )
-})
-
-// Show manager buttons unless manager is disabled
-const showManagerButtons = computed(() => {
-  return managerState.shouldShowManagerButtons.value
-})
-
-// Only show Install All button for NEW_UI (new manager with v4 support)
-const showInstallAllButton = computed(() => {
-  return managerState.shouldShowInstallButton.value
-})
-
-const hasNonReplaceableNodes = computed(
-  () =>
-    missingNodeTypes?.some(
-      (n) =>
-        typeof n === 'string' || (typeof n === 'object' && !n.isReplaceable)
-    ) ?? false
-)
-
-// Track whether missingNodePacks was ever non-empty (i.e. there were packs to install)
-const hadMissingPacks = ref(false)
-
-watch(
-  missingNodePacks,
-  (packs) => {
-    if (packs && packs.length > 0) hadMissingPacks.value = true
-  },
-  { immediate: true }
-)
-
-// Only consider "all installed" when packs transitioned from non-empty to empty
-// (actual installation happened). Replaceable-only case is handled by Content auto-close.
-const allMissingNodesInstalled = computed(() => {
-  if (!hadMissingPacks.value) return false
-  return (
-    !isLoading.value &&
-    !isInstalling.value &&
-    missingNodePacks.value?.length === 0
-  )
-})
-
-// Watch for completion and close dialog (OSS mode only)
-watch(allMissingNodesInstalled, async (allInstalled) => {
-  if (!isCloud && allInstalled && showInstallAllButton.value) {
-    // Use nextTick to ensure state updates are complete
-    await nextTick()
-
-    dialogStore.closeDialog({ key: 'global-missing-nodes' })
-
-    // Show success toast
-    useToastStore().add({
-      severity: 'success',
-      summary: t('g.success'),
-      detail: t('manager.allMissingNodesInstalled'),
-      life: 3000
-    })
-  }
-})
-</script>

src/components/dialog/content/MissingNodesHeader.vue

@@ -1,18 +0,0 @@
-<template>
-  <div class="flex w-full items-center justify-between p-4">
-    <div class="flex items-center gap-2">
-      <i class="icon-[lucide--triangle-alert] text-warning-background"></i>
-      <p class="m-0 text-sm">
-        {{
-          isCloud
-            ? $t('missingNodes.cloud.title')
-            : $t('missingNodes.oss.title')
-        }}
-      </p>
-    </div>
-  </div>
-</template>
-
-<script setup lang="ts">
-import { isCloud } from '@/platform/distribution/types'
-</script>

src/components/honeyToast/HoneyToast.vue

@@ -26,15 +26,18 @@ function toggle() {
         v-if="visible"
         role="status"
         aria-live="polite"
-        class="fixed inset-x-4 bottom-6 z-9999 mx-auto w-auto max-w-3xl overflow-hidden rounded-lg border border-border-default bg-base-background shadow-lg transition-all duration-300 sm:inset-x-0 sm:w-min sm:min-w-0"
+        :class="
+          cn(
+            'fixed inset-x-4 bottom-6 z-9999 mx-auto w-auto max-w-3xl overflow-hidden rounded-lg border border-border-default bg-base-background shadow-lg transition-all duration-300 sm:inset-x-0',
+            isExpanded ? 'sm:w-[max(400px,40vw)]' : 'sm:w-fit'
+          )
+        "
       >
         <div
           :class="
             cn(
               'max-w-full min-w-0 overflow-hidden transition-all duration-300',
-              isExpanded
-                ? 'max-h-100 w-full sm:w-[max(400px,40vw)]'
-                : 'max-h-0 w-0'
+              isExpanded ? 'max-h-100 w-full' : 'max-h-0 w-0'
             )
           "
         >

src/components/input/MultiSelect.stories.ts

@@ -1,73 +1,33 @@
 import type { Meta, StoryObj } from '@storybook/vue3-vite'
-import type { MultiSelectProps } from 'primevue/multiselect'
 import { ref } from 'vue'
 
 import MultiSelect from './MultiSelect.vue'
 import type { SelectOption } from './types'
 
-// Combine our component props with PrimeVue MultiSelect props
-// Since we use v-bind="$attrs", all PrimeVue props are available
-interface ExtendedProps extends Partial<MultiSelectProps> {
-  // Our custom props
-  label?: string
-  showSearchBox?: boolean
-  showSelectedCount?: boolean
-  showClearButton?: boolean
-  searchPlaceholder?: string
-  listMaxHeight?: string
-  popoverMinWidth?: string
-  popoverMaxWidth?: string
-  // Override modelValue type to match our Option type
-  modelValue?: SelectOption[]
-}
-
-const meta: Meta<ExtendedProps> = {
-  title: 'Components/Input/MultiSelect',
+const meta: Meta<typeof MultiSelect> = {
+  title: 'Components/Select/MultiSelect',
   component: MultiSelect,
   tags: ['autodocs'],
+  parameters: { layout: 'padded' },
+  decorators: [
+    () => ({
+      template: '<div class="pt-4"><story /></div>'
+    })
+  ],
   argTypes: {
-    label: {
-      control: 'text'
+    label: { control: 'text' },
+    size: {
+      control: { type: 'select' },
+      options: ['lg', 'md']
     },
-    options: {
-      control: 'object'
-    },
-    showSearchBox: {
-      control: 'boolean',
-      description: 'Toggle searchBar visibility'
-    },
-    showSelectedCount: {
-      control: 'boolean',
-      description: 'Toggle selected count visibility'
-    },
-    showClearButton: {
-      control: 'boolean',
-      description: 'Toggle clear button visibility'
-    },
-    searchPlaceholder: {
-      control: 'text'
-    },
-    listMaxHeight: {
-      control: 'text',
-      description: 'Maximum height of the dropdown list'
-    },
-    popoverMinWidth: {
-      control: 'text',
-      description: 'Minimum width of the popover'
-    },
-    popoverMaxWidth: {
-      control: 'text',
-      description: 'Maximum width of the popover'
-    }
+    showSearchBox: { control: 'boolean' },
+    showSelectedCount: { control: 'boolean' },
+    showClearButton: { control: 'boolean' },
+    searchPlaceholder: { control: 'text' }
   },
   args: {
-    label: 'Select',
-    options: [
-      { name: 'Vue', value: 'vue' },
-      { name: 'React', value: 'react' },
-      { name: 'Angular', value: 'angular' },
-      { name: 'Svelte', value: 'svelte' }
-    ],
+    label: 'Category',
+    size: 'lg',
     showSearchBox: false,
     showSelectedCount: false,
     showClearButton: false,
@@ -78,352 +38,125 @@ const meta: Meta<ExtendedProps> = {
 export default meta
 type Story = StoryObj<typeof meta>
 
+const sampleOptions: SelectOption[] = [
+  { name: 'Vue', value: 'vue' },
+  { name: 'React', value: 'react' },
+  { name: 'Angular', value: 'angular' },
+  { name: 'Svelte', value: 'svelte' }
+]
+
 export const Default: Story = {
   render: (args) => ({
     components: { MultiSelect },
     setup() {
-      const selected = ref([])
-      const options = args.options || [
-        { name: 'Vue', value: 'vue' },
-        { name: 'React', value: 'react' },
-        { name: 'Angular', value: 'angular' },
-        { name: 'Svelte', value: 'svelte' }
-      ]
-      return { selected, options, args }
+      const selected = ref<SelectOption[]>([])
+      return { selected, sampleOptions, args }
     },
-    template: `
-      <div>
-        <MultiSelect 
-          v-model="selected" 
-          :options="options"
-          :label="args.label"
-          :showSearchBox="args.showSearchBox"
-          :showSelectedCount="args.showSelectedCount"
-          :showClearButton="args.showClearButton"
-          :searchPlaceholder="args.searchPlaceholder"
-        />
-        <div class="mt-4 p-3 bg-base-background rounded">
-          <p class="text-sm">Selected: {{ selected.length > 0 ? selected.map(s => s.name).join(', ') : 'None' }}</p>
-        </div>
-      </div>
-    `
+    template:
+      '<MultiSelect v-model="selected" :options="sampleOptions" :label="args.label" :size="args.size" :show-search-box="args.showSearchBox" :show-selected-count="args.showSelectedCount" :show-clear-button="args.showClearButton" />'
   })
 }
 
-export const WithPreselectedValues: Story = {
-  render: (args) => ({
+export const MediumSize: Story = {
+  render: () => ({
     components: { MultiSelect },
     setup() {
-      const options = args.options || [
-        { name: 'JavaScript', value: 'js' },
-        { name: 'TypeScript', value: 'ts' },
-        { name: 'Python', value: 'python' },
-        { name: 'Go', value: 'go' },
-        { name: 'Rust', value: 'rust' }
-      ]
-      const selected = ref([options[0], options[1]])
-      return { selected, options, args }
+      const selected = ref<SelectOption[]>([sampleOptions[0]])
+      return { selected, sampleOptions }
     },
-    template: `
-      <div>
-        <MultiSelect 
-          v-model="selected" 
-          :options="options"
-          :label="args.label"
-          :showSearchBox="args.showSearchBox"
-          :showSelectedCount="args.showSelectedCount"
-          :showClearButton="args.showClearButton"
-          :searchPlaceholder="args.searchPlaceholder"
-        />
-        <div class="mt-4 p-3 bg-base-background rounded">
-          <p class="text-sm">Selected: {{ selected.map(s => s.name).join(', ') }}</p>
-        </div>
-      </div>
-    `
+    template:
+      '<MultiSelect v-model="selected" :options="sampleOptions" label="Category" size="md" />'
   }),
-  args: {
-    label: 'Select Languages',
-    options: [
-      { name: 'JavaScript', value: 'js' },
-      { name: 'TypeScript', value: 'ts' },
-      { name: 'Python', value: 'python' },
-      { name: 'Go', value: 'go' },
-      { name: 'Rust', value: 'rust' }
-    ],
-    showSearchBox: false,
-    showSelectedCount: false,
-    showClearButton: false,
-    searchPlaceholder: 'Search...'
-  }
+  parameters: { controls: { disable: true } }
 }
 
-export const MultipleSelectors: Story = {
+export const WithPreselectedValues: Story = {
+  render: () => ({
+    components: { MultiSelect },
+    setup() {
+      const selected = ref<SelectOption[]>([sampleOptions[0], sampleOptions[1]])
+      return { selected, sampleOptions }
+    },
+    template:
+      '<MultiSelect v-model="selected" :options="sampleOptions" label="Category" />'
+  }),
+  parameters: { controls: { disable: true } }
+}
+
+export const Disabled: Story = {
+  render: () => ({
+    components: { MultiSelect },
+    setup() {
+      const selected = ref<SelectOption[]>([sampleOptions[0]])
+      return { selected, sampleOptions }
+    },
+    template:
+      '<MultiSelect v-model="selected" :options="sampleOptions" label="Category" disabled />'
+  }),
+  parameters: { controls: { disable: true } }
+}
+
+export const WithSearchBox: Story = {
+  args: { showSearchBox: true },
   render: (args) => ({
     components: { MultiSelect },
     setup() {
-      const frameworkOptions = ref([
-        { name: 'Vue', value: 'vue' },
-        { name: 'React', value: 'react' },
-        { name: 'Angular', value: 'angular' },
-        { name: 'Svelte', value: 'svelte' }
-      ])
+      const selected = ref<SelectOption[]>([])
+      return { selected, sampleOptions, args }
+    },
+    template:
+      '<MultiSelect v-model="selected" :options="sampleOptions" label="Category" :show-search-box="args.showSearchBox" />'
+  })
+}
 
-      const projectOptions = ref([
-        { name: 'Project A', value: 'proj-a' },
-        { name: 'Project B', value: 'proj-b' },
-        { name: 'Project C', value: 'proj-c' },
-        { name: 'Project D', value: 'proj-d' }
-      ])
+export const AllHeaderFeatures: Story = {
+  args: {
+    showSearchBox: true,
+    showSelectedCount: true,
+    showClearButton: true
+  },
+  render: (args) => ({
+    components: { MultiSelect },
+    setup() {
+      const selected = ref<SelectOption[]>([])
+      return { selected, sampleOptions, args }
+    },
+    template:
+      '<MultiSelect v-model="selected" :options="sampleOptions" label="Category" :show-search-box="args.showSearchBox" :show-selected-count="args.showSelectedCount" :show-clear-button="args.showClearButton" />'
+  })
+}
 
-      const tagOptions = ref([
-        { name: 'Frontend', value: 'frontend' },
-        { name: 'Backend', value: 'backend' },
-        { name: 'Database', value: 'database' },
-        { name: 'DevOps', value: 'devops' },
-        { name: 'Testing', value: 'testing' }
-      ])
-
-      const selectedFrameworks = ref([])
-      const selectedProjects = ref([])
-      const selectedTags = ref([])
-
-      return {
-        frameworkOptions,
-        projectOptions,
-        tagOptions,
-        selectedFrameworks,
-        selectedProjects,
-        selectedTags,
-        args
-      }
+export const AllStates: Story = {
+  render: () => ({
+    components: { MultiSelect },
+    setup() {
+      const a = ref<SelectOption[]>([])
+      const b = ref<SelectOption[]>([sampleOptions[0]])
+      const c = ref<SelectOption[]>([sampleOptions[0]])
+      return { sampleOptions, a, b, c }
     },
     template: `
-      <div class="space-y-4">
-        <div class="flex gap-2">
-          <MultiSelect 
-            v-model="selectedFrameworks" 
-            :options="frameworkOptions"
-            label="Select Frameworks"
-            :showSearchBox="args.showSearchBox"
-            :showSelectedCount="args.showSelectedCount"
-            :showClearButton="args.showClearButton"
-            :searchPlaceholder="args.searchPlaceholder"
-          />
-          <MultiSelect 
-            v-model="selectedProjects" 
-            :options="projectOptions"
-            label="Select Projects"
-            :showSearchBox="args.showSearchBox"
-            :showSelectedCount="args.showSelectedCount"
-            :showClearButton="args.showClearButton"
-            :searchPlaceholder="args.searchPlaceholder"
-          />
-          <MultiSelect 
-            v-model="selectedTags" 
-            :options="tagOptions"
-            label="Select Tags"
-            :showSearchBox="args.showSearchBox"
-            :showSelectedCount="args.showSelectedCount"
-            :showClearButton="args.showClearButton"
-            :searchPlaceholder="args.searchPlaceholder"
-          />
+      <div class="flex flex-col gap-6">
+        <div>
+          <p class="mb-2 text-xs text-muted-foreground">Large (Interface)</p>
+          <div class="flex flex-col gap-3">
+            <MultiSelect v-model="a" :options="sampleOptions" label="Default" />
+            <MultiSelect v-model="b" :options="sampleOptions" label="With Selection" />
+            <MultiSelect v-model="c" :options="sampleOptions" label="Disabled" disabled />
+          </div>
         </div>
-        
-        <div class="p-4 bg-base-background rounded">
-          <h4 class="font-medium mt-0">Current Selection:</h4>
-          <div class="flex flex-col text-sm">
-            <p>Frameworks: {{ selectedFrameworks.length > 0 ? selectedFrameworks.map(s => s.name).join(', ') : 'None' }}</p>
-            <p>Projects: {{ selectedProjects.length > 0 ? selectedProjects.map(s => s.name).join(', ') : 'None' }}</p>
-            <p>Tags: {{ selectedTags.length > 0 ? selectedTags.map(s => s.name).join(', ') : 'None' }}</p>
+        <div>
+          <p class="mb-2 text-xs text-muted-foreground">Medium (Node)</p>
+          <div class="flex flex-col gap-3">
+            <MultiSelect v-model="a" :options="sampleOptions" label="Default" size="md" />
+            <MultiSelect v-model="b" :options="sampleOptions" label="With Selection" size="md" />
+            <MultiSelect v-model="c" :options="sampleOptions" label="Disabled" size="md" disabled />
           </div>
         </div>
       </div>
     `
   }),
-  args: {
-    showSearchBox: false,
-    showSelectedCount: false,
-    showClearButton: false,
-    searchPlaceholder: 'Search...'
-  }
-}
-
-export const WithSearchBox: Story = {
-  ...Default,
-  args: {
-    ...Default.args,
-    showSearchBox: true
-  }
-}
-
-export const WithSelectedCount: Story = {
-  ...Default,
-  args: {
-    ...Default.args,
-    showSelectedCount: true
-  }
-}
-
-export const WithClearButton: Story = {
-  ...Default,
-  args: {
-    ...Default.args,
-    showClearButton: true
-  }
-}
-
-export const AllHeaderFeatures: Story = {
-  ...Default,
-  args: {
-    ...Default.args,
-    showSearchBox: true,
-    showSelectedCount: true,
-    showClearButton: true
-  }
-}
-
-export const CustomSearchPlaceholder: Story = {
-  ...Default,
-  args: {
-    ...Default.args,
-    showSearchBox: true,
-    searchPlaceholder: 'Filter packages...'
-  }
-}
-
-export const CustomMaxHeight: Story = {
-  render: () => ({
-    components: { MultiSelect },
-    setup() {
-      const selected1 = ref([])
-      const selected2 = ref([])
-      const selected3 = ref([])
-      const manyOptions = Array.from({ length: 20 }, (_, i) => ({
-        name: `Option ${i + 1}`,
-        value: `option${i + 1}`
-      }))
-      return { selected1, selected2, selected3, manyOptions }
-    },
-    template: `
-      <div class="flex gap-4">
-        <div>
-          <h3 class="text-sm font-semibold mb-2">Small Height (10rem)</h3>
-          <MultiSelect 
-            v-model="selected1" 
-            :options="manyOptions" 
-            label="Small Dropdown" 
-            list-max-height="10rem"
-            show-selected-count 
-          />
-        </div>
-        <div>
-          <h3 class="text-sm font-semibold mb-2">Default Height (28rem)</h3>
-          <MultiSelect 
-            v-model="selected2" 
-            :options="manyOptions" 
-            label="Default Dropdown"
-            list-max-height="28rem"
-            show-selected-count 
-          />
-        </div>
-        <div>
-          <h3 class="text-sm font-semibold mb-2">Large Height (32rem)</h3>
-          <MultiSelect 
-            v-model="selected3" 
-            :options="manyOptions" 
-            label="Large Dropdown" 
-            list-max-height="32rem"
-            show-selected-count 
-          />
-        </div>
-      </div>
-    `
-  }),
   parameters: {
-    controls: { disable: true },
-    actions: { disable: true },
-    slot: { disable: true }
-  }
-}
-
-export const CustomMinWidth: Story = {
-  render: () => ({
-    components: { MultiSelect },
-    setup() {
-      const selected1 = ref([])
-      const selected2 = ref([])
-      const selected3 = ref([])
-      const options = [
-        { name: 'A', value: 'a' },
-        { name: 'B', value: 'b' },
-        { name: 'Very Long Option Name Here', value: 'long' }
-      ]
-      return { selected1, selected2, selected3, options }
-    },
-    template: `
-      <div class="flex gap-4">
-        <div>
-          <h3 class="text-sm font-semibold mb-2">Auto Width</h3>
-          <MultiSelect v-model="selected1" :options="options" label="Auto" />
-        </div>
-        <div>
-          <h3 class="text-sm font-semibold mb-2">Min Width 18rem</h3>
-          <MultiSelect v-model="selected2" :options="options" label="Min 18rem" popover-min-width="18rem" />
-        </div>
-        <div>
-          <h3 class="text-sm font-semibold mb-2">Min Width 28rem</h3>
-          <MultiSelect v-model="selected3" :options="options" label="Min 28rem" popover-min-width="28rem" />
-        </div>
-      </div>
-    `
-  }),
-  parameters: {
-    controls: { disable: true },
-    actions: { disable: true },
-    slot: { disable: true }
-  }
-}
-
-export const CustomMaxWidth: Story = {
-  render: () => ({
-    components: { MultiSelect },
-    setup() {
-      const selected1 = ref([])
-      const selected2 = ref([])
-      const selected3 = ref([])
-      const longOptions = [
-        { name: 'Short', value: 'short' },
-        {
-          name: 'This is a very long option name that would normally expand the dropdown',
-          value: 'long1'
-        },
-        {
-          name: 'Another extremely long option that demonstrates max-width constraint',
-          value: 'long2'
-        }
-      ]
-      return { selected1, selected2, selected3, longOptions }
-    },
-    template: `
-      <div class="flex gap-4">
-        <div>
-          <h3 class="text-sm font-semibold mb-2">Auto Width</h3>
-          <MultiSelect v-model="selected1" :options="longOptions" label="Auto" />
-        </div>
-        <div>
-          <h3 class="text-sm font-semibold mb-2">Max Width 18rem</h3>
-          <MultiSelect v-model="selected2" :options="longOptions" label="Max 18rem" popover-max-width="18rem" />
-        </div>
-        <div>
-          <h3 class="text-sm font-semibold mb-2">Min 12rem Max 22rem</h3>
-          <MultiSelect v-model="selected3" :options="longOptions" label="Min & Max" popover-min-width="12rem" popover-max-width="22rem" />
-        </div>
-      </div>
-    `
-  }),
-  parameters: {
-    controls: { disable: true },
-    actions: { disable: true },
-    slot: { disable: true }
+    controls: { disable: true }
   }
 }

src/components/input/MultiSelect.vue

@@ -16,20 +16,23 @@
     :pt="{
       root: ({ props }: MultiSelectPassThroughMethodOptions) => ({
         class: cn(
-          'relative inline-flex h-10 cursor-pointer select-none',
+          'relative inline-flex cursor-pointer select-none',
+          size === 'md' ? 'h-8' : 'h-10',
           'rounded-lg bg-secondary-background text-base-foreground',
           'transition-all duration-200 ease-in-out',
+          'hover:bg-secondary-background-hover',
           'border-[2.5px] border-solid',
-          selectedCount > 0
-            ? 'border-node-component-border'
-            : 'border-transparent',
-          'focus-within:border-node-component-border',
-          { 'cursor-default opacity-60': props.disabled }
+          selectedCount > 0 ? 'border-base-foreground' : 'border-transparent',
+          'focus-within:border-base-foreground',
+          props.disabled &&
+            'cursor-default opacity-30 hover:bg-secondary-background'
         )
       }),
       labelContainer: {
-        class:
-          'flex-1 flex items-center overflow-hidden whitespace-nowrap pl-4 py-2 '
+        class: cn(
+          'flex flex-1 items-center overflow-hidden py-2 whitespace-nowrap',
+          size === 'md' ? 'pl-3' : 'pl-4'
+        )
       },
       label: {
         class: 'p-0'
@@ -129,12 +132,12 @@
 
     <!-- Trigger value (keep text scale identical) -->
     <template #value>
-      <span class="text-sm">
+      <span :class="size === 'md' ? 'text-xs' : 'text-sm'">
         {{ label }}
       </span>
       <span
         v-if="selectedCount > 0"
-        class="pointer-events-none absolute -top-2 -right-2 z-10 flex size-5 items-center justify-center rounded-full bg-primary-background text-xs font-semibold text-base-foreground"
+        class="pointer-events-none absolute -top-2 -right-2 z-10 flex size-5 items-center justify-center rounded-full bg-base-foreground text-xs font-semibold text-base-background"
       >
         {{ selectedCount }}
       </span>
@@ -197,6 +200,8 @@ defineOptions({
 interface Props {
   /** Input label shown on the trigger button */
   label?: string
+  /** Trigger size: 'lg' (40px, Interface) or 'md' (32px, Node) */
+  size?: 'lg' | 'md'
   /** Show search box in the panel header */
   showSearchBox?: boolean
   /** Show selected count text in the panel header */
@@ -216,6 +221,7 @@ interface Props {
 }
 const {
   label,
+  size = 'lg',
   showSearchBox = false,
   showSelectedCount = false,
   showClearButton = false,

src/components/input/SelectDropdown.stories.ts

@@ -0,0 +1,219 @@
+import type { Meta, StoryObj } from '@storybook/vue3-vite'
+import { ref } from 'vue'
+
+import MultiSelect from './MultiSelect.vue'
+import SingleSelect from './SingleSelect.vue'
+import type { SelectOption } from './types'
+
+const meta: Meta = {
+  title: 'Components/Select/SelectDropdown',
+  tags: ['autodocs'],
+  parameters: { layout: 'padded' },
+  decorators: [
+    () => ({
+      template: '<div class="pt-4"><story /></div>'
+    })
+  ]
+}
+
+export default meta
+type Story = StoryObj<typeof meta>
+
+const modelOptions: SelectOption[] = [
+  { name: 'ACE-Step', value: 'ace-step' },
+  { name: 'Anima', value: 'anima' },
+  { name: 'BRIA', value: 'bria' },
+  { name: 'ByteDance', value: 'bytedance' },
+  { name: 'Capybara', value: 'capybara' },
+  { name: 'Chatter Box', value: 'chatter-box' },
+  { name: 'Chroma', value: 'chroma' },
+  { name: 'ChronoEdit', value: 'chronoedit' },
+  { name: 'DWPose', value: 'dwpose' },
+  { name: 'Depth Anything v2', value: 'depth-anything-v2' },
+  { name: 'ElevenLabs', value: 'elevenlabs' },
+  { name: 'Flux', value: 'flux' },
+  { name: 'HunyuanVideo', value: 'hunyuan-video' },
+  { name: 'Stable Diffusion', value: 'stable-diffusion' },
+  { name: 'SDXL', value: 'sdxl' }
+]
+
+const useCaseOptions: SelectOption[] = [
+  { name: 'Text to Image', value: 'text-to-image' },
+  { name: 'Image to Image', value: 'image-to-image' },
+  { name: 'Inpainting', value: 'inpainting' },
+  { name: 'Upscaling', value: 'upscaling' },
+  { name: 'Video Generation', value: 'video-generation' },
+  { name: 'Audio Generation', value: 'audio-generation' },
+  { name: '3D Generation', value: '3d-generation' }
+]
+
+const sortOptions: SelectOption[] = [
+  { name: 'Default', value: 'default' },
+  { name: 'Recommended', value: 'recommended' },
+  { name: 'Popular', value: 'popular' },
+  { name: 'Newest', value: 'newest' },
+  { name: 'VRAM Usage (Low to High)', value: 'vram-low-to-high' },
+  { name: 'Model Size (Low to High)', value: 'model-size-low-to-high' },
+  { name: 'Alphabetical (A-Z)', value: 'alphabetical' }
+]
+
+export const ModelFilter: Story = {
+  render: () => ({
+    components: { MultiSelect },
+    setup() {
+      const selected = ref<SelectOption[]>([
+        modelOptions[1],
+        modelOptions[2],
+        modelOptions[3]
+      ])
+      return { selected, modelOptions }
+    },
+    template: `
+      <MultiSelect
+        v-model="selected"
+        :options="modelOptions"
+        :label="selected.length === 0 ? 'Models' : selected.length === 1 ? selected[0].name : selected.length + ' Models'"
+        show-search-box
+        show-selected-count
+        show-clear-button
+        class="w-[250px]"
+      >
+        <template #icon>
+          <i class="icon-[lucide--cpu]" />
+        </template>
+      </MultiSelect>
+    `
+  }),
+  parameters: { controls: { disable: true } }
+}
+
+export const UseCaseFilter: Story = {
+  render: () => ({
+    components: { MultiSelect },
+    setup() {
+      const selected = ref<SelectOption[]>([])
+      return { selected, useCaseOptions }
+    },
+    template: `
+      <MultiSelect
+        v-model="selected"
+        :options="useCaseOptions"
+        :label="selected.length === 0 ? 'Use Case' : selected.length === 1 ? selected[0].name : selected.length + ' Use Cases'"
+        show-search-box
+        show-selected-count
+        show-clear-button
+      >
+        <template #icon>
+          <i class="icon-[lucide--target]" />
+        </template>
+      </MultiSelect>
+    `
+  }),
+  parameters: { controls: { disable: true } }
+}
+
+export const SortDropdown: Story = {
+  render: () => ({
+    components: { SingleSelect },
+    setup() {
+      const selected = ref<string | undefined>('default')
+      return { selected, sortOptions }
+    },
+    template: `
+      <SingleSelect
+        v-model="selected"
+        :options="sortOptions"
+        label="Sort by"
+        class="w-62.5"
+      >
+        <template #icon>
+          <i class="icon-[lucide--arrow-up-down] text-muted-foreground" />
+        </template>
+      </SingleSelect>
+    `
+  }),
+  parameters: { controls: { disable: true } }
+}
+
+export const TemplateFilterBar: Story = {
+  render: () => ({
+    components: { MultiSelect, SingleSelect },
+    setup() {
+      const selectedModels = ref<SelectOption[]>([
+        modelOptions[1],
+        modelOptions[2],
+        modelOptions[3]
+      ])
+      const selectedUseCases = ref<SelectOption[]>([])
+      const sortBy = ref<string | undefined>('default')
+
+      const modelLabel = () => {
+        if (selectedModels.value.length === 0) return 'Models'
+        if (selectedModels.value.length === 1)
+          return selectedModels.value[0].name
+        return selectedModels.value.length + ' Models'
+      }
+      const useCaseLabel = () => {
+        if (selectedUseCases.value.length === 0) return 'Use Case'
+        if (selectedUseCases.value.length === 1)
+          return selectedUseCases.value[0].name
+        return selectedUseCases.value.length + ' Use Cases'
+      }
+
+      return {
+        selectedModels,
+        selectedUseCases,
+        sortBy,
+        modelOptions,
+        useCaseOptions,
+        sortOptions,
+        modelLabel,
+        useCaseLabel
+      }
+    },
+    template: `
+      <div class="flex flex-wrap items-center justify-between gap-2" style="min-width: 700px;">
+        <div class="flex flex-wrap gap-2">
+          <MultiSelect
+            v-model="selectedModels"
+            :options="modelOptions"
+            :label="modelLabel()"
+            show-search-box
+            show-selected-count
+            show-clear-button
+            class="w-[250px]"
+          >
+            <template #icon>
+              <i class="icon-[lucide--cpu]" />
+            </template>
+          </MultiSelect>
+
+          <MultiSelect
+            v-model="selectedUseCases"
+            :options="useCaseOptions"
+            :label="useCaseLabel()"
+            show-search-box
+            show-selected-count
+            show-clear-button
+          >
+            <template #icon>
+              <i class="icon-[lucide--target]" />
+            </template>
+          </MultiSelect>
+        </div>
+
+        <SingleSelect
+          v-model="sortBy"
+          :options="sortOptions"
+          label="Sort by"
+          class="w-62.5"
+        >
+          <template #icon>
+            <i class="icon-[lucide--arrow-up-down] text-muted-foreground" />
+          </template>
+        </SingleSelect>
+      </div>
+    `
+  }),
+  parameters: { controls: { disable: true } }
+}

src/components/input/SingleSelect.stories.ts

@@ -3,29 +3,31 @@ import { ref } from 'vue'
 
 import SingleSelect from './SingleSelect.vue'
 
-// SingleSelect already includes options prop, so no need to extend
 const meta: Meta<typeof SingleSelect> = {
-  title: 'Components/Input/SingleSelect',
+  title: 'Components/Select/SingleSelect',
   component: SingleSelect,
   tags: ['autodocs'],
+  parameters: { layout: 'padded' },
+  decorators: [
+    () => ({
+      template: '<div class="pt-4"><story /></div>'
+    })
+  ],
   argTypes: {
     label: { control: 'text' },
     options: { control: 'object' },
-    listMaxHeight: {
-      control: 'text',
-      description: 'Maximum height of the dropdown list'
+    size: {
+      control: { type: 'select' },
+      options: ['lg', 'md']
     },
-    popoverMinWidth: {
-      control: 'text',
-      description: 'Minimum width of the popover'
-    },
-    popoverMaxWidth: {
-      control: 'text',
-      description: 'Maximum width of the popover'
-    }
+    invalid: { control: 'boolean' },
+    loading: { control: 'boolean' }
   },
   args: {
-    label: 'Sorting Type',
+    label: 'Category',
+    size: 'lg',
+    invalid: false,
+    loading: false,
     options: [
       { name: 'Popular', value: 'popular' },
       { name: 'Newest', value: 'newest' },
@@ -37,7 +39,7 @@ const meta: Meta<typeof SingleSelect> = {
 }
 
 export default meta
-export type Story = StoryObj<typeof meta>
+type Story = StoryObj<typeof meta>
 
 const sampleOptions = [
   { name: 'Popular', value: 'popular' },
@@ -52,205 +54,118 @@ export const Default: Story = {
     components: { SingleSelect },
     setup() {
       const selected = ref<string | null>(null)
-      const options = args.options || sampleOptions
-      return { selected, options, args }
+      return { selected, args }
     },
-    template: `
-      <div>
-        <SingleSelect v-model="selected" :options="options" :label="args.label" />
-        <div class="mt-4 p-3 bg-base-background rounded">
-          <p class="text-sm">Selected: {{ selected ?? 'None' }}</p>
-        </div>
-      </div>
-    `
+    template:
+      '<SingleSelect v-model="selected" :options="args.options" :label="args.label" :size="args.size" :invalid="args.invalid" :loading="args.loading" />'
   })
 }
 
+export const MediumSize: Story = {
+  render: () => ({
+    components: { SingleSelect },
+    setup() {
+      const selected = ref<string | null>('popular')
+      return { selected, sampleOptions }
+    },
+    template:
+      '<SingleSelect v-model="selected" :options="sampleOptions" label="Category" size="md" />'
+  }),
+  parameters: { controls: { disable: true } }
+}
+
 export const WithIcon: Story = {
   render: () => ({
     components: { SingleSelect },
     setup() {
       const selected = ref<string | null>('popular')
-      const options = sampleOptions
-      return { selected, options }
+      return { selected, sampleOptions }
     },
     template: `
-      <div>
-        <SingleSelect v-model="selected" :options="options" label="Sorting Type">
-          <template #icon>
-            <i class="icon-[lucide--arrow-up-down] w-3.5 h-3.5" />
-          </template>
-        </SingleSelect>
-        <div class="mt-4 p-3 bg-base-background rounded">
-          <p class="text-sm">Selected: {{ selected }}</p>
-        </div>
-      </div>
+      <SingleSelect v-model="selected" :options="sampleOptions" label="Sorting Type">
+        <template #icon>
+          <i class="icon-[lucide--arrow-up-down] size-3.5" />
+        </template>
+      </SingleSelect>
     `
-  })
+  }),
+  parameters: { controls: { disable: true } }
 }
 
-export const Preselected: Story = {
+export const Disabled: Story = {
   render: () => ({
     components: { SingleSelect },
     setup() {
-      const selected = ref<string | null>('newest')
-      const options = sampleOptions
-      return { selected, options }
+      const selected = ref<string | null>('popular')
+      return { selected, sampleOptions }
     },
-    template: `
-      <SingleSelect v-model="selected" :options="options" label="Sorting Type" />
-    `
-  })
+    template:
+      '<SingleSelect v-model="selected" :options="sampleOptions" label="Category" disabled />'
+  }),
+  parameters: { controls: { disable: true } }
 }
 
-export const AllVariants: Story = {
+export const Invalid: Story = {
   render: () => ({
     components: { SingleSelect },
     setup() {
-      const options = sampleOptions
-      const a = ref<string | null>(null)
+      const selected = ref<string | null>('popular')
+      return { selected, sampleOptions }
+    },
+    template:
+      '<SingleSelect v-model="selected" :options="sampleOptions" label="Category" invalid />'
+  }),
+  parameters: { controls: { disable: true } }
+}
+
+export const Loading: Story = {
+  render: () => ({
+    components: { SingleSelect },
+    setup() {
+      const selected = ref<string | null>('popular')
+      return { selected, sampleOptions }
+    },
+    template:
+      '<SingleSelect v-model="selected" :options="sampleOptions" label="Category" loading />'
+  }),
+  parameters: { controls: { disable: true } }
+}
+
+export const AllStates: Story = {
+  render: () => ({
+    components: { SingleSelect },
+    setup() {
+      const a = ref<string | null>('popular')
       const b = ref<string | null>('popular')
-      const c = ref<string | null>('az')
-      return { options, a, b, c }
+      const c = ref<string | null>('popular')
+      const d = ref<string | null>('popular')
+      const e = ref<string | null>('popular')
+      return { sampleOptions, a, b, c, d, e }
     },
     template: `
-      <div class="flex flex-col gap-4">
-        <div class="flex items-center gap-3">
-          <SingleSelect v-model="a" :options="options" label="No Icon" />
+      <div class="flex flex-col gap-6">
+        <div>
+          <p class="mb-2 text-xs text-muted-foreground">Large (Interface)</p>
+          <div class="flex flex-col gap-3">
+            <SingleSelect v-model="a" :options="sampleOptions" label="Default" />
+            <SingleSelect v-model="b" :options="sampleOptions" label="Disabled" disabled />
+            <SingleSelect v-model="c" :options="sampleOptions" label="Invalid" invalid />
+            <SingleSelect v-model="d" :options="sampleOptions" label="Loading" loading />
+          </div>
         </div>
-        <div class="flex items-center gap-3">
-          <SingleSelect v-model="b" :options="options" label="With Icon">
-            <template #icon>
-              <i class="icon-[lucide--arrow-up-down] w-3.5 h-3.5" />
-            </template>
-          </SingleSelect>
-        </div>
-        <div class="flex items-center gap-3">
-          <SingleSelect v-model="c" :options="options" label="Preselected (A→Z)" />
+        <div>
+          <p class="mb-2 text-xs text-muted-foreground">Medium (Node)</p>
+          <div class="flex flex-col gap-3">
+            <SingleSelect v-model="a" :options="sampleOptions" label="Default" size="md" />
+            <SingleSelect v-model="b" :options="sampleOptions" label="Disabled" size="md" disabled />
+            <SingleSelect v-model="c" :options="sampleOptions" label="Invalid" size="md" invalid />
+            <SingleSelect v-model="e" :options="sampleOptions" label="Loading" size="md" loading />
+          </div>
         </div>
       </div>
     `
   }),
   parameters: {
-    controls: { disable: true },
-    actions: { disable: true },
-    slot: { disable: true }
-  }
-}
-
-export const CustomMaxHeight: Story = {
-  render: () => ({
-    components: { SingleSelect },
-    setup() {
-      const selected = ref<string | null>(null)
-      const manyOptions = Array.from({ length: 20 }, (_, i) => ({
-        name: `Option ${i + 1}`,
-        value: `option${i + 1}`
-      }))
-      return { selected, manyOptions }
-    },
-    template: `
-      <div class="flex gap-4">
-        <div>
-          <h3 class="text-sm font-semibold mb-2">Small Height (10rem)</h3>
-          <SingleSelect v-model="selected" :options="manyOptions" label="Small Dropdown" list-max-height="10rem" />
-        </div>
-        <div>
-          <h3 class="text-sm font-semibold mb-2">Default Height (28rem)</h3>
-          <SingleSelect v-model="selected" :options="manyOptions" label="Default Dropdown" />
-        </div>
-        <div>
-          <h3 class="text-sm font-semibold mb-2">Large Height (32rem)</h3>
-          <SingleSelect v-model="selected" :options="manyOptions" label="Large Dropdown" list-max-height="32rem" />
-        </div>
-      </div>
-    `
-  }),
-  parameters: {
-    controls: { disable: true },
-    actions: { disable: true },
-    slot: { disable: true }
-  }
-}
-
-export const CustomMinWidth: Story = {
-  render: () => ({
-    components: { SingleSelect },
-    setup() {
-      const selected1 = ref<string | null>(null)
-      const selected2 = ref<string | null>(null)
-      const selected3 = ref<string | null>(null)
-      const options = [
-        { name: 'A', value: 'a' },
-        { name: 'B', value: 'b' },
-        { name: 'Very Long Option Name Here', value: 'long' }
-      ]
-      return { selected1, selected2, selected3, options }
-    },
-    template: `
-      <div class="flex gap-4">
-        <div>
-          <h3 class="text-sm font-semibold mb-2">Auto Width</h3>
-          <SingleSelect v-model="selected1" :options="options" label="Auto" />
-        </div>
-        <div>
-          <h3 class="text-sm font-semibold mb-2">Min Width 15rem</h3>
-          <SingleSelect v-model="selected2" :options="options" label="Min 15rem" popover-min-width="15rem" />
-        </div>
-        <div>
-          <h3 class="text-sm font-semibold mb-2">Min Width 25rem</h3>
-          <SingleSelect v-model="selected3" :options="options" label="Min 25rem" popover-min-width="25rem" />
-        </div>
-      </div>
-    `
-  }),
-  parameters: {
-    controls: { disable: true },
-    actions: { disable: true },
-    slot: { disable: true }
-  }
-}
-
-export const CustomMaxWidth: Story = {
-  render: () => ({
-    components: { SingleSelect },
-    setup() {
-      const selected1 = ref<string | null>(null)
-      const selected2 = ref<string | null>(null)
-      const selected3 = ref<string | null>(null)
-      const longOptions = [
-        { name: 'Short', value: 'short' },
-        {
-          name: 'This is a very long option name that would normally expand the dropdown',
-          value: 'long1'
-        },
-        {
-          name: 'Another extremely long option that demonstrates max-width constraint',
-          value: 'long2'
-        }
-      ]
-      return { selected1, selected2, selected3, longOptions }
-    },
-    template: `
-      <div class="flex gap-4">
-        <div>
-          <h3 class="text-sm font-semibold mb-2">Auto Width</h3>
-          <SingleSelect v-model="selected1" :options="longOptions" label="Auto" />
-        </div>
-        <div>
-          <h3 class="text-sm font-semibold mb-2">Max Width 15rem</h3>
-          <SingleSelect v-model="selected2" :options="longOptions" label="Max 15rem" popover-max-width="15rem" />
-        </div>
-        <div>
-          <h3 class="text-sm font-semibold mb-2">Min 10rem Max 20rem</h3>
-          <SingleSelect v-model="selected3" :options="longOptions" label="Min & Max" popover-min-width="10rem" popover-max-width="20rem" />
-        </div>
-      </div>
-    `
-  }),
-  parameters: {
-    controls: { disable: true },
-    actions: { disable: true },
-    slot: { disable: true }
+    controls: { disable: true }
   }
 }

src/components/input/SingleSelect.vue

@@ -15,23 +15,26 @@
     unstyled
     :pt="{
       root: ({ props }: SelectPassThroughMethodOptions<SelectOption>) => ({
-        class: [
-          // container
-          'h-10 relative inline-flex cursor-pointer select-none items-center',
-          // trigger surface
+        class: cn(
+          'relative inline-flex cursor-pointer items-center select-none',
+          size === 'md' ? 'h-8' : 'h-10',
           'rounded-lg',
           'bg-secondary-background text-base-foreground',
-          'border-[2.5px] border-solid border-transparent',
           'transition-all duration-200 ease-in-out',
-          'focus-within:border-node-component-border',
-          // disabled
-          { 'opacity-60 cursor-default': props.disabled }
-        ]
+          'hover:bg-secondary-background-hover',
+          'border-[2.5px] border-solid',
+          invalid
+            ? 'border-destructive-background'
+            : 'border-transparent focus-within:border-node-component-border',
+          props.disabled &&
+            'cursor-default opacity-30 hover:bg-secondary-background'
+        )
       }),
       label: {
-        class:
-          // Align with MultiSelect labelContainer spacing
-          'flex-1 flex items-center whitespace-nowrap pl-4 py-2 outline-hidden'
+        class: cn(
+          'flex flex-1 items-center py-2 whitespace-nowrap outline-hidden',
+          size === 'md' ? 'pl-3' : 'pl-4'
+        )
       },
       dropdown: {
         class:
@@ -77,6 +80,8 @@
       }
     }"
     :aria-label="label || t('g.singleSelectDropdown')"
+    :aria-busy="loading || undefined"
+    :aria-invalid="invalid || undefined"
     role="combobox"
     :aria-expanded="false"
     aria-haspopup="listbox"
@@ -84,8 +89,16 @@
   >
     <!-- Trigger value -->
     <template #value="slotProps">
-      <div class="flex items-center gap-2 text-sm">
-        <slot name="icon" />
+      <div
+        :class="
+          cn('flex items-center gap-2', size === 'md' ? 'text-xs' : 'text-sm')
+        "
+      >
+        <i
+          v-if="loading"
+          class="icon-[lucide--loader-circle] animate-spin text-muted-foreground"
+        />
+        <slot v-else name="icon" />
         <span
           v-if="slotProps.value !== null && slotProps.value !== undefined"
           class="text-base-foreground"
@@ -98,9 +111,12 @@
       </div>
     </template>
 
-    <!-- Trigger caret -->
+    <!-- Trigger caret (hidden when loading) -->
     <template #dropdownicon>
-      <i class="icon-[lucide--chevron-down] text-muted-foreground" />
+      <i
+        v-if="!loading"
+        class="icon-[lucide--chevron-down] text-muted-foreground"
+      />
     </template>
 
     <!-- Option row -->
@@ -133,6 +149,9 @@ defineOptions({
 const {
   label,
   options,
+  size = 'lg',
+  invalid = false,
+  loading = false,
   listMaxHeight = '28rem',
   popoverMinWidth,
   popoverMaxWidth
@@ -144,6 +163,12 @@ const {
    * in getLabel() to map values to their display names.
    */
   options?: SelectOption[]
+  /** Trigger size: 'lg' (40px, Interface) or 'md' (32px, Node) */
+  size?: 'lg' | 'md'
+  /** Show invalid (destructive) border */
+  invalid?: boolean
+  /** Show loading spinner instead of chevron */
+  loading?: boolean
   /** Maximum height of the dropdown panel (default: 28rem) */
   listMaxHeight?: string
   /** Minimum width of the popover (default: auto) */

src/components/topbar/CurrentUserButton.test.ts

@@ -9,6 +9,18 @@ import enMessages from '@/locales/en/main.json' with { type: 'json' }
 
 import CurrentUserButton from './CurrentUserButton.vue'
 
+const mockFeatureFlags = vi.hoisted(() => ({
+  teamWorkspacesEnabled: false
+}))
+
+const mockTeamWorkspaceStore = vi.hoisted(() => ({
+  workspaceName: { value: '' },
+  initState: { value: 'idle' },
+  isInPersonalWorkspace: { value: false }
+}))
+
+const mockIsCloud = vi.hoisted(() => ({ value: false }))
+
 // Mock all firebase modules
 vi.mock('firebase/app', () => ({
   initializeApp: vi.fn(),
@@ -32,16 +44,19 @@ vi.mock('pinia', () => ({
 // Mock the useFeatureFlags composable
 vi.mock('@/composables/useFeatureFlags', () => ({
   useFeatureFlags: vi.fn(() => ({
-    flags: { teamWorkspacesEnabled: false }
+    flags: mockFeatureFlags
   }))
 }))
 
 // Mock the useTeamWorkspaceStore
 vi.mock('@/platform/workspace/stores/teamWorkspaceStore', () => ({
-  useTeamWorkspaceStore: vi.fn(() => ({
-    workspaceName: { value: '' },
-    initState: { value: 'idle' }
-  }))
+  useTeamWorkspaceStore: vi.fn(() => mockTeamWorkspaceStore)
+}))
+
+vi.mock('@/platform/distribution/types', () => ({
+  get isCloud() {
+    return mockIsCloud.value
+  }
 }))
 
 // Mock the useCurrentUser composable
@@ -64,6 +79,16 @@ vi.mock('@/components/common/UserAvatar.vue', () => ({
   }
 }))
 
+// Mock the WorkspaceProfilePic component
+vi.mock('@/platform/workspace/components/WorkspaceProfilePic.vue', () => ({
+  default: {
+    name: 'WorkspaceProfilePicMock',
+    render() {
+      return h('div', 'WorkspaceProfilePic')
+    }
+  }
+}))
+
 // Mock the CurrentUserPopoverLegacy component
 vi.mock('./CurrentUserPopoverLegacy.vue', () => ({
   default: {
@@ -78,9 +103,15 @@ vi.mock('./CurrentUserPopoverLegacy.vue', () => ({
 describe('CurrentUserButton', () => {
   beforeEach(() => {
     vi.clearAllMocks()
+    mockFeatureFlags.teamWorkspacesEnabled = false
+    mockTeamWorkspaceStore.workspaceName.value = ''
+    mockTeamWorkspaceStore.initState.value = 'idle'
+    mockTeamWorkspaceStore.isInPersonalWorkspace.value = false
+    mockIsCloud.value = false
   })
 
-  const mountComponent = (): VueWrapper => {
+  const mountComponent = (options?: { stubButton?: boolean }): VueWrapper => {
+    const { stubButton = true } = options ?? {}
     const i18n = createI18n({
       legacy: false,
       locale: 'en',
@@ -99,7 +130,7 @@ describe('CurrentUserButton', () => {
               hide: vi.fn()
             }
           },
-          Button: true
+          ...(stubButton ? { Button: true } : {})
         }
       }
     })
@@ -137,4 +168,27 @@ describe('CurrentUserButton', () => {
     // Verify that popover.hide was called
     expect(popoverHideSpy).toHaveBeenCalled()
   })
+
+  it('shows UserAvatar in personal workspace', () => {
+    mockIsCloud.value = true
+    mockFeatureFlags.teamWorkspacesEnabled = true
+    mockTeamWorkspaceStore.initState.value = 'ready'
+    mockTeamWorkspaceStore.isInPersonalWorkspace.value = true
+
+    const wrapper = mountComponent({ stubButton: false })
+    expect(wrapper.html()).toContain('Avatar')
+    expect(wrapper.html()).not.toContain('WorkspaceProfilePic')
+  })
+
+  it('shows WorkspaceProfilePic in team workspace', () => {
+    mockIsCloud.value = true
+    mockFeatureFlags.teamWorkspacesEnabled = true
+    mockTeamWorkspaceStore.initState.value = 'ready'
+    mockTeamWorkspaceStore.isInPersonalWorkspace.value = false
+    mockTeamWorkspaceStore.workspaceName.value = 'My Team'
+
+    const wrapper = mountComponent({ stubButton: false })
+    expect(wrapper.html()).toContain('WorkspaceProfilePic')
+    expect(wrapper.html()).not.toContain('Avatar')
+  })
 })

src/components/topbar/CurrentUserButton.vue

@@ -98,15 +98,21 @@ const photoURL = computed<string | undefined>(
   () => userPhotoUrl.value ?? undefined
 )
 
-const { workspaceName: teamWorkspaceName, initState } = storeToRefs(
-  useTeamWorkspaceStore()
-)
+const {
+  workspaceName: teamWorkspaceName,
+  initState,
+  isInPersonalWorkspace
+} = storeToRefs(useTeamWorkspaceStore())
 
 const showWorkspaceSkeleton = computed(
   () => isCloud && teamWorkspacesEnabled.value && initState.value === 'loading'
 )
 const showWorkspaceIcon = computed(
-  () => isCloud && teamWorkspacesEnabled.value && initState.value === 'ready'
+  () =>
+    isCloud &&
+    teamWorkspacesEnabled.value &&
+    initState.value === 'ready' &&
+    !isInPersonalWorkspace.value
 )
 
 const workspaceName = computed(() => {

src/components/ui/select/Select.stories.ts

@@ -1,261 +0,0 @@
-import type { Meta, StoryObj } from '@storybook/vue3-vite'
-import { ref } from 'vue'
-
-import Select from './Select.vue'
-import SelectContent from './SelectContent.vue'
-import SelectGroup from './SelectGroup.vue'
-import SelectItem from './SelectItem.vue'
-import SelectLabel from './SelectLabel.vue'
-import SelectSeparator from './SelectSeparator.vue'
-import SelectTrigger from './SelectTrigger.vue'
-import SelectValue from './SelectValue.vue'
-
-const meta = {
-  title: 'Components/Select',
-  component: Select,
-  tags: ['autodocs'],
-  argTypes: {
-    modelValue: {
-      control: 'text',
-      description: 'Selected value'
-    },
-    disabled: {
-      control: 'boolean',
-      description: 'When true, disables the select'
-    },
-    'onUpdate:modelValue': { action: 'update:modelValue' }
-  }
-} satisfies Meta<typeof Select>
-
-export default meta
-type Story = StoryObj<typeof meta>
-
-export const Default: Story = {
-  render: (args) => ({
-    components: {
-      Select,
-      SelectContent,
-      SelectItem,
-      SelectTrigger,
-      SelectValue
-    },
-    setup() {
-      const value = ref(args.modelValue || '')
-      return { value, args }
-    },
-    template: `
-      <Select v-model="value" :disabled="args.disabled">
-        <SelectTrigger class="w-56">
-          <SelectValue placeholder="Select a fruit" />
-        </SelectTrigger>
-        <SelectContent>
-          <SelectItem value="apple">Apple</SelectItem>
-          <SelectItem value="banana">Banana</SelectItem>
-          <SelectItem value="cherry">Cherry</SelectItem>
-          <SelectItem value="grape">Grape</SelectItem>
-          <SelectItem value="orange">Orange</SelectItem>
-        </SelectContent>
-      </Select>
-      <div class="mt-4 text-sm text-muted-foreground">
-        Selected: {{ value || 'None' }}
-      </div>
-    `
-  }),
-  args: {
-    disabled: false
-  }
-}
-
-export const WithPlaceholder: Story = {
-  render: (args) => ({
-    components: {
-      Select,
-      SelectContent,
-      SelectItem,
-      SelectTrigger,
-      SelectValue
-    },
-    setup() {
-      const value = ref('')
-      return { value, args }
-    },
-    template: `
-      <Select v-model="value" :disabled="args.disabled">
-        <SelectTrigger class="w-56">
-          <SelectValue placeholder="Choose an option..." />
-        </SelectTrigger>
-        <SelectContent>
-          <SelectItem value="option1">Option 1</SelectItem>
-          <SelectItem value="option2">Option 2</SelectItem>
-          <SelectItem value="option3">Option 3</SelectItem>
-        </SelectContent>
-      </Select>
-    `
-  }),
-  args: {
-    disabled: false
-  }
-}
-
-export const Disabled: Story = {
-  render: (args) => ({
-    components: {
-      Select,
-      SelectContent,
-      SelectItem,
-      SelectTrigger,
-      SelectValue
-    },
-    setup() {
-      const value = ref('apple')
-      return { value, args }
-    },
-    template: `
-      <Select v-model="value" disabled>
-        <SelectTrigger class="w-56">
-          <SelectValue placeholder="Select a fruit" />
-        </SelectTrigger>
-        <SelectContent>
-          <SelectItem value="apple">Apple</SelectItem>
-          <SelectItem value="banana">Banana</SelectItem>
-          <SelectItem value="cherry">Cherry</SelectItem>
-        </SelectContent>
-      </Select>
-    `
-  })
-}
-
-export const WithGroups: Story = {
-  render: (args) => ({
-    components: {
-      Select,
-      SelectContent,
-      SelectGroup,
-      SelectItem,
-      SelectLabel,
-      SelectSeparator,
-      SelectTrigger,
-      SelectValue
-    },
-    setup() {
-      const value = ref('')
-      return { value, args }
-    },
-    template: `
-      <Select v-model="value" :disabled="args.disabled">
-        <SelectTrigger class="w-56">
-          <SelectValue placeholder="Select a model type" />
-        </SelectTrigger>
-        <SelectContent>
-          <SelectGroup>
-            <SelectLabel>Checkpoints</SelectLabel>
-            <SelectItem value="sd15">SD 1.5</SelectItem>
-            <SelectItem value="sdxl">SDXL</SelectItem>
-            <SelectItem value="flux">Flux</SelectItem>
-          </SelectGroup>
-          <SelectSeparator />
-          <SelectGroup>
-            <SelectLabel>LoRAs</SelectLabel>
-            <SelectItem value="lora-style">Style LoRA</SelectItem>
-            <SelectItem value="lora-character">Character LoRA</SelectItem>
-          </SelectGroup>
-          <SelectSeparator />
-          <SelectGroup>
-            <SelectLabel>Other</SelectLabel>
-            <SelectItem value="vae">VAE</SelectItem>
-            <SelectItem value="embedding">Embedding</SelectItem>
-          </SelectGroup>
-        </SelectContent>
-      </Select>
-      <div class="mt-4 text-sm text-muted-foreground">
-        Selected: {{ value || 'None' }}
-      </div>
-    `
-  }),
-  args: {
-    disabled: false
-  }
-}
-
-export const Scrollable: Story = {
-  render: (args) => ({
-    components: {
-      Select,
-      SelectContent,
-      SelectItem,
-      SelectTrigger,
-      SelectValue
-    },
-    setup() {
-      const value = ref('')
-      const items = Array.from({ length: 20 }, (_, i) => ({
-        value: `item-${i + 1}`,
-        label: `Option ${i + 1}`
-      }))
-      return { value, items, args }
-    },
-    template: `
-      <Select v-model="value" :disabled="args.disabled">
-        <SelectTrigger class="w-56">
-          <SelectValue placeholder="Select an option" />
-        </SelectTrigger>
-        <SelectContent>
-          <SelectItem
-            v-for="item in items"
-            :key="item.value"
-            :value="item.value"
-          >
-            {{ item.label }}
-          </SelectItem>
-        </SelectContent>
-      </Select>
-    `
-  }),
-  args: {
-    disabled: false
-  }
-}
-
-export const CustomWidth: Story = {
-  render: (args) => ({
-    components: {
-      Select,
-      SelectContent,
-      SelectItem,
-      SelectTrigger,
-      SelectValue
-    },
-    setup() {
-      const value = ref('')
-      return { value, args }
-    },
-    template: `
-      <div class="space-y-4">
-        <Select v-model="value" :disabled="args.disabled">
-          <SelectTrigger class="w-32">
-            <SelectValue placeholder="Small" />
-          </SelectTrigger>
-          <SelectContent>
-            <SelectItem value="a">A</SelectItem>
-            <SelectItem value="b">B</SelectItem>
-            <SelectItem value="c">C</SelectItem>
-          </SelectContent>
-        </Select>
-
-        <Select v-model="value" :disabled="args.disabled">
-          <SelectTrigger class="w-full">
-            <SelectValue placeholder="Full width select" />
-          </SelectTrigger>
-          <SelectContent>
-            <SelectItem value="option1">Option 1</SelectItem>
-            <SelectItem value="option2">Option 2</SelectItem>
-            <SelectItem value="option3">Option 3</SelectItem>
-          </SelectContent>
-        </Select>
-      </div>
-    `
-  }),
-  args: {
-    disabled: false
-  }
-}

src/components/ui/select/SelectGroup.vue

@@ -1,17 +0,0 @@
-<script setup lang="ts">
-import type { SelectGroupProps } from 'reka-ui'
-import { SelectGroup } from 'reka-ui'
-import type { HTMLAttributes } from 'vue'
-
-import { cn } from '@/utils/tailwindUtil'
-
-const { class: className, ...restProps } = defineProps<
-  SelectGroupProps & { class?: HTMLAttributes['class'] }
->()
-</script>
-
-<template>
-  <SelectGroup :class="cn('w-full', className)" v-bind="restProps">
-    <slot />
-  </SelectGroup>
-</template>

src/components/ui/select/SelectLabel.vue

@@ -1,25 +0,0 @@
-<script setup lang="ts">
-import type { SelectLabelProps } from 'reka-ui'
-import { SelectLabel } from 'reka-ui'
-import type { HTMLAttributes } from 'vue'
-
-import { cn } from '@/utils/tailwindUtil'
-
-const { class: className, ...restProps } = defineProps<
-  SelectLabelProps & { class?: HTMLAttributes['class'] }
->()
-</script>
-
-<template>
-  <SelectLabel
-    v-bind="restProps"
-    :class="
-      cn(
-        'px-3 py-2 text-xs tracking-wide text-muted-foreground uppercase',
-        className
-      )
-    "
-  >
-    <slot />
-  </SelectLabel>
-</template>

src/components/ui/select/SelectSeparator.vue

@@ -1,18 +0,0 @@
-<script setup lang="ts">
-import type { SelectSeparatorProps } from 'reka-ui'
-import { SelectSeparator } from 'reka-ui'
-import type { HTMLAttributes } from 'vue'
-
-import { cn } from '@/utils/tailwindUtil'
-
-const { class: className, ...restProps } = defineProps<
-  SelectSeparatorProps & { class?: HTMLAttributes['class'] }
->()
-</script>
-
-<template>
-  <SelectSeparator
-    v-bind="restProps"
-    :class="cn('-mx-1 my-1 h-px bg-border-default', className)"
-  />
-</template>

src/components/ui/select/SelectTrigger.vue

@@ -5,24 +5,41 @@ import type { HTMLAttributes } from 'vue'
 
 import { cn } from '@/utils/tailwindUtil'
 
-const { class: className, ...restProps } = defineProps<
-  SelectTriggerProps & { class?: HTMLAttributes['class'] }
+const {
+  class: className,
+  size = 'lg',
+  invalid = false,
+  ...restProps
+} = defineProps<
+  SelectTriggerProps & {
+    class?: HTMLAttributes['class']
+    /** Trigger size: 'lg' (40px) or 'md' (32px) */
+    size?: 'lg' | 'md'
+    /** Show invalid (destructive) border */
+    invalid?: boolean
+  }
 >()
 </script>
 
 <template>
   <SelectTrigger
     v-bind="restProps"
+    :aria-invalid="invalid || undefined"
     :class="
       cn(
-        'flex h-10 w-full cursor-pointer items-center justify-between select-none',
-        'rounded-lg px-4 py-2 text-sm',
+        'flex w-full cursor-pointer items-center justify-between select-none',
+        size === 'md' ? 'h-8 px-3 py-1 text-xs' : 'h-10 px-4 py-2 text-sm',
+        'rounded-lg',
         'bg-secondary-background text-base-foreground',
-        'border-[2.5px] border-solid border-transparent',
         'transition-all duration-200 ease-in-out',
-        'focus:border-node-component-border focus:outline-none',
+        'hover:bg-secondary-background-hover',
+        'border-[2.5px] border-solid',
+        invalid
+          ? 'border-destructive-background'
+          : 'border-transparent focus:border-node-component-border',
+        'focus:outline-none',
         'data-placeholder:text-muted-foreground',
-        'disabled:cursor-not-allowed disabled:opacity-60',
+        'disabled:cursor-not-allowed disabled:opacity-30 disabled:hover:bg-secondary-background',
         '[&>span]:truncate',
         className
       )

src/composables/useMissingNodesDialog.ts

@@ -1,30 +0,0 @@
-import type { ComponentAttrs } from 'vue-component-type-helpers'
-
-import MissingNodesContent from '@/components/dialog/content/MissingNodesContent.vue'
-import MissingNodesFooter from '@/components/dialog/content/MissingNodesFooter.vue'
-import MissingNodesHeader from '@/components/dialog/content/MissingNodesHeader.vue'
-import { useDialogService } from '@/services/dialogService'
-import { useDialogStore } from '@/stores/dialogStore'
-
-const DIALOG_KEY = 'global-missing-nodes'
-
-export function useMissingNodesDialog() {
-  const { showSmallLayoutDialog } = useDialogService()
-  const dialogStore = useDialogStore()
-
-  function hide() {
-    dialogStore.closeDialog({ key: DIALOG_KEY })
-  }
-
-  function show(props: ComponentAttrs<typeof MissingNodesContent>) {
-    showSmallLayoutDialog({
-      key: DIALOG_KEY,
-      headerComponent: MissingNodesHeader,
-      footerComponent: MissingNodesFooter,
-      component: MissingNodesContent,
-      props
-    })
-  }
-
-  return { show, hide }
-}

src/locales/ar/settings.json

@@ -454,9 +454,6 @@
   "Comfy_Workflow_ShowMissingModelsWarning": {
     "name": "عرض تحذير النماذج المفقودة"
   },
-  "Comfy_Workflow_ShowMissingNodesWarning": {
-    "name": "عرض تحذير العقد المفقودة"
-  },
   "Comfy_Workflow_SortNodeIdOnSave": {
     "name": "ترتيب معرفات العقد عند حفظ سير العمل"
   },

src/locales/en/settings.json

@@ -454,9 +454,6 @@
   "Comfy_Workflow_ShowMissingModelsWarning": {
     "name": "Show missing models warning"
   },
-  "Comfy_Workflow_ShowMissingNodesWarning": {
-    "name": "Show missing nodes warning"
-  },
   "Comfy_Workflow_SortNodeIdOnSave": {
     "name": "Sort node IDs when saving workflow"
   },

src/locales/es/settings.json

@@ -454,9 +454,6 @@
   "Comfy_Workflow_ShowMissingModelsWarning": {
     "name": "Mostrar advertencia de modelos faltantes"
   },
-  "Comfy_Workflow_ShowMissingNodesWarning": {
-    "name": "Mostrar advertencia de nodos faltantes"
-  },
   "Comfy_Workflow_SortNodeIdOnSave": {
     "name": "Ordenar IDs de nodos al guardar el flujo de trabajo"
   },

src/locales/fa/settings.json

@@ -454,9 +454,6 @@
   "Comfy_Workflow_ShowMissingModelsWarning": {
     "name": "نمایش هشدار مدل‌های مفقود"
   },
-  "Comfy_Workflow_ShowMissingNodesWarning": {
-    "name": "نمایش هشدار نودهای مفقود"
-  },
   "Comfy_Workflow_SortNodeIdOnSave": {
     "name": "مرتب‌سازی شناسه نودها هنگام ذخیره ورک‌فلو"
   },

src/locales/fr/settings.json

@@ -454,9 +454,6 @@
   "Comfy_Workflow_ShowMissingModelsWarning": {
     "name": "Afficher l'avertissement des modèles manquants"
   },
-  "Comfy_Workflow_ShowMissingNodesWarning": {
-    "name": "Afficher l'avertissement des nœuds manquants"
-  },
   "Comfy_Workflow_SortNodeIdOnSave": {
     "name": "Trier les ID de nœuds lors de l'enregistrement du flux de travail"
   },

src/locales/ja/settings.json

@@ -454,9 +454,6 @@
   "Comfy_Workflow_ShowMissingModelsWarning": {
     "name": "欠落しているモデルの警告を表示"
   },
-  "Comfy_Workflow_ShowMissingNodesWarning": {
-    "name": "欠落しているノードの警告を表示"
-  },
   "Comfy_Workflow_SortNodeIdOnSave": {
     "name": "ワークフローを保存する際にノードIDをソート"
   },

src/locales/ko/settings.json

@@ -454,9 +454,6 @@
   "Comfy_Workflow_ShowMissingModelsWarning": {
     "name": "누락된 모델 경고 표시"
   },
-  "Comfy_Workflow_ShowMissingNodesWarning": {
-    "name": "누락된 노드 경고 표시"
-  },
   "Comfy_Workflow_SortNodeIdOnSave": {
     "name": "워크플로 저장 시 노드 ID 정렬"
   },

src/locales/pt-BR/settings.json

@@ -454,9 +454,6 @@
   "Comfy_Workflow_ShowMissingModelsWarning": {
     "name": "Mostrar aviso de modelos ausentes"
   },
-  "Comfy_Workflow_ShowMissingNodesWarning": {
-    "name": "Mostrar aviso de nós ausentes"
-  },
   "Comfy_Workflow_SortNodeIdOnSave": {
     "name": "Ordenar IDs dos nós ao salvar fluxo de trabalho"
   },

src/locales/ru/settings.json

@@ -454,9 +454,6 @@
   "Comfy_Workflow_ShowMissingModelsWarning": {
     "name": "Показать предупреждение об отсутствующих моделях"
   },
-  "Comfy_Workflow_ShowMissingNodesWarning": {
-    "name": "Показать предупреждение об отсутствующих нодах"
-  },
   "Comfy_Workflow_SortNodeIdOnSave": {
     "name": "Сортировать ID нод при сохранении рабочего процесса"
   },

src/locales/tr/settings.json

@@ -454,9 +454,6 @@
   "Comfy_Workflow_ShowMissingModelsWarning": {
     "name": "Eksik model uyarısını göster"
   },
-  "Comfy_Workflow_ShowMissingNodesWarning": {
-    "name": "Eksik düğüm uyarısını göster"
-  },
   "Comfy_Workflow_SortNodeIdOnSave": {
     "name": "İş akışını kaydederken düğüm kimliklerini sırala"
   },

src/locales/zh-TW/settings.json

@@ -454,9 +454,6 @@
   "Comfy_Workflow_ShowMissingModelsWarning": {
     "name": "顯示缺少模型警告"
   },
-  "Comfy_Workflow_ShowMissingNodesWarning": {
-    "name": "顯示缺少節點警告"
-  },
   "Comfy_Workflow_SortNodeIdOnSave": {
     "name": "儲存工作流程時排序節點 ID"
   },

src/locales/zh/settings.json

@@ -454,9 +454,6 @@
   "Comfy_Workflow_ShowMissingModelsWarning": {
     "name": "显示缺失模型警告"
   },
-  "Comfy_Workflow_ShowMissingNodesWarning": {
-    "name": "显示缺失节点警告"
-  },
   "Comfy_Workflow_SortNodeIdOnSave": {
     "name": "保存节点ID到工作流"
   },

src/platform/settings/constants/coreSettings.ts

@@ -280,12 +280,6 @@ export const CORE_SETTINGS: SettingParams[] = [
       step: 0.01
     }
   },
-  {
-    id: 'Comfy.Workflow.ShowMissingNodesWarning',
-    name: 'Show missing nodes warning',
-    type: 'boolean',
-    defaultValue: true
-  },
   {
     id: 'Comfy.Workflow.ShowMissingModelsWarning',
     name: 'Show missing models warning',

src/platform/workflow/core/services/workflowService.test.ts

@@ -13,6 +13,7 @@ import type { ComfyWorkflow } from '@/platform/workflow/management/stores/workfl
 import { useWorkflowStore } from '@/platform/workflow/management/stores/workflowStore'
 import { useWorkflowService } from '@/platform/workflow/core/services/workflowService'
 import { app } from '@/scripts/app'
+import { useExecutionErrorStore } from '@/stores/executionErrorStore'
 import { useAppMode } from '@/composables/useAppMode'
 import type { AppMode } from '@/composables/useAppMode'
 import type { ComfyWorkflowJSON } from '@/platform/workflow/validation/schemas/workflowSchema'
@@ -56,16 +57,9 @@ function makeWorkflowData(
   }
 }
 
-const { mockShowMissingNodes, mockShowMissingModels, mockConfirm } = vi.hoisted(
-  () => ({
-    mockShowMissingNodes: vi.fn(),
-    mockShowMissingModels: vi.fn(),
-    mockConfirm: vi.fn()
-  })
-)
-
-vi.mock('@/composables/useMissingNodesDialog', () => ({
-  useMissingNodesDialog: () => ({ show: mockShowMissingNodes, hide: vi.fn() })
+const { mockShowMissingModels, mockConfirm } = vi.hoisted(() => ({
+  mockShowMissingModels: vi.fn(),
+  mockConfirm: vi.fn()
 }))
 
 vi.mock('@/composables/useMissingModelsDialog', () => ({
@@ -156,7 +150,6 @@ function createWorkflow(
 function enableWarningSettings() {
   vi.spyOn(useSettingStore(), 'get').mockImplementation(
     (key: string): boolean => {
-      if (key === 'Comfy.Workflow.ShowMissingNodesWarning') return true
       if (key === 'Comfy.Workflow.ShowMissingModelsWarning') return true
       return false
     }
@@ -178,19 +171,21 @@ describe('useWorkflowService', () => {
       const workflow = createWorkflow(null)
       useWorkflowService().showPendingWarnings(workflow)
 
-      expect(mockShowMissingNodes).not.toHaveBeenCalled()
+      const errorStore = useExecutionErrorStore()
+      expect(errorStore.surfaceMissingNodes).not.toHaveBeenCalled()
       expect(mockShowMissingModels).not.toHaveBeenCalled()
     })
 
-    it('should show missing nodes dialog and clear warnings', () => {
+    it('should surface missing nodes and clear warnings', () => {
       const missingNodeTypes = ['CustomNode1', 'CustomNode2']
       const workflow = createWorkflow({ missingNodeTypes })
 
       useWorkflowService().showPendingWarnings(workflow)
 
-      expect(mockShowMissingNodes).toHaveBeenCalledWith({
+      const errorStore = useExecutionErrorStore()
+      expect(errorStore.surfaceMissingNodes).toHaveBeenCalledWith(
         missingNodeTypes
-      })
+      )
       expect(workflow.pendingWarnings).toBeNull()
     })
 
@@ -203,7 +198,7 @@ describe('useWorkflowService', () => {
       expect(workflow.pendingWarnings).toBeNull()
     })
 
-    it('should not show dialogs when settings are disabled', () => {
+    it('should not show models dialog when settings are disabled', () => {
       vi.spyOn(useSettingStore(), 'get').mockReturnValue(false)
 
       const workflow = createWorkflow({
@@ -213,7 +208,10 @@ describe('useWorkflowService', () => {
 
       useWorkflowService().showPendingWarnings(workflow)
 
-      expect(mockShowMissingNodes).not.toHaveBeenCalled()
+      const errorStore = useExecutionErrorStore()
+      expect(errorStore.surfaceMissingNodes).toHaveBeenCalledWith([
+        'CustomNode1'
+      ])
       expect(mockShowMissingModels).not.toHaveBeenCalled()
       expect(workflow.pendingWarnings).toBeNull()
     })
@@ -227,7 +225,8 @@ describe('useWorkflowService', () => {
       service.showPendingWarnings(workflow)
       service.showPendingWarnings(workflow)
 
-      expect(mockShowMissingNodes).toHaveBeenCalledTimes(1)
+      const errorStore = useExecutionErrorStore()
+      expect(errorStore.surfaceMissingNodes).toHaveBeenCalledTimes(1)
     })
   })
 
@@ -250,7 +249,8 @@ describe('useWorkflowService', () => {
         { loadable: true }
       )
 
-      expect(mockShowMissingNodes).not.toHaveBeenCalled()
+      const errorStore = useExecutionErrorStore()
+      expect(errorStore.surfaceMissingNodes).not.toHaveBeenCalled()
 
       await useWorkflowService().openWorkflow(workflow)
 
@@ -261,9 +261,9 @@ describe('useWorkflowService', () => {
         workflow,
         expect.objectContaining({ deferWarnings: true })
       )
-      expect(mockShowMissingNodes).toHaveBeenCalledWith({
-        missingNodeTypes: ['CustomNode1']
-      })
+      expect(errorStore.surfaceMissingNodes).toHaveBeenCalledWith([
+        'CustomNode1'
+      ])
       expect(workflow.pendingWarnings).toBeNull()
     })
 
@@ -278,20 +278,21 @@ describe('useWorkflowService', () => {
       )
 
       const service = useWorkflowService()
+      const errorStore = useExecutionErrorStore()
 
       await service.openWorkflow(workflow1)
-      expect(mockShowMissingNodes).toHaveBeenCalledTimes(1)
-      expect(mockShowMissingNodes).toHaveBeenCalledWith({
-        missingNodeTypes: ['MissingNodeA']
-      })
+      expect(errorStore.surfaceMissingNodes).toHaveBeenCalledTimes(1)
+      expect(errorStore.surfaceMissingNodes).toHaveBeenCalledWith([
+        'MissingNodeA'
+      ])
       expect(workflow1.pendingWarnings).toBeNull()
       expect(workflow2.pendingWarnings).not.toBeNull()
 
       await service.openWorkflow(workflow2)
-      expect(mockShowMissingNodes).toHaveBeenCalledTimes(2)
-      expect(mockShowMissingNodes).toHaveBeenLastCalledWith({
-        missingNodeTypes: ['MissingNodeB']
-      })
+      expect(errorStore.surfaceMissingNodes).toHaveBeenCalledTimes(2)
+      expect(errorStore.surfaceMissingNodes).toHaveBeenLastCalledWith([
+        'MissingNodeB'
+      ])
       expect(workflow2.pendingWarnings).toBeNull()
     })
 
@@ -302,12 +303,13 @@ describe('useWorkflowService', () => {
       )
 
       const service = useWorkflowService()
+      const errorStore = useExecutionErrorStore()
 
       await service.openWorkflow(workflow, { force: true })
-      expect(mockShowMissingNodes).toHaveBeenCalledTimes(1)
+      expect(errorStore.surfaceMissingNodes).toHaveBeenCalledTimes(1)
 
       await service.openWorkflow(workflow, { force: true })
-      expect(mockShowMissingNodes).toHaveBeenCalledTimes(1)
+      expect(errorStore.surfaceMissingNodes).toHaveBeenCalledTimes(1)
     })
   })
 

src/platform/workflow/core/services/workflowService.ts

@@ -17,7 +17,6 @@ import { useWorkflowThumbnail } from '@/renderer/core/thumbnail/useWorkflowThumb
 import { app } from '@/scripts/app'
 import { blankGraph, defaultGraph } from '@/scripts/defaultGraph'
 import { useMissingModelsDialog } from '@/composables/useMissingModelsDialog'
-import { useMissingNodesDialog } from '@/composables/useMissingNodesDialog'
 import { useDialogService } from '@/services/dialogService'
 import { useAppMode } from '@/composables/useAppMode'
 import type { AppMode } from '@/composables/useAppMode'
@@ -41,7 +40,6 @@ export const useWorkflowService = () => {
   const toastStore = useToastStore()
   const dialogService = useDialogService()
   const missingModelsDialog = useMissingModelsDialog()
-  const missingNodesDialog = useMissingNodesDialog()
   const workflowThumbnail = useWorkflowThumbnail()
   const domWidgetStore = useDomWidgetStore()
   const executionErrorStore = useExecutionErrorStore()
@@ -540,11 +538,6 @@ export const useWorkflowService = () => {
     wf.pendingWarnings = null
 
     if (missingNodeTypes?.length) {
-      // Remove modal once Node Replacement is implemented in TabErrors.
-      if (settingStore.get('Comfy.Workflow.ShowMissingNodesWarning')) {
-        missingNodesDialog.show({ missingNodeTypes })
-      }
-
       executionErrorStore.surfaceMissingNodes(missingNodeTypes)
     }
 

src/schemas/apiSchema.ts

@@ -298,7 +298,6 @@ const zSettings = z.object({
   'Comfy.ConfirmClear': z.boolean(),
   'Comfy.DevMode': z.boolean(),
   'Comfy.UI.TabBarLayout': z.enum(['Default', 'Legacy']),
-  'Comfy.Workflow.ShowMissingNodesWarning': z.boolean(),
   'Comfy.Workflow.ShowMissingModelsWarning': z.boolean(),
   'Comfy.Workflow.WarnBlueprintOverwrite': z.boolean(),
   'Comfy.DisableFloatRounding': z.boolean(),

src/scripts/app.ts

@@ -55,7 +55,6 @@ import {
   DOMWidgetImpl
 } from '@/scripts/domWidget'
 import { useDialogService } from '@/services/dialogService'
-import { useMissingNodesDialog } from '@/composables/useMissingNodesDialog'
 import { useExtensionService } from '@/services/extensionService'
 import { useLitegraphService } from '@/services/litegraphService'
 import { useSubgraphService } from '@/services/subgraphService'
@@ -1093,11 +1092,6 @@ export class ComfyApp {
   }
 
   private showMissingNodesError(missingNodeTypes: MissingNodeType[]) {
-    // Remove modal once Node Replacement is implemented in TabErrors.
-    if (useSettingStore().get('Comfy.Workflow.ShowMissingNodesWarning')) {
-      useMissingNodesDialog().show({ missingNodeTypes })
-    }
-
     const executionErrorStore = useExecutionErrorStore()
     executionErrorStore.surfaceMissingNodes(missingNodeTypes)
   }
@@ -1830,7 +1824,6 @@ export class ComfyApp {
     )
     if (missingNodeTypes.length) {
       this.showMissingNodesError(missingNodeTypes.map((t) => t.class_type))
-      return
     }
 
     const ids = Object.keys(apiData)

src/workbench/extensions/manager/components/ManagerProgressToast.vue

@@ -245,8 +245,10 @@ onBeforeUnmount(() => {
     </template>
 
     <template #footer="{ toggle }">
-      <div class="flex w-full items-center justify-between px-6 py-2 shadow-lg">
-        <div class="flex items-center text-base leading-none">
+      <div
+        class="flex w-full items-center justify-between gap-4 px-6 py-2 shadow-lg"
+      >
+        <div class="flex min-w-0 items-center text-base leading-none">
           <div class="flex items-center">
             <template v-if="isInProgress">
               <DotSpinner duration="1s" class="mr-2" />
@@ -262,7 +264,7 @@ onBeforeUnmount(() => {
             </template>
           </div>
         </div>
-        <div class="flex items-center gap-4">
+        <div class="flex shrink-0 items-center gap-4">
           <span v-if="isInProgress" class="text-sm text-muted-foreground">
             {{ completedTasksCount }} {{ t('g.progressCountOf') }}
             {{ totalTasksCount }}