@rxflow/manhattan 0.0.1-alpha.1 → 0.0.1-alpha.11

package/cjs/getManHattanPath.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"getManHattanPath.d.ts","sourceRoot":"","sources":["../src/getManHattanPath.ts"],"names":[],"mappings":"AAAA,OAAO,EAAqB,QAAQ,EAAE,MAAM,eAAe,CAAA;AAG3D,OAAO,KAAK,EAAE,sBAAsB,EAAE,UAAU,EAAE,MAAM,WAAW,CAAA;AAMnE;;GAEG;AACH,MAAM,WAAW,sBAAsB;IACrC;;OAEG;IACH,YAAY,EAAE,MAAM,CAAA;IAEpB;;OAEG;IACH,YAAY,EAAE,MAAM,CAAC;IAErB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAEhB,cAAc,EAAE,QAAQ,CAAC;IACzB,cAAc,EAAE,QAAQ,CAAC;IACzB;;OAEG;IACH,UAAU,EAAE,UAAU,CAAA;IAEtB;;OAEG;IACH,OAAO,CAAC,EAAE,sBAAsB,CAAA;CACjC;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,sBAAsB,GAAG,MAAM,CAsRvE"}
+{"version":3,"file":"getManHattanPath.d.ts","sourceRoot":"","sources":["../src/getManHattanPath.ts"],"names":[],"mappings":"AAAA,OAAO,EAAqB,QAAQ,EAAE,MAAM,eAAe,CAAA;AAG3D,OAAO,KAAK,EAAE,sBAAsB,EAAE,UAAU,EAAE,MAAM,WAAW,CAAA;AAMnE;;GAEG;AACH,MAAM,WAAW,sBAAsB;IACrC;;OAEG;IACH,YAAY,EAAE,MAAM,CAAA;IAEpB;;OAEG;IACH,YAAY,EAAE,MAAM,CAAC;IAErB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAEhB,cAAc,EAAE,QAAQ,CAAC;IACzB,cAAc,EAAE,QAAQ,CAAC;IACzB;;OAEG;IACH,UAAU,EAAE,UAAU,CAAA;IAEtB;;OAEG;IACH,OAAO,CAAC,EAAE,sBAAsB,CAAA;CACjC;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,sBAAsB,GAAG,MAAM,CAwRvE"}

package/cjs/getManHattanPath.js

@@ -96,7 +96,7 @@ function getManHattanPath(params) {
   const smoothStepPoints = (0, _svg.parseSVGPath)(smoothStepPath);
 
   // Check if smooth step path intersects with any obstacles
-  if (smoothStepPoints.length > 0 && !(0, _utils.pathIntersectsObstacles)(smoothStepPoints, nodeLookup, sourceNodeId, targetNodeId)) {
+  if (smoothStepPoints.length > 0 && !(0, _utils.pathIntersectsObstacles)(smoothStepPoints, nodeLookup)) {
     console.log('[getManHattanPath] Using ReactFlow getSmoothStepPath (no obstacles)');
     return smoothStepPath;
   }
@@ -161,7 +161,9 @@ function getManHattanPath(params) {
   }
 
   // Insert extension point at source - always extend away from node edge by fixed step distance
+  // Add borderRadius to extension distance to account for rounded corners
   if (route.length > 0) {
+    const extensionDistance = step + options.borderRadius;
     const firstPoint = route[0];
 
     // Determine which edge the source anchor is on
@@ -172,8 +174,8 @@ function getManHattanPath(params) {
 
     // Insert extension point and corner point to ensure orthogonal path
     if (onRight) {
-      // Anchor on right edge - extend right by fixed step
-      const extendX = sourceAnchor.x + step;
+      // Anchor on right edge - extend right by step + borderRadius
+      const extendX = sourceAnchor.x + extensionDistance;
       const extensionPoint = new _geometry.Point(extendX, sourceAnchor.y);
       // Check if we need a corner point
       if (Math.abs(extensionPoint.y - firstPoint.y) > tolerance) {
@@ -182,8 +184,8 @@ function getManHattanPath(params) {
       route.unshift(extensionPoint); // Extension point (fixed distance)
       console.log('[getManHattanPath] Inserted source extension (right):', `(${extendX}, ${sourceAnchor.y})`);
     } else if (onLeft) {
-      // Anchor on left edge - extend left by fixed step
-      const extendX = sourceAnchor.x - step;
+      // Anchor on left edge - extend left by step + borderRadius
+      const extendX = sourceAnchor.x - extensionDistance;
       const extensionPoint = new _geometry.Point(extendX, sourceAnchor.y);
       if (Math.abs(extensionPoint.y - firstPoint.y) > tolerance) {
         route.unshift(new _geometry.Point(extendX, firstPoint.y));
@@ -191,8 +193,8 @@ function getManHattanPath(params) {
       route.unshift(extensionPoint);
       console.log('[getManHattanPath] Inserted source extension (left):', `(${extendX}, ${sourceAnchor.y})`);
     } else if (onBottom) {
-      // Anchor on bottom edge - extend down by fixed step
-      const extendY = sourceAnchor.y + step;
+      // Anchor on bottom edge - extend down by step + borderRadius
+      const extendY = sourceAnchor.y + extensionDistance;
       const extensionPoint = new _geometry.Point(sourceAnchor.x, extendY);
       if (Math.abs(extensionPoint.x - firstPoint.x) > tolerance) {
         route.unshift(new _geometry.Point(firstPoint.x, extendY));
@@ -200,8 +202,8 @@ function getManHattanPath(params) {
       route.unshift(extensionPoint);
       console.log('[getManHattanPath] Inserted source extension (down):', `(${sourceAnchor.x}, ${extendY})`);
     } else if (onTop) {
-      // Anchor on top edge - extend up by fixed step
-      const extendY = sourceAnchor.y - step;
+      // Anchor on top edge - extend up by step + borderRadius
+      const extendY = sourceAnchor.y - extensionDistance;
       const extensionPoint = new _geometry.Point(sourceAnchor.x, extendY);
       if (Math.abs(extensionPoint.x - firstPoint.x) > tolerance) {
         route.unshift(new _geometry.Point(firstPoint.x, extendY));
@@ -212,9 +214,9 @@ function getManHattanPath(params) {
   }
 
   // Insert extension point at target - always extend away from node edge by fixed step distance
+  // Add borderRadius to extension distance to account for rounded corners
   if (route.length > 0) {
-    const step = options.step;
-    const tolerance = 1;
+    const extensionDistance = step + options.borderRadius;
     const lastPoint = route[route.length - 1];
 
     // Determine which edge the target anchor is on
@@ -225,8 +227,8 @@ function getManHattanPath(params) {
 
     // Insert extension point and corner point to ensure orthogonal path
     if (onLeft) {
-      // Anchor on left edge - extend left by fixed step
-      const extendX = targetAnchor.x - step;
+      // Anchor on left edge - extend left by step + borderRadius
+      const extendX = targetAnchor.x - extensionDistance;
       const extensionPoint = new _geometry.Point(extendX, targetAnchor.y);
       if (Math.abs(extensionPoint.y - lastPoint.y) > tolerance) {
         route.push(new _geometry.Point(extendX, lastPoint.y)); // Corner point
@@ -234,8 +236,8 @@ function getManHattanPath(params) {
       route.push(extensionPoint); // Extension point (fixed distance)
       console.log('[getManHattanPath] Inserted target extension (left):', `(${extendX}, ${targetAnchor.y})`);
     } else if (onRight) {
-      // Anchor on right edge - extend right by fixed step
-      const extendX = targetAnchor.x + step;
+      // Anchor on right edge - extend right by step + borderRadius
+      const extendX = targetAnchor.x + extensionDistance;
       const extensionPoint = new _geometry.Point(extendX, targetAnchor.y);
       if (Math.abs(extensionPoint.y - lastPoint.y) > tolerance) {
         route.push(new _geometry.Point(extendX, lastPoint.y));
@@ -243,8 +245,8 @@ function getManHattanPath(params) {
       route.push(extensionPoint);
       console.log('[getManHattanPath] Inserted target extension (right):', `(${extendX}, ${targetAnchor.y})`);
     } else if (onTop) {
-      // Anchor on top edge - extend up by fixed step
-      const extendY = targetAnchor.y - step;
+      // Anchor on top edge - extend up by step + borderRadius
+      const extendY = targetAnchor.y - extensionDistance;
       const extensionPoint = new _geometry.Point(targetAnchor.x, extendY);
       if (Math.abs(extensionPoint.x - lastPoint.x) > tolerance) {
         route.push(new _geometry.Point(lastPoint.x, extendY));
@@ -252,8 +254,8 @@ function getManHattanPath(params) {
       route.push(extensionPoint);
       console.log('[getManHattanPath] Inserted target extension (up):', `(${targetAnchor.x}, ${extendY})`);
     } else if (onBottom) {
-      // Anchor on bottom edge - extend down by fixed step
-      const extendY = targetAnchor.y + step;
+      // Anchor on bottom edge - extend down by step + borderRadius
+      const extendY = targetAnchor.y + extensionDistance;
       const extensionPoint = new _geometry.Point(targetAnchor.x, extendY);
       if (Math.abs(extensionPoint.x - lastPoint.x) > tolerance) {
         route.push(new _geometry.Point(lastPoint.x, extendY));

package/cjs/options/defaults.js

@@ -18,7 +18,7 @@ const defaults = exports.defaults = {
   excludeNodes: [],
   excludeShapes: [],
   excludeTerminals: [],
-  padding: 0,
+  padding: 15,
   snapToGrid: true,
   borderRadius: 5,
   penalties: {

package/cjs/svg/pathParser.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"pathParser.d.ts","sourceRoot":"","sources":["../../src/svg/pathParser.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,aAAa,CAAA;AAEnC;;;GAGG;AACH,wBAAgB,YAAY,CAAC,UAAU,EAAE,MAAM,GAAG,KAAK,EAAE,CA0CxD;AAED;;GAEG;AACH,wBAAgB,YAAY,CAAC,MAAM,EAAE,KAAK,EAAE,GAAG,KAAK,EAAE,CA0BrD"}
+{"version":3,"file":"pathParser.d.ts","sourceRoot":"","sources":["../../src/svg/pathParser.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,aAAa,CAAA;AAEnC;;;GAGG;AACH,wBAAgB,YAAY,CAAC,UAAU,EAAE,MAAM,GAAG,KAAK,EAAE,CA2CxD;AAED;;GAEG;AACH,wBAAgB,YAAY,CAAC,MAAM,EAAE,KAAK,EAAE,GAAG,KAAK,EAAE,CA0BrD"}

package/cjs/svg/pathParser.js

@@ -33,8 +33,9 @@ function parseSVGPath(pathString) {
           const x = coords[2];
           const y = coords[3];
 
-          // Sample 5 points along the bezier curve
-          for (let t = 0.2; t <= 1; t += 0.2) {
+          // Sample 10 points along the bezier curve for better accuracy
+          // This ensures we don't miss intersections with obstacles
+          for (let t = 0.1; t <= 1; t += 0.1) {
             const bx = (1 - t) * (1 - t) * prevPoint.x + 2 * (1 - t) * t * cx + t * t * x;
             const by = (1 - t) * (1 - t) * prevPoint.y + 2 * (1 - t) * t * cy + t * t * y;
             points.push(new _geometry.Point(bx, by));

package/cjs/utils/grid.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"grid.d.ts","sourceRoot":"","sources":["../../src/utils/grid.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,aAAa,CAAA;AAEnC;;GAEG;AACH,MAAM,WAAW,IAAI;IACnB,MAAM,EAAE,KAAK,CAAA;IACb,CAAC,EAAE,MAAM,CAAA;IACT,CAAC,EAAE,MAAM,CAAA;CACV;AA2BD;;GAEG;AACH,wBAAgB,OAAO,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,GAAG,IAAI,CAMxE;AAED;;GAEG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,CAElE;AAYD;;GAEG;AACH,wBAAgB,KAAK,CAAC,KAAK,EAAE,KAAK,EAAE,IAAI,EAAE,IAAI,EAAE,SAAS,EAAE,MAAM,GAAG,KAAK,CAExE;AAED;;GAEG;AACH,wBAAgB,KAAK,CAAC,KAAK,EAAE,KAAK,EAAE,SAAS,EAAE,MAAM,GAAG,KAAK,CAE5D"}
+{"version":3,"file":"grid.d.ts","sourceRoot":"","sources":["../../src/utils/grid.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,aAAa,CAAA;AAEnC;;GAEG;AACH,MAAM,WAAW,IAAI;IACnB,MAAM,EAAE,KAAK,CAAA;IACb,CAAC,EAAE,MAAM,CAAA;IACT,CAAC,EAAE,MAAM,CAAA;CACV;AAWD;;GAEG;AACH,wBAAgB,OAAO,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,GAAG,IAAI,CAMxE;AAED;;GAEG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,CAElE;AAYD;;GAEG;AACH,wBAAgB,KAAK,CAAC,KAAK,EAAE,KAAK,EAAE,IAAI,EAAE,IAAI,EAAE,SAAS,EAAE,MAAM,GAAG,KAAK,CAExE;AAED;;GAEG;AACH,wBAAgB,KAAK,CAAC,KAAK,EAAE,KAAK,EAAE,SAAS,EAAE,MAAM,GAAG,KAAK,CAE5D"}

package/cjs/utils/grid.js

@@ -16,23 +16,9 @@ var _geometry = require("../geometry");
  * Get grid dimension for a single axis
  */
 function getGridDimension(diff, step) {
-  // Return step if diff = 0
-  if (!diff) {
-    return step;
-  }
-  const abs = Math.abs(diff);
-  const count = Math.round(abs / step);
-
-  // Return abs if less than one step apart
-  if (!count) {
-    return abs;
-  }
-
-  // Otherwise, return corrected step
-  const roundedDiff = count * step;
-  const remainder = abs - roundedDiff;
-  const correction = remainder / count;
-  return step + correction;
+  // Always return fixed step size to maintain consistent padding
+  // This ensures paths stay at least 'padding' distance from obstacles
+  return step;
 }
 
 /**

package/cjs/utils/pathValidation.d.ts

@@ -2,6 +2,10 @@ import { Point } from '../geometry';
 import type { NodeLookup } from '../options';
 /**
  * Check if a path intersects with any obstacles (nodes)
+ * A path is considered to intersect if it has >= 2 unique intersection points with a node
+ *
+ * Note: pathPoints should be pre-processed by parseSVGPath which samples bezier curves
+ * into line segments, so this function works correctly with curved paths
  */
-export declare function pathIntersectsObstacles(pathPoints: Point[], nodeLookup: NodeLookup, sourceNodeId: string, targetNodeId: string): boolean;
+export declare function pathIntersectsObstacles(pathPoints: Point[], nodeLookup: NodeLookup): boolean;
 //# sourceMappingURL=pathValidation.d.ts.map

package/cjs/utils/pathValidation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"pathValidation.d.ts","sourceRoot":"","sources":["../../src/utils/pathValidation.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAa,MAAM,aAAa,CAAA;AAE9C,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,YAAY,CAAA;AA8E5C;;GAEG;AACH,wBAAgB,uBAAuB,CACrC,UAAU,EAAE,KAAK,EAAE,EACnB,UAAU,EAAE,UAAU,EACtB,YAAY,EAAE,MAAM,EACpB,YAAY,EAAE,MAAM,GACnB,OAAO,CA2BT"}
+{"version":3,"file":"pathValidation.d.ts","sourceRoot":"","sources":["../../src/utils/pathValidation.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAa,MAAM,aAAa,CAAA;AAC9C,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,YAAY,CAAA;AAyF5C;;;;;;GAMG;AACH,wBAAgB,uBAAuB,CAAC,UAAU,EAAE,KAAK,EAAE,EAAE,UAAU,EAAE,UAAU,GAAG,OAAO,CAoC5F"}

package/cjs/utils/pathValidation.js

@@ -5,7 +5,6 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.pathIntersectsObstacles = pathIntersectsObstacles;
 var _geometry = require("../geometry");
-var _collision = require("../geometry/collision");
 var _node = require("./node");
 /**
  * Get node bounding box
@@ -19,77 +18,113 @@ function getNodeBBox(nodeId, nodeLookup) {
 }
 
 /**
- * Check if a point is strictly inside a rectangle (not on edge)
+ * Find unique intersection points between a line segment and a rectangle
+ * Returns array of intersection points (deduplicated)
  */
-function isPointStrictlyInside(point, rect, tolerance = 1) {
-  return point.x > rect.x + tolerance && point.x < rect.x + rect.width - tolerance && point.y > rect.y + tolerance && point.y < rect.y + rect.height - tolerance;
-}
+function findSegmentRectIntersections(p1, p2, rect) {
+  const intersections = [];
+  const tolerance = 0.01;
 
-/**
- * Check if a point intersects with a node
- */
-function checkPointIntersection(point, nodeId, nodeBBox, isTerminalNode) {
-  if (isTerminalNode) {
-    // For source/target nodes, only check if point is strictly inside (not on edge)
-    if (isPointStrictlyInside(point, nodeBBox)) {
-      console.log(`[pathIntersectsObstacles] Point (${point.x}, ${point.y}) is inside terminal node ${nodeId}`);
-      return true;
-    }
-  } else {
-    // For other nodes, check if point is inside or on edge
-    if (nodeBBox.containsPoint(point)) {
-      console.log(`[pathIntersectsObstacles] Point (${point.x}, ${point.y}) intersects node ${nodeId}`);
-      return true;
+  // Define rectangle edges
+  const edges = [{
+    start: new _geometry.Point(rect.x, rect.y),
+    end: new _geometry.Point(rect.x + rect.width, rect.y)
+  },
+  // Top
+  {
+    start: new _geometry.Point(rect.x + rect.width, rect.y),
+    end: new _geometry.Point(rect.x + rect.width, rect.y + rect.height)
+  },
+  // Right
+  {
+    start: new _geometry.Point(rect.x + rect.width, rect.y + rect.height),
+    end: new _geometry.Point(rect.x, rect.y + rect.height)
+  },
+  // Bottom
+  {
+    start: new _geometry.Point(rect.x, rect.y + rect.height),
+    end: new _geometry.Point(rect.x, rect.y)
+  } // Left
+  ];
+
+  // Find intersection point with each edge
+  for (const edge of edges) {
+    const intersection = getLineSegmentIntersection(p1, p2, edge.start, edge.end);
+    if (intersection) {
+      // Check if this point is already in the list (avoid duplicates at corners)
+      const isDuplicate = intersections.some(existing => Math.abs(existing.x - intersection.x) < tolerance && Math.abs(existing.y - intersection.y) < tolerance);
+      if (!isDuplicate) {
+        intersections.push(intersection);
+      }
     }
   }
-  return false;
+  return intersections;
 }
 
 /**
- * Check if a line segment intersects with a node
+ * Get intersection point between two line segments (if exists)
  */
-function checkSegmentIntersection(p1, p2, nodeId, nodeBBox, isTerminalNode) {
-  if (isTerminalNode) {
-    // For source/target nodes, check if segment crosses through (not just touching edge)
-    if ((0, _collision.lineSegmentCrossesRect)(p1, p2, nodeBBox)) {
-      console.log(`[pathIntersectsObstacles] Segment crosses terminal node ${nodeId}`);
-      return true;
-    }
-  } else {
-    // For other nodes, check normal intersection
-    if ((0, _collision.lineSegmentIntersectsRect)(p1, p2, nodeBBox)) {
-      console.log(`[pathIntersectsObstacles] Segment intersects node ${nodeId}`);
-      return true;
-    }
+function getLineSegmentIntersection(p1, p2, p3, p4) {
+  const d1 = direction(p3, p4, p1);
+  const d2 = direction(p3, p4, p2);
+  const d3 = direction(p1, p2, p3);
+  const d4 = direction(p1, p2, p4);
+  if ((d1 > 0 && d2 < 0 || d1 < 0 && d2 > 0) && (d3 > 0 && d4 < 0 || d3 < 0 && d4 > 0)) {
+    // Lines intersect, calculate intersection point
+    const t = ((p3.x - p1.x) * (p3.y - p4.y) - (p3.y - p1.y) * (p3.x - p4.x)) / ((p1.x - p2.x) * (p3.y - p4.y) - (p1.y - p2.y) * (p3.x - p4.x));
+    return new _geometry.Point(p1.x + t * (p2.x - p1.x), p1.y + t * (p2.y - p1.y));
   }
-  return false;
+
+  // Check collinear cases
+  if (d1 === 0 && onSegment(p3, p1, p4)) return p1.clone();
+  if (d2 === 0 && onSegment(p3, p2, p4)) return p2.clone();
+  if (d3 === 0 && onSegment(p1, p3, p2)) return p3.clone();
+  if (d4 === 0 && onSegment(p1, p4, p2)) return p4.clone();
+  return null;
+}
+function direction(p1, p2, p3) {
+  return (p3.x - p1.x) * (p2.y - p1.y) - (p2.x - p1.x) * (p3.y - p1.y);
+}
+function onSegment(p1, p2, p3) {
+  return p2.x >= Math.min(p1.x, p3.x) && p2.x <= Math.max(p1.x, p3.x) && p2.y >= Math.min(p1.y, p3.y) && p2.y <= Math.max(p1.y, p3.y);
 }
 
 /**
  * Check if a path intersects with any obstacles (nodes)
+ * A path is considered to intersect if it has >= 2 unique intersection points with a node
+ *
+ * Note: pathPoints should be pre-processed by parseSVGPath which samples bezier curves
+ * into line segments, so this function works correctly with curved paths
  */
-function pathIntersectsObstacles(pathPoints, nodeLookup, sourceNodeId, targetNodeId) {
-  // Iterate through all nodes
-  for (const [nodeId, node] of nodeLookup) {
+function pathIntersectsObstacles(pathPoints, nodeLookup) {
+  const tolerance = 0.01;
+
+  // Iterate through all nodes (including source and target)
+  for (const [nodeId] of nodeLookup) {
     const nodeBBox = getNodeBBox(nodeId, nodeLookup);
     if (!nodeBBox) continue;
-    const isTerminalNode = nodeId === sourceNodeId || nodeId === targetNodeId;
+    const allIntersections = [];
 
-    // Check each point
-    for (let i = 0; i < pathPoints.length; i++) {
-      const point = pathPoints[i];
-      if (checkPointIntersection(point, nodeId, nodeBBox, isTerminalNode)) {
-        return true;
-      }
+    // Collect all unique intersection points for this node
+    for (let i = 0; i < pathPoints.length - 1; i++) {
+      const p1 = pathPoints[i];
+      const p2 = pathPoints[i + 1];
+      const segmentIntersections = findSegmentRectIntersections(p1, p2, nodeBBox);
 
-      // Check line segment to next point
-      if (i < pathPoints.length - 1) {
-        const nextPoint = pathPoints[i + 1];
-        if (checkSegmentIntersection(point, nextPoint, nodeId, nodeBBox, isTerminalNode)) {
-          return true;
+      // Add to global list, avoiding duplicates
+      for (const intersection of segmentIntersections) {
+        const isDuplicate = allIntersections.some(existing => Math.abs(existing.x - intersection.x) < tolerance && Math.abs(existing.y - intersection.y) < tolerance);
+        if (!isDuplicate) {
+          allIntersections.push(intersection);
         }
       }
     }
+
+    // If path has 2 or more unique intersections with this node, it crosses through it
+    if (allIntersections.length >= 2) {
+      console.log(`[pathIntersectsObstacles] Path crosses node ${nodeId} with ${allIntersections.length} intersections`);
+      return true;
+    }
   }
   return false;
 }

package/esm/getManHattanPath.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"getManHattanPath.d.ts","sourceRoot":"","sources":["../src/getManHattanPath.ts"],"names":[],"mappings":"AAAA,OAAO,EAAqB,QAAQ,EAAE,MAAM,eAAe,CAAA;AAG3D,OAAO,KAAK,EAAE,sBAAsB,EAAE,UAAU,EAAE,MAAM,WAAW,CAAA;AAMnE;;GAEG;AACH,MAAM,WAAW,sBAAsB;IACrC;;OAEG;IACH,YAAY,EAAE,MAAM,CAAA;IAEpB;;OAEG;IACH,YAAY,EAAE,MAAM,CAAC;IAErB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAEhB,cAAc,EAAE,QAAQ,CAAC;IACzB,cAAc,EAAE,QAAQ,CAAC;IACzB;;OAEG;IACH,UAAU,EAAE,UAAU,CAAA;IAEtB;;OAEG;IACH,OAAO,CAAC,EAAE,sBAAsB,CAAA;CACjC;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,sBAAsB,GAAG,MAAM,CAsRvE"}
+{"version":3,"file":"getManHattanPath.d.ts","sourceRoot":"","sources":["../src/getManHattanPath.ts"],"names":[],"mappings":"AAAA,OAAO,EAAqB,QAAQ,EAAE,MAAM,eAAe,CAAA;AAG3D,OAAO,KAAK,EAAE,sBAAsB,EAAE,UAAU,EAAE,MAAM,WAAW,CAAA;AAMnE;;GAEG;AACH,MAAM,WAAW,sBAAsB;IACrC;;OAEG;IACH,YAAY,EAAE,MAAM,CAAA;IAEpB;;OAEG;IACH,YAAY,EAAE,MAAM,CAAC;IAErB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAEhB,cAAc,EAAE,QAAQ,CAAC;IACzB,cAAc,EAAE,QAAQ,CAAC;IACzB;;OAEG;IACH,UAAU,EAAE,UAAU,CAAA;IAEtB;;OAEG;IACH,OAAO,CAAC,EAAE,sBAAsB,CAAA;CACjC;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,sBAAsB,GAAG,MAAM,CAwRvE"}

package/esm/getManHattanPath.js

@@ -102,7 +102,7 @@ export function getManHattanPath(params) {
   var smoothStepPoints = parseSVGPath(smoothStepPath);
 
   // Check if smooth step path intersects with any obstacles
-  if (smoothStepPoints.length > 0 && !pathIntersectsObstacles(smoothStepPoints, nodeLookup, sourceNodeId, targetNodeId)) {
+  if (smoothStepPoints.length > 0 && !pathIntersectsObstacles(smoothStepPoints, nodeLookup)) {
     console.log('[getManHattanPath] Using ReactFlow getSmoothStepPath (no obstacles)');
     return smoothStepPath;
   }
@@ -169,7 +169,9 @@ export function getManHattanPath(params) {
   }
 
   // Insert extension point at source - always extend away from node edge by fixed step distance
+  // Add borderRadius to extension distance to account for rounded corners
   if (route.length > 0) {
+    var extensionDistance = step + options.borderRadius;
     var _firstPoint = route[0];
 
     // Determine which edge the source anchor is on
@@ -180,8 +182,8 @@ export function getManHattanPath(params) {
 
     // Insert extension point and corner point to ensure orthogonal path
     if (_onRight2) {
-      // Anchor on right edge - extend right by fixed step
-      var extendX = sourceAnchor.x + step;
+      // Anchor on right edge - extend right by step + borderRadius
+      var extendX = sourceAnchor.x + extensionDistance;
       var extensionPoint = new Point(extendX, sourceAnchor.y);
       // Check if we need a corner point
       if (Math.abs(extensionPoint.y - _firstPoint.y) > tolerance) {
@@ -190,8 +192,8 @@ export function getManHattanPath(params) {
       route.unshift(extensionPoint); // Extension point (fixed distance)
       console.log('[getManHattanPath] Inserted source extension (right):', "(".concat(extendX, ", ").concat(sourceAnchor.y, ")"));
     } else if (_onLeft2) {
-      // Anchor on left edge - extend left by fixed step
-      var _extendX = sourceAnchor.x - step;
+      // Anchor on left edge - extend left by step + borderRadius
+      var _extendX = sourceAnchor.x - extensionDistance;
       var _extensionPoint = new Point(_extendX, sourceAnchor.y);
       if (Math.abs(_extensionPoint.y - _firstPoint.y) > tolerance) {
         route.unshift(new Point(_extendX, _firstPoint.y));
@@ -199,8 +201,8 @@ export function getManHattanPath(params) {
       route.unshift(_extensionPoint);
       console.log('[getManHattanPath] Inserted source extension (left):', "(".concat(_extendX, ", ").concat(sourceAnchor.y, ")"));
     } else if (_onBottom2) {
-      // Anchor on bottom edge - extend down by fixed step
-      var extendY = sourceAnchor.y + step;
+      // Anchor on bottom edge - extend down by step + borderRadius
+      var extendY = sourceAnchor.y + extensionDistance;
       var _extensionPoint2 = new Point(sourceAnchor.x, extendY);
       if (Math.abs(_extensionPoint2.x - _firstPoint.x) > tolerance) {
         route.unshift(new Point(_firstPoint.x, extendY));
@@ -208,8 +210,8 @@ export function getManHattanPath(params) {
       route.unshift(_extensionPoint2);
       console.log('[getManHattanPath] Inserted source extension (down):', "(".concat(sourceAnchor.x, ", ").concat(extendY, ")"));
     } else if (_onTop2) {
-      // Anchor on top edge - extend up by fixed step
-      var _extendY = sourceAnchor.y - step;
+      // Anchor on top edge - extend up by step + borderRadius
+      var _extendY = sourceAnchor.y - extensionDistance;
       var _extensionPoint3 = new Point(sourceAnchor.x, _extendY);
       if (Math.abs(_extensionPoint3.x - _firstPoint.x) > tolerance) {
         route.unshift(new Point(_firstPoint.x, _extendY));
@@ -220,50 +222,50 @@ export function getManHattanPath(params) {
   }
 
   // Insert extension point at target - always extend away from node edge by fixed step distance
+  // Add borderRadius to extension distance to account for rounded corners
   if (route.length > 0) {
-    var _step = options.step;
-    var _tolerance = 1;
+    var _extensionDistance = step + options.borderRadius;
     var _lastPoint = route[route.length - 1];
 
     // Determine which edge the target anchor is on
-    var _onLeft3 = Math.abs(targetAnchor.x - targetBBox.x) < _tolerance;
-    var _onRight3 = Math.abs(targetAnchor.x - (targetBBox.x + targetBBox.width)) < _tolerance;
-    var _onTop3 = Math.abs(targetAnchor.y - targetBBox.y) < _tolerance;
-    var _onBottom3 = Math.abs(targetAnchor.y - (targetBBox.y + targetBBox.height)) < _tolerance;
+    var _onLeft3 = Math.abs(targetAnchor.x - targetBBox.x) < tolerance;
+    var _onRight3 = Math.abs(targetAnchor.x - (targetBBox.x + targetBBox.width)) < tolerance;
+    var _onTop3 = Math.abs(targetAnchor.y - targetBBox.y) < tolerance;
+    var _onBottom3 = Math.abs(targetAnchor.y - (targetBBox.y + targetBBox.height)) < tolerance;
 
     // Insert extension point and corner point to ensure orthogonal path
     if (_onLeft3) {
-      // Anchor on left edge - extend left by fixed step
-      var _extendX2 = targetAnchor.x - _step;
+      // Anchor on left edge - extend left by step + borderRadius
+      var _extendX2 = targetAnchor.x - _extensionDistance;
       var _extensionPoint4 = new Point(_extendX2, targetAnchor.y);
-      if (Math.abs(_extensionPoint4.y - _lastPoint.y) > _tolerance) {
+      if (Math.abs(_extensionPoint4.y - _lastPoint.y) > tolerance) {
         route.push(new Point(_extendX2, _lastPoint.y)); // Corner point
       }
       route.push(_extensionPoint4); // Extension point (fixed distance)
       console.log('[getManHattanPath] Inserted target extension (left):', "(".concat(_extendX2, ", ").concat(targetAnchor.y, ")"));
     } else if (_onRight3) {
-      // Anchor on right edge - extend right by fixed step
-      var _extendX3 = targetAnchor.x + _step;
+      // Anchor on right edge - extend right by step + borderRadius
+      var _extendX3 = targetAnchor.x + _extensionDistance;
       var _extensionPoint5 = new Point(_extendX3, targetAnchor.y);
-      if (Math.abs(_extensionPoint5.y - _lastPoint.y) > _tolerance) {
+      if (Math.abs(_extensionPoint5.y - _lastPoint.y) > tolerance) {
         route.push(new Point(_extendX3, _lastPoint.y));
       }
       route.push(_extensionPoint5);
       console.log('[getManHattanPath] Inserted target extension (right):', "(".concat(_extendX3, ", ").concat(targetAnchor.y, ")"));
     } else if (_onTop3) {
-      // Anchor on top edge - extend up by fixed step
-      var _extendY2 = targetAnchor.y - _step;
+      // Anchor on top edge - extend up by step + borderRadius
+      var _extendY2 = targetAnchor.y - _extensionDistance;
       var _extensionPoint6 = new Point(targetAnchor.x, _extendY2);
-      if (Math.abs(_extensionPoint6.x - _lastPoint.x) > _tolerance) {
+      if (Math.abs(_extensionPoint6.x - _lastPoint.x) > tolerance) {
         route.push(new Point(_lastPoint.x, _extendY2));
       }
       route.push(_extensionPoint6);
       console.log('[getManHattanPath] Inserted target extension (up):', "(".concat(targetAnchor.x, ", ").concat(_extendY2, ")"));
     } else if (_onBottom3) {
-      // Anchor on bottom edge - extend down by fixed step
-      var _extendY3 = targetAnchor.y + _step;
+      // Anchor on bottom edge - extend down by step + borderRadius
+      var _extendY3 = targetAnchor.y + _extensionDistance;
       var _extensionPoint7 = new Point(targetAnchor.x, _extendY3);
-      if (Math.abs(_extensionPoint7.x - _lastPoint.x) > _tolerance) {
+      if (Math.abs(_extensionPoint7.x - _lastPoint.x) > tolerance) {
         route.push(new Point(_lastPoint.x, _extendY3));
       }
       route.push(_extensionPoint7);

package/esm/options/defaults.js

@@ -12,7 +12,7 @@ export var defaults = {
   excludeNodes: [],
   excludeShapes: [],
   excludeTerminals: [],
-  padding: 0,
+  padding: 15,
   snapToGrid: true,
   borderRadius: 5,
   penalties: {

package/esm/svg/pathParser.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"pathParser.d.ts","sourceRoot":"","sources":["../../src/svg/pathParser.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,aAAa,CAAA;AAEnC;;;GAGG;AACH,wBAAgB,YAAY,CAAC,UAAU,EAAE,MAAM,GAAG,KAAK,EAAE,CA0CxD;AAED;;GAEG;AACH,wBAAgB,YAAY,CAAC,MAAM,EAAE,KAAK,EAAE,GAAG,KAAK,EAAE,CA0BrD"}
+{"version":3,"file":"pathParser.d.ts","sourceRoot":"","sources":["../../src/svg/pathParser.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,aAAa,CAAA;AAEnC;;;GAGG;AACH,wBAAgB,YAAY,CAAC,UAAU,EAAE,MAAM,GAAG,KAAK,EAAE,CA2CxD;AAED;;GAEG;AACH,wBAAgB,YAAY,CAAC,MAAM,EAAE,KAAK,EAAE,GAAG,KAAK,EAAE,CA0BrD"}

package/esm/svg/pathParser.js

@@ -34,8 +34,9 @@ export function parseSVGPath(pathString) {
             var x = coords[2];
             var y = coords[3];
 
-            // Sample 5 points along the bezier curve
-            for (var t = 0.2; t <= 1; t += 0.2) {
+            // Sample 10 points along the bezier curve for better accuracy
+            // This ensures we don't miss intersections with obstacles
+            for (var t = 0.1; t <= 1; t += 0.1) {
               var bx = (1 - t) * (1 - t) * prevPoint.x + 2 * (1 - t) * t * cx + t * t * x;
               var by = (1 - t) * (1 - t) * prevPoint.y + 2 * (1 - t) * t * cy + t * t * y;
               points.push(new Point(bx, by));

package/esm/utils/grid.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"grid.d.ts","sourceRoot":"","sources":["../../src/utils/grid.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,aAAa,CAAA;AAEnC;;GAEG;AACH,MAAM,WAAW,IAAI;IACnB,MAAM,EAAE,KAAK,CAAA;IACb,CAAC,EAAE,MAAM,CAAA;IACT,CAAC,EAAE,MAAM,CAAA;CACV;AA2BD;;GAEG;AACH,wBAAgB,OAAO,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,GAAG,IAAI,CAMxE;AAED;;GAEG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,CAElE;AAYD;;GAEG;AACH,wBAAgB,KAAK,CAAC,KAAK,EAAE,KAAK,EAAE,IAAI,EAAE,IAAI,EAAE,SAAS,EAAE,MAAM,GAAG,KAAK,CAExE;AAED;;GAEG;AACH,wBAAgB,KAAK,CAAC,KAAK,EAAE,KAAK,EAAE,SAAS,EAAE,MAAM,GAAG,KAAK,CAE5D"}
+{"version":3,"file":"grid.d.ts","sourceRoot":"","sources":["../../src/utils/grid.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,aAAa,CAAA;AAEnC;;GAEG;AACH,MAAM,WAAW,IAAI;IACnB,MAAM,EAAE,KAAK,CAAA;IACb,CAAC,EAAE,MAAM,CAAA;IACT,CAAC,EAAE,MAAM,CAAA;CACV;AAWD;;GAEG;AACH,wBAAgB,OAAO,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,GAAG,IAAI,CAMxE;AAED;;GAEG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,CAElE;AAYD;;GAEG;AACH,wBAAgB,KAAK,CAAC,KAAK,EAAE,KAAK,EAAE,IAAI,EAAE,IAAI,EAAE,SAAS,EAAE,MAAM,GAAG,KAAK,CAExE;AAED;;GAEG;AACH,wBAAgB,KAAK,CAAC,KAAK,EAAE,KAAK,EAAE,SAAS,EAAE,MAAM,GAAG,KAAK,CAE5D"}

package/esm/utils/grid.js

@@ -8,23 +8,9 @@ import { Point } from "../geometry";
  * Get grid dimension for a single axis
  */
 function getGridDimension(diff, step) {
-  // Return step if diff = 0
-  if (!diff) {
-    return step;
-  }
-  var abs = Math.abs(diff);
-  var count = Math.round(abs / step);
-
-  // Return abs if less than one step apart
-  if (!count) {
-    return abs;
-  }
-
-  // Otherwise, return corrected step
-  var roundedDiff = count * step;
-  var remainder = abs - roundedDiff;
-  var correction = remainder / count;
-  return step + correction;
+  // Always return fixed step size to maintain consistent padding
+  // This ensures paths stay at least 'padding' distance from obstacles
+  return step;
 }
 
 /**

package/esm/utils/pathValidation.d.ts

@@ -2,6 +2,10 @@ import { Point } from '../geometry';
 import type { NodeLookup } from '../options';
 /**
  * Check if a path intersects with any obstacles (nodes)
+ * A path is considered to intersect if it has >= 2 unique intersection points with a node
+ *
+ * Note: pathPoints should be pre-processed by parseSVGPath which samples bezier curves
+ * into line segments, so this function works correctly with curved paths
  */
-export declare function pathIntersectsObstacles(pathPoints: Point[], nodeLookup: NodeLookup, sourceNodeId: string, targetNodeId: string): boolean;
+export declare function pathIntersectsObstacles(pathPoints: Point[], nodeLookup: NodeLookup): boolean;
 //# sourceMappingURL=pathValidation.d.ts.map

package/esm/utils/pathValidation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"pathValidation.d.ts","sourceRoot":"","sources":["../../src/utils/pathValidation.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAa,MAAM,aAAa,CAAA;AAE9C,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,YAAY,CAAA;AA8E5C;;GAEG;AACH,wBAAgB,uBAAuB,CACrC,UAAU,EAAE,KAAK,EAAE,EACnB,UAAU,EAAE,UAAU,EACtB,YAAY,EAAE,MAAM,EACpB,YAAY,EAAE,MAAM,GACnB,OAAO,CA2BT"}
+{"version":3,"file":"pathValidation.d.ts","sourceRoot":"","sources":["../../src/utils/pathValidation.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAa,MAAM,aAAa,CAAA;AAC9C,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,YAAY,CAAA;AAyF5C;;;;;;GAMG;AACH,wBAAgB,uBAAuB,CAAC,UAAU,EAAE,KAAK,EAAE,EAAE,UAAU,EAAE,UAAU,GAAG,OAAO,CAoC5F"}

package/esm/utils/pathValidation.js

@@ -5,8 +5,7 @@ function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
 function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }
 function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
 function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
-import { Rectangle } from "../geometry";
-import { lineSegmentIntersectsRect, lineSegmentCrossesRect } from "../geometry/collision";
+import { Point, Rectangle } from "../geometry";
 import { getNodeDimensions, getNodePosition } from "./node";
 
 /**
@@ -21,84 +20,138 @@ function getNodeBBox(nodeId, nodeLookup) {
 }
 
 /**
- * Check if a point is strictly inside a rectangle (not on edge)
+ * Find unique intersection points between a line segment and a rectangle
+ * Returns array of intersection points (deduplicated)
  */
-function isPointStrictlyInside(point, rect) {
-  var tolerance = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 1;
-  return point.x > rect.x + tolerance && point.x < rect.x + rect.width - tolerance && point.y > rect.y + tolerance && point.y < rect.y + rect.height - tolerance;
-}
+function findSegmentRectIntersections(p1, p2, rect) {
+  var intersections = [];
+  var tolerance = 0.01;
 
-/**
- * Check if a point intersects with a node
- */
-function checkPointIntersection(point, nodeId, nodeBBox, isTerminalNode) {
-  if (isTerminalNode) {
-    // For source/target nodes, only check if point is strictly inside (not on edge)
-    if (isPointStrictlyInside(point, nodeBBox)) {
-      console.log("[pathIntersectsObstacles] Point (".concat(point.x, ", ").concat(point.y, ") is inside terminal node ").concat(nodeId));
-      return true;
-    }
-  } else {
-    // For other nodes, check if point is inside or on edge
-    if (nodeBBox.containsPoint(point)) {
-      console.log("[pathIntersectsObstacles] Point (".concat(point.x, ", ").concat(point.y, ") intersects node ").concat(nodeId));
-      return true;
+  // Define rectangle edges
+  var edges = [{
+    start: new Point(rect.x, rect.y),
+    end: new Point(rect.x + rect.width, rect.y)
+  },
+  // Top
+  {
+    start: new Point(rect.x + rect.width, rect.y),
+    end: new Point(rect.x + rect.width, rect.y + rect.height)
+  },
+  // Right
+  {
+    start: new Point(rect.x + rect.width, rect.y + rect.height),
+    end: new Point(rect.x, rect.y + rect.height)
+  },
+  // Bottom
+  {
+    start: new Point(rect.x, rect.y + rect.height),
+    end: new Point(rect.x, rect.y)
+  } // Left
+  ];
+
+  // Find intersection point with each edge
+  var _loop = function _loop() {
+    var edge = _edges[_i];
+    var intersection = getLineSegmentIntersection(p1, p2, edge.start, edge.end);
+    if (intersection) {
+      // Check if this point is already in the list (avoid duplicates at corners)
+      var isDuplicate = intersections.some(function (existing) {
+        return Math.abs(existing.x - intersection.x) < tolerance && Math.abs(existing.y - intersection.y) < tolerance;
+      });
+      if (!isDuplicate) {
+        intersections.push(intersection);
+      }
     }
+  };
+  for (var _i = 0, _edges = edges; _i < _edges.length; _i++) {
+    _loop();
   }
-  return false;
+  return intersections;
 }
 
 /**
- * Check if a line segment intersects with a node
+ * Get intersection point between two line segments (if exists)
  */
-function checkSegmentIntersection(p1, p2, nodeId, nodeBBox, isTerminalNode) {
-  if (isTerminalNode) {
-    // For source/target nodes, check if segment crosses through (not just touching edge)
-    if (lineSegmentCrossesRect(p1, p2, nodeBBox)) {
-      console.log("[pathIntersectsObstacles] Segment crosses terminal node ".concat(nodeId));
-      return true;
-    }
-  } else {
-    // For other nodes, check normal intersection
-    if (lineSegmentIntersectsRect(p1, p2, nodeBBox)) {
-      console.log("[pathIntersectsObstacles] Segment intersects node ".concat(nodeId));
-      return true;
-    }
+function getLineSegmentIntersection(p1, p2, p3, p4) {
+  var d1 = direction(p3, p4, p1);
+  var d2 = direction(p3, p4, p2);
+  var d3 = direction(p1, p2, p3);
+  var d4 = direction(p1, p2, p4);
+  if ((d1 > 0 && d2 < 0 || d1 < 0 && d2 > 0) && (d3 > 0 && d4 < 0 || d3 < 0 && d4 > 0)) {
+    // Lines intersect, calculate intersection point
+    var t = ((p3.x - p1.x) * (p3.y - p4.y) - (p3.y - p1.y) * (p3.x - p4.x)) / ((p1.x - p2.x) * (p3.y - p4.y) - (p1.y - p2.y) * (p3.x - p4.x));
+    return new Point(p1.x + t * (p2.x - p1.x), p1.y + t * (p2.y - p1.y));
   }
-  return false;
+
+  // Check collinear cases
+  if (d1 === 0 && onSegment(p3, p1, p4)) return p1.clone();
+  if (d2 === 0 && onSegment(p3, p2, p4)) return p2.clone();
+  if (d3 === 0 && onSegment(p1, p3, p2)) return p3.clone();
+  if (d4 === 0 && onSegment(p1, p4, p2)) return p4.clone();
+  return null;
+}
+function direction(p1, p2, p3) {
+  return (p3.x - p1.x) * (p2.y - p1.y) - (p2.x - p1.x) * (p3.y - p1.y);
+}
+function onSegment(p1, p2, p3) {
+  return p2.x >= Math.min(p1.x, p3.x) && p2.x <= Math.max(p1.x, p3.x) && p2.y >= Math.min(p1.y, p3.y) && p2.y <= Math.max(p1.y, p3.y);
 }
 
 /**
  * Check if a path intersects with any obstacles (nodes)
+ * A path is considered to intersect if it has >= 2 unique intersection points with a node
+ *
+ * Note: pathPoints should be pre-processed by parseSVGPath which samples bezier curves
+ * into line segments, so this function works correctly with curved paths
  */
-export function pathIntersectsObstacles(pathPoints, nodeLookup, sourceNodeId, targetNodeId) {
-  // Iterate through all nodes
+export function pathIntersectsObstacles(pathPoints, nodeLookup) {
+  var tolerance = 0.01;
+
+  // Iterate through all nodes (including source and target)
   var _iterator = _createForOfIteratorHelper(nodeLookup),
     _step;
   try {
     for (_iterator.s(); !(_step = _iterator.n()).done;) {
-      var _step$value = _slicedToArray(_step.value, 2),
-        nodeId = _step$value[0],
-        node = _step$value[1];
+      var _step$value = _slicedToArray(_step.value, 1),
+        nodeId = _step$value[0];
       var nodeBBox = getNodeBBox(nodeId, nodeLookup);
       if (!nodeBBox) continue;
-      var isTerminalNode = nodeId === sourceNodeId || nodeId === targetNodeId;
+      var allIntersections = [];
 
-      // Check each point
-      for (var i = 0; i < pathPoints.length; i++) {
-        var point = pathPoints[i];
-        if (checkPointIntersection(point, nodeId, nodeBBox, isTerminalNode)) {
-          return true;
-        }
+      // Collect all unique intersection points for this node
+      for (var i = 0; i < pathPoints.length - 1; i++) {
+        var p1 = pathPoints[i];
+        var p2 = pathPoints[i + 1];
+        var segmentIntersections = findSegmentRectIntersections(p1, p2, nodeBBox);
 
-        // Check line segment to next point
-        if (i < pathPoints.length - 1) {
-          var nextPoint = pathPoints[i + 1];
-          if (checkSegmentIntersection(point, nextPoint, nodeId, nodeBBox, isTerminalNode)) {
-            return true;
+        // Add to global list, avoiding duplicates
+        var _iterator2 = _createForOfIteratorHelper(segmentIntersections),
+          _step2;
+        try {
+          var _loop2 = function _loop2() {
+            var intersection = _step2.value;
+            var isDuplicate = allIntersections.some(function (existing) {
+              return Math.abs(existing.x - intersection.x) < tolerance && Math.abs(existing.y - intersection.y) < tolerance;
+            });
+            if (!isDuplicate) {
+              allIntersections.push(intersection);
+            }
+          };
+          for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+            _loop2();
           }
+        } catch (err) {
+          _iterator2.e(err);
+        } finally {
+          _iterator2.f();
         }
       }
+
+      // If path has 2 or more unique intersections with this node, it crosses through it
+      if (allIntersections.length >= 2) {
+        console.log("[pathIntersectsObstacles] Path crosses node ".concat(nodeId, " with ").concat(allIntersections.length, " intersections"));
+        return true;
+      }
     }
   } catch (err) {
     _iterator.e(err);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rxflow/manhattan",
-  "version": "0.0.1-alpha.1",
+  "version": "0.0.1-alpha.11",
   "description": "Manhattan routing algorithm for ReactFlow - generates orthogonal paths with obstacle avoidance",
   "keywords": [
     "reactflow",