@grafloria/element 0.3.18 → 0.3.20

package/src/libs/engine/src/routing/ObstacleIndex.js

@@ -0,0 +1,215 @@
+"use strict";
+// Wave 8 (Performance & scale) — Card 6: the obstacle set, indexed.
+//
+// THE MEASURED PROBLEM. Every obstacle predicate in the routers was a LINEAR
+// SCAN of the whole obstacle array:
+//
+//   collidesWithObstacles(point) → for (const o of obstacles) { ...aabb test... }
+//
+// and A* calls it once per neighbour of every cell it expands. Profiling one
+// node-drag frame on the 5k-node benchmark scene counted
+//
+//   187,488 collision calls  ×  ~9,998 obstacles each  =  1.87 BILLION aabb tests
+//
+// in a SINGLE frame — 88% of a 2.2-second frame, all of it inside
+// `collidesWithObstacles`. The routing was never the expensive part; scanning
+// the scene to ask "is this one cell free?" was.
+//
+// This is a uniform grid hash over the obstacle rects. A point query looks at
+// only the cells the query square touches, so the cost is proportional to the
+// obstacles NEAR the query, not to the scene.
+//
+// PREDICATE PARITY IS THE WHOLE CONTRACT. This index does not approximate: it
+// narrows the candidate set and then runs the SAME exact test the linear scan
+// ran, including its inclusive (>=/<=) bounds. A point is in the candidate set
+// iff its margin-expanded query square shares a grid cell with the obstacle's
+// raw rect — and if the square and the rect intersect at all (even by a single
+// boundary point, which the inclusive test counts as a hit) that intersection
+// lies in some cell that both are registered in. So the candidate set is a
+// SUPERSET of the true hits, and the exact test culls the rest: same answer,
+// every time. That is what lets it drop under the 225-assertion line harness
+// without moving a single pixel.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ObstacleIndex = void 0;
+exports.mergeObstacles = mergeObstacles;
+/** World units per cell. Nodes are ~140×70, so this holds a handful each. */
+const DEFAULT_CELL_SIZE = 128;
+/**
+ * An obstacle that spans more than this many cells is not worth exploding into
+ * the grid (a diagram-sized collapsed group block would own every cell). It
+ * goes in a small "oversized" list that every query checks directly — which is
+ * fine, because there are never many of them.
+ */
+const MAX_CELLS_PER_OBSTACLE = 1024;
+/** Cell coordinates beyond this fall back to the oversized list (keeps the packed key exact). */
+const MAX_CELL_COORD = 1 << 20;
+class ObstacleIndex {
+    constructor(obstacles, cellSize = DEFAULT_CELL_SIZE) {
+        this.cells = new Map();
+        this.oversized = [];
+        this.cellSize = cellSize;
+        let n = 0;
+        for (const o of obstacles) {
+            if (!o)
+                continue;
+            n++;
+            this.insert(o);
+        }
+        this.count = n;
+    }
+    /** How many obstacles were indexed. */
+    get size() {
+        return this.count;
+    }
+    insert(o) {
+        const c = this.cellSize;
+        const minCx = Math.floor(o.x / c);
+        const maxCx = Math.floor((o.x + o.width) / c);
+        const minCy = Math.floor(o.y / c);
+        const maxCy = Math.floor((o.y + o.height) / c);
+        const spans = (maxCx - minCx + 1) * (maxCy - minCy + 1);
+        if (!Number.isFinite(spans) ||
+            spans > MAX_CELLS_PER_OBSTACLE ||
+            Math.abs(minCx) >= MAX_CELL_COORD ||
+            Math.abs(maxCx) >= MAX_CELL_COORD ||
+            Math.abs(minCy) >= MAX_CELL_COORD ||
+            Math.abs(maxCy) >= MAX_CELL_COORD) {
+            this.oversized.push(o);
+            return;
+        }
+        for (let cx = minCx; cx <= maxCx; cx++) {
+            for (let cy = minCy; cy <= maxCy; cy++) {
+                const key = ObstacleIndex.key(cx, cy);
+                const bucket = this.cells.get(key);
+                if (bucket)
+                    bucket.push(o);
+                else
+                    this.cells.set(key, [o]);
+            }
+        }
+    }
+    /** Exact, collision-free packing of two cell coords into one number (|coord| < 2^20). */
+    static key(cx, cy) {
+        return cx * 2097152 + (cy + 1048576);
+    }
+    /**
+     * Does the point, expanded by `margin`, touch any obstacle?
+     *
+     * Byte-for-byte the predicate `OrthogonalRouter.collidesWithObstacles` used to
+     * evaluate against the whole array — inclusive bounds and all.
+     */
+    collides(px, py, margin) {
+        for (const o of this.oversized) {
+            if (ObstacleIndex.hit(o, px, py, margin))
+                return true;
+        }
+        if (this.cells.size === 0)
+            return false;
+        const c = this.cellSize;
+        const minCx = Math.floor((px - margin) / c);
+        const maxCx = Math.floor((px + margin) / c);
+        const minCy = Math.floor((py - margin) / c);
+        const maxCy = Math.floor((py + margin) / c);
+        for (let cx = minCx; cx <= maxCx; cx++) {
+            for (let cy = minCy; cy <= maxCy; cy++) {
+                const bucket = this.cells.get(ObstacleIndex.key(cx, cy));
+                if (!bucket)
+                    continue;
+                for (const o of bucket) {
+                    if (ObstacleIndex.hit(o, px, py, margin))
+                        return true;
+                }
+            }
+        }
+        return false;
+    }
+    static hit(o, px, py, margin) {
+        return (px >= o.x - margin &&
+            px <= o.x + o.width + margin &&
+            py >= o.y - margin &&
+            py <= o.y + o.height + margin);
+    }
+    /**
+     * Every obstacle whose rect could overlap the axis-aligned box — the candidate
+     * set for a segment test. Conservative (a superset); the caller runs the exact
+     * geometry test on what comes back.
+     */
+    queryBox(minX, minY, maxX, maxY) {
+        const out = [];
+        const seen = this.oversized.length > 0 || this.cells.size > 0 ? new Set() : null;
+        if (!seen)
+            return out;
+        for (const o of this.oversized) {
+            if (o.x <= maxX && o.x + o.width >= minX && o.y <= maxY && o.y + o.height >= minY) {
+                seen.add(o);
+                out.push(o);
+            }
+        }
+        const c = this.cellSize;
+        const minCx = Math.floor(minX / c);
+        const maxCx = Math.floor(maxX / c);
+        const minCy = Math.floor(minY / c);
+        const maxCy = Math.floor(maxY / c);
+        // A pathological box (an infinite/NaN coordinate) would spin here; bail to
+        // the linear answer instead of hanging the frame.
+        if (!Number.isFinite(minCx) || !Number.isFinite(maxCx) || !Number.isFinite(minCy) || !Number.isFinite(maxCy)) {
+            return this.all();
+        }
+        for (let cx = minCx; cx <= maxCx; cx++) {
+            for (let cy = minCy; cy <= maxCy; cy++) {
+                const bucket = this.cells.get(ObstacleIndex.key(cx, cy));
+                if (!bucket)
+                    continue;
+                for (const o of bucket) {
+                    if (seen.has(o))
+                        continue;
+                    seen.add(o);
+                    out.push(o);
+                }
+            }
+        }
+        return out;
+    }
+    /** Every indexed obstacle (deduplicated). Escape hatch for degenerate queries. */
+    all() {
+        const seen = new Set(this.oversized);
+        for (const bucket of this.cells.values())
+            for (const o of bucket)
+                seen.add(o);
+        return [...seen];
+    }
+}
+exports.ObstacleIndex = ObstacleIndex;
+/**
+ * Merge two obstacle sources into one array, collapsing entries that are the
+ * SAME obstacle described twice.
+ *
+ * This exists because `RoutingEngine.route()` unions its global ObstacleMap with
+ * the request's obstacles, and the renderer's request repeats what the engine
+ * already registered — so a 5,000-node diagram was handing the router a
+ * 9,998-entry obstacle array, and every one of those entries was scanned on
+ * every collision test. Deduplication is keyed on id AND geometry, so two
+ * entries that genuinely disagree about where an obstacle is are both kept:
+ * the effective blocked region is unchanged.
+ */
+function mergeObstacles(a, b) {
+    if (a.length === 0)
+        return b;
+    if (b.length === 0)
+        return a;
+    const out = [];
+    const seen = new Set();
+    for (const src of [a, b]) {
+        for (const o of src) {
+            if (!o)
+                continue;
+            const k = `${o.id}|${o.x}|${o.y}|${o.width}|${o.height}`;
+            if (seen.has(k))
+                continue;
+            seen.add(k);
+            out.push(o);
+        }
+    }
+    return out;
+}
+//# sourceMappingURL=ObstacleIndex.js.map

package/src/libs/engine/src/routing/ObstacleMap.d.ts

@@ -0,0 +1,68 @@
+import type { Obstacle, Rectangle } from './types';
+import type { Point } from '../types';
+/**
+ * ObstacleMap manages spatial indexing of obstacles for efficient queries
+ * Uses a simple grid-based spatial index for O(1) lookups
+ */
+export declare class ObstacleMap {
+    private obstacles;
+    private gridCellSize;
+    private spatialGrid;
+    /**
+     * Get number of obstacles in the map
+     */
+    size(): number;
+    /**
+     * Add an obstacle to the map
+     */
+    add(obstacle: Obstacle): void;
+    /**
+     * Remove an obstacle from the map
+     */
+    remove(id: string): boolean;
+    /**
+     * Get an obstacle by ID
+     */
+    get(id: string): Obstacle | undefined;
+    /**
+     * Update an obstacle (remove and re-add to update spatial index)
+     */
+    update(obstacle: Obstacle): void;
+    /**
+     * Clear all obstacles
+     */
+    clear(): void;
+    /**
+     * Query obstacles in a rectangular region
+     */
+    queryRegion(region: Rectangle): Obstacle[];
+    /**
+     * Query obstacles near a point within a given radius
+     */
+    queryNearPoint(point: Point, radius: number): Obstacle[];
+    /**
+     * Query obstacles along a line segment
+     */
+    queryLine(start: Point, end: Point): Obstacle[];
+    /**
+     * Get all obstacles as an array (Phase 1.6b)
+     */
+    getObstacles(): Obstacle[];
+    /**
+     * Check if a point is inside any obstacle
+     */
+    isPointInside(point: Point, respectMargin?: boolean): boolean;
+    /**
+     * Check if a line segment intersects any obstacle
+     */
+    doesLineIntersect(start: Point, end: Point, margin?: number): boolean;
+    private addToSpatialGrid;
+    private removeFromSpatialGrid;
+    private getOverlappingCells;
+    private rectanglesOverlap;
+    private pointInRectangle;
+    private lineIntersectsRectangle;
+    private lineSegmentsIntersect;
+    private getObstacleCenter;
+    private distance;
+}

package/src/libs/engine/src/routing/ObstacleMap.js

@@ -0,0 +1,312 @@
+"use strict";
+// ObstacleMap - Spatial indexing for efficient obstacle queries
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ObstacleMap = void 0;
+/**
+ * ObstacleMap manages spatial indexing of obstacles for efficient queries
+ * Uses a simple grid-based spatial index for O(1) lookups
+ */
+class ObstacleMap {
+    constructor() {
+        this.obstacles = new Map();
+        this.gridCellSize = 100; // Grid cell size for spatial indexing
+        this.spatialGrid = new Map();
+    }
+    /**
+     * Get number of obstacles in the map
+     */
+    size() {
+        return this.obstacles.size;
+    }
+    /**
+     * Add an obstacle to the map
+     */
+    add(obstacle) {
+        this.obstacles.set(obstacle.id, obstacle);
+        this.addToSpatialGrid(obstacle);
+    }
+    /**
+     * Remove an obstacle from the map
+     */
+    remove(id) {
+        const obstacle = this.obstacles.get(id);
+        if (!obstacle) {
+            return false;
+        }
+        this.removeFromSpatialGrid(obstacle);
+        return this.obstacles.delete(id);
+    }
+    /**
+     * Get an obstacle by ID
+     */
+    get(id) {
+        return this.obstacles.get(id);
+    }
+    /**
+     * Update an obstacle (remove and re-add to update spatial index)
+     */
+    update(obstacle) {
+        this.remove(obstacle.id);
+        this.add(obstacle);
+    }
+    /**
+     * Clear all obstacles
+     */
+    clear() {
+        this.obstacles.clear();
+        this.spatialGrid.clear();
+    }
+    /**
+     * Query obstacles in a rectangular region
+     */
+    queryRegion(region) {
+        const result = [];
+        const seen = new Set();
+        // Get all grid cells that overlap the region
+        const cells = this.getOverlappingCells(region);
+        for (const cellKey of cells) {
+            const obstacleIds = this.spatialGrid.get(cellKey);
+            if (!obstacleIds)
+                continue;
+            for (const id of obstacleIds) {
+                if (seen.has(id))
+                    continue;
+                seen.add(id);
+                const obstacle = this.obstacles.get(id);
+                if (obstacle && this.rectanglesOverlap(region, obstacle)) {
+                    result.push(obstacle);
+                }
+            }
+        }
+        return result;
+    }
+    /**
+     * Query obstacles near a point within a given radius
+     */
+    queryNearPoint(point, radius) {
+        const region = {
+            x: point.x - radius,
+            y: point.y - radius,
+            width: radius * 2,
+            height: radius * 2,
+        };
+        return this.queryRegion(region).filter((obstacle) => {
+            const center = this.getObstacleCenter(obstacle);
+            const distance = this.distance(point, center);
+            return distance <= radius;
+        });
+    }
+    /**
+     * Query obstacles along a line segment
+     */
+    queryLine(start, end) {
+        // Create bounding box for the line
+        const minX = Math.min(start.x, end.x);
+        const minY = Math.min(start.y, end.y);
+        const maxX = Math.max(start.x, end.x);
+        const maxY = Math.max(start.y, end.y);
+        const region = {
+            x: minX,
+            y: minY,
+            width: maxX - minX,
+            height: maxY - minY,
+        };
+        // Get obstacles in bounding box, then filter by line intersection
+        return this.queryRegion(region).filter((obstacle) => {
+            return this.lineIntersectsRectangle(start, end, obstacle);
+        });
+    }
+    /**
+     * Get all obstacles as an array (Phase 1.6b)
+     */
+    getObstacles() {
+        return Array.from(this.obstacles.values());
+    }
+    /**
+     * Check if a point is inside any obstacle
+     */
+    isPointInside(point, respectMargin = false) {
+        var _a;
+        // When respecting margins, we need to query a larger region
+        // to find obstacles whose margins might contain this point
+        const maxMargin = respectMargin ? 100 : 1; // Assume max margin of 100px
+        const nearby = this.queryRegion({
+            x: point.x - maxMargin,
+            y: point.y - maxMargin,
+            width: maxMargin * 2,
+            height: maxMargin * 2,
+        });
+        for (const obstacle of nearby) {
+            const margin = respectMargin ? ((_a = obstacle.margin) !== null && _a !== void 0 ? _a : 0) : 0;
+            const expanded = {
+                x: obstacle.x - margin,
+                y: obstacle.y - margin,
+                width: obstacle.width + margin * 2,
+                height: obstacle.height + margin * 2,
+            };
+            if (this.pointInRectangle(point, expanded)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    /**
+     * Check if a line segment intersects any obstacle
+     */
+    doesLineIntersect(start, end, margin = 0) {
+        // Expand query region by margin to catch nearby obstacles
+        const minX = Math.min(start.x, end.x) - margin;
+        const minY = Math.min(start.y, end.y) - margin;
+        const maxX = Math.max(start.x, end.x) + margin;
+        const maxY = Math.max(start.y, end.y) + margin;
+        const expandedRegion = {
+            x: minX,
+            y: minY,
+            width: maxX - minX,
+            height: maxY - minY,
+        };
+        // Query obstacles in expanded region
+        const obstacles = this.queryRegion(expandedRegion);
+        for (const obstacle of obstacles) {
+            const expanded = {
+                x: obstacle.x - margin,
+                y: obstacle.y - margin,
+                width: obstacle.width + margin * 2,
+                height: obstacle.height + margin * 2,
+            };
+            if (this.lineIntersectsRectangle(start, end, expanded)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    // ========================================
+    // Private Helper Methods
+    // ========================================
+    addToSpatialGrid(obstacle) {
+        const cells = this.getOverlappingCells(obstacle);
+        for (const cellKey of cells) {
+            if (!this.spatialGrid.has(cellKey)) {
+                this.spatialGrid.set(cellKey, new Set());
+            }
+            this.spatialGrid.get(cellKey).add(obstacle.id);
+        }
+    }
+    removeFromSpatialGrid(obstacle) {
+        const cells = this.getOverlappingCells(obstacle);
+        for (const cellKey of cells) {
+            const cell = this.spatialGrid.get(cellKey);
+            if (cell) {
+                cell.delete(obstacle.id);
+                if (cell.size === 0) {
+                    this.spatialGrid.delete(cellKey);
+                }
+            }
+        }
+    }
+    getOverlappingCells(rect) {
+        const cells = [];
+        const minCellX = Math.floor(rect.x / this.gridCellSize);
+        const minCellY = Math.floor(rect.y / this.gridCellSize);
+        const maxCellX = Math.floor((rect.x + rect.width) / this.gridCellSize);
+        const maxCellY = Math.floor((rect.y + rect.height) / this.gridCellSize);
+        for (let x = minCellX; x <= maxCellX; x++) {
+            for (let y = minCellY; y <= maxCellY; y++) {
+                cells.push(`${x},${y}`);
+            }
+        }
+        return cells;
+    }
+    rectanglesOverlap(a, b) {
+        return !(a.x + a.width < b.x ||
+            b.x + b.width < a.x ||
+            a.y + a.height < b.y ||
+            b.y + b.height < a.y);
+    }
+    pointInRectangle(point, rect) {
+        return (point.x >= rect.x &&
+            point.x <= rect.x + rect.width &&
+            point.y >= rect.y &&
+            point.y <= rect.y + rect.height);
+    }
+    lineIntersectsRectangle(start, end, rect) {
+        // Check if either endpoint is inside the rectangle
+        if (this.pointInRectangle(start, rect) || this.pointInRectangle(end, rect)) {
+            return true;
+        }
+        // Check if line's bounding box overlaps with rectangle
+        const lineMinX = Math.min(start.x, end.x);
+        const lineMaxX = Math.max(start.x, end.x);
+        const lineMinY = Math.min(start.y, end.y);
+        const lineMaxY = Math.max(start.y, end.y);
+        const rectMinX = rect.x;
+        const rectMaxX = rect.x + rect.width;
+        const rectMinY = rect.y;
+        const rectMaxY = rect.y + rect.height;
+        // No overlap if bounding boxes don't intersect
+        if (lineMaxX < rectMinX || lineMinX > rectMaxX ||
+            lineMaxY < rectMinY || lineMinY > rectMaxY) {
+            return false;
+        }
+        // Check if line intersects any of the four edges
+        const corners = [
+            { x: rect.x, y: rect.y },
+            { x: rect.x + rect.width, y: rect.y },
+            { x: rect.x + rect.width, y: rect.y + rect.height },
+            { x: rect.x, y: rect.y + rect.height },
+        ];
+        for (let i = 0; i < 4; i++) {
+            const c1 = corners[i];
+            const c2 = corners[(i + 1) % 4];
+            if (this.lineSegmentsIntersect(start, end, c1, c2)) {
+                return true;
+            }
+        }
+        // If bounding boxes overlap but no edge intersections found, assume no collision
+        return false;
+    }
+    lineSegmentsIntersect(a1, a2, b1, b2) {
+        const ccw = (A, B, C) => {
+            return (C.y - A.y) * (B.x - A.x) - (B.y - A.y) * (C.x - A.x);
+        };
+        const d1 = ccw(b1, b2, a1);
+        const d2 = ccw(b1, b2, a2);
+        const d3 = ccw(a1, a2, b1);
+        const d4 = ccw(a1, a2, b2);
+        // Standard intersection check
+        if (((d1 > 0 && d2 < 0) || (d1 < 0 && d2 > 0)) &&
+            ((d3 > 0 && d4 < 0) || (d3 < 0 && d4 > 0))) {
+            return true;
+        }
+        // Check for colinear overlapping segments
+        if (d1 === 0 && d2 === 0 && d3 === 0 && d4 === 0) {
+            // Segments are colinear, check if they overlap
+            const overlap1D = (min1, max1, min2, max2) => {
+                return Math.max(min1, min2) <= Math.min(max1, max2);
+            };
+            const a1x = Math.min(a1.x, a2.x);
+            const a2x = Math.max(a1.x, a2.x);
+            const a1y = Math.min(a1.y, a2.y);
+            const a2y = Math.max(a1.y, a2.y);
+            const b1x = Math.min(b1.x, b2.x);
+            const b2x = Math.max(b1.x, b2.x);
+            const b1y = Math.min(b1.y, b2.y);
+            const b2y = Math.max(b1.y, b2.y);
+            return overlap1D(a1x, a2x, b1x, b2x) && overlap1D(a1y, a2y, b1y, b2y);
+        }
+        return false;
+    }
+    getObstacleCenter(obstacle) {
+        return {
+            x: obstacle.x + obstacle.width / 2,
+            y: obstacle.y + obstacle.height / 2,
+        };
+    }
+    distance(a, b) {
+        const dx = b.x - a.x;
+        const dy = b.y - a.y;
+        return Math.sqrt(dx * dx + dy * dy);
+    }
+}
+exports.ObstacleMap = ObstacleMap;
+//# sourceMappingURL=ObstacleMap.js.map

package/src/libs/engine/src/routing/ObstacleMapBuilder.d.ts

@@ -0,0 +1,28 @@
+import type { DiagramModel } from '../models/DiagramModel';
+import { ObstacleMap } from './ObstacleMap';
+export interface ObstacleMapOptions {
+    /** Margin to add around each obstacle */
+    margin?: number;
+}
+/**
+ * ObstacleMapBuilder creates ObstacleMap from DiagramModel
+ * Uses global bounds to account for transforms and hierarchy
+ */
+export declare class ObstacleMapBuilder {
+    /**
+     * Build obstacle map from all nodes in diagram (Phase 1.6b)
+     * @param diagram The diagram model
+     * @param options Options for obstacle creation
+     * @returns ObstacleMap containing all diagram nodes as obstacles
+     */
+    static fromDiagram(diagram: DiagramModel, options?: ObstacleMapOptions): ObstacleMap;
+    /**
+     * Build obstacle map excluding specific nodes (Phase 1.6b)
+     * Useful for routing where source/target nodes should not be obstacles
+     * @param diagram The diagram model
+     * @param excludeIds Node IDs to exclude from obstacles
+     * @param options Options for obstacle creation
+     * @returns ObstacleMap containing diagram nodes except excluded ones
+     */
+    static fromDiagramExcluding(diagram: DiagramModel, excludeIds: string[], options?: ObstacleMapOptions): ObstacleMap;
+}

package/src/libs/engine/src/routing/ObstacleMapBuilder.js

@@ -0,0 +1,76 @@
+"use strict";
+// ObstacleMapBuilder - Builds ObstacleMap from DiagramModel (Phase 1.6b)
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ObstacleMapBuilder = void 0;
+const ObstacleMap_1 = require("./ObstacleMap");
+/**
+ * ObstacleMapBuilder creates ObstacleMap from DiagramModel
+ * Uses global bounds to account for transforms and hierarchy
+ */
+class ObstacleMapBuilder {
+    /**
+     * Build obstacle map from all nodes in diagram (Phase 1.6b)
+     * @param diagram The diagram model
+     * @param options Options for obstacle creation
+     * @returns ObstacleMap containing all diagram nodes as obstacles
+     */
+    static fromDiagram(diagram, options = {}) {
+        var _a;
+        const map = new ObstacleMap_1.ObstacleMap();
+        const margin = (_a = options.margin) !== null && _a !== void 0 ? _a : 0;
+        for (const node of diagram.getNodes()) {
+            // Skip if explicitly marked as non-obstacle
+            if (node.getData('isObstacle') === false) {
+                continue;
+            }
+            // Use global bounds (accounts for transforms and hierarchy)
+            const bounds = node.getGlobalBounds();
+            const obstacle = {
+                id: node.id,
+                x: bounds.left - margin,
+                y: bounds.top - margin,
+                width: bounds.width + margin * 2,
+                height: bounds.height + margin * 2,
+            };
+            map.add(obstacle);
+        }
+        return map;
+    }
+    /**
+     * Build obstacle map excluding specific nodes (Phase 1.6b)
+     * Useful for routing where source/target nodes should not be obstacles
+     * @param diagram The diagram model
+     * @param excludeIds Node IDs to exclude from obstacles
+     * @param options Options for obstacle creation
+     * @returns ObstacleMap containing diagram nodes except excluded ones
+     */
+    static fromDiagramExcluding(diagram, excludeIds, options = {}) {
+        var _a;
+        const map = new ObstacleMap_1.ObstacleMap();
+        const margin = (_a = options.margin) !== null && _a !== void 0 ? _a : 0;
+        const excludeSet = new Set(excludeIds);
+        for (const node of diagram.getNodes()) {
+            // Skip excluded nodes
+            if (excludeSet.has(node.id)) {
+                continue;
+            }
+            // Skip if explicitly marked as non-obstacle
+            if (node.getData('isObstacle') === false) {
+                continue;
+            }
+            // Use global bounds (accounts for transforms and hierarchy)
+            const bounds = node.getGlobalBounds();
+            const obstacle = {
+                id: node.id,
+                x: bounds.left - margin,
+                y: bounds.top - margin,
+                width: bounds.width + margin * 2,
+                height: bounds.height + margin * 2,
+            };
+            map.add(obstacle);
+        }
+        return map;
+    }
+}
+exports.ObstacleMapBuilder = ObstacleMapBuilder;
+//# sourceMappingURL=ObstacleMapBuilder.js.map