test: pin the comfyui-promptchain slot-replacement break to the read path

Replays the two functions the one confirmed-broken pack actually runs
(mobcat40/ComfyUI-PromptChain order-chain.js:123 and main.js:507) against the
ECS branch. The break is a read divergence, not a rejected write:
replaceNodeInputs never rejects on any promptchain sequence.

Adds a forced-rejection arm that pins the slotLinks.ts:192 early return, so
the claim that a rejected batch abandons the node layout is asserted rather
than read off the source.

Author: christian-byrne

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

@@ -1,12 +1,13 @@
 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 type {
   INodeInputSlot,
   INodeOutputSlot
 } from '@/lib/litegraph/src/interfaces'
 import { LGraph, LGraphNode } from '@/lib/litegraph/src/litegraph'
+import { useLinkStore } from '@/stores/linkStore'
 
 function connectedPair() {
   const graph = new LGraph()
@@ -159,3 +160,122 @@ describe('legacy slot link creation and plain-object slots (uncovered)', () => {
     expect(target.isInputConnected(0)).toBe(false)
   })
 })
+
+function autogrowChain(inputCount: number, connectedSlots: number[]) {
+  const graph = new LGraph()
+  const source = new LGraphNode('Source')
+  source.addOutput('out', 'STRING')
+  graph.add(source)
+
+  const target = new LGraphNode('PromptChain')
+  for (let i = 0; i < inputCount; i++) {
+    target.addInput(`inputs.in_${i}`, 'STRING')
+  }
+  graph.add(target)
+  for (const slot of connectedSlots) source.connect(0, target, slot)
+
+  return { graph, source, target }
+}
+
+/** mobcat40/ComfyUI-PromptChain js/lib/order-chain.js:123 `updateInputLabels`. */
+function replaceSlotsWithLabelledCopies(node: LGraphNode) {
+  for (const [index, slot] of node.inputs.entries()) {
+    if (!slot.name.includes('in_')) continue
+    slot.label = slot.link == null ? 'in' : 'PromptChain'
+    node.inputs[index] = { ...slot }
+  }
+}
+
+/** mobcat40/ComfyUI-PromptChain js/main.js:507 `trimEmptyAutogrowSlots`. */
+function trimEmptyAutogrowSlots(node: LGraphNode) {
+  const { inputs } = node
+  const autogrow = inputs.filter((input) => input.name.startsWith('inputs.in_'))
+  if (autogrow.length <= 1) return
+
+  const lastConnected = autogrow.findLastIndex((input) => input.link != null)
+  const keepCount = Math.max(1, lastConnected + 2)
+  if (keepCount >= autogrow.length) return
+
+  for (const input of autogrow.slice(keepCount)) {
+    const index = inputs.indexOf(input)
+    if (index !== -1) inputs.splice(index, 1)
+  }
+}
+
+describe('comfyui-promptchain indexed slot replacement', () => {
+  beforeEach(() => {
+    setActivePinia(createTestingPinia({ stubActions: false }))
+  })
+
+  it('keeps the link store correct when the pack replaces every slot', () => {
+    const { graph, target } = autogrowChain(4, [0, 1, 2])
+
+    replaceSlotsWithLabelledCopies(target)
+    target.removeInput(0)
+
+    expect(target.inputs).toHaveLength(3)
+    expect(graph.links.size).toBe(2)
+    expect(target.isInputConnected(0)).toBe(true)
+    expect(target.isInputConnected(1)).toBe(true)
+    expect(target.isInputConnected(2)).toBe(false)
+  })
+
+  it('never rejects the endpoint batch, though a rejection is detectable', () => {
+    const consoleError = vi.spyOn(console, 'error').mockImplementation(() => {})
+    const rejected = () =>
+      consoleError.mock.calls.filter(
+        ([message]) => message === 'Failed to replace node inputs'
+      ).length
+
+    const live = autogrowChain(4, [0, 1, 2])
+    replaceSlotsWithLabelledCopies(live.target)
+    trimEmptyAutogrowSlots(live.target)
+    replaceSlotsWithLabelledCopies(live.target)
+    live.target.removeInput(0)
+    expect(rejected()).toBe(0)
+
+    const forced = autogrowChain(4, [0, 1, 2])
+    const layoutBefore = forced.target.inputs.map((input) => input.name)
+    vi.spyOn(useLinkStore(), 'updateEndpoints').mockReturnValue({
+      ok: false,
+      error: { code: 'occupied-target', message: 'forced' }
+    })
+    forced.target.removeInput(0)
+
+    expect(rejected()).toBe(1)
+    expect(forced.target.inputs.map((input) => input.name)).toEqual(
+      layoutBefore
+    )
+
+    consoleError.mockRestore()
+  })
+
+  it.fails('reads the live link id back through a spread copy', () => {
+    const { target } = autogrowChain(2, [0])
+    const linkId = target.getInputLink(0)!.id
+
+    const copy: INodeInputSlot = { ...target.inputs[0] }
+    target.inputs[0] = copy
+
+    expect(target.inputs[0].link).toBe(linkId)
+  })
+
+  it.fails('keeps connected inputs when the pack re-reads slot.link', () => {
+    const { graph, target } = autogrowChain(4, [0, 1, 2])
+
+    replaceSlotsWithLabelledCopies(target)
+    trimEmptyAutogrowSlots(target)
+
+    expect(target.inputs).toHaveLength(4)
+    expect(graph.links.size).toBe(3)
+  })
+
+  it('keeps every input when the same trim reads live slots', () => {
+    const { graph, target } = autogrowChain(4, [0, 1, 2])
+
+    trimEmptyAutogrowSlots(target)
+
+    expect(target.inputs).toHaveLength(4)
+    expect(graph.links.size).toBe(3)
+  })
+})