@diagrammo/dgmo 0.8.2 → 0.8.4

package/src/gantt/parser.ts

@@ -2,14 +2,19 @@
 // Gantt Chart Parser
 // ============================================================
 
-import { makeDgmoError, formatDgmoError, suggest } from '../diagnostics';
+import { makeDgmoError, formatDgmoError } from '../diagnostics';
 import type { DgmoError } from '../diagnostics';
-import type { TagGroup, TagEntry } from '../utils/tag-groups';
+import type { TagGroup } from '../utils/tag-groups';
 import { matchTagBlockHeading } from '../utils/tag-groups';
-import { measureIndent, extractColor, parsePipeMetadata, MULTIPLE_PIPE_WARNING, parseFirstLine, prescanOptions, GROUP_HASH_RE } from '../utils/parsing';
+import {
+  measureIndent,
+  extractColor,
+  parsePipeMetadata,
+  MULTIPLE_PIPE_ERROR,
+  parseFirstLine,
+} from '../utils/parsing';
 import { parseOffset } from '../utils/duration';
 import type { PaletteColors } from '../palettes';
-import { resolveColor } from '../colors';
 import { getSeriesColors } from '../palettes';
 import type {
   ParsedGantt,
@@ -17,11 +22,6 @@ import type {
   GanttTask,
   GanttGroup,
   GanttParallelBlock,
-  GanttDependency,
-  GanttHolidays,
-  GanttEra,
-  GanttMarker,
-  GanttOptions,
   Duration,
   DurationUnit,
   Offset,
@@ -37,7 +37,8 @@ const DURATION_RE = /^(\d+(?:\.\d+)?)(min|bd|d|w|m|q|y|h)(\?)?\s+(.+)$/;
 const EXPLICIT_DATE_RE = /^(\d{4}-\d{2}-\d{2}(?: \d{2}:\d{2})?)\s+(.+)$/;
 
 /** Timeline migration syntax: `2024-01-15 -> 30d Label` or `2024-01-15 14:30 -> 2h Label` */
-const TIMELINE_DURATION_RE = /^(\d{4}-\d{2}-\d{2}(?: \d{2}:\d{2})?)\s*->\s*(\d+(?:\.\d+)?)(min|bd|d|w|m|q|y|h)(\?)?\s+(.+)$/;
+const TIMELINE_DURATION_RE =
+  /^(\d{4}-\d{2}-\d{2}(?: \d{2}:\d{2})?)\s*(?:->|\u2013>)\s*(\d+(?:\.\d+)?)(min|bd|d|w|m|q|y|h)(\?)?\s+(.+)$/;
 
 /** Group container: `[GroupName]` with optional pipe metadata */
 const GROUP_RE = /^\[(.+?)\]\s*(.*)$/;
@@ -49,24 +50,47 @@ const DEPENDENCY_RE = /^(?:-(.+?))?->\s*(.+)$/;
 const COMMENT_RE = /^\/\//;
 
 /** Era: `era YYYY[-MM[-DD[ HH:MM]]] -> YYYY[-MM[-DD[ HH:MM]]] Label (color?)` */
-const ERA_RE = /^era\s+(\d{4}(?:-\d{2}(?:-\d{2}(?: \d{2}:\d{2})?)?)?)\s*->\s*(\d{4}(?:-\d{2}(?:-\d{2}(?: \d{2}:\d{2})?)?)?)\s+(.+)$/i;
+const ERA_RE =
+  /^era\s+(\d{4}(?:-\d{2}(?:-\d{2}(?: \d{2}:\d{2})?)?)?)\s*(?:->|\u2013>)\s*(\d{4}(?:-\d{2}(?:-\d{2}(?: \d{2}:\d{2})?)?)?)\s+(.+)$/i;
 
 /** Marker: `marker YYYY[-MM[-DD[ HH:MM]]] Label (color?)` */
-const MARKER_RE = /^marker\s+(\d{4}(?:-\d{2}(?:-\d{2}(?: \d{2}:\d{2})?)?)?)\s+(.+)$/i;
+const MARKER_RE =
+  /^marker\s+(\d{4}(?:-\d{2}(?:-\d{2}(?: \d{2}:\d{2})?)?)?)\s+(.+)$/i;
 
 /** Holiday date: `2024-01-15 Label` */
 const HOLIDAY_DATE_RE = /^(\d{4}-\d{2}-\d{2})\s+(.+)$/;
 
 /** Holiday range: `2024-12-24 -> 2024-12-31 Label` */
-const HOLIDAY_RANGE_RE = /^(\d{4}-\d{2}-\d{2})\s*->\s*(\d{4}-\d{2}-\d{2})\s+(.+)$/;
+const HOLIDAY_RANGE_RE =
+  /^(\d{4}-\d{2}-\d{2})\s*(?:->|\u2013>)\s*(\d{4}-\d{2}-\d{2})\s+(.+)$/;
 
 /** Workweek override: `workweek sun-thu` */
 const WORKWEEK_RE = /^workweek\s+(.+)$/i;
 
+/** Era entry (inside era block, no `era` prefix): `YYYY[-MM[-DD[ HH:MM]]] -> YYYY[-MM[-DD[ HH:MM]]] Label` */
+const ERA_ENTRY_RE =
+  /^(\d{4}(?:-\d{2}(?:-\d{2}(?: \d{2}:\d{2})?)?)?)\s*(?:->|\u2013>)\s*(\d{4}(?:-\d{2}(?:-\d{2}(?: \d{2}:\d{2})?)?)?)\s+(.+)$/;
+
+/** Marker entry (inside marker block, no `marker` prefix): `YYYY[-MM[-DD[ HH:MM]]] Label` */
+const MARKER_ENTRY_RE =
+  /^(\d{4}(?:-\d{2}(?:-\d{2}(?: \d{2}:\d{2})?)?)?)\s+(.+)$/;
+
 // Valid weekday names
 const WEEKDAY_MAP: Record<string, Weekday> = {
-  mon: 'mon', tue: 'tue', wed: 'wed', thu: 'thu', fri: 'fri', sat: 'sat', sun: 'sun',
-  monday: 'mon', tuesday: 'tue', wednesday: 'wed', thursday: 'thu', friday: 'fri', saturday: 'sat', sunday: 'sun',
+  mon: 'mon',
+  tue: 'tue',
+  wed: 'wed',
+  thu: 'thu',
+  fri: 'fri',
+  sat: 'sat',
+  sun: 'sun',
+  monday: 'mon',
+  tuesday: 'tue',
+  wednesday: 'wed',
+  thursday: 'thu',
+  friday: 'fri',
+  saturday: 'sat',
+  sunday: 'sun',
 };
 
 // ── Block Stack ─────────────────────────────────────────────
@@ -81,13 +105,20 @@ interface BlockEntry {
 
 // ── Parser ──────────────────────────────────────────────────
 
-export function parseGantt(content: string, palette?: PaletteColors): ParsedGantt {
+export function parseGantt(
+  content: string,
+  palette?: PaletteColors
+): ParsedGantt {
   const lines = content.split('\n');
   const diagnostics: DgmoError[] = [];
 
   const result: ParsedGantt = {
     nodes: [],
-    holidays: { dates: [], ranges: [], workweek: ['mon', 'tue', 'wed', 'thu', 'fri'] },
+    holidays: {
+      dates: [],
+      ranges: [],
+      workweek: ['mon', 'tue', 'wed', 'thu', 'fri'],
+    },
     tagGroups: [],
     eras: [],
     markers: [],
@@ -150,12 +181,15 @@ export function parseGantt(content: string, palette?: PaletteColors): ParsedGant
   // ── State ───────────────────────────────────────────────
 
   let seenChartType = false;
-  let inHeaderBlock = true; // options must come before content
   let inHolidaysBlock = false;
   let holidaysBlockIndent = 0;
   let inTagBlock = false;
   let currentTagGroup: TagGroup | null = null;
   let tagBlockIndent = 0;
+  let inEraBlock = false;
+  let eraBlockIndent = 0;
+  let inMarkerBlock = false;
+  let markerBlockIndent = 0;
   let lastTaskNode: (GanttNode & { kind: 'task' }) | null = null;
   let taskIdCounter = 0;
   const seriesColors = palette ? getSeriesColors(palette) : [];
@@ -170,10 +204,16 @@ export function parseGantt(content: string, palette?: PaletteColors): ParsedGant
 
     // Skip empty lines
     if (!line) {
-      // Empty line ends holidays/tag blocks only if at root indent
+      // Empty line ends holidays/tag/era/marker blocks only if at root indent
       if (inHolidaysBlock && indent <= holidaysBlockIndent) {
         inHolidaysBlock = false;
       }
+      if (inEraBlock && indent <= eraBlockIndent) {
+        inEraBlock = false;
+      }
+      if (inMarkerBlock && indent <= markerBlockIndent) {
+        inMarkerBlock = false;
+      }
       if (inTagBlock && indent <= tagBlockIndent) {
         inTagBlock = false;
         if (currentTagGroup) {
@@ -190,7 +230,10 @@ export function parseGantt(content: string, palette?: PaletteColors): ParsedGant
       const firstLineResult = parseFirstLine(line);
       if (firstLineResult) {
         if (firstLineResult.chartType !== 'gantt') {
-          return fail(lineNumber, `Expected chart type "gantt", got "${firstLineResult.chartType}"`);
+          return fail(
+            lineNumber,
+            `Expected chart type "gantt", got "${firstLineResult.chartType}"`
+          );
         }
         seenChartType = true;
         if (firstLineResult.title) {
@@ -236,7 +279,10 @@ export function parseGantt(content: string, palette?: PaletteColors): ParsedGant
           if (days) {
             result.holidays.workweek = days;
           } else {
-            warn(lineNumber, `Invalid workweek format: "${workweekMatch[1]}". Use day range like "sun-thu" or comma-separated days.`);
+            warn(
+              lineNumber,
+              `Invalid workweek format: "${workweekMatch[1]}". Use day range like "sun-thu" or comma-separated days.`
+            );
           }
           continue;
         }
@@ -249,6 +295,57 @@ export function parseGantt(content: string, palette?: PaletteColors): ParsedGant
       }
     }
 
+    // ── Era block entries ─────────────────────────────────
+
+    if (inEraBlock) {
+      if (indent <= eraBlockIndent) {
+        inEraBlock = false;
+        // fall through to process this line normally
+      } else {
+        if (COMMENT_RE.test(line)) continue;
+        const eraEntryMatch = line.match(ERA_ENTRY_RE);
+        if (eraEntryMatch) {
+          const eraLabelRaw = eraEntryMatch[3].trim();
+          const eraExtracted = extractColor(eraLabelRaw, palette);
+          result.eras.push({
+            startDate: eraEntryMatch[1],
+            endDate: eraEntryMatch[2],
+            label: eraExtracted.label,
+            color: eraExtracted.color || null,
+            lineNumber,
+          });
+        } else {
+          warn(lineNumber, `Unrecognized era entry: "${line}"`);
+        }
+        continue;
+      }
+    }
+
+    // ── Marker block entries ─────────────────────────────
+
+    if (inMarkerBlock) {
+      if (indent <= markerBlockIndent) {
+        inMarkerBlock = false;
+        // fall through to process this line normally
+      } else {
+        if (COMMENT_RE.test(line)) continue;
+        const markerEntryMatch = line.match(MARKER_ENTRY_RE);
+        if (markerEntryMatch) {
+          const markerLabelRaw = markerEntryMatch[2].trim();
+          const markerExtracted = extractColor(markerLabelRaw, palette);
+          result.markers.push({
+            date: markerEntryMatch[1],
+            label: markerExtracted.label,
+            color: markerExtracted.color || null,
+            lineNumber,
+          });
+        } else {
+          warn(lineNumber, `Unrecognized marker entry: "${line}"`);
+        }
+        continue;
+      }
+    }
+
     // ── Tag block entries ─────────────────────────────────
 
     if (inTagBlock && currentTagGroup) {
@@ -263,7 +360,10 @@ export function parseGantt(content: string, palette?: PaletteColors): ParsedGant
         // First entry is the default (no `default` keyword needed)
         if (COMMENT_RE.test(line)) continue;
         const extracted = extractColor(line, palette);
-        const color = extracted.color || seriesColors[currentTagGroup.entries.length % seriesColors.length] || '#888888';
+        const color =
+          extracted.color ||
+          seriesColors[currentTagGroup.entries.length % seriesColors.length] ||
+          '#888888';
         const isFirstEntry = currentTagGroup.entries.length === 0;
         currentTagGroup.entries.push({
           value: extracted.label,
@@ -302,19 +402,32 @@ export function parseGantt(content: string, palette?: PaletteColors): ParsedGant
         let offset: Offset | undefined;
 
         if (depParts.length > 1) {
-          const meta = parsePipeMetadata(['', ...depParts.slice(1)], aliasMap, () => warn(lineNumber, MULTIPLE_PIPE_WARNING));
+          const meta = parsePipeMetadata(
+            ['', ...depParts.slice(1)],
+            aliasMap,
+            () => warn(lineNumber, MULTIPLE_PIPE_ERROR)
+          );
           if (meta.lag || meta.lead) {
             const key = meta.lag ? 'lag' : 'lead';
-            softError(lineNumber, `"${key}" is no longer supported — use "offset: ${meta[key]}" instead.${key === 'lead' ? ' Negate the value for lead behavior: "offset: -...".' : ''}`);
+            softError(
+              lineNumber,
+              `"${key}" is no longer supported — use "offset: ${meta[key]}" instead.${key === 'lead' ? ' Negate the value for lead behavior: "offset: -...".' : ''}`
+            );
           }
           if (meta.offset) {
             const raw = meta.offset;
             if (raw.trim().startsWith('+')) {
-              warn(lineNumber, `Invalid offset: "${raw}". Explicit "+" is not supported — use "${raw.trim().slice(1)}" instead.`);
+              warn(
+                lineNumber,
+                `Invalid offset: "${raw}". Explicit "+" is not supported — use "${raw.trim().slice(1)}" instead.`
+              );
             } else {
               offset = parseOffset(raw) ?? undefined;
               if (!offset) {
-                warn(lineNumber, `Invalid offset: "${raw}". Expected format like "3bd", "-5d", or "0bd".`);
+                warn(
+                  lineNumber,
+                  `Invalid offset: "${raw}". Expected format like "3bd", "-5d", or "0bd".`
+                );
               }
             }
           }
@@ -348,13 +461,14 @@ export function parseGantt(content: string, palette?: PaletteColors): ParsedGant
     if (line.toLowerCase() === 'holiday' || line.toLowerCase() === 'holidays') {
       inHolidaysBlock = true;
       holidaysBlockIndent = indent;
-      inHeaderBlock = false;
       result.options.holidaysLineNumber = lineNumber;
       continue;
     }
 
     // Single-line holiday: `holiday 2024-12-25 Christmas`
-    const holidayInlineMatch = line.match(/^holiday\s+(\d{4}-\d{2}-\d{2})\s+(.+)$/i);
+    const holidayInlineMatch = line.match(
+      /^holiday\s+(\d{4}-\d{2}-\d{2})\s+(.+)$/i
+    );
     if (holidayInlineMatch) {
       result.holidays.dates.push({
         date: holidayInlineMatch[1],
@@ -362,20 +476,14 @@ export function parseGantt(content: string, palette?: PaletteColors): ParsedGant
         lineNumber,
       });
       result.options.holidaysLineNumber ??= lineNumber;
-      inHeaderBlock = false;
       continue;
     }
 
     // Tag block heading
     const tagMatch = matchTagBlockHeading(line);
     if (tagMatch) {
-      if (tagMatch.deprecated) {
-        softError(lineNumber, `'## ${tagMatch.name}' is no longer supported — use 'tag ${tagMatch.name}' instead`);
-        continue;
-      }
       inTagBlock = true;
       tagBlockIndent = indent;
-      inHeaderBlock = false;
       currentTagGroup = {
         name: tagMatch.name,
         alias: tagMatch.alias,
@@ -388,7 +496,29 @@ export function parseGantt(content: string, palette?: PaletteColors): ParsedGant
       continue;
     }
 
-    // Era
+    // Top-level workweek (outside holiday block)
+    const topWorkweekMatch = line.match(WORKWEEK_RE);
+    if (topWorkweekMatch) {
+      const days = parseWorkweek(topWorkweekMatch[1].trim());
+      if (days) {
+        result.holidays.workweek = days;
+      } else {
+        warn(
+          lineNumber,
+          `Invalid workweek format: "${topWorkweekMatch[1]}". Use day range like "sun-thu" or comma-separated days.`
+        );
+      }
+      continue;
+    }
+
+    // Era block: bare `era` keyword starts a block
+    if (line.toLowerCase() === 'era') {
+      inEraBlock = true;
+      eraBlockIndent = indent;
+      continue;
+    }
+
+    // Era (inline)
     const eraMatch = line.match(ERA_RE);
     if (eraMatch) {
       const eraLabelRaw = eraMatch[3].trim();
@@ -400,11 +530,17 @@ export function parseGantt(content: string, palette?: PaletteColors): ParsedGant
         color: eraExtracted.color || null,
         lineNumber,
       });
-      inHeaderBlock = false;
       continue;
     }
 
-    // Marker
+    // Marker block: bare `marker` keyword starts a block
+    if (line.toLowerCase() === 'marker') {
+      inMarkerBlock = true;
+      markerBlockIndent = indent;
+      continue;
+    }
+
+    // Marker (inline)
     const markerMatch = line.match(MARKER_RE);
     if (markerMatch) {
       const markerLabelRaw = markerMatch[2].trim();
@@ -415,7 +551,6 @@ export function parseGantt(content: string, palette?: PaletteColors): ParsedGant
         color: markerExtracted.color || null,
         lineNumber,
       });
-      inHeaderBlock = false;
       continue;
     }
 
@@ -472,14 +607,14 @@ export function parseGantt(content: string, palette?: PaletteColors): ParsedGant
           result.options.title = value;
           result.options.titleLineNumber = lineNumber;
           break;
-        case 'orientation':
-          warn(lineNumber, `'orientation' is not supported for gantt charts`);
-          break;
         case 'today-marker':
           if (/^\d{4}-\d{2}-\d{2}(?: \d{2}:\d{2})?$/.test(value)) {
             result.options.todayMarker = value;
           } else {
-            warn(lineNumber, `Invalid today-marker value: "${value}". Expected YYYY-MM-DD.`);
+            warn(
+              lineNumber,
+              `Invalid today-marker value: "${value}". Expected YYYY-MM-DD.`
+            );
           }
           break;
         case 'critical-path':
@@ -494,41 +629,20 @@ export function parseGantt(content: string, palette?: PaletteColors): ParsedGant
             result.options.sort = 'tag';
             const colonIdx = value.indexOf(':');
             if (colonIdx !== -1) {
-              result.options.defaultSwimlaneGroup = value.slice(colonIdx + 1).trim() || null;
+              result.options.defaultSwimlaneGroup =
+                value.slice(colonIdx + 1).trim() || null;
             }
           } else {
-            warn(lineNumber, `Invalid sort value: "${value}". Expected "tag" or "tag:GroupName".`);
+            warn(
+              lineNumber,
+              `Invalid sort value: "${value}". Expected "tag" or "tag:GroupName".`
+            );
           }
           break;
       }
       continue;
     }
 
-    inHeaderBlock = false;
-
-    // ── `# Group` alternate syntax ──────────────────────────
-
-    const hashGroupMatch = line.match(GROUP_HASH_RE);
-    if (hashGroupMatch) {
-      const nameExtracted = extractColor(hashGroupMatch[1], palette);
-      const group: GanttGroup = {
-        name: nameExtracted.label,
-        color: nameExtracted.color || null,
-        metadata: {},
-        lineNumber,
-        children: [],
-      };
-      const groupNode: GanttNode = { kind: 'group', ...group };
-      currentContainer().push(groupNode);
-      blockStack.push({
-        node: groupNode as GanttGroup,
-        indent,
-        containerType: 'group',
-      });
-      lastTaskNode = null;
-      continue;
-    }
-
     // ── Parallel block ────────────────────────────────────
 
     if (line === 'parallel') {
@@ -548,8 +662,14 @@ export function parseGantt(content: string, palette?: PaletteColors): ParsedGant
     const groupMatch = line.match(GROUP_RE);
     if (groupMatch) {
       // Validate nesting: group under a task is invalid
-      if (blockStack.length > 0 && blockStack[blockStack.length - 1].containerType === 'task') {
-        softError(lineNumber, `Cannot nest a group inside a task. Groups must be inside other groups or parallel blocks.`);
+      if (
+        blockStack.length > 0 &&
+        blockStack[blockStack.length - 1].containerType === 'task'
+      ) {
+        softError(
+          lineNumber,
+          `Cannot nest a group inside a task. Groups must be inside other groups or parallel blocks.`
+        );
         continue;
       }
 
@@ -560,12 +680,16 @@ export function parseGantt(content: string, palette?: PaletteColors): ParsedGant
       let metadata: Record<string, string> = {};
       let color: string | null = null;
 
-      const pipeWarn = () => warn(lineNumber, MULTIPLE_PIPE_WARNING);
+      const pipeWarn = () => warn(lineNumber, MULTIPLE_PIPE_ERROR);
       if (segments.length > 0 && segments[0].trim()) {
         // Check if first segment after brackets is pipe metadata
         metadata = parsePipeMetadata(['', ...segments], aliasMap, pipeWarn);
       } else if (segments.length > 1) {
-        metadata = parsePipeMetadata(['', ...segments.slice(1)], aliasMap, pipeWarn);
+        metadata = parsePipeMetadata(
+          ['', ...segments.slice(1)],
+          aliasMap,
+          pipeWarn
+        );
       }
 
       // Extract color from group name if present
@@ -602,11 +726,21 @@ export function parseGantt(content: string, palette?: PaletteColors): ParsedGant
       const uncertain = !!timelineDurMatch[4];
       const labelRaw = timelineDurMatch[5];
 
-      const task = makeTask(labelRaw, { amount, unit }, uncertain, lineNumber, startDate);
+      const task = makeTask(
+        labelRaw,
+        { amount, unit },
+        uncertain,
+        lineNumber,
+        startDate
+      );
       const taskNode: GanttNode = { kind: 'task', ...task };
       currentContainer().push(taskNode);
       lastTaskNode = taskNode as GanttNode & { kind: 'task' };
-      blockStack.push({ node: taskNode as unknown as GanttGroup, indent, containerType: 'task' });
+      blockStack.push({
+        node: taskNode as unknown as GanttGroup,
+        indent,
+        containerType: 'task',
+      });
       continue;
     }
 
@@ -623,7 +757,11 @@ export function parseGantt(content: string, palette?: PaletteColors): ParsedGant
       const taskNode: GanttNode = { kind: 'task', ...task };
       currentContainer().push(taskNode);
       lastTaskNode = taskNode as GanttNode & { kind: 'task' };
-      blockStack.push({ node: taskNode as unknown as GanttGroup, indent, containerType: 'task' });
+      blockStack.push({
+        node: taskNode as unknown as GanttGroup,
+        indent,
+        containerType: 'task',
+      });
       continue;
     }
 
@@ -636,13 +774,17 @@ export function parseGantt(content: string, palette?: PaletteColors): ParsedGant
         null, // no duration — it's a date anchor / milestone
         false,
         lineNumber,
-        explicitDateMatch[1],
+        explicitDateMatch[1]
       );
       // Explicit date tasks with no duration are milestones
       const taskNode: GanttNode = { kind: 'task', ...task };
       currentContainer().push(taskNode);
       lastTaskNode = taskNode as GanttNode & { kind: 'task' };
-      blockStack.push({ node: taskNode as unknown as GanttGroup, indent, containerType: 'task' });
+      blockStack.push({
+        node: taskNode as unknown as GanttGroup,
+        indent,
+        containerType: 'task',
+      });
       continue;
     }
 
@@ -652,7 +794,10 @@ export function parseGantt(content: string, palette?: PaletteColors): ParsedGant
     if (depMatch) {
       // Dependency without a task context is an error
       if (!lastTaskNode) {
-        softError(lineNumber, `Dependency "-> ${depMatch[2]}" must be indented under a task.`);
+        softError(
+          lineNumber,
+          `Dependency "-> ${depMatch[2]}" must be indented under a task.`
+        );
         continue;
       }
       // This happens when the dep is at the same indent as the task
@@ -662,19 +807,32 @@ export function parseGantt(content: string, palette?: PaletteColors): ParsedGant
       let offset: Offset | undefined;
 
       if (depParts.length > 1) {
-        const meta = parsePipeMetadata(['', ...depParts.slice(1)], aliasMap, () => warn(lineNumber, MULTIPLE_PIPE_WARNING));
+        const meta = parsePipeMetadata(
+          ['', ...depParts.slice(1)],
+          aliasMap,
+          () => warn(lineNumber, MULTIPLE_PIPE_ERROR)
+        );
         if (meta.lag || meta.lead) {
           const key = meta.lag ? 'lag' : 'lead';
-          softError(lineNumber, `"${key}" is no longer supported — use "offset: ${meta[key]}" instead.${key === 'lead' ? ' Negate the value for lead behavior: "offset: -...".' : ''}`);
+          softError(
+            lineNumber,
+            `"${key}" is no longer supported — use "offset: ${meta[key]}" instead.${key === 'lead' ? ' Negate the value for lead behavior: "offset: -...".' : ''}`
+          );
         }
         if (meta.offset) {
           const raw = meta.offset;
           if (raw.trim().startsWith('+')) {
-            warn(lineNumber, `Invalid offset: "${raw}". Explicit "+" is not supported — use "${raw.trim().slice(1)}" instead.`);
+            warn(
+              lineNumber,
+              `Invalid offset: "${raw}". Explicit "+" is not supported — use "${raw.trim().slice(1)}" instead.`
+            );
           } else {
             offset = parseOffset(raw) ?? undefined;
             if (!offset) {
-              warn(lineNumber, `Invalid offset: "${raw}". Expected format like "3bd", "-5d", or "0bd".`);
+              warn(
+                lineNumber,
+                `Invalid offset: "${raw}". Expected format like "3bd", "-5d", or "0bd".`
+              );
             }
           }
         }
@@ -686,7 +844,10 @@ export function parseGantt(content: string, palette?: PaletteColors): ParsedGant
 
     // ── Bare label = parse error ──────────────────────────
 
-    softError(lineNumber, `Expected duration (e.g., "10d Task"), group brackets (e.g., "[Group]"), or keyword. Got: "${line}"`);
+    softError(
+      lineNumber,
+      `Expected duration (e.g., "10d Task"), group brackets (e.g., "[Group]"), or keyword. Got: "${line}"`
+    );
     continue;
   }
 
@@ -714,20 +875,26 @@ export function parseGantt(content: string, palette?: PaletteColors): ParsedGant
     duration: Duration | null,
     uncertain: boolean,
     ln: number,
-    explicitStart?: string,
+    explicitStart?: string
   ): GanttTask {
     const segments = labelRaw.split('|');
     const label = segments[0].trim();
 
     // Check for reserved keyword
     if (label.toLowerCase() === 'parallel') {
-      softError(ln, `"parallel" is a reserved keyword and cannot be used as a task name.`);
+      softError(
+        ln,
+        `"parallel" is a reserved keyword and cannot be used as a task name.`
+      );
     }
 
     // Parse pipe metadata
-    const metadata = segments.length > 1
-      ? parsePipeMetadata(segments, aliasMap, () => warn(ln, MULTIPLE_PIPE_WARNING))
-      : {};
+    const metadata =
+      segments.length > 1
+        ? parsePipeMetadata(segments, aliasMap, () =>
+            warn(ln, MULTIPLE_PIPE_ERROR)
+          )
+        : {};
 
     // Extract progress from metadata or shorthand
     let progress: number | null = null;
@@ -747,7 +914,10 @@ export function parseGantt(content: string, palette?: PaletteColors): ParsedGant
     // Reject lag/lead — use offset instead
     if (metadata.lag || metadata.lead) {
       const key = metadata.lag ? 'lag' : 'lead';
-      softError(ln, `"${key}" is no longer supported — use "offset: ${metadata[key]}" instead.${key === 'lead' ? ' Negate the value for lead behavior: "offset: -...".' : ''}`);
+      softError(
+        ln,
+        `"${key}" is no longer supported — use "offset: ${metadata[key]}" instead.${key === 'lead' ? ' Negate the value for lead behavior: "offset: -...".' : ''}`
+      );
     }
 
     // Extract task-level offset from metadata
@@ -755,11 +925,17 @@ export function parseGantt(content: string, palette?: PaletteColors): ParsedGant
     if (metadata.offset) {
       const raw = metadata.offset;
       if (raw.trim().startsWith('+')) {
-        warn(ln, `Invalid offset: "${raw}". Explicit "+" is not supported — use "${raw.trim().slice(1)}" instead.`);
+        warn(
+          ln,
+          `Invalid offset: "${raw}". Explicit "+" is not supported — use "${raw.trim().slice(1)}" instead.`
+        );
       } else {
         taskOffset = parseOffset(raw) ?? undefined;
         if (!taskOffset) {
-          warn(ln, `Invalid offset: "${raw}". Expected format like "3bd", "-5d", or "0bd".`);
+          warn(
+            ln,
+            `Invalid offset: "${raw}". Expected format like "3bd", "-5d", or "0bd".`
+          );
         }
       }
       delete metadata.offset;
@@ -805,7 +981,15 @@ function parseWorkweek(s: string): Weekday[] | null {
     const start = WEEKDAY_MAP[rangeParts[0].trim()];
     const end = WEEKDAY_MAP[rangeParts[1].trim()];
     if (start && end) {
-      const allDays: Weekday[] = ['mon', 'tue', 'wed', 'thu', 'fri', 'sat', 'sun'];
+      const allDays: Weekday[] = [
+        'mon',
+        'tue',
+        'wed',
+        'thu',
+        'fri',
+        'sat',
+        'sun',
+      ];
       const startIdx = allDays.indexOf(start);
       const endIdx = allDays.indexOf(end);
       const days: Weekday[] = [];
@@ -820,7 +1004,10 @@ function parseWorkweek(s: string): Weekday[] | null {
   }
 
   // Try comma-separated: "mon, tue, wed, thu, fri"
-  const parts = s.toLowerCase().split(',').map(p => p.trim());
+  const parts = s
+    .toLowerCase()
+    .split(',')
+    .map((p) => p.trim());
   const days: Weekday[] = [];
   for (const part of parts) {
     const day = WEEKDAY_MAP[part];
@@ -833,13 +1020,20 @@ function parseWorkweek(s: string): Weekday[] | null {
 // ── Known option keys ─────────────────────────────────────
 
 const KNOWN_OPTIONS = new Set([
-  'start', 'title', 'orientation', 'today-marker',
-  'critical-path', 'dependencies', 'chart', 'sort',
+  'start',
+  'title',
+  'today-marker',
+  'critical-path',
+  'dependencies',
+  'chart',
+  'sort',
 ]);
 
 /** Boolean options that can appear as bare keywords or with `no-` prefix. */
 const KNOWN_BOOLEANS = new Set([
-  'critical-path', 'today-marker', 'dependencies',
+  'critical-path',
+  'today-marker',
+  'dependencies',
 ]);
 
 function isKnownOption(key: string): boolean {