Preserve saved auto-detect output settings across workflow reloads

When a workflow is reloaded, the auto-detect source dimensions may change
technically (e.g. preview URLs, backend signatures) even though the source
image itself did not change size. Previously, these technical changes could
overwrite user-modified output dimensions.

Introduce workflow-restore tracking state and a dedicated check that keeps
the saved width/height when:
- the workflow is being restored, and the newly detected dimensions match
  the restored source dimensions, or
- the saved auto-detect properties match the newly detected dimensions.

Hooks:
- ResolutionMasterCanvas: added restoredAutoDetectDimensions and
  autoDetectWorkflowRestorePending state.
- Node lifecycle: call prepareAutoDetectWorkflowRestore() during
  onConfigure so restore state is initialized at workflow load time.
- Auto-detect methods: reset restore state when source changes or backend
  fallback occurs, and use shouldPreserveRestoredAutoDetectSettings() to
  decide whether to keep existing output.

Tests:
- Cover preserved output when technical signatures change but source size
  does not.
- Cover clearing restore state when a genuinely different size is detected.
- Cover onConfigure ordering in node lifecycle.

Author: Azornes

js/auto_detect/auto_detect_methods.js

@@ -101,6 +101,62 @@ export const autoDetectMethods = {
             || Math.round(Number(first.height) || 0) !== Math.round(Number(second.height) || 0);
     },
 
+    prepareAutoDetectWorkflowRestore() {
+        this.restoredAutoDetectDimensions = null;
+        this.autoDetectWorkflowRestorePending = !!this.node?.properties?.autoDetect;
+        if (this.autoDetectWorkflowRestorePending) {
+            log.debug('Prepared auto-detect workflow restore without recalculation', {
+                nodeId: this.node?.id ?? null,
+                savedWidth: this.widthWidget?.value ?? this.node?.properties?.valueX ?? null,
+                savedHeight: this.heightWidget?.value ?? this.node?.properties?.valueY ?? null
+            });
+        }
+    },
+
+    shouldPreserveRestoredAutoDetectSettings(dimensions) {
+        if (!dimensions) return false;
+
+        const detectedWidth = Math.round(Number(dimensions.width) || 0);
+        const detectedHeight = Math.round(Number(dimensions.height) || 0);
+
+        if (this.autoDetectWorkflowRestorePending) {
+            this.autoDetectWorkflowRestorePending = false;
+            this.restoredAutoDetectDimensions = {
+                width: detectedWidth,
+                height: detectedHeight
+            };
+            return true;
+        }
+
+        const restored = this.restoredAutoDetectDimensions;
+
+        if (restored) {
+            const matchesRestoredSource = restored.width === detectedWidth
+                && restored.height === detectedHeight;
+            if (!matchesRestoredSource) {
+                this.restoredAutoDetectDimensions = null;
+            }
+            return matchesRestoredSource;
+        }
+
+        const props = this.node?.properties;
+        const savedWidth = Math.round(Number(props?.autoDetectWidth) || 0);
+        const savedHeight = Math.round(Number(props?.autoDetectHeight) || 0);
+        const matchesSavedSource = !this.detectedDimensions
+            && savedWidth > 0
+            && savedHeight > 0
+            && savedWidth === detectedWidth
+            && savedHeight === detectedHeight;
+
+        if (matchesSavedSource) {
+            this.restoredAutoDetectDimensions = {
+                width: savedWidth,
+                height: savedHeight
+            };
+        }
+        return matchesSavedSource;
+    },
+
     shouldPreferBackendDimensions(frontendDimensions, backendDimensions, previousBackendTimestamp) {
         if (!frontendDimensions || !backendDimensions) return false;
         if (!this.haveDifferentDimensions(frontendDimensions, backendDimensions)) return false;
@@ -311,6 +367,8 @@ export const autoDetectMethods = {
 
         const sourceNode = this.getConnectedSourceNode();
         if (shouldSuppressBackendFallback(sourceNode)) {
+            this.autoDetectWorkflowRestorePending = false;
+            this.restoredAutoDetectDimensions = null;
             this.setAutoDetectSource('frontend-empty');
             this.setRawAutoDetectDimensions(null);
         } else if (this.node.properties.autoDetectSource === 'frontend-empty') {
@@ -409,6 +467,8 @@ export const autoDetectMethods = {
                     });
                 }
                 this.detectedDimensions = null;
+                this.autoDetectWorkflowRestorePending = false;
+                this.restoredAutoDetectDimensions = null;
                 this.setAutoDetectSource('backend');
                 this.setRawAutoDetectDimensions(null);
                 return;
@@ -427,6 +487,8 @@ export const autoDetectMethods = {
                 }
                 this.clearLivePreviewPending();
                 this.detectedDimensions = null;
+                this.autoDetectWorkflowRestorePending = false;
+                this.restoredAutoDetectDimensions = null;
                 this.setAutoDetectSource('frontend-empty');
                 this.setRawAutoDetectDimensions(null);
                 return;
@@ -474,24 +536,21 @@ export const autoDetectMethods = {
                 return;
             }
 
-            const props = node.properties;
-            // Restore detected dimensions if the newly detected dimensions match the saved ones on first run.
-            // This prevents overwriting user-modified/downsized settings upon reloading the workflow.
-            if (!this.detectedDimensions && props && props.autoDetectWidth > 0 && props.autoDetectHeight > 0) {
-                if (Math.round(Number(props.autoDetectWidth)) === dimensions.width &&
-                    Math.round(Number(props.autoDetectHeight)) === dimensions.height) {
-                    log.debug('Restoring auto-detect dimensions from saved properties without recalculation', {
-                        nodeId: node.id ?? null,
-                        width: dimensions.width,
-                        height: dimensions.height
-                    });
-                    this.detectedDimensions = dimensions;
-                    this.manuallySetByAutoFit = false;
-                    this.setAutoDetectSource(dimensions.source === 'frontend' ? 'frontend' : 'backend');
-                    this.setRawAutoDetectDimensions(dimensions);
-                    this.requestCanvasUpdate(true);
-                    return;
-                }
+            // Keep saved output settings while the restored source dimensions stay the same.
+            // Preview URLs and frontend/backend signatures can change during workflow loading
+            // without the source image itself changing size.
+            if (this.shouldPreserveRestoredAutoDetectSettings(dimensions)) {
+                log.debug('Keeping saved output settings for restored auto-detect dimensions', {
+                    nodeId: node.id ?? null,
+                    width: dimensions.width,
+                    height: dimensions.height
+                });
+                this.detectedDimensions = dimensions;
+                this.manuallySetByAutoFit = false;
+                this.setAutoDetectSource(dimensions.source === 'frontend' ? 'frontend' : 'backend');
+                this.setRawAutoDetectDimensions(dimensions);
+                this.requestCanvasUpdate(true);
+                return;
             }
 
             this.setAutoDetectSource(dimensions.source === 'frontend' ? 'frontend' : 'backend');

js/node/resolution_master_node_lifecycle.js

@@ -885,6 +885,12 @@ export const nodeLifecycleMethods = {
         node.onPropertyChanged = function(property) {
             self.handlePropertyChange(property);
         };
+        const origOnConfigure = node.onConfigure;
+        node.onConfigure = function() {
+            const result = origOnConfigure?.apply(this, arguments);
+            self.prepareAutoDetectWorkflowRestore();
+            return result;
+        };
         const origOnConnectionsChange = node.onConnectionsChange;
         node.onConnectionsChange = function() {
             const result = origOnConnectionsChange?.apply(this, arguments);

js/resolution_master.js

@@ -51,6 +51,8 @@ class ResolutionMasterCanvas {
         this.showTooltip = false;
         this.tooltipMousePos = null; 
         this.detectedDimensions = null;
+        this.restoredAutoDetectDimensions = null;
+        this.autoDetectWorkflowRestorePending = false;
         this.lastBackendDimensionsTimestamp = null;
         this.autoDetectStartedAtMs = null;
         this.dimensionCheckInterval = null;

tests/js/auto_detect_methods.test.mjs

@@ -192,6 +192,88 @@ test("saved detected dimensions are restored without recalculating the workflow"
 });
 
 
+test("loading a workflow preserves saved output even when technical detected dimensions are stale", async () => {
+    const sourceNode = {
+        id: 9,
+        imgs: [{ naturalWidth: 640, naturalHeight: 480, src: "workflow-preview.png" }],
+        widgets: []
+    };
+    const state = createController(sourceNode);
+    state.controller.node.properties.autoDetectWidth = 320;
+    state.controller.node.properties.autoDetectHeight = 240;
+    state.controller.widthWidget.value = 1024;
+    state.controller.heightWidget.value = 768;
+    state.controller.prepareAutoDetectWorkflowRestore();
+
+    await state.controller.checkForImageDimensions();
+
+    assert.equal(state.requests.length, 0);
+    assert.equal(state.controller.widthWidget.value, 1024);
+    assert.equal(state.controller.heightWidget.value, 768);
+    assert.equal(state.controller.node.properties.autoDetectWidth, 640);
+    assert.equal(state.controller.node.properties.autoDetectHeight, 480);
+    assert.equal(state.controller.autoDetectWorkflowRestorePending, false);
+    assert.deepEqual(state.controller.restoredAutoDetectDimensions, {
+        width: 640,
+        height: 480
+    });
+});
+
+
+test("restored output settings survive same-size signature and source changes", async () => {
+    const preview = {
+        naturalWidth: 640,
+        naturalHeight: 480,
+        src: "saved-preview.png"
+    };
+    const sourceNode = {
+        id: 9,
+        imgs: [preview],
+        widgets: []
+    };
+    const state = createController(sourceNode);
+    state.controller.node.properties.autoDetectWidth = 640;
+    state.controller.node.properties.autoDetectHeight = 480;
+
+    await state.controller.checkForImageDimensions();
+    preview.src = "reloaded-preview.png";
+    await state.controller.checkForImageDimensions();
+
+    assert.equal(state.requests.length, 0);
+    assert.equal(state.controller.detectedDimensions.width, 640);
+    assert.equal(state.controller.detectedDimensions.height, 480);
+    assert.match(state.controller.detectedDimensions.signature, /reloaded-preview\.png/);
+
+    sourceNode.imgs = [];
+    state.controller.getBackendDetectedDimensions = async () => ({
+        width: 640,
+        height: 480,
+        source: "backend",
+        timestamp: 2,
+        signature: "backend:7:2:640x480"
+    });
+    await state.controller.checkForImageDimensions();
+
+    assert.equal(state.requests.length, 0);
+    assert.equal(state.controller.node.properties.autoDetectSource, "backend");
+
+    state.controller.getBackendDetectedDimensions = async () => ({
+        width: 800,
+        height: 600,
+        source: "backend",
+        timestamp: 3,
+        signature: "backend:7:3:800x600"
+    });
+    await state.controller.checkForImageDimensions();
+
+    assert.deepEqual(state.requests, [{
+        action: "auto_detect",
+        payload: { width: 800, height: 600 }
+    }]);
+    assert.equal(state.controller.restoredAutoDetectDimensions, null);
+});
+
+
 test("async source widget callbacks notify watchers and are restored on teardown", async () => {
     const state = createController();
     const originalCallback = async value => `loaded:${value}`;

tests/js/node_lifecycle.test.mjs

@@ -162,6 +162,9 @@ test("LiteGraph lifecycle hooks synchronize serialization and clean up on remova
             events.push("original-serialize");
             serialized.originalCalled = true;
         },
+        onConfigure() {
+            events.push("original-configure");
+        },
         onRemoved() {
             events.push("original-remove");
         }
@@ -171,6 +174,7 @@ test("LiteGraph lifecycle hooks synchronize serialization and clean up on remova
     controller.installCanvasDragZoomBypass = () => {};
     controller.applyCompactSlotLabels = () => {};
     controller.installVueNodesCompatibilityWidget = () => {};
+    controller.prepareAutoDetectWorkflowRestore = () => events.push("prepare-restore");
     controller.syncAutoDetectSourceState = () => events.push("sync-source");
     controller.syncBackendFallbackWidgets = () => events.push("sync-widgets");
     controller.stopAutoDetect = () => events.push("stop-auto-detect");
@@ -181,6 +185,7 @@ test("LiteGraph lifecycle hooks synchronize serialization and clean up on remova
     controller.initializeProperties();
 
     controller.setupNode();
+    controller.node.onConfigure({});
     const serialized = {};
     controller.node.onSerialize(serialized);
     controller.node.onRemoved();
@@ -189,6 +194,9 @@ test("LiteGraph lifecycle hooks synchronize serialization and clean up on remova
     assert.equal(heightWidget.hidden, true);
     assert.equal(serialized.originalCalled, true);
     assert.equal(serialized.properties.aux_id, "Azornes/Comfyui-Resolution-Master");
+    const configureEventIndex = events.indexOf("original-configure");
+    assert.notEqual(configureEventIndex, -1);
+    assert.equal(events[configureEventIndex + 1], "prepare-restore");
     assert.deepEqual(events.slice(-6), [
         "sync-source",
         "sync-widgets",