@crazyhappyone/auto-graph 0.0.1

package/dist/index.cjs

@@ -0,0 +1,2804 @@
+'use strict';
+
+var pretext = require('@chenglou/pretext');
+var buffer = require('buffer');
+var yaml = require('yaml');
+var zod = require('zod');
+var dagre = require('@dagrejs/dagre');
+
+// src/geometry/boxes.ts
+function normalizeInsets(input = 0) {
+  if (typeof input === "number") {
+    validateMargin(input, "margin");
+    return {
+      top: input,
+      right: input,
+      bottom: input,
+      left: input
+    };
+  }
+  validateMargin(input.top, "insets.top");
+  validateMargin(input.right, "insets.right");
+  validateMargin(input.bottom, "insets.bottom");
+  validateMargin(input.left, "insets.left");
+  return {
+    top: input.top,
+    right: input.right,
+    bottom: input.bottom,
+    left: input.left
+  };
+}
+function validateBox(box, label = "box") {
+  validateFinite(box.x, `${label}.x`);
+  validateFinite(box.y, `${label}.y`);
+  validateFinite(box.width, `${label}.width`);
+  validateFinite(box.height, `${label}.height`);
+  if (box.width < 0 || box.height < 0) {
+    throw new TypeError(`${label} dimensions must be non-negative`);
+  }
+}
+function boxCenter(box) {
+  validateBox(box);
+  return {
+    x: box.x + box.width / 2,
+    y: box.y + box.height / 2
+  };
+}
+function expandBox(box, margin) {
+  validateBox(box);
+  const insets = normalizeInsets(margin);
+  return {
+    x: box.x - insets.left,
+    y: box.y - insets.top,
+    width: box.width + insets.left + insets.right,
+    height: box.height + insets.top + insets.bottom
+  };
+}
+function unionBoxes(boxes) {
+  if (boxes.length === 0) {
+    throw new TypeError("Cannot union empty box collection");
+  }
+  for (const [index, box] of boxes.entries()) {
+    validateBox(box, `boxes[${index}]`);
+  }
+  const minX = Math.min(...boxes.map((box) => box.x));
+  const minY = Math.min(...boxes.map((box) => box.y));
+  const maxX = Math.max(...boxes.map((box) => box.x + box.width));
+  const maxY = Math.max(...boxes.map((box) => box.y + box.height));
+  return {
+    x: minX,
+    y: minY,
+    width: maxX - minX,
+    height: maxY - minY
+  };
+}
+function intersectsAabb(a, b) {
+  validateBox(a, "a");
+  validateBox(b, "b");
+  return a.x <= b.x + b.width && a.x + a.width >= b.x && a.y <= b.y + b.height && a.y + a.height >= b.y;
+}
+function validateMargin(value, label) {
+  validateFinite(value, label);
+  if (value < 0) {
+    throw new TypeError(`${label} must be non-negative`);
+  }
+}
+function validateFinite(value, label) {
+  if (!Number.isFinite(value)) {
+    throw new TypeError(`${label} must be finite`);
+  }
+}
+
+// src/constraints/solver.ts
+function applyLayoutConstraints(input) {
+  const diagnostics = [];
+  const boxes = cloneValidBoxes(input.boxes, diagnostics);
+  const locks = /* @__PURE__ */ new Map();
+  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);
+  applyRelative(input.constraints, boxes, locks, diagnostics);
+  applyAlign(input.constraints, boxes, locks, diagnostics);
+  applyDistribute(input.constraints, boxes, locks, diagnostics);
+  repairOverlaps(input, boxes, locks, diagnostics);
+  return { boxes, locks, diagnostics };
+}
+function cloneValidBoxes(input, diagnostics) {
+  const boxes = /* @__PURE__ */ new Map();
+  for (const [id, box] of input) {
+    if (isFiniteBox(box)) {
+      boxes.set(id, { ...box });
+    } else {
+      diagnostics.push({
+        severity: "error",
+        code: "constraints.position.invalid",
+        message: `Box ${id} contains invalid coordinates.`,
+        path: ["boxes", id],
+        detail: { nodeId: id }
+      });
+    }
+  }
+  return boxes;
+}
+function applyFixedPositionLocks(nodes, boxes, locks, diagnostics) {
+  for (const node of nodes) {
+    if (node.position === void 0) {
+      continue;
+    }
+    const box = boxes.get(node.id);
+    if (box === void 0) {
+      missingReference(diagnostics, "node", node.id);
+      continue;
+    }
+    if (!isFinitePoint(node.position)) {
+      diagnostics.push({
+        severity: "error",
+        code: "constraints.position.invalid",
+        message: `Fixed position for ${node.id} is invalid.`,
+        path: ["nodes", node.id, "position"],
+        detail: { nodeId: node.id }
+      });
+      continue;
+    }
+    boxes.set(node.id, { ...box, x: node.position.x, y: node.position.y });
+    locks.set(node.id, { nodeId: node.id, source: "fixed-position" });
+  }
+}
+function applyExactPositions(constraints, boxes, locks, diagnostics, nodeById) {
+  for (const constraint of constraints) {
+    if (constraint.kind !== "exact-position") {
+      continue;
+    }
+    const targetId = constraintTargetId(constraint);
+    if (targetId === void 0 || !nodeById.has(targetId)) {
+      missingReference(diagnostics, "target", targetId);
+      continue;
+    }
+    const box = boxes.get(targetId);
+    if (box === void 0) {
+      missingReference(diagnostics, "box", targetId);
+      continue;
+    }
+    if (!isFinitePoint(constraint.position)) {
+      diagnostics.push({
+        severity: "error",
+        code: "constraints.position.invalid",
+        message: `Exact position for ${targetId} is invalid.`,
+        path: ["constraints", constraint.id ?? targetId, "position"],
+        detail: { nodeId: targetId }
+      });
+      continue;
+    }
+    const existingLock = locks.get(targetId);
+    if (existingLock !== void 0 && (box.x !== constraint.position.x || box.y !== constraint.position.y)) {
+      diagnostics.push({
+        severity: "error",
+        code: "constraints.conflict.exact-position",
+        message: `Exact position conflicts with existing lock for ${targetId}.`,
+        path: ["constraints", constraint.id ?? targetId],
+        detail: { nodeId: targetId, source: existingLock.source }
+      });
+      continue;
+    }
+    boxes.set(targetId, {
+      ...box,
+      x: constraint.position.x,
+      y: constraint.position.y
+    });
+    locks.set(targetId, { nodeId: targetId, source: "exact-position" });
+  }
+}
+function applyContainment(constraints, boxes, locks, diagnostics) {
+  for (const constraint of constraints) {
+    if (constraint.kind !== "containment") {
+      continue;
+    }
+    const container = boxes.get(constraint.containerId);
+    if (container === void 0) {
+      missingReference(diagnostics, "container", constraint.containerId);
+      continue;
+    }
+    const content = contentBox(container, constraint.padding);
+    for (const childId of constraint.childIds) {
+      const child = boxes.get(childId);
+      if (child === void 0) {
+        missingReference(diagnostics, "child", childId);
+        continue;
+      }
+      const next = moveInside(child, content);
+      if (samePosition(child, next)) {
+        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)) {
+          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;
+      }
+      if (next.width > content.width || next.height > content.height) {
+        diagnostics.push({
+          severity: "error",
+          code: "constraints.containment.impossible",
+          message: `Child ${childId} cannot fit inside ${constraint.containerId}.`,
+          path: ["constraints", constraint.id ?? constraint.containerId],
+          detail: { nodeId: childId, containerId: constraint.containerId }
+        });
+        continue;
+      }
+      boxes.set(childId, next);
+    }
+  }
+}
+function applyRelative(constraints, boxes, locks, diagnostics) {
+  for (const constraint of constraints) {
+    if (constraint.kind !== "relative-position") {
+      continue;
+    }
+    const source = boxes.get(constraint.sourceId);
+    const reference = boxes.get(constraint.referenceId);
+    if (source === void 0) {
+      missingReference(diagnostics, "source", constraint.sourceId);
+      continue;
+    }
+    if (reference === void 0) {
+      missingReference(diagnostics, "reference", constraint.referenceId);
+      continue;
+    }
+    const next = relativeBox(source, reference, constraint);
+    setUnlockedBox(
+      constraint.sourceId,
+      next,
+      boxes,
+      locks,
+      diagnostics,
+      constraint
+    );
+  }
+}
+function applyAlign(constraints, boxes, locks, diagnostics) {
+  for (const constraint of constraints) {
+    if (constraint.kind !== "align") {
+      continue;
+    }
+    const targets = collectTargets(constraint.targetIds, boxes, diagnostics);
+    const anchor = targets[0];
+    if (anchor === void 0) {
+      continue;
+    }
+    const value = alignmentValue(anchor.box, constraint.axis);
+    for (const { id, box } of targets.slice(1)) {
+      const next = alignBox(box, constraint.axis, value);
+      setUnlockedBox(id, next, boxes, locks, diagnostics, constraint);
+    }
+  }
+}
+function applyDistribute(constraints, boxes, locks, diagnostics) {
+  for (const constraint of constraints) {
+    if (constraint.kind !== "distribute") {
+      continue;
+    }
+    const targets = collectTargets(
+      constraint.targetIds,
+      boxes,
+      diagnostics
+    ).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) {
+      continue;
+    }
+    const first = targets[0];
+    const last = targets[targets.length - 1];
+    if (first === void 0 || last === void 0) {
+      continue;
+    }
+    const spacing = constraint.spacing ?? (distributionStart(last.box, constraint.axis) - distributionStart(first.box, constraint.axis)) / (targets.length - 1);
+    for (const [index, target] of targets.slice(1, -1).entries()) {
+      const nextStart = distributionStart(first.box, constraint.axis) + spacing * (index + 1);
+      const next = constraint.axis === "horizontal" ? { ...target.box, x: nextStart } : { ...target.box, y: nextStart };
+      setUnlockedBox(target.id, next, boxes, locks, diagnostics, constraint);
+    }
+  }
+}
+function repairOverlaps(input, boxes, locks, diagnostics) {
+  const spacing = input.overlapSpacing ?? 40;
+  const axis = input.direction === "LR" || input.direction === "RL" ? "x" : "y";
+  const ids = [...boxes.keys()].sort();
+  for (const firstId of ids) {
+    for (const secondId of ids) {
+      if (firstId >= secondId) {
+        continue;
+      }
+      const first = boxes.get(firstId);
+      const second = boxes.get(secondId);
+      if (first === void 0 || second === void 0 || !intersectsAabb(first, second)) {
+        continue;
+      }
+      const firstLocked = locks.has(firstId);
+      const secondLocked = locks.has(secondId);
+      if (firstLocked === secondLocked) {
+        continue;
+      }
+      const movingId = firstLocked ? secondId : firstId;
+      const moving = firstLocked ? second : first;
+      const fixed = firstLocked ? first : second;
+      const moved = movePastOverlap(moving, fixed, axis, spacing);
+      boxes.set(movingId, moved);
+    }
+  }
+  for (const firstId of ids) {
+    for (const secondId of ids) {
+      if (firstId >= secondId) {
+        continue;
+      }
+      const first = boxes.get(firstId);
+      const second = boxes.get(secondId);
+      if (first !== void 0 && second !== void 0 && intersectsAabb(first, second)) {
+        diagnostics.push({
+          severity: "warning",
+          code: "constraints.overlap.unresolved",
+          message: `Boxes ${firstId} and ${secondId} still overlap after stable sorted primary axis repair with configured spacing.`,
+          path: ["boxes"],
+          detail: { firstId, secondId }
+        });
+      }
+    }
+  }
+}
+function setUnlockedBox(id, next, boxes, locks, diagnostics, constraint) {
+  const current = boxes.get(id);
+  if (current === void 0) {
+    missingReference(diagnostics, "target", id);
+    return;
+  }
+  if (!isFiniteBox(next)) {
+    diagnostics.push({
+      severity: "error",
+      code: "constraints.position.invalid",
+      message: `Constraint produced an invalid position for ${id}.`,
+      path: ["constraints", constraint.id ?? id],
+      detail: { nodeId: id }
+    });
+    return;
+  }
+  if (locks.has(id) && !samePosition(current, next)) {
+    diagnostics.push({
+      severity: "warning",
+      code: "constraints.locked-target-not-moved",
+      message: `Locked target ${id} was not moved by ${constraint.kind}.`,
+      path: ["constraints", constraint.id ?? id],
+      detail: { nodeId: id, constraintKind: constraint.kind }
+    });
+    return;
+  }
+  boxes.set(id, next);
+}
+function constraintTargetId(constraint) {
+  return constraint.targetId ?? constraint.target?.id;
+}
+function collectTargets(ids, boxes, diagnostics) {
+  const targets = [];
+  for (const id of ids) {
+    const box = boxes.get(id);
+    if (box === void 0) {
+      missingReference(diagnostics, "target", id);
+    } else {
+      targets.push({ id, box });
+    }
+  }
+  return targets;
+}
+function relativeBox(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 alignmentValue(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 alignBox(box, axis, value) {
+  switch (axis) {
+    case "x":
+    case "left":
+      return { ...box, x: value };
+    case "y":
+    case "top":
+      return { ...box, y: value };
+    case "center-x":
+      return { ...box, x: value - box.width / 2 };
+    case "center-y":
+      return { ...box, y: value - box.height / 2 };
+    case "right":
+      return { ...box, x: value - box.width };
+    case "bottom":
+      return { ...box, y: value - box.height };
+  }
+}
+function distributionStart(box, axis) {
+  return axis === "horizontal" ? box.x : box.y;
+}
+function contentBox(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 moveInside(child, container) {
+  return {
+    ...child,
+    x: Math.min(
+      Math.max(child.x, container.x),
+      container.x + container.width - child.width
+    ),
+    y: Math.min(
+      Math.max(child.y, container.y),
+      container.y + container.height - child.height
+    )
+  };
+}
+function isInside(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 movePastOverlap(moving, fixed, primaryAxis, spacing) {
+  if (primaryAxis === "x") {
+    const movingCenter2 = moving.x + moving.width / 2;
+    const fixedCenter2 = fixed.x + fixed.width / 2;
+    const x = movingCenter2 >= fixedCenter2 ? fixed.x + fixed.width + spacing : fixed.x - moving.width - spacing;
+    return { ...moving, x };
+  }
+  const movingCenter = moving.y + moving.height / 2;
+  const fixedCenter = fixed.y + fixed.height / 2;
+  const y = movingCenter >= fixedCenter ? fixed.y + fixed.height + spacing : fixed.y - moving.height - spacing;
+  return { ...moving, y };
+}
+function samePosition(a, b) {
+  return a.x === b.x && a.y === b.y;
+}
+function isFiniteBox(box) {
+  try {
+    validateBox(box);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function isFinitePoint(point2) {
+  return Number.isFinite(point2.x) && Number.isFinite(point2.y);
+}
+function missingReference(diagnostics, referenceKind, id) {
+  diagnostics.push({
+    severity: "error",
+    code: "constraints.reference.missing",
+    message: `Missing ${referenceKind} reference${id === void 0 ? "" : `: ${id}`}.`,
+    path: ["constraints", referenceKind],
+    detail: id === void 0 ? {} : { id }
+  });
+}
+
+// src/dsl/diagnostics.ts
+var SEVERITY_RANK = /* @__PURE__ */ new Map([
+  ["error", 0],
+  ["warning", 1],
+  ["info", 2]
+]);
+var LAYER_RANK = /* @__PURE__ */ new Map([
+  ["parse", 0],
+  ["validate", 1],
+  ["solve", 2],
+  ["export", 3],
+  ["io", 4]
+]);
+function sortDslDiagnostics(diagnostics) {
+  return [...diagnostics].sort((a, b) => {
+    const severityDelta = (SEVERITY_RANK.get(a.severity) ?? 99) - (SEVERITY_RANK.get(b.severity) ?? 99);
+    if (severityDelta !== 0) {
+      return severityDelta;
+    }
+    const layerDelta = (LAYER_RANK.get(a.layer) ?? 99) - (LAYER_RANK.get(b.layer) ?? 99);
+    if (layerDelta !== 0) {
+      return layerDelta;
+    }
+    const pathDelta = pathKey(a.path).localeCompare(pathKey(b.path));
+    if (pathDelta !== 0) {
+      return pathDelta;
+    }
+    return a.code.localeCompare(b.code);
+  });
+}
+function createSchemaDiagnostic(path, message) {
+  return {
+    severity: "error",
+    layer: "validate",
+    code: "validate.schema.invalid",
+    message,
+    path,
+    hint: hintForPath(path)
+  };
+}
+function createParseDiagnostic(code, message, hint) {
+  return {
+    severity: "error",
+    layer: "parse",
+    code,
+    message,
+    hint
+  };
+}
+function hintForPath(path) {
+  const pathText = pathKey(path);
+  if (pathText.endsWith(".shape")) {
+    return "Use one of: rectangle, rounded-rectangle, ellipse, diamond, parallelogram, hexagon, cylinder.";
+  }
+  if (pathText.endsWith(".format")) {
+    return "Use output format svg or excalidraw.";
+  }
+  if (pathText.includes(".position.")) {
+    return "Use finite numeric x and y coordinates.";
+  }
+  return "Check the DSL value at this path against the supported schema.";
+}
+function pathKey(path) {
+  return (path ?? []).map(String).join(".");
+}
+
+// src/dsl/edges.ts
+var EDGE_ID_PATTERN = /^[A-Za-z0-9_.:-]+$/;
+var SHORTHAND_PATTERN = /^(.+?)\s*->\s*([^:]+)(?::(.*))?$/;
+function parseEdgeShorthand(value, path) {
+  const match = SHORTHAND_PATTERN.exec(value.trim());
+  if (match === null) {
+    return invalidEdgeShorthand(path);
+  }
+  const sourceId = match[1]?.trim() ?? "";
+  const targetId = match[2]?.trim() ?? "";
+  const labelText = match[3]?.trim();
+  if (!isValidEdgeId(sourceId) || !isValidEdgeId(targetId)) {
+    return invalidEdgeShorthand(path);
+  }
+  return {
+    edge: {
+      sourceId,
+      targetId,
+      ...labelText === void 0 || labelText === "" ? {} : { label: { text: labelText } }
+    },
+    diagnostics: []
+  };
+}
+function invalidEdgeShorthand(path) {
+  return {
+    diagnostics: [
+      {
+        severity: "error",
+        layer: "validate",
+        code: "validate.edge-shorthand.invalid",
+        message: "Invalid edge shorthand.",
+        path,
+        hint: 'Use "source -> target" or "source -> target: label".'
+      }
+    ]
+  };
+}
+function isValidEdgeId(value) {
+  return value.length > 0 && EDGE_ID_PATTERN.test(value);
+}
+
+// src/geometry/shapes.ts
+var SUPPORTED_SHAPES = /* @__PURE__ */ new Set([
+  "rectangle",
+  "rounded-rectangle",
+  "ellipse",
+  "diamond",
+  "parallelogram",
+  "hexagon",
+  "cylinder"
+]);
+function computeShapeGeometry(input) {
+  validateShape(input.shape);
+  validateBox(input.box);
+  const box = { ...input.box };
+  return {
+    shape: input.shape,
+    box,
+    center: boxCenter(box),
+    anchors: createAnchors(box),
+    obstacleBox: expandBox(box, input.obstacleMargin ?? 0)
+  };
+}
+function getEdgePort(geometry, toward, preferredAnchor) {
+  validateShape(geometry.shape);
+  validateBox(geometry.box);
+  validatePoint(toward, "toward");
+  if (preferredAnchor !== void 0) {
+    const anchor = geometry.anchors.find((candidate) => {
+      return candidate.name === preferredAnchor;
+    });
+    if (anchor === void 0) {
+      throw new TypeError(`Unsupported anchor: ${preferredAnchor}`);
+    }
+    return { ...anchor.point };
+  }
+  if (geometry.shape === "rectangle" || geometry.shape === "rounded-rectangle") {
+    return rayToBox(geometry.box, toward);
+  }
+  return snapToNearestAnchor(geometry, toward);
+}
+function createAnchors(box) {
+  const left = box.x;
+  const right = box.x + box.width;
+  const top = box.y;
+  const bottom = box.y + box.height;
+  const center = boxCenter(box);
+  return [
+    { name: "center", point: center },
+    { name: "top", point: { x: center.x, y: top } },
+    { name: "right", point: { x: right, y: center.y } },
+    { name: "bottom", point: { x: center.x, y: bottom } },
+    { name: "left", point: { x: left, y: center.y } },
+    { name: "top-left", point: { x: left, y: top } },
+    { name: "top-right", point: { x: right, y: top } },
+    { name: "bottom-right", point: { x: right, y: bottom } },
+    { name: "bottom-left", point: { x: left, y: bottom } }
+  ];
+}
+function rayToBox(box, toward) {
+  const center = boxCenter(box);
+  const dx = toward.x - center.x;
+  const dy = toward.y - center.y;
+  if (dx === 0 && dy === 0) {
+    return center;
+  }
+  const halfWidth = box.width / 2;
+  const halfHeight = box.height / 2;
+  const scaleX = dx === 0 ? Number.POSITIVE_INFINITY : halfWidth / Math.abs(dx);
+  const scaleY = dy === 0 ? Number.POSITIVE_INFINITY : halfHeight / Math.abs(dy);
+  const scale = Math.min(scaleX, scaleY);
+  return clampPointToBox(
+    {
+      x: center.x + dx * scale,
+      y: center.y + dy * scale
+    },
+    box
+  );
+}
+function snapToNearestAnchor(geometry, toward) {
+  let best = geometry.anchors[0];
+  let bestDistance = Number.POSITIVE_INFINITY;
+  for (const anchor of geometry.anchors) {
+    if (anchor.name === "center") {
+      continue;
+    }
+    const distance = squaredDistance(anchor.point, toward);
+    if (distance < bestDistance) {
+      best = anchor;
+      bestDistance = distance;
+    }
+  }
+  if (best === void 0) {
+    return { ...geometry.center };
+  }
+  return clampPointToBox(best.point, geometry.box);
+}
+function clampPointToBox(point2, box) {
+  return {
+    x: Math.min(Math.max(point2.x, box.x), box.x + box.width),
+    y: Math.min(Math.max(point2.y, box.y), box.y + box.height)
+  };
+}
+function squaredDistance(a, b) {
+  const dx = a.x - b.x;
+  const dy = a.y - b.y;
+  return dx * dx + dy * dy;
+}
+function validateShape(shape) {
+  if (!SUPPORTED_SHAPES.has(shape)) {
+    throw new TypeError(`Unsupported shape: ${shape}`);
+  }
+}
+function validatePoint(point2, label) {
+  if (!Number.isFinite(point2.x) || !Number.isFinite(point2.y)) {
+    throw new TypeError(`${label} point must be finite`);
+  }
+}
+
+// src/geometry/containers.ts
+function computeContainerGeometry(input) {
+  const childBounds = unionBoxes(input.childBoxes);
+  const padding = normalizeInsets(input.padding);
+  const minSize = normalizeMinSize(input.minSize);
+  const headerHeight = input.labelLayout?.fittedSize.height ?? input.labelLayout?.box.height ?? 0;
+  const intrinsicBox = {
+    x: childBounds.x - padding.left,
+    y: childBounds.y - padding.top - headerHeight,
+    width: childBounds.width + padding.left + padding.right,
+    height: childBounds.height + padding.top + padding.bottom + headerHeight
+  };
+  const box = {
+    ...intrinsicBox,
+    width: Math.max(intrinsicBox.width, minSize.width ?? 0),
+    height: Math.max(intrinsicBox.height, minSize.height ?? 0)
+  };
+  const contentBox2 = {
+    x: childBounds.x,
+    y: childBounds.y,
+    width: childBounds.width,
+    height: childBounds.height
+  };
+  const shape = computeShapeGeometry({
+    shape: "rectangle",
+    box
+  });
+  const obstacleBox = expandBox(box, input.obstacleMargin ?? 0);
+  return {
+    id: input.id,
+    box,
+    contentBox: contentBox2,
+    childBounds,
+    ...input.labelLayout === void 0 ? {} : { labelLayout: input.labelLayout },
+    anchors: shape.anchors,
+    obstacleBox,
+    diagnostics: []
+  };
+}
+function normalizeMinSize(minSize = {}) {
+  if (minSize.width !== void 0) {
+    validateSize(minSize.width, "minSize.width");
+  }
+  if (minSize.height !== void 0) {
+    validateSize(minSize.height, "minSize.height");
+  }
+  return { ...minSize };
+}
+function validateSize(value, label) {
+  if (!Number.isFinite(value) || value < 0) {
+    throw new TypeError(`${label} must be finite and non-negative`);
+  }
+}
+
+// src/text/types.ts
+function assertFinitePositive(value, label) {
+  if (!Number.isFinite(value) || value <= 0) {
+    throw new TypeError(`${label} must be finite and positive`);
+  }
+}
+function assertFiniteNonNegative(value, label) {
+  if (!Number.isFinite(value) || value < 0) {
+    throw new TypeError(`${label} must be a finite non-negative width`);
+  }
+}
+function validateTextStyle(style) {
+  assertFinitePositive(style.fontSize, "fontSize");
+  if (style.lineHeight !== void 0) {
+    assertFinitePositive(style.lineHeight, "lineHeight");
+  }
+  if (style.letterSpacing !== void 0 && !Number.isFinite(style.letterSpacing)) {
+    throw new TypeError("letterSpacing must be finite");
+  }
+}
+function resolveLineHeight(style) {
+  validateTextStyle(style);
+  return style.lineHeight ?? style.fontSize * 1.2;
+}
+function toCanvasFont(style) {
+  validateTextStyle(style);
+  const fontStyle = style.fontStyle === "italic" ? "italic " : "";
+  const fontWeight = style.fontWeight ?? 400;
+  return `${fontStyle}${fontWeight} ${style.fontSize}px ${style.fontFamily}`;
+}
+
+// src/text/fallback.ts
+var DeterministicTextMeasurer = class {
+  prepare(text, style) {
+    validateTextStyle(style);
+    return {
+      text,
+      font: toCanvasFont(style),
+      style: { ...style },
+      backend: "deterministic"
+    };
+  }
+  layout(prepared, maxWidth, lineHeight = resolveLineHeight(prepared.style)) {
+    assertFiniteNonNegative(maxWidth, "maxWidth");
+    assertFinitePositiveLineHeight(lineHeight);
+    const lines = this.wrap(prepared, maxWidth);
+    const width = lines.reduce(
+      (current, line) => Math.max(current, line.width),
+      0
+    );
+    return {
+      width,
+      height: lines.length * lineHeight,
+      lineHeight,
+      lineCount: lines.length,
+      lines,
+      diagnostics: []
+    };
+  }
+  naturalWidth(prepared) {
+    const charWidth = getCharacterWidth(prepared.style);
+    return prepared.text.split("\n").reduce((width, line) => {
+      return Math.max(width, line.length * charWidth);
+    }, 0);
+  }
+  wrap(prepared, maxWidth) {
+    const charWidth = getCharacterWidth(prepared.style);
+    const sourceLines = prepared.text.split("\n");
+    const output = [];
+    let segmentIndex = 0;
+    for (const sourceLine of sourceLines) {
+      if (sourceLine.length === 0) {
+        output.push(createLine("", 0, segmentIndex, 0, 0));
+        segmentIndex += 1;
+        continue;
+      }
+      const maxChars = maxWidth <= 0 ? 1 : Math.max(1, Math.floor(maxWidth / charWidth));
+      for (let start = 0; start < sourceLine.length; start += maxChars) {
+        const text = sourceLine.slice(start, start + maxChars);
+        output.push(
+          createLine(
+            text,
+            text.length * charWidth,
+            segmentIndex,
+            start,
+            start + text.length
+          )
+        );
+      }
+      segmentIndex += 1;
+    }
+    if (output.length === 0) {
+      output.push(createLine("", 0, 0, 0, 0));
+    }
+    return output;
+  }
+};
+function getCharacterWidth(style) {
+  const letterSpacing = style.letterSpacing ?? 0;
+  return Math.max(0, style.fontSize * 0.6 + letterSpacing);
+}
+function createLine(text, width, segmentIndex, start, end) {
+  return {
+    text,
+    width,
+    start: {
+      segmentIndex,
+      graphemeIndex: start
+    },
+    end: {
+      segmentIndex,
+      graphemeIndex: end
+    }
+  };
+}
+function assertFinitePositiveLineHeight(lineHeight) {
+  if (!Number.isFinite(lineHeight) || lineHeight <= 0) {
+    throw new TypeError("lineHeight must be finite and positive");
+  }
+}
+var RUNTIME_UNAVAILABLE = "text.pretext.runtime-unavailable";
+function isPretextRuntimeAvailable() {
+  return typeof Intl.Segmenter === "function" && typeof globalThis.OffscreenCanvas === "function";
+}
+var PretextTextMeasurer = class {
+  prepare(text, style) {
+    if (!isPretextRuntimeAvailable()) {
+      throw new TypeError(RUNTIME_UNAVAILABLE);
+    }
+    validateTextStyle(style);
+    const font = toCanvasFont(style);
+    const options = {
+      ...style.whiteSpace === void 0 ? {} : { whiteSpace: style.whiteSpace },
+      ...style.wordBreak === void 0 ? {} : { wordBreak: style.wordBreak },
+      ...style.letterSpacing === void 0 ? {} : { letterSpacing: style.letterSpacing }
+    };
+    const prepared = pretext.prepareWithSegments(text, font, options);
+    return {
+      text,
+      font,
+      style: { ...style },
+      backend: "pretext",
+      pretextPrepared: prepared
+    };
+  }
+  layout(prepared, maxWidth, lineHeight = resolveLineHeight(prepared.style)) {
+    assertFiniteNonNegative(maxWidth, "maxWidth");
+    if (!Number.isFinite(lineHeight) || lineHeight <= 0) {
+      throw new TypeError("lineHeight must be finite and positive");
+    }
+    const result = pretext.layoutWithLines(
+      toInternalPrepared(prepared),
+      maxWidth,
+      lineHeight
+    );
+    const width = result.lines.reduce(
+      (current, line) => Math.max(current, line.width),
+      0
+    );
+    return {
+      width,
+      height: result.height,
+      lineHeight,
+      lineCount: result.lineCount,
+      lines: result.lines.map((line) => ({
+        text: line.text,
+        width: line.width,
+        start: {
+          segmentIndex: line.start.segmentIndex,
+          graphemeIndex: line.start.graphemeIndex
+        },
+        end: {
+          segmentIndex: line.end.segmentIndex,
+          graphemeIndex: line.end.graphemeIndex
+        }
+      })),
+      diagnostics: []
+    };
+  }
+  naturalWidth(prepared) {
+    return pretext.measureNaturalWidth(toInternalPrepared(prepared));
+  }
+};
+function toInternalPrepared(prepared) {
+  if (prepared.backend !== "pretext" || !("pretextPrepared" in prepared)) {
+    throw new TypeError("prepared text was not created by PretextTextMeasurer");
+  }
+  return prepared.pretextPrepared;
+}
+
+// src/labels/fit.ts
+function fitLabel(text, options, measurer) {
+  return computeLabelLayout(text, options, measurer);
+}
+var LabelFitter = class {
+  constructor(measurer) {
+    this.measurer = measurer;
+  }
+  measurer;
+  fit(text, options) {
+    return computeLabelLayout(text, options, this.measurer);
+  }
+};
+function computeLabelLayout(text, options, measurer) {
+  const padding = normalizeInsets(options.padding);
+  const minSize = normalizeMinSize2(options.minSize);
+  const lineHeight = resolveLineHeight(options.font);
+  const maxWidth = normalizeMaxWidth(options.maxWidth);
+  const prepared = measurer.prepare(text, options.font);
+  const naturalTextWidth = measurer.naturalWidth(prepared);
+  const contentMaxWidth = maxWidth === void 0 ? naturalTextWidth : Math.max(0, maxWidth - padding.left - padding.right);
+  const textLayout = measurer.layout(prepared, contentMaxWidth, lineHeight);
+  const naturalSize = {
+    width: naturalTextWidth,
+    height: textLayout.height
+  };
+  const contentWidth = Math.max(
+    textLayout.width,
+    minContentWidth(minSize, padding)
+  );
+  const contentHeight = Math.max(
+    textLayout.height,
+    minContentHeight(minSize, padding)
+  );
+  const idealWidth = contentWidth + padding.left + padding.right;
+  const idealHeight = contentHeight + padding.top + padding.bottom;
+  const fittedSize = {
+    width: maxWidth === void 0 ? idealWidth : Math.min(maxWidth, idealWidth),
+    height: idealHeight
+  };
+  const box = {
+    x: 0,
+    y: 0,
+    width: fittedSize.width,
+    height: fittedSize.height
+  };
+  const contentBox2 = {
+    x: padding.left,
+    y: padding.top,
+    width: Math.max(0, box.width - padding.left - padding.right),
+    height: Math.max(0, box.height - padding.top - padding.bottom)
+  };
+  const overflow = {
+    horizontal: textLayout.width > contentBox2.width,
+    vertical: textLayout.height > contentBox2.height || diagnosedHeightConstraintOverflow(textLayout.height, padding, minSize),
+    truncated: options.overflow === "truncate" && textLayout.width > contentBox2.width
+  };
+  const diagnostics = buildDiagnostics(overflow, options.overflow);
+  return {
+    text,
+    box,
+    contentBox: contentBox2,
+    naturalSize,
+    fittedSize,
+    padding,
+    font: { ...options.font },
+    lineHeight,
+    lines: buildLines(textLayout, contentBox2, lineHeight),
+    overflow,
+    diagnostics
+  };
+}
+function buildLines(textLayout, contentBox2, lineHeight) {
+  return textLayout.lines.map((line, lineIndex) => ({
+    text: line.text,
+    box: {
+      x: contentBox2.x,
+      y: contentBox2.y + lineIndex * lineHeight,
+      width: line.width,
+      height: lineHeight
+    },
+    baselineY: contentBox2.y + lineIndex * lineHeight + lineHeight * 0.8,
+    width: line.width,
+    lineIndex,
+    sourceStart: { ...line.start },
+    sourceEnd: { ...line.end }
+  }));
+}
+function normalizeMinSize2(minSize = {}) {
+  if (minSize.width !== void 0) {
+    assertFiniteNonNegative(minSize.width, "minSize.width");
+  }
+  if (minSize.height !== void 0) {
+    assertFiniteNonNegative(minSize.height, "minSize.height");
+  }
+  return { ...minSize };
+}
+function normalizeMaxWidth(maxWidth) {
+  if (maxWidth === void 0) {
+    return void 0;
+  }
+  assertFiniteNonNegative(maxWidth, "maxWidth");
+  return maxWidth;
+}
+function minContentWidth(minSize, padding) {
+  return Math.max(0, (minSize.width ?? 0) - padding.left - padding.right);
+}
+function minContentHeight(minSize, padding) {
+  return Math.max(0, (minSize.height ?? 0) - padding.top - padding.bottom);
+}
+function diagnosedHeightConstraintOverflow(textHeight, padding, minSize) {
+  return minSize.height !== void 0 && textHeight + padding.top + padding.bottom > minSize.height;
+}
+function buildDiagnostics(overflow, mode = "allow") {
+  if (mode !== "diagnose") {
+    return [];
+  }
+  const diagnostics = [];
+  if (overflow.horizontal) {
+    diagnostics.push({
+      severity: "warning",
+      code: "label.overflow.horizontal",
+      message: "Label text exceeds the fitted content width."
+    });
+  }
+  if (overflow.vertical) {
+    diagnostics.push({
+      severity: "warning",
+      code: "label.overflow.vertical",
+      message: "Label text exceeds the fitted content height."
+    });
+  }
+  return diagnostics;
+}
+
+// src/dsl/normalize.ts
+var DEFAULT_NODE_PADDING = {
+  top: 12,
+  right: 16,
+  bottom: 12,
+  left: 16
+};
+var DEFAULT_NODE_MIN_SIZE = { width: 80, height: 40 };
+var DEFAULT_GROUP_PADDING = {
+  top: 16,
+  right: 16,
+  bottom: 16,
+  left: 16
+};
+var DEFAULT_LABEL_MAX_WIDTH = 160;
+var DEFAULT_FONT = { fontFamily: "Arial", fontSize: 14, lineHeight: 18 };
+function normalizeDiagramDsl(dslValue, options = {}) {
+  const dsl = dslValue;
+  const diagnostics = validateReferences(dsl);
+  if (diagnostics.some((diagnostic) => diagnostic.severity === "error")) {
+    return {
+      diagnostics: sortDslDiagnostics(diagnostics),
+      ...outputResult(dsl)
+    };
+  }
+  const measurer = options.textMeasurer ?? new DeterministicTextMeasurer();
+  const routeKind = dsl.routing?.kind ?? "orthogonal";
+  const diagram = {
+    id: options.id ?? dsl.id ?? "diagram",
+    ...dsl.title === void 0 ? {} : { title: dsl.title },
+    direction: dsl.layout?.direction ?? dsl.direction ?? "TB",
+    nodes: normalizeNodes(dsl, measurer),
+    edges: normalizeEdges(dsl),
+    groups: normalizeGroups(dsl, measurer),
+    constraints: normalizeConstraints(dsl),
+    diagnostics: [],
+    metadata: { routeKind }
+  };
+  return {
+    diagram,
+    diagnostics: [],
+    ...outputResult(dsl)
+  };
+}
+function outputResult(dsl) {
+  return dsl.output?.format === void 0 ? {} : { output: { format: dsl.output.format } };
+}
+function normalizeNodes(dsl, measurer) {
+  return Object.keys(dsl.nodes).sort().map((id) => {
+    const node = dsl.nodes[id];
+    const label = toLabel(node?.label);
+    const labelLayout = label === void 0 ? void 0 : fitDslLabel(label, measurer);
+    const fittedSize = labelLayout?.fittedSize;
+    return {
+      id,
+      ...label === void 0 ? {} : { label },
+      shape: node?.shape ?? "rectangle",
+      ...node?.position === void 0 ? {} : { position: point(node.position) },
+      size: {
+        width: Math.max(DEFAULT_NODE_MIN_SIZE.width, fittedSize?.width ?? 0),
+        height: Math.max(
+          DEFAULT_NODE_MIN_SIZE.height,
+          fittedSize?.height ?? 0
+        )
+      },
+      padding: { ...DEFAULT_NODE_PADDING },
+      ...labelLayout === void 0 ? {} : { labelLayout }
+    };
+  });
+}
+function normalizeEdges(dsl) {
+  const counts = /* @__PURE__ */ new Map();
+  return (dsl.edges ?? []).map((edge) => {
+    const sourceId = typeof edge === "string" ? "" : edge.sourceId ?? edge.source ?? "";
+    const targetId = typeof edge === "string" ? "" : edge.targetId ?? edge.target ?? "";
+    const baseId = `${sourceId}-${targetId}`;
+    const count = counts.get(baseId) ?? 0;
+    counts.set(baseId, count + 1);
+    const id = typeof edge === "string" ? baseId : edge.id ?? (count === 0 ? baseId : `${baseId}-${count + 1}`);
+    const label = typeof edge === "string" ? void 0 : toLabel(edge.label);
+    return {
+      id,
+      source: { nodeId: sourceId },
+      target: { nodeId: targetId },
+      ...label === void 0 ? {} : { label }
+    };
+  });
+}
+function normalizeGroups(dsl, measurer) {
+  return Object.keys(dsl.groups ?? {}).sort().map((id) => {
+    const group = dsl.groups?.[id];
+    const label = toLabel(group?.label);
+    const labelLayout = label === void 0 ? void 0 : fitDslLabel(label, measurer);
+    return {
+      id,
+      ...label === void 0 ? {} : { label },
+      nodeIds: [...group?.nodes ?? []],
+      groupIds: [...group?.groups ?? []],
+      padding: group?.padding ?? { ...DEFAULT_GROUP_PADDING },
+      ...labelLayout === void 0 ? {} : { labelLayout }
+    };
+  });
+}
+function normalizeConstraints(dsl) {
+  const constraints = [];
+  for (const constraint of dsl.constraints ?? []) {
+    switch (constraint.kind) {
+      case "exact-position":
+        constraints.push({
+          kind: "exact-position",
+          targetId: constraint.targetId ?? constraint.target ?? "",
+          position: point(constraint.position)
+        });
+        break;
+      case "relative-position":
+        constraints.push({
+          kind: "relative-position",
+          sourceId: constraint.sourceId ?? constraint.source ?? "",
+          referenceId: constraint.referenceId ?? constraint.reference ?? "",
+          relation: constraint.relation,
+          ...constraint.offset === void 0 ? {} : { offset: point(constraint.offset) }
+        });
+        break;
+      case "align":
+        constraints.push({
+          kind: "align",
+          axis: constraint.axis,
+          targetIds: [...constraint.targetIds ?? constraint.targets ?? []]
+        });
+        break;
+      case "distribute":
+        constraints.push({
+          kind: "distribute",
+          axis: constraint.axis,
+          targetIds: [...constraint.targetIds ?? constraint.targets ?? []],
+          ...constraint.spacing === void 0 ? {} : { spacing: constraint.spacing }
+        });
+        break;
+      case "containment":
+        constraints.push({
+          kind: "containment",
+          containerId: constraint.containerId ?? constraint.container ?? "",
+          childIds: [...constraint.childIds ?? constraint.children ?? []],
+          ...constraint.padding === void 0 ? {} : { padding: constraint.padding }
+        });
+        break;
+    }
+  }
+  return constraints;
+}
+function validateReferences(dsl) {
+  const diagnostics = [];
+  const nodeIds = new Set(Object.keys(dsl.nodes));
+  const groupIds = new Set(Object.keys(dsl.groups ?? {}));
+  (dsl.edges ?? []).forEach((edge, index) => {
+    if (typeof edge === "string") {
+      return;
+    }
+    const sourceId = edge.sourceId ?? edge.source;
+    const targetId = edge.targetId ?? edge.target;
+    if (sourceId !== void 0 && !nodeIds.has(sourceId)) {
+      diagnostics.push(referenceMissing(["edges", index, "source"], sourceId));
+    }
+    if (targetId !== void 0 && !nodeIds.has(targetId)) {
+      diagnostics.push(referenceMissing(["edges", index, "target"], targetId));
+    }
+  });
+  for (const [groupId, group] of Object.entries(dsl.groups ?? {})) {
+    (group.nodes ?? []).forEach((nodeId, index) => {
+      if (!nodeIds.has(nodeId)) {
+        diagnostics.push(
+          referenceMissing(["groups", groupId, "nodes", index], nodeId)
+        );
+      }
+    });
+    (group.groups ?? []).forEach((childGroupId, index) => {
+      if (!groupIds.has(childGroupId)) {
+        diagnostics.push(
+          referenceMissing(["groups", groupId, "groups", index], childGroupId)
+        );
+      }
+    });
+  }
+  (dsl.constraints ?? []).forEach((constraint, index) => {
+    switch (constraint.kind) {
+      case "exact-position": {
+        const target = constraint.targetId ?? constraint.target;
+        if (target !== void 0 && !hasNodeOrGroup(target, nodeIds, groupIds)) {
+          diagnostics.push(
+            referenceMissing(["constraints", index, "target"], target)
+          );
+        }
+        break;
+      }
+      case "relative-position": {
+        const source = constraint.sourceId ?? constraint.source;
+        const reference = constraint.referenceId ?? constraint.reference;
+        if (source !== void 0 && !hasNodeOrGroup(source, nodeIds, groupIds)) {
+          diagnostics.push(
+            referenceMissing(["constraints", index, "source"], source)
+          );
+        }
+        if (reference !== void 0 && !hasNodeOrGroup(reference, nodeIds, groupIds)) {
+          diagnostics.push(
+            referenceMissing(["constraints", index, "reference"], reference)
+          );
+        }
+        break;
+      }
+      case "align":
+      case "distribute":
+        (constraint.targetIds ?? constraint.targets ?? []).forEach(
+          (target, targetIndex) => {
+            if (!hasNodeOrGroup(target, nodeIds, groupIds)) {
+              diagnostics.push(
+                referenceMissing(
+                  ["constraints", index, "targets", targetIndex],
+                  target
+                )
+              );
+            }
+          }
+        );
+        break;
+      case "containment": {
+        const container = constraint.containerId ?? constraint.container;
+        if (container !== void 0 && !hasNodeOrGroup(container, nodeIds, groupIds)) {
+          diagnostics.push(
+            referenceMissing(["constraints", index, "container"], container)
+          );
+        }
+        (constraint.childIds ?? constraint.children ?? []).forEach(
+          (child, childIndex) => {
+            if (!hasNodeOrGroup(child, nodeIds, groupIds)) {
+              diagnostics.push(
+                referenceMissing(
+                  ["constraints", index, "children", childIndex],
+                  child
+                )
+              );
+            }
+          }
+        );
+        break;
+      }
+    }
+  });
+  return sortDslDiagnostics(diagnostics);
+}
+function referenceMissing(path, id) {
+  return {
+    severity: "error",
+    layer: "validate",
+    code: "validate.reference.missing",
+    message: `Reference "${id}" does not exist.`,
+    path,
+    hint: "Define the referenced node or group id, or update this reference."
+  };
+}
+function hasNodeOrGroup(id, nodeIds, groupIds) {
+  return nodeIds.has(id) || groupIds.has(id);
+}
+function toLabel(value) {
+  if (value === void 0) {
+    return void 0;
+  }
+  if (typeof value === "string") {
+    return { text: value };
+  }
+  return value.maxWidth === void 0 ? { text: value.text } : { text: value.text, maxWidth: value.maxWidth };
+}
+function fitDslLabel(label, measurer) {
+  return fitLabel(
+    label.text,
+    {
+      font: DEFAULT_FONT,
+      padding: DEFAULT_NODE_PADDING,
+      minSize: DEFAULT_NODE_MIN_SIZE,
+      maxWidth: label.maxWidth ?? DEFAULT_LABEL_MAX_WIDTH
+    },
+    measurer
+  );
+}
+function point(value) {
+  return { x: value.x, y: value.y };
+}
+var directionSchema = zod.z.enum(["TB", "LR", "BT", "RL"]);
+var routeKindSchema = zod.z.enum(["orthogonal", "straight"]);
+var outputFormatSchema = zod.z.enum(["svg", "excalidraw"]);
+var nodeShapeSchema = zod.z.enum([
+  "rectangle",
+  "rounded-rectangle",
+  "ellipse",
+  "diamond",
+  "parallelogram",
+  "hexagon",
+  "cylinder"
+]);
+var finiteNumberSchema = zod.z.number().finite();
+var pointSchema = zod.z.object({
+  x: finiteNumberSchema,
+  y: finiteNumberSchema
+});
+var insetsSchema = zod.z.object({
+  top: finiteNumberSchema,
+  right: finiteNumberSchema,
+  bottom: finiteNumberSchema,
+  left: finiteNumberSchema
+});
+var labelSchema = zod.z.union([
+  zod.z.string(),
+  zod.z.object({
+    text: zod.z.string(),
+    maxWidth: finiteNumberSchema.optional()
+  })
+]);
+var nodeSchema = zod.z.object({
+  label: labelSchema.optional(),
+  shape: nodeShapeSchema.optional(),
+  position: pointSchema.optional()
+});
+var structuredEdgeSchema = zod.z.object({
+  id: zod.z.string().optional(),
+  source: zod.z.string().optional(),
+  target: zod.z.string().optional(),
+  sourceId: zod.z.string().optional(),
+  targetId: zod.z.string().optional(),
+  label: labelSchema.optional()
+}).superRefine((edge, context) => {
+  if (edge.source === void 0 && edge.sourceId === void 0) {
+    context.addIssue({
+      code: "custom",
+      message: "Edge requires source or sourceId.",
+      path: ["source"]
+    });
+  }
+  if (edge.target === void 0 && edge.targetId === void 0) {
+    context.addIssue({
+      code: "custom",
+      message: "Edge requires target or targetId.",
+      path: ["target"]
+    });
+  }
+});
+var edgeSchema = zod.z.union([zod.z.string(), structuredEdgeSchema]);
+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()
+});
+var exactPositionConstraintSchema = zod.z.object({
+  kind: zod.z.literal("exact-position"),
+  target: zod.z.string().optional(),
+  targetId: zod.z.string().optional(),
+  position: pointSchema
+});
+var relativePositionConstraintSchema = zod.z.object({
+  kind: zod.z.literal("relative-position"),
+  source: zod.z.string().optional(),
+  sourceId: zod.z.string().optional(),
+  reference: zod.z.string().optional(),
+  referenceId: zod.z.string().optional(),
+  relation: zod.z.enum(["above", "right-of", "below", "left-of"]),
+  offset: pointSchema.optional()
+});
+var alignConstraintSchema = zod.z.object({
+  kind: zod.z.literal("align"),
+  axis: zod.z.enum([
+    "x",
+    "y",
+    "center-x",
+    "center-y",
+    "top",
+    "right",
+    "bottom",
+    "left"
+  ]),
+  targets: zod.z.array(zod.z.string()).optional(),
+  targetIds: zod.z.array(zod.z.string()).optional()
+});
+var distributeConstraintSchema = zod.z.object({
+  kind: zod.z.literal("distribute"),
+  axis: zod.z.enum(["horizontal", "vertical"]),
+  targets: zod.z.array(zod.z.string()).optional(),
+  targetIds: zod.z.array(zod.z.string()).optional(),
+  spacing: finiteNumberSchema.optional()
+});
+var containmentConstraintSchema = zod.z.object({
+  kind: zod.z.literal("containment"),
+  container: zod.z.string().optional(),
+  containerId: zod.z.string().optional(),
+  children: zod.z.array(zod.z.string()).optional(),
+  childIds: zod.z.array(zod.z.string()).optional(),
+  padding: insetsSchema.optional()
+});
+var constraintSchema = zod.z.union([
+  exactPositionConstraintSchema,
+  relativePositionConstraintSchema,
+  alignConstraintSchema,
+  distributeConstraintSchema,
+  containmentConstraintSchema
+]);
+var diagramDslSchema = zod.z.object({
+  id: zod.z.string().optional(),
+  title: zod.z.string().optional(),
+  direction: directionSchema.optional(),
+  layout: zod.z.object({
+    direction: directionSchema.optional()
+  }).optional(),
+  routing: zod.z.object({
+    kind: routeKindSchema.optional()
+  }).optional(),
+  nodes: zod.z.record(zod.z.string(), nodeSchema),
+  edges: zod.z.array(edgeSchema).optional(),
+  groups: zod.z.record(zod.z.string(), groupSchema).optional(),
+  constraints: zod.z.array(constraintSchema).optional(),
+  output: zod.z.object({
+    format: outputFormatSchema.optional()
+  }).optional()
+});
+function validateDiagramDsl(value) {
+  const result = diagramDslSchema.safeParse(value);
+  if (result.success) {
+    return { value: result.data, diagnostics: [] };
+  }
+  return {
+    diagnostics: sortDslDiagnostics(
+      result.error.issues.map(
+        (issue) => createSchemaDiagnostic(toDiagnosticPath(issue.path), issue.message)
+      )
+    )
+  };
+}
+function toDiagnosticPath(path) {
+  return path.flatMap(
+    (segment) => typeof segment === "string" || typeof segment === "number" ? [segment] : []
+  );
+}
+
+// src/dsl/parse.ts
+var DEFAULT_DSL_MAX_BYTES = 1e6;
+function parseDiagramDsl(source, options = {}) {
+  const maxBytes = options.maxBytes ?? DEFAULT_DSL_MAX_BYTES;
+  if (buffer.Buffer.byteLength(source, "utf8") > maxBytes) {
+    return {
+      diagnostics: [
+        createParseDiagnostic(
+          "parse.input.too-large",
+          `Input exceeds the ${maxBytes} byte limit.`,
+          "Split the diagram into smaller inputs or raise maxBytes for trusted sources."
+        )
+      ]
+    };
+  }
+  const parsed = parseSource(source, options);
+  if (parsed.value === void 0 || hasErrorDiagnostics(parsed.diagnostics)) {
+    return { diagnostics: sortDslDiagnostics(parsed.diagnostics) };
+  }
+  const expanded = expandEdgeShorthand(parsed.value);
+  if (hasErrorDiagnostics(expanded.diagnostics)) {
+    return { diagnostics: sortDslDiagnostics(expanded.diagnostics) };
+  }
+  const validated = validateDiagramDsl(expanded.value);
+  return {
+    value: validated.value,
+    diagnostics: sortDslDiagnostics([
+      ...parsed.diagnostics,
+      ...validated.diagnostics
+    ])
+  };
+}
+function parseSource(source, options) {
+  if (isJsonSource(options)) {
+    return parseJsonSource(source);
+  }
+  return parseYamlSource(source);
+}
+function parseJsonSource(source) {
+  try {
+    return { value: JSON.parse(source), diagnostics: [] };
+  } catch (error) {
+    return {
+      diagnostics: [
+        createParseDiagnostic(
+          "parse.json.invalid",
+          `Invalid JSON: ${error instanceof Error ? error.message : String(error)}`,
+          "Fix the JSON syntax or use a .yaml source file."
+        )
+      ]
+    };
+  }
+}
+function parseYamlSource(source) {
+  const document = yaml.parseDocument(source);
+  const diagnostics = [
+    ...document.errors.map(
+      (error) => createParseDiagnostic(
+        "parse.yaml.invalid",
+        `Invalid YAML: ${error.message}`,
+        "Fix the YAML syntax near the reported parser error."
+      )
+    ),
+    ...document.warnings.map((warning) => ({
+      severity: "warning",
+      layer: "parse",
+      code: "parse.yaml.warning",
+      message: `YAML warning: ${warning.message}`,
+      hint: "Review the YAML warning before relying on the parsed value."
+    }))
+  ];
+  if (document.errors.length > 0) {
+    return { diagnostics };
+  }
+  return { value: document.toJS(), diagnostics };
+}
+function isJsonSource(options) {
+  return options.sourceFormat === "json" || (options.sourcePath?.toLowerCase().endsWith(".json") ?? false);
+}
+function hasErrorDiagnostics(diagnostics) {
+  return diagnostics.some((diagnostic) => diagnostic.severity === "error");
+}
+function expandEdgeShorthand(value) {
+  if (value === null || typeof value !== "object" || Array.isArray(value) || !("edges" in value)) {
+    return { value, diagnostics: [] };
+  }
+  const record = value;
+  if (!Array.isArray(record.edges)) {
+    return { value, diagnostics: [] };
+  }
+  const diagnostics = [];
+  const edges = record.edges.map((edge, index) => {
+    const shorthand = edgeShorthandText(edge);
+    if (shorthand === void 0) {
+      return edge;
+    }
+    const result = parseEdgeShorthand(shorthand, ["edges", index]);
+    diagnostics.push(...result.diagnostics);
+    if (result.edge === void 0) {
+      return edge;
+    }
+    return {
+      sourceId: result.edge.sourceId,
+      targetId: result.edge.targetId,
+      ...result.edge.label === void 0 ? {} : { label: result.edge.label }
+    };
+  });
+  return { value: { ...record, edges }, diagnostics };
+}
+function edgeShorthandText(edge) {
+  if (typeof edge === "string") {
+    return edge;
+  }
+  if (edge === null || typeof edge !== "object" || Array.isArray(edge)) {
+    return void 0;
+  }
+  const entries = Object.entries(edge);
+  if (entries.length !== 1) {
+    return void 0;
+  }
+  const entry = entries[0];
+  if (entry === void 0) {
+    return void 0;
+  }
+  const [key, value] = entry;
+  if (!key.includes("->") || typeof value !== "string") {
+    return void 0;
+  }
+  return `${key}: ${value}`;
+}
+
+// src/exporters/arrow.ts
+function computeArrowhead(points, options = {}) {
+  const { length = 10, width = 8 } = options;
+  for (let index = points.length - 1; index > 0; index -= 1) {
+    const tip = points[index];
+    const previous = points[index - 1];
+    if (tip === void 0 || previous === void 0) {
+      continue;
+    }
+    const dx = tip.x - previous.x;
+    const dy = tip.y - previous.y;
+    const magnitude = Math.hypot(dx, dy);
+    if (magnitude === 0) {
+      continue;
+    }
+    const direction = { x: dx / magnitude, y: dy / magnitude };
+    const perpendicular = { x: -direction.y, y: direction.x };
+    const base = {
+      x: tip.x - direction.x * length,
+      y: tip.y - direction.y * length
+    };
+    const halfWidth = width / 2;
+    return {
+      tip: { ...tip },
+      left: {
+        x: base.x + perpendicular.x * halfWidth,
+        y: base.y + perpendicular.y * halfWidth
+      },
+      right: {
+        x: base.x - perpendicular.x * halfWidth,
+        y: base.y - perpendicular.y * halfWidth
+      },
+      direction
+    };
+  }
+  throw new TypeError("Arrowhead requires at least one non-zero segment");
+}
+
+// src/exporters/excalidraw.ts
+function exportExcalidraw(diagram, options = {}) {
+  const elements = [];
+  const groupIdByChildId = createGroupMembership(diagram.groups);
+  for (const group of diagram.groups) {
+    const groupElementId = groupElementIdFor(group.id);
+    elements.push(renderGroup(group));
+    const text = renderText(
+      `group-text:${group.id}`,
+      group.label,
+      group.box,
+      groupElementId,
+      groupIdByChildId.get(group.id) ?? []
+    );
+    if (text !== void 0) {
+      elements.push(text);
+    }
+  }
+  for (const node of diagram.nodes) {
+    elements.push(renderNode(node, groupIdByChildId.get(node.id) ?? []));
+    const text = renderText(
+      `node-text:${node.id}`,
+      node.label,
+      node.box,
+      `node:${node.id}`,
+      groupIdByChildId.get(node.id) ?? []
+    );
+    if (text !== void 0) {
+      elements.push(text);
+    }
+  }
+  for (const edge of diagram.edges) {
+    elements.push(renderArrow(edge));
+  }
+  const scene = {
+    type: "excalidraw",
+    version: 2,
+    source: "auto-graph",
+    elements,
+    appState: {
+      name: options.title ?? diagram.title ?? diagram.id,
+      viewBackgroundColor: "#ffffff",
+      gridSize: null
+    },
+    files: {}
+  };
+  return `${JSON.stringify(scene, null, 2)}
+`;
+}
+function renderGroup(group) {
+  return {
+    ...baseElement(`group:${group.id}`, "rectangle", group.box),
+    backgroundColor: "transparent",
+    strokeStyle: "dashed",
+    groupIds: groupGroupIds(group.id)
+  };
+}
+function renderNode(node, groupIds) {
+  return {
+    ...baseElement(`node:${node.id}`, mapShape(node.shape), node.box),
+    groupIds
+  };
+}
+function renderArrow(edge) {
+  const first = edge.points[0];
+  if (first === void 0) {
+    throw new TypeError(
+      `Excalidraw edge ${edge.id} requires at least one point`
+    );
+  }
+  const relativePoints = edge.points.map((point2) => ({
+    x: point2.x - first.x,
+    y: point2.y - first.y
+  }));
+  const box = pointsBox(relativePoints);
+  return {
+    ...baseElement(`edge:${edge.id}`, "arrow", {
+      x: first.x,
+      y: first.y,
+      width: box.width,
+      height: box.height
+    }),
+    backgroundColor: "transparent",
+    points: relativePoints,
+    startBinding: { elementId: `node:${edge.source.nodeId}`, focus: 0, gap: 0 },
+    endBinding: { elementId: `node:${edge.target.nodeId}`, focus: 0, gap: 0 },
+    startArrowhead: null,
+    endArrowhead: "arrow"
+  };
+}
+function renderText(id, label, box, containerId, groupIds) {
+  if (label?.text === void 0) {
+    return void 0;
+  }
+  const fontSize = 14;
+  return {
+    ...baseElement(id, "text", {
+      x: box.x,
+      y: box.y + box.height / 2 - fontSize / 2,
+      width: box.width,
+      height: fontSize
+    }),
+    backgroundColor: "transparent",
+    strokeColor: "#111827",
+    groupIds,
+    text: label.text,
+    fontSize,
+    fontFamily: 1,
+    textAlign: "center",
+    verticalAlign: "middle",
+    baseline: fontSize,
+    containerId,
+    originalText: label.text,
+    lineHeight: 1.25,
+    boundElements: null,
+    link: null,
+    locked: false,
+    seed: seedFor(id),
+    versionNonce: seedFor(`${id}:nonce`)
+  };
+}
+function baseElement(id, type, box) {
+  return {
+    id,
+    type,
+    x: finite(box.x),
+    y: finite(box.y),
+    width: finite(box.width),
+    height: finite(box.height),
+    angle: 0,
+    strokeColor: "#374151",
+    backgroundColor: "#f8fafc",
+    fillStyle: "solid",
+    strokeWidth: 1,
+    strokeStyle: "solid",
+    roughness: 0,
+    opacity: 100,
+    groupIds: [],
+    seed: seedFor(id),
+    version: 1,
+    versionNonce: seedFor(`${id}:nonce`),
+    isDeleted: false,
+    boundElements: null,
+    updated: 0,
+    link: null,
+    locked: false
+  };
+}
+function mapShape(shape) {
+  switch (shape) {
+    case "rounded-rectangle":
+    case "rectangle":
+      return "rectangle";
+    case "ellipse":
+      return "ellipse";
+    case "diamond":
+      return "diamond";
+    case "parallelogram":
+      return "parallelogram";
+    case "hexagon":
+      return "hexagon";
+    case "cylinder":
+      return "cylinder";
+  }
+}
+function createGroupMembership(groups) {
+  const membership = /* @__PURE__ */ new Map();
+  for (const group of groups) {
+    const groupElementId = groupElementIdFor(group.id);
+    for (const nodeId of group.nodeIds) {
+      addMembership(membership, nodeId, groupElementId);
+    }
+    for (const childGroupId of group.groupIds) {
+      addMembership(membership, childGroupId, groupElementId);
+    }
+  }
+  return membership;
+}
+function addMembership(membership, childId, groupElementId) {
+  const existing = membership.get(childId) ?? [];
+  membership.set(childId, [...existing, groupElementId].sort());
+}
+function groupGroupIds(groupId) {
+  return [groupElementIdFor(groupId)];
+}
+function groupElementIdFor(groupId) {
+  return `group:${groupId}`;
+}
+function pointsBox(points) {
+  const xs = points.map((point2) => point2.x);
+  const ys = points.map((point2) => point2.y);
+  const minX = Math.min(...xs);
+  const maxX = Math.max(...xs);
+  const minY = Math.min(...ys);
+  const maxY = Math.max(...ys);
+  return {
+    x: minX,
+    y: minY,
+    width: maxX - minX,
+    height: maxY - minY
+  };
+}
+function finite(value) {
+  if (!Number.isFinite(value)) {
+    throw new TypeError(
+      "Excalidraw export requires finite coordinated numbers"
+    );
+  }
+  return Number.parseFloat(value.toFixed(3));
+}
+function seedFor(id) {
+  let hash = 2166136261;
+  for (let index = 0; index < id.length; index += 1) {
+    hash ^= id.charCodeAt(index);
+    hash = Math.imul(hash, 16777619);
+  }
+  return Math.abs(hash);
+}
+
+// src/exporters/svg.ts
+var NODE_FILL = "#f8fafc";
+var GROUP_FILL = "#f9fafb";
+var STROKE = "#374151";
+var EDGE_STROKE = "#111827";
+var FONT_FAMILY = "Arial, sans-serif";
+function exportSvg(diagram, options = {}) {
+  const title = options.title ?? diagram.title;
+  const lines = [
+    `<svg xmlns="http://www.w3.org/2000/svg" role="img" viewBox="${formatBoxViewBox(diagram.bounds)}">`,
+    ...title === void 0 ? [] : [`  <title>${escapeXml(title)}</title>`],
+    `  <rect class="background" x="${formatNumber(diagram.bounds.x)}" y="${formatNumber(diagram.bounds.y)}" width="${formatNumber(diagram.bounds.width)}" height="${formatNumber(diagram.bounds.height)}" fill="#ffffff"/>`,
+    ...diagram.groups.map((group) => indent(renderGroup2(group))),
+    ...diagram.edges.flatMap((edge) => {
+      const path = renderEdgePath(edge.points, edge.id);
+      if (path === void 0) {
+        return [];
+      }
+      return [indent(path), indent(renderArrowhead(edge.points, edge.id))];
+    }),
+    ...diagram.nodes.map((node) => indent(renderNode2(node))),
+    ...diagram.groups.flatMap(
+      (group) => renderLabel(group.label, group.box, group)
+    ),
+    ...diagram.nodes.flatMap((node) => renderLabel(node.label, node.box, node)),
+    "</svg>"
+  ];
+  return `${lines.join("\n")}
+`;
+}
+function renderGroup2(group) {
+  return `<rect class="group" data-id="${escapeAttribute(group.id)}" x="${formatNumber(group.box.x)}" y="${formatNumber(group.box.y)}" width="${formatNumber(group.box.width)}" height="${formatNumber(group.box.height)}" fill="${GROUP_FILL}" stroke="${STROKE}" stroke-dasharray="6 4"/>`;
+}
+function renderNode2(node) {
+  const common = `class="node node-${node.shape}" data-id="${escapeAttribute(node.id)}" fill="${NODE_FILL}" stroke="${STROKE}"`;
+  switch (node.shape) {
+    case "rectangle":
+      return renderRect(node.box, common);
+    case "rounded-rectangle":
+      return renderRect(node.box, `${common} rx="8" ry="8"`);
+    case "ellipse":
+      return `<ellipse ${common} cx="${formatNumber(node.box.x + node.box.width / 2)}" cy="${formatNumber(node.box.y + node.box.height / 2)}" rx="${formatNumber(node.box.width / 2)}" ry="${formatNumber(node.box.height / 2)}"/>`;
+    case "diamond":
+    case "parallelogram":
+    case "hexagon":
+      return `<polygon ${common} points="${formatPoints(shapePoints(node.shape, node.box))}"/>`;
+    case "cylinder":
+      return `<path ${common} d="${formatCylinderPath(node.box)}"/>`;
+  }
+}
+function renderRect(box, attributes) {
+  return `<rect ${attributes} x="${formatNumber(box.x)}" y="${formatNumber(box.y)}" width="${formatNumber(box.width)}" height="${formatNumber(box.height)}"/>`;
+}
+function renderLabel(label, box, item) {
+  const labelLayout = item.labelLayout;
+  if (labelLayout?.lines !== void 0 && labelLayout.lines.length > 0) {
+    return [
+      `  <text class="label" data-for="${escapeAttribute(item.id)}" font-family="${FONT_FAMILY}" font-size="${formatNumber(labelLayout.font.fontSize)}" fill="#111827">`,
+      ...labelLayout.lines.map(
+        (line) => `    <tspan x="${formatNumber(line.box.x)}" y="${formatNumber(line.baselineY)}">${escapeXml(line.text)}</tspan>`
+      ),
+      "  </text>"
+    ];
+  }
+  if (label?.text === void 0) {
+    return [];
+  }
+  return [
+    `  <text class="label" data-for="${escapeAttribute(item.id)}" x="${formatNumber(box.x + box.width / 2)}" y="${formatNumber(box.y + box.height / 2)}" text-anchor="middle" dominant-baseline="middle" font-family="${FONT_FAMILY}" font-size="14" fill="#111827">${escapeXml(label.text)}</text>`
+  ];
+}
+function renderEdgePath(points, id) {
+  if (points.length < 2) {
+    return void 0;
+  }
+  return `<path class="edge" data-id="${escapeAttribute(id)}" d="${formatPath(points)}" fill="none" stroke="${EDGE_STROKE}" stroke-width="1.5"/>`;
+}
+function renderArrowhead(points, id) {
+  const arrowhead = computeArrowhead(points);
+  return `<polygon class="edge-arrowhead" data-edge="${escapeAttribute(id)}" points="${formatPoints([arrowhead.tip, arrowhead.left, arrowhead.right])}" fill="${EDGE_STROKE}" stroke="${EDGE_STROKE}"/>`;
+}
+function shapePoints(shape, box) {
+  const left = box.x;
+  const right = box.x + box.width;
+  const top = box.y;
+  const bottom = box.y + box.height;
+  const midX = box.x + box.width / 2;
+  const midY = box.y + box.height / 2;
+  const skew = Math.min(box.width * 0.2, 24);
+  switch (shape) {
+    case "diamond":
+      return [
+        { x: midX, y: top },
+        { x: right, y: midY },
+        { x: midX, y: bottom },
+        { x: left, y: midY }
+      ];
+    case "parallelogram":
+      return [
+        { x: left + skew, y: top },
+        { x: right, y: top },
+        { x: right - skew, y: bottom },
+        { x: left, y: bottom }
+      ];
+    case "hexagon": {
+      const inset = Math.min(box.width * 0.2, 24);
+      return [
+        { x: left + inset, y: top },
+        { x: right - inset, y: top },
+        { x: right, y: midY },
+        { x: right - inset, y: bottom },
+        { x: left + inset, y: bottom },
+        { x: left, y: midY }
+      ];
+    }
+  }
+}
+function formatCylinderPath(box) {
+  const rx = box.width / 2;
+  const ry = Math.min(12, box.height / 4);
+  const left = box.x;
+  const right = box.x + box.width;
+  const top = box.y;
+  const bottom = box.y + box.height;
+  const midX = box.x + rx;
+  return [
+    `M ${formatNumber(left)} ${formatNumber(top + ry)}`,
+    `A ${formatNumber(rx)} ${formatNumber(ry)} 0 0 1 ${formatNumber(right)} ${formatNumber(top + ry)}`,
+    `L ${formatNumber(right)} ${formatNumber(bottom - ry)}`,
+    `A ${formatNumber(rx)} ${formatNumber(ry)} 0 0 1 ${formatNumber(left)} ${formatNumber(bottom - ry)}`,
+    "Z",
+    `M ${formatNumber(left)} ${formatNumber(top + ry)}`,
+    `A ${formatNumber(rx)} ${formatNumber(ry)} 0 0 0 ${formatNumber(right)} ${formatNumber(top + ry)}`,
+    `M ${formatNumber(left)} ${formatNumber(bottom - ry)}`,
+    `A ${formatNumber(rx)} ${formatNumber(ry)} 0 0 0 ${formatNumber(right)} ${formatNumber(bottom - ry)}`,
+    `M ${formatNumber(midX)} ${formatNumber(top)}`
+  ].join(" ");
+}
+function formatPath(points) {
+  return points.map((point2, index) => {
+    const command = index === 0 ? "M" : "L";
+    return `${command} ${formatNumber(point2.x)} ${formatNumber(point2.y)}`;
+  }).join(" ");
+}
+function formatPoints(points) {
+  return points.map((point2) => `${formatNumber(point2.x)},${formatNumber(point2.y)}`).join(" ");
+}
+function formatBoxViewBox(box) {
+  return `${formatNumber(box.x)} ${formatNumber(box.y)} ${formatNumber(box.width)} ${formatNumber(box.height)}`;
+}
+function formatNumber(value) {
+  if (!Number.isFinite(value)) {
+    throw new TypeError("SVG export requires finite coordinated numbers");
+  }
+  return Number.isInteger(value) ? String(value) : value.toFixed(3).replace(/0+$/, "").replace(/\.$/, "");
+}
+function escapeXml(value) {
+  return value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;");
+}
+function escapeAttribute(value) {
+  return escapeXml(value).replaceAll('"', "&quot;");
+}
+function indent(value) {
+  return `  ${value}`;
+}
+var DEFAULT_OPTIONS = {
+  nodesep: 80,
+  ranksep: 100,
+  edgesep: 40,
+  marginx: 0,
+  marginy: 0,
+  ranker: "network-simplex"
+};
+function runDagreInitialLayout(input) {
+  const diagnostics = [];
+  const boxes = /* @__PURE__ */ new Map();
+  const validNodeIds = /* @__PURE__ */ new Set();
+  const graph = new dagre.Graph({
+    directed: true,
+    multigraph: true,
+    compound: false
+  });
+  const options = { ...DEFAULT_OPTIONS, ...input.options };
+  graph.setGraph({
+    rankdir: input.direction,
+    nodesep: options.nodesep,
+    ranksep: options.ranksep,
+    edgesep: options.edgesep,
+    marginx: options.marginx,
+    marginy: options.marginy,
+    ranker: options.ranker
+  });
+  graph.setDefaultEdgeLabel(() => ({}));
+  for (const node of input.nodes) {
+    if (!isValidDimension(node.size.width) || !isValidDimension(node.size.height)) {
+      diagnostics.push({
+        severity: "error",
+        code: "layout.node-size.invalid",
+        message: `Node ${node.id} has invalid layout dimensions.`,
+        path: ["nodes", node.id, "size"],
+        detail: { nodeId: node.id }
+      });
+      continue;
+    }
+    validNodeIds.add(node.id);
+    graph.setNode(node.id, {
+      width: node.size.width,
+      height: node.size.height
+    });
+  }
+  for (const edge of input.edges) {
+    if (!validNodeIds.has(edge.sourceId) || !validNodeIds.has(edge.targetId)) {
+      diagnostics.push({
+        severity: "error",
+        code: "layout.edge-reference.missing",
+        message: `Edge ${edge.id} references a missing layout node.`,
+        path: ["edges", edge.id],
+        detail: {
+          edgeId: edge.id,
+          sourceId: edge.sourceId,
+          targetId: edge.targetId
+        }
+      });
+      continue;
+    }
+    graph.setEdge(
+      edge.sourceId,
+      edge.targetId,
+      { minlen: 1, weight: 1 },
+      edge.id
+    );
+  }
+  dagre.layout(graph);
+  for (const node of input.nodes) {
+    if (!validNodeIds.has(node.id)) {
+      continue;
+    }
+    const label = graph.node(node.id);
+    const centerX = label?.x;
+    const centerY = label?.y;
+    if (typeof centerX !== "number" || typeof centerY !== "number" || !Number.isFinite(centerX) || !Number.isFinite(centerY)) {
+      diagnostics.push({
+        severity: "error",
+        code: "layout.node-position.invalid",
+        message: `Dagre returned an invalid position for node ${node.id}.`,
+        path: ["nodes", node.id],
+        detail: { nodeId: node.id }
+      });
+      continue;
+    }
+    boxes.set(node.id, {
+      x: centerX - node.size.width / 2,
+      y: centerY - node.size.height / 2,
+      width: node.size.width,
+      height: node.size.height
+    });
+  }
+  return { boxes, diagnostics };
+}
+function isValidDimension(value) {
+  return Number.isFinite(value) && value >= 0;
+}
+
+// src/routing/routes.ts
+function routeEdge(input) {
+  const diagnostics = [];
+  const source = getEdgePort(
+    input.source,
+    input.target.center,
+    input.sourceAnchor
+  );
+  const target = getEdgePort(
+    input.target,
+    input.source.center,
+    input.targetAnchor
+  );
+  if ((input.kind ?? "orthogonal") === "straight") {
+    return { points: simplifyRoute([source, target]), diagnostics };
+  }
+  const candidates = orthogonalCandidates(source, target, input.direction);
+  for (const candidate of candidates) {
+    if (!routeIntersectsObstacles(candidate, input.obstacles ?? [])) {
+      return { points: simplifyRoute(candidate), diagnostics };
+    }
+  }
+  diagnostics.push({
+    severity: "warning",
+    code: "routing.obstacle.unavoidable",
+    message: "No bounded orthogonal route candidate avoided all obstacles."
+  });
+  return {
+    points: simplifyRoute(candidates[0] ?? [source, target]),
+    diagnostics
+  };
+}
+function simplifyRoute(points) {
+  const withoutDuplicates = [];
+  for (const point2 of points) {
+    const previous = withoutDuplicates.at(-1);
+    if (previous === void 0 || previous.x !== point2.x || previous.y !== point2.y) {
+      withoutDuplicates.push({ ...point2 });
+    }
+  }
+  const simplified = [];
+  for (const point2 of withoutDuplicates) {
+    const previous = simplified.at(-1);
+    const beforePrevious = simplified.at(-2);
+    if (previous !== void 0 && beforePrevious !== void 0 && areCollinear(beforePrevious, previous, point2)) {
+      simplified[simplified.length - 1] = { ...point2 };
+    } else {
+      simplified.push({ ...point2 });
+    }
+  }
+  return simplified;
+}
+function orthogonalCandidates(source, target, direction) {
+  const midpointX = (source.x + target.x) / 2;
+  const midpointY = (source.y + target.y) / 2;
+  const candidates = [
+    [source, { x: target.x, y: source.y }, target],
+    [source, { x: source.x, y: target.y }, target]
+  ];
+  if (direction === "TB" || direction === "BT") {
+    candidates.push([
+      source,
+      { x: midpointX, y: source.y },
+      { x: midpointX, y: target.y },
+      target
+    ]);
+  } else {
+    candidates.push([
+      source,
+      { x: source.x, y: midpointY },
+      { x: target.x, y: midpointY },
+      target
+    ]);
+  }
+  return candidates;
+}
+function routeIntersectsObstacles(points, obstacles) {
+  for (let index = 0; index < points.length - 1; index += 1) {
+    const a = points[index];
+    const b = points[index + 1];
+    if (a === void 0 || b === void 0) {
+      continue;
+    }
+    const segment = segmentBox(a, b);
+    for (const obstacle of obstacles) {
+      validateBox(obstacle);
+      if (intersectsAabb(segment, obstacle)) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+function segmentBox(a, b) {
+  const minX = Math.min(a.x, b.x);
+  const minY = Math.min(a.y, b.y);
+  return {
+    x: minX,
+    y: minY,
+    width: Math.max(1, Math.abs(a.x - b.x)),
+    height: Math.max(1, Math.abs(a.y - b.y))
+  };
+}
+function areCollinear(a, b, c) {
+  return a.x === b.x && b.x === c.x || a.y === b.y && b.y === c.y;
+}
+
+// src/solver/solve.ts
+function solveDiagram(diagram, options = {}) {
+  const diagnostics = [...diagram.diagnostics];
+  const nodes = stableById(diagram.nodes);
+  const edges = stableById(diagram.edges);
+  const groups = stableById(diagram.groups);
+  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) => ({
+      id: edge.id,
+      sourceId: edge.source.nodeId,
+      targetId: edge.target.nodeId
+    }))
+  });
+  diagnostics.push(...layout2.diagnostics);
+  const constrained = applyLayoutConstraints({
+    direction: diagram.direction,
+    overlapSpacing: options?.overlapSpacing ?? 40,
+    boxes: layout2.boxes,
+    nodes,
+    constraints
+  });
+  diagnostics.push(...constrained.diagnostics);
+  const coordinatedNodes = coordinateNodes(
+    nodes,
+    constrained.boxes,
+    options,
+    diagnostics
+  );
+  const nodeGeometryById = new Map(
+    coordinatedNodes.map((node) => [
+      node.id,
+      computeShapeGeometry({
+        shape: node.shape,
+        box: node.box,
+        obstacleMargin: options.obstacleMargin ?? 0
+      })
+    ])
+  );
+  const coordinatedGroups = coordinateGroups(
+    groups,
+    constrained.boxes,
+    options,
+    diagnostics
+  );
+  const groupBoxes = new Map(
+    coordinatedGroups.map((group) => [group.id, group.box])
+  );
+  const coordinatedEdges = coordinateEdges(
+    edges,
+    nodeGeometryById,
+    [...nodeGeometryById.values()].map((geometry) => geometry.obstacleBox),
+    diagram.direction,
+    options,
+    diagnostics
+  );
+  const allBoxes = [
+    ...coordinatedNodes.map((node) => node.box),
+    ...groupBoxes.values()
+  ];
+  return {
+    id: diagram.id,
+    ...diagram.title === void 0 ? {} : { title: diagram.title },
+    direction: diagram.direction,
+    nodes: coordinatedNodes,
+    edges: coordinatedEdges,
+    groups: coordinatedGroups,
+    diagnostics,
+    bounds: allBoxes.length === 0 ? { x: 0, y: 0, width: 0, height: 0 } : unionBoxes(allBoxes),
+    ...diagram.metadata === void 0 ? {} : { metadata: diagram.metadata }
+  };
+}
+function coordinateNodes(nodes, boxes, options, diagnostics) {
+  const coordinated = [];
+  for (const node of nodes) {
+    const box = boxes.get(node.id);
+    if (box === void 0) {
+      diagnostics.push({
+        severity: "error",
+        code: "solver.node-box.missing",
+        message: `Node ${node.id} has no solved box.`,
+        path: ["nodes", node.id],
+        detail: { nodeId: node.id }
+      });
+      continue;
+    }
+    const geometry = computeShapeGeometry({
+      shape: node.shape,
+      box,
+      obstacleMargin: options.obstacleMargin ?? 0
+    });
+    coordinated.push({
+      id: node.id,
+      ...node.label === void 0 ? {} : { label: node.label },
+      ...node.labelLayout === void 0 ? {} : { labelLayout: node.labelLayout },
+      shape: node.shape,
+      ...node.metadata === void 0 ? {} : { metadata: node.metadata },
+      box: geometry.box,
+      anchors: geometry.anchors,
+      ...node.parentId === void 0 ? {} : { parentId: node.parentId }
+    });
+  }
+  return coordinated;
+}
+function coordinateGroups(groups, nodeBoxes, options, diagnostics) {
+  const coordinated = [];
+  const groupBoxes = /* @__PURE__ */ new Map();
+  for (const group of groups) {
+    const childBoxes = [];
+    let missing = false;
+    for (const nodeId of group.nodeIds) {
+      const box = nodeBoxes.get(nodeId);
+      if (box === void 0) {
+        missing = true;
+        diagnostics.push(groupReferenceMissing(group.id, "node", nodeId));
+      } else {
+        childBoxes.push(box);
+      }
+    }
+    for (const childGroupId of group.groupIds) {
+      const box = groupBoxes.get(childGroupId);
+      if (box === void 0) {
+        missing = true;
+        diagnostics.push(
+          groupReferenceMissing(group.id, "group", childGroupId)
+        );
+      } else {
+        childBoxes.push(box);
+      }
+    }
+    if (missing || childBoxes.length === 0) {
+      if (childBoxes.length === 0) {
+        diagnostics.push(groupReferenceMissing(group.id, "child", void 0));
+      }
+      continue;
+    }
+    const geometry = computeContainerGeometry({
+      id: group.id,
+      childBoxes,
+      padding: group.padding,
+      ...group.labelLayout === void 0 ? {} : { labelLayout: group.labelLayout },
+      obstacleMargin: options.obstacleMargin ?? 0
+    });
+    groupBoxes.set(group.id, geometry.box);
+    diagnostics.push(...geometry.diagnostics);
+    coordinated.push({
+      ...group,
+      box: geometry.box
+    });
+  }
+  return coordinated;
+}
+function coordinateEdges(edges, nodes, obstacles, direction, options, diagnostics) {
+  const coordinated = [];
+  for (const edge of edges) {
+    const source = nodes.get(edge.source.nodeId);
+    const target = nodes.get(edge.target.nodeId);
+    if (source === void 0 || target === void 0) {
+      diagnostics.push({
+        severity: "error",
+        code: "solver.edge-reference.missing",
+        message: `Edge ${edge.id} references a missing coordinated node.`,
+        path: ["edges", edge.id],
+        detail: {
+          edgeId: edge.id,
+          sourceId: edge.source.nodeId,
+          targetId: edge.target.nodeId
+        }
+      });
+      continue;
+    }
+    const route = routeEdge({
+      kind: options.routeKind ?? "orthogonal",
+      direction,
+      source,
+      target,
+      ...edge.source.anchor === void 0 ? {} : { sourceAnchor: edge.source.anchor },
+      ...edge.target.anchor === void 0 ? {} : { targetAnchor: edge.target.anchor },
+      obstacles: obstacles.filter(
+        (obstacle) => obstacle !== source.obstacleBox && obstacle !== target.obstacleBox
+      )
+    });
+    diagnostics.push(
+      ...route.diagnostics.map((diagnostic) => ({
+        ...diagnostic,
+        detail: { ...diagnostic.detail, edgeId: edge.id }
+      }))
+    );
+    coordinated.push({
+      ...edge,
+      points: route.points
+    });
+  }
+  return coordinated;
+}
+function stableById(items) {
+  return [...items].sort((a, b) => a.id.localeCompare(b.id));
+}
+function stableByConstraintId(items) {
+  return [...items].sort(
+    (a, b) => `${a.id ?? a.kind}`.localeCompare(`${b.id ?? b.kind}`)
+  );
+}
+function groupReferenceMissing(groupId, referenceKind, id) {
+  return {
+    severity: "error",
+    code: "solver.group-reference.missing",
+    message: `Group ${groupId} references a missing ${referenceKind}.`,
+    path: ["groups", groupId],
+    detail: id === void 0 ? { groupId } : { groupId, id }
+  };
+}
+
+// src/dsl/render.ts
+function resolveOutputFormat(cliFormat, dslFormat) {
+  const selected = cliFormat ?? dslFormat ?? "svg";
+  if (selected === "svg" || selected === "excalidraw") {
+    return { format: selected, diagnostics: [] };
+  }
+  return {
+    diagnostics: [
+      {
+        severity: "error",
+        layer: "validate",
+        code: "validate.output-format.unsupported",
+        message: `Unsupported output format "${selected}".`,
+        path: ["output", "format"],
+        hint: "Use svg or excalidraw."
+      }
+    ]
+  };
+}
+function exportDiagram(format, diagram) {
+  const content = format === "svg" ? exportSvg(diagram) : exportExcalidraw(diagram);
+  return { format, content, diagnostics: [] };
+}
+function renderDiagramDsl(source, options = {}) {
+  const parsed = parseDiagramDsl(source, options);
+  if (hasErrorDiagnostics2(parsed.diagnostics) || parsed.value === void 0) {
+    return { diagnostics: parsed.diagnostics };
+  }
+  const normalized = normalizeDiagramDsl(
+    parsed.value,
+    options.textMeasurer === void 0 ? {} : { textMeasurer: options.textMeasurer }
+  );
+  const format = resolveOutputFormat(options.format, normalized.output?.format);
+  const diagnostics = sortDslDiagnostics([
+    ...parsed.diagnostics,
+    ...normalized.diagnostics,
+    ...format.diagnostics
+  ]);
+  if (normalized.diagram === void 0 || format.format === void 0 || hasErrorDiagnostics2(diagnostics)) {
+    return { diagnostics };
+  }
+  const solved = solveDiagram(normalized.diagram, {
+    routeKind: normalized.diagram.metadata?.routeKind === "straight" ? "straight" : "orthogonal"
+  });
+  const solveDiagnostics = solved.diagnostics.map(toSolveDiagnostic);
+  if (hasErrorDiagnostics2(solveDiagnostics)) {
+    return {
+      diagram: solved,
+      diagnostics: sortDslDiagnostics(solveDiagnostics)
+    };
+  }
+  try {
+    const exported = exportDiagram(format.format, solved);
+    return {
+      format: exported.format,
+      content: exported.content,
+      diagram: solved,
+      diagnostics: sortDslDiagnostics([
+        ...diagnostics,
+        ...solveDiagnostics,
+        ...exported.diagnostics.map(toExportDiagnostic)
+      ])
+    };
+  } catch (error) {
+    return {
+      diagram: solved,
+      diagnostics: [
+        {
+          severity: "error",
+          layer: "export",
+          code: "export.failed",
+          message: error instanceof Error ? error.message : String(error),
+          hint: "Check the coordinated diagram and selected output format."
+        }
+      ]
+    };
+  }
+}
+function toSolveDiagnostic(diagnostic) {
+  return { ...diagnostic, layer: "solve" };
+}
+function toExportDiagnostic(diagnostic) {
+  return { ...diagnostic, layer: "export" };
+}
+function hasErrorDiagnostics2(diagnostics) {
+  return diagnostics.some((diagnostic) => diagnostic.severity === "error");
+}
+
+// src/serialization/canonical.ts
+var DEFAULT_CANONICAL_PRECISION = 3;
+var UNORDERED_COLLECTION_KEYS = /* @__PURE__ */ new Set([
+  "nodes",
+  "edges",
+  "groups",
+  "constraints",
+  "diagnostics",
+  "anchors"
+]);
+var IDENTITY_KEYS = [
+  "id",
+  "name",
+  "sourceId",
+  "targetId",
+  "nodeId",
+  "groupId",
+  "kind"
+];
+function canonicalize(value, options = {}) {
+  const precision = resolvePrecision(
+    options.precision ?? DEFAULT_CANONICAL_PRECISION
+  );
+  return canonicalizeValue(value, precision);
+}
+function stringifyCanonical(value, precision = DEFAULT_CANONICAL_PRECISION) {
+  return `${JSON.stringify(
+    canonicalize(value, { precision: resolvePrecision(precision) }),
+    null,
+    2
+  )}
+`;
+}
+function resolvePrecision(precision) {
+  if (!Number.isInteger(precision) || precision < 0) {
+    throw new TypeError("Canonical precision must be a non-negative integer");
+  }
+  return precision;
+}
+function canonicalizeValue(value, precision, parentKey) {
+  if (value === null || typeof value === "boolean" || typeof value === "string") {
+    return value;
+  }
+  if (typeof value === "number") {
+    if (!Number.isFinite(value)) {
+      throw new TypeError("Non-finite number cannot be canonicalized");
+    }
+    if (Object.is(value, -0)) {
+      return 0;
+    }
+    const factor = 10 ** precision;
+    const rounded = Math.round(value * factor) / factor;
+    return Object.is(rounded, -0) ? 0 : rounded;
+  }
+  if (Array.isArray(value)) {
+    return canonicalizeArray(value, precision, parentKey);
+  }
+  if (typeof value === "object") {
+    return canonicalizeObject(value, precision);
+  }
+  throw new TypeError("Unsupported value cannot be canonicalized");
+}
+function canonicalizeArray(value, precision, parentKey) {
+  const canonicalItems = value.map(
+    (item) => canonicalizeValue(item, precision, parentKey)
+  );
+  if (!shouldSortArray(value, parentKey)) {
+    return canonicalItems;
+  }
+  return [...canonicalItems].sort(compareCanonicalItems);
+}
+function canonicalizeObject(value, precision) {
+  const result = {};
+  for (const key of Object.keys(value).sort()) {
+    const rawValue = value[key];
+    if (rawValue === void 0) {
+      continue;
+    }
+    result[key] = canonicalizeValue(rawValue, precision, key);
+  }
+  return result;
+}
+function shouldSortArray(value, parentKey) {
+  if (parentKey === "points" || value.every(isPointLikeRecord)) {
+    return false;
+  }
+  if (parentKey !== void 0 && UNORDERED_COLLECTION_KEYS.has(parentKey)) {
+    return value.every(isPlainObject);
+  }
+  return value.length > 0 && value.every((item) => isPlainObject(item) && hasIdentityKey(item));
+}
+function compareCanonicalItems(a, b) {
+  const aKey = itemSortKey(a);
+  const bKey = itemSortKey(b);
+  return aKey.localeCompare(bKey);
+}
+function itemSortKey(value) {
+  if (!isCanonicalObject(value)) {
+    return "";
+  }
+  return IDENTITY_KEYS.map((key) => identityPart(key, value)).join("\0");
+}
+function identityPart(key, value) {
+  const part = value[key];
+  if (typeof part === "string" || typeof part === "number") {
+    return String(part);
+  }
+  return "";
+}
+function hasIdentityKey(value) {
+  return IDENTITY_KEYS.some((key) => key in value);
+}
+function isPlainObject(value) {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) {
+    return false;
+  }
+  const prototype = Object.getPrototypeOf(value);
+  return prototype === Object.prototype || prototype === null;
+}
+function isCanonicalObject(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function isPointLikeRecord(value) {
+  return isPlainObject(value) && typeof value.x === "number" && typeof value.y === "number";
+}
+
+exports.DEFAULT_CANONICAL_PRECISION = DEFAULT_CANONICAL_PRECISION;
+exports.DEFAULT_DSL_MAX_BYTES = DEFAULT_DSL_MAX_BYTES;
+exports.DeterministicTextMeasurer = DeterministicTextMeasurer;
+exports.LabelFitter = LabelFitter;
+exports.PretextTextMeasurer = PretextTextMeasurer;
+exports.applyLayoutConstraints = applyLayoutConstraints;
+exports.assertFiniteNonNegative = assertFiniteNonNegative;
+exports.assertFinitePositive = assertFinitePositive;
+exports.boxCenter = boxCenter;
+exports.canonicalize = canonicalize;
+exports.computeArrowhead = computeArrowhead;
+exports.computeContainerGeometry = computeContainerGeometry;
+exports.computeShapeGeometry = computeShapeGeometry;
+exports.expandBox = expandBox;
+exports.exportExcalidraw = exportExcalidraw;
+exports.exportSvg = exportSvg;
+exports.fitLabel = fitLabel;
+exports.getEdgePort = getEdgePort;
+exports.intersectsAabb = intersectsAabb;
+exports.isPretextRuntimeAvailable = isPretextRuntimeAvailable;
+exports.normalizeDiagramDsl = normalizeDiagramDsl;
+exports.normalizeInsets = normalizeInsets;
+exports.parseDiagramDsl = parseDiagramDsl;
+exports.parseEdgeShorthand = parseEdgeShorthand;
+exports.renderDiagramDsl = renderDiagramDsl;
+exports.resolveLineHeight = resolveLineHeight;
+exports.resolveOutputFormat = resolveOutputFormat;
+exports.routeEdge = routeEdge;
+exports.runDagreInitialLayout = runDagreInitialLayout;
+exports.simplifyRoute = simplifyRoute;
+exports.solveDiagram = solveDiagram;
+exports.sortDslDiagnostics = sortDslDiagnostics;
+exports.stringifyCanonical = stringifyCanonical;
+exports.toCanvasFont = toCanvasFont;
+exports.unionBoxes = unionBoxes;
+exports.validateBox = validateBox;
+exports.validateTextStyle = validateTextStyle;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map