@swoff/cli 0.3.13 → 0.3.14

package/dist/lib/generators/sw-sections/fetch-handler.js

@@ -1,76 +1,37 @@
-/**
- * Generates the SW fetch event handler with all caching strategies.
- *
- * Strategy dispatch tiers (highest to lowest priority):
- *   1. X-SW-Strategy header — per-request override from fetchWithCache({ strategy })
- *   2. URL pattern match — from features.serviceWorker.strategies in swoff.config.json
- *   3. defaultStrategy — fallback from features.serviceWorker.defaultStrategy
- *
- * Strategies:
- *   - cache-first:      Serve cache if exists, fetch if missing. No bg refresh.
- *   - network-first:    Try network first, fall back to cache on failure.
- *   - stale-while-revalidate: Serve cache + always refresh in background.
- *   - cache-only:       Never fetch. Cache hit or 404.
- *   - network-only:     Never cache. Always fetch.
- *   - reactive:         Serve cache + refresh on configurable triggers (interval,
- *                       onFocus, onReconnect). staleTime gates ALL triggers.
- *
- * staleTime, refetchInterval, refetchOnFocus, refetchOnReconnect are
- * reactive-only fields. Non-reactive strategies ignore them.
- *
- * Background refreshes use a shared batch queue with rate limiting.
- * On successful refresh, CACHE_UPDATED is posted to all clients.
- */
-export function generateFetchHandler(swConfig, tagInvalidation, mutationQueueEnabled) {
-    const { strategy: { default: defaultStrategy, patterns: strategies, mode: cacheStrategy = "all", normalizeKey: normalizeCacheKey, ignoreQueryParams, }, navigation: { mode: navMode = "spa", preload: navigationPreload, fallback: spaPath = "/index.html", }, refetchQueue: { batchSize: refetchBatchSize = 5, batchDelayMs: refetchBatchDelayMs = 1000, maxRetries: refetchMaxRetries = 3, retryDelayMs: refetchRetryDelayMs = 1000, }, } = swConfig;
-    const { staleTime: globalStaleTime, refetchInterval: globalRefetchInterval, refetchOnReconnect: globalRefetchOnReconnect, refetchOnFocus: globalRefetchOnFocus, } = swConfig.strategy.reactive?.defaults || {};
-    const staleVersionCode = tagInvalidation
-        ? `
-    cleanStaleVersions();
-    if (staleVersions.has(cacheKey(request))) {
-      queueRefresh(cacheKey(request), new URL(request.url).href);
-    }`
-        : "";
-    const tagCode = tagInvalidation
-        ? `
-  const tagsHeader = request.headers.get("X-SW-Cache-Tags");
-  if (tagsHeader) {
-    const cacheKeyUrl = cacheKey(request);
-    const actualUrl = new URL(request.url).href;
-    const tags = tagsHeader.split(",").map((t) => t.trim());
-    await cacheTagUrl(cacheKeyUrl, actualUrl, tags);
-  }`
+export function generateFetchHandler(swConfig, tagInvalidation, mutationQueueEnabled, authRoutePaths, serverPushEndpoint, debug) {
+    const { strategy: { default: defaultStrategy, patterns: strategies, normalizeKey: normalizeCacheKey, ignoreQueryParams, timeout: fetchTimeout = 10, maxRuntimeCacheAge: maxCacheAge, }, navigation: { mode: navMode = "spa", preload: navigationPreload, fallback: globalFallback = "", rules: navRules = [], }, } = swConfig;
+    const debugMode = debug === true;
+    const globalStaleTime = swConfig.strategy.reactive?.defaults?.staleTime;
+    const refetchRetry = swConfig.refetchQueue.retry;
+    const hasRules = navRules.length > 0;
+    const navModeCode = navMode === "ssr" ? '"ssr"' : navMode === "spa" ? '"spa"' : '"default"';
+    const fallbackCode = globalFallback ? `"${globalFallback}"` : '""';
+    const navRulesCode = hasRules
+        ? `const NAV_RULES = ${JSON.stringify(navRules.map((r) => ({
+            match: r.match,
+            ...(r.fallback ? { fallback: r.fallback } : {}),
+        })), null, 2)};
+
+function matchRouteFallback(url) {
+  swLog("matchRouteFallback", "ENTER", url, 4);
+  const path = new URL(url).pathname;
+  for (const rule of NAV_RULES) {
+    if (matchGlob(path, rule.match)) {
+      swLog("matchRouteFallback", "MATCH rule=" + rule.match + " fallback=" + (rule.fallback || "null"), url, 4);
+      return rule.fallback || null;
+    }
+  }
+  swLog("matchRouteFallback", "NO MATCH", url, 4);
+  return null;
+}
+
+`
         : "";
-    const reactGlobalDefaults = {
-        staleTime: globalStaleTime,
-        refetchInterval: globalRefetchInterval,
-        refetchOnReconnect: globalRefetchOnReconnect,
-        refetchOnFocus: globalRefetchOnFocus,
-    };
-    const reactivePatterns = Object.entries(strategies)
-        .filter(([, entry]) => {
-        const resolved = typeof entry === "string" ? { strategy: entry } : entry;
-        return resolved.strategy === "reactive";
-    })
-        .map(([pattern, entry]) => {
-        const resolved = typeof entry === "string" ? { strategy: entry } : entry;
-        return {
-            pattern,
-            staleTime: resolved.staleTime ?? reactGlobalDefaults.staleTime,
-            refetchInterval: resolved.refetchInterval ?? reactGlobalDefaults.refetchInterval,
-            refetchOnReconnect: resolved.refetchOnReconnect ?? reactGlobalDefaults.refetchOnReconnect,
-            refetchOnFocus: resolved.refetchOnFocus ?? reactGlobalDefaults.refetchOnFocus,
-        };
-    });
-    const trimDecl = `const REFETCH_BATCH_SIZE = ${refetchBatchSize};
-const REFETCH_BATCH_DELAY_MS = ${refetchBatchDelayMs};
-const REFRESH_MAX_RETRIES = ${refetchMaxRetries};
-const REFRESH_RETRY_DELAY_MS = ${refetchRetryDelayMs};`;
-    const GLOB_CODE = "\n" +
+    const globCode = "\n" +
         "// --- Glob Pattern Matching ---\n" +
         "\n" +
         "function escapeGlobMeta(s) {\n" +
-        '  return s.replace(/[.+^${}()|[\\]\\\\]/g, "\\\\$$&");\n' +
+        '  return s.replace(/[.+^${}()|[\\]\\\\]/g, "\\\\$&");\n' +
         "}\n" +
         "\n" +
         "function globPartRe(part) {\n" +
@@ -120,197 +81,59 @@ const REFRESH_RETRY_DELAY_MS = ${refetchRetryDelayMs};`;
         "  return pi === parts.length && ppi === pps.length;\n" +
         "}\n" +
         "\n";
-    return `${trimDecl}
-// --- Batch Refresh Queue ---
-
-const _refreshQueue = new Map();
-let _refreshQueuePromise = null;
-
-function queueRefresh(cacheKeyUrl, actualUrl${tagInvalidation ? ", tags" : ""}${tagInvalidation ? ", method, body, contentType" : ""}) {
-  // Use Map keyed by cacheKey for proper deduplication${tagInvalidation
-        ? `
-  // Don't let a tagless (SWR/reactive) refresh override an invalidation-triggered entry with tags
-  if (_refreshQueue.has(cacheKeyUrl) && !tags) return;`
-        : ""}
-  _refreshQueue.set(cacheKeyUrl, { cacheKey: cacheKeyUrl, actualUrl: actualUrl || cacheKeyUrl, retryCount: 0${tagInvalidation ? ", tags: tags || null, method: method || null, body: body || null, contentType: contentType || null" : ""} });
-  if (!_refreshQueuePromise) {
-    _refreshQueuePromise = _processRefreshQueue();
-  }
-  return _refreshQueuePromise;
-}
-
-async function resolveActualUrl(entry) {
-  if (entry.actualUrl) return entry.actualUrl;
-  const url = entry.cacheKey;
-  if (url.includes("/__swc/")) {
-    // Virtual cache key — look up the real URL from tag registry
-    try {
-      const db = await openTagDB();
-      const tx = db.transaction(TAG_STORE_NAME, "readonly");
-      const store = tx.objectStore(TAG_STORE_NAME);
-      const stored = await new Promise((resolve) => {
-        const req = store.get(url);
-        req.onsuccess = () => resolve(req.result);
-        req.onerror = () => resolve(null);
-      });
-      db.close();
-      if (stored?.actualUrl) return stored.actualUrl;
-    } catch {}
-  }
-  return url;
-}
-
-async function _processRefreshQueue() {
-  try {
-    while (_refreshQueue.size > 0) {
-      const batch = [];
-      for (const [cacheKey, entry] of _refreshQueue) {
-        if (batch.length >= REFETCH_BATCH_SIZE) break;
-        if (entry.nextRetryAt && entry.nextRetryAt > Date.now()) continue;
-        batch.push(entry);
-        _refreshQueue.delete(cacheKey);
-      }
-      if (batch.length === 0) break;
-
-      const clients = await self.clients.matchAll();
-
-      await Promise.allSettled(batch.map(async (entry) => {
-        const fetchUrl = await resolveActualUrl(entry);
-        try {
-          const fetchOpts = {};
-          if (entry.method && entry.method !== "GET" && entry.method !== "HEAD") {
-            fetchOpts.method = entry.method;
-            if (entry.body) fetchOpts.body = entry.body;
-            if (entry.contentType) fetchOpts.headers = { "Content-Type": entry.contentType };
-          }
-          const response = await fetch(fetchUrl, fetchOpts);
-          if (response.ok) {
-            const request = new Request(entry.cacheKey);
-            await storeRuntime(request, response);${tagInvalidation
+    const inline503 = "function inline503Response() {\n" +
+        "  return new Response(\n" +
+        '    `<!DOCTYPE html><html lang="en"><head><meta charset="utf-8"/><meta name="viewport" content="width=device-width,initial-scale=1"/><title>Offline</title><style>body{font-family:-apple-system,BlinkMacSystemFont,"Segoe UI",Roboto,sans-serif;display:flex;justify-content:center;align-items:center;height:100vh;margin:0;background:#f5f5f5}div{text-align:center}h1{font-size:2rem;color:#333}p{color:#666}</style></head><body><div><h1>You\\\'re offline</h1><p>Please check your connection and try again.</p></div></body></html>`,\n' +
+        '    { status: 503, headers: { "Content-Type": "text/html", "Cache-Control": "no-store" } }\n' +
+        "  );\n" +
+        "}\n";
+    const tagCode = tagInvalidation
         ? `
-          if (entry.tags && typeof cacheTagUrl !== "undefined") {
-            await cacheTagUrl(entry.cacheKey, fetchUrl, entry.tags, entry.method, entry.body, entry.contentType);
-          }`
-        : ""}
-            // Clean up stale version tracking on successful refresh
-            if (typeof staleVersions !== "undefined" && staleVersions.has(entry.cacheKey)) {
-              staleVersions.delete(entry.cacheKey);
-            }
-            for (const client of clients) {
-              client.postMessage({ type: "CACHE_UPDATED", url: fetchUrl });
-            }
-          }
-        } catch {
-          // Refresh failed — retry with exponential backoff
-          if (entry.retryCount < REFRESH_MAX_RETRIES) {
-            entry.retryCount++;
-            const delay = REFRESH_RETRY_DELAY_MS * Math.pow(2, entry.retryCount - 1);
-            entry.nextRetryAt = Date.now() + delay;
-            _refreshQueue.set(entry.cacheKey, entry);
-            setTimeout(() => {
-              if (!_refreshQueuePromise) {
-                _refreshQueuePromise = _processRefreshQueue();
-              }
-            }, delay);
-          }
-        }
-      }));
-
-      if (_refreshQueue.size > 0 && REFETCH_BATCH_DELAY_MS > 0) {
-        await new Promise(r => setTimeout(r, REFETCH_BATCH_DELAY_MS));
-      }
+  const tagsHeader = request.headers.get("X-SW-Cache-Tags");
+  if (tagsHeader) {
+    const cacheKeyUrl = cacheKey(request);
+    const actualUrl = new URL(request.url).href;
+    const tags = tagsHeader.split(",").map((t) => t.trim());
+    const method = request.method;
+    let body = null;
+    let contentType = null;
+    if (method !== "GET") {
+      contentType = request.headers.get("Content-Type");
+      try { body = await request.clone().text(); } catch {}
     }
-  } finally {
-    _refreshQueuePromise = null;
-  }
+    await cacheTagUrl(cacheKeyUrl, actualUrl, tags, method, body, contentType);
+  }`
+        : "";
+    return `// --- Mode & Strategy Configuration ---
+
+const NAV_MODE = ${navModeCode};
+const FALLBACK_PATH = ${fallbackCode};
+const DEFAULT_STRATEGY = "${defaultStrategy}";
+const CUSTOM_STRATEGIES = ${JSON.stringify(strategies)};
+const REACTIVE_STALE_DEFAULT = ${globalStaleTime != null ? globalStaleTime : 0};
+const FETCH_TIMEOUT_MS = ${fetchTimeout * 1000};
+const SW_DEBUG = ${debugMode};
+${authRoutePaths.length > 0 ? `const AUTH_ROUTES = ${JSON.stringify(authRoutePaths)};` : ""}
+${serverPushEndpoint ? `const SERVER_PUSH_ENDPOINT = "${serverPushEndpoint}";` : ""}
+
+${navRulesCode}// --- Debug Logging ---
+
+function swLog(fn, msg, url, indent) {
+  if (!SW_DEBUG) return;
+  var prefix = "";
+  for (var i = 0; i < (indent || 0); i++) prefix += "  ";
+  console.log("[SW]" + prefix, fn + ":", msg, url || "", Date.now());
 }
 
-// --- Reactive Patterns (extracted for interval/focus/reconnect) ---
-
-const REACTIVE_PATTERNS = ${JSON.stringify(reactivePatterns)};
+${globCode}// --- Navigation Detection ---
 
-function findReactiveConfig(url) {
-  const path = new URL(url).pathname;
-  for (const cfg of REACTIVE_PATTERNS) {
-    if (matchGlob(path, cfg.pattern)) return cfg;
-  }
-  return null;
-}
-
-function shouldReactiveRefresh(cached, config) {
-  if (!config.staleTime && config.staleTime !== 0) return true;
-  if (config.staleTime === 0) return true;
-  return isStale(cached, config.staleTime);
-}
-
-// --- Reactive Interval Timers ---
-
-${(() => {
-        const patternsWithInterval = reactivePatterns.filter((p) => !!p.refetchInterval && p.refetchInterval > 0);
-        if (patternsWithInterval.length === 0)
-            return "";
-        return `// Start intervals for reactive patterns with refetchInterval
-(async () => {
-${patternsWithInterval
-            .map((p) => `  setInterval(async () => {
-    const cache = await caches.open(CACHE_NAME_RUNTIME);
-    const keys = await cache.keys();
-    for (const request of keys) {
-      const url = new URL(request.url);
-      if (url.pathname.startsWith("/__swc/")) continue;
-      if (!matchGlob(url.pathname, "${p.pattern}")) continue;
-      const config = findReactiveConfig(url.href);
-      if (!config) continue;
-      const cached = await cache.match(request);
-      if (cached && shouldReactiveRefresh(cached, config)) {
-        queueRefresh(request.url, url.href);
-      }
-    }
-  }, ${p.refetchInterval * 1000});`)
-            .join("\n")}
-})();
-`;
-    })()}
-async function handleOnline() {
-  const clients = await self.clients.matchAll();
-  if (clients.length === 0) return;
-
-  // Step 1: Retry stale version entries (failed refetches after invalidation)
-  if (typeof staleVersions !== "undefined") {
-    const staleUrls = [...staleVersions.keys()];
-    for (const url of staleUrls) {
-      queueRefresh(url, url);
-    }
-  }
-
-  // Step 2: Refresh reactive entries with refetchOnReconnect
-  const cache = await caches.open(CACHE_NAME_RUNTIME);
-  const keys = await cache.keys();
-  for (const request of keys) {
-    const url = new URL(request.url);
-    if (url.pathname.startsWith("/__swc/")) continue;
-    const config = findReactiveConfig(url.href);
-    if (!config || !config.refetchOnReconnect) continue;
-    const cached = await cache.match(request);
-    if (cached && shouldReactiveRefresh(cached, config)) {
-      queueRefresh(request.url, url.href);
-    }
-  }
-}
-
-async function handleOnFocus() {
-  const cache = await caches.open(CACHE_NAME_RUNTIME);
-  const keys = await cache.keys();
-  for (const request of keys) {
-    const url = new URL(request.url);
-    if (url.pathname.startsWith("/__swc/")) continue;
-    const config = findReactiveConfig(url.href);
-    if (!config || !config.refetchOnFocus) continue;
-    const cached = await cache.match(request);
-    if (cached && shouldReactiveRefresh(cached, config)) {
-      queueRefresh(request.url, url.href);
-    }
-  }
+function isNavRequest(request) {
+  return (
+    request.mode === "navigate" ||
+    request.destination === "document" ||
+    (request.method === "GET" &&
+      request.headers.get("sec-fetch-mode") === "navigate")
+  );
 }
 
 // --- Cache Key ---
@@ -320,7 +143,6 @@ function cacheKey(request) {
   if (key) return new URL("/__swc/" + key, self.location.origin).href;
   const url = new URL(request.url);${normalizeCacheKey
         ? `
-  // Sort query params alphabetically for consistent cache keys
   if (url.search) {
     const params = new URLSearchParams(url.search);
     params.sort();
@@ -328,10 +150,9 @@ function cacheKey(request) {
   }`
         : ""}${ignoreQueryParams && ignoreQueryParams.length > 0
         ? `
-  // Strip configured query params from cache key
-  const ignore = ${JSON.stringify(ignoreQueryParams)};
   if (url.search) {
     const params = new URLSearchParams(url.search);
+    const ignore = ${JSON.stringify(ignoreQueryParams)};
     for (const key of ignore) params.delete(key);
     url.search = params.toString();
   }`
@@ -339,60 +160,216 @@ function cacheKey(request) {
   return url.href;
 }
 
-// --- Cache Helpers ---
+// --- Cache Lookup ---
 
 async function fromPrecache(request) {
-  const cache = await caches.open(CACHE_NAME);
-  return cache.match(new URL(request.url).pathname);
+  swLog("fromPrecache", "ENTER", request.url, 4);
+  const cache = await caches.open("precache");
+  const url = new URL(request.url);
+  url.search = "";
+  const result = await cache.match(url.href);
+  swLog("fromPrecache", result ? "HIT" : "MISS", request.url, 4);
+  return result;
 }
 
 async function fromRuntime(request) {
-  const cache = await caches.open(CACHE_NAME_RUNTIME);
-  return cache.match(cacheKey(request));
+  swLog("fromRuntime", "ENTER", request.url, 4);
+  const cache = await caches.open("swoff-runtime");
+  const result = await cache.match(cacheKey(request));
+  swLog("fromRuntime", result ? "HIT" : "MISS", request.url, 4);
+  return result;
 }
 
-async function storeRuntime(request, response) {
-  const cache = await caches.open(CACHE_NAME_RUNTIME);
-  const headers = new Headers(response.headers);
-  headers.set("X-SW-Cached-At", String(Date.now()));
-  const cloned = new Response(response.body, {
-    status: response.status,
-    statusText: response.statusText,
-    headers,
-  });
-  await cache.put(cacheKey(request), cloned);
+/*
+ * serveFromCache returns a cached Response, or null if nothing is cached.
+ *
+ * Mode-specific behaviour for navigation requests:
+ *   SPA:      bypass cache entirely → return null
+ *   SSR:      precache → runtime-html → null
+ *   Default:  same as SSR
+ *
+ * Non-navigation requests:
+ *   runtime → precache (content-type match only) → null
+ *
+ * Precache is content-type-gated for non-navigation requests to avoid
+ * serving HTML pages (stored with stripped extensions) for requests that
+ * expect a different content type (e.g. RSC payloads, JSON fetches).
+ */
+async function serveFromCache(request) {
+  swLog("serveFromCache", "ENTER", request.url, 3);
+  if (isNavRequest(request)) {
+    if (NAV_MODE === "spa") {
+      if (FALLBACK_PATH) {
+        const cache = await caches.open("precache");
+        const match = await cache.match(FALLBACK_PATH);
+        if (match) {
+          swLog("serveFromCache", "HIT fallback-path", request.url, 3);
+          return match;
+        }
+      }
+      swLog("serveFromCache", "MISS (SPA nav)", request.url, 3);
+      return null;
+    }
+    const pc = await fromPrecache(request);
+    if (pc) {
+      swLog("serveFromCache", "HIT precache (nav)", request.url, 3);
+      return pc;
+    }
+      const htmlCache = await caches.open("swoff-runtime-html");
+      const htmlMatch = await htmlCache.match(cacheKey(request));
+      if (htmlMatch) {
+        swLog("serveFromCache", "HIT runtime-html", request.url, 3);
+        return htmlMatch;
+      }
+      swLog("serveFromCache", "MISS (SSR/Default nav)", request.url, 3);
+      return null;
+    }
+    const cached = await fromRuntime(request);
+    if (cached) {
+      swLog("serveFromCache", "HIT runtime", request.url, 3);
+      return cached;
+    }
+    const pc = await fromPrecache(request);
+  if (pc) {
+    const accept = request.headers.get("Accept") || "*/*";
+    const pcType = (pc.headers.get("Content-Type") || "").split(";")[0].trim();
+    if (accept.includes(pcType) || accept.includes("*/*") || !pcType) {
+      swLog("serveFromCache", "HIT precache (sub)", request.url, 3);
+      return pc;
+    }
+    swLog("serveFromCache", "SKIP precache (type mismatch)", request.url, 3);
+  }
+  swLog("serveFromCache", "MISS (subresource)", request.url, 3);
+  return null;
 }
 
-async function cacheResponse(request, response) {
-  await storeRuntime(request, response);
-  const tagsHeader = request.headers.get("X-SW-Cache-Tags");
-  if (tagsHeader) {
-    const cacheKeyUrl = cacheKey(request);
-    const actualUrl = new URL(request.url).href;
-    const tags = tagsHeader.split(",").map((t) => t.trim());
-    const method = request.method;
-    let body = null;
-    let contentType = null;
-    if (method !== "GET" && method !== "HEAD") {
-      contentType = request.headers.get("Content-Type");
+// --- Cache Store ---
+
+/*
+ * cacheResponse stores a network response in the appropriate cache.
+ *
+ * If already in precache:
+ *   - non-HTML with same content-type → update precache entry
+ *   - otherwise → skip (no runtime duplicate)
+ * If not in precache:
+ *   - HTML → runtime-html cache
+ *   - non-HTML → runtime cache
+ *
+ * Tags are recorded in all cases.
+ */
+async function cacheResponse(response, request) {
+  swLog("cacheResponse", "ENTER", request.url, 3);
+  const key = cacheKey(request);
+  const ct = response.headers.get("Content-Type") || "";
+  var skipRuntime = false;
+  const precache = await caches.open("precache");
+  const url = new URL(key);
+  url.search = "";
+  const precached = await precache.match(url.href);
+
+  if (precached) {
+    if (!ct.startsWith("text/html")) {
+      const pct = precached.headers.get("Content-Type") || "";
+      if (pct.split(";")[0] === ct.split(";")[0]) {
+        try {
+          await precache.put(url.href, response.clone());
+          swLog("cacheResponse", "updated precache", request.url, 3);
+        } catch (e) {
+          swLog("cacheResponse", "precache update failed", request.url, 3);
+        }
+      }
+    }
+    skipRuntime = true;
+  }
+
+  if (!skipRuntime) {
+    const cacheName = ct.startsWith("text/html") ? "swoff-runtime-html" : "swoff-runtime";
+    const cache = await caches.open(cacheName);
+    const headers = new Headers(response.headers);
+    headers.set("X-SW-Cached-At", String(Date.now()));
+    const putResponse = new Response(response.body, {
+      status: response.status,
+      statusText: response.statusText,
+      headers,
+    });
+    try {
+      await cache.put(key, putResponse);
+      swLog("cacheResponse", "stored in " + cacheName, request.url, 3);
+    } catch (e) {
+      swLog("cacheResponse", "quota error, evicting stale entries", request.url, 3);
       try {
-        body = await request.clone().text();
+        // Evict stale runtime entries and retry once
+        for (const name of ["swoff-runtime", "swoff-runtime-html"]) {
+          const c = await caches.open(name);
+          const keys = await c.keys();
+          const now = Date.now();
+          for (const req of keys) {
+            const res = await c.match(req);
+            const cachedAt = res ? Number(res.headers.get("X-SW-Cached-At") || 0) : 0;
+            if (!cachedAt || now - cachedAt > 3600000) await c.delete(req);
+          }
+        }
+        await cache.put(key, putResponse.clone());
+        swLog("cacheResponse", "stored after eviction", request.url, 3);
       } catch {}
     }
-    await cacheTagUrl(cacheKeyUrl, actualUrl, tags, method, body, contentType);
-  }
+  }${tagCode}
 }
 
-async function fromSpaFallback(request) {
-  if (request.mode === "navigate") {
-    const cache = await caches.open(CACHE_NAME);
-    return cache.match("${spaPath}");
+// --- Fallback ---
+
+/*
+ * Fallback hierarchy for when a strategy cannot serve a response:
+ *   SSR / Default:  precache → runtime-html → per-route → global → inline 503
+ *   SPA:            per-route → inline 503
+ */
+async function fallback(request) {
+  swLog("fallback", "ENTER", request.url, 3);
+  const pc = await fromPrecache(request);
+  if (pc) {
+    swLog("fallback", "HIT precache", request.url, 3);
+    return pc;
+  }
+  if (NAV_MODE !== "spa") {
+      const htmlCache = await caches.open("swoff-runtime-html");
+      const htmlMatch = await htmlCache.match(cacheKey(request));
+      if (htmlMatch) {
+        swLog("fallback", "HIT runtime-html", request.url, 3);
+        return htmlMatch;
+      }
+    }${hasRules
+        ? `
+    const routeFallbackPath = matchRouteFallback(request.url);
+    if (routeFallbackPath) {
+      const cache = await caches.open("precache");
+      const match = await cache.match(routeFallbackPath);
+      if (match) {
+        swLog("fallback", "HIT per-route fallback", request.url, 3);
+        broadcastToClients("OFFLINE_FALLBACK_ACTIVATED", { detail: { route: new URL(request.url).pathname, fallbackLevel: "route-fallback", timestamp: Date.now() } });
+        return match;
+      }
+    }`
+        : ""}
+  if (NAV_MODE !== "spa") {
+    if (FALLBACK_PATH) {
+      const cache = await caches.open("precache");
+      const match = await cache.match(FALLBACK_PATH);
+      if (match) {
+        swLog("fallback", "HIT global fallback", request.url, 3);
+        broadcastToClients("OFFLINE_FALLBACK_ACTIVATED", { detail: { route: new URL(request.url).pathname, fallbackLevel: "offline-page", timestamp: Date.now() } });
+        return match;
+      }
+    }
   }
+  swLog("fallback", "HIT inline 503", request.url, 3);
+  broadcastToClients("OFFLINE_FALLBACK_ACTIVATED", { detail: { route: new URL(request.url).pathname, fallbackLevel: "inline-503", timestamp: Date.now() } });
+  return inline503Response();
 }
 
-// --- Response Helpers ---
+${inline503}// --- Response Helpers ---
 
 function markFromCache(response) {
+  swLog("markFromCache", "ENTER", response.url, 4);
   const headers = new Headers(response.headers);
   headers.set("X-SW-From-Cache", "true");
   return new Response(response.body, {
@@ -403,94 +380,309 @@ function markFromCache(response) {
 }
 
 function isStale(response, staleTimeSeconds) {
-  if (staleTimeSeconds == null || staleTimeSeconds <= 0) return false;
+  if (staleTimeSeconds == null) return false;
+  if (staleTimeSeconds === 0) return true;
+  if (staleTimeSeconds < 0) return false;
   const cachedAt = response.headers.get("X-SW-Cached-At");
   if (!cachedAt) return false;
   return Date.now() - Number(cachedAt) > staleTimeSeconds * 1000;
 }
 
-${GLOB_CODE}// --- Strategy Selection (3-tier config resolution) ---
+// --- Fetch Helpers ---
 
-function resolveStrategyEntry(entry) {
-  return typeof entry === "string" ? { strategy: entry } : entry;
+async function _fetchWithTimeout(_, request, timeoutMs) {
+  timeoutMs = timeoutMs || FETCH_TIMEOUT_MS;
+  swLog("_fetchWithTimeout", "ENTER timeout=" + timeoutMs, request.url, 3);
+  const controller = new AbortController();
+  const id = setTimeout(function() { controller.abort(); }, timeoutMs);
+  try {
+    const response = await fetch(request, { signal: controller.signal });
+    swLog("_fetchWithTimeout", "SUCCESS " + response.status, request.url, 3);
+    return response;
+  } catch (e) {
+    swLog("_fetchWithTimeout", "FAILED", request.url, 3);
+    throw e;
+  } finally {
+    clearTimeout(id);
+  }
 }
 
-function determineCacheStrategy(request, customStrategies, globalDefaults) {
+${navigationPreload
+        ? `
+async function fetchWithPreload(event, request, timeoutMs) {
+  swLog("fetchWithPreload", "ENTER", request.url, 3);
+  try {
+    const preload = await Promise.race([
+      event.preloadResponse,
+      new Promise(function(_, reject) {
+        setTimeout(function() { reject(new Error("preload timeout")); }, (timeoutMs || FETCH_TIMEOUT_MS) / 2);
+      }),
+    ]);
+    if (preload) {
+      swLog("fetchWithPreload", "HIT preload", request.url, 3);
+      return preload;
+    }
+  } catch {}
+  swLog("fetchWithPreload", "MISS preload, fallback to fetch", request.url, 3);
+  return _fetchWithTimeout(event, request, timeoutMs);
+}
+`
+        : ""}const _fetch = ${navigationPreload ? "fetchWithPreload" : "_fetchWithTimeout"};
+
+// --- Strategy Resolution ---
+
+function determineCacheStrategy(request) {
   const override = request.headers.get("X-SW-Strategy");
   if (override) {
-    const cfg = { strategy: override };
-    const hStale = request.headers.get("X-SW-Stale-Time");
-    if (hStale !== null) cfg.staleTime = Number(hStale);
-    const hFocus = request.headers.get("X-SW-Refetch-On-Focus");
-    if (hFocus !== null) cfg.refetchOnFocus = hFocus !== "false";
-    const hReconnect = request.headers.get("X-SW-Refetch-On-Reconnect");
-    if (hReconnect !== null) cfg.refetchOnReconnect = hReconnect !== "false";
-    return cfg;
+    if (override === "reactive") {
+      const staleTimeHeader = request.headers.get("X-SW-Stale-Time");
+      return {
+        strategy: "reactive",
+        timeoutMs: FETCH_TIMEOUT_MS,
+        staleTime: staleTimeHeader != null ? Number(staleTimeHeader) : REACTIVE_STALE_DEFAULT,
+        refetchInterval: Number(request.headers.get("X-SW-Refetch-Interval") || 0),
+        refetchOnFocus: request.headers.get("X-SW-Refetch-On-Focus") === "true",
+        refetchOnReconnect: request.headers.get("X-SW-Refetch-On-Reconnect") === "true",
+      };
+    }
+    return { strategy: override, timeoutMs: FETCH_TIMEOUT_MS };
   }
+
   const path = new URL(request.url).pathname;
-  for (const [pattern, entry] of Object.entries(customStrategies)) {
+  for (const [pattern, entry] of Object.entries(CUSTOM_STRATEGIES)) {
     if (matchGlob(path, pattern)) {
-      const resolved = resolveStrategyEntry(entry);
-      return { strategy: resolved.strategy };
+      const resolved = typeof entry === "string" ? { strategy: entry } : entry;
+      const timeoutMs = (resolved.timeout != null ? resolved.timeout * 1000 : FETCH_TIMEOUT_MS);
+      if (resolved.strategy === "reactive") {
+        return {
+          strategy: "reactive",
+          timeoutMs: timeoutMs,
+          staleTime: resolved.staleTime ?? REACTIVE_STALE_DEFAULT,
+          refetchInterval: resolved.refetchInterval ?? 0,
+          refetchOnFocus: resolved.refetchOnFocus ?? false,
+          refetchOnReconnect: resolved.refetchOnReconnect ?? false,
+        };
+      }
+      return { strategy: resolved.strategy, timeoutMs: timeoutMs };
     }
   }
-  return { strategy: globalDefaults.defaultStrategy };
+
+  if (DEFAULT_STRATEGY === "reactive") {
+    return {
+      strategy: "reactive",
+      timeoutMs: FETCH_TIMEOUT_MS,
+      staleTime: REACTIVE_STALE_DEFAULT,
+      refetchInterval: 0,
+      refetchOnFocus: false,
+      refetchOnReconnect: false,
+    };
+  }
+  return { strategy: DEFAULT_STRATEGY, timeoutMs: FETCH_TIMEOUT_MS };
 }
 
-function determineCacheStrategyForUrl(url, customStrategies, globalDefaults) {
-  const path = new URL(url).pathname;
-  for (const [pattern, entry] of Object.entries(customStrategies)) {
-    if (matchGlob(path, pattern)) {
-      const resolved = resolveStrategyEntry(entry);
-      return { strategy: resolved.strategy };
+// --- Reactive Entry Store ---
+
+var REACTIVE_ENTRIES = new Map();
+var REACTIVE_INTERVALS = new Map();
+var clearAllReactive = function() {
+  REACTIVE_INTERVALS.forEach(function(id) { clearInterval(id); });
+  REACTIVE_INTERVALS.clear();
+  REACTIVE_ENTRIES.clear();
+  swLog("clearAllReactive", "done", "", 0);
+};
+
+function registerReactiveEntry(url, actualUrl, config) {
+  swLog("registerReactiveEntry", "ENTER", url, 4);
+  if (REACTIVE_ENTRIES.has(url)) {
+    swLog("registerReactiveEntry", "SKIP already registered", url, 4);
+    return;
+  }
+  REACTIVE_ENTRIES.set(url, {
+    actualUrl: actualUrl,
+    refetchOnFocus: !!config.refetchOnFocus,
+    refetchOnReconnect: !!config.refetchOnReconnect,
+    refetchInterval: config.refetchInterval || 0,
+    staleTime: config.staleTime || 0,
+    lastRefetch: 0,
+  });
+  if ((config.refetchInterval || 0) > 0 && !REACTIVE_INTERVALS.has(url)) {
+    var id = setInterval(function() { refetchEntry(url); }, (config.refetchInterval || 0) * 1000);
+    REACTIVE_INTERVALS.set(url, id);
+    swLog("registerReactiveEntry", "interval=" + config.refetchInterval + "s", url, 4);
+  }
+}
+
+async function refetchEntry(url) {
+  swLog("refetchEntry", "ENTER", url, 4);
+  var entry = REACTIVE_ENTRIES.get(url);
+  var fetchUrl = entry ? entry.actualUrl || url : url;
+  var req = new Request(fetchUrl);
+  if (entry) {
+    var cached = await serveFromCache(req);
+    if (cached && !isStale(cached, entry.staleTime)) {
+      swLog("refetchEntry", "SKIP fresh in cache", url, 4);
+      entry.lastRefetch = Date.now();
+      return;
     }
   }
-  return { strategy: globalDefaults.defaultStrategy };
+  try {
+    var response = await fetchWithRetry(req, REFETCH_RETRY);
+    if (response && response.ok) {
+      await cacheResponse(response.clone(), req);
+      if (entry) entry.lastRefetch = Date.now();
+      swLog("refetchEntry", "SUCCESS", url, 4);
+      broadcastToClients("CACHE_UPDATED", { url: fetchUrl });
+    }
+    checkAuthFailure(response);
+  } catch {}
 }
 
-function applyStrategy(event, request, config) {
-  const { strategy } = config;
-  if (strategy === "reactive") {
-    const reactiveCfg = findReactiveConfig(new URL(request.url).href);
-    const staleTime = config.staleTime !== undefined ? config.staleTime : reactiveCfg?.staleTime;
-    event.respondWith(reactiveStrategy(event, request, staleTime));
-  } else if (strategy === "stale-while-revalidate") {
-    event.respondWith(staleWhileRevalidate(event, request));
-  } else if (strategy === "network-first") {
-    event.respondWith(networkFirst(event, request));
-  } else if (strategy === "cache-only") {
-    event.respondWith(cacheOnly(event, request));
-  } else if (strategy === "network-only") {
-    event.respondWith(networkOnly(event, request));
-  } else {
-    event.respondWith(cacheFirst(event, request));
+function handleRefetch(prop) {
+  swLog("handleRefetch", "ENTER prop=" + prop + " entries=" + REACTIVE_ENTRIES.size, "", 0);
+  REACTIVE_ENTRIES.forEach(function(config, url) {
+    if (config[prop]) queueRefresh(url);
+  });
+}
+
+async function checkAuthFailure(response) {
+  if (response && isAuthFailureResponse(response)) {
+    swLog("checkAuthFailure", "AUTH_FAILURE", response.url || "", 1);
+    broadcastToClients("AUTH_FAILURE");
+  }
+}
+
+// --- Strategies ---
+
+/*
+ * Reactive:   serve fresh from cache; if stale/miss → network → fallback
+ * Network-Only: network → fallback (cache ok responses)
+ * Network-First: network → cache (on fail) → fallback
+ * Cache-First: cache → network (on miss) → fallback
+ * Stale-While-Revalidate: stale cache immediately + bg network refresh → fallback
+ * Cache-Only: cache only → 404
+ */
+
+async function reactiveStrategy(event, request, config) {
+  swLog("reactiveStrategy", "ENTER", request.url, 2);
+  const staleTime = config.staleTime != null ? config.staleTime : REACTIVE_STALE_DEFAULT;
+  const cached = await serveFromCache(request);
+  if (cached && !isStale(cached, staleTime)) return markFromCache(cached);
+
+  if (cached && isStale(cached, staleTime)) {
+    event.waitUntil(queueRefresh(cacheKey(request)));
+    return markFromCache(cached);
+  }
+
+  try {
+    const response = await _fetch(event, request, config.timeoutMs);
+    checkAuthFailure(response);
+    if (response.ok) {
+      event.waitUntil(cacheResponse(response.clone(), request));
+      return response;
+    }
+    return fallback(request);
+  } catch {
+    return fallback(request);
+  }
+}
+
+async function networkFirstStrategy(event, request, config) {
+  swLog("networkFirstStrategy", "ENTER", request.url, 2);
+  try {
+    const response = await _fetch(event, request, config.timeoutMs);
+    checkAuthFailure(response);
+    if (response.ok) {
+      event.waitUntil(cacheResponse(response.clone(), request));
+      return response;
+    }
+    const cached = await serveFromCache(request);
+    if (cached) return markFromCache(cached);
+    return fallback(request);
+  } catch {
+    const cached = await serveFromCache(request);
+    if (cached) return markFromCache(cached);
+    return fallback(request);
+  }
+}
+
+async function cacheFirstStrategy(event, request, config) {
+  swLog("cacheFirstStrategy", "ENTER", request.url, 2);
+  const cached = await serveFromCache(request);
+  if (cached) return markFromCache(cached);
+
+  try {
+    const response = await _fetch(event, request, config.timeoutMs);
+    checkAuthFailure(response);
+    if (response.ok) {
+      event.waitUntil(cacheResponse(response.clone(), request));
+      return response;
+    }
+    return fallback(request);
+  } catch {
+    return fallback(request);
   }
 }
 
+async function staleWhileRevalidateStrategy(event, request, config) {
+  swLog("staleWhileRevalidateStrategy", "ENTER", request.url, 2);
+  const cached = await serveFromCache(request);
+
+  event.waitUntil(queueRefresh(cacheKey(request)));
+
+  if (cached) return markFromCache(cached);
+  try {
+    const response = await _fetch(event, request, config.timeoutMs);
+    checkAuthFailure(response);
+    if (response.ok) {
+      event.waitUntil(cacheResponse(response.clone(), request));
+      return response;
+    }
+    return fallback(request);
+  } catch {
+    return fallback(request);
+  }
+}
+
+async function cacheOnlyStrategy(event, request, _config) {
+  swLog("cacheOnlyStrategy", "ENTER", request.url, 2);
+  const cached = await serveFromCache(request);
+  if (cached) return markFromCache(cached);
+  swLog("cacheOnlyStrategy", "MISS 404", request.url, 2);
+  return new Response("Not in cache", { status: 404 });
+}
+
+const STRATEGY_HANDLERS = {
+  "reactive": reactiveStrategy,
+  "network-first": networkFirstStrategy,
+  "cache-first": cacheFirstStrategy,
+  "stale-while-revalidate": staleWhileRevalidateStrategy,
+  "cache-only": cacheOnlyStrategy,
+};
+
+async function _executeStrategy(event, request, config) {
+  swLog("_executeStrategy", "ENTER strategy=" + config.strategy, request.url, 1);
+  const handler = STRATEGY_HANDLERS[config.strategy] || cacheFirstStrategy;
+  try {
+    return await handler(event, request, config);
+  } catch {
+    swLog("_executeStrategy", "ERROR strategy=" + config.strategy, request.url, 1);
+    return fallback(request);
+  }
+}
+
+function applyStrategy(event, request, config) {
+  event.respondWith(_executeStrategy(event, request, config));
+}
+
 ${mutationQueueEnabled
         ? `// --- Mutation Queue IDB Helpers ---
 
 const MUTATION_DB_NAME = "swoff-queue";
 const MUTATION_STORE_NAME = "mutations";
-// Bump this when adding new indexes/stores for schema migration
 const MUTATION_DB_VERSION = 1;
 
-function openMutationQueueDB() {
-  return new Promise((resolve, reject) => {
-    const request = indexedDB.open(MUTATION_DB_NAME, MUTATION_DB_VERSION);
-    request.onupgradeneeded = (e) => {
-      const db = e.target.result;
-      if (!db.objectStoreNames.contains(MUTATION_STORE_NAME)) {
-        const store = db.createObjectStore(MUTATION_STORE_NAME, { keyPath: "id" });
-        store.createIndex("by-timestamp", "timestamp");
-      }
-    };
-    request.onsuccess = (e) => resolve(e.target.result);
-    request.onerror = (e) => reject(e.target.error);
-  });
-}
-
 async function storeMutationInSW(request) {
+  swLog("storeMutationInSW", "ENTER", request.url, 4);
   let body, bodyType;
   try {
     body = await request.clone().json();
@@ -503,9 +695,19 @@ async function storeMutationInSW(request) {
   const tagsHeader = request.headers.get("X-SW-Invalidate-Tags");
   const tags = tagsHeader ? tagsHeader.split(",").map(function(t) { return t.trim(); }) : [];
 
-  const db = await openMutationQueueDB();
+  const db = await openDB(MUTATION_DB_NAME, MUTATION_DB_VERSION, function(db) {
+    if (!db.objectStoreNames.contains(MUTATION_STORE_NAME)) {
+      const store = db.createObjectStore(MUTATION_STORE_NAME, { keyPath: "id" });
+      store.createIndex("by-timestamp", "timestamp");
+    }
+  });${maxCacheAge && maxCacheAge > 0
+            ? `
+  // Prune expired entries in a separate transaction
+  await pruneStaleStore(db, MUTATION_STORE_NAME, Date.now() - MAX_RUNTIME_CACHE_AGE * 1000, "id");`
+            : ""}
   const tx = db.transaction(MUTATION_STORE_NAME, "readwrite");
-  tx.objectStore(MUTATION_STORE_NAME).add({
+  const store = tx.objectStore(MUTATION_STORE_NAME);
+  store.add({
     id: crypto.randomUUID(),
     method: request.method,
     url: new URL(request.url).href,
@@ -517,26 +719,54 @@ async function storeMutationInSW(request) {
     nextRetryAt: 0,
     tags,
   });
-  await new Promise(function(resolve, reject) {
-    tx.oncomplete = function() { resolve(); };
-    tx.onerror = function() { reject(tx.error); };
-  });
+  try {
+    await new Promise(function(resolve, reject) {
+      tx.oncomplete = function() { resolve(); };
+      tx.onerror = function() { reject(tx.error); };
+    });
+    swLog("storeMutationInSW", "STORED", request.url, 4);
+  } finally {
+    db.close();
+  }
+}
+
+async function _fetchMutation(request) {
+  swLog("_fetchMutation", "ENTER", request.url, 4);
+  const controller = new AbortController();
+  const id = setTimeout(() => controller.abort(), FETCH_TIMEOUT_MS);
+  try {
+    const response = await fetch(request, { signal: controller.signal });
+    swLog("_fetchMutation", "SUCCESS " + response.status, request.url, 4);
+    return response;
+  } catch (e) {
+    swLog("_fetchMutation", "FAILED", request.url, 4);
+    throw e;
+  } finally {
+    clearTimeout(id);
+  }
 }
 
 async function handleMutation(event) {
+  swLog("handleMutation", "ENTER", event.request.url, 3);
   const request = event.request;
   if (request.headers.get("X-SW-No-Queue") === "true") {
-    return fetch(request.clone());
+    swLog("handleMutation", "no-queue mode", request.url, 3);
+    try {
+      const response = await _fetchMutation(request.clone());
+      checkAuthFailure(response);
+      return response;
+    } catch {
+      throw new Error("Mutation failed (no-queue mode)");
+    }
   }
   try {
-    return await fetch(request.clone());
+    const response = await _fetchMutation(request.clone());
+    checkAuthFailure(response);
+    return response;
   } catch {
+    swLog("handleMutation", "queuing mutation", request.url, 3);
     await storeMutationInSW(request);
-    // Notify open clients that a mutation was stored so they can try to process
-    const clients = await self.clients.matchAll();
-    clients.forEach(function(client) {
-      client.postMessage({ type: "MUTATION_STORED" });
-    });
+    broadcastToClients("MUTATION_STORED");
     const queuedBody = JSON.stringify({ queued: true });
     return new Response(queuedBody, {
       status: 202,
@@ -548,146 +778,42 @@ async function handleMutation(event) {
 
 `
         : ""}self.addEventListener("fetch", (event) => {
-  const { request } = event;${mutationQueueEnabled
+  const { request } = event;
+  swLog("fetch", "INCOMING", request.url, 0);${serverPushEndpoint
+        ? `
+  if (SERVER_PUSH_ENDPOINT && new URL(request.url).pathname.includes(SERVER_PUSH_ENDPOINT)) {
+    swLog("fetch", "server-push-bypass", request.url, 0);
+    return;
+  }`
+        : ""}${authRoutePaths.length > 0
         ? `
-  if (request.method !== "GET" && request.method !== "HEAD") {
-    if (request.headers.get("X-SW-Cache-Strategy") === "mutation") {
+  if (AUTH_ROUTES.some(function(route) { return new URL(request.url).pathname.includes(route); })) {
+    swLog("fetch", "auth-route-bypass", request.url, 0);
+    return;
+  }`
+        : ""}
+  if (request.headers.get("X-SW-Strategy") === "network-only") {
+    swLog("fetch", "strategy=network-only", request.url, 0);
+    return;
+  }${mutationQueueEnabled
+        ? `
+  if (request.method !== "GET") {
+    if (request.headers.get("X-SW-Type") === "mutation") {
       event.respondWith(handleMutation(event));
       return;
     }
-    if (!request.headers.get("X-SW-Cache-Key")) return;
+    if (!request.headers.get("X-SW-Cache-Key")) { return; }
   }`
         : `
-  if (request.method !== "GET" && request.method !== "HEAD") {
-    if (!request.headers.get("X-SW-Cache-Key")) return;
+  if (request.method !== "GET") {
+    if (!request.headers.get("X-SW-Cache-Key")) { return; }
   }`}
-  ${cacheStrategy === "explicit-only" ? `if (!request.headers.get("X-SW-Cache-Strategy")) return;` : ""}
-  applyStrategy(event, request, determineCacheStrategy(event.request, ${JSON.stringify(strategies)}, { defaultStrategy: "${defaultStrategy}" }));
-});
-
-// --- Strategies ---
-
-${navigationPreload
-        ? `
-async function fetchWithPreload(event, request) {
-  try {
-    const preload = await event.preloadResponse;
-    if (preload) return preload;
-  } catch {}
-  return fetch(request);
-}
-`
-        : ""}const _fetch = ${navigationPreload ? "fetchWithPreload" : `(event, request) => fetch(request)`};
-
-async function cacheFirst(event, request) {
-  const cached = await fromRuntime(request);
-  if (cached) {${staleVersionCode}
-    return markFromCache(cached);
+  const cfg = determineCacheStrategy(request);
+  swLog("fetch", "strategy=" + cfg.strategy, request.url, 0);
+  if (cfg.strategy === "reactive") {
+    registerReactiveEntry(cacheKey(request), request.url, cfg);
   }
-
-  const precached = await fromPrecache(request);
-  if (precached) return markFromCache(precached);
-
-  const fallback = await fromSpaFallback(request);
-  if (fallback) return fallback;
-
-  const reqForCache = request.clone();
-  const response = await _fetch(event, request);
-  if (response.ok) {
-    const responseToCache = response.clone();
-    event.waitUntil(cacheResponse(reqForCache, responseToCache));
-  }
-  return response;
-}
-
-async function networkFirst(event, request) {
-  try {
-    const reqForCache = request.clone();
-    const response = await _fetch(event, request);
-    if (response.ok) {
-      const responseToCache = response.clone();
-      event.waitUntil(cacheResponse(reqForCache, responseToCache));
-    }
-    return response;
-  } catch {
-    const cached = await fromRuntime(request);
-    if (cached) {
-      return markFromCache(cached);
-    }
-
-    const precached = await fromPrecache(request);
-    if (precached) return markFromCache(precached);
-
-    const fallback = await fromSpaFallback(request);
-    if (fallback) return fallback;
-
-    throw new Error("Network request failed and no cached response available");
-  }
-}
-
-async function staleWhileRevalidate(event, request) {
-  const cached = await fromRuntime(request);
-  if (cached) {
-    event.waitUntil(queueRefresh(cacheKey(request), new URL(request.url).href));
-    return markFromCache(cached);
-  }
-
-  const precached = await fromPrecache(request);
-  if (precached) {
-    event.waitUntil(queueRefresh(cacheKey(request), new URL(request.url).href));
-    return markFromCache(precached);
-  }
-
-  const reqForCache = request.clone();
-  const response = await _fetch(event, request);
-  if (response.ok) {
-    const responseToCache = response.clone();
-    await cacheResponse(reqForCache, responseToCache);
-  }
-  return response;
-}
-
-async function reactiveStrategy(event, request, staleTime) {
-  const cached = await fromRuntime(request);
-  // Per-request staleTime header overrides config-level staleTime
-  const headerStale = request.headers.get("X-SW-Stale-Time");
-  const effectiveStaleTime = headerStale !== null ? Number(headerStale) : staleTime;
-  if (cached) {${staleVersionCode}
-    if (shouldReactiveRefresh(cached, { staleTime: effectiveStaleTime })) {
-      event.waitUntil(queueRefresh(cacheKey(request), new URL(request.url).href));
-    }
-    return markFromCache(cached);
-  }
-
-  const precached = await fromPrecache(request);
-  if (precached) return markFromCache(precached);
-
-  const fallback = await fromSpaFallback(request);
-  if (fallback) return fallback;
-
-  const reqForCache = request.clone();
-  const response = await _fetch(event, request);
-  if (response.ok) {
-    const responseToCache = response.clone();
-    await cacheResponse(reqForCache, responseToCache);
-  }
-  return response;
-}
-
-async function cacheOnly(event, request) {
-  const cached = await fromRuntime(request);
-  if (cached) {${staleVersionCode}
-    return markFromCache(cached);
-  }
-
-  const precached = await fromPrecache(request);
-  if (precached) return markFromCache(precached);
-
-  return new Response("Not in cache", { status: 404 });
-}
-
-async function networkOnly(event, request) {
-  return _fetch(event, request);
-}`;
+  applyStrategy(event, request, cfg);
+});`;
 }
 //# sourceMappingURL=fetch-handler.js.map