@diagrammo/dgmo 0.45.0 → 0.47.0

package/dist/chunk-RTLBSQ3G.js

@@ -0,0 +1,1155 @@
+import {
+  formatLocalISODate,
+  parseLocalISODate
+} from "./chunk-L3UHP6TD.js";
+import {
+  parseDuration
+} from "./chunk-USZW2HHU.js";
+import {
+  AUTO_TAG_COLOR_SENTINEL,
+  finalizeAutoTagColors,
+  injectDefaultTagMetadata,
+  matchTagBlockHeading,
+  stripDefaultModifier,
+  tagAttrKey,
+  validateTagGroupNames,
+  validateTagValues
+} from "./chunk-QLCCJEJI.js";
+import {
+  normalizeName
+} from "./chunk-NOTA6TEI.js";
+import {
+  PERT_REGISTRY,
+  extractColor,
+  measureIndent,
+  splitNameAndMeta,
+  warnUnknownMetaKeys,
+  withTagAliases
+} from "./chunk-Y3J7VR52.js";
+import {
+  emit,
+  makeDgmoError,
+  suggest
+} from "./chunk-CXK4DZH3.js";
+
+// src/pert/diagnostics.ts
+var PERT_DX = {
+  BOTH_ANCHORS: {
+    code: "E_PERT_BOTH_ANCHORS",
+    severity: "error",
+    // Runtime: error() @ parser.ts ~1508
+    chartType: "pert",
+    title: "Both start-date and end-date set",
+    // Message interpolates an optional `priorRef` suffix referencing the
+    // first anchor's kind + line. Builder tolerates `{}` (suffix omitted).
+    message: (p) => {
+      const kind = p.firstAnchorKey;
+      const line = p.firstAnchorLine;
+      const priorRef = kind && line ? ` Conflicts with \`${String(kind)}\` declared on line ${String(line)}.` : "";
+      return `Specify \`start-date\` or \`end-date\`, not both. Use one anchor \u2014 both directives are discarded; re-author one to recover.${priorRef}`;
+    },
+    hint: "Pick a single anchor: either `start-date` (forward) or `end-date` (backward).",
+    example: "pert\nstart-date 2026-06-01\nend-date 2026-09-15\nA 1 2 3\n"
+  },
+  END_DATE_NOW: {
+    code: "E_PERT_END_DATE_NOW",
+    severity: "error",
+    // Runtime: error() @ parser.ts ~1530
+    chartType: "pert",
+    title: "`end-date now` not allowed",
+    message: "`end-date` requires an explicit YYYY-MM-DD; `now` is only valid for `start-date`.",
+    hint: "Give `end-date` a literal date, or use `start-date now` if you want today.",
+    example: "pert\nend-date now\nA 1 2 3\n"
+  },
+  INVALID_DATE: {
+    code: "E_PERT_INVALID_DATE",
+    severity: "error",
+    // Runtime: error() @ parser.ts ~1519 and ~1545
+    chartType: "pert",
+    title: "Invalid anchor date",
+    // Emitted from TWO sites with different wording:
+    //  (a) empty value @ ~1519:  "`${key}` requires a full date (YYYY-MM-DD), got '${value}'."
+    //  (b) unparseable  @ ~1545:  "Invalid date '${trimmed}' for ${key}. Expected YYYY-MM-DD."
+    // The builder reproduces BOTH: pass `empty: true` + `value`/`key` for
+    // variant (a); pass `trimmed`/`key` for variant (b). The `{}` default
+    // shows variant (b)'s representative wording.
+    message: (p) => {
+      const key = p.key ?? "start-date";
+      if (p.empty) {
+        return `\`${String(key)}\` requires a full date (YYYY-MM-DD), got '${String(p.value ?? "")}'.`;
+      }
+      const date = p.trimmed ?? p.value;
+      return date ? `Invalid date '${String(date)}' for ${String(key)}. Expected YYYY-MM-DD.` : `Invalid date for ${String(key)}. Expected YYYY-MM-DD.`;
+    },
+    hint: "Use a calendar-valid ISO date, e.g. `2026-06-01` (dashes, not slashes).",
+    example: "pert\nstart-date 2026-13-99\nA 1 2 3\n"
+  },
+  NEAR_DIRECTIVE: {
+    code: "E_PERT_NEAR_DIRECTIVE",
+    severity: "error",
+    // Runtime: error() @ parser.ts ~938
+    chartType: "pert",
+    title: "Near-miss directive typo",
+    // Interpolates the mistyped head + the suggested canonical directive.
+    message: (p) => {
+      const head = p.head ?? "start";
+      const canonical = p.canonical ?? "start-date";
+      return `Unknown directive '${String(head)}'. Did you mean '${String(canonical)}'?`;
+    },
+    hint: "Use the full directive name (`start-date`, `end-date`, `default-confidence`, `time-unit`).",
+    example: "pert\nstart 2026-06-01\nA 1 2 3\n"
+  },
+  BD_WITH_ANCHOR: {
+    code: "W_PERT_BD_WITH_ANCHOR",
+    severity: "warning",
+    // Runtime: warn() @ parser.ts ~1024
+    chartType: "pert",
+    title: "Business days with date anchor",
+    message: "`bd` (business days) is treated as calendar days when `start-date`/`end-date` is set. For business-day scheduling with weekend/holiday awareness, use Gantt.",
+    hint: "Drop the date anchor, or switch to Gantt for weekend/holiday-aware scheduling.",
+    example: "pert\ntime-unit bd\nstart-date 2026-06-01\nA 1 2 3\n"
+  },
+  SUBDAY_WITH_ANCHOR: {
+    code: "W_PERT_SUBDAY_WITH_ANCHOR",
+    severity: "warning",
+    // Runtime: warn() @ parser.ts ~1030
+    chartType: "pert",
+    title: "Sub-day time-unit with date anchor",
+    message: "Date display rounds to whole days; sub-day `time-unit` ('h'/'min') will lose precision when `start-date`/`end-date` is set. For honest output use `time-unit d`.",
+    hint: "Use `time-unit d` when anchoring to dates, or remove the anchor.",
+    example: "pert\ntime-unit h\nstart-date 2026-06-01\nA 1 2 3\n"
+  }
+};
+var PERT_DIAGNOSTICS = Object.values(PERT_DX);
+
+// src/pert/parser.ts
+var DIRECTIVE_KEYS = /* @__PURE__ */ new Set([
+  "time-unit",
+  "default-confidence",
+  "direction",
+  "node-detail",
+  "no-analysis",
+  "trials",
+  "seed",
+  "scrubber-trials",
+  "start-date",
+  "end-date",
+  "no-title",
+  "solid-fill",
+  "sprint-length",
+  "sprint-number",
+  "sprint-start",
+  "active-tag"
+]);
+var RESERVED_PIPE_KEYS = /* @__PURE__ */ new Set([
+  "confidence",
+  "collapsed"
+]);
+var NEAR_DIRECTIVE_HINTS = [
+  {
+    stem: "confidence",
+    canonical: "default-confidence",
+    matches: /^(low|medium|high)$/i
+  },
+  {
+    stem: "start",
+    canonical: "start-date",
+    matches: /^(\d{4}-\d{2}-\d{2}|now)$/i
+  },
+  {
+    stem: "end",
+    canonical: "end-date",
+    matches: /^\d{4}-\d{2}-\d{2}$/
+  },
+  {
+    stem: "time",
+    canonical: "time-unit",
+    matches: /^(d|w|m|q|y|h|min|bd|s)$/i
+  }
+];
+var GROUP_HEADER_RE = /^\[([^\]]+)\]\s*(.*)$/;
+var ARROW_RE = /^->\s*(.+?)\s*$/;
+var INDENTED_META_RE = /^([A-Za-z][\w-]*)\s*:\s*(.+)$/;
+var LABELED_ARROW_RE = /^-(.+?)->\s*(.+?)\s*$/;
+function parseEdgeLabel(label, defaultUnit) {
+  const trimmed = label.trim();
+  if (trimmed === "") return null;
+  const m = trimmed.match(/^(fs|ss|ff|sf)?([+-]?\d+(?:\.\d+)?)?\s*([a-z]+)?$/i);
+  if (!m) return null;
+  const typeRaw = m[1];
+  const numRaw = m[2];
+  const unitRaw = m[3];
+  if (!typeRaw && !numRaw) return null;
+  if (unitRaw && !numRaw) return null;
+  const type = typeRaw ? typeRaw.toUpperCase() : "FS";
+  let lag = null;
+  if (numRaw) {
+    const amount = parseFloat(numRaw);
+    if (amount !== 0) {
+      const unit = unitRaw ? unitRaw.toLowerCase() : defaultUnit;
+      if (!isValidDurationUnit(unit)) return null;
+      lag = { amount, unit };
+    }
+  }
+  return { type, lag };
+}
+var VALID_DURATION_UNITS = /* @__PURE__ */ new Set([
+  "min",
+  "h",
+  "d",
+  "bd",
+  "w",
+  "m",
+  "q",
+  "y",
+  "s"
+]);
+function isValidDurationUnit(u) {
+  return VALID_DURATION_UNITS.has(u);
+}
+var ALIAS_SUFFIX_RE = /\s+as\s+([A-Za-z][A-Za-z0-9_]{0,11})\s*$/;
+var ESTIMATE_TOKEN_RE = /^(\d+(?:\.\d+)?)(min|bd|d|w|m|q|y|h|s)?$/;
+var DEFAULT_OPTIONS = {
+  timeUnit: "d",
+  direction: "LR",
+  nodeDetail: "compact",
+  confidence: "medium",
+  trials: -1,
+  seed: -1,
+  scrubberTrials: 300,
+  anchor: null,
+  sprintLength: null,
+  sprintNumber: null,
+  sprintStart: null,
+  sprintMode: null,
+  today: ""
+};
+function deriveTrials(activityCount) {
+  const t = Math.round(1e3 * Math.sqrt(Math.max(activityCount, 1)));
+  return Math.max(5e3, Math.min(2e4, t));
+}
+function deriveSeed(s) {
+  let h = 2166136261;
+  for (let i = 0; i < s.length; i++) {
+    h ^= s.charCodeAt(i);
+    h = Math.imul(h, 16777619);
+  }
+  return h >>> 1;
+}
+function stripTrailingComment(line) {
+  const m = line.match(/^(.*?)\s+#.*$/);
+  return (m ? m[1] : line).trimEnd();
+}
+function peelAlias(text) {
+  const trimmed = text.trim();
+  const m = trimmed.match(ALIAS_SUFFIX_RE);
+  if (!m) return { head: trimmed };
+  const alias = m[1];
+  return {
+    head: trimmed.slice(0, m.index).trim(),
+    ...alias !== void 0 && { alias }
+  };
+}
+function tokenizeActivityLine(line, diagnostics, lineNumber, metaAliasMap) {
+  let body = line;
+  let pipeMetadata;
+  if (metaAliasMap !== void 0) {
+    const registry = withTagAliases(
+      PERT_REGISTRY,
+      new Set(metaAliasMap.keys())
+    );
+    const split = splitNameAndMeta(
+      body,
+      registry,
+      metaAliasMap,
+      void 0,
+      diagnostics,
+      lineNumber
+    );
+    if (diagnostics && lineNumber != null) {
+      warnUnknownMetaKeys(
+        split.meta,
+        registry,
+        (msg) => diagnostics.push(makeDgmoError(lineNumber, msg, "warning")),
+        split.name
+      );
+    }
+    if (Object.keys(split.meta).length > 0) {
+      let restored = split.name;
+      if (split.color) restored = `${restored} ${split.color}`;
+      if (split.alias) restored = `${restored} as ${split.alias}`;
+      body = restored;
+      const merged = Object.entries(split.meta).map(([k, v]) => `${k}: ${v}`).join(", ");
+      pipeMetadata = pipeMetadata ? `${pipeMetadata}, ${merged}` : merged;
+    }
+  }
+  const peeled = peelAlias(body);
+  const rawTokens = peeled.head.split(/[,\s]+/).map((t) => t.trim()).filter(Boolean);
+  let firstNumIdx = -1;
+  for (let i = 0; i < rawTokens.length; i++) {
+    if (ESTIMATE_TOKEN_RE.test(rawTokens[i])) {
+      firstNumIdx = i;
+      break;
+    }
+  }
+  let name;
+  let durationTokens;
+  if (firstNumIdx === -1) {
+    name = peeled.head;
+    durationTokens = [];
+  } else {
+    name = rawTokens.slice(0, firstNumIdx).join(" ").trim();
+    durationTokens = rawTokens.slice(firstNumIdx);
+  }
+  return {
+    name,
+    durationTokens,
+    ...peeled.alias !== void 0 && { alias: peeled.alias },
+    ...pipeMetadata !== void 0 && { pipeMetadata }
+  };
+}
+function parseEstimateToken(token, defaultUnit) {
+  const m = token.match(ESTIMATE_TOKEN_RE);
+  if (!m) return null;
+  const amount = parseFloat(m[1]);
+  if (!Number.isFinite(amount)) return null;
+  const unit = m[2] ?? defaultUnit;
+  if (unit === "s") {
+    return { amount, unit: defaultUnit };
+  }
+  const round = parseDuration(`${amount}${unit}`);
+  return round ?? { amount, unit };
+}
+function buildEstimate(tokens, defaultUnit, diagnose) {
+  if (tokens.length === 0) return null;
+  if (tokens.length === 2) {
+    diagnose(
+      `Expected 1 (M) or 3 (O M P) durations; got 2 (${tokens.join(" ")}). Did you mean '${tokens[0]} ${(parseFloat(tokens[0]) + parseFloat(tokens[1])) / 2} ${tokens[1]}'?`
+    );
+    return null;
+  }
+  if (tokens.length !== 1 && tokens.length !== 3) {
+    diagnose(
+      `Expected 1 (M) or 3 (O M P) durations; got ${tokens.length} (${tokens.join(" ")}).`
+    );
+    return null;
+  }
+  const parsed = [];
+  for (const t of tokens) {
+    const dur = parseEstimateToken(t, defaultUnit);
+    if (!dur) {
+      diagnose(`Invalid duration token '${t}'.`);
+      return null;
+    }
+    if (dur.amount < 0) {
+      diagnose(`Duration must be \u2265 0; got '${t}'.`);
+      return null;
+    }
+    parsed.push(dur);
+  }
+  if (parsed.length === 1) {
+    return { o: parsed[0], m: parsed[0], p: parsed[0], mOnly: true };
+  }
+  const [o, m, p] = parsed;
+  const sameUnit = o.unit === m.unit && m.unit === p.unit;
+  if (sameUnit && !(o.amount <= m.amount && m.amount <= p.amount)) {
+    diagnose(
+      `Invalid estimate (${tokens.join(" ")}): expected O \u2264 M \u2264 P. Did you mean (${[o.amount, m.amount, p.amount].sort((a, b) => a - b).join(" ")})?`
+    );
+    return null;
+  }
+  return { o, m, p, mOnly: false };
+}
+function parsePipeMetadata(raw, aliasMap = /* @__PURE__ */ new Map()) {
+  const out = {};
+  for (const part of raw.split(",")) {
+    const trimmed = part.trim();
+    if (!trimmed) continue;
+    const idx = trimmed.indexOf(":");
+    if (idx <= 0) continue;
+    const rawKey = trimmed.slice(0, idx).trim().toLowerCase();
+    const key = aliasMap.get(rawKey) ?? rawKey;
+    const value = trimmed.slice(idx + 1).trim();
+    out[key] = value;
+  }
+  return out;
+}
+function parsePert(content, parseOpts = {}) {
+  const lines = content.split("\n");
+  const diagnostics = [];
+  const error = (line, msg, code) => {
+    diagnostics.push(makeDgmoError(line, msg, "error", code));
+  };
+  const warn = (line, msg, code) => {
+    diagnostics.push(makeDgmoError(line, msg, "warning", code));
+  };
+  const today = formatLocalISODate(parseOpts.now ?? /* @__PURE__ */ new Date());
+  const options = { ...DEFAULT_OPTIONS, today };
+  let title = null;
+  let firstAnchorLine = null;
+  let firstAnchorKey = null;
+  const declarationsByName = /* @__PURE__ */ new Map();
+  const declarationsByAlias = /* @__PURE__ */ new Map();
+  const allDeclarations = [];
+  const sitesByName = /* @__PURE__ */ new Map();
+  const references = [];
+  const groups = [];
+  const tagGroups = [];
+  let currentTagGroup = null;
+  let contentStarted = false;
+  const metaAliasMap = /* @__PURE__ */ new Map();
+  const groupStack = [];
+  const currentGroupId = () => groupStack.length > 0 ? (
+    // In-bounds by length check.
+    groupStack[groupStack.length - 1].groupId
+  ) : void 0;
+  let currentSourceName = null;
+  let currentSourceIndent = -1;
+  let currentSourceSite = null;
+  let pastFirstLine = false;
+  for (let i = 0; i < lines.length; i++) {
+    const rawLine = lines[i];
+    const lineNumber = i + 1;
+    const trimmed = stripTrailingComment(rawLine).trim();
+    if (!trimmed) continue;
+    if (trimmed.startsWith("#") || trimmed.startsWith("//")) continue;
+    const indent = measureIndent(rawLine);
+    while (groupStack.length > 0) {
+      const top = groupStack[groupStack.length - 1];
+      if (indent <= top.indent) groupStack.pop();
+      else break;
+    }
+    if (currentSourceIndent >= 0 && indent <= currentSourceIndent && !trimmed.startsWith("-")) {
+      currentSourceName = null;
+      currentSourceIndent = -1;
+      currentSourceSite = null;
+    }
+    if (!pastFirstLine) {
+      pastFirstLine = true;
+      const tokens = trimmed.split(/\s+/);
+      const head = tokens[0].toLowerCase();
+      if (head === "pert") {
+        if (tokens.length > 1) title = tokens.slice(1).join(" ");
+        continue;
+      }
+    }
+    if (!contentStarted) {
+      const tagBlockMatch = matchTagBlockHeading(trimmed);
+      if (tagBlockMatch) {
+        currentTagGroup = {
+          name: tagBlockMatch.name,
+          ...tagBlockMatch.alias !== void 0 && {
+            alias: tagBlockMatch.alias
+          },
+          entries: [],
+          lineNumber
+        };
+        if (tagBlockMatch.alias) {
+          metaAliasMap.set(
+            tagBlockMatch.alias.toLowerCase(),
+            tagAttrKey(tagBlockMatch.name)
+          );
+        }
+        metaAliasMap.set(
+          normalizeName(tagBlockMatch.name),
+          tagAttrKey(tagBlockMatch.name)
+        );
+        tagGroups.push(currentTagGroup);
+        if (tagBlockMatch.inlineValues) {
+          for (const raw of tagBlockMatch.inlineValues) {
+            const { text, isDefault } = stripDefaultModifier(raw);
+            const { label, color } = extractColor(
+              text,
+              parseOpts.palette,
+              diagnostics,
+              lineNumber
+            );
+            if (isDefault || currentTagGroup.entries.length === 0) {
+              currentTagGroup.defaultValue = label;
+            }
+            currentTagGroup.entries.push({
+              value: label,
+              color: color ?? AUTO_TAG_COLOR_SENTINEL,
+              lineNumber
+            });
+          }
+        }
+        continue;
+      }
+      if (currentTagGroup && indent > 0) {
+        const { text, isDefault } = stripDefaultModifier(trimmed);
+        const { label, color } = extractColor(
+          text,
+          parseOpts.palette,
+          diagnostics,
+          lineNumber
+        );
+        if (isDefault || currentTagGroup.entries.length === 0) {
+          currentTagGroup.defaultValue = label;
+        }
+        currentTagGroup.entries.push({
+          value: label,
+          color: color ?? AUTO_TAG_COLOR_SENTINEL,
+          lineNumber
+        });
+        continue;
+      }
+      currentTagGroup = null;
+    } else if (matchTagBlockHeading(trimmed)) {
+      error(
+        lineNumber,
+        `'tag' declarations must appear before activities and groups.`
+      );
+      continue;
+    }
+    const groupMatch = trimmed.match(GROUP_HEADER_RE);
+    if (groupMatch) {
+      contentStarted = true;
+      currentTagGroup = null;
+      const name = groupMatch[1].trim();
+      const tail = (groupMatch[2] ?? "").trim();
+      const meta = tail ? parsePipeMetadata(tail, metaAliasMap) : {};
+      const id = `[${normalizeName(name)}]`;
+      const tags = {};
+      for (const [k, v] of Object.entries(meta)) {
+        if (!RESERVED_PIPE_KEYS.has(k)) tags[k] = v;
+      }
+      groups.push({
+        id,
+        name,
+        activityIds: [],
+        collapsed: meta["collapsed"] === "true",
+        lineNumber,
+        ...Object.keys(tags).length > 0 && { tags }
+      });
+      groupStack.push({ groupId: id, indent });
+      currentSourceName = null;
+      currentSourceIndent = -1;
+      currentSourceSite = null;
+      continue;
+    }
+    if (trimmed.startsWith("-")) {
+      contentStarted = true;
+      currentTagGroup = null;
+      let arrowTargetText;
+      let edgeType = "FS";
+      let edgeLag = null;
+      const bareMatch = trimmed.match(ARROW_RE);
+      if (bareMatch) {
+        arrowTargetText = bareMatch[1];
+      } else {
+        const labeledMatch = trimmed.match(LABELED_ARROW_RE);
+        if (!labeledMatch) {
+          error(lineNumber, `Malformed arrow line: '${trimmed}'.`);
+          continue;
+        }
+        const parsedLabel = parseEdgeLabel(labeledMatch[1], options.timeUnit);
+        if (!parsedLabel) {
+          error(
+            lineNumber,
+            `Invalid edge label '${labeledMatch[1]}' in '${trimmed}'. Expected a dependency type (FS/SS/FF/SF) and/or lag (e.g. '+2d', '-1d').`
+          );
+          continue;
+        }
+        arrowTargetText = labeledMatch[2];
+        edgeType = parsedLabel.type;
+        edgeLag = parsedLabel.lag;
+      }
+      if (!currentSourceName) {
+        error(
+          lineNumber,
+          `'-> ${arrowTargetText}' has no source \u2014 declare an activity above on a non-indented line.`
+        );
+        continue;
+      }
+      const tok = tokenizeActivityLine(
+        arrowTargetText,
+        diagnostics,
+        lineNumber,
+        metaAliasMap
+      );
+      const targetName = tok.name;
+      if (!targetName) {
+        error(lineNumber, `'-> \u2026' is missing a target name.`);
+        continue;
+      }
+      if (tok.durationTokens.length > 0 || tok.alias !== void 0 || tok.pipeMetadata !== void 0) {
+        const extras = [];
+        if (tok.durationTokens.length > 0) {
+          extras.push(`'${tok.durationTokens.join(" ")}'`);
+        }
+        if (tok.alias !== void 0) extras.push(`'as ${tok.alias}'`);
+        if (tok.pipeMetadata !== void 0) {
+          extras.push(`'${tok.pipeMetadata}'`);
+        }
+        const durHint = tok.durationTokens.length > 0 ? ` ${tok.durationTokens.join(" ")}` : "";
+        error(
+          lineNumber,
+          `Inline forward-declaration not allowed on '-> ${arrowTargetText}' (${extras.join(", ")}). Move attributes to a source-line: '${targetName}${durHint}' then '-> ${targetName}'.`
+        );
+        continue;
+      }
+      references.push({
+        sourceName: currentSourceName,
+        sourceLineNumber: -1,
+        // resolved in Pass 2 from declarations
+        targetName,
+        targetLineNumber: lineNumber,
+        type: edgeType,
+        lag: edgeLag
+      });
+      continue;
+    }
+    if (currentSourceSite) {
+      const metaMatch = trimmed.match(INDENTED_META_RE);
+      if (metaMatch) {
+        const rawKey = metaMatch[1];
+        const key = rawKey.toLowerCase();
+        const resolvedKey = metaAliasMap.get(key) ?? key;
+        if (RESERVED_PIPE_KEYS.has(resolvedKey) || metaAliasMap.has(key)) {
+          contentStarted = true;
+          currentTagGroup = null;
+          const entry = `${rawKey}: ${metaMatch[2].trim()}`;
+          currentSourceSite.pipeMetadata = currentSourceSite.pipeMetadata ? `${currentSourceSite.pipeMetadata}, ${entry}` : entry;
+          continue;
+        }
+      }
+    }
+    {
+      const firstSpace = trimmed.indexOf(" ");
+      const head = firstSpace === -1 ? trimmed.toLowerCase() : trimmed.slice(0, firstSpace).toLowerCase();
+      if (DIRECTIVE_KEYS.has(head)) {
+        const value = firstSpace === -1 ? "" : trimmed.slice(firstSpace + 1).trim();
+        if (head === "start-date" || head === "end-date") {
+          const hadAnchor = options.anchor !== null;
+          applyAnchorDirective(
+            head,
+            value,
+            lineNumber,
+            options,
+            diagnostics,
+            firstAnchorLine,
+            firstAnchorKey
+          );
+          if (!hadAnchor && options.anchor !== null) {
+            firstAnchorLine = lineNumber;
+            firstAnchorKey = head;
+          } else if (hadAnchor && options.anchor === null) {
+            firstAnchorLine = null;
+            firstAnchorKey = null;
+          }
+          continue;
+        }
+        applyDirective(head, value, lineNumber, options, error, warn);
+        continue;
+      }
+    }
+    {
+      const firstSpace = trimmed.indexOf(" ");
+      if (firstSpace > 0) {
+        const head = trimmed.slice(0, firstSpace).toLowerCase();
+        const value = trimmed.slice(firstSpace + 1).trim();
+        const hint = NEAR_DIRECTIVE_HINTS.find((h) => h.stem === head);
+        if (hint?.matches.test(value)) {
+          diagnostics.push(
+            emit(PERT_DX.NEAR_DIRECTIVE, lineNumber, {
+              head,
+              canonical: hint.canonical
+            })
+          );
+          continue;
+        }
+      }
+    }
+    if (/^milestone(\s|$)/i.test(trimmed)) {
+      error(lineNumber, `Unknown keyword 'milestone'.`);
+      continue;
+    }
+    {
+      const tok = tokenizeActivityLine(
+        trimmed,
+        diagnostics,
+        lineNumber,
+        metaAliasMap
+      );
+      if (!tok.name) {
+        error(lineNumber, `Empty activity name: '${trimmed}'.`);
+        continue;
+      }
+      contentStarted = true;
+      currentTagGroup = null;
+      const isBareSource = tok.durationTokens.length === 0 && tok.alias === void 0 && tok.pipeMetadata === void 0;
+      if (isBareSource && declarationsByAlias.has(tok.name)) {
+        const existing = declarationsByAlias.get(tok.name);
+        currentSourceName = existing.name;
+        currentSourceIndent = indent;
+        currentSourceSite = existing;
+        continue;
+      }
+      const groupHint = currentGroupId();
+      const site = {
+        name: tok.name,
+        ...tok.alias !== void 0 && { alias: tok.alias },
+        durationTokens: tok.durationTokens,
+        ...tok.pipeMetadata !== void 0 && {
+          pipeMetadata: tok.pipeMetadata
+        },
+        lineNumber,
+        ...groupHint !== void 0 && { groupHint }
+      };
+      registerSite(site);
+      currentSourceName = tok.name;
+      currentSourceIndent = indent;
+      currentSourceSite = site;
+      continue;
+    }
+  }
+  function registerSite(site) {
+    allDeclarations.push(site);
+    const key = normalizeName(site.name);
+    const bucket = sitesByName.get(key);
+    if (bucket) bucket.push(site);
+    else sitesByName.set(key, [site]);
+    if (!declarationsByName.has(key)) {
+      declarationsByName.set(key, site);
+    }
+    if (site.alias && !declarationsByAlias.has(site.alias)) {
+      declarationsByAlias.set(site.alias, site);
+    }
+  }
+  if (options.anchor !== null) {
+    if (options.timeUnit === "bd") {
+      diagnostics.push(emit(PERT_DX.BD_WITH_ANCHOR, 0));
+    } else if (options.timeUnit === "min" || options.timeUnit === "h") {
+      diagnostics.push(emit(PERT_DX.SUBDAY_WITH_ANCHOR, 0));
+    }
+  }
+  for (const [key, sites] of sitesByName) {
+    if (sites.length < 2) continue;
+    const explicit = sites.filter((s) => s.durationTokens.length > 0);
+    if (explicit.length < 2) continue;
+    const fingerprints = new Set(
+      explicit.map((s) => s.durationTokens.join(" "))
+    );
+    if (fingerprints.size > 1) {
+      const lineList = explicit.map((s) => `line ${s.lineNumber} (${s.durationTokens.join(" ")})`).join(" and ");
+      error(
+        explicit[0].lineNumber,
+        `Conflicting estimates for "${declarationsByName.get(key).name}" on ${lineList}. Keep one declaration site.`
+      );
+    }
+  }
+  const idMap = {};
+  for (const [, decl] of declarationsByName) {
+    const id = canonicalIdFromDeclaration(decl);
+    idMap[normalizeName(decl.name)] = id;
+    idMap[decl.name.toLowerCase()] = id;
+  }
+  for (const [aliasLiteral, decl] of declarationsByAlias) {
+    idMap[aliasLiteral] = canonicalIdFromDeclaration(decl);
+  }
+  function canonicalIdFromDeclaration(decl) {
+    return normalizeName(decl.name);
+  }
+  function resolveTargetId(token, lineNumber) {
+    const trimmed = token.trim();
+    if (declarationsByAlias.has(trimmed)) {
+      return canonicalIdFromDeclaration(declarationsByAlias.get(trimmed));
+    }
+    const norm = normalizeName(trimmed);
+    if (declarationsByName.has(norm)) {
+      return canonicalIdFromDeclaration(declarationsByName.get(norm));
+    }
+    const candidates = [
+      ...declarationsByAlias.keys(),
+      ...[...declarationsByName.values()].map((d) => d.name)
+    ];
+    const hint = suggest(trimmed, candidates);
+    error(
+      lineNumber,
+      `Unknown activity '${trimmed}'.${hint ? ` ${hint}` : ""}`
+    );
+    return null;
+  }
+  const bestDeclByName = /* @__PURE__ */ new Map();
+  for (const decl of allDeclarations) {
+    const key = normalizeName(decl.name);
+    const existing = bestDeclByName.get(key);
+    if (!existing) {
+      bestDeclByName.set(key, decl);
+      continue;
+    }
+    const existingHasInfo = existing.durationTokens.length > 0 || existing.alias !== void 0;
+    const incomingHasInfo = decl.durationTokens.length > 0 || decl.alias !== void 0;
+    if (!existingHasInfo && incomingHasInfo) {
+      bestDeclByName.set(key, decl);
+    }
+  }
+  const activitiesById = /* @__PURE__ */ new Map();
+  for (const [id, decl] of bestDeclByName) {
+    const estimate = buildEstimate(
+      decl.durationTokens,
+      options.timeUnit,
+      (msg) => error(decl.lineNumber, msg)
+    );
+    const meta = decl.pipeMetadata ? parsePipeMetadata(decl.pipeMetadata, metaAliasMap) : {};
+    const tags = {};
+    for (const [k, v] of Object.entries(meta)) {
+      if (!RESERVED_PIPE_KEYS.has(k)) tags[k] = v;
+    }
+    const isMilestone = estimate !== null && estimate.o.amount === 0 && estimate.m.amount === 0 && estimate.p.amount === 0;
+    activitiesById.set(id, {
+      id,
+      name: decl.name,
+      ...decl.alias !== void 0 && { alias: decl.alias },
+      duration: estimate,
+      ...meta["confidence"] && { confidence: meta["confidence"] },
+      ...decl.groupHint !== void 0 && { groupId: decl.groupHint },
+      lineNumber: decl.lineNumber,
+      isMilestone,
+      ...Object.keys(tags).length > 0 && { tags }
+    });
+  }
+  const edges = [];
+  for (const ref of references) {
+    const sourceId = resolveTargetId(ref.sourceName, ref.targetLineNumber);
+    const targetId = resolveTargetId(ref.targetName, ref.targetLineNumber);
+    if (!sourceId || !targetId) continue;
+    edges.push({
+      source: sourceId,
+      target: targetId,
+      lineNumber: ref.targetLineNumber,
+      type: ref.type,
+      lag: ref.lag
+    });
+  }
+  for (const group of groups) {
+    group.activityIds = [...activitiesById.values()].filter((a) => a.groupId === group.id).map((a) => a.id);
+    group.classification = classifyGroup(group, edges);
+  }
+  const seen = /* @__PURE__ */ new Set();
+  const activities = [];
+  for (const decl of allDeclarations) {
+    const id = canonicalIdFromDeclaration(decl);
+    if (seen.has(id)) continue;
+    seen.add(id);
+    const a = activitiesById.get(id);
+    if (a) activities.push(a);
+  }
+  if (options.trials === -1) {
+    options.trials = deriveTrials(activities.length);
+  }
+  if (options.seed === -1) {
+    const seedSource = title || activities.map((a) => a.name).sort().join("\n") || "pert";
+    options.seed = deriveSeed(seedSource);
+  }
+  const hasSprintOption = options.sprintLength !== null || options.sprintNumber !== null || options.sprintStart !== null;
+  const hasSprintUnit = options.timeUnit === "s" || activities.some(
+    (a) => a.duration !== null && (a.duration.o.unit === "s" || a.duration.m.unit === "s" || a.duration.p.unit === "s")
+  );
+  if (hasSprintOption) {
+    options.sprintMode = "explicit";
+  } else if (hasSprintUnit) {
+    options.sprintMode = "auto";
+  }
+  if (options.sprintMode) {
+    if (!options.sprintLength) {
+      options.sprintLength = { amount: 2, unit: "w" };
+    }
+    if (options.sprintNumber === null) {
+      options.sprintNumber = 1;
+    }
+  }
+  finalizeAutoTagColors(tagGroups, parseOpts.palette);
+  if (tagGroups.length > 0) {
+    validateTagGroupNames(
+      tagGroups.map((g) => ({
+        name: g.name,
+        alias: g.alias ?? null,
+        lineNumber: g.lineNumber
+      })),
+      warn,
+      error
+    );
+    const ensureTags = (entity) => {
+      if (!entity.tags) entity.tags = {};
+      return {
+        metadata: entity.tags,
+        lineNumber: entity.lineNumber
+      };
+    };
+    const activityShells = activities.map(ensureTags);
+    const groupShells = groups.map(ensureTags);
+    validateTagValues(
+      [...activityShells, ...groupShells],
+      tagGroups,
+      warn,
+      suggest
+    );
+    injectDefaultTagMetadata(activityShells, tagGroups);
+    for (const a of activities) {
+      if (a.tags && Object.keys(a.tags).length === 0) delete a.tags;
+    }
+    for (const g of groups) {
+      if (g.tags && Object.keys(g.tags).length === 0) delete g.tags;
+    }
+  }
+  const firstFatal = diagnostics.find((d) => d.severity === "error");
+  return {
+    title,
+    options,
+    activities,
+    edges,
+    groups,
+    tagGroups,
+    idMap,
+    diagnostics,
+    error: firstFatal ? firstFatal.message : null
+  };
+}
+function applyDirective(key, value, lineNumber, options, error, warn) {
+  switch (key) {
+    case "time-unit": {
+      const valid = [
+        "min",
+        "h",
+        "d",
+        "bd",
+        "w",
+        "m",
+        "q",
+        "y",
+        "s"
+      ];
+      if (!valid.includes(value)) {
+        error(
+          lineNumber,
+          `Unknown time-unit '${value}'. Expected one of ${valid.join(", ")}.`
+        );
+        return;
+      }
+      options.timeUnit = value;
+      return;
+    }
+    case "default-confidence": {
+      options.confidence = value || "medium";
+      return;
+    }
+    case "no-title": {
+      options.noTitle = true;
+      return;
+    }
+    case "solid-fill": {
+      options.solidFill = true;
+      return;
+    }
+    case "active-tag": {
+      options.activeTag = value;
+      return;
+    }
+    case "sprint-length": {
+      const dur = parseDuration(value);
+      if (!dur) {
+        warn(
+          lineNumber,
+          `Invalid sprint-length value: "${value}". Expected a duration like "2w" or "10d".`
+        );
+      } else if (dur.unit !== "d" && dur.unit !== "w") {
+        warn(
+          lineNumber,
+          `sprint-length only accepts "d" or "w" units, got "${dur.unit}".`
+        );
+      } else if (dur.amount <= 0) {
+        warn(lineNumber, `sprint-length must be greater than 0.`);
+      } else if (!Number.isInteger(dur.amount * (dur.unit === "w" ? 7 : 1))) {
+        warn(
+          lineNumber,
+          `sprint-length must resolve to a whole number of days.`
+        );
+      } else {
+        options.sprintLength = dur;
+      }
+      return;
+    }
+    case "sprint-number": {
+      const n = Number(value);
+      if (!Number.isFinite(n) || !Number.isInteger(n) || n <= 0) {
+        warn(
+          lineNumber,
+          `sprint-number must be a positive integer, got "${value}".`
+        );
+      } else {
+        options.sprintNumber = n;
+      }
+      return;
+    }
+    case "sprint-start": {
+      if (!/^\d{4}-\d{2}-\d{2}$/.test(value)) {
+        warn(
+          lineNumber,
+          `sprint-start requires a full date (YYYY-MM-DD), got "${value}".`
+        );
+      } else if (Number.isNaN((/* @__PURE__ */ new Date(value + "T00:00:00")).getTime())) {
+        warn(lineNumber, `sprint-start is not a valid date: "${value}".`);
+      } else {
+        options.sprintStart = value;
+      }
+      return;
+    }
+    case "direction": {
+      const upper = value.toUpperCase();
+      if (upper !== "LR" && upper !== "TB") {
+        error(lineNumber, `Unknown direction '${value}'. Expected LR or TB.`);
+        return;
+      }
+      options.direction = upper;
+      return;
+    }
+    case "node-detail": {
+      if (value !== "compact" && value !== "full") {
+        error(
+          lineNumber,
+          `Unknown node-detail '${value}'. Expected compact or full.`
+        );
+        return;
+      }
+      options.nodeDetail = value;
+      return;
+    }
+    case "no-analysis": {
+      options.noAnalysis = true;
+      return;
+    }
+    case "trials": {
+      const n = parseInt(value, 10);
+      if (!Number.isFinite(n) || n < 1) {
+        error(
+          lineNumber,
+          `'trials' expects a positive integer; got '${value}'.`
+        );
+        return;
+      }
+      options.trials = n;
+      return;
+    }
+    case "seed": {
+      const n = parseInt(value, 10);
+      if (!Number.isFinite(n)) {
+        error(lineNumber, `'seed' expects an integer; got '${value}'.`);
+        return;
+      }
+      options.seed = n;
+      return;
+    }
+    case "scrubber-trials": {
+      const n = parseInt(value, 10);
+      if (!Number.isFinite(n) || n < 1) {
+        error(
+          lineNumber,
+          `'scrubber-trials' expects a positive integer; got '${value}'.`
+        );
+        return;
+      }
+      if (n < 100) {
+        warn(
+          lineNumber,
+          `'scrubber-trials ${n}' is below the floor of 100; analyzer will still degrade if needed.`
+        );
+      }
+      options.scrubberTrials = n;
+      return;
+    }
+    case "start-date":
+    case "end-date": {
+      error(
+        lineNumber,
+        `internal error: anchor directive '${key}' reached generic dispatch`
+      );
+      return;
+    }
+  }
+}
+function applyAnchorDirective(key, value, lineNumber, options, diagnostics, firstAnchorLine, firstAnchorKey) {
+  if (options.anchor !== null) {
+    diagnostics.push(
+      emit(PERT_DX.BOTH_ANCHORS, lineNumber, {
+        firstAnchorKey,
+        firstAnchorLine
+      })
+    );
+    options.anchor = null;
+    return;
+  }
+  const trimmed = value.trim();
+  if (trimmed.length === 0) {
+    diagnostics.push(
+      emit(PERT_DX.INVALID_DATE, lineNumber, { empty: true, key, value })
+    );
+    return;
+  }
+  if (trimmed.toLowerCase() === "now") {
+    if (key === "end-date") {
+      diagnostics.push(emit(PERT_DX.END_DATE_NOW, lineNumber));
+      return;
+    }
+    options.anchor = { kind: "forward", date: options.today };
+    return;
+  }
+  const parsed = parseLocalISODate(trimmed);
+  if (!parsed) {
+    diagnostics.push(emit(PERT_DX.INVALID_DATE, lineNumber, { trimmed, key }));
+    return;
+  }
+  options.anchor = key === "start-date" ? { kind: "forward", date: trimmed } : { kind: "backward", date: trimmed };
+}
+function classifyGroup(group, edges) {
+  const members = new Set(group.activityIds);
+  if (members.size === 0) return "cluster";
+  const entries = /* @__PURE__ */ new Set();
+  const exits = /* @__PURE__ */ new Set();
+  for (const id of members) {
+    const incoming = edges.filter((e) => e.target === id);
+    const outgoing = edges.filter((e) => e.source === id);
+    const hasInsideIn = incoming.some((e) => members.has(e.source));
+    const hasOutsideIn = incoming.some((e) => !members.has(e.source));
+    const hasInsideOut = outgoing.some((e) => members.has(e.target));
+    const hasOutsideOut = outgoing.some((e) => !members.has(e.target));
+    if (hasOutsideIn || !hasInsideIn && incoming.length === 0)
+      entries.add(id);
+    if (hasOutsideOut || !hasInsideOut && outgoing.length === 0)
+      exits.add(id);
+  }
+  return entries.size === 1 && exits.size === 1 ? "hammock" : "cluster";
+}
+function extractPertSymbols(docText) {
+  const parsed = parsePert(docText);
+  const entities = [];
+  for (const a of parsed.activities) {
+    if (!entities.includes(a.name)) entities.push(a.name);
+    if (a.alias && !entities.includes(a.alias)) entities.push(a.alias);
+  }
+  for (const g of parsed.groups) {
+    if (!entities.includes(g.name)) entities.push(g.name);
+  }
+  return {
+    kind: "pert",
+    entities
+  };
+}
+function looksLikePert(content) {
+  for (const raw of content.split("\n")) {
+    const line = raw.trim();
+    if (!line || line.startsWith("//") || line.startsWith("#")) continue;
+    if (/^analysis\s+monte-carlo\b/i.test(line)) return true;
+  }
+  return false;
+}
+
+export {
+  PERT_DIAGNOSTICS,
+  parseEdgeLabel,
+  parsePert,
+  extractPertSymbols,
+  looksLikePert
+};
+//# sourceMappingURL=chunk-RTLBSQ3G.js.map