@markdy/core 0.8.20 → 0.8.21

package/dist/index.js

@@ -44,6 +44,7 @@ var TECHNICAL_NODE_TYPES = [
   "warehouse",
   "lake",
   "object_store",
+  "storage",
   "bucket",
   "blob",
   "volume",
@@ -117,6 +118,7 @@ var TECHNICAL_NODE_TYPES = [
   "secret",
   "key",
   "certificate",
+  "security",
   "repo",
   "branch",
   "commit",
@@ -147,6 +149,12 @@ var TECHNICAL_NODE_TYPES = [
   "loop",
   "sequence",
   "participant",
+  "hub",
+  "station",
+  "bronze",
+  "silver",
+  "gold",
+  "lane",
   "replica",
   "shard",
   "leader",
@@ -176,7 +184,9 @@ var VISUAL_PRIMITIVE_TYPES = [
   "token_strip",
   "chips",
   "glyph_card",
-  "glyph"
+  "glyph",
+  "external",
+  "optional"
 ];
 var VISUAL_PRIMITIVE_KINDS = {
   panel: "flow",
@@ -193,7 +203,9 @@ var VISUAL_PRIMITIVE_KINDS = {
   token_strip: "flow",
   chips: "flow",
   glyph_card: "flow",
-  glyph: "flow"
+  glyph: "flow",
+  external: "network",
+  optional: "flow"
 };
 var TECHNICAL_NODE_KINDS = {
   service: "compute",
@@ -246,6 +258,7 @@ var TECHNICAL_NODE_KINDS = {
   warehouse: "data",
   lake: "data",
   object_store: "data",
+  storage: "data",
   bucket: "data",
   blob: "data",
   volume: "data",
@@ -319,6 +332,7 @@ var TECHNICAL_NODE_KINDS = {
   secret: "security",
   key: "security",
   certificate: "security",
+  security: "security",
   repo: "delivery",
   branch: "delivery",
   commit: "delivery",
@@ -349,6 +363,12 @@ var TECHNICAL_NODE_KINDS = {
   loop: "flow",
   sequence: "flow",
   participant: "flow",
+  hub: "data",
+  station: "compute",
+  bronze: "data",
+  silver: "data",
+  gold: "data",
+  lane: "flow",
   replica: "distributed",
   shard: "distributed",
   leader: "distributed",
@@ -369,7 +389,19 @@ var DIAGRAM_TYPES = /* @__PURE__ */ new Set([
   "tree",
   "state",
   "sequence",
-  "constellation"
+  "constellation",
+  "loop",
+  "flywheel",
+  "medallion",
+  "quadrant",
+  "swimlane",
+  "pyramid",
+  "radar",
+  "timeline",
+  "gantt",
+  "venn",
+  "layers",
+  "nested"
 ]);
 var EDGE_OPERATORS = {
   "->": "request",
@@ -747,6 +779,470 @@ function layoutConstellation(ast) {
   }
   return nodes;
 }
+function layoutLoop(ast) {
+  const nodeIds = Object.keys(ast.nodes);
+  if (nodeIds.length === 0) return [];
+  const hubId = nodeIds.find((id) => {
+    const decl = ast.nodes[id];
+    return decl.kind === "hub" || decl.props.hub === true || /^(hub|state|memory|shared_memory|core)$/i.test(id);
+  }) ?? nodeIds[0];
+  const stationIds = nodeIds.filter((id) => id !== hubId);
+  const contentW = ast.meta.width - SAFE * 2;
+  const contentH = ast.meta.height - SAFE - TITLE_BAND - SAFE;
+  const centerX = SAFE + contentW / 2;
+  const centerY = TITLE_BAND + contentH / 2;
+  const radiusX = Math.max(140, contentW / 2 - NODE_W / 2 - SAFE);
+  const radiusY = Math.max(120, contentH / 2 - NODE_H / 2 - SAFE);
+  const nodes = [];
+  for (const id of nodeIds) {
+    const decl = ast.nodes[id];
+    const isHub = id === hubId;
+    let x;
+    let y;
+    if (isHub) {
+      x = centerX - NODE_W * 1.2 / 2;
+      y = centerY - NODE_H * 1.1 / 2;
+    } else {
+      const idx = stationIds.indexOf(id);
+      const angle = -Math.PI / 2 + idx * 2 * Math.PI / Math.max(stationIds.length, 1);
+      x = centerX + Math.cos(angle) * radiusX - NODE_W / 2;
+      y = centerY + Math.sin(angle) * radiusY - NODE_H / 2;
+    }
+    const focal = isHub || decl.props.focal === true || decl.props.accent === true;
+    nodes.push({
+      id,
+      kind: decl.kind,
+      role: nodeRole(decl.kind),
+      label: decl.label,
+      x: snapGrid(x),
+      y: snapGrid(y),
+      width: isHub ? snapGrid(NODE_W * 1.2) : NODE_W,
+      height: isHub ? snapGrid(NODE_H * 1.1) : NODE_H,
+      style: decl.style ? ast.styles[decl.style]?.props : void 0,
+      props: decl.props,
+      opacity: 0,
+      shape: isHub ? "pill" : "card",
+      focal
+    });
+  }
+  return nodes;
+}
+function layoutMedallion(ast, edges) {
+  const nodeIds = Object.keys(ast.nodes);
+  if (nodeIds.length === 0) return [];
+  function getMedallionTier(id, kind) {
+    const combined = `${id} ${kind}`.toLowerCase();
+    if (kind === "bronze" || combined.includes("bronze") || combined.includes("raw") || combined.includes("landing")) return 1;
+    if (kind === "silver" || combined.includes("silver") || combined.includes("clean") || combined.includes("curated") || combined.includes("conformed")) return 2;
+    if (kind === "gold" || combined.includes("gold") || combined.includes("agg") || combined.includes("mart") || combined.includes("analytics")) return 3;
+    if (combined.includes("bi") || combined.includes("dash") || combined.includes("model") || combined.includes("app") || combined.includes("consumer") || combined.includes("user") || combined.includes("client")) return 4;
+    return 0;
+  }
+  const tiers = /* @__PURE__ */ new Map();
+  for (let i = 0; i <= 4; i++) tiers.set(i, []);
+  for (const id of nodeIds) {
+    const decl = ast.nodes[id];
+    const tier = getMedallionTier(id, decl.kind);
+    tiers.get(tier).push(id);
+  }
+  const activeTiers = [...tiers.entries()].filter(([_, ids]) => ids.length > 0);
+  const tierCount = activeTiers.length || 1;
+  const contentW = ast.meta.width - SAFE * 2;
+  const contentH = ast.meta.height - SAFE - TITLE_BAND - SAFE;
+  const nodes = [];
+  activeTiers.forEach(([_, ids], colIdx) => {
+    const colCount = ids.length;
+    const colX = SAFE + contentW / (tierCount + 1) * (colIdx + 1) - NODE_W / 2;
+    ids.forEach((id, rowIdx) => {
+      const decl = ast.nodes[id];
+      const rowY = TITLE_BAND + contentH / (colCount + 1) * (rowIdx + 1) - NODE_H / 2;
+      const focal = decl.props.focal === true || decl.props.accent === true;
+      nodes.push({
+        id,
+        kind: decl.kind,
+        role: nodeRole(decl.kind),
+        label: decl.label,
+        x: snapGrid(colX),
+        y: snapGrid(rowY),
+        width: NODE_W,
+        height: NODE_H,
+        style: decl.style ? ast.styles[decl.style]?.props : void 0,
+        props: decl.props,
+        opacity: 0,
+        shape: "card",
+        focal
+      });
+    });
+  });
+  return nodes;
+}
+function layoutQuadrant(ast) {
+  const nodeIds = Object.keys(ast.nodes);
+  if (nodeIds.length === 0) return [];
+  const contentW = ast.meta.width - SAFE * 2;
+  const contentH = ast.meta.height - SAFE - TITLE_BAND - SAFE;
+  const centerX = SAFE + contentW / 2;
+  const centerY = TITLE_BAND + contentH / 2;
+  const quadNodes = /* @__PURE__ */ new Map([
+    [1, []],
+    [2, []],
+    [3, []],
+    [4, []]
+  ]);
+  nodeIds.forEach((id, idx) => {
+    const decl = ast.nodes[id];
+    let q = 1;
+    if (decl.props.quadrant) {
+      const qVal = String(decl.props.quadrant).toUpperCase();
+      if (qVal === "Q1" || qVal === "1" || qVal === "TOP_RIGHT") q = 1;
+      else if (qVal === "Q2" || qVal === "2" || qVal === "TOP_LEFT") q = 2;
+      else if (qVal === "Q3" || qVal === "3" || qVal === "BOTTOM_LEFT") q = 3;
+      else if (qVal === "Q4" || qVal === "4" || qVal === "BOTTOM_RIGHT") q = 4;
+    } else {
+      q = idx % 4 + 1;
+    }
+    quadNodes.get(q).push(id);
+  });
+  const nodes = [];
+  const quadCenters = {
+    1: { x: centerX + contentW / 4, y: centerY - contentH / 4 },
+    2: { x: centerX - contentW / 4, y: centerY - contentH / 4 },
+    3: { x: centerX - contentW / 4, y: centerY + contentH / 4 },
+    4: { x: centerX + contentW / 4, y: centerY + contentH / 4 }
+  };
+  for (const [qNum, ids] of quadNodes) {
+    const center = quadCenters[qNum];
+    ids.forEach((id, idx) => {
+      const decl = ast.nodes[id];
+      const offsetCount = ids.length;
+      const rowOffset = (idx - (offsetCount - 1) / 2) * (NODE_H + 16);
+      const x = center.x - NODE_W / 2;
+      const y = center.y + rowOffset - NODE_H / 2;
+      const focal = decl.props.focal === true || decl.props.accent === true;
+      nodes.push({
+        id,
+        kind: decl.kind,
+        role: nodeRole(decl.kind),
+        label: decl.label,
+        x: snapGrid(x),
+        y: snapGrid(y),
+        width: NODE_W,
+        height: NODE_H,
+        style: decl.style ? ast.styles[decl.style]?.props : void 0,
+        props: decl.props,
+        opacity: 0,
+        shape: "card",
+        focal
+      });
+    });
+  }
+  return nodes;
+}
+function layoutSwimlane(ast, edges) {
+  const nodeIds = Object.keys(ast.nodes);
+  if (nodeIds.length === 0) return [];
+  const lanes = /* @__PURE__ */ new Map();
+  const groupKeys = Object.keys(ast.groups);
+  if (groupKeys.length > 0) {
+    for (const gId of groupKeys) {
+      const members = ast.groups[gId].members.filter((id) => ast.nodes[id]);
+      if (members.length > 0) lanes.set(gId, members);
+    }
+  } else {
+    for (const id of nodeIds) {
+      const decl = ast.nodes[id];
+      const role = nodeRole(decl.kind);
+      if (!lanes.has(role)) lanes.set(role, []);
+      lanes.get(role).push(id);
+    }
+  }
+  const activeLanes = [...lanes.entries()].filter(([_, ids]) => ids.length > 0);
+  const laneCount = activeLanes.length || 1;
+  const contentW = ast.meta.width - SAFE * 2;
+  const contentH = ast.meta.height - SAFE - TITLE_BAND - SAFE;
+  const laneHeight = contentH / laneCount;
+  const nodes = [];
+  activeLanes.forEach(([_, ids], laneIdx) => {
+    const laneY = TITLE_BAND + laneIdx * laneHeight + (laneHeight - NODE_H) / 2;
+    const count = ids.length;
+    ids.forEach((id, colIdx) => {
+      const decl = ast.nodes[id];
+      const colX = SAFE + contentW / (count + 1) * (colIdx + 1) - NODE_W / 2;
+      const focal = decl.props.focal === true || decl.props.accent === true;
+      nodes.push({
+        id,
+        kind: decl.kind,
+        role: nodeRole(decl.kind),
+        label: decl.label,
+        x: snapGrid(colX),
+        y: snapGrid(laneY),
+        width: NODE_W,
+        height: NODE_H,
+        style: decl.style ? ast.styles[decl.style]?.props : void 0,
+        props: decl.props,
+        opacity: 0,
+        shape: "card",
+        focal
+      });
+    });
+  });
+  return nodes;
+}
+function layoutPyramid(ast) {
+  const nodeIds = Object.keys(ast.nodes);
+  if (nodeIds.length === 0) return [];
+  const ranks = /* @__PURE__ */ new Map();
+  nodeIds.forEach((id, idx) => {
+    const decl = ast.nodes[id];
+    const tier = typeof decl.props.tier === "number" ? decl.props.tier : typeof decl.props.level === "number" ? decl.props.level : idx;
+    if (!ranks.has(tier)) ranks.set(tier, []);
+    ranks.get(tier).push(id);
+  });
+  const sortedTiers = [...ranks.entries()].sort((a, b) => a[0] - b[0]);
+  const tierCount = sortedTiers.length || 1;
+  const contentW = ast.meta.width - SAFE * 2;
+  const contentH = ast.meta.height - SAFE - TITLE_BAND - SAFE;
+  const nodes = [];
+  sortedTiers.forEach(([_, ids], tierIdx) => {
+    const tierY = TITLE_BAND + contentH / (tierCount + 1) * (tierIdx + 1) - NODE_H / 2;
+    const spreadFraction = 0.4 + 0.6 * tierIdx / Math.max(tierCount - 1, 1);
+    const tierWidth = contentW * spreadFraction;
+    const tierStartX = SAFE + (contentW - tierWidth) / 2;
+    const count = ids.length;
+    ids.forEach((id, idx) => {
+      const decl = ast.nodes[id];
+      const x = tierStartX + tierWidth / (count + 1) * (idx + 1) - NODE_W / 2;
+      const focal = decl.props.focal === true || decl.props.accent === true;
+      nodes.push({
+        id,
+        kind: decl.kind,
+        role: nodeRole(decl.kind),
+        label: decl.label,
+        x: snapGrid(x),
+        y: snapGrid(tierY),
+        width: NODE_W,
+        height: NODE_H,
+        style: decl.style ? ast.styles[decl.style]?.props : void 0,
+        props: decl.props,
+        opacity: 0,
+        shape: "card",
+        focal
+      });
+    });
+  });
+  return nodes;
+}
+function layoutTimeline(ast) {
+  const nodeIds = Object.keys(ast.nodes);
+  if (nodeIds.length === 0) return [];
+  const contentW = ast.meta.width - SAFE * 2;
+  const contentH = ast.meta.height - SAFE - TITLE_BAND - SAFE;
+  const baselineY = TITLE_BAND + contentH / 2;
+  const spacing = contentW / Math.max(nodeIds.length, 1);
+  const nodes = [];
+  nodeIds.forEach((id, idx) => {
+    const decl = ast.nodes[id];
+    const x = SAFE + spacing * idx + (spacing - NODE_W) / 2;
+    const above = idx % 2 === 0;
+    const y = above ? baselineY - NODE_H - 24 : baselineY + 24;
+    const focal = decl.props.focal === true || decl.props.accent === true;
+    nodes.push({
+      id,
+      kind: decl.kind,
+      role: nodeRole(decl.kind),
+      label: decl.label,
+      x: snapGrid(x),
+      y: snapGrid(y),
+      width: NODE_W,
+      height: NODE_H,
+      style: decl.style ? ast.styles[decl.style]?.props : void 0,
+      props: decl.props,
+      opacity: 0,
+      shape: "pill",
+      focal
+    });
+  });
+  return nodes;
+}
+function layoutGantt(ast) {
+  const nodeIds = Object.keys(ast.nodes);
+  if (nodeIds.length === 0) return [];
+  const contentW = ast.meta.width - SAFE * 2;
+  const rowH = 56;
+  const barH = 40;
+  const nodes = [];
+  nodeIds.forEach((id, idx) => {
+    const decl = ast.nodes[id];
+    const phase = typeof decl.props.phase === "number" ? decl.props.phase : 0;
+    const span = typeof decl.props.span === "number" ? decl.props.span : 1;
+    const totalPhases = Math.max(...nodeIds.map((nid) => {
+      const p = ast.nodes[nid].props.phase;
+      const s = ast.nodes[nid].props.span;
+      return (typeof p === "number" ? p : 0) + (typeof s === "number" ? s : 1);
+    }), 1);
+    const unitW = contentW / totalPhases;
+    const x = SAFE + phase * unitW;
+    const w = Math.max(span * unitW - 8, NODE_W);
+    const y = TITLE_BAND + idx * rowH + (rowH - barH) / 2;
+    const focal = decl.props.focal === true || decl.props.accent === true;
+    nodes.push({
+      id,
+      kind: decl.kind,
+      role: nodeRole(decl.kind),
+      label: decl.label,
+      x: snapGrid(x),
+      y: snapGrid(y),
+      width: snapGrid(w),
+      height: barH,
+      style: decl.style ? ast.styles[decl.style]?.props : void 0,
+      props: decl.props,
+      opacity: 0,
+      shape: "pill",
+      focal
+    });
+  });
+  return nodes;
+}
+function layoutVenn(ast) {
+  const nodeIds = Object.keys(ast.nodes);
+  if (nodeIds.length === 0) return [];
+  const contentW = ast.meta.width - SAFE * 2;
+  const contentH = ast.meta.height - SAFE - TITLE_BAND - SAFE;
+  const centerX = SAFE + contentW / 2;
+  const centerY = TITLE_BAND + contentH / 2;
+  const N = nodeIds.length;
+  const radius = Math.min(contentW, contentH) * 0.22;
+  const nodes = [];
+  nodeIds.forEach((id, idx) => {
+    const decl = ast.nodes[id];
+    let x, y;
+    if (N === 2) {
+      x = centerX + (idx === 0 ? -radius * 0.55 : radius * 0.55) - NODE_W / 2;
+      y = centerY - NODE_H / 2;
+    } else {
+      const angle = -Math.PI / 2 + idx * 2 * Math.PI / N;
+      x = centerX + radius * 0.6 * Math.cos(angle) - NODE_W / 2;
+      y = centerY + radius * 0.6 * Math.sin(angle) - NODE_H / 2;
+    }
+    const focal = decl.props.focal === true || decl.props.accent === true;
+    nodes.push({
+      id,
+      kind: decl.kind,
+      role: nodeRole(decl.kind),
+      label: decl.label,
+      x: snapGrid(x),
+      y: snapGrid(y),
+      width: NODE_W,
+      height: NODE_H,
+      style: decl.style ? ast.styles[decl.style]?.props : void 0,
+      props: decl.props,
+      opacity: 0,
+      shape: "circle",
+      focal
+    });
+  });
+  return nodes;
+}
+function layoutLayers(ast) {
+  const nodeIds = Object.keys(ast.nodes);
+  if (nodeIds.length === 0) return [];
+  const contentW = ast.meta.width - SAFE * 2;
+  const contentH = ast.meta.height - SAFE - TITLE_BAND - SAFE;
+  const N = nodeIds.length;
+  const layerH = Math.min(Math.max((contentH - (N - 1) * 12) / N, 52), 76);
+  const totalH = N * layerH + (N - 1) * 12;
+  const startY = TITLE_BAND + (contentH - totalH) / 2;
+  const nodes = [];
+  nodeIds.forEach((id, idx) => {
+    const decl = ast.nodes[id];
+    const y = startY + idx * (layerH + 12);
+    const focal = decl.props.focal === true || decl.props.accent === true;
+    nodes.push({
+      id,
+      kind: decl.kind,
+      role: nodeRole(decl.kind),
+      label: decl.label,
+      x: snapGrid(SAFE),
+      y: snapGrid(y),
+      width: snapGrid(contentW),
+      height: snapGrid(layerH),
+      style: decl.style ? ast.styles[decl.style]?.props : void 0,
+      props: decl.props,
+      opacity: 0,
+      shape: "rounded",
+      focal
+    });
+  });
+  return nodes;
+}
+function layoutNested(ast) {
+  const nodeIds = Object.keys(ast.nodes);
+  if (nodeIds.length === 0) return [];
+  const contentW = ast.meta.width - SAFE * 2;
+  const contentH = ast.meta.height - SAFE - TITLE_BAND - SAFE;
+  const N = nodeIds.length;
+  const padX = Math.min(36, contentW * 0.4 / N);
+  const padY = Math.min(32, contentH * 0.4 / N);
+  const nodes = [];
+  nodeIds.forEach((id, idx) => {
+    const decl = ast.nodes[id];
+    const x = SAFE + idx * padX;
+    const y = TITLE_BAND + idx * padY;
+    const w = contentW - idx * padX * 2;
+    const h = contentH - idx * padY * 2;
+    const focal = decl.props.focal === true || decl.props.accent === true || idx === N - 1;
+    nodes.push({
+      id,
+      kind: decl.kind,
+      role: nodeRole(decl.kind),
+      label: decl.label,
+      x: snapGrid(x),
+      y: snapGrid(y),
+      width: snapGrid(w),
+      height: snapGrid(h),
+      style: decl.style ? ast.styles[decl.style]?.props : void 0,
+      props: decl.props,
+      opacity: 0,
+      shape: "rounded",
+      focal
+    });
+  });
+  return nodes;
+}
+function layoutRadar(ast) {
+  const nodeIds = Object.keys(ast.nodes);
+  if (nodeIds.length === 0) return [];
+  const contentW = ast.meta.width - SAFE * 2;
+  const contentH = ast.meta.height - SAFE - TITLE_BAND - SAFE;
+  const centerX = SAFE + contentW / 2;
+  const centerY = TITLE_BAND + contentH / 2;
+  const radius = Math.min(contentW, contentH) * 0.38;
+  const N = Math.max(nodeIds.length, 3);
+  const nodes = [];
+  nodeIds.forEach((id, idx) => {
+    const decl = ast.nodes[id];
+    const angle = -Math.PI / 2 + idx * 2 * Math.PI / N;
+    const x = centerX + radius * Math.cos(angle) - NODE_W / 2;
+    const y = centerY + radius * Math.sin(angle) - NODE_H / 2;
+    const focal = decl.props.focal === true || decl.props.accent === true;
+    nodes.push({
+      id,
+      kind: decl.kind,
+      role: nodeRole(decl.kind),
+      label: decl.label,
+      x: snapGrid(x),
+      y: snapGrid(y),
+      width: NODE_W,
+      height: NODE_H,
+      style: decl.style ? ast.styles[decl.style]?.props : void 0,
+      props: decl.props,
+      opacity: 0,
+      shape: "rounded",
+      focal
+    });
+  });
+  return nodes;
+}
 function layoutNodes(ast, edges) {
   const dtype = diagramType(ast);
   switch (dtype) {
@@ -758,6 +1254,29 @@ function layoutNodes(ast, edges) {
       return layoutRanked(ast, [], { columnLayout: true });
     case "constellation":
       return layoutConstellation(ast);
+    case "loop":
+    case "flywheel":
+      return layoutLoop(ast);
+    case "medallion":
+      return layoutMedallion(ast, edges);
+    case "quadrant":
+      return layoutQuadrant(ast);
+    case "swimlane":
+      return layoutSwimlane(ast, edges);
+    case "pyramid":
+      return layoutPyramid(ast);
+    case "radar":
+      return layoutRadar(ast);
+    case "timeline":
+      return layoutTimeline(ast);
+    case "gantt":
+      return layoutGantt(ast);
+    case "venn":
+      return layoutVenn(ast);
+    case "layers":
+      return layoutLayers(ast);
+    case "nested":
+      return layoutNested(ast);
     case "state":
       return layoutRanked(ast, cycleSafeEdges(Object.keys(ast.nodes), edges), { forceVertical: false });
     default:
@@ -1063,7 +1582,8 @@ var THEMES = {
     shadow: "rgba(15, 23, 42, 0.14)",
     labelPlate: "#ffffff",
     roles: { ...ROLE_COLORS },
-    edges: { ...EDGE_COLORS }
+    edges: { ...EDGE_COLORS },
+    series: ["#7c8f6f", "#5e7a9b", "#b8915a", "#9c6b50", "#6e6479"]
   },
   blueprint: {
     name: "blueprint",
@@ -1143,7 +1663,8 @@ var THEMES = {
       mono: "ui-monospace, SFMono-Regular, Menlo, monospace"
     },
     radiusMd: 6,
-    spacing: { xs: 4, sm: 8, md: 16, lg: 24, xl: 40 }
+    spacing: { xs: 4, sm: 8, md: 16, lg: 24, xl: 40 },
+    series: ["#7c8f6f", "#5e7a9b", "#b8915a", "#9c6b50", "#6e6479"]
   },
   nebula: {
     name: "nebula",
@@ -1190,6 +1711,97 @@ var THEMES = {
     },
     radiusMd: 12,
     spacing: { xs: 4, sm: 8, md: 16, lg: 24, xl: 40 }
+  },
+  terminal: {
+    name: "terminal",
+    canvas: "#0a0a0a",
+    surface: "#141414",
+    surfaceRaised: "#1e1e1e",
+    border: "#2b2b2b",
+    text: "#f5f5f5",
+    textMuted: "#9a9a9a",
+    paper: "#141414",
+    ink: "#f5f5f5",
+    muted: "#9a9a9a",
+    rule: "#2b2b2b",
+    soft: "#5c5c5c",
+    link: "#ff5a36",
+    gridMinor: "rgba(255, 255, 255, 0.04)",
+    gridMajor: "rgba(255, 255, 255, 0.08)",
+    vignette: "rgba(0, 0, 0, 0.8)",
+    accent: "#ff5a36",
+    accentTint: "rgba(255, 90, 54, 0.15)",
+    nodeSurface: "#141414",
+    nodeSurfaceRaised: "#222222",
+    hairline: "#333333",
+    shadow: "rgba(0, 0, 0, 0.8)",
+    labelPlate: "#141414",
+    flatCards: true,
+    roles: {
+      ...ROLE_COLORS,
+      compute: "#ff5a36",
+      client: "#f5f5f5",
+      data: "#9a9a9a",
+      network: "#38bdf8"
+    },
+    edges: {
+      request: "#ff5a36",
+      response: "#9a9a9a",
+      event: "#facc15",
+      dependency: "#5c5c5c"
+    },
+    fonts: {
+      title: "ui-monospace, SFMono-Regular, Menlo, monospace",
+      nodeName: "ui-monospace, SFMono-Regular, Menlo, monospace",
+      mono: "ui-monospace, SFMono-Regular, Menlo, monospace"
+    },
+    radiusMd: 6,
+    spacing: { xs: 4, sm: 8, md: 16, lg: 24, xl: 40 }
+  },
+  sketchy: {
+    name: "sketchy",
+    canvas: "#fbfaf8",
+    surface: "#ffffff",
+    surfaceRaised: "#f6f3eb",
+    border: "#2d3142",
+    text: "#2d3142",
+    textMuted: "#4f5d75",
+    paper: "#fbfaf8",
+    ink: "#2d3142",
+    muted: "#4f5d75",
+    rule: "rgba(45, 49, 66, 0.18)",
+    soft: "#7a8399",
+    link: "#eb6c36",
+    gridMinor: "rgba(45, 49, 66, 0.05)",
+    gridMajor: "rgba(45, 49, 66, 0.08)",
+    vignette: "rgba(0, 0, 0, 0.06)",
+    accent: "#eb6c36",
+    accentTint: "rgba(235, 108, 54, 0.10)",
+    nodeSurface: "#ffffff",
+    nodeSurfaceRaised: "#fbfaf8",
+    hairline: "rgba(45, 49, 66, 0.35)",
+    shadow: "rgba(45, 49, 66, 0.08)",
+    labelPlate: "#ffffff",
+    flatCards: true,
+    roles: {
+      ...ROLE_COLORS,
+      compute: "#2d3142",
+      client: "#4f5d75",
+      data: "#4f5d75"
+    },
+    edges: {
+      request: "#2d3142",
+      response: "#4f5d75",
+      event: "#eb6c36",
+      dependency: "#7a8399"
+    },
+    fonts: {
+      title: "Georgia, Times New Roman, serif",
+      nodeName: "ui-sans-serif, system-ui, sans-serif",
+      mono: "ui-monospace, SFMono-Regular, Menlo, monospace"
+    },
+    radiusMd: 4,
+    spacing: { xs: 4, sm: 8, md: 16, lg: 24, xl: 40 }
   }
 };
 function resolveTheme(name) {
@@ -2117,25 +2729,1030 @@ function parseAndCompile(source) {
   const plan = compile(ast);
   return { ast, plan };
 }
+
+// src/theme-generator.ts
+function hexToRgb(hex) {
+  let cleaned = hex.replace(/^#/, "").trim();
+  if (cleaned.length === 3) {
+    cleaned = cleaned.split("").map((c) => c + c).join("");
+  }
+  const num = parseInt(cleaned, 16);
+  return {
+    r: num >> 16 & 255,
+    g: num >> 8 & 255,
+    b: num & 255
+  };
+}
+function rgbToHsl(r, g, b) {
+  r /= 255;
+  g /= 255;
+  b /= 255;
+  const max = Math.max(r, g, b);
+  const min = Math.min(r, g, b);
+  let h = 0;
+  let s = 0;
+  const l = (max + min) / 2;
+  if (max !== min) {
+    const d = max - min;
+    s = l > 0.5 ? d / (2 - max - min) : d / (max + min);
+    switch (max) {
+      case r:
+        h = (g - b) / d + (g < b ? 6 : 0);
+        break;
+      case g:
+        h = (b - r) / d + 2;
+        break;
+      case b:
+        h = (r - g) / d + 4;
+        break;
+    }
+    h /= 6;
+  }
+  return {
+    h: Math.round(h * 360),
+    s: Math.round(s * 100),
+    l: Math.round(l * 100)
+  };
+}
+function hslToHex(h, s, l) {
+  h = (h % 360 + 360) % 360;
+  s = Math.max(0, Math.min(100, s)) / 100;
+  l = Math.max(0, Math.min(100, l)) / 100;
+  const c = (1 - Math.abs(2 * l - 1)) * s;
+  const x = c * (1 - Math.abs(h / 60 % 2 - 1));
+  const m = l - c / 2;
+  let r = 0, g = 0, b = 0;
+  if (0 <= h && h < 60) {
+    r = c;
+    g = x;
+    b = 0;
+  } else if (60 <= h && h < 120) {
+    r = x;
+    g = c;
+    b = 0;
+  } else if (120 <= h && h < 180) {
+    r = 0;
+    g = c;
+    b = x;
+  } else if (180 <= h && h < 240) {
+    r = 0;
+    g = x;
+    b = c;
+  } else if (240 <= h && h < 300) {
+    r = x;
+    g = 0;
+    b = c;
+  } else if (300 <= h && h < 360) {
+    r = c;
+    g = 0;
+    b = x;
+  }
+  const toHex = (n) => {
+    const val = Math.round((n + m) * 255);
+    return val.toString(16).padStart(2, "0");
+  };
+  return `#${toHex(r)}${toHex(g)}${toHex(b)}`;
+}
+function generateThemeFromBrand(opts) {
+  const isDark = opts.mode === "dark";
+  const { r, g, b } = hexToRgb(opts.accentHex);
+  const hsl = rgbToHsl(r, g, b);
+  const canvas = opts.canvasHex ?? (isDark ? hslToHex(hsl.h, 16, 8) : hslToHex(hsl.h, 18, 97));
+  const surface = isDark ? hslToHex(hsl.h, 14, 13) : hslToHex(hsl.h, 20, 100);
+  const surfaceRaised = isDark ? hslToHex(hsl.h, 14, 18) : hslToHex(hsl.h, 22, 94);
+  const border = isDark ? hslToHex(hsl.h, 12, 24) : hslToHex(hsl.h, 14, 86);
+  const text = opts.inkHex ?? (isDark ? hslToHex(hsl.h, 10, 94) : hslToHex(hsl.h, 24, 12));
+  const textMuted = isDark ? hslToHex(hsl.h, 10, 62) : hslToHex(hsl.h, 14, 42);
+  const gridMinor = isDark ? "rgba(255, 255, 255, 0.04)" : "rgba(0, 0, 0, 0.04)";
+  const gridMajor = isDark ? "rgba(255, 255, 255, 0.08)" : "rgba(0, 0, 0, 0.08)";
+  const vignette = isDark ? "rgba(0, 0, 0, 0.45)" : "rgba(0, 0, 0, 0.06)";
+  const accent = opts.accentHex;
+  const accentTint = isDark ? `rgba(${r}, ${g}, ${b}, 0.18)` : `rgba(${r}, ${g}, ${b}, 0.08)`;
+  const soft = isDark ? hslToHex(hsl.h, 10, 48) : hslToHex(hsl.h, 12, 58);
+  const rule = border;
+  return {
+    name: opts.name,
+    canvas,
+    surface,
+    surfaceRaised,
+    border,
+    text,
+    textMuted,
+    gridMinor,
+    gridMajor,
+    vignette,
+    accent,
+    paper: canvas,
+    ink: text,
+    muted: textMuted,
+    soft,
+    rule,
+    accentTint,
+    nodeSurface: surface,
+    nodeSurfaceRaised: surfaceRaised,
+    hairline: border,
+    shadow: isDark ? "rgba(0, 0, 0, 0.5)" : "rgba(15, 23, 42, 0.08)",
+    labelPlate: isDark ? "rgba(15, 23, 42, 0.85)" : "rgba(255, 255, 255, 0.95)",
+    roles: {
+      client: hslToHex((hsl.h + 30) % 360, 70, isDark ? 65 : 45),
+      compute: accent,
+      data: hslToHex((hsl.h + 180) % 360, 65, isDark ? 60 : 42),
+      messaging: hslToHex((hsl.h + 90) % 360, 75, isDark ? 68 : 46),
+      network: hslToHex((hsl.h + 210) % 360, 60, isDark ? 62 : 44),
+      platform: hslToHex((hsl.h + 270) % 360, 55, isDark ? 65 : 48),
+      security: hslToHex(10, 80, isDark ? 65 : 50),
+      delivery: hslToHex((hsl.h + 150) % 360, 65, isDark ? 62 : 42),
+      observability: hslToHex((hsl.h + 45) % 360, 75, isDark ? 64 : 45),
+      flow: textMuted,
+      code: textMuted,
+      distributed: hslToHex((hsl.h + 300) % 360, 60, isDark ? 65 : 45)
+    },
+    edges: {
+      request: isDark ? "#38bdf8" : "#0284c7",
+      response: isDark ? "#94a3b8" : "#64748b",
+      event: isDark ? "#f59e0b" : "#d97706",
+      dependency: isDark ? "#475569" : "#94a3b8"
+    }
+  };
+}
+
+// src/arch-lint.ts
+function matchNode(node, selector) {
+  if (!selector) return true;
+  if (selector.id && node.id !== selector.id) return false;
+  if (selector.kindEquals && node.kind.toLowerCase() !== selector.kindEquals.toLowerCase()) return false;
+  if (selector.roleEquals) {
+    const role = nodeRole(node.kind);
+    if (role.toLowerCase() !== selector.roleEquals.toLowerCase()) return false;
+  }
+  if (selector.labelContains) {
+    const target = (node.label || node.id).toLowerCase();
+    if (!target.includes(selector.labelContains.toLowerCase())) return false;
+  }
+  return true;
+}
+function matchEdge(edge, selector) {
+  if (!selector) return true;
+  if (selector.kind && edge.kind !== selector.kind) return false;
+  if (selector.labelContains) {
+    const label = (edge.label || "").toLowerCase();
+    if (!label.includes(selector.labelContains.toLowerCase())) return false;
+  }
+  return true;
+}
+function extractAllEdges(ast) {
+  const edges = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const edge of ast.edges) {
+    const key = `${edge.from}->${edge.to}:${edge.kind}:${edge.label ?? ""}`;
+    if (!seen.has(key)) {
+      seen.add(key);
+      edges.push({
+        from: edge.from,
+        to: edge.to,
+        kind: edge.kind,
+        label: edge.label,
+        line: edge.line
+      });
+    }
+  }
+  for (const beat of ast.beats) {
+    for (const cue of beat.cues) {
+      if (cue.kind === "flow") {
+        for (const seg of cue.segments) {
+          const key = `${seg.from}->${seg.to}:${seg.op}:${seg.label ?? ""}`;
+          if (!seen.has(key)) {
+            seen.add(key);
+            edges.push({
+              from: seg.from,
+              to: seg.to,
+              kind: seg.op,
+              label: seg.label,
+              line: cue.line
+            });
+          }
+        }
+      }
+    }
+  }
+  return edges;
+}
+function detectCycleInGraph(nodes, edges, edgeFilter) {
+  const candidateEdges = edges.filter((e) => matchEdge(e, edgeFilter));
+  const adj = /* @__PURE__ */ new Map();
+  for (const e of candidateEdges) {
+    if (!adj.has(e.from)) adj.set(e.from, []);
+    adj.get(e.from).push({ to: e.to, line: e.line });
+  }
+  const visited = /* @__PURE__ */ new Set();
+  const onStack = /* @__PURE__ */ new Set();
+  const parentMap = /* @__PURE__ */ new Map();
+  let foundCycle = null;
+  const dfs = (curr) => {
+    visited.add(curr);
+    onStack.add(curr);
+    for (const next of adj.get(curr) ?? []) {
+      if (foundCycle) return;
+      if (!visited.has(next.to)) {
+        parentMap.set(next.to, curr);
+        dfs(next.to);
+      } else if (onStack.has(next.to)) {
+        const cycle = [next.to, curr];
+        let p = curr;
+        while (p !== next.to && parentMap.has(p)) {
+          p = parentMap.get(p);
+          cycle.push(p);
+        }
+        foundCycle = {
+          path: cycle.reverse(),
+          line: next.line
+        };
+        return;
+      }
+    }
+    onStack.delete(curr);
+  };
+  for (const node of nodes) {
+    if (!visited.has(node.id)) {
+      dfs(node.id);
+      if (foundCycle) return foundCycle;
+    }
+  }
+  return null;
+}
+var ARCH_RULE_PRESETS = {
+  cleanArchitecture: {
+    id: "clean-architecture",
+    name: "Clean / Layered Architecture",
+    description: "Enforce strict dependency rules: Presentation cannot directly access Data Storage",
+    rules: [
+      {
+        id: "no-presentation-to-database",
+        name: "No Direct Client DB Access",
+        description: "Presentation/Client components must communicate via backend services, never directly with databases.",
+        severity: "error",
+        type: "cannot-connect",
+        from: { roleEquals: "client" },
+        to: { roleEquals: "data" }
+      },
+      {
+        id: "no-browser-to-internal-storage",
+        name: "No Direct Browser Storage Access",
+        description: "Browser nodes must not connect directly to private storage buckets.",
+        severity: "error",
+        type: "cannot-connect",
+        from: { kindEquals: "browser" },
+        to: { kindEquals: "storage" }
+      }
+    ]
+  },
+  microservicesGovernance: {
+    id: "microservices-governance",
+    name: "Microservices Governance",
+    description: "Prevent synchronous request cycles and shared database anti-patterns",
+    rules: [
+      {
+        id: "no-sync-request-cycles",
+        name: "Forbidden Request Cycle",
+        description: "Synchronous request flows (->) must not form cyclic dependencies between services.",
+        severity: "error",
+        type: "forbidden-cycle",
+        edge: { kind: "request" }
+      },
+      {
+        id: "gateway-enforcement",
+        name: "API Gateway Required",
+        description: "Architecture diagrams with 3 or more services should declare an API gateway.",
+        severity: "warning",
+        type: "must-have-role",
+        from: { roleEquals: "gateway" },
+        min: 1
+      }
+    ]
+  },
+  securityBoundaries: {
+    id: "security-boundaries",
+    name: "Zero-Trust Security Boundaries",
+    description: "Ensure external clients pass through auth and edge gateway tiers",
+    rules: [
+      {
+        id: "auth-service-presence",
+        name: "Authentication Component Presence",
+        description: "Public-facing architectures should explicitly define an Auth or Identity provider.",
+        severity: "info",
+        type: "must-have-role",
+        from: { roleEquals: "security" }
+      }
+    ]
+  }
+};
+function validateArchitecture(ast, rules = [
+  ...ARCH_RULE_PRESETS.cleanArchitecture.rules,
+  ...ARCH_RULE_PRESETS.microservicesGovernance.rules
+]) {
+  const violations = [];
+  const nodes = Object.values(ast.nodes);
+  const nodeMap = new Map(nodes.map((n) => [n.id, n]));
+  const edges = extractAllEdges(ast);
+  for (const rule of rules) {
+    switch (rule.type) {
+      case "cannot-connect": {
+        for (const edge of edges) {
+          const sourceNode = nodeMap.get(edge.from);
+          const targetNode = nodeMap.get(edge.to);
+          if (!sourceNode || !targetNode) continue;
+          if (matchNode(sourceNode, rule.from) && matchNode(targetNode, rule.to) && matchEdge(edge, rule.edge)) {
+            violations.push({
+              ruleId: rule.id,
+              ruleName: rule.name,
+              message: rule.description || `Node "${sourceNode.id}" is forbidden from connecting to "${targetNode.id}"`,
+              severity: rule.severity,
+              nodeIds: [sourceNode.id, targetNode.id],
+              edgeKeys: [`${edge.from}->${edge.to}`],
+              line: edge.line
+            });
+          }
+        }
+        break;
+      }
+      case "must-connect": {
+        const sourceNodes = nodes.filter((n) => matchNode(n, rule.from));
+        for (const src of sourceNodes) {
+          const hasMatchingConnection = edges.some((edge) => {
+            if (edge.from !== src.id) return false;
+            const targetNode = nodeMap.get(edge.to);
+            return targetNode ? matchNode(targetNode, rule.to) && matchEdge(edge, rule.edge) : false;
+          });
+          if (!hasMatchingConnection) {
+            violations.push({
+              ruleId: rule.id,
+              ruleName: rule.name,
+              message: rule.description || `Node "${src.id}" must connect to a matching downstream component`,
+              severity: rule.severity,
+              nodeIds: [src.id],
+              edgeKeys: [],
+              line: src.line
+            });
+          }
+        }
+        break;
+      }
+      case "forbidden-cycle": {
+        const cycleInfo = detectCycleInGraph(nodes, edges, rule.edge);
+        if (cycleInfo) {
+          violations.push({
+            ruleId: rule.id,
+            ruleName: rule.name,
+            message: `${rule.description} (Cycle path: ${cycleInfo.path.join(" -> ")})`,
+            severity: rule.severity,
+            nodeIds: Array.from(new Set(cycleInfo.path)),
+            edgeKeys: [],
+            line: cycleInfo.line
+          });
+        }
+        break;
+      }
+      case "must-have-role": {
+        const matching = nodes.filter((n) => matchNode(n, rule.from));
+        const min = rule.min ?? 1;
+        if (matching.length < min) {
+          violations.push({
+            ruleId: rule.id,
+            ruleName: rule.name,
+            message: rule.description,
+            severity: rule.severity,
+            nodeIds: [],
+            edgeKeys: [],
+            line: 1
+          });
+        }
+        break;
+      }
+      case "role-count-limit": {
+        const matching = nodes.filter((n) => matchNode(n, rule.from));
+        if (rule.max !== void 0 && matching.length > rule.max) {
+          violations.push({
+            ruleId: rule.id,
+            ruleName: rule.name,
+            message: `${rule.description} (Found ${matching.length}, maximum allowed is ${rule.max})`,
+            severity: rule.severity,
+            nodeIds: matching.map((n) => n.id),
+            edgeKeys: [],
+            line: matching[0]?.line ?? 1
+          });
+        }
+        break;
+      }
+    }
+  }
+  return violations;
+}
+function resolveArchitectureConfig(config) {
+  if (!config) {
+    return ARCH_RULE_PRESETS.cleanArchitecture.rules;
+  }
+  const rulesMap = /* @__PURE__ */ new Map();
+  if (config.extends) {
+    for (const presetName of config.extends) {
+      const preset = ARCH_RULE_PRESETS[presetName];
+      if (preset) {
+        for (const r of preset.rules) {
+          rulesMap.set(r.id, { ...r });
+        }
+      }
+    }
+  }
+  if (config.rules) {
+    for (const ruleItem of config.rules) {
+      if (typeof ruleItem === "string") {
+        for (const preset of Object.values(ARCH_RULE_PRESETS)) {
+          const found = preset.rules.find((r) => r.id === ruleItem);
+          if (found) {
+            rulesMap.set(found.id, { ...found });
+            break;
+          }
+        }
+      } else if (typeof ruleItem === "object" && ruleItem.id) {
+        rulesMap.set(ruleItem.id, ruleItem);
+      }
+    }
+  }
+  if (config.severityOverrides) {
+    for (const [ruleId, sev] of Object.entries(config.severityOverrides)) {
+      const existing = rulesMap.get(ruleId);
+      if (existing) {
+        existing.severity = sev;
+      }
+    }
+  }
+  if (rulesMap.size === 0) {
+    return ARCH_RULE_PRESETS.cleanArchitecture.rules;
+  }
+  return Array.from(rulesMap.values());
+}
+
+// src/classifier.ts
+var TECH_CATALOG = [
+  // ── DATABASES ───────────────────────────────────────────────────────
+  {
+    patterns: [/\b(postgres(ql)?|psql|cockroach(db)?|timescale)\b/i],
+    kind: "database",
+    role: "database",
+    badge: "SQL"
+  },
+  {
+    patterns: [/\b(mysql|mariadb|aurora|planetscale)\b/i],
+    kind: "database",
+    role: "database",
+    badge: "MySQL"
+  },
+  {
+    patterns: [/\b(mongodb|mongo|documentdb|couchdb)\b/i],
+    kind: "database",
+    role: "database",
+    badge: "Document"
+  },
+  {
+    patterns: [/\b(dynamodb|cassandra|scylla|hbase)\b/i],
+    kind: "database",
+    role: "database",
+    badge: "NoSQL"
+  },
+  {
+    patterns: [/\b(redis|memcached?|elasticache|dragonfly|valkey)\b/i],
+    kind: "cache",
+    role: "cache",
+    badge: "Cache"
+  },
+  {
+    patterns: [/\b(neo4j|memgraph|dgraph|graphdb)\b/i],
+    kind: "database",
+    role: "database",
+    badge: "Graph"
+  },
+  {
+    patterns: [/\b(clickhouse|snowflake|bigquery|redshift|duckdb)\b/i],
+    kind: "database",
+    role: "database",
+    badge: "Analytics"
+  },
+  // ── MESSAGING & EVENT STREAMING ────────────────────────────────────
+  {
+    patterns: [/\b(kafka|confluent|redpanda)\b/i],
+    kind: "queue",
+    role: "event_stream",
+    badge: "EventStream"
+  },
+  {
+    patterns: [/\b(rabbitmq|sqs|activemq|pulsar|nats|eventgrid|servicebus)\b/i],
+    kind: "queue",
+    role: "queue",
+    badge: "Queue"
+  },
+  // ── GATEWAYS & INGRESS ──────────────────────────────────────────────
+  {
+    patterns: [/\b(kong|envoy|nginx|traefik|caddy|haproxy|emissary)\b/i],
+    kind: "api_gateway",
+    role: "gateway",
+    badge: "Gateway"
+  },
+  {
+    patterns: [/\b(cloudfront|cloudflare|fastly|akamai|cdn)\b/i],
+    kind: "cdn",
+    role: "network",
+    badge: "CDN"
+  },
+  {
+    patterns: [/\b(alb|elb|nlb|load_?balancer|ingress)\b/i],
+    kind: "load_balancer",
+    role: "network",
+    badge: "LB"
+  },
+  // ── CLIENT & PRESENTATION ──────────────────────────────────────────
+  {
+    patterns: [/\b(react|vue|angular|svelte|next(\.?js)?|nuxt|solid)\b/i],
+    kind: "browser",
+    role: "client",
+    badge: "Web"
+  },
+  {
+    patterns: [/\b(flutter|react_?native|ios|android|swift|kotlin|mobile)\b/i],
+    kind: "browser",
+    role: "client",
+    badge: "Mobile"
+  },
+  // ── AI & LLM ────────────────────────────────────────────────────────
+  {
+    patterns: [/\b(gemini|gpt(-?[a-z0-9.]+)?|claude|openai|anthropic|bedrock|vertexai|mistral|ollama|deepseek)\b/i],
+    kind: "service",
+    role: "ai_model",
+    badge: "AI/LLM"
+  },
+  {
+    patterns: [/\b(pinecone|weaviate|qdrant|chroma|milvus)\b/i],
+    kind: "database",
+    role: "database",
+    badge: "VectorDB"
+  },
+  // ── CLOUD & CONTAINER RUNTIMES ─────────────────────────────────────
+  {
+    patterns: [/\b(k8s|kubernetes|eks|gke|aks|helm|argocd)\b/i],
+    kind: "cluster",
+    role: "platform",
+    badge: "K8s"
+  },
+  {
+    patterns: [/\b(lambda|cloud_?functions?|azure_?functions?|serverless)\b/i],
+    kind: "worker",
+    role: "compute",
+    badge: "Function"
+  },
+  {
+    patterns: [/\b(docker|ecs|container|fargate|cloud_?run)\b/i],
+    kind: "service",
+    role: "compute",
+    badge: "Container"
+  },
+  // ── STORAGE & BLOB ──────────────────────────────────────────────────
+  {
+    patterns: [/\b(s3|gcs|azure_?blob|minio|r2|ceph)\b/i],
+    kind: "storage",
+    role: "storage",
+    badge: "ObjectStorage"
+  },
+  // ── SECURITY & AUTH ─────────────────────────────────────────────────
+  {
+    patterns: [/\b(auth0|clerk|keycloak|cognito|okta|vault|jwt|oauth|oidc)\b/i],
+    kind: "service",
+    role: "security",
+    badge: "Security"
+  }
+];
+function classifyTechnology(id, label = "") {
+  const combined = `${id} ${label}`.trim();
+  for (const entry of TECH_CATALOG) {
+    if (entry.patterns.some((p) => p.test(combined))) {
+      return {
+        kind: entry.kind,
+        role: entry.role,
+        suggestedTheme: "paper",
+        badge: entry.badge
+      };
+    }
+  }
+  return {
+    kind: "service",
+    role: "compute",
+    suggestedTheme: "paper"
+  };
+}
+
+// src/diff.ts
+function diffDiagramASTs(beforeAST, afterAST) {
+  const nodeDiffs = [];
+  const edgeDiffs = [];
+  const beforeNodeIds = new Set(Object.keys(beforeAST.nodes));
+  const afterNodeIds = new Set(Object.keys(afterAST.nodes));
+  let addedNodesCount = 0;
+  let removedNodesCount = 0;
+  let modifiedNodesCount = 0;
+  for (const [id, afterNode] of Object.entries(afterAST.nodes)) {
+    if (!beforeNodeIds.has(id)) {
+      nodeDiffs.push({ id, status: "added", after: afterNode, changes: ["Newly added node"] });
+      addedNodesCount++;
+    } else {
+      const beforeNode = beforeAST.nodes[id];
+      const changes = [];
+      if (beforeNode.kind !== afterNode.kind) {
+        changes.push(`Kind changed: ${beforeNode.kind} \u2192 ${afterNode.kind}`);
+      }
+      if (beforeNode.label !== afterNode.label) {
+        changes.push(`Label changed: "${beforeNode.label}" \u2192 "${afterNode.label}"`);
+      }
+      if (changes.length > 0) {
+        nodeDiffs.push({ id, status: "modified", before: beforeNode, after: afterNode, changes });
+        modifiedNodesCount++;
+      } else {
+        nodeDiffs.push({ id, status: "unchanged", before: beforeNode, after: afterNode, changes: [] });
+      }
+    }
+  }
+  for (const [id, beforeNode] of Object.entries(beforeAST.nodes)) {
+    if (!afterNodeIds.has(id)) {
+      nodeDiffs.push({ id, status: "removed", before: beforeNode, changes: ["Removed node"] });
+      removedNodesCount++;
+    }
+  }
+  const edgeKey = (e) => `${e.from}->${e.to}:${e.kind}`;
+  const beforeEdgeMap = new Map(beforeAST.edges.map((e) => [edgeKey(e), e]));
+  const afterEdgeMap = new Map(afterAST.edges.map((e) => [edgeKey(e), e]));
+  for (const [key, afterEdge] of afterEdgeMap) {
+    if (!beforeEdgeMap.has(key)) {
+      edgeDiffs.push({ key, status: "added", after: afterEdge });
+    } else {
+      edgeDiffs.push({ key, status: "unchanged", before: beforeEdgeMap.get(key), after: afterEdge });
+    }
+  }
+  for (const [key, beforeEdge] of beforeEdgeMap) {
+    if (!afterEdgeMap.has(key)) {
+      edgeDiffs.push({ key, status: "removed", before: beforeEdge });
+    }
+  }
+  const summaryLines = [
+    "### \u{1F4CA} Markdy Architectural Diff Summary",
+    "",
+    `| Metric | Count |`,
+    `|---|---|`,
+    `| \u{1F7E2} Nodes Added | **${addedNodesCount}** |`,
+    `| \u{1F534} Nodes Removed | **${removedNodesCount}** |`,
+    `| \u{1F7E1} Nodes Modified | **${modifiedNodesCount}** |`,
+    ""
+  ];
+  if (addedNodesCount > 0 || modifiedNodesCount > 0 || removedNodesCount > 0) {
+    summaryLines.push("#### Changes Detail");
+    for (const nd of nodeDiffs.filter((n) => n.status !== "unchanged")) {
+      summaryLines.push(`- **${nd.id}** (${nd.status.toUpperCase()}): ${nd.changes.join(", ")}`);
+    }
+    summaryLines.push("");
+  }
+  const evolutionLines = [
+    `scene "Architecture Evolution" theme=${afterAST.meta.theme || "paper"}`,
+    `layout ${afterAST.meta.direction || "LR"}`,
+    ""
+  ];
+  for (const [id, node] of Object.entries({ ...beforeAST.nodes, ...afterAST.nodes })) {
+    evolutionLines.push(`${node.kind} ${id} "${node.label}"`);
+  }
+  evolutionLines.push("");
+  evolutionLines.push('beat v1 "Baseline Architecture":');
+  const v1NodeIds = Object.keys(beforeAST.nodes).join(" ");
+  if (v1NodeIds) {
+    evolutionLines.push(`  show ${v1NodeIds}`);
+  }
+  evolutionLines.push("");
+  evolutionLines.push('beat transition "Migrate to Target Architecture":');
+  const addedIds = nodeDiffs.filter((n) => n.status === "added").map((n) => n.id);
+  const removedIds = nodeDiffs.filter((n) => n.status === "removed").map((n) => n.id);
+  if (removedIds.length > 0) {
+    evolutionLines.push(`  hide ${removedIds.join(" ")}`);
+  }
+  if (addedIds.length > 0) {
+    evolutionLines.push(`  show ${addedIds.join(" ")}`);
+    evolutionLines.push(`  glow ${addedIds.join(" ")} color="#10b981"`);
+  }
+  return {
+    nodes: nodeDiffs,
+    edges: edgeDiffs,
+    addedNodesCount,
+    removedNodesCount,
+    modifiedNodesCount,
+    summaryMarkdown: summaryLines.join("\n"),
+    evolutionMarkdyScript: evolutionLines.join("\n")
+  };
+}
+
+// src/url-codec.ts
+var PREFIX = "~m";
+var B64_CHARS = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_";
+function bytesToBase64Url(bytes) {
+  let result = "";
+  const len = bytes.length;
+  let i = 0;
+  while (i < len) {
+    const b0 = bytes[i++];
+    const b1 = i < len ? bytes[i++] : NaN;
+    const b2 = i < len ? bytes[i++] : NaN;
+    const idx0 = b0 >> 2;
+    const idx1 = (b0 & 3) << 4 | (isNaN(b1) ? 0 : b1 >> 4);
+    result += B64_CHARS[idx0] + B64_CHARS[idx1];
+    if (!isNaN(b1)) {
+      const idx2 = (b1 & 15) << 2 | (isNaN(b2) ? 0 : b2 >> 6);
+      result += B64_CHARS[idx2];
+    }
+    if (!isNaN(b2)) {
+      const idx3 = b2 & 63;
+      result += B64_CHARS[idx3];
+    }
+  }
+  return result;
+}
+var B64_LOOKUP = new Uint8Array(256);
+for (let i = 0; i < B64_CHARS.length; i++) {
+  B64_LOOKUP[B64_CHARS.charCodeAt(i)] = i;
+}
+B64_LOOKUP["+".charCodeAt(0)] = 62;
+B64_LOOKUP["/".charCodeAt(0)] = 63;
+function base64UrlToBytes(str) {
+  const cleanStr = str.replace(/=/g, "");
+  const len = cleanStr.length;
+  const outLen = len * 3 >> 2;
+  const bytes = new Uint8Array(outLen);
+  let inIdx = 0;
+  let outIdx = 0;
+  while (inIdx < len) {
+    const c0 = B64_LOOKUP[cleanStr.charCodeAt(inIdx++)];
+    const c1 = B64_LOOKUP[cleanStr.charCodeAt(inIdx++)];
+    const c2 = inIdx < len ? B64_LOOKUP[cleanStr.charCodeAt(inIdx++)] : 64;
+    const c3 = inIdx < len ? B64_LOOKUP[cleanStr.charCodeAt(inIdx++)] : 64;
+    bytes[outIdx++] = c0 << 2 | c1 >> 4;
+    if (c2 !== 64 && outIdx < outLen) {
+      bytes[outIdx++] = (c1 & 15) << 4 | c2 >> 2;
+    }
+    if (c3 !== 64 && outIdx < outLen) {
+      bytes[outIdx++] = (c2 & 3) << 6 | c3;
+    }
+  }
+  return bytes;
+}
+async function compressMarkdyToUrlHash(code) {
+  const encoder = new TextEncoder();
+  const inputBytes = encoder.encode(code);
+  if (typeof CompressionStream !== "undefined") {
+    const cs = new CompressionStream("deflate-raw");
+    const writer = cs.writable.getWriter();
+    writer.write(inputBytes);
+    writer.close();
+    const response = new Response(cs.readable);
+    const compressedBuffer = await response.arrayBuffer();
+    return PREFIX + bytesToBase64Url(new Uint8Array(compressedBuffer));
+  }
+  return PREFIX + bytesToBase64Url(inputBytes);
+}
+async function decompressMarkdyFromUrlHash(hash) {
+  if (!hash.startsWith(PREFIX)) {
+    throw new Error("Invalid Markdy compressed URL state prefix");
+  }
+  const rawPayload = hash.slice(PREFIX.length);
+  const bytes = base64UrlToBytes(rawPayload);
+  if (typeof DecompressionStream !== "undefined") {
+    try {
+      const ds = new DecompressionStream("deflate-raw");
+      const writer = ds.writable.getWriter();
+      writer.write(bytes);
+      writer.close();
+      const response = new Response(ds.readable);
+      const decompressedBuffer = await response.arrayBuffer();
+      return new TextDecoder().decode(decompressedBuffer);
+    } catch {
+      return new TextDecoder().decode(bytes);
+    }
+  }
+  return new TextDecoder().decode(bytes);
+}
+
+// src/router.ts
+function getBoxPortPosition(box, port) {
+  switch (port) {
+    case "left":
+      return { x: box.x, y: box.y + box.height / 2 };
+    case "right":
+      return { x: box.x + box.width, y: box.y + box.height / 2 };
+    case "top":
+      return { x: box.x + box.width / 2, y: box.y };
+    case "bottom":
+      return { x: box.x + box.width / 2, y: box.y + box.height };
+  }
+}
+function selectOptimalPorts(sourceBox, targetBox) {
+  const srcCenter = { x: sourceBox.x + sourceBox.width / 2, y: sourceBox.y + sourceBox.height / 2 };
+  const tgtCenter = { x: targetBox.x + targetBox.width / 2, y: targetBox.y + targetBox.height / 2 };
+  const dx = tgtCenter.x - srcCenter.x;
+  const dy = tgtCenter.y - srcCenter.y;
+  if (Math.abs(dx) >= Math.abs(dy)) {
+    return dx > 0 ? { sourcePort: "right", targetPort: "left" } : { sourcePort: "left", targetPort: "right" };
+  } else {
+    return dy > 0 ? { sourcePort: "bottom", targetPort: "top" } : { sourcePort: "top", targetPort: "bottom" };
+  }
+}
+function routeOrthogonalEdge(sourceBox, targetBox) {
+  const { sourcePort, targetPort } = selectOptimalPorts(sourceBox, targetBox);
+  const start = getBoxPortPosition(sourceBox, sourcePort);
+  const end = getBoxPortPosition(targetBox, targetPort);
+  const waypoints = [];
+  if (sourcePort === "right" && targetPort === "left") {
+    const midX = (start.x + end.x) / 2;
+    waypoints.push({ x: midX, y: start.y });
+    waypoints.push({ x: midX, y: end.y });
+  } else if (sourcePort === "bottom" && targetPort === "top") {
+    const midY = (start.y + end.y) / 2;
+    waypoints.push({ x: start.x, y: midY });
+    waypoints.push({ x: end.x, y: midY });
+  } else {
+    waypoints.push({ x: end.x, y: start.y });
+  }
+  let svgPathData = `M ${start.x} ${start.y}`;
+  for (const wp of waypoints) {
+    svgPathData += ` L ${wp.x} ${wp.y}`;
+  }
+  svgPathData += ` L ${end.x} ${end.y}`;
+  return {
+    sourcePort,
+    targetPort,
+    startPoint: start,
+    endPoint: end,
+    waypoints,
+    svgPathData
+  };
+}
+
+// src/ai-healing.ts
+function analyzeAndBuildRepairPrompt(sourceCode) {
+  const syntaxErrors = [];
+  let ast = null;
+  try {
+    ast = parse(sourceCode);
+  } catch (err) {
+    syntaxErrors.push(err instanceof Error ? err.message : String(err));
+  }
+  if (!ast) {
+    return {
+      isValid: false,
+      syntaxErrors,
+      archViolations: [],
+      repairPrompt: [
+        "The following MarkdyScript failed to parse with syntax errors:",
+        ...syntaxErrors.map((e) => `  - ${e}`),
+        "",
+        "Please fix the code below to follow valid MarkdyScript syntax:",
+        "```markdy",
+        sourceCode,
+        "```"
+      ].join("\n")
+    };
+  }
+  const archViolations = validateArchitecture(ast);
+  if (ast.diagnostics.length === 0 && archViolations.length === 0) {
+    return { isValid: true, syntaxErrors: [], archViolations: [] };
+  }
+  const promptSections = [
+    "The MarkdyScript diagram has the following compiler diagnostics and architectural rule violations:",
+    "",
+    "### Diagnostics:",
+    ...ast.diagnostics.map((d) => `  - Line ${d.line}: ${d.message}`),
+    "",
+    "### Architectural Violations:",
+    ...archViolations.map((v) => `  - [${v.severity.toUpperCase()}] ${v.ruleName}: ${v.message}`),
+    "",
+    "Please revise the diagram code to resolve all issues while preserving semantic nodes and beats:",
+    "```markdy",
+    sourceCode,
+    "```"
+  ];
+  return {
+    isValid: false,
+    syntaxErrors: [],
+    archViolations,
+    repairPrompt: promptSections.join("\n")
+  };
+}
+
+// src/output-presets.ts
+var OUTPUT_PRESETS = {
+  "doc-inline": {
+    name: "doc-inline",
+    width: 960,
+    height: 600,
+    safeArea: 40,
+    aspect: "8:5",
+    context: "Inline documentation diagrams"
+  },
+  "doc-wide": {
+    name: "doc-wide",
+    width: 1280,
+    height: 720,
+    safeArea: 40,
+    aspect: "16:9",
+    context: "Wide documentation hero diagrams"
+  },
+  "slide-16x9": {
+    name: "slide-16x9",
+    width: 1280,
+    height: 720,
+    safeArea: 48,
+    aspect: "16:9",
+    context: "Presentation slides (Google Slides, Keynote, PowerPoint)"
+  },
+  "slide-4x3": {
+    name: "slide-4x3",
+    width: 1024,
+    height: 768,
+    safeArea: 48,
+    aspect: "4:3",
+    context: "Legacy presentation slides"
+  },
+  "social-og": {
+    name: "social-og",
+    width: 1200,
+    height: 632,
+    safeArea: 64,
+    aspect: "~1.9:1",
+    context: "Open Graph / Twitter Card / LinkedIn"
+  },
+  "social-square": {
+    name: "social-square",
+    width: 1080,
+    height: 1080,
+    safeArea: 64,
+    aspect: "1:1",
+    context: "Instagram / Square social posts"
+  },
+  "print-a4": {
+    name: "print-a4",
+    width: 1120,
+    height: 792,
+    safeArea: 40,
+    aspect: "~1.41:1",
+    context: "A4 landscape print"
+  },
+  "print-letter": {
+    name: "print-letter",
+    width: 1056,
+    height: 816,
+    safeArea: 40,
+    aspect: "~1.29:1",
+    context: "US Letter landscape print"
+  }
+};
+function resolveOutputPreset(name) {
+  return OUTPUT_PRESETS[name] ?? OUTPUT_PRESETS["doc-inline"];
+}
+function listOutputPresets() {
+  return Object.keys(OUTPUT_PRESETS);
+}
 export {
+  ARCH_RULE_PRESETS,
   BEAT_CUE_KEYWORDS,
   CUE_ALIASES,
   DIAGRAM_TYPES,
   EDGE_OPERATORS,
   NODE_ALIASES,
   NODE_KINDS,
+  OUTPUT_PRESETS,
   ParseError,
   SCENE_KEYS,
   TECHNICAL_NODE_KINDS,
   TECHNICAL_NODE_TYPES,
   THEMES,
   VISUAL_PRIMITIVE_TYPES,
+  analyzeAndBuildRepairPrompt,
   canonicalNodeKind,
+  classifyTechnology,
   compile,
   compilePlan,
+  compressMarkdyToUrlHash,
+  decompressMarkdyFromUrlHash,
+  diffDiagramASTs,
+  generateThemeFromBrand,
+  getBoxPortPosition,
   humanizeId,
+  listOutputPresets,
   nodeRole,
   parse,
   parseAndCompile,
-  resolveTheme
+  resolveArchitectureConfig,
+  resolveOutputPreset,
+  resolveTheme,
+  routeOrthogonalEdge,
+  selectOptimalPorts,
+  validateArchitecture
 };