capdag 1.222.603 → 1.226.626

package/cap-fab-renderer.js

@@ -590,6 +590,18 @@ function buildStylesheet() {
         'target-arrow-shape': 'tee',
       },
     },
+    {
+      // A convergence (fan-in) edge: a second producer feeding a cap's
+      // non-main argument. Dotted + diamond-tail to read as a merging
+      // side-input distinct from the solid main backbone edge.
+      selector: 'edge.strand-convergence',
+      style: {
+        'line-style': 'dotted',
+        'width': 2,
+        'source-arrow-shape': 'diamond',
+        'source-arrow-color': machineEdgeColor || 'data(color)',
+      },
+    },
     {
       selector: 'edge.faded',
       style: { 'opacity': fadedEdgeOpacity },
@@ -762,6 +774,28 @@ function validateStrandStep(step, path) {
     if (typeof body.output_is_sequence !== 'boolean') {
       throw new Error(`CapFabRenderer: ${path}.step_type.Cap.output_is_sequence must be a boolean`);
     }
+    // `inputs` (capdag CapInput list) carries the data-flow graph: the main
+    // input plus any convergence inputs. Optional on legacy payloads, but
+    // when present it must be well-formed — the fan-in edges are drawn from
+    // it, so a malformed entry is a hard error, not a silent skip.
+    if (body.inputs !== undefined) {
+      assertArray(body.inputs, `${path}.step_type.Cap.inputs`);
+      body.inputs.forEach((input, inputIdx) => {
+        const inputPath = `${path}.step_type.Cap.inputs[${inputIdx}]`;
+        assertObject(input, inputPath);
+        assertString(input.arg_urn, `${inputPath}.arg_urn`);
+        // serde: unit variant → the string "StrandInput"; struct variant →
+        // { Step: { token_id } }. Anything else is malformed.
+        if (input.source === 'StrandInput') return;
+        if (input.source && typeof input.source === 'object' && input.source.Step) {
+          assertString(input.source.Step.token_id, `${inputPath}.source.Step.token_id`);
+          return;
+        }
+        throw new Error(
+          `CapFabRenderer: ${inputPath}.source must be "StrandInput" or { Step: { token_id } }`
+        );
+      });
+    }
   } else {
     assertString(body.media_def, `${path}.step_type.${variant}.media_def`);
   }
@@ -1309,6 +1343,17 @@ function buildStrandGraphData(data) {
     return outerExit;
   }
 
+  // Map every step's stable token_id to its output node id. A cap
+  // step's node (`step_${i}`) IS its `to_spec` output, so a convergence
+  // input naming a producer by token resolves to that producer's output
+  // node — the value flowing into the fan-in arg.
+  const tokenToNodeId = new Map();
+  data.steps.forEach((step, i) => {
+    if (step && typeof step.token_id === 'string' && step.token_id.length > 0) {
+      tokenToNodeId.set(step.token_id, `step_${i}`);
+    }
+  });
+
   data.steps.forEach((step, i) => {
     const variant = Object.keys(step.step_type)[0];
     const nodeId = `step_${i}`;
@@ -1330,8 +1375,43 @@ function buildStrandGraphData(data) {
       if (cardinality !== '1\u21921') {
         label = `${label} (${cardinality})`;
       }
+      // Resolve this cap's actual data-flow producers from `body.inputs`
+      // (capdag CapInput serde shape): each `source` is the string
+      // "StrandInput" (fed by the strand's input anchor → the input slot
+      // node) or `{ Step: { token_id } }` (fed by a producing cap → that
+      // step's output node). This is the authoritative topology; step
+      // ORDER is not — the realizer emits edges greedily in dependency
+      // order, so `prevNodeId` (the previously-emitted step) need not be
+      // one of this cap's inputs at all.
+      const capInputs = Array.isArray(body.inputs) ? body.inputs : [];
+      const producerNodeIds = [];
+      for (const input of capInputs) {
+        const src = input && input.source;
+        if (src === 'StrandInput') {
+          producerNodeIds.push(inputSlotId);
+          continue;
+        }
+        const producerToken = src && typeof src === 'object' && src.Step && src.Step.token_id;
+        if (typeof producerToken !== 'string' || producerToken.length === 0) continue;
+        const producerNodeId = tokenToNodeId.get(producerToken);
+        if (producerNodeId) producerNodeIds.push(producerNodeId);
+      }
+
+      // Pick the source of the single labeled "backbone" edge (the one
+      // carrying the cap title + cardinality). Inside a ForEach body — or
+      // when the cap declares no inputs — keep the linear `prevNodeId`
+      // thread so the ForEach boundary handling and its (1→n) entry marker
+      // are preserved exactly. Otherwise anchor the backbone on a REAL
+      // input: `prevNodeId` if it is genuinely one, else the first actual
+      // producer — so a non-input step ordered just before this cap can
+      // never become a spurious backbone edge.
+      const isForeachContext = isForeachEntry || insideForEachBody !== null;
+      let backboneSource = prevNodeId;
+      if (!isForeachContext && producerNodeIds.length > 0 && !producerNodeIds.includes(prevNodeId)) {
+        backboneSource = producerNodeIds[0];
+      }
       addEdge(
-        prevNodeId,
+        backboneSource,
         nodeId,
         label,
         body.title,
@@ -1340,6 +1420,25 @@ function buildStrandGraphData(data) {
         { foreachEntry: isForeachEntry }
       );
 
+      // Convergence (fan-in): draw an edge from every other producer that
+      // isn't the backbone source, so a cap fed by several producers renders
+      // as a DAG, not a chain. Deduplicated against the backbone edge and
+      // against a self-loop.
+      const drawnSources = new Set([backboneSource, nodeId]);
+      for (const producerNodeId of producerNodeIds) {
+        if (drawnSources.has(producerNodeId)) continue;
+        drawnSources.add(producerNodeId);
+        addEdge(
+          producerNodeId,
+          nodeId,
+          '',
+          body.title,
+          body.cap_urn,
+          'strand-convergence',
+          {}
+        );
+      }
+
       if (insideForEachBody !== null) {
         if (bodyEntry === null) bodyEntry = nodeId;
         bodyExit = nodeId;

package/capdag.js

@@ -6388,7 +6388,9 @@ async function scanChannelRoot(scanRoot, expectedSlug, identity, discovered) {
 //   [alias cap:in="...";op=...;out="..."]   — header (defines a cap with alias)
 //   [src -> alias -> dst]                   — wiring (connects nodes via cap)
 //   [(a, b) -> alias -> dst]               — fan-in wiring
-//   [src -> LOOP alias -> dst]             — loop wiring (ForEach semantics)
+//
+// Per-item map (`is_loop`) is a derived cardinality property, never authored
+// syntax — there is no LOOP marker in the grammar.
 // ============================================================================
 
 /**
@@ -6504,7 +6506,9 @@ class MachineEdge {
    */
   toString() {
     const sources = this.sources.map(s => s.toString()).join(', ');
-    const loopPrefix = this.isLoop ? 'LOOP ' : '';
+    // Debug-only marker for a per-item map edge. Not notation syntax (the
+    // `LOOP` keyword is retired); `is_loop` is a derived cardinality property.
+    const loopPrefix = this.isLoop ? 'map ' : '';
     return `(${sources}) -${loopPrefix}${this.capUrn}-> ${this.target}`;
   }
 }
@@ -6703,13 +6707,13 @@ class Machine {
       const targetKey = edge.target.toString();
       const targetName = nodeNames.get(targetKey);
 
-      const loopPrefix = edge.isLoop ? 'LOOP ' : '';
-
+      // `is_loop` is NOT emitted into notation text: it is a derived cardinality
+      // property, not authored syntax (the `LOOP` keyword is retired).
       if (sources.length === 1) {
-        output += `[${sources[0]} -> ${loopPrefix}${alias} -> ${targetName}]`;
+        output += `[${sources[0]} -> ${alias} -> ${targetName}]`;
       } else {
         const group = sources.join(', ');
-        output += `[(${group}) -> ${loopPrefix}${alias} -> ${targetName}]`;
+        output += `[(${group}) -> ${alias} -> ${targetName}]`;
       }
     }
 
@@ -6756,13 +6760,13 @@ class Machine {
       const targetKey = edge.target.toString();
       const targetName = nodeNames.get(targetKey);
 
-      const loopPrefix = edge.isLoop ? 'LOOP ' : '';
-
+      // `is_loop` is NOT emitted into notation text: it is a derived cardinality
+      // property, not authored syntax (the `LOOP` keyword is retired).
       if (sources.length === 1) {
-        lines.push(`[${sources[0]} -> ${loopPrefix}${alias} -> ${targetName}]`);
+        lines.push(`[${sources[0]} -> ${alias} -> ${targetName}]`);
       } else {
         const group = sources.join(', ');
-        lines.push(`[(${group}) -> ${loopPrefix}${alias} -> ${targetName}]`);
+        lines.push(`[(${group}) -> ${alias} -> ${targetName}]`);
       }
     }
 
@@ -6814,13 +6818,13 @@ class Machine {
       const targetKey = edge.target.toString();
       const targetName = nodeNames.get(targetKey);
 
-      const loopPrefix = edge.isLoop ? 'LOOP ' : '';
-
+      // `is_loop` is NOT emitted into notation text: it is a derived cardinality
+      // property, not authored syntax (the `LOOP` keyword is retired).
       if (sources.length === 1) {
-        lines.push(`${open}${sources[0]} -> ${loopPrefix}${alias} -> ${targetName}${close}`);
+        lines.push(`${open}${sources[0]} -> ${alias} -> ${targetName}${close}`);
       } else {
         const group = sources.join(', ');
-        lines.push(`${open}(${group}) -> ${loopPrefix}${alias} -> ${targetName}${close}`);
+        lines.push(`${open}(${group}) -> ${alias} -> ${targetName}${close}`);
       }
     }
 
@@ -6896,13 +6900,14 @@ class Machine {
 
       const sources = edge.sources.map(s => nodeNames.get(s.toString()));
       const targetName = nodeNames.get(edge.target.toString());
-      const loopPrefix = edge.isLoop ? 'LOOP ' : '';
 
+      // `is_loop` is NOT emitted into notation text: it is a derived cardinality
+      // property, not authored syntax (the `LOOP` keyword is retired).
       if (sources.length === 1) {
-        lines.push(`${open}${sources[0]} -> ${loopPrefix}${token} -> ${targetName}${close}`);
+        lines.push(`${open}${sources[0]} -> ${token} -> ${targetName}${close}`);
       } else {
         const group = sources.join(', ');
-        lines.push(`${open}(${group}) -> ${loopPrefix}${token} -> ${targetName}${close}`);
+        lines.push(`${open}(${group}) -> ${token} -> ${targetName}${close}`);
       }
     }
 
@@ -6990,7 +6995,8 @@ class Machine {
    * - Leaf targets: stadium-shaped nodes (rounded)
    * - Intermediate nodes: rectangular
    * - Edge labels: op= tag value (or full cap URN if no op)
-   * - LOOP edges: dotted line style with "LOOP" prefix on label
+   * - Per-item map edges (`is_loop`): dotted line style — `is_loop` is a
+   *   derived render property, never the retired `LOOP` keyword
    * - Node labels: derived MediaUrn type
    *
    * @returns {string} Mermaid flowchart definition
@@ -7045,8 +7051,9 @@ class Machine {
         const srcName = nodeNames.get(srcKey);
 
         if (edge.isLoop) {
-          // Dotted line for LOOP edges
-          lines.push(`  ${srcName} -. "LOOP ${label}" .-> ${targetName}`);
+          // Dotted line renders the derived per-item map (`is_loop`) property.
+          // No "LOOP" text — that keyword is retired.
+          lines.push(`  ${srcName} -. "${label}" .-> ${targetName}`);
         } else {
           lines.push(`  ${srcName} -- "${label}" --> ${targetName}`);
         }
@@ -7164,7 +7171,6 @@ function _parseMachineInternal(input) {
         sources: stmt.sources,
         capAlias: stmt.capAlias,
         target: stmt.target,
-        isLoop: stmt.isLoop,
         position: i,
         location: stmt.location,
         sourceLocations: stmt.sourceLocations,
@@ -7286,7 +7292,13 @@ function _parseMachineInternal(input) {
     assignOrCheckNode(wiring.target, capOutMedia, nodeMedia, wiring.position,
       wiring.targetLocation || wiring.location);
 
-    edges.push(new MachineEdge(sourceUrns, capUrn, capOutMedia, wiring.isLoop));
+    // `is_loop` is a derived cardinality property, not authored syntax (the
+    // `LOOP` keyword is retired). The pure-JS parse path has no cap definitions
+    // — it derives media only from the cap URN's in=/out= specs — so it cannot
+    // evaluate the ForEach rule (a sequence source feeding a scalar-input cap).
+    // Editors obtain the derived `is_loop` from the engine server's resolved
+    // graph; here it defaults to false.
+    edges.push(new MachineEdge(sourceUrns, capUrn, capOutMedia, false));
   }
 
   return {

package/capdag.test.js

@@ -3308,14 +3308,25 @@ function test6294_Machine_fanInSecondaryUnassignedGetsWildcard() {
   assertEqual(g.edges()[0].sources[1].toString(), 'media:');
 }
 
-// TEST6306: Machine loop edge
-function test6306_Machine_loopEdge() {
-  const g = Machine.fromString(
-    '[p2t cap:in="media:disbound-page;enc=utf-8";page-to-text;out="media:enc=utf-8;ext=txt"]' +
-    '[pages -> LOOP p2t -> texts]'
+// TEST6306: The retired LOOP keyword is no longer grammar. A wiring that still
+// writes `LOOP <cap>` before the cap alias no longer parses — `LOOP` is now an
+// ordinary alias, so `pages -> LOOP p2t -> texts` is two aliases in the cap
+// position with no arrow between them, which is a syntax error.
+function test6306_Machine_loopKeywordIsNotGrammar() {
+  assertThrowsWithCode(
+    () => Machine.fromString(
+      '[p2t cap:in="media:disbound-page;enc=utf-8";page-to-text;out="media:enc=utf-8;ext=txt"]' +
+      '[pages -> LOOP p2t -> texts]'
+    ),
+    MachineSyntaxErrorCodes.PARSE_ERROR
+  );
+
+  // `LOOP` on its own in the cap position parses fine — it is just an alias —
+  // but resolves to nothing, proving it carries no special meaning.
+  assertThrowsWithCode(
+    () => Machine.fromString('[pages -> LOOP -> texts]'),
+    MachineSyntaxErrorCodes.UNDEFINED_ALIAS
   );
-  assertEqual(g.edgeCount(), 1);
-  assertEqual(g.edges()[0].isLoop, true);
 }
 
 // TEST6308: Machine undefined alias fails
@@ -3416,14 +3427,16 @@ function test6331_Machine_lineBasedTwoStepChain() {
   assertEqual(g.edgeCount(), 2);
 }
 
-// TEST6334: Machine line based loop
-function test6334_Machine_lineBasedLoop() {
-  const g = Machine.fromString(
-    'p2t cap:in="media:disbound-page;enc=utf-8";page-to-text;out="media:enc=utf-8;ext=txt"\n' +
-    'pages -> LOOP p2t -> texts'
+// TEST6334: The retired LOOP keyword is not grammar in line-based mode either —
+// `pages -> LOOP p2t -> texts` is a syntax error, same as the bracketed form.
+function test6334_Machine_lineBasedLoopKeywordIsNotGrammar() {
+  assertThrowsWithCode(
+    () => Machine.fromString(
+      'p2t cap:in="media:disbound-page;enc=utf-8";page-to-text;out="media:enc=utf-8;ext=txt"\n' +
+      'pages -> LOOP p2t -> texts'
+    ),
+    MachineSyntaxErrorCodes.PARSE_ERROR
   );
-  assertEqual(g.edgeCount(), 1);
-  assertEqual(g.edges()[0].isLoop, true);
 }
 
 // TEST6337: Machine line based fan in
@@ -3835,8 +3848,12 @@ function test6415_Machine_roundtripFanOut() {
     'Fan-out round-trip failed: ' + notation);
 }
 
-// TEST6417: Machine roundtrip loop edge
-function test6417_Machine_roundtripLoopEdge() {
+// TEST6417: A per-item map (`is_loop`) edge serializes WITHOUT any LOOP marker —
+// `is_loop` is a derived cardinality property, not authored notation text. The
+// pure-JS parse path has no cap definitions to re-derive cardinality, so the
+// reparsed edge has `isLoop === false`; editors get the derived value from the
+// engine, not from re-parsing.
+function test6417_Machine_loopEdgeSerializesWithoutLoopText() {
   const original = new Machine([new MachineEdge(
     [MediaUrn.fromString('media:disbound-page;enc=utf-8')],
     CapUrn.fromString('cap:in="media:disbound-page;enc=utf-8";page-to-text;out="media:enc=utf-8;ext=txt"'),
@@ -3844,9 +3861,17 @@ function test6417_Machine_roundtripLoopEdge() {
     true
   )]);
   const notation = original.toMachineNotation();
+  assert(!notation.includes('LOOP'), 'serialized notation must not contain the retired LOOP keyword');
+
   const reparsed = Machine.fromString(notation);
-  assert(original.isEquivalent(reparsed), 'Loop round-trip failed');
-  assertEqual(reparsed.edges()[0].isLoop, true, 'isLoop must be preserved');
+  assertEqual(reparsed.edgeCount(), 1);
+  assertEqual(reparsed.edges()[0].isLoop, false,
+    'pure-JS parse path cannot derive cardinality — isLoop defaults to false');
+  // The structural payload (sources, cap, target) round-trips intact.
+  assert(reparsed.edges()[0].capUrn.isEquivalent(original.edges()[0].capUrn),
+    'cap URN must round-trip');
+  assert(reparsed.edges()[0].target.isEquivalent(original.edges()[0].target),
+    'target media must round-trip');
 }
 
 // TEST6419: Machine serialization is deterministic
@@ -4203,16 +4228,21 @@ function test6462_Machine_toMermaid_linearChain() {
   assert(mermaid.includes('(['), 'Should have stadium shape nodes');
 }
 
-// TEST6463: Machine to mermaid loop edge
+// TEST6463: Mermaid renders a per-item map (`is_loop`) edge with a dotted line
+// — `is_loop` is a kept render property — but emits NO "LOOP" text, since that
+// keyword is retired. The loop edge is built programmatically because the
+// grammar no longer has any way to author one.
 function test6463_Machine_toMermaid_loopEdge() {
-  const machine = Machine.fromString(
-    '[p2t cap:in="media:disbound-page;enc=utf-8";page-to-text;out="media:enc=utf-8;ext=txt"]' +
-    '[pages -> LOOP p2t -> texts]'
-  );
+  const machine = new Machine([new MachineEdge(
+    [MediaUrn.fromString('media:disbound-page;enc=utf-8')],
+    CapUrn.fromString('cap:in="media:disbound-page;enc=utf-8";page-to-text;out="media:enc=utf-8;ext=txt"'),
+    MediaUrn.fromString('media:enc=utf-8;ext=txt'),
+    true
+  )]);
   const mermaid = machine.toMermaid();
-  assert(mermaid.includes('LOOP'), 'Should include LOOP label');
-  assert(mermaid.includes('-.'), 'Should use dotted line for LOOP');
-  assert(mermaid.includes('.->'), 'Should use dotted arrow for LOOP');
+  assert(!mermaid.includes('LOOP'), 'Must not emit the retired LOOP label');
+  assert(mermaid.includes('-.'), 'Should use dotted line for the per-item map edge');
+  assert(mermaid.includes('.->'), 'Should use dotted arrow for the per-item map edge');
 }
 
 // TEST6464: Machine to mermaid empty graph
@@ -6749,7 +6779,7 @@ async function runTests() {
   runTest('MACHINE:fan_out', test6290_Machine_fanOut);
   runTest('MACHINE:fan_in_secondary_assigned_by_prior_wiring', test6292_Machine_fanInSecondaryAssignedByPriorWiring);
   runTest('MACHINE:fan_in_secondary_unassigned_gets_wildcard', test6294_Machine_fanInSecondaryUnassignedGetsWildcard);
-  runTest('MACHINE:loop_edge', test6306_Machine_loopEdge);
+  runTest('MACHINE:loop_keyword_is_not_grammar', test6306_Machine_loopKeywordIsNotGrammar);
   runTest('MACHINE:undefined_alias_fails', test6308_Machine_undefinedAliasFails);
   runTest('MACHINE:node_alias_collision', test6310_Machine_nodeAliasCollision);
   runTest('MACHINE:conflicting_media_types_fail', test6312_Machine_conflictingMediaTypesFail);
@@ -6762,7 +6792,7 @@ async function runTests() {
   console.log('\n--- machine/parser.rs (line-based) ---');
   runTest('MACHINE:line_based_simple_chain', test6327_Machine_lineBasedSimpleChain);
   runTest('MACHINE:line_based_two_step_chain', test6331_Machine_lineBasedTwoStepChain);
-  runTest('MACHINE:line_based_loop', test6334_Machine_lineBasedLoop);
+  runTest('MACHINE:line_based_loop_keyword_is_not_grammar', test6334_Machine_lineBasedLoopKeywordIsNotGrammar);
   runTest('MACHINE:line_based_fan_in', test6337_Machine_lineBasedFanIn);
   runTest('MACHINE:mixed_bracketed_and_line_based', test6341_Machine_mixedBracketedAndLineBased);
   runTest('MACHINE:line_based_equivalent_to_bracketed', test6345_Machine_lineBasedEquivalentToBracketed);
@@ -6797,7 +6827,7 @@ async function runTests() {
   runTest('MACHINE:roundtrip_single_edge', test6410_Machine_roundtripSingleEdge);
   runTest('MACHINE:roundtrip_two_edge_chain', test6413_Machine_roundtripTwoEdgeChain);
   runTest('MACHINE:roundtrip_fan_out', test6415_Machine_roundtripFanOut);
-  runTest('MACHINE:roundtrip_loop_edge', test6417_Machine_roundtripLoopEdge);
+  runTest('MACHINE:loop_edge_serializes_without_loop_text', test6417_Machine_loopEdgeSerializesWithoutLoopText);
   runTest('MACHINE:serialization_is_deterministic', test6419_Machine_serializationIsDeterministic);
   runTest('MACHINE:reordered_edges_produce_same_notation', test6421_Machine_reorderedEdgesProduceSameNotation);
   runTest('MACHINE:multiline_serialize_format', test6429_Machine_multilineSerializeFormat);

package/machine-parser.js

@@ -170,14 +170,13 @@ function peg$parse(input, options) {
   const peg$c2 = "(";
   const peg$c3 = ",";
   const peg$c4 = ")";
-  const peg$c5 = "LOOP";
-  const peg$c6 = "-";
-  const peg$c7 = ">";
-  const peg$c8 = "cap:";
-  const peg$c9 = "\r\n";
-  const peg$c10 = "\"";
-  const peg$c11 = "\\\"";
-  const peg$c12 = "\\\\";
+  const peg$c5 = "-";
+  const peg$c6 = ">";
+  const peg$c7 = "cap:";
+  const peg$c8 = "\r\n";
+  const peg$c9 = "\"";
+  const peg$c10 = "\\\"";
+  const peg$c11 = "\\\\";
 
   const peg$r0 = /^[a-zA-Z_]/;
   const peg$r1 = /^[a-zA-Z0-9_\-]/;
@@ -189,21 +188,20 @@ function peg$parse(input, options) {
   const peg$e2 = peg$literalExpectation("(", false);
   const peg$e3 = peg$literalExpectation(",", false);
   const peg$e4 = peg$literalExpectation(")", false);
-  const peg$e5 = peg$literalExpectation("LOOP", false);
-  const peg$e6 = peg$literalExpectation("-", false);
-  const peg$e7 = peg$literalExpectation(">", false);
-  const peg$e8 = peg$classExpectation([["a", "z"], ["A", "Z"], "_"], false, false, false);
-  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$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");
+  const peg$e5 = peg$literalExpectation("-", false);
+  const peg$e6 = peg$literalExpectation(">", false);
+  const peg$e7 = peg$classExpectation([["a", "z"], ["A", "Z"], "_"], false, false, false);
+  const peg$e8 = peg$classExpectation([["a", "z"], ["A", "Z"], ["0", "9"], "_", "-"], false, false, false);
+  const peg$e9 = peg$literalExpectation("cap:", false);
+  const peg$e10 = peg$anyExpectation();
+  const peg$e11 = peg$otherExpectation("newline");
+  const peg$e12 = peg$literalExpectation("\r\n", false);
+  const peg$e13 = peg$classExpectation(["\n", "\r"], false, false, false);
+  const peg$e14 = peg$literalExpectation("\"", false);
+  const peg$e15 = peg$literalExpectation("\\\"", false);
+  const peg$e16 = peg$literalExpectation("\\\\", false);
+  const peg$e17 = peg$classExpectation([" ", "\t", "\r", "\n"], false, false, false);
+  const peg$e18 = peg$otherExpectation("required whitespace");
 
   function peg$f0(stmts) {    return stmts;  }
   function peg$f1(inner) {    return inner;  }
@@ -211,18 +209,16 @@ function peg$parse(input, options) {
   function peg$f3(a, c) {
     return { type: 'header', alias: a.value, capUrn: c.value, location: location(), aliasLocation: a.location, capUrnLocation: c.location };
   }
-  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(s, c, t) {
+    return { type: 'wiring', sources: s.values, capAlias: c.value, target: t.value, location: location(), sourceLocations: s.locations, capAliasLocation: c.location, targetLocation: t.location };
   }
   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$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() };  }
+  function peg$f8(a) {    return { value: a, location: location() };  }
+  function peg$f9(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 }];
@@ -515,7 +511,7 @@ function peg$parse(input, options) {
       s3 = peg$parsearrow();
       if (s3 !== peg$FAILED) {
         s4 = peg$parse_();
-        s5 = peg$parseloop_cap_loc();
+        s5 = peg$parsealias_loc();
         if (s5 !== peg$FAILED) {
           s6 = peg$parse_();
           s7 = peg$parsearrow();
@@ -673,70 +669,27 @@ function peg$parse(input, options) {
     return s0;
   }
 
-  function peg$parseloop_cap_loc() {
-    let s0, s1, s2, s3;
-
-    s0 = peg$currPos;
-    if (input.substr(peg$currPos, 4) === peg$c5) {
-      s1 = peg$c5;
-      peg$currPos += 4;
-    } else {
-      s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e5); }
-    }
-    if (s1 !== peg$FAILED) {
-      s2 = peg$parse__();
-      if (s2 !== peg$FAILED) {
-        s3 = peg$parsealias_loc();
-        if (s3 !== peg$FAILED) {
-          peg$savedPos = s0;
-          s0 = peg$f8(s3);
-        } else {
-          peg$currPos = s0;
-          s0 = peg$FAILED;
-        }
-      } else {
-        peg$currPos = s0;
-        s0 = peg$FAILED;
-      }
-    } else {
-      peg$currPos = s0;
-      s0 = peg$FAILED;
-    }
-    if (s0 === peg$FAILED) {
-      s0 = peg$currPos;
-      s1 = peg$parsealias_loc();
-      if (s1 !== peg$FAILED) {
-        peg$savedPos = s0;
-        s1 = peg$f9(s1);
-      }
-      s0 = s1;
-    }
-
-    return s0;
-  }
-
   function peg$parsearrow() {
     let s0, s1, s2;
 
     s0 = peg$currPos;
     s1 = [];
     if (input.charCodeAt(peg$currPos) === 45) {
-      s2 = peg$c6;
+      s2 = peg$c5;
       peg$currPos++;
     } else {
       s2 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e6); }
+      if (peg$silentFails === 0) { peg$fail(peg$e5); }
     }
     if (s2 !== peg$FAILED) {
       while (s2 !== peg$FAILED) {
         s1.push(s2);
         if (input.charCodeAt(peg$currPos) === 45) {
-          s2 = peg$c6;
+          s2 = peg$c5;
           peg$currPos++;
         } else {
           s2 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e6); }
+          if (peg$silentFails === 0) { peg$fail(peg$e5); }
         }
       }
     } else {
@@ -744,11 +697,11 @@ function peg$parse(input, options) {
     }
     if (s1 !== peg$FAILED) {
       if (input.charCodeAt(peg$currPos) === 62) {
-        s2 = peg$c7;
+        s2 = peg$c6;
         peg$currPos++;
       } else {
         s2 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e7); }
+        if (peg$silentFails === 0) { peg$fail(peg$e6); }
       }
       if (s2 !== peg$FAILED) {
         s1 = [s1, s2];
@@ -772,7 +725,7 @@ function peg$parse(input, options) {
     s1 = peg$parsealias();
     if (s1 !== peg$FAILED) {
       peg$savedPos = s0;
-      s1 = peg$f10(s1);
+      s1 = peg$f8(s1);
     }
     s0 = s1;
 
@@ -789,7 +742,7 @@ function peg$parse(input, options) {
       peg$currPos++;
     } else {
       s2 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e8); }
+      if (peg$silentFails === 0) { peg$fail(peg$e7); }
     }
     if (s2 !== peg$FAILED) {
       s3 = [];
@@ -798,7 +751,7 @@ function peg$parse(input, options) {
         peg$currPos++;
       } else {
         s4 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e9); }
+        if (peg$silentFails === 0) { peg$fail(peg$e8); }
       }
       while (s4 !== peg$FAILED) {
         s3.push(s4);
@@ -807,7 +760,7 @@ function peg$parse(input, options) {
           peg$currPos++;
         } else {
           s4 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e9); }
+          if (peg$silentFails === 0) { peg$fail(peg$e8); }
         }
       }
       s2 = [s2, s3];
@@ -832,7 +785,7 @@ function peg$parse(input, options) {
     s1 = peg$parsecap_urn();
     if (s1 !== peg$FAILED) {
       peg$savedPos = s0;
-      s1 = peg$f11(s1);
+      s1 = peg$f9(s1);
     }
     s0 = s1;
 
@@ -844,12 +797,12 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     s1 = peg$currPos;
-    if (input.substr(peg$currPos, 4) === peg$c8) {
-      s2 = peg$c8;
+    if (input.substr(peg$currPos, 4) === peg$c7) {
+      s2 = peg$c7;
       peg$currPos += 4;
     } else {
       s2 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e10); }
+      if (peg$silentFails === 0) { peg$fail(peg$e9); }
     }
     if (s2 !== peg$FAILED) {
       s3 = [];
@@ -912,7 +865,7 @@ function peg$parse(input, options) {
             peg$currPos++;
           } else {
             s3 = peg$FAILED;
-            if (peg$silentFails === 0) { peg$fail(peg$e11); }
+            if (peg$silentFails === 0) { peg$fail(peg$e10); }
           }
           if (s3 !== peg$FAILED) {
             s1 = [s1, s2, s3];
@@ -938,12 +891,12 @@ function peg$parse(input, options) {
     let s0, s1;
 
     peg$silentFails++;
-    if (input.substr(peg$currPos, 2) === peg$c9) {
-      s0 = peg$c9;
+    if (input.substr(peg$currPos, 2) === peg$c8) {
+      s0 = peg$c8;
       peg$currPos += 2;
     } else {
       s0 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e13); }
+      if (peg$silentFails === 0) { peg$fail(peg$e12); }
     }
     if (s0 === peg$FAILED) {
       s0 = input.charAt(peg$currPos);
@@ -951,13 +904,13 @@ function peg$parse(input, options) {
         peg$currPos++;
       } else {
         s0 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e14); }
+        if (peg$silentFails === 0) { peg$fail(peg$e13); }
       }
     }
     peg$silentFails--;
     if (s0 === peg$FAILED) {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e12); }
+      if (peg$silentFails === 0) { peg$fail(peg$e11); }
     }
 
     return s0;
@@ -968,39 +921,39 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     if (input.charCodeAt(peg$currPos) === 34) {
-      s1 = peg$c10;
+      s1 = peg$c9;
       peg$currPos++;
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e15); }
+      if (peg$silentFails === 0) { peg$fail(peg$e14); }
     }
     if (s1 !== peg$FAILED) {
       s2 = [];
-      if (input.substr(peg$currPos, 2) === peg$c11) {
-        s3 = peg$c11;
+      if (input.substr(peg$currPos, 2) === peg$c10) {
+        s3 = peg$c10;
         peg$currPos += 2;
       } else {
         s3 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e16); }
+        if (peg$silentFails === 0) { peg$fail(peg$e15); }
       }
       if (s3 === peg$FAILED) {
-        if (input.substr(peg$currPos, 2) === peg$c12) {
-          s3 = peg$c12;
+        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$e17); }
+          if (peg$silentFails === 0) { peg$fail(peg$e16); }
         }
         if (s3 === peg$FAILED) {
           s3 = peg$currPos;
           s4 = peg$currPos;
           peg$silentFails++;
           if (input.charCodeAt(peg$currPos) === 34) {
-            s5 = peg$c10;
+            s5 = peg$c9;
             peg$currPos++;
           } else {
             s5 = peg$FAILED;
-            if (peg$silentFails === 0) { peg$fail(peg$e15); }
+            if (peg$silentFails === 0) { peg$fail(peg$e14); }
           }
           peg$silentFails--;
           if (s5 === peg$FAILED) {
@@ -1015,7 +968,7 @@ function peg$parse(input, options) {
               peg$currPos++;
             } else {
               s5 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e11); }
+              if (peg$silentFails === 0) { peg$fail(peg$e10); }
             }
             if (s5 !== peg$FAILED) {
               s4 = [s4, s5];
@@ -1032,31 +985,31 @@ function peg$parse(input, options) {
       }
       while (s3 !== peg$FAILED) {
         s2.push(s3);
-        if (input.substr(peg$currPos, 2) === peg$c11) {
-          s3 = peg$c11;
+        if (input.substr(peg$currPos, 2) === peg$c10) {
+          s3 = peg$c10;
           peg$currPos += 2;
         } else {
           s3 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e16); }
+          if (peg$silentFails === 0) { peg$fail(peg$e15); }
         }
         if (s3 === peg$FAILED) {
-          if (input.substr(peg$currPos, 2) === peg$c12) {
-            s3 = peg$c12;
+          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$e17); }
+            if (peg$silentFails === 0) { peg$fail(peg$e16); }
           }
           if (s3 === peg$FAILED) {
             s3 = peg$currPos;
             s4 = peg$currPos;
             peg$silentFails++;
             if (input.charCodeAt(peg$currPos) === 34) {
-              s5 = peg$c10;
+              s5 = peg$c9;
               peg$currPos++;
             } else {
               s5 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e15); }
+              if (peg$silentFails === 0) { peg$fail(peg$e14); }
             }
             peg$silentFails--;
             if (s5 === peg$FAILED) {
@@ -1071,7 +1024,7 @@ function peg$parse(input, options) {
                 peg$currPos++;
               } else {
                 s5 = peg$FAILED;
-                if (peg$silentFails === 0) { peg$fail(peg$e11); }
+                if (peg$silentFails === 0) { peg$fail(peg$e10); }
               }
               if (s5 !== peg$FAILED) {
                 s4 = [s4, s5];
@@ -1088,11 +1041,11 @@ function peg$parse(input, options) {
         }
       }
       if (input.charCodeAt(peg$currPos) === 34) {
-        s3 = peg$c10;
+        s3 = peg$c9;
         peg$currPos++;
       } else {
         s3 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e15); }
+        if (peg$silentFails === 0) { peg$fail(peg$e14); }
       }
       if (s3 !== peg$FAILED) {
         s1 = [s1, s2, s3];
@@ -1119,7 +1072,7 @@ function peg$parse(input, options) {
       peg$currPos++;
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e18); }
+      if (peg$silentFails === 0) { peg$fail(peg$e17); }
     }
     while (s1 !== peg$FAILED) {
       s0.push(s1);
@@ -1128,7 +1081,7 @@ function peg$parse(input, options) {
         peg$currPos++;
       } else {
         s1 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e18); }
+        if (peg$silentFails === 0) { peg$fail(peg$e17); }
       }
     }
     peg$silentFails--;
@@ -1146,7 +1099,7 @@ function peg$parse(input, options) {
       peg$currPos++;
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e18); }
+      if (peg$silentFails === 0) { peg$fail(peg$e17); }
     }
     if (s1 !== peg$FAILED) {
       while (s1 !== peg$FAILED) {
@@ -1156,7 +1109,7 @@ function peg$parse(input, options) {
           peg$currPos++;
         } else {
           s1 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e18); }
+          if (peg$silentFails === 0) { peg$fail(peg$e17); }
         }
       }
     } else {
@@ -1165,7 +1118,7 @@ function peg$parse(input, options) {
     peg$silentFails--;
     if (s0 === peg$FAILED) {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e19); }
+      if (peg$silentFails === 0) { peg$fail(peg$e18); }
     }
 
     return s0;

package/machine.pegjs

@@ -13,7 +13,6 @@
 //   extract cap:in="media:ext=pdf";extract;out="media:txt;textable"
 //   doc -> extract -> text
 //   (thumbnail, model_spec) -> describe -> description
-//   pages -> LOOP p2t -> texts
 //
 // Both forms can be freely mixed in the same program.
 
@@ -29,9 +28,12 @@ header = a:alias_loc __ c:cap_urn_loc {
   return { type: 'header', alias: a.value, capUrn: c.value, location: location(), aliasLocation: a.location, capUrnLocation: c.location };
 }
 
-// Wiring: source -> loop_cap -> target
-wiring = s:source_loc _ arrow _ lc:loop_cap_loc _ arrow _ t:alias_loc {
-  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 };
+// Wiring: source -> cap -> target
+//
+// The cap position is a plain alias. There is no LOOP marker: per-item map
+// (`is_loop`) is a derived cardinality property, never authored syntax.
+wiring = s:source_loc _ arrow _ c:alias_loc _ arrow _ t:alias_loc {
+  return { type: 'wiring', sources: s.values, capAlias: c.value, target: t.value, location: location(), sourceLocations: s.locations, capAliasLocation: c.location, targetLocation: t.location };
 }
 
 source_loc = group_loc / single_alias_loc
@@ -42,9 +44,6 @@ group_loc = "(" _ first:alias_loc rest:("," _ a:alias_loc { return a; })+ _ ")"
   return { values: [first.value, ...rest.map(r => r.value)], locations: [first.location, ...rest.map(r => r.location)] };
 }
 
-loop_cap_loc = "LOOP" __ a:alias_loc { return { alias: a.value, isLoop: true, location: a.location }; }
-            / a:alias_loc { return { alias: a.value, isLoop: false, location: a.location }; }
-
 arrow = "-"+ ">"
 
 // Alias with location tracking

package/package.json

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