@expofp/wayfinding 3.11.11 → 3.12.0

package/dist/core/createWayfindingEngine.js

@@ -8,41 +8,41 @@ const POINT_EPS = 1e-6;
 const pointEquals = (a, b) => a.layer === b.layer && Math.abs(a.x - b.x) < POINT_EPS && Math.abs(a.y - b.y) < POINT_EPS;
 /**
  * Trim/extend the route's FROM tip to land exactly on `entry.projection`.
- *  The FROM boundary is the first line; `boundary.p0` is its graph node.
+ *  A* returns TO→FROM order, so the FROM boundary is the last line.
  * @param lines
  * @param entry
  */
 function attachFromEntry(lines, entry) {
     if (!lines.length)
         return lines;
-    const boundary = lines[0];
-    const chosenEndpoint = boundary.p0;
+    const boundary = lines[lines.length - 1];
+    const chosenEndpoint = boundary.p1;
     const otherEnd = pointEquals(entry.segment.p0, chosenEndpoint)
         ? entry.segment.p1
         : entry.segment.p0;
-    if (pointEquals(boundary.p1, otherEnd)) {
-        return [{ ...boundary, p0: entry.projection }, ...lines.slice(1)];
+    if (pointEquals(boundary.p0, otherEnd)) {
+        return [...lines.slice(0, -1), { ...boundary, p1: entry.projection }];
     }
-    return [{ ...entry.segment, p0: entry.projection, p1: chosenEndpoint }, ...lines];
+    return [...lines, { ...entry.segment, p0: chosenEndpoint, p1: entry.projection }];
 }
 /**
- * Mirror of {@link attachFromEntry} for the TO side: the TO boundary is the
- *  last line and `boundary.p1` is its graph node.
+ * Mirror of {@link attachFromEntry} for the TO side. TO boundary is the
+ *  FIRST line; `boundary.p0` is the chosen graph node on the TO end.
  * @param lines
  * @param entry
  */
 function attachToEntry(lines, entry) {
     if (!lines.length)
         return lines;
-    const boundary = lines[lines.length - 1];
-    const chosenEndpoint = boundary.p1;
+    const boundary = lines[0];
+    const chosenEndpoint = boundary.p0;
     const otherEnd = pointEquals(entry.segment.p0, chosenEndpoint)
         ? entry.segment.p1
         : entry.segment.p0;
-    if (pointEquals(boundary.p0, otherEnd)) {
-        return [...lines.slice(0, -1), { ...boundary, p1: entry.projection }];
+    if (pointEquals(boundary.p1, otherEnd)) {
+        return [{ ...boundary, p0: entry.projection }, ...lines.slice(1)];
     }
-    return [...lines, { ...entry.segment, p0: chosenEndpoint, p1: entry.projection }];
+    return [{ ...entry.segment, p0: entry.projection, p1: chosenEndpoint }, ...lines];
 }
 function attachOffGraphEntries(lines, fromEntry, toEntry) {
     let result = lines;

package/dist/core/graph/constants.d.ts

@@ -1,12 +1,9 @@
 /**
- * Default A* cost for an unset virtual link that changes layers. Being far
- * larger than any physical segment cost, it makes the pathfinder minimize the
- * number of floor changes, so a route only crosses a floor when needed to reach
- * the destination. A per-line `virtualLength` overrides it (designer control).
+ * Default A* cost for a virtual (floor-transition) link. Non-zero so a floor
+ * change costs more than any same-floor detour; otherwise floor changes are free
+ * and a route between two points on one floor can detour through another.
  */
-export declare const FLOOR_TRANSITION_PENALTY = 10000;
-/** Default A* cost for a virtual link that stays on the same layer (free). */
-export declare const VIRTUAL_LINE_PENALTY = 0;
+export declare const VIRTUAL_LINE_PENALTY = 10000;
 /**
  * Fallback line weight when `line.weight` is 0 (meaning "not set" in floorplan data,
  * not "free passage").

package/dist/core/graph/constants.js

@@ -1,12 +1,9 @@
 /**
- * Default A* cost for an unset virtual link that changes layers. Being far
- * larger than any physical segment cost, it makes the pathfinder minimize the
- * number of floor changes, so a route only crosses a floor when needed to reach
- * the destination. A per-line `virtualLength` overrides it (designer control).
+ * Default A* cost for a virtual (floor-transition) link. Non-zero so a floor
+ * change costs more than any same-floor detour; otherwise floor changes are free
+ * and a route between two points on one floor can detour through another.
  */
-export const FLOOR_TRANSITION_PENALTY = 10000;
-/** Default A* cost for a virtual link that stays on the same layer (free). */
-export const VIRTUAL_LINE_PENALTY = 0;
+export const VIRTUAL_LINE_PENALTY = 10000;
 /**
  * Fallback line weight when `line.weight` is 0 (meaning "not set" in floorplan data,
  * not "free passage").

package/dist/core/graph/findShortestPath.d.ts

@@ -1,8 +1,6 @@
 import { type GraphInstance, type GraphLine, type RoutePoint, type ShortestPathResult } from '../types.js';
 /**
  * Computes the weighted path cost matching the graph link distance formula.
- * Floor-change surcharges are already baked into `linkCost`, so this simply
- * sums the per-edge cost.
  * @param points
  * @param lines
  */

package/dist/core/graph/findShortestPath.js

@@ -6,8 +6,6 @@ function createRoutePoint(layer, x, y) {
 }
 /**
  * Computes the weighted path cost matching the graph link distance formula.
- * Floor-change surcharges are already baked into `linkCost`, so this simply
- * sums the per-edge cost.
  * @param points
  * @param lines
  */

package/dist/core/graph/graphHelpers.js

@@ -1,11 +1,8 @@
 import { degToRad, lineAngle, pointDistance } from '@expofp/geometry';
-export const toNodeId = (p) => `${p.layer ?? ''}_${p.x}_${p.y}`;
+export const toNodeId = (p) => `${p.layer}_${p.x}_${p.y}`;
 /** Maximum distance (SVG units) to consider two graph nodes as the same point. */
 const POINT_PROXIMITY_THRESHOLD = 1;
-// `RoutePoint.layer` is typed as a string, but external data may still supply a
-// nullish/invalid layer. Normalize it to '' so point comparisons stay consistent
-// with the ids that toNodeId/parseNodeId round-trip to.
-export const arePointsClose = (p1, p2) => (p1.layer ?? '') === (p2.layer ?? '') && pointDistance(p1, p2) <= POINT_PROXIMITY_THRESHOLD;
+export const arePointsClose = (p1, p2) => p1.layer === p2.layer && pointDistance(p1, p2) <= POINT_PROXIMITY_THRESHOLD;
 export const matchesLine = (line, p0, p1) => (arePointsClose(line.p0, p0) && arePointsClose(line.p1, p1)) ||
     (arePointsClose(line.p0, p1) && arePointsClose(line.p1, p0));
 export function findLineByEndpoints(lines, p0, p1) {

package/dist/core/graph/linkCost.d.ts

@@ -1,12 +1,6 @@
 import { type GraphLine } from '../types.js';
-export declare function changesLayer(line: GraphLine): boolean;
 /**
- * Weighted cost of a graph edge for A*.
- *
- * Physical links cost their weighted length. A virtual link uses its configured
- * `virtualLength` when set (designer control); otherwise a layer-changing link
- * costs `FLOOR_TRANSITION_PENALTY` (routes avoid needless floor changes) and a
- * same-layer link is free (`VIRTUAL_LINE_PENALTY`).
+ * Weighted cost of a route line for A* graph edge (legacy formula).
  * @param line
  */
 export declare function linkCost(line: GraphLine): number;

package/dist/core/graph/linkCost.js

@@ -1,24 +1,11 @@
 import { pointDistance } from '@expofp/geometry';
-import { DEFAULT_LINE_WEIGHT, FLOOR_TRANSITION_PENALTY, VIRTUAL_LINE_PENALTY, } from './constants.js';
-function physicalCost(line) {
-    return pointDistance(line.p0, line.p1) / (line.weight || DEFAULT_LINE_WEIGHT);
-}
-export function changesLayer(line) {
-    return (line.p0.layer ?? '') !== (line.p1.layer ?? '');
-}
+import { DEFAULT_LINE_WEIGHT, VIRTUAL_LINE_PENALTY } from './constants.js';
 /**
- * Weighted cost of a graph edge for A*.
- *
- * Physical links cost their weighted length. A virtual link uses its configured
- * `virtualLength` when set (designer control); otherwise a layer-changing link
- * costs `FLOOR_TRANSITION_PENALTY` (routes avoid needless floor changes) and a
- * same-layer link is free (`VIRTUAL_LINE_PENALTY`).
+ * Weighted cost of a route line for A* graph edge (legacy formula).
  * @param line
  */
 export function linkCost(line) {
-    if (!line.virtual)
-        return physicalCost(line);
-    if (line.virtualLength != null)
-        return line.virtualLength;
-    return changesLayer(line) ? FLOOR_TRANSITION_PENALTY : VIRTUAL_LINE_PENALTY;
+    if (line.virtual)
+        return line.virtualLength ?? VIRTUAL_LINE_PENALTY;
+    return pointDistance(line.p0, line.p1) / (line.weight || DEFAULT_LINE_WEIGHT);
 }

package/dist/core/graph/pathfinder/aStarPathFinder.js

@@ -41,9 +41,8 @@ export function createAStarPathFinder() {
             return !!graph.hasNode(id);
         },
         /**
-         * Returns path nodes in **source→target** order (`fromId` first, `toId`
-         * last). A* reconstructs from the goal, so the raw path is target→source; it
-         * is reversed here once, at the source, so no downstream reversal is needed.
+         * Returns path nodes in **target→source** order (A* reconstructs from the goal);
+         * downstream consumers depend on this ordering.
          * @param fromId
          * @param toId
          */
@@ -53,12 +52,10 @@ export function createAStarPathFinder() {
             const nodes = finder.find(fromId, toId);
             if (!nodes.length)
                 return [];
-            return nodes
-                .map((node) => {
+            return nodes.map((node) => {
                 const [layer, x, y] = parseNodeId(node.id);
                 return { id: node.id, layer, x, y };
-            })
-                .reverse();
+            });
         },
     };
 }

package/dist/core/index.d.ts

@@ -6,6 +6,7 @@ export { projectPointOnSegment } from './geometry/projectPointOnSegment.js';
 export { computeTrailPoints } from './rendering/computeTrailPoints.js';
 export type { TransitionPointDef } from './rendering/computeTransitionPoints.js';
 export { computeTransitionPoints } from './rendering/computeTransitionPoints.js';
+export { normalizeRouteDirection } from './rendering/normalizeRouteDirection.js';
 export { computeBoundingBox } from './rendering/routeGeometry.js';
 export { getRouteLength } from './routing/getRouteLength.js';
 export type { GpsProjectionConfig } from './position/gpsThreshold.js';

package/dist/core/index.js

@@ -3,6 +3,7 @@ export { projectPointOnSegment } from './geometry/projectPointOnSegment.js';
 // Rendering utilities
 export { computeTrailPoints } from './rendering/computeTrailPoints.js';
 export { computeTransitionPoints } from './rendering/computeTransitionPoints.js';
+export { normalizeRouteDirection } from './rendering/normalizeRouteDirection.js';
 export { computeBoundingBox } from './rendering/routeGeometry.js';
 // Routing utilities
 export { getRouteLength } from './routing/getRouteLength.js';

package/dist/core/position/snapToRoute.d.ts

@@ -1,9 +1,4 @@
 import { type RouteLine, type RoutePoint, type RouteSnapResult, type SnapToRouteConfig } from '../types.js';
 export { SNAP_THRESHOLD_METERS } from './gpsThreshold.js';
-/**
- * Snap a position onto a from→to route polyline. Pure geometry: nearest segment
- * within `snapThreshold`, plus the remaining arc-length to the destination.
- * Segments on a layer other than `position.layer` are skipped.
- */
-export declare function snapToRoute(position: RoutePoint, routeLines: readonly RouteLine[], { snapThreshold }: SnapToRouteConfig): RouteSnapResult;
+export declare function snapToRoute(position: RoutePoint, routeLines: RouteLine[], config: SnapToRouteConfig): RouteSnapResult;
 //# sourceMappingURL=snapToRoute.d.ts.map

package/dist/core/position/snapToRoute.js

@@ -1,18 +1,38 @@
 import { pointDistance } from '@expofp/geometry';
+import { pointInPolygon } from '../geometry/pointInPolygon.js';
 import { projectPointOnSegment } from '../geometry/projectPointOnSegment.js';
+function pointAtDistanceSafe(routeLines, distanceFromStart) {
+    let acc = 0;
+    for (const line of routeLines) {
+        const len = pointDistance(line.p0, line.p1);
+        if (len === 0)
+            continue;
+        if (acc + len >= distanceFromStart) {
+            const t = (distanceFromStart - acc) / len;
+            const x = line.p0.x + (line.p1.x - line.p0.x) * t;
+            const y = line.p0.y + (line.p1.y - line.p0.y) * t;
+            return {
+                point: { layer: line.p0.layer, x, y },
+                line,
+            };
+        }
+        acc += len;
+    }
+    const last = routeLines[routeLines.length - 1];
+    return {
+        point: { layer: last.p0.layer, x: last.p1.x, y: last.p1.y },
+        line: last,
+    };
+}
 export { SNAP_THRESHOLD_METERS } from './gpsThreshold.js';
-/**
- * Snap a position onto a from→to route polyline. Pure geometry: nearest segment
- * within `snapThreshold`, plus the remaining arc-length to the destination.
- * Segments on a layer other than `position.layer` are skipped.
- */
-export function snapToRoute(position, routeLines, { snapThreshold }) {
+export function snapToRoute(position, routeLines, config) {
     const lineCount = routeLines.length;
     if (!lineCount)
         return { snapped: false };
+    const { snapThreshold, to, from, minRemainingUnits = 0.5 } = config;
     const posLayer = position.layer || null;
     let bestDistance = Infinity;
-    let best = null;
+    let bestResult = null;
     let accumulatedLength = 0;
     let hasSegmentOnPosLayer = posLayer == null;
     for (let i = 0; i < lineCount; i++) {
@@ -29,22 +49,66 @@ export function snapToRoute(position, routeLines, { snapThreshold }) {
         const projection = projectPointOnSegment({ x: position.x, y: position.y }, p0, p1);
         if (projection.distance < bestDistance) {
             bestDistance = projection.distance;
-            best = {
-                point: { layer: p0.layer, x: projection.projected.x, y: projection.projected.y },
-                line,
-                fromStart: accumulatedLength + segLen * projection.t,
+            bestResult = {
+                segmentIndex: i,
+                t: projection.t,
+                distanceFromPolylineStart: accumulatedLength + segLen * projection.t,
             };
         }
         accumulatedLength += segLen;
     }
     if (posLayer != null && !hasSegmentOnPosLayer)
         return { snapped: false };
-    if (!best || bestDistance > snapThreshold)
+    const totalLen = accumulatedLength;
+    const routeStart = routeLines[0].p0;
+    const routeEnd = routeLines[lineCount - 1].p1;
+    const distDestToStart = pointDistance(to, routeStart);
+    const distDestToEnd = pointDistance(to, routeEnd);
+    const destinationAtPolylineStart = distDestToStart <= distDestToEnd;
+    const minRemain = Math.min(minRemainingUnits, totalLen);
+    if (from?.bounds &&
+        (posLayer == null || !from.layer || from.layer === posLayer) &&
+        pointInPolygon({ x: position.x, y: position.y }, from.bounds)) {
+        const remainingToDestination = totalLen;
+        const distanceFromStart = destinationAtPolylineStart
+            ? remainingToDestination
+            : totalLen - remainingToDestination;
+        const final = pointAtDistanceSafe(routeLines, distanceFromStart);
+        return {
+            snapped: true,
+            snappedPoint: final.point,
+            snappedLine: final.line,
+            distance: remainingToDestination,
+        };
+    }
+    if (to.bounds &&
+        (posLayer == null || !to.layer || to.layer === posLayer) &&
+        pointInPolygon({ x: position.x, y: position.y }, to.bounds)) {
+        const remainingToDestination = minRemain;
+        const passedSvgLength = totalLen - remainingToDestination;
+        const distanceFromStart = destinationAtPolylineStart ? remainingToDestination : passedSvgLength;
+        const final = pointAtDistanceSafe(routeLines, distanceFromStart);
+        return {
+            snapped: true,
+            snappedPoint: final.point,
+            snappedLine: final.line,
+            distance: remainingToDestination,
+        };
+    }
+    if (!bestResult || bestDistance > snapThreshold)
         return { snapped: false };
+    let remainingToDestination = destinationAtPolylineStart
+        ? bestResult.distanceFromPolylineStart
+        : totalLen - bestResult.distanceFromPolylineStart;
+    if (remainingToDestination < minRemain)
+        remainingToDestination = minRemain;
+    const passedSvgLength = totalLen - remainingToDestination;
+    const distanceFromStart = destinationAtPolylineStart ? remainingToDestination : passedSvgLength;
+    const final = pointAtDistanceSafe(routeLines, distanceFromStart);
     return {
         snapped: true,
-        snappedPoint: best.point,
-        snappedLine: best.line,
-        distance: accumulatedLength - best.fromStart,
+        snappedPoint: final.point,
+        snappedLine: final.line,
+        distance: remainingToDestination,
     };
 }

package/dist/core/rendering/computeTransitionPoints.js

@@ -92,9 +92,9 @@ export function computeTransitionPoints(input) {
             layer: visible.layer,
             targetLayer: resolvedTarget,
             direction: resolveDirection(floorOrder, visible.layer, resolvedTarget),
-            // Current-floor endpoint at `p0` → route departs here → "exit" (clickable
-            // to advance); at `p1` → arrives here → "entry". Null layer → default "exit".
-            role: currentLayerName ? (pickP0 ? 'exit' : 'entry') : 'exit',
+            // When currentLayerName is null, pickP0 is always true — default to "exit"
+            // to preserve existing behavior (all points show stairs icon).
+            role: currentLayerName ? (pickP0 ? 'entry' : 'exit') : 'exit',
         };
     });
     // 5. Deduplicate by coordinates. Drop entries that collide with an exit

package/dist/core/routing/buildMultiPointRoute.js

@@ -28,8 +28,16 @@ export function buildMultiPointRoute(graph, candidateGroups) {
     for (let i = 0; i < reachable.length - 1; i++) {
         segmentResults.push(buildRoute(graph, reachable[i], reachable[i + 1]));
     }
-    // Legs concatenate directly: for [A, B, C], buildRoute(A, B) → [A→…→B] and
-    // buildRoute(B, C) → [B→…→C] share endpoint B, forming one continuous polyline.
+    // A* returns each leg in target→source order (see aStarPathFinder.find()).
+    // For candidates [A, B, C], legs are computed as:
+    //   buildRoute(A, B) → lines [B→...→A]
+    //   buildRoute(B, C) → lines [C→...→B]
+    //
+    // Without reverse: allLines = [B→...→A, C→...→B] — legs are disconnected.
+    // With reverse:    allLines = [C→...→B, B→...→A] — endpoint B connects the
+    //                  chain, creating the continuous target→source polyline that
+    //                  route animation and snapping logic expect.
+    segmentResults.reverse();
     const allLines = segmentResults.flatMap((result) => result.lines);
     const totalDistance = segmentResults.reduce((sum, result) => sum + result.totalDistance, 0);
     return { lines: allLines, totalDistance };

package/dist/core/routing/getRouteLength.d.ts

@@ -1,3 +1,3 @@
 import { type RouteLine } from '../types.js';
-export declare function getRouteLength(routeLines: readonly RouteLine[]): number;
+export declare function getRouteLength(routeLines: RouteLine[]): number;
 //# sourceMappingURL=getRouteLength.d.ts.map

package/dist/core/types.d.ts

@@ -15,7 +15,7 @@ export interface RoutePoint {
 export interface RouteLine {
     readonly p0: RoutePoint;
     readonly p1: RoutePoint;
-    /** Virtual link rather than a physical path segment. May or may not change layers. */
+    /** Virtual (floor-transition) link rather than a physical path segment. */
     readonly virtual: boolean;
 }
 /**
@@ -31,10 +31,11 @@ export interface GraphLine extends RouteLine {
     /** Link weight for cost (`0` = unset → `DEFAULT_LINE_WEIGHT`). */
     readonly weight: number;
     /**
-     * Per-line virtual cost from the designer ("Virtual length"). When set it
-     * replaces the default policy (`0` = free/preferred, large = avoided);
-     * otherwise a layer-changing link costs `FLOOR_TRANSITION_PENALTY`, a
-     * same-layer one is free.
+     * Optional custom cost for virtual (floor-transition) links, configured
+     * per-line in the designer as "Virtual length". When set, the pathfinder
+     * uses this value instead of the default VIRTUAL_LINE_PENALTY, overriding it
+     * per line — `0` makes the transition free (preferred), a large value makes
+     * it avoided. When unset, the non-zero default keeps routes on the same floor.
      */
     readonly virtualLength?: number;
 }
@@ -98,5 +99,8 @@ export interface RouteEndpoint extends RoutePoint {
 }
 export interface SnapToRouteConfig {
     readonly snapThreshold: number;
+    readonly minRemainingUnits?: number;
+    readonly to: RouteEndpoint;
+    readonly from?: RouteEndpoint;
 }
 //# sourceMappingURL=types.d.ts.map

package/dist/runtime/createWayfindingRuntime.js

@@ -1,5 +1,5 @@
 import { Box } from '@expofp/geometry';
-import { createRerouteController, getRouteLength, } from '../core/index.js';
+import { createRerouteController, getRouteLength, snapToRoute, } from '../core/index.js';
 import { createEndpointView } from './endpointView.js';
 import { getRouteLines } from './getRouteLines.js';
 import { createPositionTrailView } from './positionTrailView.js';
@@ -7,7 +7,6 @@ import { CURRENT_POSITION_POINT_ID } from './positionView.js';
 import { createRouteLinesView } from './routeLinesView.js';
 import { computeRouteRenderData } from './routeRenderData.js';
 import { computeRouteUpdate } from './routeUpdate.js';
-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]);
@@ -85,6 +84,8 @@ export function createWayfindingRuntime({ engine, renderer, iconProvider, floorC
         const data = computeRouteRenderData({
             routeLines,
             currentRouteLayer: getCurrentRouteLayer(),
+            from: currentFrom,
+            to: currentTo,
             snap,
         });
         routeLinesView.draw(data, preserveProgress);
@@ -109,14 +110,12 @@ export function createWayfindingRuntime({ engine, renderer, iconProvider, floorC
         // `hasSnappedCurrentRoute` only flips for a live-CP FROM (booth/kiosk origins never snap),
         // so it already implies a CP origin — no need to re-check the endpoint id here.
         const fromAnchor = hasSnappedCurrentRoute ? null : pickAnchor(route.from);
-        // The trail tip is the route's graph endpoint on the same side as its
-        // off-graph anchor: first point for FROM, last point for TO.
         if (fromAnchor) {
-            positionTrails.setTrail(route.routePoints[0], fromAnchor);
+            positionTrails.setTrail(route.routePoints[route.routePoints.length - 1], fromAnchor);
             return;
         }
         const toAnchor = pickAnchor(route.to);
-        positionTrails.setTrail(toAnchor ? route.routePoints[route.routePoints.length - 1] : null, toAnchor);
+        positionTrails.setTrail(toAnchor ? route.routePoints[0] : null, toAnchor);
     }
     function syncRouteVisuals() {
         if (!currentFrom || !currentTo)
@@ -158,7 +157,11 @@ export function createWayfindingRuntime({ engine, renderer, iconProvider, floorC
             : // Selected floor doesn't pass through the route — view has nothing
                 // to draw, but distance must still update. Snap against the full
                 // non-virtual route directly.
-                snapPositionToRoute(currentPosition, nonVirtual, currentFrom, currentTo, snapThreshold);
+                snapToRoute(currentPosition, nonVirtual, {
+                    snapThreshold,
+                    from: currentFrom,
+                    to: currentTo,
+                });
         if (result.snapped)
             hasSnappedCurrentRoute = true;
         snappedToRoute = result.snapped;

package/dist/runtime/endpointView.js

@@ -10,8 +10,8 @@ export function createEndpointView({ renderer, iconProvider, floorContext, layer
                 return;
             const fromOnFloor = floorContext.isLayerVisible(from.layer);
             const toOnFloor = floorContext.isLayerVisible(to.layer);
-            const sourcePosition = visibleRoutePoints[0];
-            const destPosition = visibleRoutePoints[visibleRoutePoints.length - 1];
+            const sourcePosition = visibleRoutePoints[visibleRoutePoints.length - 1];
+            const destPosition = visibleRoutePoints[0];
             const sourceInactive = from.id === CURRENT_POSITION_POINT_ID && snapped;
             renderer.setIcon('source', {
                 canvas: iconProvider.getIcon(sourceInactive ? 'source_inactive' : 'source').canvas,

package/dist/runtime/positionTrailView.js

@@ -1,5 +1,5 @@
+import { snapToRoute, } from '../core/index.js';
 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 });
@@ -12,7 +12,11 @@ export function createPositionTrailView({ renderer, iconProvider, floorContext,
             positionIcon.hide();
         },
         applyToRoute(position, route, routeLines) {
-            const snap = snapPositionToRoute(position, routeLines, route.from, route.to, snapThreshold);
+            const snap = snapToRoute(position, [...routeLines], {
+                snapThreshold,
+                from: route.from,
+                to: route.to,
+            });
             const hidden = !floorContext.isLayerVisible(position.layer);
             if (snap.snapped) {
                 positionIcon.place({ ...position, x: snap.snappedPoint.x, y: snap.snappedPoint.y }, hidden);

package/dist/runtime/routeRenderData.d.ts

@@ -1,4 +1,4 @@
-import { type RouteLine, type RouteSnapResult } from '../core/index.js';
+import { type RouteEndpoint, type RouteLine, type RouteSnapResult } from '../core/index.js';
 interface RouteRenderData {
     /** Route lines behind the current user position (empty when no snap). */
     readonly passed: RouteLine[];
@@ -12,19 +12,23 @@ interface RouteRenderData {
  * passed/remaining split for the visible floor plus the remaining
  * distance to the destination.
  *
- * The full non-virtual route is sliced down to the visible floor for rendering.
- * The remaining distance is read from `snap.distance` (computed once by the
- * runtime snap, `snapPositionToRoute`); with no snap it falls back to the full
- * route length.
+ * The full non-virtual route is normalized to from→to direction once and
+ * sliced down to the visible floor for rendering. The remaining distance
+ * is read from `snap.distance` (computed once inside `snapToRoute`); when
+ * no snap is active we fall back to the full route length.
  * @param root0
  * @param root0.routeLines
  * @param root0.currentRouteLayer
+ * @param root0.from
+ * @param root0.to
  * @param root0.snap
  */
-export declare function computeRouteRenderData({ routeLines, currentRouteLayer, snap, }: {
+export declare function computeRouteRenderData({ routeLines, currentRouteLayer, from, to, snap, }: {
     readonly routeLines: RouteLine[];
     /** null = show-all mode; otherwise the active route floor. */
     readonly currentRouteLayer: string | null;
+    readonly from: RouteEndpoint;
+    readonly to: RouteEndpoint;
     readonly snap: RouteSnapResult | null;
 }): RouteRenderData;
 export {};

package/dist/runtime/routeRenderData.js

@@ -1,20 +1,22 @@
-import { getRouteLength, splitRouteByPoint, } from '../core/index.js';
+import { getRouteLength, normalizeRouteDirection, splitRouteByPoint, } from '../core/index.js';
 /**
  * Pure pipeline that produces the data needed to render the route: the
  * passed/remaining split for the visible floor plus the remaining
  * distance to the destination.
  *
- * The full non-virtual route is sliced down to the visible floor for rendering.
- * The remaining distance is read from `snap.distance` (computed once by the
- * runtime snap, `snapPositionToRoute`); with no snap it falls back to the full
- * route length.
+ * The full non-virtual route is normalized to from→to direction once and
+ * sliced down to the visible floor for rendering. The remaining distance
+ * is read from `snap.distance` (computed once inside `snapToRoute`); when
+ * no snap is active we fall back to the full route length.
  * @param root0
  * @param root0.routeLines
  * @param root0.currentRouteLayer
+ * @param root0.from
+ * @param root0.to
  * @param root0.snap
  */
-export function computeRouteRenderData({ routeLines, currentRouteLayer, snap, }) {
-    const nonVirtualOrdered = routeLines.filter((line) => !line.virtual);
+export function computeRouteRenderData({ routeLines, currentRouteLayer, from, to, snap, }) {
+    const nonVirtualOrdered = normalizeRouteDirection(routeLines.filter((line) => !line.virtual), from, to);
     const clipToVisibleFloor = (lines) => currentRouteLayer === null
         ? lines
         : lines.filter((line) => line.p0.layer === currentRouteLayer);
@@ -32,10 +34,7 @@ export function computeRouteRenderData({ routeLines, currentRouteLayer, snap, })
     // Ref-equal result means no segment matched the snap layer (bestIndex === -1); only on a
     // real split do we anchor the first remaining segment at the snap point.
     const splitOccurred = remaining !== nonVirtualOrdered;
-    // Anchor only when `remaining[0]` is on the snap's floor — at a transition it
-    // already belongs to the next floor, and keeping its own `p0` survives the clip.
-    const anchorAtSnap = splitOccurred && remaining.length > 0 && remaining[0].p0.layer === snap.snappedPoint.layer;
-    const adjustedRemaining = anchorAtSnap
+    const adjustedRemaining = splitOccurred && remaining.length > 0
         ? [{ ...remaining[0], p0: snap.snappedPoint }, ...remaining.slice(1)]
         : remaining;
     return {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@expofp/wayfinding",
-  "version": "3.11.11",
+  "version": "3.12.0",
   "type": "module",
   "description": "ExpoFP SDK internal: framework-neutral wayfinding (routing, snapping, scene rendering)",
   "homepage": "https://developer.expofp.com/",
@@ -34,7 +34,7 @@
   "dependencies": {
     "ngraph.graph": "^19.1.0",
     "tslib": "^2.3.0",
-    "@expofp/geometry": "3.11.11"
+    "@expofp/geometry": "3.12.0"
   },
   "peerDependencies": {
     "@expofp/renderer": "^3.2.4"

package/dist/runtime/snapPositionToRoute.d.ts

@@ -1,10 +0,0 @@
-import { type RouteEndpoint, type RouteLine, type RoutePoint, type RouteSnapResult } from '../core/index.js';
-/**
- * Snap a position to the from→to route, resolving from/to booth containment
- * first (domain logic kept out of the geometric `snapToRoute`):
- * - inside the origin booth → route start, full distance remaining;
- * - inside the destination booth → route end, zero remaining;
- * - otherwise → geometric snap within `snapThreshold`.
- */
-export declare function snapPositionToRoute(position: RoutePoint, routeLines: readonly RouteLine[], from: RouteEndpoint, to: RouteEndpoint, snapThreshold: number): RouteSnapResult;
-//# sourceMappingURL=snapPositionToRoute.d.ts.map

package/dist/runtime/snapPositionToRoute.js

@@ -1,36 +0,0 @@
-import { pointInPolygon } from '../core/geometry/pointInPolygon.js';
-import { getRouteLength, snapToRoute, } from '../core/index.js';
-/** Whether `position` lies inside `endpoint`'s booth bounds on a matching layer. */
-function insideBounds(position, endpoint, posLayer) {
-    if (!endpoint?.bounds)
-        return false;
-    const layerMatches = posLayer == null || !endpoint.layer || endpoint.layer === posLayer;
-    const containsPosition = pointInPolygon({ x: position.x, y: position.y }, endpoint.bounds);
-    return layerMatches && containsPosition;
-}
-/**
- * Snap a position to the from→to route, resolving from/to booth containment
- * first (domain logic kept out of the geometric `snapToRoute`):
- * - inside the origin booth → route start, full distance remaining;
- * - inside the destination booth → route end, zero remaining;
- * - otherwise → geometric snap within `snapThreshold`.
- */
-export function snapPositionToRoute(position, routeLines, from, to, snapThreshold) {
-    if (!routeLines.length)
-        return { snapped: false };
-    const posLayer = position.layer || null;
-    if (insideBounds(position, from, posLayer)) {
-        const first = routeLines[0];
-        return {
-            snapped: true,
-            snappedPoint: first.p0,
-            snappedLine: first,
-            distance: getRouteLength(routeLines),
-        };
-    }
-    if (insideBounds(position, to, posLayer)) {
-        const last = routeLines[routeLines.length - 1];
-        return { snapped: true, snappedPoint: last.p1, snappedLine: last, distance: 0 };
-    }
-    return snapToRoute(position, routeLines, { snapThreshold });
-}