@diagrammo/dgmo 0.45.0 → 0.47.0

package/dist/chunk-A44USUV7.js

@@ -0,0 +1,923 @@
+// src/infra/compute.ts
+function getNumProp(node, key, fallback) {
+  const prop = node.properties.find((p) => p.key === key);
+  if (!prop) return fallback;
+  if (typeof prop.value === "number") return prop.value;
+  const num = parseFloat(String(prop.value));
+  return isNaN(num) ? fallback : num;
+}
+function getInstanceRange(node) {
+  const prop = node.properties.find((p) => p.key === "instances");
+  if (!prop) return { min: 1, max: 1 };
+  if (typeof prop.value === "number")
+    return { min: prop.value, max: prop.value };
+  const str = String(prop.value);
+  const dash = str.indexOf("-");
+  if (dash >= 0) {
+    const min = parseInt(str.substring(0, dash), 10);
+    const max = parseInt(str.substring(dash + 1), 10);
+    return { min: isNaN(min) ? 1 : min, max: isNaN(max) ? min : max };
+  }
+  const num = parseInt(str, 10);
+  return { min: isNaN(num) ? 1 : num, max: isNaN(num) ? 1 : num };
+}
+function isServerless(node) {
+  return getNumProp(node, "concurrency", 0) > 0;
+}
+function isQueue(node) {
+  return getNumProp(node, "buffer", 0) > 0;
+}
+function serverlessCapacity(node) {
+  const concurrency = getNumProp(node, "concurrency", 0);
+  const durationMs = getNumProp(node, "duration-ms", 100);
+  return concurrency / (durationMs / 1e3);
+}
+function computeDynamicInstances(node, computedRps) {
+  const { min, max } = getInstanceRange(node);
+  const maxRps = getNumProp(node, "max-rps", 0);
+  if (maxRps <= 0 || min === max) return min;
+  const needed = Math.ceil(computedRps / maxRps);
+  return Math.min(Math.max(needed, min), max);
+}
+function computeCbState(node, computedRps, computedLatencyMs, instanceOverride, groupMultiplier = 1) {
+  const errorThreshold = getNumProp(node, "cb-error-threshold", 0);
+  const latencyThreshold = getNumProp(node, "cb-latency-threshold-ms", 0);
+  if (errorThreshold <= 0 && latencyThreshold <= 0) return "closed";
+  let capacity;
+  if (isServerless(node)) {
+    capacity = serverlessCapacity(node);
+  } else {
+    const maxRps = getNumProp(node, "max-rps", 0);
+    const instances = instanceOverride ?? computeDynamicInstances(node, computedRps);
+    capacity = maxRps > 0 ? maxRps * instances * groupMultiplier : 0;
+  }
+  if (errorThreshold > 0 && capacity > 0) {
+    const errorRate = computedRps > capacity ? (computedRps - capacity) / computedRps * 100 : 0;
+    if (errorRate >= errorThreshold) return "open";
+  }
+  if (latencyThreshold > 0 && computedLatencyMs > latencyThreshold)
+    return "open";
+  return "closed";
+}
+function computeLocalAvailability(node, inboundRps, instanceOverride, groupMultiplier = 1, defaultUptime = 100) {
+  if (node.isEdge) return 1;
+  let avail = 1;
+  const uptime = getNumProp(node, "uptime", defaultUptime) / 100;
+  avail *= uptime;
+  if (isQueue(node)) {
+    const buffer = getNumProp(node, "buffer", 0);
+    const drainRate = getNumProp(node, "drain-rate", 0) * groupMultiplier;
+    if (drainRate > 0 && buffer > 0) {
+      const fillRate = Math.max(0, inboundRps - drainRate);
+      if (fillRate > 0) {
+        const timeToOverflow = buffer / fillRate;
+        if (timeToOverflow < 60) {
+          avail *= drainRate / inboundRps;
+        }
+      }
+    }
+    return avail;
+  }
+  if (isServerless(node)) {
+    const capacity = serverlessCapacity(node);
+    if (capacity > 0 && inboundRps > capacity) {
+      avail *= capacity / inboundRps;
+    }
+  } else {
+    const maxRps = getNumProp(node, "max-rps", 0);
+    if (maxRps > 0 && inboundRps > 0) {
+      const instances = instanceOverride ?? computeDynamicInstances(node, inboundRps);
+      const capacity = maxRps * instances * groupMultiplier;
+      if (inboundRps > capacity) {
+        avail *= capacity / inboundRps;
+      }
+    }
+  }
+  const rateLimit = getNumProp(node, "ratelimit-rps", 0);
+  if (rateLimit > 0 && inboundRps > 0) {
+    let preRateLimitRps = inboundRps;
+    const cacheHit = getNumProp(node, "cache-hit", 0);
+    if (cacheHit > 0) preRateLimitRps *= (100 - cacheHit) / 100;
+    const fwBlock = getNumProp(node, "firewall-block", 0);
+    if (fwBlock > 0) preRateLimitRps *= (100 - fwBlock) / 100;
+    if (preRateLimitRps > rateLimit) {
+      avail *= rateLimit / preRateLimitRps;
+    }
+  }
+  return avail;
+}
+function applyBehaviors(node, inboundRps, groupMultiplier = 1) {
+  let rps = inboundRps;
+  const cacheHit = getNumProp(node, "cache-hit", 0);
+  if (cacheHit > 0) rps *= (100 - cacheHit) / 100;
+  const fwBlock = getNumProp(node, "firewall-block", 0);
+  if (fwBlock > 0) rps *= (100 - fwBlock) / 100;
+  const rateLimit = getNumProp(node, "ratelimit-rps", 0);
+  if (rateLimit > 0 && rps > rateLimit) rps = rateLimit;
+  if (isQueue(node)) {
+    const drainRate = getNumProp(node, "drain-rate", 0) * groupMultiplier;
+    if (drainRate > 0 && rps > drainRate) rps = drainRate;
+  }
+  return rps;
+}
+function collapseGroups(parsed, collapsedIds, defaultLatencyMs = 0, defaultUptime = 100) {
+  if (collapsedIds.size === 0)
+    return { parsed, childCapacities: /* @__PURE__ */ new Map(), groupInstances: /* @__PURE__ */ new Map() };
+  const groupChildren = /* @__PURE__ */ new Map();
+  for (const node of parsed.nodes) {
+    if (node.groupId && collapsedIds.has(node.groupId)) {
+      const list = groupChildren.get(node.groupId) ?? [];
+      list.push(node);
+      groupChildren.set(node.groupId, list);
+    }
+  }
+  const childIds = /* @__PURE__ */ new Set();
+  for (const children of groupChildren.values()) {
+    for (const c of children) childIds.add(c.id);
+  }
+  const nodeToGroup = /* @__PURE__ */ new Map();
+  for (const node of parsed.nodes) {
+    if (node.groupId && collapsedIds.has(node.groupId)) {
+      nodeToGroup.set(node.id, node.groupId);
+    }
+  }
+  const internalEdges = /* @__PURE__ */ new Set();
+  const inboundEdges = [];
+  const outboundEdges = [];
+  const crossGroupEdges = [];
+  const otherEdges = [];
+  for (const edge of parsed.edges) {
+    const srcInside = childIds.has(edge.sourceId);
+    const tgtInside = childIds.has(edge.targetId);
+    if (srcInside && tgtInside) {
+      const srcGroup = nodeToGroup.get(edge.sourceId);
+      const tgtGroup = nodeToGroup.get(edge.targetId);
+      if (srcGroup === tgtGroup) {
+        internalEdges.add(edge);
+      } else {
+        crossGroupEdges.push(edge);
+      }
+    } else if (!srcInside && tgtInside) {
+      inboundEdges.push(edge);
+    } else if (srcInside && !tgtInside) {
+      outboundEdges.push(edge);
+    } else {
+      otherEdges.push(edge);
+    }
+  }
+  const virtualNodes = [];
+  const childCapacities = /* @__PURE__ */ new Map();
+  const groupInstancesMap = /* @__PURE__ */ new Map();
+  for (const group of parsed.groups) {
+    if (!collapsedIds.has(group.id)) continue;
+    const children = groupChildren.get(group.id) ?? [];
+    if (children.length === 0) continue;
+    let minEffectiveCapacity = Infinity;
+    let hasMaxRps = false;
+    let composedUptime = 1;
+    const behaviorProps = [];
+    const perChildCapacities = [];
+    const childIdSet = new Set(children.map((c) => c.id));
+    const childLatencies = /* @__PURE__ */ new Map();
+    for (const child of children) {
+      const latencyProp = child.properties.find((p) => p.key === "latency-ms");
+      const childIsServerless = child.properties.some(
+        (p) => p.key === "concurrency"
+      );
+      let childLat;
+      if (childIsServerless) {
+        const durationProp = child.properties.find(
+          (p) => p.key === "duration-ms"
+        );
+        childLat = durationProp ? typeof durationProp.value === "number" ? durationProp.value : parseFloat(String(durationProp.value)) || 100 : 100;
+      } else if (latencyProp) {
+        childLat = typeof latencyProp.value === "number" ? latencyProp.value : parseFloat(String(latencyProp.value)) || 0;
+      } else {
+        childLat = defaultLatencyMs;
+      }
+      childLatencies.set(child.id, childLat);
+      const maxRps = child.properties.find((p) => p.key === "max-rps");
+      if (maxRps) {
+        hasMaxRps = true;
+        const val = typeof maxRps.value === "number" ? maxRps.value : parseFloat(String(maxRps.value)) || 0;
+        const childInstProp = child.properties.find(
+          (p) => p.key === "instances"
+        );
+        const childInst = childInstProp && typeof childInstProp.value === "number" ? childInstProp.value : 1;
+        const effectiveCapacity = val * childInst;
+        if (effectiveCapacity < minEffectiveCapacity)
+          minEffectiveCapacity = effectiveCapacity;
+        perChildCapacities.push(effectiveCapacity);
+      }
+      const uptimeProp = child.properties.find((p) => p.key === "uptime");
+      const uptimeVal = uptimeProp ? typeof uptimeProp.value === "number" ? uptimeProp.value : parseFloat(String(uptimeProp.value)) || 100 : defaultUptime;
+      composedUptime *= uptimeVal / 100;
+      for (const prop of child.properties) {
+        if ([
+          "cache-hit",
+          "firewall-block",
+          "ratelimit-rps",
+          "buffer",
+          "drain-rate",
+          "retention-hours",
+          "partitions",
+          "concurrency",
+          "duration-ms",
+          "cold-start-ms"
+        ].includes(prop.key)) {
+          behaviorProps.push(prop);
+        }
+      }
+    }
+    const entryIds = /* @__PURE__ */ new Set();
+    const exitIds = /* @__PURE__ */ new Set();
+    for (const edge of inboundEdges) {
+      if (childIdSet.has(edge.targetId)) entryIds.add(edge.targetId);
+    }
+    for (const edge of outboundEdges) {
+      if (childIdSet.has(edge.sourceId)) exitIds.add(edge.sourceId);
+    }
+    for (const edge of crossGroupEdges) {
+      if (childIdSet.has(edge.sourceId)) exitIds.add(edge.sourceId);
+      if (childIdSet.has(edge.targetId)) entryIds.add(edge.targetId);
+    }
+    const fwdAdj = /* @__PURE__ */ new Map();
+    for (const edge of internalEdges) {
+      if (!childIdSet.has(edge.sourceId) || !childIdSet.has(edge.targetId))
+        continue;
+      const list = fwdAdj.get(edge.sourceId) ?? [];
+      list.push(edge.targetId);
+      fwdAdj.set(edge.sourceId, list);
+    }
+    const topoOrder = [];
+    const tsVisited = /* @__PURE__ */ new Set();
+    const dfsTopoSort = (id) => {
+      if (tsVisited.has(id)) return;
+      tsVisited.add(id);
+      for (const next of fwdAdj.get(id) ?? []) dfsTopoSort(next);
+      topoOrder.unshift(id);
+    };
+    for (const child of children) dfsTopoSort(child.id);
+    const dist = /* @__PURE__ */ new Map();
+    for (const child of children) {
+      dist.set(
+        child.id,
+        entryIds.has(child.id) ? childLatencies.get(child.id) ?? 0 : -Infinity
+      );
+    }
+    for (const nodeId of topoOrder) {
+      const curDist = dist.get(nodeId) ?? -Infinity;
+      if (curDist === -Infinity) continue;
+      for (const nextId of fwdAdj.get(nodeId) ?? []) {
+        const newDist = curDist + (childLatencies.get(nextId) ?? 0);
+        if (newDist > (dist.get(nextId) ?? -Infinity))
+          dist.set(nextId, newDist);
+      }
+    }
+    let totalLatency = 0;
+    if (exitIds.size > 0) {
+      for (const id of exitIds) {
+        const d = dist.get(id);
+        if (d !== void 0 && d > -Infinity && d > totalLatency)
+          totalLatency = d;
+      }
+    } else if (entryIds.size > 0) {
+      for (const [, d] of dist) {
+        if (d > 0 && d > totalLatency) totalLatency = d;
+      }
+    } else {
+      for (const [, lat] of childLatencies) totalLatency += lat;
+    }
+    const props = [];
+    if (totalLatency > 0)
+      props.push({
+        key: "latency-ms",
+        value: totalLatency,
+        lineNumber: group.lineNumber
+      });
+    const groupInstances = typeof group.instances === "number" ? group.instances : 1;
+    if (hasMaxRps && minEffectiveCapacity < Infinity) {
+      props.push({
+        key: "max-rps",
+        value: Math.round(minEffectiveCapacity * groupInstances),
+        lineNumber: group.lineNumber
+      });
+    }
+    if (composedUptime < 1) {
+      props.push({
+        key: "uptime",
+        value: Math.round(composedUptime * 1e4) / 100,
+        lineNumber: group.lineNumber
+      });
+    }
+    for (const bp of behaviorProps) {
+      if (bp.key === "drain-rate") {
+        const val = typeof bp.value === "number" ? bp.value : parseFloat(String(bp.value)) || 0;
+        props.push({
+          ...bp,
+          value: val * groupInstances,
+          lineNumber: group.lineNumber
+        });
+      } else {
+        props.push({ ...bp, lineNumber: group.lineNumber });
+      }
+    }
+    const tags = {};
+    for (const child of children) {
+      for (const [k, v] of Object.entries(child.tags)) {
+        if (!(k in tags)) tags[k] = v;
+      }
+    }
+    const gInst = typeof group.instances === "number" ? group.instances : 1;
+    groupInstancesMap.set(group.id, gInst);
+    if (perChildCapacities.length > 0) {
+      childCapacities.set(group.id, perChildCapacities);
+    }
+    virtualNodes.push({
+      id: group.id,
+      label: group.label,
+      properties: props,
+      groupId: null,
+      tags,
+      isEdge: false,
+      lineNumber: group.lineNumber
+    });
+  }
+  const rewrittenEdges = [...otherEdges];
+  const seenEdgeKeys = /* @__PURE__ */ new Set();
+  for (const edge of inboundEdges) {
+    const groupId = nodeToGroup.get(edge.targetId);
+    const key = `${edge.sourceId}->${groupId}`;
+    if (seenEdgeKeys.has(key)) continue;
+    seenEdgeKeys.add(key);
+    rewrittenEdges.push({ ...edge, targetId: groupId });
+  }
+  for (const edge of outboundEdges) {
+    const groupId = nodeToGroup.get(edge.sourceId);
+    const key = `${groupId}->${edge.targetId}`;
+    if (seenEdgeKeys.has(key)) continue;
+    seenEdgeKeys.add(key);
+    rewrittenEdges.push({ ...edge, sourceId: groupId });
+  }
+  for (const edge of crossGroupEdges) {
+    const srcGroupId = nodeToGroup.get(edge.sourceId);
+    const tgtGroupId = nodeToGroup.get(edge.targetId);
+    const key = `${srcGroupId}->${tgtGroupId}`;
+    if (seenEdgeKeys.has(key)) continue;
+    seenEdgeKeys.add(key);
+    rewrittenEdges.push({
+      ...edge,
+      sourceId: srcGroupId,
+      targetId: tgtGroupId
+    });
+  }
+  const newNodes = parsed.nodes.filter((n) => !childIds.has(n.id));
+  newNodes.push(...virtualNodes);
+  const newGroups = parsed.groups.filter((g) => !collapsedIds.has(g.id));
+  return {
+    parsed: {
+      ...parsed,
+      nodes: newNodes,
+      edges: rewrittenEdges,
+      groups: newGroups
+    },
+    childCapacities,
+    groupInstances: groupInstancesMap
+  };
+}
+function resolveSplits(outbound, diagnostics) {
+  if (outbound.length === 0) return [];
+  if (outbound.length === 1) {
+    return [{ edge: outbound[0], split: 100 }];
+  }
+  const declared = outbound.filter((e) => e.split !== null);
+  const undeclared = outbound.filter((e) => e.split === null);
+  if (declared.length === outbound.length) {
+    const sum = declared.reduce((s, e) => s + (e.split ?? 0), 0);
+    if (Math.abs(sum - 100) > 0.01) {
+      diagnostics.push({
+        type: "SPLIT_SUM",
+        // In-bounds: declared.length === outbound.length > 1 here.
+        line: declared[0].lineNumber,
+        message: `Split percentages sum to ${sum}%, expected 100%.`
+      });
+    }
+    return declared.map((e) => ({ edge: e, split: e.split }));
+  }
+  if (declared.length === 0) {
+    const even = 100 / outbound.length;
+    return outbound.map((e) => ({ edge: e, split: even }));
+  }
+  const declaredSum = declared.reduce((s, e) => s + (e.split ?? 0), 0);
+  const remainder = 100 - declaredSum;
+  if (remainder < 0) {
+    diagnostics.push({
+      type: "SPLIT_SUM",
+      // In-bounds: this branch runs only when declared.length > 0 (some declared).
+      line: declared[0].lineNumber,
+      message: `Declared splits sum to ${declaredSum}%, exceeding 100%.`
+    });
+  }
+  const evenRemainder = undeclared.length > 0 ? remainder / undeclared.length : 0;
+  return outbound.map((e) => ({
+    edge: e,
+    split: e.split !== null ? e.split : Math.max(0, evenRemainder)
+  }));
+}
+function computeInfra(parsed, params = {}) {
+  const diagnostics = [];
+  const defaultLatencyMs = parseFloat(parsed.options["default-latency-ms"] ?? "") || 0;
+  const defaultUptime = parseFloat(parsed.options["default-uptime"] ?? "") || 100;
+  let effectiveNodes = parsed.nodes;
+  if (params.propertyOverrides) {
+    const propOv = params.propertyOverrides;
+    effectiveNodes = effectiveNodes.map((node) => {
+      const nodeOv = propOv[node.id];
+      if (!nodeOv) return node;
+      const props = node.properties.map((p) => {
+        const ov = nodeOv[p.key];
+        return ov != null ? { ...p, value: ov } : p;
+      });
+      for (const [key, val] of Object.entries(nodeOv)) {
+        if (!props.some((p) => p.key === key)) {
+          props.push({ key, value: val, lineNumber: node.lineNumber });
+        }
+      }
+      return { ...node, properties: props };
+    });
+  }
+  let effectiveParsed = effectiveNodes === parsed.nodes ? parsed : { ...parsed, nodes: effectiveNodes };
+  const collapsedGroups = params.collapsedGroups ?? new Set(parsed.groups.filter((g) => g.collapsed).map((g) => g.id));
+  let collapseChildCaps = /* @__PURE__ */ new Map();
+  let collapseGroupInst = /* @__PURE__ */ new Map();
+  if (collapsedGroups.size > 0) {
+    const cr = collapseGroups(
+      effectiveParsed,
+      collapsedGroups,
+      defaultLatencyMs,
+      defaultUptime
+    );
+    effectiveParsed = cr.parsed;
+    collapseChildCaps = cr.childCapacities;
+    collapseGroupInst = cr.groupInstances;
+  }
+  const nodeMap = /* @__PURE__ */ new Map();
+  for (const node of effectiveParsed.nodes) {
+    nodeMap.set(node.id, node);
+  }
+  const groupChildMap = /* @__PURE__ */ new Map();
+  for (const node of effectiveParsed.nodes) {
+    if (node.groupId) {
+      const children = groupChildMap.get(node.groupId) ?? [];
+      children.push(node.id);
+      groupChildMap.set(node.groupId, children);
+    }
+  }
+  const groupInstMultiplier = /* @__PURE__ */ new Map();
+  for (const group of effectiveParsed.groups) {
+    const gi = typeof group.instances === "number" ? group.instances : typeof group.instances === "string" ? parseInt(group.instances, 10) || 1 : 1;
+    if (gi > 1) {
+      const children = groupChildMap.get(group.id) ?? [];
+      for (const childId of children) {
+        groupInstMultiplier.set(childId, gi);
+      }
+    }
+  }
+  const outboundMap = /* @__PURE__ */ new Map();
+  for (const edge of effectiveParsed.edges) {
+    const list = outboundMap.get(edge.sourceId) ?? [];
+    list.push(edge);
+    outboundMap.set(edge.sourceId, list);
+  }
+  const computedRps = /* @__PURE__ */ new Map();
+  const computedEdgeRps = /* @__PURE__ */ new Map();
+  const computedLatency = /* @__PURE__ */ new Map();
+  const computedUptime = /* @__PURE__ */ new Map();
+  const localAvailability = /* @__PURE__ */ new Map();
+  const edgeNode = effectiveParsed.nodes.find((n) => n.isEdge);
+  const baseRps = params.rps ?? (edgeNode ? getNumProp(edgeNode, "rps", 0) : 0);
+  if (edgeNode) {
+    computedRps.set(edgeNode.id, baseRps);
+    computedLatency.set(edgeNode.id, 0);
+    computedUptime.set(edgeNode.id, 1);
+    const queue = [edgeNode.id];
+    const visited = /* @__PURE__ */ new Set();
+    while (queue.length > 0) {
+      const currentId = queue.shift();
+      if (visited.has(currentId)) continue;
+      visited.add(currentId);
+      const currentNode = nodeMap.get(currentId);
+      if (!currentNode) continue;
+      const inbound = computedRps.get(currentId) ?? 0;
+      const currentLatency = computedLatency.get(currentId) ?? 0;
+      const currentUptime = computedUptime.get(currentId) ?? 1;
+      const nodeLatency = currentNode.isEdge ? 0 : isServerless(currentNode) ? getNumProp(currentNode, "duration-ms", 100) : getNumProp(currentNode, "latency-ms", defaultLatencyMs);
+      const nodeUptime = currentNode.isEdge ? 1 : getNumProp(currentNode, "uptime", defaultUptime) / 100;
+      const cumulativeLatency = currentLatency + nodeLatency;
+      const cumulativeUptime = currentUptime * nodeUptime;
+      const gMul = groupInstMultiplier.get(currentId) ?? 1;
+      const outboundRps = currentNode.isEdge ? inbound : applyBehaviors(currentNode, inbound, gMul);
+      let downstreamLatency = cumulativeLatency;
+      if (isQueue(currentNode)) {
+        const drainRate = getNumProp(currentNode, "drain-rate", 0) * gMul;
+        const fillRate = drainRate > 0 ? Math.max(0, inbound - drainRate) : 0;
+        const waitTimeMs = fillRate > 0 && drainRate > 0 ? fillRate / drainRate * 1e3 : 0;
+        downstreamLatency = waitTimeMs;
+      }
+      const outbound = outboundMap.get(currentId) ?? [];
+      if (outbound.length === 0) continue;
+      const resolved = resolveSplits(outbound, diagnostics);
+      for (const { edge, split } of resolved) {
+        const edgeRps = outboundRps * (split / 100);
+        const fanout = edge.fanout != null && edge.fanout >= 1 ? edge.fanout : 1;
+        const fanoutedRps = edgeRps * fanout;
+        const edgeKey = `${edge.sourceId}->${edge.targetId}`;
+        computedEdgeRps.set(edgeKey, fanoutedRps);
+        let targetIds;
+        const groupChildren = groupChildMap.get(edge.targetId);
+        if (groupChildren && groupChildren.length > 0) {
+          targetIds = groupChildren;
+        } else {
+          targetIds = [edge.targetId];
+        }
+        for (const targetId of targetIds) {
+          const perTarget = fanoutedRps / targetIds.length;
+          const existing = computedRps.get(targetId) ?? 0;
+          computedRps.set(targetId, existing + perTarget);
+          const prevLatency = computedLatency.get(targetId) ?? 0;
+          if (downstreamLatency > prevLatency) {
+            computedLatency.set(targetId, downstreamLatency);
+          }
+          const prevUptime = computedUptime.get(targetId) ?? 1;
+          if (cumulativeUptime < prevUptime) {
+            computedUptime.set(targetId, cumulativeUptime);
+          }
+          if (!visited.has(targetId)) {
+            queue.push(targetId);
+          }
+        }
+      }
+    }
+  }
+  const instanceOverrides = params.instanceOverrides ?? {};
+  for (const node of effectiveParsed.nodes) {
+    const rps = computedRps.get(node.id) ?? 0;
+    localAvailability.set(
+      node.id,
+      computeLocalAvailability(
+        node,
+        rps,
+        instanceOverrides[node.id],
+        groupInstMultiplier.get(node.id) ?? 1,
+        defaultUptime
+      )
+    );
+  }
+  const compoundAvailability = /* @__PURE__ */ new Map();
+  if (edgeNode) {
+    compoundAvailability.set(
+      edgeNode.id,
+      localAvailability.get(edgeNode.id) ?? 1
+    );
+    const queue2 = [edgeNode.id];
+    const visited2 = /* @__PURE__ */ new Set();
+    while (queue2.length > 0) {
+      const currentId = queue2.shift();
+      if (visited2.has(currentId)) continue;
+      visited2.add(currentId);
+      const cumAvail = compoundAvailability.get(currentId) ?? 1;
+      const currentNode = nodeMap.get(currentId);
+      const propagatedAvail = currentNode && isQueue(currentNode) ? localAvailability.get(currentId) ?? 1 : cumAvail;
+      const outbound = outboundMap.get(currentId) ?? [];
+      for (const edge of outbound) {
+        const groupChildren = groupChildMap.get(edge.targetId);
+        const targetIds = groupChildren && groupChildren.length > 0 ? groupChildren : [edge.targetId];
+        for (const targetId of targetIds) {
+          const targetLocal = localAvailability.get(targetId) ?? 1;
+          const newCompound = propagatedAvail * targetLocal;
+          const prev = compoundAvailability.get(targetId) ?? 1;
+          if (newCompound < prev) {
+            compoundAvailability.set(targetId, newCompound);
+          }
+          if (!visited2.has(targetId)) queue2.push(targetId);
+        }
+      }
+    }
+  }
+  const nodeLeafCache = /* @__PURE__ */ new Map();
+  function collectLeafPaths(nodeId, visited) {
+    if (nodeLeafCache.has(nodeId)) return nodeLeafCache.get(nodeId);
+    if (visited.has(nodeId)) return [];
+    visited.add(nodeId);
+    const node = nodeMap.get(nodeId);
+    if (!node) return [];
+    let nodeLatency;
+    if (node.isEdge) {
+      nodeLatency = 0;
+    } else if (isQueue(node)) {
+      const qGMul = groupInstMultiplier.get(nodeId) ?? 1;
+      const drainRate = getNumProp(node, "drain-rate", 0) * qGMul;
+      const inbound = computedRps.get(nodeId) ?? 0;
+      const fillRate = drainRate > 0 ? Math.max(0, inbound - drainRate) : 0;
+      nodeLatency = fillRate > 0 && drainRate > 0 ? fillRate / drainRate * 1e3 : 0;
+    } else if (isServerless(node)) {
+      nodeLatency = getNumProp(node, "duration-ms", 100);
+    } else {
+      nodeLatency = getNumProp(node, "latency-ms", defaultLatencyMs);
+    }
+    const nodeUptimeFrac = node.isEdge ? 1 : getNumProp(node, "uptime", defaultUptime) / 100;
+    const nodeAvail = localAvailability.get(nodeId) ?? 1;
+    const coldStartMs = isServerless(node) ? getNumProp(node, "cold-start-ms", 0) : 0;
+    const coldLatency = nodeLatency + coldStartMs;
+    const outbound = outboundMap.get(nodeId) ?? [];
+    if (outbound.length === 0) {
+      const rps = computedRps.get(nodeId) ?? 0;
+      let result;
+      if (rps <= 0) {
+        result = [];
+      } else if (coldStartMs > 0) {
+        result = [
+          {
+            latency: nodeLatency,
+            uptime: nodeUptimeFrac,
+            availability: nodeAvail,
+            weight: rps * 0.95
+          },
+          {
+            latency: coldLatency,
+            uptime: nodeUptimeFrac,
+            availability: nodeAvail,
+            weight: rps * 0.05
+          }
+        ];
+      } else {
+        result = [
+          {
+            latency: nodeLatency,
+            uptime: nodeUptimeFrac,
+            availability: nodeAvail,
+            weight: rps
+          }
+        ];
+      }
+      nodeLeafCache.set(nodeId, result);
+      return result;
+    }
+    const resolved = resolveSplits(outbound, []);
+    const paths = [];
+    for (const { edge, split } of resolved) {
+      const fanout = edge.fanout != null && edge.fanout >= 1 ? edge.fanout : 1;
+      const groupChildren = groupChildMap.get(edge.targetId);
+      const targetIds = groupChildren && groupChildren.length > 0 ? groupChildren : [edge.targetId];
+      for (const targetId of targetIds) {
+        const childPaths = collectLeafPaths(targetId, new Set(visited));
+        for (const cp of childPaths) {
+          if (coldStartMs > 0) {
+            paths.push({
+              latency: nodeLatency + cp.latency,
+              uptime: nodeUptimeFrac * cp.uptime,
+              availability: nodeAvail * cp.availability,
+              weight: cp.weight * (split / 100) / targetIds.length * fanout * 0.95
+            });
+            paths.push({
+              latency: coldLatency + cp.latency,
+              uptime: nodeUptimeFrac * cp.uptime,
+              availability: nodeAvail * cp.availability,
+              weight: cp.weight * (split / 100) / targetIds.length * fanout * 0.05
+            });
+          } else {
+            paths.push({
+              latency: nodeLatency + cp.latency,
+              uptime: nodeUptimeFrac * cp.uptime,
+              availability: nodeAvail * cp.availability,
+              weight: cp.weight * (split / 100) / targetIds.length * fanout
+            });
+          }
+        }
+      }
+    }
+    nodeLeafCache.set(nodeId, paths);
+    return paths;
+  }
+  function percentilesFromPaths(paths) {
+    if (paths.length === 0) return { p50: 0, p90: 0, p99: 0 };
+    const sorted = [...paths].sort((a, b) => a.latency - b.latency);
+    const totalWeight = sorted.reduce((s, p) => s + p.weight, 0);
+    if (totalWeight <= 0) return { p50: 0, p90: 0, p99: 0 };
+    const getP = (pct) => {
+      const target = totalWeight * (pct / 100);
+      let cumulative = 0;
+      for (const p of sorted) {
+        cumulative += p.weight;
+        if (cumulative >= target) return p.latency;
+      }
+      return sorted[sorted.length - 1].latency;
+    };
+    return { p50: getP(50), p90: getP(90), p99: getP(99) };
+  }
+  function availabilityPercentilesFromPaths(paths) {
+    if (paths.length === 0) return { p50: 1, p90: 1, p99: 1 };
+    const sorted = [...paths].sort((a, b) => a.availability - b.availability);
+    const totalWeight = sorted.reduce((s, p) => s + p.weight, 0);
+    if (totalWeight <= 0) return { p50: 1, p90: 1, p99: 1 };
+    const getP = (pct) => {
+      const target = totalWeight * (pct / 100);
+      let cumulative = 0;
+      for (const p of sorted) {
+        cumulative += p.weight;
+        if (cumulative >= target) return p.availability;
+      }
+      return sorted[sorted.length - 1].availability;
+    };
+    return { p50: getP(50), p90: getP(90), p99: getP(99) };
+  }
+  for (const node of effectiveParsed.nodes) {
+    collectLeafPaths(node.id, /* @__PURE__ */ new Set());
+  }
+  const edgeLeafPaths = edgeNode ? nodeLeafCache.get(edgeNode.id) ?? [] : [];
+  const edgeLatency = percentilesFromPaths(edgeLeafPaths);
+  const systemUptime = edgeLeafPaths.length > 0 ? (() => {
+    const tw = edgeLeafPaths.reduce((s, p) => s + p.weight, 0);
+    return tw > 0 ? edgeLeafPaths.reduce((s, p) => s + p.uptime * (p.weight / tw), 0) : 1;
+  })() : 1;
+  const systemAvailability = edgeLeafPaths.length > 0 ? (() => {
+    const tw = edgeLeafPaths.reduce((s, p) => s + p.weight, 0);
+    return tw > 0 ? edgeLeafPaths.reduce(
+      (s, p) => s + p.availability * (p.weight / tw),
+      0
+    ) : 1;
+  })() : 1;
+  const nodePercentiles = /* @__PURE__ */ new Map();
+  const nodeAvailPercentiles = /* @__PURE__ */ new Map();
+  const downstreamAvailability = /* @__PURE__ */ new Map();
+  for (const node of effectiveParsed.nodes) {
+    const paths = nodeLeafCache.get(node.id) ?? [];
+    nodePercentiles.set(node.id, percentilesFromPaths(paths));
+    nodeAvailPercentiles.set(node.id, availabilityPercentilesFromPaths(paths));
+    if (isQueue(node)) {
+      downstreamAvailability.set(node.id, localAvailability.get(node.id) ?? 1);
+    } else {
+      const tw = paths.reduce((s, p) => s + p.weight, 0);
+      downstreamAvailability.set(
+        node.id,
+        tw > 0 ? paths.reduce((s, p) => s + p.availability * (p.weight / tw), 0) : localAvailability.get(node.id) ?? 1
+      );
+    }
+  }
+  const computedNodes = effectiveParsed.nodes.map(
+    (node) => {
+      const rps = computedRps.get(node.id) ?? 0;
+      const gMul = groupInstMultiplier.get(node.id) ?? 1;
+      let capacity;
+      let dynInstances;
+      if (isServerless(node)) {
+        capacity = serverlessCapacity(node);
+        dynInstances = 0;
+      } else {
+        const maxRps = getNumProp(node, "max-rps", 0);
+        dynInstances = instanceOverrides[node.id] ?? computeDynamicInstances(node, rps);
+        capacity = maxRps > 0 ? maxRps * dynInstances * gMul : 0;
+      }
+      const overloaded = capacity > 0 && rps > capacity;
+      let rateLimited = false;
+      if (!node.isEdge) {
+        const rl = getNumProp(node, "ratelimit-rps", 0);
+        if (rl > 0 && rps > 0) {
+          let preRl = rps;
+          const ch = getNumProp(node, "cache-hit", 0);
+          if (ch > 0) preRl *= (100 - ch) / 100;
+          const fw = getNumProp(node, "firewall-block", 0);
+          if (fw > 0) preRl *= (100 - fw) / 100;
+          rateLimited = preRl > rl;
+        }
+      }
+      const nodeLatency = node.isEdge ? 0 : isServerless(node) ? getNumProp(node, "duration-ms", 100) : getNumProp(node, "latency-ms", defaultLatencyMs);
+      const cumulativeLatency = (computedLatency.get(node.id) ?? 0) + nodeLatency;
+      const nodeUptime = node.isEdge ? 1 : getNumProp(node, "uptime", defaultUptime) / 100;
+      const cumulativeUptime = (computedUptime.get(node.id) ?? 1) * nodeUptime;
+      const cbState = computeCbState(
+        node,
+        rps,
+        cumulativeLatency,
+        instanceOverrides[node.id],
+        gMul
+      );
+      if (overloaded) {
+        const capDetail = isServerless(node) ? `concurrency ${getNumProp(node, "concurrency", 0)} / ${getNumProp(node, "duration-ms", 100)}ms` : `${getNumProp(node, "max-rps", 0)} x ${dynInstances}${gMul > 1 ? ` x ${gMul} group` : ""}`;
+        diagnostics.push({
+          type: "OVERLOAD",
+          line: node.lineNumber,
+          message: `${node.label} is overloaded: ${Math.round(rps)} rps exceeds capacity ${Math.round(capacity)} rps (${capDetail}).`
+        });
+      }
+      if (rateLimited) {
+        diagnostics.push({
+          type: "RATE_LIMITED",
+          line: node.lineNumber,
+          message: `${node.label} is rate-limiting: inbound traffic exceeds ratelimit-rps.`
+        });
+      }
+      let childHealthState;
+      const childCaps = collapseChildCaps.get(node.id);
+      if (childCaps && childCaps.length > 0) {
+        const gInst = collapseGroupInst.get(node.id) ?? 1;
+        const perInstanceRps = rps / gInst;
+        let worst = "normal";
+        for (const cap of childCaps) {
+          if (cap > 0 && perInstanceRps > cap) worst = "overloaded";
+          else if (cap > 0 && perInstanceRps > cap * 0.7 && worst !== "overloaded")
+            worst = "warning";
+        }
+        childHealthState = worst;
+      }
+      let queueMetrics;
+      if (isQueue(node)) {
+        const buffer = getNumProp(node, "buffer", 0);
+        const drainRate = getNumProp(node, "drain-rate", 0) * gMul;
+        const fillRate = drainRate > 0 ? Math.max(0, rps - drainRate) : 0;
+        const timeToOverflow = fillRate > 0 ? buffer / fillRate : Infinity;
+        const waitTimeMs = fillRate > 0 && drainRate > 0 ? fillRate / drainRate * 1e3 : 0;
+        queueMetrics = { fillRate, timeToOverflow, waitTimeMs };
+      }
+      return {
+        id: node.id,
+        label: node.label,
+        groupId: node.groupId,
+        isEdge: node.isEdge,
+        computedRps: rps,
+        overloaded,
+        rateLimited,
+        computedLatencyMs: cumulativeLatency,
+        computedLatencyPercentiles: nodePercentiles.get(node.id) ?? {
+          p50: 0,
+          p90: 0,
+          p99: 0
+        },
+        computedUptime: cumulativeUptime,
+        computedAvailability: downstreamAvailability.get(node.id) ?? 1,
+        computedAvailabilityPercentiles: nodeAvailPercentiles.get(node.id) ?? {
+          p50: 1,
+          p90: 1,
+          p99: 1
+        },
+        computedCbState: cbState,
+        computedInstances: (collapseGroupInst.get(node.id) ?? dynInstances) * gMul,
+        computedConcurrentInvocations: isServerless(node) ? Math.ceil(rps * getNumProp(node, "duration-ms", 100) / 1e3) : 0,
+        ...childHealthState !== void 0 && { childHealthState },
+        ...queueMetrics !== void 0 && { queueMetrics },
+        properties: [...node.properties],
+        tags: { ...node.tags },
+        ...node.description !== void 0 && {
+          description: [...node.description]
+        },
+        lineNumber: node.lineNumber
+      };
+    }
+  );
+  const computedEdges = effectiveParsed.edges.map(
+    (edge) => {
+      const edgeKey = `${edge.sourceId}->${edge.targetId}`;
+      const rps = computedEdgeRps.get(edgeKey) ?? 0;
+      const outbound = outboundMap.get(edge.sourceId) ?? [];
+      let resolvedSplit = edge.split ?? 100;
+      if (outbound.length > 1 && edge.split === null) {
+        const declared = outbound.filter((e) => e.split !== null);
+        if (declared.length === 0) {
+          resolvedSplit = 100 / outbound.length;
+        } else {
+          const declaredSum = declared.reduce((s, e) => s + (e.split ?? 0), 0);
+          const undeclared = outbound.filter((e) => e.split === null);
+          resolvedSplit = undeclared.length > 0 ? (100 - declaredSum) / undeclared.length : 0;
+        }
+      }
+      return {
+        sourceId: edge.sourceId,
+        targetId: edge.targetId,
+        label: edge.label,
+        async: edge.async,
+        computedRps: rps,
+        split: resolvedSplit,
+        fanout: edge.fanout,
+        lineNumber: edge.lineNumber
+      };
+    }
+  );
+  return {
+    nodes: computedNodes,
+    edges: computedEdges,
+    groups: [...effectiveParsed.groups],
+    tagGroups: [...effectiveParsed.tagGroups],
+    title: effectiveParsed.title,
+    direction: effectiveParsed.direction,
+    edgeLatency,
+    systemUptime,
+    systemAvailability,
+    options: { ...parsed.options },
+    diagnostics
+  };
+}
+
+export {
+  computeInfra
+};
+//# sourceMappingURL=chunk-A44USUV7.js.map