compasso 0.4.1 → 0.5.0

package/dist/index.cjs

@@ -168,6 +168,207 @@ function annotationSwatch(x, yCenter) {
   return annotationDot(x + LEGEND_SWATCH_W / 2, yCenter);
 }
 
+// src/core/layered.ts
+function packSubtree(node, gaps) {
+  const { ownHalfL, ownHalfR, children } = node;
+  if (children.length === 0) {
+    return { halfL: ownHalfL, halfR: ownHalfR, offsets: [] };
+  }
+  const xs = [0];
+  for (let i = 1; i < children.length; i++) {
+    xs.push(xs[i - 1] + children[i - 1].halfR + gaps.siblingGap + children[i].halfL);
+  }
+  const first = children[0];
+  const last = children[children.length - 1];
+  const axis = (xs[0] + xs[xs.length - 1]) / 2;
+  const offsets = xs.map((x) => x - axis);
+  const halfL = Math.max(ownHalfL, axis - (xs[0] - first.halfL));
+  const halfR = Math.max(ownHalfR, xs[xs.length - 1] + last.halfR - axis);
+  return { halfL, halfR, offsets };
+}
+function allocateLanes(items) {
+  const lanes = [];
+  for (const it of items) {
+    let chosen = -1;
+    for (let l = 0; l < lanes.length; l++) {
+      if (lanes[l].every((o) => it.hi <= o.lo || it.lo >= o.hi)) {
+        chosen = l;
+        break;
+      }
+    }
+    if (chosen === -1) {
+      chosen = lanes.length;
+      lanes.push([]);
+    }
+    lanes[chosen].push({ lo: it.lo, hi: it.hi });
+    it.set(chosen);
+  }
+  return lanes.length;
+}
+function bandStack(rows, opts) {
+  const { padding, corridor } = opts;
+  if (rows.length === 0) {
+    return { rowTop: [], busY: () => 0, height: padding * 2 };
+  }
+  const rowTop = [padding];
+  for (let d = 0; d < rows.length - 1; d++) {
+    rowTop.push(rowTop[d] + rows[d].rowH + rows[d].zoneH + corridor);
+  }
+  const last = rows.length - 1;
+  const busY = (d) => rowTop[d + 1] - corridor / 2;
+  const height = rowTop[last] + rows[last].rowH + rows[last].zoneH + padding;
+  return { rowTop, busY, height };
+}
+
+// src/core/glyph.ts
+function dirVec(dir) {
+  switch (dir) {
+    case "right":
+      return [1, 0];
+    case "left":
+      return [-1, 0];
+    case "down":
+      return [0, 1];
+    case "up":
+      return [0, -1];
+  }
+}
+function r(n) {
+  return Math.round(n * 100) / 100;
+}
+function pt(x, y) {
+  return `${r(x)},${r(y)}`;
+}
+var GLYPH_ARROW_LEN = 10;
+var GLYPH_ARROW_HALF = 5;
+var GLYPH_TRI_LEN = 14;
+var GLYPH_TRI_HALF = 8;
+var GLYPH_DIAMOND_LEN = 16;
+var GLYPH_DIAMOND_HALF = 6;
+function arrowOpenPoints(tip, dir, len = GLYPH_ARROW_LEN, half = GLYPH_ARROW_HALF) {
+  return _arrowPoints(tip, dir, len, half);
+}
+function arrowFilledPoints(tip, dir, len = GLYPH_ARROW_LEN, half = GLYPH_ARROW_HALF) {
+  return _arrowPoints(tip, dir, len, half);
+}
+function _arrowPoints(tip, dir, len, half) {
+  const [ux, uy] = dirVec(dir);
+  const tx = tip.x;
+  const ty = tip.y;
+  const bx = tx - ux * len;
+  const by = ty - uy * len;
+  const px = -uy;
+  const py = ux;
+  return [
+    pt(tx, ty),
+    pt(bx + px * half, by + py * half),
+    pt(bx - px * half, by - py * half)
+  ].join(" ");
+}
+function trianglePoints(tip, dir, len = GLYPH_TRI_LEN, half = GLYPH_TRI_HALF) {
+  return _arrowPoints(tip, dir, len, half);
+}
+function diamondPoints(tip, dir, len = GLYPH_DIAMOND_LEN, half = GLYPH_DIAMOND_HALF) {
+  const [ux, uy] = dirVec(dir);
+  const tx = tip.x;
+  const ty = tip.y;
+  const mx = tx + ux * (len / 2);
+  const my = ty + uy * (len / 2);
+  const basex = tx + ux * len;
+  const basey = ty + uy * len;
+  const px = -uy;
+  const py = ux;
+  return [
+    pt(tx, ty),
+    pt(mx - px * half, my - py * half),
+    pt(basex, basey),
+    pt(mx + px * half, my + py * half)
+  ].join(" ");
+}
+function glyphInset(_dir, kind) {
+  switch (kind) {
+    case "arrow":
+      return GLYPH_ARROW_LEN;
+    case "triangle":
+      return GLYPH_TRI_LEN;
+    case "diamond":
+      return GLYPH_DIAMOND_LEN;
+  }
+}
+
+// src/core/compartment.ts
+function round2(n) {
+  return Math.round(n * 100) / 100;
+}
+function measureCompartmentBox(compartments, opts) {
+  const { padX, padY, lineH, minW } = opts;
+  let maxLineW = 0;
+  for (const c of compartments) {
+    for (const line of c.lines) {
+      const w = estimateTextWidth(line, c.font);
+      if (w > maxLineW) maxLineW = w;
+    }
+  }
+  const boxW = round2(Math.max(minW, maxLineW + 2 * padX));
+  const rows = [];
+  const dividerYs = [];
+  let y = 0;
+  for (let i = 0; i < compartments.length; i++) {
+    const c = compartments[i];
+    const lineCount = c.lines.length > 0 ? c.lines.length : 1;
+    const compartmentH = padY + lineCount * lineH + padY;
+    rows.push({
+      lines: c.lines,
+      top: round2(y + padY),
+      font: c.font
+    });
+    y += compartmentH;
+    if (i < compartments.length - 1) {
+      dividerYs.push(round2(y));
+    }
+  }
+  const boxH = round2(y);
+  return { boxW, boxH, rows, dividerYs };
+}
+
+// src/core/grid.ts
+function round3(n) {
+  return Math.round(n * 100) / 100;
+}
+function packGrid(cells, gaps) {
+  if (cells.length === 0) {
+    return { cellX: [], cellY: [], colW: [], rowH: [] };
+  }
+  const { colGap, rowGap } = gaps;
+  let maxCol = 0;
+  let maxRow = 0;
+  for (const c of cells) {
+    if (c.col > maxCol) maxCol = c.col;
+    if (c.row > maxRow) maxRow = c.row;
+  }
+  const colW = Array.from({ length: maxCol + 1 }, () => 0);
+  const rowH = Array.from({ length: maxRow + 1 }, () => 0);
+  for (const c of cells) {
+    if (c.w > colW[c.col]) colW[c.col] = c.w;
+    if (c.h > rowH[c.row]) rowH[c.row] = c.h;
+  }
+  const colX = Array.from({ length: maxCol + 1 }, () => 0);
+  for (let c = 1; c <= maxCol; c++) {
+    colX[c] = round3(colX[c - 1] + colW[c - 1] + colGap);
+  }
+  const rowY = Array.from({ length: maxRow + 1 }, () => 0);
+  for (let r2 = 1; r2 <= maxRow; r2++) {
+    rowY[r2] = round3(rowY[r2 - 1] + rowH[r2 - 1] + rowGap);
+  }
+  const cellX = cells.map(
+    (c) => round3(colX[c.col] + colW[c.col] / 2)
+  );
+  const cellY = cells.map(
+    (c) => round3(rowY[c.row] + rowH[c.row] / 2)
+  );
+  return { cellX, cellY, colW, rowH };
+}
+
 // src/genogram/types.ts
 var UNION_STATUSES = [
   "married",
@@ -302,7 +503,7 @@ function arrivalOffset(slot, total) {
   const sign = slot % 2 === 1 ? -1 : 1;
   return sign * Math.ceil(slot / 2) * step;
 }
-function allocateLanes(items) {
+function allocateLanes2(items) {
   const lanes = [];
   for (const it of items) {
     let chosen = -1;
@@ -333,12 +534,12 @@ function computeGenogramLayout(people, unions, parentLinks, relationships, opts
   const validUnions = unions.filter((u) => ids.has(u.personAId) && ids.has(u.personBId) && u.personAId !== u.personBId).sort((a, b) => a.id - b.id);
   const coupleUnions = validUnions.filter((u) => u.status !== "coparental");
   const validLinks = parentLinks.filter((l) => ids.has(l.parentId) && ids.has(l.childId) && l.parentId !== l.childId).sort((a, b) => a.id - b.id);
-  const validRels = relationships.filter((r) => ids.has(r.fromPersonId) && ids.has(r.toPersonId) && r.fromPersonId !== r.toPersonId).sort((a, b) => a.id - b.id);
+  const validRels = relationships.filter((r2) => ids.has(r2.fromPersonId) && ids.has(r2.toPersonId) && r2.fromPersonId !== r2.toPersonId).sort((a, b) => a.id - b.id);
   const relClass = new Map(
-    validRels.map((r) => [r.id, classifyRelationshipType(r.type, kinship)])
+    validRels.map((r2) => [r2.id, classifyRelationshipType(r2.type, kinship)])
   );
-  const bondRels = validRels.filter((r) => relClass.get(r.id) === "bond");
-  const parentageRels = validRels.filter((r) => relClass.get(r.id) === "parentage");
+  const bondRels = validRels.filter((r2) => relClass.get(r2.id) === "bond");
+  const parentageRels = validRels.filter((r2) => relClass.get(r2.id) === "parentage");
   const realLinks = validLinks.map((l) => ({
     parentId: l.parentId,
     childId: l.childId,
@@ -348,22 +549,22 @@ function computeGenogramLayout(people, unions, parentLinks, relationships, opts
   }));
   const declaredPairs = new Set(validLinks.map((l) => pairKey(l.parentId, l.childId)));
   const promotedByPair = /* @__PURE__ */ new Map();
-  for (const r of parentageRels) {
-    const key = pairKey(r.fromPersonId, r.toPersonId);
+  for (const r2 of parentageRels) {
+    const key = pairKey(r2.fromPersonId, r2.toPersonId);
     if (declaredPairs.has(key)) continue;
     if (promotedByPair.has(key)) continue;
-    const ga = genById.get(r.fromPersonId) ?? null;
-    const gb = genById.get(r.toPersonId) ?? null;
+    const ga = genById.get(r2.fromPersonId) ?? null;
+    const gb = genById.get(r2.toPersonId) ?? null;
     let parentId;
     let childId;
     if (ga !== null && gb !== null && ga !== gb) {
-      [parentId, childId] = ga < gb ? [r.fromPersonId, r.toPersonId] : [r.toPersonId, r.fromPersonId];
+      [parentId, childId] = ga < gb ? [r2.fromPersonId, r2.toPersonId] : [r2.toPersonId, r2.fromPersonId];
     } else {
-      const fromIsChild = relationshipTypeTokens(r.type).some((t) => kinship.childWords.has(t));
-      [parentId, childId] = fromIsChild ? [r.toPersonId, r.fromPersonId] : [r.fromPersonId, r.toPersonId];
+      const fromIsChild = relationshipTypeTokens(r2.type).some((t) => kinship.childWords.has(t));
+      [parentId, childId] = fromIsChild ? [r2.toPersonId, r2.fromPersonId] : [r2.fromPersonId, r2.toPersonId];
     }
     if (parentId === childId) continue;
-    promotedByPair.set(key, { parentId, childId, quality: r.quality, edgeId: PROMOTED_REL_ID_BASE + r.id, annotated: r.annotated ?? false });
+    promotedByPair.set(key, { parentId, childId, quality: r2.quality, edgeId: PROMOTED_REL_ID_BASE + r2.id, annotated: r2.annotated ?? false });
   }
   const allLinks = [...realLinks, ...promotedByPair.values()].sort((a, b) => a.edgeId - b.edgeId);
   const coupleByPair = /* @__PURE__ */ new Map();
@@ -385,9 +586,9 @@ function computeGenogramLayout(people, unions, parentLinks, relationships, opts
     hasTie.add(l.parentId);
     hasTie.add(l.childId);
   }
-  for (const r of bondRels) {
-    hasTie.add(r.fromPersonId);
-    hasTie.add(r.toPersonId);
+  for (const r2 of bondRels) {
+    hasTie.add(r2.fromPersonId);
+    hasTie.add(r2.toPersonId);
   }
   const isIsolated = (id) => !hasTie.has(id);
   const byGen = /* @__PURE__ */ new Map();
@@ -403,13 +604,13 @@ function computeGenogramLayout(people, unions, parentLinks, relationships, opts
   });
   const rowCount = genKeys.length;
   const rowOfPerson = /* @__PURE__ */ new Map();
-  genKeys.forEach((g, r) => byGen.get(g).forEach((p) => rowOfPerson.set(p.id, r)));
-  const rowBlocks = genKeys.map((g, r) => {
+  genKeys.forEach((g, r2) => byGen.get(g).forEach((p) => rowOfPerson.set(p.id, r2)));
+  const rowBlocks = genKeys.map((g, r2) => {
     const members = byGen.get(g).map((p) => p.id);
     const adj = /* @__PURE__ */ new Map();
     for (const id of members) adj.set(id, []);
     for (const u of coupleUnions) {
-      if (rowOfPerson.get(u.personAId) === r && rowOfPerson.get(u.personBId) === r) {
+      if (rowOfPerson.get(u.personAId) === r2 && rowOfPerson.get(u.personBId) === r2) {
         adj.get(u.personAId).push(u.personBId);
         adj.get(u.personBId).push(u.personAId);
       }
@@ -465,9 +666,9 @@ function computeGenogramLayout(people, unions, parentLinks, relationships, opts
     for (const rl of bondRels) if (rl.fromPersonId === id && rl.toPersonId === other || rl.toPersonId === id && rl.fromPersonId === other) w = Math.max(w, 0.5);
     return w;
   };
-  const sweep = (r, ref) => {
+  const sweep = (r2, ref) => {
     const pos = flattened();
-    const blocks = rowBlocks[r];
+    const blocks = rowBlocks[r2];
     const bcOf = (b) => {
       let sum = 0;
       let wsum = 0;
@@ -483,23 +684,23 @@ function computeGenogramLayout(people, unions, parentLinks, relationships, opts
     };
     const keyed = blocks.map((b) => ({ b, bc: bcOf(b), minId: Math.min(...b) }));
     keyed.sort((x, y) => x.bc !== y.bc ? x.bc - y.bc : x.minId - y.minId);
-    rowBlocks[r] = keyed.map((k) => k.b);
+    rowBlocks[r2] = keyed.map((k) => k.b);
   };
   if (rowCount >= 2) {
-    for (let r = 1; r < rowCount; r++) sweep(r, r - 1);
-    for (let r = rowCount - 2; r >= 0; r--) sweep(r, r + 1);
+    for (let r2 = 1; r2 < rowCount; r2++) sweep(r2, r2 - 1);
+    for (let r2 = rowCount - 2; r2 >= 0; r2--) sweep(r2, r2 + 1);
   }
-  for (let r = 0; r < rowCount; r++) {
-    const blocks = rowBlocks[r];
+  for (let r2 = 0; r2 < rowCount; r2++) {
+    const blocks = rowBlocks[r2];
     const connected = blocks.filter((b) => !(b.length === 1 && isIsolated(b[0])));
     const isolated = blocks.filter((b) => b.length === 1 && isIsolated(b[0])).sort((a, b) => a[0] - b[0]);
-    rowBlocks[r] = [...connected, ...isolated];
+    rowBlocks[r2] = [...connected, ...isolated];
   }
   const colOf = /* @__PURE__ */ new Map();
   let colCount = 0;
-  for (let r = 0; r < rowCount; r++) {
+  for (let r2 = 0; r2 < rowCount; r2++) {
     let c = 0;
-    for (const b of rowBlocks[r]) for (const id of b) colOf.set(id, c++);
+    for (const b of rowBlocks[r2]) for (const id of b) colOf.set(id, c++);
     colCount = Math.max(colCount, c);
   }
   const colOrThrow = (id) => colOf.get(id);
@@ -526,8 +727,8 @@ function computeGenogramLayout(people, unions, parentLinks, relationships, opts
   }
   const rowMaxLines = Array.from({ length: rowCount }, () => 1);
   for (const p of people) {
-    const r = rowOfPerson.get(p.id);
-    rowMaxLines[r] = Math.max(rowMaxLines[r], measured.get(p.id).lines.length);
+    const r2 = rowOfPerson.get(p.id);
+    rowMaxLines[r2] = Math.max(rowMaxLines[r2], measured.get(p.id).lines.length);
   }
   const planned = [];
   const gutterReqs = [];
@@ -646,10 +847,10 @@ function computeGenogramLayout(people, unions, parentLinks, relationships, opts
   {
     const byRow = /* @__PURE__ */ new Map();
     for (const u of barUnions) {
-      const r = rowOfPerson.get(u.personAId);
-      (byRow.get(r) ?? byRow.set(r, []).get(r)).push(u);
+      const r2 = rowOfPerson.get(u.personAId);
+      (byRow.get(r2) ?? byRow.set(r2, []).get(r2)).push(u);
     }
-    for (const [r, rowUnions] of byRow) {
+    for (const [r2, rowUnions] of byRow) {
       const unionsOfPerson = /* @__PURE__ */ new Map();
       for (const u of rowUnions) {
         (unionsOfPerson.get(u.personAId) ?? unionsOfPerson.set(u.personAId, []).get(u.personAId)).push(u);
@@ -675,7 +876,7 @@ function computeGenogramLayout(people, unions, parentLinks, relationships, opts
         }
         comp.sort((a, b) => a.id - b.id);
         comp.forEach((u, i) => unionDipLevel.set(u.id, i));
-        rowDipLevels[r] = Math.max(rowDipLevels[r], comp.length - 1);
+        rowDipLevels[r2] = Math.max(rowDipLevels[r2], comp.length - 1);
       }
     }
   }
@@ -900,19 +1101,19 @@ function computeGenogramLayout(people, unions, parentLinks, relationships, opts
     });
   }
   const bondGroups = /* @__PURE__ */ new Map();
-  for (const r of bondRels) {
-    const style = qualityLineStyle(r.quality, opts.qualityLexicon);
-    const lo = Math.min(r.fromPersonId, r.toPersonId);
-    const hi = Math.max(r.fromPersonId, r.toPersonId);
+  for (const r2 of bondRels) {
+    const style = qualityLineStyle(r2.quality, opts.qualityLexicon);
+    const lo = Math.min(r2.fromPersonId, r2.toPersonId);
+    const hi = Math.max(r2.fromPersonId, r2.toPersonId);
     const key = `${lo}|${hi}|${style}`;
-    const title = r.quality !== null ? `${r.type} \xB7 ${r.quality}` : r.type;
+    const title = r2.quality !== null ? `${r2.type} \xB7 ${r2.quality}` : r2.type;
     const g = bondGroups.get(key);
     if (g === void 0) {
-      bondGroups.set(key, { relIds: [r.id], titles: [title], style, aId: r.fromPersonId, bId: r.toPersonId, annotated: r.annotated ?? false });
+      bondGroups.set(key, { relIds: [r2.id], titles: [title], style, aId: r2.fromPersonId, bId: r2.toPersonId, annotated: r2.annotated ?? false });
     } else {
-      g.relIds.push(r.id);
+      g.relIds.push(r2.id);
       g.titles.push(title);
-      if (r.annotated) g.annotated = true;
+      if (r2.annotated) g.annotated = true;
     }
   }
   const bondList = [...bondGroups.values()].sort((a, b) => Math.max(...a.relIds) - Math.max(...b.relIds));
@@ -947,7 +1148,7 @@ function computeGenogramLayout(people, unions, parentLinks, relationships, opts
   const laneCount = (gutter, side) => gutterLaneCount.get(`${gutter}:${side}`) ?? 0;
   const geo = {
     cx: (c) => colCenterX[c],
-    cy: (r) => rowCenterY[r],
+    cy: (r2) => rowCenterY[r2],
     glyphRight: (id) => colCenterX[colOrThrow(id)] + NODE_SIZE / 2,
     glyphLeft: (id) => colCenterX[colOrThrow(id)] - NODE_SIZE / 2,
     gutterCenterX: (g) => {
@@ -965,7 +1166,7 @@ function computeGenogramLayout(people, unions, parentLinks, relationships, opts
     },
     corridorLaneY: (req) => corridorTopY[req.corridor] + CORRIDOR_BASE / 2 + req.lane * LANE_H,
     /** Y of a dipped serial-union bar (level ≥ 1): below the row's glyph bottom edge. */
-    unionDipY: (r, level) => rowCenterY[r] + NODE_SIZE / 2 + level * UNION_STAGGER
+    unionDipY: (r2, level) => rowCenterY[r2] + NODE_SIZE / 2 + level * UNION_STAGGER
   };
   const gutterGroups = /* @__PURE__ */ new Map();
   for (const req of gutterReqs) {
@@ -975,7 +1176,7 @@ function computeGenogramLayout(people, unions, parentLinks, relationships, opts
   for (const [k, reqs] of gutterGroups) {
     gutterLaneCount.set(
       k,
-      allocateLanes(reqs.map((req) => ({ lo: req.rowLo, hi: req.rowHi, set: (lane) => req.lane = lane })))
+      allocateLanes2(reqs.map((req) => ({ lo: req.rowLo, hi: req.rowHi, set: (lane) => req.lane = lane })))
     );
   }
   const gutterWidth = (g) => {
@@ -996,7 +1197,7 @@ function computeGenogramLayout(people, unions, parentLinks, relationships, opts
   const corridorGroups = /* @__PURE__ */ new Map();
   for (const req of corridorReqs) (corridorGroups.get(req.corridor) ?? corridorGroups.set(req.corridor, []).get(req.corridor)).push(req);
   for (const [k, reqs] of corridorGroups) {
-    corridorLaneCount[k] = allocateLanes(
+    corridorLaneCount[k] = allocateLanes2(
       reqs.map((req) => {
         const [lo, hi] = req.xRange();
         return { lo, hi, set: (lane) => req.lane = lane };
@@ -1008,20 +1209,20 @@ function computeGenogramLayout(people, unions, parentLinks, relationships, opts
     if (lanes > 0) return CORRIDOR_BASE + lanes * LANE_H;
     return k < rowCount - 1 ? CORRIDOR_BASE : 0;
   };
-  const rowDipReserve = (r) => rowDipLevels[r] > 0 ? rowDipLevels[r] * UNION_STAGGER + 6 : 0;
+  const rowDipReserve = (r2) => rowDipLevels[r2] > 0 ? rowDipLevels[r2] * UNION_STAGGER + 6 : 0;
   let cursorY = PADDING;
-  for (let r = 0; r < rowCount; r++) {
-    rowCenterY[r] = cursorY + NODE_SIZE / 2;
-    rowLabelTopY[r] = cursorY + NODE_SIZE + rowDipReserve(r) + LABEL_GAP_TOP;
-    cursorY = rowLabelTopY[r] + rowMaxLines[r] * LABEL_LINE_H;
-    corridorTopY[r] = cursorY;
-    cursorY += corridorHeight(r);
+  for (let r2 = 0; r2 < rowCount; r2++) {
+    rowCenterY[r2] = cursorY + NODE_SIZE / 2;
+    rowLabelTopY[r2] = cursorY + NODE_SIZE + rowDipReserve(r2) + LABEL_GAP_TOP;
+    cursorY = rowLabelTopY[r2] + rowMaxLines[r2] * LABEL_LINE_H;
+    corridorTopY[r2] = cursorY;
+    cursorY += corridorHeight(r2);
   }
   const width = dims.width;
   const height = cursorY + PADDING;
   const nodes = [...people].sort((a, b) => a.id - b.id).map((p) => {
     const m = measured.get(p.id);
-    const r = rowOfPerson.get(p.id);
+    const r2 = rowOfPerson.get(p.id);
     const c = colOrThrow(p.id);
     return {
       personId: p.id,
@@ -1030,10 +1231,10 @@ function computeGenogramLayout(people, unions, parentLinks, relationships, opts
       deceased: p.deceased,
       annotated: p.annotated ?? false,
       cx: colCenterX[c],
-      cy: rowCenterY[r],
+      cy: rowCenterY[r2],
       size: NODE_SIZE,
       labelLines: m.lines,
-      labelTop: rowLabelTopY[r]
+      labelTop: rowLabelTopY[r2]
     };
   });
   const elements = planned.map((pl) => ({
@@ -1318,7 +1519,7 @@ var SINGLE_RING_MAX = 8;
 var NODE_STROKE = "#52525b";
 var LABEL_FILL = "#3f3f46";
 var EDGE_INK2 = "#71717a";
-var round2 = (n) => Math.round(n * 100) / 100;
+var round4 = (n) => Math.round(n * 100) / 100;
 function arrowHead(tipX, tipY, ux, uy, opacity) {
   const LEN = 9;
   const HALF_W = 4.5;
@@ -1327,9 +1528,9 @@ function arrowHead(tipX, tipY, ux, uy, opacity) {
   const px = -uy;
   const py = ux;
   const points = [
-    `${round2(tipX)},${round2(tipY)}`,
-    `${round2(bx + px * HALF_W)},${round2(by + py * HALF_W)}`,
-    `${round2(bx - px * HALF_W)},${round2(by - py * HALF_W)}`
+    `${round4(tipX)},${round4(tipY)}`,
+    `${round4(bx + px * HALF_W)},${round4(by + py * HALF_W)}`,
+    `${round4(bx - px * HALF_W)},${round4(by - py * HALF_W)}`
   ].join(" ");
   return `<polygon points="${points}" fill="${EDGE_INK2}" fill-opacity="${opacity}"/>`;
 }
@@ -1375,16 +1576,16 @@ function ecomapSvg(input, opts = {}) {
     sameRingRadius(twoRings ? 2 : 1)
   );
   if (twoRings) {
-    const crossDist = (r) => Math.sqrt(r * r + (r + ringStep) ** 2 - 2 * r * (r + ringStep) * Math.cos(stepAngle));
+    const crossDist = (r2) => Math.sqrt(r2 * r2 + (r2 + ringStep) ** 2 - 2 * r2 * (r2 + ringStep) * Math.cos(stepAngle));
     while (crossDist(innerR) < safeDist) innerR += 8;
   }
   const outerR = innerR + ringStep;
   for (let i = 0; i < n; i++) {
     const s = sats[i];
     s.angle = -Math.PI / 2 + i * Math.PI * 2 / n;
-    const r = twoRings && i % 2 === 1 ? outerR : innerR;
-    s.x = r * Math.cos(s.angle);
-    s.y = r * Math.sin(s.angle);
+    const r2 = twoRings && i % 2 === 1 ? outerR : innerR;
+    s.x = r2 * Math.cos(s.angle);
+    s.y = r2 * Math.sin(s.angle);
   }
   let minX = -centerR;
   let minY = -centerR;
@@ -1419,7 +1620,7 @@ function ecomapSvg(input, opts = {}) {
     const dashAttr = ink.dash === null ? "" : ` stroke-dasharray="${ink.dash[0]} ${ink.dash[1]}"`;
     const title = s.tie.title ?? (s.tie.quality !== null ? `${s.tie.label} \xB7 ${s.tie.quality}` : s.tie.label);
     const body = [
-      `<line x1="${round2(x1)}" y1="${round2(y1)}" x2="${round2(x2)}" y2="${round2(y2)}" stroke="${EDGE_INK2}" stroke-width="${ink.width}" stroke-opacity="${ink.opacity}"${dashAttr}/>`
+      `<line x1="${round4(x1)}" y1="${round4(y1)}" x2="${round4(x2)}" y2="${round4(y2)}" stroke="${EDGE_INK2}" stroke-width="${ink.width}" stroke-opacity="${ink.opacity}"${dashAttr}/>`
     ];
     if (s.tie.direction === "in" || s.tie.direction === "both") {
       body.push(arrowHead(x2, y2, ux, uy, ink.opacity));
@@ -1431,19 +1632,19 @@ function ecomapSvg(input, opts = {}) {
   }
   {
     const tspans = centerLines.map(
-      (line, i) => `<tspan x="${round2(cx)}" y="${round2(cy - (centerLines.length - 1) * LINE_H / 2 + i * LINE_H + fontSize * 0.32)}">${xmlEscape(line)}</tspan>`
+      (line, i) => `<tspan x="${round4(cx)}" y="${round4(cy - (centerLines.length - 1) * LINE_H / 2 + i * LINE_H + fontSize * 0.32)}">${xmlEscape(line)}</tspan>`
     ).join("");
     parts.push(
-      `<g data-individual-id="center"><title>${xmlEscape(input.centerLabel)}</title><circle cx="${round2(cx)}" cy="${round2(cy)}" r="${round2(centerR)}" fill="transparent" stroke="${NODE_STROKE}" stroke-width="2"/><text text-anchor="middle" font-family="${FONT_FAMILY}" font-size="${fontSize}" fill="${LABEL_FILL}">${tspans}</text></g>`
+      `<g data-individual-id="center"><title>${xmlEscape(input.centerLabel)}</title><circle cx="${round4(cx)}" cy="${round4(cy)}" r="${round4(centerR)}" fill="transparent" stroke="${NODE_STROKE}" stroke-width="2"/><text text-anchor="middle" font-family="${FONT_FAMILY}" font-size="${fontSize}" fill="${LABEL_FILL}">${tspans}</text></g>`
     );
   }
   for (const s of sats) {
     const tspans = s.lines.map(
-      (line, i) => `<tspan x="${round2(s.x)}" y="${round2(s.y - (s.lines.length - 1) * LINE_H / 2 + i * LINE_H + fontSize * 0.32)}">${xmlEscape(line)}</tspan>`
+      (line, i) => `<tspan x="${round4(s.x)}" y="${round4(s.y - (s.lines.length - 1) * LINE_H / 2 + i * LINE_H + fontSize * 0.32)}">${xmlEscape(line)}</tspan>`
     ).join("");
     const pieces = [
       `<title>${xmlEscape(s.tie.label)}</title>`,
-      `<ellipse cx="${round2(s.x)}" cy="${round2(s.y)}" rx="${round2(s.rx)}" ry="${round2(s.ry)}" fill="transparent" stroke="${NODE_STROKE}" stroke-width="1.5"/>`,
+      `<ellipse cx="${round4(s.x)}" cy="${round4(s.y)}" rx="${round4(s.rx)}" ry="${round4(s.ry)}" fill="transparent" stroke="${NODE_STROKE}" stroke-width="1.5"/>`,
       `<text text-anchor="middle" font-family="${FONT_FAMILY}" font-size="${fontSize}" fill="${LABEL_FILL}">${tspans}</text>`
     ];
     if (s.tie.annotated) {
@@ -1654,7 +1855,7 @@ function faultTreeIssues(input) {
       );
     }
   }
-  const GRAPH_BLOCKING2 = /* @__PURE__ */ new Set([
+  const GRAPH_BLOCKING3 = /* @__PURE__ */ new Set([
     "duplicate-id",
     "unknown-input",
     "gate-on-non-intermediate",
@@ -1663,7 +1864,7 @@ function faultTreeIssues(input) {
     "inhibit-condition",
     "top-not-intermediate"
   ]);
-  if (!issues.some((i) => GRAPH_BLOCKING2.has(i.code))) {
+  if (!issues.some((i) => GRAPH_BLOCKING3.has(i.code))) {
     const gateOf = (eventId) => gates.find((g) => g.eventId === eventId);
     const reachable = /* @__PURE__ */ new Set();
     const queue = [input.topId];
@@ -1743,7 +1944,7 @@ var FT_DROP_ID_BASE = 2e6;
 var FT_BUS_ID_BASE = 3e6;
 var FT_RISER_ID_BASE = 4e6;
 var FT_CONDITION_ID_BASE = 5e6;
-var round3 = (n) => Math.round(n * 100) / 100;
+var round5 = (n) => Math.round(n * 100) / 100;
 function wrapLeafLabel(displayLabel) {
   const perLine = Math.min(20, Math.max(12, Math.ceil(displayLabel.length / 2) + 2));
   return wrapLabel(displayLabel, perLine);
@@ -1930,14 +2131,14 @@ function computeFaultTreeLayout(input, opts = {}) {
       eventId: inst.event.id,
       kind: inst.event.kind,
       instance: instanceOf(inst),
-      cx: round3(inst.cx),
-      top: round3(top),
-      nodeW: round3(inst.m.nodeW),
-      nodeH: round3(inst.m.nodeH),
-      glyphW: round3(inst.m.glyphW),
-      glyphH: round3(inst.m.glyphH),
+      cx: round5(inst.cx),
+      top: round5(top),
+      nodeW: round5(inst.m.nodeW),
+      nodeH: round5(inst.m.nodeH),
+      glyphW: round5(inst.m.glyphW),
+      glyphH: round5(inst.m.glyphH),
       labelLines: inst.m.labelLines,
-      labelTop: labelTop === null ? null : round3(labelTop),
+      labelTop: labelTop === null ? null : round5(labelTop),
       code: inst.m.code,
       depth: inst.depth,
       title: inst.title
@@ -1955,8 +2156,8 @@ function computeFaultTreeLayout(input, opts = {}) {
     gates.push({
       gateId: g.id,
       type: g.type,
-      cx: round3(inst.cx),
-      top: round3(gateTop),
+      cx: round5(inst.cx),
+      top: round5(gateTop),
       glyphW,
       glyphH,
       title,
@@ -1973,8 +2174,8 @@ function computeFaultTreeLayout(input, opts = {}) {
         edgeId: FT_CONDITION_ID_BASE + g.id,
         kind: "condition",
         points: [
-          { x: round3(inst.cx + INHIBIT_W / 2), y: round3(gateTop + INHIBIT_CY) },
-          { x: round3(ovalLeft), y: round3(gateTop + INHIBIT_CY) }
+          { x: round5(inst.cx + INHIBIT_W / 2), y: round5(gateTop + INHIBIT_CY) },
+          { x: round5(ovalLeft), y: round5(gateTop + INHIBIT_CY) }
         ],
         instance: null,
         title: titleLabels.condition
@@ -1984,8 +2185,8 @@ function computeFaultTreeLayout(input, opts = {}) {
       edgeId: FT_STEM_ID_BASE + g.id,
       kind: "stem",
       points: [
-        { x: round3(inst.cx), y: round3(rowTop[d] + inst.m.nodeH) },
-        { x: round3(inst.cx), y: round3(gateTop) }
+        { x: round5(inst.cx), y: round5(rowTop[d] + inst.m.nodeH) },
+        { x: round5(inst.cx), y: round5(gateTop) }
       ],
       instance: null,
       title
@@ -1995,8 +2196,8 @@ function computeFaultTreeLayout(input, opts = {}) {
       edgeId: FT_DROP_ID_BASE + g.id,
       kind: "drop",
       points: [
-        { x: round3(inst.cx), y: round3(gateTop + glyphH) },
-        { x: round3(inst.cx), y: round3(by) }
+        { x: round5(inst.cx), y: round5(gateTop + glyphH) },
+        { x: round5(inst.cx), y: round5(by) }
       ],
       instance: null,
       title
@@ -2007,8 +2208,8 @@ function computeFaultTreeLayout(input, opts = {}) {
         edgeId: FT_BUS_ID_BASE + g.id,
         kind: "bus",
         points: [
-          { x: round3(Math.min(...xs)), y: round3(by) },
-          { x: round3(Math.max(...xs)), y: round3(by) }
+          { x: round5(Math.min(...xs)), y: round5(by) },
+          { x: round5(Math.max(...xs)), y: round5(by) }
         ],
         instance: null,
         title
@@ -2019,8 +2220,8 @@ function computeFaultTreeLayout(input, opts = {}) {
         edgeId: FT_RISER_ID_BASE + c.event.id,
         kind: "riser",
         points: [
-          { x: round3(c.cx), y: round3(by) },
-          { x: round3(c.cx), y: round3(rowTop[d + 1]) }
+          { x: round5(c.cx), y: round5(by) },
+          { x: round5(c.cx), y: round5(rowTop[d + 1]) }
         ],
         instance: instanceOf(c),
         title
@@ -2037,42 +2238,42 @@ var GLYPH_STROKE2 = "#52525b";
 var LABEL_FILL2 = "#3f3f46";
 var EDGE_INK3 = "#71717a";
 var GLYPH_ATTRS = `fill="transparent" stroke="${GLYPH_STROKE2}" stroke-width="2"`;
-var round4 = (n) => Math.round(n * 100) / 100;
+var round6 = (n) => Math.round(n * 100) / 100;
 function eventGlyph(n) {
   const cx = n.cx;
   const top = n.top;
   if (n.kind === "intermediate") {
-    return `<rect x="${round4(cx - n.nodeW / 2)}" y="${top}" width="${n.nodeW}" height="${n.nodeH}" rx="2" ${GLYPH_ATTRS}/>`;
+    return `<rect x="${round6(cx - n.nodeW / 2)}" y="${top}" width="${n.nodeW}" height="${n.nodeH}" rx="2" ${GLYPH_ATTRS}/>`;
   }
   if (n.kind === "basic") {
-    return `<circle cx="${cx}" cy="${round4(top + 22)}" r="22" ${GLYPH_ATTRS}/>`;
+    return `<circle cx="${cx}" cy="${round6(top + 22)}" r="22" ${GLYPH_ATTRS}/>`;
   }
   if (n.kind === "undeveloped") {
-    const pts2 = `${cx},${top} ${round4(cx + 24)},${round4(top + 24)} ${cx},${round4(top + 48)} ${round4(cx - 24)},${round4(top + 24)}`;
+    const pts2 = `${cx},${top} ${round6(cx + 24)},${round6(top + 24)} ${cx},${round6(top + 48)} ${round6(cx - 24)},${round6(top + 24)}`;
     return `<polygon points="${pts2}" ${GLYPH_ATTRS}/>`;
   }
   if (n.kind === "house") {
-    const yB = round4(top + 40);
-    const eave = round4(top + 16);
-    const pts2 = `${round4(cx - 22)},${yB} ${round4(cx - 22)},${eave} ${cx},${top} ${round4(cx + 22)},${eave} ${round4(cx + 22)},${yB}`;
+    const yB = round6(top + 40);
+    const eave = round6(top + 16);
+    const pts2 = `${round6(cx - 22)},${yB} ${round6(cx - 22)},${eave} ${cx},${top} ${round6(cx + 22)},${eave} ${round6(cx + 22)},${yB}`;
     return `<polygon points="${pts2}" ${GLYPH_ATTRS}/>`;
   }
   if (n.kind === "conditioning") {
-    return `<ellipse cx="${cx}" cy="${round4(top + 16)}" rx="${round4(n.glyphW / 2)}" ry="16" ${GLYPH_ATTRS}/>`;
+    return `<ellipse cx="${cx}" cy="${round6(top + 16)}" rx="${round6(n.glyphW / 2)}" ry="16" ${GLYPH_ATTRS}/>`;
   }
-  const pts = `${cx},${top} ${round4(cx + 22)},${round4(top + 35)} ${round4(cx - 22)},${round4(top + 35)}`;
+  const pts = `${cx},${top} ${round6(cx + 22)},${round6(top + 35)} ${round6(cx - 22)},${round6(top + 35)}`;
   return `<polygon points="${pts}" ${GLYPH_ATTRS}/>`;
 }
 function nodeSvg(n) {
   const pieces = [`<title>${xmlEscape(n.title)}</title>`, eventGlyph(n)];
   if (n.code !== null && n.kind !== "intermediate") {
     pieces.push(
-      `<text x="${n.cx}" y="${round4(n.top + n.glyphH / 2 + CODE_FONT * 0.32)}" text-anchor="middle" font-family="${FONT_FAMILY}" font-size="${CODE_FONT}" fill="${LABEL_FILL2}">${xmlEscape(n.code)}</text>`
+      `<text x="${n.cx}" y="${round6(n.top + n.glyphH / 2 + CODE_FONT * 0.32)}" text-anchor="middle" font-family="${FONT_FAMILY}" font-size="${CODE_FONT}" fill="${LABEL_FILL2}">${xmlEscape(n.code)}</text>`
     );
   }
   if (n.labelLines.length > 0) {
-    const firstBaseline = n.labelTop === null ? round4(n.top + 19) : round4(n.labelTop + 10);
-    const tspans = n.labelLines.map((line, i) => `<tspan x="${n.cx}" y="${round4(firstBaseline + i * FT_LABEL_LINE_H)}">${xmlEscape(line)}</tspan>`).join("");
+    const firstBaseline = n.labelTop === null ? round6(n.top + 19) : round6(n.labelTop + 10);
+    const tspans = n.labelLines.map((line, i) => `<tspan x="${n.cx}" y="${round6(firstBaseline + i * FT_LABEL_LINE_H)}">${xmlEscape(line)}</tspan>`).join("");
     pieces.push(
       `<text text-anchor="middle" font-family="${FONT_FAMILY}" font-size="${FT_LABEL_FONT}" fill="${LABEL_FILL2}">${tspans}</text>`
     );
@@ -2081,28 +2282,28 @@ function nodeSvg(n) {
   return `<g data-node-id="e${n.eventId}"${instance}>${pieces.join("")}</g>`;
 }
 function orBodyPath(cx, top, yB) {
-  return `M ${round4(cx - 22)} ${yB} Q ${cx} ${round4(yB - 14)} ${round4(cx + 22)} ${yB} Q ${round4(cx + 22)} ${round4(top + 14)} ${cx} ${top} Q ${round4(cx - 22)} ${round4(top + 14)} ${round4(cx - 22)} ${yB} Z`;
+  return `M ${round6(cx - 22)} ${yB} Q ${cx} ${round6(yB - 14)} ${round6(cx + 22)} ${yB} Q ${round6(cx + 22)} ${round6(top + 14)} ${cx} ${top} Q ${round6(cx - 22)} ${round6(top + 14)} ${round6(cx - 22)} ${yB} Z`;
 }
 function gateGlyph(g) {
   const cx = g.cx;
   const top = g.top;
-  const yB = round4(top + 36);
+  const yB = round6(top + 36);
   if (g.type === "and") {
-    const d = `M ${round4(cx - 22)} ${yB} L ${round4(cx - 22)} ${round4(yB - 14)} A 22 22 0 0 1 ${round4(cx + 22)} ${round4(yB - 14)} L ${round4(cx + 22)} ${yB} Z`;
+    const d = `M ${round6(cx - 22)} ${yB} L ${round6(cx - 22)} ${round6(yB - 14)} A 22 22 0 0 1 ${round6(cx + 22)} ${round6(yB - 14)} L ${round6(cx + 22)} ${yB} Z`;
     return `<path d="${d}" ${GLYPH_ATTRS}/>`;
   }
   if (g.type === "or") {
     return `<path d="${orBodyPath(cx, top, yB)}" ${GLYPH_ATTRS}/>`;
   }
   if (g.type === "xor") {
-    const arc = `M ${round4(cx - 22)} ${round4(yB + 5)} Q ${cx} ${round4(yB - 9)} ${round4(cx + 22)} ${round4(yB + 5)}`;
+    const arc = `M ${round6(cx - 22)} ${round6(yB + 5)} Q ${cx} ${round6(yB - 9)} ${round6(cx + 22)} ${round6(yB + 5)}`;
     return `<path d="${orBodyPath(cx, top, yB)}" ${GLYPH_ATTRS}/><path d="${arc}" ${GLYPH_ATTRS}/>`;
   }
   if (g.type === "inhibit") {
-    const pts = `${cx},${top} ${round4(cx + 18)},${round4(top + 12)} ${round4(cx + 18)},${round4(top + 34)} ${cx},${round4(top + 46)} ${round4(cx - 18)},${round4(top + 34)} ${round4(cx - 18)},${round4(top + 12)}`;
+    const pts = `${cx},${top} ${round6(cx + 18)},${round6(top + 12)} ${round6(cx + 18)},${round6(top + 34)} ${cx},${round6(top + 46)} ${round6(cx - 18)},${round6(top + 34)} ${round6(cx - 18)},${round6(top + 12)}`;
     return `<polygon points="${pts}" ${GLYPH_ATTRS}/>`;
   }
-  return `<path d="${orBodyPath(cx, top, yB)}" ${GLYPH_ATTRS}/><text x="${cx}" y="${round4(yB - 10)}" text-anchor="middle" font-family="${FONT_FAMILY}" font-size="9" fill="${LABEL_FILL2}">${xmlEscape(g.voteText ?? "")}</text>`;
+  return `<path d="${orBodyPath(cx, top, yB)}" ${GLYPH_ATTRS}/><text x="${cx}" y="${round6(yB - 10)}" text-anchor="middle" font-family="${FONT_FAMILY}" font-size="9" fill="${LABEL_FILL2}">${xmlEscape(g.voteText ?? "")}</text>`;
 }
 function gateSvg(g) {
   return `<g data-node-id="g${g.gateId}"><title>${xmlEscape(g.title)}</title>${gateGlyph(g)}</g>`;
@@ -2115,34 +2316,34 @@ function elementSvg2(el) {
 }
 var MINI_ATTRS = `fill="transparent" stroke="${GLYPH_STROKE2}" stroke-width="1.5"`;
 function miniEventSwatch(kind, x, y) {
-  const cx = round4(x + LEGEND_SWATCH_W / 2);
+  const cx = round6(x + LEGEND_SWATCH_W / 2);
   if (kind === "intermediate") {
-    return `<rect x="${round4(cx - 7)}" y="${round4(y - 4.5)}" width="14" height="9" rx="1" ${MINI_ATTRS}/>`;
+    return `<rect x="${round6(cx - 7)}" y="${round6(y - 4.5)}" width="14" height="9" rx="1" ${MINI_ATTRS}/>`;
   }
   if (kind === "basic") return `<circle cx="${cx}" cy="${y}" r="6" ${MINI_ATTRS}/>`;
   if (kind === "undeveloped") {
-    return `<polygon points="${cx},${round4(y - 7)} ${round4(cx + 7)},${y} ${cx},${round4(y + 7)} ${round4(cx - 7)},${y}" ${MINI_ATTRS}/>`;
+    return `<polygon points="${cx},${round6(y - 7)} ${round6(cx + 7)},${y} ${cx},${round6(y + 7)} ${round6(cx - 7)},${y}" ${MINI_ATTRS}/>`;
   }
   if (kind === "house") {
-    return `<polygon points="${round4(cx - 6)},${round4(y + 5.5)} ${round4(cx - 6)},${round4(y - 1)} ${cx},${round4(y - 5.5)} ${round4(cx + 6)},${round4(y - 1)} ${round4(cx + 6)},${round4(y + 5.5)}" ${MINI_ATTRS}/>`;
+    return `<polygon points="${round6(cx - 6)},${round6(y + 5.5)} ${round6(cx - 6)},${round6(y - 1)} ${cx},${round6(y - 5.5)} ${round6(cx + 6)},${round6(y - 1)} ${round6(cx + 6)},${round6(y + 5.5)}" ${MINI_ATTRS}/>`;
   }
   if (kind === "conditioning") return `<ellipse cx="${cx}" cy="${y}" rx="9" ry="5.5" ${MINI_ATTRS}/>`;
-  return `<polygon points="${cx},${round4(y - 5)} ${round4(cx + 6)},${round4(y + 5)} ${round4(cx - 6)},${round4(y + 5)}" ${MINI_ATTRS}/>`;
+  return `<polygon points="${cx},${round6(y - 5)} ${round6(cx + 6)},${round6(y + 5)} ${round6(cx - 6)},${round6(y + 5)}" ${MINI_ATTRS}/>`;
 }
 function miniOrPath(cx, y) {
-  return `M ${round4(cx - 7)} ${round4(y + 5.5)} Q ${cx} ${round4(y + 1)} ${round4(cx + 7)} ${round4(y + 5.5)} Q ${round4(cx + 7)} ${round4(y - 1.5)} ${cx} ${round4(y - 5.5)} Q ${round4(cx - 7)} ${round4(y - 1.5)} ${round4(cx - 7)} ${round4(y + 5.5)} Z`;
+  return `M ${round6(cx - 7)} ${round6(y + 5.5)} Q ${cx} ${round6(y + 1)} ${round6(cx + 7)} ${round6(y + 5.5)} Q ${round6(cx + 7)} ${round6(y - 1.5)} ${cx} ${round6(y - 5.5)} Q ${round6(cx - 7)} ${round6(y - 1.5)} ${round6(cx - 7)} ${round6(y + 5.5)} Z`;
 }
 function miniGateSwatch(type, x, y) {
-  const cx = round4(x + LEGEND_SWATCH_W / 2);
+  const cx = round6(x + LEGEND_SWATCH_W / 2);
   if (type === "and") {
-    const d = `M ${round4(cx - 7)} ${round4(y + 5.5)} L ${round4(cx - 7)} ${round4(y + 1.5)} A 7 7 0 0 1 ${round4(cx + 7)} ${round4(y + 1.5)} L ${round4(cx + 7)} ${round4(y + 5.5)} Z`;
+    const d = `M ${round6(cx - 7)} ${round6(y + 5.5)} L ${round6(cx - 7)} ${round6(y + 1.5)} A 7 7 0 0 1 ${round6(cx + 7)} ${round6(y + 1.5)} L ${round6(cx + 7)} ${round6(y + 5.5)} Z`;
     return `<path d="${d}" ${MINI_ATTRS}/>`;
   }
   if (type === "xor") {
-    return `<path d="${miniOrPath(cx, y)}" ${MINI_ATTRS}/><path d="M ${round4(cx - 7)} ${round4(y + 7.5)} Q ${cx} ${round4(y + 3)} ${round4(cx + 7)} ${round4(y + 7.5)}" ${MINI_ATTRS}/>`;
+    return `<path d="${miniOrPath(cx, y)}" ${MINI_ATTRS}/><path d="M ${round6(cx - 7)} ${round6(y + 7.5)} Q ${cx} ${round6(y + 3)} ${round6(cx + 7)} ${round6(y + 7.5)}" ${MINI_ATTRS}/>`;
   }
   if (type === "inhibit") {
-    return `<polygon points="${cx},${round4(y - 5.5)} ${round4(cx + 4.5)},${round4(y - 2.5)} ${round4(cx + 4.5)},${round4(y + 2.5)} ${cx},${round4(y + 5.5)} ${round4(cx - 4.5)},${round4(y + 2.5)} ${round4(cx - 4.5)},${round4(y - 2.5)}" ${MINI_ATTRS}/>`;
+    return `<polygon points="${cx},${round6(y - 5.5)} ${round6(cx + 4.5)},${round6(y - 2.5)} ${round6(cx + 4.5)},${round6(y + 2.5)} ${cx},${round6(y + 5.5)} ${round6(cx - 4.5)},${round6(y + 2.5)} ${round6(cx - 4.5)},${round6(y - 2.5)}" ${MINI_ATTRS}/>`;
   }
   return `<path d="${miniOrPath(cx, y)}" ${MINI_ATTRS}/>`;
 }
@@ -2271,7 +2472,7 @@ var TWIG_W = 1.5;
 var TWIG_OP = 0.75;
 var SUB_W = 1.2;
 var SUB_OP = 0.7;
-var round5 = (n) => Math.round(n * 100) / 100;
+var round7 = (n) => Math.round(n * 100) / 100;
 function arrowHead2(tipX, tipY, ux, uy, opacity) {
   const LEN = 9;
   const HALF_W = 4.5;
@@ -2280,14 +2481,14 @@ function arrowHead2(tipX, tipY, ux, uy, opacity) {
   const px = -uy;
   const py = ux;
   const points = [
-    `${round5(tipX)},${round5(tipY)}`,
-    `${round5(bx + px * HALF_W)},${round5(by + py * HALF_W)}`,
-    `${round5(bx - px * HALF_W)},${round5(by - py * HALF_W)}`
+    `${round7(tipX)},${round7(tipY)}`,
+    `${round7(bx + px * HALF_W)},${round7(by + py * HALF_W)}`,
+    `${round7(bx - px * HALF_W)},${round7(by - py * HALF_W)}`
   ].join(" ");
   return `<polygon points="${points}" fill="${EDGE_INK4}" fill-opacity="${opacity}"/>`;
 }
 function lineEl(x1, y1, x2, y2, w, op) {
-  return `<line x1="${round5(x1)}" y1="${round5(y1)}" x2="${round5(x2)}" y2="${round5(y2)}" stroke="${EDGE_INK4}" stroke-width="${w}" stroke-opacity="${op}"/>`;
+  return `<line x1="${round7(x1)}" y1="${round7(y1)}" x2="${round7(x2)}" y2="${round7(y2)}" stroke="${EDGE_INK4}" stroke-width="${w}" stroke-opacity="${op}"/>`;
 }
 function fishboneSvg(input, opts = {}) {
   validateIds(input);
@@ -2368,7 +2569,7 @@ function fishboneSvg(input, opts = {}) {
     { length: n },
     (_, k) => up ? spineY - (e + twigGap + (n - 1 - k) * lineH) : spineY + e + twigGap + ascent + k * lineH
   );
-  const textBlock = (anchor, x, ys, lines) => `<text text-anchor="${anchor}" font-family="${FONT_FAMILY}" font-size="${fontSize}" fill="${LABEL_FILL3}">` + lines.map((line, i) => `<tspan x="${round5(x)}" y="${round5(ys[i])}">${xmlEscape(line)}</tspan>`).join("") + `</text>`;
+  const textBlock = (anchor, x, ys, lines) => `<text text-anchor="${anchor}" font-family="${FONT_FAMILY}" font-size="${fontSize}" fill="${LABEL_FILL3}">` + lines.map((line, i) => `<tspan x="${round7(x)}" y="${round7(ys[i])}">${xmlEscape(line)}</tspan>`).join("") + `</text>`;
   const parts = [];
   {
     const body = [lineEl(tailX + dx, spineY, headLeft + dx, spineY, SPINE_W, SPINE_OP)];
@@ -2383,7 +2584,7 @@ function fishboneSvg(input, opts = {}) {
     if (arrows) body.push(arrowHead2(ax, spineY, COS60, -sgn * SIN60, BONE_OP));
     const boxTop = bone.up ? spineY - bone.B - CAT_GAP - bone.boxH : spineY + bone.B + CAT_GAP;
     body.push(
-      `<rect x="${round5(tipX - bone.boxW / 2)}" y="${round5(boxTop)}" width="${round5(bone.boxW)}" height="${round5(bone.boxH)}" rx="2" fill="transparent" stroke="${BOX_STROKE}" stroke-width="1.5"/>`
+      `<rect x="${round7(tipX - bone.boxW / 2)}" y="${round7(boxTop)}" width="${round7(bone.boxW)}" height="${round7(bone.boxH)}" rx="2" fill="transparent" stroke="${BOX_STROKE}" stroke-width="1.5"/>`
     );
     body.push(textBlock("middle", tipX, centeredYs(boxTop + bone.boxH / 2, bone.catLines.length), bone.catLines));
     parts.push(
@@ -2413,7 +2614,7 @@ function fishboneSvg(input, opts = {}) {
   {
     const x = headLeft + dx;
     parts.push(
-      `<g data-node-id="head"><title>${xmlEscape(input.effectLabel)}</title><rect x="${round5(x)}" y="${round5(spineY - headH / 2)}" width="${round5(headW)}" height="${round5(headH)}" rx="2" fill="transparent" stroke="${BOX_STROKE}" stroke-width="2"/>` + textBlock("middle", x + headW / 2, centeredYs(spineY, effLines.length), effLines) + `</g>`
+      `<g data-node-id="head"><title>${xmlEscape(input.effectLabel)}</title><rect x="${round7(x)}" y="${round7(spineY - headH / 2)}" width="${round7(headW)}" height="${round7(headH)}" rx="2" fill="transparent" stroke="${BOX_STROKE}" stroke-width="2"/>` + textBlock("middle", x + headW / 2, centeredYs(spineY, effLines.length), effLines) + `</g>`
     );
   }
   const anySubs = input.categories.some((c) => c.causes.some((k) => k.subCauses.length > 0));
@@ -2627,13 +2828,13 @@ function pedigreeIssues(input) {
       );
     }
   }
-  const GRAPH_BLOCKING2 = /* @__PURE__ */ new Set([
+  const GRAPH_BLOCKING3 = /* @__PURE__ */ new Set([
     "duplicate-id",
     "unknown-partner",
     "unknown-sibship-mating",
     "unknown-child"
   ]);
-  if (!issues.some((i) => GRAPH_BLOCKING2.has(i.code))) {
+  if (!issues.some((i) => GRAPH_BLOCKING3.has(i.code))) {
     for (const s of sibships) {
       const mating = matingById.get(s.matingId);
       if (mating === void 0) continue;
@@ -2681,7 +2882,7 @@ var PED_DESCENT_ID_BASE = 2e6;
 var PED_SIBBAR_ID_BASE = 3e6;
 var PED_RISER_ID_BASE = 4e6;
 var PED_TWINBAR_ID_BASE = 5e6;
-var round6 = (n) => Math.round(n * 100) / 100;
+var round8 = (n) => Math.round(n * 100) / 100;
 function shapeForSex2(sex) {
   if (sex === "male") return "square";
   if (sex === "female") return "circle";
@@ -2920,8 +3121,8 @@ function computePedigreeLayout(input, opts = {}) {
     rowHeight[row] = Math.max(rowHeight[row], h);
   }
   const rowTop = [PADDING5];
-  for (let r = 0; r < rowCount - 1; r++) {
-    rowTop.push(rowTop[r] + rowHeight[r] + CORRIDOR2);
+  for (let r2 = 0; r2 < rowCount - 1; r2++) {
+    rowTop.push(rowTop[r2] + rowHeight[r2] + CORRIDOR2);
   }
   const glyphCyOfRow = (row) => rowTop[row] + PED_GLYPH / 2;
   const addressByIndividual = /* @__PURE__ */ new Map();
@@ -2947,8 +3148,8 @@ function computePedigreeLayout(input, opts = {}) {
     nodes.push({
       individualId: ind.id,
       shape: shapeForSex2(ind.sex),
-      cx: round6(placed.cx),
-      cy: round6(cy),
+      cx: round8(placed.cx),
+      cy: round8(cy),
       size: PED_GLYPH,
       deceased: ind.deceased,
       carrier: ind.carrier,
@@ -2958,7 +3159,7 @@ function computePedigreeLayout(input, opts = {}) {
       labelLines: lines,
       // Labels sit BELOW the row's serial-union dip band (rowDipBand) so a hub's bridge dips
       // never cross a label box.
-      labelTop: round6(cy + PED_GLYPH / 2 + PED_LABEL_GAP + rowDipBand[row]),
+      labelTop: round8(cy + PED_GLYPH / 2 + PED_LABEL_GAP + rowDipBand[row]),
       addressLabel: address,
       title: individualTitle(ind, address, conditionLabelById, titleLabels)
     });
@@ -3001,23 +3202,23 @@ function computePedigreeLayout(input, opts = {}) {
         edgeId: PED_MATING_ID_BASE + m.id,
         kind: "mating-elbow",
         points: [
-          { x: round6(hubStubX), y: round6(glyphBottom) },
-          { x: round6(hubStubX), y: round6(dipY) },
-          { x: round6(spouseStubX), y: round6(dipY) },
-          { x: round6(spouseStubX), y: round6(glyphBottom) }
+          { x: round8(hubStubX), y: round8(glyphBottom) },
+          { x: round8(hubStubX), y: round8(dipY) },
+          { x: round8(spouseStubX), y: round8(dipY) },
+          { x: round8(spouseStubX), y: round8(glyphBottom) }
         ],
         consanguineous: m.consanguineous,
         title
       });
-      matingMidpoint.set(m.id, { x: round6((hubStubX + spouseStubX) / 2), y: round6(dipY) });
+      matingMidpoint.set(m.id, { x: round8((hubStubX + spouseStubX) / 2), y: round8(dipY) });
     } else if (ay === by) {
       const y = ay;
       elements.push({
         edgeId: PED_MATING_ID_BASE + m.id,
         kind: "mating",
         points: [
-          { x: round6(lx), y: round6(y) },
-          { x: round6(rx), y: round6(y) }
+          { x: round8(lx), y: round8(y) },
+          { x: round8(rx), y: round8(y) }
         ],
         consanguineous: m.consanguineous,
         title
@@ -3027,7 +3228,7 @@ function computePedigreeLayout(input, opts = {}) {
       const channelRight = cxOf(rightId) - nodeHalfWidth(individualById.get(rightId));
       const barCenter = matingBarCenter.get(m.id);
       const originX = barCenter !== void 0 && barCenter >= channelLeft && barCenter <= channelRight ? barCenter : midX;
-      matingMidpoint.set(m.id, { x: round6(originX), y: round6(y) });
+      matingMidpoint.set(m.id, { x: round8(originX), y: round8(y) });
     } else {
       const upId = ay <= by ? aId : bId;
       const downId = ay <= by ? bId : aId;
@@ -3046,32 +3247,32 @@ function computePedigreeLayout(input, opts = {}) {
           edgeId: PED_MATING_ID_BASE + m.id,
           kind: "mating-elbow",
           points: [
-            { x: round6(upX + (downRight ? -GLYPH_HALF : GLYPH_HALF)), y: round6(upY) },
-            { x: round6(upExitX), y: round6(upY) },
-            { x: round6(upExitX), y: round6(laneY) },
-            { x: round6(downFarX), y: round6(laneY) },
-            { x: round6(downFarX), y: round6(downY) },
-            { x: round6(downSideX), y: round6(downY) }
+            { x: round8(upX + (downRight ? -GLYPH_HALF : GLYPH_HALF)), y: round8(upY) },
+            { x: round8(upExitX), y: round8(upY) },
+            { x: round8(upExitX), y: round8(laneY) },
+            { x: round8(downFarX), y: round8(laneY) },
+            { x: round8(downFarX), y: round8(downY) },
+            { x: round8(downSideX), y: round8(downY) }
           ],
           consanguineous: m.consanguineous,
           title
         });
-        matingMidpoint.set(m.id, { x: round6(downFarX), y: round6(downY) });
+        matingMidpoint.set(m.id, { x: round8(downFarX), y: round8(downY) });
       } else {
         const elbowX = (upX + downX) / 2;
         elements.push({
           edgeId: PED_MATING_ID_BASE + m.id,
           kind: "mating-elbow",
           points: [
-            { x: round6(upX + (downX >= upX ? GLYPH_HALF : -GLYPH_HALF)), y: round6(upY) },
-            { x: round6(elbowX), y: round6(upY) },
-            { x: round6(elbowX), y: round6(downY) },
-            { x: round6(downX + (upX >= downX ? GLYPH_HALF : -GLYPH_HALF)), y: round6(downY) }
+            { x: round8(upX + (downX >= upX ? GLYPH_HALF : -GLYPH_HALF)), y: round8(upY) },
+            { x: round8(elbowX), y: round8(upY) },
+            { x: round8(elbowX), y: round8(downY) },
+            { x: round8(downX + (upX >= downX ? GLYPH_HALF : -GLYPH_HALF)), y: round8(downY) }
           ],
           consanguineous: m.consanguineous,
           title
         });
-        matingMidpoint.set(m.id, { x: round6(elbowX), y: round6(downY) });
+        matingMidpoint.set(m.id, { x: round8(elbowX), y: round8(downY) });
       }
     }
   }
@@ -3093,13 +3294,13 @@ function computePedigreeLayout(input, opts = {}) {
       const barCenterX = (barLeft + barRight) / 2;
       const bendY = barY - 2 - lane % 3 * 3;
       const descentPoints = Math.abs(mid.x - barCenterX) < 0.01 ? [
-        { x: round6(mid.x), y: round6(mid.y) },
-        { x: round6(mid.x), y: round6(barY) }
+        { x: round8(mid.x), y: round8(mid.y) },
+        { x: round8(mid.x), y: round8(barY) }
       ] : [
-        { x: round6(mid.x), y: round6(mid.y) },
-        { x: round6(mid.x), y: round6(bendY) },
-        { x: round6(barCenterX), y: round6(bendY) },
-        { x: round6(barCenterX), y: round6(barY) }
+        { x: round8(mid.x), y: round8(mid.y) },
+        { x: round8(mid.x), y: round8(bendY) },
+        { x: round8(barCenterX), y: round8(bendY) },
+        { x: round8(barCenterX), y: round8(barY) }
       ];
       elements.push({
         edgeId: PED_DESCENT_ID_BASE + s.id,
@@ -3114,8 +3315,8 @@ function computePedigreeLayout(input, opts = {}) {
         edgeId: PED_SIBBAR_ID_BASE + s.id,
         kind: "sibship-bar",
         points: [
-          { x: round6(barLeft), y: round6(barY) },
-          { x: round6(barRight), y: round6(barY) }
+          { x: round8(barLeft), y: round8(barY) },
+          { x: round8(barRight), y: round8(barY) }
         ],
         consanguineous: false,
         title: titleLabels.sibship
@@ -3136,8 +3337,8 @@ function computePedigreeLayout(input, opts = {}) {
           edgeId: PED_RISER_ID_BASE + childId,
           kind: "riser",
           points: [
-            { x: round6(cx), y: round6(barY) },
-            { x: round6(cx), y: round6(childTop) }
+            { x: round8(cx), y: round8(barY) },
+            { x: round8(cx), y: round8(childTop) }
           ],
           consanguineous: false,
           title: titleLabels.sibship
@@ -3151,15 +3352,15 @@ function computePedigreeLayout(input, opts = {}) {
       if (!emittedTwinOrdinals.has(tg.ordinal)) {
         emittedTwinOrdinals.add(tg.ordinal);
         if (tg.zygosity === "unknown") {
-          unknownTwinJunctions.push({ x: round6(junctionX), y: round6(junctionY) });
+          unknownTwinJunctions.push({ x: round8(junctionX), y: round8(junctionY) });
         }
         elements.push({
           edgeId: PED_RISER_ID_BASE + childId,
           // anchored on the first member for a stable id
           kind: "riser",
           points: [
-            { x: round6(junctionX), y: round6(barY) },
-            { x: round6(junctionX), y: round6(junctionY) }
+            { x: round8(junctionX), y: round8(barY) },
+            { x: round8(junctionX), y: round8(junctionY) }
           ],
           consanguineous: false,
           title: titleLabels.twins[tg.zygosity]
@@ -3170,8 +3371,8 @@ function computePedigreeLayout(input, opts = {}) {
             edgeId: PED_TWINBAR_ID_BASE + s.id * 100 + tg.ordinal,
             kind: "twin-bar",
             points: [
-              { x: round6(Math.min(...memberXs)), y: round6(tieY) },
-              { x: round6(Math.max(...memberXs)), y: round6(tieY) }
+              { x: round8(Math.min(...memberXs)), y: round8(tieY) },
+              { x: round8(Math.max(...memberXs)), y: round8(tieY) }
             ],
             consanguineous: false,
             title: titleLabels.twins.mz
@@ -3179,12 +3380,12 @@ function computePedigreeLayout(input, opts = {}) {
         }
       }
       const horizontalThenDown = Math.abs(cx - junctionX) < 0.01 ? [
-        { x: round6(cx), y: round6(junctionY) },
-        { x: round6(cx), y: round6(childTop) }
+        { x: round8(cx), y: round8(junctionY) },
+        { x: round8(cx), y: round8(childTop) }
       ] : [
-        { x: round6(junctionX), y: round6(junctionY) },
-        { x: round6(cx), y: round6(junctionY) },
-        { x: round6(cx), y: round6(childTop) }
+        { x: round8(junctionX), y: round8(junctionY) },
+        { x: round8(cx), y: round8(junctionY) },
+        { x: round8(cx), y: round8(childTop) }
       ];
       elements.push({
         edgeId: PED_RISER_ID_BASE + childId,
@@ -3212,7 +3413,7 @@ function computePedigreeLayout(input, opts = {}) {
   }
   const generations = [];
   for (let row = 0; row < rowCount; row++) {
-    generations.push({ roman: romanNumeral(row + 1), y: round6(glyphCyOfRow(row)) });
+    generations.push({ roman: romanNumeral(row + 1), y: round8(glyphCyOfRow(row)) });
   }
   const ZYGOSITY_ORDER = ["mz", "dz", "unknown"];
   const twinZygositiesUsed = ZYGOSITY_ORDER.filter((z) => twinZygositiesUsedSet.has(z));
@@ -3236,15 +3437,15 @@ var EDGE_INK5 = "#71717a";
 var GLYPH_ATTRS2 = `fill="transparent" stroke="${GLYPH_STROKE3}" stroke-width="2"`;
 var CONSANG_GAP = 3;
 var ZYGOSITIES = ["mz", "dz", "unknown"];
-var round7 = (n) => Math.round(n * 100) / 100;
+var round9 = (n) => Math.round(n * 100) / 100;
 function glyphOutline(shape, cx, cy, half) {
   if (shape === "square") {
-    return `<rect x="${round7(cx - half)}" y="${round7(cy - half)}" width="${half * 2}" height="${half * 2}" ${GLYPH_ATTRS2}/>`;
+    return `<rect x="${round9(cx - half)}" y="${round9(cy - half)}" width="${half * 2}" height="${half * 2}" ${GLYPH_ATTRS2}/>`;
   }
   if (shape === "circle") {
     return `<circle cx="${cx}" cy="${cy}" r="${half}" ${GLYPH_ATTRS2}/>`;
   }
-  return `<polygon points="${cx},${round7(cy - half)} ${round7(cx + half)},${cy} ${cx},${round7(cy + half)} ${round7(cx - half)},${cy}" ${GLYPH_ATTRS2}/>`;
+  return `<polygon points="${cx},${round9(cy - half)} ${round9(cx + half)},${cy} ${cx},${round9(cy + half)} ${round9(cx - half)},${cy}" ${GLYPH_ATTRS2}/>`;
 }
 function glyphVerticalExtentAt(shape, cy, half, dx) {
   const ax = Math.min(Math.abs(dx), half);
@@ -3270,8 +3471,8 @@ function fillPartitions(n, half, inkByCondition) {
     for (let s = 0; s <= SAMPLES; s++) {
       const x = left + sliceW * s / SAMPLES;
       const [yt, yb] = glyphVerticalExtentAt(n.shape, cy, half, x - cx);
-      top.push(`${round7(x)},${round7(yt)}`);
-      bottom.push(`${round7(x)},${round7(yb)}`);
+      top.push(`${round9(x)},${round9(yt)}`);
+      bottom.push(`${round9(x)},${round9(yb)}`);
     }
     const pts = [...top, ...bottom.reverse()].join(" ");
     const ink = inkByCondition.get(id) ?? GLYPH_STROKE3;
@@ -3285,24 +3486,24 @@ function carrierDot(n) {
 function deceasedSlash(n, half) {
   if (!n.deceased) return "";
   const ext = half + 4;
-  return `<line x1="${round7(n.cx - ext)}" y1="${round7(n.cy - ext)}" x2="${round7(n.cx + ext)}" y2="${round7(n.cy + ext)}" stroke="${GLYPH_STROKE3}" stroke-width="2"/>`;
+  return `<line x1="${round9(n.cx - ext)}" y1="${round9(n.cy - ext)}" x2="${round9(n.cx + ext)}" y2="${round9(n.cy + ext)}" stroke="${GLYPH_STROKE3}" stroke-width="2"/>`;
 }
 function probandArrow(n, half) {
   if (n.role === null) return "";
-  const tipX = round7(n.cx - half);
-  const tipY = round7(n.cy + half);
-  const tailX = round7(tipX - 16);
-  const tailY = round7(tipY + 16);
+  const tipX = round9(n.cx - half);
+  const tipY = round9(n.cy + half);
+  const tailX = round9(tipX - 16);
+  const tailY = round9(tipY + 16);
   const filled = n.role === "proband";
   const fill = filled ? GLYPH_STROKE3 : "transparent";
   const shaft = `<line x1="${tailX}" y1="${tailY}" x2="${tipX}" y2="${tipY}" stroke="${GLYPH_STROKE3}" stroke-width="2"/>`;
-  const head = `<polygon points="${tipX},${tipY} ${round7(tipX - 8)},${round7(tipY + 2)} ${round7(tipX - 2)},${round7(tipY + 8)}" fill="${fill}" stroke="${GLYPH_STROKE3}" stroke-width="1.5"/>`;
+  const head = `<polygon points="${tipX},${tipY} ${round9(tipX - 8)},${round9(tipY + 2)} ${round9(tipX - 2)},${round9(tipY + 8)}" fill="${fill}" stroke="${GLYPH_STROKE3}" stroke-width="1.5"/>`;
   return shaft + head;
 }
 function stillbirthMark(n, half) {
   if (!n.stillbirth) return "";
-  const y = round7(n.cy + half + PED_ADDRESS_FONT);
-  return `<text x="${round7(n.cx - half - 2)}" y="${y}" text-anchor="end" font-family="${FONT_FAMILY}" font-size="${PED_ADDRESS_FONT}" font-weight="bold" fill="${LABEL_FILL4}">SB</text>`;
+  const y = round9(n.cy + half + PED_ADDRESS_FONT);
+  return `<text x="${round9(n.cx - half - 2)}" y="${y}" text-anchor="end" font-family="${FONT_FAMILY}" font-size="${PED_ADDRESS_FONT}" font-weight="bold" fill="${LABEL_FILL4}">SB</text>`;
 }
 function nodeSvg2(n, inkByCondition) {
   const half = n.size / 2;
@@ -3316,13 +3517,13 @@ function nodeSvg2(n, inkByCondition) {
     probandArrow(n, half),
     stillbirthMark(n, half)
   ];
-  const addressY = round7(n.labelTop + PED_ADDRESS_FONT);
+  const addressY = round9(n.labelTop + PED_ADDRESS_FONT);
   pieces.push(
     `<text x="${n.cx}" y="${addressY}" text-anchor="middle" font-family="${FONT_FAMILY}" font-size="${PED_ADDRESS_FONT}" fill="${LABEL_FILL4}">${xmlEscape(n.addressLabel)}</text>`
   );
   if (n.labelLines.length > 0) {
-    const firstBaseline = round7(n.labelTop + PED_LABEL_LINE_H + 10);
-    const tspans = n.labelLines.map((line, i) => `<tspan x="${n.cx}" y="${round7(firstBaseline + i * PED_LABEL_LINE_H)}">${xmlEscape(line)}</tspan>`).join("");
+    const firstBaseline = round9(n.labelTop + PED_LABEL_LINE_H + 10);
+    const tspans = n.labelLines.map((line, i) => `<tspan x="${n.cx}" y="${round9(firstBaseline + i * PED_LABEL_LINE_H)}">${xmlEscape(line)}</tspan>`).join("");
     pieces.push(
       `<text text-anchor="middle" font-family="${FONT_FAMILY}" font-size="${PED_LABEL_FONT}" fill="${LABEL_FILL4}">${tspans}</text>`
     );
@@ -3337,7 +3538,7 @@ function elementSvg3(el) {
   const title = `<title>${xmlEscape(el.title)}</title>`;
   const stroke = `stroke="${EDGE_INK5}" stroke-width="1.5" stroke-opacity="0.75"`;
   const draw = (offsetY) => {
-    const shifted = pts.map((p) => ({ x: p.x, y: round7(p.y + offsetY) }));
+    const shifted = pts.map((p) => ({ x: p.x, y: round9(p.y + offsetY) }));
     if (shifted.length === 2) {
       return `<line x1="${shifted[0].x}" y1="${shifted[0].y}" x2="${shifted[1].x}" y2="${shifted[1].y}" ${stroke}/>`;
     }
@@ -3348,51 +3549,51 @@ function elementSvg3(el) {
 }
 function unknownTwinMarks(layout) {
   return layout.unknownTwinJunctions.map(
-    (p) => `<text x="${round7(p.x + 6)}" y="${round7(p.y + 4)}" font-family="${FONT_FAMILY}" font-size="12" font-weight="bold" fill="${LABEL_FILL4}">?</text>`
+    (p) => `<text x="${round9(p.x + 6)}" y="${round9(p.y + 4)}" font-family="${FONT_FAMILY}" font-size="12" font-weight="bold" fill="${LABEL_FILL4}">?</text>`
   ).join("");
 }
 var MINI_ATTRS2 = `fill="transparent" stroke="${GLYPH_STROKE3}" stroke-width="1.5"`;
 function miniShapeSwatch(shape, x, y) {
-  const cx = round7(x + LEGEND_SWATCH_W / 2);
-  if (shape === "square") return `<rect x="${round7(cx - 6)}" y="${round7(y - 6)}" width="12" height="12" ${MINI_ATTRS2}/>`;
+  const cx = round9(x + LEGEND_SWATCH_W / 2);
+  if (shape === "square") return `<rect x="${round9(cx - 6)}" y="${round9(y - 6)}" width="12" height="12" ${MINI_ATTRS2}/>`;
   if (shape === "circle") return `<circle cx="${cx}" cy="${y}" r="6" ${MINI_ATTRS2}/>`;
-  return `<polygon points="${cx},${round7(y - 7)} ${round7(cx + 7)},${y} ${cx},${round7(y + 7)} ${round7(cx - 7)},${y}" ${MINI_ATTRS2}/>`;
+  return `<polygon points="${cx},${round9(y - 7)} ${round9(cx + 7)},${y} ${cx},${round9(y + 7)} ${round9(cx - 7)},${y}" ${MINI_ATTRS2}/>`;
 }
 function miniSwatchCircle(filled, ink, x, y) {
-  const cx = round7(x + LEGEND_SWATCH_W / 2);
+  const cx = round9(x + LEGEND_SWATCH_W / 2);
   return `<circle cx="${cx}" cy="${y}" r="6" fill="${filled ? ink : "transparent"}" stroke="${GLYPH_STROKE3}" stroke-width="1.5"/>`;
 }
 function miniCarrierSwatch(x, y) {
-  const cx = round7(x + LEGEND_SWATCH_W / 2);
+  const cx = round9(x + LEGEND_SWATCH_W / 2);
   return `<circle cx="${cx}" cy="${y}" r="6" ${MINI_ATTRS2}/><circle cx="${cx}" cy="${y}" r="2" fill="${GLYPH_STROKE3}" stroke="none"/>`;
 }
 function miniDeceasedSwatch(x, y) {
-  const cx = round7(x + LEGEND_SWATCH_W / 2);
-  return `<circle cx="${cx}" cy="${y}" r="6" ${MINI_ATTRS2}/><line x1="${round7(cx - 7)}" y1="${round7(y - 7)}" x2="${round7(cx + 7)}" y2="${round7(y + 7)}" stroke="${GLYPH_STROKE3}" stroke-width="1.5"/>`;
+  const cx = round9(x + LEGEND_SWATCH_W / 2);
+  return `<circle cx="${cx}" cy="${y}" r="6" ${MINI_ATTRS2}/><line x1="${round9(cx - 7)}" y1="${round9(y - 7)}" x2="${round9(cx + 7)}" y2="${round9(y + 7)}" stroke="${GLYPH_STROKE3}" stroke-width="1.5"/>`;
 }
 function miniArrowSwatch(filled, x, y) {
-  const cx = round7(x + LEGEND_SWATCH_W / 2);
-  const tipX = round7(cx - 2);
-  const tipY = round7(y + 2);
-  return `<line x1="${round7(tipX - 8)}" y1="${round7(tipY + 8)}" x2="${tipX}" y2="${tipY}" stroke="${GLYPH_STROKE3}" stroke-width="1.5"/><polygon points="${tipX},${tipY} ${round7(tipX - 5)},${round7(tipY + 1)} ${round7(tipX - 1)},${round7(tipY + 5)}" fill="${filled ? GLYPH_STROKE3 : "transparent"}" stroke="${GLYPH_STROKE3}" stroke-width="1"/>`;
+  const cx = round9(x + LEGEND_SWATCH_W / 2);
+  const tipX = round9(cx - 2);
+  const tipY = round9(y + 2);
+  return `<line x1="${round9(tipX - 8)}" y1="${round9(tipY + 8)}" x2="${tipX}" y2="${tipY}" stroke="${GLYPH_STROKE3}" stroke-width="1.5"/><polygon points="${tipX},${tipY} ${round9(tipX - 5)},${round9(tipY + 1)} ${round9(tipX - 1)},${round9(tipY + 5)}" fill="${filled ? GLYPH_STROKE3 : "transparent"}" stroke="${GLYPH_STROKE3}" stroke-width="1"/>`;
 }
 function miniConsanguineousSwatch(x, y) {
-  const x1 = round7(x + 2);
-  const x2 = round7(x + LEGEND_SWATCH_W - 2);
-  return `<line x1="${x1}" y1="${round7(y - 1.5)}" x2="${x2}" y2="${round7(y - 1.5)}" stroke="${EDGE_INK5}" stroke-width="1.5"/><line x1="${x1}" y1="${round7(y + 1.5)}" x2="${x2}" y2="${round7(y + 1.5)}" stroke="${EDGE_INK5}" stroke-width="1.5"/>`;
+  const x1 = round9(x + 2);
+  const x2 = round9(x + LEGEND_SWATCH_W - 2);
+  return `<line x1="${x1}" y1="${round9(y - 1.5)}" x2="${x2}" y2="${round9(y - 1.5)}" stroke="${EDGE_INK5}" stroke-width="1.5"/><line x1="${x1}" y1="${round9(y + 1.5)}" x2="${x2}" y2="${round9(y + 1.5)}" stroke="${EDGE_INK5}" stroke-width="1.5"/>`;
 }
 function miniTwinSwatch(zygosity, x, y) {
-  const cx = round7(x + LEGEND_SWATCH_W / 2);
-  const apexY = round7(y - 6);
-  const baseY = round7(y + 6);
-  const left = round7(cx - 6);
-  const right = round7(cx + 6);
+  const cx = round9(x + LEGEND_SWATCH_W / 2);
+  const apexY = round9(y - 6);
+  const baseY = round9(y + 6);
+  const left = round9(cx - 6);
+  const right = round9(cx + 6);
   const stub = `<line x1="${cx}" y1="${apexY}" x2="${cx}" y2="${y}" stroke="${EDGE_INK5}" stroke-width="1.5"/><line x1="${left}" y1="${y}" x2="${right}" y2="${y}" stroke="${EDGE_INK5}" stroke-width="1.5"/><line x1="${left}" y1="${y}" x2="${left}" y2="${baseY}" stroke="${EDGE_INK5}" stroke-width="1.5"/><line x1="${right}" y1="${y}" x2="${right}" y2="${baseY}" stroke="${EDGE_INK5}" stroke-width="1.5"/>`;
   if (zygosity === "mz") {
-    return stub + `<line x1="${left}" y1="${round7(y + 3)}" x2="${right}" y2="${round7(y + 3)}" stroke="${EDGE_INK5}" stroke-width="1.5"/>`;
+    return stub + `<line x1="${left}" y1="${round9(y + 3)}" x2="${right}" y2="${round9(y + 3)}" stroke="${EDGE_INK5}" stroke-width="1.5"/>`;
   }
   if (zygosity === "unknown") {
-    return stub + `<text x="${round7(cx + 8)}" y="${round7(y + 3)}" font-family="${FONT_FAMILY}" font-size="9" fill="${LABEL_FILL4}">?</text>`;
+    return stub + `<text x="${round9(cx + 8)}" y="${round9(y + 3)}" font-family="${FONT_FAMILY}" font-size="9" fill="${LABEL_FILL4}">?</text>`;
   }
   return stub;
 }
@@ -3405,7 +3606,7 @@ function pedigreeLayoutSvg(layout, opts = {}) {
   for (const n of layout.nodes) parts.push(nodeSvg2(n, inkByCondition));
   for (const g of layout.generations) {
     parts.push(
-      `<text x="${round7(16)}" y="${round7(g.y + PED_LABEL_FONT * 0.32)}" text-anchor="middle" font-family="${FONT_FAMILY}" font-size="${PED_LABEL_FONT}" font-weight="bold" fill="${LABEL_FILL4}">${xmlEscape(g.roman)}</text>`
+      `<text x="${round9(16)}" y="${round9(g.y + PED_LABEL_FONT * 0.32)}" text-anchor="middle" font-family="${FONT_FAMILY}" font-size="${PED_LABEL_FONT}" font-weight="bold" fill="${LABEL_FILL4}">${xmlEscape(g.roman)}</text>`
     );
   }
   let width = layout.width;
@@ -3571,13 +3772,13 @@ function phyloIssues(input) {
       push("tip-with-children", `node ${n.id} is declared internal but has no children`);
     }
   }
-  const GRAPH_BLOCKING2 = /* @__PURE__ */ new Set([
+  const GRAPH_BLOCKING3 = /* @__PURE__ */ new Set([
     "duplicate-id",
     "unknown-endpoint",
     "unknown-root",
     "multiple-parents"
   ]);
-  if (!issues.some((i) => GRAPH_BLOCKING2.has(i.code))) {
+  if (!issues.some((i) => GRAPH_BLOCKING3.has(i.code))) {
     const childrenOf = /* @__PURE__ */ new Map();
     for (const e of [...input.edges].sort((a, b) => a.id - b.id)) {
       const arr = childrenOf.get(e.parentId) ?? [];
@@ -3655,7 +3856,7 @@ var PHYLO_BRANCH_ID_BASE = 2e6;
 var PHYLO_EXTENSION_ID_BASE = 3e6;
 var PHYLO_ROOTSTUB_ID_BASE = 4e6;
 var PHYLO_SCALEBAR_ID = 5e6;
-var round8 = (n) => Math.round(n * 100) / 100;
+var round10 = (n) => Math.round(n * 100) / 100;
 function niceScaleStep(maxLen) {
   if (!(maxLen > 0)) return 0;
   const target = maxLen / 4;
@@ -3781,8 +3982,8 @@ function computePhyloLayout(input, opts = {}) {
     edgeId: PHYLO_ROOTSTUB_ID_BASE + root.node.id,
     kind: "root-stub",
     points: [
-      { x: round8(Math.max(PADDING6 / 2, rootDrawX - ROOT_STUB)), y: round8(root.cy) },
-      { x: round8(rootDrawX), y: round8(root.cy) }
+      { x: round10(Math.max(PADDING6 / 2, rootDrawX - ROOT_STUB)), y: round10(root.cy) },
+      { x: round10(rootDrawX), y: round10(root.cy) }
     ],
     dotted: false,
     length: null,
@@ -3797,11 +3998,11 @@ function computePhyloLayout(input, opts = {}) {
     nodes.push({
       nodeId: w.node.id,
       isTip: tip,
-      cx: round8(drawX),
-      cy: round8(w.cy),
+      cx: round10(drawX),
+      cy: round10(w.cy),
       support,
       labelLines: labelLine,
-      labelLeft: round8(drawX + PHYLO_TIP_R + PHYLO_LABEL_GAP),
+      labelLeft: round10(drawX + PHYLO_TIP_R + PHYLO_LABEL_GAP),
       depth: w.depth,
       title: nodeTitle(w.node, tip, isRoot, w.inLength, titleLabels)
     });
@@ -3810,8 +4011,8 @@ function computePhyloLayout(input, opts = {}) {
         edgeId: PHYLO_EXTENSION_ID_BASE + w.node.id,
         kind: "extension",
         points: [
-          { x: round8(w.cx), y: round8(w.cy) },
-          { x: round8(alignX), y: round8(w.cy) }
+          { x: round10(w.cx), y: round10(w.cy) },
+          { x: round10(alignX), y: round10(w.cy) }
         ],
         dotted: true,
         length: null,
@@ -3827,8 +4028,8 @@ function computePhyloLayout(input, opts = {}) {
         edgeId: PHYLO_CLADEBAR_ID_BASE + w.node.id,
         kind: "clade-bar",
         points: [
-          { x: round8(w.cx), y: round8(barTop) },
-          { x: round8(w.cx), y: round8(barBottom) }
+          { x: round10(w.cx), y: round10(barTop) },
+          { x: round10(w.cx), y: round10(barBottom) }
         ],
         dotted: false,
         length: null,
@@ -3840,8 +4041,8 @@ function computePhyloLayout(input, opts = {}) {
         edgeId: PHYLO_BRANCH_ID_BASE + c.node.id,
         kind: "branch",
         points: [
-          { x: round8(w.cx), y: round8(c.cy) },
-          { x: round8(c.cx), y: round8(c.cy) }
+          { x: round10(w.cx), y: round10(c.cy) },
+          { x: round10(c.cx), y: round10(c.cy) }
         ],
         dotted: false,
         length: c.inLength,
@@ -3858,17 +4059,17 @@ function computePhyloLayout(input, opts = {}) {
     const barY = treeBottom + SCALEBAR_ZONE / 2;
     scaleBar = {
       length: stepLen,
-      x: round8(barX),
-      y: round8(barY),
-      pxLength: round8(scaleBarPx),
+      x: round10(barX),
+      y: round10(barY),
+      pxLength: round10(scaleBarPx),
       valueLabel: trimNumber(stepLen)
     };
     elements.push({
       edgeId: PHYLO_SCALEBAR_ID,
       kind: "scale-bar",
       points: [
-        { x: round8(barX), y: round8(barY) },
-        { x: round8(barX + scaleBarPx), y: round8(barY) }
+        { x: round10(barX), y: round10(barY) },
+        { x: round10(barX + scaleBarPx), y: round10(barY) }
       ],
       dotted: false,
       length: stepLen,
@@ -3882,18 +4083,18 @@ function computePhyloLayout(input, opts = {}) {
 var GLYPH_STROKE4 = "#52525b";
 var LABEL_FILL5 = "#3f3f46";
 var EDGE_INK6 = "#71717a";
-var round9 = (n) => Math.round(n * 100) / 100;
+var round11 = (n) => Math.round(n * 100) / 100;
 function nodeSvg3(n, showSupport) {
   const pieces = [`<title>${xmlEscape(n.title)}</title>`];
   pieces.push(`<circle cx="${n.cx}" cy="${n.cy}" r="2.5" fill="${GLYPH_STROKE4}"/>`);
   if (n.labelLines.length > 0) {
     pieces.push(
-      `<text x="${n.labelLeft}" y="${round9(n.cy + PHYLO_LABEL_FONT * 0.32)}" font-family="${FONT_FAMILY}" font-size="${PHYLO_LABEL_FONT}" fill="${LABEL_FILL5}">${xmlEscape(n.labelLines[0])}</text>`
+      `<text x="${n.labelLeft}" y="${round11(n.cy + PHYLO_LABEL_FONT * 0.32)}" font-family="${FONT_FAMILY}" font-size="${PHYLO_LABEL_FONT}" fill="${LABEL_FILL5}">${xmlEscape(n.labelLines[0])}</text>`
     );
   }
   if (showSupport && !n.isTip && n.support !== null) {
     pieces.push(
-      `<text x="${round9(n.cx - 4)}" y="${round9(n.cy - 3)}" text-anchor="end" font-family="${FONT_FAMILY}" font-size="${PHYLO_SUPPORT_FONT}" fill="${LABEL_FILL5}">${xmlEscape(String(n.support))}</text>`
+      `<text x="${round11(n.cx - 4)}" y="${round11(n.cy - 3)}" text-anchor="end" font-family="${FONT_FAMILY}" font-size="${PHYLO_SUPPORT_FONT}" fill="${LABEL_FILL5}">${xmlEscape(String(n.support))}</text>`
     );
   }
   return `<g data-node-id="n${n.nodeId}">${pieces.join("")}</g>`;
@@ -3908,18 +4109,18 @@ function elementSvg4(el) {
 function scaleBarLabelSvg(layout) {
   const bar = layout.scaleBar;
   if (bar === null) return "";
-  const tick = (x) => `<line x1="${x}" y1="${round9(bar.y - 3)}" x2="${x}" y2="${round9(bar.y + 3)}" stroke="${EDGE_INK6}" stroke-width="1.5" stroke-opacity="0.75"/>`;
-  return tick(bar.x) + tick(round9(bar.x + bar.pxLength)) + `<text x="${round9(bar.x + bar.pxLength / 2)}" y="${round9(bar.y - 6)}" text-anchor="middle" font-family="${FONT_FAMILY}" font-size="${PHYLO_SUPPORT_FONT}" fill="${LABEL_FILL5}">${xmlEscape(bar.valueLabel)}</text>`;
+  const tick = (x) => `<line x1="${x}" y1="${round11(bar.y - 3)}" x2="${x}" y2="${round11(bar.y + 3)}" stroke="${EDGE_INK6}" stroke-width="1.5" stroke-opacity="0.75"/>`;
+  return tick(bar.x) + tick(round11(bar.x + bar.pxLength)) + `<text x="${round11(bar.x + bar.pxLength / 2)}" y="${round11(bar.y - 6)}" text-anchor="middle" font-family="${FONT_FAMILY}" font-size="${PHYLO_SUPPORT_FONT}" fill="${LABEL_FILL5}">${xmlEscape(bar.valueLabel)}</text>`;
 }
 function supportSwatch(x, y) {
-  const cx = round9(x + LEGEND_SWATCH_W / 2);
-  return `<circle cx="${cx}" cy="${y}" r="2.5" fill="${GLYPH_STROKE4}"/><text x="${round9(cx + 5)}" y="${round9(y + PHYLO_SUPPORT_FONT * 0.32)}" font-family="${FONT_FAMILY}" font-size="${PHYLO_SUPPORT_FONT}" fill="${LABEL_FILL5}">95</text>`;
+  const cx = round11(x + LEGEND_SWATCH_W / 2);
+  return `<circle cx="${cx}" cy="${y}" r="2.5" fill="${GLYPH_STROKE4}"/><text x="${round11(cx + 5)}" y="${round11(y + PHYLO_SUPPORT_FONT * 0.32)}" font-family="${FONT_FAMILY}" font-size="${PHYLO_SUPPORT_FONT}" fill="${LABEL_FILL5}">95</text>`;
 }
 function scaleSwatch(x, y) {
-  return `<line x1="${round9(x)}" y1="${y}" x2="${round9(x + LEGEND_SWATCH_W)}" y2="${y}" stroke="${EDGE_INK6}" stroke-width="1.5" stroke-opacity="0.75"/>`;
+  return `<line x1="${round11(x)}" y1="${y}" x2="${round11(x + LEGEND_SWATCH_W)}" y2="${y}" stroke="${EDGE_INK6}" stroke-width="1.5" stroke-opacity="0.75"/>`;
 }
 function alignedTipSwatch(x, y) {
-  return `<line x1="${round9(x)}" y1="${y}" x2="${round9(x + LEGEND_SWATCH_W)}" y2="${y}" stroke="${EDGE_INK6}" stroke-width="1.5" stroke-opacity="0.5" stroke-dasharray="2,3"/>`;
+  return `<line x1="${round11(x)}" y1="${y}" x2="${round11(x + LEGEND_SWATCH_W)}" y2="${y}" stroke="${EDGE_INK6}" stroke-width="1.5" stroke-opacity="0.5" stroke-dasharray="2,3"/>`;
 }
 function phyloLayoutSvg(layout, opts = {}) {
   const labels = opts.labels ?? PHYLO_SVG_LABELS_EN;
@@ -4024,9 +4225,9 @@ function orgChartIssues(input) {
   }
   const reportById = /* @__PURE__ */ new Map();
   const dupReportIds = /* @__PURE__ */ new Set();
-  for (const r of input.reports) {
-    if (reportById.has(r.id)) dupReportIds.add(r.id);
-    else reportById.set(r.id, r);
+  for (const r2 of input.reports) {
+    if (reportById.has(r2.id)) dupReportIds.add(r2.id);
+    else reportById.set(r2.id, r2);
   }
   for (const id of [...dupReportIds].sort((a, b) => a - b)) {
     push("duplicate-id", `duplicate report id ${id}`);
@@ -4039,32 +4240,32 @@ function orgChartIssues(input) {
   const assistantReportEdge = /* @__PURE__ */ new Map();
   const solidManagedEdges = /* @__PURE__ */ new Map();
   const dottedDegree = /* @__PURE__ */ new Map();
-  for (const r of reports) {
-    const hasManager = positionById.has(r.managerId);
-    const hasReport = positionById.has(r.reportId);
+  for (const r2 of reports) {
+    const hasManager = positionById.has(r2.managerId);
+    const hasReport = positionById.has(r2.reportId);
     if (!hasManager) {
-      push("unknown-manager", `report ${r.id} managerId ${r.managerId} is not a declared position`);
+      push("unknown-manager", `report ${r2.id} managerId ${r2.managerId} is not a declared position`);
     }
     if (!hasReport) {
-      push("unknown-report", `report ${r.id} reportId ${r.reportId} is not a declared position`);
+      push("unknown-report", `report ${r2.id} reportId ${r2.reportId} is not a declared position`);
     }
-    if (r.managerId === r.reportId) {
-      push("self-report", `report ${r.id} has managerId === reportId (${r.managerId})`);
+    if (r2.managerId === r2.reportId) {
+      push("self-report", `report ${r2.id} has managerId === reportId (${r2.managerId})`);
     }
-    if (r.kind !== "dotted") {
-      const arr = solidParents.get(r.reportId) ?? [];
-      arr.push(r.id);
-      solidParents.set(r.reportId, arr);
-      const managed = solidManagedEdges.get(r.managerId) ?? [];
-      managed.push(r.id);
-      solidManagedEdges.set(r.managerId, managed);
+    if (r2.kind !== "dotted") {
+      const arr = solidParents.get(r2.reportId) ?? [];
+      arr.push(r2.id);
+      solidParents.set(r2.reportId, arr);
+      const managed = solidManagedEdges.get(r2.managerId) ?? [];
+      managed.push(r2.id);
+      solidManagedEdges.set(r2.managerId, managed);
     }
-    if (r.kind === "assistant" && r.managerId !== r.reportId && !assistantReportEdge.has(r.reportId)) {
-      assistantReportEdge.set(r.reportId, r.id);
+    if (r2.kind === "assistant" && r2.managerId !== r2.reportId && !assistantReportEdge.has(r2.reportId)) {
+      assistantReportEdge.set(r2.reportId, r2.id);
     }
-    if (r.kind === "dotted" && r.managerId !== r.reportId) {
-      if (positionById.has(r.managerId)) dottedDegree.set(r.managerId, (dottedDegree.get(r.managerId) ?? 0) + 1);
-      if (positionById.has(r.reportId)) dottedDegree.set(r.reportId, (dottedDegree.get(r.reportId) ?? 0) + 1);
+    if (r2.kind === "dotted" && r2.managerId !== r2.reportId) {
+      if (positionById.has(r2.managerId)) dottedDegree.set(r2.managerId, (dottedDegree.get(r2.managerId) ?? 0) + 1);
+      if (positionById.has(r2.reportId)) dottedDegree.set(r2.reportId, (dottedDegree.get(r2.reportId) ?? 0) + 1);
     }
   }
   for (const [reportId, edgeIds] of [...solidParents.entries()].sort((a, b) => a[0] - b[0])) {
@@ -4095,12 +4296,12 @@ function orgChartIssues(input) {
   }
   if (!issues.some((i) => GRAPH_BLOCKING.has(i.code))) {
     const solidChildren = /* @__PURE__ */ new Map();
-    for (const r of reports) {
-      if (r.kind === "dotted") continue;
-      if (r.managerId === r.reportId) continue;
-      const arr = solidChildren.get(r.managerId) ?? [];
-      arr.push(r.reportId);
-      solidChildren.set(r.managerId, arr);
+    for (const r2 of reports) {
+      if (r2.kind === "dotted") continue;
+      if (r2.managerId === r2.reportId) continue;
+      const arr = solidChildren.get(r2.managerId) ?? [];
+      arr.push(r2.reportId);
+      solidChildren.set(r2.managerId, arr);
     }
     for (const arr of solidChildren.values()) arr.sort((a, b) => a - b);
     const color = /* @__PURE__ */ new Map();
@@ -4167,26 +4368,9 @@ var ORG_BUS_ID_BASE = 2e6;
 var ORG_DROP_ID_BASE = 3e6;
 var ORG_ASSIST_ID_BASE = 4e6;
 var ORG_DOTTED_ID_BASE = 5e6;
-var round10 = (n) => Math.round(n * 100) / 100;
-var drawnLeftEdge = (cx, boxW) => round10(round10(cx) - round10(boxW) / 2);
-var drawnRightEdge = (cx, boxW) => drawnLeftEdge(cx, boxW) + round10(boxW);
-function packSubtree(node, gaps) {
-  const { ownHalfL, ownHalfR, children } = node;
-  if (children.length === 0) {
-    return { halfL: ownHalfL, halfR: ownHalfR, offsets: [] };
-  }
-  const xs = [0];
-  for (let i = 1; i < children.length; i++) {
-    xs.push(xs[i - 1] + children[i - 1].halfR + gaps.siblingGap + children[i].halfL);
-  }
-  const first = children[0];
-  const last = children[children.length - 1];
-  const axis = (xs[0] + xs[xs.length - 1]) / 2;
-  const offsets = xs.map((x) => x - axis);
-  const halfL = Math.max(ownHalfL, axis - (xs[0] - first.halfL));
-  const halfR = Math.max(ownHalfR, xs[xs.length - 1] + last.halfR - axis);
-  return { halfL, halfR, offsets };
-}
+var round12 = (n) => Math.round(n * 100) / 100;
+var drawnLeftEdge = (cx, boxW) => round12(round12(cx) - round12(boxW) / 2);
+var drawnRightEdge = (cx, boxW) => drawnLeftEdge(cx, boxW) + round12(boxW);
 function measurePosition(position, maxLabelChars, vacantWord) {
   const nameLines = position.name === "" ? [] : wrapLabelBalanced(clampLabel(position.name, maxLabelChars), 2);
   const titleLines = position.title === null ? [] : wrapLabelBalanced(clampLabel(position.title, maxLabelChars), 2);
@@ -4219,16 +4403,16 @@ function computeOrgChartLayout(input, opts = {}) {
   const vacantWord = titleLabels.vacant;
   const positionById = new Map(input.positions.map((p) => [p.id, p]));
   const reports = [...input.reports].sort((a, b) => a.id - b.id);
-  const solidReports = reports.filter((r) => r.kind !== "dotted");
+  const solidReports = reports.filter((r2) => r2.kind !== "dotted");
   const lineChildIds = /* @__PURE__ */ new Map();
   const assistChildIds = /* @__PURE__ */ new Map();
   const solidParentReportId = /* @__PURE__ */ new Set();
-  for (const r of solidReports) {
-    solidParentReportId.add(r.reportId);
-    const bucket = r.kind === "assistant" ? assistChildIds : lineChildIds;
-    const arr = bucket.get(r.managerId) ?? [];
-    arr.push(r);
-    bucket.set(r.managerId, arr);
+  for (const r2 of solidReports) {
+    solidParentReportId.add(r2.reportId);
+    const bucket = r2.kind === "assistant" ? assistChildIds : lineChildIds;
+    const arr = bucket.get(r2.managerId) ?? [];
+    arr.push(r2);
+    bucket.set(r2.managerId, arr);
   }
   for (const arr of lineChildIds.values()) arr.sort((a, b) => a.reportId - b.reportId);
   for (const arr of assistChildIds.values()) arr.sort((a, b) => a.reportId - b.reportId);
@@ -4258,12 +4442,12 @@ function computeOrgChartLayout(input, opts = {}) {
     const position = positionById.get(positionId);
     const inst = newInst(position, depth, assistReport);
     allInsts.push(inst);
-    for (const r of assistChildIds.get(positionId) ?? []) {
-      const a = build(r.reportId, depth + 1, r);
-      inst.assistants.push({ inst: a, report: r });
+    for (const r2 of assistChildIds.get(positionId) ?? []) {
+      const a = build(r2.reportId, depth + 1, r2);
+      inst.assistants.push({ inst: a, report: r2 });
     }
-    for (const r of lineChildIds.get(positionId) ?? []) {
-      inst.lineChildren.push(build(r.reportId, depth + 1, null));
+    for (const r2 of lineChildIds.get(positionId) ?? []) {
+      inst.lineChildren.push(build(r2.reportId, depth + 1, null));
     }
     return inst;
   };
@@ -4337,10 +4521,10 @@ function computeOrgChartLayout(input, opts = {}) {
   const pushNode = (inst) => {
     nodes.push({
       positionId: inst.position.id,
-      cx: round10(inst.cx),
-      top: round10(rowTop[inst.depth]),
-      boxW: round10(inst.m.boxW),
-      boxH: round10(inst.m.boxH),
+      cx: round12(inst.cx),
+      top: round12(rowTop[inst.depth]),
+      boxW: round12(inst.m.boxW),
+      boxH: round12(inst.m.boxH),
       style: inst.style,
       nameLines: inst.m.nameLines,
       titleLines: inst.m.titleLines,
@@ -4363,10 +4547,10 @@ function computeOrgChartLayout(input, opts = {}) {
       const assistMidY = assistTop + a.m.boxH / 2;
       nodes.push({
         positionId: a.position.id,
-        cx: round10(a.cx),
-        top: round10(assistTop),
-        boxW: round10(a.m.boxW),
-        boxH: round10(a.m.boxH),
+        cx: round12(a.cx),
+        top: round12(assistTop),
+        boxW: round12(a.m.boxW),
+        boxH: round12(a.m.boxH),
         style: a.style,
         nameLines: a.m.nameLines,
         titleLines: a.m.titleLines,
@@ -4381,8 +4565,8 @@ function computeOrgChartLayout(input, opts = {}) {
         edgeId: ORG_ASSIST_ID_BASE + report.reportId,
         kind: "assist",
         points: [
-          { x: round10(inst.cx), y: round10(assistMidY) },
-          { x: drawnRightEdge(a.cx, a.m.boxW), y: round10(assistMidY) }
+          { x: round12(inst.cx), y: round12(assistMidY) },
+          { x: drawnRightEdge(a.cx, a.m.boxW), y: round12(assistMidY) }
         ],
         dashed: false,
         title: reportTitle("assistant", report.label),
@@ -4398,8 +4582,8 @@ function computeOrgChartLayout(input, opts = {}) {
       edgeId: ORG_STEM_ID_BASE + inst.position.id,
       kind: "stem",
       points: [
-        { x: round10(inst.cx), y: round10(boxBottom) },
-        { x: round10(inst.cx), y: round10(by) }
+        { x: round12(inst.cx), y: round12(boxBottom) },
+        { x: round12(inst.cx), y: round12(by) }
       ],
       dashed: false,
       title: reportTitle("line", null),
@@ -4411,8 +4595,8 @@ function computeOrgChartLayout(input, opts = {}) {
         edgeId: ORG_BUS_ID_BASE + inst.position.id,
         kind: "bus",
         points: [
-          { x: round10(Math.min(...childCxs)), y: round10(by) },
-          { x: round10(Math.max(...childCxs)), y: round10(by) }
+          { x: round12(Math.min(...childCxs)), y: round12(by) },
+          { x: round12(Math.max(...childCxs)), y: round12(by) }
         ],
         dashed: false,
         title: reportTitle("line", null),
@@ -4420,15 +4604,15 @@ function computeOrgChartLayout(input, opts = {}) {
       });
     }
     const lineReports = lineChildIds.get(inst.position.id) ?? [];
-    const lineReportByChildId = new Map(lineReports.map((r) => [r.reportId, r]));
+    const lineReportByChildId = new Map(lineReports.map((r2) => [r2.reportId, r2]));
     for (const c of inst.lineChildren) {
       const lineReport = lineReportByChildId.get(c.position.id);
       elements.push({
         edgeId: ORG_DROP_ID_BASE + c.position.id,
         kind: "drop",
         points: [
-          { x: round10(c.cx), y: round10(by) },
-          { x: round10(c.cx), y: round10(rowTop[c.depth]) }
+          { x: round12(c.cx), y: round12(by) },
+          { x: round12(c.cx), y: round12(rowTop[c.depth]) }
         ],
         dashed: false,
         title: reportTitle("line", null),
@@ -4466,7 +4650,7 @@ function computeOrgChartLayout(input, opts = {}) {
   }
   const nodeById = new Map(nodes.map((n) => [n.positionId, n]));
   const dottedReports = reports.filter(
-    (r) => r.kind === "dotted" && nodeById.has(r.managerId) && nodeById.has(r.reportId) && r.managerId !== r.reportId
+    (r2) => r2.kind === "dotted" && nodeById.has(r2.managerId) && nodeById.has(r2.reportId) && r2.managerId !== r2.reportId
   );
   let maxBoxBottom = PADDING7;
   for (const n of nodes) maxBoxBottom = Math.max(maxBoxBottom, n.top + n.boxH);
@@ -4474,14 +4658,14 @@ function computeOrgChartLayout(input, opts = {}) {
   let channelLanes = 0;
   if (dottedReports.length > 0) {
     const laneOf = /* @__PURE__ */ new Map();
-    laneCount = allocateLanes2(
-      dottedReports.map((r) => {
-        const rep = escapeByPos.get(r.reportId);
-        const mgr = escapeByPos.get(r.managerId);
+    laneCount = allocateLanes(
+      dottedReports.map((r2) => {
+        const rep = escapeByPos.get(r2.reportId);
+        const mgr = escapeByPos.get(r2.managerId);
         return {
           lo: Math.min(rep.midY, mgr.midY),
           hi: Math.max(rep.midY, mgr.midY),
-          set: (lane) => laneOf.set(r.id, lane)
+          set: (lane) => laneOf.set(r2.id, lane)
         };
       })
     );
@@ -4496,19 +4680,19 @@ function computeOrgChartLayout(input, opts = {}) {
       const sign = slot % 2 === 1 ? -1 : 1;
       return mid + sign * Math.ceil(slot / 2) * step;
     };
-    const geoms = dottedReports.map((r, i) => {
-      const rep = escapeByPos.get(r.reportId);
-      const mgr = escapeByPos.get(r.managerId);
+    const geoms = dottedReports.map((r2, i) => {
+      const rep = escapeByPos.get(r2.reportId);
+      const mgr = escapeByPos.get(r2.managerId);
       return {
-        r,
+        r: r2,
         i,
-        repMidY: round10(nextExitY(r.reportId, rep.midY, rep.boxH)),
-        mgrMidY: round10(nextExitY(r.managerId, mgr.midY, mgr.boxH)),
-        repBoxEdge: round10(rep.boxEdge),
-        mgrBoxEdge: round10(mgr.boxEdge),
-        repChY: round10(channelTop + 2 * i * ORG_MATRIX_LANE_PITCH),
-        mgrChY: round10(channelTop + (2 * i + 1) * ORG_MATRIX_LANE_PITCH),
-        laneX: round10(canvasRight + ORG_MATRIX_GUTTER_GAP + laneOf.get(r.id) * ORG_MATRIX_LANE_PITCH),
+        repMidY: round12(nextExitY(r2.reportId, rep.midY, rep.boxH)),
+        mgrMidY: round12(nextExitY(r2.managerId, mgr.midY, mgr.boxH)),
+        repBoxEdge: round12(rep.boxEdge),
+        mgrBoxEdge: round12(mgr.boxEdge),
+        repChY: round12(channelTop + 2 * i * ORG_MATRIX_LANE_PITCH),
+        mgrChY: round12(channelTop + (2 * i + 1) * ORG_MATRIX_LANE_PITCH),
+        laneX: round12(canvasRight + ORG_MATRIX_GUTTER_GAP + laneOf.get(r2.id) * ORG_MATRIX_LANE_PITCH),
         repEscX: 0,
         mgrEscX: 0
       };
@@ -4546,14 +4730,14 @@ function computeOrgChartLayout(input, opts = {}) {
         else if (v.side === -1 && bRight < v.escCol - VERT_EPS) band = Math.min(band, v.escCol - bRight);
       }
       let lane = 0;
-      let candidate = round10(v.escCol);
+      let candidate = round12(v.escCol);
       while (placed.some((p) => Math.abs(p.x - candidate) < VERT_EPS && yOverlap(p.lo, p.hi, v.lo, v.hi))) {
         lane += 1;
-        candidate = round10(v.escCol + v.side * lane * ORG_MATRIX_ESCAPE_STEP);
+        candidate = round12(v.escCol + v.side * lane * ORG_MATRIX_ESCAPE_STEP);
       }
       if (lane > 0 && lane * ORG_MATRIX_ESCAPE_STEP >= band - VERT_EPS) {
         throw new Error(
-          `org-chart: escape-column-overflow \u2014 escape vertical nudged ${lane * ORG_MATRIX_ESCAPE_STEP}px from its base column exceeds the ${round10(band)}px box-free band`
+          `org-chart: escape-column-overflow \u2014 escape vertical nudged ${lane * ORG_MATRIX_ESCAPE_STEP}px from its base column exceeds the ${round12(band)}px box-free band`
         );
       }
       placed.push({ x: candidate, lo: v.lo, hi: v.hi });
@@ -4599,25 +4783,6 @@ function collapseDegenerate(points) {
   }
   return out;
 }
-function allocateLanes2(items) {
-  const lanes = [];
-  for (const it of items) {
-    let chosen = -1;
-    for (let l = 0; l < lanes.length; l++) {
-      if (lanes[l].every((o) => it.hi <= o.lo || it.lo >= o.hi)) {
-        chosen = l;
-        break;
-      }
-    }
-    if (chosen === -1) {
-      chosen = lanes.length;
-      lanes.push([]);
-    }
-    lanes[chosen].push({ lo: it.lo, hi: it.hi });
-    it.set(chosen);
-  }
-  return lanes.length;
-}
 
 // src/org-chart/svg.ts
 var GLYPH_STROKE5 = "#52525b";
@@ -4626,25 +4791,25 @@ var EDGE_INK7 = "#71717a";
 var GLYPH_ATTRS3 = `fill="transparent" stroke="${GLYPH_STROKE5}" stroke-width="2"`;
 var VACANT_DASH = `stroke-dasharray="6,4"`;
 var DOTTED = EDGE_STROKE.distant;
-var round11 = (n) => Math.round(n * 100) / 100;
+var round13 = (n) => Math.round(n * 100) / 100;
 var ORG_BOX_PAD_Y2 = 9;
 function boxSvg(n) {
-  const left = round11(n.cx - n.boxW / 2);
+  const left = round13(n.cx - n.boxW / 2);
   const pieces = [`<title>${xmlEscape(n.title)}</title>`];
   if (n.style === "dashed") {
     pieces.push(
       `<rect x="${left}" y="${n.top}" width="${n.boxW}" height="${n.boxH}" rx="2" ${GLYPH_ATTRS3} ${VACANT_DASH}/>`
     );
-    const ix = round11(left + 3);
-    const iy = round11(n.top + 3);
-    const iw = round11(n.boxW - 6);
-    const ih = round11(n.boxH - 6);
+    const ix = round13(left + 3);
+    const iy = round13(n.top + 3);
+    const iw = round13(n.boxW - 6);
+    const ih = round13(n.boxH - 6);
     pieces.push(`<rect x="${ix}" y="${iy}" width="${iw}" height="${ih}" rx="2" ${GLYPH_ATTRS3} ${VACANT_DASH}/>`);
   } else {
     pieces.push(`<rect x="${left}" y="${n.top}" width="${n.boxW}" height="${n.boxH}" rx="2" ${GLYPH_ATTRS3}/>`);
   }
   let lineIndex = 0;
-  const firstBaseline = (i) => round11(n.top + ORG_BOX_PAD_Y2 + ORG_LABEL_LINE_H / 2 + i * ORG_LABEL_LINE_H + ORG_LABEL_FONT * 0.32);
+  const firstBaseline = (i) => round13(n.top + ORG_BOX_PAD_Y2 + ORG_LABEL_LINE_H / 2 + i * ORG_LABEL_LINE_H + ORG_LABEL_FONT * 0.32);
   const textBlock = (lines, font) => {
     if (lines.length === 0) return "";
     const tspans = lines.map((line, i) => `<tspan x="${n.cx}" y="${firstBaseline(lineIndex + i)}">${xmlEscape(line)}</tspan>`).join("");
@@ -4655,7 +4820,7 @@ function boxSvg(n) {
   pieces.push(textBlock(n.titleLines, ORG_TITLE_FONT));
   pieces.push(textBlock(n.subtitleLines, ORG_TITLE_FONT));
   if (n.vacantMarker !== null) pieces.push(textBlock([n.vacantMarker], ORG_TITLE_FONT));
-  if (n.annotated) pieces.push(annotationDot(round11(n.cx + n.boxW / 2) - 4, n.top + 4));
+  if (n.annotated) pieces.push(annotationDot(round13(n.cx + n.boxW / 2) - 4, n.top + 4));
   return `<g data-node-id="p${n.positionId}">${pieces.filter((p) => p !== "").join("")}</g>`;
 }
 function elementSvg5(el) {
@@ -4674,26 +4839,26 @@ function elementSvg5(el) {
 }
 var MINI_ATTRS3 = `fill="transparent" stroke="${GLYPH_STROKE5}" stroke-width="1.5"`;
 function lineSwatch(x, y) {
-  const x1 = round11(x + 2);
-  const x2 = round11(x + LEGEND_SWATCH_W - 2);
+  const x1 = round13(x + 2);
+  const x2 = round13(x + LEGEND_SWATCH_W - 2);
   return `<line x1="${x1}" y1="${y}" x2="${x2}" y2="${y}" stroke="${EDGE_INK7}" stroke-width="1.5" stroke-opacity="0.75"/>`;
 }
 function assistantSwatch(x, y) {
-  const stemX = round11(x + LEGEND_SWATCH_W - 4);
-  const boxX = round11(x + 1);
-  return `<line x1="${stemX}" y1="${round11(y - 4)}" x2="${stemX}" y2="${y}" stroke="${EDGE_INK7}" stroke-width="1.5" stroke-opacity="0.75"/><line x1="${stemX}" y1="${y}" x2="${round11(boxX + 8)}" y2="${y}" stroke="${EDGE_INK7}" stroke-width="1.5" stroke-opacity="0.75"/><rect x="${boxX}" y="${round11(y - 3.5)}" width="8" height="7" rx="1" ${MINI_ATTRS3}/>`;
+  const stemX = round13(x + LEGEND_SWATCH_W - 4);
+  const boxX = round13(x + 1);
+  return `<line x1="${stemX}" y1="${round13(y - 4)}" x2="${stemX}" y2="${y}" stroke="${EDGE_INK7}" stroke-width="1.5" stroke-opacity="0.75"/><line x1="${stemX}" y1="${y}" x2="${round13(boxX + 8)}" y2="${y}" stroke="${EDGE_INK7}" stroke-width="1.5" stroke-opacity="0.75"/><rect x="${boxX}" y="${round13(y - 3.5)}" width="8" height="7" rx="1" ${MINI_ATTRS3}/>`;
 }
 function dottedSwatch(x, y) {
-  const x1 = round11(x + 2);
-  const x2 = round11(x + LEGEND_SWATCH_W - 2);
+  const x1 = round13(x + 2);
+  const x2 = round13(x + LEGEND_SWATCH_W - 2);
   const dash = DOTTED.dash === null ? "" : ` stroke-dasharray="${DOTTED.dash[0]},${DOTTED.dash[1]}"`;
   return `<line x1="${x1}" y1="${y}" x2="${x2}" y2="${y}" stroke="${EDGE_INK7}" stroke-width="${DOTTED.width}" stroke-opacity="${DOTTED.opacity}"${dash}/>`;
 }
 function vacantSwatch(x, y) {
-  const cx = round11(x + LEGEND_SWATCH_W / 2);
-  const bx = round11(cx - 8);
-  const by = round11(y - 5);
-  return `<rect x="${bx}" y="${by}" width="16" height="10" rx="1" ${MINI_ATTRS3} stroke-dasharray="3,2"/><rect x="${round11(bx + 2)}" y="${round11(by + 2)}" width="12" height="6" rx="1" ${MINI_ATTRS3} stroke-dasharray="3,2"/>`;
+  const cx = round13(x + LEGEND_SWATCH_W / 2);
+  const bx = round13(cx - 8);
+  const by = round13(y - 5);
+  return `<rect x="${bx}" y="${by}" width="16" height="10" rx="1" ${MINI_ATTRS3} stroke-dasharray="3,2"/><rect x="${round13(bx + 2)}" y="${round13(by + 2)}" width="12" height="6" rx="1" ${MINI_ATTRS3} stroke-dasharray="3,2"/>`;
 }
 function orgChartLayoutSvg(layout, opts = {}) {
   const labels = opts.labels ?? ORG_CHART_SVG_LABELS_EN;
@@ -4741,6 +4906,1654 @@ function orgChartSvg(input, opts = {}) {
   return { svg, layout };
 }
 
+// src/prisma/types.ts
+var PRISMA_PHASES = ["identification", "screening", "included"];
+var PRISMA_BOX_KINDS = ["flow", "exclusion"];
+var PRISMA_COLUMNS = ["main", "new", "previous"];
+
+// src/prisma/validate.ts
+var PrismaValidationError = class extends Error {
+  issues;
+  constructor(issues) {
+    super(`invalid PRISMA diagram: ${issues.map((i) => i.message).join("; ")}`);
+    this.name = "PrismaValidationError";
+    this.issues = issues;
+  }
+};
+function sortIssues5(issues) {
+  const unique = /* @__PURE__ */ new Map();
+  for (const issue of issues) unique.set(`${issue.code} ${issue.message}`, issue);
+  return [...unique.values()].sort(
+    (a, b) => a.code !== b.code ? a.code < b.code ? -1 : 1 : a.message < b.message ? -1 : a.message > b.message ? 1 : 0
+  );
+}
+function prismaIssues(input) {
+  if (input.boxes.length === 0 && input.arrows.length === 0) return [];
+  const issues = [];
+  const push = (code, message) => {
+    issues.push({ code, message });
+  };
+  const boxById = /* @__PURE__ */ new Map();
+  const dupBoxIds = /* @__PURE__ */ new Set();
+  for (const b of input.boxes) {
+    if (boxById.has(b.id)) dupBoxIds.add(b.id);
+    else boxById.set(b.id, b);
+  }
+  for (const id of [...dupBoxIds].sort((a, b) => a - b)) {
+    push("duplicate-id", `duplicate box id ${id}`);
+  }
+  const arrowById = /* @__PURE__ */ new Map();
+  const dupArrowIds = /* @__PURE__ */ new Set();
+  for (const a of input.arrows) {
+    if (arrowById.has(a.id)) dupArrowIds.add(a.id);
+    else arrowById.set(a.id, a);
+  }
+  for (const id of [...dupArrowIds].sort((a, b) => a - b)) {
+    push("duplicate-id", `duplicate arrow id ${id}`);
+  }
+  if (issues.length > 0) return sortIssues5(issues);
+  for (const arrow of [...arrowById.values()].sort((a, b) => a.id - b.id)) {
+    if (!boxById.has(arrow.fromId)) {
+      push("unknown-arrow-endpoint", `arrow ${arrow.id} fromId ${arrow.fromId} is not a declared box`);
+    }
+    if (!boxById.has(arrow.toId)) {
+      push("unknown-arrow-endpoint", `arrow ${arrow.id} toId ${arrow.toId} is not a declared box`);
+    }
+    if (arrow.fromId === arrow.toId) {
+      push("self-arrow", `arrow ${arrow.id} has fromId === toId (${arrow.fromId})`);
+    }
+  }
+  for (const box of [...boxById.values()].sort((a, b) => a.id - b.id)) {
+    for (const count of box.counts) {
+      if (count.n !== null && !Number.isFinite(count.n)) {
+        push("non-finite-count", `box ${box.id} count "${count.label}" has non-finite n: ${String(count.n)}`);
+      }
+    }
+  }
+  if (input.variant !== "flow-with-prior") {
+    for (const box of [...boxById.values()].sort((a, b) => a.id - b.id)) {
+      if (box.column === "previous") {
+        push(
+          "invalid-variant-column",
+          `box ${box.id} has column "previous" but variant is "${input.variant}"`
+        );
+      }
+    }
+  }
+  const GRAPH_BLOCKING3 = /* @__PURE__ */ new Set([
+    "duplicate-id",
+    "unknown-arrow-endpoint"
+  ]);
+  if (!issues.some((i) => GRAPH_BLOCKING3.has(i.code))) {
+    const phaseIndex = /* @__PURE__ */ new Map();
+    for (let i = 0; i < PRISMA_PHASES.length; i++) phaseIndex.set(PRISMA_PHASES[i], i);
+    for (const arrow of [...arrowById.values()].sort((a, b) => a.id - b.id)) {
+      const fromBox = boxById.get(arrow.fromId);
+      const toBox = boxById.get(arrow.toId);
+      const fromPhaseIdx = phaseIndex.get(fromBox.phase);
+      const toPhaseIdx = phaseIndex.get(toBox.phase);
+      if (fromBox.kind === "flow" && toBox.kind === "exclusion" && fromBox.phase === toBox.phase) {
+        continue;
+      }
+      if (toPhaseIdx < fromPhaseIdx) {
+        push(
+          "arrow-skips-backward",
+          `arrow ${arrow.id} goes backward: from phase "${fromBox.phase}" to "${toBox.phase}"`
+        );
+      }
+    }
+  }
+  return sortIssues5(issues);
+}
+function validatePrisma(input) {
+  const issues = prismaIssues(input);
+  if (issues.length > 0) throw new PrismaValidationError(issues);
+}
+
+// src/prisma/labels.ts
+var PRISMA_TITLE_LABELS_EN = {
+  phases: {
+    identification: "Identification",
+    screening: "Screening",
+    included: "Included"
+  },
+  nullCount: "n = \u2014",
+  arrowKinds: {
+    flow: "Flow",
+    exclusion: "Exclusion",
+    merge: "Merge"
+  }
+};
+var PRISMA_SVG_LABELS_EN = {
+  legend: {
+    flow: "Main flow",
+    exclusion: "Excluded"
+  },
+  ariaLabel: "PRISMA 2020 flow diagram"
+};
+
+// src/prisma/layout.ts
+var PRISMA_PADDING = 32;
+var PRISMA_BAND_LABEL_W = 40;
+var PRISMA_COL_GAP = 56;
+var PRISMA_CORRIDOR = 30;
+var PRISMA_BOX_PAD_X = 12;
+var PRISMA_BOX_PAD_Y = 10;
+var PRISMA_LINE_H = 14;
+var PRISMA_MIN_BOX_W = 200;
+var PRISMA_EXCL_GAP = 48;
+var PRISMA_HEADING_FONT = 12;
+var PRISMA_COUNT_FONT = 10;
+var PRISMA_ROUTE_MARGIN = 10;
+var PRISMA_ROUTE_PITCH = 10;
+var PRISMA_FLOW_ARROW_BASE = 1e6;
+var PRISMA_EXCL_ARROW_BASE = 2e6;
+var PRISMA_MERGE_ARROW_BASE = 3e6;
+function round14(n) {
+  return Math.round(n * 100) / 100;
+}
+function wrapHeading(h) {
+  if (h === null || h === "") return [];
+  return wrapLabelBalanced(h);
+}
+function countLine(label, n, nullToken) {
+  const nStr = n === null ? nullToken : String(n);
+  return `${label}: n = ${nStr}`;
+}
+function buildCountLines(counts, nullToken) {
+  return counts.map((c) => countLine(c.label, c.n, nullToken));
+}
+function boxTitle(box, nullToken) {
+  if (box.title !== void 0) return box.title;
+  const parts = [];
+  if (box.heading !== null && box.heading !== "") parts.push(box.heading);
+  for (const c of box.counts) parts.push(countLine(c.label, c.n, nullToken));
+  return parts.join("; ") || "(box)";
+}
+function computePrismaLayout(input, opts = {}) {
+  if (opts.validate !== false) validatePrisma(input);
+  const labels = opts.labels ?? PRISMA_TITLE_LABELS_EN;
+  const nullToken = labels.nullCount;
+  const COMP_OPTS = {
+    padX: PRISMA_BOX_PAD_X,
+    padY: PRISMA_BOX_PAD_Y,
+    lineH: PRISMA_LINE_H,
+    minW: PRISMA_MIN_BOX_W};
+  const boxMetrics = /* @__PURE__ */ new Map();
+  for (const b of input.boxes) {
+    const headingLines = wrapHeading(b.heading);
+    const cLines = buildCountLines(b.counts, nullToken);
+    const metrics = measureCompartmentBox(
+      [
+        { lines: headingLines, font: PRISMA_HEADING_FONT },
+        { lines: cLines, font: PRISMA_COUNT_FONT }
+      ],
+      COMP_OPTS
+    );
+    boxMetrics.set(b.id, {
+      boxW: metrics.boxW,
+      boxH: metrics.boxH,
+      rows: metrics.rows,
+      dividerYs: metrics.dividerYs,
+      headingLines,
+      countLines: cLines
+    });
+  }
+  const boxesByKey = /* @__PURE__ */ new Map();
+  for (const b of input.boxes) {
+    const key = `${b.phase}:${b.column}:${b.kind}`;
+    const arr = boxesByKey.get(key) ?? [];
+    arr.push(b);
+    boxesByKey.set(key, arr);
+  }
+  for (const arr of boxesByKey.values()) {
+    arr.sort((a, b) => a.rank !== b.rank ? a.rank - b.rank : a.id - b.id);
+  }
+  const groupOf = (phase, col, kind) => boxesByKey.get(`${phase}:${col}:${kind}`) ?? [];
+  const flowCols = input.variant === "flow-with-prior" ? ["new", "previous"] : input.variant === "flow-other-methods" ? ["main", "new"] : ["main"];
+  const contentLeft = PRISMA_PADDING + PRISMA_BAND_LABEL_W;
+  function maxColW(col, kind) {
+    let w = 0;
+    for (const phase of PRISMA_PHASES) {
+      for (const b of groupOf(phase, col, kind)) {
+        const bw = boxMetrics.get(b.id).boxW;
+        if (bw > w) w = bw;
+      }
+    }
+    return w;
+  }
+  const colHasFlow = (col) => PRISMA_PHASES.some((phase) => groupOf(phase, col, "flow").length > 0);
+  const colHasExcl = (col) => PRISMA_PHASES.some((phase) => groupOf(phase, col, "exclusion").length > 0);
+  const exclOnlyCols = ["main", "new", "previous"].filter(
+    (col) => !flowCols.includes(col) && colHasExcl(col)
+  );
+  const placedCols = [...flowCols, ...exclOnlyCols];
+  const colGeom = /* @__PURE__ */ new Map();
+  for (const col of placedCols) {
+    const flowW = colHasFlow(col) ? Math.max(PRISMA_MIN_BOX_W, maxColW(col, "flow")) : 0;
+    const exclW = maxColW(col, "exclusion");
+    const blockW = flowW > 0 && exclW > 0 ? flowW + PRISMA_EXCL_GAP + exclW : flowW > 0 ? flowW : exclW;
+    colGeom.set(col, { flowW, exclW, blockW, flowCx: 0, exclCx: 0 });
+  }
+  function placeBlock(col, blockLeft) {
+    const g = colGeom.get(col);
+    if (g.flowW > 0) g.flowCx = round14(blockLeft + g.flowW / 2);
+    if (g.exclW > 0) {
+      const exclLeft = g.flowW > 0 ? blockLeft + g.flowW + PRISMA_EXCL_GAP : blockLeft;
+      g.exclCx = round14(exclLeft + g.exclW / 2);
+    }
+  }
+  if (placedCols.length === 1) {
+    placeBlock(placedCols[0], contentLeft);
+  } else {
+    const packed = packSubtree(
+      {
+        ownHalfL: 0,
+        ownHalfR: 0,
+        children: placedCols.map((col) => {
+          const half = colGeom.get(col).blockW / 2;
+          return { halfL: half, halfR: half };
+        })
+      },
+      { siblingGap: PRISMA_COL_GAP }
+    );
+    const totalW = packed.halfL + packed.halfR;
+    const blockCx = round14(contentLeft + totalW / 2);
+    placedCols.forEach((col, i) => {
+      const w = colGeom.get(col).blockW;
+      placeBlock(col, round14(blockCx + packed.offsets[i] - w / 2));
+    });
+  }
+  let totalRight = contentLeft;
+  for (const col of placedCols) {
+    const g = colGeom.get(col);
+    const r2 = g.exclW > 0 ? round14(g.exclCx + g.exclW / 2) : round14(g.flowCx + g.flowW / 2);
+    if (r2 > totalRight) totalRight = r2;
+  }
+  const rowsByCol = /* @__PURE__ */ new Map();
+  const rowsKey = (phase, col) => `${phase}:${col}`;
+  function buildRankRows(phase, col) {
+    const byRank = /* @__PURE__ */ new Map();
+    for (const kind of ["flow", "exclusion"]) {
+      for (const b of groupOf(phase, col, kind)) {
+        const h = boxMetrics.get(b.id).boxH;
+        const prev = byRank.get(b.rank) ?? 0;
+        if (h > prev) byRank.set(b.rank, h);
+      }
+    }
+    const ranks = [...byRank.keys()].sort((a, b) => a - b);
+    return ranks.map((rank) => ({ rank, rowH: byRank.get(rank), top: 0 }));
+  }
+  for (const phase of PRISMA_PHASES) {
+    for (const col of placedCols) {
+      rowsByCol.set(rowsKey(phase, col), buildRankRows(phase, col));
+    }
+  }
+  function colStackH(rows) {
+    if (rows.length === 0) return 0;
+    let h = 0;
+    for (const r2 of rows) h += r2.rowH + PRISMA_BOX_PAD_Y;
+    return h - PRISMA_BOX_PAD_Y;
+  }
+  function bandRowH(phase) {
+    let maxH = 0;
+    let any = false;
+    for (const col of placedCols) {
+      const rows = rowsByCol.get(rowsKey(phase, col));
+      if (rows.length > 0) any = true;
+      const h = colStackH(rows);
+      if (h > maxH) maxH = h;
+    }
+    if (!any) return PRISMA_LINE_H * 2 + PRISMA_BOX_PAD_Y * 4;
+    return maxH;
+  }
+  const bandRowHs = PRISMA_PHASES.map((phase) => ({
+    rowH: bandRowH(phase),
+    zoneH: 0
+  }));
+  const stacked = bandStack(bandRowHs, { padding: PRISMA_PADDING, corridor: PRISMA_CORRIDOR });
+  const layoutBoxes = [];
+  const lboxById = /* @__PURE__ */ new Map();
+  function placeBox(b, phase, kind, cx, top) {
+    const m = boxMetrics.get(b.id);
+    const t = round14(top);
+    const title = boxTitle(b, nullToken);
+    const lbox = {
+      id: b.id,
+      phase,
+      kind,
+      cx: round14(cx),
+      top: t,
+      boxW: m.boxW,
+      boxH: m.boxH,
+      rows: m.rows.map((r2) => ({ ...r2, top: round14(t + r2.top) })),
+      dividerYs: m.dividerYs.map((d) => round14(t + d)),
+      heading: b.heading,
+      countLines: m.countLines,
+      title
+    };
+    layoutBoxes.push(lbox);
+    lboxById.set(b.id, lbox);
+  }
+  for (let phaseIdx = 0; phaseIdx < PRISMA_PHASES.length; phaseIdx++) {
+    const phase = PRISMA_PHASES[phaseIdx];
+    const bandTop = stacked.rowTop[phaseIdx];
+    for (const col of placedCols) {
+      const g = colGeom.get(col);
+      const rows = rowsByCol.get(rowsKey(phase, col));
+      const topByRank = /* @__PURE__ */ new Map();
+      let y = bandTop;
+      for (const r2 of rows) {
+        r2.top = round14(y);
+        topByRank.set(r2.rank, r2.top);
+        y = round14(y + r2.rowH + PRISMA_BOX_PAD_Y);
+      }
+      if (g.flowW > 0) {
+        for (const b of groupOf(phase, col, "flow")) {
+          placeBox(b, phase, "flow", g.flowCx, topByRank.get(b.rank));
+        }
+      }
+      if (g.exclW > 0) {
+        for (const b of groupOf(phase, col, "exclusion")) {
+          placeBox(b, phase, "exclusion", g.exclCx, topByRank.get(b.rank));
+        }
+      }
+    }
+  }
+  const elements = [];
+  const boxById = new Map(input.boxes.map((b) => [b.id, b]));
+  const phaseIndexMap = new Map(
+    PRISMA_PHASES.map((p, i) => [p, i])
+  );
+  function boxBottom(lb) {
+    return round14(lb.top + lb.boxH);
+  }
+  function bandBottom(phase) {
+    const idx = PRISMA_PHASES.indexOf(phase);
+    return round14(stacked.rowTop[idx] + bandRowHs[idx].rowH);
+  }
+  const arrowsToBox = /* @__PURE__ */ new Map();
+  for (const arrow of input.arrows) {
+    const toBox = boxById.get(arrow.toId);
+    const fromBox = boxById.get(arrow.fromId);
+    if (toBox === void 0 || fromBox === void 0) continue;
+    if (fromBox.kind === "flow" && toBox.kind === "flow") {
+      const arr = arrowsToBox.get(arrow.toId) ?? [];
+      arr.push(arrow.id);
+      arrowsToBox.set(arrow.toId, arr);
+    }
+  }
+  const arrowToBoxArrivalIdx = /* @__PURE__ */ new Map();
+  const exclArrowIndexBySource = /* @__PURE__ */ new Map();
+  for (const arrow of input.arrows) {
+    const fromLBox = lboxById.get(arrow.fromId);
+    const toLBox = lboxById.get(arrow.toId);
+    if (fromLBox === void 0 || toLBox === void 0) continue;
+    const fromBox = boxById.get(arrow.fromId);
+    const toBox = boxById.get(arrow.toId);
+    const isExclusion = fromBox.kind === "flow" && toBox.kind === "exclusion";
+    const isFlowToFlow = fromBox.kind === "flow" && toBox.kind === "flow";
+    if (isExclusion) {
+      const idx = exclArrowIndexBySource.get(arrow.fromId) ?? 0;
+      exclArrowIndexBySource.set(arrow.fromId, idx + 1);
+      const srcRight = round14(fromLBox.cx + fromLBox.boxW / 2);
+      const exclMidY = round14(toLBox.top + toLBox.boxH / 2);
+      const eLeft = round14(toLBox.cx - toLBox.boxW / 2);
+      const sameColumn = fromBox.column === toBox.column;
+      let points;
+      if (sameColumn) {
+        points = [
+          { x: round14(srcRight), y: round14(exclMidY) },
+          { x: round14(eLeft), y: round14(exclMidY) }
+        ];
+      } else {
+        const colGapStep = round14(PRISMA_COL_GAP / 8);
+        const exclGapStep = round14(PRISMA_EXCL_GAP / 8);
+        const fenceX = round14(srcRight + (idx + 1) * colGapStep);
+        const exclFenceX = round14(eLeft - (idx + 1) * exclGapStep);
+        const bBotY = bandBottom(fromBox.phase);
+        const corridorY = round14(bBotY + PRISMA_ROUTE_MARGIN + idx * PRISMA_ROUTE_PITCH);
+        points = [
+          { x: round14(srcRight), y: round14(exclMidY) },
+          // exit source right at excl center y
+          { x: round14(fenceX), y: round14(exclMidY) },
+          // horizontal into inter-col gap (unique y)
+          { x: round14(fenceX), y: round14(corridorY) },
+          // vertical at unique x in inter-col gap
+          { x: round14(exclFenceX), y: round14(corridorY) },
+          // horizontal in corridor (unique y)
+          { x: round14(exclFenceX), y: round14(exclMidY) },
+          // vertical at unique x left of excl box
+          { x: round14(eLeft), y: round14(exclMidY) }
+          // horizontal into excl box (unique y)
+        ];
+      }
+      elements.push({
+        edgeId: PRISMA_EXCL_ARROW_BASE + arrow.id,
+        kind: "exclusion",
+        points,
+        title: `${labels.arrowKinds.exclusion}: ${fromLBox.title} \u2192 ${toLBox.title}`,
+        headDir: "right"
+      });
+    } else if (isFlowToFlow) {
+      const fromPhaseIdx = phaseIndexMap.get(fromBox.phase);
+      const toPhaseIdx = phaseIndexMap.get(toBox.phase);
+      const isSamePhase = fromBox.phase === toBox.phase;
+      const isSameCol = fromBox.column === toBox.column;
+      const isForward = toPhaseIdx >= fromPhaseIdx;
+      const arrivals = arrowsToBox.get(arrow.toId) ?? [];
+      let arrivalIdx = arrowToBoxArrivalIdx.get(arrow.id) ?? 0;
+      if (!arrowToBoxArrivalIdx.has(arrow.id)) {
+        arrivalIdx = arrivals.indexOf(arrow.id);
+        arrowToBoxArrivalIdx.set(arrow.id, arrivalIdx);
+      }
+      const nArrivals = arrivals.length;
+      const APPROACH_SPREAD = round14(toLBox.boxW / 4);
+      const spreadStep = nArrivals > 1 ? round14(APPROACH_SPREAD / (nArrivals - 1)) : 0;
+      const approachX = round14(toLBox.cx - APPROACH_SPREAD / 2 + arrivalIdx * spreadStep);
+      const toTop = toLBox.top;
+      if (isSamePhase && isSameCol) {
+        const fromBottom = boxBottom(fromLBox);
+        const fromCx = round14(fromLBox.cx);
+        const toCx = round14(toLBox.cx);
+        const dropX = fromCx === toCx ? fromCx : toCx;
+        elements.push({
+          edgeId: PRISMA_FLOW_ARROW_BASE + arrow.id,
+          kind: "flow",
+          points: [
+            { x: fromCx, y: round14(fromBottom) },
+            { x: dropX, y: round14(toTop) }
+          ],
+          title: `${labels.arrowKinds.flow}: ${fromLBox.title} \u2192 ${toLBox.title}`,
+          headDir: "down"
+        });
+      } else if (isSameCol && isForward) {
+        const fromBottom = boxBottom(fromLBox);
+        if (nArrivals <= 1 && round14(fromLBox.cx) === round14(toLBox.cx)) {
+          elements.push({
+            edgeId: PRISMA_FLOW_ARROW_BASE + arrow.id,
+            kind: "flow",
+            points: [
+              { x: round14(fromLBox.cx), y: round14(fromBottom) },
+              { x: round14(toLBox.cx), y: round14(toTop) }
+            ],
+            title: `${labels.arrowKinds.flow}: ${fromLBox.title} \u2192 ${toLBox.title}`,
+            headDir: "down"
+          });
+        } else {
+          const phIdx = phaseIndexMap.get(fromBox.phase);
+          const elbowY = round14(stacked.rowTop[phIdx] + bandRowHs[phIdx].rowH + PRISMA_CORRIDOR / 2);
+          elements.push({
+            edgeId: PRISMA_FLOW_ARROW_BASE + arrow.id,
+            kind: "flow",
+            points: [
+              { x: round14(fromLBox.cx), y: round14(fromBottom) },
+              { x: round14(fromLBox.cx), y: round14(elbowY) },
+              { x: round14(approachX), y: round14(elbowY) },
+              { x: round14(approachX), y: round14(toTop) }
+            ],
+            title: `${labels.arrowKinds.flow}: ${fromLBox.title} \u2192 ${toLBox.title}`,
+            headDir: "down"
+          });
+        }
+      } else {
+        const fromBottom = boxBottom(fromLBox);
+        const phIdx = phaseIndexMap.get(fromBox.phase);
+        const elbowY = round14(stacked.rowTop[phIdx] + bandRowHs[phIdx].rowH + PRISMA_CORRIDOR / 2);
+        const fromCx = round14(fromLBox.cx);
+        if (round14(fromCx) === round14(approachX)) {
+          elements.push({
+            edgeId: PRISMA_MERGE_ARROW_BASE + arrow.id,
+            kind: "merge",
+            points: [
+              { x: fromCx, y: round14(fromBottom) },
+              { x: round14(approachX), y: round14(toTop) }
+            ],
+            title: `${labels.arrowKinds.merge}: ${fromLBox.title} \u2192 ${toLBox.title}`,
+            headDir: "down"
+          });
+        } else {
+          elements.push({
+            edgeId: PRISMA_MERGE_ARROW_BASE + arrow.id,
+            kind: "merge",
+            points: [
+              { x: fromCx, y: round14(fromBottom) },
+              { x: fromCx, y: round14(elbowY) },
+              { x: round14(approachX), y: round14(elbowY) },
+              { x: round14(approachX), y: round14(toTop) }
+            ],
+            title: `${labels.arrowKinds.merge}: ${fromLBox.title} \u2192 ${toLBox.title}`,
+            headDir: "down"
+          });
+        }
+      }
+    }
+  }
+  const canvasH = stacked.height;
+  const canvasW = round14(totalRight + PRISMA_PADDING);
+  const bands = PRISMA_PHASES.map((phase, i) => {
+    const rowTop = stacked.rowTop[i];
+    const rowH = bandRowHs[i].rowH;
+    return {
+      phase,
+      rowTop,
+      rowH,
+      labelX: PRISMA_PADDING,
+      centerY: round14(rowTop + rowH / 2)
+    };
+  });
+  return {
+    width: canvasW,
+    height: canvasH,
+    boxes: layoutBoxes,
+    elements,
+    bands,
+    variant: input.variant
+  };
+}
+
+// src/prisma/svg.ts
+var BOX_STROKE2 = "#52525b";
+var BOX_STROKE_W = 2;
+var BOX_FILL = "#fff";
+var BOX_RX = 2;
+var HEADING_FILL = "#3f3f46";
+var COUNT_FILL = "#52525b";
+var ARROW_STROKE = "#71717a";
+var ARROW_STROKE_W = 1.5;
+var ARROW_FILL = "#71717a";
+var BAND_LABEL_FILL = "#52525b";
+var BAND_LABEL_FONT = 11;
+function round15(n) {
+  return Math.round(n * 100) / 100;
+}
+function emitBox(b) {
+  const x = round15(b.cx - b.boxW / 2);
+  const y = b.top;
+  const parts = [];
+  parts.push(
+    `<rect x="${x}" y="${y}" width="${b.boxW}" height="${b.boxH}" rx="${BOX_RX}" fill="${BOX_FILL}" stroke="${BOX_STROKE2}" stroke-width="${BOX_STROKE_W}"/>`
+  );
+  for (const dy of b.dividerYs) {
+    parts.push(
+      `<line x1="${x}" y1="${dy}" x2="${round15(x + b.boxW)}" y2="${dy}" stroke="${BOX_STROKE2}" stroke-width="1"/>`
+    );
+  }
+  for (let ri = 0; ri < b.rows.length; ri++) {
+    const row = b.rows[ri];
+    const isHeading = ri === 0;
+    const font = row.font;
+    const fill = isHeading ? HEADING_FILL : COUNT_FILL;
+    const textX = isHeading ? round15(b.cx) : round15(x + 8);
+    for (let li = 0; li < row.lines.length; li++) {
+      const line = row.lines[li];
+      const textY = round15(row.top + li * 14 + font);
+      const anchorAttr = isHeading ? ` text-anchor="middle"` : "";
+      const weightAttr = isHeading ? ` font-weight="bold"` : "";
+      parts.push(
+        `<text x="${textX}" y="${textY}" font-family="${FONT_FAMILY}" font-size="${font}" fill="${fill}"${anchorAttr}${weightAttr}>${xmlEscape(line)}</text>`
+      );
+    }
+  }
+  return parts.join("");
+}
+function emitArrow(el) {
+  const points = el.points;
+  if (points.length < 2) return "";
+  const inset = glyphInset(el.headDir, "arrow");
+  const last = points[points.length - 1];
+  let lineEndX = last.x;
+  let lineEndY = last.y;
+  if (el.headDir === "down") lineEndY = round15(last.y - inset);
+  else if (el.headDir === "right") lineEndX = round15(last.x - inset);
+  else if (el.headDir === "left") lineEndX = round15(last.x + inset);
+  else lineEndY = round15(last.y + inset);
+  const linePoints = [
+    ...points.slice(0, points.length - 1).map((p) => ({ x: p.x, y: p.y })),
+    { x: lineEndX, y: lineEndY }
+  ];
+  const pathStr = pathData(linePoints);
+  const arrowPts = arrowFilledPoints({ x: last.x, y: last.y }, el.headDir);
+  return `<title>${xmlEscape(el.title)}</title><path d="${pathStr}" stroke="${ARROW_STROKE}" stroke-width="${ARROW_STROKE_W}" fill="none"/><polygon points="${arrowPts}" fill="${ARROW_FILL}" stroke="none"/>`;
+}
+function emitBandLabel(phase, labelX, centerY, bandTitleLabels) {
+  const text = bandTitleLabels.phases[phase];
+  const gutterCx = round15(labelX + PRISMA_BAND_LABEL_W / 2);
+  return `<text x="${gutterCx}" y="${round15(centerY)}" font-family="${FONT_FAMILY}" font-size="${BAND_LABEL_FONT}" fill="${BAND_LABEL_FILL}" text-anchor="middle" transform="rotate(-90,${gutterCx},${round15(centerY)})">${xmlEscape(text)}</text>`;
+}
+function buildLegendEntries(layout, svgLabels) {
+  const hasFlow = layout.boxes.some((b) => b.kind === "flow");
+  const hasExcl = layout.boxes.some((b) => b.kind === "exclusion");
+  const entries = [];
+  if (hasFlow) {
+    entries.push({
+      label: svgLabels.legend.flow,
+      swatch: (x, cy) => `<rect x="${x}" y="${round15(cy - 6)}" width="22" height="12" rx="2" fill="${BOX_FILL}" stroke="${BOX_STROKE2}" stroke-width="2"/>`
+    });
+  }
+  if (hasExcl) {
+    entries.push({
+      label: svgLabels.legend.exclusion,
+      swatch: (x, cy) => `<rect x="${x}" y="${round15(cy - 6)}" width="22" height="12" rx="2" fill="${BOX_FILL}" stroke="${BOX_STROKE2}" stroke-width="2" stroke-dasharray="4,2"/>`
+    });
+  }
+  return entries;
+}
+function prismaLayoutSvg(layout, opts = {}) {
+  const svgLabels = opts.svgLabels ?? PRISMA_SVG_LABELS_EN;
+  const bandTitleLabels = opts.titleLabels ?? PRISMA_TITLE_LABELS_EN;
+  const doLegend = opts.legend !== false;
+  const parts = [];
+  for (const band of layout.bands) {
+    parts.push(emitBandLabel(band.phase, band.labelX, band.centerY, bandTitleLabels));
+  }
+  for (const b of layout.boxes) {
+    const boxSvg3 = emitBox(b);
+    parts.push(`<g data-node-id="b${b.id}"><title>${xmlEscape(b.title)}</title>${boxSvg3}</g>`);
+  }
+  for (const el of layout.elements) {
+    const arrowSvg = emitArrow(el);
+    parts.push(`<g data-edge-id="${el.edgeId}">${arrowSvg}</g>`);
+  }
+  let w = layout.width;
+  let h = layout.height;
+  let legendSvg = "";
+  if (doLegend) {
+    const entries = buildLegendEntries(layout, svgLabels);
+    const lb = legendBlock(entries, h);
+    legendSvg = lb.svg;
+    if (entries.length > 0) {
+      w = Math.max(w, lb.width + 32 * 2);
+      h = lb.height;
+    }
+  }
+  w = round15(w);
+  h = round15(h);
+  return `<svg xmlns="http://www.w3.org/2000/svg" width="${w}" height="${h}" viewBox="0 0 ${w} ${h}" role="img" aria-label="${xmlEscape(svgLabels.ariaLabel)}">` + parts.join("") + legendSvg + `</svg>`;
+}
+
+// src/prisma/render.ts
+function prismaSvg(input, opts = {}) {
+  const layout = computePrismaLayout(input, opts);
+  const svg = prismaLayoutSvg(layout, opts);
+  return { svg, layout };
+}
+
+// src/uml/types.ts
+var UML_VISIBILITIES = ["public", "private", "protected", "package"];
+var UML_VIS_GLYPH = {
+  public: "+",
+  private: "-",
+  protected: "#",
+  package: "~"
+};
+var UML_RELATIONSHIPS = [
+  "association",
+  "directed-association",
+  "aggregation",
+  "composition",
+  "generalization",
+  "realization",
+  "dependency"
+];
+var RELATION_GLYPHS = {
+  association: { sourceEnd: "none", targetEnd: "none", line: "solid" },
+  "directed-association": { sourceEnd: "none", targetEnd: "open-arrow", line: "solid" },
+  aggregation: { sourceEnd: "hollow-diamond", targetEnd: "none", line: "solid" },
+  composition: { sourceEnd: "solid-diamond", targetEnd: "none", line: "solid" },
+  generalization: { sourceEnd: "none", targetEnd: "hollow-triangle", line: "solid" },
+  realization: { sourceEnd: "none", targetEnd: "hollow-triangle", line: "dashed" },
+  dependency: { sourceEnd: "none", targetEnd: "open-arrow", line: "dashed" }
+};
+
+// src/uml/validate.ts
+var UmlValidationError = class extends Error {
+  issues;
+  constructor(issues) {
+    super(`invalid UML class diagram: ${issues.map((i) => i.message).join("; ")}`);
+    this.name = "UmlValidationError";
+    this.issues = issues;
+  }
+};
+function sortIssues6(issues) {
+  const unique = /* @__PURE__ */ new Map();
+  for (const issue of issues) unique.set(`${issue.code} ${issue.message}`, issue);
+  return [...unique.values()].sort(
+    (a, b) => a.code !== b.code ? a.code < b.code ? -1 : 1 : a.message < b.message ? -1 : a.message > b.message ? 1 : 0
+  );
+}
+var GRAPH_BLOCKING2 = /* @__PURE__ */ new Set([
+  "duplicate-id",
+  "unknown-endpoint"
+]);
+var INHERITANCE_KINDS = /* @__PURE__ */ new Set([
+  "generalization",
+  "realization"
+]);
+function umlIssues(input) {
+  if (input.classes.length === 0 && input.relationships.length === 0) return [];
+  const issues = [];
+  const push = (code, message) => {
+    issues.push({ code, message });
+  };
+  const classById = /* @__PURE__ */ new Map();
+  const dupClassIds = /* @__PURE__ */ new Set();
+  for (const c of input.classes) {
+    if (classById.has(c.id)) dupClassIds.add(c.id);
+    else classById.set(c.id, c);
+  }
+  for (const id of [...dupClassIds].sort((a, b) => a - b)) {
+    push("duplicate-id", `duplicate class id ${id}`);
+  }
+  const relById = /* @__PURE__ */ new Map();
+  const dupRelIds = /* @__PURE__ */ new Set();
+  for (const r2 of input.relationships) {
+    if (relById.has(r2.id)) dupRelIds.add(r2.id);
+    else relById.set(r2.id, r2);
+  }
+  for (const id of [...dupRelIds].sort((a, b) => a - b)) {
+    push("duplicate-id", `duplicate relationship id ${id}`);
+  }
+  if (issues.length > 0) return sortIssues6(issues);
+  const rels = [...relById.values()].sort((a, b) => a.id - b.id);
+  for (const r2 of rels) {
+    if (!classById.has(r2.sourceId)) {
+      push("unknown-endpoint", `relationship ${r2.id} sourceId ${r2.sourceId} is not a declared class`);
+    }
+    if (!classById.has(r2.targetId)) {
+      push("unknown-endpoint", `relationship ${r2.id} targetId ${r2.targetId} is not a declared class`);
+    }
+  }
+  for (const c of [...classById.values()].sort((a, b) => a.id - b.id)) {
+    if (!Number.isInteger(c.col) || c.col < 0) {
+      push("negative-cell", `class ${c.id} col ${c.col} must be a non-negative integer`);
+    }
+    if (!Number.isInteger(c.row) || c.row < 0) {
+      push("negative-cell", `class ${c.id} row ${c.row} must be a non-negative integer`);
+    }
+  }
+  const cellKey = (c) => `${c.col},${c.row}`;
+  const cellToClasses = /* @__PURE__ */ new Map();
+  for (const c of [...classById.values()].sort((a, b) => a.id - b.id)) {
+    const key = cellKey(c);
+    const arr = cellToClasses.get(key) ?? [];
+    arr.push(c.id);
+    cellToClasses.set(key, arr);
+  }
+  for (const [key, ids] of [...cellToClasses.entries()].sort()) {
+    if (ids.length > 1) {
+      push(
+        "cell-collision",
+        `classes ${ids.sort((a, b) => a - b).join(", ")} all declare cell (${key})`
+      );
+    }
+  }
+  for (const r2 of rels) {
+    if ((r2.kind === "generalization" || r2.kind === "realization") && r2.sourceId === r2.targetId) {
+      push(
+        "self-generalization",
+        `relationship ${r2.id} is a ${r2.kind} from class ${r2.sourceId} to itself`
+      );
+    }
+  }
+  if (!issues.some((i) => GRAPH_BLOCKING2.has(i.code))) {
+    const inheritanceChildren = /* @__PURE__ */ new Map();
+    for (const r2 of rels) {
+      if (!INHERITANCE_KINDS.has(r2.kind)) continue;
+      if (r2.sourceId === r2.targetId) continue;
+      const arr = inheritanceChildren.get(r2.sourceId) ?? [];
+      arr.push(r2.targetId);
+      inheritanceChildren.set(r2.sourceId, arr);
+    }
+    for (const arr of inheritanceChildren.values()) arr.sort((a, b) => a - b);
+    const color = /* @__PURE__ */ new Map();
+    const seenCycles = /* @__PURE__ */ new Set();
+    const dfs = (start) => {
+      const stack = [{ id: start, nextChild: 0 }];
+      color.set(start, 1);
+      while (stack.length > 0) {
+        const frame = stack[stack.length - 1];
+        const children = inheritanceChildren.get(frame.id) ?? [];
+        if (frame.nextChild >= children.length) {
+          color.set(frame.id, 2);
+          stack.pop();
+          continue;
+        }
+        const child = children[frame.nextChild];
+        frame.nextChild += 1;
+        const c = color.get(child) ?? 0;
+        if (c === 1) {
+          const from = stack.findIndex((f) => f.id === child);
+          const cycle = stack.slice(from).map((f) => f.id);
+          const minIdx = cycle.indexOf(Math.min(...cycle));
+          const rotated = [...cycle.slice(minIdx), ...cycle.slice(0, minIdx)];
+          const key = rotated.join(">");
+          if (!seenCycles.has(key)) {
+            seenCycles.add(key);
+            push(
+              "generalization-cycle",
+              `generalization cycle: ${[...rotated, rotated[0]].join(" \u2192 ")}`
+            );
+          }
+        } else if (c === 0) {
+          color.set(child, 1);
+          stack.push({ id: child, nextChild: 0 });
+        }
+      }
+    };
+    for (const c of [...classById.values()].sort((a, b) => a.id - b.id)) {
+      if ((color.get(c.id) ?? 0) === 0) dfs(c.id);
+    }
+  }
+  return sortIssues6(issues);
+}
+function validateUml(input) {
+  const issues = umlIssues(input);
+  if (issues.length > 0) throw new UmlValidationError(issues);
+}
+function sideCapacity(boxH, rowGap, pitch, glyphHalf) {
+  const clear = boxH / 2 + rowGap / 2 - glyphHalf;
+  const k = Math.max(0, Math.floor(clear / pitch));
+  return 2 * k + 1;
+}
+function sideCapacityIssue(classId, side, count, capacity) {
+  return {
+    code: "too-many-side-edges",
+    message: `class ${classId} has ${count} edges on its ${side} side \u2014 at most ${capacity} fit without a port stub spilling through a neighbouring box`
+  };
+}
+
+// src/uml/labels.ts
+var UML_TITLE_LABELS_EN = {
+  kinds: {
+    association: "association",
+    "directed-association": "directed association",
+    aggregation: "aggregation",
+    composition: "composition",
+    generalization: "generalization",
+    realization: "realization",
+    dependency: "dependency"
+  },
+  visibilities: {
+    public: "public",
+    private: "private",
+    protected: "protected",
+    package: "package"
+  }
+};
+var UML_SVG_LABELS_EN = {
+  legend: {
+    association: "Association",
+    "directed-association": "Directed association",
+    aggregation: "Aggregation",
+    composition: "Composition",
+    generalization: "Generalization",
+    realization: "Realization",
+    dependency: "Dependency"
+  },
+  ariaLabel: "UML class diagram"
+};
+
+// src/uml/layout.ts
+var UML_PADDING = 32;
+var UML_COL_GAP = 64;
+var UML_ROW_GAP = 56;
+var UML_BOX_PAD_X = 10;
+var UML_BOX_PAD_Y = 8;
+var UML_LINE_H = 15;
+var UML_MIN_BOX_W = 120;
+var UML_NAME_FONT = 12;
+var UML_FEAT_FONT = 11;
+var UML_SEP_PAD = 4;
+var UML_PORT_PITCH = 12;
+var UML_SELF_LOOP_W = 28;
+var UML_LABEL_FONT = 10;
+var UML_ASSOC_ROUTE_BASE = 1e6;
+var UML_GLYPH_BASE = 2e6;
+var UML_SELF_LOOP_BASE = 3e6;
+var MIN_TERMINAL_STUB = 4;
+var round16 = (n) => Math.round(n * 100) / 100;
+function featureLine(f) {
+  const prefix = f.visibility !== null ? UML_VIS_GLYPH[f.visibility] + " " : "";
+  return prefix + f.text;
+}
+function measureClass(cls) {
+  const nameLines = [];
+  if (cls.stereotype !== null) nameLines.push(cls.stereotype);
+  nameLines.push(cls.name);
+  const attrLines = cls.attributes.map(featureLine);
+  const opLines = cls.operations.map(featureLine);
+  return measureCompartmentBox(
+    [
+      { lines: nameLines, font: UML_NAME_FONT },
+      { lines: attrLines, font: UML_FEAT_FONT },
+      { lines: opLines, font: UML_FEAT_FONT }
+    ],
+    {
+      padX: UML_BOX_PAD_X,
+      padY: UML_BOX_PAD_Y,
+      lineH: UML_LINE_H,
+      minW: UML_MIN_BOX_W}
+  );
+}
+function boxEdges(node) {
+  const left = round16(node.cx - node.boxW / 2);
+  const right = round16(left + node.boxW);
+  const top = round16(node.cy - node.boxH / 2);
+  const bottom = round16(top + node.boxH);
+  return { left, right, top, bottom };
+}
+function glyphInsetForKind(gk) {
+  switch (gk) {
+    case "none":
+      return 0;
+    case "open-arrow":
+      return glyphInset("right", "arrow");
+    case "hollow-triangle":
+      return glyphInset("right", "triangle");
+    case "hollow-diamond":
+    case "solid-diamond":
+      return glyphInset("right", "diamond");
+  }
+}
+var MAX_GLYPH_HALF = GLYPH_TRI_HALF;
+var GLYPH_SLOT_PITCH = Math.max(UML_PORT_PITCH, MAX_GLYPH_HALF * 2 + 2);
+function portOffset(slotIndex, slotSize) {
+  if (slotIndex === 0) return 0;
+  const sign = slotIndex % 2 === 1 ? 1 : -1;
+  const dist = Math.ceil(slotIndex / 2);
+  return sign * dist * slotSize;
+}
+function sidePort(node, side, dy) {
+  const { left, right } = boxEdges(node);
+  const x = side === "right" ? right : left;
+  return { x, y: round16(node.cy + dy) };
+}
+function vGutterLeft(colIdx, colX, grid) {
+  return round16(colX[colIdx] + grid.colW[colIdx]);
+}
+var V_GUTTER_MARGIN = 6;
+function horizontalGutterY(rowIdx, rowY, grid) {
+  return round16(rowY[rowIdx] + grid.rowH[rowIdx] + UML_ROW_GAP / 2);
+}
+function moveAlongDir(p, dir, dist) {
+  switch (dir) {
+    case "right":
+      return { x: round16(p.x + dist), y: p.y };
+    case "left":
+      return { x: round16(p.x - dist), y: p.y };
+    case "down":
+      return { x: p.x, y: round16(p.y + dist) };
+    case "up":
+      return { x: p.x, y: round16(p.y - dist) };
+  }
+}
+function simplifyWaypoints(pts) {
+  const dedup = [pts[0]];
+  for (let i = 1; i < pts.length; i++) {
+    const prev = dedup[dedup.length - 1];
+    const cur = pts[i];
+    if (Math.abs(cur.x - prev.x) > 1e-6 || Math.abs(cur.y - prev.y) > 1e-6) dedup.push(cur);
+  }
+  if (dedup.length <= 2) return dedup;
+  const out = [dedup[0]];
+  for (let i = 1; i < dedup.length - 1; i++) {
+    const a = out[out.length - 1];
+    const b = dedup[i];
+    const c = dedup[i + 1];
+    const abH = Math.abs(a.y - b.y) <= 1e-6;
+    const bcH = Math.abs(b.y - c.y) <= 1e-6;
+    const abV = Math.abs(a.x - b.x) <= 1e-6;
+    const bcV = Math.abs(b.x - c.x) <= 1e-6;
+    if (abH && bcH || abV && bcV) continue;
+    out.push(b);
+  }
+  out.push(dedup[dedup.length - 1]);
+  return out;
+}
+function chooseSides(srcNode, tgtNode, maxCol) {
+  const sc = srcNode.col;
+  const tc = tgtNode.col;
+  if (tc > sc) return { srcSide: "right", tgtSide: "left", srcVCol: sc, tgtVCol: tc - 1 };
+  if (tc < sc) return { srcSide: "left", tgtSide: "right", srcVCol: sc - 1, tgtVCol: tc };
+  if (sc < maxCol) return { srcSide: "right", tgtSide: "right", srcVCol: sc, tgtVCol: sc };
+  if (sc > 0) return { srcSide: "left", tgtSide: "left", srcVCol: sc - 1, tgtVCol: sc - 1 };
+  return { srcSide: "right", tgtSide: "right", srcVCol: sc, tgtVCol: sc };
+}
+function hBaseY(plan, rowY, grid) {
+  if (plan.hKind === "pad-top") return round16(UML_PADDING / 2);
+  return horizontalGutterY(plan.hRow, rowY, grid);
+}
+function hBandBounds(plan, rowY, grid) {
+  if (plan.hKind === "pad-top") return { lo: 0, hi: round16(rowY[0] ?? UML_PADDING) };
+  const lo = round16(rowY[plan.hRow] + grid.rowH[plan.hRow]);
+  const hi = round16(rowY[plan.hRow + 1]);
+  return { lo, hi };
+}
+var LANE_EPS = 0.5;
+var X_OVERLAP_EPS = 1e-4;
+function allocateHorizontal(runs, base, usableHalf) {
+  const floating = runs.filter((r2) => r2.y === null);
+  if (floating.length === 0) return;
+  const pinned = runs.filter((r2) => r2.y !== null);
+  const trackCount = floating.length + pinned.length + 1;
+  const candidates = trackCount <= 1 || usableHalf <= 0 ? [base] : Array.from(
+    { length: trackCount },
+    (_, k) => round16(base - usableHalf + (k + 0.5) * (2 * usableHalf) / trackCount)
+  );
+  const placed = pinned.map((r2) => ({ lo: r2.lo, hi: r2.hi, y: r2.y }));
+  const ordered = [...floating].sort((a, b) => a.lo - b.lo || a.hi - b.hi);
+  for (const run of ordered) {
+    let chosen = candidates[0];
+    for (const cy of candidates) {
+      const collides = placed.some(
+        (q) => Math.abs(q.y - cy) <= LANE_EPS && Math.min(run.hi, q.hi) - Math.max(run.lo, q.lo) > X_OVERLAP_EPS
+      );
+      if (!collides) {
+        chosen = cy;
+        break;
+      }
+    }
+    run.set(chosen);
+    placed.push({ lo: run.lo, hi: run.hi, y: chosen });
+  }
+}
+function applyGlyphInsets(pts, srcInset, tgtInset) {
+  if (pts.length < 2) return pts;
+  const out = pts.map((p) => ({ ...p }));
+  if (srcInset > 0) {
+    const p0 = out[0];
+    const p1 = out[1];
+    const dir = p1.x >= p0.x ? "right" : "left";
+    out[0] = moveAlongDir(p0, dir, srcInset);
+  }
+  if (tgtInset > 0) {
+    const pn = out[out.length - 1];
+    const pm = out[out.length - 2];
+    const dir = pm.x >= pn.x ? "right" : "left";
+    out[out.length - 1] = moveAlongDir(pn, dir, tgtInset);
+  }
+  return out;
+}
+function reserveTextBox(relId, slot, text, anchorX, anchorY, anchor) {
+  const w = round16(estimateTextWidth(text, UML_LABEL_FONT));
+  const h = round16(UML_LABEL_FONT * 1.2);
+  const x = anchor === "middle" ? round16(anchorX - w / 2) : round16(anchorX);
+  const y = round16(anchorY);
+  return { relId, slot, text, x, y, w, h, anchor };
+}
+function computeUmlLayout(input, labels = UML_TITLE_LABELS_EN) {
+  validateUml(input);
+  const relTitle = (rel) => rel.title ?? labels.kinds[rel.kind];
+  if (input.classes.length === 0) {
+    return {
+      nodes: [],
+      elements: [],
+      textBoxes: [],
+      canvasW: UML_PADDING * 2,
+      canvasH: UML_PADDING * 2,
+      grid: { cellX: [], cellY: [], colW: [], rowH: [] },
+      colX: [],
+      rowY: []
+    };
+  }
+  const classes = [...input.classes].sort((a, b) => a.id - b.id);
+  const rels = [...input.relationships].sort((a, b) => a.id - b.id);
+  const metricsMap = /* @__PURE__ */ new Map();
+  for (const cls of classes) metricsMap.set(cls.id, measureClass(cls));
+  const gridCells = classes.map((cls) => ({
+    col: cls.col,
+    row: cls.row,
+    w: metricsMap.get(cls.id).boxW,
+    h: metricsMap.get(cls.id).boxH
+  }));
+  const grid = packGrid(gridCells, { colGap: UML_COL_GAP, rowGap: UML_ROW_GAP });
+  const colX = [];
+  {
+    let x = UML_PADDING;
+    for (let c = 0; c < grid.colW.length; c++) {
+      colX.push(round16(x));
+      x = round16(x + grid.colW[c] + UML_COL_GAP);
+    }
+  }
+  const rowY = [];
+  {
+    let y = UML_PADDING;
+    for (let r2 = 0; r2 < grid.rowH.length; r2++) {
+      rowY.push(round16(y));
+      y = round16(y + grid.rowH[r2] + UML_ROW_GAP);
+    }
+  }
+  const nodeByClassId = /* @__PURE__ */ new Map();
+  const nodes = [];
+  for (const cls of classes) {
+    const metrics = metricsMap.get(cls.id);
+    const cx = round16(colX[cls.col] + grid.colW[cls.col] / 2);
+    const cy = round16(rowY[cls.row] + grid.rowH[cls.row] / 2);
+    const title = cls.title ?? (cls.stereotype !== null ? `\xAB${cls.stereotype}\xBB ${cls.name}` : cls.name);
+    const node = {
+      classId: cls.id,
+      cx,
+      cy,
+      boxW: metrics.boxW,
+      boxH: metrics.boxH,
+      metrics,
+      title,
+      col: cls.col,
+      row: cls.row
+    };
+    nodes.push(node);
+    nodeByClassId.set(cls.id, node);
+  }
+  const maxCol = grid.colW.length - 1;
+  const maxRow = grid.rowH.length - 1;
+  const sideCount = /* @__PURE__ */ new Map();
+  const bumpSide = (classId, side) => {
+    const key = `${classId}:${side}`;
+    sideCount.set(key, (sideCount.get(key) ?? 0) + 1);
+  };
+  for (const rel of rels) {
+    const srcNode = nodeByClassId.get(rel.sourceId);
+    const tgtNode = nodeByClassId.get(rel.targetId);
+    if (!srcNode || !tgtNode) continue;
+    if (rel.sourceId === rel.targetId) {
+      bumpSide(srcNode.classId, "right");
+      bumpSide(srcNode.classId, "right");
+      continue;
+    }
+    const { srcSide, tgtSide } = chooseSides(srcNode, tgtNode, maxCol);
+    bumpSide(srcNode.classId, srcSide);
+    bumpSide(tgtNode.classId, tgtSide);
+  }
+  {
+    const capIssues = [];
+    for (const node of nodes) {
+      const cap = sideCapacity(node.boxH, UML_ROW_GAP, GLYPH_SLOT_PITCH, MAX_GLYPH_HALF);
+      for (const side of ["left", "right"]) {
+        const count = sideCount.get(`${node.classId}:${side}`) ?? 0;
+        if (count > cap) capIssues.push(sideCapacityIssue(node.classId, side, count, cap));
+      }
+    }
+    if (capIssues.length > 0) {
+      throw new UmlValidationError(capIssues);
+    }
+  }
+  const sidePortSlot = /* @__PURE__ */ new Map();
+  const nextSidePort = (classId, side) => {
+    const key = `${classId}:${side}`;
+    const idx = sidePortSlot.get(key) ?? 0;
+    sidePortSlot.set(key, idx + 1);
+    return idx;
+  };
+  const elements = [];
+  const textBoxes = [];
+  const plans = [];
+  for (const rel of rels) {
+    const srcNode = nodeByClassId.get(rel.sourceId);
+    const tgtNode = nodeByClassId.get(rel.targetId);
+    if (!srcNode || !tgtNode) continue;
+    const glyphs = RELATION_GLYPHS[rel.kind];
+    const srcInset = glyphInsetForKind(glyphs.sourceEnd);
+    const tgtInset = glyphInsetForKind(glyphs.targetEnd);
+    if (rel.sourceId === rel.targetId) {
+      const vCol = srcNode.col;
+      const armDy1 = portOffset(nextSidePort(srcNode.classId, "right"), GLYPH_SLOT_PITCH);
+      const armDy2 = portOffset(nextSidePort(srcNode.classId, "right"), GLYPH_SLOT_PITCH);
+      plans.push({
+        rel,
+        srcNode,
+        tgtNode,
+        srcSide: "right",
+        tgtSide: "right",
+        srcVCol: vCol,
+        tgtVCol: vCol,
+        srcInset,
+        tgtInset,
+        srcPortY: round16(srcNode.cy + armDy1),
+        tgtPortY: round16(srcNode.cy + armDy2),
+        hKind: "row",
+        hRow: 0,
+        // unused for self-loops (no H-leg)
+        isSelfLoop: true,
+        srcVx: 0,
+        tgtVx: 0,
+        hY: 0
+      });
+      continue;
+    }
+    const { srcSide, tgtSide, srcVCol, tgtVCol } = chooseSides(srcNode, tgtNode, maxCol);
+    const srcPortDy = portOffset(nextSidePort(srcNode.classId, srcSide), GLYPH_SLOT_PITCH);
+    const tgtPortDy = portOffset(nextSidePort(tgtNode.classId, tgtSide), GLYPH_SLOT_PITCH);
+    const sr = srcNode.row;
+    const tr = tgtNode.row;
+    let hKind;
+    let hRow;
+    if (sr !== tr) {
+      hKind = "row";
+      hRow = Math.min(sr, tr);
+    } else if (maxRow >= 1) {
+      hKind = "row";
+      hRow = sr < maxRow ? sr : sr - 1;
+    } else {
+      hKind = "pad-top";
+      hRow = -1;
+    }
+    plans.push({
+      rel,
+      srcNode,
+      tgtNode,
+      srcSide,
+      tgtSide,
+      srcVCol,
+      tgtVCol,
+      srcInset,
+      tgtInset,
+      srcPortY: round16(srcNode.cy + srcPortDy),
+      tgtPortY: round16(tgtNode.cy + tgtPortDy),
+      hKind,
+      hRow,
+      isSelfLoop: false,
+      srcVx: 0,
+      tgtVx: 0,
+      hY: 0
+    });
+  }
+  const hHalfBand = (p) => p.hKind === "pad-top" ? round16(UML_PADDING / 2) : round16(UML_ROW_GAP / 2);
+  const vByKey = /* @__PURE__ */ new Map();
+  const pushV = (col, side, portY, hBase, half, inset, set) => {
+    const lo = Math.min(portY, round16(hBase - half));
+    const hi = Math.max(portY, round16(hBase + half));
+    const key = `${col}:${side}`;
+    const arr = vByKey.get(key) ?? [];
+    arr.push({ lo, hi, inset, lane: 0, set });
+    vByKey.set(key, arr);
+  };
+  for (const p of plans) {
+    if (p.isSelfLoop) {
+      const lo = Math.min(p.srcPortY, p.tgtPortY);
+      const hi = Math.max(p.srcPortY, p.tgtPortY);
+      const key = `${p.srcVCol}:right`;
+      const arr = vByKey.get(key) ?? [];
+      arr.push({ lo, hi, inset: Math.max(p.srcInset, p.tgtInset), lane: 0, set: (x) => {
+        p.srcVx = x;
+        p.tgtVx = x;
+      } });
+      vByKey.set(key, arr);
+      continue;
+    }
+    if (p.srcVCol === p.tgtVCol && p.srcSide === p.tgtSide) {
+      const lo = Math.min(p.srcPortY, p.tgtPortY);
+      const hi = Math.max(p.srcPortY, p.tgtPortY);
+      const key = `${p.srcVCol}:${p.srcSide}`;
+      const arr = vByKey.get(key) ?? [];
+      arr.push({ lo, hi, inset: Math.max(p.srcInset, p.tgtInset), lane: 0, set: (x) => {
+        p.srcVx = x;
+        p.tgtVx = x;
+      } });
+      vByKey.set(key, arr);
+      continue;
+    }
+    const hBase = hBaseY(p, rowY, grid);
+    const half = hHalfBand(p);
+    pushV(p.srcVCol, p.srcSide, p.srcPortY, hBase, half, p.srcInset, (x) => {
+      p.srcVx = x;
+    });
+    pushV(p.tgtVCol, p.tgtSide, p.tgtPortY, hBase, half, p.tgtInset, (x) => {
+      p.tgtVx = x;
+    });
+  }
+  for (const [key, items] of vByKey.entries()) {
+    const side = key.endsWith(":right") ? "right" : "left";
+    const col = Number(key.slice(0, key.lastIndexOf(":")));
+    const laneCount = allocateLanes(
+      items.map((it) => ({ lo: it.lo, hi: it.hi, set: (l) => {
+        it.lane = l;
+      } }))
+    );
+    const left = vGutterLeft(col, colX, grid);
+    const right = round16(left + UML_COL_GAP);
+    const center = round16((left + right) / 2);
+    const maxBaseGap = Math.max(...items.map((it) => Math.max(V_GUTTER_MARGIN, it.inset + MIN_TERMINAL_STUB)));
+    for (const it of items) {
+      let x;
+      if (side === "right") {
+        const lo = left + maxBaseGap;
+        const hi = center - 1;
+        x = laneCount <= 1 ? lo : lo + it.lane * (hi - lo) / (laneCount - 1);
+      } else {
+        const hi = right - maxBaseGap;
+        const lo = center + 1;
+        x = laneCount <= 1 ? hi : hi - it.lane * (hi - lo) / (laneCount - 1);
+      }
+      it.set(round16(x));
+    }
+  }
+  const usableHalfOf = (kind) => Math.max(0, (kind === "pad-top" ? round16(UML_PADDING / 2) : round16(UML_ROW_GAP / 2)) - 3);
+  const gutterKey = (p) => p.hKind === "pad-top" ? "pad-top" : `row:${p.hRow}`;
+  const gutterMeta = /* @__PURE__ */ new Map();
+  for (const p of plans) {
+    if (p.isSelfLoop) continue;
+    const key = gutterKey(p);
+    if (!gutterMeta.has(key)) gutterMeta.set(key, { base: hBaseY(p, rowY, grid), usableHalf: usableHalfOf(p.hKind) });
+  }
+  const hRunsByKey = /* @__PURE__ */ new Map();
+  const pushRun = (key, run) => {
+    const arr = hRunsByKey.get(key) ?? [];
+    arr.push(run);
+    hRunsByKey.set(key, arr);
+  };
+  const pinStub = (yy, a, b) => {
+    for (const [gk, meta] of gutterMeta.entries()) {
+      if (yy >= meta.base - meta.usableHalf - LANE_EPS && yy <= meta.base + meta.usableHalf + LANE_EPS) {
+        pushRun(gk, { lo: Math.min(a, b), hi: Math.max(a, b), y: yy, set: () => {
+        } });
+      }
+    }
+  };
+  for (const p of plans) {
+    if (p.isSelfLoop) {
+      const sideX = p.srcSide === "right" ? boxEdges(p.srcNode).right : boxEdges(p.srcNode).left;
+      pinStub(p.srcPortY, sideX, p.srcVx);
+      pinStub(p.tgtPortY, sideX, p.tgtVx);
+      continue;
+    }
+    const key = gutterKey(p);
+    if (Math.abs(p.srcVx - p.tgtVx) > LANE_EPS) {
+      pushRun(key, { lo: Math.min(p.srcVx, p.tgtVx), hi: Math.max(p.srcVx, p.tgtVx), y: null, set: (y) => {
+        p.hY = round16(y);
+      } });
+    } else {
+      p.hY = p.srcPortY;
+    }
+    const srcPortX = p.srcSide === "right" ? boxEdges(p.srcNode).right : boxEdges(p.srcNode).left;
+    const tgtPortX = p.tgtSide === "right" ? boxEdges(p.tgtNode).right : boxEdges(p.tgtNode).left;
+    pinStub(p.srcPortY, srcPortX, p.srcVx);
+    pinStub(p.tgtPortY, tgtPortX, p.tgtVx);
+  }
+  for (const [key, runs] of hRunsByKey.entries()) {
+    const meta = gutterMeta.get(key);
+    allocateHorizontal(runs, meta.base, meta.usableHalf);
+  }
+  for (const p of plans) {
+    const srcPort = sidePort(p.srcNode, p.srcSide, p.srcPortY - p.srcNode.cy);
+    const tgtPort = sidePort(p.tgtNode, p.tgtSide, p.tgtPortY - p.tgtNode.cy);
+    if (p.isSelfLoop) {
+      const raw2 = [
+        srcPort,
+        { x: p.srcVx, y: srcPort.y },
+        { x: p.srcVx, y: tgtPort.y },
+        tgtPort
+      ];
+      const portPts2 = simplifyWaypoints(raw2);
+      const pts2 = applyGlyphInsets(portPts2, p.srcInset, p.tgtInset);
+      const edgeId2 = UML_SELF_LOOP_BASE + p.rel.id;
+      elements.push({ edgeId: edgeId2, relId: p.rel.id, points: pts2, kind: "self-loop", title: relTitle(p.rel) });
+      reserveSelfLoopText(p.rel, p, textBoxes);
+      continue;
+    }
+    const raw = [
+      srcPort,
+      { x: p.srcVx, y: srcPort.y },
+      { x: p.srcVx, y: p.hY },
+      { x: p.tgtVx, y: p.hY },
+      { x: p.tgtVx, y: tgtPort.y },
+      tgtPort
+    ];
+    const portPts = simplifyWaypoints(raw);
+    const pts = applyGlyphInsets(portPts, p.srcInset, p.tgtInset);
+    const edgeId = UML_ASSOC_ROUTE_BASE + p.rel.id;
+    elements.push({ edgeId, relId: p.rel.id, points: pts, kind: "route", title: relTitle(p.rel) });
+    reserveRouteText(p.rel, p, hBandBounds(p, rowY, grid), textBoxes);
+  }
+  let maxRight = 0;
+  let maxBottom = 0;
+  for (const node of nodes) {
+    const { right, bottom } = boxEdges(node);
+    if (right > maxRight) maxRight = right;
+    if (bottom > maxBottom) maxBottom = bottom;
+  }
+  for (const el of elements) {
+    for (const pt2 of el.points) {
+      if (pt2.x > maxRight) maxRight = pt2.x;
+      if (pt2.y > maxBottom) maxBottom = pt2.y;
+    }
+  }
+  for (const tb of textBoxes) {
+    if (tb.x + tb.w > maxRight) maxRight = tb.x + tb.w;
+    if (tb.y + tb.h > maxBottom) maxBottom = tb.y + tb.h;
+  }
+  const canvasW = round16(maxRight + UML_PADDING);
+  const canvasH = round16(maxBottom + UML_PADDING);
+  return { nodes, elements, textBoxes, canvasW, canvasH, grid, colX, rowY };
+}
+function reserveRouteText(rel, p, band, out) {
+  const textH = round16(UML_LABEL_FONT * 1.2);
+  const clampY = (y) => round16(Math.max(band.lo + 1, Math.min(y, band.hi - 1 - textH)));
+  const above = clampY(p.hY - textH - 1);
+  const below = clampY(p.hY + 1);
+  const srcX = round16(p.srcVx + 3);
+  const tgtX = round16(p.tgtVx + 3);
+  if (rel.sourceMultiplicity !== null) {
+    out.push(reserveTextBox(rel.id, "src-mult", rel.sourceMultiplicity, srcX, above, "start"));
+  }
+  if (rel.sourceRole !== null) {
+    out.push(reserveTextBox(rel.id, "src-role", rel.sourceRole, srcX, below, "start"));
+  }
+  if (rel.targetMultiplicity !== null) {
+    out.push(reserveTextBox(rel.id, "tgt-mult", rel.targetMultiplicity, tgtX, above, "start"));
+  }
+  if (rel.targetRole !== null) {
+    out.push(reserveTextBox(rel.id, "tgt-role", rel.targetRole, tgtX, below, "start"));
+  }
+  if (rel.label !== null) {
+    const midX = round16((p.srcVx + p.tgtVx) / 2);
+    out.push(reserveTextBox(rel.id, "label", rel.label, midX, above, "middle"));
+  }
+}
+function reserveSelfLoopText(rel, p, out) {
+  const x0 = round16(p.srcVx + 3);
+  const srcY = p.srcPortY;
+  const tgtY = p.tgtPortY;
+  if (rel.sourceMultiplicity !== null) {
+    out.push(reserveTextBox(rel.id, "src-mult", rel.sourceMultiplicity, x0, round16(srcY - UML_LABEL_FONT - 1), "start"));
+  }
+  if (rel.sourceRole !== null) {
+    out.push(reserveTextBox(rel.id, "src-role", rel.sourceRole, x0, round16(srcY + 1), "start"));
+  }
+  if (rel.targetMultiplicity !== null) {
+    out.push(reserveTextBox(rel.id, "tgt-mult", rel.targetMultiplicity, x0, round16(tgtY - UML_LABEL_FONT - 1), "start"));
+  }
+  if (rel.targetRole !== null) {
+    out.push(reserveTextBox(rel.id, "tgt-role", rel.targetRole, x0, round16(tgtY + 1), "start"));
+  }
+  if (rel.label !== null) {
+    out.push(reserveTextBox(rel.id, "label", rel.label, x0, round16((srcY + tgtY) / 2 - UML_LABEL_FONT / 2), "start"));
+  }
+}
+
+// src/uml/svg.ts
+var GLYPH_STROKE6 = "#52525b";
+var LABEL_FILL7 = "#3f3f46";
+var EDGE_INK8 = "#71717a";
+var round17 = (n) => Math.round(n * 100) / 100;
+function emitGlyph(gk, tip, dir) {
+  switch (gk) {
+    case "none":
+      return "";
+    case "open-arrow": {
+      const pts = arrowOpenPoints(tip, dir);
+      return `<polyline points="${pts}" fill="none" stroke="${GLYPH_STROKE6}" stroke-width="1.5"/>`;
+    }
+    case "hollow-triangle": {
+      const pts = trianglePoints(tip, dir);
+      return `<polygon points="${pts}" fill="#fff" stroke="${GLYPH_STROKE6}" stroke-width="1.5"/>`;
+    }
+    case "hollow-diamond": {
+      const pts = diamondPoints(tip, dir);
+      return `<polygon points="${pts}" fill="#fff" stroke="${GLYPH_STROKE6}" stroke-width="1.5"/>`;
+    }
+    case "solid-diamond": {
+      const pts = diamondPoints(tip, dir);
+      return `<polygon points="${pts}" fill="${GLYPH_STROKE6}" stroke="${GLYPH_STROKE6}" stroke-width="1.5"/>`;
+    }
+  }
+}
+function glyphDir(firstPt, secondPt) {
+  const dx = secondPt.x - firstPt.x;
+  const dy = secondPt.y - firstPt.y;
+  if (Math.abs(dx) >= Math.abs(dy)) {
+    return dx >= 0 ? "left" : "right";
+  }
+  return dy >= 0 ? "up" : "down";
+}
+function featureSvg(f, x, y, font) {
+  const prefix = f.visibility !== null ? UML_VIS_GLYPH[f.visibility] + " " : "";
+  const text = prefix + f.text;
+  const baseline = round17(y + font * 0.8);
+  let out = `<text x="${x}" y="${baseline}" font-family="${FONT_FAMILY}" font-size="${font}" fill="${LABEL_FILL7}">${xmlEscape(text)}</text>`;
+  if (f.isStatic) {
+    const lineY = round17(baseline + 1);
+    const approxW = round17(text.length * font * 0.6);
+    out += `<line x1="${x}" y1="${lineY}" x2="${round17(x + approxW)}" y2="${lineY}" stroke="${LABEL_FILL7}" stroke-width="0.8"/>`;
+  }
+  return out;
+}
+function boxSvg2(node, cls) {
+  const left = round17(node.cx - node.boxW / 2);
+  const top = round17(node.cy - node.boxH / 2);
+  const metrics = node.metrics;
+  const pieces = [];
+  pieces.push(`<title>${xmlEscape(node.title)}</title>`);
+  pieces.push(
+    `<rect x="${left}" y="${top}" width="${node.boxW}" height="${node.boxH}" rx="2" fill="#fff" stroke="${GLYPH_STROKE6}" stroke-width="1.5"/>`
+  );
+  for (const dy of metrics.dividerYs) {
+    const y = round17(top + dy);
+    pieces.push(
+      `<line x1="${left}" y1="${y}" x2="${round17(left + node.boxW)}" y2="${y}" stroke="${GLYPH_STROKE6}" stroke-width="0.75"/>`
+    );
+  }
+  const compartment0 = metrics.rows[0];
+  const textX = round17(left + node.boxW / 2);
+  let lineIdx = 0;
+  if (cls.stereotype !== null) {
+    const stereoY = round17(top + compartment0.top + lineIdx * UML_LINE_H + UML_NAME_FONT * 0.8);
+    pieces.push(
+      `<text x="${textX}" y="${stereoY}" font-family="${FONT_FAMILY}" font-size="${UML_NAME_FONT}" fill="${LABEL_FILL7}" text-anchor="middle">${xmlEscape(cls.stereotype)}</text>`
+    );
+    lineIdx++;
+  }
+  const nameY = round17(top + compartment0.top + lineIdx * UML_LINE_H + UML_NAME_FONT * 0.8);
+  const nameStyle = cls.isAbstract ? ` font-style="italic"` : "";
+  const nameText = metrics.rows[0].lines[lineIdx] ?? "";
+  pieces.push(
+    `<text x="${textX}" y="${nameY}" font-family="${FONT_FAMILY}" font-size="${UML_NAME_FONT}" fill="${LABEL_FILL7}" text-anchor="middle"${nameStyle}>${xmlEscape(nameText)}</text>`
+  );
+  const attrCompartment = metrics.rows[1];
+  const attrX = round17(left + UML_BOX_PAD_X);
+  for (let i = 0; i < cls.attributes.length; i++) {
+    const f = cls.attributes[i];
+    const fy = round17(top + attrCompartment.top + i * UML_LINE_H);
+    pieces.push(featureSvg(f, attrX, fy, UML_FEAT_FONT));
+  }
+  const opCompartment = metrics.rows[2];
+  const opX = round17(left + UML_BOX_PAD_X);
+  for (let i = 0; i < cls.operations.length; i++) {
+    const f = cls.operations[i];
+    const fy = round17(top + opCompartment.top + i * UML_LINE_H);
+    pieces.push(featureSvg(f, opX, fy, UML_FEAT_FONT));
+  }
+  return `<g data-node-id="c${node.classId}">${pieces.join("")}</g>`;
+}
+function edgeSvg(el, rel, textBoxes) {
+  const glyphs = RELATION_GLYPHS[rel.kind];
+  const isDashed = glyphs.line === "dashed";
+  const stroke = isDashed ? EDGE_STROKE.distant : { width: 1.5, opacity: 0.7 };
+  const strokeAttrs = isDashed ? `stroke="${EDGE_INK8}" stroke-width="${stroke.width}" stroke-dasharray="4,4" opacity="${stroke.opacity}"` : `stroke="${EDGE_INK8}" stroke-width="${stroke.width}" opacity="${stroke.opacity}"`;
+  const pts = el.points;
+  const pieces = [`<title>${xmlEscape(el.title)}</title>`];
+  if (pts.length >= 2) {
+    pieces.push(`<polyline points="${pts.map((p) => `${p.x},${p.y}`).join(" ")}" fill="none" ${strokeAttrs}/>`);
+    if (glyphs.sourceEnd !== "none") {
+      const tip = pts[0];
+      const next = pts[1];
+      const dir = glyphDir(tip, next);
+      pieces.push(emitGlyph(glyphs.sourceEnd, tip, dir));
+    }
+    if (glyphs.targetEnd !== "none") {
+      const tip = pts[pts.length - 1];
+      const prev = pts[pts.length - 2];
+      const dir = glyphDir(tip, prev);
+      pieces.push(emitGlyph(glyphs.targetEnd, tip, dir));
+    }
+    for (const tb of textBoxes) {
+      if (tb.relId !== rel.id) continue;
+      const italic = tb.slot === "src-role" || tb.slot === "tgt-role" ? ` font-style="italic"` : "";
+      const anchor = tb.anchor === "middle" ? ` text-anchor="middle"` : "";
+      const drawX = tb.anchor === "middle" ? round17(tb.x + tb.w / 2) : tb.x;
+      const baseline = round17(tb.y + UML_LABEL_FONT * 0.8);
+      pieces.push(
+        `<text x="${drawX}" y="${baseline}" font-family="${FONT_FAMILY}" font-size="${UML_LABEL_FONT}" fill="${LABEL_FILL7}"${anchor}${italic}>${xmlEscape(tb.text)}</text>`
+      );
+    }
+  }
+  return `<g data-edge-id="${el.edgeId}">${pieces.join("")}</g>`;
+}
+function makeSwatchLine(isDashed) {
+  return (x, y) => {
+    const attrs = isDashed ? `stroke="${EDGE_INK8}" stroke-width="1.5" stroke-dasharray="4,4"` : `stroke="${EDGE_INK8}" stroke-width="1.5"`;
+    return `<line x1="${x}" y1="${y}" x2="${x + LEGEND_SWATCH_W}" y2="${y}" ${attrs}/>`;
+  };
+}
+function umlLayoutSvg(layout, input, opts = {}) {
+  const labels = opts.labels ?? UML_SVG_LABELS_EN;
+  const showLegend = opts.legend !== false;
+  const classMap = new Map(input.classes.map((c) => [c.id, c]));
+  const relMap = new Map(input.relationships.map((r2) => [r2.id, r2]));
+  const parts = [];
+  for (const node of layout.nodes) {
+    const cls = classMap.get(node.classId);
+    parts.push(boxSvg2(node, cls));
+  }
+  for (const el of layout.elements) {
+    const rel = relMap.get(el.relId);
+    if (!rel) continue;
+    parts.push(edgeSvg(el, rel, layout.textBoxes));
+  }
+  let canvasW = layout.canvasW;
+  let canvasH = layout.canvasH;
+  if (showLegend) {
+    const usedKinds = new Set(
+      input.relationships.map((r2) => r2.kind)
+    );
+    const entries = [];
+    for (const kind of UML_RELATIONSHIPS) {
+      if (!usedKinds.has(kind)) continue;
+      const isDashed = RELATION_GLYPHS[kind].line === "dashed";
+      entries.push({
+        swatch: makeSwatchLine(isDashed),
+        label: labels.legend[kind]
+      });
+    }
+    if (entries.length > 0) {
+      const block = legendBlock(entries, canvasH);
+      parts.push(block.svg);
+      canvasH = block.height;
+      canvasW = Math.max(canvasW, block.width);
+    }
+  }
+  const roundedW = round17(canvasW);
+  const roundedH = round17(canvasH);
+  return `<svg xmlns="http://www.w3.org/2000/svg" width="${roundedW}" height="${roundedH}" viewBox="0 0 ${roundedW} ${roundedH}" role="img" aria-label="${xmlEscape(labels.ariaLabel)}">` + parts.join("") + `</svg>`;
+}
+
+// src/uml/render.ts
+function umlSvg(input, opts = {}) {
+  const layout = computeUmlLayout(input, opts.titleLabels ?? UML_TITLE_LABELS_EN);
+  const svg = umlLayoutSvg(layout, input, opts);
+  return { svg, layout };
+}
+
 exports.ANNOTATION_INK = ANNOTATION_INK;
 exports.CHAR_W = CHAR_W;
 exports.CODE_FONT = CODE_FONT;
@@ -4764,6 +6577,12 @@ exports.FishboneValidationError = FishboneValidationError;
 exports.GATE_TYPES = GATE_TYPES;
 exports.GENOGRAM_SVG_LABELS_EN = GENOGRAM_SVG_LABELS_EN;
 exports.GENOGRAM_TITLE_LABELS_EN = GENOGRAM_TITLE_LABELS_EN;
+exports.GLYPH_ARROW_HALF = GLYPH_ARROW_HALF;
+exports.GLYPH_ARROW_LEN = GLYPH_ARROW_LEN;
+exports.GLYPH_DIAMOND_HALF = GLYPH_DIAMOND_HALF;
+exports.GLYPH_DIAMOND_LEN = GLYPH_DIAMOND_LEN;
+exports.GLYPH_TRI_HALF = GLYPH_TRI_HALF;
+exports.GLYPH_TRI_LEN = GLYPH_TRI_LEN;
 exports.KINSHIP_EN = KINSHIP_EN;
 exports.LABEL_FONT = LABEL_FONT;
 exports.LABEL_GAP = LABEL_GAP;
@@ -4815,16 +6634,63 @@ exports.PHYLO_SCALEBAR_ID = PHYLO_SCALEBAR_ID;
 exports.PHYLO_SUPPORT_FONT = PHYLO_SUPPORT_FONT;
 exports.PHYLO_SVG_LABELS_EN = PHYLO_SVG_LABELS_EN;
 exports.PHYLO_TITLE_LABELS_EN = PHYLO_TITLE_LABELS_EN;
+exports.PRISMA_BAND_LABEL_W = PRISMA_BAND_LABEL_W;
+exports.PRISMA_BOX_KINDS = PRISMA_BOX_KINDS;
+exports.PRISMA_BOX_PAD_X = PRISMA_BOX_PAD_X;
+exports.PRISMA_BOX_PAD_Y = PRISMA_BOX_PAD_Y;
+exports.PRISMA_COLUMNS = PRISMA_COLUMNS;
+exports.PRISMA_COL_GAP = PRISMA_COL_GAP;
+exports.PRISMA_CORRIDOR = PRISMA_CORRIDOR;
+exports.PRISMA_COUNT_FONT = PRISMA_COUNT_FONT;
+exports.PRISMA_EXCL_ARROW_BASE = PRISMA_EXCL_ARROW_BASE;
+exports.PRISMA_EXCL_GAP = PRISMA_EXCL_GAP;
+exports.PRISMA_FLOW_ARROW_BASE = PRISMA_FLOW_ARROW_BASE;
+exports.PRISMA_HEADING_FONT = PRISMA_HEADING_FONT;
+exports.PRISMA_LINE_H = PRISMA_LINE_H;
+exports.PRISMA_MERGE_ARROW_BASE = PRISMA_MERGE_ARROW_BASE;
+exports.PRISMA_MIN_BOX_W = PRISMA_MIN_BOX_W;
+exports.PRISMA_PADDING = PRISMA_PADDING;
+exports.PRISMA_PHASES = PRISMA_PHASES;
+exports.PRISMA_SVG_LABELS_EN = PRISMA_SVG_LABELS_EN;
+exports.PRISMA_TITLE_LABELS_EN = PRISMA_TITLE_LABELS_EN;
 exports.PROMOTED_REL_ID_BASE = PROMOTED_REL_ID_BASE;
 exports.PedigreeValidationError = PedigreeValidationError;
 exports.PhyloValidationError = PhyloValidationError;
+exports.PrismaValidationError = PrismaValidationError;
 exports.QUALITY_LEXICON_EN = QUALITY_LEXICON_EN;
+exports.RELATION_GLYPHS = RELATION_GLYPHS;
+exports.UML_ASSOC_ROUTE_BASE = UML_ASSOC_ROUTE_BASE;
+exports.UML_BOX_PAD_X = UML_BOX_PAD_X;
+exports.UML_BOX_PAD_Y = UML_BOX_PAD_Y;
+exports.UML_COL_GAP = UML_COL_GAP;
+exports.UML_FEAT_FONT = UML_FEAT_FONT;
+exports.UML_GLYPH_BASE = UML_GLYPH_BASE;
+exports.UML_LABEL_FONT = UML_LABEL_FONT;
+exports.UML_LINE_H = UML_LINE_H;
+exports.UML_MIN_BOX_W = UML_MIN_BOX_W;
+exports.UML_NAME_FONT = UML_NAME_FONT;
+exports.UML_PADDING = UML_PADDING;
+exports.UML_PORT_PITCH = UML_PORT_PITCH;
+exports.UML_RELATIONSHIPS = UML_RELATIONSHIPS;
+exports.UML_ROW_GAP = UML_ROW_GAP;
+exports.UML_SELF_LOOP_BASE = UML_SELF_LOOP_BASE;
+exports.UML_SELF_LOOP_W = UML_SELF_LOOP_W;
+exports.UML_SEP_PAD = UML_SEP_PAD;
+exports.UML_SVG_LABELS_EN = UML_SVG_LABELS_EN;
+exports.UML_TITLE_LABELS_EN = UML_TITLE_LABELS_EN;
+exports.UML_VISIBILITIES = UML_VISIBILITIES;
+exports.UML_VIS_GLYPH = UML_VIS_GLYPH;
 exports.UNION_NOTATION = UNION_NOTATION;
 exports.UNION_REL_ID_BASE = UNION_REL_ID_BASE;
 exports.UNION_STATUSES = UNION_STATUSES;
+exports.UmlValidationError = UmlValidationError;
+exports.allocateLanes = allocateLanes;
 exports.annotationDot = annotationDot;
 exports.annotationSwatch = annotationSwatch;
 exports.annotationTick = annotationTick;
+exports.arrowFilledPoints = arrowFilledPoints;
+exports.arrowOpenPoints = arrowOpenPoints;
+exports.bandStack = bandStack;
 exports.clampLabel = clampLabel;
 exports.classifyRelationshipType = classifyRelationshipType;
 exports.computeFaultTreeLayout = computeFaultTreeLayout;
@@ -4832,6 +6698,9 @@ exports.computeGenogramLayout = computeGenogramLayout;
 exports.computeOrgChartLayout = computeOrgChartLayout;
 exports.computePedigreeLayout = computePedigreeLayout;
 exports.computePhyloLayout = computePhyloLayout;
+exports.computePrismaLayout = computePrismaLayout;
+exports.computeUmlLayout = computeUmlLayout;
+exports.diamondPoints = diamondPoints;
 exports.ecomapSvg = ecomapSvg;
 exports.estimateTextWidth = estimateTextWidth;
 exports.faultTreeIssues = faultTreeIssues;
@@ -4840,13 +6709,16 @@ exports.faultTreeSvg = faultTreeSvg;
 exports.fishboneSvg = fishboneSvg;
 exports.genogramLayoutSvg = genogramLayoutSvg;
 exports.genogramSvg = genogramSvg;
+exports.glyphInset = glyphInset;
 exports.latestUnionPerPair = latestUnionPerPair;
 exports.legendBlock = legendBlock;
+exports.measureCompartmentBox = measureCompartmentBox;
 exports.niceScaleStep = niceScaleStep;
 exports.normalizeText = normalizeText;
 exports.orgChartIssues = orgChartIssues;
 exports.orgChartLayoutSvg = orgChartLayoutSvg;
 exports.orgChartSvg = orgChartSvg;
+exports.packGrid = packGrid;
 exports.packSubtree = packSubtree;
 exports.pathData = pathData;
 exports.pedigreeIssues = pedigreeIssues;
@@ -4855,13 +6727,24 @@ exports.pedigreeSvg = pedigreeSvg;
 exports.phyloIssues = phyloIssues;
 exports.phyloLayoutSvg = phyloLayoutSvg;
 exports.phyloSvg = phyloSvg;
+exports.prismaIssues = prismaIssues;
+exports.prismaLayoutSvg = prismaLayoutSvg;
+exports.prismaSvg = prismaSvg;
 exports.qualityLineStyle = qualityLineStyle;
 exports.relationshipTypeTokens = relationshipTypeTokens;
 exports.romanNumeral = romanNumeral;
+exports.sideCapacity = sideCapacity;
+exports.sideCapacityIssue = sideCapacityIssue;
+exports.trianglePoints = trianglePoints;
+exports.umlIssues = umlIssues;
+exports.umlLayoutSvg = umlLayoutSvg;
+exports.umlSvg = umlSvg;
 exports.validateFaultTree = validateFaultTree;
 exports.validateOrgChart = validateOrgChart;
 exports.validatePedigree = validatePedigree;
 exports.validatePhylo = validatePhylo;
+exports.validatePrisma = validatePrisma;
+exports.validateUml = validateUml;
 exports.wrapLabel = wrapLabel;
 exports.wrapLabelBalanced = wrapLabelBalanced;
 exports.xmlEscape = xmlEscape;