capdag 0.106.243 → 0.119.263

package/capdag.test.js

@@ -3755,6 +3755,7 @@ const {
   canonicalMediaUrn: rendererCanonicalMediaUrn,
   mediaNodeLabel: rendererMediaNodeLabel,
   buildStrandGraphData: rendererBuildStrandGraphData,
+  collapseStrandShapeTransitions: rendererCollapseStrandShapeTransitions,
   buildRunGraphData: rendererBuildRunGraphData,
   buildMachineGraphData: rendererBuildMachineGraphData,
   classifyStrandCapSteps: rendererClassifyStrandCapSteps,
@@ -4030,86 +4031,441 @@ function testRenderer_classifyStrandCapSteps_nestedForks() {
   assert(!capFlags.get(5).prevForEach && capFlags.get(5).nextCollect, 'cap3 outer exit');
 }
 
-function testRenderer_buildStrandGraphData_labelsForkBoundaries() {
-  // End-to-end: a foreach strand in which source_spec (media:pdf;list)
-  // differs from the first cap's from_spec (media:pdf) produces an
-  // explicit fix-up edge source→firstCap.from labeled "for each". The
-  // cap edge carries only the cap title. The topology is
-  //   media:pdf;list --[for each]--> media:pdf --[extract text]--> media:txt
-  // Only two edges — ForEach is NOT a separate node, Collect is absent
-  // because the strand's target_spec already matches the last cap's
-  // to_spec (no fan-in fix-up needed).
+// Helper: find an edge with the given source/target ids.
+function findEdge(edges, source, target) {
+  return edges.find(e => e.source === source && e.target === target);
+}
+
+function testRenderer_buildStrandGraphData_singleCapPlain() {
+  // Minimal strand with one plain 1→1 cap. Plan builder produces:
+  //   input_slot → step_0 (cap) → output
+  // (two edges, three nodes). No cardinality marker in the cap label
+  // because input_is_sequence == output_is_sequence == false.
+  const payload = {
+    source_spec: 'media:a',
+    target_spec: 'media:b',
+    steps: [
+      makeCapStep('cap:in="media:a";op=x;out="media:b"', 'x', 'media:a', 'media:b', false, false),
+    ],
+  };
+  const built = rendererBuildStrandGraphData(payload);
+  const nodeIds = built.nodes.map(n => n.id).sort();
+  assertEqual(JSON.stringify(nodeIds), JSON.stringify(['input_slot', 'output', 'step_0']),
+    'nodes are input_slot + step_0 + output (positional ids)');
+  assertEqual(built.edges.length, 2, 'two edges: input_slot→step_0 and step_0→output');
+  const capEdge = findEdge(built.edges, 'input_slot', 'step_0');
+  assert(capEdge !== undefined, 'cap edge from input_slot to step_0 exists');
+  assertEqual(capEdge.label, 'x', 'plain cap edge label is the cap title with no cardinality marker');
+  const outEdge = findEdge(built.edges, 'step_0', 'output');
+  assert(outEdge !== undefined, 'output edge from step_0 to output exists');
+}
+
+function testRenderer_buildStrandGraphData_sequenceShowsCardinality() {
+  // A cap with input_is_sequence=true MUST emit "(n→1)" on its edge
+  // label.
+  const payload = {
+    source_spec: 'media:a;list',
+    target_spec: 'media:b',
+    steps: [
+      makeCapStep('cap:in="media:a;list";op=x;out="media:b"', 'x', 'media:a;list', 'media:b', true, false),
+    ],
+  };
+  const built = rendererBuildStrandGraphData(payload);
+  const capEdge = findEdge(built.edges, 'input_slot', 'step_0');
+  assert(capEdge !== undefined, 'cap edge exists');
+  assert(capEdge.label.includes('(n\u21921)'),
+    `cap edge label must include (n\u21921) marker; got: ${capEdge.label}`);
+}
+
+function testRenderer_buildStrandGraphData_foreachCollectSpan() {
+  // Strand: [ForEach, Cap, Collect]. Plan builder produces:
+  //   input_slot (source) →direct→ step_1 (cap) — cap emits its own
+  //                                              direct edge from prev
+  //   input_slot →direct→ step_0 (foreach)      — created when Collect
+  //   step_0 →iteration→ step_1                 — iteration edge
+  //   step_1 →collection→ step_2 (collect)      — collection edge
+  //   step_2 →direct→ output                    — output connector
+  //
+  // (six nodes: input_slot, step_0, step_1, step_2, output; five
+  // edges.) ForEach and Collect are REAL nodes in the graph, not
+  // labels on cap edges — they're distinct processing units in the
+  // plan. This mirrors capdag's plan_builder.rs exactly.
   const payload = {
     source_spec: 'media:pdf;list',
-    target_spec: 'media:txt',
+    target_spec: 'media:txt;list',
     steps: [
       makeForEachStep('media:pdf;list'),
-      makeCapStep('cap:in="media:pdf";op=extract;out="media:txt"', 'extract text', 'media:pdf', 'media:txt', false, false),
+      makeCapStep('cap:in="media:pdf";op=extract;out="media:txt"', 'extract', 'media:pdf', 'media:txt', false, false),
+      makeCollectStep('media:txt'),
     ],
   };
   const built = rendererBuildStrandGraphData(payload);
-  assertEqual(built.edges.length, 2, 'one fix-up edge + one cap edge');
-  const forEachEdge = built.edges[0];
-  assertEqual(forEachEdge.label, 'for each', 'first edge is the for-each fan-out');
-  assertEqual(forEachEdge.source, 'media:pdf;list', 'for-each sources from source_spec');
-  assertEqual(forEachEdge.target, 'media:pdf', 'for-each targets first cap.from_spec');
-  const capEdge = built.edges[1];
-  assertEqual(capEdge.label, 'extract text', 'cap edge carries only the cap title');
-  assertEqual(capEdge.source, 'media:pdf', 'cap sources from its from_spec');
-  assertEqual(capEdge.target, 'media:txt', 'cap targets its to_spec');
-}
-
-function testRenderer_buildStrandGraphData_collectFixupEdge() {
-  // When the strand's target_spec (media:pdf;list) differs from the
-  // last cap's to_spec (media:pdf), the builder emits an explicit
-  // fix-up edge lastCap.to → target labeled "collect".
+  const nodeIds = built.nodes.map(n => n.id).sort();
+  assertEqual(JSON.stringify(nodeIds),
+    JSON.stringify(['input_slot', 'output', 'step_0', 'step_1', 'step_2']),
+    'positional nodes for source, foreach, cap, collect, output');
+
+  // The five edges the plan builder would produce:
+  assert(findEdge(built.edges, 'input_slot', 'step_1') !== undefined,
+    'cap direct edge input_slot→step_1 (prev wasn\'t advanced by ForEach)');
+  assert(findEdge(built.edges, 'input_slot', 'step_0') !== undefined,
+    'foreach input edge input_slot→step_0');
+  assert(findEdge(built.edges, 'step_0', 'step_1') !== undefined,
+    'iteration edge step_0→step_1 (body entry)');
+  assert(findEdge(built.edges, 'step_1', 'step_2') !== undefined,
+    'collection edge step_1→step_2 (body exit → collect)');
+  assert(findEdge(built.edges, 'step_2', 'output') !== undefined,
+    'output edge step_2→output');
+
+  // ForEach and Collect nodes carry their canonical labels.
+  const foreachNode = built.nodes.find(n => n.id === 'step_0');
+  assertEqual(foreachNode.label, 'for each', 'ForEach node labeled "for each"');
+  const collectNode = built.nodes.find(n => n.id === 'step_2');
+  assertEqual(collectNode.label, 'collect', 'Collect node labeled "collect"');
+}
+
+function testRenderer_buildStrandGraphData_standaloneCollect() {
+  // Strand with a standalone Collect (no enclosing ForEach). Plan
+  // builder creates a Collect node consuming prev directly — plain
+  // direct edge, no iteration/collection semantics.
   const payload = {
     source_spec: 'media:a',
-    target_spec: 'media:pdf;list',
+    target_spec: 'media:b;list',
     steps: [
-      makeCapStep('cap:in="media:a";op=x;out="media:pdf"', 'x', 'media:a', 'media:pdf', false, false),
-      makeCollectStep('media:pdf'),
+      makeCapStep('cap:in="media:a";op=x;out="media:b"', 'x', 'media:a', 'media:b', false, false),
+      makeCollectStep('media:b'),
     ],
   };
   const built = rendererBuildStrandGraphData(payload);
-  assertEqual(built.edges.length, 2, 'one cap edge + one collect fix-up');
-  const capEdge = built.edges[0];
-  assertEqual(capEdge.label, 'x', 'cap edge plain title');
-  const collectEdge = built.edges[1];
-  assertEqual(collectEdge.label, 'collect', 'collect fix-up labeled "collect"');
-  assertEqual(collectEdge.source, 'media:pdf', 'collect sources from last cap.to_spec');
-  assertEqual(collectEdge.target, 'media:pdf;list', 'collect targets target_spec');
-}
-
-function testRenderer_buildStrandGraphData_plainCapNoMarker() {
-  // A plain 1→1 cap step (no ForEach/Collect adjacency, no sequence)
-  // must not emit any cardinality marker in the label. This catches a
-  // regression where "1→1" was accidentally appended to every edge.
+  assert(findEdge(built.edges, 'input_slot', 'step_0') !== undefined,
+    'cap edge input_slot → step_0');
+  assert(findEdge(built.edges, 'step_0', 'step_1') !== undefined,
+    'standalone collect edge step_0 → step_1 (Collect node)');
+  assert(findEdge(built.edges, 'step_1', 'output') !== undefined,
+    'output edge step_1 → output');
+  const collectNode = built.nodes.find(n => n.id === 'step_1');
+  assertEqual(collectNode.label, 'collect', 'Collect node labeled "collect"');
+}
+
+function testRenderer_buildStrandGraphData_unclosedForEachBody() {
+  // Strand: [Cap_a, ForEach, Cap_b] with no closing Collect. The plan
+  // builder's "unclosed ForEach" branch creates a ForEach node
+  // connecting Cap_a to Cap_b via iteration, with prev becoming the
+  // body exit (Cap_b).
   const payload = {
     source_spec: 'media:a',
-    target_spec: 'media:b',
+    target_spec: 'media:c',
+    steps: [
+      makeCapStep('cap:in="media:a";op=a;out="media:b"', 'a', 'media:a', 'media:b', false, false),
+      makeForEachStep('media:b'),
+      makeCapStep('cap:in="media:b";op=b;out="media:c"', 'b', 'media:b', 'media:c', false, false),
+    ],
+  };
+  const built = rendererBuildStrandGraphData(payload);
+  // Cap_a connects from input_slot.
+  assert(findEdge(built.edges, 'input_slot', 'step_0') !== undefined,
+    'cap_a edge input_slot → step_0');
+  // Cap_b still connects directly from step_0 (the ForEach didn't
+  // advance prev). This mirrors plan_builder.
+  assert(findEdge(built.edges, 'step_0', 'step_2') !== undefined,
+    'cap_b direct edge step_0 → step_2');
+  // ForEach node at step_1 with direct edge from step_0 and iteration
+  // edge to step_2.
+  assert(findEdge(built.edges, 'step_0', 'step_1') !== undefined,
+    'foreach input edge step_0 → step_1');
+  assert(findEdge(built.edges, 'step_1', 'step_2') !== undefined,
+    'iteration edge step_1 → step_2 (body entry)');
+  // Output connects from step_2 (body exit).
+  assert(findEdge(built.edges, 'step_2', 'output') !== undefined,
+    'output edge step_2 → output');
+}
+
+function testRenderer_buildStrandGraphData_nestedForEachThrows() {
+  // Nested ForEach without an intervening body cap in the outer
+  // ForEach is an illegal nesting per plan_builder. The renderer
+  // must throw the same error to surface the issue rather than
+  // render a malformed graph.
+  const payload = {
+    source_spec: 'media:a;list;list',
+    target_spec: 'media:a',
+    steps: [
+      makeForEachStep('media:a;list;list'),
+      makeForEachStep('media:a;list'),
+      makeCapStep('cap:in="media:a";op=x;out="media:a"', 'x', 'media:a', 'media:a', false, false),
+    ],
+  };
+  let threw = false;
+  try {
+    rendererBuildStrandGraphData(payload);
+  } catch (e) {
+    threw = true;
+    assert(e.message.includes('nested ForEach'),
+      'error must name the nested-ForEach violation');
+  }
+  assert(threw, 'nested ForEach without outer body cap must throw');
+}
+
+function testRenderer_collapseStrand_singleCapBodyShowsCapTitleWithIterCollectMarker() {
+  // User spec: ForEach/Collect are NOT rendered as nodes. The
+  // transition is labeled with the enclosed cap's title + a
+  // cardinality marker. For a single-cap body the marker is n→n
+  // (iterate + collect combined) because the same cap is both
+  // the body entry and the body exit.
+  //
+  // Strand [ForEach, Cap(extract), Collect], source=pdf;list,
+  // target=txt;list — target is NOT equivalent to cap's to_spec
+  // media:txt so the output node is retained.
+  //
+  // Expected render shape: 3 nodes (input_slot, step_1, output),
+  // with the entry edge labeled "extract (n→n)" and a plain
+  // unlabeled connector to the output.
+  const payload = {
+    source_spec: 'media:pdf;list',
+    target_spec: 'media:txt;list',
+    steps: [
+      makeForEachStep('media:pdf;list'),
+      makeCapStep('cap:in="media:pdf";op=extract;out="media:txt"', 'extract', 'media:pdf', 'media:txt', false, false),
+      makeCollectStep('media:txt'),
+    ],
+  };
+  const built = rendererBuildStrandGraphData(payload);
+  const collapsed = rendererCollapseStrandShapeTransitions(built);
+
+  const nodeIds = collapsed.nodes.map(n => n.id).sort();
+  assertEqual(JSON.stringify(nodeIds),
+    JSON.stringify(['input_slot', 'output', 'step_1']),
+    'collapse removes the ForEach and Collect nodes; the remaining nodes are source + cap + target');
+
+  // Exactly one edge from input_slot → step_1, carrying the cap
+  // title + iterate+collect cardinality marker.
+  const entryEdges = collapsed.edges.filter(e => e.source === 'input_slot' && e.target === 'step_1');
+  assertEqual(entryEdges.length, 1,
+    'phantom duplicate cap edge must be gone — exactly one edge from source to cap');
+  assertEqual(entryEdges[0].label, 'extract (n\u2192n)',
+    'single-cap-body edge is labeled "<cap_title> (n→n)"');
+
+  // The exit side is a plain unlabeled connector — the cap title
+  // is already shown on the entry edge.
+  const exitEdges = collapsed.edges.filter(e => e.source === 'step_1' && e.target === 'output');
+  assertEqual(exitEdges.length, 1,
+    'there is exactly one exit edge step_1 → output');
+  assertEqual(exitEdges[0].label, '',
+    'exit connector for a single-cap body is unlabeled (cap title already shown on entry edge)');
+}
+
+function testRenderer_collapseStrand_unclosedForEachBodyCollapses() {
+  // [Cap_a, ForEach, Cap_b] with no Collect, source=media:a,
+  // target=media:c. Cap_b's to_spec is media:c which is
+  // equivalent to target_spec, so the output node is merged
+  // into step_2.
+  //
+  // Raw topology:
+  //   input_slot → step_0 (cap_a) — normal, not in any body
+  //   step_0 → step_2 (cap_b, foreachEntry=true — phantom under
+  //                   plan builder, but the foreach body entry
+  //                   under the render model)
+  //   step_0 → step_1 (foreach direct)
+  //   step_1 → step_2 (iteration)
+  //   step_2 → output (trailing connector, empty label)
+  //
+  // Collapse:
+  //   - step_1 (foreach) removed with its iteration edges.
+  //   - step_0 → step_2 relabeled "b (1→n)" via foreachEntry.
+  //   - step_2 → output merged because upstream.fullUrn equivalent
+  //     to target_spec (both media:c); step_2 takes the target
+  //     display label.
+  //
+  // Final: 3 nodes (input_slot, step_0, step_2), 2 edges.
+  const payload = {
+    source_spec: 'media:a',
+    target_spec: 'media:c',
+    steps: [
+      makeCapStep('cap:in="media:a";op=a;out="media:b"', 'a', 'media:a', 'media:b', false, false),
+      makeForEachStep('media:b'),
+      makeCapStep('cap:in="media:b";op=b;out="media:c"', 'b', 'media:b', 'media:c', false, false),
+    ],
+  };
+  const built = rendererBuildStrandGraphData(payload);
+  const collapsed = rendererCollapseStrandShapeTransitions(built);
+
+  const nodeIds = collapsed.nodes.map(n => n.id).sort();
+  assertEqual(JSON.stringify(nodeIds),
+    JSON.stringify(['input_slot', 'step_0', 'step_2']),
+    'foreach node removed and output merged into step_2 (same URN as target)');
+
+  // Exactly one edge from step_0 to step_2, labeled with cap_b's
+  // title + (1→n) marker.
+  const step0ToStep2 = collapsed.edges.filter(e => e.source === 'step_0' && e.target === 'step_2');
+  assertEqual(step0ToStep2.length, 1,
+    'exactly one step_0 → step_2 edge after dropping the foreach iteration');
+  assertEqual(step0ToStep2[0].label, 'b (1\u2192n)',
+    'the foreach-entry edge is labeled "<cap_b_title> (1→n)"');
+
+  // Cap_a's edge is unchanged (not inside a foreach body).
+  const capA = collapsed.edges.find(e => e.source === 'input_slot' && e.target === 'step_0');
+  assert(capA !== undefined, 'cap_a edge input_slot → step_0 exists');
+  assertEqual(capA.label, 'a', 'cap_a edge carries just its title (no cardinality marker since 1→1)');
+
+  // After merging, step_2 becomes the render target — no separate
+  // output node exists.
+  const outputNode = collapsed.nodes.find(n => n.id === 'output');
+  assertEqual(outputNode, undefined,
+    'output node was merged into step_2 because their URNs are semantically equivalent');
+  const mergedTarget = collapsed.nodes.find(n => n.id === 'step_2');
+  assertEqual(mergedTarget.nodeClass, 'strand-target',
+    'merged step_2 takes on the strand-target role');
+}
+
+function testRenderer_collapseStrand_standaloneCollectCollapses() {
+  // [Cap, Collect] with no enclosing ForEach, source=media:a,
+  // target=media:b;list (NOT equivalent to cap's to_spec media:b,
+  // so the output node is retained after collapse).
+  //
+  // Collapse:
+  //   - step_1 (standalone Collect) removed.
+  //   - Synthesized bridging edge step_0 → output labeled "collect".
+  //   - The cap edge input_slot → step_0 is unchanged because the
+  //     cap is not inside any foreach body.
+  //
+  // Final: 3 nodes (input_slot, step_0, output), 2 edges.
+  const payload = {
+    source_spec: 'media:a',
+    target_spec: 'media:b;list',
     steps: [
       makeCapStep('cap:in="media:a";op=x;out="media:b"', 'x', 'media:a', 'media:b', false, false),
+      makeCollectStep('media:b'),
     ],
   };
   const built = rendererBuildStrandGraphData(payload);
-  assertEqual(built.edges.length, 1, 'one edge');
-  assertEqual(built.edges[0].label, 'x', 'plain cap has no cardinality suffix');
-}
-
-function testRenderer_buildStrandGraphData_sequenceShowsCardinality() {
-  // A cap with input_is_sequence=true MUST emit "(n→1)" on the label.
+  const collapsed = rendererCollapseStrandShapeTransitions(built);
+
+  const nodeIds = collapsed.nodes.map(n => n.id).sort();
+  assertEqual(JSON.stringify(nodeIds),
+    JSON.stringify(['input_slot', 'output', 'step_0']),
+    'collect node removed; only cap + source + target remain');
+
+  const capEdge = collapsed.edges.find(e => e.source === 'input_slot' && e.target === 'step_0');
+  assert(capEdge !== undefined, 'cap edge survives');
+  assertEqual(capEdge.label, 'x',
+    'cap edge carries just its title — no foreach cardinality markers because the cap is not inside a foreach body');
+
+  const collectEdge = collapsed.edges.find(e => e.source === 'step_0' && e.target === 'output');
+  assert(collectEdge !== undefined, 'step_0 → output edge synthesized by collect collapse');
+  assertEqual(collectEdge.label, 'collect',
+    'the synthesized bridging edge for a standalone Collect is labeled "collect"');
+}
+
+function testRenderer_collapseStrand_sequenceProducingCapBeforeForeach() {
+  // Regression test mirroring the user's real strand:
+  // [Cap_disbind (output_is_sequence=true), ForEach, Cap_make_decision],
+  // source = media:pdf, target = media:decision (equivalent to
+  // the last cap's to_spec).
+  //
+  // Expected render shape after collapse:
+  //   input_slot → step_0 labeled "Disbind (1→n)" — from Disbind's
+  //       own output_is_sequence flag, computed at build time.
+  //   step_0 → step_2 labeled "Make a Decision (1→n)" — because
+  //       make_decision is the first cap inside an unclosed
+  //       ForEach body (foreachEntry=true).
+  //   No separate output node because step_2's to_spec equals the
+  //       strand target.
+  //
+  // If this test fails, the runtime bug would manifest as either
+  // (a) a duplicate target node, (b) a "for each" labeled edge
+  // where the cap title should be, or (c) the phantom direct cap
+  // edge not being relabeled.
   const payload = {
-    source_spec: 'media:a;list',
+    source_spec: 'media:pdf',
+    target_spec: 'media:decision',
+    steps: [
+      makeCapStep('cap:in="media:pdf";op=disbind;out="media:page"', 'Disbind', 'media:pdf', 'media:page', false, true),
+      makeForEachStep('media:page'),
+      makeCapStep('cap:in="media:page";op=decide;out="media:decision"', 'Make a Decision', 'media:page', 'media:decision', false, false),
+    ],
+  };
+  const built = rendererBuildStrandGraphData(payload);
+  const collapsed = rendererCollapseStrandShapeTransitions(built);
+
+  const nodeIds = collapsed.nodes.map(n => n.id).sort();
+  assertEqual(JSON.stringify(nodeIds),
+    JSON.stringify(['input_slot', 'step_0', 'step_2']),
+    'foreach node and duplicate output node both removed');
+
+  // Disbind cap edge carries its own (1→n) marker from
+  // output_is_sequence=true, NOT from the foreach flag.
+  const disbind = collapsed.edges.find(e => e.source === 'input_slot' && e.target === 'step_0');
+  assert(disbind !== undefined, 'Disbind edge input_slot → step_0 exists');
+  assertEqual(disbind.label, 'Disbind (1\u2192n)',
+    'Disbind edge reflects its own output_is_sequence=true cardinality');
+
+  // make_decision cap edge is the foreach entry — the plan-builder
+  // phantom direct edge becomes the render-visible cap edge with
+  // (1→n) appended to the cap title.
+  const makeDecision = collapsed.edges.filter(e => e.source === 'step_0' && e.target === 'step_2');
+  assertEqual(makeDecision.length, 1,
+    'exactly one edge from Text Page to Decision (phantom not duplicated)');
+  assertEqual(makeDecision[0].label, 'Make a Decision (1\u2192n)',
+    'the foreach entry edge is labeled "<cap_title> (1→n)", not "for each"');
+
+  // Duplicate target must be gone.
+  const outputNode = collapsed.nodes.find(n => n.id === 'output');
+  assertEqual(outputNode, undefined,
+    'output node merged into step_2 because they represent the same URN');
+}
+
+function testRenderer_collapseStrand_plainCapMergesTrailingOutput() {
+  // A strand with a single plain 1→1 cap whose to_spec equals
+  // target_spec. The plan-builder topology produces:
+  //   input_slot → step_0 (cap) → output
+  // The collapse pass merges the trailing output edge because
+  // step_0 and output represent the same URN (media:b).
+  //
+  // Final: 2 nodes (input_slot, step_0), 1 edge.
+  const payload = {
+    source_spec: 'media:a',
     target_spec: 'media:b',
     steps: [
-      makeCapStep('cap:in="media:a;list";op=x;out="media:b"', 'x', 'media:a;list', 'media:b', true, false),
+      makeCapStep('cap:in="media:a";op=x;out="media:b"', 'x', 'media:a', 'media:b', false, false),
     ],
   };
   const built = rendererBuildStrandGraphData(payload);
-  assertEqual(built.edges.length, 1, 'one edge');
-  assert(built.edges[0].label.includes('(n\u21921)'),
-    `edge label must include (n\u21921) marker; got: ${built.edges[0].label}`);
+  const collapsed = rendererCollapseStrandShapeTransitions(built);
+
+  assertEqual(collapsed.nodes.length, 2,
+    'duplicate output node merged into step_0 — 2 nodes remain');
+  const outputNode = collapsed.nodes.find(n => n.id === 'output');
+  assertEqual(outputNode, undefined,
+    'output node dropped by merge');
+  const mergedTarget = collapsed.nodes.find(n => n.id === 'step_0');
+  assertEqual(mergedTarget.nodeClass, 'strand-target',
+    'step_0 takes on the strand-target role after the merge');
+
+  assertEqual(collapsed.edges.length, 1, 'single cap edge remains');
+  assertEqual(collapsed.edges[0].source, 'input_slot');
+  assertEqual(collapsed.edges[0].target, 'step_0');
+  assertEqual(collapsed.edges[0].label, 'x', 'cap title preserved as edge label');
+}
+
+function testRenderer_collapseStrand_plainCapDistinctTargetNoMerge() {
+  // A strand with a single plain cap whose to_spec is NOT
+  // equivalent to target_spec. The output node must be retained
+  // and the trailing connector edge preserved.
+  const payload = {
+    source_spec: 'media:a',
+    target_spec: 'media:b;list',
+    steps: [
+      makeCapStep('cap:in="media:a";op=x;out="media:b"', 'x', 'media:a', 'media:b', false, false),
+    ],
+  };
+  const built = rendererBuildStrandGraphData(payload);
+  const collapsed = rendererCollapseStrandShapeTransitions(built);
+
+  assertEqual(collapsed.nodes.length, 3,
+    'no merge because cap to_spec (media:b) and target (media:b;list) are semantically distinct');
+  assert(collapsed.nodes.find(n => n.id === 'output') !== undefined,
+    'output node retained');
+  assert(collapsed.nodes.find(n => n.id === 'step_0') !== undefined,
+    'step_0 retained');
 }
 
 function testRenderer_validateStrandPayload_missingSourceSpec() {
@@ -4280,6 +4636,156 @@ function testRenderer_buildRunGraphData_usesCapUrnIsEquivalentForFailedCap() {
   assertEqual(failureNodes, 2, 'trace truncates at cap y via isEquivalent, yielding 2 failure nodes');
 }
 
+function testRenderer_buildRunGraphData_backboneHasNoForeachNode() {
+  // Regression test for the run-mode rendering fix: the backbone
+  // delivered to cytoscape must NOT contain any strand-foreach or
+  // strand-collect nodes. Run mode inherits the same cosmetic
+  // collapse as strand mode so the foreach/collect execution-layer
+  // concepts don't leak into the view as boxed nodes.
+  //
+  // User scenario: [Disbind (1→n), ForEach, make_decision] where
+  // target_spec equals the last cap's to_spec, so the backbone
+  // collapses to 3 nodes: input_slot, step_0 (Text Page),
+  // step_2 (Decision, merged target). No separate `for each` or
+  // `collect` boxes.
+  const strand = {
+    source_spec: 'media:pdf',
+    target_spec: 'media:decision',
+    steps: [
+      makeCapStep('cap:in="media:pdf";op=disbind;out="media:page"', 'Disbind', 'media:pdf', 'media:page', false, true),
+      makeForEachStep('media:page'),
+      makeCapStep('cap:in="media:page";op=decide;out="media:decision"', 'Make a Decision', 'media:page', 'media:decision', false, false),
+    ],
+  };
+  const payload = {
+    resolved_strand: strand,
+    body_outcomes: [],
+    visible_success_count: 0,
+    visible_failure_count: 0,
+    total_body_count: 0,
+  };
+  const built = rendererBuildRunGraphData(payload);
+
+  // Backbone must contain NO foreach/collect nodes.
+  const foreachNodes = built.strandBuilt.nodes.filter(n => n.nodeClass === 'strand-foreach');
+  const collectNodes = built.strandBuilt.nodes.filter(n => n.nodeClass === 'strand-collect');
+  assertEqual(foreachNodes.length, 0, 'run backbone must not contain strand-foreach nodes');
+  assertEqual(collectNodes.length, 0, 'run backbone must not contain strand-collect nodes');
+
+  // The backbone fallback connector is the foreach-entry cap edge
+  // that runs from the pre-foreach node to the body cap. It must
+  // survive collapse so the target stays reachable even with zero
+  // successful bodies.
+  const backboneCapEdges = built.strandBuilt.edges.filter(e => e.edgeClass === 'strand-cap-edge');
+  assert(backboneCapEdges.some(e => e.source === 'step_0' && e.target === 'step_2'),
+    'foreach-entry backbone edge step_0 → step_2 must be present for fallback connectivity');
+
+  // With zero outcomes, no replicas and no show-more nodes.
+  assertEqual(built.replicaNodes.length, 0, 'no replica nodes when body_outcomes is empty');
+  assertEqual(built.showMoreNodes.length, 0, 'no show-more nodes when no hidden outcomes');
+}
+
+function testRenderer_buildRunGraphData_allFailedDropsTargetPlaceholder() {
+  // When every body fails, the strand target node was never
+  // reached by any execution. The render drops BOTH the backbone
+  // foreach-entry edge AND the orphaned target node so the user
+  // doesn't see a stale "Decision" placeholder alongside their
+  // failed replicas.
+  const strand = {
+    source_spec: 'media:pdf',
+    target_spec: 'media:decision',
+    steps: [
+      makeCapStep('cap:in="media:pdf";op=disbind;out="media:page"', 'Disbind', 'media:pdf', 'media:page', false, true),
+      makeForEachStep('media:page'),
+      makeCapStep('cap:in="media:page";op=decide;out="media:decision"', 'Make a Decision', 'media:page', 'media:decision', false, false),
+    ],
+  };
+  const failedCapUrn = 'cap:in="media:page";op=decide;out="media:decision"';
+  const payload = {
+    resolved_strand: strand,
+    body_outcomes: [
+      { body_index: 0, success: false, cap_urns: [], saved_paths: [], total_bytes: 0, duration_ms: 0, failed_cap: failedCapUrn, error: 'boom' },
+      { body_index: 1, success: false, cap_urns: [], saved_paths: [], total_bytes: 0, duration_ms: 0, failed_cap: failedCapUrn, error: 'boom' },
+    ],
+    visible_success_count: 3,
+    visible_failure_count: 3,
+    total_body_count: 2,
+  };
+  const built = rendererBuildRunGraphData(payload);
+
+  // The dropped placeholder: step_2 (the merged strand target
+  // "Decision") is absent from the backbone because all bodies
+  // failed and the replicas didn't reach it.
+  const hasStep2 = built.strandBuilt.nodes.some(n => n.id === 'step_2');
+  assertEqual(hasStep2, false,
+    'strand target placeholder must be dropped when zero successful replicas reach it');
+
+  // The backbone foreach-entry edge is also gone — replicas
+  // replaced it and there's no orphan target to connect.
+  const foreachEntry = built.strandBuilt.edges.find(e =>
+    e.edgeClass === 'strand-cap-edge' && e.foreachEntry === true);
+  assertEqual(foreachEntry, undefined,
+    'backbone foreach-entry edge must be dropped when replicas exist');
+
+  // Failures are rendered as red replica trails that don't merge.
+  const failureNodes = built.replicaNodes.filter(n => n.classes === 'body-failure');
+  assertEqual(failureNodes.length, 2,
+    'two failed bodies render two replica nodes (truncated at failed_cap)');
+
+  // The pre-foreach cap node (step_0, "Disbind") is still present
+  // along with its incoming edge — only the post-body parts were
+  // dropped.
+  const hasStep0 = built.strandBuilt.nodes.some(n => n.id === 'step_0');
+  assertEqual(hasStep0, true, 'pre-foreach cap node survives');
+  const disbindEdge = built.strandBuilt.edges.find(e =>
+    e.source === 'input_slot' && e.target === 'step_0');
+  assert(disbindEdge !== undefined, 'pre-foreach cap edge (Disbind) survives');
+}
+
+function testRenderer_buildRunGraphData_backboneDroppedWhenSuccessful() {
+  // When at least one successful replica merges into the target,
+  // the backbone foreach-entry edge is dropped — the replica's
+  // own chain represents the execution and the backbone would
+  // otherwise duplicate the path.
+  const strand = {
+    source_spec: 'media:pdf',
+    target_spec: 'media:decision',
+    steps: [
+      makeCapStep('cap:in="media:pdf";op=disbind;out="media:page"', 'Disbind', 'media:pdf', 'media:page', false, true),
+      makeForEachStep('media:page'),
+      makeCapStep('cap:in="media:page";op=decide;out="media:decision"', 'Make a Decision', 'media:page', 'media:decision', false, false),
+    ],
+  };
+  const payload = {
+    resolved_strand: strand,
+    body_outcomes: [
+      { body_index: 0, success: true, cap_urns: [], saved_paths: [], total_bytes: 0, duration_ms: 0 },
+    ],
+    visible_success_count: 3,
+    visible_failure_count: 3,
+    total_body_count: 1,
+  };
+  const built = rendererBuildRunGraphData(payload);
+
+  // The backbone foreach-entry edge is gone.
+  const foreachEntry = built.strandBuilt.edges.find(e =>
+    e.edgeClass === 'strand-cap-edge' && e.foreachEntry === true);
+  assertEqual(foreachEntry, undefined,
+    'foreach-entry backbone edge dropped when at least one success exists');
+
+  // step_2 (target) stays because the replica merge edge lands on it.
+  const hasStep2 = built.strandBuilt.nodes.some(n => n.id === 'step_2');
+  assertEqual(hasStep2, true,
+    'strand target node survives when successful replicas merge into it');
+
+  // Exactly one successful replica node and one merge edge.
+  const successNodes = built.replicaNodes.filter(n => n.classes === 'body-success');
+  assertEqual(successNodes.length, 1, 'one replica node for one successful body');
+  const mergeEdges = built.replicaEdges.filter(e =>
+    e.data && e.data.target === 'step_2' && e.classes === 'body-success');
+  assertEqual(mergeEdges.length, 1, 'one merge edge from replica to target');
+}
+
 // ---------------- machine builder ----------------
 
 function testRenderer_validateMachinePayload_rejectsUnknownKind() {
@@ -4702,10 +5208,18 @@ async function runTests() {
   runTest('RENDERER: validateStrandStep_booleanIsSequence',   testRenderer_validateStrandStep_requiresBooleanIsSequence);
   runTest('RENDERER: classifyStrandCapSteps_simple',          testRenderer_classifyStrandCapSteps_capFlags);
   runTest('RENDERER: classifyStrandCapSteps_nested',          testRenderer_classifyStrandCapSteps_nestedForks);
-  runTest('RENDERER: buildStrand_labelsForkBoundaries',       testRenderer_buildStrandGraphData_labelsForkBoundaries);
-  runTest('RENDERER: buildStrand_collectFixupEdge',           testRenderer_buildStrandGraphData_collectFixupEdge);
-  runTest('RENDERER: buildStrand_plainCapNoMarker',           testRenderer_buildStrandGraphData_plainCapNoMarker);
+  runTest('RENDERER: buildStrand_singleCapPlain',             testRenderer_buildStrandGraphData_singleCapPlain);
   runTest('RENDERER: buildStrand_sequenceShowsCardinality',   testRenderer_buildStrandGraphData_sequenceShowsCardinality);
+  runTest('RENDERER: buildStrand_foreachCollectSpan',         testRenderer_buildStrandGraphData_foreachCollectSpan);
+  runTest('RENDERER: buildStrand_standaloneCollect',          testRenderer_buildStrandGraphData_standaloneCollect);
+  runTest('RENDERER: buildStrand_unclosedForEachBody',        testRenderer_buildStrandGraphData_unclosedForEachBody);
+  runTest('RENDERER: buildStrand_nestedForEachThrows',        testRenderer_buildStrandGraphData_nestedForEachThrows);
+  runTest('RENDERER: collapseStrand_singleCapBody',           testRenderer_collapseStrand_singleCapBodyShowsCapTitleWithIterCollectMarker);
+  runTest('RENDERER: collapseStrand_unclosedForEachBody',     testRenderer_collapseStrand_unclosedForEachBodyCollapses);
+  runTest('RENDERER: collapseStrand_standaloneCollect',       testRenderer_collapseStrand_standaloneCollectCollapses);
+  runTest('RENDERER: collapseStrand_seqCapBeforeForeach',     testRenderer_collapseStrand_sequenceProducingCapBeforeForeach);
+  runTest('RENDERER: collapseStrand_plainCapMergesOutput',    testRenderer_collapseStrand_plainCapMergesTrailingOutput);
+  runTest('RENDERER: collapseStrand_plainCapDistinctTarget',  testRenderer_collapseStrand_plainCapDistinctTargetNoMerge);
   runTest('RENDERER: validateStrand_missingSourceSpec',       testRenderer_validateStrandPayload_missingSourceSpec);
 
   console.log('\n--- cap-graph-renderer run builder ---');
@@ -4713,6 +5227,9 @@ async function runTests() {
   runTest('RENDERER: buildRun_pagesSuccessesAndFailures',     testRenderer_buildRunGraphData_pagesSuccessesAndFailures);
   runTest('RENDERER: buildRun_failureWithoutFailedCap',       testRenderer_buildRunGraphData_failureWithoutFailedCapRendersFullTrace);
   runTest('RENDERER: buildRun_usesIsEquivalentForFailedCap',  testRenderer_buildRunGraphData_usesCapUrnIsEquivalentForFailedCap);
+  runTest('RENDERER: buildRun_backboneHasNoForeachNode',      testRenderer_buildRunGraphData_backboneHasNoForeachNode);
+  runTest('RENDERER: buildRun_allFailedDropsPlaceholder',     testRenderer_buildRunGraphData_allFailedDropsTargetPlaceholder);
+  runTest('RENDERER: buildRun_backboneDroppedWhenSuccessful', testRenderer_buildRunGraphData_backboneDroppedWhenSuccessful);
 
   console.log('\n--- cap-graph-renderer machine builder ---');
   runTest('RENDERER: validateMachine_unknownKind',            testRenderer_validateMachinePayload_rejectsUnknownKind);