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

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.2";
 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) {
@@ -22574,9 +22791,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 +22811,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 +23126,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 +23345,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 +23357,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 +23382,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 +23392,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 +23470,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 +23968,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 +23989,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 +24005,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 +24037,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 +24057,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 +24073,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 +24496,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 +24520,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 +24616,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 +24627,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 +24704,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 +24721,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 +24755,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 +24773,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 +24791,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 +24801,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) {