@skygraph/core 0.0.0-placeholder.0 → 0.5.0

package/dist/chunk-7FA2TBSZ.js

@@ -0,0 +1,1211 @@
+import {
+  GRAPH_PREFIX
+} from "./chunk-5CCD5Q4B.js";
+
+// src/engines/graph/history.ts
+var HISTORY_LIMIT = 100;
+function createHistory(limit = HISTORY_LIMIT) {
+  const undoStack = [];
+  const redoStack = [];
+  function trim(stack) {
+    while (stack.length > limit) stack.shift();
+  }
+  return {
+    push(entry) {
+      undoStack.push(entry);
+      trim(undoStack);
+    },
+    popUndo() {
+      return undoStack.pop();
+    },
+    pushRedo(entry) {
+      redoStack.push(entry);
+      trim(redoStack);
+    },
+    popRedo() {
+      return redoStack.pop();
+    },
+    clearRedo() {
+      redoStack.length = 0;
+    },
+    canUndo() {
+      return undoStack.length > 0;
+    },
+    canRedo() {
+      return redoStack.length > 0;
+    },
+    clear() {
+      undoStack.length = 0;
+      redoStack.length = 0;
+    },
+    relabelTop(label) {
+      const top = undoStack[undoStack.length - 1];
+      if (!top) return;
+      undoStack[undoStack.length - 1] = { snapshot: top.snapshot, label };
+    },
+    topLabel() {
+      return undoStack[undoStack.length - 1]?.label;
+    },
+    size() {
+      return { undo: undoStack.length, redo: redoStack.length };
+    }
+  };
+}
+
+// src/engines/graph/GraphEngine.ts
+var engineCounter = 0;
+var DEFAULT_OUTLINE = { kind: "rect", w: 100, h: 60 };
+var DEFAULT_TRANSFORM = { x: 0, y: 0 };
+var DEFAULT_ANCHOR_POLICY = { kind: "perEdge", k: 1 };
+function createGraph(core, options) {
+  const engineId = `g${engineCounter++}${options?.name ? `-${options.name}` : ""}`;
+  const prefix = GRAPH_PREFIX;
+  const nodes = /* @__PURE__ */ new Map();
+  const edges = /* @__PURE__ */ new Map();
+  const edgesByNode = /* @__PURE__ */ new Map();
+  let nodeCounter = 0;
+  let edgeCounter = 0;
+  const localSubscribers = /* @__PURE__ */ new Set();
+  function publishSnapshot() {
+    core.set(`${prefix}snapshot.${engineId}`, {
+      nodes: Array.from(nodes.values()),
+      edges: Array.from(edges.values())
+    });
+    for (const cb of localSubscribers) cb();
+  }
+  function subscribeLocal(cb) {
+    localSubscribers.add(cb);
+    return () => {
+      localSubscribers.delete(cb);
+    };
+  }
+  publishSnapshot();
+  const history = createHistory(HISTORY_LIMIT);
+  let transactionDepth = 0;
+  let pendingEntry = null;
+  let isRestoring = false;
+  function _captureState() {
+    return {
+      nodes: Array.from(nodes.values()),
+      edges: Array.from(edges.values()),
+      nodeCounter,
+      edgeCounter
+    };
+  }
+  function _restoreState(snapshot) {
+    nodes.clear();
+    edges.clear();
+    edgesByNode.clear();
+    for (const n of snapshot.nodes) {
+      nodes.set(n.id, n);
+      edgesByNode.set(n.id, /* @__PURE__ */ new Set());
+    }
+    for (const e of snapshot.edges) {
+      edges.set(e.id, e);
+      ensureBucket(endpointNode(e.from)).add(e.id);
+      ensureBucket(endpointNode(e.to)).add(e.id);
+    }
+    nodeCounter = snapshot.nodeCounter;
+    edgeCounter = snapshot.edgeCounter;
+  }
+  function _withHistory(fn, label) {
+    if (isRestoring) return fn();
+    const wasOuter = transactionDepth === 0;
+    if (wasOuter) {
+      pendingEntry = { snapshot: _captureState(), label };
+    } else if (label !== void 0 && pendingEntry && pendingEntry.label === void 0) {
+      pendingEntry = { snapshot: pendingEntry.snapshot, label };
+    }
+    transactionDepth++;
+    try {
+      return fn();
+    } finally {
+      transactionDepth--;
+      if (transactionDepth === 0 && wasOuter) {
+        if (pendingEntry !== null) {
+          history.push(pendingEntry);
+          history.clearRedo();
+        }
+        pendingEntry = null;
+      }
+    }
+  }
+  function newNodeId() {
+    return `${engineId}-n${nodeCounter++}`;
+  }
+  function newEdgeId() {
+    return `${engineId}-e${edgeCounter++}`;
+  }
+  function ensureBucket(nodeId) {
+    let bucket = edgesByNode.get(nodeId);
+    if (!bucket) {
+      bucket = /* @__PURE__ */ new Set();
+      edgesByNode.set(nodeId, bucket);
+    }
+    return bucket;
+  }
+  function endpointNode(ep) {
+    return ep.node;
+  }
+  function bumpRevision(node) {
+    return { ...node, geomRevision: node.geomRevision + 1 };
+  }
+  function _addNodeImpl(init = {}) {
+    const id = init.id ?? newNodeId();
+    if (nodes.has(id)) {
+      throw new Error(`[skygraph/graph] node id "${id}" already exists`);
+    }
+    const node = {
+      id,
+      parentId: init.parentId ?? null,
+      transform: init.transform ?? { ...DEFAULT_TRANSFORM },
+      outline: init.outline ?? DEFAULT_OUTLINE,
+      anchorPolicy: init.anchorPolicy ?? DEFAULT_ANCHOR_POLICY,
+      data: init.data,
+      geomRevision: 0
+    };
+    nodes.set(id, node);
+    edgesByNode.set(id, /* @__PURE__ */ new Set());
+    publishSnapshot();
+    return id;
+  }
+  function addNode(init = {}) {
+    return _withHistory(() => _addNodeImpl(init));
+  }
+  function _removeNodeImpl(id) {
+    if (!nodes.has(id)) return;
+    const incident = edgesByNode.get(id);
+    if (incident) {
+      for (const eid of incident) removeEdge(eid);
+    }
+    for (const [otherId, n] of nodes) {
+      if (n.parentId === id) {
+        nodes.set(otherId, { ...n, parentId: null });
+      }
+    }
+    nodes.delete(id);
+    edgesByNode.delete(id);
+    publishSnapshot();
+  }
+  function removeNode(id) {
+    _withHistory(() => _removeNodeImpl(id));
+  }
+  function _updateNodeImpl(id, patch) {
+    const node = nodes.get(id);
+    if (!node) {
+      throw new Error(`[skygraph/graph] node "${id}" not found`);
+    }
+    const next = {
+      ...node,
+      transform: patch.transform ? { ...node.transform, ...patch.transform } : node.transform,
+      outline: patch.outline ?? node.outline,
+      anchorPolicy: patch.anchorPolicy ?? node.anchorPolicy,
+      data: patch.data === void 0 ? node.data : patch.data
+    };
+    const geomChanged = patch.transform !== void 0 || patch.outline !== void 0 || patch.anchorPolicy !== void 0;
+    nodes.set(id, geomChanged ? bumpRevision(next) : next);
+    publishSnapshot();
+  }
+  function updateNode(id, patch) {
+    _withHistory(() => _updateNodeImpl(id, patch));
+  }
+  function moveNode(id, x, y) {
+    _withHistory(() => _updateNodeImpl(id, { transform: { x, y } }));
+  }
+  function _setParentImpl(id, parentId) {
+    const node = nodes.get(id);
+    if (!node) {
+      throw new Error(`[skygraph/graph] node "${id}" not found`);
+    }
+    if (parentId !== null && !nodes.has(parentId)) {
+      throw new Error(`[skygraph/graph] parent node "${parentId}" not found`);
+    }
+    if (parentId === id) {
+      throw new Error(`[skygraph/graph] node cannot be its own parent ("${id}")`);
+    }
+    let cursor = parentId;
+    while (cursor !== null) {
+      if (cursor === id) {
+        throw new Error(`[skygraph/graph] setParent would create a cycle ("${id}" \u2192 "${parentId}")`);
+      }
+      cursor = nodes.get(cursor)?.parentId ?? null;
+    }
+    nodes.set(id, { ...node, parentId });
+    publishSnapshot();
+  }
+  function setParent(id, parentId) {
+    _withHistory(() => _setParentImpl(id, parentId));
+  }
+  function _addEdgeImpl(init) {
+    const id = init.id ?? newEdgeId();
+    if (edges.has(id)) {
+      throw new Error(`[skygraph/graph] edge id "${id}" already exists`);
+    }
+    const fromId = endpointNode(init.from);
+    const toId = endpointNode(init.to);
+    if (!nodes.has(fromId)) {
+      throw new Error(`[skygraph/graph] addEdge: from-node "${fromId}" not found`);
+    }
+    if (!nodes.has(toId)) {
+      throw new Error(`[skygraph/graph] addEdge: to-node "${toId}" not found`);
+    }
+    const edge = {
+      id,
+      from: init.from,
+      to: init.to,
+      routing: init.routing ?? "straight",
+      waypoints: init.waypoints,
+      data: init.data
+    };
+    edges.set(id, edge);
+    ensureBucket(fromId).add(id);
+    ensureBucket(toId).add(id);
+    publishSnapshot();
+    return id;
+  }
+  function addEdge(init) {
+    return _withHistory(() => _addEdgeImpl(init));
+  }
+  function _removeEdgeImpl(id) {
+    const edge = edges.get(id);
+    if (!edge) return;
+    edgesByNode.get(endpointNode(edge.from))?.delete(id);
+    edgesByNode.get(endpointNode(edge.to))?.delete(id);
+    edges.delete(id);
+    publishSnapshot();
+  }
+  function removeEdge(id) {
+    _withHistory(() => _removeEdgeImpl(id));
+  }
+  function getNode(id) {
+    return nodes.get(id);
+  }
+  function getEdge(id) {
+    return edges.get(id);
+  }
+  function getState() {
+    const byNode = /* @__PURE__ */ new Map();
+    for (const [nid, set] of edgesByNode) byNode.set(nid, Array.from(set));
+    return {
+      nodes: new Map(nodes),
+      edges: new Map(edges),
+      edgesByNode: byNode
+    };
+  }
+  function childrenOf(id) {
+    const out = [];
+    for (const n of nodes.values()) {
+      if (n.parentId === id) out.push(n.id);
+    }
+    return out;
+  }
+  function edgesOf(id) {
+    return Array.from(edgesByNode.get(id) ?? []);
+  }
+  function rectCornerId(corner) {
+    return corner;
+  }
+  function rectAnchors(w, h, policy) {
+    const corners = [
+      { id: rectCornerId("nw"), s: 0, point: [0, 0] },
+      { id: rectCornerId("ne"), s: 0.25, point: [w, 0] },
+      { id: rectCornerId("se"), s: 0.5, point: [w, h] },
+      { id: rectCornerId("sw"), s: 0.75, point: [0, h] }
+    ];
+    if (policy.kind === "manual") {
+      return policy.anchors.map((a) => ({
+        id: a.id,
+        s: a.s,
+        point: pointOnRectPerimeter(w, h, a.s)
+      }));
+    }
+    const k = policy.kind === "perEdge" ? Math.max(0, Math.floor(policy.k)) : null;
+    const density = policy.kind === "byLength" ? policy.density : null;
+    const out = [...corners];
+    const edgesGeom = [
+      { start: 0, end: 0.25 },
+      // top
+      { start: 0.25, end: 0.5 },
+      // right
+      { start: 0.5, end: 0.75 },
+      // bottom
+      { start: 0.75, end: 1 }
+      // left
+    ];
+    edgesGeom.forEach((edge, edgeIdx) => {
+      let count = 0;
+      if (k !== null) count = k;
+      if (density !== null) {
+        const len = edgeIdx % 2 === 0 ? w : h;
+        count = Math.max(0, Math.floor(len / density) - 1);
+      }
+      for (let i = 1; i <= count; i++) {
+        const t = i / (count + 1);
+        const s = edge.start + (edge.end - edge.start) * t;
+        out.push({
+          id: `edge${edgeIdx}-${i}of${count}`,
+          s,
+          point: pointOnRectPerimeter(w, h, s)
+        });
+      }
+    });
+    out.sort((a, b) => a.s - b.s);
+    return out;
+  }
+  function pointOnRectPerimeter(w, h, s) {
+    const ss = (s % 1 + 1) % 1;
+    if (ss < 0.25) return [w * (ss / 0.25), 0];
+    if (ss < 0.5) return [w, h * ((ss - 0.25) / 0.25)];
+    if (ss < 0.75) return [w * (1 - (ss - 0.5) / 0.25), h];
+    return [0, h * (1 - (ss - 0.75) / 0.25)];
+  }
+  function polygonAnchors(verts, policy) {
+    if (verts.length === 0) return [];
+    const segLengths = [];
+    let total = 0;
+    for (let i = 0; i < verts.length; i++) {
+      const a = verts[i];
+      const b = verts[(i + 1) % verts.length];
+      const dx = b[0] - a[0];
+      const dy = b[1] - a[1];
+      const len = Math.hypot(dx, dy);
+      segLengths.push(len);
+      total += len;
+    }
+    const cumS = [0];
+    for (let i = 0; i < segLengths.length; i++) {
+      cumS.push(cumS[i] + segLengths[i] / total);
+    }
+    function pointAt(s) {
+      const ss = (s % 1 + 1) % 1;
+      let i = 0;
+      while (i < cumS.length - 1 && cumS[i + 1] <= ss) i++;
+      const a = verts[i % verts.length];
+      const b = verts[(i + 1) % verts.length];
+      const segS0 = cumS[i];
+      const segS1 = cumS[i + 1];
+      const t = segS1 === segS0 ? 0 : (ss - segS0) / (segS1 - segS0);
+      return [a[0] + (b[0] - a[0]) * t, a[1] + (b[1] - a[1]) * t];
+    }
+    if (policy.kind === "manual") {
+      return policy.anchors.map((a) => ({ id: a.id, s: a.s, point: pointAt(a.s) }));
+    }
+    const out = [];
+    for (let i = 0; i < verts.length; i++) {
+      out.push({
+        id: `v${i}`,
+        s: cumS[i],
+        point: [verts[i][0], verts[i][1]]
+      });
+    }
+    const k = policy.kind === "perEdge" ? Math.max(0, Math.floor(policy.k)) : null;
+    const density = policy.kind === "byLength" ? policy.density : null;
+    for (let i = 0; i < verts.length; i++) {
+      const segLen = segLengths[i];
+      let count = 0;
+      if (k !== null) count = k;
+      if (density !== null) count = Math.max(0, Math.floor(segLen / density) - 1);
+      const s0 = cumS[i];
+      const s1 = cumS[i + 1];
+      for (let j = 1; j <= count; j++) {
+        const t = j / (count + 1);
+        const s = s0 + (s1 - s0) * t;
+        out.push({ id: `v${i}-${j}of${count}`, s, point: pointAt(s) });
+      }
+    }
+    out.sort((a, b) => a.s - b.s);
+    return out;
+  }
+  function ellipseAnchors(rx, ry, policy) {
+    function pointAt(s) {
+      const angle = (s % 1 + 1) % 1 * Math.PI * 2;
+      return [rx * Math.cos(angle), ry * Math.sin(angle)];
+    }
+    if (policy.kind === "manual") {
+      return policy.anchors.map((a) => ({ id: a.id, s: a.s, point: pointAt(a.s) }));
+    }
+    const k = policy.kind === "perEdge" ? Math.max(1, Math.floor(policy.k)) : null;
+    const totalSamples = k !== null ? Math.max(4, k * 4) : Math.max(4, Math.floor(2 * Math.PI * Math.max(rx, ry) / policy.density));
+    const out = [];
+    for (let i = 0; i < totalSamples; i++) {
+      const s = i / totalSamples;
+      out.push({ id: `el${i}of${totalSamples}`, s, point: pointAt(s) });
+    }
+    return out;
+  }
+  function anchorsOf(id) {
+    const node = nodes.get(id);
+    if (!node) return [];
+    const o = node.outline;
+    if (o.kind === "rect") return rectAnchors(o.w, o.h, node.anchorPolicy);
+    if (o.kind === "polygon") return polygonAnchors(o.verts, node.anchorPolicy);
+    if (o.kind === "ellipse") return ellipseAnchors(o.rx, o.ry, node.anchorPolicy);
+    if (o.kind === "path") return polygonAnchors(o.flatten, node.anchorPolicy);
+    return [];
+  }
+  function localBounds(node) {
+    const o = node.outline;
+    if (o.kind === "rect") return { x0: 0, y0: 0, x1: o.w, y1: o.h };
+    if (o.kind === "ellipse") return { x0: -o.rx, y0: -o.ry, x1: o.rx, y1: o.ry };
+    const verts = o.kind === "polygon" ? o.verts : o.flatten;
+    if (verts.length === 0) return { x0: 0, y0: 0, x1: 0, y1: 0 };
+    let x0 = verts[0][0];
+    let x1 = verts[0][0];
+    let y0 = verts[0][1];
+    let y1 = verts[0][1];
+    for (const [x, y] of verts) {
+      if (x < x0) x0 = x;
+      if (x > x1) x1 = x;
+      if (y < y0) y0 = y;
+      if (y > y1) y1 = y;
+    }
+    return { x0, y0, x1, y1 };
+  }
+  function worldOriginOf(id) {
+    let cursor = id;
+    let x = 0;
+    let y = 0;
+    let scale = 1;
+    while (cursor !== null) {
+      const n = nodes.get(cursor);
+      if (!n) break;
+      const s = n.transform.scale ?? 1;
+      x = n.transform.x + x * s;
+      y = n.transform.y + y * s;
+      scale *= s;
+      cursor = n.parentId;
+    }
+    return { x, y, scale };
+  }
+  function boundsOf(id) {
+    const node = nodes.get(id);
+    if (!node) return { x: 0, y: 0, w: 0, h: 0 };
+    const lb = localBounds(node);
+    const origin = worldOriginOf(id);
+    const w = (lb.x1 - lb.x0) * origin.scale;
+    const h = (lb.y1 - lb.y0) * origin.scale;
+    return {
+      x: origin.x + lb.x0 * origin.scale,
+      y: origin.y + lb.y0 * origin.scale,
+      w,
+      h
+    };
+  }
+  function getNodeOBB(id) {
+    const node = nodes.get(id);
+    if (!node) return { center: [0, 0], halfWidth: 0, halfHeight: 0, angle: 0 };
+    const lb = localBounds(node);
+    const origin = worldOriginOf(id);
+    const localCx = (lb.x0 + lb.x1) / 2;
+    const localCy = (lb.y0 + lb.y1) / 2;
+    const halfWidth = Math.abs((lb.x1 - lb.x0) / 2 * origin.scale);
+    const halfHeight = Math.abs((lb.y1 - lb.y0) / 2 * origin.scale);
+    let angle = 0;
+    let cursor = id;
+    while (cursor !== null) {
+      const n = nodes.get(cursor);
+      if (!n) break;
+      angle += n.transform.rot ?? 0;
+      cursor = n.parentId;
+    }
+    const center = [
+      origin.x + localCx * origin.scale,
+      origin.y + localCy * origin.scale
+    ];
+    return { center, halfWidth, halfHeight, angle };
+  }
+  function clear() {
+    nodes.clear();
+    edges.clear();
+    edgesByNode.clear();
+    nodeCounter = 0;
+    edgeCounter = 0;
+    history.clear();
+    pendingEntry = null;
+    transactionDepth = 0;
+    isRestoring = false;
+    publishSnapshot();
+  }
+  function transaction(fn, label) {
+    _withHistory(fn, label);
+  }
+  function pushHistory(label) {
+    if (transactionDepth > 0) {
+      if (pendingEntry !== null) {
+        history.push({ snapshot: pendingEntry.snapshot, label: pendingEntry.label ?? label });
+        history.clearRedo();
+      }
+      pendingEntry = { snapshot: _captureState(), label: void 0 };
+      return;
+    }
+    history.relabelTop(label);
+  }
+  function undo() {
+    if (!history.canUndo()) return false;
+    const entry = history.popUndo();
+    history.pushRedo({ snapshot: _captureState(), label: entry.label });
+    isRestoring = true;
+    try {
+      _restoreState(entry.snapshot);
+    } finally {
+      isRestoring = false;
+    }
+    publishSnapshot();
+    return true;
+  }
+  function redo() {
+    if (!history.canRedo()) return false;
+    const entry = history.popRedo();
+    history.push({ snapshot: _captureState(), label: entry.label });
+    isRestoring = true;
+    try {
+      _restoreState(entry.snapshot);
+    } finally {
+      isRestoring = false;
+    }
+    publishSnapshot();
+    return true;
+  }
+  function canUndo() {
+    return history.canUndo();
+  }
+  function canRedo() {
+    return history.canRedo();
+  }
+  function clearHistory() {
+    history.clear();
+  }
+  return {
+    addNode,
+    removeNode,
+    updateNode,
+    moveNode,
+    setParent,
+    addEdge,
+    removeEdge,
+    getNode,
+    getEdge,
+    getState,
+    childrenOf,
+    edgesOf,
+    anchorsOf,
+    boundsOf,
+    getNodeOBB,
+    subscribe: subscribeLocal,
+    transaction,
+    pushHistory,
+    undo,
+    redo,
+    canUndo,
+    canRedo,
+    clearHistory,
+    clear
+  };
+}
+
+// src/engines/graph/router.ts
+function routeOrthogonal(start, end, options) {
+  const opts = typeof options === "string" ? { preferred: options } : options ?? {};
+  const gridSize = opts.gridSize ?? 10;
+  const stubLength = opts.stubLength ?? Math.max(20, gridSize);
+  const stepPosition = opts.stepPosition ?? 0.5;
+  let sExit = null;
+  let sStub = null;
+  let sCorner = null;
+  let sSide = null;
+  if (opts.sourceBounds) {
+    const exitInfo = exitOnNearestSide(opts.sourceBounds, end, start);
+    sExit = exitInfo.point;
+    sSide = exitInfo.side;
+    sStub = extrudePoint(exitInfo.point, exitInfo.side, stubLength);
+    sCorner = orthoBridge(start, sExit, exitInfo.side);
+  }
+  let tExit = null;
+  let tStub = null;
+  let tCorner = null;
+  let tSide = null;
+  if (opts.targetBounds) {
+    const enterInfo = exitOnNearestSide(opts.targetBounds, start, end);
+    tExit = enterInfo.point;
+    tSide = enterInfo.side;
+    tStub = extrudePoint(enterInfo.point, enterInfo.side, stubLength);
+    tCorner = orthoBridge(end, tExit, enterInfo.side);
+  }
+  const coreStart = sStub ?? start;
+  const coreEnd = tStub ?? end;
+  const obstacles = opts.obstacles ?? [];
+  const filteredObstacles = obstacles.length > 0 && (opts.sourceBounds || opts.targetBounds) ? obstacles.filter((o) => o !== opts.sourceBounds && o !== opts.targetBounds) : obstacles;
+  let core;
+  if (filteredObstacles.length === 0) {
+    if (sSide && tSide) {
+      core = smoothStepRoute(coreStart, sSide, coreEnd, tSide, stepPosition);
+    } else {
+      const snap2 = opts.snap ?? gridSize;
+      core = lRoute(coreStart, coreEnd, opts.preferred ?? "auto", snap2);
+    }
+  } else {
+    const inflate = opts.inflate ?? 0;
+    const maxNodes = opts.maxNodes ?? 5e3;
+    const aStar = aStarRoute(coreStart, coreEnd, filteredObstacles, gridSize, inflate, maxNodes);
+    core = aStar ?? lRoute(coreStart, coreEnd, opts.preferred ?? "auto", opts.snap ?? gridSize);
+  }
+  const points = [];
+  pushIfDistinct(points, start);
+  if (sCorner && !pointsEqual(sCorner, start)) pushIfDistinct(points, sCorner);
+  if (sExit && !pointsEqual(sExit, points[points.length - 1])) pushIfDistinct(points, sExit);
+  if (sStub && !pointsEqual(sStub, points[points.length - 1])) pushIfDistinct(points, sStub);
+  for (let i = 0; i < core.length; i++) {
+    const p = core[i];
+    if (i === 0 && sStub && pointsEqual(p, sStub)) continue;
+    if (i === core.length - 1 && tStub && pointsEqual(p, tStub)) continue;
+    pushIfDistinct(points, p);
+  }
+  if (tStub && !pointsEqual(tStub, points[points.length - 1])) pushIfDistinct(points, tStub);
+  if (tExit && !pointsEqual(tExit, points[points.length - 1])) pushIfDistinct(points, tExit);
+  if (tCorner && !pointsEqual(tCorner, points[points.length - 1])) pushIfDistinct(points, tCorner);
+  if (!pointsEqual(end, points[points.length - 1])) pushIfDistinct(points, end);
+  return compressCollinear(points);
+}
+function smoothStepRoute(coreStart, sSide, coreEnd, tSide, stepPosition) {
+  const [sx, sy] = coreStart;
+  const [tx, ty] = coreEnd;
+  const sAxis = sideAxis(sSide);
+  const tAxis = sideAxis(tSide);
+  const sDir = sideDir(sSide);
+  const tDir = sideDir(tSide);
+  if (sAxis === tAxis) {
+    if (sDir + tDir === 0) {
+      if (sAxis === "x") {
+        const cx = sx + (tx - sx) * stepPosition;
+        return [
+          [sx, sy],
+          [cx, sy],
+          [cx, ty],
+          [tx, ty]
+        ];
+      }
+      const cy = sy + (ty - sy) * stepPosition;
+      return [
+        [sx, sy],
+        [sx, cy],
+        [tx, cy],
+        [tx, ty]
+      ];
+    }
+    if (sAxis === "x") {
+      const extX = sDir > 0 ? Math.max(sx, tx) : Math.min(sx, tx);
+      return [
+        [sx, sy],
+        [extX, sy],
+        [extX, ty],
+        [tx, ty]
+      ];
+    }
+    const extY = sDir > 0 ? Math.max(sy, ty) : Math.min(sy, ty);
+    return [
+      [sx, sy],
+      [sx, extY],
+      [tx, extY],
+      [tx, ty]
+    ];
+  }
+  if (sAxis === "x") {
+    return [
+      [sx, sy],
+      [tx, sy],
+      [tx, ty]
+    ];
+  }
+  return [
+    [sx, sy],
+    [sx, ty],
+    [tx, ty]
+  ];
+}
+function sideAxis(s) {
+  return s === "left" || s === "right" ? "x" : "y";
+}
+function sideDir(s) {
+  return s === "right" || s === "bottom" ? 1 : -1;
+}
+function pointsToPath(points) {
+  if (points.length === 0) return "";
+  const [head, ...rest] = points;
+  return `M ${head[0]} ${head[1]} ${rest.map((p) => `L ${p[0]} ${p[1]}`).join(" ")}`;
+}
+function pointsToRoundedPath(points, radius) {
+  if (points.length === 0) return "";
+  if (points.length < 3 || radius <= 0) return pointsToPath(points);
+  let d = `M ${points[0][0]} ${points[0][1]}`;
+  for (let i = 1; i < points.length - 1; i++) {
+    const a = points[i - 1];
+    const b = points[i];
+    const c = points[i + 1];
+    const lenAB = Math.hypot(b[0] - a[0], b[1] - a[1]);
+    const lenBC = Math.hypot(c[0] - b[0], c[1] - b[1]);
+    const r = Math.min(radius, lenAB / 2, lenBC / 2);
+    const ux = (b[0] - a[0]) / (lenAB || 1);
+    const uy = (b[1] - a[1]) / (lenAB || 1);
+    const vx = (c[0] - b[0]) / (lenBC || 1);
+    const vy = (c[1] - b[1]) / (lenBC || 1);
+    const cross = ux * vy - uy * vx;
+    if (r < 0.5 || Math.abs(cross) < 1e-9) {
+      d += ` L ${b[0]} ${b[1]}`;
+      continue;
+    }
+    const p1x = b[0] - ux * r;
+    const p1y = b[1] - uy * r;
+    const p2x = b[0] + vx * r;
+    const p2y = b[1] + vy * r;
+    d += ` L ${p1x} ${p1y} Q ${b[0]} ${b[1]} ${p2x} ${p2y}`;
+  }
+  const tail = points[points.length - 1];
+  d += ` L ${tail[0]} ${tail[1]}`;
+  return d;
+}
+function controlOffset(distance, curvature) {
+  if (distance >= 0) return 0.5 * distance;
+  return curvature * 25 * Math.sqrt(-distance);
+}
+function controlPoint(side, x1, y1, x2, y2, curvature) {
+  switch (side) {
+    case "left":
+      return [x1 - controlOffset(x1 - x2, curvature), y1];
+    case "right":
+      return [x1 + controlOffset(x2 - x1, curvature), y1];
+    case "top":
+      return [x1, y1 - controlOffset(y1 - y2, curvature)];
+    case "bottom":
+      return [x1, y1 + controlOffset(y2 - y1, curvature)];
+  }
+}
+function getBezierPath(opts) {
+  const curvature = opts.curvature ?? 0.25;
+  const [sx, sy] = opts.source;
+  const [tx, ty] = opts.target;
+  const [c1x, c1y] = controlPoint(opts.sourceSide, sx, sy, tx, ty, curvature);
+  const [c2x, c2y] = controlPoint(opts.targetSide, tx, ty, sx, sy, curvature);
+  return `M ${sx} ${sy} C ${c1x} ${c1y} ${c2x} ${c2y} ${tx} ${ty}`;
+}
+function floatingAnchor(box, opposite) {
+  const cx = box.x + box.w / 2;
+  const cy = box.y + box.h / 2;
+  const dx = opposite[0] - cx;
+  const dy = opposite[1] - cy;
+  if (dx === 0 && dy === 0) {
+    return { point: [box.x + box.w, cy], side: "right" };
+  }
+  const hw = box.w / 2;
+  const hh = box.h / 2;
+  const tx = dx === 0 ? Infinity : hw / Math.abs(dx);
+  const ty = dy === 0 ? Infinity : hh / Math.abs(dy);
+  if (tx < ty) {
+    const sign2 = dx > 0 ? 1 : -1;
+    return {
+      point: [cx + sign2 * hw, cy + sign2 * (hw / Math.abs(dx)) * dy],
+      side: sign2 > 0 ? "right" : "left"
+    };
+  }
+  const sign = dy > 0 ? 1 : -1;
+  return {
+    point: [cx + sign * (hh / Math.abs(dy)) * dx, cy + sign * hh],
+    side: sign > 0 ? "bottom" : "top"
+  };
+}
+function nearestSide(box, target) {
+  const cx = box.x + box.w / 2;
+  const cy = box.y + box.h / 2;
+  const dx = target[0] - cx;
+  const dy = target[1] - cy;
+  if (Math.abs(dx) >= Math.abs(dy)) return dx >= 0 ? "right" : "left";
+  return dy >= 0 ? "bottom" : "top";
+}
+function getNodeIntersection(intersectionBox, targetCenter) {
+  const w = intersectionBox.w / 2;
+  const h = intersectionBox.h / 2;
+  const x2 = intersectionBox.x + w;
+  const y2 = intersectionBox.y + h;
+  if (w === 0 || h === 0) return [x2, y2];
+  const x1 = targetCenter[0];
+  const y1 = targetCenter[1];
+  const xx1 = (x1 - x2) / (2 * w) - (y1 - y2) / (2 * h);
+  const yy1 = (x1 - x2) / (2 * w) + (y1 - y2) / (2 * h);
+  const denom = Math.abs(xx1) + Math.abs(yy1);
+  if (denom === 0) {
+    return [intersectionBox.x + intersectionBox.w, y2];
+  }
+  const a = 1 / denom;
+  const xx3 = a * xx1;
+  const yy3 = a * yy1;
+  const x = w * (xx3 + yy3) + x2;
+  const y = h * (-xx3 + yy3) + y2;
+  return [x, y];
+}
+function getEdgePosition(box, intersectionPoint) {
+  const nx = Math.round(box.x);
+  const ny = Math.round(box.y);
+  const px = Math.round(intersectionPoint[0]);
+  const py = Math.round(intersectionPoint[1]);
+  if (px <= nx + 1) return "left";
+  if (px >= nx + box.w - 1) return "right";
+  if (py <= ny + 1) return "top";
+  if (py >= ny + box.h - 1) return "bottom";
+  return "top";
+}
+function resolveEdgeEndpoint(sourceBox, targetBox, padding = 0) {
+  const targetCenter = [targetBox.x + targetBox.w / 2, targetBox.y + targetBox.h / 2];
+  const raw = getNodeIntersection(sourceBox, targetCenter);
+  const side = getEdgePosition(sourceBox, raw);
+  if (padding === 0) return { point: raw, side };
+  let point = raw;
+  switch (side) {
+    case "right":
+      point = [raw[0] + padding, raw[1]];
+      break;
+    case "left":
+      point = [raw[0] - padding, raw[1]];
+      break;
+    case "bottom":
+      point = [raw[0], raw[1] + padding];
+      break;
+    case "top":
+      point = [raw[0], raw[1] - padding];
+      break;
+  }
+  return { point, side };
+}
+function inferSide(box, anchor, opposite, tolerance = 1) {
+  const onLeft = Math.abs(anchor[0] - box.x) <= tolerance;
+  const onRight = Math.abs(anchor[0] - (box.x + box.w)) <= tolerance;
+  const onTop = Math.abs(anchor[1] - box.y) <= tolerance;
+  const onBottom = Math.abs(anchor[1] - (box.y + box.h)) <= tolerance;
+  const horizontalHit = onLeft || onRight;
+  const verticalHit = onTop || onBottom;
+  if (horizontalHit && verticalHit) {
+    const cx = box.x + box.w / 2;
+    const cy = box.y + box.h / 2;
+    const dx = opposite[0] - cx;
+    const dy = opposite[1] - cy;
+    if (Math.abs(dx) >= Math.abs(dy)) {
+      return { side: onRight ? "right" : "left", confident: true };
+    }
+    return { side: onBottom ? "bottom" : "top", confident: true };
+  }
+  if (onLeft) return { side: "left", confident: true };
+  if (onRight) return { side: "right", confident: true };
+  if (onTop) return { side: "top", confident: true };
+  if (onBottom) return { side: "bottom", confident: true };
+  return { side: nearestSide(box, opposite), confident: false };
+}
+function exitOnNearestSide(box, target, anchor) {
+  const cx = box.x + box.w / 2;
+  const cy = box.y + box.h / 2;
+  if (anchor) {
+    const tolerance = 1;
+    const onLeft = Math.abs(anchor[0] - box.x) <= tolerance;
+    const onRight = Math.abs(anchor[0] - (box.x + box.w)) <= tolerance;
+    const onTop = Math.abs(anchor[1] - box.y) <= tolerance;
+    const onBottom = Math.abs(anchor[1] - (box.y + box.h)) <= tolerance;
+    const horizontalHit = onLeft || onRight;
+    const verticalHit = onTop || onBottom;
+    if (horizontalHit && verticalHit) {
+      const dx2 = target[0] - cx;
+      const dy2 = target[1] - cy;
+      if (Math.abs(dx2) >= Math.abs(dy2)) {
+        return onRight ? { point: [box.x + box.w, cy], side: "right" } : { point: [box.x, cy], side: "left" };
+      }
+      return onBottom ? { point: [cx, box.y + box.h], side: "bottom" } : { point: [cx, box.y], side: "top" };
+    }
+    if (onRight) return { point: [box.x + box.w, cy], side: "right" };
+    if (onLeft) return { point: [box.x, cy], side: "left" };
+    if (onBottom) return { point: [cx, box.y + box.h], side: "bottom" };
+    if (onTop) return { point: [cx, box.y], side: "top" };
+  }
+  const dx = target[0] - cx;
+  const dy = target[1] - cy;
+  if (Math.abs(dx) >= Math.abs(dy)) {
+    if (dx >= 0) return { point: [box.x + box.w, cy], side: "right" };
+    return { point: [box.x, cy], side: "left" };
+  }
+  if (dy >= 0) return { point: [cx, box.y + box.h], side: "bottom" };
+  return { point: [cx, box.y], side: "top" };
+}
+function extrudePoint(point, side, distance) {
+  switch (side) {
+    case "top":
+      return [point[0], point[1] - distance];
+    case "right":
+      return [point[0] + distance, point[1]];
+    case "bottom":
+      return [point[0], point[1] + distance];
+    case "left":
+      return [point[0] - distance, point[1]];
+  }
+}
+function orthoBridge(start, exit, side) {
+  switch (side) {
+    case "right":
+    case "left":
+      return [exit[0], start[1]];
+    case "top":
+    case "bottom":
+      return [start[0], exit[1]];
+  }
+}
+function pointsEqual(a, b) {
+  return a[0] === b[0] && a[1] === b[1];
+}
+function pushIfDistinct(arr, p) {
+  if (arr.length === 0) {
+    arr.push(p);
+    return;
+  }
+  const last = arr[arr.length - 1];
+  if (!pointsEqual(last, p)) arr.push(p);
+}
+function compressCollinear(points) {
+  if (points.length <= 2) return points.slice();
+  const out = [points[0], points[1]];
+  for (let i = 2; i < points.length; i++) {
+    const cur = points[i];
+    const a = out[out.length - 2];
+    const b = out[out.length - 1];
+    const dx1 = b[0] - a[0];
+    const dy1 = b[1] - a[1];
+    const dx2 = cur[0] - b[0];
+    const dy2 = cur[1] - b[1];
+    const cross = dx1 * dy2 - dy1 * dx2;
+    if (cross === 0 && Math.sign(dx1) === Math.sign(dx2) && Math.sign(dy1) === Math.sign(dy2)) {
+      out[out.length - 1] = cur;
+    } else {
+      out.push(cur);
+    }
+  }
+  return out;
+}
+function lRoute(start, end, preferred, _snapStep) {
+  const [sx, sy] = start;
+  const [ex, ey] = end;
+  if (sx === ex || sy === ey) return [start, end];
+  const dx = Math.abs(ex - sx);
+  const dy = Math.abs(ey - sy);
+  const useHV = preferred === "hv" ? true : preferred === "vh" ? false : dx >= dy;
+  if (useHV) return [start, [ex, sy], end];
+  return [start, [sx, ey], end];
+}
+function inflateObstacles(obstacles, pad) {
+  return obstacles.map((o) => ({
+    x0: o.x - pad,
+    y0: o.y - pad,
+    x1: o.x + o.w + pad,
+    y1: o.y + o.h + pad
+  }));
+}
+function pointBlocked(x, y, rects) {
+  for (const r of rects) {
+    if (x > r.x0 && x < r.x1 && y > r.y0 && y < r.y1) return true;
+  }
+  return false;
+}
+function snap(value, step) {
+  return Math.round(value / step) * step;
+}
+function key(x, y) {
+  return `${x},${y}`;
+}
+function manhattan(ax, ay, bx, by) {
+  return Math.abs(ax - bx) + Math.abs(ay - by);
+}
+function reconstruct(cameFrom, endKey) {
+  const reversed = [];
+  let cursor = endKey;
+  while (cursor !== void 0) {
+    const [xs, ys] = cursor.split(",");
+    reversed.push([Number(xs), Number(ys)]);
+    cursor = cameFrom.get(cursor);
+  }
+  reversed.reverse();
+  const out = [];
+  for (let i = 0; i < reversed.length; i++) {
+    const cur = reversed[i];
+    if (out.length < 2) {
+      out.push(cur);
+      continue;
+    }
+    const a = out[out.length - 2];
+    const b = out[out.length - 1];
+    const dx1 = b[0] - a[0];
+    const dy1 = b[1] - a[1];
+    const dx2 = cur[0] - b[0];
+    const dy2 = cur[1] - b[1];
+    if (Math.sign(dx1) === Math.sign(dx2) && Math.sign(dy1) === Math.sign(dy2)) {
+      out[out.length - 1] = cur;
+    } else {
+      out.push(cur);
+    }
+  }
+  return out;
+}
+var MinHeap = class {
+  data = [];
+  get size() {
+    return this.data.length;
+  }
+  push(entry) {
+    this.data.push(entry);
+    this.bubbleUp(this.data.length - 1);
+  }
+  pop() {
+    if (this.data.length === 0) return void 0;
+    const head = this.data[0];
+    const tail = this.data.pop();
+    if (this.data.length > 0) {
+      this.data[0] = tail;
+      this.bubbleDown(0);
+    }
+    return head;
+  }
+  bubbleUp(i) {
+    while (i > 0) {
+      const parent = i - 1 >> 1;
+      if (this.data[i].f < this.data[parent].f) {
+        const tmp = this.data[i];
+        this.data[i] = this.data[parent];
+        this.data[parent] = tmp;
+        i = parent;
+      } else {
+        return;
+      }
+    }
+  }
+  bubbleDown(i) {
+    const n = this.data.length;
+    while (true) {
+      const l = i * 2 + 1;
+      const r = l + 1;
+      let smallest = i;
+      if (l < n && this.data[l].f < this.data[smallest].f) smallest = l;
+      if (r < n && this.data[r].f < this.data[smallest].f) smallest = r;
+      if (smallest === i) return;
+      const tmp = this.data[i];
+      this.data[i] = this.data[smallest];
+      this.data[smallest] = tmp;
+      i = smallest;
+    }
+  }
+};
+function aStarRoute(start, end, obstacles, gridSize, inflate, maxNodes) {
+  const rects = inflateObstacles(obstacles, inflate);
+  const sx = snap(start[0], gridSize);
+  const sy = snap(start[1], gridSize);
+  const ex = snap(end[0], gridSize);
+  const ey = snap(end[1], gridSize);
+  if (pointBlocked(sx, sy, rects) || pointBlocked(ex, ey, rects)) return null;
+  const startKey = key(sx, sy);
+  const endKey = key(ex, ey);
+  const gScore = /* @__PURE__ */ new Map([[startKey, 0]]);
+  const cameFrom = /* @__PURE__ */ new Map();
+  const cameDir = /* @__PURE__ */ new Map([[startKey, null]]);
+  const open = new MinHeap();
+  open.push({ k: startKey, x: sx, y: sy, f: manhattan(sx, sy, ex, ey) });
+  const TURN_PENALTY = gridSize;
+  let expansions = 0;
+  while (open.size > 0) {
+    if (expansions++ > maxNodes) return null;
+    const current = open.pop();
+    const bestG = gScore.get(current.k) ?? Infinity;
+    const expectedF = bestG + manhattan(current.x, current.y, ex, ey);
+    if (current.f > expectedF) continue;
+    if (current.k === endKey) {
+      const path = reconstruct(cameFrom, endKey);
+      if (path.length > 0) {
+        path[0] = start;
+        path[path.length - 1] = end;
+      }
+      return path;
+    }
+    const incomingDir = cameDir.get(current.k) ?? null;
+    const neighbours = [
+      [gridSize, 0, "h"],
+      [-gridSize, 0, "h"],
+      [0, gridSize, "v"],
+      [0, -gridSize, "v"]
+    ];
+    for (const [dx, dy, dir] of neighbours) {
+      const nx = current.x + dx;
+      const ny = current.y + dy;
+      if (pointBlocked(nx, ny, rects)) continue;
+      const turn = incomingDir !== null && incomingDir !== dir;
+      const tentativeG = bestG + gridSize + (turn ? TURN_PENALTY : 0);
+      const nk = key(nx, ny);
+      const prevG = gScore.get(nk) ?? Infinity;
+      if (tentativeG < prevG) {
+        cameFrom.set(nk, current.k);
+        cameDir.set(nk, dir);
+        gScore.set(nk, tentativeG);
+        const f = tentativeG + manhattan(nx, ny, ex, ey);
+        open.push({ k: nk, x: nx, y: ny, f });
+      }
+    }
+  }
+  return null;
+}
+
+// src/engines/graph/obb.ts
+function obbCorners(obb) {
+  const cos = Math.cos(obb.angle);
+  const sin = Math.sin(obb.angle);
+  const { halfWidth: hw, halfHeight: hh } = obb;
+  const [cx, cy] = obb.center;
+  const lx = [-hw, hw, hw, -hw];
+  const ly = [-hh, -hh, hh, hh];
+  const out = [];
+  for (let i = 0; i < 4; i++) {
+    const x = lx[i];
+    const y = ly[i];
+    out.push([cx + x * cos - y * sin, cy + x * sin + y * cos]);
+  }
+  return out;
+}
+function aabbFromOBB(obb) {
+  const corners = obbCorners(obb);
+  let x0 = corners[0][0];
+  let x1 = corners[0][0];
+  let y0 = corners[0][1];
+  let y1 = corners[0][1];
+  for (let i = 1; i < 4; i++) {
+    const [x, y] = corners[i];
+    if (x < x0) x0 = x;
+    if (x > x1) x1 = x;
+    if (y < y0) y0 = y;
+    if (y > y1) y1 = y;
+  }
+  return { x: x0, y: y0, w: x1 - x0, h: y1 - y0 };
+}
+function obbContainsPoint(obb, p) {
+  const cos = Math.cos(-obb.angle);
+  const sin = Math.sin(-obb.angle);
+  const dx = p[0] - obb.center[0];
+  const dy = p[1] - obb.center[1];
+  const lx = dx * cos - dy * sin;
+  const ly = dx * sin + dy * cos;
+  return Math.abs(lx) <= obb.halfWidth && Math.abs(ly) <= obb.halfHeight;
+}
+
+export {
+  createGraph,
+  routeOrthogonal,
+  pointsToPath,
+  pointsToRoundedPath,
+  getBezierPath,
+  floatingAnchor,
+  nearestSide,
+  getNodeIntersection,
+  getEdgePosition,
+  resolveEdgeEndpoint,
+  inferSide,
+  obbCorners,
+  aabbFromOBB,
+  obbContainsPoint
+};
+//# sourceMappingURL=chunk-7FA2TBSZ.js.map