diff --git a/browser_tests/assets/inputs/checkpoint_loader.json b/browser_tests/assets/inputs/checkpoint_loader.json
new file mode 100644
index 00000000000..d3e6c8ca13a
--- /dev/null
+++ b/browser_tests/assets/inputs/checkpoint_loader.json
@@ -0,0 +1,49 @@
+{
+ "last_node_id": 4,
+ "last_link_id": 0,
+ "nodes": [
+ {
+ "id": 4,
+ "type": "CheckpointLoaderSimple",
+ "pos": [400, 300],
+ "size": [350, 240],
+ "flags": {},
+ "order": 0,
+ "mode": 0,
+ "outputs": [
+ {
+ "name": "MODEL",
+ "type": "MODEL",
+ "links": [],
+ "slot_index": 0
+ },
+ {
+ "name": "CLIP",
+ "type": "CLIP",
+ "links": [],
+ "slot_index": 1
+ },
+ {
+ "name": "VAE",
+ "type": "VAE",
+ "links": [],
+ "slot_index": 2
+ }
+ ],
+ "properties": {
+ "Node name for S&R": "CheckpointLoaderSimple"
+ },
+ "widgets_values": ["sd_xl_base_1.0.safetensors"]
+ }
+ ],
+ "links": [],
+ "groups": [],
+ "config": {},
+ "extra": {
+ "ds": {
+ "scale": 0.8,
+ "offset": [0, 0]
+ }
+ },
+ "version": 0.4
+}
diff --git a/browser_tests/tests/sidebar/modelLibrary.spec.ts b/browser_tests/tests/sidebar/modelLibrary.spec.ts
index de32de68b5f..8e5ff69f297 100644
--- a/browser_tests/tests/sidebar/modelLibrary.spec.ts
+++ b/browser_tests/tests/sidebar/modelLibrary.spec.ts
@@ -301,3 +301,67 @@ test.describe('Model library sidebar - empty state', () => {
})
})
})
+
+test.describe('Model library drops on Vue nodes', { tag: '@vue-nodes' }, () => {
+ test.use({ initialSettings: { 'Comfy.ModelLibrary.UseAssetBrowser': false } })
+
+ test.beforeEach(async ({ comfyPage }) => {
+ await comfyPage.modelLibrary.mockFoldersWithFiles(MOCK_FOLDERS)
+ await comfyPage.workflow.loadWorkflow('inputs/checkpoint_loader')
+ const tab = comfyPage.menu.modelLibraryTab
+ await tab.open()
+ await tab.refreshButton.click()
+ await tab.getFolderByLabel('checkpoints').click()
+ await expect(tab.getLeafByLabel('dreamshaper_8')).toBeVisible()
+ await comfyPage.command.executeCommand('Comfy.Canvas.FitView')
+ await comfyPage.canvasOps.waitForViewToSettle()
+ })
+
+ test.afterEach(async ({ comfyPage }) => {
+ await comfyPage.modelLibrary.clearMocks()
+ await comfyPage.canvasOps.resetView()
+ })
+
+ test('updates an existing loader without creating another node', async ({
+ comfyPage
+ }) => {
+ const [loader] = await comfyPage.nodeOps.getNodeRefsByType(
+ 'CheckpointLoaderSimple'
+ )
+ const filename = await loader.getWidgetByName('ckpt_name')
+ const node = comfyPage.vueNodes.getNodeByTitle('Load Checkpoint')
+ const nodeCount = await comfyPage.nodeOps.getGraphNodesCount()
+ await comfyPage.menu.modelLibraryTab
+ .getLeafByLabel('dreamshaper_8')
+ .dragTo(node)
+ await comfyPage.nextFrame()
+ await expect(node).toContainText('dreamshaper_8.safetensors')
+ await expect
+ .poll(() => filename.getValue())
+ .toBe('dreamshaper_8.safetensors')
+ await expect
+ .poll(() => comfyPage.nodeOps.getGraphNodesCount())
+ .toBe(nodeCount)
+ })
+
+ test('still creates a loader when dropped onto empty canvas', async ({
+ comfyPage
+ }) => {
+ await comfyPage.menu.topbar.newWorkflowButton.click()
+ await expect.poll(() => comfyPage.nodeOps.getGraphNodesCount()).toBe(0)
+ const box = (await comfyPage.canvas.boundingBox())!
+ await comfyPage.menu.modelLibraryTab
+ .getLeafByLabel('dreamshaper_8')
+ .dragTo(comfyPage.canvas, {
+ targetPosition: { x: box.width / 2, y: box.height / 2 }
+ })
+ await comfyPage.nextFrame()
+ await expect.poll(() => comfyPage.nodeOps.getGraphNodesCount()).toBe(1)
+ const [loader] = await comfyPage.nodeOps.getNodeRefsByType(
+ 'CheckpointLoaderSimple'
+ )
+ await expect
+ .poll(async () => (await loader.getWidgetByName('ckpt_name')).getValue())
+ .toBe('dreamshaper_8.safetensors')
+ })
+})
diff --git a/browser_tests/tests/vueNodes/layout/ecsBridgeHistory.spec.ts b/browser_tests/tests/vueNodes/layout/ecsBridgeHistory.spec.ts
index 8f4af0d4a19..58fdc1f716d 100644
--- a/browser_tests/tests/vueNodes/layout/ecsBridgeHistory.spec.ts
+++ b/browser_tests/tests/vueNodes/layout/ecsBridgeHistory.spec.ts
@@ -2,6 +2,7 @@ import {
comfyExpect as expect,
comfyPageFixture as test
} from '@e2e/fixtures/ComfyPage'
+import { TestIds } from '@e2e/fixtures/selectors'
import { toNodeId } from '@/types/nodeId'
test.describe(
@@ -80,6 +81,40 @@ test.describe(
})
})
+ test('preserves Redo after Undo normalizes a subgraph node size', async ({
+ comfyPage
+ }) => {
+ await comfyPage.workflow.loadWorkflow(
+ 'subgraphs/subgraph-with-promoted-text-widget'
+ )
+ await comfyPage.vueNodes.enterSubgraph('11')
+ await comfyPage.command.executeCommand('Comfy.Canvas.FitView')
+
+ const node = await comfyPage.vueNodes.getFixtureByTitle('KSampler')
+ const title = 'Sampling with a long descriptive title for this workflow'
+ const rootBreadcrumb = comfyPage.page.getByTestId(
+ TestIds.breadcrumb.item('root')
+ )
+ await node.setTitle(title)
+ await rootBreadcrumb.click()
+ await comfyPage.vueNodes.enterSubgraph('11')
+
+ const stepsRow = comfyPage.vueNodes.getWidgetRowByLabel(title, 'steps')
+ const steps = stepsRow.getByRole('spinbutton')
+ await comfyPage.vueNodes.setInputNumberValue(stepsRow, '21')
+ await expect(steps).toHaveValue('21')
+ await rootBreadcrumb.click()
+ await comfyPage.vueNodes.enterSubgraph('11')
+
+ await comfyPage.command.executeCommand('Comfy.Undo')
+ await expect(steps).toHaveValue('20')
+ await rootBreadcrumb.click()
+
+ await comfyPage.command.executeCommand('Comfy.Redo')
+ await comfyPage.vueNodes.enterSubgraph('11')
+ await expect(steps).toHaveValue('21')
+ })
+
test('preserves geometry through navigation, renderer toggle, and history', async ({
comfyPage
}) => {
diff --git a/src/components/graph/GraphCanvas.test.ts b/src/components/graph/GraphCanvas.test.ts
index 1ad5246b7cf..ee91bb7206c 100644
--- a/src/components/graph/GraphCanvas.test.ts
+++ b/src/components/graph/GraphCanvas.test.ts
@@ -1,7 +1,16 @@
+import { fromPartial } from '@total-typescript/shoehorn'
import { getActivePinia } from 'pinia'
-import { render, screen } from '@testing-library/vue'
+import { fireEvent, render, screen } from '@testing-library/vue'
import type { RenderOptions } from '@testing-library/vue'
-import { beforeEach, describe, expect, it, vi } from 'vitest'
+import {
+ assert,
+ beforeEach,
+ describe,
+ expect,
+ it,
+ onTestFinished,
+ vi
+} from 'vitest'
import { nextTick } from 'vue'
import { createI18n } from 'vue-i18n'
@@ -10,6 +19,7 @@ import { useSettingStore } from '@/platform/settings/settingStore'
import { useReleaseStore } from '@/platform/updates/common/releaseStore'
import { useWorkflowStore } from '@/platform/workflow/management/stores/workflowStore'
import { useCanvasStore } from '@/renderer/core/canvas/canvasStore'
+import { api } from '@/scripts/api'
import { app } from '@/scripts/app'
import { useBootstrapStore } from '@/stores/bootstrapStore'
import { useExecutionStore } from '@/stores/executionStore'
@@ -217,6 +227,34 @@ describe('GraphCanvas first-run tour wiring', () => {
})
})
+describe('GraphCanvas canvas parent', () => {
+ it('keeps title-editor touches within the canvas parent used by extensions', async () => {
+ vi.spyOn(api, 'getSystemStats').mockResolvedValue(
+ fromPartial({ devices: [] })
+ )
+ await mountGraphCanvas({
+ TitleEditor: { template: '' }
+ })
+ // eslint-disable-next-line testing-library/no-node-access -- Extensions use this canvas ID.
+ const canvas = document.getElementById('graph-canvas')
+ assert.exists(canvas)
+ // eslint-disable-next-line testing-library/no-node-access -- Canvas-parent listeners are the compatibility contract under test.
+ const parent = canvas.parentElement
+ assert.exists(parent)
+ const receivedTouch = vi.fn()
+ parent.addEventListener('touchstart', receivedTouch, true)
+ onTestFinished(() =>
+ parent.removeEventListener('touchstart', receivedTouch, true)
+ )
+
+ await fireEvent.touchStart(
+ screen.getByRole('textbox', { name: 'Node title' })
+ )
+
+ expect(receivedTouch).toHaveBeenCalledOnce()
+ })
+})
+
describe('GraphCanvas execution progress updates', () => {
async function mountProgressHarness({
totalNodes = 1_000,
diff --git a/src/components/graph/GraphCanvas.vue b/src/components/graph/GraphCanvas.vue
index ae8ad7ebddc..d915cd56f52 100644
--- a/src/components/graph/GraphCanvas.vue
+++ b/src/components/graph/GraphCanvas.vue
@@ -73,6 +73,7 @@
()
const canvasRef = ref(null)
+const transformPaneRef =
+ useTemplateRef>('transformPaneRef')
+const vueNodeDropTarget = computed(() => {
+ const element: unknown = transformPaneRef.value?.$el
+ return element instanceof HTMLElement ? element : null
+})
const canvasPanelBoundsRef = useTemplateRef('canvasPanelBoundsRef')
const nodeSearchboxPopoverRef = shallowRef {
'checkpoints'
)
expect(useNodeDragToCanvas().startDrag).toHaveBeenCalledWith(mockNodeDef, {
- widgetValues: { ckpt_name: 'model.safetensors' },
+ widgetValues: [{ selector: 'ckpt_name', value: 'model.safetensors' }],
source: 'sidebar_drag'
})
})
diff --git a/src/composables/node/startModelNodeDragFromAsset.test.ts b/src/composables/node/startModelNodeDragFromAsset.test.ts
index 31698664e2b..0605e5aca62 100644
--- a/src/composables/node/startModelNodeDragFromAsset.test.ts
+++ b/src/composables/node/startModelNodeDragFromAsset.test.ts
@@ -40,7 +40,9 @@ describe('startModelNodeDragFromAsset', () => {
expect(error).toBeUndefined()
expect(useNodeDragToCanvas().startDrag).toHaveBeenCalledWith(nodeDef, {
- widgetValues: { ckpt_name: 'sd_xl_base_1.0.safetensors' },
+ widgetValues: [
+ { selector: 'ckpt_name', value: 'sd_xl_base_1.0.safetensors' }
+ ],
source: 'sidebar_drag'
})
})
@@ -57,7 +59,9 @@ describe('startModelNodeDragFromAsset', () => {
startModelNodeDragFromAsset(createAsset(), 'asset_browser')
expect(useNodeDragToCanvas().startDrag).toHaveBeenCalledWith(nodeDef, {
- widgetValues: { ckpt_name: 'sd_xl_base_1.0.safetensors' },
+ widgetValues: [
+ { selector: 'ckpt_name', value: 'sd_xl_base_1.0.safetensors' }
+ ],
source: 'asset_browser'
})
})
diff --git a/src/composables/node/startModelNodeDragFromAsset.ts b/src/composables/node/startModelNodeDragFromAsset.ts
index 7cebf0dab19..2c568f6e04e 100644
--- a/src/composables/node/startModelNodeDragFromAsset.ts
+++ b/src/composables/node/startModelNodeDragFromAsset.ts
@@ -14,7 +14,9 @@ export function startModelLoaderDrag(
filename: string,
source: NodeAddSource = 'sidebar_drag'
) {
- const widgetValues = provider.key ? { [provider.key]: filename } : undefined
+ const widgetValues = provider.key
+ ? [{ selector: provider.key, value: filename }]
+ : undefined
useNodeDragToCanvas().startDrag(provider.nodeDef, { widgetValues, source })
}
diff --git a/src/composables/node/useNodeDragToCanvas.test.ts b/src/composables/node/useNodeDragToCanvas.test.ts
index b2950f9850d..0fedc3b94a8 100644
--- a/src/composables/node/useNodeDragToCanvas.test.ts
+++ b/src/composables/node/useNodeDragToCanvas.test.ts
@@ -261,7 +261,7 @@ describe('useNodeDragToCanvas', () => {
const { startDrag } = useNodeDragToCanvas()
startDrag(mockNodeDef, {
- widgetValues: { ckpt_name: 'model.safetensors' }
+ widgetValues: [{ selector: 'ckpt_name', value: 'model.safetensors' }]
})
document.dispatchEvent(
@@ -275,6 +275,62 @@ describe('useNodeDragToCanvas', () => {
expect(widget.value).toBe('model.safetensors')
})
+ it('should apply a pattern selection to the first matching widget', () => {
+ mockCanvas.canvas.getBoundingClientRect.mockReturnValue({
+ left: 0,
+ right: 500,
+ top: 0,
+ bottom: 500
+ })
+ mockConvertEventToCanvasOffset.mockReturnValue([150, 150])
+ const placedNode = new LGraphNode('Placed node')
+ const strength = placedNode.addWidget(
+ 'number',
+ 'loras.0.strength',
+ 0.5,
+ () => {}
+ )
+ const first = placedNode.addWidget(
+ 'text',
+ 'loras.0.lora_name',
+ 'A.safetensors',
+ () => {}
+ )
+ const second = placedNode.addWidget(
+ 'text',
+ 'loras.1.lora_name',
+ 'B.safetensors',
+ () => {}
+ )
+ vi.mocked(useLitegraphService().addNodeOnGraph).mockReturnValue(
+ placedNode
+ )
+
+ const { startDrag } = useNodeDragToCanvas()
+ startDrag(mockNodeDef, {
+ widgetValues: [
+ {
+ selector: /^loras\.(?:0|[1-9]\d*)\.lora_name$/,
+ value: 'C.safetensors'
+ }
+ ]
+ })
+
+ document.dispatchEvent(
+ new PointerEvent('pointerup', {
+ clientX: 250,
+ clientY: 250,
+ bubbles: true
+ })
+ )
+
+ expect([strength.value, first.value, second.value]).toEqual([
+ 0.5,
+ 'C.safetensors',
+ 'B.safetensors'
+ ])
+ })
+
it('should warn but still place the node when a requested widget is missing', () => {
mockCanvas.canvas.getBoundingClientRect.mockReturnValue({
left: 0,
@@ -293,7 +349,7 @@ describe('useNodeDragToCanvas', () => {
const { startDrag } = useNodeDragToCanvas()
startDrag(mockNodeDef, {
- widgetValues: { ckpt_name: 'model.safetensors' }
+ widgetValues: [{ selector: 'ckpt_name', value: 'model.safetensors' }]
})
document.dispatchEvent(
diff --git a/src/composables/node/useNodeDragToCanvas.ts b/src/composables/node/useNodeDragToCanvas.ts
index 65a67fe63c8..9b5e9fcf8de 100644
--- a/src/composables/node/useNodeDragToCanvas.ts
+++ b/src/composables/node/useNodeDragToCanvas.ts
@@ -8,14 +8,15 @@ import { useToastStore } from '@/platform/updates/common/toastStore'
import { useCanvasStore } from '@/renderer/core/canvas/canvasStore'
import { useLitegraphService } from '@/services/litegraphService'
import type { ComfyNodeDefImpl } from '@/stores/nodeDefStore'
+import { matchesWidgetName } from '@/utils/widgetBinding'
+import type { WidgetValueBinding } from '@/utils/widgetBinding'
type DragMode = 'click' | 'native'
-type WidgetValues = Record
type Position = { x: number; y: number }
interface StartDragOptions {
mode?: DragMode
- widgetValues?: WidgetValues
+ widgetValues?: readonly WidgetValueBinding[]
source?: NodeAddSource
}
@@ -23,7 +24,7 @@ const isDragging = ref(false)
const draggedNode = shallowRef(null)
const dragMode = ref('click')
const lastNativeDragPosition = shallowRef()
-const pendingWidgetValues = shallowRef()
+const pendingWidgetValues = shallowRef()
const pendingSource = ref('sidebar_drag')
let listenersSetup = false
@@ -36,11 +37,16 @@ function trackNativeDragPosition(e: DragEvent) {
lastNativeDragPosition.value = { x: e.clientX, y: e.clientY }
}
-function applyWidgetValues(node: LGraphNode, values: WidgetValues) {
- for (const [name, value] of Object.entries(values)) {
- const widget = node.widgets?.find((w) => w.name === name)
+function applyWidgetValues(
+ node: LGraphNode,
+ values: readonly WidgetValueBinding[]
+) {
+ for (const { selector, value } of values) {
+ const widget = node.widgets?.find((w) =>
+ matchesWidgetName(w.name, selector)
+ )
if (!widget) {
- console.error(`Widget ${name} not found on node ${node.type}`)
+ console.error(`Widget ${selector} not found on node ${node.type}`)
useToastStore().add({
severity: 'warn',
summary: t('g.warning'),
diff --git a/src/composables/useCanvasDrop.test.ts b/src/composables/useCanvasDrop.test.ts
index abb59b5d15a..09f01b71b9c 100644
--- a/src/composables/useCanvasDrop.test.ts
+++ b/src/composables/useCanvasDrop.test.ts
@@ -1,13 +1,18 @@
import { fromPartial } from '@total-typescript/shoehorn'
-import { describe, expect, it, vi } from 'vitest'
+import { assert, describe, expect, it, onTestFinished, vi } from 'vitest'
import { effectScope, ref } from 'vue'
import { useCanvasDrop } from '@/composables/useCanvasDrop'
import { usePragmaticDroppable } from '@/composables/usePragmaticDragAndDrop'
import { ComfyWorkflow } from '@/platform/workflow/management/stores/workflowStore'
import { app } from '@/scripts/app'
-
-const insertWorkflow = vi.hoisted(() => vi.fn())
+import { LGraphNode } from '@/lib/litegraph/src/litegraph'
+import { useLitegraphService } from '@/services/litegraphService'
+import { useWorkflowService } from '@/platform/workflow/core/services/workflowService'
+import { ComfyModelDef } from '@/stores/modelStore'
+import { useModelToNodeStore } from '@/stores/modelToNodeStore'
+import { useNodeDefStore } from '@/stores/nodeDefStore'
+import type { ComfyNodeDefImpl } from '@/stores/nodeDefStore'
vi.mock(import('@/composables/usePragmaticDragAndDrop'), () => ({
usePragmaticDraggable: vi.fn(),
@@ -23,21 +28,13 @@ vi.mock(
})
)
-vi.mock(
- import('@/platform/workflow/core/services/workflowService'),
- () => ({ useWorkflowService: () => ({ insertWorkflow }) })
-)
-
-vi.mock(import('@/services/litegraphService'), () => ({
- useLitegraphService: () => ({ addNodeOnGraph: vi.fn() })
-}))
-
-vi.mock(import('@/scripts/app'), () => ({
- app: { canvas: { selectOnly: false } }
-}))
+vi.mock(import('@/platform/workflow/core/services/workflowService'))
+vi.mock(import('@/services/litegraphService'))
+vi.mock(import('@/scripts/app'))
function registerDrop() {
const scope = effectScope()
+ onTestFinished(() => scope.stop())
scope.run(() => useCanvasDrop(ref(document.createElement('canvas'))))
const onDrop = vi.mocked(usePragmaticDroppable).mock.lastCall?.[1].onDrop
if (!onDrop) throw new Error('canvas drop target was not registered')
@@ -45,6 +42,53 @@ function registerDrop() {
}
describe('useCanvasDrop', () => {
+ it.for([
+ { selector: 'model_a', description: 'exact widget name' },
+ { selector: /^model_/, description: 'widget name pattern' }
+ ])(
+ 'drops a model into the first widget matching $description',
+ async ({ selector }) => {
+ useNodeDefStore().nodeDefsByName = {
+ TestLoader: fromPartial({ name: 'TestLoader' })
+ }
+ useModelToNodeStore().quickRegister('test-models', 'TestLoader', selector)
+ const node = new LGraphNode('Test loader')
+ node.comfyClass = 'TestLoader'
+ const strength = node.addWidget('number', 'strength', 0.5, () => {})
+ const first = node.addWidget('text', 'model_a', 'A.safetensors', () => {})
+ const second = node.addWidget(
+ 'text',
+ 'model_b',
+ 'B.safetensors',
+ () => {}
+ )
+ assert.exists(app.canvas.graph)
+ vi.spyOn(app.canvas.graph, 'getNodeOnPos').mockReturnValue(node)
+ const onDrop = registerDrop()
+
+ await onDrop(
+ fromPartial({
+ location: { current: { input: { clientX: 10, clientY: 20 } } },
+ source: {
+ data: {
+ type: 'tree-explorer-node',
+ data: {
+ data: new ComfyModelDef('C.safetensors', 'test-models', 0)
+ }
+ }
+ }
+ })
+ )
+
+ expect([strength.value, first.value, second.value]).toEqual([
+ 0.5,
+ 'C.safetensors',
+ 'B.safetensors'
+ ])
+ expect(useLitegraphService().addNodeOnGraph).not.toHaveBeenCalled()
+ }
+ )
+
it.for([
{ selectOnly: false, inserts: 1 },
{ selectOnly: true, inserts: 0 }
@@ -72,7 +116,7 @@ describe('useCanvasDrop', () => {
})
)
- expect(insertWorkflow).toHaveBeenCalledTimes(inserts)
+ expect(useWorkflowService().insertWorkflow).toHaveBeenCalledTimes(inserts)
}
)
})
diff --git a/src/composables/useCanvasDrop.ts b/src/composables/useCanvasDrop.ts
index 18a1bd2d169..d6b2416cba1 100644
--- a/src/composables/useCanvasDrop.ts
+++ b/src/composables/useCanvasDrop.ts
@@ -15,13 +15,14 @@ import { useModelToNodeStore } from '@/stores/modelToNodeStore'
import { ComfyNodeDefImpl } from '@/stores/nodeDefStore'
import type { RenderedTreeExplorerNode } from '@/types/treeExplorerTypes'
import { isSelectOnly } from '@/utils/litegraphUtil'
+import { matchesWidgetName } from '@/utils/widgetBinding'
-export const useCanvasDrop = (canvasRef: Ref) => {
+export const useCanvasDrop = (dropTargetRef: Ref) => {
const modelToNodeStore = useModelToNodeStore()
const litegraphService = useLitegraphService()
const workflowService = useWorkflowService()
- usePragmaticDroppable(() => canvasRef.value, {
+ usePragmaticDroppable(() => dropTargetRef.value, {
getDropEffect: (args): Exclude =>
args.source.data.type === 'tree-explorer-node' ? 'copy' : 'move',
onDrop: async (event) => {
@@ -69,9 +70,10 @@ export const useCanvasDrop = (canvasRef: Ref) => {
targetProvider = provider
}
}
- if (targetGraphNode) {
- const widget = targetGraphNode.widgets?.find(
- (widget) => widget.name === targetProvider?.key
+ if (targetGraphNode && targetProvider) {
+ const { key } = targetProvider
+ const widget = targetGraphNode.widgets?.find((widget) =>
+ matchesWidgetName(widget.name, key)
)
if (widget) {
widget.value = model.file_name
diff --git a/src/composables/usePragmaticDragAndDrop.test.ts b/src/composables/usePragmaticDragAndDrop.test.ts
new file mode 100644
index 00000000000..71ace2aaf09
--- /dev/null
+++ b/src/composables/usePragmaticDragAndDrop.test.ts
@@ -0,0 +1,98 @@
+import { dropTargetForElements } from '@atlaskit/pragmatic-drag-and-drop/element/adapter'
+import { render, screen } from '@testing-library/vue'
+import userEvent from '@testing-library/user-event'
+import { describe, expect, it, vi } from 'vitest'
+import { defineComponent, h, ref } from 'vue'
+
+import { usePragmaticDroppable } from '@/composables/usePragmaticDragAndDrop'
+
+vi.mock(import('@atlaskit/pragmatic-drag-and-drop/element/adapter'))
+
+const DropSurface = defineComponent({
+ setup() {
+ const target = ref(null)
+ const visible = ref(false)
+ const version = ref(0)
+ usePragmaticDroppable(target, {})
+ return () =>
+ h('div', [
+ h(
+ 'button',
+ {
+ onClick: () => {
+ visible.value = true
+ }
+ },
+ 'Show target'
+ ),
+ h(
+ 'button',
+ {
+ onClick: () => {
+ visible.value = false
+ }
+ },
+ 'Hide target'
+ ),
+ h(
+ 'button',
+ {
+ onClick: () => {
+ version.value++
+ }
+ },
+ 'Replace target'
+ ),
+ visible.value
+ ? h('div', {
+ ref: target,
+ key: version.value,
+ role: 'region',
+ 'aria-label': 'Drop surface'
+ })
+ : null
+ ])
+ }
+})
+
+describe('usePragmaticDroppable', () => {
+ it('registers a target that appears after the component mounts', async () => {
+ const user = userEvent.setup()
+ vi.mocked(dropTargetForElements).mockReturnValue(vi.fn())
+ render(DropSurface)
+ expect(dropTargetForElements).not.toHaveBeenCalled()
+
+ await user.click(screen.getByRole('button', { name: 'Show target' }))
+
+ expect(dropTargetForElements).toHaveBeenCalledExactlyOnceWith({
+ element: screen.getByRole('region', { name: 'Drop surface' })
+ })
+ })
+
+ it('releases replaced and removed targets and stops the last target on unmount', async () => {
+ const user = userEvent.setup()
+ const firstCleanup = vi.fn()
+ const secondCleanup = vi.fn()
+ const thirdCleanup = vi.fn()
+ vi.mocked(dropTargetForElements)
+ .mockReturnValueOnce(firstCleanup)
+ .mockReturnValueOnce(secondCleanup)
+ .mockReturnValueOnce(thirdCleanup)
+ const view = render(DropSurface)
+ await user.click(screen.getByRole('button', { name: 'Show target' }))
+ await user.click(screen.getByRole('button', { name: 'Replace target' }))
+ expect(firstCleanup).toHaveBeenCalledOnce()
+ expect(dropTargetForElements).toHaveBeenCalledTimes(2)
+
+ await user.click(screen.getByRole('button', { name: 'Hide target' }))
+ expect(secondCleanup).toHaveBeenCalledOnce()
+ expect(dropTargetForElements).toHaveBeenCalledTimes(2)
+ await user.click(screen.getByRole('button', { name: 'Show target' }))
+ expect(dropTargetForElements).toHaveBeenCalledTimes(3)
+ expect(thirdCleanup).not.toHaveBeenCalled()
+
+ view.unmount()
+
+ expect(thirdCleanup).toHaveBeenCalledOnce()
+ })
+})
diff --git a/src/composables/usePragmaticDragAndDrop.ts b/src/composables/usePragmaticDragAndDrop.ts
index 03788d171e0..bd0752fa9a4 100644
--- a/src/composables/usePragmaticDragAndDrop.ts
+++ b/src/composables/usePragmaticDragAndDrop.ts
@@ -2,7 +2,7 @@ import {
draggable,
dropTargetForElements
} from '@atlaskit/pragmatic-drag-and-drop/element/adapter'
-import { onBeforeUnmount, onMounted, toValue } from 'vue'
+import { onBeforeUnmount, onMounted, toValue, watch } from 'vue'
import type { MaybeRefOrGetter } from 'vue'
export function usePragmaticDroppable(
@@ -12,16 +12,14 @@ export function usePragmaticDroppable(
let cleanup = () => {}
onMounted(() => {
- const element = toValue(dropTargetElement)
-
- if (!element) {
- return
- }
-
- cleanup = dropTargetForElements({
- element,
- ...options
- })
+ cleanup = watch(
+ () => toValue(dropTargetElement),
+ (element, _previous, onCleanup) => {
+ if (!element) return
+ onCleanup(dropTargetForElements({ element, ...options }))
+ },
+ { immediate: true, flush: 'post' }
+ )
})
onBeforeUnmount(() => {
diff --git a/src/core/graph/widgets/dynamicGroupWidget.test.ts b/src/core/graph/widgets/dynamicGroupWidget.test.ts
index 3d26a436204..d4acb8c8035 100644
--- a/src/core/graph/widgets/dynamicGroupWidget.test.ts
+++ b/src/core/graph/widgets/dynamicGroupWidget.test.ts
@@ -379,7 +379,7 @@ describe('DynamicGroup widgets', () => {
).toBe(true)
const outerInput = outerHost.inputs[0]
expect(promotedInputWidget(outerInput)?.label).toBe('LoRA #2 strength')
- return { widget, innerHost, outerHost, outerSubgraph, outerInput }
+ return { node, widget, innerHost, outerHost, outerSubgraph, outerInput }
}
it.for([
@@ -472,6 +472,78 @@ describe('DynamicGroup widgets', () => {
await vi.waitFor(() => expect(promotedInputWidget(outerInput)).toBeNull())
})
+ it('disconnects the deleted row at the outer host while keeping the next row connected', async () => {
+ const { node, widget, innerHost, outerHost, outerInput } =
+ setupTwiceDeepPromotion()
+ const graph = innerHost.subgraph.rootGraph
+ widget('loras').value = 3
+ widget('loras.2.lora_name').value = 'C'
+ widget('loras.2.strength').value = 0.37
+ expect(
+ promoteValueWidgetViaSubgraphInput(
+ innerHost,
+ node,
+ widget('loras.2.strength')
+ ).ok
+ ).toBe(true)
+ const innerPromoted = promotedInputWidget(innerHost.inputs[1])
+ assert.exists(innerPromoted)
+ expect(
+ promoteValueWidgetViaSubgraphInput(outerHost, innerHost, innerPromoted).ok
+ ).toBe(true)
+ const survivingInput = outerHost.inputs[1]
+ const otherHost = createTestSubgraphNode(outerHost.subgraph)
+ graph.add(otherHost)
+ const source = new LGraphNode('Strength source')
+ source.addOutput('strength', 'FLOAT')
+ graph.add(source)
+ const removed = source.connect(0, outerHost, 0)
+ const otherRemoved = source.connect(0, otherHost, 0)
+ const retained = source.connect(0, outerHost, 1)
+ assert.exists(removed)
+ assert.exists(otherRemoved)
+ assert.exists(retained)
+
+ widget('loras.1').callback?.(undefined)
+
+ await vi.waitFor(() => expect(promotedInputWidget(outerInput)).toBeNull())
+ expect(graph.getLink(removed.id)).toBeUndefined()
+ expect(graph.getLink(otherRemoved.id)).toBeUndefined()
+ expect(outerInput.link).toBeNull()
+ expect(otherHost.inputs[0].link).toBeNull()
+ assert.exists(survivingInput.link)
+ expect(graph.getLink(survivingInput.link)).toBe(retained)
+ expect(promotedInputWidget(survivingInput)?.value).toBe(0.37)
+ expect(promotedInputWidget(survivingInput)?.label).toBe('LoRA #2 strength')
+ expect(widget('loras.1.lora_name').value).toBe('C')
+ expect(widget('loras.1.strength').value).toBe(0.37)
+ })
+
+ it('keeps the outer connection when another node still consumes the promoted input', () => {
+ const { widget, innerHost, outerHost, outerInput } =
+ setupTwiceDeepPromotion()
+ const graph = innerHost.subgraph.rootGraph
+ const other = new LGraphNode('Another strength consumer')
+ const input = other.addInput('strength', 'FLOAT')
+ innerHost.subgraph.add(other)
+ const internal = innerHost.subgraph.inputNode.slots[0].connect(input, other)
+ const source = new LGraphNode('Strength source')
+ source.addOutput('strength', 'FLOAT')
+ graph.add(source)
+ const external = source.connect(0, outerHost, 0)
+ assert.exists(internal)
+ assert.exists(external)
+
+ widget('loras.1').callback?.(undefined)
+
+ assert.exists(outerInput.link)
+ assert.exists(input.link)
+ expect(graph.getLink(outerInput.link)).toBe(external)
+ expect(innerHost.subgraph.getLink(input.link)).toBe(internal)
+ expect(innerHost.subgraph.inputs[0].linkIds).toEqual([internal.id])
+ expect(widget('loras').value).toBe(1)
+ })
+
it.for([
{ label: 'LoRA #2 strength', expected: 'LoRA 1행 strength' },
{ label: 'My strength', expected: 'My strength' }
diff --git a/src/core/graph/widgets/dynamicGroupWidget.ts b/src/core/graph/widgets/dynamicGroupWidget.ts
index afe7ab3a221..46a34295646 100644
--- a/src/core/graph/widgets/dynamicGroupWidget.ts
+++ b/src/core/graph/widgets/dynamicGroupWidget.ts
@@ -418,9 +418,10 @@ function disconnectOrphanedPromotion(
if (!isSubgraph(graph) || graph.inputs[slot]?.linkIds.length) return
for (const host of hosts(graph)) {
const link = host.graph && inputLink(host.graph, host.id, slot)
- if (link?.origin_id !== SUBGRAPH_INPUT_ID) continue
+ if (!link) continue
host.disconnectInput(slot)
- disconnectOrphanedPromotion(host.graph, link.origin_slot, hosts)
+ if (link.origin_id === SUBGRAPH_INPUT_ID)
+ disconnectOrphanedPromotion(host.graph, link.origin_slot, hosts)
}
}
diff --git a/src/platform/assets/mappings/modelNodeMappings.ts b/src/platform/assets/mappings/modelNodeMappings.ts
index 7510fdaf83d..ee720709f77 100644
--- a/src/platform/assets/mappings/modelNodeMappings.ts
+++ b/src/platform/assets/mappings/modelNodeMappings.ts
@@ -1,9 +1,11 @@
+const loraStackFilename = /^loras\.(?:0|[1-9]\d*)\.lora_name$/
+
/**
* Default mappings from model directories to loader nodes.
*
* Each entry maps a model folder (as it appears in the model browser)
* to the node class that loads models from that folder and the
- * input key where the model name is inserted.
+ * input name or pattern used to select the model widget.
*
* An empty key ('') means the node auto-loads models without a widget
* selector, so no widget value is assigned when the node is added.
@@ -12,10 +14,13 @@
* "a/b/c" → "a/b" → "a", so registering a parent directory covers
* all its children unless a more specific entry exists.
*
- * Format: [modelDirectory, nodeClass, inputKey]
+ * Patterns enable the picker on every matching widget. Model drops populate
+ * the first matching widget.
+ *
+ * Format: [modelDirectory, nodeClass, inputNameOrPattern]
*/
export const MODEL_NODE_MAPPINGS: ReadonlyArray<
- readonly [string, string, string]
+ readonly [string, string, string | RegExp]
> = [
// Intentionally unmapped (widget values are model ids / HF repo ids, not
// asset filenames): rmbg, florence2, LLM/Qwen-VL/*, qwen-tts, diffusers
@@ -33,6 +38,8 @@ export const MODEL_NODE_MAPPINGS: ReadonlyArray<
['checkpoints', 'ImageOnlyCheckpointLoader', 'ckpt_name'],
['loras', 'LoraLoader', 'lora_name'],
['loras', 'LoraLoaderModelOnly', 'lora_name'],
+ ['loras', 'LoadLoraModel', loraStackFilename],
+ ['loras', 'LoadLoraTextEncoder', loraStackFilename],
['vae', 'VAELoader', 'vae_name'],
['controlnet', 'ControlNetLoader', 'control_net_name'],
['diffusion_models', 'UNETLoader', 'unet_name'],
@@ -158,4 +165,4 @@ export const MODEL_NODE_MAPPINGS: ReadonlyArray<
// ---- LTX-Video IC-LoRA (ComfyUI-LTXVideo) ----
['loras', 'LTXICLoRALoaderModelOnly', 'lora_name']
-] as const satisfies ReadonlyArray
+] as const satisfies ReadonlyArray
diff --git a/src/platform/assets/services/assetService.test.ts b/src/platform/assets/services/assetService.test.ts
index 83653991bbc..f9166c4d132 100644
--- a/src/platform/assets/services/assetService.test.ts
+++ b/src/platform/assets/services/assetService.test.ts
@@ -1,4 +1,6 @@
-import { useModelToNodeStore } from '@/stores/modelToNodeStore'
+import { fromPartial } from '@total-typescript/shoehorn'
+
+import { useNodeDefStore } from '@/stores/nodeDefStore'
import { useAssetsStore } from '@/stores/assetsStore'
import { beforeEach, describe, expect, it, vi } from 'vitest'
@@ -84,19 +86,13 @@ function validAsset(overrides: Partial = {}): AssetItem {
}
beforeEach(() => {
- const registeredNodeTypes: Record = {
- CheckpointLoaderSimple: 'ckpt_name',
- LoraLoader: 'lora_name'
- }
- const nodeTypeCategories: Record = {
- CheckpointLoaderSimple: 'checkpoints',
- LoraLoader: 'loras'
- }
- vi.mocked(useModelToNodeStore().getRegisteredNodeTypes).mockImplementation(
- () => registeredNodeTypes
- )
- vi.mocked(useModelToNodeStore().getCategoryForNodeType).mockImplementation(
- (nodeType: string) => nodeTypeCategories[nodeType]
+ useNodeDefStore().nodeDefsByName = Object.fromEntries(
+ [
+ 'CheckpointLoaderSimple',
+ 'LoraLoader',
+ 'LoadLoraModel',
+ 'LoadLoraTextEncoder'
+ ].map((name) => [name, fromPartial({ name })])
)
vi.spyOn(useAssetsStore().inputAssets, 'invalidate').mockImplementation(
mockInvalidateInputAssets
@@ -138,6 +134,41 @@ describe(assetService.shouldUseWidgetAssetPicker, () => {
).toBe(true)
})
+ it.for([
+ ['LoadLoraModel', 'loras.0.lora_name'],
+ ['LoadLoraModel', 'loras.1.lora_name'],
+ ['LoadLoraModel', 'loras.19.lora_name'],
+ ['LoadLoraTextEncoder', 'loras.0.lora_name'],
+ ['LoadLoraTextEncoder', 'loras.1.lora_name'],
+ ['LoadLoraTextEncoder', 'loras.19.lora_name']
+ ])('uses the asset picker for %s / %s on cloud', ([nodeType, name]) => {
+ mockDistributionState.isCloud = true
+ expect(assetService.shouldUseWidgetAssetPicker(nodeType, name)).toBe(true)
+ })
+
+ it.for(['LoadLoraModel', 'LoadLoraTextEncoder'])(
+ 'keeps the combo widget for %s outside cloud',
+ (nodeType) => {
+ mockDistributionState.isCloud = false
+ expect(
+ assetService.shouldUseWidgetAssetPicker(nodeType, 'loras.1.lora_name')
+ ).toBe(false)
+ }
+ )
+
+ it.for([
+ ['LoadLoraModel', 'loras.1.strength'],
+ ['LoadLoraModel', 'loras.-1.lora_name'],
+ ['LoadLoraModel', 'loras.01.lora_name'],
+ ['LoadLoraModel', 'prefix.loras.1.lora_name'],
+ ['LoadLoraModel', 'loras.1.lora_name.suffix'],
+ ['LoraLoader', 'loras.1.lora_name'],
+ ['UnknownNode', 'loras.1.lora_name']
+ ])('does not treat %s / %s as an asset input', ([nodeType, name]) => {
+ mockDistributionState.isCloud = true
+ expect(assetService.shouldUseWidgetAssetPicker(nodeType, name)).toBe(false)
+ })
+
it('returns false when nodeType is undefined', () => {
mockDistributionState.isCloud = true
diff --git a/src/platform/assets/services/assetService.ts b/src/platform/assets/services/assetService.ts
index 881654e6d17..49ade3e2016 100644
--- a/src/platform/assets/services/assetService.ts
+++ b/src/platform/assets/services/assetService.ts
@@ -571,9 +571,7 @@ function createAssetService() {
widgetName: string
): boolean {
if (!nodeType || !widgetName) return false
- return (
- useModelToNodeStore().getRegisteredNodeTypes()[nodeType] === widgetName
- )
+ return useModelToNodeStore().isModelWidget(nodeType, widgetName)
}
/**
diff --git a/src/platform/workflow/core/services/workflowService.test.ts b/src/platform/workflow/core/services/workflowService.test.ts
index beef1ea78d5..31c98a48402 100644
--- a/src/platform/workflow/core/services/workflowService.test.ts
+++ b/src/platform/workflow/core/services/workflowService.test.ts
@@ -380,6 +380,35 @@ describe('useWorkflowService', () => {
)
})
+ it('persists the displayed state when Undo fails before graph configuration', async () => {
+ vi.spyOn(useSettingStore(), 'get').mockImplementation(
+ (key: string) => key === 'Comfy.Workflow.Persist'
+ )
+ const activeWorkflow = createModeTestWorkflow()
+ const saved = makeWorkflowData()
+ const current = makeWorkflowData({ note: 'latest edit' })
+ const tracker = new ChangeTracker(activeWorkflow, saved)
+ activeWorkflow.changeTracker = tracker
+ tracker.activeState = current
+ tracker.undoQueue.push(saved)
+ workflowStore.activeWorkflow = activeWorkflow
+ vi.mocked(app.loadGraphData).mockImplementationOnce(async () => {
+ useWorkflowService().beforeLoadNewGraph(false)
+ return false
+ })
+
+ await tracker.undo()
+
+ expect(useWorkflowDraftStoreV2().saveDraft).toHaveBeenCalledWith(
+ activeWorkflow.path,
+ JSON.stringify(current),
+ { name: activeWorkflow.key, isTemporary: activeWorkflow.isTemporary }
+ )
+ expect(activeWorkflow.activeState).toEqual(current)
+ expect(tracker.undoQueue).toEqual([saved])
+ expect(tracker.redoQueue).toEqual([])
+ })
+
it('should show an error toast when the V2 draft store cannot save', () => {
vi.spyOn(useSettingStore(), 'get').mockImplementation((key: string) => {
return key === 'Comfy.Workflow.Persist'
diff --git a/src/platform/workflow/core/services/workflowService.ts b/src/platform/workflow/core/services/workflowService.ts
index ae96e2459f7..190a493b6fd 100644
--- a/src/platform/workflow/core/services/workflowService.ts
+++ b/src/platform/workflow/core/services/workflowService.ts
@@ -709,7 +709,9 @@ export const useWorkflowService = () => {
workflowData: ComfyWorkflowJSON,
shareId?: string
) => {
+ const graphState = app.rootGraphOrUndefined?.state
await activateLoadedWorkflow(value, workflowData, shareId)
+ if (graphState !== app.rootGraphOrUndefined?.state) return
useNodeOutputStore().restorePreviewsForWorkflow(
useWorkspaceStore().workflow.activeWorkflow?.path
)
@@ -720,6 +722,7 @@ export const useWorkflowService = () => {
workflowData: ComfyWorkflowJSON,
shareId?: string
) => {
+ const graphState = app.rootGraphOrUndefined?.state
const workflowStore = useWorkspaceStore().workflow
const { isAppMode } = useAppMode()
const wasAppMode = isAppMode.value
@@ -770,6 +773,7 @@ export const useWorkflowService = () => {
) {
const loadedWorkflow =
await workflowStore.openWorkflow(existingWorkflow)
+ if (graphState !== app.rootGraphOrUndefined?.state) return
activateRunErrors(loadedWorkflow)
if (loadedWorkflow.initialMode === undefined) {
// Prefer the file's linearMode over the draft's since the file
@@ -805,11 +809,13 @@ export const useWorkflowService = () => {
}
trackIfEnteringApp(tempWorkflow)
const loadedWorkflow = await workflowStore.openWorkflow(tempWorkflow)
+ if (graphState !== app.rootGraphOrUndefined?.state) return
activateRunErrors(loadedWorkflow)
return
}
const loadedWorkflow = await workflowStore.openWorkflow(value)
+ if (graphState !== app.rootGraphOrUndefined?.state) return
activateRunErrors(loadedWorkflow)
if (shareId) {
loadedWorkflow.shareId = shareId
diff --git a/src/platform/workflow/management/stores/workflowStore.ts b/src/platform/workflow/management/stores/workflowStore.ts
index 025a2a2f8b6..ba98273d0d3 100644
--- a/src/platform/workflow/management/stores/workflowStore.ts
+++ b/src/platform/workflow/management/stores/workflowStore.ts
@@ -212,7 +212,11 @@ export const useWorkflowStore = defineStore('workflow', () => {
if (!openWorkflowPaths.value.includes(workflow.path)) {
openWorkflowPaths.value.push(workflow.path)
}
+ const graphState = comfyApp.rootGraphOrUndefined?.state
const loadedWorkflow = await workflow.load()
+ if (graphState !== comfyApp.rootGraphOrUndefined?.state) {
+ throw new DOMException('Workflow load was replaced', 'AbortError')
+ }
activeWorkflow.value = loadedWorkflow
comfyApp.canvas.bg_tint = loadedWorkflow.tintCanvasBg
diff --git a/src/renderer/extensions/vueNodes/components/LGraphNode.test.ts b/src/renderer/extensions/vueNodes/components/LGraphNode.test.ts
index f8aaa6b297d..ae30c043b5e 100644
--- a/src/renderer/extensions/vueNodes/components/LGraphNode.test.ts
+++ b/src/renderer/extensions/vueNodes/components/LGraphNode.test.ts
@@ -1,4 +1,4 @@
-import { render, screen } from '@testing-library/vue'
+import { fireEvent, render, screen } from '@testing-library/vue'
import { getActivePinia } from 'pinia'
import { beforeEach, describe, expect, it, vi } from 'vitest'
@@ -217,6 +217,7 @@ describe('LGraphNode', () => {
mockData.mockExecuting = false
mockData.mockLgraphNode = null
mockData.resizeCallback = null
+ app.dragOverNode = null
const canvasStore = useCanvasStore()
canvasStore.selectedNodeIds.clear()
@@ -763,6 +764,24 @@ describe('LGraphNode', () => {
})
describe('handleDrop', () => {
+ it('clears the native file target when another handler already consumed the drop', async () => {
+ mockData.mockLgraphNode = {
+ onDragOver: vi.fn(),
+ isSubgraphNode: () => false
+ }
+ app.dragOverNode = {
+ id: toNodeId('previous-node'),
+ onDragDrop: vi.fn(() => false)
+ }
+ const { container } = renderLGraphNode({ nodeData: mockNodeData })
+ const event = new Event('drop', { bubbles: true, cancelable: true })
+ event.preventDefault()
+
+ await fireEvent(getNodeRoot(container), event)
+
+ expect(app.dragOverNode).toBeNull()
+ })
+
it('should set app.dragOverNode and let event bubble', async () => {
mockData.mockLgraphNode = {
onDragOver: vi.fn(),
diff --git a/src/renderer/extensions/vueNodes/components/LGraphNode.vue b/src/renderer/extensions/vueNodes/components/LGraphNode.vue
index d46b77d8dbf..945dd0c5b45 100644
--- a/src/renderer/extensions/vueNodes/components/LGraphNode.vue
+++ b/src/renderer/extensions/vueNodes/components/LGraphNode.vue
@@ -770,8 +770,8 @@ function handleDragLeave() {
isDraggingOver.value = false
}
-function handleDrop() {
+function handleDrop(event: DragEvent) {
isDraggingOver.value = false
- app.dragOverNode = resolveLGraphNode()
+ app.dragOverNode = event.defaultPrevented ? null : resolveLGraphNode()
}
diff --git a/src/renderer/extensions/vueNodes/components/LGraphNodePreview.test.ts b/src/renderer/extensions/vueNodes/components/LGraphNodePreview.test.ts
index e9889098619..c60c662658f 100644
--- a/src/renderer/extensions/vueNodes/components/LGraphNodePreview.test.ts
+++ b/src/renderer/extensions/vueNodes/components/LGraphNodePreview.test.ts
@@ -9,6 +9,7 @@ import type { WidgetGridItem } from '@/renderer/extensions/vueNodes/types/widget
import type { ComfyNodeDef as ComfyNodeDefV2 } from '@/schemas/nodeDef/nodeDefSchemaV2'
import LGraphNodePreview from '@/renderer/extensions/vueNodes/components/LGraphNodePreview.vue'
import { fromPartial } from '@total-typescript/shoehorn'
+import type { WidgetValueBinding } from '@/utils/widgetBinding'
const WidgetGridProbe = {
props: ['processedWidgets'],
@@ -43,7 +44,7 @@ const nodeDef = fromPartial({
function renderedWidgets(
def: ComfyNodeDefV2,
- props: { widgetValues?: Record } = {}
+ props: { widgetValues?: readonly WidgetValueBinding[] } = {}
) {
render(LGraphNodePreview, {
props: { nodeDef: def, ...props },
@@ -63,7 +64,7 @@ function renderedWidgets(
}
function renderedComboWidget(
- props: { widgetValues?: Record } = {}
+ props: { widgetValues?: readonly WidgetValueBinding[] } = {}
) {
return renderedWidgets(nodeDef, props).find((w) => w.name === 'ckpt_name')
}
@@ -106,7 +107,9 @@ describe('LGraphNodePreview', () => {
it('leads the combo options with the provided widget value', () => {
const widget = renderedComboWidget({
- widgetValues: { ckpt_name: 'sd_xl_base_1.0.safetensors' }
+ widgetValues: [
+ { selector: 'ckpt_name', value: 'sd_xl_base_1.0.safetensors' }
+ ]
})
expect(widget?.options?.values).toEqual([
@@ -116,6 +119,28 @@ describe('LGraphNodePreview', () => {
])
})
+ it('previews a pattern-bound value only on the first matching widget', () => {
+ const widgets = renderedWidgets(
+ fromPartial({
+ name: 'MultiModel',
+ inputs: {
+ strength: { type: 'FLOAT', default: 0.5 },
+ model_a: { type: 'COMBO', options: ['A.safetensors'] },
+ model_b: { type: 'COMBO', options: ['B.safetensors'] }
+ }
+ }),
+ {
+ widgetValues: [{ selector: /^model_/, value: 'C.safetensors' }]
+ }
+ )
+
+ expect(widgets.map(({ name, value }) => ({ name, value }))).toEqual([
+ { name: 'strength', value: 0.5 },
+ { name: 'model_a', value: 'C.safetensors' },
+ { name: 'model_b', value: 'B.safetensors' }
+ ])
+ })
+
it('keeps the combo options untouched when no value is provided', () => {
const widget = renderedComboWidget()
@@ -123,7 +148,9 @@ describe('LGraphNodePreview', () => {
})
it('leads with an explicitly empty provided value', () => {
- const widget = renderedComboWidget({ widgetValues: { ckpt_name: '' } })
+ const widget = renderedComboWidget({
+ widgetValues: [{ selector: 'ckpt_name', value: '' }]
+ })
expect(widget?.value).toBe('')
expect(widget?.options?.values).toEqual([
diff --git a/src/renderer/extensions/vueNodes/components/LGraphNodePreview.vue b/src/renderer/extensions/vueNodes/components/LGraphNodePreview.vue
index 49e6002dfe4..d8869b8a36c 100644
--- a/src/renderer/extensions/vueNodes/components/LGraphNodePreview.vue
+++ b/src/renderer/extensions/vueNodes/components/LGraphNodePreview.vue
@@ -52,6 +52,8 @@ import { toNodeId } from '@/types/nodeId'
import type { NodeState } from '@/types/nodeState'
import type { WidgetValue } from '@/types/simplifiedWidget'
import { zeroUuid } from '@/utils/uuid'
+import { matchesWidgetName } from '@/utils/widgetBinding'
+import type { WidgetValueBinding } from '@/utils/widgetBinding'
import { cn } from '@comfyorg/tailwind-utils'
const {
@@ -61,7 +63,7 @@ const {
} = defineProps<{
nodeDef: ComfyNodeDefV2
position?: 'absolute' | 'relative'
- widgetValues?: Record
+ widgetValues?: readonly WidgetValueBinding[]
}>()
const widgetStore = useWidgetStore()
@@ -110,12 +112,26 @@ const nodeData = computed(() => ({
properties: {}
}))
+const widgetInputs = computed(() =>
+ Object.entries(nodeDef.inputs || {}).filter(([, input]) =>
+ widgetStore.inputIsWidget(input)
+ )
+)
+
+const resolvedWidgetValues = computed(() =>
+ Object.fromEntries(
+ (widgetValues ?? []).flatMap(({ selector, value }) => {
+ const input = widgetInputs.value.find(([name]) =>
+ matchesWidgetName(name, selector)
+ )
+ return input ? [[input[0], value]] : []
+ })
+ )
+)
+
const previewWidgets = computed(() =>
- Object.entries(nodeDef.inputs || {})
- .filter(
- ([, input]) =>
- widgetStore.inputIsWidget(input) && !input.hidden && !input.advanced
- )
+ widgetInputs.value
+ .filter(([, input]) => !input.hidden && !input.advanced)
.map(([name, input]) => {
const isDynamicCombo = input.type === 'COMFY_DYNAMICCOMBO_V3'
const comboValues = isDynamicCombo
@@ -123,7 +139,7 @@ const previewWidgets = computed(() =>
: input.type === 'COMBO' && Array.isArray(input.options)
? input.options
: undefined
- const leadValue = widgetValues?.[name]
+ const leadValue = resolvedWidgetValues.value[name]
const value = (leadValue ??
input.default ??
comboValues?.[0] ??
diff --git a/src/scripts/app.test.ts b/src/scripts/app.test.ts
index 226d296a1c3..2e3df9a794e 100644
--- a/src/scripts/app.test.ts
+++ b/src/scripts/app.test.ts
@@ -20,7 +20,7 @@ import {
onTestFinished,
vi
} from 'vitest'
-import { ref } from 'vue'
+import { markRaw, ref } from 'vue'
import { useLitegraphService } from '@/services/litegraphService'
import { useNodeDefStore } from '@/stores/nodeDefStore'
import { transformInputSpecV1ToV2 } from '@/schemas/nodeDef/migration'
@@ -53,6 +53,7 @@ import type { LoadedComfyWorkflow } from '@/platform/workflow/management/stores/
import { useWorkflowService } from '@/platform/workflow/core/services/workflowService'
import type { useWorkflowValidation } from '@/platform/workflow/validation/composables/useWorkflowValidation'
import { createMockChangeTracker } from '@/utils/__tests__/litegraphTestUtils'
+import { ChangeTracker } from '@/scripts/changeTracker'
import {
createTestCanvasElement,
createTestDragAndScale,
@@ -532,19 +533,41 @@ describe('ComfyApp', () => {
app.canvasElRef.value = document.createElement('canvas')
Reflect.set(app, 'rootGraphInternal', new LGraph())
const showDialog = vi.spyOn(useDialogStore(), 'showDialog')
- mockExtensionService.invokeExtensionsAsync.mockImplementation(
- async (hook: string) => {
- if (hook === 'beforeConfigureGraph') {
- throw new Error('bad extension')
- }
- }
+ const error = new Error('bad extension')
+ let releaseErrorHandling!: () => void
+ const errorHandling = new Promise((resolve) => {
+ releaseErrorHandling = resolve
+ })
+ vi.when(mockExtensionService.invokeExtensionsAsync)
+ .calledWith(
+ 'beforeConfigureGraph',
+ expect.anything(),
+ expect.anything()
+ )
+ .thenRejectOnce(error)
+ vi.when(mockExtensionService.invokeExtensionsAsync)
+ .calledWith('onGraphLoadError', error)
+ .thenReturnOnce(errorHandling)
+ const load = app.loadGraphData(
+ createWorkflowGraphData(),
+ false,
+ true,
+ null,
+ { workflowNavigationId: 9 }
)
-
- await expect(
- app.loadGraphData(createWorkflowGraphData(), false, true, null, {
- workflowNavigationId: 9
- })
- ).resolves.toBe(false)
+ try {
+ await vi.waitFor(() =>
+ expect(
+ mockExtensionService.invokeExtensionsAsync
+ ).toHaveBeenCalledWith('onGraphLoadError', error)
+ )
+ expect(ChangeTracker.isLoadingGraph).toBe(true)
+ } finally {
+ releaseErrorHandling()
+ await load
+ }
+ await expect(load).resolves.toBe(false)
+ expect(ChangeTracker.isLoadingGraph).toBe(false)
expect(showDialog).toHaveBeenCalledOnce()
expect(useSubgraphNavigationStore().updateHash).toHaveBeenCalledWith(
@@ -718,6 +741,349 @@ describe('ComfyApp', () => {
expect(closed).toHaveLength(opened.length)
})
+ it('does not assign a newer workflow graph to an Undo load waiting after configuration', async () => {
+ app.canvasElRef.value = document.createElement('canvas')
+ Reflect.set(app, 'rootGraphInternal', new LGraph())
+ const firstWorkflow = new ComfyWorkflow({
+ path: 'workflows/undo.json',
+ modified: 0,
+ size: 0
+ })
+ const saved = createWorkflowGraphData()
+ saved.extra = { marker: 'saved' }
+ const changed = structuredClone(saved)
+ changed.extra = { marker: 'changed' }
+ const firstTracker = new ChangeTracker(firstWorkflow, saved)
+ firstTracker.activeState = changed
+ firstTracker._restoringState = true
+ firstWorkflow.changeTracker = firstTracker
+ const secondWorkflow = new ComfyWorkflow({
+ path: 'workflows/other.json',
+ modified: 0,
+ size: 0
+ })
+ const other = createWorkflowGraphData()
+ other.extra = { marker: 'other' }
+ const secondTracker = new ChangeTracker(secondWorkflow, other)
+ secondWorkflow.changeTracker = secondTracker
+ mockWorkflowService.afterLoadNewGraph.mockImplementation(
+ async (
+ workflow: string | ComfyWorkflow | null,
+ state: ComfyWorkflowJSON
+ ) => {
+ assert(workflow instanceof ComfyWorkflow)
+ workflow.changeTracker?.reset(state)
+ }
+ )
+ let releasePending!: () => void
+ const pending = new Promise((resolve) => {
+ releasePending = resolve
+ })
+ vi.when(mockExtensionService.invokeExtensionsAsync)
+ .calledWith('afterConfigureGraph', expect.anything())
+ .thenReturnOnce(pending)
+
+ const undoLoad = app.loadGraphData(saved, false, false, firstWorkflow, {
+ skipAssetScans: true
+ })
+ await vi.waitFor(() =>
+ expect(mockExtensionService.invokeExtensionsAsync).toHaveBeenCalledWith(
+ 'afterConfigureGraph',
+ expect.anything()
+ )
+ )
+ await app.loadGraphData(other, false, false, secondWorkflow, {
+ skipAssetScans: true
+ })
+ try {
+ expect(ChangeTracker.isLoadingGraph).toBe(false)
+ } finally {
+ releasePending()
+ await undoLoad
+ }
+ await expect(undoLoad).resolves.toBeUndefined()
+
+ expect(firstTracker.activeState).toEqual(changed)
+ expect(firstTracker.initialState).toEqual(saved)
+ expect(secondTracker.activeState.extra).toMatchObject({ marker: 'other' })
+ expect(app.rootGraph.extra).toMatchObject({ marker: 'other' })
+ })
+
+ it.for(['activation', 'tracker restoration', 'afterLoadGraph'] as const)(
+ 'cancels an older restore overtaken during %s without replacing the newer workflow',
+ async (pauseAt) => {
+ app.canvasElRef.value = document.createElement('canvas')
+ const graph = new LGraph()
+ const previousGraph = singletonApp.rootGraphOrUndefined
+ const previousCanvas = singletonApp.canvas
+ onTestFinished(() => {
+ Reflect.set(singletonApp, 'rootGraphInternal', previousGraph)
+ singletonApp.canvas = previousCanvas
+ })
+ Reflect.set(app, 'rootGraphInternal', graph)
+ Reflect.set(singletonApp, 'rootGraphInternal', graph)
+ singletonApp.canvas = mockCanvas
+ Reflect.set(mockCanvas, 'ds', { scale: 1, offset: [0, 0] })
+ await useRealWorkflowService()
+ const workflowStore = useWorkflowStore()
+ vi.mocked(workflowStore.openWorkflow).mockRestore()
+ vi.mocked(workflowStore.isActive).mockRestore()
+
+ const saved = createWorkflowGraphData()
+ saved.extra = { marker: 'saved' }
+ const changed = structuredClone(saved)
+ changed.extra = { marker: 'changed' }
+ const firstWorkflow = markLoaded(
+ new ComfyWorkflow({
+ path: 'workflows/undo.json',
+ modified: 0,
+ size: 0
+ })
+ )
+ const firstTracker = markRaw(new ChangeTracker(firstWorkflow, saved))
+ firstTracker.activeState = changed
+ firstTracker._restoringState = true
+ firstWorkflow.changeTracker = firstTracker
+ const other = createWorkflowGraphData()
+ other.extra = { marker: 'other' }
+ const secondWorkflow = markLoaded(
+ new ComfyWorkflow({
+ path: 'workflows/other.json',
+ modified: 0,
+ size: 0
+ })
+ )
+ const secondTracker = markRaw(new ChangeTracker(secondWorkflow, other))
+ secondWorkflow.changeTracker = secondTracker
+ let releasePause!: () => void
+ const pause = new Promise((resolve) => {
+ releasePause = resolve
+ })
+ let reachedPause = false
+ if (pauseAt === 'activation') {
+ vi.spyOn(firstWorkflow, 'load').mockImplementationOnce(async () => {
+ reachedPause = true
+ await pause
+ return firstWorkflow
+ })
+ } else if (pauseAt === 'tracker restoration') {
+ const openWorkflow = vi
+ .mocked(workflowStore.openWorkflow)
+ .getMockImplementation()
+ assert(openWorkflow)
+ vi.mocked(workflowStore.openWorkflow).mockImplementation(
+ async (workflow) => {
+ const loaded = await openWorkflow(workflow)
+ if (workflow.path === firstWorkflow.path) {
+ reachedPause = true
+ await pause
+ }
+ return loaded
+ }
+ )
+ } else {
+ mockExtensionService.invokeExtensionsAsync.mockImplementation(
+ async (hook) => {
+ if (hook === 'afterLoadGraph' && !reachedPause) {
+ reachedPause = true
+ await pause
+ }
+ }
+ )
+ }
+
+ const olderLoad = app.loadGraphData(
+ saved,
+ false,
+ false,
+ firstWorkflow,
+ {
+ skipAssetScans: true
+ }
+ )
+ try {
+ await vi.waitFor(() => expect(reachedPause).toBe(true))
+ await app.loadGraphData(other, false, false, secondWorkflow, {
+ skipAssetScans: true
+ })
+ } finally {
+ releasePause()
+ }
+ const result = await olderLoad
+
+ expect(workflowStore.activeWorkflow?.path).toBe(secondWorkflow.path)
+ expect(workflowStore.activeWorkflow?.changeTracker).toBe(secondTracker)
+ expect(secondTracker.activeState.extra).toMatchObject({
+ marker: 'other'
+ })
+ expect(secondTracker.initialState.extra).toMatchObject({
+ marker: 'other'
+ })
+ expect(firstTracker.initialState).toEqual(saved)
+ expect(firstTracker.activeState.extra).toMatchObject({
+ marker: pauseAt === 'afterLoadGraph' ? 'saved' : 'changed'
+ })
+ expect(graph.extra).toMatchObject({ marker: 'other' })
+ expect(ChangeTracker.isLoadingGraph).toBe(false)
+ expect(result).toBeUndefined()
+ }
+ )
+
+ it('does not assign a cleared canvas to Undo while the newer workflow is still preparing', async () => {
+ app.canvasElRef.value = document.createElement('canvas')
+ Reflect.set(app, 'rootGraphInternal', new LGraph())
+ const firstWorkflow = new ComfyWorkflow({
+ path: 'workflows/undo.json',
+ modified: 0,
+ size: 0
+ })
+ const saved = createWorkflowGraphData()
+ saved.extra = { marker: 'saved' }
+ const changed = structuredClone(saved)
+ changed.extra = { marker: 'changed' }
+ const tracker = new ChangeTracker(firstWorkflow, saved)
+ tracker.activeState = changed
+ tracker._restoringState = true
+ firstWorkflow.changeTracker = tracker
+ const secondWorkflow = new ComfyWorkflow({
+ path: 'workflows/other.json',
+ modified: 0,
+ size: 0
+ })
+ const other = createWorkflowGraphData()
+ other.extra = { marker: 'other' }
+ mockWorkflowService.afterLoadNewGraph.mockImplementation(
+ async (
+ workflow: string | ComfyWorkflow | null,
+ state: ComfyWorkflowJSON
+ ) => {
+ assert(workflow instanceof ComfyWorkflow)
+ workflow.changeTracker?.reset(state)
+ }
+ )
+ let releaseAfterConfigure!: () => void
+ const afterConfigure = new Promise((resolve) => {
+ releaseAfterConfigure = resolve
+ })
+ vi.when(mockExtensionService.invokeExtensionsAsync)
+ .calledWith('afterConfigureGraph', expect.anything())
+ .thenReturnOnce(afterConfigure)
+
+ const undoLoad = app.loadGraphData(saved, false, false, firstWorkflow, {
+ skipAssetScans: true
+ })
+ await vi.waitFor(() =>
+ expect(mockExtensionService.invokeExtensionsAsync).toHaveBeenCalledWith(
+ 'afterConfigureGraph',
+ expect.anything()
+ )
+ )
+ let releaseBeforeConfigure!: () => void
+ const beforeConfigure = new Promise((resolve) => {
+ releaseBeforeConfigure = resolve
+ })
+ vi.when(mockExtensionService.invokeExtensionsAsync)
+ .calledWith(
+ 'beforeConfigureGraph',
+ expect.anything(),
+ expect.anything()
+ )
+ .thenReturnOnce(beforeConfigure)
+ const newerLoad = app.loadGraphData(other, true, false, secondWorkflow, {
+ skipAssetScans: true
+ })
+ try {
+ await vi.waitFor(() => expect(app.rootGraph.extra).toEqual({}))
+ releaseAfterConfigure()
+ await expect(undoLoad).resolves.toBeUndefined()
+ expect(ChangeTracker.isLoadingGraph).toBe(true)
+ expect(mockExtensionService.invokeExtensionsAsync).toHaveBeenCalledWith(
+ 'onGraphLoadError',
+ expect.objectContaining({ name: 'AbortError' })
+ )
+
+ expect(tracker.activeState).toEqual(changed)
+ expect(tracker.initialState).toEqual(saved)
+ } finally {
+ releaseAfterConfigure()
+ releaseBeforeConfigure()
+ await Promise.all([undoLoad, newerLoad])
+ }
+ expect(app.rootGraph.extra).toMatchObject({ marker: 'other' })
+ expect(ChangeTracker.isLoadingGraph).toBe(false)
+ })
+
+ it('allows capture after a newer workflow finishes while old resource scans remain pending', async () => {
+ app.canvasElRef.value = document.createElement('canvas')
+ Reflect.set(app, 'rootGraphInternal', new LGraph())
+ const oldGraph = createWorkflowGraphData()
+ oldGraph.extra = { marker: 'old' }
+ const currentGraph = createWorkflowGraphData()
+ currentGraph.extra = { marker: 'current' }
+ let releaseModels!: () => void
+ const modelsPending = new Promise((resolve) => {
+ releaseModels = resolve
+ })
+ vi.mocked(runMissingModelPipeline).mockImplementationOnce(async () => {
+ await modelsPending
+ return { missingModels: [], confirmedCandidates: [] }
+ })
+ const oldLoad = app.loadGraphData(oldGraph, false, false)
+ try {
+ await vi.waitFor(() =>
+ expect(runMissingModelPipeline).toHaveBeenCalledOnce()
+ )
+ await app.loadGraphData(currentGraph, false, false, null, {
+ skipAssetScans: true
+ })
+
+ expect(app.rootGraph.extra).toMatchObject({ marker: 'current' })
+ expect(ChangeTracker.isLoadingGraph).toBe(false)
+ } finally {
+ releaseModels()
+ await oldLoad
+ }
+ })
+
+ it('keeps a configured load when a newer configure fails without clearing it', async () => {
+ app.canvasElRef.value = document.createElement('canvas')
+ Reflect.set(app, 'rootGraphInternal', new LGraph())
+ const graph = createWorkflowGraphData()
+ graph.extra = { marker: 'configured' }
+ let releaseFirst!: () => void
+ const firstPending = new Promise((resolve) => {
+ releaseFirst = resolve
+ })
+ vi.when(mockExtensionService.invokeExtensionsAsync)
+ .calledWith('afterConfigureGraph', expect.anything())
+ .thenReturnOnce(firstPending)
+ const firstLoad = app.loadGraphData(graph, false, false, null, {
+ skipAssetScans: true
+ })
+ try {
+ await vi.waitFor(() =>
+ expect(
+ mockExtensionService.invokeExtensionsAsync
+ ).toHaveBeenCalledWith('afterConfigureGraph', expect.anything())
+ )
+ vi.spyOn(app.rootGraph, 'configure').mockImplementationOnce(() => {
+ throw new Error('Configuration failed before clearing')
+ })
+ await expect(
+ app.loadGraphData(createWorkflowGraphData(), false, false, null, {
+ skipAssetScans: true
+ })
+ ).resolves.toBe(false)
+ releaseFirst()
+
+ expect(await firstLoad).toBeTruthy()
+ expect(app.rootGraph.extra).toMatchObject({ marker: 'configured' })
+ } finally {
+ releaseFirst()
+ await firstLoad
+ }
+ })
+
it('lets an older valid load commit when its newer replacement fails', async () => {
app.canvasElRef.value = document.createElement('canvas')
Reflect.set(app, 'rootGraphInternal', new LGraph())
diff --git a/src/scripts/app.ts b/src/scripts/app.ts
index 7c9068c88ce..9621ce32940 100644
--- a/src/scripts/app.ts
+++ b/src/scripts/app.ts
@@ -401,6 +401,7 @@ export class ComfyApp {
private configuringGraphLevel: number = 0
private graphLoadSequence = 0
private committedGraphLoadSequence = 0
+ private readonly pendingGraphLoads = new Set()
private pendingCamera:
| { id: number; workflow: string | null | ComfyWorkflow }
| undefined
@@ -1332,6 +1333,13 @@ export class ComfyApp {
useWorkflowService().beforeLoadNewGraph(clean)
await useExtensionService().invokeExtensionsAsync('beforeLoadGraph')
+ this.pendingGraphLoads.add(loadId)
+ ChangeTracker.isLoadingGraph = true
+ const releaseGraphLoad = () => {
+ this.pendingGraphLoads.delete(loadId)
+ if (this.pendingGraphLoads.size === 0)
+ ChangeTracker.isLoadingGraph = false
+ }
let reset_invalid_values = false
const missingNodeTypes: MissingNodeType[] = []
try {
@@ -1484,7 +1492,11 @@ export class ComfyApp {
// below. Left unhandled, that would both reject silently and leak any
// suppression/loading-state a `beforeLoadGraph` listener opened for
// this load, since nothing ever notifies it the load ended.
- await this.reportGraphLoadFailure(error)
+ try {
+ await this.reportGraphLoadFailure(error)
+ } finally {
+ releaseGraphLoad()
+ }
void useSubgraphNavigationStore().updateHash(
'workflow-load',
workflowNavigationId
@@ -1526,7 +1538,6 @@ export class ComfyApp {
}
}
- ChangeTracker.isLoadingGraph = true
let activatedWorkflow: LoadedComfyWorkflow | undefined
let reconcileResourceErrors: (() => void) | undefined
let resourceScanLoadCompleted = false
@@ -1601,6 +1612,16 @@ export class ComfyApp {
// Resolves rather than throws: the close/replacement guards read this outcome.
return false
}
+ const configuredGraphState = this.rootGraph.state
+ const configuredLoadId = this.committedGraphLoadSequence
+ const isCurrentGraphLoad = () =>
+ configuredGraphState === this.rootGraph.state &&
+ configuredLoadId === this.committedGraphLoadSequence
+ const cancelReplacedLoad = () =>
+ useExtensionService().invokeExtensionsAsync(
+ 'onGraphLoadError',
+ new DOMException('Workflow load was replaced', 'AbortError')
+ )
const snapTo = LiteGraph.alwaysSnapToGrid
? this.rootGraph.getSnapToGridSize()
: 0
@@ -1665,6 +1686,10 @@ export class ComfyApp {
'afterConfigureGraph',
missingNodeTypes
)
+ if (!isCurrentGraphLoad()) {
+ await cancelReplacedLoad()
+ return undefined
+ }
const effectiveShareId =
shareId ??
@@ -1680,12 +1705,29 @@ export class ComfyApp {
}
useTelemetry()?.trackWorkflowOpened(telemetryPayload)
useTelemetry()?.trackWorkflowImported(telemetryPayload)
- await useWorkflowService().afterLoadNewGraph(
- workflow,
- this.rootGraph.serialize() as unknown as ComfyWorkflowJSON,
- effectiveShareId
- )
+ try {
+ await useWorkflowService().afterLoadNewGraph(
+ workflow,
+ this.rootGraph.serialize() as unknown as ComfyWorkflowJSON,
+ effectiveShareId
+ )
+ } catch (error) {
+ if (isCurrentGraphLoad()) throw error
+ }
+ if (!isCurrentGraphLoad()) {
+ await cancelReplacedLoad()
+ return undefined
+ }
await useExtensionService().invokeExtensionsAsync('afterLoadGraph')
+ if (!isCurrentGraphLoad()) {
+ await cancelReplacedLoad()
+ return undefined
+ }
+ for (const pendingLoadId of this.pendingGraphLoads) {
+ if (pendingLoadId <= loadId)
+ this.pendingGraphLoads.delete(pendingLoadId)
+ }
+ ChangeTracker.isLoadingGraph = this.pendingGraphLoads.size > 0
// Capture the workflow this load activated before the asset-scan awaits
// below can hand control back and let the user switch to another one.
activatedWorkflow = useWorkflowStore().activeWorkflow ?? undefined
@@ -1753,7 +1795,7 @@ export class ComfyApp {
'workflow-load',
workflowNavigationId
)
- ChangeTracker.isLoadingGraph = false
+ releaseGraphLoad()
// The retirement watcher skips transitions made during the load.
useExecutionErrorStore().retireResolvedMissingNodePromptError()
reconcileResourceErrors?.()
diff --git a/src/scripts/changeTracker.test.ts b/src/scripts/changeTracker.test.ts
index 6c2b00bff70..b6afb12baa4 100644
--- a/src/scripts/changeTracker.test.ts
+++ b/src/scripts/changeTracker.test.ts
@@ -2,7 +2,15 @@ import { fromPartial } from '@total-typescript/shoehorn'
import { useWorkflowStore } from '@/platform/workflow/management/stores/workflowStore'
import { useSubgraphNavigationStore } from '@/stores/subgraphNavigationStore'
import { useNodeOutputStore } from '@/stores/nodeOutputStore'
-import { beforeEach, describe, expect, it, onTestFinished, vi } from 'vitest'
+import {
+ assert,
+ beforeEach,
+ describe,
+ expect,
+ it,
+ onTestFinished,
+ vi
+} from 'vitest'
import { markRaw, ref } from 'vue'
vi.mock(import('@vueuse/router'), () => ({ useRouteHash: () => ref('') }))
@@ -189,6 +197,12 @@ describe('ChangeTracker', () => {
() => {}
)
app.rootGraph.subgraphs.clear()
+ vi.mocked(app.loadGraphData).mockImplementation(async (state) => {
+ const restored = await requireValidWorkflow(state)
+ useWorkflowStore().activeWorkflow?.changeTracker.reset(restored)
+ mockCanvasState(restored)
+ return true
+ })
})
describe('undoRedo', () => {
@@ -1336,6 +1350,535 @@ describe('ChangeTracker', () => {
})
describe('undo and redo', () => {
+ it('keeps Redo after Undo normalizes an interior node size', async () => {
+ const initial = await createSubgraphState()
+ const changed = structuredClone(initial)
+ getSubgraphDefinition(changed).nodes[0].widgets_values = [2]
+ const normalized = structuredClone(initial)
+ getSubgraphDefinition(normalized).nodes[0].size = [100, 178]
+ const tracker = createTracker(changed)
+ tracker.undoQueue.push(initial)
+ vi.mocked(app.loadGraphData).mockImplementationOnce(async () => {
+ tracker.reset(normalized)
+ mockCanvasState(normalized)
+ return true
+ })
+
+ await tracker.undo()
+ tracker.captureCanvasState()
+
+ expect(tracker.undoQueue).toEqual([])
+ expect(tracker.redoQueue).toEqual([changed])
+ expect(tracker.activeState).toEqual(normalized)
+ await tracker.redo()
+ expect(tracker.activeState).toEqual(changed)
+ expect(tracker.undoQueue).toEqual([normalized])
+ expect(tracker.redoQueue).toEqual([])
+ })
+
+ it('clears Redo for an intentional resize after normalized Undo', async () => {
+ const initial = createState(1)
+ const changed = structuredClone(initial)
+ changed.nodes[0].widgets_values = [2]
+ const normalized = structuredClone(initial)
+ normalized.nodes[0].size = [100, 178]
+ const tracker = createTracker(changed)
+ tracker.undoQueue.push(initial)
+ vi.mocked(app.loadGraphData).mockImplementationOnce(async () => {
+ tracker.reset(normalized)
+ mockCanvasState(normalized)
+ return true
+ })
+ await tracker.undo()
+ const resized = structuredClone(normalized)
+ resized.nodes[0].size = [350, 220]
+ mockCanvasState(resized)
+
+ tracker.captureCanvasState()
+
+ expect(tracker.redoQueue).toEqual([])
+ expect(tracker.undoQueue).toEqual([normalized])
+ expect(tracker.activeState).toEqual(resized)
+ await tracker.undo()
+ expect(tracker.activeState).toEqual(normalized)
+ await tracker.redo()
+ expect(tracker.activeState).toEqual(resized)
+ })
+
+ it.for(['undo', 'redo'] as const)(
+ 'keeps the restored workflow snapshot when another graph is configured during %s',
+ async (direction) => {
+ const restored = createState(1)
+ const changed = createState(2)
+ const normalized = structuredClone(restored)
+ normalized.nodes[0].size = [100, 178]
+ const tracker = createTracker(changed)
+ const history = { undo: tracker.undoQueue, redo: tracker.redoQueue }
+ history[direction].push(restored)
+ vi.mocked(app.loadGraphData).mockImplementationOnce(async () => {
+ tracker.reset(normalized)
+ mockCanvasState(createState(3))
+ return true
+ })
+
+ await tracker[direction]()
+
+ expect(tracker.activeState).toEqual(normalized)
+ expect(tracker.initialState).toEqual(changed)
+ expect(history[direction]).toEqual([])
+ }
+ )
+
+ it('keeps the normalized snapshot if another workflow becomes active during Undo', async () => {
+ const initial = createState(1)
+ const tracker = createTracker(createState(2))
+ tracker.undoQueue.push(initial)
+ const normalized = structuredClone(initial)
+ normalized.nodes[0].size = [100, 178]
+ const otherState = createState(3)
+ vi.mocked(app.loadGraphData).mockImplementationOnce(async () => {
+ tracker.reset(normalized)
+ createTracker(otherState)
+ mockCanvasState(otherState)
+ return true
+ })
+
+ await tracker.undo()
+
+ expect(tracker.activeState).toEqual(normalized)
+ expect(
+ useWorkflowStore().activeWorkflow?.changeTracker.activeState
+ ).toEqual(otherState)
+ })
+
+ it('keeps Redo reachable when a load rejects after committing the normalized Undo state', async () => {
+ const saved = createState(1)
+ saved.nodes[0].widgets_values = [1]
+ const changed = structuredClone(saved)
+ changed.nodes[0].widgets_values = [2]
+ const normalized = structuredClone(saved)
+ normalized.nodes[0].size = [100, 178]
+ const tracker = createTracker(saved)
+ tracker.activeState = changed
+ tracker.undoQueue.push(saved)
+ const workflow = useWorkflowStore().activeWorkflow
+ assert.exists(workflow)
+ workflow.isModified = true
+ vi.mocked(useWorkflowStore().getWorkflowByPath).mockReturnValue(workflow)
+ const error = new Error('Post-load asset scan rejected')
+ vi.mocked(app.loadGraphData).mockImplementationOnce(async () => {
+ tracker.reset(normalized)
+ mockCanvasState(normalized)
+ throw error
+ })
+
+ await expect(tracker.undo()).rejects.toThrow(error)
+
+ expect(tracker.activeState).toEqual(normalized)
+ expect(tracker.initialState).toEqual(normalized)
+ expect(tracker.undoQueue).toEqual([])
+ expect(tracker.redoQueue).toEqual([changed])
+ expect(workflow.isModified).toBe(false)
+ expect(tracker._restoringState).toBe(false)
+ await tracker.redo()
+ expect(tracker.activeState).toEqual(changed)
+ expect(workflow.isModified).toBe(true)
+ })
+
+ it('retains the Undo target when a same-workflow reload updates the tracker instead', async () => {
+ const saved = createState(1)
+ saved.nodes[0].widgets_values = [1]
+ const current = structuredClone(saved)
+ current.nodes[0].widgets_values = [2]
+ const reloaded = structuredClone(current)
+ reloaded.nodes[0].size = [100, 178]
+ const tracker = createTracker(saved)
+ tracker.activeState = current
+ tracker.undoQueue.push(saved)
+ const workflow = useWorkflowStore().activeWorkflow
+ assert.exists(workflow)
+ workflow.isModified = true
+ vi.mocked(useWorkflowStore().getWorkflowByPath).mockReturnValue(workflow)
+ vi.mocked(app.loadGraphData).mockImplementationOnce(async () => {
+ tracker.reset(reloaded)
+ mockCanvasState(reloaded)
+ return undefined
+ })
+
+ await tracker.undo()
+
+ expect(tracker.activeState).toEqual(reloaded)
+ expect(tracker.initialState).toEqual(saved)
+ expect(tracker.undoQueue).toEqual([saved])
+ expect(tracker.redoQueue).toEqual([])
+ expect(workflow.isModified).toBe(true)
+ expect(tracker._restoringState).toBe(false)
+ })
+
+ it('keeps Redo when a late load error follows normalization of an interior node size', async () => {
+ const saved = await createSubgraphState()
+ const changed = structuredClone(saved)
+ getSubgraphDefinition(changed).nodes[0].widgets_values = [2]
+ const normalized = structuredClone(saved)
+ getSubgraphDefinition(normalized).nodes[0].size = [100, 178]
+ const tracker = createTracker(saved)
+ tracker.activeState = changed
+ tracker.undoQueue.push(saved)
+ const error = new Error('Post-load asset scan rejected')
+ vi.mocked(app.loadGraphData).mockImplementationOnce(async () => {
+ tracker.reset(normalized)
+ mockCanvasState(normalized)
+ throw error
+ })
+
+ await expect(tracker.undo()).rejects.toThrow(error)
+
+ expect(tracker.activeState).toEqual(normalized)
+ expect(tracker.initialState).toEqual(normalized)
+ expect(tracker.undoQueue).toEqual([])
+ expect(tracker.redoQueue).toEqual([changed])
+ expect(tracker._restoringState).toBe(false)
+ })
+
+ it('retains the Undo target when an unrelated same-workflow reload precedes a late error', async () => {
+ const saved = createState(1)
+ saved.nodes[0].widgets_values = [1]
+ const current = structuredClone(saved)
+ current.nodes[0].widgets_values = [2]
+ const reloaded = structuredClone(current)
+ reloaded.nodes[0].size = [100, 178]
+ const tracker = createTracker(saved)
+ tracker.activeState = current
+ tracker.undoQueue.push(saved)
+ const workflow = useWorkflowStore().activeWorkflow
+ assert.exists(workflow)
+ workflow.isModified = true
+ vi.mocked(useWorkflowStore().getWorkflowByPath).mockReturnValue(workflow)
+ const error = new Error('Superseded Undo asset scan rejected')
+ vi.mocked(app.loadGraphData).mockImplementationOnce(async () => {
+ tracker.reset(reloaded)
+ mockCanvasState(reloaded)
+ throw error
+ })
+
+ await expect(tracker.undo()).rejects.toThrow(error)
+
+ expect(tracker.activeState).toEqual(reloaded)
+ expect(tracker.initialState).toEqual(saved)
+ expect(tracker.undoQueue).toEqual([saved])
+ expect(tracker.redoQueue).toEqual([])
+ expect(workflow.isModified).toBe(true)
+ expect(tracker._restoringState).toBe(false)
+ })
+
+ it('retains a resize Undo target when an unrelated reload changes only the node size', async () => {
+ const saved = createState(1)
+ const current = structuredClone(saved)
+ current.nodes[0].size = [400, 220]
+ const reloaded = structuredClone(current)
+ reloaded.nodes[0].size = [400, 260]
+ const tracker = createTracker(saved)
+ tracker.activeState = current
+ tracker.undoQueue.push(saved)
+ vi.mocked(app.loadGraphData).mockImplementationOnce(async () => {
+ tracker.reset(reloaded)
+ mockCanvasState(reloaded)
+ return undefined
+ })
+
+ await tracker.undo()
+
+ expect(tracker.activeState).toEqual(reloaded)
+ expect(tracker.initialState).toEqual(saved)
+ expect(tracker.undoQueue).toEqual([saved])
+ expect(tracker.redoQueue).toEqual([])
+ expect(tracker._restoringState).toBe(false)
+ })
+
+ it.for([
+ { direction: 'undo', reverse: 'redo', start: 3, end: 1 },
+ { direction: 'redo', reverse: 'undo', start: 1, end: 3 }
+ ] as const)(
+ 'applies both overlapping $direction requests',
+ async ({ direction, reverse, start, end }) => {
+ vi.useFakeTimers()
+ onTestFinished(() => {
+ vi.useRealTimers()
+ })
+ const current = createState(start)
+ const intermediate = createState(2)
+ const final = createState(end)
+ const tracker = createTracker(current)
+ const history = { undo: tracker.undoQueue, redo: tracker.redoQueue }
+ history[direction].push(final, intermediate)
+ const loadGraphData = vi
+ .mocked(app.loadGraphData)
+ .getMockImplementation()
+ assert.exists(loadGraphData)
+ vi.mocked(app.loadGraphData).mockImplementationOnce(async (...args) => {
+ await new Promise((resolve) => setTimeout(resolve, 5))
+ return loadGraphData(...args)
+ })
+
+ const requests = Promise.all([
+ tracker[direction](),
+ tracker[direction]()
+ ])
+ await vi.advanceTimersByTimeAsync(5)
+ await requests
+
+ expect(tracker.activeState).toEqual(final)
+ expect(history[direction]).toEqual([])
+ expect(history[reverse]).toEqual([current, intermediate])
+ expect(tracker._restoringState).toBe(false)
+ }
+ )
+
+ it.for([
+ { first: 'undo', second: 'redo' },
+ { first: 'redo', second: 'undo' }
+ ] as const)(
+ 'applies overlapping $first then $second requests in order',
+ async ({ first, second }) => {
+ vi.useFakeTimers()
+ onTestFinished(() => {
+ vi.useRealTimers()
+ })
+ const current = createState(3)
+ const previous = createState(2)
+ const tracker = createTracker(current)
+ const history = { undo: tracker.undoQueue, redo: tracker.redoQueue }
+ history[first].push(previous)
+ const loadGraphData = vi
+ .mocked(app.loadGraphData)
+ .getMockImplementation()
+ assert.exists(loadGraphData)
+ vi.mocked(app.loadGraphData).mockImplementationOnce(async (...args) => {
+ await new Promise((resolve) => setTimeout(resolve, 5))
+ return loadGraphData(...args)
+ })
+
+ const requests = Promise.all([tracker[first](), tracker[second]()])
+ await vi.advanceTimersByTimeAsync(5)
+ await requests
+
+ expect(tracker.activeState).toEqual(current)
+ expect(history[first]).toEqual([previous])
+ expect(history[second]).toEqual([])
+ expect(tracker._restoringState).toBe(false)
+ }
+ )
+
+ it.for([false, undefined])(
+ 'processes a queued Undo after the pending restore returns %s',
+ async (result) => {
+ vi.useFakeTimers()
+ onTestFinished(() => {
+ vi.useRealTimers()
+ })
+ const earlier = createState(1)
+ const previous = createState(2)
+ const current = createState(3)
+ const tracker = createTracker(current)
+ tracker.undoQueue.push(earlier, previous)
+ vi.mocked(app.loadGraphData).mockImplementationOnce(
+ () => new Promise((resolve) => setTimeout(() => resolve(result), 5))
+ )
+
+ const requests = Promise.all([tracker.undo(), tracker.undo()])
+ await vi.advanceTimersByTimeAsync(0)
+ expect(tracker.activeState).toEqual(current)
+ expect(tracker.undoQueue).toEqual([earlier])
+ expect(tracker.redoQueue).toEqual([])
+ await vi.advanceTimersByTimeAsync(5)
+ await requests
+
+ expect(tracker.activeState).toEqual(previous)
+ expect(tracker.undoQueue).toEqual([earlier])
+ expect(tracker.redoQueue).toEqual([current])
+ expect(tracker._restoringState).toBe(false)
+ }
+ )
+
+ it.for([
+ { direction: 'undo', reverse: 'redo' },
+ { direction: 'redo', reverse: 'undo' }
+ ] as const)(
+ 'processes a queued $direction after the pending restore rejects',
+ async ({ direction, reverse }) => {
+ const current = createState(3)
+ const previous = createState(2)
+ const tracker = createTracker(current)
+ const history = { undo: tracker.undoQueue, redo: tracker.redoQueue }
+ history[direction].push(previous)
+ const error = new Error('Workflow load rejected')
+ vi.mocked(app.loadGraphData).mockRejectedValueOnce(error)
+
+ const results = await Promise.allSettled([
+ tracker[direction](),
+ tracker[direction]()
+ ])
+
+ expect(results).toEqual([
+ { status: 'rejected', reason: error },
+ { status: 'fulfilled', value: undefined }
+ ])
+ expect(tracker.activeState).toEqual(previous)
+ expect(history[direction]).toEqual([])
+ expect(history[reverse]).toEqual([current])
+ expect(tracker._restoringState).toBe(false)
+ }
+ )
+
+ it('serializes distinct workflow requests after a pending Undo', async () => {
+ vi.useFakeTimers()
+ onTestFinished(() => {
+ vi.useRealTimers()
+ })
+ const earlier = createState(1)
+ const previous = createState(2)
+ const current = createState(3)
+ const firstSelection = createState(4)
+ const secondSelection = createState(5)
+ const firstSource = [firstSelection]
+ const secondSource = [secondSelection]
+ const tracker = createTracker(current)
+ tracker.undoQueue.push(earlier, previous)
+ let releasePending!: () => void
+ const pending = new Promise((resolve) => {
+ releasePending = resolve
+ })
+ vi.mocked(app.loadGraphData).mockImplementationOnce(async () => {
+ await pending
+ tracker.reset(previous)
+ mockCanvasState(previous)
+ return true
+ })
+
+ const undo = tracker.undo()
+ let selectionFinished = false
+ const firstRequest = tracker
+ .updateState(firstSource, tracker.undoQueue)
+ .then(() => {
+ selectionFinished = true
+ })
+ const secondRequest = tracker.updateState(secondSource, tracker.undoQueue)
+ try {
+ await vi.advanceTimersByTimeAsync(0)
+ expect(selectionFinished).toBe(false)
+ } finally {
+ releasePending()
+ await Promise.all([undo, firstRequest, secondRequest])
+ }
+
+ expect(tracker.activeState).toEqual(secondSelection)
+ expect(tracker.undoQueue).toEqual([earlier, previous, firstSelection])
+ expect(tracker.redoQueue).toEqual([current])
+ expect(firstSource).toEqual([])
+ expect(secondSource).toEqual([])
+ })
+
+ it.for([false, undefined])(
+ 'preserves state and history when restoration returns %s',
+ async (result) => {
+ const initial = createState(1)
+ const current = createState(2)
+ const tracker = createTracker(current)
+ tracker.undoQueue.push(initial)
+ vi.mocked(app.loadGraphData).mockImplementationOnce(async () => {
+ expect(tracker.activeState).toEqual(current)
+ mockCanvasState(createState(3))
+ return result
+ })
+
+ await tracker.undo()
+
+ expect(tracker.activeState).toEqual(current)
+ expect(tracker.undoQueue).toEqual([initial])
+ expect(tracker.redoQueue).toEqual([])
+ expect(api.dispatchCustomEvent).not.toHaveBeenCalled()
+ expect(tracker._restoringState).toBe(false)
+ }
+ )
+
+ it('preserves state and history when restoration rejects', async () => {
+ const initial = createState(1)
+ const current = createState(2)
+ const tracker = createTracker(current)
+ tracker.undoQueue.push(initial)
+ const error = new Error('Workflow load rejected')
+ vi.mocked(app.loadGraphData).mockRejectedValueOnce(error)
+
+ await expect(tracker.undo()).rejects.toThrow(error)
+
+ expect(tracker.activeState).toEqual(current)
+ expect(tracker.undoQueue).toEqual([initial])
+ expect(tracker.redoQueue).toEqual([])
+ expect(api.dispatchCustomEvent).not.toHaveBeenCalled()
+ expect(tracker._restoringState).toBe(false)
+ })
+
+ it.for([
+ {
+ direction: 'undo',
+ reverse: 'redo',
+ restoresSaved: true,
+ restoredValue: 1,
+ modified: false
+ },
+ {
+ direction: 'redo',
+ reverse: 'undo',
+ restoresSaved: true,
+ restoredValue: 1,
+ modified: false
+ },
+ {
+ direction: 'undo',
+ reverse: 'redo',
+ restoresSaved: false,
+ restoredValue: 3,
+ modified: true
+ }
+ ] as const)(
+ 'tracks unsaved changes after $direction normalizes a node (saved target: $restoresSaved)',
+ async ({ direction, reverse, restoredValue, modified }) => {
+ const saved = createState(1)
+ saved.nodes[0].widgets_values = [1]
+ const current = structuredClone(saved)
+ current.nodes[0].widgets_values = [2]
+ const restored = structuredClone(saved)
+ restored.nodes[0].widgets_values = [restoredValue]
+ const normalized = structuredClone(restored)
+ normalized.nodes[0].size = [100, 178]
+ const tracker = createTracker(saved)
+ tracker.activeState = current
+ const workflow = useWorkflowStore().activeWorkflow
+ assert.exists(workflow)
+ vi.mocked(useWorkflowStore().getWorkflowByPath).mockReturnValue(
+ workflow
+ )
+ const history = { undo: tracker.undoQueue, redo: tracker.redoQueue }
+ history[direction].push(restored)
+ vi.mocked(app.loadGraphData).mockImplementationOnce(async () => {
+ tracker.reset(normalized)
+ mockCanvasState(normalized)
+ return true
+ })
+
+ await tracker[direction]()
+ tracker.captureCanvasState()
+
+ expect(workflow.isModified).toBe(modified)
+ expect(tracker.activeState).toEqual(normalized)
+ expect(history[direction]).toEqual([])
+ expect(history[reverse]).toEqual([current])
+ await tracker[reverse]()
+ expect(tracker.activeState).toEqual(current)
+ expect(workflow.isModified).toBe(true)
+ }
+ )
+
it('dispatches autoQueueGraphChanged for a data change in both directions', async () => {
const initial = createState(1)
const changed = structuredClone(initial)
diff --git a/src/scripts/changeTracker.ts b/src/scripts/changeTracker.ts
index e936b33d2b5..64654c6d15d 100644
--- a/src/scripts/changeTracker.ts
+++ b/src/scripts/changeTracker.ts
@@ -8,6 +8,7 @@ import { LGraphCanvas, LiteGraph } from '@/lib/litegraph/src/litegraph'
import type { ComfyWorkflow } from '@/platform/workflow/management/stores/workflowStore'
import { useWorkflowStore } from '@/platform/workflow/management/stores/workflowStore'
import type { ComfyWorkflowJSON } from '@/platform/workflow/validation/schemas/workflowSchema'
+import { collectSubgraphDefinitions } from '@/platform/workflow/core/utils/workflowFlattening'
import type { ExecutedWsMessage } from '@/platform/remote/comfyui/execution/types'
import { useDialogStore } from '@/stores/dialogStore'
import { useExecutionStore } from '@/stores/executionStore'
@@ -30,6 +31,40 @@ function withoutExecutionOrder(nodes: ComfyWorkflowJSON['nodes']) {
return nodes.map((node) => _.omit(node, ['order']))
}
+function withNormalizedNodeSizes(state: ComfyWorkflowJSON): ComfyWorkflowJSON {
+ const comparable = clone(state)
+ const subgraphs = collectSubgraphDefinitions(
+ comparable.definitions?.subgraphs ?? []
+ )
+ const nodes = [
+ ...comparable.nodes,
+ ...subgraphs.flatMap((subgraph) => subgraph.nodes)
+ ]
+ for (const node of nodes) {
+ if ('size' in node) node.size = [0, 0]
+ }
+ return comparable
+}
+
+function matchesRestoredTarget(
+ actual: ComfyWorkflowJSON,
+ target: ComfyWorkflowJSON,
+ previous: ComfyWorkflowJSON
+): boolean {
+ if (ChangeTracker.graphEqual(actual, target)) return true
+ const comparableTarget = withNormalizedNodeSizes(target)
+ return (
+ ChangeTracker.graphEqual(
+ withNormalizedNodeSizes(actual),
+ comparableTarget
+ ) &&
+ !ChangeTracker.graphEqual(
+ comparableTarget,
+ withNormalizedNodeSizes(previous)
+ )
+ )
+}
+
function isActiveTracker(tracker: ChangeTracker): boolean {
return useWorkflowStore().activeWorkflow?.changeTracker === tracker
}
@@ -271,6 +306,7 @@ export class ChangeTracker {
* Whether the redo/undo restoring is in progress.
*/
_restoringState: boolean = false
+ private restoreChain?: Promise
ds?: { scale: number; offset: [number, number] }
nodeOutputs?: Partial>
@@ -296,10 +332,9 @@ export class ChangeTracker {
* Save the current state as the initial state.
*/
reset(state?: ComfyWorkflowJSON) {
- // Do not reset the state if we are restoring.
+ if (state) this.activeState = clone(state)
if (this._restoringState) return
- if (state) this.activeState = clone(state)
this.initialState = clone(this.activeState)
}
@@ -469,22 +504,49 @@ export class ChangeTracker {
}
async updateState(source: ComfyWorkflowJSON[], target: ComfyWorkflowJSON[]) {
- const prevState = source.pop()
- if (prevState) {
- const previousState = this.activeState
- target.push(previousState)
- this._restoringState = true
- try {
- await app.loadGraphData(prevState, false, false, this.workflow, {
- checkForRerouteMigration: false,
- silentAssetErrors: true
- })
- this.activeState = prevState
- this.updateModified(previousState)
- } finally {
- this._restoringState = false
+ const restore = async () => {
+ if (this._restoringState || source.length === 0) return
+ const prevState = source.pop()
+ if (prevState) {
+ const previousState = this.activeState
+ const restoresSavedState = ChangeTracker.graphEqual(
+ prevState,
+ this.initialState
+ )
+ let restored = false
+ this._restoringState = true
+ try {
+ const result = await app.loadGraphData(
+ prevState,
+ false,
+ false,
+ this.workflow,
+ {
+ checkForRerouteMigration: false,
+ silentAssetErrors: true
+ }
+ )
+ restored = result !== false && result !== undefined
+ } finally {
+ this._restoringState = false
+ restored ||=
+ !ChangeTracker.graphEqual(this.activeState, previousState) &&
+ matchesRestoredTarget(this.activeState, prevState, previousState)
+ if (restored) {
+ target.push(previousState)
+ if (restoresSavedState) this.initialState = clone(this.activeState)
+ } else {
+ source.push(prevState)
+ }
+ if (restored) this.updateModified(previousState)
+ }
}
}
+ this.restoreChain = (this.restoreChain ?? Promise.resolve()).then(
+ restore,
+ restore
+ )
+ return this.restoreChain
}
async undo() {
diff --git a/src/stores/modelToNodeStore.test.ts b/src/stores/modelToNodeStore.test.ts
index 22566c61ca9..a2f8cdf6198 100644
--- a/src/stores/modelToNodeStore.test.ts
+++ b/src/stores/modelToNodeStore.test.ts
@@ -45,6 +45,8 @@ const MOCK_NODE_NAMES = [
'ImageOnlyCheckpointLoader',
'LoraLoader',
'LoraLoaderModelOnly',
+ 'LoadLoraModel',
+ 'LoadLoraTextEncoder',
'VAELoader',
'ControlNetLoader',
'UNETLoader',
@@ -242,6 +244,51 @@ describe('useModelToNodeStore', () => {
)
})
+ it('does not treat an auto-loading provider as an asset widget', () => {
+ expect(useModelToNodeStore().isModelWidget('FL_ChatterboxVC', '')).toBe(
+ false
+ )
+ })
+
+ it('supports repeated model fields registered outside the default mappings', () => {
+ const store = useModelToNodeStore()
+ store.registerNodeProvider(
+ 'vae',
+ new ModelNodeProvider(createMockNodeDef('MultiVAE'), /^items\.\d+\.file$/)
+ )
+
+ expect(store.isModelWidget('MultiVAE', 'items.3.file')).toBe(true)
+ expect(store.isModelWidget('MultiVAE', 'items.3.strength')).toBe(false)
+ expect(store.getCategoryForNodeType('MultiVAE')).toBe('vae')
+ })
+
+ it('matches string selectors literally, including regex characters', () => {
+ const store = useModelToNodeStore()
+ store.quickRegister('vae', 'VAELoader', 'items.*.file')
+
+ expect(store.isModelWidget('VAELoader', 'items.*.file')).toBe(true)
+ expect(store.isModelWidget('VAELoader', 'items.3.file')).toBe(false)
+ })
+
+ it.for(['g', 'y'])(
+ 'keeps repeated widget checks stable with the %s flag',
+ (flags) => {
+ const store = useModelToNodeStore()
+ store.registerNodeProvider(
+ 'vae',
+ new ModelNodeProvider(
+ createMockNodeDef('MultiVAE'),
+ new RegExp(/^items\.\d+\.file$/, flags)
+ )
+ )
+
+ expect(store.isModelWidget('MultiVAE', 'items.1.file')).toBe(true)
+ expect(store.isModelWidget('MultiVAE', 'items.1.file')).toBe(true)
+ expect(store.isModelWidget('MultiVAE', 'items.2.file')).toBe(true)
+ expect(store.isModelWidget('MultiVAE', 'items.2.strength')).toBe(false)
+ }
+ )
+
describe('getAllNodeProviders', () => {
it('should return all providers for model type with multiple nodes', () => {
const modelToNodeStore = useModelToNodeStore()
@@ -264,7 +311,7 @@ describe('useModelToNodeStore', () => {
)
const loraProviders = modelToNodeStore.getAllNodeProviders('loras')
- expect(loraProviders).toHaveLength(3)
+ expect(loraProviders).toHaveLength(5)
expect(loraProviders).toEqual(
expect.arrayContaining([
expect.objectContaining({
diff --git a/src/stores/modelToNodeStore.ts b/src/stores/modelToNodeStore.ts
index 77695de20aa..1c8650687f4 100644
--- a/src/stores/modelToNodeStore.ts
+++ b/src/stores/modelToNodeStore.ts
@@ -4,16 +4,17 @@ import { computed, ref } from 'vue'
import { MODEL_NODE_MAPPINGS } from '@/platform/assets/mappings/modelNodeMappings'
import type { ComfyNodeDefImpl } from '@/stores/nodeDefStore'
import { useNodeDefStore } from '@/stores/nodeDefStore'
+import { matchesWidgetName } from '@/utils/widgetBinding'
/** Helper class that defines how to construct a node from a model. */
export class ModelNodeProvider {
/** The node definition to use for this model. */
public nodeDef: ComfyNodeDefImpl
- /** The node input key for where to insert the model name. */
- public key: string
+ /** The input name or pattern used to select the model widget. */
+ public key: string | RegExp
- constructor(nodeDef: ComfyNodeDefImpl, key: string) {
+ constructor(nodeDef: ComfyNodeDefImpl, key: string | RegExp) {
this.nodeDef = nodeDef
this.key = key
}
@@ -25,15 +26,16 @@ export const useModelToNodeStore = defineStore('modelToNode', () => {
const nodeDefStore = useNodeDefStore()
const haveDefaultsLoaded = ref(false)
- /** Internal computed for reactive caching of registered node types */
- const registeredNodeTypes = computed>(() => {
- return Object.fromEntries(
+ const registeredNodeTypes = computed<
+ Partial>
+ >(() =>
+ Object.fromEntries(
Object.values(modelToNodeMap.value)
.filter((providers) => providers !== undefined)
.flat()
.map((provider) => [provider.nodeDef.name, provider.key])
)
- })
+ )
/** Internal computed for efficient reverse lookup: nodeType -> category */
const nodeTypeToCategory = computed(() => {
@@ -51,11 +53,16 @@ export const useModelToNodeStore = defineStore('modelToNode', () => {
})
/** Get set of all registered node types for efficient lookup */
- function getRegisteredNodeTypes(): Record {
+ function getRegisteredNodeTypes(): Partial> {
registerDefaults()
return registeredNodeTypes.value
}
+ function isModelWidget(nodeType: string, widgetName: string): boolean {
+ const key = getRegisteredNodeTypes()[nodeType]
+ return key !== undefined && matchesWidgetName(widgetName, key)
+ }
+
/**
* Get the category for a given node type.
* Performs efficient O(1) lookup using cached reverse map.
@@ -125,7 +132,9 @@ export const useModelToNodeStore = defineStore('modelToNode', () => {
*/
function registerNodeProvider(
modelType: string,
- nodeProvider: ModelNodeProvider | { nodeDef: undefined; key: string }
+ nodeProvider:
+ | ModelNodeProvider
+ | { nodeDef: undefined; key: string | RegExp }
) {
registerDefaults()
if (!nodeProvider.nodeDef) return
@@ -138,7 +147,11 @@ export const useModelToNodeStore = defineStore('modelToNode', () => {
* @param nodeClass The node class name to register.
* @param key The key to use for the node input.
*/
- function quickRegister(modelType: string, nodeClass: string, key: string) {
+ function quickRegister(
+ modelType: string,
+ nodeClass: string,
+ key: string | RegExp
+ ) {
registerNodeProvider(
modelType,
new ModelNodeProvider(nodeDefStore.nodeDefsByName[nodeClass], key)
@@ -162,6 +175,7 @@ export const useModelToNodeStore = defineStore('modelToNode', () => {
return {
modelToNodeMap,
getRegisteredNodeTypes,
+ isModelWidget,
getCategoryForNodeType,
getNodeProvider,
getAllNodeProviders,
diff --git a/src/utils/widgetBinding.ts b/src/utils/widgetBinding.ts
new file mode 100644
index 00000000000..13d96408cbd
--- /dev/null
+++ b/src/utils/widgetBinding.ts
@@ -0,0 +1,16 @@
+export interface WidgetValueBinding {
+ selector: string | RegExp
+ value: string
+}
+
+export function matchesWidgetName(
+ name: string,
+ selector: string | RegExp
+): boolean {
+ return (
+ name !== '' &&
+ (typeof selector === 'string'
+ ? name === selector
+ : name.search(selector) !== -1)
+ )
+}