@grafloria/element 0.3.18 → 0.3.20

package/src/libs/engine/src/routing/algorithms/OrthogonalRouter.js

@@ -0,0 +1,1092 @@
+"use strict";
+// OrthogonalRouter - Right-angle routing with obstacle avoidance
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OrthogonalRouter = void 0;
+const ObstacleIndex_1 = require("../ObstacleIndex");
+/**
+ * Wave 8 — Card 6. Below this many obstacles a linear scan beats a hash lookup,
+ * and building an index would cost more than it saves. Above it, the scan is
+ * what made a one-node drag take 5.5 seconds.
+ */
+const INDEX_THRESHOLD = 24;
+/**
+ * OrthogonalRouter creates paths with only 90-degree angles
+ * Supports obstacle avoidance using A* on a grid
+ */
+class OrthogonalRouter {
+    /**
+     * The index for this obstacle set: the caller's if it prepared one (the
+     * engine does), otherwise ours. Returns null for a set small enough that
+     * scanning it is genuinely cheaper.
+     */
+    static indexFor(obstacles, provided) {
+        if (provided)
+            return provided;
+        if (obstacles.length < INDEX_THRESHOLD)
+            return null;
+        let idx = OrthogonalRouter.indexCache.get(obstacles);
+        if (!idx) {
+            idx = new ObstacleIndex_1.ObstacleIndex(obstacles);
+            OrthogonalRouter.indexCache.set(obstacles, idx);
+        }
+        return idx;
+    }
+    getName() {
+        return 'orthogonal';
+    }
+    route(request) {
+        var _a, _b;
+        const { start, end, obstacles = [], options = {}, sourceDirection, targetDirection } = request;
+        const index = OrthogonalRouter.indexFor(obstacles, request.obstacleIndex);
+        // Handle same start and end point
+        if (start.x === end.x && start.y === end.y) {
+            return {
+                points: [{ x: start.x, y: start.y }],
+                totalLength: 0,
+                bendCount: 0,
+                cost: 0,
+                segments: [],
+            };
+        }
+        const bendCost = (_b = (_a = options.costs) === null || _a === void 0 ? void 0 : _a.bends) !== null && _b !== void 0 ? _b : 10;
+        // Card 1: an explicit jetty upgrades the stub contract from best-effort to
+        // GUARANTEED — and lets floating (direction-less) anchors derive exit sides
+        // from the geometry instead of taking the stub-less midline fallback.
+        const jetty = options.jetty;
+        let srcDir = sourceDirection;
+        let tgtDir = targetDirection;
+        if (jetty !== undefined) {
+            if (!srcDir)
+                srcDir = OrthogonalRouter.deriveExitSide(start, end);
+            if (!tgtDir)
+                tgtDir = OrthogonalRouter.deriveExitSide(end, start);
+        }
+        // The jetty guarantee holds on WHICHEVER branch produced the route: simple,
+        // A*-avoidance, or the collision fallback.
+        const withJetty = (path) => jetty !== undefined ? this.enforceJetty(path, start, end, srcDir, tgtDir, jetty, bendCost) : path;
+        // SMART ROUTING: Always calculate a simple orthogonal path first
+        const simplePath = this.simpleOrthogonalRoute(start, end, options.gridSize, bendCost, srcDir, tgtDir, jetty);
+        // If no obstacles provided, return the simple path
+        if (obstacles.length === 0) {
+            return withJetty(simplePath);
+        }
+        // Check if the simple path intersects any obstacles
+        const hasCollision = this.pathIntersectsObstacles(simplePath.points, obstacles, index);
+        if (!hasCollision) {
+            // Path is clear, use the simple routing
+            return withJetty(simplePath);
+        }
+        // Path has collisions - use A* pathfinding for obstacle avoidance
+        if (options.avoidObstacles) {
+            const avoidancePath = this.avoidObstaclesRoute(start, end, obstacles, options, srcDir, tgtDir, index);
+            if (avoidancePath) {
+                return withJetty(avoidancePath);
+            }
+        }
+        // Fallback: return simple path even with collisions
+        // (visual indicator that routing needs manual waypoints)
+        return withJetty(simplePath);
+    }
+    /**
+     * Card 1: the exit side a FLOATING anchor should use, derived from where the
+     * other endpoint is — dominant axis first, ties break horizontal (matching
+     * the midline fallback's own axis choice, so the derived route agrees with
+     * what the undirected route would have preferred).
+     */
+    static deriveExitSide(from, toward) {
+        const dx = toward.x - from.x;
+        const dy = toward.y - from.y;
+        if (Math.abs(dx) >= Math.abs(dy))
+            return dx >= 0 ? 'right' : 'left';
+        return dy >= 0 ? 'bottom' : 'top';
+    }
+    /**
+     * Card 1: guarantee the route leaves/enters PERPENDICULAR to the port side
+     * for at least `jetty` px before the first/after the last bend.
+     *
+     * The simple route's gap logic shrinks stubs on short links (its gapOffset
+     * clamp), and the A* grid can snap the first elbow closer than the stub — so
+     * the guarantee is enforced as a post-pass: if the first segment along the
+     * port direction is shorter than the jetty (or points the wrong way), a stub
+     * point is inserted at start + dir·jetty and the joint is re-orthogonalised
+     * by routing the old interior through the stub's far ordinate. Same for the
+     * target end, mirrored.
+     */
+    enforceJetty(path, start, end, sourceDirection, targetDirection, jetty, bendCost) {
+        if (jetty <= 0 || path.points.length < 2)
+            return path;
+        const fixEnd = (pts, anchor, dir) => {
+            if (!dir || pts.length < 2)
+                return pts;
+            const v = dir === 'left' ? { x: -1, y: 0 }
+                : dir === 'right' ? { x: 1, y: 0 }
+                    : dir === 'top' ? { x: 0, y: -1 }
+                        : { x: 0, y: 1 };
+            const stub = { x: anchor.x + v.x * jetty, y: anchor.y + v.y * jetty };
+            const first = pts[0];
+            const second = pts[1];
+            // Does the existing first segment already satisfy the contract?
+            const seg = { x: second.x - first.x, y: second.y - first.y };
+            const along = seg.x * v.x + seg.y * v.y; // signed length along the port normal
+            const perpendicular = v.x !== 0 ? seg.y === 0 : seg.x === 0;
+            if (perpendicular && along >= jetty)
+                return pts;
+            // Insert the stub, then re-orthogonalise the joint. Points of the old
+            // route lying ON the anchor→stub segment are SUBSUMED by the stub, not
+            // detoured around — otherwise a collinear-but-short stub would rebuild as
+            // an out-and-back run on the same line, which the collinear merge then
+            // collapses straight back to the too-short original (the exact failure
+            // mode the obstacle-avoidance test caught: A* grid-snaps its last elbow
+            // inside the jetty window).
+            let rest = pts.slice(1);
+            const onStubSegment = (q) => {
+                if (v.x !== 0) {
+                    if (q.y !== anchor.y)
+                        return false;
+                    const t = (q.x - anchor.x) * v.x; // signed distance along the stub
+                    return t >= 0 && t <= jetty;
+                }
+                if (q.x !== anchor.x)
+                    return false;
+                const t = (q.y - anchor.y) * v.y;
+                return t >= 0 && t <= jetty;
+            };
+            // never subsume the far anchor itself — a fully-collinear straight link
+            // must keep its endpoint.
+            while (rest.length > 1 && onStubSegment(rest[0]))
+                rest = rest.slice(1);
+            const joint = v.x !== 0
+                ? { x: stub.x, y: rest[0].y } // horizontal stub: drop vertically to the old route
+                : { x: rest[0].x, y: stub.y }; // vertical stub: run horizontally to the old route
+            const rebuilt = [first, stub, joint, ...rest];
+            // Collapse duplicates/collinear runs the insertion may have created.
+            return this.mergeCollinearPoints(this.removeDuplicatePoints(rebuilt));
+        };
+        let pts = fixEnd(path.points.map((p) => (Object.assign({}, p))), start, sourceDirection);
+        pts = fixEnd(pts.slice().reverse(), end, targetDirection).reverse();
+        const totalLength = this.calculatePathLength(pts);
+        const bendCount = Math.max(0, pts.length - 2);
+        return {
+            points: pts,
+            totalLength,
+            bendCount,
+            cost: totalLength + bendCount * bendCost,
+            segments: this.calculateSegments(pts),
+        };
+    }
+    /**
+     * Simple orthogonal route - exact implementation of React Flow's getSmoothStepPath
+     * Based on React Flow's smoothstep-edge.ts getPoints() function
+     * Handles all edge cases: opposite ports, same ports, mixed ports
+     *
+     * CRITICAL: The offset determines how far the line moves away from the port
+     * before making turns. A larger offset creates more spacing from nodes.
+     */
+    simpleOrthogonalRoute(start, end, gridSize, bendCost = 10, sourceDirection, targetDirection, jetty) {
+        // No port directions at all: route through the midline (classic HVH/VHV,
+        // the React Flow default for undirected points). The gap-point logic below
+        // assumes port directions and emits stub artifacts without them.
+        if (!sourceDirection && !targetDirection) {
+            let pts;
+            if (start.x === end.x || start.y === end.y) {
+                pts = [Object.assign({}, start), Object.assign({}, end)];
+            }
+            else if (Math.abs(end.x - start.x) >= Math.abs(end.y - start.y)) {
+                const midX = (start.x + end.x) / 2;
+                pts = [Object.assign({}, start), { x: midX, y: start.y }, { x: midX, y: end.y }, Object.assign({}, end)];
+            }
+            else {
+                const midY = (start.y + end.y) / 2;
+                pts = [Object.assign({}, start), { x: start.x, y: midY }, { x: end.x, y: midY }, Object.assign({}, end)];
+            }
+            if (gridSize && gridSize > 1) {
+                // Interior points share one snapped ordinate, so segments stay orthogonal
+                for (let i = 1; i < pts.length - 1; i++) {
+                    pts[i] = {
+                        x: Math.round(pts[i].x / gridSize) * gridSize,
+                        y: Math.round(pts[i].y / gridSize) * gridSize,
+                    };
+                }
+            }
+            const merged = this.mergeCollinearPoints(this.removeDuplicatePoints(pts));
+            const totalLength = this.calculatePathLength(merged);
+            const bendCount = Math.max(0, merged.length - 2);
+            return {
+                points: merged,
+                totalLength,
+                bendCount,
+                cost: totalLength + bendCount * bendCost,
+                segments: this.calculateSegments(merged),
+            };
+        }
+        // CRITICAL OFFSET: This determines the "breathing room" around nodes
+        // Match React Flow's exact offset value for visual consistency.
+        // Card 1: an explicit jetty replaces it (enforceJetty then GUARANTEES it).
+        const offset = jetty !== null && jetty !== void 0 ? jetty : 20;
+        // Get direction vectors for source and target
+        const sourceDir = this.getDirectionVector(sourceDirection);
+        const targetDir = this.getDirectionVector(targetDirection);
+        // Calculate gapped points (moved away from port in port direction)
+        const sourceGapped = {
+            x: start.x + sourceDir.x * offset,
+            y: start.y + sourceDir.y * offset
+        };
+        const targetGapped = {
+            x: end.x + targetDir.x * offset,
+            y: end.y + targetDir.y * offset
+        };
+        // Determine primary routing direction (React Flow line 86-92)
+        const dir = this.getRoutingDirection(sourceGapped, sourceDirection, targetGapped);
+        const dirAccessor = dir.x !== 0 ? 'x' : 'y';
+        const currDir = dir[dirAccessor];
+        let points = [];
+        const sourceGapOffset = { x: 0, y: 0 };
+        const targetGapOffset = { x: 0, y: 0 };
+        // React Flow line 107: Check if handles are opposite
+        if (sourceDir[dirAccessor] * targetDir[dirAccessor] === -1) {
+            // CASE 1: Opposite handle positions (e.g., Left -> Right, Top -> Bottom)
+            // Use Z-shape routing with center point
+            //
+            // SMART ROUTING: When ports are opposite, we create a "bent" path that routes
+            // around potential node collisions. The bend happens at the midpoint, creating
+            // a visual "elbow" that clearly shows the connection path.
+            let centerX, centerY;
+            if (dirAccessor === 'x') {
+                // Horizontal routing (e.g., Left -> Right, Right -> Left)
+                // CRITICAL FIX: Detect overshoot scenario
+                // When routing right-to-left but sourceGapped is already to the right of targetGapped,
+                // using the midpoint would cause the path to overshoot and penetrate the target node.
+                // Instead, clamp the bend to the source edge to route around the side.
+                const isOvershooting = (sourceDir.x > 0 && sourceGapped.x > targetGapped.x) ||
+                    (sourceDir.x < 0 && sourceGapped.x < targetGapped.x);
+                if (isOvershooting) {
+                    // Overshoot detected: Place bend at source edge, not midpoint
+                    // This makes the path exit the source, turn immediately, and route around the side
+                    centerX = sourceGapped.x;
+                }
+                else {
+                    // Normal case: Use midpoint
+                    centerX = (sourceGapped.x + targetGapped.x) / 2;
+                }
+                // For horizontal routing, we keep Y at source/target levels to create clear steps
+                centerY = (sourceGapped.y + targetGapped.y) / 2;
+            }
+            else {
+                // Vertical routing (e.g., Top -> Bottom, Bottom -> Top)
+                // CRITICAL FIX: Detect overshoot scenario for vertical routing
+                const isOvershooting = (sourceDir.y > 0 && sourceGapped.y > targetGapped.y) ||
+                    (sourceDir.y < 0 && sourceGapped.y < targetGapped.y);
+                if (isOvershooting) {
+                    // Overshoot detected: Place bend at source edge
+                    centerY = sourceGapped.y;
+                }
+                else {
+                    // Normal case: Use midpoint
+                    centerY = (sourceGapped.y + targetGapped.y) / 2;
+                }
+                // For vertical routing, we keep X at source/target levels to create clear steps
+                centerX = (sourceGapped.x + targetGapped.x) / 2;
+            }
+            // React Flow lines 123-140: Choose between vertical and horizontal split
+            // This creates the characteristic "step" pattern
+            const verticalSplit = [
+                { x: centerX, y: sourceGapped.y },
+                { x: centerX, y: targetGapped.y },
+            ];
+            const horizontalSplit = [
+                { x: sourceGapped.x, y: centerY },
+                { x: targetGapped.x, y: centerY },
+            ];
+            if (sourceDir[dirAccessor] === currDir) {
+                points = dirAccessor === 'x' ? verticalSplit : horizontalSplit;
+            }
+            else {
+                points = dirAccessor === 'x' ? horizontalSplit : verticalSplit;
+            }
+        }
+        else {
+            // CASE 2: Same or perpendicular handle positions
+            // Use L-shape routing
+            // React Flow lines 144-145: Define the two L-shape options
+            const sourceTarget = [{ x: sourceGapped.x, y: targetGapped.y }];
+            const targetSource = [{ x: targetGapped.x, y: sourceGapped.y }];
+            // React Flow lines 147-151: Choose L-shape direction
+            if (dirAccessor === 'x') {
+                points = sourceDir.x === currDir ? targetSource : sourceTarget;
+            }
+            else {
+                points = sourceDir.y === currDir ? sourceTarget : targetSource;
+            }
+            // React Flow lines 153-165: Handle same position ports that are too close
+            if (sourceDirection === targetDirection) {
+                const diff = Math.abs(start[dirAccessor] - end[dirAccessor]);
+                if (diff <= offset) {
+                    const gapOffset = Math.min(offset - 1, offset - diff);
+                    if (sourceDir[dirAccessor] === currDir) {
+                        sourceGapOffset[dirAccessor] = (sourceGapped[dirAccessor] > start[dirAccessor] ? -1 : 1) * gapOffset;
+                    }
+                    else {
+                        targetGapOffset[dirAccessor] = (targetGapped[dirAccessor] > end[dirAccessor] ? -1 : 1) * gapOffset;
+                    }
+                }
+            }
+            // React Flow lines 168-180: Handle mixed handle positions (e.g., Right -> Bottom)
+            if (sourceDirection !== targetDirection) {
+                const dirAccessorOpposite = dirAccessor === 'x' ? 'y' : 'x';
+                const isSameDir = sourceDir[dirAccessor] === targetDir[dirAccessorOpposite];
+                const sourceGtTargetOppo = sourceGapped[dirAccessorOpposite] > targetGapped[dirAccessorOpposite];
+                const sourceLtTargetOppo = sourceGapped[dirAccessorOpposite] < targetGapped[dirAccessorOpposite];
+                const flipSourceTarget = (sourceDir[dirAccessor] === 1 && ((!isSameDir && sourceGtTargetOppo) || (isSameDir && sourceLtTargetOppo))) ||
+                    (sourceDir[dirAccessor] !== 1 && ((!isSameDir && sourceLtTargetOppo) || (isSameDir && sourceGtTargetOppo)));
+                if (flipSourceTarget) {
+                    points = dirAccessor === 'x' ? sourceTarget : targetSource;
+                }
+            }
+        }
+        // Build path points
+        const sourceGapPoint = { x: sourceGapped.x + sourceGapOffset.x, y: sourceGapped.y + sourceGapOffset.y };
+        const targetGapPoint = { x: targetGapped.x + targetGapOffset.x, y: targetGapped.y + targetGapOffset.y };
+        // CRITICAL FIX: Ensure first and last segments are orthogonal
+        // Check if start->sourceGapPoint creates a diagonal (non-orthogonal) segment
+        const firstSegmentIsOrthogonal = (start.x === sourceGapPoint.x) || (start.y === sourceGapPoint.y);
+        const lastSegmentIsOrthogonal = (end.x === targetGapPoint.x) || (end.y === targetGapPoint.y);
+        // Build path: only include start/end if they create orthogonal segments
+        const pathPoints = [];
+        if (firstSegmentIsOrthogonal) {
+            pathPoints.push(start);
+        }
+        pathPoints.push(sourceGapPoint);
+        pathPoints.push(...points);
+        pathPoints.push(targetGapPoint);
+        if (lastSegmentIsOrthogonal) {
+            pathPoints.push(end);
+        }
+        // Snap to grid if specified
+        // CRITICAL FIX: Do NOT snap the first and last points (port positions)
+        // Only snap intermediate waypoints to prevent mismatch with port positions
+        if (gridSize && gridSize > 1) {
+            pathPoints.forEach((p, index) => {
+                // Skip first and last points - they must stay at exact port positions
+                if (index === 0 || index === pathPoints.length - 1) {
+                    return;
+                }
+                p.x = Math.round(p.x / gridSize) * gridSize;
+                p.y = Math.round(p.y / gridSize) * gridSize;
+            });
+            // CRITICAL FIX: After grid snapping, ensure first and last segments remain orthogonal
+            // Grid snapping intermediate points can create diagonal segments with unsnapped endpoints
+            if (pathPoints.length >= 2) {
+                // Fix first segment: ensure point[1] is orthogonal to point[0] (start)
+                const start = pathPoints[0];
+                const firstIntermediate = pathPoints[1];
+                const firstIsHorizontal = start.y === firstIntermediate.y;
+                const firstIsVertical = start.x === firstIntermediate.x;
+                if (!firstIsHorizontal && !firstIsVertical) {
+                    // Determine which direction to align based on source direction or infer from geometry
+                    let alignedHorizontally = false;
+                    let alignedVertically = false;
+                    if (sourceDirection === 'left' || sourceDirection === 'right') {
+                        // Horizontal port - make first segment horizontal
+                        firstIntermediate.y = start.y;
+                        alignedHorizontally = true;
+                    }
+                    else if (sourceDirection === 'top' || sourceDirection === 'bottom') {
+                        // Vertical port - make first segment vertical
+                        firstIntermediate.x = start.x;
+                        alignedVertically = true;
+                    }
+                    else {
+                        // Direction unknown - infer from start/end relative positions
+                        const deltaX = Math.abs(end.x - start.x);
+                        const deltaY = Math.abs(end.y - start.y);
+                        if (deltaX > deltaY) {
+                            firstIntermediate.y = start.y;
+                            alignedHorizontally = true;
+                        }
+                        else {
+                            firstIntermediate.x = start.x;
+                            alignedVertically = true;
+                        }
+                    }
+                    // CRITICAL FIX: Propagate alignment to all intermediate points (not just first one)
+                    // This fixes the issue where point 2, 3, etc. still have wrong coordinates after grid snap
+                    if (pathPoints.length > 3) {
+                        for (let i = 2; i < pathPoints.length - 1; i++) {
+                            if (alignedHorizontally && pathPoints[i].y !== start.y) {
+                                pathPoints[i].y = start.y;
+                            }
+                            else if (alignedVertically && pathPoints[i].x !== start.x) {
+                                pathPoints[i].x = start.x;
+                            }
+                        }
+                    }
+                }
+                // Fix last segment: ensure point[n-2] is orthogonal to point[n-1] (end)
+                if (pathPoints.length >= 3) {
+                    const end = pathPoints[pathPoints.length - 1];
+                    const lastIntermediate = pathPoints[pathPoints.length - 2];
+                    const lastIsHorizontal = lastIntermediate.y === end.y;
+                    const lastIsVertical = lastIntermediate.x === end.x;
+                    if (!lastIsHorizontal && !lastIsVertical) {
+                        // Determine which direction to align based on target direction or infer from geometry
+                        if (targetDirection === 'left' || targetDirection === 'right') {
+                            // Horizontal port - make last segment horizontal
+                            lastIntermediate.y = end.y;
+                        }
+                        else if (targetDirection === 'top' || targetDirection === 'bottom') {
+                            // Vertical port - make last segment vertical
+                            lastIntermediate.x = end.x;
+                        }
+                        else {
+                            // Direction unknown - infer from start/end relative positions
+                            const deltaX = Math.abs(end.x - start.x);
+                            const deltaY = Math.abs(end.y - start.y);
+                            if (deltaX > deltaY) {
+                                // Endpoints are more horizontally separated - likely horizontal port
+                                lastIntermediate.y = end.y;
+                            }
+                            else {
+                                // Endpoints are more vertically separated - likely vertical port
+                                lastIntermediate.x = end.x;
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        // Remove duplicate consecutive points, then merge collinear runs — the
+        // gap-point construction can emit out-and-back stubs (A→B→A) and split
+        // straight lines into multiple segments
+        const uniquePoints = this.mergeCollinearPoints(this.removeDuplicatePoints(pathPoints));
+        const totalLength = this.calculatePathLength(uniquePoints);
+        const bendCount = uniquePoints.length - 2;
+        return {
+            points: uniquePoints,
+            totalLength,
+            bendCount: Math.max(0, bendCount),
+            cost: totalLength + bendCount * bendCost,
+            segments: this.calculateSegments(uniquePoints),
+        };
+    }
+    /**
+     * Merge collinear consecutive points. Because the kept path lies on the
+     * same line the removed points did, this also collapses out-and-back
+     * excursions (backtracking stubs) without changing route coverage.
+     */
+    mergeCollinearPoints(points) {
+        if (points.length <= 2)
+            return points;
+        const out = [points[0]];
+        for (let i = 1; i < points.length; i++) {
+            const q = points[i];
+            while (out.length >= 2) {
+                const a = out[out.length - 2];
+                const b = out[out.length - 1];
+                const cross = (b.x - a.x) * (q.y - b.y) - (b.y - a.y) * (q.x - b.x);
+                if (Math.abs(cross) < 1e-6)
+                    out.pop();
+                else
+                    break;
+            }
+            const tail = out[out.length - 1];
+            if (Math.abs(q.x - tail.x) > 1e-9 || Math.abs(q.y - tail.y) > 1e-9) {
+                out.push(q);
+            }
+        }
+        return out;
+    }
+    /**
+     * Check if we can use a direct straight line between ports
+     * This happens when ports are aligned and facing each other directly
+     */
+    canUseDirectLine(start, end, sourceDirection, targetDirection, _sourceOffset, _targetOffset) {
+        if (!sourceDirection || !targetDirection)
+            return false;
+        const tolerance = 2; // pixels
+        // Check if horizontally aligned (same Y)
+        const horizontallyAligned = Math.abs(start.y - end.y) < tolerance;
+        // Check if vertically aligned (same X)
+        const verticallyAligned = Math.abs(start.x - end.x) < tolerance;
+        // For horizontal alignment, ports should face left/right
+        if (horizontallyAligned) {
+            const horizontalPorts = ((sourceDirection === 'left' || sourceDirection === 'right') &&
+                (targetDirection === 'left' || targetDirection === 'right'));
+            // Check if they face each other
+            const facingEachOther = ((sourceDirection === 'right' && targetDirection === 'left' && start.x < end.x) ||
+                (sourceDirection === 'left' && targetDirection === 'right' && start.x > end.x));
+            return horizontalPorts && facingEachOther;
+        }
+        // For vertical alignment, ports should face top/bottom
+        if (verticallyAligned) {
+            const verticalPorts = ((sourceDirection === 'top' || sourceDirection === 'bottom') &&
+                (targetDirection === 'top' || targetDirection === 'bottom'));
+            // Check if they face each other
+            const facingEachOther = ((sourceDirection === 'bottom' && targetDirection === 'top' && start.y < end.y) ||
+                (sourceDirection === 'top' && targetDirection === 'bottom' && start.y > end.y));
+            return verticalPorts && facingEachOther;
+        }
+        return false;
+    }
+    /**
+     * Simplify orthogonal path by removing redundant collinear points
+     * ONLY removes points that are on the same straight line (horizontal or vertical)
+     * This preserves proper orthogonal (right-angle) routing
+     */
+    simplifyOrthogonalPath(points) {
+        if (points.length <= 2)
+            return points;
+        const simplified = [points[0]];
+        const tolerance = 0.1; // Very tight tolerance for orthogonal alignment
+        for (let i = 1; i < points.length - 1; i++) {
+            const prev = simplified[simplified.length - 1]; // Use last point in simplified array
+            const curr = points[i];
+            const next = points[i + 1];
+            // Check if prev, curr, next are collinear (on same horizontal or vertical line)
+            const isHorizontalLine = Math.abs(prev.y - curr.y) < tolerance &&
+                Math.abs(curr.y - next.y) < tolerance;
+            const isVerticalLine = Math.abs(prev.x - curr.x) < tolerance &&
+                Math.abs(curr.x - next.x) < tolerance;
+            // Only skip this point if it's truly collinear (on same straight line)
+            // This removes redundant intermediate points but keeps all bends
+            if (!isHorizontalLine && !isVerticalLine) {
+                simplified.push(curr);
+            }
+        }
+        simplified.push(points[points.length - 1]);
+        return simplified;
+    }
+    /**
+     * Apply gap offset in the direction the port points
+     */
+    applyGapOffset(point, direction, offset) {
+        if (!direction)
+            return point;
+        switch (direction) {
+            case 'left':
+                return { x: point.x - offset, y: point.y };
+            case 'right':
+                return { x: point.x + offset, y: point.y };
+            case 'top':
+                return { x: point.x, y: point.y - offset };
+            case 'bottom':
+                return { x: point.x, y: point.y + offset };
+        }
+    }
+    /**
+     * Get direction vector for a port direction (React Flow style)
+     */
+    getDirectionVector(direction) {
+        if (!direction)
+            return { x: 0, y: 0 };
+        switch (direction) {
+            case 'left':
+                return { x: -1, y: 0 };
+            case 'right':
+                return { x: 1, y: 0 };
+            case 'top':
+                return { x: 0, y: -1 };
+            case 'bottom':
+                return { x: 0, y: 1 };
+        }
+    }
+    /**
+     * Determine routing direction based on source/target positions (React Flow logic)
+     */
+    getRoutingDirection(source, sourcePosition, target) {
+        if (!sourcePosition)
+            return { x: 1, y: 0 };
+        // For horizontal ports (left/right), determine X direction
+        if (sourcePosition === 'left' || sourcePosition === 'right') {
+            return source.x < target.x ? { x: 1, y: 0 } : { x: -1, y: 0 };
+        }
+        // For vertical ports (top/bottom), determine Y direction
+        return source.y < target.y ? { x: 0, y: 1 } : { x: 0, y: -1 };
+    }
+    /**
+     * Determine if we need Z-shape routing (vs L-shape)
+     * Z-shape is needed when ports point toward each other or in same direction
+     */
+    needsZShape(sourceDir, targetDir, sourceOffset, targetOffset) {
+        if (!sourceDir || !targetDir)
+            return false;
+        // Ports pointing opposite directions (toward each other)
+        const oppositeDirections = ((sourceDir === 'left' && targetDir === 'right') ||
+            (sourceDir === 'right' && targetDir === 'left') ||
+            (sourceDir === 'top' && targetDir === 'bottom') ||
+            (sourceDir === 'bottom' && targetDir === 'top'));
+        // Ports pointing same direction
+        const sameDirection = sourceDir === targetDir;
+        return oppositeDirections || sameDirection;
+    }
+    /**
+     * Calculate L-shape midpoint (one bend)
+     */
+    calculateLShapeMidpoint(sourceOffset, targetOffset, sourceDir, targetDir) {
+        // For L-shape, decide whether to go horizontal-then-vertical or vertical-then-horizontal
+        // Based on which port direction is dominant
+        const isSourceHorizontal = sourceDir === 'left' || sourceDir === 'right';
+        const isTargetHorizontal = targetDir === 'left' || targetDir === 'right';
+        if (isSourceHorizontal && !isTargetHorizontal) {
+            // Source is horizontal, target is vertical: horizontal first
+            return { x: targetOffset.x, y: sourceOffset.y };
+        }
+        else if (!isSourceHorizontal && isTargetHorizontal) {
+            // Source is vertical, target is horizontal: vertical first
+            return { x: sourceOffset.x, y: targetOffset.y };
+        }
+        else {
+            // Both same orientation - choose based on distance
+            const dx = Math.abs(targetOffset.x - sourceOffset.x);
+            const dy = Math.abs(targetOffset.y - sourceOffset.y);
+            if (dx > dy) {
+                return { x: targetOffset.x, y: sourceOffset.y };
+            }
+            else {
+                return { x: sourceOffset.x, y: targetOffset.y };
+            }
+        }
+    }
+    /**
+     * Calculate Z-shape midpoints (two bends)
+     */
+    calculateZShapeMidpoints(sourceOffset, targetOffset, sourceDir, targetDir) {
+        const isSourceHorizontal = sourceDir === 'left' || sourceDir === 'right';
+        if (isSourceHorizontal) {
+            // Horizontal source: H-V-H routing
+            const midX = (sourceOffset.x + targetOffset.x) / 2;
+            return [
+                { x: midX, y: sourceOffset.y },
+                { x: midX, y: targetOffset.y }
+            ];
+        }
+        else {
+            // Vertical source: V-H-V routing
+            const midY = (sourceOffset.y + targetOffset.y) / 2;
+            return [
+                { x: sourceOffset.x, y: midY },
+                { x: targetOffset.x, y: midY }
+            ];
+        }
+    }
+    /**
+     * Orthogonal routing with obstacle avoidance using A*
+     */
+    avoidObstaclesRoute(start, end, obstacles, options, sourceDirection, targetDirection, index) {
+        var _a, _b, _c, _d, _e, _f, _g;
+        const gridSize = (_a = options.gridSize) !== null && _a !== void 0 ? _a : 10;
+        const margin = (_b = options.obstacleMargin) !== null && _b !== void 0 ? _b : 20; // Margin around obstacles
+        const maxIterations = (_c = options.maxIterations) !== null && _c !== void 0 ? _c : 10000;
+        const gapOffset = 30; // Distance to move away from port (must be > margin to clear obstacle boundary)
+        // Apply gap offset to move away from ports before pathfinding
+        // This ensures paths don't start/end directly on node borders
+        const sourceOffset = this.applyGapOffset(start, sourceDirection, gapOffset);
+        const targetOffset = this.applyGapOffset(end, targetDirection, gapOffset);
+        // Snap offset points to grid for A* pathfinding
+        let gridStart = this.snapToGrid(sourceOffset, gridSize);
+        let gridEnd = this.snapToGrid(targetOffset, gridSize);
+        // CRITICAL FIX: Validate start/end points are not inside obstacles
+        // If grid snapping moved them into an obstacle, adjust outward
+        if (this.collidesWithObstacles(gridStart, obstacles, margin, index)) {
+            console.debug(`⚠️ Grid start point inside obstacle, adjusting...`);
+            gridStart = this.findNearestValidPoint(gridStart, sourceDirection, obstacles, margin, gridSize, index);
+        }
+        if (this.collidesWithObstacles(gridEnd, obstacles, margin, index)) {
+            console.debug(`⚠️ Grid end point inside obstacle, adjusting...`);
+            gridEnd = this.findNearestValidPoint(gridEnd, targetDirection, obstacles, margin, gridSize, index);
+        }
+        // Use A* to find path between offset points
+        const path = this.aStarPathfinding(gridStart, gridEnd, obstacles, gridSize, margin, maxIterations, index);
+        if (!path || path.length === 0) {
+            // IMPROVED: Log why pathfinding failed and what we're doing
+            console.debug(`⚠️ A* pathfinding failed for link routing:`, {
+                start: gridStart,
+                end: gridEnd,
+                obstacleCount: obstacles.length,
+                gridSize,
+                margin
+            });
+            console.debug(`   Falling back to simple orthogonal route (no obstacle avoidance)`);
+            // Fallback to simple route if pathfinding fails
+            return this.simpleOrthogonalRoute(start, end, gridSize, (_e = (_d = options.costs) === null || _d === void 0 ? void 0 : _d.bends) !== null && _e !== void 0 ? _e : 10, sourceDirection, targetDirection);
+        }
+        // Prepend actual start point and append actual end point
+        // This ensures the path connects to the exact port positions
+        const fullPath = [
+            { x: start.x, y: start.y },
+            ...path,
+            { x: end.x, y: end.y }
+        ];
+        // Remove duplicate consecutive points
+        const uniquePath = this.mergeCollinearPoints(this.removeDuplicatePoints(fullPath));
+        const totalLength = this.calculatePathLength(uniquePath);
+        const bendCount = this.countBends(uniquePath);
+        const bendCost = (_g = (_f = options.costs) === null || _f === void 0 ? void 0 : _f.bends) !== null && _g !== void 0 ? _g : 10;
+        return {
+            points: uniquePath,
+            totalLength,
+            bendCount,
+            cost: totalLength + bendCount * bendCost,
+            segments: this.calculateSegments(uniquePath),
+        };
+    }
+    /**
+     * A* pathfinding on a grid with improved obstacle avoidance
+     */
+    aStarPathfinding(start, end, obstacles, gridSize, margin, maxIterations, index) {
+        var _a, _b, _c;
+        const openSet = new Set();
+        const closedSet = new Set();
+        const cameFrom = new Map();
+        const gScore = new Map();
+        const fScore = new Map();
+        const startKey = this.pointToKey(start);
+        const endKey = this.pointToKey(end);
+        openSet.add(startKey);
+        gScore.set(startKey, 0);
+        fScore.set(startKey, this.heuristic(start, end));
+        let iterations = 0;
+        while (openSet.size > 0 && iterations < maxIterations) {
+            iterations++;
+            // Find node with lowest fScore
+            let currentKey = '';
+            let lowestF = Infinity;
+            for (const key of openSet) {
+                const f = (_a = fScore.get(key)) !== null && _a !== void 0 ? _a : Infinity;
+                if (f < lowestF) {
+                    lowestF = f;
+                    currentKey = key;
+                }
+            }
+            if (!currentKey)
+                break;
+            const current = this.keyToPoint(currentKey);
+            // Reached goal
+            if (currentKey === endKey) {
+                const path = this.reconstructPath(cameFrom, current);
+                // Simplify the A* path to remove unnecessary waypoints
+                return this.simplifyOrthogonalPath(path);
+            }
+            openSet.delete(currentKey);
+            closedSet.add(currentKey);
+            // Check neighbors (4-directional: up, down, left, right)
+            const neighbors = this.getOrthogonalNeighbors(current, gridSize);
+            for (const neighbor of neighbors) {
+                const neighborKey = this.pointToKey(neighbor);
+                if (closedSet.has(neighborKey))
+                    continue;
+                // Check if neighbor collides with obstacle
+                if (this.collidesWithObstacles(neighbor, obstacles, margin, index)) {
+                    closedSet.add(neighborKey);
+                    continue;
+                }
+                // Calculate movement cost with penalty for direction changes
+                let movementCost = gridSize;
+                // Add bend penalty if direction changed from previous segment
+                const parent = cameFrom.get(currentKey);
+                if (parent) {
+                    const prevDir = this.getDirection(parent, current);
+                    const nextDir = this.getDirection(current, neighbor);
+                    if (prevDir !== nextDir) {
+                        movementCost += gridSize * 0.5; // Penalty for bends to favor straighter paths
+                    }
+                }
+                const tentativeG = ((_b = gScore.get(currentKey)) !== null && _b !== void 0 ? _b : Infinity) + movementCost;
+                if (!openSet.has(neighborKey)) {
+                    openSet.add(neighborKey);
+                }
+                else if (tentativeG >= ((_c = gScore.get(neighborKey)) !== null && _c !== void 0 ? _c : Infinity)) {
+                    continue;
+                }
+                cameFrom.set(neighborKey, current);
+                gScore.set(neighborKey, tentativeG);
+                fScore.set(neighborKey, tentativeG + this.heuristic(neighbor, end));
+            }
+        }
+        // No path found
+        return null;
+    }
+    /**
+     * Reconstruct path from A* came-from map
+     */
+    reconstructPath(cameFrom, current) {
+        const path = [current];
+        let currentKey = this.pointToKey(current);
+        while (cameFrom.has(currentKey)) {
+            const point = cameFrom.get(currentKey);
+            path.unshift(point);
+            currentKey = this.pointToKey(point);
+        }
+        return path;
+    }
+    /**
+     * Manhattan distance heuristic
+     */
+    heuristic(a, b) {
+        return Math.abs(a.x - b.x) + Math.abs(a.y - b.y);
+    }
+    /**
+     * Get 4-directional orthogonal neighbors
+     */
+    getOrthogonalNeighbors(point, gridSize) {
+        return [
+            { x: point.x + gridSize, y: point.y }, // Right
+            { x: point.x - gridSize, y: point.y }, // Left
+            { x: point.x, y: point.y + gridSize }, // Down
+            { x: point.x, y: point.y - gridSize }, // Up
+        ];
+    }
+    /**
+     * Check if point collides with any obstacle
+     * FIXED: Use inclusive bounds to prevent paths grazing obstacle edges
+     */
+    collidesWithObstacles(point, obstacles, margin, index) {
+        // Wave 8 — Card 6: THE hot path. A* asks this once per neighbour of every
+        // cell it expands, and the linear scan below made that O(scene) — 1.87
+        // BILLION aabb tests in one measured 5k-node drag frame. The index answers
+        // with the identical predicate, looking only at obstacles near the point.
+        if (index)
+            return index.collides(point.x, point.y, margin);
+        for (const obstacle of obstacles) {
+            // Expand obstacle boundaries by margin to create safe zone around obstacles
+            const minX = obstacle.x - margin;
+            const maxX = obstacle.x + obstacle.width + margin;
+            const minY = obstacle.y - margin;
+            const maxY = obstacle.y + obstacle.height + margin;
+            // FIXED: Use >= and <= (inclusive) instead of > and < (exclusive)
+            // This ensures points ON the boundary are also considered colliding
+            if (point.x >= minX &&
+                point.x <= maxX &&
+                point.y >= minY &&
+                point.y <= maxY) {
+                return true;
+            }
+        }
+        return false;
+    }
+    /**
+     * Check if any segment of the path intersects with obstacles
+     * This determines if we need to use A* pathfinding
+     */
+    pathIntersectsObstacles(points, obstacles, index) {
+        if (obstacles.length === 0)
+            return false;
+        // Check each line segment of the path
+        for (let i = 1; i < points.length; i++) {
+            const p1 = points[i - 1];
+            const p2 = points[i];
+            // Wave 8 — Card 6: only obstacles whose rect can reach this segment's
+            // bounding box are candidates; the exact test below is unchanged, so the
+            // answer is unchanged. (A segment can only meet a rect inside the
+            // segment's own bbox, so the narrowing loses nothing.)
+            const candidates = index
+                ? index.queryBox(Math.min(p1.x, p2.x), Math.min(p1.y, p2.y), Math.max(p1.x, p2.x), Math.max(p1.y, p2.y))
+                : obstacles;
+            // Check if this segment intersects any obstacle
+            for (const obstacle of candidates) {
+                const rect = {
+                    x: obstacle.x,
+                    y: obstacle.y,
+                    width: obstacle.width,
+                    height: obstacle.height
+                };
+                if (this.lineIntersectsRectangle(p1, p2, rect)) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+    /**
+     * Check if a line segment intersects with a rectangle
+     */
+    lineIntersectsRectangle(p1, p2, rect) {
+        const left = rect.x;
+        const right = rect.x + rect.width;
+        const top = rect.y;
+        const bottom = rect.y + rect.height;
+        // Check if either endpoint is inside the rectangle
+        if (this.pointInRectangle(p1, rect) || this.pointInRectangle(p2, rect)) {
+            return true;
+        }
+        // Check intersection with each edge of the rectangle
+        const edges = [
+            { x1: left, y1: top, x2: right, y2: top }, // top edge
+            { x1: right, y1: top, x2: right, y2: bottom }, // right edge
+            { x1: left, y1: bottom, x2: right, y2: bottom }, // bottom edge
+            { x1: left, y1: top, x2: left, y2: bottom }, // left edge
+        ];
+        for (const edge of edges) {
+            if (this.lineSegmentsIntersect(p1, p2, { x: edge.x1, y: edge.y1 }, { x: edge.x2, y: edge.y2 })) {
+                return true;
+            }
+        }
+        return false;
+    }
+    /**
+     * Check if a point is inside a rectangle
+     */
+    pointInRectangle(p, rect) {
+        return (p.x >= rect.x &&
+            p.x <= rect.x + rect.width &&
+            p.y >= rect.y &&
+            p.y <= rect.y + rect.height);
+    }
+    /**
+     * Check if two line segments intersect
+     * Using the cross product method
+     */
+    lineSegmentsIntersect(p1, p2, p3, p4) {
+        const ccw = (a, b, c) => {
+            return (c.y - a.y) * (b.x - a.x) > (b.y - a.y) * (c.x - a.x);
+        };
+        return ccw(p1, p3, p4) !== ccw(p2, p3, p4) && ccw(p1, p2, p3) !== ccw(p1, p2, p4);
+    }
+    /**
+     * Snap point to grid
+     */
+    snapToGrid(point, gridSize) {
+        return {
+            x: Math.round(point.x / gridSize) * gridSize,
+            y: Math.round(point.y / gridSize) * gridSize,
+        };
+    }
+    /**
+     * Find nearest valid point outside obstacles
+     * Searches outward from point in the given direction until finding a valid position
+     */
+    findNearestValidPoint(point, direction, obstacles, margin, gridSize, index) {
+        // Try moving outward in the port direction to find a valid point
+        const maxAttempts = 10;
+        let current = Object.assign({}, point);
+        for (let i = 1; i <= maxAttempts; i++) {
+            // Move one grid step in the port direction
+            switch (direction) {
+                case 'left':
+                    current.x -= gridSize;
+                    break;
+                case 'right':
+                    current.x += gridSize;
+                    break;
+                case 'top':
+                    current.y -= gridSize;
+                    break;
+                case 'bottom':
+                    current.y += gridSize;
+                    break;
+                default:
+                    // No direction specified, try moving in all directions
+                    const candidates = [
+                        { x: point.x + i * gridSize, y: point.y },
+                        { x: point.x - i * gridSize, y: point.y },
+                        { x: point.x, y: point.y + i * gridSize },
+                        { x: point.x, y: point.y - i * gridSize },
+                    ];
+                    for (const candidate of candidates) {
+                        if (!this.collidesWithObstacles(candidate, obstacles, margin, index)) {
+                            return candidate;
+                        }
+                    }
+                    continue;
+            }
+            // Check if this position is valid
+            if (!this.collidesWithObstacles(current, obstacles, margin, index)) {
+                return current;
+            }
+        }
+        // If all attempts failed, return original point (pathfinding will fail, but at least we tried)
+        console.debug(`   ✗ Could not find valid point after ${maxAttempts} attempts, using original`);
+        return point;
+    }
+    /**
+     * Convert point to map key
+     */
+    pointToKey(point) {
+        return `${point.x},${point.y}`;
+    }
+    /**
+     * Convert map key to point
+     */
+    keyToPoint(key) {
+        const [x, y] = key.split(',').map(Number);
+        return { x, y };
+    }
+    /**
+     * Calculate total path length
+     */
+    calculatePathLength(points) {
+        let length = 0;
+        for (let i = 0; i < points.length - 1; i++) {
+            const dx = points[i + 1].x - points[i].x;
+            const dy = points[i + 1].y - points[i].y;
+            length += Math.sqrt(dx * dx + dy * dy);
+        }
+        return length;
+    }
+    /**
+     * Count bends in path
+     */
+    countBends(points) {
+        if (points.length < 3)
+            return 0;
+        let bends = 0;
+        for (let i = 1; i < points.length - 1; i++) {
+            const prev = points[i - 1];
+            const curr = points[i];
+            const next = points[i + 1];
+            // Check if direction changed
+            const dir1 = this.getDirection(prev, curr);
+            const dir2 = this.getDirection(curr, next);
+            if (dir1 !== dir2) {
+                bends++;
+            }
+        }
+        return bends;
+    }
+    /**
+     * Get direction between two points ('h' or 'v')
+     */
+    getDirection(a, b) {
+        return Math.abs(b.x - a.x) > Math.abs(b.y - a.y) ? 'h' : 'v';
+    }
+    /**
+     * Remove duplicate consecutive points
+     */
+    removeDuplicatePoints(points) {
+        const result = [];
+        for (let i = 0; i < points.length; i++) {
+            if (i === 0 || points[i].x !== points[i - 1].x || points[i].y !== points[i - 1].y) {
+                result.push(Object.assign({}, points[i]));
+            }
+        }
+        return result;
+    }
+    /**
+     * Calculate segments from points
+     */
+    calculateSegments(points) {
+        const segments = [];
+        for (let i = 0; i < points.length - 1; i++) {
+            const start = points[i];
+            const end = points[i + 1];
+            const dx = end.x - start.x;
+            const dy = end.y - start.y;
+            const length = Math.sqrt(dx * dx + dy * dy);
+            const angle = (Math.atan2(dy, dx) * 180) / Math.PI;
+            segments.push({
+                start: Object.assign({}, start),
+                end: Object.assign({}, end),
+                length,
+                angle,
+            });
+        }
+        return segments;
+    }
+}
+exports.OrthogonalRouter = OrthogonalRouter;
+/**
+ * Wave 8 — Card 6: indexes memoised on the obstacle ARRAY's identity, so the
+ * whole frame's links share one index instead of rebuilding it per link.
+ * Weak, so an obstacle set dies with the frame that made it.
+ */
+OrthogonalRouter.indexCache = new WeakMap();
+//# sourceMappingURL=OrthogonalRouter.js.map