@diagrammo/dgmo 0.46.0 → 0.48.0

package/{src/gantt/calculator.ts → dist/chunk-Z72XRXD4.js}

@@ -1,56 +1,103 @@
-// ============================================================
-// Gantt Schedule Calculator
-// ============================================================
-//
-// Takes a ParsedGantt and resolves all tasks to concrete start/end dates.
-// Algorithm:
-// 1. Flatten task tree, build dependency graph
-// 2. Topological sort with cycle detection
-// 3. Forward pass: resolve dates using universal max rule
-// 4. (Optional) Critical path: backward pass to find zero-slack chain
-
-import { makeDgmoError } from '../diagnostics';
-import type { DgmoError } from '../diagnostics';
-import type {
-  ParsedGantt,
-  GanttNode,
-  GanttTask,
-  GanttGroup,
-  GanttHolidays,
-  GanttOptions,
-  Duration,
-  ResolvedSchedule,
-  ResolvedSprint,
-  ResolvedGroup,
-  Offset,
-} from './types';
-import { collectTasks, resolveTaskName, isResolverError } from './resolver';
 import {
   addGanttDuration,
   buildHolidaySet,
-  parseGanttDate,
-} from '../utils/duration';
-
-// ── Internal types ──────────────────────────────────────────
+  parseGanttDate
+} from "./chunk-USZW2HHU.js";
+import {
+  normalizeName
+} from "./chunk-NOTA6TEI.js";
+import {
+  makeDgmoError
+} from "./chunk-CXK4DZH3.js";
 
-interface TaskNode {
-  task: GanttTask;
-  /** IDs of tasks this task depends on (both implicit and explicit) */
-  predecessors: string[];
-  /** Resolved start/end dates (filled during forward pass) */
-  startDate: Date | null;
-  endDate: Date | null;
+// src/gantt/resolver.ts
+function isResolverError(r) {
+  return "kind" in r;
+}
+function collectTasks(nodes) {
+  const tasks = [];
+  function walk(children) {
+    for (const node of children) {
+      if (node.kind === "task") {
+        tasks.push(node);
+      } else if (node.kind === "group" || node.kind === "parallel") {
+        walk(node.children);
+      }
+    }
+  }
+  walk(nodes);
+  return tasks;
+}
+var BRACKET_GROUP_RE = /^\[(.+?)\]\.(.+)$/;
+function ambiguousTaskMessage(trimmed, suggestions) {
+  return `Multiple tasks match "${trimmed}". Did you mean ${suggestions.map((s) => `\`${s}\``).join(" or ")}?`;
+}
+function resolveTaskName(name, allTasks) {
+  let trimmed = name.trim();
+  const bracketMatch = trimmed.match(BRACKET_GROUP_RE);
+  if (bracketMatch) {
+    trimmed = `${bracketMatch[1]}.${bracketMatch[2]}`;
+  }
+  const normTrimmed = normalizeName(trimmed);
+  const exactMatches = allTasks.filter(
+    (t) => normalizeName(t.label) === normTrimmed
+  );
+  if (exactMatches.length === 1) {
+    return { task: exactMatches[0] };
+  }
+  if (exactMatches.length > 1) {
+    const suggestions = exactMatches.map(
+      (t) => t.groupPath.length > 0 ? `${t.groupPath.join(".")}.${t.label}` : t.label
+    );
+    return {
+      kind: "ambiguous",
+      message: ambiguousTaskMessage(trimmed, suggestions)
+    };
+  }
+  const lastDotIdx = trimmed.lastIndexOf(".");
+  if (lastDotIdx > 0) {
+    const groupPrefix = trimmed.substring(0, lastDotIdx);
+    const taskLabel = trimmed.substring(lastDotIdx + 1);
+    const normTaskLabel = normalizeName(taskLabel);
+    const matches = allTasks.filter((t) => {
+      if (normalizeName(t.label) !== normTaskLabel) return false;
+      return matchesGroupPath(t.groupPath, groupPrefix);
+    });
+    if (matches.length === 1) {
+      return { task: matches[0] };
+    }
+    if (matches.length > 1) {
+      const suggestions = matches.map(
+        (t) => t.groupPath.length > 0 ? `${t.groupPath.join(".")}.${t.label}` : t.label
+      );
+      return {
+        kind: "ambiguous",
+        message: ambiguousTaskMessage(trimmed, suggestions)
+      };
+    }
+  }
+  return {
+    kind: "not_found",
+    message: `No task found with name "${trimmed}".`
+  };
+}
+function matchesGroupPath(groupPath, prefix) {
+  const normPrefix = normalizeName(prefix);
+  if (!prefix.includes(".")) {
+    return groupPath.some((g) => normalizeName(g) === normPrefix);
+  }
+  const pathStr = groupPath.map((g) => normalizeName(g)).join(".");
+  return pathStr === normPrefix || pathStr.endsWith("." + normPrefix) || pathStr.startsWith(normPrefix + ".") || pathStr.includes("." + normPrefix + ".");
 }
 
-// ── Main calculator ─────────────────────────────────────────
-
-export function calculateSchedule(parsed: ParsedGantt): ResolvedSchedule {
-  const diagnostics: DgmoError[] = [...parsed.diagnostics];
-  const result: ResolvedSchedule = {
+// src/gantt/calculator.ts
+function calculateSchedule(parsed) {
+  const diagnostics = [...parsed.diagnostics];
+  const result = {
     tasks: [],
     groups: [],
-    startDate: new Date(),
-    endDate: new Date(),
+    startDate: /* @__PURE__ */ new Date(),
+    endDate: /* @__PURE__ */ new Date(),
     holidays: parsed.holidays,
     tagGroups: parsed.tagGroups.slice(),
     eras: [],
@@ -58,127 +105,86 @@ export function calculateSchedule(parsed: ParsedGantt): ResolvedSchedule {
     sprints: [],
     options: parsed.options,
     diagnostics,
-    error: parsed.error,
+    error: parsed.error
   };
-
   if (parsed.error) return result;
-
-  const warn = (line: number, message: string): void => {
-    diagnostics.push(makeDgmoError(line, message, 'warning'));
+  const warn = (line, message) => {
+    diagnostics.push(makeDgmoError(line, message, "warning"));
   };
-
-  // ── Build holiday set ───────────────────────────────────
-
   const holidaySet = buildHolidaySet(parsed.holidays);
-
-  // ── Determine project start ─────────────────────────────
-
-  let projectStart: Date;
+  let projectStart;
   if (parsed.options.start) {
     projectStart = parseGanttDate(parsed.options.start);
   } else {
-    // Relative timeline: use epoch-like reference (Day 1 = Jan 1, 2000)
-    projectStart = new Date(2000, 0, 1);
+    projectStart = new Date(2e3, 0, 1);
   }
-
-  // ── Resolve offset-based eras and markers to absolute dates ──
-
   result.eras = parsed.eras.map((era) => {
     if (era.offsetStart && era.offsetEnd) {
       const start = addGanttDuration(
         projectStart,
         era.offsetStart.duration,
         parsed.holidays,
-        new Set(),
+        /* @__PURE__ */ new Set(),
         era.offsetStart.direction
       );
       const end = addGanttDuration(
         projectStart,
         era.offsetEnd.duration,
         parsed.holidays,
-        new Set(),
+        /* @__PURE__ */ new Set(),
         era.offsetEnd.direction
       );
       return { ...era, startDate: formatDate(start), endDate: formatDate(end) };
     }
     return era;
   });
-
   result.markers = parsed.markers.map((m) => {
     if (m.offsetDate) {
       const d = addGanttDuration(
         projectStart,
         m.offsetDate.duration,
         parsed.holidays,
-        new Set(),
+        /* @__PURE__ */ new Set(),
         m.offsetDate.direction
       );
       return { ...m, date: formatDate(d) };
     }
     return m;
   });
-
-  // ── Sprint config ──────────────────────────────────────
-
-  const sprintOpts = parsed.options.sprintLength
-    ? { sprintLength: parsed.options.sprintLength }
-    : undefined;
-
-  // ── Dep offset storage ─────────────────────────────────
-
-  const depOffsetMap = new Map<string, Offset>();
-
-  // ── Collect all tasks ───────────────────────────────────
-
+  const sprintOpts = parsed.options.sprintLength ? { sprintLength: parsed.options.sprintLength } : void 0;
+  const depOffsetMap = /* @__PURE__ */ new Map();
   const allTasks = collectTasks(parsed.nodes);
   if (allTasks.length === 0) {
-    return result; // empty chart is valid
+    return result;
   }
-
-  // Build task map by ID
-  const taskMap = new Map<string, TaskNode>();
+  const taskMap = /* @__PURE__ */ new Map();
   for (const task of allTasks) {
     taskMap.set(task.id, {
       task,
       predecessors: [],
       startDate: null,
-      endDate: null,
+      endDate: null
     });
   }
-
-  // ── Build implicit sequential dependencies ──────────────
-  // New-mode charts have explicit graph structure (all deps from arrows).
-  // Legacy charts need implicit sequential deps between siblings.
-
-  if (parsed.syntaxMode === 'legacy') {
+  if (parsed.syntaxMode === "legacy") {
     buildImplicitDeps(parsed.nodes, taskMap);
   }
-
-  // ── Resolve explicit -> dependencies ────────────────────
-
   for (const task of allTasks) {
     for (const dep of task.dependencies) {
       const resolved = resolveTaskName(dep.targetName, allTasks);
       if (isResolverError(resolved)) {
-        warn(dep.lineNumber, `\`-> ${dep.targetName}\` — ${resolved.message}`);
+        warn(dep.lineNumber, `\`-> ${dep.targetName}\` \u2014 ${resolved.message}`);
         continue;
       }
-
-      // The dependency means: target starts after source
-      // In our model: target's predecessor is source
       const targetNode = taskMap.get(resolved.task.id);
       if (targetNode) {
-        // Check for redundant dependency (already a sequential predecessor)
         if (targetNode.predecessors.includes(task.id)) {
           warn(
             dep.lineNumber,
-            parsed.syntaxMode === 'new'
-              ? `Redundant dependency: "${dep.targetName}" already follows "${task.label}".`
-              : `Redundant dependency: "${dep.targetName}" already follows "${task.label}" sequentially. Did you mean to wrap groups in \`parallel\`?`
+            parsed.syntaxMode === "new" ? `Redundant dependency: "${dep.targetName}" already follows "${task.label}".` : `Redundant dependency: "${dep.targetName}" already follows "${task.label}" sequentially. Did you mean to wrap groups in \`parallel\`?`
           );
         } else {
           targetNode.predecessors.push(task.id);
-          // Store dep offset info — we need it during scheduling
           if (dep.offset) {
             depOffsetMap.set(`${task.id}->${resolved.task.id}`, dep.offset);
           }
@@ -186,25 +192,16 @@ export function calculateSchedule(parsed: ParsedGantt): ResolvedSchedule {
       }
     }
   }
-
-  // ── Topological sort with cycle detection ───────────────
-
   let sortedIds = topologicalSort(taskMap);
   if (!sortedIds) {
-    // Find cycle, warn, and break it by removing one explicit dep edge
     const cycle = findCycle(taskMap);
-    const cycleStr = cycle.map((id) => taskMap.get(id)!.task.label).join(' → ');
+    const cycleStr = cycle.map((id) => taskMap.get(id).task.label).join(" \u2192 ");
     warn(
       // Cycle is non-empty when topo sort failed; preserves prior crash-on-empty behavior.
-      taskMap.get(cycle[0]!)!.task.lineNumber,
+      taskMap.get(cycle[0]).task.lineNumber,
       `Circular dependency detected: ${cycleStr}. The cycle-creating dependency was dropped.`
     );
-
-    // Remove the last edge in the cycle to break it
-    // (prefer removing explicit -> deps over implicit sequential ones)
     breakCycle(cycle, taskMap, depOffsetMap);
-
-    // Retry — if still cyclic after breaking, keep breaking until resolved
     sortedIds = topologicalSort(taskMap);
     let safety = 10;
     while (!sortedIds && safety-- > 0) {
@@ -213,38 +210,24 @@ export function calculateSchedule(parsed: ParsedGantt): ResolvedSchedule {
       breakCycle(nextCycle, taskMap, depOffsetMap);
       sortedIds = topologicalSort(taskMap);
     }
-
     if (!sortedIds) {
-      // Truly unresolvable — fall back to task insertion order
       sortedIds = [...taskMap.keys()];
     }
   }
-
-  // ── Forward pass: resolve dates ─────────────────────────
-
   for (const taskId of sortedIds) {
-    const node = taskMap.get(taskId)!;
+    const node = taskMap.get(taskId);
     const task = node.task;
-
-    // Determine start date: max of all predecessors' end dates (+ dep offset)
-    let start: Date;
-
+    let start;
     if (task.explicitStart) {
-      // Explicit date anchor
       start = parseGanttDate(task.explicitStart);
     } else if (node.predecessors.length === 0) {
-      // No predecessors: starts at project start
       start = new Date(projectStart);
     } else {
-      // Universal max rule: start = max(all predecessor end dates + dep offset)
-      start = new Date(-8640000000000000);
+      start = /* @__PURE__ */ new Date(-864e13);
       for (const predId of node.predecessors) {
-        const predNode = taskMap.get(predId)!;
-        if (!predNode.endDate) continue; // shouldn't happen after topo sort
-
+        const predNode = taskMap.get(predId);
+        if (!predNode.endDate) continue;
         let predEnd = new Date(predNode.endDate);
-
-        // Apply dep offset if present
         const depOffset = depOffsetMap.get(`${predId}->${taskId}`);
         if (depOffset) {
           predEnd = addGanttDuration(
@@ -256,15 +239,12 @@ export function calculateSchedule(parsed: ParsedGantt): ResolvedSchedule {
             sprintOpts
           );
         }
-
         if (predEnd.getTime() > start.getTime()) {
           start = predEnd;
         }
       }
     }
-
-    // Apply group offset as floor constraint (new mode only)
-    if (parsed.syntaxMode === 'new' && task.groupPath.length > 0) {
+    if (parsed.syntaxMode === "new" && task.groupPath.length > 0) {
       const groupOffset = findGroupOffset(parsed.nodes, task.groupPath);
       if (groupOffset) {
         const groupFloor = addGanttDuration(
@@ -280,8 +260,6 @@ export function calculateSchedule(parsed: ParsedGantt): ResolvedSchedule {
         }
       }
     }
-
-    // Apply task-level offset (shifts start forward or backward)
     if (task.offset) {
       start = addGanttDuration(
         start,
@@ -305,32 +283,24 @@ export function calculateSchedule(parsed: ParsedGantt): ResolvedSchedule {
       );
       start = new Date(projectStart);
     }
-
-    // If explicit start (+ offset) conflicts with predecessors, warn but honor explicit
     if (task.explicitStart && node.predecessors.length > 0) {
-      let maxPredEnd = new Date(-8640000000000000);
+      let maxPredEnd = /* @__PURE__ */ new Date(-864e13);
       for (const predId of node.predecessors) {
-        const predNode = taskMap.get(predId)!;
-        if (
-          predNode.endDate &&
-          predNode.endDate.getTime() > maxPredEnd.getTime()
-        ) {
+        const predNode = taskMap.get(predId);
+        if (predNode.endDate && predNode.endDate.getTime() > maxPredEnd.getTime()) {
           maxPredEnd = predNode.endDate;
         }
       }
       if (start.getTime() < maxPredEnd.getTime()) {
         warn(
           task.lineNumber,
-          `Explicit date ${task.explicitStart}${task.offset ? ' (with offset)' : ''} overlaps with predecessor ending ${formatDate(maxPredEnd)}. Using explicit date.`
+          `Explicit date ${task.explicitStart}${task.offset ? " (with offset)" : ""} overlaps with predecessor ending ${formatDate(maxPredEnd)}. Using explicit date.`
         );
       }
     }
-
-    // Calculate end date
-    let end: Date;
+    let end;
     if (task.duration) {
       if (task.duration.amount === 0) {
-        // Milestone: zero duration, end = start
         end = new Date(start);
       } else {
         end = addGanttDuration(
@@ -343,32 +313,22 @@ export function calculateSchedule(parsed: ParsedGantt): ResolvedSchedule {
         );
       }
     } else {
-      // Explicit date task with no duration = milestone at that date
       end = new Date(start);
     }
-
     node.startDate = start;
     node.endDate = end;
   }
-
-  // ── Build resolved tasks ────────────────────────────────
-
-  // Critical path calculation (if enabled)
-  const criticalSet = parsed.options.criticalPath
-    ? computeCriticalPath(
-        sortedIds,
-        taskMap,
-        depOffsetMap,
-        parsed.holidays,
-        holidaySet,
-        sprintOpts
-      )
-    : new Set<string>();
-
-  // Cascading uncertainty: uncertain if task itself is uncertain OR any predecessor is
-  const uncertainSet = new Set<string>();
+  const criticalSet = parsed.options.criticalPath ? computeCriticalPath(
+    sortedIds,
+    taskMap,
+    depOffsetMap,
+    parsed.holidays,
+    holidaySet,
+    sprintOpts
+  ) : /* @__PURE__ */ new Set();
+  const uncertainSet = /* @__PURE__ */ new Set();
   for (const taskId of sortedIds) {
-    const node = taskMap.get(taskId)!;
+    const node = taskMap.get(taskId);
     if (node.task.uncertain) {
       uncertainSet.add(taskId);
     } else {
@@ -380,33 +340,23 @@ export function calculateSchedule(parsed: ParsedGantt): ResolvedSchedule {
       }
     }
   }
-
   for (const taskId of sortedIds) {
-    const node = taskMap.get(taskId)!;
+    const node = taskMap.get(taskId);
     result.tasks.push({
       task: node.task,
-      startDate: node.startDate!,
-      endDate: node.endDate!,
+      startDate: node.startDate,
+      endDate: node.endDate,
       isCriticalPath: criticalSet.has(taskId),
       isUncertain: uncertainSet.has(taskId),
-      isMilestone:
-        node.task.duration?.amount === 0 ||
-        (!node.task.duration && !node.task.explicitStart),
+      isMilestone: node.task.duration?.amount === 0 || !node.task.duration && !node.task.explicitStart,
       groupPath: node.task.groupPath.slice(),
-      effectiveMetadata: { ...node.task.metadata },
+      effectiveMetadata: { ...node.task.metadata }
     });
   }
-
-  // ── Build resolved groups ───────────────────────────────
-
   buildResolvedGroups(parsed.nodes, taskMap, result.groups, 0);
-
-  // ── Compute overall date range ──────────────────────────
-
   if (result.tasks.length > 0) {
-    // In-bounds by result.tasks.length > 0 guard.
-    let minDate = result.tasks[0]!.startDate;
-    let maxDate = result.tasks[0]!.endDate;
+    let minDate = result.tasks[0].startDate;
+    let maxDate = result.tasks[0].endDate;
     for (const t of result.tasks) {
       if (t.startDate.getTime() < minDate.getTime()) minDate = t.startDate;
       if (t.endDate.getTime() > maxDate.getTime()) maxDate = t.endDate;
@@ -414,72 +364,40 @@ export function calculateSchedule(parsed: ParsedGantt): ResolvedSchedule {
     result.startDate = minDate;
     result.endDate = maxDate;
   }
-
-  // ── Generate sprint bands ──────────────────────────────
-
-  if (
-    parsed.options.sprintMode &&
-    parsed.options.sprintLength &&
-    result.tasks.length > 0
-  ) {
+  if (parsed.options.sprintMode && parsed.options.sprintLength && result.tasks.length > 0) {
     result.sprints = generateSprintBands(
       parsed.options,
       result.startDate,
       result.endDate,
       projectStart
     );
-
-    // Extend chart range to include the last sprint's end so it doesn't clip
     if (result.sprints.length > 0) {
-      // In-bounds by result.sprints.length > 0 guard.
-      const lastSprintEnd = result.sprints[result.sprints.length - 1]!.endDate;
+      const lastSprintEnd = result.sprints[result.sprints.length - 1].endDate;
       if (lastSprintEnd.getTime() > result.endDate.getTime()) {
         result.endDate = lastSprintEnd;
       }
     }
   }
-
-  // ── Warnings ────────────────────────────────────────────
-
-  // Missing parallel warning: 2+ top-level groups without parallel wrapper (legacy only)
-  if (parsed.syntaxMode === 'legacy') {
-    const topLevelGroups = parsed.nodes.filter((n) => n.kind === 'group');
+  if (parsed.syntaxMode === "legacy") {
+    const topLevelGroups = parsed.nodes.filter((n) => n.kind === "group");
     if (topLevelGroups.length >= 2) {
       const names = topLevelGroups.map(
-        (g) => (g as GanttGroup & { kind: 'group' }).name
+        (g) => g.name
       );
       warn(
-        topLevelGroups[0]!.lineNumber,
-        `${names.join(' and ')} are sequential. Wrap in \`parallel\` if they should run concurrently.`
+        topLevelGroups[0].lineNumber,
+        `${names.join(" and ")} are sequential. Wrap in \`parallel\` if they should run concurrently.`
       );
     }
   }
-
   return result;
 }
-
-// ── Implicit dependency builder ─────────────────────────────
-
-/**
- * Walk the gantt tree and create implicit sequential dependencies.
- * - Siblings are sequential (each task depends on the previous sibling)
- * - Parallel block children all share the parent's predecessor
- * - Groups: children are sequential within the group
- */
-function buildImplicitDeps(
-  nodes: readonly GanttNode[],
-  taskMap: Map<string, TaskNode>
-): void {
+function buildImplicitDeps(nodes, taskMap) {
   walkChildren(nodes, null);
-
-  function walkChildren(
-    children: readonly GanttNode[],
-    afterTaskId: string | null
-  ) {
+  function walkChildren(children, afterTaskId) {
     let prevTaskId = afterTaskId;
-
     for (const node of children) {
-      if (node.kind === 'task') {
+      if (node.kind === "task") {
         if (prevTaskId) {
           const taskNode = taskMap.get(node.id);
           if (taskNode && !taskNode.predecessors.includes(prevTaskId)) {
@@ -487,17 +405,13 @@ function buildImplicitDeps(
           }
         }
         prevTaskId = node.id;
-      } else if (node.kind === 'group') {
-        // Walk group children sequentially, starting after prevTaskId
+      } else if (node.kind === "group") {
         const lastId = walkSequential(node.children, prevTaskId);
         if (lastId) prevTaskId = lastId;
-      } else if (node.kind === 'parallel') {
-        // All parallel children start after prevTaskId
-        // The parallel block "ends" when all children end
-        // We need to find the last task in each branch
-        const branchLastIds: string[] = [];
+      } else if (node.kind === "parallel") {
+        const branchLastIds = [];
         for (const child of node.children) {
-          if (child.kind === 'task') {
+          if (child.kind === "task") {
             if (prevTaskId) {
               const taskNode = taskMap.get(child.id);
               if (taskNode && !taskNode.predecessors.includes(prevTaskId)) {
@@ -505,8 +419,7 @@ function buildImplicitDeps(
               }
             }
             branchLastIds.push(child.id);
-          } else if (child.kind === 'group') {
-            // First task in group depends on prevTaskId
+          } else if (child.kind === "group") {
             const firstId = findFirstTask(child.children);
             if (firstId && prevTaskId) {
               const taskNode = taskMap.get(firstId);
@@ -514,24 +427,20 @@ function buildImplicitDeps(
                 taskNode.predecessors.push(prevTaskId);
               }
             }
-            // Walk sequentially within the group
-            walkSequential(child.children, null); // internal deps only
+            walkSequential(child.children, null);
             const lastId = findLastTask(child.children);
             if (lastId) branchLastIds.push(lastId);
-          } else if (child.kind === 'parallel') {
-            // Nested parallel — recurse
+          } else if (child.kind === "parallel") {
             walkChildren([child], prevTaskId);
             const lastId = findLastTask(child.children);
             if (lastId) branchLastIds.push(lastId);
           }
         }
-        // After parallel, next sibling depends on ALL branch ends
         if (branchLastIds.length > 0) {
           prevTaskId = null;
           const nextIdx = children.indexOf(node) + 1;
           if (nextIdx < children.length) {
-            // In-bounds by nextIdx < children.length guard.
-            const nextFirstId = findFirstTask([children[nextIdx]!]);
+            const nextFirstId = findFirstTask([children[nextIdx]]);
             if (nextFirstId) {
               const nextNode = taskMap.get(nextFirstId);
               if (nextNode) {
@@ -547,14 +456,10 @@ function buildImplicitDeps(
       }
     }
   }
-
-  function walkSequential(
-    children: readonly GanttNode[],
-    afterTaskId: string | null
-  ): string | null {
+  function walkSequential(children, afterTaskId) {
     let prevTaskId = afterTaskId;
     for (const node of children) {
-      if (node.kind === 'task') {
+      if (node.kind === "task") {
         if (prevTaskId) {
           const taskNode = taskMap.get(node.id);
           if (taskNode && !taskNode.predecessors.includes(prevTaskId)) {
@@ -562,10 +467,10 @@ function buildImplicitDeps(
           }
         }
         prevTaskId = node.id;
-      } else if (node.kind === 'group') {
+      } else if (node.kind === "group") {
         const lastId = walkSequential(node.children, prevTaskId);
         if (lastId) prevTaskId = lastId;
-      } else if (node.kind === 'parallel') {
+      } else if (node.kind === "parallel") {
         walkChildren([node], prevTaskId);
         const lastId = findLastTask(node.children);
         if (lastId) prevTaskId = lastId;
@@ -574,39 +479,30 @@ function buildImplicitDeps(
     return prevTaskId;
   }
 }
-
-/** Find the first task ID in a tree (depth-first). */
-function findFirstTask(nodes: readonly GanttNode[]): string | null {
+function findFirstTask(nodes) {
   for (const node of nodes) {
-    if (node.kind === 'task') return node.id;
-    if (node.kind === 'group' || node.kind === 'parallel') {
+    if (node.kind === "task") return node.id;
+    if (node.kind === "group" || node.kind === "parallel") {
       const found = findFirstTask(node.children);
       if (found) return found;
     }
   }
   return null;
 }
-
-/** Find the last task ID in a tree (depth-first, last branch). */
-function findLastTask(nodes: readonly GanttNode[]): string | null {
+function findLastTask(nodes) {
   for (let i = nodes.length - 1; i >= 0; i--) {
-    // In-bounds by reverse loop guard (i ranges over valid indices).
-    const node = nodes[i]!;
-    if (node.kind === 'task') return node.id;
-    if (node.kind === 'group' || node.kind === 'parallel') {
+    const node = nodes[i];
+    if (node.kind === "task") return node.id;
+    if (node.kind === "group" || node.kind === "parallel") {
       const found = findLastTask(node.children);
       if (found) return found;
     }
   }
   return null;
 }
-
-// ── Topological sort ────────────────────────────────────────
-
-function topologicalSort(taskMap: Map<string, TaskNode>): string[] | null {
-  const inDegree = new Map<string, number>();
-  const adjacency = new Map<string, string[]>();
-
+function topologicalSort(taskMap) {
+  const inDegree = /* @__PURE__ */ new Map();
+  const adjacency = /* @__PURE__ */ new Map();
   for (const [id, node] of taskMap) {
     inDegree.set(id, node.predecessors.length);
     for (const pred of node.predecessors) {
@@ -615,15 +511,13 @@ function topologicalSort(taskMap: Map<string, TaskNode>): string[] | null {
       adjacency.set(pred, adj);
     }
   }
-
-  const queue: string[] = [];
+  const queue = [];
   for (const [id, degree] of inDegree) {
     if (degree === 0) queue.push(id);
   }
-
-  const sorted: string[] = [];
+  const sorted = [];
   while (queue.length > 0) {
-    const current = queue.shift()!;
+    const current = queue.shift();
     sorted.push(current);
     for (const succ of adjacency.get(current) ?? []) {
       const newDegree = (inDegree.get(succ) ?? 1) - 1;
@@ -631,15 +525,12 @@ function topologicalSort(taskMap: Map<string, TaskNode>): string[] | null {
       if (newDegree === 0) queue.push(succ);
     }
   }
-
   return sorted.length === taskMap.size ? sorted : null;
 }
-
-function findCycle(taskMap: Map<string, TaskNode>): string[] {
-  const visited = new Set<string>();
-  const onStack = new Set<string>();
-  const parent = new Map<string, string>();
-
+function findCycle(taskMap) {
+  const visited = /* @__PURE__ */ new Set();
+  const onStack = /* @__PURE__ */ new Set();
+  const parent = /* @__PURE__ */ new Map();
   for (const id of taskMap.keys()) {
     if (!visited.has(id)) {
       const cycle = dfs(id);
@@ -647,18 +538,15 @@ function findCycle(taskMap: Map<string, TaskNode>): string[] {
     }
   }
   return [];
-
-  function dfs(id: string): string[] | null {
+  function dfs(id) {
     visited.add(id);
     onStack.add(id);
-
-    const successors: string[] = [];
+    const successors = [];
     for (const [otherId, otherNode] of taskMap) {
       if (otherNode.predecessors.includes(id)) {
         successors.push(otherId);
       }
     }
-
     for (const succ of successors) {
       if (!visited.has(succ)) {
         parent.set(succ, id);
@@ -669,33 +557,20 @@ function findCycle(taskMap: Map<string, TaskNode>): string[] {
         let current = id;
         while (current !== succ) {
           cycle.push(current);
-          current = parent.get(current)!;
+          current = parent.get(current);
         }
         cycle.push(succ);
         return cycle.reverse();
       }
     }
-
     onStack.delete(id);
     return null;
   }
 }
-
-/**
- * Break a cycle by removing the last edge. The cycle array is [A, B, ..., A]
- * (starts and ends with the same node). We remove A's predecessor edge to
- * the penultimate node, which breaks the cycle.
- */
-function breakCycle(
-  cycle: string[],
-  taskMap: Map<string, TaskNode>,
-  depOffsetMap: Map<string, Offset>
-): void {
-  if (cycle.length < 3) return; // need at least [A, B, A]
-  // Remove the edge from second-to-last → first (i.e. the edge that closes the cycle)
-  // In-bounds by cycle.length >= 3 guard above.
-  const fromId = cycle[cycle.length - 2]!;
-  const toId = cycle[0]!;
+function breakCycle(cycle, taskMap, depOffsetMap) {
+  if (cycle.length < 3) return;
+  const fromId = cycle[cycle.length - 2];
+  const toId = cycle[0];
   const toNode = taskMap.get(toId);
   if (toNode) {
     const idx = toNode.predecessors.indexOf(fromId);
@@ -705,31 +580,18 @@ function breakCycle(
     }
   }
 }
-
-// ── Critical path ───────────────────────────────────────────
-
-function computeCriticalPath(
-  sortedIds: string[],
-  taskMap: Map<string, TaskNode>,
-  depOffsetMap: Map<string, Offset>,
-  holidays: GanttHolidays,
-  holidaySet: Set<string>,
-  sprintOpts?: { sprintLength?: Duration }
-): Set<string> {
-  if (sortedIds.length === 0) return new Set();
-
-  const latestEnd = new Map<string, number>();
-  const latestStart = new Map<string, number>();
-
+function computeCriticalPath(sortedIds, taskMap, depOffsetMap, holidays, holidaySet, sprintOpts) {
+  if (sortedIds.length === 0) return /* @__PURE__ */ new Set();
+  const latestEnd = /* @__PURE__ */ new Map();
+  const latestStart = /* @__PURE__ */ new Map();
   let projectEnd = 0;
   for (const id of sortedIds) {
-    const node = taskMap.get(id)!;
+    const node = taskMap.get(id);
     if (node.endDate && node.endDate.getTime() > projectEnd) {
       projectEnd = node.endDate.getTime();
     }
   }
-
-  const successors = new Map<string, string[]>();
+  const successors = /* @__PURE__ */ new Map();
   for (const [id, node] of taskMap) {
     for (const pred of node.predecessors) {
       const succs = successors.get(pred) ?? [];
@@ -737,26 +599,20 @@ function computeCriticalPath(
       successors.set(pred, succs);
     }
   }
-
-  // Backward pass (reverse order)
   for (let i = sortedIds.length - 1; i >= 0; i--) {
-    // In-bounds by loop guard.
-    const id = sortedIds[i]!;
-    const node = taskMap.get(id)!;
+    const id = sortedIds[i];
+    const node = taskMap.get(id);
     const succs = successors.get(id) ?? [];
-
     if (succs.length === 0) {
       latestEnd.set(id, projectEnd);
     } else {
       let minVal = Infinity;
       for (const succId of succs) {
         let succLS = latestStart.get(succId);
-        if (succLS === undefined) continue;
-
-        // Reverse successor's task-level offset
-        const succTask = taskMap.get(succId)!.task;
+        if (succLS === void 0) continue;
+        const succTask = taskMap.get(succId).task;
         if (succTask.offset) {
-          const reverseDir = (succTask.offset.direction * -1) as 1 | -1;
+          const reverseDir = succTask.offset.direction * -1;
           const adjusted = addGanttDuration(
             new Date(succLS),
             succTask.offset.duration,
@@ -767,11 +623,9 @@ function computeCriticalPath(
           );
           succLS = adjusted.getTime();
         }
-
-        // Reverse dep offset
         const depOffset = depOffsetMap.get(`${id}->${succId}`);
         if (depOffset) {
-          const reverseDir = (depOffset.direction * -1) as 1 | -1;
+          const reverseDir = depOffset.direction * -1;
           const adjusted = addGanttDuration(
             new Date(succLS),
             depOffset.duration,
@@ -782,62 +636,48 @@ function computeCriticalPath(
           );
           succLS = adjusted.getTime();
         }
-
         if (succLS < minVal) {
           minVal = succLS;
         }
       }
       latestEnd.set(id, minVal);
     }
-
-    const duration = node.endDate!.getTime() - node.startDate!.getTime();
-    latestStart.set(id, latestEnd.get(id)! - duration);
+    const duration = node.endDate.getTime() - node.startDate.getTime();
+    latestStart.set(id, latestEnd.get(id) - duration);
   }
-
-  const critical = new Set<string>();
+  const critical = /* @__PURE__ */ new Set();
   for (const id of sortedIds) {
-    const node = taskMap.get(id)!;
-    const slack = (latestStart.get(id) ?? 0) - node.startDate!.getTime();
-    if (Math.abs(slack) < 86400000) {
+    const node = taskMap.get(id);
+    const slack = (latestStart.get(id) ?? 0) - node.startDate.getTime();
+    if (Math.abs(slack) < 864e5) {
       critical.add(id);
     }
   }
-
   return critical;
 }
-
-// ── Resolved groups builder ─────────────────────────────────
-
-function buildResolvedGroups(
-  nodes: readonly GanttNode[],
-  taskMap: Map<string, TaskNode>,
-  groups: ResolvedGroup[],
-  depth: number
-): void {
+function buildResolvedGroups(nodes, taskMap, groups, depth) {
   for (const node of nodes) {
-    if (node.kind === 'group') {
+    if (node.kind === "group") {
       const childTasks = collectTasks(node.children);
       if (childTasks.length === 0) {
         groups.push({
           name: node.name,
           color: node.color,
           metadata: node.metadata,
-          startDate: new Date(),
-          endDate: new Date(),
+          startDate: /* @__PURE__ */ new Date(),
+          endDate: /* @__PURE__ */ new Date(),
           progress: null,
           lineNumber: node.lineNumber,
           depth,
-          ...(node.collapsed && { collapsed: true }),
+          ...node.collapsed && { collapsed: true }
         });
         continue;
       }
-
       let minStart = Infinity;
       let maxEnd = -Infinity;
       let totalProgress = 0;
       let totalDuration = 0;
       let hasProgress = false;
-
       for (const task of childTasks) {
         const resolved = taskMap.get(task.id);
         if (!resolved?.startDate || !resolved?.endDate) continue;
@@ -852,123 +692,84 @@ function buildResolvedGroups(
           hasProgress = true;
         }
       }
-
       groups.push({
         name: node.name,
         color: node.color,
         metadata: node.metadata,
         startDate: new Date(minStart === Infinity ? 0 : minStart),
         endDate: new Date(maxEnd === -Infinity ? 0 : maxEnd),
-        progress:
-          hasProgress && totalDuration > 0
-            ? totalProgress / totalDuration
-            : null,
+        progress: hasProgress && totalDuration > 0 ? totalProgress / totalDuration : null,
         lineNumber: node.lineNumber,
         depth,
-        ...(node.collapsed && { collapsed: true }),
+        ...node.collapsed && { collapsed: true }
       });
-
       buildResolvedGroups(node.children, taskMap, groups, depth + 1);
-    } else if (node.kind === 'parallel') {
+    } else if (node.kind === "parallel") {
       buildResolvedGroups(node.children, taskMap, groups, depth);
     }
   }
 }
-
-// ── Sprint band generation ──────────────────────────────────
-
-function generateSprintBands(
-  options: GanttOptions,
-  chartStart: Date,
-  chartEnd: Date,
-  projectStart: Date
-): ResolvedSprint[] {
-  const sprintLength = options.sprintLength!;
+function generateSprintBands(options, chartStart, chartEnd, projectStart) {
+  const sprintLength = options.sprintLength;
   const sprintNumber = options.sprintNumber ?? 1;
-
-  // Determine anchor date: sprint-start or chart start or today
-  let anchorDate: Date;
+  let anchorDate;
   if (options.sprintStart) {
-    anchorDate = new Date(options.sprintStart + 'T00:00:00');
+    anchorDate = /* @__PURE__ */ new Date(options.sprintStart + "T00:00:00");
   } else if (options.start) {
     anchorDate = new Date(projectStart);
   } else {
-    const now = new Date();
+    const now = /* @__PURE__ */ new Date();
     anchorDate = new Date(now.getFullYear(), now.getMonth(), now.getDate());
   }
   anchorDate.setHours(0, 0, 0, 0);
-
-  // Sprint length in whole days (parser ensures only d/w with integer day result)
   const sprintDays = Math.round(
-    sprintLength.amount * (sprintLength.unit === 'w' ? 7 : 1)
+    sprintLength.amount * (sprintLength.unit === "w" ? 7 : 1)
   );
-  if (sprintDays <= 0) return []; // defensive guard
-
-  // Bail if anchor date is invalid (e.g. sprint-start 2026-13-45)
+  if (sprintDays <= 0) return [];
   if (Number.isNaN(anchorDate.getTime())) return [];
-
-  // Calculate which sprint chartStart falls in, relative to the anchor
   const chartStartTime = new Date(chartStart);
   chartStartTime.setHours(0, 0, 0, 0);
   const chartEndTime = new Date(chartEnd);
   chartEndTime.setHours(0, 0, 0, 0);
-
-  const msPerDay = 86400000;
+  const msPerDay = 864e5;
   const dayDiff = Math.floor(
     (chartStartTime.getTime() - anchorDate.getTime()) / msPerDay
   );
-  // Floor division: which sprint index (from anchor) does chartStart fall in?
   const startSprintIndex = Math.floor(dayDiff / sprintDays);
-
-  const sprints: ResolvedSprint[] = [];
-  const maxSprints = 1000; // safety guard against infinite loops
-
-  // Generate sprints that overlap with [chartStart, chartEnd]
-  // Sprint at index i (relative to anchor) has number: sprintNumber + i
+  const sprints = [];
+  const maxSprints = 1e3;
   for (let i = startSprintIndex; sprints.length < maxSprints; i++) {
     const sprintStartDate = new Date(anchorDate);
     sprintStartDate.setDate(sprintStartDate.getDate() + i * sprintDays);
     sprintStartDate.setHours(0, 0, 0, 0);
-
     const sprintEndDate = new Date(sprintStartDate);
     sprintEndDate.setDate(sprintEndDate.getDate() + sprintDays);
     sprintEndDate.setHours(0, 0, 0, 0);
-
-    // Stop when sprint start is past chart end
     if (sprintStartDate.getTime() >= chartEndTime.getTime() + msPerDay) break;
-
     sprints.push({
       number: sprintNumber + i,
       startDate: sprintStartDate,
-      endDate: sprintEndDate,
+      endDate: sprintEndDate
     });
   }
-
   return sprints;
 }
-
-// ── Utility ─────────────────────────────────────────────────
-
-function formatDate(d: Date): string {
+function formatDate(d) {
   const y = d.getFullYear();
-  const m = String(d.getMonth() + 1).padStart(2, '0');
-  const day = String(d.getDate()).padStart(2, '0');
+  const m = String(d.getMonth() + 1).padStart(2, "0");
+  const day = String(d.getDate()).padStart(2, "0");
   return `${y}-${m}-${day}`;
 }
-
-function findGroupOffset(
-  nodes: readonly GanttNode[],
-  groupPath: readonly string[]
-): Offset | null {
+function findGroupOffset(nodes, groupPath) {
   if (groupPath.length === 0) return null;
-  const groupName = groupPath[groupPath.length - 1]!;
-  function search(children: readonly GanttNode[]): Offset | null {
+  const groupName = groupPath[groupPath.length - 1];
+  function search(children) {
     for (const node of children) {
-      if (node.kind === 'group') {
+      if (node.kind === "group") {
         if (node.name === groupName && node.offset) return node.offset;
         const found = search(node.children);
         if (found) return found;
-      } else if (node.kind === 'parallel') {
+      } else if (node.kind === "parallel") {
         const found = search(node.children);
         if (found) return found;
       }
@@ -977,3 +778,10 @@ function findGroupOffset(
   }
   return search(nodes);
 }
+
+export {
+  collectTasks,
+  resolveTaskName,
+  calculateSchedule
+};
+//# sourceMappingURL=chunk-Z72XRXD4.js.map