@minmaps-dev/mm-web-sdk 1.0.0-rc.46 → 1.0.0-rc.48

package/dist/index.d.ts

@@ -233,6 +233,11 @@ interface Zone {
     /** Authored hex color (e.g. "#d32f2f"); may be empty when the author
      *  hasn't picked one — such zones are skipped for color-coding. */
     color: string;
+    /** The color this zone's rooms are drawn in under the active theme — `color`
+     *  in the default theme, its high-contrast palette entry under high contrast.
+     *  Use this, not `color`, for a legend swatch, and re-read it on
+     *  `themeChanged`. Set on `getZones()` results only. */
+    displayColor?: string;
     description?: string;
 }
 
@@ -272,6 +277,46 @@ type WayfindCenterMode = 'none' | 'destination' | 'route';
 type RoutingOptions = {
     avoidStairs?: boolean;
 };
+/**
+ * A spot on a floor that need not be a POI — a tap in the middle of a
+ * corridor. Routes and walk times accept one wherever they accept a POI:
+ * it's snapped to the closest point along a path on its floor and routed
+ * from (or to) there, without any CMS waypoint at that spot.
+ *
+ * `kind` tells it apart from a `POI`, which also has `floorId` and
+ * `coordinates`. Build one with `sdk.snapToPath`, or by hand from a stored
+ * point (a shared link) — the SDK snaps it again either way.
+ */
+type MapLocation = {
+    kind: 'location';
+    floorId: string | number;
+    /** `[lng, lat]`. */
+    coordinates: [number, number];
+    /** What the route calls it — the arrive step's landmark and the end
+     *  flag's label. Omitted, the arrive step reads "You have arrived". */
+    label?: string;
+    /** Where the visitor actually tapped, when it's off the walking network and
+     *  `coordinates` (where the route starts or ends) had to be moved onto it.
+     *  Set by `snapToPath`; a location built from a stored point is snapped from
+     *  `tapped ?? coordinates`, so store this to rebuild it later. */
+    tapped?: [number, number];
+    /** The walkable way from `tapped` to `coordinates` — around rooms, back-of-
+     *  house areas and other obstacles, leaving a room by its door — drawn as a
+     *  dotted line with a marker on the tap. `tapped` without `approach` means
+     *  no walkable way was found (a room with no known door, somewhere nothing
+     *  walks), so the point was simply moved to the nearest path. */
+    approach?: [number, number][];
+    /** `tapped` is inside a building or room, so `approach` leads to a hallway
+     *  rather than an outdoor walkway — it picks the approach step's wording.
+     *  Set by `snapToPath` alongside `approach`. */
+    indoors?: boolean;
+    /** `tapped` was in a hallway, a little way off its path line: the point was
+     *  moved to the middle of the hall, with no `approach` to draw. Set by
+     *  `snapToPath` with `tapped`; a "choose on map" UI can say so. */
+    centered?: boolean;
+};
+/** True for a `MapLocation`, false for a `POI`. */
+declare function isMapLocation(value: unknown): value is MapLocation;
 
 /**
  * A single point along the rendered route. `mapId` lets the renderer
@@ -299,7 +344,7 @@ type RoutePoint = {
     isEndpoint?: boolean;
 };
 
-type WayfindStep = DepartStep | TurnStep | ContinueStep | TransitionStep$1 | ArriveStep;
+type WayfindStep = DepartStep | TurnStep | ContinueStep | TransitionStep$1 | ApproachStep | ArriveStep;
 type StepBase = {
     /** Indices into the input `points` array that this step spans. */
     pointRange: [startInclusive: number, endInclusive: number];
@@ -335,20 +380,44 @@ type TransitionStep$1 = StepBase & {
 type ArriveStep = StepBase & {
     type: 'arrive';
 };
+/**
+ * The walk between a tapped spot and the walking network (`MapLocation.approach`):
+ * `'start'` from where the visitor tapped to the hallway, before the depart
+ * step; `'end'` from the hallway to the tapped destination, before arrive.
+ * Its geometry isn't on the route line, so it carries its own `path` (in
+ * walking order) — highlight and frame that, not `pointRange`, which only
+ * marks the route point it joins.
+ */
+type ApproachStep = StepBase & {
+    type: 'approach';
+    approach: 'start' | 'end';
+    path: [number, number][];
+};
 
 interface MapEvent {
     floor?: Floor;
+    /** `routeReady`: the destination routed to — the exact instance, so for
+     *  `navigateFromKioskToClosestAmenity` it carries the picked `waypointId`. */
     poi?: POI;
     /** All POIs co-located at a clicked point (overlapping pins / a shared
      *  suite). Emitted by `poiSelected`; length ≥ 1, and `poi` mirrors
      *  `pois[0]` for single-POI consumers. */
     pois?: POI[];
     coordinates?: [number, number];
+    /** `locationPicked`: the tap snapped to the closest point along a path, or
+     *  `null` when no path on the floor was within reach (`coordinates` is the
+     *  raw tap either way). `routeFailed`: the location that didn't resolve.
+     *  `routeReady`: the tapped spot routed to, in place of `poi`. */
+    location?: MapLocation | null;
+    /** `locationPicked`: the tap was outside every building and room on the
+     *  floor. With `hasOutdoorPaths(floor.id)` false, nothing outdoors on this
+     *  floor is walkable — the visitor wants a floor that has outdoor paths. */
+    outdoors?: boolean;
     error?: any;
     venue?: any;
     camera?: CameraState;
     /** Emitted by `themeChanged`; `'custom'` when consumer passed a raw style. */
-    theme?: 'default' | 'high-contrast' | 'custom';
+    theme?: 'default' | 'high-contrast' | 'color-blind' | 'custom';
     /** Emitted by `localeChanged` after `setLocale()` finishes patching the
      *  venue model. BCP-47 code (`'en'`, `'es'`, `'es-MX'`). */
     locale?: string;
@@ -383,7 +452,7 @@ type BoundsPadding = number | {
  * `options.theme` init option. Pass a `StyleSpecification` directly for
  * custom themes.
  */
-type ThemeName = 'default' | 'high-contrast';
+type ThemeName = 'default' | 'high-contrast' | 'color-blind';
 /**
  * Style of the disc + ring rendered behind each amenity icon. The SDK
  * composites this into the icon bitmap at registration time, so badge +
@@ -414,7 +483,10 @@ interface SDKOptions {
     debugGlobal?: string | false;
     /**
      * Initial theme. `'default'` uses the bundled hybrid 3D theme.
-     * `'high-contrast'` uses the WCAG-AA tuned theme. Pass a
+     * `'high-contrast'` uses the WCAG-AA tuned theme. `'color-blind'` keeps the
+     * default look but swaps the colors that red-green and blue-yellow color
+     * blindness merge (the route, room categories and department zones,
+     * restrooms, parks). Pass a
      * `StyleSpecification` for fully custom styling.
      */
     theme?: ThemeName | any;
@@ -519,6 +591,16 @@ interface SDKOptions {
      * zoom.
      */
     initialZoom?: number;
+    /**
+     * Zoom floor for selecting a place — a map tap or `selectPOI` (default
+     * `19.25`, one level into the Kiosk view). A selection made from further out
+     * zooms in to this; a closer zoom is kept. At the Kiosk view's edge (18.25)
+     * the selected dot and name are drawn but still lose collision to their
+     * neighbours, and in the Building view (a room tapped from 16.5 up) they
+     * aren't drawn at all — either way the visitor selects a place they can't
+     * see. `0` keeps the current zoom on every selection.
+     */
+    selectionZoom?: number;
     /**
      * Clamp zoom-out relative to the opening view. When set, the map's
      * `minZoom` becomes `(initialZoom − this)`, so visitors can nudge out by
@@ -653,6 +735,12 @@ type SDKConfig = {
     options?: SDKOptions;
 };
 
+/** The chosen ends; either may be missing. */
+type RouteEndPreview = {
+    start?: POI | MapLocation | null;
+    destination?: POI | MapLocation | null;
+};
+
 type Visibility = 'visible' | 'none';
 type DebugLayersDeps = {
     getMap: () => Map | null;
@@ -1073,6 +1161,24 @@ interface OpenStatusOptions {
  * wrong answer at a kiosk is worse than a missing one.
  */
 declare function parseOpenHours(raw: unknown): OpenHours | null;
+/**
+ * The weekday `now` falls on in `timeZone` (host clock when omitted or
+ * unrecognised) — the same day `getOpenStatus` evaluates against. Exported so
+ * a week table can highlight "today" without disagreeing with the status line
+ * around the venue's midnight.
+ */
+declare function dayKeyAt(now: Date, timeZone?: string): DayKey;
+/**
+ * A short label for `timeZone` (host zone when omitted or unrecognised) — the
+ * zone `getOpenStatus` reads hours against — so a UI can say "Opens 9:00 AM ET".
+ *
+ * US zones get the generic form (`ET`, `CT`, `MT`, `PT`, `AKT`), which doesn't
+ * flip with daylight saving. Elsewhere the engine has no generic abbreviation
+ * (it would spell out "Germany Time"), so this falls back to the specific short
+ * name, which may be an offset (`GMT+2`). `now` only matters for that fallback
+ * and for zones like Phoenix that print `MST` year-round.
+ */
+declare function timeZoneAbbreviation(now?: Date, timeZone?: string): string;
 /**
  * The live open/closed state for a parsed week.
  *
@@ -1083,10 +1189,35 @@ declare function parseOpenHours(raw: unknown): OpenHours | null;
  *
  * Hours carry no timezone of their own, so they are read against the host clock
  * unless `options.timeZone` names the venue's zone. The kiosk case needs no
- * option: the machine stands in the building it is describing.
+ * option: the machine stands in the building it is describing. A web consumer
+ * whose visitors may be elsewhere should resolve the venue's zone (e.g. from
+ * `MinuteMaps.getVenueCenter()`) and pass it.
  */
 declare function getOpenStatus(hours: OpenHours, now?: Date, options?: OpenStatusOptions): OpenStatus;
 
+/** One floor of the active route, drawn on its own for a printout. */
+type RouteFloorImage = {
+    floor: Floor;
+    /** The bare map canvas (no DOM chrome), as a `data:` URL. */
+    dataUrl: string;
+};
+type RouteImageOptions = {
+    /** CSS-pixel size the map is laid out at while capturing. Default 1200×800. */
+    width?: number;
+    height?: number;
+    /** Canvas pixels per CSS pixel. Default 2, crisp enough for paper. */
+    pixelRatio?: number;
+    /** Padding around each floor's route segment, in CSS px. Default 40. */
+    padding?: number;
+    /** Draw in flat (2D) mode, which reads better on paper. The previous mode
+     *  is put back afterwards. Default `true`. */
+    flat?: boolean;
+    /** Image MIME type passed to `toDataURL`. Default `'image/png'`. */
+    type?: string;
+    /** Encoder quality for lossy types (`'image/jpeg'`, `'image/webp'`). */
+    quality?: number;
+};
+
 type JacsProviderConfig = {
     mode: 'proxy';
     proxyBaseUrl?: string;
@@ -1404,6 +1535,8 @@ declare class SnapshotProvider implements JacsReader {
     private fetchJson;
 }
 
+/** A built-in theme name, or `'custom'` when a raw style was passed. */
+type ActiveThemeName = ThemeName | 'custom';
 declare class MinuteMaps {
     private config;
     private map;
@@ -1461,8 +1594,9 @@ declare class MinuteMaps {
     /** Multiplier applied to every theme label's `text-size`, mutable via
      *  `setTextScale`. Re-applied after every `setTheme()` swap. */
     private textScale;
-    /** Each label layer's unscaled `text-size`, captured by `setTextScale`.
-     *  Cleared on `setTheme()` — the recreated layers carry new base values. */
+    /** Each label layer's unscaled `text-size` and em offsets, captured by
+     *  `setTextScale` and keyed `"<layer id>|<property>"`. Cleared on
+     *  `setTheme()` — the recreated layers carry new base values. */
     private baseTextSizes;
     /** Tracks the active theme name so `setTheme()` is a no-op when re-requested. */
     private activeThemeName;
@@ -1473,11 +1607,22 @@ declare class MinuteMaps {
     /** The destination of the last successfully computed route — kept so
      *  `setLocale()` can rebuild + re-emit `routeReady` with retranslated
      *  step text without recomputing the path. Cleared on route failure. */
-    private lastRouteDestinationPoi;
+    private lastRouteDestination;
+    /** `setLocationPicking` is on: a tap snaps to a path and emits
+     *  `locationPicked` instead of selecting what's under it. */
+    private locationPicking;
+    /** The active route's two ends, for redrawing its approaches after a
+     *  location-pick preview borrowed their source. */
+    private routeApproachEnds;
+    /** The running "moved to the nearest path" animation frame, if any. */
+    private pickAnimationFrame;
     /** Waypoint ids (stringified) of the connector(s) the active transition
      *  step rides — empty unless `setActiveStep` is on a transition. Drives
      *  `applyRouteConnectorHighlight`. */
     private activeTransitionWaypointIds;
+    /** Set while `captureRouteFloorImages` runs; holds the bounds padding to
+     *  put back afterwards (updated by any `setBoundsPadding` in between). */
+    private routeCapture;
     private amenityManager;
     private wayfinding;
     private highlightManager;
@@ -1511,6 +1656,13 @@ declare class MinuteMaps {
      *  fresh insets, the same way it already re-fits an active route. Cleared by
      *  `clearHighlight`. */
     private selectedCoordinates;
+    /** Zoom floor for the current selection's camera move, or `null` to keep
+     *  the current zoom. Set by `selectPOI` and map taps (`selectionZoom()` — a
+     *  pick can arrive from the Campus or Building view, where the selected
+     *  marker isn't drawn); kept beside
+     *  `selectedCoordinates` so a `setBoundsPadding` re-nudge carries the same
+     *  zoom instead of cancelling the zoom-in halfway. Cleared with it. */
+    private selectedMinZoom;
     private youAreHerePulse;
     /** Theme layers whose features represent a tappable destination/amenity.
      *  A click hit-tests these (see `SelectionManager`) → `poiSelected`. The
@@ -1651,16 +1803,62 @@ declare class MinuteMaps {
      */
     private registerRuntimeIcons;
     /**
-     * Set the active map theme by name (`'default'` / `'high-contrast'`) or by
+     * Set the active map theme by name (`'default'` / `'high-contrast'` /
+     * `'color-blind'`) or by
      * passing a custom `StyleSpecification`. The current floor, route, POIs
      * and camera are preserved across the swap — only layer styling changes.
      *
      * Used by kiosk consumers to wire the OS-level / popover high-contrast
      * toggle to the map. See `KIOSK.md` for the pattern.
+     *
+     * Switching between the two built-in themes happens in place (paint
+     * properties plus the sprite — see `swapBuiltinThemeInPlace`); a custom style,
+     * or leaving one, rebuilds the style with `setStyle`. Calls run one at a time
+     * in the order made, so a quick double toggle can't interleave two swaps.
      */
     setTheme(theme: ThemeName | StyleSpecification): Promise<void>;
+    /** Tail of the `setTheme` queue. */
+    private themeQueue;
+    private applyTheme;
+    /**
+     * Switch between built-in themes without `setStyle`. They share every layer
+     * and differ only in paint and sprite (high contrast and color-blind are
+     * derived from hybrid — see `themes/`), so this rewrites the paint
+     * properties that differ and points the map at the other sprite sheet.
+     * Sources, filters, zoom ranges, layout overrides (text scale, dyslexic font)
+     * and the selection's destination focus are untouched, so unlike the
+     * `setStyle` path there is nothing to capture and restore.
+     *
+     * Returns `false`, having changed nothing, when the two themes differ in
+     * anything paint can't express; the caller then falls back to `setStyle`.
+     */
+    private swapBuiltinThemeInPlace;
+    /** Room layers whose color a zone palette replaces. The
+     *  highlight pair is here so a selected room's raised block keeps its
+     *  palette color instead of reverting to the authored one. */
+    private static readonly ZONE_PAINT_TARGETS;
+    /** Zone id → palette fill for `themeName`, over the zones in use (see
+     *  `assignZonePaletteColors` for why only those), or `null` for a theme that
+     *  draws the authored colors. */
+    private paletteZoneColors;
+    /**
+     * Under a theme with a zone palette (high contrast, color-blind), color each
+     * zoned room from it, keeping the theme's own value for everything else.
+     * Under the default theme, write the theme's own value back: its expression
+     * already tints by the authored `zoneColor`, and an in-place swap away from
+     * color-blind wouldn't reset these layers otherwise, since the two static
+     * themes' unit fills are identical and `diffThemePaint` skips them.
+     *
+     * Writes the room layers' paint, so it must run before `setUnitFocusDim(true)`
+     * captures them — otherwise clearing the selection would hand back the
+     * palette-less value.
+     */
+    private applyZonePaint;
+    /** The color a zone's rooms are drawn in under the active theme: its palette
+     *  entry under high contrast or color-blind, its authored color otherwise. */
+    private zoneDisplayColor;
     /** Currently active theme name (or `'custom'` when a raw style was passed). */
-    getActiveTheme(): 'default' | 'high-contrast' | 'custom';
+    getActiveTheme(): ActiveThemeName;
     /**
      * Update the SDK's reduced-motion preference at runtime. When true, every
      * imperative camera move (`setView`, `resetView`, `refit`, recenter, route
@@ -1704,6 +1902,10 @@ declare class MinuteMaps {
      * wrapped), so zoom interpolation and data-driven sizing keep working. Re-applied after
      * `setTheme()`, since `setStyle({ diff: false })` recreates every layer from
      * the pristine theme JSON. Non-finite or non-positive values reset to 1.
+     *
+     * The em-based `text-offset` / `text-variable-anchor-offset` are divided by
+     * the same factor, so each label keeps its pixel distance from an icon that
+     * doesn't scale (see `scaleTextEmOffset`).
      */
     setTextScale(scale: number): void;
     getTextScale(): number;
@@ -1761,6 +1963,28 @@ declare class MinuteMaps {
     setFlatMode(enabled: boolean): void;
     toggleFlatMode(): void;
     getIsFlatMode(): boolean;
+    /**
+     * Street address of the venue, from its first JACS building's `address`.
+     * The CMS's Edit Venue form saves its Address field there, since it binds a
+     * venue to a single building. `null` before the venue loads or when the
+     * address is blank. In the venue's default language: `/all` ignores
+     * `?locale=` and the locale refetch doesn't cover buildings.
+     */
+    getVenueAddress(): string | null;
+    /**
+     * Description of the venue, from its first JACS building's `description` —
+     * stored there by the CMS's Edit Venue form, like `getVenueAddress()`.
+     * `null` before the venue loads or when the description is blank. Same
+     * locale caveat: always the venue's default language.
+     */
+    getVenueDescription(): string | null;
+    /**
+     * Center of the venue's bounds as `[lng, lat]`. `null` before the venue
+     * loads or when it has no coordinates. JACS records no time zone, so a
+     * consumer whose visitors may be outside the venue's zone resolves one from
+     * this point and passes it to `getOpenStatus` / `dayKeyAt`.
+     */
+    getVenueCenter(): [number, number] | null;
     getFloors(): Floor[];
     getCurrentFloor(): Floor | null;
     getDefaultFloor(): Floor | null;
@@ -1784,12 +2008,14 @@ declare class MinuteMaps {
         floorShortName?: string;
         zoneName?: string;
         zoneDescription?: string;
-        /** The department's authored hex colour (`Zone.color`) — the same value
-         *  that tints this room's polygon on the map, so a consumer can print a
-         *  swatch beside the department name and connect the two. Absent when the
-         *  author never picked one, which is also when the map leaves the room
-         *  untinted; treat "no colour" as "this department isn't colour-coded",
-         *  not as "fall back to a default swatch". */
+        /** The colour that tints this room's polygon on the map under the active
+         *  theme — the department's authored `Zone.color`, or its high-contrast
+         *  palette entry under high contrast (`Zone.displayColor`) — so a consumer
+         *  can print a swatch beside the department name and connect the two.
+         *  Re-read it on `themeChanged`. Absent when the author never picked one,
+         *  which is also when the map leaves the room untinted; treat "no colour"
+         *  as "this department isn't colour-coded", not as "fall back to a default
+         *  swatch". */
         zoneColor?: string;
         keywords?: string[];
         description?: string;
@@ -2015,22 +2241,128 @@ declare class MinuteMaps {
     /**
      * Route between two arbitrary POIs — the browser/mobile counterpart of
      * `navigateFromKioskToPOI`, for visitors who aren't standing at a kiosk
-     * and pick their own starting point. Same events (`routeReady` /
-     * `routeFailed`) and the same `centerMode: 'route'` framing. Switches to
-     * the origin's floor first, because the route starts there.
-     *
-     * Emits `routeFailed` with `origin_unavailable` / `destination_unavailable`
-     * when either POI has no waypoint, `no_route` when no path connects them.
+     * and pick their own starting point. `navigateBetween` with POIs only.
      */
     navigateBetweenPOIs(from: POI, to: POI, options?: {
         avoidStairs?: boolean;
     }): Promise<any>;
     /**
-     * Distance + walking time between two arbitrary POIs over the path graph —
-     * `getWalkTimeFromKiosk` with a caller-chosen origin. `null` when either POI
-     * has no waypoint on the graph or no path resolves.
+     * Route between two picks, each a POI or a `MapLocation` (a tapped spot
+     * that isn't a POI — see `snapToPath`). A location is snapped to the
+     * closest point along a path on its floor and routed from there, so a
+     * visitor can start mid-corridor with no waypoint authored at that spot.
+     * Same events (`routeReady` / `routeFailed`) and the same
+     * `centerMode: 'route'` framing as the kiosk routes. Switches to the
+     * origin's floor first, because the route starts there.
+     *
+     * Emits `routeFailed` with `origin_unavailable` / `destination_unavailable`
+     * when a POI has no waypoint or a location has no path within reach,
+     * `no_route` when no path connects them.
      */
-    getWalkTimeBetween(from: POI, target: Parameters<MinuteMaps['getWalkTimeFromKiosk']>[0], opts?: {
+    navigateBetween(from: POI | MapLocation, to: POI | MapLocation, options?: {
+        avoidStairs?: boolean;
+    }): Promise<any>;
+    /**
+     * What a tap on the map stands for as one end of a route — the rule "choose
+     * on map" (`setLocationPicking`) applies, and the one to apply to a stored
+     * tap so it resolves the same way:
+     *
+     * - **Inside a room that holds a destination** → that destination (`POI`),
+     *   routed to its entrance. A clinic's examination rooms and the like aren't
+     *   somewhere to walk a visitor through, so a tap there never becomes a spot
+     *   with an approach (`destinationInRoomAt`: smallest such room, nearest
+     *   destination in it).
+     * - **Anywhere else** — an unplotted corridor, outdoors, a room with no
+     *   destination → `snapToPath`.
+     *
+     * `null` when the floor is unknown or no path is within reach.
+     */
+    resolveMapTap(location: Omit<MapLocation, 'kind'> | MapLocation): POI | MapLocation | null;
+    /** `destinationInRoomAt` against a floor's own geometry and destinations. */
+    private destinationInRoomAtTap;
+    /**
+     * Move a spot on a floor onto the walking network — where a route from (or
+     * to) it will actually start (or end). The path point chosen is the one
+     * closest **to walk to**, not the closest in a straight line: rooms,
+     * back-of-house areas, stairs, elevators, obstacles and other buildings are
+     * walked around, and a tap inside a room leaves by its door (inferred where
+     * a path crosses the room's outline) rather than through the wall to the
+     * corridor behind it. See `data/wayfinding/approach.ts`.
+     *
+     * Returns a `MapLocation` with `coordinates` on a path (`label` carried
+     * over) and, when the tap was off the network, `tapped` plus — if a
+     * walkable way was found — `approach`, the dotted line to draw. `tapped`
+     * without `approach` means the point was simply moved (a room with no known
+     * door, somewhere nothing walks) — or, with `centered`, moved from the side
+     * of a hallway to its middle. `null` when the floor is unknown or no path
+     * is within `maxDistanceMeters` (default 30 m).
+     *
+     * Planned from `tapped ?? coordinates`, so re-snapping a result (or a stored
+     * tap) gives the same answer. Until the floor's geometry has loaded it's the
+     * plain nearest point. Cross-floor paths are never snapped to.
+     */
+    snapToPath(location: Omit<MapLocation, 'kind'> | MapLocation, opts?: {
+        maxDistanceMeters?: number;
+    }): MapLocation | null;
+    /**
+     * Whether floor `floorId` has walkways outdoors — a path edge outside every
+     * building and room. A multi-storey campus usually draws its outdoor paths
+     * on the ground floor only, so a tap outside on another floor
+     * (`locationPicked`'s `outdoors`) can't reach one: a "choose on map" UI can
+     * point the visitor to a floor where this is `true`. `false` when the floor
+     * is unknown or its geometry hasn't loaded.
+     */
+    hasOutdoorPaths(floorId: Floor['id']): boolean;
+    /**
+     * Turn map taps into location picks — for a "choose on map" control. While
+     * on, a tap selects nothing; it's snapped to the closest point along a path
+     * on the visible floor (`snapToPath`), a ring marks the snapped spot, and
+     * **`locationPicked`** is emitted with `location` (the snapped
+     * `MapLocation`, or `null` when no path was in reach — the ring is taken
+     * down), `coordinates` (the raw tap), `floor`, and `outdoors` (the tap is
+     * outside every building and room — see `hasOutdoorPaths`). Turning it off removes
+     * the ring.
+     */
+    setLocationPicking(enabled: boolean): void;
+    /**
+     * Pin the ends a visitor has chosen for a route that isn't drawn yet — a
+     * route form's start and destination — so each choice reads as saved: the
+     * sprite's `marker-start` on `start`, `marker-destination` on
+     * `destination`. A location tapped off the walking network is pinned where
+     * it was tapped. Shown on the end's own floor only. Replaces the previous
+     * preview; `{}` clears it. Independent of the route — clear it once the
+     * route is drawn, so the route's own markers stand alone.
+     */
+    setRouteEndPreview(ends: RouteEndPreview): void;
+    /**
+     * A pick on the map: the ring on the on-path point, and the approach to it
+     * from the tap. A tap that had to be *moved* (no walkable way) is shown
+     * moving — its marker slides from the tap onto the path before the ring
+     * appears — so the jump reads as deliberate. With reduced motion it's
+     * simply there.
+     */
+    private showPickedLocation;
+    /** A pick that resolved to a destination (`resolveMapTap`): its room
+     *  raised and the ring on its pin, as `highlightPOI` locates one. */
+    private showPickedDestination;
+    private stopPickAnimation;
+    /** The floor's path-graph map id: for JACS venues the floor id *is* the
+     *  mapId, but read `mapId` first rather than lean on that. */
+    private mapIdForFloorId;
+    /** What the router takes for one end of a route: a POI's waypoint, or a
+     *  location's floor + on-path point (spliced in by the provider as a
+     *  virtual node). A location must already be through `snapToPath`, so its
+     *  `coordinates` are on a path. `null` when it can't be routed. */
+    private routeEndpointWaypoint;
+    /**
+     * Distance + walking time between two arbitrary picks over the path graph —
+     * `getWalkTimeFromKiosk` with a caller-chosen origin. Either end may be a
+     * `MapLocation`, snapped exactly as `navigateBetween` snaps it, and its
+     * `approach` (the walk from the tap to the path) is counted in `feet` /
+     * `seconds` / `effortSeconds`. `null` when a POI has no waypoint on the
+     * graph, a location has no path within reach, or no path resolves.
+     */
+    getWalkTimeBetween(from: POI | MapLocation, target: Parameters<MinuteMaps['getWalkTimeFromKiosk']>[0] | MapLocation, opts?: {
         walkingSpeedFps?: number;
         avoidStairs?: boolean;
     }): {
@@ -2039,10 +2371,17 @@ declare class MinuteMaps {
         effortSeconds: number;
         pathNodeCount: number;
     } | null;
+    /** One end of a walk-time query: a POI's waypoint, or a location's
+     *  on-path point (already through `snapToPath`). */
+    private walkTimeRef;
+    /** `routeReady`'s destination: `poi` for a place — the exact instance
+     *  routed to, so `navigateFromKioskToClosestAmenity`'s pick is visible —
+     *  or `location` for a tapped spot. */
+    private routeDestinationEventField;
     /** Shared tail of the route entry points: path, camera fit, steps, events.
-     *  `originPoi` is the start a visitor picked (`navigateBetweenPOIs`), which
+     *  `originPoi` is the start a visitor picked (`navigateBetween`), which
      *  gets a start pin; a kiosk route passes none — "You are here" marks it. */
-    private routeToPoi;
+    private routeTo;
     /** Build the landmark / floor-name context the directions module needs.
      *  Pulled out so `setLocale()` or `setActiveStep()` can rebuild it on
      *  demand if we ever surface a locale-aware variant. */
@@ -2058,6 +2397,9 @@ declare class MinuteMaps {
      * instance under every floor's list.
      */
     private redrawFloorText;
+    /** The route's directions: `buildDirections` over the path, plus a step
+     *  for each tapped end's walk on to / off the network (`withApproachSteps`). */
+    private buildRouteSteps;
     private buildDirectionsContext;
     /**
      * Drive the turn-by-turn UI. Two effects:
@@ -2074,10 +2416,26 @@ declare class MinuteMaps {
      * instead swap the connector(s) the step rides to their highlighted
      * sprite badge (`CONNECTOR_HIGHLIGHTED_ICON_SUFFIX`).
      *
+     * `opts.fit` moves the camera too:
+     * - `'step'` frames just this step (zoomed no closer than
+     *   `ROUTE_STEP_FIT_MAX_ZOOM`) instead of the floor's whole segment, and
+     *   keeps framing it through later re-fits — `setBoundsPadding` as the
+     *   consumer's directions card resizes, a floor switch back to the step's
+     *   floor — until another fit or a new route.
+     * - `'route'` goes back to the route's own framing (its floor segment),
+     *   as when it was first drawn — e.g. a "Restart" on the first step.
+     *
+     * Omitted, the camera is left alone, so a route's first framing stays
+     * the whole route.
+     *
      * Pass `null` to clear the highlight without changing the floor or
      * tearing down the route.
      */
-    setActiveStep(step: WayfindStep | null): Promise<void>;
+    setActiveStep(step: WayfindStep | null, opts?: {
+        fit?: 'step' | 'route';
+    }): Promise<void>;
+    /** The coordinates of `step`'s point range, for the camera to frame. */
+    private stepFocusFor;
     private writeActiveStepHighlight;
     private clearActiveStepHighlight;
     /**
@@ -2091,6 +2449,25 @@ declare class MinuteMaps {
      * that predates the variant) rather than drawing nothing.
      */
     private applyRouteConnectorHighlight;
+    /**
+     * Draw each floor the active route crosses, in route order, and return
+     * one image per floor — for printing directions.
+     *
+     * Images are the map canvas alone, so the consumer's DOM chrome (panels,
+     * buttons, the floor picker) never appears in them. For the duration the
+     * map container is laid out at a fixed `width` × `height`, the camera
+     * fits each floor's segment of the route with uniform `padding`, and the
+     * line is drawn solid (no draw-on sweep, no step highlight). The map is
+     * drawn flat (2D) unless `flat: false`. Afterwards the container size,
+     * floor, camera, flat/3D mode and padding are put back. Hide the
+     * map behind a loading screen while this runs; the visitor would
+     * otherwise see it jump between floors.
+     *
+     * The step highlight is cleared, not restored: call `setActiveStep`
+     * again with the step your UI is showing. Resolves to `[]` when no route
+     * is displayed.
+     */
+    captureRouteFloorImages(opts?: RouteImageOptions): Promise<RouteFloorImage[]>;
     clearRoute(): void;
     /**
      * Put the end-of-route marker on `poi`, or take it down (`null`). With
@@ -2124,8 +2501,11 @@ declare class MinuteMaps {
      *
      * This is deliberately *not* `highlightPOI`, which is the search-locate
      * gesture — it zooms and recenters and draws a pulsing ring, and emits
-     * nothing. Selection is the quieter one: current zoom kept, no ring, the
-     * raised room is the indicator.
+     * nothing. Selection is the quieter one: no ring, the raised room is the
+     * indicator, and the current zoom is kept — unless it is further out than
+     * `options.selectionZoom` (default 19.25, just inside the Kiosk view), where
+     * the room or its marker may not be drawn, in which case the camera zooms in
+     * to it. A map tap gets the same floor.
      *
      * Accepts a `POI` (preferred — its `type` and `waypointId` pin down the exact
      * instance, which matters for an amenity that shares one id across every
@@ -2147,6 +2527,11 @@ declare class MinuteMaps {
     selectPOI(target: POI | string | number, options?: {
         includeCoLocated?: boolean;
     }): Promise<POI[]>;
+    /** Zoom floor for a tap or `selectPOI` camera move (`options.selectionZoom`),
+     *  or `null` to keep the current zoom. The default sits a level past the
+     *  Kiosk view's edge: right at `KIOSK_VIEW_MIN_ZOOM` the selected dot and
+     *  name are drawn but routinely lose collision to amenities and room names. */
+    private selectionZoom;
     /** Remove the POI highlight set by `highlightPOI`, un-dim the other units,
      *  and bring back the destination markers hidden by a room selection. */
     clearHighlight(): void;
@@ -2206,7 +2591,8 @@ declare class MinuteMaps {
     /** Gentle pan so the selection sits in the centre of the map area MapLibre
      *  frames within `boundsPadding` (which the consumer sets to reserve for its
      *  bottom-docked chrome / info card). A straight `easeTo`, current zoom kept,
-     *  so it reads as a nudge, not a recenter. */
+     *  so it reads as a nudge, not a recenter — unless `selectedMinZoom` is set
+     *  and the camera is further out, in which case it zooms in to that floor. */
     private easeToSelection;
     /** Dim every unit's paint (or restore it) so a selected room reads as the
      *  focus. Idempotent: capturing only happens on the first activate, and the
@@ -2652,5 +3038,5 @@ type ResolvedIconSource = {
  */
 declare function resolveAmenityIconSource(amenity: AmenityLike, preferredLocale?: string): ResolvedIconSource | null;
 
-export { BUILDING_NAME_EXTENSOR_KEY, DAY_KEYS, IMAGE_ALT_EXTENSOR_KEY, MinuteMaps, OPEN_HOURS_EXTENSOR_KEY, OPEN_HOURS_VERSION, PHONE_EXTENSOR_KEY, POINT_OF_INTEREST_EXTENSOR_KEY, RESERVED_EXTENSOR_PREFIX, SNAPSHOT_SCHEMA_VERSION, SnapshotProvider, SnapshotUnavailableError, VenueDirectory, activeSectionIndex, createMinuteMapsSDK, customerDisplayName, getOpenStatus, groupStepsIntoFloorSections, isConnectorAmenity, parseBuildingName, parseImageAlt, parseOpenHours, parsePhone, parsePointOfInterest, resolveAmenityIconSource, resolveSnapshotLocale };
-export type { Amenity, AmenityBadgeStyle, AmenityWithFloor, Bounds, BoundsPadding, CameraState, Customer, CustomerVenues, DayKey, Destination, DestinationPhone, EventCallback, Floor, FloorMetadata, HoursRange, JMapAuth, JMapConfig, JacsAuth, JacsConfig, JacsProviderConfig, JacsReader, ListCustomerVenuesOptions, MapEvent, OpenHours, OpenHoursTransition, OpenStatus, OpenStatusOptions, POI, POISearchResult, ResolvedIconSource, RouteFloorSection, RoutePoint, RoutingOptions, SDKConfig, SDKOptions, SnapshotProviderConfig, SnapshotUpdateCheck, SnapshotVersions, ThemeName, TransitionStep, VenueDirectoryConfig, VenueSummary, ViewOptions, WayfindCenterMode, WayfindStep, Waypoint, Zone };
+export { BUILDING_NAME_EXTENSOR_KEY, DAY_KEYS, IMAGE_ALT_EXTENSOR_KEY, MinuteMaps, OPEN_HOURS_EXTENSOR_KEY, OPEN_HOURS_VERSION, PHONE_EXTENSOR_KEY, POINT_OF_INTEREST_EXTENSOR_KEY, RESERVED_EXTENSOR_PREFIX, SNAPSHOT_SCHEMA_VERSION, SnapshotProvider, SnapshotUnavailableError, VenueDirectory, activeSectionIndex, createMinuteMapsSDK, customerDisplayName, dayKeyAt, getOpenStatus, groupStepsIntoFloorSections, isConnectorAmenity, isMapLocation, parseBuildingName, parseImageAlt, parseOpenHours, parsePhone, parsePointOfInterest, resolveAmenityIconSource, resolveSnapshotLocale, timeZoneAbbreviation };
+export type { Amenity, AmenityBadgeStyle, AmenityWithFloor, Bounds, BoundsPadding, CameraState, Customer, CustomerVenues, DayKey, Destination, DestinationPhone, EventCallback, Floor, FloorMetadata, HoursRange, JMapAuth, JMapConfig, JacsAuth, JacsConfig, JacsProviderConfig, JacsReader, ListCustomerVenuesOptions, MapEvent, MapLocation, OpenHours, OpenHoursTransition, OpenStatus, OpenStatusOptions, POI, POISearchResult, ResolvedIconSource, RouteEndPreview, RouteFloorImage, RouteFloorSection, RouteImageOptions, RoutePoint, RoutingOptions, SDKConfig, SDKOptions, SnapshotProviderConfig, SnapshotUpdateCheck, SnapshotVersions, ThemeName, TransitionStep, VenueDirectoryConfig, VenueSummary, ViewOptions, WayfindCenterMode, WayfindStep, Waypoint, Zone };