capdag 0.106.243 → 0.109.248

package/cap-graph-renderer.js

@@ -663,22 +663,38 @@ function classifyStrandCapSteps(steps) {
   return { capStepIndices, capFlags };
 }
 
-// Build the strand graph. Every Cap step becomes an edge
-// (`from_spec` → `to_spec`). ForEach / Collect are NOT rendered as nodes
-// — they are transitions that annotate the adjacent cap edges:
+// Build the strand graph by mirroring capdag's plan builder
+// (`capdag/src/planner/plan_builder.rs::build_plan_from_path`). The plan
+// builder is the authoritative source of truth for how strand steps
+// translate into a DAG of nodes and edges:
 //
-//   * A Cap whose previous step is ForEach gets the prefix "for each"
-//     on its edge label (the first-body entry edge).
-//   * A Cap whose next step is Collect gets the suffix "collect" on its
-//     edge label (the last-body exit edge).
+//   * Node IDs are positional: `input_slot`, `step_0`, `step_1`, …,
+//     `output`. They are NOT media URN strings — URN comparisons for
+//     graph topology are wrong because the planner connects steps by
+//     the order-theoretic `conformsTo` relation, not by string equality.
+//   * `prev_node_id` is a single running pointer, only advanced by Cap
+//     steps. ForEach steps mark the start of a body span without
+//     advancing prev; the body's first Cap still connects to whatever
+//     was before the ForEach.
+//   * Cap inside a ForEach body connects from `prev_node_id` like any
+//     other cap, AND tracks `body_entry` (first cap in body) and
+//     `body_exit` (most recent cap in body).
+//   * Collect after a ForEach body creates a ForEach node with
+//     boundaries, an iteration edge to body_entry, a Collect node, and
+//     a collection edge from body_exit to Collect. prev_node_id becomes
+//     the Collect node.
+//   * Standalone Collect (no enclosing ForEach) creates a Collect node
+//     consuming prev_node_id directly.
+//   * Unclosed ForEach with no body caps is a terminal unwrap — the
+//     ForEach node is skipped; prev_node_id stays as-is.
+//   * Unclosed ForEach WITH body caps gets a ForEach node, iteration
+//     edge to body_entry, and prev_node_id becomes body_exit.
 //
-// Source-to-body and body-to-target continuity is guaranteed by the
-// strand structure itself: consecutive cap steps satisfy
-// `stepN.to_spec == stepN+1.from_spec`, and fix-up edges are added
-// explicitly when the strand's `source_spec` differs from the first cap
-// step's `from_spec` (the ForEach shape transition) or when the strand's
-// `target_spec` differs from the last cap step's `to_spec` (the Collect
-// shape transition).
+// Node labels come from the `media_display_names` map keyed by the
+// step's canonical URN (or source_spec/target_spec for the boundary
+// nodes). ForEach and Collect nodes display "for each" / "collect".
+// Cap edges carry the cap title plus cardinality marker when either
+// input or output is a sequence.
 function buildStrandGraphData(data) {
   validateStrandPayload(data);
 
@@ -686,143 +702,197 @@ function buildStrandGraphData(data) {
   const sourceSpec = canonicalMediaUrn(data.source_spec);
   const targetSpec = canonicalMediaUrn(data.target_spec);
 
-  const canonicalDisplayLookup = new Map();
+  // Look up a display name for a media URN via the host-supplied map.
+  // Uses `MediaUrn.isEquivalent` so tag-order variation doesn't defeat
+  // the lookup — URNs are compared semantically, never as raw strings.
+  const MediaUrn = requireHostDependency('MediaUrn');
+  const displayEntries = [];
   for (const [urn, display] of Object.entries(mediaDisplayNames)) {
-    if (typeof display === 'string' && display.length > 0) {
-      canonicalDisplayLookup.set(canonicalMediaUrn(urn), display);
+    if (typeof display !== 'string' || display.length === 0) continue;
+    try {
+      displayEntries.push({ media: MediaUrn.fromString(urn), display });
+    } catch (_) {
+      // Skip entries with unparseable URN keys — the host payload is
+      // trusted, but malformed keys are not fatal.
     }
   }
-
-  const nodesMap = new Map();
-  function ensureNode(canonicalUrn) {
-    if (!nodesMap.has(canonicalUrn)) {
-      const displayName = canonicalDisplayLookup.get(canonicalUrn);
-      nodesMap.set(canonicalUrn, {
-        id: canonicalUrn,
-        label: displayName !== undefined ? displayName : mediaNodeLabel(canonicalUrn),
-        fullUrn: canonicalUrn,
-      });
+  function displayNameFor(canonicalUrn) {
+    const candidate = MediaUrn.fromString(canonicalUrn);
+    for (const entry of displayEntries) {
+      if (candidate.isEquivalent(entry.media)) return entry.display;
     }
-    return canonicalUrn;
+    return mediaNodeLabel(canonicalUrn);
   }
 
-  ensureNode(sourceSpec);
-  ensureNode(targetSpec);
-
-  const { capStepIndices } = classifyStrandCapSteps(data.steps);
-  const firstCapIdx = capStepIndices.length > 0 ? capStepIndices[0] : -1;
-  const lastCapIdx = capStepIndices.length > 0 ? capStepIndices[capStepIndices.length - 1] : -1;
-  const hasLeadingForEach = data.steps.some((s, i) =>
-    Object.keys(s.step_type)[0] === 'ForEach' && i < (firstCapIdx === -1 ? Infinity : firstCapIdx));
-  const hasTrailingCollect = data.steps.some((s, i) =>
-    Object.keys(s.step_type)[0] === 'Collect' && i > (lastCapIdx === -1 ? -Infinity : lastCapIdx));
-
+  const nodes = [];
   const edges = [];
-  let capEdgeIdx = 0;
+  const nodeIds = new Set();
 
-  // Prepend a fix-up edge from source_spec to the first cap step's
-  // from_spec when they differ. This is the ForEach shape transition
-  // rendered as an explicit edge.
-  if (firstCapIdx >= 0) {
-    const firstCap = data.steps[firstCapIdx];
-    const firstCapFrom = canonicalMediaUrn(firstCap.from_spec);
-    if (firstCapFrom !== sourceSpec) {
-      ensureNode(firstCapFrom);
-      const label = hasLeadingForEach ? 'for each' : '';
-      edges.push({
-        id: `strand-edge-${capEdgeIdx}`,
-        source: sourceSpec,
-        target: firstCapFrom,
-        title: label || 'fan-out',
-        label,
-        cardinality: '',
-        capUrn: '',
-        color: edgeHueColor(capEdgeIdx),
-      });
-      capEdgeIdx++;
-    }
+  function addNode(id, label, fullUrn, nodeClass) {
+    if (nodeIds.has(id)) return;
+    nodeIds.add(id);
+    nodes.push({
+      id,
+      label,
+      fullUrn: fullUrn || '',
+      nodeClass: nodeClass || '',
+    });
   }
-
-  // Cap step edges. Each Cap's edge connects its from_spec to its
-  // to_spec. Adjacent cap edges are continuous because the planner
-  // guarantees stepN.to_spec == stepN+1.from_spec. "for each" and
-  // "collect" labels belong on the fix-up edges around the cap chain,
-  // not on the cap edges themselves — those labels describe shape
-  // transitions between the source list and the first body scalar (and
-  // between the last body scalar and the target list), which are the
-  // fix-up edges.
-  data.steps.forEach((step) => {
+  let edgeCounter = 0;
+  function addEdge(source, target, label, title, fullUrn, edgeClass) {
+    edges.push({
+      id: `strand-edge-${edgeCounter}`,
+      source,
+      target,
+      label: label || '',
+      title: title || '',
+      fullUrn: fullUrn || '',
+      edgeClass: edgeClass || '',
+      color: edgeHueColor(edgeCounter),
+    });
+    edgeCounter++;
+  }
+
+  // Entry node — the strand's source media spec.
+  const inputSlotId = 'input_slot';
+  addNode(inputSlotId, displayNameFor(sourceSpec), sourceSpec, 'strand-source');
+
+  let prevNodeId = inputSlotId;
+
+  // Track ForEach body membership. `insideForEachBody = { index, nodeId }`
+  // records which ForEach step we're inside and the id we'll give its
+  // eventual node. `bodyEntry`/`bodyExit` track the first and most
+  // recent Cap step inside that body.
+  let insideForEachBody = null;
+  let bodyEntry = null;
+  let bodyExit = null;
+
+  // Finalize an outer ForEach body when a nested ForEach starts before
+  // the outer's Collect. Mirrors plan_builder.rs:238-289.
+  function finalizeOuterForEach(outerForEach, outerEntry, outerExit) {
+    const outerForEachInput = outerForEach.index === 0
+      ? inputSlotId
+      : `step_${outerForEach.index - 1}`;
+    // Create the ForEach node + direct edge from its input + iteration
+    // edge into the body's first cap.
+    addNode(outerForEach.nodeId, 'for each', '', 'strand-foreach');
+    addEdge(outerForEachInput, outerForEach.nodeId, 'for each', 'for each', '', 'strand-iteration');
+    addEdge(outerForEach.nodeId, outerEntry, '', '', '', 'strand-iteration');
+    return outerExit;
+  }
+
+  data.steps.forEach((step, i) => {
     const variant = Object.keys(step.step_type)[0];
-    if (variant !== 'Cap') return;
-    const body = step.step_type.Cap;
-    const fromCanonical = canonicalMediaUrn(step.from_spec);
-    const toCanonical = canonicalMediaUrn(step.to_spec);
-    ensureNode(fromCanonical);
-    ensureNode(toCanonical);
+    const nodeId = `step_${i}`;
+
+    if (variant === 'Cap') {
+      const body = step.step_type.Cap;
+      const toCanonical = canonicalMediaUrn(step.to_spec);
+      addNode(nodeId, displayNameFor(toCanonical), toCanonical, 'strand-cap');
+
+      let label = body.title;
+      const cardinality = cardinalityLabel(body.input_is_sequence, body.output_is_sequence);
+      if (cardinality !== '1\u21921') {
+        label = `${label} (${cardinality})`;
+      }
+      addEdge(prevNodeId, nodeId, label, body.title, body.cap_urn, 'strand-cap-edge');
+
+      if (insideForEachBody !== null) {
+        if (bodyEntry === null) bodyEntry = nodeId;
+        bodyExit = nodeId;
+      }
 
-    let label = body.title;
-    const cardinality = cardinalityLabel(body.input_is_sequence, body.output_is_sequence);
-    if (cardinality !== '1\u21921') {
-      label = `${label} (${cardinality})`;
+      prevNodeId = nodeId;
+      return;
     }
 
-    edges.push({
-      id: `strand-edge-${capEdgeIdx}`,
-      source: fromCanonical,
-      target: toCanonical,
-      title: body.title,
-      label,
-      cardinality,
-      capUrn: body.cap_urn,
-      color: edgeHueColor(capEdgeIdx),
-    });
-    capEdgeIdx++;
-  });
+    if (variant === 'ForEach') {
+      // If we're already inside a ForEach body when another ForEach
+      // starts, finalize the outer one first.
+      if (insideForEachBody !== null) {
+        const outer = insideForEachBody;
+        const entry = bodyEntry !== null ? bodyEntry : prevNodeId;
+        const exit = bodyExit !== null ? bodyExit : prevNodeId;
+        if (bodyEntry === null) {
+          // Outer ForEach with no body caps is an illegal nesting; the
+          // plan builder throws. Mirror that.
+          throw new Error(
+            `CapGraphRenderer strand: nested ForEach at step[${i}] but outer ForEach at step[${outer.index}] has no body caps`
+          );
+        }
+        prevNodeId = finalizeOuterForEach(outer, entry, exit);
+        bodyEntry = null;
+        bodyExit = null;
+      }
+      insideForEachBody = { index: i, nodeId };
+      bodyEntry = null;
+      bodyExit = null;
+      // Do NOT advance prevNodeId — the body's first cap will connect
+      // to whatever was before the ForEach.
+      return;
+    }
 
-  // Append a fix-up edge from the last cap's to_spec to target_spec
-  // when they differ. This is the Collect shape transition as an
-  // explicit edge.
-  if (lastCapIdx >= 0) {
-    const lastCap = data.steps[lastCapIdx];
-    const lastCapTo = canonicalMediaUrn(lastCap.to_spec);
-    if (lastCapTo !== targetSpec) {
-      const label = hasTrailingCollect ? 'collect' : '';
-      edges.push({
-        id: `strand-edge-${capEdgeIdx}`,
-        source: lastCapTo,
-        target: targetSpec,
-        title: label || 'fan-in',
-        label,
-        cardinality: '',
-        capUrn: '',
-        color: edgeHueColor(capEdgeIdx),
-      });
-      capEdgeIdx++;
+    if (variant === 'Collect') {
+      if (insideForEachBody !== null) {
+        const outer = insideForEachBody;
+        const entry = bodyEntry !== null ? bodyEntry : prevNodeId;
+        const exit = bodyExit !== null ? bodyExit : prevNodeId;
+        const outerForEachInput = outer.index === 0
+          ? inputSlotId
+          : `step_${outer.index - 1}`;
+
+        addNode(outer.nodeId, 'for each', '', 'strand-foreach');
+        addEdge(outerForEachInput, outer.nodeId, 'for each', 'for each', '', 'strand-iteration');
+        addEdge(outer.nodeId, entry, '', '', '', 'strand-iteration');
+
+        addNode(nodeId, 'collect', '', 'strand-collect');
+        addEdge(exit, nodeId, 'collect', 'collect', '', 'strand-collection');
+
+        insideForEachBody = null;
+        bodyEntry = null;
+        bodyExit = null;
+        prevNodeId = nodeId;
+      } else {
+        // Standalone Collect — scalar → list-of-one. Mirrors
+        // plan_builder.rs:333-355.
+        addNode(nodeId, 'collect', '', 'strand-collect');
+        addEdge(prevNodeId, nodeId, 'collect', 'collect', '', 'strand-collection');
+        prevNodeId = nodeId;
+      }
+      return;
     }
-  }
 
-  // Edge case: if there are no Cap steps at all, still connect source
-  // to target directly so the graph has at least one edge. This handles
-  // degenerate strands (e.g. identity).
-  if (firstCapIdx === -1 && sourceSpec !== targetSpec) {
-    edges.push({
-      id: `strand-edge-${capEdgeIdx}`,
-      source: sourceSpec,
-      target: targetSpec,
-      title: '',
-      label: '',
-      cardinality: '',
-      capUrn: '',
-      color: edgeHueColor(capEdgeIdx),
-    });
-  }
+    throw new Error(`CapGraphRenderer strand: unknown step_type variant '${variant}' at step[${i}]`);
+  });
 
-  return {
-    nodes: Array.from(nodesMap.values()),
-    edges,
-    sourceSpec,
-    targetSpec,
-  };
+  // Handle unclosed ForEach after the walk. Mirrors plan_builder.rs:362-428.
+  if (insideForEachBody !== null) {
+    const outer = insideForEachBody;
+    const hasBodyEntry = bodyEntry !== null;
+    if (hasBodyEntry) {
+      const entry = bodyEntry;
+      const exit = bodyExit;
+      const outerForEachInput = outer.index === 0
+        ? inputSlotId
+        : `step_${outer.index - 1}`;
+      addNode(outer.nodeId, 'for each', '', 'strand-foreach');
+      addEdge(outerForEachInput, outer.nodeId, 'for each', 'for each', '', 'strand-iteration');
+      addEdge(outer.nodeId, entry, '', '', '', 'strand-iteration');
+      prevNodeId = exit;
+    }
+    // hasBodyEntry === false is a terminal unwrap — skip the ForEach
+    // node entirely, prev_node_id stays as-is.
+    insideForEachBody = null;
+    bodyEntry = null;
+    bodyExit = null;
+  }
+
+  // Final output node. Mirrors plan_builder.rs:430-432.
+  const outputId = 'output';
+  addNode(outputId, displayNameFor(targetSpec), targetSpec, 'strand-target');
+  addEdge(prevNodeId, outputId, '', '', '', 'strand-cap-edge');
+
+  return { nodes, edges, sourceSpec, targetSpec };
 }
 
 function strandCytoscapeElements(built) {
@@ -833,9 +903,7 @@ function strandCytoscapeElements(built) {
       label: node.label,
       fullUrn: node.fullUrn,
     },
-    classes: node.id === built.sourceSpec ? 'strand-source'
-           : node.id === built.targetSpec ? 'strand-target'
-           : '',
+    classes: node.nodeClass || '',
   }));
   const edgeElements = built.edges.map(edge => ({
     group: 'edges',
@@ -845,10 +913,10 @@ function strandCytoscapeElements(built) {
       target: edge.target,
       label: edge.label,
       title: edge.title,
-      cardinality: edge.cardinality,
-      fullUrn: edge.capUrn,
+      fullUrn: edge.fullUrn,
       color: edge.color,
     },
+    classes: edge.edgeClass || '',
   }));
   return nodeElements.concat(edgeElements);
 }
@@ -870,6 +938,39 @@ function findCapStepIndexByUrn(steps, targetUrnString) {
   return -1;
 }
 
+// Remove nodes and edges belonging to the ForEach body's interior cap
+// steps from a strand backbone. In run mode, these are replaced by
+// per-body replicas; keeping the prototype chain alongside the
+// replicas produces a confusing double-render. The ForEach and Collect
+// nodes themselves, plus their iteration/collection edges, stay.
+function stripBodyInteriorFromStrandBackbone(built, steps, foreachStepIdx, collectStepIdx) {
+  const bodyEnd = collectStepIdx >= 0 ? collectStepIdx : steps.length;
+  // Collect the positional IDs of body-interior cap steps (the caps
+  // strictly between ForEach and Collect).
+  const interiorIds = new Set();
+  for (let i = foreachStepIdx + 1; i < bodyEnd; i++) {
+    if (Object.keys(steps[i].step_type)[0] === 'Cap') {
+      interiorIds.add(`step_${i}`);
+    }
+  }
+  if (interiorIds.size === 0) return built;
+
+  const keptNodes = built.nodes.filter(n => !interiorIds.has(n.id));
+  const keptEdges = built.edges.filter(e =>
+    !interiorIds.has(e.source) && !interiorIds.has(e.target));
+
+  // After stripping, the ForEach node and the Collect node (or the
+  // output node if no Collect) may become disconnected — the body
+  // replicas will bridge them. That's fine; cytoscape's ELK layout
+  // handles disconnected subgraphs.
+  return {
+    nodes: keptNodes,
+    edges: keptEdges,
+    sourceSpec: built.sourceSpec,
+    targetSpec: built.targetSpec,
+  };
+}
+
 function buildRunGraphData(data) {
   validateRunPayload(data);
 
@@ -879,11 +980,14 @@ function buildRunGraphData(data) {
   const strandInput = Object.assign({}, data.resolved_strand, {
     media_display_names: data.media_display_names,
   });
-  const strandBuilt = buildStrandGraphData(strandInput);
+  const strandBuiltRaw = buildStrandGraphData(strandInput);
 
   // Locate the ForEach/Collect span in the backbone for body-replica
-  // placement. We anchor body replicas to the first Cap step after a
-  // ForEach (the fan-out point) and merge back at the first Collect.
+  // placement. The strand builder uses positional node IDs mirroring
+  // the plan builder (`step_0`, `step_1`, …). The ForEach node at
+  // step index i has id `step_i`; body replicas fan out from that
+  // ForEach node and (when a Collect closes the body) merge into the
+  // Collect node at `step_j`.
   const steps = data.resolved_strand.steps;
   let foreachStepIdx = -1;
   let collectStepIdx = -1;
@@ -894,6 +998,17 @@ function buildRunGraphData(data) {
   }
   const hasForeach = foreachStepIdx >= 0;
 
+  // In run mode we want per-body replicas to REPLACE the prototype cap
+  // chain inside the ForEach body, not sit alongside it. Strip the
+  // backbone nodes and edges that correspond to body-interior Cap
+  // steps and their direct edges, keeping only the input slot, the
+  // ForEach node, the Collect node (if any), the output node, and any
+  // caps OUTSIDE the body span. Body replicas will connect from the
+  // ForEach node and merge at the Collect node.
+  const strandBuilt = hasForeach
+    ? stripBodyInteriorFromStrandBackbone(strandBuiltRaw, steps, foreachStepIdx, collectStepIdx)
+    : strandBuiltRaw;
+
   // Filter and bound the outcomes.
   const allOutcomes = data.body_outcomes.slice().sort((a, b) => a.body_index - b.body_index);
   const successes = allOutcomes.filter(o => o.success);
@@ -903,10 +1018,8 @@ function buildRunGraphData(data) {
   const hiddenSuccessCount = successes.length - visibleSuccess.length;
   const hiddenFailureCount = failures.length - visibleFailure.length;
 
-  // Map each displayed body to its per-body chain. The chain starts at
-  // the first Cap step's from_spec (the node immediately after the
-  // ForEach) and extends through either all body caps (success) or up to
-  // the failed_cap (failure).
+  // Collect the Cap steps inside the ForEach body. Each body replica
+  // chains through these caps.
   const bodyCapSteps = [];
   const bodyStart = hasForeach ? foreachStepIdx + 1 : 0;
   const bodyEnd = collectStepIdx >= 0 ? collectStepIdx : steps.length;
@@ -916,19 +1029,24 @@ function buildRunGraphData(data) {
     }
   }
 
-  // Replica node/edge ids are prefixed to avoid collision with backbone
-  // ids.
+  // Body replicas fan out from the ForEach node. If no ForEach, fall
+  // back to the input_slot. When the strand closes the body with a
+  // Collect, replicas merge into that Collect node; otherwise
+  // (unclosed ForEach) they merge into the `output` node.
+  const anchorNodeId = hasForeach ? `step_${foreachStepIdx}` : 'input_slot';
+  const mergeNodeId = collectStepIdx >= 0 ? `step_${collectStepIdx}` : 'output';
+
   const replicaNodes = [];
   const replicaEdges = [];
 
-  function buildBodyReplica(outcome, groupIndex) {
+  function buildBodyReplica(outcome) {
     const success = outcome.success;
     const successClass = success ? 'body-success' : 'body-failure';
     const edgeClass = success ? 'body-success' : 'body-failure';
     const colorVar = success ? '--graph-body-edge-success' : '--graph-body-edge-failure';
 
-    // Find the trace end (failed_cap stops the trace for failed
-    // bodies). Comparison uses CapUrn.isEquivalent.
+    // Trace end: failures stop at failed_cap. `CapUrn.isEquivalent`
+    // is used for the match — never string equality.
     let traceEnd = bodyCapSteps.length;
     if (!success && typeof outcome.failed_cap === 'string' && outcome.failed_cap.length > 0) {
       const CapUrn = requireHostDependency('CapUrn');
@@ -941,12 +1059,9 @@ function buildRunGraphData(data) {
         }
       }
     }
-    if (traceEnd === 0) return; // Nothing to render for this body.
+    if (traceEnd === 0) return;
 
-    // Anchor to the first body cap's from_spec, which equals the
-    // ForEach's from_spec (fan-out from the same source node).
-    const anchorCanonical = canonicalMediaUrn(bodyCapSteps[0].step.from_spec);
-    let prevBodyNodeId = anchorCanonical;
+    let prevBodyNodeId = anchorNodeId;
     const bodyKey = `body-${outcome.body_index}`;
     const titleLabel = typeof outcome.title === 'string' && outcome.title.length > 0
       ? outcome.title
@@ -973,7 +1088,7 @@ function buildRunGraphData(data) {
           id: `${bodyKey}-e-${i}`,
           source: prevBodyNodeId,
           target: replicaNodeId,
-          label: '',
+          label: i === 0 ? body.title : '',
           title: body.title,
           fullUrn: body.cap_urn,
           color: `var(${colorVar})`,
@@ -984,16 +1099,17 @@ function buildRunGraphData(data) {
       prevBodyNodeId = replicaNodeId;
     }
 
-    // If the collect exists and the body succeeded, attach the replica
-    // tail to the collect's to_spec node so the graph visibly fans in.
-    if (success && collectStepIdx >= 0) {
-      const collectTo = canonicalMediaUrn(steps[collectStepIdx].to_spec);
+    // Successful bodies merge their replica tail back into the Collect
+    // node (or `output` if the ForEach is unclosed) so the graph
+    // visibly fans in. Failed bodies do NOT merge — the trace
+    // terminates at the failed cap.
+    if (success) {
       replicaEdges.push({
         group: 'edges',
         data: {
           id: `${bodyKey}-merge`,
           source: prevBodyNodeId,
-          target: collectTo,
+          target: mergeNodeId,
           label: '',
           title: 'collect',
           fullUrn: '',
@@ -1005,14 +1121,13 @@ function buildRunGraphData(data) {
     }
   }
 
-  visibleSuccess.forEach((o, i) => buildBodyReplica(o, i));
-  visibleFailure.forEach((o, i) => buildBodyReplica(o, i));
+  visibleSuccess.forEach((o) => buildBodyReplica(o));
+  visibleFailure.forEach((o) => buildBodyReplica(o));
 
   // Build success and failure "show more" nodes when there are hidden
-  // outcomes. Anchored at the same ForEach fan-out source.
+  // outcomes. Anchored at the ForEach node (or input_slot if none).
   const showMoreNodes = [];
   if (hasForeach && bodyCapSteps.length > 0) {
-    const anchorCanonical = canonicalMediaUrn(bodyCapSteps[0].step.from_spec);
     if (hiddenSuccessCount > 0) {
       const nodeId = 'show-more-success';
       showMoreNodes.push({
@@ -1030,7 +1145,7 @@ function buildRunGraphData(data) {
         group: 'edges',
         data: {
           id: 'show-more-success-edge',
-          source: anchorCanonical,
+          source: anchorNodeId,
           target: nodeId,
           label: '',
           title: '',
@@ -1057,7 +1172,7 @@ function buildRunGraphData(data) {
         group: 'edges',
         data: {
           id: 'show-more-failure-edge',
-          source: anchorCanonical,
+          source: anchorNodeId,
           target: nodeId,
           label: '',
           title: '',

package/capdag.test.js

@@ -4030,86 +4030,178 @@ 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=x;out="media:b"', 'x', 'media:a', 'media:b', false, false),
+      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);
-  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.
+  // 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',
-    target_spec: 'media:b',
+    source_spec: 'media:a;list;list',
+    target_spec: 'media:a',
     steps: [
-      makeCapStep('cap:in="media:a;list";op=x;out="media:b"', 'x', 'media:a;list', 'media:b', true, false),
+      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),
     ],
   };
-  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}`);
+  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_validateStrandPayload_missingSourceSpec() {
@@ -4702,10 +4794,12 @@ 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: validateStrand_missingSourceSpec',       testRenderer_validateStrandPayload_missingSourceSpec);
 
   console.log('\n--- cap-graph-renderer run builder ---');

package/machine-parser.js

@@ -174,13 +174,15 @@ function peg$parse(input, options) {
   const peg$c6 = "-";
   const peg$c7 = ">";
   const peg$c8 = "cap:";
-  const peg$c9 = "\"";
-  const peg$c10 = "\\\"";
-  const peg$c11 = "\\\\";
+  const peg$c9 = "\r\n";
+  const peg$c10 = "\"";
+  const peg$c11 = "\\\"";
+  const peg$c12 = "\\\\";
 
   const peg$r0 = /^[a-zA-Z_]/;
   const peg$r1 = /^[a-zA-Z0-9_\-]/;
-  const peg$r2 = /^[ \t\r\n]/;
+  const peg$r2 = /^[\n\r]/;
+  const peg$r3 = /^[ \t\r\n]/;
 
   const peg$e0 = peg$literalExpectation("[", false);
   const peg$e1 = peg$literalExpectation("]", false);
@@ -194,29 +196,33 @@ function peg$parse(input, options) {
   const peg$e9 = peg$classExpectation([["a", "z"], ["A", "Z"], ["0", "9"], "_", "-"], false, false, false);
   const peg$e10 = peg$literalExpectation("cap:", false);
   const peg$e11 = peg$anyExpectation();
-  const peg$e12 = peg$literalExpectation("\"", false);
-  const peg$e13 = peg$literalExpectation("\\\"", false);
-  const peg$e14 = peg$literalExpectation("\\\\", false);
-  const peg$e15 = peg$classExpectation([" ", "\t", "\r", "\n"], false, false, false);
-  const peg$e16 = peg$otherExpectation("required whitespace");
+  const peg$e12 = peg$otherExpectation("newline");
+  const peg$e13 = peg$literalExpectation("\r\n", false);
+  const peg$e14 = peg$classExpectation(["\n", "\r"], false, false, false);
+  const peg$e15 = peg$literalExpectation("\"", false);
+  const peg$e16 = peg$literalExpectation("\\\"", false);
+  const peg$e17 = peg$literalExpectation("\\\\", false);
+  const peg$e18 = peg$classExpectation([" ", "\t", "\r", "\n"], false, false, false);
+  const peg$e19 = peg$otherExpectation("required whitespace");
 
   function peg$f0(stmts) {    return stmts;  }
   function peg$f1(inner) {    return inner;  }
-  function peg$f2(a, c) {
+  function peg$f2(inner) {    return inner;  }
+  function peg$f3(a, c) {
     return { type: 'header', alias: a.value, capUrn: c.value, location: location(), aliasLocation: a.location, capUrnLocation: c.location };
   }
-  function peg$f3(s, lc, t) {
+  function peg$f4(s, lc, t) {
     return { type: 'wiring', sources: s.values, capAlias: lc.alias, isLoop: lc.isLoop, target: t.value, location: location(), sourceLocations: s.locations, capAliasLocation: lc.location, targetLocation: t.location };
   }
-  function peg$f4(a) {    return { values: [a.value], locations: [a.location] };  }
-  function peg$f5(first, a) {    return a;  }
-  function peg$f6(first, rest) {
+  function peg$f5(a) {    return { values: [a.value], locations: [a.location] };  }
+  function peg$f6(first, a) {    return a;  }
+  function peg$f7(first, rest) {
     return { values: [first.value, ...rest.map(r => r.value)], locations: [first.location, ...rest.map(r => r.location)] };
   }
-  function peg$f7(a) {    return { alias: a.value, isLoop: true, location: a.location };  }
-  function peg$f8(a) {    return { alias: a.value, isLoop: false, location: a.location };  }
-  function peg$f9(a) {    return { value: a, location: location() };  }
-  function peg$f10(c) {    return { value: c, location: location() };  }
+  function peg$f8(a) {    return { alias: a.value, isLoop: true, location: a.location };  }
+  function peg$f9(a) {    return { alias: a.value, isLoop: false, location: a.location };  }
+  function peg$f10(a) {    return { value: a, location: location() };  }
+  function peg$f11(c) {    return { value: c, location: location() };  }
   let peg$currPos = options.peg$currPos | 0;
   let peg$savedPos = peg$currPos;
   const peg$posDetailsCache = [{ line: 1, column: 1 }];
@@ -444,6 +450,18 @@ function peg$parse(input, options) {
       peg$currPos = s0;
       s0 = peg$FAILED;
     }
+    if (s0 === peg$FAILED) {
+      s0 = peg$currPos;
+      s1 = peg$parseinner();
+      if (s1 !== peg$FAILED) {
+        s2 = peg$parse_();
+        peg$savedPos = s0;
+        s0 = peg$f2(s1);
+      } else {
+        peg$currPos = s0;
+        s0 = peg$FAILED;
+      }
+    }
 
     return s0;
   }
@@ -470,7 +488,7 @@ function peg$parse(input, options) {
         s3 = peg$parsecap_urn_loc();
         if (s3 !== peg$FAILED) {
           peg$savedPos = s0;
-          s0 = peg$f2(s1, s3);
+          s0 = peg$f3(s1, s3);
         } else {
           peg$currPos = s0;
           s0 = peg$FAILED;
@@ -506,7 +524,7 @@ function peg$parse(input, options) {
             s9 = peg$parsealias_loc();
             if (s9 !== peg$FAILED) {
               peg$savedPos = s0;
-              s0 = peg$f3(s1, s5, s9);
+              s0 = peg$f4(s1, s5, s9);
             } else {
               peg$currPos = s0;
               s0 = peg$FAILED;
@@ -549,7 +567,7 @@ function peg$parse(input, options) {
     s1 = peg$parsealias_loc();
     if (s1 !== peg$FAILED) {
       peg$savedPos = s0;
-      s1 = peg$f4(s1);
+      s1 = peg$f5(s1);
     }
     s0 = s1;
 
@@ -585,7 +603,7 @@ function peg$parse(input, options) {
           s8 = peg$parsealias_loc();
           if (s8 !== peg$FAILED) {
             peg$savedPos = s5;
-            s5 = peg$f5(s3, s8);
+            s5 = peg$f6(s3, s8);
           } else {
             peg$currPos = s5;
             s5 = peg$FAILED;
@@ -610,7 +628,7 @@ function peg$parse(input, options) {
               s8 = peg$parsealias_loc();
               if (s8 !== peg$FAILED) {
                 peg$savedPos = s5;
-                s5 = peg$f5(s3, s8);
+                s5 = peg$f6(s3, s8);
               } else {
                 peg$currPos = s5;
                 s5 = peg$FAILED;
@@ -634,7 +652,7 @@ function peg$parse(input, options) {
           }
           if (s6 !== peg$FAILED) {
             peg$savedPos = s0;
-            s0 = peg$f6(s3, s4);
+            s0 = peg$f7(s3, s4);
           } else {
             peg$currPos = s0;
             s0 = peg$FAILED;
@@ -672,7 +690,7 @@ function peg$parse(input, options) {
         s3 = peg$parsealias_loc();
         if (s3 !== peg$FAILED) {
           peg$savedPos = s0;
-          s0 = peg$f7(s3);
+          s0 = peg$f8(s3);
         } else {
           peg$currPos = s0;
           s0 = peg$FAILED;
@@ -690,7 +708,7 @@ function peg$parse(input, options) {
       s1 = peg$parsealias_loc();
       if (s1 !== peg$FAILED) {
         peg$savedPos = s0;
-        s1 = peg$f8(s1);
+        s1 = peg$f9(s1);
       }
       s0 = s1;
     }
@@ -754,7 +772,7 @@ function peg$parse(input, options) {
     s1 = peg$parsealias();
     if (s1 !== peg$FAILED) {
       peg$savedPos = s0;
-      s1 = peg$f9(s1);
+      s1 = peg$f10(s1);
     }
     s0 = s1;
 
@@ -814,7 +832,7 @@ function peg$parse(input, options) {
     s1 = peg$parsecap_urn();
     if (s1 !== peg$FAILED) {
       peg$savedPos = s0;
-      s1 = peg$f10(s1);
+      s1 = peg$f11(s1);
     }
     s0 = s1;
 
@@ -856,7 +874,7 @@ function peg$parse(input, options) {
   }
 
   function peg$parsecap_urn_body() {
-    let s0, s1, s2;
+    let s0, s1, s2, s3;
 
     s0 = peg$parsequoted_value();
     if (s0 === peg$FAILED) {
@@ -878,16 +896,31 @@ function peg$parse(input, options) {
         s1 = peg$FAILED;
       }
       if (s1 !== peg$FAILED) {
-        if (input.length > peg$currPos) {
-          s2 = input.charAt(peg$currPos);
-          peg$currPos++;
+        s2 = peg$currPos;
+        peg$silentFails++;
+        s3 = peg$parseNL();
+        peg$silentFails--;
+        if (s3 === peg$FAILED) {
+          s2 = undefined;
         } else {
+          peg$currPos = s2;
           s2 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e11); }
         }
         if (s2 !== peg$FAILED) {
-          s1 = [s1, s2];
-          s0 = s1;
+          if (input.length > peg$currPos) {
+            s3 = input.charAt(peg$currPos);
+            peg$currPos++;
+          } else {
+            s3 = peg$FAILED;
+            if (peg$silentFails === 0) { peg$fail(peg$e11); }
+          }
+          if (s3 !== peg$FAILED) {
+            s1 = [s1, s2, s3];
+            s0 = s1;
+          } else {
+            peg$currPos = s0;
+            s0 = peg$FAILED;
+          }
         } else {
           peg$currPos = s0;
           s0 = peg$FAILED;
@@ -901,44 +934,73 @@ function peg$parse(input, options) {
     return s0;
   }
 
+  function peg$parseNL() {
+    let s0, s1;
+
+    peg$silentFails++;
+    if (input.substr(peg$currPos, 2) === peg$c9) {
+      s0 = peg$c9;
+      peg$currPos += 2;
+    } else {
+      s0 = peg$FAILED;
+      if (peg$silentFails === 0) { peg$fail(peg$e13); }
+    }
+    if (s0 === peg$FAILED) {
+      s0 = input.charAt(peg$currPos);
+      if (peg$r2.test(s0)) {
+        peg$currPos++;
+      } else {
+        s0 = peg$FAILED;
+        if (peg$silentFails === 0) { peg$fail(peg$e14); }
+      }
+    }
+    peg$silentFails--;
+    if (s0 === peg$FAILED) {
+      s1 = peg$FAILED;
+      if (peg$silentFails === 0) { peg$fail(peg$e12); }
+    }
+
+    return s0;
+  }
+
   function peg$parsequoted_value() {
     let s0, s1, s2, s3, s4, s5;
 
     s0 = peg$currPos;
     if (input.charCodeAt(peg$currPos) === 34) {
-      s1 = peg$c9;
+      s1 = peg$c10;
       peg$currPos++;
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e12); }
+      if (peg$silentFails === 0) { peg$fail(peg$e15); }
     }
     if (s1 !== peg$FAILED) {
       s2 = [];
-      if (input.substr(peg$currPos, 2) === peg$c10) {
-        s3 = peg$c10;
+      if (input.substr(peg$currPos, 2) === peg$c11) {
+        s3 = peg$c11;
         peg$currPos += 2;
       } else {
         s3 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e13); }
+        if (peg$silentFails === 0) { peg$fail(peg$e16); }
       }
       if (s3 === peg$FAILED) {
-        if (input.substr(peg$currPos, 2) === peg$c11) {
-          s3 = peg$c11;
+        if (input.substr(peg$currPos, 2) === peg$c12) {
+          s3 = peg$c12;
           peg$currPos += 2;
         } else {
           s3 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e14); }
+          if (peg$silentFails === 0) { peg$fail(peg$e17); }
         }
         if (s3 === peg$FAILED) {
           s3 = peg$currPos;
           s4 = peg$currPos;
           peg$silentFails++;
           if (input.charCodeAt(peg$currPos) === 34) {
-            s5 = peg$c9;
+            s5 = peg$c10;
             peg$currPos++;
           } else {
             s5 = peg$FAILED;
-            if (peg$silentFails === 0) { peg$fail(peg$e12); }
+            if (peg$silentFails === 0) { peg$fail(peg$e15); }
           }
           peg$silentFails--;
           if (s5 === peg$FAILED) {
@@ -970,31 +1032,31 @@ function peg$parse(input, options) {
       }
       while (s3 !== peg$FAILED) {
         s2.push(s3);
-        if (input.substr(peg$currPos, 2) === peg$c10) {
-          s3 = peg$c10;
+        if (input.substr(peg$currPos, 2) === peg$c11) {
+          s3 = peg$c11;
           peg$currPos += 2;
         } else {
           s3 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e13); }
+          if (peg$silentFails === 0) { peg$fail(peg$e16); }
         }
         if (s3 === peg$FAILED) {
-          if (input.substr(peg$currPos, 2) === peg$c11) {
-            s3 = peg$c11;
+          if (input.substr(peg$currPos, 2) === peg$c12) {
+            s3 = peg$c12;
             peg$currPos += 2;
           } else {
             s3 = peg$FAILED;
-            if (peg$silentFails === 0) { peg$fail(peg$e14); }
+            if (peg$silentFails === 0) { peg$fail(peg$e17); }
           }
           if (s3 === peg$FAILED) {
             s3 = peg$currPos;
             s4 = peg$currPos;
             peg$silentFails++;
             if (input.charCodeAt(peg$currPos) === 34) {
-              s5 = peg$c9;
+              s5 = peg$c10;
               peg$currPos++;
             } else {
               s5 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e12); }
+              if (peg$silentFails === 0) { peg$fail(peg$e15); }
             }
             peg$silentFails--;
             if (s5 === peg$FAILED) {
@@ -1026,11 +1088,11 @@ function peg$parse(input, options) {
         }
       }
       if (input.charCodeAt(peg$currPos) === 34) {
-        s3 = peg$c9;
+        s3 = peg$c10;
         peg$currPos++;
       } else {
         s3 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e12); }
+        if (peg$silentFails === 0) { peg$fail(peg$e15); }
       }
       if (s3 !== peg$FAILED) {
         s1 = [s1, s2, s3];
@@ -1053,20 +1115,20 @@ function peg$parse(input, options) {
     peg$silentFails++;
     s0 = [];
     s1 = input.charAt(peg$currPos);
-    if (peg$r2.test(s1)) {
+    if (peg$r3.test(s1)) {
       peg$currPos++;
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e15); }
+      if (peg$silentFails === 0) { peg$fail(peg$e18); }
     }
     while (s1 !== peg$FAILED) {
       s0.push(s1);
       s1 = input.charAt(peg$currPos);
-      if (peg$r2.test(s1)) {
+      if (peg$r3.test(s1)) {
         peg$currPos++;
       } else {
         s1 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e15); }
+        if (peg$silentFails === 0) { peg$fail(peg$e18); }
       }
     }
     peg$silentFails--;
@@ -1080,21 +1142,21 @@ function peg$parse(input, options) {
     peg$silentFails++;
     s0 = [];
     s1 = input.charAt(peg$currPos);
-    if (peg$r2.test(s1)) {
+    if (peg$r3.test(s1)) {
       peg$currPos++;
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e15); }
+      if (peg$silentFails === 0) { peg$fail(peg$e18); }
     }
     if (s1 !== peg$FAILED) {
       while (s1 !== peg$FAILED) {
         s0.push(s1);
         s1 = input.charAt(peg$currPos);
-        if (peg$r2.test(s1)) {
+        if (peg$r3.test(s1)) {
           peg$currPos++;
         } else {
           s1 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e15); }
+          if (peg$silentFails === 0) { peg$fail(peg$e18); }
         }
       }
     } else {
@@ -1103,7 +1165,7 @@ function peg$parse(input, options) {
     peg$silentFails--;
     if (s0 === peg$FAILED) {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e16); }
+      if (peg$silentFails === 0) { peg$fail(peg$e19); }
     }
 
     return s0;

package/package.json

@@ -40,5 +40,5 @@
     "pretest": "npm run build:parser",
     "test": "node capdag.test.js"
   },
-  "version": "0.106.243"
+  "version": "0.109.248"
 }