@diagrammo/dgmo 0.8.23 → 0.8.26

package/src/cli.ts

@@ -1,7 +1,7 @@
 /* eslint-disable no-console */
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
 import { execSync } from 'node:child_process';
-import { homedir } from 'node:os';
+import { homedir, platform } from 'node:os';
 import { resolve, join, basename, extname } from 'node:path';
 import { createInterface } from 'node:readline';
 import { Resvg } from '@resvg/resvg-js';
@@ -467,10 +467,6 @@ Options:
                        With stdin and no -o, PNG is written to stdout
   --theme <theme>      Theme: ${THEMES.join(', ')} (default: light)
   --palette <name>     Palette: ${PALETTES.join(', ')} (default: nord)
-  --c4-level <level>   C4 render level: context (default), containers, components, deployment
-  --c4-system <name>   System to drill into (with --c4-level containers or components)
-  --c4-container <name> Container to drill into (with --c4-level components)
-  --tag-group <name>   Pre-select a tag group for static export coloring
   --copy               Copy URL to clipboard (only with -o url)
   --json               Output structured JSON to stdout
   --chart-types        List all supported chart types
@@ -482,6 +478,11 @@ Options:
   --install-codex-integration
                        Full Codex CLI setup: write AGENTS.md to the project and configure
                        the dgmo MCP server in .codex/config.toml (project) or ~/.codex/config.toml (global)
+  --install-claude-desktop-integration
+                       Full Claude Desktop setup: install @diagrammo/dgmo-mcp if needed,
+                       then merge the dgmo MCP entry into Claude Desktop's config file
+                       (~/Library/Application Support/Claude/claude_desktop_config.json on macOS,
+                       %APPDATA%/Claude/... on Windows, ~/.config/Claude/... on Linux)
   --help               Show this help
   --version            Show version`);
 }
@@ -508,10 +509,7 @@ function parseArgs(argv: string[]): {
   installClaudeSkill: boolean;
   installClaudeCodeIntegration: boolean;
   installCodexIntegration: boolean;
-  c4Level: 'context' | 'containers' | 'components' | 'deployment';
-  c4System: string | undefined;
-  c4Container: string | undefined;
-  tagGroup: string | undefined;
+  installClaudeDesktopIntegration: boolean;
 } {
   const result = {
     input: undefined as string | undefined,
@@ -528,14 +526,7 @@ function parseArgs(argv: string[]): {
     installClaudeSkill: false,
     installClaudeCodeIntegration: false,
     installCodexIntegration: false,
-    c4Level: 'context' as
-      | 'context'
-      | 'containers'
-      | 'components'
-      | 'deployment',
-    c4System: undefined as string | undefined,
-    c4Container: undefined as string | undefined,
-    tagGroup: undefined as string | undefined,
+    installClaudeDesktopIntegration: false,
   };
 
   const args = argv.slice(2); // skip node + script
@@ -579,30 +570,6 @@ function parseArgs(argv: string[]): {
       }
       result.palette = val;
       i++;
-    } else if (arg === '--c4-level') {
-      const val = args[++i];
-      if (
-        val !== 'context' &&
-        val !== 'containers' &&
-        val !== 'components' &&
-        val !== 'deployment'
-      ) {
-        console.error(
-          `Error: Invalid C4 level "${val}". Valid levels: context, containers, components, deployment`
-        );
-        process.exit(1);
-      }
-      result.c4Level = val;
-      i++;
-    } else if (arg === '--c4-system') {
-      result.c4System = args[++i];
-      i++;
-    } else if (arg === '--c4-container') {
-      result.c4Container = args[++i];
-      i++;
-    } else if (arg === '--tag-group') {
-      result.tagGroup = args[++i];
-      i++;
     } else if (arg === '--json') {
       result.json = true;
       i++;
@@ -618,6 +585,9 @@ function parseArgs(argv: string[]): {
     } else if (arg === '--install-codex-integration') {
       result.installCodexIntegration = true;
       i++;
+    } else if (arg === '--install-claude-desktop-integration') {
+      result.installClaudeDesktopIntegration = true;
+      i++;
     } else if (arg === '--copy') {
       result.copy = true;
       i++;
@@ -643,12 +613,19 @@ function inferFormat(outputPath: string | undefined): 'svg' | 'png' | 'url' {
   return 'png';
 }
 
+const BUNDLED_FONTS = [
+  join(__dirname, '..', 'fonts', 'Inter-Regular.ttf'),
+  join(__dirname, '..', 'fonts', 'Inter-Bold.ttf'),
+];
+
 function svgToPng(svg: string, background?: string): Buffer {
+  const fontFiles = BUNDLED_FONTS.filter((f) => existsSync(f));
   const resvg = new Resvg(svg, {
     fitTo: { mode: 'zoom', value: 2 },
     ...(background ? { background } : {}),
     font: {
-      loadSystemFonts: true,
+      loadSystemFonts: fontFiles.length === 0,
+      ...(fontFiles.length > 0 ? { fontFiles } : {}),
       defaultFontFamily: DEFAULT_FONT_NAME,
       sansSerifFamily: DEFAULT_FONT_NAME,
     },
@@ -715,7 +692,7 @@ async function main(): Promise<void> {
     } else {
       for (const id of types) {
         const desc = CHART_TYPE_DESCRIPTIONS[id];
-        console.log(desc ? `${id} — ${desc.split(' — ')[1]}` : id);
+        console.log(desc ? `${id} — ${desc}` : id);
       }
     }
     return;
@@ -1038,6 +1015,133 @@ async function main(): Promise<void> {
     return;
   }
 
+  if (opts.installClaudeDesktopIntegration) {
+    const ask = (prompt: string): Promise<string> =>
+      new Promise((resolve) => {
+        const rl = createInterface({
+          input: process.stdin,
+          output: process.stdout,
+        });
+        rl.question(prompt, (answer) => {
+          rl.close();
+          resolve(answer);
+        });
+      });
+
+    // Check / install dgmo-mcp binary
+    let dgmoMcpInstalled = false;
+    try {
+      execSync('which dgmo-mcp', { stdio: 'pipe' });
+      dgmoMcpInstalled = true;
+    } catch {
+      /* not found */
+    }
+    if (!dgmoMcpInstalled) {
+      const ans = await ask(
+        '\ndgmo-mcp not found. Install @diagrammo/dgmo-mcp globally now? [Y/n] '
+      );
+      const yes =
+        ans === '' || ans.toLowerCase() === 'y' || ans.toLowerCase() === 'yes';
+      if (yes) {
+        console.log('Installing @diagrammo/dgmo-mcp...');
+        try {
+          execSync('npm install -g @diagrammo/dgmo-mcp', { stdio: 'inherit' });
+          console.log('✓ @diagrammo/dgmo-mcp installed');
+        } catch {
+          console.error('Error: Failed to install @diagrammo/dgmo-mcp.');
+          console.error('Try manually: npm install -g @diagrammo/dgmo-mcp');
+        }
+      } else {
+        console.log(
+          '  Skipped. Install later with: npm install -g @diagrammo/dgmo-mcp'
+        );
+      }
+    } else {
+      console.log('✓ dgmo-mcp already installed');
+    }
+
+    // Resolve the Claude Desktop config path for the current platform.
+    // macOS and Windows use the documented Claude Desktop paths; Linux
+    // doesn't have a first-party build yet, but community installs follow
+    // the XDG config convention.
+    const os = platform();
+    let configPath: string;
+    if (os === 'darwin') {
+      configPath = join(
+        homedir(),
+        'Library',
+        'Application Support',
+        'Claude',
+        'claude_desktop_config.json'
+      );
+    } else if (os === 'win32') {
+      const appData =
+        process.env.APPDATA ?? join(homedir(), 'AppData', 'Roaming');
+      configPath = join(appData, 'Claude', 'claude_desktop_config.json');
+    } else {
+      configPath = join(
+        homedir(),
+        '.config',
+        'Claude',
+        'claude_desktop_config.json'
+      );
+    }
+
+    // Read existing config (or start fresh). Non-JSON contents are treated
+    // as corruption and we bail — the user needs to resolve it manually so
+    // we don't silently overwrite something they care about.
+    type ClaudeDesktopConfig = {
+      mcpServers?: Record<
+        string,
+        { command: string; args?: string[]; env?: Record<string, string> }
+      >;
+      [key: string]: unknown;
+    };
+    let config: ClaudeDesktopConfig = {};
+    if (existsSync(configPath)) {
+      const raw = readFileSync(configPath, 'utf-8');
+      if (raw.trim().length > 0) {
+        try {
+          config = JSON.parse(raw) as ClaudeDesktopConfig;
+        } catch {
+          console.error(
+            `Error: ${configPath} exists but is not valid JSON. Fix it manually and re-run, or remove the file to regenerate.`
+          );
+          process.exit(1);
+        }
+      }
+    }
+
+    const existingDgmo = config.mcpServers?.dgmo;
+    if (existingDgmo && existingDgmo.command === 'dgmo-mcp') {
+      console.log(`✓ dgmo MCP server already configured in ${configPath}`);
+    } else {
+      if (existingDgmo) {
+        const ans = await ask(
+          `\nA "dgmo" entry already exists in ${configPath}. Overwrite? [y/N] `
+        );
+        if (ans.toLowerCase() !== 'y' && ans.toLowerCase() !== 'yes') {
+          console.log('  Skipped.');
+          return;
+        }
+      }
+      config.mcpServers = {
+        ...(config.mcpServers ?? {}),
+        dgmo: { command: 'dgmo-mcp' },
+      };
+      mkdirSync(join(configPath, '..'), { recursive: true });
+      writeFileSync(
+        configPath,
+        JSON.stringify(config, null, 2) + '\n',
+        'utf-8'
+      );
+      console.log(`✓ dgmo MCP server configured: ${configPath}`);
+    }
+
+    console.log('\nRestart Claude Desktop to activate the MCP server.');
+    return;
+  }
+
   // Determine input source
   let content: string;
   let inputBasename: string | undefined;
@@ -1195,32 +1299,9 @@ async function main(): Promise<void> {
     }
   }
 
-  // Validate C4 options
-  if (opts.c4Level === 'containers' && !opts.c4System) {
-    exitWithJsonError(
-      'Error: --c4-system is required when --c4-level is containers'
-    );
-  }
-  if (opts.c4Level === 'components') {
-    if (!opts.c4System) {
-      exitWithJsonError(
-        'Error: --c4-system is required when --c4-level is components'
-      );
-    }
-    if (!opts.c4Container) {
-      exitWithJsonError(
-        'Error: --c4-container is required when --c4-level is components'
-      );
-    }
-  }
-
   const { svg } = await render(content, {
     theme: opts.theme,
     palette: opts.palette,
-    c4Level: opts.c4Level,
-    c4System: opts.c4System,
-    c4Container: opts.c4Container,
-    tagGroup: opts.tagGroup,
   });
 
   if (!svg) {

package/src/completion.ts

@@ -238,10 +238,6 @@ export const COMPLETION_REGISTRY = new Map<string, DirectiveSpec>([
         description: 'Show activation bars',
         values: ['on', 'off'],
       },
-      'collapse-notes': {
-        description: 'Collapse note blocks',
-        values: ['yes', 'no'],
-      },
       'active-tag': { description: 'Active tag group name' },
     }),
   ],

package/src/d3.ts

@@ -1506,8 +1506,15 @@ export function parseVisualization(
           result.diagnostics.push(makeDgmoError(line, msg, 'warning')),
         suggest
       );
-      validateTagGroupNames(result.timelineTagGroups, (line, msg) =>
-        result.diagnostics.push(makeDgmoError(line, msg, 'warning'))
+      validateTagGroupNames(
+        result.timelineTagGroups,
+        (line, msg) =>
+          result.diagnostics.push(makeDgmoError(line, msg, 'warning')),
+        (line, msg) => {
+          const diag = makeDgmoError(line, msg);
+          result.diagnostics.push(diag);
+          if (!result.error) result.error = formatDgmoError(diag);
+        }
       );
       for (const group of result.timelineTagGroups) {
         if (!group.defaultValue) continue;
@@ -2674,8 +2681,10 @@ function renderEras(
   eras.forEach((era, i) => {
     const startVal = parseTimelineDate(era.startDate);
     const endVal = parseTimelineDate(era.endDate);
+    if (!Number.isFinite(startVal) || !Number.isFinite(endVal)) return;
     const start = scale(startVal);
     const end = scale(endVal);
+    if (!Number.isFinite(start) || !Number.isFinite(end)) return;
     const color = era.color || eraColors[i % eraColors.length];
 
     const eraG = g
@@ -2765,7 +2774,9 @@ function renderMarkers(
 
   markers.forEach((marker) => {
     const dateVal = parseTimelineDate(marker.date);
+    if (!Number.isFinite(dateVal)) return;
     const pos = scale(dateVal);
+    if (!Number.isFinite(pos)) return;
     const color = marker.color || defaultColor;
     const lineOpacity = 0.5;
     const diamondSize = 5;
@@ -3473,6 +3484,33 @@ export function renderTimeline(
       latestEndDateStr = ev.endDate ?? ev.date;
     }
   }
+
+  // Eras and markers anchor the time axis — fold their dates into the
+  // domain so out-of-range items still render within the chart.
+  for (const era of timelineEras) {
+    const eraStartNum = parseTimelineDate(era.startDate);
+    const eraEndNum = parseTimelineDate(era.endDate);
+    if (Number.isFinite(eraStartNum) && eraStartNum < minDate) {
+      minDate = eraStartNum;
+      earliestStartDateStr = era.startDate;
+    }
+    if (Number.isFinite(eraEndNum) && eraEndNum > maxDate) {
+      maxDate = eraEndNum;
+      latestEndDateStr = era.endDate;
+    }
+  }
+  for (const marker of timelineMarkers) {
+    const markerNum = parseTimelineDate(marker.date);
+    if (!Number.isFinite(markerNum)) continue;
+    if (markerNum < minDate) {
+      minDate = markerNum;
+      earliestStartDateStr = marker.date;
+    }
+    if (markerNum > maxDate) {
+      maxDate = markerNum;
+      latestEndDateStr = marker.date;
+    }
+  }
   const datePadding = (maxDate - minDate) * 0.05 || 0.5;
 
   const FADE_OPACITY = 0.1;

package/src/dgmo-router.ts

@@ -26,6 +26,7 @@ import { parsePyramid } from './pyramid/parser';
 import { parseFirstLine } from './utils/parsing';
 import { makeDgmoError, suggest } from './diagnostics';
 import type { DgmoError } from './diagnostics';
+import { chartTypes } from './chart-types';
 
 // ============================================================
 // Content-based chart type inference helpers
@@ -192,129 +193,98 @@ export function isExtendedChartType(chartType: string): boolean {
   return EXTENDED_CHART_TYPES.has(chartType.toLowerCase());
 }
 
-/** Standard chart types parsed by parseChart (then rendered via ECharts). Internal use. */
-const STANDARD_CHART_TYPES = new Set([
-  'bar',
-  'line',
-  'multi-line',
-  'area',
-  'pie',
-  'doughnut',
-  'radar',
-  'polar-area',
-  'bar-stacked',
-]);
-
 /**
- * Returns all supported chart type identifiers.
- * Useful for CLI enumeration and autocomplete.
+ * Returns all supported chart type identifiers in canonical (tier) order,
+ * derived from `chartTypes`. Consumers that need alphabetical order should
+ * call `.sort()` explicitly.
  */
 export function getAllChartTypes(): string[] {
-  return [...DATA_CHART_TYPES, ...VISUALIZATION_TYPES, ...DIAGRAM_TYPES];
+  return chartTypes.map((c) => c.id);
 }
 
 /**
- * Canonical descriptions for every supported chart type. Shared by the CLI
- * `--chart-types` flag, the editor autocomplete popup, and the MCP
- * `list_chart_types` tool so all three surfaces stay in sync.
+ * Canonical descriptions for every supported chart type. Derived from
+ * `chartTypes` so there is exactly one place to update when adding a new
+ * type. Consumed by the CLI `--chart-types` flag, the editor autocomplete
+ * popup, and the MCP `list_chart_types` tool.
  */
-export const CHART_TYPE_DESCRIPTIONS: Record<string, string> = {
-  bar: 'Bar chart — categorical comparisons',
-  line: 'Line chart — trends over time; supports era bands (era start -> end Label (color)) for annotating named periods',
-  'multi-line':
-    'Multi-line chart — multiple series trends over time; supports era bands',
-  area: 'Area chart — filled line chart; supports era bands',
-  pie: 'Pie chart — part-to-whole proportions',
-  doughnut: 'Doughnut chart — ring-style pie chart',
-  radar: 'Radar chart — multi-dimensional metrics',
-  'polar-area': 'Polar area chart — radial bar chart',
-  'bar-stacked': 'Stacked bar chart — multi-series categorical',
-  scatter: 'Scatter plot — 2D data points or bubble chart',
-  sankey: 'Sankey diagram — flow/allocation visualization',
-  chord: 'Chord diagram — circular flow relationships',
-  function: 'Function plot — mathematical expressions',
-  heatmap: 'Heatmap — matrix intensity visualization',
-  funnel: 'Funnel chart — conversion pipeline',
-  slope: 'Slope chart — change between two periods',
-  wordcloud: 'Word cloud — term frequency visualization',
-  arc: 'Arc diagram — network relationships',
-  timeline: 'Timeline — events, eras, and date ranges',
-  venn: 'Venn diagram — set overlaps',
-  quadrant: 'Quadrant chart — 2x2 positioning matrix',
-  'tech-radar':
-    'Tech radar — technology adoption quadrants (adopt/trial/assess/hold)',
-  cycle:
-    'Cycle diagram — cyclical process visualization (PDCA, OODA, DevOps loops)',
-  sequence: 'Sequence diagram — message/interaction flows',
-  flowchart: 'Flowchart — decision trees and process flows',
-  class: 'Class diagram — UML class hierarchies',
-  er: 'ER diagram — database schemas and relationships',
-  org: 'Org chart — hierarchical tree structures',
-  kanban: 'Kanban board — task/workflow columns',
-  c4: 'C4 diagram — system architecture (context, container, component, deployment)',
-  state: 'State diagram — state machine / lifecycle transitions',
-  sitemap:
-    'Sitemap — navigable UI structure with pages, groups, and cross-link arrows',
-  infra:
-    'Infrastructure diagram — traffic flow with RPS computation, capacity modeling, and latency analysis',
-  gantt:
-    'Gantt chart — project scheduling with task dependencies and milestones',
-  'boxes-and-lines':
-    'Boxes and lines — general-purpose node-edge diagrams with nested groups, tags, and shape inference',
-  mindmap: 'Mindmap — radial hierarchy of ideas branching from a central topic',
-  wireframe:
-    'Wireframe — low-fidelity UI layout with panels, controls, and annotations',
-  'journey-map':
-    'Journey map — user experience flow with emotion scores, phases, and annotations',
-  pyramid:
-    'Pyramid — hierarchical layered pyramid (Maslow, DIKW, learning pyramid); inverted for funnel-of-learning style',
-};
-
-// ECharts-native types parsed by parseExtendedChart
-const ECHART_TYPES = new Set([
-  'scatter',
-  'sankey',
-  'chord',
-  'function',
-  'heatmap',
-  'funnel',
-]);
+export const CHART_TYPE_DESCRIPTIONS: Record<string, string> =
+  Object.fromEntries(chartTypes.map((c) => [c.id, c.description]));
 
-/** Map chart type strings to their parse function (content → { diagnostics }). */
-const PARSE_DISPATCH = new Map<
-  string,
-  (content: string) => { diagnostics: DgmoError[] }
->([
-  ['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)],
-]);
+// ============================================================
+// Parser registry — single source of truth for id → parser
+// ============================================================
+
+type ParseResult = { diagnostics: DgmoError[] };
+type ParseFn = (content: string) => ParseResult;
 
 /**
- * Parse DGMO content and return diagnostics without rendering.
- * Useful for the CLI and editor to surface all errors before attempting render.
+ * Maps every chart-type id to the parser that handles it. Adding a new
+ * chart type means:
+ *   1. Add an entry here.
+ *   2. Add an entry to `chartTypes` in `chart-types.ts`.
+ *
+ * The `chart-types.test.ts` cross-check asserts both sets are identical;
+ * forgetting either side trips the test.
  */
+export const chartTypeParsers: ReadonlyArray<readonly [string, ParseFn]> = [
+  // 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],
+];
+
+/** Ids in the same order as `chartTypeParsers`; used for cross-checks. */
+export const knownChartTypeIds: readonly string[] = chartTypeParsers.map(
+  ([id]) => id
+);
+
+const PARSER_BY_ID: Map<string, ParseFn> = new Map(chartTypeParsers);
+
 /** All known chart type names for colon-pattern detection. */
-const ALL_KNOWN_TYPES = new Set([
-  ...DATA_CHART_TYPES,
-  ...VISUALIZATION_TYPES,
-  ...DIAGRAM_TYPES,
-]);
+const ALL_KNOWN_TYPES: ReadonlySet<string> = new Set(knownChartTypeIds);
 
 /**
  * Parse DGMO content and return diagnostics without rendering.
@@ -341,31 +311,16 @@ export function parseDgmo(content: string): {
     };
   }
 
-  const directParser = PARSE_DISPATCH.get(chartType);
-  if (directParser) {
-    const result = directParser(content);
-    return {
-      diagnostics: [...result.diagnostics, ...detectEmptyContent(content)],
-      chartType,
-    };
-  }
-
-  if (STANDARD_CHART_TYPES.has(chartType)) {
-    const result = parseChart(content);
-    return {
-      diagnostics: [...result.diagnostics, ...detectEmptyContent(content)],
-      chartType,
-    };
-  }
-  if (ECHART_TYPES.has(chartType)) {
-    const result = parseExtendedChart(content);
+  const parser = PARSER_BY_ID.get(chartType);
+  if (parser) {
+    const result = parser(content);
     return {
       diagnostics: [...result.diagnostics, ...detectEmptyContent(content)],
       chartType,
     };
   }
 
-  // Visualization types (slope, wordcloud, arc, timeline, venn, quadrant)
+  // Unknown id (defensive): fall through to visualization parser.
   const result = parseVisualization(content);
   return {
     diagnostics: [...result.diagnostics, ...detectEmptyContent(content)],

package/src/editor/keywords.ts

@@ -140,8 +140,6 @@ export const DIRECTIVE_KEYWORDS = new Set([
   // Sequence
   'activations',
   'no-activations',
-  'collapse-notes',
-  'no-collapse-notes',
   // Data charts
   'stacked',
   'no-label-name',

package/src/fonts.ts

@@ -1,2 +1,3 @@
-export const FONT_FAMILY = 'Inter, system-ui, Avenir, Helvetica, Arial, sans-serif';
-export const DEFAULT_FONT_NAME = 'Helvetica';
+export const FONT_FAMILY =
+  'Inter, system-ui, Avenir, Helvetica, Arial, sans-serif';
+export const DEFAULT_FONT_NAME = 'Inter';

package/src/gantt/parser.ts

@@ -926,7 +926,11 @@ export function parseGantt(
     result.options.sort = 'default';
   }
 
-  validateTagGroupNames(result.tagGroups, warn);
+  validateTagGroupNames(result.tagGroups, warn, (line, msg) => {
+    const diag = makeDgmoError(line, msg);
+    diagnostics.push(diag);
+    if (!result.error) result.error = formatDgmoError(diag);
+  });
 
   // ── Sprint mode detection ──────────────────────────────
   const hasSprintOption =