@aranzatech/diagrams-bpmn 0.2.10 → 0.2.11

package/CHANGELOG.md

@@ -2,6 +2,31 @@
 
 ## Unreleased
 
+## 0.3.0
+
+### Batch process simulation
+
+New public API for running synthetic batch simulations directly on a BPMN diagram
+without an external engine. Enables bottleneck detection, heatmap overlays, and
+operational capacity projections from inside the modeler.
+
+**New exports (root `@aranzatech/diagrams-bpmn`)**
+
+- `runBatchSimulation(diagram, config)` — runs `N` process instances synchronously
+  and aggregates per-node statistics. Designed to be called from a Web Worker for
+  large `N` to keep the main thread unblocked.
+
+**New types**
+
+- `BatchSimConfig` — `instances`, `gatewayWeights`, `nodeDurations`, `maxSteps`
+- `BatchSimResult` — `total`, `completed`, `deadlocked`, `avgSteps`, `nodeStats`
+- `NodeSimStats` — `visits`, `totalDurationMs`, `peakConcurrency` per node
+- `GatewayWeights` — edge-id → relative weight map for exclusive / inclusive gateways
+
+Gateway weights are normalised internally; edges absent from the map default to
+weight `1`. `nodeDurations` drive `totalDurationMs` (visits × duration), enabling
+duration-based heatmaps and daily workload projections.
+
 ## 0.2.7
 
 ### XML round-trip improvements

package/dist/index.cjs

@@ -4054,6 +4054,130 @@ function isCompleted(state) {
 function setVariable(state, key, value) {
   return { ...state, variables: { ...state.variables, [key]: value } };
 }
+
+// src/simulation/batch.ts
+function weightedChoice(edgeIds, weights) {
+  if (edgeIds.length === 0) return "";
+  const w = edgeIds.map((id) => Math.max(0, weights[id] ?? 1));
+  const total = w.reduce((a, b) => a + b, 0);
+  if (total === 0) return edgeIds[0];
+  let r = Math.random() * total;
+  for (let i = 0; i < edgeIds.length; i++) {
+    r -= w[i];
+    if (r <= 0) return edgeIds[i];
+  }
+  return edgeIds[edgeIds.length - 1];
+}
+function buildBatchDiagram(diagram, gatewayWeights, gwVarMap) {
+  const patchedEdges = diagram.edges.map((edge) => {
+    const gwId = edge.source;
+    if (!(gwId in gatewayWeights) || edge.type !== "sequenceFlow") return edge;
+    const varName = gwVarMap[gwId];
+    const outEdges = diagram.edges.filter(
+      (e) => e.source === gwId && e.type === "sequenceFlow"
+    );
+    const idx = outEdges.findIndex((e) => e.id === edge.id);
+    if (idx === -1) return edge;
+    return {
+      ...edge,
+      conditionExpression: `\${${varName} == ${idx}}`,
+      isDefault: false
+    };
+  });
+  return { nodes: diagram.nodes, edges: patchedEdges };
+}
+function runOneInstance(diagram, initialVars, maxSteps) {
+  let state = createSimulation(diagram, initialVars);
+  state = tick(diagram, state);
+  const visitedNodes = /* @__PURE__ */ new Set();
+  const peakPerNode = {};
+  function snapshot() {
+    const counts = {};
+    for (const token of state.tokens) {
+      visitedNodes.add(token.elementId);
+      counts[token.elementId] = (counts[token.elementId] ?? 0) + 1;
+    }
+    for (const [nodeId, c] of Object.entries(counts)) {
+      if (c > (peakPerNode[nodeId] ?? 0)) peakPerNode[nodeId] = c;
+    }
+  }
+  snapshot();
+  let steps = 0;
+  while (state.status === "running" && steps < maxSteps) {
+    const fireable = getFireable(diagram, state);
+    if (fireable.length === 0) break;
+    for (const id of fireable) {
+      if (state.status !== "running") break;
+      state = fire(diagram, state, id);
+      snapshot();
+    }
+    steps++;
+  }
+  for (const entry of state.log) {
+    visitedNodes.add(entry.elementId);
+  }
+  return {
+    visitedNodes,
+    peakPerNode,
+    steps: state.step,
+    completed: state.status === "completed"
+  };
+}
+function runBatchSimulation(diagram, config = {}) {
+  const n = Math.max(1, config.instances ?? 100);
+  const maxSteps = Math.max(1, config.maxSteps ?? 500);
+  const gwWeights = config.gatewayWeights ?? {};
+  const nodeDurations = config.nodeDurations ?? {};
+  const gwVarMap = {};
+  Object.keys(gwWeights).forEach((gwId, i) => {
+    gwVarMap[gwId] = `__g${i}`;
+  });
+  const batchDiagram = Object.keys(gwWeights).length > 0 ? buildBatchDiagram(diagram, gwWeights, gwVarMap) : diagram;
+  const nodeStats = {};
+  function node(id) {
+    if (!nodeStats[id]) {
+      nodeStats[id] = { visits: 0, totalDurationMs: 0, peakConcurrency: 0 };
+    }
+    return nodeStats[id];
+  }
+  let completed = 0;
+  let deadlocked = 0;
+  let totalSteps = 0;
+  for (let i = 0; i < n; i++) {
+    const instanceVars = {};
+    for (const [gwId, varName] of Object.entries(gwVarMap)) {
+      const outEdges = diagram.edges.filter(
+        (e) => e.source === gwId && e.type === "sequenceFlow"
+      );
+      const edgeIds = outEdges.map((e) => e.id);
+      const chosen = weightedChoice(edgeIds, gwWeights[gwId]);
+      instanceVars[varName] = outEdges.findIndex((e) => e.id === chosen);
+    }
+    const result = runOneInstance(batchDiagram, instanceVars, maxSteps);
+    if (result.completed) {
+      completed++;
+      totalSteps += result.steps;
+    } else {
+      deadlocked++;
+    }
+    for (const nodeId of result.visitedNodes) {
+      const s = node(nodeId);
+      s.visits++;
+      s.totalDurationMs += nodeDurations[nodeId] ?? 0;
+    }
+    for (const [nodeId, peak] of Object.entries(result.peakPerNode)) {
+      const s = node(nodeId);
+      if (peak > s.peakConcurrency) s.peakConcurrency = peak;
+    }
+  }
+  return {
+    nodeStats,
+    completed,
+    deadlocked,
+    total: n,
+    avgSteps: completed > 0 ? Math.round(totalSteps / completed) : 0
+  };
+}
 function createBpmnNode(options) {
   const size = getBpmnElementSize(options.elementType);
   const meta = BPMN_ELEMENT_CATALOG[options.elementType];
@@ -4997,6 +5121,7 @@ exports.resizeBpmnNodeByHandleCommand = resizeBpmnNodeByHandleCommand;
 exports.resizeBpmnNodeCommand = resizeBpmnNodeCommand;
 exports.restoreBpmnHistory = restoreBpmnHistory;
 exports.routeBpmnEdgeCommand = routeBpmnEdgeCommand;
+exports.runBatchSimulation = runBatchSimulation;
 exports.runBpmnCommand = runBpmnCommand;
 exports.runBpmnCommands = runBpmnCommands;
 exports.selectBpmnElementsCommand = selectBpmnElementsCommand;