@crazyhappyone/auto-graph 0.0.6 → 0.1.0

package/dist/index.cjs

@@ -99,11 +99,21 @@ function applyLayoutConstraints(input) {
   const nodeById = new Map(input.nodes.map((node) => [node.id, node]));
   applyFixedPositionLocks(input.nodes, boxes, locks, diagnostics);
   applyExactPositions(input.constraints, boxes, locks, diagnostics, nodeById);
-  applyContainment(input.constraints, boxes, locks, diagnostics);
+  applyContainment(input.constraints, boxes, locks, diagnostics, false);
   applyRelative(input.constraints, boxes, locks, diagnostics);
   applyAlign(input.constraints, boxes, locks, diagnostics);
   applyDistribute(input.constraints, boxes, locks, diagnostics);
-  repairOverlaps(input, boxes, locks, diagnostics);
+  repairOverlaps(
+    input,
+    boxes,
+    locks,
+    diagnostics,
+    siblingOverlapKeys(input.constraints)
+  );
+  applyContainment(input.constraints, boxes, locks, diagnostics, true);
+  applyDistributeContained(input, boxes, locks, diagnostics);
+  reportOverlaps(boxes, diagnostics, containmentOverlapKeys(input.constraints));
+  reportIntraContainerOverflow(input, boxes, diagnostics);
   return { boxes, locks, diagnostics };
 }
 function cloneValidBoxes(input, diagnostics) {
@@ -191,7 +201,7 @@ function applyExactPositions(constraints, boxes, locks, diagnostics, nodeById) {
     locks.set(targetId, { nodeId: targetId, source: "exact-position" });
   }
 }
-function applyContainment(constraints, boxes, locks, diagnostics) {
+function applyContainment(constraints, boxes, locks, diagnostics, reportOverflow) {
   for (const constraint of constraints) {
     if (constraint.kind !== "containment") {
       continue;
@@ -213,21 +223,23 @@ function applyContainment(constraints, boxes, locks, diagnostics) {
         continue;
       }
       if (locks.has(childId)) {
-        diagnostics.push({
-          severity: "warning",
-          code: "constraints.locked-target-not-moved",
-          message: `Locked child ${childId} was not moved into containment.`,
-          path: ["constraints", constraint.id ?? constraint.containerId],
-          detail: { nodeId: childId }
-        });
-        if (!isInside(child, content)) {
+        if (!reportOverflow) {
           diagnostics.push({
-            severity: "error",
-            code: "constraints.containment.impossible",
-            message: `Locked child ${childId} cannot fit inside ${constraint.containerId}.`,
+            severity: "warning",
+            code: "constraints.locked-target-not-moved",
+            message: `Locked child ${childId} was not moved into containment.`,
             path: ["constraints", constraint.id ?? constraint.containerId],
-            detail: { nodeId: childId, containerId: constraint.containerId }
+            detail: { nodeId: childId }
           });
+          if (!isInside(child, content)) {
+            diagnostics.push({
+              severity: "error",
+              code: "constraints.containment.impossible",
+              message: `Locked child ${childId} cannot fit inside ${constraint.containerId}.`,
+              path: ["constraints", constraint.id ?? constraint.containerId],
+              detail: { nodeId: childId, containerId: constraint.containerId }
+            });
+          }
         }
         continue;
       }
@@ -242,6 +254,15 @@ function applyContainment(constraints, boxes, locks, diagnostics) {
         continue;
       }
       boxes.set(childId, next);
+      if (reportOverflow) {
+        diagnostics.push({
+          severity: "warning",
+          code: "containment_overflow",
+          message: `Child ${childId} was clamped back inside ${constraint.containerId} after constraint solving.`,
+          path: ["constraints", constraint.id ?? constraint.containerId],
+          detail: { nodeId: childId, containerId: constraint.containerId }
+        });
+      }
     }
   }
 }
@@ -317,10 +338,11 @@ function applyDistribute(constraints, boxes, locks, diagnostics) {
     }
   }
 }
-function repairOverlaps(input, boxes, locks, diagnostics) {
+function repairOverlaps(input, boxes, locks, diagnostics, siblingPairs) {
   const spacing = input.overlapSpacing ?? 40;
   const axis = input.direction === "LR" || input.direction === "RL" ? "x" : "y";
   const secondaryAxis = axis === "x" ? "y" : "x";
+  const ignoredPairs = containmentOverlapKeys(input.constraints);
   const ids = [...boxes.keys()].sort();
   for (let pass = 0; pass < 2; pass += 1) {
     for (const firstId of ids) {
@@ -328,6 +350,9 @@ function repairOverlaps(input, boxes, locks, diagnostics) {
         if (firstId >= secondId) {
           continue;
         }
+        if (ignoredPairs.has(overlapKey(firstId, secondId))) {
+          continue;
+        }
         const first = boxes.get(firstId);
         const second = boxes.get(secondId);
         if (first === void 0 || second === void 0 || !intersectsAabb(first, second)) {
@@ -342,16 +367,40 @@ function repairOverlaps(input, boxes, locks, diagnostics) {
         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);
+        const pairKey = overlapKey(firstId, secondId);
+        const effectiveSpacing = siblingPairs.has(pairKey) ? Math.max(spacing, input.minSiblingGap ?? 0) : spacing;
+        const moved = movePastOverlap(
+          moving,
+          fixed,
+          repairAxis,
+          effectiveSpacing
+        );
         boxes.set(movingId, moved);
       }
     }
   }
+  reportOverlaps(boxes, diagnostics, ignoredPairs);
+}
+function reportOverlaps(boxes, diagnostics, ignoredPairs = /* @__PURE__ */ new Set()) {
+  const ids = [...boxes.keys()].sort();
+  const reported = new Set(
+    diagnostics.filter(
+      (diagnostic) => diagnostic.code === "constraints.overlap.unresolved"
+    ).map((diagnostic) => {
+      const firstId = diagnostic.detail?.firstId;
+      const secondId = diagnostic.detail?.secondId;
+      return typeof firstId === "string" && typeof secondId === "string" ? overlapKey(firstId, secondId) : void 0;
+    }).filter((key) => key !== void 0)
+  );
   for (const firstId of ids) {
     for (const secondId of ids) {
       if (firstId >= secondId) {
         continue;
       }
+      const key = overlapKey(firstId, secondId);
+      if (reported.has(key) || ignoredPairs.has(key)) {
+        continue;
+      }
       const first = boxes.get(firstId);
       const second = boxes.get(secondId);
       if (first !== void 0 && second !== void 0 && intersectsAabb(first, second)) {
@@ -362,9 +411,136 @@ function repairOverlaps(input, boxes, locks, diagnostics) {
           path: ["boxes"],
           detail: { firstId, secondId }
         });
+        reported.add(key);
+      }
+    }
+  }
+}
+function reportIntraContainerOverflow(input, boxes, diagnostics) {
+  if (input.minSiblingGap === void 0) {
+    return;
+  }
+  const minGap = input.minSiblingGap;
+  const axis = input.direction === "LR" || input.direction === "RL" ? "x" : "y";
+  for (const constraint of input.constraints) {
+    if (constraint.kind !== "containment") {
+      continue;
+    }
+    const container = boxes.get(constraint.containerId);
+    if (container === void 0) {
+      continue;
+    }
+    const children = [];
+    for (const childId of constraint.childIds) {
+      const child = boxes.get(childId);
+      if (child !== void 0) {
+        children.push(child);
+      }
+    }
+    if (children.length < 2) {
+      continue;
+    }
+    const sorted = [...children].sort((a, b) => a[axis] - b[axis]);
+    const mainDim = axis === "x" ? "width" : "height";
+    let overlapPairs = 0;
+    for (let i = 0; i < sorted.length; i += 1) {
+      const first = sorted[i];
+      if (first === void 0) {
+        continue;
+      }
+      for (let j = i + 1; j < sorted.length; j += 1) {
+        const second = sorted[j];
+        if (second === void 0) {
+          continue;
+        }
+        if (second[axis] >= first[axis] + first[mainDim]) {
+          break;
+        }
+        if (intersectsAabb(first, second)) {
+          overlapPairs += 1;
+        }
       }
     }
+    if (overlapPairs > 0) {
+      diagnostics.push({
+        severity: "warning",
+        code: "intra_container_overflow",
+        message: `${overlapPairs} sibling pair(s) overlap inside ${constraint.containerId}.`,
+        path: ["constraints", constraint.id ?? constraint.containerId],
+        detail: {
+          containerId: constraint.containerId,
+          overlapPairs,
+          minGap
+        }
+      });
+    }
+    const pad = constraint.padding ?? { top: 0, right: 0, bottom: 0, left: 0 };
+    const contentMain = mainDim === "width" ? Math.max(0, container.width - pad.left - pad.right) : Math.max(0, container.height - pad.top - pad.bottom);
+    let childStart = Infinity;
+    let childEnd = -Infinity;
+    for (const child of sorted) {
+      const start = child[axis];
+      const end = start + child[mainDim];
+      if (start < childStart) childStart = start;
+      if (end > childEnd) childEnd = end;
+    }
+    if (sorted.length === 0) {
+      childStart = 0;
+      childEnd = 0;
+    }
+    const actualExtent = childEnd - childStart;
+    if (actualExtent > contentMain) {
+      diagnostics.push({
+        severity: "error",
+        code: "intra_container_overflow_total",
+        message: `Container ${constraint.containerId} cannot fit ${sorted.length} siblings along ${axis} (extent ${actualExtent}, available ${contentMain}).`,
+        path: ["constraints", constraint.id ?? constraint.containerId],
+        detail: {
+          containerId: constraint.containerId,
+          axis,
+          needed: actualExtent,
+          available: contentMain,
+          siblingCount: sorted.length,
+          minGap
+        }
+      });
+    }
+  }
+}
+function overlapKey(firstId, secondId) {
+  return firstId < secondId ? `${firstId}\0${secondId}` : `${secondId}\0${firstId}`;
+}
+function containmentOverlapKeys(constraints) {
+  const keys = /* @__PURE__ */ new Set();
+  for (const constraint of constraints) {
+    if (constraint.kind !== "containment") {
+      continue;
+    }
+    for (const childId of constraint.childIds) {
+      keys.add(overlapKey(constraint.containerId, childId));
+    }
   }
+  return keys;
+}
+function siblingOverlapKeys(constraints) {
+  const keys = /* @__PURE__ */ new Set();
+  for (const constraint of constraints) {
+    if (constraint.kind !== "containment") {
+      continue;
+    }
+    const { childIds } = constraint;
+    for (let i = 0; i < childIds.length; i += 1) {
+      for (let j = i + 1; j < childIds.length; j += 1) {
+        const a = childIds[i];
+        const b = childIds[j];
+        if (a === void 0 || b === void 0) {
+          continue;
+        }
+        keys.add(overlapKey(a, b));
+      }
+    }
+  }
+  return keys;
 }
 function setUnlockedBox(id, next, boxes, locks, diagnostics, constraint) {
   const current = boxes.get(id);
@@ -482,10 +658,125 @@ function contentBox(container, padding) {
   return {
     x: container.x + margin.left,
     y: container.y + margin.top,
-    width: container.width - margin.left - margin.right,
-    height: container.height - margin.top - margin.bottom
+    width: Math.max(0, container.width - margin.left - margin.right),
+    height: Math.max(0, container.height - margin.top - margin.bottom)
   };
 }
+function applyDistributeContained(input, boxes, locks, diagnostics) {
+  if (!input.distributeContainedChildren) {
+    return;
+  }
+  const axis = input.direction === "LR" || input.direction === "RL" ? "x" : "y";
+  const crossAxis = axis === "x" ? "y" : "x";
+  const mainSize = axis === "x" ? "width" : "height";
+  const crossSize = axis === "x" ? "height" : "width";
+  const minGap = input.minSiblingGap ?? 8;
+  for (const constraint of input.constraints) {
+    if (constraint.kind !== "containment") {
+      continue;
+    }
+    const container = boxes.get(constraint.containerId);
+    if (container === void 0) {
+      continue;
+    }
+    const content = contentBox(container, constraint.padding);
+    const unlocked = [];
+    const reserved = [];
+    for (const childId of constraint.childIds) {
+      const box = boxes.get(childId);
+      if (box === void 0) {
+        continue;
+      }
+      if (locks.has(childId)) {
+        diagnostics.push({
+          severity: "warning",
+          code: "constraints.locked-target-not-moved",
+          message: `Locked child ${childId} skipped during containment distribution.`,
+          path: ["constraints", constraint.id ?? constraint.containerId],
+          detail: { nodeId: childId }
+        });
+        reserved.push(intervalForBox(box, axis, mainSize));
+        continue;
+      }
+      unlocked.push({ id: childId, box });
+    }
+    if (unlocked.length < 2) {
+      continue;
+    }
+    const oversized = unlocked.filter(
+      (child) => child.box[mainSize] > content[mainSize] || child.box[crossSize] > content[crossSize]
+    );
+    if (oversized.length > 0) {
+      diagnostics.push({
+        severity: "warning",
+        code: "constraints.containment.impossible",
+        message: `Skipped ${oversized.length} oversized child(ren) during distribution in ${constraint.containerId}.`,
+        path: ["constraints", constraint.id ?? constraint.containerId],
+        detail: {
+          containerId: constraint.containerId,
+          oversized: oversized.map((c) => c.id)
+        }
+      });
+    }
+    for (const child of oversized) {
+      reserved.push(intervalForBox(child.box, axis, mainSize));
+    }
+    reserved.sort((a, b) => a.start - b.start || a.end - b.end);
+    const distributable = unlocked.filter(
+      (child) => child.box[mainSize] <= content[mainSize] && child.box[crossSize] <= content[crossSize]
+    );
+    if (distributable.length < 2) {
+      continue;
+    }
+    let pos = content[axis];
+    for (const child of distributable) {
+      pos = advancePastReserved(pos, child.box[mainSize], reserved, minGap);
+      const crossPos = content[crossAxis] + Math.max(0, (content[crossSize] - child.box[crossSize]) / 2);
+      const next = { ...child.box };
+      next[axis] = pos;
+      next[crossAxis] = crossPos;
+      const clamped = moveInside(next, content);
+      if (clamped[axis] !== next[axis]) {
+        diagnostics.push({
+          severity: "warning",
+          code: "intra_container_distributed_clamped",
+          message: `Distribution gap clamped for ${child.id} in ${constraint.containerId}.`,
+          path: ["constraints", constraint.id ?? constraint.containerId],
+          detail: { nodeId: child.id, containerId: constraint.containerId }
+        });
+      }
+      boxes.set(child.id, clamped);
+      pos = clamped[axis] + clamped[mainSize] + minGap;
+    }
+    diagnostics.push({
+      severity: "info",
+      code: "intra_container_distributed",
+      message: `Distributed ${distributable.length} children in ${constraint.containerId} along ${axis}.`,
+      path: ["constraints", constraint.id ?? constraint.containerId],
+      detail: {
+        containerId: constraint.containerId,
+        count: distributable.length,
+        axis
+      }
+    });
+  }
+}
+function intervalForBox(box, axis, mainSize) {
+  return { start: box[axis], end: box[axis] + box[mainSize] };
+}
+function advancePastReserved(pos, size, reserved, minGap) {
+  let next = pos;
+  for (const interval of reserved) {
+    if (next + size + minGap <= interval.start) {
+      break;
+    }
+    if (next >= interval.end + minGap) {
+      continue;
+    }
+    next = interval.end + minGap;
+  }
+  return next;
+}
 function moveInside(child, container) {
   return {
     ...child,
@@ -1191,7 +1482,11 @@ var DEFAULT_GROUP_PADDING = {
   left: 16
 };
 var DEFAULT_LABEL_MAX_WIDTH = 160;
-var DEFAULT_FONT = { fontFamily: "Arial", fontSize: 14, lineHeight: 18 };
+var DEFAULT_FONT = {
+  fontFamily: "Arial",
+  fontSize: 14,
+  lineHeight: 18
+};
 var DEFAULT_MATRIX_CELL_SIZE = { width: 120, height: 36 };
 var DEFAULT_TABLE_CELL_SIZE = { width: 128, height: 34 };
 var DEFAULT_PANEL_ITEM_HEIGHT = 28;
@@ -1367,7 +1662,9 @@ function endpoint(value, nodeIdOverride) {
 function style(value) {
   return {
     ...value.fill === void 0 ? {} : { fill: value.fill },
-    ...value.stroke === void 0 ? {} : { stroke: value.stroke }
+    ...value.stroke === void 0 ? {} : { stroke: value.stroke },
+    ...value.fontFamily === void 0 ? {} : { fontFamily: value.fontFamily },
+    ...value.fontSize === void 0 ? {} : { fontSize: value.fontSize }
   };
 }
 function compartments(value) {
@@ -1384,6 +1681,10 @@ function normalizeFrame(frame) {
     ...frame.context === void 0 ? {} : { context: frame.context },
     ...frame.name === void 0 ? {} : { name: frame.name },
     titleTab: frame.titleTab,
+    ...frame.headerHeight === void 0 ? {} : { headerHeight: frame.headerHeight },
+    ...frame.padding === void 0 ? {} : { padding: frame.padding },
+    ...frame.labelPosition === void 0 ? {} : { labelPosition: frame.labelPosition },
+    ...frame.direction === void 0 ? {} : { direction: frame.direction },
     ...frame.style === void 0 ? {} : { style: style(frame.style) }
   };
 }
@@ -1527,6 +1828,9 @@ function normalizeGroups(dsl, measurer) {
       nodeIds: [...group?.nodes ?? []],
       groupIds: [...group?.groups ?? []],
       padding: group?.padding ?? { ...DEFAULT_GROUP_PADDING },
+      ...group?.headerHeight === void 0 ? {} : { headerHeight: group.headerHeight },
+      ...group?.labelPosition === void 0 ? {} : { labelPosition: group.labelPosition },
+      ...group?.direction === void 0 ? {} : { direction: group.direction },
       ...labelLayout === void 0 ? {} : { labelLayout }
     };
   });
@@ -1796,6 +2100,12 @@ var insetsSchema = zod.z.object({
   bottom: finiteNumberSchema,
   left: finiteNumberSchema
 });
+var nonNegativeInsetsSchema = zod.z.object({
+  top: nonNegativeNumberSchema,
+  right: nonNegativeNumberSchema,
+  bottom: nonNegativeNumberSchema,
+  left: nonNegativeNumberSchema
+});
 var labelSchema = zod.z.union([
   zod.z.string(),
   zod.z.object({
@@ -1805,7 +2115,9 @@ var labelSchema = zod.z.union([
 ]);
 var styleSchema = zod.z.object({
   fill: zod.z.string().optional(),
-  stroke: zod.z.string().optional()
+  stroke: zod.z.string().optional(),
+  fontFamily: zod.z.string().optional(),
+  fontSize: finiteNumberSchema.optional()
 });
 var blockCellSchema = zod.z.union([
   zod.z.string(),
@@ -1876,7 +2188,10 @@ var groupSchema = zod.z.object({
   label: labelSchema.optional(),
   nodes: zod.z.array(zod.z.string()).optional(),
   groups: zod.z.array(zod.z.string()).optional(),
-  padding: insetsSchema.optional()
+  padding: insetsSchema.optional(),
+  headerHeight: nonNegativeNumberSchema.optional(),
+  labelPosition: zod.z.enum(["top", "inside", "outside"]).optional(),
+  direction: zod.z.enum(["horizontal", "vertical"]).optional()
 });
 var swimlaneSchema = zod.z.object({
   label: labelSchema.optional(),
@@ -2088,6 +2403,10 @@ var diagramDslSchema = zod.z.object({
     context: zod.z.string().optional(),
     name: zod.z.string().optional(),
     titleTab: zod.z.string(),
+    headerHeight: nonNegativeNumberSchema.optional(),
+    padding: zod.z.union([nonNegativeNumberSchema, nonNegativeInsetsSchema]).optional(),
+    labelPosition: zod.z.enum(["top", "inside", "outside"]).optional(),
+    direction: zod.z.enum(["horizontal", "vertical"]).optional(),
     style: styleSchema.optional()
   }).optional(),
   output: zod.z.object({
@@ -3222,7 +3541,7 @@ function renderSolvedTextAnnotation(annotation, className, options) {
     `data-text-surface="${escapeAttribute(annotation.surfaceKind)}"`,
     `data-owner-id="${escapeAttribute(annotation.ownerId)}"`,
     `data-text-backend="${escapeAttribute(annotation.textBackend ?? "deterministic")}"`,
-    `font-family="${FONT_FAMILY}"`,
+    `font-family="${escapeAttribute(annotation.fontFamily)}"`,
     `font-size="${formatNumber(annotation.fontSize)}"`,
     `fill="#111827"`
   ];
@@ -3550,7 +3869,12 @@ function routeEdge(input) {
       input.source.center,
       input.targetAnchor ?? defaultAnchors.targetAnchor
     );
-    const points = simplifyRoute([source, target]);
+    const points = finalizeRoute(
+      [source, target],
+      softObstacles,
+      hardObstacles,
+      diagnostics
+    );
     if (routeCrossesBoxes(points, hardObstacles)) {
       diagnostics.push({
         severity: "error",
@@ -3606,7 +3930,15 @@ function routeEdge(input) {
       candidate.points,
       candidate.endpointObstacles
     )) {
-      return { points: simplifyRoute(candidate.points), diagnostics };
+      return {
+        points: finalizeRoute(
+          candidate.points,
+          softObstacles,
+          hardObstacles,
+          diagnostics
+        ),
+        diagnostics
+      };
     }
   }
   const hardClearCandidate = candidateRoutes.find(
@@ -3622,7 +3954,12 @@ function routeEdge(input) {
       message: "No bounded orthogonal route candidate avoided all soft obstacles."
     });
     return {
-      points: simplifyRoute(hardClearCandidate.points),
+      points: finalizeRoute(
+        hardClearCandidate.points,
+        softObstacles,
+        hardObstacles,
+        diagnostics
+      ),
       diagnostics
     };
   }
@@ -3633,8 +3970,11 @@ function routeEdge(input) {
       message: "No bounded orthogonal route candidate avoided hard evidence block obstacles."
     });
     return {
-      points: simplifyRoute(
-        candidateRoutes[0]?.points ?? fallbackRoute(input, defaultAnchors)
+      points: finalizeRoute(
+        candidateRoutes[0]?.points ?? fallbackRoute(input, defaultAnchors),
+        softObstacles,
+        hardObstacles,
+        diagnostics
       ),
       diagnostics
     };
@@ -3645,12 +3985,133 @@ function routeEdge(input) {
     message: "No bounded orthogonal route candidate avoided all obstacles."
   });
   return {
-    points: simplifyRoute(
-      candidateRoutes[0]?.points ?? fallbackRoute(input, defaultAnchors)
+    points: finalizeRoute(
+      candidateRoutes[0]?.points ?? fallbackRoute(input, defaultAnchors),
+      softObstacles,
+      hardObstacles,
+      diagnostics
     ),
     diagnostics
   };
 }
+function finalizeRoute(points, softObstacles, hardObstacles, diagnostics) {
+  const simplified = simplifyRoute(points);
+  const crossesHardObstacles = routeCrossesBoxes(simplified, hardObstacles);
+  const crossesSoftObstacles = routeCrossesBoxes(simplified, softObstacles);
+  if (simplified.length < 3 && (crossesHardObstacles || crossesSoftObstacles)) {
+    diagnostics.push({
+      severity: crossesHardObstacles ? "error" : "warning",
+      code: "route_obstacle_fallback",
+      message: "Obstacle-aware routing fell back to fewer than three route points.",
+      detail: { pointCount: simplified.length }
+    });
+    return expandFallbackRoute(simplified, [
+      ...softObstacles,
+      ...hardObstacles
+    ]);
+  }
+  return simplified;
+}
+function expandFallbackRoute(points, obstacles) {
+  if (points.length !== 2) {
+    return points.map((point2) => ({ ...point2 }));
+  }
+  const [source, target] = points;
+  if (source === void 0 || target === void 0) {
+    return points.map((point2) => ({ ...point2 }));
+  }
+  if (source.y === target.y) {
+    const detourY = horizontalDetourLane(source, target, obstacles);
+    return [
+      { ...source },
+      { x: source.x, y: detourY },
+      { x: target.x, y: detourY },
+      { ...target }
+    ];
+  }
+  if (source.x === target.x) {
+    const detourX = verticalDetourLane(source, target, obstacles);
+    return [
+      { ...source },
+      { x: detourX, y: source.y },
+      { x: detourX, y: target.y },
+      { ...target }
+    ];
+  }
+  const hv = diagonalDetourHV(source, target, obstacles);
+  const vh = diagonalDetourVH(source, target, obstacles);
+  const viable = [hv, vh].filter((c) => !routeCrossesBoxes(c, obstacles));
+  if (viable.length > 0) {
+    const directLen = Math.hypot(target.x - source.x, target.y - source.y);
+    let best = viable[0];
+    for (let i = 1; i < viable.length; i += 1) {
+      const cand = viable[i];
+      if (cand !== void 0 && pathLength(cand) - directLen < pathLength(best) - directLen) {
+        best = cand;
+      }
+    }
+    return best;
+  }
+  return [
+    { ...source },
+    { x: (source.x + target.x) / 2, y: source.y },
+    { x: (source.x + target.x) / 2, y: target.y },
+    { ...target }
+  ];
+}
+function horizontalDetourLane(source, target, obstacles) {
+  const crossing = obstacles.filter(
+    (obstacle) => segmentIntersectsBox(source, target, obstacle)
+  );
+  if (crossing.length === 0) {
+    return source.y + (source.x <= target.x ? 1 : -1) * 24;
+  }
+  const margin = 24;
+  const above = Math.min(...crossing.map((obstacle) => obstacle.y)) - margin;
+  const below = Math.max(...crossing.map((obstacle) => obstacle.y + obstacle.height)) + margin;
+  return Math.abs(above - source.y) <= Math.abs(below - source.y) ? above : below;
+}
+function verticalDetourLane(source, target, obstacles) {
+  const crossing = obstacles.filter(
+    (obstacle) => segmentIntersectsBox(source, target, obstacle)
+  );
+  if (crossing.length === 0) {
+    return source.x + (source.y <= target.y ? 1 : -1) * 24;
+  }
+  const margin = 24;
+  const left = Math.min(...crossing.map((obstacle) => obstacle.x)) - margin;
+  const right = Math.max(...crossing.map((obstacle) => obstacle.x + obstacle.width)) + margin;
+  return Math.abs(left - source.x) <= Math.abs(right - source.x) ? left : right;
+}
+function diagonalDetourHV(source, target, obstacles) {
+  const detourY = horizontalDetourLane(source, target, obstacles);
+  return [
+    { ...source },
+    { x: source.x, y: detourY },
+    { x: target.x, y: detourY },
+    { ...target }
+  ];
+}
+function diagonalDetourVH(source, target, obstacles) {
+  const detourX = verticalDetourLane(source, target, obstacles);
+  return [
+    { ...source },
+    { x: detourX, y: source.y },
+    { x: detourX, y: target.y },
+    { ...target }
+  ];
+}
+function pathLength(points) {
+  let len = 0;
+  for (let i = 1; i < points.length; i += 1) {
+    const a = points[i - 1];
+    const b = points[i];
+    if (a !== void 0 && b !== void 0) {
+      len += Math.hypot(b.x - a.x, b.y - a.y);
+    }
+  }
+  return len;
+}
 function endpointObstaclesForAutoAnchors(input) {
   const boxes = [];
   if (input.sourceAnchor === void 0 && hasDistinctAnchors(input.source)) {
@@ -4022,6 +4483,15 @@ var DEFAULT_PANEL_WIDTH = 320;
 var DEFAULT_PANEL_ITEM_HEIGHT2 = 28;
 var DEFAULT_EVIDENCE_BLOCK_GAP = 24;
 var EDGE_LABEL_CLEARANCE = 8;
+var DEFAULT_CJK_FONT_FAMILY = "YaHei,SimSun,sans-serif";
+var DEFAULT_MIN_CJK_FONT_SIZE = 14;
+function prefitLabelFont(node, _options) {
+  const cjk = labelCjkTypography(node.label?.metadata);
+  const fontFamily = cjk.fontFamily ?? DEFAULT_FONT.fontFamily;
+  const fontSize = cjk.fontSize ?? DEFAULT_FONT.fontSize;
+  const lineHeight = fontSize !== DEFAULT_FONT.fontSize ? Math.max(DEFAULT_FONT.lineHeight ?? 18, fontSize * 1.2) : DEFAULT_FONT.lineHeight ?? 18;
+  return { fontFamily, fontSize, lineHeight };
+}
 var EVIDENCE_TEXT_FONT = {
   fontFamily: "Arial, sans-serif",
   fontSize: 10,
@@ -4029,43 +4499,85 @@ var EVIDENCE_TEXT_FONT = {
 };
 function solveDiagram(diagram, options = {}) {
   const diagnostics = [...diagram.diagnostics];
-  const nodes = stableById(diagram.nodes);
-  const edges = stableById(diagram.edges);
-  const groups = stableById(diagram.groups);
+  const nodes = stableUniqueById(
+    diagram.nodes,
+    diagnostics,
+    "nodes",
+    "duplicate_node_id"
+  );
+  const edges = stableUniqueById(
+    diagram.edges,
+    diagnostics,
+    "edges",
+    "duplicate_edge_id"
+  );
+  const groups = stableUniqueById(
+    diagram.groups,
+    diagnostics,
+    "groups",
+    "duplicate_group_id"
+  );
+  const cjkTypography = createCjkTypographyOptions(options);
+  const cjkStyledNodes = nodes.map(
+    (node) => enhanceNodeCjkTypography(node, cjkTypography, diagnostics)
+  );
+  const styledNodes = options.prefitLabelSize === true ? cjkStyledNodes.map(
+    (node) => prefitNodeLabelSize(node, options, diagnostics)
+  ) : cjkStyledNodes;
+  const styledEdges = edges.map(
+    (edge) => enhanceEdgeCjkTypography(edge, cjkTypography, diagnostics)
+  );
+  const styledGroups = groups.map(
+    (group) => enhanceGroupCjkTypography(group, cjkTypography, diagnostics)
+  );
+  const styledSwimlanes = (diagram.swimlanes ?? []).map(
+    (swimlane) => enhanceSwimlaneCjkTypography(swimlane, cjkTypography, diagnostics)
+  );
   const constraints = stableByConstraintId(diagram.constraints);
   const layout2 = runDagreInitialLayout({
     direction: diagram.direction,
-    nodes: nodes.map((node) => ({ id: node.id, size: node.size })),
-    edges: edges.map((edge) => ({
+    nodes: styledNodes.map((node) => ({ id: node.id, size: node.size })),
+    edges: styledEdges.map((edge) => ({
       id: edge.id,
       sourceId: edge.source.nodeId,
       targetId: edge.target.nodeId
     }))
   });
   diagnostics.push(...layout2.diagnostics);
+  const initialNodeBoxes = wrapVerticalStackIfNeeded(
+    layout2.boxes,
+    styledNodes,
+    styledEdges,
+    diagram.direction,
+    options,
+    diagnostics
+  );
   const constrained = applyLayoutConstraints({
     direction: diagram.direction,
     overlapSpacing: options?.overlapSpacing ?? 40,
-    boxes: layout2.boxes,
-    nodes,
+    ...options.minSiblingGap === void 0 ? {} : { minSiblingGap: options.minSiblingGap },
+    ...options.distributeContainedChildren === void 0 ? {} : { distributeContainedChildren: options.distributeContainedChildren },
+    boxes: initialNodeBoxes,
+    nodes: styledNodes,
     constraints
   });
   diagnostics.push(...constrained.diagnostics);
   const swimlaneContracts = applySwimlaneLayoutContracts(
-    diagram.swimlanes ?? [],
+    styledSwimlanes,
     constraints,
-    edges,
+    styledEdges,
     isTopToBottomReadingDirection(diagram.metadata?.primaryReadingDirection),
     constrained.boxes,
     constrained.locks,
-    options?.overlapSpacing ?? 40
+    options?.overlapSpacing ?? 40,
+    Math.max(0, options?.minLaneGutter ?? 0)
   );
   if (swimlaneContracts.layouts.size > 0) {
     removeResolvedOverlapDiagnostics(diagnostics, constrained.boxes);
   }
   diagnostics.push(...swimlaneContracts.diagnostics);
   const coordinatedNodes = coordinateNodes(
-    nodes,
+    styledNodes,
     constrained.boxes,
     options,
     diagnostics
@@ -4081,13 +4593,13 @@ function solveDiagram(diagram, options = {}) {
     ])
   );
   const coordinatedGroups = coordinateGroups(
-    groups,
+    styledGroups,
     constrained.boxes,
     options,
     diagnostics
   );
   const coordinatedSwimlanes = coordinateSwimlanes(
-    diagram.swimlanes ?? [],
+    styledSwimlanes,
     constrained.boxes,
     swimlaneContracts.layouts
   );
@@ -4187,7 +4699,7 @@ function solveDiagram(diagram, options = {}) {
     ...frameTextAnnotation.filter(isPreRouteTextObstacle)
   ];
   const coordinatedEdges = coordinateEdges(
-    edges,
+    styledEdges,
     nodeGeometryById,
     coordinatedNodes,
     [...nodeGeometryById.values()].map((geometry) => geometry.obstacleBox),
@@ -4203,6 +4715,11 @@ function solveDiagram(diagram, options = {}) {
   );
   const edgeTextAnnotations = coordinateEdgeTextAnnotations(
     coordinatedEdges,
+    [
+      ...coordinatedNodes.map((node) => node.box),
+      ...baseTextAnnotations.map((annotation) => annotation.box),
+      ...frameTextAnnotation.map((annotation) => annotation.box)
+    ],
     options.textMeasurer
   );
   const textAnnotations = [
@@ -4220,6 +4737,12 @@ function solveDiagram(diagram, options = {}) {
     ...edgePointBounds,
     ...edgeTextAnnotations.map((annotation) => annotation.box)
   ];
+  diagnostics.push(
+    ...reportPageOverflow(
+      frame === void 0 ? unionBoxes(boundsBase) : unionBoxes([...boundsBase, frame.box, frame.titleBox]),
+      options.pageBounds
+    )
+  );
   return {
     id: diagram.id,
     ...diagram.title === void 0 ? {} : { title: diagram.title },
@@ -4238,7 +4761,303 @@ function solveDiagram(diagram, options = {}) {
     ...diagram.metadata === void 0 ? {} : { metadata: diagram.metadata }
   };
 }
-function applySwimlaneLayoutContracts(swimlanes, constraints, edges, topToBottomFlow, nodeBoxes, locks, overlapSpacing) {
+function solveDiagramSafe(diagram, options = {}) {
+  return solveDiagram(diagram, { ...options, prefitLabelSize: true });
+}
+function prefitNodeLabelSize(node, options, diagnostics) {
+  if (node.label === void 0) {
+    return node;
+  }
+  const measurer = options.textMeasurer ?? createDefaultTextMeasurer();
+  const layout2 = fitLabel(
+    node.label.text,
+    {
+      font: prefitLabelFont(node),
+      padding: DEFAULT_NODE_PADDING,
+      minSize: DEFAULT_NODE_MIN_SIZE,
+      maxWidth: node.label.maxWidth ?? Math.max(node.size.width, DEFAULT_LABEL_MAX_WIDTH)
+    },
+    measurer
+  );
+  const width = Math.max(node.size.width, layout2.fittedSize.width);
+  const height = Math.max(node.size.height, layout2.fittedSize.height);
+  const resized = width !== node.size.width || height !== node.size.height;
+  if (resized) {
+    diagnostics.push({
+      severity: "info",
+      code: "prefit_label_resized",
+      message: `Node ${node.id} size expanded to fit its label.`,
+      path: ["nodes", node.id],
+      detail: {
+        nodeId: node.id,
+        from: { width: node.size.width, height: node.size.height },
+        to: { width, height }
+      }
+    });
+  }
+  const centeredLayout = expandLabelLayoutToNode(layout2, { width, height });
+  return { ...node, size: { width, height }, labelLayout: centeredLayout };
+}
+function expandLabelLayoutToNode(layout2, nodeSize) {
+  if (layout2.box.width >= nodeSize.width && layout2.box.height >= nodeSize.height) {
+    return layout2;
+  }
+  const offsetX = Math.max(0, (nodeSize.width - layout2.box.width) / 2);
+  const offsetY = Math.max(0, (nodeSize.height - layout2.box.height) / 2);
+  if (offsetX === 0 && offsetY === 0) {
+    return layout2;
+  }
+  return {
+    ...layout2,
+    box: {
+      x: layout2.box.x + offsetX,
+      y: layout2.box.y + offsetY,
+      width: layout2.box.width,
+      height: layout2.box.height
+    },
+    contentBox: {
+      x: layout2.contentBox.x + offsetX,
+      y: layout2.contentBox.y + offsetY,
+      width: layout2.contentBox.width,
+      height: layout2.contentBox.height
+    },
+    lines: layout2.lines.map((line) => ({
+      ...line,
+      box: {
+        x: line.box.x + offsetX,
+        y: line.box.y + offsetY,
+        width: line.box.width,
+        height: line.box.height
+      }
+    }))
+  };
+}
+function reportPageOverflow(contentBounds, pageBounds) {
+  if (pageBounds === void 0) {
+    return [];
+  }
+  const overflowRight = Math.max(
+    0,
+    contentBounds.x + contentBounds.width - pageBounds.width
+  );
+  const overflowBottom = Math.max(
+    0,
+    contentBounds.y + contentBounds.height - pageBounds.height
+  );
+  const overflowLeft = Math.max(0, -contentBounds.x);
+  const overflowTop = Math.max(0, -contentBounds.y);
+  if (overflowRight === 0 && overflowBottom === 0 && overflowLeft === 0 && overflowTop === 0) {
+    return [];
+  }
+  return [
+    {
+      severity: "warning",
+      code: "page_overflow",
+      message: `Content ${contentBounds.width}x${contentBounds.height} exceeds page ${pageBounds.width}x${pageBounds.height}.`,
+      path: ["bounds"],
+      detail: {
+        page: { width: pageBounds.width, height: pageBounds.height },
+        content: {
+          width: contentBounds.width,
+          height: contentBounds.height
+        },
+        overflow: {
+          right: overflowRight,
+          bottom: overflowBottom,
+          left: overflowLeft,
+          top: overflowTop
+        }
+      }
+    }
+  ];
+}
+function createCjkTypographyOptions(options) {
+  const fontFamily = options.cjkFontFamily === false ? void 0 : options.cjkFontFamily ?? DEFAULT_CJK_FONT_FAMILY;
+  const minFontSize = options.minCjkFontSize === false ? void 0 : options.minCjkFontSize ?? DEFAULT_MIN_CJK_FONT_SIZE;
+  return {
+    ...fontFamily === void 0 ? {} : { fontFamily },
+    ...minFontSize === void 0 ? {} : { minFontSize }
+  };
+}
+function enhanceNodeCjkTypography(node, options, diagnostics) {
+  const nodeWithStyle = enhanceStyledLabelOwner(
+    node,
+    ["nodes", node.id],
+    options,
+    diagnostics
+  );
+  const ports = nodeWithStyle.ports === void 0 ? void 0 : nodeWithStyle.ports.map(
+    (port) => enhanceStyledLabelOwner(
+      port,
+      ["nodes", node.id, "ports", port.id],
+      options,
+      diagnostics
+    )
+  );
+  return ports === void 0 ? nodeWithStyle : { ...nodeWithStyle, ports };
+}
+function enhanceEdgeCjkTypography(edge, options, diagnostics) {
+  return enhanceStyledLabelOwner(
+    edge,
+    ["edges", edge.id],
+    options,
+    diagnostics
+  );
+}
+function enhanceGroupCjkTypography(group, options, diagnostics) {
+  return enhanceStyledLabelOwner(
+    group,
+    ["groups", group.id],
+    options,
+    diagnostics
+  );
+}
+function enhanceSwimlaneCjkTypography(swimlane, options, diagnostics) {
+  const root = enhanceStyledLabelOwner(
+    swimlane,
+    ["swimlanes", swimlane.id],
+    options,
+    diagnostics
+  );
+  const lanes = root.lanes.map(
+    (lane) => enhanceSwimlaneLaneCjkTypography(swimlane.id, lane, options, diagnostics)
+  );
+  return { ...root, lanes };
+}
+function enhanceSwimlaneLaneCjkTypography(swimlaneId, lane, options, diagnostics) {
+  return enhanceStyledLabelOwner(
+    lane,
+    ["swimlanes", swimlaneId, "lanes", lane.id],
+    options,
+    diagnostics
+  );
+}
+function enhanceStyledLabelOwner(owner, path, options, diagnostics) {
+  const text = owner.label?.text;
+  if (text === void 0 || !containsCjk(text)) {
+    return owner;
+  }
+  const typography = cjkTypographyForOwner(owner, options);
+  if (typography.fontFamily === void 0 && typography.fontSize === void 0) {
+    return owner;
+  }
+  const label = owner.label;
+  if (label === void 0) {
+    return owner;
+  }
+  const nextLabel = {
+    ...label,
+    metadata: {
+      ...metadataObject(label.metadata),
+      cjkTypography: typography
+    }
+  };
+  const nextOwner = { ...owner, label: nextLabel };
+  const maybeStyled = nextOwner;
+  const nextStyle = enhanceCjkStyle(maybeStyled.style, typography);
+  reportCjkTypographyDiagnostics(
+    path,
+    typography,
+    maybeStyled.style,
+    diagnostics
+  );
+  return nextStyle === maybeStyled.style ? nextOwner : { ...nextOwner, style: nextStyle };
+}
+function cjkTypographyForOwner(owner, options) {
+  const metadataTypography = labelCjkTypography(owner.label?.metadata);
+  const fontFamily = metadataTypography.fontFamily ?? owner.style?.fontFamily ?? options.fontFamily;
+  const fontSize = boostedCjkFontSize(
+    metadataTypography.fontSize ?? owner.style?.fontSize,
+    options.minFontSize
+  );
+  return {
+    ...fontFamily === void 0 ? {} : { fontFamily },
+    ...fontSize === void 0 ? {} : { fontSize }
+  };
+}
+function labelCjkTypography(metadata) {
+  const metadataRecord = metadataObject(metadata);
+  if (metadataRecord === void 0) {
+    return {};
+  }
+  const value = metadataRecord.cjkTypography;
+  if (value === void 0 || value === null || typeof value !== "object") {
+    return {};
+  }
+  const typography = value;
+  const fontFamily = typeof typography.fontFamily === "string" ? typography.fontFamily : void 0;
+  const fontSize = typeof typography.fontSize === "number" && Number.isFinite(typography.fontSize) && typography.fontSize > 0 ? typography.fontSize : void 0;
+  return {
+    ...fontFamily === void 0 ? {} : { fontFamily },
+    ...fontSize === void 0 ? {} : { fontSize }
+  };
+}
+function metadataObject(metadata) {
+  if (metadata === void 0 || metadata === null || typeof metadata !== "object" || Array.isArray(metadata)) {
+    return void 0;
+  }
+  return metadata;
+}
+function typographyForLabel(label) {
+  return labelCjkTypography(label?.metadata);
+}
+function typographyTextStyle(label, base) {
+  const typography = typographyForLabel(label);
+  return {
+    ...base,
+    ...typography.fontFamily === void 0 ? {} : { fontFamily: typography.fontFamily },
+    ...typography.fontSize === void 0 ? {} : {
+      fontSize: typography.fontSize,
+      lineHeight: Math.max(base.lineHeight ?? 0, typography.fontSize * 1.2)
+    }
+  };
+}
+function boostedCjkFontSize(current, minFontSize) {
+  if (minFontSize === void 0) {
+    return current;
+  }
+  if (current === void 0 || current < minFontSize) {
+    return minFontSize;
+  }
+  return current;
+}
+function enhanceCjkStyle(style2, typography) {
+  let next = style2;
+  if (typography.fontFamily !== void 0 && next?.fontFamily === void 0) {
+    next = { ...next, fontFamily: typography.fontFamily };
+  }
+  if (typography.fontSize !== void 0 && (next?.fontSize === void 0 || next.fontSize < typography.fontSize)) {
+    next = { ...next, fontSize: typography.fontSize };
+  }
+  return next;
+}
+function reportCjkTypographyDiagnostics(path, typography, previousStyle, diagnostics) {
+  if (typography.fontFamily !== void 0 && previousStyle?.fontFamily === void 0) {
+    diagnostics.push({
+      severity: "info",
+      code: "cjk_font_family_applied",
+      message: `Applied CJK font family ${typography.fontFamily}.`,
+      path: [...path, "label", "metadata", "cjkTypography", "fontFamily"],
+      detail: { fontFamily: typography.fontFamily }
+    });
+  }
+  if (typography.fontSize !== void 0 && (previousStyle?.fontSize === void 0 || previousStyle.fontSize < typography.fontSize)) {
+    diagnostics.push({
+      severity: "info",
+      code: "cjk_font_size_boosted",
+      message: `Raised CJK font size to ${typography.fontSize}.`,
+      path: [...path, "label", "metadata", "cjkTypography", "fontSize"],
+      detail: {
+        minFontSize: typography.fontSize,
+        ...previousStyle?.fontSize === void 0 ? {} : { previousFontSize: previousStyle.fontSize }
+      }
+    });
+  }
+}
+function containsCjk(value) {
+  return /[\u3400-\u4dbf\u4e00-\u9fff\uf900-\ufaff]/u.test(value);
+}
+function applySwimlaneLayoutContracts(swimlanes, constraints, edges, topToBottomFlow, nodeBoxes, locks, overlapSpacing, laneGutter) {
   const layouts = /* @__PURE__ */ new Map();
   const diagnostics = [];
   const movedChildIds = /* @__PURE__ */ new Set();
@@ -4256,7 +5075,8 @@ function applySwimlaneLayoutContracts(swimlanes, constraints, edges, topToBottom
       nodeBoxes,
       locks,
       diagnostics,
-      movedChildIds
+      movedChildIds,
+      laneGutter
     );
     if (layout2 !== void 0) {
       layouts.set(swimlane.id, layout2);
@@ -4271,10 +5091,123 @@ function applySwimlaneLayoutContracts(swimlanes, constraints, edges, topToBottom
         movedChildIds
       )
     );
+    if (laneGutter > 0) {
+      diagnostics.push({
+        severity: "info",
+        code: "lane_gutter_applied",
+        message: `Applied ${laneGutter}px gutter between ${layouts.size} contract swimlane lane(s).`,
+        path: ["swimlanes"],
+        detail: { laneGutter, swimlaneCount: layouts.size }
+      });
+    }
   }
   return { layouts, diagnostics, movedChildIds };
 }
-function applySingleSwimlaneContract(swimlane, edges, topToBottomFlow, nodeBoxes, locks, diagnostics, movedChildIds) {
+function wrapVerticalStackIfNeeded(boxes, nodes, edges, direction, options, diagnostics) {
+  const wrapped = new Map([...boxes].map(([id, box]) => [id, { ...box }]));
+  const maxStackDepth = options.maxStackDepth;
+  if (maxStackDepth === void 0 || maxStackDepth <= 0 || nodes.length <= maxStackDepth) {
+    reportVerticalRunaway(
+      wrapped,
+      nodes,
+      edges,
+      direction,
+      options,
+      diagnostics
+    );
+    return wrapped;
+  }
+  if (edges.length > 0 || !isVerticalRunaway(wrapped, nodes, direction, options)) {
+    reportVerticalRunaway(
+      wrapped,
+      nodes,
+      edges,
+      direction,
+      options,
+      diagnostics
+    );
+    return wrapped;
+  }
+  const ordered = nodes.map((node) => ({ node, box: wrapped.get(node.id) })).filter(
+    (item) => item.box !== void 0
+  ).sort((a, b) => {
+    const delta = a.box.y - b.box.y;
+    return delta === 0 ? a.node.id.localeCompare(b.node.id) : delta;
+  });
+  const columns = Math.ceil(ordered.length / maxStackDepth);
+  const horizontalGap = options.overlapSpacing ?? 40;
+  const verticalGap = Math.max(24, horizontalGap / 2);
+  const columnWidths = Array.from(
+    { length: columns },
+    (_, column) => Math.max(
+      0,
+      ...ordered.slice(column * maxStackDepth, (column + 1) * maxStackDepth).map((item) => item.box.width)
+    )
+  );
+  const startX = Math.min(...ordered.map((item) => item.box.x));
+  const startY = Math.min(...ordered.map((item) => item.box.y));
+  let columnX = startX;
+  for (let column = 0; column < columns; column += 1) {
+    let y = startY;
+    const items = ordered.slice(
+      column * maxStackDepth,
+      (column + 1) * maxStackDepth
+    );
+    for (const item of items) {
+      wrapped.set(item.node.id, { ...item.box, x: columnX, y });
+      y += item.box.height + verticalGap;
+    }
+    columnX += (columnWidths[column] ?? 0) + horizontalGap;
+  }
+  diagnostics.push({
+    severity: "warning",
+    code: "vertical_runaway",
+    message: `Single-column layout exceeded maxStackDepth ${maxStackDepth}; wrapped into ${columns} columns.`,
+    path: ["nodes"],
+    detail: { nodeCount: ordered.length, maxStackDepth, columns }
+  });
+  return wrapped;
+}
+function reportVerticalRunaway(boxes, nodes, edges, direction, options, diagnostics) {
+  if (!isVerticalRunaway(boxes, nodes, direction, options)) {
+    return;
+  }
+  diagnostics.push({
+    severity: "warning",
+    code: "vertical_runaway",
+    message: "Layout produced a tall vertical stack beyond the preferred aspect ratio.",
+    path: ["nodes"],
+    detail: {
+      nodeCount: nodes.length,
+      edgeCount: edges.length,
+      ...options.preferredAspectRatio === void 0 ? {} : { preferredAspectRatio: options.preferredAspectRatio },
+      ...options.maxStackDepth === void 0 ? {} : { maxStackDepth: options.maxStackDepth }
+    }
+  });
+}
+function isVerticalRunaway(boxes, nodes, direction, options) {
+  if (options.maxStackDepth === void 0 && options.preferredAspectRatio === void 0) {
+    return false;
+  }
+  if (nodes.length < 2 || direction !== "LR" && direction !== "RL") {
+    return false;
+  }
+  const nodeBoxes = nodes.map((node) => boxes.get(node.id)).filter((box) => box !== void 0);
+  if (nodeBoxes.length < 2) {
+    return false;
+  }
+  const bounds = unionBoxes(nodeBoxes);
+  const aspectRatio = bounds.width <= 0 ? Number.POSITIVE_INFINITY : bounds.height / bounds.width;
+  const preferred = options.preferredAspectRatio ?? 3;
+  if (aspectRatio < preferred) {
+    return false;
+  }
+  const xCenters = nodeBoxes.map((box) => box.x + box.width / 2);
+  const xSpread = Math.max(...xCenters) - Math.min(...xCenters);
+  const maxWidth = Math.max(...nodeBoxes.map((box) => box.width));
+  return xSpread <= Math.max(maxWidth, options.overlapSpacing ?? 40);
+}
+function applySingleSwimlaneContract(swimlane, edges, topToBottomFlow, nodeBoxes, locks, diagnostics, movedChildIds, laneGutter) {
   const headerHeight = swimlane.headerHeight ?? 28;
   const padding = swimlane.padding ?? 16;
   const laneBounds = swimlane.lanes.map((lane) => {
@@ -4298,7 +5231,8 @@ function applySingleSwimlaneContract(swimlane, edges, topToBottomFlow, nodeBoxes
       padding,
       locks,
       diagnostics,
-      movedChildIds
+      movedChildIds,
+      laneGutter
     );
   }
   return applyHorizontalSwimlaneContract(
@@ -4309,10 +5243,11 @@ function applySingleSwimlaneContract(swimlane, edges, topToBottomFlow, nodeBoxes
     padding,
     locks,
     diagnostics,
-    movedChildIds
+    movedChildIds,
+    laneGutter
   );
 }
-function applyVerticalSwimlaneContract(swimlane, edges, topToBottomFlow, nodeBoxes, laneBounds, headerHeight, padding, locks, diagnostics, movedChildIds) {
+function applyVerticalSwimlaneContract(swimlane, edges, topToBottomFlow, nodeBoxes, laneBounds, headerHeight, padding, locks, diagnostics, movedChildIds, laneGutter) {
   const populatedBounds = laneBounds.filter(
     (box) => box !== void 0
   );
@@ -4331,6 +5266,7 @@ function applyVerticalSwimlaneContract(swimlane, edges, topToBottomFlow, nodeBox
   const rankSpacing = Math.max(96, maxRankStackHeight + padding);
   const contentHeight = maxRank === 0 ? maxChildHeight : maxRankStackHeight + maxRank * rankSpacing;
   const slotWidth = Math.max(...populatedBounds.map((box) => box.width)) + padding * 2;
+  const laneStep = slotWidth + laneGutter;
   const laneContentTop = top + headerHeight + padding;
   for (let index = 0; index < swimlane.lanes.length; index += 1) {
     const lane = swimlane.lanes[index];
@@ -4339,7 +5275,7 @@ function applyVerticalSwimlaneContract(swimlane, edges, topToBottomFlow, nodeBox
       continue;
     }
     const target = {
-      x: left + slotWidth * index + padding,
+      x: left + laneStep * index + padding,
       y: laneContentTop
     };
     if (maxRank === 0) {
@@ -4375,11 +5311,12 @@ function applyVerticalSwimlaneContract(swimlane, edges, topToBottomFlow, nodeBox
     box: {
       x: left,
       y: top,
-      width: slotWidth * swimlane.lanes.length,
+      width: laneStep * (swimlane.lanes.length - 1) + slotWidth,
       height: contentHeight + padding * 2 + headerHeight
     },
     slotWidth,
-    slotHeight: contentHeight + padding * 2 + headerHeight
+    slotHeight: contentHeight + padding * 2 + headerHeight,
+    laneStep
   };
 }
 function isTopToBottomReadingDirection(value) {
@@ -4524,7 +5461,7 @@ function rankStacks(childIds, nodeBoxes, flowRanks) {
   }
   return stacks;
 }
-function applyHorizontalSwimlaneContract(swimlane, nodeBoxes, laneBounds, headerHeight, padding, locks, diagnostics, movedChildIds) {
+function applyHorizontalSwimlaneContract(swimlane, nodeBoxes, laneBounds, headerHeight, padding, locks, diagnostics, movedChildIds, laneGutter) {
   const populatedBounds = laneBounds.filter(
     (box) => box !== void 0
   );
@@ -4532,6 +5469,7 @@ function applyHorizontalSwimlaneContract(swimlane, nodeBoxes, laneBounds, header
   const left = Math.min(...populatedBounds.map((box) => box.x));
   const slotWidth = Math.max(...populatedBounds.map((box) => box.width)) + headerHeight + padding * 2;
   const slotHeight = Math.max(...populatedBounds.map((box) => box.height)) + padding * 2;
+  const laneStep = slotHeight + laneGutter;
   for (let index = 0; index < swimlane.lanes.length; index += 1) {
     const lane = swimlane.lanes[index];
     const bounds = laneBounds[index];
@@ -4540,7 +5478,7 @@ function applyHorizontalSwimlaneContract(swimlane, nodeBoxes, laneBounds, header
     }
     const target = {
       x: left + headerHeight + padding,
-      y: top + slotHeight * index + padding
+      y: top + laneStep * index + padding
     };
     moveLaneChildren(
       lane.children,
@@ -4559,10 +5497,11 @@ function applyHorizontalSwimlaneContract(swimlane, nodeBoxes, laneBounds, header
       x: left,
       y: top,
       width: slotWidth,
-      height: slotHeight * swimlane.lanes.length
+      height: laneStep * (swimlane.lanes.length - 1) + slotHeight
     },
     slotWidth,
-    slotHeight
+    slotHeight,
+    laneStep
   };
 }
 function moveLaneChildren(childIds, nodeBoxes, locks, diagnostics, movedChildIds, offset) {
@@ -4891,7 +5830,10 @@ function coordinatePorts(node, nodeBox, portShifting) {
 }
 function portAnchor(nodeBox, side, index, count, portShifting) {
   const shiftingEnabled = portShifting?.enabled ?? true;
-  const spacing = portShifting?.spacing ?? 24;
+  const requestedSpacing = portShifting?.spacing ?? 24;
+  const maxOffset = side === "left" || side === "right" ? nodeBox.height / 2 : nodeBox.width / 2;
+  const availableSpan = 2 * maxOffset;
+  const spacing = shiftingEnabled && count > 1 ? Math.min(requestedSpacing, availableSpan / (count - 1)) : requestedSpacing;
   const centeredOffset = shiftingEnabled ? (index - (count - 1) / 2) * spacing : 0;
   switch (side) {
     case "left":
@@ -4946,13 +5888,13 @@ function coordinateSwimlanes(swimlanes, nodeBoxes, layouts) {
     if (layout2 === "contract" && contractLayout !== void 0) {
       const lanes2 = swimlane.lanes.map((lane, index) => {
         const box = swimlane.orientation === "vertical" ? {
-          x: contractLayout.box.x + contractLayout.slotWidth * index,
+          x: contractLayout.box.x + contractLayout.laneStep * index,
           y: contractLayout.box.y,
           width: contractLayout.slotWidth,
           height: contractLayout.box.height
         } : {
           x: contractLayout.box.x,
-          y: contractLayout.box.y + contractLayout.slotHeight * index,
+          y: contractLayout.box.y + contractLayout.laneStep * index,
           width: contractLayout.box.width,
           height: contractLayout.slotHeight
         };
@@ -5053,17 +5995,19 @@ function coordinateSwimlanes(swimlanes, nodeBoxes, layouts) {
   });
 }
 function coordinateFrame(frame, contentBounds) {
-  const padding = 32;
-  const titleHeight = 28;
+  const padding = framePadding(frame.padding);
+  const titleHeight = frame.headerHeight ?? 28;
   const titleWidth = Math.max(180, frame.titleTab.length * 7);
   const box = {
-    x: contentBounds.x - padding,
-    y: contentBounds.y - padding - titleHeight,
-    width: contentBounds.width + padding * 2,
-    height: contentBounds.height + padding * 2 + titleHeight
+    x: contentBounds.x - padding.left,
+    y: contentBounds.y - padding.top - titleHeight,
+    width: contentBounds.width + padding.left + padding.right,
+    height: contentBounds.height + padding.top + padding.bottom + titleHeight
   };
   return {
     ...frame,
+    headerHeight: titleHeight,
+    padding: frame.padding ?? 32,
     box,
     titleBox: {
       x: box.x,
@@ -5073,6 +6017,9 @@ function coordinateFrame(frame, contentBounds) {
     }
   };
 }
+function framePadding(value) {
+  return normalizeInsets(value ?? 32);
+}
 function expand(box, padding, titleSize) {
   return {
     x: box.x - padding,
@@ -5168,10 +6115,16 @@ function edgeBounds(edges) {
     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));
+    const extraPoints = [];
+    if (edge.points.length >= 2) {
+      const arrowhead = computeArrowhead(edge.points);
+      extraPoints.push(arrowhead.tip, arrowhead.left, arrowhead.right);
+    }
+    const allPoints = [...edge.points, ...extraPoints];
+    const minX = Math.min(...allPoints.map((point2) => point2.x));
+    const minY = Math.min(...allPoints.map((point2) => point2.y));
+    const maxX = Math.max(...allPoints.map((point2) => point2.x));
+    const maxY = Math.max(...allPoints.map((point2) => point2.y));
     return [
       {
         x: minX,
@@ -5568,6 +6521,7 @@ function coordinateBaseTextAnnotations(input) {
         ownerId: node.id,
         surfaceKind: "node-label",
         layout: layout2,
+        typography: typographyForLabel(node.label),
         anchor: node.box
       })
     );
@@ -5583,6 +6537,7 @@ function coordinateBaseTextAnnotations(input) {
         ownerId: group.id,
         surfaceKind: "group-label",
         layout: layout2,
+        typography: typographyForLabel(group.label),
         anchor: group.box
       })
     );
@@ -5595,7 +6550,11 @@ function coordinateBaseTextAnnotations(input) {
       const layout2 = fitLabel(
         port.label.text,
         {
-          font: { fontFamily: "Arial", fontSize: 10, lineHeight: 12 },
+          font: typographyTextStyle(port.label, {
+            fontFamily: "Arial",
+            fontSize: 10,
+            lineHeight: 12
+          }),
           padding: { top: 0, right: 0, bottom: 0, left: 0 },
           minSize: { width: 0, height: 0 },
           maxWidth: 160
@@ -5607,6 +6566,7 @@ function coordinateBaseTextAnnotations(input) {
           ownerId: `${node.id}.${port.id}`,
           surfaceKind: "port-label",
           layout: layout2,
+          typography: typographyForLabel(port.label),
           anchor: portLabelBox(port)
         })
       );
@@ -5657,7 +6617,11 @@ function coordinateBaseTextAnnotations(input) {
       const layout2 = fitLabel(
         lane.label.text,
         {
-          font: { fontFamily: "Arial", fontSize: 12, lineHeight: 14 },
+          font: typographyTextStyle(lane.label, {
+            fontFamily: "Arial",
+            fontSize: 12,
+            lineHeight: 14
+          }),
           padding: { top: 0, right: 0, bottom: 0, left: 0 },
           minSize: { width: 0, height: 0 },
           maxWidth: swimlane.orientation === "horizontal" ? labelBox.height : labelBox.width
@@ -5669,6 +6633,7 @@ function coordinateBaseTextAnnotations(input) {
           ownerId: `${swimlane.id}.${lane.id}`,
           surfaceKind: "swimlane-label",
           layout: layout2,
+          typography: typographyForLabel(lane.label),
           anchor: labelBox
         })
       );
@@ -5676,9 +6641,10 @@ function coordinateBaseTextAnnotations(input) {
   }
   return annotations;
 }
-function coordinateEdgeTextAnnotations(edges, textMeasurer) {
+function coordinateEdgeTextAnnotations(edges, obstacleBoxes, textMeasurer) {
   const measurer = textMeasurer ?? createDefaultTextMeasurer();
   const annotations = [];
+  const placedLabelBoxes = [];
   for (const edge of edges) {
     if (edge.label?.text === void 0) {
       continue;
@@ -5686,19 +6652,37 @@ function coordinateEdgeTextAnnotations(edges, textMeasurer) {
     const layout2 = fitLabel(
       edge.label.text,
       {
-        font: { fontFamily: "Arial", fontSize: 12, lineHeight: 14 },
+        font: typographyTextStyle(edge.label, {
+          fontFamily: "Arial",
+          fontSize: 12,
+          lineHeight: 14
+        }),
         padding: { top: 0, right: 0, bottom: 0, left: 0 },
         minSize: { width: 0, height: 0 },
         maxWidth: 200
       },
       measurer
     );
+    const center = edgeLabelAnchor(
+      edge,
+      layout2,
+      edges,
+      obstacleBoxes,
+      placedLabelBoxes
+    );
+    placedLabelBoxes.push({
+      x: center.x - layout2.box.width / 2,
+      y: center.y - layout2.box.height / 2,
+      width: layout2.box.width,
+      height: layout2.box.height
+    });
     annotations.push(
       buildCenteredTextAnnotation({
         ownerId: edge.id,
         surfaceKind: "edge-label",
         layout: layout2,
-        center: edgeLabelAnchor(edge, layout2, edges)
+        typography: typographyForLabel(edge.label),
+        center
       })
     );
   }
@@ -5737,7 +6721,8 @@ function buildTextAnnotation(input) {
     anchor: input.anchor,
     paddings: input.layout.padding,
     lines: input.layout.lines,
-    fontSize: input.layout.font.fontSize,
+    fontFamily: input.typography?.fontFamily ?? normalizeOutputFontFamily(input.layout.font),
+    fontSize: input.typography?.fontSize ?? input.layout.font.fontSize,
     textBackend: input.layout.textBackend
   };
 }
@@ -5747,6 +6732,7 @@ function buildAnchorCenteredTextAnnotation(input) {
     surfaceKind: input.surfaceKind,
     ...input.surfaceIndex === void 0 ? {} : { surfaceIndex: input.surfaceIndex },
     layout: input.layout,
+    ...input.typography === void 0 ? {} : { typography: input.typography },
     center: {
       x: input.anchor.x + input.anchor.width / 2,
       y: input.anchor.y + input.anchor.height / 2
@@ -5769,10 +6755,14 @@ function buildCenteredTextAnnotation(input) {
     anchor: input.anchor ?? input.center,
     paddings: input.layout.padding,
     lines: input.layout.lines,
-    fontSize: input.layout.font.fontSize,
+    fontFamily: input.typography?.fontFamily ?? normalizeOutputFontFamily(input.layout.font),
+    fontSize: input.typography?.fontSize ?? input.layout.font.fontSize,
     textBackend: input.layout.textBackend
   };
 }
+function normalizeOutputFontFamily(font) {
+  return font.fontFamily === "Arial" ? "Arial, sans-serif" : font.fontFamily;
+}
 function reportTextAnnotationCollisions(annotations) {
   const diagnostics = [];
   const relevantAnnotations = annotations.filter(
@@ -5962,12 +6952,16 @@ function fallbackLabelLayout(text) {
     diagnostics: []
   };
 }
-function edgeLabelAnchor(edge, layout2, edges) {
+function edgeLabelAnchor(edge, layout2, edges, obstacleBoxes, placedLabelBoxes) {
   const placement = labelPlacementOnPolyline2(edge.points);
   if (placement === void 0) {
     return { x: 0, y: 0 };
   }
-  for (const candidate of edgeLabelAnchorCandidates(edge.points, placement)) {
+  for (const candidate of edgeLabelAnchorCandidates(
+    edge.points,
+    placement,
+    layout2
+  )) {
     const labelBox = {
       x: candidate.x - layout2.box.width / 2,
       y: candidate.y - layout2.box.height / 2,
@@ -5980,36 +6974,55 @@ function edgeLabelAnchor(edge, layout2, edges) {
     const crossesOtherRoute = edges.some(
       (other) => other.id !== edge.id && routeIntersectsTextBox(other.points, labelBox)
     );
-    if (!crossesOtherRoute) {
+    if (crossesOtherRoute) {
+      continue;
+    }
+    const overlapsNode = obstacleBoxes.some(
+      (box) => intersectsAabb(labelBox, box)
+    );
+    if (overlapsNode) {
+      continue;
+    }
+    const overlapsPlacedLabel = placedLabelBoxes.some(
+      (box) => intersectsAabb(labelBox, box)
+    );
+    if (!overlapsPlacedLabel) {
       return candidate;
     }
   }
   return placement;
 }
-function edgeLabelAnchorCandidates(points, placement) {
+function edgeLabelAnchorCandidates(points, placement, layout2) {
   const segment = labelSegmentOnPolyline(points);
   if (segment === void 0) {
     return [placement];
   }
+  const candidates = [placement];
   if (segment.start.y === segment.end.y) {
-    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 }
-    ];
+    const needed = layout2.box.height / 2 + EDGE_LABEL_CLEARANCE;
+    const maxSteps = Math.max(12, Math.ceil(needed / EDGE_LABEL_CLEARANCE));
+    for (let step = 1; step <= maxSteps; step += 1) {
+      const offset = EDGE_LABEL_CLEARANCE * step;
+      candidates.push(
+        { x: placement.x, y: placement.y - offset },
+        { x: placement.x, y: placement.y + offset }
+      );
+    }
+    return candidates;
   }
   if (segment.start.x === segment.end.x) {
-    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 }
-    ];
+    const needed = layout2.box.width / 2 + EDGE_LABEL_CLEARANCE;
+    const maxSteps = Math.max(12, Math.ceil(needed / EDGE_LABEL_CLEARANCE));
+    for (let step = 1; step <= maxSteps; step += 1) {
+      const offset = EDGE_LABEL_CLEARANCE * step;
+      candidates.push(
+        { x: placement.x + offset, y: placement.y },
+        { x: placement.x - offset, y: placement.y }
+      );
+    }
+    return candidates;
   }
-  return [placement];
+  return candidates;
 }
 function labelPlacementOnPolyline2(points) {
   return labelSegmentOnPolyline(points)?.placement;
@@ -6100,8 +7113,26 @@ function portGeometry(nodeGeometry, port) {
     obstacleBox: port.box
   };
 }
-function stableById(items) {
-  return [...items].sort((a, b) => a.id.localeCompare(b.id));
+function stableUniqueById(items, diagnostics, pathRoot, code) {
+  const firstById = /* @__PURE__ */ new Map();
+  for (let index = 0; index < items.length; index += 1) {
+    const item = items[index];
+    if (item === void 0) {
+      continue;
+    }
+    if (firstById.has(item.id)) {
+      diagnostics.push({
+        severity: "error",
+        code,
+        message: `Duplicate ${pathRoot.slice(0, -1)} id ${item.id} was ignored; first occurrence was kept.`,
+        path: [pathRoot, index, "id"],
+        detail: { id: item.id, duplicateIndex: index }
+      });
+      continue;
+    }
+    firstById.set(item.id, item);
+  }
+  return [...firstById.values()].sort((a, b) => a.id.localeCompare(b.id));
 }
 function stableByConstraintId(items) {
   return [...items].sort(
@@ -6383,6 +7414,7 @@ exports.routeEdge = routeEdge;
 exports.runDagreInitialLayout = runDagreInitialLayout;
 exports.simplifyRoute = simplifyRoute;
 exports.solveDiagram = solveDiagram;
+exports.solveDiagramSafe = solveDiagramSafe;
 exports.sortDslDiagnostics = sortDslDiagnostics;
 exports.stringifyCanonical = stringifyCanonical;
 exports.toCanvasFont = toCanvasFont;