@minmaps-dev/mm-web-sdk 1.0.0-rc.33 → 1.0.0-rc.35

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import { IControl, ControlPosition, StyleSpecification, Map } from 'maplibre-gl';
+import { Map, IControl, ControlPosition, StyleSpecification } from 'maplibre-gl';
 
 /**
  * Represents a floor in a building
@@ -14,6 +14,10 @@ interface Floor {
     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 */
@@ -29,6 +33,7 @@ interface Floor {
 interface FloorMetadata {
     id: string | number;
     name: string;
+    shortName?: string;
     sequence?: number;
     isDefault?: boolean;
     isActive?: boolean;
@@ -51,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 */
@@ -98,6 +114,17 @@ interface Amenity {
     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>;
 }
@@ -113,22 +140,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>;
-    /** Uploaded image (e.g. brand/store logo). JACS `/all` fullcall serves this
-     *  as `{ items: [{ resourceType, mimeType, path }] }`; the legacy/basic shape
-     *  is `[{ locales: [{ uriPath }] }]`. `DestinationIcons.register` handles both. */
+    /** 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;
-    /** Free-form CMS metadata (reserved for future destination icon options). */
+    /** 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>;
-    /** Map-manager "Label Display" mode (JACS `displayMode`):
-     *  `0` Hidden (dot only) · `1` Label (dot + text) · `2` Image (uploaded logo).
-     *  Undefined → treated as Label (backwards-compatible default). */
+    /** @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;
-    /** Runtime-assigned map-image id, decorated in place by
-     *  `DestinationIcons.register` (only for `displayMode === 2`).
-     *  Read by the POI builder + theme layer. */
-    iconId?: string;
 }
 /**
  * Waypoint - a specific point location
@@ -206,17 +245,16 @@ type WayfindCenterMode = 'none' | 'destination' | 'route';
 /**
  * Per-call routing preferences forwarded to the wayfinding provider.
  *
- * - `accessible` — prefer accessible paths; providers should drop or heavily
- *   penalize edges marked inaccessible (stairs by default, anything else
- *   the provider's data flags).
- * - `avoidStairs` — hard-filter stairs from the graph.
+ * - `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 these
- * flags when building edge weights.
+ * provider (see `mm-web-sdk-example/lib/wayfinding`) that reads this
+ * flag when building edge weights.
  */
 type RoutingOptions = {
-    accessible?: boolean;
     avoidStairs?: boolean;
 };
 
@@ -254,13 +292,18 @@ type StepBase = {
     floorId: number | null;
     /** Localized instruction text. */
     text: string;
-    /** Total walking distance within this step, in meters (rounded). */
-    distanceMeters?: number;
+    /** 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';
@@ -339,16 +382,16 @@ type AmenityBadgeStyle = {
     /** Ring width in logical px. Default `2`. */
     ringWidth?: number;
 };
-type DestinationChipStyle = {
-    /** Chip fill colour. Default `'#FFFFFF'`. */
-    color?: string;
-    /** Chip border colour. Default navy `'#162e51'`. */
-    borderColor?: string;
-    /** Chip border width in logical px. Default `2`. */
-    borderWidth?: number;
-};
 interface SDKOptions {
     debug?: boolean;
+    /**
+     * `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. Pass a
@@ -375,6 +418,20 @@ interface SDKOptions {
      * controls the automatic highlight on `routeReady`.
      */
     routeStepHighlight?: boolean;
+    /**
+     * 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;
@@ -387,6 +444,16 @@ interface SDKOptions {
      */
     wallThickness?: 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. 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;
     /**
      * Pitch (deg) for the opening view, applied centred on the kiosk ("You
      * are here"). Omit for top-down.
@@ -438,13 +505,20 @@ interface SDKOptions {
      */
     connectorBadge?: AmenityBadgeStyle | false;
     /**
-     * Chip composited behind each destination's uploaded logo. Destinations are
-     * full-colour brand images (not recoloured), so they get a neutral white
-     * rounded chip for legibility instead of the amenity gold badge. Pass `false`
-     * to render the logo bare, or an object to tune the chip fill / border.
-     * Defaults to a white chip with a 2px navy border.
+     * 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).
      */
-    destinationChip?: DestinationChipStyle | false;
+    informationIconColor?: string;
     styleMode?: 'venueStyleUrl' | 'sdkTemplate';
     templateOverrideMode?: 'colorsOnly' | 'colorsAndConstants' | 'all';
 }
@@ -497,6 +571,230 @@ type SDKConfig = {
     options?: SDKOptions;
 };
 
+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 = {
     getVenue: () => any;
@@ -520,8 +818,13 @@ declare class AmenityManager {
      * 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 (a CMS data bug)
-     * into a single entry so React lists don't trip on dup keys.
+     * 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.
@@ -533,6 +836,175 @@ declare class AmenityManager {
     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 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.
+ */
+declare function getOpenStatus(hours: OpenHours, now?: Date, options?: OpenStatusOptions): OpenStatus;
+
 declare class MinuteMaps {
     private config;
     private map;
@@ -559,22 +1031,45 @@ declare class MinuteMaps {
     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 `applyRelativeIconZoomRanges` so icon/label reveal thresholds
+     *  are relative to this venue's own opening view rather than an absolute
+     *  MapLibre zoom — re-applied after every `setTheme()` swap too, since
+     *  `setStyle({ diff: false })` recreates layers from the pristine theme. */
+    private iconZoomBase;
     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;
     /** 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 lastRouteDestinationPoi;
     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;
@@ -586,6 +1081,15 @@ declare class MinuteMaps {
      *  *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;
+    /** 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;
     private youAreHerePulse;
     /** Theme layers whose features represent a tappable destination/amenity.
      *  A click hit-tests these (see `SelectionManager`) → `poiSelected`. The
@@ -599,6 +1103,15 @@ declare class MinuteMaps {
      *  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
@@ -616,10 +1129,9 @@ declare class MinuteMaps {
      *  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-*`, the
-     *  `poi-accessibility-icons` badge, and the `poi-highlight-*` layers —
-     *  are intentionally unaffected; they're either anchors, status
-     *  indicators, or transient focus state, not categorical content. */
+     *  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;
     private poiVisibleTypes;
     constructor(config: SDKConfig);
@@ -647,6 +1159,16 @@ declare class MinuteMaps {
     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;
@@ -676,6 +1198,24 @@ declare class MinuteMaps {
     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'`) or by
      * passing a custom `StyleSpecification`. The current floor, route, POIs
@@ -688,12 +1228,39 @@ declare class MinuteMaps {
     /** Currently active theme name (or `'custom'` when a raw style was passed). */
     getActiveTheme(): 'default' | 'high-contrast' | 'custom';
     /**
-     * Update the SDK's reduced-motion preference at runtime. When true,
-     * imperative camera animations (route fits, idle re-frames) and the
-     * route line-draw animation run with `duration: 0`.
+     * 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 the same local-glyph fallback the themes already use for
+     * `Material Icons` (`LOCAL_GLYPH_FONTS`): `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;
     /**
      * Switch the locale used for POI / amenity / destination / floor names at
      * runtime. The SDK refetches localized names from JACS (per-entity
@@ -707,9 +1274,12 @@ declare class MinuteMaps {
      * Emits a `localeChanged` event with the new code after the patch
      * completes. No-op when the code matches the current locale.
      *
-     * Throws if the underlying data provider doesn't implement locale support
-     * (only `JacsDataProvider` does today), or if the JACS fetch fails — the
-     * prior locale is left intact in that case.
+     * 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>;
     /** Currently active locale (BCP-47), or `undefined` when no locale has
@@ -733,26 +1303,122 @@ declare class MinuteMaps {
     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`, and `description` are each omitted when absent.
-     *  Keeps the display-field derivation (incl. the zone lookup) in the SDK
-     *  so consumers stay thin. */
+     *  `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 department's authored hex colour (`Zone.color`) — the same value
+         *  that tints this room's polygon on the map, so a consumer can print a
+         *  swatch beside the department name and connect the two. Absent when the
+         *  author never picked one, which is also when the map leaves the room
+         *  untinted; treat "no colour" as "this department isn't colour-coded",
+         *  not as "fall back to a default swatch". */
+        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;
     /**
@@ -767,6 +1433,14 @@ declare class MinuteMaps {
      * 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
@@ -837,8 +1511,6 @@ declare class MinuteMaps {
     wayfindBetweenWaypoints(fromWaypoint: any, toWaypoint: any, options?: {
         centerMode?: 'none' | 'destination' | 'route';
         zoom?: number;
-        /** Prefer accessible paths (drops or penalizes stairs / inaccessible edges). */
-        accessible?: boolean;
         /** Hard-filter stairs from the graph. */
         avoidStairs?: boolean;
     }): Promise<any>;
@@ -851,12 +1523,23 @@ declare class MinuteMaps {
      * you want a visual focus rather than a route.
      */
     navigateFromKioskToPOI(poi: POI, options?: {
-        accessible?: boolean;
         avoidStairs?: boolean;
     }): Promise<any>;
     /** 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;
     private buildDirectionsContext;
     /**
      * Drive the turn-by-turn UI. Two effects:
@@ -885,6 +1568,42 @@ declare class MinuteMaps {
      * 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: current zoom kept, no ring, the
+     * raised room is the indicator.
+     *
+     * 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[]>;
     /** 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;
@@ -962,17 +1681,17 @@ declare class MinuteMaps {
      * `navigateFromKioskToPOI` — so step-by-step directions, the
      * `routeReady` event, and the active-floor camera fit all "just work."
      *
-     * Pass `accessible` / `avoidStairs` to weight the *route* (the SDK's
-     * routing engine reads these per call). Note: closest-instance picking
-     * itself is currently distance-based and does not yet honor those
-     * weights — the underlying walk-time graph applies pixel-length only.
-     * In practice this matters when an amenity has multiple instances and
-     * the geometrically closest is reachable only via stairs; the picked
-     * instance won't change today, but the *route* to it will avoid stairs
-     * (or fail gracefully) if `accessible`/`avoidStairs` is set.
+     * 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). Note:
+     * closest-instance picking itself is currently distance-based and does
+     * not honor `avoidStairs` — the underlying walk-time graph applies
+     * pixel-length only. In practice this matters when an amenity has
+     * multiple instances and the geometrically closest is reachable only
+     * via stairs; the picked instance won't change today, but the *route*
+     * to it will avoid stairs (or fail gracefully) if `avoidStairs` is set.
      */
     navigateFromKioskToClosestAmenity(amenityId: string | number, options?: {
-        accessible?: boolean;
         avoidStairs?: boolean;
     }): Promise<any>;
     /**
@@ -993,6 +1712,19 @@ declare class MinuteMaps {
     private findFloorForWaypoint;
     getCameraPosition(): CameraState | null;
     getMap(): Map | null;
+    /**
+     * 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>;
     /**
@@ -1023,6 +1755,13 @@ declare class MinuteMaps {
      */
     private clampPadding;
     private getVenueBounds;
+    /**
+     * 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`.
+     */
+    private getMaxBounds;
     /**
      * Opening-framing policy applied once after the initial floor fit.
      *  - `initialPitch`: tilt to this and re-fit the building footprint so the
@@ -1076,5 +1815,76 @@ declare function groupStepsIntoFloorSections(steps: WayfindStep[]): RouteFloorSe
  */
 declare function activeSectionIndex(sections: RouteFloorSection[], activeStepIndex: number): number;
 
-export { MinuteMaps, activeSectionIndex, createMinuteMapsSDK, groupStepsIntoFloorSections };
-export type { Amenity, AmenityBadgeStyle, AmenityWithFloor, Bounds, BoundsPadding, CameraState, Destination, DestinationChipStyle, EventCallback, Floor, FloorMetadata, JMapAuth, JMapConfig, JacsAuth, JacsConfig, MapEvent, POI, POISearchResult, RouteFloorSection, RoutePoint, RoutingOptions, SDKConfig, SDKOptions, ThemeName, TransitionStep, ViewOptions, WayfindCenterMode, WayfindStep, Waypoint, Zone };
+/** 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, activeSectionIndex, createMinuteMapsSDK, getOpenStatus, groupStepsIntoFloorSections, isConnectorAmenity, parseBuildingName, parseImageAlt, parseOpenHours, parsePhone, parsePointOfInterest, resolveAmenityIconSource };
+export type { Amenity, AmenityBadgeStyle, AmenityWithFloor, Bounds, BoundsPadding, CameraState, DayKey, Destination, DestinationPhone, EventCallback, Floor, FloorMetadata, HoursRange, JMapAuth, JMapConfig, JacsAuth, JacsConfig, MapEvent, OpenHours, OpenHoursTransition, OpenStatus, OpenStatusOptions, POI, POISearchResult, ResolvedIconSource, RouteFloorSection, RoutePoint, RoutingOptions, SDKConfig, SDKOptions, ThemeName, TransitionStep, ViewOptions, WayfindCenterMode, WayfindStep, Waypoint, Zone };