fix: address ECS migration review findings

src/components/builder/AppModeWidgetList.vue

@@ -1,5 +1,5 @@
 <script setup lang="ts">
-import { computed, provide } from 'vue'
+import { computed, provide, watchEffect } from 'vue'
 import { useI18n } from 'vue-i18n'
 
 import WidgetDescription from '@/components/builder/WidgetDescription.vue'
@@ -87,15 +87,22 @@ function isWidgetInputLinked(node: LGraphNode, widgetName: string): boolean {
   return linkStore.isInputSlotConnected(graphScopeOf(graph), node.id, slot)
 }
 
+watchEffect(() => {
+  for (const entry of resolvedInputs.value) {
+    if (entry.status !== 'resolved') continue
+    if (entry.node.mode !== LGraphEventMode.ALWAYS) continue
+    ensureSelectedWidgetState(entry.widgetId, entry.widget)
+  }
+})
+
 const mappedSelections = computed((): WidgetEntry[] => {
   return resolvedInputs.value.flatMap((entry) => {
     if (entry.status !== 'resolved') return []
     const { widgetId, node, widget, config } = entry
     if (node.mode !== LGraphEventMode.ALWAYS) return []
 
-    ensureSelectedWidgetState(widgetId, widget)
-    const fullNodeData = nodeToNodeData(node, widgetId)
     if (isWidgetInputLinked(node, widget.name)) return []
+    const fullNodeData = nodeToNodeData(node, widgetId)
 
     return [
       {

src/lib/litegraph/src/LGraph.inputSlotRealign.test.ts

@@ -1,13 +1,16 @@
 import { createTestingPinia } from '@pinia/testing'
 import { setActivePinia } from 'pinia'
-import { beforeEach, describe, expect, it } from 'vitest'
+import { beforeEach, describe, expect, it, vi } from 'vitest'
 
 import {
   SUBGRAPH_INPUT_ID,
   SUBGRAPH_OUTPUT_ID
 } from '@/lib/litegraph/src/constants'
 import { LGraph, LGraphNode, LiteGraph } from '@/lib/litegraph/src/litegraph'
-import { realignInputLinkSlots } from '@/lib/litegraph/src/linkDeduplication'
+import {
+  normalizeConfiguredTopology,
+  realignInputLinkSlots
+} from '@/lib/litegraph/src/linkDeduplication'
 import type {
   ExportedSubgraph,
   ISerialisedNode,
@@ -306,6 +309,27 @@ function assertLinksRealigned(graph: LGraph, targetNodeId: NodeId) {
   }
 }
 
+describe('normalizeConfiguredTopology', () => {
+  it('keeps the competing link referenced by the target input', () => {
+    vi.spyOn(console, 'warn').mockImplementation(() => {})
+    const data = savedWorkflow()
+    const target = data.nodes?.find((node) => node.id === 2)
+    if (!target?.inputs || !data.links) throw new Error('Invalid fixture')
+    target.inputs[0].link = 2
+    data.links[1].origin_id = 99
+    data.links[1].target_slot = 0
+
+    const normalized = normalizeConfiguredTopology(data)
+
+    expect(normalized.links?.map((link) => link.id)).toEqual([2, 3])
+    expect(normalized.nodes?.[1].inputs?.[0].link).toBe(2)
+    expect(console.warn).toHaveBeenCalledWith(
+      'Dropping competing link to an occupied input',
+      expect.objectContaining({ droppedLinkId: 2, survivorLinkId: 1 })
+    )
+  })
+})
+
 describe('LGraph.configure input slot realignment (#3348)', () => {
   beforeEach(() => {
     setActivePinia(createTestingPinia({ stubActions: false }))
@@ -411,4 +435,37 @@ describe('realignInputLinkSlots', () => {
       link.id
     )
   })
+
+  it('continues after one link cannot be realigned', () => {
+    vi.spyOn(console, 'error').mockImplementation(() => {})
+    const graph = new LGraph()
+    const source = new LGraphNode('Source')
+    source.addOutput('out', 'number')
+    const target = new LGraphNode('Target')
+    target.addInput('first', 'number')
+    target.addInput('occupied', 'number')
+    target.addInput('third', 'number')
+    target.addInput('destination', 'number')
+    graph.add(source)
+    graph.add(target)
+    const blocked = source.connect(0, target, 0)!
+    source.connect(0, target, 1)
+    const movable = source.connect(0, target, 2)!
+    const nodeData = target.serialize()
+    nodeData.inputs = [
+      { ...nodeData.inputs![0], name: 'occupied', link: blocked.id },
+      { ...nodeData.inputs![1], name: 'removed', link: null },
+      { ...nodeData.inputs![2], link: null },
+      { ...nodeData.inputs![3], link: movable.id }
+    ]
+
+    realignInputLinkSlots(graph, [nodeData])
+
+    expect(blocked.target_slot).toBe(0)
+    expect(movable.target_slot).toBe(3)
+    expect(console.error).toHaveBeenCalledWith(
+      'Failed to realign input link slot',
+      expect.objectContaining({ code: 'occupied-target' })
+    )
+  })
 })

src/lib/litegraph/src/LGraph.test.ts

@@ -886,6 +886,47 @@ describe('Graph Clearing and Callbacks', () => {
       []
     )
   })
+
+  test('configure clears state already stored under the incoming graph id', () => {
+    const incoming = new LGraph()
+    const incomingId = 'graph-configure-cleanup' as UUID
+    incoming.id = incomingId
+    const data = incoming.asSerialisable()
+    const staleNodeId = toNodeId(77)
+    const staleWidgetId = widgetId(incomingId, staleNodeId, 'seed')
+    useWidgetValueStore().registerWidget(staleWidgetId, {
+      type: 'number',
+      value: 1,
+      options: {}
+    })
+    usePreviewExposureStore().addExposure(incomingId, String(staleNodeId), {
+      sourceNodeId: '10',
+      sourcePreviewName: '$$canvas-image-preview'
+    })
+    layoutStore.applyOperation({
+      type: 'createNode',
+      graphId: incomingId,
+      nodeId: staleNodeId,
+      layout: {
+        id: staleNodeId,
+        position: { x: 0, y: 0 },
+        size: { width: 100, height: 100 },
+        zIndex: 1,
+        visible: true,
+        bounds: { x: 0, y: 0, width: 100, height: 100 }
+      },
+      timestamp: Date.now(),
+      source: LayoutSource.Canvas
+    })
+
+    new LGraph().configure(data)
+
+    expect(useWidgetValueStore().getWidget(staleWidgetId)).toBeUndefined()
+    expect(
+      usePreviewExposureStore().getExposures(incomingId, String(staleNodeId))
+    ).toEqual([])
+    expect(layoutStore.getNodeLayout(incomingId, staleNodeId)).toBeNull()
+  })
 })
 
 describe('node:before-removed event', () => {

src/lib/litegraph/src/LGraph.ts

@@ -2817,9 +2817,12 @@ export class LGraph
       if (options.clearGraph) {
         const topologyScope = graphScopeOf(this)
         if (this.isRootGraph) {
+          usePreviewExposureStore().clearGraph(this.id)
+          useWidgetValueStore().clearGraph(this.id)
           useLinkStore().clearGraph(topologyScope.rootGraphId)
           useRerouteStore().clearGraph(topologyScope.rootGraphId)
           useNodeDataStore().clearGraph(this.id)
+          layoutStore.clearGraph(this.id)
         } else {
           useLinkStore().clearOwner(topologyScope)
           useRerouteStore().clearOwner(topologyScope)

src/lib/litegraph/src/LGraphCanvas.titleButtons.test.ts

@@ -8,6 +8,7 @@ import {
   LGraphNode,
   LiteGraph
 } from '@/lib/litegraph/src/litegraph'
+import { RenderShape } from '@/lib/litegraph/src/types/globalEnums'
 
 describe('LGraphCanvas Title Button Rendering', () => {
   let canvas: LGraphCanvas
@@ -86,6 +87,18 @@ describe('LGraphCanvas Title Button Rendering', () => {
   })
 
   describe('drawNode title button rendering', () => {
+    it('clips using the node rendering shape', () => {
+      Object.defineProperty(node, 'constructor', {
+        value: { shape: RenderShape.ROUND }
+      })
+      node.clip_area = true
+
+      canvas.drawNode(node, ctx)
+
+      expect(ctx.roundRect).toHaveBeenCalled()
+      expect(ctx.rect).not.toHaveBeenCalled()
+    })
+
     it('should render visible title buttons', () => {
       const button1 = node.addTitleButton({
         name: 'button1',

src/lib/litegraph/src/LGraphCanvas.ts

@@ -5684,7 +5684,7 @@ export class LGraphCanvas implements CustomEventDispatcher<LGraphCanvasEventMap>
       return
 
     // clip if required (mask)
-    const shape = node.shape || RenderShape.BOX
+    const shape = node.renderingShape
     const size = temp_vec2
     size[0] = node.renderingSize[0]
     size[1] = node.renderingSize[1]

src/lib/litegraph/src/LGraphNode.test.ts

@@ -271,7 +271,7 @@ describe('LGraphNode', () => {
       const disconnected = node2.disconnectInput(0)
       expect(disconnected).toBe(true)
       expect(node2.inputs[0].link).toBeNull()
-      expect(node1.outputs[0].links).toBeNull()
+      expect(node1.outputs[0].links).toEqual([])
       expect(graph.links.has(link!.id)).toBe(false)
 
       // Test disconnecting by slot name
@@ -347,7 +347,7 @@ describe('LGraphNode', () => {
       )
       expect(disconnectedByName).toBe(true)
       expect(targetNode1.inputs[0].link).toBeNull()
-      expect(sourceNode.outputs[1].links).toBeNull()
+      expect(sourceNode.outputs[1].links).toEqual([])
 
       // Test disconnecting all connections from an output
       const link4 = sourceNode.connect(0, targetNode1, 0)

src/lib/litegraph/src/LGraphNode.ts

@@ -3377,6 +3377,9 @@ export class LGraphNode
         ? graph.getNodeById(target_node)
         : target_node
     if (target_node && !onlyTarget) throw 'Target Node not found'
+    if (output instanceof NodeOutputSlot) {
+      output._setLegacyLinksPresent(Boolean(onlyTarget))
+    }
 
     for (const link_info of outputLinks(graph, this.id, slot)) {
       if (onlyTarget && link_info.target_id != onlyTarget.id) continue

src/lib/litegraph/src/LLink.store.test.ts

@@ -530,6 +530,27 @@ describe('LLink ↔ linkStore integration', () => {
     )
   })
 
+  it('reports a rejected legacy endpoint mutation', () => {
+    const graph = new LGraph()
+    const firstSource = new LGraphNode('First source')
+    const secondSource = new LGraphNode('Second source')
+    const target = new LGraphNode('Target')
+    firstSource.addOutput('out', 'INT')
+    secondSource.addOutput('out', 'INT')
+    target.addInput('first', 'INT')
+    target.addInput('second', 'INT')
+    graph.add(firstSource)
+    graph.add(secondSource)
+    graph.add(target)
+    const first = firstSource.connect(0, target, 0)!
+    secondSource.connect(0, target, 1)
+
+    expect(() => {
+      first.target_slot = 1
+    }).toThrow('Failed to update link endpoints (occupied-target)')
+    expect(first.target_slot).toBe(0)
+  })
+
   it('updates regular and floating views after endpoint changes', () => {
     const graph = new LGraph()
     const a = new LGraphNode('A')

src/lib/litegraph/src/LLink.ts

@@ -115,7 +115,9 @@ function applyEndpointPatch(link: LLink, patch: EndpointPatch): void {
       patch
     )
     if (!result.ok) {
-      console.error('Failed to update link endpoints', result.error)
+      throw new Error(
+        `Failed to update link endpoints (${result.error.code}): ${result.error.message}`
+      )
     }
   } else {
     Object.assign(link._state, patch)

src/lib/litegraph/src/canvas/LinkConnector.integration.test.ts

@@ -448,7 +448,7 @@ describe('LinkConnector Integration', () => {
       expect(connector.outputLinks.length).toBe(0)
 
       expect(disconnectedNode.outputs[0].links).toHaveLength(2)
-      expect(hasOutputNode.outputs[0].links).toBeNull()
+      expect(hasOutputNode.outputs[0].links).toEqual([])
 
       const reroutesAfter = disconnectedNode.outputs[0].links
         ?.map((linkId) => graph.links.get(linkId)!)

src/lib/litegraph/src/linkDeduplication.ts

@@ -59,29 +59,55 @@ export function normalizeConfiguredTopology<T extends ConfiguredGraph>(
 ): T {
   if (!data.links?.length) return data
 
-  const survivorByTarget = new Map<string, ReturnType<typeof linkFields>>()
+  const referencedInputLinks = new Set(
+    (data.nodes ?? []).flatMap((node) =>
+      (node.inputs ?? []).flatMap((input) =>
+        input.link == null ? [] : [input.link]
+      )
+    )
+  )
+  const survivorIndexByTarget = new Map<string, number>()
   const survivorByDuplicateId = new Map<number, number>()
-  const links = data.links.filter((link) => {
+  const links: ConfiguredLink[] = []
+  for (const link of data.links) {
     const fields = linkFields(link)
     const key = `${toNodeId(fields.target_id)}:${fields.target_slot}`
-    const survivor = survivorByTarget.get(key)
-    if (!survivor) {
-      survivorByTarget.set(key, fields)
-      return true
+    const survivorIndex = survivorIndexByTarget.get(key)
+    if (survivorIndex === undefined) {
+      survivorIndexByTarget.set(key, links.length)
+      links.push(link)
+      continue
     }
-    if (
+    const survivor = linkFields(links[survivorIndex])
+    const isExactDuplicate =
       toNodeId(survivor.origin_id) === toNodeId(fields.origin_id) &&
       survivor.origin_slot === fields.origin_slot
+    if (!isExactDuplicate) {
+      console.warn('Dropping competing link to an occupied input', {
+        droppedLinkId: fields.id,
+        survivorLinkId: survivor.id,
+        targetNodeId: fields.target_id,
+        targetSlot: fields.target_slot
+      })
+    }
+
+    if (
+      !isExactDuplicate &&
+      referencedInputLinks.has(fields.id) &&
+      !referencedInputLinks.has(survivor.id)
     ) {
+      links[survivorIndex] = link
+      for (const [id, survivorId] of survivorByDuplicateId) {
+        if (survivorId === survivor.id) survivorByDuplicateId.set(id, fields.id)
+      }
+      survivorByDuplicateId.set(survivor.id, fields.id)
+    } else {
       survivorByDuplicateId.set(fields.id, survivor.id)
     }
-    return false
-  })
+  }
   if (links.length === data.links.length) return data
 
   const normalized = Object.assign({}, data, { links })
-  if (!survivorByDuplicateId.size) return normalized
-
   const cloned = cloneDeep(normalized)
   remapLinkReferences(cloned, survivorByDuplicateId)
   return cloned
@@ -156,7 +182,24 @@ export function realignInputLinkSlots(
         updates
       )
       if (!result.ok) {
-        console.error('Failed to realign input link slots', result.error)
+        for (const { link, slot } of moved) {
+          const fallback = useLinkStore().updateEndpoint(
+            graphScopeOf(graph),
+            link._state,
+            { targetSlot: slot }
+          )
+          if (!fallback.ok) {
+            console.error('Failed to realign input link slot', fallback.error)
+            continue
+          }
+          node.onConnectionsChange?.(
+            NodeSlotType.INPUT,
+            slot,
+            true,
+            link,
+            node.inputs[slot]
+          )
+        }
         break
       }
       for (const { link, slot } of moved) {

src/lib/litegraph/src/node/NodeOutputSlot.test.ts

@@ -55,6 +55,15 @@ describe('NodeOutputSlot deprecated links getter', () => {
     expect(source.outputs[0].links).toBeNull()
   })
 
+  it('retains an empty array after disconnecting a specific target', () => {
+    const { source, target } = createConnectedGraph()
+    source.connect(0, target, 0)
+
+    source.disconnectOutput(0, target)
+
+    expect(source.outputs[0].links).toEqual([])
+  })
+
   it('returns null for an unconnected slot and for a graphless node', () => {
     const { source } = createConnectedGraph()
     expect(source.outputs[0].links).toBeNull()