@viamrobotics/motion-tools 1.32.0 → 1.33.1

package/dist/components/Entities/labelLayout/cost.js

@@ -0,0 +1,126 @@
+/**
+ * Cost function for a candidate label placement. Lower is better.
+ *
+ * The hierarchy `lineBox >> boxDot > boxBox > lineLine >> stick > spread > len`
+ * is near-lexicographic: a single leader passing under another label always
+ * outranks fixing every overlap a node could have against its <=24 neighbors,
+ * so the optimizer eliminates crossings first (the user's top priority), then
+ * dot coverage, then box overlaps, then tidies the radial fan.
+ */
+import { overlapAreaFrac, rectCircleOverlap, rectsOverlap, segmentRectPenetration, segmentsCross, } from './geometry';
+export const W = {
+    /** DOMINANT — a leader passing under ANOTHER label's box. Requirement #1. */
+    lineBox: 1000,
+    /** Our box covering another node's dot. Worse than a box overlap. Requirement #4. */
+    boxDot: 200,
+    /** Two label boxes overlapping. Requirement #2. */
+    boxBox: 120,
+    /** Two leaders crossing — thin lines, mild. Supports the radial fan. */
+    lineLine: 60,
+    /** Sticky bonus for staying on the previous slot (anti flip-flop). Requirement #6. */
+    stick: 35,
+    /** Penalty when a slot's angle nearly coincides with a neighbor's leader angle. */
+    spread: 15,
+    /** Outward-fan preference: cheaper to point away from the local cluster. Requirement #3. */
+    radial: 0.8,
+    /** Leader length — keep labels close to their dot. Small. */
+    len: 0.6,
+};
+/** Slot angles closer than this (radians, ~18deg) are penalised for an even fan. */
+const SPREAD_ANGLE = 0.314;
+// Reused scratch — the solver is single-threaded and never re-enters evalConflict.
+const boxA = { cx: 0, cy: 0, hw: 0, hh: 0 };
+const boxB = { cx: 0, cy: 0, hw: 0, hh: 0 };
+const boxPad = { cx: 0, cy: 0, hw: 0, hh: 0 };
+const segA = { x1: 0, y1: 0, x2: 0, y2: 0 };
+const segB = { x1: 0, y1: 0, x2: 0, y2: 0 };
+/**
+ * The geometric "bad" terms only (leader-under-box, box-over-dot, box-box,
+ * leader-leader, angular spread) for placing `node` at slot `si` against its
+ * committed neighbors. This is the local-search objective AND its termination
+ * guard — exactly 0 when the node has no crossings/overlaps. The solver both
+ * selects and accepts moves on this value so it can never lock a node at a
+ * placement whose conflict another available slot would reduce.
+ */
+export function evalConflict(node, si, neighbors, config) {
+    const s = node.slots[si];
+    const cx = node.ax + s.dx;
+    const cy = node.ay + s.dy;
+    boxA.cx = cx;
+    boxA.cy = cy;
+    boxA.hw = node.w / 2;
+    boxA.hh = node.h / 2;
+    segA.x1 = node.ax;
+    segA.y1 = node.ay;
+    segA.x2 = cx;
+    segA.y2 = cy;
+    const halfPad = config.labelPadding / 2;
+    let cost = 0;
+    for (let t = 0; t < neighbors.length; t++) {
+        const m = neighbors[t];
+        const ms = m.slots[m.slotIndex];
+        const mx = m.ax + ms.dx;
+        const my = m.ay + ms.dy;
+        boxB.cx = mx;
+        boxB.cy = my;
+        boxB.hw = m.w / 2;
+        boxB.hh = m.h / 2;
+        segB.x1 = m.ax;
+        segB.y1 = m.ay;
+        segB.x2 = mx;
+        segB.y2 = my;
+        // Our leader under their box (expanded so a grazing line still reads as a crossing).
+        boxPad.cx = mx;
+        boxPad.cy = my;
+        boxPad.hw = m.w / 2 + halfPad;
+        boxPad.hh = m.h / 2 + halfPad;
+        const p1 = segmentRectPenetration(segA, boxPad);
+        if (p1 > 0)
+            cost += W.lineBox * p1;
+        // Their leader under our box.
+        boxPad.cx = cx;
+        boxPad.cy = cy;
+        boxPad.hw = node.w / 2 + halfPad;
+        boxPad.hh = node.h / 2 + halfPad;
+        const p2 = segmentRectPenetration(segB, boxPad);
+        if (p2 > 0)
+            cost += W.lineBox * p2;
+        // Our box covering their dot.
+        const dotClearance = m.dotR + config.dotPadding;
+        const d = rectCircleOverlap(boxA, m.ax, m.ay, dotClearance);
+        if (d > 0)
+            cost += W.boxDot * (d / dotClearance);
+        // Box-box overlap (binary dominates; area term provides a separation gradient).
+        if (rectsOverlap(boxA, boxB, config.labelPadding)) {
+            cost += W.boxBox + 2 * overlapAreaFrac(boxA, boxB);
+        }
+        // Leader-leader crossing.
+        if (segmentsCross(segA, segB))
+            cost += W.lineLine;
+        // Angular spread for an even fan.
+        let dd = Math.abs(s.angle - ms.angle);
+        if (dd > Math.PI)
+            dd = 2 * Math.PI - dd;
+        if (dd < SPREAD_ANGLE)
+            cost += W.spread;
+    }
+    return cost;
+}
+/**
+ * Conflict-independent "tidiness" of a slot: short leaders, pointing away from
+ * the local cluster centroid (radial fan-out), with a bonus for staying put.
+ * Used only as a tie-break among slots of equal conflict, never to override a
+ * conflict reduction.
+ */
+export function placementBias(node, si) {
+    const s = node.slots[si];
+    let cost = W.len * s.radius;
+    const cax = node.centroidX - node.ax;
+    const cay = node.centroidY - node.ay;
+    const cl = Math.sqrt(cax * cax + cay * cay) || 1;
+    const align = (Math.cos(s.angle) * -cax + Math.sin(s.angle) * -cay) / cl;
+    cost += W.radial * (1 - align) * s.radius;
+    if (si === node.prevSlotIndex)
+        cost -= W.stick;
+    return cost;
+}

package/dist/components/Entities/labelLayout/createLabelLayout.d.ts

@@ -0,0 +1,27 @@
+/**
+ * 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 type { Camera } from 'three';
+import type { LabelStore } from './labelStore.svelte';
+import { type SolverConfig } from './types';
+export interface LayoutDeps {
+    camera: {
+        current: Camera;
+    };
+    size: {
+        current: {
+            width: number;
+            height: number;
+        };
+    };
+    invalidate: () => void;
+    labels: LabelStore;
+    config?: Partial<SolverConfig>;
+}
+export declare function createLabelLayout(deps: LayoutDeps): {
+    frame: (delta: number) => void;
+};

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

@@ -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

@@ -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

@@ -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

@@ -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

@@ -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

@@ -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

@@ -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

@@ -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

@@ -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;
+};