capdag 0.109.248 → 0.124.274

package/capdag.test.js

@@ -8,7 +8,7 @@ const {
   Cap, MediaSpec, MediaSpecError, MediaSpecErrorCodes,
   resolveMediaUrn, buildExtensionIndex, mediaUrnsForExtension, getExtensionMappings,
   CapMatrixError, CapMatrix, BestCapSetMatch, CompositeCapSet, CapBlock,
-  PluginInfo, PluginCapSummary, PluginSuggestion, PluginRepoClient, PluginRepoServer,
+  CartridgeInfo, CartridgeCapSummary, CartridgeSuggestion, CartridgeRepoClient, CartridgeRepoServer,
   CapGraphEdge, CapGraphStats, CapGraph,
   StdinSource, StdinSourceKind,
   validateNoMediaSpecRedefinitionSync,
@@ -1176,7 +1176,7 @@ function test110_multipleExtensions() {
 // TEST117: CapBlock finds more specific cap across registries
 function test117_capBlockMoreSpecificWins() {
   const providerRegistry = new CapMatrix();
-  const pluginRegistry = new CapMatrix();
+  const cartridgeRegistry = new CapMatrix();
 
   const providerHost = new MockCapSet('provider');
   const providerCap = makeCap(
@@ -1185,22 +1185,22 @@ function test117_capBlockMoreSpecificWins() {
   );
   providerRegistry.registerCapSet('provider', providerHost, [providerCap]);
 
-  const pluginHost = new MockCapSet('plugin');
-  const pluginCap = makeCap(
+  const cartridgeHost = new MockCapSet('cartridge');
+  const cartridgeCap = makeCap(
     'cap:ext=pdf;in="media:binary";op=generate_thumbnail;out="media:binary"',
-    'Plugin PDF Thumbnail Generator (specific)'
+    'Cartridge PDF Thumbnail Generator (specific)'
   );
-  pluginRegistry.registerCapSet('plugin', pluginHost, [pluginCap]);
+  cartridgeRegistry.registerCapSet('cartridge', cartridgeHost, [cartridgeCap]);
 
   const composite = new CapBlock();
   composite.addRegistry('providers', providerRegistry);
-  composite.addRegistry('plugins', pluginRegistry);
+  composite.addRegistry('cartridges', cartridgeRegistry);
 
   const request = 'cap:ext=pdf;in="media:binary";op=generate_thumbnail;out="media:binary"';
   const best = composite.findBestCapSet(request);
 
-  assertEqual(best.registryName, 'plugins', 'More specific plugin should win');
-  assertEqual(best.cap.title, 'Plugin PDF Thumbnail Generator (specific)', 'Should get plugin cap');
+  assertEqual(best.registryName, 'cartridges', 'More specific cartridge should win');
+  assertEqual(best.cap.title, 'Cartridge PDF Thumbnail Generator (specific)', 'Should get cartridge cap');
 }
 
 // TEST118: CapBlock tie-breaking prefers first registry in order
@@ -1269,7 +1269,7 @@ function test120_capBlockNoMatch() {
 // TEST121: CapBlock fallback scenario where generic cap handles unknown file types
 function test121_capBlockFallbackScenario() {
   const providerRegistry = new CapMatrix();
-  const pluginRegistry = new CapMatrix();
+  const cartridgeRegistry = new CapMatrix();
 
   const providerHost = new MockCapSet('provider_fallback');
   const providerCap = makeCap(
@@ -1278,20 +1278,20 @@ function test121_capBlockFallbackScenario() {
   );
   providerRegistry.registerCapSet('provider_fallback', providerHost, [providerCap]);
 
-  const pluginHost = new MockCapSet('pdf_plugin');
-  const pluginCap = makeCap(
+  const cartridgeHost = new MockCapSet('pdf_cartridge');
+  const cartridgeCap = makeCap(
     'cap:ext=pdf;in="media:binary";op=generate_thumbnail;out="media:binary"',
-    'PDF Thumbnail Plugin'
+    'PDF Thumbnail Cartridge'
   );
-  pluginRegistry.registerCapSet('pdf_plugin', pluginHost, [pluginCap]);
+  cartridgeRegistry.registerCapSet('pdf_cartridge', cartridgeHost, [cartridgeCap]);
 
   const composite = new CapBlock();
   composite.addRegistry('providers', providerRegistry);
-  composite.addRegistry('plugins', pluginRegistry);
+  composite.addRegistry('cartridges', cartridgeRegistry);
 
-  // PDF request -> plugin wins
+  // PDF request -> cartridge wins
   const best = composite.findBestCapSet('cap:ext=pdf;in="media:binary";op=generate_thumbnail;out="media:binary"');
-  assertEqual(best.registryName, 'plugins', 'Plugin should win for PDF');
+  assertEqual(best.registryName, 'cartridges', 'Cartridge should win for PDF');
 
   // WAV request -> provider wins (fallback)
   const bestWav = composite.findBestCapSet('cap:ext=wav;in="media:binary";op=generate_thumbnail;out="media:binary"');
@@ -1494,19 +1494,19 @@ function test130_capGraphStats() {
 // TEST131: CapGraph with CapBlock builds graph from multiple registries
 function test131_capGraphWithCapBlock() {
   const providerRegistry = new CapMatrix();
-  const pluginRegistry = new CapMatrix();
+  const cartridgeRegistry = new CapMatrix();
   const providerHost = { executeCap: async () => ({ textOutput: 'provider' }) };
-  const pluginHost = { executeCap: async () => ({ textOutput: 'plugin' }) };
+  const cartridgeHost = { executeCap: async () => ({ textOutput: 'cartridge' }) };
 
   const providerCap = makeGraphCap('media:binary', 'media:string', 'Provider Binary to String');
   providerRegistry.registerCapSet('provider', providerHost, [providerCap]);
 
-  const pluginCap = makeGraphCap('media:string', 'media:object', 'Plugin String to Object');
-  pluginRegistry.registerCapSet('plugin', pluginHost, [pluginCap]);
+  const cartridgeCap = makeGraphCap('media:string', 'media:object', 'Cartridge String to Object');
+  cartridgeRegistry.registerCapSet('cartridge', cartridgeHost, [cartridgeCap]);
 
   const cube = new CapBlock();
   cube.addRegistry('providers', providerRegistry);
-  cube.addRegistry('plugins', pluginRegistry);
+  cube.addRegistry('cartridges', cartridgeRegistry);
   const graph = cube.graph();
 
   assert(graph.canConvert('media:binary', 'media:object'), 'Should convert across registries');
@@ -1514,7 +1514,7 @@ function test131_capGraphWithCapBlock() {
   assert(path !== null, 'Should find path');
   assertEqual(path.length, 2, 'Path through 2 registries');
   assertEqual(path[0].registryName, 'providers', 'First edge from providers');
-  assertEqual(path[1].registryName, 'plugins', 'Second edge from plugins');
+  assertEqual(path[1].registryName, 'cartridges', 'Second edge from cartridges');
 }
 
 // TEST132: N/A (already covered by TEST129)
@@ -2008,14 +2008,14 @@ function testJS_mediaSpecConstruction() {
 }
 
 // =============================================================================
-// Plugin Repository Tests (TEST320-TEST335)
+// Cartridge Repository Tests (TEST320-TEST335)
 // =============================================================================
 
 // Sample registry for testing
 const sampleRegistry = {
   schemaVersion: '3.0',
   lastUpdated: '2026-02-07T16:48:28Z',
-  plugins: {
+  cartridges: {
     pdfcartridge: {
       name: 'pdfcartridge',
       description: 'PDF document processor',
@@ -2048,11 +2048,6 @@ const sampleRegistry = {
             name: 'pdfcartridge-0.81.5325.pkg',
             sha256: '9b68724eb9220ecf01e8ed4f5f80c594fbac2239bc5bf675005ec882ecc5eba0',
             size: 5187485
-          },
-          binary: {
-            name: 'pdfcartridge-0.81.5325-darwin-arm64',
-            sha256: '908187ec35632758f1a00452ff4755ba01020ea288619098b6998d5d33851d19',
-            size: 12980288
           }
         }
       }
@@ -2084,11 +2079,6 @@ const sampleRegistry = {
             name: 'txtcartridge-0.54.6408.pkg',
             sha256: 'abc123',
             size: 821000
-          },
-          binary: {
-            name: 'txtcartridge-0.54.6408-darwin-arm64',
-            sha256: 'def456',
-            size: 1700000
           }
         }
       }
@@ -2096,215 +2086,215 @@ const sampleRegistry = {
   }
 };
 
-// TEST320: Plugin info construction
-function test320_pluginInfoConstruction() {
+// TEST320: Cartridge info construction
+function test320_cartridgeInfoConstruction() {
   const data = {
-    id: 'testplugin',
-    name: 'Test Plugin',
+    id: 'testcartridge',
+    name: 'Test Cartridge',
     version: '1.0.0',
     description: 'A test',
     teamId: 'TEAM123',
     signedAt: '2026-01-01',
-    binaryName: 'test-binary',
-    binarySha256: 'abc123',
+    packageName: 'test-1.0.0.pkg',
+    packageSha256: 'abc123',
     caps: [{urn: 'cap:in="media:void";op=test;out="media:void"', title: 'Test', description: ''}]
   };
-  const plugin = new PluginInfo(data);
-  assert(plugin.id === 'testplugin', 'ID should match');
-  assert(plugin.teamId === 'TEAM123', 'Team ID should match');
-  assert(plugin.caps.length === 1, 'Should have 1 cap');
-  assert(plugin.caps[0].urn === 'cap:in="media:void";op=test;out="media:void"', 'Cap URN should match');
+  const cartridge = new CartridgeInfo(data);
+  assert(cartridge.id === 'testcartridge', 'ID should match');
+  assert(cartridge.teamId === 'TEAM123', 'Team ID should match');
+  assert(cartridge.caps.length === 1, 'Should have 1 cap');
+  assert(cartridge.caps[0].urn === 'cap:in="media:void";op=test;out="media:void"', 'Cap URN should match');
 }
 
-// TEST321: Plugin info is signed check
-function test321_pluginInfoIsSigned() {
-  const signed = new PluginInfo({id: 'test', teamId: 'TEAM', signedAt: '2026-01-01', caps: []});
-  assert(signed.isSigned() === true, 'Plugin with teamId and signedAt should be signed');
+// TEST321: Cartridge info is signed check
+function test321_cartridgeInfoIsSigned() {
+  const signed = new CartridgeInfo({id: 'test', teamId: 'TEAM', signedAt: '2026-01-01', caps: []});
+  assert(signed.isSigned() === true, 'Cartridge with teamId and signedAt should be signed');
 
-  const unsigned1 = new PluginInfo({id: 'test', teamId: '', signedAt: '2026-01-01', caps: []});
-  assert(unsigned1.isSigned() === false, 'Plugin without teamId should not be signed');
+  const unsigned1 = new CartridgeInfo({id: 'test', teamId: '', signedAt: '2026-01-01', caps: []});
+  assert(unsigned1.isSigned() === false, 'Cartridge without teamId should not be signed');
 
-  const unsigned2 = new PluginInfo({id: 'test', teamId: 'TEAM', signedAt: '', caps: []});
-  assert(unsigned2.isSigned() === false, 'Plugin without signedAt should not be signed');
+  const unsigned2 = new CartridgeInfo({id: 'test', teamId: 'TEAM', signedAt: '', caps: []});
+  assert(unsigned2.isSigned() === false, 'Cartridge without signedAt should not be signed');
 }
 
-// TEST322: Plugin info has binary check
-function test322_pluginInfoHasBinary() {
-  const withBinary = new PluginInfo({id: 'test', binaryName: 'test-bin', binarySha256: 'abc', caps: []});
-  assert(withBinary.hasBinary() === true, 'Plugin with binary info should return true');
+// TEST322: Cartridge info has package check
+function test322_cartridgeInfoHasPackage() {
+  const withPkg = new CartridgeInfo({id: 'test', packageName: 'test.pkg', packageSha256: 'abc', caps: []});
+  assert(withPkg.hasPackage() === true, 'Cartridge with package info should return true');
 
-  const noBinary1 = new PluginInfo({id: 'test', binaryName: '', binarySha256: 'abc', caps: []});
-  assert(noBinary1.hasBinary() === false, 'Plugin without binaryName should return false');
+  const noPkg1 = new CartridgeInfo({id: 'test', packageName: '', packageSha256: 'abc', caps: []});
+  assert(noPkg1.hasPackage() === false, 'Cartridge without packageName should return false');
 
-  const noBinary2 = new PluginInfo({id: 'test', binaryName: 'test', binarySha256: '', caps: []});
-  assert(noBinary2.hasBinary() === false, 'Plugin without binarySha256 should return false');
+  const noPkg2 = new CartridgeInfo({id: 'test', packageName: 'test.pkg', packageSha256: '', caps: []});
+  assert(noPkg2.hasPackage() === false, 'Cartridge without packageSha256 should return false');
 }
 
-// TEST323: PluginRepoServer validate registry
-function test323_pluginRepoServerValidateRegistry() {
+// TEST323: CartridgeRepoServer validate registry
+function test323_cartridgeRepoServerValidateRegistry() {
   // Valid registry
-  const server = new PluginRepoServer(sampleRegistry);
+  const server = new CartridgeRepoServer(sampleRegistry);
   assert(server.registry.schemaVersion === '3.0', 'Should accept valid registry');
 
   // Invalid schema version
   let threw = false;
   try {
-    new PluginRepoServer({schemaVersion: '2.0', plugins: {}});
+    new CartridgeRepoServer({schemaVersion: '2.0', cartridges: {}});
   } catch (e) {
     threw = true;
     assert(e.message.includes('schema version'), 'Should reject wrong schema version');
   }
   assert(threw, 'Should throw for invalid schema');
 
-  // Missing plugins
+  // Missing cartridges
   threw = false;
   try {
-    new PluginRepoServer({schemaVersion: '3.0'});
+    new CartridgeRepoServer({schemaVersion: '3.0'});
   } catch (e) {
     threw = true;
-    assert(e.message.includes('plugins'), 'Should reject missing plugins');
+    assert(e.message.includes('cartridges'), 'Should reject missing cartridges');
   }
-  assert(threw, 'Should throw for missing plugins');
+  assert(threw, 'Should throw for missing cartridges');
 }
 
-// TEST324: PluginRepoServer transform to array
-function test324_pluginRepoServerTransformToArray() {
-  const server = new PluginRepoServer(sampleRegistry);
-  const plugins = server.transformToPluginArray();
+// TEST324: CartridgeRepoServer transform to array
+function test324_cartridgeRepoServerTransformToArray() {
+  const server = new CartridgeRepoServer(sampleRegistry);
+  const cartridges = server.transformToCartridgeArray();
 
-  assert(Array.isArray(plugins), 'Should return array');
-  assert(plugins.length === 2, 'Should have 2 plugins');
-  
-  const pdf = plugins.find(p => p.id === 'pdfcartridge');
+  assert(Array.isArray(cartridges), 'Should return array');
+  assert(cartridges.length === 2, 'Should have 2 cartridges');
+
+  const pdf = cartridges.find(p => p.id === 'pdfcartridge');
   assert(pdf !== undefined, 'Should include pdfcartridge');
   assert(pdf.version === '0.81.5325', 'Should have latest version');
   assert(pdf.teamId === 'P336JK947M', 'Should have teamId');
   assert(pdf.signedAt === '2026-02-07T16:40:28Z', 'Should have signedAt from releaseDate');
-  assert(pdf.binaryName === 'pdfcartridge-0.81.5325-darwin-arm64', 'Should have binary name');
-  assert(pdf.binarySha256 === '908187ec35632758f1a00452ff4755ba01020ea288619098b6998d5d33851d19', 'Should have SHA256');
+  assert(pdf.packageName === 'pdfcartridge-0.81.5325.pkg', 'Should have package name');
+  assert(pdf.packageSha256 === '9b68724eb9220ecf01e8ed4f5f80c594fbac2239bc5bf675005ec882ecc5eba0', 'Should have package SHA256');
   assert(Array.isArray(pdf.caps), 'Should have caps array');
   assert(pdf.caps.length === 2, 'Should have 2 caps');
 }
 
-// TEST325: PluginRepoServer get plugins
-function test325_pluginRepoServerGetPlugins() {
-  const server = new PluginRepoServer(sampleRegistry);
-  const response = server.getPlugins();
+// TEST325: CartridgeRepoServer get cartridges
+function test325_cartridgeRepoServerGetCartridges() {
+  const server = new CartridgeRepoServer(sampleRegistry);
+  const response = server.getCartridges();
 
-  assert(response.plugins !== undefined, 'Should have plugins field');
-  assert(Array.isArray(response.plugins), 'Plugins should be array');
-  assert(response.plugins.length === 2, 'Should have 2 plugins');
+  assert(response.cartridges !== undefined, 'Should have cartridges field');
+  assert(Array.isArray(response.cartridges), 'Cartridges should be array');
+  assert(response.cartridges.length === 2, 'Should have 2 cartridges');
 }
 
-// TEST326: PluginRepoServer get plugin by ID
-function test326_pluginRepoServerGetPluginById() {
-  const server = new PluginRepoServer(sampleRegistry);
+// TEST326: CartridgeRepoServer get cartridge by ID
+function test326_cartridgeRepoServerGetCartridgeById() {
+  const server = new CartridgeRepoServer(sampleRegistry);
 
-  const pdf = server.getPluginById('pdfcartridge');
+  const pdf = server.getCartridgeById('pdfcartridge');
   assert(pdf !== undefined, 'Should find pdfcartridge');
   assert(pdf.id === 'pdfcartridge', 'Should have correct ID');
 
-  const notFound = server.getPluginById('nonexistent');
-  assert(notFound === undefined, 'Should return undefined for missing plugin');
+  const notFound = server.getCartridgeById('nonexistent');
+  assert(notFound === undefined, 'Should return undefined for missing cartridge');
 }
 
-// TEST327: PluginRepoServer search plugins
-function test327_pluginRepoServerSearchPlugins() {
-  const server = new PluginRepoServer(sampleRegistry);
+// TEST327: CartridgeRepoServer search cartridges
+function test327_cartridgeRepoServerSearchCartridges() {
+  const server = new CartridgeRepoServer(sampleRegistry);
 
-  const pdfResults = server.searchPlugins('pdf');
-  assert(pdfResults.length === 1, 'Should find 1 PDF plugin');
+  const pdfResults = server.searchCartridges('pdf');
+  assert(pdfResults.length === 1, 'Should find 1 PDF cartridge');
   assert(pdfResults[0].id === 'pdfcartridge', 'Should find pdfcartridge');
 
-  const metadataResults = server.searchPlugins('metadata');
-  assert(metadataResults.length === 1, 'Should find plugin by cap title');
+  const metadataResults = server.searchCartridges('metadata');
+  assert(metadataResults.length === 1, 'Should find cartridge by cap title');
 
-  const noResults = server.searchPlugins('nonexistent');
+  const noResults = server.searchCartridges('nonexistent');
   assert(noResults.length === 0, 'Should return empty for no matches');
 }
 
-// TEST328: PluginRepoServer get by category
-function test328_pluginRepoServerGetByCategory() {
-  const server = new PluginRepoServer(sampleRegistry);
+// TEST328: CartridgeRepoServer get by category
+function test328_cartridgeRepoServerGetByCategory() {
+  const server = new CartridgeRepoServer(sampleRegistry);
 
-  const docPlugins = server.getPluginsByCategory('document');
-  assert(docPlugins.length === 1, 'Should find 1 document plugin');
-  assert(docPlugins[0].id === 'pdfcartridge', 'Should be pdfcartridge');
+  const docCartridges = server.getCartridgesByCategory('document');
+  assert(docCartridges.length === 1, 'Should find 1 document cartridge');
+  assert(docCartridges[0].id === 'pdfcartridge', 'Should be pdfcartridge');
 
-  const textPlugins = server.getPluginsByCategory('text');
-  assert(textPlugins.length === 1, 'Should find 1 text plugin');
-  assert(textPlugins[0].id === 'txtcartridge', 'Should be txtcartridge');
+  const textCartridges = server.getCartridgesByCategory('text');
+  assert(textCartridges.length === 1, 'Should find 1 text cartridge');
+  assert(textCartridges[0].id === 'txtcartridge', 'Should be txtcartridge');
 }
 
-// TEST329: PluginRepoServer get by cap
-function test329_pluginRepoServerGetByCap() {
-  const server = new PluginRepoServer(sampleRegistry);
+// TEST329: CartridgeRepoServer get by cap
+function test329_cartridgeRepoServerGetByCap() {
+  const server = new CartridgeRepoServer(sampleRegistry);
 
   const disbindCap = 'cap:in="media:pdf";op=disbind;out="media:disbound-page;textable;list"';
-  const plugins = server.getPluginsByCap(disbindCap);
+  const cartridges = server.getCartridgesByCap(disbindCap);
 
-  assert(plugins.length === 1, 'Should find 1 plugin with this cap');
-  assert(plugins[0].id === 'pdfcartridge', 'Should be pdfcartridge');
+  assert(cartridges.length === 1, 'Should find 1 cartridge with this cap');
+  assert(cartridges[0].id === 'pdfcartridge', 'Should be pdfcartridge');
 
   const metadataCap = 'cap:in="media:pdf";op=extract_metadata;out="media:file-metadata;textable;record"';
-  const metadataPlugins = server.getPluginsByCap(metadataCap);
-  assert(metadataPlugins.length === 1, 'Should find metadata cap');
+  const metadataCartridges = server.getCartridgesByCap(metadataCap);
+  assert(metadataCartridges.length === 1, 'Should find metadata cap');
 }
 
-// TEST330: PluginRepoClient update cache
-function test330_pluginRepoClientUpdateCache() {
-  const client = new PluginRepoClient(3600);
-  const server = new PluginRepoServer(sampleRegistry);
-  const plugins = server.transformToPluginArray().map(p => new PluginInfo(p));
+// TEST330: CartridgeRepoClient update cache
+function test330_cartridgeRepoClientUpdateCache() {
+  const client = new CartridgeRepoClient(3600);
+  const server = new CartridgeRepoServer(sampleRegistry);
+  const cartridges = server.transformToCartridgeArray().map(p => new CartridgeInfo(p));
 
-  client.updateCache('https://example.com/api/plugins', plugins);
+  client.updateCache('https://example.com/api/cartridges', cartridges);
 
-  const cache = client.caches.get('https://example.com/api/plugins');
+  const cache = client.caches.get('https://example.com/api/cartridges');
   assert(cache !== undefined, 'Cache should exist');
-  assert(cache.plugins.size === 2, 'Should have 2 plugins in cache');
-  assert(cache.capToPlugins.size > 0, 'Should have cap mappings');
+  assert(cache.cartridges.size === 2, 'Should have 2 cartridges in cache');
+  assert(cache.capToCartridges.size > 0, 'Should have cap mappings');
 }
 
-// TEST331: PluginRepoClient get suggestions
-function test331_pluginRepoClientGetSuggestions() {
-  const client = new PluginRepoClient(3600);
-  const server = new PluginRepoServer(sampleRegistry);
-  const plugins = server.transformToPluginArray().map(p => new PluginInfo(p));
+// TEST331: CartridgeRepoClient get suggestions
+function test331_cartridgeRepoClientGetSuggestions() {
+  const client = new CartridgeRepoClient(3600);
+  const server = new CartridgeRepoServer(sampleRegistry);
+  const cartridges = server.transformToCartridgeArray().map(p => new CartridgeInfo(p));
 
-  client.updateCache('https://example.com/api/plugins', plugins);
+  client.updateCache('https://example.com/api/cartridges', cartridges);
 
   const disbindCap = 'cap:in="media:pdf";op=disbind;out="media:disbound-page;textable;list"';
   const suggestions = client.getSuggestionsForCap(disbindCap);
 
   assert(suggestions.length === 1, 'Should find 1 suggestion');
-  assert(suggestions[0].pluginId === 'pdfcartridge', 'Should suggest pdfcartridge');
+  assert(suggestions[0].cartridgeId === 'pdfcartridge', 'Should suggest pdfcartridge');
   assert(suggestions[0].capUrn === disbindCap, 'Should have correct cap URN');
   assert(suggestions[0].capTitle === 'Disbind PDF', 'Should have cap title');
 }
 
-// TEST332: PluginRepoClient get plugin
-function test332_pluginRepoClientGetPlugin() {
-  const client = new PluginRepoClient(3600);
-  const server = new PluginRepoServer(sampleRegistry);
-  const plugins = server.transformToPluginArray().map(p => new PluginInfo(p));
+// TEST332: CartridgeRepoClient get cartridge
+function test332_cartridgeRepoClientGetCartridge() {
+  const client = new CartridgeRepoClient(3600);
+  const server = new CartridgeRepoServer(sampleRegistry);
+  const cartridges = server.transformToCartridgeArray().map(p => new CartridgeInfo(p));
 
-  client.updateCache('https://example.com/api/plugins', plugins);
+  client.updateCache('https://example.com/api/cartridges', cartridges);
 
-  const plugin = client.getPlugin('pdfcartridge');
-  assert(plugin !== null, 'Should find plugin');
-  assert(plugin.id === 'pdfcartridge', 'Should have correct ID');
+  const cartridge = client.getCartridge('pdfcartridge');
+  assert(cartridge !== null, 'Should find cartridge');
+  assert(cartridge.id === 'pdfcartridge', 'Should have correct ID');
 
-  const notFound = client.getPlugin('nonexistent');
-  assert(notFound === null, 'Should return null for missing plugin');
+  const notFound = client.getCartridge('nonexistent');
+  assert(notFound === null, 'Should return null for missing cartridge');
 }
 
-// TEST333: PluginRepoClient get all caps
-function test333_pluginRepoClientGetAllCaps() {
-  const client = new PluginRepoClient(3600);
-  const server = new PluginRepoServer(sampleRegistry);
-  const plugins = server.transformToPluginArray().map(p => new PluginInfo(p));
+// TEST333: CartridgeRepoClient get all caps
+function test333_cartridgeRepoClientGetAllCaps() {
+  const client = new CartridgeRepoClient(3600);
+  const server = new CartridgeRepoServer(sampleRegistry);
+  const cartridges = server.transformToCartridgeArray().map(p => new CartridgeInfo(p));
 
-  client.updateCache('https://example.com/api/plugins', plugins);
+  client.updateCache('https://example.com/api/cartridges', cartridges);
 
   const caps = client.getAllAvailableCaps();
   assert(Array.isArray(caps), 'Should return array');
@@ -2312,19 +2302,19 @@ function test333_pluginRepoClientGetAllCaps() {
   assert(caps.every(c => typeof c === 'string'), 'All caps should be strings');
 }
 
-// TEST334: PluginRepoClient needs sync
-function test334_pluginRepoClientNeedsSync() {
-  const client = new PluginRepoClient(1); // 1 second TTL
-  const server = new PluginRepoServer(sampleRegistry);
-  const plugins = server.transformToPluginArray().map(p => new PluginInfo(p));
+// TEST334: CartridgeRepoClient needs sync
+function test334_cartridgeRepoClientNeedsSync() {
+  const client = new CartridgeRepoClient(1); // 1 second TTL
+  const server = new CartridgeRepoServer(sampleRegistry);
+  const cartridges = server.transformToCartridgeArray().map(p => new CartridgeInfo(p));
 
-  const urls = ['https://example.com/api/plugins'];
+  const urls = ['https://example.com/api/cartridges'];
 
   // Should need sync initially
   assert(client.needsSync(urls) === true, 'Should need sync with empty cache');
 
   // Update cache
-  client.updateCache(urls[0], plugins);
+  client.updateCache(urls[0], cartridges);
 
   // Should not need sync immediately
   assert(client.needsSync(urls) === false, 'Should not need sync right after update');
@@ -2333,33 +2323,33 @@ function test334_pluginRepoClientNeedsSync() {
   // Note: Can't test this synchronously, would need async test
 }
 
-// TEST335: PluginRepoServer and Client integration
-function test335_pluginRepoServerClientIntegration() {
+// TEST335: CartridgeRepoServer and Client integration
+function test335_cartridgeRepoServerClientIntegration() {
   // Server creates API response
-  const server = new PluginRepoServer(sampleRegistry);
-  const apiResponse = server.getPlugins();
+  const server = new CartridgeRepoServer(sampleRegistry);
+  const apiResponse = server.getCartridges();
 
   // Client consumes API response
-  const client = new PluginRepoClient(3600);
-  const plugins = apiResponse.plugins.map(p => new PluginInfo(p));
-  client.updateCache('https://example.com/api/plugins', plugins);
+  const client = new CartridgeRepoClient(3600);
+  const cartridges = apiResponse.cartridges.map(p => new CartridgeInfo(p));
+  client.updateCache('https://example.com/api/cartridges', cartridges);
 
-  // Client can find plugin
-  const plugin = client.getPlugin('pdfcartridge');
-  assert(plugin !== null, 'Client should find plugin from server data');
-  assert(plugin.isSigned(), 'Plugin should be signed');
-  assert(plugin.hasBinary(), 'Plugin should have binary');
+  // Client can find cartridge
+  const cartridge = client.getCartridge('pdfcartridge');
+  assert(cartridge !== null, 'Client should find cartridge from server data');
+  assert(cartridge.isSigned(), 'Cartridge should be signed');
+  assert(cartridge.hasPackage(), 'Cartridge should have package');
 
   // Client can get suggestions
   const capUrn = 'cap:in="media:pdf";op=disbind;out="media:disbound-page;textable;list"';
   const suggestions = client.getSuggestionsForCap(capUrn);
   assert(suggestions.length === 1, 'Should get suggestions');
-  assert(suggestions[0].pluginId === 'pdfcartridge', 'Should suggest correct plugin');
+  assert(suggestions[0].cartridgeId === 'pdfcartridge', 'Should suggest correct cartridge');
 
   // Server can search
-  const searchResults = server.searchPlugins('pdf');
+  const searchResults = server.searchCartridges('pdf');
   assert(searchResults.length === 1, 'Server search should work');
-  assert(searchResults[0].id === plugin.id, 'Search and client should agree');
+  assert(searchResults[0].id === cartridge.id, 'Search and client should agree');
 }
 
 // ============================================================================
@@ -3755,12 +3745,15 @@ const {
   canonicalMediaUrn: rendererCanonicalMediaUrn,
   mediaNodeLabel: rendererMediaNodeLabel,
   buildStrandGraphData: rendererBuildStrandGraphData,
+  collapseStrandShapeTransitions: rendererCollapseStrandShapeTransitions,
   buildRunGraphData: rendererBuildRunGraphData,
-  buildMachineGraphData: rendererBuildMachineGraphData,
+  buildEditorGraphData: rendererBuildEditorGraphData,
+  buildResolvedMachineGraphData: rendererBuildResolvedMachineGraphData,
   classifyStrandCapSteps: rendererClassifyStrandCapSteps,
   validateStrandPayload: rendererValidateStrandPayload,
   validateRunPayload: rendererValidateRunPayload,
-  validateMachinePayload: rendererValidateMachinePayload,
+  validateEditorGraphPayload: rendererValidateEditorGraphPayload,
+  validateResolvedMachinePayload: rendererValidateResolvedMachinePayload,
   validateStrandStep: rendererValidateStrandStep,
   validateBodyOutcome: rendererValidateBodyOutcome,
 } = require('./cap-graph-renderer.js');
@@ -4204,6 +4197,260 @@ function testRenderer_buildStrandGraphData_nestedForEachThrows() {
   assert(threw, 'nested ForEach without outer body cap must throw');
 }
 
+function testRenderer_collapseStrand_singleCapBodyKeepsCapOwnLabel() {
+  // User spec: ForEach/Collect are NOT rendered as nodes, and
+  // the collapse does NOT relabel cap edges. Each cap edge
+  // carries whatever label the strand builder emitted — the
+  // cap's own cardinality marker (from its input/output sequence
+  // flags) is the only source of truth.
+  //
+  // Strand [ForEach, Cap(extract, in=1, out=1), Collect],
+  // source=pdf;list, target=txt;list. The extract cap itself is
+  // 1→1, so its edge label has NO cardinality marker.
+  //
+  // Expected render shape: 3 nodes (input_slot, step_1, output),
+  // with the entry edge labeled "extract" and an unlabeled
+  // connector bridge to the output.
+  const payload = {
+    source_spec: 'media:pdf;list',
+    target_spec: 'media:txt;list',
+    steps: [
+      makeForEachStep('media:pdf;list'),
+      makeCapStep('cap:in="media:pdf";op=extract;out="media:txt"', 'extract', 'media:pdf', 'media:txt', false, false),
+      makeCollectStep('media:txt'),
+    ],
+  };
+  const built = rendererBuildStrandGraphData(payload);
+  const collapsed = rendererCollapseStrandShapeTransitions(built);
+
+  const nodeIds = collapsed.nodes.map(n => n.id).sort();
+  assertEqual(JSON.stringify(nodeIds),
+    JSON.stringify(['input_slot', 'output', 'step_1']),
+    'collapse removes the ForEach and Collect nodes; the remaining nodes are source + cap + target');
+
+  // Exactly one edge input_slot → step_1 carrying just the cap
+  // title — no (1→n) or (n→n) marker because the cap's own
+  // cardinality is 1→1.
+  const entryEdges = collapsed.edges.filter(e => e.source === 'input_slot' && e.target === 'step_1');
+  assertEqual(entryEdges.length, 1,
+    'phantom duplicate cap edge must be gone — exactly one edge from source to cap');
+  assertEqual(entryEdges[0].label, 'extract',
+    'entry edge carries just the cap title (cap is 1→1, no marker)');
+
+  // The collect bridge is an unlabeled connector.
+  const exitEdges = collapsed.edges.filter(e => e.source === 'step_1' && e.target === 'output');
+  assertEqual(exitEdges.length, 1,
+    'there is exactly one exit edge step_1 → output');
+  assertEqual(exitEdges[0].label, '',
+    'collect bridge is unlabeled');
+}
+
+function testRenderer_collapseStrand_unclosedForEachBodyCollapses() {
+  // [Cap_a(1→1), ForEach, Cap_b(1→1)] with no Collect,
+  // source=media:a, target=media:c. Cap_b's to_spec is media:c
+  // which is equivalent to target_spec, so the output node is
+  // merged into step_2.
+  //
+  // Since both caps are 1→1, neither carries a cardinality
+  // marker in the render. The foreach step is just dropped;
+  // no relabeling.
+  //
+  // Final: 3 nodes (input_slot, step_0, step_2), 2 edges.
+  const payload = {
+    source_spec: 'media:a',
+    target_spec: 'media:c',
+    steps: [
+      makeCapStep('cap:in="media:a";op=a;out="media:b"', 'a', 'media:a', 'media:b', false, false),
+      makeForEachStep('media:b'),
+      makeCapStep('cap:in="media:b";op=b;out="media:c"', 'b', 'media:b', 'media:c', false, false),
+    ],
+  };
+  const built = rendererBuildStrandGraphData(payload);
+  const collapsed = rendererCollapseStrandShapeTransitions(built);
+
+  const nodeIds = collapsed.nodes.map(n => n.id).sort();
+  assertEqual(JSON.stringify(nodeIds),
+    JSON.stringify(['input_slot', 'step_0', 'step_2']),
+    'foreach node removed and output merged into step_2 (same URN as target)');
+
+  // Exactly one edge from step_0 to step_2, labeled with just
+  // cap_b's title — no foreach marker because cap_b is 1→1 and
+  // the collapse doesn't relabel cap edges.
+  const step0ToStep2 = collapsed.edges.filter(e => e.source === 'step_0' && e.target === 'step_2');
+  assertEqual(step0ToStep2.length, 1,
+    'exactly one step_0 → step_2 edge after dropping the foreach iteration');
+  assertEqual(step0ToStep2[0].label, 'b',
+    'cap_b edge carries just its title (1→1 cap, no marker)');
+
+  // Cap_a's edge is unchanged.
+  const capA = collapsed.edges.find(e => e.source === 'input_slot' && e.target === 'step_0');
+  assert(capA !== undefined, 'cap_a edge input_slot → step_0 exists');
+  assertEqual(capA.label, 'a', 'cap_a edge carries just its title');
+
+  // After merging, step_2 becomes the render target — no separate
+  // output node exists.
+  const outputNode = collapsed.nodes.find(n => n.id === 'output');
+  assertEqual(outputNode, undefined,
+    'output node was merged into step_2 because their URNs are semantically equivalent');
+  const mergedTarget = collapsed.nodes.find(n => n.id === 'step_2');
+  assertEqual(mergedTarget.nodeClass, 'strand-target',
+    'merged step_2 takes on the strand-target role');
+}
+
+function testRenderer_collapseStrand_standaloneCollectCollapses() {
+  // [Cap, Collect] with no enclosing ForEach, source=media:a,
+  // target=media:b;list (NOT equivalent to cap's to_spec media:b,
+  // so the output node is retained after collapse).
+  //
+  // Collapse:
+  //   - step_1 (standalone Collect) removed.
+  //   - Synthesized bridging edge step_0 → output labeled "collect".
+  //   - The cap edge input_slot → step_0 is unchanged because the
+  //     cap is not inside any foreach body.
+  //
+  // Final: 3 nodes (input_slot, step_0, output), 2 edges.
+  const payload = {
+    source_spec: 'media:a',
+    target_spec: 'media:b;list',
+    steps: [
+      makeCapStep('cap:in="media:a";op=x;out="media:b"', 'x', 'media:a', 'media:b', false, false),
+      makeCollectStep('media:b'),
+    ],
+  };
+  const built = rendererBuildStrandGraphData(payload);
+  const collapsed = rendererCollapseStrandShapeTransitions(built);
+
+  const nodeIds = collapsed.nodes.map(n => n.id).sort();
+  assertEqual(JSON.stringify(nodeIds),
+    JSON.stringify(['input_slot', 'output', 'step_0']),
+    'collect node removed; only cap + source + target remain');
+
+  const capEdge = collapsed.edges.find(e => e.source === 'input_slot' && e.target === 'step_0');
+  assert(capEdge !== undefined, 'cap edge survives');
+  assertEqual(capEdge.label, 'x',
+    'cap edge carries just its title — no foreach cardinality markers because the cap is not inside a foreach body');
+
+  const collectEdge = collapsed.edges.find(e => e.source === 'step_0' && e.target === 'output');
+  assert(collectEdge !== undefined, 'step_0 → output edge synthesized by collect collapse');
+  assertEqual(collectEdge.label, '',
+    'the synthesized bridging edge for a standalone Collect is an unlabeled connector (cap labels carry all cardinality info)');
+}
+
+function testRenderer_collapseStrand_sequenceProducingCapBeforeForeach() {
+  // Regression test mirroring the user's real strand:
+  // [Cap_disbind (output_is_sequence=true), ForEach, Cap_make_decision],
+  // source = media:pdf, target = media:decision (equivalent to
+  // the last cap's to_spec).
+  //
+  // Expected render shape after collapse:
+  //   input_slot → step_0 labeled "Disbind PDF Into Pages (1→n)"
+  //       — from Disbind's own output_is_sequence flag, computed
+  //       at build time by the strand builder.
+  //   step_0 → step_2 labeled "Make a Decision" — no marker
+  //       because make_decision is 1→1. The collapse does NOT
+  //       add a (1→n) marker on this edge — the (1→n) belongs
+  //       to the cap that actually produces the sequence
+  //       (Disbind), NOT the cap that consumes one item from it.
+  //   No separate output node because step_2's to_spec equals the
+  //       strand target.
+  const payload = {
+    source_spec: 'media:pdf',
+    target_spec: 'media:decision',
+    steps: [
+      makeCapStep('cap:in="media:pdf";op=disbind;out="media:page"', 'Disbind', 'media:pdf', 'media:page', false, true),
+      makeForEachStep('media:page'),
+      makeCapStep('cap:in="media:page";op=decide;out="media:decision"', 'Make a Decision', 'media:page', 'media:decision', false, false),
+    ],
+  };
+  const built = rendererBuildStrandGraphData(payload);
+  const collapsed = rendererCollapseStrandShapeTransitions(built);
+
+  const nodeIds = collapsed.nodes.map(n => n.id).sort();
+  assertEqual(JSON.stringify(nodeIds),
+    JSON.stringify(['input_slot', 'step_0', 'step_2']),
+    'foreach node and duplicate output node both removed');
+
+  // Disbind cap edge carries its own (1→n) marker from
+  // output_is_sequence=true, NOT from the foreach flag.
+  const disbind = collapsed.edges.find(e => e.source === 'input_slot' && e.target === 'step_0');
+  assert(disbind !== undefined, 'Disbind edge input_slot → step_0 exists');
+  assertEqual(disbind.label, 'Disbind (1\u2192n)',
+    'Disbind edge reflects its own output_is_sequence=true cardinality');
+
+  // make_decision cap edge — the plan-builder phantom direct
+  // edge becomes the render-visible cap edge, carrying just the
+  // cap title. No (1→n) marker: make_decision is 1→1, and the
+  // collapse does NOT add cardinality markers based on foreach
+  // context. The fan-out semantics come from Disbind's own
+  // output_is_sequence flag, which is already visible on the
+  // Disbind edge.
+  const makeDecision = collapsed.edges.filter(e => e.source === 'step_0' && e.target === 'step_2');
+  assertEqual(makeDecision.length, 1,
+    'exactly one edge from Text Page to Decision (phantom not duplicated)');
+  assertEqual(makeDecision[0].label, 'Make a Decision',
+    'the make_decision edge carries just its title — 1→1 cap, no marker');
+
+  // Duplicate target must be gone.
+  const outputNode = collapsed.nodes.find(n => n.id === 'output');
+  assertEqual(outputNode, undefined,
+    'output node merged into step_2 because they represent the same URN');
+}
+
+function testRenderer_collapseStrand_plainCapMergesTrailingOutput() {
+  // A strand with a single plain 1→1 cap whose to_spec equals
+  // target_spec. The plan-builder topology produces:
+  //   input_slot → step_0 (cap) → output
+  // The collapse pass merges the trailing output edge because
+  // step_0 and output represent the same URN (media:b).
+  //
+  // Final: 2 nodes (input_slot, step_0), 1 edge.
+  const payload = {
+    source_spec: 'media:a',
+    target_spec: 'media:b',
+    steps: [
+      makeCapStep('cap:in="media:a";op=x;out="media:b"', 'x', 'media:a', 'media:b', false, false),
+    ],
+  };
+  const built = rendererBuildStrandGraphData(payload);
+  const collapsed = rendererCollapseStrandShapeTransitions(built);
+
+  assertEqual(collapsed.nodes.length, 2,
+    'duplicate output node merged into step_0 — 2 nodes remain');
+  const outputNode = collapsed.nodes.find(n => n.id === 'output');
+  assertEqual(outputNode, undefined,
+    'output node dropped by merge');
+  const mergedTarget = collapsed.nodes.find(n => n.id === 'step_0');
+  assertEqual(mergedTarget.nodeClass, 'strand-target',
+    'step_0 takes on the strand-target role after the merge');
+
+  assertEqual(collapsed.edges.length, 1, 'single cap edge remains');
+  assertEqual(collapsed.edges[0].source, 'input_slot');
+  assertEqual(collapsed.edges[0].target, 'step_0');
+  assertEqual(collapsed.edges[0].label, 'x', 'cap title preserved as edge label');
+}
+
+function testRenderer_collapseStrand_plainCapDistinctTargetNoMerge() {
+  // A strand with a single plain cap whose to_spec is NOT
+  // equivalent to target_spec. The output node must be retained
+  // and the trailing connector edge preserved.
+  const payload = {
+    source_spec: 'media:a',
+    target_spec: 'media:b;list',
+    steps: [
+      makeCapStep('cap:in="media:a";op=x;out="media:b"', 'x', 'media:a', 'media:b', false, false),
+    ],
+  };
+  const built = rendererBuildStrandGraphData(payload);
+  const collapsed = rendererCollapseStrandShapeTransitions(built);
+
+  assertEqual(collapsed.nodes.length, 3,
+    'no merge because cap to_spec (media:b) and target (media:b;list) are semantically distinct');
+  assert(collapsed.nodes.find(n => n.id === 'output') !== undefined,
+    'output node retained');
+  assert(collapsed.nodes.find(n => n.id === 'step_0') !== undefined,
+    'step_0 retained');
+}
+
 function testRenderer_validateStrandPayload_missingSourceSpec() {
   let threw = false;
   try {
@@ -4228,12 +4475,16 @@ function testRenderer_validateBodyOutcome_rejectsNegativeIndex() {
 }
 
 function testRenderer_buildRunGraphData_pagesSuccessesAndFailures() {
-  // 6 successes, 4 failures. visible_success_count=3, visible_failure_count=2,
-  // total_body_count=10. The builder must:
-  //  - render exactly 3 success replicas (one node per cap step per body)
-  //  - render exactly 2 failure replicas
-  //  - emit a success show-more node with hidden count 3
-  //  - emit a failure show-more node with hidden count 2
+  // 6 successes, 4 failures. visible=3+2, total=10. Body has 2
+  // caps (a, b). Each body replica is a chain of:
+  //   entry node + body_step_0 (cap a) + body_step_1 (cap b)
+  // = 3 nodes per body. Failed bodies truncate at failed_cap
+  // (cap b, idx=1) so `traceEnd=2` — same 3-node chain.
+  //
+  // Total replica nodes: (3 success × 3) + (2 failure × 3) = 15.
+  //
+  // Show-more nodes: one for 3 hidden successes, one for 2 hidden
+  // failures.
   const strand = {
     source_spec: 'media:pdf;list',
     target_spec: 'media:txt',
@@ -4269,17 +4520,14 @@ function testRenderer_buildRunGraphData_pagesSuccessesAndFailures() {
   };
   const built = rendererBuildRunGraphData(payload);
 
-  // Count replica nodes by classes.
   let successNodes = 0;
   let failureNodes = 0;
   for (const n of built.replicaNodes) {
     if (n.classes === 'body-success') successNodes++;
     if (n.classes === 'body-failure') failureNodes++;
   }
-  assertEqual(successNodes, 3 * 2, 'three successful bodies × two cap steps each = 6 success nodes');
-  // Failed bodies truncate at failed_cap (cap b = second cap), so trace
-  // length includes both cap a and cap b → 2 nodes per failed body.
-  assertEqual(failureNodes, 2 * 2, 'two failed bodies × two nodes each (trace truncated at failed_cap)');
+  assertEqual(successNodes, 3 * 3, '3 success bodies × (1 entry + 2 body caps) = 9 success replica nodes');
+  assertEqual(failureNodes, 2 * 3, '2 failure bodies × (1 entry + 2 body caps) = 6 failure replica nodes');
 
   // Show-more nodes: one for success (hidden 3), one for failure (hidden 2).
   const successShowMore = built.showMoreNodes.find(n => n.data.showMoreGroup === 'success');
@@ -4291,9 +4539,12 @@ function testRenderer_buildRunGraphData_pagesSuccessesAndFailures() {
 }
 
 function testRenderer_buildRunGraphData_failureWithoutFailedCapRendersFullTrace() {
-  // A failure without failed_cap (e.g. infrastructure failure) must still
-  // render the full body trace — the builder must not crash or produce
-  // zero replicas.
+  // A failure without failed_cap (infrastructure failure) must
+  // still render the full body trace — the builder must not
+  // crash or produce zero replicas.
+  //
+  // Strand [ForEach, Cap, Collect] → body has 1 cap. Each body
+  // replica emits 1 entry node + 1 body cap node = 2 nodes.
   const strand = {
     source_spec: 'media:pdf;list',
     target_spec: 'media:txt',
@@ -4317,7 +4568,7 @@ function testRenderer_buildRunGraphData_failureWithoutFailedCapRendersFullTrace(
   for (const n of built.replicaNodes) {
     if (n.classes === 'body-failure') failureNodes++;
   }
-  assertEqual(failureNodes, 1, 'full trace (one cap) renders as one failure node');
+  assertEqual(failureNodes, 2, 'entry + body cap = 2 failure replica nodes');
 }
 
 function testRenderer_buildRunGraphData_usesCapUrnIsEquivalentForFailedCap() {
@@ -4368,16 +4619,229 @@ function testRenderer_buildRunGraphData_usesCapUrnIsEquivalentForFailedCap() {
   for (const n of built.replicaNodes) {
     if (n.classes === 'body-failure') failureNodes++;
   }
-  // cap x + cap y = 2 nodes for a body trace that terminates at cap y.
-  assertEqual(failureNodes, 2, 'trace truncates at cap y via isEquivalent, yielding 2 failure nodes');
+  // 1 entry + 2 body step nodes (cap x and cap y, truncated
+  // at cap y) = 3 failure replica nodes.
+  assertEqual(failureNodes, 3, 'trace truncates at cap y via isEquivalent, yielding entry + 2 cap nodes');
+}
+
+function testRenderer_buildRunGraphData_backboneHasNoForeachNode() {
+  // Regression test for the run-mode rendering fix: the backbone
+  // delivered to cytoscape must NOT contain any strand-foreach or
+  // strand-collect nodes. Run mode inherits the same cosmetic
+  // collapse as strand mode so the foreach/collect execution-layer
+  // concepts don't leak into the view as boxed nodes.
+  //
+  // User scenario: [Disbind (1→n), ForEach, make_decision] where
+  // target_spec equals the last cap's to_spec, so the backbone
+  // collapses to 3 nodes: input_slot, step_0 (Text Page),
+  // step_2 (Decision, merged target). No separate `for each` or
+  // `collect` boxes.
+  const strand = {
+    source_spec: 'media:pdf',
+    target_spec: 'media:decision',
+    steps: [
+      makeCapStep('cap:in="media:pdf";op=disbind;out="media:page"', 'Disbind', 'media:pdf', 'media:page', false, true),
+      makeForEachStep('media:page'),
+      makeCapStep('cap:in="media:page";op=decide;out="media:decision"', 'Make a Decision', 'media:page', 'media:decision', false, false),
+    ],
+  };
+  const payload = {
+    resolved_strand: strand,
+    body_outcomes: [],
+    visible_success_count: 0,
+    visible_failure_count: 0,
+    total_body_count: 0,
+  };
+  const built = rendererBuildRunGraphData(payload);
+
+  // Backbone must contain NO foreach/collect nodes.
+  const foreachNodes = built.strandBuilt.nodes.filter(n => n.nodeClass === 'strand-foreach');
+  const collectNodes = built.strandBuilt.nodes.filter(n => n.nodeClass === 'strand-collect');
+  assertEqual(foreachNodes.length, 0, 'run backbone must not contain strand-foreach nodes');
+  assertEqual(collectNodes.length, 0, 'run backbone must not contain strand-collect nodes');
+
+  // The backbone fallback connector is the foreach-entry cap edge
+  // that runs from the pre-foreach node to the body cap. It must
+  // survive collapse so the target stays reachable even with zero
+  // successful bodies.
+  const backboneCapEdges = built.strandBuilt.edges.filter(e => e.edgeClass === 'strand-cap-edge');
+  assert(backboneCapEdges.some(e => e.source === 'step_0' && e.target === 'step_2'),
+    'foreach-entry backbone edge step_0 → step_2 must be present for fallback connectivity');
+
+  // With zero outcomes, no replicas and no show-more nodes.
+  assertEqual(built.replicaNodes.length, 0, 'no replica nodes when body_outcomes is empty');
+  assertEqual(built.showMoreNodes.length, 0, 'no show-more nodes when no hidden outcomes');
+}
+
+function testRenderer_buildRunGraphData_allFailedDropsTargetPlaceholder() {
+  // When every body fails, the strand target node was never
+  // reached by any execution. The render drops BOTH the backbone
+  // foreach-entry edge AND the orphaned target node so the user
+  // doesn't see a stale "Decision" placeholder alongside their
+  // failed replicas.
+  const strand = {
+    source_spec: 'media:pdf',
+    target_spec: 'media:decision',
+    steps: [
+      makeCapStep('cap:in="media:pdf";op=disbind;out="media:page"', 'Disbind', 'media:pdf', 'media:page', false, true),
+      makeForEachStep('media:page'),
+      makeCapStep('cap:in="media:page";op=decide;out="media:decision"', 'Make a Decision', 'media:page', 'media:decision', false, false),
+    ],
+  };
+  const failedCapUrn = 'cap:in="media:page";op=decide;out="media:decision"';
+  const payload = {
+    resolved_strand: strand,
+    body_outcomes: [
+      { body_index: 0, success: false, cap_urns: [], saved_paths: [], total_bytes: 0, duration_ms: 0, failed_cap: failedCapUrn, error: 'boom' },
+      { body_index: 1, success: false, cap_urns: [], saved_paths: [], total_bytes: 0, duration_ms: 0, failed_cap: failedCapUrn, error: 'boom' },
+    ],
+    visible_success_count: 3,
+    visible_failure_count: 3,
+    total_body_count: 2,
+  };
+  const built = rendererBuildRunGraphData(payload);
+
+  // The dropped placeholder: step_2 (the merged strand target
+  // "Decision") is absent from the backbone because all bodies
+  // failed and the replicas didn't reach it.
+  const hasStep2 = built.strandBuilt.nodes.some(n => n.id === 'step_2');
+  assertEqual(hasStep2, false,
+    'strand target placeholder must be dropped when zero successful replicas reach it');
+
+  // The backbone foreach-entry edge is also gone — replicas
+  // replaced it and there's no orphan target to connect.
+  const foreachEntry = built.strandBuilt.edges.find(e =>
+    e.edgeClass === 'strand-cap-edge' && e.foreachEntry === true);
+  assertEqual(foreachEntry, undefined,
+    'backbone foreach-entry edge must be dropped when replicas exist');
+
+  // Each failed body renders as an entry node + N body-step
+  // nodes. Body has 1 cap (make_decision), so 2 nodes per body.
+  // 2 failed bodies × 2 nodes = 4 failure replica nodes.
+  const failureNodes = built.replicaNodes.filter(n => n.classes === 'body-failure');
+  assertEqual(failureNodes.length, 4,
+    'two failed bodies × (entry + 1 body cap) = 4 failure replica nodes');
+
+  // Disbind is the sequence producer, so its backbone node
+  // (step_0) is ALSO dropped — the per-body entry nodes own
+  // the per-item rendering. The only surviving backbone node
+  // is the input_slot (avid-optic source PDF).
+  const hasStep0 = built.strandBuilt.nodes.some(n => n.id === 'step_0');
+  assertEqual(hasStep0, false,
+    'sequence producer backbone node (Disbind output) is dropped; replicas own the per-body rendering');
+  const hasInputSlot = built.strandBuilt.nodes.some(n => n.id === 'input_slot');
+  assertEqual(hasInputSlot, true, 'input_slot survives as the shared source');
+}
+
+function testRenderer_buildRunGraphData_unclosedForeachSuccessNoMerge() {
+  // Strand without a Collect: [Disbind, ForEach, make_decision].
+  // Under the machfab realize_strand semantics there's no Collect,
+  // so each body produces its OWN terminal output. Successful
+  // replicas do NOT merge into a shared target — each body has
+  // its own separate decision.
+  //
+  // Expected replica shape per body:
+  //   anchorNode (pre-foreach backbone) → entry (per-body Text Page)
+  //                                    → body_n_0 (per-body Decision)
+  //   (no merge edge back into the backbone)
+  const strand = {
+    source_spec: 'media:pdf',
+    target_spec: 'media:decision',
+    steps: [
+      makeCapStep('cap:in="media:pdf";op=disbind;out="media:page"', 'Disbind', 'media:pdf', 'media:page', false, true),
+      makeForEachStep('media:page'),
+      makeCapStep('cap:in="media:page";op=decide;out="media:decision"', 'Make a Decision', 'media:page', 'media:decision', false, false),
+    ],
+  };
+  const payload = {
+    resolved_strand: strand,
+    body_outcomes: [
+      { body_index: 0, success: true, cap_urns: [], saved_paths: [], total_bytes: 0, duration_ms: 0 },
+    ],
+    visible_success_count: 3,
+    visible_failure_count: 3,
+    total_body_count: 1,
+  };
+  const built = rendererBuildRunGraphData(payload);
+
+  // step_2 (the merged strand target) was dropped because it's
+  // a body cap step and there's no Collect to merge into.
+  const hasStep2 = built.strandBuilt.nodes.some(n => n.id === 'step_2');
+  assertEqual(hasStep2, false,
+    'body cap node dropped; without Collect there is no shared merge target');
+
+  // Each body produces its own entry + body cap chain: 2 nodes.
+  const successNodes = built.replicaNodes.filter(n => n.classes === 'body-success');
+  assertEqual(successNodes.length, 2,
+    'one successful body × (entry + 1 body cap) = 2 replica nodes');
+
+  // No replica edge targets the (now non-existent) step_2.
+  const mergeEdges = built.replicaEdges.filter(e =>
+    e.data && e.data.target === 'step_2');
+  assertEqual(mergeEdges.length, 0,
+    'no merge edges to step_2 because there is no Collect');
+
+  // The fork edge from anchor (input_slot, because Disbind IS
+  // the sequence producer whose backbone node is dropped) to
+  // the per-body entry IS present.
+  const forkEdges = built.replicaEdges.filter(e =>
+    e.data && e.data.source === 'input_slot' && e.classes === 'body-success');
+  assertEqual(forkEdges.length, 1, 'fork edge input_slot → body-0-entry exists');
+}
+
+function testRenderer_buildRunGraphData_closedForeachSuccessMergesAtCollectTarget() {
+  // With a Collect closing the body, successful replicas DO merge
+  // into the post-collect target so the flow converges.
+  // Strand: [Disbind, ForEach, Cap_a, Cap_b, Collect] with a
+  // downstream cap after Collect to make the post-collect target
+  // a real separate node.
+  //
+  // Actually simpler: [ForEach, Cap_a, Collect] with source=list
+  // and target=list.
+  const strand = {
+    source_spec: 'media:pdf;list',
+    target_spec: 'media:txt;list',
+    steps: [
+      makeForEachStep('media:pdf;list'),
+      makeCapStep('cap:in="media:pdf";op=extract;out="media:txt"', 'extract', 'media:pdf', 'media:txt', false, false),
+      makeCollectStep('media:txt'),
+    ],
+  };
+  const payload = {
+    resolved_strand: strand,
+    body_outcomes: [
+      { body_index: 0, success: true, cap_urns: [], saved_paths: [], total_bytes: 0, duration_ms: 0 },
+    ],
+    visible_success_count: 3,
+    visible_failure_count: 3,
+    total_body_count: 1,
+  };
+  const built = rendererBuildRunGraphData(payload);
+
+  // The post-collect target (output) is still present — it's the
+  // strand target. Successful replicas merge into it.
+  const hasOutput = built.strandBuilt.nodes.some(n => n.id === 'output');
+  assertEqual(hasOutput, true,
+    'post-collect target (output) stays because successful replicas merge into it');
+
+  // One body × (entry + 1 body cap) = 2 replica nodes.
+  const successNodes = built.replicaNodes.filter(n => n.classes === 'body-success');
+  assertEqual(successNodes.length, 2,
+    'one successful body × (entry + 1 body cap) = 2 replica nodes');
+
+  // One merge edge from the last body cap to the output node.
+  const mergeEdges = built.replicaEdges.filter(e =>
+    e.data && e.data.target === 'output' && e.classes === 'body-success');
+  assertEqual(mergeEdges.length, 1,
+    'one merge edge from body cap replica to collect target');
 }
 
-// ---------------- machine builder ----------------
+// ---------------- editor-graph builder ----------------
 
-function testRenderer_validateMachinePayload_rejectsUnknownKind() {
+function testRenderer_validateEditorGraphPayload_rejectsUnknownKind() {
   let threw = false;
   try {
-    rendererValidateMachinePayload({
+    rendererValidateEditorGraphPayload({
       elements: [{ kind: 'widget', graph_id: 'w1' }],
     });
   } catch (e) {
@@ -4388,32 +4852,102 @@ function testRenderer_validateMachinePayload_rejectsUnknownKind() {
   assert(threw, 'unknown element kind must throw');
 }
 
-function testRenderer_buildMachineGraphData_preservesTokenIds() {
-  // Token IDs are the bridge for editor cross-highlighting. Every
-  // element MUST carry its tokenId through into the cytoscape data.
+function testRenderer_buildEditorGraphData_collapsesCapsIntoLabeledEdges() {
+  // The notation analyzer emits a bipartite chain per cap
+  // application: data_node → arg_edge → cap_node → arg_edge →
+  // data_node. The machine builder collapses each cap into a
+  // single labeled edge between the input and output data slots.
+  // Cap nodes do NOT appear as cytoscape nodes. Cap tokenIds are
+  // carried on the synthesized edge so editor cross-highlight
+  // still resolves from the rendered edge to the cap's source
+  // text.
+  const data = {
+    elements: [
+      { kind: 'node', graph_id: 'n_src', label: 'n0', token_id: 't-src' },
+      { kind: 'node', graph_id: 'n_dst', label: 'n1', token_id: 't-dst' },
+      { kind: 'cap',  graph_id: 'c1',    label: 'my_cap', token_id: 't-cap', linked_cap_urn: 'cap:...' },
+      { kind: 'edge', graph_id: 'e_in',  source_graph_id: 'n_src', target_graph_id: 'c1', label: 'in', token_id: 't-ein' },
+      { kind: 'edge', graph_id: 'e_out', source_graph_id: 'c1', target_graph_id: 'n_dst', label: 'out', token_id: 't-eout' },
+    ],
+  };
+  const built = rendererBuildEditorGraphData(data);
+
+  // Only data-slot nodes survive. Cap is NOT a node.
+  assertEqual(built.nodes.length, 2, 'only data-slot nodes are rendered');
+  const nodeIds = built.nodes.map(n => n.data.id).sort();
+  assertEqual(JSON.stringify(nodeIds), JSON.stringify(['n_dst', 'n_src']),
+    'data-slot nodes preserved verbatim');
+  assertEqual(built.nodes.every(n => n.data.kind === 'node'), true,
+    'every surviving node has kind=node (no cap nodes)');
+
+  // The cap is collapsed to a single labeled edge.
+  assertEqual(built.edges.length, 1, 'one collapsed edge per cap application');
+  const edge = built.edges[0];
+  assertEqual(edge.data.source, 'n_src', 'edge source is the cap input data slot');
+  assertEqual(edge.data.target, 'n_dst', 'edge target is the cap output data slot');
+  assertEqual(edge.data.label, 'my_cap', 'edge label is the cap title');
+  assertEqual(edge.data.tokenId, 't-cap',
+    'edge carries the cap node tokenId so editor cross-highlight points to the cap in source text');
+}
+
+function testRenderer_buildEditorGraphData_loopMarkedEdgeGetsLoopClass() {
+  // A cap marked `is_loop: true` must produce a `machine-loop`
+  // edge so the stylesheet's dashed amber rule applies.
+  const data = {
+    elements: [
+      { kind: 'node', graph_id: 'a', label: 'a', token_id: 't-a' },
+      { kind: 'node', graph_id: 'b', label: 'b', token_id: 't-b' },
+      { kind: 'cap',  graph_id: 'c', label: 'looped', token_id: 't-c', is_loop: true },
+      { kind: 'edge', graph_id: 'e1', source_graph_id: 'a', target_graph_id: 'c', token_id: 't-e1' },
+      { kind: 'edge', graph_id: 'e2', source_graph_id: 'c', target_graph_id: 'b', token_id: 't-e2' },
+    ],
+  };
+  const built = rendererBuildEditorGraphData(data);
+  assertEqual(built.edges.length, 1, 'one collapsed edge');
+  assert(built.edges[0].classes.indexOf('machine-loop') >= 0,
+    'loop-marked cap emits machine-loop class on the collapsed edge');
+}
+
+function testRenderer_buildEditorGraphData_cardinalityFromDataSlotSequenceFlags() {
+  // Cardinality markers come from the source and target data
+  // slots' `is_sequence` flags. A cap whose output data slot has
+  // `is_sequence=true` shows "(1→n)" on its collapsed edge.
+  const data = {
+    elements: [
+      { kind: 'node', graph_id: 'a', label: 'pdf',   token_id: 't-a', is_sequence: false },
+      { kind: 'node', graph_id: 'b', label: 'pages', token_id: 't-b', is_sequence: true },
+      { kind: 'cap',  graph_id: 'c', label: 'disbind', token_id: 't-c' },
+      { kind: 'edge', graph_id: 'e1', source_graph_id: 'a', target_graph_id: 'c', token_id: 't-e1' },
+      { kind: 'edge', graph_id: 'e2', source_graph_id: 'c', target_graph_id: 'b', token_id: 't-e2' },
+    ],
+  };
+  const built = rendererBuildEditorGraphData(data);
+  assertEqual(built.edges.length, 1, 'one collapsed edge');
+  assertEqual(built.edges[0].data.label, 'disbind (1\u2192n)',
+    'cardinality marker "(1→n)" derived from output data slot is_sequence=true');
+}
+
+function testRenderer_buildEditorGraphData_capWithoutCompleteArgsIsDropped() {
+  // A cap with no incoming or no outgoing argument edges (e.g.
+  // the user is mid-typing) contributes nothing to the render.
+  // The data slots are still emitted.
   const data = {
     elements: [
-      { kind: 'node', graph_id: 'n1', label: 'a', token_id: 't-node-a' },
-      { kind: 'cap',  graph_id: 'c1', label: 'fn', token_id: 't-cap-fn' },
-      { kind: 'edge', graph_id: 'e1', source_graph_id: 'n1', target_graph_id: 'c1', label: '', token_id: 't-edge-1' },
+      { kind: 'node', graph_id: 'a', label: 'a', token_id: 't-a' },
+      { kind: 'cap',  graph_id: 'c', label: 'halfway', token_id: 't-c' },
+      { kind: 'edge', graph_id: 'e1', source_graph_id: 'a', target_graph_id: 'c', token_id: 't-e1' },
     ],
   };
-  const built = rendererBuildMachineGraphData(data);
-  const nodeTokens = built.nodes.map(n => n.data.tokenId).sort();
-  assertEqual(JSON.stringify(nodeTokens), JSON.stringify(['t-cap-fn', 't-node-a']),
-    'node tokenIds must round-trip');
-  assertEqual(built.edges.length, 1, 'one edge');
-  assertEqual(built.edges[0].data.tokenId, 't-edge-1', 'edge tokenId must round-trip');
-  // Kinds are carried as element data for editor-side filtering.
-  const kinds = built.nodes.map(n => n.data.kind).sort();
-  assertEqual(JSON.stringify(kinds), JSON.stringify(['cap', 'node']),
-    'element kinds must be preserved');
-}
-
-function testRenderer_buildMachineGraphData_rejectsEdgeWithMissingSource() {
+  const built = rendererBuildEditorGraphData(data);
+  assertEqual(built.nodes.length, 1, 'data slot emitted');
+  assertEqual(built.edges.length, 0,
+    'incomplete cap (no outgoing argument) drops out of the render');
+}
+
+function testRenderer_buildEditorGraphData_rejectsEdgeWithMissingSource() {
   let threw = false;
   try {
-    rendererBuildMachineGraphData({
+    rendererBuildEditorGraphData({
       elements: [
         { kind: 'edge', graph_id: 'e1', target_graph_id: 't' },
       ],
@@ -4424,6 +4958,261 @@ function testRenderer_buildMachineGraphData_rejectsEdgeWithMissingSource() {
   assert(threw, 'edge without source_graph_id must throw');
 }
 
+// ---------------- resolved-machine builder ----------------
+
+function testRenderer_buildResolvedMachineGraphData_singleStrandLinearChain() {
+  // A single-strand machine: media:pdf → extract → media:txt
+  // → embed → media:embedding. Two edges, three nodes, no
+  // loops, no fan-in. Tests the basic shape — nodes and
+  // edges flow through verbatim from the resolved machine
+  // payload.
+  const payload = {
+    strands: [
+      {
+        nodes: [
+          { id: 'n0', urn: 'media:pdf' },
+          { id: 'n1', urn: 'media:txt;textable' },
+          { id: 'n2', urn: 'media:embedding;record' },
+        ],
+        edges: [
+          {
+            alias: 'edge_0',
+            cap_urn: 'cap:in=media:pdf;op=extract;out=media:txt;textable',
+            is_loop: false,
+            assignment: [
+              { cap_arg_media_urn: 'media:pdf', source_node: 'n0' },
+            ],
+            target_node: 'n1',
+          },
+          {
+            alias: 'edge_1',
+            cap_urn: 'cap:in=media:textable;op=embed;out=media:embedding;record',
+            is_loop: false,
+            assignment: [
+              { cap_arg_media_urn: 'media:textable', source_node: 'n1' },
+            ],
+            target_node: 'n2',
+          },
+        ],
+        input_anchor_nodes: ['n0'],
+        output_anchor_nodes: ['n2'],
+      },
+    ],
+  };
+  const built = rendererBuildResolvedMachineGraphData(payload);
+  assertEqual(built.nodes.length, 3, 'three data-slot nodes');
+  assertEqual(built.edges.length, 2, 'two cap edges (one assignment each)');
+  // First edge connects n0 → n1, second connects n1 → n2.
+  const edges = built.edges.map(e => `${e.data.source}->${e.data.target}`);
+  assertEqual(edges[0], 'n0->n1', 'first edge wires n0 to n1');
+  assertEqual(edges[1], 'n1->n2', 'second edge wires n1 to n2');
+  // Anchor nodes carry the strand-source / strand-target classes.
+  const n0 = built.nodes.find(n => n.data.id === 'n0');
+  const n2 = built.nodes.find(n => n.data.id === 'n2');
+  assert(n0.classes.indexOf('strand-source') >= 0,
+    'input anchor node carries strand-source class');
+  assert(n2.classes.indexOf('strand-target') >= 0,
+    'output anchor node carries strand-target class');
+}
+
+function testRenderer_buildResolvedMachineGraphData_loopEdgeGetsLoopClass() {
+  // An is_loop edge corresponds to a strand step inside a
+  // ForEach body. The renderer must mark it with the
+  // `machine-loop` class so the dashed amber rule applies.
+  const payload = {
+    strands: [
+      {
+        nodes: [
+          { id: 'n0', urn: 'media:page;textable' },
+          { id: 'n1', urn: 'media:decision;json;record;textable' },
+        ],
+        edges: [
+          {
+            alias: 'edge_0',
+            cap_urn: 'cap:in=media:textable;op=make_decision;out=media:decision;json;record;textable',
+            is_loop: true,
+            assignment: [
+              { cap_arg_media_urn: 'media:textable', source_node: 'n0' },
+            ],
+            target_node: 'n1',
+          },
+        ],
+        input_anchor_nodes: ['n0'],
+        output_anchor_nodes: ['n1'],
+      },
+    ],
+  };
+  const built = rendererBuildResolvedMachineGraphData(payload);
+  assertEqual(built.edges.length, 1, 'one cap edge');
+  assert(built.edges[0].classes.indexOf('machine-loop') >= 0,
+    'is_loop=true must produce a machine-loop class on the cap edge');
+}
+
+function testRenderer_buildResolvedMachineGraphData_fanInProducesEdgePerAssignment() {
+  // A cap with two input args (a fan-in) gets one rendered
+  // edge per (source_node, target_node) pair so cytoscape can
+  // draw both incoming wires. Both edges share the cap title
+  // and color so they read as a single fan-in.
+  const payload = {
+    strands: [
+      {
+        nodes: [
+          { id: 'n0', urn: 'media:image;png' },
+          { id: 'n1', urn: 'media:model-spec;textable' },
+          { id: 'n2', urn: 'media:image-description;textable' },
+        ],
+        edges: [
+          {
+            alias: 'edge_0',
+            cap_urn: 'cap:in=media:image;png;op=describe_image;out=media:image-description;textable',
+            is_loop: false,
+            assignment: [
+              { cap_arg_media_urn: 'media:image;png', source_node: 'n0' },
+              { cap_arg_media_urn: 'media:model-spec;textable', source_node: 'n1' },
+            ],
+            target_node: 'n2',
+          },
+        ],
+        input_anchor_nodes: ['n0', 'n1'],
+        output_anchor_nodes: ['n2'],
+      },
+    ],
+  };
+  const built = rendererBuildResolvedMachineGraphData(payload);
+  assertEqual(built.edges.length, 2, 'two rendered edges, one per assignment binding');
+  const sources = built.edges.map(e => e.data.source).sort();
+  assertEqual(JSON.stringify(sources), JSON.stringify(['n0', 'n1']),
+    'each binding gets its own source-node edge into the same target');
+  assertEqual(built.edges[0].data.target, 'n2', 'first edge targets n2');
+  assertEqual(built.edges[1].data.target, 'n2', 'second edge targets n2');
+}
+
+function testRenderer_buildResolvedMachineGraphData_multiStrandKeepsStrandsDisjoint() {
+  // Two strands inside one machine. Each strand has its own
+  // nodes and edges. Node ids are globally unique across
+  // strands (Rust assigns them via a single counter), so no
+  // node id collision can happen. The renderer must emit
+  // every node and every edge from both strands.
+  const payload = {
+    strands: [
+      {
+        nodes: [
+          { id: 'n0', urn: 'media:pdf' },
+          { id: 'n1', urn: 'media:txt;textable' },
+        ],
+        edges: [
+          {
+            alias: 'edge_0',
+            cap_urn: 'cap:in=media:pdf;op=extract;out=media:txt;textable',
+            is_loop: false,
+            assignment: [
+              { cap_arg_media_urn: 'media:pdf', source_node: 'n0' },
+            ],
+            target_node: 'n1',
+          },
+        ],
+        input_anchor_nodes: ['n0'],
+        output_anchor_nodes: ['n1'],
+      },
+      {
+        nodes: [
+          { id: 'n2', urn: 'media:json;record;textable' },
+          { id: 'n3', urn: 'media:csv;list;record;textable' },
+        ],
+        edges: [
+          {
+            alias: 'edge_1',
+            cap_urn: 'cap:in=media:json;record;textable;op=convert_format;out=media:csv;list;record;textable',
+            is_loop: false,
+            assignment: [
+              { cap_arg_media_urn: 'media:json;record;textable', source_node: 'n2' },
+            ],
+            target_node: 'n3',
+          },
+        ],
+        input_anchor_nodes: ['n2'],
+        output_anchor_nodes: ['n3'],
+      },
+    ],
+  };
+  const built = rendererBuildResolvedMachineGraphData(payload);
+  assertEqual(built.nodes.length, 4, 'all four nodes from both strands present');
+  assertEqual(built.edges.length, 2, 'one edge per strand');
+  // Each node carries a strandIndex matching which strand it came from.
+  const idToStrand = {};
+  for (const n of built.nodes) idToStrand[n.data.id] = n.data.strandIndex;
+  assertEqual(idToStrand['n0'], 0, 'n0 belongs to strand 0');
+  assertEqual(idToStrand['n1'], 0, 'n1 belongs to strand 0');
+  assertEqual(idToStrand['n2'], 1, 'n2 belongs to strand 1');
+  assertEqual(idToStrand['n3'], 1, 'n3 belongs to strand 1');
+}
+
+function testRenderer_buildResolvedMachineGraphData_duplicateNodeIdAcrossStrandsFailsHard() {
+  // Node ids must be globally unique across strands. The
+  // Rust serializer guarantees this via a single global
+  // counter. If the host ever feeds a payload that violates
+  // it, the renderer must fail hard so the bug surfaces
+  // instead of silently overwriting one node with another.
+  const payload = {
+    strands: [
+      {
+        nodes: [{ id: 'n0', urn: 'media:pdf' }],
+        edges: [],
+        input_anchor_nodes: ['n0'],
+        output_anchor_nodes: ['n0'],
+      },
+      {
+        nodes: [{ id: 'n0', urn: 'media:html' }],
+        edges: [],
+        input_anchor_nodes: ['n0'],
+        output_anchor_nodes: ['n0'],
+      },
+    ],
+  };
+  let threw = false;
+  let message = '';
+  try {
+    rendererBuildResolvedMachineGraphData(payload);
+  } catch (e) {
+    threw = true;
+    message = e.message || '';
+  }
+  assert(threw, 'duplicate node id across strands must throw');
+  assert(message.includes('duplicate node id') && message.includes('n0'),
+    'error must name the colliding node id');
+}
+
+function testRenderer_validateResolvedMachinePayload_rejectsMissingFields() {
+  // The validator must reject any payload missing a required
+  // field on a strand, edge, node, or assignment binding.
+  // We exercise the most-likely-to-be-missed field on each
+  // sub-shape.
+  const cases = [
+    { strands: 'not-an-array' },
+    { strands: [{ nodes: [], edges: [], input_anchor_nodes: [] /* missing output_anchor_nodes */ }] },
+    { strands: [{ nodes: [{ id: 'n0' /* missing urn */ }], edges: [], input_anchor_nodes: [], output_anchor_nodes: [] }] },
+    {
+      strands: [{
+        nodes: [{ id: 'n0', urn: 'media:x' }],
+        edges: [{
+          alias: 'edge_0',
+          cap_urn: 'cap:in=...;out=...',
+          is_loop: false,
+          assignment: [{ cap_arg_media_urn: 'media:x' /* missing source_node */ }],
+          target_node: 'n0',
+        }],
+        input_anchor_nodes: ['n0'],
+        output_anchor_nodes: ['n0'],
+      }],
+    },
+  ];
+  for (const c of cases) {
+    let threw = false;
+    try { rendererValidateResolvedMachinePayload(c); } catch (e) { threw = true; }
+    assert(threw, `validator must reject payload: ${JSON.stringify(c).slice(0, 80)}`);
+  }
+}
+
 // ============================================================================
 // Test runner
 // ============================================================================
@@ -4602,24 +5391,24 @@ async function runTests() {
   if (p2) await p2;
   runTest('JS: media_spec_construction', testJS_mediaSpecConstruction);
 
-  // plugin_repo: PluginRepoServer and PluginRepoClient tests
-  console.log('\n--- plugin_repo ---');
-  runTest('TEST320: plugin_info_construction', test320_pluginInfoConstruction);
-  runTest('TEST321: plugin_info_is_signed', test321_pluginInfoIsSigned);
-  runTest('TEST322: plugin_info_has_binary', test322_pluginInfoHasBinary);
-  runTest('TEST323: plugin_repo_server_validate_registry', test323_pluginRepoServerValidateRegistry);
-  runTest('TEST324: plugin_repo_server_transform_to_array', test324_pluginRepoServerTransformToArray);
-  runTest('TEST325: plugin_repo_server_get_plugins', test325_pluginRepoServerGetPlugins);
-  runTest('TEST326: plugin_repo_server_get_plugin_by_id', test326_pluginRepoServerGetPluginById);
-  runTest('TEST327: plugin_repo_server_search_plugins', test327_pluginRepoServerSearchPlugins);
-  runTest('TEST328: plugin_repo_server_get_by_category', test328_pluginRepoServerGetByCategory);
-  runTest('TEST329: plugin_repo_server_get_by_cap', test329_pluginRepoServerGetByCap);
-  runTest('TEST330: plugin_repo_client_update_cache', test330_pluginRepoClientUpdateCache);
-  runTest('TEST331: plugin_repo_client_get_suggestions', test331_pluginRepoClientGetSuggestions);
-  runTest('TEST332: plugin_repo_client_get_plugin', test332_pluginRepoClientGetPlugin);
-  runTest('TEST333: plugin_repo_client_get_all_caps', test333_pluginRepoClientGetAllCaps);
-  runTest('TEST334: plugin_repo_client_needs_sync', test334_pluginRepoClientNeedsSync);
-  runTest('TEST335: plugin_repo_server_client_integration', test335_pluginRepoServerClientIntegration);
+  // cartridge_repo: CartridgeRepoServer and CartridgeRepoClient tests
+  console.log('\n--- cartridge_repo ---');
+  runTest('TEST320: cartridge_info_construction', test320_cartridgeInfoConstruction);
+  runTest('TEST321: cartridge_info_is_signed', test321_cartridgeInfoIsSigned);
+  runTest('TEST322: cartridge_info_has_package', test322_cartridgeInfoHasPackage);
+  runTest('TEST323: cartridge_repo_server_validate_registry', test323_cartridgeRepoServerValidateRegistry);
+  runTest('TEST324: cartridge_repo_server_transform_to_array', test324_cartridgeRepoServerTransformToArray);
+  runTest('TEST325: cartridge_repo_server_get_cartridges', test325_cartridgeRepoServerGetCartridges);
+  runTest('TEST326: cartridge_repo_server_get_cartridge_by_id', test326_cartridgeRepoServerGetCartridgeById);
+  runTest('TEST327: cartridge_repo_server_search_cartridges', test327_cartridgeRepoServerSearchCartridges);
+  runTest('TEST328: cartridge_repo_server_get_by_category', test328_cartridgeRepoServerGetByCategory);
+  runTest('TEST329: cartridge_repo_server_get_by_cap', test329_cartridgeRepoServerGetByCap);
+  runTest('TEST330: cartridge_repo_client_update_cache', test330_cartridgeRepoClientUpdateCache);
+  runTest('TEST331: cartridge_repo_client_get_suggestions', test331_cartridgeRepoClientGetSuggestions);
+  runTest('TEST332: cartridge_repo_client_get_cartridge', test332_cartridgeRepoClientGetCartridge);
+  runTest('TEST333: cartridge_repo_client_get_all_caps', test333_cartridgeRepoClientGetAllCaps);
+  runTest('TEST334: cartridge_repo_client_needs_sync', test334_cartridgeRepoClientNeedsSync);
+  runTest('TEST335: cartridge_repo_server_client_integration', test335_cartridgeRepoServerClientIntegration);
 
   // media_urn.rs: TEST546-TEST558 (MediaUrn predicates)
   console.log('\n--- media_urn.rs (predicates) ---');
@@ -4800,6 +5589,12 @@ async function runTests() {
   runTest('RENDERER: buildStrand_standaloneCollect',          testRenderer_buildStrandGraphData_standaloneCollect);
   runTest('RENDERER: buildStrand_unclosedForEachBody',        testRenderer_buildStrandGraphData_unclosedForEachBody);
   runTest('RENDERER: buildStrand_nestedForEachThrows',        testRenderer_buildStrandGraphData_nestedForEachThrows);
+  runTest('RENDERER: collapseStrand_singleCapBody',           testRenderer_collapseStrand_singleCapBodyShowsCapTitleWithIterCollectMarker);
+  runTest('RENDERER: collapseStrand_unclosedForEachBody',     testRenderer_collapseStrand_unclosedForEachBodyCollapses);
+  runTest('RENDERER: collapseStrand_standaloneCollect',       testRenderer_collapseStrand_standaloneCollectCollapses);
+  runTest('RENDERER: collapseStrand_seqCapBeforeForeach',     testRenderer_collapseStrand_sequenceProducingCapBeforeForeach);
+  runTest('RENDERER: collapseStrand_plainCapMergesOutput',    testRenderer_collapseStrand_plainCapMergesTrailingOutput);
+  runTest('RENDERER: collapseStrand_plainCapDistinctTarget',  testRenderer_collapseStrand_plainCapDistinctTargetNoMerge);
   runTest('RENDERER: validateStrand_missingSourceSpec',       testRenderer_validateStrandPayload_missingSourceSpec);
 
   console.log('\n--- cap-graph-renderer run builder ---');
@@ -4807,11 +5602,26 @@ async function runTests() {
   runTest('RENDERER: buildRun_pagesSuccessesAndFailures',     testRenderer_buildRunGraphData_pagesSuccessesAndFailures);
   runTest('RENDERER: buildRun_failureWithoutFailedCap',       testRenderer_buildRunGraphData_failureWithoutFailedCapRendersFullTrace);
   runTest('RENDERER: buildRun_usesIsEquivalentForFailedCap',  testRenderer_buildRunGraphData_usesCapUrnIsEquivalentForFailedCap);
-
-  console.log('\n--- cap-graph-renderer machine builder ---');
-  runTest('RENDERER: validateMachine_unknownKind',            testRenderer_validateMachinePayload_rejectsUnknownKind);
-  runTest('RENDERER: buildMachine_preservesTokenIds',         testRenderer_buildMachineGraphData_preservesTokenIds);
-  runTest('RENDERER: buildMachine_rejectsEdgeMissingSource',  testRenderer_buildMachineGraphData_rejectsEdgeWithMissingSource);
+  runTest('RENDERER: buildRun_backboneHasNoForeachNode',      testRenderer_buildRunGraphData_backboneHasNoForeachNode);
+  runTest('RENDERER: buildRun_allFailedDropsPlaceholder',     testRenderer_buildRunGraphData_allFailedDropsTargetPlaceholder);
+  runTest('RENDERER: buildRun_unclosedForeachNoMerge',        testRenderer_buildRunGraphData_unclosedForeachSuccessNoMerge);
+  runTest('RENDERER: buildRun_closedForeachMerges',           testRenderer_buildRunGraphData_closedForeachSuccessMergesAtCollectTarget);
+
+  console.log('\n--- cap-graph-renderer editor-graph builder ---');
+  runTest('RENDERER: validateEditorGraph_unknownKind',          testRenderer_validateEditorGraphPayload_rejectsUnknownKind);
+  runTest('RENDERER: buildEditorGraph_collapsesCapsIntoEdges',  testRenderer_buildEditorGraphData_collapsesCapsIntoLabeledEdges);
+  runTest('RENDERER: buildEditorGraph_loopEdgeGetsClass',       testRenderer_buildEditorGraphData_loopMarkedEdgeGetsLoopClass);
+  runTest('RENDERER: buildEditorGraph_cardinalityFromIsSeq',    testRenderer_buildEditorGraphData_cardinalityFromDataSlotSequenceFlags);
+  runTest('RENDERER: buildEditorGraph_incompleteCapDropped',    testRenderer_buildEditorGraphData_capWithoutCompleteArgsIsDropped);
+  runTest('RENDERER: buildEditorGraph_rejectsEdgeMissingSrc',   testRenderer_buildEditorGraphData_rejectsEdgeWithMissingSource);
+
+  console.log('\n--- cap-graph-renderer resolved-machine builder ---');
+  runTest('RENDERER: buildResolvedMachine_singleStrandLinear',     testRenderer_buildResolvedMachineGraphData_singleStrandLinearChain);
+  runTest('RENDERER: buildResolvedMachine_loopGetsLoopClass',      testRenderer_buildResolvedMachineGraphData_loopEdgeGetsLoopClass);
+  runTest('RENDERER: buildResolvedMachine_fanInOneEdgePerSrc',     testRenderer_buildResolvedMachineGraphData_fanInProducesEdgePerAssignment);
+  runTest('RENDERER: buildResolvedMachine_multiStrandDisjoint',    testRenderer_buildResolvedMachineGraphData_multiStrandKeepsStrandsDisjoint);
+  runTest('RENDERER: buildResolvedMachine_dupNodeIdFails',         testRenderer_buildResolvedMachineGraphData_duplicateNodeIdAcrossStrandsFailsHard);
+  runTest('RENDERER: validateResolvedMachine_rejectsMissingFields', testRenderer_validateResolvedMachinePayload_rejectsMissingFields);
 
   // Summary
   console.log(`\n${passCount + failCount} tests: ${passCount} passed, ${failCount} failed`);