@2112-lab/central-plant 0.2.12 → 0.3.1

package/dist/bundle/index.js

@@ -37840,7 +37840,7 @@ var CentralPlant = /*#__PURE__*/function (_BaseDisposable) {
    * Initialize the CentralPlant manager
    * 
    * @constructor
-   * @version 0.2.12
+   * @version 0.3.1
    * @updated 2025-10-22
    * 
    * @description Creates a new CentralPlant instance and initializes internal managers and utilities.
@@ -42101,9 +42101,14 @@ var CacheManager = /*#__PURE__*/function () {
         }
         return getUser;
       }(),
-      // Default error logger
+      // Injected Amplify Auth instance (set by consuming app via configure())
+      auth: null,
+      // Injected Amplify Storage instance (set by consuming app via configure())
+      storage: null,
+      // Default error logger — suppresses expected not-authenticated errors
       onError: function onError(error) {
-        return console.error('CacheManager Error:', error);
+        if ((error === null || error === void 0 ? void 0 : error.code) === 'S3CacheNotAuthenticated') return;
+        console.error('CacheManager Error:', error);
       }
     };
   }
@@ -42181,10 +42186,6 @@ var CacheManager = /*#__PURE__*/function () {
       }
       return _getCacheHandle;
     }()
-    /**
-     * Get the cache name for the current user
-     * Memoized to prevent excessive Auth calls
-     */
     /**
      * Resets the identity, forcing a re-fetch of the user/cache name on next access
      */
@@ -42281,7 +42282,6 @@ var CacheManager = /*#__PURE__*/function () {
             case 5:
               result = _context4.v;
               this.stats.hits++;
-              result instanceof Blob ? result.size : 0;
               if (result instanceof Blob) this.stats.totalBytesServed += result.size;
               return _context4.a(2, result);
             case 6:
@@ -42340,7 +42340,13 @@ var CacheManager = /*#__PURE__*/function () {
               this.stats.errors++;
               this.config.onError(_t2);
 
-              // Fallback
+              // If the error is marked noRetry, propagate immediately without a second fetch attempt
+              if (!_t2.noRetry) {
+                _context4.n = 14;
+                break;
+              }
+              throw _t2;
+            case 14:
               _context4.p = 14;
               _context4.n = 15;
               return fetcher();
@@ -42833,7 +42839,7 @@ var CacheManager = /*#__PURE__*/function () {
       return get;
     }()
     /**
-     * Delete a specific key from value
+     * Delete a specific key from the cache
      */
     )
   }, {
@@ -43066,7 +43072,7 @@ var CacheManager = /*#__PURE__*/function () {
               return _response.blob();
             case 28:
               _blob = _context11.v;
-              cachedTime = _response.headers.get('x-cached-time'); // Try to get key from headers or fallback
+              cachedTime = _response.headers.get('x-cached-time');
               sourceKey = _response.headers.get('x-source-key') || _response.headers.get('x-s3-key') || _response.headers.get('x-local-path') || _request.url;
               totalSize += _blob.size;
               items.push({
@@ -43123,6 +43129,2052 @@ var CacheManager = /*#__PURE__*/function () {
 }();
 var cacheManager = new CacheManager();
 
+/**
+ * Retrieve the injected Auth instance. Throws if not configured.
+ */
+function getAuth$1() {
+  var auth = cacheManager.config.auth;
+  if (!auth) throw new Error('cacheManager.configure({ auth }) must be called before using S3 cache functions');
+  return auth;
+}
+
+/**
+ * Retrieve the injected Storage instance. Throws if not configured.
+ */
+function getStorage() {
+  var storage = cacheManager.config.storage;
+  if (!storage) throw new Error('cacheManager.configure({ storage }) must be called before using S3 cache functions');
+  return storage;
+}
+
+/**
+ * Guard used inside S3 fetchers. Throws a noRetry error (suppressed by onError)
+ * instead of letting Storage.get() fail with an Amplify credential warning.
+ */
+function requireAuthentication() {
+  return _requireAuthentication.apply(this, arguments);
+}
+/**
+ * Reset the cache manager identity.
+ * Call this when auth state changes to ensure the correct cache partition is used.
+ */
+function _requireAuthentication() {
+  _requireAuthentication = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee() {
+    var err;
+    return _regenerator().w(function (_context) {
+      while (1) switch (_context.n) {
+        case 0:
+          _context.p = 0;
+          _context.n = 1;
+          return getAuth$1().currentAuthenticatedUser();
+        case 1:
+          _context.n = 3;
+          break;
+        case 2:
+          _context.p = 2;
+          _context.v;
+          err = new Error('S3 access requires authentication');
+          err.code = 'S3CacheNotAuthenticated';
+          err.noRetry = true;
+          throw err;
+        case 3:
+          return _context.a(2);
+      }
+    }, _callee, null, [[0, 2]]);
+  }));
+  return _requireAuthentication.apply(this, arguments);
+}
+function resetCacheIdentity() {
+  cacheManager.resetIdentity();
+  console.log('🔄 Cache identity reset - will re-evaluate on next cache access');
+}
+
+// --- Global Cache for Bundled/Static Access ---
+var GLOBAL_CACHE_NAME = 'asset-manager-global-v1';
+function getGlobalCache() {
+  return _getGlobalCache.apply(this, arguments);
+}
+function _getGlobalCache() {
+  _getGlobalCache = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee2() {
+    return _regenerator().w(function (_context2) {
+      while (1) switch (_context2.n) {
+        case 0:
+          if ('caches' in window) {
+            _context2.n = 1;
+            break;
+          }
+          return _context2.a(2, null);
+        case 1:
+          return _context2.a(2, caches.open(GLOBAL_CACHE_NAME));
+      }
+    }, _callee2);
+  }));
+  return _getGlobalCache.apply(this, arguments);
+}
+function executeGlobal(_x) {
+  return _executeGlobal.apply(this, arguments);
+}
+/**
+ * Clear the entire global cache (bundled models, thumbnails, etc.).
+ */
+function _executeGlobal() {
+  _executeGlobal = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee3(_ref) {
+    var cacheKey, fetcher, processor, metadata, cache, cachedResponse, response, responseClone, headers, responseToCache, _response, _t2, _t3, _t4, _t5, _t6, _t7;
+    return _regenerator().w(function (_context3) {
+      while (1) switch (_context3.n) {
+        case 0:
+          cacheKey = _ref.cacheKey, fetcher = _ref.fetcher, processor = _ref.processor, metadata = _ref.metadata;
+          _context3.p = 1;
+          _context3.n = 2;
+          return getGlobalCache();
+        case 2:
+          cache = _context3.v;
+          if (cache) {
+            _context3.n = 5;
+            break;
+          }
+          _t2 = processor;
+          _context3.n = 3;
+          return fetcher();
+        case 3:
+          _t3 = _context3.v;
+          _context3.n = 4;
+          return _t2(_t3);
+        case 4:
+          return _context3.a(2, _context3.v);
+        case 5:
+          _context3.n = 6;
+          return cache.match(cacheKey);
+        case 6:
+          cachedResponse = _context3.v;
+          if (!cachedResponse) {
+            _context3.n = 8;
+            break;
+          }
+          _context3.n = 7;
+          return processor(cachedResponse);
+        case 7:
+          return _context3.a(2, _context3.v);
+        case 8:
+          _context3.n = 9;
+          return fetcher();
+        case 9:
+          response = _context3.v;
+          // Clone for cache
+          responseClone = response.clone(); // Store with metadata headers if possible
+          headers = new Headers(responseClone.headers);
+          headers.append('X-Cached-Time', Date.now().toString());
+          if (metadata) {
+            headers.append('X-Cache-Metadata', JSON.stringify(metadata));
+          }
+
+          // We need to create a new Response with updated headers to store it
+          _t4 = Response;
+          _context3.n = 10;
+          return responseClone.blob();
+        case 10:
+          _t5 = _context3.v;
+          _t6 = {
+            status: responseClone.status,
+            statusText: responseClone.statusText,
+            headers: headers
+          };
+          responseToCache = new _t4(_t5, _t6);
+          _context3.n = 11;
+          return cache.put(cacheKey, responseToCache);
+        case 11:
+          _context3.n = 12;
+          return processor(response);
+        case 12:
+          return _context3.a(2, _context3.v);
+        case 13:
+          _context3.p = 13;
+          _t7 = _context3.v;
+          console.warn('Global Cache execution failed, falling back to network', _t7);
+          _context3.n = 14;
+          return fetcher();
+        case 14:
+          _response = _context3.v;
+          _context3.n = 15;
+          return processor(_response);
+        case 15:
+          return _context3.a(2, _context3.v);
+      }
+    }, _callee3, null, [[1, 13]]);
+  }));
+  return _executeGlobal.apply(this, arguments);
+}
+function clearGlobalCache() {
+  return _clearGlobalCache.apply(this, arguments);
+}
+/**
+ * Remove expired entries from the global cache.
+ * Returns the number of entries removed.
+ */
+function _clearGlobalCache() {
+  _clearGlobalCache = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee4() {
+    var deleted, _t8;
+    return _regenerator().w(function (_context4) {
+      while (1) switch (_context4.n) {
+        case 0:
+          _context4.p = 0;
+          if ('caches' in window) {
+            _context4.n = 1;
+            break;
+          }
+          return _context4.a(2, false);
+        case 1:
+          _context4.n = 2;
+          return caches.delete(GLOBAL_CACHE_NAME);
+        case 2:
+          deleted = _context4.v;
+          if (deleted) console.log('🗑️ Global cache cleared');
+          return _context4.a(2, deleted);
+        case 3:
+          _context4.p = 3;
+          _t8 = _context4.v;
+          console.warn('Failed to clear global cache:', _t8);
+          return _context4.a(2, false);
+      }
+    }, _callee4, null, [[0, 3]]);
+  }));
+  return _clearGlobalCache.apply(this, arguments);
+}
+function cleanExpiredGlobalCache() {
+  return _cleanExpiredGlobalCache.apply(this, arguments);
+}
+function _cleanExpiredGlobalCache() {
+  _cleanExpiredGlobalCache = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee6() {
+    var cache, keys, cleaned;
+    return _regenerator().w(function (_context6) {
+      while (1) switch (_context6.n) {
+        case 0:
+          _context6.n = 1;
+          return getGlobalCache();
+        case 1:
+          cache = _context6.v;
+          if (cache) {
+            _context6.n = 2;
+            break;
+          }
+          return _context6.a(2, 0);
+        case 2:
+          _context6.n = 3;
+          return cache.keys();
+        case 3:
+          keys = _context6.v;
+          cleaned = 0;
+          _context6.n = 4;
+          return Promise.all(keys.map(/*#__PURE__*/function () {
+            var _ref2 = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee5(request) {
+              var response, cachedTime, age, s3Key, expiryMs, _t9;
+              return _regenerator().w(function (_context5) {
+                while (1) switch (_context5.n) {
+                  case 0:
+                    _context5.p = 0;
+                    _context5.n = 1;
+                    return cache.match(request);
+                  case 1:
+                    response = _context5.v;
+                    if (response) {
+                      _context5.n = 2;
+                      break;
+                    }
+                    return _context5.a(2);
+                  case 2:
+                    cachedTime = parseInt(response.headers.get('X-Cached-Time') || '0');
+                    age = Date.now() - cachedTime;
+                    s3Key = request.url.replace('https://local.cache', '');
+                    expiryMs = cacheManager.getExpiryForPath(s3Key);
+                    if (!(age > expiryMs)) {
+                      _context5.n = 4;
+                      break;
+                    }
+                    _context5.n = 3;
+                    return cache.delete(request);
+                  case 3:
+                    cleaned++;
+                  case 4:
+                    _context5.n = 6;
+                    break;
+                  case 5:
+                    _context5.p = 5;
+                    _t9 = _context5.v;
+                    console.warn('Failed to check global cache entry:', _t9);
+                  case 6:
+                    return _context5.a(2);
+                }
+              }, _callee5, null, [[0, 5]]);
+            }));
+            return function (_x16) {
+              return _ref2.apply(this, arguments);
+            };
+          }()));
+        case 4:
+          if (cleaned > 0) console.log("\uD83E\uDDF9 Cleaned ".concat(cleaned, " expired global cache entries"));
+          return _context6.a(2, cleaned);
+      }
+    }, _callee6);
+  }));
+  return _cleanExpiredGlobalCache.apply(this, arguments);
+}
+function getGlobalCacheStatsDetail() {
+  return _getGlobalCacheStatsDetail.apply(this, arguments);
+} // --- Exports delegating to CacheManager ---
+function _getGlobalCacheStatsDetail() {
+  _getGlobalCacheStatsDetail = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee8() {
+    var cache, keys, items, totalSize;
+    return _regenerator().w(function (_context8) {
+      while (1) switch (_context8.n) {
+        case 0:
+          _context8.n = 1;
+          return getGlobalCache();
+        case 1:
+          cache = _context8.v;
+          if (cache) {
+            _context8.n = 2;
+            break;
+          }
+          return _context8.a(2, {
+            count: 0,
+            totalSize: 0,
+            totalSizeMB: '0.00',
+            items: []
+          });
+        case 2:
+          _context8.n = 3;
+          return cache.keys();
+        case 3:
+          keys = _context8.v;
+          items = [];
+          totalSize = 0;
+          _context8.n = 4;
+          return Promise.all(keys.map(/*#__PURE__*/function () {
+            var _ref3 = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee7(request) {
+              var response, cachedTime, metadataHeader, metadata, size, cl;
+              return _regenerator().w(function (_context7) {
+                while (1) switch (_context7.n) {
+                  case 0:
+                    _context7.n = 1;
+                    return cache.match(request);
+                  case 1:
+                    response = _context7.v;
+                    if (response) {
+                      _context7.n = 2;
+                      break;
+                    }
+                    return _context7.a(2);
+                  case 2:
+                    cachedTime = parseInt(response.headers.get('X-Cached-Time') || '0');
+                    metadataHeader = response.headers.get('X-Cache-Metadata');
+                    metadata = metadataHeader ? JSON.parse(metadataHeader) : {};
+                    size = 0;
+                    cl = response.headers.get('Content-Length');
+                    if (cl) size = parseInt(cl);
+                    totalSize += size;
+                    items.push(_objectSpread2({
+                      url: request.url,
+                      s3Key: request.url.replace('https://local.cache', ''),
+                      size: size,
+                      sizeMB: (size / (1024 * 1024)).toFixed(2),
+                      cachedTime: cachedTime,
+                      age: Date.now() - cachedTime,
+                      isLocal: true,
+                      type: response.headers.get('Content-Type') || 'application/octet-stream'
+                    }, metadata));
+                  case 3:
+                    return _context7.a(2);
+                }
+              }, _callee7);
+            }));
+            return function (_x17) {
+              return _ref3.apply(this, arguments);
+            };
+          }()));
+        case 4:
+          return _context8.a(2, {
+            count: items.length,
+            totalSize: totalSize,
+            totalSizeMB: (totalSize / (1024 * 1024)).toFixed(2),
+            items: items
+          });
+      }
+    }, _callee8);
+  }));
+  return _getGlobalCacheStatsDetail.apply(this, arguments);
+}
+function getGlobalCacheStats() {
+  return cacheManager.getGlobalStats();
+}
+function resetGlobalCacheStats() {
+  cacheManager.resetStats();
+}
+function getCurrentCacheName() {
+  return _getCurrentCacheName.apply(this, arguments);
+}
+function _getCurrentCacheName() {
+  _getCurrentCacheName = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee9() {
+    return _regenerator().w(function (_context9) {
+      while (1) switch (_context9.n) {
+        case 0:
+          return _context9.a(2, cacheManager.getCacheName());
+      }
+    }, _callee9);
+  }));
+  return _getCurrentCacheName.apply(this, arguments);
+}
+function cleanExpiredCache() {
+  return _cleanExpiredCache.apply(this, arguments);
+}
+function _cleanExpiredCache() {
+  _cleanExpiredCache = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee0() {
+    var userCount, globalCount, count;
+    return _regenerator().w(function (_context0) {
+      while (1) switch (_context0.n) {
+        case 0:
+          _context0.n = 1;
+          return cacheManager.cleanExpired();
+        case 1:
+          userCount = _context0.v;
+          _context0.n = 2;
+          return cleanExpiredGlobalCache();
+        case 2:
+          globalCount = _context0.v;
+          count = userCount + globalCount;
+          if (count > 0) console.log("\uD83E\uDDF9 Cleaned ".concat(count, " expired cache entries (user: ").concat(userCount, ", global: ").concat(globalCount, ")"));
+          return _context0.a(2, count);
+      }
+    }, _callee0);
+  }));
+  return _cleanExpiredCache.apply(this, arguments);
+}
+function cleanInvalidCacheEntries() {
+  return _cleanInvalidCacheEntries.apply(this, arguments);
+}
+function _cleanInvalidCacheEntries() {
+  _cleanInvalidCacheEntries = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee1() {
+    var count;
+    return _regenerator().w(function (_context1) {
+      while (1) switch (_context1.n) {
+        case 0:
+          _context1.n = 1;
+          return cacheManager.cleanInvalid();
+        case 1:
+          count = _context1.v;
+          if (count > 0) console.log("\uD83E\uDDF9 Cleaned ".concat(count, " invalid cache entries"));
+          return _context1.a(2, count);
+      }
+    }, _callee1);
+  }));
+  return _cleanInvalidCacheEntries.apply(this, arguments);
+}
+function getCacheStats() {
+  return _getCacheStats.apply(this, arguments);
+}
+function _getCacheStats() {
+  _getCacheStats = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee10() {
+    var allUsers,
+      userStats,
+      globalStats,
+      userItems,
+      _args10 = arguments;
+    return _regenerator().w(function (_context10) {
+      while (1) switch (_context10.n) {
+        case 0:
+          allUsers = _args10.length > 0 && _args10[0] !== undefined ? _args10[0] : false;
+          _context10.n = 1;
+          return cacheManager.getDetailedStats(allUsers);
+        case 1:
+          userStats = _context10.v;
+          _context10.n = 2;
+          return getGlobalCacheStatsDetail();
+        case 2:
+          globalStats = _context10.v;
+          // Ensure user stats items have isLocal: false
+          userItems = userStats.items.map(function (item) {
+            return _objectSpread2(_objectSpread2({}, item), {}, {
+              isLocal: false
+            });
+          }); // Merge stats
+          return _context10.a(2, {
+            count: userStats.count + globalStats.count,
+            totalSize: userStats.totalSize + globalStats.totalSize,
+            totalSizeMB: (parseFloat(userStats.totalSizeMB) + parseFloat(globalStats.totalSizeMB)).toFixed(2),
+            items: [].concat(_toConsumableArray(userItems), _toConsumableArray(globalStats.items))
+          });
+      }
+    }, _callee10);
+  }));
+  return _getCacheStats.apply(this, arguments);
+}
+function getUserOnlyCacheStats() {
+  return _getUserOnlyCacheStats.apply(this, arguments);
+}
+function _getUserOnlyCacheStats() {
+  _getUserOnlyCacheStats = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee11() {
+    var allUsers,
+      stats,
+      _args11 = arguments;
+    return _regenerator().w(function (_context11) {
+      while (1) switch (_context11.n) {
+        case 0:
+          allUsers = _args11.length > 0 && _args11[0] !== undefined ? _args11[0] : false;
+          _context11.n = 1;
+          return cacheManager.getDetailedStats(allUsers);
+        case 1:
+          stats = _context11.v;
+          // Ensure items have isLocal: false
+          stats.items = stats.items.map(function (item) {
+            return _objectSpread2(_objectSpread2({}, item), {}, {
+              isLocal: false
+            });
+          });
+          return _context11.a(2, stats);
+      }
+    }, _callee11);
+  }));
+  return _getUserOnlyCacheStats.apply(this, arguments);
+}
+function getGlobalOnlyCacheStats() {
+  return _getGlobalOnlyCacheStats.apply(this, arguments);
+}
+function _getGlobalOnlyCacheStats() {
+  _getGlobalOnlyCacheStats = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee12() {
+    return _regenerator().w(function (_context12) {
+      while (1) switch (_context12.n) {
+        case 0:
+          _context12.n = 1;
+          return getGlobalCacheStatsDetail();
+        case 1:
+          return _context12.a(2, _context12.v);
+      }
+    }, _callee12);
+  }));
+  return _getGlobalOnlyCacheStats.apply(this, arguments);
+}
+function clearS3Cache() {
+  return _clearS3Cache.apply(this, arguments);
+}
+function _clearS3Cache() {
+  _clearS3Cache = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee13() {
+    var specificKey,
+      clearAllUsers,
+      result,
+      _args13 = arguments;
+    return _regenerator().w(function (_context13) {
+      while (1) switch (_context13.n) {
+        case 0:
+          specificKey = _args13.length > 0 && _args13[0] !== undefined ? _args13[0] : null;
+          clearAllUsers = _args13.length > 1 && _args13[1] !== undefined ? _args13[1] : false;
+          _context13.n = 1;
+          return cacheManager.clearCache(specificKey, clearAllUsers);
+        case 1:
+          result = _context13.v;
+          if (specificKey) {
+            _context13.n = 2;
+            break;
+          }
+          _context13.n = 2;
+          return clearGlobalCache();
+        case 2:
+          if (result) console.log(specificKey ? "\uD83D\uDDD1\uFE0F Cleared cache for ".concat(specificKey) : "\uD83D\uDDD1\uFE0F Cache cleared (user + global)");
+          return _context13.a(2, result);
+      }
+    }, _callee13);
+  }));
+  return _clearS3Cache.apply(this, arguments);
+}
+function getAllCacheKeys() {
+  return _getAllCacheKeys.apply(this, arguments);
+}
+function _getAllCacheKeys() {
+  _getAllCacheKeys = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee14() {
+    var allKeys, addKey, globalCache, keys, allCacheNames, appCaches, _iterator, _step, cacheName, cache, _keys, _t0;
+    return _regenerator().w(function (_context14) {
+      while (1) switch (_context14.n) {
+        case 0:
+          allKeys = new Set(); // Helper to add both raw and decoded versions for robust matching
+          addKey = function addKey(url) {
+            allKeys.add(url);
+            try {
+              var decoded = decodeURI(url);
+              if (decoded !== url) allKeys.add(decoded);
+            } catch (e) {
+              // Ignore encoding errors
+            }
+          }; // 1. Get Global Cache Keys (Custom Global Cache)
+          _context14.n = 1;
+          return getGlobalCache();
+        case 1:
+          globalCache = _context14.v;
+          if (!globalCache) {
+            _context14.n = 3;
+            break;
+          }
+          _context14.n = 2;
+          return globalCache.keys();
+        case 2:
+          keys = _context14.v;
+          keys.forEach(function (request) {
+            return addKey(request.url);
+          });
+        case 3:
+          if (!('caches' in window)) {
+            _context14.n = 13;
+            break;
+          }
+          _context14.n = 4;
+          return caches.keys();
+        case 4:
+          allCacheNames = _context14.v;
+          appCaches = allCacheNames.filter(function (name) {
+            return name.startsWith(CACHE_NAME_PREFIX);
+          });
+          _iterator = _createForOfIteratorHelper(appCaches);
+          _context14.p = 5;
+          _iterator.s();
+        case 6:
+          if ((_step = _iterator.n()).done) {
+            _context14.n = 10;
+            break;
+          }
+          cacheName = _step.value;
+          _context14.n = 7;
+          return caches.open(cacheName);
+        case 7:
+          cache = _context14.v;
+          if (!cache) {
+            _context14.n = 9;
+            break;
+          }
+          _context14.n = 8;
+          return cache.keys();
+        case 8:
+          _keys = _context14.v;
+          _keys.forEach(function (request) {
+            return addKey(request.url);
+          });
+        case 9:
+          _context14.n = 6;
+          break;
+        case 10:
+          _context14.n = 12;
+          break;
+        case 11:
+          _context14.p = 11;
+          _t0 = _context14.v;
+          _iterator.e(_t0);
+        case 12:
+          _context14.p = 12;
+          _iterator.f();
+          return _context14.f(12);
+        case 13:
+          return _context14.a(2, allKeys);
+      }
+    }, _callee14, null, [[5, 11, 12, 13]]);
+  }));
+  return _getAllCacheKeys.apply(this, arguments);
+}
+function switchCachePartition(_x2) {
+  return _switchCachePartition.apply(this, arguments);
+}
+
+// --- Data Fetchers ---
+
+/**
+ * Check all app cache partitions for a cached response.
+ * This handles the race condition where auth may not be hydrated yet on page refresh.
+ * @param {string} cacheKey - The cache key to look for
+ * @returns {Promise<Response|null>} - Cached response or null if not found
+ */
+function _switchCachePartition() {
+  _switchCachePartition = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee15(isAuthenticated) {
+    var oldCacheName, partitionToDelete, deleted, newCacheName, _t1, _t10;
+    return _regenerator().w(function (_context15) {
+      while (1) switch (_context15.n) {
+        case 0:
+          _context15.p = 0;
+          console.log("\uD83D\uDD04 Switching cache partition (authenticated: ".concat(isAuthenticated, ")..."));
+          _context15.n = 1;
+          return cacheManager.getCacheName();
+        case 1:
+          oldCacheName = _context15.v;
+          // Reset identity to force re-evaluation of cache name
+          cacheManager.resetIdentity();
+          partitionToDelete = null;
+          if (isAuthenticated) {
+            // User logged in - delete anonymous cache
+            partitionToDelete = "".concat(CACHE_NAME_PREFIX, "-anonymous");
+          } else {
+            // User logged out - delete their user-specific cache
+            partitionToDelete = oldCacheName;
+          }
+          if (!partitionToDelete) {
+            _context15.n = 3;
+            break;
+          }
+          _context15.n = 2;
+          return cacheManager.deleteCache(partitionToDelete);
+        case 2:
+          _t1 = _context15.v;
+          _context15.n = 4;
+          break;
+        case 3:
+          _t1 = false;
+        case 4:
+          deleted = _t1;
+          _context15.n = 5;
+          return cacheManager.getCacheName();
+        case 5:
+          newCacheName = _context15.v;
+          console.log("\u2705 Cache partition switched:", {
+            from: oldCacheName,
+            to: newCacheName,
+            deleted: partitionToDelete
+          });
+          return _context15.a(2, {
+            oldCacheName: oldCacheName,
+            newCacheName: newCacheName,
+            deletedPartition: partitionToDelete,
+            deleted: deleted
+          });
+        case 6:
+          _context15.p = 6;
+          _t10 = _context15.v;
+          console.error('Failed to switch cache partition:', _t10);
+          return _context15.a(2, {
+            error: _t10.message
+          });
+      }
+    }, _callee15, null, [[0, 6]]);
+  }));
+  return _switchCachePartition.apply(this, arguments);
+}
+function findInAllCachePartitions(_x3) {
+  return _findInAllCachePartitions.apply(this, arguments);
+}
+function _findInAllCachePartitions() {
+  _findInAllCachePartitions = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee16(cacheKey) {
+    var allCacheNames, appCaches, encodedCacheKey, _iterator2, _step2, cacheName, cache, response, _t11;
+    return _regenerator().w(function (_context16) {
+      while (1) switch (_context16.n) {
+        case 0:
+          if ('caches' in window) {
+            _context16.n = 1;
+            break;
+          }
+          return _context16.a(2, null);
+        case 1:
+          _context16.n = 2;
+          return caches.keys();
+        case 2:
+          allCacheNames = _context16.v;
+          appCaches = allCacheNames.filter(function (name) {
+            return name.startsWith(CACHE_NAME_PREFIX);
+          }); // Also try URL-encoded version of the key in case spaces/special chars were encoded
+          encodedCacheKey = encodeURI(cacheKey);
+          _iterator2 = _createForOfIteratorHelper(appCaches);
+          _context16.p = 3;
+          _iterator2.s();
+        case 4:
+          if ((_step2 = _iterator2.n()).done) {
+            _context16.n = 10;
+            break;
+          }
+          cacheName = _step2.value;
+          _context16.n = 5;
+          return caches.open(cacheName);
+        case 5:
+          cache = _context16.v;
+          _context16.n = 6;
+          return cache.match(cacheKey);
+        case 6:
+          response = _context16.v;
+          if (!response) {
+            _context16.n = 7;
+            break;
+          }
+          console.log("\u2705 [findInAllCachePartitions] Found in ".concat(cacheName, " (exact match): ").concat(cacheKey.substring(0, 80), "..."));
+          return _context16.a(2, response);
+        case 7:
+          if (!(encodedCacheKey !== cacheKey)) {
+            _context16.n = 9;
+            break;
+          }
+          _context16.n = 8;
+          return cache.match(encodedCacheKey);
+        case 8:
+          response = _context16.v;
+          if (!response) {
+            _context16.n = 9;
+            break;
+          }
+          console.log("\u2705 [findInAllCachePartitions] Found in ".concat(cacheName, " (encoded match): ").concat(encodedCacheKey.substring(0, 80), "..."));
+          return _context16.a(2, response);
+        case 9:
+          _context16.n = 4;
+          break;
+        case 10:
+          _context16.n = 12;
+          break;
+        case 11:
+          _context16.p = 11;
+          _t11 = _context16.v;
+          _iterator2.e(_t11);
+        case 12:
+          _context16.p = 12;
+          _iterator2.f();
+          return _context16.f(12);
+        case 13:
+          return _context16.a(2, null);
+      }
+    }, _callee16, null, [[3, 11, 12, 13]]);
+  }));
+  return _findInAllCachePartitions.apply(this, arguments);
+}
+function getCachedS3Object(_x4) {
+  return _getCachedS3Object.apply(this, arguments);
+}
+function _getCachedS3Object() {
+  _getCachedS3Object = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee19(s3Key) {
+    var storageOptions,
+      expiryMs,
+      cacheKey,
+      expiry,
+      cachedResponse,
+      cachedTime,
+      age,
+      _allKeys,
+      matchingKeys,
+      _args19 = arguments;
+    return _regenerator().w(function (_context19) {
+      while (1) switch (_context19.n) {
+        case 0:
+          storageOptions = _args19.length > 1 && _args19[1] !== undefined ? _args19[1] : {};
+          expiryMs = _args19.length > 2 && _args19[2] !== undefined ? _args19[2] : null;
+          cacheKey = "https://s3.cache/".concat(s3Key);
+          expiry = expiryMs || cacheManager.getExpiryForPath(s3Key);
+          console.log("\uD83D\uDD0D [S3Cache] Checking for cached S3 object:", {
+            s3Key: s3Key,
+            cacheKey: cacheKey
+          });
+
+          // First, check ALL app cache partitions for a hit (handles auth race condition)
+          _context19.n = 1;
+          return findInAllCachePartitions(cacheKey);
+        case 1:
+          cachedResponse = _context19.v;
+          if (!cachedResponse) {
+            _context19.n = 4;
+            break;
+          }
+          cachedTime = cachedResponse.headers.get('x-cached-time');
+          age = Date.now() - parseInt(cachedTime || '0');
+          console.log("\u2705 [S3Cache] Found in cache partition, age: ".concat(Math.round(age / 1000), "s, expiry: ").concat(Math.round(expiry / 1000), "s"));
+          if (!(age < expiry)) {
+            _context19.n = 3;
+            break;
+          }
+          console.log("\u2705 [S3Cache] Returning cached blob for: ".concat(s3Key));
+          _context19.n = 2;
+          return cachedResponse.blob();
+        case 2:
+          return _context19.a(2, _context19.v);
+        case 3:
+          console.log("\u23F0 [S3Cache] Cache entry expired, will re-fetch");
+          _context19.n = 6;
+          break;
+        case 4:
+          console.log("\u274C [S3Cache] Not found in any cache partition");
+          _context19.n = 5;
+          return getAllCacheKeys();
+        case 5:
+          _allKeys = _context19.v;
+          matchingKeys = _toConsumableArray(_allKeys).filter(function (k) {
+            return k.includes('24dd6a7a') || k.includes('.glb');
+          });
+          if (matchingKeys.length > 0) {
+            console.log("\uD83D\uDD0D [S3Cache] Available GLB cache keys:", matchingKeys.slice(0, 5));
+          }
+        case 6:
+          return _context19.a(2, cacheManager.execute({
+            cacheKey: cacheKey,
+            sourceKey: s3Key,
+            expiryMs: expiry,
+            fetcher: function () {
+              var _fetcher = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee17() {
+                var Storage, Auth, result, _result, _t12;
+                return _regenerator().w(function (_context17) {
+                  while (1) switch (_context17.n) {
+                    case 0:
+                      _context17.n = 1;
+                      return requireAuthentication();
+                    case 1:
+                      Storage = getStorage();
+                      Auth = getAuth$1();
+                      _context17.p = 2;
+                      _context17.n = 3;
+                      return Storage.get(s3Key, _objectSpread2(_objectSpread2({}, storageOptions), {}, {
+                        download: true
+                      }));
+                    case 3:
+                      result = _context17.v;
+                      return _context17.a(2, result.Body);
+                    case 4:
+                      _context17.p = 4;
+                      _t12 = _context17.v;
+                      if (!(_t12.code === 'ExpiredToken' || _t12.message && _t12.message.includes('ExpiredToken'))) {
+                        _context17.n = 7;
+                        break;
+                      }
+                      console.warn("\u26A0\uFE0F Token expired fetching S3 object. Refreshing credentials and retrying...");
+                      _context17.n = 5;
+                      return Auth.currentCredentials({
+                        bypassCache: true
+                      });
+                    case 5:
+                      _context17.n = 6;
+                      return Storage.get(s3Key, _objectSpread2(_objectSpread2({}, storageOptions), {}, {
+                        download: true
+                      }));
+                    case 6:
+                      _result = _context17.v;
+                      return _context17.a(2, _result.Body);
+                    case 7:
+                      throw _t12;
+                    case 8:
+                      return _context17.a(2);
+                  }
+                }, _callee17, null, [[2, 4]]);
+              }));
+              function fetcher() {
+                return _fetcher.apply(this, arguments);
+              }
+              return fetcher;
+            }(),
+            processor: function () {
+              var _processor = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee18(res) {
+                return _regenerator().w(function (_context18) {
+                  while (1) switch (_context18.n) {
+                    case 0:
+                      if (!(res instanceof Response)) {
+                        _context18.n = 2;
+                        break;
+                      }
+                      _context18.n = 1;
+                      return res.blob();
+                    case 1:
+                      return _context18.a(2, _context18.v);
+                    case 2:
+                      return _context18.a(2, res);
+                  }
+                }, _callee18);
+              }));
+              function processor(_x18) {
+                return _processor.apply(this, arguments);
+              }
+              return processor;
+            }(),
+            logType: 'S3 Object'
+          }));
+      }
+    }, _callee19);
+  }));
+  return _getCachedS3Object.apply(this, arguments);
+}
+function getCachedS3ObjectURL(_x5) {
+  return _getCachedS3ObjectURL.apply(this, arguments);
+}
+function _getCachedS3ObjectURL() {
+  _getCachedS3ObjectURL = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee20(s3Key) {
+    var storageOptions,
+      expiryMs,
+      blob,
+      _args20 = arguments;
+    return _regenerator().w(function (_context20) {
+      while (1) switch (_context20.n) {
+        case 0:
+          storageOptions = _args20.length > 1 && _args20[1] !== undefined ? _args20[1] : {};
+          expiryMs = _args20.length > 2 && _args20[2] !== undefined ? _args20[2] : null;
+          _context20.n = 1;
+          return getCachedS3Object(s3Key, storageOptions, expiryMs);
+        case 1:
+          blob = _context20.v;
+          return _context20.a(2, URL.createObjectURL(blob));
+      }
+    }, _callee20);
+  }));
+  return _getCachedS3ObjectURL.apply(this, arguments);
+}
+function preloadS3Objects(_x6) {
+  return _preloadS3Objects.apply(this, arguments);
+}
+function _preloadS3Objects() {
+  _preloadS3Objects = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee22(s3Keys) {
+    var storageOptions,
+      results,
+      _args22 = arguments;
+    return _regenerator().w(function (_context22) {
+      while (1) switch (_context22.n) {
+        case 0:
+          storageOptions = _args22.length > 1 && _args22[1] !== undefined ? _args22[1] : {};
+          results = {
+            success: 0,
+            failed: 0,
+            errors: []
+          };
+          _context22.n = 1;
+          return Promise.all(s3Keys.map(/*#__PURE__*/function () {
+            var _ref4 = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee21(key) {
+              var _t13;
+              return _regenerator().w(function (_context21) {
+                while (1) switch (_context21.n) {
+                  case 0:
+                    _context21.p = 0;
+                    _context21.n = 1;
+                    return getCachedS3Object(key, storageOptions);
+                  case 1:
+                    results.success++;
+                    _context21.n = 3;
+                    break;
+                  case 2:
+                    _context21.p = 2;
+                    _t13 = _context21.v;
+                    results.failed++;
+                    results.errors.push({
+                      key: key,
+                      error: _t13.message
+                    });
+                  case 3:
+                    return _context21.a(2);
+                }
+              }, _callee21, null, [[0, 2]]);
+            }));
+            return function (_x19) {
+              return _ref4.apply(this, arguments);
+            };
+          }()));
+        case 1:
+          console.log("\u2705 Preload complete: ".concat(results.success, " success, ").concat(results.failed, " failed"));
+          return _context22.a(2, results);
+      }
+    }, _callee22);
+  }));
+  return _preloadS3Objects.apply(this, arguments);
+}
+function getCachedS3Json(_x7) {
+  return _getCachedS3Json.apply(this, arguments);
+}
+function _getCachedS3Json() {
+  _getCachedS3Json = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee24(s3Key) {
+    var storageOptions,
+      expiryMs,
+      _args24 = arguments;
+    return _regenerator().w(function (_context24) {
+      while (1) switch (_context24.n) {
+        case 0:
+          storageOptions = _args24.length > 1 && _args24[1] !== undefined ? _args24[1] : {};
+          expiryMs = _args24.length > 2 && _args24[2] !== undefined ? _args24[2] : null;
+          return _context24.a(2, cacheManager.execute({
+            cacheKey: "https://s3.cache/".concat(s3Key),
+            sourceKey: s3Key,
+            expiryMs: expiryMs || cacheManager.getExpiryForPath(s3Key),
+            fetcher: function () {
+              var _fetcher2 = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee23() {
+                var Storage, Auth, signedUrl, _signedUrl, _t14;
+                return _regenerator().w(function (_context23) {
+                  while (1) switch (_context23.n) {
+                    case 0:
+                      _context23.n = 1;
+                      return requireAuthentication();
+                    case 1:
+                      Storage = getStorage();
+                      Auth = getAuth$1();
+                      _context23.p = 2;
+                      _context23.n = 3;
+                      return Storage.get(s3Key, _objectSpread2(_objectSpread2({}, storageOptions), {}, {
+                        customPrefix: {
+                          public: ''
+                        }
+                      }));
+                    case 3:
+                      signedUrl = _context23.v;
+                      return _context23.a(2, fetch(signedUrl));
+                    case 4:
+                      _context23.p = 4;
+                      _t14 = _context23.v;
+                      if (!(_t14.code === 'ExpiredToken' || _t14.message && _t14.message.includes('ExpiredToken'))) {
+                        _context23.n = 7;
+                        break;
+                      }
+                      console.warn("\u26A0\uFE0F Token expired fetching S3 JSON. Refreshing credentials and retrying...");
+                      _context23.n = 5;
+                      return Auth.currentCredentials({
+                        bypassCache: true
+                      });
+                    case 5:
+                      _context23.n = 6;
+                      return Storage.get(s3Key, _objectSpread2(_objectSpread2({}, storageOptions), {}, {
+                        customPrefix: {
+                          public: ''
+                        }
+                      }));
+                    case 6:
+                      _signedUrl = _context23.v;
+                      return _context23.a(2, fetch(_signedUrl));
+                    case 7:
+                      throw _t14;
+                    case 8:
+                      return _context23.a(2);
+                  }
+                }, _callee23, null, [[2, 4]]);
+              }));
+              function fetcher() {
+                return _fetcher2.apply(this, arguments);
+              }
+              return fetcher;
+            }(),
+            processor: function processor(res) {
+              return res.json();
+            },
+            logType: 'S3 JSON'
+          }));
+      }
+    }, _callee24);
+  }));
+  return _getCachedS3Json.apply(this, arguments);
+}
+function getCachedLocalJson(_x8) {
+  return _getCachedLocalJson.apply(this, arguments);
+}
+function _getCachedLocalJson() {
+  _getCachedLocalJson = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee25(localPath) {
+    return _regenerator().w(function (_context25) {
+      while (1) switch (_context25.n) {
+        case 0:
+          return _context25.a(2, executeGlobal({
+            cacheKey: "https://local.cache".concat(localPath),
+            fetcher: function fetcher() {
+              return fetch(localPath);
+            },
+            processor: function processor(res) {
+              return res.json();
+            },
+            metadata: {
+              'x-local-path': localPath
+            }
+          }));
+      }
+    }, _callee25);
+  }));
+  return _getCachedLocalJson.apply(this, arguments);
+}
+function getCachedLocalFile(_x9) {
+  return _getCachedLocalFile.apply(this, arguments);
+}
+function _getCachedLocalFile() {
+  _getCachedLocalFile = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee26(url) {
+    return _regenerator().w(function (_context26) {
+      while (1) switch (_context26.n) {
+        case 0:
+          if (!(!url || url.includes('undefined') || url.includes('null'))) {
+            _context26.n = 1;
+            break;
+          }
+          throw new Error("Invalid URL: ".concat(url));
+        case 1:
+          return _context26.a(2, executeGlobal({
+            cacheKey: "https://local.cache".concat(url),
+            fetcher: function fetcher() {
+              return fetch(url);
+            },
+            processor: function processor(res) {
+              return res.blob();
+            },
+            metadata: {
+              'x-local-path': url
+            }
+          }));
+      }
+    }, _callee26);
+  }));
+  return _getCachedLocalFile.apply(this, arguments);
+}
+function getCachedLocalFileURL(_x0) {
+  return _getCachedLocalFileURL.apply(this, arguments);
+}
+function _getCachedLocalFileURL() {
+  _getCachedLocalFileURL = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee27(url) {
+    var expiryMs,
+      blob,
+      _args27 = arguments;
+    return _regenerator().w(function (_context27) {
+      while (1) switch (_context27.n) {
+        case 0:
+          expiryMs = _args27.length > 1 && _args27[1] !== undefined ? _args27[1] : null;
+          _context27.n = 1;
+          return getCachedLocalFile(url, expiryMs);
+        case 1:
+          blob = _context27.v;
+          return _context27.a(2, URL.createObjectURL(blob));
+      }
+    }, _callee27);
+  }));
+  return _getCachedLocalFileURL.apply(this, arguments);
+}
+function preloadLocalFiles(_x1) {
+  return _preloadLocalFiles.apply(this, arguments);
+}
+
+// --- Arbitrary JSON Helpers ---
+function _preloadLocalFiles() {
+  _preloadLocalFiles = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee29(urls) {
+    var results;
+    return _regenerator().w(function (_context29) {
+      while (1) switch (_context29.n) {
+        case 0:
+          console.log("preloadLocalFiles started");
+          results = {
+            success: 0,
+            failed: 0,
+            errors: []
+          };
+          _context29.n = 1;
+          return Promise.all(urls.map(/*#__PURE__*/function () {
+            var _ref5 = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee28(url) {
+              var _t15;
+              return _regenerator().w(function (_context28) {
+                while (1) switch (_context28.n) {
+                  case 0:
+                    _context28.p = 0;
+                    _context28.n = 1;
+                    return getCachedLocalFile(url);
+                  case 1:
+                    results.success++;
+                    _context28.n = 3;
+                    break;
+                  case 2:
+                    _context28.p = 2;
+                    _t15 = _context28.v;
+                    console.error("\u274C preloadLocalFiles Preload failed for ".concat(url, ":"), _t15);
+                    results.failed++;
+                    results.errors.push({
+                      url: url,
+                      error: _t15.message
+                    });
+                  case 3:
+                    return _context28.a(2);
+                }
+              }, _callee28, null, [[0, 2]]);
+            }));
+            return function (_x20) {
+              return _ref5.apply(this, arguments);
+            };
+          }()));
+        case 1:
+          console.log("preloadLocalFiles finished");
+          if (results.failed > 0) {
+            console.warn("\u26A0\uFE0F preloadLocalFiles Cache priming finished with errors: ".concat(results.failed, " failed"), results.errors);
+          }
+          return _context29.a(2, results);
+      }
+    }, _callee29);
+  }));
+  return _preloadLocalFiles.apply(this, arguments);
+}
+function cacheJsonData(_x10, _x11) {
+  return _cacheJsonData.apply(this, arguments);
+}
+function _cacheJsonData() {
+  _cacheJsonData = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee32(key, data) {
+    var expiryMs,
+      cacheKey,
+      _args32 = arguments;
+    return _regenerator().w(function (_context32) {
+      while (1) switch (_context32.n) {
+        case 0:
+          expiryMs = _args32.length > 2 && _args32[2] !== undefined ? _args32[2] : CACHE_EXPIRY.JSON;
+          cacheKey = "https://json.cache/".concat(key); // Delete existing entry first to ensure we overwrite with new data
+          _context32.n = 1;
+          return cacheManager.delete(cacheKey);
+        case 1:
+          return _context32.a(2, cacheManager.execute({
+            cacheKey: cacheKey,
+            sourceKey: key,
+            expiryMs: expiryMs,
+            fetcher: function () {
+              var _fetcher3 = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee30() {
+                return _regenerator().w(function (_context30) {
+                  while (1) switch (_context30.n) {
+                    case 0:
+                      return _context30.a(2, new Response(JSON.stringify(data), {
+                        headers: {
+                          'Content-Type': 'application/json'
+                        }
+                      }));
+                  }
+                }, _callee30);
+              }));
+              function fetcher() {
+                return _fetcher3.apply(this, arguments);
+              }
+              return fetcher;
+            }(),
+            processor: function () {
+              var _processor2 = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee31(res) {
+                return _regenerator().w(function (_context31) {
+                  while (1) switch (_context31.n) {
+                    case 0:
+                      return _context31.a(2, data);
+                  }
+                }, _callee31);
+              }));
+              function processor(_x21) {
+                return _processor2.apply(this, arguments);
+              }
+              return processor;
+            }(),
+            // Return the original data to the caller
+            logType: 'Arbitrary JSON'
+          }).then(function () {
+            return true;
+          }).catch(function (e) {
+            console.error("Failed to cache JSON data ".concat(key, ":"), e);
+            return false;
+          }));
+      }
+    }, _callee32);
+  }));
+  return _cacheJsonData.apply(this, arguments);
+}
+function getCachedJsonData(_x12) {
+  return _getCachedJsonData.apply(this, arguments);
+}
+function _getCachedJsonData() {
+  _getCachedJsonData = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee34(key) {
+    var expiryMs,
+      _args34 = arguments;
+    return _regenerator().w(function (_context34) {
+      while (1) switch (_context34.n) {
+        case 0:
+          expiryMs = _args34.length > 1 && _args34[1] !== undefined ? _args34[1] : CACHE_EXPIRY.JSON;
+          return _context34.a(2, cacheManager.get("https://json.cache/".concat(key), expiryMs, /*#__PURE__*/function () {
+            var _ref6 = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee33(r) {
+              return _regenerator().w(function (_context33) {
+                while (1) switch (_context33.n) {
+                  case 0:
+                    return _context33.a(2, r.json());
+                }
+              }, _callee33);
+            }));
+            return function (_x22) {
+              return _ref6.apply(this, arguments);
+            };
+          }()));
+      }
+    }, _callee34);
+  }));
+  return _getCachedJsonData.apply(this, arguments);
+}
+function removeCachedJsonData(_x13) {
+  return _removeCachedJsonData.apply(this, arguments);
+}
+
+// --- Thumbnails ---
+function _removeCachedJsonData() {
+  _removeCachedJsonData = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee35(key) {
+    return _regenerator().w(function (_context35) {
+      while (1) switch (_context35.n) {
+        case 0:
+          return _context35.a(2, cacheManager.delete("https://json.cache/".concat(key)));
+      }
+    }, _callee35);
+  }));
+  return _removeCachedJsonData.apply(this, arguments);
+}
+function getThumbnailKey(asset) {
+  var thumbnailKey = asset.thumbnailS3Path;
+  if (!thumbnailKey && asset.s3Path) {
+    var uuid = asset.uuid || asset.id;
+    var thumbnailFilename = "".concat(uuid, ".png");
+    thumbnailKey = "".concat(asset.s3Path, "/").concat(thumbnailFilename);
+  }
+  return thumbnailKey || null;
+}
+function isThumbnailCached(_x14) {
+  return _isThumbnailCached.apply(this, arguments);
+}
+function _isThumbnailCached() {
+  _isThumbnailCached = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee36(asset) {
+    var isS3Asset, key;
+    return _regenerator().w(function (_context36) {
+      while (1) switch (_context36.n) {
+        case 0:
+          // Match the isS3Component logic: isS3Component || source === 's3' || scope === 'user'
+          isS3Asset = asset.isS3Component || asset.source === 's3' || asset.scope === 'user';
+          if (isS3Asset) {
+            _context36.n = 1;
+            break;
+          }
+          return _context36.a(2, true);
+        case 1:
+          key = getThumbnailKey(asset);
+          if (key) {
+            _context36.n = 2;
+            break;
+          }
+          return _context36.a(2, false);
+        case 2:
+          return _context36.a(2, isCached(key));
+      }
+    }, _callee36);
+  }));
+  return _isThumbnailCached.apply(this, arguments);
+}
+function isCached(_x15) {
+  return _isCached.apply(this, arguments);
+}
+
+// --- Path/Expiry Helpers ---
+function _isCached() {
+  _isCached = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee37(s3Key) {
+    var expiryMs,
+      _args37 = arguments;
+    return _regenerator().w(function (_context37) {
+      while (1) switch (_context37.n) {
+        case 0:
+          expiryMs = _args37.length > 1 && _args37[1] !== undefined ? _args37[1] : null;
+          return _context37.a(2, cacheManager.has("https://s3.cache/".concat(s3Key), expiryMs));
+      }
+    }, _callee37);
+  }));
+  return _isCached.apply(this, arguments);
+}
+function getCacheExpiryForPath(path) {
+  var assetType = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
+  return cacheManager.getExpiryForPath(path, assetType);
+}
+function formatCacheExpiry(ms) {
+  var SECOND = 1000;
+  var MINUTE = 60 * SECOND;
+  var HOUR = 60 * MINUTE;
+  var DAY = 24 * HOUR;
+  var WEEK = 7 * DAY;
+  if (ms >= WEEK) return "".concat((ms / WEEK).toFixed(1), " week(s)");
+  if (ms >= DAY) return "".concat((ms / DAY).toFixed(1), " day(s)");
+  if (ms >= HOUR) return "".concat((ms / HOUR).toFixed(1), " hour(s)");
+  return "".concat((ms / 1000 / 60).toFixed(1), " minute(s)");
+}
+
+var CACHE_KEY = 's3-component-metadata';
+var CACHE_VERSION = 1;
+
+/**
+ * Simple mutex implementation for preventing concurrent read-modify-write operations
+ */
+var SimpleMutex = /*#__PURE__*/function () {
+  function SimpleMutex() {
+    _classCallCheck(this, SimpleMutex);
+    this._locked = false;
+    this._queue = [];
+  }
+  return _createClass(SimpleMutex, [{
+    key: "acquire",
+    value: function () {
+      var _acquire = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee() {
+        var _this = this;
+        return _regenerator().w(function (_context) {
+          while (1) switch (_context.n) {
+            case 0:
+              return _context.a(2, new Promise(function (resolve) {
+                if (!_this._locked) {
+                  _this._locked = true;
+                  resolve();
+                } else {
+                  _this._queue.push(resolve);
+                }
+              }));
+          }
+        }, _callee);
+      }));
+      function acquire() {
+        return _acquire.apply(this, arguments);
+      }
+      return acquire;
+    }()
+  }, {
+    key: "release",
+    value: function release() {
+      if (this._queue.length > 0) {
+        var next = this._queue.shift();
+        next();
+      } else {
+        this._locked = false;
+      }
+    }
+  }]);
+}();
+var S3MetadataCacheService = /*#__PURE__*/function () {
+  function S3MetadataCacheService() {
+    _classCallCheck(this, S3MetadataCacheService);
+    this._mutex = new SimpleMutex();
+    this._memoryCache = null;
+    this._memoryCacheTime = 0;
+    this._memoryCacheTTL = 5000; // 5 seconds in-memory cache
+  }
+
+  /**
+   * Create empty metadata structure
+   */
+  return _createClass(S3MetadataCacheService, [{
+    key: "_createEmptyMetadata",
+    value: function _createEmptyMetadata() {
+      return {
+        version: CACHE_VERSION,
+        components: [],
+        timestamp: Date.now()
+      };
+    }
+
+    /**
+     * Validate and migrate metadata if needed
+     */
+  }, {
+    key: "_validateMetadata",
+    value: function _validateMetadata(metadata) {
+      if (!metadata) {
+        return this._createEmptyMetadata();
+      }
+
+      // Ensure components array exists
+      if (!Array.isArray(metadata.components)) {
+        metadata.components = [];
+      }
+
+      // Add version if missing (for legacy cache)
+      if (metadata.version === undefined) {
+        metadata.version = CACHE_VERSION;
+      }
+      return metadata;
+    }
+
+    /**
+     * Check if memory cache is still valid
+     */
+  }, {
+    key: "_isMemoryCacheValid",
+    value: function _isMemoryCacheValid() {
+      return this._memoryCache !== null && Date.now() - this._memoryCacheTime < this._memoryCacheTTL;
+    }
+
+    /**
+     * Invalidate the memory cache
+     */
+  }, {
+    key: "_invalidateMemoryCache",
+    value: function _invalidateMemoryCache() {
+      this._memoryCache = null;
+      this._memoryCacheTime = 0;
+    }
+
+    /**
+     * Get all cached components
+     * @returns {Promise<Array>} Array of cached component metadata
+     */
+  }, {
+    key: "getAll",
+    value: (function () {
+      var _getAll = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee2() {
+        var metadata, validated, _t;
+        return _regenerator().w(function (_context2) {
+          while (1) switch (_context2.n) {
+            case 0:
+              if (!this._isMemoryCacheValid()) {
+                _context2.n = 1;
+                break;
+              }
+              return _context2.a(2, _toConsumableArray(this._memoryCache.components));
+            case 1:
+              _context2.p = 1;
+              _context2.n = 2;
+              return getCachedJsonData(CACHE_KEY);
+            case 2:
+              metadata = _context2.v;
+              validated = this._validateMetadata(metadata); // Update memory cache
+              this._memoryCache = validated;
+              this._memoryCacheTime = Date.now();
+              return _context2.a(2, _toConsumableArray(validated.components));
+            case 3:
+              _context2.p = 3;
+              _t = _context2.v;
+              console.warn('⚠️ S3MetadataCacheService: Failed to get components:', _t);
+              return _context2.a(2, []);
+          }
+        }, _callee2, this, [[1, 3]]);
+      }));
+      function getAll() {
+        return _getAll.apply(this, arguments);
+      }
+      return getAll;
+    }()
+    /**
+     * Get the full metadata object (for advanced use cases)
+     * @returns {Promise<Object>} Full metadata object with version, components, timestamp
+     */
+    )
+  }, {
+    key: "getMetadata",
+    value: (function () {
+      var _getMetadata = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee3() {
+        var metadata, validated, _t2;
+        return _regenerator().w(function (_context3) {
+          while (1) switch (_context3.n) {
+            case 0:
+              if (!this._isMemoryCacheValid()) {
+                _context3.n = 1;
+                break;
+              }
+              return _context3.a(2, _objectSpread2({}, this._memoryCache));
+            case 1:
+              _context3.p = 1;
+              _context3.n = 2;
+              return getCachedJsonData(CACHE_KEY);
+            case 2:
+              metadata = _context3.v;
+              validated = this._validateMetadata(metadata);
+              this._memoryCache = validated;
+              this._memoryCacheTime = Date.now();
+              return _context3.a(2, _objectSpread2({}, validated));
+            case 3:
+              _context3.p = 3;
+              _t2 = _context3.v;
+              console.warn('⚠️ S3MetadataCacheService: Failed to get metadata:', _t2);
+              return _context3.a(2, this._createEmptyMetadata());
+          }
+        }, _callee3, this, [[1, 3]]);
+      }));
+      function getMetadata() {
+        return _getMetadata.apply(this, arguments);
+      }
+      return getMetadata;
+    }()
+    /**
+     * Add or update a component in the cache
+     * Uses mutex to prevent race conditions
+     * @param {Object} component - Component metadata to add/update
+     * @returns {Promise<boolean>} Success status
+     */
+    )
+  }, {
+    key: "addComponent",
+    value: (function () {
+      var _addComponent = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee4(component) {
+        var metadata, validated, existingIndex, _t3;
+        return _regenerator().w(function (_context4) {
+          while (1) switch (_context4.n) {
+            case 0:
+              if (!(!component || !component.id && !component.uuid)) {
+                _context4.n = 1;
+                break;
+              }
+              console.warn('⚠️ S3MetadataCacheService: Cannot add component without id or uuid');
+              return _context4.a(2, false);
+            case 1:
+              _context4.n = 2;
+              return this._mutex.acquire();
+            case 2:
+              _context4.p = 2;
+              _context4.n = 3;
+              return getCachedJsonData(CACHE_KEY);
+            case 3:
+              metadata = _context4.v;
+              validated = this._validateMetadata(metadata); // Remove existing entry if it exists (by id or uuid)
+              existingIndex = validated.components.findIndex(function (c) {
+                return c.id === component.id || c.uuid === component.uuid || component.id && c.uuid === component.id || component.uuid && c.id === component.uuid;
+              });
+              if (existingIndex !== -1) {
+                validated.components.splice(existingIndex, 1);
+              }
+
+              // Add new component
+              validated.components.push(component);
+              validated.timestamp = Date.now();
+
+              // Write back to cache
+              _context4.n = 4;
+              return cacheJsonData(CACHE_KEY, validated);
+            case 4:
+              // Update memory cache
+              this._memoryCache = validated;
+              this._memoryCacheTime = Date.now();
+              console.log("\uD83D\uDCBE S3MetadataCacheService: Added/updated component ".concat(component.name || component.id));
+              return _context4.a(2, true);
+            case 5:
+              _context4.p = 5;
+              _t3 = _context4.v;
+              console.error('❌ S3MetadataCacheService: Failed to add component:', _t3);
+              return _context4.a(2, false);
+            case 6:
+              _context4.p = 6;
+              this._mutex.release();
+              return _context4.f(6);
+            case 7:
+              return _context4.a(2);
+          }
+        }, _callee4, this, [[2, 5, 6, 7]]);
+      }));
+      function addComponent(_x) {
+        return _addComponent.apply(this, arguments);
+      }
+      return addComponent;
+    }()
+    /**
+     * Remove a component from the cache
+     * Uses mutex to prevent race conditions
+     * @param {string} identifier - Component id or uuid to remove
+     * @returns {Promise<boolean>} Success status
+     */
+    )
+  }, {
+    key: "removeComponent",
+    value: (function () {
+      var _removeComponent = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee5(identifier) {
+        var metadata, validated, originalLength, removed, _t4;
+        return _regenerator().w(function (_context5) {
+          while (1) switch (_context5.n) {
+            case 0:
+              if (identifier) {
+                _context5.n = 1;
+                break;
+              }
+              console.warn('⚠️ S3MetadataCacheService: Cannot remove component without identifier');
+              return _context5.a(2, false);
+            case 1:
+              _context5.n = 2;
+              return this._mutex.acquire();
+            case 2:
+              _context5.p = 2;
+              _context5.n = 3;
+              return getCachedJsonData(CACHE_KEY);
+            case 3:
+              metadata = _context5.v;
+              if (!(!metadata || !metadata.components)) {
+                _context5.n = 4;
+                break;
+              }
+              console.log('ℹ️ S3MetadataCacheService: No metadata to remove from');
+              return _context5.a(2, true);
+            case 4:
+              validated = this._validateMetadata(metadata);
+              originalLength = validated.components.length; // Filter out the component by both id and uuid
+              validated.components = validated.components.filter(function (c) {
+                return c.id !== identifier && c.uuid !== identifier;
+              });
+              removed = originalLength !== validated.components.length;
+              if (!removed) {
+                _context5.n = 6;
+                break;
+              }
+              validated.timestamp = Date.now();
+              _context5.n = 5;
+              return cacheJsonData(CACHE_KEY, validated);
+            case 5:
+              // Update memory cache
+              this._memoryCache = validated;
+              this._memoryCacheTime = Date.now();
+              console.log("\uD83D\uDDD1\uFE0F S3MetadataCacheService: Removed component ".concat(identifier));
+            case 6:
+              return _context5.a(2, true);
+            case 7:
+              _context5.p = 7;
+              _t4 = _context5.v;
+              console.error('❌ S3MetadataCacheService: Failed to remove component:', _t4);
+              return _context5.a(2, false);
+            case 8:
+              _context5.p = 8;
+              this._mutex.release();
+              return _context5.f(8);
+            case 9:
+              return _context5.a(2);
+          }
+        }, _callee5, this, [[2, 7, 8, 9]]);
+      }));
+      function removeComponent(_x2) {
+        return _removeComponent.apply(this, arguments);
+      }
+      return removeComponent;
+    }()
+    /**
+     * Clear all cached metadata
+     * @returns {Promise<boolean>} Success status
+     */
+    )
+  }, {
+    key: "clear",
+    value: (function () {
+      var _clear = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee6() {
+        var _t5;
+        return _regenerator().w(function (_context6) {
+          while (1) switch (_context6.n) {
+            case 0:
+              _context6.n = 1;
+              return this._mutex.acquire();
+            case 1:
+              _context6.p = 1;
+              _context6.n = 2;
+              return removeCachedJsonData(CACHE_KEY);
+            case 2:
+              this._invalidateMemoryCache();
+              console.log('🗑️ S3MetadataCacheService: Cleared all metadata');
+              return _context6.a(2, true);
+            case 3:
+              _context6.p = 3;
+              _t5 = _context6.v;
+              console.error('❌ S3MetadataCacheService: Failed to clear metadata:', _t5);
+              return _context6.a(2, false);
+            case 4:
+              _context6.p = 4;
+              this._mutex.release();
+              return _context6.f(4);
+            case 5:
+              return _context6.a(2);
+          }
+        }, _callee6, this, [[1, 3, 4, 5]]);
+      }));
+      function clear() {
+        return _clear.apply(this, arguments);
+      }
+      return clear;
+    }()
+    /**
+     * Check if a component exists in the cache
+     * @param {string} identifier - Component id or uuid
+     * @returns {Promise<boolean>} True if exists
+     */
+    )
+  }, {
+    key: "hasComponent",
+    value: (function () {
+      var _hasComponent = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee7(identifier) {
+        var components;
+        return _regenerator().w(function (_context7) {
+          while (1) switch (_context7.n) {
+            case 0:
+              _context7.n = 1;
+              return this.getAll();
+            case 1:
+              components = _context7.v;
+              return _context7.a(2, components.some(function (c) {
+                return c.id === identifier || c.uuid === identifier;
+              }));
+          }
+        }, _callee7, this);
+      }));
+      function hasComponent(_x3) {
+        return _hasComponent.apply(this, arguments);
+      }
+      return hasComponent;
+    }()
+    /**
+     * Force refresh from persistent cache (bypass memory cache)
+     * @returns {Promise<Array>} Array of cached components
+     */
+    )
+  }, {
+    key: "refresh",
+    value: (function () {
+      var _refresh = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee8() {
+        return _regenerator().w(function (_context8) {
+          while (1) switch (_context8.n) {
+            case 0:
+              this._invalidateMemoryCache();
+              return _context8.a(2, this.getAll());
+          }
+        }, _callee8, this);
+      }));
+      function refresh() {
+        return _refresh.apply(this, arguments);
+      }
+      return refresh;
+    }()
+    /**
+     * Replace all cached components with a new array
+     * Used for bulk operations like initial fetch
+     * @param {Array} components - Array of components to cache
+     * @returns {Promise<boolean>} Success status
+     */
+    )
+  }, {
+    key: "setAll",
+    value: (function () {
+      var _setAll = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee9(components) {
+        var metadata, _t6;
+        return _regenerator().w(function (_context9) {
+          while (1) switch (_context9.n) {
+            case 0:
+              if (Array.isArray(components)) {
+                _context9.n = 1;
+                break;
+              }
+              console.warn('⚠️ S3MetadataCacheService: setAll requires an array');
+              return _context9.a(2, false);
+            case 1:
+              _context9.n = 2;
+              return this._mutex.acquire();
+            case 2:
+              _context9.p = 2;
+              metadata = {
+                version: CACHE_VERSION,
+                components: components,
+                timestamp: Date.now()
+              };
+              _context9.n = 3;
+              return cacheJsonData(CACHE_KEY, metadata);
+            case 3:
+              // Update memory cache
+              this._memoryCache = metadata;
+              this._memoryCacheTime = Date.now();
+              console.log("\uD83D\uDCBE S3MetadataCacheService: Set ".concat(components.length, " components"));
+              return _context9.a(2, true);
+            case 4:
+              _context9.p = 4;
+              _t6 = _context9.v;
+              console.error('❌ S3MetadataCacheService: Failed to set components:', _t6);
+              return _context9.a(2, false);
+            case 5:
+              _context9.p = 5;
+              this._mutex.release();
+              return _context9.f(5);
+            case 6:
+              return _context9.a(2);
+          }
+        }, _callee9, this, [[2, 4, 5, 6]]);
+      }));
+      function setAll(_x4) {
+        return _setAll.apply(this, arguments);
+      }
+      return setAll;
+    }())
+  }]);
+}(); // Export singleton instance
+var s3MetadataCache = new S3MetadataCacheService();
+
+/**
+ * Retrieve the injected Auth instance from cacheManager config.
+ * Falls back gracefully if not configured (skip credential refresh).
+ */
+function getAuth() {
+  return cacheManager.config.auth || null;
+}
+
+/**
+ * Measure S3 operation time and log results
+ * @param {string} operation - Operation name (e.g., "Upload GLB", "Download JSON")
+ * @param {Function} asyncFn - Async function to measure
+ * @param {number} fileSize - Optional file size in bytes for speed calculation
+ * @returns {Promise} - Result from asyncFn
+ */
+function measureS3Transfer(_x, _x2) {
+  return _measureS3Transfer.apply(this, arguments);
+}
+function _measureS3Transfer() {
+  _measureS3Transfer = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee2(operation, asyncFn) {
+    var fileSize,
+      startTime,
+      executeTransfer,
+      Auth,
+      endTime,
+      duration,
+      _args2 = arguments,
+      _t,
+      _t2;
+    return _regenerator().w(function (_context2) {
+      while (1) switch (_context2.n) {
+        case 0:
+          fileSize = _args2.length > 2 && _args2[2] !== undefined ? _args2[2] : null;
+          startTime = performance.now();
+          executeTransfer = /*#__PURE__*/function () {
+            var _ref = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee() {
+              var result, endTime, duration, logMessage, sizeMB, speedMBps;
+              return _regenerator().w(function (_context) {
+                while (1) switch (_context.n) {
+                  case 0:
+                    _context.n = 1;
+                    return asyncFn();
+                  case 1:
+                    result = _context.v;
+                    endTime = performance.now();
+                    duration = ((endTime - startTime) / 1000).toFixed(3); // Convert to seconds
+                    logMessage = "\u23F1\uFE0F S3 ".concat(operation, ": ").concat(duration, "s");
+                    if (fileSize) {
+                      sizeMB = (fileSize / (1024 * 1024)).toFixed(2);
+                      speedMBps = (sizeMB / duration).toFixed(2);
+                      logMessage += " (".concat(sizeMB, " MB @ ").concat(speedMBps, " MB/s)");
+                    }
+                    console.log(logMessage);
+                    return _context.a(2, result);
+                }
+              }, _callee);
+            }));
+            return function executeTransfer() {
+              return _ref.apply(this, arguments);
+            };
+          }();
+          _context2.p = 1;
+          _context2.n = 2;
+          return executeTransfer();
+        case 2:
+          return _context2.a(2, _context2.v);
+        case 3:
+          _context2.p = 3;
+          _t = _context2.v;
+          if (!(_t.code === 'ExpiredToken' || _t.message && _t.message.includes('ExpiredToken'))) {
+            _context2.n = 8;
+            break;
+          }
+          console.warn("\u26A0\uFE0F Token expired during ".concat(operation, ". Attempting session refresh and retry..."));
+          Auth = getAuth();
+          if (Auth) {
+            _context2.n = 4;
+            break;
+          }
+          console.error("\u274C Cannot refresh credentials: Auth not injected via cacheManager.configure({ auth })");
+          throw _t;
+        case 4:
+          _context2.p = 4;
+          _context2.n = 5;
+          return Auth.currentCredentials({
+            bypassCache: true
+          });
+        case 5:
+          console.log("\u2705 Session refreshed. Retrying ".concat(operation, "..."));
+
+          // Reset timer for the retry
+          startTime = performance.now();
+          _context2.n = 6;
+          return executeTransfer();
+        case 6:
+          return _context2.a(2, _context2.v);
+        case 7:
+          _context2.p = 7;
+          _t2 = _context2.v;
+          console.error("\u274C Retry failed for ".concat(operation, ":"), _t2);
+          // If retry fails, throw the Retry Error (likely unrelated or persistent auth issue)
+          throw _t2;
+        case 8:
+          // Standard error handling for non-expired tokens (or if logic above didn't catch it)
+          endTime = performance.now();
+          duration = ((endTime - startTime) / 1000).toFixed(3);
+          console.error("\u274C S3 ".concat(operation, " failed after ").concat(duration, "s:"), _t);
+          throw _t;
+        case 9:
+          return _context2.a(2);
+      }
+    }, _callee2, null, [[4, 7], [1, 3]]);
+  }));
+  return _measureS3Transfer.apply(this, arguments);
+}
+
 var Rendering2D = /*#__PURE__*/function (_BaseDisposable) {
   function Rendering2D(_canvas) {
     var _this;
@@ -44474,6 +46526,7 @@ exports.ComponentManager = ComponentManager;
 exports.ComponentTooltipManager = ComponentTooltipManager;
 exports.EnvironmentManager = EnvironmentManager;
 exports.FLOW_ATTRIBUTE_KEYS = FLOW_ATTRIBUTE_KEYS;
+exports.GLOBAL_CACHE_NAME = GLOBAL_CACHE_NAME;
 exports.KeyboardControlsManager = KeyboardControlsManager;
 exports.ModelManager = ModelManager;
 exports.OperationHistoryManager = OperationHistoryManager;
@@ -44483,6 +46536,7 @@ exports.PathfindingManager = PathfindingManager;
 exports.PerformanceMonitorManager = PerformanceMonitorManager;
 exports.Rendering2D = rendering2D;
 exports.Rendering3D = rendering3D;
+exports.S3MetadataCacheService = S3MetadataCacheService;
 exports.SceneExportManager = SceneExportManager;
 exports.SceneHierarchyManager = SceneHierarchyManager;
 exports.SceneInitializationManager = SceneInitializationManager;
@@ -44490,15 +46544,36 @@ exports.SceneOperationsManager = SceneOperationsManager;
 exports.SceneTooltipsManager = SceneTooltipsManager;
 exports.SnapshotManager = SnapshotManager;
 exports.ThreeJSResourceManager = ThreeJSResourceManager;
+exports.cacheJsonData = cacheJsonData;
 exports.cacheManager = cacheManager;
+exports.cleanExpiredCache = cleanExpiredCache;
+exports.cleanInvalidCacheEntries = cleanInvalidCacheEntries;
+exports.clearS3Cache = clearS3Cache;
 exports.createPathfindingRequest = createPathfindingRequest;
 exports.createTransformControls = createTransformControls;
 exports.findObjectByHardcodedUuid = findObjectByHardcodedUuid;
+exports.formatCacheExpiry = formatCacheExpiry;
 exports.generateUniqueComponentId = generateUniqueComponentId;
 exports.generateUuidFromName = generateUuidFromName;
+exports.getAllCacheKeys = getAllCacheKeys;
+exports.getCacheExpiryForPath = getCacheExpiryForPath;
+exports.getCacheStats = getCacheStats;
+exports.getCachedJsonData = getCachedJsonData;
+exports.getCachedLocalFile = getCachedLocalFile;
+exports.getCachedLocalFileURL = getCachedLocalFileURL;
+exports.getCachedLocalJson = getCachedLocalJson;
+exports.getCachedS3Json = getCachedS3Json;
+exports.getCachedS3Object = getCachedS3Object;
+exports.getCachedS3ObjectURL = getCachedS3ObjectURL;
+exports.getCurrentCacheName = getCurrentCacheName;
+exports.getGlobalCacheStats = getGlobalCacheStats;
+exports.getGlobalOnlyCacheStats = getGlobalOnlyCacheStats;
 exports.getHardcodedUuid = getHardcodedUuid;
 exports.getObjectTypeName = getObjectTypeName;
 exports.getObjectsByType = getObjectsByType;
+exports.getThumbnailKey = getThumbnailKey;
+exports.getUserOnlyCacheStats = getUserOnlyCacheStats;
+exports.isCached = isCached;
 exports.isComponent = isComponent;
 exports.isComputed = isComputed;
 exports.isConnector = isConnector;
@@ -44506,9 +46581,18 @@ exports.isDeclared = isDeclared;
 exports.isExportable = isExportable;
 exports.isGateway = isGateway;
 exports.isSegment = isSegment;
+exports.isThumbnailCached = isThumbnailCached;
 exports.loadTextureSetAndCreateMaterial = loadTextureSetAndCreateMaterial;
 exports.markAsComputed = markAsComputed;
 exports.markAsDeclared = markAsDeclared;
+exports.measureS3Transfer = measureS3Transfer;
 exports.modelPreloader = modelPreloader;
+exports.preloadLocalFiles = preloadLocalFiles;
+exports.preloadS3Objects = preloadS3Objects;
+exports.removeCachedJsonData = removeCachedJsonData;
+exports.resetCacheIdentity = resetCacheIdentity;
+exports.resetGlobalCacheStats = resetGlobalCacheStats;
+exports.s3MetadataCache = s3MetadataCache;
 exports.sceneViewer = sceneViewer;
 exports.shouldRemoveOnRegeneration = shouldRemoveOnRegeneration;
+exports.switchCachePartition = switchCachePartition;