@lls/offline 24.22.0-5bf1d034 → 24.22.0-658f61a6

package/lib/assets/fetch-worker.js

@@ -19,7 +19,7 @@ var makeSyncWorker = (offlineWorker2, methodNames, dbg) => {
   const makeFn = (methodName) => {
     return ({ ports, ...arg } = {}) => {
       return new Promise((resolve, reject) => {
-        const eventId = `${methodName}:${Date.now()}`;
+        const eventId = `${methodName}:${Date.now()}-${Math.random().toFixed(5)}`;
         dic[eventId] = { resolve, reject };
         offlineWorker2.postMessage({ eventId, methodName, arg }, ports);
       });
@@ -62,6 +62,7 @@ var makeSyncHandler = a(
   })
 );
 var jsonToBuf = (json) => new TextEncoder().encode(JSON.stringify(json));
+var openCache = async (mode) => caches.open(`LLS_OFFLINE_${mode}`);
 
 // src/worker/swFetchScreenCall.ts
 var zipSlugName = (str) => str.replace(/[^a-zA-Z0-9-.]/g, "");
@@ -74,6 +75,15 @@ var cocoreFetchPartialPageScreen = async (_ev, { offlineWorkerSync: offlineWorke
   const gqlPage = await offlineWorkerSync2.loadPageContent({ entryId });
   return { data: gqlPage };
 };
+var cocoreFetchBookScreen = async (_ev, { offlineWorkerSync: offlineWorkerSync2, variables, knownLinks: knownLinks2 }) => {
+  const key = `gqls/${zipSlugName(variables.uris[0] || "")}.json`;
+  const entryId = knownLinks2.get(key);
+  if (!entryId) {
+    throw new Error(`uri not found ${key}`);
+  }
+  const gqlBook = await offlineWorkerSync2.loadPageContent({ entryId });
+  return { data: gqlBook };
+};
 var cocoreFetchPartialPageSiblingsScreen = async (_ev) => {
   return { data: { viewer: {} } };
 };
@@ -188,6 +198,7 @@ var coreFetchPagesApi = async (ev, { offlineWorkerSync: offlineWorkerSync2, vari
 };
 var handles = {
   coreFetchBookDrawerScreen,
+  cocoreFetchBookScreen,
   coreFetchPagesApi,
   cocoreFetchPartialPageScreen,
   cocoreFetchPartialPageSiblingsScreen
@@ -196,7 +207,7 @@ var canHandleScreenCall = (url) => new RegExp(Object.keys(handles).join("|")).te
 var handleScreenCall = async (ev, { offlineWorkerSync: offlineWorkerSync2, knownLinks: knownLinks2 }) => {
   try {
     const variables = (
-      // @ts-ignore TODO: handle variables from body(stream) properly!!
+      // @ts-expect-error TODO: handle variables from body(stream) properly!!
       ev.request.body?.variables || JSON.parse(new URLSearchParams(new URL(ev.request.url).search).get("variables") || "{}")
     );
     console.debug("variables are", variables, "vs", ev.request.body);
@@ -211,23 +222,28 @@ var handleScreenCall = async (ev, { offlineWorkerSync: offlineWorkerSync2, known
     return { status: 500, json: JSON.stringify(e) };
   }
 };
+var setKnownLinks = (knownLinks2, { entryNames, bookId }) => {
+  entryNames.forEach((entryName) => {
+    const link = entryName.replace(new RegExp(`^\\d+/media/|^${bookId}/medias/`), "").replace(new RegExp(`^${bookId}/gqls/`), "gqls/");
+    knownLinks2.set(link, { entryName, bookId });
+  });
+};
 
 // src/worker/fetch-worker.ts
-var fetchAsset = async (ev, { entryId, mimeType, offlineWorkerSync: offlineWorkerSync2 }) => {
+var STORAGE = "cache";
+var CONF_ENV = "development";
+var fetchAsset = async (_ev, { entryId, mimeType, offlineWorkerSync: offlineWorkerSync2 }) => {
   try {
     const buf = await offlineWorkerSync2.readZipEntry(entryId);
-    const url = ev.request.url;
     return new Response(buf, {
       headers: {
         "Cache-Control": "max-age=600, s-maxage=600, public, proxy-revalidate",
+        "Content-Length": buf.byteLength,
         "Content-Type": mimeType
       },
       // @ts-ignore: poor ts typing
-      ok: true,
-      redirected: false,
       status: 200,
-      type: "cors",
-      url
+      statusText: "OK"
     });
   } catch (e) {
     console.error("FAILED fetchAsset", e);
@@ -235,8 +251,7 @@ var fetchAsset = async (ev, { entryId, mimeType, offlineWorkerSync: offlineWorke
       // @ts-ignore: poor ts typing
       ok: false,
       status: 500,
-      type: "cors",
-      url: ev.request.url
+      statusText: e?.toString?.() || "fail fetch"
     });
   }
 };
@@ -276,7 +291,42 @@ var ACCEPTED_EXTENSIONS = {
   ".gif": "image/gif",
   ".webm": "video/webm",
   ".m4a": "audio/mp4",
-  ".webp": "image/webp"
+  ".webp": "image/webp",
+  ".riv": "application/octet-stream",
+  ".pdf": "application/pdf"
+};
+var putInCache = async (request, response) => {
+  const cache = await openCache(CONF_ENV);
+  await cache.put(request, response);
+};
+var onlineFirst = async (request, event) => {
+  try {
+    const responseFromNetwork = await fetch(request);
+    const cached = putInCache(request, responseFromNetwork.clone());
+    if (request.url.endsWith(".zip")) {
+      await cached;
+      event.waitUntil(Promise.resolve());
+    } else {
+      event.waitUntil(cached);
+    }
+    return responseFromNetwork;
+  } catch (e) {
+    const over = /\/\?story=basic/.test(request.url) ? request.url.replace(/\/\?story=.*$/, "") : request;
+    const responseFromCache = await caches.match(over);
+    if (!responseFromCache) {
+      return new Response(
+        `FAILED fetch ${e && typeof e === "object" && "message" in e ? e.message : e?.toString?.()}`,
+        {
+          // @ts-ignore: poor ts typing
+          ok: false,
+          status: 500,
+          type: "cors",
+          url: event.request.url
+        }
+      );
+    }
+    return responseFromCache;
+  }
 };
 var swSelf = self;
 swSelf.addEventListener("fetch", (ev) => {
@@ -284,30 +334,33 @@ swSelf.addEventListener("fetch", (ev) => {
   const extension = url.match(/\.[^.]+$/)?.[0];
   const mimeType = extension && extension in ACCEPTED_EXTENSIONS ? ACCEPTED_EXTENSIONS[extension] : "";
   const isValidScreenCall = canHandleScreenCall(url);
+  if (STORAGE !== "cache" && url.endsWith(".zip")) {
+    return;
+  }
   if (!mimeType && !isValidScreenCall) {
     if (!/\.(css|tsx?|jsx?|woff2|fr|manifest)(\??|$)|@(vite|react|id)/.test(url)) {
       console.debug("no ext", extension || url);
     }
-    return;
+    return ev.respondWith(onlineFirst(ev.request, ev));
   }
   const entryId = knownLinks.get(url.replace(/https:\/\/.*?\//, "")) || knownLinks.get(`medias/${url.replace(/https:\/\/.*?\//, "")}`);
-  if (!entryId && !isValidScreenCall) {
-    if (/lls|lelivrescolaire/.test(url)) {
-      console.info("no link for", url.replace(/https:\/\/.*?\//, ""));
-    }
-    return;
-  }
   if (isValidScreenCall) {
     console.debug("screencall!");
     return ev.respondWith(fetchScreenCall(ev, { offlineWorkerSync, knownLinks }));
   }
-  return ev.respondWith(fetchAsset(ev, { entryId, mimeType, offlineWorkerSync }));
+  if (entryId) {
+    return ev.respondWith(fetchAsset(ev, { entryId, mimeType, offlineWorkerSync }));
+  }
+  if (/lls|lelivrescolaire/.test(url)) {
+    console.info("no link for", url.replace(/https:\/\/.*?\//, ""), `medias/${url.replace(/https:\/\/.*?\//, "")}`);
+  }
+  return;
 });
 swSelf.addEventListener("install", (_event) => {
   swSelf.skipWaiting();
 });
-swSelf.addEventListener("activate", (_event) => {
-  return swSelf.clients.claim();
+swSelf.addEventListener("activate", (event) => {
+  event.waitUntil(swSelf.clients.claim());
 });
 var offlineWorker;
 var offlineWorkerSync;
@@ -321,24 +374,37 @@ var initChannel = async (__, { ports }) => {
   );
   offlineWorkerSync = sender;
   offlineWorker.onmessage = handler.handle;
-  offlineWorkerSync.on("setKnownLinks", setKnownLinks);
+  offlineWorkerSync.on("setKnownLinks", setKnownLinks.bind(null, knownLinks));
   offlineWorker.postMessage({ methodName: "sendAppReady" });
 };
 var knownLinks = /* @__PURE__ */ new Map();
-var setKnownLinks = ({ entryNames, bookId }) => {
-  entryNames.forEach((entryName) => {
-    const link = entryName.replace(/^\d+\/media\//, "");
-    knownLinks.set(link, { entryName, bookId });
-  });
+var configure = ({
+  storage,
+  confEnv
+} = {}) => {
+  STORAGE = "cache";
+  CONF_ENV = "development";
+  if (typeof storage !== "undefined") {
+    STORAGE = storage;
+  }
+  if (typeof confEnv !== "undefined") {
+    CONF_ENV = confEnv;
+  }
+  console.info("sw::configure", { STORAGE, CONF_ENV });
 };
 swSelf.onmessage = async ({
   data: { methodName, arg } = {},
   ports
 }) => {
   const services = {
-    initChannel
+    initChannel,
+    configure
   };
   try {
+    if (methodName === "configure") {
+      await services[methodName](arg);
+      return;
+    }
     if (methodName === "initChannel") {
       if (!ports.length) {
         throw new Error("fetchworker::missing port!");

package/lib/assets/offline-worker.js

@@ -1,3 +1,14 @@
+// src/utils/error.ts
+var tryCatch = (fn) => {
+  return (resolve, reject) => {
+    try {
+      return fn().then(resolve);
+    } catch (e) {
+      return reject(e);
+    }
+  };
+};
+
 // src/utils/worker.ts
 var makeSyncWorker = (offlineWorker, methodNames, dbg) => {
   const dic = {};
@@ -19,7 +30,7 @@ var makeSyncWorker = (offlineWorker, methodNames, dbg) => {
   const makeFn = (methodName) => {
     return ({ ports, ...arg } = {}) => {
       return new Promise((resolve, reject) => {
-        const eventId = `${methodName}:${Date.now()}`;
+        const eventId = `${methodName}:${Date.now()}-${Math.random().toFixed(5)}`;
         dic[eventId] = { resolve, reject };
         offlineWorker.postMessage({ eventId, methodName, arg }, ports);
       });
@@ -72,6 +83,17 @@ var combineHandlers = (...handlers) => {
     console.error("no handlers matched", methodName);
   };
 };
+var openCache = async (mode) => caches.open(`LLS_OFFLINE_${mode}`);
+var concatArrayBuffers = (buffers) => {
+  const totalLength = buffers.reduce((sum, buf) => sum + buf.byteLength, 0);
+  const concatenated = new Uint8Array(totalLength);
+  let offset = 0;
+  for (const buffer of buffers) {
+    concatenated.set(new Uint8Array(buffer), offset);
+    offset += buffer.byteLength;
+  }
+  return concatenated.buffer;
+};
 
 // src/worker/wwApi.ts
 var STATE = {
@@ -753,6 +775,9 @@ async function decryptData(encryptedData, key2, iv2) {
   return decryptedData;
 }
 var BOOKS = {};
+var zipNameInMedias = (zipName) => {
+  return /^(pages|book)/.test(zipName);
+};
 var readZipEntry = async ({
   bookId,
   entryName,
@@ -762,9 +787,20 @@ var readZipEntry = async ({
     console.trace("no bookId", bookId, "found");
     return null;
   }
-  const bookEntry = BOOKS[bookId].get(entryName);
+  const manifest = BOOKS[bookId].manifest;
+  let overridenName = entryName;
+  if (manifest && !entryName.includes("gqls/")) {
+    const zipName = entryName.replace("medias/", "");
+    if (zipNameInMedias(zipName)) {
+      const originalName = manifest.medias[zipName];
+      overridenName = `medias/${originalName}`;
+    } else {
+      console.error("any media should exist in manifest", zipName, entryName, bookId);
+    }
+  }
+  const bookEntry = BOOKS[bookId].map.get(overridenName);
   if (!bookEntry) {
-    console.info("no bookEntry", entryName, "found");
+    console.info("no bookEntry", entryName, "found", overridenName);
     return null;
   }
   if (!bookEntry.decoded) {
@@ -775,16 +811,6 @@ var readZipEntry = async ({
 var hasZip = (bookId) => {
   return !!BOOKS[bookId];
 };
-function concatArrayBuffers(buffers) {
-  const totalLength = buffers.reduce((sum, buf) => sum + buf.byteLength, 0);
-  const concatenated = new Uint8Array(totalLength);
-  let offset = 0;
-  for (const buffer of buffers) {
-    concatenated.set(new Uint8Array(buffer), offset);
-    offset += buffer.byteLength;
-  }
-  return concatenated.buffer;
-}
 var loadZip = async (buf, bookId) => {
   const m = /* @__PURE__ */ new Map();
   const unzipper = new Unzip();
@@ -824,23 +850,42 @@ var loadZip = async (buf, bookId) => {
     await sleep;
   }
   unzipper.push(buf.slice((nChunks - 1) * chunkSize, buf.byteLength), true);
-  BOOKS[bookId] = m;
-  return [...m.keys()];
+  BOOKS[bookId] = {
+    map: m,
+    manifest: null
+  };
+  const manifestEntry = m.get("manifest.json");
+  const keys = [...m.keys()];
+  if (manifestEntry) {
+    manifestEntry.decoded = await decryptData(await manifestEntry.zipEntry.getData(), key, iv);
+    BOOKS[bookId].manifest = bufToJson(manifestEntry.decoded);
+    const { medias } = BOOKS[bookId].manifest;
+    keys.push(...Object.keys(medias).map((entryName) => `medias/${entryName}`));
+  }
+  return keys;
 };
 
 // src/worker/offline-worker.ts
 var CHECK_UPDATES = true;
-var NATIVE = false;
-var LOADED_BOOKS = /* @__PURE__ */ new Set();
+var STORAGE = "cache";
+var ZIP_BASE_URL = "https://ci.lls.fr/artefacts/content/development";
+var CONF_ENV = "development";
+var LOADED_BOOKS = /* @__PURE__ */ new Map();
 var fetchZipFile = async (zipUrl, { forceRefresh } = {}) => {
   const fileName = zipUrl.split("/").slice(-1)[0];
   const readArrayBuffer = async () => {
-    if (NATIVE) {
-      console.debug("try reading native", fileName);
+    if (STORAGE === "native") {
       const back = await sender.nativeReadFile({ fname: fileName });
-      console.debug("done readnig");
       return back;
     }
+    if (STORAGE === "cache") {
+      const response = await caches.match(zipUrl);
+      if (!response) {
+        throw new Error(`missing zip ${zipUrl}`);
+      }
+      const buf = await response.arrayBuffer();
+      return buf;
+    }
     const opfsRoot = await navigator.storage.getDirectory();
     const handle = await opfsRoot.getFileHandle(fileName);
     const accessHandle = await handle.createSyncAccessHandle();
@@ -868,7 +913,7 @@ var fetchZipFile = async (zipUrl, { forceRefresh } = {}) => {
     return buf;
   } catch (e) {
     if (e instanceof Error && e.message !== "forceRefresh" && !e.message.includes("refetching")) {
-      console.debug("opfs db not found, creating it", e, zipUrl);
+      console.debug(`${STORAGE} zip not found, creating it`, e, zipUrl);
     }
     const response = await fetch(zipUrl);
     const contentLength = +response.headers.get("Content-Length");
@@ -879,6 +924,7 @@ var fetchZipFile = async (zipUrl, { forceRefresh } = {}) => {
     while (true) {
       const { done, value: chunk } = await reader.read();
       if (done) {
+        self.postMessage({ methodName: "opfsProgress", arg: { total: contentLength, bytes: contentLength } });
         break;
       }
       arrayBuffer.set(chunk, position);
@@ -893,44 +939,69 @@ var fetchZipFile = async (zipUrl, { forceRefresh } = {}) => {
       console.debug(error);
       throw new Error(error);
     }
-    if (NATIVE) {
+    if (STORAGE === "native") {
       await sender.nativeWriteFile({ fname: fileName, buffer: arrayBuffer });
-      return await readArrayBuffer();
+    } else if (STORAGE === "opfs") {
+      const opfsRoot = await navigator.storage.getDirectory();
+      const handle = await opfsRoot.getFileHandle(fileName, { create: true });
+      const accessHandle = await handle.createSyncAccessHandle();
+      await accessHandle.truncate(0);
+      await accessHandle.write(arrayBuffer);
+      await accessHandle.close();
+    } else {
+      const cache = await openCache(CONF_ENV);
+      const response2 = new Response(arrayBuffer, {
+        headers: {
+          "Cache-Control": "max-age=600, s-maxage=600, public, proxy-revalidate",
+          "Content-Type": "application/zip"
+        },
+        // @ts-ignore: poor ts typing
+        ok: true,
+        redirected: false,
+        status: 200,
+        type: "cors",
+        url: zipUrl
+      });
+      await cache.put(zipUrl, response2);
     }
-    const opfsRoot = await navigator.storage.getDirectory();
-    const handle = await opfsRoot.getFileHandle(fileName, { create: true });
-    const accessHandle = await handle.createSyncAccessHandle();
-    await accessHandle.truncate(0);
-    await accessHandle.write(arrayBuffer);
-    await accessHandle.close();
     return await readArrayBuffer();
   }
 };
 var slugToFileMeta2 = async ({ slug }) => {
-  console.debug("hereshit");
   const json = await readZipEntry({ bookId: "preload", entryName: "preload/hashmap_slugToMetaPage.json", asJson: true });
-  console.debug("hereshit2");
   return slugToFileMeta({ slug, json });
 };
 var PRELOAD_AS_BOOK_ID = "preload";
 var isOldZip = (bookId) => typeof bookId === "number";
 var loadBook2 = async ({ id: bookId, forceRefresh }) => {
   if (LOADED_BOOKS.has(bookId)) {
+    await LOADED_BOOKS.get(bookId);
     self.postMessage({ methodName: "opfsProgress", arg: { total: 1, bytes: 1 } });
     return;
   }
-  LOADED_BOOKS.add(bookId);
-  const buf = await fetchZipFile(`https://ci.lls.fr/artefacts/content/development/${bookId}.zip`, { forceRefresh });
-  try {
-    const entryNames = await loadZip(new Uint8Array(buf), bookId);
-    fetchWorker.postMessage({ methodName: "setKnownLinks", arg: { entryNames, bookId } });
-    if (isOldZip(bookId)) {
-      const json = await readZipEntry({ entryName: `preload/${bookId}.json`, bookId: PRELOAD_AS_BOOK_ID, asJson: true });
-      loadBook(json);
-    }
-  } catch (e) {
-    console.error("failed", e);
-  }
+  const p = new Promise(
+    tryCatch(async () => {
+      const buf = await fetchZipFile(`${ZIP_BASE_URL}/${bookId}.zip`, { forceRefresh });
+      try {
+        const entryNames = await loadZip(new Uint8Array(buf), bookId);
+        fetchWorker.postMessage({ methodName: "setKnownLinks", arg: { entryNames, bookId } });
+        if (isOldZip(bookId)) {
+          const json = await readZipEntry({
+            entryName: `preload/${bookId}.json`,
+            bookId: PRELOAD_AS_BOOK_ID,
+            asJson: true
+          });
+          loadBook(json);
+        }
+        return true;
+      } catch (e) {
+        console.error("failed", e);
+        return false;
+      }
+    })
+  );
+  LOADED_BOOKS.set(bookId, p);
+  await p;
 };
 var loadPageContent2 = async ({
   bookId: iBookId,
@@ -973,11 +1044,18 @@ var initChannel = (__, { ports }) => {
 };
 var loadBooks = async ({ primaryOnly = false } = {}) => {
   let entries = [];
-  if (NATIVE) {
+  if (STORAGE === "native") {
     entries = await sender.nativeListZips();
-  } else {
+  } else if (STORAGE === "opfs") {
     const opfsRoot = await navigator.storage.getDirectory();
     entries = await opfsRoot.values();
+  } else {
+    const cache = await openCache(CONF_ENV);
+    const keys = await cache.keys();
+    const zips = keys.filter((key2) => {
+      return key2.url.match(/lecture-cp\.zip|story-.*?\.zip/);
+    });
+    entries = zips.map((zip) => ({ name: String(zip.url.split("/").pop()) }));
   }
   for await (const entry of entries) {
     if (/preload/.test(entry.name)) {
@@ -996,14 +1074,29 @@ var loadBooks = async ({ primaryOnly = false } = {}) => {
     }
   }
 };
-var configure = ({ native, checkUpdates }) => {
-  console.info("configuring!!", native, checkUpdates);
-  if (typeof native !== "undefined") {
-    NATIVE = !!native;
+var configure = ({
+  storage,
+  checkUpdates,
+  zipBaseUrl,
+  confEnv
+}) => {
+  CHECK_UPDATES = true;
+  STORAGE = "cache";
+  ZIP_BASE_URL = "https://ci.lls.fr/artefacts/content/development";
+  CONF_ENV = "development";
+  if (typeof storage !== "undefined") {
+    STORAGE = storage;
   }
-  if (typeof native !== "undefined") {
+  if (typeof checkUpdates !== "undefined") {
     CHECK_UPDATES = !!checkUpdates;
   }
+  if (typeof zipBaseUrl !== "undefined") {
+    ZIP_BASE_URL = zipBaseUrl;
+  }
+  if (typeof confEnv !== "undefined") {
+    CONF_ENV = confEnv;
+  }
+  console.info("ow::configure", { STORAGE, CHECK_UPDATES, ZIP_BASE_URL, CONF_ENV });
 };
 var loadPreload2 = async () => {
   const zipUrl = "https://lls-ci-fr.s3.eu-west-3.amazonaws.com/artefacts/content/development/preload.zip";

package/lib/index.js

@@ -1,3 +1,14 @@
+// src/utils/error.ts
+var tryCatch = (fn) => {
+  return (resolve, reject) => {
+    try {
+      return fn().then(resolve);
+    } catch (e) {
+      return reject(e);
+    }
+  };
+};
+
 // src/utils/worker.ts
 var makeSyncWorker = (offlineWorker2, methodNames, dbg) => {
   const dic = {};
@@ -19,7 +30,7 @@ var makeSyncWorker = (offlineWorker2, methodNames, dbg) => {
   const makeFn = (methodName) => {
     return ({ ports, ...arg } = {}) => {
       return new Promise((resolve, reject) => {
-        const eventId = `${methodName}:${Date.now()}`;
+        const eventId = `${methodName}:${Date.now()}-${Math.random().toFixed(5)}`;
         dic[eventId] = { resolve, reject };
         offlineWorker2.postMessage({ eventId, methodName, arg }, ports);
       });
@@ -76,11 +87,31 @@ var combineHandlers = (...handlers) => {
 import { useCallback, useEffect, useState } from "react";
 var offlineWorker = new Worker("/src/worker/offline-worker.js", { type: "module" });
 var { handler, ...offlineWorkerSync } = makeSyncWorker(
-  // @ts-ignore: TODO
   offlineWorker,
   ["initChannel", "readZipEntry", "configure", "loadPreload", "loadBooks", "loadBook"],
   "app:offlineWorker"
 );
+var fetchWorkerPromise = new Promise(
+  tryCatch(async () => {
+    let fetchWorker = null;
+    await navigator.serviceWorker.getRegistrations().then((registrations) => {
+      return Promise.all(registrations.map((reg) => reg.unregister()));
+    });
+    await navigator.serviceWorker.register("/fetch-worker.js", { type: "module" }).then((reg) => {
+      return reg.update().catch((e) => {
+        console.debug(e, "likely we are offline");
+      });
+    });
+    await navigator.serviceWorker.ready.then(async (reg) => {
+      console.debug("Service Worker registered:", reg.scope);
+      fetchWorker = reg.active;
+    }).catch((err) => console.error("Service Worker registration failed:", err));
+    if (!fetchWorker) {
+      console.debug("failed to get fetch worker");
+    }
+    return fetchWorker;
+  })
+);
 var setWorkersReady;
 var workersReadyPromise = new Promise((resolve) => {
   setWorkersReady = resolve;
@@ -90,45 +121,42 @@ var setBooksLoadedPromise = new Promise((resolve) => {
   setBooksLoaded = resolve;
 });
 var installWorker = async ({
+  skipLoadBooks = false,
   primaryOnly = false,
   nativeReadFile,
   nativeWriteFile,
   nativeListZips,
-  checkUpdates
+  storage,
+  zipBaseUrl,
+  checkUpdates,
+  confEnv
 } = {}) => {
-  let fetchWorker = null;
-  await navigator.serviceWorker.getRegistrations().then(async (registrations) => {
-    for (const registration of registrations) {
-      await registration.unregister();
-    }
-  });
-  await navigator.serviceWorker.register("/fetch-worker.js", { type: "module" }).then((reg) => reg.update());
-  await navigator.serviceWorker.ready.then(async (reg) => {
-    console.debug("Service Worker registered:", reg.scope);
-    fetchWorker = reg.active;
-  }).catch((err) => console.error("Service Worker registration failed:", err));
-  if (!fetchWorker) {
-    console.debug("failed to get fetch worker");
-    return;
-  }
+  const fetchWorker = await fetchWorkerPromise;
+  const configureOptions = { storage, zipBaseUrl, checkUpdates, confEnv };
   if (nativeReadFile) {
     const wwHandler = makeSyncHandler(offlineWorker, { nativeReadFile, nativeWriteFile, nativeListZips });
     offlineWorker.onmessage = combineHandlers(handler, wwHandler);
-    offlineWorkerSync.configure({ native: true, checkUpdates });
+    if (storage !== "native") {
+      console.warn("nativeReadFile given, ignoring storage", storage);
+    }
+    offlineWorkerSync.configure({ ...configureOptions, storage: "native" });
   } else {
-    offlineWorkerSync.configure({ native: false, checkUpdates });
     offlineWorker.onmessage = handler.handle;
+    offlineWorkerSync.configure(configureOptions);
   }
   offlineWorkerSync.on("ready", setWorkersReady);
   const channel = new MessageChannel();
   offlineWorkerSync.initChannel({ ports: [channel.port1] });
   fetchWorker.postMessage({ methodName: "initChannel" }, [channel.port2]);
+  fetchWorker.postMessage({ methodName: "configure", arg: { storage } });
   offlineWorkerSync.on("opfsProgress", () => {
   });
   if (!primaryOnly) {
     await offlineWorkerSync.loadPreload();
   }
-  await offlineWorkerSync.loadBooks();
+  if (!skipLoadBooks) {
+    await offlineWorkerSync.loadBooks({ primaryOnly });
+  }
   setBooksLoaded();
 };
 var useOfflineWorker_default = ({
@@ -136,17 +164,30 @@ var useOfflineWorker_default = ({
   nativeReadFile,
   nativeWriteFile,
   nativeListZips,
-  checkUpdates
+  checkUpdates,
+  storage,
+  zipBaseUrl,
+  confEnv
 } = {}) => {
   const [ready, setReady] = useState(false);
   useEffect(() => {
     const fn = async () => {
-      await installWorker({ primaryOnly, nativeReadFile, nativeWriteFile, nativeListZips, checkUpdates });
+      await installWorker({
+        primaryOnly,
+        nativeReadFile,
+        nativeWriteFile,
+        nativeListZips,
+        storage,
+        zipBaseUrl,
+        checkUpdates,
+        confEnv
+      });
       await Promise.all([workersReadyPromise, setBooksLoadedPromise]);
+      fetch(window.location.href.replace(window.location.search, ""));
       setReady(true);
     };
     fn();
-  }, [primaryOnly, nativeReadFile, nativeWriteFile, nativeListZips, checkUpdates]);
+  }, [primaryOnly, nativeReadFile, nativeWriteFile, nativeListZips, storage, zipBaseUrl, checkUpdates, confEnv]);
   const loadBook = useCallback(
     async ({ id, forceRefresh }, cbk) => {
       offlineWorkerSync.on("opfsProgress", cbk);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lls/offline",
-  "version": "24.22.0-5bf1d034",
+  "version": "24.22.0-658f61a6",
   "description": "offline",
   "main": "./lib/index.js",
   "module": "./lib/index.js",
@@ -52,7 +52,7 @@
     "vite": "7.0.0",
     "vite-tsconfig-paths": "5.1.4",
     "zod": "3.25.50",
-    "@lls/vitescripts": "24.22.0-5bf1d034"
+    "@lls/vitescripts": "24.22.0-658f61a6"
   },
   "dependencies": {
     "fflate": "0.8.2"