@diagrammo/dgmo 0.45.0 → 0.47.0

package/dist/chunk-NX4EQS3U.js

@@ -0,0 +1,1062 @@
+import {
+  CONFIDENCE_TABLE,
+  addCalendarDays,
+  resolveConfidence,
+  unitToDays
+} from "./chunk-L3UHP6TD.js";
+import {
+  makeDgmoError
+} from "./chunk-CXK4DZH3.js";
+
+// src/pert/monte-carlo.ts
+function lagDays(lag) {
+  return lag === null ? 0 : lag.amount * unitToDays(lag.unit);
+}
+function mulberry32(seed) {
+  let s = seed >>> 0;
+  return () => {
+    s = s + 1831565813 >>> 0;
+    let t = s;
+    t = Math.imul(t ^ t >>> 15, t | 1);
+    t ^= t + Math.imul(t ^ t >>> 7, t | 61);
+    return ((t ^ t >>> 14) >>> 0) / 4294967296;
+  };
+}
+function standardNormal(rng) {
+  let u = 0;
+  let v = 0;
+  while (u === 0) u = rng();
+  while (v === 0) v = rng();
+  return Math.sqrt(-2 * Math.log(u)) * Math.cos(2 * Math.PI * v);
+}
+function gamma(shape, rng) {
+  if (shape < 1) {
+    const u = rng();
+    return gamma(shape + 1, rng) * Math.pow(u, 1 / shape);
+  }
+  const d = shape - 1 / 3;
+  const c = 1 / Math.sqrt(9 * d);
+  while (true) {
+    let x;
+    let v;
+    do {
+      x = standardNormal(rng);
+      v = 1 + c * x;
+    } while (v <= 0);
+    v = v * v * v;
+    const u = rng();
+    if (u < 1 - 0.0331 * x * x * x * x) return d * v;
+    if (Math.log(u) < x * x / 2 + d * (1 - v + Math.log(v))) return d * v;
+  }
+}
+function sampleBeta(alpha, beta, rng) {
+  const x = gamma(alpha, rng);
+  const y = gamma(beta, rng);
+  return x / (x + y);
+}
+function sampleBetaPert(o, m, p, rng) {
+  if (o === p) return m;
+  const range = p - o;
+  const alpha = 1 + 4 * (m - o) / range;
+  const beta = 1 + 4 * (p - m) / range;
+  return o + sampleBeta(alpha, beta, rng) * range;
+}
+function simulate(resolved, expanded, _predecessors, _successors, topo, terminals, poisoned, opts) {
+  const rng = mulberry32(opts.seed);
+  const expById = /* @__PURE__ */ new Map();
+  for (const e of expanded) expById.set(e.id, e);
+  const completionTimes = new Array(opts.trials);
+  const criticalityCount = /* @__PURE__ */ new Map();
+  for (const id of topo) criticalityCount.set(id, 0);
+  const pathCount = /* @__PURE__ */ new Map();
+  const pathById = /* @__PURE__ */ new Map();
+  const incomingEdges = /* @__PURE__ */ new Map();
+  for (const id of topo) incomingEdges.set(id, []);
+  for (const e of resolved.edges) incomingEdges.get(e.target)?.push(e);
+  const es = /* @__PURE__ */ new Map();
+  const ef = /* @__PURE__ */ new Map();
+  const predOnLongestPath = /* @__PURE__ */ new Map();
+  for (let trial = 0; trial < opts.trials; trial++) {
+    for (const id of topo) {
+      const exp = expById.get(id);
+      let duration;
+      if (!exp || poisoned.has(id)) {
+        duration = 0;
+      } else if (exp.o === exp.p) {
+        duration = exp.m;
+      } else {
+        duration = sampleBetaPert(exp.o, exp.m, exp.p, rng);
+      }
+      let esLower = 0;
+      let efLower = -Infinity;
+      let bestPred = null;
+      let bestPredVal = -Infinity;
+      for (const edge of incomingEdges.get(id) ?? []) {
+        const aEs = es.get(edge.source) ?? 0;
+        const aEf = ef.get(edge.source) ?? 0;
+        const lag = lagDays(edge.lag);
+        let candES = -Infinity;
+        let candEF = -Infinity;
+        switch (edge.type) {
+          case "FS":
+            candES = aEf + lag;
+            break;
+          case "SS":
+            candES = aEs + lag;
+            break;
+          case "FF":
+            candEF = aEf + lag;
+            break;
+          case "SF":
+            candEF = aEs + lag;
+            break;
+        }
+        if (candES > esLower) esLower = candES;
+        if (candEF > efLower) efLower = candEF;
+        const contribution = Math.max(candES, candEF - duration);
+        if (contribution > bestPredVal) {
+          bestPredVal = contribution;
+          bestPred = edge.source;
+        }
+      }
+      let esVal = esLower;
+      let efVal = esVal + duration;
+      if (efLower > efVal) {
+        efVal = efLower;
+        esVal = efVal - duration;
+      }
+      es.set(id, esVal);
+      ef.set(id, efVal);
+      predOnLongestPath.set(id, bestPred);
+    }
+    let endEf = 0;
+    let endId = terminals[0] ?? null;
+    for (const id of topo) {
+      const e = ef.get(id) ?? 0;
+      if (e > endEf) {
+        endEf = e;
+        endId = id;
+      }
+    }
+    completionTimes[trial] = endEf;
+    if (endId !== null) {
+      const path = [];
+      let cur = endId;
+      while (cur !== null) {
+        path.unshift(cur);
+        criticalityCount.set(cur, (criticalityCount.get(cur) ?? 0) + 1);
+        cur = predOnLongestPath.get(cur) ?? null;
+      }
+      const key = path.join("\0");
+      pathCount.set(key, (pathCount.get(key) ?? 0) + 1);
+      if (!pathById.has(key)) pathById.set(key, path);
+    }
+  }
+  completionTimes.sort((a, b) => a - b);
+  const pct = (frac) => {
+    const idx = Math.min(
+      completionTimes.length - 1,
+      Math.max(0, Math.floor(frac * completionTimes.length))
+    );
+    return completionTimes[idx] ?? 0;
+  };
+  const minDurationDays = completionTimes[0] ?? 0;
+  const maxDurationDays = completionTimes[completionTimes.length - 1] ?? 0;
+  let modalKey = "";
+  let modalCount = -1;
+  for (const [key, count] of pathCount) {
+    if (count > modalCount) {
+      modalCount = count;
+      modalKey = key;
+    } else if (count === modalCount) {
+      const a = pathById.get(modalKey) ?? [];
+      const b = pathById.get(key) ?? [];
+      const va = pathVariance(a, expById);
+      const vb = pathVariance(b, expById);
+      if (vb > va) {
+        modalKey = key;
+      } else if (vb === va && key.localeCompare(modalKey) < 0) {
+        modalKey = key;
+      }
+    }
+  }
+  const criticalityByActivity = {};
+  for (const id of topo) {
+    criticalityByActivity[id] = (criticalityCount.get(id) ?? 0) / opts.trials;
+  }
+  return {
+    trials: opts.trials,
+    seed: opts.seed,
+    p50: pct(0.5),
+    p80: pct(0.8),
+    p95: pct(0.95),
+    p16: pct(0.16),
+    p84: pct(0.84),
+    criticalityByActivity,
+    modalCriticalPath: pathById.get(modalKey) ?? [],
+    // Analyzer populates this after MC returns by running the
+    // deterministic per-activity tornado pass. Empty here so the
+    // type contract is satisfied even in scrubber/fast paths that
+    // never compute swings.
+    tornadoSwings: [],
+    minDurationDays,
+    maxDurationDays
+  };
+}
+function pathVariance(path, expById) {
+  let sum = 0;
+  for (const id of path) {
+    const e = expById.get(id);
+    if (!e) continue;
+    const sigma = (e.p - e.o) / 6;
+    sum += sigma * sigma;
+  }
+  return sum;
+}
+function buildSimulationContext(resolved) {
+  const predecessors = /* @__PURE__ */ new Map();
+  const successors = /* @__PURE__ */ new Map();
+  for (const r of resolved.activities) {
+    predecessors.set(r.activity.id, []);
+    successors.set(r.activity.id, []);
+  }
+  for (const e of resolved.edges) {
+    successors.get(e.source)?.push(e.target);
+    predecessors.get(e.target)?.push(e.source);
+  }
+  const inDegree = /* @__PURE__ */ new Map();
+  for (const r of resolved.activities) {
+    inDegree.set(r.activity.id, predecessors.get(r.activity.id).length);
+  }
+  const queue = [];
+  for (const [id, deg] of inDegree) if (deg === 0) queue.push(id);
+  const topo = [];
+  while (queue.length > 0) {
+    const id = queue.shift();
+    topo.push(id);
+    for (const next of successors.get(id) ?? []) {
+      const deg = (inDegree.get(next) ?? 0) - 1;
+      inDegree.set(next, deg);
+      if (deg === 0) queue.push(next);
+    }
+  }
+  const terminals = [];
+  for (const r of resolved.activities) {
+    if ((successors.get(r.activity.id) ?? []).length === 0) {
+      terminals.push(r.activity.id);
+    }
+  }
+  const poisoned = /* @__PURE__ */ new Set();
+  for (const r of resolved.activities) {
+    if (r.activity.duration === null) {
+      const stack = [r.activity.id];
+      while (stack.length > 0) {
+        const id = stack.pop();
+        if (poisoned.has(id)) continue;
+        poisoned.add(id);
+        for (const next of successors.get(id) ?? []) stack.push(next);
+      }
+    }
+  }
+  return { predecessors, successors, topo, terminals, poisoned };
+}
+function simulateCanonical(resolved, expanded, opts) {
+  const ctx = buildSimulationContext(resolved);
+  return simulate(
+    resolved,
+    expanded,
+    ctx.predecessors,
+    ctx.successors,
+    ctx.topo,
+    ctx.terminals,
+    ctx.poisoned,
+    { trials: opts.trials, seed: opts.seed }
+  );
+}
+function simulateFast(resolved, expanded, opts) {
+  return simulateCanonical(resolved, expanded, opts);
+}
+
+// src/pert/analyzer.ts
+var UNIT_TO_DAYS = {
+  min: 1 / (60 * 24),
+  h: 1 / 24,
+  d: 1,
+  bd: 1,
+  // PERT has no calendar; bd ≈ d for analytical purposes
+  w: 7,
+  m: 30,
+  q: 90,
+  y: 365,
+  s: 14
+  // fallback when sprint-length isn't authored; the analyzer
+  // overrides this from `options.sprintLength` when in sprint mode.
+};
+function unitDays(unit, sprintDaysOverride) {
+  if (unit === "s" && sprintDaysOverride !== void 0) {
+    return sprintDaysOverride;
+  }
+  return UNIT_TO_DAYS[unit];
+}
+function toDays(d, sprintDaysOverride) {
+  return d.amount * unitDays(d.unit, sprintDaysOverride);
+}
+function fromDays(days, unit, sprintDaysOverride) {
+  return days / unitDays(unit, sprintDaysOverride);
+}
+function resolveSprintDays(opts) {
+  if (!opts.sprintMode || !opts.sprintLength) return void 0;
+  return opts.sprintLength.amount * UNIT_TO_DAYS[opts.sprintLength.unit];
+}
+function expandEstimate(estimate, diagramConfidence, activityConfidence, sprintDays) {
+  const o = toDays(estimate.o, sprintDays);
+  const m = toDays(estimate.m, sprintDays);
+  const p = toDays(estimate.p, sprintDays);
+  let oFinal = o;
+  let pFinal = p;
+  if (estimate.mOnly) {
+    const fromActivity = activityConfidence ? resolveConfidence(activityConfidence) : null;
+    const factors = fromActivity ?? resolveConfidence(diagramConfidence) ?? CONFIDENCE_TABLE.medium;
+    oFinal = m * factors.oFactor;
+    pFinal = m * factors.pFactor;
+  }
+  const mean = (oFinal + 4 * m + pFinal) / 6;
+  const sigma = (pFinal - oFinal) / 6;
+  return { o: oFinal, m, p: pFinal, mean, sigma };
+}
+function analyzePert(parsed) {
+  const diagnostics = [...parsed.diagnostics];
+  const error = (line, msg) => {
+    diagnostics.push(makeDgmoError(line, msg, "error"));
+  };
+  const activities = parsed.activities;
+  const edges = parsed.edges;
+  const warn = (line, msg) => {
+    diagnostics.push(makeDgmoError(line, msg, "warning"));
+  };
+  const sprintDays = resolveSprintDays(parsed.options);
+  const successors = /* @__PURE__ */ new Map();
+  const predecessors = /* @__PURE__ */ new Map();
+  const incomingEdges = /* @__PURE__ */ new Map();
+  const outgoingEdges = /* @__PURE__ */ new Map();
+  for (const a of activities) {
+    successors.set(a.id, []);
+    predecessors.set(a.id, []);
+    incomingEdges.set(a.id, []);
+    outgoingEdges.set(a.id, []);
+  }
+  for (const e of edges) {
+    successors.get(e.source)?.push(e.target);
+    predecessors.get(e.target)?.push(e.source);
+    incomingEdges.get(e.target)?.push(e);
+    outgoingEdges.get(e.source)?.push(e);
+  }
+  for (const e of edges) {
+    if (!e.lag || e.lag.amount >= 0) continue;
+    const src = activities.find((a) => a.id === e.source);
+    if (!src?.duration) continue;
+    const leadDays = -toDays(e.lag, sprintDays);
+    const srcDurDays = toDays(src.duration.m, sprintDays);
+    if (e.type === "FS" && leadDays > srcDurDays) {
+      warn(
+        e.lineNumber,
+        `Lead (${-e.lag.amount}${e.lag.unit}) exceeds predecessor "${src.name}" duration \u2014 the FS edge implies the successor starts before the predecessor.`
+      );
+    }
+  }
+  const topo = [];
+  const inDegree = /* @__PURE__ */ new Map();
+  for (const a of activities)
+    inDegree.set(a.id, predecessors.get(a.id).length);
+  const queue = [];
+  for (const [id, deg] of inDegree) if (deg === 0) queue.push(id);
+  while (queue.length > 0) {
+    const id = queue.shift();
+    topo.push(id);
+    for (const next of successors.get(id) ?? []) {
+      const deg = (inDegree.get(next) ?? 0) - 1;
+      inDegree.set(next, deg);
+      if (deg === 0) queue.push(next);
+    }
+  }
+  if (topo.length < activities.length) {
+    const culprit = activities.find((a) => (inDegree.get(a.id) ?? 0) > 0);
+    if (culprit) {
+      error(culprit.lineNumber, `Cycle detected involving "${culprit.name}".`);
+    } else {
+      error(0, `Cycle detected in PERT graph.`);
+    }
+    return emptyResolved(parsed, diagnostics);
+  }
+  const expandedById = /* @__PURE__ */ new Map();
+  for (const a of activities) {
+    if (a.duration === null) {
+      expandedById.set(a.id, null);
+      continue;
+    }
+    expandedById.set(
+      a.id,
+      expandEstimate(
+        a.duration,
+        parsed.options.confidence,
+        a.confidence,
+        sprintDays
+      )
+    );
+  }
+  const poisoned = /* @__PURE__ */ new Set();
+  for (const a of activities) {
+    if (a.duration === null) {
+      const stack = [a.id];
+      poisoned.add(a.id);
+      while (stack.length > 0) {
+        const id = stack.pop();
+        for (const next of successors.get(id) ?? []) {
+          if (!poisoned.has(next)) {
+            poisoned.add(next);
+            stack.push(next);
+          }
+        }
+      }
+    }
+  }
+  const es = /* @__PURE__ */ new Map();
+  const ef = /* @__PURE__ */ new Map();
+  for (const id of topo) {
+    if (poisoned.has(id)) {
+      es.set(id, null);
+      ef.set(id, null);
+      continue;
+    }
+    const expanded = expandedById.get(id);
+    const dur = expanded.mean;
+    let esLower = 0;
+    let efLower = -Infinity;
+    for (const edge of incomingEdges.get(id) ?? []) {
+      const aEs = es.get(edge.source);
+      const aEf = ef.get(edge.source);
+      if (aEs == null || aEf == null) continue;
+      const lagDays2 = edge.lag ? toDays(edge.lag, sprintDays) : 0;
+      switch (edge.type) {
+        case "FS":
+          esLower = Math.max(esLower, aEf + lagDays2);
+          break;
+        case "SS":
+          esLower = Math.max(esLower, aEs + lagDays2);
+          break;
+        case "FF":
+          efLower = Math.max(efLower, aEf + lagDays2);
+          break;
+        case "SF":
+          efLower = Math.max(efLower, aEs + lagDays2);
+          break;
+      }
+    }
+    let esVal = esLower;
+    let efVal = esVal + dur;
+    if (efLower > efVal) {
+      efVal = efLower;
+      esVal = efVal - dur;
+    }
+    es.set(id, esVal);
+    ef.set(id, efVal);
+  }
+  let projectMuDays = null;
+  let endId = null;
+  let anyTerminalPoisoned = false;
+  for (const a of activities) {
+    const isTerminal = (successors.get(a.id) ?? []).length === 0;
+    if (poisoned.has(a.id)) {
+      if (isTerminal) anyTerminalPoisoned = true;
+      continue;
+    }
+    const efVal = ef.get(a.id);
+    if (efVal != null && (projectMuDays === null || efVal > projectMuDays)) {
+      projectMuDays = efVal;
+      endId = a.id;
+    }
+  }
+  if (anyTerminalPoisoned) {
+    projectMuDays = null;
+    endId = null;
+  }
+  const ls = /* @__PURE__ */ new Map();
+  const lf = /* @__PURE__ */ new Map();
+  for (const a of activities) {
+    if (poisoned.has(a.id) || projectMuDays === null) {
+      ls.set(a.id, null);
+      lf.set(a.id, null);
+    } else {
+      lf.set(a.id, projectMuDays);
+      const exp = expandedById.get(a.id);
+      ls.set(a.id, projectMuDays - exp.mean);
+    }
+  }
+  for (let i = topo.length - 1; i >= 0; i--) {
+    const id = topo[i];
+    if (poisoned.has(id) || projectMuDays === null) continue;
+    const out = outgoingEdges.get(id) ?? [];
+    if (out.length === 0) continue;
+    const exp = expandedById.get(id);
+    const dur = exp.mean;
+    let lfUpper = Infinity;
+    let lsUpper = Infinity;
+    for (const edge of out) {
+      const bLs = ls.get(edge.target);
+      const bLf = lf.get(edge.target);
+      if (bLs == null || bLf == null) continue;
+      const lagDays2 = edge.lag ? toDays(edge.lag, sprintDays) : 0;
+      switch (edge.type) {
+        case "FS":
+          lfUpper = Math.min(lfUpper, bLs - lagDays2);
+          break;
+        case "SS":
+          lsUpper = Math.min(lsUpper, bLs - lagDays2);
+          break;
+        case "FF":
+          lfUpper = Math.min(lfUpper, bLf - lagDays2);
+          break;
+        case "SF":
+          lsUpper = Math.min(lsUpper, bLf - lagDays2);
+          break;
+      }
+    }
+    let lfVal = lfUpper;
+    let lsVal = lfVal - dur;
+    if (lsUpper < lsVal) {
+      lsVal = lsUpper;
+      lfVal = lsVal + dur;
+    }
+    lf.set(id, lfVal);
+    ls.set(id, lsVal);
+  }
+  const criticalPath = [];
+  if (endId !== null) {
+    let cursor = endId;
+    while (cursor !== null) {
+      criticalPath.unshift(cursor);
+      const preds = predecessors.get(cursor) ?? [];
+      if (preds.length === 0) break;
+      let bestPred = null;
+      let bestEf = -Infinity;
+      for (const pid of preds) {
+        const efp = ef.get(pid);
+        if (efp != null && efp > bestEf) {
+          bestEf = efp;
+          bestPred = pid;
+        }
+      }
+      cursor = bestPred;
+    }
+  }
+  const criticalSet = new Set(criticalPath);
+  let projectSigmaDays = null;
+  if (projectMuDays !== null && criticalPath.length > 0) {
+    let varSum = 0;
+    for (const id of criticalPath) {
+      const exp = expandedById.get(id);
+      if (exp) varSum += exp.sigma * exp.sigma;
+    }
+    projectSigmaDays = Math.sqrt(varSum);
+  }
+  const unit = parsed.options.timeUnit;
+  const resolvedActivities = activities.map((a) => {
+    const exp = expandedById.get(a.id);
+    const slackDays = ls.get(a.id) !== null && es.get(a.id) !== null ? ls.get(a.id) - es.get(a.id) : null;
+    return {
+      activity: a,
+      es: nullableToUnit(es.get(a.id) ?? null, unit, sprintDays),
+      ef: nullableToUnit(ef.get(a.id) ?? null, unit, sprintDays),
+      ls: nullableToUnit(ls.get(a.id) ?? null, unit, sprintDays),
+      lf: nullableToUnit(lf.get(a.id) ?? null, unit, sprintDays),
+      slack: nullableToUnit(slackDays, unit, sprintDays),
+      isCriticalPath: criticalSet.has(a.id),
+      mu: exp ? fromDays(exp.mean, unit, sprintDays) : null,
+      sigma: exp ? fromDays(exp.sigma, unit, sprintDays) : null,
+      criticality: null,
+      isAuthored: a.duration !== null && !a.duration.mOnly && !a.isMilestone
+    };
+  });
+  let monteCarloResult = null;
+  const dataDrivenMC = activities.some((a) => hasDuration(a));
+  const trialsClamped = dataDrivenMC && parsed.options.trials < 100;
+  let mode = dataDrivenMC && !trialsClamped ? "monte-carlo" : "analytical";
+  if (mode === "monte-carlo") {
+    const allTerminalsPoisoned = activities.filter((a) => (successors.get(a.id) ?? []).length === 0).every((a) => poisoned.has(a.id));
+    if (allTerminalsPoisoned && activities.length > 0) {
+      mode = "analytical";
+    } else {
+      const expandedArr = [];
+      for (const a of activities) {
+        const exp = expandedById.get(a.id);
+        if (exp) expandedArr.push({ id: a.id, o: exp.o, m: exp.m, p: exp.p });
+      }
+      const prelim = {
+        options: parsed.options,
+        activities: resolvedActivities,
+        edges: edges.slice(),
+        groups: [],
+        tagGroups: parsed.tagGroups.slice(),
+        mode: "monte-carlo",
+        summaryRows: null,
+        projectSubtitle: null,
+        projectMu: null,
+        projectSigma: null,
+        criticalPath,
+        projectStart: null,
+        monteCarloResult: null,
+        expandedActivities: expandedArr,
+        diagnostics: [],
+        error: null
+      };
+      monteCarloResult = simulateCanonical(prelim, expandedArr, {
+        trials: parsed.options.trials,
+        seed: parsed.options.seed
+      });
+      for (const ra of resolvedActivities) {
+        if (poisoned.has(ra.activity.id)) continue;
+        const c = monteCarloResult.criticalityByActivity[ra.activity.id];
+        ra.criticality = typeof c === "number" ? c : null;
+      }
+      monteCarloResult.tornadoSwings = computeTornadoSwings(
+        activities,
+        topo,
+        incomingEdges,
+        expandedById,
+        poisoned,
+        monteCarloResult.criticalityByActivity,
+        sprintDays
+      );
+    }
+  }
+  const rollupSet = monteCarloResult && monteCarloResult.modalCriticalPath.length > 0 ? new Set(monteCarloResult.modalCriticalPath) : criticalSet;
+  const resolvedById = new Map(
+    resolvedActivities.map((r) => [r.activity.id, r])
+  );
+  const resolvedGroups = parsed.groups.map(
+    (g) => rollupGroup(g, expandedById, resolvedById, rollupSet, unit, sprintDays)
+  );
+  const publicExpanded = [];
+  for (const a of activities) {
+    const exp = expandedById.get(a.id);
+    if (exp) publicExpanded.push({ id: a.id, o: exp.o, m: exp.m, p: exp.p });
+  }
+  const projectMuOut = projectMuDays === null ? null : fromDays(projectMuDays, unit, sprintDays);
+  const projectSigmaOut = projectSigmaDays === null ? null : fromDays(projectSigmaDays, unit, sprintDays);
+  let projectStart = null;
+  const anchor = parsed.options.anchor;
+  if (anchor !== null) {
+    if (anchor.kind === "forward") {
+      projectStart = anchor.date;
+    } else if (anchor.kind === "backward" && projectMuDays !== null) {
+      projectStart = addCalendarDays(anchor.date, -projectMuDays);
+    }
+  }
+  const summaryRows = buildSummary({
+    mode,
+    projectMu: projectMuOut,
+    projectSigma: projectSigmaOut,
+    unit,
+    parsedActivities: activities,
+    monteCarloResult,
+    trialsClamped,
+    anchor: parsed.options.anchor,
+    today: parsed.options.today,
+    ...sprintDays !== void 0 && { sprintDays }
+  });
+  const projectSubtitle = buildProjectSubtitle({
+    projectMu: projectMuOut,
+    projectSigma: projectSigmaOut,
+    unit,
+    anchor: parsed.options.anchor
+  });
+  return {
+    options: parsed.options,
+    activities: resolvedActivities,
+    edges: edges.slice(),
+    groups: resolvedGroups,
+    tagGroups: parsed.tagGroups.slice(),
+    mode,
+    summaryRows,
+    projectSubtitle,
+    projectMu: projectMuOut,
+    projectSigma: projectSigmaOut,
+    criticalPath,
+    projectStart,
+    monteCarloResult,
+    expandedActivities: publicExpanded,
+    diagnostics,
+    error: parsed.error ?? firstFatal(diagnostics)
+  };
+}
+function hasDuration(a) {
+  if (a.duration === null || a.isMilestone) return false;
+  if (a.duration.mOnly) return a.duration.m.amount > 0;
+  return true;
+}
+function computeProjectEndDays(activities, topo, incomingEdges, durations, poisoned, sprintDays) {
+  const es = /* @__PURE__ */ new Map();
+  const ef = /* @__PURE__ */ new Map();
+  for (const id of topo) {
+    const dur = poisoned.has(id) ? 0 : durations.get(id) ?? 0;
+    let esLower = 0;
+    let efLower = -Infinity;
+    for (const edge of incomingEdges.get(id) ?? []) {
+      const aEs = es.get(edge.source) ?? 0;
+      const aEf = ef.get(edge.source) ?? 0;
+      const lag = edge.lag ? toDays(edge.lag, sprintDays) : 0;
+      switch (edge.type) {
+        case "FS":
+          esLower = Math.max(esLower, aEf + lag);
+          break;
+        case "SS":
+          esLower = Math.max(esLower, aEs + lag);
+          break;
+        case "FF":
+          efLower = Math.max(efLower, aEf + lag);
+          break;
+        case "SF":
+          efLower = Math.max(efLower, aEs + lag);
+          break;
+      }
+    }
+    let esVal = esLower;
+    let efVal = esVal + dur;
+    if (efLower > efVal) {
+      efVal = efLower;
+      esVal = efVal - dur;
+    }
+    es.set(id, esVal);
+    ef.set(id, efVal);
+  }
+  let projectEnd = 0;
+  for (const a of activities) {
+    const e = ef.get(a.id) ?? 0;
+    if (e > projectEnd) projectEnd = e;
+  }
+  return projectEnd;
+}
+function computeTornadoSwings(activities, topo, incomingEdges, expandedById, poisoned, criticalityByActivity, sprintDays) {
+  const meansById = /* @__PURE__ */ new Map();
+  for (const a of activities) {
+    if (poisoned.has(a.id)) continue;
+    const exp = expandedById.get(a.id);
+    if (exp) meansById.set(a.id, exp.mean);
+  }
+  const baseline = computeProjectEndDays(
+    activities,
+    topo,
+    incomingEdges,
+    meansById,
+    poisoned,
+    sprintDays
+  );
+  const swings = [];
+  for (const a of activities) {
+    if (a.isMilestone || a.duration === null || poisoned.has(a.id)) continue;
+    const exp = expandedById.get(a.id);
+    if (!exp) continue;
+    if (exp.o === exp.m && exp.p === exp.m) continue;
+    const lowMap = new Map(meansById);
+    lowMap.set(a.id, exp.o);
+    const lowEnd = computeProjectEndDays(
+      activities,
+      topo,
+      incomingEdges,
+      lowMap,
+      poisoned,
+      sprintDays
+    );
+    const highMap = new Map(meansById);
+    highMap.set(a.id, exp.p);
+    const highEnd = computeProjectEndDays(
+      activities,
+      topo,
+      incomingEdges,
+      highMap,
+      poisoned,
+      sprintDays
+    );
+    const lowSwing = Math.max(0, baseline - lowEnd);
+    const highSwing = Math.max(0, highEnd - baseline);
+    if (lowSwing === 0 && highSwing === 0) continue;
+    const c = criticalityByActivity[a.id];
+    swings.push({
+      id: a.id,
+      name: a.name,
+      lowSwing,
+      highSwing,
+      criticality: typeof c === "number" ? c : null
+    });
+  }
+  swings.sort((a, b) => b.lowSwing + b.highSwing - (a.lowSwing + a.highSwing));
+  return swings;
+}
+function nullableToUnit(value, unit, sprintDays) {
+  return value === null ? null : fromDays(value, unit, sprintDays);
+}
+function firstFatal(diagnostics) {
+  const f = diagnostics.find((d) => d.severity === "error");
+  return f ? f.message : null;
+}
+function rollupGroup(group, expandedById, resolvedById, criticalSet, unit, sprintDays) {
+  let muDays = 0;
+  let varDays = 0;
+  let usable = false;
+  for (const id of group.activityIds) {
+    if (!criticalSet.has(id)) continue;
+    const exp = expandedById.get(id);
+    if (!exp) continue;
+    muDays += exp.mean;
+    varDays += exp.sigma * exp.sigma;
+    usable = true;
+  }
+  let es = null;
+  let ef = null;
+  let ls = null;
+  let lf = null;
+  let criticality = null;
+  for (const id of group.activityIds) {
+    const r = resolvedById.get(id);
+    if (!r) continue;
+    if (r.es !== null) es = es === null ? r.es : Math.min(es, r.es);
+    if (r.ef !== null) ef = ef === null ? r.ef : Math.max(ef, r.ef);
+    if (r.ls !== null) ls = ls === null ? r.ls : Math.min(ls, r.ls);
+    if (r.lf !== null) lf = lf === null ? r.lf : Math.max(lf, r.lf);
+    if (r.criticality !== null) {
+      criticality = criticality === null ? r.criticality : Math.max(criticality, r.criticality);
+    }
+  }
+  const slack = ls !== null && es !== null ? ls - es : null;
+  return {
+    group,
+    rolledMu: usable ? fromDays(muDays, unit, sprintDays) : null,
+    rolledSigma: usable ? fromDays(Math.sqrt(varDays), unit, sprintDays) : null,
+    entries: [],
+    exits: [],
+    es,
+    ef,
+    ls,
+    lf,
+    slack,
+    criticality
+  };
+}
+function roundConservative(durationDays, _mode) {
+  return Math.ceil(durationDays);
+}
+function buildSummary(input) {
+  const {
+    mode,
+    projectMu,
+    projectSigma,
+    unit,
+    parsedActivities,
+    monteCarloResult,
+    trialsClamped,
+    sprintDays,
+    today
+  } = input;
+  const anchor = input.anchor ?? null;
+  if (parsedActivities.length === 0) return null;
+  if (projectMu === null) {
+    if (anchor?.kind === "backward") {
+      return [
+        { text: "Expected duration: ?", level: 0 },
+        { text: "P50 latest-safe start: ?", level: 0 },
+        { text: "P80 latest-safe start: ?", level: 0 },
+        { text: "P95 latest-safe start: ?", level: 0 }
+      ];
+    }
+    const tbdCount = parsedActivities.filter(
+      (a) => a.duration === null && !a.isMilestone
+    ).length;
+    return [
+      {
+        text: `Expected duration unknown \u2014 ${tbdCount} ${tbdCount === 1 ? "activity has" : "activities have"} no estimate.`,
+        level: 0
+      }
+    ];
+  }
+  const rows = [];
+  const mc = mode === "monte-carlo" && monteCarloResult !== null;
+  const sigmaPositive = projectSigma !== null && projectSigma > 0;
+  const showMcDetail = mc && sigmaPositive;
+  const sigmaParen = showMcDetail ? ` (\xB1 ${roundForCaption(projectSigma)} ${pluralizeUnit(projectSigma, unit)})` : "";
+  if (anchor?.kind === "forward") {
+    const projectMuDays = projectMu * unitToDays(unit);
+    rows.push({
+      text: `Expected finish: ${addCalendarDays(anchor.date, projectMuDays)}${sigmaParen}.`,
+      level: 0
+    });
+  } else if (anchor?.kind === "backward") {
+    const projectMuDays = projectMu * unitToDays(unit);
+    rows.push({
+      text: `Expected start: ${addCalendarDays(anchor.date, -projectMuDays)}${sigmaParen}.`,
+      level: 0
+    });
+  } else {
+    const muStr = `${roundForCaption(projectMu)} ${pluralizeUnit(projectMu, unit)}`;
+    rows.push({
+      text: `Expected duration: ${muStr}${sigmaParen}.`,
+      level: 0
+    });
+  }
+  if (showMcDetail) {
+    const percentiles = [
+      { pct: 50, days: monteCarloResult.p50 },
+      { pct: 80, days: monteCarloResult.p80 },
+      { pct: 95, days: monteCarloResult.p95 }
+    ];
+    if (anchor?.kind === "forward") {
+      for (const { pct, days } of percentiles) {
+        const offsetDays = roundConservative(days, "forward");
+        const date = addCalendarDays(anchor.date, offsetDays);
+        rows.push({ text: `P${pct} finish: ${date}.`, level: 1 });
+      }
+    } else if (anchor?.kind === "backward") {
+      for (const { pct, days } of percentiles) {
+        const offsetDays = roundConservative(days, "backward");
+        const date = addCalendarDays(anchor.date, -offsetDays);
+        const isPast = today.length > 0 && date < today;
+        const suffix = isPast ? " (latest-safe start has passed)" : "";
+        const row = {
+          text: `P${pct} latest-safe start: ${date}${suffix}`,
+          level: 1
+        };
+        if (isPast) row.isPast = true;
+        rows.push(row);
+      }
+    } else {
+      for (const { pct, days } of percentiles) {
+        const v = fromDays(days, unit, sprintDays);
+        rows.push({ text: `P${pct}: ${formatPercentile(v, unit)}.`, level: 1 });
+      }
+    }
+  }
+  if (mc && projectSigma === 0) {
+    const filtered = rows.filter(
+      (r) => r.text.startsWith("Expected ")
+    );
+    filtered.push({
+      text: "(No variance in estimates \u2014 all activities have O = M = P.)",
+      level: 0
+    });
+    return filtered;
+  }
+  if (trialsClamped) {
+    rows.push({
+      text: "Insufficient trials configured (`trials` < 100) \u2014 falling back to deterministic analysis.",
+      level: 0
+    });
+  }
+  return rows;
+}
+function buildProjectSubtitle(input) {
+  const anchor = input.anchor ?? null;
+  const { projectMu, projectSigma, unit } = input;
+  const sigmaPositive = projectSigma !== null && projectSigma > 0;
+  const sigmaParen = sigmaPositive ? ` (\xB1 ${roundForCaption(projectSigma)})` : "";
+  if (projectMu === null) {
+    if (anchor?.kind === "forward") {
+      return `Expected finish: ? \xB7 \u2248 ? ${pluralizeUnit(2, unit)} of work`;
+    }
+    if (anchor?.kind === "backward") {
+      return `Expected start: ? \xB7 \u2248 ? ${pluralizeUnit(2, unit)} lead time`;
+    }
+    return `\u2248 ? ${pluralizeUnit(2, unit)}`;
+  }
+  const muStr = `${roundForCaption(projectMu)} ${pluralizeUnit(projectMu, unit)}`;
+  if (anchor?.kind === "forward") {
+    const projectMuDays = projectMu * unitToDays(unit);
+    return `Expected finish: ${addCalendarDays(anchor.date, projectMuDays)} \xB7 \u2248 ${muStr} of work${sigmaParen}`;
+  }
+  if (anchor?.kind === "backward") {
+    const projectMuDays = projectMu * unitToDays(unit);
+    return `Expected start: ${addCalendarDays(anchor.date, -projectMuDays)} \xB7 \u2248 ${muStr} lead time${sigmaParen}`;
+  }
+  return `\u2248 ${muStr}${sigmaParen}`;
+}
+function roundForCaption(n) {
+  let rounded;
+  const abs = Math.abs(n);
+  if (abs < 10) rounded = Math.round(n * 100) / 100;
+  else if (abs < 100) rounded = Math.round(n * 10) / 10;
+  else rounded = Math.round(n);
+  const str = rounded.toString();
+  return str.includes(".") ? str.replace(/\.?0+$/, "") : str;
+}
+var UNIT_WORDS = {
+  min: ["minute", "minutes"],
+  h: ["hour", "hours"],
+  d: ["day", "days"],
+  bd: ["business day", "business days"],
+  w: ["week", "weeks"],
+  m: ["month", "months"],
+  q: ["quarter", "quarters"],
+  y: ["year", "years"],
+  s: ["sprint", "sprints"]
+};
+function pluralizeUnit(value, unit) {
+  const [singular, plural] = UNIT_WORDS[unit];
+  return roundForCaption(value) === "1" ? singular : plural;
+}
+function formatPercentile(value, unit) {
+  return `${roundForCaption(value)} ${pluralizeUnit(value, unit)}`;
+}
+function emptyResolved(parsed, diagnostics) {
+  return {
+    options: parsed.options,
+    activities: parsed.activities.map((a) => ({
+      activity: a,
+      es: null,
+      ef: null,
+      ls: null,
+      lf: null,
+      slack: null,
+      isCriticalPath: false,
+      mu: null,
+      sigma: null,
+      criticality: null,
+      isAuthored: false
+    })),
+    edges: parsed.edges.slice(),
+    groups: parsed.groups.map((g) => ({
+      group: g,
+      rolledMu: null,
+      rolledSigma: null,
+      entries: [],
+      exits: [],
+      es: null,
+      ef: null,
+      ls: null,
+      lf: null,
+      slack: null,
+      criticality: null
+    })),
+    tagGroups: parsed.tagGroups.slice(),
+    mode: "analytical",
+    summaryRows: null,
+    projectSubtitle: null,
+    projectMu: null,
+    projectSigma: null,
+    criticalPath: [],
+    projectStart: null,
+    monteCarloResult: null,
+    expandedActivities: [],
+    diagnostics,
+    error: firstFatal(diagnostics) ?? parsed.error
+  };
+}
+
+export {
+  mulberry32,
+  sampleBetaPert,
+  buildSimulationContext,
+  simulateCanonical,
+  simulateFast,
+  analyzePert,
+  buildSummary,
+  buildProjectSubtitle
+};
+//# sourceMappingURL=chunk-NX4EQS3U.js.map