capdag 1.222.603 → 1.233.649

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`);
   }
@@ -1091,7 +1125,7 @@ function buildBrowseGraphData(capabilities) {
     // Parsing the URN canonicalizes it and validates it — fail hard on
     // malformed registry data.
     const parsedUrn = CapUrn.fromString(capData.urn);
-    const cap = createCap(parsedUrn, title, capData.command || '');
+    const cap = createCap(parsedUrn, title, capData.aliases || []);
     const capFabEdgeIndex = capFab.edges.length;
     capFab.addCap(cap, 'registry');
 
@@ -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

@@ -2530,21 +2530,22 @@ class Cap {
    * @param {Object|null} metadataJson - Optional arbitrary metadata as JSON object
    * @param {string|null} documentation - Optional long-form markdown documentation. Rendered in capability info panels, the cap navigator, capdag-dot-com, and anywhere else a rich-text explanation of the cap is useful.
    */
-  constructor(urn, title, command, capDescription = null, metadata = {}, metadataJson = null, documentation = null) {
+  constructor(urn, title, aliases, capDescription = null, metadata = {}, metadataJson = null, documentation = null) {
     if (!(urn instanceof CapUrn)) {
       throw new Error('URN must be a CapUrn instance');
     }
     if (!title || typeof title !== 'string') {
       throw new Error('Title is required and must be a string');
     }
-    if (!command || typeof command !== 'string') {
-      throw new Error('Command is required and must be a string');
+    if (!Array.isArray(aliases) || aliases.length === 0) {
+      throw new Error('Aliases are required and must be a non-empty array');
     }
 
     this.urn = urn;
     this.version = 0;
     this.title = title;
-    this.command = command;
+    this.aliases = aliases;
+    this.is_abstract = false;
     this.cap_description = capDescription;
     this.documentation = documentation;
     this.metadata = metadata || {};
@@ -2752,7 +2753,8 @@ class Cap {
 
     return this.urn.equals(other.urn) &&
            this.title === other.title &&
-           this.command === other.command &&
+           JSON.stringify([...this.aliases].sort()) === JSON.stringify([...other.aliases].sort()) &&
+           this.is_abstract === other.is_abstract &&
            this.cap_description === other.cap_description &&
            this.documentation === other.documentation &&
            JSON.stringify(this.metadata) === JSON.stringify(other.metadata) &&
@@ -2772,7 +2774,7 @@ class Cap {
     const result = {
       urn: this.urn.toString(),
       title: this.title,
-      command: this.command,
+      aliases: this.aliases,
       cap_description: this.cap_description,
       metadata: this.metadata,
       args: this.args.map(a => a.toJSON()),
@@ -2783,6 +2785,10 @@ class Cap {
       result.version = this.version;
     }
 
+    if (this.is_abstract) {
+      result.abstract = true;
+    }
+
     // Long-form markdown documentation. Only emitted when set, to match
     // the Rust serializer which skips this field when None.
     if (typeof this.documentation === 'string' && this.documentation.length > 0) {
@@ -2821,7 +2827,11 @@ class Cap {
     const documentation = (typeof json.documentation === 'string' && json.documentation.length > 0)
       ? json.documentation
       : null;
-    const cap = new Cap(urn, json.title, json.command, json.cap_description, json.metadata, json.metadata_json, documentation);
+    if (!Array.isArray(json.aliases) || json.aliases.length === 0) {
+      throw new Error(`cap '${json.urn}' must declare at least one alias (the 'aliases' field is required and non-empty)`);
+    }
+    const cap = new Cap(urn, json.title, json.aliases, json.cap_description, json.metadata, json.metadata_json, documentation);
+    cap.is_abstract = json.abstract === true;
     cap.version = (typeof json.version === 'number' && json.version !== 0) ? json.version : 0;
     // Parse args (new format)
     if (json.args && Array.isArray(json.args)) {
@@ -3046,20 +3056,20 @@ class CapManifest {
 /**
  * Helper functions for creating capabilities
  */
-function createCap(urn, title, command) {
-  return new Cap(urn, title, command);
+function createCap(urn, title, aliases) {
+  return new Cap(urn, title, aliases);
 }
 
-function createCapWithDescription(urn, title, command, description) {
-  return new Cap(urn, title, command, description);
+function createCapWithDescription(urn, title, aliases, description) {
+  return new Cap(urn, title, aliases, description);
 }
 
-function createCapWithMetadata(urn, title, command, metadata) {
-  return new Cap(urn, title, command, null, metadata);
+function createCapWithMetadata(urn, title, aliases, metadata) {
+  return new Cap(urn, title, aliases, null, metadata);
 }
 
-function createCapWithDescriptionAndMetadata(urn, title, command, description, metadata) {
-  return new Cap(urn, title, command, description, metadata);
+function createCapWithDescriptionAndMetadata(urn, title, aliases, description, metadata) {
+  return new Cap(urn, title, aliases, description, metadata);
 }
 
 // ============================================================================
@@ -3747,9 +3757,9 @@ class CapValidator {
       });
     }
 
-    if (!cap.command || typeof cap.command !== 'string') {
+    if (!Array.isArray(cap.aliases) || cap.aliases.length === 0) {
       throw new ValidationError('InvalidCapSchema', capUrn, {
-        issue: 'Cap must have a valid command'
+        issue: 'Cap must have at least one alias'
       });
     }
 
@@ -4355,37 +4365,55 @@ class CartridgeCapGroup {
 // in synchronous contexts must await.
 
 const DEV_SLUG = "dev";
-const SLUG_HEX_LEN = 16;
 
 /**
- * Compute the on-disk slug for a registry URL.
+ * The authority (host[:port]) of a registry URL: after `://` up to the next
+ * `/`, `?`, or `#` (path/query/fragment discarded).
+ */
+function authorityOfRegistryUrl(url) {
+  const i = url.indexOf("://");
+  const afterScheme = i >= 0 ? url.slice(i + 3) : url;
+  const m = afterScheme.search(/[/?#]/);
+  return m >= 0 ? afterScheme.slice(0, m) : afterScheme;
+}
+
+/**
+ * Compute the on-disk slug for a registry URL. Mirrors
+ * capdag::cartridge_slug::slug_for byte-for-byte: `DEV_SLUG` for null/undefined,
+ * otherwise a path-safe transform of the URL's authority (host[:port]) —
+ * ASCII-lowercased, every character outside `[a-z0-9.-]` replaced by `-`.
+ * Depends ONLY on the authority; path/version/query/trailing-slash/host-case
+ * do not change it.
  *
- * @param {string|null|undefined} registryUrl - The registry URL, or
- *   null/undefined for dev installs.
- * @returns {Promise<string>} The slug — `DEV_SLUG` for null,
- *   otherwise the first 16 lowercase-hex characters of
- *   sha256(registryUrl).
+ * @param {string|null|undefined} registryUrl
+ * @returns {string}
  */
-async function slugForRegistryUrl(registryUrl) {
+function slugForRegistryUrlSync(registryUrl) {
   if (registryUrl === null || registryUrl === undefined) {
     return DEV_SLUG;
   }
-  const bytes = new TextEncoder().encode(registryUrl);
-  // Web Crypto exposes SHA-256 via crypto.subtle. Node 16+ exposes
-  // it through globalThis.crypto.subtle.
-  const digestBuffer = await crypto.subtle.digest("SHA-256", bytes);
-  const digestBytes = new Uint8Array(digestBuffer);
-  let hex = "";
-  for (const b of digestBytes) {
-    hex += b.toString(16).padStart(2, "0");
+  let out = "";
+  for (const ch of authorityOfRegistryUrl(registryUrl)) {
+    const lc = ch >= "A" && ch <= "Z" ? ch.toLowerCase() : ch;
+    out += (lc >= "a" && lc <= "z") || (lc >= "0" && lc <= "9") || lc === "." || lc === "-" ? lc : "-";
   }
-  return hex.slice(0, SLUG_HEX_LEN);
+  return out;
+}
+
+/**
+ * Async wrapper retained for callers that `await` the slug. The computation is
+ * synchronous (no hashing) — the authority transform needs no crypto.
+ * @returns {Promise<string>}
+ */
+async function slugForRegistryUrl(registryUrl) {
+  return slugForRegistryUrlSync(registryUrl);
 }
 
 function isRegistrySlug(s) {
   return typeof s === "string"
-      && s.length === SLUG_HEX_LEN
-      && /^[0-9a-f]+$/.test(s);
+      && s.length > 0
+      && s !== DEV_SLUG
+      && /^[a-z0-9.-]+$/.test(s);
 }
 
 // =============================================================================
@@ -4744,6 +4772,18 @@ class CartridgeRepoClient {
     if (data.schemaVersion !== '5.0') {
       throw new Error(`Cartridge registry from ${repoUrl} has schemaVersion '${data.schemaVersion}'; required: 5.0`);
     }
+    // Cartridge registry regime version. v0 was the pre-versioning legacy at
+    // the bare /manifest path; this speaks only v1 at /v1/manifest. A manifest
+    // from a different regime version is rejected, not reinterpreted.
+    if (data.registryVersion !== 1) {
+      throw new Error(`Cartridge registry from ${repoUrl} has registryVersion '${data.registryVersion}'; this build speaks v1`);
+    }
+    // A cartridge registry must declare the fabric its caps resolve against. The
+    // client cross-checks this equals its own fabric (so every registry it uses
+    // shares one fabric); here we require it is at least present.
+    if (typeof data.fabricRegistryUrl !== 'string' || data.fabricRegistryUrl.length === 0) {
+      throw new Error(`Cartridge registry from ${repoUrl}: missing required 'fabricRegistryUrl' (the fabric its caps resolve against)`);
+    }
     // Self-referential check: the manifest declares its own URL via
     // `registryUrl`. It must match the URL we just fetched from
     // byte-for-byte — a mismatch is a manifest-corruption signal
@@ -5021,6 +5061,12 @@ class CartridgeRepoServer {
     if (this.registry.schemaVersion !== '5.0') {
       throw new Error(`Unsupported registry schema version: ${this.registry.schemaVersion}. Required: 5.0`);
     }
+    if (this.registry.registryVersion !== 1) {
+      throw new Error(`Unsupported cartridge registry version: ${this.registry.registryVersion}. This build speaks v1.`);
+    }
+    if (typeof this.registry.fabricRegistryUrl !== 'string' || this.registry.fabricRegistryUrl.length === 0) {
+      throw new Error('Registry must declare a non-empty `fabricRegistryUrl` (the fabric its caps resolve against)');
+    }
     if (typeof this.registry.registryUrl !== 'string' || this.registry.registryUrl.length === 0) {
       throw new Error('Registry must have a non-empty top-level `registryUrl` field (self-referential URL)');
     }
@@ -5450,24 +5496,15 @@ class InstalledCartridgeRecord {
 /**
  * Synchronous on-disk slug for a registry URL. Mirrors
  * capdag::bifaci::cartridge_slug::slug_for byte-for-byte: `null`/`undefined`
- * (a dev cartridge) → the literal `DEV_SLUG`; otherwise the first
- * SLUG_HEX_LEN lowercase-hex characters of sha256(url bytes).
- *
- * The async `slugForRegistryUrl` above uses Web Crypto for browser parity;
- * discovery runs only under Node and needs a synchronous slug in tight
- * per-file loops, so this uses Node's synchronous `crypto.createHash`. Both
- * produce identical output.
+ * (a dev cartridge) → the literal `DEV_SLUG`; otherwise a path-safe transform
+ * of the URL's authority (host[:port]). Identical output to the async
+ * `slugForRegistryUrl` above — no hashing, so both are trivially in sync.
  *
  * @param {string|null|undefined} registryUrl
  * @returns {string}
  */
 function slugForSync(registryUrl) {
-  if (registryUrl === null || registryUrl === undefined) {
-    return DEV_SLUG;
-  }
-  const crypto = require('crypto');
-  const hex = crypto.createHash('sha256').update(registryUrl, 'utf8').digest('hex');
-  return hex.slice(0, SLUG_HEX_LEN);
+  return slugForRegistryUrlSync(registryUrl);
 }
 
 /**
@@ -5838,14 +5875,21 @@ class DiscoveryIdentity {
    * @param {string|null} opts.registryUrl - Some(url) for release/nightly
    *   hosts, null for dev hosts.
    * @param {number} opts.fabricManifestVersion
+   * @param {number} opts.cartridgeRegistryVersion - The registry regime version
+   *   this host speaks; an on-disk PATH level ({slug}/v{N}/{channel}/…), pinned
+   *   like the channel so a v1 host never scans a v2 tree.
    */
-  constructor({ channel, registryUrl, fabricManifestVersion }) {
+  constructor({ channel, registryUrl, fabricManifestVersion, cartridgeRegistryVersion }) {
     if (channel !== CartridgeChannel.Release && channel !== CartridgeChannel.Nightly) {
       throw new Error(`DiscoveryIdentity: invalid channel '${channel}'`);
     }
+    if (!Number.isInteger(cartridgeRegistryVersion) || cartridgeRegistryVersion < 1) {
+      throw new Error(`DiscoveryIdentity: cartridgeRegistryVersion must be an integer >= 1, got '${cartridgeRegistryVersion}'`);
+    }
     this.channel = channel;
     this.registryUrl = registryUrl !== undefined ? registryUrl : null;
     this.fabricManifestVersion = fabricManifestVersion;
+    this.cartridgeRegistryVersion = cartridgeRegistryVersion;
   }
 
   /** This host's own baked-registry slug (`dev` when registryUrl is null). */
@@ -6175,7 +6219,9 @@ async function discoverCartridges(cartridgesRoot, identity) {
       continue;
     }
     const expectedSlug = slugEntry.name;
-    const scanRoot = path.join(slugDir, identity.channel);
+    // {slug}/v{cartridgeRegistryVersion}/{channel}/… — the registry regime
+    // version is a path level pinned to the host's version (like the channel).
+    const scanRoot = path.join(slugDir, `v${identity.cartridgeRegistryVersion}`, identity.channel);
     let scanStat;
     try { scanStat = fs.statSync(scanRoot); } catch (_e) { continue; }
     if (!scanStat.isDirectory()) continue;
@@ -6388,7 +6434,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 +6552,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 +6753,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 +6806,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 +6864,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 +6946,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 +7041,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 +7097,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 +7217,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 +7338,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,7 +7471,8 @@ class FabricRegistryEntry {
   constructor(data) {
     this.urn = data.urn;
     this.title = data.title || '';
-    this.command = data.command || '';
+    this.aliases = data.aliases || [];
+    this.isAbstract = data.abstract === true;
     this.description = data.cap_description || '';
     this.args = data.args || [];
     this.output = data.output || null;
@@ -7868,8 +7927,30 @@ class Manifest {
   }
 }
 
+// Unified configurable planner vocabulary (mirrors Rust plan_space.rs and the
+// PlanMachines/DiscoverConvergentTargets proto surface).
+const planner = require('./planner.js');
+
 // Export for CommonJS
 module.exports = {
+  // Planner plan-space vocabulary
+  PlanStateError: planner.PlanStateError,
+  ConvergencePresence: planner.ConvergencePresence,
+  ConvergenceLocation: planner.ConvergenceLocation,
+  ConvergenceMechanism: planner.ConvergenceMechanism,
+  ConvergenceArity: planner.ConvergenceArity,
+  DivergencePresence: planner.DivergencePresence,
+  DivergenceLocation: planner.DivergenceLocation,
+  RankPolicy: planner.RankPolicy,
+  PlanMode: planner.PlanMode,
+  PlanRequest: planner.PlanRequest,
+  parsePlanApex: planner.parsePlanApex,
+  parsePlanProfile: planner.parsePlanProfile,
+  parsePlanCost: planner.parsePlanCost,
+  parsePlanCandidate: planner.parsePlanCandidate,
+  parsePlanCandidates: planner.parsePlanCandidates,
+  parseConvergentTarget: planner.parseConvergentTarget,
+  parseConvergentTargets: planner.parseConvergentTargets,
   ALIAS_TARGET_CAP,
   ALIAS_TARGET_MEDIA,
   tokenIsUrn,
@@ -8075,7 +8156,7 @@ module.exports = {
   discoverCartridges,
   // Registry slug
   DEV_SLUG,
-  SLUG_HEX_LEN,
+  slugForRegistryUrlSync,
   slugForRegistryUrl,
   isRegistrySlug,
   // Machine notation