fix: preserve getter/setter compatibility, use getInstanceValue for execution

Revert getter to original behavior so inner node sync and E2E
navigation tests are unaffected. Per-instance values are stored
via setter and during configure, accessible through
getInstanceValue() for execution contexts.

src/core/graph/subgraph/promotedWidgetView.ts

@@ -149,13 +149,32 @@ class PromotedWidgetView implements IPromotedWidgetView {
     return this.resolveDeepest()?.widget.linkedWidgets
   }
 
+  private get _instanceKey(): string {
+    return this.disambiguatingSourceNodeId
+      ? `${this.sourceNodeId}:${this.sourceWidgetName}:${this.disambiguatingSourceNodeId}`
+      : `${this.sourceNodeId}:${this.sourceWidgetName}`
+  }
+
   get value(): IBaseWidget['value'] {
     const state = this.getWidgetState()
     if (state && isWidgetValue(state.value)) return state.value
     return this.resolveAtHost()?.widget.value
   }
 
+  /**
+   * Read the per-instance value stored during configure.
+   * Used by graphToPrompt to get the correct execution value when
+   * multiple SubgraphNode instances share the same blueprint.
+   */
+  getInstanceValue(): IBaseWidget['value'] | undefined {
+    const v = this.subgraphNode._instanceWidgetValues.get(this._instanceKey)
+    return v as IBaseWidget['value'] | undefined
+  }
+
   set value(value: IBaseWidget['value']) {
+    // Keep per-instance map in sync for execution (graphToPrompt)
+    this.subgraphNode._instanceWidgetValues.set(this._instanceKey, value)
+
     const linkedWidgets = this.getLinkedInputWidgets()
     if (linkedWidgets.length > 0) {
       const widgetStore = useWidgetValueStore()

src/lib/litegraph/src/subgraph/SubgraphNode.multiInstance.test.ts

@@ -0,0 +1,93 @@
+import { createTestingPinia } from '@pinia/testing'
+import { setActivePinia } from 'pinia'
+import { beforeEach, describe, expect, it } from 'vitest'
+
+import type { ISlotType } from '@/lib/litegraph/src/litegraph'
+import { BaseWidget, LGraphNode } from '@/lib/litegraph/src/litegraph'
+
+import {
+  createTestSubgraph,
+  createTestSubgraphNode,
+  resetSubgraphFixtureState
+} from './__fixtures__/subgraphHelpers'
+
+function createNodeWithWidget(
+  title: string,
+  widgetValue: unknown = 42,
+  slotType: ISlotType = 'number'
+) {
+  const node = new LGraphNode(title)
+  const input = node.addInput('value', slotType)
+  node.addOutput('out', slotType)
+
+  // @ts-expect-error Abstract class instantiation
+  const widget = new BaseWidget({
+    name: 'widget',
+    type: 'number',
+    value: widgetValue,
+    y: 0,
+    options: { min: 0, max: 100, step: 1 },
+    node
+  })
+  node.widgets = [widget]
+  input.widget = { name: widget.name }
+
+  return { node, widget, input }
+}
+
+beforeEach(() => {
+  setActivePinia(createTestingPinia({ stubActions: false }))
+  resetSubgraphFixtureState()
+})
+
+describe('SubgraphNode multi-instance widget isolation', () => {
+  it('preserves promoted widget values after configure with different widgets_values', () => {
+    const subgraph = createTestSubgraph({
+      inputs: [{ name: 'value', type: 'number' }]
+    })
+
+    const { node } = createNodeWithWidget('TestNode', 0)
+    subgraph.add(node)
+    subgraph.inputNode.slots[0].connect(node.inputs[0], node)
+
+    const instance1 = createTestSubgraphNode(subgraph, { id: 201 })
+    const instance2 = createTestSubgraphNode(subgraph, { id: 202 })
+
+    // Simulate what LGraph.configure does: call configure with different widgets_values
+    instance1.configure({
+      id: 201,
+      type: subgraph.id,
+      pos: [100, 100],
+      size: [200, 100],
+      inputs: [],
+      outputs: [],
+      mode: 0,
+      order: 0,
+      flags: {},
+      properties: { proxyWidgets: [['-1', 'widget']] },
+      widgets_values: [10]
+    })
+
+    instance2.configure({
+      id: 202,
+      type: subgraph.id,
+      pos: [400, 100],
+      size: [200, 100],
+      inputs: [],
+      outputs: [],
+      mode: 0,
+      order: 1,
+      flags: {},
+      properties: { proxyWidgets: [['-1', 'widget']] },
+      widgets_values: [20]
+    })
+
+    // After configuring both, each instance's per-instance value
+    // should be preserved in _instanceWidgetValues, even though the
+    // shared inner widget holds the last-configured value.
+    expect(instance1._instanceWidgetValues.size).toBeGreaterThan(0)
+    expect(instance2._instanceWidgetValues.size).toBeGreaterThan(0)
+    expect([...instance1._instanceWidgetValues.values()]).toContain(10)
+    expect([...instance2._instanceWidgetValues.values()]).toContain(20)
+  })
+})

src/lib/litegraph/src/subgraph/SubgraphNode.ts

@@ -993,7 +993,20 @@ export class SubgraphNode extends LGraphNode implements BaseLGraph {
     }
   }
 
+  /** Temporarily stored during configure for use by _internalConfigureAfterSlots */
+  private _pendingWidgetsValues?: unknown[]
+
+  /**
+   * Per-instance promoted widget values.
+   * Multiple SubgraphNode instances share the same inner nodes, so
+   * promoted widget values must be stored per-instance to avoid collisions.
+   * Key: `${sourceNodeId}:${sourceWidgetName}`
+   */
+  readonly _instanceWidgetValues = new Map<string, unknown>()
+
   override configure(info: ExportedSubgraphInstance): void {
+    this._pendingWidgetsValues = info.widgets_values
+
     for (const input of this.inputs) {
       if (
         input._listenerController &&
@@ -1124,6 +1137,20 @@ export class SubgraphNode extends LGraphNode implements BaseLGraph {
       if (store.isPromoted(this.rootGraph.id, this.id, source)) continue
       store.promote(this.rootGraph.id, this.id, source)
     }
+
+    // Restore per-instance promoted widget values from serialized widgets_values.
+    // LGraphNode.configure skips promoted widgets (serialize === false), so they
+    // must be applied here after the promoted views are created.
+    if (this._pendingWidgetsValues) {
+      const views = this._getPromotedViews()
+      let i = 0
+      for (const view of views) {
+        if (i >= this._pendingWidgetsValues.length) break
+        // Use the setter which stores in instance Map AND syncs to inner node
+        view.value = this._pendingWidgetsValues[i++] as typeof view.value
+      }
+      this._pendingWidgetsValues = undefined
+    }
   }
 
   /**