capdag 0.183.463 → 0.186.476

package/RULES.md

@@ -72,33 +72,33 @@ Examples:
 
 ## Validation Rules
 
-### XV5: No Redefinition of Registry Media Specs
+### XV5: No Redefinition of Registry Media Defs
 
-Inline media specs in a capability's `media_specs` table must not redefine media specs that already exist in the global registry or built-in specs.
+Inline media defs in a capability's `media_defs` table must not redefine media defs that already exist in the global registry or built-in specs.
 
 ```javascript
-const { validateNoMediaSpecRedefinitionSync, MEDIA_STRING } = require('capdag');
+const { validateNoMediaDefRedefinitionSync, MEDIA_STRING } = require('capdag');
 
 // This will fail - MEDIA_STRING is a built-in spec
-const mediaSpecs = {
+const mediaDefs = {
   [MEDIA_STRING]: { media_type: 'text/plain', title: 'My String' }
 };
-const result = validateNoMediaSpecRedefinitionSync(mediaSpecs);
+const result = validateNoMediaDefRedefinitionSync(mediaDefs);
 // result: { valid: false, error: 'XV5: ...', redefines: ['media:textable'] }
 
 // This is allowed - custom spec that doesn't exist
 const customSpecs = {
   'media:my-custom-type': { media_type: 'application/json', title: 'My Type' }
 };
-const customResult = validateNoMediaSpecRedefinitionSync(customSpecs);
+const customResult = validateNoMediaDefRedefinitionSync(customSpecs);
 // result: { valid: true }
 ```
 
 For server-side validation with registry access, use the async version:
 ```javascript
-const { validateNoMediaSpecRedefinition } = require('capdag');
+const { validateNoMediaDefRedefinition } = require('capdag');
 
-const result = await validateNoMediaSpecRedefinition(mediaSpecs, {
+const result = await validateNoMediaDefRedefinition(mediaDefs, {
   registryLookup: async (urn) => await mediaStore.get(urn) !== null
 });
 ```

package/build-browser.js

@@ -141,9 +141,9 @@ window.OutputValidator = OutputValidator;
 window.CapValidator = CapValidator;
 window.validateCapArgs = validateCapArgs;
 window.RESERVED_CLI_FLAGS = RESERVED_CLI_FLAGS;
-window.MediaSpec = MediaSpec;
-window.MediaSpecError = MediaSpecError;
-window.MediaSpecErrorCodes = MediaSpecErrorCodes;
+window.MediaDef = MediaDef;
+window.MediaDefError = MediaDefError;
+window.MediaDefErrorCodes = MediaDefErrorCodes;
 window.isBinaryCapUrn = isBinaryCapUrn;
 window.isJSONCapUrn = isJSONCapUrn;
 window.isStructuredCapUrn = isStructuredCapUrn;

package/cap-fab-renderer.js

@@ -742,7 +742,7 @@ function validateStrandStep(step, path) {
       throw new Error(`CapFabRenderer: ${path}.step_type.Cap.output_is_sequence must be a boolean`);
     }
   } else {
-    assertString(body.media_spec, `${path}.step_type.${variant}.media_spec`);
+    assertString(body.media_def, `${path}.step_type.${variant}.media_def`);
   }
 }
 
@@ -750,8 +750,8 @@ function validateStrandPayload(data) {
   if (!data || typeof data !== 'object') {
     throw new Error('CapFabRenderer strand mode: data must be an object');
   }
-  assertString(data.source_spec, 'strand mode data.source_spec');
-  assertString(data.target_spec, 'strand mode data.target_spec');
+  assertString(data.source_media_urn, 'strand mode data.source_media_urn');
+  assertString(data.target_media_urn, 'strand mode data.target_media_urn');
   assertArray(data.steps, 'strand mode data.steps');
   data.steps.forEach((step, idx) => {
     validateStrandStep(step, `strand mode data.steps[${idx}]`);
@@ -1087,7 +1087,7 @@ function classifyStrandCapSteps(steps) {
 //     edge to body_entry, and prev_node_id becomes body_exit.
 //
 // Node labels come from the `media_display_names` map keyed by the
-// step's canonical URN (or source_spec/target_spec for the boundary
+// step's canonical URN (or source_media_urn/target_media_urn for the boundary
 // nodes). ForEach and Collect nodes display "for each" / "collect".
 // Cap edges carry the cap title plus cardinality marker when either
 // input or output is a sequence.
@@ -1095,8 +1095,8 @@ function buildStrandGraphData(data) {
   validateStrandPayload(data);
 
   const mediaDisplayNames = data.media_display_names || {};
-  const sourceSpec = canonicalMediaUrn(data.source_spec);
-  const targetSpec = canonicalMediaUrn(data.target_spec);
+  const sourceMediaUrn = canonicalMediaUrn(data.source_media_urn);
+  const targetMediaUrn = canonicalMediaUrn(data.target_media_urn);
 
   // Look up a display name for a media URN via the host-supplied map.
   // Uses `MediaUrn.isEquivalent` so tag-order variation doesn't defeat
@@ -1151,9 +1151,9 @@ function buildStrandGraphData(data) {
     edgeCounter++;
   }
 
-  // Entry node — the strand's source media spec.
+  // Entry node — the strand's source media def.
   const inputSlotId = 'input_slot';
-  addNode(inputSlotId, displayNameFor(sourceSpec), sourceSpec, 'strand-source');
+  addNode(inputSlotId, displayNameFor(sourceMediaUrn), sourceMediaUrn, 'strand-source');
 
   let prevNodeId = inputSlotId;
 
@@ -1311,7 +1311,7 @@ function buildStrandGraphData(data) {
 
   // Final output node. Mirrors plan_builder.rs:430-432.
   const outputId = 'output';
-  addNode(outputId, displayNameFor(targetSpec), targetSpec, 'strand-target');
+  addNode(outputId, displayNameFor(targetMediaUrn), targetMediaUrn, 'strand-target');
   addEdge(prevNodeId, outputId, '', '', '', 'strand-cap-edge');
 
   // Return the raw plan-builder topology. Strand mode collapses
@@ -1319,7 +1319,7 @@ function buildStrandGraphData(data) {
   // `strandCytoscapeElements`); run mode keeps them as explicit
   // nodes because body replicas anchor at the ForEach/Collect
   // junctions.
-  return { nodes, edges, sourceSpec, targetSpec };
+  return { nodes, edges, sourceMediaUrn, targetMediaUrn };
 }
 
 // Transform the plan-builder strand topology into the render shape
@@ -1349,7 +1349,7 @@ function buildStrandGraphData(data) {
 //      post-collect cap's `input_is_sequence=true` flag.
 //
 //   4. If the last cap step's `to_spec` is semantically equivalent
-//      to the strand's `target_spec` (via MediaUrn.isEquivalent),
+//      to the strand's `target_media_urn` (via MediaUrn.isEquivalent),
 //      the separate `output` target node is dropped and the last
 //      cap edge lands on that merged endpoint. Removes the visible
 //      duplicate node.
@@ -1548,8 +1548,8 @@ function stripRunBackboneReplicaNodes(built, dropStepIds) {
   return {
     nodes: keptNodes,
     edges: keptEdges,
-    sourceSpec: built.sourceSpec,
-    targetSpec: built.targetSpec,
+    sourceMediaUrn: built.sourceMediaUrn,
+    targetMediaUrn: built.targetMediaUrn,
   };
 }
 
@@ -1569,14 +1569,14 @@ function buildRunGraphData(data) {
   // Run mode overrides the input_slot node's label with the
   // host-supplied `source_display` (runtime input filename).
   // Strand mode ignores this field so the abstract graph shows
-  // the media spec's title from `media_display_names`.
+  // the media def's title from `media_display_names`.
   if (typeof data.source_display === 'string' && data.source_display.length > 0) {
     strandBuiltCollapsed = {
       nodes: strandBuiltCollapsed.nodes.map(n =>
         n.id === 'input_slot' ? Object.assign({}, n, { label: data.source_display }) : n),
       edges: strandBuiltCollapsed.edges,
-      sourceSpec: strandBuiltCollapsed.sourceSpec,
-      targetSpec: strandBuiltCollapsed.targetSpec,
+      sourceMediaUrn: strandBuiltCollapsed.sourceMediaUrn,
+      targetMediaUrn: strandBuiltCollapsed.targetMediaUrn,
     };
   }
 
@@ -1664,7 +1664,7 @@ function buildRunGraphData(data) {
   // labels the anchor→entry edge on the first body.
   //
   // Without such a preceding sequence cap, the source itself is
-  // already a list (e.g. `media:pdf;list` source_spec) and the
+  // already a list (e.g. `media:pdf;list` source_media_urn) and the
   // ForEach iterates it directly.
   let seqProducerStepIdx = -1;
   let seqProducerStep = null;
@@ -2590,6 +2590,22 @@ class CapFabRenderer {
   // viewport (≈15% slack at 800×600).
   static get ZOOM_OUT_FIT_SLACK() { return 0.15; }
 
+  // Fit padding must scale down in very short viewports. The compact
+  // machine-select graph pane is only ~100px tall; a fixed 50px inset
+  // leaves no vertical room, so the bootstrap fit degenerates and the
+  // graph opens at Cytoscape's fallback zoom instead of a true fit.
+  // Keep the requested desktop padding where there is room, but cap it
+  // to a small fraction of the actual visible viewport in compact
+  // hosts.
+  _resolvedFitPadding(requestedPadding, containerWidth, containerHeight, excluded) {
+    const requested = Math.max(0, requestedPadding | 0);
+    const availableHeight = Math.max(0, containerHeight - excluded);
+    const limitingDim = Math.max(0, Math.min(containerWidth, availableHeight));
+    if (limitingDim <= 0) return 0;
+    const capped = Math.floor(limitingDim * 0.12);
+    return Math.max(0, Math.min(requested, capped));
+  }
+
   // Bootstrap fit: snap (no animation) to a centered, padded fit of
   // the entire graph. Used during the first paint and the post-paint
   // resize ticks while `_initialFitDone` is false. The padding here
@@ -2612,11 +2628,11 @@ class CapFabRenderer {
     if (containerWidth <= 0 || containerHeight <= 0) return;
     const elements = cy.elements();
     if (elements.length === 0) return;
-    const bb = elements.boundingBox();
+    const bb = elements.boundingBox({ includeLabels: true, includeOverlays: false });
     if (bb.w === 0 && bb.h === 0) return;
 
-    const padding = 50;
     const excluded = Math.max(0, this.bottomExcludedRegion() | 0);
+    const padding = this._resolvedFitPadding(50, containerWidth, containerHeight, excluded);
     const visibleWidth = containerWidth - padding * 2;
     const visibleHeight = containerHeight - excluded - padding * 2;
     if (visibleWidth <= 0 || visibleHeight <= 0) return;
@@ -2642,12 +2658,9 @@ class CapFabRenderer {
     // our zoom/pan write and leave the graph drifting.
     cy.stop(true);
     this._internalPanZoom = true;
-    try {
-      cy.zoom(clampedZoom);
-      cy.pan({ x: panX, y: panY });
-    } finally {
-      this._internalPanZoom = false;
-    }
+    cy.zoom(clampedZoom);
+    cy.pan({ x: panX, y: panY });
+    this._internalPanZoom = false;
   }
 
   // Mark the bootstrap centering as complete so subsequent refits
@@ -2687,7 +2700,7 @@ class CapFabRenderer {
     // that sits comfortably above this relaxed minimum, so opening
     // the view shows the graph centred with margin rather than
     // bleeding to all four edges.
-    const bb = this.cy.elements().boundingBox();
+    const bb = this.cy.elements().boundingBox({ includeLabels: true, includeOverlays: false });
     let zoomMin;
     if (bb.w > 0 && bb.h > 0) {
       const strictFit = Math.min(w / bb.w, h / bb.h);
@@ -3392,12 +3405,13 @@ class CapFabRenderer {
     this.cy.stop(true);
     if (!eles || eles.length === 0) eles = this.cy.elements();
 
-    const bb = eles.boundingBox();
+    const bb = eles.boundingBox({ includeLabels: true, includeOverlays: false });
     if (bb.w === 0 && bb.h === 0) return;
 
     const containerWidth = this.cy.width();
     const containerHeight = this.cy.height();
     const excluded = Math.max(0, this.bottomExcludedRegion() | 0);
+    padding = this._resolvedFitPadding(padding, containerWidth, containerHeight, excluded);
 
     const visibleWidth = containerWidth - padding * 2;
     const visibleHeight = containerHeight - excluded - padding * 2;
@@ -3428,12 +3442,9 @@ class CapFabRenderer {
         stop: () => { this._internalPanZoom = false; },
       });
     } else {
-      try {
-        this.cy.zoom(clampedZoom);
-        this.cy.pan({ x: panX, y: panY });
-      } finally {
-        this._internalPanZoom = false;
-      }
+      this.cy.zoom(clampedZoom);
+      this.cy.pan({ x: panX, y: panY });
+      this._internalPanZoom = false;
     }
   }