test: reproduce #15577 and #15581 on the ECS branch

Seven it.fails assertions covering both configure-time link defects, plus
controls that keep them honest.

#15577: normalizeConfiguredTopology keys duplicates on target_id:target_slot
and keeps data.links[first] rather than the link input.link names, so a
workflow with two links into one input comes up wired to the wrong upstream
node. conflictingOriginLinksRoot is byte-for-byte what main serializes after a
pack creates a link through the legacy slot mirrors alone.

#15581: a serialized input whose name has no live counterpart keeps its stale
target_slot, the resulting occupied-target rejection breaks the loop, and every
remaining move for that node is abandoned. Covers the dropped-input, renamed-
input and directly-rejected-batch cases.

Author: christian-byrne

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

@@ -1,6 +1,6 @@
 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,
@@ -379,6 +379,194 @@ describe('LGraph.configure input slot realignment (#3348)', () => {
   })
 })
 
+const SHRUNK_DEFINITION_ORDER = ['in_a', 'in_b']
+
+/** Drops any serialized input its definition no longer declares. */
+class DroppedInputTargetNode extends LGraphNode {
+  constructor(title?: string) {
+    super(title ?? 'DroppedInputTarget')
+    for (const name of SHRUNK_DEFINITION_ORDER) this.addInput(name, 'number')
+  }
+
+  override configure(data: ISerialisedNode): void {
+    data.inputs = (data.inputs ?? [])
+      .filter((input) => SHRUNK_DEFINITION_ORDER.includes(input.name))
+      .sort(
+        (a, b) =>
+          SHRUNK_DEFINITION_ORDER.indexOf(a.name) -
+          SHRUNK_DEFINITION_ORDER.indexOf(b.name)
+      )
+    super.configure(data)
+  }
+}
+
+const RENAMED_DEFINITION_ORDER = ['in_a', 'in_b', 'in_c_v2']
+
+/** Renames a live input after configure, as a pack migrating a slot does. */
+class RenamedInputTargetNode extends LGraphNode {
+  constructor(title?: string) {
+    super(title ?? 'RenamedInputTarget')
+    for (const name of RENAMED_DEFINITION_ORDER) this.addInput(name, 'number')
+  }
+
+  override configure(data: ISerialisedNode): void {
+    super.configure(data)
+    for (const input of this.inputs) {
+      if (input.name === 'in_c') input.name = 'in_c_v2'
+    }
+    this.inputs.sort(
+      (a, b) =>
+        RENAMED_DEFINITION_ORDER.indexOf(a.name) -
+        RENAMED_DEFINITION_ORDER.indexOf(b.name)
+    )
+  }
+}
+
+/**
+ * Serialized target carrying one input name the live node will not have.
+ * `in_c` holds link 3 at slot 0, so the moves `1: 1 -> 0` and `2: 2 -> 1`
+ * form a batch whose first member collides with link 3's stale placement.
+ */
+function unmatchedInputNameWorkflow(nodeType: string): SerialisableGraph {
+  return {
+    id: 'ab000000-0000-4000-8000-000000000004',
+    version: 1,
+    revision: 0,
+    state: { lastNodeId: 2, lastLinkId: 3, lastGroupId: 0, lastRerouteId: 0 },
+    nodes: [
+      {
+        id: 1,
+        type: 'test/RealignSource',
+        pos: [0, 0],
+        size: [140, 60],
+        flags: {},
+        order: 0,
+        mode: 0,
+        inputs: [],
+        outputs: [{ name: 'out', type: 'number', links: [1, 2, 3] }],
+        properties: {}
+      },
+      {
+        id: 2,
+        type: nodeType,
+        pos: [300, 0],
+        size: [140, 80],
+        flags: {},
+        order: 1,
+        mode: 0,
+        inputs: [
+          { name: 'in_c', type: 'number', link: 3 },
+          { name: 'in_a', type: 'number', link: 1 },
+          { name: 'in_b', type: 'number', link: 2 }
+        ],
+        outputs: [],
+        properties: {}
+      }
+    ],
+    links: [
+      {
+        id: 3,
+        origin_id: 1,
+        origin_slot: 0,
+        target_id: 2,
+        target_slot: 0,
+        type: 'number'
+      },
+      {
+        id: 1,
+        origin_id: 1,
+        origin_slot: 0,
+        target_id: 2,
+        target_slot: 1,
+        type: 'number'
+      },
+      {
+        id: 2,
+        origin_id: 1,
+        origin_slot: 0,
+        target_id: 2,
+        target_slot: 2,
+        type: 'number'
+      }
+    ]
+  }
+}
+
+describe('LGraph.configure realignment with an unmatched input name (#15581)', () => {
+  beforeEach(() => {
+    setActivePinia(createTestingPinia({ stubActions: false }))
+    LiteGraph.registerNodeType('test/RealignSource', SourceNode)
+    LiteGraph.registerNodeType(
+      'test/DroppedInputTarget',
+      DroppedInputTargetNode
+    )
+    LiteGraph.registerNodeType(
+      'test/RenamedInputTarget',
+      RenamedInputTargetNode
+    )
+  })
+
+  it.fails('realigns siblings when configure drops an input', () => {
+    const graph = new LGraph()
+    graph.configure(unmatchedInputNameWorkflow('test/DroppedInputTarget'))
+
+    const target = graph.getNodeById(toNodeId(2))!
+    expect(target.getInputLink(0)?.id).toBe(toLinkId(1))
+    expect(target.getInputLink(1)?.id).toBe(toLinkId(2))
+  })
+
+  it.fails('realigns siblings when configure renames an input', () => {
+    const graph = new LGraph()
+    graph.configure(unmatchedInputNameWorkflow('test/RenamedInputTarget'))
+
+    const target = graph.getNodeById(toNodeId(2))!
+    expect(target.getInputLink(0)?.id).toBe(toLinkId(1))
+    expect(target.getInputLink(1)?.id).toBe(toLinkId(2))
+  })
+
+  it.fails('reports no error while realigning around an unmatched name', () => {
+    const error = vi.spyOn(console, 'error').mockImplementation(() => {})
+
+    const graph = new LGraph()
+    graph.configure(unmatchedInputNameWorkflow('test/DroppedInputTarget'))
+
+    expect(error).not.toHaveBeenCalled()
+  })
+})
+
+describe('realignInputLinkSlots with a rejected batch (#15581)', () => {
+  beforeEach(() => {
+    setActivePinia(createTestingPinia({ stubActions: false }))
+  })
+
+  it.fails('lands the non-conflicting moves when one move is blocked', () => {
+    const graph = new LGraph()
+    const source = new LGraphNode('Source')
+    source.addOutput('out', 'number')
+    const target = new LGraphNode('Target')
+    for (const name of ['p', 'q', 'r']) target.addInput(name, 'number')
+    graph.add(source)
+    graph.add(target)
+
+    const squatter = source.connect(0, target, 0)!
+    const blocked = source.connect(0, target, 1)!
+    const free = source.connect(0, target, 2)!
+
+    const nodeData = target.serialize()
+    nodeData.inputs = [
+      { name: 'no_such_input', type: 'number', link: squatter.id },
+      { name: 'p', type: 'number', link: blocked.id },
+      { name: 'q', type: 'number', link: free.id }
+    ]
+
+    realignInputLinkSlots(graph, [nodeData])
+
+    expect(
+      useLinkStore().getInputSlotLink(graphScopeOf(graph), target.id, 1)?.id
+    ).toBe(free.id)
+  })
+})
+
 describe('realignInputLinkSlots', () => {
   beforeEach(() => {
     setActivePinia(createTestingPinia({ stubActions: false }))

src/lib/litegraph/src/__fixtures__/duplicateLinks.ts

@@ -73,6 +73,85 @@ export const duplicateLinksRoot: SerialisableGraph = {
   ]
 }
 
+/**
+ * Root graph where two links target the same input from *different* origins.
+ * SourceA (id 1) holds link 1, SourceB (id 2) holds link 2, and Target's
+ * serialized `inputs[0]` references link **2** — so the first link in array
+ * order and the link `input.link` names disagree.
+ *
+ * Not hypothetical: this is byte-for-byte what `main` serializes after a pack
+ * creates a link through the legacy slot mirrors alone (`output.links.push`,
+ * `input.link =`) instead of `node.connect()`, which is rgthree `link_fixer`'s
+ * repair idiom. Reproduced against `main` at 32d0b6e202.
+ */
+export const conflictingOriginLinksRoot: SerialisableGraph = {
+  id: 'dd000000-0000-4000-8000-000000000004',
+  version: 1,
+  revision: 0,
+  state: {
+    lastNodeId: 3,
+    lastLinkId: 2,
+    lastGroupId: 0,
+    lastRerouteId: 0
+  },
+  nodes: [
+    {
+      id: 1,
+      type: 'test/DupTestNode',
+      pos: [0, 0],
+      size: [200, 100],
+      flags: {},
+      order: 0,
+      mode: 0,
+      inputs: [{ name: 'input_0', type: 'number', link: null }],
+      outputs: [{ name: 'output_0', type: 'number', links: [1] }],
+      properties: {}
+    },
+    {
+      id: 2,
+      type: 'test/DupTestNode',
+      pos: [0, 200],
+      size: [200, 100],
+      flags: {},
+      order: 1,
+      mode: 0,
+      inputs: [{ name: 'input_0', type: 'number', link: null }],
+      outputs: [{ name: 'output_0', type: 'number', links: [2] }],
+      properties: {}
+    },
+    {
+      id: 3,
+      type: 'test/DupTestNode',
+      pos: [300, 0],
+      size: [200, 100],
+      flags: {},
+      order: 2,
+      mode: 0,
+      inputs: [{ name: 'input_0', type: 'number', link: 2 }],
+      outputs: [{ name: 'output_0', type: 'number', links: [] }],
+      properties: {}
+    }
+  ],
+  links: [
+    {
+      id: 1,
+      origin_id: 1,
+      origin_slot: 0,
+      target_id: 3,
+      target_slot: 0,
+      type: 'number'
+    },
+    {
+      id: 2,
+      origin_id: 2,
+      origin_slot: 0,
+      target_id: 3,
+      target_slot: 0,
+      type: 'number'
+    }
+  ]
+}
+
 /**
  * Root graph with slot-shifted duplicates. Target node has an extra input
  * (simulating widget-to-input conversion) that shifts the connected input