@swoff/cli 0.3.13 → 0.3.14

package/dist/runtime/push.js

@@ -1,13 +1,15 @@
-import { T, R, PT, AS } from "./utils.js";
+import { T, R, AS } from "./utils.js";
 export function generatePushCode(ctx) {
     const { ext, ts } = ctx;
-    const vapidKey = ctx.vapidKey;
     return `/**
  * Swoff Push Notifications
  * Push subscription management with IndexedDB persistence.
  *
  * Usage:
- *   import { subscribeToPush, unsubscribeFromPush, isSubscribed } from './swoff/realtime/notifications.${ext}';
+ *   import { subscribeToPush, unsubscribeFromPush, isSubscribed } from './swoff/push-notification/index.${ext}';
+ *
+ *   // Replace with your VAPID public key:
+ *   const VAPID_PUBLIC_KEY = "YOUR_VAPID_PUBLIC_KEY_HERE";
  *
  *   // Enable (triggers permission prompt)
  *   const subscription = await subscribeToPush();
@@ -24,28 +26,14 @@ export function generatePushCode(ctx) {
  *   push-subscription-changed - Subscribed/unsubscribed (detail: { subscribed })
  */
 
+import { openDB } from "../db.${ext}";
+
 const SUBSCRIPTION_DB = "swoff-push";
 const SUBSCRIPTION_STORE = "subscription";
-// Bump this when adding new indexes/stores for schema migration
-const DB_VERSION = 1;
-const VAPID_PUBLIC_KEY = ${JSON.stringify(vapidKey)};
+const VAPID_PUBLIC_KEY = "";
 
 let permissionState${T(ts, "NotificationPermission | undefined")} = typeof Notification !== "undefined" ? Notification.permission : undefined;
 
-function openPushDB()${R(ts, "Promise<IDBDatabase>")}{
-  return new Promise${PT(ts, "IDBDatabase")}((resolve, reject) => {
-    const request = indexedDB.open(SUBSCRIPTION_DB, DB_VERSION);
-    request.onupgradeneeded = (e) => {
-      const db = (e.target${AS(ts, "IDBOpenDBRequest")}).result;
-      if (!db.objectStoreNames.contains(SUBSCRIPTION_STORE)) {
-        db.createObjectStore(SUBSCRIPTION_STORE, { keyPath: "id" });
-      }
-    };
-    request.onsuccess = (e) => resolve((e.target${AS(ts, "IDBOpenDBRequest")}).result);
-    request.onerror = (e) => reject((e.target${AS(ts, "IDBRequest")}).error);
-  });
-}
-
 /** Request notification permission from the user. Returns true if granted. */
 export async function requestNotificationPermission()${R(ts, "Promise<boolean>")}{
   if (permissionState === "granted") return true;
@@ -69,7 +57,7 @@ export async function getPushSubscription()${R(ts, "Promise<PushSubscription | n
   }
 }
 
-/** Subscribe to push notifications. Returns the subscription or null if permission denied. Uses the VAPID public key from your swoff.config.json. */
+/** Subscribe to push notifications. Returns the subscription or null if permission denied. Update VAPID_PUBLIC_KEY at the top with your key. */
 export async function subscribeToPush()${R(ts, "Promise<PushSubscription | null>")}{
   const granted = await requestNotificationPermission();
   if (!granted) return null;
@@ -80,7 +68,7 @@ export async function subscribeToPush()${R(ts, "Promise<PushSubscription | null>
     applicationServerKey: urlBase64ToUint8Array(VAPID_PUBLIC_KEY)${AS(ts, "BufferSource")},
   });
 
-  const db = await openPushDB();
+  const db = await openDB(SUBSCRIPTION_DB, SUBSCRIPTION_STORE, "id");
   const tx = db.transaction(SUBSCRIPTION_STORE, "readwrite");
   tx.objectStore(SUBSCRIPTION_STORE).put({
     id: "current",
@@ -89,8 +77,8 @@ export async function subscribeToPush()${R(ts, "Promise<PushSubscription | null>
     subscribedAt: Date.now(),
   });
   await new Promise<void>((resolve, reject) => {
-    tx.oncomplete = () => resolve();
-    tx.onerror = () => reject(tx.error);
+    tx.oncomplete = () => { db.close(); resolve(); };
+    tx.onerror = () => { db.close(); reject(tx.error); };
   });
 
   window.dispatchEvent(
@@ -107,12 +95,12 @@ export async function unsubscribeFromPush()${R(ts, "Promise<void>")}{
 
   await subscription.unsubscribe();
 
-  const db = await openPushDB();
+  const db = await openDB(SUBSCRIPTION_DB, SUBSCRIPTION_STORE, "id");
   const tx = db.transaction(SUBSCRIPTION_STORE, "readwrite");
   tx.objectStore(SUBSCRIPTION_STORE).delete("current");
   await new Promise<void>((resolve, reject) => {
-    tx.oncomplete = () => resolve();
-    tx.onerror = () => reject(tx.error);
+    tx.oncomplete = () => { db.close(); resolve(); };
+    tx.onerror = () => { db.close(); reject(tx.error); };
   });
 
   window.dispatchEvent(

package/dist/runtime/push.js.map

@@ -1 +1 @@
-{"version":3,"file":"push.js","sourceRoot":"","sources":["../../src/runtime/push.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,MAAM,YAAY,CAAC;AAE1C,MAAM,UAAU,gBAAgB,CAAC,GAA0C;IACzE,MAAM,EAAE,GAAG,EAAE,EAAE,EAAE,GAAG,GAAG,CAAC;IACxB,MAAM,QAAQ,GAAG,GAAG,CAAC,QAAQ,CAAC;IAC9B,OAAO;;;;;0GAKiG,GAAG;;;;;;;;;;;;;;;;;;;;;2BAqBlF,IAAI,CAAC,SAAS,CAAC,QAAQ,CAAC;;qBAE9B,CAAC,CAAC,EAAE,EAAE,oCAAoC,CAAC;;uBAEzC,CAAC,CAAC,EAAE,EAAE,sBAAsB,CAAC;sBAC9B,EAAE,CAAC,EAAE,EAAE,aAAa,CAAC;;;4BAGf,EAAE,CAAC,EAAE,EAAE,kBAAkB,CAAC;;;;;kDAKJ,EAAE,CAAC,EAAE,EAAE,kBAAkB,CAAC;+CAC7B,EAAE,CAAC,EAAE,EAAE,YAAY,CAAC;;;;;uDAKZ,CAAC,CAAC,EAAE,EAAE,kBAAkB,CAAC;;;;;;;;;;;;;6CAanC,CAAC,CAAC,EAAE,EAAE,kCAAkC,CAAC;;;;;;;;;;yCAU7C,CAAC,CAAC,EAAE,EAAE,kCAAkC,CAAC;;;;;;;mEAOf,EAAE,CAAC,EAAE,EAAE,cAAc,CAAC;;;;;;;;;;;;;;;;;;;;;;;;6CAwB5C,CAAC,CAAC,EAAE,EAAE,eAAe,CAAC;;;;;;;;;;;;;;;;;;;;sCAoB7B,CAAC,CAAC,EAAE,EAAE,kBAAkB,CAAC;;;;;;6CAMlB,CAAC,CAAC,EAAE,EAAE,QAAQ,CAAC,IAAI,CAAC,CAAC,EAAE,EAAE,YAAY,CAAC;;;;;;CAMlF,CAAC;AACF,CAAC"}
+{"version":3,"file":"push.js","sourceRoot":"","sources":["../../src/runtime/push.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,CAAC,EAAM,EAAE,EAAE,MAAM,YAAY,CAAC;AAE1C,MAAM,UAAU,gBAAgB,CAAC,GAAmB;IAClD,MAAM,EAAE,GAAG,EAAE,EAAE,EAAE,GAAG,GAAG,CAAC;IACxB,OAAO;;;;;2GAKkG,GAAG;;;;;;;;;;;;;;;;;;;;gCAoB9E,GAAG;;;;;;qBAMd,CAAC,CAAC,EAAE,EAAE,oCAAoC,CAAC;;;uDAGT,CAAC,CAAC,EAAE,EAAE,kBAAkB,CAAC;;;;;;;;;;;;;6CAanC,CAAC,CAAC,EAAE,EAAE,kCAAkC,CAAC;;;;;;;;;;yCAU7C,CAAC,CAAC,EAAE,EAAE,kCAAkC,CAAC;;;;;;;mEAOf,EAAE,CAAC,EAAE,EAAE,cAAc,CAAC;;;;;;;;;;;;;;;;;;;;;;;;6CAwB5C,CAAC,CAAC,EAAE,EAAE,eAAe,CAAC;;;;;;;;;;;;;;;;;;;;sCAoB7B,CAAC,CAAC,EAAE,EAAE,kBAAkB,CAAC;;;;;;6CAMlB,CAAC,CAAC,EAAE,EAAE,QAAQ,CAAC,IAAI,CAAC,CAAC,EAAE,EAAE,YAAY,CAAC;;;;;;CAMlF,CAAC;AACF,CAAC"}

package/dist/runtime/pwa-injector.js

@@ -1,44 +1,15 @@
-import { R } from "./utils.js";
 export function generatePwaInjectorCode(ctx) {
-    const { ext, ts } = ctx;
-    const preventLine = ctx.preventDefaultInstall ? "    e.preventDefault();\n" : "";
+    const { ext } = ctx;
     return `/**
  * Swoff PWA Injector
- * Service worker installation event wiring for PWA installability.
+ * Re-exports setupPwaInstall from the prompt module.
  *
  * Usage:
  *   import { setupPwaInstall } from './swoff/pwa/injector.${ext}';
  *   setupPwaInstall();
- *
- * Window properties:
- *   window.deferredInstallPrompt - The captured BeforeInstallPromptEvent
  */
 
-/** Set up beforeinstallprompt and appinstalled event listeners. Call once at app startup. */
-export function setupPwaInstall()${R(ts, "void")}{
-  window.addEventListener("beforeinstallprompt", (e) => {
-    window.deferredInstallPrompt = e as BeforeInstallPromptEvent;
-    window.pwaInstallable = true;
-
-${preventLine}
-    window.dispatchEvent(
-      new CustomEvent("pwa-installable", {
-        detail: { isInstallable: true },
-      })
-    );
-  });
-
-  window.addEventListener("appinstalled", () => {
-    window.deferredInstallPrompt = null;
-    window.pwaInstallable = false;
-
-    window.dispatchEvent(
-      new CustomEvent("pwa-installed", {
-        detail: { outcome: "accepted" },
-      })
-    );
-  });
-}
+export { setupPwaInstall } from "./prompt.${ext}";
 `;
 }
 //# sourceMappingURL=pwa-injector.js.map

package/dist/runtime/pwa-injector.js.map

@@ -1 +1 @@
-{"version":3,"file":"pwa-injector.js","sourceRoot":"","sources":["../../src/runtime/pwa-injector.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,YAAY,CAAC;AAE/B,MAAM,UAAU,uBAAuB,CAAC,GAAwD;IAC9F,MAAM,EAAE,GAAG,EAAE,EAAE,EAAE,GAAG,GAAG,CAAC;IACxB,MAAM,WAAW,GAAG,GAAG,CAAC,qBAAqB,CAAC,CAAC,CAAC,2BAA2B,CAAC,CAAC,CAAC,EAAE,CAAC;IAEjF,OAAO;;;;;6DAKoD,GAAG;;;;;;;;mCAQ7B,CAAC,CAAC,EAAE,EAAE,MAAM,CAAC;;;;;EAK9C,WAAW;;;;;;;;;;;;;;;;;;;CAmBZ,CAAC;AACF,CAAC"}
+{"version":3,"file":"pwa-injector.js","sourceRoot":"","sources":["../../src/runtime/pwa-injector.ts"],"names":[],"mappings":"AAEA,MAAM,UAAU,uBAAuB,CAAC,GAAmB;IACzD,MAAM,EAAE,GAAG,EAAE,GAAG,GAAG,CAAC;IAEpB,OAAO;;;;;6DAKoD,GAAG;;;;4CAIpB,GAAG;CAC9C,CAAC;AACF,CAAC"}

package/dist/runtime/pwa-prompt.js

@@ -1,12 +1,17 @@
-import { R } from "./utils.js";
+import { R, AS } from "./utils.js";
 export function generatePwaPromptCode(ctx) {
     const { ext, ts } = ctx;
+    const preventLine = ctx.preventDefaultInstall
+        ? "    e.preventDefault();\n"
+        : "";
     return `/**
  * Swoff PWA Install Prompt
- * Installability check and manual prompt trigger.
+ * Installability check, manual prompt trigger, and event listener setup.
  *
  * Usage:
- *   import { isInstallable, promptInstall } from './swoff/pwa/prompt.${ext}';
+ *   import { setupPwaInstall, isInstallable, promptInstall } from './swoff/pwa/prompt.${ext}';
+ *
+ *   setupPwaInstall();  // sets up beforeinstallprompt and appinstalled listeners
  *
  *   if (isInstallable()) {
  *     const result = await promptInstall();
@@ -16,8 +21,35 @@ export function generatePwaPromptCode(ctx) {
  *   window.deferredInstallPrompt - The captured BeforeInstallPromptEvent
  */
 
+/** Set up beforeinstallprompt and appinstalled event listeners. Call once at app startup. */
+export function setupPwaInstall()${R(ts, "void")}{
+  window.addEventListener("beforeinstallprompt", (e) => {
+    window.deferredInstallPrompt = e${AS(ts, "BeforeInstallPromptEvent")};
+    window.pwaInstallable = true;
+
+${preventLine}
+    window.dispatchEvent(
+      new CustomEvent("pwa-installable", {
+        detail: { isInstallable: true },
+      })
+    );
+  });
+
+  window.addEventListener("appinstalled", () => {
+    window.deferredInstallPrompt = null;
+    window.pwaInstallable = false;
+
+    window.dispatchEvent(
+      new CustomEvent("pwa-installed", {
+        detail: { outcome: "accepted" },
+      })
+    );
+  });
+}
+
 /** Check if the PWA install prompt is available (user has met install criteria). */
 export function isInstallable()${R(ts, "boolean")}{
+  if (typeof window === "undefined") return false;
   return !!window.deferredInstallPrompt;
 }
 

package/dist/runtime/pwa-prompt.js.map

@@ -1 +1 @@
-{"version":3,"file":"pwa-prompt.js","sourceRoot":"","sources":["../../src/runtime/pwa-prompt.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,YAAY,CAAC;AAE/B,MAAM,UAAU,qBAAqB,CAAC,GAAmB;IACvD,MAAM,EAAE,GAAG,EAAE,EAAE,EAAE,GAAG,GAAG,CAAC;IAExB,OAAO;;;;;wEAK+D,GAAG;;;;;;;;;;;iCAW1C,CAAC,CAAC,EAAE,EAAE,SAAS,CAAC;;;;;uCAKV,CAAC,CAAC,EAAE,EAAE,8BAA8B,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;CA2B3E,CAAC;AACF,CAAC"}
+{"version":3,"file":"pwa-prompt.js","sourceRoot":"","sources":["../../src/runtime/pwa-prompt.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,EAAE,EAAE,MAAM,YAAY,CAAC;AAEnC,MAAM,UAAU,qBAAqB,CACnC,GAAyD;IAEzD,MAAM,EAAE,GAAG,EAAE,EAAE,EAAE,GAAG,GAAG,CAAC;IACxB,MAAM,WAAW,GAAG,GAAG,CAAC,qBAAqB;QAC3C,CAAC,CAAC,2BAA2B;QAC7B,CAAC,CAAC,EAAE,CAAC;IAEP,OAAO;;;;;yFAKgF,GAAG;;;;;;;;;;;;;mCAazD,CAAC,CAAC,EAAE,EAAE,MAAM,CAAC;;sCAEV,EAAE,CAAC,EAAE,EAAE,0BAA0B,CAAC;;;EAGtE,WAAW;;;;;;;;;;;;;;;;;;;;;iCAqBoB,CAAC,CAAC,EAAE,EAAE,SAAS,CAAC;;;;;;uCAMV,CAAC,CAAC,EAAE,EAAE,8BAA8B,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;CA2B3E,CAAC;AACF,CAAC"}

package/dist/runtime/reset.js

@@ -1,49 +1,51 @@
-import { T, R } from "./utils.js";
+import { T, O, R } from "./utils.js";
 export function generateResetCode(ctx) {
     const { ext, ts } = ctx;
     return `/**
  * Swoff Reset
  * Nuclear option: wipe all swoff data (caches, IndexedDB, localStorage),
- * unregister the service worker, then re-register from scratch.
+ * then instruct the service worker to clear and re-precache all assets.
+ *
+ * Unlike the old approach of unregister + re-register (which often failed to
+ * trigger the install event for byte-identical scripts), this sends a
+ * RESET_CACHE message to the active SW, which handles cache clearing and
+ * re-precaching internally.
  *
  * Usage:
  *   import { resetSwoff } from './swoff/reset.${ext}';
  *
  *   // Full reset (default)
  *   const result = await resetSwoff();
- *   console.log(result.unregistered, result.reregistered, result.warnings);
+ *   console.log(result.warnings);
  *
  *   // Selective reset — keep caches but reset IDB + SW
  *   await resetSwoff({ clearCache: false });
  *
  * Events dispatched:
  *   swoff:reset-start    — before any cleanup begins
- *   swoff:reset-complete — after everything finishes (detail: { unregistered, reregistered, warnings })
+ *   swoff:reset-complete — after everything finishes (detail: { warnings })
  */
 
-import { initServiceWorker } from "./sw/injector.${ext}";
-
 export interface ResetSwoffOptions {
   /** Clear all Cache Storage caches (default: true) */
-  clearCache${T(ts, "boolean")};
+  clearCache${O(ts, "boolean")};
   /** Delete all swoff-* IndexedDB databases (default: true) */
-  clearIdb${T(ts, "boolean")};
+  clearIdb${O(ts, "boolean")};
   /** Clear localStorage keys like swRegisteredVersion (default: true) */
-  clearStorage${T(ts, "boolean")};
-  /** Unregister SW then re-register (default: true) */
-  unregisterSW${T(ts, "boolean")};
+  clearStorage${O(ts, "boolean")};
+  /** Reset SW caches (clear + re-precache) (default: true) */
+  resetSwCache${O(ts, "boolean")};
 }
 
 const DEFAULT_OPTIONS: ResetSwoffOptions = {
   clearCache: true,
   clearIdb: true,
   clearStorage: true,
-  unregisterSW: true,
+  resetSwCache: true,
 };
 
 const KNOWN_DB_NAMES = [
   "swoff-auth",
-  "swoff-auth-user",
   "swoff-queue",
   "swoff-cache-tags",
   "swoff-push",
@@ -74,14 +76,14 @@ async function deleteSwoffDatabases(warnings${T(ts, "string[]")})${R(ts, "Promis
   }
 }
 
-/** Nuclear reset: wipes all swoff-persisted data, unregisters the SW, then re-registers from scratch. Returns detailed results. */
-export async function resetSwoff(opts${T(ts, "Partial<ResetSwoffOptions>")} = {})${R(ts, "Promise<{ unregistered: boolean; reregistered: boolean; warnings: string[] }>")}{
+/** Nuclear reset: wipes all swoff-persisted data and resets the SW cache. Returns detailed results. */
+export async function resetSwoff(opts${T(ts, "ResetSwoffOptions")} = {})${R(ts, "Promise<{ warnings: string[] }>")}{
   const options${T(ts, "ResetSwoffOptions")} = { ...DEFAULT_OPTIONS, ...opts };
   const warnings${T(ts, "string[]")} = [];
 
   window.dispatchEvent(new CustomEvent("swoff:reset-start"));
 
-  // 1. Clear Cache Storage
+  // 1. Clear Cache Storage (belt-and-suspenders — SW also clears them)
   if (options.clearCache) {
     try {
       if (typeof caches !== "undefined") {
@@ -107,39 +109,34 @@ export async function resetSwoff(opts${T(ts, "Partial<ResetSwoffOptions>")} = {}
     }
   }
 
-  // 4. Unregister SW
-  let unregistered = false;
-  if (options.unregisterSW) {
+  // 4. Tell the SW to clear its caches and re-precache all assets
+  if (options.resetSwCache) {
     try {
-      if ("serviceWorker" in navigator) {
-        const reg = await navigator.serviceWorker.getRegistration();
-        if (reg) {
-          unregistered = await reg.unregister();
+      if ("serviceWorker" in navigator && navigator.serviceWorker.controller) {
+        const registration = await navigator.serviceWorker.ready;
+        if (registration.active) {
+          await new Promise<void>((resolve) => {
+            const channel = new MessageChannel();
+            const timer = setTimeout(() => {
+              channel.port1.close();
+              resolve();
+            }, 10000);
+            channel.port1.onmessage = (event) => {
+              if (event.data.type === "RESET_CACHE_COMPLETE") {
+                clearTimeout(timer);
+                resolve();
+              }
+            };
+            registration.active?.postMessage({ type: "RESET_CACHE" }, [channel.port2]);
+          });
         }
       }
     } catch (e) {
-      warnings.push(\`Failed to unregister SW: \${e}\`);
-    }
-
-    // Always clear the version marker before re-registering so initServiceWorker
-    // detects a fresh install rather than trying to reuse a stale registration
-    try {
-      localStorage.removeItem("swRegisteredVersion");
-    } catch { /* ignore */ }
-  }
-
-  // 5. Re-register SW
-  let reregistered = false;
-  if (options.unregisterSW) {
-    try {
-      await initServiceWorker();
-      reregistered = true;
-    } catch (e) {
-      warnings.push(\`Failed to re-register SW: \${e}\`);
+      warnings.push(\`Failed to reset SW cache: \${e}\`);
     }
   }
 
-  const result = { unregistered, reregistered, warnings };
+  const result = { warnings };
   window.dispatchEvent(new CustomEvent("swoff:reset-complete", { detail: result }));
   return result;
 }

package/dist/runtime/reset.js.map

@@ -1 +1 @@
-{"version":3,"file":"reset.js","sourceRoot":"","sources":["../../src/runtime/reset.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,CAAC,EAAE,MAAM,YAAY,CAAC;AAElC,MAAM,UAAU,iBAAiB,CAAC,GAAmB;IACnD,MAAM,EAAE,GAAG,EAAE,EAAE,EAAE,GAAG,GAAG,CAAC;IACxB,OAAO;;;;;;iDAMwC,GAAG;;;;;;;;;;;;;;mDAcD,GAAG;;;;cAIxC,CAAC,CAAC,EAAE,EAAE,SAAS,CAAC;;YAElB,CAAC,CAAC,EAAE,EAAE,SAAS,CAAC;;gBAEZ,CAAC,CAAC,EAAE,EAAE,SAAS,CAAC;;gBAEhB,CAAC,CAAC,EAAE,EAAE,SAAS,CAAC;;;;;;;;;;;;;;;;;;;8CAmBc,CAAC,CAAC,EAAE,EAAE,UAAU,CAAC,IAAI,CAAC,CAAC,EAAE,EAAE,eAAe,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;uCAyBlD,CAAC,CAAC,EAAE,EAAE,4BAA4B,CAAE,SAAS,CAAC,CAAC,EAAE,EAAE,+EAA+E,CAAC;iBACzJ,CAAC,CAAC,EAAE,EAAE,mBAAmB,CAAC;kBACzB,CAAC,CAAC,EAAE,EAAE,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkElC,CAAC;AACF,CAAC"}
+{"version":3,"file":"reset.js","sourceRoot":"","sources":["../../src/runtime/reset.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,MAAM,YAAY,CAAC;AAErC,MAAM,UAAU,iBAAiB,CAAC,GAAmB;IACnD,MAAM,EAAE,GAAG,EAAE,EAAE,EAAE,GAAG,GAAG,CAAC;IACxB,OAAO;;;;;;;;;;;iDAWwC,GAAG;;;;;;;;;;;;;;;;cAgBtC,CAAC,CAAC,EAAE,EAAE,SAAS,CAAC;;YAElB,CAAC,CAAC,EAAE,EAAE,SAAS,CAAC;;gBAEZ,CAAC,CAAC,EAAE,EAAE,SAAS,CAAC;;gBAEhB,CAAC,CAAC,EAAE,EAAE,SAAS,CAAC;;;;;;;;;;;;;;;;;;8CAkBc,CAAC,CAAC,EAAE,EAAE,UAAU,CAAC,IAAI,CAAC,CAAC,EAAE,EAAE,eAAe,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;uCAyBlD,CAAC,CAAC,EAAE,EAAE,mBAAmB,CAAC,SAAS,CAAC,CAAC,EAAE,EAAE,iCAAiC,CAAC;iBACjG,CAAC,CAAC,EAAE,EAAE,mBAAmB,CAAC;kBACzB,CAAC,CAAC,EAAE,EAAE,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA6DlC,CAAC;AACF,CAAC"}

package/dist/runtime/server-push.js

@@ -1,9 +1,9 @@
-import { T, R } from "./utils.js";
+import { T, R, AS } from "./utils.js";
 export function generateServerPushCode(ctx, pushType, endpoint, reconnectDelayMs) {
     const { ext, ts } = ctx;
     const invalidate = `
   // Forward to SW for cache invalidation
-  if (navigator.serviceWorker.controller) {
+  if (navigator.serviceWorker?.controller) {
     for (const tag of tags) {
       navigator.serviceWorker.controller.postMessage({ type: "INVALIDATE_TAG", tag });
     }
@@ -15,6 +15,8 @@ export function generateServerPushCode(ctx, pushType, endpoint, reconnectDelayMs
       credentials: "include",
       signal: options.signal,
     }).then(async (response) => {
+      currentFetchController = null;
+      if (!active) { resolve(); return; }
       if (!response.ok || !response.body) { resolve(); return; }
       notifyStatus(true);
       const reader = response.body.getReader();
@@ -51,14 +53,15 @@ export function generateServerPushCode(ctx, pushType, endpoint, reconnectDelayMs
   return new Promise((resolve) => {
     try {
       const ws = new WebSocket(API_BASE + "${endpoint}");
+      currentWs = ws;
       ws.onopen = () => notifyStatus(true);
       ws.onmessage = (event) => {
         try { const d = JSON.parse(event.data); if (d.type === "invalidate" && d.tags) handleInvalidation(d.tags); } catch {}
       };
-      ws.onclose = () => { notifyStatus(false); resolve(); };
-      ws.onerror = () => { ws.close(); resolve(); };
+      ws.onclose = () => { currentWs = null; notifyStatus(false); resolve(); };
+      ws.onerror = () => { currentWs = null; ws.close(); resolve(); };
       if (options.signal) {
-        options.signal.addEventListener("abort", () => ws.close());
+        options.signal.addEventListener("abort", () => { ws.close(); currentWs = null; });
       }
     } catch { resolve(); }
   });`;
@@ -70,7 +73,7 @@ export function generateServerPushCode(ctx, pushType, endpoint, reconnectDelayMs
  * This client-side helper provides status tracking and a manual start/stop API.
  *
  * Usage:
- *   import { startPushEvents, stopPushEvents, isPushConnected } from "./realtime/server-push.${ext}";
+ *   import { startPushEvents, stopPushEvents, isPushConnected } from "./server-push/client.${ext}";
  *   startPushEvents();
  *
  * Server sends:
@@ -87,6 +90,8 @@ type PushEventOptions= {
 let active${T(ts, "boolean")} = false;
 let swConnected${T(ts, "boolean")} = false;
 let reconnectTimer${T(ts, "ReturnType<typeof setTimeout> | null")} = null;
+let currentWs${T(ts, "WebSocket | null")} = null;
+let currentFetchController${T(ts, "AbortController | null")} = null;
 
 function handleInvalidation(tags${T(ts, "string[]")})${R(ts, "void")}{${invalidate}
   window.dispatchEvent(new CustomEvent("cache-invalidated", { detail: { tags } }));
@@ -97,7 +102,7 @@ function notifyStatus(connected${T(ts, "boolean")})${R(ts, "void")}{
 }
 
 // Listen for SSE status from the SW
-if (typeof navigator !== "undefined" && navigator.serviceWorker) {
+if (typeof navigator !== "undefined" && "serviceWorker" in navigator) {
   navigator.serviceWorker.addEventListener("message", (event) => {
     if (event.data?.type === "SSE_STATUS") {
       swConnected = event.data.connected;
@@ -106,7 +111,10 @@ if (typeof navigator !== "undefined" && navigator.serviceWorker) {
   });
 }
 
-async function connect(options${T(ts, "PushEventOptions")} = {} as PushEventOptions)${R(ts, "Promise<void>")}{
+async function connect()${R(ts, "Promise<void>")}{
+  const controller = new AbortController();
+  currentFetchController = controller;
+  const options = { signal: controller.signal }${AS(ts, "PushEventOptions")};
   ${pushType === "sse" ? sseConnect : wsConnect}
 }
 
@@ -115,14 +123,14 @@ export async function startPushEvents(){
   if (active) return;
 
   // If SW is already controlling the page, skip client-side connection — the SW handles push events.
-  if (navigator.serviceWorker.controller) return;
+  if (navigator.serviceWorker?.controller) return;
 
   // Listen for SW activation — if SW takes over, disconnect the client fallback.
   const onControllerChange = () => { stopPushEvents(); };
-  navigator.serviceWorker.addEventListener("controllerchange", onControllerChange);
+  navigator.serviceWorker?.addEventListener("controllerchange", onControllerChange);
 
   active = true;
-  let delay = ${reconnectDelayMs};
+  let delay = Math.max(1000, ${reconnectDelayMs});
   while (active) {
     await connect();
     if (!active) break;
@@ -130,13 +138,15 @@ export async function startPushEvents(){
     delay = Math.min(delay * 1.5, 30000); // cap at 30s
   }
 
-  navigator.serviceWorker.removeEventListener("controllerchange", onControllerChange);
+  navigator.serviceWorker?.removeEventListener("controllerchange", onControllerChange);
 }
 
-/** Stop listening for push events. */
+/** Stop listening for push events and close the active connection. */
 export function stopPushEvents(){
   active = false;
   if (reconnectTimer) { clearTimeout(reconnectTimer); reconnectTimer = null; }
+  if (currentWs) { currentWs.close(); currentWs = null; }
+  if (currentFetchController) { currentFetchController.abort(); currentFetchController = null; }
 }
 
 /** Check if the push connection is currently established. */

package/dist/runtime/server-push.js.map

@@ -1 +1 @@
-{"version":3,"file":"server-push.js","sourceRoot":"","sources":["../../src/runtime/server-push.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,CAAC,EAAE,MAAM,YAAY,CAAC;AAElC,MAAM,UAAU,sBAAsB,CACpC,GAAmB,EACnB,QAAgB,EAChB,QAAgB,EAChB,gBAAwB;IAExB,MAAM,EAAE,GAAG,EAAE,EAAE,EAAE,GAAG,GAAG,CAAC;IAExB,MAAM,UAAU,GAAG;;;;;;IAMjB,CAAC;IAEH,MAAM,UAAU,GAAG;;wBAEG,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAoC1B,CAAC;IAEL,MAAM,SAAS,GAAG;;;6CAGyB,QAAQ;;;;;;;;;;;MAW/C,CAAC;IAEL,OAAO;;;oCAG2B,QAAQ;;;;;gGAKoD,GAAG;;;;;;;;sCAQ7D,GAAG;;;UAG/B,CAAC,CAAC,EAAE,EAAE,aAAa,CAAC;;;YAGlB,CAAC,CAAC,EAAE,EAAE,SAAS,CAAC;iBACX,CAAC,CAAC,EAAE,EAAE,SAAS,CAAC;oBACb,CAAC,CAAC,EAAE,EAAE,sCAAsC,CAAC;;kCAE/B,CAAC,CAAC,EAAE,EAAE,UAAU,CAAC,IAAI,CAAC,CAAC,EAAE,EAAE,MAAM,CAAC,IAAI,UAAU;;;;iCAIjD,CAAC,CAAC,EAAE,EAAE,SAAS,CAAC,IAAI,CAAC,CAAC,EAAE,EAAE,MAAM,CAAC;;;;;;;;;;;;;;gCAclC,CAAC,CAAC,EAAE,EAAE,kBAAkB,CAAC,6BAA6B,CAAC,CAAC,EAAE,EAAE,eAAe,CAAC;IACxG,QAAQ,KAAK,KAAK,CAAC,CAAC,CAAC,UAAU,CAAC,CAAC,CAAC,SAAS;;;;;;;;;;;;;;;gBAe/B,gBAAgB;;;;;;;;;;;;;;;;;;;;;CAqB/B,CAAC;AACF,CAAC"}
+{"version":3,"file":"server-push.js","sourceRoot":"","sources":["../../src/runtime/server-push.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,MAAM,YAAY,CAAC;AAEtC,MAAM,UAAU,sBAAsB,CACpC,GAAmB,EACnB,QAAgB,EAChB,QAAgB,EAChB,gBAAwB;IAExB,MAAM,EAAE,GAAG,EAAE,EAAE,EAAE,GAAG,GAAG,CAAC;IAExB,MAAM,UAAU,GAAG;;;;;;IAMjB,CAAC;IAEH,MAAM,UAAU,GAAG;;wBAEG,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAsC1B,CAAC;IAEL,MAAM,SAAS,GAAG;;;6CAGyB,QAAQ;;;;;;;;;;;;MAY/C,CAAC;IAEL,OAAO;;;oCAG2B,QAAQ;;;;;8FAKkD,GAAG;;;;;;;;sCAQ3D,GAAG;;;UAG/B,CAAC,CAAC,EAAE,EAAE,aAAa,CAAC;;;YAGlB,CAAC,CAAC,EAAE,EAAE,SAAS,CAAC;iBACX,CAAC,CAAC,EAAE,EAAE,SAAS,CAAC;oBACb,CAAC,CAAC,EAAE,EAAE,sCAAsC,CAAC;eAClD,CAAC,CAAC,EAAE,EAAE,kBAAkB,CAAC;4BACZ,CAAC,CAAC,EAAE,EAAE,wBAAwB,CAAC;;kCAEzB,CAAC,CAAC,EAAE,EAAE,UAAU,CAAC,IAAI,CAAC,CAAC,EAAE,EAAE,MAAM,CAAC,IAAI,UAAU;;;;iCAIjD,CAAC,CAAC,EAAE,EAAE,SAAS,CAAC,IAAI,CAAC,CAAC,EAAE,EAAE,MAAM,CAAC;;;;;;;;;;;;;;0BAcxC,CAAC,CAAC,EAAE,EAAE,eAAe,CAAC;;;iDAGC,EAAE,CAAC,EAAE,EAAE,kBAAkB,CAAC;IACvE,QAAQ,KAAK,KAAK,CAAC,CAAC,CAAC,UAAU,CAAC,CAAC,CAAC,SAAS;;;;;;;;;;;;;;;+BAehB,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;CAuB9C,CAAC;AACF,CAAC"}

package/dist/runtime/storage.js

@@ -0,0 +1,32 @@
+import { T, R } from "./utils.js";
+export function generateStorageCode(ctx) {
+    const { ext, ts } = ctx;
+    return `/**
+ * Swoff Storage
+ * Pure utility functions for storage estimation and formatting.
+ *
+ * Usage:
+ *   import { getStorageEstimate, formatBytes } from "./swoff/storage.${ext}";
+ *   const { usage, quota, percentUsed } = await getStorageEstimate();
+ */
+
+/** Get raw storage estimate. */
+export async function getStorageEstimate()${R(ts, "Promise<{ usage: number; quota: number; percentUsed: number }>")}{
+  if (!navigator.storage?.estimate) {
+    return { usage: 0, quota: 0, percentUsed: 0 };
+  }
+  const { usage = 0, quota = 0 } = await navigator.storage.estimate();
+  const percentUsed = quota > 0 ? Math.round((usage / quota) * 100) : 0;
+  return { usage, quota, percentUsed };
+}
+
+/** Format bytes to a human-readable string (e.g. "1.5 MB"). */
+export function formatBytes(bytes${T(ts, "number")})${R(ts, "string")}{
+  if (bytes === 0) return "0 B";
+  const units = ["B", "KB", "MB", "GB"];
+  const i = Math.floor(Math.log(bytes) / Math.log(1024));
+  return \`\${(bytes / Math.pow(1024, i)).toFixed(1)} \${units[i]}\`;
+}
+`;
+}
+//# sourceMappingURL=storage.js.map

package/dist/runtime/storage.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"storage.js","sourceRoot":"","sources":["../../src/runtime/storage.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,CAAC,EAAE,MAAM,YAAY,CAAC;AAElC,MAAM,UAAU,mBAAmB,CAAC,GAAmB;IACrD,MAAM,EAAE,GAAG,EAAE,EAAE,EAAE,GAAG,GAAG,CAAC;IACxB,OAAO;;;;;wEAK+D,GAAG;;;;;4CAK/B,CAAC,CAAC,EAAE,EAAE,gEAAgE,CAAC;;;;;;;;;;mCAUhF,CAAC,CAAC,EAAE,EAAE,QAAQ,CAAC,IAAI,CAAC,CAAC,EAAE,EAAE,QAAQ,CAAC;;;;;;CAMpE,CAAC;AACF,CAAC"}