@expofp/wayfinding 3.11.11

package/dist/index.js

@@ -0,0 +1,13 @@
+/**
+ * `@expofp/wayfinding` — framework-neutral wayfinding: routing/snapping engine,
+ * an imperative runtime, and a scene renderer behind a single entry point.
+ */
+export { createWayfinding } from './createWayfinding.js';
+// Protocol sentinel: the host must stamp it as the `id` of a "current position"
+// route endpoint so the runtime renders that point as the live position.
+export { CURRENT_POSITION_POINT_ID } from './runtime/index.js';
+// Pure routing helper: orders waypoints for the shortest visiting sequence
+// (nearest-neighbour + 2-opt). Stateless and instance-free, so callers can plan
+// multi-stop routes before a wayfinding instance exists (e.g. the SDK
+// `getOptimizedRoutes`).
+export { optimizeWaypointOrder } from './core/routing/optimizeWaypointOrder.js';

package/dist/renderer/createWayfindingRenderer.d.ts

@@ -0,0 +1,14 @@
+import type { RendererPort, WayfindingRenderer, WayfindingRendererConfig } from './types.js';
+/**
+ * Create a {@link WayfindingRenderer} — the composition root that wires
+ * together {@link LayerManager}, {@link IconManager}, {@link TrailManager},
+ * and {@link RouteLineManager}.
+ *
+ * Exposes `applyScale`/`applyRoll`/`handleClick`/`handleHover` for the app glue
+ * to drive from engine events.
+ * @param rendererPort
+ * @param config
+ * @throws If `rendererPort.getLayers()` throws (e.g. the scene is not started).
+ */
+export declare function createWayfindingRenderer(rendererPort: RendererPort, config?: WayfindingRendererConfig): WayfindingRenderer;
+//# sourceMappingURL=createWayfindingRenderer.d.ts.map

package/dist/renderer/createWayfindingRenderer.js

@@ -0,0 +1,51 @@
+import { createIconManager } from './iconManager.js';
+import { createLayerManager } from './layerManager.js';
+import { createRouteLineManager } from './routeLineManager.js';
+import { createTrailManager } from './trailManager.js';
+const DEFAULT_COLORS = {
+    passed: '#B5B7BC',
+    remaining: '#A4CCE2',
+    active: '#0794EA',
+};
+/**
+ * Create a {@link WayfindingRenderer} — the composition root that wires
+ * together {@link LayerManager}, {@link IconManager}, {@link TrailManager},
+ * and {@link RouteLineManager}.
+ *
+ * Exposes `applyScale`/`applyRoll`/`handleClick`/`handleHover` for the app glue
+ * to drive from engine events.
+ * @param rendererPort
+ * @param config
+ * @throws If `rendererPort.getLayers()` throws (e.g. the scene is not started).
+ */
+export function createWayfindingRenderer(rendererPort, config = {}) {
+    const colors = { ...DEFAULT_COLORS, ...config.colors };
+    const layerManager = createLayerManager(rendererPort);
+    const iconManager = createIconManager(layerManager, rendererPort);
+    const trailManager = createTrailManager(layerManager, rendererPort);
+    const routeLineManager = createRouteLineManager(layerManager, colors, rendererPort);
+    const wfRenderer = {
+        setIcon: (...args) => iconManager.setIcon(...args),
+        clearIcons: (...args) => iconManager.clearIcons(...args),
+        setTrail: (...args) => trailManager.setTrail(...args),
+        setRouteLines: (...args) => routeLineManager.setRouteLines(...args),
+        applyScale: (scale) => [...iconManager.applyScale(scale), ...trailManager.applyScale(scale)],
+        applyRoll: (cameraAngle) => iconManager.applyRoll(cameraAngle),
+        handleClick: (defs) => iconManager.handleClick(defs),
+        handleHover: (defs) => iconManager.handleHover(defs),
+        clearRoute() {
+            routeLineManager.clearLines();
+            trailManager.destroy();
+            iconManager.hideAll();
+        },
+        flush: () => layerManager.flush(),
+        destroy() {
+            wfRenderer.clearRoute();
+            iconManager.destroy();
+            trailManager.destroy();
+            routeLineManager.destroy();
+            layerManager.destroy();
+        },
+    };
+    return wfRenderer;
+}

package/dist/renderer/iconManager.d.ts

@@ -0,0 +1,39 @@
+import type { RenderableDef } from '@expofp/renderer';
+import type { LayerManager } from './layerManager.js';
+import type { IconConfig, RendererPort } from './types.js';
+/**
+ * Manages `ImageDef` icons in the scene graph.
+ *
+ * Icons are keyed by `(name, key?)`. First `setIcon` creates the `ImageDef`;
+ * subsequent calls mutate in place. Pass `config: null` to hide an icon
+ * without destroying it.
+ *
+ * Exposes pure `applyScale`/`applyRoll`/`handleClick`/`handleHover` that the
+ * app glue drives from engine events.
+ */
+export interface IconManager {
+    /** Place, update, or hide an icon. See {@link WayfindingRenderer.setIcon}. */
+    setIcon(name: string, config: IconConfig | null, key?: string | number): void;
+    /** Hide all icons matching the given name(s). */
+    clearIcons(names: string | readonly string[]): void;
+    /** Hide every managed icon (used by `clearRoute`). */
+    hideAll(): void;
+    /** Clear internal state. */
+    destroy(): void;
+    /** Recompute bounds of all visible icons for `scale`; returns changed defs. */
+    applyScale(scale: number): RenderableDef[];
+    /** Apply camera roll to cardinal-snap icons; returns changed defs. */
+    applyRoll(cameraAngle: number): RenderableDef[];
+    /** Fire the first hit clickable icon's `onClick` from already-picked defs. */
+    handleClick(defs: readonly RenderableDef[]): void;
+    /** Whether a clickable icon is under the already-picked defs. */
+    handleHover(defs: readonly RenderableDef[]): boolean;
+}
+/**
+ * Create an {@link IconManager} that places `ImageDef` icons into layers
+ * managed by the given {@link LayerManager}.
+ * @param layerManager
+ * @param rendererPort
+ */
+export declare function createIconManager(layerManager: LayerManager, rendererPort: RendererPort): IconManager;
+//# sourceMappingURL=iconManager.d.ts.map

package/dist/renderer/iconManager.js

@@ -0,0 +1,166 @@
+import { Rect } from '@expofp/geometry';
+/**
+ * Create an {@link IconManager} that places `ImageDef` icons into layers
+ * managed by the given {@link LayerManager}.
+ * @param layerManager
+ * @param rendererPort
+ */
+export function createIconManager(layerManager, rendererPort) {
+    const icons = new Map();
+    const iconKeysByName = new Map();
+    const keyToName = new Map();
+    function composeKey(name, key) {
+        return key === undefined ? name : `${name}#${key}`;
+    }
+    function trackKey(name, iconKey) {
+        let nameKeys = iconKeysByName.get(name);
+        if (!nameKeys) {
+            nameKeys = new Set();
+            iconKeysByName.set(name, nameKeys);
+        }
+        nameKeys.add(iconKey);
+        keyToName.set(iconKey, name);
+    }
+    function untrackKey(iconKey) {
+        const name = keyToName.get(iconKey);
+        if (!name)
+            return;
+        const nameKeys = iconKeysByName.get(name);
+        if (nameKeys)
+            nameKeys.delete(iconKey);
+        keyToName.delete(iconKey);
+    }
+    function createIcon(iconKey, name, cfg) {
+        const layer = layerManager.touchLayer(cfg.layer);
+        const scale = rendererPort.getScale();
+        const def = rendererPort.createImageDef(cfg.canvas, new Rect({ x: cfg.x, y: cfg.y }, { x: cfg.canvas.width * scale, y: cfg.canvas.height * scale }, cfg.rotation), { hidden: cfg.hidden ?? false, dim: cfg.dimmed ?? false, origin: cfg.origin });
+        layer.children.push(def);
+        const record = {
+            imageDef: def,
+            layerName: cfg.layer,
+            cardinalSnap: cfg.cardinalSnap ?? false,
+            center: { x: cfg.x, y: cfg.y },
+            rotation: cfg.rotation,
+            callback: cfg.onClick ?? null,
+        };
+        icons.set(iconKey, record);
+        trackKey(name, iconKey);
+        return record;
+    }
+    function recreateIcon(iconKey, name, record, cfg) {
+        const oldLayer = layerManager.resolveLayer(record.layerName);
+        const oldChildren = oldLayer.children;
+        const idx = oldChildren.indexOf(record.imageDef);
+        if (idx >= 0)
+            oldChildren.splice(idx, 1);
+        layerManager.touchedLayers.set(record.layerName, oldLayer);
+        icons.delete(iconKey);
+        untrackKey(iconKey);
+        createIcon(iconKey, name, cfg);
+    }
+    function updateIcon(iconKey, name, record, cfg) {
+        if (record.layerName !== cfg.layer) {
+            throw new Error(`renderer: icon "${iconKey}" cannot move between layers (was "${record.layerName}", got "${cfg.layer}")`);
+        }
+        if (record.imageDef.source !== cfg.canvas) {
+            recreateIcon(iconKey, name, record, cfg);
+            return;
+        }
+        const scale = rendererPort.getScale();
+        record.imageDef.bounds = rendererPort.rectToRenderer(new Rect({ x: cfg.x, y: cfg.y }, { x: cfg.canvas.width * scale, y: cfg.canvas.height * scale }, cfg.rotation));
+        record.imageDef.hidden = cfg.hidden ?? false;
+        record.imageDef.dim = cfg.dimmed ?? false;
+        record.center = { x: cfg.x, y: cfg.y };
+        record.rotation = cfg.rotation;
+        record.callback = cfg.onClick ?? null;
+        layerManager.touchLayer(cfg.layer);
+    }
+    return {
+        setIcon(name, cfg, key) {
+            const iconKey = composeKey(name, key);
+            if (cfg === null) {
+                const record = icons.get(iconKey);
+                if (record) {
+                    record.imageDef.hidden = true;
+                    record.callback = null;
+                    layerManager.touchLayer(record.layerName);
+                }
+                return;
+            }
+            const existing = icons.get(iconKey);
+            if (existing)
+                updateIcon(iconKey, name, existing, cfg);
+            else
+                createIcon(iconKey, name, cfg);
+        },
+        clearIcons(names) {
+            const list = typeof names === 'string' ? [names] : names;
+            for (const name of list) {
+                const nameKeys = iconKeysByName.get(name);
+                if (!nameKeys)
+                    continue;
+                for (const iconKey of nameKeys) {
+                    const record = icons.get(iconKey);
+                    if (record) {
+                        record.imageDef.hidden = true;
+                        record.callback = null;
+                        layerManager.touchLayer(record.layerName);
+                    }
+                }
+            }
+        },
+        hideAll() {
+            for (const record of icons.values()) {
+                record.imageDef.hidden = true;
+                record.callback = null;
+                layerManager.touchedLayers.set(record.layerName, layerManager.resolveLayer(record.layerName));
+            }
+        },
+        destroy() {
+            icons.clear();
+            iconKeysByName.clear();
+            keyToName.clear();
+        },
+        applyScale(scale) {
+            const defs = [];
+            for (const record of icons.values()) {
+                if (record.imageDef.hidden)
+                    continue;
+                record.imageDef.bounds = rendererPort.rectToRenderer(new Rect(record.center, { x: record.imageDef.source.width * scale, y: record.imageDef.source.height * scale }, record.rotation));
+                defs.push(record.imageDef);
+            }
+            return defs;
+        },
+        applyRoll(cameraAngle) {
+            const defs = [];
+            for (const record of icons.values()) {
+                if (!record.cardinalSnap)
+                    continue;
+                const currentRotation = record.rotation ?? 0;
+                const delta = rendererPort.getRotation(cameraAngle, currentRotation);
+                if (delta === undefined)
+                    continue;
+                record.rotation = currentRotation + delta;
+                record.imageDef.bounds.rotation = record.rotation;
+                defs.push(record.imageDef);
+            }
+            return defs;
+        },
+        handleClick(defs) {
+            for (const record of icons.values()) {
+                if (record.callback && !record.imageDef.hidden && defs.includes(record.imageDef)) {
+                    record.callback();
+                    return;
+                }
+            }
+        },
+        handleHover(defs) {
+            for (const record of icons.values()) {
+                if (record.callback && !record.imageDef.hidden && defs.includes(record.imageDef)) {
+                    return true;
+                }
+            }
+            return false;
+        },
+    };
+}

package/dist/renderer/index.d.ts

@@ -0,0 +1,3 @@
+export { createWayfindingRenderer } from './createWayfindingRenderer.js';
+export type { IconConfig, RendererPort, WayfindingRenderer } from './types.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/renderer/index.js

@@ -0,0 +1 @@
+export { createWayfindingRenderer } from './createWayfindingRenderer.js';

package/dist/renderer/layerManager.d.ts

@@ -0,0 +1,27 @@
+import type { LayerDef } from '@expofp/renderer';
+import type { RendererPort } from './types.js';
+/**
+ * Manages scene layer resolution, caching, dirty-tracking, and flush.
+ *
+ * Layers are resolved by name from `rendererPort.getLayers()` and cached. `touchLayer`
+ * marks a layer as dirty; `flush` commits all dirty layers via `rendererPort.update`
+ * in a single call.
+ */
+export interface LayerManager {
+    /** Layers modified since the last {@link flush}. */
+    readonly touchedLayers: Map<string, LayerDef>;
+    /** Resolve a layer by name (cached). Throws if not found. */
+    resolveLayer(name: string): LayerDef;
+    /** Resolve a layer and mark it as dirty for the next {@link flush}. */
+    touchLayer(name: string): LayerDef;
+    /** Commit all dirty layers to `RendererService` and clear the dirty set. */
+    flush(): void;
+    /** Clear caches and dirty set. */
+    destroy(): void;
+}
+/**
+ * Create a {@link LayerManager} bound to the given {@link RendererPort}.
+ * @param rendererPort
+ */
+export declare function createLayerManager(rendererPort: RendererPort): LayerManager;
+//# sourceMappingURL=layerManager.d.ts.map

package/dist/renderer/layerManager.js

@@ -0,0 +1,40 @@
+/**
+ * Create a {@link LayerManager} bound to the given {@link RendererPort}.
+ * @param rendererPort
+ */
+export function createLayerManager(rendererPort) {
+    const allLayers = rendererPort.getLayers();
+    const layerCache = new Map();
+    const touchedLayers = new Map();
+    return {
+        touchedLayers,
+        resolveLayer(name) {
+            const cached = layerCache.get(name);
+            if (cached)
+                return cached;
+            const layer = allLayers.find((candidate) => candidate.name === name);
+            if (!layer)
+                throw new Error(`renderer: layer "${name}" not found in scene`);
+            layerCache.set(name, layer);
+            return layer;
+        },
+        touchLayer(name) {
+            const layer = this.resolveLayer(name);
+            touchedLayers.set(name, layer);
+            return layer;
+        },
+        flush() {
+            if (touchedLayers.size === 0)
+                return;
+            for (const layer of touchedLayers.values()) {
+                layer.children = [...layer.children];
+            }
+            rendererPort.update(...touchedLayers.values());
+            touchedLayers.clear();
+        },
+        destroy() {
+            touchedLayers.clear();
+            layerCache.clear();
+        },
+    };
+}

package/dist/renderer/lineAnimation.d.ts

@@ -0,0 +1,11 @@
+import type { Point2Like } from '@expofp/geometry';
+import type { LineDef } from '@expofp/renderer';
+export interface AnimationHandle {
+    stop: () => void;
+    getProgress: () => number;
+}
+export type AnimatedLineDef = Omit<LineDef, 'points'> & {
+    points: [Point2Like, Point2Like];
+};
+export declare function animateLineSegments(lineSegments: AnimatedLineDef[], callback: (segment: AnimatedLineDef, segmentIndex: number, reset: boolean) => void, getScale: () => number, startProgress?: number): AnimationHandle | undefined;
+//# sourceMappingURL=lineAnimation.d.ts.map

package/dist/renderer/lineAnimation.js

@@ -0,0 +1,127 @@
+export function animateLineSegments(lineSegments, callback, getScale, startProgress = 0) {
+    let currentSegmentIndex = 0;
+    let segmentProgress = 0;
+    let lastTimestamp = null;
+    let animationFrameId = null;
+    if (!lineSegments.length)
+        return;
+    const segmentLengths = lineSegments.map((s) => {
+        const dx = s.points[1].x - s.points[0].x;
+        const dy = s.points[1].y - s.points[0].y;
+        return Math.sqrt(dx * dx + dy * dy);
+    });
+    const totalLength = segmentLengths.reduce((a, b) => a + b, 0);
+    // A zero-length route would spin the per-frame while-loop forever.
+    if (!totalLength)
+        return;
+    const baseSpeed = Math.max(20, Math.min(totalLength / 2, 300));
+    function initFromProgress(progress) {
+        const targetDistance = (progress % 1) * totalLength;
+        let accumulated = 0;
+        currentSegmentIndex = 0;
+        segmentProgress = 0;
+        for (let i = 0; i < segmentLengths.length; i++) {
+            if (accumulated + segmentLengths[i] > targetDistance) {
+                currentSegmentIndex = i;
+                segmentProgress = targetDistance - accumulated;
+                break;
+            }
+            accumulated += segmentLengths[i];
+            if (i === segmentLengths.length - 1) {
+                currentSegmentIndex = 0;
+                segmentProgress = 0;
+            }
+        }
+    }
+    function updateSegment(segment, progress) {
+        const start = segment.points[0];
+        const end = segment.points[1];
+        const dx = end.x - start.x;
+        const dy = end.y - start.y;
+        const length = Math.sqrt(dx * dx + dy * dy);
+        const t = Math.min(progress / length, 1);
+        return {
+            points: [
+                { x: start.x, y: start.y },
+                { x: start.x + dx * t, y: start.y + dy * t },
+            ],
+            color: segment.color,
+            width: segment.width,
+        };
+    }
+    function animate(timestamp) {
+        lastTimestamp ??= timestamp;
+        const delta = (timestamp - lastTimestamp) / 1000;
+        lastTimestamp = timestamp;
+        const scale = getScale();
+        // A detached canvas (host element removed from the DOM on SPA navigation)
+        // reports a bogus ptScale (Infinity on a zero-size canvas). Anything but a
+        // positive finite scale poisons segmentProgress and spins the loop below,
+        // freezing the tab — skip the frame until a usable scale returns.
+        if (!(Number.isFinite(scale) && scale > 0)) {
+            animationFrameId = requestAnimationFrame(animate);
+            return;
+        }
+        const adjustedSpeed = baseSpeed * Math.sqrt(scale);
+        segmentProgress += adjustedSpeed * delta;
+        // Keep progress within a single lap. totalLength > 0 is guaranteed above, so
+        // the loop can advance at most lineSegments.length steps — it can never spin,
+        // whatever scale/delta the engine feeds in.
+        segmentProgress %= totalLength;
+        while (segmentProgress >= segmentLengths[currentSegmentIndex]) {
+            segmentProgress -= segmentLengths[currentSegmentIndex];
+            currentSegmentIndex++;
+            if (currentSegmentIndex >= lineSegments.length) {
+                currentSegmentIndex = 0;
+            }
+        }
+        const currentSegment = lineSegments[currentSegmentIndex];
+        const updatedSegment = updateSegment(currentSegment, segmentProgress);
+        callback(updatedSegment, currentSegmentIndex, false);
+        animationFrameId = requestAnimationFrame(animate);
+    }
+    function start() {
+        stop();
+        if (startProgress <= 0) {
+            currentSegmentIndex = 0;
+            segmentProgress = 0;
+        }
+        lastTimestamp = null;
+        animationFrameId = requestAnimationFrame(animate);
+    }
+    function stop() {
+        if (animationFrameId) {
+            cancelAnimationFrame(animationFrameId);
+            animationFrameId = null;
+            lastTimestamp = null;
+        }
+    }
+    function getProgress() {
+        if (totalLength <= 0)
+            return 0;
+        let accumulated = 0;
+        for (let i = 0; i < currentSegmentIndex; i++) {
+            accumulated += segmentLengths[i];
+        }
+        accumulated += segmentProgress;
+        return accumulated / totalLength;
+    }
+    function handleVisibilityChange() {
+        if (document.visibilityState === 'visible')
+            start();
+        else
+            stop();
+    }
+    if (startProgress > 0) {
+        initFromProgress(startProgress);
+    }
+    document.addEventListener('visibilitychange', handleVisibilityChange);
+    start();
+    return {
+        stop: () => {
+            stop();
+            document.removeEventListener('visibilitychange', handleVisibilityChange);
+        },
+        getProgress,
+    };
+}

package/dist/renderer/routeLineManager.d.ts

@@ -0,0 +1,44 @@
+import type { LayerManager } from './layerManager.js';
+import type { RendererPort, RouteColors } from './types.js';
+/**
+ * Manages static route lines (passed + remaining) and an animated overlay
+ * on the remaining segment.
+ */
+export interface RouteLineManager {
+    setRouteLines(passed: readonly {
+        readonly p0: {
+            x: number;
+            y: number;
+        };
+        readonly p1: {
+            x: number;
+            y: number;
+        };
+    }[], remaining: readonly {
+        readonly p0: {
+            x: number;
+            y: number;
+        };
+        readonly p1: {
+            x: number;
+            y: number;
+        };
+    }[], options: {
+        readonly linesLayer: string;
+        readonly animatedLinesLayer: string;
+        readonly resetAnimation?: boolean;
+    }): void;
+    /** Stop animation, wipe both lines layers. */
+    clearLines(): void;
+    /** Alias for {@link clearLines}. */
+    destroy(): void;
+}
+/**
+ * Create a {@link RouteLineManager} that renders `LineDef` segments
+ * into layers managed by the given {@link LayerManager}.
+ * @param layerManager
+ * @param colors
+ * @param rendererPort
+ */
+export declare function createRouteLineManager(layerManager: LayerManager, colors: RouteColors, rendererPort: RendererPort): RouteLineManager;
+//# sourceMappingURL=routeLineManager.d.ts.map

package/dist/renderer/routeLineManager.js

@@ -0,0 +1,62 @@
+import { animateLineSegments, } from './lineAnimation.js';
+/**
+ * Create a {@link RouteLineManager} that renders `LineDef` segments
+ * into layers managed by the given {@link LayerManager}.
+ * @param layerManager
+ * @param colors
+ * @param rendererPort
+ */
+export function createRouteLineManager(layerManager, colors, rendererPort) {
+    let animationHandle = null;
+    let lastLinesLayer = null;
+    let lastAnimatedLayer = null;
+    return {
+        setRouteLines(passed, remaining, options) {
+            const linesLayer = layerManager.touchLayer(options.linesLayer);
+            const animatedLayer = layerManager.touchLayer(options.animatedLinesLayer);
+            lastLinesLayer = linesLayer;
+            lastAnimatedLayer = animatedLayer;
+            const reset = options.resetAnimation ?? true;
+            let resumeFrom = 0;
+            if (animationHandle) {
+                if (!reset)
+                    resumeFrom = animationHandle.getProgress();
+                animationHandle.stop();
+                animationHandle = null;
+            }
+            const passedDefs = passed.map((seg) => rendererPort.createLineDef(seg, colors.passed));
+            const remainingDefs = remaining.map((seg) => rendererPort.createLineDef(seg, colors.remaining));
+            linesLayer.children = [...passedDefs, ...remainingDefs];
+            if (!remainingDefs.length) {
+                animatedLayer.children = [];
+                return;
+            }
+            const animatedDefs = remainingDefs.map((def) => ({
+                ...def,
+                color: colors.active,
+            }));
+            animationHandle =
+                animateLineSegments(animatedDefs, (line, idx, justReset) => {
+                    animatedLayer.children = justReset ? [] : [...animatedDefs.slice(0, idx), line];
+                    rendererPort.update(animatedLayer);
+                }, () => rendererPort.getScale(), resumeFrom) ?? null;
+        },
+        clearLines() {
+            if (animationHandle) {
+                animationHandle.stop();
+                animationHandle = null;
+            }
+            if (lastLinesLayer) {
+                lastLinesLayer.children = [];
+                layerManager.touchedLayers.set(lastLinesLayer.name, lastLinesLayer);
+            }
+            if (lastAnimatedLayer) {
+                lastAnimatedLayer.children = [];
+                layerManager.touchedLayers.set(lastAnimatedLayer.name, lastAnimatedLayer);
+            }
+        },
+        destroy() {
+            this.clearLines();
+        },
+    };
+}

package/dist/renderer/trailManager.d.ts

@@ -0,0 +1,32 @@
+import { type Point2Like } from '@expofp/geometry';
+import type { RenderableDef } from '@expofp/renderer';
+import type { LayerManager } from './layerManager.js';
+import type { RendererPort } from './types.js';
+/**
+ * Manages named trails of evenly-spaced dots between two points.
+ *
+ * On camera zoom the app glue calls `applyScale` so dots are recalculated and
+ * visual spacing stays constant.
+ */
+export interface TrailManager {
+    /**
+     * Place, update, or remove a named trail.
+     * Pass `from/to = null` to remove the trail.
+     */
+    setTrail(name: string, from: Point2Like | null, to: Point2Like | null, options?: {
+        readonly canvas: HTMLCanvasElement;
+        readonly layer: string;
+    }): void;
+    /** Redraw all trails for `scale`; returns changed layer defs. */
+    applyScale(scale: number): RenderableDef[];
+    /** Remove all trails. */
+    destroy(): void;
+}
+/**
+ * Create a {@link TrailManager} that renders dot trails into layers
+ * managed by the given {@link LayerManager}.
+ * @param layerManager
+ * @param rendererPort
+ */
+export declare function createTrailManager(layerManager: LayerManager, rendererPort: RendererPort): TrailManager;
+//# sourceMappingURL=trailManager.d.ts.map