compasso 0.1.0 → 0.3.0

package/dist/index.cjs

@@ -5,6 +5,35 @@ function xmlEscape(text) {
   return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
 }
 
+// src/core/roman.ts
+var ROMAN_TABLE = [
+  [1e3, "M"],
+  [900, "CM"],
+  [500, "D"],
+  [400, "CD"],
+  [100, "C"],
+  [90, "XC"],
+  [50, "L"],
+  [40, "XL"],
+  [10, "X"],
+  [9, "IX"],
+  [5, "V"],
+  [4, "IV"],
+  [1, "I"]
+];
+function romanNumeral(n) {
+  if (!Number.isInteger(n) || n < 1 || n > 3999) return String(n);
+  let remaining = n;
+  let out = "";
+  for (const [value, symbol] of ROMAN_TABLE) {
+    while (remaining >= value) {
+      out += symbol;
+      remaining -= value;
+    }
+  }
+  return out;
+}
+
 // src/core/geometry.ts
 function pathData(points) {
   return points.map((p, i) => `${i === 0 ? "M" : "L"} ${p.x} ${p.y}`).join(" ");
@@ -15,19 +44,27 @@ var CHAR_W = 0.6;
 function estimateTextWidth(text, fontPx) {
   return text.length * fontPx * CHAR_W;
 }
-function wrapLabel(label, perLine) {
+function wrapLabel(label, perLine, maxLines = 2) {
   if (label.length <= perLine) return [label];
   const cap = (s) => s.length > perLine ? s.slice(0, Math.max(1, perLine - 1)) + "\u2026" : s;
-  let line1 = "";
-  let line2 = "";
+  const lines = [""];
   for (const word of label.split(/\s+/)) {
-    if (line2 === "" && (line1 === "" || (line1 + " " + word).length <= perLine)) {
-      line1 = line1 === "" ? word : `${line1} ${word}`;
+    const last = lines.length - 1;
+    const current = lines[last];
+    if (current === "" || (current + " " + word).length <= perLine) {
+      lines[last] = current === "" ? word : `${current} ${word}`;
+    } else if (lines.length < maxLines) {
+      lines.push(word);
     } else {
-      line2 = line2 === "" ? word : `${line2} ${word}`;
+      lines[last] = `${current} ${word}`;
     }
   }
-  return line2 === "" ? [cap(line1)] : [cap(line1), cap(line2)];
+  if (lines.length > 1 && lines[lines.length - 1] === "") lines.pop();
+  return lines.map(cap);
+}
+function wrapLabelBalanced(label, maxLines) {
+  const perLine = Math.min(26, Math.max(14, Math.ceil(label.length / 2) + 2));
+  return wrapLabel(label, perLine, maxLines);
 }
 function clampLabel(label, maxChars) {
   if (maxChars === void 0 || label.length <= maxChars) return label;
@@ -35,6 +72,28 @@ function clampLabel(label, maxChars) {
 }
 var FONT_FAMILY = "Helvetica, Arial, sans-serif";
 
+// src/core/legend.ts
+var LEGEND_ROW_H = 18;
+var LEGEND_PAD = 16;
+var LEGEND_SWATCH_W = 22;
+var LEGEND_GAP = 14;
+var LEGEND_FONT = 11;
+var LEGEND_TEXT_FILL = "#52525b";
+function legendBlock(entries, startY) {
+  if (entries.length === 0) return { svg: "", width: 0, height: startY };
+  const rows = entries.map((entry, i) => {
+    const rowCenterY = startY + i * LEGEND_ROW_H + LEGEND_ROW_H / 2;
+    const textX = LEGEND_PAD + LEGEND_SWATCH_W + LEGEND_GAP;
+    return entry.swatch(LEGEND_PAD, rowCenterY) + `<text x="${textX}" y="${rowCenterY + LEGEND_FONT * 0.32}" font-family="${FONT_FAMILY}" font-size="${LEGEND_FONT}" fill="${LEGEND_TEXT_FILL}">${xmlEscape(entry.label)}</text>`;
+  });
+  const widestLabel = entries.reduce((m, e) => Math.max(m, estimateTextWidth(e.label, LEGEND_FONT)), 0);
+  return {
+    svg: `<g data-compasso-legend="true">${rows.join("")}</g>`,
+    width: LEGEND_PAD + LEGEND_SWATCH_W + LEGEND_GAP + widestLabel + LEGEND_PAD,
+    height: startY + entries.length * LEGEND_ROW_H + LEGEND_PAD / 2
+  };
+}
+
 // src/core/stroke.ts
 var EDGE_STROKE = {
   plain: { width: 1.5, dash: null, opacity: 0.6 },
@@ -206,14 +265,6 @@ function shapeForSex(sex) {
   if (sex === "female") return "circle";
   return "diamond";
 }
-function wrapNodeLabel(displayLabel) {
-  const perLine = Math.min(26, Math.max(14, Math.ceil(displayLabel.length / 2) + 2));
-  return wrapLabel(displayLabel, perLine);
-}
-function clampLabel2(label, maxChars) {
-  if (maxChars === void 0 || label.length <= maxChars) return label;
-  return label.slice(0, Math.max(1, maxChars - 1)) + "\u2026";
-}
 var STUB_OFFSETS = [9, -9, 18, -18, 26, -26];
 var ARRIVAL_HALF = NODE_SIZE / 2 - 8;
 function stubOffset(slot) {
@@ -437,7 +488,7 @@ function computeGenogramLayout(people, unions, parentLinks, relationships, opts
   }
   const measured = /* @__PURE__ */ new Map();
   for (const p of people) {
-    const lines = wrapNodeLabel(clampLabel2(p.label, opts.maxLabelChars));
+    const lines = wrapLabelBalanced(clampLabel(p.label, opts.maxLabelChars));
     const contentW = Math.max(NODE_SIZE, lines.reduce((m, l) => Math.max(m, estimateTextWidth(l, LABEL_FONT)), 0));
     measured.set(p.id, { person: p, lines, contentW });
   }
@@ -1001,11 +1052,6 @@ var STRUCT_WIDTH = 1.5;
 var STRUCT_OPACITY = 0.75;
 var DOTTED_DASH = [2, 3];
 var DOTTED_OPACITY = 0.55;
-var LEGEND_ROW_H = 18;
-var LEGEND_PAD = 16;
-var LEGEND_SWATCH_W = 22;
-var LEGEND_GAP = 14;
-var LEGEND_FONT = 11;
 function glyphSvg(shape, cx, cy, half) {
   const stroke = `fill="transparent" stroke="${GLYPH_STROKE}" stroke-width="2"`;
   if (shape === "square") {
@@ -1141,17 +1187,11 @@ function genogramLayoutSvg(layout, opts = {}) {
         label: labels.isolated
       });
     }
-    if (entries.length > 0) {
-      const startY = layout.height;
-      const rows = entries.map((entry, i) => {
-        const rowCenterY = startY + i * LEGEND_ROW_H + LEGEND_ROW_H / 2;
-        const textX = LEGEND_PAD + LEGEND_SWATCH_W + LEGEND_GAP;
-        return entry.swatch(LEGEND_PAD, rowCenterY) + `<text x="${textX}" y="${rowCenterY + LEGEND_FONT * 0.32}" font-family="${FONT_FAMILY}" font-size="${LEGEND_FONT}" fill="${GLYPH_STROKE}">${xmlEscape(entry.label)}</text>`;
-      });
-      parts.push(`<g data-compasso-legend="true">${rows.join("")}</g>`);
-      const widestLabel = entries.reduce((m, e) => Math.max(m, estimateTextWidth(e.label, LEGEND_FONT)), 0);
-      width = Math.max(width, LEGEND_PAD + LEGEND_SWATCH_W + LEGEND_GAP + widestLabel + LEGEND_PAD);
-      height = startY + entries.length * LEGEND_ROW_H + LEGEND_PAD / 2;
+    const block = legendBlock(entries, layout.height);
+    if (block.svg !== "") {
+      parts.push(block.svg);
+      width = Math.max(width, block.width);
+      height = block.height;
     }
   }
   return `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 ${width} ${height}" width="${width}" height="${height}" role="img" aria-label="${xmlEscape(labels.ariaLabel)}">` + parts.join("") + `</svg>`;
@@ -1228,16 +1268,7 @@ var SINGLE_RING_MAX = 8;
 var NODE_STROKE = "#52525b";
 var LABEL_FILL = "#3f3f46";
 var EDGE_INK2 = "#71717a";
-var LEGEND_ROW_H2 = 18;
-var LEGEND_PAD2 = 16;
-var LEGEND_SWATCH_W2 = 22;
-var LEGEND_GAP2 = 14;
-var LEGEND_FONT2 = 11;
 var round = (n) => Math.round(n * 100) / 100;
-function wrapTieLabel(displayLabel) {
-  const perLine = Math.min(26, Math.max(14, Math.ceil(displayLabel.length / 2) + 2));
-  return wrapLabel(displayLabel, perLine);
-}
 function arrowHead(tipX, tipY, ux, uy, opacity) {
   const LEN = 9;
   const HALF_W = 4.5;
@@ -1256,7 +1287,7 @@ function ecomapSvg(input, opts = {}) {
   const fontSize = opts.fontSize ?? 12;
   const labels = opts.labels ?? ECOMAP_LABELS_EN;
   const sats = [...input.ties].sort((a, b) => a.id - b.id).map((tie) => {
-    const lines = wrapTieLabel(clampLabel(tie.label, opts.maxLabelChars));
+    const lines = wrapLabelBalanced(clampLabel(tie.label, opts.maxLabelChars));
     const w2 = Math.max(...lines.map((l) => estimateTextWidth(l, fontSize))) + NODE_PAD_X * 2;
     const h2 = lines.length * LINE_H + NODE_PAD_Y * 2;
     return {
@@ -1270,7 +1301,7 @@ function ecomapSvg(input, opts = {}) {
       style: qualityLineStyle(tie.quality, opts.qualityLexicon)
     };
   });
-  const centerLines = wrapTieLabel(input.centerLabel);
+  const centerLines = wrapLabelBalanced(input.centerLabel);
   const centerR = Math.max(
     CENTER_MIN_R,
     Math.max(...centerLines.map((l) => estimateTextWidth(l, fontSize))) / 2 + 12,
@@ -1368,7 +1399,7 @@ function ecomapSvg(input, opts = {}) {
     const entries = [];
     if (sats.some((s) => s.style === "plain")) {
       entries.push({
-        swatch: (x, y) => `<line x1="${x}" y1="${y}" x2="${x + LEGEND_SWATCH_W2}" y2="${y}" stroke="${EDGE_INK2}" stroke-width="${EDGE_STROKE.plain.width}" stroke-opacity="${EDGE_STROKE.plain.opacity}"/>`,
+        swatch: (x, y) => `<line x1="${x}" y1="${y}" x2="${x + LEGEND_SWATCH_W}" y2="${y}" stroke="${EDGE_INK2}" stroke-width="${EDGE_STROKE.plain.width}" stroke-opacity="${EDGE_STROKE.plain.opacity}"/>`,
         label: labels.neutralTie
       });
     }
@@ -1378,64 +1409,2600 @@ function ecomapSvg(input, opts = {}) {
       const ink = EDGE_STROKE[style];
       const dashAttr = ink.dash === null ? "" : ` stroke-dasharray="${ink.dash[0]} ${ink.dash[1]}"`;
       entries.push({
-        swatch: (x, y) => `<line x1="${x}" y1="${y}" x2="${x + LEGEND_SWATCH_W2}" y2="${y}" stroke="${EDGE_INK2}" stroke-width="${ink.width}" stroke-opacity="${ink.opacity}"${dashAttr}/>`,
+        swatch: (x, y) => `<line x1="${x}" y1="${y}" x2="${x + LEGEND_SWATCH_W}" y2="${y}" stroke="${EDGE_INK2}" stroke-width="${ink.width}" stroke-opacity="${ink.opacity}"${dashAttr}/>`,
         label: labels.bondStyles[style]
       });
     }
     if (sats.some((s) => s.tie.direction !== null)) {
       entries.push({
-        swatch: (x, y) => `<line x1="${x}" y1="${y}" x2="${x + LEGEND_SWATCH_W2 - 8}" y2="${y}" stroke="${EDGE_INK2}" stroke-width="1.5" stroke-opacity="0.75"/>` + arrowHead(x + LEGEND_SWATCH_W2, y, 1, 0, 0.75),
+        swatch: (x, y) => `<line x1="${x}" y1="${y}" x2="${x + LEGEND_SWATCH_W - 8}" y2="${y}" stroke="${EDGE_INK2}" stroke-width="1.5" stroke-opacity="0.75"/>` + arrowHead(x + LEGEND_SWATCH_W, y, 1, 0, 0.75),
         label: labels.direction
       });
     }
     if (entries.length > 0) {
-      const startY = height;
-      const rows = entries.map((entry, i) => {
-        const rowCenterY = startY + i * LEGEND_ROW_H2 + LEGEND_ROW_H2 / 2;
-        const textX = LEGEND_PAD2 + LEGEND_SWATCH_W2 + LEGEND_GAP2;
-        return entry.swatch(LEGEND_PAD2, rowCenterY) + `<text x="${textX}" y="${rowCenterY + LEGEND_FONT2 * 0.32}" font-family="${FONT_FAMILY}" font-size="${LEGEND_FONT2}" fill="${NODE_STROKE}">${xmlEscape(entry.label)}</text>`;
+      const block = legendBlock(entries, height);
+      parts.push(block.svg);
+      width = Math.max(width, block.width);
+      height = block.height;
+    }
+  }
+  const w = Math.ceil(width);
+  const h = Math.ceil(height);
+  return `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 ${w} ${h}" width="${w}" height="${h}" role="img" aria-label="${xmlEscape(labels.ariaLabel)}">` + parts.join("") + `</svg>`;
+}
+
+// src/fault-tree/types.ts
+var FAULT_TREE_EVENT_KINDS = [
+  "intermediate",
+  "basic",
+  "undeveloped",
+  "house",
+  "conditioning",
+  "transfer"
+];
+var GATE_TYPES = ["and", "or", "xor", "inhibit", "vote"];
+
+// src/fault-tree/labels.ts
+var FAULT_TREE_TITLE_LABELS_EN = {
+  gates: {
+    and: "AND gate",
+    or: "OR gate",
+    xor: "Exclusive-OR gate",
+    inhibit: "Inhibit gate",
+    vote: "Voting gate"
+  },
+  condition: "condition"
+};
+var FAULT_TREE_SVG_LABELS_EN = {
+  events: {
+    intermediate: "Intermediate event",
+    basic: "Basic event",
+    undeveloped: "Undeveloped event",
+    house: "External event (normally occurs)",
+    conditioning: "Conditioning event",
+    transfer: "Transfer (developed elsewhere)"
+  },
+  gates: {
+    and: "AND gate (all inputs)",
+    or: "OR gate (any input)",
+    xor: "Exclusive-OR gate (exactly one input)",
+    inhibit: "INHIBIT gate (input under condition)",
+    vote: "Voting gate (k of n)"
+  },
+  ariaLabel: "Fault tree"
+};
+
+// src/fault-tree/validate.ts
+var FaultTreeValidationError = class extends Error {
+  issues;
+  constructor(issues) {
+    super(`invalid fault tree: ${issues.map((i) => i.message).join("; ")}`);
+    this.name = "FaultTreeValidationError";
+    this.issues = issues;
+  }
+};
+function listIds(ids) {
+  if (ids.length === 1) return String(ids[0]);
+  return `${ids.slice(0, -1).join(", ")} and ${ids[ids.length - 1]}`;
+}
+function sortIssues(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 faultTreeIssues(input) {
+  if (input.events.length === 0 && input.gates.length === 0) return [];
+  const issues = [];
+  const push = (code, message) => {
+    issues.push({ code, message });
+  };
+  const eventById = /* @__PURE__ */ new Map();
+  const dupEventIds = /* @__PURE__ */ new Set();
+  for (const e of input.events) {
+    if (eventById.has(e.id)) dupEventIds.add(e.id);
+    else eventById.set(e.id, e);
+  }
+  for (const id of [...dupEventIds].sort((a, b) => a - b)) {
+    push("duplicate-id", `duplicate event id ${id}`);
+  }
+  const gateById = /* @__PURE__ */ new Map();
+  const dupGateIds = /* @__PURE__ */ new Set();
+  for (const g of input.gates) {
+    if (gateById.has(g.id)) dupGateIds.add(g.id);
+    else gateById.set(g.id, g);
+  }
+  for (const id of [...dupGateIds].sort((a, b) => a - b)) {
+    push("duplicate-id", `duplicate gate id ${id}`);
+  }
+  if (issues.length > 0) {
+    return sortIssues(issues);
+  }
+  const gates = [...gateById.values()].sort((a, b) => a.id - b.id);
+  const top = eventById.get(input.topId);
+  if (top === void 0 || top.kind !== "intermediate") {
+    push("top-not-intermediate", `topId ${input.topId} is not an intermediate event`);
+  }
+  const conditioningAsInput = /* @__PURE__ */ new Set();
+  for (const g of gates) {
+    const out = eventById.get(g.eventId);
+    if (out !== void 0 && out.kind === "transfer") {
+      push("transfer-with-gate", `transfer event ${g.eventId} cannot have a gate`);
+    } else if (out === void 0 || out.kind !== "intermediate") {
+      push("gate-on-non-intermediate", `gate ${g.id} resolves non-intermediate event ${g.eventId}`);
+    }
+    if (g.type === "inhibit") {
+      if (g.inputIds.length !== 1) push("gate-arity", `inhibit gate ${g.id} needs exactly 1 input`);
+    } else if (g.inputIds.length < 2) {
+      push("gate-arity", `${g.type} gate ${g.id} needs \u22652 inputs`);
+    }
+    if (g.type === "vote" && (!Number.isInteger(g.k) || g.k < 1 || g.k > g.inputIds.length)) {
+      push("vote-threshold", `vote gate ${g.id}: k=${g.k} of ${g.inputIds.length}`);
+    }
+    if (g.type === "inhibit") {
+      const cond = eventById.get(g.conditionId);
+      if (cond === void 0 || cond.kind !== "conditioning") {
+        push("inhibit-condition", `inhibit gate ${g.id} conditionId ${g.conditionId} is not a conditioning event`);
+      }
+    }
+    for (const inputId of g.inputIds) {
+      const child = eventById.get(inputId);
+      if (child === void 0) {
+        push("unknown-input", `gate ${g.id} input ${inputId} is not a declared event`);
+        continue;
+      }
+      if (inputId === input.topId) push("top-as-input", `top event ${input.topId} is used as a gate input`);
+      if (child.kind === "conditioning") conditioningAsInput.add(inputId);
+    }
+  }
+  for (const id of [...conditioningAsInput].sort((a, b) => a - b)) {
+    push("conditioning-as-input", `conditioning event ${id} used as a gate input`);
+  }
+  const gatesByEvent = /* @__PURE__ */ new Map();
+  for (const g of gates) {
+    const arr = gatesByEvent.get(g.eventId) ?? [];
+    arr.push(g.id);
+    gatesByEvent.set(g.eventId, arr);
+  }
+  for (const [eventId, gateIds] of [...gatesByEvent.entries()].sort((a, b) => a[0] - b[0])) {
+    if (gateIds.length > 1) {
+      push("event-with-two-gates", `event ${eventId} is resolved by gates ${listIds(gateIds.sort((a, b) => a - b))}`);
+    }
+  }
+  for (const e of [...eventById.values()].sort((a, b) => a.id - b.id)) {
+    if (e.kind === "intermediate" && !gatesByEvent.has(e.id)) {
+      push("event-without-gate", `intermediate event ${e.id} has no gate \u2014 declare it kind "undeveloped" instead`);
+    }
+  }
+  const intermediateRefs = /* @__PURE__ */ new Map();
+  for (const g of gates) {
+    for (const inputId of g.inputIds) {
+      if (eventById.get(inputId)?.kind !== "intermediate") continue;
+      const arr = intermediateRefs.get(inputId) ?? [];
+      arr.push(g.id);
+      intermediateRefs.set(inputId, arr);
+    }
+  }
+  for (const [eventId, gateIds] of [...intermediateRefs.entries()].sort((a, b) => a[0] - b[0])) {
+    if (gateIds.length > 1) {
+      push(
+        "intermediate-reused",
+        `intermediate event ${eventId} feeds gates ${listIds(gateIds.sort((a, b) => a - b))} \u2014 repeat it via a "transfer" event`
+      );
+    }
+  }
+  const GRAPH_BLOCKING = /* @__PURE__ */ new Set([
+    "duplicate-id",
+    "unknown-input",
+    "gate-on-non-intermediate",
+    "transfer-with-gate",
+    "event-with-two-gates",
+    "inhibit-condition",
+    "top-not-intermediate"
+  ]);
+  if (!issues.some((i) => GRAPH_BLOCKING.has(i.code))) {
+    const gateOf = (eventId) => gates.find((g) => g.eventId === eventId);
+    const reachable = /* @__PURE__ */ new Set();
+    const queue = [input.topId];
+    while (queue.length > 0) {
+      const id = queue.shift();
+      if (reachable.has(id)) continue;
+      reachable.add(id);
+      const g = gateOf(id);
+      if (g === void 0) continue;
+      queue.push(...g.inputIds);
+      if (g.type === "inhibit") queue.push(g.conditionId);
+    }
+    for (const e of [...eventById.values()].sort((a, b) => a.id - b.id)) {
+      if (!reachable.has(e.id)) push("unreachable-event", `event ${e.id} is declared but unreachable from the top`);
+    }
+    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 = gateOf(frame.id)?.inputIds ?? [];
+        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("cycle", `cycle: ${[...rotated, rotated[0]].join(" \u2192 ")}`);
+          }
+        } else if (c === 0) {
+          color.set(child, 1);
+          stack.push({ id: child, nextChild: 0 });
+        }
+      }
+    };
+    for (const e of [...eventById.values()].sort((a, b) => a.id - b.id)) {
+      if ((color.get(e.id) ?? 0) === 0) dfs(e.id);
+    }
+  }
+  return sortIssues(issues);
+}
+function validateFaultTree(input) {
+  const issues = faultTreeIssues(input);
+  if (issues.length > 0) throw new FaultTreeValidationError(issues);
+}
+
+// src/fault-tree/layout.ts
+var FT_LABEL_FONT = 12;
+var FT_LABEL_LINE_H = 14;
+var CODE_FONT = 10;
+var LABEL_GAP = 6;
+var PADDING3 = 32;
+var H_GAP = 28;
+var CORRIDOR = 30;
+var STEM = 10;
+var COND_GAP = 14;
+var GATE_W = 44;
+var GATE_H = 36;
+var XOR_H = GATE_H + 5;
+var INHIBIT_W = 36;
+var INHIBIT_H = 46;
+var INHIBIT_CY = 23;
+var FT_STEM_ID_BASE = 1e6;
+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 round2 = (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);
+}
+var CODE_REAL_HEADROOM = 1.15;
+var CODE_MARGIN = 2;
+function codeGlyphHalfAt(kind, y) {
+  if (kind === "basic") {
+    const dy = y - 22;
+    return Math.sqrt(Math.max(0, 22 * 22 - dy * dy));
+  }
+  if (kind === "undeveloped") {
+    return 24 * Math.max(0, 1 - Math.abs(y - 24) / 24);
+  }
+  if (kind === "house") {
+    return y >= 16 ? 22 : 22 * y / 16;
+  }
+  return 22 * Math.max(0, Math.min(35, y)) / 35;
+}
+function codeBaselineHalfWidth(kind, glyphH) {
+  return codeGlyphHalfAt(kind, glyphH / 2 + CODE_FONT * 0.32);
+}
+function maxCodeChars(kind, glyphH) {
+  const half = codeBaselineHalfWidth(kind, glyphH);
+  const perChar = CODE_FONT * CHAR_W * CODE_REAL_HEADROOM / 2;
+  return Math.max(1, Math.floor((half - CODE_MARGIN) / perChar));
+}
+function measureEvent(event, maxLabelChars) {
+  if (event.kind === "intermediate") {
+    const lines2 = event.label === "" ? [] : wrapLabelBalanced(clampLabel(event.label, maxLabelChars), 3);
+    const maxLineW = lines2.reduce((m, l) => Math.max(m, estimateTextWidth(l, FT_LABEL_FONT)), 0);
+    const w = Math.max(96, maxLineW + 24);
+    const h = lines2.length * FT_LABEL_LINE_H + 18;
+    return { nodeW: w, nodeH: h, glyphW: w, glyphH: h, labelLines: lines2, code: null };
+  }
+  const rawCode = event.code === null || event.code === "" ? null : event.code;
+  const lines = event.label === "" ? [] : wrapLeafLabel(clampLabel(event.label, maxLabelChars));
+  const labelW = lines.reduce((m, l) => Math.max(m, estimateTextWidth(l, FT_LABEL_FONT)), 0);
+  let glyphW;
+  let glyphH;
+  let code = rawCode;
+  if (event.kind === "basic") {
+    glyphW = 44;
+    glyphH = 44;
+    code = rawCode === null ? null : clampLabel(rawCode, maxCodeChars("basic", glyphH));
+  } else if (event.kind === "undeveloped") {
+    glyphW = 48;
+    glyphH = 48;
+    code = rawCode === null ? null : clampLabel(rawCode, maxCodeChars("undeveloped", glyphH));
+  } else if (event.kind === "house") {
+    glyphW = 44;
+    glyphH = 40;
+    code = rawCode === null ? null : clampLabel(rawCode, maxCodeChars("house", glyphH));
+  } else if (event.kind === "conditioning") {
+    code = rawCode === null ? null : clampLabel(rawCode, 6);
+    const rx = Math.max(30, estimateTextWidth(code ?? "", CODE_FONT) / 2 + 8);
+    glyphW = rx * 2;
+    glyphH = 32;
+  } else {
+    glyphW = 44;
+    glyphH = 35;
+    code = rawCode === null ? null : clampLabel(rawCode, maxCodeChars("transfer", glyphH));
+  }
+  const nodeW = Math.max(glyphW, labelW);
+  const nodeH = glyphH + (lines.length > 0 ? LABEL_GAP + lines.length * FT_LABEL_LINE_H : 0);
+  return { nodeW, nodeH, glyphW, glyphH, labelLines: lines, code };
+}
+function eventTitle(event) {
+  if (event.title !== void 0) return event.title;
+  return event.code !== null && event.code !== "" ? `${event.code} \xB7 ${event.label}` : event.label;
+}
+function computeFaultTreeLayout(input, opts = {}) {
+  if (input.events.length === 0 && input.gates.length === 0) {
+    return { width: PADDING3 * 2, height: PADDING3 * 2, nodes: [], gates: [], elements: [] };
+  }
+  validateFaultTree(input);
+  const titleLabels = opts.titleLabels ?? FAULT_TREE_TITLE_LABELS_EN;
+  const eventById = new Map(input.events.map((e) => [e.id, e]));
+  const gateByEvent = new Map(input.gates.map((g) => [g.eventId, g]));
+  const seqByEvent = /* @__PURE__ */ new Map();
+  const newInst = (event, gate, depth) => {
+    const seq = seqByEvent.get(event.id) ?? 0;
+    seqByEvent.set(event.id, seq + 1);
+    const inst = {
+      event,
+      gate,
+      children: [],
+      cond: null,
+      depth,
+      m: measureEvent(event, opts.maxLabelChars),
+      title: eventTitle(event),
+      seq,
+      spanL: 0,
+      spanR: 0,
+      offset: 0,
+      cx: 0
+    };
+    return inst;
+  };
+  const build = (eventId, depth) => {
+    const event = eventById.get(eventId);
+    const gate = gateByEvent.get(eventId) ?? null;
+    const inst = newInst(event, gate, depth);
+    if (gate !== null) {
+      if (gate.type === "inhibit") {
+        inst.cond = newInst(eventById.get(gate.conditionId), null, depth);
+      }
+      for (const childId of gate.inputIds) inst.children.push(build(childId, depth + 1));
+    }
+    return inst;
+  };
+  const root = build(input.topId, 0);
+  const pack = (inst) => {
+    for (const c of inst.children) pack(c);
+    const condW = inst.cond !== null ? COND_GAP + inst.cond.m.nodeW : 0;
+    const selfL = inst.m.nodeW / 2;
+    const selfR = inst.m.nodeW / 2 + condW;
+    if (inst.children.length === 0) {
+      inst.spanL = selfL;
+      inst.spanR = selfR;
+      return;
+    }
+    const xs = [0];
+    for (let i = 1; i < inst.children.length; i++) {
+      xs.push(xs[i - 1] + inst.children[i - 1].spanR + H_GAP + inst.children[i].spanL);
+    }
+    const first = inst.children[0];
+    const last2 = inst.children[inst.children.length - 1];
+    const px = (xs[0] + xs[xs.length - 1]) / 2;
+    inst.children.forEach((c, i) => c.offset = xs[i] - px);
+    inst.spanL = Math.max(selfL, px - (xs[0] - first.spanL));
+    inst.spanR = Math.max(selfR, xs[xs.length - 1] + last2.spanR - px);
+  };
+  pack(root);
+  root.cx = PADDING3 + root.spanL;
+  const placeX = (inst) => {
+    for (const c of inst.children) {
+      c.cx = inst.cx + c.offset;
+      placeX(c);
+    }
+  };
+  placeX(root);
+  const rowInsts = [];
+  const visitRows = (inst) => {
+    (rowInsts[inst.depth] ??= []).push(inst);
+    for (const c of inst.children) visitRows(c);
+  };
+  visitRows(root);
+  const depthCount = rowInsts.length;
+  const gateExtent = (inst) => {
+    const g = inst.gate;
+    if (g.type === "xor") return XOR_H;
+    if (g.type === "inhibit") {
+      const condBottom = INHIBIT_CY - 16 + inst.cond.m.nodeH;
+      return Math.max(INHIBIT_H, condBottom);
+    }
+    return GATE_H;
+  };
+  const rowH = [];
+  const gateZone = [];
+  for (let d = 0; d < depthCount; d++) {
+    const insts = rowInsts[d];
+    rowH.push(insts.reduce((m, i) => Math.max(m, i.m.nodeH), 0));
+    const gated = insts.filter((i) => i.gate !== null);
+    gateZone.push(gated.length === 0 ? 0 : STEM + gated.reduce((m, i) => Math.max(m, gateExtent(i)), 0));
+  }
+  const rowTop = [PADDING3];
+  for (let d = 0; d < depthCount - 1; d++) {
+    rowTop.push(rowTop[d] + rowH[d] + gateZone[d] + CORRIDOR);
+  }
+  const busY = (d) => rowTop[d + 1] - CORRIDOR / 2;
+  const width = Math.ceil(PADDING3 * 2 + root.spanL + root.spanR);
+  const last = depthCount - 1;
+  const height = Math.ceil(rowTop[last] + rowH[last] + gateZone[last] + PADDING3);
+  const instanceOf = (inst) => (seqByEvent.get(inst.event.id) ?? 0) > 1 ? inst.seq : null;
+  const nodes = [];
+  const gates = [];
+  const elements = [];
+  const gateTitle = (g) => g.type === "vote" ? `${titleLabels.gates.vote} ${g.k}/${g.inputIds.length}` : titleLabels.gates[g.type];
+  const pushNode = (inst, top) => {
+    const isRect = inst.event.kind === "intermediate";
+    const labelTop = !isRect && inst.m.labelLines.length > 0 ? top + inst.m.glyphH + LABEL_GAP : null;
+    nodes.push({
+      eventId: inst.event.id,
+      kind: inst.event.kind,
+      instance: instanceOf(inst),
+      cx: round2(inst.cx),
+      top: round2(top),
+      nodeW: round2(inst.m.nodeW),
+      nodeH: round2(inst.m.nodeH),
+      glyphW: round2(inst.m.glyphW),
+      glyphH: round2(inst.m.glyphH),
+      labelLines: inst.m.labelLines,
+      labelTop: labelTop === null ? null : round2(labelTop),
+      code: inst.m.code,
+      depth: inst.depth,
+      title: inst.title
+    });
+  };
+  const emit = (inst) => {
+    const d = inst.depth;
+    pushNode(inst, rowTop[d]);
+    const g = inst.gate;
+    if (g === null) return;
+    const gateTop = rowTop[d] + rowH[d] + STEM;
+    const glyphW = g.type === "inhibit" ? INHIBIT_W : GATE_W;
+    const glyphH = g.type === "xor" ? XOR_H : g.type === "inhibit" ? INHIBIT_H : GATE_H;
+    const title = gateTitle(g);
+    gates.push({
+      gateId: g.id,
+      type: g.type,
+      cx: round2(inst.cx),
+      top: round2(gateTop),
+      glyphW,
+      glyphH,
+      title,
+      voteText: g.type === "vote" ? `${g.k}/${g.inputIds.length}` : null
+    });
+    if (inst.cond !== null) {
+      const cond = inst.cond;
+      const nodeLeft = inst.cx + INHIBIT_W / 2 + COND_GAP;
+      cond.cx = nodeLeft + cond.m.nodeW / 2;
+      const condTop = gateTop + INHIBIT_CY - 16;
+      pushNode(cond, condTop);
+      const ovalLeft = cond.cx - cond.m.glyphW / 2;
+      elements.push({
+        edgeId: FT_CONDITION_ID_BASE + g.id,
+        kind: "condition",
+        points: [
+          { x: round2(inst.cx + INHIBIT_W / 2), y: round2(gateTop + INHIBIT_CY) },
+          { x: round2(ovalLeft), y: round2(gateTop + INHIBIT_CY) }
+        ],
+        instance: null,
+        title: titleLabels.condition
+      });
+    }
+    elements.push({
+      edgeId: FT_STEM_ID_BASE + g.id,
+      kind: "stem",
+      points: [
+        { x: round2(inst.cx), y: round2(rowTop[d] + inst.m.nodeH) },
+        { x: round2(inst.cx), y: round2(gateTop) }
+      ],
+      instance: null,
+      title
+    });
+    const by = busY(d);
+    elements.push({
+      edgeId: FT_DROP_ID_BASE + g.id,
+      kind: "drop",
+      points: [
+        { x: round2(inst.cx), y: round2(gateTop + glyphH) },
+        { x: round2(inst.cx), y: round2(by) }
+      ],
+      instance: null,
+      title
+    });
+    if (inst.children.length > 1) {
+      const xs = inst.children.map((c) => c.cx);
+      elements.push({
+        edgeId: FT_BUS_ID_BASE + g.id,
+        kind: "bus",
+        points: [
+          { x: round2(Math.min(...xs)), y: round2(by) },
+          { x: round2(Math.max(...xs)), y: round2(by) }
+        ],
+        instance: null,
+        title
+      });
+    }
+    for (const c of inst.children) {
+      elements.push({
+        edgeId: FT_RISER_ID_BASE + c.event.id,
+        kind: "riser",
+        points: [
+          { x: round2(c.cx), y: round2(by) },
+          { x: round2(c.cx), y: round2(rowTop[d + 1]) }
+        ],
+        instance: instanceOf(c),
+        title
       });
-      parts.push(`<g data-compasso-legend="true">${rows.join("")}</g>`);
-      const widestLabel = entries.reduce((m, e) => Math.max(m, estimateTextWidth(e.label, LEGEND_FONT2)), 0);
-      width = Math.max(width, LEGEND_PAD2 + LEGEND_SWATCH_W2 + LEGEND_GAP2 + widestLabel + LEGEND_PAD2);
-      height = startY + entries.length * LEGEND_ROW_H2 + LEGEND_PAD2 / 2;
     }
+    for (const c of inst.children) emit(c);
+  };
+  emit(root);
+  return { width, height, nodes, gates, elements };
+}
+
+// src/fault-tree/svg.ts
+var GLYPH_STROKE2 = "#52525b";
+var LABEL_FILL2 = "#3f3f46";
+var EDGE_INK3 = "#71717a";
+var GLYPH_ATTRS = `fill="transparent" stroke="${GLYPH_STROKE2}" stroke-width="2"`;
+var round3 = (n) => Math.round(n * 100) / 100;
+function eventGlyph(n) {
+  const cx = n.cx;
+  const top = n.top;
+  if (n.kind === "intermediate") {
+    return `<rect x="${round3(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="${round3(top + 22)}" r="22" ${GLYPH_ATTRS}/>`;
+  }
+  if (n.kind === "undeveloped") {
+    const pts2 = `${cx},${top} ${round3(cx + 24)},${round3(top + 24)} ${cx},${round3(top + 48)} ${round3(cx - 24)},${round3(top + 24)}`;
+    return `<polygon points="${pts2}" ${GLYPH_ATTRS}/>`;
+  }
+  if (n.kind === "house") {
+    const yB = round3(top + 40);
+    const eave = round3(top + 16);
+    const pts2 = `${round3(cx - 22)},${yB} ${round3(cx - 22)},${eave} ${cx},${top} ${round3(cx + 22)},${eave} ${round3(cx + 22)},${yB}`;
+    return `<polygon points="${pts2}" ${GLYPH_ATTRS}/>`;
+  }
+  if (n.kind === "conditioning") {
+    return `<ellipse cx="${cx}" cy="${round3(top + 16)}" rx="${round3(n.glyphW / 2)}" ry="16" ${GLYPH_ATTRS}/>`;
+  }
+  const pts = `${cx},${top} ${round3(cx + 22)},${round3(top + 35)} ${round3(cx - 22)},${round3(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="${round3(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 ? round3(n.top + 19) : round3(n.labelTop + 10);
+    const tspans = n.labelLines.map((line, i) => `<tspan x="${n.cx}" y="${round3(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>`
+    );
+  }
+  const instance = n.instance === null ? "" : ` data-instance="${n.instance}"`;
+  return `<g data-node-id="e${n.eventId}"${instance}>${pieces.join("")}</g>`;
+}
+function orBodyPath(cx, top, yB) {
+  return `M ${round3(cx - 22)} ${yB} Q ${cx} ${round3(yB - 14)} ${round3(cx + 22)} ${yB} Q ${round3(cx + 22)} ${round3(top + 14)} ${cx} ${top} Q ${round3(cx - 22)} ${round3(top + 14)} ${round3(cx - 22)} ${yB} Z`;
+}
+function gateGlyph(g) {
+  const cx = g.cx;
+  const top = g.top;
+  const yB = round3(top + 36);
+  if (g.type === "and") {
+    const d = `M ${round3(cx - 22)} ${yB} L ${round3(cx - 22)} ${round3(yB - 14)} A 22 22 0 0 1 ${round3(cx + 22)} ${round3(yB - 14)} L ${round3(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 ${round3(cx - 22)} ${round3(yB + 5)} Q ${cx} ${round3(yB - 9)} ${round3(cx + 22)} ${round3(yB + 5)}`;
+    return `<path d="${orBodyPath(cx, top, yB)}" ${GLYPH_ATTRS}/><path d="${arc}" ${GLYPH_ATTRS}/>`;
+  }
+  if (g.type === "inhibit") {
+    const pts = `${cx},${top} ${round3(cx + 18)},${round3(top + 12)} ${round3(cx + 18)},${round3(top + 34)} ${cx},${round3(top + 46)} ${round3(cx - 18)},${round3(top + 34)} ${round3(cx - 18)},${round3(top + 12)}`;
+    return `<polygon points="${pts}" ${GLYPH_ATTRS}/>`;
+  }
+  return `<path d="${orBodyPath(cx, top, yB)}" ${GLYPH_ATTRS}/><text x="${cx}" y="${round3(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>`;
+}
+function elementSvg2(el) {
+  const a = el.points[0];
+  const b = el.points[1];
+  const instance = el.instance === null ? "" : ` data-instance="${el.instance}"`;
+  return `<g data-edge-id="${el.edgeId}"${instance}><title>${xmlEscape(el.title)}</title><line x1="${a.x}" y1="${a.y}" x2="${b.x}" y2="${b.y}" stroke="${EDGE_INK3}" stroke-width="1.5" stroke-opacity="0.75"/></g>`;
+}
+var MINI_ATTRS = `fill="transparent" stroke="${GLYPH_STROKE2}" stroke-width="1.5"`;
+function miniEventSwatch(kind, x, y) {
+  const cx = round3(x + LEGEND_SWATCH_W / 2);
+  if (kind === "intermediate") {
+    return `<rect x="${round3(cx - 7)}" y="${round3(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},${round3(y - 7)} ${round3(cx + 7)},${y} ${cx},${round3(y + 7)} ${round3(cx - 7)},${y}" ${MINI_ATTRS}/>`;
+  }
+  if (kind === "house") {
+    return `<polygon points="${round3(cx - 6)},${round3(y + 5.5)} ${round3(cx - 6)},${round3(y - 1)} ${cx},${round3(y - 5.5)} ${round3(cx + 6)},${round3(y - 1)} ${round3(cx + 6)},${round3(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},${round3(y - 5)} ${round3(cx + 6)},${round3(y + 5)} ${round3(cx - 6)},${round3(y + 5)}" ${MINI_ATTRS}/>`;
+}
+function miniOrPath(cx, y) {
+  return `M ${round3(cx - 7)} ${round3(y + 5.5)} Q ${cx} ${round3(y + 1)} ${round3(cx + 7)} ${round3(y + 5.5)} Q ${round3(cx + 7)} ${round3(y - 1.5)} ${cx} ${round3(y - 5.5)} Q ${round3(cx - 7)} ${round3(y - 1.5)} ${round3(cx - 7)} ${round3(y + 5.5)} Z`;
+}
+function miniGateSwatch(type, x, y) {
+  const cx = round3(x + LEGEND_SWATCH_W / 2);
+  if (type === "and") {
+    const d = `M ${round3(cx - 7)} ${round3(y + 5.5)} L ${round3(cx - 7)} ${round3(y + 1.5)} A 7 7 0 0 1 ${round3(cx + 7)} ${round3(y + 1.5)} L ${round3(cx + 7)} ${round3(y + 5.5)} Z`;
+    return `<path d="${d}" ${MINI_ATTRS}/>`;
+  }
+  if (type === "xor") {
+    return `<path d="${miniOrPath(cx, y)}" ${MINI_ATTRS}/><path d="M ${round3(cx - 7)} ${round3(y + 7.5)} Q ${cx} ${round3(y + 3)} ${round3(cx + 7)} ${round3(y + 7.5)}" ${MINI_ATTRS}/>`;
+  }
+  if (type === "inhibit") {
+    return `<polygon points="${cx},${round3(y - 5.5)} ${round3(cx + 4.5)},${round3(y - 2.5)} ${round3(cx + 4.5)},${round3(y + 2.5)} ${cx},${round3(y + 5.5)} ${round3(cx - 4.5)},${round3(y + 2.5)} ${round3(cx - 4.5)},${round3(y - 2.5)}" ${MINI_ATTRS}/>`;
+  }
+  return `<path d="${miniOrPath(cx, y)}" ${MINI_ATTRS}/>`;
+}
+function faultTreeLayoutSvg(layout, opts = {}) {
+  const labels = opts.labels ?? FAULT_TREE_SVG_LABELS_EN;
+  const parts = [];
+  for (const el of layout.elements) parts.push(elementSvg2(el));
+  for (const g of layout.gates) parts.push(gateSvg(g));
+  for (const n of layout.nodes) parts.push(nodeSvg(n));
+  let width = layout.width;
+  let height = layout.height;
+  if (opts.legend !== false && layout.nodes.length > 0) {
+    const kindsUsed = new Set(layout.nodes.map((n) => n.kind));
+    const typesUsed = new Set(layout.gates.map((g) => g.type));
+    const entries = [];
+    for (const kind of FAULT_TREE_EVENT_KINDS) {
+      if (!kindsUsed.has(kind)) continue;
+      entries.push({ swatch: (x, y) => miniEventSwatch(kind, x, y), label: labels.events[kind] });
+    }
+    for (const type of GATE_TYPES) {
+      if (!typesUsed.has(type)) continue;
+      entries.push({ swatch: (x, y) => miniGateSwatch(type, x, y), label: labels.gates[type] });
+    }
+    const block = legendBlock(entries, layout.height);
+    if (block.svg !== "") {
+      parts.push(block.svg);
+      width = Math.max(width, block.width);
+      height = block.height;
+    }
+  }
+  const w = Math.ceil(width);
+  const h = Math.ceil(height);
+  return `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 ${w} ${h}" width="${w}" height="${h}" role="img" aria-label="${xmlEscape(labels.ariaLabel)}">` + parts.join("") + `</svg>`;
+}
+
+// src/fault-tree/render.ts
+function faultTreeSvg(input, opts = {}) {
+  const layout = computeFaultTreeLayout(input, {
+    ...opts.maxLabelChars !== void 0 ? { maxLabelChars: opts.maxLabelChars } : {},
+    ...opts.titleLabels !== void 0 ? { titleLabels: opts.titleLabels } : {}
+  });
+  const svg = faultTreeLayoutSvg(layout, {
+    ...opts.legend === false ? { legend: false } : {},
+    ...opts.svgLabels !== void 0 ? { labels: opts.svgLabels } : {}
+  });
+  return { svg, layout };
+}
+
+// src/fishbone/render.ts
+var FISHBONE_LABELS_EN = {
+  cause: "Cause",
+  subCause: "Sub-cause",
+  ariaLabel: "Cause-and-effect diagram (Ishikawa)"
+};
+var FishboneValidationError = class extends Error {
+  issues;
+  constructor(issues) {
+    super(`invalid fishbone: ${issues.map((i) => i.message).join("; ")}`);
+    this.name = "FishboneValidationError";
+    this.issues = issues;
+  }
+};
+function duplicateIds(ids) {
+  const seen = /* @__PURE__ */ new Set();
+  const dups = /* @__PURE__ */ new Set();
+  for (const id of ids) {
+    if (seen.has(id)) dups.add(id);
+    seen.add(id);
+  }
+  return [...dups].sort((a, b) => a - b);
+}
+function validateIds(input) {
+  const issues = [];
+  const collect = (noun, ids) => {
+    for (const id of duplicateIds(ids)) {
+      issues.push({ code: "duplicate-id", message: `duplicate ${noun} id ${id}` });
+    }
+  };
+  collect("category", input.categories.map((c) => c.id));
+  collect("cause", input.categories.flatMap((c) => c.causes.map((k) => k.id)));
+  collect(
+    "sub-cause",
+    input.categories.flatMap((c) => c.causes.flatMap((k) => k.subCauses.map((s) => s.id)))
+  );
+  if (issues.length > 0) throw new FishboneValidationError(issues);
+}
+var TAN60 = 1.7320508075688772;
+var SIN60 = 0.8660254037844386;
+var COS60 = 0.5;
+var PADDING4 = 32;
+var ROW_GAP = 12;
+var BONE_GAP = 36;
+var CAT_PAD_X = 12;
+var CAT_PAD_Y = 8;
+var CAT_GAP = 12;
+var TAIL_EXTRA = 44;
+var HEAD_GAP = 24;
+var HEAD_PAD_X = 14;
+var HEAD_PAD_Y = 10;
+var SUB_PER_LINE = 18;
+var ASCENT_12 = 11;
+var DESCENT_12 = 3;
+function verticalMetrics(fontSize) {
+  const ascent = Math.ceil(ASCENT_12 * fontSize / 12);
+  const descent = Math.ceil(DESCENT_12 * fontSize / 12);
+  const lineH = ascent + descent;
+  const twigGap = descent + 1;
+  return {
+    ascent,
+    lineH,
+    twigGap,
+    sV: 2 * lineH + twigGap + 8,
+    spineClear: 2 * lineH + twigGap,
+    boneClear: Math.ceil((2 * lineH + twigGap) / TAN60) + 25,
+    subGap: lineH
+  };
+}
+var EDGE_INK4 = "#71717a";
+var BOX_STROKE = "#52525b";
+var LABEL_FILL3 = "#3f3f46";
+var SPINE_W = 2.5;
+var SPINE_OP = 0.85;
+var BONE_W = 2;
+var BONE_OP = 0.8;
+var TWIG_W = 1.5;
+var TWIG_OP = 0.75;
+var SUB_W = 1.2;
+var SUB_OP = 0.7;
+var round4 = (n) => Math.round(n * 100) / 100;
+function arrowHead2(tipX, tipY, ux, uy, opacity) {
+  const LEN = 9;
+  const HALF_W = 4.5;
+  const bx = tipX - ux * LEN;
+  const by = tipY - uy * LEN;
+  const px = -uy;
+  const py = ux;
+  const points = [
+    `${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_INK4}" fill-opacity="${opacity}"/>`;
+}
+function lineEl(x1, y1, x2, y2, w, op) {
+  return `<line x1="${round4(x1)}" y1="${round4(y1)}" x2="${round4(x2)}" y2="${round4(y2)}" stroke="${EDGE_INK4}" stroke-width="${w}" stroke-opacity="${op}"/>`;
+}
+function fishboneSvg(input, opts = {}) {
+  validateIds(input);
+  const fontSize = opts.fontSize ?? 12;
+  const { ascent, lineH, twigGap, sV, spineClear, boneClear, subGap } = verticalMetrics(fontSize);
+  const labels = opts.labels ?? FISHBONE_LABELS_EN;
+  const arrows = opts.arrowheads !== false;
+  const bones = input.categories.map((category, idx) => {
+    let cursor = spineClear;
+    const bands = category.causes.map((cause) => {
+      const lines = wrapLabelBalanced(clampLabel(cause.label, opts.maxLabelChars));
+      const labelW = Math.max(...lines.map((l) => estimateTextWidth(l, fontSize)));
+      const blockH = lines.length * lineH;
+      const offset = cursor;
+      const bx = -offset / TAN60;
+      const subs = [];
+      for (const sub of cause.subCauses) {
+        const line = wrapLabel(clampLabel(sub.label, opts.maxLabelChars), SUB_PER_LINE, 1)[0];
+        const w2 = estimateTextWidth(line, fontSize);
+        const prev = subs.length > 0 ? subs[subs.length - 1] : null;
+        const sx = prev === null ? bx - (sV + lineH) / TAN60 - 10 - w2 / 2 : prev.sx - (prev.w + w2) * 0.6 - subGap;
+        subs.push({ sub, line, w: w2, sx, outerX: sx - sV / TAN60 });
+      }
+      const last = subs.length > 0 ? subs[subs.length - 1] : null;
+      const subSpan = last === null ? 0 : bx - (last.outerX - last.w / 2);
+      const twigLen = last === null ? labelW + boneClear : Math.max(labelW + boneClear, subSpan + boneClear, labelW + (bx - last.outerX) + 10);
+      const bandH = Math.max(blockH + twigGap, subs.length > 0 ? sV + lineH + twigGap : 0) + ROW_GAP;
+      cursor += bandH;
+      return { cause, lines, labelW, blockH, offset, bandH, bx, freeEnd: bx - twigLen, subs };
+    });
+    const B = cursor + 16;
+    const catLines = wrapLabelBalanced(clampLabel(category.label, opts.maxLabelChars));
+    const boxW = Math.max(...catLines.map((l) => estimateTextWidth(l, fontSize))) + CAT_PAD_X * 2;
+    const boxH = catLines.length * lineH + CAT_PAD_Y * 2;
+    const tipX = -B / TAN60;
+    return {
+      category,
+      up: idx % 2 === 0,
+      bands,
+      B,
+      catLines,
+      boxW,
+      boxH,
+      // Left extent: the category box's left edge or the deepest twig free end —
+      // every label sits AT or right of its twig's free end, every sub label sits
+      // right of the free end too (twigLen ≥ subSpan + boneClear).
+      relL: Math.max(B / TAN60 + boxW / 2, ...bands.map((b) => -b.freeEnd)),
+      // Right extent: a wide category box on a short bone may overhang the attach.
+      relR: Math.max(0, boxW / 2 + tipX),
+      ax: 0
+    };
+  });
+  const cursors = { top: 0, bottom: 0 };
+  for (const bone of bones) {
+    const side = bone.up ? "top" : "bottom";
+    bone.ax = cursors[side] - bone.relR;
+    cursors[side] = bone.ax - bone.relL - BONE_GAP;
+  }
+  const effLines = wrapLabelBalanced(clampLabel(input.effectLabel, opts.maxLabelChars));
+  const headW = Math.max(...effLines.map((l) => estimateTextWidth(l, fontSize))) + HEAD_PAD_X * 2;
+  const headH = effLines.length * lineH + HEAD_PAD_Y * 2;
+  const headLeft = bones.length > 0 ? HEAD_GAP : 0;
+  const tailX = bones.length > 0 ? Math.min(...bones.map((b) => b.ax - b.relL)) - TAIL_EXTRA : headLeft - (TAIL_EXTRA + HEAD_GAP);
+  let minY = -headH / 2;
+  let maxY = headH / 2;
+  for (const bone of bones) {
+    const reach = bone.B + CAT_GAP + bone.boxH;
+    if (bone.up) minY = Math.min(minY, -reach);
+    else maxY = Math.max(maxY, reach);
+  }
+  const dx = PADDING4 - tailX;
+  const dy = PADDING4 - minY;
+  let width = headLeft + headW - tailX + PADDING4 * 2;
+  let height = maxY - minY + PADDING4 * 2;
+  const spineY = dy;
+  const centeredYs = (cy, n) => Array.from({ length: n }, (_, i) => cy - (n - 1) * lineH / 2 + i * lineH + fontSize * 0.32);
+  const bandBaselines = (e, n, up) => Array.from(
+    { 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="${round4(x)}" y="${round4(ys[i])}">${xmlEscape(line)}</tspan>`).join("") + `</text>`;
+  const parts = [];
+  {
+    const body = [lineEl(tailX + dx, spineY, headLeft + dx, spineY, SPINE_W, SPINE_OP)];
+    if (arrows) body.push(arrowHead2(headLeft + dx, spineY, 1, 0, SPINE_OP));
+    parts.push(`<g data-edge-id="spine"><title>${xmlEscape(labels.ariaLabel)}</title>${body.join("")}</g>`);
+  }
+  for (const bone of bones) {
+    const sgn = bone.up ? -1 : 1;
+    const ax = bone.ax + dx;
+    const tipX = ax - bone.B / TAN60;
+    const body = [lineEl(tipX, spineY + sgn * bone.B, ax, spineY, BONE_W, BONE_OP)];
+    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="${round4(tipX - bone.boxW / 2)}" y="${round4(boxTop)}" width="${round4(bone.boxW)}" height="${round4(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(
+      `<g data-node-id="b${bone.category.id}"><title>${xmlEscape(bone.category.title ?? bone.category.label)}</title>${body.join("")}</g>`
+    );
+    for (const band of bone.bands) {
+      const ty = spineY + sgn * band.offset;
+      const bx = ax + band.bx;
+      const freeEnd = ax + band.freeEnd;
+      const cbody = [lineEl(freeEnd, ty, bx, ty, TWIG_W, TWIG_OP)];
+      if (arrows) cbody.push(arrowHead2(bx, ty, 1, 0, TWIG_OP));
+      cbody.push(textBlock("start", freeEnd + 2, bandBaselines(band.offset, band.lines.length, bone.up), band.lines));
+      parts.push(
+        `<g data-node-id="c${band.cause.id}"><title>${xmlEscape(band.cause.title ?? band.cause.label)}</title>${cbody.join("")}</g>`
+      );
+      for (const s of band.subs) {
+        const sx = ax + s.sx;
+        const ox = ax + s.outerX;
+        const sbody = [lineEl(ox, spineY + sgn * (band.offset + sV), sx, ty, SUB_W, SUB_OP)];
+        if (arrows) sbody.push(arrowHead2(sx, ty, COS60, -sgn * SIN60, SUB_OP));
+        const baseline = bone.up ? spineY - (band.offset + sV + twigGap) : spineY + band.offset + sV + twigGap + ascent;
+        sbody.push(textBlock("middle", ox, [baseline], [s.line]));
+        parts.push(`<g data-node-id="s${s.sub.id}"><title>${xmlEscape(s.sub.label)}</title>${sbody.join("")}</g>`);
+      }
+    }
+  }
+  {
+    const x = headLeft + dx;
+    parts.push(
+      `<g data-node-id="head"><title>${xmlEscape(input.effectLabel)}</title><rect x="${round4(x)}" y="${round4(spineY - headH / 2)}" width="${round4(headW)}" height="${round4(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));
+  if (opts.legend !== false && anySubs) {
+    const entries = [
+      {
+        swatch: (x, y) => lineEl(x, y, x + LEGEND_SWATCH_W, y, TWIG_W, TWIG_OP),
+        label: labels.cause
+      },
+      {
+        swatch: (x, y) => lineEl(x, y + 5, x + LEGEND_SWATCH_W, y - 5, SUB_W, SUB_OP),
+        label: labels.subCause
+      }
+    ];
+    const block = legendBlock(entries, height);
+    parts.push(block.svg);
+    width = Math.max(width, block.width);
+    height = block.height;
   }
   const w = Math.ceil(width);
   const h = Math.ceil(height);
   return `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 ${w} ${h}" width="${w}" height="${h}" role="img" aria-label="${xmlEscape(labels.ariaLabel)}">` + parts.join("") + `</svg>`;
 }
 
+// src/pedigree/types.ts
+var LIFE_STATUSES = ["alive", "stillbirth"];
+
+// src/pedigree/labels.ts
+var PEDIGREE_TITLE_LABELS_EN = {
+  affected: "affected",
+  carrier: "carrier",
+  deceased: "deceased",
+  proband: "proband",
+  consultand: "consultand",
+  consanguineous: "consanguineous mating",
+  mating: "mating",
+  sibship: "sibship",
+  twins: {
+    mz: "monozygotic twins",
+    dz: "dizygotic twins",
+    unknown: "twins, zygosity unknown"
+  },
+  stillbirth: "stillbirth",
+  generation: "generation"
+};
+var PEDIGREE_SVG_LABELS_EN = {
+  shapes: {
+    square: "Male",
+    circle: "Female",
+    diamond: "Sex unknown"
+  },
+  unaffected: "Unaffected",
+  carrier: "Carrier",
+  deceased: "Deceased",
+  proband: "Proband",
+  consultand: "Consultand",
+  consanguineous: "Consanguineous mating",
+  twins: {
+    mz: "Monozygotic twins",
+    dz: "Dizygotic twins",
+    unknown: "Twins (zygosity unknown)"
+  },
+  stillbirth: "Stillbirth",
+  isolated: "No recorded relatives",
+  ariaLabel: "Pedigree chart"
+};
+
+// src/pedigree/validate.ts
+var PedigreeValidationError = class extends Error {
+  issues;
+  constructor(issues) {
+    super(`invalid pedigree: ${issues.map((i) => i.message).join("; ")}`);
+    this.name = "PedigreeValidationError";
+    this.issues = issues;
+  }
+};
+var MAX_CONDITIONS_PER_INDIVIDUAL = 4;
+function sortIssues2(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 pedigreeIssues(input) {
+  if (input.individuals.length === 0 && input.matings.length === 0 && input.sibships.length === 0) return [];
+  const issues = [];
+  const push = (code, message) => {
+    issues.push({ code, message });
+  };
+  const individualById = /* @__PURE__ */ new Map();
+  const dupIndividualIds = /* @__PURE__ */ new Set();
+  for (const ind of input.individuals) {
+    if (individualById.has(ind.id)) dupIndividualIds.add(ind.id);
+    else individualById.set(ind.id, ind);
+  }
+  for (const id of [...dupIndividualIds].sort((a, b) => a - b)) {
+    push("duplicate-id", `duplicate individual id ${id}`);
+  }
+  const matingById = /* @__PURE__ */ new Map();
+  const dupMatingIds = /* @__PURE__ */ new Set();
+  for (const m of input.matings) {
+    if (matingById.has(m.id)) dupMatingIds.add(m.id);
+    else matingById.set(m.id, m);
+  }
+  for (const id of [...dupMatingIds].sort((a, b) => a - b)) {
+    push("duplicate-id", `duplicate mating id ${id}`);
+  }
+  const sibshipById = /* @__PURE__ */ new Map();
+  const dupSibshipIds = /* @__PURE__ */ new Set();
+  for (const s of input.sibships) {
+    if (sibshipById.has(s.id)) dupSibshipIds.add(s.id);
+    else sibshipById.set(s.id, s);
+  }
+  for (const id of [...dupSibshipIds].sort((a, b) => a - b)) {
+    push("duplicate-id", `duplicate sibship id ${id}`);
+  }
+  if (issues.length > 0) {
+    return sortIssues2(issues);
+  }
+  const individuals = [...individualById.values()].sort((a, b) => a.id - b.id);
+  const matings = [...matingById.values()].sort((a, b) => a.id - b.id);
+  const sibships = [...sibshipById.values()].sort((a, b) => a.id - b.id);
+  const conditionIds = new Set(input.conditions.map((c) => c.id));
+  for (const m of matings) {
+    if (!individualById.has(m.partnerAId)) {
+      push("unknown-partner", `mating ${m.id} references unknown individual ${m.partnerAId}`);
+    }
+    if (!individualById.has(m.partnerBId)) {
+      push("unknown-partner", `mating ${m.id} references unknown individual ${m.partnerBId}`);
+    }
+    if (m.partnerAId === m.partnerBId) {
+      push("self-mating", `mating ${m.id} mates individual ${m.partnerAId} with itself`);
+    }
+  }
+  for (const s of sibships) {
+    if (!matingById.has(s.matingId)) {
+      push("unknown-sibship-mating", `sibship ${s.id} references unknown mating ${s.matingId}`);
+    }
+    for (const childId of s.childIds) {
+      if (!individualById.has(childId)) {
+        push("unknown-child", `sibship ${s.id} references unknown child ${childId}`);
+      }
+    }
+    const childSet = new Set(s.childIds);
+    const offending = /* @__PURE__ */ new Set();
+    for (const tg of s.twinGroups) {
+      for (const memberId of tg.childIds) {
+        if (!childSet.has(memberId)) offending.add(memberId);
+      }
+    }
+    for (const memberId of [...offending].sort((a, b) => a - b)) {
+      push("twin-not-in-sibship", `twin ${memberId} is not a child of sibship ${s.id}`);
+    }
+    for (const tg of s.twinGroups) {
+      if (tg.childIds.length < 2) {
+        const [only] = tg.childIds;
+        push(
+          "twin-group-too-small",
+          `twin group in sibship ${s.id} has only 1 member (${only ?? "none"}) \u2014 at least 2 required`
+        );
+      }
+    }
+    for (const tg of s.twinGroups) {
+      if (tg.childIds.length < 2) continue;
+      const memberSet = new Set(tg.childIds);
+      const positions = s.childIds.map((cid, pos) => memberSet.has(cid) ? pos : -1).filter((p) => p >= 0);
+      if (positions.length === 0) continue;
+      const first = positions[0];
+      const last = positions[positions.length - 1];
+      if (last - first !== positions.length - 1) {
+        const memberList = [...tg.childIds].sort((a, b) => a - b).join(", ");
+        push(
+          "twin-group-not-contiguous",
+          `twin group [${memberList}] in sibship ${s.id} is not a contiguous run in childIds`
+        );
+      }
+    }
+  }
+  const sibshipsOfChild = /* @__PURE__ */ new Map();
+  for (const s of sibships) {
+    for (const childId of s.childIds) {
+      const arr = sibshipsOfChild.get(childId) ?? [];
+      arr.push(s.id);
+      sibshipsOfChild.set(childId, arr);
+    }
+  }
+  for (const [childId, sibIds] of [...sibshipsOfChild.entries()].sort((a, b) => a[0] - b[0])) {
+    if (sibIds.length > 1) {
+      push(
+        "child-of-two-sibships",
+        `individual ${childId} is a child of sibships ${[...sibIds].sort((a, b) => a - b).join(", ")}`
+      );
+    }
+  }
+  for (const ind of individuals) {
+    if (!Number.isInteger(ind.generation)) {
+      push("generation-not-integer", `individual ${ind.id} has non-integer generation ${ind.generation}`);
+    }
+  }
+  for (const ind of individuals) {
+    for (const conditionId of ind.affectedBy) {
+      if (!conditionIds.has(conditionId)) {
+        push("unknown-condition", `individual ${ind.id} is affected by unknown condition ${conditionId}`);
+      }
+    }
+    if (ind.affectedBy.length > MAX_CONDITIONS_PER_INDIVIDUAL) {
+      push(
+        "too-many-conditions",
+        `individual ${ind.id} has ${ind.affectedBy.length} conditions \u2014 at most ${MAX_CONDITIONS_PER_INDIVIDUAL} can be drawn`
+      );
+    }
+  }
+  const GRAPH_BLOCKING = /* @__PURE__ */ new Set([
+    "duplicate-id",
+    "unknown-partner",
+    "unknown-sibship-mating",
+    "unknown-child"
+  ]);
+  if (!issues.some((i) => GRAPH_BLOCKING.has(i.code))) {
+    for (const s of sibships) {
+      const mating = matingById.get(s.matingId);
+      if (mating === void 0) continue;
+      const a = individualById.get(mating.partnerAId);
+      const b = individualById.get(mating.partnerBId);
+      const parentGenerations = [a, b].filter((p) => p !== void 0 && Number.isInteger(p.generation)).map((p) => p.generation);
+      if (parentGenerations.length === 0) continue;
+      const parentRow = Math.max(...parentGenerations);
+      for (const childId of s.childIds) {
+        const child = individualById.get(childId);
+        if (child === void 0 || !Number.isInteger(child.generation)) continue;
+        if (child.generation <= parentRow) {
+          push(
+            "generation-inversion",
+            `child ${childId} (generation ${child.generation}) is not below its parents (generation ${parentRow}) in sibship ${s.id}`
+          );
+        }
+      }
+    }
+  }
+  return sortIssues2(issues);
+}
+function validatePedigree(input) {
+  const issues = pedigreeIssues(input);
+  if (issues.length > 0) throw new PedigreeValidationError(issues);
+}
+
+// src/pedigree/layout.ts
+var PED_GLYPH = 40;
+var PED_LABEL_FONT = 12;
+var PED_LABEL_LINE_H = 14;
+var PED_ADDRESS_FONT = 10;
+var PED_LABEL_GAP = 6;
+var PADDING5 = 32;
+var GUTTER = 36;
+var H_GAP2 = 28;
+var MATING_RUN = 22;
+var CORRIDOR2 = 44;
+var TWIN_JUNCTION_DROP = 12;
+var BRIDGE_DIP_GAP = 10;
+var BRIDGE_DIP_STEP = 7;
+var BRIDGE_STUB_X_STEP = 3;
+var PED_MATING_ID_BASE = 1e6;
+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 round5 = (n) => Math.round(n * 100) / 100;
+function shapeForSex2(sex) {
+  if (sex === "male") return "square";
+  if (sex === "female") return "circle";
+  return "diamond";
+}
+var PED_CONDITION_FILLS = ["#52525b", "#a1a1aa", "#3f3f46", "#71717a"];
+function wrapPedigreeLabel(displayLabel) {
+  if (displayLabel === "") return [];
+  return wrapLabelBalanced(displayLabel, 2);
+}
+function individualTitle(ind, address, conditionLabelById, titleLabels) {
+  if (ind.title !== void 0) return ind.title;
+  const parts = [`${address} \xB7 ${ind.label}`];
+  if (ind.affectedBy.length > 0) {
+    const names = ind.affectedBy.map((id) => conditionLabelById.get(id) ?? String(id));
+    parts.push(`${titleLabels.affected}: ${names.join(", ")}`);
+  }
+  if (ind.carrier && ind.affectedBy.length === 0) parts.push(titleLabels.carrier);
+  if (ind.deceased) parts.push(titleLabels.deceased);
+  if (ind.role === "proband") parts.push(titleLabels.proband);
+  else if (ind.role === "consultand") parts.push(titleLabels.consultand);
+  if (ind.lifeStatus === "stillbirth") parts.push(titleLabels.stillbirth);
+  return parts.join(" \xB7 ");
+}
+function computePedigreeLayout(input, opts = {}) {
+  if (input.individuals.length === 0 && input.matings.length === 0 && input.sibships.length === 0) {
+    return {
+      width: PADDING5 * 2,
+      height: PADDING5 * 2,
+      nodes: [],
+      elements: [],
+      generations: [],
+      conditionFills: [],
+      twinZygositiesUsed: [],
+      unknownTwinJunctions: [],
+      isolatedIndividualIds: []
+    };
+  }
+  validatePedigree(input);
+  const titleLabels = opts.titleLabels ?? PEDIGREE_TITLE_LABELS_EN;
+  const individuals = [...input.individuals].sort((a, b) => a.id - b.id);
+  const individualById = new Map(individuals.map((i) => [i.id, i]));
+  const matings = [...input.matings].sort((a, b) => a.id - b.id);
+  const sibships = [...input.sibships].sort((a, b) => a.id - b.id);
+  const conditionLabelById = new Map(input.conditions.map((c) => [c.id, c.label]));
+  const partnersOf = (m) => m.partnerAId <= m.partnerBId ? [m.partnerAId, m.partnerBId] : [m.partnerBId, m.partnerAId];
+  const distinctGenerations = [...new Set(individuals.map((i) => i.generation))].sort((a, b) => a - b);
+  const rowOfGeneration = /* @__PURE__ */ new Map();
+  distinctGenerations.forEach((g, i) => rowOfGeneration.set(g, i));
+  const rowCount = distinctGenerations.length;
+  const labelLinesOf = /* @__PURE__ */ new Map();
+  for (const ind of individuals) {
+    labelLinesOf.set(ind.id, wrapPedigreeLabel(clampLabel(ind.label, opts.maxLabelChars)));
+  }
+  const nodeHalfWidth = (ind) => {
+    const lines = labelLinesOf.get(ind.id) ?? [];
+    const labelW = lines.reduce((m, l) => Math.max(m, estimateTextWidth(l, PED_LABEL_FONT)), 0);
+    return Math.max(PED_GLYPH, labelW) / 2;
+  };
+  const childToSibship = /* @__PURE__ */ new Map();
+  for (const s of sibships) for (const c of s.childIds) childToSibship.set(c, s);
+  const sibshipByMating = /* @__PURE__ */ new Map();
+  for (const s of sibships) {
+    const arr = sibshipByMating.get(s.matingId) ?? [];
+    arr.push(s);
+    sibshipByMating.set(s.matingId, arr);
+  }
+  const matingsOfIndividual = /* @__PURE__ */ new Map();
+  for (const m of matings) {
+    for (const p of partnersOf(m)) {
+      const arr = matingsOfIndividual.get(p) ?? [];
+      arr.push(m);
+      matingsOfIndividual.set(p, arr);
+    }
+  }
+  const placedById = /* @__PURE__ */ new Map();
+  let cursorX = PADDING5 + GUTTER;
+  const placeLeaf = (ind, leftEdge) => {
+    const half = nodeHalfWidth(ind);
+    const cx = leftEdge + half;
+    const placed = { ind, cx, spanL: half, spanR: half };
+    placedById.set(ind.id, placed);
+    return placed;
+  };
+  const placedMatings = /* @__PURE__ */ new Set();
+  const matingCount = (id) => (matingsOfIndividual.get(id) ?? []).length;
+  const hubCursor = /* @__PURE__ */ new Map();
+  const hubSpouseSeq = /* @__PURE__ */ new Map();
+  const packMating = (mating, leftEdge) => {
+    placedMatings.add(mating.id);
+    const [aId, bId] = partnersOf(mating);
+    const a = individualById.get(aId);
+    const b = individualById.get(bId);
+    const aHalf = nodeHalfWidth(a);
+    const bHalf = nodeHalfWidth(b);
+    const halfSep = Math.max(aHalf, bHalf) + MATING_RUN;
+    const aPlaced = placedById.get(aId);
+    const bPlaced = placedById.get(bId);
+    const hubId = aPlaced !== void 0 ? aId : bPlaced !== void 0 ? bId : matingCount(aId) >= 2 ? aId : matingCount(bId) >= 2 ? bId : null;
+    const blockLeft = hubId !== null && hubCursor.has(hubId) ? hubCursor.get(hubId) : leftEdge;
+    const sibs = (sibshipByMating.get(mating.id) ?? []).sort((s1, s2) => s1.id - s2.id);
+    const childIds = sibs.flatMap((s) => s.childIds);
+    let childCursor = blockLeft;
+    let childLeft = Number.POSITIVE_INFINITY;
+    let childrenRight = blockLeft;
+    let placedAnyChild = false;
+    for (const childId of childIds) {
+      const child = individualById.get(childId);
+      if (child === void 0 || placedById.has(childId)) continue;
+      const downMating = (matingsOfIndividual.get(childId) ?? []).find((m) => {
+        if (placedMatings.has(m.id)) return false;
+        const [pa, pb] = partnersOf(m);
+        const otherId = pa === childId ? pb : pa;
+        const other = individualById.get(otherId);
+        return other === void 0 || child.generation <= other.generation;
+      });
+      if (downMating !== void 0) {
+        const right = packMating(downMating, childCursor);
+        childLeft = Math.min(childLeft, placedById.get(childId).cx - nodeHalfWidth(child));
+        childrenRight = right;
+        childCursor = right + H_GAP2;
+      } else {
+        const placed = placeLeaf(child, childCursor);
+        childLeft = Math.min(childLeft, placed.cx - placed.spanL);
+        childrenRight = placed.cx + placed.spanR;
+        childCursor = childrenRight + H_GAP2;
+      }
+      placedAnyChild = true;
+    }
+    const bandMid = placedAnyChild ? (childLeft + childrenRight) / 2 : blockLeft + halfSep;
+    if (hubId === null) {
+      const pairMid = placedAnyChild ? bandMid : blockLeft + Math.max(aHalf, bHalf) + halfSep;
+      placedById.set(aId, { ind: a, cx: pairMid - halfSep, spanL: aHalf, spanR: aHalf });
+      placedById.set(bId, { ind: b, cx: pairMid + halfSep, spanL: bHalf, spanR: bHalf });
+    } else {
+      const spouseId = hubId === aId ? bId : aId;
+      const spouse = individualById.get(spouseId);
+      const spouseHalf = nodeHalfWidth(spouse);
+      const hubHalf = nodeHalfWidth(individualById.get(hubId));
+      const seq = hubSpouseSeq.get(hubId) ?? 0;
+      const hubExisting = placedById.get(hubId);
+      const minSpouseCx = blockLeft + hubHalf + halfSep;
+      let spouseCx = placedAnyChild ? Math.max(bandMid, minSpouseCx) : minSpouseCx + spouseHalf;
+      if (hubExisting === void 0) {
+        placedById.set(hubId, { ind: individualById.get(hubId), cx: spouseCx - halfSep, spanL: hubHalf, spanR: hubHalf });
+      } else {
+        spouseCx = Math.max(spouseCx, hubExisting.cx + halfSep);
+      }
+      placedById.set(spouseId, { ind: spouse, cx: spouseCx, spanL: spouseHalf, spanR: spouseHalf });
+      hubSpouseSeq.set(hubId, seq + 1);
+    }
+    const blockRight = Math.max(
+      childrenRight,
+      placedById.get(aId).cx + nodeHalfWidth(a),
+      placedById.get(bId).cx + nodeHalfWidth(b)
+    );
+    if (hubId !== null) hubCursor.set(hubId, blockRight + H_GAP2);
+    return blockRight;
+  };
+  const generationOfMating = (m) => {
+    const [aId, bId] = partnersOf(m);
+    const a = individualById.get(aId);
+    const b = individualById.get(bId);
+    const gens = [a, b].filter((p) => p !== void 0).map((p) => p.generation);
+    return gens.length > 0 ? Math.min(...gens) : 0;
+  };
+  const rootMatings = matings.filter((m) => {
+    const [aId, bId] = partnersOf(m);
+    return !childToSibship.has(aId) && !childToSibship.has(bId);
+  }).sort((m1, m2) => generationOfMating(m1) - generationOfMating(m2) || m1.id - m2.id);
+  for (const m of rootMatings) {
+    if (placedMatings.has(m.id)) continue;
+    const right = packMating(m, cursorX);
+    cursorX = right + H_GAP2 * 2;
+  }
+  for (const m of matings) {
+    if (placedMatings.has(m.id)) continue;
+    const right = packMating(m, cursorX);
+    cursorX = right + H_GAP2 * 2;
+  }
+  const inAnyMating = /* @__PURE__ */ new Set();
+  for (const m of matings) for (const p of partnersOf(m)) inAnyMating.add(p);
+  const isolatedIndividualIds = individuals.filter((i) => !inAnyMating.has(i.id) && !childToSibship.has(i.id)).map((i) => i.id);
+  for (const id of isolatedIndividualIds) {
+    const ind = individualById.get(id);
+    if (placedById.has(id)) continue;
+    placeLeaf(ind, cursorX);
+    cursorX = placedById.get(id).cx + nodeHalfWidth(ind) + H_GAP2;
+  }
+  for (const ind of individuals) {
+    if (placedById.has(ind.id)) continue;
+    placeLeaf(ind, cursorX);
+    cursorX = placedById.get(ind.id).cx + nodeHalfWidth(ind) + H_GAP2;
+  }
+  const matingBridgeSlot = /* @__PURE__ */ new Map();
+  {
+    const dipSlotByRow = /* @__PURE__ */ new Map();
+    for (const m of [...matings].sort((m1, m2) => m1.id - m2.id)) {
+      const [aId, bId] = partnersOf(m);
+      const a = individualById.get(aId);
+      const b = individualById.get(bId);
+      if (a === void 0 || b === void 0) continue;
+      if (a.generation !== b.generation) continue;
+      const row = rowOfGeneration.get(a.generation);
+      const loX = Math.min(placedById.get(aId).cx, placedById.get(bId).cx);
+      const hiX = Math.max(placedById.get(aId).cx, placedById.get(bId).cx);
+      const blocked = individuals.some(
+        (i) => i.id !== aId && i.id !== bId && rowOfGeneration.get(i.generation) === row && placedById.has(i.id) && placedById.get(i.id).cx > loX + 0.01 && placedById.get(i.id).cx < hiX - 0.01
+      );
+      if (!blocked) {
+        matingBridgeSlot.set(m.id, 0);
+        continue;
+      }
+      const slot = (dipSlotByRow.get(row) ?? 0) + 1;
+      dipSlotByRow.set(row, slot);
+      matingBridgeSlot.set(m.id, slot);
+    }
+  }
+  const rowDipBand = new Array(rowCount).fill(0);
+  for (const m of matings) {
+    const slot = matingBridgeSlot.get(m.id) ?? 0;
+    if (slot < 1) continue;
+    const [aId, bId] = partnersOf(m);
+    const a = individualById.get(aId);
+    const b = individualById.get(bId);
+    const gens = [a, b].filter((p) => p !== void 0).map((p) => p.generation);
+    if (gens.length === 0) continue;
+    const row = rowOfGeneration.get(Math.min(...gens));
+    rowDipBand[row] = Math.max(rowDipBand[row], BRIDGE_DIP_GAP + slot * BRIDGE_DIP_STEP + PED_LABEL_GAP);
+  }
+  const rowHeight = new Array(rowCount).fill(0);
+  for (const ind of individuals) {
+    const row = rowOfGeneration.get(ind.generation);
+    const lines = labelLinesOf.get(ind.id) ?? [];
+    const h = PED_GLYPH + PED_LABEL_GAP + rowDipBand[row] + (lines.length + 1) * PED_LABEL_LINE_H;
+    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);
+  }
+  const glyphCyOfRow = (row) => rowTop[row] + PED_GLYPH / 2;
+  const addressByIndividual = /* @__PURE__ */ new Map();
+  for (let row = 0; row < rowCount; row++) {
+    const roman = romanNumeral(row + 1);
+    const inRow = individuals.filter((i) => rowOfGeneration.get(i.generation) === row).sort((a, b) => placedById.get(a.id).cx - placedById.get(b.id).cx || a.id - b.id);
+    inRow.forEach((ind, i) => addressByIndividual.set(ind.id, `${roman}-${i + 1}`));
+  }
+  const declaredConditionIds = new Set(input.conditions.map((c) => c.id));
+  const usedConditionIds = [...new Set(individuals.flatMap((i) => i.affectedBy))].filter((id) => declaredConditionIds.has(id)).sort((x, y) => x - y);
+  const conditionFills = usedConditionIds.map((id, i) => ({
+    id,
+    ink: PED_CONDITION_FILLS[i % PED_CONDITION_FILLS.length],
+    label: conditionLabelById.get(id) ?? `condition ${id}`
+  }));
+  const nodes = [];
+  for (const ind of individuals) {
+    const placed = placedById.get(ind.id);
+    const row = rowOfGeneration.get(ind.generation);
+    const cy = glyphCyOfRow(row);
+    const lines = labelLinesOf.get(ind.id) ?? [];
+    const address = addressByIndividual.get(ind.id);
+    nodes.push({
+      individualId: ind.id,
+      shape: shapeForSex2(ind.sex),
+      cx: round5(placed.cx),
+      cy: round5(cy),
+      size: PED_GLYPH,
+      deceased: ind.deceased,
+      carrier: ind.carrier,
+      role: ind.role,
+      stillbirth: ind.lifeStatus === "stillbirth",
+      affectedBy: ind.affectedBy,
+      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: round5(cy + PED_GLYPH / 2 + PED_LABEL_GAP + rowDipBand[row]),
+      addressLabel: address,
+      title: individualTitle(ind, address, conditionLabelById, titleLabels)
+    });
+  }
+  const elements = [];
+  const cxOf = (id) => placedById.get(id).cx;
+  const cyOf = (id) => glyphCyOfRow(rowOfGeneration.get(individualById.get(id).generation));
+  const GLYPH_HALF = PED_GLYPH / 2;
+  const matingBarCenter = /* @__PURE__ */ new Map();
+  for (const s of sibships) {
+    const childIds = s.childIds.filter((id) => placedById.has(id));
+    if (childIds.length === 0) continue;
+    const xs = childIds.map(cxOf);
+    const center = (Math.min(...xs) + Math.max(...xs)) / 2;
+    matingBarCenter.set(s.matingId, center);
+  }
+  const matingMidpoint = /* @__PURE__ */ new Map();
+  const bridgeDipY = (slot) => BRIDGE_DIP_GAP + slot * BRIDGE_DIP_STEP;
+  for (const m of matings) {
+    const [aId, bId] = partnersOf(m);
+    const ax = cxOf(aId);
+    const bx = cxOf(bId);
+    const ay = cyOf(aId);
+    const by = cyOf(bId);
+    const leftId = ax <= bx ? aId : bId;
+    const rightId = ax <= bx ? bId : aId;
+    const lx = cxOf(leftId) + GLYPH_HALF;
+    const rx = cxOf(rightId) - GLYPH_HALF;
+    const title = m.consanguineous ? titleLabels.consanguineous : titleLabels.mating;
+    const bridgeSlot = matingBridgeSlot.get(m.id) ?? 0;
+    if (ay === by && bridgeSlot >= 1) {
+      const hubCx = cxOf(leftId);
+      const spouseCx = cxOf(rightId);
+      const glyphBottom = ay + GLYPH_HALF;
+      const dipY = glyphBottom + bridgeDipY(bridgeSlot);
+      const stubOff = Math.min(bridgeSlot * BRIDGE_STUB_X_STEP, GLYPH_HALF - 4);
+      const hubStubX = hubCx + stubOff;
+      const spouseStubX = spouseCx - stubOff;
+      elements.push({
+        edgeId: PED_MATING_ID_BASE + m.id,
+        kind: "mating-elbow",
+        points: [
+          { x: round5(hubStubX), y: round5(glyphBottom) },
+          { x: round5(hubStubX), y: round5(dipY) },
+          { x: round5(spouseStubX), y: round5(dipY) },
+          { x: round5(spouseStubX), y: round5(glyphBottom) }
+        ],
+        consanguineous: m.consanguineous,
+        title
+      });
+      matingMidpoint.set(m.id, { x: round5((hubStubX + spouseStubX) / 2), y: round5(dipY) });
+    } else if (ay === by) {
+      const y = ay;
+      elements.push({
+        edgeId: PED_MATING_ID_BASE + m.id,
+        kind: "mating",
+        points: [
+          { x: round5(lx), y: round5(y) },
+          { x: round5(rx), y: round5(y) }
+        ],
+        consanguineous: m.consanguineous,
+        title
+      });
+      const midX = (lx + rx) / 2;
+      const channelLeft = cxOf(leftId) + nodeHalfWidth(individualById.get(leftId));
+      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: round5(originX), y: round5(y) });
+    } else {
+      const upId = ay <= by ? aId : bId;
+      const downId = ay <= by ? bId : aId;
+      const upX = cxOf(upId);
+      const upY = cyOf(upId);
+      const downX = cxOf(downId);
+      const downY = cyOf(downId);
+      if (childToSibship.has(downId)) {
+        const upRow = rowOfGeneration.get(individualById.get(upId).generation);
+        const laneY = rowTop[upRow] + rowHeight[upRow] + CORRIDOR2 / 4 + 4;
+        const downRight = downX >= upX;
+        const upExitX = upX + (downRight ? -1 : 1) * (nodeHalfWidth(individualById.get(upId)) + 6);
+        const downFarX = downX + (downRight ? 1 : -1) * (GLYPH_HALF + H_GAP2 / 2);
+        const downSideX = downX + (downRight ? 1 : -1) * GLYPH_HALF;
+        elements.push({
+          edgeId: PED_MATING_ID_BASE + m.id,
+          kind: "mating-elbow",
+          points: [
+            { x: round5(upX + (downRight ? -GLYPH_HALF : GLYPH_HALF)), y: round5(upY) },
+            { x: round5(upExitX), y: round5(upY) },
+            { x: round5(upExitX), y: round5(laneY) },
+            { x: round5(downFarX), y: round5(laneY) },
+            { x: round5(downFarX), y: round5(downY) },
+            { x: round5(downSideX), y: round5(downY) }
+          ],
+          consanguineous: m.consanguineous,
+          title
+        });
+        matingMidpoint.set(m.id, { x: round5(downFarX), y: round5(downY) });
+      } else {
+        const elbowX = (upX + downX) / 2;
+        elements.push({
+          edgeId: PED_MATING_ID_BASE + m.id,
+          kind: "mating-elbow",
+          points: [
+            { x: round5(upX + (downX >= upX ? GLYPH_HALF : -GLYPH_HALF)), y: round5(upY) },
+            { x: round5(elbowX), y: round5(upY) },
+            { x: round5(elbowX), y: round5(downY) },
+            { x: round5(downX + (upX >= downX ? GLYPH_HALF : -GLYPH_HALF)), y: round5(downY) }
+          ],
+          consanguineous: m.consanguineous,
+          title
+        });
+        matingMidpoint.set(m.id, { x: round5(elbowX), y: round5(downY) });
+      }
+    }
+  }
+  const twinZygositiesUsedSet = /* @__PURE__ */ new Set();
+  const unknownTwinJunctions = [];
+  const bendLaneByRow = /* @__PURE__ */ new Map();
+  for (const s of sibships) {
+    const childIds = s.childIds.filter((id) => individualById.has(id));
+    if (childIds.length === 0) continue;
+    const mid = matingMidpoint.get(s.matingId);
+    const childRow = rowOfGeneration.get(individualById.get(childIds[0]).generation);
+    const barY = rowTop[childRow] - CORRIDOR2 / 2;
+    const lane = bendLaneByRow.get(childRow) ?? 0;
+    bendLaneByRow.set(childRow, lane + 1);
+    const childXs = childIds.map(cxOf);
+    const barLeft = Math.min(...childXs);
+    const barRight = Math.max(...childXs);
+    if (mid !== void 0) {
+      const barCenterX = (barLeft + barRight) / 2;
+      const bendY = barY - 2 - lane % 3 * 3;
+      const descentPoints = Math.abs(mid.x - barCenterX) < 0.01 ? [
+        { x: round5(mid.x), y: round5(mid.y) },
+        { x: round5(mid.x), y: round5(barY) }
+      ] : [
+        { x: round5(mid.x), y: round5(mid.y) },
+        { x: round5(mid.x), y: round5(bendY) },
+        { x: round5(barCenterX), y: round5(bendY) },
+        { x: round5(barCenterX), y: round5(barY) }
+      ];
+      elements.push({
+        edgeId: PED_DESCENT_ID_BASE + s.id,
+        kind: "descent",
+        points: descentPoints,
+        consanguineous: false,
+        title: titleLabels.sibship
+      });
+    }
+    if (childIds.length > 1) {
+      elements.push({
+        edgeId: PED_SIBBAR_ID_BASE + s.id,
+        kind: "sibship-bar",
+        points: [
+          { x: round5(barLeft), y: round5(barY) },
+          { x: round5(barRight), y: round5(barY) }
+        ],
+        consanguineous: false,
+        title: titleLabels.sibship
+      });
+    }
+    const twinGroupOfChild = /* @__PURE__ */ new Map();
+    s.twinGroups.forEach((tg, ordinal) => {
+      const members = tg.childIds.filter((id) => childIds.includes(id));
+      for (const id of members) twinGroupOfChild.set(id, { ordinal, zygosity: tg.zygosity, members });
+    });
+    const emittedTwinOrdinals = /* @__PURE__ */ new Set();
+    for (const childId of childIds) {
+      const cx = cxOf(childId);
+      const childTop = cyOf(childId) - PED_GLYPH / 2;
+      const tg = twinGroupOfChild.get(childId);
+      if (tg === void 0) {
+        elements.push({
+          edgeId: PED_RISER_ID_BASE + childId,
+          kind: "riser",
+          points: [
+            { x: round5(cx), y: round5(barY) },
+            { x: round5(cx), y: round5(childTop) }
+          ],
+          consanguineous: false,
+          title: titleLabels.sibship
+        });
+        continue;
+      }
+      const memberXs = tg.members.map(cxOf);
+      const junctionX = (Math.min(...memberXs) + Math.max(...memberXs)) / 2;
+      const junctionY = barY + TWIN_JUNCTION_DROP;
+      twinZygositiesUsedSet.add(tg.zygosity);
+      if (!emittedTwinOrdinals.has(tg.ordinal)) {
+        emittedTwinOrdinals.add(tg.ordinal);
+        if (tg.zygosity === "unknown") {
+          unknownTwinJunctions.push({ x: round5(junctionX), y: round5(junctionY) });
+        }
+        elements.push({
+          edgeId: PED_RISER_ID_BASE + childId,
+          // anchored on the first member for a stable id
+          kind: "riser",
+          points: [
+            { x: round5(junctionX), y: round5(barY) },
+            { x: round5(junctionX), y: round5(junctionY) }
+          ],
+          consanguineous: false,
+          title: titleLabels.twins[tg.zygosity]
+        });
+        if (tg.zygosity === "mz" && memberXs.length >= 2) {
+          const tieY = junctionY + 6;
+          elements.push({
+            edgeId: PED_TWINBAR_ID_BASE + s.id * 100 + tg.ordinal,
+            kind: "twin-bar",
+            points: [
+              { x: round5(Math.min(...memberXs)), y: round5(tieY) },
+              { x: round5(Math.max(...memberXs)), y: round5(tieY) }
+            ],
+            consanguineous: false,
+            title: titleLabels.twins.mz
+          });
+        }
+      }
+      const horizontalThenDown = Math.abs(cx - junctionX) < 0.01 ? [
+        { x: round5(cx), y: round5(junctionY) },
+        { x: round5(cx), y: round5(childTop) }
+      ] : [
+        { x: round5(junctionX), y: round5(junctionY) },
+        { x: round5(cx), y: round5(junctionY) },
+        { x: round5(cx), y: round5(childTop) }
+      ];
+      elements.push({
+        edgeId: PED_RISER_ID_BASE + childId,
+        kind: "riser",
+        points: horizontalThenDown,
+        consanguineous: false,
+        title: titleLabels.twins[tg.zygosity]
+      });
+    }
+  }
+  let maxX = PADDING5 * 2;
+  let maxY = PADDING5 * 2;
+  for (const n of nodes) {
+    const labelW = n.labelLines.reduce((m, l) => Math.max(m, estimateTextWidth(l, PED_LABEL_FONT)), 0);
+    const half = Math.max(PED_GLYPH, labelW) / 2;
+    maxX = Math.max(maxX, n.cx + half + PADDING5);
+    const labelBottom = n.labelTop + (n.labelLines.length + 1) * PED_LABEL_LINE_H;
+    maxY = Math.max(maxY, labelBottom + PADDING5);
+  }
+  for (const el of elements) {
+    for (const p of el.points) {
+      maxX = Math.max(maxX, p.x + PADDING5);
+      maxY = Math.max(maxY, p.y + PADDING5);
+    }
+  }
+  const generations = [];
+  for (let row = 0; row < rowCount; row++) {
+    generations.push({ roman: romanNumeral(row + 1), y: round5(glyphCyOfRow(row)) });
+  }
+  const ZYGOSITY_ORDER = ["mz", "dz", "unknown"];
+  const twinZygositiesUsed = ZYGOSITY_ORDER.filter((z) => twinZygositiesUsedSet.has(z));
+  return {
+    width: Math.ceil(maxX),
+    height: Math.ceil(maxY),
+    nodes,
+    elements,
+    generations,
+    conditionFills,
+    twinZygositiesUsed,
+    unknownTwinJunctions,
+    isolatedIndividualIds
+  };
+}
+
+// src/pedigree/svg.ts
+var GLYPH_STROKE3 = "#52525b";
+var LABEL_FILL4 = "#3f3f46";
+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 round6 = (n) => Math.round(n * 100) / 100;
+function glyphOutline(shape, cx, cy, half) {
+  if (shape === "square") {
+    return `<rect x="${round6(cx - half)}" y="${round6(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},${round6(cy - half)} ${round6(cx + half)},${cy} ${cx},${round6(cy + half)} ${round6(cx - half)},${cy}" ${GLYPH_ATTRS2}/>`;
+}
+function glyphVerticalExtentAt(shape, cy, half, dx) {
+  const ax = Math.min(Math.abs(dx), half);
+  if (shape === "square") return [cy - half, cy + half];
+  if (shape === "circle") {
+    const h2 = Math.sqrt(Math.max(0, half * half - ax * ax));
+    return [cy - h2, cy + h2];
+  }
+  const h = half - ax;
+  return [cy - h, cy + h];
+}
+function fillPartitions(n, half, inkByCondition) {
+  const ids = n.affectedBy;
+  if (ids.length === 0) return "";
+  const cx = n.cx;
+  const cy = n.cy;
+  const sliceW = half * 2 / ids.length;
+  return ids.map((id, i) => {
+    const left = cx - half + i * sliceW;
+    const SAMPLES = 8;
+    const top = [];
+    const bottom = [];
+    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(`${round6(x)},${round6(yt)}`);
+      bottom.push(`${round6(x)},${round6(yb)}`);
+    }
+    const pts = [...top, ...bottom.reverse()].join(" ");
+    const ink = inkByCondition.get(id) ?? GLYPH_STROKE3;
+    return `<polygon points="${pts}" fill="${ink}" stroke="none"/>`;
+  }).join("");
+}
+function carrierDot(n) {
+  if (!n.carrier || n.affectedBy.length > 0) return "";
+  return `<circle cx="${n.cx}" cy="${n.cy}" r="4" fill="${GLYPH_STROKE3}" stroke="none"/>`;
+}
+function deceasedSlash(n, half) {
+  if (!n.deceased) return "";
+  const ext = half + 4;
+  return `<line x1="${round6(n.cx - ext)}" y1="${round6(n.cy - ext)}" x2="${round6(n.cx + ext)}" y2="${round6(n.cy + ext)}" stroke="${GLYPH_STROKE3}" stroke-width="2"/>`;
+}
+function probandArrow(n, half) {
+  if (n.role === null) return "";
+  const tipX = round6(n.cx - half);
+  const tipY = round6(n.cy + half);
+  const tailX = round6(tipX - 16);
+  const tailY = round6(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} ${round6(tipX - 8)},${round6(tipY + 2)} ${round6(tipX - 2)},${round6(tipY + 8)}" fill="${fill}" stroke="${GLYPH_STROKE3}" stroke-width="1.5"/>`;
+  return shaft + head;
+}
+function stillbirthMark(n, half) {
+  if (!n.stillbirth) return "";
+  const y = round6(n.cy + half + PED_ADDRESS_FONT);
+  return `<text x="${round6(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;
+  const pieces = [
+    `<title>${xmlEscape(n.title)}</title>`,
+    // Fill partitions sit UNDER the outline so the border stays crisp.
+    fillPartitions(n, half, inkByCondition),
+    glyphOutline(n.shape, n.cx, n.cy, half),
+    carrierDot(n),
+    deceasedSlash(n, half),
+    probandArrow(n, half),
+    stillbirthMark(n, half)
+  ];
+  const addressY = round6(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 = round6(n.labelTop + PED_LABEL_LINE_H + 10);
+    const tspans = n.labelLines.map((line, i) => `<tspan x="${n.cx}" y="${round6(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>`
+    );
+  }
+  return `<g data-individual-id="p${n.individualId}">${pieces.join("")}</g>`;
+}
+function pathData3(points) {
+  return points.map((p, i) => `${i === 0 ? "M" : "L"} ${p.x} ${p.y}`).join(" ");
+}
+function elementSvg3(el) {
+  const pts = el.points;
+  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: round6(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}/>`;
+    }
+    return `<path d="${pathData3(shifted)}" fill="none" ${stroke}/>`;
+  };
+  const body = el.consanguineous && (el.kind === "mating" || el.kind === "mating-elbow") ? draw(-CONSANG_GAP / 2) + draw(CONSANG_GAP / 2) : draw(0);
+  return `<g data-edge-id="${el.edgeId}">${title}${body}</g>`;
+}
+function unknownTwinMarks(layout) {
+  return layout.unknownTwinJunctions.map(
+    (p) => `<text x="${round6(p.x + 6)}" y="${round6(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 = round6(x + LEGEND_SWATCH_W / 2);
+  if (shape === "square") return `<rect x="${round6(cx - 6)}" y="${round6(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},${round6(y - 7)} ${round6(cx + 7)},${y} ${cx},${round6(y + 7)} ${round6(cx - 7)},${y}" ${MINI_ATTRS2}/>`;
+}
+function miniSwatchCircle(filled, ink, x, y) {
+  const cx = round6(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 = round6(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 = round6(x + LEGEND_SWATCH_W / 2);
+  return `<circle cx="${cx}" cy="${y}" r="6" ${MINI_ATTRS2}/><line x1="${round6(cx - 7)}" y1="${round6(y - 7)}" x2="${round6(cx + 7)}" y2="${round6(y + 7)}" stroke="${GLYPH_STROKE3}" stroke-width="1.5"/>`;
+}
+function miniArrowSwatch(filled, x, y) {
+  const cx = round6(x + LEGEND_SWATCH_W / 2);
+  const tipX = round6(cx - 2);
+  const tipY = round6(y + 2);
+  return `<line x1="${round6(tipX - 8)}" y1="${round6(tipY + 8)}" x2="${tipX}" y2="${tipY}" stroke="${GLYPH_STROKE3}" stroke-width="1.5"/><polygon points="${tipX},${tipY} ${round6(tipX - 5)},${round6(tipY + 1)} ${round6(tipX - 1)},${round6(tipY + 5)}" fill="${filled ? GLYPH_STROKE3 : "transparent"}" stroke="${GLYPH_STROKE3}" stroke-width="1"/>`;
+}
+function miniConsanguineousSwatch(x, y) {
+  const x1 = round6(x + 2);
+  const x2 = round6(x + LEGEND_SWATCH_W - 2);
+  return `<line x1="${x1}" y1="${round6(y - 1.5)}" x2="${x2}" y2="${round6(y - 1.5)}" stroke="${EDGE_INK5}" stroke-width="1.5"/><line x1="${x1}" y1="${round6(y + 1.5)}" x2="${x2}" y2="${round6(y + 1.5)}" stroke="${EDGE_INK5}" stroke-width="1.5"/>`;
+}
+function miniTwinSwatch(zygosity, x, y) {
+  const cx = round6(x + LEGEND_SWATCH_W / 2);
+  const apexY = round6(y - 6);
+  const baseY = round6(y + 6);
+  const left = round6(cx - 6);
+  const right = round6(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="${round6(y + 3)}" x2="${right}" y2="${round6(y + 3)}" stroke="${EDGE_INK5}" stroke-width="1.5"/>`;
+  }
+  if (zygosity === "unknown") {
+    return stub + `<text x="${round6(cx + 8)}" y="${round6(y + 3)}" font-family="${FONT_FAMILY}" font-size="9" fill="${LABEL_FILL4}">?</text>`;
+  }
+  return stub;
+}
+function pedigreeLayoutSvg(layout, opts = {}) {
+  const labels = opts.labels ?? PEDIGREE_SVG_LABELS_EN;
+  const inkByCondition = new Map(layout.conditionFills.map((c) => [c.id, c.ink]));
+  const parts = [];
+  for (const el of layout.elements) parts.push(elementSvg3(el));
+  parts.push(unknownTwinMarks(layout));
+  for (const n of layout.nodes) parts.push(nodeSvg2(n, inkByCondition));
+  for (const g of layout.generations) {
+    parts.push(
+      `<text x="${round6(16)}" y="${round6(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;
+  let height = layout.height;
+  if (opts.legend !== false && layout.nodes.length > 0) {
+    const entries = [];
+    const shapesUsed = new Set(layout.nodes.map((n) => n.shape));
+    for (const shape of ["square", "circle", "diamond"]) {
+      if (!shapesUsed.has(shape)) continue;
+      entries.push({ swatch: (x, y) => miniShapeSwatch(shape, x, y), label: labels.shapes[shape] });
+    }
+    for (const c of layout.conditionFills) {
+      entries.push({ swatch: (x, y) => miniSwatchCircle(true, c.ink, x, y), label: c.label });
+    }
+    if (layout.nodes.some((n) => n.affectedBy.length === 0)) {
+      entries.push({ swatch: (x, y) => miniSwatchCircle(false, GLYPH_STROKE3, x, y), label: labels.unaffected });
+    }
+    if (layout.nodes.some((n) => n.carrier && n.affectedBy.length === 0)) {
+      entries.push({ swatch: miniCarrierSwatch, label: labels.carrier });
+    }
+    if (layout.nodes.some((n) => n.deceased)) {
+      entries.push({ swatch: miniDeceasedSwatch, label: labels.deceased });
+    }
+    if (layout.nodes.some((n) => n.role === "proband")) {
+      entries.push({ swatch: (x, y) => miniArrowSwatch(true, x, y), label: labels.proband });
+    }
+    if (layout.nodes.some((n) => n.role === "consultand")) {
+      entries.push({ swatch: (x, y) => miniArrowSwatch(false, x, y), label: labels.consultand });
+    }
+    if (layout.nodes.some((n) => n.stillbirth)) {
+      entries.push({ swatch: () => "", label: labels.stillbirth });
+    }
+    if (layout.elements.some((el) => el.consanguineous)) {
+      entries.push({ swatch: miniConsanguineousSwatch, label: labels.consanguineous });
+    }
+    const twinsUsed = new Set(layout.twinZygositiesUsed);
+    for (const z of ZYGOSITIES) {
+      if (!twinsUsed.has(z)) continue;
+      entries.push({ swatch: (x, y) => miniTwinSwatch(z, x, y), label: labels.twins[z] });
+    }
+    if (layout.isolatedIndividualIds.length > 0) {
+      entries.push({ swatch: () => "", label: labels.isolated });
+    }
+    const block = legendBlock(entries, layout.height);
+    if (block.svg !== "") {
+      parts.push(block.svg);
+      width = Math.max(width, block.width);
+      height = block.height;
+    }
+  }
+  const w = Math.ceil(width);
+  const h = Math.ceil(height);
+  return `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 ${w} ${h}" width="${w}" height="${h}" role="img" aria-label="${xmlEscape(labels.ariaLabel)}">` + parts.join("") + `</svg>`;
+}
+
+// src/pedigree/render.ts
+function pedigreeSvg(input, opts = {}) {
+  const layout = computePedigreeLayout(input, {
+    ...opts.maxLabelChars !== void 0 ? { maxLabelChars: opts.maxLabelChars } : {},
+    ...opts.titleLabels !== void 0 ? { titleLabels: opts.titleLabels } : {}
+  });
+  const svg = pedigreeLayoutSvg(layout, {
+    ...opts.legend === false ? { legend: false } : {},
+    ...opts.svgLabels !== void 0 ? { labels: opts.svgLabels } : {}
+  });
+  return { svg, layout };
+}
+
+// src/phylo/labels.ts
+var PHYLO_TITLE_LABELS_EN = {
+  branchLength: "branch length",
+  support: "support",
+  clade: "clade",
+  tip: "tip",
+  root: "root"
+};
+var PHYLO_SVG_LABELS_EN = {
+  support: "Support value (bootstrap/posterior)",
+  scaleBar: "Scale: substitutions per site",
+  alignedTip: "Aligned tip (true position dotted)",
+  ariaLabel: {
+    cladogram: "Phylogenetic tree (cladogram)",
+    phylogram: "Phylogenetic tree (phylogram)"
+  }
+};
+
+// src/phylo/validate.ts
+var PhyloValidationError = class extends Error {
+  issues;
+  constructor(issues) {
+    super(`invalid phylo tree: ${issues.map((i) => i.message).join("; ")}`);
+    this.name = "PhyloValidationError";
+    this.issues = issues;
+  }
+};
+function sortIssues3(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 phyloIssues(input) {
+  if (input.nodes.length === 0 && input.edges.length === 0) return [];
+  const issues = [];
+  const push = (code, message) => {
+    issues.push({ code, message });
+  };
+  const nodeById = /* @__PURE__ */ new Map();
+  const dupNodeIds = /* @__PURE__ */ new Set();
+  for (const n of input.nodes) {
+    if (nodeById.has(n.id)) dupNodeIds.add(n.id);
+    else nodeById.set(n.id, n);
+  }
+  for (const id of [...dupNodeIds].sort((a, b) => a - b)) {
+    push("duplicate-id", `duplicate node id ${id}`);
+  }
+  const dupEdgeIds = /* @__PURE__ */ new Set();
+  const seenEdgeIds = /* @__PURE__ */ new Set();
+  for (const e of input.edges) {
+    if (seenEdgeIds.has(e.id)) dupEdgeIds.add(e.id);
+    else seenEdgeIds.add(e.id);
+  }
+  for (const id of [...dupEdgeIds].sort((a, b) => a - b)) {
+    push("duplicate-id", `duplicate edge id ${id}`);
+  }
+  if (issues.length > 0) {
+    return sortIssues3(issues);
+  }
+  if (!nodeById.has(input.rootId)) {
+    push("unknown-root", `rootId ${input.rootId} is not a declared node`);
+  }
+  const incomingByChild = /* @__PURE__ */ new Map();
+  for (const e of [...input.edges].sort((a, b) => a.id - b.id)) {
+    const knownParent = nodeById.has(e.parentId);
+    const knownChild = nodeById.has(e.childId);
+    if (!knownParent) push("unknown-endpoint", `edge ${e.id} parentId ${e.parentId} is not a declared node`);
+    if (!knownChild) push("unknown-endpoint", `edge ${e.id} childId ${e.childId} is not a declared node`);
+    if (e.length !== null && (!Number.isFinite(e.length) || e.length < 0)) {
+      push("negative-length", `edge ${e.id} has non-finite or negative length ${e.length}`);
+    }
+    if (knownParent && knownChild) {
+      const arr = incomingByChild.get(e.childId) ?? [];
+      arr.push(e.parentId);
+      incomingByChild.set(e.childId, arr);
+    }
+  }
+  const childIdsWithEdges = /* @__PURE__ */ new Set();
+  for (const e of input.edges) childIdsWithEdges.add(e.childId);
+  for (const [childId, parents] of [...incomingByChild.entries()].sort((a, b) => a[0] - b[0])) {
+    if (parents.length > 1) {
+      push("multiple-parents", `node ${childId} has ${parents.length} parents`);
+    }
+  }
+  const hasChildren = /* @__PURE__ */ new Set();
+  for (const e of input.edges) {
+    if (nodeById.has(e.parentId)) hasChildren.add(e.parentId);
+  }
+  for (const n of [...nodeById.values()].sort((a, b) => a.id - b.id)) {
+    if (n.isTip === true && hasChildren.has(n.id)) {
+      push("tip-with-children", `node ${n.id} is declared a tip but has children`);
+    } else if (n.isTip === false && !hasChildren.has(n.id)) {
+      push("tip-with-children", `node ${n.id} is declared internal but has no children`);
+    }
+  }
+  const GRAPH_BLOCKING = /* @__PURE__ */ new Set([
+    "duplicate-id",
+    "unknown-endpoint",
+    "unknown-root",
+    "multiple-parents"
+  ]);
+  if (!issues.some((i) => GRAPH_BLOCKING.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) ?? [];
+      arr.push(e.childId);
+      childrenOf.set(e.parentId, arr);
+    }
+    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 = childrenOf.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("cycle", `cycle: ${[...rotated, rotated[0]].join(" \u2192 ")}`);
+          }
+        } else if (c === 0) {
+          color.set(child, 1);
+          stack.push({ id: child, nextChild: 0 });
+        }
+      }
+    };
+    for (const n of [...nodeById.values()].sort((a, b) => a.id - b.id)) {
+      if ((color.get(n.id) ?? 0) === 0) dfs(n.id);
+    }
+    const reachable = /* @__PURE__ */ new Set();
+    const queue = [input.rootId];
+    while (queue.length > 0) {
+      const id = queue.shift();
+      if (reachable.has(id)) continue;
+      reachable.add(id);
+      for (const childId of childrenOf.get(id) ?? []) queue.push(childId);
+    }
+    for (const n of [...nodeById.values()].sort((a, b) => a.id - b.id)) {
+      if (!reachable.has(n.id)) push("disconnected-node", `node ${n.id} is unreachable from the root`);
+    }
+  }
+  return sortIssues3(issues);
+}
+function validatePhylo(input) {
+  const issues = phyloIssues(input);
+  if (issues.length > 0) throw new PhyloValidationError(issues);
+}
+
+// src/phylo/layout.ts
+var PHYLO_LABEL_FONT = 12;
+var PHYLO_ROW_SLOT = 22;
+var PHYLO_SUPPORT_FONT = 10;
+var PHYLO_LABEL_GAP = 8;
+var PADDING6 = 32;
+var PHYLO_LEVEL_W = 72;
+var PHYLO_TIP_R = 2.5;
+var SUPPORT_GAP = 4;
+var SCALEBAR_ZONE = 34;
+var MIN_DRAW_W = PHYLO_LEVEL_W;
+var PHYLO_ZERO_NUDGE = 1;
+var PHYLO_CLADEBAR_ID_BASE = 1e6;
+var PHYLO_BRANCH_ID_BASE = 2e6;
+var PHYLO_EXTENSION_ID_BASE = 3e6;
+var PHYLO_ROOTSTUB_ID_BASE = 4e6;
+var PHYLO_SCALEBAR_ID = 5e6;
+var round7 = (n) => Math.round(n * 100) / 100;
+function niceScaleStep(maxLen) {
+  if (!(maxLen > 0)) return 0;
+  const target = maxLen / 4;
+  const exp = Math.floor(Math.log10(target));
+  const pow = Math.pow(10, exp);
+  const tol = target * 1e-9;
+  for (const mult of [5, 2, 1]) {
+    const step = mult * pow;
+    if (step <= target + tol) return step;
+  }
+  return 5 * Math.pow(10, exp - 1);
+}
+function trimNumber(n) {
+  if (Number.isInteger(n)) return String(n);
+  return String(Number(n.toPrecision(6))).replace(/0+$/, "").replace(/\.$/, "");
+}
+function nodeTitle(node, isTip, isRoot, inLength, labels) {
+  if (node.title !== void 0) return node.title;
+  const role = isRoot ? labels.root : isTip ? labels.tip : labels.clade;
+  const head = node.label === "" ? role : node.label;
+  const parts = [head];
+  if (inLength !== null) parts.push(`${labels.branchLength}: ${trimNumber(inLength)}`);
+  if (!isTip && node.support !== void 0 && node.support !== null) {
+    parts.push(`${labels.support}: ${trimNumber(node.support)}`);
+  }
+  return parts.join(" \xB7 ");
+}
+function computePhyloLayout(input, opts = {}) {
+  const mode = opts.mode ?? "cladogram";
+  if (input.nodes.length === 0 && input.edges.length === 0) {
+    return { width: PADDING6 * 2, height: PADDING6 * 2, mode, nodes: [], elements: [], scaleBar: null, showSupport: false };
+  }
+  validatePhylo(input);
+  const titleLabels = opts.titleLabels ?? PHYLO_TITLE_LABELS_EN;
+  const alignTips = opts.alignTips ?? mode === "cladogram";
+  const showSupport = opts.showSupport ?? false;
+  const wantScaleBar = (opts.scaleBar ?? true) && mode === "phylogram";
+  const nodeById = new Map(input.nodes.map((n) => [n.id, n]));
+  const childrenOf = /* @__PURE__ */ new Map();
+  const inLengthByChild = /* @__PURE__ */ new Map();
+  for (const e of [...input.edges].sort((a, b) => a.id - b.id)) {
+    (childrenOf.get(e.parentId) ?? childrenOf.set(e.parentId, []).get(e.parentId)).push(e.childId);
+    inLengthByChild.set(e.childId, e.length);
+  }
+  const allWork = [];
+  const build = (nodeId, depth, dist) => {
+    const node = nodeById.get(nodeId);
+    const inLength = inLengthByChild.get(nodeId) ?? null;
+    const work = { node, children: [], depth, dist, inLength, cx: 0, cy: 0 };
+    allWork.push(work);
+    for (const childId of childrenOf.get(nodeId) ?? []) {
+      const childLen = inLengthByChild.get(childId);
+      const add = childLen === null || childLen === void 0 ? 0 : Math.max(0, childLen);
+      work.children.push(build(childId, depth + 1, dist + add));
+    }
+    return work;
+  };
+  const root = build(input.rootId, 0, 0);
+  const isTip = (w) => w.children.length === 0;
+  const top = PADDING6;
+  let tipIndex = 0;
+  const assignY = (w) => {
+    if (isTip(w)) {
+      w.cy = top + tipIndex * PHYLO_ROW_SLOT + PHYLO_ROW_SLOT / 2;
+      tipIndex += 1;
+      return;
+    }
+    for (const c of w.children) assignY(c);
+    const ys = w.children.map((c) => c.cy);
+    w.cy = (Math.min(...ys) + Math.max(...ys)) / 2;
+  };
+  assignY(root);
+  const tipCount = tipIndex;
+  const maxDepth = allWork.reduce((m, w) => Math.max(m, w.depth), 0);
+  const maxDist = allWork.reduce((m, w) => Math.max(m, w.dist), 0);
+  const supportNodes = allWork.filter(
+    (w) => !isTip(w) && w.node.support !== void 0 && w.node.support !== null
+  );
+  const effectiveShowSupport = showSupport && supportNodes.length > 0;
+  const supportMargin = effectiveShowSupport ? supportNodes.reduce(
+    (m, w) => Math.max(m, estimateTextWidth(trimNumber(w.node.support), PHYLO_SUPPORT_FONT)),
+    0
+  ) + SUPPORT_GAP : 0;
+  const padLeft = PADDING6 + supportMargin;
+  const tipLabelW = allWork.filter(isTip).reduce((m, w) => Math.max(m, estimateTextWidth(clampLabel(w.node.label, opts.maxLabelChars), PHYLO_LABEL_FONT)), 0);
+  const labelReserve = (tipCount > 0 ? PHYLO_LABEL_GAP + tipLabelW : 0) + PADDING6;
+  const phylogramScaled = mode === "phylogram" && maxDist > 0;
+  const drawW = Math.max(MIN_DRAW_W, maxDepth * PHYLO_LEVEL_W);
+  const scale = phylogramScaled ? drawW / maxDist : 0;
+  const xOf = (w) => {
+    if (phylogramScaled) return padLeft + w.dist * scale;
+    return padLeft + w.depth * PHYLO_LEVEL_W;
+  };
+  for (const w of allWork) w.cx = xOf(w);
+  if (phylogramScaled) {
+    const nudge = (w) => {
+      for (const c of w.children) {
+        if (!isTip(c) && c.cx <= w.cx + 1e-6) c.cx = w.cx + PHYLO_ZERO_NUDGE;
+        nudge(c);
+      }
+    };
+    nudge(root);
+  }
+  const tipsAligned = alignTips;
+  const maxTipX = allWork.filter(isTip).reduce((m, w) => Math.max(m, w.cx), padLeft);
+  const alignX = phylogramScaled ? maxTipX : padLeft + maxDepth * PHYLO_LEVEL_W;
+  const tipDrawX = (w) => tipsAligned ? alignX : w.cx;
+  const rightmost = tipsAligned ? alignX : allWork.reduce((m, w) => Math.max(m, w.cx), padLeft);
+  const treeBottom = top + (tipCount > 0 ? tipCount * PHYLO_ROW_SLOT : PHYLO_ROW_SLOT);
+  const scaleBarPx = wantScaleBar && maxDist > 0 ? niceScaleStep(maxDist) * scale : 0;
+  const hasScaleBar = wantScaleBar && maxDist > 0 && scaleBarPx > 0;
+  const width = Math.ceil(rightmost + labelReserve);
+  const height = Math.ceil(treeBottom + (hasScaleBar ? SCALEBAR_ZONE : 0) + PADDING6 / 2);
+  const nodes = [];
+  const elements = [];
+  const branchTitle = (w) => {
+    if (w.inLength !== null) return `${titleLabels.branchLength}: ${trimNumber(w.inLength)}`;
+    return titleLabels.branchLength;
+  };
+  const ROOT_STUB = 14;
+  const rootDrawX = isTip(root) ? tipDrawX(root) : root.cx;
+  elements.push({
+    edgeId: PHYLO_ROOTSTUB_ID_BASE + root.node.id,
+    kind: "root-stub",
+    points: [
+      { x: round7(Math.max(PADDING6 / 2, rootDrawX - ROOT_STUB)), y: round7(root.cy) },
+      { x: round7(rootDrawX), y: round7(root.cy) }
+    ],
+    dotted: false,
+    length: null,
+    title: titleLabels.root
+  });
+  const emit = (w) => {
+    const tip = isTip(w);
+    const isRoot = w === root;
+    const drawX = tip ? tipDrawX(w) : w.cx;
+    const support = w.node.support === void 0 ? null : w.node.support;
+    const labelLine = tip && w.node.label !== "" ? [clampLabel(w.node.label, opts.maxLabelChars)] : [];
+    nodes.push({
+      nodeId: w.node.id,
+      isTip: tip,
+      cx: round7(drawX),
+      cy: round7(w.cy),
+      support,
+      labelLines: labelLine,
+      labelLeft: round7(drawX + PHYLO_TIP_R + PHYLO_LABEL_GAP),
+      depth: w.depth,
+      title: nodeTitle(w.node, tip, isRoot, w.inLength, titleLabels)
+    });
+    if (tip && tipsAligned && w.cx < alignX - 1e-6) {
+      elements.push({
+        edgeId: PHYLO_EXTENSION_ID_BASE + w.node.id,
+        kind: "extension",
+        points: [
+          { x: round7(w.cx), y: round7(w.cy) },
+          { x: round7(alignX), y: round7(w.cy) }
+        ],
+        dotted: true,
+        length: null,
+        title: titleLabels.tip
+      });
+    }
+    if (w.children.length === 0) return;
+    const childYs = w.children.map((c) => c.cy);
+    const barTop = Math.min(...childYs);
+    const barBottom = Math.max(...childYs);
+    if (barBottom - barTop > 1e-6) {
+      elements.push({
+        edgeId: PHYLO_CLADEBAR_ID_BASE + w.node.id,
+        kind: "clade-bar",
+        points: [
+          { x: round7(w.cx), y: round7(barTop) },
+          { x: round7(w.cx), y: round7(barBottom) }
+        ],
+        dotted: false,
+        length: null,
+        title: isRoot ? titleLabels.root : titleLabels.clade
+      });
+    }
+    for (const c of w.children) {
+      elements.push({
+        edgeId: PHYLO_BRANCH_ID_BASE + c.node.id,
+        kind: "branch",
+        points: [
+          { x: round7(w.cx), y: round7(c.cy) },
+          { x: round7(c.cx), y: round7(c.cy) }
+        ],
+        dotted: false,
+        length: c.inLength,
+        title: branchTitle(c)
+      });
+    }
+    for (const c of w.children) emit(c);
+  };
+  emit(root);
+  let scaleBar = null;
+  if (hasScaleBar) {
+    const stepLen = niceScaleStep(maxDist);
+    const barX = padLeft;
+    const barY = treeBottom + SCALEBAR_ZONE / 2;
+    scaleBar = {
+      length: stepLen,
+      x: round7(barX),
+      y: round7(barY),
+      pxLength: round7(scaleBarPx),
+      valueLabel: trimNumber(stepLen)
+    };
+    elements.push({
+      edgeId: PHYLO_SCALEBAR_ID,
+      kind: "scale-bar",
+      points: [
+        { x: round7(barX), y: round7(barY) },
+        { x: round7(barX + scaleBarPx), y: round7(barY) }
+      ],
+      dotted: false,
+      length: stepLen,
+      title: `${titleLabels.branchLength}: ${trimNumber(stepLen)}`
+    });
+  }
+  return { width, height, mode, nodes, elements, scaleBar, showSupport: effectiveShowSupport };
+}
+
+// src/phylo/svg.ts
+var GLYPH_STROKE4 = "#52525b";
+var LABEL_FILL5 = "#3f3f46";
+var EDGE_INK6 = "#71717a";
+var round8 = (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="${round8(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="${round8(n.cx - 4)}" y="${round8(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>`;
+}
+function elementSvg4(el) {
+  const a = el.points[0];
+  const b = el.points[1];
+  const dash = el.dotted ? ` stroke-dasharray="2,3"` : "";
+  const opacity = el.kind === "extension" ? "0.5" : "0.75";
+  return `<g data-edge-id="${el.edgeId}"><title>${xmlEscape(el.title)}</title><line x1="${a.x}" y1="${a.y}" x2="${b.x}" y2="${b.y}" stroke="${EDGE_INK6}" stroke-width="1.5" stroke-opacity="${opacity}"${dash}/></g>`;
+}
+function scaleBarLabelSvg(layout) {
+  const bar = layout.scaleBar;
+  if (bar === null) return "";
+  const tick = (x) => `<line x1="${x}" y1="${round8(bar.y - 3)}" x2="${x}" y2="${round8(bar.y + 3)}" stroke="${EDGE_INK6}" stroke-width="1.5" stroke-opacity="0.75"/>`;
+  return tick(bar.x) + tick(round8(bar.x + bar.pxLength)) + `<text x="${round8(bar.x + bar.pxLength / 2)}" y="${round8(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 = round8(x + LEGEND_SWATCH_W / 2);
+  return `<circle cx="${cx}" cy="${y}" r="2.5" fill="${GLYPH_STROKE4}"/><text x="${round8(cx + 5)}" y="${round8(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="${round8(x)}" y1="${y}" x2="${round8(x + LEGEND_SWATCH_W)}" y2="${y}" stroke="${EDGE_INK6}" stroke-width="1.5" stroke-opacity="0.75"/>`;
+}
+function alignedTipSwatch(x, y) {
+  return `<line x1="${round8(x)}" y1="${y}" x2="${round8(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;
+  const showSupport = layout.showSupport;
+  const parts = [];
+  for (const el of layout.elements) parts.push(elementSvg4(el));
+  parts.push(scaleBarLabelSvg(layout));
+  for (const n of layout.nodes) parts.push(nodeSvg3(n, showSupport));
+  let width = layout.width;
+  let height = layout.height;
+  if (opts.legend !== false && layout.nodes.length > 0) {
+    const entries = [];
+    if (showSupport) entries.push({ swatch: supportSwatch, label: labels.support });
+    if (layout.scaleBar !== null) entries.push({ swatch: scaleSwatch, label: labels.scaleBar });
+    if (layout.elements.some((e) => e.kind === "extension")) {
+      entries.push({ swatch: alignedTipSwatch, label: labels.alignedTip });
+    }
+    const block = legendBlock(entries, layout.height);
+    if (block.svg !== "") {
+      parts.push(block.svg);
+      width = Math.max(width, block.width);
+      height = block.height;
+    }
+  }
+  const w = Math.ceil(width);
+  const h = Math.ceil(height);
+  return `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 ${w} ${h}" width="${w}" height="${h}" role="img" aria-label="${xmlEscape(labels.ariaLabel[layout.mode])}">` + parts.join("") + `</svg>`;
+}
+
+// src/phylo/render.ts
+function phyloSvg(input, opts = {}) {
+  const layout = computePhyloLayout(input, {
+    ...opts.mode !== void 0 ? { mode: opts.mode } : {},
+    ...opts.alignTips !== void 0 ? { alignTips: opts.alignTips } : {},
+    ...opts.showSupport !== void 0 ? { showSupport: opts.showSupport } : {},
+    ...opts.scaleBar !== void 0 ? { scaleBar: opts.scaleBar } : {},
+    ...opts.maxLabelChars !== void 0 ? { maxLabelChars: opts.maxLabelChars } : {},
+    ...opts.titleLabels !== void 0 ? { titleLabels: opts.titleLabels } : {}
+  });
+  const svg = phyloLayoutSvg(layout, {
+    ...opts.legend === false ? { legend: false } : {},
+    ...opts.svgLabels !== void 0 ? { labels: opts.svgLabels } : {}
+  });
+  return { svg, layout };
+}
+
 exports.CHAR_W = CHAR_W;
+exports.CODE_FONT = CODE_FONT;
 exports.ECOMAP_LABELS_EN = ECOMAP_LABELS_EN;
 exports.EDGE_FONT = EDGE_FONT;
 exports.EDGE_STROKE = EDGE_STROKE;
+exports.FAULT_TREE_EVENT_KINDS = FAULT_TREE_EVENT_KINDS;
+exports.FAULT_TREE_SVG_LABELS_EN = FAULT_TREE_SVG_LABELS_EN;
+exports.FAULT_TREE_TITLE_LABELS_EN = FAULT_TREE_TITLE_LABELS_EN;
+exports.FISHBONE_LABELS_EN = FISHBONE_LABELS_EN;
 exports.FONT_FAMILY = FONT_FAMILY;
+exports.FT_BUS_ID_BASE = FT_BUS_ID_BASE;
+exports.FT_CONDITION_ID_BASE = FT_CONDITION_ID_BASE;
+exports.FT_DROP_ID_BASE = FT_DROP_ID_BASE;
+exports.FT_LABEL_FONT = FT_LABEL_FONT;
+exports.FT_LABEL_LINE_H = FT_LABEL_LINE_H;
+exports.FT_RISER_ID_BASE = FT_RISER_ID_BASE;
+exports.FT_STEM_ID_BASE = FT_STEM_ID_BASE;
+exports.FaultTreeValidationError = FaultTreeValidationError;
+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.KINSHIP_EN = KINSHIP_EN;
 exports.LABEL_FONT = LABEL_FONT;
+exports.LABEL_GAP = LABEL_GAP;
 exports.LABEL_LINE_H = LABEL_LINE_H;
+exports.LEGEND_FONT = LEGEND_FONT;
+exports.LEGEND_GAP = LEGEND_GAP;
+exports.LEGEND_PAD = LEGEND_PAD;
+exports.LEGEND_ROW_H = LEGEND_ROW_H;
+exports.LEGEND_SWATCH_W = LEGEND_SWATCH_W;
+exports.LIFE_STATUSES = LIFE_STATUSES;
+exports.MAX_CONDITIONS_PER_INDIVIDUAL = MAX_CONDITIONS_PER_INDIVIDUAL;
 exports.NODE_SIZE = NODE_SIZE;
 exports.PARENT_REL_ID_BASE = PARENT_REL_ID_BASE;
+exports.PEDIGREE_SVG_LABELS_EN = PEDIGREE_SVG_LABELS_EN;
+exports.PEDIGREE_TITLE_LABELS_EN = PEDIGREE_TITLE_LABELS_EN;
+exports.PED_ADDRESS_FONT = PED_ADDRESS_FONT;
+exports.PED_CONDITION_FILLS = PED_CONDITION_FILLS;
+exports.PED_DESCENT_ID_BASE = PED_DESCENT_ID_BASE;
+exports.PED_GLYPH = PED_GLYPH;
+exports.PED_LABEL_FONT = PED_LABEL_FONT;
+exports.PED_LABEL_GAP = PED_LABEL_GAP;
+exports.PED_LABEL_LINE_H = PED_LABEL_LINE_H;
+exports.PED_MATING_ID_BASE = PED_MATING_ID_BASE;
+exports.PED_RISER_ID_BASE = PED_RISER_ID_BASE;
+exports.PED_SIBBAR_ID_BASE = PED_SIBBAR_ID_BASE;
+exports.PED_TWINBAR_ID_BASE = PED_TWINBAR_ID_BASE;
+exports.PHYLO_BRANCH_ID_BASE = PHYLO_BRANCH_ID_BASE;
+exports.PHYLO_CLADEBAR_ID_BASE = PHYLO_CLADEBAR_ID_BASE;
+exports.PHYLO_EXTENSION_ID_BASE = PHYLO_EXTENSION_ID_BASE;
+exports.PHYLO_LABEL_FONT = PHYLO_LABEL_FONT;
+exports.PHYLO_LABEL_GAP = PHYLO_LABEL_GAP;
+exports.PHYLO_ROOTSTUB_ID_BASE = PHYLO_ROOTSTUB_ID_BASE;
+exports.PHYLO_ROW_SLOT = PHYLO_ROW_SLOT;
+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.PROMOTED_REL_ID_BASE = PROMOTED_REL_ID_BASE;
+exports.PedigreeValidationError = PedigreeValidationError;
+exports.PhyloValidationError = PhyloValidationError;
 exports.QUALITY_LEXICON_EN = QUALITY_LEXICON_EN;
 exports.UNION_NOTATION = UNION_NOTATION;
 exports.UNION_REL_ID_BASE = UNION_REL_ID_BASE;
 exports.UNION_STATUSES = UNION_STATUSES;
 exports.clampLabel = clampLabel;
 exports.classifyRelationshipType = classifyRelationshipType;
+exports.computeFaultTreeLayout = computeFaultTreeLayout;
 exports.computeGenogramLayout = computeGenogramLayout;
+exports.computePedigreeLayout = computePedigreeLayout;
+exports.computePhyloLayout = computePhyloLayout;
 exports.ecomapSvg = ecomapSvg;
 exports.estimateTextWidth = estimateTextWidth;
+exports.faultTreeIssues = faultTreeIssues;
+exports.faultTreeLayoutSvg = faultTreeLayoutSvg;
+exports.faultTreeSvg = faultTreeSvg;
+exports.fishboneSvg = fishboneSvg;
 exports.genogramLayoutSvg = genogramLayoutSvg;
 exports.genogramSvg = genogramSvg;
 exports.latestUnionPerPair = latestUnionPerPair;
+exports.legendBlock = legendBlock;
+exports.niceScaleStep = niceScaleStep;
 exports.normalizeText = normalizeText;
 exports.pathData = pathData;
+exports.pedigreeIssues = pedigreeIssues;
+exports.pedigreeLayoutSvg = pedigreeLayoutSvg;
+exports.pedigreeSvg = pedigreeSvg;
+exports.phyloIssues = phyloIssues;
+exports.phyloLayoutSvg = phyloLayoutSvg;
+exports.phyloSvg = phyloSvg;
 exports.qualityLineStyle = qualityLineStyle;
 exports.relationshipTypeTokens = relationshipTypeTokens;
+exports.romanNumeral = romanNumeral;
+exports.validateFaultTree = validateFaultTree;
+exports.validatePedigree = validatePedigree;
+exports.validatePhylo = validatePhylo;
 exports.wrapLabel = wrapLabel;
+exports.wrapLabelBalanced = wrapLabelBalanced;
 exports.xmlEscape = xmlEscape;
 //# sourceMappingURL=index.cjs.map
 //# sourceMappingURL=index.cjs.map