@diagrammo/dgmo 0.8.23 → 0.8.25

package/dist/index.cjs

@@ -2086,7 +2086,8 @@ function validateTagValues(entities, tagGroups, pushWarning, suggestFn) {
     }
   }
 }
-function validateTagGroupNames(tagGroups, pushWarning) {
+function validateTagGroupNames(tagGroups, pushWarning, pushError) {
+  const report = pushError ?? pushWarning;
   for (const group of tagGroups) {
     if (group.name.toLowerCase() === "none") {
       pushWarning(
@@ -2094,6 +2095,18 @@ function validateTagGroupNames(tagGroups, pushWarning) {
         `'none' is a reserved keyword and cannot be used as a tag group name`
       );
     }
+    if (!VALID_TAG_IDENT_RE.test(group.name)) {
+      report(
+        group.lineNumber,
+        `Tag group name "${group.name}" contains invalid characters \u2014 use a single identifier (letters, digits, underscore, hyphen)`
+      );
+    }
+    if (group.alias != null && !VALID_TAG_IDENT_RE.test(group.alias)) {
+      report(
+        group.lineNumber,
+        `Tag group alias "${group.alias}" contains invalid characters \u2014 use a single identifier (letters, digits, underscore, hyphen)`
+      );
+    }
   }
 }
 function injectDefaultTagMetadata(entities, tagGroups, skip) {
@@ -2132,12 +2145,13 @@ function resolveActiveTagGroup(tagGroups, explicitActiveTag, programmaticOverrid
 function matchTagBlockHeading(trimmed) {
   return parseTagDeclaration(trimmed);
 }
-var TAG_BLOCK_NOCOLON_RE;
+var TAG_BLOCK_NOCOLON_RE, VALID_TAG_IDENT_RE;
 var init_tag_groups = __esm({
   "src/utils/tag-groups.ts"() {
     "use strict";
     init_parsing();
     TAG_BLOCK_NOCOLON_RE = /^tag\s+/i;
+    VALID_TAG_IDENT_RE = /^[A-Za-z_][A-Za-z0-9_-]*$/;
   }
 });
 
@@ -3073,7 +3087,6 @@ var init_participant_inference = __esm({
       { pattern: /^Admin$/i, type: "actor" },
       { pattern: /^User$/i, type: "actor" },
       { pattern: /^Customer$/i, type: "actor" },
-      { pattern: /^Client$/i, type: "actor" },
       { pattern: /^Agent$/i, type: "actor" },
       { pattern: /^Person$/i, type: "actor" },
       { pattern: /^Buyer$/i, type: "actor" },
@@ -4071,7 +4084,7 @@ function parseSequenceDgmo(content) {
         entities.push({ metadata: g.metadata, lineNumber: g.lineNumber });
     }
     validateTagValues(entities, result.tagGroups, pushWarning, suggest);
-    validateTagGroupNames(result.tagGroups, pushWarning);
+    validateTagGroupNames(result.tagGroups, pushWarning, pushError);
   }
   return result;
 }
@@ -4094,7 +4107,7 @@ var init_parser = __esm({
     init_parsing();
     init_tag_groups();
     KNOWN_SEQ_OPTIONS = /* @__PURE__ */ new Set(["active-tag"]);
-    KNOWN_SEQ_BOOLEANS = /* @__PURE__ */ new Set(["activations", "collapse-notes"]);
+    KNOWN_SEQ_BOOLEANS = /* @__PURE__ */ new Set(["activations"]);
     VALID_PARTICIPANT_TYPES = /* @__PURE__ */ new Set([
       "service",
       "database",
@@ -8452,7 +8465,7 @@ function parseOrg(content, palette) {
     };
     collectAll(result.roots);
     validateTagValues(allNodes, result.tagGroups, pushWarning, suggest);
-    validateTagGroupNames(result.tagGroups, pushWarning);
+    validateTagGroupNames(result.tagGroups, pushWarning, pushError);
   }
   if (result.roots.length === 0 && result.tagGroups.length === 0 && !result.error) {
     const diag = makeDgmoError(1, "No nodes found in org chart");
@@ -8785,7 +8798,11 @@ function parseKanban(content, palette) {
   if (result.columns.length === 0 && !result.error) {
     return fail(1, "No columns found. Use [Column Name] to define columns");
   }
-  validateTagGroupNames(result.tagGroups, warn);
+  validateTagGroupNames(result.tagGroups, warn, (line11, msg) => {
+    const diag = makeDgmoError(line11, msg);
+    result.diagnostics.push(diag);
+    if (!result.error) result.error = formatDgmoError(diag);
+  });
   return result;
 }
 function parseCardLine(trimmed, lineNumber, counter, aliasMap, _palette, _diagnostics) {
@@ -9911,7 +9928,7 @@ function parseSitemap(content, palette) {
     };
     collectAll(result.roots);
     validateTagValues(allNodes, result.tagGroups, pushWarning, suggest);
-    validateTagGroupNames(result.tagGroups, pushWarning);
+    validateTagGroupNames(result.tagGroups, pushWarning, pushError);
   }
   if (result.roots.length === 0 && result.tagGroups.length === 0 && !result.error) {
     const diag = makeDgmoError(1, "No pages found in sitemap");
@@ -10548,7 +10565,7 @@ function parseInfra(content) {
       }
     }
   }
-  validateTagGroupNames(result.tagGroups, warn);
+  validateTagGroupNames(result.tagGroups, warn, setError);
   return result;
 }
 function extractSymbols4(docText) {
@@ -11489,7 +11506,11 @@ function parseGantt(content, palette) {
     warn(0, "sort tag has no effect \u2014 no tag groups defined.");
     result.options.sort = "default";
   }
-  validateTagGroupNames(result.tagGroups, warn);
+  validateTagGroupNames(result.tagGroups, warn, (line11, msg) => {
+    const diag = makeDgmoError(line11, msg);
+    diagnostics.push(diag);
+    if (!result.error) result.error = formatDgmoError(diag);
+  });
   const hasSprintOption = result.options.sprintLength !== null || result.options.sprintNumber !== null || result.options.sprintStart !== null;
   const hasSprintUnit = hasSprintDurationUnit(result.nodes);
   if (hasSprintOption) {
@@ -11753,6 +11774,7 @@ function parseBoxesAndLines(content) {
   const groupLabels = /* @__PURE__ */ new Set();
   let lastNodeLabel = null;
   let lastSourceIsGroup = false;
+  let lastNodeIndent = 0;
   let descState = null;
   function flushDescription() {
     if (descState && descState.lines.length > 0) {
@@ -12050,7 +12072,8 @@ function parseBoxesAndLines(content) {
       if (trimmed.startsWith("->") || /^-[^>].*->/.test(trimmed)) {
         const gs2 = currentGroupState();
         const inGroup = gs2 && indent > gs2.indent;
-        if (inGroup) {
+        const indentedUnderNode = lastNodeLabel && !lastSourceIsGroup && indent > lastNodeIndent;
+        if (inGroup && !indentedUnderNode) {
           const sourcePrefix = `[${gs2.group.label}]`;
           edgeText = `${sourcePrefix} ${trimmed}`;
         } else if (lastNodeLabel) {
@@ -12090,6 +12113,7 @@ function parseBoxesAndLines(content) {
     }
     lastNodeLabel = node.label;
     lastSourceIsGroup = false;
+    lastNodeIndent = indent;
     const gs = currentGroupState();
     const isGroupChild = gs && indent > gs.indent;
     if (nodeLabels.has(node.label)) {
@@ -12158,7 +12182,11 @@ function parseBoxesAndLines(content) {
   if (result.tagGroups.length > 0) {
     injectDefaultTagMetadata(result.nodes, result.tagGroups);
     validateTagValues(result.nodes, result.tagGroups, pushWarning, suggest);
-    validateTagGroupNames(result.tagGroups, pushWarning);
+    validateTagGroupNames(result.tagGroups, pushWarning, (line11, msg) => {
+      const diag = makeDgmoError(line11, msg);
+      result.diagnostics.push(diag);
+      if (!result.error) result.error = diag.message;
+    });
   }
   return result;
 }
@@ -13134,7 +13162,9 @@ function parseWireframe(content) {
       }
     }
   }
-  validateTagGroupNames(tagGroups, pushWarning);
+  validateTagGroupNames(tagGroups, pushWarning, (line11, msg) => {
+    diagnostics.push(makeDgmoError(line11, msg));
+  });
   const error = diagnostics.find((d) => d.severity === "error") ? formatDgmoError(diagnostics.find((d) => d.severity === "error")) : null;
   return {
     title,
@@ -14062,7 +14092,11 @@ function parseJourneyMap(content, palette) {
   if (result.phases.length === 0 && result.steps.length === 0 && !result.error) {
     return fail(1, "No phases or steps found");
   }
-  validateTagGroupNames(result.tagGroups, warn);
+  validateTagGroupNames(result.tagGroups, warn, (line11, msg) => {
+    const diag = makeDgmoError(line11, msg);
+    result.diagnostics.push(diag);
+    if (!result.error) result.error = formatDgmoError(diag);
+  });
   return result;
 }
 function parseStepLine(trimmed, lineNumber, counter, aliasMap, warn) {
@@ -14292,13 +14326,425 @@ var init_parser16 = __esm({
   }
 });
 
+// src/chart-types.ts
+var chartTypes;
+var init_chart_types = __esm({
+  "src/chart-types.ts"() {
+    "use strict";
+    chartTypes = [
+      // ── Tier 1 — Narrative / architecture diagrams ────────────
+      {
+        id: "journey-map",
+        description: "User experience flow with emotion scores, phases, and annotations",
+        triggers: [
+          "user journey",
+          "customer journey",
+          "customer experience",
+          "customer goes through",
+          "user goes through",
+          "customer path",
+          "customer touchpoints",
+          "cx flow",
+          "ux journey",
+          "onboarding flow",
+          "persona journey",
+          "empathy map",
+          "service blueprint"
+        ]
+      },
+      {
+        id: "c4",
+        description: "System architecture (context, container, component, deployment)",
+        triggers: [
+          "c4 diagram",
+          "system context",
+          "container diagram",
+          "component diagram",
+          "architecture overview",
+          "software architecture"
+        ]
+      },
+      {
+        id: "er",
+        description: "Database schemas and relationships",
+        triggers: [
+          "database schema",
+          "er diagram",
+          "entity relationship",
+          "data model",
+          "tables and relationships",
+          "foreign keys"
+        ]
+      },
+      {
+        id: "class",
+        description: "UML class hierarchies",
+        triggers: [
+          "uml class",
+          "class hierarchy",
+          "class diagram",
+          "inheritance tree",
+          "oop structure"
+        ]
+      },
+      {
+        id: "sequence",
+        description: "Message / interaction flows",
+        triggers: [
+          "sequence diagram",
+          "message flow",
+          "api call flow",
+          "request lifecycle",
+          "interaction diagram",
+          "call sequence"
+        ],
+        fallback: true
+      },
+      {
+        id: "state",
+        description: "State machine / lifecycle transitions",
+        triggers: [
+          "state diagram",
+          "state machine",
+          "state transitions",
+          "lifecycle diagram",
+          "status transitions"
+        ]
+      },
+      {
+        id: "infra",
+        description: "Infrastructure traffic flow with RPS computation",
+        triggers: [
+          "infrastructure diagram",
+          "traffic flow",
+          "request path",
+          "rps",
+          "capacity planning",
+          "network topology"
+        ]
+      },
+      {
+        id: "gantt",
+        description: "Project scheduling with task dependencies and milestones",
+        triggers: [
+          "gantt chart",
+          "project schedule",
+          "sprint plan",
+          "project timeline",
+          "task dependencies",
+          "project milestones"
+        ]
+      },
+      // ── Tier 2 — Specialized structural diagrams ──────────────
+      {
+        id: "timeline",
+        description: "Events, eras, and date ranges",
+        triggers: [
+          "event timeline",
+          "historical timeline",
+          "era chart",
+          "period chart",
+          "project history"
+        ]
+      },
+      {
+        id: "org",
+        description: "Reporting hierarchy",
+        triggers: [
+          "org chart",
+          "organization chart",
+          "reporting structure",
+          "hierarchy chart",
+          "team structure"
+        ]
+      },
+      {
+        id: "sitemap",
+        description: "Site / app navigation structure",
+        triggers: [
+          "sitemap",
+          "site structure",
+          "page hierarchy",
+          "navigation structure",
+          "app navigation"
+        ]
+      },
+      {
+        id: "kanban",
+        description: "Task board columns",
+        triggers: [
+          "kanban board",
+          "task board",
+          "workflow columns",
+          "todo doing done",
+          "agile board"
+        ]
+      },
+      {
+        id: "tech-radar",
+        description: "Technology adoption quadrants (adopt/trial/assess/hold)",
+        triggers: [
+          "tech radar",
+          "technology radar",
+          "tech adoption",
+          "adopt trial assess hold",
+          "tech choices"
+        ]
+      },
+      {
+        id: "mindmap",
+        description: "Radial hierarchy of ideas branching from a central topic",
+        triggers: [
+          "mind map",
+          "brainstorm diagram",
+          "concept map",
+          "idea tree",
+          "radial ideas"
+        ]
+      },
+      {
+        id: "wireframe",
+        description: "Low-fidelity UI layout with panels, controls, and annotations",
+        triggers: [
+          "wireframe",
+          "ui mockup",
+          "screen layout",
+          "page layout",
+          "low-fidelity mockup"
+        ]
+      },
+      {
+        id: "cycle",
+        description: "Cyclical process visualization (PDCA, OODA, DevOps loops)",
+        triggers: [
+          "pdca cycle",
+          "ooda loop",
+          "feedback loop",
+          "cyclical process",
+          "devops loop",
+          "continuous loop"
+        ]
+      },
+      {
+        id: "pyramid",
+        description: "Stacked hierarchy of layers with descriptions (Maslow, DIKW)",
+        triggers: [
+          "pyramid diagram",
+          "layered hierarchy",
+          "maslow hierarchy",
+          "dikw pyramid",
+          "layered model"
+        ]
+      },
+      // ── Tier 3 — Specialized analytical charts ────────────────
+      {
+        id: "quadrant",
+        description: "2x2 positioning matrix",
+        triggers: [
+          "2x2 matrix",
+          "priority matrix",
+          "quadrant chart",
+          "impact effort matrix",
+          "positioning matrix"
+        ]
+      },
+      {
+        id: "venn",
+        description: "Set overlaps",
+        triggers: [
+          "venn diagram",
+          "set overlap",
+          "intersection of",
+          "shared traits",
+          "overlapping circles"
+        ]
+      },
+      {
+        id: "funnel",
+        description: "Conversion pipeline",
+        triggers: [
+          "conversion funnel",
+          "sales funnel",
+          "user funnel",
+          "pipeline stages",
+          "drop-off funnel"
+        ]
+      },
+      {
+        id: "slope",
+        description: "Change between two periods",
+        triggers: [
+          "slope chart",
+          "before and after",
+          "two-period change",
+          "delta chart",
+          "shift comparison"
+        ]
+      },
+      {
+        id: "sankey",
+        description: "Flow / allocation visualization",
+        triggers: [
+          "sankey diagram",
+          "flow allocation",
+          "budget flow",
+          "energy flow",
+          "traffic allocation"
+        ]
+      },
+      {
+        id: "chord",
+        description: "Circular flow relationships",
+        triggers: [
+          "chord diagram",
+          "circular flow",
+          "relationship wheel",
+          "team connections"
+        ]
+      },
+      {
+        id: "arc",
+        description: "Network relationships",
+        triggers: [
+          "arc diagram",
+          "relationship chart",
+          "connection arcs",
+          "network arcs"
+        ]
+      },
+      {
+        id: "wordcloud",
+        description: "Term frequency visualization",
+        triggers: [
+          "word cloud",
+          "tag cloud",
+          "term frequency",
+          "keyword frequency"
+        ]
+      },
+      {
+        id: "heatmap",
+        description: "Matrix intensity visualization",
+        triggers: [
+          "heatmap",
+          "intensity matrix",
+          "activity heatmap",
+          "correlation matrix"
+        ]
+      },
+      {
+        id: "function",
+        description: "Mathematical expressions",
+        triggers: [
+          "function plot",
+          "mathematical plot",
+          "equation chart",
+          "graph y=f(x)"
+        ]
+      },
+      // ── Tier 4 — General-purpose data charts ──────────────────
+      {
+        id: "bar",
+        description: "Categorical comparisons",
+        triggers: ["bar chart", "categorical comparison", "bar graph"],
+        fallback: true
+      },
+      {
+        id: "line",
+        description: "Trends over time",
+        triggers: ["line chart", "trend over time", "time series"],
+        fallback: true
+      },
+      {
+        id: "multi-line",
+        description: "Multiple series trends over time",
+        triggers: [
+          "multi-line chart",
+          "multiple trends",
+          "multiple series over time"
+        ]
+      },
+      {
+        id: "area",
+        description: "Filled line chart",
+        triggers: ["area chart", "filled line", "cumulative trend"]
+      },
+      {
+        id: "pie",
+        description: "Part-to-whole proportions",
+        triggers: ["pie chart", "part to whole", "percentage breakdown"]
+      },
+      {
+        id: "doughnut",
+        description: "Ring-style pie chart",
+        triggers: ["doughnut chart", "donut chart", "ring chart"]
+      },
+      {
+        id: "radar",
+        description: "Multi-dimensional metrics",
+        triggers: ["radar chart", "spider chart", "multi-dimensional metrics"]
+      },
+      {
+        id: "polar-area",
+        description: "Radial bar chart",
+        triggers: ["polar area", "radial bar chart"]
+      },
+      {
+        id: "bar-stacked",
+        description: "Multi-series categorical",
+        triggers: [
+          "stacked bar",
+          "stacked bar chart",
+          "multi-series bar",
+          "composite bar"
+        ]
+      },
+      {
+        id: "scatter",
+        description: "2D data points or bubble chart",
+        triggers: [
+          "scatter plot",
+          "correlation plot",
+          "bubble chart",
+          "2d data points"
+        ]
+      },
+      // ── Tier 5 — Generic catch-alls (listed last on purpose) ──
+      {
+        id: "flowchart",
+        description: "Decision trees and process flows",
+        triggers: [
+          "flowchart",
+          "decision tree",
+          "if-then diagram",
+          "process flow with decisions"
+        ],
+        fallback: true
+      },
+      {
+        id: "boxes-and-lines",
+        description: "General-purpose node-edge diagrams with groups and tags",
+        triggers: [
+          "boxes and lines",
+          "nodes and edges",
+          "generic diagram",
+          "general-purpose network"
+        ],
+        fallback: true
+      }
+    ];
+  }
+});
+
 // src/dgmo-router.ts
 var dgmo_router_exports = {};
 __export(dgmo_router_exports, {
   CHART_TYPE_DESCRIPTIONS: () => CHART_TYPE_DESCRIPTIONS,
+  chartTypeParsers: () => chartTypeParsers,
   getAllChartTypes: () => getAllChartTypes,
   getRenderCategory: () => getRenderCategory,
   isExtendedChartType: () => isExtendedChartType,
+  knownChartTypeIds: () => knownChartTypeIds,
   looksLikeC4: () => looksLikeC4,
   looksLikeGantt: () => looksLikeGantt,
   parseDgmo: () => parseDgmo,
@@ -14357,7 +14803,7 @@ function isExtendedChartType(chartType) {
   return EXTENDED_CHART_TYPES.has(chartType.toLowerCase());
 }
 function getAllChartTypes() {
-  return [...DATA_CHART_TYPES, ...VISUALIZATION_TYPES, ...DIAGRAM_TYPES];
+  return chartTypes.map((c) => c.id);
 }
 function parseDgmo(content) {
   const chartType = parseDgmoChartType(content);
@@ -14372,23 +14818,9 @@ function parseDgmo(content) {
       chartType: null
     };
   }
-  const directParser = PARSE_DISPATCH.get(chartType);
-  if (directParser) {
-    const result2 = directParser(content);
-    return {
-      diagnostics: [...result2.diagnostics, ...detectEmptyContent(content)],
-      chartType
-    };
-  }
-  if (STANDARD_CHART_TYPES2.has(chartType)) {
-    const result2 = parseChart(content);
-    return {
-      diagnostics: [...result2.diagnostics, ...detectEmptyContent(content)],
-      chartType
-    };
-  }
-  if (ECHART_TYPES.has(chartType)) {
-    const result2 = parseExtendedChart(content);
+  const parser = PARSER_BY_ID.get(chartType);
+  if (parser) {
+    const result2 = parser(content);
     return {
       diagnostics: [...result2.diagnostics, ...detectEmptyContent(content)],
       chartType
@@ -14440,7 +14872,7 @@ function detectEmptyContent(content) {
   }
   return [];
 }
-var GANTT_DURATION_RE, GANTT_DATE_RE, C4_TYPE_RE, DATA_CHART_TYPES, VISUALIZATION_TYPES, DIAGRAM_TYPES, EXTENDED_CHART_TYPES, STANDARD_CHART_TYPES2, CHART_TYPE_DESCRIPTIONS, ECHART_TYPES, PARSE_DISPATCH, ALL_KNOWN_TYPES;
+var GANTT_DURATION_RE, GANTT_DATE_RE, C4_TYPE_RE, DATA_CHART_TYPES, VISUALIZATION_TYPES, DIAGRAM_TYPES, EXTENDED_CHART_TYPES, CHART_TYPE_DESCRIPTIONS, chartTypeParsers, knownChartTypeIds, PARSER_BY_ID, ALL_KNOWN_TYPES;
 var init_dgmo_router = __esm({
   "src/dgmo-router.ts"() {
     "use strict";
@@ -14467,6 +14899,7 @@ var init_dgmo_router = __esm({
     init_parser16();
     init_parsing();
     init_diagnostics();
+    init_chart_types();
     GANTT_DURATION_RE = /^\d+(?:\.\d+)?(?:min|bd|d|w|m|q|y|h)(?:\?)?\s+/;
     GANTT_DATE_RE = /^\d{4}-\d{2}-\d{2}(?:\s\d{2}:\d{2})?\s+/;
     C4_TYPE_RE = /\bis\s+an?\s+(person|system|container|component)\b/i;
@@ -14523,91 +14956,57 @@ var init_dgmo_router = __esm({
       "heatmap",
       "funnel"
     ]);
-    STANDARD_CHART_TYPES2 = /* @__PURE__ */ new Set([
-      "bar",
-      "line",
-      "multi-line",
-      "area",
-      "pie",
-      "doughnut",
-      "radar",
-      "polar-area",
-      "bar-stacked"
-    ]);
-    CHART_TYPE_DESCRIPTIONS = {
-      bar: "Bar chart \u2014 categorical comparisons",
-      line: "Line chart \u2014 trends over time; supports era bands (era start -> end Label (color)) for annotating named periods",
-      "multi-line": "Multi-line chart \u2014 multiple series trends over time; supports era bands",
-      area: "Area chart \u2014 filled line chart; supports era bands",
-      pie: "Pie chart \u2014 part-to-whole proportions",
-      doughnut: "Doughnut chart \u2014 ring-style pie chart",
-      radar: "Radar chart \u2014 multi-dimensional metrics",
-      "polar-area": "Polar area chart \u2014 radial bar chart",
-      "bar-stacked": "Stacked bar chart \u2014 multi-series categorical",
-      scatter: "Scatter plot \u2014 2D data points or bubble chart",
-      sankey: "Sankey diagram \u2014 flow/allocation visualization",
-      chord: "Chord diagram \u2014 circular flow relationships",
-      function: "Function plot \u2014 mathematical expressions",
-      heatmap: "Heatmap \u2014 matrix intensity visualization",
-      funnel: "Funnel chart \u2014 conversion pipeline",
-      slope: "Slope chart \u2014 change between two periods",
-      wordcloud: "Word cloud \u2014 term frequency visualization",
-      arc: "Arc diagram \u2014 network relationships",
-      timeline: "Timeline \u2014 events, eras, and date ranges",
-      venn: "Venn diagram \u2014 set overlaps",
-      quadrant: "Quadrant chart \u2014 2x2 positioning matrix",
-      "tech-radar": "Tech radar \u2014 technology adoption quadrants (adopt/trial/assess/hold)",
-      cycle: "Cycle diagram \u2014 cyclical process visualization (PDCA, OODA, DevOps loops)",
-      sequence: "Sequence diagram \u2014 message/interaction flows",
-      flowchart: "Flowchart \u2014 decision trees and process flows",
-      class: "Class diagram \u2014 UML class hierarchies",
-      er: "ER diagram \u2014 database schemas and relationships",
-      org: "Org chart \u2014 hierarchical tree structures",
-      kanban: "Kanban board \u2014 task/workflow columns",
-      c4: "C4 diagram \u2014 system architecture (context, container, component, deployment)",
-      state: "State diagram \u2014 state machine / lifecycle transitions",
-      sitemap: "Sitemap \u2014 navigable UI structure with pages, groups, and cross-link arrows",
-      infra: "Infrastructure diagram \u2014 traffic flow with RPS computation, capacity modeling, and latency analysis",
-      gantt: "Gantt chart \u2014 project scheduling with task dependencies and milestones",
-      "boxes-and-lines": "Boxes and lines \u2014 general-purpose node-edge diagrams with nested groups, tags, and shape inference",
-      mindmap: "Mindmap \u2014 radial hierarchy of ideas branching from a central topic",
-      wireframe: "Wireframe \u2014 low-fidelity UI layout with panels, controls, and annotations",
-      "journey-map": "Journey map \u2014 user experience flow with emotion scores, phases, and annotations",
-      pyramid: "Pyramid \u2014 hierarchical layered pyramid (Maslow, DIKW, learning pyramid); inverted for funnel-of-learning style"
-    };
-    ECHART_TYPES = /* @__PURE__ */ new Set([
-      "scatter",
-      "sankey",
-      "chord",
-      "function",
-      "heatmap",
-      "funnel"
-    ]);
-    PARSE_DISPATCH = /* @__PURE__ */ new Map([
-      ["sequence", (c) => parseSequenceDgmo(c)],
-      ["flowchart", (c) => parseFlowchart(c)],
-      ["class", (c) => parseClassDiagram(c)],
-      ["er", (c) => parseERDiagram(c)],
-      ["org", (c) => parseOrg(c)],
-      ["kanban", (c) => parseKanban(c)],
-      ["c4", (c) => parseC4(c)],
-      ["state", (c) => parseState(c)],
-      ["sitemap", (c) => parseSitemap(c)],
-      ["infra", (c) => parseInfra(c)],
-      ["gantt", (c) => parseGantt(c)],
-      ["boxes-and-lines", (c) => parseBoxesAndLines(c)],
-      ["mindmap", (c) => parseMindmap(c)],
-      ["wireframe", (c) => parseWireframe(c)],
-      ["tech-radar", (c) => parseTechRadar(c)],
-      ["cycle", (c) => parseCycle(c)],
-      ["journey-map", (c) => parseJourneyMap(c)],
-      ["pyramid", (c) => parsePyramid(c)]
-    ]);
-    ALL_KNOWN_TYPES = /* @__PURE__ */ new Set([
-      ...DATA_CHART_TYPES,
-      ...VISUALIZATION_TYPES,
-      ...DIAGRAM_TYPES
-    ]);
+    CHART_TYPE_DESCRIPTIONS = Object.fromEntries(chartTypes.map((c) => [c.id, c.description]));
+    chartTypeParsers = [
+      // Structured diagrams (direct parsers)
+      ["sequence", parseSequenceDgmo],
+      ["flowchart", parseFlowchart],
+      ["class", parseClassDiagram],
+      ["er", parseERDiagram],
+      ["state", parseState],
+      ["org", parseOrg],
+      ["kanban", parseKanban],
+      ["c4", parseC4],
+      ["sitemap", parseSitemap],
+      ["infra", parseInfra],
+      ["gantt", parseGantt],
+      ["boxes-and-lines", parseBoxesAndLines],
+      ["mindmap", parseMindmap],
+      ["wireframe", parseWireframe],
+      ["tech-radar", parseTechRadar],
+      ["cycle", parseCycle],
+      ["journey-map", parseJourneyMap],
+      ["pyramid", parsePyramid],
+      // Standard ECharts charts (parseChart)
+      ["bar", parseChart],
+      ["line", parseChart],
+      ["multi-line", parseChart],
+      ["area", parseChart],
+      ["pie", parseChart],
+      ["doughnut", parseChart],
+      ["radar", parseChart],
+      ["polar-area", parseChart],
+      ["bar-stacked", parseChart],
+      // Extended ECharts charts (parseExtendedChart)
+      ["scatter", parseExtendedChart],
+      ["sankey", parseExtendedChart],
+      ["chord", parseExtendedChart],
+      ["function", parseExtendedChart],
+      ["heatmap", parseExtendedChart],
+      ["funnel", parseExtendedChart],
+      // D3 visualizations (parseVisualization)
+      ["slope", parseVisualization],
+      ["wordcloud", parseVisualization],
+      ["arc", parseVisualization],
+      ["timeline", parseVisualization],
+      ["venn", parseVisualization],
+      ["quadrant", parseVisualization]
+    ];
+    knownChartTypeIds = chartTypeParsers.map(
+      ([id]) => id
+    );
+    PARSER_BY_ID = new Map(chartTypeParsers);
+    ALL_KNOWN_TYPES = new Set(knownChartTypeIds);
   }
 });
 
@@ -19643,7 +20042,16 @@ function renderBoxesAndLines(container, parsed, layout, palette, isDark, options
       const clipId = `bl-clip-${group.label.replace(/[[\]\s]/g, "")}`;
       groupG.append("clipPath").attr("id", clipId).append("rect").attr("x", gx).attr("y", gy).attr("width", group.width).attr("height", group.height).attr("rx", NODE_RX);
       groupG.append("rect").attr("x", gx).attr("y", gy + group.height - COLLAPSE_BAR_HEIGHT3).attr("width", group.width).attr("height", COLLAPSE_BAR_HEIGHT3).attr("fill", strokeColor).attr("clip-path", `url(#${clipId})`).attr("class", "bl-collapse-bar");
-      groupG.append("text").attr("class", "bl-group-label").attr("x", group.x).attr("y", group.y).attr("text-anchor", "middle").attr("dominant-baseline", "central").attr("font-family", FONT_FAMILY).attr("font-size", GROUP_LABEL_FONT_SIZE).attr("font-weight", "600").attr("fill", palette.text).text(group.label);
+      const maxLabelLines = Math.max(
+        2,
+        Math.floor((group.height - 16) / (MIN_NODE_FONT_SIZE * 1.3))
+      );
+      const fitted = fitLabelToHeader(group.label, group.width, maxLabelLines);
+      const lineH = fitted.fontSize * 1.3;
+      const totalH = fitted.lines.length * lineH;
+      for (let li = 0; li < fitted.lines.length; li++) {
+        groupG.append("text").attr("class", "bl-group-label").attr("x", group.x).attr("y", group.y - totalH / 2 + lineH / 2 + li * lineH).attr("text-anchor", "middle").attr("dominant-baseline", "central").attr("font-family", FONT_FAMILY).attr("font-size", fitted.fontSize).attr("font-weight", "600").attr("fill", palette.text).text(fitted.lines[li]);
+      }
     } else {
       groupG.append("rect").attr("x", gx).attr("y", gy).attr("width", group.width).attr("height", groupHeight).attr("rx", GROUP_RX).attr("ry", GROUP_RX).attr("fill", mix(palette.surface, palette.bg, 40)).attr("stroke", palette.textMuted).attr("stroke-width", 1).attr("stroke-opacity", 0.35);
       groupG.append("text").attr("class", "bl-group-label").attr("x", gx + group.width / 2).attr("y", gy + 18).attr("text-anchor", "middle").attr("font-family", FONT_FAMILY).attr("font-size", GROUP_LABEL_FONT_SIZE).attr("font-weight", "600").attr("fill", palette.text).text(group.label);
@@ -32154,7 +32562,8 @@ function layoutJourneyMap(parsed, palette, options) {
   const annoIconIndent = ANNO_ICON_SIZE + ANNO_ICON_GAP;
   const annoTextW = STEP_CARD_WIDTH - CARD_PADDING_X2 * 2 - annoIconIndent;
   const descTextWidth = STEP_CARD_WIDTH - CARD_PADDING_X2 * 2;
-  const charWidth = 4.8;
+  const FONT_SIZE_META2 = 10;
+  const charWidth = FONT_SIZE_META2 * 0.6;
   const titleTextWidth = STEP_CARD_WIDTH - CARD_PADDING_X2 * 2;
   const titleCharWidth = 6.5;
   const TITLE_LINE_HEIGHT2 = 16;
@@ -34537,7 +34946,6 @@ __export(renderer_exports16, {
   applyPositionOverrides: () => applyPositionOverrides,
   buildNoteMessageMap: () => buildNoteMessageMap,
   buildRenderSequence: () => buildRenderSequence,
-  collectNoteLineNumbers: () => collectNoteLineNumbers,
   computeActivations: () => computeActivations,
   groupMessagesBySection: () => groupMessagesBySection,
   parseInlineMarkdown: () => parseInlineMarkdown,
@@ -34920,9 +35328,6 @@ function renderSequenceDiagram(container, parsed, palette, isDark, _onNavigateTo
   const groups = collapsed ? collapsed.groups : parsed.groups;
   const collapsedGroupIds = collapsed?.collapsedGroupIds ?? /* @__PURE__ */ new Map();
   const collapsedSections = options?.collapsedSections;
-  const expandedNoteLines = options?.expandedNoteLines;
-  const collapseNotesDisabled = parsedOptions["collapse-notes"]?.toLowerCase() === "no";
-  const isNoteExpanded = (note) => expandedNoteLines === void 0 || collapseNotesDisabled || expandedNoteLines.has(note.lineNumber);
   const sourceParticipants = collapsed ? collapsed.participants : parsed.participants;
   const participants = applyPositionOverrides(
     applyGroupOrdering(sourceParticipants, groups, messages)
@@ -35091,7 +35496,7 @@ function renderSequenceDiagram(container, parsed, palette, isDark, _onNavigateTo
           const note = els[j];
           const sc = isNoteAfterSelfCall(note);
           const maxW = noteEffectiveMaxW(note.participantId, note.position, sc);
-          const noteH = isNoteExpanded(note) ? computeNoteHeight(note.text, charsForWidth(maxW)) : COLLAPSED_NOTE_H;
+          const noteH = computeNoteHeight(note.text, charsForWidth(maxW));
           totalExtent += noteH + NOTE_OFFSET_BELOW;
           j++;
         }
@@ -35287,7 +35692,10 @@ function renderSequenceDiagram(container, parsed, palette, isDark, _onNavigateTo
               prevNote.position,
               isNoteAfterSelfCall(prevNote)
             );
-            const prevNoteH = isNoteExpanded(prevNote) ? computeNoteHeight(prevNote.text, charsForWidth(prevMaxW)) : COLLAPSED_NOTE_H;
+            const prevNoteH = computeNoteHeight(
+              prevNote.text,
+              charsForWidth(prevMaxW)
+            );
             noteTopY = prevNoteY + prevNoteH + NOTE_OFFSET_BELOW;
           } else {
             noteTopY = stepY(si) + noteOffsetBelow(el);
@@ -35318,7 +35726,7 @@ function renderSequenceDiagram(container, parsed, palette, isDark, _onNavigateTo
       note.position,
       isNoteAfterSelfCall(note)
     );
-    const noteH = isNoteExpanded(note) ? computeNoteHeight(note.text, charsForWidth(maxW)) : COLLAPSED_NOTE_H;
+    const noteH = computeNoteHeight(note.text, charsForWidth(maxW));
     contentBottomY = Math.max(
       contentBottomY,
       noteTopY + noteH + NOTE_TRAILING_GAP
@@ -35388,24 +35796,6 @@ function renderSequenceDiagram(container, parsed, palette, isDark, _onNavigateTo
       titleEl.attr("data-line-number", parsed.titleLineNumber);
     }
   }
-  const allNoteLineNumbers = [];
-  const collectNoteLines = (els) => {
-    for (const el of els) {
-      if (isSequenceNote(el)) {
-        allNoteLineNumbers.push(el.lineNumber);
-      } else if (isSequenceBlock(el)) {
-        collectNoteLines(el.children);
-        if ("elseChildren" in el) collectNoteLines(el.elseChildren);
-        if ("branches" in el && Array.isArray(el.branches)) {
-          for (const branch of el.branches) {
-            collectNoteLines(branch.children);
-          }
-        }
-      }
-    }
-  };
-  collectNoteLines(elements);
-  const showNotesControl = allNoteLineNumbers.length > 0 && !collapseNotesDisabled && expandedNoteLines !== void 0;
   const hasTagGroups = parsed.tagGroups.length > 0;
   const collapsedGroupNames = /* @__PURE__ */ new Set();
   const collapsedGroupMeta = /* @__PURE__ */ new Map();
@@ -35817,7 +36207,6 @@ function renderSequenceDiagram(container, parsed, palette, isDark, _onNavigateTo
     }
   });
   const noteFill = isDark ? mix(palette.surface, palette.bg, 50) : mix(palette.bg, palette.surface, 15);
-  const collapsedNoteFill = mix(palette.textMuted, palette.bg, 15);
   const renderNoteElements = (els) => {
     for (const el of els) {
       if (isSequenceNote(el)) {
@@ -35825,83 +36214,54 @@ function renderSequenceDiagram(container, parsed, palette, isDark, _onNavigateTo
         if (px === void 0) continue;
         const noteTopY = noteYMap.get(el);
         if (noteTopY === void 0) continue;
-        const expanded = isNoteExpanded(el);
         const isRight = el.position === "right";
-        if (expanded) {
-          const afterSelfCall = isNoteAfterSelfCall(el);
-          const maxW = noteEffectiveMaxW(
-            el.participantId,
-            el.position,
-            afterSelfCall
-          );
-          const maxChars = charsForWidth(maxW);
-          const wrappedLines = wrapTextLines(el.text, maxChars);
-          const noteH = wrappedLines.length * NOTE_LINE_H + NOTE_PAD_V * 2;
-          const maxLineLen = Math.max(...wrappedLines.map((l) => l.length));
-          const noteW = Math.min(
-            maxW,
-            Math.max(80, maxLineLen * NOTE_CHAR_W + NOTE_PAD_H * 2 + NOTE_FOLD)
-          );
-          const rightOffset = afterSelfCall && isRight ? ACTIVATION_WIDTH / 2 + SELF_CALL_WIDTH + NOTE_GAP : ACTIVATION_WIDTH + NOTE_GAP;
-          const noteX = isRight ? px + rightOffset : px - ACTIVATION_WIDTH - NOTE_GAP - noteW;
-          const noteG = svg.append("g").attr("class", "note").attr("data-note-toggle", "").attr("data-line-number", String(el.lineNumber)).attr("data-line-end", String(el.endLineNumber));
-          noteG.append("path").attr(
-            "d",
-            [
-              `M ${noteX} ${noteTopY}`,
-              `L ${noteX + noteW - NOTE_FOLD} ${noteTopY}`,
-              `L ${noteX + noteW} ${noteTopY + NOTE_FOLD}`,
-              `L ${noteX + noteW} ${noteTopY + noteH}`,
-              `L ${noteX} ${noteTopY + noteH}`,
-              "Z"
-            ].join(" ")
-          ).attr("fill", noteFill).attr("stroke", palette.textMuted).attr("stroke-width", 0.75).attr("class", "note-box");
-          noteG.append("path").attr(
-            "d",
-            [
-              `M ${noteX + noteW - NOTE_FOLD} ${noteTopY}`,
-              `L ${noteX + noteW - NOTE_FOLD} ${noteTopY + NOTE_FOLD}`,
-              `L ${noteX + noteW} ${noteTopY + NOTE_FOLD}`
-            ].join(" ")
-          ).attr("fill", "none").attr("stroke", palette.textMuted).attr("stroke-width", 0.75).attr("class", "note-fold");
-          wrappedLines.forEach((line11, li) => {
-            const textY = noteTopY + NOTE_PAD_V + (li + 1) * NOTE_LINE_H - 3;
-            const isBullet = line11.startsWith("- ");
-            const bulletIndent = isBullet ? 10 : 0;
-            const displayLine = isBullet ? line11.slice(2) : line11;
-            const textEl = noteG.append("text").attr("x", noteX + NOTE_PAD_H + bulletIndent).attr("y", textY).attr("fill", palette.text).attr("font-size", NOTE_FONT_SIZE).attr("class", "note-text");
-            if (isBullet) {
-              noteG.append("text").attr("x", noteX + NOTE_PAD_H).attr("y", textY).attr("fill", palette.text).attr("font-size", NOTE_FONT_SIZE).text("\u2022");
-            }
-            renderInlineText(textEl, displayLine, palette, NOTE_FONT_SIZE);
-          });
-        } else {
-          const cFold = 6;
-          const afterSelfCallC = isNoteAfterSelfCall(el);
-          const rightOffsetC = afterSelfCallC && isRight ? ACTIVATION_WIDTH / 2 + SELF_CALL_WIDTH + NOTE_GAP : ACTIVATION_WIDTH + NOTE_GAP;
-          const noteX = isRight ? px + rightOffsetC : px - ACTIVATION_WIDTH - NOTE_GAP - COLLAPSED_NOTE_W;
-          const noteG = svg.append("g").attr("class", "note note-collapsed").attr("data-note-toggle", "").attr("data-line-number", String(el.lineNumber)).attr("data-line-end", String(el.endLineNumber)).style("cursor", "pointer");
-          noteG.append("path").attr(
-            "d",
-            [
-              `M ${noteX} ${noteTopY}`,
-              `L ${noteX + COLLAPSED_NOTE_W - cFold} ${noteTopY}`,
-              `L ${noteX + COLLAPSED_NOTE_W} ${noteTopY + cFold}`,
-              `L ${noteX + COLLAPSED_NOTE_W} ${noteTopY + COLLAPSED_NOTE_H}`,
-              `L ${noteX} ${noteTopY + COLLAPSED_NOTE_H}`,
-              "Z"
-            ].join(" ")
-          ).attr("fill", collapsedNoteFill).attr("stroke", palette.border).attr("stroke-width", 0.75).attr("class", "note-box");
-          noteG.append("path").attr(
-            "d",
-            [
-              `M ${noteX + COLLAPSED_NOTE_W - cFold} ${noteTopY}`,
-              `L ${noteX + COLLAPSED_NOTE_W - cFold} ${noteTopY + cFold}`,
-              `L ${noteX + COLLAPSED_NOTE_W} ${noteTopY + cFold}`
-            ].join(" ")
-          ).attr("fill", "none").attr("stroke", palette.border).attr("stroke-width", 0.75).attr("class", "note-fold");
-          noteG.append("text").attr("x", noteX + COLLAPSED_NOTE_W / 2).attr("y", noteTopY + COLLAPSED_NOTE_H / 2 + 3).attr("text-anchor", "middle").attr("fill", palette.textMuted).attr("font-size", 9).attr("class", "note-text").text("\u2026");
-        }
+        const afterSelfCall = isNoteAfterSelfCall(el);
+        const maxW = noteEffectiveMaxW(
+          el.participantId,
+          el.position,
+          afterSelfCall
+        );
+        const maxChars = charsForWidth(maxW);
+        const wrappedLines = wrapTextLines(el.text, maxChars);
+        const noteH = wrappedLines.length * NOTE_LINE_H + NOTE_PAD_V * 2;
+        const maxLineLen = Math.max(...wrappedLines.map((l) => l.length));
+        const noteW = Math.min(
+          maxW,
+          Math.max(80, maxLineLen * NOTE_CHAR_W + NOTE_PAD_H * 2 + NOTE_FOLD)
+        );
+        const rightOffset = afterSelfCall && isRight ? ACTIVATION_WIDTH / 2 + SELF_CALL_WIDTH + NOTE_GAP : ACTIVATION_WIDTH + NOTE_GAP;
+        const noteX = isRight ? px + rightOffset : px - ACTIVATION_WIDTH - NOTE_GAP - noteW;
+        const noteG = svg.append("g").attr("class", "note").attr("data-note-toggle", "").attr("data-line-number", String(el.lineNumber)).attr("data-line-end", String(el.endLineNumber));
+        noteG.append("path").attr(
+          "d",
+          [
+            `M ${noteX} ${noteTopY}`,
+            `L ${noteX + noteW - NOTE_FOLD} ${noteTopY}`,
+            `L ${noteX + noteW} ${noteTopY + NOTE_FOLD}`,
+            `L ${noteX + noteW} ${noteTopY + noteH}`,
+            `L ${noteX} ${noteTopY + noteH}`,
+            "Z"
+          ].join(" ")
+        ).attr("fill", noteFill).attr("stroke", palette.textMuted).attr("stroke-width", 0.75).attr("class", "note-box");
+        noteG.append("path").attr(
+          "d",
+          [
+            `M ${noteX + noteW - NOTE_FOLD} ${noteTopY}`,
+            `L ${noteX + noteW - NOTE_FOLD} ${noteTopY + NOTE_FOLD}`,
+            `L ${noteX + noteW} ${noteTopY + NOTE_FOLD}`
+          ].join(" ")
+        ).attr("fill", "none").attr("stroke", palette.textMuted).attr("stroke-width", 0.75).attr("class", "note-fold");
+        wrappedLines.forEach((line11, li) => {
+          const textY = noteTopY + NOTE_PAD_V + (li + 1) * NOTE_LINE_H - 3;
+          const isBullet = line11.startsWith("- ");
+          const bulletIndent = isBullet ? 10 : 0;
+          const displayLine = isBullet ? line11.slice(2) : line11;
+          const textEl = noteG.append("text").attr("x", noteX + NOTE_PAD_H + bulletIndent).attr("y", textY).attr("fill", palette.text).attr("font-size", NOTE_FONT_SIZE).attr("class", "note-text");
+          if (isBullet) {
+            noteG.append("text").attr("x", noteX + NOTE_PAD_H).attr("y", textY).attr("fill", palette.text).attr("font-size", NOTE_FONT_SIZE).text("\u2022");
+          }
+          renderInlineText(textEl, displayLine, palette, NOTE_FONT_SIZE);
+        });
       } else if (isSequenceBlock(el)) {
         renderNoteElements(el.children);
         if (el.elseIfBranches) {
@@ -35916,8 +36276,7 @@ function renderSequenceDiagram(container, parsed, palette, isDark, _onNavigateTo
   if (elements && elements.length > 0) {
     renderNoteElements(elements);
   }
-  if (hasTagGroups || showNotesControl) {
-    const controlsExpanded = options?.controlsExpanded ?? false;
+  if (hasTagGroups) {
     const legendY = TOP_MARGIN + titleOffset;
     const resolvedGroups = parsed.tagGroups.filter((tg) => tg.entries.length > 0).map((tg) => ({
       name: tg.name,
@@ -35926,37 +36285,16 @@ function renderSequenceDiagram(container, parsed, palette, isDark, _onNavigateTo
         color: e.color
       }))
     }));
-    const allExpanded = showNotesControl && (options?.expandAllNotes ?? false);
-    const controlsGroup = showNotesControl ? {
-      toggles: [
-        {
-          id: "expand-all-notes",
-          type: "toggle",
-          label: "Expand Notes",
-          active: allExpanded,
-          onToggle: () => {
-          }
-        }
-      ]
-    } : void 0;
     const legendConfig = {
       groups: resolvedGroups,
       position: { placement: "top-center", titleRelation: "below-title" },
-      mode: "fixed",
-      controlsGroup
+      mode: "fixed"
     };
     const legendState = {
       activeGroup: activeTagGroup ?? null,
-      controlsExpanded
-    };
-    const legendCallbacks = {
-      onControlsExpand: () => {
-        options?.onToggleControlsExpand?.();
-      },
-      onControlsToggle: (_toggleId, active) => {
-        options?.onExpandAllNotes?.(active);
-      }
+      controlsExpanded: false
     };
+    const legendCallbacks = {};
     const legendG = svg.append("g").attr("class", "sequence-legend").attr("transform", `translate(0,${legendY})`);
     renderLegendD3(
       legendG,
@@ -35995,26 +36333,6 @@ function buildNoteMessageMap(elements) {
   walk(elements);
   return map;
 }
-function collectNoteLineNumbers(elements) {
-  const result = [];
-  const walk = (els) => {
-    for (const el of els) {
-      if (isSequenceNote(el)) {
-        result.push(el.lineNumber);
-      } else if (isSequenceBlock(el)) {
-        walk(el.children);
-        if (el.elseIfBranches) {
-          for (const branch of el.elseIfBranches) {
-            walk(branch.children);
-          }
-        }
-        walk(el.elseChildren);
-      }
-    }
-  };
-  walk(elements);
-  return result;
-}
 function renderParticipant(svg, participant, cx, cy, palette, isDark, color, tagAttr) {
   const g = svg.append("g").attr("transform", `translate(${cx}, ${cy})`).attr("class", "participant").attr("data-participant-id", participant.id);
   if (tagAttr) {
@@ -36070,7 +36388,7 @@ function renderParticipant(svg, participant, cx, cy, palette, isDark, color, tag
     });
   }
 }
-var d3Selection18, PARTICIPANT_GAP, PARTICIPANT_BOX_WIDTH, PARTICIPANT_BOX_HEIGHT, TOP_MARGIN, TITLE_HEIGHT8, PARTICIPANT_Y_OFFSET, SERVICE_BORDER_RADIUS, MESSAGE_START_OFFSET, LIFELINE_TAIL, ARROWHEAD_SIZE, NOTE_MAX_W, NOTE_FOLD, NOTE_PAD_H, NOTE_PAD_V, NOTE_FONT_SIZE, NOTE_LINE_H, NOTE_GAP, NOTE_CHAR_W, NOTE_CHARS_PER_LINE, COLLAPSED_NOTE_H, COLLAPSED_NOTE_W, ACTIVATION_WIDTH, SELF_CALL_HEIGHT, SELF_CALL_WIDTH, NOTE_LANE_MAX, LABEL_CHAR_WIDTH, LABEL_MAX_CHARS, fill, stroke, SW, W, H;
+var d3Selection18, PARTICIPANT_GAP, PARTICIPANT_BOX_WIDTH, PARTICIPANT_BOX_HEIGHT, TOP_MARGIN, TITLE_HEIGHT8, PARTICIPANT_Y_OFFSET, SERVICE_BORDER_RADIUS, MESSAGE_START_OFFSET, LIFELINE_TAIL, ARROWHEAD_SIZE, NOTE_MAX_W, NOTE_FOLD, NOTE_PAD_H, NOTE_PAD_V, NOTE_FONT_SIZE, NOTE_LINE_H, NOTE_GAP, NOTE_CHAR_W, NOTE_CHARS_PER_LINE, ACTIVATION_WIDTH, SELF_CALL_HEIGHT, SELF_CALL_WIDTH, NOTE_LANE_MAX, LABEL_CHAR_WIDTH, LABEL_MAX_CHARS, fill, stroke, SW, W, H;
 var init_renderer16 = __esm({
   "src/sequence/renderer.ts"() {
     "use strict";
@@ -36106,8 +36424,6 @@ var init_renderer16 = __esm({
     NOTE_CHARS_PER_LINE = Math.floor(
       (NOTE_MAX_W - NOTE_PAD_H * 2 - NOTE_FOLD) / NOTE_CHAR_W
     );
-    COLLAPSED_NOTE_H = 20;
-    COLLAPSED_NOTE_W = 40;
     ACTIVATION_WIDTH = 10;
     SELF_CALL_HEIGHT = 25;
     SELF_CALL_WIDTH = 30;
@@ -37073,7 +37389,12 @@ function parseVisualization(content, palette) {
       );
       validateTagGroupNames(
         result.timelineTagGroups,
-        (line11, msg) => result.diagnostics.push(makeDgmoError(line11, msg, "warning"))
+        (line11, msg) => result.diagnostics.push(makeDgmoError(line11, msg, "warning")),
+        (line11, msg) => {
+          const diag = makeDgmoError(line11, msg);
+          result.diagnostics.push(diag);
+          if (!result.error) result.error = formatDgmoError(diag);
+        }
       );
       for (const group of result.timelineTagGroups) {
         if (!group.defaultValue) continue;
@@ -40883,6 +41204,7 @@ var require_lz_string = __commonJS({
 var index_exports = {};
 __export(index_exports, {
   ALL_CHART_TYPES: () => ALL_CHART_TYPES,
+  AMBIGUITY_THRESHOLD: () => AMBIGUITY_THRESHOLD,
   ARROW_DIAGNOSTIC_CODES: () => ARROW_DIAGNOSTIC_CODES,
   CHART_TYPES: () => CHART_TYPES,
   CHART_TYPE_DESCRIPTIONS: () => CHART_TYPE_DESCRIPTIONS,
@@ -40891,6 +41213,7 @@ __export(index_exports, {
   INFRA_BEHAVIOR_KEYS: () => INFRA_BEHAVIOR_KEYS,
   LEGEND_HEIGHT: () => LEGEND_HEIGHT,
   METADATA_KEY_SET: () => METADATA_KEY_SET,
+  MIN_PRIMARY_SCORE: () => MIN_PRIMARY_SCORE,
   PIPE_METADATA: () => PIPE_METADATA,
   RECOGNIZED_COLOR_NAMES: () => RECOGNIZED_COLOR_NAMES,
   RULE_COUNT: () => RULE_COUNT,
@@ -40906,13 +41229,15 @@ __export(index_exports, {
   buildTagLaneRowList: () => buildTagLaneRowList,
   calculateSchedule: () => calculateSchedule,
   catppuccinPalette: () => catppuccinPalette,
+  chartTypeConfidence: () => confidence,
+  chartTypeParsers: () => chartTypeParsers,
+  chartTypes: () => chartTypes,
   collapseBoxesAndLines: () => collapseBoxesAndLines,
   collapseMindmapTree: () => collapseMindmapTree,
   collapseOrgTree: () => collapseOrgTree,
   collapseSitemapTree: () => collapseSitemapTree,
   collapseStateGroups: () => collapseStateGroups,
   collectDiagramRoles: () => collectDiagramRoles,
-  collectNoteLineNumbers: () => collectNoteLineNumbers,
   collectTasks: () => collectTasks,
   colorNames: () => colorNames,
   computeActivations: () => computeActivations,
@@ -40958,6 +41283,7 @@ __export(index_exports, {
   isSequenceBlock: () => isSequenceBlock,
   isSequenceNote: () => isSequenceNote,
   isValidHex: () => isValidHex,
+  knownChartTypeIds: () => knownChartTypeIds,
   layoutBoxesAndLines: () => layoutBoxesAndLines,
   layoutC4Components: () => layoutC4Components,
   layoutC4Containers: () => layoutC4Containers,
@@ -40980,10 +41306,12 @@ __export(index_exports, {
   looksLikeState: () => looksLikeState,
   makeDgmoError: () => makeDgmoError,
   matchColorParens: () => matchColorParens,
+  matchesContiguously: () => matchesContiguously,
   mix: () => mix,
   monokaiPalette: () => monokaiPalette,
   nord: () => nord,
   nordPalette: () => nordPalette,
+  normalizeChartTypePrompt: () => normalize,
   oneDarkPalette: () => oneDarkPalette,
   orderArcNodes: () => orderArcNodes,
   parseAndLayoutInfra: () => parseAndLayoutInfra,
@@ -41075,9 +41403,11 @@ __export(index_exports, {
   resolveTaskName: () => resolveTaskName,
   rollUpContextRelationships: () => rollUpContextRelationships,
   rosePinePalette: () => rosePinePalette,
+  scoreChartType: () => scoreChartType,
   seriesColors: () => seriesColors,
   shade: () => shade,
   solarizedPalette: () => solarizedPalette,
+  suggestChartTypes: () => suggestChartTypes,
   tint: () => tint,
   tokyoNightPalette: () => tokyoNightPalette,
   truncateBareUrl: () => truncateBareUrl,
@@ -41148,6 +41478,83 @@ async function render(content, options) {
   return { svg, diagnostics };
 }
 
+// src/index.ts
+init_chart_types();
+
+// src/chart-type-scoring.ts
+init_chart_types();
+var TYPOGRAPHIC_REPLACEMENTS = [
+  [/[‘’]/g, "'"],
+  // curly single quotes
+  [/[“”]/g, '"'],
+  // curly double quotes
+  [/[–—]/g, "-"],
+  // en/em dash
+  [/×/g, "x"]
+  // unicode multiplication → ASCII (for "2×2" vs "2x2")
+];
+function normalize(s) {
+  let out = s.normalize("NFKD").toLowerCase();
+  for (const [re, repl] of TYPOGRAPHIC_REPLACEMENTS)
+    out = out.replace(re, repl);
+  return out.split(/[^a-z0-9]+/).filter(Boolean);
+}
+function matchesContiguously(promptTokens, triggerTokens) {
+  if (triggerTokens.length === 0 || triggerTokens.length > promptTokens.length)
+    return false;
+  outer: for (let i = 0; i <= promptTokens.length - triggerTokens.length; i++) {
+    for (let j = 0; j < triggerTokens.length; j++) {
+      if (promptTokens[i + j] !== triggerTokens[j]) continue outer;
+    }
+    return true;
+  }
+  return false;
+}
+function scoreChartType(prompt, type) {
+  const promptTokens = normalize(prompt);
+  const matched = [];
+  let score = 0;
+  for (const trigger of type.triggers) {
+    const triggerTokens = normalize(trigger);
+    if (matchesContiguously(promptTokens, triggerTokens)) {
+      matched.push(trigger);
+      score += triggerTokens.length;
+    }
+  }
+  const descTokens = new Set(normalize(type.description));
+  let descHits = 0;
+  for (const t of promptTokens) if (descTokens.has(t)) descHits++;
+  score += descHits * 0.25;
+  return { score, matched };
+}
+var MIN_PRIMARY_SCORE = 1;
+var AMBIGUITY_THRESHOLD = 0.5;
+function confidence(top, second) {
+  if (top < MIN_PRIMARY_SCORE) return "ambiguous";
+  if (second === 0) return "high";
+  if (top >= second * 2) return "high";
+  if (top - second < AMBIGUITY_THRESHOLD) return "ambiguous";
+  return "medium";
+}
+function suggestChartTypes(prompt) {
+  const scored = [];
+  for (const type of chartTypes) {
+    const { score, matched } = scoreChartType(prompt, type);
+    if (score > 0) scored.push({ type, score, matched });
+  }
+  scored.sort((a, b) => b.score - a.score);
+  const fallback = chartTypes.filter((c) => c.fallback);
+  const topScore = scored[0]?.score ?? 0;
+  const secondScore = scored[1]?.score ?? 0;
+  const fellBack = topScore < MIN_PRIMARY_SCORE;
+  return {
+    ranked: scored,
+    fallback,
+    confidence: confidence(topScore, secondScore),
+    fellBack
+  };
+}
+
 // src/index.ts
 init_dgmo_router();
 init_chart();
@@ -42059,10 +42466,6 @@ var COMPLETION_REGISTRY = /* @__PURE__ */ new Map([
         description: "Show activation bars",
         values: ["on", "off"]
       },
-      "collapse-notes": {
-        description: "Collapse note blocks",
-        values: ["yes", "no"]
-      },
       "active-tag": { description: "Active tag group name" }
     })
   ],
@@ -42800,6 +43203,7 @@ init_parsing();
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   ALL_CHART_TYPES,
+  AMBIGUITY_THRESHOLD,
   ARROW_DIAGNOSTIC_CODES,
   CHART_TYPES,
   CHART_TYPE_DESCRIPTIONS,
@@ -42808,6 +43212,7 @@ init_parsing();
   INFRA_BEHAVIOR_KEYS,
   LEGEND_HEIGHT,
   METADATA_KEY_SET,
+  MIN_PRIMARY_SCORE,
   PIPE_METADATA,
   RECOGNIZED_COLOR_NAMES,
   RULE_COUNT,
@@ -42823,13 +43228,15 @@ init_parsing();
   buildTagLaneRowList,
   calculateSchedule,
   catppuccinPalette,
+  chartTypeConfidence,
+  chartTypeParsers,
+  chartTypes,
   collapseBoxesAndLines,
   collapseMindmapTree,
   collapseOrgTree,
   collapseSitemapTree,
   collapseStateGroups,
   collectDiagramRoles,
-  collectNoteLineNumbers,
   collectTasks,
   colorNames,
   computeActivations,
@@ -42875,6 +43282,7 @@ init_parsing();
   isSequenceBlock,
   isSequenceNote,
   isValidHex,
+  knownChartTypeIds,
   layoutBoxesAndLines,
   layoutC4Components,
   layoutC4Containers,
@@ -42897,10 +43305,12 @@ init_parsing();
   looksLikeState,
   makeDgmoError,
   matchColorParens,
+  matchesContiguously,
   mix,
   monokaiPalette,
   nord,
   nordPalette,
+  normalizeChartTypePrompt,
   oneDarkPalette,
   orderArcNodes,
   parseAndLayoutInfra,
@@ -42992,9 +43402,11 @@ init_parsing();
   resolveTaskName,
   rollUpContextRelationships,
   rosePinePalette,
+  scoreChartType,
   seriesColors,
   shade,
   solarizedPalette,
+  suggestChartTypes,
   tint,
   tokyoNightPalette,
   truncateBareUrl,