@grafloria/element 0.3.18 → 0.3.19

package/src/libs/renderer/src/svg/port-layout.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"port-layout.js","sourceRoot":"","sources":["../../../../../../renderer/src/svg/port-layout.ts"],"names":[],"mappings":"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"}

package/src/libs/renderer/src/svg/port-positioning.d.ts

@@ -0,0 +1,33 @@
+import type { BoundingBox, NodeModel, PortModel } from '@grafloria/engine';
+/**
+ * Calculate port position based on node shape
+ * Returns position relative to node's local coordinate system (0,0 = top-left)
+ *
+ * Phase 3.2: Shape-aware port positioning
+ * - Rectangle: ports spread evenly along the edge (single port = midpoint)
+ * - Circle/Ellipse: ports on the perimeter, fanned symmetrically per side
+ * - Diamond: ports at vertices
+ * - Hexagon: ports spread along the flat edges
+ *
+ * Multiple ports on the same side are distributed by their rank among that
+ * side's ports (ordered by `index`, then declaration order) so they never
+ * stack on the same point.
+ */
+export declare function getPortPositionForShape(port: PortModel, node: NodeModel): {
+    x: number;
+    y: number;
+};
+/**
+ * The port's WORLD position — for hit-testing, magnets and link endpoints alike.
+ * Everything that needs "where is this port on screen" comes through here, so
+ * what you click is always what you see.
+ */
+export declare function portWorldPosition(port: PortModel, node: NodeModel): {
+    x: number;
+    y: number;
+};
+/** Same answer, for callers that already hold the node's bounding box. */
+export declare function portPositionInBounds(port: PortModel, node: NodeModel, bounds: BoundingBox): {
+    x: number;
+    y: number;
+};

package/src/libs/renderer/src/svg/port-positioning.js

@@ -0,0 +1,101 @@
+"use strict";
+// Shape-Aware Port Positioning Utility (Phase 3.2)
+//
+// Wave 6 (Ports & connections), Card 4: this is now the front door to the
+// PLUGGABLE port-layout engine (see `port-layout.ts`), not just to the shape
+// registry.
+//
+//   port/group declares no layout → strategy `shape` → the shape registry's
+//                                   `portAnchor`, exactly as before. The
+//                                   geometry-true anchors (cylinder rim seam,
+//                                   actor hands, hexagon flats) still win and the
+//                                   emitted geometry is byte-identical.
+//   port/group declares a layout   → that named strategy runs instead.
+//
+// It is also THE port-position function. It has a rival:
+// `PortModel.getAbsolutePosition()` walks the BOUNDING BOX (edge midpoints,
+// blind to the silhouette and to how many ports share a side) and that is what
+// the port hit-test and the magnet were snapping to, while THIS is what actually
+// gets drawn. On any non-rect shape, or any side with more than one port, you
+// were clicking several pixels away from the circle you could see. See
+// `portWorldPosition` — the one true answer, which those call sites now use.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPortPositionForShape = getPortPositionForShape;
+exports.portWorldPosition = portWorldPosition;
+exports.portPositionInBounds = portPositionInBounds;
+const engine_1 = require("@grafloria/engine");
+// Nodes & shapes foundation: shape-specific anchor geometry lives in the shape
+// registry (getShape(type).portAnchor). This module keeps the port-RANKING logic
+// (how many ports share a layout scope, and this port's rank among them) and
+// hands the geometry to the layout engine.
+const port_layout_1 = require("./port-layout");
+/**
+ * Calculate port position based on node shape
+ * Returns position relative to node's local coordinate system (0,0 = top-left)
+ *
+ * Phase 3.2: Shape-aware port positioning
+ * - Rectangle: ports spread evenly along the edge (single port = midpoint)
+ * - Circle/Ellipse: ports on the perimeter, fanned symmetrically per side
+ * - Diamond: ports at vertices
+ * - Hexagon: ports spread along the flat edges
+ *
+ * Multiple ports on the same side are distributed by their rank among that
+ * side's ports (ordered by `index`, then declaration order) so they never
+ * stack on the same point.
+ */
+function getPortPositionForShape(port, node) {
+    const shapeConfig = node.getMetadata('shape') || { type: 'rect' };
+    const { width, height } = node.size;
+    const config = (0, engine_1.resolvePortConfig)(port, node);
+    const side = config.side;
+    const { rank, count } = getLayoutRank(port, node, side, config.groupId);
+    const position = (0, port_layout_1.runPortLayout)(config.layout, {
+        width,
+        height,
+        side,
+        rank,
+        count,
+        shapeType: shapeConfig.type,
+        rotation: node.rotation,
+    });
+    // Apply port offset
+    return {
+        x: position.x + port.offset.x,
+        y: position.y + port.offset.y,
+    };
+}
+/**
+ * The port's WORLD position — for hit-testing, magnets and link endpoints alike.
+ * Everything that needs "where is this port on screen" comes through here, so
+ * what you click is always what you see.
+ */
+function portWorldPosition(port, node) {
+    const local = getPortPositionForShape(port, node);
+    const world = node.getWorldPosition();
+    return { x: world.x + local.x, y: world.y + local.y };
+}
+/** Same answer, for callers that already hold the node's bounding box. */
+function portPositionInBounds(port, node, bounds) {
+    const local = getPortPositionForShape(port, node);
+    return { x: bounds.left + local.x, y: bounds.top + local.y };
+}
+/**
+ * Rank of this port among the ports sharing its LAYOUT SCOPE, plus the size of
+ * that scope. Stable order: by `index`, ties by declaration order.
+ *
+ * The scope is the port's GROUP when it has one (Card 3 — a group is precisely
+ * "the set of ports laid out together", so five inputs in group `in` spread
+ * across five slots even if an ungrouped port also sits on the left edge), and
+ * otherwise its SIDE, which is the pre-wave-6 scope and is what keeps every
+ * existing diagram's port geometry identical.
+ */
+function getLayoutRank(port, node, side, groupId) {
+    const inScope = node
+        .getPorts()
+        .filter((p) => { var _a; return groupId ? p.group === groupId : !p.group && ((_a = p.alignment) === null || _a === void 0 ? void 0 : _a.side) === side; })
+        .map((p, declarationOrder) => ({ p, declarationOrder }))
+        .sort((a, b) => (a.p.index || 0) - (b.p.index || 0) || a.declarationOrder - b.declarationOrder);
+    const rank = inScope.findIndex((entry) => entry.p.id === port.id);
+    return { rank: rank < 0 ? 0 : rank, count: Math.max(1, inScope.length) };
+}
+//# sourceMappingURL=port-positioning.js.map

package/src/libs/renderer/src/svg/port-positioning.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"port-positioning.js","sourceRoot":"","sources":["../../../../../../renderer/src/svg/port-positioning.ts"],"names":[],"mappings":"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"}

package/src/libs/renderer/src/svg/port-spots.d.ts

@@ -0,0 +1,69 @@
+import type { PortSpot, PortSpreadSpec } from '@grafloria/engine';
+import { type FanoutSide } from './link-fanout';
+export type Side = FanoutSide;
+export interface SpotInput {
+    /** World position of the port's anchor (its glyph centre). */
+    x: number;
+    y: number;
+    /** Glyph half-extents — a spot names a corner/edge of THIS box. */
+    hw: number;
+    hh: number;
+    /** The port's side: the default direction, and the default spot. */
+    side: Side;
+}
+/** Unit tangent of a side — the axis links spread along. */
+export declare function sideTangent(side: Side): {
+    x: number;
+    y: number;
+};
+/**
+ * Resolve `spot` to a world point on the glyph box, plus the direction the link
+ * travels there.
+ *
+ * `default` (and an absent spec) resolves to the glyph CENTRE and the port's
+ * own side — byte-for-byte the pre-wave-6 endpoint. Nothing moves unless the
+ * author asks it to.
+ */
+export declare function resolveSpot(spot: PortSpot | undefined, input: SpotInput): {
+    point: {
+        x: number;
+        y: number;
+    };
+    direction: Side;
+};
+/**
+ * The signed lane offsets for `count` links sharing one port, spaced `spacing`
+ * apart and CENTRED on the port's own attachment point.
+ *
+ *   count 1 → [0]                 ← a lone link NEVER moves. This is the whole
+ *                                   byte-stability guarantee: a port with one
+ *                                   link renders exactly where it always did.
+ *   count 2 → [-s/2, +s/2]
+ *   count 3 → [-s, 0, +s]
+ */
+export declare function spreadOffsets(count: number, spacing: number, max?: number): number[];
+/**
+ * Slide an attachment point along the port's EDGE (its tangent) by one lane.
+ *
+ * Along the tangent, deliberately — sliding along the NORMAL would push the
+ * endpoint off the node and leave a visible gap between the link and the port
+ * it is supposed to be touching.
+ */
+export declare function applySpread(point: {
+    x: number;
+    y: number;
+}, side: Side, laneOffset: number): {
+    x: number;
+    y: number;
+};
+/**
+ * The lane assignment for every link on one port: `linkId → offset`.
+ *
+ * Lanes are ordered by a STABLE key (the id of the link's other endpoint, then
+ * the link's own id) rather than by insertion order, so the fan doesn't reshuffle
+ * itself every time an unrelated link is added or the diagram is reloaded.
+ */
+export declare function assignSpreadLanes(entries: Array<{
+    linkId: string;
+    sortKey: string;
+}>, spec: PortSpreadSpec | undefined): Map<string, number>;

package/src/libs/renderer/src/svg/port-spots.js

@@ -0,0 +1,154 @@
+"use strict";
+// port-spots.ts — Wave 6 (Ports & connections), Card 5.
+//
+// Where on a port's glyph does a link actually attach, and which way does it
+// leave? And when N links all land on ONE port, how do they share it?
+//
+// Two problems, one module:
+//
+//   1. ATTACHMENT SPOT. Every link used to attach to the port's centre point and
+//      leave along the port's side. `fromSpot`/`toSpot` let a port say otherwise
+//      — attach at the glyph's top-left corner, leave downward, stand off 4px.
+//
+//   2. MULTI-LINK SPREAD. Every link landing on a port landed on the SAME point,
+//      so five links into one input arrived as a single overdrawn stroke. The
+//      spread fans them along the port's edge — the tangent, not the normal, so
+//      they still arrive travelling the right way.
+//
+// This module does NOT route. It computes ENDPOINTS and hands them to the routing
+// engine, which is exactly the seam the routers already consume (`getLinkEndpoints`
+// → `{start, end, sourceDirection, targetDirection}`). No router is touched.
+//
+// PURE GEOMETRY.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sideTangent = sideTangent;
+exports.resolveSpot = resolveSpot;
+exports.spreadOffsets = spreadOffsets;
+exports.applySpread = applySpread;
+exports.assignSpreadLanes = assignSpreadLanes;
+const engine_1 = require("@grafloria/engine");
+// Wave 4 already worked out the unit outward normal of a side for the self-loop
+// router. There is exactly one right answer, so there is exactly one function.
+const link_fanout_1 = require("./link-fanout");
+/** Unit tangent of a side — the axis links spread along. */
+function sideTangent(side) {
+    const normal = (0, link_fanout_1.sideNormal)(side);
+    return { x: -normal.y, y: normal.x };
+}
+/**
+ * Resolve `spot` to a world point on the glyph box, plus the direction the link
+ * travels there.
+ *
+ * `default` (and an absent spec) resolves to the glyph CENTRE and the port's
+ * own side — byte-for-byte the pre-wave-6 endpoint. Nothing moves unless the
+ * author asks it to.
+ */
+function resolveSpot(spot, input) {
+    var _a, _b, _c;
+    const { x, y, hw, hh, side } = input;
+    const name = (_a = spot === null || spot === void 0 ? void 0 : spot.spot) !== null && _a !== void 0 ? _a : 'default';
+    const direction = (_b = spot === null || spot === void 0 ? void 0 : spot.direction) !== null && _b !== void 0 ? _b : side;
+    let px = x;
+    let py = y;
+    switch (name) {
+        case 'top':
+            py = y - hh;
+            break;
+        case 'bottom':
+            py = y + hh;
+            break;
+        case 'left':
+            px = x - hw;
+            break;
+        case 'right':
+            px = x + hw;
+            break;
+        case 'topLeft':
+            px = x - hw;
+            py = y - hh;
+            break;
+        case 'topRight':
+            px = x + hw;
+            py = y - hh;
+            break;
+        case 'bottomLeft':
+            px = x - hw;
+            py = y + hh;
+            break;
+        case 'bottomRight':
+            px = x + hw;
+            py = y + hh;
+            break;
+        case 'center':
+        case 'default':
+        default:
+            // The glyph centre — the historical attachment point.
+            break;
+    }
+    // Stand-off: push the attachment further out along the travel direction, so a
+    // link can start clear of a big glyph (or of its own arrowhead).
+    const distance = (_c = spot === null || spot === void 0 ? void 0 : spot.distance) !== null && _c !== void 0 ? _c : 0;
+    if (distance) {
+        const normal = (0, link_fanout_1.sideNormal)(direction);
+        px += normal.x * distance;
+        py += normal.y * distance;
+    }
+    return { point: { x: px, y: py }, direction };
+}
+/**
+ * The signed lane offsets for `count` links sharing one port, spaced `spacing`
+ * apart and CENTRED on the port's own attachment point.
+ *
+ *   count 1 → [0]                 ← a lone link NEVER moves. This is the whole
+ *                                   byte-stability guarantee: a port with one
+ *                                   link renders exactly where it always did.
+ *   count 2 → [-s/2, +s/2]
+ *   count 3 → [-s, 0, +s]
+ */
+function spreadOffsets(count, spacing, max = 0) {
+    if (count <= 1)
+        return [0];
+    // A cap folds the outer lanes back onto the outermost allowed one, so a port
+    // with 50 links doesn't grow a 500px fan.
+    const lanes = max > 0 ? Math.min(count, max) : count;
+    const offsets = [];
+    for (let i = 0; i < count; i++) {
+        const lane = Math.min(i, lanes - 1);
+        offsets.push((lane - (lanes - 1) / 2) * spacing);
+    }
+    return offsets;
+}
+/**
+ * Slide an attachment point along the port's EDGE (its tangent) by one lane.
+ *
+ * Along the tangent, deliberately — sliding along the NORMAL would push the
+ * endpoint off the node and leave a visible gap between the link and the port
+ * it is supposed to be touching.
+ */
+function applySpread(point, side, laneOffset) {
+    if (!laneOffset)
+        return point;
+    const tangent = sideTangent(side);
+    return { x: point.x + tangent.x * laneOffset, y: point.y + tangent.y * laneOffset };
+}
+/**
+ * The lane assignment for every link on one port: `linkId → offset`.
+ *
+ * Lanes are ordered by a STABLE key (the id of the link's other endpoint, then
+ * the link's own id) rather than by insertion order, so the fan doesn't reshuffle
+ * itself every time an unrelated link is added or the diagram is reloaded.
+ */
+function assignSpreadLanes(entries, spec) {
+    var _a, _b;
+    const lanes = new Map();
+    if (!(spec === null || spec === void 0 ? void 0 : spec.enabled) || entries.length <= 1) {
+        for (const entry of entries)
+            lanes.set(entry.linkId, 0);
+        return lanes;
+    }
+    const sorted = [...entries].sort((a, b) => a.sortKey.localeCompare(b.sortKey) || a.linkId.localeCompare(b.linkId));
+    const offsets = spreadOffsets(sorted.length, (_a = spec.spacing) !== null && _a !== void 0 ? _a : engine_1.DEFAULT_PORT_SPREAD_SPACING, (_b = spec.max) !== null && _b !== void 0 ? _b : 0);
+    sorted.forEach((entry, i) => { var _a; return lanes.set(entry.linkId, (_a = offsets[i]) !== null && _a !== void 0 ? _a : 0); });
+    return lanes;
+}
+//# sourceMappingURL=port-spots.js.map

package/src/libs/renderer/src/svg/port-spots.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"port-spots.js","sourceRoot":"","sources":["../../../../../../renderer/src/svg/port-spots.ts"],"names":[],"mappings":"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"}

package/src/libs/renderer/src/svg/route-memo.d.ts

@@ -0,0 +1,63 @@
+import type { RoutedPath } from '@grafloria/engine';
+export interface Rect {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+export interface RouteMemoStats {
+    /** links whose route had to be computed this frame */
+    routed: number;
+    /** links served from the previous frame's route */
+    reused: number;
+}
+/**
+ * How far outside a link's routed bounding box an obstacle can still have shaped
+ * that route. The router pushes off the port by `gapOffset` (30), keeps
+ * `obstacleMargin` (20) clearance from every body, and moves on a `gridSize`
+ * (10) lattice — so an obstacle that shaped this route is within ~60 units of
+ * it. 80 buys margin over that without pulling in half the diagram.
+ *
+ * This is the one approximation in the cache, and it is deliberately generous:
+ * being too eager here costs a re-route, being too clever costs a wrong route.
+ */
+export declare const ROUTE_INFLUENCE_PAD = 80;
+export declare class RouteMemo {
+    private entries;
+    private prevRects;
+    /** Bumped by the caller when something OUTSIDE the node rects changes the obstacle set. */
+    private epoch;
+    private _stats;
+    get stats(): Readonly<RouteMemoStats>;
+    get size(): number;
+    /**
+     * Start a frame. Diffs this frame's node rectangles against last frame's and
+     * returns the world regions that changed — each moved node contributes BOTH
+     * where it was and where it now is, because a link routed around its old
+     * position is just as stale as one routed through its new one.
+     *
+     * `obstacleEpoch` covers obstacle-set changes that are NOT node rects — a
+     * group collapsing hides its members and adds a block, and no node moved. A
+     * change there drops the whole cache, which is the honest thing to do: it is
+     * rare, and reasoning about which links a collapse touched is how you ship a
+     * stale route.
+     */
+    beginFrame(rects: Map<string, Rect>, obstacleEpoch: string): Rect[];
+    /** The route for this link if its inputs are unchanged since we cached it. */
+    lookup(linkId: string, key: string): RoutedPath | undefined;
+    store(linkId: string, key: string, routed: RoutedPath): void;
+    /** A route computed but NOT cacheable (e.g. no route found) must not keep a stale entry. */
+    drop(linkId: string): void;
+    invalidate(linkIds: Iterable<string>): void;
+    clear(): void;
+}
+/** Grow a rect by `pad` on every side. */
+export declare function inflate(r: Rect, pad: number): Rect;
+/**
+ * Merge dirty rects that overlap or nearly touch, so a drag of one node does not
+ * fire N separate spatial queries. Cheap and approximate: one pass, absorbing
+ * into the first box that already covers the candidate's neighbourhood. The
+ * result is a SUPERSET of the input regions, which is the safe direction — it
+ * can only invalidate more links, never fewer.
+ */
+export declare function coalesce(rects: Rect[], maxBoxes?: number): Rect[];

package/src/libs/renderer/src/svg/route-memo.js

@@ -0,0 +1,206 @@
+"use strict";
+// Wave 8 (Performance & scale) — Card 6: route only what actually changed.
+//
+// THE BUG THIS EXISTS TO KILL. `renderLinksLayer` re-routed EVERY visible link
+// on EVERY frame:
+//
+//     for (const link of sortedLinks) { ... this.computeAutoRoute(link, endpoints) ... }
+//
+// whether or not anything had moved. Obstacle-avoiding routing is not cheap, so
+// an idle frame paid for a full re-solve of the visible scene, and moving ONE
+// node cost 5.5 seconds at 10k nodes — O(scene) work for an O(1) edit.
+//
+// WHAT MAKES A ROUTE STALE. Two different things, and getting only the first is
+// the trap:
+//
+//   1. The link's own inputs changed — its endpoints moved (because a node it is
+//      attached to moved or resized), its router changed, its lane in a parallel
+//      bundle changed. This is captured by the cache KEY: the key is built from
+//      the routing inputs, so a change to any of them is a miss. Endpoint moves
+//      need no special case at all — the endpoint coordinates ARE the key.
+//
+//   2. THE OBSTACLE CASE, which "did an endpoint move?" misses entirely: a node
+//      that this link does not touch moved INTO (or OUT OF) the corridor the
+//      link routes through. Nothing about the link changed; its correct route
+//      did. A cache that only watches endpoints serves a route straight through
+//      the new obstacle — fast and wrong.
+//
+// Wave 4 hit this same shape from the other side: the link VNode cache keyed off
+// `link.isDirty`, but a link's rendered output also depends on where its NODES
+// went, so it served stale geometry. The fix there was `markLinksWhoseFrameChanged`.
+// This is the same discipline one level down, on the ROUTE rather than the VNode.
+//
+// HOW CASE 2 IS CAUGHT. Every frame we diff the node rectangles against last
+// frame's. Each node that moved, resized, appeared or vanished contributes its
+// OLD and NEW rectangles as a dirty region. The engine's link spatial index —
+// which is keyed on each link's routed bounding box, because `syncLinkPoints`
+// refreshes it — is then asked which links' boxes intersect those regions,
+// inflated by the routing clearance. Those links are invalidated. A link that
+// neither moved nor had its corridor disturbed keeps its route, forever, for
+// free.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RouteMemo = exports.ROUTE_INFLUENCE_PAD = void 0;
+exports.inflate = inflate;
+exports.coalesce = coalesce;
+/**
+ * How far outside a link's routed bounding box an obstacle can still have shaped
+ * that route. The router pushes off the port by `gapOffset` (30), keeps
+ * `obstacleMargin` (20) clearance from every body, and moves on a `gridSize`
+ * (10) lattice — so an obstacle that shaped this route is within ~60 units of
+ * it. 80 buys margin over that without pulling in half the diagram.
+ *
+ * This is the one approximation in the cache, and it is deliberately generous:
+ * being too eager here costs a re-route, being too clever costs a wrong route.
+ */
+exports.ROUTE_INFLUENCE_PAD = 80;
+/** Entries above this are evicted oldest-first — a deleted link must not leak forever. */
+const MAX_ENTRIES = 50000;
+class RouteMemo {
+    constructor() {
+        this.entries = new Map();
+        this.prevRects = new Map();
+        /** Bumped by the caller when something OUTSIDE the node rects changes the obstacle set. */
+        this.epoch = '';
+        this._stats = { routed: 0, reused: 0 };
+    }
+    get stats() {
+        return this._stats;
+    }
+    get size() {
+        return this.entries.size;
+    }
+    /**
+     * Start a frame. Diffs this frame's node rectangles against last frame's and
+     * returns the world regions that changed — each moved node contributes BOTH
+     * where it was and where it now is, because a link routed around its old
+     * position is just as stale as one routed through its new one.
+     *
+     * `obstacleEpoch` covers obstacle-set changes that are NOT node rects — a
+     * group collapsing hides its members and adds a block, and no node moved. A
+     * change there drops the whole cache, which is the honest thing to do: it is
+     * rare, and reasoning about which links a collapse touched is how you ship a
+     * stale route.
+     */
+    beginFrame(rects, obstacleEpoch) {
+        this._stats = { routed: 0, reused: 0 };
+        if (obstacleEpoch !== this.epoch) {
+            this.epoch = obstacleEpoch;
+            this.entries.clear();
+            this.prevRects = rects;
+            // Everything is stale; no point enumerating regions.
+            return [];
+        }
+        const dirty = [];
+        for (const [id, now] of rects) {
+            const before = this.prevRects.get(id);
+            if (!before) {
+                dirty.push(now); // appeared
+                continue;
+            }
+            if (before.x !== now.x ||
+                before.y !== now.y ||
+                before.width !== now.width ||
+                before.height !== now.height) {
+                dirty.push(before); // vacated
+                dirty.push(now); // occupied
+            }
+        }
+        for (const [id, before] of this.prevRects) {
+            if (!rects.has(id))
+                dirty.push(before); // vanished
+        }
+        this.prevRects = rects;
+        return dirty;
+    }
+    /** The route for this link if its inputs are unchanged since we cached it. */
+    lookup(linkId, key) {
+        const hit = this.entries.get(linkId);
+        if (!hit || hit.key !== key)
+            return undefined;
+        this._stats.reused++;
+        return hit.routed;
+    }
+    store(linkId, key, routed) {
+        this._stats.routed++;
+        if (this.entries.size >= MAX_ENTRIES && !this.entries.has(linkId)) {
+            // Map iterates in insertion order, so this drops the oldest.
+            const oldest = this.entries.keys().next();
+            if (!oldest.done)
+                this.entries.delete(oldest.value);
+        }
+        this.entries.set(linkId, { key, routed });
+    }
+    /** A route computed but NOT cacheable (e.g. no route found) must not keep a stale entry. */
+    drop(linkId) {
+        this.entries.delete(linkId);
+    }
+    invalidate(linkIds) {
+        for (const id of linkIds)
+            this.entries.delete(id);
+    }
+    clear() {
+        this.entries.clear();
+        this.prevRects.clear();
+        this.epoch = '';
+    }
+}
+exports.RouteMemo = RouteMemo;
+/** Grow a rect by `pad` on every side. */
+function inflate(r, pad) {
+    return {
+        x: r.x - pad,
+        y: r.y - pad,
+        width: r.width + pad * 2,
+        height: r.height + pad * 2,
+    };
+}
+/**
+ * Merge dirty rects that overlap or nearly touch, so a drag of one node does not
+ * fire N separate spatial queries. Cheap and approximate: one pass, absorbing
+ * into the first box that already covers the candidate's neighbourhood. The
+ * result is a SUPERSET of the input regions, which is the safe direction — it
+ * can only invalidate more links, never fewer.
+ */
+function coalesce(rects, maxBoxes = 16) {
+    if (rects.length <= 1)
+        return rects;
+    const boxes = [];
+    for (const r of rects) {
+        let merged = false;
+        for (let i = 0; i < boxes.length; i++) {
+            const b = boxes[i];
+            if (r.x <= b.x + b.width &&
+                r.x + r.width >= b.x &&
+                r.y <= b.y + b.height &&
+                r.y + r.height >= b.y) {
+                const minX = Math.min(b.x, r.x);
+                const minY = Math.min(b.y, r.y);
+                const maxX = Math.max(b.x + b.width, r.x + r.width);
+                const maxY = Math.max(b.y + b.height, r.y + r.height);
+                boxes[i] = { x: minX, y: minY, width: maxX - minX, height: maxY - minY };
+                merged = true;
+                break;
+            }
+        }
+        if (!merged)
+            boxes.push(Object.assign({}, r));
+    }
+    // A pathological frame (a layout run moving every node) must not turn into
+    // thousands of spatial queries. Past the cap, collapse to one covering box:
+    // strictly more invalidation, strictly less bookkeeping.
+    if (boxes.length > maxBoxes) {
+        let minX = Infinity;
+        let minY = Infinity;
+        let maxX = -Infinity;
+        let maxY = -Infinity;
+        for (const b of boxes) {
+            minX = Math.min(minX, b.x);
+            minY = Math.min(minY, b.y);
+            maxX = Math.max(maxX, b.x + b.width);
+            maxY = Math.max(maxY, b.y + b.height);
+        }
+        return [{ x: minX, y: minY, width: maxX - minX, height: maxY - minY }];
+    }
+    return boxes;
+}
+//# sourceMappingURL=route-memo.js.map