@mapvx/web-js 3.4.0-dev.1 → 3.4.0

package/dist/umd/index.js

@@ -43,6 +43,14 @@ module.exports = require("three");
 
 /***/ },
 
+/***/ 502
+(module) {
+
+"use strict";
+module.exports = require("three/addons/libs/meshopt_decoder.module.js");
+
+/***/ },
+
 /***/ 303
 (module) {
 
@@ -11240,7 +11248,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.4.0-dev.1";
+var sentry_SDK_VERSION =  false ? 0 : "3.4.0";
 var DSN =  false ? 0 : "https://872f598f020e3cd73a0933b562d24c81@sentry.mapvx.app/5";
 
 /**
@@ -18654,6 +18662,89 @@ function _3d_unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof
 function _3d_iterableToArray(r) { if ("undefined" != typeof Symbol && null != r[Symbol.iterator] || null != r["@@iterator"]) return Array.from(r); }
 function _3d_arrayWithoutHoles(r) { if (Array.isArray(r)) return _3d_arrayLikeToArray(r); }
 function _3d_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; }
+/** Default LOD hysteresis (zoom units) when {@link Models3DLodConfig.hysteresis} is unset. */
+var DEFAULT_LOD_HYSTERESIS = 0.5;
+
+/**
+ * Resolved LOD zoom boundaries: models unload strictly below `unloadBelow` and (re)load at or
+ * above `reloadAtOrAbove`. The gap between them is the hysteresis dead-band.
+ * @internal
+ */
+
+/**
+ * Computes the unload/reload zoom boundaries from {@link Models3DConfig.lod}, or `null` when LOD is
+ * disabled (no `lod`, no models, or a non-finite `minZoom`). Pure — safe to unit-test without WebGL.
+ */
+var resolveModels3DLodThresholds = function resolveModels3DLodThresholds(models) {
+  var lod = models === null || models === void 0 ? void 0 : models.lod;
+  if (!models || models.enabled === false || !lod || typeof lod.minZoom !== "number" || !Number.isFinite(lod.minZoom)) {
+    return null;
+  }
+  var hysteresis = typeof lod.hysteresis === "number" && Number.isFinite(lod.hysteresis) && lod.hysteresis >= 0 ? lod.hysteresis : DEFAULT_LOD_HYSTERESIS;
+  return {
+    reloadAtOrAbove: lod.minZoom,
+    unloadBelow: lod.minZoom - hysteresis
+  };
+};
+
+/**
+ * Decides what the LOD controller should do at the current zoom given whether the models are
+ * currently unloaded. Returns `"unload"` when they are loaded but the camera is below the unload
+ * boundary, `"reload"` when they are unloaded but the camera has returned to/above the reload
+ * boundary, and `"none"` otherwise (including within the hysteresis band). Pure/testable.
+ */
+var lodActionForZoom = function lodActionForZoom(zoom, thresholds, currentlyUnloaded) {
+  if (!currentlyUnloaded && zoom < thresholds.unloadBelow) {
+    return "unload";
+  }
+  if (currentlyUnloaded && zoom >= thresholds.reloadAtOrAbove) {
+    return "reload";
+  }
+  return "none";
+};
+
+/**
+ * Resolved deck.gl tile-cache props: every field concrete, ready to spread onto an `MVTLayer`.
+ * @internal
+ */
+
+/**
+ * Conservative defaults that bound each deck.gl overlay layer's in-memory tile cache. Chosen to
+ * favor low RAM: only the visible working set (plus a small margin) stays parsed in memory; the
+ * raw tile bytes remain on disk in the Service Worker cache, so an evicted tile is re-parsed
+ * rather than re-downloaded. Raise `maxCacheSize` only if profiling shows flashing at the
+ * viewport edge while panning.
+ * @internal
+ */
+var DEFAULT_DECK_TILE_CACHE = {
+  // Per layer; with four overlay layers this caps the parsed-tile set at ~4x this number.
+  maxCacheSize: 64,
+  maxRequests: 6,
+  // Drop parent tiles once children cover the viewport — keeps the resident set smallest.
+  refinementStrategy: "no-overlap",
+  // Byte budget is opt-in (deck.gl only enforces it when a tile's byte size is known).
+  maxCacheByteSize: undefined
+};
+
+/**
+ * Merges an optional {@link DeckTileCacheConfig} over {@link DEFAULT_DECK_TILE_CACHE}, ignoring
+ * `undefined`/`null` fields and clamping numeric bounds to at least 1. The result is always
+ * bounded — passing `undefined` yields the defaults, never an unlimited cache.
+ */
+var resolveDeckTileCache = function resolveDeckTileCache(config) {
+  var _config$refinementStr;
+  var clampPositive = function clampPositive(value, fallback) {
+    return typeof value === "number" && Number.isFinite(value) && value >= 1 ? Math.floor(value) : fallback;
+  };
+  var maxCacheByteSize = typeof (config === null || config === void 0 ? void 0 : config.maxCacheByteSize) === "number" && Number.isFinite(config.maxCacheByteSize) && config.maxCacheByteSize >= 1 ? Math.floor(config.maxCacheByteSize) : DEFAULT_DECK_TILE_CACHE.maxCacheByteSize;
+  return {
+    maxCacheSize: clampPositive(config === null || config === void 0 ? void 0 : config.maxCacheSize, DEFAULT_DECK_TILE_CACHE.maxCacheSize),
+    maxRequests: clampPositive(config === null || config === void 0 ? void 0 : config.maxRequests, DEFAULT_DECK_TILE_CACHE.maxRequests),
+    refinementStrategy: (_config$refinementStr = config === null || config === void 0 ? void 0 : config.refinementStrategy) !== null && _config$refinementStr !== void 0 ? _config$refinementStr : DEFAULT_DECK_TILE_CACHE.refinementStrategy,
+    maxCacheByteSize: maxCacheByteSize
+  };
+};
+
 /**
  * Default lights matching the legacy escalator scene when {@link Models3DConfig.lights} is unset.
  * @internal
@@ -19063,17 +19154,19 @@ var deckPromise;
  * Subsequent calls return the same promise, so a single Three.js instance is shared.
  */
 function loadThree() {
-  threePromise !== null && threePromise !== void 0 ? threePromise : threePromise = Promise.all([Promise.resolve(/* import() */).then(__webpack_require__.t.bind(__webpack_require__, 912, 23)), Promise.resolve(/* import() */).then(__webpack_require__.t.bind(__webpack_require__, 833, 23)), Promise.resolve(/* import() */).then(__webpack_require__.t.bind(__webpack_require__, 303, 23)), Promise.resolve(/* import() */).then(__webpack_require__.t.bind(__webpack_require__, 373, 23))]).then(function (_ref) {
-    var _ref2 = three_slicedToArray(_ref, 4),
+  threePromise !== null && threePromise !== void 0 ? threePromise : threePromise = Promise.all([Promise.resolve(/* import() */).then(__webpack_require__.t.bind(__webpack_require__, 912, 23)), Promise.resolve(/* import() */).then(__webpack_require__.t.bind(__webpack_require__, 833, 23)), Promise.resolve(/* import() */).then(__webpack_require__.t.bind(__webpack_require__, 303, 23)), Promise.resolve(/* import() */).then(__webpack_require__.t.bind(__webpack_require__, 373, 23)), Promise.resolve(/* import() */).then(__webpack_require__.t.bind(__webpack_require__, 502, 23))]).then(function (_ref) {
+    var _ref2 = three_slicedToArray(_ref, 5),
       three = _ref2[0],
       gltf = _ref2[1],
       draco = _ref2[2],
-      ktx2 = _ref2[3];
+      ktx2 = _ref2[3],
+      meshopt = _ref2[4];
     return {
       THREE: three,
       GLTFLoader: gltf.GLTFLoader,
       DRACOLoader: draco.DRACOLoader,
-      KTX2Loader: ktx2.KTX2Loader
+      KTX2Loader: ktx2.KTX2Loader,
+      MeshoptDecoder: meshopt.MeshoptDecoder
     };
   });
   return threePromise;
@@ -19131,6 +19224,12 @@ function getGltfLoader() {
     ktx2Loader.detectSupport(new mod.THREE.WebGLRenderer({
       antialias: true
     }));
+
+    // Enable EXT_meshopt_compression so meshopt-compressed GLBs decode. The decoder is a WASM
+    // singleton; GLTFLoader awaits its `.ready` promise internally before parsing. Assets that
+    // don't use the extension are unaffected. This lets the offline pipeline pick meshopt (often
+    // smaller than Draco for the scene's meshes) without a runtime change.
+    gltfLoader.setMeshoptDecoder(mod.MeshoptDecoder);
     return gltfLoader;
   });
   return gltfLoaderPromise;
@@ -19488,6 +19587,7 @@ function scene3DController_toPrimitive(t, r) { if ("object" != scene3DController
  */
 var Scene3DController = /*#__PURE__*/function () {
   function Scene3DController(map, scene3DConfig, initialCenter, onModelsProgress) {
+    var _scene3DConfig$custom;
     scene3DController_classCallCheck(this, Scene3DController);
     /** Latest known floor key; updated by the floor-change hooks and read when (re)building layers. */
     scene3DController_defineProperty(this, "currentFloor", "");
@@ -19515,10 +19615,21 @@ var Scene3DController = /*#__PURE__*/function () {
     scene3DController_defineProperty(this, "scene3DRouteCollisionPoints", []);
     scene3DController_defineProperty(this, "spriteIconMapping", {});
     scene3DController_defineProperty(this, "spriteAtlasImage", new Image());
+    /** True while the GLB models are unloaded by LOD (camera zoomed out past the threshold). */
+    scene3DController_defineProperty(this, "modelsUnloadedByLod", false);
+    /**
+     * True while {@link loadScene3DGlbTemplates} is populating `scene3DGlbRootByUrl` /
+     * `scene3DGlbTemplateById` (initial load or an LOD reload). Guards against overlapping reloads
+     * and, in {@link updateLodForZoom}, against an LOD unload running concurrently and clearing
+     * those same maps out from under the in-flight load.
+     */
+    scene3DController_defineProperty(this, "glbTemplatesLoadInFlight", false);
     this.map = map;
     this.scene3DConfig = scene3DConfig;
     this.initialCenter = initialCenter;
     this.onModelsProgress = onModelsProgress;
+    this.deckTileCache = resolveDeckTileCache((_scene3DConfig$custom = scene3DConfig.customLayers) === null || _scene3DConfig$custom === void 0 ? void 0 : _scene3DConfig$custom.tileCache);
+    this.lodThresholds = resolveModels3DLodThresholds(scene3DConfig.models);
   }
 
   // Lifecycle entry points forwarded by the map ---------------------------------------------
@@ -19572,6 +19683,7 @@ var Scene3DController = /*#__PURE__*/function () {
               this.map.addControl(this.deckOverlay);
               // Hide MapLibre icon layers — replaced by deck.gl IconLayer
               this.hideLayers(this.scene3DConfig.hideLayers);
+              this.installDebugStatsHook();
               models = this.scene3DConfig.models;
               glbModelsActive = models !== undefined && models.enabled !== false && models.assets.length > 0;
               if (glbModelsActive) {
@@ -19592,19 +19704,136 @@ var Scene3DController = /*#__PURE__*/function () {
         return _onMapLoad.apply(this, arguments);
       }
       return onMapLoad;
-    }() /** Re-applies zoom-based model transparency; call on every map `zoom`. */
+    }() /** Re-applies zoom-based model transparency and evaluates LOD; call on every map `zoom`. */
   }, {
     key: "onZoom",
     value: function onZoom() {
       this.applyModelOpacity();
+      this.updateLodForZoom();
+    }
+
+    /**
+     * Evaluates the zoom-based LOD (see {@link Models3DConfig.lod}): unloads the GLB models from
+     * memory when the camera drops below the unload boundary and reloads them when it returns to the
+     * reload boundary. No-op when LOD is disabled. Cheap enough to call on every `zoom` event — it
+     * only acts on a boundary crossing.
+     */
+  }, {
+    key: "updateLodForZoom",
+    value: function updateLodForZoom() {
+      if (!this.lodThresholds) {
+        return;
+      }
+      var action = lodActionForZoom(this.map.getZoom(), this.lodThresholds, this.modelsUnloadedByLod);
+      if (action === "unload") {
+        if (this.glbTemplatesLoadInFlight) {
+          // A load is already populating the model maps; unloading now would race with it.
+          // reloadScene3DModelsForLod()/the initial load re-evaluate the zoom once they settle.
+          return;
+        }
+        this.unloadScene3DModelsForLod();
+      } else if (action === "reload") {
+        void this.reloadScene3DModelsForLod();
+      }
     }
 
+    /**
+     * Frees the GLB models' GPU resources (placed group's material clones + every cached template's
+     * geometry/textures) while keeping the custom layer, its `WebGLRenderer`, scene and lights alive,
+     * so a later {@link reloadScene3DModelsForLod} can repopulate without recreating the map layer.
+     * Distinct from {@link dispose}, which tears the whole controller down.
+     */
+  }, {
+    key: "unloadScene3DModelsForLod",
+    value: function unloadScene3DModelsForLod() {
+      var _this$threeMod;
+      var three = (_this$threeMod = this.threeMod) === null || _this$threeMod === void 0 ? void 0 : _this$threeMod.THREE;
+      if (!three) {
+        return;
+      }
+      if (this.scene3DModelsGroup) {
+        var _this$scene3DGlbScene;
+        disposeMaterialsOnly(three, this.scene3DModelsGroup);
+        (_this$scene3DGlbScene = this.scene3DGlbScene) === null || _this$scene3DGlbScene === void 0 || _this$scene3DGlbScene.remove(this.scene3DModelsGroup);
+        this.scene3DModelsGroup = undefined;
+      }
+      // Iterate the deduped-by-URL roots so a shared root is never disposed twice (mirrors dispose()).
+      var _iterator = scene3DController_createForOfIteratorHelper(this.scene3DGlbRootByUrl.values()),
+        _step;
+      try {
+        for (_iterator.s(); !(_step = _iterator.n()).done;) {
+          var root = _step.value;
+          disposeObject3D(three, root);
+        }
+      } catch (err) {
+        _iterator.e(err);
+      } finally {
+        _iterator.f();
+      }
+      this.scene3DGlbRootByUrl.clear();
+      this.scene3DGlbTemplateById.clear();
+      this.modelsUnloadedByLod = true;
+      this.map.triggerRepaint();
+    }
+
+    /**
+     * Reloads the GLB templates from disk/network and re-places them for the current floor after an
+     * LOD unload. Guards against overlapping reloads, and re-evaluates the zoom on completion so a
+     * camera that zoomed back out mid-download ends up unloaded again rather than stuck loaded.
+     */
+  }, {
+    key: "reloadScene3DModelsForLod",
+    value: (function () {
+      var _reloadScene3DModelsForLod = scene3DController_asyncToGenerator(/*#__PURE__*/scene3DController_regenerator().m(function _callee2() {
+        var _t2;
+        return scene3DController_regenerator().w(function (_context2) {
+          while (1) switch (_context2.p = _context2.n) {
+            case 0:
+              if (!this.glbTemplatesLoadInFlight) {
+                _context2.n = 1;
+                break;
+              }
+              return _context2.a(2);
+            case 1:
+              this.glbTemplatesLoadInFlight = true;
+              _context2.p = 2;
+              _context2.n = 3;
+              return this.loadScene3DGlbTemplates();
+            case 3:
+              this.placeScene3DModels();
+              // Only mark as loaded once placement actually succeeded, so a failed reload leaves
+              // modelsUnloadedByLod = true and the trailing updateLodForZoom() below retries it.
+              this.modelsUnloadedByLod = false;
+              _context2.n = 5;
+              break;
+            case 4:
+              _context2.p = 4;
+              _t2 = _context2.v;
+              console.error("Failed to reload declarative GLB models after LOD unload", _t2);
+            case 5:
+              _context2.p = 5;
+              this.glbTemplatesLoadInFlight = false;
+              return _context2.f(5);
+            case 6:
+              // The camera may have moved during the async load; re-evaluate so a zoom back out unloads again.
+              this.updateLodForZoom();
+            case 7:
+              return _context2.a(2);
+          }
+        }, _callee2, this, [[2, 4, 5, 6]]);
+      }));
+      function reloadScene3DModelsForLod() {
+        return _reloadScene3DModelsForLod.apply(this, arguments);
+      }
+      return reloadScene3DModelsForLod;
+    }()
     /**
      * Sets the route path used for GLB route-transparency collision and re-evaluates which models a
      * route currently crosses. Points are tagged with the floor on which their route segment is
      * visible; only points on the current floor participate, so a model never fades unless a route is
      * visibly crossing it on the displayed floor. Pass an empty array to clear.
      */
+    )
   }, {
     key: "setRouteCollisionPath",
     value: function setRouteCollisionPath(points) {
@@ -19639,6 +19868,93 @@ var Scene3DController = /*#__PURE__*/function () {
       this.updateDeckOverlay();
     }
 
+    /**
+     * A point-in-time snapshot of the 3D scene's memory drivers, for profiling. The Three.js
+     * `renderer.info` counters are the best in-page proxy for GLB VRAM (decoded geometries/textures
+     * live on the GPU and are not visible to `performance.memory`, which only reports the JS heap).
+     * The deck tile counts approximate the overlay's parsed-tile working set — the thing the tile-cache
+     * bounds (see {@link DeckTileCacheConfig}) keep from growing without limit as the map pans/zooms.
+     *
+     * @group Map
+     */
+  }, {
+    key: "getDebugStats",
+    value: function getDebugStats() {
+      var _this$glbRenderer, _info$programs$length, _info$programs, _this$scene3DModelsGr, _this$scene3DModelsGr2;
+      var info = (_this$glbRenderer = this.glbRenderer) === null || _this$glbRenderer === void 0 ? void 0 : _this$glbRenderer.info;
+      var three = info ? {
+        geometries: info.memory.geometries,
+        textures: info.memory.textures,
+        programs: (_info$programs$length = (_info$programs = info.programs) === null || _info$programs === void 0 ? void 0 : _info$programs.length) !== null && _info$programs$length !== void 0 ? _info$programs$length : 0,
+        renderCalls: info.render.calls,
+        triangles: info.render.triangles
+      } : null;
+      var deckTiles = null;
+      try {
+        var _overlay$_deck;
+        // Best-effort read of each overlay layer's parsed-tile count. deck.gl internals are private,
+        // so this is guarded — it degrades to `null` rather than throwing if the shape changes.
+        var overlay = this.deckOverlay;
+        var layers = overlay === null || overlay === void 0 || (_overlay$_deck = overlay._deck) === null || _overlay$_deck === void 0 || (_overlay$_deck = _overlay$_deck.layerManager) === null || _overlay$_deck === void 0 ? void 0 : _overlay$_deck.layers;
+        if (Array.isArray(layers)) {
+          var counts = {};
+          for (var _i = 0, _arr = layers; _i < _arr.length; _i++) {
+            var _layer$state;
+            var layer = _arr[_i];
+            var size = layer === null || layer === void 0 || (_layer$state = layer.state) === null || _layer$state === void 0 || (_layer$state = _layer$state.tileset) === null || _layer$state === void 0 || (_layer$state = _layer$state._cache) === null || _layer$state === void 0 ? void 0 : _layer$state.size;
+            if (typeof size === "number" && layer.id) {
+              var _counts$baseId;
+              // Strip deck's per-sublayer suffixes so the four MVT roots aggregate by base id.
+              var baseId = layer.id.split("-sublayer")[0];
+              counts[baseId] = Math.max((_counts$baseId = counts[baseId]) !== null && _counts$baseId !== void 0 ? _counts$baseId : 0, size);
+            }
+          }
+          deckTiles = counts;
+        }
+      } catch (_unused) {
+        deckTiles = null;
+      }
+      return {
+        zoom: this.map.getZoom(),
+        currentFloor: this.currentFloor,
+        modelsUnloadedByLod: this.modelsUnloadedByLod,
+        glbRoots: this.scene3DGlbRootByUrl.size,
+        glbTemplates: this.scene3DGlbTemplateById.size,
+        placedModels: (_this$scene3DModelsGr = (_this$scene3DModelsGr2 = this.scene3DModelsGroup) === null || _this$scene3DModelsGr2 === void 0 ? void 0 : _this$scene3DModelsGr2.children.length) !== null && _this$scene3DModelsGr !== void 0 ? _this$scene3DModelsGr : 0,
+        three: three,
+        deckTiles: deckTiles,
+        deckTileCache: this.deckTileCache,
+        lodThresholds: this.lodThresholds
+      };
+    }
+
+    /**
+     * Exposes {@link getDebugStats} as `globalThis.__mvxScene3DStats()` when the opt-in flag
+     * `globalThis.__MVX_SCENE3D_DEBUG__` is truthy, so a profiling session can read the scene's memory
+     * drivers from the console/tests without external tooling. No-op (and no global written) otherwise.
+     */
+  }, {
+    key: "installDebugStatsHook",
+    value: function installDebugStatsHook() {
+      var _this = this;
+      var g = globalThis;
+      if (g.__MVX_SCENE3D_DEBUG__) {
+        g.__mvxScene3DStats = function () {
+          return _this.getDebugStats();
+        };
+      }
+    }
+
+    /** Removes the debug hook if it points at this controller. Called from {@link dispose}. */
+  }, {
+    key: "uninstallDebugStatsHook",
+    value: function uninstallDebugStatsHook() {
+      var g = globalThis;
+      if (g.__mvxScene3DStats) {
+        delete g.__mvxScene3DStats;
+      }
+    }
+
     /**
      * Releases every GPU resource this controller owns: the placed models group's material clones,
      * the cached GLB templates' geometries/materials/textures, and the `WebGLRenderer` created for the
@@ -19652,8 +19968,8 @@ var Scene3DController = /*#__PURE__*/function () {
   }, {
     key: "dispose",
     value: function dispose() {
-      var _this$threeMod, _this$glbRenderer;
-      var three = (_this$threeMod = this.threeMod) === null || _this$threeMod === void 0 ? void 0 : _this$threeMod.THREE;
+      var _this$threeMod2, _this$glbRenderer2;
+      var three = (_this$threeMod2 = this.threeMod) === null || _this$threeMod2 === void 0 ? void 0 : _this$threeMod2.THREE;
       if (three) {
         if (this.scene3DModelsGroup) {
           disposeMaterialsOnly(three, this.scene3DModelsGroup);
@@ -19661,24 +19977,25 @@ var Scene3DController = /*#__PURE__*/function () {
         }
         // Iterate the deduplicated-by-URL roots (not `scene3DGlbTemplateById`, which may map several
         // asset ids to the same root) so a shared root is never disposed more than once.
-        var _iterator = scene3DController_createForOfIteratorHelper(this.scene3DGlbRootByUrl.values()),
-          _step;
+        var _iterator2 = scene3DController_createForOfIteratorHelper(this.scene3DGlbRootByUrl.values()),
+          _step2;
         try {
-          for (_iterator.s(); !(_step = _iterator.n()).done;) {
-            var root = _step.value;
+          for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+            var root = _step2.value;
             disposeObject3D(three, root);
           }
         } catch (err) {
-          _iterator.e(err);
+          _iterator2.e(err);
         } finally {
-          _iterator.f();
+          _iterator2.f();
         }
       }
       this.scene3DGlbRootByUrl.clear();
       this.scene3DGlbTemplateById.clear();
       this.scene3DGlbScene = undefined;
-      (_this$glbRenderer = this.glbRenderer) === null || _this$glbRenderer === void 0 || _this$glbRenderer.dispose();
+      (_this$glbRenderer2 = this.glbRenderer) === null || _this$glbRenderer2 === void 0 || _this$glbRenderer2.dispose();
       this.glbRenderer = undefined;
+      this.uninstallDebugStatsHook();
     }
 
     // Internal implementation -----------------------------------------------------------------
@@ -19690,40 +20007,40 @@ var Scene3DController = /*#__PURE__*/function () {
   }, {
     key: "ensure3DLibs",
     value: function () {
-      var _ensure3DLibs = scene3DController_asyncToGenerator(/*#__PURE__*/scene3DController_regenerator().m(function _callee2() {
-        var _this$threeMod2, _this$deckMod;
-        return scene3DController_regenerator().w(function (_context2) {
-          while (1) switch (_context2.n) {
+      var _ensure3DLibs = scene3DController_asyncToGenerator(/*#__PURE__*/scene3DController_regenerator().m(function _callee3() {
+        var _this$threeMod3, _this$deckMod;
+        return scene3DController_regenerator().w(function (_context3) {
+          while (1) switch (_context3.n) {
             case 0:
-              if (!((_this$threeMod2 = this.threeMod) !== null && _this$threeMod2 !== void 0)) {
-                _context2.n = 1;
+              if (!((_this$threeMod3 = this.threeMod) !== null && _this$threeMod3 !== void 0)) {
+                _context3.n = 1;
                 break;
               }
-              _this$threeMod2;
-              _context2.n = 3;
+              _this$threeMod3;
+              _context3.n = 3;
               break;
             case 1:
-              _context2.n = 2;
+              _context3.n = 2;
               return loadThree();
             case 2:
-              this.threeMod = _context2.v;
+              this.threeMod = _context3.v;
             case 3:
               if (!((_this$deckMod = this.deckMod) !== null && _this$deckMod !== void 0)) {
-                _context2.n = 4;
+                _context3.n = 4;
                 break;
               }
               _this$deckMod;
-              _context2.n = 6;
+              _context3.n = 6;
               break;
             case 4:
-              _context2.n = 5;
+              _context3.n = 5;
               return loadDeck();
             case 5:
-              this.deckMod = _context2.v;
+              this.deckMod = _context3.v;
             case 6:
-              return _context2.a(2);
+              return _context3.a(2);
           }
-        }, _callee2, this);
+        }, _callee3, this);
       }));
       function ensure3DLibs() {
         return _ensure3DLibs.apply(this, arguments);
@@ -19733,7 +20050,7 @@ var Scene3DController = /*#__PURE__*/function () {
   }, {
     key: "createGlbCustomLayer",
     value: function createGlbCustomLayer() {
-      var _this = this;
+      var _this2 = this;
       var three = this.threeMod.THREE;
       var refMercator = maplibre_gl.MercatorCoordinate.fromLngLat(this.initialCenter, 0);
       var meterScale = refMercator.meterInMercatorCoordinateUnits();
@@ -19746,10 +20063,16 @@ var Scene3DController = /*#__PURE__*/function () {
       } else {
         this.scene3DGlbLightCount = 0;
       }
+      this.glbTemplatesLoadInFlight = true;
       void this.loadScene3DGlbTemplates().then(function () {
-        return _this.placeScene3DModels();
+        _this2.placeScene3DModels();
       })["catch"](function (err) {
         console.error("Failed to initialize declarative GLB models", err);
+      })["finally"](function () {
+        _this2.glbTemplatesLoadInFlight = false;
+        // Honor LOD from the first frame: if the map opened below the unload threshold, free the
+        // models just loaded (they reload when the user zooms in). No-op when LOD is disabled.
+        _this2.updateLodForZoom();
       });
       var renderer = undefined;
       var camera = undefined;
@@ -19773,17 +20096,17 @@ var Scene3DController = /*#__PURE__*/function () {
           // Stored on the controller (not just this closure) so `dispose()` can release it — MapLibre
           // does not call a custom layer's `onRemove` when the whole map/style is torn down via
           // `map.remove()`, so callers must dispose this controller explicitly before that happens.
-          _this.glbRenderer = renderer;
+          _this2.glbRenderer = renderer;
         },
         onRemove: function onRemove() {
-          _this.dispose();
+          _this2.dispose();
         },
         render: function render(_gl, args) {
           var _args$defaultProjecti;
-          if (!camera || !renderer || !_this.scene3DGlbScene || !_this.scene3DModelsGroup || _this.scene3DModelsGroup.children.length === 0) {
+          if (!camera || !renderer || !_this2.scene3DGlbScene || !_this2.scene3DModelsGroup || _this2.scene3DModelsGroup.children.length === 0) {
             return;
           }
-          var canvas = _this.map.getCanvas();
+          var canvas = _this2.map.getCanvas();
           var width = canvas.width;
           var height = canvas.height;
           // Skip while the framebuffer has no drawable area (e.g. devtools opening).
@@ -19798,27 +20121,27 @@ var Scene3DController = /*#__PURE__*/function () {
           tmpMatrix.fromArray(mainMatrix).multiply(modelTransform);
           camera.projectionMatrix.copy(tmpMatrix);
           renderer.resetState();
-          renderer.render(_this.scene3DGlbScene, camera);
+          renderer.render(_this2.scene3DGlbScene, camera);
         }
       };
     }
   }, {
     key: "loadScene3DGlbTemplates",
     value: function () {
-      var _loadScene3DGlbTemplates = scene3DController_asyncToGenerator(/*#__PURE__*/scene3DController_regenerator().m(function _callee4() {
-        var _this$threeMod3,
-          _this2 = this;
-        var three, models, uniqueUrls, errorByUrl, semaphore, loadedBytesByUrl, totalBytesByUrl, settledAssets, totalAssets, reportProgress, _iterator3, _step3, asset, root, center, _t5;
-        return scene3DController_regenerator().w(function (_context4) {
-          while (1) switch (_context4.p = _context4.n) {
+      var _loadScene3DGlbTemplates = scene3DController_asyncToGenerator(/*#__PURE__*/scene3DController_regenerator().m(function _callee5() {
+        var _this$threeMod4,
+          _this3 = this;
+        var three, models, uniqueUrls, errorByUrl, semaphore, loadedBytesByUrl, totalBytesByUrl, settledAssets, totalAssets, reportProgress, _iterator4, _step4, asset, root, center, _t6;
+        return scene3DController_regenerator().w(function (_context5) {
+          while (1) switch (_context5.p = _context5.n) {
             case 0:
-              three = (_this$threeMod3 = this.threeMod) === null || _this$threeMod3 === void 0 ? void 0 : _this$threeMod3.THREE;
+              three = (_this$threeMod4 = this.threeMod) === null || _this$threeMod4 === void 0 ? void 0 : _this$threeMod4.THREE;
               models = this.scene3DConfig.models;
               if (!(!three || !models || models.enabled === false || models.assets.length === 0)) {
-                _context4.n = 1;
+                _context5.n = 1;
                 break;
               }
-              return _context4.a(2);
+              return _context5.a(2);
             case 1:
               this.scene3DGlbRootByUrl.clear();
               this.scene3DGlbTemplateById.clear();
@@ -19839,26 +20162,26 @@ var Scene3DController = /*#__PURE__*/function () {
               settledAssets = 0;
               totalAssets = uniqueUrls.length;
               reportProgress = function reportProgress(done) {
-                if (!_this2.onModelsProgress) return;
+                if (!_this3.onModelsProgress) return;
                 var loadedBytes = 0;
                 var totalBytes = 0;
-                var _iterator2 = scene3DController_createForOfIteratorHelper(uniqueUrls),
-                  _step2;
+                var _iterator3 = scene3DController_createForOfIteratorHelper(uniqueUrls),
+                  _step3;
                 try {
-                  for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+                  for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
                     var _loadedBytesByUrl$get;
-                    var url = _step2.value;
+                    var url = _step3.value;
                     loadedBytes += (_loadedBytesByUrl$get = loadedBytesByUrl.get(url)) !== null && _loadedBytesByUrl$get !== void 0 ? _loadedBytesByUrl$get : 0;
                     var total = totalBytesByUrl.get(url);
                     totalBytes = total == null || totalBytes === null ? null : totalBytes + total;
                   }
                 } catch (err) {
-                  _iterator2.e(err);
+                  _iterator3.e(err);
                 } finally {
-                  _iterator2.f();
+                  _iterator3.f();
                 }
                 try {
-                  _this2.onModelsProgress({
+                  _this3.onModelsProgress({
                     loadedAssets: settledAssets,
                     totalAssets: totalAssets,
                     loadedBytes: loadedBytes,
@@ -19872,20 +20195,20 @@ var Scene3DController = /*#__PURE__*/function () {
                   console.error("onScene3DModelsProgress callback threw", err);
                 }
               };
-              _context4.n = 2;
+              _context5.n = 2;
               return Promise.all(uniqueUrls.map(/*#__PURE__*/function () {
-                var _ref = scene3DController_asyncToGenerator(/*#__PURE__*/scene3DController_regenerator().m(function _callee3(url) {
-                  var _ref2, _totalBytesByUrl$get, _t2, _t3, _t4;
-                  return scene3DController_regenerator().w(function (_context3) {
-                    while (1) switch (_context3.p = _context3.n) {
+                var _ref = scene3DController_asyncToGenerator(/*#__PURE__*/scene3DController_regenerator().m(function _callee4(url) {
+                  var _ref2, _totalBytesByUrl$get, _t3, _t4, _t5;
+                  return scene3DController_regenerator().w(function (_context4) {
+                    while (1) switch (_context4.p = _context4.n) {
                       case 0:
-                        _context3.n = 1;
+                        _context4.n = 1;
                         return semaphore.acquire();
                       case 1:
-                        _context3.p = 1;
-                        _t2 = _this2.scene3DGlbRootByUrl;
-                        _t3 = url;
-                        _context3.n = 2;
+                        _context4.p = 1;
+                        _t3 = _this3.scene3DGlbRootByUrl;
+                        _t4 = url;
+                        _context4.n = 2;
                         return loadGlbRoot(url, {
                           onProgress: function onProgress(event) {
                             loadedBytesByUrl.set(url, event.loaded);
@@ -19894,15 +20217,15 @@ var Scene3DController = /*#__PURE__*/function () {
                           }
                         });
                       case 2:
-                        _t2.set.call(_t2, _t3, _context3.v);
-                        _context3.n = 4;
+                        _t3.set.call(_t3, _t4, _context4.v);
+                        _context4.n = 4;
                         break;
                       case 3:
-                        _context3.p = 3;
-                        _t4 = _context3.v;
-                        errorByUrl.set(url, _t4);
+                        _context4.p = 3;
+                        _t5 = _context4.v;
+                        errorByUrl.set(url, _t5);
                       case 4:
-                        _context3.p = 4;
+                        _context4.p = 4;
                         settledAssets++;
                         // Once a URL has settled, its total is knowable even if no progress event ever supplied
                         // one (failed before the first byte, or the server omitted Content-Length): fall back to
@@ -19911,11 +20234,11 @@ var Scene3DController = /*#__PURE__*/function () {
                         totalBytesByUrl.set(url, (_ref2 = (_totalBytesByUrl$get = totalBytesByUrl.get(url)) !== null && _totalBytesByUrl$get !== void 0 ? _totalBytesByUrl$get : loadedBytesByUrl.get(url)) !== null && _ref2 !== void 0 ? _ref2 : 0);
                         semaphore.release();
                         reportProgress(false);
-                        return _context3.f(4);
+                        return _context4.f(4);
                       case 5:
-                        return _context3.a(2);
+                        return _context4.a(2);
                     }
-                  }, _callee3, null, [[1, 3, 4, 5]]);
+                  }, _callee4, null, [[1, 3, 4, 5]]);
                 }));
                 return function (_x) {
                   return _ref.apply(this, arguments);
@@ -19923,22 +20246,22 @@ var Scene3DController = /*#__PURE__*/function () {
               }()));
             case 2:
               reportProgress(true);
-              _iterator3 = scene3DController_createForOfIteratorHelper(models.assets);
-              _context4.p = 3;
-              _iterator3.s();
+              _iterator4 = scene3DController_createForOfIteratorHelper(models.assets);
+              _context5.p = 3;
+              _iterator4.s();
             case 4:
-              if ((_step3 = _iterator3.n()).done) {
-                _context4.n = 7;
+              if ((_step4 = _iterator4.n()).done) {
+                _context5.n = 7;
                 break;
               }
-              asset = _step3.value;
+              asset = _step4.value;
               root = this.scene3DGlbRootByUrl.get(asset.url);
               if (root) {
-                _context4.n = 5;
+                _context5.n = 5;
                 break;
               }
               console.error("Failed to load GLB asset \"".concat(asset.id, "\" from ").concat(asset.url), errorByUrl.get(asset.url));
-              return _context4.a(3, 6);
+              return _context5.a(3, 6);
             case 5:
               center = computeGlbBottomAnchor(three, root);
               this.scene3DGlbTemplateById.set(asset.id, {
@@ -19946,23 +20269,23 @@ var Scene3DController = /*#__PURE__*/function () {
                 center: center
               });
             case 6:
-              _context4.n = 4;
+              _context5.n = 4;
               break;
             case 7:
-              _context4.n = 9;
+              _context5.n = 9;
               break;
             case 8:
-              _context4.p = 8;
-              _t5 = _context4.v;
-              _iterator3.e(_t5);
+              _context5.p = 8;
+              _t6 = _context5.v;
+              _iterator4.e(_t6);
             case 9:
-              _context4.p = 9;
-              _iterator3.f();
-              return _context4.f(9);
+              _context5.p = 9;
+              _iterator4.f();
+              return _context5.f(9);
             case 10:
-              return _context4.a(2);
+              return _context5.a(2);
           }
-        }, _callee4, this, [[3, 8, 9, 10]]);
+        }, _callee5, this, [[3, 8, 9, 10]]);
       }));
       function loadScene3DGlbTemplates() {
         return _loadScene3DGlbTemplates.apply(this, arguments);
@@ -19972,15 +20295,15 @@ var Scene3DController = /*#__PURE__*/function () {
   }, {
     key: "placeScene3DModels",
     value: function placeScene3DModels() {
-      var _this$threeMod4,
+      var _this$threeMod5,
         _models$globalOffset$,
         _models$globalOffset,
         _models$globalOffset$2,
         _models$globalOffset2,
         _models$globalOffset$3,
         _models$globalOffset3,
-        _this3 = this;
-      var three = (_this$threeMod4 = this.threeMod) === null || _this$threeMod4 === void 0 ? void 0 : _this$threeMod4.THREE;
+        _this4 = this;
+      var three = (_this$threeMod5 = this.threeMod) === null || _this$threeMod5 === void 0 ? void 0 : _this$threeMod5.THREE;
       if (!three || !this.scene3DGlbScene) {
         return;
       }
@@ -20004,16 +20327,16 @@ var Scene3DController = /*#__PURE__*/function () {
       var floorKey = this.currentFloor;
       var modelsGroup = new three.Group();
       modelsGroup.position.set((_models$globalOffset$ = (_models$globalOffset = models.globalOffset) === null || _models$globalOffset === void 0 ? void 0 : _models$globalOffset.x) !== null && _models$globalOffset$ !== void 0 ? _models$globalOffset$ : 0, (_models$globalOffset$2 = (_models$globalOffset2 = models.globalOffset) === null || _models$globalOffset2 === void 0 ? void 0 : _models$globalOffset2.y) !== null && _models$globalOffset$2 !== void 0 ? _models$globalOffset$2 : 0, (_models$globalOffset$3 = (_models$globalOffset3 = models.globalOffset) === null || _models$globalOffset3 === void 0 ? void 0 : _models$globalOffset3.z) !== null && _models$globalOffset$3 !== void 0 ? _models$globalOffset$3 : 0);
-      var _iterator4 = scene3DController_createForOfIteratorHelper(models.placements),
-        _step4;
+      var _iterator5 = scene3DController_createForOfIteratorHelper(models.placements),
+        _step5;
       try {
         var _loop = function _loop() {
             var _placement$position$a;
-            var placement = _step4.value;
+            var placement = _step5.value;
             if (!isPlacementVisibleOnFloor(placement, floorKey)) {
               return 0; // continue
             }
-            var template = _this3.scene3DGlbTemplateById.get(placement.assetId);
+            var template = _this4.scene3DGlbTemplateById.get(placement.assetId);
             if (!template) {
               return 0; // continue
             }
@@ -20075,14 +20398,14 @@ var Scene3DController = /*#__PURE__*/function () {
             modelsGroup.add(pivot);
           },
           _ret;
-        for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
+        for (_iterator5.s(); !(_step5 = _iterator5.n()).done;) {
           _ret = _loop();
           if (_ret === 0) continue;
         }
       } catch (err) {
-        _iterator4.e(err);
+        _iterator5.e(err);
       } finally {
-        _iterator4.f();
+        _iterator5.f();
       }
       this.scene3DModelsGroup = modelsGroup;
       this.scene3DGlbScene.add(modelsGroup);
@@ -20102,15 +20425,15 @@ var Scene3DController = /*#__PURE__*/function () {
   }, {
     key: "recomputeRouteAffectedModels",
     value: function recomputeRouteAffectedModels() {
-      var _this$threeMod5,
-        _this4 = this;
-      var three = (_this$threeMod5 = this.threeMod) === null || _this$threeMod5 === void 0 ? void 0 : _this$threeMod5.THREE;
+      var _this$threeMod6,
+        _this5 = this;
+      var three = (_this$threeMod6 = this.threeMod) === null || _this$threeMod6 === void 0 ? void 0 : _this$threeMod6.THREE;
       var modelsGroup = this.scene3DModelsGroup;
       if (!three || !modelsGroup) {
         return;
       }
       var points = this.scene3DRouteCollisionPoints.filter(function (p) {
-        return p.floorKey === _this4.currentFloor;
+        return p.floorKey === _this5.currentFloor;
       });
 
       // Convert each route point into the models group's local frame (metres relative to
@@ -20127,11 +20450,11 @@ var Scene3DController = /*#__PURE__*/function () {
       });
       modelsGroup.updateMatrixWorld(true);
       var local = new three.Vector3();
-      var _iterator5 = scene3DController_createForOfIteratorHelper(modelsGroup.children),
-        _step5;
+      var _iterator6 = scene3DController_createForOfIteratorHelper(modelsGroup.children),
+        _step6;
       try {
         var _loop2 = function _loop2() {
-          var pivot = _step5.value;
+          var pivot = _step6.value;
           var routeCfg = pivot.userData.routeTransparency;
           var footprint = pivot.userData.footprint;
           // Only models with a route-transparency config participate (feature activation gate).
@@ -20148,13 +20471,13 @@ var Scene3DController = /*#__PURE__*/function () {
             return pointInFootprint(footprint, local.x, local.z);
           });
         };
-        for (_iterator5.s(); !(_step5 = _iterator5.n()).done;) {
+        for (_iterator6.s(); !(_step6 = _iterator6.n()).done;) {
           if (_loop2()) continue;
         }
       } catch (err) {
-        _iterator5.e(err);
+        _iterator6.e(err);
       } finally {
-        _iterator5.f();
+        _iterator6.f();
       }
     }
 
@@ -20174,11 +20497,11 @@ var Scene3DController = /*#__PURE__*/function () {
       }
       var zoom = this.map.getZoom();
       var changed = false;
-      var _iterator6 = scene3DController_createForOfIteratorHelper(this.scene3DModelsGroup.children),
-        _step6;
+      var _iterator7 = scene3DController_createForOfIteratorHelper(this.scene3DModelsGroup.children),
+        _step7;
       try {
         var _loop3 = function _loop3() {
-          var pivot = _step6.value;
+          var pivot = _step7.value;
           var zoomCfg = pivot.userData.zoomTransparency;
           var routeCfg = pivot.userData.routeTransparency;
           var routeAffected = pivot.userData.routeAffected === true;
@@ -20189,11 +20512,11 @@ var Scene3DController = /*#__PURE__*/function () {
               return;
             }
             var materials = Array.isArray(mesh.material) ? mesh.material : [mesh.material];
-            var _iterator7 = scene3DController_createForOfIteratorHelper(materials),
-              _step7;
+            var _iterator8 = scene3DController_createForOfIteratorHelper(materials),
+              _step8;
             try {
-              for (_iterator7.s(); !(_step7 = _iterator7.n()).done;) {
-                var material = _step7.value;
+              for (_iterator8.s(); !(_step8 = _iterator8.n()).done;) {
+                var material = _step8.value;
                 if (material.opacity !== opacity) {
                   material.transparent = opacity < 1;
                   material.opacity = opacity;
@@ -20203,19 +20526,19 @@ var Scene3DController = /*#__PURE__*/function () {
                 }
               }
             } catch (err) {
-              _iterator7.e(err);
+              _iterator8.e(err);
             } finally {
-              _iterator7.f();
+              _iterator8.f();
             }
           });
         };
-        for (_iterator6.s(); !(_step6 = _iterator6.n()).done;) {
+        for (_iterator7.s(); !(_step7 = _iterator7.n()).done;) {
           _loop3();
         }
       } catch (err) {
-        _iterator6.e(err);
+        _iterator7.e(err);
       } finally {
-        _iterator6.f();
+        _iterator7.f();
       }
       if (changed) {
         this.map.triggerRepaint();
@@ -20224,12 +20547,12 @@ var Scene3DController = /*#__PURE__*/function () {
   }, {
     key: "loadSpriteAtlas",
     value: function () {
-      var _loadSpriteAtlas = scene3DController_asyncToGenerator(/*#__PURE__*/scene3DController_regenerator().m(function _callee5(spriteUrl) {
+      var _loadSpriteAtlas = scene3DController_asyncToGenerator(/*#__PURE__*/scene3DController_regenerator().m(function _callee6(spriteUrl) {
         var _yield$Promise$all, _yield$Promise$all2, json, img;
-        return scene3DController_regenerator().w(function (_context5) {
-          while (1) switch (_context5.n) {
+        return scene3DController_regenerator().w(function (_context6) {
+          while (1) switch (_context6.n) {
             case 0:
-              _context5.n = 1;
+              _context6.n = 1;
               return Promise.all([fetch("".concat(spriteUrl, ".json")).then(function (r) {
                 return r.json();
               }), new Promise(function (resolve, reject) {
@@ -20242,29 +20565,52 @@ var Scene3DController = /*#__PURE__*/function () {
                 image.src = "".concat(spriteUrl, ".png");
               })]);
             case 1:
-              _yield$Promise$all = _context5.v;
+              _yield$Promise$all = _context6.v;
               _yield$Promise$all2 = scene3DController_slicedToArray(_yield$Promise$all, 2);
               json = _yield$Promise$all2[0];
               img = _yield$Promise$all2[1];
               this.spriteIconMapping = json;
               this.spriteAtlasImage = img;
             case 2:
-              return _context5.a(2);
+              return _context6.a(2);
           }
-        }, _callee5, this);
+        }, _callee6, this);
       }));
       function loadSpriteAtlas(_x2) {
         return _loadSpriteAtlas.apply(this, arguments);
       }
       return loadSpriteAtlas;
     }()
+    /**
+     * Cache-bounding props spread onto every deck.gl `MVTLayer` so the overlays never keep an
+     * unbounded set of parsed tiles in memory. `maxCacheByteSize` is only included when configured
+     * (deck.gl enforces it only when a tile's byte size is known).
+     */
+  }, {
+    key: "deckTileCacheProps",
+    get: function get() {
+      var _this$deckTileCache = this.deckTileCache,
+        maxCacheSize = _this$deckTileCache.maxCacheSize,
+        maxRequests = _this$deckTileCache.maxRequests,
+        refinementStrategy = _this$deckTileCache.refinementStrategy,
+        maxCacheByteSize = _this$deckTileCache.maxCacheByteSize;
+      var props = {
+        maxCacheSize: maxCacheSize,
+        maxRequests: maxRequests,
+        refinementStrategy: refinementStrategy
+      };
+      if (maxCacheByteSize !== undefined) {
+        props.maxCacheByteSize = maxCacheByteSize;
+      }
+      return props;
+    }
   }, {
     key: "makeElevatedLinesLayer",
     value: function makeElevatedLinesLayer(floorKey, layerConfig) {
       var _layerConfig$binaryDa;
       var deck = this.deckMod;
       if (!deck) return null;
-      return new deck.MVTLayer({
+      return new deck.MVTLayer(scene3DController_objectSpread(scene3DController_objectSpread({}, this.deckTileCacheProps), {}, {
         id: "indoor-lines-elevated",
         data: layerConfig.dataUrl,
         binary: (_layerConfig$binaryDa = layerConfig.binaryData) !== null && _layerConfig$binaryDa !== void 0 ? _layerConfig$binaryDa : false,
@@ -20289,7 +20635,7 @@ var Scene3DController = /*#__PURE__*/function () {
         updateTriggers: {
           renderSubLayers: [floorKey]
         }
-      });
+      }));
     }
   }, {
     key: "makeLabelLayer",
@@ -20297,11 +20643,11 @@ var Scene3DController = /*#__PURE__*/function () {
       var _layerConfig$binaryDa2,
         _layerConfig$minZoom,
         _layerConfig$maxZoom,
-        _this5 = this;
+        _this6 = this;
       var useSdf = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;
       var deck = this.deckMod;
       if (!deck) return null;
-      return new deck.MVTLayer({
+      return new deck.MVTLayer(scene3DController_objectSpread(scene3DController_objectSpread({}, this.deckTileCacheProps), {}, {
         id: "indoor-labels",
         data: layerConfig.dataUrl,
         binary: (_layerConfig$binaryDa2 = layerConfig.binaryData) !== null && _layerConfig$binaryDa2 !== void 0 ? _layerConfig$binaryDa2 : false,
@@ -20312,7 +20658,7 @@ var Scene3DController = /*#__PURE__*/function () {
           // Use area_name and poi Point features — unique per tile, no duplicates.
           // If a logo-{name} image exists in the sprite, the icon takes priority over the text label.
           var textData = buildLabelData(props.data || [], floorKey, function (imageId) {
-            return _this5.map.hasImage(imageId);
+            return _this6.map.hasImage(imageId);
           }, (_layerConfig$defaultH2 = layerConfig.defaultHeight) !== null && _layerConfig$defaultH2 !== void 0 ? _layerConfig$defaultH2 : 5);
           if (!textData.length) return null;
           return new deck.TextLayer(scene3DController_objectSpread(scene3DController_objectSpread({}, props), {}, {
@@ -20343,7 +20689,7 @@ var Scene3DController = /*#__PURE__*/function () {
         updateTriggers: {
           renderSubLayers: [floorKey]
         }
-      });
+      }));
     }
   }, {
     key: "makePoiIconLayer",
@@ -20351,10 +20697,10 @@ var Scene3DController = /*#__PURE__*/function () {
       var _layerConfig$binaryDa3,
         _layerConfig$minZoom2,
         _layerConfig$maxZoom2,
-        _this6 = this;
+        _this7 = this;
       var deck = this.deckMod;
       if (!deck || !this.spriteIconMapping || !this.spriteAtlasImage) return null;
-      return new deck.MVTLayer({
+      return new deck.MVTLayer(scene3DController_objectSpread(scene3DController_objectSpread({}, this.deckTileCacheProps), {}, {
         id: "indoor-poi-icons",
         data: layerConfig.dataUrl,
         binary: (_layerConfig$binaryDa3 = layerConfig.binaryData) !== null && _layerConfig$binaryDa3 !== void 0 ? _layerConfig$binaryDa3 : false,
@@ -20367,8 +20713,8 @@ var Scene3DController = /*#__PURE__*/function () {
           return new deck.IconLayer(scene3DController_objectSpread(scene3DController_objectSpread({}, props), {}, {
             id: "".concat(props.id, "-poi-icons"),
             data: iconData,
-            iconAtlas: _this6.spriteAtlasImage,
-            iconMapping: _this6.spriteIconMapping,
+            iconAtlas: _this7.spriteAtlasImage,
+            iconMapping: _this7.spriteIconMapping,
             getIcon: function getIcon(d) {
               return d.icon;
             },
@@ -20385,7 +20731,7 @@ var Scene3DController = /*#__PURE__*/function () {
         updateTriggers: {
           renderSubLayers: [floorKey]
         }
-      });
+      }));
     }
   }, {
     key: "makeStoreLogoLayer",
@@ -20393,10 +20739,10 @@ var Scene3DController = /*#__PURE__*/function () {
       var _layerConfig$binaryDa4,
         _layerConfig$minZoom3,
         _layerConfig$maxZoom3,
-        _this7 = this;
+        _this8 = this;
       var deck = this.deckMod;
       if (!deck || !this.spriteIconMapping || !this.spriteAtlasImage) return null;
-      return new deck.MVTLayer({
+      return new deck.MVTLayer(scene3DController_objectSpread(scene3DController_objectSpread({}, this.deckTileCacheProps), {}, {
         id: "indoor-store-logos",
         data: layerConfig.dataUrl,
         binary: (_layerConfig$binaryDa4 = layerConfig.binaryData) !== null && _layerConfig$binaryDa4 !== void 0 ? _layerConfig$binaryDa4 : false,
@@ -20404,13 +20750,13 @@ var Scene3DController = /*#__PURE__*/function () {
         maxZoom: (_layerConfig$maxZoom3 = layerConfig.maxZoom) !== null && _layerConfig$maxZoom3 !== void 0 ? _layerConfig$maxZoom3 : 24,
         renderSubLayers: function renderSubLayers(props) {
           var _layerConfig$defaultH4, _layerConfig$sizeUnit2, _layerConfig$sizeScal2, _layerConfig$billboar2;
-          var logoData = buildStoreLogoData(props.data || [], floorKey, _this7.spriteIconMapping, (_layerConfig$defaultH4 = layerConfig.defaultHeight) !== null && _layerConfig$defaultH4 !== void 0 ? _layerConfig$defaultH4 : 5);
+          var logoData = buildStoreLogoData(props.data || [], floorKey, _this8.spriteIconMapping, (_layerConfig$defaultH4 = layerConfig.defaultHeight) !== null && _layerConfig$defaultH4 !== void 0 ? _layerConfig$defaultH4 : 5);
           if (!logoData.length) return null;
           return new deck.IconLayer(scene3DController_objectSpread(scene3DController_objectSpread({}, props), {}, {
             id: "".concat(props.id, "-store-logos"),
             data: logoData,
-            iconAtlas: _this7.spriteAtlasImage,
-            iconMapping: _this7.spriteIconMapping,
+            iconAtlas: _this8.spriteAtlasImage,
+            iconMapping: _this8.spriteIconMapping,
             getIcon: function getIcon(d) {
               return d.icon;
             },
@@ -20422,7 +20768,7 @@ var Scene3DController = /*#__PURE__*/function () {
             },
             getSize: function getSize(d) {
               var _layerConfig$logoScal;
-              return computeStoreLogoSize(_this7.spriteIconMapping, d.icon, (_layerConfig$logoScal = layerConfig.logoScale) !== null && _layerConfig$logoScal !== void 0 ? _layerConfig$logoScal : {});
+              return computeStoreLogoSize(_this8.spriteIconMapping, d.icon, (_layerConfig$logoScal = layerConfig.logoScale) !== null && _layerConfig$logoScal !== void 0 ? _layerConfig$logoScal : {});
             },
             sizeUnits: (_layerConfig$sizeUnit2 = layerConfig.sizeUnits) !== null && _layerConfig$sizeUnit2 !== void 0 ? _layerConfig$sizeUnit2 : "meters",
             sizeScale: (_layerConfig$sizeScal2 = layerConfig.sizeScale) !== null && _layerConfig$sizeScal2 !== void 0 ? _layerConfig$sizeScal2 : 1,
@@ -20433,7 +20779,7 @@ var Scene3DController = /*#__PURE__*/function () {
         updateTriggers: {
           renderSubLayers: [floorKey]
         }
-      });
+      }));
     }
   }, {
     key: "updateDeckOverlay",
@@ -20467,19 +20813,19 @@ var Scene3DController = /*#__PURE__*/function () {
     key: "hideLayers",
     value: function hideLayers(layersIds) {
       if (!layersIds) return;
-      var _iterator8 = scene3DController_createForOfIteratorHelper(layersIds),
-        _step8;
+      var _iterator9 = scene3DController_createForOfIteratorHelper(layersIds),
+        _step9;
       try {
-        for (_iterator8.s(); !(_step8 = _iterator8.n()).done;) {
-          var layerId = _step8.value;
+        for (_iterator9.s(); !(_step9 = _iterator9.n()).done;) {
+          var layerId = _step9.value;
           var layer = this.map.getLayer(layerId);
           if (!layer) continue;
           this.map.setLayoutProperty(layer.id, "visibility", "none");
         }
       } catch (err) {
-        _iterator8.e(err);
+        _iterator9.e(err);
       } finally {
-        _iterator8.f();
+        _iterator9.f();
       }
     }
   }]);