@crazyhappyone/auto-graph 0.0.2 → 0.0.4

package/dist/index.js

@@ -1197,6 +1197,7 @@ function normalizeDiagramDsl(dslValue, options = {}) {
   const measurer = options.textMeasurer ?? createDefaultTextMeasurer();
   const routeKind = dsl.routing?.kind ?? "orthogonal";
   const portShifting = normalizePortShifting(dsl.routing?.portShifting);
+  const primaryReadingDirection = dsl.layout?.primaryReadingDirection;
   const diagram = {
     id: options.id ?? dsl.id ?? "diagram",
     ...dsl.title === void 0 ? {} : { title: dsl.title },
@@ -1210,6 +1211,7 @@ function normalizeDiagramDsl(dslValue, options = {}) {
     ...dsl.frame === void 0 ? {} : { frame: normalizeFrame(dsl.frame) },
     metadata: {
       routeKind,
+      ...primaryReadingDirection === void 0 ? {} : { primaryReadingDirection },
       ...portShifting === void 0 ? {} : { portShifting }
     }
   };
@@ -1380,14 +1382,17 @@ function formatCompartmentEntry(value) {
   return `${entry[0]}: ${entry[1]}`;
 }
 function normalizeSwimlanes(dsl) {
-  return Object.keys(dsl.swimlanes ?? {}).sort().map((id) => {
+  return Object.keys(dsl.swimlanes ?? {}).map((id) => {
     const swimlane = dsl.swimlanes?.[id];
     const label = toLabel(swimlane?.label);
     return {
       id,
       ...label === void 0 ? {} : { label },
       orientation: swimlane?.orientation ?? "vertical",
-      lanes: Object.keys(swimlane?.lanes ?? {}).sort().map((laneId) => {
+      layout: swimlane?.layout ?? "overlay",
+      ...swimlane?.headerHeight === void 0 ? {} : { headerHeight: swimlane.headerHeight },
+      ...swimlane?.padding === void 0 ? {} : { padding: swimlane.padding },
+      lanes: Object.keys(swimlane?.lanes ?? {}).map((laneId) => {
         const lane = swimlane?.lanes[laneId];
         const laneLabel = toLabel(lane?.label);
         return {
@@ -1465,11 +1470,6 @@ function validateReferences(dsl) {
   const diagnostics = [];
   const nodeIds = new Set(Object.keys(dsl.nodes));
   const groupIds = new Set(Object.keys(dsl.groups ?? {}));
-  const swimlaneLaneIds = new Set(
-    Object.entries(dsl.swimlanes ?? {}).flatMap(
-      ([swimlaneId, swimlane]) => Object.keys(swimlane.lanes).map((laneId) => `${swimlaneId}.${laneId}`)
-    )
-  );
   (dsl.edges ?? []).forEach((edge, index) => {
     if (typeof edge === "string") {
       return;
@@ -1577,10 +1577,12 @@ function validateReferences(dsl) {
         break;
       case "containment": {
         const container = constraint.containerId ?? constraint.container;
-        if (container !== void 0 && !hasNodeOrGroup(container, nodeIds, groupIds, swimlaneLaneIds)) {
-          diagnostics.push(
-            referenceMissing(["constraints", index, "container"], container)
-          );
+        if (container !== void 0) {
+          if (!nodeIds.has(container)) {
+            diagnostics.push(
+              referenceMissing(["constraints", index, "container"], container)
+            );
+          }
         }
         (constraint.childIds ?? constraint.children ?? []).forEach(
           (child, childIndex) => {
@@ -1657,6 +1659,10 @@ var routeKindSchema = z.enum(["orthogonal", "straight"]);
 var outputFormatSchema = z.enum(["svg", "excalidraw"]);
 var edgeStrokeStyleSchema = z.enum(["solid", "dashed"]);
 var edgeArrowheadSchema = z.enum(["triangle", "hollowTriangle"]);
+var primaryReadingDirectionSchema = z.enum([
+  "top_to_bottom",
+  "top-to-bottom"
+]);
 var nodeShapeSchema = z.enum([
   "rectangle",
   "rounded-rectangle",
@@ -1667,6 +1673,7 @@ var nodeShapeSchema = z.enum([
   "cylinder"
 ]);
 var finiteNumberSchema = z.number().finite();
+var nonNegativeNumberSchema = finiteNumberSchema.min(0);
 var pointSchema = z.object({
   x: finiteNumberSchema,
   y: finiteNumberSchema
@@ -1753,6 +1760,9 @@ var groupSchema = z.object({
 var swimlaneSchema = z.object({
   label: labelSchema.optional(),
   orientation: z.enum(["vertical", "horizontal"]).optional(),
+  layout: z.enum(["overlay", "contract"]).optional(),
+  headerHeight: nonNegativeNumberSchema.optional(),
+  padding: nonNegativeNumberSchema.optional(),
   lanes: z.record(
     z.string(),
     z.object({
@@ -1818,7 +1828,8 @@ var diagramDslSchema = z.object({
   title: z.string().optional(),
   direction: directionSchema.optional(),
   layout: z.object({
-    direction: directionSchema.optional()
+    direction: directionSchema.optional(),
+    primaryReadingDirection: primaryReadingDirectionSchema.optional()
   }).optional(),
   routing: z.object({
     kind: routeKindSchema.optional(),
@@ -2348,15 +2359,30 @@ function renderSwimlane(swimlane) {
     lines.push(
       `    <rect class="swimlane-lane" data-lane="${escapeAttribute(`${swimlane.id}.${lane.id}`)}" x="${formatNumber(lane.box.x)}" y="${formatNumber(lane.box.y)}" width="${formatNumber(lane.box.width)}" height="${formatNumber(lane.box.height)}" fill="none" stroke="${STROKE}"/>`
     );
-    if (lane.label?.text !== void 0) {
+    if (lane.headerBox !== void 0) {
+      lines.push(
+        `    <rect class="swimlane-header" data-lane-header="${escapeAttribute(`${swimlane.id}.${lane.id}`)}" x="${formatNumber(lane.headerBox.x)}" y="${formatNumber(lane.headerBox.y)}" width="${formatNumber(lane.headerBox.width)}" height="${formatNumber(lane.headerBox.height)}" fill="#f3f4f6" stroke="${STROKE}"/>`
+      );
+    }
+    if (lane.contentBox !== void 0) {
       lines.push(
-        `    <text class="swimlane-label" x="${formatNumber(lane.box.x + lane.box.width / 2)}" y="${formatNumber(lane.box.y + 16)}" text-anchor="middle" font-family="${FONT_FAMILY}" font-size="12" fill="#111827">${escapeXml(lane.label.text)}</text>`
+        `    <rect class="swimlane-content" data-lane-content="${escapeAttribute(`${swimlane.id}.${lane.id}`)}" x="${formatNumber(lane.contentBox.x)}" y="${formatNumber(lane.contentBox.y)}" width="${formatNumber(lane.contentBox.width)}" height="${formatNumber(lane.contentBox.height)}" fill="none" stroke="none"/>`
       );
     }
+    if (lane.label?.text !== void 0) {
+      const labelBox = lane.headerBox ?? lane.box;
+      lines.push(renderSwimlaneLabel(swimlane, lane.label.text, labelBox));
+    }
   }
   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) {
   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)}"/>`,
@@ -2422,7 +2448,7 @@ function renderRect(box, attributes) {
 function renderLabel(label, box, item) {
   const labelLayout = item.labelLayout;
   if (labelLayout?.lines !== void 0 && labelLayout.lines.length > 0) {
-    const offset = isAbsoluteLabelLayout(labelLayout.box, box) ? { x: 0, y: 0 } : { x: box.x, y: box.y };
+    const offset = { x: box.x, y: box.y };
     return [
       `  <text class="label" data-for="${escapeAttribute(item.id)}" font-family="${FONT_FAMILY}" font-size="${formatNumber(labelLayout.font.fontSize)}" fill="#111827">`,
       ...labelLayout.lines.map(
@@ -2521,9 +2547,6 @@ function pathPointsBeforeArrowhead(points) {
   };
   return [...points.slice(0, -1), base];
 }
-function isAbsoluteLabelLayout(labelBox, itemBox) {
-  return labelBox.x >= itemBox.x && labelBox.y >= itemBox.y && labelBox.x + labelBox.width <= itemBox.x + itemBox.width && labelBox.y + labelBox.height <= itemBox.y + itemBox.height;
-}
 function shapePoints(shape, box) {
   const left = box.x;
   const right = box.x + box.width;
@@ -2937,6 +2960,19 @@ function solveDiagram(diagram, options = {}) {
     constraints
   });
   diagnostics.push(...constrained.diagnostics);
+  const swimlaneContracts = applySwimlaneLayoutContracts(
+    diagram.swimlanes ?? [],
+    constraints,
+    edges,
+    isTopToBottomReadingDirection(diagram.metadata?.primaryReadingDirection),
+    constrained.boxes,
+    constrained.locks,
+    options?.overlapSpacing ?? 40
+  );
+  if (swimlaneContracts.layouts.size > 0) {
+    removeResolvedOverlapDiagnostics(diagnostics, constrained.boxes);
+  }
+  diagnostics.push(...swimlaneContracts.diagnostics);
   const coordinatedNodes = coordinateNodes(
     nodes,
     constrained.boxes,
@@ -2961,7 +2997,8 @@ function solveDiagram(diagram, options = {}) {
   );
   const coordinatedSwimlanes = coordinateSwimlanes(
     diagram.swimlanes ?? [],
-    constrained.boxes
+    constrained.boxes,
+    swimlaneContracts.layouts
   );
   const groupBoxes = new Map(
     coordinatedGroups.map((group) => [group.id, group.box])
@@ -3003,6 +3040,591 @@ function solveDiagram(diagram, options = {}) {
     ...diagram.metadata === void 0 ? {} : { metadata: diagram.metadata }
   };
 }
+function applySwimlaneLayoutContracts(swimlanes, constraints, edges, topToBottomFlow, nodeBoxes, locks, overlapSpacing) {
+  const layouts = /* @__PURE__ */ new Map();
+  const diagnostics = [];
+  const movedChildIds = /* @__PURE__ */ new Set();
+  for (const swimlane of swimlanes) {
+    if ((swimlane.layout ?? "overlay") !== "contract") {
+      continue;
+    }
+    if (swimlane.lanes.length === 0) {
+      continue;
+    }
+    const layout2 = applySingleSwimlaneContract(
+      swimlane,
+      edges,
+      topToBottomFlow,
+      nodeBoxes,
+      locks,
+      diagnostics,
+      movedChildIds
+    );
+    if (layout2 !== void 0) {
+      layouts.set(swimlane.id, layout2);
+    }
+  }
+  if (layouts.size > 0) {
+    diagnostics.push(
+      ...reportSwimlaneOverlaps(nodeBoxes, locks, overlapSpacing),
+      ...reportSwimlaneConstraintInvalidations(
+        constraints,
+        nodeBoxes,
+        movedChildIds
+      )
+    );
+  }
+  return { layouts, diagnostics, movedChildIds };
+}
+function applySingleSwimlaneContract(swimlane, edges, topToBottomFlow, nodeBoxes, locks, diagnostics, movedChildIds) {
+  const headerHeight = swimlane.headerHeight ?? 28;
+  const padding = swimlane.padding ?? 16;
+  const laneBounds = swimlane.lanes.map((lane) => {
+    const childBoxes = lane.children.map((child) => nodeBoxes.get(child)).filter((box) => box !== void 0);
+    return childBoxes.length === 0 ? void 0 : unionBoxes(childBoxes);
+  });
+  const populatedBounds = laneBounds.filter(
+    (box) => box !== void 0
+  );
+  if (populatedBounds.length === 0) {
+    return void 0;
+  }
+  if (swimlane.orientation === "vertical") {
+    return applyVerticalSwimlaneContract(
+      swimlane,
+      edges,
+      topToBottomFlow,
+      nodeBoxes,
+      laneBounds,
+      headerHeight,
+      padding,
+      locks,
+      diagnostics,
+      movedChildIds
+    );
+  }
+  return applyHorizontalSwimlaneContract(
+    swimlane,
+    nodeBoxes,
+    laneBounds,
+    headerHeight,
+    padding,
+    locks,
+    diagnostics,
+    movedChildIds
+  );
+}
+function applyVerticalSwimlaneContract(swimlane, edges, topToBottomFlow, nodeBoxes, laneBounds, headerHeight, padding, locks, diagnostics, movedChildIds) {
+  const populatedBounds = laneBounds.filter(
+    (box) => box !== void 0
+  );
+  const top = Math.min(...populatedBounds.map((box) => box.y));
+  const left = Math.min(...populatedBounds.map((box) => box.x));
+  const maxChildHeight = Math.max(...populatedBounds.map((box) => box.height));
+  const flowRanks = topToBottomFlow ? rankVerticalSwimlaneChildren(swimlane, edges) : /* @__PURE__ */ new Map();
+  const maxRank = flowRanks.size === 0 ? 0 : Math.max(...Array.from(flowRanks.values()));
+  const rankStackGap = Math.max(8, padding / 2);
+  const maxRankStackHeight = maxVerticalRankStackHeight(
+    swimlane,
+    nodeBoxes,
+    flowRanks,
+    rankStackGap
+  );
+  const rankSpacing = Math.max(96, maxRankStackHeight + padding);
+  const contentHeight = maxRank === 0 ? maxChildHeight : maxRankStackHeight + maxRank * rankSpacing;
+  const slotWidth = Math.max(...populatedBounds.map((box) => box.width)) + padding * 2;
+  const laneContentTop = top + headerHeight + padding;
+  for (let index = 0; index < swimlane.lanes.length; index += 1) {
+    const lane = swimlane.lanes[index];
+    const bounds = laneBounds[index];
+    if (lane === void 0 || bounds === void 0) {
+      continue;
+    }
+    const target = {
+      x: left + slotWidth * index + padding,
+      y: laneContentTop
+    };
+    if (maxRank === 0) {
+      moveLaneChildren(
+        lane.children,
+        nodeBoxes,
+        locks,
+        diagnostics,
+        movedChildIds,
+        {
+          x: target.x - bounds.x,
+          y: target.y - bounds.y
+        }
+      );
+      continue;
+    }
+    moveRankedVerticalLaneChildren(
+      lane.children,
+      nodeBoxes,
+      locks,
+      diagnostics,
+      movedChildIds,
+      flowRanks,
+      rankSpacing,
+      rankStackGap,
+      {
+        x: target.x - bounds.x,
+        y: laneContentTop
+      }
+    );
+  }
+  return {
+    box: {
+      x: left,
+      y: top,
+      width: slotWidth * swimlane.lanes.length,
+      height: contentHeight + padding * 2 + headerHeight
+    },
+    slotWidth,
+    slotHeight: contentHeight + padding * 2 + headerHeight
+  };
+}
+function isTopToBottomReadingDirection(value) {
+  return value === "top_to_bottom" || value === "top-to-bottom";
+}
+function rankVerticalSwimlaneChildren(swimlane, edges) {
+  const childOrder = /* @__PURE__ */ new Map();
+  for (const lane of swimlane.lanes) {
+    for (const childId of lane.children) {
+      if (!childOrder.has(childId)) {
+        childOrder.set(childId, childOrder.size);
+      }
+    }
+  }
+  if (childOrder.size === 0) {
+    return /* @__PURE__ */ new Map();
+  }
+  const childIds = new Set(childOrder.keys());
+  const relevantEdges = edges.filter(
+    (edge) => childIds.has(edge.source.nodeId) && childIds.has(edge.target.nodeId) && edge.source.nodeId !== edge.target.nodeId
+  );
+  if (relevantEdges.length === 0) {
+    return /* @__PURE__ */ new Map();
+  }
+  const ranks = new Map([...childIds].map((id) => [id, 0]));
+  const outgoing = /* @__PURE__ */ new Map();
+  const inDegree = new Map([...childIds].map((id) => [id, 0]));
+  for (const edge of relevantEdges) {
+    const targets = outgoing.get(edge.source.nodeId) ?? [];
+    targets.push(edge.target.nodeId);
+    outgoing.set(edge.source.nodeId, targets);
+    inDegree.set(
+      edge.target.nodeId,
+      (inDegree.get(edge.target.nodeId) ?? 0) + 1
+    );
+  }
+  const queue = [...childIds].filter((id) => (inDegree.get(id) ?? 0) === 0).sort((a, b) => (childOrder.get(a) ?? 0) - (childOrder.get(b) ?? 0));
+  let visited = 0;
+  for (let cursor = 0; cursor < queue.length; cursor += 1) {
+    const sourceId = queue[cursor];
+    if (sourceId === void 0) {
+      continue;
+    }
+    visited += 1;
+    for (const targetId of outgoing.get(sourceId) ?? []) {
+      ranks.set(
+        targetId,
+        Math.max(ranks.get(targetId) ?? 0, (ranks.get(sourceId) ?? 0) + 1)
+      );
+      const nextInDegree = (inDegree.get(targetId) ?? 0) - 1;
+      inDegree.set(targetId, nextInDegree);
+      if (nextInDegree === 0) {
+        queue.push(targetId);
+      }
+    }
+  }
+  return visited === childIds.size ? ranks : rankCyclicSwimlaneChildren(childIds, relevantEdges);
+}
+function rankCyclicSwimlaneChildren(childIds, edges) {
+  const maxRank = Math.max(0, childIds.size - 1);
+  const ranks = new Map([...childIds].map((id) => [id, 0]));
+  for (let iteration = 0; iteration < childIds.size; iteration += 1) {
+    let changed = false;
+    for (const edge of edges) {
+      const nextRank = Math.min(
+        maxRank,
+        (ranks.get(edge.source.nodeId) ?? 0) + 1
+      );
+      if (nextRank > (ranks.get(edge.target.nodeId) ?? 0)) {
+        ranks.set(edge.target.nodeId, nextRank);
+        changed = true;
+      }
+    }
+    if (!changed) {
+      break;
+    }
+  }
+  return ranks;
+}
+function maxVerticalRankStackHeight(swimlane, nodeBoxes, flowRanks, gap) {
+  let maxHeight = 0;
+  for (const lane of swimlane.lanes) {
+    for (const stack of rankStacks(
+      lane.children,
+      nodeBoxes,
+      flowRanks
+    ).values()) {
+      const height = stack.reduce(
+        (total, item, index) => total + item.box.height + (index === 0 ? 0 : gap),
+        0
+      );
+      maxHeight = Math.max(maxHeight, height);
+    }
+  }
+  return maxHeight;
+}
+function moveRankedVerticalLaneChildren(childIds, nodeBoxes, locks, diagnostics, movedChildIds, flowRanks, rankSpacing, rankStackGap, target) {
+  for (const [rank, stack] of rankStacks(childIds, nodeBoxes, flowRanks)) {
+    let yOffset = 0;
+    for (const item of stack) {
+      const { childId, box } = item;
+      if (locks.has(childId)) {
+        diagnostics.push({
+          severity: "warning",
+          code: "constraints.locked-target-not-moved",
+          message: `Locked child ${childId} was not moved into contract swimlane slot.`,
+          path: ["swimlanes"],
+          detail: { nodeId: childId }
+        });
+        continue;
+      }
+      const next = {
+        ...box,
+        x: box.x + target.x,
+        y: target.y + rank * rankSpacing + yOffset
+      };
+      if (next.x !== box.x || next.y !== box.y) {
+        movedChildIds.add(childId);
+      }
+      nodeBoxes.set(childId, next);
+      yOffset += box.height + rankStackGap;
+    }
+  }
+}
+function rankStacks(childIds, nodeBoxes, flowRanks) {
+  const stacks = /* @__PURE__ */ new Map();
+  for (const childId of childIds) {
+    const box = nodeBoxes.get(childId);
+    if (box === void 0) {
+      continue;
+    }
+    const rank = flowRanks.get(childId) ?? 0;
+    const stack = stacks.get(rank) ?? [];
+    stack.push({ childId, box });
+    stacks.set(rank, stack);
+  }
+  for (const stack of stacks.values()) {
+    stack.sort((a, b) => {
+      const deltaY = a.box.y - b.box.y;
+      return deltaY === 0 ? a.childId.localeCompare(b.childId) : deltaY;
+    });
+  }
+  return stacks;
+}
+function applyHorizontalSwimlaneContract(swimlane, nodeBoxes, laneBounds, headerHeight, padding, locks, diagnostics, movedChildIds) {
+  const populatedBounds = laneBounds.filter(
+    (box) => box !== void 0
+  );
+  const top = Math.min(...populatedBounds.map((box) => box.y));
+  const left = Math.min(...populatedBounds.map((box) => box.x));
+  const slotWidth = Math.max(...populatedBounds.map((box) => box.width)) + headerHeight + padding * 2;
+  const slotHeight = Math.max(...populatedBounds.map((box) => box.height)) + padding * 2;
+  for (let index = 0; index < swimlane.lanes.length; index += 1) {
+    const lane = swimlane.lanes[index];
+    const bounds = laneBounds[index];
+    if (lane === void 0 || bounds === void 0) {
+      continue;
+    }
+    const target = {
+      x: left + headerHeight + padding,
+      y: top + slotHeight * index + padding
+    };
+    moveLaneChildren(
+      lane.children,
+      nodeBoxes,
+      locks,
+      diagnostics,
+      movedChildIds,
+      {
+        x: target.x - bounds.x,
+        y: target.y - bounds.y
+      }
+    );
+  }
+  return {
+    box: {
+      x: left,
+      y: top,
+      width: slotWidth,
+      height: slotHeight * swimlane.lanes.length
+    },
+    slotWidth,
+    slotHeight
+  };
+}
+function moveLaneChildren(childIds, nodeBoxes, locks, diagnostics, movedChildIds, offset) {
+  for (const childId of childIds) {
+    const box = nodeBoxes.get(childId);
+    if (box === void 0) {
+      continue;
+    }
+    if (locks.has(childId)) {
+      diagnostics.push({
+        severity: "warning",
+        code: "constraints.locked-target-not-moved",
+        message: `Locked child ${childId} was not moved into contract swimlane slot.`,
+        path: ["swimlanes"],
+        detail: { nodeId: childId }
+      });
+      continue;
+    }
+    if (offset.x !== 0 || offset.y !== 0) {
+      movedChildIds.add(childId);
+    }
+    nodeBoxes.set(childId, {
+      ...box,
+      x: box.x + offset.x,
+      y: box.y + offset.y
+    });
+  }
+}
+function removeResolvedOverlapDiagnostics(diagnostics, nodeBoxes) {
+  for (let index = diagnostics.length - 1; index >= 0; index -= 1) {
+    const diagnostic = diagnostics[index];
+    if (diagnostic?.code !== "constraints.overlap.unresolved") {
+      continue;
+    }
+    const firstId = detailString(diagnostic, "firstId");
+    const secondId = detailString(diagnostic, "secondId");
+    const first = firstId === void 0 ? void 0 : nodeBoxes.get(firstId);
+    const second = secondId === void 0 ? void 0 : nodeBoxes.get(secondId);
+    if (first !== void 0 && second !== void 0 && !intersectsAabb(first, second)) {
+      diagnostics.splice(index, 1);
+    }
+  }
+}
+function reportSwimlaneConstraintInvalidations(constraints, nodeBoxes, movedChildIds) {
+  const diagnostics = [];
+  for (const constraint of constraints) {
+    const invalidatedNodeIds = movedConstraintNodeIds(
+      constraint,
+      nodeBoxes,
+      movedChildIds
+    );
+    if (invalidatedNodeIds.length === 0) {
+      continue;
+    }
+    diagnostics.push({
+      severity: "warning",
+      code: "constraints.swimlane-contract.invalidated",
+      message: `Contract swimlane placement moved node(s) after ${constraint.kind} constraint solving; final geometry no longer satisfies that constraint.`,
+      path: ["swimlanes"],
+      detail: {
+        constraintKind: constraint.kind,
+        ...constraint.id === void 0 ? {} : { constraintId: constraint.id },
+        nodeIds: invalidatedNodeIds
+      }
+    });
+  }
+  return diagnostics;
+}
+function movedConstraintNodeIds(constraint, nodeBoxes, movedChildIds) {
+  switch (constraint.kind) {
+    case "exact-position":
+      return [];
+    case "containment":
+      return movedContainmentViolations(constraint, nodeBoxes, movedChildIds);
+    case "relative-position":
+      return movedRelativeViolations(constraint, nodeBoxes, movedChildIds);
+    case "align":
+      return movedAlignViolations(constraint, nodeBoxes, movedChildIds);
+    case "distribute":
+      return movedDistributeViolations(constraint, nodeBoxes, movedChildIds);
+  }
+}
+function movedContainmentViolations(constraint, nodeBoxes, movedChildIds) {
+  const container = nodeBoxes.get(constraint.containerId);
+  if (container === void 0) {
+    return [];
+  }
+  const content = paddedContentBox(container, constraint.padding);
+  return constraint.childIds.filter((childId) => {
+    if (!movedChildIds.has(childId)) {
+      return false;
+    }
+    const child = nodeBoxes.get(childId);
+    return child !== void 0 && !boxInside(child, content);
+  });
+}
+function movedRelativeViolations(constraint, nodeBoxes, movedChildIds) {
+  if (!movedChildIds.has(constraint.sourceId) && !movedChildIds.has(constraint.referenceId)) {
+    return [];
+  }
+  const source = nodeBoxes.get(constraint.sourceId);
+  const reference = nodeBoxes.get(constraint.referenceId);
+  if (source === void 0 || reference === void 0) {
+    return [];
+  }
+  return sameBoxPosition(
+    source,
+    expectedRelativeBox(source, reference, constraint)
+  ) ? [] : [constraint.sourceId];
+}
+function movedAlignViolations(constraint, nodeBoxes, movedChildIds) {
+  if (!constraint.targetIds.some((id) => movedChildIds.has(id))) {
+    return [];
+  }
+  const targets = constraint.targetIds.map((id) => ({ id, box: nodeBoxes.get(id) })).filter(
+    (target) => target.box !== void 0
+  );
+  const anchor = targets[0];
+  if (anchor === void 0) {
+    return [];
+  }
+  const expected = alignmentValue2(anchor.box, constraint.axis);
+  return targets.filter(
+    (target) => movedChildIds.has(target.id) && !sameNumber(alignmentValue2(target.box, constraint.axis), expected)
+  ).map((target) => target.id);
+}
+function movedDistributeViolations(constraint, nodeBoxes, movedChildIds) {
+  if (!constraint.targetIds.some((id) => movedChildIds.has(id))) {
+    return [];
+  }
+  const targets = constraint.targetIds.map((id) => ({ id, box: nodeBoxes.get(id) })).filter(
+    (target) => target.box !== void 0
+  ).sort((a, b) => {
+    const delta = constraint.axis === "horizontal" ? a.box.x - b.box.x : a.box.y - b.box.y;
+    return delta === 0 ? a.id.localeCompare(b.id) : delta;
+  });
+  if (targets.length < 3) {
+    return [];
+  }
+  const first = targets[0];
+  const last = targets.at(-1);
+  if (first === void 0 || last === void 0) {
+    return [];
+  }
+  const expectedSpacing = constraint.spacing ?? (distributionStart2(last.box, constraint.axis) - distributionStart2(first.box, constraint.axis)) / (targets.length - 1);
+  return targets.slice(1).filter((target, index) => {
+    const previous = targets[index];
+    if (previous === void 0 || !movedChildIds.has(target.id)) {
+      return false;
+    }
+    return !sameNumber(
+      distributionStart2(target.box, constraint.axis) - distributionStart2(previous.box, constraint.axis),
+      expectedSpacing
+    );
+  }).map((target) => target.id);
+}
+function expectedRelativeBox(source, reference, constraint) {
+  const offset = constraint.offset ?? { x: 0, y: 0 };
+  switch (constraint.relation) {
+    case "above":
+      return {
+        ...source,
+        x: reference.x + offset.x,
+        y: reference.y - source.height + offset.y
+      };
+    case "right-of":
+      return {
+        ...source,
+        x: reference.x + reference.width + offset.x,
+        y: reference.y + offset.y
+      };
+    case "below":
+      return {
+        ...source,
+        x: reference.x + offset.x,
+        y: reference.y + reference.height + offset.y
+      };
+    case "left-of":
+      return {
+        ...source,
+        x: reference.x - source.width + offset.x,
+        y: reference.y + offset.y
+      };
+  }
+}
+function paddedContentBox(container, padding) {
+  const margin = padding ?? { top: 0, right: 0, bottom: 0, left: 0 };
+  return {
+    x: container.x + margin.left,
+    y: container.y + margin.top,
+    width: container.width - margin.left - margin.right,
+    height: container.height - margin.top - margin.bottom
+  };
+}
+function boxInside(child, container) {
+  return child.x >= container.x && child.y >= container.y && child.x + child.width <= container.x + container.width && child.y + child.height <= container.y + container.height;
+}
+function sameBoxPosition(first, second) {
+  return sameNumber(first.x, second.x) && sameNumber(first.y, second.y);
+}
+function sameNumber(first, second) {
+  return Math.abs(first - second) < 1e-3;
+}
+function alignmentValue2(box, axis) {
+  switch (axis) {
+    case "x":
+    case "left":
+      return box.x;
+    case "y":
+    case "top":
+      return box.y;
+    case "center-x":
+      return box.x + box.width / 2;
+    case "center-y":
+      return box.y + box.height / 2;
+    case "right":
+      return box.x + box.width;
+    case "bottom":
+      return box.y + box.height;
+  }
+}
+function distributionStart2(box, axis) {
+  return axis === "horizontal" ? box.x : box.y;
+}
+function detailString(diagnostic, key) {
+  const value = diagnostic.detail?.[key];
+  return typeof value === "string" ? value : void 0;
+}
+function reportSwimlaneOverlaps(nodeBoxes, locks, overlapSpacing) {
+  const diagnostics = [];
+  const ids = [...nodeBoxes.keys()].sort();
+  for (const firstId of ids) {
+    for (const secondId of ids) {
+      if (firstId >= secondId) {
+        continue;
+      }
+      const first = nodeBoxes.get(firstId);
+      const second = nodeBoxes.get(secondId);
+      if (first === void 0 || second === void 0) {
+        continue;
+      }
+      if (!intersectsAabb(first, second)) {
+        continue;
+      }
+      diagnostics.push({
+        severity: "warning",
+        code: "constraints.overlap.unresolved",
+        message: `Boxes ${firstId} and ${secondId} still overlap after contract swimlane placement with configured spacing ${overlapSpacing}.`,
+        path: ["swimlanes"],
+        detail: {
+          firstId,
+          secondId,
+          firstLocked: locks.has(firstId),
+          secondLocked: locks.has(secondId)
+        }
+      });
+    }
+  }
+  return diagnostics;
+}
 function coordinateNodes(nodes, boxes, options, diagnostics) {
   const coordinated = [];
   for (const node of nodes) {
@@ -3117,16 +3739,70 @@ function portLabelBox(port) {
     height
   };
 }
-function coordinateSwimlanes(swimlanes, nodeBoxes) {
-  const titleSize = 28;
-  const padding = 16;
+function coordinateSwimlanes(swimlanes, nodeBoxes, layouts) {
   return swimlanes.map((swimlane) => {
-    const laneBoxes = swimlane.lanes.flatMap((lane) => {
+    const layout2 = swimlane.layout ?? "overlay";
+    const headerHeight = swimlane.headerHeight ?? 28;
+    const padding = swimlane.padding ?? 16;
+    const contractLayout = layouts.get(swimlane.id);
+    if (layout2 === "contract" && contractLayout !== void 0) {
+      const lanes2 = swimlane.lanes.map((lane, index) => {
+        const box = swimlane.orientation === "vertical" ? {
+          x: contractLayout.box.x + contractLayout.slotWidth * index,
+          y: contractLayout.box.y,
+          width: contractLayout.slotWidth,
+          height: contractLayout.box.height
+        } : {
+          x: contractLayout.box.x,
+          y: contractLayout.box.y + contractLayout.slotHeight * index,
+          width: contractLayout.box.width,
+          height: contractLayout.slotHeight
+        };
+        const headerBox = swimlane.orientation === "vertical" ? {
+          x: box.x,
+          y: box.y,
+          width: box.width,
+          height: headerHeight
+        } : {
+          x: box.x,
+          y: box.y,
+          width: headerHeight,
+          height: box.height
+        };
+        const contentBox2 = swimlane.orientation === "vertical" ? {
+          x: box.x,
+          y: box.y + headerHeight,
+          width: box.width,
+          height: Math.max(0, box.height - headerHeight)
+        } : {
+          x: box.x + headerHeight,
+          y: box.y,
+          width: Math.max(0, box.width - headerHeight),
+          height: box.height
+        };
+        return {
+          ...lane,
+          box,
+          headerBox,
+          contentBox: contentBox2
+        };
+      });
+      return {
+        ...swimlane,
+        lanes: lanes2,
+        box: contractLayout.box,
+        ...headerHeight === void 0 ? {} : { headerHeight },
+        ...padding === void 0 ? {} : { padding }
+      };
+    }
+    const laneContentBoxes = swimlane.lanes.map((lane) => {
       const childBoxes = lane.children.map((child) => nodeBoxes.get(child)).filter((box) => box !== void 0);
-      return childBoxes.length === 0 ? [] : [unionBoxes(childBoxes)];
+      return childBoxes.length === 0 ? void 0 : unionBoxes(childBoxes);
     });
-    const laneUnion = laneBoxes.length === 0 ? { x: 0, y: 0, width: 120, height: 80 } : unionBoxes(laneBoxes);
-    const outer = expand(laneUnion, padding, titleSize);
+    const laneUnion = laneContentBoxes.filter((box) => box !== void 0).length === 0 ? { x: 0, y: 0, width: 120, height: 80 } : unionBoxes(
+      laneContentBoxes.filter((box) => box !== void 0)
+    );
+    const outer = expand(laneUnion, padding, headerHeight);
     const laneCount = Math.max(1, swimlane.lanes.length);
     const lanes = swimlane.lanes.map((lane, index) => {
       const box = swimlane.orientation === "vertical" ? {
@@ -3140,9 +3816,42 @@ function coordinateSwimlanes(swimlanes, nodeBoxes) {
         width: outer.width,
         height: outer.height / laneCount
       };
-      return { ...lane, box };
+      const headerBox = layout2 === "contract" ? swimlane.orientation === "vertical" ? {
+        x: box.x,
+        y: box.y,
+        width: box.width,
+        height: headerHeight
+      } : {
+        x: box.x,
+        y: box.y,
+        width: headerHeight,
+        height: box.height
+      } : void 0;
+      const contentBox2 = layout2 === "contract" ? swimlane.orientation === "vertical" ? {
+        x: box.x,
+        y: box.y + headerHeight,
+        width: box.width,
+        height: Math.max(0, box.height - headerHeight)
+      } : {
+        x: box.x + headerHeight,
+        y: box.y,
+        width: Math.max(0, box.width - headerHeight),
+        height: box.height
+      } : void 0;
+      return {
+        ...lane,
+        box,
+        ...headerBox === void 0 ? {} : { headerBox },
+        ...contentBox2 === void 0 ? {} : { contentBox: contentBox2 }
+      };
     });
-    return { ...swimlane, lanes, box: outer };
+    return {
+      ...swimlane,
+      lanes,
+      box: outer,
+      ...headerHeight === void 0 ? {} : { headerHeight },
+      ...padding === void 0 ? {} : { padding }
+    };
   });
 }
 function coordinateFrame(frame, contentBounds) {