From bed706e0d787c7ef6069c60c1a946e52768d39c2 Mon Sep 17 00:00:00 2001 From: Connor Byrne Date: Tue, 11 Aug 2026 16:11:37 -0700 Subject: [PATCH 1/7] test: add failing repro for uploads not reaching the workflow draft An image dropped on a Load Image node commits its widget value with a bare property assignment and never nudges the change tracker. HTML5 drag-and-drop emits no mouseup, and the upload resolves after the gesture ends, so none of ChangeTracker's input hooks fire: captureCanvasState is never called, graphChanged is never dispatched, and the 512ms draft persist never runs. Reloading the browser restores the previous image. --- .../composables/useImageUploadWidget.test.ts | 52 ++++++++++++++++++- 1 file changed, 51 insertions(+), 1 deletion(-) diff --git a/src/renderer/extensions/vueNodes/widgets/composables/useImageUploadWidget.test.ts b/src/renderer/extensions/vueNodes/widgets/composables/useImageUploadWidget.test.ts index 48aefafb554..3dc8be44509 100644 --- a/src/renderer/extensions/vueNodes/widgets/composables/useImageUploadWidget.test.ts +++ b/src/renderer/extensions/vueNodes/widgets/composables/useImageUploadWidget.test.ts @@ -19,7 +19,16 @@ const mocks = vi.hoisted(() => ({ capturedUploadOptions: undefined as CapturedImageUploadOptions | undefined, openFileSelection: vi.fn(), setNodeOutputs: vi.fn(), - showPreview: vi.fn() + showPreview: vi.fn(), + captureCanvasState: vi.fn() +})) + +vi.mock('@/platform/workflow/management/stores/workflowStore', () => ({ + useWorkflowStore: () => ({ + activeWorkflow: { + changeTracker: { captureCanvasState: mocks.captureCanvasState } + } + }) })) vi.mock('@/composables/node/useNodeImage', () => ({ @@ -96,6 +105,7 @@ const outputFolderCases: { describe('useImageUploadWidget', () => { beforeEach(() => { mocks.capturedUploadOptions = undefined + mocks.captureCanvasState.mockClear() vi.stubGlobal('requestAnimationFrame', vi.fn()) }) @@ -149,4 +159,44 @@ describe('useImageUploadWidget', () => { expect(fileComboWidget.value).toBe(expected) }) + + it('captures canvas state after upload so the draft persists the new value', () => { + const { fileComboWidget, node } = createUploadNode() + const constructor = useImageUploadWidget() + + constructor( + node, + 'upload', + [ + 'IMAGEUPLOAD', + { imageInputName: 'image', image_upload: true } + ] as InputSpec, + fromPartial({}) + ) + + mocks.capturedUploadOptions?.onUploadComplete(['uploaded.png']) + + expect(fileComboWidget.value).toBe('uploaded.png') + expect(mocks.captureCanvasState).toHaveBeenCalled() + }) + + it('does not capture canvas state when the value is unchanged', () => { + const { fileComboWidget, node } = createUploadNode() + const constructor = useImageUploadWidget() + + constructor( + node, + 'upload', + [ + 'IMAGEUPLOAD', + { imageInputName: 'image', image_upload: true } + ] as InputSpec, + fromPartial({}) + ) + + mocks.capturedUploadOptions?.onUploadComplete(['missing.png']) + + expect(fileComboWidget.value).toBe('missing.png') + expect(mocks.captureCanvasState).not.toHaveBeenCalled() + }) }) From de3c37a74752323eaf6b2e01e1c9b65f12c34aa5 Mon Sep 17 00:00:00 2001 From: Connor Byrne Date: Tue, 11 Aug 2026 16:13:21 -0700 Subject: [PATCH 2/7] fix(assets): capture canvas state after an image upload commits Workflow drafts persist on graphChanged, which ChangeTracker only dispatches from captureCanvasState. Its hooks are all user-input events, and HTML5 drag-and-drop emits no mouseup while the upload resolves after the gesture ends, so a dropped image never reached the draft and a reload restored the previous one. Capture on commit, matching createAssetWidget, which already does this for the asset browser. --- .../tests/loadImageUploadPersistence.spec.ts | 48 +++++++++++++++++++ .../composables/useImageUploadWidget.ts | 4 ++ 2 files changed, 52 insertions(+) create mode 100644 browser_tests/tests/loadImageUploadPersistence.spec.ts diff --git a/browser_tests/tests/loadImageUploadPersistence.spec.ts b/browser_tests/tests/loadImageUploadPersistence.spec.ts new file mode 100644 index 00000000000..d78228c95cc --- /dev/null +++ b/browser_tests/tests/loadImageUploadPersistence.spec.ts @@ -0,0 +1,48 @@ +/** + * FE-1425: dropping an image on a Load Image node must survive a browser + * reload without an explicit save. `Comfy.Workflow.Persist` defaults to true + * and writes a localStorage draft on every `graphChanged`, but the upload + * commit never nudged the change tracker — and HTML5 drag-and-drop emits no + * mouseup for its global hook to catch — so the draft kept the previous image. + */ +import { expect } from '@playwright/test' + +import { comfyPageFixture as test } from '@e2e/fixtures/ComfyPage' + +const DROPPED_FILE = 'image64x64.webp' + +test.describe('Load Image upload persistence', () => { + test('keeps a dropped image across a reload without saving', async ({ + comfyPage + }) => { + await comfyPage.nodeOps.clearGraph() + await comfyPage.searchBoxV2.addNode('Load Image') + + const [loadImageNode] = + await comfyPage.nodeOps.getNodeRefsByType('LoadImage') + const { x, y } = await loadImageNode.getPosition() + + const readImageWidgetValue = () => + comfyPage.page.evaluate( + () => + window.app?.graph?.nodes + .find((node) => node.type === 'LoadImage') + ?.widgets?.find((widget) => widget.name === 'image')?.value + ) + + const valueBeforeDrop = await readImageWidgetValue() + + const draftSaveStartedAt = Date.now() + await comfyPage.dragDrop.dragAndDropFile(DROPPED_FILE, { + dropPosition: { x, y } + }) + + await expect.poll(readImageWidgetValue).not.toBe(valueBeforeDrop) + const valueAfterDrop = await readImageWidgetValue() + + await comfyPage.workflow.waitForDraftIndexUpdatedSince(draftSaveStartedAt) + await comfyPage.workflow.reloadAndWaitForApp() + + await expect.poll(readImageWidgetValue).toBe(valueAfterDrop) + }) +}) diff --git a/src/renderer/extensions/vueNodes/widgets/composables/useImageUploadWidget.ts b/src/renderer/extensions/vueNodes/widgets/composables/useImageUploadWidget.ts index 7695481810c..b673582ed85 100644 --- a/src/renderer/extensions/vueNodes/widgets/composables/useImageUploadWidget.ts +++ b/src/renderer/extensions/vueNodes/widgets/composables/useImageUploadWidget.ts @@ -5,6 +5,7 @@ import type { LGraphNode } from '@/lib/litegraph/src/litegraph' import type { IComboWidget } from '@/lib/litegraph/src/types/widgets' import type { ResultItem, ResultItemType } from '@/schemas/apiSchema' import type { InputSpec } from '@/schemas/nodeDefSchema' +import { useWorkflowStore } from '@/platform/workflow/management/stores/workflowStore' import type { ComfyWidgetConstructor } from '@/scripts/widgets' import { useNodeOutputStore } from '@/stores/nodeOutputStore' import { isImageUploadInput } from '@/types/nodeDefAugmentation' @@ -97,6 +98,9 @@ export const useImageUploadWidget = () => { oldValue, fileComboWidget ) + if (oldValue !== newValue) { + useWorkflowStore().activeWorkflow?.changeTracker?.captureCanvasState() + } } }) From dd5f0cc958609f187b4769883aaef06a81b1f0bc Mon Sep 17 00:00:00 2001 From: Connor Byrne Date: Tue, 11 Aug 2026 16:22:41 -0700 Subject: [PATCH 3/7] test: wait on the draft holding the new value instead of the draft index waitForDraftIndexUpdatedSince assumes a saved workflow; this test runs on the default temporary one, so the index timed out. Assert the draft content directly, which is both the thing under test and a debounce-safe wait. --- .../tests/loadImageUploadPersistence.spec.ts | 22 ++++++++++++++++--- 1 file changed, 19 insertions(+), 3 deletions(-) diff --git a/browser_tests/tests/loadImageUploadPersistence.spec.ts b/browser_tests/tests/loadImageUploadPersistence.spec.ts index d78228c95cc..90ccdb1e3ac 100644 --- a/browser_tests/tests/loadImageUploadPersistence.spec.ts +++ b/browser_tests/tests/loadImageUploadPersistence.spec.ts @@ -32,15 +32,31 @@ test.describe('Load Image upload persistence', () => { const valueBeforeDrop = await readImageWidgetValue() - const draftSaveStartedAt = Date.now() await comfyPage.dragDrop.dragAndDropFile(DROPPED_FILE, { dropPosition: { x, y } }) await expect.poll(readImageWidgetValue).not.toBe(valueBeforeDrop) - const valueAfterDrop = await readImageWidgetValue() + const valueAfterDrop = String(await readImageWidgetValue()) + + // The draft carrying the new value is what survives the reload, so waiting + // on it also covers the 512ms persist debounce. + await expect + .poll( + () => + comfyPage.page.evaluate((expected) => { + for (let i = 0; i < window.localStorage.length; i++) { + const key = window.localStorage.key(i) + if (!key?.startsWith('Comfy.Workflow.Draft.v2:')) continue + if (window.localStorage.getItem(key)?.includes(expected)) + return true + } + return false + }, valueAfterDrop), + { timeout: 15_000 } + ) + .toBe(true) - await comfyPage.workflow.waitForDraftIndexUpdatedSince(draftSaveStartedAt) await comfyPage.workflow.reloadAndWaitForApp() await expect.poll(readImageWidgetValue).toBe(valueAfterDrop) From 388bd2a654e72c61e261f21805caf90d9de32527 Mon Sep 17 00:00:00 2001 From: Connor Byrne Date: Tue, 11 Aug 2026 16:40:26 -0700 Subject: [PATCH 4/7] test: enable workflow persistence and raise the timeout The e2e environment does not have Comfy.Workflow.Persist on, so no draft was ever written and the poll could not pass. Set it explicitly, matching subgraphDraftPositions and workflowPersistence, and give the test the same 30s budget those use for a reload round trip. --- browser_tests/tests/loadImageUploadPersistence.spec.ts | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/browser_tests/tests/loadImageUploadPersistence.spec.ts b/browser_tests/tests/loadImageUploadPersistence.spec.ts index 90ccdb1e3ac..ae54c623eba 100644 --- a/browser_tests/tests/loadImageUploadPersistence.spec.ts +++ b/browser_tests/tests/loadImageUploadPersistence.spec.ts @@ -15,6 +15,9 @@ test.describe('Load Image upload persistence', () => { test('keeps a dropped image across a reload without saving', async ({ comfyPage }) => { + test.setTimeout(30000) + + await comfyPage.settings.setSetting('Comfy.Workflow.Persist', true) await comfyPage.nodeOps.clearGraph() await comfyPage.searchBoxV2.addNode('Load Image') @@ -53,7 +56,7 @@ test.describe('Load Image upload persistence', () => { } return false }, valueAfterDrop), - { timeout: 15_000 } + { timeout: 10_000 } ) .toBe(true) From 3659c5b552d327182d5614cc189cc96116c5a1fc Mon Sep 17 00:00:00 2001 From: Connor Byrne Date: Tue, 11 Aug 2026 17:01:20 -0700 Subject: [PATCH 5/7] test: wait for the upload to commit before reading the widget value dragAndDropFile defaults waitForUpload to false, so the test read the optimistic value onUploadStart writes rather than the one the upload commits, then searched the draft for a value that was never persisted. --- browser_tests/tests/loadImageUploadPersistence.spec.ts | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/browser_tests/tests/loadImageUploadPersistence.spec.ts b/browser_tests/tests/loadImageUploadPersistence.spec.ts index ae54c623eba..10292777031 100644 --- a/browser_tests/tests/loadImageUploadPersistence.spec.ts +++ b/browser_tests/tests/loadImageUploadPersistence.spec.ts @@ -35,8 +35,12 @@ test.describe('Load Image upload persistence', () => { const valueBeforeDrop = await readImageWidgetValue() + // Without waitForUpload the helper returns during the optimistic window, + // where the widget briefly holds the raw local filename rather than the + // value the upload actually commits. await comfyPage.dragDrop.dragAndDropFile(DROPPED_FILE, { - dropPosition: { x, y } + dropPosition: { x, y }, + waitForUpload: true }) await expect.poll(readImageWidgetValue).not.toBe(valueBeforeDrop) From a190c11cd943a7958de2ed4c67484207a9bf7fed Mon Sep 17 00:00:00 2001 From: Connor Byrne Date: Tue, 11 Aug 2026 21:09:56 -0700 Subject: [PATCH 6/7] fix: capture canvas state whenever an upload commits MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit onUploadStart already sets the widget to the local filename, so by the time onUploadComplete ran, oldValue equalled the committed value in the ordinary case where the server keeps the name — the equality guard meant captureCanvasState never fired and no draft was written. captureCanvasState already no-ops on an unchanged graph, so the guard only suppressed it. The e2e passed regardless because the node-add and the upload landed in one 512ms persist debounce; it only failed once SLOW_MO separated them. Assert on the uploaded filename rather than on the value changing so a re-run against a server that already holds the file still exercises the path, and delete the upload afterwards — it was leaking into the shard and flipping the Load Image combo arrows in loadWorkflowInMedia's screenshots. --- .../tests/loadImageUploadPersistence.spec.ts | 21 +++++++++---------- .../composables/useImageUploadWidget.test.ts | 11 ++++++---- .../composables/useImageUploadWidget.ts | 4 +--- 3 files changed, 18 insertions(+), 18 deletions(-) diff --git a/browser_tests/tests/loadImageUploadPersistence.spec.ts b/browser_tests/tests/loadImageUploadPersistence.spec.ts index 10292777031..589ad806919 100644 --- a/browser_tests/tests/loadImageUploadPersistence.spec.ts +++ b/browser_tests/tests/loadImageUploadPersistence.spec.ts @@ -13,9 +13,10 @@ const DROPPED_FILE = 'image64x64.webp' test.describe('Load Image upload persistence', () => { test('keeps a dropped image across a reload without saving', async ({ - comfyPage + comfyPage, + comfyFiles }) => { - test.setTimeout(30000) + test.setTimeout(60000) await comfyPage.settings.setSetting('Comfy.Workflow.Persist', true) await comfyPage.nodeOps.clearGraph() @@ -33,18 +34,16 @@ test.describe('Load Image upload persistence', () => { ?.widgets?.find((widget) => widget.name === 'image')?.value ) - const valueBeforeDrop = await readImageWidgetValue() - - // Without waitForUpload the helper returns during the optimistic window, - // where the widget briefly holds the raw local filename rather than the - // value the upload actually commits. + // The server keeps the filename when the same bytes are uploaded again, so + // asserting on the name rather than on "the value changed" keeps this test + // correct whether or not a previous run already left the file behind. await comfyPage.dragDrop.dragAndDropFile(DROPPED_FILE, { dropPosition: { x, y }, waitForUpload: true }) + comfyFiles.deleteAfterTest({ filename: DROPPED_FILE, type: 'input' }) - await expect.poll(readImageWidgetValue).not.toBe(valueBeforeDrop) - const valueAfterDrop = String(await readImageWidgetValue()) + await expect.poll(readImageWidgetValue).toBe(DROPPED_FILE) // The draft carrying the new value is what survives the reload, so waiting // on it also covers the 512ms persist debounce. @@ -59,13 +58,13 @@ test.describe('Load Image upload persistence', () => { return true } return false - }, valueAfterDrop), + }, DROPPED_FILE), { timeout: 10_000 } ) .toBe(true) await comfyPage.workflow.reloadAndWaitForApp() - await expect.poll(readImageWidgetValue).toBe(valueAfterDrop) + await expect.poll(readImageWidgetValue).toBe(DROPPED_FILE) }) }) diff --git a/src/renderer/extensions/vueNodes/widgets/composables/useImageUploadWidget.test.ts b/src/renderer/extensions/vueNodes/widgets/composables/useImageUploadWidget.test.ts index 3dc8be44509..0fa94f896ad 100644 --- a/src/renderer/extensions/vueNodes/widgets/composables/useImageUploadWidget.test.ts +++ b/src/renderer/extensions/vueNodes/widgets/composables/useImageUploadWidget.test.ts @@ -180,7 +180,7 @@ describe('useImageUploadWidget', () => { expect(mocks.captureCanvasState).toHaveBeenCalled() }) - it('does not capture canvas state when the value is unchanged', () => { + it('captures canvas state when the server keeps the optimistic filename', () => { const { fileComboWidget, node } = createUploadNode() const constructor = useImageUploadWidget() @@ -194,9 +194,12 @@ describe('useImageUploadWidget', () => { fromPartial({}) ) - mocks.capturedUploadOptions?.onUploadComplete(['missing.png']) + mocks.capturedUploadOptions?.onUploadStart?.([ + new File([], 'uploaded.png', { type: 'image/png' }) + ]) + mocks.capturedUploadOptions?.onUploadComplete(['uploaded.png']) - expect(fileComboWidget.value).toBe('missing.png') - expect(mocks.captureCanvasState).not.toHaveBeenCalled() + expect(fileComboWidget.value).toBe('uploaded.png') + expect(mocks.captureCanvasState).toHaveBeenCalled() }) }) diff --git a/src/renderer/extensions/vueNodes/widgets/composables/useImageUploadWidget.ts b/src/renderer/extensions/vueNodes/widgets/composables/useImageUploadWidget.ts index b673582ed85..75a456acc01 100644 --- a/src/renderer/extensions/vueNodes/widgets/composables/useImageUploadWidget.ts +++ b/src/renderer/extensions/vueNodes/widgets/composables/useImageUploadWidget.ts @@ -98,9 +98,7 @@ export const useImageUploadWidget = () => { oldValue, fileComboWidget ) - if (oldValue !== newValue) { - useWorkflowStore().activeWorkflow?.changeTracker?.captureCanvasState() - } + useWorkflowStore().activeWorkflow?.changeTracker?.captureCanvasState() } }) From 72e8ac32b07e17ab9027132d0cf8139f08dd818c Mon Sep 17 00:00:00 2001 From: Connor Byrne Date: Tue, 11 Aug 2026 21:22:50 -0700 Subject: [PATCH 7/7] test: recompute isModified after re-baselining the change tracker The upload now marks the workflow modified, which is correct, so this test's re-baseline had to actually clear the flag rather than rely on it never having been set. --- browser_tests/tests/assetDeleteClearsLoadImage.spec.ts | 3 +++ 1 file changed, 3 insertions(+) diff --git a/browser_tests/tests/assetDeleteClearsLoadImage.spec.ts b/browser_tests/tests/assetDeleteClearsLoadImage.spec.ts index c6a90fb1645..10b921a78ae 100644 --- a/browser_tests/tests/assetDeleteClearsLoadImage.spec.ts +++ b/browser_tests/tests/assetDeleteClearsLoadImage.spec.ts @@ -144,11 +144,14 @@ baseTest.describe( // Re-baseline the change tracker so the deletion-side mutation is the // only thing that can flip `isModified` later. + // `reset()` re-baselines `initialState`; only `updateModified()` + // recomputes `isModified` from it. await comfyPage.page.evaluate(() => { const tracker = window.app?.extensionManager?.workflow?.activeWorkflow ?.changeTracker tracker?.reset?.() + tracker?.updateModified?.() }) await expect .poll(() => comfyPage.workflow.isCurrentWorkflowModified())