schematex 0.3.0 → 0.3.2

package/dist/{chunk-H2OEUBPO.js → chunk-SE23X5OE.js}

@@ -1,6 +1,6 @@
-import { parseLegendDirective, applyLegendOverrides, renderLegend } from './chunk-DNZFOCV7.js';
+import { parseLegendDirective, applyLegendOverrides, renderLegend } from './chunk-ZTSO3S4P.js';
 import { resolveGenogramTheme, STROKE_WIDTH, cssCustomProperties } from './chunk-2VNMKOUO.js';
-import { title, text, group, pattern, path, circle, el, defs, polygon, rect, line, desc, svgRoot } from './chunk-KLJEK547.js';
+import { title, text, group, pattern, path, circle, el, defs, polygon, rect, line, desc, svgRoot } from './chunk-WHJXRLFD.js';
 
 // src/diagrams/genogram/parser.ts
 var ParseError = class extends Error {
@@ -17,6 +17,9 @@ var ParseError = class extends Error {
   source;
 };
 var COUPLE_OPS = [
+  { token: "~/~", type: "cohabiting-ended" },
+  { token: "-//", type: "separated" },
+  // alias for -/-
   { token: "-x-", type: "divorced" },
   { token: "-/-", type: "separated" },
   { token: "-o-", type: "engaged" },
@@ -37,6 +40,7 @@ var SPECIAL_CHILD_PROPS = /* @__PURE__ */ new Set([
   "twin-identical",
   "twin-fraternal"
 ]);
+var SECONDARY_LINK_PROPS = /* @__PURE__ */ new Set(["foster", "adopted", "guardian"]);
 var VALID_FILLS = /* @__PURE__ */ new Set([
   "full",
   "half-left",
@@ -110,6 +114,8 @@ function parseGenogram(text2) {
   const relationships = [];
   const childSpecialProps = /* @__PURE__ */ new Map();
   const legendOverrides = {};
+  const childrenWithPrimary = /* @__PURE__ */ new Set();
+  let unknownSibCounter = 0;
   skipBlankAndComments(state);
   while (state.currentLine < state.lines.length) {
     skipBlankAndComments(state);
@@ -164,8 +170,12 @@ function parseGenogram(text2) {
       }
       const rightKey = rightId.toLowerCase();
       if (rightProps) {
-        const rightIndividual = buildIndividual(rightId, rightProps, lineNum, lineText);
-        individualsMap.set(rightKey, rightIndividual);
+        const incoming = buildIndividual(rightId, rightProps, lineNum, lineText);
+        const existing = individualsMap.get(rightKey);
+        individualsMap.set(
+          rightKey,
+          existing ? mergeIndividual(existing, incoming, lineNum, lineText) : incoming
+        );
       } else if (!individualsMap.has(rightKey)) {
         throw new ParseError(
           `Unknown individual '${rightId}'`,
@@ -189,26 +199,47 @@ function parseGenogram(text2) {
         const childIndent = getIndent(childLine);
         if (childIndent <= coupleIndent) break;
         const childLineNum = state.currentLine + 1;
-        const { id: childId, propsStr } = splitIdAndProps(childTrimmed);
-        const childKey = childId.toLowerCase();
-        const individual = buildIndividual(
-          childId,
-          propsStr,
+        let parsedId;
+        let parsedProps;
+        if (childTrimmed === "?" || childTrimmed.startsWith("? ")) {
+          parsedId = `__unknown_siblings_${++unknownSibCounter}`;
+          parsedProps = "unknown, unknown-siblings";
+        } else {
+          const split = splitIdAndProps(childTrimmed);
+          parsedId = split.id;
+          parsedProps = split.propsStr;
+        }
+        const childKey = parsedId.toLowerCase();
+        const incoming = buildIndividual(
+          parsedId,
+          parsedProps,
           childLineNum,
           childLine
         );
-        if (propsStr) {
-          for (const sp of SPECIAL_CHILD_PROPS) {
-            if (propsTokens(propsStr).includes(sp)) {
-              childSpecialProps.set(childKey, sp);
-            }
-          }
+        const tokens = parsedProps ? propsTokens(parsedProps) : [];
+        for (const sp of SPECIAL_CHILD_PROPS) {
+          if (tokens.includes(sp)) childSpecialProps.set(childKey, sp);
         }
-        individualsMap.set(childKey, individual);
+        const isSecondaryDecl = tokens.some((t) => SECONDARY_LINK_PROPS.has(t));
+        const existing = individualsMap.get(childKey);
+        individualsMap.set(
+          childKey,
+          existing ? mergeIndividual(existing, incoming, childLineNum, childLine) : incoming
+        );
         const coupleKey = `${leftKey}+${rightKey}`;
-        const pcType = childSpecialProps.get(childKey);
-        const relType = pcType && (pcType === "adopted" || pcType === "foster") ? pcType : "parent-child";
-        relationships.push({ type: relType, from: coupleKey, to: childKey });
+        const lineChildType = tokens.find(
+          (t) => SPECIAL_CHILD_PROPS.has(t)
+        );
+        const relType = lineChildType === "adopted" || lineChildType === "foster" ? lineChildType : "parent-child";
+        const isSecondary = isSecondaryDecl && childrenWithPrimary.has(childKey);
+        const rel2 = {
+          type: relType,
+          from: coupleKey,
+          to: childKey
+        };
+        if (isSecondary) rel2.secondary = true;
+        relationships.push(rel2);
+        if (!isSecondary) childrenWithPrimary.add(childKey);
         state.currentLine++;
       }
     } else {
@@ -218,7 +249,10 @@ function parseGenogram(text2) {
       const individual = buildIndividual(id, propsStr, lineNum, lineText);
       const existing = individualsMap.get(key);
       if (existing) {
-        individualsMap.set(key, mergeIndividual(existing, individual));
+        individualsMap.set(
+          key,
+          mergeIndividual(existing, individual, lineNum, lineText)
+        );
       } else {
         individualsMap.set(key, individual);
       }
@@ -249,6 +283,7 @@ function parseGenogram(text2) {
       });
     }
   }
+  normalizePrimaryParentRels(relationships);
   const hasLegendOverrides = Object.keys(legendOverrides).length > 0 && Object.values(legendOverrides).some((v) => v !== void 0);
   return {
     type: "genogram",
@@ -258,6 +293,33 @@ function parseGenogram(text2) {
     legendOverrides: hasLegendOverrides ? legendOverrides : void 0
   };
 }
+function normalizePrimaryParentRels(relationships) {
+  const PARENT_CHILD_TYPES = /* @__PURE__ */ new Set([
+    "parent-child",
+    "adopted",
+    "foster"
+  ]);
+  const byChild = /* @__PURE__ */ new Map();
+  for (let i = 0; i < relationships.length; i++) {
+    const r = relationships[i];
+    if (!PARENT_CHILD_TYPES.has(r.type)) continue;
+    const arr = byChild.get(r.to) ?? [];
+    arr.push(i);
+    byChild.set(r.to, arr);
+  }
+  for (const indices of byChild.values()) {
+    if (indices.length < 2) continue;
+    let primaryIdx = indices.find((i) => relationships[i].type === "parent-child");
+    if (primaryIdx === void 0) primaryIdx = indices[0];
+    for (const i of indices) {
+      if (i === primaryIdx) {
+        delete relationships[i].secondary;
+      } else {
+        relationships[i].secondary = true;
+      }
+    }
+  }
+}
 function currentLineText(state) {
   return state.lines[state.currentLine];
 }
@@ -389,7 +451,11 @@ function buildIndividual(id, propsStr, lineNum, lineText) {
     } else if (tokenLower === "index") {
       if (!individual.markers) individual.markers = [];
       individual.markers.push("index-person");
-    } else if (SPECIAL_CHILD_PROPS.has(tokenLower)) {
+    } else if (tokenLower === "unknown-siblings") {
+      if (!individual.markers) individual.markers = [];
+      individual.markers.push("unknown-siblings");
+      if (!individual.label || individual.label === id) individual.label = "?";
+    } else if (SPECIAL_CHILD_PROPS.has(tokenLower) || tokenLower === "guardian") {
       continue;
     } else if (/^\d{4}$/.test(tokenLower)) {
       if (individual.birthYear !== void 0) {
@@ -415,13 +481,27 @@ function buildIndividual(id, propsStr, lineNum, lineText) {
         if (!isNaN(deathNum)) individual.deathYear = deathNum;
       } else if (key === "label") {
         individual.label = value.replace(/^"|"$/g, "");
+      } else if (key === "sibling-of") {
+        individual.siblingOf = value.toLowerCase();
+      } else if (key === "shape") {
+        const v = value.toLowerCase();
+        if (v === "square" || v === "circle" || v === "diamond" || v === "triangle" || v === "triangle-down") {
+          individual.shape = v;
+        } else {
+          throw new ParseError(
+            `Invalid shape '${value}'. Valid: square, circle, diamond, triangle, triangle-down`,
+            lineNum,
+            1,
+            lineText
+          );
+        }
       } else {
         if (!individual.properties) individual.properties = {};
         individual.properties[key] = value;
       }
     } else {
       throw new ParseError(
-        `Unknown property '${token}'. Valid: male, female, unknown, deceased, stillborn, miscarriage, abortion, adopted, foster, twin-identical, twin-fraternal, index, a 4-digit year, conditions:..., age:N, death:YYYY, or key:value`,
+        `Unknown property '${token}'. Valid: male, female, unknown, deceased, stillborn, miscarriage, abortion, adopted, foster, guardian, twin-identical, twin-fraternal, index, unknown-siblings, a 4-digit year, conditions:..., age:N, death:YYYY, label:"...", sibling-of:ID, or key:value`,
         lineNum,
         1,
         lineText
@@ -461,20 +541,81 @@ function parseConditions(raw, lineNum, lineText) {
   }
   return conditions;
 }
-function mergeIndividual(existing, incoming) {
+function mergeIndividual(existing, incoming, lineNum, lineText) {
+  let mergedSex = existing.sex;
+  if (incoming.sex !== "unknown") {
+    if (existing.sex !== "unknown" && existing.sex !== incoming.sex) {
+      throw new ParseError(
+        `Conflicting sex for '${existing.id}': previously '${existing.sex}', now '${incoming.sex}'`,
+        lineNum,
+        1,
+        lineText
+      );
+    }
+    mergedSex = incoming.sex;
+  }
+  let mergedStatus = existing.status;
+  if (incoming.status !== "alive") {
+    if (existing.status !== "alive" && existing.status !== incoming.status) {
+      throw new ParseError(
+        `Conflicting status for '${existing.id}': previously '${existing.status}', now '${incoming.status}'`,
+        lineNum,
+        1,
+        lineText
+      );
+    }
+    mergedStatus = incoming.status;
+  }
+  if (incoming.birthYear !== void 0 && existing.birthYear !== void 0 && incoming.birthYear !== existing.birthYear) {
+    throw new ParseError(
+      `Conflicting birth year for '${existing.id}': previously ${existing.birthYear}, now ${incoming.birthYear}`,
+      lineNum,
+      1,
+      lineText
+    );
+  }
+  if (incoming.deathYear !== void 0 && existing.deathYear !== void 0 && incoming.deathYear !== existing.deathYear) {
+    throw new ParseError(
+      `Conflicting death year for '${existing.id}': previously ${existing.deathYear}, now ${incoming.deathYear}`,
+      lineNum,
+      1,
+      lineText
+    );
+  }
+  const incomingHasExplicitLabel = incoming.label !== incoming.id && incoming.label !== "";
+  const existingHasExplicitLabel = existing.label !== existing.id && existing.label !== "";
+  const mergedLabel = incomingHasExplicitLabel ? incoming.label : existingHasExplicitLabel ? existing.label : existing.label;
+  const mergedMarkers = mergeArrayUnique(existing.markers, incoming.markers);
   return {
     ...existing,
-    sex: incoming.sex !== "unknown" ? incoming.sex : existing.sex,
-    status: incoming.status !== "alive" ? incoming.status : existing.status,
+    sex: mergedSex,
+    status: mergedStatus,
+    label: mergedLabel,
     birthYear: incoming.birthYear ?? existing.birthYear,
     deathYear: incoming.deathYear ?? existing.deathYear,
+    age: incoming.age ?? existing.age,
     conditions: incoming.conditions ?? existing.conditions,
+    heritage: incoming.heritage ?? existing.heritage,
+    siblingOf: incoming.siblingOf ?? existing.siblingOf,
+    markers: mergedMarkers,
     properties: {
       ...existing.properties,
       ...incoming.properties
     }
   };
 }
+function mergeArrayUnique(a, b) {
+  if (!a && !b) return void 0;
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const v of [...a ?? [], ...b ?? []]) {
+    if (!seen.has(v)) {
+      seen.add(v);
+      out.push(v);
+    }
+  }
+  return out.length ? out : void 0;
+}
 
 // src/diagrams/genogram/layout.ts
 function layoutGenogram(ast, config) {
@@ -483,8 +624,19 @@ function layoutGenogram(ast, config) {
   const ordered = orderNodesInGenerations(graph);
   const positions = assignPositions(ordered, graph, config);
   const edges = computeEdges(graph, positions, config);
+  const secondaryEdges = computeSecondaryParentEdges(
+    ast.relationships,
+    graph,
+    positions,
+    config
+  );
   const emotionalEdges = computeEmotionalEdges(ast.relationships, positions, config);
-  return packageResult(positions, [...edges, ...emotionalEdges], graph, config);
+  return packageResult(
+    positions,
+    [...edges, ...secondaryEdges, ...emotionalEdges],
+    graph,
+    config
+  );
 }
 function buildGraph(ast) {
   const individuals = /* @__PURE__ */ new Map();
@@ -494,7 +646,7 @@ function buildGraph(ast) {
   const familyUnits = [];
   const childOf = /* @__PURE__ */ new Map();
   const coupleRels = ast.relationships.filter(
-    (r) => r.type === "married" || r.type === "divorced" || r.type === "separated" || r.type === "engaged" || r.type === "cohabiting" || r.type === "consanguineous"
+    (r) => r.type === "married" || r.type === "divorced" || r.type === "separated" || r.type === "engaged" || r.type === "cohabiting" || r.type === "cohabiting-ended" || r.type === "consanguineous"
   );
   for (const rel of coupleRels) {
     const fuId = `${rel.from}+${rel.to}`;
@@ -516,7 +668,7 @@ function buildGraph(ast) {
     }
     const children = [];
     for (const r of ast.relationships) {
-      if ((r.type === "parent-child" || r.type === "adopted" || r.type === "foster") && r.from === fuId) {
+      if ((r.type === "parent-child" || r.type === "adopted" || r.type === "foster") && r.from === fuId && !r.secondary) {
         children.push(r.to);
         childOf.set(r.to, fuId);
       }
@@ -539,7 +691,12 @@ function buildGraph(ast) {
 function assignGenerations(graph) {
   const { individuals, familyUnits, childOf, generations } = graph;
   const allIds = Array.from(individuals.keys());
-  const roots = allIds.filter((id) => !childOf.has(id));
+  const roots = allIds.filter((id) => {
+    if (childOf.has(id)) return false;
+    const ind = individuals.get(id);
+    if (ind?.siblingOf) return false;
+    return true;
+  });
   if (roots.length === 0 && allIds.length > 0) {
     for (const id of allIds) generations.set(id, 0);
     return;
@@ -587,6 +744,21 @@ function assignGenerations(graph) {
       }
     }
   }
+  let siblingChanged = true;
+  let safety = 0;
+  while (siblingChanged && safety++ < allIds.length + 1) {
+    siblingChanged = false;
+    for (const id of allIds) {
+      if (generations.has(id)) continue;
+      const ind = individuals.get(id);
+      if (!ind?.siblingOf) continue;
+      const refGen = generations.get(ind.siblingOf);
+      if (refGen !== void 0) {
+        generations.set(id, refGen);
+        siblingChanged = true;
+      }
+    }
+  }
   for (const id of allIds) {
     if (!generations.has(id)) {
       generations.set(id, 0);
@@ -662,15 +834,33 @@ function orderGeneration(nodeIds, _genIdx, graph, familyUnits) {
     }
   }
   const remaining = nodeIds.filter((id) => !placed.has(id));
-  remaining.sort((a, b) => {
+  const siblingOfRemaining = remaining.filter((id) => {
+    const ind = graph.individuals.get(id);
+    return ind?.siblingOf && placed.has(ind.siblingOf);
+  });
+  const otherRemaining = remaining.filter(
+    (id) => !siblingOfRemaining.includes(id)
+  );
+  otherRemaining.sort((a, b) => {
     const indA = graph.individuals.get(a);
     const indB = graph.individuals.get(b);
     return (indA?.birthYear ?? 9999) - (indB?.birthYear ?? 9999);
   });
-  for (const id of remaining) {
+  for (const id of otherRemaining) {
     ordered.push(id);
     placed.add(id);
   }
+  for (const id of siblingOfRemaining) {
+    const ind = graph.individuals.get(id);
+    if (!ind?.siblingOf) continue;
+    const refIdx = ordered.indexOf(ind.siblingOf);
+    if (refIdx === -1) {
+      ordered.push(id);
+    } else {
+      ordered.splice(refIdx + 1, 0, id);
+    }
+    placed.add(id);
+  }
   return ordered;
 }
 var LABEL_HEIGHT = 20;
@@ -698,9 +888,10 @@ function assignPositions(orderedGens, graph, config) {
       }
     }
   }
-  resolveOverlaps(positions, orderedGens, config);
+  resolveOverlaps(positions, orderedGens, config, graph);
   centerChildrenUnderParents(positions, graph, config);
-  resolveOverlaps(positions, orderedGens, config);
+  unscrambleSibships(positions, graph, config);
+  resolveOverlaps(positions, orderedGens, config, graph);
   return positions;
 }
 function buildSegments(nodeIds, _genIdx, graph) {
@@ -848,15 +1039,81 @@ function centerChildrenUnderParents(positions, graph, config) {
     }
   }
 }
-function resolveOverlaps(positions, orderedGens, config) {
+function unscrambleSibships(positions, graph, config) {
+  const familyGap = config.nodeWidth + config.nodeSpacingX * 1.5;
+  const childSpacing = config.nodeWidth + config.nodeSpacingX;
+  const byGen = /* @__PURE__ */ new Map();
+  for (const [id, pos] of positions) {
+    const arr = byGen.get(pos.generation) ?? [];
+    arr.push(id);
+    byGen.set(pos.generation, arr);
+  }
+  for (const [, ids] of byGen) {
+    const sibshipMap = /* @__PURE__ */ new Map();
+    for (const id of ids) {
+      const fu = graph.childOf.get(id);
+      if (!fu) continue;
+      const arr = sibshipMap.get(fu) ?? [];
+      arr.push(id);
+      sibshipMap.set(fu, arr);
+    }
+    if (sibshipMap.size <= 1) continue;
+    const sibships = [...sibshipMap.entries()].map(([fuId, children]) => {
+      const fu = graph.familyUnits.find((f) => f.id === fuId);
+      if (!fu) return null;
+      const pa = positions.get(fu.partners[0]);
+      const pb = positions.get(fu.partners[1]);
+      if (!pa || !pb) return null;
+      return { fuId, children, midX: (pa.x + pb.x) / 2 };
+    }).filter((x) => x !== null).sort((a, b) => a.midX - b.midX);
+    let cursor = null;
+    for (const ss of sibships) {
+      const sortedKids = [...ss.children].sort((a, b) => {
+        const ya = graph.individuals.get(a)?.birthYear ?? 9999;
+        const yb = graph.individuals.get(b)?.birthYear ?? 9999;
+        return ya - yb;
+      });
+      const totalWidth = Math.max(0, (sortedKids.length - 1) * childSpacing);
+      let startX = ss.midX - totalWidth / 2;
+      if (cursor !== null && startX < cursor) startX = cursor;
+      for (let i = 0; i < sortedKids.length; i++) {
+        const pos = positions.get(sortedKids[i]);
+        if (pos) pos.x = startX + i * childSpacing;
+      }
+      cursor = startX + totalWidth + familyGap;
+    }
+  }
+}
+function resolveOverlaps(positions, orderedGens, config, graph) {
   const minGap = config.nodeWidth + config.nodeSpacingX;
+  const familyGap = config.nodeWidth + config.nodeSpacingX * 1.5;
+  const cluster = /* @__PURE__ */ new Map();
+  if (graph) {
+    for (const [id] of positions) {
+      const fu = graph.childOf.get(id);
+      if (fu) cluster.set(id, fu);
+    }
+    for (const fu of graph.familyUnits) {
+      for (const p of fu.partners) {
+        if (cluster.has(p)) continue;
+        const other = fu.partners[0] === p ? fu.partners[1] : fu.partners[0];
+        const otherCluster = cluster.get(other);
+        if (otherCluster) cluster.set(p, otherCluster);
+      }
+    }
+  }
   for (const gen of orderedGens) {
     const genNodes = gen.nodeIds.map((id) => positions.get(id)).filter((p) => p !== void 0);
     genNodes.sort((a, b) => a.x - b.x);
     for (let i = 1; i < genNodes.length; i++) {
-      const gap = genNodes[i].x - genNodes[i - 1].x;
-      if (gap < minGap) {
-        const shift = minGap - gap;
+      const prev = genNodes[i - 1];
+      const cur = genNodes[i];
+      const cPrev = cluster.get(prev.id);
+      const cCur = cluster.get(cur.id);
+      const required = cPrev && cCur && cPrev !== cCur ? familyGap : minGap;
+      const gap = cur.x - prev.x;
+      if (gap < required) {
+        const shift = required - gap;
         for (let j = i; j < genNodes.length; j++) {
           genNodes[j].x += shift;
         }
@@ -1089,6 +1346,34 @@ function computeEmotionalEdges(relationships, positions, config) {
   }
   return edges;
 }
+function computeSecondaryParentEdges(relationships, graph, positions, config) {
+  const edges = [];
+  const half = config.nodeHeight / 2;
+  for (const rel of relationships) {
+    if (!rel.secondary) continue;
+    if (rel.type !== "parent-child" && rel.type !== "foster" && rel.type !== "adopted")
+      continue;
+    const fu = graph.familyUnits.find((f) => f.id === rel.from);
+    if (!fu) continue;
+    const posA = positions.get(fu.partners[0]);
+    const posB = positions.get(fu.partners[1]);
+    const childPos = positions.get(rel.to);
+    if (!posA || !posB || !childPos) continue;
+    const coupleMidX = (posA.x + posB.x) / 2;
+    const coupleY = posA.y;
+    const startX = coupleMidX;
+    const startY = coupleY + half + 4;
+    const childTopY = childPos.y - half - 4;
+    const path2 = childPos.y === coupleY ? `M ${startX} ${startY} L ${startX} ${startY + 16} L ${childPos.x} ${startY + 16} L ${childPos.x} ${childPos.y - half - 4}` : `M ${startX} ${startY} L ${startX} ${(startY + childTopY) / 2} L ${childPos.x} ${(startY + childTopY) / 2} L ${childPos.x} ${childTopY}`;
+    edges.push({
+      from: rel.from,
+      to: rel.to,
+      relationship: rel,
+      path: path2
+    });
+  }
+  return edges;
+}
 function shiftPath(pathData, dx, dy) {
   return pathData.replace(
     /([\d.-]+)\s+([\d.-]+)/g,
@@ -1115,7 +1400,7 @@ function renderIndividualSymbol(individual, x, y, size) {
     children.push(indexBorder(individual.sex, half));
     classes.push("schematex-genogram-index-person");
   }
-  children.push(baseShape(individual.sex, half));
+  children.push(baseShape(individual.sex, half, individual.shape));
   if (individual.conditions?.length) {
     for (const cond of individual.conditions) {
       children.push(conditionFillElement(individual.sex, half, cond));
@@ -1139,6 +1424,23 @@ function renderIndividualSymbol(individual, x, y, size) {
       )
     );
   }
+  const isUnknownSiblings = individual.markers?.includes("unknown-siblings");
+  if (isUnknownSiblings) {
+    classes.push("schematex-genogram-unknown-siblings");
+    children.push(
+      text(
+        {
+          x: 0,
+          y: 5,
+          class: "schematex-genogram-unknown-siblings-mark",
+          "text-anchor": "middle",
+          "font-size": "16",
+          "font-weight": "bold"
+        },
+        "?"
+      )
+    );
+  }
   return group(
     {
       class: classes.join(" "),
@@ -1280,31 +1582,30 @@ function indexBorder(sex, half) {
       });
   }
 }
-function baseShape(sex, half) {
+function baseShape(sex, half, shape) {
+  const cls = "schematex-genogram-shape";
+  switch (shape) {
+    case "square":
+      return rect({ x: -half, y: -half, width: half * 2, height: half * 2, class: cls });
+    case "circle":
+      return circle({ cx: 0, cy: 0, r: half, class: cls });
+    case "diamond":
+      return polygon({ points: `0,${-half} ${half},0 0,${half} ${-half},0`, class: cls });
+    case "triangle":
+      return polygon({ points: `0,${-half} ${half},${half} ${-half},${half}`, class: cls });
+    case "triangle-down":
+      return polygon({ points: `${-half},${-half} ${half},${-half} 0,${half}`, class: cls });
+  }
   switch (sex) {
     case "male":
-      return rect({
-        x: -half,
-        y: -half,
-        width: half * 2,
-        height: half * 2,
-        class: "schematex-genogram-shape"
-      });
+      return rect({ x: -half, y: -half, width: half * 2, height: half * 2, class: cls });
     case "female":
-      return circle({
-        cx: 0,
-        cy: 0,
-        r: half,
-        class: "schematex-genogram-shape"
-      });
+      return circle({ cx: 0, cy: 0, r: half, class: cls });
     case "unknown":
     case "other":
     case "nonbinary":
     case "intersex":
-      return polygon({
-        points: `0,${-half} ${half},0 0,${half} ${-half},0`,
-        class: "schematex-genogram-shape"
-      });
+      return polygon({ points: `0,${-half} ${half},0 0,${half} ${-half},0`, class: cls });
   }
 }
 function deceasedOverlay(sex, half) {
@@ -1401,6 +1702,7 @@ var STRUCTURAL_TYPES = /* @__PURE__ */ new Set([
   "separated",
   "engaged",
   "cohabiting",
+  "cohabiting-ended",
   "domestic-partnership",
   "consanguineous",
   "parent-child",
@@ -1593,6 +1895,7 @@ function buildStructuralItems(rels, theme) {
     "separated",
     "engaged",
     "cohabiting",
+    "cohabiting-ended",
     "domestic-partnership",
     "consanguineous",
     "adopted",
@@ -1622,6 +1925,14 @@ function structuralItem(t, theme) {
       return { ...base, kind: "edge", marker: "X", pattern: "solid" };
     case "separated":
       return { ...base, kind: "edge", marker: "slash", pattern: "solid" };
+    case "cohabiting-ended":
+      return {
+        ...base,
+        label: "Cohabiting (ended)",
+        kind: "edge",
+        marker: "slash",
+        pattern: "dashed"
+      };
     case "engaged":
     case "cohabiting":
     case "adopted":
@@ -1784,7 +2095,8 @@ function buildMarkerItems(individuals, theme) {
     "index-person",
     "transgender",
     "no-children",
-    "infertile"
+    "infertile",
+    "unknown-siblings"
   ];
   const items = [];
   for (const m of order) {
@@ -1817,6 +2129,16 @@ function markerItem(m, theme) {
       return { key: `marker.${m}`, label: "No children (by choice)", kind: "marker", marker: "slash", section: "markers" };
     case "infertile":
       return { key: `marker.${m}`, label: "Infertile", kind: "marker", marker: "X", section: "markers" };
+    case "unknown-siblings":
+      return {
+        key: `marker.${m}`,
+        label: "Sibling(s) \u2014 unknown count",
+        kind: "shape",
+        shape: "diamond",
+        fill: "#ffffff",
+        color: theme?.stroke,
+        section: "markers"
+      };
     default:
       return { key: `marker.${m}`, label: humanize(m), kind: "marker", marker: "dot", section: "markers" };
   }
@@ -1837,7 +2159,11 @@ function renderGenogram(layout, config, ast) {
   const emotionalLayer = renderEmotionalEdges(emotionalEdges);
   const nodeLayers = renderNodes(genGroups);
   const labelLayer = renderLabels(layout.nodes, config);
-  const edgeLabelLayer = renderEdgeLabels(structuralEdges, config);
+  const labelEdges = structuralEdges.filter(
+    (e) => !e.relationship.secondary
+  );
+  const edgeLabelLayer = renderEdgeLabels(labelEdges, config);
+  const siblingOfLayer = renderSiblingOfBrackets(layout, ast);
   const nodeCount = layout.nodes.length;
   const genCount = genGroups.size;
   const chartTitle = ast?.metadata?.title;
@@ -1871,7 +2197,7 @@ function renderGenogram(layout, config, ast) {
   chartContent.push(
     group(
       { transform: titleHeight > 0 ? `translate(0, ${titleHeight})` : void 0 },
-      [edgeLayers, emotionalLayer, ...nodeLayers, labelLayer, edgeLabelLayer]
+      [edgeLayers, siblingOfLayer, emotionalLayer, ...nodeLayers, labelLayer, edgeLabelLayer]
     )
   );
   let finalWidth = layout.width;
@@ -1933,8 +2259,15 @@ function buildStyles(config) {
 .schematex-genogram-label { font-family: ${config.fontFamily}; font-size: ${config.fontSize}px; text-anchor: middle; fill: ${t.text}; }
 .schematex-genogram-edge { stroke: ${t.neutral}; stroke-width: ${STROKE_WIDTH.normal}; fill: none; stroke-linecap: round; stroke-linejoin: round; }
 .schematex-genogram-edge-cohabiting path { stroke-dasharray: 6,4; }
+.schematex-genogram-edge-cohabiting-ended path { stroke-dasharray: 6,4; }
 .schematex-genogram-edge-divorced .schematex-genogram-divorce-mark { stroke: ${t.neutral}; stroke-width: ${STROKE_WIDTH.normal}; }
 .schematex-genogram-edge-separated .schematex-genogram-separation-mark { stroke: ${t.neutral}; stroke-width: ${STROKE_WIDTH.normal}; }
+.schematex-genogram-edge-cohabiting-ended .schematex-genogram-separation-mark { stroke: ${t.neutral}; stroke-width: ${STROKE_WIDTH.normal}; }
+/* Secondary parent-child link (foster/adopted "current caregiver") \u2014 dotted, muted */
+.schematex-genogram-edge-secondary path { stroke: ${t.neutral}; stroke-width: ${STROKE_WIDTH.normal}; stroke-dasharray: 2,4; fill: none; opacity: 0.85; }
+/* Sibling-of bracket (known relative, unknown ancestry) \u2014 dashed */
+.schematex-genogram-sibling-of path { stroke: ${t.neutral}; stroke-width: ${STROKE_WIDTH.normal}; stroke-dasharray: 4,3; fill: none; opacity: 0.7; }
+.schematex-genogram-unknown-siblings-mark { fill: ${t.text}; pointer-events: none; }
 .schematex-genogram-deceased-mark { stroke: ${t.deceasedMark}; stroke-width: ${STROKE_WIDTH.normal}; stroke-linecap: round; }
 /* Inline fill on each .schematex-genogram-condition-fill element comes from cond.color. The CSS only sets a default for elements that did not receive an inline fill attribute. */
 .schematex-genogram-condition-fill:not([fill]) { fill: ${t.conditionFill}; }
@@ -2080,10 +2413,27 @@ function renderEdges(edges) {
   const children = [];
   for (const edge of edges) {
     const relType = edge.relationship.type;
-    const cssClass = `schematex-genogram-edge schematex-genogram-edge-${relType}`;
+    const isSecondary = edge.relationship.secondary === true;
+    const cssClass = isSecondary ? `schematex-genogram-edge schematex-genogram-edge-secondary schematex-genogram-edge-secondary-${relType}` : `schematex-genogram-edge schematex-genogram-edge-${relType}`;
     const elements = [
       el("path", { d: edge.path, class: "schematex-genogram-edge-path" })
     ];
+    if (relType === "cohabiting-ended" && !isSecondary) {
+      const mid = pathMidpoint(edge.path);
+      if (mid) {
+        elements.push(
+          el("line", {
+            x1: mid.x - 4,
+            y1: mid.y - 6,
+            x2: mid.x + 4,
+            y2: mid.y + 6,
+            class: "schematex-genogram-separation-mark",
+            stroke: "#333",
+            "stroke-width": "2"
+          })
+        );
+      }
+    }
     if (relType === "divorced") {
       const mid = pathMidpoint(edge.path);
       if (mid) {
@@ -2182,6 +2532,35 @@ function renderNodes(genGroups) {
   }
   return layers;
 }
+function renderSiblingOfBrackets(layout, ast) {
+  if (!ast) return group({ class: "schematex-genogram-sibling-of-edges" }, []);
+  const elements = [];
+  const nodeById = new Map(layout.nodes.map((n) => [n.id, n]));
+  for (const ind of ast.individuals) {
+    if (!ind.siblingOf) continue;
+    const fromNode = nodeById.get(ind.id);
+    const toNode = nodeById.get(ind.siblingOf);
+    if (!fromNode || !toNode) continue;
+    if (fromNode.generation !== toNode.generation) continue;
+    const fromCx = fromNode.x + fromNode.width / 2;
+    const fromTopY = fromNode.y;
+    const toCx = toNode.x + toNode.width / 2;
+    const toTopY = toNode.y;
+    const bracketY = Math.min(fromTopY, toTopY) - 12;
+    const path2 = `M ${fromCx} ${fromTopY} L ${fromCx} ${bracketY} L ${toCx} ${bracketY} L ${toCx} ${toTopY}`;
+    elements.push(
+      group(
+        {
+          class: "schematex-genogram-sibling-of",
+          "data-from": ind.id,
+          "data-to": ind.siblingOf
+        },
+        [el("path", { d: path2 })]
+      )
+    );
+  }
+  return group({ class: "schematex-genogram-sibling-of-edges" }, elements);
+}
 function renderLabels(nodes, config) {
   const labels = [];
   for (const node of nodes) {
@@ -2238,5 +2617,5 @@ var genogram = {
 };
 
 export { ParseError, genogram, getRequiredDefs, layoutGenogram, parseGenogram, renderGenogram, renderIndividualSymbol };
-//# sourceMappingURL=chunk-H2OEUBPO.js.map
-//# sourceMappingURL=chunk-H2OEUBPO.js.map
+//# sourceMappingURL=chunk-SE23X5OE.js.map
+//# sourceMappingURL=chunk-SE23X5OE.js.map