@expofp/wayfinding 3.13.0 → 3.13.1

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`.
- *  A* returns TO→FROM order, so the FROM boundary is the last line.
+ *  The FROM boundary is the first line; `boundary.p0` is its graph node.
  * @param lines
  * @param entry
  */
 function attachFromEntry(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];
 }
 /**
- * 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.
+ * Mirror of {@link attachFromEntry} for the TO side: the TO boundary is the
+ *  last line and `boundary.p1` is its graph node.
  * @param lines
  * @param entry
  */
 function attachToEntry(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 }];
 }
 function attachOffGraphEntries(lines, fromEntry, toEntry) {
     let result = lines;

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

@@ -1,9 +1,12 @@
 /**
- * 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.
+ * 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).
  */
-export declare const VIRTUAL_LINE_PENALTY = 10000;
+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;
 /**
  * Fallback line weight when `line.weight` is 0 (meaning "not set" in floorplan data,
  * not "free passage").

package/dist/core/graph/constants.js

@@ -1,9 +1,12 @@
 /**
- * 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.
+ * 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).
  */
-export const VIRTUAL_LINE_PENALTY = 10000;
+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;
 /**
  * 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,6 +1,8 @@
 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,6 +6,8 @@ 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,8 +1,11 @@
 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;
-export const arePointsClose = (p1, p2) => p1.layer === p2.layer && pointDistance(p1, p2) <= POINT_PROXIMITY_THRESHOLD;
+// `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 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,6 +1,12 @@
 import { type GraphLine } from '../types.js';
+export declare function changesLayer(line: GraphLine): boolean;
 /**
- * Weighted cost of a route line for A* graph edge (legacy formula).
+ * 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`).
  * @param line
  */
 export declare function linkCost(line: GraphLine): number;

package/dist/core/graph/linkCost.js

@@ -1,11 +1,24 @@
 import { pointDistance } from '@expofp/geometry';
-import { DEFAULT_LINE_WEIGHT, VIRTUAL_LINE_PENALTY } from './constants.js';
+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 ?? '');
+}
 /**
- * Weighted cost of a route line for A* graph edge (legacy formula).
+ * 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`).
  * @param line
  */
 export function linkCost(line) {
-    if (line.virtual)
-        return line.virtualLength ?? VIRTUAL_LINE_PENALTY;
-    return pointDistance(line.p0, line.p1) / (line.weight || DEFAULT_LINE_WEIGHT);
+    if (!line.virtual)
+        return physicalCost(line);
+    if (line.virtualLength != null)
+        return line.virtualLength;
+    return changesLayer(line) ? FLOOR_TRANSITION_PENALTY : VIRTUAL_LINE_PENALTY;
 }

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

@@ -41,8 +41,9 @@ export function createAStarPathFinder() {
             return !!graph.hasNode(id);
         },
         /**
-         * Returns path nodes in **target→source** order (A* reconstructs from the goal);
-         * downstream consumers depend on this ordering.
+         * 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.
          * @param fromId
          * @param toId
          */
@@ -52,10 +53,12 @@ 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,7 +6,6 @@ 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,7 +3,6 @@ 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,4 +1,9 @@
 import { type RouteLine, type RoutePoint, type RouteSnapResult, type SnapToRouteConfig } from '../types.js';
 export { SNAP_THRESHOLD_METERS } from './gpsThreshold.js';
-export declare function snapToRoute(position: RoutePoint, routeLines: RouteLine[], config: SnapToRouteConfig): RouteSnapResult;
+/**
+ * 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;
 //# sourceMappingURL=snapToRoute.d.ts.map

package/dist/core/position/snapToRoute.js

@@ -1,38 +1,18 @@
 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';
-export function snapToRoute(position, routeLines, config) {
+/**
+ * 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 }) {
     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 bestResult = null;
+    let best = null;
     let accumulatedLength = 0;
     let hasSegmentOnPosLayer = posLayer == null;
     for (let i = 0; i < lineCount; i++) {
@@ -49,66 +29,22 @@ export function snapToRoute(position, routeLines, config) {
         const projection = projectPointOnSegment({ x: position.x, y: position.y }, p0, p1);
         if (projection.distance < bestDistance) {
             bestDistance = projection.distance;
-            bestResult = {
-                segmentIndex: i,
-                t: projection.t,
-                distanceFromPolylineStart: accumulatedLength + segLen * projection.t,
+            best = {
+                point: { layer: p0.layer, x: projection.projected.x, y: projection.projected.y },
+                line,
+                fromStart: accumulatedLength + segLen * projection.t,
             };
         }
         accumulatedLength += segLen;
     }
     if (posLayer != null && !hasSegmentOnPosLayer)
         return { snapped: false };
-    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)
+    if (!best || 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: final.point,
-        snappedLine: final.line,
-        distance: remainingToDestination,
+        snappedPoint: best.point,
+        snappedLine: best.line,
+        distance: accumulatedLength - best.fromStart,
     };
 }

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),
-            // 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',
+            // 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',
         };
     });
     // 5. Deduplicate by coordinates. Drop entries that collide with an exit

package/dist/core/routing/buildMultiPointRoute.js

@@ -28,16 +28,8 @@ export function buildMultiPointRoute(graph, candidateGroups) {
     for (let i = 0; i < reachable.length - 1; i++) {
         segmentResults.push(buildRoute(graph, reachable[i], reachable[i + 1]));
     }
-    // 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();
+    // 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.
     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: RouteLine[]): number;
+export declare function getRouteLength(routeLines: readonly 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 (floor-transition) link rather than a physical path segment. */
+    /** Virtual link rather than a physical path segment. May or may not change layers. */
     readonly virtual: boolean;
 }
 /**
@@ -31,11 +31,10 @@ export interface GraphLine extends RouteLine {
     /** Link weight for cost (`0` = unset → `DEFAULT_LINE_WEIGHT`). */
     readonly weight: number;
     /**
-     * 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.
+     * 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.
      */
     readonly virtualLength?: number;
 }
@@ -99,8 +98,5 @@ 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, snapToRoute, } from '../core/index.js';
+import { createRerouteController, getRouteLength, } from '../core/index.js';
 import { createEndpointView } from './endpointView.js';
 import { getRouteLines } from './getRouteLines.js';
 import { createPositionTrailView } from './positionTrailView.js';
@@ -7,6 +7,7 @@ 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]);
@@ -84,8 +85,6 @@ export function createWayfindingRuntime({ engine, renderer, iconProvider, floorC
         const data = computeRouteRenderData({
             routeLines,
             currentRouteLayer: getCurrentRouteLayer(),
-            from: currentFrom,
-            to: currentTo,
             snap,
         });
         routeLinesView.draw(data, preserveProgress);
@@ -110,12 +109,14 @@ 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[route.routePoints.length - 1], fromAnchor);
+            positionTrails.setTrail(route.routePoints[0], fromAnchor);
             return;
         }
         const toAnchor = pickAnchor(route.to);
-        positionTrails.setTrail(toAnchor ? route.routePoints[0] : null, toAnchor);
+        positionTrails.setTrail(toAnchor ? route.routePoints[route.routePoints.length - 1] : null, toAnchor);
     }
     function syncRouteVisuals() {
         if (!currentFrom || !currentTo)
@@ -157,11 +158,7 @@ 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.
-                snapToRoute(currentPosition, nonVirtual, {
-                    snapThreshold,
-                    from: currentFrom,
-                    to: currentTo,
-                });
+                snapPositionToRoute(currentPosition, nonVirtual, currentFrom, currentTo, snapThreshold);
         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[visibleRoutePoints.length - 1];
-            const destPosition = visibleRoutePoints[0];
+            const sourcePosition = visibleRoutePoints[0];
+            const destPosition = visibleRoutePoints[visibleRoutePoints.length - 1];
             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,11 +12,7 @@ export function createPositionTrailView({ renderer, iconProvider, floorContext,
             positionIcon.hide();
         },
         applyToRoute(position, route, routeLines) {
-            const snap = snapToRoute(position, [...routeLines], {
-                snapThreshold,
-                from: route.from,
-                to: route.to,
-            });
+            const snap = snapPositionToRoute(position, routeLines, route.from, route.to, snapThreshold);
             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 RouteEndpoint, type RouteLine, type RouteSnapResult } from '../core/index.js';
+import { 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,23 +12,19 @@ interface RouteRenderData {
  * passed/remaining split for the visible floor plus the remaining
  * distance to the destination.
  *
- * 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.
+ * 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.
  * @param root0
  * @param root0.routeLines
  * @param root0.currentRouteLayer
- * @param root0.from
- * @param root0.to
  * @param root0.snap
  */
-export declare function computeRouteRenderData({ routeLines, currentRouteLayer, from, to, snap, }: {
+export declare function computeRouteRenderData({ routeLines, currentRouteLayer, 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,22 +1,20 @@
-import { getRouteLength, normalizeRouteDirection, splitRouteByPoint, } from '../core/index.js';
+import { getRouteLength, 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 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.
+ * 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.
  * @param root0
  * @param root0.routeLines
  * @param root0.currentRouteLayer
- * @param root0.from
- * @param root0.to
  * @param root0.snap
  */
-export function computeRouteRenderData({ routeLines, currentRouteLayer, from, to, snap, }) {
-    const nonVirtualOrdered = normalizeRouteDirection(routeLines.filter((line) => !line.virtual), from, to);
+export function computeRouteRenderData({ routeLines, currentRouteLayer, snap, }) {
+    const nonVirtualOrdered = routeLines.filter((line) => !line.virtual);
     const clipToVisibleFloor = (lines) => currentRouteLayer === null
         ? lines
         : lines.filter((line) => line.p0.layer === currentRouteLayer);
@@ -34,7 +32,10 @@ export function computeRouteRenderData({ routeLines, currentRouteLayer, from, to
     // 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;
-    const adjustedRemaining = splitOccurred && remaining.length > 0
+    // 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
         ? [{ ...remaining[0], p0: snap.snappedPoint }, ...remaining.slice(1)]
         : remaining;
     return {

package/dist/runtime/snapPositionToRoute.d.ts

@@ -0,0 +1,10 @@
+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

@@ -0,0 +1,36 @@
+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 });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@expofp/wayfinding",
-  "version": "3.13.0",
+  "version": "3.13.1",
   "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.13.0"
+    "@expofp/geometry": "3.13.1"
   },
   "peerDependencies": {
     "@expofp/renderer": "^3.2.4"

package/dist/core/rendering/normalizeRouteDirection.d.ts

@@ -1,19 +0,0 @@
-import type { RouteLine, RoutePoint } from '../types.js';
-/**
- * Ensures that `routeLines` run in the from→to direction.
- *
- * A* returns paths in target→source order. For rendering (arrow animation,
- * route progress split) and remaining-distance computation the lines must
- * go from the origin to the destination.
- *
- * Direction is decided by projecting `from` (or `to` as a fallback) onto
- * `routeLines`: if the anchor lands closer to the polyline end than to
- * its start, the array is reversed and each segment's endpoints are
- * flipped to keep continuity.
- * @param routeLines  Lines to normalize.
- * @param from        Route origin (user-selected "from" point).
- * @param to          Route destination (user-selected "to" point).
- * @returns Lines guaranteed to run from→to, or the original array unchanged.
- */
-export declare function normalizeRouteDirection(routeLines: RouteLine[], from: RoutePoint, to: RoutePoint): RouteLine[];
-//# sourceMappingURL=normalizeRouteDirection.d.ts.map

package/dist/core/rendering/normalizeRouteDirection.js

@@ -1,82 +0,0 @@
-import { pointDistance } from '@expofp/geometry';
-/**
- * Projects `point` onto the closest segment of `segments` that shares the same layer,
- * returning the arc-length distance from the polyline start to the projection.
- * @param point
- * @param segments
- * @param segmentLengths
- */
-function projectPointOnRoute(point, segments, segmentLengths) {
-    let accumulatedLength = 0;
-    let bestDistance = Infinity;
-    let bestFromStart = Infinity;
-    const total = segmentLengths.reduce((sum, len) => sum + len, 0);
-    for (let i = 0; i < segments.length; i++) {
-        const segment = segments[i];
-        const segmentLength = segmentLengths[i];
-        // Empty `point.layer` = wildcard (single-floor plans without layers).
-        if (point.layer && segment.p0.layer !== point.layer) {
-            accumulatedLength += segmentLength;
-            continue;
-        }
-        const dx = segment.p1.x - segment.p0.x;
-        const dy = segment.p1.y - segment.p0.y;
-        const lengthSquared = dx * dx + dy * dy;
-        // Near-zero-length segment — nothing meaningful to project onto.
-        if (lengthSquared < 1e-10) {
-            accumulatedLength += segmentLength;
-            continue;
-        }
-        // Project point onto segment, clamped to [0, 1].
-        const t = ((point.x - segment.p0.x) * dx + (point.y - segment.p0.y) * dy) / lengthSquared;
-        const clamped = Math.max(0, Math.min(1, t));
-        const projectedX = segment.p0.x + dx * clamped;
-        const projectedY = segment.p0.y + dy * clamped;
-        const distance = Math.hypot(point.x - projectedX, point.y - projectedY);
-        if (distance < bestDistance) {
-            bestDistance = distance;
-            bestFromStart = accumulatedLength + segmentLength * clamped;
-        }
-        accumulatedLength += segmentLength;
-    }
-    return { found: bestFromStart !== Infinity, fromStart: bestFromStart, total };
-}
-/**
- * Ensures that `routeLines` run in the from→to direction.
- *
- * A* returns paths in target→source order. For rendering (arrow animation,
- * route progress split) and remaining-distance computation the lines must
- * go from the origin to the destination.
- *
- * Direction is decided by projecting `from` (or `to` as a fallback) onto
- * `routeLines`: if the anchor lands closer to the polyline end than to
- * its start, the array is reversed and each segment's endpoints are
- * flipped to keep continuity.
- * @param routeLines  Lines to normalize.
- * @param from        Route origin (user-selected "from" point).
- * @param to          Route destination (user-selected "to" point).
- * @returns Lines guaranteed to run from→to, or the original array unchanged.
- */
-export function normalizeRouteDirection(routeLines, from, to) {
-    // Precompute segment lengths once (used for both projections).
-    const segmentLengths = routeLines.map((line) => pointDistance(line.p0, line.p1));
-    // Try to anchor using `from`. Fall back to `to` if `from` doesn't land on any same-layer segment.
-    const fromProjection = projectPointOnRoute(from, routeLines, segmentLengths);
-    const anchor = fromProjection.found
-        ? fromProjection
-        : projectPointOnRoute(to, routeLines, segmentLengths);
-    if (!anchor.found)
-        return routeLines;
-    const distToStart = anchor.fromStart;
-    const distToEnd = anchor.total - anchor.fromStart;
-    // If `from` was used as anchor: `from` should be closer to the start.
-    // If `to` was used as fallback: `to` should be closer to the end.
-    const shouldReverse = fromProjection.found ? distToEnd < distToStart : distToStart < distToEnd;
-    if (!shouldReverse)
-        return routeLines;
-    // Reverse segment order AND flip each segment's endpoints to maintain continuity.
-    return routeLines
-        .slice()
-        .reverse()
-        .map((line) => ({ ...line, p0: line.p1, p1: line.p0 }));
-}