@swoff/cli 0.3.9 → 0.3.10

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

@@ -22,21 +22,25 @@
  * 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 ? `
+    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 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);
-  }` : "";
+  }`
+        : "";
     const reactGlobalDefaults = {
         staleTime: globalStaleTime,
         refetchInterval: globalRefetchInterval,
@@ -64,44 +68,42 @@ const REFRESH_MAX_RETRIES = ${refetchMaxRetries};
 const REFRESH_RETRY_DELAY_MS = ${refetchRetryDelayMs};`;
     const GLOB_CODE = "\n" +
         "// --- Glob Pattern Matching ---\n" +
-        "// NOTE: This is an inline copy of the algorithm in shared/glob-matcher.ts.\n" +
-        "// Keep the two implementations in sync when making changes.\n" +
         "\n" +
         "function escapeGlobMeta(s) {\n" +
-        "  return s.replace(/[.+^${}()|[\\]\\\\]/g, \"\\\\$$&\");\n" +
+        '  return s.replace(/[.+^${}()|[\\]\\\\]/g, "\\\\$$&");\n' +
         "}\n" +
         "\n" +
         "function globPartRe(part) {\n" +
-        "  for (var o = \"\", i = 0; i < part.length; i++) {\n" +
+        '  for (var o = "", i = 0; i < part.length; i++) {\n' +
         "    var c = part[i];\n" +
-        "    if (c === \"*\") { o += \"[^/]*\"; }\n" +
-        "    else if (c === \"?\") { o += \"[^/]\"; }\n" +
-        "    else if (c === \"{\") {\n" +
-        "      var cl = part.indexOf(\"}\", i);\n" +
-        "      if (cl === -1) { o += \"\\\\\" + c; }\n" +
+        '    if (c === "*") { o += "[^/]*"; }\n' +
+        '    else if (c === "?") { o += "[^/]"; }\n' +
+        '    else if (c === "{") {\n' +
+        '      var cl = part.indexOf("}", i);\n' +
+        '      if (cl === -1) { o += "\\\\" + c; }\n' +
         "      else {\n" +
-        "        o += \"(?:\" + part.slice(i + 1, cl).split(\",\").map(function(s) { return escapeGlobMeta(s.trim()); }).join(\"|\") + \")\";\n" +
+        '        o += "(?:" + part.slice(i + 1, cl).split(",").map(function(s) { return escapeGlobMeta(s.trim()); }).join("|") + ")";\n' +
         "        i = cl;\n" +
         "      }\n" +
-        "    } else { o += \"\\\\\" + c; }\n" +
+        '    } else { o += "\\\\" + c; }\n' +
         "  }\n" +
         "  return o;\n" +
         "}\n" +
         "\n" +
         "function matchGlob(path, pattern) {\n" +
-        "  if (pattern.charAt(0) === \"!\") return !matchGlob(path, pattern.slice(1));\n" +
-        "  var parts = pattern.split(\"/\").filter(Boolean);\n" +
-        "  var pps = path.split(\"/\").filter(Boolean);\n" +
+        '  if (pattern.charAt(0) === "!") return !matchGlob(path, pattern.slice(1));\n' +
+        '  var parts = pattern.split("/").filter(Boolean);\n' +
+        '  var pps = path.split("/").filter(Boolean);\n' +
         "  var pi = 0, ppi = 0;\n" +
         "  while (pi < parts.length && ppi < pps.length) {\n" +
         "    var part = parts[pi];\n" +
-        "    if (part === \"**\") {\n" +
+        '    if (part === "**") {\n' +
         "      if (pi === parts.length - 1) return true;\n" +
         "      var nxt = parts[pi + 1];\n" +
         "      var found = -1;\n" +
         "      for (var j = ppi; j < pps.length; j++) {\n" +
-        "        if (nxt.indexOf(\"*\") > -1 || nxt.indexOf(\"?\") > -1 || nxt.indexOf(\"{\") > -1) {\n" +
-        "          if (new RegExp(\"^\" + globPartRe(nxt) + \"$\").test(pps[j])) { found = j; break; }\n" +
+        '        if (nxt.indexOf("*") > -1 || nxt.indexOf("?") > -1 || nxt.indexOf("{") > -1) {\n' +
+        '          if (new RegExp("^" + globPartRe(nxt) + "$").test(pps[j])) { found = j; break; }\n' +
         "        } else if (nxt === pps[j]) { found = j; break; }\n" +
         "      }\n" +
         "      if (found === -1) return false;\n" +
@@ -109,8 +111,8 @@ const REFRESH_RETRY_DELAY_MS = ${refetchRetryDelayMs};`;
         "      pi++;\n" +
         "      continue;\n" +
         "    }\n" +
-        "    if (part.indexOf(\"*\") > -1 || part.indexOf(\"?\") > -1 || part.indexOf(\"{\") > -1) {\n" +
-        "      if (!new RegExp(\"^\" + globPartRe(part) + \"$\").test(pps[ppi])) return false;\n" +
+        '    if (part.indexOf("*") > -1 || part.indexOf("?") > -1 || part.indexOf("{") > -1) {\n' +
+        '      if (!new RegExp("^" + globPartRe(part) + "$").test(pps[ppi])) return false;\n' +
         "    } else if (part !== pps[ppi]) return false;\n" +
         "    pi++;\n" +
         "    ppi++;\n" +
@@ -122,86 +124,105 @@ const REFRESH_RETRY_DELAY_MS = ${refetchRetryDelayMs};`;
 // --- Batch Refresh Queue ---
 
 const _refreshQueue = new Map();
-let _refreshQueueProcessing = false;
 let _refreshQueuePromise = null;
 
-function queueRefresh(cacheKeyUrl, actualUrl${tagInvalidation ? ", tags" : ""}) {
-  // Use Map keyed by cacheKey for proper deduplication${tagInvalidation ? `
+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" : ""} });
+  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().finally(() => {
-      _refreshQueuePromise = null;
-      if (_refreshQueue.size > 0) queueRefresh();
-    });
+    _refreshQueuePromise = _processRefreshQueue();
   }
   return _refreshQueuePromise;
 }
 
-function resolveActualUrl(entry) {
-  const url = entry.actualUrl || entry.cacheKey;
+async function resolveActualUrl(entry) {
+  if (entry.actualUrl) return entry.actualUrl;
+  const url = entry.cacheKey;
   if (url.includes("/__swc/")) {
-    // Virtual cache key — use the stored actual URL from tag registry
-    return url;
+    // 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() {
-  while (_refreshQueue.size > 0) {
-    const batch = [];
-    for (const [cacheKey, entry] of _refreshQueue) {
-      if (batch.length >= REFETCH_BATCH_SIZE) break;
-      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 = resolveActualUrl(entry);
-      try {
-        const response = await fetch(fetchUrl);
-        if (response.ok) {
-          const request = new Request(entry.cacheKey);
-          await storeRuntime(request, response);${tagInvalidation ? `
+  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
+        ? `
           if (entry.tags && typeof cacheTagUrl !== "undefined") {
-            await cacheTagUrl(entry.cacheKey, fetchUrl, entry.tags);
-          }` : ""}
-          // Clean up stale version tracking on successful refresh
-          if (typeof staleVersions !== "undefined" && staleVersions.has(entry.cacheKey)) {
-            staleVersions.delete(entry.cacheKey);
+            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 });
+            }
           }
-          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);
           }
         }
-      } 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);
-          _refreshQueue.set(entry.cacheKey, entry);
-          // Schedule re-processing after delay
-          setTimeout(() => {
-            if (!_refreshQueuePromise) {
-              _refreshQueuePromise = _processRefreshQueue().finally(() => {
-                _refreshQueuePromise = null;
-                if (_refreshQueue.size > 0) queueRefresh();
-              });
-            }
-          }, delay);
-        }
-      }
-    }));
+      }));
 
-    if (_refreshQueue.size > 0 && REFETCH_BATCH_DELAY_MS > 0) {
-      await new Promise(r => setTimeout(r, REFETCH_BATCH_DELAY_MS));
+      if (_refreshQueue.size > 0 && REFETCH_BATCH_DELAY_MS > 0) {
+        await new Promise(r => setTimeout(r, REFETCH_BATCH_DELAY_MS));
+      }
     }
+  } finally {
+    _refreshQueuePromise = null;
   }
-  _refreshQueueProcessing = false;
 }
 
 // --- Reactive Patterns (extracted for interval/focus/reconnect) ---
@@ -230,7 +251,8 @@ ${(() => {
             return "";
         return `// Start intervals for reactive patterns with refetchInterval
 (async () => {
-${patternsWithInterval.map(p => `  setInterval(async () => {
+${patternsWithInterval
+            .map((p) => `  setInterval(async () => {
     const cache = await caches.open(CACHE_NAME_RUNTIME);
     const keys = await cache.keys();
     for (const request of keys) {
@@ -244,7 +266,8 @@ ${patternsWithInterval.map(p => `  setInterval(async () => {
         queueRefresh(request.url, url.href);
       }
     }
-  }, ${p.refetchInterval * 1000});`).join("\n")}
+  }, ${p.refetchInterval * 1000});`)
+            .join("\n")}
 })();
 `;
     })()}
@@ -295,13 +318,15 @@ async function handleOnFocus() {
 function cacheKey(request) {
   const key = request.headers.get("X-SW-Cache-Key");
   if (key) return new URL("/__swc/" + key, self.location.origin).href;
-  const url = new URL(request.url);${normalizeCacheKey ? `
+  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();
     url.search = params.toString();
-  }` : ""}${ignoreQueryParams && ignoreQueryParams.length > 0
+  }`
+        : ""}${ignoreQueryParams && ignoreQueryParams.length > 0
         ? `
   // Strip configured query params from cache key
   const ignore = ${JSON.stringify(ignoreQueryParams)};
@@ -339,7 +364,23 @@ async function storeRuntime(request, response) {
 }
 
 async function cacheResponse(request, response) {
-  await storeRuntime(request, response);${tagCode}
+  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");
+      try {
+        body = await request.clone().text();
+      } catch {}
+    }
+    await cacheTagUrl(cacheKeyUrl, actualUrl, tags, method, body, contentType);
+  }
 }
 
 async function fromSpaFallback(request) {
@@ -362,7 +403,7 @@ function markFromCache(response) {
 }
 
 function isStale(response, staleTimeSeconds) {
-  if (!staleTimeSeconds || staleTimeSeconds <= 0) return false;
+  if (staleTimeSeconds == null || staleTimeSeconds <= 0) return false;
   const cachedAt = response.headers.get("X-SW-Cached-At");
   if (!cachedAt) return false;
   return Date.now() - Number(cachedAt) > staleTimeSeconds * 1000;
@@ -377,7 +418,14 @@ function resolveStrategyEntry(entry) {
 function determineCacheStrategy(request, customStrategies, globalDefaults) {
   const override = request.headers.get("X-SW-Strategy");
   if (override) {
-    return { strategy: 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;
   }
   const path = new URL(request.url).pathname;
   for (const [pattern, entry] of Object.entries(customStrategies)) {
@@ -404,7 +452,8 @@ function applyStrategy(event, request, config) {
   const { strategy } = config;
   if (strategy === "reactive") {
     const reactiveCfg = findReactiveConfig(new URL(request.url).href);
-    event.respondWith(reactiveStrategy(event, request, reactiveCfg?.staleTime));
+    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") {
@@ -418,14 +467,17 @@ function applyStrategy(event, request, config) {
   }
 }
 
-${mutationQueueEnabled ? `// --- Mutation Queue IDB Helpers ---
+${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, 1);
+    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)) {
@@ -459,7 +511,7 @@ async function storeMutationInSW(request) {
     url: new URL(request.url).href,
     body,
     bodyType,
-    headers: {},
+    headers: request.headers.get("Content-Type") ? { "Content-Type": request.headers.get("Content-Type") } : {},
     timestamp: Date.now(),
     retryCount: 0,
     nextRetryAt: 0,
@@ -494,15 +546,18 @@ async function handleMutation(event) {
   }
 }
 
-` : ""}self.addEventListener("fetch", (event) => {
-  const { request } = event;${mutationQueueEnabled ? `
+`
+        : ""}self.addEventListener("fetch", (event) => {
+  const { request } = event;${mutationQueueEnabled
+        ? `
   if (request.method !== "GET" && request.method !== "HEAD") {
     if (request.headers.get("X-SW-Cache-Strategy") === "mutation") {
       event.respondWith(handleMutation(event));
       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;
   }`}
@@ -512,7 +567,8 @@ async function handleMutation(event) {
 
 // --- Strategies ---
 
-${navigationPreload ? `
+${navigationPreload
+        ? `
 async function fetchWithPreload(event, request) {
   try {
     const preload = await event.preloadResponse;
@@ -520,7 +576,8 @@ async function fetchWithPreload(event, request) {
   } catch {}
   return fetch(request);
 }
-` : ""}const _fetch = ${navigationPreload ? "fetchWithPreload" : `(event, request) => fetch(request)`};
+`
+        : ""}const _fetch = ${navigationPreload ? "fetchWithPreload" : `(event, request) => fetch(request)`};
 
 async function cacheFirst(event, request) {
   const cached = await fromRuntime(request);
@@ -534,20 +591,22 @@ async function cacheFirst(event, request) {
   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(request, responseToCache));
+    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(request, responseToCache));
+      event.waitUntil(cacheResponse(reqForCache, responseToCache));
     }
     return response;
   } catch {
@@ -579,10 +638,11 @@ async function staleWhileRevalidate(event, request) {
     return markFromCache(precached);
   }
 
+  const reqForCache = request.clone();
   const response = await _fetch(event, request);
   if (response.ok) {
     const responseToCache = response.clone();
-    await cacheResponse(request, responseToCache);
+    await cacheResponse(reqForCache, responseToCache);
   }
   return response;
 }
@@ -605,10 +665,11 @@ async function reactiveStrategy(event, request, staleTime) {
   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(request, responseToCache);
+    await cacheResponse(reqForCache, responseToCache);
   }
   return response;
 }

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

@@ -1 +1 @@
-{"version":3,"file":"fetch-handler.js","sourceRoot":"","sources":["../../../../src/lib/generators/sw-sections/fetch-handler.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"fetch-handler.js","sourceRoot":"","sources":["../../../../src/lib/generators/sw-sections/fetch-handler.ts"],"names":[],"mappings":"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"}

package/dist/lib/generators/sw-sections/glob-matcher-code.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"glob-matcher-code.js","sourceRoot":"","sources":["../../../../src/lib/generators/sw-sections/glob-matcher-code.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,MAAM,CAAC,MAAM,iBAAiB,GAAG,IAAI;IACrC,oCAAoC;IACpC,IAAI;IACJ,gCAAgC;IAChC,0DAA0D;IAC1D,KAAK;IACL,IAAI;IACJ,+BAA+B;IAC/B,qDAAqD;IACrD,wBAAwB;IACxB,wCAAwC;IACxC,4CAA4C;IAC5C,6BAA6B;IAC7B,wCAAwC;IACxC,6CAA6C;IAC7C,gBAAgB;IAChB,gIAAgI;IAChI,mBAAmB;IACnB,WAAW;IACX,mCAAmC;IACnC,OAAO;IACP,eAAe;IACf,KAAK;IACL,IAAI;IACJ,uCAAuC;IACvC,+EAA+E;IAC/E,qDAAqD;IACrD,gDAAgD;IAChD,0BAA0B;IAC1B,qDAAqD;IACrD,6BAA6B;IAC7B,4BAA4B;IAC5B,mDAAmD;IACnD,kCAAkC;IAClC,yBAAyB;IACzB,kDAAkD;IAClD,0FAA0F;IAC1F,6FAA6F;IAC7F,4DAA4D;IAC5D,WAAW;IACX,yCAAyC;IACzC,sBAAsB;IACtB,eAAe;IACf,mBAAmB;IACnB,SAAS;IACT,yFAAyF;IACzF,qFAAqF;IACrF,mDAAmD;IACnD,aAAa;IACb,cAAc;IACd,OAAO;IACP,uDAAuD;IACvD,KAAK;IACL,IAAI,CAAC"}

package/dist/lib/generators/sw-sections/server-push-handler.js

@@ -48,6 +48,14 @@ self.addEventListener("activate", (event) => {
     return `
 // --- Server Push Events (SSE) ---
 
+function notifyClientsSSE(connected) {
+  self.clients.matchAll().then(function(clients) {
+    clients.forEach(function(client) {
+      client.postMessage({ type: "SSE_STATUS", connected: !!connected });
+    });
+  });
+}
+
 let pushReconnectTimer = null;
 let pushAbortController = null;
 
@@ -56,12 +64,15 @@ async function connectPushEvents() {
     pushAbortController = new AbortController();
     const response = await fetch("${endpoint}", {
       headers: { Accept: "text/event-stream" },
+      credentials: "include",
       signal: pushAbortController.signal,
     });
     if (!response.ok || !response.body) {
+      notifyClientsSSE(false);
       scheduleReconnect();
       return;
     }
+    notifyClientsSSE(true);
     const reader = response.body.getReader();
     const decoder = new TextDecoder();
     let buffer = "";
@@ -98,6 +109,7 @@ async function connectPushEvents() {
   } catch {
     // Connection lost or aborted
   }
+  notifyClientsSSE(false);
   scheduleReconnect();
 }
 

package/dist/lib/generators/sw-sections/server-push-handler.js.map

@@ -1 +1 @@
-{"version":3,"file":"server-push-handler.js","sourceRoot":"","sources":["../../../../src/lib/generators/sw-sections/server-push-handler.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,MAAM,UAAU,yBAAyB,CACvC,IAAyB,EACzB,QAAgB,EAChB,gBAAwB;IAExB,IAAI,IAAI,KAAK,WAAW,EAAE,CAAC;QACzB,OAAO;;;;;;;;8BAQmB,QAAQ;;;;;;;;;;;;;;;;;;;;;;;uDAuBiB,gBAAgB;;;;;;CAMtE,CAAC;IACA,CAAC;IAED,qCAAqC;IACrC,OAAO;;;;;;;;;oCAS2B,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uDAiDW,gBAAgB;;;;;;CAMtE,CAAC;AACF,CAAC"}
+{"version":3,"file":"server-push-handler.js","sourceRoot":"","sources":["../../../../src/lib/generators/sw-sections/server-push-handler.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,MAAM,UAAU,yBAAyB,CACvC,IAAyB,EACzB,QAAgB,EAChB,gBAAwB;IAExB,IAAI,IAAI,KAAK,WAAW,EAAE,CAAC;QACzB,OAAO;;;;;;;;8BAQmB,QAAQ;;;;;;;;;;;;;;;;;;;;;;;uDAuBiB,gBAAgB;;;;;;CAMtE,CAAC;IACA,CAAC;IAED,qCAAqC;IACrC,OAAO;;;;;;;;;;;;;;;;;oCAiB2B,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uDAqDW,gBAAgB;;;;;;CAMtE,CAAC;AACF,CAAC"}

package/dist/lib/generators/sw-sections/tag-management.js

@@ -12,6 +12,8 @@ const STALE_VERSIONS_MAX = 100;
 const STALE_VERSION_TTL = 30 * 60 * 1000;
 const TAG_DB_NAME = "swoff-cache-tags";
 const TAG_STORE_NAME = "tags";
+// Bump this when adding new indexes/stores for schema migration
+const TAG_DB_VERSION = 1;
 
 function cleanStaleVersions() {
   const now = Date.now();
@@ -24,7 +26,7 @@ function cleanStaleVersions() {
 
 function openTagDB() {
   return new Promise((resolve, reject) => {
-    const request = indexedDB.open(TAG_DB_NAME, 1);
+    const request = indexedDB.open(TAG_DB_NAME, TAG_DB_VERSION);
     request.onupgradeneeded = (e) => {
       const db = e.target.result;
       if (!db.objectStoreNames.contains(TAG_STORE_NAME)) {
@@ -37,11 +39,11 @@ function openTagDB() {
   });
 }
 
-async function cacheTagUrl(url, actualUrl, tags) {
+async function cacheTagUrl(url, actualUrl, tags, method, body, contentType) {
   const db = await openTagDB();
   const tx = db.transaction(TAG_STORE_NAME, "readwrite");
   const store = tx.objectStore(TAG_STORE_NAME);
-  store.put({ url, actualUrl, tags });
+  store.put({ url, actualUrl, tags, method: method || "GET", body: body || null, contentType: contentType || null });
   await new Promise((resolve, reject) => {
     tx.oncomplete = () => resolve();
     tx.onerror = () => reject(tx.error);
@@ -81,7 +83,7 @@ async function invalidateByTag(tag) {
   // Enqueue background refetch through batched refresh queue
   for (const entry of entries) {
     staleVersions.set(entry.url, Date.now());
-    queueRefresh(entry.url, entry.actualUrl, entry.tags);
+    queueRefresh(entry.url, entry.actualUrl, entry.tags, entry.method, entry.body, entry.contentType);
   }
 
   const clients = await self.clients.matchAll();

package/dist/lib/generators/sw-sections/tag-management.js.map

@@ -1 +1 @@
-{"version":3,"file":"tag-management.js","sourceRoot":"","sources":["../../../../src/lib/generators/sw-sections/tag-management.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,MAAM,UAAU,qBAAqB;IACnC,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAkIP,CAAC;AACH,CAAC"}
+{"version":3,"file":"tag-management.js","sourceRoot":"","sources":["../../../../src/lib/generators/sw-sections/tag-management.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,MAAM,UAAU,qBAAqB;IACnC,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAoIP,CAAC;AACH,CAAC"}