@expofp/floorplan 0.0.0-experimental.2632d13

package/dist/esm/wayfinding/adapters/arbitraryPoint.js

@@ -0,0 +1,25 @@
+import { CURRENT_POSITION_POINT_ID } from '@expofp/wayfinding';
+/** Display name for an {@link ArbitraryPoint} derived from the current GPS position. */
+export const CURRENT_LOCATION_NAME = 'Your Location';
+// Re-exported so app code reaches it through the adapters gateway; the constant is owned by the
+// runtime package (`runtime/positionView`).
+export { CURRENT_POSITION_POINT_ID };
+/** Stable id for the static kiosk-anchor `ArbitraryPoint`. */
+export const KIOSK_ANCHOR_POINT_ID = 'kiosk-anchor';
+/** Stable id for a venue door standing in as one end of a cross-venue journey's
+ *  indoor leg. The engine learns nothing from it — a door is an off-graph
+ *  endpoint exactly like the kiosk anchor beside it (ADR-0010). */
+export const JOURNEY_ENTRANCE_POINT_ID = 'journey-entrance';
+/**
+ * Builds an `ArbitraryPoint` from any `{x, y, z?}`-shaped value (CurrentPosition,
+ * Kiosk descriptor, freeform coords). Normalises `z` to a string `layer`.
+ */
+export function toArbitraryPoint(point, name, id) {
+    return {
+        id,
+        x: point.x,
+        y: point.y,
+        layer: point.z != null ? String(point.z) : '',
+        name,
+    };
+}

package/dist/esm/wayfinding/adapters/boothToEndpoint.d.ts

@@ -0,0 +1,19 @@
+import type { RouteEndpoint } from '@expofp/wayfinding';
+import type { BoothSource } from '../storePorts';
+/**
+ * Converts an efp booth to a neutral {@link RouteEndpoint}. The booth's
+ * (possibly rotated) rectangle becomes a 4-vertex polygon used by the engine
+ * as a containment region for graph-point lookup.
+ *
+ * `booth.rotate` is stored positive-clockwise (y-down) after Task 4, matching
+ * the geometry package convention, so it feeds the geometry Rect directly.
+ * Corner order is top-left, top-right, bottom-right, bottom-left.
+ *
+ * An outdoor PoI is a bare point on no level: it has no size, so the engine
+ * snaps it to the nearest walkway segment the way it snaps a kiosk anchor, and
+ * that walkway belongs to whichever level holds the outdoor network. Every
+ * other booth keeps its polygon and its level, which keeps stacked floors from
+ * sharing graph nodes.
+ */
+export declare function boothToEndpoint(booth: BoothSource): RouteEndpoint;
+//# sourceMappingURL=boothToEndpoint.d.ts.map

package/dist/esm/wayfinding/adapters/boothToEndpoint.js

@@ -0,0 +1,32 @@
+import { Rect } from '@expofp/geometry';
+import { isOutdoorPoiBooth } from '../../utils/outdoor-poi';
+/**
+ * Converts an efp booth to a neutral {@link RouteEndpoint}. The booth's
+ * (possibly rotated) rectangle becomes a 4-vertex polygon used by the engine
+ * as a containment region for graph-point lookup.
+ *
+ * `booth.rotate` is stored positive-clockwise (y-down) after Task 4, matching
+ * the geometry package convention, so it feeds the geometry Rect directly.
+ * Corner order is top-left, top-right, bottom-right, bottom-left.
+ *
+ * An outdoor PoI is a bare point on no level: it has no size, so the engine
+ * snaps it to the nearest walkway segment the way it snaps a kiosk anchor, and
+ * that walkway belongs to whichever level holds the outdoor network. Every
+ * other booth keeps its polygon and its level, which keeps stacked floors from
+ * sharing graph nodes.
+ */
+export function boothToEndpoint(booth) {
+    const rect = booth.rect;
+    if (isOutdoorPoiBooth(booth))
+        return { x: rect.center.x, y: rect.center.y, layer: '' };
+    // Build the (possibly rotated) booth rectangle from its corners. booth.rect is
+    // an unrotated geometry Box; combine it with booth.rotate into a rotated Rect.
+    // Corners are Points (x/y), which already satisfy RouteEndpoint.bounds.
+    const bounds = Rect.fromMinMax(rect.min, rect.max, booth.rotate).corners();
+    return {
+        x: rect.center.x,
+        y: rect.center.y,
+        layer: booth.layer?.name ?? '',
+        bounds,
+    };
+}

package/dist/esm/wayfinding/adapters/campusEndpoints.d.ts

@@ -0,0 +1,13 @@
+import type { Wayfinding } from '@expofp/wayfinding';
+import type { CampusGraphDataSource } from './graphDataSource';
+/**
+ * The wayfinding instance with every route endpoint joining the graph on the layer the graph runs
+ * on where it stands ({@link CampusGraphDataSource.getEndpointLayer}). On a campus graph an object
+ * drawn on a layer no venue owns — an outdoor area's information point, parking, entrance — has
+ * no graph of its own; the converter stubbed it into the shared `WF` graph, so it joins that.
+ * @param wayfinding - The instance to route with.
+ * @param graph - The graph the instance routes over.
+ * @returns The same instance, routing between joined endpoints.
+ */
+export declare function withCampusEndpoints(wayfinding: Wayfinding, graph: Pick<CampusGraphDataSource, 'getEndpointLayer'>): Wayfinding;
+//# sourceMappingURL=campusEndpoints.d.ts.map

package/dist/esm/wayfinding/adapters/campusEndpoints.js

@@ -0,0 +1,25 @@
+/**
+ * The wayfinding instance with every route endpoint joining the graph on the layer the graph runs
+ * on where it stands ({@link CampusGraphDataSource.getEndpointLayer}). On a campus graph an object
+ * drawn on a layer no venue owns — an outdoor area's information point, parking, entrance — has
+ * no graph of its own; the converter stubbed it into the shared `WF` graph, so it joins that.
+ * @param wayfinding - The instance to route with.
+ * @param graph - The graph the instance routes over.
+ * @returns The same instance, routing between joined endpoints.
+ */
+export function withCampusEndpoints(wayfinding, graph) {
+    const join = (endpoint) => {
+        const layer = graph.getEndpointLayer(endpoint);
+        return layer === endpoint.layer ? endpoint : { ...endpoint, layer };
+    };
+    return {
+        ...wayfinding,
+        setRoute: (input) => wayfinding.setRoute({
+            ...input,
+            from: join(input.from),
+            to: join(input.to),
+            waypoints: input.waypoints?.map(join),
+        }),
+        buildRoute: (from, to, options) => wayfinding.buildRoute(join(from), join(to), options),
+    };
+}

package/dist/esm/wayfinding/adapters/canvasIconProvider.d.ts

@@ -0,0 +1,20 @@
+/**
+ * efp-app adapter: creates icon canvases from store.fp.icons.
+ *
+ * Extracts the icon creation block from config-wf.ts (lines 168–248).
+ * All canvases are pre-created eagerly.
+ * Fallback canvases are used when custom images are not available.
+ */
+import type { IconProvider } from '@expofp/wayfinding';
+interface CanvasIconProviderConfig {
+    /** Icon image map — typically store.fp.icons */
+    readonly iconMap: Map<string, HTMLImageElement>;
+    readonly pixelRatio: number;
+    /** Source/current/transition icon color. When set, the drawn canvas replaces the bundled SVG. */
+    readonly sourceColor?: string;
+    /** Destination icon color. When set, the drawn canvas replaces the bundled SVG. */
+    readonly destinationColor?: string;
+}
+export declare function createCanvasIconProvider(config: CanvasIconProviderConfig): IconProvider;
+export {};
+//# sourceMappingURL=canvasIconProvider.d.ts.map

package/dist/esm/wayfinding/adapters/canvasIconProvider.js

@@ -0,0 +1,73 @@
+/**
+ * efp-app adapter: creates icon canvases from store.fp.icons.
+ *
+ * Extracts the icon creation block from config-wf.ts (lines 168–248).
+ * All canvases are pre-created eagerly.
+ * Fallback canvases are used when custom images are not available.
+ */
+import { circleCanvasCssSize, createArrowCurrentCanvas, createCircleCanvas, createCurrentCanvas, createImageCanvas, createTargetCanvas, cssSizeOf, } from '../../components/Map/drawing/config/canvases';
+const DEFAULT_SOURCE_COLOR = '#00A2FF';
+const DEFAULT_DESTINATION_COLOR = '#FF9F06';
+const ICON_SIZE = 34;
+/** The trail dot's radius in CSS pixels. */
+const TRAIL_DOT_RADIUS = 4;
+/** transition_up / transition_down arrows render wider than the square icons. */
+const TRANSITION_ARROW_WIDTH = 56;
+function fromMapOrFallback(iconMap, iconKey, width, height, pixelRatio, fallback) {
+    const image = iconMap.get(iconKey);
+    if (image) {
+        image.id = iconKey;
+        return createImageCanvas(image, width, height, pixelRatio);
+    }
+    return fallback();
+}
+/**
+ * Wraps a canvas as an icon asset, stating the size it is drawn at.
+ *
+ * The creators record that size on the canvas, so it is read back from there rather than from the
+ * canvas's `width` and `height`, which are the backing store in the device pixels it was rasterized
+ * at — a different quantity that says how crisp the icon is, not how big.
+ * @param canvas - A canvas made by one of the creators in `canvases`.
+ * @param cssSize - The size to state when the creator is known to draw a different one.
+ * @returns The asset.
+ */
+function toAsset(canvas, cssSize = cssSizeOf(canvas)) {
+    return { canvas, width: cssSize.width, height: cssSize.height };
+}
+export function createCanvasIconProvider(config) {
+    const { iconMap, pixelRatio } = config;
+    const sourceColor = config.sourceColor ?? DEFAULT_SOURCE_COLOR;
+    const destinationColor = config.destinationColor ?? DEFAULT_DESTINATION_COLOR;
+    // When a color is configured, skip the bundled bitmap for the entries whose
+    // drawn fallback is a FULL replacement (source, destination, transition_entry)
+    // so the configured color wins. Entries whose fallback only draws a plain
+    // circle (transition_up/down) or that must keep the bundled art keep iconMap.
+    const sourceIcons = config.sourceColor ? new Map() : iconMap;
+    const destinationIcons = config.destinationColor ? new Map() : iconMap;
+    const icons = new Map();
+    icons.set('destination', toAsset(fromMapOrFallback(destinationIcons, 'destination', ICON_SIZE, ICON_SIZE, pixelRatio, () => createTargetCanvas(pixelRatio, destinationColor))));
+    icons.set('source', toAsset(fromMapOrFallback(sourceIcons, 'departure', ICON_SIZE, ICON_SIZE, pixelRatio, () => createCurrentCanvas(pixelRatio, sourceColor))));
+    // Greyed-out source — shown at the route start while a live CP marks the user elsewhere.
+    icons.set('source_inactive', toAsset(fromMapOrFallback(iconMap, 'departure_inactive', ICON_SIZE, ICON_SIZE, pixelRatio, () => createCurrentCanvas(pixelRatio, sourceColor))));
+    const currentCanvas = createCurrentCanvas(pixelRatio, sourceColor);
+    currentCanvas.id = 'current-location';
+    icons.set('current', toAsset(currentCanvas));
+    const transitionCanvas = fromMapOrFallback(iconMap, 'transition', ICON_SIZE, ICON_SIZE, pixelRatio, () => createCurrentCanvas(pixelRatio, sourceColor));
+    icons.set('transition', toAsset(transitionCanvas));
+    icons.set('transition_up', toAsset(fromMapOrFallback(iconMap, 'transition_up', TRANSITION_ARROW_WIDTH, ICON_SIZE, pixelRatio, () => transitionCanvas)));
+    icons.set('transition_down', toAsset(fromMapOrFallback(iconMap, 'transition_down', TRANSITION_ARROW_WIDTH, ICON_SIZE, pixelRatio, () => transitionCanvas)));
+    icons.set('transition_entry', toAsset(fromMapOrFallback(sourceIcons, 'departure', ICON_SIZE, ICON_SIZE, pixelRatio, () => createCurrentCanvas(pixelRatio, sourceColor))));
+    icons.set('current_arrow', toAsset(fromMapOrFallback(iconMap, 'direction', ICON_SIZE, ICON_SIZE, pixelRatio, () => createArrowCurrentCanvas(pixelRatio, sourceColor))));
+    icons.set('trail', toAsset(createCircleCanvas(TRAIL_DOT_RADIUS, '#b5b7bc'), {
+        width: circleCanvasCssSize(TRAIL_DOT_RADIUS),
+        height: circleCanvasCssSize(TRAIL_DOT_RADIUS),
+    }));
+    return {
+        getIcon(name) {
+            const asset = icons.get(name);
+            if (!asset)
+                throw new Error(`Unknown icon: ${name}`);
+            return asset;
+        },
+    };
+}

package/dist/esm/wayfinding/adapters/floorContext.d.ts

@@ -0,0 +1,20 @@
+import type { FloorContext } from '@expofp/wayfinding';
+import type LayerStore from '../../store/LayerStore';
+import type RouteStore from '../../store/RouteStore';
+/** The one venue signal this adapter reads; `VenueStore` satisfies it structurally. */
+interface VenueModeSource {
+    readonly isCampusMode: boolean;
+}
+/** The campus graph's outdoor side; `createGraphDataSource` satisfies it on venue plans. */
+interface OutdoorGraphSource {
+    /** The `WF*` layers that still carry graph lines once venue points moved onto their levels. */
+    getOutdoorLayers(): readonly string[];
+}
+/**
+ * Adapter: builds a neutral {@link FloorContext} from the efp `LayerStore` +
+ * `RouteStore`. Single place in the code that knows about efp-specific magic
+ * values like `LayersMode.Default === 0`.
+ */
+export declare function createFloorContext(layerStore: LayerStore, routeStore: RouteStore, venueStore?: VenueModeSource, outdoorGraph?: OutdoorGraphSource): FloorContext;
+export {};
+//# sourceMappingURL=floorContext.d.ts.map

package/dist/esm/wayfinding/adapters/floorContext.js

@@ -0,0 +1,43 @@
+// Mirrors `LayersMode.Default`; a value import of the enum would pull the whole
+// `LayerStore` runtime module into this type-only adapter.
+const LAYERS_MODE_DEFAULT = 0;
+/**
+ * Adapter: builds a neutral {@link FloorContext} from the efp `LayerStore` +
+ * `RouteStore`. Single place in the code that knows about efp-specific magic
+ * values like `LayersMode.Default === 0`.
+ */
+export function createFloorContext(layerStore, routeStore, venueStore, outdoorGraph) {
+    return {
+        showAllFloors() {
+            return layerStore.mode === LAYERS_MODE_DEFAULT;
+        },
+        getActiveFloors() {
+            // Campus mode shows one level per venue, all venues at once: each
+            // visible level is an active floor, so a route scopes to floors exactly
+            // as on a single-venue plan, and a connected route that crosses venues
+            // draws on every venue's shown level. The outdoor leg of a campus graph
+            // runs on no plan layer, so it is active alongside them.
+            if (venueStore?.isCampusMode) {
+                return [
+                    ...layerStore.layers.filter((layer) => layer.visible).map((layer) => layer.name),
+                    ...(outdoorGraph?.getOutdoorLayers() ?? []),
+                ];
+            }
+            const name = routeStore.currentRouteLayer?.name;
+            if (!name)
+                return [];
+            const visible = layerStore.layers.some((layer) => layer.name === name && layer.visible);
+            return visible ? [name] : [];
+        },
+        isLayerVisible(layer) {
+            if (!layer)
+                return true;
+            if (layerStore.findLayer)
+                return layerStore.findLayer(layer)?.visible ?? true;
+            return layerStore.layers.some((candidate) => candidate.name === layer && candidate.visible);
+        },
+        getFloorOrder() {
+            return layerStore.floors.map((floor) => floor.name).reverse();
+        },
+    };
+}

package/dist/esm/wayfinding/adapters/graphDataSource.d.ts

@@ -0,0 +1,49 @@
+import type { Point2Like } from '@expofp/geometry';
+import type { GraphDataSource, RoutePoint } from '@expofp/wayfinding';
+/** The venue a graph point stands in, narrowed to what partitioning reads. */
+interface CampusVenue {
+    readonly levels: readonly {
+        readonly layer: {
+            readonly name: string;
+        };
+        readonly ordinal: number;
+    }[];
+}
+/** The venue model, narrowed to what partitioning a shared campus graph reads. */
+export interface CampusVenueSource {
+    /** Replaced, not mutated, when the model is (re)built — the partition is cached against it. */
+    readonly venues: readonly unknown[];
+    /** The venue whose outline holds a plan point (the smallest when outlines nest); null outdoors. */
+    venueAt(point: Point2Like): CampusVenue | null;
+    /** The venue owning a plan layer as one of its levels; null for a layer no venue owns. */
+    venueOfLayer(name: string): unknown;
+}
+/** The app's graph, plus the outdoor side of a campus graph the venues share. */
+export interface CampusGraphDataSource extends GraphDataSource {
+    /** The `WF*` layers still carrying graph lines once venue points moved onto their levels. */
+    getOutdoorLayers(): readonly string[];
+    /** Every layer the campus graph's legs run on: the floors its points moved onto, then the outdoor ones. */
+    getCampusLayers(): readonly string[];
+    /**
+     * The layer a route endpoint joins the graph on. An object drawn on a layer no venue owns
+     * (an outdoor area) joins the campus graph where it stands; any other endpoint keeps its layer.
+     */
+    getEndpointLayer(point: RoutePoint): string;
+}
+/**
+ * Reads the app's wayfinding graph off the resolver memo (`getWfData`).
+ *
+ * On a multi-venue plan the graph may be drawn once for the whole campus, on a
+ * `WF*` layer no level owns, while every booth stands on its venue's level — and
+ * the engine only joins an endpoint to graph points on its own layer. So each
+ * such point moves onto the ground level (`ordinal: 0`) of the venue whose
+ * outline holds it; points outdoors keep their `WF*` layer as the outdoor leg.
+ * The relabel is a function of position alone, so points that coincide stay
+ * one node and every route is the one the flat graph gives: a line through a
+ * door just becomes a physical line between two layers, costed by its length
+ * like any other. Lines already authored on a level are left as they are.
+ * @param venueSource - The venue model; a plan without one gets its graph as authored.
+ */
+export declare function createGraphDataSource(venueSource?: CampusVenueSource): CampusGraphDataSource;
+export {};
+//# sourceMappingURL=graphDataSource.d.ts.map

package/dist/esm/wayfinding/adapters/graphDataSource.js

@@ -0,0 +1,87 @@
+import { getWfData } from '../../data/fp-payloads';
+/** A wayfinding layer: graph-only, never a plan layer (contract §10). */
+const isWfLayer = (layer) => !!layer?.startsWith('WF');
+const NO_VENUES = {
+    venues: [],
+    venueAt: () => null,
+    venueOfLayer: () => null,
+};
+/**
+ * Reads the app's wayfinding graph off the resolver memo (`getWfData`).
+ *
+ * On a multi-venue plan the graph may be drawn once for the whole campus, on a
+ * `WF*` layer no level owns, while every booth stands on its venue's level — and
+ * the engine only joins an endpoint to graph points on its own layer. So each
+ * such point moves onto the ground level (`ordinal: 0`) of the venue whose
+ * outline holds it; points outdoors keep their `WF*` layer as the outdoor leg.
+ * The relabel is a function of position alone, so points that coincide stay
+ * one node and every route is the one the flat graph gives: a line through a
+ * door just becomes a physical line between two layers, costed by its length
+ * like any other. Lines already authored on a level are left as they are.
+ * @param venueSource - The venue model; a plan without one gets its graph as authored.
+ */
+export function createGraphDataSource(venueSource = NO_VENUES) {
+    /** The ground level of the venue whose outline holds a point; undefined outdoors. */
+    const groundLevelAt = (point) => venueSource.venueAt(point)?.levels.find((level) => level.ordinal === 0)?.layer.name;
+    let partition = null;
+    const partitioned = () => {
+        const wfData = getWfData();
+        const { venues } = venueSource;
+        if (partition?.wfData === wfData && partition.venues === venues)
+            return partition;
+        const authoredLines = (wfData?.lines ?? []);
+        const authoredLineEnds = (wfData?.lineEnds ?? []);
+        if (!venues.length) {
+            partition = {
+                wfData,
+                venues,
+                lines: authoredLines,
+                lineEnds: authoredLineEnds,
+                outdoorLayers: [],
+                campusLayers: [],
+            };
+        }
+        else {
+            const reachedFloors = new Set();
+            const toVenueLevel = (point) => {
+                if (!isWfLayer(point.layer))
+                    return point;
+                const ground = groundLevelAt(point);
+                if (!ground)
+                    return point;
+                reachedFloors.add(ground);
+                return { ...point, layer: ground };
+            };
+            const lines = authoredLines.map((line) => ({
+                ...line,
+                p0: toVenueLevel(line.p0),
+                p1: toVenueLevel(line.p1),
+            }));
+            const outdoorLayers = new Set(lines.flatMap(({ p0, p1 }) => [p0.layer, p1.layer]).filter((layer) => isWfLayer(layer)));
+            partition = {
+                wfData,
+                venues,
+                lines,
+                lineEnds: authoredLineEnds.map(toVenueLevel),
+                outdoorLayers: [...outdoorLayers],
+                campusLayers: [...reachedFloors, ...outdoorLayers],
+            };
+        }
+        return partition;
+    };
+    return {
+        getLines: () => partitioned().lines,
+        getLineEnds: () => partitioned().lineEnds,
+        getOutdoorLayers: () => partitioned().outdoorLayers,
+        getCampusLayers: () => partitioned().campusLayers,
+        getEndpointLayer: (point) => {
+            // A floorless point already matches every layer; a level is where its own graph runs; and
+            // without a campus graph no layer runs anywhere else.
+            const { campusLayers, outdoorLayers } = partitioned();
+            if (!point.layer || venueSource.venueOfLayer(point.layer) || !campusLayers.length) {
+                return point.layer;
+            }
+            return groundLevelAt(point) ?? outdoorLayers[0] ?? point.layer;
+        },
+    };
+}

package/dist/esm/wayfinding/adapters/index.d.ts

@@ -0,0 +1,10 @@
+export type { ArbitraryPoint, ArbitraryPointId } from './arbitraryPoint';
+export { CURRENT_LOCATION_NAME, CURRENT_POSITION_POINT_ID, JOURNEY_ENTRANCE_POINT_ID, KIOSK_ANCHOR_POINT_ID, toArbitraryPoint, } from './arbitraryPoint';
+export { boothToEndpoint } from './boothToEndpoint';
+export { withCampusEndpoints } from './campusEndpoints';
+export { createCanvasIconProvider } from './canvasIconProvider';
+export { createFloorContext } from './floorContext';
+export { createGraphDataSource } from './graphDataSource';
+export { createKioskCanvas } from './kioskCanvas';
+export { positionInput } from './positionInput';
+//# sourceMappingURL=index.d.ts.map

package/dist/esm/wayfinding/adapters/index.js

@@ -0,0 +1,8 @@
+export { CURRENT_LOCATION_NAME, CURRENT_POSITION_POINT_ID, JOURNEY_ENTRANCE_POINT_ID, KIOSK_ANCHOR_POINT_ID, toArbitraryPoint, } from './arbitraryPoint';
+export { boothToEndpoint } from './boothToEndpoint';
+export { withCampusEndpoints } from './campusEndpoints';
+export { createCanvasIconProvider } from './canvasIconProvider';
+export { createFloorContext } from './floorContext';
+export { createGraphDataSource } from './graphDataSource';
+export { createKioskCanvas } from './kioskCanvas';
+export { positionInput } from './positionInput';

package/dist/esm/wayfinding/adapters/kioskCanvas.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Builds the kiosk icon canvas. If `kioskIconMap` provides a "kiosk" image,
+ * it's drawn at a size scaled by `iconSizePercent` (default 100%). Otherwise
+ * falls back to a generic arrow canvas tinted with the fallback color.
+ */
+export declare function createKioskCanvas(kioskIconMap: Map<string, HTMLImageElement> | undefined, iconSizePercent?: number): HTMLCanvasElement;
+//# sourceMappingURL=kioskCanvas.d.ts.map

package/dist/esm/wayfinding/adapters/kioskCanvas.js

@@ -0,0 +1,22 @@
+import Color from 'color';
+import { createArrowCurrentCanvas, createImageCanvas, } from '../../components/Map/drawing/config/canvases';
+import { decreaseByPercentage } from '../../utils/math';
+const KIOSK_BASE_WIDTH = 199;
+const KIOSK_BASE_HEIGHT = 152;
+const KIOSK_BASE_REDUCTION_PERCENT = 55;
+const KIOSK_FALLBACK_COLOR = '#ee4422';
+/**
+ * Builds the kiosk icon canvas. If `kioskIconMap` provides a "kiosk" image,
+ * it's drawn at a size scaled by `iconSizePercent` (default 100%). Otherwise
+ * falls back to a generic arrow canvas tinted with the fallback color.
+ */
+export function createKioskCanvas(kioskIconMap, iconSizePercent) {
+    const pixelRatio = devicePixelRatio;
+    const image = kioskIconMap?.get('kiosk');
+    if (image) {
+        image.id = 'kiosk';
+        const iconSizeScale = iconSizePercent ? iconSizePercent / 100 : 1;
+        return createImageCanvas(image, decreaseByPercentage(KIOSK_BASE_WIDTH * iconSizeScale, KIOSK_BASE_REDUCTION_PERCENT), decreaseByPercentage(KIOSK_BASE_HEIGHT * iconSizeScale, KIOSK_BASE_REDUCTION_PERCENT), pixelRatio);
+    }
+    return createArrowCurrentCanvas(pixelRatio, Color(KIOSK_FALLBACK_COLOR).hex());
+}

package/dist/esm/wayfinding/adapters/positionInput.d.ts

@@ -0,0 +1,12 @@
+import type { PositionInput } from '@expofp/wayfinding';
+import type { PositionView } from '../storePorts';
+/**
+ * Converts an efp position read-model to a neutral `PositionInput` for the
+ * runtime.
+ *
+ * `z` can be `number | string | undefined`; the runtime expects `layer:
+ * string`. The efp `angle` maps to the neutral `heading`; non-finite values
+ * become `undefined`.
+ */
+export declare function positionInput(position: PositionView): PositionInput;
+//# sourceMappingURL=positionInput.d.ts.map

package/dist/esm/wayfinding/adapters/positionInput.js

@@ -0,0 +1,16 @@
+/**
+ * Converts an efp position read-model to a neutral `PositionInput` for the
+ * runtime.
+ *
+ * `z` can be `number | string | undefined`; the runtime expects `layer:
+ * string`. The efp `angle` maps to the neutral `heading`; non-finite values
+ * become `undefined`.
+ */
+export function positionInput(position) {
+    return {
+        x: position.x,
+        y: position.y,
+        layer: position.z != null ? String(position.z) : '',
+        heading: Number.isFinite(position.angle) ? position.angle : undefined,
+    };
+}

package/dist/esm/wayfinding/bindMobxReactions.d.ts

@@ -0,0 +1,28 @@
+import type { Wayfinding } from '@expofp/wayfinding';
+import type { KioskHandler } from './handlers/kioskHandler';
+import type { YahHandler } from './handlers/yahHandler';
+import type { LayerStorePort, RouteStorePort, UiStatePort } from './storePorts';
+interface BindMobxReactionsArgs {
+    readonly wayfinding: Pick<Wayfinding, 'setRoute' | 'clearRoute' | 'setPosition' | 'notifyFloorChanged' | 'shouldReroute'>;
+    readonly kioskHandler: KioskHandler;
+    readonly yahHandler: YahHandler;
+    readonly stores: {
+        readonly routeStore: RouteStorePort;
+        readonly uiState: UiStatePort;
+        readonly layerStore: LayerStorePort;
+    };
+}
+/**
+ * Wires the observable efp stores to the imperative wayfinding instance and
+ * the efp-side kiosk/yah handlers. Each reaction translates observable
+ * changes into neutral-typed imperative calls.
+ *
+ * Triggers `routeStore.rebuildRouteFromPosition` (via `wayfinding.shouldReroute`) when
+ * the live CP needs to become (or refresh) the route's FROM.
+ *
+ * Returns a dispose function that tears down all reactions plus the deferred
+ * floor-change timeout.
+ */
+export declare function bindMobxReactions({ wayfinding, kioskHandler, yahHandler, stores: { routeStore, uiState, layerStore }, }: BindMobxReactionsArgs): () => void;
+export {};
+//# sourceMappingURL=bindMobxReactions.d.ts.map