@mapvx/web-js 4.0.2 → 4.0.3-dev.2

package/dist/es/map/map.js

@@ -1,73 +1,27 @@
 import { LngLatBounds, Map, NavigationControl, Popup, addProtocol, } from "maplibre-gl";
 import { Semaphore } from "../utils/semaphore";
 import { installMapLibreWorker } from "./installMapLibreWorker";
-/** Shared GeoJSON source holding every circle drawn through the circle API. */
 const CIRCLE_SOURCE_ID = "mapvx-circles";
-/** Fill layer rendering the translucent interior of the circles. */
 const CIRCLE_FILL_LAYER_ID = "mapvx-circles-fill";
-/** Line layer rendering the circle outlines. */
 const CIRCLE_LINE_LAYER_ID = "mapvx-circles-line";
-/**
- * Layer-id suffix per circle render order. The default placement keeps the
- * unsuffixed ids so existing consumers referencing them keep working.
- */
 const CIRCLE_LAYER_SUFFIXES = {
     aboveBasemap: "",
     belowLabels: "-below-labels",
     top: "-top",
 };
-/**
- * How many times a failed vector tile is reloaded before it is dropped from the retry
- * queue. Bounded so a permanently unavailable tile stops being requested, while a tile
- * that failed on a transient network error still gets several chances.
- */
 const MAX_TILE_RETRIES = 5;
-/**
- * Base delay for the retry backoff. Attempt N waits `BASE * 2^(N-1)` before it is
- * eligible again — 1s, 2s, 4s, 8s — so a tile that keeps failing is retried ever less
- * often instead of once per timer tick.
- */
 const TILE_RETRY_BASE_DELAY_MS = 1000;
-/**
- * Safety deadline for {@link InternalMapVXMap.setStyle}'s `onStyleReady` callback. The
- * callback normally fires on the map's `idle` event, but `idle` may never arrive (the
- * style request failed, the swap never settles). Callers hide the map behind a loading
- * overlay until the callback arrives, so it must be released no matter what.
- */
 const STYLE_READY_TIMEOUT_MS = 4000;
-/**
- * Frames a floor change waits before it will believe the indoor tiles are
- * already rebuilt (see `updateMarkersWhenFloorSettles`). Genuinely a frame
- * count: the reload is dispatched on the map's next render, so this is how
- * many renders it gets to be observed in.
- */
 const FLOOR_SETTLE_MIN_FRAMES = 3;
-/**
- * Longest a floor change waits for the new floor's tiles before switching the
- * HTML markers anyway, so a stalled source never hides markers for good.
- *
- * A deadline rather than a frame count. The panels this matters on run at
- * 20-30 fps, where a 60-frame cap is two to three seconds — and the wait also
- * gates `addMarker`, so overshooting it is not merely a late marker switch.
- */
 const FLOOR_SETTLE_MAX_MS = 1000;
-/** Fill/line layer ids for one circle render-order bucket. */
 function circleLayerIdsFor(order) {
     const suffix = CIRCLE_LAYER_SUFFIXES[order];
     return { fill: CIRCLE_FILL_LAYER_ID + suffix, line: CIRCLE_LINE_LAYER_ID + suffix };
 }
-/** True for the layer ids owned by the circle API, regardless of bucket. */
 function isCircleLayerId(id) {
     return id.startsWith(CIRCLE_FILL_LAYER_ID) || id.startsWith(CIRCLE_LINE_LAYER_ID);
 }
-// Flag to track if cached-tile protocol has been registered
 let cachedTileProtocolRegistered = false;
-/**
- * Deep clone helper that works in all environments.
- * Uses structuredClone if available, otherwise falls back to JSON serialization.
- * @param obj The object to clone
- * @returns A deep clone of the object
- */
 function deepClone(obj) {
     if (obj === undefined || obj === null) {
         return obj;
@@ -77,28 +31,12 @@ function deepClone(obj) {
     }
     return JSON.parse(JSON.stringify(obj));
 }
-/**
- * Register a custom protocol for cached tiles that routes requests through the main thread.
- * This allows the service worker to intercept and cache tile requests.
- *
- * Wraps fetches in a {@link Semaphore} so tile CDN / WAFs are not hit with
- * unbounded parallel requests (same host as the service worker cache). The
- * semaphore is created once with the limit from the first map's config; later
- * calls are no-ops because the protocol can only be registered once globally
- * on MapLibre.
- *
- * @param maxConcurrentFetches - Maximum number of in-flight tile fetches.
- */
 function registerCachedTileProtocol(maxConcurrentFetches) {
     if (cachedTileProtocolRegistered)
         return;
     const semaphore = new Semaphore(maxConcurrentFetches);
     addProtocol("cached-tile", (params, abortController) => {
         const url = params.url.replace("cached-tile://", "https://");
-        // Pass the abort signal to acquire() so a request cancelled while still
-        // queued (e.g. during rapid zoom) drops out of the FIFO queue instead of
-        // waiting for a slot just to bail. release() runs only inside this chain,
-        // i.e. only after a slot was actually granted.
         return semaphore.acquire(abortController.signal).then(() => fetch(url, { signal: abortController.signal })
             .then((response) => {
             if (!response.ok) {
@@ -113,12 +51,6 @@ function registerCachedTileProtocol(maxConcurrentFetches) {
     });
     cachedTileProtocolRegistered = true;
 }
-/**
- * Converts a PaddingValue to pixels based on the container and viewport dimensions.
- * @param value The padding value (number or string with unit)
- * @param dimension The reference dimension in pixels (container width/height)
- * @returns The padding value in pixels
- */
 function parsePaddingValue(value, dimension) {
     if (value === undefined) {
         return 0;
@@ -145,13 +77,6 @@ function parsePaddingValue(value, dimension) {
             return numericValue;
     }
 }
-/**
- * Converts PaddingOptions with mixed units to MapLibre's pixel-based padding format.
- * @param padding The padding options with optional fields and mixed units
- * @param containerWidth The map container width in pixels
- * @param containerHeight The map container height in pixels
- * @returns Padding object with all values in pixels
- */
 function convertPaddingToPixels(padding, containerWidth, containerHeight) {
     if (!padding) {
         return { top: 0, bottom: 0, left: 0, right: 0 };
@@ -180,129 +105,38 @@ import { Scene3DController } from "./scene3DController";
 import { computeOrientedCamera, refineCameraForPitch } from "./fitCamera";
 import { LiveMapFitTransform } from "./liveMapFitTransform";
 import { buildInteractionOptions, shouldDisableTouchRotation } from "./mapInteractionOptions";
-/**
- * Class to interact with the map.
- * @category Map
- * @hidden
- */
-/**
- * Whether a style publishes any `fill-extrusion` layer, i.e. whether it has extruded rooms for the
- * 3D scene to stand on.
- *
- * This is the only reliable signal for "does 3D work here". `mapStyleJson` is served per API key,
- * so the same venue comes back with extrusions on a 3D key and flat on a 2D one — the place id
- * cannot answer the question.
- *
- * @param style The style about to be applied, or the one currently applied.
- * @returns `true` when at least one layer is `fill-extrusion`.
- */
 function styleHasExtrusions(style) {
     return style.layers.some((layer) => layer.type === "fill-extrusion");
 }
 export class InternalMapVXMap extends Loggeable {
-    /** Whether a floor change is still rebuilding, so markers wait for it. */
     get floorSettlePending() {
         return this.floorSettleDeadline != null && this.now() < this.floorSettleDeadline;
     }
-    /** Wall clock for the settle deadline; `Date.now` where `performance` is absent. */
     now() {
         return typeof performance !== "undefined" ? performance.now() : Date.now();
     }
-    /**
-     * Creates a new map instance with the parameters specified in mapConfig and assigns it to the provided HTML container.
-     * @param mapConfig Configuration parameters for the map.
-     * @param container Container where the assignment of the created map is required.
-     * @param parentPlace Parent place required for map floor mapping, along with the display of subplaces.
-     * @param token The token provided for the creation and fetching of map information.
-     * @returns A new instance of MapVXMap.
-     */
     constructor(mapConfig, container, token) {
         var _a, _b, _c;
         super();
-        /**
-         * Monotonic counter for {@link addLiveRoute} calls. Refreshes overlap (each one
-         * awaits a fetch), so only the call holding the latest ticket may touch the
-         * map — an older response resolving last is discarded instead of clobbering
-         * the newer route.
-         */
         this.liveRouteTicket = 0;
         this.potentialParentPlaces = [];
         this.innerFloors = [];
         this.subPlaces = [];
         this.currentFloor = "";
         this.baseFilters = {};
-        /**
-         * Layer ids whose declared (base) filter has already been resolved — either captured
-         * into {@link baseFilters} or confirmed absent.
-         *
-         * `baseFilters[id] === undefined` cannot carry that information on its own: it means
-         * both "not looked at yet" and "looked at, the layer declares no filter". Without the
-         * distinction, a later pass re-reads the layer's LIVE filter — which by then is the
-         * one this class wrote — and stores our own floor/public-place filter as if it were
-         * the style's, so the layer keeps filtering by a stale floor forever.
-         *
-         * An id lands here the moment its declared filter is read from the style spec, or the
-         * moment this class writes a filter to that layer, whichever happens first. Layers
-         * added asynchronously after a `setStyle` swap are in neither situation, so their
-         * genuinely pristine live filter is still captured on first touch.
-         */
         this.capturedBaseFilters = new Set();
-        /**
-         * Monotonic id of the most recently STARTED style swap. Every {@link setStyle} call
-         * captures its own value and checks it again in each async continuation, so a
-         * superseded swap can neither touch the shared bookkeeping (`styleReadyTimer`,
-         * `pendingStyleSwapListener`) nor apply its obsolete style to the live map.
-         *
-         * A per-call `readied` flag is not enough: the timer and the listener slot are
-         * single-valued instance state, so two overlapping swaps otherwise clobber each
-         * other's — one caller's overlay is released by the other's failure, or an
-         * abandoned listener re-seeds filters from layer ids the current style lacks.
-         */
         this.styleSwapGeneration = 0;
         this.markers = [];
         this.circles = [];
         this.enableHover = false;
         this.hoveredId = "unselected";
         this.failedTiles = new Set();
-        /**
-         * Retry bookkeeping per failed tile. A WeakMap so it can never outlive the tiles
-         * themselves — entries disappear with the tile objects, which is why none of the
-         * `failedTiles.clear()` paths have to reset it.
-         */
         this.tileRetryState = new WeakMap();
         this.geoLocation = navigator.geolocation;
-        /** Floor-change settle bookkeeping (see `updateMarkersWhenFloorSettles`). */
         this.floorSettleToken = 0;
-        /**
-         * When the floor-change settle stops holding markers back, or `null` when no
-         * change is in flight.
-         *
-         * A deadline rather than a flag, because `addMarker` reads it: the poll that
-         * would clear a flag runs on `requestAnimationFrame`, which does not fire in
-         * a backgrounded tab and does not run at all for a map torn down through
-         * MapLibre's own `remove()` rather than `destroyMap`. A flag left set there
-         * makes every later `addMarker` skip the call that attaches the marker, for
-         * good; a deadline expires on its own.
-         */
         this.floorSettleDeadline = null;
-        /** Owns the deck.gl overlay + GLB scene; created on style load only when 3D is active. */
         this.scene3D = undefined;
-        /**
-         * Whether the style currently applied publishes `fill-extrusion` layers, i.e. whether there are
-         * roofs for the 3D scene to sit on. Recomputed on every style the map is given, because the style
-         * is served per API key, not per venue: the same place can come back 3D on one key and flat on
-         * another. Assumed true until a style says otherwise, so 2D maps (which never read it) are
-         * unaffected.
-         */
         this.styleSupports3D = true;
-        // First statement on purpose, and further forward than it looks necessary. MapLibre reads
-        // WORKER_URL once, when its first Dispatcher is built, and never again while any map is alive
-        // — so the worker has to be installed before *anything* touches MapLibre, not merely before
-        // `new Map(...)`. Today the constructor reaches MapLibre only through the map itself, but
-        // until recently it also called `setRTLTextPlugin()` here, which builds a Dispatcher of its
-        // own 200 lines ahead of the map; `prewarm()` and `importScriptInWorkers()` do the same.
-        // Keeping this first means no later edit can slip such a call in front of it.
-        // See installMapLibreWorker and DEVELOPER_DOCS/MAPLIBRE_V6_MIGRATION.md.
         installMapLibreWorker();
         this.repository = new Repository(token, (_a = mapConfig.lang) !== null && _a !== void 0 ? _a : "en", mapConfig.apiUrl, undefined, mapConfig.mapvxRequestContext, {
             routeApiUrl: mapConfig.routeApiUrl,
@@ -331,9 +165,6 @@ export class InternalMapVXMap extends Loggeable {
         })();
         this.markerLayoutConfig = Object.assign(Object.assign({}, 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);
@@ -345,12 +176,6 @@ export class InternalMapVXMap extends Loggeable {
         this.enableHover = mapConfig.enableHover || false;
         this.initialMapStyleSetUp(mapConfig, container);
     }
-    /**
-     * Transform style sources to use cached-tile:// protocol for tile URLs.
-     * This enables the service worker to intercept and cache tile requests.
-     * @param style The original style specification
-     * @returns A new style with transformed tile URLs
-     */
     transformStyleForCaching(style) {
         if (!style) {
             return style;
@@ -359,9 +184,6 @@ export class InternalMapVXMap extends Loggeable {
         if (transformedStyle === null || transformedStyle === void 0 ? void 0 : transformedStyle.sources) {
             for (const sourceKey of Object.keys(transformedStyle.sources)) {
                 const source = transformedStyle.sources[sourceKey];
-                // Transform vector and raster tile sources
-                // Only transform source.tiles (actual tile URLs), NOT source.url (TileJSON metadata URL)
-                // source.url points to a TileJSON file that returns JSON, not binary tile data
                 if (source.tiles && Array.isArray(source.tiles)) {
                     source.tiles = source.tiles.map((tileUrl) => {
                         if (tileUrl.startsWith("https://")) {
@@ -418,11 +240,6 @@ export class InternalMapVXMap extends Loggeable {
                 .catch(console.error);
             return;
         }
-        // Through the same helper as `setStyle` and `changeParentPlaceTo`. This PR
-        // forwards `styleRef`/`styleTheme` to the initial load too, and a ref scoped
-        // to the user's client rather than to the api key resolves only over bearer
-        // — fetched over the api-key path it 4xx'd, and since this is the call that
-        // creates the map, the map was never created at all.
         this.fetchVenueStyle(mapConfig.parentPlaceId, mapConfig.styleRef, mapConfig.styleTheme)
             .then((style) => {
             return this.onMapStyleLoaded(mapConfig, container, style);
@@ -433,15 +250,11 @@ export class InternalMapVXMap extends Loggeable {
     }
     onMapStyleLoaded(mapConfig, container, style) {
         var _a, _b, _c, _d, _e, _f, _g, _h;
-        // Determine if service worker caching should be enabled
         const useServiceWorkerCaching = this.tileCacheConfig.enabled && this.tileCacheConfig.persistToServiceWorker;
         if (useServiceWorkerCaching) {
             registerCachedTileProtocol(this.tileCacheConfig.maxConcurrentTileFetches);
         }
-        // Transform tile URLs only if service worker caching is enabled
         const finalStyle = useServiceWorkerCaching ? this.transformStyleForCaching(style) : style;
-        // Read straight off the style object rather than `map.getStyle()`: the map does not exist yet
-        // here, and the decision has to be made before the 3D controller is constructed below.
         this.styleSupports3D = styleHasExtrusions(finalStyle);
         if (this.mode === "3D" && !this.styleSupports3D) {
             this.logWarning(new Error("3D was requested but this style publishes no `fill-extrusion` layers, so there are no " +
@@ -450,18 +263,13 @@ export class InternalMapVXMap extends Loggeable {
                 "floating above the ground. The style is served per API key, not per venue, so check " +
                 "that this key publishes 3D."), { functionName: "onMapStyleLoaded", parentPlaceId: (_a = this.parentPlaceId) !== null && _a !== void 0 ? _a : "" });
         }
-        const mapOptions = Object.assign({ container, style: finalStyle, center: mapConfig.center, zoom: mapConfig.zoom, pitch: (_b = mapConfig.pitch) !== null && _b !== void 0 ? _b : 0, attributionControl: false, maplibreLogo: false, bearingSnap: (_c = mapConfig.bearingSnap) !== null && _c !== void 0 ? _c : 0, cancelPendingTileRequestsWhileZooming: true, 
-            // Use configured maxTiles for MapLibre's memory cache
-            maxTileCacheSize: this.tileCacheConfig.maxTiles }, buildInteractionOptions(mapConfig));
+        const mapOptions = Object.assign({ container, style: finalStyle, center: mapConfig.center, zoom: mapConfig.zoom, pitch: (_b = mapConfig.pitch) !== null && _b !== void 0 ? _b : 0, attributionControl: false, maplibreLogo: false, bearingSnap: (_c = mapConfig.bearingSnap) !== null && _c !== void 0 ? _c : 0, cancelPendingTileRequestsWhileZooming: true, maxTileCacheSize: this.tileCacheConfig.maxTiles }, buildInteractionOptions(mapConfig));
         if (mapConfig.maxZoom)
             mapOptions.maxZoom = mapConfig.maxZoom;
         if (mapConfig.minZoom)
             mapOptions.minZoom = mapConfig.minZoom;
-        // Reduced internal resolution on request (fill-rate relief for low-end GPUs);
-        // MapLibre keeps devicePixelRatio when the option is left out.
         if (mapConfig.pixelRatio !== undefined)
             mapOptions.pixelRatio = mapConfig.pixelRatio;
-        // `0` disables the post-gesture fade tail entirely; keep MapLibre's default otherwise.
         if (mapConfig.fadeDuration !== undefined)
             mapOptions.fadeDuration = mapConfig.fadeDuration;
         if (mapConfig.maxBounds && mapConfig.maxBounds.length > 1) {
@@ -469,13 +277,9 @@ export class InternalMapVXMap extends Loggeable {
             mapOptions.maxBounds = new LngLatBounds([boundingBox[0].lng, boundingBox[0].lat], [boundingBox[1].lng, boundingBox[1].lat]);
         }
         this.map = new Map(mapOptions);
-        // 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, 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.
         if (shouldDisableTouchRotation(mapConfig)) {
             (_e = (_d = this.map.touchZoomRotate) === null || _d === void 0 ? void 0 : _d.disableRotation) === null || _e === void 0 ? void 0 : _e.call(_d);
         }
@@ -485,7 +289,6 @@ export class InternalMapVXMap extends Loggeable {
         }), (_h = mapConfig.navigationPosition) !== null && _h !== void 0 ? _h : "top-right");
         this.map.on("load", () => {
             var _a, _b;
-            // 3D libraries load asynchronously; the rest of the load flow does not wait on them.
             void ((_a = this.scene3D) === null || _a === void 0 ? void 0 : _a.onMapLoad());
             this.whenStyleUpdates(style);
             if (mapConfig.lang)
@@ -495,8 +298,6 @@ export class InternalMapVXMap extends Loggeable {
             this.subscribeToFailedTiles();
             this.markerLayoutController.attach();
         });
-        // Self-healing for circles: a full style reload wipes custom sources and
-        // layers, and not every restyle path goes through whenStyleUpdates.
         this.map.on("styledata", () => {
             if (this.circles.length > 0)
                 this.ensureCircleLayers();
@@ -522,15 +323,6 @@ export class InternalMapVXMap extends Loggeable {
         style.layers
             .filter((layer) => layer.id.startsWith("indoor-"))
             .forEach((layer) => {
-            // Seed from the STYLE SPEC — the only pristine source — and do it BEFORE the
-            // setFilter below overwrites the live filter. Reading it back afterwards would
-            // return our own `publicPlaceFilter` and store it as the layer's declared one,
-            // turning `public_place` from an OR into an AND and hiding every private
-            // feature on the selected floor. Every indoor layer is covered, not just
-            // fill/line/symbol: a `circle` layer is discriminated by its filter just the
-            // same, and dropping it makes the layer repaint every feature.
-            // `filter` is absent from the union member for `background` layers, hence the
-            // structural read rather than `layer.filter`.
             const declared = layer.filter;
             this.captureDeclaredBaseFilter(layer.id, declared);
             const baseFilter = this.baseFilters[layer.id];
@@ -543,18 +335,6 @@ export class InternalMapVXMap extends Loggeable {
             }
         });
     }
-    /**
-     * Records a layer's declared (base) filter the first time the layer is seen, from an
-     * explicit value (a style-spec `filter`) when one is available, otherwise by reading
-     * the live filter — which is only pristine for layers this class has never written to.
-     *
-     * Marking happens even when no filter exists, so the layer is never revisited: on a
-     * second visit its live filter is one we produced, and storing that as the "declared"
-     * filter is what freezes a layer to a stale floor.
-     *
-     * @param layerId Id of the layer whose base filter should be resolved.
-     * @param declared Declared filter straight from the style spec, when the caller has it.
-     */
     captureDeclaredBaseFilter(layerId, declared) {
         if (this.capturedBaseFilters.has(layerId))
             return;
@@ -566,7 +346,6 @@ export class InternalMapVXMap extends Loggeable {
     }
     setLayersForLanguage(lang) {
         var _a, _b;
-        // outdoor layers
         const layersName = [
             "aerodrome_label",
             "mountain_peak",
@@ -607,7 +386,6 @@ export class InternalMapVXMap extends Loggeable {
                 this.debugLog("Layer language update failed (layer may not exist)", error);
             }
         });
-        // indoor layers
         const indoorLayerIds = layers
             .filter((layer) => {
             var _a;
@@ -632,11 +410,6 @@ export class InternalMapVXMap extends Loggeable {
             }
         });
     }
-    /**
-     * Add values to identify the client.
-     * @param segmentation The pair values to use as segmentation.
-     * @returns The segmentation with the added values.
-     */
     prepareSegmentation(segmentation) {
         var _a;
         return Object.assign(Object.assign({}, segmentation), { token: this.token, parentPlaceId: (_a = this.parentPlaceId) !== null && _a !== void 0 ? _a : "None" });
@@ -645,32 +418,20 @@ export class InternalMapVXMap extends Loggeable {
         var _a;
         this.circles = [];
         this.markerLayoutController.destroy();
-        // Drop any in-flight `setStyle` bookkeeping while the map still exists: the
-        // listener has to be detached before `map.remove()`, and the safety timer must not
-        // outlive the map and call `onStyleReady` for a map that is already gone.
         this.clearPendingStyleSwapListener();
         if (this.styleReadyTimer) {
             clearTimeout(this.styleReadyTimer);
             this.styleReadyTimer = undefined;
         }
-        // Drop any floor-settle poll in flight: bumping the token makes the next
-        // `requestAnimationFrame` callback return instead of re-queueing itself and
-        // re-attaching markers to a map that has already been removed.
         this.floorSettleToken++;
         this.floorSettleDeadline = null;
-        // Dispose the 3D scene's GPU resources before the map (and its shared WebGL context) go away —
-        // MapLibre's own teardown never calls the custom GLB layer's `onRemove`.
         (_a = this.scene3D) === null || _a === void 0 ? void 0 : _a.dispose();
         this.map.remove();
         this.unsubscribeFromFailedTiles();
     }
     clearTileCache() {
         try {
-            // Clear the failed tiles tracking set
             this.failedTiles.clear();
-            // Force MapLibre to reload all visible tiles by triggering a repaint
-            // Note: MapLibre doesn't expose a direct cache clear method, so we
-            // trigger a style refresh which causes tiles to be re-requested
             if (this.map) {
                 this.map.triggerRepaint();
             }
@@ -680,18 +441,6 @@ export class InternalMapVXMap extends Loggeable {
             this.debugLog("Tile cache clear failed (cache may not exist)", error);
         }
     }
-    /**
-     * Whether 3D scene features (deck.gl overlay, declarative GLB custom layer, etc.) are active.
-     * Requires {@link MapConfig.mode} `"3D"`, {@link Scene3DConfig.enabled} not `false`, and a style
-     * that actually publishes `fill-extrusion` layers ({@link styleSupports3D}).
-     *
-     * That last condition is what keeps a caller from asking for 3D on a flat style: the overlay
-     * would float above the ground while `hideLayers` removed the 2D labels underneath, leaving a
-     * map with no labels at all — worse than the plain 2D map the caller would otherwise get.
-     *
-     * The heavy WebGL / deck.gl work lives in {@link Scene3DController}; this only decides whether one
-     * is created and wired up. When `scene3D` is omitted, 3D features remain available.
-     */
     is3DSceneActive() {
         var _a;
         return this.mode === "3D" && ((_a = this.scene3DConfig) === null || _a === void 0 ? void 0 : _a.enabled) !== false && this.styleSupports3D;
@@ -700,14 +449,6 @@ export class InternalMapVXMap extends Loggeable {
         var _a;
         return (_a = this.currentFloor) !== null && _a !== void 0 ? _a : "";
     }
-    /**
-     * Sets the route path used for GLB route-transparency collision, so 3D models a route passes
-     * through fade and reveal the floor plan underneath. Called by {@link RouteController} whenever
-     * the set of drawn routes changes. Points are tagged with the floor their segment is drawn on;
-     * only points on the displayed floor participate. Pass an empty array to clear.
-     *
-     * No-op unless the 3D scene is active.
-     */
     setRouteCollisionPath(points) {
         var _a;
         if (!this.is3DSceneActive()) {
@@ -715,11 +456,6 @@ export class InternalMapVXMap extends Loggeable {
         }
         (_a = this.scene3D) === null || _a === void 0 ? void 0 : _a.setRouteCollisionPath(points);
     }
-    /**
-     * Performs changes when parent place is updated
-     * @param place new parent place
-     * @param updateStyle defines if new parent place style must be set
-     */
     changeParentPlaceTo(place, updateStyle = false, onStyleReady) {
         var _a, _b, _c, _d, _e, _f, _g;
         this.parentPlace = place;
@@ -737,52 +473,21 @@ export class InternalMapVXMap extends Loggeable {
                 const useServiceWorkerCaching = this.tileCacheConfig.enabled && this.tileCacheConfig.persistToServiceWorker;
                 const finalStyle = useServiceWorkerCaching ? this.transformStyleForCaching(style) : style;
                 this.map.setStyle(finalStyle);
-                // The new place's style declares its own filters for the same `indoor-*` layer
-                // ids. Without this reset every id is still marked captured from the previous
-                // place, so `captureDeclaredBaseFilter` early-returns for all of them and the
-                // previous place's expressions keep filtering the new style forever. (The
-                // `switch (layer.type)` block that used to re-read them on every style load was
-                // removed when capture became once-per-id, which is what made this necessary.)
                 this.resetBaseFilters();
                 this.whenStyleUpdates(finalStyle);
                 onStyleReady === null || onStyleReady === void 0 ? void 0 : onStyleReady();
             })
                 .catch((error) => {
                 this.logError(error, { functionName: "changeParentPlaceTo" });
-                // Release the caller either way. `onStyleReady` is what a consumer
-                // hides its loading overlay on, so swallowing the failure here left
-                // the overlay up for good rather than merely unstyled.
                 onStyleReady === null || onStyleReady === void 0 ? void 0 : onStyleReady();
             });
         }
     }
-    /**
-     * Fetch the venue style over whichever endpoint this map is authorized on.
-     *
-     * A bearer token authorizes by the user's client access rather than the api
-     * key's scopes, so a client's branded style resolves without granting that
-     * place to a shared api key; api-key consumers keep the
-     * `/api/sdk/v2/mapStyleJson` path.
-     *
-     * Both callers go through here so they cannot disagree. They used to: once
-     * `setStyle` had stored a `styleRef` it resolved over bearer, the next
-     * parent-place change refetched that same ref over the api-key path, whose
-     * key does not scope it — a non-ok response, a rejected promise, and a style
-     * that was never applied, with `onStyleReady` left unfired under a caller's
-     * loading overlay.
-     */
     fetchVenueStyle(placeId, styleRef, styleTheme) {
         return this.authToken
             ? this.repository.fetchAndParseMapStyleByBearer(placeId, this.authToken, styleRef, styleTheme)
             : this.repository.fetchAndParseMapStyle(placeId, styleRef, styleTheme);
     }
-    /**
-     * Update the parent place and the current floor.
-     * Does not update layers, markers, etc.
-     * @param parentPlaceId
-     * @param floorId
-     * @throws A error if the parent place is not one of the allowed places to show.
-     */
     updatePlaceAndFloor(parentPlaceId, floorId) {
         var _a, _b, _c, _d, _e, _f;
         const place = this.potentialParentPlaces.find((place) => place.mapvxId === parentPlaceId);
@@ -810,10 +515,6 @@ export class InternalMapVXMap extends Loggeable {
     setLang(lang) {
         this.repository.setLang(lang);
         this.currentLang = lang;
-        // setLayersForLanguage reads this.map.getStyle()?.layers, which is empty
-        // until the style finishes loading. If setLang is called right after
-        // createMap (before the "load" event), apply it once the style is ready
-        // so the language change is not silently dropped.
         if (this.map.isStyleLoaded()) {
             this.setLayersForLanguage(lang);
         }
@@ -825,10 +526,6 @@ export class InternalMapVXMap extends Loggeable {
         this.changeParentPlaceTo(place, updateStyle, onStyleReady);
     }
     setStyle(styleRef, styleTheme, onStyleReady) {
-        // Every swap gets a generation. All shared bookkeeping below is touched only while
-        // this swap is still the current one, so two overlapping calls cannot release each
-        // other's overlay or apply an obsolete style. `readied` stays per-call because each
-        // caller's callback must still fire exactly once.
         const generation = ++this.styleSwapGeneration;
         const isCurrent = () => this.styleSwapGeneration === generation;
         let readied = false;
@@ -836,30 +533,16 @@ export class InternalMapVXMap extends Loggeable {
             if (readied)
                 return;
             readied = true;
-            // Only the current swap owns the shared timer; a superseded swap clearing it here
-            // would leave the live swap with no safety net (and its caller hidden forever).
             if (isCurrent() && this.styleReadyTimer) {
                 clearTimeout(this.styleReadyTimer);
                 this.styleReadyTimer = undefined;
             }
             onStyleReady === null || onStyleReady === void 0 ? void 0 : onStyleReady(error);
         };
-        // `onStyleReady` must fire on EVERY path — success, a rejected style request, or a
-        // swap that never settles — because callers keep the map hidden behind a loading
-        // overlay until it arrives. The safety timer is therefore armed before the request
-        // instead of inside `.then()`.
         if (this.styleReadyTimer)
             clearTimeout(this.styleReadyTimer);
         this.styleReadyTimer = setTimeout(reportReady, STYLE_READY_TIMEOUT_MS);
-        // A previous swap may still hold a `styledata` listener whose style never reached the
-        // loaded state. Drop it before starting a new one: it captured an obsolete style and
-        // would otherwise fire on this swap, wiping `baseFilters` and calling `setFilter`
-        // with layer ids the new style does not have.
         this.clearPendingStyleSwapListener();
-        // `this.map` is created asynchronously (see `onMapStyleLoaded`), so a `setStyle` call
-        // made right after `createMap` can land before it exists. Fail loudly instead of
-        // letting `this.map.setStyle` throw into `.catch`, which reported READY and left the
-        // caller revealing the previous style as if the swap had succeeded.
         if (!this.map) {
             const error = new Error("setStyle called before the map finished initializing; wait for the map's load event");
             this.logError(error, { functionName: "setStyle" });
@@ -869,40 +552,15 @@ export class InternalMapVXMap extends Loggeable {
         const stylePromise = this.fetchVenueStyle(this.parentPlaceId, styleRef, styleTheme);
         stylePromise
             .then((style) => {
-            // A newer swap started while this style was in flight. Applying this one now
-            // would fight the newer style layer by layer, so drop it and let the newer swap
-            // own the map and its caller's callback.
             if (!isCurrent())
                 return;
-            // Remember what is actually on screen: `changeParentPlaceTo` refetches the
-            // style with these, so without this an explicitly applied style would be
-            // silently reverted to the constructor's on the next parent-place change.
-            // After the generation check: a superseded swap never reached the map, so it
-            // must not claim to be what is on it.
             this.styleRef = styleRef;
             this.styleTheme = styleTheme;
             const useServiceWorkerCaching = this.tileCacheConfig.enabled && this.tileCacheConfig.persistToServiceWorker;
             const finalStyle = useServiceWorkerCaching ? this.transformStyleForCaching(style) : style;
-            // Full (non-diff) swap so the previewed style completely replaces the base —
-            // a diff would keep old base layers and reappear on the next floor change.
             this.map.setStyle(finalStyle, { diff: false });
-            // Drop the previous style's base filters SYNCHRONOUSLY, right where the layers
-            // they describe stop existing. They are keyed by layer id and persist across
-            // swaps, so any code reading them before the apply pass below (the `idle`
-            // handler's `filterByFloorKey`, a floor change racing the swap) would AND the
-            // previous style's discriminator into the new style's layers — the stale-filter
-            // washout this reset exists to prevent. Gating it on `isStyleLoaded` left exactly
-            // that window open. Fresh declared filters are re-captured lazily in
-            // `applyLayerFilters` as each indoor layer is first touched.
             this.resetBaseFilters();
-            // Re-apply floor filters, route/circle layers and markers ONLY once the new
-            // style's sources/layers have finished loading; running them mid-reload throws
-            // (`getSource` on an undefined style) and the floor filter would not stick.
             const applyOnceLoaded = () => {
-                // Superseded: detach and leave the map to the newer swap. Without this the
-                // listener stays attached (the slot it was tracked in has been overwritten)
-                // and re-seeds filters from layer ids the current style does not have, which
-                // makes maplibre throw and aborts the newer swap's own listener.
                 if (!isCurrent()) {
                     this.map.off("styledata", applyOnceLoaded);
                     return;
@@ -914,28 +572,13 @@ export class InternalMapVXMap extends Loggeable {
                     this.pendingStyleSwapListener = undefined;
                 }
                 this.whenStyleUpdates(finalStyle);
-                // A non-diff swap replaces every layer, so anything applied ON TOP of the
-                // style — label language, caller-requested place highlights, the 3D scene's
-                // GLB layer and hidden-layer overrides — is gone and has to be replayed.
-                // `whenStyleUpdates` covers only floor filters, routes and circles.
                 this.restoreStyleOverlays();
                 this.logEvent("setStyle");
             };
             this.pendingStyleSwapListener = applyOnceLoaded;
             this.map.on("styledata", applyOnceLoaded);
             applyOnceLoaded();
-            // Re-apply the floor filter and report ready once the map is idle. This is
-            // intentionally OUTSIDE applyOnceLoaded's `isStyleLoaded` gate: the indoor
-            // polygon layers settle a beat after the swap (so the floor filter in
-            // whenStyleUpdates misses them and the venue paints every floor at once), and
-            // `idle` only fires once the style is loaded and its first tiles rendered — so
-            // filterByFloorKey is safe here and does not depend on the sometimes-flaky
-            // isStyleLoaded check. onStyleReady lets callers reveal the map only once it is
-            // settled; the timer armed above just clears a hanging overlay if idle never fires.
             this.map.once("idle", () => {
-                // `once` cannot be cancelled, so a superseded swap's handler still fires —
-                // filtering here keeps it from re-filtering the newer style's floors and from
-                // reporting the newer swap's caller ready ahead of time.
                 if (!isCurrent())
                     return;
                 this.filterByFloorKey(this.currentFloor);
@@ -943,46 +586,18 @@ export class InternalMapVXMap extends Loggeable {
             });
         })
             .catch((error) => {
-            // A superseded swap must not tear down the listener the CURRENT swap installed.
             if (isCurrent()) {
                 this.clearPendingStyleSwapListener();
             }
             this.logError(error, { functionName: "setStyle" });
-            // Release the caller immediately instead of making it wait out the safety timer:
-            // the style will never arrive, so the overlay has nothing to wait for. The error
-            // is handed to the callback so a caller can tell a failed swap from an applied
-            // one — the previous style is still on screen either way.
             reportReady(error instanceof Error ? error : new Error(String(error)));
         });
     }
-    /**
-     * Forgets every captured base filter so the next style's declared filters are read
-     * fresh from that style instead of inherited from the previous one.
-     *
-     * Both halves must move together: `baseFilters` holds the expressions and
-     * `capturedBaseFilters` records which layer ids have already been resolved, so
-     * clearing only the first would leave every id marked "already captured" and the new
-     * style's filters would never be read at all.
-     */
     resetBaseFilters() {
         this.baseFilters = {};
         this.capturedBaseFilters.clear();
     }
-    /**
-     * Replays everything that lives ON TOP of the map style after a full (non-diff) swap
-     * has deleted it: label language expressions, caller-requested place highlights and
-     * the 3D scene's GLB layer / hidden-layer overrides.
-     *
-     * These are deliberately not part of `whenStyleUpdates`, which restores only
-     * style-derived state. These are decisions the SDK's callers made through `setLang`,
-     * `setPlacesAsSelected`, `addBorderToPlaces` and the 3D config, and nothing else would
-     * ever restore them.
-     */
     restoreStyleOverlays() {
-        // Each step is isolated: the style itself has already been applied by the time we get
-        // here, so one failing restore must neither skip the others nor bubble out into
-        // `setStyle`'s `.catch`, which would report the successful swap to `onStyleReady` as
-        // a failure. `setPlacesAsSelected` / `addBorderToPlaces` throw by contract.
         const restore = (what, step) => {
             try {
                 step();
@@ -1000,13 +615,7 @@ export class InternalMapVXMap extends Loggeable {
             const { placeIds, color, width } = this.borderedPlacesRequest;
             restore("borderedPlaces", () => this.addBorderToPlaces(placeIds, color, width));
         }
-        // A style swap can cross the 3D/2D line: `changeParentPlaceTo` refetches `mapStyleJson`, and
-        // the new venue's style may publish no extrusions. Re-read it from the live style before
-        // deciding, or the reattach below would put the overlay back on flat ground.
         this.styleSupports3D = this.is3DStyle();
-        // The swap removed the GLB custom layer, and MapLibre called its `onRemove`, which
-        // disposes the whole three.js scene. Nothing else re-adds it, so without this every
-        // 3D model disappears permanently and `hideLayers` stops being applied.
         restore("scene3D", () => {
             var _a;
             if (!this.is3DSceneActive())
@@ -1014,31 +623,16 @@ export class InternalMapVXMap extends Loggeable {
             (_a = this.scene3D) === null || _a === void 0 ? void 0 : _a.reattachToStyle();
         });
     }
-    /**
-     * Removes the `styledata` listener left by an in-flight {@link setStyle} swap, if any.
-     * Called before starting a new swap and when one fails, so a listener holding an
-     * obsolete style can never fire against a different style's layers.
-     */
     clearPendingStyleSwapListener() {
         var _a;
         if (!this.pendingStyleSwapListener)
             return;
-        // `this.map?` — a listener can only have been installed while the map existed, but
-        // this also runs from `destroyMap` and from `setStyle` before the map is created.
         (_a = this.map) === null || _a === void 0 ? void 0 : _a.off("styledata", this.pendingStyleSwapListener);
         this.pendingStyleSwapListener = undefined;
     }
-    /**
-     * Removes current parent place and updates style to default
-     */
     removeParentPlace() {
         this.changeParentPlaceTo(undefined, true);
     }
-    /**
-     * Applies filters and changes to layers according to given style.
-     * Expected to be called every time a new style is loaded
-     * @param newStyle
-     */
     whenStyleUpdates(newStyle) {
         var _a;
         if (newStyle) {
@@ -1049,17 +643,6 @@ export class InternalMapVXMap extends Loggeable {
         this.filterByFloorKey(this.currentFloor);
         (_a = this.scene3D) === null || _a === void 0 ? void 0 : _a.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
-     */
     getMarkers() {
         const unmanaged = this.routeController.getRouteMarkers();
         if (this.userLocationMarker)
@@ -1069,7 +652,6 @@ export class InternalMapVXMap extends Loggeable {
     addMarker(marker) {
         var _a;
         try {
-            // Check if a marker with the same ID already exists and remove it
             if (marker.id) {
                 const existingMarkerIndex = this.markers.findIndex((m) => m.id === marker.id);
                 if (existingMarkerIndex !== -1) {
@@ -1083,8 +665,6 @@ export class InternalMapVXMap extends Loggeable {
                 }
             }
             const markerCreated = new MarkerAttribute(Object.assign(Object.assign({}, marker), { maxLabelWidthPx: (_a = marker.maxLabelWidthPx) !== null && _a !== void 0 ? _a : this.markerLayoutConfig.maxLabelWidthPx }));
-            // While a floor change is still being rebuilt, the marker is shown by that
-            // change's settle step, together with the new floor.
             if (!this.floorSettlePending) {
                 markerCreated.changeFloor(this.currentFloor, this.map, this.isOutdoorFloor(this.currentFloor));
             }
@@ -1181,11 +761,9 @@ export class InternalMapVXMap extends Loggeable {
     }
     addCircle(circle) {
         try {
-            // Check if a circle with the same ID already exists and replace it
             if (circle.id) {
                 this.circles = this.circles.filter((c) => c.id !== circle.id);
             }
-            // resolveCircleConfig validates radiusMeters and coordinates
             const record = resolveCircleConfig(circle);
             this.circles.push(record);
             this.refreshCircles();
@@ -1201,7 +779,6 @@ export class InternalMapVXMap extends Loggeable {
             const index = this.circles.findIndex((c) => c.id === circleConfig.id);
             if (index === -1)
                 return null;
-            // resolveCircleConfig validates radiusMeters and coordinates
             this.circles[index] = resolveCircleConfig(circleConfig, this.circles[index].hidden);
             this.refreshCircles();
             this.logEvent("updateCircle");
@@ -1226,7 +803,6 @@ export class InternalMapVXMap extends Loggeable {
             const circle = this.circles.find((c) => c.id === circleId);
             if (circle === undefined)
                 return false;
-            // Validate inputs before modifying
             if (!center) {
                 throw new Error("Circle center is required");
             }
@@ -1259,7 +835,6 @@ export class InternalMapVXMap extends Loggeable {
             const circle = this.circles.find((c) => c.id === circleId);
             if (circle === undefined)
                 return false;
-            // Update only style properties, clamp opacities
             if (style.fillColor !== undefined)
                 circle.fillColor = style.fillColor;
             if (style.fillOpacity !== undefined)
@@ -1330,12 +905,6 @@ export class InternalMapVXMap extends Loggeable {
             return false;
         }
     }
-    /**
-     * Builds the GeoJSON FeatureCollection for every currently visible circle.
-     * Visibility mirrors marker semantics: a circle with a floor is shown only
-     * while that floor is displayed, and a circle without a floor is shown only
-     * in outdoor contexts. Hidden circles are always omitted.
-     */
     circleFeatureCollection() {
         var _a;
         const floorId = (_a = this.currentFloor) !== null && _a !== void 0 ? _a : "";
@@ -1368,24 +937,6 @@ export class InternalMapVXMap extends Loggeable {
         }));
         return { type: "FeatureCollection", features };
     }
-    /**
-     * Idempotently adds the shared circle source and its fill/line layers.
-     * Layers are inserted below the first symbol layer so place labels and
-     * markers stay readable above the translucent fill. Safe to call at any
-     * time: a style that is still loading simply rejects the calls, and the
-     * styledata listener retries once the style is ready.
-     */
-    /**
-     * Resolves the layer id to insert circle layers before, for one render
-     * order. `undefined` means "append on top".
-     *
-     * `aboveBasemap` finds the topmost non-symbol layer of the style and
-     * inserts before the first symbol layer that follows it. On indoor styles
-     * the floor-plate and building polygons are ordered after the first symbol
-     * layer, so anchoring on the topmost geometry layer — instead of the first
-     * symbol layer — guarantees circles are never occluded by basemap fills
-     * while still rendering below the labels that follow them.
-     */
     circleBeforeIdFor(order) {
         var _a, _b, _c, _d;
         if (order === "top")
@@ -1394,7 +945,6 @@ export class InternalMapVXMap extends Loggeable {
         if (order === "belowLabels") {
             return (_c = layers.find((layer) => layer.type === "symbol")) === null || _c === void 0 ? void 0 : _c.id;
         }
-        // aboveBasemap
         let lastNonSymbolIndex = -1;
         layers.forEach((layer, index) => {
             if (layer.type !== "symbol")
@@ -1402,15 +952,6 @@ export class InternalMapVXMap extends Loggeable {
         });
         return (_d = layers.slice(lastNonSymbolIndex + 1).find((layer) => layer.type === "symbol")) === null || _d === void 0 ? void 0 : _d.id;
     }
-    /**
-     * Idempotently ensures the shared circle source and one fill/line layer
-     * pair per render order in use, at the placement that order requires.
-     * Placement is recomputed and re-asserted (via moveLayer) on every call,
-     * so circles regain their correct z-order after any style reload or
-     * floor/parent-place change. Safe to call at any time: a style that is
-     * still loading simply rejects the calls, and the styledata listener
-     * retries once the style is ready.
-     */
     ensureCircleLayers() {
         if (!this.map)
             return;
@@ -1422,14 +963,7 @@ export class InternalMapVXMap extends Loggeable {
                 });
             }
             const ordersInUse = new Set(this.circles.map((c) => c.renderOrder));
-            // Always keep the default bucket alive so an empty map still renders
-            // newly added circles without a layer rebuild
             ordersInUse.add("aboveBasemap");
-            // Process buckets lowest-first (CIRCLE_RENDER_ORDERS is canonical):
-            // when two buckets resolve to the same anchor, each addLayer/moveLayer
-            // lands immediately before it, so a bucket processed later paints above
-            // the ones processed earlier. Canonical order keeps
-            // belowLabels < aboveBasemap < top regardless of circle insertion order.
             for (const order of CIRCLE_RENDER_ORDERS) {
                 if (!ordersInUse.has(order))
                     continue;
@@ -1475,11 +1009,6 @@ export class InternalMapVXMap extends Loggeable {
             this.debugLog("Layers not added: style not loaded yet, the styledata listener will re-add them", error);
         }
     }
-    /**
-     * Re-renders all circles: ensures the source and layers exist, then pushes
-     * the current FeatureCollection. Called after every mutation of the circle
-     * list, on floor changes, and when the map style reloads.
-     */
     refreshCircles() {
         if (!this.map)
             return;
@@ -1494,21 +1023,12 @@ export class InternalMapVXMap extends Loggeable {
             this.debugLog("Source not found (a new style may still be loading)", error);
         }
     }
-    /**
-     * Use it to change the current layer
-     * @param floorKey floor id
-     */
     filterByFloorKey(floorKey) {
         this.currentFloor = floorKey;
         const floorKeyString = floorKey !== null && floorKey !== void 0 ? floorKey : "";
         if (this.innerFloors.every((floor) => floor.key !== floorKey) && floorKey !== "") {
             this.logEvent("invalidFloorKey", { floorKey: floorKeyString });
         }
-        // One style read for the whole floor change. `getStyle()` serializes every
-        // source and layer of the venue style, and the second read is the expensive
-        // one: `updateFiltersTo` writes filters and layout properties in between,
-        // and each write nulls maplibre's `_serializedLayers` cache, so anything
-        // that reads the style afterwards rebuilds it from scratch.
         const layers = this.safeStyleLayers();
         this.updateFiltersTo(floorKeyString, layers);
         this.updateMarkersWhenFloorSettles(floorKeyString, layers);
@@ -1516,28 +1036,10 @@ export class InternalMapVXMap extends Loggeable {
         this.routeController.updateRouteLayers(floorKeyString);
         this.routeController.updateRouteMarkerVisibility(floorKeyString);
     }
-    /**
-     * Show/hide the HTML markers for `floorId` once the indoor tiles have been
-     * rebuilt with the new floor filters.
-     *
-     * A floor change is a `setFilter` on every indoor layer: MapLibre rebuilds the
-     * tile buckets in its worker, so the new floor appears a few frames later
-     * (hundreds of ms on a low-end panel) while a marker is a DOM element that
-     * would move instantly. Waiting for the source to report loaded makes floor
-     * polygons and markers switch in the same frame. The wait is bounded, is
-     * dropped when a newer floor change arrives, and is skipped outside a
-     * browser (no `requestAnimationFrame`).
-     */
     updateMarkersWhenFloorSettles(floorId, styleLayers) {
         const token = ++this.floorSettleToken;
-        // Resolved rather than probed with `hasStyle()`, which is another full
-        // `getStyle()` — and by this point the most expensive kind, because
-        // `updateFiltersTo` has just invalidated the serialized-layer cache.
         const layers = styleLayers === undefined ? this.safeStyleLayers() : styleLayers;
         if (typeof requestAnimationFrame !== "function" || layers === null) {
-            // No poll will run for this floor change, so nothing would ever clear the
-            // flag later: leaving it set makes every subsequent `addMarker` skip
-            // `changeFloor` and the marker is never attached to the map.
             this.floorSettleDeadline = null;
             this.updateMarkersTo(floorId);
             return;
@@ -1554,9 +1056,6 @@ export class InternalMapVXMap extends Loggeable {
             const loaded = sourceIds.every((id) => this.isSourceSettled(id));
             if (!loaded)
                 sawReloading = true;
-            // The reload is dispatched on the map's next render, which may run after
-            // this callback within the same frame: give it a couple of frames to be
-            // observed before concluding there was nothing to reload.
             const settled = loaded && (sawReloading || frames >= FLOOR_SETTLE_MIN_FRAMES);
             if (settled || this.now() >= deadline) {
                 this.floorSettleDeadline = null;
@@ -1567,19 +1066,6 @@ export class InternalMapVXMap extends Loggeable {
         };
         requestAnimationFrame(poll);
     }
-    /**
-     * Sources whose tiles a switch to `floorId` actually reloads, and which the
-     * marker settle therefore has to wait on.
-     *
-     * With a vector basemap that is the source the `indoor-*` layers draw from,
-     * because the floor change is a `setFilter` over those layers. An offline
-     * bundle's raster basemap switches floors by making `raster-floor-<key>`
-     * visible instead, and those tiles only begin loading at that moment — while
-     * its `indoor-*` layers carry labels and hover, are already loaded, and would
-     * report settled at once, letting the markers switch a floor before its image
-     * had painted. That is the configuration this wait exists for, so both are
-     * waited on.
-     */
     floorSettleSourceIds(floorId, layers) {
         const ids = new Set();
         const rasterFloor = layers.find((layer) => layer.id === `raster-floor-${floorId}`);
@@ -1589,7 +1075,6 @@ export class InternalMapVXMap extends Loggeable {
         ids.add(this.indoorSourceId(layers));
         return [...ids];
     }
-    /** The vector source the `indoor-*` layers draw from (`indoorequal` by default). */
     indoorSourceId(layers) {
         for (const layer of layers) {
             if (layer.id.startsWith("indoor-") && "source" in layer && typeof layer.source === "string") {
@@ -1633,21 +1118,8 @@ export class InternalMapVXMap extends Loggeable {
         var _a, _b, _c;
         if (!this.map)
             return;
-        // `null` means the caller looked and there was no style; only `undefined`
-        // means it did not look.
         const layers = (_a = (styleLayers === undefined ? this.safeStyleLayers() : styleLayers)) !== null && _a !== void 0 ? _a : [];
-        // Raster basemap (offline bundles baked with one raster archive per floor):
-        // a floor is switched by showing its `raster-floor-<key>` layer and hiding
-        // the others. The remaining `indoor-*` layers (labels, hover, highlights)
-        // are still vector and keep going through the filter logic below.
         const rasterFloorPrefix = "raster-floor-";
-        // Only switch the raster basemap when there is a baked layer to switch to.
-        // Hiding every raster floor leaves the basemap blank, and no id can match in
-        // two cases: no floor at all (an outdoor place, or a venue with no floors,
-        // where `currentFloor` is `""`), and a floor the bundle has no raster
-        // archive for — a venue where only some floors are baked, or a floor added
-        // after the bundle was built. Keeping the current one visible is the safe
-        // fallback for both.
         const rasterFloorLayerIds = layers
             .filter((l) => l.id.startsWith(rasterFloorPrefix))
             .map((l) => l.id);
@@ -1664,14 +1136,6 @@ export class InternalMapVXMap extends Loggeable {
         });
         const baseFloorId = (_b = this.innerFloors.find((floor) => floor.key === floorId)) === null || _b === void 0 ? void 0 : _b.baseFloor;
         const indoorLayers = layers.filter((layer) => layer.id.startsWith("indoor-"));
-        // Resolve each indoor layer's declared (base) filter before we start folding floor
-        // filters into it — and before cloning it into a `base-indoor-*` layer, which copies
-        // the base filter across. Layers added asynchronously after a `setStyle` swap are
-        // missing when `setBaseFilters` runs, so this is where their still-pristine filter
-        // is captured; without it the layer loses its own discrimination and repaints every
-        // feature (the washed-out / blue-outline look after changing floors). Layers already
-        // resolved are skipped, so a filter this class wrote is never mistaken for a
-        // declared one.
         indoorLayers.forEach((layer) => this.captureDeclaredBaseFilter(layer.id));
         if (baseFloorId != undefined) {
             const firstLayerId = (_c = indoorLayers[0]) === null || _c === void 0 ? void 0 : _c.id;
@@ -1689,11 +1153,6 @@ export class InternalMapVXMap extends Loggeable {
             this.applyLayerFilters(layer, floorId);
         });
     }
-    /**
-     * Reads a layer's current filter, tolerating the layer having been removed or the
-     * style being mid-swap (maplibre `getFilter` throws in those cases). Returns
-     * `undefined` instead of throwing so base-filter capture never aborts floor filtering.
-     */
     safeGetFilter(layerId) {
         try {
             return this.map.getFilter(layerId);
@@ -1704,15 +1163,6 @@ export class InternalMapVXMap extends Loggeable {
     }
     applyLayerFilters(layer, floorId) {
         var _a;
-        // Resolve the layer's declared (base) filter the first time we touch it. Indoor
-        // layers such as `indoor-polygon-room` share one source and are told apart only by
-        // their own filter (e.g. `["in","room",["get","tags"]]`); we must fold that into the
-        // floor filter or the layer repaints every feature. Some of these layers are added
-        // asynchronously after a `setStyle` swap, so they are absent when `setBaseFilters`
-        // runs — capturing here, while their live filter is still pristine, is what keeps a
-        // floor change from wiping the style (the washed-out, blue-outline look).
-        // `base-indoor-*` clones inherit their base filter from the layer they were cloned
-        // from, so they are never read back.
         if (!layer.id.startsWith("base-indoor-")) {
             this.captureDeclaredBaseFilter(layer.id);
         }
@@ -1748,9 +1198,6 @@ export class InternalMapVXMap extends Loggeable {
             (layer.type == "fill" || layer.type === "fill-extrusion")) {
             customFilters.push(["!", ["in", this.hoveredId, ["get", "ref"]]]);
         }
-        // From here on this layer's live filter is ours, never the style's declared one.
-        // Marking it keeps any later pass from reading it back as a base filter — that is
-        // what used to AND the previous floor into the next one and blank the layer out.
         this.capturedBaseFilters.add(layer.id);
         if (baseFilter != null) {
             const finalFilter = ["all", baseFilter, customFilters];
@@ -1760,21 +1207,9 @@ export class InternalMapVXMap extends Loggeable {
             this.map.setFilter(layer.id, customFilters);
         }
     }
-    /**
-     * Floors of the parent place
-     * @returns Inner floors of the parent place
-     */
     getInnerFloors() {
         return this.innerFloors;
     }
-    /**
-     * Whether `floorId` shows the venue's outdoors, and so whether entities that
-     * carry no floor of their own belong on screen with it.
-     *
-     * A map without a parent place is outdoors throughout; inside one, only a
-     * floor reachable from GPS is. Markers, circles and the route marker all hang
-     * their visibility on this, so they answer it the same way.
-     */
     isOutdoorFloor(floorId) {
         var _a, _b;
         return (!this.parentPlace ||
@@ -1886,11 +1321,9 @@ export class InternalMapVXMap extends Loggeable {
                 maxLng !== null && maxLng !== void 0 ? maxLng : 0,
                 maxLat !== null && maxLat !== void 0 ? maxLat : 0,
             ];
-            // Get container dimensions for percentage-based padding calculations
             const container = this.map.getContainer();
             const containerWidth = container.clientWidth;
             const containerHeight = container.clientHeight;
-            // Convert padding values with units to pixels
             const padding = convertPaddingToPixels(options === null || options === void 0 ? void 0 : options.padding, containerWidth, containerHeight);
             const fitOptions = Object.assign(Object.assign({}, options), { padding });
             const bearing = this.map.getBearing();
@@ -1909,11 +1342,9 @@ export class InternalMapVXMap extends Loggeable {
             return;
         }
         const onComplete = options === null || options === void 0 ? void 0 : options.onComplete;
-        // Get container dimensions for percentage-based padding calculations
         const container = this.map.getContainer();
         const containerWidth = container.clientWidth;
         const containerHeight = container.clientHeight;
-        // Convert padding values with units to pixels
         const padding = convertPaddingToPixels(options === null || options === void 0 ? void 0 : options.padding, containerWidth, containerHeight);
         if (coordinates.length === 1) {
             const [coord] = coordinates;
@@ -1933,17 +1364,8 @@ export class InternalMapVXMap extends Loggeable {
             maxZoom: (_c = options === null || options === void 0 ? void 0 : options.maxZoom) !== null && _c !== void 0 ? _c : this.map.getMaxZoom(),
             minZoom: this.map.getMinZoom(),
         };
-        // Orthographic oriented fit (exact for pitch 0). maplibre's fitBounds only
-        // fits a north-up LngLatBounds, which wastes viewport space for diagonal
-        // geometries under a bearing.
         let camera = computeOrientedCamera(coordinates, cameraParams);
-        // With a tilted camera the orthographic zoom is off due to perspective, so
-        // refine it against maplibre's real projection on a cloned transform.
         if (pitch > 0) {
-            // Simulated on the live map through its public API rather than on `map.transform.clone()`:
-            // MapLibre v6 removes the internal transform and exposes no replacement. The whole loop is
-            // synchronous and ends in `restore()`, so no intermediate frame is ever painted.
-            // See DEVELOPER_DOCS/MAPLIBRE_V6_MIGRATION.md.
             const fitTransform = new LiveMapFitTransform(this.map);
             try {
                 camera = refineCameraForPitch(fitTransform, coordinates, camera, Object.assign(Object.assign({}, cameraParams), { pitch }));
@@ -1960,12 +1382,10 @@ export class InternalMapVXMap extends Loggeable {
             padding }));
     }
     fitRouteByPlace(route, placeId, options) {
-        // Filter steps that belong to the specified place
         const stepsInPlace = route.steps.filter((step) => step.startInsidePlace === placeId || step.endInsidePlace === placeId);
         if (stepsInPlace.length === 0) {
             return;
         }
-        // Extract all coordinates from the filtered steps
         const coords = stepsInPlace.flatMap((step) => extractStepCoordinates(step));
         if (coords.length > 0) {
             this.fitCoordinates(coords, options);
@@ -2019,27 +1439,14 @@ export class InternalMapVXMap extends Loggeable {
             this.logEvent("addLiveRoute");
             const fetchRouteConfig = new InternalGetRouteConfiguration(config);
             const drawRouteConfig = new InternalDrawRouteConfiguration(drawConfig);
-            // Take a ticket BEFORE awaiting: refreshes overlap, and an older response
-            // resolving after a newer one must not clobber it (stale route drawn,
-            // liveRouteId pointing at the wrong instance).
             const ticket = ++this.liveRouteTicket;
             const route = await this.repository.fetchAndParseLiveRoute(fetchRouteConfig);
             if (ticket !== this.liveRouteTicket) {
-                // Superseded while in flight — the map shows (or will show) the newer
-                // route. Return the fetched data without drawing it.
                 return route;
             }
-            // Replace the previous live route so repeated refreshes don't stack paths
-            // on the map. Removal happens AFTER the fetch, so a failed refresh leaves
-            // the current route on screen. Targeted by id, so routes drawn with
-            // addRoute are untouched.
             if (this.liveRouteId !== undefined && this.liveRouteId !== route.id) {
                 this.routeController.removeRoute(this.liveRouteId);
             }
-            // Clear any instance already using this id (a same-id refresh, or the same
-            // route previously drawn via addRoute) — the controller derives its
-            // source/layer ids from the route id, so re-adding without removing would
-            // throw "Source already exists".
             if (this.routeController.getRouteIds().includes(route.id)) {
                 this.routeController.removeRoute(route.id);
             }
@@ -2093,13 +1500,6 @@ export class InternalMapVXMap extends Loggeable {
         }
         this.syncLiveRouteId();
     }
-    /**
-     * Drop {@link liveRouteId} when the instance it points at is no longer on the
-     * map (removed via removeRoute/removeRouteById/removeAllRoutes — including the
-     * no-arg removeRoute, which removes the last-added route). Keeps the live
-     * bookkeeping in sync so a later {@link addLiveRoute} doesn't act on a
-     * dangling id.
-     */
     syncLiveRouteId() {
         if (this.liveRouteId !== undefined &&
             !this.routeController.getRouteIds().includes(this.liveRouteId)) {
@@ -2134,15 +1534,12 @@ export class InternalMapVXMap extends Loggeable {
         this.map.on("click", async (e) => {
             var _a, _b;
             const features = this.map.queryRenderedFeatures(e.point);
-            // Filter room features by current floor
             const roomFeatures = features.filter((feature) => { var _a; return feature.properties.class === "room" && ((_a = feature.properties) === null || _a === void 0 ? void 0 : _a.floor_key) === this.currentFloor; });
             const touchedFeature = roomFeatures[0];
             const ref = touchedFeature === null || touchedFeature === void 0 ? void 0 : touchedFeature.properties.ref;
             if (ref != null && typeof ref === "string" && ref.length > 0) {
                 console.log("touchedFeature", ref);
-                // First, search in current subPlaces
                 let clickedPlace = this.subPlaces.find((subPlace) => subPlace.mapvxId === ref);
-                // If not found, search in subplaces of potential parent places
                 if (clickedPlace === undefined) {
                     for (const potentialParentPlace of this.potentialParentPlaces) {
                         const cachedSubPlaces = this.repository.getCachedSubPlaces(potentialParentPlace.mapvxId);
@@ -2154,7 +1551,6 @@ export class InternalMapVXMap extends Loggeable {
                         }
                     }
                 }
-                // As last resort, search in general cache
                 if (clickedPlace === undefined) {
                     const cachedPlaces = this.repository.getCachedPlaces([ref]);
                     if (cachedPlaces.length === 0) {
@@ -2190,8 +1586,6 @@ export class InternalMapVXMap extends Loggeable {
                 this.updateFiltersTo(this.currentFloor);
             }
         });
-        // When the mouse leaves the state-fill layer, update the feature state of the
-        // previously hovered feature.
         this.map.on("mouseleave", "hoverable", () => {
             this.hoveredId = "unselected";
             this.updateFiltersTo(this.currentFloor);
@@ -2211,8 +1605,6 @@ export class InternalMapVXMap extends Loggeable {
             const placeFilter = ["any", ...coloredPlacesFilters];
             const condition = ["all", placeFilter, basicFilter];
             this.map.setFilter("indoor-colored-places", condition);
-            // Caller-defined base filter: mark it resolved so no later capture can
-            // overwrite this customization with the layer's style-declared filter.
             this.capturedBaseFilters.add("indoor-colored-places");
             this.baseFilters["indoor-colored-places"] = placeFilter;
             if (color !== undefined) {
@@ -2233,10 +1625,6 @@ export class InternalMapVXMap extends Loggeable {
             this.debugLog("Place selection failed (layer may not exist)", error);
         }
     }
-    /**
-     * Same question as {@link styleHasExtrusions}, asked of the style the map is currently showing
-     * rather than one about to be applied. Used after load, when `map.getStyle()` is available.
-     */
     is3DStyle() {
         return styleHasExtrusions(this.map.getStyle());
     }
@@ -2303,8 +1691,6 @@ export class InternalMapVXMap extends Loggeable {
         this.coloredPlacesRequest = undefined;
         if (this.hasLayer("indoor-colored-places")) {
             const condition = ["==", ["get", "ref"], "unselected"];
-            // Caller-defined base filter: mark it resolved so no later capture can
-            // overwrite this customization with the layer's style-declared filter.
             this.capturedBaseFilters.add("indoor-colored-places");
             this.baseFilters["indoor-colored-places"] = condition;
             this.map.setFilter("indoor-colored-places", condition);
@@ -2488,7 +1874,6 @@ export class InternalMapVXMap extends Loggeable {
             this.userLocationMarker.remove();
             this.userLocationMarker = undefined;
             this.markerLayoutController.scheduleRelayout();
-            // Check if watchPosition ID is valid and stop tracking
             if (this.watchPositionID) {
                 this.geoLocation.clearWatch(this.watchPositionID);
                 this.watchPositionID = undefined;
@@ -2512,8 +1897,6 @@ export class InternalMapVXMap extends Loggeable {
             const placeFilter = ["any", ...coloredPlacesFilters];
             const condition = ["all", placeFilter, basicFilter];
             this.map.setFilter("indoor-bordered-places", condition);
-            // Caller-defined base filter: mark it resolved so no later capture can
-            // overwrite this customization with the layer's style-declared filter.
             this.capturedBaseFilters.add("indoor-bordered-places");
             this.baseFilters["indoor-bordered-places"] = placeFilter;
             if (color !== undefined && width !== undefined) {
@@ -2543,8 +1926,6 @@ export class InternalMapVXMap extends Loggeable {
         this.borderedPlacesRequest = undefined;
         if (this.hasLayer("indoor-bordered-places")) {
             const condition = ["==", ["get", "ref"], "unselected"];
-            // Caller-defined base filter: mark it resolved so no later capture can
-            // overwrite this customization with the layer's style-declared filter.
             this.capturedBaseFilters.add("indoor-bordered-places");
             this.baseFilters["indoor-bordered-places"] = condition;
             this.map.setFilter("indoor-bordered-places", condition);
@@ -2554,30 +1935,26 @@ export class InternalMapVXMap extends Loggeable {
         var _a, _b;
         e.originalEvent.preventDefault();
         console.warn("Contexto WebGL perdido 😢");
-        // Intentar restaurar el contexto automáticamente
         const canvas = (_a = this === null || this === void 0 ? void 0 : this.map) === null || _a === void 0 ? void 0 : _a.getCanvas();
         const gl = (canvas === null || canvas === void 0 ? void 0 : canvas.getContext("webgl")) || (canvas === null || canvas === void 0 ? void 0 : canvas.getContext("webgl2"));
         if (gl && gl.isContextLost()) {
             canvas.addEventListener("webglcontextrestored", () => {
                 console.debug("Contexto WebGL restaurado, forzando re-render");
-                this.map.triggerRepaint(); // forzar repaint
+                this.map.triggerRepaint();
                 this.failedTiles.clear();
             }, { once: true });
             const ext = gl.getExtension("WEBGL_lose_context");
-            (_b = ext === null || ext === void 0 ? void 0 : ext.restoreContext) === null || _b === void 0 ? void 0 : _b.call(ext); // si aplica
+            (_b = ext === null || ext === void 0 ? void 0 : ext.restoreContext) === null || _b === void 0 ? void 0 : _b.call(ext);
         }
     }
     onWebGLContextRestored() {
         console.debug("Evento webglcontextrestored recibido, haciendo map.redraw()");
-        this.map.redraw(); // fuerza un redraw síncrono  [oai_citation:0‡maplibre.org](https://www.maplibre.org/maplibre-gl-js/docs/API/classes/Map/?utm_source=chatgpt.com)
+        this.map.redraw();
         this.failedTiles.clear();
     }
     onSourceData(e) {
         var _a;
-        // Only track tiles that actually failed to load (not aborted or never loaded)
         if (e.source.type === "vector" && e.sourceId === "indoorequal" && e.tile && !e.isSourceLoaded) {
-            // Check if tile has an error state before adding to retry queue
-            // Access state property safely as it may not always be available
             const tileState = (_a = e.tile) === null || _a === void 0 ? void 0 : _a.state;
             if (tileState === "errored" || tileState === "expired") {
                 this.failedTiles.add(e.tile);
@@ -2585,25 +1962,10 @@ export class InternalMapVXMap extends Loggeable {
         }
     }
     onSourceDataAbort(e) {
-        // Remove aborted tiles from retry queue as they shouldn't be retried
         if (e.source.type === "vector" && e.sourceId === "indoorequal" && e.tile) {
             this.failedTiles.delete(e.tile);
         }
     }
-    /**
-     * True when a style object is attached to the map. During a full `setStyle` swap the
-     * map is momentarily style-less and any `getSource`/`getFilter` call throws
-     * ("Cannot read properties of undefined"), so call sites that only need the style to
-     * exist should gate on this rather than on `isStyleLoaded()`.
-     */
-    /**
-     * This style's layers, or `null` when the map has no style right now.
-     *
-     * The one place the style is read for a floor change, so callers can pass the
-     * result on instead of each probing again — `getStyle()` serializes every
-     * source and layer, and `Style._updateLayer` drops the cache behind it on
-     * every filter or layout write.
-     */
     safeStyleLayers() {
         var _a, _b, _c;
         try {
@@ -2615,12 +1977,6 @@ export class InternalMapVXMap extends Loggeable {
     }
     hasStyle() {
         var _a;
-        // `map.getStyle()` is the PUBLIC probe: it returns the serialized style, or throws
-        // while the map is momentarily style-less mid-swap. Reading maplibre's internal
-        // `style` field instead (it is absent from the public typings, so it needed a double
-        // cast) would fail closed and silently forever the moment a maplibre upgrade renames
-        // or privatizes it — disabling both the tile-retry loop and `setStyle`'s apply pass
-        // with no throw and no log. `safeGetFilter` already uses this try/catch shape.
         try {
             return ((_a = this.map) === null || _a === void 0 ? void 0 : _a.getStyle()) != null;
         }
@@ -2628,12 +1984,6 @@ export class InternalMapVXMap extends Loggeable {
             return false;
         }
     }
-    /**
-     * True when the map has a style object attached and fully loaded. Unlike
-     * `map.isStyleLoaded()`, this does not emit maplibre's "There is no style
-     * added to the map" warning when the style is momentarily absent (e.g. during
-     * a `setStyle` swap), because it checks for the style object first.
-     */
     hasLoadedStyle() {
         if (!this.hasStyle())
             return false;
@@ -2642,20 +1992,11 @@ export class InternalMapVXMap extends Loggeable {
     subscribeToFailedTiles() {
         if (this.retryTimer)
             return;
-        // Store bound functions for proper cleanup
         this.boundOnSourceData = this.onSourceData.bind(this);
         this.boundOnSourceDataAbort = this.onSourceDataAbort.bind(this);
         this.boundOnWebGLContextLost = this.onWebGLContextLost.bind(this);
         this.boundOnWebGLContextRestored = this.onWebGLContextRestored.bind(this);
         this.retryTimer = setInterval(() => {
-            // During a full style swap (`setStyle` with `diff: false`) the map can
-            // momentarily have no style object attached. Calling `getSource` then
-            // throws ("Cannot read properties of undefined (reading 'getSource')").
-            // Only the style's PRESENCE is checked here, never `isStyleLoaded()`:
-            // that is false while any source still has tiles in flight, which is
-            // exactly when tiles fail — gating on it would skip every tick during a
-            // bad-network burst. The queue is left untouched so the tiles queued
-            // mid-swap are still retried on the next tick.
             if (!this.hasStyle()) {
                 return;
             }
@@ -2668,27 +2009,21 @@ export class InternalMapVXMap extends Loggeable {
                 this.failedTiles.clear();
                 return;
             }
-            // Process tiles and remove invalid ones
             const tilesToRetry = [];
             const tilesToRemove = [];
             this.failedTiles.forEach((tile) => {
-                // Check if tile is still valid before attempting reload
                 if (!tile || tile.state === "unloaded" || tile.state === "loading") {
                     tilesToRemove.push(tile);
                     return;
                 }
-                // Only retry tiles that are in an error state
                 if (tile.state === "errored" || tile.state === "expired") {
                     tilesToRetry.push(tile);
                 }
                 else {
-                    // Tile is in a valid state, remove from retry queue
                     tilesToRemove.push(tile);
                 }
             });
-            // Remove invalid tiles from the set
             tilesToRemove.forEach((tile) => this.failedTiles.delete(tile));
-            // Attempt to reload valid failed tiles
             const now = Date.now();
             tilesToRetry.forEach((tile) => {
                 var _a;
@@ -2697,7 +2032,6 @@ export class InternalMapVXMap extends Loggeable {
                     nextAttemptAt: 0,
                     pending: false,
                 };
-                // Skip tiles with a reload still in flight or still inside their backoff window.
                 if (retry.pending || now < retry.nextAttemptAt)
                     return;
                 const onFailure = (error) => {
@@ -2708,7 +2042,6 @@ export class InternalMapVXMap extends Loggeable {
                         this.tileRetryState.delete(tile);
                         return;
                     }
-                    // Stay in the queue and try again once the backoff has elapsed.
                     const backoffMs = TILE_RETRY_BASE_DELAY_MS * 2 ** (attempts - 1);
                     this.debugLog(`Tile reload failed (attempt ${attempts}/${MAX_TILE_RETRIES}), retrying in ${backoffMs}ms`, error);
                     this.tileRetryState.set(tile, {
@@ -2718,18 +2051,11 @@ export class InternalMapVXMap extends Loggeable {
                     });
                 };
                 try {
-                    // Verify tile still exists and is in a retryable state
                     if (tile && (tile.state === "errored" || tile.state === "expired")) {
                         this.tileRetryState.set(tile, Object.assign(Object.assign({}, retry), { pending: true }));
-                        // loadTile is async, so a rejection escapes this try/catch and has to be handled
-                        // on the promise itself - otherwise it surfaces as an unhandled rejection and the
-                        // tile is retried on every tick regardless of how often it has already failed.
                         source
                             .loadTile(tile)
                             .then(() => {
-                            // 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.
                             this.tileRetryState.delete(tile);
                         })
                             .catch(onFailure);
@@ -2742,9 +2068,7 @@ export class InternalMapVXMap extends Loggeable {
         }, 1000);
         this.map.on("sourcedata", this.boundOnSourceData);
         this.map.on("sourcedataabort", this.boundOnSourceDataAbort);
-        // Escucha el evento de contexto perdido
         this.map.on("webglcontextlost", this.boundOnWebGLContextLost);
-        // Adicional: escucha evento restauración
         this.map.on("webglcontextrestored", this.boundOnWebGLContextRestored);
     }
     unsubscribeFromFailedTiles() {
@@ -2771,4 +2095,3 @@ export class InternalMapVXMap extends Loggeable {
         this.failedTiles.clear();
     }
 }
-//# sourceMappingURL=map.js.map