capdag 1.219.594 → 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

@@ -5876,10 +5876,11 @@ function unixSecondsNow() {
 }
 
 // Default protocol limits / version, mirroring capdag::bifaci::frame.
-const BIFACI_PROTOCOL_VERSION = 2;
+const BIFACI_PROTOCOL_VERSION = 3;
 const BIFACI_DEFAULT_MAX_FRAME = 3670016;
 const BIFACI_DEFAULT_MAX_CHUNK = 262144;
 const BIFACI_DEFAULT_MAX_REORDER_BUFFER = 64;
+const BIFACI_DEFAULT_INITIAL_CREDIT = 32;
 const BIFACI_FRAME_TYPE_HELLO = 0;
 // Frame CBOR integer keys (capdag::bifaci::frame::keys).
 const BIFACI_KEY_VERSION = 0;
@@ -6008,6 +6009,7 @@ function encodeHelloFrame() {
       ['max_frame', BIFACI_DEFAULT_MAX_FRAME],
       ['max_chunk', BIFACI_DEFAULT_MAX_CHUNK],
       ['max_reorder_buffer', BIFACI_DEFAULT_MAX_REORDER_BUFFER],
+      ['initial_credit', BIFACI_DEFAULT_INITIAL_CREDIT],
       ['version', BIFACI_PROTOCOL_VERSION],
     ],
   };
@@ -6386,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.
 // ============================================================================
 
 /**
@@ -6502,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}`;
   }
 }
@@ -6701,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}]`;
       }
     }
 
@@ -6754,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}]`);
       }
     }
 
@@ -6812,13 +6818,96 @@ 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]} -> ${alias} -> ${targetName}${close}`);
+      } else {
+        const group = sources.join(', ');
+        lines.push(`${open}(${group}) -> ${alias} -> ${targetName}${close}`);
+      }
+    }
+
+    return bracketed ? lines.join('') : lines.join('\n');
+  }
+
+  /**
+   * Serialize to machine notation rendering each cap by its registered display
+   * alias (shortest name, ties alphabetical) when one exists, falling back to
+   * the canonical-URN `edge_N` header form otherwise. This is the "store
+   * aliased" form: generated and persisted machines use it so the saved
+   * notation reads in terms of aliases.
+   *
+   * Semantics (mirrors Rust Machine::to_machine_notation_aliased):
+   *  - A cap WITH a display alias is referenced DIRECTLY in the wiring's
+   *    cap-position by its alias name, with NO `[edge_N cap:...]` header (the
+   *    grammar forbids an alias in a header's cap position anyway, and a header
+   *    would be redundant).
+   *  - A cap WITHOUT an alias keeps the synthetic `edge_N` wiring token plus its
+   *    `[edge_N cap:...]` header binding it to the canonical cap URN.
+   *
+   * The canonical `edge_N` numbering and node naming are inherited unchanged
+   * from the canonical serializer, so an un-aliased machine produces byte-
+   * identical output to toMachineNotationFormatted.
+   *
+   * @param {FabricRegistryClient} registry - resolves URN → display alias
+   * @param {'bracketed' | 'line-based'} format
+   * @returns {string}
+   */
+  toMachineNotationAliased(registry, format) {
+    if (this._edges.length === 0) {
+      return '';
+    }
+
+    const { aliases, nodeNames, edgeOrder } = this._buildSerializationMaps();
+    const bracketed = format === 'bracketed';
+    const open = bracketed ? '[' : '';
+    const close = bracketed ? ']' : '';
+
+    // Resolve, per edge index, the cap-position token and whether it needs a
+    // header. An aliased cap uses its display alias directly (no header); an
+    // un-aliased cap keeps its synthetic `edge_N` token (with a header).
+    const edgeToken = new Map();   // edgeIdx → token used in the wiring
+    const edgeNeedsHeader = new Map(); // edgeIdx → bool
+    for (const [edgeAlias, info] of aliases) {
+      const edge = this._edges[info.edgeIdx];
+      const displayAlias = registry.displayAliasForUrn(edge.capUrn.toString());
+      if (displayAlias !== null && displayAlias !== undefined) {
+        edgeToken.set(info.edgeIdx, displayAlias);
+        edgeNeedsHeader.set(info.edgeIdx, false);
+      } else {
+        edgeToken.set(info.edgeIdx, edgeAlias);
+        edgeNeedsHeader.set(info.edgeIdx, true);
+      }
+    }
+
+    const lines = [];
+
+    // Headers only for edges that kept a synthetic `edge_N` token (un-aliased
+    // caps). Emit in alias-sorted order to match the canonical serializer.
+    const sortedAliases = Array.from(aliases.entries()).sort((a, b) => a[0] < b[0] ? -1 : a[0] > b[0] ? 1 : 0);
+    for (const [, info] of sortedAliases) {
+      if (edgeNeedsHeader.get(info.edgeIdx)) {
+        const edge = this._edges[info.edgeIdx];
+        lines.push(`${open}${edgeToken.get(info.edgeIdx)} ${edge.capUrn}${close}`);
+      }
+    }
+
+    // Wirings in canonical edge order, using the resolved cap-position token.
+    for (const edgeIdx of edgeOrder) {
+      const edge = this._edges[edgeIdx];
+      const token = edgeToken.get(edgeIdx);
 
+      const sources = edge.sources.map(s => nodeNames.get(s.toString()));
+      const targetName = nodeNames.get(edge.target.toString());
+
+      // `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]} -> ${token} -> ${targetName}${close}`);
       } else {
         const group = sources.join(', ');
-        lines.push(`${open}(${group}) -> ${loopPrefix}${alias} -> ${targetName}${close}`);
+        lines.push(`${open}(${group}) -> ${token} -> ${targetName}${close}`);
       }
     }
 
@@ -6906,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
@@ -6961,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}`);
         }
@@ -7080,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,
@@ -7202,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 {
@@ -7413,6 +7509,12 @@ class FabricRegistryClient {
     // canonical key only needs to be unique per equivalence class; we
     // store one entry per equivalence class.
     this._mediaCache = new Map();
+    // Normalized alias name → StoredAlias. Mirrors Rust
+    // FabricRegistry::cached_aliases. The display/serialization surfaces
+    // read this synchronously; it is warmed by insertCachedAliasForTest (and,
+    // in the heavier mirrors, a background prefetch this lightweight client
+    // does not implement).
+    this._cachedAliases = new Map();
   }
 
   /**
@@ -7542,12 +7644,88 @@ class FabricRegistryClient {
     return Array.from(ops).sort();
   }
 
+  /**
+   * Insert an alias directly into the in-memory cache, keyed by its
+   * normalized name. Mirrors Rust
+   * FabricRegistry::insert_cached_alias_for_test — it is the warm-cache seam
+   * the display/serialization primitives read from. The lightweight JS client
+   * has no background alias prefetch, so callers seed the cache through here.
+   *
+   * @param {StoredAlias} alias
+   */
+  insertCachedAliasForTest(alias) {
+    const normalized = normalizeAliasName(alias.name);
+    this._cachedAliases.set(normalized, alias);
+  }
+
+  /**
+   * Reverse lookup: the display alias for a `cap:`/`media:` URN, or null if no
+   * cached alias points at it. This is the canonical primitive every UI surface
+   * and notation generator uses to render an aliased name in place of a raw URN.
+   *
+   * The query URN is canonicalised through its own parser (cap vs media by
+   * prefix) before matching, because alias targets are stored canonically — a
+   * non-canonical query (different tag order, redundant whitespace) would
+   * otherwise miss. A URN that is neither a cap nor a media URN, or that fails
+   * to parse, returns null (it cannot have an alias).
+   *
+   * When multiple aliases target the same URN, the winner is the SHORTEST name,
+   * ties broken alphabetically (see selectDisplayAlias). This is deterministic
+   * and stable across processes for a given alias set.
+   *
+   * Mirrors Rust FabricRegistry::display_alias_for_urn.
+   * @param {string} urn
+   * @returns {string|null}
+   */
+  displayAliasForUrn(urn) {
+    // Canonicalise by kind. classifyAliasTarget keys off the parser (cap vs
+    // media), the same classifier the alias publisher uses for targets, so a
+    // query and a stored target canonicalise identically.
+    const kind = classifyAliasTarget(urn);
+    let canonical;
+    if (kind === ALIAS_TARGET_CAP) {
+      canonical = CapUrn.fromString(urn).toString();
+    } else if (kind === ALIAS_TARGET_MEDIA) {
+      canonical = MediaUrn.fromString(urn).toString();
+    } else {
+      return null;
+    }
+
+    const names = [];
+    for (const alias of this._cachedAliases.values()) {
+      if (alias.target === canonical) {
+        names.push(alias.name);
+      }
+    }
+    return selectDisplayAlias(names);
+  }
+
+  /**
+   * All cached aliases whose target is a CAP URN, as [name, capUrn] pairs.
+   * Used by the notation editor to offer registered cap aliases as wiring
+   * completions. Order is unspecified (the caller sorts/filters). Synchronous,
+   * cache-only — relies on the alias cache having been warmed.
+   *
+   * Mirrors Rust FabricRegistry::cached_cap_aliases.
+   * @returns {Array<[string, string]>}
+   */
+  cachedCapAliases() {
+    const pairs = [];
+    for (const alias of this._cachedAliases.values()) {
+      if (classifyAliasTarget(alias.target) === ALIAS_TARGET_CAP) {
+        pairs.push([alias.name, alias.target]);
+      }
+    }
+    return pairs;
+  }
+
   /**
    * Invalidate all caches. Next call to any method fetches fresh data.
    */
   invalidate() {
     this._capCache = null;
     this._mediaCache.clear();
+    this._cachedAliases.clear();
   }
 }
 
@@ -7620,6 +7798,34 @@ function classifyAliasTarget(target) {
   return null;
 }
 
+/**
+ * Pick the display alias from a set of alias names that all target the same
+ * URN: the SHORTEST name, ties broken alphabetically. Returns null for an
+ * empty set.
+ *
+ * The ordering is total and deterministic: (length, name) lexicographic. So
+ * `png` beats `png-image` (shorter), and between equal-length `a16` / `a09`
+ * the alphabetical-smaller `a09` wins. Stable across processes for a given
+ * alias set, which is what makes aliased UI/notation reproducible.
+ *
+ * Mirrors Rust select_display_alias.
+ * @param {Iterable<string>} names
+ * @returns {string|null}
+ */
+function selectDisplayAlias(names) {
+  let best = null;
+  for (const name of names) {
+    if (
+      best === null ||
+      name.length < best.length ||
+      (name.length === best.length && name < best)
+    ) {
+      best = name;
+    }
+  }
+  return best;
+}
+
 /**
  * The published wire/cache shape of a single fabric alias. Mirrors
  * fabric/alias.schema.json: { name, target, version }.
@@ -7682,6 +7888,7 @@ module.exports = {
   isAliasToken,
   normalizeAliasName,
   classifyAliasTarget,
+  selectDisplayAlias,
   StoredAlias,
   Manifest,
   CapUrn,

package/capdag.test.js

@@ -36,6 +36,7 @@ const {
   CAP_IDENTITY,
   ALIAS_TARGET_CAP, ALIAS_TARGET_MEDIA,
   tokenIsUrn, isAliasToken, normalizeAliasName, classifyAliasTarget,
+  selectDisplayAlias,
   StoredAlias, Manifest
 } = require('./capdag.js');
 
@@ -3307,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
@@ -3415,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
@@ -3834,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"'),
@@ -3843,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
@@ -4202,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
@@ -6383,6 +6414,107 @@ function test1887_manifestSerdeRoundTripsAliases() {
   assertEqual(JSON.stringify(a.toJSON()), '{"name":"pdf2text","target":"cap:effect=none","version":3}', 'alias wire shape');
 }
 
+// TEST1894: selectDisplayAlias picks the SHORTEST name, ties broken
+// alphabetically. This is the deterministic ordering every aliased-display
+// surface relies on; a regression here silently changes which alias the whole
+// UI renders.
+function test1894_selectDisplayAliasOrdering() {
+  // Shorter wins over longer regardless of alphabetical order.
+  assertEqual(selectDisplayAlias(['png-image', 'png', 'image-png']), 'png', 'shortest wins');
+  // Equal length → alphabetical (a09 < a16).
+  assertEqual(selectDisplayAlias(['a16', 'a09', 'a12']), 'a09', 'tie → alphabetical');
+  // Single candidate returns itself.
+  assertEqual(selectDisplayAlias(['solo']), 'solo', 'single candidate');
+  // Empty set → null.
+  assertEqual(selectDisplayAlias([]), null, 'empty → null');
+}
+
+// TEST1895: displayAliasForUrn reverse-resolves a URN to its display alias.
+// Proves: (1) the shortest-then-alphabetical winner among multiple aliases on
+// the same target, (2) a NON-canonical query URN (different tag order) still
+// resolves because the query is canonicalised before matching, (3) a URN with
+// no alias returns null, (4) a non-URN string returns null.
+function test1895_displayAliasForUrn() {
+  const registry = new FabricRegistryClient();
+  const capTarget = CapUrn.fromString('cap:coerce;in="media:integer;numeric";out="media:enc=utf-8"').toString();
+  // Two aliases on the same cap target; "i2s" is shorter than "int2str".
+  registry.insertCachedAliasForTest(new StoredAlias('int2str', capTarget, 1));
+  registry.insertCachedAliasForTest(new StoredAlias('i2s', capTarget, 1));
+  // A media alias too. Stored canonically.
+  const jsonTarget = MediaUrn.fromString('media:fmt=json;record').toString();
+  registry.insertCachedAliasForTest(new StoredAlias('json', jsonTarget, 1));
+
+  // Canonical query → shortest alias wins.
+  assertEqual(
+    registry.displayAliasForUrn('cap:coerce;in="media:integer;numeric";out="media:enc=utf-8"'),
+    'i2s', 'shortest cap alias wins');
+  // NON-canonical query (media tags reordered) must still resolve via
+  // canonicalisation.
+  assertEqual(registry.displayAliasForUrn('media:record;fmt=json'), 'json',
+    'non-canonical media query canonicalises');
+  // A real URN with no alias → null.
+  assertEqual(registry.displayAliasForUrn('media:enc=utf-8;ext=pdf'), null, 'no alias → null');
+  // A non-URN (no cap:/media: prefix) → null, never a throw.
+  assertEqual(registry.displayAliasForUrn('int2str'), null, 'non-URN → null');
+}
+
+// TEST1896: cachedCapAliases returns only CAP-targeted aliases as [name,
+// target] pairs — media aliases are excluded. Drives the notation editor's
+// registered-alias completions.
+function test1896_cachedCapAliasesFiltersToCapTargets() {
+  const registry = new FabricRegistryClient();
+  const capTarget = CapUrn.fromString('cap:coerce;in="media:integer;numeric";out="media:enc=utf-8"').toString();
+  registry.insertCachedAliasForTest(new StoredAlias('int2str', capTarget, 1));
+  registry.insertCachedAliasForTest(new StoredAlias('json', MediaUrn.fromString('media:fmt=json;record').toString(), 1));
+  const capAliases = registry.cachedCapAliases();
+  assertEqual(capAliases.length, 1, 'only the cap alias is returned');
+  assertEqual(capAliases[0][0], 'int2str', 'pair name');
+  assertEqual(capAliases[0][1], capTarget, 'pair target');
+}
+
+// TEST1196: toMachineNotationAliased references an aliased cap DIRECTLY in the
+// wiring by its display alias (shortest, then alphabetical) with NO header, and
+// keeps the synthetic `edge_N` token + header for a cap that has no alias.
+function test1196_aliasedSerializationUsesAliasAndDropsHeader() {
+  const registry = new FabricRegistryClient();
+  const m = Machine.fromString(
+    '[extract cap:in="media:ext=pdf";extract;out="media:enc=utf-8;ext=txt"]' +
+    '[embed cap:in="media:enc=utf-8;ext=txt";embed;out="media:embedding-vector;enc=utf-8;record"]' +
+    '[doc -> extract -> text]' +
+    '[text -> embed -> vectors]'
+  );
+  // Canonical target strings for the two caps, exactly as the serializer keys.
+  const extractTarget = m.edges().find(e => e.capUrn.toString().includes('extract')).capUrn.toString();
+  // Two aliases on the extract cap; "ex" is shorter than "extract-pdf".
+  registry.insertCachedAliasForTest(new StoredAlias('extract-pdf', extractTarget, 1));
+  registry.insertCachedAliasForTest(new StoredAlias('ex', extractTarget, 1));
+  // No alias for the embed cap → it must stay a raw URN with a header.
+
+  const aliased = m.toMachineNotationAliased(registry, 'bracketed');
+
+  // The extract cap is aliased: referenced directly in the wiring by its
+  // SHORTER alias `ex`, with NO header, and its URN must not appear.
+  assert(aliased.includes('-> ex ->'),
+    `extract cap must be referenced by shortest alias 'ex', got: ${aliased}`);
+  assert(!aliased.includes('extract;out'),
+    `the aliased extract cap URN must not appear, got: ${aliased}`);
+  // The longer alias must not be chosen.
+  assert(!aliased.includes('extract-pdf'),
+    `the longer alias must not be used, got: ${aliased}`);
+  // The un-aliased embed cap keeps its synthetic header binding `edge_N` to the
+  // canonical embed URN.
+  assert(/\[edge_\d+ cap:.*embed/.test(aliased),
+    `the un-aliased embed cap must keep its header URN, got: ${aliased}`);
+
+  // An un-aliased machine (empty registry) is byte-identical to the canonical
+  // formatted form — the aliased path adds nothing when no alias exists.
+  const empty = new FabricRegistryClient();
+  assertEqual(
+    m.toMachineNotationAliased(empty, 'bracketed'),
+    m.toMachineNotationFormatted('bracketed'),
+    'no aliases → identical to canonical bracketed form');
+}
+
 // ============================================================================
 // Test runner
 // ============================================================================
@@ -6647,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);
@@ -6660,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);
@@ -6695,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);
@@ -6849,6 +6981,12 @@ async function runTests() {
   runTest('TEST1882: classify_alias_target_by_prefix',      test1882_classifyAliasTargetByPrefix);
   runTest('TEST1887: manifest_serde_round_trips_aliases',   test1887_manifestSerdeRoundTripsAliases);
 
+  console.log('\n--- URN→alias display + aliased serialization (test1894–test1896, test1196) ---');
+  runTest('TEST1894: select_display_alias_ordering',         test1894_selectDisplayAliasOrdering);
+  runTest('TEST1895: display_alias_for_urn',                 test1895_displayAliasForUrn);
+  runTest('TEST1896: cached_cap_aliases_filters_to_cap',     test1896_cachedCapAliasesFiltersToCapTargets);
+  runTest('TEST1196: aliased_serialization_uses_alias',      test1196_aliasedSerializationUsesAliasAndDropsHeader);
+
   // Summary
   console.log(`\n${passCount + failCount} tests: ${passCount} passed, ${failCount} failed`);
   if (failCount > 0) {

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.219.594"
+  "version": "1.226.626"
 }