fix: refactor: Use real composable implementations in ComfyHubPublishDialog tests instead of heavy mocks (#9449)

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

src/components/curve/curveUtils.ts

@@ -51,17 +51,6 @@ export function createMonotoneInterpolator(
     }
   }
 
-  const segCount = n - 1
-  const segDx = new Float64Array(segCount)
-  const segM0dx = new Float64Array(segCount)
-  const segM1dx = new Float64Array(segCount)
-  for (let i = 0; i < segCount; i++) {
-    const dx = xs[i + 1] - xs[i]
-    segDx[i] = dx
-    segM0dx[i] = slopes[i] * dx
-    segM1dx[i] = slopes[i + 1] * dx
-  }
-
   return (x: number): number => {
     if (x <= xs[0]) return ys[0]
     if (x >= xs[n - 1]) return ys[n - 1]
@@ -74,7 +63,7 @@ export function createMonotoneInterpolator(
       else hi = mid
     }
 
-    const dx = segDx[lo]
+    const dx = xs[hi] - xs[lo]
     if (dx === 0) return ys[lo]
 
     const t = (x - xs[lo]) / dx
@@ -86,7 +75,12 @@ export function createMonotoneInterpolator(
     const h01 = -2 * t3 + 3 * t2
     const h11 = t3 - t2
 
-    return h00 * ys[lo] + h10 * segM0dx[lo] + h01 * ys[hi] + h11 * segM1dx[lo]
+    return (
+      h00 * ys[lo] +
+      h10 * dx * slopes[lo] +
+      h01 * ys[hi] +
+      h11 * dx * slopes[hi]
+    )
   }
 }
 

src/composables/useCoreCommands.ts

@@ -905,14 +905,6 @@ export function useCoreCommands(): ComfyCommand[] {
         app.canvas.pasteFromClipboard()
       }
     },
-    {
-      id: 'Comfy.Canvas.PasteFromClipboardWithConnect',
-      icon: 'icon-[lucide--clipboard-paste]',
-      label: () => t('Paste with Connect'),
-      function: () => {
-        app.canvas.pasteFromClipboard({ connectInputs: true })
-      }
-    },
     {
       id: 'Comfy.Canvas.SelectAll',
       icon: 'icon-[lucide--lasso-select]',
@@ -927,12 +919,6 @@ export function useCoreCommands(): ComfyCommand[] {
       label: 'Delete Selected Items',
       versionAdded: '1.10.5',
       function: () => {
-        if (app.canvas.selectedItems.size === 0) {
-          app.canvas.canvas.dispatchEvent(
-            new CustomEvent('litegraph:no-items-selected', { bubbles: true })
-          )
-          return
-        }
         app.canvas.deleteSelected()
         app.canvas.setDirty(true, true)
       }

src/composables/useWorkflowActionsMenu.ts

@@ -189,10 +189,11 @@ export function useWorkflowActionsMenu(
 
     addItem({
       id: 'share',
-      label: t('breadcrumbsMenu.share'),
+      label: t('menuLabels.Share'),
       icon: 'icon-[comfy--send]',
       command: async () => {},
-      visible: false
+      disabled: true,
+      visible: isRoot
     })
 
     addItem({

src/lib/litegraph/src/LGraphCanvas.ts

@@ -3791,6 +3791,13 @@ export class LGraphCanvas implements CustomEventDispatcher<LGraphCanvasEventMap>
     return
   }
 
+  private _noItemsSelected(): void {
+    const event = new CustomEvent('litegraph:no-items-selected', {
+      bubbles: true
+    })
+    this.canvas.dispatchEvent(event)
+  }
+
   /**
    * process a key event
    */
@@ -3835,6 +3842,31 @@ export class LGraphCanvas implements CustomEventDispatcher<LGraphCanvasEventMap>
         this.node_panel?.close()
         this.options_panel?.close()
         if (this.node_panel || this.options_panel) block_default = true
+      } else if (e.keyCode === 65 && e.ctrlKey) {
+        // select all Control A
+        this.selectItems()
+        block_default = true
+      } else if (e.keyCode === 67 && (e.metaKey || e.ctrlKey) && !e.shiftKey) {
+        // copy
+        if (this.selected_nodes) {
+          this.copyToClipboard()
+          block_default = true
+        }
+      } else if (e.keyCode === 86 && (e.metaKey || e.ctrlKey)) {
+        // paste
+        this.pasteFromClipboard({ connectInputs: e.shiftKey })
+      } else if (e.key === 'Delete' || e.key === 'Backspace') {
+        // delete or backspace
+        // @ts-expect-error EventTarget.localName is not in standard types
+        if (e.target.localName != 'input' && e.target.localName != 'textarea') {
+          if (this.selectedItems.size === 0) {
+            this._noItemsSelected()
+            return
+          }
+
+          this.deleteSelected()
+          block_default = true
+        }
       }
 
       // TODO

src/locales/en/main.json

@@ -178,7 +178,7 @@
     "uploadAlreadyInProgress": "Upload already in progress",
     "capture": "capture",
     "nodes": "Nodes",
-    "nodesCount": "{count} node | {count} nodes",
+    "nodesCount": "{count} nodes | {count} node | {count} nodes",
     "addNode": "Add a node...",
     "filterBy": "Filter by:",
     "filterByType": "Filter by {type}...",
@@ -222,7 +222,7 @@
     "failed": "Failed",
     "cancelled": "Cancelled",
     "job": "Job",
-    "asset": "{count} asset | {count} assets",
+    "asset": "{count} assets | {count} asset | {count} assets",
     "untitled": "Untitled",
     "emDash": "—",
     "enabling": "Enabling {id}",
@@ -1262,7 +1262,6 @@
     "Move Selected Nodes Right": "Move Selected Nodes Right",
     "Move Selected Nodes Up": "Move Selected Nodes Up",
     "Paste": "Paste",
-    "Paste with Connect": "Paste with Connect",
     "Reset View": "Reset View",
     "Resize Selected Nodes": "Resize Selected Nodes",
     "Select All": "Select All",
@@ -2604,8 +2603,7 @@
     "deleteWorkflow": "Delete Workflow",
     "deleteBlueprint": "Delete Blueprint",
     "enterNewName": "Enter new name",
-    "missingNodesWarning": "Workflow contains unsupported nodes (highlighted red).",
-    "share": "Share"
+    "missingNodesWarning": "Workflow contains unsupported nodes (highlighted red)."
   },
   "shortcuts": {
     "shortcuts": "Shortcuts",
@@ -3349,7 +3347,7 @@
     }
   },
   "errorOverlay": {
-    "errorCount": "{count} ERROR | {count} ERRORS",
+    "errorCount": "{count} ERRORS | {count} ERROR | {count} ERRORS",
     "seeErrors": "See Errors"
   },
   "help": {
@@ -3359,7 +3357,7 @@
   "progressToast": {
     "importingModels": "Importing Models",
     "downloadingModel": "Downloading model...",
-    "downloadsFailed": "{count} download failed | {count} downloads failed",
+    "downloadsFailed": "{count} downloads failed | {count} download failed | {count} downloads failed",
     "allDownloadsCompleted": "All downloads completed",
     "noImportsInQueue": "No {filter} in queue",
     "failed": "Failed",
@@ -3376,7 +3374,7 @@
     "exportingAssets": "Exporting Assets",
     "preparingExport": "Preparing export...",
     "exportError": "Export failed",
-    "exportFailed": "{count} export failed | {count} exports failed",
+    "exportFailed": "{count} export failed | {count} export failed | {count} exports failed",
     "allExportsCompleted": "All exports completed",
     "noExportsInQueue": "No {filter} exports in queue",
     "exportStarted": "Preparing ZIP download...",

src/platform/keybindings/defaults.ts

@@ -208,52 +208,5 @@ export const CORE_KEYBINDINGS: Keybinding[] = [
       key: 'Escape'
     },
     commandId: 'Comfy.Graph.ExitSubgraph'
-  },
-  {
-    combo: {
-      ctrl: true,
-      key: 'a'
-    },
-    commandId: 'Comfy.Canvas.SelectAll',
-    targetElementId: 'graph-canvas-container'
-  },
-  {
-    combo: {
-      ctrl: true,
-      key: 'c'
-    },
-    commandId: 'Comfy.Canvas.CopySelected',
-    targetElementId: 'graph-canvas-container'
-  },
-  {
-    combo: {
-      ctrl: true,
-      key: 'v'
-    },
-    commandId: 'Comfy.Canvas.PasteFromClipboard',
-    targetElementId: 'graph-canvas-container'
-  },
-  {
-    combo: {
-      ctrl: true,
-      shift: true,
-      key: 'v'
-    },
-    commandId: 'Comfy.Canvas.PasteFromClipboardWithConnect',
-    targetElementId: 'graph-canvas-container'
-  },
-  {
-    combo: {
-      key: 'Delete'
-    },
-    commandId: 'Comfy.Canvas.DeleteSelectedItems',
-    targetElementId: 'graph-canvas-container'
-  },
-  {
-    combo: {
-      key: 'Backspace'
-    },
-    commandId: 'Comfy.Canvas.DeleteSelectedItems',
-    targetElementId: 'graph-canvas-container'
   }
 ]

src/platform/keybindings/keybindingService.forwarding.test.ts

@@ -1,11 +1,22 @@
 import { createTestingPinia } from '@pinia/testing'
 import { setActivePinia } from 'pinia'
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+import { beforeEach, describe, expect, it, vi } from 'vitest'
 
 import { useKeybindingService } from '@/platform/keybindings/keybindingService'
+import { app } from '@/scripts/app'
 import { useCommandStore } from '@/stores/commandStore'
 import { useDialogStore } from '@/stores/dialogStore'
 
+vi.mock('@/scripts/app', () => {
+  return {
+    app: {
+      canvas: {
+        processKey: vi.fn()
+      }
+    }
+  }
+})
+
 vi.mock('@/platform/settings/settingStore', () => ({
   useSettingStore: vi.fn(() => ({
     get: vi.fn(() => [])
@@ -25,15 +36,13 @@ function createTestKeyboardEvent(
     ctrlKey?: boolean
     altKey?: boolean
     metaKey?: boolean
-    shiftKey?: boolean
   } = {}
 ): KeyboardEvent {
   const {
     target = document.body,
     ctrlKey = false,
     altKey = false,
-    metaKey = false,
-    shiftKey = false
+    metaKey = false
   } = options
 
   const event = new KeyboardEvent('keydown', {
@@ -41,7 +50,6 @@ function createTestKeyboardEvent(
     ctrlKey,
     altKey,
     metaKey,
-    shiftKey,
     bubbles: true,
     cancelable: true
   })
@@ -52,10 +60,8 @@ function createTestKeyboardEvent(
   return event
 }
 
-describe('keybindingService - Canvas Keybindings', () => {
+describe('keybindingService - Event Forwarding', () => {
   let keybindingService: ReturnType<typeof useKeybindingService>
-  let canvasContainer: HTMLDivElement
-  let canvasChild: HTMLCanvasElement
 
   beforeEach(() => {
     vi.clearAllMocks()
@@ -70,156 +76,94 @@ describe('keybindingService - Canvas Keybindings', () => {
       typeof useDialogStore
     >)
 
-    canvasContainer = document.createElement('div')
-    canvasContainer.id = 'graph-canvas-container'
-    canvasChild = document.createElement('canvas')
-    canvasContainer.appendChild(canvasChild)
-    document.body.appendChild(canvasContainer)
-
     keybindingService = useKeybindingService()
     keybindingService.registerCoreKeybindings()
   })
 
-  afterEach(() => {
-    canvasContainer.remove()
-  })
-
-  it('should execute DeleteSelectedItems for Delete key on canvas', async () => {
-    const event = createTestKeyboardEvent('Delete', {
-      target: canvasChild
-    })
+  it('should forward Delete key to canvas when no keybinding exists', async () => {
+    const event = createTestKeyboardEvent('Delete')
 
     await keybindingService.keybindHandler(event)
 
-    expect(vi.mocked(useCommandStore().execute)).toHaveBeenCalledWith(
-      'Comfy.Canvas.DeleteSelectedItems'
-    )
+    expect(vi.mocked(app.canvas.processKey)).toHaveBeenCalledWith(event)
+    expect(vi.mocked(useCommandStore().execute)).not.toHaveBeenCalled()
   })
 
-  it('should execute DeleteSelectedItems for Backspace key on canvas', async () => {
-    const event = createTestKeyboardEvent('Backspace', {
-      target: canvasChild
-    })
+  it('should forward Backspace key to canvas when no keybinding exists', async () => {
+    const event = createTestKeyboardEvent('Backspace')
 
     await keybindingService.keybindHandler(event)
 
-    expect(vi.mocked(useCommandStore().execute)).toHaveBeenCalledWith(
-      'Comfy.Canvas.DeleteSelectedItems'
-    )
+    expect(vi.mocked(app.canvas.processKey)).toHaveBeenCalledWith(event)
+    expect(vi.mocked(useCommandStore().execute)).not.toHaveBeenCalled()
   })
 
-  it('should not execute DeleteSelectedItems when typing in input field', async () => {
+  it('should not forward Delete key when typing in input field', async () => {
     const inputElement = document.createElement('input')
     const event = createTestKeyboardEvent('Delete', { target: inputElement })
 
     await keybindingService.keybindHandler(event)
 
+    expect(vi.mocked(app.canvas.processKey)).not.toHaveBeenCalled()
     expect(vi.mocked(useCommandStore().execute)).not.toHaveBeenCalled()
   })
 
-  it('should not execute DeleteSelectedItems when typing in textarea', async () => {
+  it('should not forward Delete key when typing in textarea', async () => {
     const textareaElement = document.createElement('textarea')
-    const event = createTestKeyboardEvent('Delete', {
-      target: textareaElement
-    })
+    const event = createTestKeyboardEvent('Delete', { target: textareaElement })
 
     await keybindingService.keybindHandler(event)
 
+    expect(vi.mocked(app.canvas.processKey)).not.toHaveBeenCalled()
     expect(vi.mocked(useCommandStore().execute)).not.toHaveBeenCalled()
   })
 
-  it('should execute SelectAll for Ctrl+A on canvas', async () => {
-    const event = createTestKeyboardEvent('a', {
-      ctrlKey: true,
-      target: canvasChild
-    })
+  it('should not forward Delete key when canvas processKey is not available', async () => {
+    // Temporarily replace processKey with undefined - testing edge case
+    const originalProcessKey = vi.mocked(app.canvas).processKey
+    vi.mocked(app.canvas).processKey = undefined!
 
-    await keybindingService.keybindHandler(event)
+    const event = createTestKeyboardEvent('Delete')
 
-    expect(vi.mocked(useCommandStore().execute)).toHaveBeenCalledWith(
-      'Comfy.Canvas.SelectAll'
-    )
+    try {
+      await keybindingService.keybindHandler(event)
+      expect(vi.mocked(useCommandStore().execute)).not.toHaveBeenCalled()
+    } finally {
+      // Restore processKey for other tests
+      vi.mocked(app.canvas).processKey = originalProcessKey
+    }
   })
 
-  it('should execute CopySelected for Ctrl+C on canvas', async () => {
-    const event = createTestKeyboardEvent('c', {
-      ctrlKey: true,
-      target: canvasChild
-    })
+  it('should not forward Delete key when canvas is not available', async () => {
+    const originalCanvas = vi.mocked(app).canvas
+    vi.mocked(app).canvas = null!
 
-    await keybindingService.keybindHandler(event)
+    const event = createTestKeyboardEvent('Delete')
 
-    expect(vi.mocked(useCommandStore().execute)).toHaveBeenCalledWith(
-      'Comfy.Canvas.CopySelected'
-    )
+    try {
+      await keybindingService.keybindHandler(event)
+      expect(vi.mocked(useCommandStore().execute)).not.toHaveBeenCalled()
+    } finally {
+      // Restore canvas for other tests
+      vi.mocked(app).canvas = originalCanvas
+    }
   })
 
-  it('should execute PasteFromClipboard for Ctrl+V on canvas', async () => {
-    const event = createTestKeyboardEvent('v', {
-      ctrlKey: true,
-      target: canvasChild
-    })
-
-    await keybindingService.keybindHandler(event)
-
-    expect(vi.mocked(useCommandStore().execute)).toHaveBeenCalledWith(
-      'Comfy.Canvas.PasteFromClipboard'
-    )
-  })
-
-  it('should execute PasteFromClipboardWithConnect for Ctrl+Shift+V on canvas', async () => {
-    const event = createTestKeyboardEvent('v', {
-      ctrlKey: true,
-      shiftKey: true,
-      target: canvasChild
-    })
-
-    await keybindingService.keybindHandler(event)
-
-    expect(vi.mocked(useCommandStore().execute)).toHaveBeenCalledWith(
-      'Comfy.Canvas.PasteFromClipboardWithConnect'
-    )
-  })
-
-  it('should execute graph-canvas bindings by normalizing to graph-canvas-container', async () => {
-    const event = createTestKeyboardEvent('=', {
-      altKey: true,
-      target: canvasChild
-    })
-
-    await keybindingService.keybindHandler(event)
-
-    expect(vi.mocked(useCommandStore().execute)).toHaveBeenCalledWith(
-      'Comfy.Canvas.ZoomIn'
-    )
-  })
-
-  it('should not execute graph-canvas bindings when target is outside canvas', async () => {
-    const outsideDiv = document.createElement('div')
-    document.body.appendChild(outsideDiv)
-
-    const event = createTestKeyboardEvent('=', {
-      altKey: true,
-      target: outsideDiv
-    })
+  it('should not forward non-canvas keys', async () => {
+    const event = createTestKeyboardEvent('Enter')
 
     await keybindingService.keybindHandler(event)
 
+    expect(vi.mocked(app.canvas.processKey)).not.toHaveBeenCalled()
     expect(vi.mocked(useCommandStore().execute)).not.toHaveBeenCalled()
-    outsideDiv.remove()
   })
 
-  it('should not execute canvas commands when target is outside canvas container', async () => {
-    const outsideDiv = document.createElement('div')
-    document.body.appendChild(outsideDiv)
-
-    const event = createTestKeyboardEvent('Delete', {
-      target: outsideDiv
-    })
+  it('should not forward when modifier keys are pressed', async () => {
+    const event = createTestKeyboardEvent('Delete', { ctrlKey: true })
 
     await keybindingService.keybindHandler(event)
 
+    expect(vi.mocked(app.canvas.processKey)).not.toHaveBeenCalled()
     expect(vi.mocked(useCommandStore().execute)).not.toHaveBeenCalled()
-    outsideDiv.remove()
   })
 })

src/platform/keybindings/keybindingService.ts

@@ -1,5 +1,6 @@
 import { isCloud } from '@/platform/distribution/types'
 import { useSettingStore } from '@/platform/settings/settingStore'
+import { app } from '@/scripts/app'
 import { useCommandStore } from '@/stores/commandStore'
 import { useDialogStore } from '@/stores/dialogStore'
 
@@ -14,6 +15,16 @@ export function useKeybindingService() {
   const settingStore = useSettingStore()
   const dialogStore = useDialogStore()
 
+  function shouldForwardToCanvas(event: KeyboardEvent): boolean {
+    if (event.ctrlKey || event.altKey || event.metaKey) {
+      return false
+    }
+
+    const canvasKeys = ['Delete', 'Backspace']
+
+    return canvasKeys.includes(event.key)
+  }
+
   async function keybindHandler(event: KeyboardEvent) {
     const keyCombo = KeyComboImpl.fromEvent(event)
     if (keyCombo.isModifier) {
@@ -33,17 +44,7 @@ export function useKeybindingService() {
     }
 
     const keybinding = keybindingStore.getKeybinding(keyCombo)
-    if (keybinding) {
-      const targetElementId =
-        keybinding.targetElementId === 'graph-canvas'
-          ? 'graph-canvas-container'
-          : keybinding.targetElementId
-      if (targetElementId) {
-        const container = document.getElementById(targetElementId)
-        if (!container?.contains(target)) {
-          return
-        }
-      }
+    if (keybinding && keybinding.targetElementId !== 'graph-canvas') {
       if (
         event.key === 'Escape' &&
         !event.ctrlKey &&
@@ -73,6 +74,18 @@ export function useKeybindingService() {
       return
     }
 
+    if (!keybinding && shouldForwardToCanvas(event)) {
+      const canvas = app.canvas
+      if (
+        canvas &&
+        canvas.processKey &&
+        typeof canvas.processKey === 'function'
+      ) {
+        canvas.processKey(event)
+        return
+      }
+    }
+
     if (event.ctrlKey || event.altKey || event.metaKey) {
       return
     }

src/platform/workflow/sharing/components/publish/ComfyHubPublishDialog.test.ts

@@ -1,59 +1,79 @@
 import { flushPromises, mount } from '@vue/test-utils'
 import { beforeEach, describe, expect, it, vi } from 'vitest'
-import { ref } from 'vue'
 
 import ComfyHubPublishDialog from '@/platform/workflow/sharing/components/publish/ComfyHubPublishDialog.vue'
+import type { ComfyHubProfile } from '@/schemas/apiSchema'
 
-const mockFetchProfile = vi.hoisted(() => vi.fn())
-const mockGoToStep = vi.hoisted(() => vi.fn())
-const mockGoNext = vi.hoisted(() => vi.fn())
-const mockGoBack = vi.hoisted(() => vi.fn())
-const mockOpenProfileCreationStep = vi.hoisted(() => vi.fn())
-const mockCloseProfileCreationStep = vi.hoisted(() => vi.fn())
+const mockFetchApi = vi.hoisted(() => vi.fn())
+const mockToastErrorHandler = vi.hoisted(() => vi.fn())
+const mockResolvedUserInfo = vi.hoisted(() => ({
+  value: { id: 'user-a' }
+}))
 
-vi.mock(
-  '@/platform/workflow/sharing/composables/useComfyHubProfileGate',
-  () => ({
-    useComfyHubProfileGate: () => ({
-      fetchProfile: mockFetchProfile
-    })
+vi.mock('@/scripts/api', () => ({
+  api: {
+    fetchApi: mockFetchApi
+  }
+}))
+
+vi.mock('@/composables/auth/useCurrentUser', () => ({
+  useCurrentUser: () => ({
+    resolvedUserInfo: mockResolvedUserInfo
   })
-)
+}))
 
-vi.mock(
-  '@/platform/workflow/sharing/composables/useComfyHubPublishWizard',
-  () => ({
-    useComfyHubPublishWizard: () => ({
-      currentStep: ref('finish'),
-      formData: ref({
-        name: '',
-        description: '',
-        workflowType: '',
-        tags: [],
-        thumbnailType: 'image',
-        thumbnailFile: null,
-        comparisonBeforeFile: null,
-        comparisonAfterFile: null,
-        exampleImages: [],
-        selectedExampleIds: []
-      }),
-      isFirstStep: ref(false),
-      isLastStep: ref(true),
-      goToStep: mockGoToStep,
-      goNext: mockGoNext,
-      goBack: mockGoBack,
-      openProfileCreationStep: mockOpenProfileCreationStep,
-      closeProfileCreationStep: mockCloseProfileCreationStep
-    })
+vi.mock('@/composables/useErrorHandling', () => ({
+  useErrorHandling: () => ({
+    toastErrorHandler: mockToastErrorHandler
   })
-)
+}))
+
+vi.mock('@/platform/workflow/management/stores/workflowStore', () => ({
+  useWorkflowStore: () => ({
+    activeWorkflow: { filename: 'test-workflow' }
+  })
+}))
+
+const mockProfile: ComfyHubProfile = {
+  username: 'testuser',
+  name: 'Test User',
+  description: 'A test profile'
+}
+
+function mockSuccessResponse(data?: unknown) {
+  return {
+    ok: true,
+    json: async () => data ?? mockProfile
+  } as Response
+}
+
+function mockErrorResponse(status = 404) {
+  return {
+    ok: false,
+    status,
+    json: async () => ({ message: 'Not found' })
+  } as Response
+}
+
+// Reset module-level singleton state in useComfyHubProfileGate between tests
+async function resetProfileGateSingleton() {
+  const { useComfyHubProfileGate } =
+    await import('@/platform/workflow/sharing/composables/useComfyHubProfileGate')
+  const gate = useComfyHubProfileGate()
+  gate.hasProfile.value = null
+  gate.profile.value = null
+  gate.isCheckingProfile.value = false
+  gate.isFetchingProfile.value = false
+}
 
 describe('ComfyHubPublishDialog', () => {
   const onClose = vi.fn()
 
-  beforeEach(() => {
+  beforeEach(async () => {
     vi.clearAllMocks()
-    mockFetchProfile.mockResolvedValue(null)
+    mockResolvedUserInfo.value = { id: 'user-a' }
+    mockFetchApi.mockResolvedValue(mockErrorResponse())
+    await resetProfileGateSingleton()
   })
 
   function createWrapper() {
@@ -78,7 +98,7 @@ describe('ComfyHubPublishDialog', () => {
           },
           ComfyHubPublishWizardContent: {
             template:
-              '<div><button data-testid="require-profile" @click="$props.onRequireProfile()" /><button data-testid="gate-complete" @click="$props.onGateComplete()" /><button data-testid="gate-close" @click="$props.onGateClose()" /></div>',
+              '<div><button data-testid="require-profile" @click="$props.onRequireProfile()" /><button data-testid="gate-complete" @click="$props.onGateComplete()" /><button data-testid="gate-close" @click="$props.onGateClose()" /><span data-testid="current-step">{{ $props.currentStep }}</span></div>',
             props: [
               'currentStep',
               'formData',
@@ -88,7 +108,9 @@ describe('ComfyHubPublishDialog', () => {
               'onGoBack',
               'onRequireProfile',
               'onGateComplete',
-              'onGateClose'
+              'onGateClose',
+              'onUpdateFormData',
+              'onPublish'
             ]
           }
         }
@@ -96,44 +118,62 @@ describe('ComfyHubPublishDialog', () => {
     })
   }
 
-  it('starts in publish wizard mode and prefetches profile asynchronously', async () => {
+  it('prefetches profile on mount via real composable', async () => {
     createWrapper()
     await flushPromises()
 
-    expect(mockFetchProfile).toHaveBeenCalledWith()
+    expect(mockFetchApi).toHaveBeenCalledWith('/hub/profile')
   })
 
-  it('switches to profile creation step when final-step publish requires profile', async () => {
+  it('starts on the describe step with real wizard composable', async () => {
+    const wrapper = createWrapper()
+    await flushPromises()
+
+    expect(wrapper.find('[data-testid="current-step"]').text()).toBe('describe')
+  })
+
+  it('switches to profileCreation step when require-profile is triggered', async () => {
     const wrapper = createWrapper()
     await flushPromises()
 
     await wrapper.find('[data-testid="require-profile"]').trigger('click')
 
-    expect(mockOpenProfileCreationStep).toHaveBeenCalledOnce()
+    expect(wrapper.find('[data-testid="current-step"]').text()).toBe(
+      'profileCreation'
+    )
   })
 
-  it('returns to finish state after gate complete and does not auto-close', async () => {
+  it('returns to finish step and re-fetches profile after gate complete', async () => {
+    mockFetchApi.mockResolvedValue(mockSuccessResponse())
     const wrapper = createWrapper()
     await flushPromises()
 
     await wrapper.find('[data-testid="require-profile"]').trigger('click')
+    expect(wrapper.find('[data-testid="current-step"]').text()).toBe(
+      'profileCreation'
+    )
+
     await wrapper.find('[data-testid="gate-complete"]').trigger('click')
+    await flushPromises()
 
-    expect(mockOpenProfileCreationStep).toHaveBeenCalledOnce()
-    expect(mockCloseProfileCreationStep).toHaveBeenCalledOnce()
-    expect(mockFetchProfile).toHaveBeenCalledWith({ force: true })
+    expect(wrapper.find('[data-testid="current-step"]').text()).toBe('finish')
+    // Initial prefetch + force re-fetch after gate complete
+    expect(mockFetchApi).toHaveBeenCalledTimes(2)
     expect(onClose).not.toHaveBeenCalled()
   })
 
-  it('returns to finish state when profile gate is closed', async () => {
+  it('returns to finish step when profile gate is closed', async () => {
     const wrapper = createWrapper()
     await flushPromises()
 
     await wrapper.find('[data-testid="require-profile"]').trigger('click')
+    expect(wrapper.find('[data-testid="current-step"]').text()).toBe(
+      'profileCreation'
+    )
+
     await wrapper.find('[data-testid="gate-close"]').trigger('click')
 
-    expect(mockOpenProfileCreationStep).toHaveBeenCalledOnce()
-    expect(mockCloseProfileCreationStep).toHaveBeenCalledOnce()
+    expect(wrapper.find('[data-testid="current-step"]').text()).toBe('finish')
     expect(onClose).not.toHaveBeenCalled()
   })
 })

src/scripts/app.ts

@@ -676,6 +676,20 @@ export class ComfyApp {
           e.stopImmediatePropagation()
           return
         }
+
+        // Ctrl+C Copy
+        if (e.key === 'c' && (e.metaKey || e.ctrlKey)) {
+          return
+        }
+
+        // Ctrl+V Paste
+        if (
+          (e.key === 'v' || e.key == 'V') &&
+          (e.metaKey || e.ctrlKey) &&
+          !e.shiftKey
+        ) {
+          return
+        }
       }
 
       // Fall through to Litegraph defaults