@crazyhappyone/auto-graph 0.0.4 → 0.0.6

package/dist/index.js

@@ -317,27 +317,31 @@ function applyDistribute(constraints, boxes, locks, diagnostics) {
 function repairOverlaps(input, boxes, locks, diagnostics) {
   const spacing = input.overlapSpacing ?? 40;
   const axis = input.direction === "LR" || input.direction === "RL" ? "x" : "y";
+  const secondaryAxis = axis === "x" ? "y" : "x";
   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;
+        }
+        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 moved = movePastOverlap(moving, fixed, repairAxis, spacing);
+        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);
     }
   }
   for (const firstId of ids) {
@@ -1185,6 +1189,9 @@ var DEFAULT_GROUP_PADDING = {
 };
 var DEFAULT_LABEL_MAX_WIDTH = 160;
 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);
@@ -1198,6 +1205,9 @@ function normalizeDiagramDsl(dslValue, options = {}) {
   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 },
@@ -1206,6 +1216,9 @@ 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) },
@@ -1404,6 +1417,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];
@@ -1695,6 +1804,15 @@ var styleSchema = z.object({
   fill: z.string().optional(),
   stroke: z.string().optional()
 });
+var blockCellSchema = z.union([
+  z.string(),
+  z.object({
+    text: z.string(),
+    fill: z.string().optional(),
+    stroke: z.string().optional(),
+    style: styleSchema.optional()
+  })
+]);
 var portSideSchema = z.enum(["top", "right", "bottom", "left"]);
 var portKindSchema = z.enum(["proxy", "flow"]);
 var portSchema = z.object({
@@ -1771,6 +1889,122 @@ var swimlaneSchema = z.object({
     })
   )
 });
+var matrixSchema = z.object({
+  id: z.string(),
+  rows: z.array(z.string()),
+  cols: z.array(z.string()),
+  cells: z.array(z.array(blockCellSchema)),
+  position: pointSchema.optional(),
+  size: 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 = z.object({
+  id: z.string(),
+  label: labelSchema
+});
+var tableRowSchema = z.object({
+  id: z.string(),
+  cells: z.record(z.string(), blockCellSchema)
+});
+var tableSchema = z.object({
+  id: z.string(),
+  columns: z.array(tableColumnSchema),
+  rows: z.array(tableRowSchema),
+  position: pointSchema.optional(),
+  size: 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 = z.union([
+  z.string(),
+  z.object({
+    id: z.string().optional(),
+    label: labelSchema,
+    detail: labelSchema.optional(),
+    style: styleSchema.optional()
+  })
+]);
+var evidencePanelSchema = z.object({
+  id: z.string(),
+  kind: z.enum(["legend", "rule", "note", "verification"]),
+  items: z.array(panelItemSchema),
+  position: pointSchema.optional(),
+  size: 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 = z.object({
   kind: z.literal("exact-position"),
   target: z.string().optional(),
@@ -1842,6 +2076,9 @@ var diagramDslSchema = z.object({
   edges: z.array(edgeSchema).optional(),
   groups: z.record(z.string(), groupSchema).optional(),
   swimlanes: z.record(z.string(), swimlaneSchema).optional(),
+  matrices: z.array(matrixSchema).optional(),
+  tables: z.array(tableSchema).optional(),
+  evidencePanels: z.array(evidencePanelSchema).optional(),
   constraints: z.array(constraintSchema).optional(),
   frame: z.object({
     kind: z.string(),
@@ -1853,6 +2090,15 @@ var diagramDslSchema = z.object({
   output: 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);
@@ -1872,6 +2118,62 @@ function toDiagnosticPath(path) {
     (segment) => typeof segment === "string" || typeof segment === "number" ? [segment] : []
   );
 }
+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;
@@ -2073,6 +2375,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));
   }
@@ -2105,6 +2416,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) {
@@ -2164,6 +2552,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,
@@ -2241,6 +2657,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);
@@ -2278,42 +2709,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;
@@ -2333,18 +2975,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 [];
   }
@@ -2370,28 +3021,49 @@ function renderSwimlane(swimlane) {
       );
     }
     if (lane.label?.text !== void 0) {
-      const labelBox = lane.headerBox ?? lane.box;
-      lines.push(renderSwimlaneLabel(swimlane, lane.label.text, labelBox));
+      const annotation = findAnnotation(
+        annotations,
+        "swimlane-label",
+        `${swimlane.id}.${lane.id}`
+      );
+      lines.push(
+        ...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 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 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 [];
@@ -2411,7 +3083,6 @@ function renderCompartments(node) {
       text
     }))
   ];
-  const lineHeight = 16;
   const lines = [
     `  <g class="compartment" data-for="${escapeAttribute(node.id)}">`
   ];
@@ -2420,32 +3091,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 };
@@ -2471,10 +3182,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 [];
@@ -2488,6 +3206,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="${FONT_FAMILY}"`,
+    `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(
@@ -2570,17 +3367,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) {
@@ -2605,10 +3400,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(" ");
@@ -2631,6 +3425,9 @@ function escapeAttribute(value) {
 function indent(value) {
   return `  ${value}`;
 }
+function indentLines(values) {
+  return values.map(indent);
+}
 var DEFAULT_OPTIONS = {
   nodesep: 80,
   ranksep: 100,
@@ -2732,37 +3529,112 @@ 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 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 = simplifyRoute([source, target]);
+    if (routeCrossesBoxes(points, hardObstacles)) {
+      diagnostics.push({
+        severity: "error",
+        code: "routing.evidence.crossing_forbidden",
+        message: "Straight route crosses hard evidence block obstacles."
+      });
+      return { points, diagnostics };
+    }
+    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: simplifyRoute(candidate.points), diagnostics };
+    }
   }
-  const candidates = orthogonalCandidates(source, target, input.direction);
-  candidates.push(
-    ...expandedObstacleCandidates(
-      source,
-      target,
-      input.direction,
-      input.obstacles ?? []
+  const hardClearCandidate = candidateRoutes.find(
+    (candidate) => !routeIntersectsObstacles(candidate.points, hardObstacles) && !routeIntersectsEndpointInteriors(
+      candidate.points,
+      candidate.endpointObstacles
     )
   );
-  for (const candidate of candidates) {
-    if (!routeIntersectsObstacles(candidate, input.obstacles ?? [])) {
-      return { points: simplifyRoute(candidate), diagnostics };
-    }
+  if (hardClearCandidate !== void 0) {
+    diagnostics.push({
+      severity: "warning",
+      code: "routing.obstacle.unavoidable",
+      message: "No bounded orthogonal route candidate avoided all soft obstacles."
+    });
+    return {
+      points: simplifyRoute(hardClearCandidate.points),
+      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: simplifyRoute(
+        candidateRoutes[0]?.points ?? fallbackRoute(input, defaultAnchors)
+      ),
+      diagnostics
+    };
   }
   diagnostics.push({
     severity: "warning",
@@ -2770,10 +3642,111 @@ function routeEdge(input) {
     message: "No bounded orthogonal route candidate avoided all obstacles."
   });
   return {
-    points: simplifyRoute(candidates[0] ?? [source, target]),
+    points: simplifyRoute(
+      candidateRoutes[0]?.points ?? fallbackRoute(input, defaultAnchors)
+    ),
     diagnostics
   };
 }
+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) {
@@ -2898,6 +3871,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);
@@ -2921,6 +3932,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);
@@ -2936,6 +4013,17 @@ 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 EVIDENCE_TEXT_FONT = {
+  fontFamily: "Arial, sans-serif",
+  fontSize: 10,
+  lineHeight: 12
+};
 function solveDiagram(diagram, options = {}) {
   const diagnostics = [...diagram.diagnostics];
   const nodes = stableById(diagram.nodes);
@@ -3000,19 +4088,21 @@ function solveDiagram(diagram, options = {}) {
     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(
@@ -3022,10 +4112,111 @@ 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(
+    [
+      ...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 coordinatedEdges = coordinateEdges(
+    edges,
+    nodeGeometryById,
+    coordinatedNodes,
+    [...nodeGeometryById.values()].map((geometry) => geometry.obstacleBox),
+    [
+      ...coordinatedTables.map((table) => table.box),
+      ...coordinatedEvidencePanels.map((panel) => panel.box)
+    ],
+    routingTextObstacles,
+    coordinatedMatrices.map((matrix) => matrix.box),
+    diagram.direction,
+    options,
+    diagnostics
+  );
+  const edgeTextAnnotations = coordinateEdgeTextAnnotations(
+    coordinatedEdges,
+    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)
+  ];
   return {
     id: diagram.id,
     ...diagram.title === void 0 ? {} : { title: diagram.title },
@@ -3034,9 +4225,13 @@ function solveDiagram(diagram, options = {}) {
     edges: coordinatedEdges,
     groups: coordinatedGroups,
     ...coordinatedSwimlanes.length === 0 ? {} : { swimlanes: coordinatedSwimlanes },
+    ...coordinatedMatrices.length === 0 ? {} : { matrices: coordinatedMatrices },
+    ...coordinatedTables.length === 0 ? {} : { tables: coordinatedTables },
+    ...coordinatedEvidencePanels.length === 0 ? {} : { evidencePanels: coordinatedEvidencePanels },
     diagnostics,
-    bounds: frame === void 0 ? contentBounds : unionBoxes([contentBounds, frame.box, frame.titleBox]),
+    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 }
   };
 }
@@ -3931,23 +5126,380 @@ function coordinateGroups(groups, nodeBoxes, options, diagnostics) {
   }
   return coordinated;
 }
-function coordinateEdges(edges, nodes, coordinatedNodes, obstacles, direction, options, diagnostics) {
-  const coordinated = [];
-  const coordinatedNodeById = new Map(
-    coordinatedNodes.map((node) => [node.id, node])
-  );
-  for (const edge of edges) {
-    const source = nodes.get(edge.source.nodeId);
-    const target = nodes.get(edge.target.nodeId);
-    if (source === void 0 || target === void 0) {
-      diagnostics.push({
-        severity: "error",
-        code: "solver.edge-reference.missing",
-        message: `Edge ${edge.id} references a missing coordinated node.`,
-        path: ["edges", edge.id],
-        detail: {
-          edgeId: edge.id,
-          sourceId: edge.source.nodeId,
+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 minX = Math.min(...edge.points.map((point2) => point2.x));
+    const minY = Math.min(...edge.points.map((point2) => point2.y));
+    const maxX = Math.max(...edge.points.map((point2) => point2.x));
+    const maxY = Math.max(...edge.points.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(blocks, contentBounds) {
+  let nextY = contentBounds.y;
+  const x = contentBounds.x + contentBounds.width + DEFAULT_EVIDENCE_BLOCK_GAP;
+  for (const block of blocks) {
+    if (block.position !== void 0) {
+      continue;
+    }
+    block.box.x = x;
+    block.box.y = nextY;
+    nextY += block.box.height + DEFAULT_EVIDENCE_BLOCK_GAP;
+  }
+}
+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));
+    }
+  }
+  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, softObstacles, textObstacles, hardObstacles, direction, options, diagnostics) {
+  const coordinated = [];
+  const coordinatedNodeById = new Map(
+    coordinatedNodes.map((node) => [node.id, node])
+  );
+  for (const edge of edges) {
+    const source = nodes.get(edge.source.nodeId);
+    const target = nodes.get(edge.target.nodeId);
+    if (source === void 0 || target === void 0) {
+      diagnostics.push({
+        severity: "error",
+        code: "solver.edge-reference.missing",
+        message: `Edge ${edge.id} references a missing coordinated node.`,
+        path: ["edges", edge.id],
+        detail: {
+          edgeId: edge.id,
+          sourceId: edge.source.nodeId,
           targetId: edge.target.nodeId
         }
       });
@@ -3955,6 +5507,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,
@@ -3962,9 +5516,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) => ({
@@ -3979,6 +5538,550 @@ 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,
+        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,
+        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: { 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,
+          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: { 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,
+          anchor: labelBox
+        })
+      );
+    }
+  }
+  return annotations;
+}
+function coordinateEdgeTextAnnotations(edges, textMeasurer) {
+  const measurer = textMeasurer ?? createDefaultTextMeasurer();
+  const annotations = [];
+  for (const edge of edges) {
+    if (edge.label?.text === void 0) {
+      continue;
+    }
+    const layout2 = fitLabel(
+      edge.label.text,
+      {
+        font: { fontFamily: "Arial", fontSize: 12, lineHeight: 14 },
+        padding: { top: 0, right: 0, bottom: 0, left: 0 },
+        minSize: { width: 0, height: 0 },
+        maxWidth: 200
+      },
+      measurer
+    );
+    annotations.push(
+      buildCenteredTextAnnotation({
+        ownerId: edge.id,
+        surfaceKind: "edge-label",
+        layout: layout2,
+        center: edgeLabelAnchor(edge, layout2, edges)
+      })
+    );
+  }
+  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,
+    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,
+    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,
+    fontSize: input.layout.font.fontSize,
+    textBackend: input.layout.textBackend
+  };
+}
+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) {
+  const placement = labelPlacementOnPolyline2(edge.points);
+  if (placement === void 0) {
+    return { x: 0, y: 0 };
+  }
+  for (const candidate of edgeLabelAnchorCandidates(edge.points, placement)) {
+    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) {
+      return candidate;
+    }
+  }
+  return placement;
+}
+function edgeLabelAnchorCandidates(points, placement) {
+  const segment = labelSegmentOnPolyline(points);
+  if (segment === void 0) {
+    return [placement];
+  }
+  if (segment.start.y === segment.end.y) {
+    return [
+      placement,
+      { x: placement.x, y: placement.y - EDGE_LABEL_CLEARANCE },
+      { x: placement.x, y: placement.y + EDGE_LABEL_CLEARANCE },
+      { x: placement.x, y: placement.y - EDGE_LABEL_CLEARANCE * 2 },
+      { x: placement.x, y: placement.y + EDGE_LABEL_CLEARANCE * 2 }
+    ];
+  }
+  if (segment.start.x === segment.end.x) {
+    return [
+      placement,
+      { x: placement.x + EDGE_LABEL_CLEARANCE, y: placement.y },
+      { x: placement.x - EDGE_LABEL_CLEARANCE, y: placement.y },
+      { x: placement.x + EDGE_LABEL_CLEARANCE * 2, y: placement.y },
+      { x: placement.x - EDGE_LABEL_CLEARANCE * 2, y: placement.y }
+    ];
+  }
+  return [placement];
+}
+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;
@@ -4055,7 +6158,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)) {