drowai-mcp 0.1.0

package/dist/cli.js

@@ -0,0 +1,3126 @@
+#!/usr/bin/env node
+
+import { realpathSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+
+import { randomUUID } from "node:crypto";
+
+import Fastify from "fastify";
+
+var error = (code, message, options = {}) => {
+  const result = {
+    code,
+    message,
+    severity: "error"
+  };
+  if (options.fieldPath !== void 0) {
+    result.fieldPath = options.fieldPath;
+  }
+  if (options.objectId !== void 0) {
+    result.objectId = options.objectId;
+  }
+  return result;
+};
+var warning = (code, message, options = {}) => {
+  const result = {
+    code,
+    message,
+    severity: "warning"
+  };
+  if (options.fieldPath !== void 0) {
+    result.fieldPath = options.fieldPath;
+  }
+  if (options.objectId !== void 0) {
+    result.objectId = options.objectId;
+  }
+  return result;
+};
+
+import { ulid } from "ulid";
+
+var DOCUMENT_ID_PREFIX = "doc_";
+var NODE_ID_PREFIX = "node_";
+var EDGE_ID_PREFIX = "edge_";
+var NODE_TYPES = [
+  "rectangle",
+  "roundedRectangle",
+  "ellipse",
+  "diamond",
+  "text"
+];
+var EDGE_PATH_TYPES = ["straight", "orthogonal"];
+var STYLE_PRESETS = ["default", "emphasis", "warning", "muted"];
+var STROKE_WIDTHS = [1, 2, 3, 4, 6];
+var FONT_SIZES = [12, 14, 16, 20, 24, 32];
+var EDGE_FONT_SIZES = [12, 14, 16, 20, 24];
+var FONT_WEIGHTS = ["normal", "bold"];
+var TEXT_ALIGNS = ["left", "center", "right"];
+var VERTICAL_ALIGNS = ["top", "middle", "bottom"];
+var ARROW_TYPES = ["none", "classic", "block", "open"];
+var ANCHOR_SIDES = ["top", "right", "bottom", "left"];
+
+var ID_PATTERNS = {
+  [DOCUMENT_ID_PREFIX]: /^doc_[a-z0-9][a-z0-9_-]{2,63}$/,
+  [NODE_ID_PREFIX]: /^node_[a-z0-9][a-z0-9_-]{2,63}$/,
+  [EDGE_ID_PREFIX]: /^edge_[a-z0-9][a-z0-9_-]{2,63}$/
+};
+var generateDocumentId = () => `${DOCUMENT_ID_PREFIX}${ulid().toLowerCase()}`;
+var generateNodeId = () => `${NODE_ID_PREFIX}${ulid().toLowerCase()}`;
+var generateEdgeId = () => `${EDGE_ID_PREFIX}${ulid().toLowerCase()}`;
+
+var BASE_NODE_PRESETS = {
+  default: {
+    fillColor: "#ffffff",
+    strokeColor: "#1f2937",
+    strokeWidth: 1,
+    dashed: false,
+    rounded: false,
+    textColor: "#111827",
+    fontSize: 14,
+    fontWeight: "normal",
+    textAlign: "center",
+    verticalAlign: "middle",
+    wrap: true
+  },
+  emphasis: {
+    fillColor: "#dbeafe",
+    strokeColor: "#1d4ed8",
+    strokeWidth: 2,
+    dashed: false,
+    rounded: false,
+    textColor: "#1e3a8a",
+    fontSize: 14,
+    fontWeight: "bold",
+    textAlign: "center",
+    verticalAlign: "middle",
+    wrap: true
+  },
+  warning: {
+    fillColor: "#fef3c7",
+    strokeColor: "#d97706",
+    strokeWidth: 2,
+    dashed: false,
+    rounded: false,
+    textColor: "#92400e",
+    fontSize: 14,
+    fontWeight: "bold",
+    textAlign: "center",
+    verticalAlign: "middle",
+    wrap: true
+  },
+  muted: {
+    fillColor: "#f3f4f6",
+    strokeColor: "#9ca3af",
+    strokeWidth: 1,
+    dashed: true,
+    rounded: false,
+    textColor: "#6b7280",
+    fontSize: 14,
+    fontWeight: "normal",
+    textAlign: "center",
+    verticalAlign: "middle",
+    wrap: true
+  }
+};
+var BASE_EDGE_PRESETS = {
+  default: {
+    strokeColor: "#1f2937",
+    strokeWidth: 1,
+    dashed: false,
+    textColor: "#111827",
+    fontSize: 14,
+    fontWeight: "normal",
+    textAlign: "center",
+    verticalAlign: "middle",
+    wrap: true,
+    arrowStart: "none",
+    arrowEnd: "classic"
+  },
+  emphasis: {
+    strokeColor: "#1d4ed8",
+    strokeWidth: 2,
+    dashed: false,
+    textColor: "#1e3a8a",
+    fontSize: 14,
+    fontWeight: "bold",
+    textAlign: "center",
+    verticalAlign: "middle",
+    wrap: true,
+    arrowStart: "none",
+    arrowEnd: "classic"
+  },
+  warning: {
+    strokeColor: "#d97706",
+    strokeWidth: 2,
+    dashed: false,
+    textColor: "#92400e",
+    fontSize: 14,
+    fontWeight: "bold",
+    textAlign: "center",
+    verticalAlign: "middle",
+    wrap: true,
+    arrowStart: "none",
+    arrowEnd: "classic"
+  },
+  muted: {
+    strokeColor: "#9ca3af",
+    strokeWidth: 1,
+    dashed: true,
+    textColor: "#6b7280",
+    fontSize: 14,
+    fontWeight: "normal",
+    textAlign: "center",
+    verticalAlign: "middle",
+    wrap: true,
+    arrowStart: "none",
+    arrowEnd: "open"
+  }
+};
+var NODE_STYLE_KEYS = [
+  "preset",
+  "fillColor",
+  "strokeColor",
+  "strokeWidth",
+  "dashed",
+  "rounded",
+  "textColor",
+  "fontSize",
+  "fontWeight",
+  "textAlign",
+  "verticalAlign",
+  "wrap"
+];
+var EDGE_STYLE_KEYS = [
+  "preset",
+  "strokeColor",
+  "strokeWidth",
+  "dashed",
+  "textColor",
+  "fontSize",
+  "fontWeight",
+  "textAlign",
+  "verticalAlign",
+  "wrap",
+  "arrowStart",
+  "arrowEnd"
+];
+var resolveNodeStyle = (style, forceRounded) => {
+  const preset = style?.preset ?? "default";
+  const resolved = {
+    preset,
+    ...BASE_NODE_PRESETS[preset],
+    ...style
+  };
+  if (forceRounded) {
+    resolved.rounded = true;
+  }
+  return resolved;
+};
+var resolveEdgeStyle = (style) => {
+  const preset = style?.preset ?? "default";
+  return {
+    preset,
+    ...BASE_EDGE_PRESETS[preset],
+    ...style
+  };
+};
+
+var ANCHOR_ORDER = ["right", "bottom", "left", "top"];
+var nodeCenter = (node) => ({
+  x: node.x + Math.round(node.width / 2),
+  y: node.y + Math.round(node.height / 2)
+});
+var axisOf = (side) => side === "left" || side === "right" ? "horizontal" : "vertical";
+var anchorRank = {
+  right: 0,
+  bottom: 1,
+  left: 2,
+  top: 3
+};
+var getAnchorPoint = (node, side) => {
+  switch (side) {
+    case "top":
+      return { x: node.x + Math.round(node.width / 2), y: node.y };
+    case "right":
+      return { x: node.x + node.width, y: node.y + Math.round(node.height / 2) };
+    case "bottom":
+      return { x: node.x + Math.round(node.width / 2), y: node.y + node.height };
+    case "left":
+      return { x: node.x, y: node.y + Math.round(node.height / 2) };
+  }
+};
+var fallbackAnchors = (source, target) => {
+  const sourceCenter = nodeCenter(source);
+  const targetCenter = nodeCenter(target);
+  const dx = targetCenter.x - sourceCenter.x;
+  const dy = targetCenter.y - sourceCenter.y;
+  if (Math.abs(dx) >= Math.abs(dy)) {
+    return dx >= 0 ? { sourceAnchor: "right", targetAnchor: "left" } : { sourceAnchor: "left", targetAnchor: "right" };
+  }
+  return dy >= 0 ? { sourceAnchor: "bottom", targetAnchor: "top" } : { sourceAnchor: "top", targetAnchor: "bottom" };
+};
+var roundPoint = (point) => ({
+  x: Math.round(point.x),
+  y: Math.round(point.y)
+});
+var dedupeRoutePoints = (points) => {
+  const result = [];
+  for (const point of points) {
+    const previous = result.at(-1);
+    const rounded = roundPoint(point);
+    if (!previous || previous.x !== rounded.x || previous.y !== rounded.y) {
+      result.push(rounded);
+    }
+  }
+  return result;
+};
+var preferredAxis = (source, target) => {
+  const horizontalGap = Math.max(target.x - (source.x + source.width), source.x - (target.x + target.width), 0);
+  const verticalGap = Math.max(target.y - (source.y + source.height), source.y - (target.y + target.height), 0);
+  if (horizontalGap !== verticalGap) {
+    return horizontalGap > verticalGap ? "horizontal" : "vertical";
+  }
+  const sourceCenter = nodeCenter(source);
+  const targetCenter = nodeCenter(target);
+  const dx = Math.abs(targetCenter.x - sourceCenter.x);
+  const dy = Math.abs(targetCenter.y - sourceCenter.y);
+  if (dx === dy) {
+    return null;
+  }
+  return dx > dy ? "horizontal" : "vertical";
+};
+var buildRawRoutePoints = (sourcePoint, targetPoint, sourceAnchor, targetAnchor) => {
+  const sourceAxis = axisOf(sourceAnchor);
+  const targetAxis = axisOf(targetAnchor);
+  if (sourceAxis !== targetAxis) {
+    return sourceAxis === "horizontal" ? [{ x: targetPoint.x, y: sourcePoint.y }] : [{ x: sourcePoint.x, y: targetPoint.y }];
+  }
+  if (sourceAxis === "horizontal") {
+    const midpointX = Math.round((sourcePoint.x + targetPoint.x) / 2);
+    if (sourcePoint.y === targetPoint.y) {
+      return [{ x: midpointX, y: sourcePoint.y }];
+    }
+    return [
+      { x: midpointX, y: sourcePoint.y },
+      { x: midpointX, y: targetPoint.y }
+    ];
+  }
+  const midpointY = Math.round((sourcePoint.y + targetPoint.y) / 2);
+  if (sourcePoint.x === targetPoint.x) {
+    return [{ x: sourcePoint.x, y: midpointY }];
+  }
+  return [
+    { x: sourcePoint.x, y: midpointY },
+    { x: targetPoint.x, y: midpointY }
+  ];
+};
+var normalizeCandidatePoints = (sourcePoint, targetPoint, points) => {
+  const deduped = dedupeRoutePoints(points);
+  if (deduped.length <= 1) {
+    return deduped;
+  }
+  const fullPath = [sourcePoint, ...deduped, targetPoint];
+  const simplified = [];
+  for (let index = 1; index < fullPath.length - 1; index += 1) {
+    const previous = fullPath[index - 1];
+    const current = fullPath[index];
+    const next = fullPath[index + 1];
+    const isCollinear = previous.x === current.x && current.x === next.x || previous.y === current.y && current.y === next.y;
+    if (!isCollinear) {
+      simplified.push(current);
+    }
+  }
+  return simplified;
+};
+var directionOf = (from, to) => {
+  if (from.x === to.x && from.y === to.y) {
+    return null;
+  }
+  if (from.x !== to.x && from.y !== to.y) {
+    return null;
+  }
+  if (to.x > from.x) {
+    return "right";
+  }
+  if (to.x < from.x) {
+    return "left";
+  }
+  return to.y > from.y ? "bottom" : "top";
+};
+var countBends = (path) => {
+  let bends = 0;
+  let previousDirection = null;
+  for (let index = 1; index < path.length; index += 1) {
+    const direction = directionOf(path[index - 1], path[index]);
+    if (!direction) {
+      return Number.POSITIVE_INFINITY;
+    }
+    if (previousDirection && previousDirection !== direction) {
+      bends += 1;
+    }
+    previousDirection = direction;
+  }
+  return bends;
+};
+var totalLength = (path) => path.slice(1).reduce((sum, point, index) => {
+  const previous = path[index];
+  return sum + Math.abs(point.x - previous.x) + Math.abs(point.y - previous.y);
+}, 0);
+var facingPenalty = (anchor, from, to) => {
+  switch (anchor) {
+    case "right":
+      return to.x >= from.x ? 0 : 2;
+    case "left":
+      return to.x <= from.x ? 0 : 2;
+    case "bottom":
+      return to.y >= from.y ? 0 : 2;
+    case "top":
+      return to.y <= from.y ? 0 : 2;
+  }
+};
+var stickinessPenalty = (sourceAnchor, targetAnchor, preferred) => {
+  if (!preferred?.sourceAnchor && !preferred?.targetAnchor) {
+    return 0;
+  }
+  let penalty = 0;
+  if (preferred.sourceAnchor && preferred.sourceAnchor !== sourceAnchor) {
+    penalty += 1;
+  }
+  if (preferred.targetAnchor && preferred.targetAnchor !== targetAnchor) {
+    penalty += 1;
+  }
+  return penalty;
+};
+var buildCandidate = (source, target, sourceAnchor, targetAnchor, preferred, preferredRouteAxis) => {
+  const sourceCenter = nodeCenter(source);
+  const targetCenter = nodeCenter(target);
+  const sourcePoint = getAnchorPoint(source, sourceAnchor);
+  const targetPoint = getAnchorPoint(target, targetAnchor);
+  const points = normalizeCandidatePoints(
+    sourcePoint,
+    targetPoint,
+    buildRawRoutePoints(sourcePoint, targetPoint, sourceAnchor, targetAnchor)
+  );
+  const path = [sourcePoint, ...points, targetPoint];
+  const startDirection = directionOf(sourcePoint, path[1]);
+  const targetEntryDirection = directionOf(targetPoint, path[path.length - 2]);
+  if (!startDirection || !targetEntryDirection) {
+    return null;
+  }
+  if (startDirection !== sourceAnchor || targetEntryDirection !== targetAnchor) {
+    return null;
+  }
+  const bends = countBends(path);
+  if (!Number.isFinite(bends)) {
+    return null;
+  }
+  return {
+    sourceAnchor,
+    targetAnchor,
+    points,
+    score: [
+      bends,
+      facingPenalty(sourceAnchor, sourceCenter, targetCenter) + facingPenalty(targetAnchor, targetCenter, sourceCenter),
+      stickinessPenalty(sourceAnchor, targetAnchor, preferred),
+      preferredRouteAxis && axisOf(sourceAnchor) !== preferredRouteAxis ? 1 : 0,
+      totalLength(path),
+      anchorRank[sourceAnchor],
+      anchorRank[targetAnchor]
+    ]
+  };
+};
+var candidateOrder = (left, right) => {
+  for (let index = 0; index < left.score.length; index += 1) {
+    const delta = left.score[index] - right.score[index];
+    if (delta !== 0) {
+      return delta;
+    }
+  }
+  return 0;
+};
+var selectRouteCandidate = (source, target, preferred) => {
+  const axisPreference = preferredAxis(source, target);
+  let selected = null;
+  for (const sourceAnchor of ANCHOR_ORDER) {
+    for (const targetAnchor of ANCHOR_ORDER) {
+      const candidate = buildCandidate(source, target, sourceAnchor, targetAnchor, preferred, axisPreference);
+      if (!candidate) {
+        continue;
+      }
+      if (!selected || candidateOrder(candidate, selected) < 0) {
+        selected = candidate;
+      }
+    }
+  }
+  return selected;
+};
+var deriveAnchors = (source, target) => {
+  const candidate = selectRouteCandidate(source, target);
+  return candidate ? {
+    sourceAnchor: candidate.sourceAnchor,
+    targetAnchor: candidate.targetAnchor
+  } : fallbackAnchors(source, target);
+};
+var calculateOrthogonalRoute = (source, target, revision, preferred) => {
+  const candidate = selectRouteCandidate(source, target, preferred);
+  if (candidate) {
+    return {
+      sourceAnchor: candidate.sourceAnchor,
+      targetAnchor: candidate.targetAnchor,
+      points: candidate.points,
+      calculatedAtRevision: revision
+    };
+  }
+  const { sourceAnchor, targetAnchor } = fallbackAnchors(source, target);
+  const sourcePoint = getAnchorPoint(source, sourceAnchor);
+  const targetPoint = getAnchorPoint(target, targetAnchor);
+  const points = sourceAnchor === "left" || sourceAnchor === "right" ? dedupeRoutePoints([
+    { x: Math.round((sourcePoint.x + targetPoint.x) / 2), y: sourcePoint.y },
+    { x: Math.round((sourcePoint.x + targetPoint.x) / 2), y: targetPoint.y }
+  ]) : dedupeRoutePoints([
+    { x: sourcePoint.x, y: Math.round((sourcePoint.y + targetPoint.y) / 2) },
+    { x: targetPoint.x, y: Math.round((sourcePoint.y + targetPoint.y) / 2) }
+  ]);
+  return {
+    sourceAnchor,
+    targetAnchor,
+    points,
+    calculatedAtRevision: revision
+  };
+};
+var recalculateEdgePaths = (document, edgeIds, nextRevision) => {
+  const allowed = edgeIds ? new Set(edgeIds) : null;
+  const nodeMap = new Map(document.nodes.map((node) => [node.id, node]));
+  return {
+    ...document,
+    edges: document.edges.map((edge) => {
+      if (edge.pathType !== "orthogonal") {
+        return edge;
+      }
+      if (allowed && !allowed.has(edge.id)) {
+        return edge;
+      }
+      const source = nodeMap.get(edge.sourceNodeId);
+      const target = nodeMap.get(edge.targetNodeId);
+      if (!source || !target) {
+        return edge;
+      }
+      return {
+        ...edge,
+        route: calculateOrthogonalRoute(source, target, nextRevision, edge.route)
+      };
+    })
+  };
+};
+
+var DEFAULT_CANVAS = {
+  width: 1600,
+  height: 900,
+  backgroundColor: "#ffffff",
+  padding: 80,
+  autoExpand: true
+};
+var round = (value) => Math.round(value);
+var normalizePoint = (point) => ({
+  x: round(point.x),
+  y: round(point.y)
+});
+var nowIso = () => (/* @__PURE__ */ new Date()).toISOString();
+var normalizeCanvas = (canvas) => ({
+  width: round(canvas?.width ?? DEFAULT_CANVAS.width),
+  height: round(canvas?.height ?? DEFAULT_CANVAS.height),
+  backgroundColor: canvas?.backgroundColor ?? DEFAULT_CANVAS.backgroundColor,
+  padding: round(canvas?.padding ?? DEFAULT_CANVAS.padding),
+  autoExpand: canvas?.autoExpand ?? DEFAULT_CANVAS.autoExpand
+});
+var createDocument = (input, actor, timestamp = nowIso()) => {
+  return normalizeDocument({
+    id: input?.id ?? generateDocumentId(),
+    title: input?.title ?? "Untitled Diagram",
+    revision: 1,
+    metadata: {
+      createdBy: actor.actorId,
+      createdAt: timestamp,
+      updatedAt: timestamp,
+      ownerId: actor.ownerId,
+      tenantId: actor.tenantId
+    },
+    canvas: normalizeCanvas(input?.canvas),
+    nodes: [],
+    edges: []
+  });
+};
+var normalizeNode = (input) => ({
+  id: input.id ?? generateNodeId(),
+  type: input.type,
+  x: round(input.x),
+  y: round(input.y),
+  width: round(input.width),
+  height: round(input.height),
+  text: input.text ?? "",
+  style: resolveNodeStyle(input.style, input.type === "roundedRectangle"),
+  zIndex: round(input.zIndex ?? 0),
+  metadata: { ...input.metadata ?? {} }
+});
+var normalizeEdge = (input, nodeMap) => {
+  const sourceNode = nodeMap.get(input.sourceNodeId);
+  const targetNode = nodeMap.get(input.targetNodeId);
+  const anchors = sourceNode && targetNode ? deriveAnchors(sourceNode, targetNode) : { sourceAnchor: "right", targetAnchor: "left" };
+  return {
+    id: input.id ?? generateEdgeId(),
+    sourceNodeId: input.sourceNodeId,
+    targetNodeId: input.targetNodeId,
+    label: input.label ?? "",
+    pathType: input.pathType ?? "straight",
+    route: {
+      sourceAnchor: input.route?.sourceAnchor ?? anchors.sourceAnchor,
+      targetAnchor: input.route?.targetAnchor ?? anchors.targetAnchor,
+      points: (input.route?.points ?? []).map(normalizePoint),
+      calculatedAtRevision: input.route?.calculatedAtRevision ?? null
+    },
+    style: resolveEdgeStyle(input.style),
+    metadata: { ...input.metadata ?? {} }
+  };
+};
+var autoExpandCanvas = (document) => {
+  if (!document.canvas.autoExpand) {
+    return document;
+  }
+  let maxX = document.canvas.width;
+  let maxY = document.canvas.height;
+  for (const node of document.nodes) {
+    maxX = Math.max(maxX, node.x + node.width + document.canvas.padding);
+    maxY = Math.max(maxY, node.y + node.height + document.canvas.padding);
+  }
+  for (const edge of document.edges) {
+    for (const point of edge.route.points) {
+      maxX = Math.max(maxX, point.x + document.canvas.padding);
+      maxY = Math.max(maxY, point.y + document.canvas.padding);
+    }
+  }
+  return {
+    ...document,
+    canvas: {
+      ...document.canvas,
+      width: Math.max(320, round(maxX)),
+      height: Math.max(240, round(maxY))
+    }
+  };
+};
+var normalizeDocument = (input) => {
+  const normalizedNodes = input.nodes.map(normalizeNode).sort((a, b) => a.zIndex - b.zIndex || a.id.localeCompare(b.id));
+  const nodeMap = new Map(normalizedNodes.map((node) => [node.id, node]));
+  const normalizedEdges = input.edges.map((edge) => normalizeEdge(edge, nodeMap)).sort((a, b) => a.id.localeCompare(b.id));
+  return autoExpandCanvas({
+    id: input.id,
+    title: input.title,
+    revision: round(input.revision),
+    metadata: { ...input.metadata },
+    canvas: normalizeCanvas(input.canvas),
+    nodes: normalizedNodes,
+    edges: normalizedEdges
+  });
+};
+
+var nodeMapOf = (document) => new Map(document.nodes.map((node) => [node.id, node]));
+var edgeMapOf = (document) => new Map(document.edges.map((edge) => [edge.id, edge]));
+var withRevision = (document, revision) => ({
+  ...document,
+  revision,
+  metadata: {
+    ...document.metadata,
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  }
+});
+var addNode = (document, input) => {
+  const node = normalizeNode(input);
+  return {
+    document: normalizeDocument({
+      ...document,
+      nodes: [...document.nodes, node]
+    }),
+    changedObjectIds: [node.id]
+  };
+};
+var updateNode = (document, nodeId, changes) => {
+  let changed = false;
+  const nodes = document.nodes.map((node) => {
+    if (node.id !== nodeId) {
+      return node;
+    }
+    changed = true;
+    return normalizeNode({
+      ...node,
+      ...changes,
+      metadata: changes.metadata ?? node.metadata,
+      style: {
+        ...node.style,
+        ...changes.style
+      }
+    });
+  });
+  return {
+    document: normalizeDocument({ ...document, nodes }),
+    changedObjectIds: changed ? [nodeId] : []
+  };
+};
+var deleteNode = (document, nodeId) => {
+  const edgesToDelete = document.edges.filter((edge) => edge.sourceNodeId === nodeId || edge.targetNodeId === nodeId).map((edge) => edge.id);
+  return {
+    document: normalizeDocument({
+      ...document,
+      nodes: document.nodes.filter((node) => node.id !== nodeId),
+      edges: document.edges.filter((edge) => !edgesToDelete.includes(edge.id))
+    }),
+    changedObjectIds: [nodeId, ...edgesToDelete]
+  };
+};
+var addEdge = (document, input) => {
+  const edge = normalizeEdge(input, nodeMapOf(document));
+  return {
+    document: normalizeDocument({
+      ...document,
+      edges: [...document.edges, edge]
+    }),
+    changedObjectIds: [edge.id]
+  };
+};
+var updateEdge = (document, edgeId, changes) => {
+  let changed = false;
+  const nodes = nodeMapOf(document);
+  const edges = document.edges.map((edge) => {
+    if (edge.id !== edgeId) {
+      return edge;
+    }
+    changed = true;
+    return normalizeEdge(
+      {
+        ...edge,
+        ...changes,
+        metadata: changes.metadata ?? edge.metadata,
+        route: {
+          ...edge.route,
+          ...changes.route
+        },
+        style: {
+          ...edge.style,
+          ...changes.style
+        }
+      },
+      nodes
+    );
+  });
+  return {
+    document: normalizeDocument({ ...document, edges }),
+    changedObjectIds: changed ? [edgeId] : []
+  };
+};
+var deleteEdge = (document, edgeId) => ({
+  document: normalizeDocument({
+    ...document,
+    edges: document.edges.filter((edge) => edge.id !== edgeId)
+  }),
+  changedObjectIds: [edgeId]
+});
+var replaceDocument = (document, replacement) => ({
+  document: normalizeDocument({
+    ...replacement,
+    id: document.id,
+    revision: document.revision,
+    metadata: {
+      ...document.metadata,
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    }
+  }),
+  changedObjectIds: [
+    replacement.id,
+    ...replacement.nodes.map((node) => node.id),
+    ...replacement.edges.map((edge) => edge.id)
+  ]
+});
+var recalculatePaths = (document, edgeIds, nextRevision) => {
+  const before = edgeMapOf(document);
+  const next = recalculateEdgePaths(document, edgeIds, nextRevision);
+  const changedObjectIds = next.edges.filter((edge) => JSON.stringify(before.get(edge.id)?.route) !== JSON.stringify(edge.route)).map((edge) => edge.id);
+  return {
+    document: normalizeDocument(next),
+    changedObjectIds
+  };
+};
+var applyPatchOperations = (document, operations, nextRevision) => {
+  let current = document;
+  const changedObjectIds = /* @__PURE__ */ new Set();
+  for (const operation of operations) {
+    let result;
+    switch (operation.op) {
+      case "addNode":
+        result = addNode(current, operation.node);
+        break;
+      case "updateNode":
+        result = updateNode(current, operation.nodeId, operation.changes);
+        break;
+      case "deleteNode":
+        result = deleteNode(current, operation.nodeId);
+        break;
+      case "addEdge":
+        result = addEdge(current, operation.edge);
+        break;
+      case "updateEdge":
+        result = updateEdge(current, operation.edgeId, operation.changes);
+        break;
+      case "deleteEdge":
+        result = deleteEdge(current, operation.edgeId);
+        break;
+      case "replaceDocument":
+        result = replaceDocument(current, operation.document);
+        break;
+      case "recalculateEdgePaths":
+        result = recalculatePaths(current, operation.edgeIds, nextRevision);
+        break;
+    }
+    current = result.document;
+    for (const objectId of result.changedObjectIds) {
+      changedObjectIds.add(objectId);
+    }
+  }
+  return {
+    document: current,
+    changedObjectIds: [...changedObjectIds]
+  };
+};
+
+var DEFAULT_INSECURE_DEV_AUTH_TOKEN = "local-dev-token";
+var INSECURE_DEV_ACTOR = {
+  actorId: "local-dev",
+  ownerId: "local-dev",
+  tenantId: "local"
+};
+var authFailure = (code, message) => ({
+  success: false,
+  errors: [error(code, message)]
+});
+var resolveAuthOptions = (options = {}) => ({
+  tokenRegistry: options.tokenRegistry ?? {},
+  allowInsecureDevBypass: options.allowInsecureDevBypass ?? false,
+  insecureDevToken: options.insecureDevToken?.trim() || DEFAULT_INSECURE_DEV_AUTH_TOKEN
+});
+var resolveActorFromAuthorizationHeader = (authorizationHeader, options) => {
+  if (authorizationHeader === void 0) {
+    return authFailure("AUTH_REQUIRED", "Authorization header is required.");
+  }
+  if (Array.isArray(authorizationHeader)) {
+    return authFailure("INVALID_AUTH_TOKEN", "Authorization header must be a single Bearer token.");
+  }
+  const match = authorizationHeader.match(/^Bearer\s+(.+)$/i);
+  if (!match) {
+    return authFailure("INVALID_AUTH_TOKEN", "Authorization header must use Bearer <token>.");
+  }
+  const token = match[1]?.trim();
+  if (!token) {
+    return authFailure("INVALID_AUTH_TOKEN", "Authorization bearer token must not be empty.");
+  }
+  if (options.allowInsecureDevBypass && token === options.insecureDevToken) {
+    return {
+      success: true,
+      actor: { ...INSECURE_DEV_ACTOR }
+    };
+  }
+  const actor = options.tokenRegistry[token];
+  if (!actor) {
+    return authFailure("INVALID_AUTH_TOKEN", "Authorization token is not recognized.");
+  }
+  return {
+    success: true,
+    actor: { ...actor }
+  };
+};
+
+import Database from "better-sqlite3";
+var MIGRATIONS = [
+  `
+    CREATE TABLE IF NOT EXISTS documents (
+      id TEXT PRIMARY KEY,
+      tenant_id TEXT NOT NULL,
+      owner_id TEXT NOT NULL,
+      title TEXT NOT NULL,
+      revision INTEGER NOT NULL,
+      document_json TEXT NOT NULL,
+      created_at TEXT NOT NULL,
+      updated_at TEXT NOT NULL
+    );
+  `,
+  `
+    CREATE INDEX IF NOT EXISTS idx_documents_tenant_updated
+      ON documents (tenant_id, updated_at DESC);
+  `,
+  `
+    CREATE TABLE IF NOT EXISTS document_operation_logs (
+      request_id TEXT PRIMARY KEY,
+      document_id TEXT NOT NULL,
+      tenant_id TEXT NOT NULL,
+      actor_id TEXT NOT NULL,
+      operation_type TEXT NOT NULL,
+      success INTEGER NOT NULL,
+      revision INTEGER,
+      changed_object_ids_json TEXT NOT NULL,
+      errors_json TEXT NOT NULL,
+      warnings_json TEXT NOT NULL,
+      created_at TEXT NOT NULL
+    );
+  `,
+  `
+    CREATE INDEX IF NOT EXISTS idx_document_operation_logs_document
+      ON document_operation_logs (document_id, created_at DESC);
+  `
+];
+var isSqliteConstraintError = (cause) => cause instanceof Error && "code" in cause && typeof cause.code === "string" && cause.code.startsWith("SQLITE_CONSTRAINT");
+var documentParams = (document) => ({
+  id: document.id,
+  tenant_id: document.metadata.tenantId,
+  owner_id: document.metadata.ownerId,
+  title: document.title,
+  revision: document.revision,
+  document_json: JSON.stringify(document),
+  created_at: document.metadata.createdAt,
+  updated_at: document.metadata.updatedAt
+});
+var DocumentAlreadyExistsError = class extends Error {
+  constructor(documentId) {
+    super(`Document already exists: ${documentId}`);
+    this.name = "DocumentAlreadyExistsError";
+  }
+};
+var SQLiteDocumentRepository = class {
+  db;
+  constructor(filename = ":memory:") {
+    this.db = new Database(filename);
+    this.db.pragma("foreign_keys = ON");
+    if (filename !== ":memory:") {
+      this.db.pragma("journal_mode = WAL");
+    }
+    this.db.pragma("busy_timeout = 5000");
+    for (const migration of MIGRATIONS) {
+      this.db.exec(migration);
+    }
+  }
+  close() {
+    this.db.close();
+  }
+  transaction(callback) {
+    return this.db.transaction(callback)();
+  }
+  getDocument(id) {
+    const row = this.db.prepare("SELECT document_json FROM documents WHERE id = ?").get(id);
+    return row ? JSON.parse(row.document_json) : null;
+  }
+  insertDocument(document) {
+    try {
+      this.db.prepare(
+        `
+            INSERT INTO documents (
+              id, tenant_id, owner_id, title, revision, document_json, created_at, updated_at
+            ) VALUES (
+              @id, @tenant_id, @owner_id, @title, @revision, @document_json, @created_at, @updated_at
+            )
+          `
+      ).run(documentParams(document));
+    } catch (cause) {
+      if (isSqliteConstraintError(cause)) {
+        throw new DocumentAlreadyExistsError(document.id);
+      }
+      throw cause;
+    }
+  }
+  updateDocument(document) {
+    const result = this.db.prepare(
+      `
+          UPDATE documents
+          SET
+            tenant_id = @tenant_id,
+            owner_id = @owner_id,
+            title = @title,
+            revision = @revision,
+            document_json = @document_json,
+            created_at = @created_at,
+            updated_at = @updated_at
+          WHERE id = @id
+        `
+    ).run(documentParams(document));
+    if (result.changes === 0) {
+      throw new Error(`Document not found for update: ${document.id}`);
+    }
+  }
+  insertOperationLog(entry) {
+    this.db.prepare(
+      `
+          INSERT INTO document_operation_logs (
+            request_id, document_id, tenant_id, actor_id, operation_type, success, revision,
+            changed_object_ids_json, errors_json, warnings_json, created_at
+          ) VALUES (
+            @request_id, @document_id, @tenant_id, @actor_id, @operation_type, @success, @revision,
+            @changed_object_ids_json, @errors_json, @warnings_json, @created_at
+          )
+        `
+    ).run({
+      request_id: entry.requestId,
+      document_id: entry.documentId,
+      tenant_id: entry.tenantId,
+      actor_id: entry.actorId,
+      operation_type: entry.operationType,
+      success: entry.success ? 1 : 0,
+      revision: entry.revision,
+      changed_object_ids_json: JSON.stringify(entry.changedObjectIds),
+      errors_json: JSON.stringify(entry.errors),
+      warnings_json: JSON.stringify(entry.warnings),
+      created_at: entry.createdAt ?? (/* @__PURE__ */ new Date()).toISOString()
+    });
+  }
+};
+var SqliteDocumentRepository = class extends SQLiteDocumentRepository {
+  insertDocument(document) {
+    super.insertDocument(document);
+  }
+  updateDocument(document) {
+    super.updateDocument(document);
+  }
+  logOperation(entry) {
+    this.insertOperationLog({
+      ...entry,
+      createdAt: (/* @__PURE__ */ new Date()).toISOString()
+    });
+  }
+};
+
+import { DOMParser } from "@xmldom/xmldom";
+var ALLOWED_TAGS = /* @__PURE__ */ new Set([
+  "mxfile",
+  "diagram",
+  "mxGraphModel",
+  "root",
+  "mxCell",
+  "mxGeometry",
+  "Array",
+  "mxPoint"
+]);
+var childElements = (node) => {
+  const elements = [];
+  for (let index = 0; index < node.childNodes.length; index += 1) {
+    const child = node.childNodes.item(index);
+    if (child && child.nodeType === child.ELEMENT_NODE) {
+      elements.push(child);
+    }
+  }
+  return elements;
+};
+var getSingleChild = (node, tagName) => childElements(node).find((child) => child.tagName === tagName);
+var validateDrawioXml = (xml) => {
+  const doc = new DOMParser().parseFromString(xml, "text/xml");
+  const root = doc.documentElement;
+  if (!root) {
+    return { errors: [error("DRAWIO_INVALID_XML", "XML could not be parsed")], warnings: [] };
+  }
+  const errors = [];
+  const visit = (element) => {
+    if (!ALLOWED_TAGS.has(element.tagName)) {
+      errors.push(error("DRAWIO_INVALID_TAG", `Unsupported draw.io tag: ${element.tagName}`));
+    }
+    for (const child of childElements(element)) {
+      visit(child);
+    }
+  };
+  visit(root);
+  let graphModel;
+  if (root.tagName === "mxfile") {
+    const diagram = getSingleChild(root, "diagram");
+    graphModel = diagram ? getSingleChild(diagram, "mxGraphModel") : void 0;
+  } else if (root.tagName === "mxGraphModel") {
+    graphModel = root;
+  } else {
+    errors.push(error("DRAWIO_INVALID_ROOT", "Root element must be mxfile or mxGraphModel"));
+  }
+  if (!graphModel) {
+    errors.push(error("DRAWIO_INVALID_STRUCTURE", "mxGraphModel element is required"));
+    return { errors, warnings: [] };
+  }
+  const graphRoot = getSingleChild(graphModel, "root");
+  if (!graphRoot) {
+    errors.push(error("DRAWIO_INVALID_STRUCTURE", "mxGraphModel must contain root"));
+    return { errors, warnings: [] };
+  }
+  const cells = childElements(graphRoot).filter((element) => element.tagName === "mxCell");
+  const cellIds = new Set(cells.map((cell) => cell.getAttribute("id")).filter(Boolean));
+  if (!cellIds.has("0") || !cells.some((cell) => cell.getAttribute("id") === "1" && cell.getAttribute("parent") === "0")) {
+    errors.push(error("DRAWIO_INVALID_STRUCTURE", "Missing required mxCell skeleton"));
+  }
+  for (const cell of cells) {
+    const cellId = cell.getAttribute("id") ?? void 0;
+    const isEdge = cell.getAttribute("edge") === "1";
+    const parent = cell.getAttribute("parent");
+    if (cellId !== "0" && parent && !cellIds.has(parent)) {
+      errors.push(error("DRAWIO_REFERENCE_MISSING", "mxCell parent reference is invalid", { objectId: cellId }));
+    }
+    if (isEdge) {
+      const source = cell.getAttribute("source");
+      const target = cell.getAttribute("target");
+      if (!source || !target || !parent) {
+        errors.push(error("DRAWIO_INVALID_EDGE", "Edge cells require source, target, and parent", { objectId: cellId }));
+      }
+      if (source && !cellIds.has(source)) {
+        errors.push(error("DRAWIO_REFERENCE_MISSING", "Edge source reference is invalid", { objectId: cellId }));
+      }
+      if (target && !cellIds.has(target)) {
+        errors.push(error("DRAWIO_REFERENCE_MISSING", "Edge target reference is invalid", { objectId: cellId }));
+      }
+      const geometry = childElements(cell).find(
+        (child) => child.tagName === "mxGeometry" && child.getAttribute("relative") === "1" && child.getAttribute("as") === "geometry"
+      );
+      if (!geometry) {
+        errors.push(
+          error("DRAWIO_INVALID_EDGE", 'Edge cells require <mxGeometry relative="1" as="geometry" />', {
+            objectId: cellId
+          })
+        );
+      }
+    }
+  }
+  return { errors, warnings: [] };
+};
+
+import { z } from "zod";
+var idPattern = (prefix) => new RegExp(`^${prefix}[a-z0-9][a-z0-9_-]{2,63}$`);
+var literalUnion = (values) => z.union(values.map((value) => z.literal(value)));
+var hexColorSchema = z.string().regex(/^#[0-9a-fA-F]{6}$/, "Expected six-digit hex color");
+var metadataSchema = z.record(z.string(), z.string());
+var documentMetadataSchema = z.object({
+  createdBy: z.string().min(1).max(64),
+  createdAt: z.string().datetime(),
+  updatedAt: z.string().datetime(),
+  ownerId: z.string().min(1).max(64),
+  tenantId: z.string().min(1).max(64)
+}).strict();
+var canvasSchema = z.object({
+  width: z.number().int().min(320).max(1e4),
+  height: z.number().int().min(240).max(1e4),
+  backgroundColor: hexColorSchema,
+  padding: z.number().int().min(0).max(400),
+  autoExpand: z.boolean()
+}).strict();
+var nodeStyleInputSchema = z.object({
+  preset: z.enum(STYLE_PRESETS).optional(),
+  fillColor: hexColorSchema.optional(),
+  strokeColor: hexColorSchema.optional(),
+  strokeWidth: literalUnion(STROKE_WIDTHS).optional(),
+  dashed: z.boolean().optional(),
+  rounded: z.boolean().optional(),
+  textColor: hexColorSchema.optional(),
+  fontSize: literalUnion(FONT_SIZES).optional(),
+  fontWeight: z.enum(FONT_WEIGHTS).optional(),
+  textAlign: z.enum(TEXT_ALIGNS).optional(),
+  verticalAlign: z.enum(VERTICAL_ALIGNS).optional(),
+  wrap: z.boolean().optional()
+}).strict();
+var edgeStyleInputSchema = z.object({
+  preset: z.enum(STYLE_PRESETS).optional(),
+  strokeColor: hexColorSchema.optional(),
+  strokeWidth: literalUnion(STROKE_WIDTHS).optional(),
+  dashed: z.boolean().optional(),
+  textColor: hexColorSchema.optional(),
+  fontSize: literalUnion(EDGE_FONT_SIZES).optional(),
+  fontWeight: z.enum(FONT_WEIGHTS).optional(),
+  textAlign: z.enum(TEXT_ALIGNS).optional(),
+  verticalAlign: z.enum(VERTICAL_ALIGNS).optional(),
+  wrap: z.boolean().optional(),
+  arrowStart: z.enum(ARROW_TYPES).optional(),
+  arrowEnd: z.enum(ARROW_TYPES).optional()
+}).strict();
+var resolvedNodeStyleSchema = nodeStyleInputSchema.extend({
+  preset: z.enum(STYLE_PRESETS),
+  fillColor: hexColorSchema,
+  strokeColor: hexColorSchema,
+  strokeWidth: literalUnion(STROKE_WIDTHS),
+  dashed: z.boolean(),
+  rounded: z.boolean(),
+  textColor: hexColorSchema,
+  fontSize: literalUnion(FONT_SIZES),
+  fontWeight: z.enum(FONT_WEIGHTS),
+  textAlign: z.enum(TEXT_ALIGNS),
+  verticalAlign: z.enum(VERTICAL_ALIGNS),
+  wrap: z.boolean()
+});
+var resolvedEdgeStyleSchema = edgeStyleInputSchema.extend({
+  preset: z.enum(STYLE_PRESETS),
+  strokeColor: hexColorSchema,
+  strokeWidth: literalUnion(STROKE_WIDTHS),
+  dashed: z.boolean(),
+  textColor: hexColorSchema,
+  fontSize: literalUnion(EDGE_FONT_SIZES),
+  fontWeight: z.enum(FONT_WEIGHTS),
+  textAlign: z.enum(TEXT_ALIGNS),
+  verticalAlign: z.enum(VERTICAL_ALIGNS),
+  wrap: z.boolean(),
+  arrowStart: z.enum(ARROW_TYPES),
+  arrowEnd: z.enum(ARROW_TYPES)
+});
+var pointSchema = z.object({
+  x: z.number().int(),
+  y: z.number().int()
+}).strict();
+var edgeRouteSchema = z.object({
+  points: z.array(pointSchema),
+  sourceAnchor: z.enum(ANCHOR_SIDES),
+  targetAnchor: z.enum(ANCHOR_SIDES),
+  calculatedAtRevision: z.number().int().nullable()
+}).strict();
+var nodeInputSchema = z.object({
+  id: z.string().regex(idPattern(NODE_ID_PREFIX)).optional(),
+  type: z.enum(NODE_TYPES),
+  x: z.number().int().min(0).max(1e5),
+  y: z.number().int().min(0).max(1e5),
+  width: z.number().int().min(16).max(4e3),
+  height: z.number().int().min(16).max(4e3),
+  text: z.string().max(4e3).default(""),
+  style: nodeStyleInputSchema.optional(),
+  zIndex: z.number().int().min(0).max(9999).default(0),
+  metadata: metadataSchema.default({})
+}).strict();
+var nodeChangesSchema = z.object({
+  type: z.enum(NODE_TYPES).optional(),
+  x: z.number().int().min(0).max(1e5).optional(),
+  y: z.number().int().min(0).max(1e5).optional(),
+  width: z.number().int().min(16).max(4e3).optional(),
+  height: z.number().int().min(16).max(4e3).optional(),
+  text: z.string().max(4e3).optional(),
+  style: nodeStyleInputSchema.optional(),
+  zIndex: z.number().int().min(0).max(9999).optional(),
+  metadata: metadataSchema.optional()
+}).strict();
+var edgeInputSchema = z.object({
+  id: z.string().regex(idPattern(EDGE_ID_PREFIX)).optional(),
+  sourceNodeId: z.string().regex(idPattern(NODE_ID_PREFIX)),
+  targetNodeId: z.string().regex(idPattern(NODE_ID_PREFIX)),
+  label: z.string().max(1e3).default(""),
+  pathType: z.enum(EDGE_PATH_TYPES).default("straight"),
+  route: edgeRouteSchema.partial().optional(),
+  style: edgeStyleInputSchema.optional(),
+  metadata: metadataSchema.default({})
+}).strict();
+var edgeChangesSchema = z.object({
+  sourceNodeId: z.string().regex(idPattern(NODE_ID_PREFIX)).optional(),
+  targetNodeId: z.string().regex(idPattern(NODE_ID_PREFIX)).optional(),
+  label: z.string().max(1e3).optional(),
+  pathType: z.enum(EDGE_PATH_TYPES).optional(),
+  route: edgeRouteSchema.partial().optional(),
+  style: edgeStyleInputSchema.optional(),
+  metadata: metadataSchema.optional()
+}).strict();
+var nodeSchema = nodeInputSchema.extend({
+  id: z.string().regex(idPattern(NODE_ID_PREFIX)),
+  style: resolvedNodeStyleSchema
+});
+var edgeSchema = edgeInputSchema.extend({
+  id: z.string().regex(idPattern(EDGE_ID_PREFIX)),
+  route: edgeRouteSchema,
+  style: resolvedEdgeStyleSchema
+});
+var documentSchema = z.object({
+  id: z.string().regex(idPattern(DOCUMENT_ID_PREFIX)),
+  title: z.string().min(1).max(120),
+  revision: z.number().int().min(1),
+  metadata: documentMetadataSchema,
+  canvas: canvasSchema,
+  nodes: z.array(nodeSchema),
+  edges: z.array(edgeSchema)
+}).strict();
+var createDocumentRequestSchema = z.object({
+  id: z.string().regex(idPattern(DOCUMENT_ID_PREFIX)).optional(),
+  title: z.string().min(1).max(120).optional(),
+  canvas: canvasSchema.partial().optional()
+}).strict();
+var baseRevisionSchema = z.object({
+  baseRevision: z.number().int().min(1)
+});
+var addNodeRequestSchema = z.object({
+  baseRevision: z.number().int().min(1),
+  node: nodeInputSchema
+}).strict();
+var updateNodeRequestSchema = z.object({
+  baseRevision: z.number().int().min(1),
+  changes: nodeChangesSchema
+}).strict();
+var addEdgeRequestSchema = z.object({
+  baseRevision: z.number().int().min(1),
+  edge: edgeInputSchema
+}).strict();
+var updateEdgeRequestSchema = z.object({
+  baseRevision: z.number().int().min(1),
+  changes: edgeChangesSchema
+}).strict();
+var cloneDocumentRequestSchema = z.object({
+  title: z.string().min(1).max(120).optional()
+}).strict();
+var patchOperationSchema = z.discriminatedUnion("op", [
+  z.object({ op: z.literal("addNode"), node: nodeInputSchema }).strict(),
+  z.object({ op: z.literal("updateNode"), nodeId: z.string().regex(idPattern(NODE_ID_PREFIX)), changes: nodeChangesSchema }).strict(),
+  z.object({ op: z.literal("deleteNode"), nodeId: z.string().regex(idPattern(NODE_ID_PREFIX)) }).strict(),
+  z.object({ op: z.literal("addEdge"), edge: edgeInputSchema }).strict(),
+  z.object({ op: z.literal("updateEdge"), edgeId: z.string().regex(idPattern(EDGE_ID_PREFIX)), changes: edgeChangesSchema }).strict(),
+  z.object({ op: z.literal("deleteEdge"), edgeId: z.string().regex(idPattern(EDGE_ID_PREFIX)) }).strict(),
+  z.object({ op: z.literal("replaceDocument"), document: documentSchema }).strict(),
+  z.object({
+    op: z.literal("recalculateEdgePaths"),
+    edgeIds: z.array(z.string().regex(idPattern(EDGE_ID_PREFIX))).optional()
+  }).strict()
+]);
+var patchRequestSchema = z.object({
+  baseRevision: z.number().int().min(1),
+  atomic: z.boolean().default(true),
+  dryRun: z.boolean().default(false),
+  operations: z.array(patchOperationSchema).min(1)
+}).strict();
+var validateRequestSchema = z.object({
+  target: z.enum(["document", "drawio"]).default("document"),
+  drawioMode: z.enum(["mxfile", "mxGraphModel"]).default("mxfile")
+}).strict();
+var renderRequestSchema = z.object({
+  includeObjectMetadata: z.boolean().default(true),
+  fitToCanvas: z.boolean().default(true)
+}).strict();
+var exportRequestSchema = z.object({
+  format: z.enum(["drawio", "svg", "png"]).default("drawio"),
+  drawioMode: z.enum(["mxfile", "mxGraphModel"]).default("mxfile"),
+  scale: z.union([z.literal(1), z.literal(2), z.literal(3)]).default(1)
+}).strict();
+var issuePath = (issue) => issue.path.join(".");
+var mapIssue = (issue) => {
+  const path = issuePath(issue);
+  const isStylePath = path.includes("style");
+  if (issue.code === "unrecognized_keys") {
+    return issue.keys.map(
+      (key) => error(
+        isStylePath ? "INVALID_STYLE_KEY" : "INVALID_INPUT",
+        `Unknown property: ${key}`,
+        { fieldPath: path ? `${path}.${key}` : key }
+      )
+    );
+  }
+  if (issue.code === "invalid_value") {
+    if (path.endsWith("type")) {
+      return [error("UNSUPPORTED_NODE_TYPE", "Unsupported node type", { fieldPath: path })];
+    }
+    if (path.endsWith("pathType")) {
+      return [error("UNSUPPORTED_EDGE_PATH", "Unsupported edge path type", { fieldPath: path })];
+    }
+    return [error(isStylePath ? "INVALID_STYLE" : "INVALID_INPUT", issue.message, { fieldPath: path })];
+  }
+  if (issue.code === "invalid_format" && path.toLowerCase().includes("color")) {
+    return [error("INVALID_COLOR", issue.message, { fieldPath: path })];
+  }
+  if (issue.code === "too_small" || issue.code === "too_big") {
+    const code = path.endsWith("x") || path.endsWith("y") || path.endsWith("width") || path.endsWith("height") || path.endsWith("padding") ? "INVALID_GEOMETRY" : isStylePath ? "INVALID_STYLE" : "INVALID_INPUT";
+    return [error(code, issue.message, { fieldPath: path })];
+  }
+  return [
+    error(isStylePath ? "INVALID_STYLE" : "INVALID_INPUT", issue.message, {
+      ...path ? { fieldPath: path } : {}
+    })
+  ];
+};
+var safeParseWithErrors = (schema, input) => {
+  const result = schema.safeParse(input);
+  if (result.success) {
+    return result;
+  }
+  return {
+    success: false,
+    errors: result.error.issues.flatMap(mapIssue)
+  };
+};
+var STYLE_ALLOWLISTS = {
+  node: new Set(NODE_STYLE_KEYS),
+  edge: new Set(EDGE_STYLE_KEYS)
+};
+
+var lineHeightMultiplier = 1.2;
+var nodeOverlapThreshold = 0.25;
+var minimumMeaningfulOverlapArea = 400;
+var lineHeight = (fontSize) => Math.round(fontSize * lineHeightMultiplier);
+var intersectionArea = (a, b) => {
+  const x = Math.max(0, Math.min(a.x + a.width, b.x + b.width) - Math.max(a.x, b.x));
+  const y = Math.max(0, Math.min(a.y + a.height, b.y + b.height) - Math.max(a.y, b.y));
+  return x * y;
+};
+var splitLongWord = (word, maxChars) => {
+  const parts = [];
+  for (let index = 0; index < word.length; index += maxChars) {
+    parts.push(word.slice(index, index + maxChars));
+  }
+  return parts;
+};
+var wrapText = (text, maxWidth, fontSize, wrap) => {
+  const maxChars = Math.max(1, Math.floor(maxWidth / (fontSize * 0.56)));
+  return text.split("\n").flatMap((paragraph) => {
+    if (!wrap) {
+      return [paragraph];
+    }
+    const words = paragraph.split(/\s+/).filter(Boolean);
+    if (words.length === 0) {
+      return [""];
+    }
+    const lines = [];
+    let current = "";
+    for (const word of words) {
+      const candidates = word.length > maxChars ? splitLongWord(word, maxChars) : [word];
+      for (const candidate of candidates) {
+        const next = current ? `${current} ${candidate}` : candidate;
+        if (next.length <= maxChars) {
+          current = next;
+        } else {
+          if (current) {
+            lines.push(current);
+          }
+          current = candidate;
+        }
+      }
+    }
+    if (current) {
+      lines.push(current);
+    }
+    return lines.length > 0 ? lines : [""];
+  });
+};
+var detectTextOverflow = (node) => {
+  if (!node.text.trim()) {
+    return false;
+  }
+  const availableWidth = Math.max(1, node.width - (node.type === "text" ? 0 : 24));
+  const lines = wrapText(node.text, availableWidth, node.style.fontSize, node.style.wrap);
+  const maxLines = Math.max(1, Math.floor((node.height - 12) / lineHeight(node.style.fontSize)));
+  return lines.length > maxLines;
+};
+var dedupeWarnings = (warnings) => {
+  const seen = /* @__PURE__ */ new Set();
+  return warnings.filter((item) => {
+    const key = `${item.code}:${item.objectId ?? ""}:${item.fieldPath ?? ""}`;
+    if (seen.has(key)) {
+      return false;
+    }
+    seen.add(key);
+    return true;
+  });
+};
+var validateNodeWarnings = (document) => {
+  const warnings = [];
+  for (const node of document.nodes) {
+    if (node.x < 0 || node.y < 0 || node.x + node.width > document.canvas.width || node.y + node.height > document.canvas.height) {
+      warnings.push(
+        warning("OBJECT_OUTSIDE_CANVAS", "Object exceeds canvas bounds", { objectId: node.id })
+      );
+    }
+    if (detectTextOverflow(node)) {
+      warnings.push(warning("TEXT_OVERFLOW", "Text may overflow the node bounds", { objectId: node.id }));
+    }
+  }
+  for (let index = 0; index < document.nodes.length; index += 1) {
+    for (let otherIndex = index + 1; otherIndex < document.nodes.length; otherIndex += 1) {
+      const left = document.nodes[index];
+      const right = document.nodes[otherIndex];
+      if (!left || !right) {
+        continue;
+      }
+      const overlapArea = intersectionArea(left, right);
+      if (overlapArea === 0) {
+        continue;
+      }
+      if (overlapArea < minimumMeaningfulOverlapArea) {
+        continue;
+      }
+      const smallerArea = Math.min(left.width * left.height, right.width * right.height);
+      if (smallerArea > 0 && overlapArea / smallerArea >= nodeOverlapThreshold) {
+        warnings.push(
+          warning("HIGH_NODE_OVERLAP", "Nodes overlap significantly", {
+            objectId: [left.id, right.id].sort().join(",")
+          })
+        );
+      }
+    }
+  }
+  return warnings;
+};
+var validateEdgeWarnings = (edges, nodeIds) => edges.flatMap(
+  (edge) => edge.pathType === "orthogonal" && edge.route.points.length === 0 && nodeIds.has(edge.sourceNodeId) && nodeIds.has(edge.targetNodeId) ? [warning("ORTHOGONAL_ROUTE_MISSING", "Orthogonal route has not been calculated", { objectId: edge.id })] : []
+);
+var validateDocumentSemantics = (document) => {
+  const errors = [];
+  const seenIds = /* @__PURE__ */ new Set();
+  const nodeIds = new Set(document.nodes.map((node) => node.id));
+  const allIds = [
+    document.id,
+    ...document.nodes.map((node) => node.id),
+    ...document.edges.map((edge) => edge.id)
+  ];
+  for (const id of allIds) {
+    if (seenIds.has(id)) {
+      errors.push(error("DUPLICATE_OBJECT_ID", "Object ID must be unique across the document", { objectId: id }));
+    }
+    seenIds.add(id);
+  }
+  for (const node of document.nodes) {
+    if (node.width <= 0 || node.height <= 0) {
+      errors.push(error("INVALID_GEOMETRY", "Node width and height must be positive", { objectId: node.id }));
+    }
+  }
+  for (const edge of document.edges) {
+    if (!nodeIds.has(edge.sourceNodeId) || !nodeIds.has(edge.targetNodeId)) {
+      errors.push(
+        error("EDGE_ENDPOINT_MISSING", "Edge endpoints must reference existing nodes", { objectId: edge.id })
+      );
+    }
+  }
+  return {
+    errors,
+    warnings: dedupeWarnings([...validateNodeWarnings(document), ...validateEdgeWarnings(document.edges, nodeIds)])
+  };
+};
+
+var statusForErrors = (errors) => {
+  if (errors.some((item) => item.code === "AUTH_REQUIRED" || item.code === "INVALID_AUTH_TOKEN")) {
+    return 401;
+  }
+  if (errors.some((item) => item.code === "REVISION_CONFLICT" || item.code === "DOCUMENT_ALREADY_EXISTS")) {
+    return 409;
+  }
+  if (errors.some((item) => item.code.endsWith("_NOT_FOUND"))) {
+    return 404;
+  }
+  if (errors.some((item) => item.code === "FORBIDDEN")) {
+    return 403;
+  }
+  return 400;
+};
+var sendEnvelope = (reply, envelope) => envelope.success ? reply.code(200).send(envelope) : reply.code(statusForErrors(envelope.errors)).send(envelope);
+var failureEnvelope = (requestId, errors) => ({
+  requestId,
+  success: false,
+  revision: null,
+  errors,
+  warnings: [],
+  changedObjectIds: []
+});
+var parseOrReply = (reply, schema, body, requestId) => {
+  const parsed = safeParseWithErrors(schema, body);
+  if (parsed.success) {
+    return parsed.data;
+  }
+  reply.code(statusForErrors(parsed.errors)).send(failureEnvelope(requestId, parsed.errors));
+  return void 0;
+};
+var actorFromRequest = (request) => request.drowaiActor;
+var registerDocumentRoutes = (app, { documentService, auth }) => {
+  app.addHook("preHandler", async (request, reply) => {
+    const resolved = resolveActorFromAuthorizationHeader(request.headers.authorization, auth);
+    if (!resolved.success) {
+      return reply.code(statusForErrors(resolved.errors)).send(failureEnvelope(request.id, resolved.errors));
+    }
+    request.drowaiActor = resolved.actor;
+    return void 0;
+  });
+  app.post("/documents", async (request, reply) => {
+    const parsed = parseOrReply(reply, createDocumentRequestSchema, request.body, request.id);
+    if (!parsed) {
+      return;
+    }
+    return sendEnvelope(reply, documentService.createDocument(request.id, actorFromRequest(request), parsed));
+  });
+  app.get("/documents/:id", async (request, reply) => {
+    const params = request.params;
+    return sendEnvelope(reply, documentService.getDocument(request.id, actorFromRequest(request), params.id));
+  });
+  app.post("/documents/:id/clone", async (request, reply) => {
+    const params = request.params;
+    const parsed = parseOrReply(reply, cloneDocumentRequestSchema, request.body ?? {}, request.id);
+    if (!parsed) {
+      return;
+    }
+    return sendEnvelope(reply, documentService.cloneDocument(request.id, actorFromRequest(request), params.id, parsed.title));
+  });
+  app.post("/documents/:id/nodes", async (request, reply) => {
+    const params = request.params;
+    const parsed = parseOrReply(reply, addNodeRequestSchema, request.body, request.id);
+    if (!parsed) {
+      return;
+    }
+    return sendEnvelope(
+      reply,
+      documentService.addNode(request.id, actorFromRequest(request), params.id, parsed.baseRevision, parsed.node)
+    );
+  });
+  app.patch("/documents/:id/nodes/:nodeId", async (request, reply) => {
+    const params = request.params;
+    const parsed = parseOrReply(reply, updateNodeRequestSchema, request.body, request.id);
+    if (!parsed) {
+      return;
+    }
+    return sendEnvelope(
+      reply,
+      documentService.updateNode(
+        request.id,
+        actorFromRequest(request),
+        params.id,
+        parsed.baseRevision,
+        params.nodeId,
+        parsed.changes
+      )
+    );
+  });
+  app.delete("/documents/:id/nodes/:nodeId", async (request, reply) => {
+    const params = request.params;
+    const parsed = parseOrReply(reply, baseRevisionSchema, request.body, request.id);
+    if (!parsed) {
+      return;
+    }
+    return sendEnvelope(
+      reply,
+      documentService.deleteNode(
+        request.id,
+        actorFromRequest(request),
+        params.id,
+        parsed.baseRevision,
+        params.nodeId
+      )
+    );
+  });
+  app.post("/documents/:id/edges", async (request, reply) => {
+    const params = request.params;
+    const parsed = parseOrReply(reply, addEdgeRequestSchema, request.body, request.id);
+    if (!parsed) {
+      return;
+    }
+    return sendEnvelope(
+      reply,
+      documentService.addEdge(request.id, actorFromRequest(request), params.id, parsed.baseRevision, parsed.edge)
+    );
+  });
+  app.patch("/documents/:id/edges/:edgeId", async (request, reply) => {
+    const params = request.params;
+    const parsed = parseOrReply(reply, updateEdgeRequestSchema, request.body, request.id);
+    if (!parsed) {
+      return;
+    }
+    return sendEnvelope(
+      reply,
+      documentService.updateEdge(
+        request.id,
+        actorFromRequest(request),
+        params.id,
+        parsed.baseRevision,
+        params.edgeId,
+        parsed.changes
+      )
+    );
+  });
+  app.delete("/documents/:id/edges/:edgeId", async (request, reply) => {
+    const params = request.params;
+    const parsed = parseOrReply(reply, baseRevisionSchema, request.body, request.id);
+    if (!parsed) {
+      return;
+    }
+    return sendEnvelope(
+      reply,
+      documentService.deleteEdge(
+        request.id,
+        actorFromRequest(request),
+        params.id,
+        parsed.baseRevision,
+        params.edgeId
+      )
+    );
+  });
+  app.post("/documents/:id/patch", async (request, reply) => {
+    const params = request.params;
+    const parsed = parseOrReply(reply, patchRequestSchema, request.body, request.id);
+    if (!parsed) {
+      return;
+    }
+    return sendEnvelope(
+      reply,
+      documentService.patchDocument(
+        request.id,
+        actorFromRequest(request),
+        params.id,
+        parsed.baseRevision,
+        parsed.operations,
+        parsed.atomic,
+        parsed.dryRun
+      )
+    );
+  });
+  app.post("/documents/:id/validate", async (request, reply) => {
+    const params = request.params;
+    const parsed = parseOrReply(reply, validateRequestSchema, request.body ?? {}, request.id);
+    if (!parsed) {
+      return;
+    }
+    return sendEnvelope(
+      reply,
+      documentService.validateDocument(
+        request.id,
+        actorFromRequest(request),
+        params.id,
+        parsed.target,
+        parsed.drawioMode
+      )
+    );
+  });
+  app.post("/documents/:id/render", async (request, reply) => {
+    const params = request.params;
+    const parsed = parseOrReply(reply, renderRequestSchema, request.body ?? {}, request.id);
+    if (!parsed) {
+      return;
+    }
+    return sendEnvelope(reply, documentService.renderDocument(request.id, actorFromRequest(request), params.id));
+  });
+  app.post("/documents/:id/export", async (request, reply) => {
+    const params = request.params;
+    const parsed = parseOrReply(reply, exportRequestSchema, request.body ?? {}, request.id);
+    if (!parsed) {
+      return;
+    }
+    return sendEnvelope(
+      reply,
+      documentService.exportDocument(
+        request.id,
+        actorFromRequest(request),
+        params.id,
+        parsed.format,
+        parsed.drawioMode,
+        parsed.scale
+      )
+    );
+  });
+};
+
+import { create } from "xmlbuilder2";
+var DEFAULT_OPTIONS = {
+  mode: "mxfile",
+  modifiedAt: (/* @__PURE__ */ new Date()).toISOString(),
+  host: "drowai",
+  agent: "DrowAI"
+};
+var serializeStyle = (tokens) => tokens.join(";") + ";";
+var nodeStyle = (node) => {
+  const shapeTokens = node.type === "rectangle" ? ["shape=rectangle", "rounded=0", "whiteSpace=wrap", "html=1"] : node.type === "roundedRectangle" ? ["shape=rectangle", "rounded=1", "whiteSpace=wrap", "html=1"] : node.type === "ellipse" ? ["ellipse", "whiteSpace=wrap", "html=1"] : node.type === "diamond" ? ["rhombus", "whiteSpace=wrap", "html=1"] : ["text", "whiteSpace=wrap", "html=1", "strokeColor=none", "fillColor=none"];
+  const commonTokens = node.type === "text" ? [
+    `fontColor=${node.style.textColor}`,
+    `fontSize=${node.style.fontSize}`,
+    `fontStyle=${node.style.fontWeight === "bold" ? 1 : 0}`,
+    `align=${node.style.textAlign}`,
+    `verticalAlign=${node.style.verticalAlign}`
+  ] : [
+    `fillColor=${node.style.fillColor}`,
+    `strokeColor=${node.style.strokeColor}`,
+    `strokeWidth=${node.style.strokeWidth}`,
+    `dashed=${node.style.dashed ? 1 : 0}`,
+    `fontColor=${node.style.textColor}`,
+    `fontSize=${node.style.fontSize}`,
+    `fontStyle=${node.style.fontWeight === "bold" ? 1 : 0}`,
+    `align=${node.style.textAlign}`,
+    `verticalAlign=${node.style.verticalAlign}`
+  ];
+  return serializeStyle([...shapeTokens, ...commonTokens]);
+};
+var edgeStyle = (edge) => {
+  const baseTokens = edge.pathType === "orthogonal" ? ["edgeStyle=orthogonalEdgeStyle", "rounded=0", "jettySize=auto", "html=1"] : ["edgeStyle=none", "rounded=0", "html=1"];
+  return serializeStyle([
+    ...baseTokens,
+    `strokeColor=${edge.style.strokeColor}`,
+    `strokeWidth=${edge.style.strokeWidth}`,
+    `dashed=${edge.style.dashed ? 1 : 0}`,
+    `fontColor=${edge.style.textColor}`,
+    `fontSize=${edge.style.fontSize}`,
+    `fontStyle=${edge.style.fontWeight === "bold" ? 1 : 0}`,
+    `align=${edge.style.textAlign}`,
+    `verticalAlign=${edge.style.verticalAlign}`,
+    `startArrow=${edge.style.arrowStart}`,
+    `endArrow=${edge.style.arrowEnd}`
+  ]);
+};
+var appendNodeCell = (root, node) => {
+  root.ele("mxCell", {
+    id: node.id,
+    value: node.text,
+    style: nodeStyle(node),
+    vertex: "1",
+    parent: "1"
+  }).ele("mxGeometry", {
+    x: String(node.x),
+    y: String(node.y),
+    width: String(node.width),
+    height: String(node.height),
+    as: "geometry"
+  }).up().up();
+};
+var appendEdgeCell = (root, edge) => {
+  const cell = root.ele("mxCell", {
+    id: edge.id,
+    value: edge.label,
+    style: edgeStyle(edge),
+    edge: "1",
+    parent: "1",
+    source: edge.sourceNodeId,
+    target: edge.targetNodeId
+  });
+  const geometry = cell.ele("mxGeometry", {
+    relative: "1",
+    as: "geometry"
+  });
+  if (edge.route.points.length > 0) {
+    const points = geometry.ele("Array", { as: "points" });
+    for (const point of edge.route.points) {
+      points.ele("mxPoint", {
+        x: String(point.x),
+        y: String(point.y)
+      });
+    }
+  }
+};
+var buildGraphModel = (document) => {
+  const graphModel = create({ version: "1.0", encoding: "UTF-8" }).ele("mxGraphModel", {
+    dx: String(document.canvas.width),
+    dy: String(document.canvas.height),
+    grid: "1",
+    gridSize: "10",
+    page: "1",
+    pageWidth: String(document.canvas.width),
+    pageHeight: String(document.canvas.height)
+  });
+  const root = graphModel.ele("root");
+  root.ele("mxCell", { id: "0" });
+  root.ele("mxCell", { id: "1", parent: "0" });
+  for (const node of document.nodes) {
+    appendNodeCell(root, node);
+  }
+  for (const edge of document.edges) {
+    appendEdgeCell(root, edge);
+  }
+  return graphModel;
+};
+var exportDrawioDocument = (document, options = {}) => {
+  const resolved = {
+    ...DEFAULT_OPTIONS,
+    ...options,
+    modifiedAt: options.modifiedAt ?? document.metadata.updatedAt
+  };
+  const graphModel = buildGraphModel(document);
+  if (resolved.mode === "mxGraphModel") {
+    return graphModel.end({ prettyPrint: false });
+  }
+  const mxfile = create({ version: "1.0", encoding: "UTF-8" }).ele("mxfile", {
+    host: resolved.host,
+    modified: resolved.modifiedAt,
+    agent: resolved.agent
+  });
+  mxfile.ele("diagram", {
+    id: document.id,
+    name: "Page-1"
+  }).import(graphModel);
+  return mxfile.end({ prettyPrint: false });
+};
+
+import { createHash } from "node:crypto";
+
+var xmlEscape = (value) => value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;").replaceAll("'", "&apos;");
+var lineHeight2 = (fontSize) => Math.round(fontSize * 1.2);
+var splitLongWord2 = (word, maxChars) => {
+  const parts = [];
+  for (let index = 0; index < word.length; index += maxChars) {
+    parts.push(word.slice(index, index + maxChars));
+  }
+  return parts;
+};
+var wrapText2 = (text, maxWidth, fontSize, wrap) => {
+  const maxChars = Math.max(1, Math.floor(maxWidth / (fontSize * 0.56)));
+  return text.split("\n").flatMap((paragraph) => {
+    if (!wrap) {
+      return [paragraph];
+    }
+    const words = paragraph.split(/\s+/).filter(Boolean);
+    if (words.length === 0) {
+      return [""];
+    }
+    const lines = [];
+    let current = "";
+    for (const word of words) {
+      const candidates = word.length > maxChars ? splitLongWord2(word, maxChars) : [word];
+      for (const candidate of candidates) {
+        const next = current ? `${current} ${candidate}` : candidate;
+        if (next.length <= maxChars) {
+          current = next;
+        } else {
+          if (current) {
+            lines.push(current);
+          }
+          current = candidate;
+        }
+      }
+    }
+    if (current) {
+      lines.push(current);
+    }
+    return lines.length > 0 ? lines : [""];
+  });
+};
+var alignText = (x, width, align) => {
+  if (align === "left") {
+    return { x: x + 12, anchor: "start" };
+  }
+  if (align === "right") {
+    return { x: x + width - 12, anchor: "end" };
+  }
+  return { x: x + Math.round(width / 2), anchor: "middle" };
+};
+var computeTextStartY = (y, height, lineCount, fontSize, verticalAlign) => {
+  const totalHeight = lineCount * lineHeight2(fontSize);
+  if (verticalAlign === "top") {
+    return y + fontSize + 8;
+  }
+  if (verticalAlign === "bottom") {
+    return y + height - totalHeight + fontSize - 8;
+  }
+  return y + Math.round((height - totalHeight) / 2) + fontSize;
+};
+var renderTextBlock = (node, warnings, isTextOnly = false) => {
+  const lines = wrapText2(node.text, node.width - (isTextOnly ? 0 : 24), node.style.fontSize, node.style.wrap);
+  const maxLines = Math.max(1, Math.floor((node.height - 12) / lineHeight2(node.style.fontSize)));
+  const renderedLines = lines.slice(0, maxLines);
+  if (lines.length > maxLines) {
+    warnings.push(
+      warning("TEXT_OVERFLOW", "Text rendering truncated to fit node bounds", { objectId: node.id })
+    );
+  }
+  const { x, anchor } = alignText(node.x, node.width, node.style.textAlign);
+  const startY = computeTextStartY(
+    node.y,
+    node.height,
+    renderedLines.length,
+    node.style.fontSize,
+    node.style.verticalAlign
+  );
+  const tspans = renderedLines.map(
+    (line, index) => `<tspan x="${x}" dy="${index === 0 ? 0 : lineHeight2(node.style.fontSize)}">${xmlEscape(line)}</tspan>`
+  ).join("");
+  return `<text fill="${node.style.textColor}" font-size="${node.style.fontSize}" font-weight="${node.style.fontWeight}" text-anchor="${anchor}" dominant-baseline="alphabetic">${tspans}</text>`;
+};
+var renderNodeShape = (node) => {
+  const common = `fill="${node.type === "text" ? "none" : node.style.fillColor}" stroke="${node.type === "text" ? "none" : node.style.strokeColor}" stroke-width="${node.type === "text" ? 0 : node.style.strokeWidth}"${node.style.dashed ? ` stroke-dasharray="${node.style.strokeWidth * 4} ${node.style.strokeWidth * 2}"` : ""}`;
+  switch (node.type) {
+    case "rectangle":
+      return `<rect x="${node.x}" y="${node.y}" width="${node.width}" height="${node.height}" rx="0" ry="0" ${common}/>`;
+    case "roundedRectangle":
+      return `<rect x="${node.x}" y="${node.y}" width="${node.width}" height="${node.height}" rx="12" ry="12" ${common}/>`;
+    case "ellipse":
+      return `<ellipse cx="${node.x + Math.round(node.width / 2)}" cy="${node.y + Math.round(node.height / 2)}" rx="${Math.round(node.width / 2)}" ry="${Math.round(node.height / 2)}" ${common}/>`;
+    case "diamond": {
+      const points = [
+        `${node.x + Math.round(node.width / 2)},${node.y}`,
+        `${node.x + node.width},${node.y + Math.round(node.height / 2)}`,
+        `${node.x + Math.round(node.width / 2)},${node.y + node.height}`,
+        `${node.x},${node.y + Math.round(node.height / 2)}`
+      ].join(" ");
+      return `<polygon points="${points}" ${common}/>`;
+    }
+    case "text":
+      return "";
+  }
+};
+var polylineMidpoint = (points) => {
+  if (points.length === 0) {
+    return { x: 0, y: 0 };
+  }
+  const lengths = [];
+  let total = 0;
+  for (let index = 1; index < points.length; index += 1) {
+    const current = points[index];
+    const previous = points[index - 1];
+    const length = Math.hypot(current.x - previous.x, current.y - previous.y);
+    lengths.push(length);
+    total += length;
+  }
+  const target = total / 2;
+  let walked = 0;
+  for (let index = 1; index < points.length; index += 1) {
+    const segmentLength = lengths[index - 1] ?? 0;
+    const current = points[index];
+    const previous = points[index - 1];
+    if (walked + segmentLength >= target) {
+      const ratio = segmentLength === 0 ? 0 : (target - walked) / segmentLength;
+      return {
+        x: Math.round(previous.x + (current.x - previous.x) * ratio),
+        y: Math.round(previous.y + (current.y - previous.y) * ratio)
+      };
+    }
+    walked += segmentLength;
+  }
+  return points.at(-1) ?? points[0];
+};
+var renderEdge = (edge, document, warnings) => {
+  const sourceNode = document.nodes.find((node) => node.id === edge.sourceNodeId);
+  const targetNode = document.nodes.find((node) => node.id === edge.targetNodeId);
+  if (!sourceNode || !targetNode) {
+    return "";
+  }
+  const source = getAnchorPoint(sourceNode, edge.route.sourceAnchor);
+  const target = getAnchorPoint(targetNode, edge.route.targetAnchor);
+  const points = [source, ...edge.route.points, target];
+  const stroke = `stroke="${edge.style.strokeColor}" stroke-width="${edge.style.strokeWidth}" fill="none"${edge.style.dashed ? ` stroke-dasharray="${edge.style.strokeWidth * 4} ${edge.style.strokeWidth * 2}"` : ""}`;
+  const markerStart = edge.style.arrowStart !== "none" ? ` marker-start="url(#arrow-${edge.style.arrowStart})"` : "";
+  const markerEnd = edge.style.arrowEnd !== "none" ? ` marker-end="url(#arrow-${edge.style.arrowEnd})"` : "";
+  if (edge.pathType === "orthogonal" && edge.route.points.length === 0) {
+    warnings.push(
+      warning("ORTHOGONAL_ROUTE_MISSING", "Orthogonal edge route has not been calculated", { objectId: edge.id })
+    );
+  }
+  const shape = edge.pathType === "straight" ? `<line x1="${source.x}" y1="${source.y}" x2="${target.x}" y2="${target.y}" ${stroke}${markerStart}${markerEnd}/>` : `<polyline points="${points.map((point) => `${point.x},${point.y}`).join(" ")}" ${stroke}${markerStart}${markerEnd}/>`;
+  const midpoint = polylineMidpoint(points);
+  const label = edge.label ? `<text x="${midpoint.x}" y="${midpoint.y - 6}" fill="${edge.style.textColor}" font-size="${edge.style.fontSize}" font-weight="${edge.style.fontWeight}" text-anchor="middle">${xmlEscape(edge.label)}</text>` : "";
+  return `<g data-object-id="${edge.id}" data-object-type="edge" data-z-index="0">${shape}${label}</g>`;
+};
+var renderNode = (node, warnings) => {
+  const shape = renderNodeShape(node);
+  const text = node.text ? renderTextBlock(node, warnings, node.type === "text") : "";
+  return `<g data-object-id="${node.id}" data-object-type="${node.type}" data-z-index="${node.zIndex}">${shape}${text}</g>`;
+};
+var markers = () => `
+  <defs>
+    <marker id="arrow-classic" viewBox="0 0 10 10" refX="9" refY="5" markerWidth="7" markerHeight="7" orient="auto-start-reverse">
+      <path d="M 0 0 L 10 5 L 0 10 z" fill="context-stroke"/>
+    </marker>
+    <marker id="arrow-block" viewBox="0 0 10 10" refX="9" refY="5" markerWidth="8" markerHeight="8" orient="auto-start-reverse">
+      <path d="M 0 0 L 10 5 L 0 10 z" fill="context-stroke"/>
+    </marker>
+    <marker id="arrow-open" viewBox="0 0 10 10" refX="9" refY="5" markerWidth="8" markerHeight="8" orient="auto-start-reverse">
+      <path d="M 1 1 L 9 5 L 1 9" fill="none" stroke="context-stroke" stroke-width="1.5"/>
+    </marker>
+  </defs>
+`;
+var renderDocumentAsSvg = (document) => {
+  const warnings = [];
+  const viewBox = `0 0 ${document.canvas.width} ${document.canvas.height}`;
+  const nodeMarkup = document.nodes.map((node) => renderNode(node, warnings)).join("");
+  const edgeMarkup = document.edges.map((edge) => renderEdge(edge, document, warnings)).join("");
+  const svg = `<svg xmlns="http://www.w3.org/2000/svg" viewBox="${viewBox}" width="${document.canvas.width}" height="${document.canvas.height}">${markers()}<rect x="0" y="0" width="${document.canvas.width}" height="${document.canvas.height}" fill="${document.canvas.backgroundColor}"/>${edgeMarkup}${nodeMarkup}</svg>`;
+  return {
+    svg,
+    viewBox,
+    warnings
+  };
+};
+var renderSvgDocument = renderDocumentAsSvg;
+
+import { Resvg } from "@resvg/resvg-js";
+var PNG_EXPORT_SCALES = [1, 2, 3];
+var exportDocumentToPng = (document, scale = 1) => {
+  if (!PNG_EXPORT_SCALES.includes(scale)) {
+    throw new RangeError(`PNG export scale must be one of ${PNG_EXPORT_SCALES.join(", ")}`);
+  }
+  const rendered = renderSvgDocument(document);
+  const resvg = new Resvg(rendered.svg, {
+    background: document.canvas.backgroundColor,
+    fitTo: {
+      mode: "zoom",
+      value: scale
+    }
+  });
+  const png = resvg.render();
+  const content = png.asPng();
+  return {
+    content,
+    width: document.canvas.width * scale,
+    height: document.canvas.height * scale,
+    scale,
+    svg: rendered.svg,
+    warnings: rendered.warnings,
+    sha256: createHash("sha256").update(content).digest("hex")
+  };
+};
+
+var dedupeIssues = (items) => {
+  const seen = /* @__PURE__ */ new Set();
+  return items.filter((item) => {
+    const key = JSON.stringify(item);
+    if (seen.has(key)) {
+      return false;
+    }
+    seen.add(key);
+    return true;
+  });
+};
+var mergeWarnings = (...groups) => {
+  const seen = /* @__PURE__ */ new Set();
+  return groups.flat().filter((item) => {
+    const key = `${item.code}:${item.objectId ?? ""}:${item.fieldPath ?? ""}:${item.severity}`;
+    if (seen.has(key)) {
+      return false;
+    }
+    seen.add(key);
+    return true;
+  });
+};
+var validateNormalizedDocument = (document) => {
+  const parsed = safeParseWithErrors(documentSchema, document);
+  const semantic = validateDocumentSemantics(document);
+  return {
+    errors: dedupeIssues(parsed.success ? semantic.errors : [...parsed.errors, ...semantic.errors]),
+    warnings: dedupeIssues(semantic.warnings)
+  };
+};
+var applyActorAccess = (document, actor) => {
+  if (document.metadata.tenantId !== actor.tenantId || document.metadata.ownerId !== actor.ownerId) {
+    return [error("FORBIDDEN", "Document belongs to a different owner or tenant")];
+  }
+  return [];
+};
+var cloneDocumentWithFreshIds = (document, actor, title) => {
+  const nodeIdMap = new Map(document.nodes.map((node) => [node.id, generateNodeId()]));
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+  return normalizeDocument({
+    ...document,
+    id: generateDocumentId(),
+    title: title ?? `${document.title} Copy`,
+    revision: 1,
+    metadata: {
+      ...document.metadata,
+      createdBy: actor.actorId,
+      createdAt: timestamp,
+      updatedAt: timestamp,
+      ownerId: actor.ownerId,
+      tenantId: actor.tenantId
+    },
+    nodes: document.nodes.map((node) => ({
+      ...node,
+      id: nodeIdMap.get(node.id) ?? generateNodeId()
+    })),
+    edges: document.edges.map((edge) => ({
+      ...edge,
+      id: generateEdgeId(),
+      sourceNodeId: nodeIdMap.get(edge.sourceNodeId) ?? edge.sourceNodeId,
+      targetNodeId: nodeIdMap.get(edge.targetNodeId) ?? edge.targetNodeId
+    }))
+  });
+};
+var DocumentService = class {
+  constructor(repository) {
+    this.repository = repository;
+  }
+  repository;
+  logOperation(params) {
+    this.repository.logOperation({
+      requestId: params.requestId,
+      documentId: params.documentId,
+      tenantId: params.actor.tenantId,
+      actorId: params.actor.actorId,
+      operationType: params.operationType,
+      success: params.success,
+      revision: params.revision,
+      changedObjectIds: params.changedObjectIds,
+      errors: params.errors,
+      warnings: params.warnings
+    });
+  }
+  success(requestId, document, changedObjectIds, warnings = [], data) {
+    return {
+      requestId,
+      success: true,
+      revision: document.revision,
+      errors: [],
+      warnings,
+      changedObjectIds,
+      normalizedDocument: document,
+      ...data !== void 0 ? { data } : {}
+    };
+  }
+  failure(requestId, errors, warnings = [], document) {
+    return {
+      requestId,
+      success: false,
+      revision: document?.revision ?? null,
+      errors,
+      warnings,
+      changedObjectIds: [],
+      ...document ? { normalizedDocument: document } : {}
+    };
+  }
+  loadDocument(documentId, actor) {
+    const document = this.repository.getDocument(documentId);
+    if (!document) {
+      return { errors: [error("DOCUMENT_NOT_FOUND", "Document not found", { objectId: documentId })] };
+    }
+    const accessErrors = applyActorAccess(document, actor);
+    if (accessErrors.length > 0) {
+      return { errors: accessErrors };
+    }
+    return { document, errors: [] };
+  }
+  ensureRevision(document, baseRevision) {
+    return document.revision === baseRevision ? [] : [
+      error("REVISION_CONFLICT", "Document revision does not match baseRevision", {
+        objectId: document.id
+      })
+    ];
+  }
+  persistDocument(requestId, actor, operationType, document, changedObjectIds, warnings, isCreate = false) {
+    this.repository.transaction(() => {
+      if (isCreate) {
+        this.repository.insertDocument(document);
+      } else {
+        this.repository.updateDocument(document);
+      }
+      this.logOperation({
+        requestId,
+        actor,
+        operationType,
+        documentId: document.id,
+        success: true,
+        revision: document.revision,
+        changedObjectIds,
+        errors: [],
+        warnings
+      });
+    });
+    return this.success(requestId, document, changedObjectIds, warnings);
+  }
+  createDocument(requestId, actor, input) {
+    const document = createDocument(input, actor);
+    const validation = validateNormalizedDocument(document);
+    if (validation.errors.length > 0) {
+      return this.failure(requestId, validation.errors, validation.warnings, document);
+    }
+    try {
+      return this.persistDocument(requestId, actor, "createDocument", document, [document.id], validation.warnings, true);
+    } catch (cause) {
+      if (cause instanceof DocumentAlreadyExistsError) {
+        const errors = [error("DOCUMENT_ALREADY_EXISTS", "Document already exists", { objectId: document.id })];
+        this.logOperation({
+          requestId,
+          actor,
+          operationType: "createDocument",
+          documentId: document.id,
+          success: false,
+          revision: null,
+          changedObjectIds: [],
+          errors,
+          warnings: []
+        });
+        return this.failure(requestId, errors);
+      }
+      throw cause;
+    }
+  }
+  getDocument(requestId, actor, documentId) {
+    const loaded = this.loadDocument(documentId, actor);
+    if (loaded.errors.length > 0 || !loaded.document) {
+      return this.failure(requestId, loaded.errors);
+    }
+    return this.success(requestId, loaded.document, []);
+  }
+  cloneDocument(requestId, actor, documentId, title) {
+    const loaded = this.loadDocument(documentId, actor);
+    if (loaded.errors.length > 0 || !loaded.document) {
+      return this.failure(requestId, loaded.errors);
+    }
+    const cloned = cloneDocumentWithFreshIds(loaded.document, actor, title);
+    return this.persistDocument(requestId, actor, "cloneDocument", cloned, [cloned.id], [], true);
+  }
+  updateWithMutation(requestId, actor, documentId, baseRevision, operationType, mutate) {
+    const loaded = this.loadDocument(documentId, actor);
+    if (loaded.errors.length > 0 || !loaded.document) {
+      return this.failure(requestId, loaded.errors);
+    }
+    const revisionErrors = this.ensureRevision(loaded.document, baseRevision);
+    if (revisionErrors.length > 0) {
+      return this.failure(requestId, revisionErrors, [], loaded.document);
+    }
+    const result = mutate(loaded.document);
+    if (result.errors && result.errors.length > 0) {
+      return this.failure(requestId, result.errors, [], loaded.document);
+    }
+    const nextDocument = withRevision(result.document, loaded.document.revision + 1);
+    const validation = validateNormalizedDocument(nextDocument);
+    if (validation.errors.length > 0) {
+      this.logOperation({
+        requestId,
+        actor,
+        operationType,
+        documentId,
+        success: false,
+        revision: loaded.document.revision,
+        changedObjectIds: result.changedObjectIds,
+        errors: validation.errors,
+        warnings: validation.warnings
+      });
+      return this.failure(requestId, validation.errors, validation.warnings, loaded.document);
+    }
+    return this.persistDocument(
+      requestId,
+      actor,
+      operationType,
+      nextDocument,
+      result.changedObjectIds,
+      validation.warnings
+    );
+  }
+  addNode(requestId, actor, documentId, baseRevision, node) {
+    return this.updateWithMutation(
+      requestId,
+      actor,
+      documentId,
+      baseRevision,
+      "addNode",
+      (document) => addNode(document, node)
+    );
+  }
+  updateNode(requestId, actor, documentId, baseRevision, nodeId, changes) {
+    return this.updateWithMutation(requestId, actor, documentId, baseRevision, "updateNode", (document) => {
+      if (!document.nodes.some((node) => node.id === nodeId)) {
+        return {
+          document,
+          changedObjectIds: [],
+          errors: [error("NODE_NOT_FOUND", "Node not found", { objectId: nodeId })]
+        };
+      }
+      return updateNode(document, nodeId, changes);
+    });
+  }
+  deleteNode(requestId, actor, documentId, baseRevision, nodeId) {
+    return this.updateWithMutation(requestId, actor, documentId, baseRevision, "deleteNode", (document) => {
+      if (!document.nodes.some((node) => node.id === nodeId)) {
+        return {
+          document,
+          changedObjectIds: [],
+          errors: [error("NODE_NOT_FOUND", "Node not found", { objectId: nodeId })]
+        };
+      }
+      return deleteNode(document, nodeId);
+    });
+  }
+  addEdge(requestId, actor, documentId, baseRevision, edge) {
+    return this.updateWithMutation(
+      requestId,
+      actor,
+      documentId,
+      baseRevision,
+      "addEdge",
+      (document) => addEdge(document, edge)
+    );
+  }
+  updateEdge(requestId, actor, documentId, baseRevision, edgeId, changes) {
+    return this.updateWithMutation(requestId, actor, documentId, baseRevision, "updateEdge", (document) => {
+      if (!document.edges.some((edge) => edge.id === edgeId)) {
+        return {
+          document,
+          changedObjectIds: [],
+          errors: [error("EDGE_NOT_FOUND", "Edge not found", { objectId: edgeId })]
+        };
+      }
+      return updateEdge(document, edgeId, changes);
+    });
+  }
+  deleteEdge(requestId, actor, documentId, baseRevision, edgeId) {
+    return this.updateWithMutation(requestId, actor, documentId, baseRevision, "deleteEdge", (document) => {
+      if (!document.edges.some((edge) => edge.id === edgeId)) {
+        return {
+          document,
+          changedObjectIds: [],
+          errors: [error("EDGE_NOT_FOUND", "Edge not found", { objectId: edgeId })]
+        };
+      }
+      return deleteEdge(document, edgeId);
+    });
+  }
+  patchDocument(requestId, actor, documentId, baseRevision, operations, atomic = true, dryRun = false) {
+    const loaded = this.loadDocument(documentId, actor);
+    if (loaded.errors.length > 0 || !loaded.document) {
+      return this.failure(requestId, loaded.errors);
+    }
+    const revisionErrors = this.ensureRevision(loaded.document, baseRevision);
+    if (revisionErrors.length > 0) {
+      return this.failure(requestId, revisionErrors, [], loaded.document);
+    }
+    const preview = applyPatchOperations(loaded.document, operations, loaded.document.revision + 1);
+    const previewDocument = withRevision(preview.document, loaded.document.revision + 1);
+    const previewValidation = validateNormalizedDocument(previewDocument);
+    if (atomic && previewValidation.errors.length > 0) {
+      this.logOperation({
+        requestId,
+        actor,
+        operationType: "patchDocument",
+        documentId,
+        success: false,
+        revision: loaded.document.revision,
+        changedObjectIds: preview.changedObjectIds,
+        errors: previewValidation.errors,
+        warnings: previewValidation.warnings
+      });
+      return this.failure(requestId, previewValidation.errors, previewValidation.warnings, loaded.document);
+    }
+    if (!atomic) {
+      let current = loaded.document;
+      const changedObjectIds = /* @__PURE__ */ new Set();
+      const warnings = [];
+      const errors = [];
+      for (const operation of operations) {
+        const candidate = applyPatchOperations(current, [operation], loaded.document.revision + 1);
+        const candidateDocument = withRevision(candidate.document, loaded.document.revision + 1);
+        const candidateValidation = validateNormalizedDocument(candidateDocument);
+        if (candidateValidation.errors.length > 0) {
+          errors.push(...candidateValidation.errors);
+          warnings.push(...candidateValidation.warnings);
+          continue;
+        }
+        current = candidateDocument;
+        for (const objectId of candidate.changedObjectIds) {
+          changedObjectIds.add(objectId);
+        }
+        warnings.push(...candidateValidation.warnings);
+      }
+      if (errors.length > 0 && changedObjectIds.size === 0) {
+        return this.failure(requestId, dedupeIssues(errors), dedupeIssues(warnings), loaded.document);
+      }
+      if (dryRun) {
+        return this.success(requestId, current, [...changedObjectIds], dedupeIssues(warnings));
+      }
+      return this.persistDocument(
+        requestId,
+        actor,
+        "patchDocument",
+        current,
+        [...changedObjectIds],
+        dedupeIssues(warnings)
+      );
+    }
+    if (dryRun) {
+      return this.success(
+        requestId,
+        previewDocument,
+        preview.changedObjectIds,
+        previewValidation.warnings
+      );
+    }
+    return this.persistDocument(
+      requestId,
+      actor,
+      "patchDocument",
+      previewDocument,
+      preview.changedObjectIds,
+      previewValidation.warnings
+    );
+  }
+  validateDocument(requestId, actor, documentId, target, drawioMode) {
+    const loaded = this.loadDocument(documentId, actor);
+    if (loaded.errors.length > 0 || !loaded.document) {
+      return this.failure(requestId, loaded.errors);
+    }
+    if (target === "document") {
+      const validation2 = validateNormalizedDocument(loaded.document);
+      return {
+        ...this.success(requestId, loaded.document, [], validation2.warnings, {
+          target,
+          valid: validation2.errors.length === 0
+        }),
+        success: validation2.errors.length === 0,
+        errors: validation2.errors
+      };
+    }
+    const xml = exportDrawioDocument(loaded.document, { mode: drawioMode });
+    const validation = validateDrawioXml(xml);
+    return {
+      ...this.success(requestId, loaded.document, [], validation.warnings, {
+        target,
+        valid: validation.errors.length === 0
+      }),
+      success: validation.errors.length === 0,
+      errors: validation.errors
+    };
+  }
+  renderDocument(requestId, actor, documentId) {
+    const loaded = this.loadDocument(documentId, actor);
+    if (loaded.errors.length > 0 || !loaded.document) {
+      return this.failure(requestId, loaded.errors);
+    }
+    const rendered = renderSvgDocument(loaded.document);
+    const validation = validateNormalizedDocument(loaded.document);
+    return this.success(requestId, loaded.document, [], mergeWarnings(validation.warnings, rendered.warnings), {
+      svg: rendered.svg,
+      viewBox: rendered.viewBox
+    });
+  }
+  exportDocument(requestId, actor, documentId, format, drawioMode, scale = 1) {
+    const loaded = this.loadDocument(documentId, actor);
+    if (loaded.errors.length > 0 || !loaded.document) {
+      return this.failure(requestId, loaded.errors);
+    }
+    if (format === "svg") {
+      const rendered = renderSvgDocument(loaded.document);
+      const validation2 = validateNormalizedDocument(loaded.document);
+      return this.success(requestId, loaded.document, [], mergeWarnings(validation2.warnings, rendered.warnings), {
+        format,
+        contentType: "image/svg+xml",
+        content: rendered.svg
+      });
+    }
+    if (format === "png") {
+      const rendered = exportDocumentToPng(loaded.document, scale);
+      const validation2 = validateNormalizedDocument(loaded.document);
+      return this.success(requestId, loaded.document, [], mergeWarnings(validation2.warnings, rendered.warnings), {
+        format,
+        contentType: "image/png",
+        content: Buffer.from(rendered.content).toString("base64"),
+        encoding: "base64"
+      });
+    }
+    const xml = exportDrawioDocument(loaded.document, { mode: drawioMode });
+    const validation = validateDrawioXml(xml);
+    if (validation.errors.length > 0) {
+      return this.failure(requestId, validation.errors, validation.warnings, loaded.document);
+    }
+    return this.success(requestId, loaded.document, [], validation.warnings, {
+      format,
+      contentType: "application/xml",
+      content: xml
+    });
+  }
+};
+
+var createApp = async (options = {}) => {
+  const app = Fastify({ logger: false });
+  const repository = new SqliteDocumentRepository(options.dbPath ?? process.env.DROWAI_DB_PATH ?? ":memory:");
+  const documentService = new DocumentService(repository);
+  const auth = resolveAuthOptions(options.auth);
+  registerDocumentRoutes(app, { documentService, auth });
+  app.addHook("onClose", async () => {
+    repository.close();
+  });
+  return app;
+};
+
+import { z as z2 } from "zod";
+var SUPPORTED_PROTOCOL_VERSIONS = [
+  "2025-11-25",
+  "2025-06-18",
+  "2025-03-26",
+  "2024-11-05"
+];
+var DROWAI_MCP_SERVER_NAME = "drowai-orchestrator";
+var DROWAI_MCP_SERVER_TITLE = "DrowAI Orchestrator";
+var DROWAI_MCP_SERVER_VERSION = "0.1.0";
+var SERVER_INSTRUCTIONS = "Use these tools as a thin adapter over DrowAI's canonical HTTP JSON API. Mutations require baseRevision. The normalizedDocument in each result remains the source of truth.";
+var MCP_LOCAL_ACTOR = {
+  actorId: "mcp-local",
+  ownerId: "mcp-local",
+  tenantId: "local"
+};
+var documentIdToolSchema = z2.object({
+  documentId: z2.string().min(1).describe("Target document id, for example doc_examplecase")
+});
+var nodeIdToolSchema = z2.object({
+  nodeId: z2.string().min(1).describe("Target node id")
+});
+var edgeIdToolSchema = z2.object({
+  edgeId: z2.string().min(1).describe("Target edge id")
+});
+var getDocumentToolSchema = documentIdToolSchema.strict();
+var addNodeToolSchema = addNodeRequestSchema.extend(documentIdToolSchema.shape).strict();
+var updateNodeToolSchema = updateNodeRequestSchema.extend({
+  ...documentIdToolSchema.shape,
+  ...nodeIdToolSchema.shape
+}).strict();
+var deleteNodeToolSchema = baseRevisionSchema.extend({
+  ...documentIdToolSchema.shape,
+  ...nodeIdToolSchema.shape
+}).strict();
+var addEdgeToolSchema = addEdgeRequestSchema.extend(documentIdToolSchema.shape).strict();
+var updateEdgeToolSchema = updateEdgeRequestSchema.extend({
+  ...documentIdToolSchema.shape,
+  ...edgeIdToolSchema.shape
+}).strict();
+var deleteEdgeToolSchema = baseRevisionSchema.extend({
+  ...documentIdToolSchema.shape,
+  ...edgeIdToolSchema.shape
+}).strict();
+var patchDocumentToolSchema = patchRequestSchema.extend(documentIdToolSchema.shape).strict();
+var validateDocumentToolSchema = validateRequestSchema.extend(documentIdToolSchema.shape).strict();
+var renderDocumentToolSchema = renderRequestSchema.extend(documentIdToolSchema.shape).strict();
+var exportDocumentToolSchema = exportRequestSchema.extend(documentIdToolSchema.shape).strict();
+var ApiBridge = class {
+  constructor(request) {
+    this.request = request;
+  }
+  request;
+  encode(segment) {
+    return encodeURIComponent(segment);
+  }
+  createDocument(payload) {
+    return this.request("POST", "/documents", payload);
+  }
+  getDocument(documentId) {
+    return this.request("GET", `/documents/${this.encode(documentId)}`);
+  }
+  addNode(documentId, payload) {
+    return this.request("POST", `/documents/${this.encode(documentId)}/nodes`, payload);
+  }
+  updateNode(documentId, nodeId, payload) {
+    return this.request("PATCH", `/documents/${this.encode(documentId)}/nodes/${this.encode(nodeId)}`, payload);
+  }
+  deleteNode(documentId, nodeId, payload) {
+    return this.request("DELETE", `/documents/${this.encode(documentId)}/nodes/${this.encode(nodeId)}`, payload);
+  }
+  addEdge(documentId, payload) {
+    return this.request("POST", `/documents/${this.encode(documentId)}/edges`, payload);
+  }
+  updateEdge(documentId, edgeId, payload) {
+    return this.request("PATCH", `/documents/${this.encode(documentId)}/edges/${this.encode(edgeId)}`, payload);
+  }
+  deleteEdge(documentId, edgeId, payload) {
+    return this.request("DELETE", `/documents/${this.encode(documentId)}/edges/${this.encode(edgeId)}`, payload);
+  }
+  patchDocument(documentId, payload) {
+    return this.request("POST", `/documents/${this.encode(documentId)}/patch`, payload);
+  }
+  validateDocument(documentId, payload) {
+    return this.request("POST", `/documents/${this.encode(documentId)}/validate`, payload);
+  }
+  renderDocument(documentId, payload) {
+    return this.request("POST", `/documents/${this.encode(documentId)}/render`, payload);
+  }
+  exportDocument(documentId, payload) {
+    return this.request("POST", `/documents/${this.encode(documentId)}/export`, payload);
+  }
+};
+var createToolContracts = () => [
+  {
+    name: "create_document",
+    title: "Create document",
+    description: "Create a new DrowAI document and return the normalized JSON envelope.",
+    schema: createDocumentRequestSchema,
+    execute: (args, api) => api.createDocument(args)
+  },
+  {
+    name: "get_document",
+    title: "Get document",
+    description: "Fetch a normalized DrowAI document by id.",
+    schema: getDocumentToolSchema,
+    execute: (args, api) => api.getDocument(args.documentId)
+  },
+  {
+    name: "add_node",
+    title: "Add node",
+    description: "Append one node to an existing document.",
+    schema: addNodeToolSchema,
+    execute: (args, api) => {
+      const { documentId, ...payload } = args;
+      return api.addNode(documentId, payload);
+    }
+  },
+  {
+    name: "update_node",
+    title: "Update node",
+    description: "Apply a partial update to one node.",
+    schema: updateNodeToolSchema,
+    execute: (args, api) => {
+      const { documentId, nodeId, ...payload } = args;
+      return api.updateNode(documentId, nodeId, payload);
+    }
+  },
+  {
+    name: "delete_node",
+    title: "Delete node",
+    description: "Delete one node and any connected edges.",
+    schema: deleteNodeToolSchema,
+    execute: (args, api) => {
+      const { documentId, nodeId, ...payload } = args;
+      return api.deleteNode(documentId, nodeId, payload);
+    }
+  },
+  {
+    name: "add_edge",
+    title: "Add edge",
+    description: "Append one edge to an existing document.",
+    schema: addEdgeToolSchema,
+    execute: (args, api) => {
+      const { documentId, ...payload } = args;
+      return api.addEdge(documentId, payload);
+    }
+  },
+  {
+    name: "update_edge",
+    title: "Update edge",
+    description: "Apply a partial update to one edge.",
+    schema: updateEdgeToolSchema,
+    execute: (args, api) => {
+      const { documentId, edgeId, ...payload } = args;
+      return api.updateEdge(documentId, edgeId, payload);
+    }
+  },
+  {
+    name: "delete_edge",
+    title: "Delete edge",
+    description: "Delete one edge from a document.",
+    schema: deleteEdgeToolSchema,
+    execute: (args, api) => {
+      const { documentId, edgeId, ...payload } = args;
+      return api.deleteEdge(documentId, edgeId, payload);
+    }
+  },
+  {
+    name: "patch_document",
+    title: "Patch document",
+    description: "Run ordered patch operations, including orthogonal route recalculation.",
+    schema: patchDocumentToolSchema,
+    execute: (args, api) => {
+      const { documentId, ...payload } = args;
+      return api.patchDocument(documentId, payload);
+    }
+  },
+  {
+    name: "validate_document",
+    title: "Validate document",
+    description: "Validate a normalized document or its draw.io export.",
+    schema: validateDocumentToolSchema,
+    execute: (args, api) => {
+      const { documentId, ...payload } = args;
+      return api.validateDocument(documentId, payload);
+    }
+  },
+  {
+    name: "render_document",
+    title: "Render document",
+    description: "Render the canonical document JSON into SVG.",
+    schema: renderDocumentToolSchema,
+    execute: (args, api) => {
+      const { documentId, ...payload } = args;
+      return api.renderDocument(documentId, payload);
+    }
+  },
+  {
+    name: "export_document",
+    title: "Export document",
+    description: "Export the canonical document JSON to draw.io XML, SVG, or PNG.",
+    schema: exportDocumentToolSchema,
+    execute: (args, api) => {
+      const { documentId, ...payload } = args;
+      return api.exportDocument(documentId, payload);
+    }
+  }
+];
+var jsonRpcSuccess = (id, result) => ({
+  jsonrpc: "2.0",
+  id,
+  result
+});
+var jsonRpcError = (id, code, message, data) => ({
+  jsonrpc: "2.0",
+  id,
+  error: {
+    code,
+    message,
+    ...data !== void 0 ? { data } : {}
+  }
+});
+var toolInputSchema = (schema) => z2.toJSONSchema(schema);
+var toolResult = (payload, isError = false) => ({
+  content: [
+    {
+      type: "text",
+      text: JSON.stringify(payload, null, 2)
+    }
+  ],
+  structuredContent: payload,
+  isError
+});
+var toolArgumentError = (errors) => toolResult(
+  {
+    success: false,
+    revision: null,
+    errors,
+    warnings: [],
+    changedObjectIds: []
+  },
+  true
+);
+var selectProtocolVersion = (requested) => requested && SUPPORTED_PROTOCOL_VERSIONS.includes(requested) ? requested : SUPPORTED_PROTOCOL_VERSIONS[0];
+var DrowaiMcpServer = class _DrowaiMcpServer {
+  constructor(app, authToken) {
+    this.app = app;
+    this.bridge = new ApiBridge(async (method, path, payload) => {
+      const injectOptions = {
+        method,
+        url: path,
+        headers: {
+          authorization: `Bearer ${authToken}`
+        },
+        ...payload !== void 0 ? { payload } : {}
+      };
+      const response = await this.app.inject(injectOptions);
+      return JSON.parse(String(response.body));
+    });
+  }
+  app;
+  tools = createToolContracts();
+  toolMap = new Map(this.tools.map((tool) => [tool.name, tool]));
+  bridge;
+  negotiatedProtocolVersion = null;
+  static async create(options = {}) {
+    const authToken = options.authToken ?? randomUUID();
+    const app = await createApp({
+      ...options.dbPath ? { dbPath: options.dbPath } : {},
+      auth: {
+        tokenRegistry: {
+          [authToken]: MCP_LOCAL_ACTOR
+        }
+      }
+    });
+    return new _DrowaiMcpServer(app, authToken);
+  }
+  async close() {
+    await this.app.close();
+  }
+  async handleMessage(message) {
+    if (Array.isArray(message)) {
+      const responses = [];
+      for (const item of message) {
+        const response = await this.handleRequest(item);
+        if (response) {
+          responses.push(response);
+        }
+      }
+      return responses.length > 0 ? responses : void 0;
+    }
+    return this.handleRequest(message);
+  }
+  async handleRequest(message) {
+    const id = "id" in message ? message.id ?? null : null;
+    if (message.jsonrpc !== "2.0") {
+      return jsonRpcError(id, -32600, "Invalid JSON-RPC version");
+    }
+    if (typeof message.method !== "string") {
+      return "id" in message ? jsonRpcError(id, -32600, "Invalid JSON-RPC request") : void 0;
+    }
+    switch (message.method) {
+      case "initialize":
+        return this.initialize(id, message.params);
+      case "notifications/initialized":
+        return void 0;
+      case "ping":
+        return jsonRpcSuccess(id, {});
+      case "tools/list":
+        return this.listTools(id);
+      case "tools/call":
+        return this.callTool(id, message.params);
+      default:
+        return "id" in message ? jsonRpcError(id, -32601, `Method not found: ${message.method}`) : void 0;
+    }
+  }
+  initialize(id, params) {
+    const parsed = safeParseWithErrors(
+      z2.object({
+        protocolVersion: z2.string().min(1),
+        capabilities: z2.record(z2.string(), z2.unknown()).default({}),
+        clientInfo: z2.object({
+          name: z2.string().min(1),
+          version: z2.string().min(1),
+          title: z2.string().optional()
+        }).strict()
+      }).strict(),
+      params
+    );
+    if (!parsed.success) {
+      return jsonRpcError(id, -32602, "Invalid initialize params", { errors: parsed.errors });
+    }
+    const selectedProtocolVersion = selectProtocolVersion(parsed.data.protocolVersion);
+    this.negotiatedProtocolVersion = selectedProtocolVersion;
+    return jsonRpcSuccess(id, {
+      protocolVersion: selectedProtocolVersion,
+      capabilities: {
+        tools: {
+          listChanged: false
+        }
+      },
+      serverInfo: {
+        name: DROWAI_MCP_SERVER_NAME,
+        title: DROWAI_MCP_SERVER_TITLE,
+        version: DROWAI_MCP_SERVER_VERSION
+      },
+      instructions: SERVER_INSTRUCTIONS
+    });
+  }
+  listTools(id) {
+    if (!this.negotiatedProtocolVersion) {
+      return jsonRpcError(id, -32002, "Server not initialized");
+    }
+    return jsonRpcSuccess(id, {
+      tools: this.tools.map((tool) => ({
+        name: tool.name,
+        title: tool.title,
+        description: tool.description,
+        inputSchema: toolInputSchema(tool.schema)
+      }))
+    });
+  }
+  async callTool(id, params) {
+    if (!this.negotiatedProtocolVersion) {
+      return jsonRpcError(id, -32002, "Server not initialized");
+    }
+    const parsed = safeParseWithErrors(
+      z2.object({
+        name: z2.string().min(1),
+        arguments: z2.record(z2.string(), z2.unknown()).optional()
+      }).strict(),
+      params
+    );
+    if (!parsed.success) {
+      return jsonRpcSuccess(id, toolArgumentError(parsed.errors));
+    }
+    const tool = this.toolMap.get(parsed.data.name);
+    if (!tool) {
+      return jsonRpcSuccess(
+        id,
+        toolResult(
+          {
+            success: false,
+            revision: null,
+            errors: [
+              {
+                code: "UNKNOWN_TOOL",
+                message: `Unknown MCP tool: ${parsed.data.name}`
+              }
+            ],
+            warnings: [],
+            changedObjectIds: []
+          },
+          true
+        )
+      );
+    }
+    const validatedArguments = safeParseWithErrors(tool.schema, parsed.data.arguments ?? {});
+    if (!validatedArguments.success) {
+      return jsonRpcSuccess(id, toolArgumentError(validatedArguments.errors));
+    }
+    try {
+      const payload = await tool.execute(validatedArguments.data, this.bridge);
+      const resultPayload = typeof payload === "object" && payload !== null && "success" in payload ? payload : { success: true, data: payload };
+      const isError = typeof resultPayload === "object" && resultPayload !== null && "success" in resultPayload && resultPayload.success === false;
+      return jsonRpcSuccess(id, toolResult(resultPayload, isError));
+    } catch (cause) {
+      return jsonRpcSuccess(
+        id,
+        toolResult(
+          {
+            success: false,
+            revision: null,
+            errors: [
+              {
+                code: "MCP_TOOL_EXECUTION_FAILED",
+                message: cause instanceof Error ? cause.message : String(cause)
+              }
+            ],
+            warnings: [],
+            changedObjectIds: []
+          },
+          true
+        )
+      );
+    }
+  }
+};
+var createDrowaiMcpServer = (options = {}) => DrowaiMcpServer.create(options);
+
+import { createInterface } from "node:readline";
+var defaultRuntime = () => ({
+  stdin: process.stdin,
+  stdout: process.stdout,
+  signalProcess: process,
+  exit: (code) => {
+    process.exit(code);
+  }
+});
+var send = (output, message) => {
+  output.write(`${JSON.stringify(message)}
+`);
+};
+var runStdioMcpServer = async (options, runtime = defaultRuntime()) => {
+  const server = await createDrowaiMcpServer(options);
+  const reader = createInterface({
+    input: runtime.stdin,
+    crlfDelay: Infinity
+  });
+  let closed = false;
+  const closeServer = async () => {
+    if (closed) {
+      return;
+    }
+    closed = true;
+    reader.close();
+    await server.close();
+  };
+  const handleSignal = async () => {
+    await closeServer();
+    runtime.exit?.(0);
+  };
+  const signalProcess = runtime.signalProcess;
+  signalProcess?.on("SIGINT", handleSignal);
+  signalProcess?.on("SIGTERM", handleSignal);
+  try {
+    for await (const rawLine of reader) {
+      const line = rawLine.trim();
+      if (!line) {
+        continue;
+      }
+      try {
+        const message = JSON.parse(line);
+        const response = await server.handleMessage(message);
+        if (response) {
+          send(runtime.stdout, response);
+        }
+      } catch (cause) {
+        send(runtime.stdout, {
+          jsonrpc: "2.0",
+          id: null,
+          error: {
+            code: -32700,
+            message: "Parse error",
+            data: cause instanceof Error ? cause.message : String(cause)
+          }
+        });
+      }
+    }
+  } finally {
+    signalProcess?.off("SIGINT", handleSignal);
+    signalProcess?.off("SIGTERM", handleSignal);
+    await closeServer();
+  }
+};
+
+var defaultCliRuntime = () => ({
+  stdin: process.stdin,
+  stdout: process.stdout,
+  stderr: process.stderr,
+  signalProcess: process,
+  exit: (code) => {
+    process.exit(code);
+  }
+});
+var usageText = () => [
+  "Usage: drowai-mcp [--db-path <path>] [--auth-token <token>] [--help] [--version]",
+  "",
+  "MCP-only CLI for the DrowAI diagram platform.",
+  "The package does not expose API or viewer subcommands.",
+  "",
+  "Options:",
+  "  --db-path <path>      Persist SQLite data to the given path",
+  "  --auth-token <token>  Override the embedded API auth secret",
+  "  --help                Print this help text to stderr",
+  "  --version             Print the CLI version to stderr",
+  "",
+  "Environment:",
+  "  DROWAI_DB_PATH        Fallback database path when --db-path is omitted",
+  "  DROWAI_MCP_TOKEN      Fallback auth token when --auth-token is omitted",
+  "",
+  "Examples:",
+  "  npx drowai-mcp",
+  "  DROWAI_DB_PATH=./state/drowai.sqlite npx drowai-mcp",
+  "  npx drowai-mcp --db-path ./state/drowai.sqlite"
+].join("\n");
+var readInlineOrNext = (argv, index, name) => {
+  const current = argv[index] ?? "";
+  const inlinePrefix = `${name}=`;
+  if (current.startsWith(inlinePrefix)) {
+    const value = current.slice(inlinePrefix.length);
+    return value ? { value, nextIndex: index } : { nextIndex: index, error: `Missing value for ${name}` };
+  }
+  const next = argv[index + 1];
+  if (!next || next.startsWith("-")) {
+    return { nextIndex: index, error: `Missing value for ${name}` };
+  }
+  return { value: next, nextIndex: index + 1 };
+};
+var parseCliArgs = (argv, env = process.env) => {
+  let dbPath = env.DROWAI_DB_PATH;
+  let authToken = env.DROWAI_MCP_TOKEN;
+  for (let index = 0; index < argv.length; index += 1) {
+    const arg = argv[index] ?? "";
+    if (arg === "--help" || arg === "-h") {
+      return { kind: "help" };
+    }
+    if (arg === "--version" || arg === "-v") {
+      return { kind: "version" };
+    }
+    if (arg === "--db-path" || arg.startsWith("--db-path=")) {
+      const parsed = readInlineOrNext(argv, index, "--db-path");
+      if (parsed.error) {
+        return { kind: "error", message: parsed.error };
+      }
+      dbPath = parsed.value;
+      index = parsed.nextIndex;
+      continue;
+    }
+    if (arg === "--auth-token" || arg.startsWith("--auth-token=")) {
+      const parsed = readInlineOrNext(argv, index, "--auth-token");
+      if (parsed.error) {
+        return { kind: "error", message: parsed.error };
+      }
+      authToken = parsed.value;
+      index = parsed.nextIndex;
+      continue;
+    }
+    if (arg.startsWith("-")) {
+      return { kind: "error", message: `Unknown argument: ${arg}` };
+    }
+    return { kind: "error", message: `Unexpected positional argument: ${arg}` };
+  }
+  return {
+    kind: "run",
+    serverOptions: {
+      ...dbPath ? { dbPath } : {},
+      ...authToken ? { authToken } : {}
+    }
+  };
+};
+var runCli = async (argv = process.argv.slice(2), runtime = defaultCliRuntime(), env = process.env) => {
+  const command = parseCliArgs(argv, env);
+  switch (command.kind) {
+    case "help":
+      runtime.stderr.write(`${usageText()}
+`);
+      return 0;
+    case "version":
+      runtime.stderr.write(`${DROWAI_MCP_SERVER_VERSION}
+`);
+      return 0;
+    case "error":
+      runtime.stderr.write(`${command.message}
+
+${usageText()}
+`);
+      return 1;
+    case "run":
+      await runStdioMcpServer(command.serverOptions, runtime);
+      return 0;
+  }
+};
+var isCliEntrypoint = (entryUrl, argvPath) => {
+  if (!argvPath) {
+    return false;
+  }
+  try {
+    return realpathSync(fileURLToPath(entryUrl)) === realpathSync(argvPath);
+  } catch {
+    return entryUrl === new URL(argvPath, "file://").href;
+  }
+};
+if (isCliEntrypoint(import.meta.url, process.argv[1])) {
+  const exitCode = await runCli();
+  process.exitCode = exitCode;
+}
+export {
+  parseCliArgs,
+  runCli
+};