@lupinum/board-core 0.1.0

package/dist/index.js

@@ -0,0 +1,4159 @@
+import {
+  BoardConflictError,
+  BoardDestroyedError,
+  BoardError,
+  BoardInputError,
+  BoardNotFoundError,
+  assertInternalBoardPlugin,
+  registerBoardInteractionAdapter
+} from "./chunk-5JZXHZWR.js";
+
+// src/math.ts
+function clamp(value, min, max) {
+  return Math.min(max, Math.max(min, value));
+}
+function lerp(a, b, t) {
+  return a + (b - a) * t;
+}
+function lerpCamera(from, to, t) {
+  return {
+    x: lerp(from.x, to.x, t),
+    y: lerp(from.y, to.y, t),
+    z: lerp(from.z, to.z, t)
+  };
+}
+function screenToWorld(point, camera) {
+  return {
+    x: point.x / camera.z - camera.x,
+    y: point.y / camera.z - camera.y
+  };
+}
+function worldToScreen(point, camera) {
+  return {
+    x: (point.x + camera.x) * camera.z,
+    y: (point.y + camera.y) * camera.z
+  };
+}
+function getVisibleBounds(width, height, camera) {
+  const topLeft = screenToWorld({ x: 0, y: 0 }, camera);
+  const bottomRight = screenToWorld({ x: width, y: height }, camera);
+  return {
+    minX: topLeft.x,
+    minY: topLeft.y,
+    maxX: bottomRight.x,
+    maxY: bottomRight.y
+  };
+}
+function pointInBounds(point, bounds) {
+  return point.x >= bounds.minX && point.x <= bounds.maxX && point.y >= bounds.minY && point.y <= bounds.maxY;
+}
+function boundsIntersect(a, b) {
+  return !(a.maxX < b.minX || a.minX > b.maxX || a.maxY < b.minY || a.minY > b.maxY);
+}
+function boundsContain(outer, inner) {
+  return inner.minX >= outer.minX && inner.maxX <= outer.maxX && inner.minY >= outer.minY && inner.maxY <= outer.maxY;
+}
+function getBoundsFromPoints(a, b) {
+  return {
+    minX: Math.min(a.x, b.x),
+    minY: Math.min(a.y, b.y),
+    maxX: Math.max(a.x, b.x),
+    maxY: Math.max(a.y, b.y)
+  };
+}
+function snapValue(value, step) {
+  if (step <= 0) {
+    return value;
+  }
+  return Math.round(value / step) * step;
+}
+function snapPoint(point, step) {
+  return {
+    x: snapValue(point.x, step),
+    y: snapValue(point.y, step)
+  };
+}
+function snapSize(value, step, min) {
+  return Math.max(min, snapValue(value, step));
+}
+function zoomCameraAtScreenPoint(screenPoint, delta, camera, min, max) {
+  const nextZoom = clamp(camera.z * Math.pow(2, -delta * 0.01), min, max);
+  const before = screenToWorld(screenPoint, camera);
+  const after = {
+    x: screenPoint.x / nextZoom - camera.x,
+    y: screenPoint.y / nextZoom - camera.y
+  };
+  return {
+    x: camera.x + (after.x - before.x),
+    y: camera.y + (after.y - before.y),
+    z: nextZoom
+  };
+}
+
+// src/hierarchy.ts
+function getBoundsFromNode(node) {
+  return {
+    minX: node.x,
+    minY: node.y,
+    maxX: node.x + node.width,
+    maxY: node.y + node.height
+  };
+}
+function groupArea(node) {
+  return node.width * node.height;
+}
+function addDescendants(rootId, nodes, out) {
+  for (const n of nodes.values()) {
+    if (n.parentId === rootId && !out.has(n.id)) {
+      out.add(n.id);
+      if (n.type === "group") {
+        addDescendants(n.id, nodes, out);
+      }
+    }
+  }
+}
+function expandGroupDragSeeds(seedIds, nodes) {
+  const out = /* @__PURE__ */ new Set();
+  for (const id of seedIds) {
+    out.add(id);
+    const n = nodes.get(id);
+    if (n?.type === "group") {
+      addDescendants(id, nodes, out);
+    }
+  }
+  return out;
+}
+function collectSubtreeIds(rootId, nodes, into) {
+  into.add(rootId);
+  for (const n of nodes.values()) {
+    if (n.parentId === rootId) {
+      collectSubtreeIds(n.id, nodes, into);
+    }
+  }
+}
+function collectUniformTranslationTargets(seedIds, nodes) {
+  const expanded = expandGroupDragSeeds(seedIds, nodes);
+  const roots = [];
+  for (const id of expanded) {
+    const n = nodes.get(id);
+    if (!n) {
+      continue;
+    }
+    if (!n.parentId || !expanded.has(n.parentId)) {
+      roots.push(id);
+    }
+  }
+  const out = /* @__PURE__ */ new Set();
+  for (const r of roots) {
+    collectSubtreeIds(r, nodes, out);
+  }
+  return [...out];
+}
+function isStrictDescendantOf(maybeDescendant, ancestorId, nodes) {
+  let walk = nodes.get(maybeDescendant)?.parentId;
+  const seen = /* @__PURE__ */ new Set();
+  while (walk) {
+    if (seen.has(walk)) {
+      return false;
+    }
+    seen.add(walk);
+    if (walk === ancestorId) {
+      return true;
+    }
+    walk = nodes.get(walk)?.parentId;
+  }
+  return false;
+}
+function findContainingGroup(node, nodes) {
+  const nodeBounds = getBoundsFromNode(node);
+  const candidates = [];
+  for (const g of nodes.values()) {
+    if (g.type !== "group" || !g.visible) {
+      continue;
+    }
+    if (g.id === node.id) {
+      continue;
+    }
+    if (isStrictDescendantOf(g.id, node.id, nodes)) {
+      continue;
+    }
+    if (!boundsContain(getBoundsFromNode(g), nodeBounds)) {
+      continue;
+    }
+    candidates.push(g);
+  }
+  if (candidates.length === 0) {
+    return void 0;
+  }
+  candidates.sort((a, b) => groupArea(a) - groupArea(b));
+  return candidates[0].id;
+}
+function sortIdsByZIndex(ids, nodes) {
+  return [...ids].sort((a, b) => {
+    const za = nodes.get(a)?.zIndex ?? 0;
+    const zb = nodes.get(b)?.zIndex ?? 0;
+    return za - zb;
+  });
+}
+
+// src/resize.ts
+function applyResizeDelta(node, handle, deltaX, deltaY, constraints) {
+  let { x, y, width, height } = node;
+  if (handle.includes("e")) {
+    width = Math.max(constraints.minWidth, node.width + deltaX);
+  }
+  if (handle.includes("s")) {
+    height = Math.max(constraints.minHeight, node.height + deltaY);
+  }
+  if (handle.includes("w")) {
+    const nextWidth = Math.max(constraints.minWidth, node.width - deltaX);
+    const consumed = node.width - nextWidth;
+    width = nextWidth;
+    x = node.x + consumed;
+  }
+  if (handle.includes("n")) {
+    const nextHeight = Math.max(constraints.minHeight, node.height - deltaY);
+    const consumed = node.height - nextHeight;
+    height = nextHeight;
+    y = node.y + consumed;
+  }
+  return { x, y, width, height };
+}
+function snapResizedBounds(bounds, handle, gridSize, constraints) {
+  let { x, y, width, height } = bounds;
+  const right = bounds.x + bounds.width;
+  const bottom = bounds.y + bounds.height;
+  if (handle.includes("e")) {
+    width = snapSize(width, gridSize, constraints.minWidth);
+  } else {
+    x = snapValue(x, gridSize);
+  }
+  if (handle.includes("s")) {
+    height = snapSize(height, gridSize, constraints.minHeight);
+  } else {
+    y = snapValue(y, gridSize);
+  }
+  if (handle.includes("w")) {
+    width = snapSize(width, gridSize, constraints.minWidth);
+    x = snapValue(right - width, gridSize);
+    width = Math.max(constraints.minWidth, right - x);
+  }
+  if (handle.includes("n")) {
+    height = snapSize(height, gridSize, constraints.minHeight);
+    y = snapValue(bottom - height, gridSize);
+    height = Math.max(constraints.minHeight, bottom - y);
+  }
+  return { x, y, width, height };
+}
+function applyResizeDeltaLocked(node, handle, deltaX, deltaY, constraints, aspectRatio) {
+  const { width: w, height: h } = node;
+  let cdx = deltaX;
+  let cdy = deltaY;
+  let effectiveHandle = handle;
+  if (handle === "e") {
+    const newW = Math.max(constraints.minWidth, w + deltaX);
+    cdx = newW - w;
+    cdy = Math.max(constraints.minHeight, newW / aspectRatio) - h;
+    effectiveHandle = "se";
+  } else if (handle === "w") {
+    const newW = Math.max(constraints.minWidth, w - deltaX);
+    cdy = Math.max(constraints.minHeight, newW / aspectRatio) - h;
+    effectiveHandle = "sw";
+  } else if (handle === "s") {
+    const newH = Math.max(constraints.minHeight, h + deltaY);
+    cdy = newH - h;
+    cdx = Math.max(constraints.minWidth, newH * aspectRatio) - w;
+    effectiveHandle = "se";
+  } else if (handle === "n") {
+    const newH = Math.max(constraints.minHeight, h - deltaY);
+    cdx = Math.max(constraints.minWidth, newH * aspectRatio) - w;
+    effectiveHandle = "ne";
+  } else {
+    const xSign = handle.includes("e") ? 1 : -1;
+    const ySign = handle.includes("s") ? 1 : -1;
+    const growX = xSign * deltaX;
+    const growY = ySign * deltaY;
+    let newW;
+    let newH;
+    if (Math.abs(growX / w) >= Math.abs(growY / h)) {
+      newW = Math.max(constraints.minWidth, w + growX);
+      newH = Math.max(constraints.minHeight, newW / aspectRatio);
+    } else {
+      newH = Math.max(constraints.minHeight, h + growY);
+      newW = Math.max(constraints.minWidth, newH * aspectRatio);
+    }
+    cdx = xSign * (newW - w);
+    cdy = ySign * (newH - h);
+  }
+  return applyResizeDelta(node, effectiveHandle, cdx, cdy, constraints);
+}
+function snapResizedBoundsLocked(bounds, startBounds, handle, gridSize, constraints, aspectRatio) {
+  const right = startBounds.x + startBounds.width;
+  const bottom = startBounds.y + startBounds.height;
+  if (handle === "n" || handle === "s") {
+    const snappedH2 = snapSize(bounds.height, gridSize, constraints.minHeight);
+    const snappedW2 = Math.max(constraints.minWidth, snappedH2 * aspectRatio);
+    const y2 = handle === "n" ? bottom - snappedH2 : bounds.y;
+    return { x: bounds.x, y: y2, width: snappedW2, height: snappedH2 };
+  }
+  const snappedW = snapSize(bounds.width, gridSize, constraints.minWidth);
+  const snappedH = Math.max(constraints.minHeight, snappedW / aspectRatio);
+  const x = handle.includes("w") ? right - snappedW : bounds.x;
+  const y = handle.includes("n") ? bottom - snappedH : bounds.y;
+  return { x, y, width: snappedW, height: snappedH };
+}
+
+// src/snap.ts
+function collectNodeEdges(node) {
+  const right = node.x + node.width;
+  const bottom = node.y + node.height;
+  return [
+    { axis: "x", value: node.x, extentMin: node.y, extentMax: bottom },
+    { axis: "x", value: right, extentMin: node.y, extentMax: bottom },
+    { axis: "y", value: node.y, extentMin: node.x, extentMax: right },
+    { axis: "y", value: bottom, extentMin: node.x, extentMax: right }
+  ];
+}
+function buildSnapEdgeIndex(nodes) {
+  const x = [];
+  const y = [];
+  for (const node of nodes) {
+    if (!node.visible) continue;
+    for (const edge of collectNodeEdges(node)) {
+      ;
+      (edge.axis === "x" ? x : y).push({ ...edge, nodeId: node.id });
+    }
+  }
+  x.sort((left, right) => left.value - right.value);
+  y.sort((left, right) => left.value - right.value);
+  return { x, y };
+}
+function lowerBound(candidates, value) {
+  let low = 0;
+  let high = candidates.length;
+  while (low < high) {
+    const middle = low + high >>> 1;
+    if (candidates[middle].value < value) low = middle + 1;
+    else high = middle;
+  }
+  return low;
+}
+function findBestSnap(activeValue, activeExtentMin, activeExtentMax, axis, candidates, threshold, index, excludeIds) {
+  let bestDist = threshold;
+  let bestCandidate = null;
+  const source = index?.[axis] ?? candidates;
+  const start = index ? lowerBound(source, activeValue - threshold) : 0;
+  for (let position = start; position < source.length; position += 1) {
+    const candidate = source[position];
+    if (index && candidate.value >= activeValue + threshold) break;
+    if (candidate.axis !== axis) continue;
+    if (candidate.nodeId && excludeIds?.has(candidate.nodeId)) continue;
+    const dist = Math.abs(candidate.value - activeValue);
+    if (dist < bestDist) {
+      bestDist = dist;
+      bestCandidate = candidate;
+    }
+  }
+  if (!bestCandidate) return null;
+  const guideFrom = Math.min(activeExtentMin, bestCandidate.extentMin);
+  const guideTo = Math.max(activeExtentMax, bestCandidate.extentMax);
+  return {
+    snappedValue: bestCandidate.value,
+    guide: {
+      axis,
+      position: bestCandidate.value,
+      from: guideFrom,
+      to: guideTo
+    }
+  };
+}
+function snapBoundsToEdges(bounds, handle, otherEdges, threshold, excludeIds) {
+  let { x, y, width, height } = bounds;
+  const guides = [];
+  const right = x + width;
+  const bottom = y + height;
+  if (handle.includes("e")) {
+    const snap = findBestSnap(
+      right,
+      y,
+      bottom,
+      "x",
+      Array.isArray(otherEdges) ? otherEdges : [],
+      threshold,
+      Array.isArray(otherEdges) ? void 0 : otherEdges,
+      excludeIds
+    );
+    if (snap) {
+      width = snap.snappedValue - x;
+      guides.push(snap.guide);
+    }
+  }
+  if (handle.includes("w")) {
+    const snap = findBestSnap(
+      x,
+      y,
+      bottom,
+      "x",
+      Array.isArray(otherEdges) ? otherEdges : [],
+      threshold,
+      Array.isArray(otherEdges) ? void 0 : otherEdges,
+      excludeIds
+    );
+    if (snap) {
+      const oldRight = x + width;
+      x = snap.snappedValue;
+      width = oldRight - x;
+      guides.push(snap.guide);
+    }
+  }
+  if (handle.includes("s")) {
+    const snap = findBestSnap(
+      bottom,
+      x,
+      right,
+      "y",
+      Array.isArray(otherEdges) ? otherEdges : [],
+      threshold,
+      Array.isArray(otherEdges) ? void 0 : otherEdges,
+      excludeIds
+    );
+    if (snap) {
+      height = snap.snappedValue - y;
+      guides.push(snap.guide);
+    }
+  }
+  if (handle.includes("n")) {
+    const snap = findBestSnap(
+      y,
+      x,
+      right,
+      "y",
+      Array.isArray(otherEdges) ? otherEdges : [],
+      threshold,
+      Array.isArray(otherEdges) ? void 0 : otherEdges,
+      excludeIds
+    );
+    if (snap) {
+      const oldBottom = y + height;
+      y = snap.snappedValue;
+      height = oldBottom - y;
+      guides.push(snap.guide);
+    }
+  }
+  return { bounds: { x, y, width, height }, guides };
+}
+function snapPositionToEdges(bounds, otherEdges, threshold, excludeIds) {
+  let dx = 0;
+  let dy = 0;
+  const guides = [];
+  const { x, y, width, height } = bounds;
+  const right = x + width;
+  const bottom = y + height;
+  const candidates = Array.isArray(otherEdges) ? otherEdges : [];
+  const index = Array.isArray(otherEdges) ? void 0 : otherEdges;
+  const snapLeft = findBestSnap(
+    x,
+    y,
+    bottom,
+    "x",
+    candidates,
+    threshold,
+    index,
+    excludeIds
+  );
+  const snapRight = findBestSnap(
+    right,
+    y,
+    bottom,
+    "x",
+    candidates,
+    threshold,
+    index,
+    excludeIds
+  );
+  if (snapLeft && snapRight) {
+    const distLeft = Math.abs(snapLeft.snappedValue - x);
+    const distRight = Math.abs(snapRight.snappedValue - right);
+    if (distLeft <= distRight) {
+      dx = snapLeft.snappedValue - x;
+      guides.push(snapLeft.guide);
+    } else {
+      dx = snapRight.snappedValue - right;
+      guides.push(snapRight.guide);
+    }
+  } else if (snapLeft) {
+    dx = snapLeft.snappedValue - x;
+    guides.push(snapLeft.guide);
+  } else if (snapRight) {
+    dx = snapRight.snappedValue - right;
+    guides.push(snapRight.guide);
+  }
+  const snapTop = findBestSnap(
+    y,
+    x + dx,
+    right + dx,
+    "y",
+    candidates,
+    threshold,
+    index,
+    excludeIds
+  );
+  const snapBottom = findBestSnap(
+    bottom,
+    x + dx,
+    right + dx,
+    "y",
+    candidates,
+    threshold,
+    index,
+    excludeIds
+  );
+  if (snapTop && snapBottom) {
+    const distTop = Math.abs(snapTop.snappedValue - y);
+    const distBottom = Math.abs(snapBottom.snappedValue - bottom);
+    if (distTop <= distBottom) {
+      dy = snapTop.snappedValue - y;
+      guides.push(snapTop.guide);
+    } else {
+      dy = snapBottom.snappedValue - bottom;
+      guides.push(snapBottom.guide);
+    }
+  } else if (snapTop) {
+    dy = snapTop.snappedValue - y;
+    guides.push(snapTop.guide);
+  } else if (snapBottom) {
+    dy = snapBottom.snappedValue - bottom;
+    guides.push(snapBottom.guide);
+  }
+  return { dx, dy, guides };
+}
+
+// src/helpers/clone.ts
+function freezeClone(value) {
+  if (Array.isArray(value)) {
+    for (const entry of value) {
+      freezeClone(entry);
+    }
+    return Object.freeze(value);
+  }
+  if (value && typeof value === "object") {
+    for (const child of Object.values(value)) {
+      freezeClone(child);
+    }
+    return Object.freeze(value);
+  }
+  return value;
+}
+function sameArray(a, b) {
+  if (a.length !== b.length) {
+    return false;
+  }
+  return a.every((value, index) => value === b[index]);
+}
+function readonlyMapView(source) {
+  let view;
+  view = Object.freeze({
+    get size() {
+      return source.size;
+    },
+    get: (key) => source.get(key),
+    has: (key) => source.has(key),
+    entries: () => source.entries(),
+    keys: () => source.keys(),
+    values: () => source.values(),
+    forEach: (callback, thisArg) => {
+      source.forEach((value, key) => callback.call(thisArg, value, key, view));
+    },
+    [Symbol.iterator]: () => source[Symbol.iterator]()
+  });
+  return view;
+}
+function readonlySetView(source) {
+  let view;
+  view = Object.freeze({
+    get size() {
+      return source.size;
+    },
+    has: (value) => source.has(value),
+    entries: () => source.entries(),
+    keys: () => source.keys(),
+    values: () => source.values(),
+    forEach: (callback, thisArg) => {
+      source.forEach((value) => callback.call(thisArg, value, value, view));
+    },
+    [Symbol.iterator]: () => source[Symbol.iterator](),
+    union: (other) => {
+      const result = new Set(source);
+      for (const value of iteratorValues(other.keys())) result.add(value);
+      return result;
+    },
+    intersection: (other) => {
+      const result = /* @__PURE__ */ new Set();
+      for (const value of source) {
+        if (other.has(value)) result.add(value);
+      }
+      return result;
+    },
+    difference: (other) => {
+      const result = /* @__PURE__ */ new Set();
+      for (const value of source) {
+        if (!other.has(value)) result.add(value);
+      }
+      return result;
+    },
+    symmetricDifference: (other) => {
+      const result = new Set(source);
+      for (const value of iteratorValues(other.keys())) {
+        if (source.has(value)) result.delete(value);
+        else result.add(value);
+      }
+      return result;
+    },
+    isSubsetOf: (other) => {
+      for (const value of source) if (!other.has(value)) return false;
+      return true;
+    },
+    isSupersetOf: (other) => {
+      for (const value of iteratorValues(other.keys())) {
+        if (!source.has(value)) return false;
+      }
+      return true;
+    },
+    isDisjointFrom: (other) => {
+      for (const value of source) if (other.has(value)) return false;
+      return true;
+    }
+  });
+  return view;
+}
+function* iteratorValues(iterator) {
+  while (true) {
+    const result = iterator.next();
+    if (result.done) return;
+    yield result.value;
+  }
+}
+
+// src/helpers/ids.ts
+function createNodeId() {
+  return crypto.randomUUID();
+}
+
+// src/helpers/animation.ts
+function getAnimationFrameDriver() {
+  const raf = globalThis.requestAnimationFrame?.bind(globalThis);
+  const caf = globalThis.cancelAnimationFrame?.bind(globalThis);
+  if (typeof raf === "function" && typeof caf === "function") {
+    return { raf, caf };
+  }
+  return {
+    raf: (cb) => globalThis.setTimeout(() => cb(Date.now()), 16),
+    caf: (handle) => globalThis.clearTimeout(handle)
+  };
+}
+var AnimationCancelled = class extends Error {
+  constructor() {
+    super("Animation cancelled");
+    this.name = "AnimationCancelled";
+  }
+};
+
+// src/state/types.ts
+var DEFAULT_CAMERA = { x: 0, y: 0, z: 1 };
+var DEFAULT_ZOOM = { min: 0.1, max: 8 };
+var DEFAULT_GRID = {
+  size: 10,
+  majorEvery: 5,
+  snap: true,
+  edgeSnap: true,
+  edgeSnapThreshold: 8,
+  pattern: "line"
+};
+var DEFAULT_NODE_CONSTRAINTS = {
+  minWidth: 50,
+  minHeight: 50,
+  defaultWidth: 240,
+  defaultHeight: 160
+};
+var DEFAULT_VIEWPORT_SIZE = { x: 1280, y: 720 };
+
+// src/state/initial.ts
+function normalizeExistingNode(node) {
+  const parentId = typeof node.parentId === "string" && node.parentId.length > 0 ? node.parentId : void 0;
+  return {
+    ...node,
+    color: node.color,
+    locked: Boolean(node.locked),
+    visible: node.visible !== false,
+    parentId
+  };
+}
+
+// src/helpers/node-shape.ts
+function materializeNode(node) {
+  return freezeClone({
+    id: node.id,
+    type: node.type,
+    x: node.x,
+    y: node.y,
+    width: node.width,
+    height: node.height,
+    ...node.color !== void 0 ? { color: node.color } : {},
+    ...node.text !== void 0 ? { text: node.text } : {},
+    ...node.file !== void 0 ? { file: node.file } : {},
+    ...node.subpath !== void 0 ? { subpath: node.subpath } : {},
+    ...node.url !== void 0 ? { url: node.url } : {},
+    ...node.label !== void 0 ? { label: node.label } : {},
+    ...node.background !== void 0 ? { background: node.background } : {},
+    ...node.backgroundStyle !== void 0 ? { backgroundStyle: node.backgroundStyle } : {},
+    zIndex: node.zIndex,
+    locked: node.locked,
+    visible: node.visible,
+    ...node.parentId !== void 0 ? { parentId: node.parentId } : {}
+  });
+}
+
+// src/invariants.ts
+function cloneInteraction(interaction) {
+  switch (interaction.mode) {
+    case "idle":
+      return { mode: "idle" };
+    case "editing-text":
+      return { mode: "editing-text", nodeId: interaction.nodeId };
+    case "panning":
+      return {
+        mode: "panning",
+        pointerId: interaction.pointerId,
+        lastScreenPoint: { ...interaction.lastScreenPoint }
+      };
+    case "dragging-nodes":
+      return {
+        mode: "dragging-nodes",
+        pointerId: interaction.pointerId,
+        nodeIds: [...interaction.nodeIds],
+        startScreenPoint: { ...interaction.startScreenPoint },
+        startNodePositions: Object.fromEntries(
+          Object.entries(interaction.startNodePositions).map(([key, value]) => [
+            key,
+            { ...value }
+          ])
+        )
+      };
+    case "resizing-node":
+      return {
+        mode: "resizing-node",
+        pointerId: interaction.pointerId,
+        nodeId: interaction.nodeId,
+        handle: interaction.handle,
+        startScreenPoint: { ...interaction.startScreenPoint },
+        startNodeBounds: { ...interaction.startNodeBounds },
+        aspectRatio: interaction.aspectRatio
+      };
+    case "box-select":
+      return {
+        mode: "box-select",
+        pointerId: interaction.pointerId,
+        selectionMode: interaction.selectionMode,
+        startScreenPoint: { ...interaction.startScreenPoint },
+        currentScreenPoint: { ...interaction.currentScreenPoint },
+        startWorldPoint: { ...interaction.startWorldPoint },
+        currentWorldPoint: { ...interaction.currentWorldPoint }
+      };
+  }
+}
+function validateState(state, grid, context) {
+  const failures = [];
+  const push = (name, message) => {
+    failures.push({ name, message, context, state });
+  };
+  if (!Number.isFinite(state.camera.x) || !Number.isFinite(state.camera.y) || !Number.isFinite(state.camera.z) || state.camera.z <= 0) {
+    push(
+      "camera.valid",
+      "Camera position must be finite and zoom must be greater than 0."
+    );
+  }
+  if (grid.size <= 0 || !Number.isFinite(grid.size)) {
+    push("grid.size", "Grid size must be a finite number greater than 0.");
+  }
+  if (grid.majorEvery < 1 || !Number.isFinite(grid.majorEvery) || !Number.isInteger(grid.majorEvery)) {
+    push(
+      "grid.majorEvery",
+      "Grid majorEvery must be an integer greater than or equal to 1."
+    );
+  }
+  if (grid.edgeSnapThreshold <= 0 || !Number.isFinite(grid.edgeSnapThreshold)) {
+    push(
+      "grid.edgeSnapThreshold",
+      "Grid edgeSnapThreshold must be a finite number greater than 0."
+    );
+  }
+  const zIndexes = /* @__PURE__ */ new Set();
+  for (const node of state.nodes.values()) {
+    validateNode(node, push);
+    validateNodeParent(node, state, push);
+    if (zIndexes.has(node.zIndex)) {
+      push(
+        "node.zIndex.unique",
+        `Node ${node.id} shares a z-index with another node.`
+      );
+    }
+    zIndexes.add(node.zIndex);
+  }
+  for (const id of state.selection.values()) {
+    if (!state.nodes.has(id)) {
+      push("selection.exists", `Selected node ${id} does not exist.`);
+    }
+  }
+  if (state.interaction.mode === "editing-text" && !state.nodes.has(state.interaction.nodeId)) {
+    push(
+      "interaction.node",
+      `Editing node ${state.interaction.nodeId} does not exist.`
+    );
+  }
+  if (state.interaction.mode === "resizing-node" && !state.nodes.has(state.interaction.nodeId)) {
+    push(
+      "interaction.node",
+      `Resizing node ${state.interaction.nodeId} does not exist.`
+    );
+  }
+  if (state.interaction.mode === "dragging-nodes") {
+    for (const id of state.interaction.nodeIds) {
+      if (!state.nodes.has(id)) {
+        push("interaction.node", `Dragging node ${id} does not exist.`);
+      }
+    }
+  }
+  return failures;
+}
+function validateNode(node, push) {
+  if (!Number.isFinite(node.x) || !Number.isFinite(node.y) || !Number.isFinite(node.width) || !Number.isFinite(node.height)) {
+    push("node.finite", `Node ${node.id} contains non-finite geometry.`);
+  }
+  if (node.width <= 0 || node.height <= 0) {
+    push("node.size", `Node ${node.id} must have positive width and height.`);
+  }
+}
+function validateNodeParent(node, state, push) {
+  if (node.parentId === void 0) {
+    return;
+  }
+  if (node.parentId === node.id) {
+    push("node.parentId", `Node ${node.id} cannot be its own parent.`);
+    return;
+  }
+  const parent = state.nodes.get(node.parentId);
+  if (!parent) {
+    push(
+      "node.parentId",
+      `Node ${node.id} references missing parent ${node.parentId}.`
+    );
+    return;
+  }
+  if (parent.type !== "group") {
+    push(
+      "node.parentId",
+      `Node ${node.id} parent must be type "group", got "${parent.type}".`
+    );
+  }
+  let walk = parent;
+  const seen = /* @__PURE__ */ new Set();
+  while (walk) {
+    if (seen.has(walk.id)) {
+      push(
+        "node.parentId",
+        `Cycle detected in parent chain for node ${node.id}.`
+      );
+      return;
+    }
+    seen.add(walk.id);
+    if (walk.id === node.id) {
+      push(
+        "node.parentId",
+        `Node ${node.id} would create a cycle in the parent chain.`
+      );
+      return;
+    }
+    if (!walk.parentId) {
+      break;
+    }
+    walk = state.nodes.get(walk.parentId);
+  }
+}
+
+// src/state/selectors.ts
+var materializedNodes = /* @__PURE__ */ new WeakMap();
+function getMaterializedNode(node) {
+  const cached = materializedNodes.get(node);
+  if (cached) return cached;
+  const materialized = materializeNode(node);
+  materializedNodes.set(node, materialized);
+  return materialized;
+}
+function buildPublicNodeMap(state) {
+  return new Map(
+    Array.from(
+      state.nodes.values(),
+      (node) => [node.id, getMaterializedNode(node)]
+    )
+  );
+}
+function buildSnapshot(state, grid, publicNodes) {
+  const nodes = Array.from(publicNodes.values()).sort(
+    (a, b) => a.zIndex - b.zIndex
+  );
+  return freezeClone({
+    nodes,
+    camera: { ...state.camera },
+    grid: { ...grid },
+    selection: Array.from(state.selection.values()),
+    interaction: cloneInteraction(state.interaction),
+    snapGuides: state.snapGuides.map((guide) => ({ ...guide })),
+    nextZIndex: state.nextZIndex
+  });
+}
+function buildPublicState(state, grid, publicNodes) {
+  return {
+    camera: freezeClone({ ...state.camera }),
+    grid: freezeClone({ ...grid }),
+    nodes: new Map(publicNodes),
+    selection: new Set(state.selection),
+    interaction: cloneInteraction(state.interaction),
+    snapGuides: state.snapGuides.map((guide) => freezeClone({ ...guide }))
+  };
+}
+
+// src/helpers/selection-helpers.ts
+function getSelectionNodes(state) {
+  return Array.from(state.selection.values()).map((id) => state.nodes.get(id)).filter((node) => Boolean(node));
+}
+function getCopyClosureNodes(state) {
+  const selected = getSelectionNodes(state);
+  const ids = expandGroupDragSeeds(
+    selected.map((node) => node.id),
+    state.nodes
+  );
+  return Array.from(ids).map((id) => state.nodes.get(id)).filter((node) => Boolean(node)).sort((a, b) => a.zIndex - b.zIndex);
+}
+function duplicateForest(state, grid, nodes, offset) {
+  const sorted = [...nodes].sort((a, b) => a.zIndex - b.zIndex);
+  const idMap = /* @__PURE__ */ new Map();
+  for (const node of sorted) {
+    idMap.set(node.id, createNodeId());
+  }
+  return {
+    nodes: sorted.map((node) => ({
+      ...node,
+      id: idMap.get(node.id),
+      parentId: node.parentId && idMap.has(node.parentId) ? idMap.get(node.parentId) : void 0,
+      x: grid.snap ? snapValue(node.x + offset.x, grid.size) : node.x + offset.x,
+      y: grid.snap ? snapValue(node.y + offset.y, grid.size) : node.y + offset.y,
+      zIndex: state.nextZIndex++
+    })),
+    idMap
+  };
+}
+
+// src/engine/events.ts
+function createEventBus(opts) {
+  const listeners = /* @__PURE__ */ new Map();
+  const trace = [];
+  const queuedEvents = [];
+  let transactionDepth = 0;
+  function reportUnhandledError(error, context) {
+    if (opts.onUnhandledError) {
+      try {
+        opts.onUnhandledError(error, context);
+      } catch (reportingError) {
+        console.error(
+          `[board] onUnhandledError failed while reporting ${context.source}:`,
+          reportingError
+        );
+      }
+      return;
+    }
+    const subject = context.source === "event-listener" ? `handler for "${context.event}"` : context.source === "subscriber" ? `subscriber for "${context.channel}"` : `commit effect for "${context.commit}"`;
+    console.error(`[board] ${subject} threw:`, error);
+  }
+  function emit(event, ...args) {
+    if (transactionDepth > 0) {
+      queuedEvents.push({ event, args });
+      return;
+    }
+    publish(event, args);
+  }
+  function publish(event, args) {
+    if (opts.diagnosticsEnabled) {
+      trace.push({ event: String(event), timestamp: Date.now(), args });
+      if (trace.length > opts.traceLimit) {
+        trace.shift();
+      }
+    }
+    for (const handler of listeners.get(event) ?? []) {
+      try {
+        ;
+        handler(
+          ...args
+        );
+      } catch (error) {
+        reportUnhandledError(error, {
+          source: "event-listener",
+          event: String(event)
+        });
+      }
+    }
+  }
+  function emitImmediate(event, ...args) {
+    publish(event, args);
+  }
+  function on(event, handler) {
+    const set = listeners.get(event) ?? /* @__PURE__ */ new Set();
+    set.add(handler);
+    listeners.set(event, set);
+    return () => off(event, handler);
+  }
+  function once(event, handler) {
+    const unsubscribe = on(event, ((...args) => {
+      unsubscribe();
+      handler(...args);
+    }));
+    return unsubscribe;
+  }
+  function off(event, handler) {
+    listeners.get(event)?.delete(handler);
+  }
+  function exportTrace() {
+    return trace.map(
+      (entry) => Object.freeze({
+        ...entry,
+        args: Object.freeze([...entry.args])
+      })
+    );
+  }
+  function clear() {
+    listeners.clear();
+    trace.length = 0;
+    queuedEvents.length = 0;
+    transactionDepth = 0;
+  }
+  function beginTransaction() {
+    transactionDepth += 1;
+  }
+  function commitTransaction() {
+    if (transactionDepth === 0) return;
+    transactionDepth -= 1;
+    if (transactionDepth !== 0) return;
+    const events = queuedEvents.splice(0);
+    for (const entry of events) {
+      publishQueued(entry);
+    }
+  }
+  function publishQueued(entry) {
+    publish(
+      entry.event,
+      entry.args
+    );
+  }
+  function rollbackTransaction() {
+    if (transactionDepth === 0) return;
+    transactionDepth -= 1;
+    if (transactionDepth === 0) {
+      queuedEvents.length = 0;
+    }
+  }
+  return {
+    emit,
+    emitImmediate,
+    on,
+    once,
+    off,
+    exportTrace,
+    beginTransaction,
+    commitTransaction,
+    rollbackTransaction,
+    reportUnhandledError,
+    clear
+  };
+}
+
+// src/engine/command-runtime.ts
+var BATCH_COMMAND_METADATA = {
+  history: "record"
+};
+function createCommandGuardRegistry() {
+  const guards = [];
+  function add(fn) {
+    guards.push(fn);
+    return () => {
+      const index = guards.indexOf(fn);
+      if (index !== -1) guards.splice(index, 1);
+    };
+  }
+  function run(name, args, metadata) {
+    const command = Object.freeze({
+      name,
+      args: Object.freeze([...args]),
+      metadata: Object.freeze({ ...metadata })
+    });
+    for (const guard of guards) {
+      const result = guard(command);
+      if (result !== true) {
+        return result;
+      }
+    }
+    return null;
+  }
+  return {
+    add,
+    run,
+    clear: () => {
+      guards.length = 0;
+    }
+  };
+}
+function createValidator(deps) {
+  return function validate(context) {
+    const failures = validateState(deps.getState(), deps.getGrid(), context);
+    for (const failure of failures) {
+      deps.emitFailure(failure);
+    }
+    if (failures.length > 0) {
+      throw new BoardInputError(
+        `Board validation failed in ${context}: ${failures[0]?.message}`
+      );
+    }
+  };
+}
+function createBatchCommandController(deps) {
+  let depth = 0;
+  let startedAt = 0;
+  let validationPending = false;
+  let hasFailed = false;
+  let failure;
+  function flushBatchNotifications() {
+    const pending = [...deps.batchCtrl.pending];
+    deps.batchCtrl.pending.clear();
+    deps.batchCtrl.rollbacks.clear();
+    for (const flush of pending) flush();
+  }
+  function rollbackBatchNotifications() {
+    const rollbacks = [...deps.batchCtrl.rollbacks];
+    deps.batchCtrl.pending.clear();
+    deps.batchCtrl.rollbacks.clear();
+    for (const rollback of rollbacks) rollback();
+  }
+  function begin() {
+    if (depth === 0) {
+      startedAt = performance.now();
+      deps.batchCtrl.depth += 1;
+      deps.emitCommandBefore("batch", [], BATCH_COMMAND_METADATA);
+    }
+    depth += 1;
+  }
+  function end(beforePublish) {
+    depth -= 1;
+    if (depth !== 0) return;
+    try {
+      if (hasFailed) {
+        throw failure;
+      }
+      if (validationPending) {
+        deps.validate("batch");
+      }
+      beforePublish?.();
+      deps.batchCtrl.depth -= 1;
+      flushBatchNotifications();
+    } catch (error) {
+      deps.batchCtrl.depth -= 1;
+      rollbackBatchNotifications();
+      throw error;
+    } finally {
+      validationPending = false;
+      hasFailed = false;
+      failure = void 0;
+    }
+    deps.emitCommandAfter(
+      "batch",
+      [],
+      performance.now() - startedAt,
+      BATCH_COMMAND_METADATA
+    );
+  }
+  function batch(fn, beforePublish) {
+    begin();
+    try {
+      fn();
+    } catch (error) {
+      if (!hasFailed) {
+        hasFailed = true;
+        failure = error;
+      }
+      depth -= 1;
+      if (depth === 0) {
+        validationPending = false;
+        deps.batchCtrl.depth -= 1;
+        rollbackBatchNotifications();
+        hasFailed = false;
+        failure = void 0;
+      }
+      throw error;
+    }
+    end(beforePublish);
+  }
+  return {
+    isBatching: () => depth > 0,
+    markValidationPending: () => {
+      validationPending = true;
+    },
+    begin,
+    end,
+    batch,
+    flushBatchNotifications,
+    rollbackBatchNotifications
+  };
+}
+
+// src/subscribable.ts
+function createBatchController() {
+  return { depth: 0, pending: /* @__PURE__ */ new Set(), rollbacks: /* @__PURE__ */ new Set() };
+}
+function createSubscribable(initial, batch, reportError) {
+  let current = initial;
+  let prev = initial;
+  let transactionPrev;
+  let hasTransactionPrev = false;
+  let destroyed = false;
+  const listeners = /* @__PURE__ */ new Set();
+  function assertActive() {
+    if (destroyed) {
+      throw new BoardDestroyedError();
+    }
+  }
+  function notify() {
+    assertActive();
+    if (batch.depth > 0) {
+      batch.pending.add(flush);
+      return;
+    }
+    flush();
+  }
+  function flush() {
+    assertActive();
+    const snapshot = current;
+    const prevSnapshot = hasTransactionPrev ? transactionPrev : prev;
+    prev = current;
+    transactionPrev = void 0;
+    hasTransactionPrev = false;
+    for (const fn of listeners) {
+      try {
+        fn(snapshot, prevSnapshot);
+      } catch (error) {
+        reportError(error);
+      }
+    }
+  }
+  return {
+    get() {
+      assertActive();
+      return current;
+    },
+    set(value) {
+      assertActive();
+      if (batch.depth > 0 && !hasTransactionPrev) {
+        transactionPrev = current;
+        hasTransactionPrev = true;
+        batch.rollbacks.add(rollback);
+      }
+      prev = current;
+      current = value;
+      notify();
+    },
+    subscribe(callback) {
+      assertActive();
+      listeners.add(callback);
+      return () => {
+        listeners.delete(callback);
+      };
+    },
+    notify,
+    destroy() {
+      destroyed = true;
+      listeners.clear();
+      batch.pending.delete(flush);
+      batch.rollbacks.delete(rollback);
+    }
+  };
+  function rollback() {
+    if (!hasTransactionPrev) return;
+    current = transactionPrev;
+    prev = transactionPrev;
+    transactionPrev = void 0;
+    hasTransactionPrev = false;
+  }
+}
+
+// src/engine/options.ts
+function requireFinite(name, value) {
+  if (!Number.isFinite(value)) {
+    throw new BoardInputError(`${name} must be a finite number.`);
+  }
+}
+function requirePositive(name, value) {
+  requireFinite(name, value);
+  if (value <= 0) {
+    throw new BoardInputError(`${name} must be greater than 0.`);
+  }
+}
+function validateCamera(camera) {
+  requireFinite("camera.x", camera.x);
+  requireFinite("camera.y", camera.y);
+  requirePositive("camera.z", camera.z);
+}
+function validateGridSettings(grid) {
+  requirePositive("grid.size", grid.size);
+  requirePositive("grid.majorEvery", grid.majorEvery);
+  requirePositive("grid.edgeSnapThreshold", grid.edgeSnapThreshold);
+  if (!Number.isInteger(grid.majorEvery)) {
+    throw new BoardInputError("grid.majorEvery must be an integer.");
+  }
+  if (typeof grid.snap !== "boolean" || typeof grid.edgeSnap !== "boolean") {
+    throw new BoardInputError("grid snap settings must be boolean values.");
+  }
+  if (!["dot", "line", "cross", "none"].includes(grid.pattern)) {
+    throw new BoardInputError(
+      `Grid pattern "${String(grid.pattern)}" is unsupported.`
+    );
+  }
+}
+function validateBoardConfiguration(config) {
+  validateCamera(config.camera);
+  requirePositive("zoom.min", config.zoom.min);
+  requirePositive("zoom.max", config.zoom.max);
+  if (config.zoom.min > config.zoom.max) {
+    throw new BoardInputError(
+      "zoom.min must be less than or equal to zoom.max."
+    );
+  }
+  validateGridSettings(config.grid);
+  if (!["autocad", "contain", "intersect"].includes(config.boxSelectBehavior)) {
+    throw new BoardInputError(
+      `Box-select behavior "${String(config.boxSelectBehavior)}" is unsupported.`
+    );
+  }
+  requirePositive("nodes.minWidth", config.nodeConstraints.minWidth);
+  requirePositive("nodes.minHeight", config.nodeConstraints.minHeight);
+  requirePositive("nodes.defaultWidth", config.nodeConstraints.defaultWidth);
+  requirePositive("nodes.defaultHeight", config.nodeConstraints.defaultHeight);
+  if (config.nodeConstraints.defaultWidth < config.nodeConstraints.minWidth) {
+    throw new BoardInputError(
+      "nodes.defaultWidth must be greater than or equal to nodes.minWidth."
+    );
+  }
+  if (config.nodeConstraints.defaultHeight < config.nodeConstraints.minHeight) {
+    throw new BoardInputError(
+      "nodes.defaultHeight must be greater than or equal to nodes.minHeight."
+    );
+  }
+  if (typeof config.diagnostics === "object") {
+    const limit = config.diagnostics.traceLimit;
+    if (limit !== void 0 && (!Number.isInteger(limit) || limit < 0)) {
+      throw new BoardInputError(
+        "diagnostics.traceLimit must be a non-negative integer."
+      );
+    }
+  }
+  const pluginNames = /* @__PURE__ */ new Set();
+  for (const plugin of config.plugins) {
+    if (pluginNames.has(plugin.name)) {
+      throw new BoardConflictError(
+        `Board plugin name "${plugin.name}" is registered more than once.`
+      );
+    }
+    pluginNames.add(plugin.name);
+  }
+}
+
+// src/engine/subscribables.ts
+function createReactiveLayer(deps) {
+  const { getState, getGrid, emit, getEffectiveNodes, reportSubscriberError } = deps;
+  const initialState = getState();
+  const initialGrid = getGrid();
+  const batchCtrl = createBatchController();
+  const $camera = createSubscribable(
+    freezeClone({ ...initialState.camera }),
+    batchCtrl,
+    (error) => reportSubscriberError("$camera", error)
+  );
+  const $grid = createSubscribable(
+    freezeClone({ ...initialGrid }),
+    batchCtrl,
+    (error) => reportSubscriberError("$grid", error)
+  );
+  const $nodes = createSubscribable(
+    readonlyMapView(/* @__PURE__ */ new Map()),
+    batchCtrl,
+    (error) => reportSubscriberError("$nodes", error)
+  );
+  const $selection = createSubscribable(
+    readonlySetView(new Set(initialState.selection)),
+    batchCtrl,
+    (error) => reportSubscriberError("$selection", error)
+  );
+  const $interaction = createSubscribable(
+    cloneInteraction(initialState.interaction),
+    batchCtrl,
+    (error) => reportSubscriberError("$interaction", error)
+  );
+  const $snapGuides = createSubscribable(
+    initialState.snapGuides.map((guide) => freezeClone({ ...guide })),
+    batchCtrl,
+    (error) => reportSubscriberError("$snapGuides", error)
+  );
+  let cachedPublicNodeMap = null;
+  function getPublicNodeMap() {
+    if (!cachedPublicNodeMap) {
+      cachedPublicNodeMap = buildPublicNodeMap({ nodes: getEffectiveNodes() });
+    }
+    return cachedPublicNodeMap;
+  }
+  function invalidateNodeCache() {
+    cachedPublicNodeMap = null;
+  }
+  function notifyNodesChanged() {
+    cachedPublicNodeMap = null;
+    if (batchCtrl.depth > 0) {
+      batchCtrl.pending.add(publishNodes);
+      return;
+    }
+    publishNodes();
+  }
+  function publishNodes() {
+    $nodes.set(readonlyMapView(getPublicNodeMap()));
+  }
+  function notifyCameraChanged() {
+    $camera.set(freezeClone({ ...getState().camera }));
+  }
+  function notifyGridChanged() {
+    $grid.set(freezeClone({ ...getGrid() }));
+  }
+  function notifySelectionChanged() {
+    $selection.set(readonlySetView(new Set(getState().selection)));
+  }
+  function notifyInteractionChanged() {
+    $interaction.set(cloneInteraction(getState().interaction));
+  }
+  function notifySnapGuidesChanged() {
+    $snapGuides.set(
+      getState().snapGuides.map((guide) => freezeClone({ ...guide }))
+    );
+  }
+  function setCamera(next) {
+    validateCamera(next);
+    const state = getState();
+    const prev = { ...state.camera };
+    if (prev.x === next.x && prev.y === next.y && prev.z === next.z) return;
+    state.camera = next;
+    $camera.set(freezeClone({ ...next }));
+    emit("camera:change", freezeClone({ ...next }), freezeClone(prev));
+  }
+  function setSelection(nextSelection) {
+    const state = getState();
+    const prev = Array.from(state.selection.values());
+    const next = Array.from(nextSelection);
+    if (sameArray(prev, next)) return;
+    state.selection = new Set(next);
+    notifySelectionChanged();
+    emit("selection:change", next, prev);
+  }
+  function setInteraction(next) {
+    const state = getState();
+    const prev = state.interaction;
+    state.interaction = next;
+    notifyInteractionChanged();
+    if (prev.mode === "idle" && next.mode !== "idle") {
+      emit("interaction:start", cloneInteraction(next));
+      return;
+    }
+    if (prev.mode !== "idle" && next.mode === "idle") {
+      emit("interaction:end", cloneInteraction(prev));
+      return;
+    }
+    if (prev.mode !== "idle" && next.mode !== "idle") {
+      emit("interaction:update", cloneInteraction(next));
+    }
+  }
+  function setSnapGuides(next) {
+    const state = getState();
+    state.snapGuides = next;
+    notifySnapGuidesChanged();
+  }
+  function destroy() {
+    $camera.destroy();
+    $grid.destroy();
+    $nodes.destroy();
+    $selection.destroy();
+    $interaction.destroy();
+    $snapGuides.destroy();
+    batchCtrl.pending.clear();
+    batchCtrl.rollbacks.clear();
+  }
+  return {
+    batchCtrl,
+    $camera,
+    $grid,
+    $nodes,
+    $selection,
+    $interaction,
+    $snapGuides,
+    getPublicNodeMap,
+    invalidateNodeCache,
+    notifyNodesChanged,
+    notifyCameraChanged,
+    notifyGridChanged,
+    notifySelectionChanged,
+    notifyInteractionChanged,
+    notifySnapGuidesChanged,
+    setCamera,
+    setSelection,
+    setInteraction,
+    setSnapGuides,
+    destroy
+  };
+}
+
+// src/engine/transaction.ts
+function createTransactionExecutor(deps) {
+  const defaultMetadata = { history: "record" };
+  function prepare(name, args, metadata, emitBefore) {
+    deps.assertAlive();
+    const blockedReason = deps.runGuard(name, args, metadata);
+    if (blockedReason) {
+      deps.emitBlocked(name, args, metadata);
+      throw deps.createBlockedError(name, args, blockedReason);
+    }
+    if (emitBefore) deps.emitBefore(name, args, metadata);
+  }
+  function runCommand(name, args, fn, metadata = defaultMetadata, commitOverride) {
+    const inBatch = deps.isBatching();
+    prepare(name, args, metadata, false);
+    const started = performance.now();
+    const ownsEffects = deps.canOwnEffects();
+    if (ownsEffects) deps.beginEffects();
+    if (!inBatch) deps.emitBefore(name, args, metadata);
+    let historyBefore = ownsEffects ? deps.captureHistoryRoot() : null;
+    const checkpoint = ownsEffects && metadata.validate !== false ? deps.beginPersistentTransaction() : null;
+    try {
+      historyBefore = deps.beforeExecute(name, metadata, historyBefore) ?? historyBefore;
+      const result = fn();
+      if (metadata.validate !== false) {
+        if (inBatch) deps.markValidationPending();
+        else deps.validate(name);
+      }
+      const commitBefore = commitOverride?.before ?? historyBefore;
+      const preparedCommit = commitBefore ? deps.prepareCommit(
+        commitOverride?.label ?? name,
+        commitOverride?.metadata ?? metadata,
+        commitBefore
+      ) : null;
+      const commitErrors = preparedCommit?.finalize() ?? [];
+      if (!inBatch) {
+        deps.emitAfter(name, args, performance.now() - started, metadata);
+      }
+      if (ownsEffects) deps.commitEffects();
+      for (const error of commitErrors) {
+        deps.reportCommitError(preparedCommit.label, error);
+      }
+      return result;
+    } catch (error) {
+      if (checkpoint) deps.rollbackPersistentTransaction(checkpoint);
+      if (ownsEffects) deps.rollbackEffects();
+      throw error;
+    }
+  }
+  async function runAsyncCommand(name, args, fn, metadata = defaultMetadata) {
+    prepare(name, args, metadata, false);
+    const started = performance.now();
+    try {
+      const result = await fn();
+      if (metadata.validate !== false) deps.validate(name);
+      deps.emitBefore(name, args, metadata);
+      deps.emitAfter(name, args, performance.now() - started, metadata);
+      return result;
+    } catch (error) {
+      if (deps.isCancellation(error)) return void 0;
+      throw error;
+    }
+  }
+  return { runCommand, runAsyncCommand };
+}
+function stagePersistentRoots(roots) {
+  return {
+    state: {
+      camera: { ...roots.state.camera },
+      nodes: new Map(roots.state.nodes),
+      selection: new Set(roots.state.selection),
+      interaction: cloneInteraction(roots.state.interaction),
+      snapGuides: roots.state.snapGuides.map((guide) => ({ ...guide })),
+      nextZIndex: roots.state.nextZIndex
+    },
+    grid: { ...roots.grid },
+    pluginStates: new Map(
+      Array.from(roots.pluginStates, ([name, pluginState]) => [
+        name,
+        { state: pluginState.state }
+      ])
+    )
+  };
+}
+
+// src/colors.ts
+var BOARD_COLOR_PRESETS = [
+  { preset: "1", hex: "#e5476a", label: "Rose" },
+  { preset: "2", hex: "#d97a1c", label: "Amber" },
+  { preset: "3", hex: "#b89a14", label: "Citron" },
+  { preset: "4", hex: "#2fa560", label: "Moss" },
+  { preset: "5", hex: "#3b7de0", label: "Azure" },
+  { preset: "6", hex: "#7e5ae4", label: "Violet" }
+];
+function isBoardColorPreset(value) {
+  return typeof value === "string" && BOARD_COLOR_PRESETS.some((option) => option.preset === value);
+}
+function colorForPreset(preset) {
+  if (!preset) {
+    return "";
+  }
+  return BOARD_COLOR_PRESETS.find((option) => option.preset === preset)?.hex ?? "";
+}
+
+// src/engine/persistence.ts
+var JSON_CANVAS_NODE_TYPES = /* @__PURE__ */ new Set([
+  "text",
+  "file",
+  "link",
+  "group"
+]);
+var JSON_CANVAS_SIDES = /* @__PURE__ */ new Set([
+  "top",
+  "right",
+  "bottom",
+  "left"
+]);
+var JSON_CANVAS_EDGE_ENDS = /* @__PURE__ */ new Set(["none", "arrow"]);
+var JSON_CANVAS_BACKGROUND_STYLES = /* @__PURE__ */ new Set(["cover", "ratio", "repeat"]);
+function isJsonCanvasNodeType(value) {
+  return typeof value === "string" && JSON_CANVAS_NODE_TYPES.has(value);
+}
+function normalizeNodeType(value) {
+  if (value === void 0) return "text";
+  if (isJsonCanvasNodeType(value)) return value;
+  throw new BoardInputError(
+    `Unsupported JSON Canvas node type "${String(value)}".`
+  );
+}
+function withNodeFields(base, input) {
+  switch (base.type) {
+    case "file":
+      return {
+        ...base,
+        file: typeof input.file === "string" ? input.file : "",
+        ...typeof input.subpath === "string" ? { subpath: input.subpath } : {}
+      };
+    case "link":
+      return {
+        ...base,
+        url: typeof input.url === "string" ? input.url : ""
+      };
+    case "group":
+      return {
+        ...base,
+        ...typeof input.label === "string" ? { label: input.label } : {},
+        ...typeof input.background === "string" ? { background: input.background } : {},
+        ...input.backgroundStyle === "cover" || input.backgroundStyle === "ratio" || input.backgroundStyle === "repeat" ? { backgroundStyle: input.backgroundStyle } : {}
+      };
+    case "text":
+    default:
+      return {
+        ...base,
+        text: typeof input.text === "string" ? input.text : ""
+      };
+  }
+}
+function validateJsonCanvasNodeFields(node) {
+  if (node.color !== void 0 && !isBoardColorPreset(node.color) && !/^#[0-9a-fA-F]{6}$/.test(node.color)) {
+    throw new BoardInputError(
+      `Invalid board document: node "${node.id}" has invalid color.`
+    );
+  }
+  if (node.type === "text" && typeof node.text !== "string") {
+    throw new BoardInputError(
+      `Invalid board document: text node "${node.id}" is missing required text.`
+    );
+  }
+  if (node.type === "file" && typeof node.file !== "string") {
+    throw new BoardInputError(
+      `Invalid board document: file node "${node.id}" is missing required file.`
+    );
+  }
+  if (node.type === "link" && typeof node.url !== "string") {
+    throw new BoardInputError(
+      `Invalid board document: link node "${node.id}" is missing required url.`
+    );
+  }
+}
+function jsonNodeToBoardNode(node, meta, index) {
+  validateJsonCanvasNodeFields(node);
+  const base = {
+    id: node.id,
+    type: node.type,
+    x: node.x,
+    y: node.y,
+    width: node.width,
+    height: node.height,
+    ...node.color !== void 0 ? { color: node.color } : {},
+    zIndex: Number.isFinite(meta?.zIndex) ? meta.zIndex : index + 1,
+    locked: Boolean(meta?.locked),
+    visible: meta?.visible !== false,
+    ...typeof meta?.parentId === "string" ? { parentId: meta.parentId } : {}
+  };
+  return withNodeFields(base, node);
+}
+function boardNodeToJsonNode(node) {
+  const base = {
+    id: node.id,
+    type: node.type,
+    x: node.x,
+    y: node.y,
+    width: node.width,
+    height: node.height,
+    ...node.color !== void 0 ? { color: node.color } : {}
+  };
+  switch (node.type) {
+    case "file":
+      return {
+        ...base,
+        type: "file",
+        file: node.file ?? "",
+        ...node.subpath !== void 0 ? { subpath: node.subpath } : {}
+      };
+    case "link":
+      return { ...base, type: "link", url: node.url ?? "" };
+    case "group":
+      return {
+        ...base,
+        type: "group",
+        ...node.label !== void 0 ? { label: node.label } : {},
+        ...node.background !== void 0 ? { background: node.background } : {},
+        ...node.backgroundStyle !== void 0 ? { backgroundStyle: node.backgroundStyle } : {}
+      };
+    case "text":
+    default:
+      return { ...base, type: "text", text: node.text ?? "" };
+  }
+}
+function mergeMetadata(base, patch) {
+  if (!patch) return base;
+  return {
+    ...base,
+    ...patch,
+    nodes: base.nodes || patch.nodes ? { ...base.nodes ?? {}, ...patch.nodes ?? {} } : void 0,
+    edges: base.edges || patch.edges ? { ...base.edges ?? {}, ...patch.edges ?? {} } : void 0
+  };
+}
+function getDocumentMetadata(document) {
+  return document["x-vue-board"];
+}
+function toPersistedDocument(snapshot, featureDocuments) {
+  let metadata = {
+    camera: snapshot.camera,
+    grid: snapshot.grid,
+    selection: snapshot.selection,
+    nextZIndex: snapshot.nextZIndex,
+    nodes: Object.fromEntries(
+      snapshot.nodes.map((node) => [
+        node.id,
+        {
+          zIndex: node.zIndex,
+          locked: node.locked,
+          visible: node.visible,
+          ...node.parentId !== void 0 ? { parentId: node.parentId } : {}
+        }
+      ])
+    )
+  };
+  let edges;
+  for (const featureDocument of featureDocuments) {
+    if (featureDocument.edges !== void 0) {
+      edges = featureDocument.edges;
+    }
+    metadata = mergeMetadata(metadata, getDocumentMetadata(featureDocument));
+  }
+  return {
+    nodes: snapshot.nodes.map((node) => boardNodeToJsonNode(node)),
+    ...edges !== void 0 ? { edges } : {},
+    "x-vue-board": metadata
+  };
+}
+function isRecord(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function assertRecord(value, message) {
+  if (!isRecord(value)) {
+    throw new BoardInputError(message);
+  }
+  return value;
+}
+function assertOptionalFiniteNumber(value, message) {
+  if (value !== void 0 && !Number.isFinite(value)) {
+    throw new BoardInputError(message);
+  }
+}
+function assertOptionalBoolean(value, message) {
+  if (value !== void 0 && typeof value !== "boolean") {
+    throw new BoardInputError(message);
+  }
+}
+function validateDocumentMetadata(metadata) {
+  if (metadata === void 0) return;
+  const meta = assertRecord(
+    metadata,
+    "Invalid board document: board metadata must be an object."
+  );
+  if (meta.camera !== void 0) {
+    const camera = assertRecord(
+      meta.camera,
+      "Invalid board document: board metadata camera must be an object."
+    );
+    for (const key of ["x", "y", "z"]) {
+      assertOptionalFiniteNumber(
+        camera[key],
+        `Invalid board document: board metadata camera.${key} must be finite.`
+      );
+    }
+  }
+  if (meta.grid !== void 0) {
+    const grid = assertRecord(
+      meta.grid,
+      "Invalid board document: board metadata grid must be an object."
+    );
+    for (const key of ["size", "majorEvery", "edgeSnapThreshold"]) {
+      assertOptionalFiniteNumber(
+        grid[key],
+        `Invalid board document: board metadata grid.${key} must be finite.`
+      );
+    }
+    assertOptionalBoolean(
+      grid.snap,
+      "Invalid board document: board metadata grid.snap must be boolean."
+    );
+    assertOptionalBoolean(
+      grid.edgeSnap,
+      "Invalid board document: board metadata grid.edgeSnap must be boolean."
+    );
+    if (grid.pattern !== void 0 && grid.pattern !== "dot" && grid.pattern !== "line" && grid.pattern !== "cross" && grid.pattern !== "none") {
+      throw new BoardInputError(
+        `Invalid board document: board metadata grid.pattern "${String(grid.pattern)}" is unsupported.`
+      );
+    }
+  }
+  if (meta.selection !== void 0 && !Array.isArray(meta.selection)) {
+    throw new BoardInputError(
+      "Invalid board document: board metadata selection must be an array."
+    );
+  }
+  if (Array.isArray(meta.selection) && meta.selection.some((id) => typeof id !== "string")) {
+    throw new BoardInputError(
+      "Invalid board document: board metadata selection must contain only node IDs."
+    );
+  }
+  assertOptionalFiniteNumber(
+    meta.nextZIndex,
+    "Invalid board document: board metadata nextZIndex must be finite."
+  );
+  if (meta.nextZIndex !== void 0 && (!Number.isInteger(meta.nextZIndex) || meta.nextZIndex < 1)) {
+    throw new BoardInputError(
+      "Invalid board document: board metadata nextZIndex must be a positive integer."
+    );
+  }
+  if (meta.nodes !== void 0) {
+    const nodes = assertRecord(
+      meta.nodes,
+      "Invalid board document: board metadata nodes must be an object."
+    );
+    for (const [id, nodeMeta] of Object.entries(nodes)) {
+      const node = assertRecord(
+        nodeMeta,
+        `Invalid board document: metadata for node "${id}" must be an object.`
+      );
+      assertOptionalFiniteNumber(
+        node.zIndex,
+        `Invalid board document: metadata for node "${id}" has invalid zIndex.`
+      );
+      assertOptionalBoolean(
+        node.locked,
+        `Invalid board document: metadata for node "${id}" has invalid locked flag.`
+      );
+      assertOptionalBoolean(
+        node.visible,
+        `Invalid board document: metadata for node "${id}" has invalid visible flag.`
+      );
+      if (node.parentId !== void 0 && typeof node.parentId !== "string") {
+        throw new BoardInputError(
+          `Invalid board document: metadata for node "${id}" has invalid parentId.`
+        );
+      }
+    }
+  }
+  if (meta.edges !== void 0) {
+    const edges = assertRecord(
+      meta.edges,
+      "Invalid board document: board metadata edges must be an object."
+    );
+    for (const [id, edgeMeta] of Object.entries(edges)) {
+      const edge = assertRecord(
+        edgeMeta,
+        `Invalid board document: metadata for edge "${id}" must be an object.`
+      );
+      assertOptionalFiniteNumber(
+        edge.zIndex,
+        `Invalid board document: metadata for edge "${id}" has invalid zIndex.`
+      );
+      if (edge.data !== void 0 && !isRecord(edge.data)) {
+        throw new BoardInputError(
+          `Invalid board document: metadata for edge "${id}" has invalid data.`
+        );
+      }
+    }
+  }
+}
+function normalizeDocumentForImport(raw) {
+  const parsed = assertRecord(
+    raw,
+    "Invalid board document: document must be an object."
+  );
+  if (!Array.isArray(parsed.nodes)) {
+    throw new BoardInputError("Invalid board document: missing nodes array.");
+  }
+  for (const key of [
+    "camera",
+    "grid",
+    "selection",
+    "interaction",
+    "snapGuides",
+    "nextZIndex"
+  ]) {
+    if (key in parsed) {
+      throw new BoardInputError(
+        `Invalid board document: runtime field "${key}" belongs under x-vue-board.`
+      );
+    }
+  }
+  validateDocumentMetadata(getDocumentMetadata(parsed));
+  const seenNodes = /* @__PURE__ */ new Set();
+  const nodes = parsed.nodes.map((node) => {
+    if (!isRecord(node)) {
+      throw new BoardInputError(
+        "Invalid board document: node entries must be objects."
+      );
+    }
+    if (typeof node.id !== "string" || typeof node.x !== "number" || typeof node.y !== "number" || typeof node.width !== "number" || typeof node.height !== "number" || !Number.isFinite(node.x) || !Number.isFinite(node.y) || !Number.isFinite(node.width) || !Number.isFinite(node.height) || node.width <= 0 || node.height <= 0) {
+      throw new BoardInputError(
+        `Invalid board document: node "${String(node.id ?? "?")}" has invalid geometry.`
+      );
+    }
+    if (!isJsonCanvasNodeType(node.type)) {
+      throw new BoardInputError(
+        `Invalid board document: node "${String(node.id)}" has unsupported type "${String(node.type)}".`
+      );
+    }
+    if (node.type === "group" && node.backgroundStyle !== void 0 && !JSON_CANVAS_BACKGROUND_STYLES.has(String(node.backgroundStyle))) {
+      throw new BoardInputError(
+        `Invalid board document: node "${String(node.id)}" has unsupported backgroundStyle "${String(node.backgroundStyle)}".`
+      );
+    }
+    const normalized = { ...node };
+    validateJsonCanvasNodeFields(normalized);
+    if (seenNodes.has(normalized.id)) {
+      throw new BoardInputError(
+        `Invalid board document: duplicate node id "${normalized.id}".`
+      );
+    }
+    seenNodes.add(normalized.id);
+    return normalized;
+  });
+  let edges;
+  if (parsed.edges !== void 0) {
+    if (!Array.isArray(parsed.edges)) {
+      throw new BoardInputError(
+        "Invalid board document: edges must be an array."
+      );
+    }
+    const seenEdges = /* @__PURE__ */ new Set();
+    edges = parsed.edges.map((edge) => {
+      if (!isRecord(edge)) {
+        throw new BoardInputError(
+          "Invalid board document: edge entries must be objects."
+        );
+      }
+      if (typeof edge.id !== "string" || typeof edge.fromNode !== "string" || typeof edge.toNode !== "string") {
+        throw new BoardInputError(
+          `Invalid board document: edge "${String(edge.id ?? "?")}" has invalid endpoints.`
+        );
+      }
+      const id = edge.id;
+      const fromNode = edge.fromNode;
+      const toNode = edge.toNode;
+      if (seenEdges.has(id)) {
+        throw new BoardInputError(
+          `Invalid board document: duplicate edge id "${id}".`
+        );
+      }
+      seenEdges.add(id);
+      if (!seenNodes.has(fromNode) || !seenNodes.has(toNode)) {
+        throw new BoardInputError(
+          `Invalid board document: edge "${id}" references a missing node.`
+        );
+      }
+      if (edge.fromSide !== void 0 && !JSON_CANVAS_SIDES.has(edge.fromSide)) {
+        throw new BoardInputError(
+          `Invalid board document: edge "${id}" has unsupported fromSide "${String(edge.fromSide)}".`
+        );
+      }
+      if (edge.toSide !== void 0 && !JSON_CANVAS_SIDES.has(edge.toSide)) {
+        throw new BoardInputError(
+          `Invalid board document: edge "${id}" has unsupported toSide "${String(edge.toSide)}".`
+        );
+      }
+      if (edge.fromEnd !== void 0 && !JSON_CANVAS_EDGE_ENDS.has(edge.fromEnd)) {
+        throw new BoardInputError(
+          `Invalid board document: edge "${id}" has unsupported fromEnd "${String(edge.fromEnd)}".`
+        );
+      }
+      if (edge.toEnd !== void 0 && !JSON_CANVAS_EDGE_ENDS.has(edge.toEnd)) {
+        throw new BoardInputError(
+          `Invalid board document: edge "${id}" has unsupported toEnd "${String(edge.toEnd)}".`
+        );
+      }
+      if (edge.label !== void 0 && typeof edge.label !== "string") {
+        throw new BoardInputError(
+          `Invalid board document: edge "${id}" has invalid label.`
+        );
+      }
+      return { ...edge, id, fromNode, toNode };
+    });
+  }
+  return {
+    nodes,
+    ...edges !== void 0 ? { edges } : {},
+    ...getDocumentMetadata(parsed) !== void 0 ? { "x-vue-board": getDocumentMetadata(parsed) } : {}
+  };
+}
+function materializeSnapshotNodes(snapshot) {
+  return [...snapshot.nodes];
+}
+function documentToSnapshot(document) {
+  const metadata = getDocumentMetadata(document);
+  const nodes = document.nodes.map(
+    (node, index) => normalizeExistingNode(
+      jsonNodeToBoardNode(node, metadata?.nodes?.[node.id], index)
+    )
+  );
+  const gridSettings = {
+    ...DEFAULT_GRID,
+    ...metadata?.grid ?? {}
+  };
+  const selection = Array.isArray(metadata?.selection) ? metadata.selection.filter(
+    (id) => typeof id === "string" && nodes.some((node) => node.id === id)
+  ).map((id) => id) : [];
+  const nextZIndex = metadata?.nextZIndex ?? nodes.reduce((max, node) => Math.max(max, node.zIndex), 0) + 1;
+  const camera = { ...DEFAULT_CAMERA, ...metadata?.camera ?? {} };
+  const snapshot = {
+    camera,
+    grid: gridSettings,
+    nodes,
+    selection,
+    interaction: { mode: "idle" },
+    snapGuides: [],
+    nextZIndex
+  };
+  const failures = validateState(
+    {
+      camera,
+      grid: gridSettings,
+      nodes: new Map(nodes.map((node) => [node.id, node])),
+      selection: new Set(selection),
+      interaction: { mode: "idle" },
+      snapGuides: []
+    },
+    gridSettings,
+    "loadDocument"
+  );
+  if (failures.length > 0) {
+    throw new BoardInputError(
+      `Invalid board document: ${failures[0]?.message ?? "invariant failed."}`
+    );
+  }
+  return snapshot;
+}
+
+// src/engine/camera-session.ts
+function createCameraSession(deps) {
+  let animationToken = 0;
+  function cancelAnimations() {
+    animationToken += 1;
+  }
+  async function animateTo(target) {
+    validateCamera(target);
+    animationToken += 1;
+    const token = animationToken;
+    const start = { ...deps.getCamera() };
+    const started = performance.now();
+    const duration = 280;
+    const { raf } = getAnimationFrameDriver();
+    await new Promise((resolve, reject) => {
+      const tick = () => {
+        if (token !== animationToken) {
+          reject(new AnimationCancelled());
+          return;
+        }
+        const elapsed = performance.now() - started;
+        const t = clamp(elapsed / duration, 0, 1);
+        const eased = 1 - Math.pow(1 - t, 3);
+        deps.setCamera(lerpCamera(start, target, eased));
+        if (t < 1) raf(tick);
+        else resolve();
+      };
+      raf(tick);
+    });
+  }
+  function computeFit(ids, padding = 40) {
+    const idSet = ids ? new Set(ids) : null;
+    const source = Array.from(deps.getNodes()).filter(
+      (node) => node.visible && (!idSet || idSet.has(node.id))
+    );
+    if (source.length === 0) return null;
+    const bounds = source.reduce((acc, node) => {
+      const current = getBoundsFromNode(node);
+      return {
+        minX: Math.min(acc.minX, current.minX),
+        minY: Math.min(acc.minY, current.minY),
+        maxX: Math.max(acc.maxX, current.maxX),
+        maxY: Math.max(acc.maxY, current.maxY)
+      };
+    }, getBoundsFromNode(source[0]));
+    const viewport = deps.getViewportSize();
+    const width = Math.max(1, bounds.maxX - bounds.minX);
+    const height = Math.max(1, bounds.maxY - bounds.minY);
+    const zoomLevel = clamp(
+      Math.min(
+        (viewport.x - padding * 2) / width,
+        (viewport.y - padding * 2) / height
+      ),
+      deps.zoom.min,
+      deps.zoom.max
+    );
+    const center = {
+      x: (bounds.minX + bounds.maxX) / 2,
+      y: (bounds.minY + bounds.maxY) / 2
+    };
+    return {
+      x: viewport.x / (2 * zoomLevel) - center.x,
+      y: viewport.y / (2 * zoomLevel) - center.y,
+      z: zoomLevel
+    };
+  }
+  return { animateTo, cancelAnimations, computeFit };
+}
+
+// src/engine/node-shape.ts
+function assertValidNodeGeometry(id, geometry) {
+  if (!Number.isFinite(geometry.x) || !Number.isFinite(geometry.y) || !Number.isFinite(geometry.width) || !Number.isFinite(geometry.height) || geometry.width <= 0 || geometry.height <= 0) {
+    throw new BoardInputError(`Invalid node geometry for "${id}".`);
+  }
+}
+function assertValidParentLink(nodes, id, parentId) {
+  if (parentId === void 0) return;
+  if (parentId === id) {
+    throw new BoardInputError(`Node "${id}" cannot be its own parent.`);
+  }
+  const parent = nodes.get(parentId);
+  if (!parent) {
+    throw new BoardInputError(
+      `Node "${id}" references missing parent "${parentId}".`
+    );
+  }
+  if (parent.type !== "group") {
+    throw new BoardInputError(
+      `Node "${id}" parent "${parentId}" must be a group.`
+    );
+  }
+  let walk = parent;
+  const seen = /* @__PURE__ */ new Set();
+  while (walk) {
+    if (walk.id === id || seen.has(walk.id)) {
+      throw new BoardInputError(`Node "${id}" cannot create a parent cycle.`);
+    }
+    seen.add(walk.id);
+    walk = walk.parentId ? nodes.get(walk.parentId) : void 0;
+  }
+}
+function normalizeNodeInput(input, context) {
+  const { nodes, grid, constraints } = context;
+  const rawPoint = { x: input.x ?? 0, y: input.y ?? 0 };
+  const point = grid.snap ? snapPoint(rawPoint, grid.size) : rawPoint;
+  const width = grid.snap ? snapSize(
+    input.width ?? constraints.defaultWidth,
+    grid.size,
+    constraints.minWidth
+  ) : input.width ?? constraints.defaultWidth;
+  const height = grid.snap ? snapSize(
+    input.height ?? constraints.defaultHeight,
+    grid.size,
+    constraints.minHeight
+  ) : input.height ?? constraints.defaultHeight;
+  const type = normalizeNodeType(input.type);
+  const parentId = typeof input.parentId === "string" && input.parentId.length > 0 ? input.parentId : void 0;
+  const id = input.id ?? createNodeId();
+  if (nodes.has(id)) {
+    throw new BoardConflictError(
+      `Cannot create node: node "${id}" already exists.`
+    );
+  }
+  assertValidNodeGeometry(id, { x: point.x, y: point.y, width, height });
+  assertValidParentLink(nodes, id, parentId);
+  return {
+    node: withNodeFields(
+      {
+        id,
+        type,
+        x: point.x,
+        y: point.y,
+        width,
+        height,
+        color: input.color,
+        zIndex: context.nextZIndex,
+        locked: Boolean(input.locked),
+        visible: input.visible !== false,
+        parentId
+      },
+      input
+    ),
+    nextZIndex: context.nextZIndex + 1
+  };
+}
+function applyNodePatchToNode(node, patch, context) {
+  const invalidFields = node.type === "text" ? ["file", "subpath", "url", "label", "background", "backgroundStyle"] : node.type === "file" ? ["text", "url", "label", "background", "backgroundStyle"] : node.type === "link" ? [
+    "text",
+    "file",
+    "subpath",
+    "label",
+    "background",
+    "backgroundStyle"
+  ] : ["text", "file", "subpath", "url"];
+  const invalidField = invalidFields.find((field) => field in patch);
+  if (invalidField) {
+    throw new BoardInputError(
+      `Cannot update ${node.type} node "${node.id}" with field "${invalidField}".`
+    );
+  }
+  const nextCommon = {
+    x: patch.x ?? node.x,
+    y: patch.y ?? node.y,
+    width: patch.width ?? node.width,
+    height: patch.height ?? node.height,
+    parentId: "parentId" in patch ? patch.parentId : node.parentId,
+    color: "color" in patch ? patch.color : node.color,
+    locked: patch.locked ?? node.locked,
+    visible: patch.visible ?? node.visible
+  };
+  const { grid, constraints, nodes } = context;
+  const x = grid.snap ? snapValue(nextCommon.x, grid.size) : nextCommon.x;
+  const y = grid.snap ? snapValue(nextCommon.y, grid.size) : nextCommon.y;
+  const width = grid.snap ? snapSize(nextCommon.width, grid.size, constraints.minWidth) : nextCommon.width;
+  const height = grid.snap ? snapSize(nextCommon.height, grid.size, constraints.minHeight) : nextCommon.height;
+  assertValidNodeGeometry(node.id, { x, y, width, height });
+  assertValidParentLink(nodes, node.id, nextCommon.parentId);
+  const common = {
+    id: node.id,
+    x,
+    y,
+    width,
+    height,
+    color: nextCommon.color,
+    zIndex: node.zIndex,
+    locked: nextCommon.locked,
+    visible: nextCommon.visible,
+    parentId: nextCommon.parentId
+  };
+  switch (node.type) {
+    case "text":
+      return { ...common, type: "text", text: patch.text ?? node.text };
+    case "file":
+      return {
+        ...common,
+        type: "file",
+        file: patch.file ?? node.file,
+        subpath: "subpath" in patch ? patch.subpath : node.subpath
+      };
+    case "link":
+      return { ...common, type: "link", url: patch.url ?? node.url };
+    case "group":
+      return {
+        ...common,
+        type: "group",
+        label: "label" in patch ? patch.label : node.label,
+        background: "background" in patch ? patch.background : node.background,
+        backgroundStyle: "backgroundStyle" in patch ? patch.backgroundStyle : node.backgroundStyle
+      };
+  }
+}
+
+// src/engine.ts
+var CommandBlockedError = class extends BoardError {
+  constructor(command, args, reason) {
+    super(`Command "${command}" was blocked: ${reason}`);
+    this.command = command;
+    this.args = args;
+    this.reason = reason;
+    this.name = "CommandBlockedError";
+  }
+  command;
+  args;
+  reason;
+};
+var CONNECTIONS_FEATURE_NAME = "connections";
+var RECORD_COMMAND = { history: "record" };
+var IGNORE_COMMAND = { history: "ignore" };
+var IGNORE_UNVALIDATED_COMMAND = {
+  history: "ignore",
+  validate: false
+};
+function requireFiniteInput(name, ...values) {
+  if (values.some((value) => !Number.isFinite(value))) {
+    throw new BoardInputError(`${name} must contain only finite numbers.`);
+  }
+}
+function requireNonNegativeInput(name, value) {
+  requireFiniteInput(name, value);
+  if (value < 0) {
+    throw new BoardInputError(`${name} must be greater than or equal to 0.`);
+  }
+}
+function createBoardEngine(options = {}) {
+  const camera = { ...DEFAULT_CAMERA, ...options.camera };
+  const zoom = { ...DEFAULT_ZOOM, ...options.zoom };
+  let grid = { ...DEFAULT_GRID, ...options.grid };
+  const boxSelectBehavior = options.boxSelect?.behavior ?? "autocad";
+  const nodeConstraints = {
+    ...DEFAULT_NODE_CONSTRAINTS,
+    ...options.nodes
+  };
+  const diagnosticsEnabled = Boolean(options.diagnostics);
+  const traceLimit = typeof options.diagnostics === "object" && options.diagnostics.traceLimit !== void 0 ? options.diagnostics.traceLimit : 500;
+  validateBoardConfiguration({
+    camera,
+    zoom,
+    grid,
+    nodeConstraints,
+    plugins: options.plugins ?? [],
+    diagnostics: options.diagnostics,
+    boxSelectBehavior
+  });
+  for (const plugin of options.plugins ?? []) {
+    assertInternalBoardPlugin(plugin);
+  }
+  const eventBus = createEventBus({
+    diagnosticsEnabled,
+    traceLimit,
+    onUnhandledError: options.onUnhandledError
+  });
+  const { emit, emitImmediate, on, once, off, reportUnhandledError } = eventBus;
+  const commandGuards = createCommandGuardRegistry();
+  const commitProjectors = /* @__PURE__ */ new Set();
+  const nodeDeletedHooks = /* @__PURE__ */ new Set();
+  const pluginCleanups = /* @__PURE__ */ new Map();
+  let pluginStates = /* @__PURE__ */ new Map();
+  const pluginPersistence = /* @__PURE__ */ new Map();
+  function notifyNodeDeletedPlugins(nodeId) {
+    for (const hook of nodeDeletedHooks) hook(nodeId);
+  }
+  const clipboard = [];
+  const plugins = {};
+  let viewportSize = { ...DEFAULT_VIEWPORT_SIZE };
+  let destroyed = false;
+  let finalizingCommitEffects = false;
+  let activeGestureHistoryRoot = null;
+  let activeBoxSelectionBefore = null;
+  const nodeOverrides = /* @__PURE__ */ new Map();
+  let indexedNodeRoot = null;
+  let snapEdgeIndex = null;
+  function getSnapEdgeIndex() {
+    if (indexedNodeRoot !== state.nodes || !snapEdgeIndex) {
+      indexedNodeRoot = state.nodes;
+      snapEdgeIndex = buildSnapEdgeIndex(state.nodes.values());
+    }
+    return snapEdgeIndex;
+  }
+  function assertAlive() {
+    if (destroyed) {
+      throw new BoardDestroyedError();
+    }
+  }
+  function assertMutationAllowed() {
+    if (finalizingCommitEffects) {
+      throw new BoardConflictError(
+        "Board mutations are unavailable during commit-effect finalization."
+      );
+    }
+  }
+  function assertCommandReady() {
+    assertAlive();
+    assertMutationAllowed();
+  }
+  let state = {
+    camera,
+    nodes: /* @__PURE__ */ new Map(),
+    selection: /* @__PURE__ */ new Set(),
+    interaction: { mode: "idle" },
+    snapGuides: [],
+    nextZIndex: 1
+  };
+  const initialDocument = options.initialDocument ? normalizeDocumentForImport(options.initialDocument) : null;
+  if (initialDocument) {
+    const initial = documentToSnapshot(initialDocument);
+    state.camera = { ...initial.camera };
+    state.selection = /* @__PURE__ */ new Set();
+    state.nextZIndex = initial.nextZIndex;
+    Object.assign(grid, { ...initial.grid });
+    for (const rawNode of materializeSnapshotNodes(initial)) {
+      const normalized = normalizeExistingNode(rawNode);
+      state.nodes.set(normalized.id, normalized);
+      state.nextZIndex = Math.max(state.nextZIndex, normalized.zIndex + 1);
+    }
+    state.selection = new Set(
+      initial.selection.filter((id) => state.nodes.has(id))
+    );
+  }
+  for (const node of options.initialNodes ?? []) {
+    const normalized = normalizeExistingNode(node);
+    if (state.nodes.has(normalized.id)) {
+      throw new BoardConflictError(
+        `Cannot initialize board: node "${normalized.id}" is duplicated.`
+      );
+    }
+    state.nodes.set(normalized.id, normalized);
+    state.nextZIndex = Math.max(state.nextZIndex, normalized.zIndex + 1);
+  }
+  const reactive = createReactiveLayer({
+    getState: () => state,
+    getGrid: () => grid,
+    emit,
+    reportSubscriberError: (channel, error) => reportUnhandledError(error, { source: "subscriber", channel }),
+    getEffectiveNodes: () => {
+      if (nodeOverrides.size === 0) return state.nodes;
+      const effective = new Map(state.nodes);
+      for (const [id, node] of nodeOverrides) effective.set(id, node);
+      return effective;
+    }
+  });
+  const {
+    batchCtrl,
+    $camera,
+    $grid,
+    $nodes,
+    $selection,
+    $interaction,
+    $snapGuides,
+    getPublicNodeMap,
+    invalidateNodeCache,
+    notifyNodesChanged,
+    notifyCameraChanged,
+    notifyGridChanged,
+    notifySelectionChanged,
+    notifyInteractionChanged,
+    notifySnapGuidesChanged,
+    setCamera,
+    setSelection,
+    setInteraction,
+    setSnapGuides,
+    destroy: destroyReactiveLayer
+  } = reactive;
+  const cameraSession = createCameraSession({
+    getCamera: () => state.camera,
+    getNodes: () => state.nodes.values(),
+    getViewportSize: () => viewportSize,
+    setCamera,
+    zoom
+  });
+  const batches = createBatchCommandController({
+    batchCtrl,
+    emitCommandBefore: (name, args, metadata) => emit("command:before", name, args, metadata),
+    emitCommandAfter: (name, args, duration, metadata) => emit("command:after", name, args, duration, metadata),
+    validate: (ctx) => validate(ctx)
+  });
+  function getGridSettings() {
+    assertAlive();
+    return freezeClone({ ...grid });
+  }
+  function resolveBoxSelectMode(startScreenPoint, currentScreenPoint) {
+    if (boxSelectBehavior === "contain") {
+      return "window";
+    }
+    if (boxSelectBehavior === "intersect") {
+      return "crossing";
+    }
+    return currentScreenPoint.x >= startScreenPoint.x ? "window" : "crossing";
+  }
+  function getViewportSize() {
+    assertAlive();
+    return freezeClone({ ...viewportSize });
+  }
+  function materializeNode2(node) {
+    return materializeNode(node);
+  }
+  function getState() {
+    assertAlive();
+    return buildPublicState(state, grid, getPublicNodeMap());
+  }
+  function beginPersistentTransaction() {
+    const roots = { state, grid, pluginStates };
+    const checkpoint = {
+      roots,
+      clipboard: [...clipboard],
+      nodeOverrides: new Map(nodeOverrides),
+      activeGestureHistoryRoot,
+      activeBoxSelectionBefore
+    };
+    const candidate = stagePersistentRoots(roots);
+    state = candidate.state;
+    grid = candidate.grid;
+    pluginStates = candidate.pluginStates;
+    return checkpoint;
+  }
+  function rollbackPersistentTransaction(checkpoint) {
+    state = checkpoint.roots.state;
+    grid = checkpoint.roots.grid;
+    pluginStates = checkpoint.roots.pluginStates;
+    clipboard.splice(0, clipboard.length, ...checkpoint.clipboard);
+    nodeOverrides.clear();
+    for (const [id, node] of checkpoint.nodeOverrides) {
+      nodeOverrides.set(id, node);
+    }
+    activeGestureHistoryRoot = checkpoint.activeGestureHistoryRoot;
+    activeBoxSelectionBefore = checkpoint.activeBoxSelectionBefore;
+    invalidateNodeCache();
+  }
+  function captureHistoryRoot() {
+    return {
+      nodes: state.nodes,
+      grid: freezeClone({ ...grid }),
+      selection: state.selection,
+      nextZIndex: state.nextZIndex,
+      pluginSlices: new Map(
+        Array.from(pluginStates, ([name, pluginState]) => [
+          name,
+          pluginState.state
+        ])
+      )
+    };
+  }
+  function sameHistoryRoot(left, right) {
+    if (left.nextZIndex !== right.nextZIndex) return false;
+    if (left.grid.size !== right.grid.size || left.grid.majorEvery !== right.grid.majorEvery || left.grid.snap !== right.grid.snap || left.grid.edgeSnap !== right.grid.edgeSnap || left.grid.edgeSnapThreshold !== right.grid.edgeSnapThreshold || left.grid.pattern !== right.grid.pattern) {
+      return false;
+    }
+    if (left.nodes.size !== right.nodes.size) return false;
+    for (const [id, node] of left.nodes) {
+      if (right.nodes.get(id) !== node) return false;
+    }
+    if (left.selection.size !== right.selection.size) return false;
+    for (const id of left.selection) {
+      if (!right.selection.has(id)) return false;
+    }
+    if (left.pluginSlices.size !== right.pluginSlices.size) return false;
+    for (const [name, slice] of left.pluginSlices) {
+      if (right.pluginSlices.get(name) !== slice) return false;
+    }
+    return true;
+  }
+  function prepareCommit(label, metadata, before) {
+    const after = captureHistoryRoot();
+    if (sameHistoryRoot(before, after)) return null;
+    const commit = Object.freeze({
+      label,
+      timestamp: Date.now(),
+      metadata,
+      before,
+      after
+    });
+    const effects = Array.from(commitProjectors, (project) => project(commit));
+    return {
+      label,
+      finalize() {
+        const errors = [];
+        finalizingCommitEffects = true;
+        try {
+          for (const effect of effects) {
+            try {
+              effect();
+            } catch (error) {
+              errors.push(error);
+            }
+          }
+        } finally {
+          finalizingCommitEffects = false;
+        }
+        return errors;
+      }
+    };
+  }
+  const validate = createValidator({
+    getState: () => getState(),
+    getGrid: () => grid,
+    emitFailure: (failure) => emitImmediate("validation:failed", failure)
+  });
+  function discardActiveInteraction() {
+    if (state.interaction.mode === "idle" && nodeOverrides.size === 0) return;
+    const hadNodeOverrides = nodeOverrides.size > 0;
+    const selectionBefore = state.interaction.mode === "box-select" ? activeBoxSelectionBefore : null;
+    nodeOverrides.clear();
+    activeGestureHistoryRoot = null;
+    activeBoxSelectionBefore = null;
+    setSnapGuides([]);
+    if (selectionBefore) setSelection(selectionBefore);
+    setInteraction({ mode: "idle" });
+    if (hadNodeOverrides) notifyNodesChanged();
+  }
+  const { runCommand, runAsyncCommand } = createTransactionExecutor({
+    assertAlive: assertCommandReady,
+    runGuard: (name, args, metadata) => commandGuards.run(name, args, metadata),
+    emitBlocked: (name, args, metadata) => emitImmediate("command:blocked", name, args, metadata),
+    emitBefore: (name, args, metadata) => emit("command:before", name, args, metadata),
+    emitAfter: (name, args, duration, metadata) => emit("command:after", name, args, duration, metadata),
+    createBlockedError: (name, args, reason) => new CommandBlockedError(name, args, reason),
+    isBatching: () => batches.isBatching(),
+    canOwnEffects: () => batchCtrl.depth === 0,
+    beginEffects: () => {
+      batchCtrl.depth += 1;
+      eventBus.beginTransaction();
+    },
+    commitEffects: () => {
+      batchCtrl.depth -= 1;
+      batches.flushBatchNotifications();
+      eventBus.commitTransaction();
+    },
+    rollbackEffects: () => {
+      batchCtrl.depth -= 1;
+      batches.rollbackBatchNotifications();
+      eventBus.rollbackTransaction();
+    },
+    markValidationPending: () => batches.markValidationPending(),
+    captureHistoryRoot,
+    beginPersistentTransaction,
+    rollbackPersistentTransaction,
+    beforeExecute: (name, metadata, historyBefore) => {
+      const restoresBoxSelection = state.interaction.mode === "box-select" && activeBoxSelectionBefore !== null;
+      if (metadata.history === "record" && name !== "endInteraction") {
+        discardActiveInteraction();
+        if (restoresBoxSelection && historyBefore) {
+          return {
+            ...historyBefore,
+            selection: new Set(state.selection)
+          };
+        }
+      }
+      return null;
+    },
+    prepareCommit,
+    reportCommitError: (label, error) => reportUnhandledError(error, {
+      source: "commit-effect",
+      commit: label
+    }),
+    validate,
+    isCancellation: (error) => error instanceof AnimationCancelled
+  });
+  function assertBoardNode(id) {
+    const node = nodeOverrides.get(id) ?? state.nodes.get(id);
+    if (!node) {
+      throw new BoardNotFoundError(`Node "${id}" does not exist.`);
+    }
+    return node;
+  }
+  function setNodeOverride(node) {
+    nodeOverrides.set(node.id, node);
+    return node;
+  }
+  function commitNodeOverrides(interaction) {
+    for (const [id, next] of nodeOverrides) {
+      const before = state.nodes.get(id);
+      if (!before || before === next) continue;
+      state.nodes.set(id, next);
+      if (interaction.mode === "dragging-nodes") {
+        emit("node:moved", materializeNode2(next), {
+          x: next.x - before.x,
+          y: next.y - before.y
+        });
+        emit("node:updated", materializeNode2(next), materializeNode2(before));
+      } else if (id === interaction.nodeId) {
+        emitNodeResize(before, next);
+      }
+    }
+    nodeOverrides.clear();
+    notifyNodesChanged();
+  }
+  function normalizeNode(input) {
+    const normalized = normalizeNodeInput(input, {
+      nodes: state.nodes,
+      grid,
+      constraints: nodeConstraints,
+      nextZIndex: state.nextZIndex
+    });
+    state.nextZIndex = normalized.nextZIndex;
+    return normalized.node;
+  }
+  function applyNodePatch(node, patch) {
+    return applyNodePatchToNode(node, patch, {
+      nodes: state.nodes,
+      grid,
+      constraints: nodeConstraints
+    });
+  }
+  function replaceBoardNodeWithoutNotify(node, next) {
+    const stored = next;
+    state.nodes.set(node.id, stored);
+    invalidateNodeCache();
+    return stored;
+  }
+  function replaceBoardNode(node, next) {
+    const stored = replaceBoardNodeWithoutNotify(node, next);
+    notifyNodesChanged();
+    return stored;
+  }
+  function emitNodeResize(before, after) {
+    const publicNode = materializeNode2(after);
+    emit("node:resized", publicNode, {
+      x: before.x,
+      y: before.y,
+      width: before.width,
+      height: before.height
+    });
+    emit("node:updated", publicNode, materializeNode2(before));
+  }
+  function getPublicNode(id) {
+    return materializeNode2(assertBoardNode(id));
+  }
+  function getDirectChildren(parentId) {
+    return Array.from(state.nodes.values()).filter(
+      (node) => node.parentId === parentId
+    );
+  }
+  function collectSubtreeIdSet(rootId, into) {
+    collectSubtreeIds(rootId, state.nodes, into);
+  }
+  function forestIdsFromSeeds(seedIds) {
+    const out = /* @__PURE__ */ new Set();
+    for (const id of seedIds) {
+      if (state.nodes.has(id)) {
+        collectSubtreeIdSet(id, out);
+      }
+    }
+    return out;
+  }
+  function deletionOrderPostOrder(ids) {
+    const memo = /* @__PURE__ */ new Map();
+    function depthOf(id) {
+      const cached = memo.get(id);
+      if (cached !== void 0) {
+        return cached;
+      }
+      const node = state.nodes.get(id);
+      if (!node?.parentId || !ids.has(node.parentId)) {
+        memo.set(id, 0);
+        return 0;
+      }
+      const depth = depthOf(node.parentId) + 1;
+      memo.set(id, depth);
+      return depth;
+    }
+    return Array.from(ids).sort((a, b) => depthOf(b) - depthOf(a));
+  }
+  function fixSubtreeZOrderAfter(parent, nodeId) {
+    const node = state.nodes.get(nodeId);
+    if (!node) {
+      return;
+    }
+    let current = node;
+    if (parent && current.zIndex <= parent.zIndex) {
+      current = replaceBoardNode(node, {
+        ...node,
+        zIndex: state.nextZIndex++
+      });
+    }
+    for (const child of getDirectChildren(nodeId)) {
+      fixSubtreeZOrderAfter(current, child.id);
+    }
+  }
+  function restackGroupDescendantsAbove(groupId) {
+    const group = state.nodes.get(groupId);
+    if (!group || group.type !== "group") {
+      return;
+    }
+    for (const child of getDirectChildren(groupId)) {
+      fixSubtreeZOrderAfter(group, child.id);
+    }
+  }
+  function reparentAfterDrag(movedIds) {
+    const ordered = sortIdsByZIndex(
+      movedIds,
+      state.nodes
+    );
+    for (const id of ordered) {
+      const node = state.nodes.get(id);
+      if (!node) {
+        continue;
+      }
+      const nextParent = findContainingGroup(
+        node,
+        state.nodes
+      );
+      if (nextParent === node.parentId) {
+        continue;
+      }
+      const updated = replaceBoardNode(node, {
+        ...node,
+        parentId: nextParent
+      });
+      emit("node:updated", materializeNode2(updated), materializeNode2(node));
+      fixSubtreeZOrderAfter(nextParent ? assertBoardNode(nextParent) : null, id);
+    }
+  }
+  function reparentNodesCapturedByGroups(groupIds, excludeIds) {
+    const exclude = new Set(excludeIds);
+    const groups = groupIds.map((id) => state.nodes.get(id)).filter((node) => Boolean(node)).filter((node) => node.type === "group" && node.visible);
+    if (groups.length === 0) {
+      return;
+    }
+    const captured = [];
+    for (const node of state.nodes.values()) {
+      if (exclude.has(node.id) || node.locked || !node.visible) {
+        continue;
+      }
+      if (groups.some(
+        (group) => boundsContain(getBoundsFromNode(group), getBoundsFromNode(node))
+      )) {
+        captured.push(node.id);
+      }
+    }
+    if (captured.length > 0) {
+      reparentAfterDrag(captured);
+    }
+  }
+  function reparentNodesCapturedByMovedGroups(movedIds) {
+    reparentNodesCapturedByGroups(movedIds, movedIds);
+  }
+  function getSelectionNodes3() {
+    return getSelectionNodes(state);
+  }
+  function getCopyClosureNodes2() {
+    return getCopyClosureNodes(state);
+  }
+  function duplicateForest2(nodes, offset) {
+    return duplicateForest(state, grid, nodes, offset);
+  }
+  function cleanupSelection() {
+    setSelection(
+      Array.from(state.selection.values()).filter((id) => state.nodes.has(id))
+    );
+  }
+  function restoreSnapshot(snapshot, mode) {
+    const snapshotNodes = materializeSnapshotNodes(snapshot);
+    const idMap = /* @__PURE__ */ new Map();
+    if (mode === "replace") {
+      const existingIds = deletionOrderPostOrder(new Set(state.nodes.keys()));
+      for (const id of existingIds) {
+        const prevNode = state.nodes.get(id);
+        if (!prevNode) {
+          continue;
+        }
+        state.nodes.delete(id);
+        notifyNodeDeletedPlugins(prevNode.id);
+        emit("node:deleted", id, materializeNode2(prevNode));
+      }
+      state.nextZIndex = snapshot.nextZIndex ?? snapshotNodes.reduce((max, node) => Math.max(max, node.zIndex), 0) + 1;
+      for (const rawNode of snapshotNodes) {
+        const node = normalizeExistingNode(rawNode);
+        state.nodes.set(node.id, node);
+        idMap.set(rawNode.id, node.id);
+        emit("node:created", materializeNode2(node));
+      }
+      state.selection = new Set(
+        snapshot.selection.filter((id) => state.nodes.has(id))
+      );
+      state.interaction = { mode: "idle" };
+      state.snapGuides = [];
+      state.camera = { ...snapshot.camera };
+      Object.assign(grid, { ...snapshot.grid });
+      notifyCameraChanged();
+      notifyNodesChanged();
+      notifySelectionChanged();
+      notifyInteractionChanged();
+      notifySnapGuidesChanged();
+      return idMap;
+    }
+    for (const rawNode of snapshotNodes) {
+      const node = normalizeExistingNode(rawNode);
+      const id = state.nodes.has(node.id) ? createNodeId() : node.id;
+      state.nodes.set(id, { ...node, id, zIndex: state.nextZIndex++ });
+      idMap.set(node.id, id);
+    }
+    notifyNodesChanged();
+    return idMap;
+  }
+  function restorePluginDocuments(document, mode, idMap = /* @__PURE__ */ new Map()) {
+    for (const entry of pluginPersistence.values()) {
+      entry.hooks.loadDocument?.(entry.context, document, mode, idMap);
+    }
+  }
+  function assertCanRestoreDocument(document) {
+    if (document.edges?.length && !pluginPersistence.has(CONNECTIONS_FEATURE_NAME)) {
+      throw new BoardInputError(
+        "Invalid board document: edges require the connections plugin."
+      );
+    }
+  }
+  function installPlugin(plugin) {
+    if (plugin.slice) {
+      pluginStates.set(plugin.name, {
+        state: plugin.slice.initial
+      });
+    }
+    const pluginCtx = Object.assign(
+      Object.create(engine),
+      {
+        getPluginState: () => {
+          assertAlive();
+          const entry = pluginStates.get(plugin.name);
+          if (!entry) {
+            throw new Error(
+              `Plugin "${plugin.name}" did not register a persistent slice.`
+            );
+          }
+          return entry.state;
+        },
+        updatePluginState: (update) => {
+          assertAlive();
+          assertMutationAllowed();
+          const entry = pluginStates.get(plugin.name);
+          if (!entry) {
+            throw new Error(
+              `Plugin "${plugin.name}" did not register a persistent slice.`
+            );
+          }
+          const next = update(entry.state);
+          entry.state = next;
+          return next;
+        }
+      }
+    );
+    const cleanup = plugin.install(pluginCtx);
+    if (plugin.nodeDeleted) {
+      nodeDeletedHooks.add((nodeId) => plugin.nodeDeleted(pluginCtx, nodeId));
+    }
+    if (plugin.persistence) {
+      pluginPersistence.set(plugin.name, {
+        context: pluginCtx,
+        hooks: plugin.persistence
+      });
+    }
+    pluginCleanups.set(plugin.name, cleanup ?? (() => void 0));
+  }
+  const engine = {
+    plugins,
+    assertActive: assertAlive,
+    isBatching: () => batches.isBatching(),
+    $camera,
+    $grid,
+    $nodes,
+    $selection,
+    $interaction,
+    $snapGuides,
+    destroy() {
+      if (destroyed) {
+        return;
+      }
+      assertMutationAllowed();
+      destroyed = true;
+      cameraSession.cancelAnimations();
+      nodeOverrides.clear();
+      activeGestureHistoryRoot = null;
+      activeBoxSelectionBefore = null;
+      const cleanupErrors = [];
+      for (const cleanup of pluginCleanups.values()) {
+        try {
+          cleanup();
+        } catch (error) {
+          cleanupErrors.push(error);
+        }
+      }
+      emit("destroy");
+      pluginCleanups.clear();
+      pluginStates.clear();
+      pluginPersistence.clear();
+      commitProjectors.clear();
+      nodeDeletedHooks.clear();
+      commandGuards.clear();
+      eventBus.clear();
+      destroyReactiveLayer();
+      if (cleanupErrors.length > 0) {
+        throw new AggregateError(
+          cleanupErrors,
+          "One or more board plugin cleanups failed."
+        );
+      }
+    },
+    extend(key, value) {
+      assertMutationAllowed();
+      plugins[key] = value;
+    },
+    batch(fn) {
+      assertCommandReady();
+      if (batches.isBatching()) {
+        batches.batch(fn);
+        return;
+      }
+      const originalHistoryBefore = captureHistoryRoot();
+      const checkpoint = beginPersistentTransaction();
+      eventBus.beginTransaction();
+      let historyBefore = originalHistoryBefore;
+      let commitErrors = [];
+      try {
+        batches.batch(
+          () => {
+            const restoresBoxSelection = state.interaction.mode === "box-select" && activeBoxSelectionBefore !== null;
+            discardActiveInteraction();
+            if (restoresBoxSelection) {
+              historyBefore = {
+                ...originalHistoryBefore,
+                selection: new Set(state.selection)
+              };
+            }
+            fn();
+          },
+          () => {
+            commitErrors = prepareCommit(
+              "batch",
+              RECORD_COMMAND,
+              historyBefore
+            )?.finalize() ?? [];
+          }
+        );
+        eventBus.commitTransaction();
+        for (const error of commitErrors) {
+          reportUnhandledError(error, {
+            source: "commit-effect",
+            commit: "batch"
+          });
+        }
+      } catch (error) {
+        rollbackPersistentTransaction(checkpoint);
+        eventBus.rollbackTransaction();
+        throw error;
+      }
+    },
+    getState,
+    getGridSettings,
+    getViewportSize,
+    updateGridSettings(patch) {
+      return runCommand("updateGridSettings", [patch], () => {
+        const next = { ...grid, ...patch };
+        validateGridSettings(next);
+        Object.assign(grid, next);
+        notifyGridChanged();
+        return getGridSettings();
+      });
+    },
+    setViewportSize(size) {
+      assertAlive();
+      assertMutationAllowed();
+      if (!Number.isFinite(size.x) || !Number.isFinite(size.y)) {
+        throw new BoardInputError(
+          "Viewport width and height must be finite numbers."
+        );
+      }
+      const next = {
+        x: Math.max(1, size.x),
+        y: Math.max(1, size.y)
+      };
+      if (next.x === viewportSize.x && next.y === viewportSize.y) {
+        return;
+      }
+      const prev = { ...viewportSize };
+      viewportSize = next;
+      emit("viewport:change", freezeClone({ ...next }), freezeClone(prev));
+    },
+    emit,
+    on(event, handler) {
+      assertAlive();
+      return on(event, handler);
+    },
+    once(event, handler) {
+      assertAlive();
+      return once(event, handler);
+    },
+    off(event, handler) {
+      assertAlive();
+      off(event, handler);
+    },
+    exportTrace() {
+      assertAlive();
+      return eventBus.exportTrace();
+    },
+    addCommandGuard(fn) {
+      assertAlive();
+      assertMutationAllowed();
+      return commandGuards.add(fn);
+    },
+    runCommand(name, args, fn, metadata) {
+      return runCommand(name, args, fn, metadata);
+    },
+    projectCommit(projector) {
+      assertAlive();
+      assertMutationAllowed();
+      commitProjectors.add(projector);
+      return () => commitProjectors.delete(projector);
+    },
+    restoreHistoryRoot(root) {
+      runCommand(
+        "history:restore",
+        [],
+        () => {
+          nodeOverrides.clear();
+          activeBoxSelectionBefore = null;
+          state.nodes = new Map(root.nodes);
+          state.selection = new Set(
+            Array.from(root.selection).filter((id) => state.nodes.has(id))
+          );
+          state.nextZIndex = root.nextZIndex;
+          Object.assign(grid, root.grid);
+          for (const [name, pluginState] of pluginStates) {
+            if (root.pluginSlices.has(name)) {
+              pluginState.state = root.pluginSlices.get(name);
+            }
+          }
+          setInteraction({ mode: "idle" });
+          setSnapGuides([]);
+          notifyGridChanged();
+          notifyNodesChanged();
+          notifySelectionChanged();
+        },
+        IGNORE_COMMAND
+      );
+    },
+    getPluginState() {
+      throw new Error(
+        "getPluginState is only available inside an internal plugin install() context."
+      );
+    },
+    updatePluginState(_update) {
+      throw new Error(
+        "updatePluginState is only available inside an internal plugin install() context."
+      );
+    },
+    screenToWorld(point) {
+      assertAlive();
+      return screenToWorld(point, state.camera);
+    },
+    worldToScreen(point) {
+      assertAlive();
+      return worldToScreen(point, state.camera);
+    },
+    getVisibleBounds(width, height) {
+      assertAlive();
+      return getVisibleBounds(width, height, state.camera);
+    },
+    getNode(id) {
+      assertAlive();
+      return getPublicNode(id);
+    },
+    findNode(id) {
+      assertAlive();
+      return state.nodes.has(id) ? getPublicNode(id) : null;
+    },
+    hasNode(id) {
+      assertAlive();
+      return state.nodes.has(id);
+    },
+    getNodeAt(worldPoint) {
+      assertAlive();
+      let best = null;
+      let bestZ = -Infinity;
+      for (const node of state.nodes.values()) {
+        if (node.visible && node.zIndex > bestZ && pointInBounds(worldPoint, getBoundsFromNode(node))) {
+          best = node;
+          bestZ = node.zIndex;
+        }
+      }
+      return best ? materializeNode2(best) : null;
+    },
+    getNodesInBounds(bounds) {
+      assertAlive();
+      return Array.from(state.nodes.values()).filter(
+        (node) => node.visible && boundsIntersect(getBoundsFromNode(node), bounds)
+      ).map((node) => materializeNode2(node));
+    },
+    panBy(dx, dy) {
+      requireFiniteInput("panBy delta", dx, dy);
+      runCommand(
+        "panBy",
+        [dx, dy],
+        () => {
+          setCamera({
+            x: state.camera.x - dx / state.camera.z,
+            y: state.camera.y - dy / state.camera.z,
+            z: state.camera.z
+          });
+        },
+        IGNORE_UNVALIDATED_COMMAND
+      );
+    },
+    panTo(worldPoint, animated = false) {
+      requireFiniteInput("panTo point", worldPoint.x, worldPoint.y);
+      const target = { x: -worldPoint.x, y: -worldPoint.y, z: state.camera.z };
+      return runAsyncCommand(
+        "panTo",
+        [worldPoint, animated],
+        async () => {
+          if (animated) {
+            await cameraSession.animateTo(target);
+          } else {
+            setCamera(target);
+          }
+        },
+        IGNORE_UNVALIDATED_COMMAND
+      );
+    },
+    zoomAt(screenPoint, delta) {
+      requireFiniteInput("zoomAt input", screenPoint.x, screenPoint.y, delta);
+      runCommand(
+        "zoomAt",
+        [screenPoint, delta],
+        () => {
+          setCamera(
+            zoomCameraAtScreenPoint(
+              screenPoint,
+              delta,
+              state.camera,
+              zoom.min,
+              zoom.max
+            )
+          );
+        },
+        IGNORE_UNVALIDATED_COMMAND
+      );
+    },
+    zoomTo(level, animated = false) {
+      requireFiniteInput("zoomTo level", level);
+      const clamped = clamp(level, zoom.min, zoom.max);
+      const viewportCenter = { x: viewportSize.x / 2, y: viewportSize.y / 2 };
+      const centerWorld = screenToWorld(viewportCenter, state.camera);
+      const target = {
+        x: viewportCenter.x / clamped - centerWorld.x,
+        y: viewportCenter.y / clamped - centerWorld.y,
+        z: clamped
+      };
+      return runAsyncCommand(
+        "zoomTo",
+        [level, animated],
+        async () => {
+          if (animated) {
+            await cameraSession.animateTo(target);
+          } else {
+            setCamera(target);
+          }
+        },
+        IGNORE_UNVALIDATED_COMMAND
+      );
+    },
+    zoomToFit(padding = 40, animated = false) {
+      requireNonNegativeInput("zoomToFit padding", padding);
+      return runAsyncCommand(
+        "zoomToFit",
+        [padding, animated],
+        async () => {
+          const target = cameraSession.computeFit(null, padding);
+          if (!target) {
+            return;
+          }
+          if (animated) {
+            await cameraSession.animateTo(target);
+          } else {
+            setCamera(target);
+          }
+        },
+        IGNORE_UNVALIDATED_COMMAND
+      );
+    },
+    zoomToNodes(ids, padding = 40, animated = false) {
+      requireNonNegativeInput("zoomToNodes padding", padding);
+      return runAsyncCommand(
+        "zoomToNodes",
+        [ids, padding, animated],
+        async () => {
+          const target = cameraSession.computeFit(ids, padding);
+          if (!target) {
+            return;
+          }
+          if (animated) {
+            await cameraSession.animateTo(target);
+          } else {
+            setCamera(target);
+          }
+        },
+        IGNORE_UNVALIDATED_COMMAND
+      );
+    },
+    createNode(input) {
+      return runCommand("createNode", [input], () => {
+        const node = normalizeNode(input);
+        state.nodes.set(node.id, node);
+        notifyNodesChanged();
+        if (input.select !== false) {
+          setSelection([node.id]);
+        }
+        const publicNode = materializeNode2(node);
+        emit("node:created", publicNode);
+        return publicNode;
+      });
+    },
+    updateNode(id, patch) {
+      return runCommand("updateNode", [id, patch], () => {
+        const current = assertBoardNode(id);
+        const next = applyNodePatch(current, patch);
+        const stored = replaceBoardNode(current, next);
+        const publicNode = materializeNode2(stored);
+        emit("node:updated", publicNode, materializeNode2(current));
+        return publicNode;
+      });
+    },
+    deleteNode(id) {
+      runCommand("deleteNode", [id], () => {
+        assertBoardNode(id);
+        const toDelete = /* @__PURE__ */ new Set();
+        collectSubtreeIdSet(id, toDelete);
+        for (const deleteId of deletionOrderPostOrder(toDelete)) {
+          const prevNode = state.nodes.get(deleteId);
+          if (!prevNode) {
+            continue;
+          }
+          state.nodes.delete(deleteId);
+          notifyNodeDeletedPlugins(prevNode.id);
+          emit("node:deleted", deleteId, materializeNode2(prevNode));
+        }
+        notifyNodesChanged();
+        cleanupSelection();
+        if (state.interaction.mode !== "idle") {
+          setInteraction({ mode: "idle" });
+        }
+      });
+    },
+    moveNode(id, dx, dy) {
+      return runCommand("moveNode", [id, dx, dy], () => {
+        const node = assertBoardNode(id);
+        if (node.locked) {
+          return materializeNode2(node);
+        }
+        const targets = collectUniformTranslationTargets(
+          [id],
+          state.nodes
+        );
+        for (const targetId of targets) {
+          const current = assertBoardNode(targetId);
+          const next = {
+            ...current,
+            x: grid.snap ? snapValue(current.x + dx, grid.size) : current.x + dx,
+            y: grid.snap ? snapValue(current.y + dy, grid.size) : current.y + dy
+          };
+          const stored = replaceBoardNodeWithoutNotify(current, next);
+          const publicNode = materializeNode2(stored);
+          emit("node:moved", publicNode, {
+            x: publicNode.x - current.x,
+            y: publicNode.y - current.y
+          });
+          emit("node:updated", publicNode, materializeNode2(current));
+        }
+        if (targets.length > 0) {
+          notifyNodesChanged();
+        }
+        reparentAfterDrag(targets);
+        reparentNodesCapturedByMovedGroups(targets);
+        return getPublicNode(id);
+      });
+    },
+    translateSelectedNodes(dx, dy) {
+      runCommand("translateSelectedNodes", [dx, dy], () => {
+        const seeds = Array.from(state.selection.values()).filter((id) => {
+          const node = state.nodes.get(id);
+          return node && !node.locked;
+        });
+        if (seeds.length === 0) {
+          return;
+        }
+        const targets = collectUniformTranslationTargets(
+          seeds,
+          state.nodes
+        );
+        for (const targetId of targets) {
+          const current = assertBoardNode(targetId);
+          const next = {
+            ...current,
+            x: grid.snap ? snapValue(current.x + dx, grid.size) : current.x + dx,
+            y: grid.snap ? snapValue(current.y + dy, grid.size) : current.y + dy
+          };
+          const stored = replaceBoardNodeWithoutNotify(current, next);
+          const publicNode = materializeNode2(stored);
+          emit("node:moved", publicNode, {
+            x: publicNode.x - current.x,
+            y: publicNode.y - current.y
+          });
+          emit("node:updated", publicNode, materializeNode2(current));
+        }
+        if (targets.length > 0) {
+          notifyNodesChanged();
+        }
+        reparentAfterDrag(targets);
+        reparentNodesCapturedByMovedGroups(targets);
+      });
+    },
+    resizeNode(id, handle, dx, dy) {
+      return runCommand("resizeNode", [id, handle, dx, dy], () => {
+        const node = assertBoardNode(id);
+        if (node.locked) {
+          return materializeNode2(node);
+        }
+        const raw = applyResizeDelta(node, handle, dx, dy, {
+          minWidth: nodeConstraints.minWidth,
+          minHeight: nodeConstraints.minHeight
+        });
+        const nextBounds = grid.snap ? snapResizedBounds(raw, handle, grid.size, {
+          minWidth: nodeConstraints.minWidth,
+          minHeight: nodeConstraints.minHeight
+        }) : raw;
+        const stored = replaceBoardNode(node, {
+          ...node,
+          ...nextBounds
+        });
+        const publicNode = materializeNode2(stored);
+        emit("node:resized", publicNode, {
+          x: node.x,
+          y: node.y,
+          width: node.width,
+          height: node.height
+        });
+        emit("node:updated", publicNode, materializeNode2(node));
+        return publicNode;
+      });
+    },
+    bringToFront(id) {
+      runCommand("bringToFront", [id], () => {
+        const node = assertBoardNode(id);
+        const stored = replaceBoardNode(node, {
+          ...node,
+          zIndex: state.nextZIndex++
+        });
+        emit("node:updated", materializeNode2(stored), materializeNode2(node));
+        restackGroupDescendantsAbove(id);
+      });
+    },
+    sendToBack(id) {
+      runCommand("sendToBack", [id], () => {
+        const node = assertBoardNode(id);
+        const minZ = Math.min(
+          ...Array.from(state.nodes.values(), (entry) => entry.zIndex)
+        );
+        const stored = replaceBoardNode(node, {
+          ...node,
+          zIndex: minZ - 1
+        });
+        emit("node:updated", materializeNode2(stored), materializeNode2(node));
+        restackGroupDescendantsAbove(id);
+      });
+    },
+    lockNode(id) {
+      runCommand("lockNode", [id], () => {
+        const node = assertBoardNode(id);
+        const stored = replaceBoardNode(node, {
+          ...node,
+          locked: true
+        });
+        emit("node:updated", materializeNode2(stored), materializeNode2(node));
+      });
+    },
+    unlockNode(id) {
+      runCommand("unlockNode", [id], () => {
+        const node = assertBoardNode(id);
+        const stored = replaceBoardNode(node, {
+          ...node,
+          locked: false
+        });
+        emit("node:updated", materializeNode2(stored), materializeNode2(node));
+      });
+    },
+    duplicateNodes(ids, offset = { x: grid.size, y: grid.size }) {
+      return runCommand("duplicateNodes", [ids, offset], () => {
+        const forest = forestIdsFromSeeds(ids);
+        const source = Array.from(forest).map((id) => state.nodes.get(id)).filter((node) => Boolean(node)).sort((a, b) => a.zIndex - b.zIndex);
+        const duplicated = duplicateForest2(source, offset);
+        const created = duplicated.nodes;
+        for (const node of created) {
+          state.nodes.set(node.id, node);
+          emit("node:created", materializeNode2(node));
+        }
+        notifyNodesChanged();
+        setSelection(created.map((node) => node.id));
+        return {
+          nodes: created.map((node) => materializeNode2(node)),
+          idMap: duplicated.idMap
+        };
+      });
+    },
+    copySelected() {
+      return runCommand("copySelected", [], () => {
+        clipboard.length = 0;
+        for (const node of getCopyClosureNodes2()) {
+          clipboard.push({ ...node });
+        }
+        return clipboard.map((node) => materializeNode2(node));
+      });
+    },
+    pasteClipboard(offset = { x: grid.size, y: grid.size }) {
+      return runCommand("pasteClipboard", [offset], () => {
+        const created = duplicateForest2(clipboard, offset).nodes;
+        for (const node of created) {
+          state.nodes.set(node.id, node);
+          emit("node:created", materializeNode2(node));
+        }
+        notifyNodesChanged();
+        setSelection(created.map((node) => node.id));
+        return created.map((node) => materializeNode2(node));
+      });
+    },
+    select(ids, mode = "replace") {
+      runCommand(
+        "select",
+        [ids, mode],
+        () => {
+          discardActiveInteraction();
+          const resolved = Array.isArray(ids) ? ids : [ids];
+          if (mode === "replace") {
+            setSelection(resolved);
+            return;
+          }
+          const next = new Set(state.selection);
+          for (const id of resolved) {
+            if (mode === "toggle") {
+              if (next.has(id)) {
+                next.delete(id);
+              } else {
+                next.add(id);
+              }
+            } else {
+              next.add(id);
+            }
+          }
+          setSelection(next);
+        },
+        IGNORE_COMMAND
+      );
+    },
+    selectAll() {
+      runCommand(
+        "selectAll",
+        [],
+        () => {
+          discardActiveInteraction();
+          setSelection(
+            Array.from(state.nodes.values()).filter((node) => node.visible).map((node) => node.id)
+          );
+        },
+        IGNORE_COMMAND
+      );
+    },
+    clearSelection() {
+      runCommand(
+        "clearSelection",
+        [],
+        () => {
+          discardActiveInteraction();
+          setSelection([]);
+        },
+        IGNORE_COMMAND
+      );
+    },
+    deleteSelected() {
+      runCommand("deleteSelected", [], () => {
+        const deletingRoots = getSelectionNodes3().filter((node) => !node.locked);
+        const toDelete = /* @__PURE__ */ new Set();
+        for (const node of deletingRoots) {
+          collectSubtreeIdSet(node.id, toDelete);
+        }
+        for (const deleteId of deletionOrderPostOrder(toDelete)) {
+          const prevNode = state.nodes.get(deleteId);
+          if (!prevNode) {
+            continue;
+          }
+          state.nodes.delete(deleteId);
+          notifyNodeDeletedPlugins(prevNode.id);
+          emit("node:deleted", deleteId, materializeNode2(prevNode));
+        }
+        if (toDelete.size > 0) {
+          notifyNodesChanged();
+        }
+        setSelection([]);
+        setInteraction({ mode: "idle" });
+      });
+    },
+    getSelection() {
+      assertAlive();
+      return Array.from(state.selection.values());
+    },
+    beginPan(pointerId, screenPoint) {
+      runCommand(
+        "beginPan",
+        [pointerId, screenPoint],
+        () => {
+          discardActiveInteraction();
+          setInteraction({
+            mode: "panning",
+            pointerId,
+            lastScreenPoint: { ...screenPoint }
+          });
+        },
+        IGNORE_UNVALIDATED_COMMAND
+      );
+    },
+    beginNodeDrag(id, pointerId, screenPoint) {
+      runCommand(
+        "beginNodeDrag",
+        [id, pointerId, screenPoint],
+        () => {
+          assertBoardNode(id);
+          discardActiveInteraction();
+          const node = assertBoardNode(id);
+          if (node.locked) {
+            return;
+          }
+          activeGestureHistoryRoot = captureHistoryRoot();
+          const initialSelection = state.selection.has(id) ? getSelectionNodes3().filter((entry) => !entry.locked).map((entry) => entry.id) : [id];
+          const nodeIds = collectUniformTranslationTargets(
+            initialSelection,
+            state.nodes
+          );
+          if (!state.selection.has(id)) {
+            setSelection([id]);
+          }
+          const startNodePositions = Object.fromEntries(
+            nodeIds.map((nodeId) => {
+              const current = assertBoardNode(nodeId);
+              return [nodeId, { x: current.x, y: current.y }];
+            })
+          );
+          setInteraction({
+            mode: "dragging-nodes",
+            pointerId,
+            nodeIds,
+            startScreenPoint: { ...screenPoint },
+            startNodePositions
+          });
+        },
+        IGNORE_UNVALIDATED_COMMAND
+      );
+    },
+    beginResize(id, handle, pointerId, screenPoint) {
+      runCommand(
+        "beginResize",
+        [id, handle, pointerId, screenPoint],
+        () => {
+          assertBoardNode(id);
+          discardActiveInteraction();
+          const node = assertBoardNode(id);
+          if (node.locked) {
+            return;
+          }
+          activeGestureHistoryRoot = captureHistoryRoot();
+          setSelection([id]);
+          setInteraction({
+            mode: "resizing-node",
+            pointerId,
+            nodeId: id,
+            handle,
+            startScreenPoint: { ...screenPoint },
+            startNodeBounds: {
+              x: node.x,
+              y: node.y,
+              width: node.width,
+              height: node.height
+            },
+            aspectRatio: node.width / node.height
+          });
+        },
+        IGNORE_UNVALIDATED_COMMAND
+      );
+    },
+    beginBoxSelect(pointerId, screenPoint) {
+      runCommand(
+        "beginBoxSelect",
+        [pointerId, screenPoint],
+        () => {
+          discardActiveInteraction();
+          const worldPoint = engine.screenToWorld(screenPoint);
+          activeBoxSelectionBefore = new Set(state.selection);
+          setSelection([]);
+          setInteraction({
+            mode: "box-select",
+            pointerId,
+            selectionMode: resolveBoxSelectMode(screenPoint, screenPoint),
+            startScreenPoint: { ...screenPoint },
+            currentScreenPoint: { ...screenPoint },
+            startWorldPoint: worldPoint,
+            currentWorldPoint: worldPoint
+          });
+        },
+        IGNORE_UNVALIDATED_COMMAND
+      );
+    },
+    beginTextEdit(id) {
+      runCommand(
+        "beginTextEdit",
+        [id],
+        () => {
+          const node = assertBoardNode(id);
+          if (node.type !== "text") {
+            throw new BoardInputError(
+              `Cannot edit text for ${node.type} node "${id}".`
+            );
+          }
+          discardActiveInteraction();
+          setSelection([id]);
+          setInteraction({ mode: "editing-text", nodeId: id });
+        },
+        IGNORE_UNVALIDATED_COMMAND
+      );
+    },
+    commitTextEdit(id, text) {
+      return runCommand("commitTextEdit", [id, text], () => {
+        const node = assertBoardNode(id);
+        if (node.type !== "text") {
+          throw new BoardInputError(
+            `Cannot edit text for ${node.type} node "${id}".`
+          );
+        }
+        let stored = node;
+        if (text !== void 0) {
+          stored = replaceBoardNode(node, { ...node, text });
+          emit("node:updated", materializeNode2(stored), materializeNode2(node));
+        }
+        setInteraction({ mode: "idle" });
+        return materializeNode2(stored);
+      });
+    },
+    cancelTextEdit() {
+      if (state.interaction.mode !== "editing-text") return;
+      runCommand(
+        "cancelTextEdit",
+        [],
+        () => setInteraction({ mode: "idle" }),
+        IGNORE_UNVALIDATED_COMMAND
+      );
+    },
+    updatePointer(pointerId, screenPoint, modifiers) {
+      const interaction = state.interaction;
+      if (interaction.mode === "idle" || interaction.mode === "editing-text" || interaction.pointerId !== pointerId) {
+        return;
+      }
+      if (interaction.mode === "panning") {
+        runCommand(
+          "updatePointer",
+          [pointerId, screenPoint],
+          () => {
+            const deltaX = screenPoint.x - interaction.lastScreenPoint.x;
+            const deltaY = screenPoint.y - interaction.lastScreenPoint.y;
+            setCamera({
+              x: state.camera.x + deltaX / state.camera.z,
+              y: state.camera.y + deltaY / state.camera.z,
+              z: state.camera.z
+            });
+            setInteraction({
+              ...interaction,
+              lastScreenPoint: { ...screenPoint }
+            });
+          },
+          IGNORE_UNVALIDATED_COMMAND
+        );
+        return;
+      }
+      if (interaction.mode === "dragging-nodes") {
+        runCommand(
+          "updatePointer",
+          [pointerId, screenPoint, modifiers],
+          () => {
+            const rawDeltaX = (screenPoint.x - interaction.startScreenPoint.x) / state.camera.z;
+            const rawDeltaY = (screenPoint.y - interaction.startScreenPoint.y) / state.camera.z;
+            const axisLocked = Boolean(modifiers?.shift);
+            const deltaX = axisLocked && Math.abs(rawDeltaY) > Math.abs(rawDeltaX) ? 0 : rawDeltaX;
+            const deltaY = axisLocked && Math.abs(rawDeltaX) >= Math.abs(rawDeltaY) ? 0 : rawDeltaY;
+            const bypassSnapping = Boolean(modifiers?.space);
+            const snapToGrid = grid.snap && !bypassSnapping;
+            const prelimBounds = {};
+            let minX = Infinity;
+            let minY = Infinity;
+            let maxX = -Infinity;
+            let maxY = -Infinity;
+            for (const nodeId of interaction.nodeIds) {
+              const node = assertBoardNode(nodeId);
+              const origin = interaction.startNodePositions[nodeId];
+              if (!origin) {
+                continue;
+              }
+              const x = snapToGrid ? snapValue(origin.x + deltaX, grid.size) : origin.x + deltaX;
+              const y = snapToGrid ? snapValue(origin.y + deltaY, grid.size) : origin.y + deltaY;
+              prelimBounds[nodeId] = {
+                x,
+                y,
+                width: node.width,
+                height: node.height
+              };
+              minX = Math.min(minX, x);
+              minY = Math.min(minY, y);
+              maxX = Math.max(maxX, x + node.width);
+              maxY = Math.max(maxY, y + node.height);
+            }
+            const snapResult = bypassSnapping || !grid.edgeSnap ? { dx: 0, dy: 0, guides: [] } : (() => {
+              const excludeIds = new Set(interaction.nodeIds);
+              const groupBounds = {
+                x: minX,
+                y: minY,
+                width: maxX - minX,
+                height: maxY - minY
+              };
+              return snapPositionToEdges(
+                groupBounds,
+                getSnapEdgeIndex(),
+                grid.edgeSnapThreshold / state.camera.z,
+                excludeIds
+              );
+            })();
+            setSnapGuides(snapResult.guides);
+            let movedNodeCount = 0;
+            for (const nodeId of interaction.nodeIds) {
+              const current = assertBoardNode(nodeId);
+              const preliminary = prelimBounds[nodeId];
+              if (!preliminary) {
+                continue;
+              }
+              setNodeOverride({
+                ...current,
+                x: preliminary.x + snapResult.dx,
+                y: preliminary.y + snapResult.dy
+              });
+              movedNodeCount += 1;
+            }
+            if (movedNodeCount > 0) {
+              notifyNodesChanged();
+            }
+          },
+          IGNORE_UNVALIDATED_COMMAND
+        );
+        return;
+      }
+      if (interaction.mode === "resizing-node") {
+        runCommand(
+          "updatePointer",
+          [pointerId, screenPoint, modifiers],
+          () => {
+            const node = assertBoardNode(interaction.nodeId);
+            const deltaX = (screenPoint.x - interaction.startScreenPoint.x) / state.camera.z;
+            const deltaY = (screenPoint.y - interaction.startScreenPoint.y) / state.camera.z;
+            const constraints = {
+              minWidth: nodeConstraints.minWidth,
+              minHeight: nodeConstraints.minHeight
+            };
+            const locked = Boolean(modifiers?.shift);
+            const bypassSnapping = Boolean(modifiers?.space);
+            const raw = locked ? applyResizeDeltaLocked(
+              interaction.startNodeBounds,
+              interaction.handle,
+              deltaX,
+              deltaY,
+              constraints,
+              interaction.aspectRatio
+            ) : applyResizeDelta(
+              interaction.startNodeBounds,
+              interaction.handle,
+              deltaX,
+              deltaY,
+              constraints
+            );
+            if (locked) {
+              const nextBounds = !bypassSnapping && grid.snap ? snapResizedBoundsLocked(
+                raw,
+                interaction.startNodeBounds,
+                interaction.handle,
+                grid.size,
+                constraints,
+                interaction.aspectRatio
+              ) : raw;
+              setSnapGuides([]);
+              setNodeOverride({
+                ...node,
+                ...nextBounds
+              });
+            } else {
+              const gridSnapped = !bypassSnapping && grid.snap ? snapResizedBounds(
+                raw,
+                interaction.handle,
+                grid.size,
+                constraints
+              ) : raw;
+              if (bypassSnapping || !grid.edgeSnap) {
+                setSnapGuides([]);
+                setNodeOverride({
+                  ...node,
+                  ...gridSnapped
+                });
+              } else {
+                const snapResult = snapBoundsToEdges(
+                  gridSnapped,
+                  interaction.handle,
+                  getSnapEdgeIndex(),
+                  grid.edgeSnapThreshold / state.camera.z,
+                  /* @__PURE__ */ new Set([interaction.nodeId])
+                );
+                setSnapGuides(snapResult.guides);
+                setNodeOverride({
+                  ...node,
+                  ...snapResult.bounds
+                });
+              }
+            }
+            notifyNodesChanged();
+          },
+          IGNORE_UNVALIDATED_COMMAND
+        );
+        return;
+      }
+      runCommand(
+        "updatePointer",
+        [pointerId, screenPoint],
+        () => {
+          const currentWorldPoint = engine.screenToWorld(screenPoint);
+          const bounds = getBoundsFromPoints(
+            interaction.startWorldPoint,
+            currentWorldPoint
+          );
+          const selectionMode = resolveBoxSelectMode(
+            interaction.startScreenPoint,
+            screenPoint
+          );
+          const matches = Array.from(state.nodes.values()).filter((node) => node.visible).filter(
+            (node) => selectionMode === "window" ? boundsContain(bounds, getBoundsFromNode(node)) : boundsIntersect(getBoundsFromNode(node), bounds)
+          ).map((node) => node.id);
+          setSelection(matches);
+          setInteraction({
+            ...interaction,
+            selectionMode,
+            currentScreenPoint: { ...screenPoint },
+            currentWorldPoint
+          });
+        },
+        IGNORE_UNVALIDATED_COMMAND
+      );
+    },
+    endInteraction(pointerId) {
+      const interaction = state.interaction;
+      if (interaction.mode === "idle") {
+        return;
+      }
+      if ("pointerId" in interaction && pointerId !== void 0 && interaction.pointerId !== pointerId) {
+        return;
+      }
+      const gestureCommit = activeGestureHistoryRoot && (interaction.mode === "dragging-nodes" || interaction.mode === "resizing-node") ? {
+        before: activeGestureHistoryRoot,
+        label: interaction.mode === "dragging-nodes" ? "moveNodes" : "resizeNode",
+        metadata: RECORD_COMMAND
+      } : void 0;
+      runCommand(
+        "endInteraction",
+        [pointerId],
+        () => {
+          const previous = state.interaction;
+          setSnapGuides([]);
+          if (previous.mode === "dragging-nodes") {
+            commitNodeOverrides(previous);
+            reparentAfterDrag(previous.nodeIds);
+            reparentNodesCapturedByMovedGroups(previous.nodeIds);
+          }
+          if (previous.mode === "resizing-node") {
+            commitNodeOverrides(previous);
+            reparentNodesCapturedByGroups([previous.nodeId], [previous.nodeId]);
+          }
+          setInteraction({ mode: "idle" });
+        },
+        gestureCommit ? RECORD_COMMAND : IGNORE_COMMAND,
+        gestureCommit
+      );
+      activeGestureHistoryRoot = null;
+      activeBoxSelectionBefore = null;
+    },
+    cancelInteraction(pointerId) {
+      const interaction = state.interaction;
+      if (interaction.mode === "idle") return;
+      if ("pointerId" in interaction && pointerId !== void 0 && interaction.pointerId !== pointerId) {
+        return;
+      }
+      runCommand(
+        "cancelInteraction",
+        [pointerId],
+        () => {
+          discardActiveInteraction();
+        },
+        IGNORE_UNVALIDATED_COMMAND
+      );
+    },
+    getUniformTranslationTargets(seedIds) {
+      assertAlive();
+      return collectUniformTranslationTargets(
+        seedIds,
+        state.nodes
+      );
+    },
+    syncGroupZOrder(groupId) {
+      runCommand("syncGroupZOrder", [groupId], () => {
+        assertBoardNode(groupId);
+        restackGroupDescendantsAbove(groupId);
+      });
+    },
+    exportDocument() {
+      assertAlive();
+      const pluginDocuments = Array.from(
+        pluginPersistence.values(),
+        (entry) => entry.hooks.exportDocument?.(entry.context) ?? {}
+      );
+      return toPersistedDocument(
+        buildSnapshot(state, grid, buildPublicNodeMap(state)),
+        pluginDocuments
+      );
+    },
+    loadDocument(document, options2 = {}) {
+      const mode = options2.mode ?? "replace";
+      runCommand(
+        "loadDocument",
+        [mode],
+        () => {
+          const normalized = normalizeDocumentForImport(document);
+          assertCanRestoreDocument(normalized);
+          const snapshot = documentToSnapshot(normalized);
+          nodeOverrides.clear();
+          activeGestureHistoryRoot = null;
+          activeBoxSelectionBefore = null;
+          const idMap = restoreSnapshot(snapshot, mode);
+          restorePluginDocuments(normalized, mode, idMap);
+        },
+        IGNORE_COMMAND
+      );
+    }
+  };
+  notifyNodesChanged();
+  for (const plugin of options.plugins ?? []) {
+    assertInternalBoardPlugin(plugin);
+    installPlugin(plugin);
+  }
+  if (initialDocument) {
+    assertCanRestoreDocument(initialDocument);
+    runCommand(
+      "initializeDocument",
+      [],
+      () => restorePluginDocuments(initialDocument, "replace"),
+      IGNORE_COMMAND
+    );
+  }
+  validate("createBoardEngine");
+  const internalKeys = /* @__PURE__ */ new Set([
+    "emit",
+    "assertActive",
+    "isBatching",
+    "extend",
+    "runCommand",
+    "projectCommit",
+    "restoreHistoryRoot",
+    "getPluginState",
+    "updatePluginState",
+    "beginPan",
+    "beginNodeDrag",
+    "beginResize",
+    "beginBoxSelect",
+    "updatePointer",
+    "endInteraction",
+    "cancelInteraction",
+    "getUniformTranslationTargets",
+    "syncGroupZOrder"
+  ]);
+  const publicEngine = Object.fromEntries(
+    Object.entries(engine).filter(([key]) => !internalKeys.has(key))
+  );
+  registerBoardInteractionAdapter(publicEngine, engine);
+  return publicEngine;
+}
+
+// src/types.ts
+var asNodeId = (value) => value;
+var asEdgeId = (value) => value;
+
+// src/selection.ts
+function getSelectionNodes2(engine) {
+  const selected = new Set(engine.getSelection());
+  return Array.from(engine.getState().nodes.values()).filter(
+    (node) => selected.has(node.id)
+  );
+}
+function getSelectionBounds(engine) {
+  const nodes = getSelectionNodes2(engine);
+  if (nodes.length === 0) {
+    return null;
+  }
+  return {
+    minX: Math.min(...nodes.map((node) => node.x)),
+    minY: Math.min(...nodes.map((node) => node.y)),
+    maxX: Math.max(...nodes.map((node) => node.x + node.width)),
+    maxY: Math.max(...nodes.map((node) => node.y + node.height))
+  };
+}
+function toggleIds(current, ids) {
+  const next = new Set(current);
+  for (const id of ids) {
+    if (next.has(id)) {
+      next.delete(id);
+    } else {
+      next.add(id);
+    }
+  }
+  return Array.from(next);
+}
+export {
+  BOARD_COLOR_PRESETS,
+  BoardConflictError,
+  BoardDestroyedError,
+  BoardError,
+  BoardInputError,
+  BoardNotFoundError,
+  CommandBlockedError,
+  asEdgeId,
+  asNodeId,
+  boundsIntersect,
+  clamp,
+  colorForPreset,
+  createBoardEngine,
+  getBoundsFromPoints,
+  getSelectionBounds,
+  getSelectionNodes2 as getSelectionNodes,
+  getVisibleBounds,
+  isBoardColorPreset,
+  toggleIds
+};