@synergenius/flow-weaver 0.33.1 → 0.44.0

package/dist/cli/flow-weaver-chunk-6ZUJ7LMX.mjs

@@ -0,0 +1,2003 @@
+import { createRequire as __createRequire } from "module";
+const require = __createRequire(import.meta.url);
+import {
+  NODE_DEFAULT_COLOR,
+  NODE_VARIANT_COLORS,
+  TYPE_ABBREVIATIONS,
+  getPortColor
+} from "./flow-weaver-chunk-55QMUZIA.mjs";
+import {
+  assignImplicitPortOrders
+} from "./flow-weaver-chunk-APX6MQ5A.mjs";
+import {
+  SCOPED_PORT_NAMES,
+  isExecutePort,
+  isExitNode,
+  isFailurePort,
+  isScopedFailurePort,
+  isScopedStartPort,
+  isScopedSuccessPort,
+  isSuccessPort
+} from "./flow-weaver-chunk-DRN7KPWY.mjs";
+
+// src/diagram/layout.ts
+function layoutWorkflow(ast) {
+  const nodeIds = /* @__PURE__ */ new Set();
+  nodeIds.add("Start");
+  nodeIds.add("Exit");
+  const scopedChildren = /* @__PURE__ */ new Set();
+  if (ast.scopes) {
+    for (const children of Object.values(ast.scopes)) {
+      for (const child of children) {
+        scopedChildren.add(child);
+      }
+    }
+  }
+  for (const inst of ast.instances) {
+    if (!scopedChildren.has(inst.id)) {
+      nodeIds.add(inst.id);
+    }
+  }
+  const forward = /* @__PURE__ */ new Map();
+  const backward = /* @__PURE__ */ new Map();
+  for (const id of nodeIds) {
+    forward.set(id, /* @__PURE__ */ new Set());
+    backward.set(id, /* @__PURE__ */ new Set());
+  }
+  for (const conn of ast.connections) {
+    if (conn.from.scope || conn.to.scope) continue;
+    const from = conn.from.node;
+    const to = conn.to.node;
+    if (!nodeIds.has(from) || !nodeIds.has(to)) continue;
+    forward.get(from).add(to);
+    backward.get(to).add(from);
+  }
+  const nodeLayer = /* @__PURE__ */ new Map();
+  const inDegree = /* @__PURE__ */ new Map();
+  for (const id of nodeIds) {
+    inDegree.set(id, backward.get(id).size);
+  }
+  const queue = [];
+  for (const id of nodeIds) {
+    if (inDegree.get(id) === 0) {
+      queue.push(id);
+      nodeLayer.set(id, 0);
+    }
+  }
+  if (!nodeLayer.has("Start")) {
+    nodeLayer.set("Start", 0);
+    queue.push("Start");
+  }
+  let head = 0;
+  while (head < queue.length) {
+    const node = queue[head++];
+    const layer = nodeLayer.get(node);
+    for (const next of forward.get(node)) {
+      const candidate = layer + 1;
+      if (!nodeLayer.has(next) || nodeLayer.get(next) < candidate) {
+        nodeLayer.set(next, candidate);
+      }
+      inDegree.set(next, inDegree.get(next) - 1);
+      if (inDegree.get(next) === 0) {
+        queue.push(next);
+      }
+    }
+  }
+  for (const id of nodeIds) {
+    if (!nodeLayer.has(id)) {
+      nodeLayer.set(id, 1);
+    }
+  }
+  let maxLayer = 0;
+  for (const [id, layer] of nodeLayer) {
+    if (!isExitNode(id) && layer > maxLayer) {
+      maxLayer = layer;
+    }
+  }
+  nodeLayer.set("Exit", maxLayer + 1);
+  const layerCount = nodeLayer.get("Exit") + 1;
+  const layers = Array.from({ length: layerCount }, () => []);
+  for (const [id, layer] of nodeLayer) {
+    layers[layer].push(id);
+  }
+  for (let sweep = 0; sweep < 4; sweep++) {
+    if (sweep % 2 === 0) {
+      for (let l = 1; l < layerCount; l++) {
+        sortLayerByBarycenter(layers[l], layers[l - 1], backward, forward);
+      }
+    } else {
+      for (let l = layerCount - 2; l >= 0; l--) {
+        sortLayerByBarycenter(layers[l], layers[l + 1], forward, backward);
+      }
+    }
+  }
+  return { layers, nodeLayer };
+}
+function sortLayerByBarycenter(layer, referenceLayer, _adjacencyToRef, _adjacencyFromRef) {
+  const refPositions = /* @__PURE__ */ new Map();
+  referenceLayer.forEach((id, i) => refPositions.set(id, i));
+  const barycenters = /* @__PURE__ */ new Map();
+  for (const nodeId of layer) {
+    const neighbors = [];
+    const fwd = _adjacencyToRef.get(nodeId);
+    const bwd = _adjacencyFromRef.get(nodeId);
+    if (fwd) {
+      for (const n of fwd) {
+        if (refPositions.has(n)) neighbors.push(refPositions.get(n));
+      }
+    }
+    if (bwd) {
+      for (const n of bwd) {
+        if (refPositions.has(n)) neighbors.push(refPositions.get(n));
+      }
+    }
+    if (neighbors.length > 0) {
+      barycenters.set(nodeId, neighbors.reduce((a, b) => a + b, 0) / neighbors.length);
+    } else {
+      barycenters.set(nodeId, Infinity);
+    }
+  }
+  layer.sort((a, b) => barycenters.get(a) - barycenters.get(b));
+}
+
+// src/diagram/graph/metrics.ts
+var PORT_RADIUS = 7;
+var PORT_SIZE = PORT_RADIUS * 2;
+var PORT_GAP = 8;
+var PORT_PADDING_Y = 18;
+var NODE_MIN_WIDTH = 90;
+var NODE_MIN_HEIGHT = 90;
+var LABEL_CLEARANCE = 42;
+var LABEL_HEIGHT = 24;
+var LABEL_GAP = 12;
+var CHAR_WIDTHS = {
+  " ": 2.78,
+  "!": 3.34,
+  '"': 4.74,
+  "#": 5.56,
+  "$": 5.56,
+  "%": 8.9,
+  "&": 7.23,
+  "'": 2.38,
+  "(": 3.34,
+  ")": 3.34,
+  "*": 3.9,
+  "+": 5.84,
+  ",": 2.78,
+  "-": 3.34,
+  ".": 2.78,
+  "/": 3.95,
+  "0": 5.56,
+  "1": 5.56,
+  "2": 5.56,
+  "3": 5.56,
+  "4": 5.56,
+  "5": 5.56,
+  "6": 5.56,
+  "7": 5.56,
+  "8": 5.56,
+  "9": 5.56,
+  ":": 3.34,
+  ";": 3.34,
+  "<": 5.86,
+  "=": 5.84,
+  ">": 5.86,
+  "?": 6.11,
+  "@": 9.76,
+  A: 7.23,
+  B: 7.23,
+  C: 7.23,
+  D: 7.23,
+  E: 6.67,
+  F: 6.11,
+  G: 7.78,
+  H: 7.23,
+  I: 2.78,
+  J: 5.56,
+  K: 7.23,
+  L: 6.11,
+  M: 8.34,
+  N: 7.23,
+  O: 7.78,
+  P: 6.67,
+  Q: 7.78,
+  R: 7.23,
+  S: 6.67,
+  T: 6.11,
+  U: 7.23,
+  V: 6.67,
+  W: 9.45,
+  X: 6.67,
+  Y: 6.67,
+  Z: 6.11,
+  "[": 3.34,
+  "\\": 3.95,
+  "]": 3.34,
+  "^": 5.84,
+  "_": 5.56,
+  "`": 3.58,
+  a: 5.56,
+  b: 6.11,
+  c: 5.56,
+  d: 6.11,
+  e: 5.56,
+  f: 3.34,
+  g: 6.11,
+  h: 6.11,
+  i: 2.78,
+  j: 2.78,
+  k: 5.56,
+  l: 2.78,
+  m: 8.9,
+  n: 6.11,
+  o: 6.11,
+  p: 6.11,
+  q: 6.11,
+  r: 3.9,
+  s: 5.56,
+  t: 3.34,
+  u: 6.11,
+  v: 5.56,
+  w: 7.78,
+  x: 5.56,
+  y: 5.56,
+  z: 5,
+  "{": 3.9,
+  "|": 2.8,
+  "}": 3.9,
+  "~": 5.96
+};
+var DEFAULT_CHAR_WIDTH = 5.56;
+function measureText(text) {
+  let width = 0;
+  for (let i = 0; i < text.length; i++) {
+    width += CHAR_WIDTHS[text[i]] ?? DEFAULT_CHAR_WIDTH;
+  }
+  return width;
+}
+function portBadgeWidth(port) {
+  const abbrev = TYPE_ABBREVIATIONS[port.dataType] ?? port.dataType;
+  const typeWidth = measureText(abbrev);
+  const labelWidth = measureText(port.label);
+  const pad = 7;
+  const divGap = 4;
+  return pad + typeWidth + divGap + 1 + divGap + labelWidth + pad;
+}
+function portLabelExtent(port) {
+  const badgeGap = 5;
+  return PORT_RADIUS + badgeGap + portBadgeWidth(port);
+}
+function maxPortLabelExtent(ports) {
+  if (ports.length === 0) return 0;
+  let max = 0;
+  for (const port of ports) {
+    const abbrev = TYPE_ABBREVIATIONS[port.dataType] ?? port.dataType;
+    const badgeTextWidth = measureText(abbrev) + measureText(port.label);
+    const badgeWidth = badgeTextWidth + 23;
+    max = Math.max(max, PORT_RADIUS + 5 + badgeWidth);
+  }
+  return max;
+}
+function portsColumnHeight(count) {
+  if (count === 0) return 0;
+  return PORT_PADDING_Y + count * PORT_SIZE + (count - 1) * PORT_GAP + PORT_PADDING_Y;
+}
+
+// src/diagram/graph/bounds.ts
+var PADDING = 40;
+function normalizeNodes(nodes) {
+  let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;
+  for (const node of nodes) {
+    const labelTop = node.y - LABEL_HEIGHT - LABEL_GAP;
+    const inputLabelExtent = maxPortLabelExtent(node.inputs);
+    const outputLabelExtent = maxPortLabelExtent(node.outputs);
+    minX = Math.min(minX, node.x - inputLabelExtent);
+    minY = Math.min(minY, labelTop);
+    maxX = Math.max(maxX, node.x + node.width + outputLabelExtent);
+    maxY = Math.max(maxY, node.y + node.height);
+  }
+  const offsetX = -minX + PADDING;
+  const offsetY = -minY + PADDING;
+  const shiftPorts = (ports) => {
+    for (const p of ports) {
+      p.cx += offsetX;
+      p.cy += offsetY;
+    }
+  };
+  for (const node of nodes) {
+    node.x += offsetX;
+    node.y += offsetY;
+    shiftPorts(node.inputs);
+    shiftPorts(node.outputs);
+    if (node.scopeChildren) {
+      for (const child of node.scopeChildren) {
+        child.x += offsetX;
+        child.y += offsetY;
+        shiftPorts(child.inputs);
+        shiftPorts(child.outputs);
+      }
+    }
+    if (node.scopePorts) {
+      shiftPorts(node.scopePorts.inputs);
+      shiftPorts(node.scopePorts.outputs);
+    }
+  }
+  return { minX, minY, maxX, maxY };
+}
+function graphBounds(extent, connections, nodes) {
+  const { minX, minY, maxX, maxY } = extent;
+  let originX = 0;
+  let originY = 0;
+  let normalizedMaxY = maxY - minY + PADDING * 2;
+  let normalizedMaxX = maxX - minX + PADDING * 2;
+  const allConns = [...connections];
+  for (const node of nodes) {
+    if (node.scopeConnections) allConns.push(...node.scopeConnections);
+  }
+  for (const conn of allConns) {
+    const pe = pathExtent(conn.path);
+    if (pe.maxY + PADDING > normalizedMaxY) normalizedMaxY = pe.maxY + PADDING;
+    if (pe.maxX + PADDING > normalizedMaxX) normalizedMaxX = pe.maxX + PADDING;
+    if (pe.minY - PADDING < originY) originY = pe.minY - PADDING;
+    if (pe.minX - PADDING < originX) originX = pe.minX - PADDING;
+  }
+  normalizedMaxX -= originX;
+  normalizedMaxY -= originY;
+  return { width: normalizedMaxX, height: normalizedMaxY, originX, originY };
+}
+function pathExtent(path) {
+  let minX = Infinity, minY = Infinity;
+  let maxX = -Infinity, maxY = -Infinity;
+  const pattern = /(-?[\d.]+),(-?[\d.]+)/g;
+  let m;
+  while ((m = pattern.exec(path)) !== null) {
+    const x = parseFloat(m[1]);
+    const y = parseFloat(m[2]);
+    minX = Math.min(minX, x);
+    minY = Math.min(minY, y);
+    maxX = Math.max(maxX, x);
+    maxY = Math.max(maxY, y);
+  }
+  return { minX, minY, maxX, maxY };
+}
+
+// src/diagram/graph/ports.ts
+function orderedPorts(ports, direction) {
+  const cloned = {};
+  for (const [name, def] of Object.entries(ports)) {
+    cloned[name] = { ...def, metadata: def.metadata ? { ...def.metadata } : void 0 };
+  }
+  assignImplicitPortOrders(cloned);
+  return Object.entries(cloned).sort(([, a], [, b]) => {
+    const orderA = a.metadata?.order ?? Infinity;
+    const orderB = b.metadata?.order ?? Infinity;
+    return orderA - orderB;
+  }).map(([name, def]) => ({
+    name,
+    label: def.label ?? name,
+    dataType: def.dataType,
+    direction,
+    isControlFlow: def.dataType === "STEP",
+    isFailure: !!def.failure,
+    cx: 0,
+    cy: 0
+  }));
+}
+function filterHiddenPorts(ports) {
+  const result = {};
+  for (const [name, def] of Object.entries(ports)) {
+    if (!def.hidden) result[name] = def;
+  }
+  return result;
+}
+function filterNonScopedPorts(ports) {
+  const result = {};
+  for (const [name, def] of Object.entries(ports)) {
+    if (!def.scope) result[name] = def;
+  }
+  return result;
+}
+function computePortPositions(node) {
+  positionPortList(node.inputs, node.x, node.y);
+  positionPortList(node.outputs, node.x + node.width, node.y);
+}
+function positionPortList(ports, cx, nodeY) {
+  if (ports.length === 0) return;
+  for (let i = 0; i < ports.length; i++) {
+    ports[i].cx = cx;
+    ports[i].cy = nodeY + PORT_PADDING_Y + i * (PORT_SIZE + PORT_GAP) + PORT_SIZE / 2;
+  }
+}
+
+// src/diagram/graph/nodes.ts
+function buildNodeTypeMap(ast) {
+  const nodeTypeMap = /* @__PURE__ */ new Map();
+  for (const nt of ast.nodeTypes) {
+    nodeTypeMap.set(nt.name, nt);
+    if (nt.functionName && nt.functionName !== nt.name) {
+      nodeTypeMap.set(nt.functionName, nt);
+    }
+  }
+  return nodeTypeMap;
+}
+function computeNodeDimensions(node) {
+  const maxPorts = Math.max(node.inputs.length, node.outputs.length);
+  const portsHeight = maxPorts > 0 ? PORT_PADDING_Y + maxPorts * PORT_SIZE + (maxPorts - 1) * PORT_GAP + PORT_PADDING_Y : 0;
+  node.width = NODE_MIN_WIDTH;
+  node.height = Math.max(NODE_MIN_HEIGHT, portsHeight);
+}
+function buildStartNode(ast) {
+  const allStartPorts = filterHiddenPorts({ ...ast.startPorts });
+  if (!allStartPorts.execute && !ast.startPorts.execute?.hidden) {
+    allStartPorts.execute = { dataType: "STEP" };
+  }
+  const startOutputs = orderedPorts(allStartPorts, "OUTPUT");
+  return {
+    id: "Start",
+    label: "Start",
+    color: NODE_DEFAULT_COLOR,
+    icon: "startNode",
+    isVirtual: true,
+    inputs: [],
+    outputs: startOutputs,
+    x: 0,
+    y: 0,
+    width: NODE_MIN_WIDTH,
+    height: NODE_MIN_HEIGHT
+  };
+}
+function buildExitNode(ast) {
+  const allExitPorts = filterHiddenPorts({ ...ast.exitPorts });
+  if (!allExitPorts.onSuccess && !ast.exitPorts.onSuccess?.hidden) {
+    allExitPorts.onSuccess = { dataType: "STEP", isControlFlow: true };
+  }
+  if (!allExitPorts.onFailure && !ast.exitPorts.onFailure?.hidden) {
+    allExitPorts.onFailure = { dataType: "STEP", isControlFlow: true, failure: true };
+  } else if (allExitPorts.onFailure) {
+    allExitPorts.onFailure = { ...allExitPorts.onFailure, failure: true };
+  }
+  const exitInputs = orderedPorts(allExitPorts, "INPUT");
+  return {
+    id: "Exit",
+    label: "Exit",
+    color: NODE_DEFAULT_COLOR,
+    icon: "exitNode",
+    isVirtual: true,
+    inputs: exitInputs,
+    outputs: [],
+    x: 0,
+    y: 0,
+    width: NODE_MIN_WIDTH,
+    height: NODE_MIN_HEIGHT
+  };
+}
+function collectWiredStepPorts(ast) {
+  const stepPortsUsed = /* @__PURE__ */ new Map();
+  const noteStep = (nodeId, port) => {
+    if (!isExecutePort(port) && !isSuccessPort(port) && !isFailurePort(port)) return;
+    let s = stepPortsUsed.get(nodeId);
+    if (!s) stepPortsUsed.set(nodeId, s = /* @__PURE__ */ new Set());
+    s.add(port);
+  };
+  for (const conn of ast.connections) {
+    noteStep(conn.from.node, conn.from.port);
+    noteStep(conn.to.node, conn.to.port);
+  }
+  return stepPortsUsed;
+}
+function buildInstanceNode(instId, instNodeType, instConfig, nodeTypeMap, theme = "dark", connectedStepPorts) {
+  const nt = nodeTypeMap.get(instNodeType);
+  const allInputs = nt ? filterHiddenPorts(filterNonScopedPorts(nt.inputs)) : {};
+  const allOutputs = nt ? filterHiddenPorts(filterNonScopedPorts(nt.outputs)) : {};
+  const pullStyle = !!nt?.expression && connectedStepPorts !== void 0 && connectedStepPorts.size === 0;
+  if (pullStyle) {
+    delete allInputs.execute;
+    delete allOutputs.onSuccess;
+    delete allOutputs.onFailure;
+  }
+  if (nt && !nt.expression) {
+    if (!allInputs.execute && !nt.inputs.execute?.hidden) allInputs.execute = { dataType: "STEP" };
+  }
+  if (!pullStyle && nt && nt.hasSuccessPort && !allOutputs.onSuccess && !nt.outputs.onSuccess?.hidden) {
+    allOutputs.onSuccess = { dataType: "STEP", isControlFlow: true };
+  }
+  if (!pullStyle && nt && nt.hasFailurePort && !allOutputs.onFailure && !nt.outputs.onFailure?.hidden) {
+    allOutputs.onFailure = { dataType: "STEP", isControlFlow: true, failure: true };
+  }
+  const resolvedIcon = instConfig?.icon ?? nt?.visuals?.icon ?? resolveDefaultIcon(nt);
+  return {
+    id: instId,
+    label: instConfig?.label ?? nt?.label ?? instId,
+    color: resolveNodeColor(instConfig?.color ?? nt?.visuals?.color, theme),
+    icon: resolvedIcon,
+    isVirtual: false,
+    inputs: orderedPorts(allInputs, "INPUT"),
+    outputs: orderedPorts(allOutputs, "OUTPUT"),
+    x: 0,
+    y: 0,
+    width: NODE_MIN_WIDTH,
+    height: NODE_MIN_HEIGHT
+  };
+}
+function applySizeOverrides(ast, diagramNodes, scopedChildren) {
+  for (const inst of ast.instances) {
+    if (scopedChildren.has(inst.id)) continue;
+    const node = diagramNodes.get(inst.id);
+    if (!node) continue;
+    if (inst.config?.width != null) node.width = inst.config.width;
+    if (inst.config?.height != null) node.height = inst.config.height;
+  }
+}
+function resolveNodeColor(color, theme = "dark") {
+  if (!color) return NODE_DEFAULT_COLOR;
+  const variant = NODE_VARIANT_COLORS[color];
+  if (variant) return theme === "dark" ? variant.darkBorder : variant.border;
+  return color;
+}
+function resolveDefaultIcon(nt) {
+  if (!nt) return "code";
+  if (nt.variant === "WORKFLOW" || nt.variant === "IMPORTED_WORKFLOW") return "flow";
+  return "code";
+}
+
+// src/diagram/graph/placement.ts
+var LAYER_GAP_X = 300;
+var MIN_EDGE_GAP = 112;
+var NODE_GAP_Y = 60;
+function layerOutputExtent(layerNodes, diagramNodes) {
+  let max = 0;
+  for (const id of layerNodes) {
+    const node = diagramNodes.get(id);
+    max = Math.max(max, maxPortLabelExtent(node.outputs));
+  }
+  return max;
+}
+function layerInputExtent(layerNodes, diagramNodes) {
+  let max = 0;
+  for (const id of layerNodes) {
+    const node = diagramNodes.get(id);
+    max = Math.max(max, maxPortLabelExtent(node.inputs));
+  }
+  return max;
+}
+function adaptiveGapY(layerSize) {
+  if (layerSize <= 2) return NODE_GAP_Y;
+  return Math.max(24, Math.round(NODE_GAP_Y * 2 / layerSize));
+}
+function assignLayerCoordinates(layers, diagramNodes) {
+  const filtered = layers.map((l) => l.filter((id) => diagramNodes.has(id)));
+  let currentX = 0;
+  for (let i = 0; i < filtered.length; i++) {
+    const layerNodes = filtered[i];
+    if (layerNodes.length === 0) {
+      currentX += LAYER_GAP_X;
+      continue;
+    }
+    const maxWidth = Math.max(...layerNodes.map((id) => diagramNodes.get(id).width));
+    const gapY = adaptiveGapY(layerNodes.length);
+    const totalHeight = layerNodes.reduce((sum, id) => {
+      const n = diagramNodes.get(id);
+      return sum + n.height + LABEL_HEIGHT + LABEL_GAP;
+    }, 0) + (layerNodes.length - 1) * gapY;
+    let currentY = -totalHeight / 2;
+    for (const id of layerNodes) {
+      const node = diagramNodes.get(id);
+      currentY += LABEL_HEIGHT + LABEL_GAP;
+      node.x = currentX + (maxWidth - node.width) / 2;
+      node.y = currentY;
+      currentY += node.height + gapY;
+    }
+    const nextLayerNodes = filtered[i + 1];
+    if (nextLayerNodes && nextLayerNodes.length > 0) {
+      const outputOverhang = layerOutputExtent(layerNodes, diagramNodes);
+      const inputOverhang = layerInputExtent(nextLayerNodes, diagramNodes);
+      const labelMinGap = outputOverhang + LABEL_CLEARANCE + inputOverhang;
+      const edgeGap = Math.max(labelMinGap, LAYER_GAP_X - maxWidth, MIN_EDGE_GAP);
+      currentX += maxWidth + edgeGap;
+    } else {
+      currentX += maxWidth + LAYER_GAP_X;
+    }
+  }
+}
+function resolvePostLayoutOverlaps(diagramNodes) {
+  const hasScopeParent = [...diagramNodes.values()].some((n) => n.scopeChildren && n.scopeChildren.length > 0);
+  if (!hasScopeParent) return;
+  const nodes = [...diagramNodes.values()].sort((a, b) => a.x - b.x);
+  for (let i = 1; i < nodes.length; i++) {
+    const prev = nodes[i - 1];
+    const curr = nodes[i];
+    if (!prev.scopeChildren || prev.scopeChildren.length === 0) continue;
+    const actualGap = curr.x - (prev.x + prev.width);
+    if (actualGap < MIN_EDGE_GAP) {
+      const shift = MIN_EDGE_GAP - actualGap;
+      for (let j = i; j < nodes.length; j++) {
+        nodes[j].x += shift;
+      }
+    }
+  }
+}
+
+// src/diagram/orthogonal-router.ts
+var TRACK_SPACING = 15;
+var EDGE_OFFSET = 5;
+var BELOW_BIAS = 40;
+var TrackAllocator = class {
+  claims = /* @__PURE__ */ new Map();
+  claim(xMin, xMax, candidateY) {
+    const snap = (y) => Math.round(y / TRACK_SPACING) * TRACK_SPACING;
+    const overlaps = (slot) => {
+      const intervals = this.claims.get(slot);
+      if (!intervals) return false;
+      return intervals.some(([a, b]) => xMin < b && xMax > a);
+    };
+    const take = (slot) => {
+      if (!this.claims.has(slot)) this.claims.set(slot, []);
+      const slotClaims = this.claims.get(slot);
+      if (slotClaims) slotClaims.push([xMin, xMax]);
+      return slot;
+    };
+    const base = snap(candidateY);
+    for (let i = 0; i < 60; i++) {
+      const below = base + i * TRACK_SPACING;
+      if (!overlaps(below)) return take(below);
+      if (i > 0) {
+        const above = base - i * TRACK_SPACING;
+        if (!overlaps(above)) return take(above);
+      }
+    }
+    return candidateY;
+  }
+};
+function inflateBox(box, padding) {
+  return {
+    left: box.x - padding,
+    right: box.x + box.width + padding,
+    top: box.y - padding,
+    bottom: box.y + box.height + padding
+  };
+}
+function segmentOverlapsBox(xMin, xMax, y, box) {
+  return xMin < box.right && xMax > box.left && y >= box.top && y <= box.bottom;
+}
+function verticalSegmentClear(x, yMin, yMax, boxes) {
+  return !boxes.some(
+    (box) => x >= box.left && x <= box.right && yMin < box.bottom && yMax > box.top
+  );
+}
+function findClearY(xMin, xMax, candidateY, boxes) {
+  const isBlocked = (y) => boxes.some((box) => segmentOverlapsBox(xMin, xMax, y, box));
+  if (!isBlocked(candidateY)) return candidateY;
+  const edges = [];
+  for (const box of boxes) {
+    if (xMin < box.right && xMax > box.left) {
+      edges.push(box.top);
+      edges.push(box.bottom);
+    }
+  }
+  if (edges.length === 0) return candidateY;
+  edges.sort((a, b) => a - b);
+  let bestY = candidateY;
+  let bestDist = Infinity;
+  for (const edge of edges) {
+    for (const y of [edge - EDGE_OFFSET, edge + EDGE_OFFSET]) {
+      if (!isBlocked(y)) {
+        const dist = Math.abs(y - candidateY);
+        if (dist < bestDist) {
+          bestDist = dist;
+          bestY = y;
+        }
+      }
+    }
+  }
+  if (bestDist === Infinity) {
+    const allMin = Math.min(...edges) - EDGE_OFFSET * 2;
+    const allMax = Math.max(...edges) + EDGE_OFFSET * 2;
+    bestY = Math.abs(allMin - candidateY) < Math.abs(allMax - candidateY) ? allMin : allMax;
+    if (isBlocked(bestY)) {
+      for (let offset = TRACK_SPACING; offset < 800; offset += TRACK_SPACING) {
+        if (!isBlocked(bestY - offset)) {
+          bestY -= offset;
+          break;
+        }
+        if (!isBlocked(bestY + offset)) {
+          bestY += offset;
+          break;
+        }
+      }
+    }
+  }
+  return bestY;
+}
+function findClearX(yMin, yMax, candidateX, boxes) {
+  const isBlocked = (x) => boxes.some((box) => x >= box.left && x <= box.right && yMin < box.bottom && yMax > box.top);
+  if (!isBlocked(candidateX)) return candidateX;
+  const edges = [];
+  for (const box of boxes) {
+    if (yMin < box.bottom && yMax > box.top) {
+      edges.push(box.left);
+      edges.push(box.right);
+    }
+  }
+  if (edges.length === 0) return candidateX;
+  edges.sort((a, b) => a - b);
+  let bestX = candidateX;
+  let bestDist = Infinity;
+  for (const edge of edges) {
+    for (const x of [edge - EDGE_OFFSET, edge + EDGE_OFFSET]) {
+      if (!isBlocked(x)) {
+        const dist = Math.abs(x - candidateX);
+        if (dist < bestDist) {
+          bestDist = dist;
+          bestX = x;
+        }
+      }
+    }
+  }
+  if (bestDist === Infinity) {
+    const allMin = Math.min(...edges) - EDGE_OFFSET * 2;
+    const allMax = Math.max(...edges) + EDGE_OFFSET * 2;
+    bestX = Math.abs(allMin - candidateX) <= Math.abs(allMax - candidateX) ? allMin : allMax;
+    if (isBlocked(bestX)) {
+      for (let offset = TRACK_SPACING; offset < 800; offset += TRACK_SPACING) {
+        if (!isBlocked(bestX - offset)) {
+          bestX -= offset;
+          break;
+        }
+        if (!isBlocked(bestX + offset)) {
+          bestX += offset;
+          break;
+        }
+      }
+    }
+  }
+  return bestX;
+}
+var MIN_SEGMENT_LENGTH = 3;
+var JOG_THRESHOLD = 10;
+function simplifyWaypoints(waypoints) {
+  if (waypoints.length <= 2) return waypoints;
+  let pts = waypoints;
+  let jogFound = true;
+  while (jogFound) {
+    jogFound = false;
+    for (let i = 0; i < pts.length - 3; i++) {
+      const a = pts[i], b = pts[i + 1], c = pts[i + 2], d = pts[i + 3];
+      const jogH = Math.abs(b[1] - c[1]);
+      if (Math.abs(a[1] - b[1]) < 0.5 && Math.abs(b[0] - c[0]) < 0.5 && Math.abs(c[1] - d[1]) < 0.5 && jogH > 0.5 && jogH < JOG_THRESHOLD) {
+        if (Math.abs(a[1] - d[1]) < 0.5) {
+          const snapY = a[1];
+          const newPts = pts.slice();
+          newPts[i + 1] = [b[0], snapY];
+          newPts[i + 2] = [c[0], snapY];
+          pts = newPts;
+          jogFound = true;
+          break;
+        }
+      }
+      const jogW = Math.abs(b[0] - c[0]);
+      if (Math.abs(a[0] - b[0]) < 0.5 && Math.abs(b[1] - c[1]) < 0.5 && Math.abs(c[0] - d[0]) < 0.5 && jogW > 0.5 && jogW < JOG_THRESHOLD) {
+        if (Math.abs(a[0] - d[0]) < 0.5) {
+          const snapX = a[0];
+          const newPts = pts.slice();
+          newPts[i + 1] = [snapX, b[1]];
+          newPts[i + 2] = [snapX, c[1]];
+          pts = newPts;
+          jogFound = true;
+          break;
+        }
+      }
+    }
+  }
+  const result = [pts[0]];
+  for (let i = 1; i < pts.length - 1; i++) {
+    const prev = result[result.length - 1];
+    const curr = pts[i];
+    const next = pts[i + 1];
+    const distToPrev = Math.abs(prev[0] - curr[0]) + Math.abs(prev[1] - curr[1]);
+    if (distToPrev < MIN_SEGMENT_LENGTH) {
+      const wouldDiag = Math.abs(prev[0] - next[0]) > 0.5 && Math.abs(prev[1] - next[1]) > 0.5;
+      if (!wouldDiag) continue;
+    }
+    const sameX = Math.abs(prev[0] - curr[0]) < 0.01 && Math.abs(curr[0] - next[0]) < 0.01;
+    const sameY = Math.abs(prev[1] - curr[1]) < 0.01 && Math.abs(curr[1] - next[1]) < 0.01;
+    if (!sameX && !sameY) {
+      result.push(curr);
+    }
+  }
+  result.push(pts[pts.length - 1]);
+  return result;
+}
+function waypointsToSvgPath(waypoints, cornerRadius) {
+  if (waypoints.length < 2) return "";
+  if (waypoints.length === 2) {
+    return `M ${waypoints[0][0]},${waypoints[0][1]} L ${waypoints[1][0]},${waypoints[1][1]}`;
+  }
+  const radii = new Array(waypoints.length).fill(0);
+  for (let i = 1; i < waypoints.length - 1; i++) {
+    const prev = waypoints[i - 1];
+    const curr = waypoints[i];
+    const next = waypoints[i + 1];
+    const lenPrev = Math.sqrt((prev[0] - curr[0]) ** 2 + (prev[1] - curr[1]) ** 2);
+    const lenNext = Math.sqrt((next[0] - curr[0]) ** 2 + (next[1] - curr[1]) ** 2);
+    radii[i] = lenPrev < 0.01 || lenNext < 0.01 ? 0 : Math.min(cornerRadius, lenPrev / 2, lenNext / 2);
+  }
+  for (let i = 1; i < waypoints.length - 2; i++) {
+    const curr = waypoints[i];
+    const next = waypoints[i + 1];
+    const segLen = Math.sqrt((next[0] - curr[0]) ** 2 + (next[1] - curr[1]) ** 2);
+    const total = radii[i] + radii[i + 1];
+    if (total > segLen && total > 0) {
+      const scale = segLen / total;
+      radii[i] *= scale;
+      radii[i + 1] *= scale;
+    }
+  }
+  let path = `M ${waypoints[0][0]},${waypoints[0][1]}`;
+  for (let i = 1; i < waypoints.length - 1; i++) {
+    const prev = waypoints[i - 1];
+    const curr = waypoints[i];
+    const next = waypoints[i + 1];
+    const r = radii[i];
+    if (r < 0.01) {
+      path += ` L ${curr[0]},${curr[1]}`;
+      continue;
+    }
+    const dPrev = [prev[0] - curr[0], prev[1] - curr[1]];
+    const dNext = [next[0] - curr[0], next[1] - curr[1]];
+    const lenPrev = Math.sqrt(dPrev[0] * dPrev[0] + dPrev[1] * dPrev[1]);
+    const lenNext = Math.sqrt(dNext[0] * dNext[0] + dNext[1] * dNext[1]);
+    const uPrev = [dPrev[0] / lenPrev, dPrev[1] / lenPrev];
+    const uNext = [dNext[0] / lenNext, dNext[1] / lenNext];
+    const cross = uPrev[0] * uNext[1] - uPrev[1] * uNext[0];
+    const deflection = Math.abs(cross);
+    const scaledR = r * deflection;
+    if (scaledR < 0.5) {
+      path += ` L ${curr[0]},${curr[1]}`;
+      continue;
+    }
+    const arcStart = [curr[0] + uPrev[0] * scaledR, curr[1] + uPrev[1] * scaledR];
+    const arcEnd = [curr[0] + uNext[0] * scaledR, curr[1] + uNext[1] * scaledR];
+    const sweep = cross > 0 ? 0 : 1;
+    path += ` L ${arcStart[0]},${arcStart[1]}`;
+    path += ` A ${scaledR} ${scaledR} 0 0 ${sweep} ${arcEnd[0]},${arcEnd[1]}`;
+  }
+  const last = waypoints[waypoints.length - 1];
+  path += ` L ${last[0]},${last[1]}`;
+  return path;
+}
+function computeWaypoints(from, to, nodeBoxes, sourceNodeId, targetNodeId, padding, exitStub, entryStub, scopedInternal, allocator) {
+  const isSelfConnection = sourceNodeId === targetNodeId && !scopedInternal;
+  const inflatedBoxes = nodeBoxes.map((box) => inflateBox(box, padding));
+  const stubExit = [from[0] + exitStub, from[1]];
+  const stubEntry = [to[0] - entryStub, to[1]];
+  const xMin = Math.min(stubExit[0], stubEntry[0]);
+  const xMax = Math.max(stubExit[0], stubEntry[0]);
+  if (!isSelfConnection && to[0] >= from[0] - exitStub) {
+    let candidateY = (from[1] + to[1]) / 2 + BELOW_BIAS;
+    const intermediateBoxes = inflatedBoxes.filter((box) => box.left < xMax && box.right > xMin);
+    if (intermediateBoxes.length >= 2) {
+      const clusterTop = Math.min(...intermediateBoxes.map((b) => b.top));
+      const clusterBottom = Math.max(...intermediateBoxes.map((b) => b.bottom));
+      if (candidateY > clusterTop && candidateY < clusterBottom) {
+        const distToTop = candidateY - clusterTop;
+        const distToBottom = clusterBottom - candidateY;
+        candidateY = distToTop < distToBottom ? clusterTop - padding : clusterBottom + padding;
+      }
+    }
+    const clearY = allocator ? allocator.claim(xMin, xMax, findClearY(xMin, xMax, candidateY, inflatedBoxes)) : findClearY(xMin, xMax, candidateY, inflatedBoxes);
+    const yMin = Math.min(from[1], to[1]);
+    const yMax = Math.max(from[1], to[1]);
+    const stubsCross = stubExit[0] >= stubEntry[0];
+    const midX = stubsCross ? (from[0] + to[0]) / 2 : stubExit[0] + (stubEntry[0] - stubExit[0]) * 0.75;
+    const freeMidX = findClearX(yMin, yMax || yMin + 1, midX, inflatedBoxes);
+    const lShapeXValid = stubsCross ? freeMidX >= Math.min(from[0], to[0]) && freeMidX <= Math.max(from[0], to[0]) : freeMidX > stubExit[0] && freeMidX < stubEntry[0];
+    if (lShapeXValid && verticalSegmentClear(freeMidX, yMin, yMax, inflatedBoxes) && !inflatedBoxes.some((box) => segmentOverlapsBox(stubExit[0], freeMidX, from[1], box)) && !inflatedBoxes.some((box) => segmentOverlapsBox(freeMidX, stubEntry[0], to[1], box))) {
+      return simplifyWaypoints([from, [freeMidX, from[1]], [freeMidX, to[1]], to]);
+    }
+    if (Math.abs(clearY - from[1]) < JOG_THRESHOLD && !inflatedBoxes.some((box) => segmentOverlapsBox(xMin, xMax, from[1], box))) {
+      candidateY = from[1];
+    } else if (Math.abs(clearY - to[1]) < JOG_THRESHOLD && !inflatedBoxes.some((box) => segmentOverlapsBox(xMin, xMax, to[1], box))) {
+      candidateY = to[1];
+    } else {
+      candidateY = clearY;
+    }
+    const exitYMin = Math.min(from[1], candidateY);
+    const exitYMax = Math.max(from[1], candidateY);
+    let exitX = findClearX(exitYMin, exitYMax, stubExit[0], inflatedBoxes);
+    if (exitX < from[0]) {
+      exitX = stubExit[0];
+      if (!verticalSegmentClear(exitX, exitYMin, exitYMax, inflatedBoxes)) {
+        exitX = findClearX(exitYMin, exitYMax, stubExit[0] + TRACK_SPACING, inflatedBoxes);
+      }
+    }
+    const entryYMin = Math.min(to[1], candidateY);
+    const entryYMax = Math.max(to[1], candidateY);
+    let entryX = findClearX(entryYMin, entryYMax, stubEntry[0], inflatedBoxes);
+    if (entryX > to[0]) {
+      entryX = stubEntry[0];
+      if (!verticalSegmentClear(entryX, entryYMin, entryYMax, inflatedBoxes)) {
+        entryX = findClearX(entryYMin, entryYMax, stubEntry[0] - TRACK_SPACING, inflatedBoxes);
+      }
+    }
+    return simplifyWaypoints([
+      from,
+      [exitX, from[1]],
+      [exitX, candidateY],
+      [entryX, candidateY],
+      [entryX, to[1]],
+      to
+    ]);
+  } else {
+    const sourceBox = nodeBoxes.find((b) => b.id === sourceNodeId);
+    const targetBox = nodeBoxes.find((b) => b.id === targetNodeId);
+    const corridorBoxes = inflatedBoxes.filter((box) => box.left < xMax && box.right > xMin);
+    const bottoms = corridorBoxes.map((b) => b.bottom);
+    const tops = corridorBoxes.map((b) => b.top);
+    if (sourceBox) {
+      bottoms.push(sourceBox.y + sourceBox.height + padding);
+      tops.push(sourceBox.y - padding);
+    }
+    if (targetBox) {
+      bottoms.push(targetBox.y + targetBox.height + padding);
+      tops.push(targetBox.y - padding);
+    }
+    const maxBottom = Math.max(...bottoms, from[1] + 50, to[1] + 50);
+    const minTop = Math.min(...tops, from[1] - 50, to[1] - 50);
+    const avgY = (from[1] + to[1]) / 2 + BELOW_BIAS;
+    const escapeBelow = maxBottom + padding;
+    const escapeAbove = minTop - padding;
+    let escapeY = Math.abs(escapeAbove - avgY) < Math.abs(escapeBelow - avgY) ? escapeAbove : escapeBelow;
+    escapeY = allocator ? allocator.claim(xMin, xMax, findClearY(xMin, xMax, escapeY, inflatedBoxes)) : findClearY(xMin, xMax, escapeY, inflatedBoxes);
+    const bwExitYMin = Math.min(from[1], escapeY);
+    const bwExitYMax = Math.max(from[1], escapeY);
+    const bwExitX = findClearX(bwExitYMin, bwExitYMax, stubExit[0], inflatedBoxes);
+    const bwEntryYMin = Math.min(to[1], escapeY);
+    const bwEntryYMax = Math.max(to[1], escapeY);
+    const bwEntryX = findClearX(bwEntryYMin, bwEntryYMax, stubEntry[0], inflatedBoxes);
+    return simplifyWaypoints([
+      from,
+      [bwExitX, from[1]],
+      [bwExitX, escapeY],
+      [bwEntryX, escapeY],
+      [bwEntryX, to[1]],
+      to
+    ]);
+  }
+}
+function calculateOrthogonalPath(from, to, nodeBoxes, sourceNodeId, targetNodeId, options) {
+  const cornerRadius = options?.cornerRadius ?? 10;
+  const padding = options?.padding ?? 15;
+  const stubLength = options?.stubLength ?? 20;
+  const stubSpacing = options?.stubSpacing ?? 12;
+  const maxStubLength = options?.maxStubLength ?? 80;
+  const fromPortIndex = options?.fromPortIndex ?? 0;
+  const toPortIndex = options?.toPortIndex ?? 0;
+  const exitStub = Math.min(stubLength + fromPortIndex * stubSpacing, maxStubLength);
+  const entryStub = Math.min(stubLength + toPortIndex * stubSpacing, maxStubLength);
+  const waypoints = computeWaypoints(
+    from,
+    to,
+    nodeBoxes,
+    sourceNodeId,
+    targetNodeId,
+    padding,
+    exitStub,
+    entryStub,
+    options?.scopedInternal,
+    options?.allocator
+  );
+  if (!waypoints) return null;
+  return waypointsToSvgPath(waypoints, cornerRadius);
+}
+function calculateOrthogonalPathSafe(from, to, nodeBoxes, sourceNodeId, targetNodeId, options) {
+  try {
+    const path = calculateOrthogonalPath(from, to, nodeBoxes, sourceNodeId, targetNodeId, options);
+    if (!path || path.length < 5) return null;
+    return path;
+  } catch {
+    return null;
+  }
+}
+
+// src/diagram/graph/routing.ts
+var STUB_DISTANCE_THRESHOLD = 500;
+var STUB_LENGTH = 30;
+function computeConnectionPath(sx, sy, tx, ty) {
+  return `M ${sx},${sy} L ${tx},${ty}`;
+}
+function collectExternalConnections(ast, diagramNodes, scopedChildren) {
+  const pendingConnections = [];
+  for (const conn of ast.connections) {
+    if (conn.from.scope || conn.to.scope) continue;
+    let fromNode = diagramNodes.get(conn.from.node);
+    let toNode = diagramNodes.get(conn.to.node);
+    if (!fromNode) {
+      for (const node of diagramNodes.values()) {
+        const child = node.scopeChildren?.find((c) => c.id === conn.from.node);
+        if (child) {
+          fromNode = child;
+          break;
+        }
+      }
+    }
+    if (!toNode) {
+      for (const node of diagramNodes.values()) {
+        const child = node.scopeChildren?.find((c) => c.id === conn.to.node);
+        if (child) {
+          toNode = child;
+          break;
+        }
+      }
+    }
+    if (!fromNode || !toNode) continue;
+    const fromIsScoped = scopedChildren.has(conn.from.node);
+    const toIsScoped = scopedChildren.has(conn.to.node);
+    if (fromIsScoped && toIsScoped) continue;
+    if (fromIsScoped && diagramNodes.has(conn.to.node) && findScopeParent(conn.from.node, diagramNodes) === conn.to.node) continue;
+    if (toIsScoped && diagramNodes.has(conn.from.node) && findScopeParent(conn.to.node, diagramNodes) === conn.from.node) continue;
+    const sourcePort = fromNode.outputs.find((p) => p.name === conn.from.port);
+    const targetPort = toNode.inputs.find((p) => p.name === conn.to.port);
+    if (!sourcePort || !targetPort) continue;
+    const fromPortIndex = fromNode.outputs.indexOf(sourcePort);
+    const toPortIndex = toNode.inputs.indexOf(targetPort);
+    pendingConnections.push({
+      fromNodeId: conn.from.node,
+      fromPortName: conn.from.port,
+      toNodeId: conn.to.node,
+      toPortName: conn.to.port,
+      sourcePort,
+      targetPort,
+      fromPortIndex,
+      toPortIndex
+    });
+  }
+  return pendingConnections;
+}
+function routeConnections(pendingConnections, nodes, theme) {
+  const nodeBoxes = buildNodeBoxes(nodes);
+  const allocator = new TrackAllocator();
+  const connections = routeExternalConnections(pendingConnections, nodeBoxes, allocator, theme);
+  routeScopeConnections(nodes, nodeBoxes, allocator);
+  return connections;
+}
+function buildNodeBoxes(nodes) {
+  const nodeBoxes = nodes.map((node) => ({
+    id: node.id,
+    x: node.x,
+    y: node.y,
+    width: node.width,
+    height: node.height
+  }));
+  for (const node of nodes) {
+    if (node.scopeChildren) {
+      for (const child of node.scopeChildren) {
+        nodeBoxes.push({ id: child.id, x: child.x, y: child.y, width: child.width, height: child.height });
+      }
+    }
+  }
+  return nodeBoxes;
+}
+function compareRoutingOrder(a, b) {
+  const aSpan = Math.abs(a.targetPort.cx - a.sourcePort.cx);
+  const bSpan = Math.abs(b.targetPort.cx - b.sourcePort.cx);
+  if (Math.abs(aSpan - bSpan) > 1) return aSpan - bSpan;
+  if (Math.abs(a.sourcePort.cx - b.sourcePort.cx) > 1) return a.sourcePort.cx - b.sourcePort.cx;
+  return a.sourcePort.cy - b.sourcePort.cy;
+}
+function routeExternalConnections(pendingConnections, nodeBoxes, allocator, theme) {
+  pendingConnections.sort(compareRoutingOrder);
+  const connections = [];
+  for (const pc of pendingConnections) {
+    const sx = pc.sourcePort.cx;
+    const sy = pc.sourcePort.cy;
+    const tx = pc.targetPort.cx;
+    const ty = pc.targetPort.cy;
+    const sourceColor = getPortColor(pc.sourcePort.dataType, pc.sourcePort.isFailure, theme);
+    const targetColor = getPortColor(pc.targetPort.dataType, pc.targetPort.isFailure, theme);
+    const xDistance = Math.abs(tx - sx);
+    const dashed = pc.sourcePort.dataType !== "STEP";
+    const srcLabelEnd = portLabelExtent(pc.sourcePort);
+    const tgtLabelEnd = portLabelExtent(pc.targetPort);
+    const sourceStub = {
+      x: sx + srcLabelEnd,
+      y: sy,
+      endX: sx + srcLabelEnd + STUB_LENGTH,
+      labelOffset: srcLabelEnd,
+      color: sourceColor,
+      dashed
+    };
+    const targetStub = {
+      x: tx - tgtLabelEnd,
+      y: ty,
+      endX: tx - tgtLabelEnd - STUB_LENGTH,
+      labelOffset: tgtLabelEnd,
+      color: targetColor,
+      dashed
+    };
+    const pathSx = sx + srcLabelEnd;
+    const pathTx = tx - tgtLabelEnd;
+    let path;
+    if (xDistance > STUB_DISTANCE_THRESHOLD) {
+      path = "";
+    } else {
+      const orthoPath = calculateOrthogonalPathSafe(
+        [pathSx, sy],
+        [pathTx, ty],
+        nodeBoxes,
+        pc.fromNodeId,
+        pc.toNodeId,
+        { fromPortIndex: pc.fromPortIndex, toPortIndex: pc.toPortIndex, allocator }
+      );
+      path = orthoPath ?? computeConnectionPath(pathSx, sy, pathTx, ty);
+    }
+    connections.push({
+      fromNode: pc.fromNodeId,
+      fromPort: pc.fromPortName,
+      toNode: pc.toNodeId,
+      toPort: pc.toPortName,
+      sourceColor,
+      targetColor,
+      isStepConnection: pc.sourcePort.dataType === "STEP",
+      path,
+      sourceStub,
+      targetStub
+    });
+  }
+  return connections;
+}
+function routeScopeConnections(nodes, nodeBoxes, allocator) {
+  for (const node of nodes) {
+    if (!node.scopeConnections || !node.scopePorts || !node.scopeChildren) continue;
+    const childMap = /* @__PURE__ */ new Map();
+    for (const c of node.scopeChildren) childMap.set(c.id, c);
+    const scopePending = [];
+    for (const conn of node.scopeConnections) {
+      const sPort = findScopePort(conn.fromNode, conn.fromPort, node, childMap, "output");
+      const tPort = findScopePort(conn.toNode, conn.toPort, node, childMap, "input");
+      if (!sPort || !tPort) continue;
+      let fromPortIndex = 0;
+      let toPortIndex = 0;
+      if (conn.fromNode === node.id) {
+        fromPortIndex = node.scopePorts.outputs.indexOf(sPort);
+      } else {
+        const fromChild = childMap.get(conn.fromNode);
+        if (fromChild) fromPortIndex = fromChild.outputs.indexOf(sPort);
+      }
+      if (conn.toNode === node.id) {
+        toPortIndex = node.scopePorts.inputs.indexOf(tPort);
+      } else {
+        const toChild = childMap.get(conn.toNode);
+        if (toChild) toPortIndex = toChild.inputs.indexOf(tPort);
+      }
+      scopePending.push({
+        conn,
+        sourcePort: sPort,
+        targetPort: tPort,
+        fromNodeId: conn.fromNode,
+        toNodeId: conn.toNode,
+        fromPortIndex: Math.max(0, fromPortIndex),
+        toPortIndex: Math.max(0, toPortIndex)
+      });
+    }
+    scopePending.sort(compareRoutingOrder);
+    for (const sp of scopePending) {
+      const sx = sp.sourcePort.cx;
+      const sy = sp.sourcePort.cy;
+      const tx = sp.targetPort.cx;
+      const ty = sp.targetPort.cy;
+      const orthoPath = calculateOrthogonalPathSafe(
+        [sx, sy],
+        [tx, ty],
+        nodeBoxes,
+        sp.fromNodeId,
+        sp.toNodeId,
+        { fromPortIndex: sp.fromPortIndex, toPortIndex: sp.toPortIndex, allocator }
+      );
+      sp.conn.path = orthoPath ?? computeConnectionPath(sx, sy, tx, ty);
+    }
+  }
+}
+function findScopePort(nodeId, portName, parentNode, childMap, side) {
+  if (nodeId === parentNode.id) {
+    const ports = side === "output" ? parentNode.scopePorts?.outputs : parentNode.scopePorts?.inputs;
+    return ports?.find((p) => p.name === portName);
+  }
+  const child = childMap.get(nodeId);
+  if (!child) return void 0;
+  return side === "output" ? child.outputs.find((p) => p.name === portName) : child.inputs.find((p) => p.name === portName);
+}
+function findScopeParent(childId, diagramNodes) {
+  for (const node of diagramNodes.values()) {
+    if (node.scopeChildren?.some((c) => c.id === childId)) return node.id;
+  }
+  return void 0;
+}
+
+// src/diagram/graph/scopes.ts
+var SCOPE_PADDING_X = 140;
+var SCOPE_PADDING_Y = 40;
+var SCOPE_PORT_COLUMN = 45;
+var SCOPE_INNER_GAP_X = 240;
+function collectScopes(ast) {
+  const scopedChildren = /* @__PURE__ */ new Set();
+  const allScopes = { ...ast.scopes ?? {} };
+  if (ast.scopes) {
+    for (const children of Object.values(ast.scopes)) {
+      for (const child of children) scopedChildren.add(child);
+    }
+  }
+  const inferredScopes = /* @__PURE__ */ new Map();
+  for (const conn of ast.connections) {
+    if (conn.from.scope) {
+      const key = `${conn.from.node}.${conn.from.scope}`;
+      if (!inferredScopes.has(key)) inferredScopes.set(key, /* @__PURE__ */ new Set());
+      inferredScopes.get(key).add(conn.to.node);
+    }
+    if (conn.to.scope) {
+      const key = `${conn.to.node}.${conn.to.scope}`;
+      if (!inferredScopes.has(key)) inferredScopes.set(key, /* @__PURE__ */ new Set());
+      inferredScopes.get(key).add(conn.from.node);
+    }
+  }
+  for (const [key, childSet] of inferredScopes) {
+    if (!allScopes[key]) {
+      allScopes[key] = [...childSet];
+      for (const child of childSet) scopedChildren.add(child);
+    }
+  }
+  return { allScopes, scopedChildren };
+}
+function buildScopeSubGraphs(ast, diagramNodes, allScopes, nodeTypeMap, theme) {
+  for (const [scopeKey, childIds] of Object.entries(allScopes)) {
+    const dotIndex = scopeKey.indexOf(".");
+    const parentId = scopeKey.substring(0, dotIndex);
+    const scopeName = scopeKey.substring(dotIndex + 1);
+    const parentNode = diagramNodes.get(parentId);
+    if (!parentNode) continue;
+    const parentInst = ast.instances.find((i) => i.id === parentId);
+    if (!parentInst) continue;
+    const parentNt = nodeTypeMap.get(parentInst.nodeType);
+    if (!parentNt) continue;
+    buildScopeSubGraph(parentNode, parentNt, scopeName, childIds, ast, nodeTypeMap, theme);
+  }
+}
+function buildScopeSubGraph(parentNode, parentNt, scopeName, childIds, ast, nodeTypeMap, theme = "dark") {
+  const childIdSet = new Set(childIds);
+  const scopedOutputDefs = {};
+  const scopedInputDefs = {};
+  for (const [name, def] of Object.entries(parentNt.outputs)) {
+    if (def.scope === scopeName) scopedOutputDefs[name] = def;
+  }
+  for (const [name, def] of Object.entries(parentNt.inputs)) {
+    if (def.scope === scopeName) scopedInputDefs[name] = def;
+  }
+  for (const conn of ast.connections) {
+    if (conn.from.node === parentNode.id && childIdSet.has(conn.to.node)) {
+      const portName = conn.from.port;
+      if (!scopedOutputDefs[portName]) {
+        const parentDef = parentNt.outputs[portName];
+        if (parentDef) {
+          scopedOutputDefs[portName] = { ...parentDef, scope: scopeName };
+        } else {
+          const childInst = ast.instances.find((i) => i.id === conn.to.node);
+          const childNt = childInst ? nodeTypeMap.get(childInst.nodeType) : void 0;
+          const childInputDef = childNt?.inputs[conn.to.port];
+          scopedOutputDefs[portName] = {
+            dataType: childInputDef?.dataType ?? "ANY",
+            scope: scopeName,
+            label: childInputDef?.label ?? portName
+          };
+        }
+      }
+    }
+    if (conn.to.node === parentNode.id && childIdSet.has(conn.from.node)) {
+      const portName = conn.to.port;
+      if (!scopedInputDefs[portName]) {
+        const parentDef = parentNt.inputs[portName];
+        if (parentDef) {
+          scopedInputDefs[portName] = { ...parentDef, scope: scopeName };
+        } else {
+          const childInst = ast.instances.find((i) => i.id === conn.from.node);
+          const childNt = childInst ? nodeTypeMap.get(childInst.nodeType) : void 0;
+          const childOutputDef = childNt?.outputs[conn.from.port];
+          scopedInputDefs[portName] = {
+            dataType: childOutputDef?.dataType ?? "ANY",
+            scope: scopeName,
+            label: childOutputDef?.label ?? portName
+          };
+        }
+      }
+    }
+  }
+  if (!parentNt.expression) {
+    if (!scopedOutputDefs[SCOPED_PORT_NAMES.START]) {
+      scopedOutputDefs[SCOPED_PORT_NAMES.START] = { dataType: "STEP", scope: scopeName, label: "Execute" };
+    }
+    if (!scopedInputDefs[SCOPED_PORT_NAMES.SUCCESS]) {
+      scopedInputDefs[SCOPED_PORT_NAMES.SUCCESS] = { dataType: "STEP", isControlFlow: true, scope: scopeName, label: "On Success" };
+    }
+    if (!scopedInputDefs[SCOPED_PORT_NAMES.FAILURE]) {
+      scopedInputDefs[SCOPED_PORT_NAMES.FAILURE] = { dataType: "STEP", isControlFlow: true, scope: scopeName, failure: true, label: "On Failure" };
+    }
+  }
+  parentNode.outputs = parentNode.outputs.filter((p) => !scopedOutputDefs[p.name]);
+  parentNode.inputs = parentNode.inputs.filter((p) => !scopedInputDefs[p.name]);
+  const scopeOutputPorts = orderedPorts(scopedOutputDefs, "OUTPUT");
+  const scopeInputPorts = orderedPorts(scopedInputDefs, "INPUT");
+  const children = [];
+  for (const childId of childIds) {
+    const childInst = ast.instances.find((i) => i.id === childId);
+    if (!childInst) continue;
+    const childNode = buildInstanceNode(childId, childInst.nodeType, childInst.config, nodeTypeMap, theme);
+    computeNodeDimensions(childNode);
+    if (childInst.config?.width != null) childNode.width = childInst.config.width;
+    if (childInst.config?.height != null) childNode.height = childInst.config.height;
+    children.push(childNode);
+  }
+  if (children.length === 0) return;
+  let childX = 0;
+  const maxChildHeight = Math.max(...children.map((c) => c.height + LABEL_HEIGHT + LABEL_GAP));
+  for (const child of children) {
+    child.x = childX;
+    child.y = LABEL_HEIGHT + LABEL_GAP + (maxChildHeight - LABEL_HEIGHT - LABEL_GAP - child.height) / 2;
+    childX += child.width + SCOPE_INNER_GAP_X;
+  }
+  const childrenWidth = childX > 0 ? childX - SCOPE_INNER_GAP_X : 0;
+  const childrenHeight = maxChildHeight;
+  const scopeOutPortsHeight = portsColumnHeight(scopeOutputPorts.length);
+  const scopeInPortsHeight = portsColumnHeight(scopeInputPorts.length);
+  const parentUI = ast.ui?.instances?.find((u) => u.name === parentNode.id);
+  const uiWidth = parentUI?.expandedWidth ?? parentUI?.width;
+  const uiHeight = parentUI?.expandedHeight ?? parentUI?.height;
+  const maxLeftLabelExtent = scopeOutputPorts.length > 0 ? Math.max(...scopeOutputPorts.map(portLabelExtent)) : 0;
+  const maxRightLabelExtent = scopeInputPorts.length > 0 ? Math.max(...scopeInputPorts.map(portLabelExtent)) : 0;
+  const minInnerWidth = maxLeftLabelExtent + LABEL_CLEARANCE + maxRightLabelExtent;
+  const contentWidth = Math.max(childrenWidth, minInnerWidth);
+  const computedWidth = SCOPE_PORT_COLUMN + SCOPE_PADDING_X + contentWidth + SCOPE_PADDING_X + SCOPE_PORT_COLUMN;
+  const computedHeight = SCOPE_PADDING_Y * 2 + Math.max(childrenHeight, scopeOutPortsHeight, scopeInPortsHeight);
+  parentNode.width = Math.max(parentNode.width, uiWidth ?? computedWidth);
+  parentNode.height = Math.max(parentNode.height, uiHeight ?? computedHeight);
+  parentNode.scopeChildren = children;
+  parentNode.scopePorts = { inputs: scopeInputPorts, outputs: scopeOutputPorts };
+  parentNode.scopeConnections = [];
+}
+function finalizeScopePositions(parentNode, ast, theme = "dark") {
+  const children = parentNode.scopeChildren;
+  const scopePorts = parentNode.scopePorts;
+  if (!children || children.length === 0 || !scopePorts) return;
+  const innerLeft = parentNode.x + SCOPE_PORT_COLUMN + SCOPE_PADDING_X;
+  const innerRight = parentNode.x + parentNode.width - SCOPE_PORT_COLUMN - SCOPE_PADDING_X;
+  const innerWidth = innerRight - innerLeft;
+  const lastChild = children[children.length - 1];
+  const childrenBlockWidth = lastChild.x + lastChild.width;
+  const centerOffsetX = innerLeft + (innerWidth - childrenBlockWidth) / 2;
+  const scopeOriginY = parentNode.y + SCOPE_PADDING_Y;
+  for (const child of children) {
+    child.x += centerOffsetX;
+    child.y += scopeOriginY;
+    computePortPositions(child);
+  }
+  const leftEdgeX = parentNode.x + SCOPE_PORT_COLUMN;
+  positionPortList(scopePorts.outputs, leftEdgeX, parentNode.y);
+  const rightEdgeX = parentNode.x + parentNode.width - SCOPE_PORT_COLUMN;
+  positionPortList(scopePorts.inputs, rightEdgeX, parentNode.y);
+  const childNodeMap = /* @__PURE__ */ new Map();
+  for (const child of children) childNodeMap.set(child.id, child);
+  const childIdSet = new Set(children.map((c) => c.id));
+  parentNode.scopeConnections = [];
+  for (const conn of ast.connections) {
+    const fromIsChild = childIdSet.has(conn.from.node);
+    const toIsChild = childIdSet.has(conn.to.node);
+    const fromIsParent = conn.from.node === parentNode.id;
+    const toIsParent = conn.to.node === parentNode.id;
+    if (!fromIsChild && !toIsChild) continue;
+    if (fromIsParent && toIsChild) {
+      const sourcePort = scopePorts.outputs.find((p) => p.name === conn.from.port);
+      const targetChild = childNodeMap.get(conn.to.node);
+      const targetPort = targetChild?.inputs.find((p) => p.name === conn.to.port);
+      if (sourcePort && targetPort) {
+        parentNode.scopeConnections.push(buildConnection(
+          parentNode.id,
+          conn.from.port,
+          conn.to.node,
+          conn.to.port,
+          sourcePort,
+          targetPort,
+          theme
+        ));
+      }
+      continue;
+    }
+    if (fromIsChild && toIsParent) {
+      const sourceChild = childNodeMap.get(conn.from.node);
+      const sourcePort = sourceChild?.outputs.find((p) => p.name === conn.from.port);
+      const targetPort = scopePorts.inputs.find((p) => p.name === conn.to.port);
+      if (sourcePort && targetPort) {
+        parentNode.scopeConnections.push(buildConnection(
+          conn.from.node,
+          conn.from.port,
+          parentNode.id,
+          conn.to.port,
+          sourcePort,
+          targetPort,
+          theme
+        ));
+      }
+      continue;
+    }
+    if (fromIsChild && toIsChild) {
+      const sourceChild = childNodeMap.get(conn.from.node);
+      const targetChild = childNodeMap.get(conn.to.node);
+      if (sourceChild && targetChild) {
+        const sourcePort = sourceChild.outputs.find((p) => p.name === conn.from.port);
+        const targetPort = targetChild.inputs.find((p) => p.name === conn.to.port);
+        if (sourcePort && targetPort) {
+          parentNode.scopeConnections.push(buildConnection(
+            conn.from.node,
+            conn.from.port,
+            conn.to.node,
+            conn.to.port,
+            sourcePort,
+            targetPort,
+            theme
+          ));
+        }
+      }
+      continue;
+    }
+  }
+  if (children.length > 0) {
+    const connectedScopePorts = new Set(
+      parentNode.scopeConnections.map(
+        (c) => c.fromNode === parentNode.id ? `out:${c.fromPort}` : `in:${c.toPort}`
+      ).filter((k) => k.startsWith("out:") || k.startsWith("in:"))
+    );
+    const firstChild = children[0];
+    const lastChild2 = children[children.length - 1];
+    const execScopePort = scopePorts.outputs.find((p) => isScopedStartPort(p.name));
+    const execChildPort = firstChild.inputs.find((p) => isExecutePort(p.name));
+    if (execScopePort && execChildPort && !connectedScopePorts.has(`out:${execScopePort.name}`)) {
+      parentNode.scopeConnections.push(buildConnection(
+        parentNode.id,
+        execScopePort.name,
+        firstChild.id,
+        execChildPort.name,
+        execScopePort,
+        execChildPort,
+        theme
+      ));
+    }
+    const successScopePort = scopePorts.inputs.find((p) => isScopedSuccessPort(p.name));
+    const successChildPort = lastChild2.outputs.find((p) => isSuccessPort(p.name));
+    if (successScopePort && successChildPort && !connectedScopePorts.has(`in:${successScopePort.name}`)) {
+      parentNode.scopeConnections.push(buildConnection(
+        lastChild2.id,
+        successChildPort.name,
+        parentNode.id,
+        successScopePort.name,
+        successChildPort,
+        successScopePort,
+        theme
+      ));
+    }
+    const failureScopePort = scopePorts.inputs.find((p) => isScopedFailurePort(p.name));
+    const failureChildPort = lastChild2.outputs.find((p) => isFailurePort(p.name));
+    if (failureScopePort && failureChildPort && !connectedScopePorts.has(`in:${failureScopePort.name}`)) {
+      parentNode.scopeConnections.push(buildConnection(
+        lastChild2.id,
+        failureChildPort.name,
+        parentNode.id,
+        failureScopePort.name,
+        failureChildPort,
+        failureScopePort,
+        theme
+      ));
+    }
+  }
+}
+function buildConnection(fromNode, fromPort, toNode, toPort, sourcePort, targetPort, theme = "dark") {
+  const sourceColor = getPortColor(sourcePort.dataType, sourcePort.isFailure, theme);
+  const targetColor = getPortColor(targetPort.dataType, targetPort.isFailure, theme);
+  const path = computeConnectionPath(sourcePort.cx, sourcePort.cy, targetPort.cx, targetPort.cy);
+  return {
+    fromNode,
+    fromPort,
+    toNode,
+    toPort,
+    sourceColor,
+    targetColor,
+    isStepConnection: sourcePort.dataType === "STEP",
+    path
+  };
+}
+
+// src/diagram/geometry.ts
+function buildDiagramGraph(ast, options = {}) {
+  const themeName = options.theme ?? "dark";
+  const nodeTypeMap = buildNodeTypeMap(ast);
+  const { allScopes, scopedChildren } = collectScopes(ast);
+  const diagramNodes = /* @__PURE__ */ new Map();
+  diagramNodes.set("Start", buildStartNode(ast));
+  diagramNodes.set("Exit", buildExitNode(ast));
+  const stepPortsUsed = collectWiredStepPorts(ast);
+  for (const inst of ast.instances) {
+    if (scopedChildren.has(inst.id)) continue;
+    const node = buildInstanceNode(
+      inst.id,
+      inst.nodeType,
+      inst.config,
+      nodeTypeMap,
+      themeName,
+      stepPortsUsed.get(inst.id) ?? /* @__PURE__ */ new Set()
+    );
+    diagramNodes.set(inst.id, node);
+  }
+  for (const node of diagramNodes.values()) {
+    computeNodeDimensions(node);
+  }
+  buildScopeSubGraphs(ast, diagramNodes, allScopes, nodeTypeMap, themeName);
+  applySizeOverrides(ast, diagramNodes, scopedChildren);
+  const { layers } = layoutWorkflow(ast);
+  assignLayerCoordinates(layers, diagramNodes);
+  resolvePostLayoutOverlaps(diagramNodes);
+  for (const node of diagramNodes.values()) {
+    computePortPositions(node);
+  }
+  for (const node of diagramNodes.values()) {
+    if (node.scopeChildren) {
+      finalizeScopePositions(node, ast, themeName);
+    }
+  }
+  const pendingConnections = collectExternalConnections(ast, diagramNodes, scopedChildren);
+  const nodes = Array.from(diagramNodes.values());
+  const extent = normalizeNodes(nodes);
+  const connections = routeConnections(pendingConnections, nodes, themeName);
+  return {
+    nodes,
+    connections,
+    bounds: graphBounds(extent, connections, nodes),
+    workflowName: ast.name
+  };
+}
+
+// src/diagram/ascii-renderer.ts
+function groupByLayer(nodes) {
+  if (nodes.length === 0) return [];
+  const sorted = [...nodes].sort((a, b) => a.x - b.x);
+  const layers = [];
+  let currentX = sorted[0].x;
+  let currentLayer = [];
+  for (const node of sorted) {
+    if (Math.abs(node.x - currentX) > 10) {
+      layers.push(currentLayer);
+      currentLayer = [];
+      currentX = node.x;
+    }
+    currentLayer.push(node);
+  }
+  if (currentLayer.length > 0) layers.push(currentLayer);
+  return layers;
+}
+function buildConnectedPorts(connections) {
+  const s = /* @__PURE__ */ new Set();
+  for (const c of connections) {
+    s.add(`${c.fromNode}.${c.fromPort}`);
+    s.add(`${c.toNode}.${c.toPort}`);
+  }
+  return s;
+}
+function portSymbol(nodeId, port, connected) {
+  return connected.has(`${nodeId}.${port.name}`) ? "\u25CF" : "\u25CB";
+}
+function cornerChar(isStep, hDir, vDir) {
+  if (hDir === "right" && vDir === "down") return isStep ? "\u2554" : "\u250C";
+  if (hDir === "left" && vDir === "down") return isStep ? "\u2557" : "\u2510";
+  if (hDir === "right" && vDir === "up") return isStep ? "\u255A" : "\u2514";
+  if (hDir === "left" && vDir === "up") return isStep ? "\u255D" : "\u2518";
+  return "\u253C";
+}
+var H_CHARS = new Set("\u2500\u2550");
+var V_CHARS = new Set("\u2502\u2551");
+var CharGrid = class {
+  cells;
+  width;
+  height;
+  constructor(w, h) {
+    this.width = w;
+    this.height = h;
+    this.cells = new Array(w * h).fill(" ");
+  }
+  set(x, y, ch) {
+    if (x < 0 || x >= this.width || y < 0 || y >= this.height) return;
+    const existing = this.cells[y * this.width + x];
+    if (existing !== " ") {
+      if (H_CHARS.has(ch) && V_CHARS.has(existing) || V_CHARS.has(ch) && H_CHARS.has(existing)) {
+        this.cells[y * this.width + x] = "\u253C";
+        return;
+      }
+      if (H_CHARS.has(ch) && H_CHARS.has(existing) || V_CHARS.has(ch) && V_CHARS.has(existing)) {
+        return;
+      }
+    }
+    this.cells[y * this.width + x] = ch;
+  }
+  get(x, y) {
+    if (x >= 0 && x < this.width && y >= 0 && y < this.height) {
+      return this.cells[y * this.width + x];
+    }
+    return " ";
+  }
+  /** Force-write, ignoring collision logic (for boxes and text). */
+  forceSet(x, y, ch) {
+    if (x >= 0 && x < this.width && y >= 0 && y < this.height) {
+      this.cells[y * this.width + x] = ch;
+    }
+  }
+  writeStr(x, y, s) {
+    for (let i = 0; i < s.length; i++) {
+      this.forceSet(x + i, y, s[i]);
+    }
+  }
+  toLines() {
+    const lines = [];
+    for (let y = 0; y < this.height; y++) {
+      let line = "";
+      for (let x = 0; x < this.width; x++) {
+        line += this.cells[y * this.width + x];
+      }
+      lines.push(line.trimEnd());
+    }
+    while (lines.length > 0 && lines[lines.length - 1] === "") lines.pop();
+    return lines;
+  }
+};
+function mergePortRows(inputs, outputs) {
+  const rows = [];
+  const maxLen = Math.max(inputs.length, outputs.length);
+  for (let i = 0; i < maxLen; i++) {
+    rows.push({
+      input: i < inputs.length ? inputs[i] : null,
+      output: i < outputs.length ? outputs[i] : null
+    });
+  }
+  return rows;
+}
+function measureBox(node) {
+  const portRows = mergePortRows(node.inputs, node.outputs);
+  const maxInputPortLen = node.inputs.length > 0 ? Math.max(...node.inputs.map((p) => p.name.length)) : 0;
+  const maxOutputPortLen = node.outputs.length > 0 ? Math.max(...node.outputs.map((p) => p.name.length)) : 0;
+  const portsContentWidth = (maxInputPortLen > 0 ? maxInputPortLen + 2 : 0) + 2 + (maxOutputPortLen > 0 ? maxOutputPortLen + 2 : 0);
+  const innerWidth = Math.max(node.label.length + 2, portsContentWidth, 10);
+  const boxWidth = innerWidth + 2;
+  const headerRows = 3;
+  const portRowCount = Math.max(portRows.length, 1);
+  const boxHeight = headerRows + portRowCount + 1;
+  const portRowOffsets = /* @__PURE__ */ new Map();
+  for (let i = 0; i < portRows.length; i++) {
+    if (portRows[i].input) portRowOffsets.set(portRows[i].input.name, headerRows + i);
+    if (portRows[i].output) portRowOffsets.set(portRows[i].output.name, headerRows + i);
+  }
+  return { node, innerWidth, boxWidth, portRows, boxHeight, portRowOffsets };
+}
+function drawBox(grid, box, bx, by, connected) {
+  const { innerWidth, portRows, node } = box;
+  grid.forceSet(bx, by, "\u250C");
+  for (let i = 0; i < innerWidth; i++) grid.forceSet(bx + 1 + i, by, "\u2500");
+  grid.forceSet(bx + innerWidth + 1, by, "\u2510");
+  const labelPad = innerWidth - node.label.length;
+  const padL = Math.floor(labelPad / 2);
+  grid.forceSet(bx, by + 1, "\u2502");
+  grid.writeStr(bx + 1 + padL, by + 1, node.label);
+  grid.forceSet(bx + innerWidth + 1, by + 1, "\u2502");
+  grid.forceSet(bx, by + 2, "\u251C");
+  for (let i = 0; i < innerWidth; i++) grid.forceSet(bx + 1 + i, by + 2, "\u2500");
+  grid.forceSet(bx + innerWidth + 1, by + 2, "\u2524");
+  for (let i = 0; i < Math.max(portRows.length, 1); i++) {
+    const ry = by + 3 + i;
+    grid.forceSet(bx, ry, "\u2502");
+    grid.forceSet(bx + innerWidth + 1, ry, "\u2502");
+    if (i < portRows.length) {
+      const row = portRows[i];
+      if (row.input) {
+        grid.writeStr(bx + 1, ry, `${portSymbol(node.id, row.input, connected)} ${row.input.name}`);
+      }
+      if (row.output) {
+        const txt = `${row.output.name} ${portSymbol(node.id, row.output, connected)}`;
+        grid.writeStr(bx + innerWidth + 1 - txt.length, ry, txt);
+      }
+    }
+  }
+  const bottomY = by + box.boxHeight - 1;
+  grid.forceSet(bx, bottomY, "\u2514");
+  for (let i = 0; i < innerWidth; i++) grid.forceSet(bx + 1 + i, bottomY, "\u2500");
+  grid.forceSet(bx + innerWidth + 1, bottomY, "\u2518");
+}
+function renderASCII(graph) {
+  const layers = groupByLayer(graph.nodes);
+  if (layers.length === 0) return `${graph.workflowName}
+(empty workflow)`;
+  const layerBoxes = layers.map((layer) => layer.map(measureBox));
+  const colWidths = layerBoxes.map((boxes) => Math.max(...boxes.map((b) => b.boxWidth)));
+  const wireGap = 14;
+  const colX = [];
+  let cx = 1;
+  for (let c = 0; c < layerBoxes.length; c++) {
+    colX.push(cx);
+    cx += colWidths[c] + wireGap;
+  }
+  const gridWidth = cx + 1;
+  const nodeColMap = /* @__PURE__ */ new Map();
+  for (let c = 0; c < layerBoxes.length; c++) {
+    for (const box of layerBoxes[c]) nodeColMap.set(box.node.id, c);
+  }
+  let spanCount = 0;
+  for (const conn of graph.connections) {
+    const fc = nodeColMap.get(conn.fromNode);
+    const tc = nodeColMap.get(conn.toNode);
+    if (fc !== void 0 && tc !== void 0 && Math.abs(tc - fc) > 1) spanCount++;
+  }
+  const highwayMargin = spanCount > 0 ? spanCount + 1 : 0;
+  const nodeGapY = 2;
+  const boxPositions = /* @__PURE__ */ new Map();
+  const boxStartY = 3 + highwayMargin;
+  let maxGridHeight = 0;
+  for (let c = 0; c < layerBoxes.length; c++) {
+    let y = boxStartY;
+    for (const box of layerBoxes[c]) {
+      boxPositions.set(box.node.id, { col: c, bx: colX[c], by: y, box });
+      y += box.boxHeight + nodeGapY;
+    }
+    if (y > maxGridHeight) maxGridHeight = y;
+  }
+  maxGridHeight += highwayMargin + 3;
+  const connected = buildConnectedPorts(graph.connections);
+  const grid = new CharGrid(gridWidth, maxGridHeight);
+  const titleX = Math.max(0, Math.floor((gridWidth - graph.workflowName.length) / 2));
+  grid.writeStr(titleX, 1, graph.workflowName);
+  for (const pos of boxPositions.values()) {
+    drawBox(grid, pos.box, pos.bx, pos.by, connected);
+  }
+  drawConnections(grid, graph.connections, boxPositions, boxStartY, maxGridHeight);
+  const scopeLines = [];
+  for (const node of graph.nodes) {
+    if (node.scopeChildren && node.scopeChildren.length > 0) {
+      scopeLines.push("");
+      scopeLines.push(` Scope [${node.label}]:`);
+      if (node.scopeConnections) {
+        for (const sc of node.scopeConnections) {
+          const arrow = sc.isStepConnection ? "\u2550\u2550\u25B6" : "\u2500\u2500\u25B6";
+          scopeLines.push(`   ${sc.fromNode}.${sc.fromPort} ${arrow} ${sc.toNode}.${sc.toPort}${sc.isStepConnection ? "  STEP" : ""}`);
+        }
+      }
+    }
+  }
+  const lines = grid.toLines();
+  lines.push(...scopeLines);
+  lines.push("");
+  lines.push(" \u25CF connected  \u25CB not connected  \u2550\u2550\u25B6 STEP  \u2500\u2500\u25B6 DATA");
+  return lines.join("\n");
+}
+function drawConnections(grid, connections, positions, _boxAreaTop, _gridHeight) {
+  let globalMinY = Infinity;
+  let globalMaxY = 0;
+  for (const pos of positions.values()) {
+    globalMinY = Math.min(globalMinY, pos.by);
+    globalMaxY = Math.max(globalMaxY, pos.by + pos.box.boxHeight);
+  }
+  const sorted = [...connections].sort((a, b) => {
+    const fa = positions.get(a.fromNode);
+    const ta = positions.get(a.toNode);
+    const fb = positions.get(b.fromNode);
+    const tb = positions.get(b.toNode);
+    if (!fa || !ta || !fb || !tb) return 0;
+    const spanA = Math.abs(ta.col - fa.col);
+    const spanB = Math.abs(tb.col - fb.col);
+    if (spanA !== spanB) return spanA - spanB;
+    const ya = fa.by + (fa.box.portRowOffsets.get(a.fromPort) ?? 0);
+    const yb = fb.by + (fb.box.portRowOffsets.get(b.fromPort) ?? 0);
+    return ya - yb;
+  });
+  const usedTracks = /* @__PURE__ */ new Map();
+  let nextAboveHighway = globalMinY - 2;
+  let nextBelowHighway = globalMaxY + 1;
+  for (const conn of sorted) {
+    const fromPos = positions.get(conn.fromNode);
+    const toPos = positions.get(conn.toNode);
+    if (!fromPos || !toPos) continue;
+    const fromRowOff = fromPos.box.portRowOffsets.get(conn.fromPort);
+    const toRowOff = toPos.box.portRowOffsets.get(conn.toPort);
+    if (fromRowOff === void 0 || toRowOff === void 0) continue;
+    const y1 = fromPos.by + fromRowOff;
+    const y2 = toPos.by + toRowOff;
+    const x1 = fromPos.bx + fromPos.box.boxWidth;
+    const x2 = toPos.bx - 1;
+    const isStep = conn.isStepConnection;
+    const hCh = isStep ? "\u2550" : "\u2500";
+    const vCh = isStep ? "\u2551" : "\u2502";
+    const isAdjacent = toPos.col === fromPos.col + 1;
+    if (isAdjacent) {
+      drawAdjacentRoute(grid, x1, y1, x2, y2, hCh, vCh, isStep, usedTracks, fromPos, toPos);
+    } else {
+      const avgY = (y1 + y2) / 2;
+      const midBoxY = (globalMinY + globalMaxY) / 2;
+      let highwayY;
+      if (avgY <= midBoxY) {
+        highwayY = nextAboveHighway;
+        nextAboveHighway--;
+      } else {
+        highwayY = nextBelowHighway;
+        nextBelowHighway++;
+      }
+      drawSpanningRoute(grid, x1, y1, x2, y2, highwayY, hCh, vCh, isStep, usedTracks, fromPos, toPos);
+    }
+  }
+}
+function drawAdjacentRoute(grid, x1, y1, x2, y2, hCh, vCh, isStep, usedTracks, fromPos, toPos) {
+  if (y1 === y2) {
+    for (let x = x1; x < x2; x++) grid.set(x, y1, hCh);
+    grid.set(x2, y1, "\u25B6");
+    return;
+  }
+  const gapStart = fromPos.bx + fromPos.box.boxWidth + 1;
+  const gapEnd = toPos.bx - 2;
+  const midX = findTrack(usedTracks, gapStart, gapEnd, y1, y2);
+  markTrack(usedTracks, midX, y1, y2);
+  for (let x = x1; x < midX; x++) grid.set(x, y1, hCh);
+  grid.set(midX, y1, cornerChar(isStep, "left", y2 > y1 ? "down" : "up"));
+  drawVerticalSegment(grid, midX, y1, y2, vCh);
+  grid.set(midX, y2, cornerChar(isStep, "right", y2 > y1 ? "up" : "down"));
+  for (let x = midX + 1; x < x2; x++) grid.set(x, y2, hCh);
+  grid.set(x2, y2, "\u25B6");
+}
+function drawSpanningRoute(grid, x1, y1, x2, y2, highwayY, hCh, vCh, isStep, usedTracks, fromPos, toPos) {
+  const srcGapStart = fromPos.bx + fromPos.box.boxWidth + 1;
+  const srcGapEnd = srcGapStart + 10;
+  const srcMidX = findTrack(usedTracks, srcGapStart, srcGapEnd, y1, highwayY);
+  markTrack(usedTracks, srcMidX, y1, highwayY);
+  const tgtGapEnd = toPos.bx - 2;
+  const tgtGapStart = tgtGapEnd - 10;
+  const tgtMidX = findTrack(usedTracks, tgtGapStart, tgtGapEnd, highwayY, y2);
+  markTrack(usedTracks, tgtMidX, highwayY, y2);
+  const goingDown = highwayY > y1;
+  const goingUp = y2 < highwayY;
+  for (let x = x1; x < srcMidX; x++) grid.set(x, y1, hCh);
+  grid.set(srcMidX, y1, cornerChar(isStep, "left", goingDown ? "down" : "up"));
+  drawVerticalSegment(grid, srcMidX, y1, highwayY, vCh);
+  grid.set(srcMidX, highwayY, cornerChar(isStep, "right", goingDown ? "up" : "down"));
+  for (let x = srcMidX + 1; x < tgtMidX; x++) grid.set(x, highwayY, hCh);
+  grid.set(tgtMidX, highwayY, cornerChar(isStep, "left", goingUp ? "up" : "down"));
+  drawVerticalSegment(grid, tgtMidX, highwayY, y2, vCh);
+  grid.set(tgtMidX, y2, cornerChar(isStep, "right", goingUp ? "down" : "up"));
+  for (let x = tgtMidX + 1; x < x2; x++) grid.set(x, y2, hCh);
+  grid.set(x2, y2, "\u25B6");
+}
+function drawVerticalSegment(grid, x, y1, y2, vCh) {
+  const minY = Math.min(y1, y2);
+  const maxY = Math.max(y1, y2);
+  for (let y = minY + 1; y < maxY; y++) {
+    grid.set(x, y, vCh);
+  }
+}
+function findTrack(usedTracks, gapStart, gapEnd, y1, y2) {
+  const minY = Math.min(y1, y2);
+  const maxY = Math.max(y1, y2);
+  const actualStart = Math.min(gapStart, gapEnd);
+  const actualEnd = Math.max(gapStart, gapEnd);
+  const mid = Math.floor((actualStart + actualEnd) / 2);
+  for (let offset = 0; offset <= actualEnd - actualStart; offset++) {
+    for (const candidate of [mid + offset, mid - offset]) {
+      if (candidate < actualStart || candidate > actualEnd) continue;
+      const existing = usedTracks.get(candidate);
+      if (!existing) return candidate;
+      let conflict = false;
+      for (let y = minY; y <= maxY; y++) {
+        if (existing.has(y)) {
+          conflict = true;
+          break;
+        }
+      }
+      if (!conflict) return candidate;
+    }
+  }
+  return mid;
+}
+function markTrack(usedTracks, x, y1, y2) {
+  if (!usedTracks.has(x)) usedTracks.set(x, /* @__PURE__ */ new Set());
+  const s = usedTracks.get(x);
+  const minY = Math.min(y1, y2);
+  const maxY = Math.max(y1, y2);
+  for (let y = minY; y <= maxY; y++) s.add(y);
+}
+function renderASCIICompact(graph) {
+  const layers = groupByLayer(graph.nodes);
+  if (layers.length === 0) return `${graph.workflowName}
+(empty workflow)`;
+  const outputLines = [];
+  outputLines.push(graph.workflowName);
+  outputLines.push("");
+  const mainChain = [];
+  const parallelNodes = [];
+  for (const layer of layers) {
+    mainChain.push(layer[0]);
+    for (let i = 1; i < layer.length; i++) parallelNodes.push(layer[i]);
+  }
+  const topParts = [];
+  const midParts = [];
+  const botParts = [];
+  for (let i = 0; i < mainChain.length; i++) {
+    const node = mainChain[i];
+    const innerWidth = Math.max(node.label.length + 2, 5);
+    const padLeft = Math.floor((innerWidth - node.label.length) / 2);
+    const padRight = innerWidth - node.label.length - padLeft;
+    topParts.push("\u250C" + "\u2500".repeat(innerWidth) + "\u2510");
+    midParts.push("\u2502" + " ".repeat(padLeft) + node.label + " ".repeat(padRight) + "\u2502");
+    botParts.push("\u2514" + "\u2500".repeat(innerWidth) + "\u2518");
+    if (i < mainChain.length - 1) {
+      topParts.push("    ");
+      midParts.push("\u2501\u2501\u2501\u25B6");
+      botParts.push("    ");
+    }
+  }
+  outputLines.push(" " + topParts.join(""));
+  outputLines.push(" " + midParts.join(""));
+  outputLines.push(" " + botParts.join(""));
+  if (parallelNodes.length > 0) {
+    outputLines.push("");
+    outputLines.push(" Parallel: " + parallelNodes.map((n) => n.label).join(", "));
+  }
+  for (const node of graph.nodes) {
+    if (node.scopeChildren && node.scopeChildren.length > 0) {
+      outputLines.push("");
+      outputLines.push(` Scope [${node.label}]: ` + node.scopeChildren.map((c) => c.label).join(" \u2501\u25B6 "));
+    }
+  }
+  return outputLines.join("\n");
+}
+function renderText(graph) {
+  const lines = [];
+  const connected = buildConnectedPorts(graph.connections);
+  lines.push(graph.workflowName);
+  lines.push("\u2550".repeat(graph.workflowName.length));
+  lines.push("");
+  lines.push("Nodes:");
+  const maxLabelLen = Math.max(...graph.nodes.map((n) => n.label.length), 5);
+  for (const node of graph.nodes) {
+    const label = node.label.padEnd(maxLabelLen);
+    const inputPorts = node.inputs.map((p) => `${p.name}${portSymbol(node.id, p, connected)}`);
+    const outputPorts = node.outputs.map((p) => `${p.name}${portSymbol(node.id, p, connected)}`);
+    const inputStr = inputPorts.length > 0 ? `[${inputPorts.join(", ")}]` : "";
+    const outputStr = outputPorts.length > 0 ? `[${outputPorts.join(", ")}]` : "";
+    if (inputStr && outputStr) {
+      lines.push(`  ${label}  ${inputStr} \u2192 ${outputStr}`);
+    } else if (outputStr) {
+      lines.push(`  ${label}  ${outputStr}`);
+    } else if (inputStr) {
+      lines.push(`  ${label}  ${inputStr}`);
+    } else {
+      lines.push(`  ${label}`);
+    }
+    if (node.scopeChildren && node.scopeChildren.length > 0) {
+      lines.push(`  ${" ".repeat(maxLabelLen)}    scope: ${node.scopeChildren.map((c) => c.label).join(", ")}`);
+    }
+  }
+  if (graph.connections.length > 0) {
+    lines.push("");
+    lines.push("Connections:");
+    const maxFromLen = Math.max(...graph.connections.map((c) => `${c.fromNode}.${c.fromPort}`.length));
+    for (const conn of graph.connections) {
+      const from = `${conn.fromNode}.${conn.fromPort}`.padEnd(maxFromLen);
+      const arrow = conn.isStepConnection ? "\u2501\u2501\u25B6" : "\u2500\u2500\u25B6";
+      const to = `${conn.toNode}.${conn.toPort}`;
+      const type = conn.isStepConnection ? "STEP" : "";
+      lines.push(`  ${from}  ${arrow} ${to}${type ? "  " + type : ""}`);
+    }
+  }
+  return lines.join("\n");
+}
+
+export {
+  buildDiagramGraph,
+  renderASCII,
+  renderASCIICompact,
+  renderText
+};