@grafloria/element 0.3.17 → 0.3.19

package/src/libs/engine/src/layout/force-layout-adapter.js

@@ -0,0 +1,790 @@
+"use strict";
+/**
+ * Force-Directed (Organic) Layout Adapter
+ *
+ * Physics-based layout where nodes repel each other and edges act as springs.
+ * Creates natural-looking layouts that reveal clustering patterns.
+ *
+ * Best for:
+ * - Social networks
+ * - Biological networks
+ * - General graphs without clear hierarchy
+ * - Discovering natural clusters
+ *
+ * Algorithm: Fruchterman-Reingold with Barnes-Hut optimization
+ *
+ * @module layout/force-layout-adapter
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ForceLayoutAdapter = void 0;
+const tslib_1 = require("tslib");
+const rng_1 = require("./rng");
+const layout_quality_metrics_1 = require("./layout-quality-metrics");
+const component_packing_1 = require("./component-packing");
+/**
+ * Force-Directed Layout Adapter
+ *
+ * Implements Fruchterman-Reingold algorithm with Barnes-Hut optimization.
+ */
+class ForceLayoutAdapter {
+    constructor() {
+        this.name = 'force';
+    }
+    /**
+     * Wave 7 Card 3 — the simulation, exposed one iteration at a time.
+     *
+     * This is where the physics lives, and it is the ONLY place it lives: `apply()`
+     * below is now just "drive this to convergence". Splitting the loop out (rather
+     * than copying it into a worker-flavoured twin) is what keeps the off-thread
+     * path honest — the worker and the main thread run the same arithmetic in the
+     * same order, so they cannot drift.
+     *
+     * Pure and synchronous: no clock, no DOM, and randomness only through the
+     * seeded generator. Those three abstinences are the whole reason a worker run
+     * and an inline run produce byte-identical coordinates.
+     *
+     * `snapshot()` is meaningful after ANY number of steps, which is what makes a
+     * cancelled force layout return the 200-iteration picture it already has
+     * instead of throwing it away.
+     */
+    createRun(nodes, links, options = {}) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l;
+        // Merge with defaults
+        const opts = Object.assign({ repulsion: (_a = options.repulsion) !== null && _a !== void 0 ? _a : 100, 
+            // wave: force-attraction — was 0.1, too weak to pull connected nodes
+            // BELOW the repulsion-driven field spacing. At 0.1 an edge relaxes to
+            // wherever repulsion parks it (≈ its rest length) instead of the spring
+            // actively holding it in, so on a dense two-cluster graph connected pairs
+            // sat at the SAME distance as random pairs — "no attraction". 0.2 makes
+            // the spring the dominant term at edge scale (edges settle near rest
+            // length, non-edges stay out at the repulsion equilibrium) while staying
+            // far from the over-tightening that would collapse a mesh. See the
+            // "linked pairs sit closer than the average pair" tests.
+            attraction: (_b = options.attraction) !== null && _b !== void 0 ? _b : 0.2, gravity: (_c = options.gravity) !== null && _c !== void 0 ? _c : 0.1, temperature: (_d = options.temperature) !== null && _d !== void 0 ? _d : 100, cooling: (_e = options.cooling) !== null && _e !== void 0 ? _e : 0.95, iterations: (_f = options.iterations) !== null && _f !== void 0 ? _f : 300, threshold: (_g = options.threshold) !== null && _g !== void 0 ? _g : 0.1, useBarnesHut: (_h = options.useBarnesHut) !== null && _h !== void 0 ? _h : true, theta: (_j = options.theta) !== null && _j !== void 0 ? _j : 0.9, linkDistance: (_k = options.linkDistance) !== null && _k !== void 0 ? _k : 100, randomize: (_l = options.randomize) !== null && _l !== void 0 ? _l : true }, options);
+        // Initialize force nodes
+        const forceNodes = this.initializeNodes(nodes, opts);
+        const forceNodeMap = new Map(forceNodes.map(n => [n.id, n]));
+        // Build edge list
+        const edges = links
+            .filter(link => link.sourceNodeId && link.targetNodeId)
+            .map(link => ({
+            source: forceNodeMap.get(link.sourceNodeId),
+            target: forceNodeMap.get(link.targetNodeId),
+        }))
+            .filter(edge => edge.source && edge.target);
+        // Apply constraints (pin nodes)
+        if (options.constraints) {
+            forceNodes.forEach(node => {
+                const constraints = options.constraints.constraints.filter(c => c.nodeId === node.id);
+                if (constraints.length > 0) {
+                    const constraint = constraints[0];
+                    if (constraint.type === 'pin' && constraint.position) {
+                        node.x = constraint.position.x;
+                        node.y = constraint.position.y;
+                        node.fixed = true;
+                    }
+                }
+            });
+        }
+        const adapter = this;
+        let temperature = opts.temperature;
+        let iteration = 0;
+        let maxMovement = Infinity;
+        // Exactly the original `while` condition, hoisted so `step()` can consult it
+        // both before doing work (so a zero-iteration run does none) and after (so
+        // the caller learns there is no more).
+        const shouldContinue = () => iteration < opts.iterations && maxMovement > opts.threshold;
+        return {
+            get iteration() {
+                return iteration;
+            },
+            get totalIterations() {
+                return opts.iterations;
+            },
+            step() {
+                if (!shouldContinue())
+                    return false;
+                // Reset forces
+                forceNodes.forEach(node => {
+                    node.fx = 0;
+                    node.fy = 0;
+                });
+                // Repulsion forces (using Barnes-Hut if enabled)
+                if (opts.useBarnesHut && forceNodes.length > 50) {
+                    adapter.applyBarnesHutRepulsion(forceNodes, opts);
+                }
+                else {
+                    adapter.applyRepulsion(forceNodes, opts);
+                }
+                // Attraction forces along edges
+                adapter.applyAttraction(edges, opts);
+                // Gravity to center
+                adapter.applyGravity(forceNodes, opts);
+                // Update positions
+                maxMovement = adapter.updatePositions(forceNodes, temperature);
+                // Cool down
+                temperature *= opts.cooling;
+                iteration++;
+                return shouldContinue();
+            },
+            snapshot() {
+                // Hand over a picture whose BOXES do not overlap. The physics is
+                // size-aware, but a run can stop early (iteration cap, threshold,
+                // cancellation) with residue — and downstream overlap removal is an
+                // x-only sweep, so any residue it inherits becomes pure horizontal
+                // spread (the cigar). A uniform scale about the centroid clears it
+                // while preserving the layout's shape exactly. Pure: sim state is
+                // not mutated, so snapshot() stays valid mid-run.
+                //
+                // `removeOverlaps: false` is the caller saying "raw output, please" —
+                // honour it here exactly as component-packing honours it downstream,
+                // or the escape hatch would be a lie on the one algorithm anybody
+                // would want it for.
+                const nodePositions = opts.removeOverlaps === false
+                    ? new Map(forceNodes.map(n => [n.id, { x: n.x, y: n.y }]))
+                    : adapter.resolveResidualOverlap(forceNodes);
+                return {
+                    nodePositions,
+                    bounds: adapter.calculateBounds([...nodePositions.values()]),
+                    metadata: {
+                        algorithm: 'force',
+                        iterations: iteration,
+                        finalTemperature: temperature,
+                        // The clock is the caller's business, not the simulation's: a run
+                        // that timed itself could not produce identical output twice.
+                        executionTime: 0,
+                        nodeCount: nodes.length,
+                        linkCount: links.length,
+                    },
+                };
+            },
+        };
+    }
+    /**
+     * Apply force-directed layout (run the simulation to convergence).
+     */
+    apply(nodes_1, links_1) {
+        return tslib_1.__awaiter(this, arguments, void 0, function* (nodes, links, options = {}) {
+            const startTime = performance.now();
+            const run = this.createRun(nodes, links, options);
+            while (run.step()) {
+                // run to convergence or the iteration cap, whichever comes first
+            }
+            const result = run.snapshot();
+            // Apply positions to nodes
+            nodes.forEach(node => {
+                const position = result.nodePositions.get(node.id);
+                if (position) {
+                    node.setPosition(position.x, position.y);
+                }
+            });
+            // Calculate quality metrics if requested
+            let quality = undefined;
+            if (options.calculateQuality) {
+                quality = layout_quality_metrics_1.LayoutQualityMetrics.assess(nodes, links, {
+                    includeSuggestions: true,
+                    canvasDimensions: options.canvasDimensions,
+                });
+            }
+            return Object.assign(Object.assign({}, result), { metadata: Object.assign(Object.assign({}, result.metadata), { algorithm: 'force', executionTime: performance.now() - startTime }), quality });
+        });
+    }
+    /**
+     * Initialize force nodes with random or existing positions
+     */
+    initializeNodes(nodes, options) {
+        const forceNodes = [];
+        const rng = (0, rng_1.createLayoutRng)(options.seed);
+        // The cigar bug (wave: layout-cigar): initial positions must give the BOXES
+        // room. The old ±250 random square holds ~50 default-sized boxes; seed 2000
+        // nodes into it and the simulation freezes (the temperature schedule allows
+        // only ~2000px of total travel) long before repulsion can inflate the cloud
+        // to a viable density. The residue was a heavily box-overlapping blob, and
+        // the downstream x-only overlap sweep then converted ALL of that overlap
+        // into pure x-spread — the measured 6-7:1 horizontal cigar.
+        //
+        // So: start at the DENSITY THE BOXES NEED, not at a fixed size. A sunflower
+        // (phyllotaxis) spiral with the ring pitch set to the mean box diagonal
+        // packs n boxes into a disc with near-uniform, near-contact spacing — the
+        // physics then only has to refine locally, which fits the travel budget at
+        // every graph size. Seeded jitter keeps runs reproducible (Card 0) while
+        // different seeds still give genuinely different pictures.
+        let meanDiagonal = 0;
+        for (const node of nodes) {
+            const size = (0, component_packing_1.nodeSize)(node);
+            meanDiagonal += Math.hypot(size.width, size.height);
+        }
+        meanDiagonal /= Math.max(nodes.length, 1);
+        const pitch = meanDiagonal + 16;
+        const GOLDEN_ANGLE = Math.PI * (3 - Math.sqrt(5));
+        let index = 0;
+        for (const node of nodes) {
+            let x, y;
+            if (options.randomize) {
+                // Card 0: SEEDED. This was `Math.random()`, so the same graph produced a
+                // different picture on every run — untestable, unreproducible on reload,
+                // and it makes the mental-map card undefinable (you cannot minimise
+                // movement against a baseline that itself moves).
+                const r = pitch * Math.sqrt(index + 0.5);
+                const angle = index * GOLDEN_ANGLE;
+                x = r * Math.cos(angle) + rng.between(-0.3 * pitch, 0.3 * pitch);
+                y = r * Math.sin(angle) + rng.between(-0.3 * pitch, 0.3 * pitch);
+            }
+            else {
+                // Use existing position
+                x = node.position.x;
+                y = node.position.y;
+            }
+            index++;
+            const size = (0, component_packing_1.nodeSize)(node);
+            forceNodes.push({
+                id: node.id,
+                x,
+                y,
+                vx: 0,
+                vy: 0,
+                fx: 0,
+                fy: 0,
+                mass: 1,
+                fixed: false,
+                width: size.width,
+                height: size.height,
+                radius: Math.hypot(size.width, size.height) / 2,
+            });
+        }
+        return forceNodes;
+    }
+    /**
+     * Apply repulsion forces between all node pairs
+     */
+    applyRepulsion(nodes, options) {
+        const k = options.repulsion;
+        for (let i = 0; i < nodes.length; i++) {
+            for (let j = i + 1; j < nodes.length; j++) {
+                const n1 = nodes[i];
+                const n2 = nodes[j];
+                const dx = n2.x - n1.x;
+                const dy = n2.y - n1.y;
+                const distSq = dx * dx + dy * dy + 0.01; // Avoid division by zero
+                const dist = Math.sqrt(distSq);
+                // Repulse by BOX GAP, not centre distance: the force diverges as the
+                // boxes approach contact, so the simulation itself keeps them apart
+                // instead of leaving a pile for a post-pass to shove sideways.
+                const gap = Math.max(dist - (n1.radius + n2.radius), 1);
+                const force = (k * k) / (gap * gap);
+                const fx = (dx / dist) * force;
+                const fy = (dy / dist) * force;
+                n1.fx -= fx;
+                n1.fy -= fy;
+                n2.fx += fx;
+                n2.fy += fy;
+            }
+        }
+    }
+    /**
+     * Apply Barnes-Hut approximation for repulsion (O(n log n))
+     */
+    applyBarnesHutRepulsion(nodes, options) {
+        // Build quadtree
+        const quadtree = this.buildQuadTree(nodes);
+        // Apply repulsion using quadtree
+        const k = options.repulsion;
+        const kk = k * k;
+        const theta = options.theta;
+        // Iterative traversal with one shared stack, hoisted locals, and a single
+        // division per visited cell — (dx/dist)·(k²m/gap²) is algebraically
+        // dx·k²m/(gap²·dist). This inner loop runs millions of times per layout
+        // (~64 cell visits × n nodes × iterations) and was ~90% of the
+        // simulation's wall time on a 900-node mesh; the flattening plus the
+        // merged division roughly halve it. Same visit set, same forces.
+        const stack = [];
+        for (const node of nodes) {
+            const nx = node.x;
+            const ny = node.y;
+            const nr = node.radius;
+            let fx = 0;
+            let fy = 0;
+            let top = 0;
+            stack[top++] = quadtree;
+            while (top > 0) {
+                const tree = stack[--top];
+                if (tree.mass === 0)
+                    continue;
+                const dx = tree.x - nx;
+                const dy = tree.y - ny;
+                const dist = Math.sqrt(dx * dx + dy * dy + 0.01);
+                if ((tree.right - tree.left) / dist < theta) {
+                    // Far enough: treat the whole cell as one size-aware body
+                    let gap = dist - nr - tree.radius;
+                    if (gap < 1)
+                        gap = 1;
+                    const f = (kk * tree.mass) / (gap * gap * dist);
+                    fx -= dx * f;
+                    fy -= dy * f;
+                }
+                else if (tree.children) {
+                    const children = tree.children;
+                    stack[top++] = children[0];
+                    stack[top++] = children[1];
+                    stack[top++] = children[2];
+                    stack[top++] = children[3];
+                }
+                else if (tree.node && tree.node !== node) {
+                    let gap = dist - nr - tree.node.radius;
+                    if (gap < 1)
+                        gap = 1;
+                    const f = kk / (gap * gap * dist);
+                    fx -= dx * f;
+                    fy -= dy * f;
+                }
+            }
+            node.fx += fx;
+            node.fy += fy;
+        }
+    }
+    /**
+     * Build quadtree for Barnes-Hut
+     */
+    buildQuadTree(nodes) {
+        if (nodes.length === 0) {
+            return {
+                x: 0,
+                y: 0,
+                mass: 0,
+                radius: 0,
+                left: 0,
+                top: 0,
+                right: 0,
+                bottom: 0,
+            };
+        }
+        // Calculate bounds
+        let minX = Infinity, minY = Infinity;
+        let maxX = -Infinity, maxY = -Infinity;
+        for (const node of nodes) {
+            minX = Math.min(minX, node.x);
+            minY = Math.min(minY, node.y);
+            maxX = Math.max(maxX, node.x);
+            maxY = Math.max(maxY, node.y);
+        }
+        // Create root
+        const root = {
+            x: (minX + maxX) / 2,
+            y: (minY + maxY) / 2,
+            mass: 0,
+            radius: 0,
+            left: minX,
+            top: minY,
+            right: maxX,
+            bottom: maxY,
+        };
+        // Insert nodes
+        for (const node of nodes) {
+            this.insertIntoQuadTree(root, node);
+        }
+        return root;
+    }
+    /**
+     * Insert node into quadtree
+     */
+    insertIntoQuadTree(tree, node) {
+        // Update mass, center of mass, and mean collision radius
+        const totalMass = tree.mass + node.mass;
+        tree.x = (tree.x * tree.mass + node.x * node.mass) / totalMass;
+        tree.y = (tree.y * tree.mass + node.y * node.mass) / totalMass;
+        tree.radius = (tree.radius * tree.mass + node.radius * node.mass) / totalMass;
+        tree.mass = totalMass;
+        // If this is a leaf, either store the node or subdivide
+        if (!tree.children) {
+            if (!tree.node) {
+                tree.node = node;
+            }
+            else {
+                // Subdivide
+                this.subdivideQuadTree(tree);
+                this.insertIntoQuadTree(tree, tree.node);
+                this.insertIntoQuadTree(tree, node);
+                tree.node = undefined;
+            }
+        }
+        else {
+            // Insert into appropriate child
+            const childIndex = this.getQuadrant(tree, node);
+            this.insertIntoQuadTree(tree.children[childIndex], node);
+        }
+    }
+    /**
+     * Subdivide quadtree node
+     */
+    subdivideQuadTree(tree) {
+        const midX = (tree.left + tree.right) / 2;
+        const midY = (tree.top + tree.bottom) / 2;
+        tree.children = [
+            // NW
+            {
+                x: (tree.left + midX) / 2,
+                y: (tree.top + midY) / 2,
+                mass: 0,
+                radius: 0,
+                left: tree.left,
+                top: tree.top,
+                right: midX,
+                bottom: midY,
+            },
+            // NE
+            {
+                x: (midX + tree.right) / 2,
+                y: (tree.top + midY) / 2,
+                mass: 0,
+                radius: 0,
+                left: midX,
+                top: tree.top,
+                right: tree.right,
+                bottom: midY,
+            },
+            // SW
+            {
+                x: (tree.left + midX) / 2,
+                y: (midY + tree.bottom) / 2,
+                mass: 0,
+                radius: 0,
+                left: tree.left,
+                top: midY,
+                right: midX,
+                bottom: tree.bottom,
+            },
+            // SE
+            {
+                x: (midX + tree.right) / 2,
+                y: (midY + tree.bottom) / 2,
+                mass: 0,
+                radius: 0,
+                left: midX,
+                top: midY,
+                right: tree.right,
+                bottom: tree.bottom,
+            },
+        ];
+    }
+    /**
+     * Get quadrant for node
+     */
+    getQuadrant(tree, node) {
+        const midX = (tree.left + tree.right) / 2;
+        const midY = (tree.top + tree.bottom) / 2;
+        if (node.x < midX) {
+            return node.y < midY ? 0 : 2; // NW or SW
+        }
+        else {
+            return node.y < midY ? 1 : 3; // NE or SE
+        }
+    }
+    /**
+     * Apply attraction forces along edges
+     */
+    applyAttraction(edges, options) {
+        const k = options.attraction;
+        const baseLength = options.linkDistance;
+        for (const edge of edges) {
+            const dx = edge.target.x - edge.source.x;
+            const dy = edge.target.y - edge.source.y;
+            const dist = Math.sqrt(dx * dx + dy * dy) + 0.01;
+            // Spring force (Hooke's law). The rest length is `linkDistance` plus a
+            // box clearance, so a satisfied edge leaves a visible gap instead of
+            // pulling its endpoints into overlap.
+            //
+            // wave: force-attraction — that clearance used to be the FULL collision
+            // radii (half the box DIAGONAL each). For default 60px boxes that made
+            // the rest length 100+85≈185 — which is exactly where box-gap repulsion
+            // parks two UNconnected default boxes too. So connected and unconnected
+            // pairs relaxed to the same spacing and the layout stopped revealing
+            // clusters (the demo measured mean-edge ≈ mean-pair). HALF the clearance
+            // pulls the rest length below the repulsion field (100+42≈142) so edges
+            // are unambiguously the shorter distance, while box-gap repulsion — which
+            // diverges at contact — still guarantees no overlap regardless of what
+            // the spring wants. Measured on the two-cluster graph: mean-edge/mean-pair
+            // fell from 1.01 (no attraction) to ~0.77.
+            const clearance = (edge.source.radius + edge.target.radius) * 0.5;
+            const idealLength = baseLength + clearance;
+            const force = k * (dist - idealLength);
+            const fx = (dx / dist) * force;
+            const fy = (dy / dist) * force;
+            edge.source.fx += fx;
+            edge.source.fy += fy;
+            edge.target.fx -= fx;
+            edge.target.fy -= fy;
+        }
+    }
+    /**
+     * Apply gravity pulling nodes to center
+     */
+    applyGravity(nodes, options) {
+        const g = options.gravity;
+        // A pull that grows linearly with distance forever is scale-dependent: on a
+        // 900-node graph the rim sits thousands of px out, gravity dwarfs every
+        // other force, and the graph is crushed into an overlapping blob (which the
+        // x-only downstream sweep then smears into the cigar). Saturate the pull
+        // beyond a couple of edge lengths — compact graphs (everything within
+        // `gravityRange` of the centre) are numerically UNCHANGED, big graphs keep
+        // a gentle, size-independent centring pressure.
+        const gravityRange = 2 * options.linkDistance;
+        // Calculate center
+        let cx = 0, cy = 0;
+        for (const node of nodes) {
+            cx += node.x;
+            cy += node.y;
+        }
+        cx /= nodes.length;
+        cy /= nodes.length;
+        // Apply gravity
+        for (const node of nodes) {
+            const dx = cx - node.x;
+            const dy = cy - node.y;
+            const dist = Math.hypot(dx, dy);
+            if (dist <= gravityRange || dist === 0) {
+                node.fx += dx * g;
+                node.fy += dy * g;
+            }
+            else {
+                const saturated = (g * gravityRange) / dist;
+                node.fx += dx * saturated;
+                node.fy += dy * saturated;
+            }
+        }
+    }
+    /**
+     * Update node positions based on forces
+     */
+    updatePositions(nodes, temperature) {
+        let maxMovement = 0;
+        for (const node of nodes) {
+            if (node.fixed) {
+                continue;
+            }
+            // Update velocity
+            node.vx += node.fx;
+            node.vy += node.fy;
+            // Apply damping
+            node.vx *= 0.9;
+            node.vy *= 0.9;
+            // Limit velocity by temperature
+            const speed = Math.sqrt(node.vx * node.vx + node.vy * node.vy);
+            if (speed > temperature) {
+                node.vx = (node.vx / speed) * temperature;
+                node.vy = (node.vy / speed) * temperature;
+            }
+            // Update position
+            node.x += node.vx;
+            node.y += node.vy;
+            // Track movement
+            const movement = Math.abs(node.vx) + Math.abs(node.vy);
+            maxMovement = Math.max(maxMovement, movement);
+        }
+        return maxMovement;
+    }
+    /**
+     * The last line of defence against the cigar (wave: layout-cigar).
+     *
+     * The size-aware forces keep boxes apart at equilibrium, but a run can stop
+     * before equilibrium (iteration cap, cooling, cancellation). Whatever box
+     * overlap remains would otherwise be resolved by overlap-removal.ts, whose
+     * sweep separates strictly along X — measured on a 15x15 mesh, that turned
+     * an aspect-1.0 force layout into an aspect-6.7 horizontal wedge. So the
+     * simulation cleans up after itself, axis-symmetrically:
+     *
+     *   1. ZOOM. If the field is BROADLY too dense, scale every position
+     *      uniformly about the centroid — a pure zoom preserves the layout's
+     *      shape exactly, and growing the scale never creates a new overlap.
+     *      The factor is what clears 90% of the overlapping pairs (capped):
+     *      chasing the single worst pair was measured to inflate a perfect
+     *      3950px mesh 4.5x for the sake of a couple of stragglers.
+     *   2. LOCAL PASSES. The stragglers are pushed apart pairwise along their
+     *      minimum-translation axis, both nodes moving symmetrically. Pairwise
+     *      relaxation famously does not converge on a PILE (see
+     *      overlap-removal.ts's header) — but after the physics and the zoom
+     *      there is no pile, only isolated collisions, which it resolves in a
+     *      pass or two. Anything truly pathological is left for the downstream
+     *      sweep, where a handful of x-only nudges cannot bend the aspect.
+     *
+     * Deterministic (stable orders, no randomness), pure with respect to the
+     * simulation state, and skipped when a node is pinned — a pin is a promise
+     * about absolute coordinates.
+     */
+    resolveResidualOverlap(forceNodes) {
+        const positions = new Map();
+        forceNodes.forEach(node => {
+            positions.set(node.id, { x: node.x, y: node.y });
+        });
+        if (forceNodes.length < 2 || forceNodes.some(n => n.fixed))
+            return positions;
+        // Clearance to open between boxes that were overlapping. Anything > 0
+        // makes the downstream sweep a no-op; a few px keeps boxes readable.
+        const margin = 8;
+        const boxes = forceNodes.map(n => ({
+            id: n.id, x: n.x, y: n.y, width: n.width, height: n.height,
+        }));
+        // Overlapping pairs (within `margin`), via the same (x, id) sort-sweep
+        // overlap-removal.ts uses to stay near-linear on a mostly-separated field.
+        const overlappingPairs = () => {
+            const sorted = [...boxes].sort((a, b) => a.x - b.x || (a.id < b.id ? -1 : 1));
+            const pairs = [];
+            const active = [];
+            for (const box of sorted) {
+                for (let i = active.length - 1; i >= 0; i--) {
+                    if (active[i].x + active[i].width + margin <= box.x)
+                        active.splice(i, 1);
+                }
+                for (const other of active) {
+                    if (box.x < other.x + other.width + margin &&
+                        other.x < box.x + box.width + margin &&
+                        box.y < other.y + other.height + margin &&
+                        other.y < box.y + box.height + margin) {
+                        pairs.push([other, box]);
+                    }
+                }
+                active.push(box);
+            }
+            return pairs;
+        };
+        // ------------------------------------------------------------------ zoom
+        const needs = [];
+        for (const [a, b] of overlappingPairs()) {
+            // After a zoom by s the delta between two positions is s·d, so clearing
+            // a pair on ONE axis needs s·|d| ≥ (leading box's extent + margin) on
+            // that axis; the pair needs its cheaper axis.
+            const dx = b.x - a.x; // ≥ 0: `a` entered the sweep first
+            const dy = b.y - a.y;
+            const sx = dx > 0 ? (a.width + margin) / dx : Infinity;
+            const sy = dy > 0 ? (a.height + margin) / dy
+                : dy < 0 ? (b.height + margin) / -dy
+                    : Infinity;
+            needs.push(Math.min(sx, sy));
+        }
+        if (needs.length > 0) {
+            needs.sort((a, b) => a - b);
+            const p90 = needs[Math.min(needs.length - 1, Math.ceil(needs.length * 0.9) - 1)];
+            const scale = Math.min(Math.max(p90, 1), 2);
+            if (scale > 1) {
+                let cx = 0, cy = 0;
+                for (const box of boxes) {
+                    cx += box.x;
+                    cy += box.y;
+                }
+                cx /= boxes.length;
+                cy /= boxes.length;
+                for (const box of boxes) {
+                    box.x = cx + (box.x - cx) * scale;
+                    box.y = cy + (box.y - cy) * scale;
+                }
+            }
+        }
+        // ---------------------------------------------------------- local passes
+        for (let pass = 0; pass < 4; pass++) {
+            const pairs = overlappingPairs();
+            if (pairs.length === 0)
+                break;
+            for (const [a, b] of pairs) {
+                const overlapX = Math.min(a.x + a.width, b.x + b.width) + margin - Math.max(a.x, b.x);
+                const overlapY = Math.min(a.y + a.height, b.y + b.height) + margin - Math.max(a.y, b.y);
+                if (overlapX <= 0 || overlapY <= 0)
+                    continue; // an earlier push freed it
+                // Minimum-translation axis, split evenly so the pair's midpoint — and
+                // with it the picture's balance — stays put.
+                if (overlapX <= overlapY) {
+                    const push = overlapX / 2;
+                    if (a.x <= b.x) {
+                        a.x -= push;
+                        b.x += push;
+                    }
+                    else {
+                        a.x += push;
+                        b.x -= push;
+                    }
+                }
+                else {
+                    const push = overlapY / 2;
+                    if (a.y <= b.y) {
+                        a.y -= push;
+                        b.y += push;
+                    }
+                    else {
+                        a.y += push;
+                        b.y -= push;
+                    }
+                }
+            }
+        }
+        for (const box of boxes) {
+            positions.set(box.id, { x: box.x, y: box.y });
+        }
+        return positions;
+    }
+    /**
+     * Calculate bounding box
+     */
+    calculateBounds(points) {
+        if (points.length === 0) {
+            return { x: 0, y: 0, width: 0, height: 0 };
+        }
+        let minX = Infinity, minY = Infinity;
+        let maxX = -Infinity, maxY = -Infinity;
+        for (const node of points) {
+            minX = Math.min(minX, node.x);
+            minY = Math.min(minY, node.y);
+            maxX = Math.max(maxX, node.x);
+            maxY = Math.max(maxY, node.y);
+        }
+        // Add padding
+        const padding = 50;
+        minX -= padding;
+        minY -= padding;
+        maxX += padding;
+        maxY += padding;
+        return {
+            x: minX,
+            y: minY,
+            width: maxX - minX,
+            height: maxY - minY,
+        };
+    }
+    /**
+     * Apply incremental layout (Phase 1 compatibility)
+     */
+    applyIncremental(nodes, links, incrementalOptions, layoutOptions) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            // Force-directed layout doesn't support true incremental layout
+            // Just apply full layout
+            const result = yield this.apply(nodes, links, layoutOptions);
+            return Object.assign(Object.assign({}, result), { incremental: {
+                    newNodeIds: incrementalOptions.newNodeIds || [],
+                    pinnedNodeIds: [],
+                    movedNodeIds: nodes.map(n => n.id),
+                    strategy: 'full-relayout',
+                    constraintsApplied: 0,
+                } });
+        });
+    }
+    /**
+     * Validate options
+     */
+    validateOptions(options) {
+        if (options.repulsion !== undefined && options.repulsion < 0) {
+            return false;
+        }
+        if (options.attraction !== undefined && options.attraction < 0) {
+            return false;
+        }
+        if (options.iterations !== undefined && options.iterations < 1) {
+            return false;
+        }
+        if (options.cooling !== undefined && (options.cooling <= 0 || options.cooling > 1)) {
+            return false;
+        }
+        if (options.theta !== undefined && (options.theta <= 0 || options.theta > 1)) {
+            return false;
+        }
+        return true;
+    }
+}
+exports.ForceLayoutAdapter = ForceLayoutAdapter;
+//# sourceMappingURL=force-layout-adapter.js.map