@mapvx/web-js 3.1.0 → 3.2.0-dev.2

package/dist/umd/index.js

@@ -281,6 +281,7 @@ __webpack_require__.d(__webpack_exports__, {
   CIRCLE_DEFAULTS: () => (/* reexport */ CIRCLE_DEFAULTS),
   CacheManager: () => (/* reexport */ CacheManager),
   DEFAULT_CACHE_CONFIGS: () => (/* reexport */ DEFAULT_CACHE_CONFIGS),
+  DEFAULT_MARKER_LAYOUT_CONFIG: () => (/* reexport */ DEFAULT_MARKER_LAYOUT_CONFIG),
   DEFAULT_MAX_STORAGE_BYTES: () => (/* reexport */ DEFAULT_MAX_STORAGE_BYTES),
   DEFAULT_TILE_CACHE_CONFIG: () => (/* reexport */ DEFAULT_TILE_CACHE_CONFIG),
   FetchHttpClient: () => (/* reexport */ FetchHttpClient),
@@ -11239,7 +11240,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.1.0";
+var sentry_SDK_VERSION =  false ? 0 : "3.2.0-dev.2";
 var DSN =  false ? 0 : "https://872f598f020e3cd73a0933b562d24c81@sentry.mapvx.app/5";
 
 /**
@@ -11875,6 +11876,10 @@ function getBoundingBox(points) {
   return [southwest, northeast];
 }
 ;// ./src/domain/models/marker.ts
+function marker_typeof(o) { "@babel/helpers - typeof"; return marker_typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, marker_typeof(o); }
+function marker_ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function marker_objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? marker_ownKeys(Object(t), !0).forEach(function (r) { marker_defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : marker_ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+function marker_defineProperty(e, r, t) { return (r = marker_toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
 function _callSuper(t, o, e) { return o = _getPrototypeOf(o), _possibleConstructorReturn(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], _getPrototypeOf(t).constructor) : o.apply(t, e)); }
 function _possibleConstructorReturn(t, e) { if (e && ("object" == marker_typeof(e) || "function" == typeof e)) return e; if (void 0 !== e) throw new TypeError("Derived constructors may only return object or undefined"); return _assertThisInitialized(t); }
 function _assertThisInitialized(e) { if (void 0 === e) throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); return e; }
@@ -11882,7 +11887,6 @@ function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.
 function _getPrototypeOf(t) { return _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function (t) { return t.__proto__ || Object.getPrototypeOf(t); }, _getPrototypeOf(t); }
 function _inherits(t, e) { if ("function" != typeof e && null !== e) throw new TypeError("Super expression must either be null or a function"); t.prototype = Object.create(e && e.prototype, { constructor: { value: t, writable: !0, configurable: !0 } }), Object.defineProperty(t, "prototype", { writable: !1 }), e && _setPrototypeOf(t, e); }
 function _setPrototypeOf(t, e) { return _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function (t, e) { return t.__proto__ = e, t; }, _setPrototypeOf(t, e); }
-function marker_typeof(o) { "@babel/helpers - typeof"; return marker_typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, marker_typeof(o); }
 function marker_classCallCheck(a, n) { if (!(a instanceof n)) throw new TypeError("Cannot call a class as a function"); }
 function marker_defineProperties(e, r) { for (var t = 0; t < r.length; t++) { var o = r[t]; o.enumerable = o.enumerable || !1, o.configurable = !0, "value" in o && (o.writable = !0), Object.defineProperty(e, marker_toPropertyKey(o.key), o); } }
 function marker_createClass(e, r, t) { return r && marker_defineProperties(e.prototype, r), t && marker_defineProperties(e, t), Object.defineProperty(e, "prototype", { writable: !1 }), e; }
@@ -11917,6 +11921,22 @@ var TextPosition = /*#__PURE__*/function (TextPosition) {
   return TextPosition;
 }({});
 
+/**
+ * Fallback icon width/height, in pixels, used whenever a marker is created
+ * without explicit `iconProperties`.
+ *
+ * @group Markers
+ */
+var DEFAULT_ICON_SIZE_PX = 40;
+
+/**
+ * Fallback maximum label width, in pixels, used whenever neither the marker
+ * nor the map's `markerLayout` configuration specifies one.
+ *
+ * @group Markers
+ */
+var DEFAULT_MAX_LABEL_WIDTH_PX = 200;
+
 /**
  * Alignment options for marker rotation and pitch behavior.
  * Controls how the marker responds to map rotation and pitch changes.
@@ -11961,6 +11981,7 @@ var TextPosition = /*#__PURE__*/function (TextPosition) {
  *
  * @group Markers
  */
+
 /**
  * Utility class for creating and manipulating marker elements on a map.
  * Provides static methods for marker element creation and styling.
@@ -11990,75 +12011,55 @@ var MarkerUtils = /*#__PURE__*/function () {
       var markerContainer = document.createElement("div");
 
       // Configure specific marker dimensions
-      var iconWidth = (_marker$iconPropertie = (_marker$iconPropertie2 = marker.iconProperties) === null || _marker$iconPropertie2 === void 0 ? void 0 : _marker$iconPropertie2.width) !== null && _marker$iconPropertie !== void 0 ? _marker$iconPropertie : 40;
-      var iconHeight = (_marker$iconPropertie3 = (_marker$iconPropertie4 = marker.iconProperties) === null || _marker$iconPropertie4 === void 0 ? void 0 : _marker$iconPropertie4.height) !== null && _marker$iconPropertie3 !== void 0 ? _marker$iconPropertie3 : 40;
+      var iconWidth = (_marker$iconPropertie = (_marker$iconPropertie2 = marker.iconProperties) === null || _marker$iconPropertie2 === void 0 ? void 0 : _marker$iconPropertie2.width) !== null && _marker$iconPropertie !== void 0 ? _marker$iconPropertie : DEFAULT_ICON_SIZE_PX;
+      var iconHeight = (_marker$iconPropertie3 = (_marker$iconPropertie4 = marker.iconProperties) === null || _marker$iconPropertie4 === void 0 ? void 0 : _marker$iconPropertie4.height) !== null && _marker$iconPropertie3 !== void 0 ? _marker$iconPropertie3 : DEFAULT_ICON_SIZE_PX;
 
-      // Apply base class
+      // Apply base class. The container's own box is always the icon's box (or
+      // the custom `element`'s natural box) — the label is positioned
+      // absolutely (see .text-container in styles.css) so it never affects
+      // this box, which is exactly what MapLibre anchors the marker to.
       markerContainer.className = "mapvx-marker";
-
-      // Configure classes and dimensions based on text presence
-      if (marker.text) {
-        // If text exists, adjust layout according to position
-        switch (marker.textPosition) {
-          case TextPosition.top:
-          case TextPosition.bottom:
-            markerContainer.classList.add("text-column");
-            markerContainer.style.width = "".concat(Math.max(iconWidth, 200), "px");
-            markerContainer.style.height = "auto";
-            break;
-          case TextPosition.left:
-          case TextPosition.right:
-          default:
-            markerContainer.classList.add("text-row");
-            markerContainer.style.width = "auto";
-            markerContainer.style.height = "".concat(iconHeight, "px");
-            break;
-        }
-      } else {
-        // No text, use fixed icon dimensions as in official example
-        markerContainer.classList.add("no-text");
-        markerContainer.style.width = "".concat(iconWidth, "px");
-        markerContainer.style.height = "".concat(iconHeight, "px");
-      }
       markerContainer.addEventListener("click", function () {
         var _marker$onClick;
         (_marker$onClick = marker.onClick) === null || _marker$onClick === void 0 || _marker$onClick.call(marker);
       });
+
+      // Custom element replaces icon entirely; the label (if any) still gets
+      // appended, positioned absolutely relative to it.
       if (marker.element) {
+        // Only force a box when the caller declared the footprint. Otherwise
+        // the container is left to size itself to the custom element, and
+        // automatic label collision avoidance measures that real box from the
+        // DOM instead of assuming the default icon size — see
+        // {@link MarkerAttribute.measureIconFromDom}.
+        if (marker.iconProperties) {
+          markerContainer.style.width = "".concat(iconWidth, "px");
+          markerContainer.style.height = "".concat(iconHeight, "px");
+        }
         markerContainer.appendChild(marker.element);
-        return this.setAndCreateText(marker, markerContainer, "".concat(iconHeight, "px"), "".concat(iconWidth, "px"));
+        return this.setAndCreateText(marker, markerContainer);
       }
-
-      // Create elements in correct order according to textPosition
+      markerContainer.style.width = "".concat(iconWidth, "px");
+      markerContainer.style.height = "".concat(iconHeight, "px");
       var iconElement = this.createIconElement(marker, iconWidth, iconHeight);
-      var textElement = marker.text ? this.createTextContainer(typeof marker.text === "string" ? this.createTextElement(marker.text, marker.textProperties) : marker.text, marker.textPosition) : null;
-
-      // Add elements in correct order
-      if (marker.textPosition === TextPosition.top || marker.textPosition === TextPosition.left) {
-        if (textElement) markerContainer.appendChild(textElement);
-        markerContainer.appendChild(iconElement);
-      } else {
-        markerContainer.appendChild(iconElement);
-        if (textElement) markerContainer.appendChild(textElement);
-      }
-      return markerContainer;
+      markerContainer.appendChild(iconElement);
+      return this.setAndCreateText(marker, markerContainer);
     }
 
     /**
-     * Sets up text positioning and styling for the marker.
+     * Appends the marker's text label (if any) to the container, positioned
+     * around whichever element (icon or custom `element`) is already there.
      *
      * @param markerConfig - Configuration object containing text properties
-     * @param container - Container element where text will be added
-     * @param iconHeight - Height of the icon for positioning calculations
-     * @param iconWidth - Width of the icon for positioning calculations
-     * @returns Container element with properly positioned text
+     * @param container - Container element to append the label to
+     * @returns The same container, with the label appended when text is present
      */
   }, {
     key: "setAndCreateText",
-    value: function setAndCreateText(markerConfig, container, iconHeight, iconWidth) {
+    value: function setAndCreateText(markerConfig, container) {
       if (markerConfig.text) {
         var textElement = typeof markerConfig.text === "string" ? this.createTextElement(markerConfig.text, markerConfig.textProperties) : markerConfig.text;
-        var textContainer = this.createTextContainer(textElement, markerConfig.textPosition);
+        var textContainer = this.createTextContainer(textElement, markerConfig.textPosition, markerConfig.maxLabelWidthPx);
         container.appendChild(textContainer);
       }
       return container;
@@ -12094,43 +12095,75 @@ var MarkerUtils = /*#__PURE__*/function () {
     }
 
     /**
-     * Creates a text container with proper positioning using CSS classes.
-     * Uses natural block/flex layout without absolute positioning.
+     * Creates a text container, absolutely positioned around the marker's icon
+     * via CSS (see `.text-container` in styles.css), so the label never affects
+     * the container's own box.
      *
      * @param textElement - The text element to contain
      * @param textPosition - Desired position relative to the icon
+     * @param maxLabelWidthPx - Maximum label width in pixels before truncation
      * @returns Container with text positioned using CSS classes
      */
   }, {
     key: "createTextContainer",
-    value: function createTextContainer(textElement, textPosition) {
+    value: function createTextContainer(textElement, textPosition, maxLabelWidthPx) {
       var textContainer = document.createElement("div");
 
       // Apply base class
       textContainer.className = "text-container";
-
-      // Apply position class
-      switch (textPosition) {
-        case TextPosition.top:
-          textContainer.classList.add("top");
-          break;
-        case TextPosition.bottom:
-          textContainer.classList.add("bottom");
-          break;
-        case TextPosition.left:
-          textContainer.classList.add("left");
-          break;
-        default:
-          // right
-          textContainer.classList.add("right");
-          break;
-      }
+      textContainer.style.maxWidth = "".concat(maxLabelWidthPx !== null && maxLabelWidthPx !== void 0 ? maxLabelWidthPx : DEFAULT_MAX_LABEL_WIDTH_PX, "px");
+      this.setTextPositionClass(textContainer, this.resolveTextPosition(textPosition));
       textElement.style.display = "block";
       textElement.style.margin = "0";
       textContainer.appendChild(textElement);
       return textContainer;
     }
 
+    /**
+     * Resolves an optional {@link TextPosition} to its default (`right`), the
+     * same default `createTextContainer` has always applied.
+     */
+  }, {
+    key: "resolveTextPosition",
+    value: function resolveTextPosition(textPosition) {
+      return textPosition !== null && textPosition !== void 0 ? textPosition : TextPosition.right;
+    }
+
+    /**
+     * Swaps a text container's position class, keeping exactly one of
+     * `top|bottom|left|right` applied at a time.
+     */
+  }, {
+    key: "setTextPositionClass",
+    value: function setTextPositionClass(textContainer, position) {
+      textContainer.classList.remove("top", "bottom", "left", "right");
+      textContainer.classList.add(TextPosition[position]);
+    }
+
+    /**
+     * Repositions (or hides) a marker's already-rendered text label at
+     * runtime, without rebuilding any DOM. Used both by automatic collision
+     * avoidance and by anything else that needs to move a label after
+     * creation.
+     *
+     * @param textContainer - The `.text-container` element to reposition
+     * @param position - Side of the icon the label should render on
+     * @param hidden - Whether the label should be hidden (kept measurable via
+     *   `visibility`, never removed via `display`, so it can be measured again
+     *   to decide whether it fits once something else changes)
+     *
+     * @example
+     * ```typescript
+     * MarkerUtils.applyTextPosition(textEl, TextPosition.left, false);
+     * ```
+     */
+  }, {
+    key: "applyTextPosition",
+    value: function applyTextPosition(textContainer, position, hidden) {
+      this.setTextPositionClass(textContainer, position);
+      textContainer.style.visibility = hidden ? "hidden" : "";
+    }
+
     /**
      * Creates and returns an icon element for the marker, using the image URL
      * specified in the `MarkerConfig` object.
@@ -12150,8 +12183,8 @@ var MarkerUtils = /*#__PURE__*/function () {
       var _marker$iconPropertie5, _marker$iconPropertie6, _marker$iconPropertie7, _marker$iconPropertie8;
       var image = document.createElement("img");
       image.src = typeof marker.icon == "string" ? marker.icon : "";
-      image.width = (_marker$iconPropertie5 = (_marker$iconPropertie6 = marker.iconProperties) === null || _marker$iconPropertie6 === void 0 ? void 0 : _marker$iconPropertie6.width) !== null && _marker$iconPropertie5 !== void 0 ? _marker$iconPropertie5 : 40;
-      image.height = (_marker$iconPropertie7 = (_marker$iconPropertie8 = marker.iconProperties) === null || _marker$iconPropertie8 === void 0 ? void 0 : _marker$iconPropertie8.height) !== null && _marker$iconPropertie7 !== void 0 ? _marker$iconPropertie7 : 40;
+      image.width = (_marker$iconPropertie5 = (_marker$iconPropertie6 = marker.iconProperties) === null || _marker$iconPropertie6 === void 0 ? void 0 : _marker$iconPropertie6.width) !== null && _marker$iconPropertie5 !== void 0 ? _marker$iconPropertie5 : DEFAULT_ICON_SIZE_PX;
+      image.height = (_marker$iconPropertie7 = (_marker$iconPropertie8 = marker.iconProperties) === null || _marker$iconPropertie8 === void 0 ? void 0 : _marker$iconPropertie8.height) !== null && _marker$iconPropertie7 !== void 0 ? _marker$iconPropertie7 : DEFAULT_ICON_SIZE_PX;
       image.style.objectFit = "contain";
       image.style.filter = "drop-shadow(0px 4px 4px rgba(0, 0, 0, 0.25))";
       return image;
@@ -12190,6 +12223,7 @@ var MarkerUtils = /*#__PURE__*/function () {
     }
   }]);
 }();
+
 /**
  * Custom implementation of a MapLibre Marker with additional functionality.
  * Extends the base MapLibre Marker class with MapVX-specific features.
@@ -12220,6 +12254,56 @@ var MarkerAttribute = /*#__PURE__*/function (_Marker) {
    * Used for indoor navigation and floor-specific marker management.
    */
 
+  /**
+   * Resolved icon dimensions (defaults to {@link DEFAULT_ICON_SIZE_PX} square
+   * when unspecified), matching whatever `MarkerUtils.createMarkerElement`
+   * rendered. Used by automatic label collision avoidance to compute the
+   * icon's on-screen rect without a DOM measurement — except when
+   * {@link measureIconFromDom} is set.
+   * @internal
+   */
+
+  /**
+   * The `PositionAnchor` this marker was created with, needed by automatic
+   * label collision avoidance to translate a screen point into the icon's
+   * on-screen rect the same way MapLibre itself does.
+   * @internal
+   */
+
+  /**
+   * The marker's preferred text position, used as the first candidate by
+   * automatic label collision avoidance before it tries the other sides.
+   * @internal
+   */
+
+  /**
+   * Priority used to resolve label collisions; see
+   * {@link MarkerConfig.labelPriority}.
+   * @internal
+   */
+
+  /**
+   * Cached reference to this marker's `.text-container` element, if it has
+   * a text label. Avoids querying the DOM on every layout pass.
+   * @internal
+   */
+
+  /**
+   * True when the marker renders a caller-supplied `element` and no
+   * `iconProperties` declared its footprint. In that case {@link iconSize}
+   * is only a fallback and automatic label collision avoidance measures the
+   * marker element's real box from the DOM instead.
+   * @internal
+   */
+
+  /**
+   * The config this marker currently renders from. {@link updateIcon} merges
+   * its (usually partial) config on top of this one, so an update that omits
+   * `iconProperties`, `textPosition` or `labelPriority` keeps whatever the
+   * marker already had instead of silently snapping back to the SDK defaults
+   * — both in the DOM it rebuilds and in the layout state derived from it.
+   */
+
   /**
    * Constructs a new `MarkerAttribute` object with the specified properties.
    *
@@ -12236,7 +12320,7 @@ var MarkerAttribute = /*#__PURE__*/function (_Marker) {
    * ```
    */
   function MarkerAttribute(markerConfig) {
-    var _markerConfig$anchor, _markerConfig$rotatio, _markerConfig$id, _markerConfig$floorId;
+    var _markerConfig$anchor, _markerConfig$rotatio, _markerConfig$id, _markerConfig$floorId, _markerConfig$anchor2;
     var _this;
     marker_classCallCheck(this, MarkerAttribute);
     _this = _callSuper(this, MarkerAttribute, [{
@@ -12254,22 +12338,78 @@ var MarkerAttribute = /*#__PURE__*/function (_Marker) {
     _this.id = (_markerConfig$id = markerConfig.id) !== null && _markerConfig$id !== void 0 ? _markerConfig$id : generateHexadecimalKey();
     _this.coordinate = markerConfig.coordinate;
     _this.floorId = (_markerConfig$floorId = markerConfig.floorId) !== null && _markerConfig$floorId !== void 0 ? _markerConfig$floorId : "";
+    // MapLibre resolves the anchor once, in the `super()` call above, and
+    // offers no way to change it afterwards — so this mirror is set here and
+    // never touched by `updateIcon`.
+    _this.anchorType = (_markerConfig$anchor2 = markerConfig.anchor) !== null && _markerConfig$anchor2 !== void 0 ? _markerConfig$anchor2 : "center";
+    _this.currentConfig = markerConfig;
+    _this.applyLayoutState(markerConfig);
     return _this;
   }
 
   /**
-   * Adds the marker attribute to the specified map.
-   *
-   * @param map - The map instance where the marker attribute will be added
-   *
-   * @example
-   * ```typescript
-   * const marker = new MarkerAttribute(markerConfig);
-   * marker.addToMap(mapInstance);
-   * ```
+   * Derives the state automatic label collision avoidance reads (icon box,
+   * preferred label side, priority, label element) from a fully-resolved
+   * config. It is what assigns the fields declared with `!` above — the
+   * constructor always calls it, but TypeScript can't see through the
+   * indirection. Shared by the constructor and {@link updateIcon} so the two can
+   * never drift apart.
    */
   _inherits(MarkerAttribute, _Marker);
   return marker_createClass(MarkerAttribute, [{
+    key: "applyLayoutState",
+    value: function applyLayoutState(config) {
+      var _config$iconPropertie, _config$iconPropertie2, _config$iconPropertie3, _config$iconPropertie4, _config$labelPriority;
+      this.iconSize = {
+        width: (_config$iconPropertie = (_config$iconPropertie2 = config.iconProperties) === null || _config$iconPropertie2 === void 0 ? void 0 : _config$iconPropertie2.width) !== null && _config$iconPropertie !== void 0 ? _config$iconPropertie : DEFAULT_ICON_SIZE_PX,
+        height: (_config$iconPropertie3 = (_config$iconPropertie4 = config.iconProperties) === null || _config$iconPropertie4 === void 0 ? void 0 : _config$iconPropertie4.height) !== null && _config$iconPropertie3 !== void 0 ? _config$iconPropertie3 : DEFAULT_ICON_SIZE_PX
+      };
+      this.preferredTextPosition = MarkerUtils.resolveTextPosition(config.textPosition);
+      this.labelPriority = (_config$labelPriority = config.labelPriority) !== null && _config$labelPriority !== void 0 ? _config$labelPriority : 0;
+      this.measureIconFromDom = config.element != null && config.iconProperties == null;
+      this.textContainerEl = this.findTextContainerEl();
+    }
+
+    /**
+     * Merges an update on top of the marker's current config, so a partial
+     * update such as `{ id, coordinate, icon }` keeps the marker's existing
+     * icon dimensions, label side and priority.
+     *
+     * `element` is deliberately *not* carried forward: it and `icon` are
+     * mutually exclusive rendering paths, and `updateIcon` has always chosen
+     * the path named by the update itself.
+     */
+  }, {
+    key: "mergeConfig",
+    value: function mergeConfig(update) {
+      return marker_objectSpread(marker_objectSpread(marker_objectSpread({}, this.currentConfig), update), {}, {
+        element: update.element
+      });
+    }
+
+    /**
+     * Finds this marker's `.text-container` child element, if it has one.
+     */
+  }, {
+    key: "findTextContainerEl",
+    value: function findTextContainerEl() {
+      return Array.from(this._element.children).find(function (child) {
+        return child instanceof HTMLElement && child.classList.contains("text-container");
+      });
+    }
+
+    /**
+     * Adds the marker attribute to the specified map.
+     *
+     * @param map - The map instance where the marker attribute will be added
+     *
+     * @example
+     * ```typescript
+     * const marker = new MarkerAttribute(markerConfig);
+     * marker.addToMap(mapInstance);
+     * ```
+     */
+  }, {
     key: "addToMap",
     value: function addToMap(map) {
       if (!map) return;
@@ -12279,6 +12419,11 @@ var MarkerAttribute = /*#__PURE__*/function (_Marker) {
     /**
      * Updates the icon of the marker attribute based on the specified marker configuration.
      *
+     * The config is merged on top of the one the marker currently renders
+     * from, so a partial update keeps every property it omits — passing only
+     * `{ icon }` no longer resets the marker's icon dimensions, preferred
+     * label side or label priority to their defaults.
+     *
      * @param marker - `MarkerConfig` object containing the new marker configuration
      *
      * @example
@@ -12292,12 +12437,13 @@ var MarkerAttribute = /*#__PURE__*/function (_Marker) {
   }, {
     key: "updateIcon",
     value: function updateIcon(marker) {
-      var _marker$rotationAlign;
-      if (marker.element) {
+      var _config$rotationAlign;
+      var config = this.mergeConfig(marker);
+      if (config.element) {
         this._element.innerHTML = "";
-        this._element.appendChild(marker.element);
+        this._element.appendChild(config.element);
       } else {
-        var markerElement = MarkerUtils.createMarkerElement(marker);
+        var markerElement = MarkerUtils.createMarkerElement(config);
         var oldMarkerContent = this._element.querySelector("div");
         var newMarkerContent = markerElement.querySelector("div");
         if (newMarkerContent) {
@@ -12305,11 +12451,13 @@ var MarkerAttribute = /*#__PURE__*/function (_Marker) {
           oldMarkerContent === null || oldMarkerContent === void 0 || (_oldMarkerContent$par = oldMarkerContent.parentElement) === null || _oldMarkerContent$par === void 0 || _oldMarkerContent$par.replaceChild(newMarkerContent, oldMarkerContent);
         }
       }
-      this.setRotationAlignment((_marker$rotationAlign = marker.rotationAlignment) !== null && _marker$rotationAlign !== void 0 ? _marker$rotationAlign : "viewport");
+      this.setRotationAlignment((_config$rotationAlign = config.rotationAlignment) !== null && _config$rotationAlign !== void 0 ? _config$rotationAlign : "viewport");
       this.setPitchAlignment("viewport");
-      if (typeof marker.rotation === "number") {
-        this.setRotation(marker.rotation);
+      if (typeof config.rotation === "number") {
+        this.setRotation(config.rotation);
       }
+      this.currentConfig = config;
+      this.applyLayoutState(config);
     }
 
     /**
@@ -12386,6 +12534,485 @@ var MarkerAttribute = /*#__PURE__*/function (_Marker) {
     }
   }]);
 }(maplibre_gl.Marker);
+;// ./src/controllers/markerLayoutController.ts
+function markerLayoutController_typeof(o) { "@babel/helpers - typeof"; return markerLayoutController_typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, markerLayoutController_typeof(o); }
+function _toConsumableArray(r) { return _arrayWithoutHoles(r) || _iterableToArray(r) || markerLayoutController_unsupportedIterableToArray(r) || _nonIterableSpread(); }
+function _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 _iterableToArray(r) { if ("undefined" != typeof Symbol && null != r[Symbol.iterator] || null != r["@@iterator"]) return Array.from(r); }
+function _arrayWithoutHoles(r) { if (Array.isArray(r)) return markerLayoutController_arrayLikeToArray(r); }
+function markerLayoutController_createForOfIteratorHelper(r, e) { var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (!t) { if (Array.isArray(r) || (t = markerLayoutController_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 markerLayoutController_unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return markerLayoutController_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) ? markerLayoutController_arrayLikeToArray(r, a) : void 0; } }
+function markerLayoutController_arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
+function markerLayoutController_classCallCheck(a, n) { if (!(a instanceof n)) throw new TypeError("Cannot call a class as a function"); }
+function markerLayoutController_defineProperties(e, r) { for (var t = 0; t < r.length; t++) { var o = r[t]; o.enumerable = o.enumerable || !1, o.configurable = !0, "value" in o && (o.writable = !0), Object.defineProperty(e, markerLayoutController_toPropertyKey(o.key), o); } }
+function markerLayoutController_createClass(e, r, t) { return r && markerLayoutController_defineProperties(e.prototype, r), t && markerLayoutController_defineProperties(e, t), Object.defineProperty(e, "prototype", { writable: !1 }), e; }
+function markerLayoutController_defineProperty(e, r, t) { return (r = markerLayoutController_toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
+function markerLayoutController_toPropertyKey(t) { var i = markerLayoutController_toPrimitive(t, "string"); return "symbol" == markerLayoutController_typeof(i) ? i : i + ""; }
+function markerLayoutController_toPrimitive(t, r) { if ("object" != markerLayoutController_typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != markerLayoutController_typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+
+
+/** Axis-aligned box in screen (CSS pixel) space. */
+
+/**
+ * Fraction of the icon's own box, along each axis, that MapLibre's Marker
+ * anchor math (`translate(-x%, -y%)`) aligns to the geodetic point. Mirrors
+ * MapLibre's own `anchorTranslate` table so the collision math agrees with
+ * what's actually on screen.
+ */
+var ANCHOR_FRACTIONS = {
+  center: {
+    fx: 0.5,
+    fy: 0.5
+  },
+  top: {
+    fx: 0.5,
+    fy: 0
+  },
+  bottom: {
+    fx: 0.5,
+    fy: 1
+  },
+  left: {
+    fx: 0,
+    fy: 0.5
+  },
+  right: {
+    fx: 1,
+    fy: 0.5
+  },
+  "top-left": {
+    fx: 0,
+    fy: 0
+  },
+  "top-right": {
+    fx: 1,
+    fy: 0
+  },
+  "bottom-left": {
+    fx: 0,
+    fy: 1
+  },
+  "bottom-right": {
+    fx: 1,
+    fy: 1
+  }
+};
+
+/** Candidate order tried when a marker's preferred side is unavailable. */
+var FALLBACK_ORDER = [TextPosition.right, TextPosition.top, TextPosition.left, TextPosition.bottom];
+
+/** Builds the icon's on-screen rect from its projected point, size and anchor. */
+function computeIconRect(screen, iconSize, anchor) {
+  var _ANCHOR_FRACTIONS$anc;
+  var _ref = (_ANCHOR_FRACTIONS$anc = ANCHOR_FRACTIONS[anchor]) !== null && _ANCHOR_FRACTIONS$anc !== void 0 ? _ANCHOR_FRACTIONS$anc : ANCHOR_FRACTIONS.center,
+    fx = _ref.fx,
+    fy = _ref.fy;
+  return {
+    left: screen.x - fx * iconSize.width,
+    top: screen.y - fy * iconSize.height,
+    width: iconSize.width,
+    height: iconSize.height
+  };
+}
+
+/**
+ * Builds a candidate label rect for one side of an icon. Mirrors the CSS in
+ * `styles.css` (`.text-container.right/left/top/bottom`) exactly, so a
+ * position the algorithm picks as collision-free renders collision-free.
+ */
+function computeCandidateRect(iconRect, labelSize, position, gapPx, verticalGapPx) {
+  switch (position) {
+    case TextPosition.left:
+      return {
+        left: iconRect.left - gapPx - labelSize.width,
+        top: iconRect.top + iconRect.height / 2 - labelSize.height / 2,
+        width: labelSize.width,
+        height: labelSize.height
+      };
+    case TextPosition.top:
+      return {
+        left: iconRect.left + iconRect.width / 2 - labelSize.width / 2,
+        top: iconRect.top - verticalGapPx - labelSize.height,
+        width: labelSize.width,
+        height: labelSize.height
+      };
+    case TextPosition.bottom:
+      return {
+        left: iconRect.left + iconRect.width / 2 - labelSize.width / 2,
+        top: iconRect.top + iconRect.height + verticalGapPx,
+        width: labelSize.width,
+        height: labelSize.height
+      };
+    case TextPosition.right:
+    default:
+      return {
+        left: iconRect.left + iconRect.width + gapPx,
+        top: iconRect.top + iconRect.height / 2 - labelSize.height / 2,
+        width: labelSize.width,
+        height: labelSize.height
+      };
+  }
+}
+
+/** Expands a rect by `padding` on every side. */
+function expandRect(rect, padding) {
+  return {
+    left: rect.left - padding,
+    top: rect.top - padding,
+    width: rect.width + 2 * padding,
+    height: rect.height + 2 * padding
+  };
+}
+
+/** Standard AABB intersection test. */
+function rectsIntersect(a, b) {
+  return a.left < b.left + b.width && a.left + a.width > b.left && a.top < b.top + b.height && a.top + a.height > b.top;
+}
+
+/**
+ * Automatic collision avoidance for marker text labels: keeps a marker's
+ * icon fixed while moving (or hiding) its label to avoid overlapping
+ * neighboring markers' icons/labels, similar to Google Maps' label
+ * placement. Below `minZoomForLabels` it withholds every label instead, so
+ * a zoomed-out map shows pins only. See {@link MarkerLayoutConfig}.
+ *
+ * Not part of the public SDK surface — owned and driven entirely by
+ * {@link InternalMapVXMap}, mirroring `RouteController`.
+ */
+var MarkerLayoutController = /*#__PURE__*/function () {
+  function MarkerLayoutController(map, config) {
+    var _this = this;
+    markerLayoutController_classCallCheck(this, MarkerLayoutController);
+    markerLayoutController_defineProperty(this, "labelSizeCache", new WeakMap());
+    markerLayoutController_defineProperty(this, "iconSizeCache", new WeakMap());
+    markerLayoutController_defineProperty(this, "lastAppliedState", new WeakMap());
+    markerLayoutController_defineProperty(this, "attached", false);
+    this.mapvxMap = map;
+    this.config = config;
+    this.boundOnMove = function () {
+      return _this.scheduleRelayout();
+    };
+  }
+  return markerLayoutController_createClass(MarkerLayoutController, [{
+    key: "map",
+    get: function get() {
+      return this.mapvxMap.map;
+    }
+
+    /**
+     * Starts listening for camera movement. Safe to call once the underlying
+     * MapLibre `Map` instance exists; a single `"move"` listener covers pan,
+     * zoom, rotate, pitch and `resize()`.
+     */
+  }, {
+    key: "attach",
+    value: function attach() {
+      if (this.attached) return;
+      this.attached = true;
+      this.map.on("move", this.boundOnMove);
+      this.remeasureWhenFontsLoad();
+      this.scheduleRelayout();
+    }
+
+    /**
+     * Publishes the configured gaps and label width cap as CSS custom
+     * properties, which `styles.css` reads to offset labels from their icon.
+     * Without this the stylesheet would keep its hardcoded defaults while the
+     * collision math used the configured values, so any custom `gapPx` /
+     * `verticalGapPx` would produce placements this controller believes are
+     * collision-free but that visibly overlap on screen.
+     *
+     * Called with the map's own container, so every marker MapLibre mounts
+     * inside it inherits the values.
+     */
+  }, {
+    key: "applyLayoutVariables",
+    value: function applyLayoutVariables(container) {
+      container.style.setProperty("--mapvx-label-gap", "".concat(this.config.gapPx, "px"));
+      container.style.setProperty("--mapvx-label-vertical-gap", "".concat(this.config.verticalGapPx, "px"));
+      container.style.setProperty("--mapvx-label-max-width", "".concat(this.config.maxLabelWidthPx, "px"));
+    }
+
+    /**
+     * A label measured before its web font finishes loading is measured in the
+     * fallback font, and that wrong footprint would otherwise be cached for
+     * the marker's lifetime. Drop every measurement once fonts settle.
+     */
+  }, {
+    key: "remeasureWhenFontsLoad",
+    value: function remeasureWhenFontsLoad() {
+      var _this2 = this;
+      var fonts = document.fonts;
+      if (!fonts) return;
+      fonts.ready.then(function () {
+        if (!_this2.attached) return;
+        _this2.labelSizeCache = new WeakMap();
+        _this2.iconSizeCache = new WeakMap();
+        _this2.scheduleRelayout();
+      })["catch"](function () {
+        // Font loading failing is not a layout error: the measurements
+        // already taken in the fallback font stay in effect.
+      });
+    }
+
+    /** Stops listening and cancels any pending layout pass. */
+  }, {
+    key: "destroy",
+    value: function destroy() {
+      if (this.attached) {
+        this.map.off("move", this.boundOnMove);
+        this.attached = false;
+      }
+      if (this.rafHandle !== undefined) {
+        cancelAnimationFrame(this.rafHandle);
+        this.rafHandle = undefined;
+      }
+    }
+
+    /**
+     * Drops everything cached for a marker, e.g. after its text/content
+     * changed.
+     *
+     * The last applied decision has to go too: rebuilding a marker's DOM
+     * replaces its `.text-container` with a fresh one carrying the preferred
+     * side and no `visibility`, so a decision remembered from the old element
+     * would make {@link applyDecisions} short-circuit and leave the new label
+     * on the wrong side — or visible when it should be hidden.
+     */
+  }, {
+    key: "invalidateMarker",
+    value: function invalidateMarker(marker) {
+      this.labelSizeCache["delete"](marker);
+      this.iconSizeCache["delete"](marker);
+      this.lastAppliedState["delete"](marker);
+    }
+
+    /** Coalesces repeated calls into a single layout pass per animation frame. */
+  }, {
+    key: "scheduleRelayout",
+    value: function scheduleRelayout() {
+      var _this3 = this;
+      if (!this.config.enabled || this.rafHandle !== undefined) return;
+      this.rafHandle = requestAnimationFrame(function () {
+        _this3.rafHandle = undefined;
+        _this3.performLayout();
+      });
+    }
+  }, {
+    key: "performLayout",
+    value: function performLayout() {
+      // Guards against a relayout firing before the underlying MapLibre `map`
+      // exists (e.g. a marker added before the "load" event) — `attach()`
+      // schedules its own initial pass once it's safe to touch `this.map`.
+      if (!this.attached) return;
+      var markers = this.mapvxMap.getMarkers();
+      if (markers.length === 0) return;
+      var container = this.map.getContainer();
+      var viewportWidth = container.clientWidth;
+      var viewportHeight = container.clientHeight;
+      var cullMargin = this.config.maxLabelWidthPx + Math.max(this.config.gapPx, this.config.verticalGapPx);
+
+      // A single `>=` per pass, evaluated here rather than in `attach()` so it
+      // tracks the live camera: the controller already relayouts on every
+      // "move", which fires continuously through a pan/pinch, so labels cross
+      // the threshold mid-gesture instead of snapping at its end.
+      var labelsAllowed = this.map.getZoom() >= this.config.minZoomForLabels;
+      var entries = this.readMarkers(markers, viewportWidth, viewportHeight, cullMargin);
+      var decisions = this.decidePlacements(entries, labelsAllowed);
+      this.applyDecisions(decisions);
+    }
+
+    /** Read phase: project + measure, no writes. Culls markers fully outside the viewport. */
+  }, {
+    key: "readMarkers",
+    value: function readMarkers(markers, viewportWidth, viewportHeight, cullMargin) {
+      var entries = [];
+      var _iterator = markerLayoutController_createForOfIteratorHelper(markers),
+        _step;
+      try {
+        for (_iterator.s(); !(_step = _iterator.n()).done;) {
+          var marker = _step.value;
+          if (!marker.getElement().isConnected) continue;
+          var screen = this.map.project(marker.getLngLat());
+          var iconRect = computeIconRect(screen, this.resolveIconSize(marker), marker.anchorType);
+          var outOfViewport = iconRect.left + iconRect.width < -cullMargin || iconRect.left > viewportWidth + cullMargin || iconRect.top + iconRect.height < -cullMargin || iconRect.top > viewportHeight + cullMargin;
+          if (outOfViewport) continue;
+          entries.push({
+            marker: marker,
+            iconRect: iconRect,
+            labelSize: this.resolveLabelSize(marker)
+          });
+        }
+      } catch (err) {
+        _iterator.e(err);
+      } finally {
+        _iterator.f();
+      }
+      return entries;
+    }
+  }, {
+    key: "resolveLabelSize",
+    value: function resolveLabelSize(marker) {
+      var textEl = marker.textContainerEl;
+      if (!textEl) return undefined;
+      return this.measureCached(this.labelSizeCache, marker, textEl);
+    }
+
+    /**
+     * The icon's box. Markers built from a caller-supplied `element` with no
+     * declared `iconProperties` are measured from the DOM, since their real
+     * size is whatever that element renders at; everyone else's box is exactly
+     * what `MarkerUtils.createMarkerElement` pinned it to.
+     */
+  }, {
+    key: "resolveIconSize",
+    value: function resolveIconSize(marker) {
+      var _this$measureCached;
+      if (!marker.measureIconFromDom) return marker.iconSize;
+      return (_this$measureCached = this.measureCached(this.iconSizeCache, marker, marker.getElement())) !== null && _this$measureCached !== void 0 ? _this$measureCached : marker.iconSize;
+    }
+
+    /**
+     * Measures an element once and remembers it. A zero measurement is
+     * returned but never cached: it means the element isn't laid out yet (a
+     * `display: none` ancestor, a first pass before the web font loads), and
+     * caching it would freeze that marker's footprint at nothing for the rest
+     * of its life.
+     */
+  }, {
+    key: "measureCached",
+    value: function measureCached(cache, marker, element) {
+      var cached = cache.get(marker);
+      if (cached) return cached;
+      var measured = {
+        width: element.offsetWidth,
+        height: element.offsetHeight
+      };
+      if (measured.width <= 0 || measured.height <= 0) return undefined;
+      cache.set(marker, measured);
+      return measured;
+    }
+
+    /**
+     * Compute phase: pure, no DOM access. Icons always block; labels negotiate
+     * a side or hide.
+     *
+     * Below `minZoomForLabels` every label is hidden and none is placed, so no
+     * label ever becomes an obstacle for a neighbor at that zoom — a label the
+     * threshold withheld must not displace anything on its way out.
+     */
+  }, {
+    key: "decidePlacements",
+    value: function decidePlacements(entries, labelsAllowed) {
+      var _this4 = this;
+      var placedLabels = [];
+      var withLabel = entries.filter(hasLabelSize);
+      var decisions = new Map();
+      if (!labelsAllowed) {
+        var _iterator2 = markerLayoutController_createForOfIteratorHelper(withLabel),
+          _step2;
+        try {
+          for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+            var entry = _step2.value;
+            decisions.set(entry.marker, {
+              position: entry.marker.preferredTextPosition,
+              hidden: true
+            });
+          }
+        } catch (err) {
+          _iterator2.e(err);
+        } finally {
+          _iterator2.f();
+        }
+        return decisions;
+      }
+
+      // Stable sort (spec-guaranteed): equal priority keeps insertion order.
+      withLabel.sort(function (a, b) {
+        return b.marker.labelPriority - a.marker.labelPriority;
+      });
+      var _iterator3 = markerLayoutController_createForOfIteratorHelper(withLabel),
+        _step3;
+      try {
+        var _loop = function _loop() {
+          var entry = _step3.value;
+          var order = [entry.marker.preferredTextPosition].concat(_toConsumableArray(FALLBACK_ORDER.filter(function (position) {
+            return position !== entry.marker.preferredTextPosition;
+          })));
+          var fit = order.map(function (position) {
+            return {
+              position: position,
+              rect: computeCandidateRect(entry.iconRect, entry.labelSize, position, _this4.config.gapPx, _this4.config.verticalGapPx)
+            };
+          }).find(function (_ref2) {
+            var rect = _ref2.rect;
+            return !_this4.collides(rect, entry.marker, entries, placedLabels);
+          });
+          if (fit) {
+            placedLabels.push(fit.rect);
+            decisions.set(entry.marker, {
+              position: fit.position,
+              hidden: false
+            });
+          } else {
+            decisions.set(entry.marker, {
+              position: entry.marker.preferredTextPosition,
+              hidden: true
+            });
+          }
+        };
+        for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+          _loop();
+        }
+      } catch (err) {
+        _iterator3.e(err);
+      } finally {
+        _iterator3.f();
+      }
+      return decisions;
+    }
+
+    /**
+     * Whether a candidate label rect clashes with any other marker's icon or
+     * with a label already placed this pass.
+     *
+     * A label's own icon is deliberately excluded: `gapPx`/`verticalGapPx`
+     * already define the spacing to it, and `paddingPx` is breathing room
+     * against *neighbors*. Counting the own icon here would make top/bottom
+     * impossible for every marker as soon as `paddingPx` exceeded
+     * `verticalGapPx` (4 vs 4 by default) — and at `paddingPx: 10` would hide
+     * every label on the map.
+     */
+  }, {
+    key: "collides",
+    value: function collides(rect, self, entries, placedLabels) {
+      var padded = expandRect(rect, this.config.paddingPx);
+      return entries.some(function (other) {
+        return other.marker !== self && rectsIntersect(padded, other.iconRect);
+      }) || placedLabels.some(function (label) {
+        return rectsIntersect(padded, label);
+      });
+    }
+
+    /** Write phase: only touches the DOM for markers whose decision actually changed. */
+  }, {
+    key: "applyDecisions",
+    value: function applyDecisions(decisions) {
+      var _this5 = this;
+      decisions.forEach(function (decision, marker) {
+        var last = _this5.lastAppliedState.get(marker);
+        if (last && last.position === decision.position && last.hidden === decision.hidden) return;
+        if (marker.textContainerEl) {
+          MarkerUtils.applyTextPosition(marker.textContainerEl, decision.position, decision.hidden);
+        }
+        _this5.lastAppliedState.set(marker, decision);
+      });
+    }
+  }]);
+}();
+function hasLabelSize(entry) {
+  return entry.labelSize !== undefined;
+}
 ;// ./src/domain/models/routeInstance.ts
 /**
  * Represents the conditions for the step animation.
@@ -12615,10 +13242,10 @@ nav_functions_defineProperty(NavFunctions, "EARTH_RADIUS", 6378000);
 function routeController_typeof(o) { "@babel/helpers - typeof"; return routeController_typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, routeController_typeof(o); }
 function routeController_ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
 function routeController_objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? routeController_ownKeys(Object(t), !0).forEach(function (r) { routeController_defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : routeController_ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
-function _toConsumableArray(r) { return _arrayWithoutHoles(r) || _iterableToArray(r) || routeController_unsupportedIterableToArray(r) || _nonIterableSpread(); }
-function _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 _iterableToArray(r) { if ("undefined" != typeof Symbol && null != r[Symbol.iterator] || null != r["@@iterator"]) return Array.from(r); }
-function _arrayWithoutHoles(r) { if (Array.isArray(r)) return routeController_arrayLikeToArray(r); }
+function routeController_toConsumableArray(r) { return routeController_arrayWithoutHoles(r) || routeController_iterableToArray(r) || routeController_unsupportedIterableToArray(r) || routeController_nonIterableSpread(); }
+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_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; }
@@ -13045,7 +13672,7 @@ var RouteController = /*#__PURE__*/function () {
           throw new Error("Error: position array has different length than colors array");
         }
         var stops = createStops(positionsToUse, colors);
-        var gradient = ["interpolate", ["linear"], ["line-progress"]].concat(_toConsumableArray(stops));
+        var gradient = ["interpolate", ["linear"], ["line-progress"]].concat(routeController_toConsumableArray(stops));
         return {
           "line-color": null,
           "line-gradient": gradient,
@@ -13156,25 +13783,49 @@ var RouteController = /*#__PURE__*/function () {
     }
 
     /**
-     * Update the visibility of route markers for all active routes.
-     * @param floorId The floor ID to update the visibility for.
+     * Every active route's marker. Used by `MarkerLayoutController` so marker
+     * labels are never placed on top of a route's own marker.
+     * @internal
      */
   }, {
-    key: "updateRouteMarkerVisibility",
-    value: function updateRouteMarkerVisibility(floorId) {
+    key: "getRouteMarkers",
+    value: function getRouteMarkers() {
+      var markers = [];
       var _iterator6 = routeController_createForOfIteratorHelper(this.routes.values()),
         _step6;
       try {
         for (_iterator6.s(); !(_step6 = _iterator6.n()).done;) {
-          var _instance$routeMarker, _instance$routeMarker2, _instance$routeMarker3;
           var instance = _step6.value;
-          ((_instance$routeMarker = instance.routeMarker) === null || _instance$routeMarker === void 0 ? void 0 : _instance$routeMarker.floorId) === floorId ? (_instance$routeMarker2 = instance.routeMarker) === null || _instance$routeMarker2 === void 0 ? void 0 : _instance$routeMarker2.show(this.map) : (_instance$routeMarker3 = instance.routeMarker) === null || _instance$routeMarker3 === void 0 ? void 0 : _instance$routeMarker3.hide();
+          if (instance.routeMarker) markers.push(instance.routeMarker);
         }
       } catch (err) {
         _iterator6.e(err);
       } finally {
         _iterator6.f();
       }
+      return markers;
+    }
+
+    /**
+     * Update the visibility of route markers for all active routes.
+     * @param floorId The floor ID to update the visibility for.
+     */
+  }, {
+    key: "updateRouteMarkerVisibility",
+    value: function updateRouteMarkerVisibility(floorId) {
+      var _iterator7 = routeController_createForOfIteratorHelper(this.routes.values()),
+        _step7;
+      try {
+        for (_iterator7.s(); !(_step7 = _iterator7.n()).done;) {
+          var _instance$routeMarker, _instance$routeMarker2, _instance$routeMarker3;
+          var instance = _step7.value;
+          ((_instance$routeMarker = instance.routeMarker) === null || _instance$routeMarker === void 0 ? void 0 : _instance$routeMarker.floorId) === floorId ? (_instance$routeMarker2 = instance.routeMarker) === null || _instance$routeMarker2 === void 0 ? void 0 : _instance$routeMarker2.show(this.map) : (_instance$routeMarker3 = instance.routeMarker) === null || _instance$routeMarker3 === void 0 ? void 0 : _instance$routeMarker3.hide();
+        }
+      } catch (err) {
+        _iterator7.e(err);
+      } finally {
+        _iterator7.f();
+      }
     }
   }, {
     key: "updatePlaceFloorForRouting",
@@ -13293,7 +13944,7 @@ var RouteController = /*#__PURE__*/function () {
       this.removeSourcesAndLayersForRoute(instance);
       this.routes["delete"](instance.id);
       if (this.lastAddedRouteId === instance.id) {
-        var remaining = _toConsumableArray(this.routes.keys());
+        var remaining = routeController_toConsumableArray(this.routes.keys());
         this.lastAddedRouteId = remaining.length > 0 ? remaining[remaining.length - 1] : undefined;
       }
       this.syncRouteCollision();
@@ -13305,18 +13956,18 @@ var RouteController = /*#__PURE__*/function () {
   }, {
     key: "removeAllRoutes",
     value: function removeAllRoutes() {
-      var _iterator7 = routeController_createForOfIteratorHelper(this.routes.values()),
-        _step7;
+      var _iterator8 = routeController_createForOfIteratorHelper(this.routes.values()),
+        _step8;
       try {
-        for (_iterator7.s(); !(_step7 = _iterator7.n()).done;) {
-          var instance = _step7.value;
+        for (_iterator8.s(); !(_step8 = _iterator8.n()).done;) {
+          var instance = _step8.value;
           this.clearRouteInstance(instance);
           this.removeSourcesAndLayersForRoute(instance);
         }
       } catch (err) {
-        _iterator7.e(err);
+        _iterator8.e(err);
       } finally {
-        _iterator7.f();
+        _iterator8.f();
       }
       this.routes.clear();
       this.lastAddedRouteId = undefined;
@@ -13330,7 +13981,7 @@ var RouteController = /*#__PURE__*/function () {
   }, {
     key: "getRouteIds",
     value: function getRouteIds() {
-      return _toConsumableArray(this.routes.keys());
+      return routeController_toConsumableArray(this.routes.keys());
     }
   }, {
     key: "internalPause",
@@ -14551,6 +15202,8 @@ var Loggeable = /*#__PURE__*/function () {
   }]);
 }();
 ;// ./src/domain/models/mapConfig.ts
+
+
 /**
  * Configuration options for map tile caching.
  * Allows controlling how map tiles are cached in memory and persisted via service worker.
@@ -14593,6 +15246,49 @@ var DEFAULT_TILE_CACHE_CONFIG = {
  */
 var MAPLIBRE_MAX_TILE_CACHE_HARD_CAP = 100000;
 
+/**
+ * Configuration for automatic marker label collision avoidance.
+ *
+ * When enabled, a marker's text label (see `MarkerConfig.textPosition`) is
+ * treated as a preferred starting side rather than a fixed placement: the
+ * SDK checks it against neighboring markers' icons and labels, moves it to
+ * a free side (right/top/left/bottom) when its preferred side is occupied,
+ * and hides it entirely when no side is collision-free. The marker's icon
+ * itself never moves.
+ *
+ * @example
+ * ```typescript
+ * const markerLayoutConfig: MarkerLayoutConfig = {
+ *   enabled: true,
+ *   minZoomForLabels: 17,
+ *   gapPx: 8,
+ *   maxLabelWidthPx: 160,
+ * };
+ * ```
+ *
+ * @group Configuration
+ */
+
+/**
+ * Default values for marker layout configuration
+ * @internal
+ */
+var DEFAULT_MARKER_LAYOUT_CONFIG = {
+  enabled: true,
+  minZoomForLabels: Number.NEGATIVE_INFINITY,
+  gapPx: 8,
+  verticalGapPx: 4,
+  paddingPx: 4,
+  maxLabelWidthPx: DEFAULT_MAX_LABEL_WIDTH_PX
+};
+
+/**
+ * Aggregate load progress for the declarative GLB models in {@link MapConfig.scene3D}, reported via
+ * {@link MapConfig.onScene3DModelsProgress}.
+ *
+ * @group Configuration
+ */
+
 /**
  * Basic configuration for the map.
  * Provides essential settings for initializing and customizing map behavior.
@@ -14642,6 +15338,7 @@ var MAPLIBRE_MAX_TILE_CACHE_HARD_CAP = 100000;
  * @property authToken - (Optional) Authentication token for accessing protected map resources. Required for loading map related data from Portal.
  * @property apiUrl - (Optional) Injected by SDK when creating map; base API URL for map requests.
  * @property mapvxRequestContext - (Optional) Injected by SDK when creating map; context sent as headers to public-api.mapvx.com.
+ * @property markerLayout - (Optional) Automatic marker label collision avoidance configuration.
  */
 ;// ./node_modules/.pnpm/@googlemaps+polyline-codec@1.0.28/node_modules/@googlemaps/polyline-codec/dist/index.esm.js
 /**
@@ -15343,8 +16040,9 @@ function MVXTransport(data) {
 ;// ./src/utils/mapvxHostname.ts
 /**
  * Returns whether a URL hostname is part of the MapVX API domain tree.
- * Matches `mapvx.com` and any subdomain (`api.mapvx.com`, `public-api.mapvx.com`,
- * `integration.mapvx.com`, etc.). Does not match lookalike domains (e.g. `notmapvx.com`).
+ * Matches `mapvx.com` and `mapvx.dev` plus any subdomain (`api.mapvx.com`,
+ * `public-api.mapvx.com`, `api.mapvx.dev`, `portal.mapvx.dev`, etc.).
+ * Does not match lookalike domains (e.g. `notmapvx.com`).
  *
  * @param hostname - Value from `URL.hostname` (no port)
  * @returns True if context headers should be attached for this host
@@ -15355,7 +16053,7 @@ function isMapVxRequestHostname(hostname) {
   if (!h) {
     return false;
   }
-  return /^(?:[a-z0-9-]+\.)*mapvx\.com$/.test(h);
+  return /^(?:[a-z0-9-]+\.)*mapvx\.(?:com|dev)$/.test(h);
 }
 ;// ./src/repository/requester.ts
 function requester_toConsumableArray(r) { return requester_arrayWithoutHoles(r) || requester_iterableToArray(r) || requester_unsupportedIterableToArray(r) || requester_nonIterableSpread(); }
@@ -18375,6 +19073,12 @@ function loadDeck() {
 ;// ./src/utils/loadGlb.ts
 function loadGlb_regenerator() { /*! regenerator-runtime -- Copyright (c) 2014-present, Facebook, Inc. -- license (MIT): https://github.com/babel/babel/blob/main/packages/babel-helpers/LICENSE */ var e, t, r = "function" == typeof Symbol ? Symbol : {}, n = r.iterator || "@@iterator", o = r.toStringTag || "@@toStringTag"; function i(r, n, o, i) { var c = n && n.prototype instanceof Generator ? n : Generator, u = Object.create(c.prototype); return loadGlb_regeneratorDefine2(u, "_invoke", function (r, n, o) { var i, c, u, f = 0, p = o || [], y = !1, G = { p: 0, n: 0, v: e, a: d, f: d.bind(e, 4), d: function d(t, r) { return i = t, c = 0, u = e, G.n = r, a; } }; function d(r, n) { for (c = r, u = n, t = 0; !y && f && !o && t < p.length; t++) { var o, i = p[t], d = G.p, l = i[2]; r > 3 ? (o = l === n) && (u = i[(c = i[4]) ? 5 : (c = 3, 3)], i[4] = i[5] = e) : i[0] <= d && ((o = r < 2 && d < i[1]) ? (c = 0, G.v = n, G.n = i[1]) : d < l && (o = r < 3 || i[0] > n || n > l) && (i[4] = r, i[5] = n, G.n = l, c = 0)); } if (o || r > 1) return a; throw y = !0, n; } return function (o, p, l) { if (f > 1) throw TypeError("Generator is already running"); for (y && 1 === p && d(p, l), c = p, u = l; (t = c < 2 ? e : u) || !y;) { i || (c ? c < 3 ? (c > 1 && (G.n = -1), d(c, u)) : G.n = u : G.v = u); try { if (f = 2, i) { if (c || (o = "next"), t = i[o]) { if (!(t = t.call(i, u))) throw TypeError("iterator result is not an object"); if (!t.done) return t; u = t.value, c < 2 && (c = 0); } else 1 === c && (t = i["return"]) && t.call(i), c < 2 && (u = TypeError("The iterator does not provide a '" + o + "' method"), c = 1); i = e; } else if ((t = (y = G.n < 0) ? u : r.call(n, G)) !== a) break; } catch (t) { i = e, c = 1, u = t; } finally { f = 1; } } return { value: t, done: y }; }; }(r, o, i), !0), u; } var a = {}; function Generator() {} function GeneratorFunction() {} function GeneratorFunctionPrototype() {} t = Object.getPrototypeOf; var c = [][n] ? t(t([][n]())) : (loadGlb_regeneratorDefine2(t = {}, n, function () { return this; }), t), u = GeneratorFunctionPrototype.prototype = Generator.prototype = Object.create(c); function f(e) { return Object.setPrototypeOf ? Object.setPrototypeOf(e, GeneratorFunctionPrototype) : (e.__proto__ = GeneratorFunctionPrototype, loadGlb_regeneratorDefine2(e, o, "GeneratorFunction")), e.prototype = Object.create(u), e; } return GeneratorFunction.prototype = GeneratorFunctionPrototype, loadGlb_regeneratorDefine2(u, "constructor", GeneratorFunctionPrototype), loadGlb_regeneratorDefine2(GeneratorFunctionPrototype, "constructor", GeneratorFunction), GeneratorFunction.displayName = "GeneratorFunction", loadGlb_regeneratorDefine2(GeneratorFunctionPrototype, o, "GeneratorFunction"), loadGlb_regeneratorDefine2(u), loadGlb_regeneratorDefine2(u, o, "Generator"), loadGlb_regeneratorDefine2(u, n, function () { return this; }), loadGlb_regeneratorDefine2(u, "toString", function () { return "[object Generator]"; }), (loadGlb_regenerator = function _regenerator() { return { w: i, m: f }; })(); }
 function loadGlb_regeneratorDefine2(e, r, n, t) { var i = Object.defineProperty; try { i({}, "", {}); } catch (e) { i = 0; } loadGlb_regeneratorDefine2 = function _regeneratorDefine(e, r, n, t) { function o(r, n) { loadGlb_regeneratorDefine2(e, r, function (e) { return this._invoke(r, n, e); }); } r ? i ? i(e, r, { value: n, enumerable: !t, configurable: !t, writable: !t }) : e[r] = n : (o("next", 0), o("throw", 1), o("return", 2)); }, loadGlb_regeneratorDefine2(e, r, n, t); }
+function loadGlb_slicedToArray(r, e) { return loadGlb_arrayWithHoles(r) || loadGlb_iterableToArrayLimit(r, e) || loadGlb_unsupportedIterableToArray(r, e) || loadGlb_nonIterableRest(); }
+function loadGlb_nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function loadGlb_unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return loadGlb_arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? loadGlb_arrayLikeToArray(r, a) : void 0; } }
+function loadGlb_arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
+function loadGlb_iterableToArrayLimit(r, l) { var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (null != t) { var e, n, i, u, a = [], f = !0, o = !1; try { if (i = (t = t.call(r)).next, 0 === l) { if (Object(t) !== t) return; f = !1; } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0); } catch (r) { o = !0, n = r; } finally { try { if (!f && null != t["return"] && (u = t["return"](), Object(u) !== u)) return; } finally { if (o) throw n; } } return a; } }
+function loadGlb_arrayWithHoles(r) { if (Array.isArray(r)) return r; }
 function loadGlb_asyncGeneratorStep(n, t, e, r, o, a, c) { try { var i = n[a](c), u = i.value; } catch (n) { return void e(n); } i.done ? t(u) : Promise.resolve(u).then(r, o); }
 function loadGlb_asyncToGenerator(n) { return function () { var t = this, e = arguments; return new Promise(function (r, o) { var a = n.apply(t, e); function _next(n) { loadGlb_asyncGeneratorStep(a, r, o, _next, _throw, "next", n); } function _throw(n) { loadGlb_asyncGeneratorStep(a, r, o, _next, _throw, "throw", n); } _next(void 0); }); }; }
 
@@ -18404,10 +19108,58 @@ function getGltfLoader() {
   return gltfLoaderPromise;
 }
 
+/**
+ * Default per-asset timeout for {@link loadGlbRoot}.
+ *
+ * Guards against loaders that hang instead of throwing — a GLB whose binary chunk is truncated
+ * (see {@link loadGlbRoot}'s completeness check) or otherwise malformed can put Three.js's
+ * `DRACOLoader` into an undefined state: sometimes a decode error, sometimes no callback at all.
+ * Without a timeout, one such asset never settles and blocks every other load queued behind it.
+ *
+ * @group Configuration
+ */
+var DEFAULT_GLB_LOAD_TIMEOUT_MS = 30000;
+
+/**
+ * Magic number ("glTF" read little-endian) at byte offset 0 of every binary glTF (`.glb`)
+ * container. Used only to tell a binary GLB apart from a plain JSON `.gltf` payload — the latter
+ * has no such header and skips the completeness check in {@link assertGlbBufferComplete}.
+ */
+var GLB_MAGIC = 0x46546c67;
+
+/**
+ * Rejects a GLB download that was cut short before it reaches Three.js's `GLTFLoader`/`DRACOLoader`,
+ * whose behavior on truncated input ranges from a cryptic decode error (e.g. "Unexpected geometry
+ * type") to an outright hang, rather than a clear message pointing at the actual problem.
+ *
+ * The binary glTF container format requires the 12-byte header's declared total length to equal
+ * the file's real byte length (see the {@link https://registry.khronos.org/glTF/specs/2.0/glTF-2.0.html#binary-header | spec}).
+ * A mismatch means the response body was truncated — a dropped connection, or the object stored at
+ * `url` is itself incomplete — so every buffer-view offset past that point reads garbage. This is
+ * exactly what was found in the field for one "Suelo" asset that both threw a decode error and (in
+ * a larger sibling file) hung: the file's own header declared a ~383 MB binary chunk while only
+ * ~8.7 MB had actually been received.
+ */
+function assertGlbBufferComplete(buffer, url) {
+  if (buffer.byteLength < 12) return; // too short to have a GLB header; let parse() report it
+  var header = new DataView(buffer, 0, 12);
+  if (header.getUint32(0, true) !== GLB_MAGIC) return; // plain JSON .gltf, not a binary .glb
+  var declaredLength = header.getUint32(8, true);
+  if (declaredLength !== buffer.byteLength) {
+    throw new Error("GLB download is truncated or corrupt: header declares ".concat(declaredLength, " bytes, received ").concat(buffer.byteLength, ": ").concat(url));
+  }
+}
+
+/** Options for {@link loadGlbRoot}. */
+
 /**
  * Loads a GLB/GLTF from URL and returns the root scene group.
  * Central entry point so the loader implementation can be swapped later (e.g. Draco, KTX2, custom fetch).
  *
+ * Fetches the raw bytes itself (rather than deferring to `GLTFLoader.load`) so a truncated download
+ * can be caught and rejected clearly — see {@link assertGlbBufferComplete} — before it ever reaches
+ * the Draco/KTX2 decoders.
+ *
  * @param url - GLB URL
  * @returns Root `THREE.Group` from the loaded glTF scene
  * @group Utils
@@ -18417,23 +19169,99 @@ function loadGlbRoot(_x) {
 }
 function _loadGlbRoot() {
   _loadGlbRoot = loadGlb_asyncToGenerator(/*#__PURE__*/loadGlb_regenerator().m(function _callee(url) {
-    var gltfLoader;
+    var options,
+      _options$timeoutMs,
+      timeoutMs,
+      onProgress,
+      _yield$Promise$all,
+      _yield$Promise$all2,
+      gltfLoader,
+      three,
+      settled,
+      fileLoader,
+      load,
+      timer,
+      timeout,
+      _args = arguments;
     return loadGlb_regenerator().w(function (_context) {
-      while (1) switch (_context.n) {
+      while (1) switch (_context.p = _context.n) {
         case 0:
+          options = _args.length > 1 && _args[1] !== undefined ? _args[1] : {};
+          _options$timeoutMs = options.timeoutMs, timeoutMs = _options$timeoutMs === void 0 ? DEFAULT_GLB_LOAD_TIMEOUT_MS : _options$timeoutMs, onProgress = options.onProgress;
           _context.n = 1;
-          return getGltfLoader();
+          return Promise.all([getGltfLoader(), loadThree()]);
         case 1:
-          gltfLoader = _context.v;
-          return _context.a(2, new Promise(function (resolve, reject) {
-            gltfLoader.load(url, function (gltf) {
-              resolve(gltf.scene);
-            }, undefined, function (error) {
+          _yield$Promise$all = _context.v;
+          _yield$Promise$all2 = loadGlb_slicedToArray(_yield$Promise$all, 2);
+          gltfLoader = _yield$Promise$all2[0];
+          three = _yield$Promise$all2[1].THREE;
+          // Set once the caller has stopped waiting (success, failure, or timeout) so any callback three
+          // fires afterwards — e.g. a timed-out fetch/decode that keeps running in the background — is a
+          // no-op instead of resolving/rejecting an already-settled promise or emitting a stray progress
+          // event after the batch this asset belongs to already reported `done: true`.
+          settled = false;
+          fileLoader = new three.FileLoader();
+          fileLoader.setResponseType("arraybuffer");
+          load = new Promise(function (resolve, reject) {
+            var onError = function onError(error) {
+              if (settled) return;
               reject(error instanceof Error ? error : new Error(String(error)));
-            });
-          }));
-      }
-    }, _callee);
+            };
+            fileLoader.load(url, function (data) {
+              if (settled) return;
+              var buffer = data;
+              try {
+                assertGlbBufferComplete(buffer, url);
+              } catch (err) {
+                onError(err);
+                return;
+              }
+              gltfLoader.parse(buffer, three.LoaderUtils.extractUrlBase(url), function (gltf) {
+                if (settled) return;
+                resolve(gltf.scene);
+              }, onError);
+            }, function (event) {
+              if (!settled) onProgress === null || onProgress === void 0 || onProgress(event);
+            }, onError);
+          });
+          if (!(!Number.isFinite(timeoutMs) || timeoutMs <= 0)) {
+            _context.n = 5;
+            break;
+          }
+          _context.p = 2;
+          _context.n = 3;
+          return load;
+        case 3:
+          return _context.a(2, _context.v);
+        case 4:
+          _context.p = 4;
+          settled = true;
+          return _context.f(4);
+        case 5:
+          timeout = new Promise(function (_resolve, reject) {
+            timer = setTimeout(function () {
+              return reject(new Error("Timed out loading GLB after ".concat(timeoutMs, "ms: ").concat(url)));
+            }, timeoutMs);
+          });
+          _context.p = 6;
+          _context.n = 7;
+          return Promise.race([load, timeout]);
+        case 7:
+          return _context.a(2, _context.v);
+        case 8:
+          _context.p = 8;
+          settled = true;
+          clearTimeout(timer);
+          // Cancels the underlying fetch (and, by never delivering its buffer, the Draco/KTX2 decode)
+          // so a timed-out asset actually frees its network/CPU usage instead of running to completion
+          // unattended — otherwise GLB_LOAD_CONCURRENCY only bounds how many loads the caller awaits,
+          // not how many are truly in flight. A no-op if `load` already won the race.
+          fileLoader.abort();
+          return _context.f(8);
+        case 9:
+          return _context.a(2);
+      }
+    }, _callee, null, [[6,, 8, 9], [2,, 4, 5]]);
   }));
   return _loadGlbRoot.apply(this, arguments);
 }
@@ -18501,7 +19329,11 @@ function scene3DController_nonIterableRest() { throw new TypeError("Invalid atte
 function scene3DController_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 scene3DController_arrayWithHoles(r) { if (Array.isArray(r)) return r; }
 function scene3DController_createForOfIteratorHelper(r, e) { var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (!t) { if (Array.isArray(r) || (t = scene3DController_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 scene3DController_toConsumableArray(r) { return scene3DController_arrayWithoutHoles(r) || scene3DController_iterableToArray(r) || scene3DController_unsupportedIterableToArray(r) || scene3DController_nonIterableSpread(); }
+function scene3DController_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 scene3DController_unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return scene3DController_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) ? scene3DController_arrayLikeToArray(r, a) : void 0; } }
+function scene3DController_iterableToArray(r) { if ("undefined" != typeof Symbol && null != r[Symbol.iterator] || null != r["@@iterator"]) return Array.from(r); }
+function scene3DController_arrayWithoutHoles(r) { if (Array.isArray(r)) return scene3DController_arrayLikeToArray(r); }
 function scene3DController_arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
 function scene3DController_regenerator() { /*! regenerator-runtime -- Copyright (c) 2014-present, Facebook, Inc. -- license (MIT): https://github.com/babel/babel/blob/main/packages/babel-helpers/LICENSE */ var e, t, r = "function" == typeof Symbol ? Symbol : {}, n = r.iterator || "@@iterator", o = r.toStringTag || "@@toStringTag"; function i(r, n, o, i) { var c = n && n.prototype instanceof Generator ? n : Generator, u = Object.create(c.prototype); return scene3DController_regeneratorDefine2(u, "_invoke", function (r, n, o) { var i, c, u, f = 0, p = o || [], y = !1, G = { p: 0, n: 0, v: e, a: d, f: d.bind(e, 4), d: function d(t, r) { return i = t, c = 0, u = e, G.n = r, a; } }; function d(r, n) { for (c = r, u = n, t = 0; !y && f && !o && t < p.length; t++) { var o, i = p[t], d = G.p, l = i[2]; r > 3 ? (o = l === n) && (u = i[(c = i[4]) ? 5 : (c = 3, 3)], i[4] = i[5] = e) : i[0] <= d && ((o = r < 2 && d < i[1]) ? (c = 0, G.v = n, G.n = i[1]) : d < l && (o = r < 3 || i[0] > n || n > l) && (i[4] = r, i[5] = n, G.n = l, c = 0)); } if (o || r > 1) return a; throw y = !0, n; } return function (o, p, l) { if (f > 1) throw TypeError("Generator is already running"); for (y && 1 === p && d(p, l), c = p, u = l; (t = c < 2 ? e : u) || !y;) { i || (c ? c < 3 ? (c > 1 && (G.n = -1), d(c, u)) : G.n = u : G.v = u); try { if (f = 2, i) { if (c || (o = "next"), t = i[o]) { if (!(t = t.call(i, u))) throw TypeError("iterator result is not an object"); if (!t.done) return t; u = t.value, c < 2 && (c = 0); } else 1 === c && (t = i["return"]) && t.call(i), c < 2 && (u = TypeError("The iterator does not provide a '" + o + "' method"), c = 1); i = e; } else if ((t = (y = G.n < 0) ? u : r.call(n, G)) !== a) break; } catch (t) { i = e, c = 1, u = t; } finally { f = 1; } } return { value: t, done: y }; }; }(r, o, i), !0), u; } var a = {}; function Generator() {} function GeneratorFunction() {} function GeneratorFunctionPrototype() {} t = Object.getPrototypeOf; var c = [][n] ? t(t([][n]())) : (scene3DController_regeneratorDefine2(t = {}, n, function () { return this; }), t), u = GeneratorFunctionPrototype.prototype = Generator.prototype = Object.create(c); function f(e) { return Object.setPrototypeOf ? Object.setPrototypeOf(e, GeneratorFunctionPrototype) : (e.__proto__ = GeneratorFunctionPrototype, scene3DController_regeneratorDefine2(e, o, "GeneratorFunction")), e.prototype = Object.create(u), e; } return GeneratorFunction.prototype = GeneratorFunctionPrototype, scene3DController_regeneratorDefine2(u, "constructor", GeneratorFunctionPrototype), scene3DController_regeneratorDefine2(GeneratorFunctionPrototype, "constructor", GeneratorFunction), GeneratorFunction.displayName = "GeneratorFunction", scene3DController_regeneratorDefine2(GeneratorFunctionPrototype, o, "GeneratorFunction"), scene3DController_regeneratorDefine2(u), scene3DController_regeneratorDefine2(u, o, "Generator"), scene3DController_regeneratorDefine2(u, n, function () { return this; }), scene3DController_regeneratorDefine2(u, "toString", function () { return "[object Generator]"; }), (scene3DController_regenerator = function _regenerator() { return { w: i, m: f }; })(); }
 function scene3DController_regeneratorDefine2(e, r, n, t) { var i = Object.defineProperty; try { i({}, "", {}); } catch (e) { i = 0; } scene3DController_regeneratorDefine2 = function _regeneratorDefine(e, r, n, t) { function o(r, n) { scene3DController_regeneratorDefine2(e, r, function (e) { return this._invoke(r, n, e); }); } r ? i ? i(e, r, { value: n, enumerable: !t, configurable: !t, writable: !t }) : e[r] = n : (o("next", 0), o("throw", 1), o("return", 2)); }, scene3DController_regeneratorDefine2(e, r, n, t); }
@@ -18520,6 +19352,7 @@ function scene3DController_toPrimitive(t, r) { if ("object" != scene3DController
 
 
 
+
 /**
  * Owns the experimental 3D scene for a MapLibre map: the deck.gl overlay layers (elevated room
  * outlines, indoor labels, POI icons, store logos) and the declarative GLB custom layer rendered
@@ -18536,7 +19369,7 @@ function scene3DController_toPrimitive(t, r) { if ("object" != scene3DController
  * @group Map
  */
 var Scene3DController = /*#__PURE__*/function () {
-  function Scene3DController(map, scene3DConfig, initialCenter) {
+  function Scene3DController(map, scene3DConfig, initialCenter, onModelsProgress) {
     scene3DController_classCallCheck(this, Scene3DController);
     /** Latest known floor key; updated by the floor-change hooks and read when (re)building layers. */
     scene3DController_defineProperty(this, "currentFloor", "");
@@ -18565,6 +19398,7 @@ var Scene3DController = /*#__PURE__*/function () {
     this.map = map;
     this.scene3DConfig = scene3DConfig;
     this.initialCenter = initialCenter;
+    this.onModelsProgress = onModelsProgress;
   }
 
   // Lifecycle entry points forwarded by the map ---------------------------------------------
@@ -18793,72 +19627,164 @@ var Scene3DController = /*#__PURE__*/function () {
   }, {
     key: "loadScene3DGlbTemplates",
     value: function () {
-      var _loadScene3DGlbTemplates = scene3DController_asyncToGenerator(/*#__PURE__*/scene3DController_regenerator().m(function _callee3() {
-        var _this$threeMod2;
-        var three, models, _iterator, _step, asset, root, center, _t2, _t3;
-        return scene3DController_regenerator().w(function (_context3) {
-          while (1) switch (_context3.p = _context3.n) {
+      var _loadScene3DGlbTemplates = scene3DController_asyncToGenerator(/*#__PURE__*/scene3DController_regenerator().m(function _callee4() {
+        var _this$threeMod2,
+          _this2 = this;
+        var three, models, uniqueUrls, errorByUrl, semaphore, loadedBytesByUrl, totalBytesByUrl, settledAssets, totalAssets, reportProgress, _iterator2, _step2, asset, root, center, _t5;
+        return scene3DController_regenerator().w(function (_context4) {
+          while (1) switch (_context4.p = _context4.n) {
             case 0:
               three = (_this$threeMod2 = this.threeMod) === null || _this$threeMod2 === void 0 ? void 0 : _this$threeMod2.THREE;
               models = this.scene3DConfig.models;
               if (!(!three || !models || models.enabled === false || models.assets.length === 0)) {
-                _context3.n = 1;
+                _context4.n = 1;
                 break;
               }
-              return _context3.a(2);
+              return _context4.a(2);
             case 1:
               this.scene3DGlbRootByUrl.clear();
               this.scene3DGlbTemplateById.clear();
-              _iterator = scene3DController_createForOfIteratorHelper(models.assets);
-              _context3.p = 2;
-              _iterator.s();
-            case 3:
-              if ((_step = _iterator.n()).done) {
-                _context3.n = 9;
+
+              // Load every distinct URL with bounded concurrency (see GLB_LOAD_CONCURRENCY) instead of one
+              // at a time, and let each load time out (see loadGlbRoot) — a single hung or malformed/truncated
+              // asset is skipped and logged instead of blocking every asset queued behind it. Deduplicating by
+              // URL up front — not inside the concurrent task — means assets sharing a URL never trigger
+              // duplicate loads and never tie up more than one concurrency slot waiting on the same result.
+              uniqueUrls = scene3DController_toConsumableArray(new Set(models.assets.map(function (asset) {
+                return asset.url;
+              })));
+              errorByUrl = new globalThis.Map();
+              semaphore = new Semaphore(Scene3DController.GLB_LOAD_CONCURRENCY); // Progress bookkeeping for `onModelsProgress` (e.g. a totem's loading bar). Kept even when no
+              // callback is registered — the cost is a handful of Map writes over at most a few dozen assets.
+              loadedBytesByUrl = new globalThis.Map();
+              totalBytesByUrl = new globalThis.Map();
+              settledAssets = 0;
+              totalAssets = uniqueUrls.length;
+              reportProgress = function reportProgress(done) {
+                if (!_this2.onModelsProgress) return;
+                var loadedBytes = 0;
+                var totalBytes = 0;
+                var _iterator = scene3DController_createForOfIteratorHelper(uniqueUrls),
+                  _step;
+                try {
+                  for (_iterator.s(); !(_step = _iterator.n()).done;) {
+                    var _loadedBytesByUrl$get;
+                    var url = _step.value;
+                    loadedBytes += (_loadedBytesByUrl$get = loadedBytesByUrl.get(url)) !== null && _loadedBytesByUrl$get !== void 0 ? _loadedBytesByUrl$get : 0;
+                    var total = totalBytesByUrl.get(url);
+                    totalBytes = total == null || totalBytes === null ? null : totalBytes + total;
+                  }
+                } catch (err) {
+                  _iterator.e(err);
+                } finally {
+                  _iterator.f();
+                }
+                try {
+                  _this2.onModelsProgress({
+                    loadedAssets: settledAssets,
+                    totalAssets: totalAssets,
+                    loadedBytes: loadedBytes,
+                    totalBytes: totalBytes,
+                    done: done
+                  });
+                } catch (err) {
+                  // Isolate the SDK's own load bookkeeping from a throwing consumer callback — letting this
+                  // escape would reject the `Promise.all` below (or, from the `onProgress` path, break
+                  // three.js's internal stream-reading chain) and lose every already-loaded asset.
+                  console.error("onScene3DModelsProgress callback threw", err);
+                }
+              };
+              _context4.n = 2;
+              return Promise.all(uniqueUrls.map(/*#__PURE__*/function () {
+                var _ref = scene3DController_asyncToGenerator(/*#__PURE__*/scene3DController_regenerator().m(function _callee3(url) {
+                  var _ref2, _totalBytesByUrl$get, _t2, _t3, _t4;
+                  return scene3DController_regenerator().w(function (_context3) {
+                    while (1) switch (_context3.p = _context3.n) {
+                      case 0:
+                        _context3.n = 1;
+                        return semaphore.acquire();
+                      case 1:
+                        _context3.p = 1;
+                        _t2 = _this2.scene3DGlbRootByUrl;
+                        _t3 = url;
+                        _context3.n = 2;
+                        return loadGlbRoot(url, {
+                          onProgress: function onProgress(event) {
+                            loadedBytesByUrl.set(url, event.loaded);
+                            totalBytesByUrl.set(url, event.lengthComputable ? event.total : null);
+                            reportProgress(false);
+                          }
+                        });
+                      case 2:
+                        _t2.set.call(_t2, _t3, _context3.v);
+                        _context3.n = 4;
+                        break;
+                      case 3:
+                        _context3.p = 3;
+                        _t4 = _context3.v;
+                        errorByUrl.set(url, _t4);
+                      case 4:
+                        _context3.p = 4;
+                        settledAssets++;
+                        // Once a URL has settled, its total is knowable even if no progress event ever supplied
+                        // one (failed before the first byte, or the server omitted Content-Length): fall back to
+                        // however many bytes actually arrived. Otherwise a single such asset would force the
+                        // whole batch's `totalBytes` to stay `null` forever, even after `done: true`.
+                        totalBytesByUrl.set(url, (_ref2 = (_totalBytesByUrl$get = totalBytesByUrl.get(url)) !== null && _totalBytesByUrl$get !== void 0 ? _totalBytesByUrl$get : loadedBytesByUrl.get(url)) !== null && _ref2 !== void 0 ? _ref2 : 0);
+                        semaphore.release();
+                        reportProgress(false);
+                        return _context3.f(4);
+                      case 5:
+                        return _context3.a(2);
+                    }
+                  }, _callee3, null, [[1, 3, 4, 5]]);
+                }));
+                return function (_x) {
+                  return _ref.apply(this, arguments);
+                };
+              }()));
+            case 2:
+              reportProgress(true);
+              _iterator2 = scene3DController_createForOfIteratorHelper(models.assets);
+              _context4.p = 3;
+              _iterator2.s();
+            case 4:
+              if ((_step2 = _iterator2.n()).done) {
+                _context4.n = 7;
                 break;
               }
-              asset = _step.value;
-              _context3.p = 4;
+              asset = _step2.value;
               root = this.scene3DGlbRootByUrl.get(asset.url);
               if (root) {
-                _context3.n = 6;
+                _context4.n = 5;
                 break;
               }
-              _context3.n = 5;
-              return loadGlbRoot(asset.url);
+              console.error("Failed to load GLB asset \"".concat(asset.id, "\" from ").concat(asset.url), errorByUrl.get(asset.url));
+              return _context4.a(3, 6);
             case 5:
-              root = _context3.v;
-              this.scene3DGlbRootByUrl.set(asset.url, root);
-            case 6:
               center = computeGlbBottomAnchor(three, root);
               this.scene3DGlbTemplateById.set(asset.id, {
                 root: root,
                 center: center
               });
-              _context3.n = 8;
+            case 6:
+              _context4.n = 4;
               break;
             case 7:
-              _context3.p = 7;
-              _t2 = _context3.v;
-              console.error("Failed to load GLB asset \"".concat(asset.id, "\" from ").concat(asset.url), _t2);
-            case 8:
-              _context3.n = 3;
+              _context4.n = 9;
               break;
+            case 8:
+              _context4.p = 8;
+              _t5 = _context4.v;
+              _iterator2.e(_t5);
             case 9:
-              _context3.n = 11;
-              break;
+              _context4.p = 9;
+              _iterator2.f();
+              return _context4.f(9);
             case 10:
-              _context3.p = 10;
-              _t3 = _context3.v;
-              _iterator.e(_t3);
-            case 11:
-              _context3.p = 11;
-              _iterator.f();
-              return _context3.f(11);
-            case 12:
-              return _context3.a(2);
+              return _context4.a(2);
           }
-        }, _callee3, this, [[4, 7], [2, 10, 11, 12]]);
+        }, _callee4, this, [[3, 8, 9, 10]]);
       }));
       function loadScene3DGlbTemplates() {
         return _loadScene3DGlbTemplates.apply(this, arguments);
@@ -18875,7 +19801,7 @@ var Scene3DController = /*#__PURE__*/function () {
         _models$globalOffset2,
         _models$globalOffset$3,
         _models$globalOffset3,
-        _this2 = this;
+        _this3 = this;
       var three = (_this$threeMod3 = this.threeMod) === null || _this$threeMod3 === void 0 ? void 0 : _this$threeMod3.THREE;
       if (!three || !this.scene3DGlbScene) {
         return;
@@ -18896,16 +19822,16 @@ var Scene3DController = /*#__PURE__*/function () {
       var floorKey = this.currentFloor;
       var modelsGroup = new three.Group();
       modelsGroup.position.set((_models$globalOffset$ = (_models$globalOffset = models.globalOffset) === null || _models$globalOffset === void 0 ? void 0 : _models$globalOffset.x) !== null && _models$globalOffset$ !== void 0 ? _models$globalOffset$ : 0, (_models$globalOffset$2 = (_models$globalOffset2 = models.globalOffset) === null || _models$globalOffset2 === void 0 ? void 0 : _models$globalOffset2.y) !== null && _models$globalOffset$2 !== void 0 ? _models$globalOffset$2 : 0, (_models$globalOffset$3 = (_models$globalOffset3 = models.globalOffset) === null || _models$globalOffset3 === void 0 ? void 0 : _models$globalOffset3.z) !== null && _models$globalOffset$3 !== void 0 ? _models$globalOffset$3 : 0);
-      var _iterator2 = scene3DController_createForOfIteratorHelper(models.placements),
-        _step2;
+      var _iterator3 = scene3DController_createForOfIteratorHelper(models.placements),
+        _step3;
       try {
         var _loop = function _loop() {
             var _placement$position$a;
-            var placement = _step2.value;
+            var placement = _step3.value;
             if (!isPlacementVisibleOnFloor(placement, floorKey)) {
               return 0; // continue
             }
-            var template = _this2.scene3DGlbTemplateById.get(placement.assetId);
+            var template = _this3.scene3DGlbTemplateById.get(placement.assetId);
             if (!template) {
               return 0; // continue
             }
@@ -18967,14 +19893,14 @@ var Scene3DController = /*#__PURE__*/function () {
             modelsGroup.add(pivot);
           },
           _ret;
-        for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+        for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
           _ret = _loop();
           if (_ret === 0) continue;
         }
       } catch (err) {
-        _iterator2.e(err);
+        _iterator3.e(err);
       } finally {
-        _iterator2.f();
+        _iterator3.f();
       }
       this.scene3DModelsGroup = modelsGroup;
       this.scene3DGlbScene.add(modelsGroup);
@@ -18995,14 +19921,14 @@ var Scene3DController = /*#__PURE__*/function () {
     key: "recomputeRouteAffectedModels",
     value: function recomputeRouteAffectedModels() {
       var _this$threeMod4,
-        _this3 = this;
+        _this4 = this;
       var three = (_this$threeMod4 = this.threeMod) === null || _this$threeMod4 === void 0 ? void 0 : _this$threeMod4.THREE;
       var modelsGroup = this.scene3DModelsGroup;
       if (!three || !modelsGroup) {
         return;
       }
       var points = this.scene3DRouteCollisionPoints.filter(function (p) {
-        return p.floorKey === _this3.currentFloor;
+        return p.floorKey === _this4.currentFloor;
       });
 
       // Convert each route point into the models group's local frame (metres relative to
@@ -19019,11 +19945,11 @@ var Scene3DController = /*#__PURE__*/function () {
       });
       modelsGroup.updateMatrixWorld(true);
       var local = new three.Vector3();
-      var _iterator3 = scene3DController_createForOfIteratorHelper(modelsGroup.children),
-        _step3;
+      var _iterator4 = scene3DController_createForOfIteratorHelper(modelsGroup.children),
+        _step4;
       try {
         var _loop2 = function _loop2() {
-          var pivot = _step3.value;
+          var pivot = _step4.value;
           var routeCfg = pivot.userData.routeTransparency;
           var footprint = pivot.userData.footprint;
           // Only models with a route-transparency config participate (feature activation gate).
@@ -19040,13 +19966,13 @@ var Scene3DController = /*#__PURE__*/function () {
             return pointInFootprint(footprint, local.x, local.z);
           });
         };
-        for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+        for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
           if (_loop2()) continue;
         }
       } catch (err) {
-        _iterator3.e(err);
+        _iterator4.e(err);
       } finally {
-        _iterator3.f();
+        _iterator4.f();
       }
     }
 
@@ -19066,11 +19992,11 @@ var Scene3DController = /*#__PURE__*/function () {
       }
       var zoom = this.map.getZoom();
       var changed = false;
-      var _iterator4 = scene3DController_createForOfIteratorHelper(this.scene3DModelsGroup.children),
-        _step4;
+      var _iterator5 = scene3DController_createForOfIteratorHelper(this.scene3DModelsGroup.children),
+        _step5;
       try {
         var _loop3 = function _loop3() {
-          var pivot = _step4.value;
+          var pivot = _step5.value;
           var zoomCfg = pivot.userData.zoomTransparency;
           var routeCfg = pivot.userData.routeTransparency;
           var routeAffected = pivot.userData.routeAffected === true;
@@ -19081,11 +20007,11 @@ var Scene3DController = /*#__PURE__*/function () {
               return;
             }
             var materials = Array.isArray(mesh.material) ? mesh.material : [mesh.material];
-            var _iterator5 = scene3DController_createForOfIteratorHelper(materials),
-              _step5;
+            var _iterator6 = scene3DController_createForOfIteratorHelper(materials),
+              _step6;
             try {
-              for (_iterator5.s(); !(_step5 = _iterator5.n()).done;) {
-                var material = _step5.value;
+              for (_iterator6.s(); !(_step6 = _iterator6.n()).done;) {
+                var material = _step6.value;
                 if (material.opacity !== opacity) {
                   material.transparent = opacity < 1;
                   material.opacity = opacity;
@@ -19095,19 +20021,19 @@ var Scene3DController = /*#__PURE__*/function () {
                 }
               }
             } catch (err) {
-              _iterator5.e(err);
+              _iterator6.e(err);
             } finally {
-              _iterator5.f();
+              _iterator6.f();
             }
           });
         };
-        for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
+        for (_iterator5.s(); !(_step5 = _iterator5.n()).done;) {
           _loop3();
         }
       } catch (err) {
-        _iterator4.e(err);
+        _iterator5.e(err);
       } finally {
-        _iterator4.f();
+        _iterator5.f();
       }
       if (changed) {
         this.map.triggerRepaint();
@@ -19116,12 +20042,12 @@ var Scene3DController = /*#__PURE__*/function () {
   }, {
     key: "loadSpriteAtlas",
     value: function () {
-      var _loadSpriteAtlas = scene3DController_asyncToGenerator(/*#__PURE__*/scene3DController_regenerator().m(function _callee4(spriteUrl) {
+      var _loadSpriteAtlas = scene3DController_asyncToGenerator(/*#__PURE__*/scene3DController_regenerator().m(function _callee5(spriteUrl) {
         var _yield$Promise$all, _yield$Promise$all2, json, img;
-        return scene3DController_regenerator().w(function (_context4) {
-          while (1) switch (_context4.n) {
+        return scene3DController_regenerator().w(function (_context5) {
+          while (1) switch (_context5.n) {
             case 0:
-              _context4.n = 1;
+              _context5.n = 1;
               return Promise.all([fetch("".concat(spriteUrl, ".json")).then(function (r) {
                 return r.json();
               }), new Promise(function (resolve, reject) {
@@ -19134,18 +20060,18 @@ var Scene3DController = /*#__PURE__*/function () {
                 image.src = "".concat(spriteUrl, ".png");
               })]);
             case 1:
-              _yield$Promise$all = _context4.v;
+              _yield$Promise$all = _context5.v;
               _yield$Promise$all2 = scene3DController_slicedToArray(_yield$Promise$all, 2);
               json = _yield$Promise$all2[0];
               img = _yield$Promise$all2[1];
               this.spriteIconMapping = json;
               this.spriteAtlasImage = img;
             case 2:
-              return _context4.a(2);
+              return _context5.a(2);
           }
-        }, _callee4, this);
+        }, _callee5, this);
       }));
-      function loadSpriteAtlas(_x) {
+      function loadSpriteAtlas(_x2) {
         return _loadSpriteAtlas.apply(this, arguments);
       }
       return loadSpriteAtlas;
@@ -19189,7 +20115,7 @@ var Scene3DController = /*#__PURE__*/function () {
       var _layerConfig$binaryDa2,
         _layerConfig$minZoom,
         _layerConfig$maxZoom,
-        _this4 = this;
+        _this5 = this;
       var useSdf = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;
       var deck = this.deckMod;
       if (!deck) return null;
@@ -19204,7 +20130,7 @@ var Scene3DController = /*#__PURE__*/function () {
           // Use area_name and poi Point features — unique per tile, no duplicates.
           // If a logo-{name} image exists in the sprite, the icon takes priority over the text label.
           var textData = buildLabelData(props.data || [], floorKey, function (imageId) {
-            return _this4.map.hasImage(imageId);
+            return _this5.map.hasImage(imageId);
           }, (_layerConfig$defaultH2 = layerConfig.defaultHeight) !== null && _layerConfig$defaultH2 !== void 0 ? _layerConfig$defaultH2 : 5);
           if (!textData.length) return null;
           return new deck.TextLayer(scene3DController_objectSpread(scene3DController_objectSpread({}, props), {}, {
@@ -19243,7 +20169,7 @@ var Scene3DController = /*#__PURE__*/function () {
       var _layerConfig$binaryDa3,
         _layerConfig$minZoom2,
         _layerConfig$maxZoom2,
-        _this5 = this;
+        _this6 = this;
       var deck = this.deckMod;
       if (!deck || !this.spriteIconMapping || !this.spriteAtlasImage) return null;
       return new deck.MVTLayer({
@@ -19259,8 +20185,8 @@ var Scene3DController = /*#__PURE__*/function () {
           return new deck.IconLayer(scene3DController_objectSpread(scene3DController_objectSpread({}, props), {}, {
             id: "".concat(props.id, "-poi-icons"),
             data: iconData,
-            iconAtlas: _this5.spriteAtlasImage,
-            iconMapping: _this5.spriteIconMapping,
+            iconAtlas: _this6.spriteAtlasImage,
+            iconMapping: _this6.spriteIconMapping,
             getIcon: function getIcon(d) {
               return d.icon;
             },
@@ -19285,7 +20211,7 @@ var Scene3DController = /*#__PURE__*/function () {
       var _layerConfig$binaryDa4,
         _layerConfig$minZoom3,
         _layerConfig$maxZoom3,
-        _this6 = this;
+        _this7 = this;
       var deck = this.deckMod;
       if (!deck || !this.spriteIconMapping || !this.spriteAtlasImage) return null;
       return new deck.MVTLayer({
@@ -19296,13 +20222,13 @@ var Scene3DController = /*#__PURE__*/function () {
         maxZoom: (_layerConfig$maxZoom3 = layerConfig.maxZoom) !== null && _layerConfig$maxZoom3 !== void 0 ? _layerConfig$maxZoom3 : 24,
         renderSubLayers: function renderSubLayers(props) {
           var _layerConfig$defaultH4, _layerConfig$sizeUnit2, _layerConfig$sizeScal2, _layerConfig$billboar2;
-          var logoData = buildStoreLogoData(props.data || [], floorKey, _this6.spriteIconMapping, (_layerConfig$defaultH4 = layerConfig.defaultHeight) !== null && _layerConfig$defaultH4 !== void 0 ? _layerConfig$defaultH4 : 5);
+          var logoData = buildStoreLogoData(props.data || [], floorKey, _this7.spriteIconMapping, (_layerConfig$defaultH4 = layerConfig.defaultHeight) !== null && _layerConfig$defaultH4 !== void 0 ? _layerConfig$defaultH4 : 5);
           if (!logoData.length) return null;
           return new deck.IconLayer(scene3DController_objectSpread(scene3DController_objectSpread({}, props), {}, {
             id: "".concat(props.id, "-store-logos"),
             data: logoData,
-            iconAtlas: _this6.spriteAtlasImage,
-            iconMapping: _this6.spriteIconMapping,
+            iconAtlas: _this7.spriteAtlasImage,
+            iconMapping: _this7.spriteIconMapping,
             getIcon: function getIcon(d) {
               return d.icon;
             },
@@ -19314,7 +20240,7 @@ var Scene3DController = /*#__PURE__*/function () {
             },
             getSize: function getSize(d) {
               var _layerConfig$logoScal;
-              return computeStoreLogoSize(_this6.spriteIconMapping, d.icon, (_layerConfig$logoScal = layerConfig.logoScale) !== null && _layerConfig$logoScal !== void 0 ? _layerConfig$logoScal : {});
+              return computeStoreLogoSize(_this7.spriteIconMapping, d.icon, (_layerConfig$logoScal = layerConfig.logoScale) !== null && _layerConfig$logoScal !== void 0 ? _layerConfig$logoScal : {});
             },
             sizeUnits: (_layerConfig$sizeUnit2 = layerConfig.sizeUnits) !== null && _layerConfig$sizeUnit2 !== void 0 ? _layerConfig$sizeUnit2 : "meters",
             sizeScale: (_layerConfig$sizeScal2 = layerConfig.sizeScale) !== null && _layerConfig$sizeScal2 !== void 0 ? _layerConfig$sizeScal2 : 1,
@@ -19359,23 +20285,30 @@ var Scene3DController = /*#__PURE__*/function () {
     key: "hideLayers",
     value: function hideLayers(layersIds) {
       if (!layersIds) return;
-      var _iterator6 = scene3DController_createForOfIteratorHelper(layersIds),
-        _step6;
+      var _iterator7 = scene3DController_createForOfIteratorHelper(layersIds),
+        _step7;
       try {
-        for (_iterator6.s(); !(_step6 = _iterator6.n()).done;) {
-          var layerId = _step6.value;
+        for (_iterator7.s(); !(_step7 = _iterator7.n()).done;) {
+          var layerId = _step7.value;
           var layer = this.map.getLayer(layerId);
           if (!layer) continue;
           this.map.setLayoutProperty(layer.id, "visibility", "none");
         }
       } catch (err) {
-        _iterator6.e(err);
+        _iterator7.e(err);
       } finally {
-        _iterator6.f();
+        _iterator7.f();
       }
     }
   }]);
 }();
+/**
+ * Bounded concurrency for loading declarative GLB assets in {@link loadScene3DGlbTemplates}.
+ * High enough that one slow/broken asset (see {@link loadGlbRoot}'s timeout) does not stall the
+ * rest of the batch, low enough to avoid saturating the browser with concurrent Draco/KTX2
+ * decodes when a scene declares many assets.
+ */
+scene3DController_defineProperty(Scene3DController, "GLB_LOAD_CONCURRENCY", 4);
 ;// ./src/map/fitCamera.ts
 function fitCamera_createForOfIteratorHelper(r, e) { var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (!t) { if (Array.isArray(r) || (t = fitCamera_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 fitCamera_unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return fitCamera_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) ? fitCamera_arrayLikeToArray(r, a) : void 0; } }
@@ -19835,6 +20768,7 @@ function convertPaddingToPixels(padding, containerWidth, containerHeight) {
 
 
 
+
 /**
  * @group Map
  */
@@ -19908,6 +20842,12 @@ var InternalMapVXMap = /*#__PURE__*/function (_Loggeable) {
       merged.maxTiles = Math.min(merged.maxTiles, MAPLIBRE_MAX_TILE_CACHE_HARD_CAP);
       return merged;
     }();
+    _this.markerLayoutConfig = map_objectSpread(map_objectSpread({}, DEFAULT_MARKER_LAYOUT_CONFIG), mapConfig.markerLayout);
+    _this.markerLayoutController = new MarkerLayoutController(_this, _this.markerLayoutConfig);
+    // `container` is the very element handed to MapLibre below, and every
+    // marker is mounted inside it, so publishing the gap/width variables here
+    // covers markers added before the map's "load" event fires.
+    _this.markerLayoutController.applyLayoutVariables(container);
     if (mapConfig.parentPlaceId != null) {
       _this.initialPlaceDetailSetUp(mapConfig.parentPlaceId, mapConfig.authToken);
     }
@@ -20054,7 +20994,7 @@ var InternalMapVXMap = /*#__PURE__*/function (_Loggeable) {
       // Create the 3D controller only when the map opts into 3D. All heavy WebGL / deck.gl work is
       // owned by it; in 2D mode `this.scene3D` stays undefined and every hook below is a no-op.
       if (this.is3DSceneActive() && this.scene3DConfig) {
-        this.scene3D = new Scene3DController(this.map, this.scene3DConfig, this.initialCenter);
+        this.scene3D = new Scene3DController(this.map, this.scene3DConfig, this.initialCenter, mapConfig.onScene3DModelsProgress);
       }
       // When rotation is disabled we still want pinch-to-zoom to work, so the
       // two-finger rotation is turned off here instead of via the constructor.
@@ -20075,6 +21015,7 @@ var InternalMapVXMap = /*#__PURE__*/function (_Loggeable) {
         (_mapConfig$onMapReady = mapConfig.onMapReady) === null || _mapConfig$onMapReady === void 0 || _mapConfig$onMapReady.call(mapConfig);
         _this6.onHover();
         _this6.subscribeToFailedTiles();
+        _this6.markerLayoutController.attach();
       });
       // Self-healing for circles: a full style reload wipes custom sources and
       // layers, and not every restyle path goes through whenStyleUpdates.
@@ -20182,6 +21123,7 @@ var InternalMapVXMap = /*#__PURE__*/function (_Loggeable) {
     key: "destroyMap",
     value: function destroyMap() {
       this.circles = [];
+      this.markerLayoutController.destroy();
       this.map.remove();
       this.unsubscribeFromFailedTiles();
     }
@@ -20373,12 +21315,31 @@ var InternalMapVXMap = /*#__PURE__*/function (_Loggeable) {
       this.filterByFloorKey(this.currentFloor);
       (_this$scene3D4 = this.scene3D) === null || _this$scene3D4 === void 0 || _this$scene3D4.refreshOverlay(this.currentFloor);
     }
+
+    /**
+     * Internal accessor for every marker currently on the map, used by
+     * {@link MarkerLayoutController} to compute collision avoidance. Not part
+     * of the public `MapVXMap` interface.
+     *
+     * The user-location marker and the route controller's markers live outside
+     * `this.markers`, but they still occupy screen space — leaving them out
+     * would let labels be placed straight on top of them. They carry no label
+     * of their own, so they only ever act as obstacles.
+     * @internal
+     */
+  }, {
+    key: "getMarkers",
+    value: function getMarkers() {
+      var unmanaged = this.routeController.getRouteMarkers();
+      if (this.userLocationMarker) unmanaged.push(this.userLocationMarker);
+      return unmanaged.length > 0 ? [].concat(map_toConsumableArray(this.markers), map_toConsumableArray(unmanaged)) : this.markers;
+    }
   }, {
     key: "addMarker",
     value: function addMarker(marker) {
       var _this1 = this;
       try {
-        var _this$innerFloors$fin4, _this$innerFloors$fin5;
+        var _marker$maxLabelWidth, _this$innerFloors$fin4, _this$innerFloors$fin5;
         // Check if a marker with the same ID already exists and remove it
         if (marker.id) {
           var existingMarkerIndex = this.markers.findIndex(function (m) {
@@ -20394,12 +21355,15 @@ var InternalMapVXMap = /*#__PURE__*/function (_Loggeable) {
             });
           }
         }
-        var markerCreated = new MarkerAttribute(marker);
+        var markerCreated = new MarkerAttribute(map_objectSpread(map_objectSpread({}, marker), {}, {
+          maxLabelWidthPx: (_marker$maxLabelWidth = marker.maxLabelWidthPx) !== null && _marker$maxLabelWidth !== void 0 ? _marker$maxLabelWidth : this.markerLayoutConfig.maxLabelWidthPx
+        }));
         var isOutdoor = !this.parentPlace || ((_this$innerFloors$fin4 = (_this$innerFloors$fin5 = this.innerFloors.find(function (floor) {
           return floor.key === _this1.currentFloor;
         })) === null || _this$innerFloors$fin5 === void 0 ? void 0 : _this$innerFloors$fin5.reachableFromGPS) !== null && _this$innerFloors$fin4 !== void 0 ? _this$innerFloors$fin4 : false);
         markerCreated.changeFloor(this.currentFloor, this.map, isOutdoor);
         this.markers.push(markerCreated);
+        this.markerLayoutController.scheduleRelayout();
         this.logEvent("addMarker");
         return markerCreated.id;
       } catch (error) {
@@ -20418,6 +21382,8 @@ var InternalMapVXMap = /*#__PURE__*/function (_Loggeable) {
         });
         if (_marker !== undefined) {
           _marker.updateIcon(markerConfig);
+          this.markerLayoutController.invalidateMarker(_marker);
+          this.markerLayoutController.scheduleRelayout();
         }
         this.logEvent("updateMarker");
         return (_marker$id = _marker === null || _marker === void 0 ? void 0 : _marker.id) !== null && _marker$id !== void 0 ? _marker$id : "";
@@ -20436,6 +21402,7 @@ var InternalMapVXMap = /*#__PURE__*/function (_Loggeable) {
         });
         if (_marker2 !== undefined) {
           _marker2.setLngLat(newPosition);
+          this.markerLayoutController.scheduleRelayout();
         }
         this.logEvent("updateMarkerPosition");
       } catch (error) {
@@ -20453,6 +21420,7 @@ var InternalMapVXMap = /*#__PURE__*/function (_Loggeable) {
         });
         if (_marker3 !== null && this.map) {
           _marker3 === null || _marker3 === void 0 || _marker3.show(this.map);
+          this.markerLayoutController.scheduleRelayout();
         }
         this.logEvent("showMarker");
       } catch (error) {
@@ -20468,6 +21436,7 @@ var InternalMapVXMap = /*#__PURE__*/function (_Loggeable) {
         });
         if (_marker4 !== null) {
           _marker4 === null || _marker4 === void 0 || _marker4.hide();
+          this.markerLayoutController.scheduleRelayout();
         }
         this.logEvent("hideMarker");
       } catch (error) {
@@ -20486,6 +21455,7 @@ var InternalMapVXMap = /*#__PURE__*/function (_Loggeable) {
           this.markers = this.markers.filter(function (e) {
             return e.id !== markerId;
           });
+          this.markerLayoutController.scheduleRelayout();
         }
         this.logEvent("removeMarker");
       } catch (error) {
@@ -20502,6 +21472,7 @@ var InternalMapVXMap = /*#__PURE__*/function (_Loggeable) {
           marker.remove();
         });
         this.markers = [];
+        this.markerLayoutController.scheduleRelayout();
         this.logEvent("removeAllMarkers");
       } catch (error) {
         throw new Error("Failed to remove all markers", {
@@ -20935,6 +21906,7 @@ var InternalMapVXMap = /*#__PURE__*/function (_Loggeable) {
       this.markers.forEach(function (e) {
         e.changeFloor(floorId, _this10.map, isOutdoor);
       });
+      this.markerLayoutController.scheduleRelayout();
     }
   }, {
     key: "updateFiltersTo",
@@ -22008,6 +22980,7 @@ var InternalMapVXMap = /*#__PURE__*/function (_Loggeable) {
   }, {
     key: "addUserLocationTracking",
     value: function addUserLocationTracking(enableHighAccuracy, geoLocation, icon) {
+      var _this14 = this;
       var initialCoordinate = {
         lat: 0.0,
         lng: 0.0
@@ -22028,8 +23001,10 @@ var InternalMapVXMap = /*#__PURE__*/function (_Loggeable) {
       var marker = new MarkerAttribute(markerConfig);
       marker.addToMap(this.map);
       this.userLocationMarker = marker;
+      this.markerLayoutController.scheduleRelayout();
       var updateMarker = function updateMarker(position) {
         marker.setLngLat([position.coords.longitude, position.coords.latitude]);
+        _this14.markerLayoutController.scheduleRelayout();
       };
       this.geoLocation = geoLocation !== null && geoLocation !== void 0 ? geoLocation : navigator.geolocation;
       this.watchPositionID = this.geoLocation.watchPosition(updateMarker, function (error) {
@@ -22044,6 +23019,7 @@ var InternalMapVXMap = /*#__PURE__*/function (_Loggeable) {
       if (this.userLocationMarker !== undefined) {
         this.userLocationMarker.remove();
         this.userLocationMarker = undefined;
+        this.markerLayoutController.scheduleRelayout();
 
         // Check if watchPosition ID is valid and stop tracking
         if (this.watchPositionID) {
@@ -22112,7 +23088,7 @@ var InternalMapVXMap = /*#__PURE__*/function (_Loggeable) {
     key: "onWebGLContextLost",
     value: function onWebGLContextLost(e) {
       var _this$map,
-        _this14 = this;
+        _this15 = this;
       e.originalEvent.preventDefault();
       console.warn("Contexto WebGL perdido 😢");
 
@@ -22123,8 +23099,8 @@ var InternalMapVXMap = /*#__PURE__*/function (_Loggeable) {
         var _ext$restoreContext;
         canvas.addEventListener("webglcontextrestored", function () {
           console.debug("Contexto WebGL restaurado, forzando re-render");
-          _this14.map.triggerRepaint(); // forzar repaint
-          _this14.failedTiles.clear();
+          _this15.map.triggerRepaint(); // forzar repaint
+          _this15.failedTiles.clear();
         }, {
           once: true
         });
@@ -22164,7 +23140,7 @@ var InternalMapVXMap = /*#__PURE__*/function (_Loggeable) {
   }, {
     key: "subscribeToFailedTiles",
     value: function subscribeToFailedTiles() {
-      var _this15 = this;
+      var _this16 = this;
       if (this.retryTimer) return;
 
       // Store bound functions for proper cleanup
@@ -22173,20 +23149,20 @@ var InternalMapVXMap = /*#__PURE__*/function (_Loggeable) {
       this.boundOnWebGLContextLost = this.onWebGLContextLost.bind(this);
       this.boundOnWebGLContextRestored = this.onWebGLContextRestored.bind(this);
       this.retryTimer = setInterval(function () {
-        if (!_this15.map.getSource("indoorequal")) {
-          _this15.failedTiles.clear();
+        if (!_this16.map.getSource("indoorequal")) {
+          _this16.failedTiles.clear();
           return;
         }
-        var source = _this15.map.getSource("indoorequal");
+        var source = _this16.map.getSource("indoorequal");
         if (!source || source.type !== "vector") {
-          _this15.failedTiles.clear();
+          _this16.failedTiles.clear();
           return;
         }
 
         // Process tiles and remove invalid ones
         var tilesToRetry = [];
         var tilesToRemove = [];
-        _this15.failedTiles.forEach(function (tile) {
+        _this16.failedTiles.forEach(function (tile) {
           // Check if tile is still valid before attempting reload
           if (!tile || tile.state === "unloaded" || tile.state === "loading") {
             tilesToRemove.push(tile);
@@ -22204,14 +23180,14 @@ var InternalMapVXMap = /*#__PURE__*/function (_Loggeable) {
 
         // Remove invalid tiles from the set
         tilesToRemove.forEach(function (tile) {
-          return _this15.failedTiles["delete"](tile);
+          return _this16.failedTiles["delete"](tile);
         });
 
         // Attempt to reload valid failed tiles
         var now = Date.now();
         tilesToRetry.forEach(function (tile) {
-          var _this15$tileRetryStat;
-          var retry = (_this15$tileRetryStat = _this15.tileRetryState.get(tile)) !== null && _this15$tileRetryStat !== void 0 ? _this15$tileRetryStat : {
+          var _this16$tileRetryStat;
+          var retry = (_this16$tileRetryStat = _this16.tileRetryState.get(tile)) !== null && _this16$tileRetryStat !== void 0 ? _this16$tileRetryStat : {
             attempts: 0,
             nextAttemptAt: 0,
             pending: false
@@ -22222,16 +23198,16 @@ var InternalMapVXMap = /*#__PURE__*/function (_Loggeable) {
           var onFailure = function onFailure(error) {
             var attempts = retry.attempts + 1;
             if (attempts >= MAX_TILE_RETRIES) {
-              _this15.debugLog("Tile reload failed ".concat(attempts, " times, dropping it from the retry queue"), error);
-              _this15.failedTiles["delete"](tile);
-              _this15.tileRetryState["delete"](tile);
+              _this16.debugLog("Tile reload failed ".concat(attempts, " times, dropping it from the retry queue"), error);
+              _this16.failedTiles["delete"](tile);
+              _this16.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);
-            _this15.debugLog("Tile reload failed (attempt ".concat(attempts, "/").concat(MAX_TILE_RETRIES, "), retrying in ").concat(backoffMs, "ms"), error);
-            _this15.tileRetryState.set(tile, {
+            _this16.debugLog("Tile reload failed (attempt ".concat(attempts, "/").concat(MAX_TILE_RETRIES, "), retrying in ").concat(backoffMs, "ms"), error);
+            _this16.tileRetryState.set(tile, {
               attempts: attempts,
               nextAttemptAt: Date.now() + backoffMs,
               pending: false
@@ -22240,7 +23216,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")) {
-              _this15.tileRetryState.set(tile, map_objectSpread(map_objectSpread({}, retry), {}, {
+              _this16.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
@@ -22250,7 +23226,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.
-                _this15.tileRetryState["delete"](tile);
+                _this16.tileRetryState["delete"](tile);
               })["catch"](onFailure);
             }
           } catch (error) {