@zeniai/web-app-ui 5.0.27-dev → 5.0.28-dev

package/dist/service-worker.js

@@ -1,162 +1,130 @@
 // service-worker.js
-// v1.0.2 - Cache-bust helpers so SW + helpers always match after deploy
-//
-// Deployment: When changing this file or service-worker-helpers.js:
-// 1. Bump CACHE_VERSION below so old caches are dropped on activate.
-// 2. Deploy both service-worker.js and service-worker-helpers.js together.
-// 3. Helpers are loaded with the same query string as the SW (see importScripts
-//    below), so they are not served from cache after a new registration.
-// 4. Clients register with a cache-busting param; skipWaiting() + update flow
-//    ensure the new worker activates and users get the update without manual steps.
-//
-// Import helper functions (use same query as SW URL so helpers are not served from cache)
-importScripts("service-worker-helpers.js" + self.location.search);
 
 // Get environment variable from URL parameters
 const params = new URLSearchParams(self.location.search);
 const env = params.get("env");
 const endpointUrl = params.get("endpoint");
 
-// Cache versioning for clean cache management (bump on every SW/helpers deploy)
-const CACHE_VERSION = "v1.0.2"; // Increment this to force cache refresh
-const CACHE_NAME = `app-cache-${CACHE_VERSION}-${self.registration.scope}`;
-const API_CACHE_NAME = "api-prefetch-cache";
-const METADATA_CACHE_NAME = "api-cache-metadata";
+// Cache versioning for clean cache management
+const CACHE_NAME = `app-cache-${self.registration.scope}`;
 
 // Set polling interval (30 minutes for PROD, 10 minutes for other environments)
 const POLLING_INTERVAL =
   env === "PROD" || env === "NEXT" ? 0.5 * 60 * 60 * 1000 : 10 * 60 * 1000;
 
-// API Cache expiry duration (20 minutes default, configurable from app)
-let apiCacheDuration = 1000 * 60 * 20; // milliseconds
-
-// Cache size limits for memory management
-const MAX_CACHE_ENTRIES = 100; // Maximum number of cached URLs
-const MAX_CACHE_SIZE_MB = 50; // Maximum cache size in MB
-const LOW_STORAGE_THRESHOLD_MB = 100; // Alert if available storage < 100MB
-const CACHE_CLEANUP_INTERVAL = 1000 * 60 * 15; // Cleanup every 15 minutes
-
-// Cache eviction configuration (configurable percentages)
-const CACHE_SIZE_EXCEEDED_EVICTION_PERCENT = 0.2; // Evict 20% of entries when cache size limit exceeded
-const LOW_STORAGE_EVICTION_PERCENT = 0.5; // Evict 50% of entries when storage is critically low
-
-// Continuous prefetch configuration
-const PREFETCH_INTERVAL = 1000 * 60 * 20; // Re-prefetch every 20 minutes
-let prefetchIntervalId = null; // Store interval ID for cleanup
-let currentPrefetchJob = null; // Store current prefetch configuration
-
-// Interval tracking to prevent duplicates on re-activation
-let updateCheckIntervalId = null;
-let cacheMaintenanceIntervalId = null;
-
 // Incrased the popup hiding interval for PROD env after discussion with product team
 // Set auto hide interval (96 hours for PROD, 48 hours for other environments)
 const HIDING_INTERVAL =
   env === "PROD" || env === "NEXT" ? 96 * 60 * 60 * 1000 : 48 * 60 * 60 * 1000;
 
-// State object for update tracking (passed to helpers)
-const updateState = {
-  lastDeployedTime: null, // Track the last deployment time
-  updatePending: false, // Flag to track if new assets are available
-};
-
-// Whitelist of URLs that should be prefetched and cached
-// Key: normalized URL, Value: tenant_id (to support tenant-specific caching)
-const prefetchableURLs = new Map();
-
-// Track cache access times for LRU eviction
-const cacheAccessTimes = new Map(); // Key: cacheKey, Value: timestamp
-
-// Track page refresh state to bypass cache during refresh
-// Key: clientId (string), Value: timestamp when refresh was detected
-// Cache is bypassed for requests within REFRESH_BYPASS_WINDOW_MS of refresh
-const refreshTimestamps = new Map();
-const REFRESH_BYPASS_WINDOW_MS = 10000; // 10 seconds - bypass cache for 10 seconds after refresh
-
-// Cleanup expired refresh timestamps periodically
-setInterval(() => {
-  const now = Date.now();
-  for (const [clientId, timestamp] of refreshTimestamps.entries()) {
-    if (now - timestamp > REFRESH_BYPASS_WINDOW_MS) {
-      refreshTimestamps.delete(clientId);
-    }
-  }
-}, 5000); // Clean up every 5 seconds
-
-// Initialize logging helpers first (needed by other functions)
-const {envLog, envWarn, envError} = createLoggingHelpers(env);
-
-// Initialize update helpers (after logging helpers are available)
-const {checkForUpdate, notifyClientsForUpdate, hideUpdatePopupsFromAllClients} =
-  createUpdateHelpers({
-    env,
-    endpointUrl,
-    HIDING_INTERVAL,
-    state: updateState,
-    envError,
-  });
+let lastDeployedTime = null; // Track the last deployment time
+let updatePending = false; // Flag to track if new assets are available
 
 // Install event - activate new SW immediately
 self.addEventListener("install", (event) => {
-  envLog(`[Service Worker] 🔧 Installing version ${CACHE_VERSION}`);
   event.waitUntil(self.skipWaiting()); // Activate the new service worker immediately
 });
 
 // Activate event - claim clients and clear old caches
 self.addEventListener("activate", (event) => {
-  envLog(`[Service Worker] ✅ Activating version ${CACHE_VERSION}`);
   event.waitUntil(
     (async () => {
       // Clear old caches during activation
       const cacheNames = await caches.keys();
-      envLog(
-        `[Service Worker] 🗑️ Found ${cacheNames.length} caches, clearing old ones...`
-      );
       await Promise.all(
-        cacheNames.map((cacheName) => {
-          // Keep current version cache, API cache, and metadata cache
-          if (
-            cacheName !== CACHE_NAME &&
-            cacheName !== API_CACHE_NAME &&
-            cacheName !== METADATA_CACHE_NAME
-          ) {
-            envLog(`[Service Worker] 🗑️ Deleting old cache: ${cacheName}`);
-            return caches.delete(cacheName);
-          }
-          return Promise.resolve();
-        })
+        cacheNames.map((cacheName) =>
+          cacheName !== CACHE_NAME
+            ? caches.delete(cacheName)
+            : Promise.resolve()
+        )
       );
 
-      // Clear any existing intervals to prevent duplicates on re-activation
-      if (updateCheckIntervalId != null) {
-        clearInterval(updateCheckIntervalId);
-        updateCheckIntervalId = null;
+      // Register periodic sync if supported, fallback to polling otherwise
+      try {
+        if ("periodicSync" in self.registration) {
+          await self.registration.periodicSync.register("check-for-update", {
+            minInterval: POLLING_INTERVAL,
+          });
+        } else {
+          setInterval(checkForUpdate, POLLING_INTERVAL);
+        }
+      } catch (error) {
+        console.warn("Periodic sync permission denied:", error);
+        setInterval(checkForUpdate, POLLING_INTERVAL);
       }
-      if (cacheMaintenanceIntervalId != null) {
-        clearInterval(cacheMaintenanceIntervalId);
-        cacheMaintenanceIntervalId = null;
+
+      await self.clients.claim(); // Take control of open tabs
+    })()
+  );
+});
+
+// Polling or Push-based update check
+async function checkForUpdate() {
+  try {
+    const response = await fetch(
+      `${endpointUrl}/api/last-deployed?env=${env}`,
+      {
+        cache: "no-cache",
       }
+    );
 
-      // Set up polling for update checks (periodicSync requires PWA installation and permissions)
-      updateCheckIntervalId = setInterval(checkForUpdate, POLLING_INTERVAL);
-      envLog(
-        `[Service Worker] ⏰ Update check interval set (${POLLING_INTERVAL / 1000 / 60} minutes)`
-      );
+    if (response.ok) {
+      const {lastDeployed} = await response.json();
 
-      await self.clients.claim(); // Take control of open tabs
-      envLog(`[Service Worker] 🎉 Version ${CACHE_VERSION} is now active!`);
+      if (lastDeployedTime != null && lastDeployed !== lastDeployedTime) {
+        lastDeployedTime = lastDeployed;
+        updatePending = true;
 
-      // Start periodic cache maintenance
-      cacheMaintenanceIntervalId = setInterval(
-        performCacheMaintenance,
-        CACHE_CLEANUP_INTERVAL
+        notifyClientsForUpdate(); // Notify clients about the update
+        scheduleBackgroundActivation(); // Schedule background activation
+      } else {
+        lastDeployedTime = lastDeployed;
+      }
+    }
+  } catch (error) {
+    console.error("Error during update check:", error);
+  }
+}
+
+// Notify clients about the available update
+function notifyClientsForUpdate() {
+  self.clients
+    .matchAll({type: "window", includeUncontrolled: true})
+    .then((clients) => {
+      clients.forEach((client) => client.postMessage({type: "UPDATE_READY"}));
+    });
+}
+
+// Hide available update popups from clients
+function hideUpdatePopupsFromAllClients() {
+  self.clients
+    .matchAll({type: "window", includeUncontrolled: true})
+    .then((clients) => {
+      clients.forEach((client) =>
+        client.postMessage({type: "HIDE_UPDATE_POPUP"})
       );
+    });
+}
 
-      // Perform initial maintenance
-      await performCacheMaintenance();
-    })()
-  );
-});
+// Schedule background activation after HIDING_INTERVAL if the user doesn’t act
+function scheduleBackgroundActivation() {
+  setTimeout(async () => {
+    if (updatePending) {
+      // Send a message to the client to hide the popup
+      const allClients = await self.clients.matchAll({
+        type: "window",
+        includeUncontrolled: true,
+      });
+      allClients.forEach((client) =>
+        client.postMessage({type: "HIDE_UPDATE_POPUP"})
+      );
+
+      // Activate the new service worker
+      await self.skipWaiting();
+      updatePending = false;
+    }
+  }, HIDING_INTERVAL); // hiding timeout
+}
 
 // Handle periodic sync events if supported
 self.addEventListener("periodicsync", (event) => {
@@ -190,779 +158,3 @@ self.addEventListener("push", (event) => {
     hideUpdatePopupsFromAllClients();
   }
 });
-
-// Handle messages from the client app
-self.addEventListener("message", async (event) => {
-  // Security: Verify the message origin matches our app's origin
-  if (event.origin !== self.origin) {
-    envWarn(
-      "[Service Worker] ⚠️ Rejected message from untrusted origin:",
-      event.origin
-    );
-    return;
-  }
-
-  const {type, payload} = event.data ?? {};
-
-  if (type === "DASHBOARD_LOADED") {
-    envLog(
-      "[Service Worker] 🎉 Dashboard page loaded! Signal received from Dashboard in Service Worker",
-      payload
-    );
-  }
-
-  if (type === "PREFETCH_URLS") {
-    envLog("[Service Worker] 📦 Received prefetch URL list");
-    const {urls, authHeaders, batchSize = 0, expirationTime} = payload;
-    const tenantId = authHeaders["zeni-tenant-id"];
-
-    if (expirationTime != null) {
-      envLog(
-        `[Service Worker] 🎯 Setting expiration time to ${expirationTime} minutes`
-      );
-      apiCacheDuration = expirationTime * 1000 * 60; // convert minutes to milliseconds
-    }
-
-    if (tenantId == null || tenantId === "") {
-      envError("[Service Worker] ❌ No tenant ID found in auth headers!");
-      return;
-    }
-
-    if (urls == null || urls.length === 0) {
-      envLog("[Service Worker] ⚠️ No URLs to prefetch");
-      return;
-    }
-
-    envLog(
-      `[Service Worker] 🎯 Setting up continuous prefetch for ${urls.length} URLs (tenant: ${tenantId})${batchSize > 0 ? ` with batch size ${batchSize}` : ""}, expiration: ${Math.round(apiCacheDuration / 1000 / 60)}m`
-    );
-
-    // Add URLs to the prefetchable whitelist with tenant ID (normalized for consistent matching)
-    urls.forEach((item) => {
-      const normalizedUrl = normalizeUrl(item.url);
-      prefetchableURLs.set(normalizedUrl, tenantId);
-    });
-    envLog(
-      `[Service Worker] 📝 Updated prefetch whitelist (${prefetchableURLs.size} total URLs)`
-    );
-
-    // Start continuous prefetching with interval
-    startContinuousPrefetch(urls, authHeaders, tenantId, batchSize);
-  }
-
-  if (type === "STOP_PREFETCH") {
-    envLog("[Service Worker] 🛑 Received stop prefetch signal");
-    stopContinuousPrefetch();
-  }
-
-  if (type === "WAKE_UP") {
-    envLog("[Service Worker] 👋 Waking up - user returned to tab");
-    // Service worker is now active and ready to handle requests
-  }
-
-  if (type === "PAGE_REFRESH") {
-    // Get client ID from the message source
-    // event.source can be a Client or MessagePort, we need the client ID
-    const timestamp = payload?.timestamp ?? Date.now();
-
-    // Try to get client ID from the source
-    let clientId = null;
-    if (event.source) {
-      // If source is a Client, use its id
-      if ("id" in event.source) {
-        clientId = event.source.id;
-      } else if (typeof event.source === "string") {
-        clientId = event.source;
-      }
-    }
-
-    // If we couldn't get client ID from source, try to get it from all clients
-    // by matching the message origin/timestamp
-    if (clientId == null || clientId === "") {
-      try {
-        const clients = await self.clients.matchAll({
-          includeUncontrolled: true,
-          type: "window",
-        });
-        // Use the first client as fallback (in most cases there's only one)
-        if (clients.length > 0) {
-          clientId = clients[0].id;
-        }
-      } catch (error) {
-        envWarn(
-          "[Service Worker] Could not get client ID for refresh tracking:",
-          error
-        );
-      }
-    }
-
-    if (clientId != null && clientId !== "") {
-      envLog(
-        `[Service Worker] 🔄 Page refresh detected from client ${clientId} - will bypass cache for ${REFRESH_BYPASS_WINDOW_MS / 1000}s`
-      );
-
-      // Store refresh timestamp for this client
-      refreshTimestamps.set(clientId, timestamp);
-    } else {
-      // Fallback: use a global refresh flag (less precise but works)
-      envLog(
-        `[Service Worker] 🔄 Page refresh detected (client ID unknown) - will bypass cache for ${REFRESH_BYPASS_WINDOW_MS / 1000}s`
-      );
-      refreshTimestamps.set("global", timestamp);
-    }
-  }
-});
-
-/**
- * Generate tenant-specific cache key
- */
-function getCacheKey(url, tenantId) {
-  return `${tenantId}:${url}`;
-}
-
-/**
- * Store cache metadata (timestamp) for a URL with tenant context
- */
-async function setCacheMetadata(url, tenantId) {
-  try {
-    const cacheKey = getCacheKey(url, tenantId);
-    const metadataCache = await caches.open(METADATA_CACHE_NAME);
-    const metadata = {
-      url: url,
-      tenantId: tenantId,
-      cachedAt: Date.now(),
-      expiresAt: Date.now() + apiCacheDuration,
-    };
-
-    // Store metadata as a Response object with tenant-specific key
-    const metadataResponse = new Response(JSON.stringify(metadata), {
-      headers: {"Content-Type": "application/json"},
-    });
-
-    await metadataCache.put(cacheKey, metadataResponse);
-  } catch (error) {
-    envError("[Service Worker] Error storing cache metadata:", error);
-  }
-}
-
-/**
- * Get cache metadata for a URL with tenant context
- */
-async function getCacheMetadata(url, tenantId) {
-  try {
-    const cacheKey = getCacheKey(url, tenantId);
-    const metadataCache = await caches.open(METADATA_CACHE_NAME);
-    const metadataResponse = await metadataCache.match(cacheKey);
-
-    if (metadataResponse) {
-      const metadata = await metadataResponse.json();
-      return metadata;
-    }
-    return null;
-  } catch (error) {
-    envError("[Service Worker] Error reading cache metadata:", error);
-    return null;
-  }
-}
-
-/**
- * Check if cached data is still valid (not expired) for specific tenant
- */
-async function isCacheValid(url, tenantId) {
-  const metadata = await getCacheMetadata(url, tenantId);
-
-  if (metadata == null) {
-    return false;
-  }
-
-  const now = Date.now();
-  const isValid = now < metadata.expiresAt;
-
-  if (!isValid) {
-    const ageMinutes = Math.round((now - metadata.cachedAt) / 1000 / 60);
-    envLog(
-      `[Service Worker] ⏰ Cache expired for tenant ${tenantId}, URL: ${url} (age: ${ageMinutes} minutes)`
-    );
-  }
-
-  return isValid;
-}
-
-// Initialize service worker helpers (after isCacheValid is defined)
-const {
-  isCommonAPIUrl,
-  shouldProcessUrl,
-  normalizeUrl,
-  checkStorageQuota,
-  getCacheEntryCount,
-  recordCacheAccess,
-  performCacheMaintenance,
-} = createServiceWorkerHelpers({
-  API_CACHE_NAME,
-  METADATA_CACHE_NAME,
-  MAX_CACHE_ENTRIES,
-  MAX_CACHE_SIZE_MB,
-  LOW_STORAGE_THRESHOLD_MB,
-  CACHE_SIZE_EXCEEDED_EVICTION_PERCENT,
-  LOW_STORAGE_EVICTION_PERCENT,
-  cacheAccessTimes,
-  isCacheValid,
-  envLog,
-  envWarn,
-  envError,
-  URL_PATTERNS_TO_PROCESS: [
-    "/accounting/2.0/reports/balance_sheet",
-    "/accounting/2.0/reports/profit_and_loss",
-    "/accounting/2.0/reports/cash_flow",
-  ], // Configurable URL patterns
-});
-
-/**
- * Delete cache metadata for a URL with tenant context
- */
-async function deleteCacheMetadata(url, tenantId) {
-  try {
-    const cacheKey = getCacheKey(url, tenantId);
-    const metadataCache = await caches.open(METADATA_CACHE_NAME);
-    await metadataCache.delete(cacheKey);
-  } catch (error) {
-    envError("[Service Worker] Error deleting cache metadata:", error);
-  }
-}
-
-/**
- * Execute prefetch for stored job
- * Called immediately and at intervals
- * Supports batching - if batchSize > 0, URLs are fetched in batches with each batch waiting for completion
- */
-async function executePrefetch() {
-  if (currentPrefetchJob == null) {
-    envWarn("[Service Worker] ⚠️ No prefetch job to execute");
-    return;
-  }
-
-  const {urls, authHeaders, tenantId, batchSize = 0} = currentPrefetchJob;
-
-  envLog(
-    `[Service Worker] 🔄 Executing periodic prefetch for tenant ${tenantId} (${urls.length} URLs)${batchSize > 0 ? ` in batches of ${batchSize}` : ""}`
-  );
-
-  // Check storage quota once at the beginning of prefetch cycle
-  const storageInfo = await checkStorageQuota();
-  if (storageInfo.low === true) {
-    envWarn(
-      `[Service Worker] ⚠️ Low storage detected (${storageInfo.availableMB.toFixed(2)}MB available), performing maintenance before prefetch...`
-    );
-    await performCacheMaintenance();
-    // Re-check storage after maintenance
-    const updatedStorageInfo = await checkStorageQuota();
-    if (updatedStorageInfo.low === true) {
-      envWarn(
-        `[Service Worker] ⚠️ Storage still low after maintenance, skipping prefetch cycle`
-      );
-      return;
-    }
-  }
-
-  if (batchSize > 0) {
-    // Process URLs in batches, waiting for each batch to complete
-    const totalBatches = Math.ceil(urls.length / batchSize);
-
-    for (let batchIndex = 0; batchIndex < totalBatches; batchIndex++) {
-      const startIdx = batchIndex * batchSize;
-      const endIdx = Math.min(startIdx + batchSize, urls.length);
-      const batch = urls.slice(startIdx, endIdx);
-
-      envLog(
-        `[Service Worker] 📦 Processing batch ${batchIndex + 1}/${totalBatches} (${batch.length} URLs)`
-      );
-
-      // Fetch all URLs in this batch concurrently and wait for all to complete
-      const batchPromises = batch.map((item, indexInBatch) => {
-        const globalIndex = startIdx + indexInBatch + 1;
-        return prefetchURL(
-          item.url,
-          item.priority,
-          item.apiType,
-          globalIndex,
-          authHeaders,
-          tenantId,
-          true // skipStorageCheck - already checked at batch level
-        );
-      });
-
-      // Wait for all URLs in this batch to complete before moving to next batch
-      await Promise.allSettled(batchPromises);
-
-      envLog(
-        `[Service Worker] ✅ Batch ${batchIndex + 1}/${totalBatches} completed`
-      );
-    }
-
-    envLog(`[Service Worker] 🎉 All ${totalBatches} batches completed`);
-  } else {
-    // Prefetch all URLs concurrently (original behavior)
-    urls.forEach((item, index) => {
-      prefetchURL(
-        item.url,
-        item.priority,
-        item.apiType,
-        index + 1,
-        authHeaders,
-        tenantId,
-        true // skipStorageCheck - already checked at batch level
-      );
-    });
-  }
-}
-
-/**
- * Start continuous prefetching at intervals
- * @param {Array} urls - List of URLs to prefetch
- * @param {Object} authHeaders - Authentication headers
- * @param {string} tenantId - Tenant ID
- * @param {number} batchSize - If > 0, URLs will be fetched in batches of this size
- */
-function startContinuousPrefetch(urls, authHeaders, tenantId, batchSize = 0) {
-  // Clear any existing interval
-  stopContinuousPrefetch();
-
-  // Store the current prefetch job with batch size
-  currentPrefetchJob = {urls, authHeaders, tenantId, batchSize};
-
-  envLog(
-    `[Service Worker] ⏰ Starting continuous prefetch (interval: ${PREFETCH_INTERVAL / 1000 / 60} minutes)${batchSize > 0 ? ` with batch size ${batchSize}` : ""}`
-  );
-
-  // Execute immediately
-  executePrefetch();
-
-  // Set up interval for continuous prefetching
-  prefetchIntervalId = setInterval(() => {
-    envLog(`[Service Worker] 🔄 Periodic prefetch triggered`);
-    executePrefetch();
-  }, PREFETCH_INTERVAL);
-}
-
-/**
- * Stop continuous prefetching
- */
-function stopContinuousPrefetch() {
-  if (prefetchIntervalId != null) {
-    clearInterval(prefetchIntervalId);
-    prefetchIntervalId = null;
-    envLog("[Service Worker] ⏹️ Stopped continuous prefetch");
-  }
-  currentPrefetchJob = null;
-}
-
-/**
- * Prefetch a single URL and cache it with tenant-specific key
- * Only fetches if cache is expired or doesn't exist for this tenant
- * Skips prefetch for "common" API types (they will be cached on-demand)
- * @param {boolean} skipStorageCheck - If true, skips storage quota check (already checked at batch level)
- */
-async function prefetchURL(
-  url,
-  priority,
-  apiType,
-  index,
-  authHeaders,
-  tenantId,
-  skipStorageCheck = false
-) {
-  try {
-    // Normalize URL for consistent cache key generation
-    const normalizedUrl = normalizeUrl(url);
-
-    // Check storage quota before prefetching (only if not already checked at batch level)
-    if (!skipStorageCheck) {
-      const storageInfo = await checkStorageQuota();
-      if (storageInfo.low === true) {
-        envWarn(
-          `[Service Worker] ⚠️ ${index}. Skipping prefetch due to low storage (${storageInfo.availableMB.toFixed(2)}MB available)`
-        );
-        // Trigger maintenance to free up space
-        await performCacheMaintenance();
-        return;
-      }
-    }
-
-    // Check if URL is already cached and still valid for this tenant
-    const cache = await caches.open(API_CACHE_NAME);
-    const cacheKey = getCacheKey(normalizedUrl, tenantId);
-    const cachedResponse = await cache.match(cacheKey);
-
-    if (cachedResponse) {
-      const isValid = await isCacheValid(normalizedUrl, tenantId);
-
-      if (isValid) {
-        // Cache is still valid for this tenant, skip prefetch
-        const metadata = await getCacheMetadata(normalizedUrl, tenantId);
-        const ageMinutes = Math.round(
-          (Date.now() - metadata.cachedAt) / 1000 / 60
-        );
-        const remainingMinutes = Math.round(
-          (metadata.expiresAt - Date.now()) / 1000 / 60
-        );
-
-        // Record access for LRU tracking
-        recordCacheAccess(cacheKey);
-
-        envLog(
-          `[Service Worker] ⏭️ ${index}. Skipping prefetch for tenant ${tenantId} - ${url} (already cached, age: ${ageMinutes}m, expires in: ${remainingMinutes}m)`
-        );
-        return; // Skip prefetch
-      } else {
-        // Cache expired for this tenant, will refetch
-        const metadata = await getCacheMetadata(normalizedUrl, tenantId);
-        const ageMinutes = Math.round(
-          (Date.now() - metadata.cachedAt) / 1000 / 60
-        );
-        envLog(
-          `[Service Worker] 🔄 ${index}. Cache expired for tenant ${tenantId} (age: ${ageMinutes}m), refetching - ${url}`
-        );
-      }
-    }
-
-    // Check cache limits before fetching
-    const entryCount = await getCacheEntryCount(API_CACHE_NAME);
-    if (entryCount >= MAX_CACHE_ENTRIES) {
-      envWarn(
-        `[Service Worker] ⚠️ ${index}. Cache limit reached (${entryCount}/${MAX_CACHE_ENTRIES}), performing maintenance...`
-      );
-      await performCacheMaintenance();
-    }
-
-    // Fetch the URL (either not cached or expired for this tenant)
-    envLog(
-      `[Service Worker] [${priority}] ${index}. Fetching for tenant ${tenantId}: ${url}`
-    );
-    envLog("[Service Worker] 🔑 Auth headers:", authHeaders);
-    let response;
-    try {
-      response = await fetch(url, {
-        method: "GET",
-        headers: authHeaders,
-      });
-    } catch (error) {
-      envError(`[Service Worker] ❌ ${index}. Error:`, error.message, url);
-      return;
-    }
-
-    if (response.ok) {
-      // Cache the response with tenant-specific key (using normalized URL)
-      await cache.put(cacheKey, response.clone());
-
-      // Store cache metadata with timestamp and tenant ID
-      await setCacheMetadata(normalizedUrl, tenantId);
-
-      // Record access for LRU tracking
-      recordCacheAccess(cacheKey);
-
-      envLog(
-        `[Service Worker] ✅ ${index}. Cached successfully for tenant (${apiType}) ${tenantId} (expires in ${apiCacheDuration / 1000 / 60} minutes)`
-      );
-    } else {
-      envWarn(
-        `[Service Worker] ❌ ${index}. Failed with status: ${response.status}`
-      );
-    }
-  } catch (error) {
-    envError(`[Service Worker] ❌ ${index}. Error:`, error.message);
-  }
-}
-
-// Intercept fetch requests to serve cached prefetched data (tenant-aware)
-self.addEventListener("fetch", (event) => {
-  const {request} = event;
-
-  // Check for signout API call - clear all caches
-  if (
-    request.url.includes("/auth/1.0/signout") === true &&
-    request.method === "POST"
-  ) {
-    envLog("[Service Worker] 🚪 Signout detected, clearing all caches...");
-    setTimeout(() => {
-      clearAllCaches();
-    }, 1000);
-    return;
-  }
-
-  // Check if URL should be processed based on configured patterns
-  const shouldProcess = shouldProcessUrl(request.url);
-  if (shouldProcess === true) {
-    envLog(
-      `[Service Worker] 🔄 URL should be processed, processing: ${request.url}`
-    );
-  } else {
-    return;
-  }
-
-  // Only handle GET requests for caching
-  if (request.method !== "GET") {
-    return;
-  }
-
-  // Extract tenant ID from request headers - required for cache lookup
-  const tenantId = request.headers.get("zeni-tenant-id");
-
-  // Skip if no tenant ID (can't do tenant-specific caching)
-  if (tenantId == null || tenantId === "") {
-    return;
-  }
-
-  // Check if this request is part of a page refresh (should bypass cache)
-  // We'll check this inside the respondWith handler where we can properly await client lookup
-
-  // Normalize request URL for consistent cache key matching
-  const normalizedRequestUrl = normalizeUrl(request.url);
-  const cacheKey = getCacheKey(normalizedRequestUrl, tenantId);
-
-  // Check if this URL is in our in-memory prefetch whitelist
-  const isInPrefetchWhitelist = prefetchableURLs.has(normalizedRequestUrl);
-  const whitelistTenantId = prefetchableURLs.get(normalizedRequestUrl);
-
-  // Check if this is a common API URL (always cacheable)
-  const isCommonUrl = isCommonAPIUrl(normalizedRequestUrl);
-
-  // Determine if URL should be cached (either in whitelist or is common API)
-  const isCacheable = isInPrefetchWhitelist || isCommonUrl;
-
-  // If in whitelist but different tenant, skip (tenant mismatch)
-  if (isInPrefetchWhitelist && whitelistTenantId !== tenantId) {
-    envLog(
-      `[Service Worker] 🔄 Tenant mismatch for ${request.url} (expected: ${whitelistTenantId}, got: ${tenantId}), passing through`
-    );
-    return;
-  }
-
-  // Respond with cache-first strategy (unless it's a refresh)
-  // Check cache directly (don't rely solely on in-memory whitelist which clears on SW restart)
-  event.respondWith(
-    (async () => {
-      try {
-        // Check if this request is part of a page refresh (should bypass cache)
-        let isRefreshRequest = false;
-        try {
-          if (event.clientId != null && event.clientId !== "") {
-            // Check if there's a recent refresh timestamp for this client
-            const refreshTimestamp = refreshTimestamps.get(event.clientId);
-            if (refreshTimestamp != null) {
-              const now = Date.now();
-              const timeSinceRefresh = now - refreshTimestamp;
-
-              if (timeSinceRefresh < REFRESH_BYPASS_WINDOW_MS) {
-                isRefreshRequest = true;
-                envLog(
-                  `[Service Worker] 🔄 Refresh detected (${Math.round(timeSinceRefresh / 1000)}s ago) - bypassing cache for: ${request.url}`
-                );
-              } else {
-                // Clean up expired refresh timestamp
-                refreshTimestamps.delete(event.clientId);
-              }
-            }
-
-            // Also check global refresh flag as fallback
-            if (!isRefreshRequest) {
-              const globalRefreshTimestamp = refreshTimestamps.get("global");
-              if (globalRefreshTimestamp != null) {
-                const now = Date.now();
-                const timeSinceRefresh = now - globalRefreshTimestamp;
-
-                if (timeSinceRefresh < REFRESH_BYPASS_WINDOW_MS) {
-                  isRefreshRequest = true;
-                  envLog(
-                    `[Service Worker] 🔄 Global refresh detected (${Math.round(timeSinceRefresh / 1000)}s ago) - bypassing cache for: ${request.url}`
-                  );
-                } else {
-                  // Clean up expired global refresh timestamp
-                  refreshTimestamps.delete("global");
-                }
-              }
-            }
-          }
-        } catch (error) {
-          // If we can't determine client, continue normally (not a refresh)
-          envLog(
-            "[Service Worker] Could not determine client for refresh check (normal for non-client requests)",
-            error
-          );
-        }
-
-        // If this is a refresh request, bypass cache and fetch fresh data
-        if (isRefreshRequest) {
-          envLog(
-            `[Service Worker] 🔄 Refresh request - bypassing cache and fetching fresh data: ${request.url}`
-          );
-
-          let networkResponse;
-          try {
-            networkResponse = await fetch(request);
-          } catch (error) {
-            envError(
-              "[Service Worker] ❌ Error during fetch:",
-              error,
-              request.url
-            );
-            return;
-          }
-
-          // Cache the fresh response if URL is in prefetch whitelist or is a common API URL
-          if (networkResponse.ok && isCacheable === true) {
-            const cache = await caches.open(API_CACHE_NAME);
-            await cache.put(cacheKey, networkResponse.clone());
-            await setCacheMetadata(normalizedRequestUrl, tenantId);
-            recordCacheAccess(cacheKey);
-            envLog(
-              `[Service Worker] ✅ Fetched and cached fresh data (refresh) for tenant ${tenantId}: ${request.url}${isCommonUrl === true ? " (common API)" : ""}`
-            );
-          }
-
-          return networkResponse;
-        }
-
-        // Normal flow: check cache first
-        const cache = await caches.open(API_CACHE_NAME);
-        const cachedResponse = await cache.match(cacheKey);
-
-        // Check if cache exists and is still valid for this tenant
-        if (cachedResponse) {
-          const isValid = await isCacheValid(normalizedRequestUrl, tenantId);
-
-          if (isValid) {
-            // Cache is still valid for this tenant, serve it immediately
-            const metadata = await getCacheMetadata(
-              normalizedRequestUrl,
-              tenantId
-            );
-
-            const ageMinutes = metadata
-              ? Math.round((Date.now() - metadata.cachedAt) / 1000 / 60)
-              : 0;
-
-            // Record access for LRU tracking
-            recordCacheAccess(cacheKey);
-
-            // Add URL to in-memory whitelist if not already there (restore after SW restart)
-            // Also add common URLs for tracking
-            if (!isInPrefetchWhitelist && isCacheable === true) {
-              prefetchableURLs.set(normalizedRequestUrl, tenantId);
-              envLog(
-                `[Service Worker] 📝 Restored ${normalizedRequestUrl} to prefetch whitelist from cache${isCommonUrl === true ? " (common API)" : ""}`
-              );
-            }
-
-            envLog(
-              `[Service Worker] ⚡ Serving from cache for tenant ${tenantId} (age: ${ageMinutes}m): ${request.url}`
-            );
-
-            return cachedResponse;
-          } else {
-            // Cache expired for this tenant, fetch fresh data
-            envLog(
-              `[Service Worker] 🔄 Cache expired for tenant ${tenantId}, fetching fresh data: ${request.url}`
-            );
-
-            // Delete expired cache and metadata
-            await cache.delete(cacheKey);
-            await deleteCacheMetadata(normalizedRequestUrl, tenantId);
-
-            let networkResponse;
-            try {
-              networkResponse = await fetch(request);
-            } catch (error) {
-              envError(
-                "[Service Worker] ❌ Error during fetch:",
-                error,
-                request.url
-              );
-              return;
-            }
-
-            // Cache if URL is in prefetch whitelist or is a common API URL
-            if (networkResponse.ok && isCacheable === true) {
-              await cache.put(cacheKey, networkResponse.clone());
-              await setCacheMetadata(normalizedRequestUrl, tenantId);
-              recordCacheAccess(cacheKey);
-              envLog(
-                `[Service Worker] ✅ Fetched and cached fresh data for tenant ${tenantId}${isCommonUrl === true ? " (common API)" : ""}`
-              );
-            }
-
-            return networkResponse;
-          }
-        }
-
-        // Not in cache - fetch from network
-        let networkResponse;
-        try {
-          networkResponse = await fetch(request);
-        } catch (error) {
-          envError(
-            "[Service Worker] ❌ Error during fetch:",
-            error,
-            request.url
-          );
-          return;
-        }
-
-        // Cache if URL is in prefetch whitelist or is a common API URL
-        if (networkResponse.ok && isCacheable === true) {
-          await cache.put(cacheKey, networkResponse.clone());
-          await setCacheMetadata(normalizedRequestUrl, tenantId);
-          recordCacheAccess(cacheKey);
-          envLog(
-            `[Service Worker] ✅ Fetched and cached for tenant ${tenantId}: ${request.url}${isCommonUrl === true ? " (common API)" : ""}`
-          );
-        }
-
-        return networkResponse;
-      } catch (error) {
-        envError(
-          `[Service Worker] ❌ Fetch error for tenant ${tenantId}:`,
-          error,
-          request.url
-        );
-        return;
-      }
-    })()
-  );
-});
-
-/**
- * Clear all caches (API cache and metadata)
- * Called on signout to ensure no data persists
- */
-async function clearAllCaches() {
-  try {
-    envLog("[Service Worker] 🧹 Starting cache cleanup...");
-
-    // Stop continuous prefetch
-    stopContinuousPrefetch();
-
-    // Clear API prefetch cache
-    const apiCacheDeleted = await caches.delete(API_CACHE_NAME);
-    if (apiCacheDeleted) {
-      envLog(`[Service Worker] ✅ Cleared ${API_CACHE_NAME}`);
-    }
-
-    // Clear metadata cache
-    const metadataCacheDeleted = await caches.delete(METADATA_CACHE_NAME);
-    if (metadataCacheDeleted) {
-      envLog(`[Service Worker] ✅ Cleared ${METADATA_CACHE_NAME}`);
-    }
-
-    // Clear prefetchable URLs whitelist
-    prefetchableURLs.clear();
-    envLog("[Service Worker] ✅ Cleared prefetch whitelist");
-
-    // Clear LRU access times
-    cacheAccessTimes.clear();
-    envLog("[Service Worker] ✅ Cleared cache access times");
-
-    envLog("[Service Worker] 🎉 All caches cleared successfully");
-  } catch (error) {
-    envError("[Service Worker] ❌ Error clearing caches:", error);
-  }
-}