compasso 0.4.1 → 0.5.0

package/dist/prisma/index.cjs

@@ -0,0 +1,882 @@
+'use strict';
+
+// src/prisma/types.ts
+var PRISMA_PHASES = ["identification", "screening", "included"];
+var PRISMA_BOX_KINDS = ["flow", "exclusion"];
+var PRISMA_COLUMNS = ["main", "new", "previous"];
+
+// src/prisma/validate.ts
+var PrismaValidationError = class extends Error {
+  issues;
+  constructor(issues) {
+    super(`invalid PRISMA diagram: ${issues.map((i) => i.message).join("; ")}`);
+    this.name = "PrismaValidationError";
+    this.issues = issues;
+  }
+};
+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 prismaIssues(input) {
+  if (input.boxes.length === 0 && input.arrows.length === 0) return [];
+  const issues = [];
+  const push = (code, message) => {
+    issues.push({ code, message });
+  };
+  const boxById = /* @__PURE__ */ new Map();
+  const dupBoxIds = /* @__PURE__ */ new Set();
+  for (const b of input.boxes) {
+    if (boxById.has(b.id)) dupBoxIds.add(b.id);
+    else boxById.set(b.id, b);
+  }
+  for (const id of [...dupBoxIds].sort((a, b) => a - b)) {
+    push("duplicate-id", `duplicate box id ${id}`);
+  }
+  const arrowById = /* @__PURE__ */ new Map();
+  const dupArrowIds = /* @__PURE__ */ new Set();
+  for (const a of input.arrows) {
+    if (arrowById.has(a.id)) dupArrowIds.add(a.id);
+    else arrowById.set(a.id, a);
+  }
+  for (const id of [...dupArrowIds].sort((a, b) => a - b)) {
+    push("duplicate-id", `duplicate arrow id ${id}`);
+  }
+  if (issues.length > 0) return sortIssues(issues);
+  for (const arrow of [...arrowById.values()].sort((a, b) => a.id - b.id)) {
+    if (!boxById.has(arrow.fromId)) {
+      push("unknown-arrow-endpoint", `arrow ${arrow.id} fromId ${arrow.fromId} is not a declared box`);
+    }
+    if (!boxById.has(arrow.toId)) {
+      push("unknown-arrow-endpoint", `arrow ${arrow.id} toId ${arrow.toId} is not a declared box`);
+    }
+    if (arrow.fromId === arrow.toId) {
+      push("self-arrow", `arrow ${arrow.id} has fromId === toId (${arrow.fromId})`);
+    }
+  }
+  for (const box of [...boxById.values()].sort((a, b) => a.id - b.id)) {
+    for (const count of box.counts) {
+      if (count.n !== null && !Number.isFinite(count.n)) {
+        push("non-finite-count", `box ${box.id} count "${count.label}" has non-finite n: ${String(count.n)}`);
+      }
+    }
+  }
+  if (input.variant !== "flow-with-prior") {
+    for (const box of [...boxById.values()].sort((a, b) => a.id - b.id)) {
+      if (box.column === "previous") {
+        push(
+          "invalid-variant-column",
+          `box ${box.id} has column "previous" but variant is "${input.variant}"`
+        );
+      }
+    }
+  }
+  const GRAPH_BLOCKING = /* @__PURE__ */ new Set([
+    "duplicate-id",
+    "unknown-arrow-endpoint"
+  ]);
+  if (!issues.some((i) => GRAPH_BLOCKING.has(i.code))) {
+    const phaseIndex = /* @__PURE__ */ new Map();
+    for (let i = 0; i < PRISMA_PHASES.length; i++) phaseIndex.set(PRISMA_PHASES[i], i);
+    for (const arrow of [...arrowById.values()].sort((a, b) => a.id - b.id)) {
+      const fromBox = boxById.get(arrow.fromId);
+      const toBox = boxById.get(arrow.toId);
+      const fromPhaseIdx = phaseIndex.get(fromBox.phase);
+      const toPhaseIdx = phaseIndex.get(toBox.phase);
+      if (fromBox.kind === "flow" && toBox.kind === "exclusion" && fromBox.phase === toBox.phase) {
+        continue;
+      }
+      if (toPhaseIdx < fromPhaseIdx) {
+        push(
+          "arrow-skips-backward",
+          `arrow ${arrow.id} goes backward: from phase "${fromBox.phase}" to "${toBox.phase}"`
+        );
+      }
+    }
+  }
+  return sortIssues(issues);
+}
+function validatePrisma(input) {
+  const issues = prismaIssues(input);
+  if (issues.length > 0) throw new PrismaValidationError(issues);
+}
+
+// src/prisma/labels.ts
+var PRISMA_TITLE_LABELS_EN = {
+  phases: {
+    identification: "Identification",
+    screening: "Screening",
+    included: "Included"
+  },
+  nullCount: "n = \u2014",
+  arrowKinds: {
+    flow: "Flow",
+    exclusion: "Exclusion",
+    merge: "Merge"
+  }
+};
+var PRISMA_SVG_LABELS_EN = {
+  legend: {
+    flow: "Main flow",
+    exclusion: "Excluded"
+  },
+  ariaLabel: "PRISMA 2020 flow diagram"
+};
+
+// 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/geometry.ts
+function pathData(points) {
+  return points.map((p, i) => `${i === 0 ? "M" : "L"} ${p.x} ${p.y}`).join(" ");
+}
+
+// src/core/text.ts
+var CHAR_W = 0.6;
+function estimateTextWidth(text, fontPx) {
+  return text.length * fontPx * CHAR_W;
+}
+function wrapLabel(label, perLine, maxLines = 2) {
+  if (label.length <= perLine) return [label];
+  const cap = (s) => s.length > perLine ? s.slice(0, Math.max(1, perLine - 1)) + "\u2026" : s;
+  const lines = [""];
+  for (const word of label.split(/\s+/)) {
+    const last = lines.length - 1;
+    const current = lines[last];
+    if (current === "" || (current + " " + word).length <= perLine) {
+      lines[last] = current === "" ? word : `${current} ${word}`;
+    } else if (lines.length < maxLines) {
+      lines.push(word);
+    } else {
+      lines[last] = `${current} ${word}`;
+    }
+  }
+  if (lines.length > 1 && lines[lines.length - 1] === "") lines.pop();
+  return lines.map(cap);
+}
+function wrapLabelBalanced(label, maxLines) {
+  const perLine = Math.min(26, Math.max(14, Math.ceil(label.length / 2) + 2));
+  return wrapLabel(label, perLine, maxLines);
+}
+var FONT_FAMILY = "Helvetica, Arial, sans-serif";
+
+// src/core/legend.ts
+var LEGEND_ROW_H = 18;
+var LEGEND_PAD = 16;
+var LEGEND_SWATCH_W = 22;
+var LEGEND_GAP = 14;
+var LEGEND_FONT = 11;
+var LEGEND_TEXT_FILL = "#52525b";
+function legendBlock(entries, startY) {
+  if (entries.length === 0) return { svg: "", width: 0, height: startY };
+  const rows = entries.map((entry, i) => {
+    const rowCenterY = startY + i * LEGEND_ROW_H + LEGEND_ROW_H / 2;
+    const textX = LEGEND_PAD + LEGEND_SWATCH_W + LEGEND_GAP;
+    return entry.swatch(LEGEND_PAD, rowCenterY) + `<text x="${textX}" y="${rowCenterY + LEGEND_FONT * 0.32}" font-family="${FONT_FAMILY}" font-size="${LEGEND_FONT}" fill="${LEGEND_TEXT_FILL}">${xmlEscape(entry.label)}</text>`;
+  });
+  const widestLabel = entries.reduce((m, e) => Math.max(m, estimateTextWidth(e.label, LEGEND_FONT)), 0);
+  return {
+    svg: `<g data-compasso-legend="true">${rows.join("")}</g>`,
+    width: LEGEND_PAD + LEGEND_SWATCH_W + LEGEND_GAP + widestLabel + LEGEND_PAD,
+    height: startY + entries.length * LEGEND_ROW_H + LEGEND_PAD / 2
+  };
+}
+
+// src/core/layered.ts
+function packSubtree(node, gaps) {
+  const { ownHalfL, ownHalfR, children } = node;
+  if (children.length === 0) {
+    return { halfL: ownHalfL, halfR: ownHalfR, offsets: [] };
+  }
+  const xs = [0];
+  for (let i = 1; i < children.length; i++) {
+    xs.push(xs[i - 1] + children[i - 1].halfR + gaps.siblingGap + children[i].halfL);
+  }
+  const first = children[0];
+  const last = children[children.length - 1];
+  const axis = (xs[0] + xs[xs.length - 1]) / 2;
+  const offsets = xs.map((x) => x - axis);
+  const halfL = Math.max(ownHalfL, axis - (xs[0] - first.halfL));
+  const halfR = Math.max(ownHalfR, xs[xs.length - 1] + last.halfR - axis);
+  return { halfL, halfR, offsets };
+}
+function bandStack(rows, opts) {
+  const { padding, corridor } = opts;
+  if (rows.length === 0) {
+    return { rowTop: [], busY: () => 0, height: padding * 2 };
+  }
+  const rowTop = [padding];
+  for (let d = 0; d < rows.length - 1; d++) {
+    rowTop.push(rowTop[d] + rows[d].rowH + rows[d].zoneH + corridor);
+  }
+  const last = rows.length - 1;
+  const busY = (d) => rowTop[d + 1] - corridor / 2;
+  const height = rowTop[last] + rows[last].rowH + rows[last].zoneH + padding;
+  return { rowTop, busY, height };
+}
+
+// src/core/glyph.ts
+function dirVec(dir) {
+  switch (dir) {
+    case "right":
+      return [1, 0];
+    case "left":
+      return [-1, 0];
+    case "down":
+      return [0, 1];
+    case "up":
+      return [0, -1];
+  }
+}
+function r(n) {
+  return Math.round(n * 100) / 100;
+}
+function pt(x, y) {
+  return `${r(x)},${r(y)}`;
+}
+var GLYPH_ARROW_LEN = 10;
+var GLYPH_ARROW_HALF = 5;
+var GLYPH_TRI_LEN = 14;
+var GLYPH_DIAMOND_LEN = 16;
+function arrowFilledPoints(tip, dir, len = GLYPH_ARROW_LEN, half = GLYPH_ARROW_HALF) {
+  return _arrowPoints(tip, dir, len, half);
+}
+function _arrowPoints(tip, dir, len, half) {
+  const [ux, uy] = dirVec(dir);
+  const tx = tip.x;
+  const ty = tip.y;
+  const bx = tx - ux * len;
+  const by = ty - uy * len;
+  const px = -uy;
+  const py = ux;
+  return [
+    pt(tx, ty),
+    pt(bx + px * half, by + py * half),
+    pt(bx - px * half, by - py * half)
+  ].join(" ");
+}
+function glyphInset(_dir, kind) {
+  switch (kind) {
+    case "arrow":
+      return GLYPH_ARROW_LEN;
+    case "triangle":
+      return GLYPH_TRI_LEN;
+    case "diamond":
+      return GLYPH_DIAMOND_LEN;
+  }
+}
+
+// src/core/compartment.ts
+function round(n) {
+  return Math.round(n * 100) / 100;
+}
+function measureCompartmentBox(compartments, opts) {
+  const { padX, padY, lineH, minW } = opts;
+  let maxLineW = 0;
+  for (const c of compartments) {
+    for (const line of c.lines) {
+      const w = estimateTextWidth(line, c.font);
+      if (w > maxLineW) maxLineW = w;
+    }
+  }
+  const boxW = round(Math.max(minW, maxLineW + 2 * padX));
+  const rows = [];
+  const dividerYs = [];
+  let y = 0;
+  for (let i = 0; i < compartments.length; i++) {
+    const c = compartments[i];
+    const lineCount = c.lines.length > 0 ? c.lines.length : 1;
+    const compartmentH = padY + lineCount * lineH + padY;
+    rows.push({
+      lines: c.lines,
+      top: round(y + padY),
+      font: c.font
+    });
+    y += compartmentH;
+    if (i < compartments.length - 1) {
+      dividerYs.push(round(y));
+    }
+  }
+  const boxH = round(y);
+  return { boxW, boxH, rows, dividerYs };
+}
+
+// src/prisma/layout.ts
+var PRISMA_PADDING = 32;
+var PRISMA_BAND_LABEL_W = 40;
+var PRISMA_COL_GAP = 56;
+var PRISMA_CORRIDOR = 30;
+var PRISMA_BOX_PAD_X = 12;
+var PRISMA_BOX_PAD_Y = 10;
+var PRISMA_LINE_H = 14;
+var PRISMA_MIN_BOX_W = 200;
+var PRISMA_EXCL_GAP = 48;
+var PRISMA_HEADING_FONT = 12;
+var PRISMA_COUNT_FONT = 10;
+var PRISMA_ROUTE_MARGIN = 10;
+var PRISMA_ROUTE_PITCH = 10;
+var PRISMA_FLOW_ARROW_BASE = 1e6;
+var PRISMA_EXCL_ARROW_BASE = 2e6;
+var PRISMA_MERGE_ARROW_BASE = 3e6;
+function round2(n) {
+  return Math.round(n * 100) / 100;
+}
+function wrapHeading(h) {
+  if (h === null || h === "") return [];
+  return wrapLabelBalanced(h);
+}
+function countLine(label, n, nullToken) {
+  const nStr = n === null ? nullToken : String(n);
+  return `${label}: n = ${nStr}`;
+}
+function buildCountLines(counts, nullToken) {
+  return counts.map((c) => countLine(c.label, c.n, nullToken));
+}
+function boxTitle(box, nullToken) {
+  if (box.title !== void 0) return box.title;
+  const parts = [];
+  if (box.heading !== null && box.heading !== "") parts.push(box.heading);
+  for (const c of box.counts) parts.push(countLine(c.label, c.n, nullToken));
+  return parts.join("; ") || "(box)";
+}
+function computePrismaLayout(input, opts = {}) {
+  if (opts.validate !== false) validatePrisma(input);
+  const labels = opts.labels ?? PRISMA_TITLE_LABELS_EN;
+  const nullToken = labels.nullCount;
+  const COMP_OPTS = {
+    padX: PRISMA_BOX_PAD_X,
+    padY: PRISMA_BOX_PAD_Y,
+    lineH: PRISMA_LINE_H,
+    minW: PRISMA_MIN_BOX_W};
+  const boxMetrics = /* @__PURE__ */ new Map();
+  for (const b of input.boxes) {
+    const headingLines = wrapHeading(b.heading);
+    const cLines = buildCountLines(b.counts, nullToken);
+    const metrics = measureCompartmentBox(
+      [
+        { lines: headingLines, font: PRISMA_HEADING_FONT },
+        { lines: cLines, font: PRISMA_COUNT_FONT }
+      ],
+      COMP_OPTS
+    );
+    boxMetrics.set(b.id, {
+      boxW: metrics.boxW,
+      boxH: metrics.boxH,
+      rows: metrics.rows,
+      dividerYs: metrics.dividerYs,
+      headingLines,
+      countLines: cLines
+    });
+  }
+  const boxesByKey = /* @__PURE__ */ new Map();
+  for (const b of input.boxes) {
+    const key = `${b.phase}:${b.column}:${b.kind}`;
+    const arr = boxesByKey.get(key) ?? [];
+    arr.push(b);
+    boxesByKey.set(key, arr);
+  }
+  for (const arr of boxesByKey.values()) {
+    arr.sort((a, b) => a.rank !== b.rank ? a.rank - b.rank : a.id - b.id);
+  }
+  const groupOf = (phase, col, kind) => boxesByKey.get(`${phase}:${col}:${kind}`) ?? [];
+  const flowCols = input.variant === "flow-with-prior" ? ["new", "previous"] : input.variant === "flow-other-methods" ? ["main", "new"] : ["main"];
+  const contentLeft = PRISMA_PADDING + PRISMA_BAND_LABEL_W;
+  function maxColW(col, kind) {
+    let w = 0;
+    for (const phase of PRISMA_PHASES) {
+      for (const b of groupOf(phase, col, kind)) {
+        const bw = boxMetrics.get(b.id).boxW;
+        if (bw > w) w = bw;
+      }
+    }
+    return w;
+  }
+  const colHasFlow = (col) => PRISMA_PHASES.some((phase) => groupOf(phase, col, "flow").length > 0);
+  const colHasExcl = (col) => PRISMA_PHASES.some((phase) => groupOf(phase, col, "exclusion").length > 0);
+  const exclOnlyCols = ["main", "new", "previous"].filter(
+    (col) => !flowCols.includes(col) && colHasExcl(col)
+  );
+  const placedCols = [...flowCols, ...exclOnlyCols];
+  const colGeom = /* @__PURE__ */ new Map();
+  for (const col of placedCols) {
+    const flowW = colHasFlow(col) ? Math.max(PRISMA_MIN_BOX_W, maxColW(col, "flow")) : 0;
+    const exclW = maxColW(col, "exclusion");
+    const blockW = flowW > 0 && exclW > 0 ? flowW + PRISMA_EXCL_GAP + exclW : flowW > 0 ? flowW : exclW;
+    colGeom.set(col, { flowW, exclW, blockW, flowCx: 0, exclCx: 0 });
+  }
+  function placeBlock(col, blockLeft) {
+    const g = colGeom.get(col);
+    if (g.flowW > 0) g.flowCx = round2(blockLeft + g.flowW / 2);
+    if (g.exclW > 0) {
+      const exclLeft = g.flowW > 0 ? blockLeft + g.flowW + PRISMA_EXCL_GAP : blockLeft;
+      g.exclCx = round2(exclLeft + g.exclW / 2);
+    }
+  }
+  if (placedCols.length === 1) {
+    placeBlock(placedCols[0], contentLeft);
+  } else {
+    const packed = packSubtree(
+      {
+        ownHalfL: 0,
+        ownHalfR: 0,
+        children: placedCols.map((col) => {
+          const half = colGeom.get(col).blockW / 2;
+          return { halfL: half, halfR: half };
+        })
+      },
+      { siblingGap: PRISMA_COL_GAP }
+    );
+    const totalW = packed.halfL + packed.halfR;
+    const blockCx = round2(contentLeft + totalW / 2);
+    placedCols.forEach((col, i) => {
+      const w = colGeom.get(col).blockW;
+      placeBlock(col, round2(blockCx + packed.offsets[i] - w / 2));
+    });
+  }
+  let totalRight = contentLeft;
+  for (const col of placedCols) {
+    const g = colGeom.get(col);
+    const r2 = g.exclW > 0 ? round2(g.exclCx + g.exclW / 2) : round2(g.flowCx + g.flowW / 2);
+    if (r2 > totalRight) totalRight = r2;
+  }
+  const rowsByCol = /* @__PURE__ */ new Map();
+  const rowsKey = (phase, col) => `${phase}:${col}`;
+  function buildRankRows(phase, col) {
+    const byRank = /* @__PURE__ */ new Map();
+    for (const kind of ["flow", "exclusion"]) {
+      for (const b of groupOf(phase, col, kind)) {
+        const h = boxMetrics.get(b.id).boxH;
+        const prev = byRank.get(b.rank) ?? 0;
+        if (h > prev) byRank.set(b.rank, h);
+      }
+    }
+    const ranks = [...byRank.keys()].sort((a, b) => a - b);
+    return ranks.map((rank) => ({ rank, rowH: byRank.get(rank), top: 0 }));
+  }
+  for (const phase of PRISMA_PHASES) {
+    for (const col of placedCols) {
+      rowsByCol.set(rowsKey(phase, col), buildRankRows(phase, col));
+    }
+  }
+  function colStackH(rows) {
+    if (rows.length === 0) return 0;
+    let h = 0;
+    for (const r2 of rows) h += r2.rowH + PRISMA_BOX_PAD_Y;
+    return h - PRISMA_BOX_PAD_Y;
+  }
+  function bandRowH(phase) {
+    let maxH = 0;
+    let any = false;
+    for (const col of placedCols) {
+      const rows = rowsByCol.get(rowsKey(phase, col));
+      if (rows.length > 0) any = true;
+      const h = colStackH(rows);
+      if (h > maxH) maxH = h;
+    }
+    if (!any) return PRISMA_LINE_H * 2 + PRISMA_BOX_PAD_Y * 4;
+    return maxH;
+  }
+  const bandRowHs = PRISMA_PHASES.map((phase) => ({
+    rowH: bandRowH(phase),
+    zoneH: 0
+  }));
+  const stacked = bandStack(bandRowHs, { padding: PRISMA_PADDING, corridor: PRISMA_CORRIDOR });
+  const layoutBoxes = [];
+  const lboxById = /* @__PURE__ */ new Map();
+  function placeBox(b, phase, kind, cx, top) {
+    const m = boxMetrics.get(b.id);
+    const t = round2(top);
+    const title = boxTitle(b, nullToken);
+    const lbox = {
+      id: b.id,
+      phase,
+      kind,
+      cx: round2(cx),
+      top: t,
+      boxW: m.boxW,
+      boxH: m.boxH,
+      rows: m.rows.map((r2) => ({ ...r2, top: round2(t + r2.top) })),
+      dividerYs: m.dividerYs.map((d) => round2(t + d)),
+      heading: b.heading,
+      countLines: m.countLines,
+      title
+    };
+    layoutBoxes.push(lbox);
+    lboxById.set(b.id, lbox);
+  }
+  for (let phaseIdx = 0; phaseIdx < PRISMA_PHASES.length; phaseIdx++) {
+    const phase = PRISMA_PHASES[phaseIdx];
+    const bandTop = stacked.rowTop[phaseIdx];
+    for (const col of placedCols) {
+      const g = colGeom.get(col);
+      const rows = rowsByCol.get(rowsKey(phase, col));
+      const topByRank = /* @__PURE__ */ new Map();
+      let y = bandTop;
+      for (const r2 of rows) {
+        r2.top = round2(y);
+        topByRank.set(r2.rank, r2.top);
+        y = round2(y + r2.rowH + PRISMA_BOX_PAD_Y);
+      }
+      if (g.flowW > 0) {
+        for (const b of groupOf(phase, col, "flow")) {
+          placeBox(b, phase, "flow", g.flowCx, topByRank.get(b.rank));
+        }
+      }
+      if (g.exclW > 0) {
+        for (const b of groupOf(phase, col, "exclusion")) {
+          placeBox(b, phase, "exclusion", g.exclCx, topByRank.get(b.rank));
+        }
+      }
+    }
+  }
+  const elements = [];
+  const boxById = new Map(input.boxes.map((b) => [b.id, b]));
+  const phaseIndexMap = new Map(
+    PRISMA_PHASES.map((p, i) => [p, i])
+  );
+  function boxBottom(lb) {
+    return round2(lb.top + lb.boxH);
+  }
+  function bandBottom(phase) {
+    const idx = PRISMA_PHASES.indexOf(phase);
+    return round2(stacked.rowTop[idx] + bandRowHs[idx].rowH);
+  }
+  const arrowsToBox = /* @__PURE__ */ new Map();
+  for (const arrow of input.arrows) {
+    const toBox = boxById.get(arrow.toId);
+    const fromBox = boxById.get(arrow.fromId);
+    if (toBox === void 0 || fromBox === void 0) continue;
+    if (fromBox.kind === "flow" && toBox.kind === "flow") {
+      const arr = arrowsToBox.get(arrow.toId) ?? [];
+      arr.push(arrow.id);
+      arrowsToBox.set(arrow.toId, arr);
+    }
+  }
+  const arrowToBoxArrivalIdx = /* @__PURE__ */ new Map();
+  const exclArrowIndexBySource = /* @__PURE__ */ new Map();
+  for (const arrow of input.arrows) {
+    const fromLBox = lboxById.get(arrow.fromId);
+    const toLBox = lboxById.get(arrow.toId);
+    if (fromLBox === void 0 || toLBox === void 0) continue;
+    const fromBox = boxById.get(arrow.fromId);
+    const toBox = boxById.get(arrow.toId);
+    const isExclusion = fromBox.kind === "flow" && toBox.kind === "exclusion";
+    const isFlowToFlow = fromBox.kind === "flow" && toBox.kind === "flow";
+    if (isExclusion) {
+      const idx = exclArrowIndexBySource.get(arrow.fromId) ?? 0;
+      exclArrowIndexBySource.set(arrow.fromId, idx + 1);
+      const srcRight = round2(fromLBox.cx + fromLBox.boxW / 2);
+      const exclMidY = round2(toLBox.top + toLBox.boxH / 2);
+      const eLeft = round2(toLBox.cx - toLBox.boxW / 2);
+      const sameColumn = fromBox.column === toBox.column;
+      let points;
+      if (sameColumn) {
+        points = [
+          { x: round2(srcRight), y: round2(exclMidY) },
+          { x: round2(eLeft), y: round2(exclMidY) }
+        ];
+      } else {
+        const colGapStep = round2(PRISMA_COL_GAP / 8);
+        const exclGapStep = round2(PRISMA_EXCL_GAP / 8);
+        const fenceX = round2(srcRight + (idx + 1) * colGapStep);
+        const exclFenceX = round2(eLeft - (idx + 1) * exclGapStep);
+        const bBotY = bandBottom(fromBox.phase);
+        const corridorY = round2(bBotY + PRISMA_ROUTE_MARGIN + idx * PRISMA_ROUTE_PITCH);
+        points = [
+          { x: round2(srcRight), y: round2(exclMidY) },
+          // exit source right at excl center y
+          { x: round2(fenceX), y: round2(exclMidY) },
+          // horizontal into inter-col gap (unique y)
+          { x: round2(fenceX), y: round2(corridorY) },
+          // vertical at unique x in inter-col gap
+          { x: round2(exclFenceX), y: round2(corridorY) },
+          // horizontal in corridor (unique y)
+          { x: round2(exclFenceX), y: round2(exclMidY) },
+          // vertical at unique x left of excl box
+          { x: round2(eLeft), y: round2(exclMidY) }
+          // horizontal into excl box (unique y)
+        ];
+      }
+      elements.push({
+        edgeId: PRISMA_EXCL_ARROW_BASE + arrow.id,
+        kind: "exclusion",
+        points,
+        title: `${labels.arrowKinds.exclusion}: ${fromLBox.title} \u2192 ${toLBox.title}`,
+        headDir: "right"
+      });
+    } else if (isFlowToFlow) {
+      const fromPhaseIdx = phaseIndexMap.get(fromBox.phase);
+      const toPhaseIdx = phaseIndexMap.get(toBox.phase);
+      const isSamePhase = fromBox.phase === toBox.phase;
+      const isSameCol = fromBox.column === toBox.column;
+      const isForward = toPhaseIdx >= fromPhaseIdx;
+      const arrivals = arrowsToBox.get(arrow.toId) ?? [];
+      let arrivalIdx = arrowToBoxArrivalIdx.get(arrow.id) ?? 0;
+      if (!arrowToBoxArrivalIdx.has(arrow.id)) {
+        arrivalIdx = arrivals.indexOf(arrow.id);
+        arrowToBoxArrivalIdx.set(arrow.id, arrivalIdx);
+      }
+      const nArrivals = arrivals.length;
+      const APPROACH_SPREAD = round2(toLBox.boxW / 4);
+      const spreadStep = nArrivals > 1 ? round2(APPROACH_SPREAD / (nArrivals - 1)) : 0;
+      const approachX = round2(toLBox.cx - APPROACH_SPREAD / 2 + arrivalIdx * spreadStep);
+      const toTop = toLBox.top;
+      if (isSamePhase && isSameCol) {
+        const fromBottom = boxBottom(fromLBox);
+        const fromCx = round2(fromLBox.cx);
+        const toCx = round2(toLBox.cx);
+        const dropX = fromCx === toCx ? fromCx : toCx;
+        elements.push({
+          edgeId: PRISMA_FLOW_ARROW_BASE + arrow.id,
+          kind: "flow",
+          points: [
+            { x: fromCx, y: round2(fromBottom) },
+            { x: dropX, y: round2(toTop) }
+          ],
+          title: `${labels.arrowKinds.flow}: ${fromLBox.title} \u2192 ${toLBox.title}`,
+          headDir: "down"
+        });
+      } else if (isSameCol && isForward) {
+        const fromBottom = boxBottom(fromLBox);
+        if (nArrivals <= 1 && round2(fromLBox.cx) === round2(toLBox.cx)) {
+          elements.push({
+            edgeId: PRISMA_FLOW_ARROW_BASE + arrow.id,
+            kind: "flow",
+            points: [
+              { x: round2(fromLBox.cx), y: round2(fromBottom) },
+              { x: round2(toLBox.cx), y: round2(toTop) }
+            ],
+            title: `${labels.arrowKinds.flow}: ${fromLBox.title} \u2192 ${toLBox.title}`,
+            headDir: "down"
+          });
+        } else {
+          const phIdx = phaseIndexMap.get(fromBox.phase);
+          const elbowY = round2(stacked.rowTop[phIdx] + bandRowHs[phIdx].rowH + PRISMA_CORRIDOR / 2);
+          elements.push({
+            edgeId: PRISMA_FLOW_ARROW_BASE + arrow.id,
+            kind: "flow",
+            points: [
+              { x: round2(fromLBox.cx), y: round2(fromBottom) },
+              { x: round2(fromLBox.cx), y: round2(elbowY) },
+              { x: round2(approachX), y: round2(elbowY) },
+              { x: round2(approachX), y: round2(toTop) }
+            ],
+            title: `${labels.arrowKinds.flow}: ${fromLBox.title} \u2192 ${toLBox.title}`,
+            headDir: "down"
+          });
+        }
+      } else {
+        const fromBottom = boxBottom(fromLBox);
+        const phIdx = phaseIndexMap.get(fromBox.phase);
+        const elbowY = round2(stacked.rowTop[phIdx] + bandRowHs[phIdx].rowH + PRISMA_CORRIDOR / 2);
+        const fromCx = round2(fromLBox.cx);
+        if (round2(fromCx) === round2(approachX)) {
+          elements.push({
+            edgeId: PRISMA_MERGE_ARROW_BASE + arrow.id,
+            kind: "merge",
+            points: [
+              { x: fromCx, y: round2(fromBottom) },
+              { x: round2(approachX), y: round2(toTop) }
+            ],
+            title: `${labels.arrowKinds.merge}: ${fromLBox.title} \u2192 ${toLBox.title}`,
+            headDir: "down"
+          });
+        } else {
+          elements.push({
+            edgeId: PRISMA_MERGE_ARROW_BASE + arrow.id,
+            kind: "merge",
+            points: [
+              { x: fromCx, y: round2(fromBottom) },
+              { x: fromCx, y: round2(elbowY) },
+              { x: round2(approachX), y: round2(elbowY) },
+              { x: round2(approachX), y: round2(toTop) }
+            ],
+            title: `${labels.arrowKinds.merge}: ${fromLBox.title} \u2192 ${toLBox.title}`,
+            headDir: "down"
+          });
+        }
+      }
+    }
+  }
+  const canvasH = stacked.height;
+  const canvasW = round2(totalRight + PRISMA_PADDING);
+  const bands = PRISMA_PHASES.map((phase, i) => {
+    const rowTop = stacked.rowTop[i];
+    const rowH = bandRowHs[i].rowH;
+    return {
+      phase,
+      rowTop,
+      rowH,
+      labelX: PRISMA_PADDING,
+      centerY: round2(rowTop + rowH / 2)
+    };
+  });
+  return {
+    width: canvasW,
+    height: canvasH,
+    boxes: layoutBoxes,
+    elements,
+    bands,
+    variant: input.variant
+  };
+}
+
+// src/prisma/svg.ts
+var BOX_STROKE = "#52525b";
+var BOX_STROKE_W = 2;
+var BOX_FILL = "#fff";
+var BOX_RX = 2;
+var HEADING_FILL = "#3f3f46";
+var COUNT_FILL = "#52525b";
+var ARROW_STROKE = "#71717a";
+var ARROW_STROKE_W = 1.5;
+var ARROW_FILL = "#71717a";
+var BAND_LABEL_FILL = "#52525b";
+var BAND_LABEL_FONT = 11;
+function round3(n) {
+  return Math.round(n * 100) / 100;
+}
+function emitBox(b) {
+  const x = round3(b.cx - b.boxW / 2);
+  const y = b.top;
+  const parts = [];
+  parts.push(
+    `<rect x="${x}" y="${y}" width="${b.boxW}" height="${b.boxH}" rx="${BOX_RX}" fill="${BOX_FILL}" stroke="${BOX_STROKE}" stroke-width="${BOX_STROKE_W}"/>`
+  );
+  for (const dy of b.dividerYs) {
+    parts.push(
+      `<line x1="${x}" y1="${dy}" x2="${round3(x + b.boxW)}" y2="${dy}" stroke="${BOX_STROKE}" stroke-width="1"/>`
+    );
+  }
+  for (let ri = 0; ri < b.rows.length; ri++) {
+    const row = b.rows[ri];
+    const isHeading = ri === 0;
+    const font = row.font;
+    const fill = isHeading ? HEADING_FILL : COUNT_FILL;
+    const textX = isHeading ? round3(b.cx) : round3(x + 8);
+    for (let li = 0; li < row.lines.length; li++) {
+      const line = row.lines[li];
+      const textY = round3(row.top + li * 14 + font);
+      const anchorAttr = isHeading ? ` text-anchor="middle"` : "";
+      const weightAttr = isHeading ? ` font-weight="bold"` : "";
+      parts.push(
+        `<text x="${textX}" y="${textY}" font-family="${FONT_FAMILY}" font-size="${font}" fill="${fill}"${anchorAttr}${weightAttr}>${xmlEscape(line)}</text>`
+      );
+    }
+  }
+  return parts.join("");
+}
+function emitArrow(el) {
+  const points = el.points;
+  if (points.length < 2) return "";
+  const inset = glyphInset(el.headDir, "arrow");
+  const last = points[points.length - 1];
+  let lineEndX = last.x;
+  let lineEndY = last.y;
+  if (el.headDir === "down") lineEndY = round3(last.y - inset);
+  else if (el.headDir === "right") lineEndX = round3(last.x - inset);
+  else if (el.headDir === "left") lineEndX = round3(last.x + inset);
+  else lineEndY = round3(last.y + inset);
+  const linePoints = [
+    ...points.slice(0, points.length - 1).map((p) => ({ x: p.x, y: p.y })),
+    { x: lineEndX, y: lineEndY }
+  ];
+  const pathStr = pathData(linePoints);
+  const arrowPts = arrowFilledPoints({ x: last.x, y: last.y }, el.headDir);
+  return `<title>${xmlEscape(el.title)}</title><path d="${pathStr}" stroke="${ARROW_STROKE}" stroke-width="${ARROW_STROKE_W}" fill="none"/><polygon points="${arrowPts}" fill="${ARROW_FILL}" stroke="none"/>`;
+}
+function emitBandLabel(phase, labelX, centerY, bandTitleLabels) {
+  const text = bandTitleLabels.phases[phase];
+  const gutterCx = round3(labelX + PRISMA_BAND_LABEL_W / 2);
+  return `<text x="${gutterCx}" y="${round3(centerY)}" font-family="${FONT_FAMILY}" font-size="${BAND_LABEL_FONT}" fill="${BAND_LABEL_FILL}" text-anchor="middle" transform="rotate(-90,${gutterCx},${round3(centerY)})">${xmlEscape(text)}</text>`;
+}
+function buildLegendEntries(layout, svgLabels) {
+  const hasFlow = layout.boxes.some((b) => b.kind === "flow");
+  const hasExcl = layout.boxes.some((b) => b.kind === "exclusion");
+  const entries = [];
+  if (hasFlow) {
+    entries.push({
+      label: svgLabels.legend.flow,
+      swatch: (x, cy) => `<rect x="${x}" y="${round3(cy - 6)}" width="22" height="12" rx="2" fill="${BOX_FILL}" stroke="${BOX_STROKE}" stroke-width="2"/>`
+    });
+  }
+  if (hasExcl) {
+    entries.push({
+      label: svgLabels.legend.exclusion,
+      swatch: (x, cy) => `<rect x="${x}" y="${round3(cy - 6)}" width="22" height="12" rx="2" fill="${BOX_FILL}" stroke="${BOX_STROKE}" stroke-width="2" stroke-dasharray="4,2"/>`
+    });
+  }
+  return entries;
+}
+function prismaLayoutSvg(layout, opts = {}) {
+  const svgLabels = opts.svgLabels ?? PRISMA_SVG_LABELS_EN;
+  const bandTitleLabels = opts.titleLabels ?? PRISMA_TITLE_LABELS_EN;
+  const doLegend = opts.legend !== false;
+  const parts = [];
+  for (const band of layout.bands) {
+    parts.push(emitBandLabel(band.phase, band.labelX, band.centerY, bandTitleLabels));
+  }
+  for (const b of layout.boxes) {
+    const boxSvg = emitBox(b);
+    parts.push(`<g data-node-id="b${b.id}"><title>${xmlEscape(b.title)}</title>${boxSvg}</g>`);
+  }
+  for (const el of layout.elements) {
+    const arrowSvg = emitArrow(el);
+    parts.push(`<g data-edge-id="${el.edgeId}">${arrowSvg}</g>`);
+  }
+  let w = layout.width;
+  let h = layout.height;
+  let legendSvg = "";
+  if (doLegend) {
+    const entries = buildLegendEntries(layout, svgLabels);
+    const lb = legendBlock(entries, h);
+    legendSvg = lb.svg;
+    if (entries.length > 0) {
+      w = Math.max(w, lb.width + 32 * 2);
+      h = lb.height;
+    }
+  }
+  w = round3(w);
+  h = round3(h);
+  return `<svg xmlns="http://www.w3.org/2000/svg" width="${w}" height="${h}" viewBox="0 0 ${w} ${h}" role="img" aria-label="${xmlEscape(svgLabels.ariaLabel)}">` + parts.join("") + legendSvg + `</svg>`;
+}
+
+// src/prisma/render.ts
+function prismaSvg(input, opts = {}) {
+  const layout = computePrismaLayout(input, opts);
+  const svg = prismaLayoutSvg(layout, opts);
+  return { svg, layout };
+}
+
+exports.PRISMA_BAND_LABEL_W = PRISMA_BAND_LABEL_W;
+exports.PRISMA_BOX_KINDS = PRISMA_BOX_KINDS;
+exports.PRISMA_BOX_PAD_X = PRISMA_BOX_PAD_X;
+exports.PRISMA_BOX_PAD_Y = PRISMA_BOX_PAD_Y;
+exports.PRISMA_COLUMNS = PRISMA_COLUMNS;
+exports.PRISMA_COL_GAP = PRISMA_COL_GAP;
+exports.PRISMA_CORRIDOR = PRISMA_CORRIDOR;
+exports.PRISMA_COUNT_FONT = PRISMA_COUNT_FONT;
+exports.PRISMA_EXCL_ARROW_BASE = PRISMA_EXCL_ARROW_BASE;
+exports.PRISMA_EXCL_GAP = PRISMA_EXCL_GAP;
+exports.PRISMA_FLOW_ARROW_BASE = PRISMA_FLOW_ARROW_BASE;
+exports.PRISMA_HEADING_FONT = PRISMA_HEADING_FONT;
+exports.PRISMA_LINE_H = PRISMA_LINE_H;
+exports.PRISMA_MERGE_ARROW_BASE = PRISMA_MERGE_ARROW_BASE;
+exports.PRISMA_MIN_BOX_W = PRISMA_MIN_BOX_W;
+exports.PRISMA_PADDING = PRISMA_PADDING;
+exports.PRISMA_PHASES = PRISMA_PHASES;
+exports.PRISMA_SVG_LABELS_EN = PRISMA_SVG_LABELS_EN;
+exports.PRISMA_TITLE_LABELS_EN = PRISMA_TITLE_LABELS_EN;
+exports.PrismaValidationError = PrismaValidationError;
+exports.computePrismaLayout = computePrismaLayout;
+exports.prismaIssues = prismaIssues;
+exports.prismaLayoutSvg = prismaLayoutSvg;
+exports.prismaSvg = prismaSvg;
+exports.validatePrisma = validatePrisma;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map