@2112-lab/central-plant 0.2.12 → 0.3.1

package/dist/esm/src/managers/cache/S3CacheService.js

@@ -0,0 +1,1441 @@
+import { asyncToGenerator as _asyncToGenerator, regenerator as _regenerator, objectSpread2 as _objectSpread2, toConsumableArray as _toConsumableArray, createForOfIteratorHelper as _createForOfIteratorHelper } from '../../../_virtual/_rollupPluginBabelHelpers.js';
+import { cacheManager, CACHE_NAME_PREFIX, CACHE_EXPIRY } from './CacheManager.js';
+
+/**
+ * Retrieve the injected Auth instance. Throws if not configured.
+ */
+function getAuth() {
+  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().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();
+                      _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();
+                      _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)");
+}
+
+export { GLOBAL_CACHE_NAME, cacheJsonData, cleanExpiredCache, cleanInvalidCacheEntries, clearS3Cache, formatCacheExpiry, getAllCacheKeys, getCacheExpiryForPath, getCacheStats, getCachedJsonData, getCachedLocalFile, getCachedLocalFileURL, getCachedLocalJson, getCachedS3Json, getCachedS3Object, getCachedS3ObjectURL, getCurrentCacheName, getGlobalCacheStats, getGlobalOnlyCacheStats, getThumbnailKey, getUserOnlyCacheStats, isCached, isThumbnailCached, preloadLocalFiles, preloadS3Objects, removeCachedJsonData, resetCacheIdentity, resetGlobalCacheStats, switchCachePartition };