npm - @viamrobotics/motion-tools - Versions diffs - 1.33.0 → 1.33.2 - Mend

@viamrobotics/motion-tools 1.33.0 → 1.33.2

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (60) hide show

package/dist/components/Entities/labelLayout/createLabelLayout.js ADDED Viewed

@@ -0,0 +1,194 @@
+/**
+ * The label layout engine. Owns node lifecycle and the per-frame pipeline:
+ * a cheap dirty gate, then (only when dirty) measure → build neighbourhood →
+ * warm-start → solve → handle teleports, and every animating frame ease toward
+ * the solved targets and write them to the DOM. It idles (no work, no
+ * invalidate) once the camera is still and every label has settled.
+ */
+import { applyTeleports } from './applyTeleports';
+import { buildNeighborhood } from './buildNeighborhood';
+import { cameraMatrixHash } from './cameraHash';
+import { measureNode } from './measure';
+import { generateSlots, hashString } from './slots';
+import { solve } from './solve';
+import { SpatialHash } from './spatialHash';
+import { defaultSolverConfig } from './types';
+import { lerpStep, writeBack } from './writeBack';
+/** Clamp the frame delta so a long idle gap can't make the ease overshoot. */
+const MAX_DELTA = 0.05;
+/** Frames to keep retrying a failed measure after a real change before giving up (idle). */
+const MAX_RETRY = 4;
+export function createLabelLayout(deps) {
+    const config = { ...defaultSolverConfig, ...deps.config };
+    const nodesByLabel = new WeakMap();
+    const grid = new SpatialHash();
+    let activeNodes = [];
+    let bestSnap = new Int16Array(0);
+    let lastCamHash = -1;
+    let lastSetVersion = -1;
+    let pendingRetry = false;
+    let retryBudget = 0;
+    let animating = false;
+    function ensureNode(labelEl) {
+        const existing = nodesByLabel.get(labelEl);
+        if (existing)
+            return existing;
+        const textEl = labelEl.querySelector('.text');
+        const dotEl = labelEl.querySelector('.dot');
+        const lineEl = labelEl.querySelector('.link line');
+        if (!textEl || !dotEl || !lineEl)
+            return null;
+        textEl.style.willChange = 'transform';
+        const id = crypto.randomUUID();
+        const node = {
+            id,
+            idHash: hashString(id),
+            ax: 0,
+            ay: 0,
+            dotR: 0,
+            w: 0,
+            h: 0,
+            scale: 1,
+            cssDotW: 0,
+            dotLocalX: Number.NaN,
+            dotLocalY: Number.NaN,
+            slots: [],
+            geomKey: '',
+            crowded: false,
+            slotIndex: -1,
+            prevSlotIndex: -1,
+            cx: Number.NaN,
+            cy: Number.NaN,
+            tx: 0,
+            ty: 0,
+            settled: false,
+            conflict: 0,
+            locked: false,
+            centroidX: 0,
+            centroidY: 0,
+            prevAx: Number.NaN,
+            prevAy: Number.NaN,
+            neighbors: [],
+            labelEl,
+            textEl,
+            dotEl,
+            lineEl,
+        };
+        nodesByLabel.set(labelEl, node);
+        return node;
+    }
+    function geomKey(node) {
+        return `${Math.round(node.w)}_${Math.round(node.h)}_${Math.round(node.dotR)}`;
+    }
+    function nearestSlot(node) {
+        let best = 0;
+        let bestDist = Number.POSITIVE_INFINITY;
+        for (let i = 0; i < node.slots.length; i++) {
+            const sx = node.ax + node.slots[i].dx;
+            const sy = node.ay + node.slots[i].dy;
+            const d = (sx - node.cx) ** 2 + (sy - node.cy) ** 2;
+            if (d < bestDist) {
+                bestDist = d;
+                best = i;
+            }
+        }
+        return best;
+    }
+    function solveLayout(width, height) {
+        pendingRetry = false;
+        activeNodes = [];
+        for (const el of deps.labels.current) {
+            // Skip detached or hidden islands (e.g. <HTML> sets display:none when an
+            // entity is behind the camera) without arming a retry — they have no
+            // client rects, and treating them as "not ready" would pin the
+            // on-demand loop re-solving every frame.
+            if (!el.isConnected || el.getClientRects().length === 0)
+                continue;
+            const node = ensureNode(el);
+            if (!node) {
+                pendingRetry = true;
+                continue;
+            }
+            if (measureNode(node))
+                activeNodes.push(node);
+            else
+                pendingRetry = true;
+        }
+        const nodes = activeNodes;
+        const n = nodes.length;
+        if (n === 0)
+            return;
+        buildNeighborhood(grid, nodes, config);
+        // Crowding (post-symmetrisation) drives adaptive slot density.
+        for (const node of nodes) {
+            const crowded = node.neighbors.length > config.crowdedThreshold;
+            const key = geomKey(node);
+            if (key !== node.geomKey || crowded !== node.crowded) {
+                node.slots = generateSlots(node, crowded, config);
+                node.geomKey = key;
+                node.crowded = crowded;
+                node.slotIndex = -1;
+            }
+        }
+        // Local cluster centroid for the outward-fan term.
+        for (const node of nodes) {
+            let sx = node.ax;
+            let sy = node.ay;
+            for (const m of node.neighbors) {
+                sx += m.ax;
+                sy += m.ay;
+            }
+            const count = node.neighbors.length + 1;
+            node.centroidX = sx / count;
+            node.centroidY = sy / count;
+        }
+        // Warm-start: fresh nodes start near their dot, then snap onto the lattice.
+        for (const node of nodes) {
+            if (Number.isNaN(node.cx)) {
+                node.cx = node.ax + (node.w / 2 + node.dotR + config.dotPadding);
+                node.cy = node.ay;
+            }
+            if (node.slotIndex < 0 || node.slotIndex >= node.slots.length) {
+                node.slotIndex = nearestSlot(node);
+            }
+        }
+        if (bestSnap.length < n)
+            bestSnap = new Int16Array(n);
+        solve(nodes, config, bestSnap);
+        // A big camera jump (or a brand-new node) snaps labels to their solved
+        // target; everything else eases there from its current position.
+        applyTeleports(nodes, width, height, config);
+    }
+    function frame(delta) {
+        const { width, height } = deps.size.current;
+        const camHash = cameraMatrixHash(deps.camera.current, width, height);
+        const setVersion = deps.labels.version;
+        // A real change (camera/label-set) re-arms the retry window; pendingRetry can
+        // then drive a few more solves for genuinely-transient unmeasurable labels
+        // (first paint) without spinning forever on a persistently-unmeasurable one.
+        const changed = camHash !== lastCamHash || setVersion !== lastSetVersion;
+        if (changed)
+            retryBudget = MAX_RETRY;
+        const retrying = pendingRetry && retryBudget > 0 && !changed;
+        if (retrying)
+            retryBudget--;
+        const dirty = changed || retrying;
+        if (dirty) {
+            solveLayout(width, height);
+            lastCamHash = camHash;
+            lastSetVersion = setVersion;
+        }
+        if (!dirty && !animating)
+            return;
+        const dt = Math.min(delta, MAX_DELTA);
+        let moving = false;
+        for (const node of activeNodes) {
+            if (lerpStep(node, dt, config.settleEps))
+                moving = true;
+            writeBack(node);
+        }
+        animating = moving;
+        deps.invalidate();
+    }
+    return { frame };
+}

package/dist/components/Entities/labelLayout/geometry.d.ts ADDED Viewed

@@ -0,0 +1,20 @@
+/**
+ * Pure 2D geometry primitives used by the label layout cost function.
+ *
+ * Rectangles are center + half-extents; segments are flat coordinates. None of
+ * these allocate, so they are safe to call inside the solver's hot loop.
+ */
+import type { Rect, Segment } from './types';
+export declare function rectsOverlap(a: Rect, b: Rect, pad?: number): boolean;
+/** Fraction of the smaller rectangle's area covered by the intersection, 0..1. */
+export declare function overlapAreaFrac(a: Rect, b: Rect): number;
+/**
+ * Continuous penetration: how much of the segment lies inside the rectangle,
+ * as a fraction of segment length (0 = disjoint, 1 = fully inside). Gives the
+ * optimizer a gradient that the boolean test lacks.
+ */
+export declare function segmentRectPenetration(s: Segment, r: Rect): number;
+/** Proper crossing of two segments (shared endpoints / collinear touching excluded). */
+export declare function segmentsCross(a: Segment, b: Segment): boolean;
+/** Penetration depth (viewport px) of a circle into a rectangle, 0 if disjoint. */
+export declare function rectCircleOverlap(r: Rect, cx: number, cy: number, rad: number): number;

package/dist/components/Entities/labelLayout/geometry.js ADDED Viewed

@@ -0,0 +1,151 @@
+/**
+ * Pure 2D geometry primitives used by the label layout cost function.
+ *
+ * Rectangles are center + half-extents; segments are flat coordinates. None of
+ * these allocate, so they are safe to call inside the solver's hot loop.
+ */
+export function rectsOverlap(a, b, pad = 0) {
+    return Math.abs(a.cx - b.cx) < a.hw + b.hw + pad && Math.abs(a.cy - b.cy) < a.hh + b.hh + pad;
+}
+/** Fraction of the smaller rectangle's area covered by the intersection, 0..1. */
+export function overlapAreaFrac(a, b) {
+    const ox = Math.min(a.cx + a.hw, b.cx + b.hw) - Math.max(a.cx - a.hw, b.cx - b.hw);
+    if (ox <= 0)
+        return 0;
+    const oy = Math.min(a.cy + a.hh, b.cy + b.hh) - Math.max(a.cy - a.hh, b.cy - b.hh);
+    if (oy <= 0)
+        return 0;
+    return (ox * oy) / Math.min(4 * a.hw * a.hh, 4 * b.hw * b.hh);
+}
+/**
+ * Liang-Barsky clip of a segment against a rectangle.
+ * Returns the clipped length as a fraction of the full segment (0..1), or -1 if
+ * the segment misses the rectangle entirely.
+ */
+function clipFraction(s, r) {
+    const minX = r.cx - r.hw;
+    const maxX = r.cx + r.hw;
+    const minY = r.cy - r.hh;
+    const maxY = r.cy + r.hh;
+    const dx = s.x2 - s.x1;
+    const dy = s.y2 - s.y1;
+    let t0 = 0;
+    let t1 = 1;
+    let p;
+    let q;
+    let t;
+    // Four clip edges, inlined to avoid per-call allocation in the hot loop.
+    // Each edge is a (p, q) pair; the point is inside when p*t <= q holds.
+    p = -dx;
+    q = s.x1 - minX;
+    if (p === 0) {
+        if (q < 0)
+            return -1;
+    }
+    else {
+        t = q / p;
+        if (p < 0) {
+            if (t > t1)
+                return -1;
+            if (t > t0)
+                t0 = t;
+        }
+        else {
+            if (t < t0)
+                return -1;
+            if (t < t1)
+                t1 = t;
+        }
+    }
+    p = dx;
+    q = maxX - s.x1;
+    if (p === 0) {
+        if (q < 0)
+            return -1;
+    }
+    else {
+        t = q / p;
+        if (p < 0) {
+            if (t > t1)
+                return -1;
+            if (t > t0)
+                t0 = t;
+        }
+        else {
+            if (t < t0)
+                return -1;
+            if (t < t1)
+                t1 = t;
+        }
+    }
+    p = -dy;
+    q = s.y1 - minY;
+    if (p === 0) {
+        if (q < 0)
+            return -1;
+    }
+    else {
+        t = q / p;
+        if (p < 0) {
+            if (t > t1)
+                return -1;
+            if (t > t0)
+                t0 = t;
+        }
+        else {
+            if (t < t0)
+                return -1;
+            if (t < t1)
+                t1 = t;
+        }
+    }
+    p = dy;
+    q = maxY - s.y1;
+    if (p === 0) {
+        if (q < 0)
+            return -1;
+    }
+    else {
+        t = q / p;
+        if (p < 0) {
+            if (t > t1)
+                return -1;
+            if (t > t0)
+                t0 = t;
+        }
+        else {
+            if (t < t0)
+                return -1;
+            if (t < t1)
+                t1 = t;
+        }
+    }
+    return t0 <= t1 ? t1 - t0 : -1;
+}
+/**
+ * Continuous penetration: how much of the segment lies inside the rectangle,
+ * as a fraction of segment length (0 = disjoint, 1 = fully inside). Gives the
+ * optimizer a gradient that the boolean test lacks.
+ */
+export function segmentRectPenetration(s, r) {
+    const f = clipFraction(s, r);
+    return Math.max(f, 0);
+}
+function ccw(ax, ay, bx, by, px, py) {
+    return (bx - ax) * (py - ay) - (by - ay) * (px - ax);
+}
+/** Proper crossing of two segments (shared endpoints / collinear touching excluded). */
+export function segmentsCross(a, b) {
+    const d1 = ccw(b.x1, b.y1, b.x2, b.y2, a.x1, a.y1);
+    const d2 = ccw(b.x1, b.y1, b.x2, b.y2, a.x2, a.y2);
+    const d3 = ccw(a.x1, a.y1, a.x2, a.y2, b.x1, b.y1);
+    const d4 = ccw(a.x1, a.y1, a.x2, a.y2, b.x2, b.y2);
+    return d1 > 0 !== d2 > 0 && d3 > 0 !== d4 > 0;
+}
+/** Penetration depth (viewport px) of a circle into a rectangle, 0 if disjoint. */
+export function rectCircleOverlap(r, cx, cy, rad) {
+    const nx = Math.max(Math.abs(cx - r.cx) - r.hw, 0);
+    const ny = Math.max(Math.abs(cy - r.cy) - r.hh, 0);
+    const d = Math.sqrt(nx * nx + ny * ny);
+    return Math.max(rad - d, 0);
+}

package/dist/components/Entities/labelLayout/labelStore.svelte.d.ts ADDED Viewed

@@ -0,0 +1,17 @@
+/**
+ * Registry of live label root elements (`.label`) shared between the per-entity
+ * `Label.svelte` components (which add/remove themselves) and the layout engine
+ * (which reads them each solve).
+ *
+ * `version` is bumped on every structural or text change so the engine can cheaply
+ * detect that a re-solve is needed without diffing the DOM.
+ */
+export declare class LabelStore {
+    current: HTMLElement[];
+    version: number;
+    add(element: HTMLElement): void;
+    remove(element: HTMLElement): void;
+    /** Signal that a label's text (and therefore its measured size) may have changed. */
+    touch(): void;
+}
+export declare const labels: LabelStore;

package/dist/components/Entities/labelLayout/labelStore.svelte.js ADDED Viewed

@@ -0,0 +1,28 @@
+/**
+ * Registry of live label root elements (`.label`) shared between the per-entity
+ * `Label.svelte` components (which add/remove themselves) and the layout engine
+ * (which reads them each solve).
+ *
+ * `version` is bumped on every structural or text change so the engine can cheaply
+ * detect that a re-solve is needed without diffing the DOM.
+ */
+export class LabelStore {
+    current = $state([]);
+    version = $state(0);
+    add(element) {
+        this.current.push(element);
+        this.version += 1;
+    }
+    remove(element) {
+        const index = this.current.indexOf(element);
+        if (index !== -1) {
+            this.current.splice(index, 1);
+            this.version += 1;
+        }
+    }
+    /** Signal that a label's text (and therefore its measured size) may have changed. */
+    touch() {
+        this.version += 1;
+    }
+}
+export const labels = new LabelStore();

package/dist/components/Entities/labelLayout/measure.d.ts ADDED Viewed

@@ -0,0 +1,13 @@
+/**
+ * Reads a label's on-screen geometry from the DOM. This is the only place that
+ * forces layout (getBoundingClientRect / getComputedStyle), and the engine calls
+ * it for every node in one batch at the top of a solve — all reads before any
+ * writes — so the per-frame read/write thrash of the old engine is gone.
+ */
+import type { LabelNode } from './types';
+/**
+ * Refresh `node`'s anchor, size, and scale from the DOM.
+ * Returns false if the label isn't measurable yet (detached or not laid out),
+ * in which case the caller skips it this solve and retries.
+ */
+export declare function measureNode(node: LabelNode): boolean;

package/dist/components/Entities/labelLayout/measure.js ADDED Viewed

@@ -0,0 +1,42 @@
+/**
+ * Reads a label's on-screen geometry from the DOM. This is the only place that
+ * forces layout (getBoundingClientRect / getComputedStyle), and the engine calls
+ * it for every node in one batch at the top of a solve — all reads before any
+ * writes — so the per-frame read/write thrash of the old engine is gone.
+ */
+/** CSS size of the dot (`.dot` is Tailwind `h-2 w-2` = 8px); used only as a scale fallback. */
+const DOT_CSS_FALLBACK = 8;
+/**
+ * Refresh `node`'s anchor, size, and scale from the DOM.
+ * Returns false if the label isn't measurable yet (detached or not laid out),
+ * in which case the caller skips it this solve and retries.
+ */
+export function measureNode(node) {
+    if (!node.labelEl.isConnected)
+        return false;
+    const dot = node.dotEl.getBoundingClientRect();
+    const text = node.textEl.getBoundingClientRect();
+    if (dot.width === 0 || text.width === 0)
+        return false;
+    const dotCenterX = dot.left + dot.width / 2;
+    const dotCenterY = dot.top + dot.height / 2;
+    node.ax = dotCenterX;
+    node.ay = dotCenterY;
+    node.dotR = dot.width / 2;
+    node.w = text.width;
+    node.h = text.height;
+    if (node.cssDotW === 0) {
+        node.cssDotW = Number.parseFloat(getComputedStyle(node.dotEl).width) || DOT_CSS_FALLBACK;
+    }
+    const s = dot.width / node.cssDotW;
+    node.scale = Number.isFinite(s) && s > 1e-4 ? s : 1;
+    // The dot's center relative to the island origin (the 0x0 `.label` box placed
+    // at the projected 3D point) is a fixed CSS layout offset — measure it once so
+    // the leader line starts at the dot wherever the dot's CSS positions it.
+    if (Number.isNaN(node.dotLocalX)) {
+        const island = node.labelEl.getBoundingClientRect();
+        node.dotLocalX = (dotCenterX - island.left) / node.scale;
+        node.dotLocalY = (dotCenterY - island.top) / node.scale;
+    }
+    return true;
+}

package/dist/components/Entities/labelLayout/slots.d.ts ADDED Viewed

@@ -0,0 +1,11 @@
+/**
+ * Candidate slot generation: concentric rings of radial directions around a dot.
+ *
+ * The inner radius per angle uses the AABB support function (tighter than a
+ * uniform half-diagonal, so cardinal placements sit closer), guaranteeing a
+ * node's own dot never enters its own box at any angle.
+ */
+import type { LabelNode, Slot, SolverConfig } from './types';
+export declare const generateSlots: (node: LabelNode, crowded: boolean, config: SolverConfig) => Slot[];
+/** FNV-1a hash of a string → unsigned 32-bit. */
+export declare const hashString: (s: string) => number;

package/dist/components/Entities/labelLayout/slots.js ADDED Viewed

@@ -0,0 +1,47 @@
+/**
+ * Candidate slot generation: concentric rings of radial directions around a dot.
+ *
+ * The inner radius per angle uses the AABB support function (tighter than a
+ * uniform half-diagonal, so cardinal placements sit closer), guaranteeing a
+ * node's own dot never enters its own box at any angle.
+ */
+import { W } from './cost';
+export const generateSlots = (node, crowded, config) => {
+    const angles = crowded ? config.anglesPerRing * 2 : config.anglesPerRing;
+    const rings = crowded ? config.ringRadiiCrowded : config.ringRadii;
+    // Deterministic per-node phase so neighbouring dots don't expose identical angles.
+    const phase = ((node.idHash % angles) / angles) * ((2 * Math.PI) / angles);
+    const halfW = node.w / 2;
+    const halfH = node.h / 2;
+    const slots = [];
+    for (let ring = 0; ring < rings.length; ring++) {
+        // Half-step stagger on odd rings so leaders interleave instead of stacking.
+        const stagger = ring % 2 ? Math.PI / angles : 0;
+        for (let k = 0; k < angles; k++) {
+            const angle = phase + stagger + (k / angles) * 2 * Math.PI;
+            const ct = Math.cos(angle);
+            const st = Math.sin(angle);
+            const support = Math.abs(ct) * halfW + Math.abs(st) * halfH;
+            const radius = (support + node.dotR + config.dotPadding) * rings[ring];
+            slots.push({
+                dx: ct * radius,
+                dy: st * radius,
+                angle,
+                radius,
+                ring,
+                baseCost: W.len * radius,
+            });
+        }
+    }
+    slots.sort((a, b) => a.baseCost - b.baseCost);
+    return slots;
+};
+/** FNV-1a hash of a string → unsigned 32-bit. */
+export const hashString = (s) => {
+    let h = 2166136261;
+    for (let i = 0; i < s.length; i++) {
+        h ^= s.charCodeAt(i);
+        h = Math.imul(h, 16777619);
+    }
+    return h >>> 0;
+};

package/dist/components/Entities/labelLayout/solve.d.ts ADDED Viewed

@@ -0,0 +1,11 @@
+/**
+ * Deterministic slot assignment via priority-ordered conflict-graph local search.
+ *
+ * Warm-started from each node's previously committed slot (set by the engine
+ * before this runs), it repeatedly moves the worst-conflict node to its lowest
+ * cost slot, re-scoring only the affected neighbourhood, until no node has a
+ * conflict or the move budget is spent. A best-total snapshot is restored at the
+ * end so a re-solve can never regress below where it started.
+ */
+import type { LabelNode, SolverConfig } from './types';
+export declare const solve: (nodes: LabelNode[], config: SolverConfig, bestSnap: Int16Array) => void;

package/dist/components/Entities/labelLayout/solve.js ADDED Viewed

@@ -0,0 +1,93 @@
+import { evalConflict, placementBias, W } from './cost';
+/** Conflicts below this are treated as resolved (floating-point slack). */
+const RESOLVED = 0.5;
+/**
+ * The slot that minimizes conflict (crossings/overlaps), breaking ties by the
+ * tidiness bias. Selection and the caller's acceptance gate share the conflict
+ * objective, so a node is never locked at a placement another slot would
+ * improve. The baseCost early-out applies only once conflict is already
+ * resolved — while a node still conflicts, every slot is considered.
+ */
+const bestSlot = (node, config) => {
+    const neighbors = node.neighbors;
+    let index = node.slotIndex;
+    let conflict = evalConflict(node, node.slotIndex, neighbors, config);
+    let bias = placementBias(node, node.slotIndex);
+    for (let s = 0; s < node.slots.length; s++) {
+        if (s === node.slotIndex)
+            continue;
+        // Slots are sorted ascending by baseCost; once conflict is resolved only
+        // tidiness remains, so no farther slot can beat the incumbent's bias.
+        if (conflict <= RESOLVED && node.slots[s].baseCost - W.stick >= bias)
+            break;
+        const c = evalConflict(node, s, neighbors, config);
+        const b = placementBias(node, s);
+        if (c < conflict - 1e-6 || (c <= conflict + 1e-6 && b < bias)) {
+            index = s;
+            conflict = c;
+            bias = b;
+        }
+    }
+    return { index, conflict };
+};
+export const solve = (nodes, config, bestSnap) => {
+    const n = nodes.length;
+    if (n === 0)
+        return;
+    for (const node of nodes)
+        node.prevSlotIndex = node.slotIndex;
+    const order = nodes.toSorted((a, b) => b.w * b.h - a.w * a.h || a.slots.length - b.slots.length || a.idHash - b.idHash);
+    let total = 0;
+    for (let i = 0; i < n; i++) {
+        const node = nodes[i];
+        node.conflict = evalConflict(node, node.slotIndex, node.neighbors, config);
+        node.locked = false;
+        total += node.conflict;
+    }
+    let bestE = total;
+    for (let i = 0; i < n; i++)
+        bestSnap[i] = nodes[i].slotIndex;
+    let budget = config.polishBudget;
+    while (budget > 0) {
+        let worst;
+        let worstConflict = RESOLVED;
+        for (let i = 0; i < n; i++) {
+            const node = order[i];
+            if (!node.locked && node.conflict > worstConflict) {
+                worstConflict = node.conflict;
+                worst = node;
+            }
+        }
+        if (!worst)
+            break;
+        const result = bestSlot(worst, config);
+        if (result.index !== worst.slotIndex && result.conflict < worst.conflict - RESOLVED) {
+            total += result.conflict - worst.conflict;
+            worst.slotIndex = result.index;
+            worst.conflict = result.conflict;
+            budget--;
+            // Moving `worst` changes the pairwise cost of its neighbors only.
+            for (const m of worst.neighbors) {
+                const before = m.conflict;
+                m.conflict = evalConflict(m, m.slotIndex, m.neighbors, config);
+                total += m.conflict - before;
+                m.locked = false;
+            }
+            if (total < bestE) {
+                bestE = total;
+                for (let i = 0; i < n; i++)
+                    bestSnap[i] = nodes[i].slotIndex;
+            }
+        }
+        else {
+            worst.locked = true;
+        }
+    }
+    for (let i = 0; i < n; i++) {
+        const node = nodes[i];
+        node.slotIndex = bestSnap[i];
+        const slot = node.slots[node.slotIndex];
+        node.tx = node.ax + slot.dx;
+        node.ty = node.ay + slot.dy;
+    }
+};

package/dist/components/Entities/labelLayout/spatialHash.d.ts ADDED Viewed

@@ -0,0 +1,15 @@
+/**
+ * Uniform grid over label anchors, used to prune the O(n^2) cost evaluation to a
+ * bounded neighborhood. The cell size is chosen so any two labels whose boxes
+ * could possibly interact share or border a cell, so scanning the 3x3 block
+ * around a node finds every candidate.
+ */
+import type { LabelNode } from './types';
+export declare class SpatialHash {
+    private cell;
+    private readonly buckets;
+    private static key;
+    build(nodes: LabelNode[], cell: number): void;
+    /** Nearest `max` nodes (by anchor distance) in the 3x3 cell block around `node`, excluding itself. */
+    queryNeighbors(node: LabelNode, max: number): LabelNode[];
+}