@diagrammo/dgmo 0.15.0 → 0.15.1

package/dist/pert.js

@@ -0,0 +1,294 @@
+// src/pert/internal.ts
+var UNIT_TO_DAYS_LOCAL = {
+  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
+  // sprint (14 calendar days) — not seconds
+};
+function unitToDays(unit) {
+  return UNIT_TO_DAYS_LOCAL[unit];
+}
+
+// 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);
+}
+export {
+  buildSimulationContext,
+  mulberry32,
+  sampleBetaPert,
+  simulateCanonical,
+  simulateFast
+};
+//# sourceMappingURL=pert.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@diagrammo/dgmo",
-  "version": "0.15.0",
+  "version": "0.15.1",
   "description": "DGMO diagram markup language — parser, renderer, and color system",
   "license": "MIT",
   "repository": {
@@ -9,6 +9,9 @@
   },
   "homepage": "https://github.com/diagrammo/dgmo#readme",
   "type": "module",
+  "engines": {
+    "node": ">=20.6"
+  },
   "bin": {
     "dgmo": "dist/cli.cjs"
   },
@@ -46,6 +49,16 @@
         "default": "./dist/highlight.cjs"
       }
     },
+    "./advanced": {
+      "import": {
+        "types": "./dist/advanced.d.ts",
+        "default": "./dist/advanced.js"
+      },
+      "require": {
+        "types": "./dist/advanced.d.cts",
+        "default": "./dist/advanced.cjs"
+      }
+    },
     "./internal": {
       "import": {
         "types": "./dist/internal.d.ts",
@@ -56,6 +69,16 @@
         "default": "./dist/internal.cjs"
       }
     },
+    "./pert": {
+      "import": {
+        "types": "./dist/pert.d.ts",
+        "default": "./dist/pert.js"
+      },
+      "require": {
+        "types": "./dist/pert.d.cts",
+        "default": "./dist/pert.cjs"
+      }
+    },
     "./auto": {
       "import": {
         "types": "./dist/auto.d.ts",
@@ -96,7 +119,7 @@
     "typecheck": "tsc --noEmit",
     "dev": "tsup --watch",
     "pretest": "pnpm codegen",
-    "test": "vitest run",
+    "test": "vitest run --coverage",
     "test:watch": "vitest",
     "test:auto": "pnpm build && vitest run tests/auto.test.ts tests/safe-href.test.ts",
     "sri": "node scripts/sri.mjs",
@@ -111,7 +134,7 @@
     "check:deadcode": "knip",
     "check:spelling": "cspell \"src/**/*.ts\" \"tests/**/*.ts\"",
     "check:all": "pnpm check:deadcode && pnpm check:spelling && pnpm check:duplication && pnpm check:circular && pnpm check:deps && pnpm check:security && pnpm build && pnpm check:publish && pnpm check:types",
-    "check:circular": "madge --circular --extensions ts src/ --json | node -e \"const c=JSON.parse(require('fs').readFileSync('/dev/stdin','utf8')); const n=c.length; if(n>10){console.error('New circular deps found ('+n+' > 10 known type-only cycles)');process.exit(1)}else if(n>0){console.log(n+' known type-only/dynamic cycles (safe)')}else{console.log('No circular dependencies')}\"",
+    "check:circular": "madge --circular --extensions ts src/ --json | node -e \"const c=JSON.parse(require('fs').readFileSync('/dev/stdin','utf8')); const n=c.length; if(n>4){console.error('New circular deps found ('+n+' > 4 known type-only cycles)');process.exit(1)}else if(n>0){console.log(n+' known type-only/dynamic cycles (safe)')}else{console.log('No circular dependencies')}\"",
     "check:deps": "depcheck --ignores='@codemirror/language,@lezer/*,husky,lint-staged,tsup,axe-core'",
     "check:security": "pnpm audit --prod",
     "check:publish": "publint",
@@ -130,6 +153,7 @@
     "d3-selection": "^3.0.0",
     "d3-shape": "^3.2.0",
     "echarts": "^6.0.0",
+    "elkjs": "^0.11.1",
     "jsdom": "^29.0.2",
     "lz-string": "^1.5.0"
   },
@@ -145,6 +169,7 @@
     "@types/d3-selection": "^3.0.11",
     "@types/d3-shape": "^3.1.8",
     "@types/jsdom": "^28.0.1",
+    "@vitest/coverage-v8": "^4.1.6",
     "axe-core": "^4.10.0",
     "cspell": "^10.0.0",
     "depcheck": "^1.4.7",