From 4a98a02b017e153f3c18dea6909a53e2eac5a194 Mon Sep 17 00:00:00 2001
From: jaeone lee <89377375+jaeone94@users.noreply.github.com>
Date: Sun, 11 Oct 2026 15:27:48 +0000
Subject: [PATCH 1/6] fix: disconnect orphaned DynamicGroup host inputs
(#20708)
## ELI5
Deleting a repeated row should also remove the wires that only fed that
row. When the row was exposed through nested subgraphs, a wire from an
ordinary outer node could remain after its destination disappeared. This
disconnects that unused wire while preserving connections with another
internal consumer.
## Summary
- Disconnect orphaned host inputs regardless of whether their source is
an ordinary node or a subgraph boundary.
- Continue cleanup through nested boundaries only for subgraph-input
links.
- Cover deletion of a middle row across two promotion boundaries,
preservation of the next row, and preservation of a shared input with
another consumer.
## Verification
- Regression on unmodified production: 43 passed, 1 failed because the
deleted row's outer wire remained.
- With the fix: `pnpm test:unit
src/core/graph/widgets/dynamicGroupWidget.test.ts --maxWorkers=1
--no-file-parallelism`, 44 passed.
- Pre-commit formatting, lint, and app typecheck, plus pre-push checks,
passed.
- Real-backend browser coverage belongs to #17510 (test: verify
DynamicGroup in a dedicated backend E2E job) and #20307 (test: validate
native LoRA stack assets and execution). Those suites pin a Core
revision containing the private DynamicGroup contract because the
default CI image does not provide the test nodes. This PR keeps the
topology regression at the unit level and does not add another temporary
backend override.
## Provenance
- **Authored by:** interactive session
- **Verified:** the targeted regression suite and repository pre-commit
checks above.
- **Deviations:** dedicated browser integration remains in the existing
E2E follow-up work.
(cherry picked from commit f9684f1a4a35550debd48e5db34d56c4772b33ad)
---
.../graph/widgets/dynamicGroupWidget.test.ts | 74 ++++++++++++++++++-
src/core/graph/widgets/dynamicGroupWidget.ts | 5 +-
2 files changed, 76 insertions(+), 3 deletions(-)
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)
}
}
From ee536b4323b959eeb7d28ccf510d1bc3b3d40519 Mon Sep 17 00:00:00 2001
From: jaeone lee <89377375+jaeone94@users.noreply.github.com>
Date: Tue, 13 Oct 2026 01:34:24 +0000
Subject: [PATCH 2/6] fix: receive model library drops on Vue nodes (#20540)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
Dragging a model onto an existing Nodes 2.0 loader now updates that
loader. Dropping onto empty canvas continues to create a loader.
Found while validating #20307 — test: validate native LoRA stack assets
and execution, and reproduced with the stock Checkpoint loader. The
model assignment logic already handles existing nodes, but its drop
target was only the canvas element; Vue node content is a sibling and
never reached that handler.
- Register the existing drop handler on the canvas and the existing Vue
TransformPane separately. Sidebar and toolbar UI remain outside those
targets.
- Preserve model-to-widget selection and node creation behavior. The
canvas keeps its original DOM parent, preserving legacy touch listeners,
dialog stacking, and resize callers.
- Add real drag E2E coverage for existing-node assignment and
empty-canvas creation using a single stock loader fixture.
- **Authored by:** interactive session
- **Verified:** Targeted model-library Playwright cases: existing-node
assignment failed before the fix while empty-canvas creation passed;
both passed after. The two existing `logicalCanvasSizing.spec.ts` cases
also passed. All four touched unit suites passed (57 tests) after the
lifecycle and native-drop handoff corrections. A new title-editor touch
regression fails with the wrapper and passes with the original canvas
parent. App/browser typechecks and staged lint/format checks passed
through the commit hook; pre-push Knip and Fallow also passed.
With both independent fixes applied locally to #20307 — test: validate
native LoRA stack assets and execution, the two previously failing
scenarios passed: model drop followed by native execution, and a
two-level promoted toggle edited after draft reload. No backend pin is
needed for this PR’s stock-node regression tests.
- [x] Drop a model on an existing Vue Checkpoint loader; check the
filename and unchanged node count.
- [x] Drop a model on empty canvas; check the new loader and selected
filename.
- [x] Check existing canvas sizing coverage at DPR 2.
Removed the extra drop wrapper after Cursor identified its effect on
canvas-parent touch listeners and LiteGraph dialog placement. Both drop
targets reuse the existing handler; model selection and hit testing are
unchanged.
The conditional Vue pane appears after GraphCanvas mounts. The existing
drop-target composable now watches the element, registers a late target,
releases a replaced or removed target, and disposes the current
registration on unmount. Two new actual-composable lifecycle regressions
fail before this correction and pass after it. Existing static targets
and the canvas parent stay supported.
Consumed pragmatic drops now also clear a stale native drag target. A
regression fails before the correction and passes after it; unhandled
native drops still hand off to the current node.
(cherry picked from commit 495879f111705e62886bb244c8b8858f8bee6d91)
---
.../assets/inputs/checkpoint_loader.json | 49 ++++++++++
.../tests/sidebar/modelLibrary.spec.ts | 64 ++++++++++++
src/components/graph/GraphCanvas.test.ts | 43 +++++++-
src/components/graph/GraphCanvas.vue | 8 ++
src/composables/useCanvasDrop.ts | 4 +-
.../usePragmaticDragAndDrop.test.ts | 98 +++++++++++++++++++
src/composables/usePragmaticDragAndDrop.ts | 20 ++--
.../vueNodes/components/LGraphNode.test.ts | 19 ++++
.../vueNodes/components/LGraphNode.vue | 4 +-
9 files changed, 292 insertions(+), 17 deletions(-)
create mode 100644 browser_tests/assets/inputs/checkpoint_loader.json
create mode 100644 src/composables/usePragmaticDragAndDrop.test.ts
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/src/components/graph/GraphCanvas.test.ts b/src/components/graph/GraphCanvas.test.ts
index 1ad5246b7cf..01ad69ad33c 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,35 @@ 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: '' }
+ })
+ // oxlint-disable-next-line testing-library/no-node-access -- Extensions use this canvas ID.
+ const canvas = document.getElementById('graph-canvas')
+ assert.exists(canvas)
+ // oxlint-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) => {
+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) => {
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/renderer/extensions/vueNodes/components/LGraphNode.test.ts b/src/renderer/extensions/vueNodes/components/LGraphNode.test.ts
index f8aaa6b297d..4800f430752 100644
--- a/src/renderer/extensions/vueNodes/components/LGraphNode.test.ts
+++ b/src/renderer/extensions/vueNodes/components/LGraphNode.test.ts
@@ -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()
}
From c5fd69e36329868685fc5dc9f6523a1fd1b5d13d Mon Sep 17 00:00:00 2001
From: jaeone lee <89377375+jaeone94@users.noreply.github.com>
Date: Mon, 12 Oct 2026 22:38:50 +0000
Subject: [PATCH 3/6] fix: preserve redo after restored node size normalization
(#20294)
Undo should leave Redo available when a restored node grows
automatically to fit its widgets. A deliberate edit should still clear
Redo. If another workflow finishes opening meanwhile, the older load
must leave that workflow and its history alone.
Undo can restore a node at a larger size so its widgets fit. The next
navigation click previously treated that automatic adjustment as a user
edit and erased Redo. Retain the normalized live snapshot while
preserving the saved baseline and normal history behavior for
intentional edits.
Fixes #20285 ([Redo history is cleared after Undo normalizes node
size](https://github.com/Comfy-Org/ComfyUI_frontend/issues/20285)).
- Preserve history during preload persistence and recover a consumed
entry when restoration never applies. If restoration already applied
before a later error, keep the previous state reachable through the
reverse queue.
- Serialize every history request, including consecutive Undo or Redo
presses. Each request retains its own result; a failed restore does not
reject the request queued behind it.
- Check graph state and the committed load sequence after configuration,
workflow activation, and the final extension hook. A superseded load
cannot return the newer workflow as its own result.
- Check replacement before changing the active workflow in the store,
and again before resetting a tracker or restoring previews in the
service. The app handles superseded activation as cancellation. Public
arguments, return conventions, and loader options remain unchanged.
- Keep capture suppressed during preparation and activation. Release
obsolete markers when a newer workflow completes, while preserving
suppression for newer preparation still in progress.
- [Earlier
CI](https://github.com/Comfy-Org/ComfyUI_frontend/actions/runs/38101318782)
passed on `37e74c2da2`, including all required checks. The browser
report records **2,261 passed, 0 failed**.
- **435 passed, 1 existing skipped** after the queued-request
correction, one worker, across the App, ChangeTracker, workflow service,
and workflow store suites.
- Queued-request local red/green: six regressions fail before this
correction (consecutive Undo/Redo and requests following refusal or
rejection); two crossed-direction controls pass. After the fix, all
eight cases pass. The delay uses fake timers, with no timing sleeps or
new test helper. New-head CI will rerun after the push.
- Three fresh activation regressions fail with production code restored
to `a0658b8773` and pass with this fix: pause the workflow load before
activation; pause after activation but before tracker restoration; pause
`afterLoadGraph`. Complete a newer load, then release the older one.
Verify the newer workflow, tracker, saved baseline, and graph remain
intact and the older load returns cancellation. These are local
red/green results, not a claim of CI red/green proof.
- Existing coverage also checks saved-state normalization, intentional
resizing, draft persistence, late errors, replacement during
configuration/preparation, and overlapping history operations.
The KSampler E2E in `ecsBridgeHistory.spec.ts` renames KSampler, changes
`steps` from 20 to 21, undoes to 20, clicks the root breadcrumb, and
redoes to 21. It failed on
[8ae1b91f5b](https://github.com/Comfy-Org/ComfyUI_frontend/commit/8ae1b91f5bd3ad15b926953998edd07c287a4ed5),
before [#17441: feat: support DynamicGroup widget
inputs](https://github.com/Comfy-Org/ComfyUI_frontend/pull/17441), and
also failed with history code restored from
[6bf649f930](https://github.com/Comfy-Org/ComfyUI_frontend/commit/6bf649f9305f2a5ed0d918b8d4d489dfbc664409).
Previous local verification with the fix passed all three cases in that
spec and the image-preview compatibility case. The [earlier changed-spec
recording
run](https://github.com/Comfy-Org/ComfyUI_frontend/actions/runs/38101318502)
passed all **11 cases** across both changed browser specs, including
this KSampler regression and image-preview Undo/Redo.
Whole-canvas rollback after partial configuration, retracting
already-published Agent document operations, and exhaustive asset-scan
interleavings remain separate loader work. This PR adds no feature flag
or backend SHA override.
- **Authored by:** interactive session.
- **Verified:** local historical KSampler red/green, fresh activation
red/green, and the four related unit suites above. The normal commit
hook passed for the queued-request correction. The earlier CI and
changed-spec recording results above predate that correction; its
new-head CI is pending.
- **Deviations:** no CI red/green or whole-canvas/document rollback
claim.
(cherry picked from commit a2ad2089d99df5ba77446e1ae7f2229ecd18f86c)
---
.../interactions/node/imagePreview.spec.ts | 17 +
.../vueNodes/layout/ecsBridgeHistory.spec.ts | 35 ++
.../core/services/workflowService.test.ts | 29 +
.../workflow/core/services/workflowService.ts | 6 +
.../management/stores/workflowStore.ts | 4 +
src/scripts/app.test.ts | 392 ++++++++++++-
src/scripts/app.ts | 58 +-
src/scripts/changeTracker.test.ts | 545 +++++++++++++++++-
src/scripts/changeTracker.ts | 94 ++-
9 files changed, 1142 insertions(+), 38 deletions(-)
diff --git a/browser_tests/tests/vueNodes/interactions/node/imagePreview.spec.ts b/browser_tests/tests/vueNodes/interactions/node/imagePreview.spec.ts
index 54bc2bbe702..4c241d6787f 100644
--- a/browser_tests/tests/vueNodes/interactions/node/imagePreview.spec.ts
+++ b/browser_tests/tests/vueNodes/interactions/node/imagePreview.spec.ts
@@ -40,6 +40,23 @@ test.describe('Vue Nodes Image Preview', { tag: '@vue-nodes' }, () => {
}
}
+ test('restores an image preview with Undo and removes it again with Redo', async ({
+ comfyPage
+ }) => {
+ const node = await loadImageOnNode(comfyPage)
+ await node.title.click()
+ await comfyPage.keyboard.delete()
+ await expect(comfyPage.vueNodes.nodes).toHaveCount(0)
+
+ await comfyPage.keyboard.undo()
+ await node.waitForImageLoaded('image64x64.webp')
+ await expect(node.imagePreview).toContainText('64 x 64')
+ await node.title.click()
+
+ await comfyPage.keyboard.redo()
+ await expect(comfyPage.vueNodes.nodes).toHaveCount(0)
+ })
+
test('opens mask editor from image preview button', async ({ comfyPage }) => {
const { imagePreview } = await loadImageOnNode(comfyPage)
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/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..4c8bb7fa020 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 = useApp().rootGraphOrUndefined?.state
await activateLoadedWorkflow(value, workflowData, shareId)
+ if (graphState !== useApp().rootGraphOrUndefined?.state) return
useNodeOutputStore().restorePreviewsForWorkflow(
useWorkspaceStore().workflow.activeWorkflow?.path
)
@@ -720,6 +722,7 @@ export const useWorkflowService = () => {
workflowData: ComfyWorkflowJSON,
shareId?: string
) => {
+ const graphState = useApp().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 !== useApp().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 !== useApp().rootGraphOrUndefined?.state) return
activateRunErrors(loadedWorkflow)
return
}
const loadedWorkflow = await workflowStore.openWorkflow(value)
+ if (graphState !== useApp().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..db683774d2b 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 = useApp().rootGraphOrUndefined?.state
const loadedWorkflow = await workflow.load()
+ if (graphState !== useApp().rootGraphOrUndefined?.state) {
+ throw new DOMException('Workflow load was replaced', 'AbortError')
+ }
activeWorkflow.value = loadedWorkflow
comfyApp.canvas.bg_tint = loadedWorkflow.tintCanvasBg
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() {
From ea2fb1b47a2b9ccbbc31ec254c6c9518bec69d1d Mon Sep 17 00:00:00 2001
From: jaeone lee <89377375+jaeone94@users.noreply.github.com>
Date: Fri, 9 Oct 2026 18:42:07 +0000
Subject: [PATCH 4/6] feat: support dynamic asset widgets for native LoRA
stacks (#20305)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
## ELI5
Repeated LoRA rows should each offer the same model picker as a normal
LoRA loader. A model input can now be registered by an exact widget name
or a name pattern, including the two native LoRA stack nodes.
## Motivation
The native loaders repeat filename inputs as `loras..lora_name`.
An exact registration only covers one row. Listing every index would
couple the frontend to a backend row limit and miss rows restored from
an over-limit workflow.
## Summary
- Keep three-field model mappings: `[modelDirectory, nodeClass, string |
RegExp]`. Register `LoadLoraModel` and `LoadLoraTextEncoder` with one
shared filename pattern, without a separate row-zero key.
- Use one matcher for picker eligibility, model drops, and preview value
bindings. Strings match literally; regex checks remain stable with `g`
and `y`. Empty widget names remain ineligible.
- Carry the selector and filename through model drags, then fill the
first matching widget on the created or existing node. Resolve preview
bindings when their inputs change before looking values up by name.
- Include repeated filename inputs in agent deployment briefs for both
named and positional workflow values, using the same matcher as the
asset UI.
- Preserve the Cloud-only picker gate and existing category/provider
selection. The registrations become available when the backend exposes
the node types; no separate feature flag is added.
## Drop behavior
Model drops fill the first matching widget in node order. They do not
target the hovered row, distribute multiple files among rows, or create
missing rows. Repeated drops may replace the same widget's value. This
is the current node-level drop limitation. Clicking a row's asset picker
still edits that specific row. Expanding DynamicGroup rows in drag
previews is separate work.
## Extension migration notes
Existing string registrations and empty auto-load keys keep their
behavior. A repeated filename registration can use
`quickRegister('loras', 'MyLoader', /^items\.\d+\.filename$/)`; every
matching widget gets picker eligibility, while a model drop fills only
the first match. Asset categories are still selected per node type, so
this does not add per-widget categories.
Code importing the internal drag composable or preview component must
change `widgetValues: { filename: value }` to `widgetValues: [{
selector: 'filename', value }]`. `ModelNodeProvider.key` and
`getRegisteredNodeTypes()` entries can now be `RegExp`; use
`isModelWidget(nodeType, widgetName)` for eligibility instead of
comparing a widget name with the selector. Graph serialization, widget
names, callbacks, and `node.widgets` layout are unchanged.
## Reviewer context
- **Type:** Feature, dynamic asset input matching with native LoRA
loaders as its first consumers.
- **Slots into:** [Comfy-Org/ComfyUI#16309: feat: add native LoRA stack
loader nodes](https://github.com/Comfy-Org/ComfyUI/pull/16309). [#20307:
test: validate native LoRA stack assets and
execution](https://github.com/Comfy-Org/ComfyUI_frontend/pull/20307) is
the child integration PR, including asset selection and real CPU prompt
execution against the pinned native backend. Cloud model preparation
remains separate rollout work.
## Test plan
- Check picker eligibility for both native loaders across row indices
and after row removal/renumbering.
- Check static loaders, auto-loading providers, and OSS combo widgets
retain their behavior.
- Drop a model onto a node with multiple matching widgets and verify
only the first changes. Check new-node placement, preview values, and
the warning when placement has no matching widget.
## Provenance
- **Authored by:** interactive session
- **Verified:** Latest main merge: 231 targeted unit tests passed across
model binding/placement, sidebar/preview, and agent-handoff/build-input
suites (single worker). The named LoRA model-list regression failed
before the handoff adaptation and passed after. Commit hooks passed
formatting/lint and all selected project typechecks; pre-push
Knip/Fallow passed. Earlier selector implementation was also verified
red→green against the previous implementation.
- **Deviations:** The child Native LoRA E2E branch is being refreshed
separately against the merged backend. Real Cloud model preparation and
execution still require staging QA.
(cherry picked from commit 47d37deed8a1117848886467c8baefeac4cd9ddd)
---
.../interactions/node/imagePreview.spec.ts | 17 -----
.../tabs/ModelLibrarySidebarTab.test.ts | 2 +-
.../node/startModelNodeDragFromAsset.test.ts | 8 +-
.../node/startModelNodeDragFromAsset.ts | 4 +-
.../node/useNodeDragToCanvas.test.ts | 60 ++++++++++++++-
src/composables/node/useNodeDragToCanvas.ts | 20 +++--
src/composables/useCanvasDrop.test.ts | 76 +++++++++++++++----
src/composables/useCanvasDrop.ts | 8 +-
.../assets/mappings/modelNodeMappings.ts | 15 +++-
.../assets/services/assetService.test.ts | 59 ++++++++++----
src/platform/assets/services/assetService.ts | 4 +-
.../components/LGraphNodePreview.test.ts | 35 ++++++++-
.../vueNodes/components/LGraphNodePreview.vue | 30 ++++++--
src/stores/modelToNodeStore.test.ts | 49 +++++++++++-
src/stores/modelToNodeStore.ts | 34 ++++++---
src/utils/widgetBinding.ts | 16 ++++
16 files changed, 345 insertions(+), 92 deletions(-)
create mode 100644 src/utils/widgetBinding.ts
diff --git a/browser_tests/tests/vueNodes/interactions/node/imagePreview.spec.ts b/browser_tests/tests/vueNodes/interactions/node/imagePreview.spec.ts
index 4c241d6787f..54bc2bbe702 100644
--- a/browser_tests/tests/vueNodes/interactions/node/imagePreview.spec.ts
+++ b/browser_tests/tests/vueNodes/interactions/node/imagePreview.spec.ts
@@ -40,23 +40,6 @@ test.describe('Vue Nodes Image Preview', { tag: '@vue-nodes' }, () => {
}
}
- test('restores an image preview with Undo and removes it again with Redo', async ({
- comfyPage
- }) => {
- const node = await loadImageOnNode(comfyPage)
- await node.title.click()
- await comfyPage.keyboard.delete()
- await expect(comfyPage.vueNodes.nodes).toHaveCount(0)
-
- await comfyPage.keyboard.undo()
- await node.waitForImageLoaded('image64x64.webp')
- await expect(node.imagePreview).toContainText('64 x 64')
- await node.title.click()
-
- await comfyPage.keyboard.redo()
- await expect(comfyPage.vueNodes.nodes).toHaveCount(0)
- })
-
test('opens mask editor from image preview button', async ({ comfyPage }) => {
const { imagePreview } = await loadImageOnNode(comfyPage)
diff --git a/src/components/sidebar/tabs/ModelLibrarySidebarTab.test.ts b/src/components/sidebar/tabs/ModelLibrarySidebarTab.test.ts
index 1bb97cf33dc..3f04cbc1bb8 100644
--- a/src/components/sidebar/tabs/ModelLibrarySidebarTab.test.ts
+++ b/src/components/sidebar/tabs/ModelLibrarySidebarTab.test.ts
@@ -169,7 +169,7 @@ describe('ModelLibrarySidebarTab', () => {
'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 5a854d95554..d6b2416cba1 100644
--- a/src/composables/useCanvasDrop.ts
+++ b/src/composables/useCanvasDrop.ts
@@ -15,6 +15,7 @@ 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 = (dropTargetRef: Ref) => {
const modelToNodeStore = useModelToNodeStore()
@@ -69,9 +70,10 @@ export const useCanvasDrop = (dropTargetRef: 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/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/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/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)
+ )
+}
From cd67cf74d777c19603014c7cb1bd7144cc51f675 Mon Sep 17 00:00:00 2001
From: jaeone94 <89377375+jaeone94@users.noreply.github.com>
Date: Thu, 15 Oct 2026 08:19:11 +0900
Subject: [PATCH 5/6] fix: adapt DynamicGroup backports to cloud/1.56
- Use the app singleton instead of useApp(), which cloud/1.56 does not have.
- Drop the #20294 image preview E2E addition that uses helpers missing here.
- Add the missing fireEvent import.
---
.../workflow/core/services/workflowService.ts | 12 ++++++------
.../workflow/management/stores/workflowStore.ts | 4 ++--
.../vueNodes/components/LGraphNode.test.ts | 2 +-
3 files changed, 9 insertions(+), 9 deletions(-)
diff --git a/src/platform/workflow/core/services/workflowService.ts b/src/platform/workflow/core/services/workflowService.ts
index 4c8bb7fa020..190a493b6fd 100644
--- a/src/platform/workflow/core/services/workflowService.ts
+++ b/src/platform/workflow/core/services/workflowService.ts
@@ -709,9 +709,9 @@ export const useWorkflowService = () => {
workflowData: ComfyWorkflowJSON,
shareId?: string
) => {
- const graphState = useApp().rootGraphOrUndefined?.state
+ const graphState = app.rootGraphOrUndefined?.state
await activateLoadedWorkflow(value, workflowData, shareId)
- if (graphState !== useApp().rootGraphOrUndefined?.state) return
+ if (graphState !== app.rootGraphOrUndefined?.state) return
useNodeOutputStore().restorePreviewsForWorkflow(
useWorkspaceStore().workflow.activeWorkflow?.path
)
@@ -722,7 +722,7 @@ export const useWorkflowService = () => {
workflowData: ComfyWorkflowJSON,
shareId?: string
) => {
- const graphState = useApp().rootGraphOrUndefined?.state
+ const graphState = app.rootGraphOrUndefined?.state
const workflowStore = useWorkspaceStore().workflow
const { isAppMode } = useAppMode()
const wasAppMode = isAppMode.value
@@ -773,7 +773,7 @@ export const useWorkflowService = () => {
) {
const loadedWorkflow =
await workflowStore.openWorkflow(existingWorkflow)
- if (graphState !== useApp().rootGraphOrUndefined?.state) return
+ if (graphState !== app.rootGraphOrUndefined?.state) return
activateRunErrors(loadedWorkflow)
if (loadedWorkflow.initialMode === undefined) {
// Prefer the file's linearMode over the draft's since the file
@@ -809,13 +809,13 @@ export const useWorkflowService = () => {
}
trackIfEnteringApp(tempWorkflow)
const loadedWorkflow = await workflowStore.openWorkflow(tempWorkflow)
- if (graphState !== useApp().rootGraphOrUndefined?.state) return
+ if (graphState !== app.rootGraphOrUndefined?.state) return
activateRunErrors(loadedWorkflow)
return
}
const loadedWorkflow = await workflowStore.openWorkflow(value)
- if (graphState !== useApp().rootGraphOrUndefined?.state) return
+ 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 db683774d2b..ba98273d0d3 100644
--- a/src/platform/workflow/management/stores/workflowStore.ts
+++ b/src/platform/workflow/management/stores/workflowStore.ts
@@ -212,9 +212,9 @@ export const useWorkflowStore = defineStore('workflow', () => {
if (!openWorkflowPaths.value.includes(workflow.path)) {
openWorkflowPaths.value.push(workflow.path)
}
- const graphState = useApp().rootGraphOrUndefined?.state
+ const graphState = comfyApp.rootGraphOrUndefined?.state
const loadedWorkflow = await workflow.load()
- if (graphState !== useApp().rootGraphOrUndefined?.state) {
+ if (graphState !== comfyApp.rootGraphOrUndefined?.state) {
throw new DOMException('Workflow load was replaced', 'AbortError')
}
activeWorkflow.value = loadedWorkflow
diff --git a/src/renderer/extensions/vueNodes/components/LGraphNode.test.ts b/src/renderer/extensions/vueNodes/components/LGraphNode.test.ts
index 4800f430752..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'
From 6d8346f7eed30a15e2934a43be488a06b4bae987 Mon Sep 17 00:00:00 2001
From: jaeone94 <89377375+jaeone94@users.noreply.github.com>
Date: Thu, 15 Oct 2026 08:21:11 +0900
Subject: [PATCH 6/6] test: use eslint suppression for canvas parent access
---
src/components/graph/GraphCanvas.test.ts | 5 ++---
1 file changed, 2 insertions(+), 3 deletions(-)
diff --git a/src/components/graph/GraphCanvas.test.ts b/src/components/graph/GraphCanvas.test.ts
index 01ad69ad33c..ee91bb7206c 100644
--- a/src/components/graph/GraphCanvas.test.ts
+++ b/src/components/graph/GraphCanvas.test.ts
@@ -235,10 +235,10 @@ describe('GraphCanvas canvas parent', () => {
await mountGraphCanvas({
TitleEditor: { template: '' }
})
- // oxlint-disable-next-line testing-library/no-node-access -- Extensions use this canvas ID.
+ // eslint-disable-next-line testing-library/no-node-access -- Extensions use this canvas ID.
const canvas = document.getElementById('graph-canvas')
assert.exists(canvas)
- // oxlint-disable-next-line testing-library/no-node-access -- Canvas-parent listeners are the compatibility contract under test.
+ // 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()
@@ -253,7 +253,6 @@ describe('GraphCanvas canvas parent', () => {
expect(receivedTouch).toHaveBeenCalledOnce()
})
-
})
describe('GraphCanvas execution progress updates', () => {