compasso 0.1.0

package/dist/genogram/index.cjs

@@ -0,0 +1,1222 @@
+'use strict';
+
+// src/genogram/types.ts
+var UNION_STATUSES = [
+  "married",
+  "cohabiting",
+  "dating",
+  "separated",
+  "divorced",
+  "coparental",
+  "unknown"
+];
+
+// src/genogram/labels.ts
+var GENOGRAM_TITLE_LABELS_EN = {
+  unionStatus: {
+    married: "married",
+    cohabiting: "cohabiting",
+    dating: "dating",
+    separated: "separated",
+    divorced: "divorced",
+    coparental: "co-parents (never a couple)",
+    unknown: "union (type not stated)"
+  },
+  parentage: "parent of"
+};
+var GENOGRAM_SVG_LABELS_EN = {
+  shapes: {
+    square: "Man",
+    circle: "Woman",
+    diamond: "Sex not stated"
+  },
+  deceased: "Deceased",
+  bondStyles: {
+    close: "Close",
+    distant: "Distant",
+    conflict: "Conflictual",
+    cutoff: "Cut off (no contact)"
+  },
+  isolated: "No recorded ancestry",
+  ariaLabel: "Family map (genogram)"
+};
+
+// src/core/xml.ts
+function xmlEscape(text) {
+  return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
+}
+
+// src/core/text.ts
+var CHAR_W = 0.6;
+function estimateTextWidth(text, fontPx) {
+  return text.length * fontPx * CHAR_W;
+}
+function wrapLabel(label, perLine) {
+  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 = "";
+  for (const word of label.split(/\s+/)) {
+    if (line2 === "" && (line1 === "" || (line1 + " " + word).length <= perLine)) {
+      line1 = line1 === "" ? word : `${line1} ${word}`;
+    } else {
+      line2 = line2 === "" ? word : `${line2} ${word}`;
+    }
+  }
+  return line2 === "" ? [cap(line1)] : [cap(line1), cap(line2)];
+}
+var FONT_FAMILY = "Helvetica, Arial, sans-serif";
+
+// src/core/stroke.ts
+var EDGE_STROKE = {
+  plain: { width: 1.5, dash: null, opacity: 0.6 },
+  close: { width: 3, dash: null, opacity: 0.85 },
+  distant: { width: 1.5, dash: [4, 4], opacity: 0.55 },
+  conflict: { width: 2, dash: [2, 2], opacity: 0.75 },
+  cutoff: { width: 1.5, dash: [6, 5], opacity: 0.4 }
+};
+var QUALITY_LEXICON_EN = {
+  buckets: [
+    {
+      style: "close",
+      needles: ["close", "warm", "support", "lov", "affection", "caring", "tight", "harmon", "healthy"]
+    },
+    {
+      style: "distant",
+      needles: ["distant", "detach", "absent", "cold", "drift"]
+    },
+    {
+      style: "conflict",
+      needles: ["conflict", "fight", "tens", "difficult", "hostil", "violen", "abus", "aggress", "complicat", "toxic", "argu"]
+    },
+    {
+      style: "cutoff",
+      needles: ["estrang", "cut off", "cutoff", "no contact", "broken off", "sever"]
+    }
+  ],
+  negations: ["not", "never", "no longer", "hardly"]
+};
+function normalizeText(text) {
+  return text.normalize("NFD").replace(/[̀-ͯ]/g, "").toLowerCase();
+}
+var escapeRegExp = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+function qualityLineStyle(quality, lexicon = QUALITY_LEXICON_EN) {
+  if (quality === null) return "plain";
+  const haystack = normalizeText(quality);
+  if (haystack.trim() === "") return "plain";
+  if (lexicon.negations.length > 0) {
+    const negation = new RegExp(`\\b(${lexicon.negations.map(escapeRegExp).join("|")})\\b`);
+    if (negation.test(haystack)) return "plain";
+  }
+  const matched = [];
+  for (const { style, needles } of lexicon.buckets) {
+    if (needles.some((n) => haystack.includes(n))) matched.push(style);
+  }
+  return matched.length === 1 ? matched[0] : "plain";
+}
+
+// src/genogram/kinship.ts
+var KINSHIP_EN = {
+  derived: /* @__PURE__ */ new Set([
+    "brother",
+    "brothers",
+    "sister",
+    "sisters",
+    "sibling",
+    "siblings",
+    "grandmother",
+    "grandfather",
+    "grandma",
+    "grandpa",
+    "granny",
+    "grandad",
+    "granddad",
+    "grandparent",
+    "grandparents",
+    "grandson",
+    "granddaughter",
+    "grandchild",
+    "grandchildren",
+    "uncle",
+    "uncles",
+    "aunt",
+    "aunts",
+    "auntie",
+    "cousin",
+    "cousins",
+    "nephew",
+    "nephews",
+    "niece",
+    "nieces"
+  ]),
+  parentage: /* @__PURE__ */ new Set([
+    "mother",
+    "mothers",
+    "mom",
+    "mum",
+    "father",
+    "fathers",
+    "dad",
+    "parent",
+    "parents",
+    "son",
+    "sons",
+    "daughter",
+    "daughters"
+  ]),
+  childWords: /* @__PURE__ */ new Set(["son", "sons", "daughter", "daughters"])
+};
+function relationshipTypeTokens(type) {
+  return normalizeText(type).split(/[^a-z0-9]+/).filter((t) => t !== "");
+}
+function classifyRelationshipType(type, kinship = KINSHIP_EN) {
+  const toks = relationshipTypeTokens(type);
+  if (toks.some((t) => kinship.derived.has(t))) return "derived";
+  if (toks.some((t) => kinship.parentage.has(t))) return "parentage";
+  return "bond";
+}
+
+// src/genogram/layout.ts
+var NODE_SIZE = 56;
+var PADDING = 32;
+var COL_PAD = 30;
+var LABEL_GAP_TOP = 8;
+var CORRIDOR_BASE = 24;
+var LANE_H = 8;
+var UNION_STAGGER = 12;
+var STUB_X_OFF = 14;
+var ISOLATED_GUTTER_EXTRA = 2 * COL_PAD;
+var LABEL_FONT = 12;
+var LABEL_LINE_H = 14;
+var EDGE_FONT = 11;
+var UNION_REL_ID_BASE = 1e6;
+var PARENT_REL_ID_BASE = 2e6;
+var PROMOTED_REL_ID_BASE = 3e6;
+function shapeForSex(sex) {
+  if (sex === "male") return "square";
+  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) {
+  return STUB_OFFSETS[Math.min(slot, STUB_OFFSETS.length - 1)];
+}
+function arrivalOffset(slot, total) {
+  if (slot === 0 || total <= 1) return 0;
+  const step = Math.min(12, ARRIVAL_HALF / Math.max(1, Math.ceil((total - 1) / 2)));
+  const sign = slot % 2 === 1 ? -1 : 1;
+  return sign * Math.ceil(slot / 2) * step;
+}
+function allocateLanes(items) {
+  const lanes = [];
+  for (const it of items) {
+    let chosen = -1;
+    for (let l = 0; l < lanes.length; l++) {
+      if (lanes[l].every((o) => it.hi <= o.lo || it.lo >= o.hi)) {
+        chosen = l;
+        break;
+      }
+    }
+    if (chosen === -1) {
+      chosen = lanes.length;
+      lanes.push([]);
+    }
+    lanes[chosen].push({ lo: it.lo, hi: it.hi });
+    it.set(chosen);
+  }
+  return lanes.length;
+}
+function computeGenogramLayout(people, unions, parentLinks, relationships, opts = {}) {
+  const kinship = opts.kinship ?? KINSHIP_EN;
+  const titleLabels = opts.titleLabels ?? GENOGRAM_TITLE_LABELS_EN;
+  if (people.length === 0) {
+    return { width: PADDING * 2, height: PADDING * 2, nodes: [], elements: [], isolatedPersonIds: [] };
+  }
+  const ids = new Set(people.map((p) => p.id));
+  const pairKey = (a, b) => `${Math.min(a, b)}|${Math.max(a, b)}`;
+  const genById = new Map(people.map((p) => [p.id, p.generation]));
+  const validUnions = unions.filter((u) => ids.has(u.personAId) && ids.has(u.personBId) && u.personAId !== u.personBId).sort((a, b) => a.id - b.id);
+  const coupleUnions = validUnions.filter((u) => u.status !== "coparental");
+  const validLinks = parentLinks.filter((l) => ids.has(l.parentId) && ids.has(l.childId) && l.parentId !== l.childId).sort((a, b) => a.id - b.id);
+  const validRels = relationships.filter((r) => ids.has(r.fromPersonId) && ids.has(r.toPersonId) && r.fromPersonId !== r.toPersonId).sort((a, b) => a.id - b.id);
+  const relClass = new Map(
+    validRels.map((r) => [r.id, classifyRelationshipType(r.type, kinship)])
+  );
+  const bondRels = validRels.filter((r) => relClass.get(r.id) === "bond");
+  const parentageRels = validRels.filter((r) => relClass.get(r.id) === "parentage");
+  const realLinks = validLinks.map((l) => ({
+    parentId: l.parentId,
+    childId: l.childId,
+    quality: l.quality,
+    edgeId: PARENT_REL_ID_BASE + l.id
+  }));
+  const declaredPairs = new Set(validLinks.map((l) => pairKey(l.parentId, l.childId)));
+  const promotedByPair = /* @__PURE__ */ new Map();
+  for (const r of parentageRels) {
+    const key = pairKey(r.fromPersonId, r.toPersonId);
+    if (declaredPairs.has(key)) continue;
+    if (promotedByPair.has(key)) continue;
+    const ga = genById.get(r.fromPersonId) ?? null;
+    const gb = genById.get(r.toPersonId) ?? null;
+    let parentId;
+    let childId;
+    if (ga !== null && gb !== null && ga !== gb) {
+      [parentId, childId] = ga < gb ? [r.fromPersonId, r.toPersonId] : [r.toPersonId, r.fromPersonId];
+    } else {
+      const fromIsChild = relationshipTypeTokens(r.type).some((t) => kinship.childWords.has(t));
+      [parentId, childId] = fromIsChild ? [r.toPersonId, r.fromPersonId] : [r.fromPersonId, r.toPersonId];
+    }
+    if (parentId === childId) continue;
+    promotedByPair.set(key, { parentId, childId, quality: r.quality, edgeId: PROMOTED_REL_ID_BASE + r.id });
+  }
+  const allLinks = [...realLinks, ...promotedByPair.values()].sort((a, b) => a.edgeId - b.edgeId);
+  const coupleByPair = /* @__PURE__ */ new Map();
+  for (const u of coupleUnions) coupleByPair.set(pairKey(u.personAId, u.personBId), u);
+  const parentsOf = /* @__PURE__ */ new Map();
+  const linkOf = /* @__PURE__ */ new Map();
+  for (const l of allLinks) {
+    const arr = parentsOf.get(l.childId) ?? [];
+    if (!arr.includes(l.parentId)) arr.push(l.parentId);
+    parentsOf.set(l.childId, arr);
+    linkOf.set(`${l.parentId}>${l.childId}`, l);
+  }
+  const hasTie = /* @__PURE__ */ new Set();
+  for (const u of validUnions) {
+    hasTie.add(u.personAId);
+    hasTie.add(u.personBId);
+  }
+  for (const l of allLinks) {
+    hasTie.add(l.parentId);
+    hasTie.add(l.childId);
+  }
+  for (const r of bondRels) {
+    hasTie.add(r.fromPersonId);
+    hasTie.add(r.toPersonId);
+  }
+  const isIsolated = (id) => !hasTie.has(id);
+  const byGen = /* @__PURE__ */ new Map();
+  for (const p of people) {
+    const bucket = byGen.get(p.generation);
+    if (bucket === void 0) byGen.set(p.generation, [p]);
+    else bucket.push(p);
+  }
+  const genKeys = [...byGen.keys()].sort((a, b) => {
+    if (a === null) return 1;
+    if (b === null) return -1;
+    return a - b;
+  });
+  const rowCount = genKeys.length;
+  const rowOfPerson = /* @__PURE__ */ new Map();
+  genKeys.forEach((g, r) => byGen.get(g).forEach((p) => rowOfPerson.set(p.id, r)));
+  const rowBlocks = genKeys.map((g, r) => {
+    const members = byGen.get(g).map((p) => p.id);
+    const adj = /* @__PURE__ */ new Map();
+    for (const id of members) adj.set(id, []);
+    for (const u of coupleUnions) {
+      if (rowOfPerson.get(u.personAId) === r && rowOfPerson.get(u.personBId) === r) {
+        adj.get(u.personAId).push(u.personBId);
+        adj.get(u.personBId).push(u.personAId);
+      }
+    }
+    for (const id of members) adj.get(id).sort((a, b) => a - b);
+    const seen = /* @__PURE__ */ new Set();
+    const blocks = [];
+    for (const start of [...members].sort((a, b) => a - b)) {
+      if (seen.has(start)) continue;
+      const comp = [];
+      const stack = [start];
+      seen.add(start);
+      while (stack.length > 0) {
+        const n = stack.pop();
+        comp.push(n);
+        for (const m of adj.get(n)) if (!seen.has(m)) {
+          seen.add(m);
+          stack.push(m);
+        }
+      }
+      blocks.push(linearizeBlock(comp, adj));
+    }
+    return blocks;
+  });
+  const flattened = () => {
+    const pos = /* @__PURE__ */ new Map();
+    for (const blocks of rowBlocks) {
+      let c = 0;
+      for (const b of blocks) for (const id of b) pos.set(id, c++);
+    }
+    return pos;
+  };
+  const structuralNeighbors = (id) => {
+    const out = [];
+    for (const u of coupleUnions) {
+      if (u.personAId === id) out.push({ id: u.personBId, w: 1 });
+      else if (u.personBId === id) out.push({ id: u.personAId, w: 1 });
+    }
+    for (const l of allLinks) {
+      if (l.childId === id) out.push({ id: l.parentId, w: 1 });
+      else if (l.parentId === id) out.push({ id: l.childId, w: 1 });
+    }
+    for (const rl of bondRels) {
+      if (rl.fromPersonId === id) out.push({ id: rl.toPersonId, w: 0.5 });
+      else if (rl.toPersonId === id) out.push({ id: rl.fromPersonId, w: 0.5 });
+    }
+    return out.map((o) => o.id);
+  };
+  const neighborWeight = (id, other) => {
+    let w = 0;
+    for (const u of coupleUnions) if (u.personAId === id && u.personBId === other || u.personBId === id && u.personAId === other) w = Math.max(w, 1);
+    for (const l of allLinks) if (l.childId === id && l.parentId === other || l.parentId === id && l.childId === other) w = Math.max(w, 1);
+    for (const rl of bondRels) if (rl.fromPersonId === id && rl.toPersonId === other || rl.toPersonId === id && rl.fromPersonId === other) w = Math.max(w, 0.5);
+    return w;
+  };
+  const sweep = (r, ref) => {
+    const pos = flattened();
+    const blocks = rowBlocks[r];
+    const bcOf = (b) => {
+      let sum = 0;
+      let wsum = 0;
+      for (const id of b) {
+        for (const nb of structuralNeighbors(id)) {
+          if (rowOfPerson.get(nb) !== ref) continue;
+          const w = neighborWeight(id, nb);
+          sum += (pos.get(nb) ?? 0) * w;
+          wsum += w;
+        }
+      }
+      return wsum === 0 ? Number.POSITIVE_INFINITY : sum / wsum;
+    };
+    const keyed = blocks.map((b) => ({ b, bc: bcOf(b), minId: Math.min(...b) }));
+    keyed.sort((x, y) => x.bc !== y.bc ? x.bc - y.bc : x.minId - y.minId);
+    rowBlocks[r] = keyed.map((k) => k.b);
+  };
+  if (rowCount >= 2) {
+    for (let r = 1; r < rowCount; r++) sweep(r, r - 1);
+    for (let r = rowCount - 2; r >= 0; r--) sweep(r, r + 1);
+  }
+  for (let r = 0; r < rowCount; r++) {
+    const blocks = rowBlocks[r];
+    const connected = blocks.filter((b) => !(b.length === 1 && isIsolated(b[0])));
+    const isolated = blocks.filter((b) => b.length === 1 && isIsolated(b[0])).sort((a, b) => a[0] - b[0]);
+    rowBlocks[r] = [...connected, ...isolated];
+  }
+  const colOf = /* @__PURE__ */ new Map();
+  let colCount = 0;
+  for (let r = 0; r < rowCount; r++) {
+    let c = 0;
+    for (const b of rowBlocks[r]) for (const id of b) colOf.set(id, c++);
+    colCount = Math.max(colCount, c);
+  }
+  const colOrThrow = (id) => colOf.get(id);
+  let isolatedTailCol = colCount;
+  {
+    const peopleAtCol = Array.from({ length: colCount }, () => []);
+    for (const p of people) peopleAtCol[colOrThrow(p.id)].push(p.id);
+    for (let c = colCount - 1; c >= 1; c--) {
+      const all = peopleAtCol[c];
+      if (all.length > 0 && all.every((id) => isIsolated(id))) isolatedTailCol = c;
+      else break;
+    }
+  }
+  const measured = /* @__PURE__ */ new Map();
+  for (const p of people) {
+    const lines = wrapNodeLabel(clampLabel2(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 });
+  }
+  const colWidth = Array.from({ length: colCount }, () => NODE_SIZE);
+  for (const p of people) {
+    const c = colOrThrow(p.id);
+    colWidth[c] = Math.max(colWidth[c], measured.get(p.id).contentW);
+  }
+  const rowMaxLines = Array.from({ length: rowCount }, () => 1);
+  for (const p of people) {
+    const r = rowOfPerson.get(p.id);
+    rowMaxLines[r] = Math.max(rowMaxLines[r], measured.get(p.id).lines.length);
+  }
+  const planned = [];
+  const gutterReqs = [];
+  const corridorReqs = [];
+  const stubCount = /* @__PURE__ */ new Map();
+  const arrivalCount = /* @__PURE__ */ new Map();
+  const newStub = (personId, side) => {
+    const key = `${personId}:${side}`;
+    const slot = stubCount.get(key) ?? 0;
+    stubCount.set(key, slot + 1);
+    return { personId, side, slot };
+  };
+  const newArrival = (personId) => {
+    const slot = arrivalCount.get(personId) ?? 0;
+    arrivalCount.set(personId, slot + 1);
+    return { personId, slot };
+  };
+  const departSide = (srcId, dstId) => {
+    const sc = colOrThrow(srcId);
+    const dc = colOrThrow(dstId);
+    if (dc > sc) return 1;
+    if (dc < sc) return -1;
+    return sc < colCount - 1 ? 1 : -1;
+  };
+  const gutterFor = (srcCol, side) => side === 1 ? { gutter: srcCol, gSide: -1 } : { gutter: srcCol - 1, gSide: 1 };
+  const planConnector = (srcId, dstId, arrivalAtCenter) => {
+    const srcRow = rowOfPerson.get(srcId);
+    const dstRow = rowOfPerson.get(dstId);
+    const [upperId, lowerId] = srcRow <= dstRow ? [srcId, dstId] : [dstId, srcId];
+    const upperRow = rowOfPerson.get(upperId);
+    const lowerRow = rowOfPerson.get(lowerId);
+    const side = departSide(upperId, lowerId);
+    const { gutter, gSide } = gutterFor(colOrThrow(upperId), side);
+    const stub = newStub(upperId, side);
+    const corridor = Math.max(0, Math.min(rowCount - 1, lowerRow - 1));
+    const gReq = {
+      gutter,
+      side: gSide,
+      rowLo: Math.min(upperRow, corridor + 0.5),
+      rowHi: Math.max(upperRow, corridor + 0.5),
+      lane: 0
+    };
+    gutterReqs.push(gReq);
+    const arrival = newArrival(lowerId);
+    const arrivalX = () => geo.cx(colOrThrow(lowerId)) + (arrival ? arrivalOffset(arrival.slot, arrivalCount.get(lowerId) ?? 1) : 0);
+    const cReq = {
+      corridor,
+      xRange: () => {
+        const gx = geo.gutterLaneX(gReq);
+        const ax = arrivalX();
+        return [Math.min(gx, ax), Math.max(gx, ax)];
+      },
+      lane: 0
+    };
+    corridorReqs.push(cReq);
+    return () => {
+      const sy = geo.cy(upperRow) + stubOffset(stub.slot);
+      const sEdge = side === 1 ? geo.glyphRight(upperId) : geo.glyphLeft(upperId);
+      const gx = geo.gutterLaneX(gReq);
+      const cyCorr = geo.corridorLaneY(cReq);
+      const ax = arrivalX();
+      const topY = geo.cy(lowerRow) - NODE_SIZE / 2;
+      return [
+        { x: sEdge, y: sy },
+        { x: gx, y: sy },
+        { x: gx, y: cyCorr },
+        { x: ax, y: cyCorr },
+        { x: ax, y: topY }
+      ];
+    };
+  };
+  const planUConnector = (aId, bId) => {
+    const row = rowOfPerson.get(aId);
+    const [leftId, rightId] = colOrThrow(aId) <= colOrThrow(bId) ? [aId, bId] : [bId, aId];
+    const stubL = newStub(leftId, 1);
+    const stubR = newStub(rightId, -1);
+    const gL = gutterFor(colOrThrow(leftId), 1);
+    const gR = gutterFor(colOrThrow(rightId), -1);
+    const gReqL = { gutter: gL.gutter, side: gL.gSide, rowLo: row, rowHi: row + 0.5, lane: 0 };
+    const gReqR = { gutter: gR.gutter, side: gR.gSide, rowLo: row, rowHi: row + 0.5, lane: 0 };
+    gutterReqs.push(gReqL, gReqR);
+    const cReq = {
+      corridor: row,
+      xRange: () => {
+        const xL = geo.gutterLaneX(gReqL);
+        const xR = geo.gutterLaneX(gReqR);
+        return [Math.min(xL, xR), Math.max(xL, xR)];
+      },
+      lane: 0
+    };
+    corridorReqs.push(cReq);
+    return () => {
+      const yL = geo.cy(row) + stubOffset(stubL.slot);
+      const yR = geo.cy(row) + stubOffset(stubR.slot);
+      const xL = geo.gutterLaneX(gReqL);
+      const xR = geo.gutterLaneX(gReqR);
+      const cyCorr = geo.corridorLaneY(cReq);
+      return [
+        { x: geo.glyphRight(leftId), y: yL },
+        { x: xL, y: yL },
+        { x: xL, y: cyCorr },
+        { x: xR, y: cyCorr },
+        { x: xR, y: yR },
+        { x: geo.glyphLeft(rightId), y: yR }
+      ];
+    };
+  };
+  const unionTitle = (u) => u.quality !== null ? `${titleLabels.unionStatus[u.status]} \xB7 ${u.quality}` : titleLabels.unionStatus[u.status];
+  const linkTitle = (l) => l.quality !== null ? `${titleLabels.parentage} \xB7 ${l.quality}` : titleLabels.parentage;
+  const unionIsBar = /* @__PURE__ */ new Map();
+  const barUnions = coupleUnions.filter(
+    (u) => rowOfPerson.get(u.personAId) === rowOfPerson.get(u.personBId) && Math.abs(colOrThrow(u.personAId) - colOrThrow(u.personBId)) === 1
+  );
+  const unionDipLevel = /* @__PURE__ */ new Map();
+  const rowDipLevels = Array.from({ length: rowCount }, () => 0);
+  {
+    const byRow = /* @__PURE__ */ new Map();
+    for (const u of barUnions) {
+      const r = rowOfPerson.get(u.personAId);
+      (byRow.get(r) ?? byRow.set(r, []).get(r)).push(u);
+    }
+    for (const [r, rowUnions] of byRow) {
+      const unionsOfPerson = /* @__PURE__ */ new Map();
+      for (const u of rowUnions) {
+        (unionsOfPerson.get(u.personAId) ?? unionsOfPerson.set(u.personAId, []).get(u.personAId)).push(u);
+        (unionsOfPerson.get(u.personBId) ?? unionsOfPerson.set(u.personBId, []).get(u.personBId)).push(u);
+      }
+      const seen = /* @__PURE__ */ new Set();
+      for (const start of [...rowUnions].sort((a, b) => a.id - b.id)) {
+        if (seen.has(start.id)) continue;
+        const comp = [];
+        const stack = [start];
+        seen.add(start.id);
+        while (stack.length > 0) {
+          const u = stack.pop();
+          comp.push(u);
+          for (const pid of [u.personAId, u.personBId]) {
+            for (const nb of unionsOfPerson.get(pid) ?? []) {
+              if (!seen.has(nb.id)) {
+                seen.add(nb.id);
+                stack.push(nb);
+              }
+            }
+          }
+        }
+        comp.sort((a, b) => a.id - b.id);
+        comp.forEach((u, i) => unionDipLevel.set(u.id, i));
+        rowDipLevels[r] = Math.max(rowDipLevels[r], comp.length - 1);
+      }
+    }
+  }
+  for (const u of coupleUnions) {
+    const aRow = rowOfPerson.get(u.personAId);
+    const bRow = rowOfPerson.get(u.personBId);
+    const adjacent = aRow === bRow && Math.abs(colOrThrow(u.personAId) - colOrThrow(u.personBId)) === 1;
+    unionIsBar.set(u.id, adjacent);
+    const edgeId = UNION_REL_ID_BASE + u.id;
+    if (adjacent) {
+      const [leftId, rightId] = colOrThrow(u.personAId) < colOrThrow(u.personBId) ? [u.personAId, u.personBId] : [u.personBId, u.personAId];
+      const dipLevel = unionDipLevel.get(u.id) ?? 0;
+      planned.push({
+        kind: "union-bar",
+        relIds: [edgeId],
+        edgeId,
+        fromPersonId: u.personAId,
+        toPersonId: u.personBId,
+        titles: [unionTitle(u)],
+        lineStyle: "plain",
+        build: () => {
+          const cy = geo.cy(rowOfPerson.get(leftId));
+          if (dipLevel === 0) {
+            return [
+              { x: geo.glyphRight(leftId), y: cy },
+              { x: geo.glyphLeft(rightId), y: cy }
+            ];
+          }
+          const y = geo.unionDipY(rowOfPerson.get(leftId), dipLevel);
+          const bottom = cy + NODE_SIZE / 2;
+          const lx = geo.cx(colOrThrow(leftId)) + STUB_X_OFF;
+          const rx = geo.cx(colOrThrow(rightId)) - STUB_X_OFF;
+          return [
+            { x: lx, y: bottom },
+            { x: lx, y },
+            { x: rx, y },
+            { x: rx, y: bottom }
+          ];
+        }
+      });
+    } else {
+      const sameRow = aRow === bRow;
+      const build = sameRow ? planUConnector(u.personAId, u.personBId) : (() => {
+        const [up, lo] = aRow < bRow ? [u.personAId, u.personBId] : [u.personBId, u.personAId];
+        return planConnector(up, lo);
+      })();
+      planned.push({
+        kind: "union-elbow",
+        relIds: [edgeId],
+        edgeId,
+        fromPersonId: u.personAId,
+        toPersonId: u.personBId,
+        titles: [unionTitle(u)],
+        lineStyle: "plain",
+        build
+      });
+    }
+  }
+  const coupleChildrenByUnion = /* @__PURE__ */ new Map();
+  const loneLinks = [];
+  for (const childId of [...parentsOf.keys()].sort((a, b) => a - b)) {
+    const parents = [...parentsOf.get(childId)].sort((a, b) => a - b);
+    const couplePairUnions = parents.flatMap((p, i) => parents.slice(i + 1).map((q) => coupleByPair.get(pairKey(p, q)))).filter((u) => u !== void 0 && unionIsBar.get(u.id) === true);
+    if (couplePairUnions.length === 1) {
+      const u = couplePairUnions[0];
+      const arr = coupleChildrenByUnion.get(u.id) ?? [];
+      arr.push(childId);
+      coupleChildrenByUnion.set(u.id, arr);
+      const couplePeople = /* @__PURE__ */ new Set([u.personAId, u.personBId]);
+      for (const p of parents) if (!couplePeople.has(p)) loneLinks.push(linkOf.get(`${p}>${childId}`));
+    } else {
+      for (const p of parents) loneLinks.push(linkOf.get(`${p}>${childId}`));
+    }
+  }
+  for (const u of coupleUnions) {
+    const children = coupleChildrenByUnion.get(u.id);
+    if (children === void 0 || children.length === 0) continue;
+    const leftId = colOrThrow(u.personAId) < colOrThrow(u.personBId) ? u.personAId : u.personBId;
+    const interGutter = colOrThrow(leftId);
+    const parentRow = rowOfPerson.get(u.personAId);
+    const uDipLevel = unionDipLevel.get(u.id) ?? 0;
+    const spineStartY = () => uDipLevel === 0 ? geo.cy(parentRow) : geo.unionDipY(parentRow, uDipLevel);
+    const byChildRow = /* @__PURE__ */ new Map();
+    for (const c of children) {
+      const cr = rowOfPerson.get(c);
+      (byChildRow.get(cr) ?? byChildRow.set(cr, []).get(cr)).push(c);
+    }
+    for (const childRow of [...byChildRow.keys()].sort((a, b) => a - b)) {
+      const groupKids = byChildRow.get(childRow).sort((a, b) => colOrThrow(a) - colOrThrow(b));
+      const corridor = Math.max(0, Math.min(rowCount - 1, childRow - 1));
+      const sibSpan = () => [geo.gutterCenterX(interGutter), ...groupKids.map((c) => geo.cx(colOrThrow(c)))];
+      const sibReq = {
+        corridor,
+        xRange: () => {
+          const xs = sibSpan();
+          return [Math.min(...xs), Math.max(...xs)];
+        },
+        lane: 0
+      };
+      corridorReqs.push(sibReq);
+      const spineReq = {
+        gutter: interGutter,
+        side: 0,
+        rowLo: Math.min(parentRow, corridor + 0.5),
+        // ordered (FIX D-2): never inverted
+        rowHi: Math.max(parentRow, corridor + 0.5),
+        lane: 0
+      };
+      gutterReqs.push(spineReq);
+      const aId = (c) => linkOf.get(`${u.personAId}>${c}`).edgeId;
+      const childDrop = (c, parentId) => {
+        const link = linkOf.get(`${parentId}>${c}`);
+        const edgeId = link.edgeId;
+        const arr = newArrival(c);
+        planned.push({
+          kind: "descent",
+          relIds: [edgeId],
+          edgeId,
+          fromPersonId: null,
+          toPersonId: c,
+          titles: [linkTitle(link)],
+          lineStyle: "plain",
+          build: () => {
+            const y = geo.corridorLaneY(sibReq);
+            const x = geo.cx(colOrThrow(c)) + arrivalOffset(arr.slot, arrivalCount.get(c) ?? 1);
+            return [
+              { x, y },
+              { x, y: geo.cy(rowOfPerson.get(c)) - NODE_SIZE / 2 }
+            ];
+          }
+        });
+      };
+      if (groupKids.length === 1) {
+        const c = groupKids[0];
+        planned.push({
+          kind: "descent",
+          relIds: [aId(c)],
+          edgeId: aId(c),
+          fromPersonId: null,
+          toPersonId: null,
+          titles: [linkTitle(linkOf.get(`${u.personAId}>${c}`))],
+          lineStyle: "plain",
+          build: () => {
+            const sy = geo.corridorLaneY(sibReq);
+            const sx = geo.gutterCenterX(interGutter);
+            const cx = geo.cx(colOrThrow(c));
+            return [
+              { x: sx, y: spineStartY() },
+              { x: sx, y: sy },
+              { x: cx, y: sy }
+            ];
+          }
+        });
+        childDrop(c, u.personBId);
+      } else {
+        const aLinks = groupKids.map((c) => aId(c));
+        const aLinkTitle = (c) => linkTitle(linkOf.get(`${u.personAId}>${c}`));
+        planned.push({
+          kind: "sibling-bar",
+          relIds: [aLinks[0], ...aLinks.slice(2)],
+          edgeId: aLinks[0],
+          fromPersonId: null,
+          toPersonId: null,
+          // Carry the verbatim title of EVERY A-side link this bar represents, so no
+          // declared quality word is dropped from the drawn element (FIX C-2 / SPEC inv #4).
+          titles: [aLinkTitle(groupKids[0]), ...groupKids.slice(2).map(aLinkTitle)],
+          lineStyle: "plain",
+          build: () => {
+            const y = geo.corridorLaneY(sibReq);
+            const xs = sibSpan();
+            return [
+              { x: Math.min(...xs), y },
+              { x: Math.max(...xs), y }
+            ];
+          }
+        });
+        planned.push({
+          kind: "descent",
+          relIds: [aLinks[1]],
+          edgeId: aLinks[1],
+          fromPersonId: null,
+          toPersonId: null,
+          titles: [aLinkTitle(groupKids[1])],
+          // the A-side link this spine carries, verbatim
+          lineStyle: "plain",
+          build: () => {
+            const sy = geo.corridorLaneY(sibReq);
+            const x = geo.gutterCenterX(interGutter);
+            return [
+              { x, y: spineStartY() },
+              { x, y: sy }
+            ];
+          }
+        });
+        for (const c of groupKids) childDrop(c, u.personBId);
+      }
+    }
+  }
+  for (const l of [...loneLinks].sort((a, b) => a.edgeId - b.edgeId)) {
+    const edgeId = l.edgeId;
+    const pRow = rowOfPerson.get(l.parentId);
+    const cRow = rowOfPerson.get(l.childId);
+    const build = pRow === cRow ? planUConnector(l.parentId, l.childId) : planConnector(l.parentId, l.childId);
+    planned.push({
+      kind: "descent",
+      relIds: [edgeId],
+      edgeId,
+      fromPersonId: l.parentId,
+      toPersonId: l.childId,
+      titles: [linkTitle(l)],
+      lineStyle: "plain",
+      dotted: true,
+      build
+    });
+  }
+  const bondGroups = /* @__PURE__ */ new Map();
+  for (const r of bondRels) {
+    const style = qualityLineStyle(r.quality, opts.qualityLexicon);
+    const lo = Math.min(r.fromPersonId, r.toPersonId);
+    const hi = Math.max(r.fromPersonId, r.toPersonId);
+    const key = `${lo}|${hi}|${style}`;
+    const title = r.quality !== null ? `${r.type} \xB7 ${r.quality}` : r.type;
+    const g = bondGroups.get(key);
+    if (g === void 0) {
+      bondGroups.set(key, { relIds: [r.id], titles: [title], style, aId: r.fromPersonId, bId: r.toPersonId });
+    } else {
+      g.relIds.push(r.id);
+      g.titles.push(title);
+    }
+  }
+  const bondList = [...bondGroups.values()].sort((a, b) => Math.max(...a.relIds) - Math.max(...b.relIds));
+  for (const g of bondList) {
+    const aRow = rowOfPerson.get(g.aId);
+    const bRow = rowOfPerson.get(g.bId);
+    const build = aRow === bRow ? planUConnector(g.aId, g.bId) : (() => {
+      const [up, lo] = aRow < bRow ? [g.aId, g.bId] : [g.bId, g.aId];
+      return planConnector(up, lo);
+    })();
+    planned.push({
+      kind: "bond",
+      relIds: g.relIds,
+      edgeId: Math.max(...g.relIds),
+      fromPersonId: g.aId,
+      toPersonId: g.bId,
+      titles: g.titles,
+      lineStyle: g.style,
+      build
+    });
+  }
+  const colCenterX = [];
+  const colLeftX = [];
+  const colRightX = [];
+  const rowCenterY = [];
+  const rowLabelTopY = [];
+  const corridorTopY = [];
+  const dims = { width: 0 };
+  const gutterLaneCount = /* @__PURE__ */ new Map();
+  const corridorLaneCount = Array.from({ length: rowCount }, () => 0);
+  const laneCount = (gutter, side) => gutterLaneCount.get(`${gutter}:${side}`) ?? 0;
+  const geo = {
+    cx: (c) => colCenterX[c],
+    cy: (r) => rowCenterY[r],
+    glyphRight: (id) => colCenterX[colOrThrow(id)] + NODE_SIZE / 2,
+    glyphLeft: (id) => colCenterX[colOrThrow(id)] - NODE_SIZE / 2,
+    gutterCenterX: (g) => {
+      const left = g < 0 ? PADDING : colRightX[g];
+      const right = g >= colCount - 1 ? dims.width - PADDING : colLeftX[g + 1];
+      return (left + right) / 2;
+    },
+    gutterLaneX: (req) => {
+      const left = req.gutter < 0 ? PADDING : colRightX[req.gutter];
+      const right = req.gutter >= colCount - 1 ? dims.width - PADDING : colLeftX[req.gutter + 1];
+      const lCount = laneCount(req.gutter, -1);
+      if (req.side === -1) return left + (req.lane + 1) * LANE_H;
+      if (req.side === 0) return left + (lCount + req.lane + 1) * LANE_H;
+      return right - (req.lane + 1) * LANE_H;
+    },
+    corridorLaneY: (req) => corridorTopY[req.corridor] + CORRIDOR_BASE / 2 + req.lane * LANE_H,
+    /** Y of a dipped serial-union bar (level ≥ 1): below the row's glyph bottom edge. */
+    unionDipY: (r, level) => rowCenterY[r] + NODE_SIZE / 2 + level * UNION_STAGGER
+  };
+  const gutterGroups = /* @__PURE__ */ new Map();
+  for (const req of gutterReqs) {
+    const k = `${req.gutter}:${req.side}`;
+    (gutterGroups.get(k) ?? gutterGroups.set(k, []).get(k)).push(req);
+  }
+  for (const [k, reqs] of gutterGroups) {
+    gutterLaneCount.set(
+      k,
+      allocateLanes(reqs.map((req) => ({ lo: req.rowLo, hi: req.rowHi, set: (lane) => req.lane = lane })))
+    );
+  }
+  const gutterWidth = (g) => {
+    const lanes = laneCount(g, -1) + laneCount(g, 0) + laneCount(g, 1);
+    const extra = g === isolatedTailCol - 1 ? ISOLATED_GUTTER_EXTRA : 0;
+    if (g === -1 || g === colCount - 1) return lanes > 0 ? COL_PAD + lanes * LANE_H + extra : extra;
+    return COL_PAD + lanes * LANE_H + extra;
+  };
+  let cursorX = PADDING + gutterWidth(-1);
+  for (let c = 0; c < colCount; c++) {
+    colLeftX[c] = cursorX;
+    colCenterX[c] = cursorX + colWidth[c] / 2;
+    cursorX += colWidth[c];
+    colRightX[c] = cursorX;
+    cursorX += gutterWidth(c);
+  }
+  dims.width = cursorX + PADDING;
+  const corridorGroups = /* @__PURE__ */ new Map();
+  for (const req of corridorReqs) (corridorGroups.get(req.corridor) ?? corridorGroups.set(req.corridor, []).get(req.corridor)).push(req);
+  for (const [k, reqs] of corridorGroups) {
+    corridorLaneCount[k] = allocateLanes(
+      reqs.map((req) => {
+        const [lo, hi] = req.xRange();
+        return { lo, hi, set: (lane) => req.lane = lane };
+      })
+    );
+  }
+  const corridorHeight = (k) => {
+    const lanes = corridorLaneCount[k] ?? 0;
+    if (lanes > 0) return CORRIDOR_BASE + lanes * LANE_H;
+    return k < rowCount - 1 ? CORRIDOR_BASE : 0;
+  };
+  const rowDipReserve = (r) => rowDipLevels[r] > 0 ? rowDipLevels[r] * UNION_STAGGER + 6 : 0;
+  let cursorY = PADDING;
+  for (let r = 0; r < rowCount; r++) {
+    rowCenterY[r] = cursorY + NODE_SIZE / 2;
+    rowLabelTopY[r] = cursorY + NODE_SIZE + rowDipReserve(r) + LABEL_GAP_TOP;
+    cursorY = rowLabelTopY[r] + rowMaxLines[r] * LABEL_LINE_H;
+    corridorTopY[r] = cursorY;
+    cursorY += corridorHeight(r);
+  }
+  const width = dims.width;
+  const height = cursorY + PADDING;
+  const nodes = [...people].sort((a, b) => a.id - b.id).map((p) => {
+    const m = measured.get(p.id);
+    const r = rowOfPerson.get(p.id);
+    const c = colOrThrow(p.id);
+    return {
+      personId: p.id,
+      label: p.label,
+      shape: shapeForSex(p.sex),
+      deceased: p.deceased,
+      cx: colCenterX[c],
+      cy: rowCenterY[r],
+      size: NODE_SIZE,
+      labelLines: m.lines,
+      labelTop: rowLabelTopY[r]
+    };
+  });
+  const elements = planned.map((pl) => ({
+    kind: pl.kind,
+    relIds: pl.relIds,
+    edgeId: pl.edgeId,
+    fromPersonId: pl.fromPersonId,
+    toPersonId: pl.toPersonId,
+    points: pl.build(),
+    titles: pl.titles,
+    lineStyle: pl.lineStyle,
+    ...pl.unionStyle !== void 0 ? { unionStyle: pl.unionStyle } : {},
+    ...pl.dotted ? { dotted: true } : {}
+  }));
+  const isolatedPersonIds = people.filter((p) => isIsolated(p.id)).map((p) => p.id).sort((a, b) => a - b);
+  return { width, height, nodes, elements, isolatedPersonIds };
+}
+function linearizeBlock(comp, adj) {
+  if (comp.length <= 1) return [...comp];
+  const inComp = new Set(comp);
+  const degree = (id) => adj.get(id).filter((n) => inComp.has(n)).length;
+  const endpoints = comp.filter((id) => degree(id) === 1).sort((a, b) => a - b);
+  const edgeCount = comp.reduce((s, id) => s + degree(id), 0) / 2;
+  const isPath = edgeCount === comp.length - 1 && endpoints.length === 2;
+  const order = [];
+  const seen = /* @__PURE__ */ new Set();
+  if (isPath) {
+    let cur = endpoints[0];
+    while (cur !== void 0) {
+      order.push(cur);
+      seen.add(cur);
+      cur = adj.get(cur).filter((n) => inComp.has(n)).sort((a, b) => a - b).find((n) => !seen.has(n));
+    }
+    return order;
+  }
+  const stack = [Math.min(...comp)];
+  while (stack.length > 0) {
+    const n = stack.pop();
+    if (seen.has(n)) continue;
+    seen.add(n);
+    order.push(n);
+    for (const m of adj.get(n).filter((x) => inComp.has(x)).sort((a, b) => b - a)) {
+      if (!seen.has(m)) stack.push(m);
+    }
+  }
+  return order;
+}
+
+// src/genogram/svg.ts
+var GLYPH_STROKE = "#52525b";
+var NODE_LABEL_FILL = "#3f3f46";
+var EDGE_INK = "#71717a";
+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") {
+    return `<rect x="${cx - half}" y="${cy - half}" width="${half * 2}" height="${half * 2}" rx="4" ${stroke}/>`;
+  }
+  if (shape === "circle") {
+    return `<circle cx="${cx}" cy="${cy}" r="${half}" ${stroke}/>`;
+  }
+  return `<polygon points="${cx},${cy - half} ${cx + half},${cy} ${cx},${cy + half} ${cx - half},${cy}" ${stroke}/>`;
+}
+function pathData(points) {
+  return points.map((p, i) => `${i === 0 ? "M" : "L"} ${p.x} ${p.y}`).join(" ");
+}
+function longestHSegment(points) {
+  let best = [points[0], points[points.length - 1]];
+  let bestLen = -1;
+  for (let i = 0; i + 1 < points.length; i++) {
+    const a = points[i];
+    const b = points[i + 1];
+    if (a.y === b.y) {
+      const len = Math.abs(b.x - a.x);
+      if (len > bestLen) {
+        bestLen = len;
+        best = [a, b];
+      }
+    }
+  }
+  return best;
+}
+function slashMarks(a, b, count, width) {
+  const mx = (a.x + b.x) / 2;
+  const my = (a.y + b.y) / 2;
+  const dx = b.x - a.x;
+  const dy = b.y - a.y;
+  const len = Math.hypot(dx, dy) || 1;
+  const ux = dx / len;
+  const uy = dy / len;
+  const HALF = 7;
+  const STEP = 4;
+  const offsets = count === 1 ? [0] : [-STEP, STEP];
+  return offsets.map((o) => {
+    const px = mx + ux * o;
+    const py = my + uy * o;
+    return `<line x1="${px - HALF}" y1="${py + HALF}" x2="${px + HALF}" y2="${py - HALF}" stroke="${EDGE_INK}" stroke-width="${width}"/>`;
+  }).join("");
+}
+function resolveUnionStyle(el, override) {
+  return override.get(el.edgeId) ?? el.unionStyle ?? {};
+}
+function elementSvg(el, override) {
+  const title = `<title>${xmlEscape(el.titles.join("\n"))}</title>`;
+  const pts = el.points;
+  const drawLine = (dash, width, opacity) => {
+    const dashAttr = dash === null ? "" : ` stroke-dasharray="${dash[0]} ${dash[1]}"`;
+    if (pts.length === 2) {
+      return `<line x1="${pts[0].x}" y1="${pts[0].y}" x2="${pts[1].x}" y2="${pts[1].y}" stroke="${EDGE_INK}" stroke-width="${width}" stroke-opacity="${opacity}"${dashAttr}/>`;
+    }
+    return `<path d="${pathData(pts)}" fill="none" stroke="${EDGE_INK}" stroke-width="${width}" stroke-opacity="${opacity}"${dashAttr}/>`;
+  };
+  if (el.kind === "union-bar" || el.kind === "union-elbow") {
+    const style = resolveUnionStyle(el, override);
+    const body = [drawLine(style.dash ?? null, STRUCT_WIDTH, STRUCT_OPACITY)];
+    const slashes = style.slashes ?? 0;
+    if (slashes === 1 || slashes === 2) {
+      const [a, b] = pts.length === 2 ? [pts[0], pts[1]] : longestHSegment(pts);
+      body.push(slashMarks(a, b, slashes, STRUCT_WIDTH));
+    }
+    return `<g data-edge-id="${el.edgeId}">${title}${body.join("")}</g>`;
+  }
+  if (el.kind === "descent" || el.kind === "sibling-bar") {
+    const dash = el.dotted ? DOTTED_DASH : null;
+    const opacity = el.dotted ? DOTTED_OPACITY : STRUCT_OPACITY;
+    return `<g data-edge-id="${el.edgeId}">${title}${drawLine(dash, STRUCT_WIDTH, opacity)}</g>`;
+  }
+  const ink = EDGE_STROKE[el.lineStyle];
+  return `<g data-edge-id="${el.edgeId}">${title}${drawLine(ink.dash, ink.width, ink.opacity)}</g>`;
+}
+function genogramLayoutSvg(layout, opts = {}) {
+  const override = opts.unionStyleByRelId ?? /* @__PURE__ */ new Map();
+  const labels = opts.labels ?? GENOGRAM_SVG_LABELS_EN;
+  const parts = [];
+  for (const el of layout.elements) parts.push(elementSvg(el, override));
+  for (const node of layout.nodes) {
+    const half = node.size / 2;
+    const pieces = [
+      `<title>${xmlEscape(node.label)}</title>`,
+      glyphSvg(node.shape, node.cx, node.cy, half)
+    ];
+    if (node.deceased) {
+      pieces.push(
+        `<line x1="${node.cx - half}" y1="${node.cy - half}" x2="${node.cx + half}" y2="${node.cy + half}" stroke="${GLYPH_STROKE}" stroke-width="2"/>`
+      );
+    }
+    const tspans = node.labelLines.map(
+      (line, i) => `<tspan x="${node.cx}" y="${node.labelTop + 10 + i * LABEL_LINE_H}">${xmlEscape(line)}</tspan>`
+    ).join("");
+    pieces.push(
+      `<text text-anchor="middle" font-family="${FONT_FAMILY}" font-size="${LABEL_FONT}" fill="${NODE_LABEL_FILL}">${tspans}</text>`
+    );
+    parts.push(`<g data-individual-id="p${node.personId}">${pieces.join("")}</g>`);
+  }
+  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) => glyphSvg(shape, x + LEGEND_SWATCH_W / 2, y, 6),
+        label: labels.shapes[shape]
+      });
+    }
+    if (layout.nodes.some((n) => n.deceased)) {
+      entries.push({
+        swatch: (x, y) => glyphSvg("square", x + LEGEND_SWATCH_W / 2, y, 6) + `<line x1="${x + LEGEND_SWATCH_W / 2 - 6}" y1="${y - 6}" x2="${x + LEGEND_SWATCH_W / 2 + 6}" y2="${y + 6}" stroke="${GLYPH_STROKE}" stroke-width="2"/>`,
+        label: labels.deceased
+      });
+    }
+    const stylesUsed = new Set(layout.elements.filter((e) => e.kind === "bond").map((e) => e.lineStyle));
+    for (const style of ["close", "distant", "conflict", "cutoff"]) {
+      if (!stylesUsed.has(style)) continue;
+      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_W}" y2="${y}" stroke="${EDGE_INK}" stroke-width="${ink.width}" stroke-opacity="${ink.opacity}"${dashAttr}/>`,
+        label: labels.bondStyles[style]
+      });
+    }
+    if (layout.isolatedPersonIds.length > 0) {
+      entries.push({
+        swatch: (x, y) => glyphSvg("square", x + LEGEND_SWATCH_W / 2, y, 6),
+        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;
+    }
+  }
+  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>`;
+}
+
+// src/genogram/render.ts
+var COUPLE_DASH = [6, 4];
+var UNION_NOTATION = {
+  married: {},
+  // solid bar
+  cohabiting: { dash: COUPLE_DASH },
+  dating: { dash: COUPLE_DASH },
+  unknown: { dash: COUPLE_DASH },
+  separated: { slashes: 1 },
+  // solid + one diagonal slash
+  divorced: { slashes: 2 }
+  // solid + two parallel slashes
+};
+function latestUnionPerPair(unions) {
+  const byPair = /* @__PURE__ */ new Map();
+  for (const u of [...unions].sort((a, b) => a.id - b.id)) {
+    const key = `${Math.min(u.personAId, u.personBId)}|${Math.max(u.personAId, u.personBId)}`;
+    byPair.set(key, u);
+  }
+  return [...byPair.values()].sort((a, b) => a.id - b.id);
+}
+function genogramSvg(input, opts = {}) {
+  const ids = new Set(input.people.map((p) => p.id));
+  const dedupedUnions = latestUnionPerPair(input.unions).filter(
+    (u) => ids.has(u.personAId) && ids.has(u.personBId)
+  );
+  const layout = computeGenogramLayout(
+    input.people,
+    dedupedUnions,
+    input.parentLinks,
+    input.relationships,
+    opts
+  );
+  const unionStyleByRelId = /* @__PURE__ */ new Map();
+  for (const u of dedupedUnions) {
+    if (u.status === "coparental") continue;
+    unionStyleByRelId.set(UNION_REL_ID_BASE + u.id, UNION_NOTATION[u.status]);
+  }
+  const svg = genogramLayoutSvg(layout, {
+    unionStyleByRelId,
+    ...opts.legend === false ? { legend: false } : {},
+    ...opts.svgLabels !== void 0 ? { labels: opts.svgLabels } : {}
+  });
+  return { svg, layout };
+}
+
+exports.CHAR_W = CHAR_W;
+exports.EDGE_FONT = EDGE_FONT;
+exports.EDGE_STROKE = EDGE_STROKE;
+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_LINE_H = LABEL_LINE_H;
+exports.NODE_SIZE = NODE_SIZE;
+exports.PARENT_REL_ID_BASE = PARENT_REL_ID_BASE;
+exports.PROMOTED_REL_ID_BASE = PROMOTED_REL_ID_BASE;
+exports.UNION_NOTATION = UNION_NOTATION;
+exports.UNION_REL_ID_BASE = UNION_REL_ID_BASE;
+exports.UNION_STATUSES = UNION_STATUSES;
+exports.classifyRelationshipType = classifyRelationshipType;
+exports.computeGenogramLayout = computeGenogramLayout;
+exports.estimateTextWidth = estimateTextWidth;
+exports.genogramLayoutSvg = genogramLayoutSvg;
+exports.genogramSvg = genogramSvg;
+exports.latestUnionPerPair = latestUnionPerPair;
+exports.qualityLineStyle = qualityLineStyle;
+exports.relationshipTypeTokens = relationshipTypeTokens;
+exports.wrapLabel = wrapLabel;
+exports.xmlEscape = xmlEscape;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map