@theodo-group/epure 0.1.0 → 0.2.0

package/dist-lib/render.js

@@ -0,0 +1,2717 @@
+import {
+  Area,
+  AreaLabel,
+  Edge,
+  EdgeDefs,
+  Node,
+  STROKE_WIDTH,
+  labelPillSize
+} from "./chunk-7YSWFGM7.js";
+import {
+  iconById
+} from "./chunk-KBK6AYWD.js";
+
+// lib/render.ts
+import { existsSync } from "fs";
+import { dirname, join as join2 } from "path";
+import { fileURLToPath } from "url";
+
+// src/layout/elk.ts
+import {
+  init,
+  routeEdges
+} from "@mr_mint/elkjs-libavoid";
+
+// src/layout/areaTree.ts
+var buildAreaTree = (areas) => {
+  const byId = new Map(areas.map((a) => [a.id, a]));
+  const parentsOf = /* @__PURE__ */ new Map();
+  for (const a of areas) {
+    for (const mid of a.members) {
+      if (!byId.has(mid) || mid === a.id) continue;
+      const arr = parentsOf.get(mid) ?? [];
+      arr.push(a.id);
+      parentsOf.set(mid, arr);
+    }
+  }
+  const depthOf = /* @__PURE__ */ new Map();
+  const depth = (id, stack) => {
+    const hit = depthOf.get(id);
+    if (hit !== void 0) return hit;
+    if (stack.has(id)) return 0;
+    stack.add(id);
+    let d = 0;
+    for (const pid of parentsOf.get(id) ?? []) {
+      d = Math.max(d, depth(pid, stack) + 1);
+    }
+    stack.delete(id);
+    depthOf.set(id, d);
+    return d;
+  };
+  for (const a of areas) depth(a.id, /* @__PURE__ */ new Set());
+  const leafNodesOf = /* @__PURE__ */ new Map();
+  const leaves = (id, stack) => {
+    const hit = leafNodesOf.get(id);
+    if (hit) return hit;
+    const out = /* @__PURE__ */ new Set();
+    if (stack.has(id)) return out;
+    stack.add(id);
+    for (const mid of byId.get(id)?.members ?? []) {
+      if (byId.has(mid)) {
+        for (const n of leaves(mid, stack)) out.add(n);
+      } else {
+        out.add(mid);
+      }
+    }
+    stack.delete(id);
+    leafNodesOf.set(id, out);
+    return out;
+  };
+  for (const a of areas) leaves(a.id, /* @__PURE__ */ new Set());
+  const ancestorsOf = /* @__PURE__ */ new Map();
+  const ancestors = (id, stack) => {
+    const hit = ancestorsOf.get(id);
+    if (hit) return hit;
+    const out = /* @__PURE__ */ new Set();
+    if (stack.has(id)) return out;
+    stack.add(id);
+    for (const pid of parentsOf.get(id) ?? []) {
+      out.add(pid);
+      for (const anc of ancestors(pid, stack)) out.add(anc);
+    }
+    stack.delete(id);
+    ancestorsOf.set(id, out);
+    return out;
+  };
+  for (const a of areas) ancestors(a.id, /* @__PURE__ */ new Set());
+  return { byId, depthOf, leafNodesOf, ancestorsOf };
+};
+
+// src/layout/elk.ts
+var wasmLocator = "/libavoid.wasm";
+var setLibavoidWasmPath = (path) => {
+  wasmLocator = path;
+};
+var AREA_PAD = 24;
+var NESTED_AREA_PAD = 48;
+var TITLE_INSET_X = 14;
+var TITLE_HEIGHT = 22;
+var TITLE_CHAR_PX = 7;
+var TITLE_PAD_X = 10;
+var TITLE_MIN_W = 40;
+var areaTitleRect = (areaRect, label) => ({
+  x: areaRect.x + TITLE_INSET_X,
+  y: areaRect.y - TITLE_HEIGHT / 2,
+  w: Math.max(TITLE_MIN_W, label.length * TITLE_CHAR_PX + TITLE_PAD_X * 2),
+  h: TITLE_HEIGHT
+});
+var areaBlocksEdge = (area, srcId, tgtId) => !area.members.has(srcId) && !area.members.has(tgtId);
+var rectContains = (outer, inner) => inner.x >= outer.x && inner.y >= outer.y && inner.x + inner.w <= outer.x + outer.w && inner.y + inner.h <= outer.y + outer.h;
+var routeOptions = (gridSize) => ({
+  routingType: "orthogonal",
+  shapeBufferDistance: Math.max(8, gridSize / 2),
+  idealNudgingDistance: gridSize,
+  segmentPenalty: 10,
+  // A crossing costs ~10 extra segments (segmentPenalty 10) — enough to detour
+  // around an avoidable crossing without over-bending simple diagrams.
+  crossingPenalty: 100,
+  nudgeOrthogonalSegmentsConnectedToShapes: true,
+  nudgeSharedPathsWithCommonEndPoint: true
+});
+var edgeKey = (sourceId, targetId) => `${sourceId}->${targetId}`;
+var snap = (v, gridSize) => Math.round(v / gridSize) * gridSize;
+var polylineLength = (points) => {
+  let total = 0;
+  for (let i = 1; i < points.length; i += 1) {
+    const a = points[i - 1];
+    const b = points[i];
+    total += Math.hypot(b.x - a.x, b.y - a.y);
+  }
+  return total;
+};
+var longestHorizontalMidpoint = (points) => {
+  let bestLen = 0;
+  let best;
+  for (let i = 1; i < points.length; i += 1) {
+    const a = points[i - 1];
+    const b = points[i];
+    if (a.y === b.y) {
+      const len = Math.abs(b.x - a.x);
+      if (len > bestLen) {
+        bestLen = len;
+        best = { x: (a.x + b.x) / 2, y: a.y };
+      }
+    }
+  }
+  return best;
+};
+var pathMidpoint = (points) => {
+  if (points.length === 0) return { x: 0, y: 0 };
+  const total = polylineLength(points);
+  const half = total / 2;
+  let acc = 0;
+  for (let i = 1; i < points.length; i += 1) {
+    const a = points[i - 1];
+    const b = points[i];
+    const seg = Math.hypot(b.x - a.x, b.y - a.y);
+    if (acc + seg >= half) {
+      const t = seg === 0 ? 0 : (half - acc) / seg;
+      return { x: a.x + (b.x - a.x) * t, y: a.y + (b.y - a.y) * t };
+    }
+    acc += seg;
+  }
+  return points[points.length - 1];
+};
+var distToRect = (p, r) => {
+  const dx = Math.max(r.x - p.x, 0, p.x - (r.x + r.w));
+  const dy = Math.max(r.y - p.y, 0, p.y - (r.y + r.h));
+  return Math.hypot(dx, dy);
+};
+var clearanceAt = (p, nodes) => {
+  let min = Infinity;
+  for (const id in nodes) min = Math.min(min, distToRect(p, nodes[id]));
+  return min;
+};
+var LABEL_MIN_CLEARANCE = 12;
+var chooseLabelAnchor = (points, nodes) => {
+  const preferred = longestHorizontalMidpoint(points) ?? pathMidpoint(points);
+  if (clearanceAt(preferred, nodes) >= LABEL_MIN_CLEARANCE) return preferred;
+  let best = preferred;
+  let bestClear = clearanceAt(preferred, nodes);
+  const STEP = 16;
+  for (let i = 1; i < points.length; i += 1) {
+    const a = points[i - 1];
+    const b = points[i];
+    const len = Math.hypot(b.x - a.x, b.y - a.y);
+    const steps = Math.max(1, Math.round(len / STEP));
+    for (let s = 1; s < steps; s += 1) {
+      const t = s / steps;
+      const p = { x: a.x + (b.x - a.x) * t, y: a.y + (b.y - a.y) * t };
+      const c = clearanceAt(p, nodes);
+      if (c > bestClear) {
+        bestClear = c;
+        best = p;
+      }
+    }
+  }
+  return best;
+};
+var makeEdgeId = (source, target, index) => `${source}->${target}#${index}`;
+var toPixelRect = (node, gridSize) => ({
+  x: (node.cx - node.w / 2) * gridSize,
+  y: (node.cy - node.h / 2) * gridSize,
+  w: node.w * gridSize,
+  h: node.h * gridSize
+});
+var faceCache = null;
+var topologySig = (diagram) => diagram.nodes.map((n) => n.id).join(",") + "|" + diagram.edges.map((e) => `${e.source}>${e.target}`).join(",") + "|" + diagram.areas.map((a) => `${a.id}:${[...a.members].sort().join("+")}`).join(",");
+var route = async (diagram, layout, opts = {}) => {
+  const { gridSize } = layout;
+  const quick = opts.quick === true;
+  const pixelNodes = {};
+  for (const [id, node] of Object.entries(layout.nodes)) {
+    pixelNodes[id] = toPixelRect(node, gridSize);
+  }
+  const ensureRect = (id) => {
+    if (!pixelNodes[id]) {
+      pixelNodes[id] = toPixelRect({ cx: 0, cy: 0, w: 4, h: 2 }, gridSize);
+    }
+  };
+  for (const n of diagram.nodes) ensureRect(n.id);
+  for (const e of diagram.edges) {
+    ensureRect(e.source);
+    ensureRect(e.target);
+  }
+  const areaTree = buildAreaTree(diagram.areas);
+  const areaRectById = /* @__PURE__ */ new Map();
+  const NEST_EXTRA = NESTED_AREA_PAD - AREA_PAD;
+  const computeAreaRect = (aid, stack) => {
+    const hit = areaRectById.get(aid);
+    if (hit) return hit;
+    if (stack.has(aid)) return null;
+    stack.add(aid);
+    const area = areaTree.byId.get(aid);
+    let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;
+    for (const mid of area.members) {
+      let r;
+      if (areaTree.byId.has(mid)) {
+        const child = computeAreaRect(mid, stack);
+        r = child && {
+          x: child.x - NEST_EXTRA,
+          y: child.y - NEST_EXTRA,
+          w: child.w + NEST_EXTRA * 2,
+          h: child.h + NEST_EXTRA * 2
+        };
+      } else {
+        r = pixelNodes[mid] ?? null;
+      }
+      if (!r) continue;
+      minX = Math.min(minX, r.x);
+      minY = Math.min(minY, r.y);
+      maxX = Math.max(maxX, r.x + r.w);
+      maxY = Math.max(maxY, r.y + r.h);
+    }
+    stack.delete(aid);
+    if (!isFinite(minX)) return null;
+    const rect = {
+      x: minX - AREA_PAD,
+      y: minY - AREA_PAD,
+      w: maxX - minX + AREA_PAD * 2,
+      h: maxY - minY + AREA_PAD * 2
+    };
+    areaRectById.set(aid, rect);
+    return rect;
+  };
+  const areaObstacles = [];
+  for (const a of diagram.areas) {
+    const rect = computeAreaRect(a.id, /* @__PURE__ */ new Set());
+    if (!rect) continue;
+    areaObstacles.push({
+      id: a.id,
+      rect,
+      members: areaTree.leafNodesOf.get(a.id) ?? /* @__PURE__ */ new Set()
+    });
+  }
+  const titleObstacles = [];
+  for (const a of diagram.areas) {
+    if (!a.label) continue;
+    const rect = areaRectById.get(a.id);
+    if (!rect) continue;
+    titleObstacles.push({
+      id: a.id,
+      rect: areaTitleRect(rect, a.label),
+      members: /* @__PURE__ */ new Set()
+    });
+  }
+  const titleChildren = titleObstacles.map((t) => ({
+    id: `__title__${t.id}`,
+    x: t.rect.x,
+    y: t.rect.y,
+    width: t.rect.w,
+    height: t.rect.h
+  }));
+  const edgeMeta = /* @__PURE__ */ new Map();
+  const edgeIds = [];
+  diagram.edges.forEach((e, i) => {
+    const src = pixelNodes[e.source];
+    const tgt = pixelNodes[e.target];
+    const srcCx = src.x + src.w / 2;
+    const srcCy = src.y + src.h / 2;
+    const tgtCx = tgt.x + tgt.w / 2;
+    const tgtCy = tgt.y + tgt.h / 2;
+    const dx = tgtCx - srcCx;
+    const dy = tgtCy - srcCy;
+    let sourceSide;
+    let targetSide;
+    if (Math.abs(dx) >= Math.abs(dy)) {
+      sourceSide = dx >= 0 ? "E" : "W";
+      targetSide = dx >= 0 ? "W" : "E";
+    } else {
+      sourceSide = dy >= 0 ? "S" : "N";
+      targetSide = dy >= 0 ? "N" : "S";
+    }
+    const stored = layout.edges[edgeKey(e.source, e.target)];
+    const explicitSource = stored?.sourceSide !== void 0;
+    const explicitTarget = stored?.targetSide !== void 0;
+    if (explicitSource) sourceSide = stored.sourceSide;
+    if (explicitTarget) targetSide = stored.targetSide;
+    const id = makeEdgeId(e.source, e.target, i);
+    edgeMeta.set(id, {
+      source: e.source,
+      target: e.target,
+      sourceSide,
+      targetSide,
+      explicitSource,
+      explicitTarget
+    });
+    edgeIds.push(id);
+  });
+  const options = routeOptions(gridSize);
+  const sig = topologySig(diagram);
+  const cacheHit = faceCache?.sig === sig;
+  if (quick && cacheHit) {
+    for (const id of edgeIds) {
+      const m = edgeMeta.get(id);
+      const f = faceCache.faces.get(id);
+      if (!f) continue;
+      if (!m.explicitSource) m.sourceSide = f.s;
+      if (!m.explicitTarget) m.targetSide = f.t;
+    }
+  } else {
+    try {
+      await init(wasmLocator);
+      const plainNodes = diagram.nodes.map((n) => {
+        const pos = pixelNodes[n.id];
+        return { id: n.id, x: pos.x, y: pos.y, width: pos.w, height: pos.h };
+      });
+      const centerEdges = edgeIds.map((id) => {
+        const m = edgeMeta.get(id);
+        return { id, source: m.source, target: m.target };
+      });
+      const learned = await routeEdges(
+        { id: "root", children: plainNodes, edges: centerEdges },
+        options
+      );
+      for (const id of edgeIds) {
+        const m = edgeMeta.get(id);
+        if (m.explicitSource && m.explicitTarget) continue;
+        const res = learned.get(id);
+        if (!res) continue;
+        const poly = cleanPolyline([res.sourcePoint, ...res.bendPoints, res.targetPoint]);
+        if (poly.length < 2) continue;
+        if (!m.explicitSource) m.sourceSide = sideFromSegment(poly[0], poly[1]);
+        if (!m.explicitTarget) {
+          m.targetSide = sideFromSegment(poly[poly.length - 1], poly[poly.length - 2]);
+        }
+      }
+      const faces = /* @__PURE__ */ new Map();
+      for (const id of edgeIds) {
+        const m = edgeMeta.get(id);
+        faces.set(id, { s: m.sourceSide, t: m.targetSide });
+      }
+      faceCache = { sig, faces };
+    } catch {
+    }
+  }
+  const edgeAnchors = computeEdgeAnchors(edgeIds, edgeMeta, pixelNodes, areaObstacles);
+  const srcPortId = (id) => `${id}::s`;
+  const tgtPortId = (id) => `${id}::t`;
+  const buildGraph = (anchors) => {
+    const portsByNode = /* @__PURE__ */ new Map();
+    const addPort = (nodeId, pid, abs) => {
+      const node = pixelNodes[nodeId];
+      const arr = portsByNode.get(nodeId) ?? [];
+      arr.push({ id: pid, x: abs.x - node.x, y: abs.y - node.y, width: 0, height: 0 });
+      portsByNode.set(nodeId, arr);
+    };
+    for (const id of edgeIds) {
+      const m = edgeMeta.get(id);
+      const h = anchors.get(id);
+      addPort(m.source, srcPortId(id), h.sourceAnchor);
+      addPort(m.target, tgtPortId(id), h.targetAnchor);
+    }
+    const elkNodes = diagram.nodes.map((n) => {
+      const pos = pixelNodes[n.id];
+      return { id: n.id, x: pos.x, y: pos.y, width: pos.w, height: pos.h, ports: portsByNode.get(n.id) ?? [] };
+    });
+    const elkEdges = edgeIds.map((id) => {
+      const m = edgeMeta.get(id);
+      return { id, source: m.source, target: m.target, sourcePort: srcPortId(id), targetPort: tgtPortId(id) };
+    });
+    return { elkNodes, elkEdges };
+  };
+  const runLibavoid = async (elkNodes, elkEdges, skipAreas = false) => {
+    await init(wasmLocator);
+    if (skipAreas || areaObstacles.length === 0) {
+      return routeEdges(
+        { id: "root", children: [...elkNodes, ...titleChildren], edges: elkEdges },
+        options
+      );
+    }
+    const groups = /* @__PURE__ */ new Map();
+    for (const e of elkEdges) {
+      const m = edgeMeta.get(e.id);
+      const blocking = areaObstacles.filter((a) => areaBlocksEdge(a, m.source, m.target));
+      const blockingIds = new Set(blocking.map((a) => a.id));
+      const topmost = blocking.filter((a) => {
+        const ancs = areaTree.ancestorsOf.get(a.id);
+        if (!ancs) return true;
+        for (const anc of ancs) if (blockingIds.has(anc)) return false;
+        return true;
+      });
+      const sig2 = topmost.map((a) => a.id).sort().join("|");
+      let g = groups.get(sig2);
+      if (!g) {
+        g = { areas: topmost, edges: [] };
+        groups.set(sig2, g);
+      }
+      g.edges.push(e);
+    }
+    const merged = /* @__PURE__ */ new Map();
+    for (const g of groups.values()) {
+      const covered = /* @__PURE__ */ new Set();
+      for (const a of g.areas) for (const nid of a.members) covered.add(nid);
+      const areaChildren = g.areas.map((a) => ({
+        id: `__area__${a.id}`,
+        x: a.rect.x,
+        y: a.rect.y,
+        width: a.rect.w,
+        height: a.rect.h
+      }));
+      const groupTitles = [];
+      for (const t of titleObstacles) {
+        if (g.areas.some((a) => rectContains(a.rect, t.rect))) continue;
+        groupTitles.push({
+          id: `__title__${t.id}`,
+          x: t.rect.x,
+          y: t.rect.y,
+          width: t.rect.w,
+          height: t.rect.h
+        });
+      }
+      const r = await routeEdges(
+        {
+          id: "root",
+          children: [
+            ...elkNodes.filter((n) => !covered.has(n.id)),
+            ...areaChildren,
+            ...groupTitles
+          ],
+          edges: g.edges
+        },
+        options
+      );
+      for (const [k, v] of r) merged.set(k, v);
+    }
+    return merged;
+  };
+  const routeOnce = async (anchors, skipAreas = false) => {
+    const { elkNodes, elkEdges } = buildGraph(anchors);
+    return runLibavoid(elkNodes, elkEdges, skipAreas);
+  };
+  let routes;
+  let libavoidOk = false;
+  try {
+    routes = await routeOnce(edgeAnchors, quick);
+    libavoidOk = true;
+  } catch {
+    routes = /* @__PURE__ */ new Map();
+    for (const id of edgeIds) {
+      const meta = edgeMeta.get(id);
+      const h = edgeAnchors.get(id);
+      routes.set(id, {
+        sourcePoint: h.sourceAnchor,
+        targetPoint: h.targetAnchor,
+        bendPoints: [],
+        sourceSide: connectionSideFromSide(meta.sourceSide),
+        targetSide: connectionSideFromSide(meta.targetSide)
+      });
+    }
+  }
+  if (libavoidOk && !quick) {
+    const MAX_ROUNDS = 4;
+    const polysOf = (rs) => {
+      const m = /* @__PURE__ */ new Map();
+      for (const id of edgeIds) {
+        const r = rs.get(id);
+        if (r) m.set(id, polyOf(r));
+      }
+      return m;
+    };
+    let bestPolys = polysOf(routes);
+    let bestCount = crossingPairs(bestPolys, edgeIds).length;
+    for (let round = 0; round < MAX_ROUNDS && bestCount > 0; round += 1) {
+      const used = /* @__PURE__ */ new Set();
+      const swaps = [];
+      for (const [a, b] of crossingPairs(bestPolys, edgeIds)) {
+        if (used.has(a) || used.has(b)) continue;
+        const f = sharedFace(a, b, edgeMeta);
+        if (!f) continue;
+        used.add(a);
+        used.add(b);
+        swaps.push({ a, b, endA: f.endA, endB: f.endB });
+      }
+      if (swaps.length === 0) break;
+      const trial = new Map(edgeAnchors);
+      for (const s of swaps) {
+        const pa = anchorEnd(trial.get(s.a), s.endA);
+        const pb = anchorEnd(trial.get(s.b), s.endB);
+        trial.set(s.a, withAnchorEnd(trial.get(s.a), s.endA, pb));
+        trial.set(s.b, withAnchorEnd(trial.get(s.b), s.endB, pa));
+      }
+      const trialRoutes = await routeOnce(trial);
+      const trialPolys = polysOf(trialRoutes);
+      const trialCount = crossingPairs(trialPolys, edgeIds).length;
+      if (trialCount < bestCount) {
+        for (const s of swaps) {
+          const pa = anchorEnd(edgeAnchors.get(s.a), s.endA);
+          const pb = anchorEnd(edgeAnchors.get(s.b), s.endB);
+          edgeAnchors.set(s.a, withAnchorEnd(edgeAnchors.get(s.a), s.endA, pb));
+          edgeAnchors.set(s.b, withAnchorEnd(edgeAnchors.get(s.b), s.endB, pa));
+        }
+        routes = trialRoutes;
+        bestPolys = trialPolys;
+        bestCount = trialCount;
+      } else {
+        break;
+      }
+    }
+  }
+  const libPolys = /* @__PURE__ */ new Map();
+  const snapObstacles = [...areaObstacles, ...titleObstacles];
+  if (libavoidOk) {
+    for (const id of edgeIds) {
+      const meta = edgeMeta.get(id);
+      const result = routes.get(id);
+      if (!result) continue;
+      const poly = cleanPolyline([
+        result.sourcePoint,
+        ...result.bendPoints,
+        result.targetPoint
+      ]);
+      if (poly.length < 2) continue;
+      if (!isOrthogonalPath(poly)) continue;
+      const libSourceSide = sideFromSegment(poly[0], poly[1]);
+      const libTargetSide = sideFromSegment(
+        poly[poly.length - 1],
+        poly[poly.length - 2]
+      );
+      if (meta.explicitSource && libSourceSide !== meta.sourceSide || meta.explicitTarget && libTargetSide !== meta.targetSide) {
+        continue;
+      }
+      libPolys.set(
+        id,
+        snapPolylineToGrid(poly, gridSize, pixelNodes, snapObstacles, meta.source, meta.target)
+      );
+    }
+  }
+  resolveSegmentOverlaps(edgeAnchors, edgeMeta, pixelNodes, gridSize, libPolys);
+  const routedEdges = [];
+  for (const id of edgeIds) {
+    const meta = edgeMeta.get(id);
+    const lib = libPolys.get(id);
+    let points;
+    if (lib) {
+      points = lib;
+    } else {
+      const { sourceAnchor, targetAnchor, bendCoord } = edgeAnchors.get(id);
+      points = buildOrthogonalPath(
+        sourceAnchor,
+        targetAnchor,
+        meta.sourceSide,
+        meta.targetSide,
+        gridSize,
+        bendCoord
+      );
+    }
+    const styleSpec = layout.edges[edgeKey(meta.source, meta.target)];
+    const baseAnchor = chooseLabelAnchor(points, pixelNodes);
+    const labelDx = styleSpec?.labelDx ?? 0;
+    const labelDy = styleSpec?.labelDy ?? 0;
+    const labelAnchor = baseAnchor ? { x: baseAnchor.x + labelDx * gridSize, y: baseAnchor.y + labelDy * gridSize } : void 0;
+    routedEdges.push({
+      id,
+      source: { nodeId: meta.source, side: meta.sourceSide },
+      target: { nodeId: meta.target, side: meta.targetSide },
+      points,
+      labelAnchor,
+      color: styleSpec?.color,
+      lineStyle: styleSpec?.lineStyle,
+      width: styleSpec?.width,
+      startCap: styleSpec?.startCap,
+      endCap: styleSpec?.endCap,
+      // Surfaced so the label drag handle can read the committed offset as its
+      // starting point (the anchor above already bakes it in).
+      labelDx: styleSpec?.labelDx,
+      labelDy: styleSpec?.labelDy
+    });
+  }
+  const nodes = diagram.nodes.map((n) => {
+    const pos = pixelNodes[n.id];
+    const layoutNode = layout.nodes[n.id];
+    return {
+      id: n.id,
+      x: pos.x,
+      y: pos.y,
+      w: pos.w,
+      h: pos.h,
+      textSize: layoutNode?.textSize,
+      textColor: layoutNode?.textColor,
+      borderColor: layoutNode?.borderColor,
+      borderStyle: layoutNode?.borderStyle,
+      fillColor: layoutNode?.fillColor,
+      shape: layoutNode?.shape,
+      icon: layoutNode?.icon,
+      iconPosition: layoutNode?.iconPosition
+    };
+  });
+  const areas = diagram.areas.map((a, declIndex) => ({ a, declIndex })).sort(
+    (x, y) => (areaTree.depthOf.get(x.a.id) ?? 0) - (areaTree.depthOf.get(y.a.id) ?? 0) || x.declIndex - y.declIndex
+  ).map(({ a }) => {
+    const style = layout.areas?.[a.id];
+    const rect = areaRectById.get(a.id);
+    if (!rect) {
+      return { id: a.id, label: a.label, members: a.members, x: 0, y: 0, w: 0, h: 0, ...style };
+    }
+    return {
+      id: a.id,
+      label: a.label,
+      members: a.members,
+      x: rect.x,
+      y: rect.y,
+      w: rect.w,
+      h: rect.h,
+      borderColor: style?.borderColor,
+      borderStyle: style?.borderStyle,
+      fillColor: style?.fillColor
+    };
+  });
+  return {
+    gridSize,
+    nodes,
+    areas,
+    edges: routedEdges
+  };
+};
+var isHorizontalSide = (side) => side === "E" || side === "W";
+var sideFromSegment = (from, to) => {
+  const dx = to.x - from.x;
+  const dy = to.y - from.y;
+  if (Math.abs(dx) >= Math.abs(dy)) return dx >= 0 ? "E" : "W";
+  return dy >= 0 ? "S" : "N";
+};
+var FACE_MARGIN = 12;
+var faceCoord = (node, side) => side === "E" ? node.x + node.w : side === "W" ? node.x : side === "S" ? node.y + node.h : node.y;
+var faceRange = (node, side) => {
+  const horiz = isHorizontalSide(side);
+  const origin = horiz ? node.y : node.x;
+  const size = horiz ? node.h : node.w;
+  const margin = Math.min(FACE_MARGIN, size / 4);
+  return [origin + margin, origin + size - margin];
+};
+var FACE_FRAME = {
+  N: { n: { x: 0, y: -1 }, t: { x: 1, y: 0 } },
+  S: { n: { x: 0, y: 1 }, t: { x: 1, y: 0 } },
+  E: { n: { x: 1, y: 0 }, t: { x: 0, y: 1 } },
+  W: { n: { x: -1, y: 0 }, t: { x: 0, y: 1 } }
+};
+var fanOrderKey = (fanCenter, connectedCenter, side) => {
+  const dx = connectedCenter.x - fanCenter.x;
+  const dy = connectedCenter.y - fanCenter.y;
+  const { n, t } = FACE_FRAME[side];
+  return Math.atan2(dx * t.x + dy * t.y, dx * n.x + dy * n.y);
+};
+var computeEdgeAnchors = (edgeIds, edgeMeta, nodes, areaObstacles = []) => {
+  const faceGroups = /* @__PURE__ */ new Map();
+  for (const eid of edgeIds) {
+    const m = edgeMeta.get(eid);
+    for (const [nodeId, side, connId] of [
+      [m.source, m.sourceSide, m.target],
+      [m.target, m.targetSide, m.source]
+    ]) {
+      const key = `${nodeId}:${side}`;
+      let arr = faceGroups.get(key);
+      if (!arr) {
+        arr = [];
+        faceGroups.set(key, arr);
+      }
+      arr.push({ edgeId: eid, connectedId: connId });
+    }
+  }
+  const distributed = /* @__PURE__ */ new Map();
+  const multiFaces = /* @__PURE__ */ new Set();
+  const bendCoords = /* @__PURE__ */ new Map();
+  for (const [key, group] of faceGroups) {
+    if (group.length < 2) continue;
+    const [nodeId, sideStr] = key.split(":");
+    const fanSide = sideStr;
+    const fanNode = nodes[nodeId];
+    const horiz = isHorizontalSide(fanSide);
+    const [lo, hi] = faceRange(fanNode, fanSide);
+    const n = group.length;
+    const fanCenter = {
+      x: fanNode.x + fanNode.w / 2,
+      y: fanNode.y + fanNode.h / 2
+    };
+    const connectedCenter = (id) => {
+      const c = nodes[id];
+      return { x: c.x + c.w / 2, y: c.y + c.h / 2 };
+    };
+    const sorted = [...group].sort(
+      (a, b) => fanOrderKey(fanCenter, connectedCenter(a.connectedId), fanSide) - fanOrderKey(fanCenter, connectedCenter(b.connectedId), fanSide)
+    );
+    const step = (hi - lo) / n;
+    for (let i = 0; i < n; i++) {
+      distributed.set(`${sorted[i].edgeId}:${nodeId}`, lo + step * (i + 0.5));
+    }
+    for (const g of group) multiFaces.add(`${g.edgeId}:${nodeId}`);
+    const fanFC = faceCoord(fanNode, fanSide);
+    const fanCenterPerp = horiz ? fanNode.y + fanNode.h / 2 : fanNode.x + fanNode.w / 2;
+    const distOf = /* @__PURE__ */ new Map();
+    for (const item of sorted) {
+      const otherNode = nodes[item.connectedId];
+      const otherPerp = horiz ? otherNode.y + otherNode.h / 2 : otherNode.x + otherNode.w / 2;
+      distOf.set(item.edgeId, Math.abs(otherPerp - fanCenterPerp));
+    }
+    const uniqueDists = [...new Set(distOf.values())].sort((a, b) => b - a);
+    const numDepths = uniqueDists.length;
+    for (const item of sorted) {
+      const m = edgeMeta.get(item.edgeId);
+      const isSource = m.source === nodeId;
+      const otherSide = isSource ? m.targetSide : m.sourceSide;
+      const otherNode = nodes[item.connectedId];
+      if (!otherNode) continue;
+      const otherFC = faceCoord(otherNode, otherSide);
+      const depth = uniqueDists.indexOf(distOf.get(item.edgeId));
+      const offset = (otherFC - fanFC) * (depth + 1) / (numDepths + 1);
+      if (!bendCoords.has(item.edgeId)) {
+        bendCoords.set(item.edgeId, fanFC + offset);
+      }
+    }
+  }
+  const result = /* @__PURE__ */ new Map();
+  for (const eid of edgeIds) {
+    const m = edgeMeta.get(eid);
+    const src = nodes[m.source];
+    const tgt = nodes[m.target];
+    const srcMulti = multiFaces.has(`${eid}:${m.source}`);
+    const tgtMulti = multiFaces.has(`${eid}:${m.target}`);
+    const srcHoriz = isHorizontalSide(m.sourceSide);
+    const tgtHoriz = isHorizontalSide(m.targetSide);
+    const srcFC = faceCoord(src, m.sourceSide);
+    const tgtFC = faceCoord(tgt, m.targetSide);
+    let srcPerp;
+    let tgtPerp;
+    if (srcMulti && tgtMulti) {
+      srcPerp = distributed.get(`${eid}:${m.source}`);
+      tgtPerp = distributed.get(`${eid}:${m.target}`);
+    } else if (srcMulti) {
+      srcPerp = distributed.get(`${eid}:${m.source}`);
+      tgtPerp = tgtHoriz ? tgt.y + tgt.h / 2 : tgt.x + tgt.w / 2;
+    } else if (tgtMulti) {
+      tgtPerp = distributed.get(`${eid}:${m.target}`);
+      srcPerp = srcHoriz ? src.y + src.h / 2 : src.x + src.w / 2;
+    } else {
+      srcPerp = srcHoriz ? src.y + src.h / 2 : src.x + src.w / 2;
+      tgtPerp = tgtHoriz ? tgt.y + tgt.h / 2 : tgt.x + tgt.w / 2;
+    }
+    const sourceAnchor = srcHoriz ? { x: srcFC, y: srcPerp } : { x: srcPerp, y: srcFC };
+    const targetAnchor = tgtHoriz ? { x: tgtFC, y: tgtPerp } : { x: tgtPerp, y: tgtFC };
+    let bendCoord = bendCoords.get(eid);
+    if (srcHoriz === tgtHoriz && sourceAnchor.x !== targetAnchor.x && sourceAnchor.y !== targetAnchor.y) {
+      const candidate = bendCoord ?? (srcHoriz ? (sourceAnchor.x + targetAnchor.x) / 2 : (sourceAnchor.y + targetAnchor.y) / 2);
+      const adjusted = avoidObstacles(
+        candidate,
+        srcHoriz,
+        sourceAnchor,
+        targetAnchor,
+        nodes,
+        m.source,
+        m.target,
+        areaObstacles
+      );
+      if (adjusted !== candidate) bendCoord = adjusted;
+    }
+    result.set(eid, { sourceAnchor, targetAnchor, bendCoord });
+  }
+  return result;
+};
+var OBSTACLE_PAD = 8;
+var avoidObstacles = (candidate, horizontalSides, src, tgt, nodes, srcId, tgtId, areaObstacles = []) => {
+  const aLo = horizontalSides ? Math.min(src.y, tgt.y) : Math.min(src.x, tgt.x);
+  const aHi = horizontalSides ? Math.max(src.y, tgt.y) : Math.max(src.x, tgt.x);
+  const pLo = horizontalSides ? Math.min(src.x, tgt.x) : Math.min(src.y, tgt.y);
+  const pHi = horizontalSides ? Math.max(src.x, tgt.x) : Math.max(src.y, tgt.y);
+  if (pHi - pLo <= 0) return candidate;
+  const rects = [];
+  for (const [id, n] of Object.entries(nodes)) {
+    if (id === srcId || id === tgtId) continue;
+    rects.push(n);
+  }
+  for (const a of areaObstacles) {
+    if (areaBlocksEdge(a, srcId, tgtId)) rects.push(a.rect);
+  }
+  const obstacles = [];
+  for (const n of rects) {
+    const nALo = horizontalSides ? n.y : n.x;
+    const nAHi = horizontalSides ? n.y + n.h : n.x + n.w;
+    const nPLo = horizontalSides ? n.x : n.y;
+    const nPHi = horizontalSides ? n.x + n.w : n.y + n.h;
+    if (nAHi <= aLo || nALo >= aHi) continue;
+    if (nPHi <= pLo || nPLo >= pHi) continue;
+    obstacles.push([nPLo, nPHi]);
+  }
+  if (obstacles.length === 0) return candidate;
+  const blocking = obstacles.find(([lo, hi]) => candidate > lo && candidate < hi);
+  if (!blocking) return candidate;
+  const leftCandidate = blocking[0] - OBSTACLE_PAD;
+  const rightCandidate = blocking[1] + OBSTACLE_PAD;
+  const leftOk = leftCandidate > pLo && !obstacles.some(([lo, hi]) => leftCandidate > lo && leftCandidate < hi);
+  const rightOk = rightCandidate < pHi && !obstacles.some(([lo, hi]) => rightCandidate > lo && rightCandidate < hi);
+  if (leftOk && rightOk) {
+    return Math.abs(leftCandidate - candidate) <= Math.abs(rightCandidate - candidate) ? leftCandidate : rightCandidate;
+  }
+  if (leftOk) return leftCandidate;
+  if (rightOk) return rightCandidate;
+  return candidate;
+};
+var zJogCoord = (a, c, gridSize) => {
+  const snapped = snap((a + c) / 2, gridSize);
+  if (snapped !== a && snapped !== c) return snapped;
+  return (a + c) / 2;
+};
+var CROSS_INSET = 1.5;
+var segCrossesRect = (a, b, r) => {
+  const x0 = r.x + CROSS_INSET;
+  const x1 = r.x + r.w - CROSS_INSET;
+  const y0 = r.y + CROSS_INSET;
+  const y1 = r.y + r.h - CROSS_INSET;
+  if (x1 <= x0 || y1 <= y0) return false;
+  if (a.y === b.y) {
+    if (a.y <= y0 || a.y >= y1) return false;
+    return Math.min(a.x, b.x) < x1 && Math.max(a.x, b.x) > x0;
+  }
+  if (a.x === b.x) {
+    if (a.x <= x0 || a.x >= x1) return false;
+    return Math.min(a.y, b.y) < y1 && Math.max(a.y, b.y) > y0;
+  }
+  return false;
+};
+var pathCrossesForeignNode = (pts, nodes, srcId, tgtId, areaObstacles = []) => {
+  const blocking = areaObstacles.filter((a) => areaBlocksEdge(a, srcId, tgtId));
+  for (let i = 1; i < pts.length; i += 1) {
+    for (const [id, r] of Object.entries(nodes)) {
+      if (id === srcId || id === tgtId) continue;
+      if (segCrossesRect(pts[i - 1], pts[i], r)) return true;
+    }
+    for (const a of blocking) {
+      if (segCrossesRect(pts[i - 1], pts[i], a.rect)) return true;
+    }
+  }
+  return false;
+};
+var cleanPolyline = (pts) => {
+  const dedup = [];
+  for (const p of pts) {
+    const tail = dedup[dedup.length - 1];
+    if (tail && tail.x === p.x && tail.y === p.y) continue;
+    dedup.push({ x: p.x, y: p.y });
+  }
+  const out = [];
+  for (let i = 0; i < dedup.length; i += 1) {
+    const prev = out[out.length - 1];
+    const cur = dedup[i];
+    const next = dedup[i + 1];
+    if (prev && next && (prev.x === cur.x && cur.x === next.x || prev.y === cur.y && cur.y === next.y)) {
+      continue;
+    }
+    out.push(cur);
+  }
+  return out;
+};
+var polyOf = (r) => cleanPolyline([r.sourcePoint, ...r.bendPoints, r.targetPoint]);
+var isOrthogonalPath = (pts) => {
+  for (let i = 1; i < pts.length; i += 1) {
+    const a = pts[i - 1], b = pts[i];
+    if (Math.abs(a.x - b.x) > 0.5 && Math.abs(a.y - b.y) > 0.5) return false;
+  }
+  return true;
+};
+var polysCross = (a, b) => {
+  for (let i = 1; i < a.length; i += 1) {
+    for (let j = 1; j < b.length; j += 1) {
+      const a1 = a[i - 1], a2 = a[i], b1 = b[j - 1], b2 = b[j];
+      const aH = Math.abs(a1.y - a2.y) < 0.5 && Math.abs(a1.x - a2.x) > 0.5;
+      const aV = Math.abs(a1.x - a2.x) < 0.5 && Math.abs(a1.y - a2.y) > 0.5;
+      const bH = Math.abs(b1.y - b2.y) < 0.5 && Math.abs(b1.x - b2.x) > 0.5;
+      const bV = Math.abs(b1.x - b2.x) < 0.5 && Math.abs(b1.y - b2.y) > 0.5;
+      let h = null;
+      let v = null;
+      if (aH && bV) {
+        h = [a1, a2];
+        v = [b1, b2];
+      } else if (aV && bH) {
+        h = [b1, b2];
+        v = [a1, a2];
+      }
+      if (!h || !v) continue;
+      const hy = h[0].y, vx = v[0].x, e = 1;
+      if (vx > Math.min(h[0].x, h[1].x) + e && vx < Math.max(h[0].x, h[1].x) - e && hy > Math.min(v[0].y, v[1].y) + e && hy < Math.max(v[0].y, v[1].y) - e) return true;
+    }
+  }
+  return false;
+};
+var crossingPairs = (polys, ids) => {
+  const out = [];
+  for (let i = 0; i < ids.length; i += 1) {
+    for (let j = i + 1; j < ids.length; j += 1) {
+      const A = polys.get(ids[i]), B = polys.get(ids[j]);
+      if (A && B && polysCross(A, B)) out.push([ids[i], ids[j]]);
+    }
+  }
+  return out;
+};
+var sharedFace = (a, b, meta) => {
+  const ma = meta.get(a), mb = meta.get(b);
+  const endsA = [
+    ["source", ma.source, ma.sourceSide],
+    ["target", ma.target, ma.targetSide]
+  ];
+  const endsB = [
+    ["source", mb.source, mb.sourceSide],
+    ["target", mb.target, mb.targetSide]
+  ];
+  for (const [ea, na, sa] of endsA) {
+    for (const [eb, nb, sb] of endsB) {
+      if (na === nb && sa === sb) return { endA: ea, endB: eb };
+    }
+  }
+  return null;
+};
+var anchorEnd = (h, end) => end === "source" ? h.sourceAnchor : h.targetAnchor;
+var withAnchorEnd = (h, end, pt) => end === "source" ? { ...h, sourceAnchor: pt } : { ...h, targetAnchor: pt };
+var snapPolylineToGrid = (poly, gridSize, nodes, areaObstacles, srcId, tgtId) => {
+  if (poly.length < 4) return cleanPolyline(poly);
+  const out = poly.map((p) => ({ x: p.x, y: p.y }));
+  for (let i = 1; i < out.length - 2; i += 1) {
+    const a = out[i];
+    const b = out[i + 1];
+    const before = out[i - 1];
+    const after = out[i + 2];
+    if (Math.abs(a.x - b.x) < 0.5) {
+      const sx = snap(a.x, gridSize);
+      const lo = Math.min(before.x, after.x);
+      const hi = Math.max(before.x, after.x);
+      if (sx > lo && sx < hi) {
+        a.x = sx;
+        b.x = sx;
+      }
+    } else if (Math.abs(a.y - b.y) < 0.5) {
+      const sy = snap(a.y, gridSize);
+      const lo = Math.min(before.y, after.y);
+      const hi = Math.max(before.y, after.y);
+      if (sy > lo && sy < hi) {
+        a.y = sy;
+        b.y = sy;
+      }
+    }
+  }
+  const snapped = cleanPolyline(out);
+  if (pathCrossesForeignNode(snapped, nodes, srcId, tgtId, areaObstacles)) {
+    return cleanPolyline(poly);
+  }
+  return snapped;
+};
+var buildOrthogonalPath = (A, C, sourceSide, targetSide, gridSize, bendCoord) => {
+  const srcHoriz = isHorizontalSide(sourceSide);
+  const tgtHoriz = isHorizontalSide(targetSide);
+  const out = [{ x: A.x, y: A.y }];
+  if (srcHoriz === tgtHoriz) {
+    if (srcHoriz) {
+      if (A.y !== C.y) {
+        const midX = bendCoord ?? zJogCoord(A.x, C.x, gridSize);
+        out.push({ x: midX, y: A.y }, { x: midX, y: C.y });
+      }
+    } else if (A.x !== C.x) {
+      const midY = bendCoord ?? zJogCoord(A.y, C.y, gridSize);
+      out.push({ x: A.x, y: midY }, { x: C.x, y: midY });
+    }
+  } else {
+    const corner = srcHoriz ? { x: C.x, y: A.y } : { x: A.x, y: C.y };
+    out.push(corner);
+  }
+  out.push({ x: C.x, y: C.y });
+  const deduped = [];
+  for (const p of out) {
+    const tail = deduped[deduped.length - 1];
+    if (tail && tail.x === p.x && tail.y === p.y) continue;
+    deduped.push(p);
+  }
+  return deduped;
+};
+var segmentsFor = (hints, m, gridSize) => {
+  const path = buildOrthogonalPath(
+    hints.sourceAnchor,
+    hints.targetAnchor,
+    m.sourceSide,
+    m.targetSide,
+    gridSize,
+    hints.bendCoord
+  );
+  const segs = [];
+  for (let i = 1; i < path.length; i += 1) {
+    const a = path[i - 1];
+    const b = path[i];
+    const isFirst = i === 1;
+    const isLast = i === path.length - 1;
+    const endpoint = isFirst ? "source" : isLast ? "target" : null;
+    if (a.x === b.x && a.y !== b.y) {
+      segs.push({
+        axis: "V",
+        coord: a.x,
+        lo: Math.min(a.y, b.y),
+        hi: Math.max(a.y, b.y),
+        endpoint
+      });
+    } else if (a.y === b.y && a.x !== b.x) {
+      segs.push({
+        axis: "H",
+        coord: a.y,
+        lo: Math.min(a.x, b.x),
+        hi: Math.max(a.x, b.x),
+        endpoint
+      });
+    }
+  }
+  return segs;
+};
+var segmentsFromPolyline = (poly) => {
+  const segs = [];
+  for (let i = 1; i < poly.length; i += 1) {
+    const a = poly[i - 1];
+    const b = poly[i];
+    if (Math.abs(a.x - b.x) < 0.5 && Math.abs(a.y - b.y) >= 0.5) {
+      segs.push({ axis: "V", coord: a.x, lo: Math.min(a.y, b.y), hi: Math.max(a.y, b.y), endpoint: null });
+    } else if (Math.abs(a.y - b.y) < 0.5 && Math.abs(a.x - b.x) >= 0.5) {
+      segs.push({ axis: "H", coord: a.y, lo: Math.min(a.x, b.x), hi: Math.max(a.x, b.x), endpoint: null });
+    }
+  }
+  return segs;
+};
+var nudgeAnchorAlongFace = (node, side, current, attempts) => {
+  const horiz = isHorizontalSide(side);
+  const [lo, hi] = faceRange(node, side);
+  const cur = horiz ? current.y : current.x;
+  for (const delta of attempts) {
+    const next = cur + delta;
+    if (next >= lo && next <= hi) {
+      return horiz ? { x: current.x, y: next } : { x: next, y: current.y };
+    }
+  }
+  return current;
+};
+var resolveSegmentOverlaps = (edgeAnchors, edgeMeta, nodes, gridSize, skip) => {
+  const OVERLAP_TOLERANCE = 4;
+  const nudgeAmount = Math.max(gridSize / 2, 16);
+  const NUDGE_ATTEMPTS = [nudgeAmount, -nudgeAmount, nudgeAmount * 2, -nudgeAmount * 2];
+  const BEND_MIN_GAP = gridSize;
+  const MAX_ITERATIONS = 16;
+  const MAX_ENDPOINT_NUDGES = 3;
+  const endpointNudges = /* @__PURE__ */ new Map();
+  const bendCoordOf = (h, axis) => h.bendCoord ?? (axis === "V" ? (h.sourceAnchor.x + h.targetAnchor.x) / 2 : (h.sourceAnchor.y + h.targetAnchor.y) / 2);
+  const fixedSegments = [];
+  for (const poly of skip.values()) fixedSegments.push(...segmentsFromPolyline(poly));
+  const spanOverlap = (a, b) => Math.min(a.hi, b.hi) - Math.max(a.lo, b.lo);
+  const segmentsCross = (a, b) => {
+    if (a.axis === b.axis) return false;
+    const v = a.axis === "V" ? a : b;
+    const h = a.axis === "V" ? b : a;
+    return v.coord > h.lo && v.coord < h.hi && h.coord > v.lo && h.coord < v.hi;
+  };
+  const relocateBendLeg = (edgeId, leg, segs) => {
+    const hints = edgeAnchors.get(edgeId);
+    const meta = edgeMeta.get(edgeId);
+    if (!hints || !meta) return false;
+    const axis = leg.axis;
+    const span = axis === "V" ? [hints.sourceAnchor.x, hints.targetAnchor.x] : [hints.sourceAnchor.y, hints.targetAnchor.y];
+    const margin = Math.min(nudgeAmount, (Math.max(...span) - Math.min(...span)) / 3);
+    const lo = Math.min(...span) + margin;
+    const hi = Math.max(...span) - margin;
+    if (hi <= lo) return false;
+    const otherSegs = [...fixedSegments];
+    for (const [oid, osegs] of segs) if (oid !== edgeId) otherSegs.push(...osegs);
+    const blockers = otherSegs.filter((os) => os.axis === axis && spanOverlap(os, leg) > OVERLAP_TOLERANCE).map((os) => os.coord);
+    const clear = (c) => c >= lo && c <= hi && blockers.every((b) => Math.abs(c - b) >= BEND_MIN_GAP - 1);
+    const crossingsAt = (c) => {
+      let n = 0;
+      for (const ms of segmentsFor({ ...hints, bendCoord: c }, meta, gridSize)) {
+        for (const os of otherSegs) if (segmentsCross(ms, os)) n += 1;
+      }
+      return n;
+    };
+    const cur = bendCoordOf(hints, axis);
+    const step = Math.max(8, gridSize / 4);
+    let best = null;
+    for (let d = step; d <= hi - lo; d += step) {
+      for (const c of [cur + d, cur - d]) {
+        if (!clear(c)) continue;
+        const cross = crossingsAt(c);
+        if (cross === 0) {
+          edgeAnchors.set(edgeId, { ...hints, bendCoord: c });
+          return true;
+        }
+        if (!best || cross < best.cross) best = { c, cross };
+      }
+    }
+    if (best) {
+      edgeAnchors.set(edgeId, { ...hints, bendCoord: best.c });
+      return true;
+    }
+    return false;
+  };
+  for (let iter = 0; iter < MAX_ITERATIONS; iter += 1) {
+    const segs = /* @__PURE__ */ new Map();
+    for (const [edgeId, hints] of edgeAnchors) {
+      if (skip.has(edgeId)) continue;
+      const m = edgeMeta.get(edgeId);
+      segs.set(edgeId, segmentsFor(hints, m, gridSize));
+    }
+    const others = (selfId) => {
+      const out = [...fixedSegments];
+      for (const [oid, osegs] of segs) if (oid !== selfId) out.push(...osegs);
+      return out;
+    };
+    const endpointConflicts = [];
+    const bendConflicts = [];
+    for (const [e1, segs1] of segs) {
+      const rest = others(e1);
+      for (const s1 of segs1) {
+        for (const s2 of rest) {
+          if (s1.axis !== s2.axis) continue;
+          if (spanOverlap(s1, s2) <= OVERLAP_TOLERANCE) continue;
+          const coordGap = Math.abs(s1.coord - s2.coord);
+          if (coordGap > OVERLAP_TOLERANCE) continue;
+          if (s1.endpoint) {
+            endpointConflicts.push({ edgeId: e1, endpoint: s1.endpoint });
+          } else {
+            bendConflicts.push({ edgeId: e1, leg: s1 });
+          }
+          break;
+        }
+      }
+    }
+    let progressed = false;
+    for (const c of endpointConflicts) {
+      const key = `${c.edgeId}:${c.endpoint}`;
+      if ((endpointNudges.get(key) ?? 0) >= MAX_ENDPOINT_NUDGES) continue;
+      const m = edgeMeta.get(c.edgeId);
+      const hints = edgeAnchors.get(c.edgeId);
+      const isSource = c.endpoint === "source";
+      const node = nodes[isSource ? m.source : m.target];
+      if (!node) continue;
+      const side = isSource ? m.sourceSide : m.targetSide;
+      const currentAnchor = isSource ? hints.sourceAnchor : hints.targetAnchor;
+      const nudged = nudgeAnchorAlongFace(node, side, currentAnchor, NUDGE_ATTEMPTS);
+      if (nudged === currentAnchor) continue;
+      endpointNudges.set(key, (endpointNudges.get(key) ?? 0) + 1);
+      edgeAnchors.set(c.edgeId, {
+        ...hints,
+        sourceAnchor: isSource ? nudged : hints.sourceAnchor,
+        targetAnchor: isSource ? hints.targetAnchor : nudged
+      });
+      progressed = true;
+      break;
+    }
+    for (const c of bendConflicts) {
+      if (relocateBendLeg(c.edgeId, c.leg, segs)) {
+        progressed = true;
+        break;
+      }
+    }
+    if (!progressed) return;
+  }
+};
+var connectionSideFromSide = (side) => {
+  switch (side) {
+    case "N":
+      return "north";
+    case "S":
+      return "south";
+    case "E":
+      return "east";
+    case "W":
+      return "west";
+  }
+};
+
+// src/parser/lexer.ts
+import { createToken, Lexer } from "chevrotain";
+var WhiteSpace = createToken({
+  name: "WhiteSpace",
+  pattern: /[ \t\r]+/,
+  group: Lexer.SKIPPED
+});
+var Comment = createToken({
+  name: "Comment",
+  // `#` to end of line; the trailing newline stays so it can still act as a
+  // statement terminator.
+  pattern: /#[^\n]*/,
+  group: Lexer.SKIPPED
+});
+var Newline = createToken({
+  name: "Newline",
+  // Collapse consecutive newlines into one logical terminator.
+  pattern: /\n+/,
+  line_breaks: true
+});
+var ArrowBoth = createToken({ name: "ArrowBoth", pattern: /<->/ });
+var ArrowRight = createToken({ name: "ArrowRight", pattern: /->/ });
+var ArrowLeft = createToken({ name: "ArrowLeft", pattern: /<-/ });
+var DashDash = createToken({ name: "DashDash", pattern: /--/ });
+var LCurly = createToken({ name: "LCurly", pattern: /\{/ });
+var RCurly = createToken({ name: "RCurly", pattern: /\}/ });
+var Colon = createToken({ name: "Colon", pattern: /:/ });
+var Semicolon = createToken({ name: "Semicolon", pattern: /;/ });
+var Dot = createToken({ name: "Dot", pattern: /\./ });
+var StringLit = createToken({
+  name: "StringLit",
+  pattern: /"(?:\\.|[^"\\\n])*"|'(?:\\.|[^'\\\n])*'/
+});
+var NumberLit = createToken({
+  name: "NumberLit",
+  pattern: /[0-9]+(?:\.[0-9]+)?/
+});
+var LETTER = "A-Za-z\xC0-\xFF\u0100-\u024F";
+var DIGIT = "0-9";
+var Identifier = createToken({
+  name: "Identifier",
+  pattern: new RegExp(
+    `[${LETTER}_][${LETTER}${DIGIT}_]*(?:-[${LETTER}${DIGIT}_]+)*`
+  )
+});
+var allTokens = [
+  WhiteSpace,
+  Comment,
+  Newline,
+  ArrowBoth,
+  ArrowRight,
+  ArrowLeft,
+  DashDash,
+  LCurly,
+  RCurly,
+  Colon,
+  Semicolon,
+  Dot,
+  StringLit,
+  NumberLit,
+  Identifier
+];
+var lexer = new Lexer(allTokens, {
+  positionTracking: "full",
+  ensureOptimizations: false
+});
+
+// src/parser/parser.ts
+import { CstParser } from "chevrotain";
+var D2Parser = class extends CstParser {
+  constructor() {
+    super(allTokens, {
+      recoveryEnabled: false,
+      // We only need 2-token lookahead to distinguish edges (id arrow ...)
+      // from node/area declarations (id colon ... | id { ... } | id alone).
+      maxLookahead: 3
+    });
+    this.performSelfAnalysis();
+  }
+  // program := (statement Newline?)*
+  program = this.RULE("program", () => {
+    this.MANY1(() => this.CONSUME1(Newline));
+    this.MANY2(() => {
+      this.SUBRULE(this.statement);
+      this.MANY3(() => this.CONSUME2(Newline));
+    });
+  });
+  // statement := edgeDecl | nodeOrAreaDecl
+  //
+  // Disambiguated by looking at the token after the first Identifier: an
+  // arrow operator means we're in an edge declaration.
+  statement = this.RULE("statement", () => {
+    this.OR([
+      {
+        GATE: () => this.isArrowAhead(),
+        ALT: () => this.SUBRULE(this.edgeDecl)
+      },
+      { ALT: () => this.SUBRULE(this.nodeOrAreaDecl) }
+    ]);
+  });
+  // nodeOrAreaDecl := Identifier (Colon labelOrValue)? (LCurly blockItem* RCurly)?
+  nodeOrAreaDecl = this.RULE("nodeOrAreaDecl", () => {
+    this.CONSUME(Identifier);
+    this.OPTION1(() => {
+      this.CONSUME(Colon);
+      this.SUBRULE(this.labelOrValue);
+    });
+    this.OPTION2(() => {
+      this.CONSUME(LCurly);
+      this.MANY1(() => this.CONSUME1(Newline));
+      this.MANY2(() => {
+        this.SUBRULE(this.blockItem);
+        this.MANY3(() => {
+          this.OR2([
+            { ALT: () => this.CONSUME(Semicolon) },
+            { ALT: () => this.CONSUME2(Newline) }
+          ]);
+        });
+      });
+      this.CONSUME(RCurly);
+    });
+  });
+  // blockItem := attr | memberStmt
+  //
+  // We distinguish on the second token: `Identifier Colon` or `Identifier Dot`
+  // is an attr; `Identifier` followed by anything else (`;`, newline, `}`) is
+  // a member declaration.
+  blockItem = this.RULE("blockItem", () => {
+    this.OR([
+      {
+        GATE: () => this.isAttrAhead(),
+        ALT: () => this.SUBRULE(this.attr)
+      },
+      { ALT: () => this.SUBRULE(this.memberStmt) }
+    ]);
+  });
+  // attr := Identifier (Dot Identifier)* Colon attrValue
+  attr = this.RULE("attr", () => {
+    this.CONSUME(Identifier);
+    this.MANY(() => {
+      this.CONSUME(Dot);
+      this.CONSUME2(Identifier);
+    });
+    this.CONSUME(Colon);
+    this.SUBRULE(this.attrValue);
+  });
+  // memberStmt := Identifier
+  // Terminators (`;`, newline) are consumed by the enclosing block rule.
+  memberStmt = this.RULE("memberStmt", () => {
+    this.CONSUME(Identifier);
+  });
+  // edgeDecl := Identifier arrowOp Identifier (Colon labelOrValue)? (LCurly attr* RCurly)?
+  edgeDecl = this.RULE("edgeDecl", () => {
+    this.CONSUME(Identifier);
+    this.SUBRULE(this.arrowOp);
+    this.CONSUME2(Identifier);
+    this.OPTION1(() => {
+      this.CONSUME(Colon);
+      this.SUBRULE(this.labelOrValue);
+    });
+    this.OPTION2(() => {
+      this.CONSUME(LCurly);
+      this.MANY1(() => this.CONSUME1(Newline));
+      this.MANY2(() => {
+        this.SUBRULE(this.attr);
+        this.MANY3(() => {
+          this.OR([
+            { ALT: () => this.CONSUME(Semicolon) },
+            { ALT: () => this.CONSUME2(Newline) }
+          ]);
+        });
+      });
+      this.CONSUME(RCurly);
+    });
+  });
+  // arrowOp := -> | <- | <-> | --
+  arrowOp = this.RULE("arrowOp", () => {
+    this.OR([
+      { ALT: () => this.CONSUME(ArrowRight) },
+      { ALT: () => this.CONSUME(ArrowLeft) },
+      { ALT: () => this.CONSUME(ArrowBoth) },
+      { ALT: () => this.CONSUME(DashDash) }
+    ]);
+  });
+  // labelOrValue := StringLit | Identifier+
+  //
+  // Unquoted labels may contain spaces (e.g. `api: Web App`), so we greedily
+  // consume consecutive identifiers up to the next structural token.
+  labelOrValue = this.RULE("labelOrValue", () => {
+    this.OR([
+      { ALT: () => this.CONSUME(StringLit) },
+      {
+        ALT: () => {
+          this.CONSUME(Identifier);
+          this.MANY(() => this.CONSUME2(Identifier));
+        }
+      }
+    ]);
+  });
+  // attrValue := StringLit | Identifier | NumberLit
+  attrValue = this.RULE("attrValue", () => {
+    this.OR([
+      { ALT: () => this.CONSUME(StringLit) },
+      { ALT: () => this.CONSUME(Identifier) },
+      { ALT: () => this.CONSUME(NumberLit) }
+    ]);
+  });
+  // --- Lookahead helpers --------------------------------------------------
+  isArrowAhead() {
+    const t1 = this.LA(1);
+    const t2 = this.LA(2);
+    if (t1.tokenType !== Identifier) return false;
+    return t2.tokenType === ArrowRight || t2.tokenType === ArrowLeft || t2.tokenType === ArrowBoth || t2.tokenType === DashDash;
+  }
+  isAttrAhead() {
+    const t1 = this.LA(1);
+    const t2 = this.LA(2);
+    if (t1.tokenType !== Identifier) return false;
+    return t2.tokenType === Colon || t2.tokenType === Dot;
+  }
+};
+var parserInstance = new D2Parser();
+
+// src/parser/ast.ts
+var SHAPE_NAMES = [
+  "rectangle",
+  "cylinder",
+  "person"
+];
+
+// src/parser/visitor.ts
+var BaseVisitor = parserInstance.getBaseCstVisitorConstructor();
+var D2Visitor = class extends BaseVisitor {
+  errors = [];
+  constructor() {
+    super();
+    this.validateVisitor();
+  }
+  // -- root ---------------------------------------------------------------
+  program(ctx) {
+    const diagram = { nodes: [], edges: [], areas: [] };
+    const seenIds = /* @__PURE__ */ new Set();
+    for (const stmt of ctx.statement ?? []) {
+      const result = this.visit(stmt);
+      if (!result) continue;
+      if (result.kind === "edge") {
+        diagram.edges.push(result);
+        continue;
+      }
+      if (seenIds.has(result.id)) {
+        this.errors.push({
+          message: `Duplicate id "${result.id}".`,
+          range: result.range
+        });
+        continue;
+      }
+      seenIds.add(result.id);
+      if (result.kind === "node") {
+        diagram.nodes.push(result);
+      } else {
+        diagram.areas.push(result);
+      }
+    }
+    this.validateAreaNesting(diagram.areas);
+    return diagram;
+  }
+  // Nested containers are by-reference (an area listing another area's id as a
+  // member). The member graph must stay a DAG: an area containing itself or a
+  // cycle between areas would make the derived boxes undefined, so both are
+  // hard errors, anchored to the member token that closes the loop.
+  validateAreaNesting(areas) {
+    const areaById = new Map(areas.map((a) => [a.id, a]));
+    const state = /* @__PURE__ */ new Map();
+    const visit = (area) => {
+      state.set(area.id, 1);
+      area.members.forEach((mid, i) => {
+        const range = area.memberRanges[i] ?? area.range;
+        if (mid === area.id) {
+          this.errors.push({
+            message: `Area "${area.id}" cannot contain itself.`,
+            range
+          });
+          return;
+        }
+        const child = areaById.get(mid);
+        if (!child) return;
+        if (state.get(mid) === 1) {
+          this.errors.push({
+            message: `Membership cycle: area "${area.id}" contains "${mid}", which already contains "${area.id}".`,
+            range
+          });
+          return;
+        }
+        if (!state.has(mid)) visit(child);
+      });
+      state.set(area.id, 2);
+    };
+    for (const a of areas) {
+      if (!state.has(a.id)) visit(a);
+    }
+  }
+  statement(ctx) {
+    if (ctx.edgeDecl) return this.visit(ctx.edgeDecl);
+    if (ctx.nodeOrAreaDecl) {
+      return this.visit(ctx.nodeOrAreaDecl);
+    }
+    return void 0;
+  }
+  // -- node / area --------------------------------------------------------
+  nodeOrAreaDecl(ctx) {
+    const idTok = ctx.Identifier[0];
+    const id = idTok.image;
+    const idRange = makeRange(idTok, idTok);
+    const label = ctx.labelOrValue ? this.visit(ctx.labelOrValue).text : void 0;
+    const labelRange = ctx.labelOrValue?.[0] ? this.labelValueRange(ctx.labelOrValue[0]) : void 0;
+    const block = this.collectBlock(ctx);
+    const endTok = ctx.RCurly?.[0] ?? (ctx.labelOrValue?.[0] ? this.lastTokenOfLabel(ctx.labelOrValue[0]) : void 0) ?? idTok;
+    const range = makeRange(idTok, endTok);
+    if (!ctx.LCurly) {
+      return makeNode(id, label, "rectangle", range, idRange, labelRange);
+    }
+    const hasMembers = block.items.some((i) => i.kind === "member");
+    const hasAttrs = block.items.some((i) => i.kind === "attr");
+    if (hasMembers) {
+      if (hasAttrs) {
+        this.errors.push({
+          message: `Container "${id}" mixes attributes and members; only one is allowed in an area.`,
+          range
+        });
+      }
+      return this.buildArea(id, label, block, range);
+    }
+    return this.buildNode(id, label, block, range, idRange, labelRange);
+  }
+  buildNode(id, label, block, range, idRange, labelRange) {
+    let shape = "rectangle";
+    for (const item of block.items) {
+      if (item.kind !== "attr") continue;
+      if (item.path.length === 1 && item.path[0] === "shape") {
+        const value = item.value?.text;
+        if (value && SHAPE_NAMES.includes(value)) {
+          shape = value;
+        } else {
+          this.errors.push({
+            message: `Unknown shape "${value ?? ""}" on node "${id}".`,
+            range: item.range
+          });
+        }
+        continue;
+      }
+      if (item.path.length > 2) {
+        this.errors.push({
+          message: `Unsupported dotted attribute "${item.path.join(
+            "."
+          )}" on node "${id}".`,
+          range: item.range
+        });
+      }
+    }
+    return makeNode(id, label, shape, range, idRange, labelRange);
+  }
+  buildArea(id, label, block, range) {
+    const members = [];
+    const memberRanges = [];
+    for (const item of block.items) {
+      if (item.kind !== "member") continue;
+      const memberId = item.path[0];
+      if (members.includes(memberId)) {
+        this.errors.push({
+          message: `Area "${id}" lists member "${memberId}" more than once.`,
+          range: item.range
+        });
+        continue;
+      }
+      members.push(memberId);
+      memberRanges.push(item.range);
+    }
+    return { kind: "area", id, label, members, memberRanges, range };
+  }
+  // -- edge ---------------------------------------------------------------
+  edgeDecl(ctx) {
+    const sourceTok = ctx.Identifier[0];
+    const targetTok = ctx.Identifier[1];
+    const direction = this.visit(ctx.arrowOp);
+    const label = ctx.labelOrValue ? this.visit(ctx.labelOrValue).text : void 0;
+    let style = "solid";
+    for (const a of ctx.attr ?? []) {
+      const item = this.visit(a);
+      if (item.kind !== "attr") continue;
+      if (item.path.length === 2 && item.path[0] === "style" && item.path[1] === "stroke-dash") {
+        style = strokeDashToStyle(item.value);
+        continue;
+      }
+      if (item.path.length > 2) {
+        this.errors.push({
+          message: `Unsupported dotted attribute "${item.path.join(
+            "."
+          )}" on edge.`,
+          range: item.range
+        });
+      }
+    }
+    const endTok = ctx.RCurly?.[0] ?? (ctx.labelOrValue?.[0] ? this.lastTokenOfLabel(ctx.labelOrValue[0]) : void 0) ?? targetTok;
+    const range = makeRange(sourceTok, endTok);
+    return {
+      kind: "edge",
+      source: sourceTok.image,
+      target: targetTok.image,
+      direction,
+      label,
+      style,
+      range
+    };
+  }
+  arrowOp(ctx) {
+    if (ctx.ArrowRight) return "forward";
+    if (ctx.ArrowLeft) return "backward";
+    if (ctx.ArrowBoth) return "bidirectional";
+    return "none";
+  }
+  // -- block bodies -------------------------------------------------------
+  blockItem(ctx) {
+    if (ctx.attr) return this.visit(ctx.attr);
+    return this.visit(ctx.memberStmt);
+  }
+  attr(ctx) {
+    const path = ctx.Identifier.map((t) => t.image);
+    const value = this.visit(ctx.attrValue);
+    const range = makeRange(
+      ctx.Identifier[0],
+      this.lastTokenOfAttrValue(ctx.attrValue[0])
+    );
+    return { kind: "attr", path, value, range };
+  }
+  memberStmt(ctx) {
+    const tok = ctx.Identifier[0];
+    return {
+      kind: "member",
+      path: [tok.image],
+      range: makeRange(tok, tok)
+    };
+  }
+  labelOrValue(ctx) {
+    if (ctx.StringLit) {
+      const tok = ctx.StringLit[0];
+      return { kind: "string", text: unquote(tok.image) };
+    }
+    const text = ctx.Identifier.map((t) => t.image).join(" ");
+    return { kind: "identifier", text };
+  }
+  attrValue(ctx) {
+    if (ctx.StringLit) {
+      const tok2 = ctx.StringLit[0];
+      return { kind: "string", text: unquote(tok2.image), raw: tok2.image };
+    }
+    if (ctx.NumberLit) {
+      const tok2 = ctx.NumberLit[0];
+      return { kind: "number", text: tok2.image, raw: tok2.image };
+    }
+    const tok = ctx.Identifier[0];
+    return { kind: "identifier", text: tok.image, raw: tok.image };
+  }
+  // -- helpers ------------------------------------------------------------
+  collectBlock(ctx) {
+    const items = [];
+    for (const item of ctx.blockItem ?? []) {
+      items.push(this.visit(item));
+    }
+    const start = ctx.LCurly?.[0];
+    const end = ctx.RCurly?.[0];
+    const range = start && end ? makeRange(start, end) : { start: dummyPos(), end: dummyPos() };
+    return { items, range };
+  }
+  lastTokenOfLabel(node) {
+    const ch = node.children;
+    if (ch.StringLit?.[0]) return ch.StringLit[0];
+    const ids = ch.Identifier;
+    return ids?.[ids.length - 1];
+  }
+  // Source span covering the label value: the StringLit (quotes included) or
+  // the run of unquoted identifier tokens. Used to rewrite a node's label in
+  // place from the canvas editor.
+  labelValueRange(node) {
+    const ch = node.children;
+    if (ch.StringLit?.[0]) return makeRange(ch.StringLit[0], ch.StringLit[0]);
+    const ids = ch.Identifier;
+    if (ids && ids.length > 0) return makeRange(ids[0], ids[ids.length - 1]);
+    return void 0;
+  }
+  lastTokenOfAttrValue(node) {
+    const ch = node.children;
+    return ch.StringLit?.[0] ?? ch.NumberLit?.[0] ?? ch.Identifier[0];
+  }
+};
+function makeNode(id, label, shape, range, idRange, labelRange) {
+  return {
+    kind: "node",
+    id,
+    label,
+    shape,
+    range,
+    idRange,
+    ...labelRange ? { labelRange } : {}
+  };
+}
+function makeRange(start, end) {
+  return {
+    start: {
+      line: start.startLine ?? 1,
+      column: start.startColumn ?? 1,
+      offset: start.startOffset
+    },
+    end: {
+      line: end.endLine ?? start.startLine ?? 1,
+      column: (end.endColumn ?? start.startColumn ?? 1) + 1,
+      offset: (end.endOffset ?? start.startOffset) + 1
+    }
+  };
+}
+function dummyPos() {
+  return { line: 1, column: 1, offset: 0 };
+}
+function unquote(raw) {
+  const body = raw.slice(1, -1);
+  let out = "";
+  for (let i = 0; i < body.length; i++) {
+    const c = body[i];
+    if (c !== "\\" || i === body.length - 1) {
+      out += c;
+      continue;
+    }
+    const next = body[++i];
+    switch (next) {
+      case "n":
+        out += "\n";
+        break;
+      case "t":
+        out += "	";
+        break;
+      case "r":
+        out += "\r";
+        break;
+      default:
+        out += next;
+    }
+  }
+  return out;
+}
+function strokeDashToStyle(value) {
+  if (!value) return "solid";
+  const n = Number(value.text);
+  if (!Number.isFinite(n) || n <= 0) return "solid";
+  if (n <= 3) return "dotted";
+  return "dashed";
+}
+
+// src/parser/index.ts
+function emptyRange() {
+  return {
+    start: { line: 1, column: 1, offset: 0 },
+    end: { line: 1, column: 1, offset: 0 }
+  };
+}
+function parse(source) {
+  const lexResult = lexer.tokenize(source);
+  const errors = lexResult.errors.map(lexErrorToParseError);
+  parserInstance.input = lexResult.tokens;
+  const cst = parserInstance.program();
+  const eof = eofPos(source);
+  for (const e of parserInstance.errors) {
+    errors.push(parserErrorToParseError(e, eof));
+  }
+  const visitor = new D2Visitor();
+  let diagram;
+  try {
+    diagram = visitor.visit(cst);
+  } catch (err) {
+    errors.push({
+      message: err.message,
+      range: emptyRange()
+    });
+    return { ok: false, errors };
+  }
+  errors.push(...visitor.errors);
+  if (errors.length > 0) return { ok: false, errors };
+  return { ok: true, diagram };
+}
+function lexErrorToParseError(e) {
+  const line = e.line ?? 1;
+  const column = e.column ?? 1;
+  const offset = e.offset ?? 0;
+  const length = e.length ?? 1;
+  return {
+    message: e.message,
+    range: {
+      start: { line, column, offset },
+      end: { line, column: column + length, offset: offset + length }
+    }
+  };
+}
+function parserErrorToParseError(e, eof) {
+  const tok = e.token;
+  const startLine = finite(tok?.startLine, eof.line);
+  const startColumn = finite(tok?.startColumn, eof.column);
+  const startOffset = finite(tok?.startOffset, eof.offset);
+  return {
+    message: e.message,
+    range: {
+      start: { line: startLine, column: startColumn, offset: startOffset },
+      end: {
+        line: finite(tok?.endLine, startLine),
+        column: finite(tok?.endColumn, startColumn) + 1,
+        offset: finite(tok?.endOffset, startOffset) + 1
+      }
+    }
+  };
+}
+function finite(v, fallback) {
+  return typeof v === "number" && Number.isFinite(v) ? v : fallback;
+}
+function eofPos(source) {
+  const nl = source.split("\n");
+  return {
+    line: nl.length,
+    column: (nl[nl.length - 1]?.length ?? 0) + 1,
+    offset: source.length
+  };
+}
+
+// src/file/layoutSchema.ts
+var JsonParser = class {
+  constructor(text) {
+    this.text = text;
+  }
+  text;
+  i = 0;
+  line = 1;
+  col = 1;
+  parse() {
+    this.skipWs();
+    const root = this.parseValue();
+    this.skipWs();
+    if (this.i < this.text.length) {
+      throw this.error(`Unexpected trailing content`, this.pos());
+    }
+    return root;
+  }
+  pos() {
+    return { line: this.line, column: this.col, offset: this.i };
+  }
+  rangeFrom(start) {
+    return { start, end: this.pos() };
+  }
+  advance(n = 1) {
+    for (let k = 0; k < n; k++) {
+      const ch = this.text[this.i];
+      if (ch === "\n") {
+        this.line += 1;
+        this.col = 1;
+      } else {
+        this.col += 1;
+      }
+      this.i += 1;
+    }
+  }
+  peek() {
+    return this.text[this.i];
+  }
+  skipWs() {
+    while (this.i < this.text.length) {
+      const ch = this.text[this.i];
+      if (ch === " " || ch === "	" || ch === "\r" || ch === "\n") {
+        this.advance();
+      } else {
+        break;
+      }
+    }
+  }
+  error(message, start) {
+    const end = {
+      line: start.line,
+      column: start.column + 1,
+      offset: Math.min(this.text.length, start.offset + 1)
+    };
+    const err = new Error(message);
+    err.range = { start, end };
+    return err;
+  }
+  parseValue() {
+    this.skipWs();
+    const ch = this.peek();
+    if (ch === void 0) throw this.error("Unexpected end of input", this.pos());
+    if (ch === "{") return this.parseObject();
+    if (ch === "[") return this.parseArray();
+    if (ch === '"') return this.parseString();
+    if (ch === "-" || ch >= "0" && ch <= "9") return this.parseNumber();
+    if (this.text.startsWith("true", this.i)) {
+      const start = this.pos();
+      this.advance(4);
+      return { kind: "boolean", range: this.rangeFrom(start), value: true };
+    }
+    if (this.text.startsWith("false", this.i)) {
+      const start = this.pos();
+      this.advance(5);
+      return { kind: "boolean", range: this.rangeFrom(start), value: false };
+    }
+    if (this.text.startsWith("null", this.i)) {
+      const start = this.pos();
+      this.advance(4);
+      return { kind: "null", range: this.rangeFrom(start) };
+    }
+    throw this.error(`Unexpected character '${ch}'`, this.pos());
+  }
+  parseObject() {
+    const start = this.pos();
+    this.advance();
+    const entries = [];
+    this.skipWs();
+    if (this.peek() === "}") {
+      this.advance();
+      return { kind: "object", range: this.rangeFrom(start), entries };
+    }
+    while (true) {
+      this.skipWs();
+      if (this.peek() !== '"') {
+        throw this.error("Expected string key", this.pos());
+      }
+      const keyStart = this.pos();
+      const keyNode = this.parseString();
+      const keyRange = { start: keyStart, end: this.pos() };
+      this.skipWs();
+      if (this.peek() !== ":") {
+        throw this.error(`Expected ':' after key`, this.pos());
+      }
+      this.advance();
+      const value = this.parseValue();
+      entries.push({ key: keyNode.kind === "string" ? keyNode.value : "", keyRange, value });
+      this.skipWs();
+      const next = this.peek();
+      if (next === ",") {
+        this.advance();
+        continue;
+      }
+      if (next === "}") {
+        this.advance();
+        break;
+      }
+      throw this.error(`Expected ',' or '}'`, this.pos());
+    }
+    return { kind: "object", range: this.rangeFrom(start), entries };
+  }
+  parseArray() {
+    const start = this.pos();
+    this.advance();
+    const items = [];
+    this.skipWs();
+    if (this.peek() === "]") {
+      this.advance();
+      return { kind: "array", range: this.rangeFrom(start), items };
+    }
+    while (true) {
+      items.push(this.parseValue());
+      this.skipWs();
+      const next = this.peek();
+      if (next === ",") {
+        this.advance();
+        continue;
+      }
+      if (next === "]") {
+        this.advance();
+        break;
+      }
+      throw this.error(`Expected ',' or ']'`, this.pos());
+    }
+    return { kind: "array", range: this.rangeFrom(start), items };
+  }
+  parseString() {
+    const start = this.pos();
+    this.advance();
+    let value = "";
+    while (this.i < this.text.length) {
+      const ch = this.peek();
+      if (ch === '"') {
+        this.advance();
+        return { kind: "string", range: this.rangeFrom(start), value };
+      }
+      if (ch === "\n") {
+        throw this.error("Unterminated string", this.pos());
+      }
+      if (ch === "\\") {
+        this.advance();
+        const esc = this.peek();
+        if (esc === void 0) throw this.error("Unterminated escape", this.pos());
+        switch (esc) {
+          case '"':
+            value += '"';
+            this.advance();
+            break;
+          case "\\":
+            value += "\\";
+            this.advance();
+            break;
+          case "/":
+            value += "/";
+            this.advance();
+            break;
+          case "b":
+            value += "\b";
+            this.advance();
+            break;
+          case "f":
+            value += "\f";
+            this.advance();
+            break;
+          case "n":
+            value += "\n";
+            this.advance();
+            break;
+          case "r":
+            value += "\r";
+            this.advance();
+            break;
+          case "t":
+            value += "	";
+            this.advance();
+            break;
+          case "u": {
+            this.advance();
+            const hex = this.text.slice(this.i, this.i + 4);
+            if (!/^[0-9a-fA-F]{4}$/.test(hex)) {
+              throw this.error("Invalid unicode escape", this.pos());
+            }
+            value += String.fromCharCode(parseInt(hex, 16));
+            this.advance(4);
+            break;
+          }
+          default:
+            throw this.error(`Invalid escape \\${esc}`, this.pos());
+        }
+        continue;
+      }
+      value += ch;
+      this.advance();
+    }
+    throw this.error("Unterminated string", this.pos());
+  }
+  parseNumber() {
+    const start = this.pos();
+    const match = /-?(?:0|[1-9]\d*)(?:\.\d+)?(?:[eE][+-]?\d+)?/y;
+    match.lastIndex = this.i;
+    const m = match.exec(this.text);
+    if (!m) throw this.error("Invalid number", start);
+    this.advance(m[0].length);
+    return { kind: "number", range: this.rangeFrom(start), value: parseFloat(m[0]) };
+  }
+};
+var PALETTE_COLORS = /* @__PURE__ */ new Set([
+  "black",
+  "gray",
+  "red",
+  "orange",
+  "yellow",
+  "green",
+  "teal",
+  "blue",
+  "purple",
+  "pink"
+]);
+var FILL_COLORS = /* @__PURE__ */ new Set([...PALETTE_COLORS, "transparent", "white"]);
+var SIZES = /* @__PURE__ */ new Set(["S", "M", "L", "XL"]);
+var LINE_STYLES = /* @__PURE__ */ new Set(["solid", "dashed", "dotted"]);
+var END_CAPS = /* @__PURE__ */ new Set(["none", "arrow", "dot", "diamond"]);
+var ICON_POSITIONS = /* @__PURE__ */ new Set(["corner", "top"]);
+var SIDES = /* @__PURE__ */ new Set(["N", "S", "E", "W"]);
+var NODE_FIELDS = /* @__PURE__ */ new Set([
+  "cx",
+  "cy",
+  "w",
+  "h",
+  "textSize",
+  "textColor",
+  "borderColor",
+  "borderStyle",
+  "fillColor",
+  "icon",
+  "iconPosition",
+  "shape"
+]);
+var SHAPES = /* @__PURE__ */ new Set(["rectangle", "cylinder", "person"]);
+var EDGE_FIELDS = /* @__PURE__ */ new Set([
+  "color",
+  "lineStyle",
+  "width",
+  "startCap",
+  "endCap",
+  "sourceSide",
+  "targetSide",
+  "labelDx",
+  "labelDy"
+]);
+var AREA_FIELDS = /* @__PURE__ */ new Set(["borderColor", "borderStyle", "fillColor"]);
+var ROOT_FIELDS = /* @__PURE__ */ new Set(["gridSize", "nodes", "edges", "areas"]);
+var push = (ctx, message, range) => {
+  ctx.errors.push({ message, range });
+};
+var validateEnum = (node, allowed, label, ctx) => {
+  if (node.kind !== "string") {
+    push(ctx, `${label} must be a string`, node.range);
+    return;
+  }
+  if (!allowed.has(node.value)) {
+    const list = [...allowed].join(", ");
+    push(ctx, `${label} must be one of: ${list}`, node.range);
+  }
+};
+var validateNumber = (node, label, ctx, opts = {}) => {
+  if (node.kind !== "number") {
+    push(ctx, `${label} must be a number`, node.range);
+    return;
+  }
+  if (opts.integer && !Number.isInteger(node.value)) {
+    push(ctx, `${label} must be an integer`, node.range);
+  }
+  if (opts.min !== void 0 && node.value < opts.min) {
+    push(ctx, `${label} must be \u2265 ${opts.min}`, node.range);
+  }
+};
+var validateNode = (node, key, ctx) => {
+  if (node.kind !== "object") {
+    push(ctx, `Node "${key}" must be an object`, node.range);
+    return;
+  }
+  const seen = /* @__PURE__ */ new Set();
+  for (const entry of node.entries) {
+    if (seen.has(entry.key)) {
+      push(ctx, `Duplicate field "${entry.key}"`, entry.keyRange);
+    }
+    seen.add(entry.key);
+    switch (entry.key) {
+      case "cx":
+      case "cy":
+        validateNumber(entry.value, entry.key, ctx);
+        break;
+      case "w":
+      case "h":
+        validateNumber(entry.value, entry.key, ctx, { min: 1 });
+        break;
+      case "textSize":
+        validateEnum(entry.value, SIZES, "textSize", ctx);
+        break;
+      case "textColor":
+      case "borderColor":
+        validateEnum(entry.value, PALETTE_COLORS, entry.key, ctx);
+        break;
+      case "fillColor":
+        validateEnum(entry.value, FILL_COLORS, "fillColor", ctx);
+        break;
+      case "borderStyle":
+        validateEnum(entry.value, LINE_STYLES, "borderStyle", ctx);
+        break;
+      case "iconPosition":
+        validateEnum(entry.value, ICON_POSITIONS, "iconPosition", ctx);
+        break;
+      case "shape":
+        validateEnum(entry.value, SHAPES, "shape", ctx);
+        break;
+      case "icon":
+        if (entry.value.kind !== "string") {
+          push(ctx, "icon must be a string", entry.value.range);
+        } else if (!iconById(entry.value.value)) {
+          push(ctx, `Unknown icon "${entry.value.value}"`, entry.value.range);
+        }
+        break;
+      default:
+        if (!NODE_FIELDS.has(entry.key)) {
+          push(ctx, `Unknown node field "${entry.key}"`, entry.keyRange);
+        }
+    }
+  }
+  for (const req of ["cx", "cy", "w", "h"]) {
+    if (!seen.has(req)) {
+      push(ctx, `Node "${key}" is missing "${req}"`, node.range);
+    }
+  }
+};
+var validateEdge = (node, key, ctx) => {
+  if (node.kind !== "object") {
+    push(ctx, `Edge "${key}" must be an object`, node.range);
+    return;
+  }
+  const seen = /* @__PURE__ */ new Set();
+  for (const entry of node.entries) {
+    if (seen.has(entry.key)) {
+      push(ctx, `Duplicate field "${entry.key}"`, entry.keyRange);
+    }
+    seen.add(entry.key);
+    switch (entry.key) {
+      case "color":
+        validateEnum(entry.value, PALETTE_COLORS, "color", ctx);
+        break;
+      case "lineStyle":
+        validateEnum(entry.value, LINE_STYLES, "lineStyle", ctx);
+        break;
+      case "width":
+        validateEnum(entry.value, SIZES, "width", ctx);
+        break;
+      case "startCap":
+      case "endCap":
+        validateEnum(entry.value, END_CAPS, entry.key, ctx);
+        break;
+      case "sourceSide":
+      case "targetSide":
+        validateEnum(entry.value, SIDES, entry.key, ctx);
+        break;
+      case "labelDx":
+      case "labelDy":
+        validateNumber(entry.value, entry.key, ctx, { integer: true });
+        break;
+      default:
+        if (!EDGE_FIELDS.has(entry.key)) {
+          push(ctx, `Unknown edge field "${entry.key}"`, entry.keyRange);
+        }
+    }
+  }
+};
+var validateArea = (node, key, ctx) => {
+  if (node.kind !== "object") {
+    push(ctx, `Area "${key}" must be an object`, node.range);
+    return;
+  }
+  const seen = /* @__PURE__ */ new Set();
+  for (const entry of node.entries) {
+    if (seen.has(entry.key)) {
+      push(ctx, `Duplicate field "${entry.key}"`, entry.keyRange);
+    }
+    seen.add(entry.key);
+    switch (entry.key) {
+      case "borderColor":
+        validateEnum(entry.value, PALETTE_COLORS, "borderColor", ctx);
+        break;
+      case "borderStyle":
+        validateEnum(entry.value, LINE_STYLES, "borderStyle", ctx);
+        break;
+      case "fillColor":
+        validateEnum(entry.value, FILL_COLORS, "fillColor", ctx);
+        break;
+      default:
+        if (!AREA_FIELDS.has(entry.key)) {
+          push(ctx, `Unknown area field "${entry.key}"`, entry.keyRange);
+        }
+    }
+  }
+};
+var validateMap = (node, label, ctx, validate) => {
+  if (node.kind !== "object") {
+    push(ctx, `${label} must be an object`, node.range);
+    return;
+  }
+  const seen = /* @__PURE__ */ new Set();
+  for (const entry of node.entries) {
+    if (seen.has(entry.key)) {
+      push(ctx, `Duplicate key "${entry.key}"`, entry.keyRange);
+    }
+    seen.add(entry.key);
+    validate(entry.value, entry.key, ctx);
+  }
+};
+var validateRoot = (node, ctx) => {
+  if (node.kind !== "object") {
+    push(ctx, "Layout root must be an object", node.range);
+    return;
+  }
+  const seen = /* @__PURE__ */ new Set();
+  for (const entry of node.entries) {
+    if (seen.has(entry.key)) {
+      push(ctx, `Duplicate field "${entry.key}"`, entry.keyRange);
+    }
+    seen.add(entry.key);
+    switch (entry.key) {
+      case "gridSize":
+        validateNumber(entry.value, "gridSize", ctx, { integer: true, min: 1 });
+        break;
+      case "nodes":
+        validateMap(entry.value, "nodes", ctx, validateNode);
+        break;
+      case "edges":
+        validateMap(entry.value, "edges", ctx, validateEdge);
+        break;
+      case "areas":
+        validateMap(entry.value, "areas", ctx, validateArea);
+        break;
+      default:
+        if (!ROOT_FIELDS.has(entry.key)) {
+          push(ctx, `Unknown root field "${entry.key}"`, entry.keyRange);
+        }
+    }
+  }
+  for (const req of ["gridSize", "nodes", "edges"]) {
+    if (!seen.has(req)) {
+      push(ctx, `Layout is missing "${req}"`, node.range);
+    }
+  }
+};
+var nodeToValue = (node) => {
+  switch (node.kind) {
+    case "string":
+      return node.value;
+    case "number":
+      return node.value;
+    case "boolean":
+      return node.value;
+    case "null":
+      return null;
+    case "array":
+      return node.items.map(nodeToValue);
+    case "object": {
+      const out = {};
+      for (const entry of node.entries) out[entry.key] = nodeToValue(entry.value);
+      return out;
+    }
+  }
+};
+var validateLayoutJson = (text) => {
+  let root;
+  try {
+    root = new JsonParser(text).parse();
+  } catch (e) {
+    const err = e;
+    return {
+      value: null,
+      errors: [{ message: err.message, range: err.range }]
+    };
+  }
+  const ctx = { errors: [] };
+  validateRoot(root, ctx);
+  if (ctx.errors.length > 0) {
+    return { value: null, errors: ctx.errors };
+  }
+  return { value: nodeToValue(root), errors: [] };
+};
+
+// src/layout/normalize.ts
+var DEFAULT_NODE_W = 4;
+var DEFAULT_NODE_H = 2;
+var START_CX = 4;
+var START_CY = 2;
+var COL_STRIDE = 6;
+var ROW_STRIDE = 4;
+var WRAP_COLS = 6;
+function normalizeForRoute(diagram, layout) {
+  const missing = diagram.nodes.filter((n) => !layout.nodes[n.id]);
+  if (missing.length === 0) return layout;
+  const placed = Object.values(layout.nodes);
+  const startCy = placed.length === 0 ? START_CY : Math.ceil(Math.max(...placed.map((n) => n.cy + n.h / 2))) + 2;
+  const nodes = { ...layout.nodes };
+  missing.forEach((node, i) => {
+    const col = i % WRAP_COLS;
+    const row = Math.floor(i / WRAP_COLS);
+    nodes[node.id] = {
+      cx: START_CX + col * COL_STRIDE,
+      cy: startCy + row * ROW_STRIDE,
+      w: DEFAULT_NODE_W,
+      h: DEFAULT_NODE_H
+    };
+  });
+  return { ...layout, nodes };
+}
+
+// server/render/model.ts
+var fallbackLayout = () => ({ gridSize: 40, nodes: {}, edges: {} });
+var buildRenderModel = async (d2, layoutText) => {
+  const parsed = parse(d2);
+  if (!parsed.ok) {
+    const first = parsed.errors[0];
+    return {
+      error: first ? `${first.range.start.line}:${first.range.start.column} ${first.message}` : "parse error"
+    };
+  }
+  const layout = layoutText !== null ? validateLayoutJson(layoutText).value ?? fallbackLayout() : fallbackLayout();
+  const routed = await route(parsed.diagram, normalizeForRoute(parsed.diagram, layout));
+  const nodes = {};
+  for (const node of parsed.diagram.nodes) {
+    nodes[node.id] = { shape: node.shape, label: node.label };
+  }
+  const edges = {};
+  parsed.diagram.edges.forEach((edge, i) => {
+    edges[makeEdgeId(edge.source, edge.target, i)] = {
+      label: edge.label,
+      style: edge.style,
+      marker: edge.direction
+    };
+  });
+  return { routed, nodes, edges };
+};
+
+// server/render/png.ts
+import { Resvg } from "@resvg/resvg-js";
+var svgToPng = (svg, opts = {}) => {
+  const scale = opts.scale ?? 2;
+  const resvg = new Resvg(svg, {
+    background: opts.background ?? "#ffffff",
+    fitTo: scale === 1 ? { mode: "original" } : { mode: "zoom", value: scale },
+    // The diagram's text was laid out with approximate metrics, so any clean
+    // sans-serif is fine; load whatever the host has and fall back to a generic.
+    font: { loadSystemFonts: true, defaultFontFamily: "Arial" }
+  });
+  return resvg.render().asPng();
+};
+
+// server/render/pngText.ts
+var PNG_SIGNATURE = Buffer.from([137, 80, 78, 71, 13, 10, 26, 10]);
+var CRC_TABLE = (() => {
+  const table = new Uint32Array(256);
+  for (let n = 0; n < 256; n += 1) {
+    let c = n;
+    for (let k = 0; k < 8; k += 1) c = c & 1 ? 3988292384 ^ c >>> 1 : c >>> 1;
+    table[n] = c >>> 0;
+  }
+  return table;
+})();
+var crc32 = (buf) => {
+  let c = 4294967295;
+  for (let i = 0; i < buf.length; i += 1) c = CRC_TABLE[(c ^ buf[i]) & 255] ^ c >>> 8;
+  return (c ^ 4294967295) >>> 0;
+};
+var iTXtChunk = (keyword, text) => {
+  const body = Buffer.concat([
+    Buffer.from(keyword, "latin1"),
+    Buffer.from([0]),
+    // keyword null-terminator
+    Buffer.from([0, 0]),
+    // compression flag (0 = none) + method
+    Buffer.from([0]),
+    // empty language tag + null
+    Buffer.from([0]),
+    // empty translated keyword + null
+    Buffer.from(text, "utf8")
+  ]);
+  const type = Buffer.from("iTXt", "latin1");
+  const len = Buffer.alloc(4);
+  len.writeUInt32BE(body.length, 0);
+  const crc = Buffer.alloc(4);
+  crc.writeUInt32BE(crc32(Buffer.concat([type, body])), 0);
+  return Buffer.concat([len, type, body, crc]);
+};
+var isPng = (png) => png.length >= 33 && png.subarray(0, 8).equals(PNG_SIGNATURE) && png.subarray(12, 16).toString("latin1") === "IHDR";
+var embedPngText = (png, entries) => {
+  if (entries.length === 0 || !isPng(png)) return png;
+  const ihdrLen = png.readUInt32BE(8);
+  const insertAt = 8 + 4 + 4 + ihdrLen + 4;
+  const chunks = entries.map((e) => iTXtChunk(e.keyword, e.text));
+  return Buffer.concat([png.subarray(0, insertAt), ...chunks, png.subarray(insertAt)]);
+};
+var readPngText = (png) => {
+  const out = {};
+  if (!isPng(png)) return out;
+  let off = 8;
+  while (off + 8 <= png.length) {
+    const len = png.readUInt32BE(off);
+    const type = png.subarray(off + 4, off + 8).toString("latin1");
+    const data = png.subarray(off + 8, off + 8 + len);
+    if (type === "tEXt") {
+      const sep = data.indexOf(0);
+      if (sep >= 0) out[data.subarray(0, sep).toString("latin1")] = data.subarray(sep + 1).toString("latin1");
+    } else if (type === "iTXt") {
+      const kwEnd = data.indexOf(0);
+      if (kwEnd >= 0) {
+        const keyword = data.subarray(0, kwEnd).toString("latin1");
+        const langStart = kwEnd + 3;
+        const langEnd = data.indexOf(0, langStart);
+        const transEnd = data.indexOf(0, langEnd + 1);
+        out[keyword] = data.subarray(transEnd + 1).toString("utf8");
+      }
+    }
+    if (type === "IEND") break;
+    off += 8 + len + 4;
+  }
+  return out;
+};
+var PNG_SOURCE_KEYS = {
+  d2: "epure.d2",
+  layout: "epure.layout.json"
+};
+var PNG_MARKER_KEYS = {
+  software: "Software",
+  description: "Description"
+};
+var EPURE_SOFTWARE = "\xC9pure \u2014 github:theodo-group/epure";
+var epureDescription = (hasLayout) => [
+  "Architecture diagram made with \xC9pure, a grid-snapped, git-reviewable diagram editor.",
+  `Its editable source is embedded in this PNG as text chunks: "${PNG_SOURCE_KEYS.d2}" is the` + (hasLayout ? ` diagram topology and "${PNG_SOURCE_KEYS.layout}" is the layout.` : " diagram topology."),
+  "Extract it with `npx -y github:theodo-group/epure source <this-file.png>`,",
+  "then edit the .epr.d2 / .epr.layout.json pair and open it live with",
+  "`npx -y github:theodo-group/epure <name>.epr.d2`."
+].join(" ");
+var epureMetaEntries = (d2, layoutText) => [
+  { keyword: PNG_MARKER_KEYS.software, text: EPURE_SOFTWARE },
+  { keyword: PNG_MARKER_KEYS.description, text: epureDescription(layoutText !== null) },
+  { keyword: PNG_SOURCE_KEYS.d2, text: d2 },
+  ...layoutText !== null ? [{ keyword: PNG_SOURCE_KEYS.layout, text: layoutText }] : []
+];
+
+// server/render/svg.tsx
+import { readFileSync } from "fs";
+import { join } from "path";
+import { renderToStaticMarkup } from "react-dom/server";
+
+// src/layout/crossings.ts
+var AX_EPS = 0.5;
+var END_EPS = 1;
+var GAP_BASE = 7;
+var widthOf = (e) => STROKE_WIDTH[e.width ?? "M"];
+var segmentsOf = (pts) => {
+  const out = [];
+  for (let i = 1; i < pts.length; i += 1) {
+    const a = pts[i - 1];
+    const b = pts[i];
+    out.push({ x1: a.x, y1: a.y, x2: b.x, y2: b.y });
+  }
+  return out;
+};
+var isHorizontal = (s) => Math.abs(s.y1 - s.y2) <= AX_EPS && Math.abs(s.x1 - s.x2) > AX_EPS;
+var isVertical = (s) => Math.abs(s.x1 - s.x2) <= AX_EPS && Math.abs(s.y1 - s.y2) > AX_EPS;
+var intersect = (h, v) => {
+  const hy = (h.y1 + h.y2) / 2;
+  const vx = (v.x1 + v.x2) / 2;
+  const hxLo = Math.min(h.x1, h.x2);
+  const hxHi = Math.max(h.x1, h.x2);
+  const vyLo = Math.min(v.y1, v.y2);
+  const vyHi = Math.max(v.y1, v.y2);
+  if (vx > hxLo + END_EPS && vx < hxHi - END_EPS && hy > vyLo + END_EPS && hy < vyHi - END_EPS) {
+    return { x: vx, y: hy };
+  }
+  return null;
+};
+var computeCrossings = (edges) => {
+  const result = /* @__PURE__ */ new Map();
+  const cache = edges.map((e) => segmentsOf(e.points));
+  for (let i = 0; i < edges.length; i += 1) {
+    for (let j = i + 1; j < edges.length; j += 1) {
+      const under = edges[i];
+      const r = GAP_BASE + widthOf(edges[j]);
+      for (const a of cache[i]) {
+        for (const b of cache[j]) {
+          let pt = null;
+          if (isHorizontal(a) && isVertical(b)) pt = intersect(a, b);
+          else if (isVertical(a) && isHorizontal(b)) pt = intersect(b, a);
+          if (!pt) continue;
+          const list = result.get(under.id);
+          if (list) list.push({ x: pt.x, y: pt.y, r });
+          else result.set(under.id, [{ x: pt.x, y: pt.y, r }]);
+        }
+      }
+    }
+  }
+  return result;
+};
+
+// server/render/svg.tsx
+import { jsx, jsxs } from "react/jsx-runtime";
+var DEFAULT_PADDING = 32;
+var computeBounds = (diagram, edgeMeta) => {
+  let minX = Infinity;
+  let minY = Infinity;
+  let maxX = -Infinity;
+  let maxY = -Infinity;
+  const grow = (x, y) => {
+    minX = Math.min(minX, x);
+    minY = Math.min(minY, y);
+    maxX = Math.max(maxX, x);
+    maxY = Math.max(maxY, y);
+  };
+  for (const a of diagram.areas) {
+    grow(a.x, a.y);
+    grow(a.x + a.w, a.y + a.h);
+    grow(a.x, a.y - 12);
+  }
+  for (const n of diagram.nodes) {
+    grow(n.x, n.y);
+    grow(n.x + n.w, n.y + n.h);
+    grow(n.x + n.w, n.y + n.h + 26);
+  }
+  for (const e of diagram.edges) {
+    for (const p of e.points) grow(p.x, p.y);
+    const label = edgeMeta[e.id]?.label;
+    if (label && e.labelAnchor) {
+      const { w: pillW, h: pillH } = labelPillSize(label);
+      grow(e.labelAnchor.x - pillW / 2, e.labelAnchor.y - pillH / 2);
+      grow(e.labelAnchor.x + pillW / 2, e.labelAnchor.y + pillH / 2);
+    }
+  }
+  if (!Number.isFinite(minX)) return { x: 0, y: 0, w: 800, h: 600 };
+  return { x: minX, y: minY, w: maxX - minX, h: maxY - minY };
+};
+var renderSvgString = (model, opts = {}) => {
+  const { routed, nodes, edges } = model;
+  const pad = opts.padding ?? DEFAULT_PADDING;
+  const b = computeBounds(routed, edges);
+  const crossings = computeCrossings(routed.edges);
+  const x = b.x - pad;
+  const y = b.y - pad;
+  const w = Math.max(1, b.w + pad * 2);
+  const h = Math.max(1, b.h + pad * 2);
+  const markup = renderToStaticMarkup(
+    /* @__PURE__ */ jsxs(
+      "svg",
+      {
+        xmlns: "http://www.w3.org/2000/svg",
+        viewBox: `${x} ${y} ${w} ${h}`,
+        width: w,
+        height: h,
+        children: [
+          /* @__PURE__ */ jsx(EdgeDefs, {}),
+          /* @__PURE__ */ jsx("rect", { x, y, width: w, height: h, fill: opts.background ?? "#ffffff" }),
+          routed.areas.map((area) => /* @__PURE__ */ jsx(Area, { area }, area.id)),
+          routed.edges.map((edge) => {
+            const m = edges[edge.id] ?? {};
+            return /* @__PURE__ */ jsx(
+              Edge,
+              {
+                edge,
+                label: m.label,
+                style: m.style,
+                marker: m.marker,
+                crossings: crossings.get(edge.id)
+              },
+              edge.id
+            );
+          }),
+          routed.nodes.map((node) => {
+            const m = nodes[node.id] ?? {};
+            return /* @__PURE__ */ jsx(
+              Node,
+              {
+                id: node.id,
+                shape: node.shape ?? m.shape ?? "rectangle",
+                label: m.label,
+                x: node.x,
+                y: node.y,
+                w: node.w,
+                h: node.h,
+                textSize: node.textSize,
+                textColor: node.textColor,
+                borderColor: node.borderColor,
+                borderStyle: node.borderStyle,
+                fillColor: node.fillColor,
+                icon: node.icon,
+                iconPosition: node.iconPosition,
+                gridSize: routed.gridSize
+              },
+              node.id
+            );
+          }),
+          routed.areas.map((area) => /* @__PURE__ */ jsx(AreaLabel, { area }, `label-${area.id}`))
+        ]
+      }
+    )
+  );
+  return markup;
+};
+var inlineIcons = (svg, iconsDir) => svg.replace(
+  /(xlink:href|href)="\/icons\/([^"]+)"/g,
+  (whole, attr, file) => {
+    try {
+      const bytes = readFileSync(join(iconsDir, file));
+      const mime = file.endsWith(".svg") ? "image/svg+xml" : "image/png";
+      return `${attr}="data:${mime};base64,${bytes.toString("base64")}"`;
+    } catch {
+      return whole;
+    }
+  }
+);
+
+// server/render/index.ts
+var renderDiagramSvg = async (d2, layoutText, opts = {}) => {
+  const model = await buildRenderModel(d2, layoutText);
+  if ("error" in model) return model;
+  const svg = renderSvgString(model, opts);
+  return opts.iconsDir ? inlineIcons(svg, opts.iconsDir) : svg;
+};
+var renderDiagramPng = async (d2, layoutText, opts = {}) => {
+  const svg = await renderDiagramSvg(d2, layoutText, opts);
+  if (typeof svg !== "string") return svg;
+  const png = svgToPng(svg, opts);
+  return embedPngText(png, epureMetaEntries(d2, layoutText));
+};
+
+// lib/render.ts
+var HERE = dirname(fileURLToPath(import.meta.url));
+var WASM_CANDIDATES = [join2(HERE, "libavoid.wasm"), join2(HERE, "..", "public", "libavoid.wasm")];
+var wasm = WASM_CANDIDATES.find(existsSync);
+if (wasm) setLibavoidWasmPath(wasm);
+var packagedIconsDir = () => {
+  const candidates = [join2(HERE, "..", "dist", "icons"), join2(HERE, "..", "public", "icons")];
+  return candidates.find(existsSync) ?? candidates[0];
+};
+export {
+  PNG_MARKER_KEYS,
+  PNG_SOURCE_KEYS,
+  buildRenderModel,
+  embedPngText,
+  epureMetaEntries,
+  inlineIcons,
+  packagedIconsDir,
+  readPngText,
+  renderDiagramPng,
+  renderDiagramSvg,
+  renderSvgString,
+  setLibavoidWasmPath,
+  svgToPng
+};