@grafloria/element 0.3.20 → 0.3.22

package/src/libs/engine/src/routing/global/GlobalRouteSolver.js

@@ -1,334 +0,0 @@
-"use strict";
-// Wave 5 (Edge routing) — Card 7: a global penalty-based solver.
-//
-// Everything before this card routes edges ONE AT A TIME: each edge sees nodes
-// as obstacles but not the other edges, so shared corridors, crossings and
-// congestion are patched afterwards (fan-out, nudging, jumps). A
-// libavoid/Adaptagrams-class solver inverts that: ALL edges route against one
-// shared penalty model, so an edge pays for crossing another edge or crowding a
-// corridor at ROUTING time and picks a different channel by itself.
-//
-// The model, deliberately small:
-//   - per-edge geometry: ManhattanRouter (jetty, U-turn ban, turn cost) with
-//     its obstacle set = the diagram's obstacles;
-//   - plus a shared PENALTY FIELD sampled per grid cell: occupancy laid down by
-//     every OTHER edge's current route (congestion), with crossings priced via
-//     perpendicular-occupancy (a horizontal step through a cell some other
-//     edge crossed vertically is what a crossing IS on a grid);
-//   - passes: edges route in deterministic order, each pass re-routing against
-//     the field the previous pass produced; the field converges quickly (2
-//     passes default) because the penalties are additive and static within a
-//     pass.
-//
-// INCREMENTAL: the solver keeps each edge's last route and the field; a change
-// re-routes only the changed edges plus the edges whose routes touch the cells
-// the change dirtied — the same dirty-set discipline the edge optimizer uses.
-//
-// The solver is PURE and synchronous — no DOM, no Date.now, no randomness —
-// which is what lets the worker host (see solver-host.ts) run the identical
-// code on either side of a postMessage boundary and lets tests prove
-// determinism by simple re-runs.
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.GlobalRouteSolver = void 0;
-const ManhattanRouter_1 = require("../algorithms/ManhattanRouter");
-const DEFAULTS = {
-    gridSize: 20,
-    obstacleMargin: 10,
-    congestionPenalty: 30,
-    crossingPenalty: 60,
-    passes: 2,
-    maxIterations: 20000,
-    bendCost: 10,
-};
-/** cell key for a world point on the solver grid */
-function cellKey(x, y, step) {
-    return `${Math.round(x / step)},${Math.round(y / step)}`;
-}
-class GlobalRouteSolver {
-    constructor(options = {}) {
-        this.router = new ManhattanRouter_1.ManhattanRouter();
-        // last solution + the field it produced
-        this.routes = new Map();
-        this.edges = new Map();
-        this.obstacles = [];
-        /** cell → per-axis occupancy laid down by each edge: id → 'h' | 'v' */
-        this.field = new Map();
-        this._stats = { edgesRouted: 0, edgesReused: 0 };
-        this.options = Object.assign(Object.assign({}, DEFAULTS), options);
-    }
-    get stats() {
-        return this._stats;
-    }
-    /** Full solve. Deterministic: edges route in id order, every pass. */
-    solve(edges, obstacles) {
-        this.edges = new Map(edges.map((e) => [e.id, e]));
-        this.obstacles = obstacles;
-        this.routes.clear();
-        this.field.clear();
-        this._stats = { edgesRouted: 0, edgesReused: 0 };
-        const order = [...edges].sort((a, b) => (a.id < b.id ? -1 : 1));
-        for (let pass = 0; pass < this.options.passes; pass++) {
-            for (const edge of order) {
-                this.routeEdge(edge);
-            }
-        }
-        return new Map(this.routes);
-    }
-    /**
-     * Re-solve after a change: `changed` edges re-route (removed ones pass with
-     * `removed: true`), and so does every edge whose current route touches a cell
-     * a changed edge occupied before or after. Everything else is served as-is.
-     */
-    solveIncremental(changed, obstacles) {
-        var _a, _b;
-        if (obstacles)
-            this.obstacles = obstacles;
-        this._stats = { edgesRouted: 0, edgesReused: 0 };
-        // cells dirtied by the change: old routes of changed edges
-        const dirtyCells = new Set();
-        for (const { edge } of changed) {
-            for (const [cell, byEdge] of this.field) {
-                if (byEdge.has(edge.id))
-                    dirtyCells.add(cell);
-            }
-        }
-        for (const { edge, removed } of changed) {
-            this.clearFromField(edge.id);
-            if (removed) {
-                this.routes.delete(edge.id);
-                this.edges.delete(edge.id);
-            }
-            else {
-                this.edges.set(edge.id, edge);
-            }
-        }
-        // route the changed (surviving) edges — collecting the cells they now hold
-        const toRoute = changed.filter((c) => !c.removed).map((c) => c.edge);
-        for (const edge of [...toRoute].sort((a, b) => (a.id < b.id ? -1 : 1))) {
-            this.routeEdge(edge);
-            for (const [cell, byEdge] of this.field) {
-                if (byEdge.has(edge.id))
-                    dirtyCells.add(cell);
-            }
-        }
-        // neighbourhood: edges whose route passes through any dirty cell
-        const neighbours = new Set();
-        for (const cell of dirtyCells) {
-            for (const id of (_b = (_a = this.field.get(cell)) === null || _a === void 0 ? void 0 : _a.keys()) !== null && _b !== void 0 ? _b : []) {
-                if (!changed.some((c) => c.edge.id === id))
-                    neighbours.add(id);
-            }
-        }
-        for (const id of [...neighbours].sort()) {
-            const edge = this.edges.get(id);
-            if (edge)
-                this.routeEdge(edge);
-        }
-        this._stats.edgesReused = this.edges.size - this._stats.edgesRouted;
-        return new Map(this.routes);
-    }
-    // -------------------------------------------------------------------------
-    routeEdge(edge) {
-        this.clearFromField(edge.id);
-        const step = this.options.gridSize;
-        // The penalty field enters through the ManhattanRouter's container hook? No —
-        // it needs per-cell costs, so the router is given a costFn via obstacles?
-        // Neither fits; the field is applied by wrapping the router's own search
-        // through a penalized obstacle expansion: we inflate the request with
-        // PSEUDO-obstacle costs by re-running Manhattan on a costed grid. To keep
-        // ManhattanRouter untouched (it is a shipped card), the solver runs its own
-        // copy of the same search with the extra per-cell term. See penalisedRoute.
-        const routed = this.penalisedRoute(edge, step);
-        if (!routed)
-            return;
-        this.routes.set(edge.id, routed.points);
-        this._stats.edgesRouted++;
-        // lay the route into the field
-        const pts = routed.points;
-        for (let i = 0; i < pts.length - 1; i++) {
-            const a = pts[i];
-            const b = pts[i + 1];
-            const horizontal = a.y === b.y;
-            const n = Math.max(Math.abs(b.x - a.x), Math.abs(b.y - a.y)) / step;
-            for (let k = 0; k <= n; k++) {
-                const x = a.x + (b.x - a.x) * (n === 0 ? 0 : k / n);
-                const y = a.y + (b.y - a.y) * (n === 0 ? 0 : k / n);
-                const cell = cellKey(x, y, step);
-                let byEdge = this.field.get(cell);
-                if (!byEdge) {
-                    byEdge = new Map();
-                    this.field.set(cell, byEdge);
-                }
-                byEdge.set(edge.id, horizontal ? 'h' : 'v');
-            }
-        }
-    }
-    /**
-     * Manhattan-style search with the shared penalty field added per step:
-     * congestion (any other edge in the cell) and crossing (another edge through
-     * the cell PERPENDICULAR to this step). Same moves, same U-turn ban, same
-     * jetty handling as ManhattanRouter — the field term is the only addition.
-     */
-    penalisedRoute(edge, step) {
-        var _a, _b, _c;
-        const { congestionPenalty, crossingPenalty } = this.options;
-        const self = this;
-        // Delegate the mechanical parts to ManhattanRouter by pre-charging the
-        // field into a transient obstacle-cost surface is not expressible via its
-        // public options — so the solver reuses the router for the BASE route and
-        // falls back to it when the field is empty (fast path), and otherwise runs
-        // the costed variant below.
-        const fieldEmpty = this.field.size === 0;
-        const base = () => {
-            var _a;
-            return this.router.route({
-                start: edge.start,
-                end: edge.end,
-                sourceDirection: edge.sourceDirection,
-                targetDirection: edge.targetDirection,
-                obstacles: this.obstacles,
-                options: {
-                    gridSize: step,
-                    obstacleMargin: this.options.obstacleMargin,
-                    maxIterations: this.options.maxIterations,
-                    costs: { bends: this.options.bendCost },
-                    jetty: (_a = edge.jetty) !== null && _a !== void 0 ? _a : step,
-                },
-            });
-        };
-        if (fieldEmpty)
-            return base();
-        // ---- costed grid search (the router's algorithm + the field term) -------
-        const jetty = (_a = edge.jetty) !== null && _a !== void 0 ? _a : step;
-        const DIR = {
-            left: { x: -1, y: 0 },
-            right: { x: 1, y: 0 },
-            top: { x: 0, y: -1 },
-            bottom: { x: 0, y: 1 },
-        };
-        const srcSide = (_b = edge.sourceDirection) !== null && _b !== void 0 ? _b : (Math.abs(edge.end.x - edge.start.x) >= Math.abs(edge.end.y - edge.start.y)
-            ? edge.end.x >= edge.start.x ? 'right' : 'left'
-            : edge.end.y >= edge.start.y ? 'bottom' : 'top');
-        const tgtSide = (_c = edge.targetDirection) !== null && _c !== void 0 ? _c : (Math.abs(edge.start.x - edge.end.x) >= Math.abs(edge.start.y - edge.end.y)
-            ? edge.start.x >= edge.end.x ? 'right' : 'left'
-            : edge.start.y >= edge.end.y ? 'bottom' : 'top');
-        const sv = DIR[srcSide];
-        const tv = DIR[tgtSide];
-        const sStub = { x: edge.start.x + sv.x * jetty, y: edge.start.y + sv.y * jetty };
-        const tStub = { x: edge.end.x + tv.x * jetty, y: edge.end.y + tv.y * jetty };
-        const margin = this.options.obstacleMargin;
-        const inflated = this.obstacles.map((o) => {
-            var _a, _b, _c, _d;
-            return ({
-                x: o.x - margin - ((_a = o.margin) !== null && _a !== void 0 ? _a : 0),
-                y: o.y - margin - ((_b = o.margin) !== null && _b !== void 0 ? _b : 0),
-                width: o.width + 2 * (margin + ((_c = o.margin) !== null && _c !== void 0 ? _c : 0)),
-                height: o.height + 2 * (margin + ((_d = o.margin) !== null && _d !== void 0 ? _d : 0)),
-            });
-        });
-        const blocked = (x, y) => inflated.some((o) => x >= o.x && x <= o.x + o.width && y >= o.y && y <= o.y + o.height);
-        const MOVES = [
-            { dx: 1, dy: 0, h: true },
-            { dx: 0, dy: 1, h: false },
-            { dx: -1, dy: 0, h: true },
-            { dx: 0, dy: -1, h: false },
-        ];
-        const sx = Math.round(sStub.x / step), sy = Math.round(sStub.y / step);
-        const tx = Math.round(tStub.x / step), ty = Math.round(tStub.y / step);
-        const startMove = MOVES.findIndex((m) => (srcSide === 'right' && m.dx === 1) || (srcSide === 'left' && m.dx === -1) ||
-            (srcSide === 'bottom' && m.dy === 1) || (srcSide === 'top' && m.dy === -1));
-        const h = (x, y) => (Math.abs(x - tx) + Math.abs(y - ty)) * step;
-        const open = [{ x: sx, y: sy, move: startMove, g: 0, f: h(sx, sy), parent: null }];
-        const best = new Map([[`${sx},${sy},${startMove}`, 0]]);
-        let expansions = 0;
-        const fieldCost = (x, y, moveHorizontal) => {
-            const byEdge = self.field.get(`${x},${y}`);
-            if (!byEdge)
-                return 0;
-            let cost = 0;
-            for (const [id, axis] of byEdge) {
-                if (id === edge.id)
-                    continue;
-                cost += congestionPenalty;
-                // perpendicular occupancy = a crossing on a grid
-                if ((axis === 'h') !== moveHorizontal)
-                    cost += crossingPenalty;
-            }
-            return cost;
-        };
-        while (open.length > 0) {
-            if (++expansions > this.options.maxIterations)
-                return base(); // budget: fall back, never spin
-            let bi = 0;
-            for (let i = 1; i < open.length; i++)
-                if (open[i].f < open[bi].f)
-                    bi = i;
-            const node = open.splice(bi, 1)[0];
-            if (node.x === tx && node.y === ty) {
-                const cells = [];
-                let cur = node;
-                while (cur) {
-                    cells.push({ x: cur.x * step, y: cur.y * step });
-                    cur = cur.parent;
-                }
-                cells.reverse();
-                const join = (a, b, horizFirst) => a.x === b.x || a.y === b.y ? [] : [horizFirst ? { x: b.x, y: a.y } : { x: a.x, y: b.y }];
-                const raw = [
-                    Object.assign({}, edge.start),
-                    sStub,
-                    ...join(sStub, cells[0], sv.x !== 0),
-                    ...cells,
-                    ...join(cells[cells.length - 1], tStub, true),
-                    tStub,
-                    Object.assign({}, edge.end),
-                ];
-                // dedupe + collinear merge
-                const pts = [];
-                for (const p of raw) {
-                    const last = pts[pts.length - 1];
-                    if (last && last.x === p.x && last.y === p.y)
-                        continue;
-                    while (pts.length >= 2) {
-                        const a2 = pts[pts.length - 2], b2 = pts[pts.length - 1];
-                        if ((a2.x === b2.x && b2.x === p.x) || (a2.y === b2.y && b2.y === p.y))
-                            pts.pop();
-                        else
-                            break;
-                    }
-                    pts.push(Object.assign({}, p));
-                }
-                let len = 0;
-                for (let i = 1; i < pts.length; i++)
-                    len += Math.abs(pts[i].x - pts[i - 1].x) + Math.abs(pts[i].y - pts[i - 1].y);
-                return { points: pts, totalLength: len, bendCount: Math.max(0, pts.length - 2) };
-            }
-            for (let mi = 0; mi < MOVES.length; mi++) {
-                if (node.move >= 0 && mi === (node.move + 2) % 4)
-                    continue; // no U-turns
-                const m = MOVES[mi];
-                const nx = node.x + m.dx, ny = node.y + m.dy;
-                const wx = nx * step, wy = ny * step;
-                if (!(nx === tx && ny === ty) && blocked(wx, wy))
-                    continue;
-                const turn = node.move >= 0 && mi !== node.move ? this.options.bendCost : 0;
-                const g = node.g + step + turn + fieldCost(nx, ny, m.h);
-                const key = `${nx},${ny},${mi}`;
-                const known = best.get(key);
-                if (known !== undefined && known <= g)
-                    continue;
-                best.set(key, g);
-                open.push({ x: nx, y: ny, move: mi, g, f: g + h(nx, ny), parent: node });
-            }
-        }
-        return base();
-    }
-    clearFromField(edgeId) {
-        for (const [cell, byEdge] of this.field) {
-            byEdge.delete(edgeId);
-            if (byEdge.size === 0)
-                this.field.delete(cell);
-        }
-    }
-}
-exports.GlobalRouteSolver = GlobalRouteSolver;
-//# sourceMappingURL=GlobalRouteSolver.js.map

package/src/libs/engine/src/routing/global/solver-host.d.ts

@@ -1,65 +0,0 @@
-import { type SolverEdge, type SolverOptions, type SolverStats } from './GlobalRouteSolver';
-import type { Obstacle } from '../types';
-import type { Point } from '../../types';
-export interface SolverRequestSolve {
-    seq: number;
-    kind: 'solve';
-    edges: SolverEdge[];
-    obstacles: Obstacle[];
-    options?: SolverOptions;
-}
-export interface SolverRequestIncremental {
-    seq: number;
-    kind: 'incremental';
-    changed: Array<{
-        edge: SolverEdge;
-        removed?: boolean;
-    }>;
-    obstacles?: Obstacle[];
-}
-export type SolverRequest = SolverRequestSolve | SolverRequestIncremental;
-export interface SolverResponse {
-    seq: number;
-    routes: Array<[string, Point[]]>;
-    stats: SolverStats;
-}
-/** The message port surface the host needs — a real Worker satisfies it. */
-export interface SolverPort {
-    postMessage(msg: SolverRequest): void;
-    onmessage: ((ev: {
-        data: SolverResponse;
-    }) => void) | null;
-}
-/**
- * Serve solver requests on a port. This IS the worker's message loop — call it
- * inside the worker script with `self`, or in a test with a fake port.
- */
-export declare function serveSolver(port: {
-    onmessage: ((ev: {
-        data: SolverRequest;
-    }) => void) | null;
-    postMessage(msg: SolverResponse): void;
-}): void;
-/**
- * The caller-side host. Pass a real Worker (or anything satisfying SolverPort)
- * to run remote; pass nothing to run inline on the same thread — identical
- * behaviour, no protocol drift, because BOTH paths speak through serveSolver.
- */
-export declare class SolverHost {
-    private seq;
-    private pending;
-    private readonly port;
-    constructor(port?: SolverPort);
-    solve(edges: SolverEdge[], obstacles: Obstacle[], options?: SolverOptions): Promise<{
-        routes: Map<string, Point[]>;
-        stats: SolverStats;
-    }>;
-    solveIncremental(changed: Array<{
-        edge: SolverEdge;
-        removed?: boolean;
-    }>, obstacles?: Obstacle[]): Promise<{
-        routes: Map<string, Point[]>;
-        stats: SolverStats;
-    }>;
-    private request;
-}

package/src/libs/engine/src/routing/global/solver-host.js

@@ -1,87 +0,0 @@
-"use strict";
-// Wave 5 (Edge routing) — Card 7, the worker seam.
-//
-// The solver is pure and synchronous; this host runs it EITHER inline (no
-// Worker available — jsdom, SSR, tests) or behind a postMessage boundary, with
-// one protocol and one code path for callers. The caller never knows which.
-//
-// Protocol (structured-clone-safe, no functions, no class instances):
-//   → { seq, kind: 'solve',       edges, obstacles, options }
-//   → { seq, kind: 'incremental', changed, obstacles? }
-//   ← { seq, routes: Array<[edgeId, Point[]]>, stats }
-//
-// `createSolverWorkerScript()` returns the exact onmessage body a bundler-built
-// Worker needs, so the renderer (or a server thumbnailer) can instantiate the
-// worker however its toolchain likes — new Worker(new URL(...)), a blob, or a
-// node worker_thread — and hand the port in. The host does not construct
-// Workers itself: doing so would bake ONE bundler's URL scheme into the engine.
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SolverHost = void 0;
-exports.serveSolver = serveSolver;
-const GlobalRouteSolver_1 = require("./GlobalRouteSolver");
-/**
- * Serve solver requests on a port. This IS the worker's message loop — call it
- * inside the worker script with `self`, or in a test with a fake port.
- */
-function serveSolver(port) {
-    let solver = null;
-    port.onmessage = (ev) => {
-        const req = ev.data;
-        if (req.kind === 'solve') {
-            solver = new GlobalRouteSolver_1.GlobalRouteSolver(req.options);
-            const routes = solver.solve(req.edges, req.obstacles);
-            port.postMessage({ seq: req.seq, routes: [...routes], stats: Object.assign({}, solver.stats) });
-        }
-        else {
-            if (!solver)
-                solver = new GlobalRouteSolver_1.GlobalRouteSolver();
-            const routes = solver.solveIncremental(req.changed, req.obstacles);
-            port.postMessage({ seq: req.seq, routes: [...routes], stats: Object.assign({}, solver.stats) });
-        }
-    };
-}
-/**
- * The caller-side host. Pass a real Worker (or anything satisfying SolverPort)
- * to run remote; pass nothing to run inline on the same thread — identical
- * behaviour, no protocol drift, because BOTH paths speak through serveSolver.
- */
-class SolverHost {
-    constructor(port) {
-        this.seq = 0;
-        this.pending = new Map();
-        if (port) {
-            this.port = port;
-        }
-        else {
-            // inline fallback: a loopback "port" pair served by the same loop the
-            // worker would run — the protocol is exercised even in-process.
-            const hostSide = { postMessage: () => void 0, onmessage: null };
-            const workerSide = {
-                onmessage: null,
-                postMessage: (msg) => { var _a; return (_a = hostSide.onmessage) === null || _a === void 0 ? void 0 : _a.call(hostSide, { data: msg }); },
-            };
-            serveSolver(workerSide);
-            hostSide.postMessage = (msg) => { var _a; return (_a = workerSide.onmessage) === null || _a === void 0 ? void 0 : _a.call(workerSide, { data: msg }); };
-            this.port = hostSide;
-        }
-        this.port.onmessage = (ev) => {
-            const cb = this.pending.get(ev.data.seq);
-            this.pending.delete(ev.data.seq);
-            cb === null || cb === void 0 ? void 0 : cb(ev.data);
-        };
-    }
-    solve(edges, obstacles, options) {
-        return this.request({ seq: ++this.seq, kind: 'solve', edges, obstacles, options });
-    }
-    solveIncremental(changed, obstacles) {
-        return this.request({ seq: ++this.seq, kind: 'incremental', changed, obstacles });
-    }
-    request(req) {
-        return new Promise((resolve) => {
-            this.pending.set(req.seq, (r) => resolve({ routes: new Map(r.routes), stats: r.stats }));
-            this.port.postMessage(req);
-        });
-    }
-}
-exports.SolverHost = SolverHost;
-//# sourceMappingURL=solver-host.js.map

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

@@ -1,15 +0,0 @@
-export * from './types';
-export * from './RoutingEngine';
-export * from './LiveReroutingEngine';
-export * from './ObstacleMap';
-export * from './ObstacleIndex';
-export * from './ObstacleMapBuilder';
-export * from './PathSimplifier';
-export * from './algorithms/StraightRouter';
-export * from './algorithms/OrthogonalRouter';
-export * from './algorithms/ManhattanRouter';
-export * from './global/GlobalRouteSolver';
-export * from './global/solver-host';
-export * from './algorithms/AStarRouter';
-export * from './algorithms/DijkstraRouter';
-export * from './algorithms/VisibilityGraphRouter';

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

@@ -1,20 +0,0 @@
-"use strict";
-// Routing index - exports routing system components
-Object.defineProperty(exports, "__esModule", { value: true });
-const tslib_1 = require("tslib");
-tslib_1.__exportStar(require("./types"), exports);
-tslib_1.__exportStar(require("./RoutingEngine"), exports);
-tslib_1.__exportStar(require("./LiveReroutingEngine"), exports); // Phase 0.2
-tslib_1.__exportStar(require("./ObstacleMap"), exports);
-tslib_1.__exportStar(require("./ObstacleIndex"), exports); // Wave 8 Card 6
-tslib_1.__exportStar(require("./ObstacleMapBuilder"), exports); // Phase 1.6b
-tslib_1.__exportStar(require("./PathSimplifier"), exports); // Phase 2.2
-tslib_1.__exportStar(require("./algorithms/StraightRouter"), exports);
-tslib_1.__exportStar(require("./algorithms/OrthogonalRouter"), exports);
-tslib_1.__exportStar(require("./algorithms/ManhattanRouter"), exports); // Wave 5 Card 3
-tslib_1.__exportStar(require("./global/GlobalRouteSolver"), exports); // Wave 5 Card 7
-tslib_1.__exportStar(require("./global/solver-host"), exports); // Wave 5 Card 7
-tslib_1.__exportStar(require("./algorithms/AStarRouter"), exports); // Phase 1.6b
-tslib_1.__exportStar(require("./algorithms/DijkstraRouter"), exports); // Phase 1.6b
-tslib_1.__exportStar(require("./algorithms/VisibilityGraphRouter"), exports); // Phase 1.6b
-//# sourceMappingURL=index.js.map

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

@@ -1,161 +0,0 @@
-import type { Point, Rectangle as GeometryRectangle } from '../types';
-import type { ObstacleIndex } from './ObstacleIndex';
-export type { GeometryRectangle as Rectangle };
-/**
- * A point in the routing grid/space
- */
-export interface RoutePoint extends Point {
-    /** Optional cost associated with this point */
-    cost?: number;
-}
-/**
- * A segment of a route path
- */
-export interface RouteSegment {
-    start: RoutePoint;
-    end: RoutePoint;
-    /** Length of the segment */
-    length: number;
-    /** Angle in degrees */
-    angle: number;
-}
-/**
- * A complete routed path
- */
-export interface RoutedPath {
-    /** Ordered points forming the path */
-    points: RoutePoint[];
-    /** Total path length */
-    totalLength: number;
-    /** Number of bends/turns in the path */
-    bendCount: number;
-    /** Optional cost of the path */
-    cost?: number;
-    /** Route segments */
-    segments?: RouteSegment[];
-}
-/**
- * Obstacle in the routing space (usually a node)
- */
-export interface Obstacle extends GeometryRectangle {
-    /** Unique identifier */
-    id: string;
-    /** Optional padding/margin around obstacle */
-    margin?: number;
-    /**
-     * Wave 5 (Edge routing) — Card 6: containment. Obstacles are no longer a flat
-     * set — a group obstacle knows it is one, and a node obstacle can carry its
-     * containing group, so routers can treat "inside the same container" and
-     * "collapsed group = one solid block" as first-class facts.
-     */
-    kind?: 'node' | 'group';
-    /** The containing group's id, when the obstacle lives inside one. */
-    parentId?: string;
-}
-/**
- * Routing algorithm type
- */
-export type RoutingAlgorithm = 'straight' | 'orthogonal' | 'manhattan' | 'elk' | 'a-star' | 'dijkstra' | 'visibility-graph' | 'custom';
-/**
- * Routing options
- */
-export interface RoutingOptions {
-    /** Algorithm to use */
-    algorithm?: RoutingAlgorithm;
-    /** Avoid obstacles */
-    avoidObstacles?: boolean;
-    /** Grid cell size for grid-based algorithms */
-    gridSize?: number;
-    /** Margin around obstacles */
-    obstacleMargin?: number;
-    /** Minimize bends (for orthogonal) */
-    minimizeBends?: boolean;
-    /** Cost weights */
-    costs?: {
-        distance?: number;
-        bends?: number;
-        crossings?: number;
-    };
-    /** Maximum iterations for pathfinding */
-    maxIterations?: number;
-    /**
-     * Wave 5 (Edge routing) — Card 1. Minimum port-anchor stub: the route must
-     * leave the source and enter the target PERPENDICULAR to the port side for at
-     * least this many px before the first bend. When set it also replaces the
-     * built-in 20px breathing-room offset, and a link with FLOATING (direction-
-     * less) anchors derives its exit sides from the relative geometry instead of
-     * taking the stub-less midline fallback.
-     *
-     * Unset = legacy behaviour, byte-for-byte: best-effort 20px stubs that can
-     * shrink on short links, midline routing for undirected anchors.
-     */
-    jetty?: number;
-    /**
-     * Wave 5 — Card 6: soft containment. When both endpoints live in the same
-     * group, the renderer passes that group's bounds here; grid routers charge
-     * `containerPenalty` per step OUTSIDE the container, so sibling edges stay
-     * within their container when an inside route exists — without making escape
-     * impossible when obstacles force it.
-     */
-    container?: GeometryRectangle;
-    /** Extra cost per grid step outside `container`. Default: 2 × gridSize. */
-    containerPenalty?: number;
-    /** Phase 2.2: Simplify path to reduce waypoint count */
-    simplifyPath?: boolean;
-    /** Phase 2.2: Simplification tolerance (epsilon) - higher values = more aggressive */
-    simplificationEpsilon?: number;
-}
-/**
- * Port direction for routing algorithms that need to respect port orientation
- */
-export type PortDirection = 'left' | 'right' | 'top' | 'bottom';
-/**
- * Routing request
- */
-export interface RouteRequest {
-    /** Start point */
-    start: Point;
-    /** End point */
-    end: Point;
-    /** Obstacles to avoid */
-    obstacles?: Obstacle[];
-    /** Routing options */
-    options?: RoutingOptions;
-    /** Direction the source port points (for orthogonal routing) */
-    sourceDirection?: PortDirection;
-    /** Direction the target port points (for orthogonal routing) */
-    targetDirection?: PortDirection;
-    /**
-     * Wave 8 — Card 6: a prebuilt spatial index over EXACTLY `obstacles`.
-     *
-     * An optimisation, never a semantic input: a router that ignores it and scans
-     * `obstacles` linearly gets the same answer, just slower. RoutingEngine builds
-     * one per obstacle set and reuses it across every link in a frame, so the A*
-     * inner loop stops paying O(scene) per cell it looks at. If you set this by
-     * hand it MUST describe the same obstacles as `obstacles`, or the two will
-     * disagree and the router will believe whichever one it asked.
-     */
-    obstacleIndex?: ObstacleIndex;
-}
-/**
- * Interface for routing algorithms
- */
-export interface IRouter {
-    /**
-     * Calculate a route from start to end
-     * Can be synchronous or asynchronous (for algorithms like ELK.js)
-     */
-    route(request: RouteRequest): RoutedPath | null | Promise<RoutedPath | null>;
-    /**
-     * Get algorithm name
-     */
-    getName(): string;
-}
-/**
- * Heuristic function for pathfinding
- */
-export type HeuristicFunction = (a: Point, b: Point) => number;
-/**
- * Cost function for path evaluation
- */
-export type CostFunction = (path: RoutedPath) => number;