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

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.3";
+var sentry_SDK_VERSION =  false ? 0 : "3.5.0";
 var DSN =  false ? 0 : "https://872f598f020e3cd73a0933b562d24c81@sentry.mapvx.app/5";
 
 /**
@@ -13057,6 +13057,20 @@ function hasLabelSize(entry) {
   return entry.labelSize !== undefined;
 }
 ;// ./src/domain/models/routeInstance.ts
+/**
+ * A floor switch the animation has decided on but not yet shown. It is applied
+ * together with the next step's geometry, once that geometry is on screen, so
+ * the marker never lands on a floor whose route line is not drawn yet.
+ * @group Routes
+ */
+
+/**
+ * Distances along the step being animated, in meters: `cumulative[i]` is the
+ * length up to `step.coordinates[i]`, `total` the full step length. The drawn
+ * part of the line is revealed as `traveled / total` via `line-progress`.
+ * @group Routes
+ */
+
 /**
  * Represents the conditions for the step animation.
  * @group Routes
@@ -13099,7 +13113,8 @@ function createRouteInstance(route) {
       }
     },
     animationStatus: "NO_ROUTE",
-    stepAnimationStatus: "NO_ROUTE"
+    stepAnimationStatus: "NO_ROUTE",
+    layerDrawConfigs: {}
   };
 }
 ;// ./src/utils/nav-functions.ts
@@ -13289,6 +13304,10 @@ function routeController_toConsumableArray(r) { return routeController_arrayWith
 function routeController_nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
 function routeController_iterableToArray(r) { if ("undefined" != typeof Symbol && null != r[Symbol.iterator] || null != r["@@iterator"]) return Array.from(r); }
 function routeController_arrayWithoutHoles(r) { if (Array.isArray(r)) return routeController_arrayLikeToArray(r); }
+function routeController_slicedToArray(r, e) { return routeController_arrayWithHoles(r) || routeController_iterableToArrayLimit(r, e) || routeController_unsupportedIterableToArray(r, e) || routeController_nonIterableRest(); }
+function routeController_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 routeController_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 routeController_arrayWithHoles(r) { if (Array.isArray(r)) return r; }
 function routeController_createForOfIteratorHelper(r, e) { var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (!t) { if (Array.isArray(r) || (t = routeController_unsupportedIterableToArray(r)) || e && r && "number" == typeof r.length) { t && (r = t); var _n = 0, F = function F() {}; return { s: F, n: function n() { return _n >= r.length ? { done: !0 } : { done: !1, value: r[_n++] }; }, e: function e(r) { throw r; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var o, a = !0, u = !1; return { s: function s() { t = t.call(r); }, n: function n() { var r = t.next(); return a = r.done, r; }, e: function e(r) { u = !0, o = r; }, f: function f() { try { a || null == t["return"] || t["return"](); } finally { if (u) throw o; } } }; }
 function routeController_unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return routeController_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) ? routeController_arrayLikeToArray(r, a) : void 0; } }
 function routeController_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; }
@@ -13314,6 +13333,27 @@ var DEFAULT_AUTO_FIT_PADDING = {
   left: 150
 };
 
+/**
+ * Longest a step waits for its line to be uploaded before animating anyway, so
+ * a stalled worker never freezes the route.
+ *
+ * A deadline rather than a frame count. `animateStep` is handed a `timestamp`
+ * already, and a frame count would stretch to three seconds or more on the
+ * 20-30 fps panels this wait exists for — the devices where a frozen marker at
+ * every step boundary is most visible.
+ */
+var MAX_SOURCE_WAIT_MS = 1500;
+
+/** Fully transparent: the part of a step line the reveal has not reached yet. */
+var TRANSPARENT_COLOR = "rgba(0, 0, 0, 0)";
+
+/**
+ * Width of the reveal cut-off, as a fraction of the step line. One texel of
+ * maplibre's 256-sample gradient ramp, i.e. the narrowest edge the ramp can
+ * actually resolve.
+ */
+var REVEAL_EDGE = 1 / 256;
+
 /**
  * Longest gap between two frames, in milliseconds, that still counts as
  * animation time.
@@ -13372,9 +13412,10 @@ 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.
+     * when a source asks it to. The CURRENT layer needs it to reveal the step
+     * line as the marker advances, and `preparePaintForLayer` emits a
+     * `line-progress` gradient for a GradientStyle on any of the three — without
+     * it, a consumer setting a gradient route style silently got no gradient.
      */
   }, {
     key: "addSourcesAndLayersForRoute",
@@ -13458,6 +13499,7 @@ var RouteController = /*#__PURE__*/function () {
         for (_iterator.s(); !(_step = _iterator.n()).done;) {
           var instance = _step.value;
           this.addSourcesAndLayersForRoute(instance);
+          this.restoreLayerPaint(instance);
         }
       } catch (err) {
         _iterator.e(err);
@@ -13467,6 +13509,38 @@ var RouteController = /*#__PURE__*/function () {
       this.syncRouteCollision();
     }
 
+    /**
+     * Re-apply the paint a style reload dropped.
+     *
+     * {@link addSourcesAndLayersForRoute} re-adds the layers with no paint at all, so
+     * without this the route keeps its geometry but loses its colors — and the CURRENT
+     * layer loses its `line-gradient`, which is the only thing hiding the part of the
+     * step the marker has not reached yet: the whole step would be drawn at once.
+     */
+  }, {
+    key: "restoreLayerPaint",
+    value: function restoreLayerPaint(instance) {
+      var _instance$revealFract;
+      for (var _i2 = 0, _Object$entries = Object.entries(instance.layerDrawConfigs); _i2 < _Object$entries.length; _i2++) {
+        var _Object$entries$_i = routeController_slicedToArray(_Object$entries[_i2], 2),
+          layerId = _Object$entries$_i[0],
+          drawConfig = _Object$entries$_i[1];
+        this.setLayerPaint(instance, layerId, drawConfig);
+      }
+      // `?? 0`: a step whose geometry was loaded while the style was mid-swap
+      // never got a reveal recorded, because `applyReveal` bails when there is no
+      // layer to paint. Leaving the gradient off entirely then draws the whole
+      // step at once in the traveled color, and the `awaitingSources` hold, the
+      // rotation phase, the floor-change wait and a pause can each postpone the
+      // frame that would correct it — indefinitely, in the case of a pause.
+      // Revealing nothing is the safe default.
+      var reveal = (_instance$revealFract = instance.revealFraction) !== null && _instance$revealFract !== void 0 ? _instance$revealFract : 0;
+      // Force the update: `applyReveal` skips a fraction it believes is already on
+      // the map, and the fresh layer has no gradient at all.
+      instance.revealFraction = undefined;
+      this.applyReveal(instance, reveal);
+    }
+
     /**
      * Recompute the GLB route-transparency collision path from all active routes and push it to the
      * map. Every polyline point of every step is tagged with the floor its segment is drawn on (same
@@ -13533,7 +13607,7 @@ var RouteController = /*#__PURE__*/function () {
       this.lastAddedRouteId = instance.id;
       this.addSourcesAndLayersForRoute(instance);
       this.setSourceData(instance, instance.aheadId, route.steps);
-      this.setLayerPaint(instance.aheadId, drawConfig);
+      this.setLayerPaint(instance, instance.aheadId, drawConfig);
       this.updateLayerFilter(instance.aheadId);
       this.syncRouteCollision();
     }
@@ -13659,7 +13733,7 @@ var RouteController = /*#__PURE__*/function () {
       aheadSource === null || aheadSource === void 0 || aheadSource.setData(instance.aheadSourceData);
 
       // Ensure paint is set on the behind layer
-      this.setLayerPaint(instance.behindId, behindDrawConfig);
+      this.setLayerPaint(instance, instance.behindId, behindDrawConfig);
       this.updateLayerFilter(instance.behindId);
       this.updateLayerFilter(instance.aheadId);
     }
@@ -13705,57 +13779,222 @@ var RouteController = /*#__PURE__*/function () {
         source === null || source === void 0 || source.setData(instance.behindSourceData);
       }
     }
+
+    /**
+     * Upload the whole polyline of `step` as the CURRENT feature and reset its
+     * reveal to zero. The line is then drawn progressively by moving a
+     * `line-progress` cut-off (see {@link applyReveal}) instead of re-uploading a
+     * growing geometry every frame: a paint change is applied synchronously, while
+     * a `setData` goes through the worker and lands several frames after the DOM
+     * marker already moved — on a slow device the marker visibly ran ahead of
+     * its line.
+     */
   }, {
-    key: "setCurrentSourceData",
-    value: function setCurrentSourceData(instance, step) {
+    key: "loadStepGeometry",
+    value: function loadStepGeometry(instance, step) {
+      var _step$coordinates;
       instance.currentSourceData.properties = {
         floor_key: this.getFloorKeyForStep(step)
       };
-      var coordinate = step === null || step === void 0 ? void 0 : step.coordinates[0];
-      if (coordinate != null) {
-        instance.currentSourceData.geometry.coordinates = [[coordinate.lng, coordinate.lat]];
-      } else {
-        instance.currentSourceData.geometry.coordinates = [];
-      }
+      var coordinates = (_step$coordinates = step === null || step === void 0 ? void 0 : step.coordinates) !== null && _step$coordinates !== void 0 ? _step$coordinates : [];
+      // A LineString needs at least two positions; anything shorter draws nothing.
+      instance.currentSourceData.geometry.coordinates = coordinates.length >= 2 ? coordinates.map(function (c) {
+        return [c.lng, c.lat];
+      }) : [];
+      var cumulative = [0];
+      for (var i = 1; i < coordinates.length; i++) {
+        cumulative.push(cumulative[i - 1] + NavFunctions.distance(coordinates[i - 1], coordinates[i]));
+      }
+      instance.stepMetrics = {
+        cumulative: cumulative,
+        total: cumulative[cumulative.length - 1]
+      };
+      instance.revealFraction = undefined;
+      this.applyReveal(instance, 0);
       var source = this.map.getSource(instance.currentId);
       source === null || source === void 0 || source.setData(instance.currentSourceData);
     }
+
+    /**
+     * Fraction of the step line up to `coordinatesIndex` plus `extraMeters` along
+     * the following segment.
+     */
+  }, {
+    key: "fractionAlongStep",
+    value: function fractionAlongStep(instance, coordinatesIndex, extraMeters) {
+      var _metrics$cumulative$i;
+      var metrics = instance.stepMetrics;
+      if (!metrics || metrics.total <= 0) return 1;
+      var index = Math.min(coordinatesIndex, metrics.cumulative.length - 1);
+      return (((_metrics$cumulative$i = metrics.cumulative[index]) !== null && _metrics$cumulative$i !== void 0 ? _metrics$cumulative$i : 0) + extraMeters) / metrics.total;
+    }
+
+    /**
+     * Show the first `fraction` of the CURRENT step line: a `line-gradient` step on
+     * `line-progress` that turns transparent past the cut-off. MapLibre treats it
+     * as a plain paint update (a 256px ramp re-rendered on the next draw), so the
+     * line head and the marker move in the same frame.
+     *
+     * The paint is set with `validate: false`: this runs on every animation frame and
+     * the expression is built here, not taken from a consumer, so re-parsing and
+     * re-validating it 60 times a second is pure overhead on a totem-class device.
+     */
+  }, {
+    key: "applyReveal",
+    value: function applyReveal(instance, fraction) {
+      var color = instance.currentLineColor;
+      if (color === undefined) return;
+      var clamped = Math.max(0, Math.min(1, fraction));
+      if (instance.revealFraction === clamped) return;
+      // A full style swap removes the route's sources and layers and re-adds them a
+      // few frames later. Painting a layer that is not there fires a MapLibre error on
+      // every animation frame; `revealFraction` is deliberately left untouched so
+      // `restoreLayerPaint` re-applies this reveal once the layers are back.
+      if (!this.hasSource(instance.currentId)) return;
+      instance.revealFraction = clamped;
+      this.map.setPaintProperty(instance.currentId, "line-gradient", this.revealGradient(color, clamped), {
+        validate: false
+      });
+    }
+
+    /**
+     * The `line-gradient` that shows the first `fraction` of the step line and
+     * nothing after it.
+     *
+     * Deliberately built on `interpolate` rather than the `step` this reads like.
+     * `LineStyleLayer._handleSpecialPaintPropertyUpdate` sets `stepInterpolant`
+     * for any `step` root, and `stepInterpolant` swaps the gradient ramp from a
+     * fixed 256 texels to
+     * `clamp(nextPowerOfTwo(lineLength * 1024 * potentialOverzoom), 256, maxTextureSize)`
+     * — 4096 to 16384 in practice. Every `setPaintProperty` here bumps
+     * `gradientVersion`, so that ramp would be re-rendered and re-uploaded once
+     * per visible tile per frame, which is the opposite of what this reveal is
+     * for. An `interpolate` root keeps the ramp at 256 texels; the cost is a
+     * one-texel soft edge at the cut-off instead of a hard one.
+     */
+  }, {
+    key: "revealGradient",
+    value: function revealGradient(color, fraction) {
+      if (fraction <= 0) return TRANSPARENT_COLOR;
+      // `line-progress` reaches exactly 1 at the last vertex, so a fully revealed
+      // line is just the line's own color, with no cut-off to express.
+      if (fraction >= 1) return color;
+      return ["interpolate", ["linear"], ["line-progress"], fraction, color,
+      // `interpolate` clamps to its domain, so one texel past the cut-off is
+      // enough to make everything beyond it transparent.
+      Math.min(fraction + REVEAL_EDGE, 1), TRANSPARENT_COLOR];
+    }
+
+    /**
+     * Whether the route's three sources have finished uploading their latest
+     * data, i.e. what is on screen matches what was last set. Maps without
+     * `isSourceLoaded` (test doubles) count as ready.
+     */
+  }, {
+    key: "stepSourcesReady",
+    value: function stepSourcesReady(instance) {
+      try {
+        // CURRENT alone. It carries the step being drawn, which is what has to be
+        // on screen for the line, the floor and the marker to change together.
+        // AHEAD and BEHIND hold the whole route and are rewritten in full at every
+        // boundary, so waiting on them made the freeze at each step scale with the
+        // route's total length rather than the step's — and on a long route that
+        // is the difference between imperceptible and hitting the deadline.
+        if (!this.map.getSource(instance.currentId)) return false;
+        return this.map.isSourceLoaded(instance.currentId) !== false;
+      } catch (_unused3) {
+        // The map is briefly style-less mid-swap and `getSource` throws there. This runs
+        // inside a `requestAnimationFrame` callback, where an exception would kill the
+        // animation loop for good, so treat it as "not ready yet" instead.
+        return false;
+      }
+    }
+
+    /** Whether `sourceId` is currently on the map (false while a style swap is in flight). */
+  }, {
+    key: "hasSource",
+    value: function hasSource(sourceId) {
+      try {
+        return this.map.getSource(sourceId) != null;
+      } catch (_unused4) {
+        return false;
+      }
+    }
+
+    /**
+     * Apply a floor switch that was deferred until the next step's line was
+     * uploaded, then put the marker where that step starts. Floor, line and
+     * marker change in the same frame.
+     */
+  }, {
+    key: "applyPendingFloor",
+    value: function applyPendingFloor(instance) {
+      var _instance$conditions;
+      var pending = (_instance$conditions = instance.conditions) === null || _instance$conditions === void 0 ? void 0 : _instance$conditions.pendingFloor;
+      if (!pending || !instance.conditions) return;
+      instance.conditions.pendingFloor = undefined;
+      this.updatePlaceFloorForRouting(instance, pending.placeId, pending.floorKey);
+      this.setMarkerLngLat(instance, pending.location);
+    }
   }, {
     key: "setLayerPaint",
-    value: function setLayerPaint(layerId, drawConfig) {
+    value: function setLayerPaint(instance, layerId, drawConfig) {
+      instance.layerDrawConfigs[layerId] = drawConfig;
       var paintConfig = this.preparePaintForLayer(drawConfig);
       for (var property in paintConfig) {
         this.map.setPaintProperty(layerId, property, paintConfig[property]);
       }
     }
+
+    /**
+     * Set the paint the step line is drawn with, resolving its color once.
+     *
+     * See {@link RouteInstance.currentLineColor}: resolving a gradient allocates
+     * and can throw, and the reveal would otherwise redo it on every frame.
+     */
+  }, {
+    key: "setCurrentDrawConfig",
+    value: function setCurrentDrawConfig(instance, drawConfig) {
+      instance.currentDrawConfig = drawConfig;
+      instance.currentLineColor = this.lineColorExpression(drawConfig);
+    }
+
+    /** The color of a route line: a solid color or a `line-progress` gradient ramp. */
   }, {
-    key: "preparePaintForLayer",
-    value: function preparePaintForLayer(drawConfig) {
+    key: "lineColorExpression",
+    value: function lineColorExpression(drawConfig) {
       if ("color" in drawConfig.routeStyle) {
         // Check for propriety unique to SolidStyle
+        return drawConfig.routeStyle.color;
+      }
+      // Is GradienteStyle
+      var _drawConfig$routeStyl = drawConfig.routeStyle,
+        colors = _drawConfig$routeStyl.colors,
+        positions = _drawConfig$routeStyl.positions;
+      var positionsToUse = positions !== null && positions !== void 0 ? positions : createPositionsForStops(colors.length);
+      if (positionsToUse.length !== colors.length) {
+        throw new Error("Error: position array has different length than colors array");
+      }
+      var stops = createStops(positionsToUse, colors);
+      return ["interpolate", ["linear"], ["line-progress"]].concat(routeController_toConsumableArray(stops));
+    }
+  }, {
+    key: "preparePaintForLayer",
+    value: function preparePaintForLayer(drawConfig) {
+      var color = this.lineColorExpression(drawConfig);
+      if (typeof color === "string") {
         return {
-          "line-color": drawConfig.routeStyle.color,
+          "line-color": color,
           "line-gradient": null,
           // null to unset the existing value
           "line-width": drawConfig.polylineWidth
         };
-      } else {
-        // Is GradienteStyle
-        var _drawConfig$routeStyl = drawConfig.routeStyle,
-          colors = _drawConfig$routeStyl.colors,
-          positions = _drawConfig$routeStyl.positions;
-        var positionsToUse = positions !== null && positions !== void 0 ? positions : createPositionsForStops(colors.length);
-        if (positionsToUse.length !== colors.length) {
-          throw new Error("Error: position array has different length than colors array");
-        }
-        var stops = createStops(positionsToUse, colors);
-        var gradient = ["interpolate", ["linear"], ["line-progress"]].concat(routeController_toConsumableArray(stops));
-        return {
-          "line-color": null,
-          "line-gradient": gradient,
-          "line-width": drawConfig.polylineWidth
-        };
       }
+      return {
+        "line-color": null,
+        "line-gradient": color,
+        "line-width": drawConfig.polylineWidth
+      };
     }
 
     /**
@@ -13948,13 +14187,11 @@ var RouteController = /*#__PURE__*/function () {
       this.updatePlaceFloorForRouting(instance, firstStep.startInsidePlace, firstStep.startInsideFloor);
       this.setSourceData(instance, instance.aheadId, route.steps);
       this.setSourceData(instance, instance.behindId, []);
-      instance.currentSourceData.properties = {
-        floor_key: this.getFloorKeyForStep(firstStep)
-      };
-      instance.currentSourceData.geometry.coordinates = [[firstStep.coordinates[0].lng, firstStep.coordinates[0].lat]];
-      this.setLayerPaint(instance.aheadId, drawConfig.aheadConfig);
-      this.setLayerPaint(instance.behindId, drawConfig.behindConfig);
-      this.setLayerPaint(instance.currentId, drawConfig.behindConfig);
+      this.setLayerPaint(instance, instance.aheadId, drawConfig.aheadConfig);
+      this.setLayerPaint(instance, instance.behindId, drawConfig.behindConfig);
+      this.setLayerPaint(instance, instance.currentId, drawConfig.behindConfig);
+      this.setCurrentDrawConfig(instance, drawConfig.behindConfig);
+      this.loadStepGeometry(instance, firstStep);
       instance.animationConfig = animationConfig;
       instance.routeMarker = new MarkerAttribute({
         coordinate: firstStep.startLocation,
@@ -13991,6 +14228,7 @@ var RouteController = /*#__PURE__*/function () {
         progress: 0,
         resetTime: false,
         waitStartTime: undefined,
+        awaitingSources: true,
         animationId: requestAnimationFrame(function (time) {
           return _this2.animateStep(time, instance);
         }),
@@ -14004,10 +14242,30 @@ var RouteController = /*#__PURE__*/function () {
       });
       this.syncRouteCollision();
     }
+
+    /**
+     * Tear one route instance down.
+     *
+     * `applyPendingFloorChange` decides what happens to a floor switch this
+     * instance had decided on but not yet shown. Removing a single route mid-walk
+     * applies it: the consumer may be removing the route from the step callback,
+     * and dropping the switch would leave the map on the floor the route has
+     * already left. Clearing every route does not — a floor switch is a visible
+     * camera and filter change plus an `onFloorChange` to the consumer, and
+     * `removeAllRoutes` is what teardown calls, where moving the map is
+     * a side effect nobody asked for and a consumer that re-enters from
+     * `onFloorChange` re-enters teardown.
+     */
   }, {
     key: "clearRouteInstance",
     value: function clearRouteInstance(instance) {
       var _instance$routeMarker6;
+      var applyPendingFloorChange = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
+      if (applyPendingFloorChange) {
+        this.applyPendingFloor(instance);
+      } else if (instance.conditions) {
+        instance.conditions.pendingFloor = undefined;
+      }
       (_instance$routeMarker6 = instance.routeMarker) === null || _instance$routeMarker6 === void 0 || _instance$routeMarker6.remove();
       instance.routeMarker = undefined;
       this.setSourceData(instance, instance.aheadId, []);
@@ -14055,7 +14313,7 @@ var RouteController = /*#__PURE__*/function () {
       try {
         for (_iterator8.s(); !(_step8 = _iterator8.n()).done;) {
           var instance = _step8.value;
-          this.clearRouteInstance(instance);
+          this.clearRouteInstance(instance, false);
           this.removeSourcesAndLayersForRoute(instance);
         }
       } catch (err) {
@@ -14152,12 +14410,7 @@ var RouteController = /*#__PURE__*/function () {
       this.updatePlaceFloorForRouting(instance, firstStep.startInsidePlace, firstStep.startInsideFloor);
       this.setSourceData(instance, instance.aheadId, instance.route.steps);
       this.setSourceData(instance, instance.behindId, []);
-      instance.currentSourceData.properties = {
-        floor_key: this.getFloorKeyForStep(firstStep)
-      };
-      instance.currentSourceData.geometry.coordinates = [[firstStep.coordinates[0].lng, firstStep.coordinates[0].lat]];
-      var source = this.map.getSource(instance.currentId);
-      source === null || source === void 0 || source.setData(instance.currentSourceData);
+      this.loadStepGeometry(instance, firstStep);
       (_this$setMarkerRotati = this.setMarkerRotation(instance, 0)) === null || _this$setMarkerRotati === void 0 || _this$setMarkerRotati.setLngLat(firstStep.startLocation).addTo(this.map);
 
       // Auto-fit by place if enabled
@@ -14189,6 +14442,7 @@ var RouteController = /*#__PURE__*/function () {
         progress: 0,
         resetTime: false,
         waitStartTime: undefined,
+        awaitingSources: true,
         animationId: requestAnimationFrame(function (time) {
           return _this4.animateStep(time, instance);
         }),
@@ -14240,10 +14494,11 @@ var RouteController = /*#__PURE__*/function () {
       this.updatePlaceFloorForRouting(instance, firstStep.startInsidePlace, firstStep.startInsideFloor);
       this.setSourceData(instance, instance.aheadId, route.steps);
       this.setSourceData(instance, instance.behindId, []);
-      this.setCurrentSourceData(instance, firstStep);
-      this.setLayerPaint(instance.aheadId, drawConfig.aheadConfig);
-      this.setLayerPaint(instance.behindId, drawConfig.behindConfig);
-      this.setLayerPaint(instance.currentId, drawConfig.behindConfig);
+      this.setLayerPaint(instance, instance.aheadId, drawConfig.aheadConfig);
+      this.setLayerPaint(instance, instance.behindId, drawConfig.behindConfig);
+      this.setLayerPaint(instance, instance.currentId, drawConfig.behindConfig);
+      this.setCurrentDrawConfig(instance, drawConfig.behindConfig);
+      this.loadStepGeometry(instance, firstStep);
       instance.animationConfig = animationConfig;
       instance.routeMarker = new MarkerAttribute({
         coordinate: firstStep.startLocation,
@@ -14293,7 +14548,7 @@ var RouteController = /*#__PURE__*/function () {
           var step = instance.route.steps[index];
           _this5.setSourceData(instance, instance.behindId, behindSteps);
           _this5.setSourceData(instance, instance.aheadId, aheadSteps);
-          _this5.setCurrentSourceData(instance, step);
+          _this5.loadStepGeometry(instance, step);
           instance.conditions.index = index;
 
           // The status settles before either callback, as everywhere else: no frame
@@ -14406,7 +14661,7 @@ var RouteController = /*#__PURE__*/function () {
         var step = instance.route.steps[index];
         this.setSourceData(instance, instance.behindId, behindSteps);
         this.setSourceData(instance, instance.aheadId, aheadSteps);
-        this.setCurrentSourceData(instance, step);
+        this.loadStepGeometry(instance, step);
         if (step.startInsideFloor != step.endInsideFloor && step.startInsideFloor) {
           this.updatePlaceFloorForRouting(instance, step.startInsidePlace, step.startInsideFloor);
         }
@@ -14484,19 +14739,40 @@ var RouteController = /*#__PURE__*/function () {
       var aheadSteps = instance.route.steps.slice(index + 1);
       this.setSourceData(instance, instance.behindId, behindSteps);
       this.setSourceData(instance, instance.aheadId, aheadSteps);
-      instance.currentSourceData.geometry.coordinates = [];
       if (index + 1 < instance.route.steps.length) {
-        var _instance$animationCo9, _instance$animationCo1, _instance$animationCo10;
+        var _instance$animationCo9;
         var step = instance.route.steps[index + 1];
-        instance.currentSourceData.geometry.coordinates.push([step.startLocation.lng, step.startLocation.lat]);
-        instance.currentSourceData.properties = {
-          floor_key: this.getFloorKeyForStep(step)
-        };
+        this.loadStepGeometry(instance, step);
         instance.conditions.startTime = timestamp;
         instance.conditions.index++;
         instance.conditions.coordinatesIndex = 0;
         instance.conditions.progress = 0;
         instance.conditions.rotatingIcon = true;
+        // The step starts once its line (and the updated behind/ahead lines) are
+        // on screen; a floor switch decided by the previous step, or implied by a
+        // step that starts on another floor, is applied at that same moment.
+        instance.conditions.awaitingSources = true;
+        instance.conditions.awaitDeadline = undefined;
+        // Compared against the floor the PREVIOUS step ended on, not the map's current
+        // floor: the route decides its own floor changes, so a user who browsed to
+        // another floor mid-animation is not yanked back at every step boundary.
+        var previousStep = instance.route.steps[index];
+        // Against the previous step's *effective* floor, not its raw
+        // `endInsideFloor`. Venue data routinely carries `startInsideFloor` with
+        // no `endInsideFloor` — `getFloorKeyForStep` exists to resolve exactly
+        // that shape — and comparing against the raw field made every boundary
+        // on such a route look like a floor change: the map moved, the consumer
+        // got an `onFloorChange`, a settle poll ran and the step callback was
+        // deferred a frame, at each step. A user who had browsed to another floor
+        // was yanked back, which is what the deferral above is meant to avoid.
+        var previousFloor = this.getFloorKeyForStep(previousStep);
+        if (!instance.conditions.pendingFloor && step.startInsideFloor && step.startInsideFloor !== previousFloor) {
+          instance.conditions.pendingFloor = {
+            placeId: step.startInsidePlace,
+            floorKey: step.startInsideFloor,
+            location: step.startLocation
+          };
+        }
         if (!compareLatLng(instance.route.steps[index].endLocation, step.startLocation)) instance.conditions.nextFloorFirstStepIndex = index + 2;
         instance.conditions.animationId = requestAnimationFrame(function (time) {
           return _this7.animateStep(time, instance);
@@ -14514,12 +14790,30 @@ var RouteController = /*#__PURE__*/function () {
             this.mapvxMap.fitRouteByPlace(instance.route, stepPlaceId, fitOptions);
           }
         }
-        (_instance$animationCo1 = (_instance$animationCo10 = instance.animationConfig).callBack) === null || _instance$animationCo1 === void 0 || _instance$animationCo1.call(_instance$animationCo10, {
-          isFinished: false,
-          step: instance.route.steps[index + 1]
-        });
+        if (instance.conditions.pendingFloor) {
+          // The switch lands a few frames later, in `animateStep`. Firing the callback
+          // now would report the step while the map is still on the previous floor —
+          // and a consumer that stops the route from it would drop the switch entirely.
+          instance.conditions.pendingStepCallback = step;
+        } else {
+          var _instance$animationCo1, _instance$animationCo10;
+          (_instance$animationCo1 = (_instance$animationCo10 = instance.animationConfig).callBack) === null || _instance$animationCo1 === void 0 || _instance$animationCo1.call(_instance$animationCo10, {
+            isFinished: false,
+            step: step
+          });
+        }
       } else {
         var _instance$animationCo11, _instance$animationCo12;
+        // finishes animation
+        this.applyPendingFloor(instance);
+        // That reached `onFloorChange`, and a consumer removing the route from it
+        // has already had `clearRouteInstance` null `animationConfig` and settle
+        // the status at "NO_ROUTE". Both lines below write through it — the
+        // `?.` is on `callBack`, not on `animationConfig` — so without this the
+        // branch threw a TypeError out of the rAF callback, and overwrote a
+        // finished instance's status with "FINISHED". `animateStep`'s release
+        // path takes the same guard after the same call.
+        if (instance.conditions == null || instance.animationConfig == null) return;
         // 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
@@ -14542,17 +14836,17 @@ var RouteController = /*#__PURE__*/function () {
       if (instance.conditions == null || instance.animationConfig == null || instance.route == null) {
         throw new Error("Error: conditions and animationConfig should not be null at this point");
       }
-      var _instance$conditions = instance.conditions,
-        startTime = _instance$conditions.startTime,
-        resetTime = _instance$conditions.resetTime,
-        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;
+        startTime = _instance$conditions2.startTime,
+        resetTime = _instance$conditions2.resetTime,
+        progress = _instance$conditions2.progress,
+        waitStartTime = _instance$conditions2.waitStartTime;
+      var _instance$conditions3 = instance.conditions,
+        coordinatesIndex = _instance$conditions3.coordinatesIndex,
+        iconRotation = _instance$conditions3.iconRotation,
+        index = _instance$conditions3.index,
+        onFinish = _instance$conditions3.onFinish,
+        rotatingIcon = _instance$conditions3.rotatingIcon;
       var _instance$animationCo13 = instance.animationConfig,
         stepTime = _instance$animationCo13.stepTime,
         minimumSpeed = _instance$animationCo13.minimumSpeed,
@@ -14571,6 +14865,62 @@ var RouteController = /*#__PURE__*/function () {
         });
         return;
       }
+      if (instance.conditions.awaitingSources) {
+        var _instance$conditions$;
+        var deadline = (_instance$conditions$ = instance.conditions.awaitDeadline) !== null && _instance$conditions$ !== void 0 ? _instance$conditions$ : timestamp + MAX_SOURCE_WAIT_MS;
+        // The deadline is wall clock, and this block returns before the frame-gap
+        // branch below can ever run, so it needs that branch's shift applied here
+        // — the same one `waitStartTime` gets, for the same reason. A backgrounded
+        // tab or a pause longer than the deadline would otherwise release the step
+        // on the first frame back without once asking whether its line is on
+        // screen, which is the desync the wait exists to prevent.
+        if (previousFrameTime != null && timestamp - previousFrameTime > MAX_FRAME_GAP_MS) {
+          deadline += timestamp - previousFrameTime;
+        }
+        instance.conditions.awaitDeadline = deadline;
+        if (!this.stepSourcesReady(instance) && timestamp < deadline) {
+          // Hold the clock: the step starts when its line can be seen.
+          instance.conditions.startTime = timestamp;
+          instance.conditions.animationId = requestAnimationFrame(function (time) {
+            return _this8.animateStep(time, instance);
+          });
+          return;
+        }
+        instance.conditions.awaitingSources = false;
+        instance.conditions.awaitDeadline = undefined;
+        instance.conditions.startTime = timestamp;
+        var heldStep = instance.conditions.pendingStepCallback;
+        instance.conditions.pendingStepCallback = undefined;
+
+        // The frame that releases the wait draws nothing: it queues its successor
+        // and hands control to the consumer, and that successor does the drawing.
+        //
+        // The queue has to come first. Both calls below reach consumer code —
+        // `applyPendingFloor` through the `onFloorChange` handler, and the held
+        // step callback directly — and a `pauseAnimation()` from either one
+        // cancels whatever id sits in `conditions.animationId`. While that id was
+        // the frame already executing, cancelling it did nothing: the loop kept
+        // running under a `PAUSED` status, and the matching `resumeAnimation()`
+        // passed its status guard and installed a second concurrent rAF chain on
+        // the same instance. Queueing first gives that pause a pending frame to
+        // cancel, and returning afterwards means this frame does not queue a
+        // replacement for the one it just cancelled.
+        instance.conditions.animationId = requestAnimationFrame(function (time) {
+          return _this8.animateStep(time, instance);
+        });
+        this.applyPendingFloor(instance);
+        // `onFloorChange` may have removed the route; everything below reads
+        // `conditions`.
+        if (instance.conditions == null || instance.animationConfig == null) return;
+        if (heldStep) {
+          var _instance$animationCo14, _instance$animationCo15;
+          (_instance$animationCo14 = (_instance$animationCo15 = instance.animationConfig).callBack) === null || _instance$animationCo14 === void 0 || _instance$animationCo14.call(_instance$animationCo15, {
+            isFinished: false,
+            step: heldStep
+          });
+        }
+        return;
+      }
       if (resetTime) {
         startTime = timestamp - progress;
         instance.conditions.startTime = startTime;
@@ -14644,7 +14994,16 @@ var RouteController = /*#__PURE__*/function () {
             return;
           }
         }
-        if (step.startInsideFloor !== step.endInsideFloor) {
+
+        // There has to be a floor to switch *to*. An absent `startInsideFloor` is
+        // meaningful — that is a step entering the building from outdoors — but an
+        // absent `endInsideFloor` is not: venue data routinely omits it on a step
+        // that does not change floor, and reading that as "different" made every
+        // such step stall for `changeFloorTime` and then queue a switch whose
+        // `floorKey` was `undefined`. `updatePlaceFloorForRouting` drops that
+        // silently, but not before it has occupied the `pendingFloor` slot the
+        // step boundary needed for a real one.
+        if (step.endInsideFloor && step.startInsideFloor !== step.endInsideFloor) {
           if (waitStartTime == null) {
             instance.conditions.waitStartTime = timestamp;
             instance.conditions.animationId = requestAnimationFrame(function (time) {
@@ -14658,9 +15017,20 @@ var RouteController = /*#__PURE__*/function () {
             });
             return;
           } else {
-            this.updatePlaceFloorForRouting(instance, step.endInsidePlace, step.endInsideFloor);
-            this.setMarkerLngLat(instance, step.endLocation);
             instance.conditions.waitStartTime = undefined;
+            if (instance.conditions.isStepByStep) {
+              // Step-by-step mode is user-driven: switch right away, as before.
+              this.updatePlaceFloorForRouting(instance, step.endInsidePlace, step.endInsideFloor);
+              this.setMarkerLngLat(instance, step.endLocation);
+            } else {
+              // Defer the switch until the next step's line is uploaded, so floor,
+              // line and marker change together (see applyPendingFloor).
+              instance.conditions.pendingFloor = {
+                placeId: step.endInsidePlace,
+                floorKey: step.endInsideFloor,
+                location: step.endLocation
+              };
+            }
             onFinish === null || onFinish === void 0 || onFinish(timestamp);
             return;
           }
@@ -14677,23 +15047,17 @@ var RouteController = /*#__PURE__*/function () {
         // 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.
+        //
+        // The step's whole polyline is already uploaded (see `loadStepGeometry`),
+        // so a frame commits nothing: it only moves the reveal cut-off, which is
+        // the same distance that moves the marker.
         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);
+            // `segmentEnd` is the step's last vertex: reveal the line in full.
+            this.applyReveal(instance, this.fractionAlongStep(instance, instance.conditions.coordinatesIndex + 1, 0));
             onFinish === null || onFinish === void 0 || onFinish(timestamp);
             return;
           }
@@ -14724,7 +15088,8 @@ var RouteController = /*#__PURE__*/function () {
               instance.conditions.rotatingIcon = true;
               instance.conditions.startTime = timestamp;
               instance.conditions.progress = 0;
-              this.flushCurrentSourceData(instance);
+              // The marker stops on the vertex it turns about, so the line does too.
+              this.applyReveal(instance, this.fractionAlongStep(instance, instance.conditions.coordinatesIndex, 0));
               instance.conditions.animationId = requestAnimationFrame(function (time) {
                 return _this8.animateStep(time, instance);
               });
@@ -14738,10 +15103,12 @@ var RouteController = /*#__PURE__*/function () {
           segmentEnd = next;
           segmentDistance = NavFunctions.distance(segmentStart, segmentEnd);
         }
-        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);
+        var traveled = Math.min(speed * progressInSeconds, segmentDistance);
+        var point = segmentDistance === 0 ? segmentEnd : NavFunctions.intermediatePointBetween(segmentStart, segmentEnd, traveled / segmentDistance);
+        // The same distance drives the reveal cut-off and the marker, and the
+        // reveal is a synchronous paint update rather than a `setData` that lands
+        // several frames later, so the two cannot drift apart.
+        this.applyReveal(instance, this.fractionAlongStep(instance, instance.conditions.coordinatesIndex, traveled));
         this.setMarkerLngLat(instance, point);
         // Only when it has genuinely left the DOM. maplibre's `Marker.addTo`
         // opens with `remove()`, so re-attaching an attached marker tears down
@@ -14769,26 +15136,11 @@ 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) {
-      var _instance$conditions3, _instance$routeMarker9;
-      if ((_instance$conditions3 = instance.conditions) !== null && _instance$conditions3 !== void 0 && _instance$conditions3.isStepByStep) {
+      var _instance$conditions4, _instance$routeMarker9;
+      if ((_instance$conditions4 = instance.conditions) !== null && _instance$conditions4 !== void 0 && _instance$conditions4.isStepByStep) {
         this.cameraFollow(instance, point);
       }
       (_instance$routeMarker9 = instance.routeMarker) === null || _instance$routeMarker9 === void 0 || _instance$routeMarker9.setLngLat(point);
@@ -14796,11 +15148,11 @@ var RouteController = /*#__PURE__*/function () {
   }, {
     key: "setMarkerRotation",
     value: function setMarkerRotation(instance, angle) {
-      var _instance$conditions4, _instance$animationCo14, _instance$routeMarker1;
-      if ((_instance$conditions4 = instance.conditions) !== null && _instance$conditions4 !== void 0 && _instance$conditions4.isStepByStep && !((_instance$animationCo14 = instance.animationConfig) !== null && _instance$animationCo14 !== void 0 && _instance$animationCo14.keepFixedBearing)) {
-        var _instance$animationCo15, _instance$routeMarker0;
+      var _instance$conditions5, _instance$animationCo16, _instance$routeMarker1;
+      if ((_instance$conditions5 = instance.conditions) !== null && _instance$conditions5 !== void 0 && _instance$conditions5.isStepByStep && !((_instance$animationCo16 = instance.animationConfig) !== null && _instance$animationCo16 !== void 0 && _instance$animationCo16.keepFixedBearing)) {
+        var _instance$animationCo17, _instance$routeMarker0;
         this.mapvxMap.updateCamera({
-          duration: (_instance$animationCo15 = instance.animationConfig) === null || _instance$animationCo15 === void 0 ? void 0 : _instance$animationCo15.iconRotationTime,
+          duration: (_instance$animationCo17 = instance.animationConfig) === null || _instance$animationCo17 === void 0 ? void 0 : _instance$animationCo17.iconRotationTime,
           animate: true,
           bearing: angle,
           center: (_instance$routeMarker0 = instance.routeMarker) === null || _instance$routeMarker0 === void 0 ? void 0 : _instance$routeMarker0.getLngLat()
@@ -14818,12 +15170,12 @@ var RouteController = /*#__PURE__*/function () {
   }, {
     key: "cameraFollow",
     value: function cameraFollow(instance, point) {
-      var _instance$animationCo16, _instance$animationCo17, _instance$animationCo18, _instance$routeMarker11;
-      var keepFixedBearing = (_instance$animationCo16 = (_instance$animationCo17 = instance.animationConfig) === null || _instance$animationCo17 === void 0 ? void 0 : _instance$animationCo17.keepFixedBearing) !== null && _instance$animationCo16 !== void 0 ? _instance$animationCo16 : false;
+      var _instance$animationCo18, _instance$animationCo19, _instance$animationCo20, _instance$routeMarker11;
+      var keepFixedBearing = (_instance$animationCo18 = (_instance$animationCo19 = instance.animationConfig) === null || _instance$animationCo19 === void 0 ? void 0 : _instance$animationCo19.keepFixedBearing) !== null && _instance$animationCo18 !== void 0 ? _instance$animationCo18 : false;
       this.mapvxMap.updateCamera(routeController_objectSpread({
         center: point,
         animate: true,
-        duration: (_instance$animationCo18 = instance.animationConfig) === null || _instance$animationCo18 === void 0 ? void 0 : _instance$animationCo18.iconRotationTime
+        duration: (_instance$animationCo20 = instance.animationConfig) === null || _instance$animationCo20 === void 0 ? void 0 : _instance$animationCo20.iconRotationTime
       }, keepFixedBearing ? {} : {
         bearing: (_instance$routeMarker11 = instance.routeMarker) === null || _instance$routeMarker11 === void 0 ? void 0 : _instance$routeMarker11.getRotation()
       }));
@@ -21753,6 +22105,13 @@ function refineCameraForPitch(transform, coordinates, initial, params) {
   return best;
 }
 ;// ./src/map/mapInteractionOptions.ts
+/**
+ * Highest pitch MapLibre accepts for `minPitch`/`maxPitch` (it rejects anything
+ * above 180); a locked pitch is clamped to it so the lock can never contradict
+ * the {@link MapConfig.pitch} the map was built with.
+ */
+var MAX_LOCKED_PITCH = 180;
+
 /**
  * Subset of MapLibre {@link MapOptions} that can be derived from the interaction
  * restriction flags on {@link MapConfig}.
@@ -21774,6 +22133,10 @@ function refineCameraForPitch(transform, coordinates, initial, params) {
  * pinch-to-zoom, so it is handled separately after construction — see
  * {@link shouldDisableTouchRotation}.
  *
+ * `pitchEnabled: false` freezes the tilt: the pitch gestures are disabled and
+ * `minPitch`/`maxPitch` are pinned to {@link MapConfig.pitch}, so neither the
+ * user nor a later camera update can change it.
+ *
  * @internal
  */
 function buildInteractionOptions(mapConfig) {
@@ -21789,6 +22152,14 @@ function buildInteractionOptions(mapConfig) {
     options.dragRotate = false;
     options.pitchWithRotate = false;
   }
+  if (mapConfig.pitchEnabled === false) {
+    var _mapConfig$pitch;
+    var lockedPitch = Math.min(Math.max((_mapConfig$pitch = mapConfig.pitch) !== null && _mapConfig$pitch !== void 0 ? _mapConfig$pitch : 0, 0), MAX_LOCKED_PITCH);
+    options.touchPitch = false;
+    options.pitchWithRotate = false;
+    options.minPitch = lockedPitch;
+    options.maxPitch = lockedPitch;
+  }
   return options;
 }
 
@@ -21878,6 +22249,24 @@ var TILE_RETRY_BASE_DELAY_MS = 1000;
  */
 var STYLE_READY_TIMEOUT_MS = 4000;
 
+/**
+ * Frames a floor change waits before it will believe the indoor tiles are
+ * already rebuilt (see `updateMarkersWhenFloorSettles`). Genuinely a frame
+ * count: the reload is dispatched on the map's next render, so this is how
+ * many renders it gets to be observed in.
+ */
+var FLOOR_SETTLE_MIN_FRAMES = 3;
+
+/**
+ * Longest a floor change waits for the new floor's tiles before switching the
+ * HTML markers anyway, so a stalled source never hides markers for good.
+ *
+ * A deadline rather than a frame count. The panels this matters on run at
+ * 20-30 fps, where a 60-frame cap is two to three seconds — and the wait also
+ * gates `addMarker`, so overshooting it is not merely a late marker switch.
+ */
+var FLOOR_SETTLE_MAX_MS = 1000;
+
 /** Bookkeeping for one tile in the retry queue. */
 
 /** Fill/line layer ids for one circle render-order bucket. */
@@ -22115,6 +22504,20 @@ var InternalMapVXMap = /*#__PURE__*/function (_Loggeable) {
      */
     map_defineProperty(_this, "tileRetryState", new WeakMap());
     map_defineProperty(_this, "geoLocation", navigator.geolocation);
+    /** Floor-change settle bookkeeping (see `updateMarkersWhenFloorSettles`). */
+    map_defineProperty(_this, "floorSettleToken", 0);
+    /**
+     * When the floor-change settle stops holding markers back, or `null` when no
+     * change is in flight.
+     *
+     * A deadline rather than a flag, because `addMarker` reads it: the poll that
+     * would clear a flag runs on `requestAnimationFrame`, which does not fire in
+     * a backgrounded tab and does not run at all for a map torn down through
+     * MapLibre's own `remove()` rather than `destroyMap`. A flag left set there
+     * makes every later `addMarker` skip the call that attaches the marker, for
+     * good; a deadline expires on its own.
+     */
+    map_defineProperty(_this, "floorSettleDeadline", null);
     /** Owns the deck.gl overlay + GLB scene; created on style load only when 3D is active. */
     map_defineProperty(_this, "scene3D", undefined);
     if (rtlLanguages.includes((_mapConfig$lang = mapConfig.lang) !== null && _mapConfig$lang !== void 0 ? _mapConfig$lang : "")) {
@@ -22136,6 +22539,8 @@ var InternalMapVXMap = /*#__PURE__*/function (_Loggeable) {
     _this.onFloorChange = mapConfig.onFloorChange;
     _this.onParentPlaceChange = mapConfig.onParentPlaceChange;
     _this.mode = (_mapConfig$mode = mapConfig.mode) !== null && _mapConfig$mode !== void 0 ? _mapConfig$mode : "2D";
+    _this.styleRef = mapConfig.styleRef;
+    _this.styleTheme = mapConfig.styleTheme;
     _this.scene3DConfig = mapConfig.scene3D;
     _this.initialCenter = mapConfig.center;
     _this.tileCacheConfig = function () {
@@ -22161,6 +22566,20 @@ var InternalMapVXMap = /*#__PURE__*/function (_Loggeable) {
   }
   map_inherits(InternalMapVXMap, _Loggeable);
   return map_createClass(InternalMapVXMap, [{
+    key: "floorSettlePending",
+    get: /** Whether a floor change is still rebuilding, so markers wait for it. */
+    function get() {
+      return this.floorSettleDeadline != null && this.now() < this.floorSettleDeadline;
+    }
+
+    /** Wall clock for the settle deadline; `Date.now` where `performance` is absent. */
+  }, {
+    key: "now",
+    value: function now() {
+      return typeof performance !== "undefined" ? performance.now() : Date.now();
+    }
+    /** Style variant/theme requested on every mapStyleJson fetch for this map. */
+  }, {
     key: "setRTLSupport",
     value: function setRTLSupport() {
       (0,maplibre_gl.setRTLTextPlugin)("https://unpkg.com/@mapbox/mapbox-gl-rtl-text@0.3.0/dist/mapbox-gl-rtl-text.js", false)["catch"](function () {
@@ -22251,9 +22670,18 @@ var InternalMapVXMap = /*#__PURE__*/function (_Loggeable) {
         })["catch"](console.error);
         return;
       }
-      this.repository.fetchAndParseMapStyle(mapConfig.parentPlaceId).then(function (style) {
+      // Through the same helper as `setStyle` and `changeParentPlaceTo`. This PR
+      // forwards `styleRef`/`styleTheme` to the initial load too, and a ref scoped
+      // to the user's client rather than to the api key resolves only over bearer
+      // — fetched over the api-key path it 4xx'd, and since this is the call that
+      // creates the map, the map was never created at all.
+      this.fetchVenueStyle(mapConfig.parentPlaceId, mapConfig.styleRef, mapConfig.styleTheme).then(function (style) {
         return _this5.onMapStyleLoaded(mapConfig, container, style);
-      })["catch"](console.error);
+      })["catch"](function (error) {
+        _this5.logError(error, {
+          functionName: "initialMapStyleSetUp"
+        });
+      });
     }
   }, {
     key: "onMapStyleLoaded",
@@ -22287,6 +22715,11 @@ var InternalMapVXMap = /*#__PURE__*/function (_Loggeable) {
       }, buildInteractionOptions(mapConfig));
       if (mapConfig.maxZoom) mapOptions.maxZoom = mapConfig.maxZoom;
       if (mapConfig.minZoom) mapOptions.minZoom = mapConfig.minZoom;
+      // Reduced internal resolution on request (fill-rate relief for low-end GPUs);
+      // MapLibre keeps devicePixelRatio when the option is left out.
+      if (mapConfig.pixelRatio !== undefined) mapOptions.pixelRatio = mapConfig.pixelRatio;
+      // `0` disables the post-gesture fade tail entirely; keep MapLibre's default otherwise.
+      if (mapConfig.fadeDuration !== undefined) mapOptions.fadeDuration = mapConfig.fadeDuration;
       if (mapConfig.maxBounds && mapConfig.maxBounds.length > 1) {
         var boundingBox = getBoundingBox(mapConfig.maxBounds);
         mapOptions.maxBounds = new maplibre_gl.LngLatBounds([boundingBox[0].lng, boundingBox[0].lat], [boundingBox[1].lng, boundingBox[1].lat]);
@@ -22456,6 +22889,11 @@ var InternalMapVXMap = /*#__PURE__*/function (_Loggeable) {
         clearTimeout(this.styleReadyTimer);
         this.styleReadyTimer = undefined;
       }
+      // Drop any floor-settle poll in flight: bumping the token makes the next
+      // `requestAnimationFrame` callback return instead of re-queueing itself and
+      // re-attaching markers to a map that has already been removed.
+      this.floorSettleToken++;
+      this.floorSettleDeadline = null;
       // Dispose the 3D scene's GPU resources before the map (and its shared WebGL context) go away —
       // MapLibre's own teardown never calls the custom GLB layer's `onRemove`.
       (_this$scene3D = this.scene3D) === null || _this$scene3D === void 0 || _this$scene3D.dispose();
@@ -22549,7 +22987,7 @@ var InternalMapVXMap = /*#__PURE__*/function (_Loggeable) {
       }
       (_this$scene3D3 = this.scene3D) === null || _this$scene3D3 === void 0 || _this$scene3D3.onFloorChange(this.currentFloor);
       if (updateStyle) {
-        this.repository.fetchAndParseMapStyle(place === null || place === void 0 ? void 0 : place.mapvxId).then(function (style) {
+        this.fetchVenueStyle(place === null || place === void 0 ? void 0 : place.mapvxId, this.styleRef, this.styleTheme).then(function (style) {
           var useServiceWorkerCaching = _this9.tileCacheConfig.enabled && _this9.tileCacheConfig.persistToServiceWorker;
           var finalStyle = useServiceWorkerCaching ? _this9.transformStyleForCaching(style) : style;
           _this9.map.setStyle(finalStyle);
@@ -22562,10 +23000,39 @@ var InternalMapVXMap = /*#__PURE__*/function (_Loggeable) {
           _this9.resetBaseFilters();
           _this9.whenStyleUpdates(finalStyle);
           onStyleReady === null || onStyleReady === void 0 || onStyleReady();
-        })["catch"](console.error);
+        })["catch"](function (error) {
+          _this9.logError(error, {
+            functionName: "changeParentPlaceTo"
+          });
+          // Release the caller either way. `onStyleReady` is what a consumer
+          // hides its loading overlay on, so swallowing the failure here left
+          // the overlay up for good rather than merely unstyled.
+          onStyleReady === null || onStyleReady === void 0 || onStyleReady();
+        });
       }
     }
 
+    /**
+     * Fetch the venue style over whichever endpoint this map is authorized on.
+     *
+     * A bearer token authorizes by the user's client access rather than the api
+     * key's scopes, so a client's branded style resolves without granting that
+     * place to a shared api key; api-key consumers keep the
+     * `/api/sdk/v2/mapStyleJson` path.
+     *
+     * Both callers go through here so they cannot disagree. They used to: once
+     * `setStyle` had stored a `styleRef` it resolved over bearer, the next
+     * parent-place change refetched that same ref over the api-key path, whose
+     * key does not scope it — a non-ok response, a rejected promise, and a style
+     * that was never applied, with `onStyleReady` left unfired under a caller's
+     * loading overlay.
+     */
+  }, {
+    key: "fetchVenueStyle",
+    value: function fetchVenueStyle(placeId, styleRef, styleTheme) {
+      return this.authToken ? this.repository.fetchAndParseMapStyleByBearer(placeId, this.authToken, styleRef, styleTheme) : this.repository.fetchAndParseMapStyle(placeId, styleRef, styleTheme);
+    }
+
     /**
      * Update the parent place and the current floor.
      * Does not update layers, markers, etc.
@@ -22681,18 +23148,20 @@ var InternalMapVXMap = /*#__PURE__*/function (_Loggeable) {
         reportReady(error);
         return;
       }
-
-      // When a user bearer token is present, the style is resolved through the
-      // bearer-authenticated endpoint, which authorizes by the user's client access
-      // rather than the api key's scopes — so a client's branded style can be
-      // previewed/applied without granting that place to a shared api key.
-      // Api-key consumers keep the `/api/sdk/v2/mapStyleJson` path.
-      var stylePromise = this.authToken ? this.repository.fetchAndParseMapStyleByBearer(this.parentPlaceId, this.authToken, styleRef, styleTheme) : this.repository.fetchAndParseMapStyle(this.parentPlaceId, styleRef, styleTheme);
+      var stylePromise = this.fetchVenueStyle(this.parentPlaceId, styleRef, styleTheme);
       stylePromise.then(function (style) {
         // A newer swap started while this style was in flight. Applying this one now
         // would fight the newer style layer by layer, so drop it and let the newer swap
         // own the map and its caller's callback.
         if (!isCurrent()) return;
+
+        // Remember what is actually on screen: `changeParentPlaceTo` refetches the
+        // style with these, so without this an explicitly applied style would be
+        // silently reverted to the constructor's on the next parent-place change.
+        // After the generation check: a superseded swap never reached the map, so it
+        // must not claim to be what is on it.
+        _this1.styleRef = styleRef;
+        _this1.styleTheme = styleTheme;
         var useServiceWorkerCaching = _this1.tileCacheConfig.enabled && _this1.tileCacheConfig.persistToServiceWorker;
         var finalStyle = useServiceWorkerCaching ? _this1.transformStyleForCaching(style) : style;
         // Full (non-diff) swap so the previewed style completely replaces the base —
@@ -22930,7 +23399,11 @@ 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
         }));
-        markerCreated.changeFloor(this.currentFloor, this.map, this.isOutdoorFloor(this.currentFloor));
+        // While a floor change is still being rebuilt, the marker is shown by that
+        // change's settle step, together with the new floor.
+        if (!this.floorSettlePending) {
+          markerCreated.changeFloor(this.currentFloor, this.map, this.isOutdoorFloor(this.currentFloor));
+        }
         this.markers.push(markerCreated);
         this.markerLayoutController.scheduleRelayout();
         this.logEvent("addMarker");
@@ -23438,12 +23911,131 @@ var InternalMapVXMap = /*#__PURE__*/function (_Loggeable) {
           floorKey: floorKeyString
         });
       }
-      this.updateFiltersTo(floorKeyString);
-      this.updateMarkersTo(floorKeyString);
+      // One style read for the whole floor change. `getStyle()` serializes every
+      // source and layer of the venue style, and the second read is the expensive
+      // one: `updateFiltersTo` writes filters and layout properties in between,
+      // and each write nulls maplibre's `_serializedLayers` cache, so anything
+      // that reads the style afterwards rebuilds it from scratch.
+      var layers = this.safeStyleLayers();
+      this.updateFiltersTo(floorKeyString, layers);
+      this.updateMarkersWhenFloorSettles(floorKeyString, layers);
       this.refreshCircles();
       this.routeController.updateRouteLayers(floorKeyString);
       this.routeController.updateRouteMarkerVisibility(floorKeyString);
     }
+
+    /**
+     * Show/hide the HTML markers for `floorId` once the indoor tiles have been
+     * rebuilt with the new floor filters.
+     *
+     * A floor change is a `setFilter` on every indoor layer: MapLibre rebuilds the
+     * tile buckets in its worker, so the new floor appears a few frames later
+     * (hundreds of ms on a low-end panel) while a marker is a DOM element that
+     * would move instantly. Waiting for the source to report loaded makes floor
+     * polygons and markers switch in the same frame. The wait is bounded, is
+     * dropped when a newer floor change arrives, and is skipped outside a
+     * browser (no `requestAnimationFrame`).
+     */
+  }, {
+    key: "updateMarkersWhenFloorSettles",
+    value: function updateMarkersWhenFloorSettles(floorId, styleLayers) {
+      var _this11 = this;
+      var token = ++this.floorSettleToken;
+      // Resolved rather than probed with `hasStyle()`, which is another full
+      // `getStyle()` — and by this point the most expensive kind, because
+      // `updateFiltersTo` has just invalidated the serialized-layer cache.
+      var layers = styleLayers === undefined ? this.safeStyleLayers() : styleLayers;
+      if (typeof requestAnimationFrame !== "function" || layers === null) {
+        // No poll will run for this floor change, so nothing would ever clear the
+        // flag later: leaving it set makes every subsequent `addMarker` skip
+        // `changeFloor` and the marker is never attached to the map.
+        this.floorSettleDeadline = null;
+        this.updateMarkersTo(floorId);
+        return;
+      }
+      var sourceIds = this.floorSettleSourceIds(floorId, layers);
+      var deadline = this.now() + FLOOR_SETTLE_MAX_MS;
+      this.floorSettleDeadline = deadline;
+      var sawReloading = false;
+      var frames = 0;
+      var _poll = function poll() {
+        if (token !== _this11.floorSettleToken) return;
+        frames++;
+        var loaded = sourceIds.every(function (id) {
+          return _this11.isSourceSettled(id);
+        });
+        if (!loaded) sawReloading = true;
+        // The reload is dispatched on the map's next render, which may run after
+        // this callback within the same frame: give it a couple of frames to be
+        // observed before concluding there was nothing to reload.
+        var settled = loaded && (sawReloading || frames >= FLOOR_SETTLE_MIN_FRAMES);
+        if (settled || _this11.now() >= deadline) {
+          _this11.floorSettleDeadline = null;
+          _this11.updateMarkersTo(floorId);
+          return;
+        }
+        requestAnimationFrame(_poll);
+      };
+      requestAnimationFrame(_poll);
+    }
+
+    /**
+     * Sources whose tiles a switch to `floorId` actually reloads, and which the
+     * marker settle therefore has to wait on.
+     *
+     * With a vector basemap that is the source the `indoor-*` layers draw from,
+     * because the floor change is a `setFilter` over those layers. An offline
+     * bundle's raster basemap switches floors by making `raster-floor-<key>`
+     * visible instead, and those tiles only begin loading at that moment — while
+     * its `indoor-*` layers carry labels and hover, are already loaded, and would
+     * report settled at once, letting the markers switch a floor before its image
+     * had painted. That is the configuration this wait exists for, so both are
+     * waited on.
+     */
+  }, {
+    key: "floorSettleSourceIds",
+    value: function floorSettleSourceIds(floorId, layers) {
+      var ids = new Set();
+      var rasterFloor = layers.find(function (layer) {
+        return layer.id === "raster-floor-".concat(floorId);
+      });
+      if (rasterFloor && "source" in rasterFloor && typeof rasterFloor.source === "string") {
+        ids.add(rasterFloor.source);
+      }
+      ids.add(this.indoorSourceId(layers));
+      return map_toConsumableArray(ids);
+    }
+
+    /** The vector source the `indoor-*` layers draw from (`indoorequal` by default). */
+  }, {
+    key: "indoorSourceId",
+    value: function indoorSourceId(layers) {
+      var _iterator2 = map_createForOfIteratorHelper(layers),
+        _step2;
+      try {
+        for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+          var layer = _step2.value;
+          if (layer.id.startsWith("indoor-") && "source" in layer && typeof layer.source === "string") {
+            return layer.source;
+          }
+        }
+      } catch (err) {
+        _iterator2.e(err);
+      } finally {
+        _iterator2.f();
+      }
+      return "indoorequal";
+    }
+  }, {
+    key: "isSourceSettled",
+    value: function isSourceSettled(sourceId) {
+      try {
+        if (!this.map.getSource(sourceId)) return true;
+        return this.map.isSourceLoaded(sourceId) !== false;
+      } catch (_unused) {
+        return true;
+      }
+    }
   }, {
     key: "getContainer",
     value: function getContainer() {
@@ -23464,26 +24056,51 @@ var InternalMapVXMap = /*#__PURE__*/function (_Loggeable) {
   }, {
     key: "updateMarkersTo",
     value: function updateMarkersTo(floorId) {
-      var _this11 = this;
+      var _this12 = this;
       var isOutdoor = this.isOutdoorFloor(floorId);
       this.markers.forEach(function (e) {
-        e.changeFloor(floorId, _this11.map, isOutdoor);
+        e.changeFloor(floorId, _this12.map, isOutdoor);
       });
       this.markerLayoutController.scheduleRelayout();
     }
   }, {
     key: "updateFiltersTo",
-    value: function updateFiltersTo(floorId) {
-      var _this$map$getStyle$la3,
-        _this$map$getStyle3,
-        _this12 = this,
+    value: function updateFiltersTo(floorId, styleLayers) {
+      var _ref4,
+        _this13 = 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 : [];
+      // `null` means the caller looked and there was no style; only `undefined`
+      // means it did not look.
+      var layers = (_ref4 = styleLayers === undefined ? this.safeStyleLayers() : styleLayers) !== null && _ref4 !== void 0 ? _ref4 : [];
+
+      // Raster basemap (offline bundles baked with one raster archive per floor):
+      // a floor is switched by showing its `raster-floor-<key>` layer and hiding
+      // the others. The remaining `indoor-*` layers (labels, hover, highlights)
+      // are still vector and keep going through the filter logic below.
+      var rasterFloorPrefix = "raster-floor-";
+      // Only switch the raster basemap when there is a baked layer to switch to.
+      // Hiding every raster floor leaves the basemap blank, and no id can match in
+      // two cases: no floor at all (an outdoor place, or a venue with no floors,
+      // where `currentFloor` is `""`), and a floor the bundle has no raster
+      // archive for — a venue where only some floors are baked, or a floor added
+      // after the bundle was built. Keeping the current one visible is the safe
+      // fallback for both.
+      var rasterFloorLayerIds = layers.filter(function (l) {
+        return l.id.startsWith(rasterFloorPrefix);
+      }).map(function (l) {
+        return l.id;
+      });
+      var targetRasterFloor = rasterFloorPrefix + floorId;
+      if (floorId && rasterFloorLayerIds.includes(targetRasterFloor)) {
+        rasterFloorLayerIds.forEach(function (id) {
+          _this13.map.setLayoutProperty(id, "visibility", id === targetRasterFloor ? "visible" : "none");
+        });
+      }
       layers.filter(function (l) {
         return l.id.startsWith("base-indoor-");
       }).forEach(function (l) {
-        _this12.map.removeLayer(l.id);
+        _this13.map.removeLayer(l.id);
       });
       var baseFloorId = (_this$innerFloors$fin4 = this.innerFloors.find(function (floor) {
         return floor.key === floorId;
@@ -23501,7 +24118,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 _this12.captureDeclaredBaseFilter(layer.id);
+        return _this13.captureDeclaredBaseFilter(layer.id);
       });
       if (baseFloorId != undefined) {
         var _indoorLayers$;
@@ -23511,13 +24128,13 @@ var InternalMapVXMap = /*#__PURE__*/function (_Loggeable) {
         }).forEach(function (layer) {
           var baseLayer = deepClone(layer);
           baseLayer.id = "base-" + layer.id;
-          _this12.baseFilters[baseLayer.id] = _this12.baseFilters[layer.id];
-          _this12.map.addLayer(baseLayer, firstLayerId);
-          _this12.applyLayerFilters(baseLayer, baseFloorId);
+          _this13.baseFilters[baseLayer.id] = _this13.baseFilters[layer.id];
+          _this13.map.addLayer(baseLayer, firstLayerId);
+          _this13.applyLayerFilters(baseLayer, baseFloorId);
         });
       }
       indoorLayers.forEach(function (layer) {
-        _this12.applyLayerFilters(layer, floorId);
+        _this13.applyLayerFilters(layer, floorId);
       });
     }
 
@@ -23531,7 +24148,7 @@ var InternalMapVXMap = /*#__PURE__*/function (_Loggeable) {
     value: function safeGetFilter(layerId) {
       try {
         return this.map.getFilter(layerId);
-      } catch (_unused) {
+      } catch (_unused2) {
         return undefined;
       }
     }
@@ -23719,11 +24336,11 @@ var InternalMapVXMap = /*#__PURE__*/function (_Loggeable) {
         var minLng;
         var maxLat;
         var maxLng;
-        var _iterator2 = map_createForOfIteratorHelper(coordinates),
-          _step2;
+        var _iterator3 = map_createForOfIteratorHelper(coordinates),
+          _step3;
         try {
-          for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
-            var _coord = _step2.value;
+          for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+            var _coord = _step3.value;
             var lat = _coord.lat,
               lng = _coord.lng;
             minLat = minLat === undefined ? lat : Math.min(minLat, lat);
@@ -23732,9 +24349,9 @@ var InternalMapVXMap = /*#__PURE__*/function (_Loggeable) {
             maxLng = maxLng === undefined ? lng : Math.max(maxLng, lng);
           }
         } catch (err) {
-          _iterator2.e(err);
+          _iterator3.e(err);
         } finally {
-          _iterator2.f();
+          _iterator3.f();
         }
         var bounds = [minLng !== null && minLng !== void 0 ? minLng : 0, minLat !== null && minLat !== void 0 ? minLat : 0, maxLng !== null && maxLng !== void 0 ? maxLng : 0, maxLat !== null && maxLat !== void 0 ? maxLat : 0];
 
@@ -23869,8 +24486,9 @@ var InternalMapVXMap = /*#__PURE__*/function (_Loggeable) {
       try {
         var _this$onFloorChange3;
         this.updatePlaceAndFloor(placeId, floorId);
-        this.updateFiltersTo(floorId);
-        this.updateMarkersTo(floorId);
+        var layers = this.safeStyleLayers();
+        this.updateFiltersTo(floorId, layers);
+        this.updateMarkersWhenFloorSettles(floorId, layers);
         (_this$onFloorChange3 = this.onFloorChange) === null || _this$onFloorChange3 === void 0 || _this$onFloorChange3.call(this, floorId);
         this.logEvent("updatePlaceAndFloorForRouting", {
           floorId: floorId
@@ -24087,17 +24705,17 @@ var InternalMapVXMap = /*#__PURE__*/function (_Loggeable) {
   }, {
     key: "defaultClickListener",
     value: function defaultClickListener() {
-      var _this13 = this;
+      var _this14 = 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;
+        var _ref5 = map_asyncToGenerator(/*#__PURE__*/map_regenerator().m(function _callee3(e) {
+          var features, roomFeatures, touchedFeature, ref, _clickedPlace, _ref6, _clickedPlace$mapvxId, _clickedPlace2, _clickedPlace3, clickedPlace, _iterator4, _step4, potentialParentPlace, cachedSubPlaces, cachedPlaces, clickedPlaceId, _t3;
           return map_regenerator().w(function (_context3) {
             while (1) switch (_context3.p = _context3.n) {
               case 0:
-                features = _this13.map.queryRenderedFeatures(e.point); // Filter room features by current floor
+                features = _this14.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) === _this13.currentFloor;
+                  return feature.properties["class"] === "room" && ((_feature$properties = feature.properties) === null || _feature$properties === void 0 ? void 0 : _feature$properties.floor_key) === _this14.currentFloor;
                 });
                 touchedFeature = roomFeatures[0];
                 ref = touchedFeature === null || touchedFeature === void 0 ? void 0 : touchedFeature.properties.ref;
@@ -24108,23 +24726,23 @@ var InternalMapVXMap = /*#__PURE__*/function (_Loggeable) {
                 console.log("touchedFeature", ref);
 
                 // First, search in current subPlaces
-                clickedPlace = _this13.subPlaces.find(function (subPlace) {
+                clickedPlace = _this14.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(_this13.potentialParentPlaces);
+                _iterator4 = map_createForOfIteratorHelper(_this14.potentialParentPlaces);
                 _context3.p = 1;
-                _iterator3.s();
+                _iterator4.s();
               case 2:
-                if ((_step3 = _iterator3.n()).done) {
+                if ((_step4 = _iterator4.n()).done) {
                   _context3.n = 4;
                   break;
                 }
-                potentialParentPlace = _step3.value;
-                cachedSubPlaces = _this13.repository.getCachedSubPlaces(potentialParentPlace.mapvxId);
+                potentialParentPlace = _step4.value;
+                cachedSubPlaces = _this14.repository.getCachedSubPlaces(potentialParentPlace.mapvxId);
                 if (!cachedSubPlaces) {
                   _context3.n = 3;
                   break;
@@ -24146,24 +24764,24 @@ var InternalMapVXMap = /*#__PURE__*/function (_Loggeable) {
               case 5:
                 _context3.p = 5;
                 _t3 = _context3.v;
-                _iterator3.e(_t3);
+                _iterator4.e(_t3);
               case 6:
                 _context3.p = 6;
-                _iterator3.f();
+                _iterator4.f();
                 return _context3.f(6);
               case 7:
                 if (!(clickedPlace === undefined)) {
                   _context3.n = 10;
                   break;
                 }
-                cachedPlaces = _this13.repository.getCachedPlaces([ref]);
+                cachedPlaces = _this14.repository.getCachedPlaces([ref]);
                 if (!(cachedPlaces.length === 0)) {
                   _context3.n = 9;
                   break;
                 }
                 console.log("fetching place detail from server", ref);
                 _context3.n = 8;
-                return _this13.repository.fetchAndParsePlaceDetail({
+                return _this14.repository.fetchAndParsePlaceDetail({
                   id: ref
                 });
               case 8:
@@ -24175,9 +24793,9 @@ var InternalMapVXMap = /*#__PURE__*/function (_Loggeable) {
                 clickedPlace = cachedPlaces === null || cachedPlaces === void 0 ? void 0 : cachedPlaces[0];
               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 && _this13.clickCallback) {
-                  _this13.clickCallback(clickedPlaceId);
+                clickedPlaceId = (_ref6 = (_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 && _ref6 !== void 0 ? _ref6 : "";
+                if (clickedPlace !== undefined && _this14.clickCallback) {
+                  _this14.clickCallback(clickedPlaceId);
                 }
               case 11:
                 return _context3.a(2);
@@ -24185,36 +24803,36 @@ var InternalMapVXMap = /*#__PURE__*/function (_Loggeable) {
           }, _callee3, null, [[1, 5, 6, 7]]);
         }));
         return function (_x3) {
-          return _ref4.apply(this, arguments);
+          return _ref5.apply(this, arguments);
         };
       }());
     }
   }, {
     key: "onHover",
     value: function onHover() {
-      var _this14 = this;
+      var _this15 = 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) === _this14.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) === _this15.currentFloor;
         });
         var ref = feature === null || feature === void 0 ? void 0 : feature.properties.ref;
         if (ref != null && typeof ref === "string" && ref.length > 0) {
-          _this14.hoveredId = ref;
-          _this14.updateFiltersTo(_this14.currentFloor);
-        } else if (ref === undefined && _this14.hoveredId !== "unselected") {
-          _this14.hoveredId = "unselected";
-          _this14.updateFiltersTo(_this14.currentFloor);
+          _this15.hoveredId = ref;
+          _this15.updateFiltersTo(_this15.currentFloor);
+        } else if (ref === undefined && _this15.hoveredId !== "unselected") {
+          _this15.hoveredId = "unselected";
+          _this15.updateFiltersTo(_this15.currentFloor);
         }
       });
 
       // When the mouse leaves the state-fill layer, update the feature state of the
       // previously hovered feature.
       this.map.on("mouseleave", "hoverable", function () {
-        _this14.hoveredId = "unselected";
-        _this14.updateFiltersTo(_this14.currentFloor);
+        _this15.hoveredId = "unselected";
+        _this15.updateFiltersTo(_this15.currentFloor);
       });
     }
   }, {
@@ -24615,7 +25233,7 @@ var InternalMapVXMap = /*#__PURE__*/function (_Loggeable) {
   }, {
     key: "addUserLocationTracking",
     value: function addUserLocationTracking(enableHighAccuracy, geoLocation, icon) {
-      var _this15 = this;
+      var _this16 = this;
       var initialCoordinate = {
         lat: 0.0,
         lng: 0.0
@@ -24639,7 +25257,7 @@ var InternalMapVXMap = /*#__PURE__*/function (_Loggeable) {
       this.markerLayoutController.scheduleRelayout();
       var updateMarker = function updateMarker(position) {
         marker.setLngLat([position.coords.longitude, position.coords.latitude]);
-        _this15.markerLayoutController.scheduleRelayout();
+        _this16.markerLayoutController.scheduleRelayout();
       };
       this.geoLocation = geoLocation !== null && geoLocation !== void 0 ? geoLocation : navigator.geolocation;
       this.watchPositionID = this.geoLocation.watchPosition(updateMarker, function (error) {
@@ -24735,7 +25353,7 @@ var InternalMapVXMap = /*#__PURE__*/function (_Loggeable) {
     key: "onWebGLContextLost",
     value: function onWebGLContextLost(e) {
       var _this$map2,
-        _this16 = this;
+        _this17 = this;
       e.originalEvent.preventDefault();
       console.warn("Contexto WebGL perdido 😢");
 
@@ -24746,8 +25364,8 @@ var InternalMapVXMap = /*#__PURE__*/function (_Loggeable) {
         var _ext$restoreContext;
         canvas.addEventListener("webglcontextrestored", function () {
           console.debug("Contexto WebGL restaurado, forzando re-render");
-          _this16.map.triggerRepaint(); // forzar repaint
-          _this16.failedTiles.clear();
+          _this17.map.triggerRepaint(); // forzar repaint
+          _this17.failedTiles.clear();
         }, {
           once: true
         });
@@ -24791,6 +25409,24 @@ var InternalMapVXMap = /*#__PURE__*/function (_Loggeable) {
      * ("Cannot read properties of undefined"), so call sites that only need the style to
      * exist should gate on this rather than on `isStyleLoaded()`.
      */
+    /**
+     * This style's layers, or `null` when the map has no style right now.
+     *
+     * The one place the style is read for a floor change, so callers can pass the
+     * result on instead of each probing again — `getStyle()` serializes every
+     * source and layer, and `Style._updateLayer` drops the cache behind it on
+     * every filter or layout write.
+     */
+  }, {
+    key: "safeStyleLayers",
+    value: function safeStyleLayers() {
+      try {
+        var _this$map$getStyle$la3, _this$map3;
+        return (_this$map$getStyle$la3 = (_this$map3 = this.map) === null || _this$map3 === void 0 || (_this$map3 = _this$map3.getStyle()) === null || _this$map3 === void 0 ? void 0 : _this$map3.layers) !== null && _this$map$getStyle$la3 !== void 0 ? _this$map$getStyle$la3 : null;
+      } catch (_unused3) {
+        return null;
+      }
+    }
   }, {
     key: "hasStyle",
     value: function hasStyle() {
@@ -24801,9 +25437,9 @@ var InternalMapVXMap = /*#__PURE__*/function (_Loggeable) {
       // or privatizes it — disabling both the tile-retry loop and `setStyle`'s apply pass
       // with no throw and no log. `safeGetFilter` already uses this try/catch shape.
       try {
-        var _this$map3;
-        return ((_this$map3 = this.map) === null || _this$map3 === void 0 ? void 0 : _this$map3.getStyle()) != null;
-      } catch (_unused2) {
+        var _this$map4;
+        return ((_this$map4 = this.map) === null || _this$map4 === void 0 ? void 0 : _this$map4.getStyle()) != null;
+      } catch (_unused4) {
         return false;
       }
     }
@@ -24823,7 +25459,7 @@ var InternalMapVXMap = /*#__PURE__*/function (_Loggeable) {
   }, {
     key: "subscribeToFailedTiles",
     value: function subscribeToFailedTiles() {
-      var _this17 = this;
+      var _this18 = this;
       if (this.retryTimer) return;
 
       // Store bound functions for proper cleanup
@@ -24840,23 +25476,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 (!_this17.hasStyle()) {
+        if (!_this18.hasStyle()) {
           return;
         }
-        if (!_this17.map.getSource("indoorequal")) {
-          _this17.failedTiles.clear();
+        if (!_this18.map.getSource("indoorequal")) {
+          _this18.failedTiles.clear();
           return;
         }
-        var source = _this17.map.getSource("indoorequal");
+        var source = _this18.map.getSource("indoorequal");
         if (!source || source.type !== "vector") {
-          _this17.failedTiles.clear();
+          _this18.failedTiles.clear();
           return;
         }
 
         // Process tiles and remove invalid ones
         var tilesToRetry = [];
         var tilesToRemove = [];
-        _this17.failedTiles.forEach(function (tile) {
+        _this18.failedTiles.forEach(function (tile) {
           // Check if tile is still valid before attempting reload
           if (!tile || tile.state === "unloaded" || tile.state === "loading") {
             tilesToRemove.push(tile);
@@ -24874,14 +25510,14 @@ var InternalMapVXMap = /*#__PURE__*/function (_Loggeable) {
 
         // Remove invalid tiles from the set
         tilesToRemove.forEach(function (tile) {
-          return _this17.failedTiles["delete"](tile);
+          return _this18.failedTiles["delete"](tile);
         });
 
         // Attempt to reload valid failed tiles
         var now = Date.now();
         tilesToRetry.forEach(function (tile) {
-          var _this17$tileRetryStat;
-          var retry = (_this17$tileRetryStat = _this17.tileRetryState.get(tile)) !== null && _this17$tileRetryStat !== void 0 ? _this17$tileRetryStat : {
+          var _this18$tileRetryStat;
+          var retry = (_this18$tileRetryStat = _this18.tileRetryState.get(tile)) !== null && _this18$tileRetryStat !== void 0 ? _this18$tileRetryStat : {
             attempts: 0,
             nextAttemptAt: 0,
             pending: false
@@ -24892,16 +25528,16 @@ var InternalMapVXMap = /*#__PURE__*/function (_Loggeable) {
           var onFailure = function onFailure(error) {
             var attempts = retry.attempts + 1;
             if (attempts >= MAX_TILE_RETRIES) {
-              _this17.debugLog("Tile reload failed ".concat(attempts, " times, dropping it from the retry queue"), error);
-              _this17.failedTiles["delete"](tile);
-              _this17.tileRetryState["delete"](tile);
+              _this18.debugLog("Tile reload failed ".concat(attempts, " times, dropping it from the retry queue"), error);
+              _this18.failedTiles["delete"](tile);
+              _this18.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);
-            _this17.debugLog("Tile reload failed (attempt ".concat(attempts, "/").concat(MAX_TILE_RETRIES, "), retrying in ").concat(backoffMs, "ms"), error);
-            _this17.tileRetryState.set(tile, {
+            _this18.debugLog("Tile reload failed (attempt ".concat(attempts, "/").concat(MAX_TILE_RETRIES, "), retrying in ").concat(backoffMs, "ms"), error);
+            _this18.tileRetryState.set(tile, {
               attempts: attempts,
               nextAttemptAt: Date.now() + backoffMs,
               pending: false
@@ -24910,7 +25546,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")) {
-              _this17.tileRetryState.set(tile, map_objectSpread(map_objectSpread({}, retry), {}, {
+              _this18.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
@@ -24920,7 +25556,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.
-                _this17.tileRetryState["delete"](tile);
+                _this18.tileRetryState["delete"](tile);
               })["catch"](onFailure);
             }
           } catch (error) {