@skygraph/core 0.4.0 → 0.5.0

package/dist/graph.d.cts

@@ -402,7 +402,8 @@ interface RouteOrthogonalOptions {
     targetBounds?: AABB;
     /**
      * Length (world units) of the perpendicular stub generated when
-     * `sourceBounds` / `targetBounds` is set. Defaults to `max(8, gridSize)`.
+     * `sourceBounds` / `targetBounds` is set. Defaults to `max(20, gridSize)`
+     * — matches React Flow's `offset = 20` for smoothstep edges.
      */
     stubLength?: number;
     /**
@@ -412,6 +413,19 @@ interface RouteOrthogonalOptions {
      * affects the L-route fallback.
      */
     snap?: number;
+    /**
+     * Where the central bend sits on the connector when both
+     * `sourceBounds` and `targetBounds` are provided.
+     *
+     *   - `0`   → bend right at the source stub
+     *   - `0.5` → midpoint between the two stubs (default — matches
+     *             React Flow's `stepPosition`)
+     *   - `1`   → bend right at the target stub
+     *
+     * Ignored when bounds are missing (we fall back to the legacy L-route)
+     * or when A* is engaged (it picks bends from path-cost, not position).
+     */
+    stepPosition?: number;
 }
 /**
  * Compute an orthogonal (right-angled) path between two points.
@@ -483,6 +497,23 @@ interface BezierPathOptions {
  * point when the caller doesn't already know it.
  */
 declare function getBezierPath(opts: BezierPathOptions): string;
+/**
+ * Compute the intersection of the line from `box`'s centre to
+ * `opposite` with the rectangle's border. Returns the border point and
+ * the side it sits on.
+ *
+ * This is the "floating anchor" trick used by React Flow's
+ * FloatingEdges example and most graph viz libraries: instead of
+ * binding an endpoint to a fixed corner or midpoint, you bind it to
+ * the centre and let it slide along the perimeter following the
+ * direction to the other node. The result is dramatically cleaner on
+ * dense / unstructured graphs because every edge picks the closest
+ * face automatically as nodes are dragged around.
+ */
+declare function floatingAnchor(box: AABB, opposite: Point): {
+    point: Point;
+    side: Side;
+};
 /**
  * Pick the side of `box` whose midpoint is closest to `target`. Same
  * logic as the internal helper used by orthogonal routing — exposed
@@ -490,6 +521,104 @@ declare function getBezierPath(opts: BezierPathOptions): string;
  * it.
  */
 declare function nearestSide(box: AABB, target: Point): Side;
+/**
+ * Resolved edge endpoint geometry — output of {@link resolveEdgeEndpoint}.
+ *
+ * `point` is in world space, sitting on (or just outside of) the
+ * `box` border. `side` records which face the connector exits / enters
+ * so downstream consumers (bezier control handles, orthogonal stubs)
+ * can stay perpendicular.
+ */
+interface ResolvedEndpoint {
+    point: Point;
+    side: Side;
+}
+/**
+ * Compute the intersection of the segment between the centre of
+ * `intersectionBox` and `targetCenter` with the perimeter of
+ * `intersectionBox`.
+ *
+ * **Source / credit.** Direct port of the algorithm used by xyflow
+ * (React Flow) for FloatingEdges and by mxGraph / draw.io's
+ * `mxPerimeter.RectanglePerimeter`. The closed-form derivation is in
+ * https://math.stackexchange.com/questions/1724792 — it parametrises
+ * the rectangle as the manhattan-norm rhombus `|x| + |y| = 1` and
+ * solves for the unit intersection in one step, which is faster and
+ * numerically more stable than the angle-based formulation.
+ *
+ * We use this as the canonical endpoint resolver for every routing
+ * mode (`straight` / `orthogonal` / `bezier`). The visible benefit is
+ * stability: nothing in this function depends on user-supplied
+ * anchors — the side, the point, the angle of approach are all pure
+ * functions of the two rectangles' bounding boxes, so dragging a node
+ * around never produces the "wrong-side-of-the-box" / "edge cuts
+ * through the node body" artifacts that the anchor-honouring resolver
+ * used to leak.
+ *
+ * Returns the world-space intersection point. When `box` has zero
+ * area (degenerate node) the function returns its centre so callers
+ * can still draw a useful edge to it.
+ */
+declare function getNodeIntersection(intersectionBox: AABB, targetCenter: Point): Point;
+/**
+ * Classify which face of `box` the `intersectionPoint` sits on.
+ * Companion to {@link getNodeIntersection} — together they replace the
+ * old anchor-driven endpoint resolver.
+ *
+ * The function rounds both the box position and the point to integer
+ * pixels (matches the xyflow heuristic) before comparing, which keeps
+ * floating-point noise from picking the wrong side when an
+ * intersection lands almost exactly on a corner.
+ */
+declare function getEdgePosition(box: AABB, intersectionPoint: Point): Side;
+/**
+ * Single canonical edge endpoint resolver used by `<Diagram>` for
+ * every routing mode. Wraps {@link getNodeIntersection} +
+ * {@link getEdgePosition} into the `{ point, side }` shape the
+ * adapters expect, and applies a small outward `padding` so the
+ * arrowhead marker has room to sit between the path tip and the node
+ * border (matches React Flow / draw.io behaviour).
+ *
+ * **Important: anchor information is intentionally ignored here.**
+ * The `<Diagram>` API still accepts `from: { anchor: 'nw' }` etc. for
+ * back-compat and semantic intent, but the visual layer now derives
+ * the endpoint purely from bounding boxes. This is the floating-edges
+ * approach taken by every mainstream diagram library — it's what
+ * makes drag-around-the-canvas behaviour feel correct on randomly
+ * laid-out graphs.
+ */
+declare function resolveEdgeEndpoint(sourceBox: AABB, targetBox: AABB, padding?: number): ResolvedEndpoint;
+/**
+ * Decide which face an endpoint sits on, combining two cues:
+ *
+ *   1. **Anchor position** — if `anchor` is already at one of `box`'s
+ *      borders (within `tolerance`), the corresponding face is returned
+ *      as-is. This lets consumers express intent ("exit from the right
+ *      side") simply by placing the anchor on that border.
+ *
+ *   2. **Geometry fallback** — when the anchor is interior to `box`
+ *      (or no border match) we fall back to {@link nearestSide} pointed
+ *      at the opposite endpoint. This is the right answer for centre
+ *      anchors and produces stable sides for big graphs where every
+ *      pair of nodes has a different relative position.
+ *
+ * Returns the side along with a `confident` flag — `true` when the
+ * decision came from the anchor position (case 1), `false` when it
+ * fell back to geometry (case 2). Consumers that want to override the
+ * fallback in special cases can branch on the flag.
+ *
+ * Corner anchors (touching two borders simultaneously like `nw` / `ne`)
+ * are disambiguated by which face points more strongly at the opposite
+ * endpoint. **The disambiguation is also clamped to faces that face the
+ * other node** — a `ne` anchor on the source whose target sits to its
+ * left will pick `left` instead of `right`, because using `right` would
+ * route the edge AWAY from the target. This is the key fix for the
+ * "stub-then-180°-loop" artifact visible on randomly-laid-out graphs.
+ */
+declare function inferSide(box: AABB, anchor: Point, opposite: Point, tolerance?: number): {
+    side: Side;
+    confident: boolean;
+};
 
 /**
  * Oriented Bounding Box — a rectangle in world space described by its centre,
@@ -539,4 +668,4 @@ declare function aabbFromOBB(obb: OBB): AABB;
  */
 declare function obbContainsPoint(obb: OBB, p: Point): boolean;
 
-export { type AABB, type Anchor, type AnchorId, type AnchorPolicy, type BezierPathOptions, type EdgeEndpoint, type EdgeId, type EdgeInit, type GraphEdge, type GraphEngine, type GraphEngineOptions, type GraphNode, type GraphState, type NodeId, type NodeInit, type NodeTransform, type NodeUpdate, type OBB$1 as OBB, type Outline, type Point, type RouteOrthogonalOptions, type Side, aabbFromOBB, createGraph, getBezierPath, nearestSide, obbContainsPoint, obbCorners, pointsToPath, pointsToRoundedPath, routeOrthogonal };
+export { type AABB, type Anchor, type AnchorId, type AnchorPolicy, type BezierPathOptions, type EdgeEndpoint, type EdgeId, type EdgeInit, type GraphEdge, type GraphEngine, type GraphEngineOptions, type GraphNode, type GraphState, type NodeId, type NodeInit, type NodeTransform, type NodeUpdate, type OBB$1 as OBB, type Outline, type Point, type ResolvedEndpoint, type RouteOrthogonalOptions, type Side, aabbFromOBB, createGraph, floatingAnchor, getBezierPath, getEdgePosition, getNodeIntersection, inferSide, nearestSide, obbContainsPoint, obbCorners, pointsToPath, pointsToRoundedPath, resolveEdgeEndpoint, routeOrthogonal };

package/dist/graph.d.ts

@@ -402,7 +402,8 @@ interface RouteOrthogonalOptions {
     targetBounds?: AABB;
     /**
      * Length (world units) of the perpendicular stub generated when
-     * `sourceBounds` / `targetBounds` is set. Defaults to `max(8, gridSize)`.
+     * `sourceBounds` / `targetBounds` is set. Defaults to `max(20, gridSize)`
+     * — matches React Flow's `offset = 20` for smoothstep edges.
      */
     stubLength?: number;
     /**
@@ -412,6 +413,19 @@ interface RouteOrthogonalOptions {
      * affects the L-route fallback.
      */
     snap?: number;
+    /**
+     * Where the central bend sits on the connector when both
+     * `sourceBounds` and `targetBounds` are provided.
+     *
+     *   - `0`   → bend right at the source stub
+     *   - `0.5` → midpoint between the two stubs (default — matches
+     *             React Flow's `stepPosition`)
+     *   - `1`   → bend right at the target stub
+     *
+     * Ignored when bounds are missing (we fall back to the legacy L-route)
+     * or when A* is engaged (it picks bends from path-cost, not position).
+     */
+    stepPosition?: number;
 }
 /**
  * Compute an orthogonal (right-angled) path between two points.
@@ -483,6 +497,23 @@ interface BezierPathOptions {
  * point when the caller doesn't already know it.
  */
 declare function getBezierPath(opts: BezierPathOptions): string;
+/**
+ * Compute the intersection of the line from `box`'s centre to
+ * `opposite` with the rectangle's border. Returns the border point and
+ * the side it sits on.
+ *
+ * This is the "floating anchor" trick used by React Flow's
+ * FloatingEdges example and most graph viz libraries: instead of
+ * binding an endpoint to a fixed corner or midpoint, you bind it to
+ * the centre and let it slide along the perimeter following the
+ * direction to the other node. The result is dramatically cleaner on
+ * dense / unstructured graphs because every edge picks the closest
+ * face automatically as nodes are dragged around.
+ */
+declare function floatingAnchor(box: AABB, opposite: Point): {
+    point: Point;
+    side: Side;
+};
 /**
  * Pick the side of `box` whose midpoint is closest to `target`. Same
  * logic as the internal helper used by orthogonal routing — exposed
@@ -490,6 +521,104 @@ declare function getBezierPath(opts: BezierPathOptions): string;
  * it.
  */
 declare function nearestSide(box: AABB, target: Point): Side;
+/**
+ * Resolved edge endpoint geometry — output of {@link resolveEdgeEndpoint}.
+ *
+ * `point` is in world space, sitting on (or just outside of) the
+ * `box` border. `side` records which face the connector exits / enters
+ * so downstream consumers (bezier control handles, orthogonal stubs)
+ * can stay perpendicular.
+ */
+interface ResolvedEndpoint {
+    point: Point;
+    side: Side;
+}
+/**
+ * Compute the intersection of the segment between the centre of
+ * `intersectionBox` and `targetCenter` with the perimeter of
+ * `intersectionBox`.
+ *
+ * **Source / credit.** Direct port of the algorithm used by xyflow
+ * (React Flow) for FloatingEdges and by mxGraph / draw.io's
+ * `mxPerimeter.RectanglePerimeter`. The closed-form derivation is in
+ * https://math.stackexchange.com/questions/1724792 — it parametrises
+ * the rectangle as the manhattan-norm rhombus `|x| + |y| = 1` and
+ * solves for the unit intersection in one step, which is faster and
+ * numerically more stable than the angle-based formulation.
+ *
+ * We use this as the canonical endpoint resolver for every routing
+ * mode (`straight` / `orthogonal` / `bezier`). The visible benefit is
+ * stability: nothing in this function depends on user-supplied
+ * anchors — the side, the point, the angle of approach are all pure
+ * functions of the two rectangles' bounding boxes, so dragging a node
+ * around never produces the "wrong-side-of-the-box" / "edge cuts
+ * through the node body" artifacts that the anchor-honouring resolver
+ * used to leak.
+ *
+ * Returns the world-space intersection point. When `box` has zero
+ * area (degenerate node) the function returns its centre so callers
+ * can still draw a useful edge to it.
+ */
+declare function getNodeIntersection(intersectionBox: AABB, targetCenter: Point): Point;
+/**
+ * Classify which face of `box` the `intersectionPoint` sits on.
+ * Companion to {@link getNodeIntersection} — together they replace the
+ * old anchor-driven endpoint resolver.
+ *
+ * The function rounds both the box position and the point to integer
+ * pixels (matches the xyflow heuristic) before comparing, which keeps
+ * floating-point noise from picking the wrong side when an
+ * intersection lands almost exactly on a corner.
+ */
+declare function getEdgePosition(box: AABB, intersectionPoint: Point): Side;
+/**
+ * Single canonical edge endpoint resolver used by `<Diagram>` for
+ * every routing mode. Wraps {@link getNodeIntersection} +
+ * {@link getEdgePosition} into the `{ point, side }` shape the
+ * adapters expect, and applies a small outward `padding` so the
+ * arrowhead marker has room to sit between the path tip and the node
+ * border (matches React Flow / draw.io behaviour).
+ *
+ * **Important: anchor information is intentionally ignored here.**
+ * The `<Diagram>` API still accepts `from: { anchor: 'nw' }` etc. for
+ * back-compat and semantic intent, but the visual layer now derives
+ * the endpoint purely from bounding boxes. This is the floating-edges
+ * approach taken by every mainstream diagram library — it's what
+ * makes drag-around-the-canvas behaviour feel correct on randomly
+ * laid-out graphs.
+ */
+declare function resolveEdgeEndpoint(sourceBox: AABB, targetBox: AABB, padding?: number): ResolvedEndpoint;
+/**
+ * Decide which face an endpoint sits on, combining two cues:
+ *
+ *   1. **Anchor position** — if `anchor` is already at one of `box`'s
+ *      borders (within `tolerance`), the corresponding face is returned
+ *      as-is. This lets consumers express intent ("exit from the right
+ *      side") simply by placing the anchor on that border.
+ *
+ *   2. **Geometry fallback** — when the anchor is interior to `box`
+ *      (or no border match) we fall back to {@link nearestSide} pointed
+ *      at the opposite endpoint. This is the right answer for centre
+ *      anchors and produces stable sides for big graphs where every
+ *      pair of nodes has a different relative position.
+ *
+ * Returns the side along with a `confident` flag — `true` when the
+ * decision came from the anchor position (case 1), `false` when it
+ * fell back to geometry (case 2). Consumers that want to override the
+ * fallback in special cases can branch on the flag.
+ *
+ * Corner anchors (touching two borders simultaneously like `nw` / `ne`)
+ * are disambiguated by which face points more strongly at the opposite
+ * endpoint. **The disambiguation is also clamped to faces that face the
+ * other node** — a `ne` anchor on the source whose target sits to its
+ * left will pick `left` instead of `right`, because using `right` would
+ * route the edge AWAY from the target. This is the key fix for the
+ * "stub-then-180°-loop" artifact visible on randomly-laid-out graphs.
+ */
+declare function inferSide(box: AABB, anchor: Point, opposite: Point, tolerance?: number): {
+    side: Side;
+    confident: boolean;
+};
 
 /**
  * Oriented Bounding Box — a rectangle in world space described by its centre,
@@ -539,4 +668,4 @@ declare function aabbFromOBB(obb: OBB): AABB;
  */
 declare function obbContainsPoint(obb: OBB, p: Point): boolean;
 
-export { type AABB, type Anchor, type AnchorId, type AnchorPolicy, type BezierPathOptions, type EdgeEndpoint, type EdgeId, type EdgeInit, type GraphEdge, type GraphEngine, type GraphEngineOptions, type GraphNode, type GraphState, type NodeId, type NodeInit, type NodeTransform, type NodeUpdate, type OBB$1 as OBB, type Outline, type Point, type RouteOrthogonalOptions, type Side, aabbFromOBB, createGraph, getBezierPath, nearestSide, obbContainsPoint, obbCorners, pointsToPath, pointsToRoundedPath, routeOrthogonal };
+export { type AABB, type Anchor, type AnchorId, type AnchorPolicy, type BezierPathOptions, type EdgeEndpoint, type EdgeId, type EdgeInit, type GraphEdge, type GraphEngine, type GraphEngineOptions, type GraphNode, type GraphState, type NodeId, type NodeInit, type NodeTransform, type NodeUpdate, type OBB$1 as OBB, type Outline, type Point, type ResolvedEndpoint, type RouteOrthogonalOptions, type Side, aabbFromOBB, createGraph, floatingAnchor, getBezierPath, getEdgePosition, getNodeIntersection, inferSide, nearestSide, obbContainsPoint, obbCorners, pointsToPath, pointsToRoundedPath, resolveEdgeEndpoint, routeOrthogonal };

package/dist/graph.js

@@ -1,24 +1,34 @@
 import {
   aabbFromOBB,
   createGraph,
+  floatingAnchor,
   getBezierPath,
+  getEdgePosition,
+  getNodeIntersection,
+  inferSide,
   nearestSide,
   obbContainsPoint,
   obbCorners,
   pointsToPath,
   pointsToRoundedPath,
+  resolveEdgeEndpoint,
   routeOrthogonal
-} from "./chunk-KP75DEA4.js";
+} from "./chunk-7FA2TBSZ.js";
 import "./chunk-5CCD5Q4B.js";
 export {
   aabbFromOBB,
   createGraph,
+  floatingAnchor,
   getBezierPath,
+  getEdgePosition,
+  getNodeIntersection,
+  inferSide,
   nearestSide,
   obbContainsPoint,
   obbCorners,
   pointsToPath,
   pointsToRoundedPath,
+  resolveEdgeEndpoint,
   routeOrthogonal
 };
 //# sourceMappingURL=graph.js.map

package/dist/index.cjs

@@ -38,8 +38,12 @@ __export(src_exports, {
   createTypedCore: () => createTypedCore,
   createVirtual: () => createVirtual,
   detectConflicts: () => detectConflicts,
+  floatingAnchor: () => floatingAnchor,
   freezeMiddleware: () => freezeMiddleware,
   getBezierPath: () => getBezierPath,
+  getEdgePosition: () => getEdgePosition,
+  getNodeIntersection: () => getNodeIntersection,
+  inferSide: () => inferSide,
   isAvailable: () => isAvailable,
   listReservedPrefixes: () => listReservedPrefixes,
   loggerMiddleware: () => loggerMiddleware,
@@ -52,6 +56,7 @@ __export(src_exports, {
   pointsToPath: () => pointsToPath,
   pointsToRoundedPath: () => pointsToRoundedPath,
   reservePrefix: () => reservePrefix,
+  resolveEdgeEndpoint: () => resolveEdgeEndpoint,
   resolveOperator: () => resolveOperator,
   routeOrthogonal: () => routeOrthogonal,
   validationMiddleware: () => validationMiddleware
@@ -2013,22 +2018,27 @@ function createGraph(core, options) {
 function routeOrthogonal(start, end, options) {
   const opts = typeof options === "string" ? { preferred: options } : options ?? {};
   const gridSize = opts.gridSize ?? 10;
-  const stubLength = opts.stubLength ?? Math.max(8, gridSize);
+  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);
+    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);
+    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);
   }
@@ -2038,8 +2048,12 @@ function routeOrthogonal(start, end, options) {
   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) {
-    const snap2 = opts.snap ?? gridSize;
-    core = lRoute(coreStart, coreEnd, opts.preferred ?? "auto", snap2);
+    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;
@@ -2063,6 +2077,68 @@ function routeOrthogonal(start, end, options) {
   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;
@@ -2122,6 +2198,31 @@ function getBezierPath(opts) {
   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;
@@ -2130,9 +2231,107 @@ function nearestSide(box, target) {
   if (Math.abs(dx) >= Math.abs(dy)) return dx >= 0 ? "right" : "left";
   return dy >= 0 ? "bottom" : "top";
 }
-function exitOnNearestSide(box, target) {
+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)) {
@@ -3635,8 +3834,12 @@ function createCalendar(core, options) {
   createTypedCore,
   createVirtual,
   detectConflicts,
+  floatingAnchor,
   freezeMiddleware,
   getBezierPath,
+  getEdgePosition,
+  getNodeIntersection,
+  inferSide,
   isAvailable,
   listReservedPrefixes,
   loggerMiddleware,
@@ -3649,6 +3852,7 @@ function createCalendar(core, options) {
   pointsToPath,
   pointsToRoundedPath,
   reservePrefix,
+  resolveEdgeEndpoint,
   resolveOperator,
   routeOrthogonal,
   validationMiddleware