compasso 0.2.0 → 0.4.0

package/dist/chunk-F47C6ZEB.js

@@ -0,0 +1,1041 @@
+import { clampLabel, romanNumeral, estimateTextWidth, FONT_FAMILY, xmlEscape, legendBlock, wrapLabelBalanced, LEGEND_SWATCH_W } from './chunk-O3BT2O42.js';
+
+// 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 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 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 sortIssues(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 sortIssues(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 PADDING = 32;
+var GUTTER = 36;
+var H_GAP = 28;
+var MATING_RUN = 22;
+var CORRIDOR = 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 round = (n) => Math.round(n * 100) / 100;
+function shapeForSex(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: PADDING * 2,
+      height: PADDING * 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 = PADDING + 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_GAP;
+      } else {
+        const placed = placeLeaf(child, childCursor);
+        childLeft = Math.min(childLeft, placed.cx - placed.spanL);
+        childrenRight = placed.cx + placed.spanR;
+        childCursor = childrenRight + H_GAP;
+      }
+      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_GAP);
+    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_GAP * 2;
+  }
+  for (const m of matings) {
+    if (placedMatings.has(m.id)) continue;
+    const right = packMating(m, cursorX);
+    cursorX = right + H_GAP * 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_GAP;
+  }
+  for (const ind of individuals) {
+    if (placedById.has(ind.id)) continue;
+    placeLeaf(ind, cursorX);
+    cursorX = placedById.get(ind.id).cx + nodeHalfWidth(ind) + H_GAP;
+  }
+  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 = [PADDING];
+  for (let r = 0; r < rowCount - 1; r++) {
+    rowTop.push(rowTop[r] + rowHeight[r] + CORRIDOR);
+  }
+  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: shapeForSex(ind.sex),
+      cx: round(placed.cx),
+      cy: round(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: round(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: round(hubStubX), y: round(glyphBottom) },
+          { x: round(hubStubX), y: round(dipY) },
+          { x: round(spouseStubX), y: round(dipY) },
+          { x: round(spouseStubX), y: round(glyphBottom) }
+        ],
+        consanguineous: m.consanguineous,
+        title
+      });
+      matingMidpoint.set(m.id, { x: round((hubStubX + spouseStubX) / 2), y: round(dipY) });
+    } else if (ay === by) {
+      const y = ay;
+      elements.push({
+        edgeId: PED_MATING_ID_BASE + m.id,
+        kind: "mating",
+        points: [
+          { x: round(lx), y: round(y) },
+          { x: round(rx), y: round(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: round(originX), y: round(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] + CORRIDOR / 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_GAP / 2);
+        const downSideX = downX + (downRight ? 1 : -1) * GLYPH_HALF;
+        elements.push({
+          edgeId: PED_MATING_ID_BASE + m.id,
+          kind: "mating-elbow",
+          points: [
+            { x: round(upX + (downRight ? -GLYPH_HALF : GLYPH_HALF)), y: round(upY) },
+            { x: round(upExitX), y: round(upY) },
+            { x: round(upExitX), y: round(laneY) },
+            { x: round(downFarX), y: round(laneY) },
+            { x: round(downFarX), y: round(downY) },
+            { x: round(downSideX), y: round(downY) }
+          ],
+          consanguineous: m.consanguineous,
+          title
+        });
+        matingMidpoint.set(m.id, { x: round(downFarX), y: round(downY) });
+      } else {
+        const elbowX = (upX + downX) / 2;
+        elements.push({
+          edgeId: PED_MATING_ID_BASE + m.id,
+          kind: "mating-elbow",
+          points: [
+            { x: round(upX + (downX >= upX ? GLYPH_HALF : -GLYPH_HALF)), y: round(upY) },
+            { x: round(elbowX), y: round(upY) },
+            { x: round(elbowX), y: round(downY) },
+            { x: round(downX + (upX >= downX ? GLYPH_HALF : -GLYPH_HALF)), y: round(downY) }
+          ],
+          consanguineous: m.consanguineous,
+          title
+        });
+        matingMidpoint.set(m.id, { x: round(elbowX), y: round(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] - CORRIDOR / 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: round(mid.x), y: round(mid.y) },
+        { x: round(mid.x), y: round(barY) }
+      ] : [
+        { x: round(mid.x), y: round(mid.y) },
+        { x: round(mid.x), y: round(bendY) },
+        { x: round(barCenterX), y: round(bendY) },
+        { x: round(barCenterX), y: round(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: round(barLeft), y: round(barY) },
+          { x: round(barRight), y: round(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: round(cx), y: round(barY) },
+            { x: round(cx), y: round(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: round(junctionX), y: round(junctionY) });
+        }
+        elements.push({
+          edgeId: PED_RISER_ID_BASE + childId,
+          // anchored on the first member for a stable id
+          kind: "riser",
+          points: [
+            { x: round(junctionX), y: round(barY) },
+            { x: round(junctionX), y: round(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: round(Math.min(...memberXs)), y: round(tieY) },
+              { x: round(Math.max(...memberXs)), y: round(tieY) }
+            ],
+            consanguineous: false,
+            title: titleLabels.twins.mz
+          });
+        }
+      }
+      const horizontalThenDown = Math.abs(cx - junctionX) < 0.01 ? [
+        { x: round(cx), y: round(junctionY) },
+        { x: round(cx), y: round(childTop) }
+      ] : [
+        { x: round(junctionX), y: round(junctionY) },
+        { x: round(cx), y: round(junctionY) },
+        { x: round(cx), y: round(childTop) }
+      ];
+      elements.push({
+        edgeId: PED_RISER_ID_BASE + childId,
+        kind: "riser",
+        points: horizontalThenDown,
+        consanguineous: false,
+        title: titleLabels.twins[tg.zygosity]
+      });
+    }
+  }
+  let maxX = PADDING * 2;
+  let maxY = PADDING * 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 + PADDING);
+    const labelBottom = n.labelTop + (n.labelLines.length + 1) * PED_LABEL_LINE_H;
+    maxY = Math.max(maxY, labelBottom + PADDING);
+  }
+  for (const el of elements) {
+    for (const p of el.points) {
+      maxX = Math.max(maxX, p.x + PADDING);
+      maxY = Math.max(maxY, p.y + PADDING);
+    }
+  }
+  const generations = [];
+  for (let row = 0; row < rowCount; row++) {
+    generations.push({ roman: romanNumeral(row + 1), y: round(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_STROKE = "#52525b";
+var LABEL_FILL = "#3f3f46";
+var EDGE_INK = "#71717a";
+var GLYPH_ATTRS = `fill="transparent" stroke="${GLYPH_STROKE}" stroke-width="2"`;
+var CONSANG_GAP = 3;
+var ZYGOSITIES = ["mz", "dz", "unknown"];
+var round2 = (n) => Math.round(n * 100) / 100;
+function glyphOutline(shape, cx, cy, half) {
+  if (shape === "square") {
+    return `<rect x="${round2(cx - half)}" y="${round2(cy - half)}" width="${half * 2}" height="${half * 2}" ${GLYPH_ATTRS}/>`;
+  }
+  if (shape === "circle") {
+    return `<circle cx="${cx}" cy="${cy}" r="${half}" ${GLYPH_ATTRS}/>`;
+  }
+  return `<polygon points="${cx},${round2(cy - half)} ${round2(cx + half)},${cy} ${cx},${round2(cy + half)} ${round2(cx - half)},${cy}" ${GLYPH_ATTRS}/>`;
+}
+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(`${round2(x)},${round2(yt)}`);
+      bottom.push(`${round2(x)},${round2(yb)}`);
+    }
+    const pts = [...top, ...bottom.reverse()].join(" ");
+    const ink = inkByCondition.get(id) ?? GLYPH_STROKE;
+    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_STROKE}" stroke="none"/>`;
+}
+function deceasedSlash(n, half) {
+  if (!n.deceased) return "";
+  const ext = half + 4;
+  return `<line x1="${round2(n.cx - ext)}" y1="${round2(n.cy - ext)}" x2="${round2(n.cx + ext)}" y2="${round2(n.cy + ext)}" stroke="${GLYPH_STROKE}" stroke-width="2"/>`;
+}
+function probandArrow(n, half) {
+  if (n.role === null) return "";
+  const tipX = round2(n.cx - half);
+  const tipY = round2(n.cy + half);
+  const tailX = round2(tipX - 16);
+  const tailY = round2(tipY + 16);
+  const filled = n.role === "proband";
+  const fill = filled ? GLYPH_STROKE : "transparent";
+  const shaft = `<line x1="${tailX}" y1="${tailY}" x2="${tipX}" y2="${tipY}" stroke="${GLYPH_STROKE}" stroke-width="2"/>`;
+  const head = `<polygon points="${tipX},${tipY} ${round2(tipX - 8)},${round2(tipY + 2)} ${round2(tipX - 2)},${round2(tipY + 8)}" fill="${fill}" stroke="${GLYPH_STROKE}" stroke-width="1.5"/>`;
+  return shaft + head;
+}
+function stillbirthMark(n, half) {
+  if (!n.stillbirth) return "";
+  const y = round2(n.cy + half + PED_ADDRESS_FONT);
+  return `<text x="${round2(n.cx - half - 2)}" y="${y}" text-anchor="end" font-family="${FONT_FAMILY}" font-size="${PED_ADDRESS_FONT}" font-weight="bold" fill="${LABEL_FILL}">SB</text>`;
+}
+function nodeSvg(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 = round2(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_FILL}">${xmlEscape(n.addressLabel)}</text>`
+  );
+  if (n.labelLines.length > 0) {
+    const firstBaseline = round2(n.labelTop + PED_LABEL_LINE_H + 10);
+    const tspans = n.labelLines.map((line, i) => `<tspan x="${n.cx}" y="${round2(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_FILL}">${tspans}</text>`
+    );
+  }
+  return `<g data-individual-id="p${n.individualId}">${pieces.join("")}</g>`;
+}
+function pathData(points) {
+  return points.map((p, i) => `${i === 0 ? "M" : "L"} ${p.x} ${p.y}`).join(" ");
+}
+function elementSvg(el) {
+  const pts = el.points;
+  const title = `<title>${xmlEscape(el.title)}</title>`;
+  const stroke = `stroke="${EDGE_INK}" stroke-width="1.5" stroke-opacity="0.75"`;
+  const draw = (offsetY) => {
+    const shifted = pts.map((p) => ({ x: p.x, y: round2(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="${pathData(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="${round2(p.x + 6)}" y="${round2(p.y + 4)}" font-family="${FONT_FAMILY}" font-size="12" font-weight="bold" fill="${LABEL_FILL}">?</text>`
+  ).join("");
+}
+var MINI_ATTRS = `fill="transparent" stroke="${GLYPH_STROKE}" stroke-width="1.5"`;
+function miniShapeSwatch(shape, x, y) {
+  const cx = round2(x + LEGEND_SWATCH_W / 2);
+  if (shape === "square") return `<rect x="${round2(cx - 6)}" y="${round2(y - 6)}" width="12" height="12" ${MINI_ATTRS}/>`;
+  if (shape === "circle") return `<circle cx="${cx}" cy="${y}" r="6" ${MINI_ATTRS}/>`;
+  return `<polygon points="${cx},${round2(y - 7)} ${round2(cx + 7)},${y} ${cx},${round2(y + 7)} ${round2(cx - 7)},${y}" ${MINI_ATTRS}/>`;
+}
+function miniSwatchCircle(filled, ink, x, y) {
+  const cx = round2(x + LEGEND_SWATCH_W / 2);
+  return `<circle cx="${cx}" cy="${y}" r="6" fill="${filled ? ink : "transparent"}" stroke="${GLYPH_STROKE}" stroke-width="1.5"/>`;
+}
+function miniCarrierSwatch(x, y) {
+  const cx = round2(x + LEGEND_SWATCH_W / 2);
+  return `<circle cx="${cx}" cy="${y}" r="6" ${MINI_ATTRS}/><circle cx="${cx}" cy="${y}" r="2" fill="${GLYPH_STROKE}" stroke="none"/>`;
+}
+function miniDeceasedSwatch(x, y) {
+  const cx = round2(x + LEGEND_SWATCH_W / 2);
+  return `<circle cx="${cx}" cy="${y}" r="6" ${MINI_ATTRS}/><line x1="${round2(cx - 7)}" y1="${round2(y - 7)}" x2="${round2(cx + 7)}" y2="${round2(y + 7)}" stroke="${GLYPH_STROKE}" stroke-width="1.5"/>`;
+}
+function miniArrowSwatch(filled, x, y) {
+  const cx = round2(x + LEGEND_SWATCH_W / 2);
+  const tipX = round2(cx - 2);
+  const tipY = round2(y + 2);
+  return `<line x1="${round2(tipX - 8)}" y1="${round2(tipY + 8)}" x2="${tipX}" y2="${tipY}" stroke="${GLYPH_STROKE}" stroke-width="1.5"/><polygon points="${tipX},${tipY} ${round2(tipX - 5)},${round2(tipY + 1)} ${round2(tipX - 1)},${round2(tipY + 5)}" fill="${filled ? GLYPH_STROKE : "transparent"}" stroke="${GLYPH_STROKE}" stroke-width="1"/>`;
+}
+function miniConsanguineousSwatch(x, y) {
+  const x1 = round2(x + 2);
+  const x2 = round2(x + LEGEND_SWATCH_W - 2);
+  return `<line x1="${x1}" y1="${round2(y - 1.5)}" x2="${x2}" y2="${round2(y - 1.5)}" stroke="${EDGE_INK}" stroke-width="1.5"/><line x1="${x1}" y1="${round2(y + 1.5)}" x2="${x2}" y2="${round2(y + 1.5)}" stroke="${EDGE_INK}" stroke-width="1.5"/>`;
+}
+function miniTwinSwatch(zygosity, x, y) {
+  const cx = round2(x + LEGEND_SWATCH_W / 2);
+  const apexY = round2(y - 6);
+  const baseY = round2(y + 6);
+  const left = round2(cx - 6);
+  const right = round2(cx + 6);
+  const stub = `<line x1="${cx}" y1="${apexY}" x2="${cx}" y2="${y}" stroke="${EDGE_INK}" stroke-width="1.5"/><line x1="${left}" y1="${y}" x2="${right}" y2="${y}" stroke="${EDGE_INK}" stroke-width="1.5"/><line x1="${left}" y1="${y}" x2="${left}" y2="${baseY}" stroke="${EDGE_INK}" stroke-width="1.5"/><line x1="${right}" y1="${y}" x2="${right}" y2="${baseY}" stroke="${EDGE_INK}" stroke-width="1.5"/>`;
+  if (zygosity === "mz") {
+    return stub + `<line x1="${left}" y1="${round2(y + 3)}" x2="${right}" y2="${round2(y + 3)}" stroke="${EDGE_INK}" stroke-width="1.5"/>`;
+  }
+  if (zygosity === "unknown") {
+    return stub + `<text x="${round2(cx + 8)}" y="${round2(y + 3)}" font-family="${FONT_FAMILY}" font-size="9" fill="${LABEL_FILL}">?</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(elementSvg(el));
+  parts.push(unknownTwinMarks(layout));
+  for (const n of layout.nodes) parts.push(nodeSvg(n, inkByCondition));
+  for (const g of layout.generations) {
+    parts.push(
+      `<text x="${round2(16)}" y="${round2(g.y + PED_LABEL_FONT * 0.32)}" text-anchor="middle" font-family="${FONT_FAMILY}" font-size="${PED_LABEL_FONT}" font-weight="bold" fill="${LABEL_FILL}">${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_STROKE, 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 };
+}
+
+export { LIFE_STATUSES, MAX_CONDITIONS_PER_INDIVIDUAL, PEDIGREE_SVG_LABELS_EN, PEDIGREE_TITLE_LABELS_EN, PED_ADDRESS_FONT, PED_CONDITION_FILLS, PED_DESCENT_ID_BASE, PED_GLYPH, PED_LABEL_FONT, PED_LABEL_GAP, PED_LABEL_LINE_H, PED_MATING_ID_BASE, PED_RISER_ID_BASE, PED_SIBBAR_ID_BASE, PED_TWINBAR_ID_BASE, PedigreeValidationError, computePedigreeLayout, pedigreeIssues, pedigreeLayoutSvg, pedigreeSvg, validatePedigree };
+//# sourceMappingURL=chunk-F47C6ZEB.js.map
+//# sourceMappingURL=chunk-F47C6ZEB.js.map