@crazyhappyone/auto-graph 0.0.21 → 0.1.1

package/dist/index.cjs

@@ -99,11 +99,21 @@ function applyLayoutConstraints(input) {
   const nodeById = new Map(input.nodes.map((node) => [node.id, node]));
   applyFixedPositionLocks(input.nodes, boxes, locks, diagnostics);
   applyExactPositions(input.constraints, boxes, locks, diagnostics, nodeById);
-  applyContainment(input.constraints, boxes, locks, diagnostics);
+  applyContainment(input.constraints, boxes, locks, diagnostics, false);
   applyRelative(input.constraints, boxes, locks, diagnostics);
   applyAlign(input.constraints, boxes, locks, diagnostics);
   applyDistribute(input.constraints, boxes, locks, diagnostics);
-  repairOverlaps(input, boxes, locks, diagnostics);
+  repairOverlaps(
+    input,
+    boxes,
+    locks,
+    diagnostics,
+    siblingOverlapKeys(input.constraints)
+  );
+  applyContainment(input.constraints, boxes, locks, diagnostics, true);
+  applyDistributeContained(input, boxes, locks, diagnostics);
+  reportOverlaps(boxes, diagnostics, containmentOverlapKeys(input.constraints));
+  reportIntraContainerOverflow(input, boxes, diagnostics);
   return { boxes, locks, diagnostics };
 }
 function cloneValidBoxes(input, diagnostics) {
@@ -191,7 +201,7 @@ function applyExactPositions(constraints, boxes, locks, diagnostics, nodeById) {
     locks.set(targetId, { nodeId: targetId, source: "exact-position" });
   }
 }
-function applyContainment(constraints, boxes, locks, diagnostics) {
+function applyContainment(constraints, boxes, locks, diagnostics, reportOverflow) {
   for (const constraint of constraints) {
     if (constraint.kind !== "containment") {
       continue;
@@ -213,21 +223,23 @@ function applyContainment(constraints, boxes, locks, diagnostics) {
         continue;
       }
       if (locks.has(childId)) {
-        diagnostics.push({
-          severity: "warning",
-          code: "constraints.locked-target-not-moved",
-          message: `Locked child ${childId} was not moved into containment.`,
-          path: ["constraints", constraint.id ?? constraint.containerId],
-          detail: { nodeId: childId }
-        });
-        if (!isInside(child, content)) {
+        if (!reportOverflow) {
           diagnostics.push({
-            severity: "error",
-            code: "constraints.containment.impossible",
-            message: `Locked child ${childId} cannot fit inside ${constraint.containerId}.`,
+            severity: "warning",
+            code: "constraints.locked-target-not-moved",
+            message: `Locked child ${childId} was not moved into containment.`,
             path: ["constraints", constraint.id ?? constraint.containerId],
-            detail: { nodeId: childId, containerId: constraint.containerId }
+            detail: { nodeId: childId }
           });
+          if (!isInside(child, content)) {
+            diagnostics.push({
+              severity: "error",
+              code: "constraints.containment.impossible",
+              message: `Locked child ${childId} cannot fit inside ${constraint.containerId}.`,
+              path: ["constraints", constraint.id ?? constraint.containerId],
+              detail: { nodeId: childId, containerId: constraint.containerId }
+            });
+          }
         }
         continue;
       }
@@ -242,6 +254,15 @@ function applyContainment(constraints, boxes, locks, diagnostics) {
         continue;
       }
       boxes.set(childId, next);
+      if (reportOverflow) {
+        diagnostics.push({
+          severity: "warning",
+          code: "containment_overflow",
+          message: `Child ${childId} was clamped back inside ${constraint.containerId} after constraint solving.`,
+          path: ["constraints", constraint.id ?? constraint.containerId],
+          detail: { nodeId: childId, containerId: constraint.containerId }
+        });
+      }
     }
   }
 }
@@ -317,37 +338,69 @@ function applyDistribute(constraints, boxes, locks, diagnostics) {
     }
   }
 }
-function repairOverlaps(input, boxes, locks, diagnostics) {
+function repairOverlaps(input, boxes, locks, diagnostics, siblingPairs) {
   const spacing = input.overlapSpacing ?? 40;
   const axis = input.direction === "LR" || input.direction === "RL" ? "x" : "y";
+  const secondaryAxis = axis === "x" ? "y" : "x";
+  const ignoredPairs = containmentOverlapKeys(input.constraints);
   const ids = [...boxes.keys()].sort();
-  for (const firstId of ids) {
-    for (const secondId of ids) {
-      if (firstId >= secondId) {
-        continue;
-      }
-      const first = boxes.get(firstId);
-      const second = boxes.get(secondId);
-      if (first === void 0 || second === void 0 || !intersectsAabb(first, second)) {
-        continue;
-      }
-      const firstLocked = locks.has(firstId);
-      const secondLocked = locks.has(secondId);
-      if (firstLocked === secondLocked) {
-        continue;
+  for (let pass = 0; pass < 2; pass += 1) {
+    for (const firstId of ids) {
+      for (const secondId of ids) {
+        if (firstId >= secondId) {
+          continue;
+        }
+        if (ignoredPairs.has(overlapKey(firstId, secondId))) {
+          continue;
+        }
+        const first = boxes.get(firstId);
+        const second = boxes.get(secondId);
+        if (first === void 0 || second === void 0 || !intersectsAabb(first, second)) {
+          continue;
+        }
+        const firstLocked = locks.has(firstId);
+        const secondLocked = locks.has(secondId);
+        if (firstLocked && secondLocked) {
+          continue;
+        }
+        const movingId = firstLocked ? secondId : secondLocked ? firstId : secondId;
+        const moving = movingId === firstId ? first : second;
+        const fixed = movingId === firstId ? second : first;
+        const repairAxis = firstLocked === secondLocked && pass === 0 ? secondaryAxis : axis;
+        const pairKey = overlapKey(firstId, secondId);
+        const effectiveSpacing = siblingPairs.has(pairKey) ? Math.max(spacing, input.minSiblingGap ?? 0) : spacing;
+        const moved = movePastOverlap(
+          moving,
+          fixed,
+          repairAxis,
+          effectiveSpacing
+        );
+        boxes.set(movingId, moved);
       }
-      const movingId = firstLocked ? secondId : firstId;
-      const moving = firstLocked ? second : first;
-      const fixed = firstLocked ? first : second;
-      const moved = movePastOverlap(moving, fixed, axis, spacing);
-      boxes.set(movingId, moved);
     }
   }
+  reportOverlaps(boxes, diagnostics, ignoredPairs);
+}
+function reportOverlaps(boxes, diagnostics, ignoredPairs = /* @__PURE__ */ new Set()) {
+  const ids = [...boxes.keys()].sort();
+  const reported = new Set(
+    diagnostics.filter(
+      (diagnostic) => diagnostic.code === "constraints.overlap.unresolved"
+    ).map((diagnostic) => {
+      const firstId = diagnostic.detail?.firstId;
+      const secondId = diagnostic.detail?.secondId;
+      return typeof firstId === "string" && typeof secondId === "string" ? overlapKey(firstId, secondId) : void 0;
+    }).filter((key) => key !== void 0)
+  );
   for (const firstId of ids) {
     for (const secondId of ids) {
       if (firstId >= secondId) {
         continue;
       }
+      const key = overlapKey(firstId, secondId);
+      if (reported.has(key) || ignoredPairs.has(key)) {
+        continue;
+      }
       const first = boxes.get(firstId);
       const second = boxes.get(secondId);
       if (first !== void 0 && second !== void 0 && intersectsAabb(first, second)) {
@@ -358,9 +411,136 @@ function repairOverlaps(input, boxes, locks, diagnostics) {
           path: ["boxes"],
           detail: { firstId, secondId }
         });
+        reported.add(key);
+      }
+    }
+  }
+}
+function reportIntraContainerOverflow(input, boxes, diagnostics) {
+  if (input.minSiblingGap === void 0) {
+    return;
+  }
+  const minGap = input.minSiblingGap;
+  const axis = input.direction === "LR" || input.direction === "RL" ? "x" : "y";
+  for (const constraint of input.constraints) {
+    if (constraint.kind !== "containment") {
+      continue;
+    }
+    const container = boxes.get(constraint.containerId);
+    if (container === void 0) {
+      continue;
+    }
+    const children = [];
+    for (const childId of constraint.childIds) {
+      const child = boxes.get(childId);
+      if (child !== void 0) {
+        children.push(child);
+      }
+    }
+    if (children.length < 2) {
+      continue;
+    }
+    const sorted = [...children].sort((a, b) => a[axis] - b[axis]);
+    const mainDim = axis === "x" ? "width" : "height";
+    let overlapPairs = 0;
+    for (let i = 0; i < sorted.length; i += 1) {
+      const first = sorted[i];
+      if (first === void 0) {
+        continue;
+      }
+      for (let j = i + 1; j < sorted.length; j += 1) {
+        const second = sorted[j];
+        if (second === void 0) {
+          continue;
+        }
+        if (second[axis] >= first[axis] + first[mainDim]) {
+          break;
+        }
+        if (intersectsAabb(first, second)) {
+          overlapPairs += 1;
+        }
+      }
+    }
+    if (overlapPairs > 0) {
+      diagnostics.push({
+        severity: "warning",
+        code: "intra_container_overflow",
+        message: `${overlapPairs} sibling pair(s) overlap inside ${constraint.containerId}.`,
+        path: ["constraints", constraint.id ?? constraint.containerId],
+        detail: {
+          containerId: constraint.containerId,
+          overlapPairs,
+          minGap
+        }
+      });
+    }
+    const pad = constraint.padding ?? { top: 0, right: 0, bottom: 0, left: 0 };
+    const contentMain = mainDim === "width" ? Math.max(0, container.width - pad.left - pad.right) : Math.max(0, container.height - pad.top - pad.bottom);
+    let childStart = Infinity;
+    let childEnd = -Infinity;
+    for (const child of sorted) {
+      const start = child[axis];
+      const end = start + child[mainDim];
+      if (start < childStart) childStart = start;
+      if (end > childEnd) childEnd = end;
+    }
+    if (sorted.length === 0) {
+      childStart = 0;
+      childEnd = 0;
+    }
+    const actualExtent = childEnd - childStart;
+    if (actualExtent > contentMain) {
+      diagnostics.push({
+        severity: "error",
+        code: "intra_container_overflow_total",
+        message: `Container ${constraint.containerId} cannot fit ${sorted.length} siblings along ${axis} (extent ${actualExtent}, available ${contentMain}).`,
+        path: ["constraints", constraint.id ?? constraint.containerId],
+        detail: {
+          containerId: constraint.containerId,
+          axis,
+          needed: actualExtent,
+          available: contentMain,
+          siblingCount: sorted.length,
+          minGap
+        }
+      });
+    }
+  }
+}
+function overlapKey(firstId, secondId) {
+  return firstId < secondId ? `${firstId}\0${secondId}` : `${secondId}\0${firstId}`;
+}
+function containmentOverlapKeys(constraints) {
+  const keys = /* @__PURE__ */ new Set();
+  for (const constraint of constraints) {
+    if (constraint.kind !== "containment") {
+      continue;
+    }
+    for (const childId of constraint.childIds) {
+      keys.add(overlapKey(constraint.containerId, childId));
+    }
+  }
+  return keys;
+}
+function siblingOverlapKeys(constraints) {
+  const keys = /* @__PURE__ */ new Set();
+  for (const constraint of constraints) {
+    if (constraint.kind !== "containment") {
+      continue;
+    }
+    const { childIds } = constraint;
+    for (let i = 0; i < childIds.length; i += 1) {
+      for (let j = i + 1; j < childIds.length; j += 1) {
+        const a = childIds[i];
+        const b = childIds[j];
+        if (a === void 0 || b === void 0) {
+          continue;
+        }
+        keys.add(overlapKey(a, b));
       }
     }
   }
+  return keys;
 }
 function setUnlockedBox(id, next, boxes, locks, diagnostics, constraint) {
   const current = boxes.get(id);
@@ -478,10 +658,125 @@ function contentBox(container, padding) {
   return {
     x: container.x + margin.left,
     y: container.y + margin.top,
-    width: container.width - margin.left - margin.right,
-    height: container.height - margin.top - margin.bottom
+    width: Math.max(0, container.width - margin.left - margin.right),
+    height: Math.max(0, container.height - margin.top - margin.bottom)
   };
 }
+function applyDistributeContained(input, boxes, locks, diagnostics) {
+  if (!input.distributeContainedChildren) {
+    return;
+  }
+  const axis = input.direction === "LR" || input.direction === "RL" ? "x" : "y";
+  const crossAxis = axis === "x" ? "y" : "x";
+  const mainSize = axis === "x" ? "width" : "height";
+  const crossSize = axis === "x" ? "height" : "width";
+  const minGap = input.minSiblingGap ?? 8;
+  for (const constraint of input.constraints) {
+    if (constraint.kind !== "containment") {
+      continue;
+    }
+    const container = boxes.get(constraint.containerId);
+    if (container === void 0) {
+      continue;
+    }
+    const content = contentBox(container, constraint.padding);
+    const unlocked = [];
+    const reserved = [];
+    for (const childId of constraint.childIds) {
+      const box = boxes.get(childId);
+      if (box === void 0) {
+        continue;
+      }
+      if (locks.has(childId)) {
+        diagnostics.push({
+          severity: "warning",
+          code: "constraints.locked-target-not-moved",
+          message: `Locked child ${childId} skipped during containment distribution.`,
+          path: ["constraints", constraint.id ?? constraint.containerId],
+          detail: { nodeId: childId }
+        });
+        reserved.push(intervalForBox(box, axis, mainSize));
+        continue;
+      }
+      unlocked.push({ id: childId, box });
+    }
+    if (unlocked.length < 2) {
+      continue;
+    }
+    const oversized = unlocked.filter(
+      (child) => child.box[mainSize] > content[mainSize] || child.box[crossSize] > content[crossSize]
+    );
+    if (oversized.length > 0) {
+      diagnostics.push({
+        severity: "warning",
+        code: "constraints.containment.impossible",
+        message: `Skipped ${oversized.length} oversized child(ren) during distribution in ${constraint.containerId}.`,
+        path: ["constraints", constraint.id ?? constraint.containerId],
+        detail: {
+          containerId: constraint.containerId,
+          oversized: oversized.map((c) => c.id)
+        }
+      });
+    }
+    for (const child of oversized) {
+      reserved.push(intervalForBox(child.box, axis, mainSize));
+    }
+    reserved.sort((a, b) => a.start - b.start || a.end - b.end);
+    const distributable = unlocked.filter(
+      (child) => child.box[mainSize] <= content[mainSize] && child.box[crossSize] <= content[crossSize]
+    );
+    if (distributable.length < 2) {
+      continue;
+    }
+    let pos = content[axis];
+    for (const child of distributable) {
+      pos = advancePastReserved(pos, child.box[mainSize], reserved, minGap);
+      const crossPos = content[crossAxis] + Math.max(0, (content[crossSize] - child.box[crossSize]) / 2);
+      const next = { ...child.box };
+      next[axis] = pos;
+      next[crossAxis] = crossPos;
+      const clamped = moveInside(next, content);
+      if (clamped[axis] !== next[axis]) {
+        diagnostics.push({
+          severity: "warning",
+          code: "intra_container_distributed_clamped",
+          message: `Distribution gap clamped for ${child.id} in ${constraint.containerId}.`,
+          path: ["constraints", constraint.id ?? constraint.containerId],
+          detail: { nodeId: child.id, containerId: constraint.containerId }
+        });
+      }
+      boxes.set(child.id, clamped);
+      pos = clamped[axis] + clamped[mainSize] + minGap;
+    }
+    diagnostics.push({
+      severity: "info",
+      code: "intra_container_distributed",
+      message: `Distributed ${distributable.length} children in ${constraint.containerId} along ${axis}.`,
+      path: ["constraints", constraint.id ?? constraint.containerId],
+      detail: {
+        containerId: constraint.containerId,
+        count: distributable.length,
+        axis
+      }
+    });
+  }
+}
+function intervalForBox(box, axis, mainSize) {
+  return { start: box[axis], end: box[axis] + box[mainSize] };
+}
+function advancePastReserved(pos, size, reserved, minGap) {
+  let next = pos;
+  for (const interval of reserved) {
+    if (next + size + minGap <= interval.start) {
+      break;
+    }
+    if (next >= interval.end + minGap) {
+      continue;
+    }
+    next = interval.end + minGap;
+  }
+  return next;
+}
 function moveInside(child, container) {
   return {
     ...child,
@@ -1187,7 +1482,14 @@ var DEFAULT_GROUP_PADDING = {
   left: 16
 };
 var DEFAULT_LABEL_MAX_WIDTH = 160;
-var DEFAULT_FONT = { fontFamily: "Arial", fontSize: 14, lineHeight: 18 };
+var DEFAULT_FONT = {
+  fontFamily: "Arial",
+  fontSize: 14,
+  lineHeight: 18
+};
+var DEFAULT_MATRIX_CELL_SIZE = { width: 120, height: 36 };
+var DEFAULT_TABLE_CELL_SIZE = { width: 128, height: 34 };
+var DEFAULT_PANEL_ITEM_HEIGHT = 28;
 function normalizeDiagramDsl(dslValue, options = {}) {
   const dsl = dslValue;
   const diagnostics = validateReferences(dsl);
@@ -1200,6 +1502,10 @@ function normalizeDiagramDsl(dslValue, options = {}) {
   const measurer = options.textMeasurer ?? createDefaultTextMeasurer();
   const routeKind = dsl.routing?.kind ?? "orthogonal";
   const portShifting = normalizePortShifting(dsl.routing?.portShifting);
+  const primaryReadingDirection = dsl.layout?.primaryReadingDirection;
+  const matrices = normalizeMatrices(dsl);
+  const tables = normalizeTables(dsl);
+  const evidencePanels = normalizeEvidencePanels(dsl);
   const diagram = {
     id: options.id ?? dsl.id ?? "diagram",
     ...dsl.title === void 0 ? {} : { title: dsl.title },
@@ -1208,11 +1514,15 @@ function normalizeDiagramDsl(dslValue, options = {}) {
     edges: normalizeEdges(dsl),
     groups: normalizeGroups(dsl, measurer),
     swimlanes: normalizeSwimlanes(dsl),
+    ...matrices === void 0 ? {} : { matrices },
+    ...tables === void 0 ? {} : { tables },
+    ...evidencePanels === void 0 ? {} : { evidencePanels },
     constraints: normalizeConstraints(dsl),
     diagnostics: [],
     ...dsl.frame === void 0 ? {} : { frame: normalizeFrame(dsl.frame) },
     metadata: {
       routeKind,
+      ...primaryReadingDirection === void 0 ? {} : { primaryReadingDirection },
       ...portShifting === void 0 ? {} : { portShifting }
     }
   };
@@ -1352,7 +1662,9 @@ function endpoint(value, nodeIdOverride) {
 function style(value) {
   return {
     ...value.fill === void 0 ? {} : { fill: value.fill },
-    ...value.stroke === void 0 ? {} : { stroke: value.stroke }
+    ...value.stroke === void 0 ? {} : { stroke: value.stroke },
+    ...value.fontFamily === void 0 ? {} : { fontFamily: value.fontFamily },
+    ...value.fontSize === void 0 ? {} : { fontSize: value.fontSize }
   };
 }
 function compartments(value) {
@@ -1369,6 +1681,10 @@ function normalizeFrame(frame) {
     ...frame.context === void 0 ? {} : { context: frame.context },
     ...frame.name === void 0 ? {} : { name: frame.name },
     titleTab: frame.titleTab,
+    ...frame.headerHeight === void 0 ? {} : { headerHeight: frame.headerHeight },
+    ...frame.padding === void 0 ? {} : { padding: frame.padding },
+    ...frame.labelPosition === void 0 ? {} : { labelPosition: frame.labelPosition },
+    ...frame.direction === void 0 ? {} : { direction: frame.direction },
     ...frame.style === void 0 ? {} : { style: style(frame.style) }
   };
 }
@@ -1383,14 +1699,17 @@ function formatCompartmentEntry(value) {
   return `${entry[0]}: ${entry[1]}`;
 }
 function normalizeSwimlanes(dsl) {
-  return Object.keys(dsl.swimlanes ?? {}).sort().map((id) => {
+  return Object.keys(dsl.swimlanes ?? {}).map((id) => {
     const swimlane = dsl.swimlanes?.[id];
     const label = toLabel(swimlane?.label);
     return {
       id,
       ...label === void 0 ? {} : { label },
       orientation: swimlane?.orientation ?? "vertical",
-      lanes: Object.keys(swimlane?.lanes ?? {}).sort().map((laneId) => {
+      layout: swimlane?.layout ?? "overlay",
+      ...swimlane?.headerHeight === void 0 ? {} : { headerHeight: swimlane.headerHeight },
+      ...swimlane?.padding === void 0 ? {} : { padding: swimlane.padding },
+      lanes: Object.keys(swimlane?.lanes ?? {}).map((laneId) => {
         const lane = swimlane?.lanes[laneId];
         const laneLabel = toLabel(lane?.label);
         return {
@@ -1402,6 +1721,102 @@ function normalizeSwimlanes(dsl) {
     };
   });
 }
+function normalizeMatrices(dsl) {
+  if (dsl.matrices === void 0) {
+    return void 0;
+  }
+  return dsl.matrices.map((matrix) => ({
+    id: matrix.id,
+    rows: [...matrix.rows],
+    cols: [...matrix.cols],
+    cells: matrix.cells.map((row) => row.map(cell)),
+    ...matrix.position === void 0 ? {} : { position: point(matrix.position) },
+    size: matrix.size ?? {
+      width: defaultMatrixRowHeaderWidth(matrix) + Math.max(1, matrix.cols.length) * DEFAULT_MATRIX_CELL_SIZE.width,
+      height: Math.max(1, matrix.rows.length + 1) * DEFAULT_MATRIX_CELL_SIZE.height
+    },
+    ...matrix.style === void 0 ? {} : { style: style(matrix.style) }
+  }));
+}
+function defaultMatrixRowHeaderWidth(matrix) {
+  return matrix.rows.length === 0 ? 0 : Math.min(96, DEFAULT_MATRIX_CELL_SIZE.width);
+}
+function normalizeTables(dsl) {
+  if (dsl.tables === void 0) {
+    return void 0;
+  }
+  return dsl.tables.map((table) => ({
+    id: table.id,
+    columns: table.columns.map(tableColumn),
+    rows: table.rows.map(tableRow),
+    ...table.position === void 0 ? {} : { position: point(table.position) },
+    size: table.size ?? {
+      width: Math.max(1, table.columns.length) * DEFAULT_TABLE_CELL_SIZE.width,
+      height: Math.max(1, table.rows.length + 1) * DEFAULT_TABLE_CELL_SIZE.height
+    },
+    ...table.style === void 0 ? {} : { style: style(table.style) }
+  }));
+}
+function normalizeEvidencePanels(dsl) {
+  if (dsl.evidencePanels === void 0) {
+    return void 0;
+  }
+  return dsl.evidencePanels.map((panel) => ({
+    id: panel.id,
+    kind: panel.kind,
+    items: panel.items.map(panelItem),
+    ...panel.position === void 0 ? {} : { position: point(panel.position) },
+    size: panel.size ?? {
+      width: 320,
+      height: Math.max(1, panel.items.length) * DEFAULT_PANEL_ITEM_HEIGHT
+    },
+    ...panel.style === void 0 ? {} : { style: style(panel.style) }
+  }));
+}
+function cell(value) {
+  if (typeof value === "string") {
+    return { text: value };
+  }
+  return {
+    text: value.text,
+    ...value.style === void 0 && value.fill === void 0 && value.stroke === void 0 ? {} : {
+      style: style({
+        ...value.style,
+        ...value.fill === void 0 ? {} : { fill: value.fill },
+        ...value.stroke === void 0 ? {} : { stroke: value.stroke }
+      })
+    }
+  };
+}
+function tableColumn(value) {
+  return {
+    id: value.id,
+    label: toLabel(value.label) ?? { text: value.id }
+  };
+}
+function tableRow(value) {
+  return {
+    id: value.id,
+    cells: Object.fromEntries(
+      Object.keys(value.cells).map((columnId) => [
+        columnId,
+        cell(value.cells[columnId] ?? "")
+      ])
+    )
+  };
+}
+function panelItem(value) {
+  if (typeof value === "string") {
+    return { label: { text: value } };
+  }
+  const detail = toLabel(value.detail);
+  return {
+    ...value.id === void 0 ? {} : { id: value.id },
+    label: toLabel(value.label) ?? { text: "" },
+    ...detail === void 0 ? {} : { detail },
+    ...value.style === void 0 ? {} : { style: style(value.style) }
+  };
+}
 function normalizeGroups(dsl, measurer) {
   return Object.keys(dsl.groups ?? {}).sort().map((id) => {
     const group = dsl.groups?.[id];
@@ -1413,6 +1828,9 @@ function normalizeGroups(dsl, measurer) {
       nodeIds: [...group?.nodes ?? []],
       groupIds: [...group?.groups ?? []],
       padding: group?.padding ?? { ...DEFAULT_GROUP_PADDING },
+      ...group?.headerHeight === void 0 ? {} : { headerHeight: group.headerHeight },
+      ...group?.labelPosition === void 0 ? {} : { labelPosition: group.labelPosition },
+      ...group?.direction === void 0 ? {} : { direction: group.direction },
       ...labelLayout === void 0 ? {} : { labelLayout }
     };
   });
@@ -1657,6 +2075,10 @@ var routeKindSchema = zod.z.enum(["orthogonal", "straight"]);
 var outputFormatSchema = zod.z.enum(["svg", "excalidraw"]);
 var edgeStrokeStyleSchema = zod.z.enum(["solid", "dashed"]);
 var edgeArrowheadSchema = zod.z.enum(["triangle", "hollowTriangle"]);
+var primaryReadingDirectionSchema = zod.z.enum([
+  "top_to_bottom",
+  "top-to-bottom"
+]);
 var nodeShapeSchema = zod.z.enum([
   "rectangle",
   "rounded-rectangle",
@@ -1667,6 +2089,7 @@ var nodeShapeSchema = zod.z.enum([
   "cylinder"
 ]);
 var finiteNumberSchema = zod.z.number().finite();
+var nonNegativeNumberSchema = finiteNumberSchema.min(0);
 var pointSchema = zod.z.object({
   x: finiteNumberSchema,
   y: finiteNumberSchema
@@ -1677,6 +2100,12 @@ var insetsSchema = zod.z.object({
   bottom: finiteNumberSchema,
   left: finiteNumberSchema
 });
+var nonNegativeInsetsSchema = zod.z.object({
+  top: nonNegativeNumberSchema,
+  right: nonNegativeNumberSchema,
+  bottom: nonNegativeNumberSchema,
+  left: nonNegativeNumberSchema
+});
 var labelSchema = zod.z.union([
   zod.z.string(),
   zod.z.object({
@@ -1686,8 +2115,19 @@ var labelSchema = zod.z.union([
 ]);
 var styleSchema = zod.z.object({
   fill: zod.z.string().optional(),
-  stroke: zod.z.string().optional()
+  stroke: zod.z.string().optional(),
+  fontFamily: zod.z.string().optional(),
+  fontSize: finiteNumberSchema.optional()
 });
+var blockCellSchema = zod.z.union([
+  zod.z.string(),
+  zod.z.object({
+    text: zod.z.string(),
+    fill: zod.z.string().optional(),
+    stroke: zod.z.string().optional(),
+    style: styleSchema.optional()
+  })
+]);
 var portSideSchema = zod.z.enum(["top", "right", "bottom", "left"]);
 var portKindSchema = zod.z.enum(["proxy", "flow"]);
 var portSchema = zod.z.object({
@@ -1748,11 +2188,17 @@ var groupSchema = zod.z.object({
   label: labelSchema.optional(),
   nodes: zod.z.array(zod.z.string()).optional(),
   groups: zod.z.array(zod.z.string()).optional(),
-  padding: insetsSchema.optional()
+  padding: insetsSchema.optional(),
+  headerHeight: nonNegativeNumberSchema.optional(),
+  labelPosition: zod.z.enum(["top", "inside", "outside"]).optional(),
+  direction: zod.z.enum(["horizontal", "vertical"]).optional()
 });
 var swimlaneSchema = zod.z.object({
   label: labelSchema.optional(),
   orientation: zod.z.enum(["vertical", "horizontal"]).optional(),
+  layout: zod.z.enum(["overlay", "contract"]).optional(),
+  headerHeight: nonNegativeNumberSchema.optional(),
+  padding: nonNegativeNumberSchema.optional(),
   lanes: zod.z.record(
     zod.z.string(),
     zod.z.object({
@@ -1761,6 +2207,122 @@ var swimlaneSchema = zod.z.object({
     })
   )
 });
+var matrixSchema = zod.z.object({
+  id: zod.z.string(),
+  rows: zod.z.array(zod.z.string()),
+  cols: zod.z.array(zod.z.string()),
+  cells: zod.z.array(zod.z.array(blockCellSchema)),
+  position: pointSchema.optional(),
+  size: zod.z.object({
+    width: nonNegativeNumberSchema,
+    height: nonNegativeNumberSchema
+  }).optional(),
+  style: styleSchema.optional()
+}).superRefine((matrix, context) => {
+  checkDuplicateValues("matrix row", matrix.rows, context, (index) => [
+    "rows",
+    index
+  ]);
+  checkDuplicateValues("matrix column", matrix.cols, context, (index) => [
+    "cols",
+    index
+  ]);
+  if (matrix.cells.length !== matrix.rows.length) {
+    context.addIssue({
+      code: "custom",
+      message: `Matrix cells must contain exactly ${matrix.rows.length} row(s).`,
+      path: ["cells"]
+    });
+  }
+  matrix.cells.forEach((row, rowIndex) => {
+    if (row.length !== matrix.cols.length) {
+      context.addIssue({
+        code: "custom",
+        message: `Matrix cell row must contain exactly ${matrix.cols.length} column(s).`,
+        path: ["cells", rowIndex]
+      });
+    }
+  });
+});
+var tableColumnSchema = zod.z.object({
+  id: zod.z.string(),
+  label: labelSchema
+});
+var tableRowSchema = zod.z.object({
+  id: zod.z.string(),
+  cells: zod.z.record(zod.z.string(), blockCellSchema)
+});
+var tableSchema = zod.z.object({
+  id: zod.z.string(),
+  columns: zod.z.array(tableColumnSchema),
+  rows: zod.z.array(tableRowSchema),
+  position: pointSchema.optional(),
+  size: zod.z.object({
+    width: nonNegativeNumberSchema,
+    height: nonNegativeNumberSchema
+  }).optional(),
+  style: styleSchema.optional()
+}).superRefine((table, context) => {
+  checkDuplicateIds("column", table.columns, context, (index) => [
+    "columns",
+    index,
+    "id"
+  ]);
+  checkDuplicateIds("row", table.rows, context, (index) => [
+    "rows",
+    index,
+    "id"
+  ]);
+  const columnIds = new Set(table.columns.map((column) => column.id));
+  table.rows.forEach((row, rowIndex) => {
+    for (const columnId of Object.keys(row.cells)) {
+      if (!columnIds.has(columnId)) {
+        context.addIssue({
+          code: "custom",
+          message: `Table row cell references undeclared column "${columnId}".`,
+          path: ["rows", rowIndex, "cells", columnId]
+        });
+      }
+    }
+  });
+});
+var panelItemSchema = zod.z.union([
+  zod.z.string(),
+  zod.z.object({
+    id: zod.z.string().optional(),
+    label: labelSchema,
+    detail: labelSchema.optional(),
+    style: styleSchema.optional()
+  })
+]);
+var evidencePanelSchema = zod.z.object({
+  id: zod.z.string(),
+  kind: zod.z.enum(["legend", "rule", "note", "verification"]),
+  items: zod.z.array(panelItemSchema),
+  position: pointSchema.optional(),
+  size: zod.z.object({
+    width: nonNegativeNumberSchema,
+    height: nonNegativeNumberSchema
+  }).optional(),
+  style: styleSchema.optional()
+}).superRefine((panel, context) => {
+  const firstIndexByItemId = /* @__PURE__ */ new Map();
+  panel.items.forEach((item, index) => {
+    if (typeof item === "string" || item.id === void 0) {
+      return;
+    }
+    const firstIndex = firstIndexByItemId.get(item.id);
+    if (firstIndex === void 0) {
+      firstIndexByItemId.set(item.id, index);
+      return;
+    }
+    context.addIssue({
+      code: "custom",
+      message: `Duplicate evidence panel item id "${item.id}".`,
+      path: ["items", index, "id"]
+    });
+  });
+});
 var exactPositionConstraintSchema = zod.z.object({
   kind: zod.z.literal("exact-position"),
   target: zod.z.string().optional(),
@@ -1818,7 +2380,8 @@ var diagramDslSchema = zod.z.object({
   title: zod.z.string().optional(),
   direction: directionSchema.optional(),
   layout: zod.z.object({
-    direction: directionSchema.optional()
+    direction: directionSchema.optional(),
+    primaryReadingDirection: primaryReadingDirectionSchema.optional()
   }).optional(),
   routing: zod.z.object({
     kind: routeKindSchema.optional(),
@@ -1831,17 +2394,33 @@ var diagramDslSchema = zod.z.object({
   edges: zod.z.array(edgeSchema).optional(),
   groups: zod.z.record(zod.z.string(), groupSchema).optional(),
   swimlanes: zod.z.record(zod.z.string(), swimlaneSchema).optional(),
+  matrices: zod.z.array(matrixSchema).optional(),
+  tables: zod.z.array(tableSchema).optional(),
+  evidencePanels: zod.z.array(evidencePanelSchema).optional(),
   constraints: zod.z.array(constraintSchema).optional(),
   frame: zod.z.object({
     kind: zod.z.string(),
     context: zod.z.string().optional(),
     name: zod.z.string().optional(),
     titleTab: zod.z.string(),
+    headerHeight: nonNegativeNumberSchema.optional(),
+    padding: zod.z.union([nonNegativeNumberSchema, nonNegativeInsetsSchema]).optional(),
+    labelPosition: zod.z.enum(["top", "inside", "outside"]).optional(),
+    direction: zod.z.enum(["horizontal", "vertical"]).optional(),
     style: styleSchema.optional()
   }).optional(),
   output: zod.z.object({
     format: outputFormatSchema.optional()
   }).optional()
+}).superRefine((diagram, context) => {
+  checkDuplicateEvidenceBlockIds("matrices", diagram.matrices, context);
+  checkDuplicateEvidenceBlockIds("tables", diagram.tables, context);
+  checkDuplicateEvidenceBlockIds(
+    "evidencePanels",
+    diagram.evidencePanels,
+    context
+  );
+  checkDuplicateEvidenceBlockIdsAcrossTypes(diagram, context);
 });
 function validateDiagramDsl(value) {
   const result = diagramDslSchema.safeParse(value);
@@ -1861,25 +2440,81 @@ function toDiagnosticPath(path) {
     (segment) => typeof segment === "string" || typeof segment === "number" ? [segment] : []
   );
 }
-
-// src/dsl/parse.ts
-var DEFAULT_DSL_MAX_BYTES = 1e6;
-function parseDiagramDsl(source, options = {}) {
-  const maxBytes = options.maxBytes ?? DEFAULT_DSL_MAX_BYTES;
-  if (buffer.Buffer.byteLength(source, "utf8") > maxBytes) {
-    return {
-      diagnostics: [
-        createParseDiagnostic(
-          "parse.input.too-large",
-          `Input exceeds the ${maxBytes} byte limit.`,
-          "Split the diagram into smaller inputs or raise maxBytes for trusted sources."
-        )
-      ]
-    };
-  }
-  const parsed = parseSource(source, options);
-  if (parsed.value === void 0 || hasErrorDiagnostics(parsed.diagnostics)) {
-    return { diagnostics: sortDslDiagnostics(parsed.diagnostics) };
+function checkDuplicateEvidenceBlockIds(collection, blocks, context) {
+  checkDuplicateIds(
+    `evidence block id in ${collection}`,
+    blocks ?? [],
+    context,
+    (index) => [collection, index, "id"]
+  );
+}
+function checkDuplicateIds(label, items, context, pathForIndex) {
+  const firstIndexById = /* @__PURE__ */ new Map();
+  items.forEach((item, index) => {
+    const firstIndex = firstIndexById.get(item.id);
+    if (firstIndex === void 0) {
+      firstIndexById.set(item.id, index);
+      return;
+    }
+    context.addIssue({
+      code: "custom",
+      message: `Duplicate ${label} "${item.id}".`,
+      path: pathForIndex(index)
+    });
+  });
+}
+function checkDuplicateValues(label, values, context, pathForIndex) {
+  const firstIndexByValue = /* @__PURE__ */ new Map();
+  values.forEach((value, index) => {
+    const firstIndex = firstIndexByValue.get(value);
+    if (firstIndex === void 0) {
+      firstIndexByValue.set(value, index);
+      return;
+    }
+    context.addIssue({
+      code: "custom",
+      message: `Duplicate ${label} "${value}".`,
+      path: pathForIndex(index)
+    });
+  });
+}
+function checkDuplicateEvidenceBlockIdsAcrossTypes(diagram, context) {
+  const firstById = /* @__PURE__ */ new Map();
+  for (const collection of ["matrices", "tables", "evidencePanels"]) {
+    const blocks = diagram[collection] ?? [];
+    blocks.forEach((block, index) => {
+      const first = firstById.get(block.id);
+      if (first === void 0) {
+        firstById.set(block.id, { collection, index });
+        return;
+      }
+      context.addIssue({
+        code: "custom",
+        message: `Duplicate evidence block id "${block.id}" across ${first.collection} and ${collection}.`,
+        path: [collection, index, "id"]
+      });
+    });
+  }
+}
+
+// src/dsl/parse.ts
+var DEFAULT_DSL_MAX_BYTES = 1e6;
+function parseDiagramDsl(source, options = {}) {
+  const maxBytes = options.maxBytes ?? DEFAULT_DSL_MAX_BYTES;
+  if (buffer.Buffer.byteLength(source, "utf8") > maxBytes) {
+    return {
+      diagnostics: [
+        createParseDiagnostic(
+          "parse.input.too-large",
+          `Input exceeds the ${maxBytes} byte limit.`,
+          "Split the diagram into smaller inputs or raise maxBytes for trusted sources."
+        )
+      ]
+    };
+  }
+  const parsed = parseSource(source, options);
+  if (parsed.value === void 0 || hasErrorDiagnostics(parsed.diagnostics)) {
+    return { diagnostics: sortDslDiagnostics(parsed.diagnostics) };
   }
   const expanded = expandEdgeShorthand(parsed.value);
   if (hasErrorDiagnostics(expanded.diagnostics)) {
@@ -2062,6 +2697,15 @@ function exportExcalidraw(diagram, options = {}) {
       elements.push(text);
     }
   }
+  for (const matrix of diagram.matrices ?? []) {
+    elements.push(...renderMatrixBlock(matrix));
+  }
+  for (const table of diagram.tables ?? []) {
+    elements.push(...renderTableBlock(table));
+  }
+  for (const panel of diagram.evidencePanels ?? []) {
+    elements.push(...renderEvidencePanel(panel));
+  }
   for (const edge of diagram.edges) {
     elements.push(renderArrow(edge));
   }
@@ -2094,6 +2738,83 @@ function renderNode(node, groupIds) {
     groupIds
   };
 }
+function renderMatrixBlock(matrix) {
+  const containerId = `matrix:${matrix.id}`;
+  const groupIds = [containerId];
+  const label = blockText([
+    matrix.id,
+    `row | ${matrix.cols.join(" | ")}`,
+    ...matrix.rows.map((rowId, rowIndex) => {
+      const row = matrix.cells[rowIndex] ?? [];
+      return `${rowId}: ${matrix.cols.map((_, columnIndex) => row[columnIndex]?.text ?? "").join(" | ")}`;
+    })
+  ]);
+  return [
+    {
+      ...baseElement(containerId, "rectangle", matrix.box),
+      backgroundColor: matrix.style?.fill ?? "#f8fafc",
+      strokeColor: matrix.style?.stroke ?? "#374151",
+      groupIds
+    },
+    renderTextBlock(
+      `matrix-text:${matrix.id}`,
+      label,
+      matrix.box,
+      containerId,
+      groupIds
+    )
+  ];
+}
+function renderTableBlock(table) {
+  const containerId = `table:${table.id}`;
+  const groupIds = [containerId];
+  const label = blockText([
+    table.columns.map((column) => column.label.text).join(" | "),
+    ...table.rows.map(
+      (row) => table.columns.map((column) => row.cells[column.id]?.text ?? "").join(" | ")
+    )
+  ]);
+  return [
+    {
+      ...baseElement(containerId, "rectangle", table.box),
+      backgroundColor: table.style?.fill ?? "#f8fafc",
+      strokeColor: table.style?.stroke ?? "#374151",
+      groupIds
+    },
+    renderTextBlock(
+      `table-text:${table.id}`,
+      label,
+      table.box,
+      containerId,
+      groupIds
+    )
+  ];
+}
+function renderEvidencePanel(panel) {
+  const containerId = `evidence-panel:${panel.id}`;
+  const groupIds = [containerId];
+  const label = blockText([
+    `${panel.kind}: ${panel.id}`,
+    ...panel.items.map(
+      (item) => item.detail?.text === void 0 ? item.label.text : `${item.label.text}: ${item.detail.text}`
+    )
+  ]);
+  return [
+    {
+      ...baseElement(containerId, "rectangle", panel.box),
+      backgroundColor: panel.style?.fill ?? panelKindFill(panel.kind),
+      strokeColor: panel.style?.stroke ?? "#374151",
+      groupIds
+    },
+    renderTextBlock(
+      `evidence-panel-text:${panel.id}`,
+      label,
+      panel.box,
+      containerId,
+      groupIds
+    )
+  ];
+}
 function renderArrow(edge) {
   const first = edge.points[0];
   if (first === void 0) {
@@ -2153,6 +2874,34 @@ function renderText(id, label, box, containerId, groupIds) {
     versionNonce: seedFor(`${id}:nonce`)
   };
 }
+function renderTextBlock(id, text, box, containerId, groupIds) {
+  const fontSize = 12;
+  return {
+    ...baseElement(id, "text", {
+      x: box.x + 8,
+      y: box.y + 8,
+      width: Math.max(0, box.width - 16),
+      height: Math.max(fontSize, box.height - 16)
+    }),
+    backgroundColor: "transparent",
+    strokeColor: "#111827",
+    groupIds,
+    text,
+    fontSize,
+    fontFamily: 1,
+    textAlign: "left",
+    verticalAlign: "top",
+    baseline: fontSize,
+    containerId,
+    originalText: text,
+    lineHeight: 1.25,
+    boundElements: null,
+    link: null,
+    locked: false,
+    seed: seedFor(id),
+    versionNonce: seedFor(`${id}:nonce`)
+  };
+}
 function baseElement(id, type, box) {
   return {
     id,
@@ -2230,6 +2979,21 @@ function groupGroupIds(groupId) {
 function groupElementIdFor(groupId) {
   return `group:${groupId}`;
 }
+function blockText(lines) {
+  return lines.filter((line) => line.length > 0).join("\n");
+}
+function panelKindFill(kind) {
+  switch (kind) {
+    case "legend":
+      return "#ecfdf5";
+    case "rule":
+      return "#eff6ff";
+    case "note":
+      return "#fffbeb";
+    case "verification":
+      return "#fef2f2";
+  }
+}
 function pointsBox(points) {
   const xs = points.map((point2) => point2.x);
   const ys = points.map((point2) => point2.y);
@@ -2267,42 +3031,253 @@ var GROUP_FILL = "#f9fafb";
 var STROKE = "#374151";
 var EDGE_STROKE = "#111827";
 var FONT_FAMILY = "Arial, sans-serif";
+var EVIDENCE_FILL = "#f8fafc";
+var EVIDENCE_HEADER_FILL = "#e5e7eb";
+var EVIDENCE_TEXT_FONT_SIZE = 10;
+var EVIDENCE_TEXT_LINE_HEIGHT = 12;
+var EVIDENCE_PANEL_KIND_FILL = {
+  legend: "#ecfdf5",
+  rule: "#eff6ff",
+  note: "#fffbeb",
+  verification: "#fef2f2"
+};
 function exportSvg(diagram, options = {}) {
   const title = options.title ?? diagram.title;
-  const lines = [
+  const annotations = diagram.textAnnotations ?? [];
+  return `${[
     `<svg xmlns="http://www.w3.org/2000/svg" role="img" viewBox="${formatBoxViewBox(diagram.bounds)}">`,
     ...title === void 0 ? [] : [`  <title>${escapeXml(title)}</title>`],
     `  <rect class="background" x="${formatNumber(diagram.bounds.x)}" y="${formatNumber(diagram.bounds.y)}" width="${formatNumber(diagram.bounds.width)}" height="${formatNumber(diagram.bounds.height)}" fill="#ffffff"/>`,
-    ...diagram.frame === void 0 ? [] : [indent(renderFrame(diagram.frame))],
+    ...diagram.frame === void 0 ? [] : [indent(renderFrame(diagram.frame, annotations))],
     ...(diagram.swimlanes ?? []).flatMap(
-      (swimlane) => renderSwimlane(swimlane)
+      (swimlane) => renderSwimlane(swimlane, annotations)
     ),
     ...diagram.groups.map((group) => indent(renderGroup2(group))),
+    ...(diagram.matrices ?? []).flatMap(
+      (matrix) => indentLines(renderMatrixBlock2(matrix))
+    ),
+    ...(diagram.tables ?? []).flatMap(
+      (table) => indentLines(renderTableBlock2(table))
+    ),
+    ...(diagram.evidencePanels ?? []).flatMap(
+      (panel) => indentLines(renderEvidencePanel2(panel))
+    ),
     ...diagram.edges.flatMap((edge) => {
       const path = renderEdgePath(edge);
-      if (path === void 0) {
-        return [];
-      }
-      return [indent(path), indent(renderArrowhead(edge))];
+      return path === void 0 ? [] : [indent(path), indent(renderArrowhead(edge))];
     }),
     ...diagram.nodes.map((node) => indent(renderNode2(node))),
-    ...diagram.nodes.flatMap((node) => renderCompartments(node)),
-    ...diagram.nodes.flatMap((node) => renderPorts(node)),
+    ...diagram.nodes.flatMap((node) => renderCompartments(node, annotations)),
+    ...diagram.nodes.flatMap((node) => renderPorts(node, annotations)),
     ...diagram.groups.flatMap(
-      (group) => renderLabel(group.label, group.box, group)
+      (group) => renderLabel(group.label, group.box, group, annotations, "group-label")
     ),
     ...diagram.nodes.flatMap(
-      (node) => node.compartments === void 0 ? renderLabel(node.label, node.box, node) : []
+      (node) => node.compartments === void 0 ? renderLabel(node.label, node.box, node, annotations, "node-label") : []
     ),
-    ...diagram.edges.flatMap((edge) => renderEdgeLabel(edge)),
+    ...diagram.edges.flatMap((edge) => renderEdgeLabel(edge, annotations)),
     "</svg>"
-  ];
-  return `${lines.join("\n")}
+  ].join("\n")}
 `;
 }
 function renderGroup2(group) {
   return `<rect class="group" data-id="${escapeAttribute(group.id)}" x="${formatNumber(group.box.x)}" y="${formatNumber(group.box.y)}" width="${formatNumber(group.box.width)}" height="${formatNumber(group.box.height)}" fill="${GROUP_FILL}" stroke="${STROKE}" stroke-dasharray="6 4"/>`;
 }
+function renderMatrixBlock2(matrix) {
+  const columnCount = Math.max(1, matrix.cols.length);
+  const rowCount = matrix.rows.length;
+  const rowHeaderWidth = rowCount > 0 ? Math.min(96, matrix.box.width * 0.28) : 0;
+  const dataWidth = Math.max(0, matrix.box.width - rowHeaderWidth);
+  const cellWidth = dataWidth / columnCount;
+  const rowHeight = matrix.box.height / Math.max(1, rowCount + 1);
+  const lines = [
+    `<g class="matrix-block" data-id="${escapeAttribute(matrix.id)}" data-row-count="${rowCount}" data-column-count="${matrix.cols.length}">`,
+    `  <rect class="matrix-frame" x="${formatNumber(matrix.box.x)}" y="${formatNumber(matrix.box.y)}" width="${formatNumber(matrix.box.width)}" height="${formatNumber(matrix.box.height)}" fill="${escapeAttribute(matrix.style?.fill ?? EVIDENCE_FILL)}" stroke="${escapeAttribute(matrix.style?.stroke ?? STROKE)}"/>`
+  ];
+  if (rowHeaderWidth > 0) {
+    lines.push(
+      `  <rect class="matrix-corner-header" x="${formatNumber(matrix.box.x)}" y="${formatNumber(matrix.box.y)}" width="${formatNumber(rowHeaderWidth)}" height="${formatNumber(rowHeight)}" fill="${EVIDENCE_HEADER_FILL}" stroke="${STROKE}"/>`
+    );
+  }
+  for (let columnIndex = 0; columnIndex < matrix.cols.length; columnIndex += 1) {
+    const column = matrix.cols[columnIndex];
+    if (column === void 0) {
+      continue;
+    }
+    const x = matrix.box.x + rowHeaderWidth + columnIndex * cellWidth;
+    lines.push(
+      `  <rect class="matrix-column-header" data-col="${escapeAttribute(column)}" x="${formatNumber(x)}" y="${formatNumber(matrix.box.y)}" width="${formatNumber(cellWidth)}" height="${formatNumber(rowHeight)}" fill="${EVIDENCE_HEADER_FILL}" stroke="${STROKE}"/>`,
+      renderEvidenceText(
+        "matrix-column-label",
+        matrix.columnLabelLayouts?.[columnIndex]?.lines ?? [column],
+        {
+          x,
+          y: matrix.box.y,
+          width: cellWidth,
+          height: rowHeight
+        }
+      )
+    );
+  }
+  for (let rowIndex = 0; rowIndex < matrix.rows.length; rowIndex += 1) {
+    const row = matrix.rows[rowIndex];
+    const cells = matrix.cells[rowIndex] ?? [];
+    if (row === void 0) {
+      continue;
+    }
+    if (rowHeaderWidth > 0) {
+      const rowHeaderBox = {
+        x: matrix.box.x,
+        y: matrix.box.y + (rowIndex + 1) * rowHeight,
+        width: rowHeaderWidth,
+        height: rowHeight
+      };
+      lines.push(
+        `  <rect class="matrix-row-header" data-row="${escapeAttribute(row)}" x="${formatNumber(rowHeaderBox.x)}" y="${formatNumber(rowHeaderBox.y)}" width="${formatNumber(rowHeaderBox.width)}" height="${formatNumber(rowHeaderBox.height)}" fill="${EVIDENCE_HEADER_FILL}" stroke="${STROKE}"/>`,
+        renderEvidenceText(
+          "matrix-row-label",
+          matrix.rowLabelLayouts?.[rowIndex]?.lines ?? [row],
+          rowHeaderBox
+        )
+      );
+    }
+    for (let columnIndex = 0; columnIndex < matrix.cols.length; columnIndex += 1) {
+      const column = matrix.cols[columnIndex];
+      if (column === void 0) {
+        continue;
+      }
+      const cell2 = cells[columnIndex] ?? { text: "" };
+      const box = {
+        x: matrix.box.x + rowHeaderWidth + columnIndex * cellWidth,
+        y: matrix.box.y + (rowIndex + 1) * rowHeight,
+        width: cellWidth,
+        height: rowHeight
+      };
+      lines.push(
+        `  <rect class="matrix-cell" data-row="${escapeAttribute(row)}" data-col="${escapeAttribute(column)}" x="${formatNumber(box.x)}" y="${formatNumber(box.y)}" width="${formatNumber(box.width)}" height="${formatNumber(box.height)}" fill="${escapeAttribute(cell2.style?.fill ?? "#ffffff")}" stroke="${escapeAttribute(cell2.style?.stroke ?? STROKE)}"/>`,
+        renderEvidenceText(
+          "matrix-cell-label",
+          matrix.cellLabelLayouts?.[rowIndex]?.[columnIndex]?.lines ?? [
+            cell2.text
+          ],
+          box
+        )
+      );
+    }
+  }
+  lines.push("</g>");
+  return lines;
+}
+function renderTableBlock2(table) {
+  const columnCount = Math.max(1, table.columns.length);
+  const rowHeight = table.box.height / Math.max(1, table.rows.length + 1);
+  const lines = [
+    `<g class="table-block" data-id="${escapeAttribute(table.id)}" data-row-count="${table.rows.length}" data-column-count="${table.columns.length}">`,
+    `  <rect class="table-frame" x="${formatNumber(table.box.x)}" y="${formatNumber(table.box.y)}" width="${formatNumber(table.box.width)}" height="${formatNumber(table.box.height)}" fill="${escapeAttribute(table.style?.fill ?? EVIDENCE_FILL)}" stroke="${escapeAttribute(table.style?.stroke ?? STROKE)}"/>`,
+    `  <g class="table-header" data-column-count="${table.columns.length}">`
+  ];
+  for (let columnIndex = 0; columnIndex < table.columns.length; columnIndex += 1) {
+    const column = table.columns[columnIndex];
+    if (column === void 0) {
+      continue;
+    }
+    const columnBox = tableCellBox(
+      table,
+      columnIndex,
+      0,
+      rowHeight,
+      columnCount
+    );
+    lines.push(
+      `    <rect class="table-header-cell" data-col="${escapeAttribute(column.id)}" x="${formatNumber(columnBox.x)}" y="${formatNumber(columnBox.y)}" width="${formatNumber(columnBox.width)}" height="${formatNumber(columnBox.height)}" fill="${EVIDENCE_HEADER_FILL}" stroke="${STROKE}"/>`,
+      `    ${renderEvidenceText("table-header-label", table.columnLabelLayouts?.[columnIndex]?.lines ?? [column.label.text], columnBox)}`
+    );
+  }
+  lines.push("  </g>");
+  for (let rowIndex = 0; rowIndex < table.rows.length; rowIndex += 1) {
+    const row = table.rows[rowIndex];
+    if (row === void 0) {
+      continue;
+    }
+    const rowBox = {
+      x: table.box.x,
+      y: table.box.y + (rowIndex + 1) * rowHeight,
+      width: table.box.width,
+      height: rowHeight
+    };
+    const rowClass = rowIndex % 2 === 0 ? "table-row-even" : "table-row-odd";
+    lines.push(
+      `  <g class="table-row ${rowClass}" data-row="${escapeAttribute(row.id)}">`,
+      `    <rect class="${rowClass}" data-row="${escapeAttribute(row.id)}" x="${formatNumber(rowBox.x)}" y="${formatNumber(rowBox.y)}" width="${formatNumber(rowBox.width)}" height="${formatNumber(rowBox.height)}" fill="${rowIndex % 2 === 0 ? "#ffffff" : "#f3f4f6"}" stroke="none"/>`
+    );
+    for (let columnIndex = 0; columnIndex < table.columns.length; columnIndex += 1) {
+      const column = table.columns[columnIndex];
+      if (column === void 0) {
+        continue;
+      }
+      const cell2 = row.cells[column.id] ?? { text: "" };
+      const cellBox = tableCellBox(
+        table,
+        columnIndex,
+        rowIndex + 1,
+        rowHeight,
+        columnCount
+      );
+      lines.push(
+        `    <rect class="table-cell" data-col="${escapeAttribute(column.id)}" x="${formatNumber(cellBox.x)}" y="${formatNumber(cellBox.y)}" width="${formatNumber(cellBox.width)}" height="${formatNumber(cellBox.height)}" fill="${escapeAttribute(cell2.style?.fill ?? "transparent")}" stroke="${escapeAttribute(cell2.style?.stroke ?? STROKE)}"/>`,
+        `    ${renderEvidenceText("table-cell-label", table.cellLabelLayouts?.[rowIndex]?.[columnIndex]?.lines ?? [cell2.text], cellBox)}`
+      );
+    }
+    lines.push("  </g>");
+  }
+  lines.push("</g>");
+  return lines;
+}
+function renderEvidencePanel2(panel) {
+  const titleWidth = Math.min(panel.box.width * 0.36, 140);
+  const itemBox = {
+    x: panel.box.x + titleWidth,
+    y: panel.box.y,
+    width: panel.box.width - titleWidth,
+    height: panel.box.height
+  };
+  const titleBox = {
+    x: panel.box.x,
+    y: panel.box.y,
+    width: titleWidth,
+    height: panel.box.height
+  };
+  const itemHeight = panel.box.height / Math.max(1, panel.items.length);
+  const lines = [
+    `<g class="evidence-panel evidence-panel--${panel.kind}" data-id="${escapeAttribute(panel.id)}" data-kind="${escapeAttribute(panel.kind)}" data-item-count="${panel.items.length}">`,
+    `  <rect class="evidence-panel-frame" x="${formatNumber(panel.box.x)}" y="${formatNumber(panel.box.y)}" width="${formatNumber(panel.box.width)}" height="${formatNumber(panel.box.height)}" fill="${escapeAttribute(panel.style?.fill ?? EVIDENCE_PANEL_KIND_FILL[panel.kind])}" stroke="${escapeAttribute(panel.style?.stroke ?? STROKE)}"/>`,
+    `  <g class="evidence-panel-title-cell">`,
+    `    <rect class="evidence-panel-title-bg" x="${formatNumber(titleBox.x)}" y="${formatNumber(titleBox.y)}" width="${formatNumber(titleBox.width)}" height="${formatNumber(titleBox.height)}" fill="${EVIDENCE_HEADER_FILL}" stroke="${STROKE}"/>`,
+    `    ${renderEvidenceText("evidence-panel-title", panel.titleLayout?.lines ?? [`${panel.kind}: ${panel.id}`], titleBox)}`,
+    "  </g>",
+    `  <g class="evidence-panel-items-cell">`,
+    `    <rect class="evidence-panel-items-bg" x="${formatNumber(itemBox.x)}" y="${formatNumber(itemBox.y)}" width="${formatNumber(itemBox.width)}" height="${formatNumber(itemBox.height)}" fill="transparent" stroke="${STROKE}"/>`
+  ];
+  for (let index = 0; index < panel.items.length; index += 1) {
+    const item = panel.items[index];
+    if (item === void 0) {
+      continue;
+    }
+    const text = panelItemText(item.label.text, item.detail?.text);
+    const box = {
+      x: itemBox.x,
+      y: itemBox.y + index * itemHeight,
+      width: itemBox.width,
+      height: itemHeight
+    };
+    lines.push(
+      `    <rect class="evidence-panel-item" data-item="${escapeAttribute(item.id ?? String(index))}" x="${formatNumber(box.x)}" y="${formatNumber(box.y)}" width="${formatNumber(box.width)}" height="${formatNumber(box.height)}" fill="${escapeAttribute(item.style?.fill ?? "transparent")}" stroke="${escapeAttribute(item.style?.stroke ?? "none")}"/>`,
+      `    ${renderEvidenceText("evidence-panel-item-label", panel.itemLayouts?.[index]?.lines ?? [text], box)}`
+    );
+  }
+  lines.push("  </g>", "</g>");
+  return lines;
+}
 function renderNode2(node) {
   const fill = node.style?.fill ?? NODE_FILL;
   const stroke = node.style?.stroke ?? STROKE;
@@ -2322,18 +3297,27 @@ function renderNode2(node) {
       return `<path ${common} d="${formatCylinderPath(node.box)}"/>`;
   }
 }
-function renderFrame(frame) {
+function renderFrame(frame, annotations) {
   const stroke = frame.style?.stroke ?? "#6b7280";
   const fill = frame.style?.fill ?? "transparent";
   return [
     `<g class="sysml-frame" data-kind="${escapeAttribute(frame.kind)}">`,
     `  <rect class="sysml-frame-border" x="${formatNumber(frame.box.x)}" y="${formatNumber(frame.box.y)}" width="${formatNumber(frame.box.width)}" height="${formatNumber(frame.box.height)}" fill="${escapeAttribute(fill)}" stroke="${escapeAttribute(stroke)}"/>`,
     `  <path class="sysml-title-tab" d="M ${formatNumber(frame.titleBox.x)} ${formatNumber(frame.titleBox.y + frame.titleBox.height)} L ${formatNumber(frame.titleBox.x)} ${formatNumber(frame.titleBox.y)} L ${formatNumber(frame.titleBox.x + frame.titleBox.width - 16)} ${formatNumber(frame.titleBox.y)} L ${formatNumber(frame.titleBox.x + frame.titleBox.width)} ${formatNumber(frame.titleBox.y + frame.titleBox.height)} Z" fill="#f3f4f6" stroke="${escapeAttribute(stroke)}"/>`,
-    `  <text class="sysml-title-tab-label" x="${formatNumber(frame.titleBox.x + 8)}" y="${formatNumber(frame.titleBox.y + frame.titleBox.height / 2)}" dominant-baseline="middle" font-family="${FONT_FAMILY}" font-size="12" fill="#111827">${escapeXml(frame.titleTab)}</text>`,
+    ...renderSolvedTextAnnotation(
+      findAnnotation(annotations, "frame-title", frame.kind),
+      `sysml-title-tab-label`,
+      {
+        indent: "  ",
+        mode: "center",
+        fallbackText: frame.titleTab}
+    ) ?? [
+      `  <text class="sysml-title-tab-label" x="${formatNumber(frame.titleBox.x + 8)}" y="${formatNumber(frame.titleBox.y + frame.titleBox.height / 2)}" dominant-baseline="middle" font-family="${FONT_FAMILY}" font-size="12" fill="#111827">${escapeXml(frame.titleTab)}</text>`
+    ],
     "</g>"
   ].join("\n");
 }
-function renderSwimlane(swimlane) {
+function renderSwimlane(swimlane, annotations) {
   if (swimlane.box === void 0) {
     return [];
   }
@@ -2348,24 +3332,60 @@ function renderSwimlane(swimlane) {
     lines.push(
       `    <rect class="swimlane-lane" data-lane="${escapeAttribute(`${swimlane.id}.${lane.id}`)}" x="${formatNumber(lane.box.x)}" y="${formatNumber(lane.box.y)}" width="${formatNumber(lane.box.width)}" height="${formatNumber(lane.box.height)}" fill="none" stroke="${STROKE}"/>`
     );
+    if (lane.headerBox !== void 0) {
+      lines.push(
+        `    <rect class="swimlane-header" data-lane-header="${escapeAttribute(`${swimlane.id}.${lane.id}`)}" x="${formatNumber(lane.headerBox.x)}" y="${formatNumber(lane.headerBox.y)}" width="${formatNumber(lane.headerBox.width)}" height="${formatNumber(lane.headerBox.height)}" fill="#f3f4f6" stroke="${STROKE}"/>`
+      );
+    }
+    if (lane.contentBox !== void 0) {
+      lines.push(
+        `    <rect class="swimlane-content" data-lane-content="${escapeAttribute(`${swimlane.id}.${lane.id}`)}" x="${formatNumber(lane.contentBox.x)}" y="${formatNumber(lane.contentBox.y)}" width="${formatNumber(lane.contentBox.width)}" height="${formatNumber(lane.contentBox.height)}" fill="none" stroke="none"/>`
+      );
+    }
     if (lane.label?.text !== void 0) {
+      const annotation = findAnnotation(
+        annotations,
+        "swimlane-label",
+        `${swimlane.id}.${lane.id}`
+      );
       lines.push(
-        `    <text class="swimlane-label" x="${formatNumber(lane.box.x + lane.box.width / 2)}" y="${formatNumber(lane.box.y + 16)}" text-anchor="middle" font-family="${FONT_FAMILY}" font-size="12" fill="#111827">${escapeXml(lane.label.text)}</text>`
+        ...annotation === void 0 ? [
+          renderSwimlaneLabel(
+            swimlane,
+            lane.label.text,
+            lane.headerBox ?? lane.box
+          )
+        ] : renderSolvedTextAnnotation(annotation, "swimlane-label", {
+          indent: "    ",
+          mode: "center",
+          rotate: swimlane.orientation === "horizontal"
+        }) ?? []
       );
     }
   }
   lines.push("  </g>");
   return lines;
 }
-function renderPorts(node) {
+function renderPorts(node, annotations) {
   return (node.ports ?? []).flatMap((port) => [
     `  <rect class="port" data-kind="${escapeAttribute(port.kind)}" data-port="${escapeAttribute(`${node.id}.${port.id}`)}" x="${formatNumber(port.box.x)}" y="${formatNumber(port.box.y)}" width="${formatNumber(port.box.width)}" height="${formatNumber(port.box.height)}" fill="${escapeAttribute(port.style?.fill ?? "#d9ead3")}" stroke="${escapeAttribute(port.style?.stroke ?? STROKE)}"/>`,
-    ...port.label?.text === void 0 ? [] : [
-      `  <text class="port-label" data-for="${escapeAttribute(`${node.id}.${port.id}`)}" x="${formatNumber(portLabelX(port.anchor.x, port.side))}" y="${formatNumber(port.anchor.y - 8)}" text-anchor="${port.side === "left" ? "end" : "start"}" font-family="${FONT_FAMILY}" font-size="10" fill="#111827">${escapeXml(port.label.text)}</text>`
-    ]
+    ...port.label?.text === void 0 ? [] : (() => {
+      const annotation = findAnnotation(
+        annotations,
+        "port-label",
+        `${node.id}.${port.id}`
+      );
+      return annotation === void 0 ? [
+        `  <text class="port-label" data-for="${escapeAttribute(`${node.id}.${port.id}`)}" x="${formatNumber(portLabelX(port.anchor.x, port.side))}" y="${formatNumber(port.anchor.y - 8)}" text-anchor="${port.side === "left" ? "end" : "start"}" font-family="${FONT_FAMILY}" font-size="10" fill="#111827">${escapeXml(port.label.text)}</text>`
+      ] : renderSolvedTextAnnotation(annotation, "port-label", {
+        indent: "  ",
+        mode: "center",
+        textAnchor: port.side === "left" ? "end" : "start"
+      }) ?? [];
+    })()
   ]);
 }
-function renderCompartments(node) {
+function renderCompartments(node, annotations) {
   const compartments2 = node.compartments;
   if (compartments2 === void 0) {
     return [];
@@ -2385,7 +3405,6 @@ function renderCompartments(node) {
       text
     }))
   ];
-  const lineHeight = 16;
   const lines = [
     `  <g class="compartment" data-for="${escapeAttribute(node.id)}">`
   ];
@@ -2394,32 +3413,72 @@ function renderCompartments(node) {
     if (row === void 0) {
       continue;
     }
-    const y = node.box.y + 18 + index * lineHeight;
+    const y = node.box.y + 18 + index * 16;
     if (index > 1) {
       lines.push(
         `    <line class="compartment-separator" x1="${formatNumber(node.box.x)}" y1="${formatNumber(y - 12)}" x2="${formatNumber(node.box.x + node.box.width)}" y2="${formatNumber(y - 12)}" stroke="${STROKE}"/>`
       );
     }
+    const annotation = findAnnotation(
+      annotations,
+      "compartment-row",
+      node.id,
+      index
+    );
     lines.push(
-      `    <text class="compartment-${row.className}" x="${formatNumber(node.box.x + node.box.width / 2)}" y="${formatNumber(y)}" text-anchor="middle" font-family="${FONT_FAMILY}" font-size="11" fill="#111827">${escapeXml(row.text)}</text>`
+      ...annotation === void 0 ? [
+        `    <text class="compartment-${row.className}" x="${formatNumber(node.box.x + node.box.width / 2)}" y="${formatNumber(y)}" text-anchor="middle" font-family="${FONT_FAMILY}" font-size="11" fill="#111827">${escapeXml(row.text)}</text>`
+      ] : renderSolvedTextAnnotation(
+        annotation,
+        `compartment-${row.className}`,
+        {
+          indent: "    ",
+          mode: "center"
+        }
+      ) ?? []
     );
   }
   lines.push("  </g>");
   return lines;
 }
-function portLabelX(x, side) {
-  if (side === "left") {
-    return x - 8;
-  }
-  if (side === "right") {
-    return x + 8;
+function tableCellBox(table, columnIndex, rowIndex, rowHeight, columnCount) {
+  const x = table.columnXOffsets[columnIndex] ?? table.box.x + table.box.width / columnCount * columnIndex;
+  const nextX = table.columnXOffsets[columnIndex + 1] ?? table.box.x + table.box.width;
+  return {
+    x,
+    y: table.box.y + rowIndex * rowHeight,
+    width: nextX - x,
+    height: rowHeight
+  };
+}
+function renderEvidenceText(className, lines, box) {
+  const fontSize = EVIDENCE_TEXT_FONT_SIZE;
+  const lineHeight = EVIDENCE_TEXT_LINE_HEIGHT;
+  const x = box.x + box.width / 2;
+  if (lines.length <= 1) {
+    return `<text class="${className}" x="${formatNumber(x)}" y="${formatNumber(box.y + box.height / 2)}" text-anchor="middle" dominant-baseline="middle" font-family="${FONT_FAMILY}" font-size="${formatNumber(fontSize)}" fill="#111827">${escapeXml(lines[0] ?? "")}</text>`;
   }
-  return x + 8;
+  const totalHeight = (lines.length - 1) * lineHeight;
+  const firstBaselineY = box.y + box.height / 2 - totalHeight / 2;
+  return [
+    `<text class="${className}" x="${formatNumber(x)}" y="${formatNumber(firstBaselineY)}" text-anchor="middle" dominant-baseline="middle" font-family="${FONT_FAMILY}" font-size="${formatNumber(fontSize)}" fill="#111827">`,
+    ...lines.map(
+      (line, index) => `  <tspan x="${formatNumber(x)}" y="${formatNumber(firstBaselineY + index * lineHeight)}">${escapeXml(line)}</tspan>`
+    ),
+    "</text>"
+  ].join("\n");
 }
-function renderRect(box, attributes) {
-  return `<rect ${attributes} x="${formatNumber(box.x)}" y="${formatNumber(box.y)}" width="${formatNumber(box.width)}" height="${formatNumber(box.height)}"/>`;
+function panelItemText(label, detail) {
+  return detail === void 0 ? label : `${label}: ${detail}`;
 }
-function renderLabel(label, box, item) {
+function renderLabel(label, box, item, annotations, surfaceKind) {
+  const annotation = findAnnotation(annotations, surfaceKind, item.id);
+  if (annotation !== void 0) {
+    return renderSolvedTextAnnotation(annotation, "label", {
+      indent: "  ",
+      mode: "center"
+    }) ?? [];
+  }
   const labelLayout = item.labelLayout;
   if (labelLayout?.lines !== void 0 && labelLayout.lines.length > 0) {
     const offset = { x: box.x, y: box.y };
@@ -2445,10 +3504,17 @@ function renderEdgePath(edge) {
   const dash = edge.style === "dashed" ? ' stroke-dasharray="6 4"' : "";
   return `<path class="edge" data-id="${escapeAttribute(edge.id)}" d="${formatPath(pathPointsBeforeArrowhead(edge.points))}" fill="none" stroke="${EDGE_STROKE}" stroke-width="1.5"${dash}/>`;
 }
-function renderEdgeLabel(edge) {
+function renderEdgeLabel(edge, annotations) {
   if (edge.label?.text === void 0 || edge.points.length < 2) {
     return [];
   }
+  const annotation = findAnnotation(annotations, "edge-label", edge.id);
+  if (annotation !== void 0) {
+    return renderSolvedTextAnnotation(annotation, "edge-label", {
+      indent: "  ",
+      mode: "center"
+    }) ?? [];
+  }
   const placement = labelPlacementOnPolyline(edge.points);
   if (placement === void 0) {
     return [];
@@ -2462,6 +3528,85 @@ function renderArrowhead(edge) {
   const fill = edge.arrowhead === "hollowTriangle" ? "none" : EDGE_STROKE;
   return `<polygon class="edge-arrowhead" data-edge="${escapeAttribute(edge.id)}" points="${formatPoints([arrowhead.tip, arrowhead.left, arrowhead.right])}" fill="${fill}" stroke="${EDGE_STROKE}"/>`;
 }
+function renderSolvedTextAnnotation(annotation, className, options) {
+  if (annotation === void 0) {
+    return void 0;
+  }
+  const x = options.mode === "center" ? annotation.box.x + annotation.box.width / 2 : annotation.box.x;
+  const y = options.mode === "center" ? annotation.box.y + annotation.box.height / 2 : annotation.box.y + annotation.box.height;
+  const rotate = options.rotate ? ` transform="rotate(-90 ${formatNumber(x)} ${formatNumber(y)})"` : "";
+  const attrs = [
+    `class="${className}"`,
+    `data-for="${escapeAttribute(annotation.ownerId)}"`,
+    `data-text-surface="${escapeAttribute(annotation.surfaceKind)}"`,
+    `data-owner-id="${escapeAttribute(annotation.ownerId)}"`,
+    `data-text-backend="${escapeAttribute(annotation.textBackend ?? "deterministic")}"`,
+    `font-family="${escapeAttribute(annotation.fontFamily)}"`,
+    `font-size="${formatNumber(annotation.fontSize)}"`,
+    `fill="#111827"`
+  ];
+  if (options.mode === "center") {
+    attrs.push('text-anchor="middle"');
+  } else {
+    attrs.push(`text-anchor="${options.textAnchor ?? "start"}"`);
+  }
+  if (annotation.lines.length > 1) {
+    return [
+      `${options.indent}<text ${attrs.join(" ")}${rotate}>`,
+      ...annotation.lines.map(
+        (line2) => `${options.indent}  <tspan x="${formatNumber(textLineX(annotation, line2, options))}" y="${formatNumber(annotation.box.y + line2.baselineY)}">${escapeXml(line2.text)}</tspan>`
+      ),
+      `${options.indent}</text>`
+    ];
+  }
+  const line = annotation.lines[0];
+  const text = line?.text ?? options.fallbackText ?? annotation.text;
+  const singleLineAttrs = options.mode === "center" ? [...attrs, 'dominant-baseline="middle"'] : attrs;
+  return [
+    `${options.indent}<text ${singleLineAttrs.join(" ")} x="${formatNumber(x)}" y="${formatNumber(y)}"${rotate}>${escapeXml(text)}</text>`
+  ];
+}
+function textLineX(annotation, line, options) {
+  if (options.mode === "center") {
+    return annotation.box.x + line.box.x + line.box.width / 2;
+  }
+  if ((options.textAnchor ?? "start") === "end") {
+    return annotation.box.x + line.box.x + line.box.width;
+  }
+  return annotation.box.x + line.box.x;
+}
+function findAnnotation(annotations, surfaceKind, ownerId, index) {
+  return annotations.find((annotation) => {
+    if (annotation.surfaceKind !== surfaceKind) {
+      return false;
+    }
+    if (annotation.ownerId !== ownerId) {
+      return false;
+    }
+    if (index === void 0) {
+      return annotation.surfaceIndex === void 0;
+    }
+    return annotation.surfaceIndex === index;
+  });
+}
+function renderSwimlaneLabel(swimlane, text, labelBox) {
+  const x = labelBox.x + labelBox.width / 2;
+  const y = labelBox.y + labelBox.height / 2;
+  const transform = swimlane.orientation === "horizontal" ? ` transform="rotate(-90 ${formatNumber(x)} ${formatNumber(y)})"` : "";
+  return `    <text class="swimlane-label" x="${formatNumber(x)}" y="${formatNumber(y)}" text-anchor="middle" dominant-baseline="middle"${transform} font-family="${FONT_FAMILY}" font-size="12" fill="#111827">${escapeXml(text)}</text>`;
+}
+function renderRect(box, attributes) {
+  return `<rect ${attributes} x="${formatNumber(box.x)}" y="${formatNumber(box.y)}" width="${formatNumber(box.width)}" height="${formatNumber(box.height)}"/>`;
+}
+function portLabelX(x, side) {
+  if (side === "left") {
+    return x - 8;
+  }
+  if (side === "right") {
+    return x + 8;
+  }
+  return x + 8;
+}
 function labelPlacementOnPolyline(points) {
   const segments = nonZeroSegments(points);
   const totalLength = segments.reduce(
@@ -2544,17 +3689,15 @@ function shapePoints(shape, box) {
         { x: right - skew, y: bottom },
         { x: left, y: bottom }
       ];
-    case "hexagon": {
-      const inset = Math.min(box.width * 0.2, 24);
+    case "hexagon":
       return [
-        { x: left + inset, y: top },
-        { x: right - inset, y: top },
+        { x: left + skew, y: top },
+        { x: right - skew, y: top },
         { x: right, y: midY },
-        { x: right - inset, y: bottom },
-        { x: left + inset, y: bottom },
+        { x: right - skew, y: bottom },
+        { x: left + skew, y: bottom },
         { x: left, y: midY }
       ];
-    }
   }
 }
 function formatCylinderPath(box) {
@@ -2579,10 +3722,9 @@ function formatCylinderPath(box) {
   ].join(" ");
 }
 function formatPath(points) {
-  return points.map((point2, index) => {
-    const command = index === 0 ? "M" : "L";
-    return `${command} ${formatNumber(point2.x)} ${formatNumber(point2.y)}`;
-  }).join(" ");
+  return points.map(
+    (point2, index) => `${index === 0 ? "M" : "L"} ${formatNumber(point2.x)} ${formatNumber(point2.y)}`
+  ).join(" ");
 }
 function formatPoints(points) {
   return points.map((point2) => `${formatNumber(point2.x)},${formatNumber(point2.y)}`).join(" ");
@@ -2605,6 +3747,18 @@ function escapeAttribute(value) {
 function indent(value) {
   return `  ${value}`;
 }
+function indentLines(values) {
+  return values.map(indent);
+}
+
+// src/ir/diagnostics.ts
+var DELIVERABILITY_DIAGNOSTIC_CODES = /* @__PURE__ */ new Set([
+  "constraints.locked-target-not-moved",
+  "routing.evidence.crossing_forbidden",
+  "routing.obstacle.unavoidable",
+  "route_obstacle_fallback",
+  "routing.text-clearance.unresolved"
+]);
 var DEFAULT_OPTIONS = {
   nodesep: 80,
   ranksep: 100,
@@ -2706,48 +3860,374 @@ function isValidDimension(value) {
 // src/routing/routes.ts
 function routeEdge(input) {
   const diagnostics = [];
+  const softObstacles = input.obstacles ?? [];
+  const hardObstacles = input.hardObstacles ?? [];
   const defaultAnchors = defaultAnchorsForGeometry(
     input.source.box,
     input.target.box,
     input.direction
   );
-  const source = getEdgePort(
-    input.source,
-    input.target.center,
-    input.sourceAnchor ?? defaultAnchors.sourceAnchor
-  );
-  const target = getEdgePort(
-    input.target,
-    input.source.center,
-    input.targetAnchor ?? defaultAnchors.targetAnchor
-  );
   if ((input.kind ?? "orthogonal") === "straight") {
-    return { points: simplifyRoute([source, target]), diagnostics };
-  }
-  const candidates = orthogonalCandidates(source, target, input.direction);
-  candidates.push(
-    ...expandedObstacleCandidates(
-      source,
-      target,
-      input.direction,
-      input.obstacles ?? []
-    )
-  );
-  for (const candidate of candidates) {
-    if (!routeIntersectsObstacles(candidate, input.obstacles ?? [])) {
-      return { points: simplifyRoute(candidate), diagnostics };
+    const source = getEdgePort(
+      input.source,
+      input.target.center,
+      input.sourceAnchor ?? defaultAnchors.sourceAnchor
+    );
+    const target = getEdgePort(
+      input.target,
+      input.source.center,
+      input.targetAnchor ?? defaultAnchors.targetAnchor
+    );
+    const points = finalizeRoute(
+      [source, target],
+      softObstacles,
+      hardObstacles,
+      diagnostics
+    );
+    if (routeCrossesBoxes(points, hardObstacles)) {
+      diagnostics.push({
+        severity: "error",
+        code: "routing.evidence.crossing_forbidden",
+        message: "Straight route crosses hard evidence block obstacles."
+      });
+      return { points, diagnostics };
     }
-  }
-  diagnostics.push({
-    severity: "warning",
-    code: "routing.obstacle.unavoidable",
+    if (routeCrossesBoxes(points, softObstacles)) {
+      diagnostics.push({
+        severity: "warning",
+        code: "routing.obstacle.unavoidable",
+        message: "Straight route crosses soft obstacles."
+      });
+    }
+    return { points, diagnostics };
+  }
+  const routeLaneObstacles = [...softObstacles, ...hardObstacles];
+  const anchorPairs = routeAnchorPairs(input, defaultAnchors);
+  const candidateRoutes = anchorPairs.flatMap(
+    ({ sourceAnchor, targetAnchor }) => {
+      const source = getEdgePort(
+        input.source,
+        input.target.center,
+        sourceAnchor
+      );
+      const target = getEdgePort(
+        input.target,
+        input.source.center,
+        targetAnchor
+      );
+      const routes = [
+        ...orthogonalCandidates(source, target, input.direction),
+        ...expandedObstacleCandidates(
+          source,
+          target,
+          input.direction,
+          routeLaneObstacles
+        ),
+        ...outerDoglegCandidates(
+          source,
+          target,
+          input.direction,
+          routeLaneObstacles
+        )
+      ];
+      const endpointObstacles = endpointObstaclesForAutoAnchors(input);
+      return routes.map((points) => ({ points, endpointObstacles }));
+    }
+  );
+  for (const candidate of candidateRoutes) {
+    if (!routeIntersectsObstacles(candidate.points, softObstacles) && !routeIntersectsObstacles(candidate.points, hardObstacles) && !routeIntersectsEndpointInteriors(
+      candidate.points,
+      candidate.endpointObstacles
+    )) {
+      return {
+        points: finalizeRoute(
+          candidate.points,
+          softObstacles,
+          hardObstacles,
+          diagnostics
+        ),
+        diagnostics
+      };
+    }
+  }
+  const hardClearCandidate = candidateRoutes.find(
+    (candidate) => !routeIntersectsObstacles(candidate.points, hardObstacles) && !routeIntersectsEndpointInteriors(
+      candidate.points,
+      candidate.endpointObstacles
+    )
+  );
+  if (hardClearCandidate !== void 0) {
+    diagnostics.push({
+      severity: "warning",
+      code: "routing.obstacle.unavoidable",
+      message: "No bounded orthogonal route candidate avoided all soft obstacles."
+    });
+    return {
+      points: finalizeRoute(
+        hardClearCandidate.points,
+        softObstacles,
+        hardObstacles,
+        diagnostics
+      ),
+      diagnostics
+    };
+  }
+  if (hardObstacles.length > 0) {
+    diagnostics.push({
+      severity: "error",
+      code: "routing.evidence.crossing_forbidden",
+      message: "No bounded orthogonal route candidate avoided hard evidence block obstacles."
+    });
+    return {
+      points: finalizeRoute(
+        candidateRoutes[0]?.points ?? fallbackRoute(input, defaultAnchors),
+        softObstacles,
+        hardObstacles,
+        diagnostics
+      ),
+      diagnostics
+    };
+  }
+  diagnostics.push({
+    severity: "warning",
+    code: "routing.obstacle.unavoidable",
     message: "No bounded orthogonal route candidate avoided all obstacles."
   });
   return {
-    points: simplifyRoute(candidates[0] ?? [source, target]),
+    points: finalizeRoute(
+      candidateRoutes[0]?.points ?? fallbackRoute(input, defaultAnchors),
+      softObstacles,
+      hardObstacles,
+      diagnostics
+    ),
     diagnostics
   };
 }
+function finalizeRoute(points, softObstacles, hardObstacles, diagnostics) {
+  const simplified = simplifyRoute(points);
+  if (simplified.length >= 3) {
+    return simplified;
+  }
+  const crossesHardObstacles = routeCrossesBoxes(simplified, hardObstacles);
+  const crossesSoftObstacles = routeCrossesBoxes(simplified, softObstacles);
+  if (!crossesHardObstacles && !crossesSoftObstacles) {
+    return simplified;
+  }
+  const expanded = expandFallbackRoute(simplified, [
+    ...softObstacles,
+    ...hardObstacles
+  ]);
+  const expandedCrossesHard = routeCrossesBoxes(expanded, hardObstacles);
+  const expandedCrossesSoft = routeCrossesBoxes(expanded, softObstacles);
+  if (expandedCrossesHard || expandedCrossesSoft) {
+    diagnostics.push({
+      severity: expandedCrossesHard ? "error" : "warning",
+      code: "route_obstacle_fallback",
+      message: "Obstacle-aware routing fell back to fewer than three route points.",
+      detail: { pointCount: simplified.length }
+    });
+  }
+  return expanded;
+}
+function expandFallbackRoute(points, obstacles) {
+  if (points.length !== 2) {
+    return points.map((point2) => ({ ...point2 }));
+  }
+  const [source, target] = points;
+  if (source === void 0 || target === void 0) {
+    return points.map((point2) => ({ ...point2 }));
+  }
+  if (source.y === target.y) {
+    const detourY = horizontalDetourLane(source, target, obstacles);
+    return [
+      { ...source },
+      { x: source.x, y: detourY },
+      { x: target.x, y: detourY },
+      { ...target }
+    ];
+  }
+  if (source.x === target.x) {
+    const detourX = verticalDetourLane(source, target, obstacles);
+    return [
+      { ...source },
+      { x: detourX, y: source.y },
+      { x: detourX, y: target.y },
+      { ...target }
+    ];
+  }
+  const hv = diagonalDetourHV(source, target, obstacles);
+  const vh = diagonalDetourVH(source, target, obstacles);
+  const viable = [hv, vh].filter((c) => !routeCrossesBoxes(c, obstacles));
+  const [firstViable, ...remainingViable] = viable;
+  if (firstViable !== void 0) {
+    const directLen = Math.hypot(target.x - source.x, target.y - source.y);
+    let best = firstViable;
+    for (const cand of remainingViable) {
+      if (pathLength(cand) - directLen < pathLength(best) - directLen) {
+        best = cand;
+      }
+    }
+    return best;
+  }
+  return [
+    { ...source },
+    { x: (source.x + target.x) / 2, y: source.y },
+    { x: (source.x + target.x) / 2, y: target.y },
+    { ...target }
+  ];
+}
+function horizontalDetourLane(source, target, obstacles) {
+  const crossing = obstacles.filter(
+    (obstacle) => segmentIntersectsBox(source, target, obstacle)
+  );
+  if (crossing.length === 0) {
+    return source.y + (source.x <= target.x ? 1 : -1) * 24;
+  }
+  const margin = 24;
+  const above = Math.min(...crossing.map((obstacle) => obstacle.y)) - margin;
+  const below = Math.max(...crossing.map((obstacle) => obstacle.y + obstacle.height)) + margin;
+  return Math.abs(above - source.y) <= Math.abs(below - source.y) ? above : below;
+}
+function verticalDetourLane(source, target, obstacles) {
+  const crossing = obstacles.filter(
+    (obstacle) => segmentIntersectsBox(source, target, obstacle)
+  );
+  if (crossing.length === 0) {
+    return source.x + (source.y <= target.y ? 1 : -1) * 24;
+  }
+  const margin = 24;
+  const left = Math.min(...crossing.map((obstacle) => obstacle.x)) - margin;
+  const right = Math.max(...crossing.map((obstacle) => obstacle.x + obstacle.width)) + margin;
+  return Math.abs(left - source.x) <= Math.abs(right - source.x) ? left : right;
+}
+function diagonalDetourHV(source, target, obstacles) {
+  const detourY = horizontalDetourLane(source, target, obstacles);
+  return [
+    { ...source },
+    { x: source.x, y: detourY },
+    { x: target.x, y: detourY },
+    { ...target }
+  ];
+}
+function diagonalDetourVH(source, target, obstacles) {
+  const detourX = verticalDetourLane(source, target, obstacles);
+  return [
+    { ...source },
+    { x: detourX, y: source.y },
+    { x: detourX, y: target.y },
+    { ...target }
+  ];
+}
+function pathLength(points) {
+  let len = 0;
+  for (let i = 1; i < points.length; i += 1) {
+    const a = points[i - 1];
+    const b = points[i];
+    if (a !== void 0 && b !== void 0) {
+      len += Math.hypot(b.x - a.x, b.y - a.y);
+    }
+  }
+  return len;
+}
+function endpointObstaclesForAutoAnchors(input) {
+  const boxes = [];
+  if (input.sourceAnchor === void 0 && hasDistinctAnchors(input.source)) {
+    boxes.push(insetBox(input.source.box, 1));
+  }
+  if (input.targetAnchor === void 0 && hasDistinctAnchors(input.target)) {
+    boxes.push(insetBox(input.target.box, 1));
+  }
+  return boxes.filter((box) => box.width > 0 && box.height > 0);
+}
+function hasDistinctAnchors(geometry) {
+  const points = new Set(
+    geometry.anchors.map((anchor) => `${anchor.point.x},${anchor.point.y}`)
+  );
+  return points.size > 1;
+}
+function insetBox(box, margin) {
+  return {
+    x: box.x + margin,
+    y: box.y + margin,
+    width: box.width - margin * 2,
+    height: box.height - margin * 2
+  };
+}
+function fallbackRoute(input, defaultAnchors) {
+  return [
+    getEdgePort(
+      input.source,
+      input.target.center,
+      input.sourceAnchor ?? defaultAnchors.sourceAnchor
+    ),
+    getEdgePort(
+      input.target,
+      input.source.center,
+      input.targetAnchor ?? defaultAnchors.targetAnchor
+    )
+  ];
+}
+function routeAnchorPairs(input, defaultAnchors) {
+  const sourceAnchors = routeAnchorCandidates(
+    input.sourceAnchor,
+    defaultAnchors.sourceAnchor,
+    input.source,
+    input.target.center
+  );
+  const targetAnchors = routeAnchorCandidates(
+    input.targetAnchor,
+    defaultAnchors.targetAnchor,
+    input.target,
+    input.source.center
+  );
+  const pairs = sourceAnchors.flatMap(
+    (sourceAnchor) => targetAnchors.map((targetAnchor) => ({ sourceAnchor, targetAnchor }))
+  );
+  const seen = /* @__PURE__ */ new Set();
+  return pairs.filter((pair) => {
+    const key = `${pair.sourceAnchor}->${pair.targetAnchor}`;
+    if (seen.has(key)) {
+      return false;
+    }
+    seen.add(key);
+    return true;
+  });
+}
+function routeAnchorCandidates(explicitAnchor, defaultAnchor, geometry, toward) {
+  if (explicitAnchor !== void 0) {
+    return [explicitAnchor];
+  }
+  const ranked = rankedSideAnchors(geometry, toward);
+  return [defaultAnchor, ...ranked].filter(
+    (anchor, index, anchors) => anchors.indexOf(anchor) === index
+  );
+}
+function rankedSideAnchors(geometry, toward) {
+  const anchors = outwardSideAnchors(geometry.box, toward);
+  return anchors.sort((left, right) => {
+    const leftPoint = getEdgePort(geometry, toward, left);
+    const rightPoint = getEdgePort(geometry, toward, right);
+    const distance = squaredDistance2(leftPoint, toward) - squaredDistance2(rightPoint, toward);
+    return distance === 0 ? left.localeCompare(right) : distance;
+  });
+}
+function outwardSideAnchors(box, toward) {
+  const center = {
+    x: box.x + box.width / 2,
+    y: box.y + box.height / 2
+  };
+  const dx = toward.x - center.x;
+  const dy = toward.y - center.y;
+  if (Math.abs(dx) >= Math.abs(dy)) {
+    return dx >= 0 ? ["right", "top", "bottom"] : ["left", "top", "bottom"];
+  }
+  return dy >= 0 ? ["bottom", "left", "right"] : ["top", "left", "right"];
+}
+function squaredDistance2(a, b) {
+  const dx = a.x - b.x;
+  const dy = a.y - b.y;
+  return dx * dx + dy * dy;
+}
 function simplifyRoute(points) {
   const withoutDuplicates = [];
   for (const point2 of points) {
@@ -2872,6 +4352,44 @@ function expandedObstacleCandidates(source, target, direction, obstacles) {
   }
   return candidates;
 }
+function outerDoglegCandidates(source, target, direction, obstacles) {
+  if (obstacles.length === 0) {
+    return [];
+  }
+  const margin = 24;
+  const minX = Math.min(...obstacles.map((obstacle) => obstacle.x)) - margin;
+  const maxX = Math.max(...obstacles.map((obstacle) => obstacle.x + obstacle.width)) + margin;
+  const minY = Math.min(...obstacles.map((obstacle) => obstacle.y)) - margin;
+  const maxY = Math.max(...obstacles.map((obstacle) => obstacle.y + obstacle.height)) + margin;
+  if (direction === "TB" || direction === "BT") {
+    const exit2 = exitDelta(source, target, "y");
+    return sortedUniqueLanes([minX, maxX], (source.x + target.x) / 2).map(
+      (laneX) => [
+        source,
+        { x: source.x, y: source.y + exit2 },
+        { x: laneX, y: source.y + exit2 },
+        { x: laneX, y: target.y - exit2 },
+        { x: target.x, y: target.y - exit2 },
+        target
+      ]
+    );
+  }
+  const exit = exitDelta(source, target, "x");
+  return sortedUniqueLanes([minY, maxY], (source.y + target.y) / 2).map(
+    (laneY) => [
+      source,
+      { x: source.x + exit, y: source.y },
+      { x: source.x + exit, y: laneY },
+      { x: target.x - exit, y: laneY },
+      { x: target.x - exit, y: target.y },
+      target
+    ]
+  );
+}
+function exitDelta(source, target, axis) {
+  const delta = axis === "x" ? target.x - source.x : target.y - source.y;
+  return (delta >= 0 ? 1 : -1) * 24;
+}
 function sortedUniqueLanes(lanes, midpoint) {
   return [...new Set(lanes)].filter((lane) => Number.isFinite(lane)).sort((left, right) => {
     const distance = Math.abs(left - midpoint) - Math.abs(right - midpoint);
@@ -2895,6 +4413,72 @@ function routeIntersectsObstacles(points, obstacles) {
   }
   return false;
 }
+function routeIntersectsEndpointInteriors(points, endpointInteriors) {
+  for (let index = 0; index < points.length - 1; index += 1) {
+    const a = points[index];
+    const b = points[index + 1];
+    if (a === void 0 || b === void 0) {
+      continue;
+    }
+    const segment = segmentBox(a, b);
+    for (const endpointInterior of endpointInteriors) {
+      validateBox(endpointInterior);
+      if (intersectsAabb(segment, endpointInterior)) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+function routeCrossesBoxes(points, obstacles) {
+  for (let index = 0; index < points.length - 1; index += 1) {
+    const a = points[index];
+    const b = points[index + 1];
+    if (a === void 0 || b === void 0) {
+      continue;
+    }
+    for (const obstacle of obstacles) {
+      validateBox(obstacle);
+      if (segmentIntersectsBox(a, b, obstacle)) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+function segmentIntersectsBox(start, end, box) {
+  const left = box.x;
+  const right = box.x + box.width;
+  const top = box.y;
+  const bottom = box.y + box.height;
+  if (pointInsideBox(start, box) || pointInsideBox(end, box)) {
+    return true;
+  }
+  if (start.x === end.x) {
+    return start.x > left && start.x < right && rangesOverlap(start.y, end.y, top, bottom);
+  }
+  if (start.y === end.y) {
+    return start.y > top && start.y < bottom && rangesOverlap(start.x, end.x, left, right);
+  }
+  return segmentIntersectsBoxEdge(start, end, left, top, right, top) || segmentIntersectsBoxEdge(start, end, right, top, right, bottom) || segmentIntersectsBoxEdge(start, end, right, bottom, left, bottom) || segmentIntersectsBoxEdge(start, end, left, bottom, left, top);
+}
+function pointInsideBox(point2, box) {
+  return point2.x > box.x && point2.x < box.x + box.width && point2.y > box.y && point2.y < box.y + box.height;
+}
+function rangesOverlap(a, b, min, max) {
+  const low = Math.min(a, b);
+  const high = Math.max(a, b);
+  return high > min && low < max;
+}
+function segmentIntersectsBoxEdge(start, end, x1, y1, x2, y2) {
+  const denominator = (end.x - start.x) * (y2 - y1) - (end.y - start.y) * (x2 - x1);
+  if (denominator === 0) {
+    return false;
+  }
+  const t = ((x1 - start.x) * (y2 - y1) - (y1 - start.y) * (x2 - x1)) / denominator;
+  const u = ((x1 - start.x) * (end.y - start.y) - (y1 - start.y) * (end.x - start.x)) / denominator;
+  return t > 0 && t < 1 && u > 0 && u < 1;
+}
 function segmentBox(a, b) {
   const minX = Math.min(a.x, b.x);
   const minY = Math.min(a.y, b.y);
@@ -2910,32 +4494,107 @@ function areCollinear(a, b, c) {
 }
 
 // src/solver/solve.ts
+var DEFAULT_MATRIX_CELL_SIZE2 = { width: 120, height: 36 };
+var DEFAULT_TABLE_CELL_SIZE2 = { width: 128, height: 34 };
+var DEFAULT_PANEL_WIDTH = 320;
+var DEFAULT_PANEL_ITEM_HEIGHT2 = 28;
+var DEFAULT_EVIDENCE_BLOCK_GAP = 24;
+var EDGE_LABEL_CLEARANCE = 8;
+var DEFAULT_CJK_FONT_FAMILY = "YaHei,SimSun,sans-serif";
+var DEFAULT_MIN_CJK_FONT_SIZE = 14;
+function prefitLabelFont(node, _options) {
+  const cjk = labelCjkTypography(node.label?.metadata);
+  const fontFamily = cjk.fontFamily ?? DEFAULT_FONT.fontFamily;
+  const fontSize = cjk.fontSize ?? DEFAULT_FONT.fontSize;
+  const lineHeight = fontSize !== DEFAULT_FONT.fontSize ? Math.max(DEFAULT_FONT.lineHeight ?? 18, fontSize * 1.2) : DEFAULT_FONT.lineHeight ?? 18;
+  return { fontFamily, fontSize, lineHeight };
+}
+var EVIDENCE_TEXT_FONT = {
+  fontFamily: "Arial, sans-serif",
+  fontSize: 10,
+  lineHeight: 12
+};
 function solveDiagram(diagram, options = {}) {
   const diagnostics = [...diagram.diagnostics];
-  const nodes = stableById(diagram.nodes);
-  const edges = stableById(diagram.edges);
-  const groups = stableById(diagram.groups);
+  const nodes = stableUniqueById(
+    diagram.nodes,
+    diagnostics,
+    "nodes",
+    "duplicate_node_id"
+  );
+  const edges = stableUniqueById(
+    diagram.edges,
+    diagnostics,
+    "edges",
+    "duplicate_edge_id"
+  );
+  const groups = stableUniqueById(
+    diagram.groups,
+    diagnostics,
+    "groups",
+    "duplicate_group_id"
+  );
+  const cjkTypography = createCjkTypographyOptions(options);
+  const cjkStyledNodes = nodes.map(
+    (node) => enhanceNodeCjkTypography(node, cjkTypography, diagnostics)
+  );
+  const styledNodes = options.prefitLabelSize === true ? cjkStyledNodes.map(
+    (node) => prefitNodeLabelSize(node, options, diagnostics)
+  ) : cjkStyledNodes;
+  const styledEdges = edges.map(
+    (edge) => enhanceEdgeCjkTypography(edge, cjkTypography, diagnostics)
+  );
+  const styledGroups = groups.map(
+    (group) => enhanceGroupCjkTypography(group, cjkTypography, diagnostics)
+  );
+  const styledSwimlanes = (diagram.swimlanes ?? []).map(
+    (swimlane) => enhanceSwimlaneCjkTypography(swimlane, cjkTypography, diagnostics)
+  );
   const constraints = stableByConstraintId(diagram.constraints);
   const layout2 = runDagreInitialLayout({
     direction: diagram.direction,
-    nodes: nodes.map((node) => ({ id: node.id, size: node.size })),
-    edges: edges.map((edge) => ({
+    nodes: styledNodes.map((node) => ({ id: node.id, size: node.size })),
+    edges: styledEdges.map((edge) => ({
       id: edge.id,
       sourceId: edge.source.nodeId,
       targetId: edge.target.nodeId
     }))
   });
   diagnostics.push(...layout2.diagnostics);
+  const initialNodeBoxes = wrapVerticalStackIfNeeded(
+    layout2.boxes,
+    styledNodes,
+    styledEdges,
+    diagram.direction,
+    options,
+    diagnostics
+  );
   const constrained = applyLayoutConstraints({
     direction: diagram.direction,
     overlapSpacing: options?.overlapSpacing ?? 40,
-    boxes: layout2.boxes,
-    nodes,
+    ...options.minSiblingGap === void 0 ? {} : { minSiblingGap: options.minSiblingGap },
+    ...options.distributeContainedChildren === void 0 ? {} : { distributeContainedChildren: options.distributeContainedChildren },
+    boxes: initialNodeBoxes,
+    nodes: styledNodes,
     constraints
   });
   diagnostics.push(...constrained.diagnostics);
+  const swimlaneContracts = applySwimlaneLayoutContracts(
+    styledSwimlanes,
+    constraints,
+    styledEdges,
+    isTopToBottomReadingDirection(diagram.metadata?.primaryReadingDirection),
+    constrained.boxes,
+    constrained.locks,
+    options?.overlapSpacing ?? 40,
+    Math.max(0, options?.minLaneGutter ?? 0)
+  );
+  if (swimlaneContracts.layouts.size > 0) {
+    removeResolvedOverlapDiagnostics(diagnostics, constrained.boxes);
+  }
+  diagnostics.push(...swimlaneContracts.diagnostics);
   const coordinatedNodes = coordinateNodes(
-    nodes,
+    styledNodes,
     constrained.boxes,
     options,
     diagnostics
@@ -2951,28 +4610,31 @@ function solveDiagram(diagram, options = {}) {
     ])
   );
   const coordinatedGroups = coordinateGroups(
-    groups,
+    styledGroups,
     constrained.boxes,
     options,
     diagnostics
   );
   const coordinatedSwimlanes = coordinateSwimlanes(
-    diagram.swimlanes ?? [],
-    constrained.boxes
+    styledSwimlanes,
+    constrained.boxes,
+    swimlaneContracts.layouts
+  );
+  const coordinatedMatrices = coordinateMatrices(diagram.matrices ?? []);
+  const coordinatedTables = coordinateTables(diagram.tables ?? []);
+  const coordinatedEvidencePanels = coordinateEvidencePanels(
+    diagram.evidencePanels ?? []
   );
   const groupBoxes = new Map(
     coordinatedGroups.map((group) => [group.id, group.box])
   );
-  const coordinatedEdges = coordinateEdges(
-    edges,
-    nodeGeometryById,
-    coordinatedNodes,
-    [...nodeGeometryById.values()].map((geometry) => geometry.obstacleBox),
-    diagram.direction,
-    options,
-    diagnostics
-  );
-  const allBoxes = [
+  const baseTextAnnotations = coordinateBaseTextAnnotations({
+    nodes: coordinatedNodes,
+    groups: coordinatedGroups,
+    swimlanes: coordinatedSwimlanes,
+    ...options.textMeasurer === void 0 ? {} : { textMeasurer: options.textMeasurer }
+  });
+  const layoutBoxes = [
     ...coordinatedNodes.map((node) => node.box),
     ...coordinatedNodes.flatMap(
       (node) => (node.ports ?? []).flatMap(
@@ -2982,10 +4644,149 @@ function solveDiagram(diagram, options = {}) {
     ...groupBoxes.values(),
     ...coordinatedSwimlanes.flatMap(
       (swimlane) => swimlane.box === void 0 ? [] : [swimlane.box]
-    )
+    ),
+    ...baseTextAnnotations.map((annotation) => annotation.box)
+  ];
+  const initialContentBounds = layoutBoxes.length === 0 ? { x: 0, y: 0, width: 0} : unionBoxes(layoutBoxes);
+  placeEvidenceBlocks(
+    options.obstacleMargin ?? 0,
+    [
+      ...coordinatedMatrices,
+      ...coordinatedTables,
+      ...coordinatedEvidencePanels
+    ],
+    initialContentBounds
+  );
+  refreshTableColumnXOffsets(coordinatedTables);
+  measureEvidenceTextBlocks(
+    coordinatedMatrices,
+    coordinatedTables,
+    coordinatedEvidencePanels,
+    options.textMeasurer
+  );
+  const evidenceBoxes = [
+    ...coordinatedMatrices.map((matrix) => matrix.box),
+    ...coordinatedTables.map((table) => table.box),
+    ...coordinatedEvidencePanels.map((panel) => panel.box)
   ];
+  diagnostics.push(
+    ...reportEvidenceBlockOverlaps(
+      [
+        ...coordinatedMatrices.map((matrix) => ({
+          id: matrix.id,
+          kind: "matrix",
+          ...matrix.position === void 0 ? {} : { position: matrix.position },
+          box: matrix.box
+        })),
+        ...coordinatedTables.map((table) => ({
+          id: table.id,
+          kind: "table",
+          ...table.position === void 0 ? {} : { position: table.position },
+          box: table.box
+        })),
+        ...coordinatedEvidencePanels.map((panel) => ({
+          id: panel.id,
+          kind: "evidence-panel",
+          ...panel.position === void 0 ? {} : { position: panel.position },
+          box: panel.box
+        }))
+      ],
+      [
+        ...coordinatedNodes.map((node) => ({
+          id: node.id,
+          kind: "node",
+          box: node.box
+        })),
+        ...coordinatedGroups.map((group) => ({
+          id: group.id,
+          kind: "group",
+          box: group.box
+        })),
+        ...coordinatedSwimlanes.flatMap(
+          (swimlane) => swimlane.box === void 0 ? [] : [{ id: swimlane.id, kind: "swimlane", box: swimlane.box }]
+        )
+      ]
+    )
+  );
+  const allBoxes = [...layoutBoxes, ...evidenceBoxes];
   const contentBounds = allBoxes.length === 0 ? { x: 0, y: 0, width: 0, height: 0 } : unionBoxes(allBoxes);
   const frame = diagram.frame === void 0 ? void 0 : coordinateFrame(diagram.frame, contentBounds);
+  const frameTextAnnotation = frame === void 0 ? [] : [coordinateFrameTextAnnotation(frame, options.textMeasurer)];
+  const routingTextObstacles = [
+    ...baseTextAnnotations.filter(isPreRouteTextObstacle),
+    ...frameTextAnnotation.filter(isPreRouteTextObstacle)
+  ];
+  const margin = options.obstacleMargin ?? 0;
+  const softObstacles = [
+    ...coordinatedTables.map((table) => expandBox(table.box, margin)),
+    ...coordinatedEvidencePanels.map((panel) => expandBox(panel.box, margin))
+  ];
+  const hardObstacles = coordinatedMatrices.map(
+    (matrix) => expandBox(matrix.box, margin)
+  );
+  const titleBarObstacles = [];
+  if (frame !== void 0) {
+    titleBarObstacles.push(expandBox(frame.titleBox, margin));
+  }
+  for (const swimlane of coordinatedSwimlanes) {
+    for (const lane of swimlane.lanes) {
+      if (lane.headerBox !== void 0 && lane.headerBox.width > 0 && lane.headerBox.height > 0) {
+        titleBarObstacles.push(expandBox(lane.headerBox, margin));
+      }
+    }
+  }
+  const coordinatedEdges = coordinateEdges(
+    styledEdges,
+    nodeGeometryById,
+    coordinatedNodes,
+    [...nodeGeometryById.values()].map((geometry) => geometry.obstacleBox),
+    [...softObstacles, ...titleBarObstacles],
+    routingTextObstacles,
+    hardObstacles,
+    diagram.direction,
+    options,
+    diagnostics
+  );
+  const edgeTextAnnotations = coordinateEdgeTextAnnotations(
+    coordinatedEdges,
+    [
+      ...coordinatedNodes.map((node) => node.box),
+      ...baseTextAnnotations.map((annotation) => annotation.box),
+      ...frameTextAnnotation.map((annotation) => annotation.box)
+    ],
+    options.textMeasurer
+  );
+  const textAnnotations = [
+    ...baseTextAnnotations,
+    ...frameTextAnnotation,
+    ...edgeTextAnnotations
+  ];
+  diagnostics.push(...reportTextAnnotationCollisions(textAnnotations));
+  diagnostics.push(
+    ...reportRouteTextClearance(coordinatedEdges, textAnnotations)
+  );
+  const edgePointBounds = edgeBounds(coordinatedEdges);
+  const boundsBase = [
+    contentBounds,
+    ...edgePointBounds,
+    ...edgeTextAnnotations.map((annotation) => annotation.box)
+  ];
+  diagnostics.push(
+    ...reportPageOverflow(
+      frame === void 0 ? unionBoxes(boundsBase) : unionBoxes([...boundsBase, frame.box, frame.titleBox]),
+      options.pageBounds
+    )
+  );
+  let degraded = false;
+  const resultDiagnostics = diagnostics.map((diagnostic) => {
+    if (DELIVERABILITY_DIAGNOSTIC_CODES.has(diagnostic.code)) {
+      degraded = true;
+      if (options.strict) {
+        return { ...diagnostic, severity: "error" };
+      }
+    }
+    return diagnostic;
+  });
   return {
     id: diagram.id,
     ...diagram.title === void 0 ? {} : { title: diagram.title },
@@ -2994,36 +4795,1042 @@ function solveDiagram(diagram, options = {}) {
     edges: coordinatedEdges,
     groups: coordinatedGroups,
     ...coordinatedSwimlanes.length === 0 ? {} : { swimlanes: coordinatedSwimlanes },
-    diagnostics,
-    bounds: frame === void 0 ? contentBounds : unionBoxes([contentBounds, frame.box, frame.titleBox]),
+    ...coordinatedMatrices.length === 0 ? {} : { matrices: coordinatedMatrices },
+    ...coordinatedTables.length === 0 ? {} : { tables: coordinatedTables },
+    ...coordinatedEvidencePanels.length === 0 ? {} : { evidencePanels: coordinatedEvidencePanels },
+    diagnostics: resultDiagnostics,
+    degraded,
+    bounds: frame === void 0 ? unionBoxes(boundsBase) : unionBoxes([...boundsBase, frame.box, frame.titleBox]),
     ...frame === void 0 ? {} : { frame },
+    ...textAnnotations.length === 0 ? {} : { textAnnotations },
     ...diagram.metadata === void 0 ? {} : { metadata: diagram.metadata }
   };
 }
-function coordinateNodes(nodes, boxes, options, diagnostics) {
-  const coordinated = [];
-  for (const node of nodes) {
-    const box = boxes.get(node.id);
-    if (box === void 0) {
-      diagnostics.push({
-        severity: "error",
-        code: "solver.node-box.missing",
-        message: `Node ${node.id} has no solved box.`,
-        path: ["nodes", node.id],
-        detail: { nodeId: node.id }
-      });
-      continue;
-    }
-    const geometry = computeShapeGeometry({
-      shape: node.shape,
-      box,
-      obstacleMargin: options.obstacleMargin ?? 0
-    });
-    coordinated.push({
-      id: node.id,
-      ...node.label === void 0 ? {} : { label: node.label },
-      ...node.style === void 0 ? {} : { style: node.style },
-      ...node.ports === void 0 ? {} : { ports: coordinatePorts(node, box, options.portShifting) },
+function solveDiagramSafe(diagram, options = {}) {
+  return solveDiagram(diagram, { ...options, prefitLabelSize: true });
+}
+function prefitNodeLabelSize(node, options, diagnostics) {
+  if (node.label === void 0) {
+    return node;
+  }
+  const measurer = options.textMeasurer ?? createDefaultTextMeasurer();
+  const layout2 = fitLabel(
+    node.label.text,
+    {
+      font: prefitLabelFont(node),
+      padding: DEFAULT_NODE_PADDING,
+      minSize: DEFAULT_NODE_MIN_SIZE,
+      maxWidth: node.label.maxWidth ?? Math.max(node.size.width, DEFAULT_LABEL_MAX_WIDTH)
+    },
+    measurer
+  );
+  const width = Math.max(node.size.width, layout2.fittedSize.width);
+  const height = Math.max(node.size.height, layout2.fittedSize.height);
+  const resized = width !== node.size.width || height !== node.size.height;
+  if (resized) {
+    diagnostics.push({
+      severity: "info",
+      code: "prefit_label_resized",
+      message: `Node ${node.id} size expanded to fit its label.`,
+      path: ["nodes", node.id],
+      detail: {
+        nodeId: node.id,
+        from: { width: node.size.width, height: node.size.height },
+        to: { width, height }
+      }
+    });
+  }
+  const centeredLayout = expandLabelLayoutToNode(layout2, { width, height });
+  return { ...node, size: { width, height }, labelLayout: centeredLayout };
+}
+function expandLabelLayoutToNode(layout2, nodeSize) {
+  if (layout2.box.width >= nodeSize.width && layout2.box.height >= nodeSize.height) {
+    return layout2;
+  }
+  const offsetX = Math.max(0, (nodeSize.width - layout2.box.width) / 2);
+  const offsetY = Math.max(0, (nodeSize.height - layout2.box.height) / 2);
+  if (offsetX === 0 && offsetY === 0) {
+    return layout2;
+  }
+  return {
+    ...layout2,
+    box: {
+      x: layout2.box.x + offsetX,
+      y: layout2.box.y + offsetY,
+      width: layout2.box.width,
+      height: layout2.box.height
+    },
+    contentBox: {
+      x: layout2.contentBox.x + offsetX,
+      y: layout2.contentBox.y + offsetY,
+      width: layout2.contentBox.width,
+      height: layout2.contentBox.height
+    },
+    lines: layout2.lines.map((line) => ({
+      ...line,
+      box: {
+        x: line.box.x + offsetX,
+        y: line.box.y + offsetY,
+        width: line.box.width,
+        height: line.box.height
+      }
+    }))
+  };
+}
+function reportPageOverflow(contentBounds, pageBounds) {
+  if (pageBounds === void 0) {
+    return [];
+  }
+  const overflowRight = Math.max(
+    0,
+    contentBounds.x + contentBounds.width - pageBounds.width
+  );
+  const overflowBottom = Math.max(
+    0,
+    contentBounds.y + contentBounds.height - pageBounds.height
+  );
+  const overflowLeft = Math.max(0, -contentBounds.x);
+  const overflowTop = Math.max(0, -contentBounds.y);
+  if (overflowRight === 0 && overflowBottom === 0 && overflowLeft === 0 && overflowTop === 0) {
+    return [];
+  }
+  return [
+    {
+      severity: "warning",
+      code: "page_overflow",
+      message: `Content ${contentBounds.width}x${contentBounds.height} exceeds page ${pageBounds.width}x${pageBounds.height}.`,
+      path: ["bounds"],
+      detail: {
+        page: { width: pageBounds.width, height: pageBounds.height },
+        content: {
+          width: contentBounds.width,
+          height: contentBounds.height
+        },
+        overflow: {
+          right: overflowRight,
+          bottom: overflowBottom,
+          left: overflowLeft,
+          top: overflowTop
+        }
+      }
+    }
+  ];
+}
+function createCjkTypographyOptions(options) {
+  const fontFamily = options.cjkFontFamily === false ? void 0 : options.cjkFontFamily ?? DEFAULT_CJK_FONT_FAMILY;
+  const minFontSize = options.minCjkFontSize === false ? void 0 : options.minCjkFontSize ?? DEFAULT_MIN_CJK_FONT_SIZE;
+  return {
+    ...fontFamily === void 0 ? {} : { fontFamily },
+    ...minFontSize === void 0 ? {} : { minFontSize }
+  };
+}
+function enhanceNodeCjkTypography(node, options, diagnostics) {
+  const nodeWithStyle = enhanceStyledLabelOwner(
+    node,
+    ["nodes", node.id],
+    options,
+    diagnostics
+  );
+  const ports = nodeWithStyle.ports === void 0 ? void 0 : nodeWithStyle.ports.map(
+    (port) => enhanceStyledLabelOwner(
+      port,
+      ["nodes", node.id, "ports", port.id],
+      options,
+      diagnostics
+    )
+  );
+  return ports === void 0 ? nodeWithStyle : { ...nodeWithStyle, ports };
+}
+function enhanceEdgeCjkTypography(edge, options, diagnostics) {
+  return enhanceStyledLabelOwner(
+    edge,
+    ["edges", edge.id],
+    options,
+    diagnostics
+  );
+}
+function enhanceGroupCjkTypography(group, options, diagnostics) {
+  return enhanceStyledLabelOwner(
+    group,
+    ["groups", group.id],
+    options,
+    diagnostics
+  );
+}
+function enhanceSwimlaneCjkTypography(swimlane, options, diagnostics) {
+  const root = enhanceStyledLabelOwner(
+    swimlane,
+    ["swimlanes", swimlane.id],
+    options,
+    diagnostics
+  );
+  const lanes = root.lanes.map(
+    (lane) => enhanceSwimlaneLaneCjkTypography(swimlane.id, lane, options, diagnostics)
+  );
+  return { ...root, lanes };
+}
+function enhanceSwimlaneLaneCjkTypography(swimlaneId, lane, options, diagnostics) {
+  return enhanceStyledLabelOwner(
+    lane,
+    ["swimlanes", swimlaneId, "lanes", lane.id],
+    options,
+    diagnostics
+  );
+}
+function enhanceStyledLabelOwner(owner, path, options, diagnostics) {
+  const text = owner.label?.text;
+  if (text === void 0 || !containsCjk(text)) {
+    return owner;
+  }
+  const typography = cjkTypographyForOwner(owner, options);
+  if (typography.fontFamily === void 0 && typography.fontSize === void 0) {
+    return owner;
+  }
+  const label = owner.label;
+  if (label === void 0) {
+    return owner;
+  }
+  const nextLabel = {
+    ...label,
+    metadata: {
+      ...metadataObject(label.metadata),
+      cjkTypography: typography
+    }
+  };
+  const nextOwner = { ...owner, label: nextLabel };
+  const maybeStyled = nextOwner;
+  const nextStyle = enhanceCjkStyle(maybeStyled.style, typography);
+  reportCjkTypographyDiagnostics(
+    path,
+    typography,
+    maybeStyled.style,
+    diagnostics
+  );
+  return nextStyle === maybeStyled.style ? nextOwner : { ...nextOwner, style: nextStyle };
+}
+function cjkTypographyForOwner(owner, options) {
+  const metadataTypography = labelCjkTypography(owner.label?.metadata);
+  const fontFamily = metadataTypography.fontFamily ?? owner.style?.fontFamily ?? options.fontFamily;
+  const fontSize = boostedCjkFontSize(
+    metadataTypography.fontSize ?? owner.style?.fontSize,
+    options.minFontSize
+  );
+  return {
+    ...fontFamily === void 0 ? {} : { fontFamily },
+    ...fontSize === void 0 ? {} : { fontSize }
+  };
+}
+function labelCjkTypography(metadata) {
+  const metadataRecord = metadataObject(metadata);
+  if (metadataRecord === void 0) {
+    return {};
+  }
+  const value = metadataRecord.cjkTypography;
+  if (value === void 0 || value === null || typeof value !== "object") {
+    return {};
+  }
+  const typography = value;
+  const fontFamily = typeof typography.fontFamily === "string" ? typography.fontFamily : void 0;
+  const fontSize = typeof typography.fontSize === "number" && Number.isFinite(typography.fontSize) && typography.fontSize > 0 ? typography.fontSize : void 0;
+  return {
+    ...fontFamily === void 0 ? {} : { fontFamily },
+    ...fontSize === void 0 ? {} : { fontSize }
+  };
+}
+function metadataObject(metadata) {
+  if (metadata === void 0 || metadata === null || typeof metadata !== "object" || Array.isArray(metadata)) {
+    return void 0;
+  }
+  return metadata;
+}
+function typographyForLabel(label) {
+  return labelCjkTypography(label?.metadata);
+}
+function typographyTextStyle(label, base) {
+  const typography = typographyForLabel(label);
+  return {
+    ...base,
+    ...typography.fontFamily === void 0 ? {} : { fontFamily: typography.fontFamily },
+    ...typography.fontSize === void 0 ? {} : {
+      fontSize: typography.fontSize,
+      lineHeight: Math.max(base.lineHeight ?? 0, typography.fontSize * 1.2)
+    }
+  };
+}
+function boostedCjkFontSize(current, minFontSize) {
+  if (minFontSize === void 0) {
+    return current;
+  }
+  if (current === void 0 || current < minFontSize) {
+    return minFontSize;
+  }
+  return current;
+}
+function enhanceCjkStyle(style2, typography) {
+  let next = style2;
+  if (typography.fontFamily !== void 0 && next?.fontFamily === void 0) {
+    next = { ...next, fontFamily: typography.fontFamily };
+  }
+  if (typography.fontSize !== void 0 && (next?.fontSize === void 0 || next.fontSize < typography.fontSize)) {
+    next = { ...next, fontSize: typography.fontSize };
+  }
+  return next;
+}
+function reportCjkTypographyDiagnostics(path, typography, previousStyle, diagnostics) {
+  if (typography.fontFamily !== void 0 && previousStyle?.fontFamily === void 0) {
+    diagnostics.push({
+      severity: "info",
+      code: "cjk_font_family_applied",
+      message: `Applied CJK font family ${typography.fontFamily}.`,
+      path: [...path, "label", "metadata", "cjkTypography", "fontFamily"],
+      detail: { fontFamily: typography.fontFamily }
+    });
+  }
+  if (typography.fontSize !== void 0 && (previousStyle?.fontSize === void 0 || previousStyle.fontSize < typography.fontSize)) {
+    diagnostics.push({
+      severity: "info",
+      code: "cjk_font_size_boosted",
+      message: `Raised CJK font size to ${typography.fontSize}.`,
+      path: [...path, "label", "metadata", "cjkTypography", "fontSize"],
+      detail: {
+        minFontSize: typography.fontSize,
+        ...previousStyle?.fontSize === void 0 ? {} : { previousFontSize: previousStyle.fontSize }
+      }
+    });
+  }
+}
+function containsCjk(value) {
+  return /[\u3400-\u4dbf\u4e00-\u9fff\uf900-\ufaff]/u.test(value);
+}
+function applySwimlaneLayoutContracts(swimlanes, constraints, edges, topToBottomFlow, nodeBoxes, locks, overlapSpacing, laneGutter) {
+  const layouts = /* @__PURE__ */ new Map();
+  const diagnostics = [];
+  const movedChildIds = /* @__PURE__ */ new Set();
+  for (const swimlane of swimlanes) {
+    if ((swimlane.layout ?? "overlay") !== "contract") {
+      continue;
+    }
+    if (swimlane.lanes.length === 0) {
+      continue;
+    }
+    const layout2 = applySingleSwimlaneContract(
+      swimlane,
+      edges,
+      topToBottomFlow,
+      nodeBoxes,
+      locks,
+      diagnostics,
+      movedChildIds,
+      laneGutter
+    );
+    if (layout2 !== void 0) {
+      layouts.set(swimlane.id, layout2);
+    }
+  }
+  if (layouts.size > 0) {
+    diagnostics.push(
+      ...reportSwimlaneOverlaps(nodeBoxes, locks, overlapSpacing),
+      ...reportSwimlaneConstraintInvalidations(
+        constraints,
+        nodeBoxes,
+        movedChildIds
+      )
+    );
+    if (laneGutter > 0) {
+      diagnostics.push({
+        severity: "info",
+        code: "lane_gutter_applied",
+        message: `Applied ${laneGutter}px gutter between ${layouts.size} contract swimlane lane(s).`,
+        path: ["swimlanes"],
+        detail: { laneGutter, swimlaneCount: layouts.size }
+      });
+    }
+  }
+  return { layouts, diagnostics, movedChildIds };
+}
+function wrapVerticalStackIfNeeded(boxes, nodes, edges, direction, options, diagnostics) {
+  const wrapped = new Map([...boxes].map(([id, box]) => [id, { ...box }]));
+  const maxStackDepth = options.maxStackDepth;
+  if (maxStackDepth === void 0 || maxStackDepth <= 0 || nodes.length <= maxStackDepth) {
+    reportVerticalRunaway(
+      wrapped,
+      nodes,
+      edges,
+      direction,
+      options,
+      diagnostics
+    );
+    return wrapped;
+  }
+  if (edges.length > 0 || !isVerticalRunaway(wrapped, nodes, direction, options)) {
+    reportVerticalRunaway(
+      wrapped,
+      nodes,
+      edges,
+      direction,
+      options,
+      diagnostics
+    );
+    return wrapped;
+  }
+  const ordered = nodes.map((node) => ({ node, box: wrapped.get(node.id) })).filter(
+    (item) => item.box !== void 0
+  ).sort((a, b) => {
+    const delta = a.box.y - b.box.y;
+    return delta === 0 ? a.node.id.localeCompare(b.node.id) : delta;
+  });
+  const columns = Math.ceil(ordered.length / maxStackDepth);
+  const horizontalGap = options.overlapSpacing ?? 40;
+  const verticalGap = Math.max(24, horizontalGap / 2);
+  const columnWidths = Array.from(
+    { length: columns },
+    (_, column) => Math.max(
+      0,
+      ...ordered.slice(column * maxStackDepth, (column + 1) * maxStackDepth).map((item) => item.box.width)
+    )
+  );
+  const startX = Math.min(...ordered.map((item) => item.box.x));
+  const startY = Math.min(...ordered.map((item) => item.box.y));
+  let columnX = startX;
+  for (let column = 0; column < columns; column += 1) {
+    let y = startY;
+    const items = ordered.slice(
+      column * maxStackDepth,
+      (column + 1) * maxStackDepth
+    );
+    for (const item of items) {
+      wrapped.set(item.node.id, { ...item.box, x: columnX, y });
+      y += item.box.height + verticalGap;
+    }
+    columnX += (columnWidths[column] ?? 0) + horizontalGap;
+  }
+  diagnostics.push({
+    severity: "warning",
+    code: "vertical_runaway",
+    message: `Single-column layout exceeded maxStackDepth ${maxStackDepth}; wrapped into ${columns} columns.`,
+    path: ["nodes"],
+    detail: { nodeCount: ordered.length, maxStackDepth, columns }
+  });
+  return wrapped;
+}
+function reportVerticalRunaway(boxes, nodes, edges, direction, options, diagnostics) {
+  if (!isVerticalRunaway(boxes, nodes, direction, options)) {
+    return;
+  }
+  diagnostics.push({
+    severity: "warning",
+    code: "vertical_runaway",
+    message: "Layout produced a tall vertical stack beyond the preferred aspect ratio.",
+    path: ["nodes"],
+    detail: {
+      nodeCount: nodes.length,
+      edgeCount: edges.length,
+      ...options.preferredAspectRatio === void 0 ? {} : { preferredAspectRatio: options.preferredAspectRatio },
+      ...options.maxStackDepth === void 0 ? {} : { maxStackDepth: options.maxStackDepth }
+    }
+  });
+}
+function isVerticalRunaway(boxes, nodes, direction, options) {
+  if (options.maxStackDepth === void 0 && options.preferredAspectRatio === void 0) {
+    return false;
+  }
+  if (nodes.length < 2 || direction !== "LR" && direction !== "RL") {
+    return false;
+  }
+  const nodeBoxes = nodes.map((node) => boxes.get(node.id)).filter((box) => box !== void 0);
+  if (nodeBoxes.length < 2) {
+    return false;
+  }
+  const bounds = unionBoxes(nodeBoxes);
+  const aspectRatio = bounds.width <= 0 ? Number.POSITIVE_INFINITY : bounds.height / bounds.width;
+  const preferred = options.preferredAspectRatio ?? 3;
+  if (aspectRatio < preferred) {
+    return false;
+  }
+  const xCenters = nodeBoxes.map((box) => box.x + box.width / 2);
+  const xSpread = Math.max(...xCenters) - Math.min(...xCenters);
+  const maxWidth = Math.max(...nodeBoxes.map((box) => box.width));
+  return xSpread <= Math.max(maxWidth, options.overlapSpacing ?? 40);
+}
+function applySingleSwimlaneContract(swimlane, edges, topToBottomFlow, nodeBoxes, locks, diagnostics, movedChildIds, laneGutter) {
+  const headerHeight = swimlane.headerHeight ?? 28;
+  const padding = swimlane.padding ?? 16;
+  const laneBounds = swimlane.lanes.map((lane) => {
+    const childBoxes = lane.children.map((child) => nodeBoxes.get(child)).filter((box) => box !== void 0);
+    return childBoxes.length === 0 ? void 0 : unionBoxes(childBoxes);
+  });
+  const populatedBounds = laneBounds.filter(
+    (box) => box !== void 0
+  );
+  if (populatedBounds.length === 0) {
+    return void 0;
+  }
+  if (swimlane.orientation === "vertical") {
+    return applyVerticalSwimlaneContract(
+      swimlane,
+      edges,
+      topToBottomFlow,
+      nodeBoxes,
+      laneBounds,
+      headerHeight,
+      padding,
+      locks,
+      diagnostics,
+      movedChildIds,
+      laneGutter
+    );
+  }
+  return applyHorizontalSwimlaneContract(
+    swimlane,
+    nodeBoxes,
+    laneBounds,
+    headerHeight,
+    padding,
+    locks,
+    diagnostics,
+    movedChildIds,
+    laneGutter
+  );
+}
+function applyVerticalSwimlaneContract(swimlane, edges, topToBottomFlow, nodeBoxes, laneBounds, headerHeight, padding, locks, diagnostics, movedChildIds, laneGutter) {
+  const populatedBounds = laneBounds.filter(
+    (box) => box !== void 0
+  );
+  const top = Math.min(...populatedBounds.map((box) => box.y));
+  const left = Math.min(...populatedBounds.map((box) => box.x));
+  const maxChildHeight = Math.max(...populatedBounds.map((box) => box.height));
+  const flowRanks = topToBottomFlow ? rankVerticalSwimlaneChildren(swimlane, edges) : /* @__PURE__ */ new Map();
+  const maxRank = flowRanks.size === 0 ? 0 : Math.max(...Array.from(flowRanks.values()));
+  const rankStackGap = Math.max(8, padding / 2);
+  const maxRankStackHeight = maxVerticalRankStackHeight(
+    swimlane,
+    nodeBoxes,
+    flowRanks,
+    rankStackGap
+  );
+  const rankSpacing = Math.max(96, maxRankStackHeight + padding);
+  const contentHeight = maxRank === 0 ? maxChildHeight : maxRankStackHeight + maxRank * rankSpacing;
+  const slotWidth = Math.max(...populatedBounds.map((box) => box.width)) + padding * 2;
+  const laneStep = slotWidth + laneGutter;
+  const laneContentTop = top + headerHeight + padding;
+  for (let index = 0; index < swimlane.lanes.length; index += 1) {
+    const lane = swimlane.lanes[index];
+    const bounds = laneBounds[index];
+    if (lane === void 0 || bounds === void 0) {
+      continue;
+    }
+    const target = {
+      x: left + laneStep * index + padding,
+      y: laneContentTop
+    };
+    if (maxRank === 0) {
+      moveLaneChildren(
+        lane.children,
+        nodeBoxes,
+        locks,
+        diagnostics,
+        movedChildIds,
+        {
+          x: target.x - bounds.x,
+          y: target.y - bounds.y
+        }
+      );
+      continue;
+    }
+    moveRankedVerticalLaneChildren(
+      lane.children,
+      nodeBoxes,
+      locks,
+      diagnostics,
+      movedChildIds,
+      flowRanks,
+      rankSpacing,
+      rankStackGap,
+      {
+        x: target.x - bounds.x,
+        y: laneContentTop
+      }
+    );
+  }
+  return {
+    box: {
+      x: left,
+      y: top,
+      width: laneStep * (swimlane.lanes.length - 1) + slotWidth,
+      height: contentHeight + padding * 2 + headerHeight
+    },
+    slotWidth,
+    slotHeight: contentHeight + padding * 2 + headerHeight,
+    laneStep
+  };
+}
+function isTopToBottomReadingDirection(value) {
+  return value === "top_to_bottom" || value === "top-to-bottom";
+}
+function rankVerticalSwimlaneChildren(swimlane, edges) {
+  const childOrder = /* @__PURE__ */ new Map();
+  for (const lane of swimlane.lanes) {
+    for (const childId of lane.children) {
+      if (!childOrder.has(childId)) {
+        childOrder.set(childId, childOrder.size);
+      }
+    }
+  }
+  if (childOrder.size === 0) {
+    return /* @__PURE__ */ new Map();
+  }
+  const childIds = new Set(childOrder.keys());
+  const relevantEdges = edges.filter(
+    (edge) => childIds.has(edge.source.nodeId) && childIds.has(edge.target.nodeId) && edge.source.nodeId !== edge.target.nodeId
+  );
+  if (relevantEdges.length === 0) {
+    return /* @__PURE__ */ new Map();
+  }
+  const ranks = new Map([...childIds].map((id) => [id, 0]));
+  const outgoing = /* @__PURE__ */ new Map();
+  const inDegree = new Map([...childIds].map((id) => [id, 0]));
+  for (const edge of relevantEdges) {
+    const targets = outgoing.get(edge.source.nodeId) ?? [];
+    targets.push(edge.target.nodeId);
+    outgoing.set(edge.source.nodeId, targets);
+    inDegree.set(
+      edge.target.nodeId,
+      (inDegree.get(edge.target.nodeId) ?? 0) + 1
+    );
+  }
+  const queue = [...childIds].filter((id) => (inDegree.get(id) ?? 0) === 0).sort((a, b) => (childOrder.get(a) ?? 0) - (childOrder.get(b) ?? 0));
+  let visited = 0;
+  for (let cursor = 0; cursor < queue.length; cursor += 1) {
+    const sourceId = queue[cursor];
+    if (sourceId === void 0) {
+      continue;
+    }
+    visited += 1;
+    for (const targetId of outgoing.get(sourceId) ?? []) {
+      ranks.set(
+        targetId,
+        Math.max(ranks.get(targetId) ?? 0, (ranks.get(sourceId) ?? 0) + 1)
+      );
+      const nextInDegree = (inDegree.get(targetId) ?? 0) - 1;
+      inDegree.set(targetId, nextInDegree);
+      if (nextInDegree === 0) {
+        queue.push(targetId);
+      }
+    }
+  }
+  return visited === childIds.size ? ranks : rankCyclicSwimlaneChildren(childIds, relevantEdges);
+}
+function rankCyclicSwimlaneChildren(childIds, edges) {
+  const maxRank = Math.max(0, childIds.size - 1);
+  const ranks = new Map([...childIds].map((id) => [id, 0]));
+  for (let iteration = 0; iteration < childIds.size; iteration += 1) {
+    let changed = false;
+    for (const edge of edges) {
+      const nextRank = Math.min(
+        maxRank,
+        (ranks.get(edge.source.nodeId) ?? 0) + 1
+      );
+      if (nextRank > (ranks.get(edge.target.nodeId) ?? 0)) {
+        ranks.set(edge.target.nodeId, nextRank);
+        changed = true;
+      }
+    }
+    if (!changed) {
+      break;
+    }
+  }
+  return ranks;
+}
+function maxVerticalRankStackHeight(swimlane, nodeBoxes, flowRanks, gap) {
+  let maxHeight = 0;
+  for (const lane of swimlane.lanes) {
+    for (const stack of rankStacks(
+      lane.children,
+      nodeBoxes,
+      flowRanks
+    ).values()) {
+      const height = stack.reduce(
+        (total, item, index) => total + item.box.height + (index === 0 ? 0 : gap),
+        0
+      );
+      maxHeight = Math.max(maxHeight, height);
+    }
+  }
+  return maxHeight;
+}
+function moveRankedVerticalLaneChildren(childIds, nodeBoxes, locks, diagnostics, movedChildIds, flowRanks, rankSpacing, rankStackGap, target) {
+  for (const [rank, stack] of rankStacks(childIds, nodeBoxes, flowRanks)) {
+    let yOffset = 0;
+    for (const item of stack) {
+      const { childId, box } = item;
+      if (locks.has(childId)) {
+        diagnostics.push({
+          severity: "warning",
+          code: "constraints.locked-target-not-moved",
+          message: `Locked child ${childId} was not moved into contract swimlane slot.`,
+          path: ["swimlanes"],
+          detail: { nodeId: childId }
+        });
+        continue;
+      }
+      const next = {
+        ...box,
+        x: box.x + target.x,
+        y: target.y + rank * rankSpacing + yOffset
+      };
+      if (next.x !== box.x || next.y !== box.y) {
+        movedChildIds.add(childId);
+      }
+      nodeBoxes.set(childId, next);
+      yOffset += box.height + rankStackGap;
+    }
+  }
+}
+function rankStacks(childIds, nodeBoxes, flowRanks) {
+  const stacks = /* @__PURE__ */ new Map();
+  for (const childId of childIds) {
+    const box = nodeBoxes.get(childId);
+    if (box === void 0) {
+      continue;
+    }
+    const rank = flowRanks.get(childId) ?? 0;
+    const stack = stacks.get(rank) ?? [];
+    stack.push({ childId, box });
+    stacks.set(rank, stack);
+  }
+  for (const stack of stacks.values()) {
+    stack.sort((a, b) => {
+      const deltaY = a.box.y - b.box.y;
+      return deltaY === 0 ? a.childId.localeCompare(b.childId) : deltaY;
+    });
+  }
+  return stacks;
+}
+function applyHorizontalSwimlaneContract(swimlane, nodeBoxes, laneBounds, headerHeight, padding, locks, diagnostics, movedChildIds, laneGutter) {
+  const populatedBounds = laneBounds.filter(
+    (box) => box !== void 0
+  );
+  const top = Math.min(...populatedBounds.map((box) => box.y));
+  const left = Math.min(...populatedBounds.map((box) => box.x));
+  const slotWidth = Math.max(...populatedBounds.map((box) => box.width)) + headerHeight + padding * 2;
+  const slotHeight = Math.max(...populatedBounds.map((box) => box.height)) + padding * 2;
+  const laneStep = slotHeight + laneGutter;
+  for (let index = 0; index < swimlane.lanes.length; index += 1) {
+    const lane = swimlane.lanes[index];
+    const bounds = laneBounds[index];
+    if (lane === void 0 || bounds === void 0) {
+      continue;
+    }
+    const target = {
+      x: left + headerHeight + padding,
+      y: top + laneStep * index + padding
+    };
+    moveLaneChildren(
+      lane.children,
+      nodeBoxes,
+      locks,
+      diagnostics,
+      movedChildIds,
+      {
+        x: target.x - bounds.x,
+        y: target.y - bounds.y
+      }
+    );
+  }
+  return {
+    box: {
+      x: left,
+      y: top,
+      width: slotWidth,
+      height: laneStep * (swimlane.lanes.length - 1) + slotHeight
+    },
+    slotWidth,
+    slotHeight,
+    laneStep
+  };
+}
+function moveLaneChildren(childIds, nodeBoxes, locks, diagnostics, movedChildIds, offset) {
+  for (const childId of childIds) {
+    const box = nodeBoxes.get(childId);
+    if (box === void 0) {
+      continue;
+    }
+    if (locks.has(childId)) {
+      diagnostics.push({
+        severity: "warning",
+        code: "constraints.locked-target-not-moved",
+        message: `Locked child ${childId} was not moved into contract swimlane slot.`,
+        path: ["swimlanes"],
+        detail: { nodeId: childId }
+      });
+      continue;
+    }
+    if (offset.x !== 0 || offset.y !== 0) {
+      movedChildIds.add(childId);
+    }
+    nodeBoxes.set(childId, {
+      ...box,
+      x: box.x + offset.x,
+      y: box.y + offset.y
+    });
+  }
+}
+function removeResolvedOverlapDiagnostics(diagnostics, nodeBoxes) {
+  for (let index = diagnostics.length - 1; index >= 0; index -= 1) {
+    const diagnostic = diagnostics[index];
+    if (diagnostic?.code !== "constraints.overlap.unresolved") {
+      continue;
+    }
+    const firstId = detailString(diagnostic, "firstId");
+    const secondId = detailString(diagnostic, "secondId");
+    const first = firstId === void 0 ? void 0 : nodeBoxes.get(firstId);
+    const second = secondId === void 0 ? void 0 : nodeBoxes.get(secondId);
+    if (first !== void 0 && second !== void 0 && !intersectsAabb(first, second)) {
+      diagnostics.splice(index, 1);
+    }
+  }
+}
+function reportSwimlaneConstraintInvalidations(constraints, nodeBoxes, movedChildIds) {
+  const diagnostics = [];
+  for (const constraint of constraints) {
+    const invalidatedNodeIds = movedConstraintNodeIds(
+      constraint,
+      nodeBoxes,
+      movedChildIds
+    );
+    if (invalidatedNodeIds.length === 0) {
+      continue;
+    }
+    diagnostics.push({
+      severity: "warning",
+      code: "constraints.swimlane-contract.invalidated",
+      message: `Contract swimlane placement moved node(s) after ${constraint.kind} constraint solving; final geometry no longer satisfies that constraint.`,
+      path: ["swimlanes"],
+      detail: {
+        constraintKind: constraint.kind,
+        ...constraint.id === void 0 ? {} : { constraintId: constraint.id },
+        nodeIds: invalidatedNodeIds
+      }
+    });
+  }
+  return diagnostics;
+}
+function movedConstraintNodeIds(constraint, nodeBoxes, movedChildIds) {
+  switch (constraint.kind) {
+    case "exact-position":
+      return [];
+    case "containment":
+      return movedContainmentViolations(constraint, nodeBoxes, movedChildIds);
+    case "relative-position":
+      return movedRelativeViolations(constraint, nodeBoxes, movedChildIds);
+    case "align":
+      return movedAlignViolations(constraint, nodeBoxes, movedChildIds);
+    case "distribute":
+      return movedDistributeViolations(constraint, nodeBoxes, movedChildIds);
+  }
+}
+function movedContainmentViolations(constraint, nodeBoxes, movedChildIds) {
+  const container = nodeBoxes.get(constraint.containerId);
+  if (container === void 0) {
+    return [];
+  }
+  const content = paddedContentBox(container, constraint.padding);
+  return constraint.childIds.filter((childId) => {
+    if (!movedChildIds.has(childId)) {
+      return false;
+    }
+    const child = nodeBoxes.get(childId);
+    return child !== void 0 && !boxInside(child, content);
+  });
+}
+function movedRelativeViolations(constraint, nodeBoxes, movedChildIds) {
+  if (!movedChildIds.has(constraint.sourceId) && !movedChildIds.has(constraint.referenceId)) {
+    return [];
+  }
+  const source = nodeBoxes.get(constraint.sourceId);
+  const reference = nodeBoxes.get(constraint.referenceId);
+  if (source === void 0 || reference === void 0) {
+    return [];
+  }
+  return sameBoxPosition(
+    source,
+    expectedRelativeBox(source, reference, constraint)
+  ) ? [] : [constraint.sourceId];
+}
+function movedAlignViolations(constraint, nodeBoxes, movedChildIds) {
+  if (!constraint.targetIds.some((id) => movedChildIds.has(id))) {
+    return [];
+  }
+  const targets = constraint.targetIds.map((id) => ({ id, box: nodeBoxes.get(id) })).filter(
+    (target) => target.box !== void 0
+  );
+  const anchor = targets[0];
+  if (anchor === void 0) {
+    return [];
+  }
+  const expected = alignmentValue2(anchor.box, constraint.axis);
+  return targets.filter(
+    (target) => movedChildIds.has(target.id) && !sameNumber(alignmentValue2(target.box, constraint.axis), expected)
+  ).map((target) => target.id);
+}
+function movedDistributeViolations(constraint, nodeBoxes, movedChildIds) {
+  if (!constraint.targetIds.some((id) => movedChildIds.has(id))) {
+    return [];
+  }
+  const targets = constraint.targetIds.map((id) => ({ id, box: nodeBoxes.get(id) })).filter(
+    (target) => target.box !== void 0
+  ).sort((a, b) => {
+    const delta = constraint.axis === "horizontal" ? a.box.x - b.box.x : a.box.y - b.box.y;
+    return delta === 0 ? a.id.localeCompare(b.id) : delta;
+  });
+  if (targets.length < 3) {
+    return [];
+  }
+  const first = targets[0];
+  const last = targets.at(-1);
+  if (first === void 0 || last === void 0) {
+    return [];
+  }
+  const expectedSpacing = constraint.spacing ?? (distributionStart2(last.box, constraint.axis) - distributionStart2(first.box, constraint.axis)) / (targets.length - 1);
+  return targets.slice(1).filter((target, index) => {
+    const previous = targets[index];
+    if (previous === void 0 || !movedChildIds.has(target.id)) {
+      return false;
+    }
+    return !sameNumber(
+      distributionStart2(target.box, constraint.axis) - distributionStart2(previous.box, constraint.axis),
+      expectedSpacing
+    );
+  }).map((target) => target.id);
+}
+function expectedRelativeBox(source, reference, constraint) {
+  const offset = constraint.offset ?? { x: 0, y: 0 };
+  switch (constraint.relation) {
+    case "above":
+      return {
+        ...source,
+        x: reference.x + offset.x,
+        y: reference.y - source.height + offset.y
+      };
+    case "right-of":
+      return {
+        ...source,
+        x: reference.x + reference.width + offset.x,
+        y: reference.y + offset.y
+      };
+    case "below":
+      return {
+        ...source,
+        x: reference.x + offset.x,
+        y: reference.y + reference.height + offset.y
+      };
+    case "left-of":
+      return {
+        ...source,
+        x: reference.x - source.width + offset.x,
+        y: reference.y + offset.y
+      };
+  }
+}
+function paddedContentBox(container, padding) {
+  const margin = padding ?? { top: 0, right: 0, bottom: 0, left: 0 };
+  return {
+    x: container.x + margin.left,
+    y: container.y + margin.top,
+    width: container.width - margin.left - margin.right,
+    height: container.height - margin.top - margin.bottom
+  };
+}
+function boxInside(child, container) {
+  return child.x >= container.x && child.y >= container.y && child.x + child.width <= container.x + container.width && child.y + child.height <= container.y + container.height;
+}
+function sameBoxPosition(first, second) {
+  return sameNumber(first.x, second.x) && sameNumber(first.y, second.y);
+}
+function sameNumber(first, second) {
+  return Math.abs(first - second) < 1e-3;
+}
+function alignmentValue2(box, axis) {
+  switch (axis) {
+    case "x":
+    case "left":
+      return box.x;
+    case "y":
+    case "top":
+      return box.y;
+    case "center-x":
+      return box.x + box.width / 2;
+    case "center-y":
+      return box.y + box.height / 2;
+    case "right":
+      return box.x + box.width;
+    case "bottom":
+      return box.y + box.height;
+  }
+}
+function distributionStart2(box, axis) {
+  return axis === "horizontal" ? box.x : box.y;
+}
+function detailString(diagnostic, key) {
+  const value = diagnostic.detail?.[key];
+  return typeof value === "string" ? value : void 0;
+}
+function reportSwimlaneOverlaps(nodeBoxes, locks, overlapSpacing) {
+  const diagnostics = [];
+  const ids = [...nodeBoxes.keys()].sort();
+  for (const firstId of ids) {
+    for (const secondId of ids) {
+      if (firstId >= secondId) {
+        continue;
+      }
+      const first = nodeBoxes.get(firstId);
+      const second = nodeBoxes.get(secondId);
+      if (first === void 0 || second === void 0) {
+        continue;
+      }
+      if (!intersectsAabb(first, second)) {
+        continue;
+      }
+      diagnostics.push({
+        severity: "warning",
+        code: "constraints.overlap.unresolved",
+        message: `Boxes ${firstId} and ${secondId} still overlap after contract swimlane placement with configured spacing ${overlapSpacing}.`,
+        path: ["swimlanes"],
+        detail: {
+          firstId,
+          secondId,
+          firstLocked: locks.has(firstId),
+          secondLocked: locks.has(secondId)
+        }
+      });
+    }
+  }
+  return diagnostics;
+}
+function coordinateNodes(nodes, boxes, options, diagnostics) {
+  const coordinated = [];
+  for (const node of nodes) {
+    const box = boxes.get(node.id);
+    if (box === void 0) {
+      diagnostics.push({
+        severity: "error",
+        code: "solver.node-box.missing",
+        message: `Node ${node.id} has no solved box.`,
+        path: ["nodes", node.id],
+        detail: { nodeId: node.id }
+      });
+      continue;
+    }
+    const geometry = computeShapeGeometry({
+      shape: node.shape,
+      box,
+      obstacleMargin: options.obstacleMargin ?? 0
+    });
+    coordinated.push({
+      id: node.id,
+      ...node.label === void 0 ? {} : { label: node.label },
+      ...node.style === void 0 ? {} : { style: node.style },
+      ...node.ports === void 0 ? {} : { ports: coordinatePorts(node, box, options.portShifting) },
       ...node.compartments === void 0 ? {} : { compartments: node.compartments },
       ...node.labelLayout === void 0 ? {} : { labelLayout: node.labelLayout },
       shape: node.shape,
@@ -3068,7 +5875,10 @@ function coordinatePorts(node, nodeBox, portShifting) {
 }
 function portAnchor(nodeBox, side, index, count, portShifting) {
   const shiftingEnabled = portShifting?.enabled ?? true;
-  const spacing = portShifting?.spacing ?? 24;
+  const requestedSpacing = portShifting?.spacing ?? 24;
+  const maxOffset = side === "left" || side === "right" ? nodeBox.height / 2 : nodeBox.width / 2;
+  const availableSpan = 2 * maxOffset;
+  const spacing = shiftingEnabled && count > 1 ? Math.min(requestedSpacing, availableSpan / (count - 1)) : requestedSpacing;
   const centeredOffset = shiftingEnabled ? (index - (count - 1) / 2) * spacing : 0;
   switch (side) {
     case "left":
@@ -3114,16 +5924,70 @@ function portLabelBox(port) {
     height
   };
 }
-function coordinateSwimlanes(swimlanes, nodeBoxes) {
-  const titleSize = 28;
-  const padding = 16;
+function coordinateSwimlanes(swimlanes, nodeBoxes, layouts) {
   return swimlanes.map((swimlane) => {
-    const laneBoxes = swimlane.lanes.flatMap((lane) => {
+    const layout2 = swimlane.layout ?? "overlay";
+    const headerHeight = swimlane.headerHeight ?? 28;
+    const padding = swimlane.padding ?? 16;
+    const contractLayout = layouts.get(swimlane.id);
+    if (layout2 === "contract" && contractLayout !== void 0) {
+      const lanes2 = swimlane.lanes.map((lane, index) => {
+        const box = swimlane.orientation === "vertical" ? {
+          x: contractLayout.box.x + contractLayout.laneStep * index,
+          y: contractLayout.box.y,
+          width: contractLayout.slotWidth,
+          height: contractLayout.box.height
+        } : {
+          x: contractLayout.box.x,
+          y: contractLayout.box.y + contractLayout.laneStep * index,
+          width: contractLayout.box.width,
+          height: contractLayout.slotHeight
+        };
+        const headerBox = swimlane.orientation === "vertical" ? {
+          x: box.x,
+          y: box.y,
+          width: box.width,
+          height: headerHeight
+        } : {
+          x: box.x,
+          y: box.y,
+          width: headerHeight,
+          height: box.height
+        };
+        const contentBox2 = swimlane.orientation === "vertical" ? {
+          x: box.x,
+          y: box.y + headerHeight,
+          width: box.width,
+          height: Math.max(0, box.height - headerHeight)
+        } : {
+          x: box.x + headerHeight,
+          y: box.y,
+          width: Math.max(0, box.width - headerHeight),
+          height: box.height
+        };
+        return {
+          ...lane,
+          box,
+          headerBox,
+          contentBox: contentBox2
+        };
+      });
+      return {
+        ...swimlane,
+        lanes: lanes2,
+        box: contractLayout.box,
+        ...headerHeight === void 0 ? {} : { headerHeight },
+        ...padding === void 0 ? {} : { padding }
+      };
+    }
+    const laneContentBoxes = swimlane.lanes.map((lane) => {
       const childBoxes = lane.children.map((child) => nodeBoxes.get(child)).filter((box) => box !== void 0);
-      return childBoxes.length === 0 ? [] : [unionBoxes(childBoxes)];
+      return childBoxes.length === 0 ? void 0 : unionBoxes(childBoxes);
     });
-    const laneUnion = laneBoxes.length === 0 ? { x: 0, y: 0, width: 120, height: 80 } : unionBoxes(laneBoxes);
-    const outer = expand(laneUnion, padding, titleSize);
+    const laneUnion = laneContentBoxes.filter((box) => box !== void 0).length === 0 ? { x: 0, y: 0, width: 120, height: 80 } : unionBoxes(
+      laneContentBoxes.filter((box) => box !== void 0)
+    );
+    const outer = expand(laneUnion, padding, headerHeight);
     const laneCount = Math.max(1, swimlane.lanes.length);
     const lanes = swimlane.lanes.map((lane, index) => {
       const box = swimlane.orientation === "vertical" ? {
@@ -3137,23 +6001,58 @@ function coordinateSwimlanes(swimlanes, nodeBoxes) {
         width: outer.width,
         height: outer.height / laneCount
       };
-      return { ...lane, box };
+      const headerBox = layout2 === "contract" ? swimlane.orientation === "vertical" ? {
+        x: box.x,
+        y: box.y,
+        width: box.width,
+        height: headerHeight
+      } : {
+        x: box.x,
+        y: box.y,
+        width: headerHeight,
+        height: box.height
+      } : void 0;
+      const contentBox2 = layout2 === "contract" ? swimlane.orientation === "vertical" ? {
+        x: box.x,
+        y: box.y + headerHeight,
+        width: box.width,
+        height: Math.max(0, box.height - headerHeight)
+      } : {
+        x: box.x + headerHeight,
+        y: box.y,
+        width: Math.max(0, box.width - headerHeight),
+        height: box.height
+      } : void 0;
+      return {
+        ...lane,
+        box,
+        ...headerBox === void 0 ? {} : { headerBox },
+        ...contentBox2 === void 0 ? {} : { contentBox: contentBox2 }
+      };
     });
-    return { ...swimlane, lanes, box: outer };
+    return {
+      ...swimlane,
+      lanes,
+      box: outer,
+      ...headerHeight === void 0 ? {} : { headerHeight },
+      ...padding === void 0 ? {} : { padding }
+    };
   });
 }
 function coordinateFrame(frame, contentBounds) {
-  const padding = 32;
-  const titleHeight = 28;
+  const padding = framePadding(frame.padding);
+  const titleHeight = frame.headerHeight ?? 28;
   const titleWidth = Math.max(180, frame.titleTab.length * 7);
   const box = {
-    x: contentBounds.x - padding,
-    y: contentBounds.y - padding - titleHeight,
-    width: contentBounds.width + padding * 2,
-    height: contentBounds.height + padding * 2 + titleHeight
+    x: contentBounds.x - padding.left,
+    y: contentBounds.y - padding.top - titleHeight,
+    width: contentBounds.width + padding.left + padding.right,
+    height: contentBounds.height + padding.top + padding.bottom + titleHeight
   };
   return {
     ...frame,
+    headerHeight: titleHeight,
+    padding: frame.padding ?? 32,
     box,
     titleBox: {
       x: box.x,
@@ -3163,6 +6062,9 @@ function coordinateFrame(frame, contentBounds) {
     }
   };
 }
+function framePadding(value) {
+  return normalizeInsets(value ?? 32);
+}
 function expand(box, padding, titleSize) {
   return {
     x: box.x - padding,
@@ -3201,25 +6103,397 @@ function coordinateGroups(groups, nodeBoxes, options, diagnostics) {
       if (childBoxes.length === 0) {
         diagnostics.push(groupReferenceMissing(group.id, "child", void 0));
       }
-      continue;
+      continue;
+    }
+    const geometry = computeContainerGeometry({
+      id: group.id,
+      childBoxes,
+      padding: group.padding,
+      ...group.labelLayout === void 0 ? {} : { labelLayout: group.labelLayout },
+      obstacleMargin: options.obstacleMargin ?? 0
+    });
+    groupBoxes.set(group.id, geometry.box);
+    diagnostics.push(...geometry.diagnostics);
+    coordinated.push({
+      ...group,
+      box: geometry.box
+    });
+  }
+  return coordinated;
+}
+function coordinateMatrices(matrices) {
+  return matrices.map((block) => ({
+    ...block,
+    box: blockBox(block, {
+      width: defaultMatrixRowHeaderWidth2(block) + Math.max(1, block.cols.length) * DEFAULT_MATRIX_CELL_SIZE2.width,
+      height: Math.max(1, block.rows.length + 1) * DEFAULT_MATRIX_CELL_SIZE2.height
+    })
+  }));
+}
+function defaultMatrixRowHeaderWidth2(block) {
+  return block.rows.length === 0 ? 0 : Math.min(96, DEFAULT_MATRIX_CELL_SIZE2.width);
+}
+function coordinateTables(tables) {
+  return tables.map((table) => {
+    const box = blockBox(table, {
+      width: Math.max(1, table.columns.length) * DEFAULT_TABLE_CELL_SIZE2.width,
+      height: Math.max(1, table.rows.length + 1) * DEFAULT_TABLE_CELL_SIZE2.height
+    });
+    return {
+      ...table,
+      box,
+      columnXOffsets: columnXOffsets(table, box)
+    };
+  });
+}
+function coordinateEvidencePanels(panels) {
+  return panels.map((block) => ({
+    ...block,
+    box: blockBox(block, {
+      width: DEFAULT_PANEL_WIDTH,
+      height: Math.max(1, block.items.length) * DEFAULT_PANEL_ITEM_HEIGHT2
+    })
+  }));
+}
+function edgeBounds(edges) {
+  return edges.flatMap((edge) => {
+    if (edge.points.length === 0) {
+      return [];
+    }
+    const extraPoints = [];
+    if (edge.points.length >= 2) {
+      const arrowhead = computeArrowhead(edge.points);
+      extraPoints.push(arrowhead.tip, arrowhead.left, arrowhead.right);
+    }
+    const allPoints = [...edge.points, ...extraPoints];
+    const minX = Math.min(...allPoints.map((point2) => point2.x));
+    const minY = Math.min(...allPoints.map((point2) => point2.y));
+    const maxX = Math.max(...allPoints.map((point2) => point2.x));
+    const maxY = Math.max(...allPoints.map((point2) => point2.y));
+    return [
+      {
+        x: minX,
+        y: minY,
+        width: maxX - minX,
+        height: maxY - minY
+      }
+    ];
+  });
+}
+function blockBox(block, defaultSize) {
+  return {
+    x: block.position?.x ?? 0,
+    y: block.position?.y ?? 0,
+    width: block.size?.width ?? defaultSize.width,
+    height: block.size?.height ?? defaultSize.height
+  };
+}
+function placeEvidenceBlocks(obstacleMargin, blocks, contentBounds) {
+  const margin = normalizeInsets(obstacleMargin);
+  const horizontalGap = Math.max(
+    DEFAULT_EVIDENCE_BLOCK_GAP,
+    margin.right + margin.left
+  );
+  const verticalGap = Math.max(
+    DEFAULT_EVIDENCE_BLOCK_GAP,
+    margin.bottom + margin.top
+  );
+  let nextY = contentBounds.y;
+  const x = contentBounds.x + contentBounds.width + horizontalGap;
+  for (const block of blocks) {
+    if (block.position !== void 0) {
+      continue;
+    }
+    block.box.x = x;
+    block.box.y = nextY;
+    nextY += block.box.height + verticalGap;
+  }
+}
+function columnXOffsets(table, box) {
+  if (table.columns.length === 0) {
+    return [];
+  }
+  const columnWidth = box.width / table.columns.length;
+  return table.columns.map((_, index) => box.x + index * columnWidth);
+}
+function tableCellBox2(table, columnIndex, rowIndex, rowHeight, columnCount) {
+  const x = table.columnXOffsets[columnIndex] ?? table.box.x + table.box.width / columnCount * columnIndex;
+  const nextX = table.columnXOffsets[columnIndex + 1] ?? table.box.x + table.box.width;
+  return {
+    x,
+    y: table.box.y + rowIndex * rowHeight,
+    width: nextX - x,
+    height: rowHeight
+  };
+}
+function refreshTableColumnXOffsets(tables) {
+  for (const table of tables) {
+    table.columnXOffsets = columnXOffsets(table, table.box);
+  }
+}
+function measureEvidenceTextBlocks(matrices, tables, panels, textMeasurer) {
+  const measurer = textMeasurer ?? createDefaultTextMeasurer();
+  for (const matrix of matrices) {
+    const geometry = matrixGeometry(matrix);
+    matrix.columnLabelLayouts = matrix.cols.map(
+      (column) => measureEvidenceTextLayout(column, geometry.columnHeaderBox, measurer)
+    );
+    matrix.rowLabelLayouts = matrix.rows.map(
+      (row, index) => measureEvidenceTextLayout(row, geometry.rowHeaderBox(index), measurer)
+    );
+    matrix.cellLabelLayouts = matrix.rows.map(
+      (_, rowIndex) => matrix.cols.map((_2, columnIndex) => {
+        const cell2 = matrix.cells[rowIndex]?.[columnIndex] ?? { text: "" };
+        return measureEvidenceTextLayout(
+          cell2.text,
+          geometry.cellBox(rowIndex, columnIndex),
+          measurer
+        );
+      })
+    );
+  }
+  for (const table of tables) {
+    const rowHeight = table.box.height / Math.max(1, table.rows.length + 1);
+    const columnCount = Math.max(1, table.columns.length);
+    table.columnLabelLayouts = table.columns.map(
+      (column, columnIndex) => measureEvidenceTextLayout(
+        column.label.text,
+        tableCellBox2(table, columnIndex, 0, rowHeight, columnCount),
+        measurer
+      )
+    );
+    table.cellLabelLayouts = table.rows.map(
+      (row, rowIndex) => table.columns.map((column, columnIndex) => {
+        const cell2 = row.cells[column.id] ?? { text: "" };
+        return measureEvidenceTextLayout(
+          cell2.text,
+          tableCellBox2(
+            table,
+            columnIndex,
+            rowIndex + 1,
+            rowHeight,
+            columnCount
+          ),
+          measurer
+        );
+      })
+    );
+  }
+  for (const panel of panels) {
+    const geometry = panelGeometry(panel);
+    panel.titleLayout = measureEvidenceTextLayout(
+      `${panel.kind}: ${panel.id}`,
+      geometry.titleBox,
+      measurer
+    );
+    panel.itemLayouts = panel.items.map(
+      (item, index) => measureEvidenceTextLayout(
+        panelItemText2(item.label.text, item.detail?.text),
+        geometry.itemRowBox(index),
+        measurer
+      )
+    );
+  }
+}
+function measureEvidenceTextLayout(text, box, textMeasurer) {
+  const lineHeight = EVIDENCE_TEXT_FONT.lineHeight;
+  return {
+    lines: wrapEvidenceText(text, {
+      maxWidth: Math.max(0, box.width - 8),
+      maxLines: Math.max(1, Math.floor((box.height - 4) / lineHeight)),
+      textMeasurer
+    })
+  };
+}
+function wrapEvidenceText(text, options) {
+  const normalized = text.trim().replace(/\s+/g, " ");
+  if (normalized.length === 0) {
+    return [""];
+  }
+  const lines = [];
+  let current = "";
+  let overflow = false;
+  for (const word of normalized.split(" ")) {
+    const chunks = chunkEvidenceWord(
+      word,
+      options.maxWidth,
+      options.textMeasurer
+    );
+    for (const chunk of chunks) {
+      const candidate = current.length === 0 ? chunk : `${current} ${chunk}`;
+      if (measureEvidenceText(candidate, options.textMeasurer) <= options.maxWidth) {
+        current = candidate;
+        continue;
+      }
+      if (current.length > 0) {
+        lines.push(current);
+        current = chunk;
+      } else {
+        lines.push(chunk);
+        current = "";
+      }
+      if (lines.length >= options.maxLines) {
+        overflow = true;
+        break;
+      }
+    }
+    if (overflow) {
+      break;
+    }
+  }
+  if (!overflow && current.length > 0) {
+    lines.push(current);
+  }
+  if (lines.length > options.maxLines) {
+    overflow = true;
+    lines.length = options.maxLines;
+  }
+  if (overflow || lines.length === options.maxLines) {
+    const rendered = lines.join(" ");
+    if (rendered.length < normalized.length) {
+      lines[lines.length - 1] = ellipsizeMeasuredEvidenceLine(
+        lines[lines.length - 1] ?? "",
+        options.maxWidth,
+        options.textMeasurer
+      );
+    }
+  }
+  return lines.length === 0 ? [""] : lines;
+}
+function chunkEvidenceWord(word, maxWidth, textMeasurer) {
+  if (measureEvidenceText(word, textMeasurer) <= maxWidth) {
+    return [word];
+  }
+  const chunks = [];
+  let current = "";
+  for (const char of Array.from(word)) {
+    const candidate = `${current}${char}`;
+    if (current.length > 0 && measureEvidenceText(candidate, textMeasurer) > maxWidth) {
+      chunks.push(current);
+      current = char;
+      continue;
+    }
+    current = candidate;
+  }
+  if (current.length > 0) {
+    chunks.push(current);
+  }
+  return chunks.length === 0 ? [word] : chunks;
+}
+function ellipsizeMeasuredEvidenceLine(line, maxWidth, textMeasurer) {
+  const ellipsis = "...";
+  if (measureEvidenceText(ellipsis, textMeasurer) > maxWidth) {
+    return "";
+  }
+  let candidate = line.trimEnd();
+  while (candidate.length > 0 && measureEvidenceText(`${candidate}${ellipsis}`, textMeasurer) > maxWidth) {
+    candidate = Array.from(candidate).slice(0, -1).join("").trimEnd();
+  }
+  return `${candidate}${ellipsis}`;
+}
+function measureEvidenceText(text, textMeasurer) {
+  return textMeasurer.naturalWidth(
+    textMeasurer.prepare(text, EVIDENCE_TEXT_FONT)
+  );
+}
+function matrixGeometry(matrix) {
+  const columnCount = Math.max(1, matrix.cols.length);
+  const rowCount = matrix.rows.length;
+  const rowHeaderWidth = rowCount > 0 ? Math.min(96, matrix.box.width * 0.28) : 0;
+  const dataWidth = Math.max(0, matrix.box.width - rowHeaderWidth);
+  const cellWidth = dataWidth / columnCount;
+  const rowHeight = matrix.box.height / Math.max(1, rowCount + 1);
+  return {
+    rowHeaderWidth,
+    cellWidth,
+    rowHeight,
+    columnHeaderBox: {
+      x: matrix.box.x + rowHeaderWidth,
+      y: matrix.box.y,
+      width: cellWidth,
+      height: rowHeight
+    },
+    rowHeaderBox: (rowIndex) => ({
+      x: matrix.box.x,
+      y: matrix.box.y + (rowIndex + 1) * rowHeight,
+      width: rowHeaderWidth,
+      height: rowHeight
+    }),
+    cellBox: (rowIndex, columnIndex) => ({
+      x: matrix.box.x + rowHeaderWidth + columnIndex * cellWidth,
+      y: matrix.box.y + (rowIndex + 1) * rowHeight,
+      width: cellWidth,
+      height: rowHeight
+    })
+  };
+}
+function panelGeometry(panel) {
+  const titleWidth = Math.min(panel.box.width * 0.36, 140);
+  const itemBox = {
+    x: panel.box.x + titleWidth,
+    y: panel.box.y,
+    width: panel.box.width - titleWidth,
+    height: panel.box.height
+  };
+  const itemHeight = panel.box.height / Math.max(1, panel.items.length);
+  return {
+    titleBox: {
+      x: panel.box.x,
+      y: panel.box.y,
+      width: titleWidth,
+      height: panel.box.height
+    },
+    itemRowBox: (index) => ({
+      x: itemBox.x,
+      y: itemBox.y + index * itemHeight,
+      width: itemBox.width,
+      height: itemHeight
+    })
+  };
+}
+function panelItemText2(label, detail) {
+  return detail === void 0 ? label : `${label}: ${detail}`;
+}
+function reportEvidenceBlockOverlaps(evidenceBlocks, contentBlocks) {
+  const diagnostics = [];
+  for (let index = 0; index < evidenceBlocks.length; index += 1) {
+    const block = evidenceBlocks[index];
+    if (block === void 0 || block.position === void 0) {
+      continue;
+    }
+    for (const content of contentBlocks) {
+      if (intersectsAabb(block.box, content.box)) {
+        diagnostics.push(evidenceOverlapDiagnostic(block, content));
+      }
+    }
+    for (let otherIndex = 0; otherIndex < evidenceBlocks.length; otherIndex += 1) {
+      if (otherIndex === index) {
+        continue;
+      }
+      const other = evidenceBlocks[otherIndex];
+      if (other === void 0 || other.position !== void 0 && otherIndex < index || !intersectsAabb(block.box, other.box)) {
+        continue;
+      }
+      diagnostics.push(evidenceOverlapDiagnostic(block, other));
     }
-    const geometry = computeContainerGeometry({
-      id: group.id,
-      childBoxes,
-      padding: group.padding,
-      ...group.labelLayout === void 0 ? {} : { labelLayout: group.labelLayout },
-      obstacleMargin: options.obstacleMargin ?? 0
-    });
-    groupBoxes.set(group.id, geometry.box);
-    diagnostics.push(...geometry.diagnostics);
-    coordinated.push({
-      ...group,
-      box: geometry.box
-    });
   }
-  return coordinated;
+  return diagnostics;
+}
+function evidenceOverlapDiagnostic(block, conflict) {
+  return {
+    severity: "warning",
+    code: "constraints.overlap.unresolved",
+    message: `Evidence block ${block.id} overlaps ${conflict.kind} ${conflict.id}.`,
+    path: ["evidence", block.id],
+    detail: {
+      evidenceBlockId: block.id,
+      evidenceBlockKind: block.kind,
+      conflictingObjectId: conflict.id,
+      conflictingObjectKind: conflict.kind
+    }
+  };
 }
-function coordinateEdges(edges, nodes, coordinatedNodes, obstacles, direction, options, diagnostics) {
+function coordinateEdges(edges, nodes, coordinatedNodes, obstacles, softObstacles, textObstacles, hardObstacles, direction, options, diagnostics) {
   const coordinated = [];
   const coordinatedNodeById = new Map(
     coordinatedNodes.map((node) => [node.id, node])
@@ -3243,6 +6517,8 @@ function coordinateEdges(edges, nodes, coordinatedNodes, obstacles, direction, o
     }
     const sourcePort = coordinatedNodeById.get(edge.source.nodeId)?.ports?.find((port) => port.id === edge.source.portId);
     const targetPort = coordinatedNodeById.get(edge.target.nodeId)?.ports?.find((port) => port.id === edge.target.portId);
+    const connectedTextOwners = edgeConnectedTextOwnerIds(edge);
+    const routeTextObstacles = textObstacles.filter((annotation) => !connectedTextOwners.has(annotation.ownerId)).map((annotation) => annotation.box);
     const route = routeEdge({
       kind: options.routeKind ?? "orthogonal",
       direction,
@@ -3250,9 +6526,14 @@ function coordinateEdges(edges, nodes, coordinatedNodes, obstacles, direction, o
       target: portGeometry(target, targetPort),
       ...edge.source.anchor === void 0 ? {} : { sourceAnchor: edge.source.anchor },
       ...edge.target.anchor === void 0 ? {} : { targetAnchor: edge.target.anchor },
-      obstacles: obstacles.filter(
-        (obstacle) => obstacle !== source.obstacleBox && obstacle !== target.obstacleBox
-      )
+      obstacles: [
+        ...obstacles.filter(
+          (obstacle) => obstacle !== source.obstacleBox && obstacle !== target.obstacleBox
+        ),
+        ...softObstacles,
+        ...routeTextObstacles
+      ],
+      hardObstacles
     });
     diagnostics.push(
       ...route.diagnostics.map((diagnostic) => ({
@@ -3267,6 +6548,610 @@ function coordinateEdges(edges, nodes, coordinatedNodes, obstacles, direction, o
   }
   return coordinated;
 }
+function edgeConnectedTextOwnerIds(edge) {
+  const owners = /* @__PURE__ */ new Set();
+  if (edge.source.portId !== void 0) {
+    owners.add(`${edge.source.nodeId}.${edge.source.portId}`);
+  }
+  if (edge.target.portId !== void 0) {
+    owners.add(`${edge.target.nodeId}.${edge.target.portId}`);
+  }
+  return owners;
+}
+function coordinateBaseTextAnnotations(input) {
+  const measurer = input.textMeasurer ?? createDefaultTextMeasurer();
+  const annotations = [];
+  for (const node of input.nodes) {
+    if (node.compartments !== void 0) {
+      continue;
+    }
+    if (node.labelLayout === void 0 && node.label === void 0) {
+      continue;
+    }
+    const layout2 = node.labelLayout ?? fallbackLabelLayout(node.label?.text ?? "");
+    const buildAnnotation = node.labelLayout === void 0 ? buildAnchorCenteredTextAnnotation : buildTextAnnotation;
+    annotations.push(
+      buildAnnotation({
+        ownerId: node.id,
+        surfaceKind: "node-label",
+        layout: layout2,
+        typography: typographyForLabel(node.label),
+        anchor: node.box
+      })
+    );
+  }
+  for (const group of input.groups) {
+    if (group.labelLayout === void 0 && group.label === void 0) {
+      continue;
+    }
+    const layout2 = group.labelLayout ?? fallbackLabelLayout(group.label?.text ?? "");
+    const buildAnnotation = group.labelLayout === void 0 ? buildAnchorCenteredTextAnnotation : buildTextAnnotation;
+    annotations.push(
+      buildAnnotation({
+        ownerId: group.id,
+        surfaceKind: "group-label",
+        layout: layout2,
+        typography: typographyForLabel(group.label),
+        anchor: group.box
+      })
+    );
+  }
+  for (const node of input.nodes) {
+    for (const port of node.ports ?? []) {
+      if (port.label?.text === void 0) {
+        continue;
+      }
+      const layout2 = fitLabel(
+        port.label.text,
+        {
+          font: typographyTextStyle(port.label, {
+            fontFamily: "Arial",
+            fontSize: 10,
+            lineHeight: 12
+          }),
+          padding: { top: 0, right: 0, bottom: 0, left: 0 },
+          minSize: { width: 0, height: 0 },
+          maxWidth: 160
+        },
+        measurer
+      );
+      annotations.push(
+        buildTextAnnotation({
+          ownerId: `${node.id}.${port.id}`,
+          surfaceKind: "port-label",
+          layout: layout2,
+          typography: typographyForLabel(port.label),
+          anchor: portLabelBox(port)
+        })
+      );
+    }
+  }
+  for (const node of input.nodes) {
+    if (node.compartments === void 0) {
+      continue;
+    }
+    const rows = compartmentRows2(node);
+    for (let index = 0; index < rows.length; index += 1) {
+      const row = rows[index];
+      if (row === void 0) {
+        continue;
+      }
+      const layout2 = fitLabel(
+        row,
+        {
+          font: { fontFamily: "Arial", fontSize: 11, lineHeight: 13 },
+          padding: { top: 0, right: 0, bottom: 0, left: 0 },
+          minSize: { width: 0, height: 0 },
+          maxWidth: node.box.width
+        },
+        measurer
+      );
+      annotations.push(
+        buildAnchorCenteredTextAnnotation({
+          ownerId: node.id,
+          surfaceKind: "compartment-row",
+          surfaceIndex: index,
+          layout: layout2,
+          anchor: {
+            x: node.box.x,
+            y: node.box.y + 18 + index * 16,
+            width: node.box.width,
+            height: 16
+          }
+        })
+      );
+    }
+  }
+  for (const swimlane of input.swimlanes) {
+    for (const lane of swimlane.lanes) {
+      if (lane.label?.text === void 0 || lane.box === void 0) {
+        continue;
+      }
+      const labelBox = lane.headerBox ?? lane.box;
+      const layout2 = fitLabel(
+        lane.label.text,
+        {
+          font: typographyTextStyle(lane.label, {
+            fontFamily: "Arial",
+            fontSize: 12,
+            lineHeight: 14
+          }),
+          padding: { top: 0, right: 0, bottom: 0, left: 0 },
+          minSize: { width: 0, height: 0 },
+          maxWidth: swimlane.orientation === "horizontal" ? labelBox.height : labelBox.width
+        },
+        measurer
+      );
+      annotations.push(
+        buildAnchorCenteredTextAnnotation({
+          ownerId: `${swimlane.id}.${lane.id}`,
+          surfaceKind: "swimlane-label",
+          layout: layout2,
+          typography: typographyForLabel(lane.label),
+          anchor: labelBox
+        })
+      );
+    }
+  }
+  return annotations;
+}
+function coordinateEdgeTextAnnotations(edges, obstacleBoxes, textMeasurer) {
+  const measurer = textMeasurer ?? createDefaultTextMeasurer();
+  const annotations = [];
+  const placedLabelBoxes = [];
+  for (const edge of edges) {
+    if (edge.label?.text === void 0) {
+      continue;
+    }
+    const layout2 = fitLabel(
+      edge.label.text,
+      {
+        font: typographyTextStyle(edge.label, {
+          fontFamily: "Arial",
+          fontSize: 12,
+          lineHeight: 14
+        }),
+        padding: { top: 0, right: 0, bottom: 0, left: 0 },
+        minSize: { width: 0, height: 0 },
+        maxWidth: 200
+      },
+      measurer
+    );
+    const center = edgeLabelAnchor(
+      edge,
+      layout2,
+      edges,
+      obstacleBoxes,
+      placedLabelBoxes
+    );
+    placedLabelBoxes.push({
+      x: center.x - layout2.box.width / 2,
+      y: center.y - layout2.box.height / 2,
+      width: layout2.box.width,
+      height: layout2.box.height
+    });
+    annotations.push(
+      buildCenteredTextAnnotation({
+        ownerId: edge.id,
+        surfaceKind: "edge-label",
+        layout: layout2,
+        typography: typographyForLabel(edge.label),
+        center
+      })
+    );
+  }
+  return annotations;
+}
+function coordinateFrameTextAnnotation(frame, textMeasurer) {
+  const layout2 = fitLabel(
+    frame.titleTab,
+    {
+      font: { fontFamily: "Arial", fontSize: 12, lineHeight: 14 },
+      padding: { top: 0, right: 0, bottom: 0, left: 0 },
+      minSize: { width: 0, height: 0 },
+      maxWidth: frame.titleBox.width
+    },
+    textMeasurer ?? createDefaultTextMeasurer()
+  );
+  return buildAnchorCenteredTextAnnotation({
+    ownerId: frame.kind,
+    surfaceKind: "frame-title",
+    layout: layout2,
+    anchor: frame.titleBox
+  });
+}
+function buildTextAnnotation(input) {
+  return {
+    text: input.layout.text,
+    ownerId: input.ownerId,
+    surfaceKind: input.surfaceKind,
+    ...input.surfaceIndex === void 0 ? {} : { surfaceIndex: input.surfaceIndex },
+    box: {
+      x: input.anchor.x + input.layout.box.x,
+      y: input.anchor.y + input.layout.box.y,
+      width: input.layout.box.width,
+      height: input.layout.box.height
+    },
+    anchor: input.anchor,
+    paddings: input.layout.padding,
+    lines: input.layout.lines,
+    fontFamily: input.typography?.fontFamily ?? normalizeOutputFontFamily(input.layout.font),
+    fontSize: input.typography?.fontSize ?? input.layout.font.fontSize,
+    textBackend: input.layout.textBackend
+  };
+}
+function buildAnchorCenteredTextAnnotation(input) {
+  return buildCenteredTextAnnotation({
+    ownerId: input.ownerId,
+    surfaceKind: input.surfaceKind,
+    ...input.surfaceIndex === void 0 ? {} : { surfaceIndex: input.surfaceIndex },
+    layout: input.layout,
+    ...input.typography === void 0 ? {} : { typography: input.typography },
+    center: {
+      x: input.anchor.x + input.anchor.width / 2,
+      y: input.anchor.y + input.anchor.height / 2
+    },
+    anchor: input.anchor
+  });
+}
+function buildCenteredTextAnnotation(input) {
+  return {
+    text: input.layout.text,
+    ownerId: input.ownerId,
+    surfaceKind: input.surfaceKind,
+    ...input.surfaceIndex === void 0 ? {} : { surfaceIndex: input.surfaceIndex },
+    box: {
+      x: input.center.x - input.layout.box.width / 2,
+      y: input.center.y - input.layout.box.height / 2,
+      width: input.layout.box.width,
+      height: input.layout.box.height
+    },
+    anchor: input.anchor ?? input.center,
+    paddings: input.layout.padding,
+    lines: input.layout.lines,
+    fontFamily: input.typography?.fontFamily ?? normalizeOutputFontFamily(input.layout.font),
+    fontSize: input.typography?.fontSize ?? input.layout.font.fontSize,
+    textBackend: input.layout.textBackend
+  };
+}
+function normalizeOutputFontFamily(font) {
+  return font.fontFamily === "Arial" ? "Arial, sans-serif" : font.fontFamily;
+}
+function reportTextAnnotationCollisions(annotations) {
+  const diagnostics = [];
+  const relevantAnnotations = annotations.filter(
+    (annotation) => isExternallyPlacedText(annotation.surfaceKind)
+  );
+  for (let annotationIndex = 0; annotationIndex < relevantAnnotations.length; annotationIndex += 1) {
+    const annotation = relevantAnnotations[annotationIndex];
+    if (annotation === void 0) {
+      continue;
+    }
+    for (let otherIndex = annotationIndex + 1; otherIndex < relevantAnnotations.length; otherIndex += 1) {
+      const other = relevantAnnotations[otherIndex];
+      if (other === void 0) {
+        continue;
+      }
+      if (!intersectsAabb(annotation.box, other.box)) {
+        continue;
+      }
+      if (annotation.ownerId === other.ownerId && annotation.surfaceKind === other.surfaceKind) {
+        continue;
+      }
+      diagnostics.push({
+        severity: "warning",
+        code: "constraints.overlap.unresolved",
+        message: `Text surface ${annotation.surfaceKind} for ${annotation.ownerId} overlaps text surface ${other.surfaceKind} for ${other.ownerId}.`,
+        path: ["textAnnotations", annotation.surfaceKind, annotation.ownerId],
+        detail: compactDetail({
+          textSurfaceKind: annotation.surfaceKind,
+          ownerId: annotation.ownerId,
+          conflictingObjectId: other.ownerId,
+          conflictingObjectKind: other.surfaceKind,
+          surfaceIndex: annotation.surfaceIndex,
+          otherSurfaceKind: other.surfaceKind,
+          otherSurfaceIndex: other.surfaceIndex,
+          textBackend: annotation.textBackend
+        })
+      });
+    }
+  }
+  return diagnostics;
+}
+function reportRouteTextClearance(edges, annotations) {
+  const diagnostics = [];
+  const relevantAnnotations = annotations.filter(isRouteClearanceText);
+  for (const edge of edges) {
+    const connectedTextOwners = edgeConnectedTextOwnerIds(edge);
+    for (const annotation of relevantAnnotations) {
+      if (annotation.ownerId === edge.id || connectedTextOwners.has(annotation.ownerId)) {
+        continue;
+      }
+      if (!routeIntersectsTextBox(edge.points, annotation.box)) {
+        continue;
+      }
+      diagnostics.push({
+        severity: "warning",
+        code: "routing.text-clearance.unresolved",
+        message: `Edge ${edge.id} intersects solved text surface ${annotation.surfaceKind} for ${annotation.ownerId}.`,
+        path: ["edges", edge.id],
+        detail: compactDetail({
+          edgeId: edge.id,
+          textSurfaceKind: annotation.surfaceKind,
+          conflictingObjectId: annotation.ownerId,
+          surfaceIndex: annotation.surfaceIndex,
+          textBackend: annotation.textBackend
+        })
+      });
+    }
+  }
+  return diagnostics;
+}
+function isPreRouteTextObstacle(annotation) {
+  if (annotation.surfaceKind === "edge-label") {
+    return false;
+  }
+  return isRouteClearanceText(annotation);
+}
+function isRouteClearanceText(annotation) {
+  switch (annotation.surfaceKind) {
+    case "port-label":
+    case "edge-label":
+    case "swimlane-label":
+    case "frame-title":
+      return true;
+    case "node-label":
+    case "group-label":
+    case "compartment-row":
+      return textExtendsOutsideAnchor(annotation);
+  }
+}
+function textExtendsOutsideAnchor(annotation) {
+  if (!("width" in annotation.anchor)) {
+    return true;
+  }
+  const epsilon = 1e-3;
+  return annotation.box.x < annotation.anchor.x - epsilon || annotation.box.y < annotation.anchor.y - epsilon || annotation.box.x + annotation.box.width > annotation.anchor.x + annotation.anchor.width + epsilon || annotation.box.y + annotation.box.height > annotation.anchor.y + annotation.anchor.height + epsilon;
+}
+function routeIntersectsTextBox(points, box) {
+  for (let index = 0; index < points.length - 1; index += 1) {
+    const start = points[index];
+    const end = points[index + 1];
+    if (start === void 0 || end === void 0) {
+      continue;
+    }
+    if (segmentIntersectsBox2(start, end, box)) {
+      return true;
+    }
+  }
+  return false;
+}
+function segmentIntersectsBox2(start, end, box) {
+  const left = box.x;
+  const right = box.x + box.width;
+  const top = box.y;
+  const bottom = box.y + box.height;
+  if (pointInsideBox2(start, box) || pointInsideBox2(end, box)) {
+    return true;
+  }
+  if (start.x === end.x) {
+    return start.x > left && start.x < right && rangesOverlap2(start.y, end.y, top, bottom);
+  }
+  if (start.y === end.y) {
+    return start.y > top && start.y < bottom && rangesOverlap2(start.x, end.x, left, right);
+  }
+  return segmentIntersectsBoxEdge2(start, end, left, top, right, top) || segmentIntersectsBoxEdge2(start, end, right, top, right, bottom) || segmentIntersectsBoxEdge2(start, end, right, bottom, left, bottom) || segmentIntersectsBoxEdge2(start, end, left, bottom, left, top);
+}
+function pointInsideBox2(point2, box) {
+  return point2.x > box.x && point2.x < box.x + box.width && point2.y > box.y && point2.y < box.y + box.height;
+}
+function rangesOverlap2(a, b, min, max) {
+  const low = Math.min(a, b);
+  const high = Math.max(a, b);
+  return high > min && low < max;
+}
+function segmentIntersectsBoxEdge2(start, end, x1, y1, x2, y2) {
+  const denominator = (end.x - start.x) * (y2 - y1) - (end.y - start.y) * (x2 - x1);
+  if (denominator === 0) {
+    return false;
+  }
+  const t = ((x1 - start.x) * (y2 - y1) - (y1 - start.y) * (x2 - x1)) / denominator;
+  const u = ((x1 - start.x) * (end.y - start.y) - (y1 - start.y) * (end.x - start.x)) / denominator;
+  return t > 0 && t < 1 && u > 0 && u < 1;
+}
+function compactDetail(detail) {
+  return Object.fromEntries(
+    Object.entries(detail).filter(
+      (entry) => entry[1] !== void 0
+    )
+  );
+}
+function isExternallyPlacedText(surfaceKind) {
+  switch (surfaceKind) {
+    case "port-label":
+      return true;
+    case "edge-label":
+      return false;
+    case "swimlane-label":
+      return true;
+    case "frame-title":
+      return true;
+    case "node-label":
+    case "group-label":
+    case "compartment-row":
+      return false;
+  }
+}
+function fallbackLabelLayout(text) {
+  const width = Math.max(0, text.length * 7);
+  return {
+    text,
+    box: { x: 0, y: 0, width, height: 14 },
+    contentBox: { x: 0, y: 0, width, height: 14 },
+    naturalSize: { width, height: 14 },
+    fittedSize: { width, height: 14 },
+    padding: { top: 0, right: 0, bottom: 0, left: 0 },
+    font: { fontFamily: "Arial", fontSize: 12, lineHeight: 14 },
+    lineHeight: 14,
+    lines: [
+      {
+        text,
+        box: { x: 0, y: 0, width, height: 14 },
+        baselineY: 11.2,
+        width,
+        lineIndex: 0
+      }
+    ],
+    overflow: { horizontal: false, vertical: false, truncated: false },
+    diagnostics: []
+  };
+}
+function edgeLabelAnchor(edge, layout2, edges, obstacleBoxes, placedLabelBoxes) {
+  const placement = labelPlacementOnPolyline2(edge.points);
+  if (placement === void 0) {
+    return { x: 0, y: 0 };
+  }
+  for (const candidate of edgeLabelAnchorCandidates(
+    edge.points,
+    placement,
+    layout2
+  )) {
+    const labelBox = {
+      x: candidate.x - layout2.box.width / 2,
+      y: candidate.y - layout2.box.height / 2,
+      width: layout2.box.width,
+      height: layout2.box.height
+    };
+    if (routeIntersectsTextBox(edge.points, labelBox)) {
+      continue;
+    }
+    const crossesOtherRoute = edges.some(
+      (other) => other.id !== edge.id && routeIntersectsTextBox(other.points, labelBox)
+    );
+    if (crossesOtherRoute) {
+      continue;
+    }
+    const overlapsNode = obstacleBoxes.some(
+      (box) => intersectsAabb(labelBox, box)
+    );
+    if (overlapsNode) {
+      continue;
+    }
+    const overlapsPlacedLabel = placedLabelBoxes.some(
+      (box) => intersectsAabb(labelBox, box)
+    );
+    if (!overlapsPlacedLabel) {
+      return candidate;
+    }
+  }
+  return placement;
+}
+function edgeLabelAnchorCandidates(points, placement, layout2) {
+  const segment = labelSegmentOnPolyline(points);
+  if (segment === void 0) {
+    return [placement];
+  }
+  const candidates = [placement];
+  if (segment.start.y === segment.end.y) {
+    const needed = layout2.box.height / 2 + EDGE_LABEL_CLEARANCE;
+    const maxSteps = Math.max(12, Math.ceil(needed / EDGE_LABEL_CLEARANCE));
+    for (let step = 1; step <= maxSteps; step += 1) {
+      const offset = EDGE_LABEL_CLEARANCE * step;
+      candidates.push(
+        { x: placement.x, y: placement.y - offset },
+        { x: placement.x, y: placement.y + offset }
+      );
+    }
+    return candidates;
+  }
+  if (segment.start.x === segment.end.x) {
+    const needed = layout2.box.width / 2 + EDGE_LABEL_CLEARANCE;
+    const maxSteps = Math.max(12, Math.ceil(needed / EDGE_LABEL_CLEARANCE));
+    for (let step = 1; step <= maxSteps; step += 1) {
+      const offset = EDGE_LABEL_CLEARANCE * step;
+      candidates.push(
+        { x: placement.x + offset, y: placement.y },
+        { x: placement.x - offset, y: placement.y }
+      );
+    }
+    return candidates;
+  }
+  return candidates;
+}
+function labelPlacementOnPolyline2(points) {
+  return labelSegmentOnPolyline(points)?.placement;
+}
+function labelSegmentOnPolyline(points) {
+  const segments = nonZeroSegments2(points);
+  const totalLength = segments.reduce(
+    (sum, segment) => sum + segment.length,
+    0
+  );
+  if (totalLength <= 0) {
+    return void 0;
+  }
+  let remaining = totalLength / 2;
+  for (const segment of segments) {
+    if (remaining <= segment.length) {
+      const ratio = remaining / segment.length;
+      const x = segment.start.x + (segment.end.x - segment.start.x) * ratio;
+      const y = segment.start.y + (segment.end.y - segment.start.y) * ratio;
+      const offset2 = labelOffset2(segment);
+      return {
+        start: segment.start,
+        end: segment.end,
+        placement: { x: x + offset2.x, y: y + offset2.y }
+      };
+    }
+    remaining -= segment.length;
+  }
+  const last = segments.at(-1);
+  if (last === void 0) {
+    return void 0;
+  }
+  const offset = labelOffset2(last);
+  return {
+    start: last.start,
+    end: last.end,
+    placement: { x: last.end.x + offset.x, y: last.end.y + offset.y }
+  };
+}
+function nonZeroSegments2(points) {
+  const segments = [];
+  for (let index = 0; index < points.length - 1; index += 1) {
+    const start = points[index];
+    const end = points[index + 1];
+    if (start === void 0 || end === void 0) {
+      continue;
+    }
+    const length = Math.hypot(end.x - start.x, end.y - start.y);
+    if (length > 0) {
+      segments.push({ start, end, length });
+    }
+  }
+  return segments;
+}
+function labelOffset2(segment) {
+  const offset = 10;
+  const dx = segment.end.x - segment.start.x;
+  const dy = segment.end.y - segment.start.y;
+  return {
+    x: -dy / segment.length * offset,
+    y: dx / segment.length * offset
+  };
+}
+function compartmentRows2(node) {
+  const compartments2 = node.compartments;
+  if (compartments2 === void 0) {
+    return [];
+  }
+  return [
+    ...compartments2.stereotype === void 0 ? [] : [compartments2.stereotype],
+    ...compartments2.name === void 0 ? [node.label?.text ?? node.id] : [compartments2.name],
+    ...compartments2.properties ?? [],
+    ...compartments2.constraints ?? []
+  ];
+}
 function portGeometry(nodeGeometry, port) {
   if (port === void 0) {
     return nodeGeometry;
@@ -3282,8 +7167,26 @@ function portGeometry(nodeGeometry, port) {
     obstacleBox: port.box
   };
 }
-function stableById(items) {
-  return [...items].sort((a, b) => a.id.localeCompare(b.id));
+function stableUniqueById(items, diagnostics, pathRoot, code) {
+  const firstById = /* @__PURE__ */ new Map();
+  for (let index = 0; index < items.length; index += 1) {
+    const item = items[index];
+    if (item === void 0) {
+      continue;
+    }
+    if (firstById.has(item.id)) {
+      diagnostics.push({
+        severity: "error",
+        code,
+        message: `Duplicate ${pathRoot.slice(0, -1)} id ${item.id} was ignored; first occurrence was kept.`,
+        path: [pathRoot, index, "id"],
+        detail: { id: item.id, duplicateIndex: index }
+      });
+      continue;
+    }
+    firstById.set(item.id, item);
+  }
+  return [...firstById.values()].sort((a, b) => a.id.localeCompare(b.id));
 }
 function stableByConstraintId(items) {
   return [...items].sort(
@@ -3343,7 +7246,8 @@ function renderDiagramDsl(source, options = {}) {
   }
   const solved = solveDiagram(normalized.diagram, {
     routeKind: normalized.diagram.metadata?.routeKind === "straight" ? "straight" : "orthogonal",
-    ...solvePortShiftingOption(normalized.diagram.metadata?.portShifting)
+    ...solvePortShiftingOption(normalized.diagram.metadata?.portShifting),
+    ...options.textMeasurer === void 0 ? {} : { textMeasurer: options.textMeasurer }
   });
   const solveDiagnostics = solved.diagnostics.map(toSolveDiagnostic);
   if (hasErrorDiagnostics2(solveDiagnostics)) {
@@ -3533,6 +7437,7 @@ function isPointLikeRecord(value) {
 
 exports.DEFAULT_CANONICAL_PRECISION = DEFAULT_CANONICAL_PRECISION;
 exports.DEFAULT_DSL_MAX_BYTES = DEFAULT_DSL_MAX_BYTES;
+exports.DELIVERABILITY_DIAGNOSTIC_CODES = DELIVERABILITY_DIAGNOSTIC_CODES;
 exports.DeterministicTextMeasurer = DeterministicTextMeasurer;
 exports.LabelFitter = LabelFitter;
 exports.PretextTextMeasurer = PretextTextMeasurer;
@@ -3564,6 +7469,7 @@ exports.routeEdge = routeEdge;
 exports.runDagreInitialLayout = runDagreInitialLayout;
 exports.simplifyRoute = simplifyRoute;
 exports.solveDiagram = solveDiagram;
+exports.solveDiagramSafe = solveDiagramSafe;
 exports.sortDslDiagnostics = sortDslDiagnostics;
 exports.stringifyCanonical = stringifyCanonical;
 exports.toCanvasFont = toCanvasFont;