compasso 0.1.0 → 0.3.0

package/dist/chunk-LRHHUJFZ.js

@@ -0,0 +1,703 @@
+import { legendBlock, xmlEscape, FONT_FAMILY, LEGEND_SWATCH_W, wrapLabelBalanced, clampLabel, estimateTextWidth, wrapLabel, CHAR_W } from './chunk-O3BT2O42.js';
+
+// src/fault-tree/types.ts
+var FAULT_TREE_EVENT_KINDS = [
+  "intermediate",
+  "basic",
+  "undeveloped",
+  "house",
+  "conditioning",
+  "transfer"
+];
+var GATE_TYPES = ["and", "or", "xor", "inhibit", "vote"];
+
+// src/fault-tree/labels.ts
+var FAULT_TREE_TITLE_LABELS_EN = {
+  gates: {
+    and: "AND gate",
+    or: "OR gate",
+    xor: "Exclusive-OR gate",
+    inhibit: "Inhibit gate",
+    vote: "Voting gate"
+  },
+  condition: "condition"
+};
+var FAULT_TREE_SVG_LABELS_EN = {
+  events: {
+    intermediate: "Intermediate event",
+    basic: "Basic event",
+    undeveloped: "Undeveloped event",
+    house: "External event (normally occurs)",
+    conditioning: "Conditioning event",
+    transfer: "Transfer (developed elsewhere)"
+  },
+  gates: {
+    and: "AND gate (all inputs)",
+    or: "OR gate (any input)",
+    xor: "Exclusive-OR gate (exactly one input)",
+    inhibit: "INHIBIT gate (input under condition)",
+    vote: "Voting gate (k of n)"
+  },
+  ariaLabel: "Fault tree"
+};
+
+// src/fault-tree/validate.ts
+var FaultTreeValidationError = class extends Error {
+  issues;
+  constructor(issues) {
+    super(`invalid fault tree: ${issues.map((i) => i.message).join("; ")}`);
+    this.name = "FaultTreeValidationError";
+    this.issues = issues;
+  }
+};
+function listIds(ids) {
+  if (ids.length === 1) return String(ids[0]);
+  return `${ids.slice(0, -1).join(", ")} and ${ids[ids.length - 1]}`;
+}
+function sortIssues(issues) {
+  const unique = /* @__PURE__ */ new Map();
+  for (const issue of issues) unique.set(`${issue.code} ${issue.message}`, issue);
+  return [...unique.values()].sort(
+    (a, b) => a.code !== b.code ? a.code < b.code ? -1 : 1 : a.message < b.message ? -1 : a.message > b.message ? 1 : 0
+  );
+}
+function faultTreeIssues(input) {
+  if (input.events.length === 0 && input.gates.length === 0) return [];
+  const issues = [];
+  const push = (code, message) => {
+    issues.push({ code, message });
+  };
+  const eventById = /* @__PURE__ */ new Map();
+  const dupEventIds = /* @__PURE__ */ new Set();
+  for (const e of input.events) {
+    if (eventById.has(e.id)) dupEventIds.add(e.id);
+    else eventById.set(e.id, e);
+  }
+  for (const id of [...dupEventIds].sort((a, b) => a - b)) {
+    push("duplicate-id", `duplicate event id ${id}`);
+  }
+  const gateById = /* @__PURE__ */ new Map();
+  const dupGateIds = /* @__PURE__ */ new Set();
+  for (const g of input.gates) {
+    if (gateById.has(g.id)) dupGateIds.add(g.id);
+    else gateById.set(g.id, g);
+  }
+  for (const id of [...dupGateIds].sort((a, b) => a - b)) {
+    push("duplicate-id", `duplicate gate id ${id}`);
+  }
+  if (issues.length > 0) {
+    return sortIssues(issues);
+  }
+  const gates = [...gateById.values()].sort((a, b) => a.id - b.id);
+  const top = eventById.get(input.topId);
+  if (top === void 0 || top.kind !== "intermediate") {
+    push("top-not-intermediate", `topId ${input.topId} is not an intermediate event`);
+  }
+  const conditioningAsInput = /* @__PURE__ */ new Set();
+  for (const g of gates) {
+    const out = eventById.get(g.eventId);
+    if (out !== void 0 && out.kind === "transfer") {
+      push("transfer-with-gate", `transfer event ${g.eventId} cannot have a gate`);
+    } else if (out === void 0 || out.kind !== "intermediate") {
+      push("gate-on-non-intermediate", `gate ${g.id} resolves non-intermediate event ${g.eventId}`);
+    }
+    if (g.type === "inhibit") {
+      if (g.inputIds.length !== 1) push("gate-arity", `inhibit gate ${g.id} needs exactly 1 input`);
+    } else if (g.inputIds.length < 2) {
+      push("gate-arity", `${g.type} gate ${g.id} needs \u22652 inputs`);
+    }
+    if (g.type === "vote" && (!Number.isInteger(g.k) || g.k < 1 || g.k > g.inputIds.length)) {
+      push("vote-threshold", `vote gate ${g.id}: k=${g.k} of ${g.inputIds.length}`);
+    }
+    if (g.type === "inhibit") {
+      const cond = eventById.get(g.conditionId);
+      if (cond === void 0 || cond.kind !== "conditioning") {
+        push("inhibit-condition", `inhibit gate ${g.id} conditionId ${g.conditionId} is not a conditioning event`);
+      }
+    }
+    for (const inputId of g.inputIds) {
+      const child = eventById.get(inputId);
+      if (child === void 0) {
+        push("unknown-input", `gate ${g.id} input ${inputId} is not a declared event`);
+        continue;
+      }
+      if (inputId === input.topId) push("top-as-input", `top event ${input.topId} is used as a gate input`);
+      if (child.kind === "conditioning") conditioningAsInput.add(inputId);
+    }
+  }
+  for (const id of [...conditioningAsInput].sort((a, b) => a - b)) {
+    push("conditioning-as-input", `conditioning event ${id} used as a gate input`);
+  }
+  const gatesByEvent = /* @__PURE__ */ new Map();
+  for (const g of gates) {
+    const arr = gatesByEvent.get(g.eventId) ?? [];
+    arr.push(g.id);
+    gatesByEvent.set(g.eventId, arr);
+  }
+  for (const [eventId, gateIds] of [...gatesByEvent.entries()].sort((a, b) => a[0] - b[0])) {
+    if (gateIds.length > 1) {
+      push("event-with-two-gates", `event ${eventId} is resolved by gates ${listIds(gateIds.sort((a, b) => a - b))}`);
+    }
+  }
+  for (const e of [...eventById.values()].sort((a, b) => a.id - b.id)) {
+    if (e.kind === "intermediate" && !gatesByEvent.has(e.id)) {
+      push("event-without-gate", `intermediate event ${e.id} has no gate \u2014 declare it kind "undeveloped" instead`);
+    }
+  }
+  const intermediateRefs = /* @__PURE__ */ new Map();
+  for (const g of gates) {
+    for (const inputId of g.inputIds) {
+      if (eventById.get(inputId)?.kind !== "intermediate") continue;
+      const arr = intermediateRefs.get(inputId) ?? [];
+      arr.push(g.id);
+      intermediateRefs.set(inputId, arr);
+    }
+  }
+  for (const [eventId, gateIds] of [...intermediateRefs.entries()].sort((a, b) => a[0] - b[0])) {
+    if (gateIds.length > 1) {
+      push(
+        "intermediate-reused",
+        `intermediate event ${eventId} feeds gates ${listIds(gateIds.sort((a, b) => a - b))} \u2014 repeat it via a "transfer" event`
+      );
+    }
+  }
+  const GRAPH_BLOCKING = /* @__PURE__ */ new Set([
+    "duplicate-id",
+    "unknown-input",
+    "gate-on-non-intermediate",
+    "transfer-with-gate",
+    "event-with-two-gates",
+    "inhibit-condition",
+    "top-not-intermediate"
+  ]);
+  if (!issues.some((i) => GRAPH_BLOCKING.has(i.code))) {
+    const gateOf = (eventId) => gates.find((g) => g.eventId === eventId);
+    const reachable = /* @__PURE__ */ new Set();
+    const queue = [input.topId];
+    while (queue.length > 0) {
+      const id = queue.shift();
+      if (reachable.has(id)) continue;
+      reachable.add(id);
+      const g = gateOf(id);
+      if (g === void 0) continue;
+      queue.push(...g.inputIds);
+      if (g.type === "inhibit") queue.push(g.conditionId);
+    }
+    for (const e of [...eventById.values()].sort((a, b) => a.id - b.id)) {
+      if (!reachable.has(e.id)) push("unreachable-event", `event ${e.id} is declared but unreachable from the top`);
+    }
+    const color = /* @__PURE__ */ new Map();
+    const seenCycles = /* @__PURE__ */ new Set();
+    const dfs = (start) => {
+      const stack = [{ id: start, nextChild: 0 }];
+      color.set(start, 1);
+      while (stack.length > 0) {
+        const frame = stack[stack.length - 1];
+        const children = gateOf(frame.id)?.inputIds ?? [];
+        if (frame.nextChild >= children.length) {
+          color.set(frame.id, 2);
+          stack.pop();
+          continue;
+        }
+        const child = children[frame.nextChild];
+        frame.nextChild += 1;
+        const c = color.get(child) ?? 0;
+        if (c === 1) {
+          const from = stack.findIndex((f) => f.id === child);
+          const cycle = stack.slice(from).map((f) => f.id);
+          const minIdx = cycle.indexOf(Math.min(...cycle));
+          const rotated = [...cycle.slice(minIdx), ...cycle.slice(0, minIdx)];
+          const key = rotated.join(">");
+          if (!seenCycles.has(key)) {
+            seenCycles.add(key);
+            push("cycle", `cycle: ${[...rotated, rotated[0]].join(" \u2192 ")}`);
+          }
+        } else if (c === 0) {
+          color.set(child, 1);
+          stack.push({ id: child, nextChild: 0 });
+        }
+      }
+    };
+    for (const e of [...eventById.values()].sort((a, b) => a.id - b.id)) {
+      if ((color.get(e.id) ?? 0) === 0) dfs(e.id);
+    }
+  }
+  return sortIssues(issues);
+}
+function validateFaultTree(input) {
+  const issues = faultTreeIssues(input);
+  if (issues.length > 0) throw new FaultTreeValidationError(issues);
+}
+
+// src/fault-tree/layout.ts
+var FT_LABEL_FONT = 12;
+var FT_LABEL_LINE_H = 14;
+var CODE_FONT = 10;
+var LABEL_GAP = 6;
+var PADDING = 32;
+var H_GAP = 28;
+var CORRIDOR = 30;
+var STEM = 10;
+var COND_GAP = 14;
+var GATE_W = 44;
+var GATE_H = 36;
+var XOR_H = GATE_H + 5;
+var INHIBIT_W = 36;
+var INHIBIT_H = 46;
+var INHIBIT_CY = 23;
+var FT_STEM_ID_BASE = 1e6;
+var FT_DROP_ID_BASE = 2e6;
+var FT_BUS_ID_BASE = 3e6;
+var FT_RISER_ID_BASE = 4e6;
+var FT_CONDITION_ID_BASE = 5e6;
+var round = (n) => Math.round(n * 100) / 100;
+function wrapLeafLabel(displayLabel) {
+  const perLine = Math.min(20, Math.max(12, Math.ceil(displayLabel.length / 2) + 2));
+  return wrapLabel(displayLabel, perLine);
+}
+var CODE_REAL_HEADROOM = 1.15;
+var CODE_MARGIN = 2;
+function codeGlyphHalfAt(kind, y) {
+  if (kind === "basic") {
+    const dy = y - 22;
+    return Math.sqrt(Math.max(0, 22 * 22 - dy * dy));
+  }
+  if (kind === "undeveloped") {
+    return 24 * Math.max(0, 1 - Math.abs(y - 24) / 24);
+  }
+  if (kind === "house") {
+    return y >= 16 ? 22 : 22 * y / 16;
+  }
+  return 22 * Math.max(0, Math.min(35, y)) / 35;
+}
+function codeBaselineHalfWidth(kind, glyphH) {
+  return codeGlyphHalfAt(kind, glyphH / 2 + CODE_FONT * 0.32);
+}
+function maxCodeChars(kind, glyphH) {
+  const half = codeBaselineHalfWidth(kind, glyphH);
+  const perChar = CODE_FONT * CHAR_W * CODE_REAL_HEADROOM / 2;
+  return Math.max(1, Math.floor((half - CODE_MARGIN) / perChar));
+}
+function measureEvent(event, maxLabelChars) {
+  if (event.kind === "intermediate") {
+    const lines2 = event.label === "" ? [] : wrapLabelBalanced(clampLabel(event.label, maxLabelChars), 3);
+    const maxLineW = lines2.reduce((m, l) => Math.max(m, estimateTextWidth(l, FT_LABEL_FONT)), 0);
+    const w = Math.max(96, maxLineW + 24);
+    const h = lines2.length * FT_LABEL_LINE_H + 18;
+    return { nodeW: w, nodeH: h, glyphW: w, glyphH: h, labelLines: lines2, code: null };
+  }
+  const rawCode = event.code === null || event.code === "" ? null : event.code;
+  const lines = event.label === "" ? [] : wrapLeafLabel(clampLabel(event.label, maxLabelChars));
+  const labelW = lines.reduce((m, l) => Math.max(m, estimateTextWidth(l, FT_LABEL_FONT)), 0);
+  let glyphW;
+  let glyphH;
+  let code = rawCode;
+  if (event.kind === "basic") {
+    glyphW = 44;
+    glyphH = 44;
+    code = rawCode === null ? null : clampLabel(rawCode, maxCodeChars("basic", glyphH));
+  } else if (event.kind === "undeveloped") {
+    glyphW = 48;
+    glyphH = 48;
+    code = rawCode === null ? null : clampLabel(rawCode, maxCodeChars("undeveloped", glyphH));
+  } else if (event.kind === "house") {
+    glyphW = 44;
+    glyphH = 40;
+    code = rawCode === null ? null : clampLabel(rawCode, maxCodeChars("house", glyphH));
+  } else if (event.kind === "conditioning") {
+    code = rawCode === null ? null : clampLabel(rawCode, 6);
+    const rx = Math.max(30, estimateTextWidth(code ?? "", CODE_FONT) / 2 + 8);
+    glyphW = rx * 2;
+    glyphH = 32;
+  } else {
+    glyphW = 44;
+    glyphH = 35;
+    code = rawCode === null ? null : clampLabel(rawCode, maxCodeChars("transfer", glyphH));
+  }
+  const nodeW = Math.max(glyphW, labelW);
+  const nodeH = glyphH + (lines.length > 0 ? LABEL_GAP + lines.length * FT_LABEL_LINE_H : 0);
+  return { nodeW, nodeH, glyphW, glyphH, labelLines: lines, code };
+}
+function eventTitle(event) {
+  if (event.title !== void 0) return event.title;
+  return event.code !== null && event.code !== "" ? `${event.code} \xB7 ${event.label}` : event.label;
+}
+function computeFaultTreeLayout(input, opts = {}) {
+  if (input.events.length === 0 && input.gates.length === 0) {
+    return { width: PADDING * 2, height: PADDING * 2, nodes: [], gates: [], elements: [] };
+  }
+  validateFaultTree(input);
+  const titleLabels = opts.titleLabels ?? FAULT_TREE_TITLE_LABELS_EN;
+  const eventById = new Map(input.events.map((e) => [e.id, e]));
+  const gateByEvent = new Map(input.gates.map((g) => [g.eventId, g]));
+  const seqByEvent = /* @__PURE__ */ new Map();
+  const newInst = (event, gate, depth) => {
+    const seq = seqByEvent.get(event.id) ?? 0;
+    seqByEvent.set(event.id, seq + 1);
+    const inst = {
+      event,
+      gate,
+      children: [],
+      cond: null,
+      depth,
+      m: measureEvent(event, opts.maxLabelChars),
+      title: eventTitle(event),
+      seq,
+      spanL: 0,
+      spanR: 0,
+      offset: 0,
+      cx: 0
+    };
+    return inst;
+  };
+  const build = (eventId, depth) => {
+    const event = eventById.get(eventId);
+    const gate = gateByEvent.get(eventId) ?? null;
+    const inst = newInst(event, gate, depth);
+    if (gate !== null) {
+      if (gate.type === "inhibit") {
+        inst.cond = newInst(eventById.get(gate.conditionId), null, depth);
+      }
+      for (const childId of gate.inputIds) inst.children.push(build(childId, depth + 1));
+    }
+    return inst;
+  };
+  const root = build(input.topId, 0);
+  const pack = (inst) => {
+    for (const c of inst.children) pack(c);
+    const condW = inst.cond !== null ? COND_GAP + inst.cond.m.nodeW : 0;
+    const selfL = inst.m.nodeW / 2;
+    const selfR = inst.m.nodeW / 2 + condW;
+    if (inst.children.length === 0) {
+      inst.spanL = selfL;
+      inst.spanR = selfR;
+      return;
+    }
+    const xs = [0];
+    for (let i = 1; i < inst.children.length; i++) {
+      xs.push(xs[i - 1] + inst.children[i - 1].spanR + H_GAP + inst.children[i].spanL);
+    }
+    const first = inst.children[0];
+    const last2 = inst.children[inst.children.length - 1];
+    const px = (xs[0] + xs[xs.length - 1]) / 2;
+    inst.children.forEach((c, i) => c.offset = xs[i] - px);
+    inst.spanL = Math.max(selfL, px - (xs[0] - first.spanL));
+    inst.spanR = Math.max(selfR, xs[xs.length - 1] + last2.spanR - px);
+  };
+  pack(root);
+  root.cx = PADDING + root.spanL;
+  const placeX = (inst) => {
+    for (const c of inst.children) {
+      c.cx = inst.cx + c.offset;
+      placeX(c);
+    }
+  };
+  placeX(root);
+  const rowInsts = [];
+  const visitRows = (inst) => {
+    (rowInsts[inst.depth] ??= []).push(inst);
+    for (const c of inst.children) visitRows(c);
+  };
+  visitRows(root);
+  const depthCount = rowInsts.length;
+  const gateExtent = (inst) => {
+    const g = inst.gate;
+    if (g.type === "xor") return XOR_H;
+    if (g.type === "inhibit") {
+      const condBottom = INHIBIT_CY - 16 + inst.cond.m.nodeH;
+      return Math.max(INHIBIT_H, condBottom);
+    }
+    return GATE_H;
+  };
+  const rowH = [];
+  const gateZone = [];
+  for (let d = 0; d < depthCount; d++) {
+    const insts = rowInsts[d];
+    rowH.push(insts.reduce((m, i) => Math.max(m, i.m.nodeH), 0));
+    const gated = insts.filter((i) => i.gate !== null);
+    gateZone.push(gated.length === 0 ? 0 : STEM + gated.reduce((m, i) => Math.max(m, gateExtent(i)), 0));
+  }
+  const rowTop = [PADDING];
+  for (let d = 0; d < depthCount - 1; d++) {
+    rowTop.push(rowTop[d] + rowH[d] + gateZone[d] + CORRIDOR);
+  }
+  const busY = (d) => rowTop[d + 1] - CORRIDOR / 2;
+  const width = Math.ceil(PADDING * 2 + root.spanL + root.spanR);
+  const last = depthCount - 1;
+  const height = Math.ceil(rowTop[last] + rowH[last] + gateZone[last] + PADDING);
+  const instanceOf = (inst) => (seqByEvent.get(inst.event.id) ?? 0) > 1 ? inst.seq : null;
+  const nodes = [];
+  const gates = [];
+  const elements = [];
+  const gateTitle = (g) => g.type === "vote" ? `${titleLabels.gates.vote} ${g.k}/${g.inputIds.length}` : titleLabels.gates[g.type];
+  const pushNode = (inst, top) => {
+    const isRect = inst.event.kind === "intermediate";
+    const labelTop = !isRect && inst.m.labelLines.length > 0 ? top + inst.m.glyphH + LABEL_GAP : null;
+    nodes.push({
+      eventId: inst.event.id,
+      kind: inst.event.kind,
+      instance: instanceOf(inst),
+      cx: round(inst.cx),
+      top: round(top),
+      nodeW: round(inst.m.nodeW),
+      nodeH: round(inst.m.nodeH),
+      glyphW: round(inst.m.glyphW),
+      glyphH: round(inst.m.glyphH),
+      labelLines: inst.m.labelLines,
+      labelTop: labelTop === null ? null : round(labelTop),
+      code: inst.m.code,
+      depth: inst.depth,
+      title: inst.title
+    });
+  };
+  const emit = (inst) => {
+    const d = inst.depth;
+    pushNode(inst, rowTop[d]);
+    const g = inst.gate;
+    if (g === null) return;
+    const gateTop = rowTop[d] + rowH[d] + STEM;
+    const glyphW = g.type === "inhibit" ? INHIBIT_W : GATE_W;
+    const glyphH = g.type === "xor" ? XOR_H : g.type === "inhibit" ? INHIBIT_H : GATE_H;
+    const title = gateTitle(g);
+    gates.push({
+      gateId: g.id,
+      type: g.type,
+      cx: round(inst.cx),
+      top: round(gateTop),
+      glyphW,
+      glyphH,
+      title,
+      voteText: g.type === "vote" ? `${g.k}/${g.inputIds.length}` : null
+    });
+    if (inst.cond !== null) {
+      const cond = inst.cond;
+      const nodeLeft = inst.cx + INHIBIT_W / 2 + COND_GAP;
+      cond.cx = nodeLeft + cond.m.nodeW / 2;
+      const condTop = gateTop + INHIBIT_CY - 16;
+      pushNode(cond, condTop);
+      const ovalLeft = cond.cx - cond.m.glyphW / 2;
+      elements.push({
+        edgeId: FT_CONDITION_ID_BASE + g.id,
+        kind: "condition",
+        points: [
+          { x: round(inst.cx + INHIBIT_W / 2), y: round(gateTop + INHIBIT_CY) },
+          { x: round(ovalLeft), y: round(gateTop + INHIBIT_CY) }
+        ],
+        instance: null,
+        title: titleLabels.condition
+      });
+    }
+    elements.push({
+      edgeId: FT_STEM_ID_BASE + g.id,
+      kind: "stem",
+      points: [
+        { x: round(inst.cx), y: round(rowTop[d] + inst.m.nodeH) },
+        { x: round(inst.cx), y: round(gateTop) }
+      ],
+      instance: null,
+      title
+    });
+    const by = busY(d);
+    elements.push({
+      edgeId: FT_DROP_ID_BASE + g.id,
+      kind: "drop",
+      points: [
+        { x: round(inst.cx), y: round(gateTop + glyphH) },
+        { x: round(inst.cx), y: round(by) }
+      ],
+      instance: null,
+      title
+    });
+    if (inst.children.length > 1) {
+      const xs = inst.children.map((c) => c.cx);
+      elements.push({
+        edgeId: FT_BUS_ID_BASE + g.id,
+        kind: "bus",
+        points: [
+          { x: round(Math.min(...xs)), y: round(by) },
+          { x: round(Math.max(...xs)), y: round(by) }
+        ],
+        instance: null,
+        title
+      });
+    }
+    for (const c of inst.children) {
+      elements.push({
+        edgeId: FT_RISER_ID_BASE + c.event.id,
+        kind: "riser",
+        points: [
+          { x: round(c.cx), y: round(by) },
+          { x: round(c.cx), y: round(rowTop[d + 1]) }
+        ],
+        instance: instanceOf(c),
+        title
+      });
+    }
+    for (const c of inst.children) emit(c);
+  };
+  emit(root);
+  return { width, height, nodes, gates, elements };
+}
+
+// src/fault-tree/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 round2 = (n) => Math.round(n * 100) / 100;
+function eventGlyph(n) {
+  const cx = n.cx;
+  const top = n.top;
+  if (n.kind === "intermediate") {
+    return `<rect x="${round2(cx - n.nodeW / 2)}" y="${top}" width="${n.nodeW}" height="${n.nodeH}" rx="2" ${GLYPH_ATTRS}/>`;
+  }
+  if (n.kind === "basic") {
+    return `<circle cx="${cx}" cy="${round2(top + 22)}" r="22" ${GLYPH_ATTRS}/>`;
+  }
+  if (n.kind === "undeveloped") {
+    const pts2 = `${cx},${top} ${round2(cx + 24)},${round2(top + 24)} ${cx},${round2(top + 48)} ${round2(cx - 24)},${round2(top + 24)}`;
+    return `<polygon points="${pts2}" ${GLYPH_ATTRS}/>`;
+  }
+  if (n.kind === "house") {
+    const yB = round2(top + 40);
+    const eave = round2(top + 16);
+    const pts2 = `${round2(cx - 22)},${yB} ${round2(cx - 22)},${eave} ${cx},${top} ${round2(cx + 22)},${eave} ${round2(cx + 22)},${yB}`;
+    return `<polygon points="${pts2}" ${GLYPH_ATTRS}/>`;
+  }
+  if (n.kind === "conditioning") {
+    return `<ellipse cx="${cx}" cy="${round2(top + 16)}" rx="${round2(n.glyphW / 2)}" ry="16" ${GLYPH_ATTRS}/>`;
+  }
+  const pts = `${cx},${top} ${round2(cx + 22)},${round2(top + 35)} ${round2(cx - 22)},${round2(top + 35)}`;
+  return `<polygon points="${pts}" ${GLYPH_ATTRS}/>`;
+}
+function nodeSvg(n) {
+  const pieces = [`<title>${xmlEscape(n.title)}</title>`, eventGlyph(n)];
+  if (n.code !== null && n.kind !== "intermediate") {
+    pieces.push(
+      `<text x="${n.cx}" y="${round2(n.top + n.glyphH / 2 + CODE_FONT * 0.32)}" text-anchor="middle" font-family="${FONT_FAMILY}" font-size="${CODE_FONT}" fill="${LABEL_FILL}">${xmlEscape(n.code)}</text>`
+    );
+  }
+  if (n.labelLines.length > 0) {
+    const firstBaseline = n.labelTop === null ? round2(n.top + 19) : round2(n.labelTop + 10);
+    const tspans = n.labelLines.map((line, i) => `<tspan x="${n.cx}" y="${round2(firstBaseline + i * FT_LABEL_LINE_H)}">${xmlEscape(line)}</tspan>`).join("");
+    pieces.push(
+      `<text text-anchor="middle" font-family="${FONT_FAMILY}" font-size="${FT_LABEL_FONT}" fill="${LABEL_FILL}">${tspans}</text>`
+    );
+  }
+  const instance = n.instance === null ? "" : ` data-instance="${n.instance}"`;
+  return `<g data-node-id="e${n.eventId}"${instance}>${pieces.join("")}</g>`;
+}
+function orBodyPath(cx, top, yB) {
+  return `M ${round2(cx - 22)} ${yB} Q ${cx} ${round2(yB - 14)} ${round2(cx + 22)} ${yB} Q ${round2(cx + 22)} ${round2(top + 14)} ${cx} ${top} Q ${round2(cx - 22)} ${round2(top + 14)} ${round2(cx - 22)} ${yB} Z`;
+}
+function gateGlyph(g) {
+  const cx = g.cx;
+  const top = g.top;
+  const yB = round2(top + 36);
+  if (g.type === "and") {
+    const d = `M ${round2(cx - 22)} ${yB} L ${round2(cx - 22)} ${round2(yB - 14)} A 22 22 0 0 1 ${round2(cx + 22)} ${round2(yB - 14)} L ${round2(cx + 22)} ${yB} Z`;
+    return `<path d="${d}" ${GLYPH_ATTRS}/>`;
+  }
+  if (g.type === "or") {
+    return `<path d="${orBodyPath(cx, top, yB)}" ${GLYPH_ATTRS}/>`;
+  }
+  if (g.type === "xor") {
+    const arc = `M ${round2(cx - 22)} ${round2(yB + 5)} Q ${cx} ${round2(yB - 9)} ${round2(cx + 22)} ${round2(yB + 5)}`;
+    return `<path d="${orBodyPath(cx, top, yB)}" ${GLYPH_ATTRS}/><path d="${arc}" ${GLYPH_ATTRS}/>`;
+  }
+  if (g.type === "inhibit") {
+    const pts = `${cx},${top} ${round2(cx + 18)},${round2(top + 12)} ${round2(cx + 18)},${round2(top + 34)} ${cx},${round2(top + 46)} ${round2(cx - 18)},${round2(top + 34)} ${round2(cx - 18)},${round2(top + 12)}`;
+    return `<polygon points="${pts}" ${GLYPH_ATTRS}/>`;
+  }
+  return `<path d="${orBodyPath(cx, top, yB)}" ${GLYPH_ATTRS}/><text x="${cx}" y="${round2(yB - 10)}" text-anchor="middle" font-family="${FONT_FAMILY}" font-size="9" fill="${LABEL_FILL}">${xmlEscape(g.voteText ?? "")}</text>`;
+}
+function gateSvg(g) {
+  return `<g data-node-id="g${g.gateId}"><title>${xmlEscape(g.title)}</title>${gateGlyph(g)}</g>`;
+}
+function elementSvg(el) {
+  const a = el.points[0];
+  const b = el.points[1];
+  const instance = el.instance === null ? "" : ` data-instance="${el.instance}"`;
+  return `<g data-edge-id="${el.edgeId}"${instance}><title>${xmlEscape(el.title)}</title><line x1="${a.x}" y1="${a.y}" x2="${b.x}" y2="${b.y}" stroke="${EDGE_INK}" stroke-width="1.5" stroke-opacity="0.75"/></g>`;
+}
+var MINI_ATTRS = `fill="transparent" stroke="${GLYPH_STROKE}" stroke-width="1.5"`;
+function miniEventSwatch(kind, x, y) {
+  const cx = round2(x + LEGEND_SWATCH_W / 2);
+  if (kind === "intermediate") {
+    return `<rect x="${round2(cx - 7)}" y="${round2(y - 4.5)}" width="14" height="9" rx="1" ${MINI_ATTRS}/>`;
+  }
+  if (kind === "basic") return `<circle cx="${cx}" cy="${y}" r="6" ${MINI_ATTRS}/>`;
+  if (kind === "undeveloped") {
+    return `<polygon points="${cx},${round2(y - 7)} ${round2(cx + 7)},${y} ${cx},${round2(y + 7)} ${round2(cx - 7)},${y}" ${MINI_ATTRS}/>`;
+  }
+  if (kind === "house") {
+    return `<polygon points="${round2(cx - 6)},${round2(y + 5.5)} ${round2(cx - 6)},${round2(y - 1)} ${cx},${round2(y - 5.5)} ${round2(cx + 6)},${round2(y - 1)} ${round2(cx + 6)},${round2(y + 5.5)}" ${MINI_ATTRS}/>`;
+  }
+  if (kind === "conditioning") return `<ellipse cx="${cx}" cy="${y}" rx="9" ry="5.5" ${MINI_ATTRS}/>`;
+  return `<polygon points="${cx},${round2(y - 5)} ${round2(cx + 6)},${round2(y + 5)} ${round2(cx - 6)},${round2(y + 5)}" ${MINI_ATTRS}/>`;
+}
+function miniOrPath(cx, y) {
+  return `M ${round2(cx - 7)} ${round2(y + 5.5)} Q ${cx} ${round2(y + 1)} ${round2(cx + 7)} ${round2(y + 5.5)} Q ${round2(cx + 7)} ${round2(y - 1.5)} ${cx} ${round2(y - 5.5)} Q ${round2(cx - 7)} ${round2(y - 1.5)} ${round2(cx - 7)} ${round2(y + 5.5)} Z`;
+}
+function miniGateSwatch(type, x, y) {
+  const cx = round2(x + LEGEND_SWATCH_W / 2);
+  if (type === "and") {
+    const d = `M ${round2(cx - 7)} ${round2(y + 5.5)} L ${round2(cx - 7)} ${round2(y + 1.5)} A 7 7 0 0 1 ${round2(cx + 7)} ${round2(y + 1.5)} L ${round2(cx + 7)} ${round2(y + 5.5)} Z`;
+    return `<path d="${d}" ${MINI_ATTRS}/>`;
+  }
+  if (type === "xor") {
+    return `<path d="${miniOrPath(cx, y)}" ${MINI_ATTRS}/><path d="M ${round2(cx - 7)} ${round2(y + 7.5)} Q ${cx} ${round2(y + 3)} ${round2(cx + 7)} ${round2(y + 7.5)}" ${MINI_ATTRS}/>`;
+  }
+  if (type === "inhibit") {
+    return `<polygon points="${cx},${round2(y - 5.5)} ${round2(cx + 4.5)},${round2(y - 2.5)} ${round2(cx + 4.5)},${round2(y + 2.5)} ${cx},${round2(y + 5.5)} ${round2(cx - 4.5)},${round2(y + 2.5)} ${round2(cx - 4.5)},${round2(y - 2.5)}" ${MINI_ATTRS}/>`;
+  }
+  return `<path d="${miniOrPath(cx, y)}" ${MINI_ATTRS}/>`;
+}
+function faultTreeLayoutSvg(layout, opts = {}) {
+  const labels = opts.labels ?? FAULT_TREE_SVG_LABELS_EN;
+  const parts = [];
+  for (const el of layout.elements) parts.push(elementSvg(el));
+  for (const g of layout.gates) parts.push(gateSvg(g));
+  for (const n of layout.nodes) parts.push(nodeSvg(n));
+  let width = layout.width;
+  let height = layout.height;
+  if (opts.legend !== false && layout.nodes.length > 0) {
+    const kindsUsed = new Set(layout.nodes.map((n) => n.kind));
+    const typesUsed = new Set(layout.gates.map((g) => g.type));
+    const entries = [];
+    for (const kind of FAULT_TREE_EVENT_KINDS) {
+      if (!kindsUsed.has(kind)) continue;
+      entries.push({ swatch: (x, y) => miniEventSwatch(kind, x, y), label: labels.events[kind] });
+    }
+    for (const type of GATE_TYPES) {
+      if (!typesUsed.has(type)) continue;
+      entries.push({ swatch: (x, y) => miniGateSwatch(type, x, y), label: labels.gates[type] });
+    }
+    const block = legendBlock(entries, layout.height);
+    if (block.svg !== "") {
+      parts.push(block.svg);
+      width = Math.max(width, block.width);
+      height = block.height;
+    }
+  }
+  const w = Math.ceil(width);
+  const h = Math.ceil(height);
+  return `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 ${w} ${h}" width="${w}" height="${h}" role="img" aria-label="${xmlEscape(labels.ariaLabel)}">` + parts.join("") + `</svg>`;
+}
+
+// src/fault-tree/render.ts
+function faultTreeSvg(input, opts = {}) {
+  const layout = computeFaultTreeLayout(input, {
+    ...opts.maxLabelChars !== void 0 ? { maxLabelChars: opts.maxLabelChars } : {},
+    ...opts.titleLabels !== void 0 ? { titleLabels: opts.titleLabels } : {}
+  });
+  const svg = faultTreeLayoutSvg(layout, {
+    ...opts.legend === false ? { legend: false } : {},
+    ...opts.svgLabels !== void 0 ? { labels: opts.svgLabels } : {}
+  });
+  return { svg, layout };
+}
+
+export { CODE_FONT, FAULT_TREE_EVENT_KINDS, FAULT_TREE_SVG_LABELS_EN, FAULT_TREE_TITLE_LABELS_EN, FT_BUS_ID_BASE, FT_CONDITION_ID_BASE, FT_DROP_ID_BASE, FT_LABEL_FONT, FT_LABEL_LINE_H, FT_RISER_ID_BASE, FT_STEM_ID_BASE, FaultTreeValidationError, GATE_TYPES, LABEL_GAP, computeFaultTreeLayout, faultTreeIssues, faultTreeLayoutSvg, faultTreeSvg, validateFaultTree };
+//# sourceMappingURL=chunk-LRHHUJFZ.js.map
+//# sourceMappingURL=chunk-LRHHUJFZ.js.map