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

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.1";
 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,42 @@ 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
+};
+
 /**
  * Basic configuration for the map.
  * Provides essential settings for initializing and customizing map behavior.
@@ -14642,6 +15331,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 +16033,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 +16046,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(); }
@@ -19835,6 +20526,7 @@ function convertPaddingToPixels(padding, containerWidth, containerHeight) {
 
 
 
+
 /**
  * @group Map
  */
@@ -19908,6 +20600,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);
     }
@@ -20075,6 +20773,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 +20881,7 @@ var InternalMapVXMap = /*#__PURE__*/function (_Loggeable) {
     key: "destroyMap",
     value: function destroyMap() {
       this.circles = [];
+      this.markerLayoutController.destroy();
       this.map.remove();
       this.unsubscribeFromFailedTiles();
     }
@@ -20373,12 +21073,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 +21113,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 +21140,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 +21160,7 @@ var InternalMapVXMap = /*#__PURE__*/function (_Loggeable) {
         });
         if (_marker2 !== undefined) {
           _marker2.setLngLat(newPosition);
+          this.markerLayoutController.scheduleRelayout();
         }
         this.logEvent("updateMarkerPosition");
       } catch (error) {
@@ -20453,6 +21178,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 +21194,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 +21213,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 +21230,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 +21664,7 @@ var InternalMapVXMap = /*#__PURE__*/function (_Loggeable) {
       this.markers.forEach(function (e) {
         e.changeFloor(floorId, _this10.map, isOutdoor);
       });
+      this.markerLayoutController.scheduleRelayout();
     }
   }, {
     key: "updateFiltersTo",
@@ -22008,6 +22738,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 +22759,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 +22777,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 +22846,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 +22857,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 +22898,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 +22907,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 +22938,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 +22956,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 +22974,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 +22984,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) {