@minmaps-dev/mm-web-sdk 1.0.0-rc.5 → 1.0.0-rc.51

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import { IControl, ControlPosition, Map } from 'maplibre-gl';
+import { Map, StyleSpecification, IControl, ControlPosition } from 'maplibre-gl';
 
 /**
  * Represents a floor in a building
@@ -6,8 +6,18 @@ import { IControl, ControlPosition, Map } from 'maplibre-gl';
 interface Floor {
     /** Unique floor identifier */
     id: string | number;
+    /**
+     * Underlying map entity id. Separate from `id` (the floor entity id) — used
+     * by waypoints (`wp.mapId`) and floor-geojson endpoints. Optional because
+     * not all providers populate it.
+     */
+    mapId?: string | number;
     /** Display name of the floor */
     name: string;
+    /** Short display name of the floor (e.g. "L2"). Optional: JACS leaves it
+     *  unset on plenty of floors, and `JacsDataProvider` maps a blank one to
+     *  `undefined` rather than inventing a value. */
+    shortName?: string;
     /** Floor sequence/order (e.g., -1 for basement, 0 for ground, 1 for first floor) */
     sequence?: number;
     /** Associated map data */
@@ -23,6 +33,7 @@ interface Floor {
 interface FloorMetadata {
     id: string | number;
     name: string;
+    shortName?: string;
     sequence?: number;
     isDefault?: boolean;
     isActive?: boolean;
@@ -32,7 +43,7 @@ interface POI {
     /** Unique identifier */
     id: string | number;
     /** POI type */
-    type: 'amenity' | 'destination';
+    type: 'amenity' | 'destination' | 'kiosk';
     /** Display name */
     name: string;
     /** Geographic coordinates [longitude, latitude] */
@@ -45,6 +56,17 @@ interface POI {
     floorId: string | number;
     /** Category/type of amenity (e.g., 'restroom', 'elevator') */
     amenityType?: string;
+    /** Locale-stable classification text (name + type + keywords, frozen at
+     *  load before any locale patch can translate them). Copied from the
+     *  source `Amenity.classifyText`; used by `amenityCategoryFor`/rank
+     *  instead of the live, possibly-translated fields. See `Amenity.classifyText`. */
+    classifyText?: string;
+    /** Which amenity icon layer this POI renders in — `'connector'`,
+     *  `'entrance'`, `'parking'`, `'bus'`, `'information'` or `'other'`.
+     *  Derived from the amenity's connector flag, name, type and keywords;
+     *  emitted as the `amenityCategory` feature property the theme filters on.
+     *  Amenities only. See `amenityCategoryFor`. */
+    amenityCategory?: 'connector' | 'entrance' | 'parking' | 'bus' | 'information' | 'other';
     /** Search keywords */
     keywords?: string[];
     /** Additional properties */
@@ -55,6 +77,15 @@ interface POI {
     waypoint?: Waypoint;
     /** Marks this POI as the "You are here" kiosk */
     isYouAreHere?: boolean;
+    /** For kiosk POIs only: compass heading the device physically faces, in
+     *  degrees clockwise from north. Sourced from JACS `Device.heading`. */
+    heading?: number | null;
+    /** Per-instance name for this specific placement of an amenity (e.g.
+     *  "Parking Lot A" for a "Parking" amenity), resolved from the waypoint's
+     *  `amenityAssociations`. Distinct from `name`, which is the amenity's
+     *  type-level name shared by every instance — see `Amenity.name`. Amenities
+     *  only, and only set when JACS actually returned an instance name. */
+    instanceName?: string;
 }
 /**
  * Amenity - a specific type of POI (facilities, services)
@@ -64,14 +95,42 @@ interface Amenity {
     id: string | number;
     /** Display name */
     name: string;
-    /** SVG icon data */
+    /** Inline SVG markup (legacy fullcall DTO). When absent, icon is resolved from `uris`. */
     svg?: string;
+    /**
+     * Hosted icon descriptors from JACS (`uris[].locales[].uriPath`). Used by
+     * the SDK's runtime icon fetcher to register a map image at init time.
+     */
+    uris?: Array<{
+        mimeType?: string;
+        resourceType?: string;
+        locales?: Array<{
+            locale?: string;
+            uriPath?: string;
+        }>;
+    }>;
+    /**
+     * Map-image id used as `icon-image` in the POI style layer. Decorated
+     * in-place by AmenityIcons.register once the SVG is fetched and registered.
+     */
+    iconId?: string;
     /** Search keywords */
     keywords?: string[];
     /** Associated waypoints */
     waypoints?: Waypoint[];
     /** Amenity type/category */
     type?: string;
+    /**
+     * Locale-stable snapshot of `name + type + keywords`, captured once from
+     * the `/all` payload before `applyLocale` ever runs. `amenityCategoryFor`
+     * and the icon-rank heuristics in `poi.ts` match hard-coded English
+     * vocabulary against those fields; `name`/`keywords` are legitimately
+     * overwritten with translated text on a language switch
+     * (`LOCALIZED_FIELDS.amenity`), which reclassified every translated
+     * amenity to `'other'`/tier-3 and dropped its icon until the next zoom
+     * recomputed the rank gate. Classification reads this frozen copy instead.
+     */
+    classifyText?: string;
     /** Extended properties */
     extensors?: Record<string, unknown>;
 }
@@ -87,8 +146,34 @@ interface Destination {
     waypoints?: Waypoint[];
     /** Category/classification */
     category?: string;
+    /** Room number — the CMS's "Room Number" field. A **real JACS column**, not
+     *  one of the `mm_` stand-in extensors, so it arrives on the entity rather
+     *  than in `extensors`. Surfaced as `getPOIDetails().roomNumber`. */
+    unitNumber?: string | null;
+    /** Search keywords */
+    keywords?: string[];
     /** Additional properties */
     properties?: Record<string, unknown>;
+    /** The CMS "Location Image" — a photo or logo for the popover, not a map
+     *  marker. JACS `/all` fullcall serves this as
+     *  `{ items: [{ resourceType, mimeType, path }] }`; the legacy/basic shape is
+     *  `[{ locales: [{ uriPath }] }]`. `destinationImageSrc` handles both, and
+     *  surfaces the result on `sdk.getPOIDetails(poi).imageUrl`. */
+    uris?: unknown;
+    /** Inline SVG for the uploaded image, embedded by JACS `/all`. Preferred over
+     *  fetching `uris[].path` — no network round-trip. */
+    svg?: string;
+    /** Free-form CMS metadata. */
+    extensors?: Record<string, unknown>;
+    /** @deprecated Read by nothing in the SDK as of rc.34.
+     *
+     *  JACS still serves the old map-manager "Label Display" mode
+     *  (`0` Hidden · `1` Label · `2` Image), but the CMS removed the picker and
+     *  pins every write to `1`. Rows authored before that keep a stale `0`/`2`
+     *  the author can no longer change, so honouring the field would hide labels
+     *  with no way to bring them back. Destinations always render dot + text
+     *  label; the uploaded image goes to the popover instead. */
+    displayMode?: number;
 }
 /**
  * Waypoint - a specific point location
@@ -102,6 +187,19 @@ interface Waypoint {
     floorId?: string | number;
     /** Whether this is the primary/default waypoint */
     isPrimary?: boolean;
+    /** CMS zone (department) this waypoint belongs to, if any. The only backend
+     *  link between a location and its department — read at runtime across the
+     *  data provider (see the package CLAUDE.md zone landmine). */
+    zoneId?: string | number;
+    /** Per-instance names JACS attaches to this waypoint's amenities (e.g. a
+     *  "Parking" amenity placed twice as "Parking Lot A" / "Parking Lot B").
+     *  `id` matches an `Amenity.id`, not this waypoint — a waypoint can carry
+     *  more than one amenity, so a consumer must find the entry for the
+     *  specific amenity it's rendering rather than assuming index 0. */
+    amenityAssociations?: Array<{
+        id: string | number;
+        name: string;
+    }>;
 }
 /**
  * Amenity enriched with the floor it belongs to
@@ -121,6 +219,28 @@ interface POISearchResult {
     matchedFields: string[];
 }
 
+/**
+ * A Zone is a CMS-authored department category — a named, colored grouping
+ * (e.g. "Cardiology", "Surgical", "Admin"). Zones are venue-wide (not
+ * floor-scoped) in the JACS `/all` payload and carry no geometry of their own;
+ * their spatial footprint is derived from the waypoints that reference them
+ * (`waypoint.zoneId`), which lets the SDK color-code the room/unit polygons a
+ * zone covers. See `map/zones.ts` for the derivation.
+ */
+interface Zone {
+    id: number;
+    name: string;
+    /** 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;
+}
+
 /** Captured camera state (center, zoom, pitch, bearing) */
 type CameraState = {
     center: [number, number];
@@ -140,25 +260,447 @@ type ViewOptions = {
 /** SW/NE bounding box */
 type Bounds = [[number, number], [number, number]];
 
+/** How to center the map after computing a route */
+type WayfindCenterMode = 'none' | 'destination' | 'route';
+/**
+ * Per-call routing preferences forwarded to the wayfinding provider.
+ *
+ * - `avoidStairs` — hard-filter stairs from the graph. Accessibility
+ *   preference otherwise comes from the CMS's per-path-type `weight`
+ *   (elevators score low, stairs/escalators score high) — see
+ *   `data/wayfinding/weights.ts` — not from a caller-supplied flag.
+ *
+ * The bundled stub provider doesn't compute routes; consumers wire a real
+ * provider (see `mm-web-sdk-example/lib/wayfinding`) that reads this
+ * flag when building edge weights.
+ */
+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
+ * split the polyline by floor (so other-floor segments don't paint
+ * through the visible floor's geometry); `waypointId` and `pathTypeId`
+ * let downstream layers (text-directions, step UI) classify
+ * transitions — e.g. "Take the elevator" vs "Walk straight". The two
+ * endpoint points are the kiosk and destination anchors (`isEndpoint`
+ * marks them so they can render endpoint pins). All fields except
+ * `coordinates` are optional for backward-compat with the straight-line
+ * fallback.
+ */
+type RoutePoint = {
+    coordinates: [number, number];
+    /** Floor mapId this point sits on. Missing on the straight-line fallback. */
+    mapId?: number;
+    /** JACS waypoint id this point resolved to, if any. */
+    waypointId?: number;
+    /** Path type of the edge that LEADS INTO this point (i.e. the edge
+     *  whose `toKey` is this node). Used to detect elevator / stair /
+     *  escalator transitions. Missing on the start point and on the
+     *  straight-line fallback. */
+    pathTypeId?: number;
+    /** True for the snapped kiosk + destination anchors. */
+    isEndpoint?: boolean;
+};
+
+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];
+    /** Floor this step is on. `null` for cross-floor transitions. */
+    floorId: number | null;
+    /** Localized instruction text. */
+    text: string;
+    /** Total walking distance within this step, in feet (rounded). */
+    distanceFeet?: number;
+    /** Landmark name used for anchoring, if any. */
+    landmark?: string;
+};
+type DepartStep = StepBase & {
+    type: 'depart';
+    /** Which way the traveller turns before walking off, relative to the
+     *  way they're facing at the origin. Absent when `originFacingBearing`
+     *  wasn't supplied (direction unknowable) or when the route heads
+     *  straight ahead. Consumers use it to pick the step's icon. */
+    initialTurn?: 'left' | 'right' | 'around';
+};
+type TurnStep = StepBase & {
+    type: 'turn-left' | 'turn-right' | 'u-turn';
+};
+type ContinueStep = StepBase & {
+    type: 'continue';
+};
+type TransitionStep$1 = StepBase & {
+    type: 'transition';
+    transition: 'elevator' | 'stairs' | 'escalator';
+    fromFloorId: number | null;
+    toFloorId: number | null;
+};
+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' | 'color-blind' | 'custom';
+    /** Emitted by `localeChanged` after `setLocale()` finishes patching the
+     *  venue model. BCP-47 code (`'en'`, `'es'`, `'es-MX'`). */
+    locale?: string;
+    /** Emitted by `routeReady` after a successful `navigateFromKioskToPOI`.
+     *  Carries the raw geometry (`points`) and the human-readable
+     *  step-by-step directions. Subscribe to drive a turn-by-turn UI. */
+    route?: {
+        points: RoutePoint[];
+        steps: WayfindStep[];
+        /** Floor mapId of each segment, in render order. `null` for
+         *  segments emitted by the straight-line fallback. */
+        floorIds: Array<number | null>;
+    };
 }
 type EventCallback = (event: MapEvent) => void;
 
+/**
+ * Padding kept clear inside the viewport when the SDK frames bounds —
+ * the initial venue/floor fit and the wayfinding route fit. A plain
+ * number pads all sides equally; the object form lets a kiosk reserve
+ * space for fixed UI overlays (header, dock, side rails) so framed
+ * content is never hidden behind them.
+ */
+type BoundsPadding = number | {
+    top: number;
+    bottom: number;
+    left: number;
+    right: number;
+};
+/**
+ * Built-in theme names accepted by `MinuteMaps.setTheme()` and the
+ * `options.theme` init option. Pass a `StyleSpecification` directly for
+ * custom themes.
+ */
+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 +
+ * icon participate in symbol collision as one unit.
+ */
+type AmenityBadgeStyle = {
+    /** Fill colour of the badge disc. Default `'#fdb81e'`. */
+    color?: string;
+    /** Stroke colour of the ring around the disc. Default `'#FFFFFF'`. */
+    ringColor?: string;
+    /** Ring width in logical px. Default `2`. */
+    ringWidth?: number;
+    /** Extra inset between the icon and the badge's inner edge, in logical px
+     *  (applied on all sides). Default `0` — the icon fills ~85% of the disc
+     *  as before. Raise this if an icon's own artwork reaches close to its
+     *  viewBox edges and ends up touching the ring. */
+    padding?: number;
+};
 interface SDKOptions {
     debug?: boolean;
-    theme?: 'light' | 'dark' | 'hybrid' | any;
+    /**
+     * `window` key the SDK instance is published under while `debug` is on, so
+     * a running kiosk can be driven from devtools (`mm.debug.hide('labels')`,
+     * `mm.getMap()`). Defaults to `'mm'`. Pass another name to avoid a clash,
+     * or `false` to publish nothing even in debug mode. Ignored entirely when
+     * `debug` is off.
+     */
+    debugGlobal?: string | false;
+    /**
+     * Initial theme. `'default'` uses the bundled hybrid 3D theme.
+     * `'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;
+    /**
+     * When true, the SDK skips animations on imperative camera calls
+     * (wayfinding fits, `setView`, idle re-frames). Consumers should
+     * mirror their app's `prefers-reduced-motion` state into this.
+     */
+    reducedMotion?: boolean;
+    /**
+     * Whether a freshly computed route auto-highlights its first step's
+     * segment (the brighter `route-line-active` overlay). Defaults to
+     * `true`, preserving the turn-by-turn segment highlight that
+     * `setActiveStep` drives.
+     *
+     * Set `false` for kiosk-style "show the whole route at once" UIs:
+     * the entire route line is shown without singling out one segment,
+     * which reads more clearly at a glance and avoids implying the visitor
+     * must step through the route. `setActiveStep` still works when called
+     * explicitly (e.g. a paginated QR-handoff / mobile flow) — this only
+     * controls the automatic highlight on `routeReady`.
+     */
+    routeStepHighlight?: boolean;
+    /**
+     * Which way is up while a route is on screen. Defaults to `'kiosk'`.
+     *
+     * - `'kiosk'` — the kiosk's heading rotated 180°, so the map matches the
+     *   direction a visitor walks away from the screen (180°, south-up, when
+     *   the venue has no kiosk heading).
+     * - `'first-step'` — the direction of the route's first step: the tapped
+     *   start's approach when there is one, otherwise the first stretch of
+     *   the path. For UIs viewed away from any kiosk (a phone, a home
+     *   computer), where the kiosk's facing means nothing. Taken once per
+     *   route, so stepping through it or toggling the full route keeps that
+     *   orientation.
+     */
+    routeBearing?: 'kiosk' | 'first-step';
+    /**
+     * Whether restroom pins that are too close together to draw individually
+     * collapse into a single Material `wc` badge. Defaults to `true`.
+     *
+     * Venues author men's and women's restrooms as two amenities a few metres
+     * apart. Both are wayfinding-critical (rank 0) and both draw on a layer that
+     * doesn't allow icon overlap, so without this MapLibre resolves the collision
+     * by hiding one of them outright until the camera is very close in. Grouping
+     * shows one badge in their place and hands back *all* the members when it's
+     * tapped, so the consumer can offer directions to each.
+     *
+     * Set `false` to opt out and get the raw collision behaviour back.
+     */
+    groupRestroomIcons?: boolean;
     initialFloor?: string | number;
     enableInteractions?: boolean;
     customSprite?: string;
     minIndoorZoom?: number;
+    /**
+     * How far, in **metres** (default `0.3`, ≈1 ft), extruded interior polygons
+     * (restrooms, back-of-house, obstacles, connectors) are inset so their edges
+     * don't z-fight the neighbouring room block. A polygon too thin to survive
+     * the inset (it would keep under half its area, e.g. a ~0.3 m back-of-house
+     * perimeter band) is left at its original size rather than erased. Metres to match the theme's
+     * `fill-extrusion-height` values, which MapLibre defines in metres — unlike
+     * the distances shown to visitors, which are in feet. Was feet before this
+     * option changed units; a value of `1` is now ~3.3× thicker.
+     */
     wallThickness?: number;
-    boundsPadding?: number;
+    /**
+     * How much costlier a candidate on a **different floor** from the kiosk is
+     * treated when choosing the closest instance of an amenity (default `1.5`).
+     * Used by `findClosestByWalkTime`, and so by `navigateFromKioskToClosestAmenity`
+     * and `highlightAmenity`.
+     *
+     * A multiplier on the trip's effort — walk time plus the elevator wait — not
+     * a distance: `1.5` means another floor's instance has to be a third cheaper
+     * to beat one on the kiosk's floor. It is a *preference* for not making the
+     * visitor change floors, layered on top of the physical cost of doing so
+     * (which is already in the effort). `1` turns it off and ranks by effort
+     * alone; a value below `1` is treated as `1`. It only affects which instance
+     * is chosen — never a route.
+     *
+     * For scale: at the Las Vegas VA the nearest other-floor Lactation Pod costs
+     * ~400 ft-equivalent against ~530 for the one on the kiosk's floor, so it
+     * takes a value above ~1.32 to keep the visitor on their floor.
+     */
+    otherFloorPenalty?: number;
+    boundsPadding?: BoundsPadding;
+    /**
+     * Caps how far a visitor can pan/zoom out. By default the SDK derives this
+     * from the venue's own bounds, scaled to 3x its width/height around the
+     * same center — enough room to pan around the building without drifting
+     * into an empty, un-tiled region. The default box is never smaller than
+     * ~3.7 km a side, so a small venue isn't forced to zoom in tighter than a
+     * large one. Pass a number to use a different
+     * multiplier (e.g. `1.5` for a tighter leash), explicit `[[west, south],
+     * [east, north]]` bounds to override entirely, or `false` to disable
+     * max-bounds clamping.
+     */
+    maxBounds?: Bounds | number | false;
+    /**
+     * Hides basemap points of interest (civic and marine icons, park names) that
+     * fall within this many metres of the venue's bounds, so an OSM library or
+     * chapel on the campus isn't drawn underneath the venue's own map. Defaults
+     * to `50`. Street labels, road shields and water labels are never hidden.
+     * Pass `false` to show every basemap POI.
+     */
+    hideBasemapPoisNearVenue?: number | false;
+    /**
+     * Whether the venue's kiosk anchors a "You are here" marker, and the opening
+     * view / default route origin. Defaults to `true`. Set `false` for non-kiosk
+     * consumers (e.g. a browser map): no device is resolved, even via the
+     * "first placed device" fallback, so the marker is never drawn.
+     */
+    kiosk?: boolean;
+    /**
+     * Pitch (deg) for the opening view, applied centred on the kiosk ("You
+     * are here"). Omit for top-down.
+     */
+    initialPitch?: number;
+    /**
+     * Zoom for the opening view, centred on the kiosk. Set this above the
+     * theme's unit-walls breakpoint (~16.5 in the bundled hybrid theme) so the
+     * kiosk opens on the building's interior floor plan (its contents) rather
+     * than a zoomed-out 3D massing outline. Omit to keep the post-floor-fit
+     * 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
+     * this many zoom levels but never pull back below the interior into the
+     * massing/region. `0` locks zoom-out exactly to the opening view.
+     */
+    minZoomBelowInitialFit?: number;
+    /**
+     * Zoom-out floor expressed as ground scale: the most metres one CSS pixel
+     * may span. The SDK converts it to a `minZoom` at the venue's latitude, so
+     * every venue shows the same amount of surrounding map when fully zoomed
+     * out — a plain zoom number doesn't, because Web Mercator shows less ground
+     * per zoom level the further a venue is from the equator. Takes precedence
+     * over `minZoomBelowInitialFit`. For scale, `1.207` is zoom 15.8 at Orlando
+     * (about 2.3 km x 1.3 km on a 1920x1080 screen).
+     */
+    minZoomMetersPerPixel?: number;
+    /**
+     * Override the colour the SDK recolours every amenity SVG to before it
+     * composites the badge. `none` / `transparent` fills are preserved so
+     * cut-outs stay. When the badge is enabled (the default), this defaults
+     * to navy (`#162e51`) so icons read on gold. Set explicitly for a
+     * different look, or set `amenityBadge: false` to disable recolouring
+     * altogether and keep the CMS-uploaded colours.
+     */
+    amenityIconColor?: string;
+    /**
+     * Badge composited behind each amenity icon. Pass `false` to render the
+     * icon alone (no badge — useful for high-contrast or 2D themes where the
+     * gold disc would compete with the floor). Pass an object to tune the
+     * disc / ring style. Defaults to a VA-gold disc with a 2px white ring.
+     *
+     * The badge is baked into the icon bitmap (canvas composite) rather than
+     * drawn as a separate circle layer, so badge + icon participate in symbol
+     * collision together — overlapping amenities hide as one unit instead of
+     * the icon hiding while the disc stays painted.
+     */
+    amenityBadge?: AmenityBadgeStyle | false;
+    /**
+     * Badge for vertical-circulation connectors (elevator / stairs / escalator).
+     * These render as their own visual class — a navy disc with a white glyph —
+     * so circulation reads distinct from the gold service amenities. Pass `false`
+     * to fall them back into the regular gold badge, or an object to tune the
+     * disc / ring. When `amenityBadge` is `false`, connectors are badge-less too
+     * unless this is set explicitly.
+     */
+    connectorBadge?: AmenityBadgeStyle | false;
+    /**
+     * Badge for information-desk amenities (curated `information`/`info`
+     * icon). These render as their own visual class — a green disc with a
+     * white glyph by default — so information reads distinct from the gold
+     * service amenities. Pass `false` to fall them back into the regular gold
+     * badge, or an object to tune the disc / ring. When `amenityBadge` is
+     * `false`, information icons are badge-less too unless this is set
+     * explicitly.
+     */
+    informationBadge?: AmenityBadgeStyle | false;
+    /**
+     * Glyph colour for information icons on their badge. Default white
+     * (matches `informationBadge`'s default green disc).
+     */
+    informationIconColor?: string;
+    /**
+     * Badge for the end-of-route flag (`poi-route-end-flag`) shown in place of a
+     * destination's dot while a route to it is displayed. Has its own defaults
+     * (green disc, white ring) that don't follow `amenityBadge`. Pass an object
+     * to tune the disc / ring, or `false` for the bare flag glyph with no badge.
+     * When `amenityBadge` is `false`, the flag is badge-less too unless this is
+     * set explicitly. Under the high-contrast theme the disc colour is forced to
+     * the high-contrast amenity yellow, like the amenity and connector badges.
+     */
+    routeEndBadge?: AmenityBadgeStyle | false;
+    /**
+     * Flag glyph colour on the end-of-route badge. Default white (contrasts the
+     * default green disc); doesn't follow `amenityIconColor`. Ignored under the
+     * high-contrast theme, which forces its own glyph colour.
+     */
+    routeEndIconColor?: string;
     styleMode?: 'venueStyleUrl' | 'sdkTemplate';
     templateOverrideMode?: 'colorsOnly' | 'colorsAndConstants' | 'all';
 }
@@ -190,9 +732,19 @@ type SDKConfig = {
         venueId: number;
         locale?: string;
         auth?: JMapAuth;
+        /**
+         * Identifies which physical kiosk this instance is, so the SDK can pin
+         * the "You are here" marker. Matched against either the numeric device
+         * `id` or the device `uuid` from the venue's `devices`. The device's
+         * attached waypoint (`waypoint.deviceIds`) is the kiosk's location.
+         */
+        deviceId?: string | number;
     };
     jacs: {
-        mode: 'proxy' | 'direct';
+        /** `snapshot` reads published venue snapshots from a CDN — what clients
+         *  should use. `proxy`/`direct` read live JACS (the draft): local dev and
+         *  CMS preview. */
+        mode: 'proxy' | 'direct' | 'snapshot';
         host?: string;
         auth?: {
             clientId: string;
@@ -200,12 +752,240 @@ type SDKConfig = {
             password: string;
         };
         proxyBaseUrl?: string;
+        baseUrl?: string;
     };
     options?: SDKOptions;
 };
 
-/** How to center the map after computing a route */
-type WayfindCenterMode = 'none' | 'destination' | 'route';
+/** 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;
+    /**
+     * Re-assert the visibility the SDK itself owns — floor layers, the POI
+     * category filter, the 2D/3D view mode. Called at the end of `reset()`,
+     * because restoring a captured `visibility` can't distinguish "the theme
+     * ships this visible" from "the SDK hid it because it belongs to another
+     * floor", and the naive restore would reveal every floor at once.
+     */
+    reapplySdkState?: () => void;
+    log?: (...args: unknown[]) => void;
+};
+type LayerRow = {
+    id: string;
+    type: string;
+    visibility: Visibility;
+    /**
+     * What this layer's visibility was before we touched it — i.e. what the
+     * theme and the SDK want it to be. Equal to `visibility` for any layer we
+     * hold no override on. A UI wanting to show "is this group on" should judge
+     * only the layers whose `base` is `'visible'`: the rest (the 3D extrusions
+     * in flat mode, the 2D outlines outside it) aren't rendering by design, so
+     * counting them makes a healthy group look half-off.
+     */
+    base: Visibility;
+};
+/**
+ * Console-facing layer inspector for demos, screenshots and debugging.
+ *
+ * Reachable as `sdk.debug`, and as `window.mm.debug` when
+ * `options.debug` is on (see `options.debugGlobal`).
+ *
+ * Two things make it more than a wrapper around `setLayoutProperty`:
+ *
+ * 1. **Selectors.** `hide('amenities')`, `hide('route-')`, `hide('/^poi-/')`
+ *    and `hide('type:fill-extrusion')` all work, so you don't have to know
+ *    the theme's layer ids to start poking at it.
+ * 2. **Overrides are sticky.** The SDK re-asserts layer visibility on floor
+ *    changes, `setPOIFilter`, flat-mode toggles and theme swaps — all of which
+ *    would otherwise wipe a manual toggle mid-demo. Every override is re-applied
+ *    on `styledata`, so what you hid stays hidden until `reset()`.
+ */
+declare class DebugLayers {
+    private deps;
+    /** layer id → visibility this API is asserting. */
+    private overrides;
+    /** layer id → visibility before we first touched it. */
+    private originals;
+    /** `${layer}|${prop}` → paint value before we first touched it. */
+    private paintOriginals;
+    private sticky;
+    private attachedTo;
+    /** Re-entrancy guard: our own `setLayoutProperty` fires `styledata`. */
+    private applying;
+    private readonly onStyleData;
+    constructor(deps: DebugLayersDeps);
+    /** Begin re-asserting overrides across style/floor changes. */
+    attach(map: Map): void;
+    detach(): void;
+    /**
+     * Every layer in the active style, newest-on-top last, with its current
+     * visibility. Pass a selector to narrow it (same grammar as `hide`).
+     */
+    list(selector?: string): LayerRow[];
+    /** Just the ids currently rendering — the quickest "what am I looking at". */
+    visible(): string[];
+    /** Group name → the ids it resolves to *in the active style*. */
+    groups(): Record<string, string[]>;
+    /** Hide every layer the selectors resolve to. Returns the ids affected. */
+    hide(...selectors: string[]): string[];
+    /**
+     * **Force** every resolved layer visible — including ones the SDK
+     * deliberately keeps off: the 3D extrusions while flat mode is on, the 2D
+     * outlines while it isn't, every floor but the active one. Forcing those
+     * renders two representations of the same geometry at once, or every floor
+     * stacked, and the map looks wrong.
+     *
+     * So this is *not* the way to undo a `hide()` — use `restore()`, which puts
+     * each layer back to what it was rather than blanket-revealing the group.
+     * Reach for `show()` only when you actually mean "reveal this regardless".
+     */
+    show(...selectors: string[]): string[];
+    /**
+     * Undo our overrides on these layers: each goes back to the visibility it
+     * had before we first touched it, and control returns to the SDK (floor
+     * layers, POI filter, view mode re-assert afterwards).
+     *
+     * This is the correct inverse of `hide()`. A group is rarely uniformly
+     * visible to begin with — `rooms` hides either the 2D outline or the 3D
+     * extrusion depending on view mode, and every floor layer but the active
+     * one is off — so `hide()` then `show()` does not round-trip, but `hide()`
+     * then `restore()` does.
+     *
+     * Returns the ids that actually had an override; layers we never touched
+     * are left alone.
+     */
+    restore(...selectors: string[]): string[];
+    /** Flip each resolved layer independently. Returns the ids affected. */
+    toggle(...selectors: string[]): string[];
+    /**
+     * Show only what the selectors resolve to — everything else is hidden
+     * (except `background`, which is just the canvas colour). The one-liner for
+     * "which layer is drawing that thing".
+     *
+     * The kept set is *restored*, not forced: anything we'd previously hidden
+     * comes back, but a layer the theme ships hidden stays hidden. Soloing must
+     * not invent geometry that never renders normally — see `show()`.
+     */
+    solo(...selectors: string[]): string[];
+    /**
+     * Set a paint property — `paint('units-fill', 'fill-color', '#f00')`. The
+     * original value is captured so `reset()` puts it back. Not sticky: unlike
+     * visibility, a theme swap rebuilds paint from the new style and re-applying
+     * a captured expression across themes is exactly the bug `setTheme` had to
+     * fix. Re-run it after a swap if you need it back.
+     */
+    paint(selector: string, prop: string, value: unknown): string[];
+    /**
+     * Drop every override and paint change, then let the SDK re-assert the
+     * visibility it owns (floor layers, POI filter, view mode). Back to the map
+     * you'd have had without touching anything.
+     */
+    reset(): void;
+    /**
+     * Hand the layers we just released back to the SDK, then re-assert whatever
+     * overrides are still standing.
+     *
+     * The second half is not belt-and-braces. The SDK's re-assert passes are
+     * all-or-nothing: with no POI filter active, `applyPOIFilter` writes
+     * `visible` to *every* POI category layer, and the floor / view-mode passes
+     * sweep their whole layer sets the same way. So releasing one group would
+     * un-hide every other group you'd hidden — hide labels, destinations and
+     * amenities, re-check one, and all three came back.
+     *
+     * Doing it here rather than waiting for the `styledata` the SDK's writes
+     * trigger also keeps it synchronous: MapLibre fires that on a later frame,
+     * so a UI reading visibility straight after this call would otherwise see —
+     * and render — the clobbered state.
+     */
+    private handBackToSdk;
+    /**
+     * The current override set as a plain object — save it, paste it back with
+     * `apply()` to reproduce the exact same framing for a screenshot later.
+     */
+    snapshot(): Record<string, Visibility>;
+    /** Apply a `snapshot()` (or any layer-id → visibility map). */
+    apply(snapshot: Record<string, Visibility>): string[];
+    /**
+     * Stop (or resume) re-asserting overrides when the style changes. Turn it
+     * off if you want a floor switch or `setPOIFilter` to win over what you
+     * toggled by hand.
+     */
+    setSticky(enabled: boolean): boolean;
+    /** Console cheat sheet. */
+    help(): Array<{
+        call: string;
+        does: string;
+    }>;
+    /**
+     * Resolve one selector to layer ids present in the active style, tried in
+     * order: group name → exact layer id → `type:<layer type>` → `/regex/` →
+     * case-insensitive substring on the id.
+     */
+    resolve(selector: string): string[];
+    private resolveAll;
+    private set;
+    /**
+     * Put these layers back to their pre-override visibility and forget them.
+     * Callers decide whether to follow up with `reapplySdkState` — `restore()`
+     * and `reset()` do, `solo()` deliberately doesn't.
+     */
+    private restoreVisibility;
+    /** Write one layer's visibility and remember it as an override. */
+    private write;
+    /**
+     * Re-assert overrides after something else rewrote layer visibility. Only
+     * writes when the current value actually differs, so this doesn't feed
+     * itself through the `styledata` it triggers.
+     */
+    private reapply;
+    private styleLayers;
+    private visibilityOf;
+    /**
+     * MapLibre throws from these getters/setters while a style is mid-swap (the
+     * layer exists in `getStyle()` but its owner is being replaced). A debug tool
+     * that can break the map it's inspecting is worse than useless.
+     */
+    private safe;
+}
+
+type LayerAudit = {
+    /** `featureType` values the CMS permits for this customer. */
+    allowed: string[];
+    /** `featureType` values actually present in the loaded floors. */
+    inData: string[];
+    /** `featureType` values some theme layer filters on. */
+    inStyle: string[];
+    /**
+     * Drawn on a map but not in the customer's allowed list — a mis-authored
+     * or renamed layer. These render only by accident (if the theme happens to
+     * match the string) and are invisible otherwise.
+     */
+    unauthorized: string[];
+    /**
+     * Present in the data and allowed, but no theme layer filters on it. The
+     * author drew something the map will never show.
+     */
+    unstyled: string[];
+    /**
+     * The theme filters on it, but no loaded floor contains it. Dead weight in
+     * the style *for this venue* — another venue may well use it, so this is a
+     * prompt to check, not a delete list. Cross-reference `allowed`: a value
+     * that isn't in there either is dead everywhere for this customer.
+     */
+    unused: string[];
+    /**
+     * Allowed by the CMS but no theme rule matches it, whether or not this
+     * venue happens to draw it. The SDK's total blind spot — an author can
+     * legitimately draw any of these and get nothing.
+     */
+    allowedNotStyled: string[];
+};
 
 type LoggerFn = (...args: unknown[]) => void;
 type AmenityManagerDeps = {
@@ -224,71 +1004,1896 @@ declare class AmenityManager {
     private log;
     private loadForFloor;
     getAll(): AmenityWithFloor[];
+    /**
+     * Venue-wide amenities, one entry per id. `getAll()` returns each amenity
+     * once per floor it appears on (and so renders a multi-floor "Bathroom"
+     * three times in a venue list); this collapses those into a single record
+     * with all its waypoints merged across floors.
+     *
+     * Also folds any duplicate-id records from the provider into a single entry
+     * so React lists don't trip on dup keys. This used to say those duplicates
+     * were "a CMS data bug" — they weren't. JACS returns one record per amenity;
+     * the SDK's own floor index pushed it once per waypoint, so an amenity with
+     * four placements on a floor came back four times. Fixed at the source in
+     * `jacsDataProvider.floorIdsForWaypoints`; the fold stays as a cheap guard
+     * for a provider that genuinely repeats an id.
+     *
+     * Use this for venue-wide browse UIs; pair it with `findClosestWaypoint`
+     * (on the SDK) to resolve a tap to the nearest physical instance.
+     */
+    getDistinct(): Amenity[];
     getByFloorId(floorId: Floor['id']): AmenityWithFloor[];
     getAllKiosks(): AmenityWithFloor[];
     getKioskForFloor(floorId: Floor['id']): AmenityWithFloor | null;
     logKioskForFloor(floorId: Floor['id']): void;
 }
 
+/**
+ * The `mm_`-prefixed extensor keys the CMS reserves for fields JACS has no
+ * column for yet.
+ *
+ * This file is the read half of a cross-repo table: the write half is
+ * `cms/packages/map-manager/app/utils/reserved-extensors.js`, which owns the key
+ * names, the value encodings, and the rule that a default value is deleted
+ * rather than stored. Change them together.
+ *
+ * The `mm_` prefix is load-bearing on both sides. Authors can type anything into
+ * the CMS's free-form Properties editor, so an unprefixed key like
+ * `point_of_interest` could collide with a hand-entered one; the prefix also
+ * makes "is this key reserved?" a prefix scan rather than a hand-maintained list
+ * once JACS grows real columns and these are migrated away.
+ *
+ * Two things that look like they belong here and don't:
+ *
+ * - **Room number.** The CMS labels it "Room Number", but it writes the real
+ *   `Destination.unitNumber` field, not an extensor. `getPOIDetails().roomNumber`
+ *   reads that field (see `sdk.ts`).
+ * - **`mm_point_of_interest`.** Registered by the CMS and parsed here for
+ *   completeness, but deliberately not surfaced on `getPOIDetails` — nothing has
+ *   pinned down whether an unflagged destination should drop out of search, out
+ *   of the map, or neither, and guessing wrong is worse than omitting it.
+ */
+declare const RESERVED_EXTENSOR_PREFIX = "mm_";
+/** Weekly opening hours. Value shape and parser live in `openHours.ts`. */
+declare const OPEN_HOURS_EXTENSOR_KEY = "mm_open_hours";
+/** Phone number, with the extension folded into the same value. */
+declare const PHONE_EXTENSOR_KEY = "mm_phone";
+/** Alt text for the destination's uploaded Location Image. */
+declare const IMAGE_ALT_EXTENSOR_KEY = "mm_image_alt";
+/** Author-set "this is a point of interest" flag. Parsed, not surfaced. */
+declare const POINT_OF_INTEREST_EXTENSOR_KEY = "mm_point_of_interest";
+/**
+ * Which building on the campus the destination stands in.
+ *
+ * The venue's own `Building` record can't answer this: the CMS binds a venue to
+ * a single building and hangs the floor list off it, so a campus with a dozen
+ * numbered buildings has one `Building` and no way to say which one a room is
+ * in. The author types it as free text, and that text is what a kiosk prints —
+ * it is not a reference to anything, so don't try to resolve it against
+ * `venue.buildings`.
+ */
+declare const BUILDING_NAME_EXTENSOR_KEY = "mm_building_name";
+interface DestinationPhone {
+    /** Exactly as the author typed it — `"(408) 300-9294"`. Deliberately not
+     *  normalised: doing that properly across international formats needs a real
+     *  phone library, and the CMS makes the same choice on the way in. */
+    number: string;
+    /** Internal extension digits, when there is one. */
+    ext?: string;
+}
+/**
+ * `"(408) 300-9294;ext=123"` → `{ number, ext }`. `null` when there's no number
+ * — including for the empty string, which is how JACS spells a deleted key.
+ */
+declare function parsePhone(raw: unknown): DestinationPhone | null;
+/** Alt text for the Location Image, or `undefined` when the author set none. */
+declare function parseImageAlt(raw: unknown): string | undefined;
+/** The building name, or `undefined` when the author set none. */
+declare function parseBuildingName(raw: unknown): string | undefined;
+/** The point-of-interest flag. Absence means false — only the checked state is
+ *  ever stored. */
+declare function parsePointOfInterest(raw: unknown): boolean;
+
+/**
+ * Weekly opening hours for a destination.
+ *
+ * JACS has no hours column, so the CMS ships the whole week in a single
+ * destination extensor — key `mm_open_hours`, value a JSON string:
+ *
+ *   {"v":1,"days":{"mon":[["09:00","17:30"]],"sat":[],"sun":[["00:00","24:00"]]}}
+ *
+ * - Times are 24-hour `"HH:MM"` and **venue-local**; no timezone is recorded.
+ * - Each day maps to an array of `[open, close]` ranges. The editor exposes one
+ *   range per day today, but the array shape leaves room for split shifts (a
+ *   cafeteria that closes over the afternoon) and extra ranges round-trip.
+ * - An empty array — or a missing day — means closed.
+ * - `[["00:00","24:00"]]` means open 24 hours.
+ *
+ * This module owns the read half: parse the value (`parseOpenHours`) and derive
+ * the live open/closed state from it (`getOpenStatus`). The write half lives in
+ * the CMS (`map-manager`'s `utils/open-hours.js`) — the two must agree on the
+ * wire shape above, so change them together. The key itself is registered in
+ * `reservedExtensors.ts` alongside the CMS's other stand-in fields, mirroring
+ * the same split on the authoring side.
+ */
+
+/** Wire-format version this module understands. */
+declare const OPEN_HOURS_VERSION = 1;
+type DayKey = 'mon' | 'tue' | 'wed' | 'thu' | 'fri' | 'sat' | 'sun';
+/** Monday-first, matching the wire format's own day order. `getOpenStatus`
+ *  reports `OpenHoursTransition.day` as one of these. */
+declare const DAY_KEYS: readonly DayKey[];
+/** One open→close stretch within a single day. 24-hour `"HH:MM"`, venue-local.
+ *  `close` may be `"24:00"` (end of day); `open` never is. */
+interface HoursRange {
+    open: string;
+    close: string;
+}
+/** A parsed week. Every day is present; a closed day is an empty array. */
+interface OpenHours {
+    days: Record<DayKey, HoursRange[]>;
+    /** Open every minute of the week (a 24/7 emergency department, say). The
+     *  status has no `closesAt` in this case — there is nothing to count down to. */
+    alwaysOpen: boolean;
+}
+/** A point in the week the status is counting toward. */
+interface OpenHoursTransition {
+    /** Day the transition falls on, venue-local. */
+    day: DayKey;
+    /** 24-hour `"HH:MM"`, venue-local. Midnight is always `"00:00"` on the
+     *  following day — `"24:00"` never surfaces here. */
+    time: string;
+    /** Whole minutes from `now`. */
+    minutesUntil: number;
+    /** Calendar days ahead: `0` today, `1` tomorrow. */
+    daysAhead: number;
+}
+interface OpenStatus {
+    /** Open right now. */
+    open: boolean;
+    /** Open every minute of the week — no closing time to show. */
+    alwaysOpen: boolean;
+    /** Open, and closing within `soonMinutes`. */
+    closingSoon: boolean;
+    /** Closed, and opening within `soonMinutes`. */
+    openingSoon: boolean;
+    /** When open: the end of the current stretch. Absent when `alwaysOpen`. */
+    closesAt?: OpenHoursTransition;
+    /** When closed: the next time it opens. Absent when no day is open. */
+    opensAt?: OpenHoursTransition;
+}
+interface OpenStatusOptions {
+    /** How near a transition counts as "soon". Default `30`. */
+    soonMinutes?: number;
+    /** IANA zone the hours are expressed in (`'America/Denver'`). Omit — the
+     *  normal case for a kiosk standing in the venue — to read the host clock.
+     *  An unrecognised zone falls back to the host clock rather than throwing. */
+    timeZone?: string;
+}
+/**
+ * Extensor value → a parsed week, or `null` when there is nothing usable.
+ *
+ * Accepts the stored JSON string or an already-parsed object. Anything
+ * unreadable — absent key, malformed JSON, no open day — is `null` rather than
+ * a throw, so a bad value costs the consumer an omitted section, not a crash.
+ *
+ * An unknown `v` is also `null`, deliberately. A future version could add
+ * holiday overrides or a timezone; reading only the `days` it recognises would
+ * let the SDK announce "Open" on a day the venue marked closed, and a confidently
+ * 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.
+ *
+ * Pure and time-explicit: pass the `now` you want evaluated (default: the
+ * moment of the call). Nothing is cached, so a consumer that wants a status
+ * that stays true — a kiosk card sitting open — re-calls this on a tick rather
+ * than holding the result.
+ *
+ * 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. 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;
+    fetchImpl?: typeof fetch;
+} | {
+    mode: 'direct';
+    host: string;
+    clientId: string;
+    username: string;
+    password: string;
+    fetchImpl?: typeof fetch;
+};
+type GetBuildingsArgs = {
+    customerId: number | string;
+    venueId: number | string;
+};
+type GetFloorsArgs = {
+    customerId: number | string;
+    venueId: number | string;
+    buildingId: number | string;
+    /** BCP-47 code (`es`, `en-US`). When set, JACS resolves floor `name` /
+     *  `description` to that locale instead of the customer's default. */
+    locale?: string;
+};
+type GetDestinationsArgs = {
+    customerId: number | string;
+    venueId: number | string;
+    /** See {@link GetFloorsArgs.locale}. */
+    locale?: string;
+};
+type GetAmenitiesArgs = {
+    customerId: number | string;
+    /** See {@link GetFloorsArgs.locale}. */
+    locale?: string;
+};
+type GetZonesArgs = {
+    customerId: number | string;
+    venueId: number | string;
+    /** See {@link GetFloorsArgs.locale}. */
+    locale?: string;
+};
+type GetMapLabelsArgs = {
+    customerId: number | string;
+    venueId: number | string;
+    /** See {@link GetFloorsArgs.locale}. */
+    locale?: string;
+};
+type GetVenueArgs = {
+    customerId: number | string;
+    venueId: number | string;
+};
+type JacsVenue = Record<string, any>;
+type GetBuildingFullArgs = {
+    customerId: number | string;
+    venueId: number | string;
+    buildingId: number | string;
+    mapProfile?: string;
+    geojson?: boolean;
+};
+type JacsBuildingFull = Record<string, any>;
+type JacsVenueAll = Record<string, any>;
+type GetStylesheet3dArgs = {
+    customerId: number | string;
+    venueId: number | string;
+    buildingId: number | string;
+};
+type GetFloorMapGeoJsonArgs = {
+    customerId: number | string;
+    venueId: number | string;
+    buildingId: number | string;
+    floorId: number | string;
+};
+type GetPolygonLayersArgs = {
+    customerId: number | string;
+};
+type GetFloorMapTemplate3dArgs = {
+    customerId: number | string;
+    venueId: number | string;
+    buildingId: number | string;
+    floorId: number | string;
+};
+type JacsBuilding = {
+    id?: number | string;
+    buildingId?: number | string;
+    name?: string;
+    isDefault?: boolean;
+    default?: boolean;
+    [key: string]: any;
+};
+type JacsFloor = Record<string, any>;
+type JacsDestination = Record<string, any>;
+type JacsAmenity = Record<string, any>;
+type JacsZone = Record<string, any>;
+type JacsMapLabel = Record<string, any>;
+type JacsPolygonLayer = Record<string, any>;
+/**
+ * This matches the “map-template/3d” shape you pasted earlier:
+ * rows keyed by layerName with paint-ish properties like fill, line-color, etc.
+ */
+type JacsMapTemplate3dRow = {
+    layerName: string;
+    fill?: string | null;
+    'fill-opacity'?: number | null;
+    fillAntialias?: boolean | null;
+    'fill-pattern'?: string | null;
+    'line-color'?: string | null;
+    'line-width'?: number | null;
+    lineOpacity?: number | null;
+    strokeWidth?: number | null;
+    strokeOpacity?: number | null;
+    'fill-extrusion-color'?: string | null;
+    'fill-extrusion-height'?: number | null;
+    'fill-extrusion-opacity'?: number | null;
+    'fill-extrusion-base'?: number | null;
+    'fill-extrusion-pattern'?: string | null;
+    [key: string]: any;
+};
+declare class JacsProvider {
+    private mode;
+    private proxyBaseUrl;
+    private direct;
+    private fetchImpl;
+    private tokenCache;
+    constructor(config: JacsProviderConfig);
+    /** `/customer/all` — every customer with its venues, for a venue picker. Each
+     *  entry is `{ customer, venues[] }`. Not venue-scoped. */
+    getCustomersAll(): Promise<Record<string, any>[]>;
+    getPolygonLayers(args: GetPolygonLayersArgs): Promise<JacsPolygonLayer[]>;
+    getFloorMapTemplate3d(args: GetFloorMapTemplate3dArgs): Promise<JacsMapTemplate3dRow[]>;
+    getFloors(args: GetFloorsArgs): Promise<JacsFloor[]>;
+    /**
+     * Hits the JEM venue full-call aggregator at /customer/{cid}/venue/{vid}/all.
+     * Unlike /building/{bid}/full this endpoint does NOT go through Redis — JACS
+     * assembles the response server-side from many controllers on every call, so
+     * SDK consumers always see fresh data regardless of cache invalidation state.
+     *
+     * Response shape: { customer, venue, buildings: [{ floors }], waypoints[],
+     * destinations[], amenities[], paths[], mapLabels[], devices[], zones[],
+     * pathTypes[], mapProfiles[] }. Floor geojson is NOT included — the SDK
+     * lazy-loads it via ensureFloorGeojson.
+     */
+    getVenueAll(args: GetVenueArgs): Promise<JacsVenueAll>;
+    getVenue(args: GetVenueArgs): Promise<JacsVenue>;
+    getFloorMapGeojson(args: GetFloorMapGeoJsonArgs): Promise<GeoJSON.FeatureCollection>;
+    getBuildingFull(args: GetBuildingFullArgs): Promise<JacsBuildingFull>;
+    getDestinations(args: GetDestinationsArgs): Promise<JacsDestination[]>;
+    /** Zones (department groupings). `name` / `description` are localized. */
+    getZones(args: GetZonesArgs): Promise<JacsZone[]>;
+    /**
+     * CMS-authored map labels (street / area / wing names). The endpoint is
+     * `/label`, not `/map-label` — the latter 404s. The localized `name` is on
+     * the label template; each `instances[]` placement carries its own internal
+     * `name` ("Parking Lot E - Instance 1") which is authoring metadata and is
+     * never displayed.
+     */
+    getMapLabels(args: GetMapLabelsArgs): Promise<JacsMapLabel[]>;
+    /**
+     * Amenities are **customer-scoped**, not venue-scoped. A
+     * `/customer/{id}/venue/{id}/amenity` path also exists and returns the same
+     * records, but it silently ignores `?locale=` — it answers with the base
+     * (en-US) names for every locale, which reads as "translations aren't
+     * working" rather than as a wrong URL. Only `/customer/{id}/amenity`
+     * resolves the locale. Don't reintroduce the venue segment.
+     */
+    getAmenities(args: GetAmenitiesArgs): Promise<JacsAmenity[]>;
+    getBuildings(args: GetBuildingsArgs): Promise<JacsBuilding[]>;
+    getStylesheet3d(args: GetStylesheet3dArgs): Promise<StyleSpecification>;
+    invalidateToken(): void;
+    getJson<T>(path: string): Promise<T>;
+    private extractArray;
+    private getJwtToken;
+    private normalizeHost;
+    private joinUrl;
+    private safeReadText;
+}
+
+/** The JacsProvider methods the SDK's data layer reads. Both JacsProvider (live
+ *  JACS) and SnapshotProvider (published snapshots) implement them. */
+type JacsReader = Pick<JacsProvider, 'getVenueAll' | 'getFloorMapGeojson' | 'getDestinations' | 'getFloors' | 'getZones' | 'getMapLabels' | 'getAmenities' | 'getPolygonLayers' | 'getCustomersAll'>;
+type SnapshotProviderConfig = {
+    /** Root of the snapshot host, e.g. `https://snapshots.example.com`. */
+    baseUrl: string;
+    fetchImpl?: typeof fetch;
+};
+/** Highest manifest `schemaVersion` this SDK can read. */
+declare const SNAPSHOT_SCHEMA_VERSION = 1;
+/**
+ * The venue (or its customer) can't be shown from snapshots: it was never
+ * published, or it was withdrawn (unpublished, disabled or deleted). Thrown
+ * from `init()`; check `reason` to show "not published" vs "no longer
+ * available".
+ */
+declare class SnapshotUnavailableError extends Error {
+    readonly reason: 'not-published' | 'withdrawn';
+    readonly customerId: string;
+    readonly venueId: string | null;
+    constructor(reason: 'not-published' | 'withdrawn', customerId: string, venueId: string | null);
+}
+/** The customer and venue snapshot versions a load is using. */
+type SnapshotVersions = {
+    customer: number;
+    venue: number;
+};
+/**
+ * Result of `checkForUpdate`: whether what's published now differs from what
+ * this instance loaded.
+ *
+ * - `current` — nothing newer is published.
+ * - `available` — a newer customer or venue version is published; reload to
+ *   show it.
+ * - `unavailable` — the venue (or its customer) has since been withdrawn or
+ *   was never published; a reload would fail with `SnapshotUnavailableError`.
+ * - `incompatible` — a newer version is published in a schema this SDK can't
+ *   read; don't reload until the SDK is updated.
+ */
+type SnapshotUpdateCheck = {
+    status: 'current';
+    loaded: SnapshotVersions;
+} | {
+    status: 'available';
+    loaded: SnapshotVersions;
+    latest: SnapshotVersions;
+} | {
+    status: 'unavailable';
+    loaded: SnapshotVersions;
+    reason: 'not-published' | 'withdrawn';
+} | {
+    status: 'incompatible';
+    loaded: SnapshotVersions;
+    schemaVersion: number;
+};
+/**
+ * Picks the locale folder to read. Exact (case-insensitive) match first, then a
+ * same-language match (`es` → `es-US`), then `fallback` — so a locale the
+ * customer added after this venue was last published falls back to the default
+ * language until the venue is republished.
+ */
+declare function resolveSnapshotLocale(requested: string | undefined, available: string[], fallback: string): string;
+declare class SnapshotProvider implements JacsReader {
+    private baseUrl;
+    private fetchImpl;
+    private snapshots;
+    private files;
+    constructor(config: SnapshotProviderConfig);
+    /** `directory.json` — published, public customers with their venues, in
+     *  `/customer/all`'s `{ customer, venues[] }` shape. */
+    getCustomersAll(): Promise<Record<string, any>[]>;
+    /** venue.json with the customer-wide pieces put back where `/all` has them. */
+    getVenueAll(args: {
+        customerId: number | string;
+        venueId: number | string;
+    }): Promise<JacsVenueAll>;
+    getFloorMapGeojson(args: {
+        customerId: number | string;
+        venueId: number | string;
+        floorId: number | string;
+    }): Promise<GeoJSON.FeatureCollection>;
+    getDestinations(args: {
+        customerId: number | string;
+        venueId: number | string;
+        locale?: string;
+    }): Promise<JacsDestination[]>;
+    /** The snapshot holds the first building's floors only — the one the SDK reads. */
+    getFloors(args: {
+        customerId: number | string;
+        venueId: number | string;
+        locale?: string;
+    }): Promise<JacsFloor[]>;
+    getZones(args: {
+        customerId: number | string;
+        venueId: number | string;
+        locale?: string;
+    }): Promise<JacsZone[]>;
+    getMapLabels(args: {
+        customerId: number | string;
+        venueId: number | string;
+        locale?: string;
+    }): Promise<JacsMapLabel[]>;
+    getAmenities(args: {
+        customerId: number | string;
+        locale?: string;
+    }): Promise<JacsAmenity[]>;
+    getPolygonLayers(args: {
+        customerId: number | string;
+    }): Promise<JacsPolygonLayer[]>;
+    /** The manifest versions this instance is reading, once loaded. */
+    getVersions(customerId: number | string, venueId: number | string): Promise<{
+        customer: number;
+        venue: number;
+    }>;
+    /**
+     * Re-reads both manifests (without changing what this instance reads) and
+     * compares them with the versions it loaded. Rejects when a manifest can't
+     * be fetched — a network failure says nothing about what's published, so
+     * try again later.
+     */
+    checkForUpdate(customerId: number | string, venueId: number | string): Promise<SnapshotUpdateCheck>;
+    private venueLocalized;
+    private customerRef;
+    private venueRef;
+    /**
+     * Runs `read` against the pinned snapshots. The publisher keeps old versions
+     * for a while, but a long-running client (a kiosk) can outlive one: if a
+     * pinned version's file is gone, re-read that manifest and retry once on the
+     * current version. Data already loaded from the old version stays as it was;
+     * files fetched from now on come from the new one.
+     */
+    private pinned;
+    /** The current manifest, read once per instance: a loaded venue keeps
+     *  reading the version it started with (see `pinned` for when it can't). */
+    private snapshot;
+    /** Versioned files are immutable, so one fetch per file per instance. */
+    private file;
+    private list;
+    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;
+    /**
+     * Generation token for `init()`. Bumped by every `init()` and by `destroy()`,
+     * so an init suspended on a network await can tell it has been superseded and
+     * bail instead of creating a map nobody holds a reference to.
+     *
+     * This is what makes `destroy()` safe *during* init: `destroy()` only removes
+     * `this.map`, which is still null until step 3, so a teardown that lands
+     * mid-fetch has nothing to clean up — and without this token the init would
+     * resume and build a fully live orphan (WebGL context, render loop, map-level
+     * listeners, YAH pulse) that can never be reached to shut down. React
+     * StrictMode's mount → unmount → mount does exactly this on every dev load.
+     *
+     * A counter, not a sticky `destroyed` flag: `destroy()` → `init()` re-init is
+     * a supported lifecycle (see the manager-class note in CLAUDE.md), so the
+     * instance has to stay usable after teardown.
+     */
+    private initGeneration;
     private data;
     private wayfindingProvider;
     private events;
     private floorsApi;
     private venue;
     private spriteKeys;
-    private readonly debug;
+    private readonly debugEnabled;
     private readonly logger;
+    /**
+     * Console-facing layer inspector — `sdk.debug.hide('labels')`,
+     * `sdk.debug.solo('route')`, `sdk.debug.reset()`. Always present so demo
+     * code can drive it; additionally reachable as `window.mm.debug` when
+     * `options.debug` is on. See `DebugLayers`.
+     */
+    readonly debug: DebugLayers;
+    /** The `window` key `debug` mode installed this instance under, if any. */
+    private debugGlobalKey;
     private defaultCamera;
+    /** This venue's opening zoom, captured once after the initial fit resolves.
+     *  Anchors the pinned zoom profile's icon/label reveal thresholds (idle
+     *  spotlight, active route) to this venue's own opening view rather than an
+     *  absolute MapLibre zoom, and the roof fill's fade-in. See `zoomViews`. */
+    private iconZoomBase;
+    /** The current floor's building-label points, as written to
+     *  `MAP_LABELS_SOURCE_ID` — what a building-label tap hit-tests against. */
+    private buildingLabelPoints;
+    /** Which layers show at which zoom: the Campus / Building / Kiosk views, or
+     *  the pinned profile while the idle spotlight or a route is up. Re-applied
+     *  after every `setTheme()` swap, since `setStyle({ diff: false })`
+     *  recreates layers from the pristine theme. */
+    private zoomViews;
     private viewModes;
+    /** Mirror of `config.options.reducedMotion`, mutable via `setReducedMotion`. */
+    private reducedMotion;
+    /** Whether map labels render in OpenDyslexic, mutable via `setDyslexicFont`.
+     *  Re-applied after every `setTheme()` swap, same reason as `iconZoomBase`. */
+    private dyslexicFont;
+    /** 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` 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;
+    /** Tracks the active locale so `setLocale()` is a no-op when re-requested.
+     *  Seeded from `config.jmap.locale` at construction; `undefined` means
+     *  whatever the customer's default locale is on the JACS side. */
+    private currentLocale;
+    /** 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 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;
+    private selectionManager;
+    private restroomGroups;
+    /** Captured unit paint values to restore when the selection clears, or
+     *  `null` when no room is currently focused. See `UNIT_DIM_TARGETS`. */
+    private unitDimRestore;
+    /** Captured destination-layer filters to restore when the selection clears,
+     *  or `null` when no destination focus is active. See `setDestinationFocus`. */
+    private destFocusRestore;
+    /** The allow-list currently narrowing the destination layers, or `null` when
+     *  no focus is active. Kept alongside `destFocusRestore` (which holds the
+     *  *previous* filters, not the ids) so `setTheme` can re-apply the same focus
+     *  to the new style's layers after a swap discards the old ones. */
+    private destFocusIds;
+    /** The predicate currently narrowing the POI marker layers to a curated set,
+     *  or `null` when no spotlight is active. See `setPOISpotlight`. Held as the
+     *  predicate, not a resolved id list, so a floor change or locale redraw can
+     *  re-resolve it against the POIs now on screen. */
+    private poiSpotlight;
+    /** Layer filters as they were before the spotlight narrowed them, put back
+     *  verbatim when it releases. `null` when no spotlight filter is applied. */
+    private poiSpotlightRestore;
+    /** Coordinates of the current tap/Info selection, or `null` when nothing is
+     *  selected. `easeToSelection` reads `getBoundsPadding()` at the moment a
+     *  selection is made, which is often *before* the consumer's info card has
+     *  mounted and been measured into that padding — so the first pan can land
+     *  the POI behind the card. Kept here so `setBoundsPadding` can re-nudge the
+     *  camera once the consumer measures its now-mounted chrome and reports
+     *  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
+     *  "You are here" anchor and the transient highlight layers are excluded;
+     *  a POI drawn across the circle/label/icon layers is de-duped downstream
+     *  in `resolveClickedPOIs`. */
+    private static readonly CLICKABLE_POI_LAYERS;
+    /** Room-body layers that are also tappable: a click on a `Units` polygon
+     *  resolves to the destination pin inside it (see `resolvePOIsFromFeatures`).
+     *  Queried alongside the pin layers so tapping the room or its dot behaves
+     *  identically. Kept separate from the pin list because these carry no POI
+     *  identity of their own — they resolve spatially. */
+    private static readonly CLICKABLE_UNIT_LAYERS;
+    /** The kiosk's own "you are here" pin — icon, directional heading wedge,
+     *  and the ring drawn behind them. Deliberately **not** part of
+     *  `CLICKABLE_POI_LAYERS`: that list feeds `emitPoiSelected`, which opens
+     *  a selection card for a destination/amenity, and this pin isn't one —
+     *  it's where the kiosk itself is standing. A tap here means "where am
+     *  I", so it gets its own delegated listener emitting `youAreHereClicked`
+     *  instead, for a consumer to wire to the same recenter action as its
+     *  own recenter control. */
+    private static readonly YOU_ARE_HERE_LAYERS;
+    /** While a room is selected, the other units are recolored to a flat, muted
+     *  gray so the raised, full-strength highlight block reads as the focus. We
+     *  recolor rather than lower opacity on purpose: translucent extrusions blend
+     *  through their neighbours and look murky. The blocks stay fully opaque (and
+     *  keep their vertical-gradient shading, so they still read as rooms) — just
+     *  colorless. The selected room's own base grays too, but its highlight cap
+     *  sits opaque and taller on top, so it still stands out. The original paint
+     *  value (the data-driven color expression) is captured at mute time and put
+     *  back on `clearHighlight`, so department tinting returns intact. */
+    private static readonly UNIT_DIM_TARGETS;
+    /** Destination marker layers hidden down to just the selected destination
+     *  while a room is focused, so the map declutters to the one place in view.
+     *  Amenity/connector layers (`poiType: 'amenity'`), the "you are here" anchor,
+     *  and room name labels (`map-labels`) are deliberately absent — they stay
+     *  visible as wayfinding reference. Restored on `clearHighlight`. */
+    private static readonly DESTINATION_FOCUS_LAYERS;
+    /** Categorical POI layers in the bundled theme that `setPOIFilter`
+     *  toggles. Layers absent from this list — `poi-you-are-here-*` and the
+     *  `poi-highlight-*` layers — are intentionally unaffected; they're
+     *  anchors or transient focus state, not categorical content. */
+    private static readonly POI_CATEGORY_LAYERS;
+    /** Marker layers `setPOISpotlight` narrows. Every categorical POI layer
+     *  except `poi-other-amenity-icons`, whose filter the restroom-group manager
+     *  and the zoom-range pass rewrite as the camera moves — a spotlight
+     *  narrowing would be silently overwritten mid-orbit — plus the per-instance
+     *  amenity label, which is a marker in every sense but isn't a category. */
+    private static readonly POI_SPOTLIGHT_LAYERS;
+    private poiVisibleTypes;
+    /** Independent show/hide state for destination dots and name labels, set
+     *  by `setDestinationCirclesVisible`/`setDestinationLabelsVisible`. Kept
+     *  separate from `poiVisibleTypes` so the two controls compose instead of
+     *  clobbering each other — `applyPOIFilter` and `applyDestinationDisplay`
+     *  each own one paint/layout axis of the same layers. */
+    private destinationCirclesVisible;
+    private destinationLabelsVisible;
     constructor(config: SDKConfig);
     init(): Promise<void>;
+    /**
+     * Supply an image the current style has requested but doesn't have.
+     *
+     * Every imperatively-registered image is served from here, because a theme
+     * swap (`setStyle` with `diff: false`) drops all of them and the code that
+     * registered them doesn't run again:
+     *
+     * - the **route arrow** isn't in the sprite sheet at all — it's canvas-drawn
+     *   on demand (this was already the case);
+     * - **amenity / destination icons** come back from `iconCache`. Their
+     *   registrars run only during `init`, so before this they went missing on
+     *   the first theme swap and never returned — the map kept the dots and
+     *   labels but lost every badge and logo.
+     *
+     * Serving lazily (rather than re-registering everything on `style.load`)
+     * means only the ids the new style actually asks for are restored, with no
+     * refetch and no re-compositing.
+     */
+    private serveMissingStyleImage;
     on(event: string, cb: (e: MapEvent) => void): void;
     off(event: string, cb?: (e: MapEvent) => void): void;
     addControl(control: IControl, position?: ControlPosition): void;
     setView(options: ViewOptions): void;
+    /**
+     * Force a camera move to land instantly while reduced motion is on.
+     *
+     * The single gate every consumer-driven move goes through — zoom
+     * buttons, compass reset, go-home, recenter, route fits — so the one
+     * toggle covers them all instead of each call site remembering to ask.
+     * Returns `opts` untouched when the preference is off, so a caller that
+     * asked for `animate: false` keeps it either way.
+     */
+    private motionGated;
     get amenities(): AmenityManager;
     resetView(opts?: {
         animate?: boolean;
         duration?: number;
     }): void;
+    /** Whether the "You are here" pin, its name or its ring is drawn under
+     *  `point` — the same box the `youAreHereClicked` handler queries, so a tap
+     *  that recenters never also selects the room or pins beneath the pin.
+     *  Synchronous, and `false` if the query throws: `poi-data` doesn't show the
+     *  persistent failure `map/symbolHitTest.ts` works around, only the
+     *  one-frame one, and a dropped claim then just lets the tap select. */
+    private isYouAreHereAt;
+    /** The venue marker or building label drawn under `point`, as the point to
+     *  zoom in on, or `null`. */
+    private zoomTapTargetAt;
+    /** A venue marker or building label tap: zoom in on that symbol to the Kiosk view,
+     *  centered in the area the chrome leaves free (`boundsPadding`). Keeps the
+     *  current pitch and bearing. */
+    private zoomToKioskView;
+    /**
+     * Content-aware re-frame: fit an active route if one is displayed,
+     * otherwise fit the current floor's geojson. Unlike `resetView()`, this
+     * preserves the user's pitch and bearing — it only adjusts center/zoom
+     * to bring the scene back into view. Intended use is after the map
+     * container resizes (e.g. a side drawer opens beside the map and the
+     * pane gets narrower), so what matters stays framed without a yank.
+     */
+    refit(opts?: {
+        animate?: boolean;
+        duration?: number;
+    }): void;
+    /**
+     * Update the bounds padding (camera insets) used by route + floor fits.
+     * Consumers measure their on-screen chrome (panels, rails) and pass the
+     * insets so a fit frames the path in the visible, unobscured area rather
+     * than under the UI. Stored; the next fit / `refit()` uses it (clamped so
+     * a fit always lands — see `clampPadding`). While the camera still sits on
+     * the opening view, that view is re-framed with the new insets too (and
+     * becomes `resetView()`'s target) — the opening fit runs before a consumer
+     * can measure chrome that only mounts once the map is ready.
+     */
+    setBoundsPadding(p: BoundsPadding): void;
+    /** Whether the camera is still exactly on the opening view — no pan, zoom,
+     *  tilt or rotate since init (or since the last re-frame). */
+    private isAtOpeningView;
+    /** Redo the opening fit (the current floor's footprint, or the venue's
+     *  bounds without floor geometry) with the current bounds padding, then the
+     *  opening framing policy, and make the result the new `resetView()` target.
+     *  Z0 (`iconZoomBase`) is left as captured at init. */
+    private reframeOpeningView;
+    private fitToBounds;
     set3dEnabled(enabled: boolean): void;
     toggle3d(): void;
     getIs3dEnabled(): boolean;
+    /**
+     * (Re-)register per-amenity icons, per-destination logos, and the kiosk
+     * "you are here" icon. Needed both at init and after every `setTheme()`
+     * call — `map.setStyle(..., { diff: false })` tears down and recreates
+     * the whole `Style` object, which drops every image added at runtime via
+     * `map.addImage`. Only `route-arrow` re-registers itself lazily via
+     * `styleimagemissing`; everything else must be re-run explicitly here or
+     * it silently goes blank after a theme swap.
+     *
+     * `themeName === 'high-contrast'` recolors both the amenity badge disc
+     * and the connector (elevator/stairs/escalator) badge disc to
+     * `HIGH_CONTRAST_AMENITY_BADGE_COLOR`, and forces both the regular and
+     * connector glyph to `HIGH_CONTRAST_AMENITY_ICON_COLOR` so neither
+     * washes out against its now-yellow disc and the two match each other.
+     * Ring colors are left untouched. Failures per icon set are logged and
+     * skipped so one bad icon doesn't block the rest.
+     */
+    private registerRuntimeIcons;
+    /**
+     * 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(): ActiveThemeName;
+    /**
+     * Update the SDK's reduced-motion preference at runtime. When true, every
+     * imperative camera move (`setView`, `resetView`, `refit`, recenter, route
+     * fits, selection pans, floor fits) runs with `duration: 0`, and every
+     * looping animation the SDK drives — the route line-draw, the flowing route
+     * arrows, the "You are here" pulse, the selection ring's ping — is stopped.
+     *
+     * Anything already on screen is switched over here, not just on the next
+     * action: a visitor who flips the toggle mid-route is doing it *because* of
+     * the motion they can see, so waiting for the next event would be the one
+     * moment the preference doesn't work.
+     */
+    setReducedMotion(enabled: boolean): void;
+    getReducedMotion(): boolean;
+    /**
+     * Swap every map label (street names, POI names, building labels, "You are
+     * here") between the bundled themes' default font and OpenDyslexic. Mirrors
+     * the DOM-side dyslexic-font accommodation onto the canvas, which CSS can't
+     * reach.
+     *
+     * Goes through MapLibre's local-glyph fallback: `text-font` values are swapped to
+     * fontstack names intentionally absent from the glyph server
+     * (`OpenDyslexic Bold` etc.), so MapLibre rasterizes them from a
+     * page-loaded `@font-face` instead. The consuming app owns loading that
+     * font — the SDK ships no assets — so this is a no-op glyph-wise (labels
+     * fall back to tofu-free default rendering) if the app never declared it.
+     *
+     * Re-applied after `setTheme()`, since `setStyle({ diff: false })`
+     * recreates every layer from the pristine (non-dyslexic) theme JSON.
+     */
+    setDyslexicFont(enabled: boolean): Promise<void>;
+    getDyslexicFont(): boolean;
+    private applyDyslexicFontToLabels;
+    /**
+     * Scale every map label's `text-size` by `scale` (1 = theme default; the
+     * example kiosk passes 1.15 for its "large text" setting). Mirrors the
+     * DOM-side text-size accommodation onto the canvas, which CSS can't reach.
+     *
+     * Multiplies the output values inside each layer's `text-size` (MapLibre
+     * requires `zoom` to stay at the top of the expression, so it can't be
+     * 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;
+    private applyTextScaleToLabels;
+    /**
+     * Switch the locale used for POI / amenity / destination / floor names at
+     * runtime. The SDK refetches localized names from JACS (per-entity
+     * endpoints — `/all` does not honor `?locale=`), patches the in-memory
+     * venue model in place, then redraws the POI source for the current floor
+     * so map labels render in the new language.
+     *
+     * Structural data (waypoints, coordinates, iconIds) is preserved — only
+     * the localized fields (`name`, `description`) move.
+     *
+     * Emits a `localeChanged` event with the new code after the patch
+     * completes. No-op when the code matches the current locale.
+     *
+     * Throws only on programmer error — a provider without locale support
+     * (only `JacsDataProvider` has it today) or an empty code. A **failed
+     * JACS fetch is not fatal**: the locale still switches and is reported,
+     * it's only the localized names that stay on the prior language. That
+     * split is deliberate — generated directions text ships inside the SDK
+     * and must not be held hostage to a network round-trip.
+     */
+    setLocale(locale: string): Promise<void>;
+    /**
+     * Start fetching the localized names for `locale` in the background so a
+     * later `setLocale(locale)` only has the in-memory patch and redraw left to
+     * do. Call it once after `ready` for each alternate language the UI offers.
+     *
+     * Never throws and never changes the active locale or the map — a provider
+     * without locale support, an empty code or a failed fetch is a silent no-op
+     * (a failed fetch is retried when `setLocale` runs). Safe to call
+     * repeatedly; the fetch for a given code happens once.
+     */
+    prefetchLocale(locale: string): Promise<void>;
+    /**
+     * Whether newer data has been published since this venue loaded, for
+     * long-running displays (kiosks) that should pick up a publish. Snapshot
+     * mode only: it re-reads the venue's and customer's manifests and compares
+     * them with the versions in use; `{ status: 'unsupported' }` in live
+     * (`proxy`/`direct`) modes. A loaded venue never switches versions by
+     * itself — on `available`, reload (ideally while nobody is using the
+     * screen). Rejects when the manifests can't be fetched; try again later.
+     */
+    checkForUpdate(): Promise<SnapshotUpdateCheck | {
+        status: 'unsupported';
+    }>;
+    /** Currently active locale (BCP-47), or `undefined` when no locale has
+     *  been set — meaning JACS resolves names to the customer's default. */
+    getActiveLocale(): string | undefined;
     setUnits2dEnabled(enabled: boolean): void;
     toggleUnits2d(): void;
     getIsUnits2dEnabled(): boolean;
     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;
     getDestinations(floor?: Floor): Destination[];
+    getZones(): Zone[];
+    /** The department (zone) a POI belongs to, resolved via its waypoint's
+     *  `zoneId` — the only backend link between a location and a department
+     *  (see the zone landmine in the package CLAUDE.md). `null` when the POI
+     *  has no waypoint, no zone, or the zone id is unknown. */
+    getZoneForPOI(poi: POI): Zone | null;
+    /** Human-readable detail fields for a POI info popover. Only surfaces
+     *  fields that exist on the current data — `category`, `floorName`,
+     *  `zoneName`, `keywords`, `description`, and `imageUrl` are each omitted
+     *  when absent. Keeps the display-field derivation (incl. the zone lookup)
+     *  in the SDK so consumers stay thin. */
+    getPOIDetails(poi: POI): {
+        name: string;
+        type: 'amenity' | 'destination' | 'kiosk';
+        category?: string;
+        floorName?: string;
+        floorShortName?: string;
+        zoneName?: string;
+        zoneDescription?: string;
+        /** 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;
+        /** CMS-authored extras from the entity's `extensors` bag (opening hours,
+         *  days, room, building). Free-form — the consumer decides what to render.
+         *  Artwork is not in here; see `imageUrl`. */
+        properties?: Record<string, unknown>;
+        /** The destination's uploaded location image, ready for an `<img src>`.
+         *  Destinations only — amenities use sprite glyphs, not photos. Inline SVG
+         *  from `/all` comes back as a data URI; otherwise it's the uploaded uri
+         *  path. Absent when nothing was uploaded in the CMS. */
+        imageUrl?: string;
+        /** Author-written alt text for `imageUrl` (`mm_image_alt`) — a description
+         *  of the place, for screen readers and for anyone the image fails to load
+         *  for. Absent when the author wrote none, in which case the image is
+         *  decorative and belongs in an `<img alt="">`, not an unlabelled one. */
+        imageAlt?: string;
+        /** Room number — the CMS's "Room Number". Reads the real
+         *  `Destination.unitNumber` column, falling back to a legacy hand-typed
+         *  `room_number` property for venues authored before that field existed. */
+        roomNumber?: string;
+        /** Which building on the campus this destination is in (`mm_building_name`),
+         *  as the author typed it — "200", "Ambulatory Care". Free text, not a
+         *  reference to a `Building` record; render it, don't resolve it. Falls back
+         *  to the legacy hand-typed `building_name` property, which is unprefixed
+         *  and therefore a different key. */
+        buildingName?: string;
+        /** Phone number and internal extension (`mm_phone`). The number is exactly
+         *  as the author typed it, not normalised — see `parsePhone`. */
+        phone?: DestinationPhone;
+        /** The CMS-authored opening hours (`mm_open_hours`), parsed. Absent when
+         *  the author set none, or the stored value is unreadable.
+         *
+         *  Static — it describes the week, not this moment. Pass it to
+         *  `getOpenStatus()` for the live open/closed state, and re-call that on a
+         *  tick if the UI stays on screen. The raw string also remains in
+         *  `properties` for consumers that would rather parse it themselves. */
+        openHours?: OpenHours;
+    };
+    /** Resolve the source Destination/Amenity record backing a rendered POI,
+     *  for detail fields (category, localized description) that don't live on
+     *  the built POI object. */
+    private getSourceEntity;
     getPolygonLayers(): any[];
+    /**
+     * Cross-reference the venue's drawn layers against the customer's allowed
+     * layer list (JACS `GET /customer/{id}/polygon-layer`) and against what the
+     * active theme can actually render.
+     *
+     * Three failure modes, none of which is visible by looking at the map:
+     * a layer drawn under a name the CMS doesn't list (`unauthorized`), a layer
+     * legitimately drawn that no theme rule matches (`unstyled`), and a theme
+     * rule with nothing to draw at this venue (`unused`). Runs automatically
+     * once after `ready` when `options.debug` is on; call it directly —
+     * `mm.validateMapLayers()` — any time.
+     *
+     * Only counts floors whose geojson has loaded. Init preloads the rest in
+     * the background, so a call in the first moments after `ready` may report
+     * fewer `inData` types than a call a second later.
+     */
+    validateMapLayers(): Promise<LayerAudit>;
+    /** Debug-mode auto-run: log findings once, stay silent when clean. */
+    private reportLayerAudit;
     getFloorMapTemplate3d(floorId: string | number): any[];
     getAllPOIs(floor?: Floor): POI[];
+    /**
+     * Put the map on the kiosk's floor before drawing a route from it.
+     *
+     * **A route from the kiosk always starts on the kiosk's floor**, so that is
+     * the floor the visitor has to be looking at when it appears. The renderer
+     * agrees with that already — `wayfinding` reveals and frames *the active
+     * floor's* slice of the route — which is exactly why this matters: leave the
+     * map where the visitor had wandered to and the route arrives framed on the
+     * wrong leg, or on no leg at all.
+     *
+     * Both halves of that were reported from a real kiosk. Browse up to Level 3,
+     * search, press Directions: if Level 3 isn't on the route the fit falls back
+     * to the union of every floor and nothing reads as a path from here; if it
+     * *is* on the route — because the destination is up there — the visitor is
+     * looking at the last leg of a walk they haven't started, with no indication
+     * that the first one is two floors down.
+     *
+     * Called before the route is computed rather than after it's drawn, so the
+     * camera makes one move instead of fitting the wrong floor and correcting.
+     * No-op when the venue has no kiosk anchor (those routes fail anyway) or the
+     * map is already there.
+     */
+    private showKioskFloorForRoute;
+    /**
+     * The floor the kiosk is physically anchored to — not necessarily the
+     * floor currently displayed (the visitor may have panned the floor
+     * selector to preview a destination on another level, and the SDK opens
+     * on the venue's configured default floor rather than the kiosk's own —
+     * see `FloorManager.selectInitialFloor`). Anchor resolution (routing,
+     * recentering, closest-waypoint) must resolve against this floor, never
+     * `getCurrentFloor()`, or it silently misses the "you are here" POI
+     * whenever the two diverge. `null` when the venue has no kiosk anchor.
+     */
+    getKioskFloor(): Floor | null;
     getYouAreHerePOI(floor?: Floor): POI | null;
     getYouAreHereCoordinates(floor?: Floor): [number, number] | null;
+    /**
+     * Compass heading the kiosk's physical hardware faces, in degrees
+     * clockwise from north. Sourced from JACS `Device.heading`. `null` when
+     * the venue's device record has no heading set.
+     *
+     * In order to rotate the map so it is oriented towards the user's gaze,
+     * 180 is subtracted from `Device.heading`.
+     *
+     * Drives `recenterOnKiosk({ useHeading: true })` and the directional
+     * cone rendered next to the "You are here" marker.
+     */
+    getKioskHeading(): number | null;
+    /**
+     * Bearing (degrees clockwise from north) the visitor at the kiosk is
+     * FACING — the device heading rotated 180°, since they stand in front
+     * of the screen looking back at it. `null` when the device record
+     * carries no heading, in which case direction-relative wording ("turn
+     * right and walk 40 ft") is suppressed rather than guessed.
+     */
+    private getVisitorFacingBearing;
+    /**
+     * Display name of the JACS device the kiosk is anchored to (e.g.
+     * "Main Lobby Kiosk", "Information Desk Kiosk"). `null` when the venue
+     * has no kiosk anchor or the device record carries no `name`.
+     *
+     * Distinct from `getYouAreHerePOI()?.name`, which is always the
+     * literal "You are here" label rendered on the map. Use this for chrome
+     * that needs the kiosk's identity — e.g. the directions overlay's
+     * "From <kiosk>" header.
+     */
+    getKioskName(): string | null;
+    /**
+     * Distance + walking time from the kiosk's anchor waypoint to a target,
+     * computed over the JACS path graph (the same graph the routing engine
+     * uses). Designed for "Closest: 30 sec walk" subtitles in the consumer
+     * UI — no second graph build, no second Dijkstra implementation.
+     *
+     * Accepts a raw waypoint id, an amenity / destination object (the first
+     * entry of its `waypoints` array is treated as the entry point), or any
+     * `{ id, mapId? }` shape. Returns `null` when the kiosk isn't anchored,
+     * the target waypoint isn't on the graph, or no path resolves.
+     *
+     * Walking speed defaults to 2.953 ft/s (0.9 m/s, average adult walking speed —
+     * PMC2967707). Pass `walkingSpeedFps` to estimate for accessibility (e.g. 2).
+     *
+     * `feet` / `seconds` are the *physical* walk — horizontal legs only, what a
+     * visitor is shown. `effortSeconds` adds the router's charge for each floor
+     * change (the elevator wait) and is what to *rank* candidates by; see
+     * `findClosestByWalkTime`. Pass `avoidStairs` to price the path as a route
+     * with that option would be.
+     */
+    getWalkTimeFromKiosk(target: number | string | {
+        id?: number | string;
+        mapId?: number;
+    } | {
+        waypoints?: Array<number | string | {
+            id?: number | string;
+        }>;
+    }, opts?: {
+        walkingSpeedFps?: number;
+        avoidStairs?: boolean;
+    }): {
+        feet: number;
+        seconds: number;
+        effortSeconds: number;
+        pathNodeCount: number;
+    } | null;
+    /**
+     * Center the camera on the kiosk's "You are here" position. Use this
+     * (not `resetView`) for a chrome "Recenter" button — `resetView` snaps
+     * to the SDK's captured default camera, which may have been a venue
+     * overview rather than the kiosk's spot.
+     *
+     * When `useHeading` is true (default) and the kiosk device has a
+     * `heading` on file, the camera's bearing is rotated so the direction
+     * the kiosk physically faces ends up at the top of the screen. That
+     * way "what the user sees in front of them" matches "what's up on the
+     * map" — the single largest readability win for stressed indoor users.
+     */
+    recenterOnKiosk(opts?: {
+        useHeading?: boolean;
+        zoom?: number;
+        pitch?: number;
+        animate?: boolean;
+        duration?: number;
+    }): void;
+    /**
+     * Find the POI placed on a given waypoint, searching every floor. A
+     * waypoint is a single placement, so this resolves the exact amenity
+     * instance or destination a kiosk routed to — unlike an amenity id, which
+     * is shared by all of its instances. The kiosk's own "You are here" POI is
+     * skipped. Returns `null` when nothing is placed on that waypoint (stale id,
+     * or a floor whose geometry hasn't loaded).
+     */
+    getPOIByWaypointId(waypointId: string | number): POI | null;
     searchPOIs(query: string, floor?: Floor): POI[];
+    /**
+     * Search POIs across every floor in the venue. Returns raw matches —
+     * an amenity that exists on multiple floors appears multiple times,
+     * once per instance. Consumers that need one row per logical amenity
+     * should dedupe by id (and, for "nearest", pick the instance closest
+     * to the kiosk via planar distance on `coordinates`).
+     */
+    searchAllPOIs(query: string): POI[];
     wayfindBetweenWaypoints(fromWaypoint: any, toWaypoint: any, options?: {
         centerMode?: 'none' | 'destination' | 'route';
         zoom?: number;
+        /** Hard-filter stairs from the graph. */
+        avoidStairs?: boolean;
     }): Promise<any>;
     navigateFromKioskToDestination(destination: any): Promise<any>;
+    /**
+     * Route from the kiosk to a specific POI's waypoint. Use this when you
+     * already hold a resolved POI (e.g. from `searchPOIs` / `searchAllPOIs`).
+     * For a venue-wide amenity record with multiple instances, resolve via
+     * `findClosestWaypoint` first — or use `highlightAmenity` instead, if
+     * you want a visual focus rather than a route.
+     */
+    navigateFromKioskToPOI(poi: POI, options?: {
+        avoidStairs?: boolean;
+    }): Promise<any>;
+    /**
+     * 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. `navigateBetween` with POIs only.
+     */
+    navigateBetweenPOIs(from: POI, to: POI, options?: {
+        avoidStairs?: boolean;
+    }): Promise<any>;
+    /**
+     * 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.
+     */
+    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;
+    }): {
+        feet: number;
+        seconds: number;
+        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 (`navigateBetween`), which
+     *  gets a start pin; a kiosk route passes none — "You are here" marks it. */
+    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. */
+    /**
+     * Rewrite every source whose features carry venue-authored *text* for a
+     * floor: POI labels and map labels. Both read their names straight out of
+     * the venue model, so anything that mutates that model in place — today
+     * `setLocale`'s translation patch — has to call this or the map keeps
+     * rendering the old strings until the next floor change.
+     *
+     * Map labels ride the same lifecycle as POIs and carry the `allLevels`
+     * flag, which the projector has already honored by duplicating the
+     * 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:
+     *
+     * 1. When the step's `floorId` differs from the active floor, switch
+     *    floors so the segment for the step's leg becomes visible.
+     * 2. Highlight the step's slice of the route line by writing the
+     *    point range to the `route-active-step` source; the bundled
+     *    theme's `route-line-active` layer paints it in gold over the
+     *    muted base route.
+     *
+     * Transition steps (cross-floor elevator / stair hops) clear the line
+     * highlight — there's no meaningful on-floor segment to paint — and
+     * 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, opts?: {
+        fit?: 'step' | 'route';
+    }): Promise<void>;
+    /** The coordinates of `step`'s point range, for the camera to frame. */
+    private stepFocusFor;
+    private writeActiveStepHighlight;
+    private clearActiveStepHighlight;
+    private clearRouteConnectorHighlight;
+    /**
+     * Point `ROUTE_CONNECTOR_LAYER_ID`'s `icon-image` at the highlighted badge
+     * for the connector(s) the active transition step rides, and back at the
+     * plain `iconId` otherwise. Imperative like the layer's filter, so it's
+     * re-run from `updateRouteFloorFilter` after a theme swap drops it.
+     *
+     * `coalesce` over `image` falls back to the plain badge when the sprite has
+     * no `-highlighted` copy of an id (a custom CMS connector icon, or a sprite
+     * 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
+     * `start`, the route's start also gets the sprite's `marker-start` pin.
+     *
+     * A destination gets a flag in place of its dot; an amenity instance gets an
+     * enlarged copy of its own icon (`map/routeEnd.ts`). Both are drawn from a
+     * source of their own, so this never touches the POI layers — clearing the
+     * route empties the source and the ordinary dot / icon are what remain.
+     *
+     * The routed restroom is also kept out of restroom grouping while the marker
+     * is up; see `RestroomGroupManager.setExcludedKey`.
+     */
+    private setRouteEnd;
+    /**
+     * Highlight a single POI on the map — a pulsing ring — and bring it into
+     * view. Resolves the POI across all floors, switching the active floor if
+     * it lives on another one. Pass a POI / amenity / destination id.
+     */
+    highlightPOI(id: string | number): Promise<void>;
+    /**
+     * Select a POI programmatically — the same end state as tapping it on the
+     * map, from a list or any other chrome.
+     *
+     * Switches the active floor first when the POI lives on another one, raises
+     * its room as a highlighted block, mutes the neighbouring units, declutters
+     * to the selected destination(s), pans it into the unobscured map area and
+     * emits **`poiSelected`** carrying every co-located POI. A consumer that
+     * already renders an info card off that event therefore needs no second code
+     * path: a tap and a list pick arrive the same way.
+     *
+     * 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: 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
+     * physical pin) or a bare id.
+     *
+     * **`includeCoLocated: false` emits only the requested POI.** By default the
+     * payload carries everything sharing the room, which is right when the
+     * gesture was a tap — the visitor pointed at a place on a floor plan and the
+     * consumer has to show them what's there. It's wrong when they picked one
+     * entry out of a named list: they have already disambiguated, and handing
+     * back four places would ask them to do it again, on a card that opened
+     * *because* they were specific. The map treatment is identical either way
+     * (same room raised, same neighbours muted, same pan); only the payload —
+     * and so the declutter's allow-list — narrows.
+     *
+     * Returns the selected POIs, `pois[0]` being the requested one; an empty
+     * array if no POI matched, which is also when nothing on the map changes.
+     */
+    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;
+    /** Map a click's raw feature hits to the full, de-duplicated POIs at that
+     *  point (see `resolvePOIsFromFeatures`). Injected into `SelectionManager`.
+     *  `getAllPOIs()` is the current floor's rendered POIs — the only clickable
+     *  ones — and carries each POI's `waypoint`, needed for directions. */
+    private resolveClickedPOIs;
+    /** Emit `poiSelected` for the co-located POIs at a clicked point. Focuses the
+     *  selection in place (no recenter — the user already sees where they
+     *  tapped): rings the tapped dot and, when the tap landed in a room, raises
+     *  that room as a highlighted block so the eye goes to the selected unit.
+     *  `clearHighlight` removes both. `poi` mirrors `pois[0]` for single-POI
+     *  consumers. */
+    private emitPoiSelected;
+    /**
+     * Build the room-highlight payload for a selection. The colour comes from the
+     * *clicked* feature (the rendered truth), but the geometry comes from the
+     * floor's full source polygon — the clicked feature is from
+     * `queryRenderedFeatures`, whose geometry is clipped to on-screen tiles, so
+     * highlighting it directly would leave any off-screen part of the room grey
+     * (its base extrusion is muted). Falls back to the clipped geometry if the
+     * full polygon can't be found. Returns `null` for a pin with no room.
+     */
+    private unitHighlightFor;
+    /** The full, unclipped `Units` polygon on the current floor that contains
+     *  `coord`, straight from the floor source (not the tile-clipped render). */
+    private fullUnitPolygonAt;
+    /**
+     * Hide every destination marker except the given ids (pass `null` to
+     * restore all). Narrows each destination layer's own filter with an id
+     * allow-list; amenity/connector/"you are here" layers are untouched, so they
+     * stay on the map as reference. Captures the original filters once and puts
+     * them back verbatim, so the layers' base rules (poiType, showLabel, iconId)
+     * survive.
+     */
+    private setDestinationFocus;
+    /**
+     * Select every destination inside a tapped cluster bubble, so a consumer's
+     * multi-place card lists them — the same `poiSelected` a tap on stacked pins
+     * emits.
+     *
+     * Unlike `emitPoiSelected` this raises no room and narrows no markers. A
+     * cluster spans rooms, so there is no one unit to raise or dim around, and
+     * the destination focus would filter out the bubble that was just tapped
+     * (its features carry no `id`) and the members hidden inside it with it.
+     * Any earlier selection is cleared first, so a room left raised by the last
+     * tap doesn't outlive this one. `clearHighlight` afterwards is a harmless
+     * no-op for the consumer to call on dismiss.
+     *
+     * The leaves are read back from the cluster source (`getClusterLeaves`: a
+     * promise on MapLibre v5, a callback on v4 — `peerDependencies` allows both)
+     * and resolved against the floor's POIs, since a source feature only carries
+     * enough identity to look the full POI (with its waypoint) back up.
+     */
+    private selectCluster;
+    /** 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 — 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
+     *  captured originals are put back verbatim on deactivate. */
+    private setUnitFocusDim;
+    /**
+     * Show only the named POI categories on the map. Pass `['amenity']` to
+     * emphasize amenities (e.g. while an Amenities drawer is open) — destination
+     * POIs hide. Call `clearPOIFilter()` to restore the default (all categories).
+     *
+     * The "You are here" marker, the wheelchair-accessibility badge, and any
+     * active highlight are not affected and always render.
+     */
+    setPOIFilter(types: Array<'amenity' | 'destination'>): void;
+    /** Restore the default — every POI category renders. */
+    clearPOIFilter(): void;
+    /**
+     * Narrow the POI markers to a curated set: only POIs for which `match`
+     * returns true keep their icon and label, every other pin on the categorical
+     * marker layers (destinations, entrances, parking, bus, connectors,
+     * information, and the per-instance amenity names) is filtered out. Built for
+     * an attract loop that wants a few chosen places on screen instead of either
+     * every marker or none.
+     *
+     * `match` runs against the current floor's POIs — the same objects
+     * `getAllPOIs()` returns, `instanceName` and `amenityCategory` included — and
+     * is re-run on every floor change, theme swap and locale redraw, so the
+     * spotlight follows the map rather than the floor it was set on. Kiosk
+     * "You are here" is never touched.
+     *
+     * Two things it deliberately leaves alone:
+     * - `poi-other-amenity-icons` and the restroom badge. Their filters are owned
+     *   by the restroom-group manager and rewritten as the camera moves, so a
+     *   narrowing there would not survive a frame. Hide them with `hideLayers`
+     *   if the spotlight should exclude them.
+     * - `setPOIFilter`'s category visibility, which composes: a category the
+     *   filter hides stays hidden whatever `match` says.
+     *
+     * Selecting a place (`selectPOI`, a map tap) releases the spotlight. Pass
+     * `null` — or call `clearPOISpotlight()` — to restore every marker.
+     */
+    setPOISpotlight(match: ((poi: POI) => boolean) | null): void;
+    /** Re-apply the zoom profile if the idle spotlight or a route just changed
+     *  which one is in force, and refresh what hangs off it. */
+    private syncZoomViews;
+    /** Restore every POI marker narrowed by `setPOISpotlight`. */
+    clearPOISpotlight(): void;
+    private applyPOISpotlight;
+    private applyPOIFilter;
+    /**
+     * Show or hide destination dots, independently of their name labels and of
+     * `setPOIFilter`'s combined `'destination'` category (which still toggles
+     * both together). Affects every destination dot — both the dot+label
+     * marker on `poi-destination-labels` and the dot-only fallback on
+     * `poi-destination-circles` that a `showLabel: false` POI renders on.
+     *
+     * Implemented as `icon-opacity`, not a layer swap: dot and label are
+     * placed as one collision unit on `poi-destination-labels` (`icon-optional:
+     * false` / `text-optional: true`), which is what guarantees a label never
+     * renders without a dot beneath it. Splitting them into independently
+     * *placed* layers would let MapLibre's collision index resolve each half
+     * on its own, so a label could win placement while its dot lost — the
+     * "floating name" bug this theme's combined layer was built to fix (see
+     * `themes.test.ts` :: "a destination is one marker").
+     */
+    setDestinationCirclesVisible(visible: boolean): void;
+    /**
+     * Show or hide destination name labels, independently of their dots. See
+     * `setDestinationCirclesVisible` for why this is an opacity toggle on the
+     * shared marker layer rather than a separate label layer.
+     *
+     * `visible: true` (the default) doesn't mean "always on" — labels still
+     * fade in only once the visitor has zoomed in past the venue's opening
+     * view (`DESTINATION_LABEL_REVEAL_OFFSET` in `iconZoomRanges.ts`), so a
+     * zoomed-out visitor sees dots without the screen filling with names. Pass
+     * `false` to suppress labels outright regardless of zoom.
+     */
+    setDestinationLabelsVisible(visible: boolean): void;
+    private applyDestinationDisplay;
+    /**
+     * Return the waypoint in `waypoints` closest to `from`. Useful for
+     * "route to the nearest X" against a venue-wide amenity record that has
+     * multiple physical instances. Defaults `from` to the kiosk's
+     * "You are here" coordinates.
+     *
+     * Distance is planar Euclidean on lng/lat — sufficient for ordering at
+     * single-venue scale, and avoids a turf dependency on the hot path.
+     */
+    findClosestWaypoint(waypoints: Waypoint[], from?: [number, number]): Waypoint | null;
+    /**
+     * Pick the candidate cheapest to reach from the kiosk — the one rule for
+     * "closest instance of an amenity". `navigateFromKioskToClosestAmenity` and
+     * `highlightAmenity` use it, and a consumer collapsing a venue-wide amenity
+     * to a single search row should too, so a tap and a search result can never
+     * resolve the same amenity to different floors.
+     *
+     * Each candidate is scored by `getWalkTimeFromKiosk().effortSeconds` — walk
+     * time over the JACS path graph **plus the elevator wait** for any floor
+     * change — and a candidate on a *different floor* from the kiosk has that
+     * score multiplied by `options.otherFloorPenalty` (default `1.5`; `1`
+     * disables it). The wait is the physical cost of leaving the floor; the
+     * multiplier is a preference for not making the visitor do it, and only
+     * applies here — it never changes a route.
+     *
+     * `toWaypoint` maps a candidate to the waypoint it stands for (identity for
+     * a `Waypoint[]`, `poi => poi.waypoint` for a `POI[]`). Candidates whose
+     * waypoint is missing or has no coordinates are ignored, as are waypoints
+     * the graph can't reach from the kiosk. If none resolve a cost, falls back
+     * to the planar `findClosestWaypoint`, **restricted to the kiosk's floor
+     * when any candidate is on it** (planar distance is meaningless across
+     * overlaid floors). Returns `null` for no usable candidate. Pass the same
+     * `avoidStairs` the route will use so the pick and the route agree.
+     */
+    findClosestByWalkTime<T>(items: readonly T[], toWaypoint: (item: T) => Waypoint | null | undefined, opts?: {
+        avoidStairs?: boolean;
+    }): T | null;
+    /**
+     * Route from the kiosk to the closest physical instance of an amenity.
+     * Resolves the amenity venue-wide, picks the instance with the smallest
+     * path-graph cost from the kiosk (`findClosestByWalkTime`: walk time plus
+     * the elevator wait, with a preference for the kiosk's floor; falling back
+     * to planar Euclidean when the walk-time graph can't resolve any waypoint), switches the
+     * active floor if needed, and routes via the same plumbing as
+     * `navigateFromKioskToPOI` — so step-by-step directions, the
+     * `routeReady` event, and the active-floor camera fit all "just work."
+     *
+     * Pass `avoidStairs` to hard-filter stairs from the *route* (the SDK's
+     * routing engine reads it per call; the CMS's per-path-type weight
+     * otherwise handles accessibility preference automatically). The same
+     * flag is passed to the closest-instance pick, so an instance reachable
+     * only by stairs is skipped in favour of one the route can actually reach.
+     */
+    navigateFromKioskToClosestAmenity(amenityId: string | number, options?: {
+        avoidStairs?: boolean;
+    }): Promise<any>;
+    /**
+     * Highlight + center on the closest physical instance of an amenity.
+     * The amenity is resolved against `amenities.getDistinct()` (venue-wide,
+     * deduped); the closest waypoint to the kiosk is picked; the active floor
+     * is switched if that instance lives on another one.
+     *
+     * This is the right call from a venue-wide list ("here are all the
+     * bathrooms in the building, take me to the closest one"). For taps on
+     * a specific resolved POI (e.g. a search result that already names one
+     * instance), use `highlightPOI` instead.
+     */
+    highlightAmenity(amenityId: string | number): Promise<void>;
+    /** Which floor owns this waypoint, by matching mapId against the floor's
+     *  `mapId` (or `id` as fallback). Used to switch floors when routing /
+     *  highlighting hits an instance on a different one. */
+    private findFloorForWaypoint;
     getCameraPosition(): CameraState | null;
     getMap(): Map | null;
+    /**
+     * Hide one or more layers by id — a public, always-live counterpart to
+     * `debug.hide()` for consumers that want to toggle arbitrary layers
+     * without reaching into the console-facing debug API. Sticky: the
+     * override is re-asserted across floor changes, `setPOIFilter`, view-mode
+     * toggles and theme swaps until `showLayers` undoes it. Ids absent from
+     * the active style are skipped silently. Returns the ids actually found
+     * and hidden.
+     */
+    hideLayers(layerIds: string[]): string[];
+    /**
+     * Undo `hideLayers` for these ids. Each layer returns to whatever
+     * visibility the SDK's own state — current floor, POI filter, view mode —
+     * says it should have; it is **not** forced to `visible`. A layer the SDK
+     * is independently keeping hidden (another floor's layers, an
+     * off-view-mode extrusion) stays hidden rather than being force-revealed.
+     * This is the correct inverse of `hideLayers` (mirrors `debug.restore()` —
+     * see `debugLayers.ts` for why a blanket "show" is usually the wrong
+     * undo). Returns the ids that actually had an override to release.
+     */
+    showLayers(layerIds: string[]): string[];
+    /**
+     * Whether a layer is currently rendering (`visibility !== 'none'`).
+     * `false` for a layer absent from the active style.
+     */
+    isLayerVisible(layerId: string): boolean;
+    /**
+     * Put this instance on `window` so a kiosk running in a browser can be
+     * driven from devtools — `mm.debug.help()`, `mm.getMap()`, `mm.setTheme(…)`.
+     * Debug builds only: nothing is exposed unless `options.debug` is on, and
+     * `options.debugGlobal` renames the key (or `false` opts out entirely).
+     *
+     * Refuses to clobber a key that already holds something that isn't a
+     * MinuteMaps — a kiosk shell with its own `window.mm` shouldn't lose it to
+     * a dev-mode convenience.
+     */
+    private exposeDebugGlobal;
+    /** Drop the `window` handle, but only if it still points at this instance. */
+    private releaseDebugGlobal;
     destroy(): void;
     setCurrentFloor(floor: Floor): Promise<void>;
+    /**
+     * Filter the route-line / route-halo layers to only render segments
+     * whose `floorId` matches the active floor (or features that carry no
+     * `floorId` at all — the straight-line fallback, which we want visible
+     * on every floor since it has no floor membership to filter against).
+     *
+     * Features are tagged with the JACS pixel `mapId` (that's what flows
+     * through the route point's `mapId`), so the filter compares against
+     * the active floor's `mapId`, NOT its `id` — those are two different
+     * JACS identifiers (`floor.id` is the building-floor record; `mapId`
+     * is the SVG asset). We accept the floor's `id` here for convenience
+     * and resolve to `mapId` via `getFloors()`.
+     *
+     * Applied imperatively rather than baked into the theme JSON so the
+     * filter tracks runtime floor changes without restyling the map.
+     */
+    private updateRouteFloorFilter;
     isReady(): boolean;
     private setFloorLayerVisibility;
     private getBoundsPadding;
+    /**
+     * Shrink per-side padding if the requested insets would leave no room.
+     * `cameraForBounds` / `fitBounds` silently fail ("Map cannot fit within
+     * canvas") when an axis's total padding meets or exceeds that axis — cap
+     * each axis's total at 80% so a fit always has space to land.
+     */
+    private clampPadding;
     private getVenueBounds;
+    /**
+     * The polygon `options.hideBasemapPoisNearVenue` hides basemap POIs inside:
+     * the venue's bounds padded outward. `null` when disabled or before the
+     * venue loads.
+     */
+    private getBasemapPoiMask;
+    /**
+     * Resolve `options.maxBounds` into the actual pan/zoom-out cap. `false`
+     * disables it, explicit bounds pass through as-is, and a number (or the
+     * unset default of 3) scales the venue's own bounds outward around its
+     * center — see `scaleBounds`.
+     *
+     * The unset default is also floored at `DEFAULT_MIN_MAX_BOUNDS_SPAN_M` per
+     * side. MapLibre won't zoom out past the point where `maxBounds` fills the
+     * viewport, so a small venue's 3x box would otherwise raise the effective
+     * zoom-out floor above `minZoom` and show far less surrounding map than a
+     * large venue does. An explicit number is a deliberate leash and is left as-is.
+     */
+    private getMaxBounds;
+    /**
+     * Opening-framing policy applied once after the initial floor fit.
+     *  - `initialPitch`: tilt to this and re-fit the building footprint so the
+     *    kiosk opens on a tilted building instead of a flat top-down plan.
+     *  - `minZoomBelowInitialFit`: clamp the map's minZoom to
+     *    `(fitZoom − margin)` so visitors can't pull back to the empty region.
+     * Both are no-ops when their option is unset.
+     */
+    private applyInitialFraming;
     private applyInitialViewFromVenue;
     private loadAndPatchVenueStyle;
     private ensureFloorLayersFromStyle;
@@ -296,5 +2901,204 @@ declare class MinuteMaps {
 }
 declare function createMinuteMapsSDK(config: SDKConfig): MinuteMaps;
 
-export { MinuteMaps, createMinuteMapsSDK };
-export type { Amenity, AmenityWithFloor, Bounds, CameraState, Destination, EventCallback, Floor, FloorMetadata, JMapAuth, JMapConfig, JacsAuth, JacsConfig, MapEvent, POI, POISearchResult, SDKConfig, SDKOptions, ViewOptions, WayfindCenterMode, Waypoint };
+/** Where a `VenueDirectory` reads from: live JACS (`proxy`/`direct`, which
+ *  reads `/customer/all`) or published snapshots (`snapshot`, which reads
+ *  `directory.json` — published venues only). */
+type VenueDirectoryConfig = JacsProviderConfig | ({
+    mode: 'snapshot';
+} & SnapshotProviderConfig);
+/** The slice of `/customer/all`'s `customer` object a client acts on. Audit
+ *  fields, quotas and SSO config are dropped on purpose. */
+type Customer = {
+    id: number | string;
+    name: string;
+    /** `null` when JACS has no localized name; use {@link customerDisplayName}. */
+    localizedName: string | null;
+    /** Environment/partition the customer lives in; test customers carry a
+     *  different one, which is what the `tenantId` filter keys on. */
+    tenantId: number | null;
+    uuid: string | null;
+    /** BCP-47 code of `defaultLocale.locale`. */
+    defaultLocale: string | null;
+};
+/** A venue as listed under a customer — a summary, not the loaded venue model. */
+type VenueSummary = {
+    id: number | string;
+    customerId: number | string;
+    name: string;
+    /** South-west corner (`bottomLng`, `bottomLat`); `null` if JACS omitted coordinates. */
+    southWest: [number, number] | null;
+    /** North-east corner (`topLng`, `topLat`). */
+    northEast: [number, number] | null;
+    /** JACS's `status` flag. Not filtered here — a picker decides whether to hide
+     *  `false` (unpublished) venues. */
+    status: boolean;
+    locked: boolean;
+    uuid: string | null;
+    /** JACS's `externalId`; `null` when the venue has none. */
+    externalId: string | null;
+    /** JACS `extensors` — free-form per-venue key/values (`GO_LIVE`, `MOBILE_APP`,
+     *  `KIOSK_LOCATIONS`, analytics ids, …). Values are the raw strings JACS sends
+     *  (`KIOSK_LOCATIONS` is a JSON-encoded string); non-scalar values are dropped. */
+    extensors: Record<string, string>;
+    /** UUID of the venue's default map template; `null` when not set. */
+    defaultMapTemplateId: string | null;
+    /** JACS `labelType` enum value; `null` if omitted. */
+    labelType: number | null;
+    /** Whether the venue's map uses marker clustering. */
+    clustering: boolean;
+    /** Whether JACS publishes the venue's edits automatically. */
+    autoPublish: boolean;
+    /** The venue's street address (its first building's `address`); `null` when
+     *  blank or unknown. Only snapshot directories carry it — `/customer/all`
+     *  has no buildings — so it is always `null` in `proxy`/`direct` mode. Same
+     *  value `MinuteMaps.getVenueAddress()` returns once the venue loads. */
+    address: string | null;
+    /** The venue's description, as with `address`. Matches
+     *  `MinuteMaps.getVenueDescription()`. */
+    description: string | null;
+    /** Whether the venue has a map to open: `false` when the publisher listed it
+     *  with no building, floors or uploaded floor maps, so a picker can show it
+     *  without loading it. `null` when the source doesn't say — always in
+     *  `proxy`/`direct` mode, and in snapshots published before the field. */
+    mapped: boolean | null;
+};
+/** One entry of `/customer/all`: a customer and the venues it owns. Hand a
+ *  venue's `customerId` and `id` to the SDK's `jacs`/`venue` config to load it. */
+type CustomerVenues = {
+    customer: Customer;
+    venues: VenueSummary[];
+};
+type ListCustomerVenuesOptions = {
+    /** Keep only customers with this `tenantId`, so test customers living in
+     *  other tenants are left out. A customer with no `tenantId` never matches.
+     *  Omit to return every customer the proxy exposes. */
+    tenantId?: number;
+};
+/** `customer.localizedName` when non-blank, else `customer.name`. */
+declare function customerDisplayName(customer: Customer): string;
+/**
+ * Lists the customers and venues a user can pick from — the data behind a
+ * "select your hospital" screen. Unlike the `MinuteMaps` class this isn't
+ * bound to a venue: it runs *before* one is chosen.
+ *
+ * Accepts JACS config (proxy or direct), snapshot config, or an existing
+ * `JacsProvider` / `SnapshotProvider`.
+ */
+declare class VenueDirectory {
+    private jacs;
+    constructor(config: VenueDirectoryConfig | JacsReader);
+    /** `/customer/all`, optionally narrowed to one `tenantId`. */
+    listCustomerVenues(options?: ListCustomerVenuesOptions): Promise<CustomerVenues[]>;
+}
+
+type TransitionStep = Extract<WayfindStep, {
+    type: 'transition';
+}>;
+type RouteFloorSection = {
+    /** Floor (JACS `mapId`) this section is on. `null` only for a degenerate
+     *  floorless route (straight-line fallback with no `mapId`). */
+    floorId: number | null;
+    /** This floor's steps, each with its index into the original flat array
+     *  so the consumer can call `setActiveStep` / highlight by index. */
+    steps: Array<{
+        step: WayfindStep;
+        index: number;
+    }>;
+    /** Index of this section's first step in the original array — the target
+     *  for `setActiveStep` when advancing INTO this section. */
+    firstStepIndex: number;
+    /** The transition step that leaves this floor for the next section, if
+     *  any. Absent on the final section. Its `text` ("Take the elevator to
+     *  Basement") makes a good "continue" button label. */
+    exit?: {
+        step: TransitionStep;
+        index: number;
+    };
+};
+/**
+ * Group steps into per-floor sections. Single-floor routes return one
+ * section (so a consumer can keep its whole-route view for that case).
+ */
+declare function groupStepsIntoFloorSections(steps: WayfindStep[]): RouteFloorSection[];
+/**
+ * Which section is "active" given the active step index — the last section
+ * whose `firstStepIndex` is at or before `activeStepIndex`. Returns 0 when
+ * nothing matches (e.g. index points at the leading transition, which
+ * shouldn't happen since routes start with a depart step).
+ */
+declare function activeSectionIndex(sections: RouteFloorSection[], activeStepIndex: number): number;
+
+/** True when an amenity is a vertical-circulation connector. The provider
+ *  stamps `_connector` on every synthetic elevator / stairs / escalator, which
+ *  is the reliable signal — `extensors.iconName` is only the *display* glyph
+ *  and may be any CMS-assigned icon (we still honour it as a fallback for
+ *  amenities authored with a connector icon name directly). */
+declare function isConnectorAmenity(amenity: AmenityLike): boolean;
+type LocaleField = {
+    locale?: string;
+    uriPath?: string;
+};
+type UriField = {
+    mimeType?: string;
+    resourceType?: string;
+    locales?: LocaleField[];
+};
+type AmenityLike = {
+    id: number | string;
+    iconId?: string;
+    uris?: UriField[] | null;
+    /** Inline SVG markup. Used by the SDK for synthetic connector
+     *  amenities (elevator / stairs / escalator) where the CMS has no
+     *  uploaded icon to fetch. When set, this short-circuits the
+     *  `uris[].locales[].uriPath` lookup. */
+    svg?: string;
+    /** Free-form CMS metadata. When `extensors.iconName` names a curated
+     *  Material Symbols icon, the SDK renders it from the bundled registry
+     *  (no upload, no network) — see `pickMaterialSvg`. */
+    extensors?: Record<string, unknown> | null;
+    /** Set by the JACS provider on synthetic vertical-circulation amenities
+     *  (elevator / stairs / escalator built from path types). The reliable
+     *  connector signal — `extensors.iconName` is the *display* glyph, which
+     *  may be any CMS-assigned icon, not the connector kind. */
+    _connector?: boolean;
+};
+type ResolvedIconSource = {
+    /** Map image id to register/reference. Shared across amenities for
+     *  connectors (preset) and curated Material icons (`material-<name>`). */
+    iconId: string;
+    /** Source for `composeAmenityBitmap` — exactly one of url / inlineSvg. */
+    source: {
+        url?: string;
+        inlineSvg?: string;
+    };
+    /**
+     * Where the artwork came from. The map doesn't care — it rasterises all
+     * three the same way — but a DOM consumer must, because provenance decides
+     * both trust and styling:
+     *
+     * - `material` — from the SDK's bundled registry. Ours, so it's safe to
+     *   inline into the DOM, and safe to recolour (it's a monochrome glyph).
+     * - `inline` — an `svg` string off the CMS record. **Author-supplied
+     *   markup**: an inline `<svg>` can carry `<script>`, so render it through
+     *   an `<img src="data:…">` (which never executes script), not
+     *   `dangerouslySetInnerHTML`.
+     * - `upload` — a URL to a CMS-uploaded file. Also author-supplied, also an
+     *   `<img>`; and it arrives in whatever colours the author chose, so don't
+     *   assume you can tint it to match a badge.
+     */
+    kind: 'material' | 'inline' | 'upload';
+};
+/**
+ * Pure icon-source resolution by precedence — no map/DOM side effects, so it's
+ * unit-testable:
+ *   1. inline svg          — explicit inline-SVG override (rare)
+ *   2. extensors.iconName  — curated Material icon (bundled, shared bitmap);
+ *                            also how synthetic connectors render now
+ *   3. uris[].uriPath      — legacy / custom-uploaded SVG (fetched)
+ * Returns null when the amenity has no resolvable icon.
+ */
+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, 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 };