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', () => {