@expofp/wayfinding 3.11.11

package/dist/core/rendering/normalizeRouteDirection.js

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

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

@@ -0,0 +1,9 @@
+import { Box, type Point2Like } from '@expofp/geometry';
+/**
+ * Computes the axis-aligned bounding box of a set of points.
+ * Always returns a {@link Box}. An empty array returns `Box.fromPoints([])` — a zero-size
+ * box at the origin — which is distinguished from a real route bbox via `.isEmpty()`.
+ * @param points
+ */
+export declare function computeBoundingBox(points: readonly Point2Like[]): Box;
+//# sourceMappingURL=routeGeometry.d.ts.map

package/dist/core/rendering/routeGeometry.js

@@ -0,0 +1,10 @@
+import { Box } from '@expofp/geometry';
+/**
+ * Computes the axis-aligned bounding box of a set of points.
+ * Always returns a {@link Box}. An empty array returns `Box.fromPoints([])` — a zero-size
+ * box at the origin — which is distinguished from a real route bbox via `.isEmpty()`.
+ * @param points
+ */
+export function computeBoundingBox(points) {
+    return Box.fromPoints(points);
+}

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

@@ -0,0 +1,13 @@
+import { type GraphInstance, type RoutePoint, type RouteResult } from '../types.js';
+/**
+ * Builds a route through an ordered sequence of pre-resolved candidate groups.
+ * Each group is a `RoutePoint[]` — the candidate graph points for one waypoint.
+ *
+ * Intermediate groups with no candidates (empty arrays) are silently skipped —
+ * adjacent groups are connected directly. This matches the legacy behavior
+ * where unreachable waypoints were omitted.
+ * @param graph
+ * @param candidateGroups
+ */
+export declare function buildMultiPointRoute(graph: GraphInstance, candidateGroups: RoutePoint[][]): RouteResult;
+//# sourceMappingURL=buildMultiPointRoute.d.ts.map

package/dist/core/routing/buildMultiPointRoute.js

@@ -0,0 +1,36 @@
+import { buildRoute } from './buildRoute.js';
+import { emptyResult } from './routeResult.js';
+/**
+ * Builds a route through an ordered sequence of pre-resolved candidate groups.
+ * Each group is a `RoutePoint[]` — the candidate graph points for one waypoint.
+ *
+ * Intermediate groups with no candidates (empty arrays) are silently skipped —
+ * adjacent groups are connected directly. This matches the legacy behavior
+ * where unreachable waypoints were omitted.
+ * @param graph
+ * @param candidateGroups
+ */
+export function buildMultiPointRoute(graph, candidateGroups) {
+    if (candidateGroups.length < 2)
+        return emptyResult();
+    // Skip intermediate waypoints with no graph candidates (legacy behavior:
+    // the old code omitted such waypoints from pointsArr, connecting adjacent ones)
+    const reachable = candidateGroups.filter((candidates, index) => {
+        if (index === 0 || index === candidateGroups.length - 1)
+            return true;
+        return candidates.length > 0;
+    });
+    if (reachable.length < 2)
+        return emptyResult();
+    if (reachable.length === 2)
+        return buildRoute(graph, reachable[0], reachable[1]);
+    const segmentResults = [];
+    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.
+    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/buildRoute.d.ts

@@ -0,0 +1,12 @@
+import { type GraphInstance, type RoutePoint, type RouteResult } from '../types.js';
+/**
+ * Builds a route between two sets of candidate graph points.
+ *
+ * This is pure pathfinding — it does not resolve waypoints to graph points.
+ * Resolution is the caller's responsibility (see `getGraphLines`).
+ * @param graph
+ * @param fromCandidates
+ * @param toCandidates
+ */
+export declare function buildRoute(graph: GraphInstance, fromCandidates: RoutePoint[], toCandidates: RoutePoint[]): RouteResult;
+//# sourceMappingURL=buildRoute.d.ts.map

package/dist/core/routing/buildRoute.js

@@ -0,0 +1,19 @@
+import { findShortestPath } from '../graph/findShortestPath.js';
+import { emptyResult } from './routeResult.js';
+/**
+ * Builds a route between two sets of candidate graph points.
+ *
+ * This is pure pathfinding — it does not resolve waypoints to graph points.
+ * Resolution is the caller's responsibility (see `getGraphLines`).
+ * @param graph
+ * @param fromCandidates
+ * @param toCandidates
+ */
+export function buildRoute(graph, fromCandidates, toCandidates) {
+    if (!fromCandidates.length || !toCandidates.length)
+        return emptyResult();
+    const result = findShortestPath(graph, fromCandidates, toCandidates);
+    if (!result)
+        return emptyResult();
+    return { lines: result.lines, totalDistance: result.distance };
+}

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

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

package/dist/core/routing/getRouteLength.js

@@ -0,0 +1,4 @@
+import { pointDistance } from '@expofp/geometry';
+export function getRouteLength(routeLines) {
+    return routeLines.reduce((distance, line) => distance + pointDistance(line.p0, line.p1), 0);
+}

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

@@ -0,0 +1,9 @@
+import { type GraphDataSource, type PolygonVertex, type RoutePoint } from '../types.js';
+/**
+ * Graph endpoints inside a convex polygon (e.g. booth rect), filtered by layer.
+ * @param dataSource
+ * @param polygon
+ * @param layer
+ */
+export declare function findGraphPointsInPolygon(dataSource: GraphDataSource, polygon: readonly PolygonVertex[], layer?: string): RoutePoint[];
+//# sourceMappingURL=graphPointResolvers.d.ts.map

package/dist/core/routing/graphPointResolvers.js

@@ -0,0 +1,13 @@
+import { computePolygonArea, pointInPolygon } from '../geometry/pointInPolygon.js';
+/**
+ * Graph endpoints inside a convex polygon (e.g. booth rect), filtered by layer.
+ * @param dataSource
+ * @param polygon
+ * @param layer
+ */
+export function findGraphPointsInPolygon(dataSource, polygon, layer) {
+    const polygonArea = computePolygonArea(polygon);
+    return dataSource
+        .getLineEnds()
+        .filter((lineEnd) => (!layer || lineEnd.layer === layer) && pointInPolygon(lineEnd, polygon, polygonArea));
+}

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

@@ -0,0 +1,14 @@
+import type { Point2Like } from '@expofp/geometry';
+/**
+ * Optimizes waypoint ordering to minimize total travel distance.
+ * Nearest neighbor O(n²) + 2-opt refinement O(k·n²), k ≤ 100.
+ * @param data
+ */
+export declare function optimizeWaypointOrder(data: readonly [string, Point2Like][]): string[];
+/**
+ * Reorders waypoints for fastest traversal.
+ * First and last stay fixed (from/to), only middle waypoints are reordered.
+ * @param waypoints
+ */
+export declare function reorderWaypoints<T extends Point2Like>(waypoints: T[]): T[];
+//# sourceMappingURL=optimizeWaypointOrder.d.ts.map

package/dist/core/routing/optimizeWaypointOrder.js

@@ -0,0 +1,88 @@
+const MAX_ITERATIONS = 100;
+const MIN_IMPROVEMENT = -0.01;
+/**
+ * Optimizes waypoint ordering to minimize total travel distance.
+ * Nearest neighbor O(n²) + 2-opt refinement O(k·n²), k ≤ 100.
+ * @param data
+ */
+export function optimizeWaypointOrder(data) {
+    const points = new Map(data);
+    const waypoints = Array.from(points.keys());
+    if (waypoints.length <= 2)
+        return waypoints;
+    const route = nearestNeighbor(waypoints, points);
+    return route.length < 4 ? route : twoOpt(route, points);
+}
+/**
+ * Reorders waypoints for fastest traversal.
+ * First and last stay fixed (from/to), only middle waypoints are reordered.
+ * @param waypoints
+ */
+export function reorderWaypoints(waypoints) {
+    if (waypoints.length <= 3)
+        return waypoints;
+    const first = waypoints[0];
+    const last = waypoints[waypoints.length - 1];
+    const middle = waypoints.slice(1, -1);
+    const indexed = middle.map((wp, index) => [
+        String(index),
+        { x: wp.x, y: wp.y },
+    ]);
+    const optimizedOrder = optimizeWaypointOrder(indexed);
+    const reordered = optimizedOrder.map((index) => middle[Number(index)]);
+    return [first, ...reordered, last];
+}
+function nearestNeighbor(waypoints, points) {
+    const sorted = [waypoints[0]];
+    const remaining = new Set(waypoints);
+    let current = waypoints[0];
+    remaining.delete(waypoints[0]);
+    while (remaining.size > 0) {
+        const cur = points.get(current);
+        let nearest = '';
+        let minDist = Infinity;
+        for (const id of remaining) {
+            const pt = points.get(id);
+            const distance = Math.abs(cur.x - pt.x) + Math.abs(cur.y - pt.y);
+            if (distance < minDist) {
+                minDist = distance;
+                nearest = id;
+            }
+        }
+        if (!nearest)
+            break;
+        sorted.push(nearest);
+        remaining.delete(nearest);
+        current = nearest;
+    }
+    return sorted;
+}
+function twoOpt(route, points) {
+    const result = [...route];
+    let improved = true;
+    for (let iter = 0; improved && iter < MAX_ITERATIONS; iter++) {
+        improved = false;
+        scan: for (let index = 1; index < result.length - 2; index++) {
+            for (let swapEnd = index + 1; swapEnd < result.length - 1; swapEnd++) {
+                const before = points.get(result[index - 1]);
+                const start = points.get(result[index]);
+                const end = points.get(result[swapEnd]);
+                const after = points.get(result[swapEnd + 1]);
+                const delta = Math.abs(before.x - end.x) +
+                    Math.abs(before.y - end.y) +
+                    Math.abs(start.x - after.x) +
+                    Math.abs(start.y - after.y) -
+                    (Math.abs(before.x - start.x) + Math.abs(before.y - start.y)) -
+                    (Math.abs(end.x - after.x) + Math.abs(end.y - after.y));
+                if (delta < MIN_IMPROVEMENT) {
+                    for (let left = index, right = swapEnd; left < right; left++, right--) {
+                        [result[left], result[right]] = [result[right], result[left]];
+                    }
+                    improved = true;
+                    break scan;
+                }
+            }
+        }
+    }
+    return result;
+}

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

@@ -0,0 +1,23 @@
+import type { GraphInstance, RouteEndpoint, RouteLine, RoutePoint } from '../types.js';
+export interface OffGraphEntry {
+    readonly segment: RouteLine;
+    readonly projection: RoutePoint;
+}
+/**
+ * A* candidates plus an optional `offGraphEntry` — set when the route's entry needs perpendicular
+ *  trim to land on a point inside a segment instead of at a graph node.
+ */
+export interface ResolvedCandidates {
+    readonly candidates: RoutePoint[];
+    readonly offGraphEntry: OffGraphEntry | null;
+}
+/**
+ * Turns a route endpoint into A* candidates.
+ *  - Booth (has `bounds`) → graph nodes inside the polygon.
+ *  - Off-graph point → nearest segment on its layer; both ends are candidates and `offGraphEntry`
+ *    holds the perpendicular foot to trim to. If the foot falls off the segment, attach at its node.
+ * @param graph
+ * @param endpoint
+ */
+export declare function resolveWaypointCandidates(graph: GraphInstance, endpoint: RouteEndpoint): ResolvedCandidates;
+//# sourceMappingURL=resolveWaypointCandidates.d.ts.map

package/dist/core/routing/resolveWaypointCandidates.js

@@ -0,0 +1,49 @@
+import { projectPointOnSegment, } from '../geometry/projectPointOnSegment.js';
+import { findGraphPointsInPolygon } from './graphPointResolvers.js';
+/**
+ * Turns a route endpoint into A* candidates.
+ *  - Booth (has `bounds`) → graph nodes inside the polygon.
+ *  - Off-graph point → nearest segment on its layer; both ends are candidates and `offGraphEntry`
+ *    holds the perpendicular foot to trim to. If the foot falls off the segment, attach at its node.
+ * @param graph
+ * @param endpoint
+ */
+export function resolveWaypointCandidates(graph, endpoint) {
+    if (endpoint.bounds?.length) {
+        return {
+            candidates: findGraphPointsInPolygon(graph.dataSource, endpoint.bounds, endpoint.layer),
+            offGraphEntry: null,
+        };
+    }
+    let nearest = null;
+    let nearestDistance = Infinity;
+    for (const line of graph.dataSource.getLines()) {
+        if (line.virtual)
+            continue;
+        if (endpoint.layer && line.p0.layer !== endpoint.layer)
+            continue;
+        if (line.p0.x === line.p1.x && line.p0.y === line.p1.y)
+            continue;
+        const proj = projectPointOnSegment(endpoint, line.p0, line.p1);
+        if (proj.distance < nearestDistance) {
+            nearestDistance = proj.distance;
+            nearest = { segment: line, proj };
+        }
+    }
+    if (!nearest)
+        return { candidates: [], offGraphEntry: null };
+    const { segment, proj } = nearest;
+    // Foot outside the segment → closest point is a graph node; attach there directly, no trim.
+    if (proj.t === 0)
+        return { candidates: [segment.p0], offGraphEntry: null };
+    if (proj.t === 1)
+        return { candidates: [segment.p1], offGraphEntry: null };
+    // Foot inside the segment → both ends are A* candidates (shorter path wins); trim to the foot.
+    return {
+        candidates: [segment.p0, segment.p1],
+        offGraphEntry: {
+            segment,
+            projection: { layer: segment.p0.layer, x: proj.projected.x, y: proj.projected.y },
+        },
+    };
+}

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

@@ -0,0 +1,4 @@
+import { type RouteResult } from '../types.js';
+/** Returns a fresh empty result each call to avoid shared-mutable-object bugs at runtime. */
+export declare const emptyResult: () => RouteResult;
+//# sourceMappingURL=routeResult.d.ts.map

package/dist/core/routing/routeResult.js

@@ -0,0 +1,2 @@
+/** Returns a fresh empty result each call to avoid shared-mutable-object bugs at runtime. */
+export const emptyResult = () => ({ lines: [], totalDistance: 0 });

package/dist/core/types.d.ts

@@ -0,0 +1,102 @@
+export interface PolygonVertex {
+    readonly x: number;
+    readonly y: number;
+}
+export interface RoutePoint {
+    readonly x: number;
+    readonly y: number;
+    readonly layer: string;
+}
+/**
+ * A computed route segment — the public output of routing, consumed by the
+ * runtime and rendering. Carries only what consumers read; graph-build
+ * properties (direction, cost) live on {@link GraphLine}, not here.
+ */
+export interface RouteLine {
+    readonly p0: RoutePoint;
+    readonly p1: RoutePoint;
+    /** Virtual link rather than a physical path segment. May or may not change layers. */
+    readonly virtual: boolean;
+}
+/**
+ * A source graph line from external wayfinding data (wf.data.js) — the input to
+ * graph building. Extends {@link RouteLine} with build-only properties
+ * (accessibility, direction, cost) that never reach a computed route.
+ */
+export interface GraphLine extends RouteLine {
+    /** Flagged inaccessible in source data: graph-build filter + the venue accessible toggle. */
+    readonly unaccessible: boolean;
+    /** One-way link: in oriented mode no reverse edge is added. */
+    readonly unidirection: boolean;
+    /** 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.
+     */
+    readonly virtualLength?: number;
+}
+export interface PathNode {
+    readonly id: string;
+    readonly layer: string;
+    readonly x: number;
+    readonly y: number;
+}
+export interface PathFinderOptions {
+    readonly oriented: boolean;
+    readonly onlyAccessible: boolean;
+}
+export interface PathFinder {
+    build(lines: GraphLine[], options: PathFinderOptions): void;
+    find(fromId: string, toId: string): PathNode[];
+    hasNode(id: string): boolean;
+}
+export interface GraphDataSource {
+    getLines(): GraphLine[];
+    getLineEnds(): RoutePoint[];
+}
+export interface GraphInstance {
+    readonly finder: PathFinder;
+    readonly dataSource: GraphDataSource;
+    readonly options: GraphBuildOptions;
+}
+export interface GraphBuildOptions {
+    readonly oriented?: boolean;
+    readonly onlyAccessible?: boolean;
+}
+export interface ShortestPathResult {
+    readonly lines: RouteLine[];
+    readonly distance: number;
+}
+export interface RouteResult {
+    readonly lines: RouteLine[];
+    readonly totalDistance: number;
+}
+export type RouteSnapResult = {
+    snapped: false;
+} | {
+    readonly snapped: true;
+    readonly snappedPoint: RoutePoint;
+    readonly snappedLine: RouteLine;
+    /** Arc-length from `snappedPoint` to the destination, along the route. */
+    readonly distance: number;
+};
+/**
+ * Route endpoint: anchor on a layer, with optional perimeter polygon (booth bounds).
+ * With `bounds` → engine picks the optimal graph node inside the polygon.
+ * Without `bounds` → off-graph point (e.g. kiosk); engine snaps to nearest graph anchor.
+ *
+ * `id` is an opaque runtime discriminator the engine ignores — used by the
+ * adapter layer to mark off-graph endpoints (e.g. CP-derived vs kiosk anchor)
+ * so the renderer can branch on endpoint origin without re-checking UI types.
+ */
+export interface RouteEndpoint extends RoutePoint {
+    readonly bounds?: readonly PolygonVertex[];
+    readonly id?: string;
+}
+export interface SnapToRouteConfig {
+    readonly snapThreshold: number;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/core/types.js

@@ -0,0 +1 @@
+export {};

package/dist/createWayfinding.d.ts

@@ -0,0 +1,68 @@
+import type { Box } from '@expofp/geometry';
+import type { RenderableDef } from '@expofp/renderer';
+import { type GpsProjectionConfig, type GraphDataSource, type Route, type RouteEndpoint, type RouteLine, type RoutePoint, type TransitionPointDef } from './core/index.js';
+import { type IconConfig, type RendererPort } from './renderer/index.js';
+import { type FloorContext, type IconProvider, type LayerNames, type PositionInput, type SetRouteInput } from './runtime/index.js';
+/** Plan GPS calibration plus optional snap / reroute distance overrides (meters). */
+export type GpsConfig = GpsProjectionConfig & {
+    snapThreshold?: number;
+    rerouteThreshold?: number;
+};
+/**
+ * Everything `createWayfinding` needs. The host implements the four ports
+ * (`dataSource`/`renderer`/`iconProvider`/`floorContext`) so the package stays
+ * free of any concrete renderer, DOM, or app state.
+ */
+export interface WayfindingConfig {
+    readonly dataSource: GraphDataSource;
+    readonly renderer: RendererPort;
+    readonly iconProvider: IconProvider;
+    readonly floorContext: FloorContext;
+    readonly layers: LayerNames;
+    /** Plan GPS calibration; the snap and reroute thresholds are derived from it. */
+    readonly gpsConfig?: GpsConfig;
+    readonly onTransitionClick?: (point: TransitionPointDef) => void;
+    /** Fired when the route changes. `bounds.isEmpty()` detects an empty/cleared route. */
+    readonly onRouteUpdate?: (lines: readonly RouteLine[], bounds: Box) => void;
+    /** Fired when the remaining distance changes (route change + position snaps). */
+    readonly onRouteDistance?: (distance: number) => void;
+}
+/**
+ * The single wayfinding instance. Owns the routing engine, the scene renderer,
+ * and the runtime; the host drives it with route/position/floor updates and
+ * forwards its camera/pointer events to the `apply*`/`handle*` methods.
+ */
+export interface Wayfinding {
+    /** Build (or update) the active route; `false` when no path exists. */
+    setRoute(input: SetRouteInput): boolean;
+    /** Build a one-off route without touching the active scene (diagnostics). */
+    buildRoute(from: RouteEndpoint, to: RouteEndpoint, options?: {
+        accessible?: boolean;
+    }): Route;
+    clearRoute(): void;
+    /** Update the user position; `null` hides the position icon and off-route trail. */
+    setPosition(position: PositionInput | null): void;
+    /** Re-render route content after the active floor changed. */
+    notifyFloorChanged(): void;
+    /** Whether the position has drifted off the active route far enough to reroute. */
+    shouldReroute(position: RoutePoint): boolean;
+    /** Forward a camera-zoom change; rescales icons/trails and commits. */
+    applyScale(scale: number): void;
+    /** Forward a camera-roll change; re-orients cardinal-snap icons and commits. */
+    applyRoll(angle: number): void;
+    /** Forward a pointer click (already picked scene defs); fires icon `onClick`. */
+    handleClick(defs: readonly RenderableDef[]): void;
+    /** Forward a pointer move (already picked scene defs); `true` over a clickable icon. */
+    handleHover(defs: readonly RenderableDef[]): boolean;
+    /**
+     * Place, update, or hide (`config: null`) a host annotation icon — e.g. kiosk
+     * or you-are-here — on the wayfinding icon layer. These icons share the route
+     * icons' scale/roll handling. Buffered — call `flush()` to commit.
+     */
+    setIcon(name: string, config: IconConfig | null, key?: string | number): void;
+    /** Commit buffered scene mutations. */
+    flush(): void;
+    destroy(): void;
+}
+export declare function createWayfinding(config: WayfindingConfig): Wayfinding;
+//# sourceMappingURL=createWayfinding.d.ts.map

package/dist/createWayfinding.js

@@ -0,0 +1,44 @@
+import { createWayfindingEngine, getThresholdFromMetersToSvg, getThresholdOrDefault, resolveRerouteThresholdSvg, SNAP_THRESHOLD_METERS, } from './core/index.js';
+import { createWayfindingRenderer } from './renderer/index.js';
+import { createWayfindingRuntime, } from './runtime/index.js';
+export function createWayfinding(config) {
+    const { dataSource, renderer: rendererPort, iconProvider, floorContext, layers, gpsConfig, } = config;
+    const engine = createWayfindingEngine(dataSource);
+    const renderer = createWayfindingRenderer(rendererPort);
+    const snapThresholdMeters = getThresholdOrDefault(gpsConfig?.snapThreshold, SNAP_THRESHOLD_METERS);
+    const snapThreshold = getThresholdFromMetersToSvg({
+        thresholdInMeters: snapThresholdMeters,
+        gpsConfig,
+    });
+    const runtime = createWayfindingRuntime({
+        engine,
+        renderer,
+        iconProvider,
+        floorContext,
+        layers,
+        snapThreshold,
+        rerouteThreshold: resolveRerouteThresholdSvg(gpsConfig),
+        onTransitionClick: (point) => config.onTransitionClick?.(point),
+        onRouteUpdate: (lines, bounds) => config.onRouteUpdate?.(lines, bounds),
+        onRouteDistance: (distance) => config.onRouteDistance?.(distance),
+    });
+    const renderDefs = (defs) => {
+        if (defs.length)
+            rendererPort.update(...defs);
+    };
+    return {
+        setRoute: (input) => runtime.setRoute(input),
+        buildRoute: (from, to, options) => engine.buildRoute(from, to, options),
+        clearRoute: () => runtime.clearRoute(),
+        setPosition: (position) => runtime.onPositionChanged(position),
+        notifyFloorChanged: () => runtime.onFloorChanged(),
+        shouldReroute: (position) => runtime.shouldReroute(position),
+        applyScale: (scale) => renderDefs(renderer.applyScale(scale)),
+        applyRoll: (angle) => renderDefs(renderer.applyRoll(angle)),
+        handleClick: (defs) => renderer.handleClick(defs),
+        handleHover: (defs) => renderer.handleHover(defs),
+        setIcon: (name, config, key) => renderer.setIcon(name, config, key),
+        flush: () => renderer.flush(),
+        destroy: () => runtime.destroy(),
+    };
+}

package/dist/index.d.ts

@@ -0,0 +1,14 @@
+/**
+ * `@expofp/wayfinding` — framework-neutral wayfinding: routing/snapping engine,
+ * an imperative runtime, and a scene renderer behind a single entry point.
+ */
+export type { GpsConfig, Wayfinding, WayfindingConfig } from './createWayfinding.js';
+export { createWayfinding } from './createWayfinding.js';
+export type { GraphDataSource } from './core/index.js';
+export type { IconConfig, RendererPort } from './renderer/index.js';
+export type { FloorContext, IconAsset, IconName, IconProvider, LayerNames, } from './runtime/index.js';
+export type { GraphLine, Route, RouteEndpoint, RouteLine, RoutePoint, TransitionPointDef, } from './core/index.js';
+export type { PositionInput, SetRouteInput } from './runtime/index.js';
+export { CURRENT_POSITION_POINT_ID } from './runtime/index.js';
+export { optimizeWaypointOrder } from './core/routing/optimizeWaypointOrder.js';
+//# sourceMappingURL=index.d.ts.map