@markdy/core 1.0.19 → 1.0.21

package/README.md

@@ -64,6 +64,8 @@ try {
 |---|---|---|
 | `parse` | `(source, opts?) => DiagramAST` | Parse MarkdyScript source into a diagram AST |
 | `compile` | `(ast) => RenderPlan` | Lay out nodes, route edges, and schedule cues |
+| `compilePlan` | `(ast, theme) => RenderPlan` | Compile AST against a resolved theme token set |
+| `computeAdaptiveDimensions` | `(ast, edges?) => { width, height }` | Compute content-adaptive canvas dimensions from topology & items |
 | `parseAndCompile` | `(source) => { ast, plan }` | Parse and compile in one call |
 | `ParseError` | class | Error with `.line` number for diagnostics |
 | `DiagramAST` | type | Parsed scene: meta, nodes, edges, groups, patterns, beats |

package/dist/index.d.ts

@@ -78,6 +78,10 @@ type SceneMeta = {
     theme: string;
     direction: LayoutDirection;
     duration?: number;
+    /** Whether width was explicitly specified by the author in the script. */
+    explicitWidth?: boolean;
+    /** Whether height was explicitly specified by the author in the script. */
+    explicitHeight?: boolean;
     /** Opt-in diagram mode; defaults to architecture. */
     type?: DiagramType;
     /** Playback, controls, interaction, and chrome behavior. Source of truth. */
@@ -369,6 +373,14 @@ type RenderPlan = {
     duration: number;
 };
 
+/**
+ * Computes optimal, content-adaptive canvas width and height for a diagram AST
+ * when dimensions are omitted or partially specified in the script.
+ */
+declare function computeAdaptiveDimensions(ast: DiagramAST, edges?: RoutedEdge[]): {
+    width: number;
+    height: number;
+};
 declare function compilePlan(ast: DiagramAST, theme: ThemeTokens): RenderPlan;
 
 /**
@@ -633,4 +645,4 @@ declare function resolveOutputPreset(name: string): OutputPreset;
 /** List all available preset names. */
 declare function listOutputPresets(): string[];
 
-export { ARCH_RULE_PRESETS, type AnnotationDecl, type ArchRuleType, type ArchitecturePreset, type ArchitectureRule, type ArchitectureViolation, BEAT_CUE_KEYWORDS, type BeatDecl, type BeatRange, type Box, CUE_ALIASES, type CardinalPort, type Cue, DIAGRAM_TYPES, type Diagnostic, type DiagramAST, type DiagramDiffResult, type DiagramType, type DiffChangeType, EDGE_OPERATORS, type EdgeDecl, type EdgeDiff, type EdgeKind, type EdgeSelector, type FlowSegment, type GroupBoundary, type GroupDecl, type LayoutDirection, type MarkdyConfig, NODE_ALIASES, NODE_KINDS, type NodeDecl, type NodeDiff, type NodeSelector, type NodeShape, OUTPUT_PRESETS, type OutputPreset, PLAYER_FLAT_KEYS, PLAYER_GROUPS, ParseError, type ParseOptions, type ParseResult, type PatternDecl, type PlayerChromeConfig, type PlayerConfig, type PlayerControlsConfig, type PlayerInteractionConfig, type PlayerOverrides, type PlayerPlaybackConfig, type PlayerProgress, type PlayerScope, type Point, type PositionedNode, type RenderPlan, type RepairPromptBundle, type ResolvedPlayer, type RoutedEdge, type RoutedPath, type RuleSeverity, SCENE_KEYS, type SceneMeta, type SemanticProfile, type SequenceActivation, type SequenceMessage, type StyleDecl, TECHNICAL_NODE_KINDS, TECHNICAL_NODE_TYPES, THEMES, type ThemeGeneratorOptions, type ThemeTokens, type TimedCue, type TreeBus, VISUAL_PRIMITIVE_TYPES, analyzeAndBuildRepairPrompt, applyPlayerSetting, canonicalNodeKind, classifyTechnology, compile, compilePlan, compressMarkdyToUrlHash, decompressMarkdyFromUrlHash, diffDiagramASTs, generateThemeFromBrand, getBoxPortPosition, humanizeId, listOutputPresets, nodeRole, parse, parseAndCompile, resolveArchitectureConfig, resolveOutputPreset, resolvePlayer, resolveTheme, routeOrthogonalEdge, selectOptimalPorts, validateArchitecture };
+export { ARCH_RULE_PRESETS, type AnnotationDecl, type ArchRuleType, type ArchitecturePreset, type ArchitectureRule, type ArchitectureViolation, BEAT_CUE_KEYWORDS, type BeatDecl, type BeatRange, type Box, CUE_ALIASES, type CardinalPort, type Cue, DIAGRAM_TYPES, type Diagnostic, type DiagramAST, type DiagramDiffResult, type DiagramType, type DiffChangeType, EDGE_OPERATORS, type EdgeDecl, type EdgeDiff, type EdgeKind, type EdgeSelector, type FlowSegment, type GroupBoundary, type GroupDecl, type LayoutDirection, type MarkdyConfig, NODE_ALIASES, NODE_KINDS, type NodeDecl, type NodeDiff, type NodeSelector, type NodeShape, OUTPUT_PRESETS, type OutputPreset, PLAYER_FLAT_KEYS, PLAYER_GROUPS, ParseError, type ParseOptions, type ParseResult, type PatternDecl, type PlayerChromeConfig, type PlayerConfig, type PlayerControlsConfig, type PlayerInteractionConfig, type PlayerOverrides, type PlayerPlaybackConfig, type PlayerProgress, type PlayerScope, type Point, type PositionedNode, type RenderPlan, type RepairPromptBundle, type ResolvedPlayer, type RoutedEdge, type RoutedPath, type RuleSeverity, SCENE_KEYS, type SceneMeta, type SemanticProfile, type SequenceActivation, type SequenceMessage, type StyleDecl, TECHNICAL_NODE_KINDS, TECHNICAL_NODE_TYPES, THEMES, type ThemeGeneratorOptions, type ThemeTokens, type TimedCue, type TreeBus, VISUAL_PRIMITIVE_TYPES, analyzeAndBuildRepairPrompt, applyPlayerSetting, canonicalNodeKind, classifyTechnology, compile, compilePlan, compressMarkdyToUrlHash, computeAdaptiveDimensions, decompressMarkdyFromUrlHash, diffDiagramASTs, generateThemeFromBrand, getBoxPortPosition, humanizeId, listOutputPresets, nodeRole, parse, parseAndCompile, resolveArchitectureConfig, resolveOutputPreset, resolvePlayer, resolveTheme, routeOrthogonalEdge, selectOptimalPorts, validateArchitecture };

package/dist/index.js

@@ -630,7 +630,7 @@ function resolvePlayer(config = {}, overrides = {}) {
     svg: resolveControl(configuredControls.svg),
     share: resolveControl(configuredControls.share),
     code: resolveControl(configuredControls.code, false),
-    theme: resolveControl(configuredControls.theme, false)
+    theme: resolveControl(configuredControls.theme, hostControlDefault)
   };
   const interactionOn = overrides.interactiveViewport !== false && (overrides.interactiveViewport === true || config.interaction !== void 0 || overrides.controls === true);
   const gestures = {
@@ -874,8 +874,8 @@ function assignRanks(nodeIds, edges, direction) {
   }
   return ranks;
 }
-function snapGrid(n) {
-  return Math.round(n / 4) * 4;
+function snapGrid(n, step = 4) {
+  return Math.round(n / step) * step;
 }
 function layoutRanked(ast, edges, opts) {
   const nodeIds = Object.keys(ast.nodes);
@@ -895,12 +895,33 @@ function layoutRanked(ast, edges, opts) {
       nodeGroupIndex.set(memberId, gIdx);
     }
   });
-  for (const ids of byRank.values()) {
+  const nodeDeclOrder = new Map(nodeIds.map((id, idx) => [id, idx]));
+  const incomingParents = /* @__PURE__ */ new Map();
+  for (const id of nodeIds) incomingParents.set(id, []);
+  for (const e of edges) {
+    if (e.kind !== "response" && !e.selfLoop && ast.nodes[e.from] && ast.nodes[e.to]) {
+      incomingParents.get(e.to)?.push(e.from);
+    }
+  }
+  const rankOrder = /* @__PURE__ */ new Map();
+  const sortedRanks = [...byRank.keys()].sort((a, b) => a - b);
+  for (const r of sortedRanks) {
+    const ids = byRank.get(r);
     ids.sort((a, b) => {
       const ga = nodeGroupIndex.has(a) ? nodeGroupIndex.get(a) : 9999;
       const gb = nodeGroupIndex.has(b) ? nodeGroupIndex.get(b) : 9999;
       if (ga !== gb) return ga - gb;
-      return a.localeCompare(b);
+      const parentsA = (incomingParents.get(a) ?? []).filter((p) => rankOrder.has(p));
+      const parentsB = (incomingParents.get(b) ?? []).filter((p) => rankOrder.has(p));
+      if (parentsA.length > 0 && parentsB.length > 0) {
+        const avgA = parentsA.reduce((sum, p) => sum + (rankOrder.get(p) ?? 0), 0) / parentsA.length;
+        const avgB = parentsB.reduce((sum, p) => sum + (rankOrder.get(p) ?? 0), 0) / parentsB.length;
+        if (Math.abs(avgA - avgB) > 1e-3) return avgA - avgB;
+      }
+      return (nodeDeclOrder.get(a) ?? 0) - (nodeDeclOrder.get(b) ?? 0);
+    });
+    ids.forEach((id, idx) => {
+      rankOrder.set(id, idx);
     });
   }
   const isVertical = direction === "TB" || direction === "BT";
@@ -1681,7 +1702,7 @@ function layoutNodes(ast, edges) {
   const dtype = diagramType(ast);
   switch (dtype) {
     case "flowchart":
-      return layoutRanked(ast, edges, { forceVertical: true });
+      return layoutRanked(ast, edges, { forceVertical: ast.meta.direction === "TB" || ast.meta.direction === "BT" });
     case "tree":
       return layoutTree(ast, edges.some((edge) => edge.structural) ? edges.filter((edge) => edge.structural) : edges);
     case "sequence":
@@ -1917,8 +1938,171 @@ function buildSequencePlan(ast, cues) {
   });
   return { messages, activations };
 }
+function computeAdaptiveDimensions(ast, edges) {
+  const explicitW = ast.meta.explicitWidth === true;
+  const explicitH = ast.meta.explicitHeight === true;
+  if (explicitW && explicitH) {
+    return { width: ast.meta.width, height: ast.meta.height };
+  }
+  const effectiveEdges = edges ?? collectStructuralEdges(ast);
+  const nodeIds = Object.keys(ast.nodes);
+  const nodeCount = nodeIds.length;
+  const dtype = diagramType(ast);
+  const direction = ast.meta.direction ?? "LR";
+  const isVertical = direction === "TB" || direction === "BT";
+  const groupCount = Object.keys(ast.groups).length;
+  let autoW = 1280;
+  let autoH = 720;
+  if (nodeCount === 0) {
+    autoW = 1280;
+    autoH = 720;
+  } else if (dtype === "sequence") {
+    const flowCues = ast.beats.flatMap((b) => b.cues).filter((c) => c.kind === "flow");
+    const count = Math.max(nodeCount, 1);
+    const flowCount = flowCues.length;
+    const requiredW = SAFE * 2 + Math.max(count * 220, 800);
+    const requiredH = TITLE_BAND + NODE_H + 56 + Math.max(flowCount * 76, 280) + SAFE + 48;
+    autoW = Math.max(1088, Math.min(2560, requiredW));
+    autoH = Math.max(640, Math.min(1800, requiredH));
+  } else if (dtype === "tree") {
+    let measureSubtree2 = function(id) {
+      const kids = children.get(id) ?? [];
+      if (kids.length === 0) {
+        subtreeSpan.set(id, minLeafWidth);
+        return minLeafWidth;
+      }
+      let total = 0;
+      for (const kid of kids) total += measureSubtree2(kid);
+      const span = Math.max(minLeafWidth, total);
+      subtreeSpan.set(id, span);
+      return span;
+    };
+    var measureSubtree = measureSubtree2;
+    const children = /* @__PURE__ */ new Map();
+    const hasParent = /* @__PURE__ */ new Set();
+    for (const id of nodeIds) children.set(id, []);
+    const treeEdges = effectiveEdges.some((e) => e.structural) ? effectiveEdges.filter((e) => e.structural) : effectiveEdges;
+    for (const e of treeEdges) {
+      if (ast.nodes[e.from] && ast.nodes[e.to] && e.from !== e.to) {
+        children.get(e.from)?.push(e.to);
+        hasParent.add(e.to);
+      }
+    }
+    const roots = nodeIds.filter((id) => !hasParent.has(id));
+    const depth = /* @__PURE__ */ new Map();
+    const queue = [...roots];
+    for (const r of roots) depth.set(r, 0);
+    while (queue.length > 0) {
+      const cur = queue.shift();
+      const d = depth.get(cur) ?? 0;
+      for (const child of children.get(cur) ?? []) {
+        if (!depth.has(child)) {
+          depth.set(child, d + 1);
+          queue.push(child);
+        }
+      }
+    }
+    for (const id of nodeIds) if (!depth.has(id)) depth.set(id, 0);
+    const maxDepth = Math.max(...depth.values(), 0);
+    const minLeafWidth = NODE_W + 48;
+    const subtreeSpan = /* @__PURE__ */ new Map();
+    let totalRootsWidth = 0;
+    const activeRoots = roots.length > 0 ? roots : nodeIds;
+    for (const r of activeRoots) totalRootsWidth += measureSubtree2(r);
+    const requiredW = SAFE * 2 + totalRootsWidth;
+    const requiredH = TITLE_BAND + SAFE * 2 + (maxDepth + 1) * 140;
+    autoW = Math.max(1120, Math.min(2560, requiredW));
+    autoH = Math.max(640, Math.min(1600, requiredH));
+  } else if (dtype === "swimlane") {
+    const laneCount = Math.max(groupCount, 1);
+    const maxInLane = Math.max(
+      ...Object.values(ast.groups).map((g) => g.members.length),
+      Math.ceil(nodeCount / laneCount),
+      1
+    );
+    const requiredW = SAFE * 2 + 140 + maxInLane * 220;
+    const requiredH = TITLE_BAND + SAFE * 2 + laneCount * 140;
+    autoW = Math.max(1152, Math.min(2560, requiredW));
+    autoH = Math.max(640, Math.min(1600, requiredH));
+  } else if (dtype === "pyramid") {
+    const tierCount = Math.max(nodeCount, 1);
+    autoW = 1280;
+    const requiredH = TITLE_BAND + SAFE * 2 + tierCount * 110;
+    autoH = Math.max(640, Math.min(1440, requiredH));
+  } else if (dtype === "layers") {
+    const layerCount = Math.max(nodeCount, 1);
+    autoW = 1280;
+    const requiredH = TITLE_BAND + SAFE * 2 + layerCount * 96;
+    autoH = Math.max(640, Math.min(1440, requiredH));
+  } else if (dtype === "timeline" || dtype === "gantt") {
+    const milestones = Math.max(nodeCount, 1);
+    const requiredW = SAFE * 2 + milestones * 240;
+    const requiredH = TITLE_BAND + SAFE * 2 + 380;
+    autoW = Math.max(1200, Math.min(2560, requiredW));
+    autoH = Math.max(640, Math.min(1200, requiredH));
+  } else if (dtype === "loop" || dtype === "flywheel" || dtype === "radar" || dtype === "venn" || dtype === "constellation") {
+    const N = Math.max(nodeCount, 3);
+    const minRadius = 200;
+    const radiusNeeded = Math.max(minRadius, N * 180 / (2 * Math.PI));
+    const requiredW = SAFE * 2 + radiusNeeded * 2 + 240;
+    const requiredH = TITLE_BAND + SAFE * 2 + radiusNeeded * 2 + 140;
+    autoW = Math.max(1088, Math.min(2200, requiredW));
+    autoH = Math.max(720, Math.min(1600, requiredH));
+  } else if (dtype === "quadrant") {
+    autoW = 1200;
+    autoH = 800;
+  } else {
+    const forceVertical = dtype === "flowchart" && isVertical || isVertical;
+    const ranks = assignRanks(nodeIds, effectiveEdges, forceVertical ? "TB" : "LR");
+    const byRank = /* @__PURE__ */ new Map();
+    for (const id of nodeIds) {
+      const r = ranks.get(id) ?? 0;
+      if (!byRank.has(r)) byRank.set(r, []);
+      byRank.get(r).push(id);
+    }
+    const rankCount = Math.max(...byRank.keys(), 0) + 1;
+    const maxInRank = Math.max(...[...byRank.values()].map((v) => v.length), 1);
+    const groupPaddingBonus = groupCount > 0 ? GROUP_PAD * 2 : 0;
+    if (forceVertical) {
+      const requiredW = SAFE * 2 + maxInRank * NODE_W + (maxInRank - 1) * 44 + groupPaddingBonus;
+      const requiredH = SAFE * 2 + TITLE_BAND + rankCount * NODE_H + (rankCount - 1) * 56 + groupPaddingBonus;
+      if (nodeCount <= 2) {
+        autoW = 960;
+        autoH = 640;
+      } else if (nodeCount <= 4 && rankCount <= 3) {
+        autoW = 1024;
+        autoH = 720;
+      } else {
+        autoW = Math.max(960, Math.min(2400, requiredW));
+        autoH = Math.max(720, Math.min(2e3, requiredH));
+      }
+    } else {
+      const requiredW = SAFE * 2 + rankCount * NODE_W + (rankCount - 1) * 44 + groupPaddingBonus;
+      const requiredH = SAFE * 2 + TITLE_BAND + maxInRank * NODE_H + (maxInRank - 1) * 36 + groupPaddingBonus;
+      if (nodeCount <= 2 && rankCount <= 2) {
+        autoW = 1024;
+        autoH = 576;
+      } else if (nodeCount <= 4 && rankCount <= 3 && maxInRank <= 2) {
+        autoW = 1152;
+        autoH = 648;
+      } else {
+        autoW = Math.max(1152, Math.min(2560, requiredW));
+        autoH = Math.max(648, Math.min(1600, requiredH));
+      }
+    }
+  }
+  return {
+    width: explicitW ? ast.meta.width : snapGrid(autoW, 16),
+    height: explicitH ? ast.meta.height : snapGrid(autoH, 16)
+  };
+}
 function compilePlan(ast, theme) {
   const structuralEdges = collectStructuralEdges(ast);
+  if (!ast.meta.explicitWidth || !ast.meta.explicitHeight) {
+    const dims = computeAdaptiveDimensions(ast, structuralEdges);
+    if (!ast.meta.explicitWidth) ast.meta.width = dims.width;
+    if (!ast.meta.explicitHeight) ast.meta.height = dims.height;
+  }
   const nodes = layoutNodes(ast, structuralEdges);
   const groupBoundaries = computeGroupBoundaries(ast, nodes);
   const treeBuses = computeTreeBuses(ast, nodes, structuralEdges.filter((edge) => edge.structural));
@@ -2965,8 +3149,15 @@ function parse(source, opts = {}) {
           diagnostics.push({ severity: "warning", message: `unknown scene property '${k}'`, line: lineNo });
           continue;
         }
-        if (k === "width" || k === "height" || k === "fps") meta[k] = Number(v);
-        else if (k === "duration") meta.duration = Number(v);
+        if (k === "width") {
+          meta.width = Number(v);
+          meta.explicitWidth = true;
+        } else if (k === "height") {
+          meta.height = Number(v);
+          meta.explicitHeight = true;
+        } else if (k === "fps") {
+          meta.fps = Number(v);
+        } else if (k === "duration") meta.duration = Number(v);
         else if (k === "theme") meta.theme = String(v);
         else if (k === "direction" || k === "layout") meta.direction = String(v).toUpperCase();
         else if (PLAYER_FLAT_KEY_SET.has(k)) {
@@ -2978,6 +3169,9 @@ function parse(source, opts = {}) {
             diagnostics.push({ severity: "warning", message: `unknown diagram type '${v}'`, line: lineNo });
           } else {
             meta.type = t;
+            if (t === "flowchart" && !props.direction && !props.layout && !inlineLayout) {
+              meta.direction = "TB";
+            }
           }
         }
       }
@@ -4246,6 +4440,7 @@ export {
   compile,
   compilePlan,
   compressMarkdyToUrlHash,
+  computeAdaptiveDimensions,
   decompressMarkdyFromUrlHash,
   diffDiagramASTs,
   generateThemeFromBrand,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@markdy/core",
-  "version": "1.0.19",
+  "version": "1.0.21",
   "description": "Diagram-native MarkdyScript parser and compiler (auto-layout, edge routing, cue scheduling) — zero runtime dependencies.",
   "license": "MIT",
   "type": "module",