agentic-mermaid 0.1.1 → 0.2.0

package/src/gantt/layout.ts

@@ -1,365 +0,0 @@
-// ============================================================================
-// Gantt layout — schedule → deterministic geometry (docs/design/families/gantt.md §4).
-//
-// One layout model feeds both renderers: the SVG renderer consumes the pixel
-// geometry directly; the ASCII renderer reuses tick *selection* (the resolved
-// tick instants) and the row model with its own column math. Bars never
-// leave the plot area; `vert` markers consume no task row; compact mode packs
-// non-overlapping tasks of a section into shared rows deterministically
-// (first-fit by source order).
-// ============================================================================
-
-import type {
-  GanttModel, GanttSchedule, GanttLayoutResult, GanttBarLayout, GanttRowLayout,
-  GanttSectionBand, GanttVertLayout, GanttTick, GanttTickUnit, EpochMs,
-} from './types.ts'
-import { DAY_MS, dayOfWeek, WEEKDAY_INDEX, formatGanttInstant, startOfDay } from './schedule.ts'
-import { applyTextTransform, estimateTextWidth, resolveRenderStyle, STROKE_WIDTHS } from '../styles.ts'
-import type { RenderStyleDefaults, ResolvedRenderStyle } from '../styles.ts'
-import type { RenderOptions } from '../types.ts'
-
-export const GANTT_MAX_TICKS = 120
-
-export interface GanttLayoutOptions {
-  /** Total drawing width; the plot shrinks to fit. */
-  width?: number
-  compact?: boolean
-  barHeight?: number
-  /** Resolved clock instant (schedule.today). */
-  today?: EpochMs
-  /** Render options whose style roles affect label and axis geometry. */
-  renderOptions?: RenderOptions
-}
-
-const GL = {
-  plotWidth: 600,
-  padding: 16,
-  titleHeight: 34,
-  axisHeight: 24,
-  rowGap: 8,
-  sectionGap: 6,
-  barHeight: 22,
-  labelGap: 12,
-  labelFontSize: 13,
-  sectionFontSize: 13,
-} as const
-
-export const GANTT_STYLE_DEFAULTS: RenderStyleDefaults = {
-  nodeLabelFontSize: GL.labelFontSize,
-  edgeLabelFontSize: 11,
-  groupHeaderFontSize: GL.sectionFontSize,
-  nodeLabelFontWeight: 500,
-  edgeLabelFontWeight: 500,
-  groupHeaderFontWeight: 600,
-  nodePaddingX: 0,
-  nodePaddingY: 0,
-  nodeLineWidth: STROKE_WIDTHS.innerBox,
-  edgeLineWidth: STROKE_WIDTHS.connector,
-  groupCornerRadius: 0,
-  groupPaddingX: 0,
-  groupPaddingY: 0,
-  groupLineWidth: STROKE_WIDTHS.outerBox,
-}
-
-const TICK_UNIT_MS: Record<GanttTickUnit, number> = {
-  millisecond: 1,
-  second: 1000,
-  minute: 60_000,
-  hour: 3_600_000,
-  day: DAY_MS,
-  week: 7 * DAY_MS,
-  month: 30 * DAY_MS, // month ticks step by calendar months; this is the sizing estimate
-}
-
-// Auto-tick candidates: (stepMs, defaultFormat) pairs from minutes to years.
-const AUTO_TICKS: Array<{ unit: GanttTickUnit; count: number; format: string }> = [
-  { unit: 'minute', count: 1, format: '%H:%M' },
-  { unit: 'minute', count: 15, format: '%H:%M' },
-  { unit: 'hour', count: 1, format: '%H:%M' },
-  { unit: 'hour', count: 6, format: '%H:%M' },
-  { unit: 'day', count: 1, format: '%m-%d' },
-  { unit: 'week', count: 1, format: '%m-%d' },
-  { unit: 'week', count: 2, format: '%m-%d' },
-  { unit: 'month', count: 1, format: '%b %Y' },
-  { unit: 'month', count: 3, format: '%b %Y' },
-  { unit: 'month', count: 12, format: '%Y' },
-]
-
-interface TickPlan {
-  unit: GanttTickUnit
-  count: number
-  format: string
-}
-
-const INLINE_FORMAT_TAG = /<\/?(?:b|strong|i|em|u|s|del)\s*>/gi
-
-export function resolveGanttRenderStyle(options: RenderOptions = {}): ResolvedRenderStyle {
-  return resolveRenderStyle(options, GANTT_STYLE_DEFAULTS)
-}
-
-export function ganttTitleFontSize(style: ResolvedRenderStyle): number {
-  return Math.max(17, style.groupHeaderFontSize)
-}
-
-export function ganttTitleY(style: ResolvedRenderStyle): number {
-  const titleHeight = ganttTitleHeight(style)
-  return titleHeight === GL.titleHeight ? 18 : titleHeight / 2
-}
-
-export function ganttAxisLabelOffset(style: ResolvedRenderStyle): number {
-  return Math.max(10, style.edgeLabelFontSize * 0.75)
-}
-
-export function ganttMeasureTextWidth(
-  text: string,
-  fontSize: number,
-  fontWeight: number,
-  letterSpacing = 0,
-): number {
-  const plain = text.replace(INLINE_FORMAT_TAG, '')
-  const codepoints = [...plain].length
-  const tracking = Math.max(0, codepoints - 1) * letterSpacing
-  return Math.max(0, estimateTextWidth(plain, fontSize, fontWeight) + tracking)
-}
-
-function ganttTitleHeight(style: ResolvedRenderStyle): number {
-  return Math.max(GL.titleHeight, Math.ceil(ganttTitleFontSize(style) * 1.3) + 8)
-}
-
-function ganttAxisHeight(style: ResolvedRenderStyle): number {
-  return Math.max(GL.axisHeight, Math.ceil(ganttAxisLabelOffset(style) + style.edgeLabelFontSize * 0.65 + 4))
-}
-
-function ganttRowHeight(style: ResolvedRenderStyle, barHeight: number): number {
-  const labelLineHeight = Math.max(style.nodeLabelFontSize, style.groupHeaderFontSize) * 1.3
-  return Math.ceil(Math.max(barHeight, labelLineHeight)) + GL.rowGap
-}
-
-/**
- * Pick the tick plan: the explicit `tickInterval` when it stays under the
- * GANTT_MAX_TICKS bound (mermaid PR #7197 regression: tiny intervals must not
- * generate unbounded ticks), otherwise the smallest auto candidate that fits.
- */
-export function planTicks(schedule: GanttSchedule, model: GanttModel, targetTicks = 8): TickPlan {
-  const span = schedule.timeMax - schedule.timeMin
-  if (model.tickInterval) {
-    const step = TICK_UNIT_MS[model.tickInterval.unit] * model.tickInterval.count
-    if (span / step <= GANTT_MAX_TICKS) {
-      return { ...model.tickInterval, format: model.axisFormat ?? defaultFormatFor(model.tickInterval.unit) }
-    }
-  }
-  for (const cand of AUTO_TICKS) {
-    const step = TICK_UNIT_MS[cand.unit] * cand.count
-    if (span / step <= targetTicks) {
-      return { unit: cand.unit, count: cand.count, format: model.axisFormat ?? cand.format }
-    }
-  }
-  const last = AUTO_TICKS[AUTO_TICKS.length - 1]!
-  // Beyond the largest candidate: scale year ticks up until bounded.
-  let count = last.count
-  while ((span / (TICK_UNIT_MS.month * count)) > GANTT_MAX_TICKS) count *= 2
-  return { unit: 'month', count, format: model.axisFormat ?? last.format }
-}
-
-function defaultFormatFor(unit: GanttTickUnit): string {
-  switch (unit) {
-    case 'millisecond': case 'second': return '%H:%M:%S'
-    case 'minute': case 'hour': return '%H:%M'
-    case 'day': case 'week': return '%m-%d'
-    case 'month': return '%b %Y'
-  }
-}
-
-/** First tick instant at or before timeMin, aligned to the unit (weeks align
- *  to the model's weekStart; months to the 1st; days to midnight UTC). */
-function alignTickStart(timeMin: EpochMs, plan: TickPlan, weekStart: number): EpochMs {
-  if (plan.unit === 'week') {
-    let t = startOfDay(timeMin)
-    let steps = 0
-    while (dayOfWeek(t) !== weekStart && steps++ < 7) t -= DAY_MS
-    return t
-  }
-  if (plan.unit === 'month') {
-    const d = new Date(timeMin)
-    return Date.UTC(d.getUTCFullYear(), d.getUTCMonth(), 1)
-  }
-  if (plan.unit === 'day') return startOfDay(timeMin)
-  const step = TICK_UNIT_MS[plan.unit] * plan.count
-  return Math.floor(timeMin / step) * step
-}
-
-function nextTick(t: EpochMs, plan: TickPlan): EpochMs {
-  if (plan.unit === 'month') {
-    const d = new Date(t)
-    return Date.UTC(d.getUTCFullYear(), d.getUTCMonth() + plan.count, 1)
-  }
-  return t + TICK_UNIT_MS[plan.unit] * plan.count
-}
-
-/**
- * Resolve the tick instants for a schedule (shared by SVG and ASCII).
- * Bounded by GANTT_MAX_TICKS regardless of inputs.
- */
-export function resolveTicks(schedule: GanttSchedule, model: GanttModel, targetTicks = 8): Array<{ time: EpochMs; label: string }> {
-  const plan = planTicks(schedule, model, targetTicks)
-  const weekStart = WEEKDAY_INDEX[model.weekStart]
-  const out: Array<{ time: EpochMs; label: string }> = []
-  let t = alignTickStart(schedule.timeMin, plan, weekStart)
-  let guard = 0
-  while (t <= schedule.timeMax && guard++ <= GANTT_MAX_TICKS) {
-    if (t >= schedule.timeMin) out.push({ time: t, label: formatGanttInstant(t, plan.format) })
-    t = nextTick(t, plan)
-  }
-  // A coarse explicit interval over a short span (e.g. `tickInterval 1month`
-  // on a 2-day chart) can leave zero in-range ticks; an axis must never be
-  // empty, so fall back to a single tick at the range start.
-  if (out.length === 0) {
-    out.push({ time: schedule.timeMin, label: formatGanttInstant(schedule.timeMin, plan.format) })
-  }
-  return out
-}
-
-/**
- * Compact-mode lane packing: within one section, tasks (source order) go to
- * the first lane whose latest end is <= the task's start. Deterministic and
- * overlap-free by construction.
- */
-export function packCompactLanes(tasks: Array<{ start: EpochMs; end: EpochMs }>): number[] {
-  const laneEnds: EpochMs[] = []
-  const laneOf: number[] = []
-  for (const t of tasks) {
-    let lane = laneEnds.findIndex(end => end <= t.start)
-    if (lane === -1) {
-      lane = laneEnds.length
-      laneEnds.push(t.end)
-    } else {
-      laneEnds[lane] = t.end
-    }
-    laneOf.push(lane)
-  }
-  return laneOf
-}
-
-export function layoutGantt(model: GanttModel, schedule: GanttSchedule, options: GanttLayoutOptions = {}): GanttLayoutResult {
-  const style = resolveGanttRenderStyle(options.renderOptions)
-  const compact = options.compact ?? (model.displayMode === 'compact')
-  const barHeight = options.barHeight ?? model.barHeight ?? GL.barHeight
-  const rowH = ganttRowHeight(style, barHeight)
-
-  const vertTasks = schedule.tasks.filter(t => t.tags.includes('vert'))
-  const rowTasks = schedule.tasks.filter(t => !t.tags.includes('vert'))
-
-  // ---- label column ---------------------------------------------------------
-  let labelColumnWidth = 0
-  for (const t of rowTasks) {
-    const label = applyTextTransform(t.label, style.nodeTextTransform)
-    labelColumnWidth = Math.max(labelColumnWidth, ganttMeasureTextWidth(label, style.nodeLabelFontSize, style.nodeLabelFontWeight, style.nodeLetterSpacing))
-  }
-  for (const s of model.sections) {
-    if (s.label) {
-      const label = applyTextTransform(s.label, style.groupTextTransform)
-      labelColumnWidth = Math.max(labelColumnWidth, ganttMeasureTextWidth(label, style.groupHeaderFontSize, style.groupHeaderFontWeight, style.groupLetterSpacing))
-    }
-  }
-  labelColumnWidth = Math.ceil(labelColumnWidth) + GL.labelGap
-
-  const width = options.width ?? (GL.padding * 2 + labelColumnWidth + GL.plotWidth)
-  const plotX = GL.padding + labelColumnWidth
-  const plotW = Math.max(120, width - plotX - GL.padding)
-
-  const titleH = model.title ? ganttTitleHeight(style) : 0
-  const axisH = ganttAxisHeight(style)
-  const topAxisH = model.topAxis ? axisH : 0
-  const plotY = GL.padding + titleH + topAxisH
-
-  const span = schedule.timeMax - schedule.timeMin
-  const xOf = (t: EpochMs): number => plotX + ((t - schedule.timeMin) / span) * plotW
-
-  // ---- rows + bars (vert tasks never consume a row) --------------------------
-  const bars: GanttBarLayout[] = []
-  const rows: GanttRowLayout[] = []
-  const sections: GanttSectionBand[] = []
-  let y = plotY
-
-  for (let si = 0; si < model.sections.length; si++) {
-    const section = model.sections[si]!
-    const sectionTasks = rowTasks.filter(t => t.sectionIndex === si)
-    if (sectionTasks.length === 0 && section.label === undefined) continue
-    // Bars/rows reference the BAND index in the emitted sections array (empty
-    // implicit sections are skipped, so it can differ from the model index).
-    const bandIndex = sections.length
-    const bandStartY = y
-    const rowStart = rows.length
-    if (section.label !== undefined) y += rowH // the section header row
-
-    const lanes = compact ? packCompactLanes(sectionTasks) : sectionTasks.map((_, i) => i)
-    const laneCount = sectionTasks.length === 0 ? 0 : Math.max(...lanes) + 1
-    const laneRows: GanttRowLayout[] = []
-    for (let li = 0; li < laneCount; li++) {
-      laneRows.push({ barIndexes: [], sectionIndex: bandIndex, y: y + li * rowH, h: barHeight })
-    }
-    sectionTasks.forEach((t, i) => {
-      const lane = lanes[i]!
-      const row = laneRows[lane]!
-      const x = xOf(t.start)
-      const w = Math.max(t.end > t.start ? 2 : 0, xOf(t.end) - x)
-      const isMilestone = t.tags.includes('milestone')
-      // Milestone diamonds extend ±barHeight/2 around their center; clamp the
-      // center so a milestone at the range edge stays inside the plot band
-      // (the ASCII renderer clamps its grid column the same way — issue #26:
-      // shared geometry, not per-renderer patch-ups).
-      let milestoneX: number | undefined
-      if (isMilestone) {
-        const r = barHeight / 2
-        const lo = plotX + r
-        const hi = Math.max(lo, plotX + plotW - r)
-        milestoneX = Math.min(hi, Math.max(lo, x + w / 2))
-      }
-      bars.push({
-        taskIndex: t.index, id: t.id, label: t.label, tags: t.tags, sectionIndex: bandIndex,
-        x, y: row.y, w, h: barHeight,
-        milestoneX,
-        rowIndex: rowStart + (section.label !== undefined ? 1 : 0) + lane,
-        start: t.start, end: t.end,
-      })
-      row.barIndexes.push(bars.length - 1)
-    })
-    rows.push(...laneRows)
-    y += laneCount * rowH
-    sections.push({
-      label: section.label, y: bandStartY, h: y - bandStartY,
-      rowStart, rowEnd: rows.length,
-    })
-    y += GL.sectionGap
-  }
-
-  const plotH = Math.max(rowH, y - plotY)
-  const height = plotY + plotH + axisH + GL.padding
-
-  // ---- ticks / markers --------------------------------------------------------
-  const ticks: GanttTick[] = resolveTicks(schedule, model).map(t => ({
-    time: t.time, x: xOf(t.time), label: t.label,
-  }))
-
-  const verts: GanttVertLayout[] = vertTasks.map(t => ({
-    taskIndex: t.index, label: t.label,
-    x: xOf(t.start + (t.end - t.start) / 2), time: t.start,
-  }))
-
-  const todayX = options.today !== undefined && options.today >= schedule.timeMin && options.today <= schedule.timeMax
-    ? xOf(options.today)
-    : undefined
-
-  return {
-    title: model.title,
-    width, height,
-    plot: { x: plotX, y: plotY, w: plotW, h: plotH },
-    labelColumnWidth,
-    rows, sections, bars, verts, ticks,
-    topAxis: model.topAxis,
-    todayX,
-    timeMin: schedule.timeMin, timeMax: schedule.timeMax,
-    dateOnly: schedule.dateOnly,
-    compact, barHeight,
-  }
-}

package/src/gantt/parser.ts

@@ -1,282 +0,0 @@
-// ============================================================================
-// Gantt syntax parser — Mermaid-compatible `gantt` source → GanttModel.
-//
-// Renderer-grade parser with error semantics (docs/design/families/gantt.md §Parser
-// rules): never silently drop a line; duplicate task ids are errors; invalid
-// directives/tasks are errors with line numbers. The agent-grade structured-
-// or-opaque parser lives in src/agent/gantt-body.ts and shares the task-line
-// helpers exported here so the two cannot drift.
-//
-// Input is the normalized line list from mermaid-source.ts (trimmed, comments
-// stripped, header first). Frontmatter-derived config (displayMode, barHeight)
-// is merged by the caller via applyGanttFrontmatterConfig.
-// ============================================================================
-
-import type {
-  GanttModel, GanttModelTask, GanttModelSection, GanttTaskTag,
-  GanttCalendarToken, GanttWeekday, GanttStartExpr, GanttEndExpr, GanttTickUnit,
-} from './types.ts'
-import { GanttError } from './types.ts'
-import type { MermaidFrontmatterMap } from '../mermaid-source.ts'
-import { getFrontmatterMap, getFrontmatterScalar } from '../mermaid-source.ts'
-
-export const GANTT_TASK_TAGS: readonly GanttTaskTag[] = ['active', 'done', 'crit', 'milestone', 'vert']
-
-const WEEKDAYS: readonly GanttWeekday[] = [
-  'sunday', 'monday', 'tuesday', 'wednesday', 'thursday', 'friday', 'saturday',
-]
-
-export const GANTT_DURATION_RE = /^(\d+(?:\.\d+)?)(ms|s|m|h|d|w|M|y)$/
-const TICK_INTERVAL_RE = /^([1-9][0-9]*)(millisecond|second|minute|hour|day|week|month)$/
-
-export interface ParsedTaskMeta {
-  tags: GanttTaskTag[]
-  id?: string
-  start?: GanttStartExpr
-  end: GanttEndExpr
-}
-
-/**
- * Parse the metadata half of a task line (after the `:`), following Mermaid's
- * comma-split convention: leading items are status tags; the remainder is
- * `[id,] [start,] end`. One item = end only (start inherited from the previous
- * task); two = start + end; three = id + start + end. Returns null with no
- * side effects when the shape is invalid — callers decide error vs opaque.
- */
-export function parseGanttTaskMeta(rawMeta: string): ParsedTaskMeta | null {
-  const items = rawMeta.split(',').map(s => s.trim())
-  if (items.some(s => s.length === 0)) return null
-  const tags: GanttTaskTag[] = []
-  let i = 0
-  while (i < items.length && (GANTT_TASK_TAGS as readonly string[]).includes(items[i]!)) {
-    const tag = items[i]! as GanttTaskTag
-    if (tags.includes(tag)) return null // repeated tag is malformed
-    tags.push(tag)
-    i++
-  }
-  const rest = items.slice(i)
-  if (rest.length === 0 || rest.length > 3) return null
-
-  const classifyStart = (raw: string): GanttStartExpr => {
-    const after = raw.match(/^after\s+(.+)$/)
-    if (after) return { kind: 'after', refs: after[1]!.split(/\s+/).filter(Boolean) }
-    return { kind: 'date', raw }
-  }
-  const classifyEnd = (raw: string): GanttEndExpr => {
-    const until = raw.match(/^until\s+(.+)$/)
-    if (until) return { kind: 'until', refs: until[1]!.split(/\s+/).filter(Boolean) }
-    if (GANTT_DURATION_RE.test(raw)) return { kind: 'duration', raw }
-    return { kind: 'date', raw }
-  }
-
-  if (rest.length === 1) return { tags, end: classifyEnd(rest[0]!) }
-  if (rest.length === 2) return { tags, start: classifyStart(rest[0]!), end: classifyEnd(rest[1]!) }
-  // Three items: Mermaid treats the first as the task id unconditionally.
-  const id = rest[0]!
-  if (!/^[\w-]+$/.test(id)) return null
-  return { tags, id, start: classifyStart(rest[1]!), end: classifyEnd(rest[2]!) }
-}
-
-/** Canonical re-emission of a parsed task metadata (used by the agent body
- *  serializer and the parser↔body differential tests). */
-export function renderGanttTaskMeta(meta: ParsedTaskMeta): string {
-  const parts: string[] = [...meta.tags]
-  if (meta.id !== undefined) parts.push(meta.id)
-  if (meta.start) parts.push(meta.start.kind === 'after' ? `after ${meta.start.refs.join(' ')}` : meta.start.raw)
-  parts.push(meta.end.kind === 'until' ? `until ${meta.end.refs.join(' ')}` : meta.end.raw)
-  return parts.join(', ')
-}
-
-function parseCalendarTokens(raw: string): GanttCalendarToken[] {
-  // Mermaid accepts comma- or whitespace-separated entries.
-  return raw.split(/[,\s]+/).filter(Boolean).map((tok): GanttCalendarToken => {
-    const lower = tok.toLowerCase()
-    if (lower === 'weekends') return { kind: 'weekends' }
-    if ((WEEKDAYS as readonly string[]).includes(lower)) return { kind: 'weekday', day: lower as GanttWeekday }
-    return { kind: 'date', raw: tok }
-  })
-}
-
-const DIRECTIVE_RES = {
-  title: /^title\s+(.+)$/i,
-  dateFormat: /^dateFormat\s+(.+)$/i,
-  axisFormat: /^axisFormat\s+(.+)$/i,
-  tickInterval: /^tickInterval\s+(.+)$/i,
-  excludes: /^excludes\s+(.+)$/i,
-  includes: /^includes\s+(.+)$/i,
-  todayMarker: /^todayMarker\s+(.+)$/i,
-  weekday: /^weekday\s+(.+)$/i,
-  weekend: /^weekend\s+(.+)$/i,
-  section: /^section\s+(.+)$/i,
-  click: /^click\s+([\w-]+)\s+(href|call)\s+(.+)$/i,
-  accTitle: /^accTitle\s*:\s*(.+)$/i,
-  accDescrInline: /^accDescr\s*:\s*(.+)$/i,
-  accDescrBlock: /^accDescr\s*\{\s*$/i,
-} as const
-
-/**
- * Parse normalized Mermaid gantt lines (header included) into a GanttModel.
- * Throws GanttError with a code and 1-based line number on the first invalid
- * construct. Lines is the normalized list, so `lineNo` refers to it.
- */
-export function parseGanttModel(lines: string[]): GanttModel {
-  const header = (lines[0] ?? '').trim()
-  if (!/^gantt\s*$/i.test(header)) {
-    throw new GanttError('GANTT_BAD_DIRECTIVE', `Expected "gantt" header, got "${header}"`, 1)
-  }
-
-  const model: GanttModel = {
-    dateFormat: 'YYYY-MM-DD',
-    inclusiveEndDates: false,
-    topAxis: false,
-    excludes: [],
-    includes: [],
-    weekendStart: 'saturday',
-    weekStart: 'sunday',
-    sections: [{ taskIndexes: [] }],
-    tasks: [],
-    clicks: [],
-  }
-  const seenIds = new Set<string>()
-  let currentSection = 0
-  let inAccDescr = false
-  const accDescrBuf: string[] = []
-
-  for (let i = 1; i < lines.length; i++) {
-    const line = lines[i]!.trim()
-    const lineNo = i + 1
-    if (!line || line.startsWith('%%')) continue
-
-    if (inAccDescr) {
-      if (/^\}\s*$/.test(line)) {
-        model.accDescr = accDescrBuf.join(' ').trim()
-        inAccDescr = false
-      } else {
-        accDescrBuf.push(line)
-      }
-      continue
-    }
-
-    let m: RegExpMatchArray | null
-
-    if ((m = line.match(DIRECTIVE_RES.title))) { model.title = m[1]!.trim(); continue }
-    if ((m = line.match(DIRECTIVE_RES.dateFormat))) { model.dateFormat = m[1]!.trim(); continue }
-    if ((m = line.match(DIRECTIVE_RES.axisFormat))) { model.axisFormat = m[1]!.trim(); continue }
-    if ((m = line.match(DIRECTIVE_RES.tickInterval))) {
-      // Lenient like Mermaid: values outside the documented
-      // `count(millisecond|second|minute|hour|day|week|month)` shape are
-      // ignored and the axis falls back to auto ticks — mermaid's own docs
-      // contain `tickInterval 1decade`. The PR #7197 safety property lives in
-      // bounded tick GENERATION (layout.ts), not in rejecting the directive.
-      const tm = m[1]!.trim().match(TICK_INTERVAL_RE)
-      if (tm) model.tickInterval = { count: Number(tm[1]), unit: tm[2] as GanttTickUnit }
-      continue
-    }
-    if (/^inclusiveEndDates\s*$/i.test(line)) { model.inclusiveEndDates = true; continue }
-    if (/^topAxis\s*$/i.test(line)) { model.topAxis = true; continue }
-    if ((m = line.match(DIRECTIVE_RES.excludes))) {
-      // Multiple excludes lines accumulate (mermaid PR #7772).
-      model.excludes.push(...parseCalendarTokens(m[1]!.trim()))
-      continue
-    }
-    if ((m = line.match(DIRECTIVE_RES.includes))) {
-      model.includes.push(...parseCalendarTokens(m[1]!.trim()))
-      continue
-    }
-    if ((m = line.match(DIRECTIVE_RES.todayMarker))) {
-      const v = m[1]!.trim()
-      model.todayMarker = v.toLowerCase() === 'off' ? { off: true } : { off: false, style: v }
-      continue
-    }
-    if ((m = line.match(DIRECTIVE_RES.weekday))) {
-      const day = m[1]!.trim().toLowerCase()
-      if (!(WEEKDAYS as readonly string[]).includes(day)) {
-        throw new GanttError('GANTT_BAD_DIRECTIVE', `Invalid weekday "${m[1]!.trim()}"`, lineNo)
-      }
-      model.weekStart = day as GanttWeekday
-      continue
-    }
-    if ((m = line.match(DIRECTIVE_RES.weekend))) {
-      const day = m[1]!.trim().toLowerCase()
-      if (day !== 'friday' && day !== 'saturday') {
-        throw new GanttError('GANTT_BAD_DIRECTIVE', `Invalid weekend "${m[1]!.trim()}" (friday or saturday)`, lineNo)
-      }
-      model.weekendStart = day
-      continue
-    }
-    if ((m = line.match(DIRECTIVE_RES.click))) {
-      model.clicks.push({ taskId: m[1]!, action: m[2]!.toLowerCase() as 'href' | 'call', rest: m[3]!.trim(), line: lineNo })
-      continue
-    }
-    if ((m = line.match(DIRECTIVE_RES.accTitle))) { model.accTitle = m[1]!.trim(); continue }
-    if (DIRECTIVE_RES.accDescrBlock.test(line)) { inAccDescr = true; continue }
-    if ((m = line.match(DIRECTIVE_RES.accDescrInline))) { model.accDescr = m[1]!.trim(); continue }
-    if ((m = line.match(DIRECTIVE_RES.section))) {
-      model.sections.push({ label: m[1]!.trim(), taskIndexes: [], line: lineNo })
-      currentSection = model.sections.length - 1
-      continue
-    }
-
-    // Task line: `<label> : <metadata>` — label is everything before the LAST
-    // colon-separated metadata block. Mermaid's grammar splits on the first
-    // colon (labels cannot contain `:`); `#`/`;` are allowed in labels since
-    // mermaid PR #5095 (our comment stripping only removes `%%` lines).
-    const colon = line.indexOf(':')
-    if (colon > 0 && colon < line.length - 1) {
-      const label = line.slice(0, colon).trim()
-      const rawMeta = line.slice(colon + 1).trim()
-      const meta = parseGanttTaskMeta(rawMeta)
-      if (!meta) throw new GanttError('GANTT_BAD_TASK', `Invalid task metadata "${rawMeta}"`, lineNo)
-      if (!label) throw new GanttError('GANTT_BAD_TASK', 'Task label is empty', lineNo)
-      if (meta.id !== undefined) {
-        if (seenIds.has(meta.id)) throw new GanttError('GANTT_DUPLICATE_TASK_ID', `Duplicate task id "${meta.id}"`, lineNo)
-        seenIds.add(meta.id)
-      }
-      const task: GanttModelTask = {
-        index: model.tasks.length,
-        id: meta.id,
-        label,
-        tags: meta.tags,
-        start: meta.start,
-        end: meta.end,
-        sectionIndex: currentSection,
-        line: lineNo,
-      }
-      model.tasks.push(task)
-      model.sections[currentSection]!.taskIndexes.push(task.index)
-      continue
-    }
-
-    throw new GanttError('GANTT_BAD_DIRECTIVE', `Unrecognized gantt line "${line}"`, lineNo)
-  }
-
-  if (inAccDescr) throw new GanttError('GANTT_BAD_DIRECTIVE', 'Unclosed accDescr block')
-  return model
-}
-
-/**
- * Merge frontmatter/init config into the model: Mermaid accepts
- * `displayMode: compact` at the top level and `gantt: { displayMode,
- * barHeight, topAxis }` under config. mermaid-source.ts already folds the
- * `config:` root into the top-level map.
- */
-export function applyGanttFrontmatterConfig(model: GanttModel, frontmatter: MermaidFrontmatterMap | undefined): GanttModel {
-  if (!frontmatter) return model
-  const topLevelMode = getFrontmatterScalar<string>(frontmatter, ['displayMode'])
-  const ganttMap = getFrontmatterMap(frontmatter, ['gantt'])
-  const ganttMode = ganttMap ? getFrontmatterScalar<string>(frontmatter, ['gantt', 'displayMode']) : undefined
-  const mode = ganttMode ?? topLevelMode
-  if (typeof mode === 'string' && mode.toLowerCase() === 'compact') model.displayMode = 'compact'
-  const barHeight = getFrontmatterScalar<number>(frontmatter, ['gantt', 'barHeight'])
-  if (typeof barHeight === 'number' && Number.isFinite(barHeight) && barHeight > 0) model.barHeight = barHeight
-  const topAxis = getFrontmatterScalar<boolean>(frontmatter, ['gantt', 'topAxis'])
-  if (topAxis === true) model.topAxis = true
-  const axisFormat = getFrontmatterScalar<string>(frontmatter, ['gantt', 'axisFormat'])
-  if (typeof axisFormat === 'string' && model.axisFormat === undefined) model.axisFormat = axisFormat
-  const tickInterval = getFrontmatterScalar<string>(frontmatter, ['gantt', 'tickInterval'])
-  if (typeof tickInterval === 'string' && model.tickInterval === undefined) {
-    const tm = tickInterval.match(TICK_INTERVAL_RE)
-    if (tm) model.tickInterval = { count: Number(tm[1]), unit: tm[2] as GanttTickUnit }
-  }
-  return model
-}

package/src/gantt/pipeline.ts

@@ -1,27 +0,0 @@
-import type { MermaidFrontmatterMap } from '../mermaid-source.ts'
-import { applyGanttFrontmatterConfig, parseGanttModel } from './parser.ts'
-import { resolveGanttSchedule } from './schedule.ts'
-import { layoutGantt, type GanttLayoutOptions } from './layout.ts'
-import type { GanttClock, GanttLayoutResult, GanttModel, GanttSchedule } from './types.ts'
-
-export interface GanttRenderPipelineOptions {
-  clock?: GanttClock
-  layout?: Omit<GanttLayoutOptions, 'today'>
-}
-
-export interface GanttRenderPipeline {
-  model: GanttModel
-  schedule: GanttSchedule
-  positioned: GanttLayoutResult
-}
-
-export function buildGanttRenderPipeline(
-  lines: string[],
-  frontmatter: MermaidFrontmatterMap | undefined,
-  options: GanttRenderPipelineOptions = {},
-): GanttRenderPipeline {
-  const model = applyGanttFrontmatterConfig(parseGanttModel(lines), frontmatter)
-  const schedule = resolveGanttSchedule(model, options.clock)
-  const positioned = layoutGantt(model, schedule, { ...options.layout, today: schedule.today })
-  return { model, schedule, positioned }
-}