@expofp/wayfinding 3.11.11

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

@@ -0,0 +1,64 @@
+import { lineAngle } from '@expofp/geometry';
+import { buildNGraph } from '../buildNGraph.js';
+import { TURN_PENALTY } from '../constants.js';
+import aStarPathSearch from '../utils/a-star/a-star.js';
+import { parseNodeId } from './parseNodeId.js';
+function createAnglePenaltyDistance() {
+    return function anglePenaltyDistance(fromNode, toNode, link) {
+        let coef = 1;
+        if (toNode.parent) {
+            const [, parentX, parentY] = parseNodeId(toNode.parent.node.id);
+            const [, toX, toY] = parseNodeId(toNode.node.id);
+            const [, fromX, fromY] = parseNodeId(fromNode.id);
+            const previousAngle = lineAngle({ x: parentX, y: parentY }, { x: toX, y: toY });
+            const nextAngle = lineAngle({ x: toX, y: toY }, { x: fromX, y: fromY });
+            // Strict !== on floats is intentional: applies the 1% penalty for
+            // any non-zero direction change, no matter how small. This is legacy
+            // behavior — introducing an angle threshold would change route selection.
+            // lineAngle now returns radians (atan2) instead of degrees (law of
+            // cosines); identical inputs still yield identical bits, so the strict
+            // equality of two same-direction segments is preserved.
+            if (previousAngle !== nextAngle)
+                coef = TURN_PENALTY;
+        }
+        return coef * link.data.distance;
+    };
+}
+export function createAStarPathFinder() {
+    let finder = null;
+    let graph = null;
+    return {
+        build(lines, options) {
+            graph = buildNGraph(lines, options);
+            finder = aStarPathSearch(graph, {
+                oriented: options.oriented,
+                distance: createAnglePenaltyDistance(),
+            });
+        },
+        hasNode(id) {
+            if (!graph)
+                return false;
+            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.
+         * @param fromId
+         * @param toId
+         */
+        find(fromId, toId) {
+            if (!finder)
+                return [];
+            const nodes = finder.find(fromId, toId);
+            if (!nodes.length)
+                return [];
+            return nodes
+                .map((node) => {
+                const [layer, x, y] = parseNodeId(node.id);
+                return { id: node.id, layer, x, y };
+            })
+                .reverse();
+        },
+    };
+}

package/dist/core/graph/pathfinder/parseNodeId.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Decodes a node ID created by `pointId` back into [layer, x, y].
+ *
+ * Point IDs are formatted as "{layer}_{x}_{y}". Since layer names may
+ * contain underscores (e.g. "floor_1"), we parse from the right where
+ * x and y are always the last two segments.
+ * @param id
+ */
+export declare function parseNodeId(id: string): [string, number, number];
+//# sourceMappingURL=parseNodeId.d.ts.map

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

@@ -0,0 +1,20 @@
+/**
+ * Decodes a node ID created by `pointId` back into [layer, x, y].
+ *
+ * Point IDs are formatted as "{layer}_{x}_{y}". Since layer names may
+ * contain underscores (e.g. "floor_1"), we parse from the right where
+ * x and y are always the last two segments.
+ * @param id
+ */
+export function parseNodeId(id) {
+    const lastSep = id.lastIndexOf('_');
+    const secondLastSep = id.lastIndexOf('_', lastSep - 1);
+    if (secondLastSep === -1) {
+        throw new Error(`WF: invalid node ID format "${id}", expected "{layer}_{x}_{y}"`);
+    }
+    return [
+        id.substring(0, secondLastSep),
+        parseFloat(id.substring(secondLastSep + 1, lastSep)),
+        parseFloat(id.substring(lastSep + 1)),
+    ];
+}

package/dist/core/index.d.ts

@@ -0,0 +1,17 @@
+export type { Route, WayfindingEngine } from './createWayfindingEngine.js';
+export { createWayfindingEngine } from './createWayfindingEngine.js';
+export type { GraphDataSource, GraphLine, RouteEndpoint, RouteLine, RoutePoint, RouteSnapResult, SnapToRouteConfig, } from './types.js';
+export type { SegmentProjection } from './geometry/projectPointOnSegment.js';
+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 { computeBoundingBox } from './rendering/routeGeometry.js';
+export { getRouteLength } from './routing/getRouteLength.js';
+export type { GpsProjectionConfig } from './position/gpsThreshold.js';
+export { getThresholdFromMetersToSvg, getThresholdOrDefault, getThresholdSafe, resolveRerouteThresholdSvg, SNAP_THRESHOLD_METERS, } from './position/gpsThreshold.js';
+export type { RerouteController } from './position/rerouteController.js';
+export { createRerouteController } from './position/rerouteController.js';
+export { snapToRoute } from './position/snapToRoute.js';
+export { splitRouteByPoint } from './position/splitRouteByPoint.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/core/index.js

@@ -0,0 +1,12 @@
+export { createWayfindingEngine } from './createWayfindingEngine.js';
+export { projectPointOnSegment } from './geometry/projectPointOnSegment.js';
+// Rendering utilities
+export { computeTrailPoints } from './rendering/computeTrailPoints.js';
+export { computeTransitionPoints } from './rendering/computeTransitionPoints.js';
+export { computeBoundingBox } from './rendering/routeGeometry.js';
+// Routing utilities
+export { getRouteLength } from './routing/getRouteLength.js';
+export { getThresholdFromMetersToSvg, getThresholdOrDefault, getThresholdSafe, resolveRerouteThresholdSvg, SNAP_THRESHOLD_METERS, } from './position/gpsThreshold.js';
+export { createRerouteController } from './position/rerouteController.js';
+export { snapToRoute } from './position/snapToRoute.js';
+export { splitRouteByPoint } from './position/splitRouteByPoint.js';

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

@@ -0,0 +1,3 @@
+import type { RouteLine, RoutePoint } from '../types.js';
+export declare function distancePointToRouteOnLayer(point: RoutePoint, lines: RouteLine[]): number;
+//# sourceMappingURL=distanceToRoute.d.ts.map

package/dist/core/position/distanceToRoute.js

@@ -0,0 +1,29 @@
+import { pointDistance } from '@expofp/geometry';
+function distancePointToSegment(px, py, ax, ay, bx, by) {
+    const abx = bx - ax;
+    const aby = by - ay;
+    const apx = px - ax;
+    const apy = py - ay;
+    const abLen2 = abx * abx + aby * aby;
+    if (abLen2 === 0)
+        return pointDistance({ x: px, y: py }, { x: ax, y: ay });
+    let t = (apx * abx + apy * aby) / abLen2;
+    if (t < 0)
+        t = 0;
+    else if (t > 1)
+        t = 1;
+    const cx = ax + t * abx;
+    const cy = ay + t * aby;
+    return pointDistance({ x: px, y: py }, { x: cx, y: cy });
+}
+export function distancePointToRouteOnLayer(point, lines) {
+    let best = Infinity;
+    for (const line of lines) {
+        if (point.layer && (line.p0.layer !== point.layer || line.p1.layer !== point.layer))
+            continue;
+        const dist = distancePointToSegment(point.x, point.y, line.p0.x, line.p0.y, line.p1.x, line.p1.y);
+        if (dist < best)
+            best = dist;
+    }
+    return best;
+}

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

@@ -0,0 +1,32 @@
+export declare const SNAP_THRESHOLD_METERS = 7.5;
+export interface GpsProjectionConfig {
+    readonly p0: {
+        x: number;
+        y: number;
+        lat: number;
+        lng: number;
+    };
+    readonly p2: {
+        x: number;
+        y: number;
+        lat: number;
+        lng: number;
+    };
+}
+export declare const getThresholdSafe: (value?: number) => number | undefined;
+export declare const getThresholdOrDefault: (value: number | undefined, defaultValue: number) => number;
+export declare function getThresholdFromMetersToSvg({ thresholdInMeters, gpsConfig, }: {
+    thresholdInMeters?: number;
+    gpsConfig?: GpsProjectionConfig;
+}): number;
+/**
+ * Resolves the reroute threshold (SVG units) for the active plan: honours
+ * `gpsConfig.rerouteThreshold` (meters) override, otherwise falls back to
+ * {@link REROUTE_THRESHOLD_METERS}. Returns plan-scaled SVG units suitable
+ * for `shouldReroute`.
+ * @param gpsConfig
+ */
+export declare function resolveRerouteThresholdSvg(gpsConfig?: GpsProjectionConfig & {
+    rerouteThreshold?: number;
+}): number;
+//# sourceMappingURL=gpsThreshold.d.ts.map

package/dist/core/position/gpsThreshold.js

@@ -0,0 +1,48 @@
+import { haversineDistance, pointDistance } from '@expofp/geometry';
+export const SNAP_THRESHOLD_METERS = 7.5;
+// Reroute must be strictly larger than snap.
+const REROUTE_THRESHOLD_METERS = 15;
+const FALLBACK_SVG_THRESHOLD = 20;
+function metersToSvgUnits(meters, gpsConfig) {
+    const { p0, p2 } = gpsConfig;
+    const fullGpsDistance = haversineDistance(p0, p2);
+    const fullSvgLength = pointDistance(p0, p2);
+    if (!fullGpsDistance || !fullSvgLength)
+        return 0;
+    return meters * (fullSvgLength / fullGpsDistance);
+}
+export const getThresholdSafe = (value) => {
+    if (typeof value === 'number' && Number.isFinite(value)) {
+        return value;
+    }
+    return;
+};
+export const getThresholdOrDefault = (value, defaultValue) => {
+    const threshold = getThresholdSafe(value);
+    if (threshold === undefined || threshold === 0) {
+        return defaultValue;
+    }
+    return threshold;
+};
+export function getThresholdFromMetersToSvg({ thresholdInMeters, gpsConfig, }) {
+    let thresholdSvg = 0;
+    // 0 / missing meters → "not configured" → fall back to FALLBACK_SVG_THRESHOLD.
+    if (thresholdInMeters && gpsConfig) {
+        thresholdSvg = metersToSvgUnits(thresholdInMeters, gpsConfig);
+    }
+    if (!thresholdSvg) {
+        thresholdSvg = FALLBACK_SVG_THRESHOLD;
+    }
+    return thresholdSvg;
+}
+/**
+ * Resolves the reroute threshold (SVG units) for the active plan: honours
+ * `gpsConfig.rerouteThreshold` (meters) override, otherwise falls back to
+ * {@link REROUTE_THRESHOLD_METERS}. Returns plan-scaled SVG units suitable
+ * for `shouldReroute`.
+ * @param gpsConfig
+ */
+export function resolveRerouteThresholdSvg(gpsConfig) {
+    const thresholdInMeters = getThresholdOrDefault(gpsConfig?.rerouteThreshold, REROUTE_THRESHOLD_METERS);
+    return getThresholdFromMetersToSvg({ thresholdInMeters, gpsConfig });
+}

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

@@ -0,0 +1,13 @@
+import type { RouteLine, RoutePoint } from '../types.js';
+/** Decides whether the current GPS tick warrants rebuilding the route. */
+export interface RerouteController {
+    /** Evaluates the current tick. Returns `true` when the caller should rebuild the route. */
+    shouldReroute(position: RoutePoint, routeLines: RouteLine[]): boolean;
+}
+/**
+ * `thresholdSvg` — plan-scale-aware off-route distance (SVG units), produced by
+ *  `resolveRerouteThresholdSvg` and passed in by the composition root.
+ * @param thresholdSvg
+ */
+export declare function createRerouteController(thresholdSvg: number): RerouteController;
+//# sourceMappingURL=rerouteController.d.ts.map

package/dist/core/position/rerouteController.js

@@ -0,0 +1,22 @@
+import { distancePointToRouteOnLayer } from './distanceToRoute.js';
+/**
+ * `thresholdSvg` — plan-scale-aware off-route distance (SVG units), produced by
+ *  `resolveRerouteThresholdSvg` and passed in by the composition root.
+ * @param thresholdSvg
+ */
+export function createRerouteController(thresholdSvg) {
+    return {
+        shouldReroute(position, routeLines) {
+            if (!routeLines.length)
+                return false;
+            const positionLayer = position.layer;
+            // Layer mismatch — route doesn't touch CP's layer; fire without the distance check.
+            if (positionLayer &&
+                !routeLines.some((line) => line.p0.layer === positionLayer && line.p1.layer === positionLayer)) {
+                return true;
+            }
+            const distance = distancePointToRouteOnLayer(position, routeLines);
+            return distance > thresholdSvg;
+        },
+    };
+}

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

@@ -0,0 +1,9 @@
+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;
+//# sourceMappingURL=snapToRoute.d.ts.map

package/dist/core/position/snapToRoute.js

@@ -0,0 +1,50 @@
+import { pointDistance } from '@expofp/geometry';
+import { projectPointOnSegment } from '../geometry/projectPointOnSegment.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 function snapToRoute(position, routeLines, { snapThreshold }) {
+    const lineCount = routeLines.length;
+    if (!lineCount)
+        return { snapped: false };
+    const posLayer = position.layer || null;
+    let bestDistance = Infinity;
+    let best = null;
+    let accumulatedLength = 0;
+    let hasSegmentOnPosLayer = posLayer == null;
+    for (let i = 0; i < lineCount; i++) {
+        const line = routeLines[i];
+        const { p0, p1 } = line;
+        const segLen = pointDistance(p0, p1);
+        if (segLen === 0)
+            continue;
+        if (posLayer != null && String(p0.layer) !== posLayer) {
+            accumulatedLength += segLen;
+            continue;
+        }
+        hasSegmentOnPosLayer = true;
+        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,
+            };
+        }
+        accumulatedLength += segLen;
+    }
+    if (posLayer != null && !hasSegmentOnPosLayer)
+        return { snapped: false };
+    if (!best || bestDistance > snapThreshold)
+        return { snapped: false };
+    return {
+        snapped: true,
+        snappedPoint: best.point,
+        snappedLine: best.line,
+        distance: accumulatedLength - best.fromStart,
+    };
+}

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

@@ -0,0 +1,6 @@
+import { type RouteLine, type RoutePoint } from '../types.js';
+export declare function splitRouteByPoint(routeLines: RouteLine[], snapPoint: RoutePoint): {
+    passed: RouteLine[];
+    remaining: RouteLine[];
+};
+//# sourceMappingURL=splitRouteByPoint.d.ts.map

package/dist/core/position/splitRouteByPoint.js

@@ -0,0 +1,56 @@
+export function splitRouteByPoint(routeLines, snapPoint) {
+    const EPS = 1e-6;
+    let bestIndex = -1;
+    let bestT = 0;
+    let bestDist = Infinity;
+    for (let i = 0; i < routeLines.length; i++) {
+        const line = routeLines[i];
+        if (line.p0.layer !== snapPoint.layer)
+            continue;
+        const dx = line.p1.x - line.p0.x;
+        const dy = line.p1.y - line.p0.y;
+        const len2 = dx * dx + dy * dy;
+        if (len2 === 0)
+            continue;
+        const t = ((snapPoint.x - line.p0.x) * dx + (snapPoint.y - line.p0.y) * dy) / len2;
+        if (t < -EPS || t > 1 + EPS)
+            continue;
+        const clampedT = Math.min(1, Math.max(0, t));
+        const px = line.p0.x + clampedT * dx;
+        const py = line.p0.y + clampedT * dy;
+        const dist = (snapPoint.x - px) ** 2 + (snapPoint.y - py) ** 2;
+        if (dist < bestDist) {
+            bestDist = dist;
+            bestIndex = i;
+            bestT = clampedT;
+        }
+    }
+    if (bestIndex === -1) {
+        return {
+            passed: [],
+            remaining: routeLines,
+        };
+    }
+    if (bestT < EPS) {
+        return {
+            passed: routeLines.slice(0, bestIndex),
+            remaining: routeLines.slice(bestIndex),
+        };
+    }
+    if (bestT > 1 - EPS) {
+        return {
+            passed: routeLines.slice(0, bestIndex + 1),
+            remaining: routeLines.slice(bestIndex + 1),
+        };
+    }
+    const line = routeLines[bestIndex];
+    const splitPoint = {
+        layer: line.p0.layer,
+        x: line.p0.x + bestT * (line.p1.x - line.p0.x),
+        y: line.p0.y + bestT * (line.p1.y - line.p0.y),
+    };
+    return {
+        passed: [...routeLines.slice(0, bestIndex), { ...line, p1: splitPoint }],
+        remaining: [{ ...line, p0: splitPoint }, ...routeLines.slice(bestIndex + 1)],
+    };
+}

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

@@ -0,0 +1,12 @@
+import { type Point2Like } from '@expofp/geometry';
+/**
+ * Generates evenly-spaced points along a quadratic Bézier curve
+ * between two points. Used for dotted trail visualization when
+ * a point (kiosk, GPS, marker, etc.) is far from the route.
+ * @param from - Start point (e.g. route endpoint)
+ * @param to - End point (e.g. off-route position)
+ * @param interval - Spacing between points in SVG units (default: 8)
+ * @param curvature - Arc height as fraction of distance (0 = straight, 0.4 = default arc)
+ */
+export declare function computeTrailPoints(from: Point2Like, to: Point2Like, interval?: number, curvature?: number): Point2Like[];
+//# sourceMappingURL=computeTrailPoints.d.ts.map

package/dist/core/rendering/computeTrailPoints.js

@@ -0,0 +1,35 @@
+import { pointDistance } from '@expofp/geometry';
+const DEFAULT_CURVATURE = 0.4;
+const DEFAULT_INTERVAL = 8;
+/**
+ * Generates evenly-spaced points along a quadratic Bézier curve
+ * between two points. Used for dotted trail visualization when
+ * a point (kiosk, GPS, marker, etc.) is far from the route.
+ * @param from - Start point (e.g. route endpoint)
+ * @param to - End point (e.g. off-route position)
+ * @param interval - Spacing between points in SVG units (default: 8)
+ * @param curvature - Arc height as fraction of distance (0 = straight, 0.4 = default arc)
+ */
+export function computeTrailPoints(from, to, interval = DEFAULT_INTERVAL, curvature = DEFAULT_CURVATURE) {
+    const distance = pointDistance(to, from);
+    if (distance === 0 || interval <= 0)
+        return [];
+    const count = Math.max(Math.ceil(distance / interval) + 1, 2);
+    const mid = {
+        x: (from.x + to.x) / 2,
+        y: (from.y + to.y) / 2 - distance * curvature,
+    };
+    const points = [];
+    for (let i = 0; i < count; i++) {
+        const t = i / (count - 1);
+        points.push(quadraticBezier(from, mid, to, t));
+    }
+    return points;
+}
+function quadraticBezier(p0, p1, p2, t) {
+    const mt = 1 - t;
+    return {
+        x: mt * mt * p0.x + 2 * mt * t * p1.x + t * t * p2.x,
+        y: mt * mt * p0.y + 2 * mt * t * p1.y + t * t * p2.y,
+    };
+}

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

@@ -0,0 +1,32 @@
+import { type RouteLine } from '../types.js';
+interface TransitionPointsInput {
+    /** Full route including virtual lines */
+    readonly routeLines: RouteLine[];
+    /** Floor to scope to. `null` = no floor scoping (returns transitions on every floor). */
+    readonly currentLayerName: string | null;
+    /** Floor names ordered low → high (from layerStore.floors) */
+    readonly floorOrder: string[];
+}
+export interface TransitionPointDef {
+    readonly x: number;
+    readonly y: number;
+    /** Floor where the icon is rendered */
+    readonly layer: string;
+    /** Floor the transition leads to (for click-to-switch) */
+    readonly targetLayer: string;
+    readonly direction: 'up' | 'down' | 'neutral';
+    /** Whether this is an entry (arriving from another floor) or exit (leaving to another floor) in walking direction */
+    readonly role: 'entry' | 'exit';
+}
+/**
+ * Computes deduplicated, correctly-directed transition points for the
+ * current floor.
+ *
+ * Works directly with the full `routeLines` array (including virtual lines)
+ * and does NOT depend on `routeNextFloor` — the target floor is read from
+ * the opposite endpoint of each virtual line.
+ * @param input
+ */
+export declare function computeTransitionPoints(input: TransitionPointsInput): TransitionPointDef[];
+export {};
+//# sourceMappingURL=computeTransitionPoints.d.ts.map

package/dist/core/rendering/computeTransitionPoints.js

@@ -0,0 +1,114 @@
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+function layersMatch(a, b) {
+    return a.toLowerCase() === b.toLowerCase();
+}
+function findFloorIndex(floorOrder, layerName) {
+    return floorOrder.findIndex((name) => layersMatch(name, layerName));
+}
+function resolveDirection(floorOrder, currentLayer, targetLayer) {
+    const currentIndex = findFloorIndex(floorOrder, currentLayer);
+    const targetIndex = findFloorIndex(floorOrder, targetLayer);
+    if (currentIndex === -1 || targetIndex === -1)
+        return 'neutral';
+    return targetIndex > currentIndex ? 'up' : 'down';
+}
+function findNextVirtualLink(crossFloorLines, fromLayer, visited) {
+    return crossFloorLines.find((line) => {
+        if (layersMatch(line.p0.layer, fromLayer))
+            return !visited.has(line.p1.layer.toLowerCase());
+        if (layersMatch(line.p1.layer, fromLayer))
+            return !visited.has(line.p0.layer.toLowerCase());
+        return false;
+    });
+}
+/**
+ * Follows a chain of virtual lines through transit floors (floors with no
+ * physical route lines) until reaching a floor that has physical lines.
+ *
+ * Example: route L1 → L2(transit) → L3 — immediateTarget is L2,
+ * but L2 has no physical lines, so we follow the virtual chain to L3.
+ * @param crossFloorLines
+ * @param floorsWithPhysicalLines
+ * @param currentLayer
+ * @param immediateTarget
+ */
+function resolveTransitTarget(crossFloorLines, floorsWithPhysicalLines, currentLayer, immediateTarget) {
+    if (floorsWithPhysicalLines.has(immediateTarget.toLowerCase())) {
+        return immediateTarget;
+    }
+    let target = immediateTarget;
+    const visited = new Set([currentLayer.toLowerCase(), target.toLowerCase()]);
+    let next = findNextVirtualLink(crossFloorLines, target, visited);
+    while (next) {
+        target = layersMatch(next.p0.layer, target) ? next.p1.layer : next.p0.layer;
+        if (floorsWithPhysicalLines.has(target.toLowerCase()))
+            break;
+        visited.add(target.toLowerCase());
+        next = findNextVirtualLink(crossFloorLines, target, visited);
+    }
+    return target;
+}
+// ---------------------------------------------------------------------------
+// Main
+// ---------------------------------------------------------------------------
+/**
+ * Computes deduplicated, correctly-directed transition points for the
+ * current floor.
+ *
+ * Works directly with the full `routeLines` array (including virtual lines)
+ * and does NOT depend on `routeNextFloor` — the target floor is read from
+ * the opposite endpoint of each virtual line.
+ * @param input
+ */
+export function computeTransitionPoints(input) {
+    const { routeLines, currentLayerName, floorOrder } = input;
+    // 1. Only virtual lines that actually cross floors
+    const crossFloorLines = routeLines.filter((line) => line.virtual && !layersMatch(line.p0.layer, line.p1.layer));
+    // 2. Floors that have physical (non-virtual) route lines — used to skip transit floors
+    const floorsWithPhysicalLines = new Set();
+    for (const line of routeLines) {
+        if (!line.virtual) {
+            floorsWithPhysicalLines.add(line.p0.layer.toLowerCase());
+            floorsWithPhysicalLines.add(line.p1.layer.toLowerCase());
+        }
+    }
+    // 3. Keep only lines touching the current floor (when set)
+    const relevantLines = currentLayerName
+        ? crossFloorLines.filter((line) => layersMatch(line.p0.layer, currentLayerName) ||
+            layersMatch(line.p1.layer, currentLayerName))
+        : crossFloorLines;
+    // 4. Pick the endpoint on the current floor; the other is the target
+    const points = relevantLines.map((line) => {
+        const pickP0 = currentLayerName ? layersMatch(line.p0.layer, currentLayerName) : true;
+        const visible = pickP0 ? line.p0 : line.p1;
+        const target = pickP0 ? line.p1 : line.p0;
+        // Follow virtual chain through transit floors (e.g. L1→L2(transit)→L3 → targetLayer=L3)
+        const resolvedTarget = resolveTransitTarget(crossFloorLines, floorsWithPhysicalLines, visible.layer, target.layer);
+        return {
+            x: visible.x,
+            y: visible.y,
+            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',
+        };
+    });
+    // 5. Deduplicate by coordinates. Drop entries that collide with an exit
+    //    at the same node so the directional transition_up/down icon isn't
+    //    overridden by transition_entry in multi-point routes.
+    const exitKeys = new Set(points.filter((p) => p.role === 'exit').map((p) => `${p.x}:${p.y}`));
+    const emittedKeys = new Set();
+    return points.filter((point) => {
+        const key = `${point.x}:${point.y}`;
+        if (point.role === 'entry' && exitKeys.has(key))
+            return false;
+        if (emittedKeys.has(key))
+            return false;
+        emittedKeys.add(key);
+        return true;
+    });
+}

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

@@ -0,0 +1,10 @@
+import { type RouteLine } from '../types.js';
+/**
+ * Filters route lines for a given floor: removes virtual segments
+ * and keeps only lines on the specified floor.
+ * @param routeLines - All route lines (may span multiple floors)
+ * @param currentFloor - Floor to filter by, or `null` to return all non-virtual lines
+ *   (single-floor plans / "show all" mode)
+ */
+export declare function getVisibleRouteLines(routeLines: readonly RouteLine[], currentFloor: string | null): RouteLine[];
+//# sourceMappingURL=getVisibleRouteLines.d.ts.map

package/dist/core/rendering/getVisibleRouteLines.js

@@ -0,0 +1,18 @@
+/**
+ * Filters route lines for a given floor: removes virtual segments
+ * and keeps only lines on the specified floor.
+ * @param routeLines - All route lines (may span multiple floors)
+ * @param currentFloor - Floor to filter by, or `null` to return all non-virtual lines
+ *   (single-floor plans / "show all" mode)
+ */
+export function getVisibleRouteLines(routeLines, currentFloor) {
+    const result = [];
+    for (const line of routeLines) {
+        if (line.virtual)
+            continue;
+        if (currentFloor !== null && line.p0.layer !== currentFloor)
+            continue;
+        result.push(line);
+    }
+    return result;
+}

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

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