@expofp/wayfinding 3.33.0 → 3.34.1

package/dist/renderer/routeLineManager.js

@@ -1,16 +1,27 @@
 import { animateLineSegments } from './lineAnimation.js';
+/**
+ * Builds one route line. The points are copied rather than aliased: the caller keeps its segments,
+ * and the animated overlay replaces its own `points` as the head travels.
+ * @param seg - The segment to draw.
+ * @param color - Stroke color.
+ * @returns The def.
+ */
+function lineDef({ p0, p1 }, color) {
+    return { points: { p0: { x: p0.x, y: p0.y }, p1: { x: p1.x, y: p1.y } }, color, width: 10 };
+}
 /**
  * Create a {@link RouteLineManager} that renders `LineDef` segments
  * into layers managed by the given {@link LayerManager}.
- * @param layerManager - Where the lines are placed and dirt is tracked.
+ * @param layerManager - Tracks what changed.
  * @param colors - The route palette.
  * @param port - The commit function the animation ticks through.
+ * @param layers - The two line layers to draw into.
  * @returns The manager.
  */
-export function createRouteLineManager(layerManager, colors, port) {
+export function createRouteLineManager(layerManager, colors, port, layers) {
+    const linesLayer = layers.lines;
+    const animatedLayer = layers.linesAnimated;
     let animationHandle = null;
-    let lastLinesLayer = null;
-    let lastAnimatedLayer = null;
     /**
      * The pixel size the chase animation modulates its speed by. Route lines need no layout of their
      * own — `LineDef.width` is already in screen pixels — so this is the one thing the animated layer's
@@ -28,40 +39,38 @@ export function createRouteLineManager(layerManager, colors, port) {
         currentPixelSize = pixelSize;
     }
     /**
-     * Empties one lines layer, hiding each def in place first.
-     *
-     * The hide is not redundant with the removal. The renderer commits a def write synchronously but
-     * defers a membership sweep — renderer's `useStagedChildren` (`objects/layer/
-     * mount-scheduler.ts`) pipes a layer's children through `useDeferredValue`, so the unmount that
-     * releases the removed instances lands a transition commit later. Lines that were only removed
-     * therefore outlived the route's icons — which `hideIcon` hides in place — by a frame or more,
-     * and the cleared route's line visibly lingered behind its pins. Hiding first puts the whole
-     * teardown in the same synchronous commit; the deferred sweep then releases slots that are
-     * already invisible. Drop the hides if the renderer ever hides departed defs urgently itself
-     * (the place to do it is `useStagedChildren`, where the fresh snapshot and the deferred children
-     * are both at hand).
-     * @param layer - The layer to empty, when it is known yet.
+     * Empties one lines layer, hiding what it held first — see {@link hideDeparting}.
+     * @param layer - The layer to empty.
      */
     function wipe(layer) {
-        if (!layer)
-            return;
+        hideDeparting(layer);
+        layer.children = [];
+        layerManager.touchLayer(layer);
+    }
+    /**
+     * Hides every line a layer still holds, before whatever replaces them.
+     *
+     * The renderer commits a def write synchronously but defers the membership sweep — renderer's
+     * `useStagedChildren` (`objects/layer/mount-scheduler.ts`) pipes a layer's children through
+     * `useDeferredValue` — so lines that were only removed outlive the route's icons, which
+     * `hideIcon` hides in place, by a frame or more. That is how a cleared route's line lingered
+     * behind its pins. Drop this if the renderer ever hides departed defs urgently itself.
+     * @param layer - The layer whose current lines are on their way out.
+     */
+    function hideDeparting(layer) {
         for (const def of layer.children) {
             def.hidden = true;
             layerManager.touchDef(def);
         }
-        layer.children = [];
-        layerManager.touchedLayers.set(layer.name, layer);
     }
     return {
         setRouteLines(passed, remaining, options) {
-            const linesLayer = layerManager.touchLayer(options.linesLayer);
-            const animatedLayer = layerManager.touchLayer(options.animatedLinesLayer);
-            // Declared here rather than at construction, because this is where the layer is first known.
-            // The `update(layer)` a flush performs is what makes it register under this.
+            layerManager.touchLayer(linesLayer);
+            layerManager.touchLayer(animatedLayer);
+            // Declared on every call rather than at construction: the `update(layer)` a flush performs is
+            // what makes the renderer register the layer under this handler.
             animatedLayer.onScale = ({ pixelSize }) => readPixelSize(pixelSize);
-            lastLinesLayer = linesLayer;
-            lastAnimatedLayer = animatedLayer;
-            const reset = options.resetAnimation ?? true;
+            const reset = options?.resetAnimation ?? true;
             let resumeFrom = 0;
             if (animationHandle) {
                 if (!reset)
@@ -69,8 +78,12 @@ export function createRouteLineManager(layerManager, colors, port) {
                 animationHandle.stop();
                 animationHandle = null;
             }
-            const passedDefs = passed.map((seg) => port.createLineDef(seg, colors.passed));
-            const remainingDefs = remaining.map((seg) => port.createLineDef(seg, colors.remaining));
+            // Every call replaces both layers wholesale, so the lines on their way out are hidden first
+            // — `setRouteLines([], [])` is how a route is cleared.
+            hideDeparting(linesLayer);
+            hideDeparting(animatedLayer);
+            const passedDefs = passed.map((seg) => lineDef(seg, colors.passed));
+            const remainingDefs = remaining.map((seg) => lineDef(seg, colors.remaining));
             linesLayer.children = [...passedDefs, ...remainingDefs];
             if (!remainingDefs.length) {
                 animatedLayer.children = [];
@@ -80,7 +93,7 @@ export function createRouteLineManager(layerManager, colors, port) {
             // `points` object: the chase moves these in place, and the static line beneath must not move
             // with them. They start hidden, and the animation shows each as the head reaches it.
             const animatedDefs = remaining.map((seg) => ({
-                ...port.createLineDef(seg, colors.active),
+                ...lineDef(seg, colors.active),
                 hidden: true,
             }));
             // Mounted once. The chase moves these defs rather than rewriting this array, so no instance is
@@ -94,11 +107,14 @@ export function createRouteLineManager(layerManager, colors, port) {
                 animationHandle.stop();
                 animationHandle = null;
             }
-            wipe(lastLinesLayer);
-            wipe(lastAnimatedLayer);
+            wipe(linesLayer);
+            wipe(animatedLayer);
         },
         destroy() {
             this.clearLines();
+            // The layer outlives this manager, so the handler goes with it: left in place it keeps the
+            // manager reachable and runs on every camera step.
+            animatedLayer.onScale = undefined;
         },
     };
 }

package/dist/renderer/trailManager.d.ts

@@ -1,6 +1,6 @@
 import { type Point2Like } from '@expofp/geometry';
+import type { ImageDef, LayerDef } 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.
  *
@@ -16,16 +16,15 @@ export interface TrailManager {
      */
     setTrail(name: string, from: Point2Like | null, to: Point2Like | null, options?: {
         readonly canvas: HTMLCanvasElement;
-        readonly layer: string;
     }): void;
     /** Remove all trails. */
     destroy(): void;
 }
 /**
- * Create a {@link TrailManager} that renders dot trails into layers
- * managed by the given {@link LayerManager}.
- * @param layerManager - Where the trails are placed and dirt is tracked.
+ * Create a {@link TrailManager} that renders dot trails into the block's trail layer.
+ * @param layerManager - Tracks what changed.
+ * @param layer - The layer the dots go in.
  * @returns The manager.
  */
-export declare function createTrailManager(layerManager: LayerManager, port: RendererPort): TrailManager;
+export declare function createTrailManager(layerManager: LayerManager, layer: LayerDef<ImageDef>): TrailManager;
 //# sourceMappingURL=trailManager.d.ts.map

package/dist/renderer/trailManager.js

@@ -3,12 +3,12 @@ import { computeTrailPoints } from '../core/index.js';
 /** Distance between trail dots at a pixel size of 1, in the same units as route points. */
 const TRAIL_INTERVAL_AT_BASE_PIXEL_SIZE = 40;
 /**
- * Create a {@link TrailManager} that renders dot trails into layers
- * managed by the given {@link LayerManager}.
- * @param layerManager - Where the trails are placed and dirt is tracked.
+ * Create a {@link TrailManager} that renders dot trails into the block's trail layer.
+ * @param layerManager - Tracks what changed.
+ * @param layer - The layer the dots go in.
  * @returns The manager.
  */
-export function createTrailManager(layerManager, port) {
+export function createTrailManager(layerManager, layer) {
     const trails = new Map();
     /**
      * The pixel size the trails currently hold their spacing for.
@@ -20,31 +20,26 @@ export function createTrailManager(layerManager, port) {
      */
     let currentPixelSize = 1;
     /**
-     * The layers this manager has declared an `onScale` on.
+     * Whether this manager has declared its `onScale` on the layer.
      *
      * Declaring the handler is not enough to be called: `useLayoutTargets` registers a layer as a
      * layout target from a render, so the layer has to be committed once after the handler appears.
-     * That commit is a membership change, which is why it happens once per layer rather than per
-     * redraw.
+     * That commit is a membership change, which is why it happens once rather than per redraw.
      */
-    const wiredLayers = new Set();
+    let wired = false;
     /**
      * Lays every trail on one layer out for a new pixel size — what each trail layer's `onScale`
      * closure delegates to.
      *
-     * One function per manager, not per def: what it reads is this manager's trails, and the closure
-     * hands it the one layer it serves.
-     * @param layer - The trail layer.
+     * One function per manager, not per def: what it reads is this manager's trails.
      * @param pixelSize - Plan units per device pixel.
      * @returns The dots that were written, plus the layer when the dot count changed with them.
      */
-    function layOutTrails(layer, pixelSize) {
+    function layOutTrails(pixelSize) {
         currentPixelSize = pixelSize;
         const changed = [];
         let membershipChanged = false;
         for (const record of trails.values()) {
-            if (record.layerName !== layer.name)
-                continue;
             const result = redraw(record);
             changed.push(...result.changed);
             membershipChanged ||= result.membershipChanged;
@@ -66,26 +61,20 @@ export function createTrailManager(layerManager, port) {
     function removeDots(record, dots) {
         if (!dots.length)
             return;
-        const layer = layerManager.touchLayer(record.layerName);
         const dropped = new Set(dots);
         for (const dot of dropped)
             dot.hidden = true;
         layer.children = layer.children.filter((child) => !dropped.has(child));
+        layerManager.touchLayer(layer);
     }
-    /**
-     * The trail layer, with this manager's `onScale` declared on it the first time it is asked for.
-     * @param name - The layer's name.
-     * @returns The layer.
-     */
-    function wireLayer(name) {
-        const layer = layerManager.resolveLayer(name);
-        if (wiredLayers.has(name))
-            return layer;
-        layer.onScale = ({ pixelSize }) => layOutTrails(layer, pixelSize);
-        wiredLayers.add(name);
+    /** Declares this manager's `onScale` on the layer, once. */
+    function wireLayer() {
+        if (wired)
+            return;
+        layer.onScale = ({ pixelSize }) => layOutTrails(pixelSize);
+        wired = true;
         // Committed with the layer, which is what makes the renderer register the handler.
-        layerManager.touchLayer(name);
-        return layer;
+        layerManager.touchLayer(layer);
     }
     /**
      * Lays one trail out at the current pixel size, reusing the dots it already holds.
@@ -97,7 +86,7 @@ export function createTrailManager(layerManager, port) {
      * @returns The dots that were written, and whether the layer's membership changed with them.
      */
     function redraw(record) {
-        const layer = wireLayer(record.layerName);
+        wireLayer();
         const interval = TRAIL_INTERVAL_AT_BASE_PIXEL_SIZE * currentPixelSize;
         const points = computeTrailPoints(record.from, record.to, interval);
         const canvas = record.canvas;
@@ -113,10 +102,10 @@ export function createTrailManager(layerManager, port) {
         if (points.length > kept) {
             const added = points
                 .slice(kept)
-                .map((point) => port.createImageDef(canvas, new Rect({ x: point.x, y: point.y }, size)));
+                .map((point) => ({ source: canvas, bounds: new Rect({ x: point.x, y: point.y }, size) }));
             layer.children.push(...added);
             dots.push(...added);
-            layerManager.touchLayer(record.layerName);
+            layerManager.touchLayer(layer);
             return { changed, membershipChanged: true };
         }
         if (dots.length > kept) {
@@ -161,21 +150,15 @@ export function createTrailManager(layerManager, port) {
                 throw new Error(`renderer: setTrail("${name}") requires options when from/to are non-null`);
             const existing = trails.get(name);
             if (existing) {
-                if (existing.canvas !== options.canvas || existing.layerName !== options.layer) {
-                    throw new Error(`renderer: trail "${name}" cannot change canvas or layer after first call`);
+                if (existing.canvas !== options.canvas) {
+                    throw new Error(`renderer: trail "${name}" cannot change canvas after first call`);
                 }
                 existing.from = from;
                 existing.to = to;
                 bufferRedraw(redraw(existing));
                 return;
             }
-            const record = {
-                from,
-                to,
-                canvas: options.canvas,
-                layerName: options.layer,
-                dotDefs: [],
-            };
+            const record = { from, to, canvas: options.canvas, dotDefs: [] };
             trails.set(name, record);
             bufferRedraw(redraw(record));
         },
@@ -183,10 +166,9 @@ export function createTrailManager(layerManager, port) {
             for (const trailName of [...trails.keys()])
                 drop(trailName);
             // The layer outlives this manager, so the handler has to go with it: left in place it keeps
-            // the manager, its layers and its canvases reachable, and runs on every camera step.
-            for (const name of wiredLayers)
-                layerManager.resolveLayer(name).onScale = undefined;
-            wiredLayers.clear();
+            // the manager, its layer and its canvases reachable, and runs on every camera step.
+            layer.onScale = undefined;
+            wired = false;
         },
     };
 }

package/dist/renderer/types.d.ts

@@ -1,29 +1,17 @@
-import type { Point2Like, Rect } from '@expofp/geometry';
-import type { ImageDef, ImageSource, LayerDef, LineDef, RenderableDef } from '@expofp/renderer';
+import type { Point2Like } from '@expofp/geometry';
+import type { ImageDef, RenderableDef } from '@expofp/renderer';
 /**
- * What the wayfinding renderer needs from whatever is drawing the scene.
- *
- * The def factories are injected rather than imported because they live in the host
- * (floorplan's `src/renderer`), which depends on this package — importing them back would close a
- * cycle.
+ * What the wayfinding renderer needs from whatever is drawing the scene — the rules only the host
+ * can answer for. The defs themselves are plain objects this package builds where it uses them.
  */
 export interface RendererPort {
-    /** Builds an image def. `bounds` carries a placeholder size until the first `onScale`. */
-    createImageDef(source: ImageSource, bounds: Rect, options?: {
-        hidden?: boolean;
-        dim?: number;
-        interactive?: boolean;
-        origin?: [number, number];
-        /** Forwarded from {@link IconConfig.cardinalSnap}; the host attaches the rule. */
-        cardinalSnap?: boolean;
-    }): ImageDef;
-    /** Builds a line def between two points. */
-    createLineDef(line: {
-        p0: Point2Like;
-        p1: Point2Like;
-    }, color?: string, width?: number): LineDef;
-    /** The scene's root layers; the `wf-*` layers are resolved out of these by name. */
-    readonly layers: readonly LayerDef[];
+    /**
+     * Declares the host's camera-roll rule on a def that has to stay readable, for
+     * {@link IconConfig.cardinalSnap}. The rule is the host's because the plan's own labels turn by
+     * it, and one plan turns one way.
+     * @param def - The def to keep upright.
+     */
+    attachCardinalSnap(def: ImageDef): void;
     /**
      * Commits changed defs.
      *
@@ -40,14 +28,14 @@ export interface RouteColors {
 export interface IconConfig {
     readonly canvas: HTMLCanvasElement;
     /**
-     * Target layer name in the scene. Renderer locates the layer once per
-     * (name, layer) slot and reuses it.
+     * Draw the icon on the level above the other icons rather than among them — the live position,
+     * which an endpoint pin must never cover. Two icon layers exist because the draw order inside one
+     * is the slot a def was given, which no caller can set.
      *
-     * TODO(future): when renderer learns to create layers dynamically
-     * inside `createWayfindingRenderer`, this field is removed — renderer
-     * will own layer creation by icon name.
+     * Fixed at first setIcon for an icon key: a later call that changes it throws, since moving a def
+     * between layers would mean removing it from one and adding it to another.
      */
-    readonly layer: string;
+    readonly onTop?: boolean;
     readonly x: number;
     readonly y: number;
     /** Rotation in radians. */
@@ -60,7 +48,7 @@ export interface IconConfig {
      */
     readonly origin?: [number, number];
     /**
-     * Keeps the icon readable as the camera rolls; the host's `createImageDef` attaches the rule.
+     * Keeps the icon readable as the camera rolls; the host attaches the rule.
      * The turn is relative — the icon holds its starting heading plus whole quarters — so do NOT
      * enable it where `rotation` carries meaning (position arrow, kiosk heading).
      *
@@ -82,21 +70,20 @@ export interface WayfindingRendererConfig {
  */
 export interface WayfindingRenderer {
     /**
-     * Place or update an icon by `(name, key)`. First call creates it in
-     * `config.layer`; later calls mutate in place. `config: null` hides it.
-     * `config.layer` must stay stable for a `(name, key)`. Buffered — `flush()` to commit.
+     * Place or update an icon by `(name, key)`. The first call creates it, later calls mutate it in
+     * place, and `config: null` hides it. `config.onTop` must stay stable for a `(name, key)`.
+     * Buffered — `flush()` to commit.
      */
     setIcon(name: string, config: IconConfig | null, key?: string | number): void;
     /** Hide every icon sharing one of `names` (kept alive for reuse). Buffered. */
     clearIcons(names: string | readonly string[]): void;
     /**
      * Place or update a named dot trail between two points; `from/to = null`
-     * clears it. `options` required when non-null; `canvas`/`layer` must stay
-     * stable. Buffered — `flush()` to commit.
+     * clears it. `options` required when non-null; `canvas` must stay stable.
+     * Buffered — `flush()` to commit.
      */
     setTrail(name: string, from: Point2Like | null, to: Point2Like | null, options?: {
         readonly canvas: HTMLCanvasElement;
-        readonly layer: string;
     }): void;
     /**
      * Replace static route lines (passed + remaining) and (re)start the remaining
@@ -108,9 +95,7 @@ export interface WayfindingRenderer {
     }[], remaining: readonly {
         readonly p0: Point2Like;
         readonly p1: Point2Like;
-    }[], options: {
-        readonly linesLayer: string;
-        readonly animatedLinesLayer: string;
+    }[], options?: {
         readonly resetAnimation?: boolean;
     }): void;
     /**
@@ -124,7 +109,7 @@ export interface WayfindingRenderer {
     clearRoute(): void;
     /** Commit buffered mutations to the renderer (via the injected `update`). */
     flush(): void;
-    /** Full teardown (managers cleared). Does NOT flush. */
+    /** Full teardown: empties the host's layers, commits that, and clears the managers. */
     destroy(): void;
 }
 //# sourceMappingURL=types.d.ts.map

package/dist/runtime/createWayfindingRuntime.d.ts

@@ -1,3 +1,3 @@
 import type { WayfindingRuntime, WayfindingRuntimeConfig } from './types.js';
-export declare function createWayfindingRuntime({ engine, renderer, iconProvider, floorContext, layers, snapThreshold, rerouteThreshold, onTransitionClick, onRouteUpdate, onRouteDistance, }: WayfindingRuntimeConfig): WayfindingRuntime;
+export declare function createWayfindingRuntime({ engine, renderer, iconProvider, floorContext, snapThreshold, rerouteThreshold, onTransitionClick, onRouteUpdate, onRouteDistance, }: WayfindingRuntimeConfig): WayfindingRuntime;
 //# sourceMappingURL=createWayfindingRuntime.d.ts.map

package/dist/runtime/createWayfindingRuntime.js

@@ -11,35 +11,24 @@ import { snapPositionToRoute } from './snapPositionToRoute.js';
 import { createTrailView } from './trailView.js';
 import { createTransitionView } from './transitionView.js';
 const linesToPoints = (lines) => lines.flatMap((line) => [line.p0, line.p1]);
-export function createWayfindingRuntime({ engine, renderer, iconProvider, floorContext, layers, snapThreshold, rerouteThreshold, onTransitionClick, onRouteUpdate, onRouteDistance, }) {
+export function createWayfindingRuntime({ engine, renderer, iconProvider, floorContext, snapThreshold, rerouteThreshold, onTransitionClick, onRouteUpdate, onRouteDistance, }) {
     const rerouteController = createRerouteController(rerouteThreshold);
-    const endpoints = createEndpointView({
-        renderer,
-        iconProvider,
-        floorContext,
-        layer: layers.points,
-    });
+    const endpoints = createEndpointView({ renderer, iconProvider, floorContext });
     const transitions = createTransitionView({
         renderer,
         iconProvider,
         floorContext,
         onTransitionClick,
-        layer: layers.points,
     });
-    const trails = createTrailView({ renderer, iconProvider, floorContext, layer: layers.trail });
+    const trails = createTrailView({ renderer, iconProvider, floorContext });
     const positionTrails = createPositionTrailView({
         renderer,
         iconProvider,
         floorContext,
         trails,
-        iconLayer: layers.currentPosition,
         snapThreshold,
     });
-    const routeLinesView = createRouteLinesView({
-        renderer,
-        linesLayer: layers.lines,
-        animatedLinesLayer: layers.linesAnimated,
-    });
+    const routeLinesView = createRouteLinesView({ renderer });
     let routeLines = [];
     let currentFrom = null;
     let currentTo = null;

package/dist/runtime/endpointView.d.ts

@@ -10,11 +10,10 @@ interface EndpointView {
     place(from: RouteEndpoint, to: RouteEndpoint, visibleRoutePoints: readonly RoutePoint[], snapped: boolean): void;
     hide(): void;
 }
-export declare function createEndpointView({ renderer, iconProvider, floorContext, layer, }: {
+export declare function createEndpointView({ renderer, iconProvider, floorContext, }: {
     renderer: Pick<WayfindingRenderer, 'setIcon'>;
     iconProvider: Pick<IconProvider, 'getIcon'>;
     floorContext: Pick<FloorContext, 'isLayerVisible'>;
-    layer: string;
 }): EndpointView;
 export {};
 //# sourceMappingURL=endpointView.d.ts.map

package/dist/runtime/endpointView.js

@@ -3,7 +3,7 @@ function isSourceIconHidden(from, onFloor) {
     // Hide only a kiosk anchor — an off-graph origin that isn't the live current position.
     return !onFloor || (!from.bounds && from.id !== CURRENT_POSITION_POINT_ID);
 }
-export function createEndpointView({ renderer, iconProvider, floorContext, layer, }) {
+export function createEndpointView({ renderer, iconProvider, floorContext, }) {
     return {
         place(from, to, visibleRoutePoints, snapped) {
             if (!visibleRoutePoints.length)
@@ -15,7 +15,6 @@ export function createEndpointView({ renderer, iconProvider, floorContext, layer
             const sourceInactive = from.id === CURRENT_POSITION_POINT_ID && snapped;
             renderer.setIcon('source', {
                 canvas: iconProvider.getIcon(sourceInactive ? 'source_inactive' : 'source').canvas,
-                layer,
                 x: sourcePosition.x,
                 y: sourcePosition.y,
                 hidden: isSourceIconHidden(from, fromOnFloor),
@@ -24,7 +23,6 @@ export function createEndpointView({ renderer, iconProvider, floorContext, layer
             });
             renderer.setIcon('destination', {
                 canvas: iconProvider.getIcon('destination').canvas,
-                layer,
                 x: destPosition.x,
                 y: destPosition.y,
                 hidden: !toOnFloor || !to.bounds,

package/dist/runtime/index.d.ts

@@ -1,4 +1,4 @@
 export { createWayfindingRuntime } from './createWayfindingRuntime.js';
 export { CURRENT_POSITION_POINT_ID } from './positionView.js';
-export type { FloorContext, IconAsset, IconName, IconProvider, LayerNames, PositionInput, SetRouteInput, WayfindingRuntime, WayfindingRuntimeConfig, } from './types.js';
+export type { FloorContext, IconAsset, IconName, IconProvider, PositionInput, SetRouteInput, WayfindingRuntime, WayfindingRuntimeConfig, } from './types.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/runtime/positionTrailView.d.ts

@@ -40,12 +40,11 @@ interface PositionTrailView {
     /** Clear the trail slot (does not touch the icon). */
     clearTrail(): void;
 }
-export declare function createPositionTrailView({ renderer, iconProvider, floorContext, trails, iconLayer, snapThreshold, }: {
+export declare function createPositionTrailView({ renderer, iconProvider, floorContext, trails, snapThreshold, }: {
     renderer: Pick<WayfindingRenderer, 'setIcon'>;
     iconProvider: Pick<IconProvider, 'getIcon'>;
     floorContext: Pick<FloorContext, 'isLayerVisible'>;
     trails: TrailView;
-    iconLayer: string;
     snapThreshold: number;
 }): PositionTrailView;
 export {};

package/dist/runtime/positionTrailView.js

@@ -1,8 +1,8 @@
 import { createPositionView } from './positionView.js';
 import { snapPositionToRoute } from './snapPositionToRoute.js';
 const TRAIL_SLOT = 'trail';
-export function createPositionTrailView({ renderer, iconProvider, floorContext, trails, iconLayer, snapThreshold, }) {
-    const positionIcon = createPositionView({ renderer, iconProvider, layer: iconLayer });
+export function createPositionTrailView({ renderer, iconProvider, floorContext, trails, snapThreshold, }) {
+    const positionIcon = createPositionView({ renderer, iconProvider });
     return {
         placeIcon(position) {
             const hidden = !floorContext.isLayerVisible(position.layer);

package/dist/runtime/positionView.d.ts

@@ -14,10 +14,9 @@ interface PositionView {
     place(input: PositionInput, hidden: boolean): void;
     hide(): void;
 }
-export declare function createPositionView({ renderer, iconProvider, layer, }: {
+export declare function createPositionView({ renderer, iconProvider, }: {
     renderer: Pick<WayfindingRenderer, 'setIcon'>;
     iconProvider: Pick<IconProvider, 'getIcon'>;
-    layer: string;
 }): PositionView;
 export {};
 //# sourceMappingURL=positionView.d.ts.map

package/dist/runtime/positionView.js

@@ -1,7 +1,7 @@
 import { degToRad } from '@expofp/geometry';
 export const CURRENT_POSITION_POINT_ID = 'current-position';
 const POSITION_ICON_KEY = 'position';
-export function createPositionView({ renderer, iconProvider, layer, }) {
+export function createPositionView({ renderer, iconProvider, }) {
     return {
         place(input, hidden) {
             const hasHeading = Number.isFinite(input.heading);
@@ -9,7 +9,8 @@ export function createPositionView({ renderer, iconProvider, layer, }) {
             const rotation = hasHeading ? degToRad(input.heading) : undefined;
             renderer.setIcon(POSITION_ICON_KEY, {
                 canvas: iconProvider.getIcon(iconName).canvas,
-                layer,
+                // Above the route icons: the live position must never end up under an endpoint pin.
+                onTop: true,
                 x: input.x,
                 y: input.y,
                 rotation,

package/dist/runtime/routeLinesView.d.ts

@@ -9,10 +9,8 @@ interface RouteLinesView {
     /** Clear all rendered route lines + animated segments. */
     clear(): void;
 }
-export declare function createRouteLinesView({ renderer, linesLayer, animatedLinesLayer, }: {
+export declare function createRouteLinesView({ renderer, }: {
     renderer: Pick<WayfindingRenderer, 'setRouteLines'>;
-    linesLayer: string;
-    animatedLinesLayer: string;
 }): RouteLinesView;
 export {};
 //# sourceMappingURL=routeLinesView.d.ts.map

package/dist/runtime/routeLinesView.js

@@ -1,18 +1,10 @@
-export function createRouteLinesView({ renderer, linesLayer, animatedLinesLayer, }) {
+export function createRouteLinesView({ renderer, }) {
     return {
         draw({ passed, remaining }, preserveProgress = false) {
-            renderer.setRouteLines(passed, remaining, {
-                linesLayer,
-                animatedLinesLayer,
-                resetAnimation: !preserveProgress,
-            });
+            renderer.setRouteLines(passed, remaining, { resetAnimation: !preserveProgress });
         },
         clear() {
-            renderer.setRouteLines([], [], {
-                linesLayer,
-                animatedLinesLayer,
-                resetAnimation: true,
-            });
+            renderer.setRouteLines([], [], { resetAnimation: true });
         },
     };
 }

package/dist/runtime/trailView.d.ts

@@ -11,10 +11,9 @@ export interface TrailView {
     clear(slot: string): void;
     clearAll(): void;
 }
-export declare function createTrailView({ renderer, iconProvider, floorContext, layer, }: {
+export declare function createTrailView({ renderer, iconProvider, floorContext, }: {
     renderer: Pick<WayfindingRenderer, 'setTrail'>;
     iconProvider: Pick<IconProvider, 'getIcon'>;
     floorContext: Pick<FloorContext, 'showAllFloors' | 'getActiveFloor'>;
-    layer: string;
 }): TrailView;
 //# sourceMappingURL=trailView.d.ts.map