@mapvx/web-js 3.5.0-dev.1 → 3.5.0-dev.3

package/dist/umd/index.js

@@ -11249,7 +11249,7 @@ const extractSafariExtensionDetails = (func, filename) => {
 // exists only for the type-checker, so in the ES/CJS builds the identifier is
 // genuinely absent and a direct comparison throws ReferenceError at module load.
 // `typeof` is the only safe way to probe a possibly-undeclared global.
-var sentry_SDK_VERSION =  false ? 0 : "3.5.0-dev.1";
+var sentry_SDK_VERSION =  false ? 0 : "3.5.0-dev.3";
 var DSN =  false ? 0 : "https://872f598f020e3cd73a0933b562d24c81@sentry.mapvx.app/5";
 
 /**
@@ -11888,14 +11888,17 @@ function getBoundingBox(points) {
 function marker_typeof(o) { "@babel/helpers - typeof"; return marker_typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, marker_typeof(o); }
 function marker_ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
 function marker_objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? marker_ownKeys(Object(t), !0).forEach(function (r) { marker_defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : marker_ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
-function marker_defineProperty(e, r, t) { return (r = marker_toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
 function _callSuper(t, o, e) { return o = _getPrototypeOf(o), _possibleConstructorReturn(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], _getPrototypeOf(t).constructor) : o.apply(t, e)); }
 function _possibleConstructorReturn(t, e) { if (e && ("object" == marker_typeof(e) || "function" == typeof e)) return e; if (void 0 !== e) throw new TypeError("Derived constructors may only return object or undefined"); return _assertThisInitialized(t); }
 function _assertThisInitialized(e) { if (void 0 === e) throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); return e; }
 function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }
+function _superPropGet(t, o, e, r) { var p = _get(_getPrototypeOf(1 & r ? t.prototype : t), o, e); return 2 & r && "function" == typeof p ? function (t) { return p.apply(e, t); } : p; }
+function _get() { return _get = "undefined" != typeof Reflect && Reflect.get ? Reflect.get.bind() : function (e, t, r) { var p = _superPropBase(e, t); if (p) { var n = Object.getOwnPropertyDescriptor(p, t); return n.get ? n.get.call(arguments.length < 3 ? e : r) : n.value; } }, _get.apply(null, arguments); }
+function _superPropBase(t, o) { for (; !{}.hasOwnProperty.call(t, o) && null !== (t = _getPrototypeOf(t));); return t; }
 function _getPrototypeOf(t) { return _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function (t) { return t.__proto__ || Object.getPrototypeOf(t); }, _getPrototypeOf(t); }
 function _inherits(t, e) { if ("function" != typeof e && null !== e) throw new TypeError("Super expression must either be null or a function"); t.prototype = Object.create(e && e.prototype, { constructor: { value: t, writable: !0, configurable: !0 } }), Object.defineProperty(t, "prototype", { writable: !1 }), e && _setPrototypeOf(t, e); }
 function _setPrototypeOf(t, e) { return _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function (t, e) { return t.__proto__ = e, t; }, _setPrototypeOf(t, e); }
+function marker_defineProperty(e, r, t) { return (r = marker_toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
 function marker_classCallCheck(a, n) { if (!(a instanceof n)) throw new TypeError("Cannot call a class as a function"); }
 function marker_defineProperties(e, r) { for (var t = 0; t < r.length; t++) { var o = r[t]; o.enumerable = o.enumerable || !1, o.configurable = !0, "value" in o && (o.writable = !0), Object.defineProperty(e, marker_toPropertyKey(o.key), o); } }
 function marker_createClass(e, r, t) { return r && marker_defineProperties(e.prototype, r), t && marker_defineProperties(e, t), Object.defineProperty(e, "prototype", { writable: !1 }), e; }
@@ -12248,21 +12251,6 @@ var MarkerUtils = /*#__PURE__*/function () {
  * ```
  */
 var MarkerAttribute = /*#__PURE__*/function (_Marker) {
-  /**
-   * Unique identifier for the marker attribute.
-   * Used for marker management and identification.
-   */
-
-  /**
-   * Geographic coordinates of the marker attribute.
-   * @see {@link LatLng} for coordinate structure
-   */
-
-  /**
-   * Identifier of the floor where the marker attribute is located.
-   * Used for indoor navigation and floor-specific marker management.
-   */
-
   /**
    * Resolved icon dimensions (defaults to {@link DEFAULT_ICON_SIZE_PX} square
    * when unspecified), matching whatever `MarkerUtils.createMarkerElement`
@@ -12338,6 +12326,33 @@ var MarkerAttribute = /*#__PURE__*/function (_Marker) {
       anchor: (_markerConfig$anchor = markerConfig.anchor) !== null && _markerConfig$anchor !== void 0 ? _markerConfig$anchor : "center",
       offset: [0, 0]
     }]);
+    /**
+     * Unique identifier for the marker attribute.
+     * Used for marker management and identification.
+     */
+    /**
+     * Geographic coordinates of the marker attribute.
+     * @see {@link LatLng} for coordinate structure
+     */
+    /**
+     * Identifier of the floor where the marker attribute is located.
+     * Used for indoor navigation and floor-specific marker management.
+     */
+    /**
+     * True while this marker is hidden on purpose, via {@link hide} (or {@link changeFloor}
+     * resolving to a floor this marker is not on).
+     *
+     * DOM connectivity cannot answer this: {@link hide} works by calling maplibre's
+     * `Marker.remove()`, which detaches the element, so a hidden marker and one that never got
+     * attached look identical from `getElement().isConnected`. Anything that re-attaches a marker
+     * it does not own — the route animation re-attaches its arrow when a step transition drops it —
+     * has to consult this flag, or it silently un-hides the marker on its next frame.
+     *
+     * Any attach clears it — see the {@link addTo} override — so "attached" and "not hidden"
+     * never disagree, whichever entry point put the marker back on the map.
+     * @internal
+     */
+    marker_defineProperty(_this, "hiddenOnPurpose", false);
     _this.setLngLat([markerConfig.coordinate.lng, markerConfig.coordinate.lat]);
     _this.setRotationAlignment((_markerConfig$rotatio = markerConfig.rotationAlignment) !== null && _markerConfig$rotatio !== void 0 ? _markerConfig$rotatio : "viewport");
     _this.setPitchAlignment("viewport");
@@ -12499,6 +12514,7 @@ var MarkerAttribute = /*#__PURE__*/function (_Marker) {
   }, {
     key: "hide",
     value: function hide() {
+      this.hiddenOnPurpose = true;
       this.remove();
     }
 
@@ -12519,6 +12535,24 @@ var MarkerAttribute = /*#__PURE__*/function (_Marker) {
       this.addTo(map);
     }
 
+    /**
+     * Attaches the marker, clearing {@link hiddenOnPurpose}.
+     *
+     * Overridden so every attach path agrees on visibility: {@link show}, {@link addToMap} and a
+     * direct `addTo` all funnel through here, so a marker cannot end up on the map while still
+     * flagged as deliberately hidden — which would make the route animation refuse to restore an
+     * arrow that is in fact visible.
+     *
+     * @param map - The map instance to attach the marker to.
+     * @returns This marker, for chaining, as maplibre's `Marker.addTo` does.
+     */
+  }, {
+    key: "addTo",
+    value: function addTo(map) {
+      this.hiddenOnPurpose = false;
+      return _superPropGet(MarkerAttribute, "addTo", this, 3)([map]);
+    }
+
     /**
      * Hides marker if currentFloor is different from the marker floor.
      * Used for floor-based marker visibility management.
@@ -13280,6 +13314,32 @@ var DEFAULT_AUTO_FIT_PADDING = {
   left: 150
 };
 
+/**
+ * Longest gap between two frames, in milliseconds, that still counts as
+ * animation time.
+ *
+ * The frame loop charges the marker for however much wall clock has elapsed,
+ * which is what makes a step take `stepTime` at any frame rate. A gap larger
+ * than any frame rate can explain is not slow rendering, though — it is time
+ * the animation did not run at all. `requestAnimationFrame` does not fire in a
+ * backgrounded tab, so the first frame after the page comes back carries the
+ * entire absence, and charging it advanced the draw by the whole gap: one
+ * frame 10 s late at 50 m/s consumed exactly a hundred vertices in a single
+ * `setData`, with the camera following the line as it jumped.
+ *
+ * Such a gap is therefore not charged (see `animateStep`). This is deliberately
+ * NOT a clamp on how far one frame may advance: clamping would cap the catch-up
+ * and hand back the frame-rate independence this loop exists to provide, and it
+ * would still be wrong — the marker would sprint to catch up through time
+ * nobody watched. Skipping the gap instead is what a pause does, which is what
+ * an absence is.
+ *
+ * 500 ms is two frames per second. Real rendering does not sustain anything
+ * near that low, so the threshold only ever separates absence from rendering,
+ * and never shortens the catch-up of a genuinely slow frame.
+ */
+var MAX_FRAME_GAP_MS = 500;
+
 /**
  * Represents the controller for routes on the map.
  * Supports multiple simultaneous routes with independent customizations,
@@ -13310,12 +13370,18 @@ var RouteController = /*#__PURE__*/function () {
 
     /**
      * Add MapLibre sources and layers for a single route instance.
+     *
+     * All three sources set `lineMetrics`: maplibre computes `line-progress` only
+     * when a source asks it to, and `preparePaintForLayer` emits a
+     * `line-progress` gradient for a GradientStyle. Without it, a consumer
+     * setting a gradient route style silently got no gradient at all.
      */
   }, {
     key: "addSourcesAndLayersForRoute",
     value: function addSourcesAndLayersForRoute(instance) {
       this.map.addSource(instance.aheadId, {
         type: "geojson",
+        lineMetrics: true,
         data: instance.aheadSourceData
       });
       this.map.addLayer({
@@ -13329,6 +13395,7 @@ var RouteController = /*#__PURE__*/function () {
       });
       this.map.addSource(instance.behindId, {
         type: "geojson",
+        lineMetrics: true,
         data: instance.behindSourceData
       });
       this.map.addLayer({
@@ -13342,6 +13409,7 @@ var RouteController = /*#__PURE__*/function () {
       });
       this.map.addSource(instance.currentId, {
         type: "geojson",
+        lineMetrics: true,
         data: instance.currentSourceData
       });
       this.map.addLayer({
@@ -13701,9 +13769,12 @@ var RouteController = /*#__PURE__*/function () {
     value: function updateLayerFilter(layerId, floorId) {
       var newFloorId = floorId !== null && floorId !== void 0 ? floorId : this.mapvxMap.getCurrentFloor();
       if (newFloorId === undefined) return;
-      if (this.map.getStyle().layers.some(function (layer) {
-        return layer.id === layerId;
-      })) {
+      // `getLayer` is a map lookup; `getStyle()` serialises every source and
+      // layer in the style just to answer the same question. This runs three
+      // times per route per floor change, and each preceding `setFilter`
+      // invalidates maplibre's serialised-layer cache, so the later calls used to
+      // re-serialise from scratch.
+      if (this.map.getLayer(layerId) != null) {
         this.map.setFilter(layerId, ["==", ["get", "floor_key"], newFloorId]);
       }
     }
@@ -13822,13 +13893,20 @@ var RouteController = /*#__PURE__*/function () {
   }, {
     key: "updateRouteMarkerVisibility",
     value: function updateRouteMarkerVisibility(floorId) {
+      // An outdoor step gives its marker an empty floorId, which never equals a
+      // real floor key — so on a venue with buildings the route arrow used to be
+      // hidden the moment the map filtered by one, and only reappeared because
+      // the animation re-attached the marker on its next frame. Outdoors is an
+      // allowance markers and circles already make; the route arrow makes it too.
+      var isOutdoor = this.mapvxMap.isOutdoorFloor(floorId);
       var _iterator7 = routeController_createForOfIteratorHelper(this.routes.values()),
         _step7;
       try {
         for (_iterator7.s(); !(_step7 = _iterator7.n()).done;) {
-          var _instance$routeMarker, _instance$routeMarker2, _instance$routeMarker3;
+          var _instance$routeMarker, _instance$routeMarker2, _instance$routeMarker3, _instance$routeMarker4;
           var instance = _step7.value;
-          ((_instance$routeMarker = instance.routeMarker) === null || _instance$routeMarker === void 0 ? void 0 : _instance$routeMarker.floorId) === floorId ? (_instance$routeMarker2 = instance.routeMarker) === null || _instance$routeMarker2 === void 0 ? void 0 : _instance$routeMarker2.show(this.map) : (_instance$routeMarker3 = instance.routeMarker) === null || _instance$routeMarker3 === void 0 ? void 0 : _instance$routeMarker3.hide();
+          var markerFloorId = (_instance$routeMarker = (_instance$routeMarker2 = instance.routeMarker) === null || _instance$routeMarker2 === void 0 ? void 0 : _instance$routeMarker2.floorId) !== null && _instance$routeMarker !== void 0 ? _instance$routeMarker : "";
+          markerFloorId === floorId || isOutdoor && markerFloorId === "" ? (_instance$routeMarker3 = instance.routeMarker) === null || _instance$routeMarker3 === void 0 ? void 0 : _instance$routeMarker3.show(this.map) : (_instance$routeMarker4 = instance.routeMarker) === null || _instance$routeMarker4 === void 0 ? void 0 : _instance$routeMarker4.hide();
         }
       } catch (err) {
         _iterator7.e(err);
@@ -13840,10 +13918,10 @@ var RouteController = /*#__PURE__*/function () {
     key: "updatePlaceFloorForRouting",
     value: function updatePlaceFloorForRouting(instance, placeId, floorKey) {
       if (placeId && floorKey) {
-        var _instance$routeMarker4;
+        var _instance$routeMarker5;
         this.mapvxMap.updatePlaceAndFloorForRouting(placeId, floorKey);
         this.updateRouteLayers(floorKey);
-        (_instance$routeMarker4 = instance.routeMarker) === null || _instance$routeMarker4 === void 0 || _instance$routeMarker4.setFloor(floorKey);
+        (_instance$routeMarker5 = instance.routeMarker) === null || _instance$routeMarker5 === void 0 || _instance$routeMarker5.setFloor(floorKey);
         this.updateRouteMarkerVisibility(floorKey);
       }
     }
@@ -13858,8 +13936,8 @@ var RouteController = /*#__PURE__*/function () {
     key: "startAnimating",
     value: function startAnimating(route, drawConfig, animationConfig) {
       var _animationConfig$auto,
-        _animationConfig$call,
-        _this2 = this;
+        _this2 = this,
+        _animationConfig$call;
       var instance = createRouteInstance(route);
       this.routes.set(instance.id, instance);
       this.lastAddedRouteId = instance.id;
@@ -13897,10 +13975,13 @@ var RouteController = /*#__PURE__*/function () {
           this.mapvxMap.fitRouteByPlace(route, firstStep.startInsidePlace, fitOptions);
         }
       }
-      (_animationConfig$call = animationConfig.callBack) === null || _animationConfig$call === void 0 || _animationConfig$call.call(animationConfig, {
-        isFinished: false,
-        step: firstStep
-      });
+
+      // The conditions go in before the consumer hears about the start, for the same reason
+      // `restartAnimation` orders it that way. `animationStatus` is already "STARTED" here, so a
+      // consumer that pauses from inside this callback — showing a modal per step, say — passed
+      // `internalPause`'s status guard and then died on its `instance.conditions == null` check:
+      // the pause was dropped in silence, the loop kept running, and because the status stayed
+      // "STARTED" the matching `resumeAnimation()` bailed out too.
       instance.conditions = {
         index: 0,
         coordinatesIndex: 0,
@@ -13917,13 +13998,17 @@ var RouteController = /*#__PURE__*/function () {
           return _this2.prepareForNextStep(time, instance);
         }
       };
+      (_animationConfig$call = animationConfig.callBack) === null || _animationConfig$call === void 0 || _animationConfig$call.call(animationConfig, {
+        isFinished: false,
+        step: firstStep
+      });
       this.syncRouteCollision();
     }
   }, {
     key: "clearRouteInstance",
     value: function clearRouteInstance(instance) {
-      var _instance$routeMarker5;
-      (_instance$routeMarker5 = instance.routeMarker) === null || _instance$routeMarker5 === void 0 || _instance$routeMarker5.remove();
+      var _instance$routeMarker6;
+      (_instance$routeMarker6 = instance.routeMarker) === null || _instance$routeMarker6 === void 0 || _instance$routeMarker6.remove();
       instance.routeMarker = undefined;
       this.setSourceData(instance, instance.aheadId, []);
       this.setSourceData(instance, instance.behindId, []);
@@ -14046,9 +14131,9 @@ var RouteController = /*#__PURE__*/function () {
     value: function restartAnimation(routeId) {
       var _this$setMarkerRotati,
         _instance$animationCo,
+        _this4 = this,
         _instance$animationCo3,
-        _instance$animationCo4,
-        _this4 = this;
+        _instance$animationCo4;
       var instance = this.resolveInstance(routeId);
       if (!instance) {
         throw new Error("Does not exist animated route to restart");
@@ -14086,10 +14171,15 @@ var RouteController = /*#__PURE__*/function () {
           this.mapvxMap.fitRouteByPlace(instance.route, firstStep.startInsidePlace, fitOptions);
         }
       }
-      (_instance$animationCo3 = (_instance$animationCo4 = instance.animationConfig).callBack) === null || _instance$animationCo3 === void 0 || _instance$animationCo3.call(_instance$animationCo4, {
-        isFinished: false,
-        step: firstStep
-      });
+
+      // The new conditions go in before the consumer hears about the restart.
+      // Invoking the callback first left `instance.conditions` pointing at the
+      // previous run, so a consumer that pauses from inside it — showing a modal
+      // per step, say — cancelled a frame id that had already fired, marked the
+      // instance PAUSED, and then had a live loop installed underneath it. The
+      // next resume passed the "not paused" guard and started a second loop on
+      // the same instance; each schedules its own successor, so the doubling was
+      // permanent.
       instance.conditions = {
         index: 0,
         coordinatesIndex: 0,
@@ -14106,6 +14196,10 @@ var RouteController = /*#__PURE__*/function () {
           return _this4.prepareForNextStep(time, instance);
         }
       };
+      (_instance$animationCo3 = (_instance$animationCo4 = instance.animationConfig).callBack) === null || _instance$animationCo3 === void 0 || _instance$animationCo3.call(_instance$animationCo4, {
+        isFinished: false,
+        step: firstStep
+      });
     }
 
     /**
@@ -14134,8 +14228,8 @@ var RouteController = /*#__PURE__*/function () {
     key: "addStepAnimation",
     value: function addStepAnimation(route, drawConfig, animationConfig) {
       var _animationConfig$auto3,
-        _animationConfig$call2,
-        _this5 = this;
+        _this5 = this,
+        _animationConfig$call4;
       var instance = createRouteInstance(route);
       this.routes.set(instance.id, instance);
       this.lastAddedRouteId = instance.id;
@@ -14171,10 +14265,12 @@ var RouteController = /*#__PURE__*/function () {
           this.mapvxMap.fitRouteByPlace(route, firstStep.startInsidePlace, fitOptions);
         }
       }
-      (_animationConfig$call2 = animationConfig.callBack) === null || _animationConfig$call2 === void 0 || _animationConfig$call2.call(animationConfig, {
-        isFinished: false,
-        step: firstStep
-      });
+
+      // The conditions go in before the consumer hears about the route, as they
+      // do in `startAnimating`. Invoking the callback first left `conditions`
+      // undefined, so a consumer advancing the route from it — the step-by-step
+      // integration draws its first step this way — hit `nextStepAnimation`'s
+      // null check and got an exception instead of a step.
       instance.conditions = {
         index: 0,
         coordinatesIndex: 0,
@@ -14199,8 +14295,16 @@ var RouteController = /*#__PURE__*/function () {
           _this5.setSourceData(instance, instance.aheadId, aheadSteps);
           _this5.setCurrentSourceData(instance, step);
           instance.conditions.index = index;
+
+          // The status settles before either callback, as everywhere else: no frame
+          // is live once `animateStep` hands over to `onFinish`, so "WAITING" is
+          // already true here. Writing it afterwards overwrote the "ANIMATING" of a
+          // consumer that chained the next step from this callback, and the
+          // following `nextStepAnimation` then skipped its cancel and installed a
+          // second self-sustaining loop on the same instance.
+          instance.stepAnimationStatus = "WAITING";
           if (index < route.steps.length) {
-            var _animationConfig$auto5, _animationConfig$call3;
+            var _animationConfig$auto5, _animationConfig$call2;
             var nextStep = route.steps[index];
 
             // Auto-fit by place if enabled and place changed
@@ -14215,20 +14319,23 @@ var RouteController = /*#__PURE__*/function () {
                 _this5.mapvxMap.fitRouteByPlace(instance.route, stepPlaceId, _fitOptions);
               }
             }
-            (_animationConfig$call3 = animationConfig.callBack) === null || _animationConfig$call3 === void 0 || _animationConfig$call3.call(animationConfig, {
+            (_animationConfig$call2 = animationConfig.callBack) === null || _animationConfig$call2 === void 0 || _animationConfig$call2.call(animationConfig, {
               isFinished: false,
               step: nextStep
             });
           } else {
-            var _animationConfig$call4;
-            (_animationConfig$call4 = animationConfig.callBack) === null || _animationConfig$call4 === void 0 || _animationConfig$call4.call(animationConfig, {
+            var _animationConfig$call3;
+            (_animationConfig$call3 = animationConfig.callBack) === null || _animationConfig$call3 === void 0 || _animationConfig$call3.call(animationConfig, {
               isFinished: true,
               step: null
             });
           }
-          instance.stepAnimationStatus = "WAITING";
         }
       };
+      (_animationConfig$call4 = animationConfig.callBack) === null || _animationConfig$call4 === void 0 || _animationConfig$call4.call(animationConfig, {
+        isFinished: false,
+        step: firstStep
+      });
       this.syncRouteCollision();
     }
 
@@ -14347,7 +14454,7 @@ var RouteController = /*#__PURE__*/function () {
   }, {
     key: "centerOnCurrentStep",
     value: function centerOnCurrentStep(routeId) {
-      var _instance$routeMarker6;
+      var _instance$routeMarker7;
       var instance = this.resolveInstance(routeId);
       if (!instance) {
         throw new Error("Error: Does not exist step animation");
@@ -14358,7 +14465,7 @@ var RouteController = /*#__PURE__*/function () {
       if (instance.conditions == null || instance.animationConfig == null || instance.route == null) {
         throw new Error("Error: conditions, animationConfig or route should not be null at this point");
       }
-      var currentMarkerPosition = (_instance$routeMarker6 = instance.routeMarker) === null || _instance$routeMarker6 === void 0 ? void 0 : _instance$routeMarker6.getLngLat();
+      var currentMarkerPosition = (_instance$routeMarker7 = instance.routeMarker) === null || _instance$routeMarker7 === void 0 ? void 0 : _instance$routeMarker7.getLngLat();
       if (currentMarkerPosition) {
         this.map.panTo(currentMarkerPosition);
       } else {
@@ -14413,12 +14520,19 @@ var RouteController = /*#__PURE__*/function () {
         });
       } else {
         var _instance$animationCo11, _instance$animationCo12;
-        // finishes animation
+        // The status settles before the consumer hears that the route finished,
+        // for the same reason `startAnimating` and `restartAnimation` order it
+        // that way. A consumer that relaunches from this callback — looping a
+        // kiosk demo is the ordinary case — got its fresh "STARTED" overwritten
+        // by the "FINISHED" written afterwards, and was left with a live loop the
+        // controller believed was over: `pauseAnimation` and `stopAnimation` both
+        // bailed on the status guard, and the next `restartAnimation` skipped its
+        // cancel and installed a second self-sustaining loop.
+        instance.animationStatus = "FINISHED";
         (_instance$animationCo11 = (_instance$animationCo12 = instance.animationConfig).callBack) === null || _instance$animationCo11 === void 0 || _instance$animationCo11.call(_instance$animationCo12, {
           isFinished: true,
           step: null
         });
-        instance.animationStatus = "FINISHED";
       }
     }
   }, {
@@ -14431,19 +14545,25 @@ var RouteController = /*#__PURE__*/function () {
       var _instance$conditions = instance.conditions,
         startTime = _instance$conditions.startTime,
         resetTime = _instance$conditions.resetTime,
-        progress = _instance$conditions.progress;
+        progress = _instance$conditions.progress,
+        waitStartTime = _instance$conditions.waitStartTime;
       var _instance$conditions2 = instance.conditions,
         coordinatesIndex = _instance$conditions2.coordinatesIndex,
         iconRotation = _instance$conditions2.iconRotation,
         index = _instance$conditions2.index,
         onFinish = _instance$conditions2.onFinish,
-        rotatingIcon = _instance$conditions2.rotatingIcon,
-        waitStartTime = _instance$conditions2.waitStartTime;
+        rotatingIcon = _instance$conditions2.rotatingIcon;
       var _instance$animationCo13 = instance.animationConfig,
         stepTime = _instance$animationCo13.stepTime,
         minimumSpeed = _instance$animationCo13.minimumSpeed,
         iconRotationTime = _instance$animationCo13.iconRotationTime,
         changeFloorTime = _instance$animationCo13.changeFloorTime;
+
+      // How long this frame took to arrive. Recorded before any early return, so
+      // the next frame measures from the last one delivered rather than from the
+      // last one that drew.
+      var previousFrameTime = instance.conditions.lastFrameTime;
+      instance.conditions.lastFrameTime = timestamp;
       if (startTime == null) {
         instance.conditions.startTime = timestamp;
         instance.conditions.animationId = requestAnimationFrame(function (time) {
@@ -14456,10 +14576,35 @@ var RouteController = /*#__PURE__*/function () {
         instance.conditions.startTime = startTime;
         resetTime = false;
         instance.conditions.resetTime = resetTime;
+      } else if (previousFrameTime != null && timestamp - previousFrameTime > MAX_FRAME_GAP_MS) {
+        // Absence, not slow rendering: see MAX_FRAME_GAP_MS. Shift the clock
+        // forward by the gap instead of charging it, exactly as resuming from a
+        // pause does above, so this frame redraws where the last one left off
+        // and the next resumes from there.
+        var gap = timestamp - previousFrameTime;
+        // What the previous frame had charged. Equal to `progress` whenever the
+        // two are in step, but the rotation branches above set `startTime` to
+        // the frame timestamp without resetting `progress`, so reading the
+        // stored value would carry a whole rotation's worth of time into the
+        // first frame back. Recomputed instead, which is 0 in exactly that case.
+        progress = previousFrameTime - startTime;
+        instance.conditions.progress = progress;
+        startTime = timestamp - progress;
+        instance.conditions.startTime = startTime;
+        // The floor-change wait runs on the raw timestamp rather than on
+        // `progress`, so it needs the same shift or an absence would satisfy it
+        // outright.
+        if (waitStartTime != null) {
+          waitStartTime += gap;
+          instance.conditions.waitStartTime = waitStartTime;
+        }
       } else {
         progress = timestamp - startTime;
         instance.conditions.progress = progress;
       }
+
+      // Not const: the segment loop below rewinds it as it charges the clock for
+      // each segment it consumes within the frame.
       var progressInSeconds = progress / 1000;
       var step = instance.route.steps[index];
       if (step.coordinates.length <= 0) {
@@ -14469,7 +14614,6 @@ var RouteController = /*#__PURE__*/function () {
       var start = step.coordinates[coordinatesIndex];
       var end = step.coordinates[coordinatesIndex + 1];
       if (start != null && end != null) {
-        var _instance$routeMarker8;
         if (rotatingIcon) {
           var angle = NavFunctions.bearingInDegBetween(start, end);
           if (iconRotationTime === 0 || instance.conditions.nextFloorFirstStepIndex === index || Math.abs(angle - instance.conditions.iconRotation) < 15) {
@@ -14521,43 +14665,101 @@ var RouteController = /*#__PURE__*/function () {
             return;
           }
         }
-        var distance = NavFunctions.distance(start, end);
         var speed = Math.max(step.distance / stepTime, minimumSpeed !== null && minimumSpeed !== void 0 ? minimumSpeed : 0);
-        if (speed * progressInSeconds > distance) {
-          instance.currentSourceData.geometry.coordinates.push([end.lng, end.lat]);
-          var _source = this.map.getSource(instance.currentId);
-          _source === null || _source === void 0 || _source.setData(instance.currentSourceData);
-          if (coordinatesIndex + 2 < step.coordinates.length) {
-            var next = step.coordinates[coordinatesIndex + 2];
-            if (!compareLatLng(end, next)) {
-              if (instance.conditions.isStepByStep) {
-                instance.conditions.rotatingIcon = true;
-              } else {
-                var _instance$routeMarker7;
-                var nextAngle = NavFunctions.bearingInDegBetween(end, next);
-                instance.conditions.iconRotation = nextAngle;
-                (_instance$routeMarker7 = instance.routeMarker) === null || _instance$routeMarker7 === void 0 || _instance$routeMarker7.setRotation(nextAngle);
-              }
-            }
-            instance.conditions.startTime = timestamp;
-            instance.conditions.progress = 0;
-            instance.conditions.coordinatesIndex++;
-            instance.conditions.animationId = requestAnimationFrame(function (time) {
-              return _this8.animateStep(time, instance);
-            });
-            return;
-          } else {
+
+        // Consume every whole segment the elapsed time pays for inside this one
+        // frame, carrying the sub-segment remainder into the next.
+        //
+        // Advancing a single vertex per frame — and restarting the clock at each
+        // one, which threw the overshoot away — made a step's duration depend on
+        // the frame rate: it cost `stepTime` plus up to one frame per vertex,
+        // and once `speed * frameInterval` exceeded a segment's length it
+        // ignored `stepTime` altogether and collapsed to `vertexCount / fps`.
+        // Encoded polylines quantise near 1.1 m, so that regime was the common
+        // one, not the corner case.
+        var segmentStart = start;
+        var segmentEnd = end;
+        var segmentDistance = NavFunctions.distance(segmentStart, segmentEnd);
+
+        // Drop the previous frame's interpolated tip before committing anything.
+        // Coordinates up to and including the current vertex are settled geometry
+        // — exactly `coordinatesIndex + 1` of them — and the tip is a single
+        // moving point after them, re-placed at the end of this frame. Appending
+        // one per frame instead grew the drawn line with elapsed frames, well
+        // past the polyline's own vertex count, and `setData` re-indexed every
+        // one of those points on the next frame.
+        var coordinates = instance.currentSourceData.geometry.coordinates;
+        coordinates.length = Math.min(coordinates.length, instance.conditions.coordinatesIndex + 1);
+        while (speed * progressInSeconds > segmentDistance) {
+          coordinates.push([segmentEnd.lng, segmentEnd.lat]);
+          if (instance.conditions.coordinatesIndex + 2 >= step.coordinates.length) {
+            this.flushCurrentSourceData(instance);
             onFinish === null || onFinish === void 0 || onFinish(timestamp);
             return;
           }
+
+          // Charge the clock exactly what this segment cost instead of
+          // restarting it, so no time is lost at a vertex.
+          var segmentMs = segmentDistance / speed * 1000;
+          startTime += segmentMs;
+          progress -= segmentMs;
+          instance.conditions.startTime = startTime;
+          instance.conditions.progress = progress;
+          progressInSeconds = progress / 1000;
+          instance.conditions.coordinatesIndex++;
+          var next = step.coordinates[instance.conditions.coordinatesIndex + 1];
+          if (!compareLatLng(segmentEnd, next)) {
+            var _instance$routeMarker8;
+            if (instance.conditions.isStepByStep) {
+              // Step-by-step mode animates the turn itself, on the rotation
+              // branch of the next frame. Stop consuming segments and let it.
+              //
+              // The clock restarts here because the rotation branch measures its
+              // own progress from `startTime`, and every other transition into it
+              // resets too (see `prepareForNextStep` and the floor-change hand-off).
+              // Carrying this frame's leftover sub-segment time over instead
+              // started the turn already part-way through — or skipped it outright
+              // once the remainder exceeded `iconRotationTime`. Before the segment
+              // loop existed the per-vertex path reset it as well.
+              instance.conditions.rotatingIcon = true;
+              instance.conditions.startTime = timestamp;
+              instance.conditions.progress = 0;
+              this.flushCurrentSourceData(instance);
+              instance.conditions.animationId = requestAnimationFrame(function (time) {
+                return _this8.animateStep(time, instance);
+              });
+              return;
+            }
+            var nextAngle = NavFunctions.bearingInDegBetween(segmentEnd, next);
+            instance.conditions.iconRotation = nextAngle;
+            (_instance$routeMarker8 = instance.routeMarker) === null || _instance$routeMarker8 === void 0 || _instance$routeMarker8.setRotation(nextAngle);
+          }
+          segmentStart = segmentEnd;
+          segmentEnd = next;
+          segmentDistance = NavFunctions.distance(segmentStart, segmentEnd);
         }
-        var fraction = speed * progressInSeconds / distance;
-        var point = distance === 0 ? end : NavFunctions.intermediatePointBetween(start, end, Math.min(fraction, 1));
-        instance.currentSourceData.geometry.coordinates.push([point.lng, point.lat]);
-        var source = this.map.getSource(instance.currentId);
-        source === null || source === void 0 || source.setData(instance.currentSourceData);
+        var fraction = speed * progressInSeconds / segmentDistance;
+        var point = segmentDistance === 0 ? segmentEnd : NavFunctions.intermediatePointBetween(segmentStart, segmentEnd, Math.min(fraction, 1));
+        coordinates.push([point.lng, point.lat]);
+        this.flushCurrentSourceData(instance);
         this.setMarkerLngLat(instance, point);
-        (_instance$routeMarker8 = instance.routeMarker) === null || _instance$routeMarker8 === void 0 || _instance$routeMarker8.addTo(this.map);
+        // Only when it has genuinely left the DOM. maplibre's `Marker.addTo`
+        // opens with `remove()`, so re-attaching an attached marker tears down
+        // and rebuilds 13 map listeners and detaches and re-appends the element.
+        // Unconditionally, that ran every frame — and quietly undid
+        // `updateRouteMarkerVisibility` hiding the arrow, which is the bug it was
+        // really covering for.
+        //
+        // `isConnected` alone cannot express that: `hide()` detaches the element
+        // through maplibre's `Marker.remove()`, so a marker hidden by a floor
+        // change reads as disconnected and was re-attached on the very next
+        // frame — the arrow reappeared on the wrong floor. Hidden-ness is an
+        // intent, so it is read from the flag `hide()`/`show()` maintain, and
+        // `isConnected` is left to answer only what it can: whether a marker
+        // nobody hid has fallen out of the DOM (a step transition removing it).
+        if (instance.routeMarker != null && !instance.routeMarker.hiddenOnPurpose && !instance.routeMarker.getElement().isConnected) {
+          instance.routeMarker.addTo(this.map);
+        }
         instance.conditions.animationId = requestAnimationFrame(function (time) {
           return _this8.animateStep(time, instance);
         });
@@ -14567,6 +14769,21 @@ var RouteController = /*#__PURE__*/function () {
         return;
       }
     }
+
+    /**
+     * Pushes the in-progress segment's geometry to its map source.
+     *
+     * Called once per frame rather than once per vertex crossed: `setData`
+     * rebuilds the whole geojson-vt index and reloads every in-view tile, so its
+     * cost is a large fixed one per call and is worth paying only once, with the
+     * frame's final geometry.
+     */
+  }, {
+    key: "flushCurrentSourceData",
+    value: function flushCurrentSourceData(instance) {
+      var source = this.map.getSource(instance.currentId);
+      source === null || source === void 0 || source.setData(instance.currentSourceData);
+    }
   }, {
     key: "setMarkerLngLat",
     value: function setMarkerLngLat(instance, point) {
@@ -19492,37 +19709,83 @@ function three_arrayWithHoles(r) { if (Array.isArray(r)) return r; }
 
 /** Runtime handle to the deck.gl classes used by the 3D scene. */
 
-var threePromise;
-var deckPromise;
+/**
+ * Memoizes a dynamic-import chain, caching only a FULFILLED result.
+ *
+ * A plain `cached ??= import(...)` also memoizes a *rejection*, so one transient chunk-fetch
+ * failure (a dropped connection, a cache-busted deploy mid-session) permanently disables the
+ * feature for the rest of the page's life: every retry receives the same rejected promise and
+ * fails identically. The 3D scene retries on its own — `reloadScene3DModelsForLod` reloads GLB
+ * templates on every zoom-in past the LOD threshold — so a sticky rejection turns a blip into
+ * models that never come back until the user reloads.
+ *
+ * Concurrent callers still share one in-flight import (that is the point of the cache); only the
+ * rejected promise is evicted, and the error is re-thrown so every current caller still sees it.
+ *
+ * Exported only so the eviction behaviour can be tested directly — the loaders below wrap real
+ * dynamic `import()` calls, which a unit test cannot fail on demand.
+ *
+ * @param load Builds the import promise. Called again on the first retry after a failure.
+ * @returns An accessor that imports at most once per successful load.
+ * @internal
+ */
+function memoizeImport(load) {
+  var cached;
+  return function () {
+    cached !== null && cached !== void 0 ? cached : cached = load()["catch"](function (error) {
+      // Evict BEFORE re-throwing so the next call starts a fresh import. Safe to assign here:
+      // a promise never settles synchronously, so `cached` is already assigned by now.
+      cached = undefined;
+      throw error;
+    });
+    return cached;
+  };
+}
 
 /**
  * Dynamically imports Three.js and the GLTF/DRACO/KTX2 loaders once and caches the result.
  * Subsequent calls return the same promise, so a single Three.js instance is shared.
+ * A failed import is not cached — see {@link memoizeImport}.
  */
-function loadThree() {
-  threePromise !== null && threePromise !== void 0 ? threePromise : threePromise = Promise.all([Promise.resolve(/* import() */).then(__webpack_require__.t.bind(__webpack_require__, 912, 23)), Promise.resolve(/* import() */).then(__webpack_require__.t.bind(__webpack_require__, 833, 23)), Promise.resolve(/* import() */).then(__webpack_require__.t.bind(__webpack_require__, 303, 23)), Promise.resolve(/* import() */).then(__webpack_require__.t.bind(__webpack_require__, 373, 23)), Promise.resolve(/* import() */).then(__webpack_require__.t.bind(__webpack_require__, 502, 23))]).then(function (_ref) {
-    var _ref2 = three_slicedToArray(_ref, 5),
+var loadThree = memoizeImport(function () {
+  return Promise.all([Promise.resolve(/* import() */).then(__webpack_require__.t.bind(__webpack_require__, 912, 23)), Promise.resolve(/* import() */).then(__webpack_require__.t.bind(__webpack_require__, 833, 23)), Promise.resolve(/* import() */).then(__webpack_require__.t.bind(__webpack_require__, 303, 23)), Promise.resolve(/* import() */).then(__webpack_require__.t.bind(__webpack_require__, 373, 23))]).then(function (_ref) {
+    var _ref2 = three_slicedToArray(_ref, 4),
       three = _ref2[0],
       gltf = _ref2[1],
       draco = _ref2[2],
-      ktx2 = _ref2[3],
-      meshopt = _ref2[4];
+      ktx2 = _ref2[3];
     return {
       THREE: three,
       GLTFLoader: gltf.GLTFLoader,
       DRACOLoader: draco.DRACOLoader,
-      KTX2Loader: ktx2.KTX2Loader,
-      MeshoptDecoder: meshopt.MeshoptDecoder
+      KTX2Loader: ktx2.KTX2Loader
     };
   });
-  return threePromise;
-}
+});
+
+/**
+ * Dynamically imports the singleton meshopt decoder once and caches the result.
+ *
+ * Deliberately NOT part of {@link loadThree}'s import chain: only GLBs compressed with
+ * `EXT_meshopt_compression` need it, so keeping it out of the eager `Promise.all` keeps the
+ * decoder module (and its WASM instantiation) off the critical path of the first 3D frame.
+ * It is fetched on the first meshopt buffer decode instead — see the lazy wrapper in
+ * `loadGlb.ts`. That moves the fetch inside `parse()`, competing with hundreds of MB of GLB
+ * downloads, so not caching a failed import (see {@link memoizeImport}) matters more here than
+ * for the eager loaders.
+ */
+var loadMeshoptDecoder = memoizeImport(function () {
+  return Promise.resolve(/* import() */).then(__webpack_require__.t.bind(__webpack_require__, 502, 23)).then(function (meshopt) {
+    return meshopt.MeshoptDecoder;
+  });
+});
 
 /**
  * Dynamically imports the deck.gl overlay and layer classes once and caches the result.
+ * A failed import is not cached — see {@link memoizeImport}.
  */
-function loadDeck() {
-  deckPromise !== null && deckPromise !== void 0 ? deckPromise : deckPromise = Promise.all([Promise.resolve(/* import() */).then(__webpack_require__.t.bind(__webpack_require__, 452, 23)), Promise.resolve(/* import() */).then(__webpack_require__.t.bind(__webpack_require__, 741, 23)), Promise.resolve(/* import() */).then(__webpack_require__.t.bind(__webpack_require__, 589, 23))]).then(function (_ref3) {
+var loadDeck = memoizeImport(function () {
+  return Promise.all([Promise.resolve(/* import() */).then(__webpack_require__.t.bind(__webpack_require__, 452, 23)), Promise.resolve(/* import() */).then(__webpack_require__.t.bind(__webpack_require__, 741, 23)), Promise.resolve(/* import() */).then(__webpack_require__.t.bind(__webpack_require__, 589, 23))]).then(function (_ref3) {
     var _ref4 = three_slicedToArray(_ref3, 3),
       mapbox = _ref4[0],
       geoLayers = _ref4[1],
@@ -19535,31 +19798,104 @@ function loadDeck() {
       TextLayer: layers.TextLayer
     };
   });
-  return deckPromise;
-}
+});
 ;// ./src/utils/loadGlb.ts
-function loadGlb_regenerator() { /*! regenerator-runtime -- Copyright (c) 2014-present, Facebook, Inc. -- license (MIT): https://github.com/babel/babel/blob/main/packages/babel-helpers/LICENSE */ var e, t, r = "function" == typeof Symbol ? Symbol : {}, n = r.iterator || "@@iterator", o = r.toStringTag || "@@toStringTag"; function i(r, n, o, i) { var c = n && n.prototype instanceof Generator ? n : Generator, u = Object.create(c.prototype); return loadGlb_regeneratorDefine2(u, "_invoke", function (r, n, o) { var i, c, u, f = 0, p = o || [], y = !1, G = { p: 0, n: 0, v: e, a: d, f: d.bind(e, 4), d: function d(t, r) { return i = t, c = 0, u = e, G.n = r, a; } }; function d(r, n) { for (c = r, u = n, t = 0; !y && f && !o && t < p.length; t++) { var o, i = p[t], d = G.p, l = i[2]; r > 3 ? (o = l === n) && (u = i[(c = i[4]) ? 5 : (c = 3, 3)], i[4] = i[5] = e) : i[0] <= d && ((o = r < 2 && d < i[1]) ? (c = 0, G.v = n, G.n = i[1]) : d < l && (o = r < 3 || i[0] > n || n > l) && (i[4] = r, i[5] = n, G.n = l, c = 0)); } if (o || r > 1) return a; throw y = !0, n; } return function (o, p, l) { if (f > 1) throw TypeError("Generator is already running"); for (y && 1 === p && d(p, l), c = p, u = l; (t = c < 2 ? e : u) || !y;) { i || (c ? c < 3 ? (c > 1 && (G.n = -1), d(c, u)) : G.n = u : G.v = u); try { if (f = 2, i) { if (c || (o = "next"), t = i[o]) { if (!(t = t.call(i, u))) throw TypeError("iterator result is not an object"); if (!t.done) return t; u = t.value, c < 2 && (c = 0); } else 1 === c && (t = i["return"]) && t.call(i), c < 2 && (u = TypeError("The iterator does not provide a '" + o + "' method"), c = 1); i = e; } else if ((t = (y = G.n < 0) ? u : r.call(n, G)) !== a) break; } catch (t) { i = e, c = 1, u = t; } finally { f = 1; } } return { value: t, done: y }; }; }(r, o, i), !0), u; } var a = {}; function Generator() {} function GeneratorFunction() {} function GeneratorFunctionPrototype() {} t = Object.getPrototypeOf; var c = [][n] ? t(t([][n]())) : (loadGlb_regeneratorDefine2(t = {}, n, function () { return this; }), t), u = GeneratorFunctionPrototype.prototype = Generator.prototype = Object.create(c); function f(e) { return Object.setPrototypeOf ? Object.setPrototypeOf(e, GeneratorFunctionPrototype) : (e.__proto__ = GeneratorFunctionPrototype, loadGlb_regeneratorDefine2(e, o, "GeneratorFunction")), e.prototype = Object.create(u), e; } return GeneratorFunction.prototype = GeneratorFunctionPrototype, loadGlb_regeneratorDefine2(u, "constructor", GeneratorFunctionPrototype), loadGlb_regeneratorDefine2(GeneratorFunctionPrototype, "constructor", GeneratorFunction), GeneratorFunction.displayName = "GeneratorFunction", loadGlb_regeneratorDefine2(GeneratorFunctionPrototype, o, "GeneratorFunction"), loadGlb_regeneratorDefine2(u), loadGlb_regeneratorDefine2(u, o, "Generator"), loadGlb_regeneratorDefine2(u, n, function () { return this; }), loadGlb_regeneratorDefine2(u, "toString", function () { return "[object Generator]"; }), (loadGlb_regenerator = function _regenerator() { return { w: i, m: f }; })(); }
-function loadGlb_regeneratorDefine2(e, r, n, t) { var i = Object.defineProperty; try { i({}, "", {}); } catch (e) { i = 0; } loadGlb_regeneratorDefine2 = function _regeneratorDefine(e, r, n, t) { function o(r, n) { loadGlb_regeneratorDefine2(e, r, function (e) { return this._invoke(r, n, e); }); } r ? i ? i(e, r, { value: n, enumerable: !t, configurable: !t, writable: !t }) : e[r] = n : (o("next", 0), o("throw", 1), o("return", 2)); }, loadGlb_regeneratorDefine2(e, r, n, t); }
 function loadGlb_slicedToArray(r, e) { return loadGlb_arrayWithHoles(r) || loadGlb_iterableToArrayLimit(r, e) || loadGlb_unsupportedIterableToArray(r, e) || loadGlb_nonIterableRest(); }
 function loadGlb_nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
 function loadGlb_unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return loadGlb_arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? loadGlb_arrayLikeToArray(r, a) : void 0; } }
 function loadGlb_arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
 function loadGlb_iterableToArrayLimit(r, l) { var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (null != t) { var e, n, i, u, a = [], f = !0, o = !1; try { if (i = (t = t.call(r)).next, 0 === l) { if (Object(t) !== t) return; f = !1; } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0); } catch (r) { o = !0, n = r; } finally { try { if (!f && null != t["return"] && (u = t["return"](), Object(u) !== u)) return; } finally { if (o) throw n; } } return a; } }
 function loadGlb_arrayWithHoles(r) { if (Array.isArray(r)) return r; }
+function loadGlb_regenerator() { /*! regenerator-runtime -- Copyright (c) 2014-present, Facebook, Inc. -- license (MIT): https://github.com/babel/babel/blob/main/packages/babel-helpers/LICENSE */ var e, t, r = "function" == typeof Symbol ? Symbol : {}, n = r.iterator || "@@iterator", o = r.toStringTag || "@@toStringTag"; function i(r, n, o, i) { var c = n && n.prototype instanceof Generator ? n : Generator, u = Object.create(c.prototype); return loadGlb_regeneratorDefine2(u, "_invoke", function (r, n, o) { var i, c, u, f = 0, p = o || [], y = !1, G = { p: 0, n: 0, v: e, a: d, f: d.bind(e, 4), d: function d(t, r) { return i = t, c = 0, u = e, G.n = r, a; } }; function d(r, n) { for (c = r, u = n, t = 0; !y && f && !o && t < p.length; t++) { var o, i = p[t], d = G.p, l = i[2]; r > 3 ? (o = l === n) && (u = i[(c = i[4]) ? 5 : (c = 3, 3)], i[4] = i[5] = e) : i[0] <= d && ((o = r < 2 && d < i[1]) ? (c = 0, G.v = n, G.n = i[1]) : d < l && (o = r < 3 || i[0] > n || n > l) && (i[4] = r, i[5] = n, G.n = l, c = 0)); } if (o || r > 1) return a; throw y = !0, n; } return function (o, p, l) { if (f > 1) throw TypeError("Generator is already running"); for (y && 1 === p && d(p, l), c = p, u = l; (t = c < 2 ? e : u) || !y;) { i || (c ? c < 3 ? (c > 1 && (G.n = -1), d(c, u)) : G.n = u : G.v = u); try { if (f = 2, i) { if (c || (o = "next"), t = i[o]) { if (!(t = t.call(i, u))) throw TypeError("iterator result is not an object"); if (!t.done) return t; u = t.value, c < 2 && (c = 0); } else 1 === c && (t = i["return"]) && t.call(i), c < 2 && (u = TypeError("The iterator does not provide a '" + o + "' method"), c = 1); i = e; } else if ((t = (y = G.n < 0) ? u : r.call(n, G)) !== a) break; } catch (t) { i = e, c = 1, u = t; } finally { f = 1; } } return { value: t, done: y }; }; }(r, o, i), !0), u; } var a = {}; function Generator() {} function GeneratorFunction() {} function GeneratorFunctionPrototype() {} t = Object.getPrototypeOf; var c = [][n] ? t(t([][n]())) : (loadGlb_regeneratorDefine2(t = {}, n, function () { return this; }), t), u = GeneratorFunctionPrototype.prototype = Generator.prototype = Object.create(c); function f(e) { return Object.setPrototypeOf ? Object.setPrototypeOf(e, GeneratorFunctionPrototype) : (e.__proto__ = GeneratorFunctionPrototype, loadGlb_regeneratorDefine2(e, o, "GeneratorFunction")), e.prototype = Object.create(u), e; } return GeneratorFunction.prototype = GeneratorFunctionPrototype, loadGlb_regeneratorDefine2(u, "constructor", GeneratorFunctionPrototype), loadGlb_regeneratorDefine2(GeneratorFunctionPrototype, "constructor", GeneratorFunction), GeneratorFunction.displayName = "GeneratorFunction", loadGlb_regeneratorDefine2(GeneratorFunctionPrototype, o, "GeneratorFunction"), loadGlb_regeneratorDefine2(u), loadGlb_regeneratorDefine2(u, o, "Generator"), loadGlb_regeneratorDefine2(u, n, function () { return this; }), loadGlb_regeneratorDefine2(u, "toString", function () { return "[object Generator]"; }), (loadGlb_regenerator = function _regenerator() { return { w: i, m: f }; })(); }
+function loadGlb_regeneratorDefine2(e, r, n, t) { var i = Object.defineProperty; try { i({}, "", {}); } catch (e) { i = 0; } loadGlb_regeneratorDefine2 = function _regeneratorDefine(e, r, n, t) { function o(r, n) { loadGlb_regeneratorDefine2(e, r, function (e) { return this._invoke(r, n, e); }); } r ? i ? i(e, r, { value: n, enumerable: !t, configurable: !t, writable: !t }) : e[r] = n : (o("next", 0), o("throw", 1), o("return", 2)); }, loadGlb_regeneratorDefine2(e, r, n, t); }
 function loadGlb_asyncGeneratorStep(n, t, e, r, o, a, c) { try { var i = n[a](c), u = i.value; } catch (n) { return void e(n); } i.done ? t(u) : Promise.resolve(u).then(r, o); }
 function loadGlb_asyncToGenerator(n) { return function () { var t = this, e = arguments; return new Promise(function (r, o) { var a = n.apply(t, e); function _next(n) { loadGlb_asyncGeneratorStep(a, r, o, _next, _throw, "next", n); } function _throw(n) { loadGlb_asyncGeneratorStep(a, r, o, _next, _throw, "throw", n); } _next(void 0); }); }; }
+function loadGlb_typeof(o) { "@babel/helpers - typeof"; return loadGlb_typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, loadGlb_typeof(o); }
 
 
 
+/**
+ * The subset of the meshopt decoder contract `GLTFLoader` actually exercises when
+ * `decodeGltfBufferAsync` is present: it checks `supported`, then calls `decodeGltfBufferAsync`
+ * for each `EXT_meshopt_compression` buffer view (never touching `ready`/`decodeGltfBuffer`).
+ *
+ * The signature is derived from the module type again, now that
+ * `src/types/three-addons.d.ts` declares the decoder's shape directly instead of forwarding to
+ * `@types/three`'s unresolvable `export * from "meshoptimizer/decoder"` — which `skipLibCheck`
+ * swallowed, collapsing the lookup to `any`. Deriving keeps this interface and the delegation
+ * call in `createLazyMeshoptDecoder` checked against a single definition; hand-writing it here
+ * left the delegation itself unchecked, because the value it delegates to was still `any`.
+ *
+ * That definition is transcribed from three's JS, so it is an assertion about that file rather
+ * than a derivation from it: a three.js change needs the `.d.ts` updated by hand. What is
+ * compiler-enforced is that this shim and its consumers agree with it.
+ * @internal
+ */
+
+/**
+ * Builds a stand-in meshopt decoder that defers importing the real module (and instantiating its
+ * WASM) until the first `EXT_meshopt_compression` buffer actually needs decoding. GLBs without the
+ * extension never trigger the import, so the decoder stays off the critical path of the first 3D
+ * frame — it used to be part of the eager three.js import chain, delaying every scene load.
+ *
+ * `supported` mirrors the real module's own gate — it returns a bare `{ supported: false }` when
+ * `typeof WebAssembly !== "object"` — so the answer is reproduced synchronously here without
+ * importing anything. Reporting a flat `true` instead would break the platforms it claims to
+ * support: `GLTFLoader` reads `supported` before deciding to decode, and on `false` with meshopt
+ * merely OPTIONAL it returns `null` and falls back to the GLB's uncompressed buffer
+ * (`GLTFLoader.js` `GLTFMeshoptCompression.loadBufferView`). Claiming support on a WASM-less
+ * platform discards that fallback and fails the whole asset with a `TypeError` from this shim,
+ * since `decodeGltfBufferAsync` does not exist on the real module there.
+ *
+ * @param load Injectable module loader, for tests. Defaults to the cached {@link loadMeshoptDecoder}.
+ * @internal
+ */
+function createLazyMeshoptDecoder() {
+  var load = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : loadMeshoptDecoder;
+  return {
+    // Same condition the real decoder uses, evaluated without loading it.
+    supported: (typeof WebAssembly === "undefined" ? "undefined" : loadGlb_typeof(WebAssembly)) === "object",
+    decodeGltfBufferAsync: function () {
+      var _decodeGltfBufferAsync = loadGlb_asyncToGenerator(/*#__PURE__*/loadGlb_regenerator().m(function _callee(count, size, source, mode, filter) {
+        var decoder;
+        return loadGlb_regenerator().w(function (_context) {
+          while (1) switch (_context.n) {
+            case 0:
+              _context.n = 1;
+              return load();
+            case 1:
+              decoder = _context.v;
+              _context.n = 2;
+              return decoder.ready;
+            case 2:
+              return _context.a(2, decoder.decodeGltfBufferAsync(count, size, source, mode, filter));
+          }
+        }, _callee);
+      }));
+      function decodeGltfBufferAsync(_x, _x2, _x3, _x4, _x5) {
+        return _decodeGltfBufferAsync.apply(this, arguments);
+      }
+      return decodeGltfBufferAsync;
+    }()
+  };
+}
+
 /**
  * Lazily-initialized, cached GLTF loader configured with Draco + KTX2 support.
  *
  * The loaders (and their WebGLRenderer for KTX2 support detection) are heavy and pull in Three.js,
  * so they are created on first use inside the dynamic-import boundary rather than at module load.
- */
-var gltfLoaderPromise;
-function getGltfLoader() {
-  gltfLoaderPromise !== null && gltfLoaderPromise !== void 0 ? gltfLoaderPromise : gltfLoaderPromise = loadThree().then(function (mod) {
+ *
+ * Memoized through {@link memoizeImport} for the same reason the loaders in `three.ts` are: a plain
+ * `cached ??=` also caches a rejection. Fixing the three loaders was not enough, because this is a
+ * SECOND cache wrapped around `loadThree()` — so a transient failure was evicted there and then
+ * replayed from here forever, and `loadGlbRoot` awaits both, meaning every GLB kept failing with
+ * the stale error long after `loadThree()` had recovered. Not only network: the `.then` below
+ * constructs a `WebGLRenderer` for KTX2 support detection, and a failed context creation was
+ * cached just the same.
+ */
+var getGltfLoader = memoizeImport(function () {
+  return loadThree().then(function (mod) {
     var dracoLoader = new mod.DRACOLoader();
     dracoLoader.setDecoderPath(DEFAULT_DRACO_DECODER_PATH);
     var gltfLoader = new mod.GLTFLoader();
@@ -19571,15 +19907,15 @@ function getGltfLoader() {
       antialias: true
     }));
 
-    // Enable EXT_meshopt_compression so meshopt-compressed GLBs decode. The decoder is a WASM
-    // singleton; GLTFLoader awaits its `.ready` promise internally before parsing. Assets that
-    // don't use the extension are unaffected. This lets the offline pipeline pick meshopt (often
-    // smaller than Draco for the scene's meshes) without a runtime change.
-    gltfLoader.setMeshoptDecoder(mod.MeshoptDecoder);
+    // Enable EXT_meshopt_compression so meshopt-compressed GLBs decode, without paying for the
+    // decoder module up front: the lazy stand-in imports it (and instantiates its WASM) only when
+    // the first meshopt-compressed buffer is actually decoded. Assets that don't use the extension
+    // never load it. The cast is safe — with `decodeGltfBufferAsync` present, GLTFLoader touches
+    // only `supported` and `decodeGltfBufferAsync` (see LazyMeshoptDecoder).
+    gltfLoader.setMeshoptDecoder(createLazyMeshoptDecoder());
     return gltfLoader;
   });
-  return gltfLoaderPromise;
-}
+});
 
 /**
  * Default per-asset timeout for {@link loadGlbRoot}.
@@ -19644,11 +19980,11 @@ function assertGlbBufferComplete(buffer, url) {
  * @returns Root `THREE.Group` from the loaded glTF scene
  * @group Utils
  */
-function loadGlbRoot(_x) {
+function loadGlbRoot(_x6) {
   return _loadGlbRoot.apply(this, arguments);
 }
 function _loadGlbRoot() {
-  _loadGlbRoot = loadGlb_asyncToGenerator(/*#__PURE__*/loadGlb_regenerator().m(function _callee(url) {
+  _loadGlbRoot = loadGlb_asyncToGenerator(/*#__PURE__*/loadGlb_regenerator().m(function _callee2(url) {
     var options,
       _options$timeoutMs,
       timeoutMs,
@@ -19662,16 +19998,16 @@ function _loadGlbRoot() {
       load,
       timer,
       timeout,
-      _args = arguments;
-    return loadGlb_regenerator().w(function (_context) {
-      while (1) switch (_context.p = _context.n) {
+      _args2 = arguments;
+    return loadGlb_regenerator().w(function (_context2) {
+      while (1) switch (_context2.p = _context2.n) {
         case 0:
-          options = _args.length > 1 && _args[1] !== undefined ? _args[1] : {};
+          options = _args2.length > 1 && _args2[1] !== undefined ? _args2[1] : {};
           _options$timeoutMs = options.timeoutMs, timeoutMs = _options$timeoutMs === void 0 ? DEFAULT_GLB_LOAD_TIMEOUT_MS : _options$timeoutMs, onProgress = options.onProgress;
-          _context.n = 1;
+          _context2.n = 1;
           return Promise.all([getGltfLoader(), loadThree()]);
         case 1:
-          _yield$Promise$all = _context.v;
+          _yield$Promise$all = _context2.v;
           _yield$Promise$all2 = loadGlb_slicedToArray(_yield$Promise$all, 2);
           gltfLoader = _yield$Promise$all2[0];
           three = _yield$Promise$all2[1].THREE;
@@ -19705,31 +20041,31 @@ function _loadGlbRoot() {
             }, onError);
           });
           if (!(!Number.isFinite(timeoutMs) || timeoutMs <= 0)) {
-            _context.n = 5;
+            _context2.n = 5;
             break;
           }
-          _context.p = 2;
-          _context.n = 3;
+          _context2.p = 2;
+          _context2.n = 3;
           return load;
         case 3:
-          return _context.a(2, _context.v);
+          return _context2.a(2, _context2.v);
         case 4:
-          _context.p = 4;
+          _context2.p = 4;
           settled = true;
-          return _context.f(4);
+          return _context2.f(4);
         case 5:
           timeout = new Promise(function (_resolve, reject) {
             timer = setTimeout(function () {
               return reject(new Error("Timed out loading GLB after ".concat(timeoutMs, "ms: ").concat(url)));
             }, timeoutMs);
           });
-          _context.p = 6;
-          _context.n = 7;
+          _context2.p = 6;
+          _context2.n = 7;
           return Promise.race([load, timeout]);
         case 7:
-          return _context.a(2, _context.v);
+          return _context2.a(2, _context2.v);
         case 8:
-          _context.p = 8;
+          _context2.p = 8;
           settled = true;
           clearTimeout(timer);
           // Cancels the underlying fetch (and, by never delivering its buffer, the Draco/KTX2 decode)
@@ -19737,11 +20073,11 @@ function _loadGlbRoot() {
           // unattended — otherwise GLB_LOAD_CONCURRENCY only bounds how many loads the caller awaits,
           // not how many are truly in flight. A no-op if `load` already won the race.
           fileLoader.abort();
-          return _context.f(8);
+          return _context2.f(8);
         case 9:
-          return _context.a(2);
+          return _context2.a(2);
       }
-    }, _callee, null, [[6,, 8, 9], [2,, 4, 5]]);
+    }, _callee2, null, [[6,, 8, 9], [2,, 4, 5]]);
   }));
   return _loadGlbRoot.apply(this, arguments);
 }
@@ -22574,9 +22910,8 @@ var InternalMapVXMap = /*#__PURE__*/function (_Loggeable) {
   }, {
     key: "addMarker",
     value: function addMarker(marker) {
-      var _this11 = this;
       try {
-        var _marker$maxLabelWidth, _this$innerFloors$fin4, _this$innerFloors$fin5;
+        var _marker$maxLabelWidth;
         // Check if a marker with the same ID already exists and remove it
         if (marker.id) {
           var existingMarkerIndex = this.markers.findIndex(function (m) {
@@ -22595,10 +22930,7 @@ var InternalMapVXMap = /*#__PURE__*/function (_Loggeable) {
         var markerCreated = new MarkerAttribute(map_objectSpread(map_objectSpread({}, marker), {}, {
           maxLabelWidthPx: (_marker$maxLabelWidth = marker.maxLabelWidthPx) !== null && _marker$maxLabelWidth !== void 0 ? _marker$maxLabelWidth : this.markerLayoutConfig.maxLabelWidthPx
         }));
-        var isOutdoor = !this.parentPlace || ((_this$innerFloors$fin4 = (_this$innerFloors$fin5 = this.innerFloors.find(function (floor) {
-          return floor.key === _this11.currentFloor;
-        })) === null || _this$innerFloors$fin5 === void 0 ? void 0 : _this$innerFloors$fin5.reachableFromGPS) !== null && _this$innerFloors$fin4 !== void 0 ? _this$innerFloors$fin4 : false);
-        markerCreated.changeFloor(this.currentFloor, this.map, isOutdoor);
+        markerCreated.changeFloor(this.currentFloor, this.map, this.isOutdoorFloor(this.currentFloor));
         this.markers.push(markerCreated);
         this.markerLayoutController.scheduleRelayout();
         this.logEvent("addMarker");
@@ -22913,11 +23245,9 @@ var InternalMapVXMap = /*#__PURE__*/function (_Loggeable) {
   }, {
     key: "circleFeatureCollection",
     value: function circleFeatureCollection() {
-      var _this$currentFloor3, _this$innerFloors$fin6, _this$innerFloors$fin7;
+      var _this$currentFloor3;
       var floorId = (_this$currentFloor3 = this.currentFloor) !== null && _this$currentFloor3 !== void 0 ? _this$currentFloor3 : "";
-      var isOutdoor = !this.parentPlace || ((_this$innerFloors$fin6 = (_this$innerFloors$fin7 = this.innerFloors.find(function (floor) {
-        return floor.key === floorId;
-      })) === null || _this$innerFloors$fin7 === void 0 ? void 0 : _this$innerFloors$fin7.reachableFromGPS) !== null && _this$innerFloors$fin6 !== void 0 ? _this$innerFloors$fin6 : false);
+      var isOutdoor = this.isOutdoorFloor(floorId);
       var features = this.circles.filter(function (circle) {
         var _circle$floorId;
         if (circle.hidden) return false;
@@ -23134,14 +23464,10 @@ var InternalMapVXMap = /*#__PURE__*/function (_Loggeable) {
   }, {
     key: "updateMarkersTo",
     value: function updateMarkersTo(floorId) {
-      var _this$innerFloors$fin8,
-        _this$innerFloors$fin9,
-        _this12 = this;
-      var isOutdoor = !this.parentPlace || ((_this$innerFloors$fin8 = (_this$innerFloors$fin9 = this.innerFloors.find(function (floor) {
-        return floor.key === floorId;
-      })) === null || _this$innerFloors$fin9 === void 0 ? void 0 : _this$innerFloors$fin9.reachableFromGPS) !== null && _this$innerFloors$fin8 !== void 0 ? _this$innerFloors$fin8 : false);
+      var _this11 = this;
+      var isOutdoor = this.isOutdoorFloor(floorId);
       this.markers.forEach(function (e) {
-        e.changeFloor(floorId, _this12.map, isOutdoor);
+        e.changeFloor(floorId, _this11.map, isOutdoor);
       });
       this.markerLayoutController.scheduleRelayout();
     }
@@ -23150,18 +23476,18 @@ var InternalMapVXMap = /*#__PURE__*/function (_Loggeable) {
     value: function updateFiltersTo(floorId) {
       var _this$map$getStyle$la3,
         _this$map$getStyle3,
-        _this13 = this,
-        _this$innerFloors$fin0;
+        _this12 = this,
+        _this$innerFloors$fin4;
       if (!this.map) return;
       var layers = (_this$map$getStyle$la3 = (_this$map$getStyle3 = this.map.getStyle()) === null || _this$map$getStyle3 === void 0 ? void 0 : _this$map$getStyle3.layers) !== null && _this$map$getStyle$la3 !== void 0 ? _this$map$getStyle$la3 : [];
       layers.filter(function (l) {
         return l.id.startsWith("base-indoor-");
       }).forEach(function (l) {
-        _this13.map.removeLayer(l.id);
+        _this12.map.removeLayer(l.id);
       });
-      var baseFloorId = (_this$innerFloors$fin0 = this.innerFloors.find(function (floor) {
+      var baseFloorId = (_this$innerFloors$fin4 = this.innerFloors.find(function (floor) {
         return floor.key === floorId;
-      })) === null || _this$innerFloors$fin0 === void 0 ? void 0 : _this$innerFloors$fin0.baseFloor;
+      })) === null || _this$innerFloors$fin4 === void 0 ? void 0 : _this$innerFloors$fin4.baseFloor;
       var indoorLayers = layers.filter(function (layer) {
         return layer.id.startsWith("indoor-");
       });
@@ -23175,7 +23501,7 @@ var InternalMapVXMap = /*#__PURE__*/function (_Loggeable) {
       // resolved are skipped, so a filter this class wrote is never mistaken for a
       // declared one.
       indoorLayers.forEach(function (layer) {
-        return _this13.captureDeclaredBaseFilter(layer.id);
+        return _this12.captureDeclaredBaseFilter(layer.id);
       });
       if (baseFloorId != undefined) {
         var _indoorLayers$;
@@ -23185,13 +23511,13 @@ var InternalMapVXMap = /*#__PURE__*/function (_Loggeable) {
         }).forEach(function (layer) {
           var baseLayer = deepClone(layer);
           baseLayer.id = "base-" + layer.id;
-          _this13.baseFilters[baseLayer.id] = _this13.baseFilters[layer.id];
-          _this13.map.addLayer(baseLayer, firstLayerId);
-          _this13.applyLayerFilters(baseLayer, baseFloorId);
+          _this12.baseFilters[baseLayer.id] = _this12.baseFilters[layer.id];
+          _this12.map.addLayer(baseLayer, firstLayerId);
+          _this12.applyLayerFilters(baseLayer, baseFloorId);
         });
       }
       indoorLayers.forEach(function (layer) {
-        _this13.applyLayerFilters(layer, floorId);
+        _this12.applyLayerFilters(layer, floorId);
       });
     }
 
@@ -23263,6 +23589,23 @@ var InternalMapVXMap = /*#__PURE__*/function (_Loggeable) {
     value: function getInnerFloors() {
       return this.innerFloors;
     }
+
+    /**
+     * Whether `floorId` shows the venue's outdoors, and so whether entities that
+     * carry no floor of their own belong on screen with it.
+     *
+     * A map without a parent place is outdoors throughout; inside one, only a
+     * floor reachable from GPS is. Markers, circles and the route marker all hang
+     * their visibility on this, so they answer it the same way.
+     */
+  }, {
+    key: "isOutdoorFloor",
+    value: function isOutdoorFloor(floorId) {
+      var _this$innerFloors$fin5, _this$innerFloors$fin6;
+      return !this.parentPlace || ((_this$innerFloors$fin5 = (_this$innerFloors$fin6 = this.innerFloors.find(function (floor) {
+        return floor.key === floorId;
+      })) === null || _this$innerFloors$fin6 === void 0 ? void 0 : _this$innerFloors$fin6.reachableFromGPS) !== null && _this$innerFloors$fin5 !== void 0 ? _this$innerFloors$fin5 : false);
+    }
   }, {
     key: "updateCamera",
     value: function updateCamera(newCamera, callback) {
@@ -23744,17 +24087,17 @@ var InternalMapVXMap = /*#__PURE__*/function (_Loggeable) {
   }, {
     key: "defaultClickListener",
     value: function defaultClickListener() {
-      var _this14 = this;
+      var _this13 = this;
       this.map.on("click", /*#__PURE__*/function () {
         var _ref4 = map_asyncToGenerator(/*#__PURE__*/map_regenerator().m(function _callee3(e) {
           var features, roomFeatures, touchedFeature, ref, _clickedPlace, _ref5, _clickedPlace$mapvxId, _clickedPlace2, _clickedPlace3, clickedPlace, _iterator3, _step3, potentialParentPlace, cachedSubPlaces, cachedPlaces, clickedPlaceId, _t3;
           return map_regenerator().w(function (_context3) {
             while (1) switch (_context3.p = _context3.n) {
               case 0:
-                features = _this14.map.queryRenderedFeatures(e.point); // Filter room features by current floor
+                features = _this13.map.queryRenderedFeatures(e.point); // Filter room features by current floor
                 roomFeatures = features.filter(function (feature) {
                   var _feature$properties;
-                  return feature.properties["class"] === "room" && ((_feature$properties = feature.properties) === null || _feature$properties === void 0 ? void 0 : _feature$properties.floor_key) === _this14.currentFloor;
+                  return feature.properties["class"] === "room" && ((_feature$properties = feature.properties) === null || _feature$properties === void 0 ? void 0 : _feature$properties.floor_key) === _this13.currentFloor;
                 });
                 touchedFeature = roomFeatures[0];
                 ref = touchedFeature === null || touchedFeature === void 0 ? void 0 : touchedFeature.properties.ref;
@@ -23765,14 +24108,14 @@ var InternalMapVXMap = /*#__PURE__*/function (_Loggeable) {
                 console.log("touchedFeature", ref);
 
                 // First, search in current subPlaces
-                clickedPlace = _this14.subPlaces.find(function (subPlace) {
+                clickedPlace = _this13.subPlaces.find(function (subPlace) {
                   return subPlace.mapvxId === ref;
                 }); // If not found, search in subplaces of potential parent places
                 if (!(clickedPlace === undefined)) {
                   _context3.n = 7;
                   break;
                 }
-                _iterator3 = map_createForOfIteratorHelper(_this14.potentialParentPlaces);
+                _iterator3 = map_createForOfIteratorHelper(_this13.potentialParentPlaces);
                 _context3.p = 1;
                 _iterator3.s();
               case 2:
@@ -23781,7 +24124,7 @@ var InternalMapVXMap = /*#__PURE__*/function (_Loggeable) {
                   break;
                 }
                 potentialParentPlace = _step3.value;
-                cachedSubPlaces = _this14.repository.getCachedSubPlaces(potentialParentPlace.mapvxId);
+                cachedSubPlaces = _this13.repository.getCachedSubPlaces(potentialParentPlace.mapvxId);
                 if (!cachedSubPlaces) {
                   _context3.n = 3;
                   break;
@@ -23813,14 +24156,14 @@ var InternalMapVXMap = /*#__PURE__*/function (_Loggeable) {
                   _context3.n = 10;
                   break;
                 }
-                cachedPlaces = _this14.repository.getCachedPlaces([ref]);
+                cachedPlaces = _this13.repository.getCachedPlaces([ref]);
                 if (!(cachedPlaces.length === 0)) {
                   _context3.n = 9;
                   break;
                 }
                 console.log("fetching place detail from server", ref);
                 _context3.n = 8;
-                return _this14.repository.fetchAndParsePlaceDetail({
+                return _this13.repository.fetchAndParsePlaceDetail({
                   id: ref
                 });
               case 8:
@@ -23833,8 +24176,8 @@ var InternalMapVXMap = /*#__PURE__*/function (_Loggeable) {
               case 10:
                 console.log("clickedPlace", (_clickedPlace = clickedPlace) === null || _clickedPlace === void 0 ? void 0 : _clickedPlace.title);
                 clickedPlaceId = (_ref5 = (_clickedPlace$mapvxId = (_clickedPlace2 = clickedPlace) === null || _clickedPlace2 === void 0 ? void 0 : _clickedPlace2.mapvxId) !== null && _clickedPlace$mapvxId !== void 0 ? _clickedPlace$mapvxId : (_clickedPlace3 = clickedPlace) === null || _clickedPlace3 === void 0 ? void 0 : _clickedPlace3.clientId) !== null && _ref5 !== void 0 ? _ref5 : "";
-                if (clickedPlace !== undefined && _this14.clickCallback) {
-                  _this14.clickCallback(clickedPlaceId);
+                if (clickedPlace !== undefined && _this13.clickCallback) {
+                  _this13.clickCallback(clickedPlaceId);
                 }
               case 11:
                 return _context3.a(2);
@@ -23849,29 +24192,29 @@ var InternalMapVXMap = /*#__PURE__*/function (_Loggeable) {
   }, {
     key: "onHover",
     value: function onHover() {
-      var _this15 = this;
+      var _this14 = this;
       if (!this.enableHover) return;
       this.map.on("mousemove", "hoverable", function (e) {
         var _e$features;
         var feature = (_e$features = e.features) === null || _e$features === void 0 ? void 0 : _e$features.find(function (feature) {
           var _feature$properties$r, _feature$properties2;
-          return ((_feature$properties$r = feature.properties.ref) === null || _feature$properties$r === void 0 ? void 0 : _feature$properties$r.length) > 0 && ((_feature$properties2 = feature.properties) === null || _feature$properties2 === void 0 ? void 0 : _feature$properties2.floor_key) === _this15.currentFloor;
+          return ((_feature$properties$r = feature.properties.ref) === null || _feature$properties$r === void 0 ? void 0 : _feature$properties$r.length) > 0 && ((_feature$properties2 = feature.properties) === null || _feature$properties2 === void 0 ? void 0 : _feature$properties2.floor_key) === _this14.currentFloor;
         });
         var ref = feature === null || feature === void 0 ? void 0 : feature.properties.ref;
         if (ref != null && typeof ref === "string" && ref.length > 0) {
-          _this15.hoveredId = ref;
-          _this15.updateFiltersTo(_this15.currentFloor);
-        } else if (ref === undefined && _this15.hoveredId !== "unselected") {
-          _this15.hoveredId = "unselected";
-          _this15.updateFiltersTo(_this15.currentFloor);
+          _this14.hoveredId = ref;
+          _this14.updateFiltersTo(_this14.currentFloor);
+        } else if (ref === undefined && _this14.hoveredId !== "unselected") {
+          _this14.hoveredId = "unselected";
+          _this14.updateFiltersTo(_this14.currentFloor);
         }
       });
 
       // When the mouse leaves the state-fill layer, update the feature state of the
       // previously hovered feature.
       this.map.on("mouseleave", "hoverable", function () {
-        _this15.hoveredId = "unselected";
-        _this15.updateFiltersTo(_this15.currentFloor);
+        _this14.hoveredId = "unselected";
+        _this14.updateFiltersTo(_this14.currentFloor);
       });
     }
   }, {
@@ -24272,7 +24615,7 @@ var InternalMapVXMap = /*#__PURE__*/function (_Loggeable) {
   }, {
     key: "addUserLocationTracking",
     value: function addUserLocationTracking(enableHighAccuracy, geoLocation, icon) {
-      var _this16 = this;
+      var _this15 = this;
       var initialCoordinate = {
         lat: 0.0,
         lng: 0.0
@@ -24296,7 +24639,7 @@ var InternalMapVXMap = /*#__PURE__*/function (_Loggeable) {
       this.markerLayoutController.scheduleRelayout();
       var updateMarker = function updateMarker(position) {
         marker.setLngLat([position.coords.longitude, position.coords.latitude]);
-        _this16.markerLayoutController.scheduleRelayout();
+        _this15.markerLayoutController.scheduleRelayout();
       };
       this.geoLocation = geoLocation !== null && geoLocation !== void 0 ? geoLocation : navigator.geolocation;
       this.watchPositionID = this.geoLocation.watchPosition(updateMarker, function (error) {
@@ -24392,7 +24735,7 @@ var InternalMapVXMap = /*#__PURE__*/function (_Loggeable) {
     key: "onWebGLContextLost",
     value: function onWebGLContextLost(e) {
       var _this$map2,
-        _this17 = this;
+        _this16 = this;
       e.originalEvent.preventDefault();
       console.warn("Contexto WebGL perdido 😢");
 
@@ -24403,8 +24746,8 @@ var InternalMapVXMap = /*#__PURE__*/function (_Loggeable) {
         var _ext$restoreContext;
         canvas.addEventListener("webglcontextrestored", function () {
           console.debug("Contexto WebGL restaurado, forzando re-render");
-          _this17.map.triggerRepaint(); // forzar repaint
-          _this17.failedTiles.clear();
+          _this16.map.triggerRepaint(); // forzar repaint
+          _this16.failedTiles.clear();
         }, {
           once: true
         });
@@ -24480,7 +24823,7 @@ var InternalMapVXMap = /*#__PURE__*/function (_Loggeable) {
   }, {
     key: "subscribeToFailedTiles",
     value: function subscribeToFailedTiles() {
-      var _this18 = this;
+      var _this17 = this;
       if (this.retryTimer) return;
 
       // Store bound functions for proper cleanup
@@ -24497,23 +24840,23 @@ var InternalMapVXMap = /*#__PURE__*/function (_Loggeable) {
         // exactly when tiles fail — gating on it would skip every tick during a
         // bad-network burst. The queue is left untouched so the tiles queued
         // mid-swap are still retried on the next tick.
-        if (!_this18.hasStyle()) {
+        if (!_this17.hasStyle()) {
           return;
         }
-        if (!_this18.map.getSource("indoorequal")) {
-          _this18.failedTiles.clear();
+        if (!_this17.map.getSource("indoorequal")) {
+          _this17.failedTiles.clear();
           return;
         }
-        var source = _this18.map.getSource("indoorequal");
+        var source = _this17.map.getSource("indoorequal");
         if (!source || source.type !== "vector") {
-          _this18.failedTiles.clear();
+          _this17.failedTiles.clear();
           return;
         }
 
         // Process tiles and remove invalid ones
         var tilesToRetry = [];
         var tilesToRemove = [];
-        _this18.failedTiles.forEach(function (tile) {
+        _this17.failedTiles.forEach(function (tile) {
           // Check if tile is still valid before attempting reload
           if (!tile || tile.state === "unloaded" || tile.state === "loading") {
             tilesToRemove.push(tile);
@@ -24531,14 +24874,14 @@ var InternalMapVXMap = /*#__PURE__*/function (_Loggeable) {
 
         // Remove invalid tiles from the set
         tilesToRemove.forEach(function (tile) {
-          return _this18.failedTiles["delete"](tile);
+          return _this17.failedTiles["delete"](tile);
         });
 
         // Attempt to reload valid failed tiles
         var now = Date.now();
         tilesToRetry.forEach(function (tile) {
-          var _this18$tileRetryStat;
-          var retry = (_this18$tileRetryStat = _this18.tileRetryState.get(tile)) !== null && _this18$tileRetryStat !== void 0 ? _this18$tileRetryStat : {
+          var _this17$tileRetryStat;
+          var retry = (_this17$tileRetryStat = _this17.tileRetryState.get(tile)) !== null && _this17$tileRetryStat !== void 0 ? _this17$tileRetryStat : {
             attempts: 0,
             nextAttemptAt: 0,
             pending: false
@@ -24549,16 +24892,16 @@ var InternalMapVXMap = /*#__PURE__*/function (_Loggeable) {
           var onFailure = function onFailure(error) {
             var attempts = retry.attempts + 1;
             if (attempts >= MAX_TILE_RETRIES) {
-              _this18.debugLog("Tile reload failed ".concat(attempts, " times, dropping it from the retry queue"), error);
-              _this18.failedTiles["delete"](tile);
-              _this18.tileRetryState["delete"](tile);
+              _this17.debugLog("Tile reload failed ".concat(attempts, " times, dropping it from the retry queue"), error);
+              _this17.failedTiles["delete"](tile);
+              _this17.tileRetryState["delete"](tile);
               return;
             }
 
             // Stay in the queue and try again once the backoff has elapsed.
             var backoffMs = TILE_RETRY_BASE_DELAY_MS * Math.pow(2, attempts - 1);
-            _this18.debugLog("Tile reload failed (attempt ".concat(attempts, "/").concat(MAX_TILE_RETRIES, "), retrying in ").concat(backoffMs, "ms"), error);
-            _this18.tileRetryState.set(tile, {
+            _this17.debugLog("Tile reload failed (attempt ".concat(attempts, "/").concat(MAX_TILE_RETRIES, "), retrying in ").concat(backoffMs, "ms"), error);
+            _this17.tileRetryState.set(tile, {
               attempts: attempts,
               nextAttemptAt: Date.now() + backoffMs,
               pending: false
@@ -24567,7 +24910,7 @@ var InternalMapVXMap = /*#__PURE__*/function (_Loggeable) {
           try {
             // Verify tile still exists and is in a retryable state
             if (tile && (tile.state === "errored" || tile.state === "expired")) {
-              _this18.tileRetryState.set(tile, map_objectSpread(map_objectSpread({}, retry), {}, {
+              _this17.tileRetryState.set(tile, map_objectSpread(map_objectSpread({}, retry), {}, {
                 pending: true
               }));
               // loadTile is async, so a rejection escapes this try/catch and has to be handled
@@ -24577,7 +24920,7 @@ var InternalMapVXMap = /*#__PURE__*/function (_Loggeable) {
                 // Loaded: forget the attempt history so a later failure starts from zero. The
                 // tile leaves the queue through the tilesToRemove branch on the next tick,
                 // once its state is no longer errored/expired.
-                _this18.tileRetryState["delete"](tile);
+                _this17.tileRetryState["delete"](tile);
               })["catch"](onFailure);
             }
           } catch (error) {