@lls/offline 24.20.0-debug → 24.22.0-34f32711

package/README.md

@@ -3,3 +3,27 @@
 handles offline as webworker for android/ios and desktop
 
 Likely used by core, cocore
+
+## Getting started
+
+Deux types de workers pour gérer le offline:
+
+- un web worker (WW): offlineWorker.ts
+- un service worker (SW): fetch.worker.ts
+
+Le main (useOfflineWorker) instancie les deux workers.
+Dû à la nature du SW qui ne peut pas poster en retour au main, on crèe un lien entre WW et SW via MessageChannel afin qu'ils puissent communiquer entre eux.
+
+SW a pour responsabilité d'intercepter les calls (GQL, assets)
+Il demande le contenu à WW.
+
+WW a pour responsabilité de
+- fetcher le contenu offline (.zip sur s3)
+- gérer l'opfs (stockage navigateur du contenu)
+- lire dans les archives pour servir SW
+
+## Testing
+
+Les WW et SW ont pour interface (offlineWorker.ts, fetch.worker.ts) et délèguent les méthodes métiers aux autres fichiers worker agnostiques (donc testable)
+
+

package/lib/assets/{fetch.worker.js → fetch-worker.js}

@@ -11,12 +11,11 @@ var makeSyncWorker = (offlineWorker2, methodNames, dbg) => {
       }
     } else {
       if (methodName && !methodName.startsWith("async") && !(methodName in cbks)) {
-        console.error(`syncWorker: ${dbg}`, eventId, methodName, error);
+        console.error(`syncWorker: unknown methodName cbk ${dbg}`, eventId, methodName, error);
       }
     }
     methodName && cbks[methodName]?.(arg);
   };
-  offlineWorker2.onmessage = fn;
   const makeFn = (methodName) => {
     return ({ ports, ...arg } = {}) => {
       return new Promise((resolve, reject) => {
@@ -31,27 +30,54 @@ var makeSyncWorker = (offlineWorker2, methodNames, dbg) => {
       cbks[key] = fn2;
     }
   });
-  return obj;
+  return {
+    ...obj,
+    handler: {
+      canHandle: (methodName) => {
+        return methodName in cbks || methodNames.includes(methodName);
+      },
+      handle: fn
+    }
+  };
 };
 var a = (a2) => a2;
 var makeSyncHandler = a(
-  (sender, services) => async ({ data: { eventId, methodName, arg } = {}, ports }) => {
-    try {
-      if (typeof methodName === "string" && methodName in services && services[methodName]) {
-        const results = await services[methodName](arg, { ports });
-        sender.postMessage({ eventId, methodName, results });
-        return;
+  (sender, services) => ({
+    canHandle: (methodName) => {
+      return methodName in services;
+    },
+    handle: async ({ data: { eventId, methodName, arg } = {}, ports }) => {
+      try {
+        if (typeof methodName === "string" && methodName in services && services[methodName]) {
+          const results = await services[methodName](arg, { ports });
+          sender.postMessage({ eventId, methodName, results });
+          return;
+        }
+        throw new Error(`invalid methodName ${Object.keys(services)} |${String(methodName)}`);
+      } catch (e) {
+        console.debug("failed", e);
+        sender.postMessage({ eventId, methodName, error: e });
       }
-      throw new Error(`invalid methodName ${String(methodName)}`);
-    } catch (e) {
-      console.debug("failed", e);
-      sender.postMessage({ eventId, methodName, error: e });
     }
-  }
+  })
 );
 var jsonToBuf = (json) => new TextEncoder().encode(JSON.stringify(json));
+var openCache = async () => caches.open(`LLS_OFFLINE_${process.env.CONF_ENV}`);
 
 // src/worker/swFetchScreenCall.ts
+var zipSlugName = (str) => str.replace(/[^a-zA-Z0-9-.]/g, "");
+var cocoreFetchPartialPageScreen = async (_ev, { offlineWorkerSync: offlineWorkerSync2, variables, knownLinks: knownLinks2 }) => {
+  const key = `gqls/${zipSlugName(variables.slugs[0] || "")}.json`;
+  const entryId = knownLinks2.get(key);
+  if (!entryId) {
+    throw new Error(`slug not found ${key}`);
+  }
+  const gqlPage = await offlineWorkerSync2.loadPageContent({ entryId });
+  return { data: gqlPage };
+};
+var cocoreFetchPartialPageSiblingsScreen = async (_ev) => {
+  return { data: { viewer: {} } };
+};
 var coreFetchBookDrawerScreen = async (_ev, { offlineWorkerSync: offlineWorkerSync2, variables }) => {
   const slug = variables.slugs?.[0];
   const uris = variables.uris;
@@ -161,30 +187,39 @@ var coreFetchPagesApi = async (ev, { offlineWorkerSync: offlineWorkerSync2, vari
     }
   }
 };
-var handleScreenCall = async (ev, { offlineWorkerSync: offlineWorkerSync2 }) => {
+var handles = {
+  coreFetchBookDrawerScreen,
+  coreFetchPagesApi,
+  cocoreFetchPartialPageScreen,
+  cocoreFetchPartialPageSiblingsScreen
+};
+var canHandleScreenCall = (url) => new RegExp(Object.keys(handles).join("|")).test(url);
+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);
-    const handles = {
-      coreFetchBookDrawerScreen,
-      coreFetchPagesApi
-    };
     const key = ev.request.url.match(Object.keys(handles).join("|"))?.[0];
     if (!key) {
       throw new Error("unknown ev");
     }
-    const json = await handles[key](ev, { offlineWorkerSync: offlineWorkerSync2, variables });
+    const json = await handles[key](ev, { offlineWorkerSync: offlineWorkerSync2, variables, knownLinks: knownLinks2 });
     return { status: 200, json };
   } catch (e) {
     console.error(e);
     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
+// src/worker/fetch-worker.ts
 var fetchAsset = async (ev, { entryId, mimeType, offlineWorkerSync: offlineWorkerSync2 }) => {
   try {
     const buf = await offlineWorkerSync2.readZipEntry(entryId);
@@ -212,9 +247,9 @@ var fetchAsset = async (ev, { entryId, mimeType, offlineWorkerSync: offlineWorke
     });
   }
 };
-var fetchScreenCall = async (ev, { offlineWorkerSync: offlineWorkerSync2 }) => {
+var fetchScreenCall = async (ev, { offlineWorkerSync: offlineWorkerSync2, knownLinks: knownLinks2 }) => {
   try {
-    const { status, json } = await handleScreenCall(ev, { offlineWorkerSync: offlineWorkerSync2 });
+    const { status, json } = await handleScreenCall(ev, { offlineWorkerSync: offlineWorkerSync2, knownLinks: knownLinks2 });
     return new Response(jsonToBuf(json), {
       headers: {
         "Cache-Control": "max-age=600, s-maxage=600, public, proxy-revalidate",
@@ -250,65 +285,107 @@ var ACCEPTED_EXTENSIONS = {
   ".m4a": "audio/mp4",
   ".webp": "image/webp"
 };
+var putInCache = async (request, response) => {
+  const cache = await openCache();
+  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", {
+        // @ts-ignore: poor ts typing
+        ok: false,
+        status: 500,
+        type: "cors",
+        url: event.request.url
+      });
+    }
+    return responseFromCache;
+  }
+};
+var STORAGE = "cache";
 var swSelf = self;
 swSelf.addEventListener("fetch", (ev) => {
   const url = ev.request.url;
   const extension = url.match(/\.[^.]+$/)?.[0];
   const mimeType = extension && extension in ACCEPTED_EXTENSIONS ? ACCEPTED_EXTENSIONS[extension] : "";
-  const screenCall = /coreFetchPagesApi|coreFetchBookDrawerScreen/.test(url);
-  if (!mimeType && !screenCall) {
-    if (!/\.(css|tsx?|jsx?|woff2|fr)/.test(url)) {
-      console.debug("no ext", url.match(/\.[^.]+$/)?.[0]);
-    }
+  const isValidScreenCall = canHandleScreenCall(url);
+  if (STORAGE !== "cache" && url.endsWith(".zip")) {
     return;
   }
-  const entryId = knownLinks.get(url.replace(/https:\/\/.*?\//, ""));
-  if (!entryId && !screenCall) {
-    if (/lls|lelivrescolaire/.test(url)) {
-      console.info("no link for", url.replace(/https:\/\/.*?\//, ""));
+  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));
   }
-  if (screenCall) {
+  const entryId = knownLinks.get(url.replace(/https:\/\/.*?\//, "")) || knownLinks.get(`medias/${url.replace(/https:\/\/.*?\//, "")}`);
+  if (isValidScreenCall) {
     console.debug("screencall!");
-    return ev.respondWith(fetchScreenCall(ev, { offlineWorkerSync }));
+    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;
 var initChannel = async (__, { ports }) => {
-  console.info(`FETCH WORKER innitChannel v${13}`);
+  console.info(`FETCH WORKER innitChannel v${/* @__PURE__ */ new Date()}`);
   offlineWorker = ports[0];
-  offlineWorkerSync = makeSyncWorker(
+  const { handler, ...sender } = makeSyncWorker(
     offlineWorker,
     ["readZipEntry", "loadBook", "slugToFileMeta", "loadPageContent", "searchBooks"],
     "fetchworker"
   );
-  offlineWorkerSync.on("setKnownLinks", setKnownLinks);
+  offlineWorkerSync = sender;
+  offlineWorker.onmessage = handler.handle;
+  offlineWorkerSync.on("setKnownLinks", setKnownLinks.bind(null, setKnownLinks));
   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 } = {}) => {
+  STORAGE = "cache";
+  if (typeof storage !== "undefined") {
+    STORAGE = storage;
+  }
+  console.info("sw::configure", { STORAGE });
 };
 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!");
@@ -316,7 +393,7 @@ swSelf.onmessage = async ({
       await services[methodName](arg, { ports });
       return;
     }
-    throw new Error(`fetchworker:invalid methodName ${methodName}`);
+    throw new Error(`fetchworker:invalid methodName ${Object.keys(services)} ${methodName}`);
   } catch (e) {
     console.error("failed", e);
   }

package/lib/assets/{offlineWorker.js → offline-worker.js}

@@ -1,21 +1,89 @@
+// 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 = {};
+  const cbks = {};
+  const fn = ({ data: { eventId, methodName, results, error, arg } = {} } = {}) => {
+    if (eventId && eventId in dic) {
+      if (error) {
+        dic[eventId].reject(error);
+      } else {
+        dic[eventId].resolve(results);
+      }
+    } else {
+      if (methodName && !methodName.startsWith("async") && !(methodName in cbks)) {
+        console.error(`syncWorker: unknown methodName cbk ${dbg}`, eventId, methodName, error);
+      }
+    }
+    methodName && cbks[methodName]?.(arg);
+  };
+  const makeFn = (methodName) => {
+    return ({ ports, ...arg } = {}) => {
+      return new Promise((resolve, reject) => {
+        const eventId = `${methodName}:${Date.now()}`;
+        dic[eventId] = { resolve, reject };
+        offlineWorker.postMessage({ eventId, methodName, arg }, ports);
+      });
+    };
+  };
+  const obj = Object.assign(Object.fromEntries(methodNames.map((name) => [name, makeFn(name)])), {
+    on: (key2, fn2) => {
+      cbks[key2] = fn2;
+    }
+  });
+  return {
+    ...obj,
+    handler: {
+      canHandle: (methodName) => {
+        return methodName in cbks || methodNames.includes(methodName);
+      },
+      handle: fn
+    }
+  };
+};
 var a = (a2) => a2;
 var makeSyncHandler = a(
-  (sender, services) => async ({ data: { eventId, methodName, arg } = {}, ports }) => {
-    try {
-      if (typeof methodName === "string" && methodName in services && services[methodName]) {
-        const results = await services[methodName](arg, { ports });
-        sender.postMessage({ eventId, methodName, results });
-        return;
+  (sender2, services) => ({
+    canHandle: (methodName) => {
+      return methodName in services;
+    },
+    handle: async ({ data: { eventId, methodName, arg } = {}, ports }) => {
+      try {
+        if (typeof methodName === "string" && methodName in services && services[methodName]) {
+          const results = await services[methodName](arg, { ports });
+          sender2.postMessage({ eventId, methodName, results });
+          return;
+        }
+        throw new Error(`invalid methodName ${Object.keys(services)} |${String(methodName)}`);
+      } catch (e) {
+        console.debug("failed", e);
+        sender2.postMessage({ eventId, methodName, error: e });
       }
-      throw new Error(`invalid methodName ${String(methodName)}`);
-    } catch (e) {
-      console.debug("failed", e);
-      sender.postMessage({ eventId, methodName, error: e });
     }
-  }
+  })
 );
 var bufToJson = (buf) => JSON.parse(new TextDecoder("UTF-8").decode(new Uint8Array(buf)));
+var combineHandlers = (...handlers) => {
+  return ({ data: { methodName, ...data } = {}, ports }) => {
+    for (const h of handlers) {
+      if (h.canHandle(String(methodName))) {
+        return h.handle({ data: { methodName, ...data }, ports });
+      }
+    }
+    console.error("no handlers matched", methodName);
+  };
+};
+var openCache = async () => caches.open(`LLS_OFFLINE_${process.env.CONF_ENV}`);
 
 // src/worker/wwApi.ts
 var STATE = {
@@ -40,7 +108,9 @@ var slugToFileMeta = async ({ slug, json }) => {
   return { pageId, chapterId };
 };
 var loadPageContent = async ({ chapterId, json }) => {
-  json.viewer.pages.hits[0].chapter = STATE.chapters[chapterId] || json.viewer.pages.hits[0].chapter;
+  if (chapterId) {
+    json.viewer.pages.hits[0].chapter = STATE.chapters[chapterId] || json.viewer.pages.hits[0].chapter;
+  }
   return json;
 };
 var searchBooks = async ({
@@ -83,14 +153,7 @@ var loadPreload = (json) => {
   });
 };
 
-// ../../node_modules/.pnpm/fflate@0.8.2/node_modules/fflate/esm/index.mjs
-import { createRequire } from "module";
-var require2 = createRequire("/");
-var Worker;
-try {
-  Worker = require2("worker_threads").Worker;
-} catch (e) {
-}
+// ../../node_modules/.pnpm/fflate@0.8.2/node_modules/fflate/esm/browser.js
 var u8 = Uint8Array;
 var u16 = Uint16Array;
 var i32 = Int32Array;
@@ -739,6 +802,9 @@ var loadZip = async (buf, bookId) => {
   const unzipper = new Unzip();
   unzipper.register(UnzipInflate);
   unzipper.onfile = (file) => {
+    if (!file.name.includes(".")) {
+      return;
+    }
     m.set(file.name, {
       decoded: null,
       zipEntry: {
@@ -762,17 +828,39 @@ var loadZip = async (buf, bookId) => {
       }
     });
   };
-  unzipper.push(buf);
+  const chunkSize = 32 * 1024 * 1024;
+  const nChunks = Math.max(1, Math.floor(buf.byteLength / chunkSize));
+  const sleep = new Promise((resolve) => setTimeout(resolve, 0));
+  for (let i = 0; i < nChunks - 1; ++i) {
+    unzipper.push(buf.slice(i * chunkSize, (i + 1) * chunkSize));
+    await sleep;
+  }
+  unzipper.push(buf.slice((nChunks - 1) * chunkSize, buf.byteLength), true);
   BOOKS[bookId] = m;
   return [...m.keys()];
 };
 
-// src/worker/offlineWorker.ts
-var CHECK_UPDATES = false;
-var fetchZipFile = async (zipUrl) => {
-  const opfsRoot = await navigator.storage.getDirectory();
+// src/worker/offline-worker.ts
+var CHECK_UPDATES = true;
+var STORAGE = "cache";
+var ZIP_BASE_URL = "https://ci.lls.fr/artefacts/content/development";
+var LOADED_BOOKS = /* @__PURE__ */ new Map();
+var fetchZipFile = async (zipUrl, { forceRefresh } = {}) => {
   const fileName = zipUrl.split("/").slice(-1)[0];
   const readArrayBuffer = async () => {
+    if (STORAGE === "native") {
+      const back = await sender.nativeReadFile({ fname: fileName });
+      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();
     const size = accessHandle.getSize();
@@ -782,6 +870,9 @@ var fetchZipFile = async (zipUrl) => {
     return arrayBuffer;
   };
   try {
+    if (forceRefresh) {
+      throw new Error("forceRefresh");
+    }
     const buf = await readArrayBuffer();
     if (CHECK_UPDATES) {
       const response = await fetch(zipUrl, { method: "HEAD" });
@@ -795,51 +886,118 @@ var fetchZipFile = async (zipUrl) => {
     }
     return buf;
   } catch (e) {
-    console.debug("opfs db not found, creating it", e, zipUrl);
-    const arrayBuffer = await fetch(zipUrl).then((res) => res.arrayBuffer());
+    if (e instanceof Error && e.message !== "forceRefresh" && !e.message.includes("refetching")) {
+      console.debug(`${STORAGE} zip not found, creating it`, e, zipUrl);
+    }
+    const response = await fetch(zipUrl);
+    const contentLength = +response.headers.get("Content-Length");
+    const reader = response.body.getReader();
+    let position = 0;
+    const arrayBuffer = new Uint8Array(contentLength);
+    let prevPosition = 0;
+    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);
+      position += chunk.length;
+      if (position - prevPosition > 1e6) {
+        prevPosition = position;
+        self.postMessage({ methodName: "opfsProgress", arg: { total: contentLength, bytes: position } });
+      }
+    }
     if (arrayBuffer.byteLength < 1e4) {
-      const error = `likely ${zipUrl} was not fetched`;
+      const error = `likely ${zipUrl} was not fetched ${arrayBuffer.byteLength}`;
       console.debug(error);
       throw new Error(error);
     }
-    const handle = await opfsRoot.getFileHandle(fileName, { create: true });
-    const accessHandle = await handle.createSyncAccessHandle();
-    await accessHandle.truncate(0);
-    await accessHandle.write(arrayBuffer);
-    await accessHandle.close();
+    if (STORAGE === "native") {
+      await sender.nativeWriteFile({ fname: fileName, buffer: arrayBuffer });
+    } 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();
+      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);
+    }
     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 loadBook2 = async (bookId) => {
-  const buf = await fetchZipFile(`https://ci.lls.fr/artefacts/content/production/${bookId}.zip`);
-  try {
-    const entryNames = await loadZip(new Uint8Array(buf), bookId);
-    fetchWorker.postMessage({ methodName: "setKnownLinks", arg: { entryNames, bookId } });
-    const json = await readZipEntry({ entryName: `preload/${bookId}.json`, bookId: PRELOAD_AS_BOOK_ID, asJson: true });
-    loadBook(json);
-  } catch (e) {
-    console.error("failed", e);
+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;
   }
+  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,
+  bookId: iBookId,
   chapterId,
-  pageId
+  pageId,
+  entryId
 }) => {
-  const json = await readZipEntry({ entryName: `${chapterId}/${pageId}.json`, bookId, asJson: true });
+  const bookId = entryId ? entryId.bookId : iBookId;
+  if (!bookId) {
+    throw new Error("missing bookId: expect entryId or bookId");
+  }
+  const json = await readZipEntry({
+    entryName: entryId ? entryId.entryName : `${chapterId}/${pageId}.json`,
+    bookId,
+    asJson: true
+  });
   return await loadPageContent({ chapterId, json });
 };
 var fetchWorker;
 var initChannel = (__, { ports }) => {
   fetchWorker = ports[0];
-  const defaultHandler = makeSyncHandler(fetchWorker, {
+  const { canHandle, handle } = makeSyncHandler(fetchWorker, {
     readZipEntry,
     loadBook: loadBook2,
     slugToFileMeta: slugToFileMeta2,
@@ -851,20 +1009,62 @@ var initChannel = (__, { ports }) => {
       self.postMessage({ methodName: "ready" });
       return;
     }
-    defaultHandler(dataObj);
+    if (canHandle(dataObj.data?.methodName || "")) {
+      return handle(dataObj);
+    }
+    console.error("unknown methodName", dataObj.data?.methodName);
   };
   fetchWorker.onmessage = fn;
 };
-var loadBooks = async () => {
-  const opfsRoot = await navigator.storage.getDirectory();
-  const entries = await opfsRoot.values();
+var loadBooks = async ({ primaryOnly = false } = {}) => {
+  let entries = [];
+  if (STORAGE === "native") {
+    entries = await sender.nativeListZips();
+  } else if (STORAGE === "opfs") {
+    const opfsRoot = await navigator.storage.getDirectory();
+    entries = await opfsRoot.values();
+  } else {
+    const cache = await openCache();
+    const keys = await cache.keys();
+    const zips = keys.filter((key2) => key2.url.endsWith(".zip"));
+    entries = zips.map((zip) => ({ name: String(zip.url.split("/").pop()) }));
+  }
   for await (const entry of entries) {
+    if (/preload/.test(entry.name)) {
+      continue;
+    }
     if (/\d+\.zip$/.test(entry.name)) {
-      const bookId = entry.name.match(/\d+/)[0];
-      await loadBook2(Number.parseInt(bookId, 10));
+      if (!primaryOnly) {
+        const bookId = entry.name.match(/\d+/)[0];
+        await loadBook2({ id: Number.parseInt(bookId, 10) });
+      }
+    } else if (/zip$/.test(entry.name)) {
+      const methodUri = entry.name.replace(".zip", "");
+      await loadBook2({ id: methodUri });
+    } else {
+      console.info(`invalid book entry ${entry.name}`);
     }
   }
 };
+var configure = ({
+  storage,
+  checkUpdates,
+  zipBaseUrl
+}) => {
+  CHECK_UPDATES = true;
+  STORAGE = "cache";
+  ZIP_BASE_URL = "https://ci.lls.fr/artefacts/content/development";
+  if (typeof storage !== "undefined") {
+    STORAGE = storage;
+  }
+  if (typeof checkUpdates !== "undefined") {
+    CHECK_UPDATES = !!checkUpdates;
+  }
+  if (typeof zipBaseUrl !== "undefined") {
+    ZIP_BASE_URL = zipBaseUrl;
+  }
+  console.info("ow::configure", { STORAGE, CHECK_UPDATES, ZIP_BASE_URL });
+};
 var loadPreload2 = async () => {
   const zipUrl = "https://lls-ci-fr.s3.eu-west-3.amazonaws.com/artefacts/content/development/preload.zip";
   const buf = await fetchZipFile(zipUrl);
@@ -877,9 +1077,13 @@ var loadPreload2 = async () => {
     console.error("failed", e);
   }
 };
-self.onmessage = makeSyncHandler(self, {
+var mainHandle = makeSyncHandler(self, {
   initChannel,
   loadPreload: loadPreload2,
   readZipEntry,
-  loadBooks
+  loadBooks,
+  loadBook: loadBook2,
+  configure
 });
+var { handler, ...sender } = makeSyncWorker(self, ["nativeWriteFile", "nativeReadFile", "nativeListZips"]);
+self.onmessage = combineHandlers(mainHandle, handler);

package/lib/index.d.ts

@@ -0,0 +1 @@
+declare module "@lls/offline"

package/lib/index.js

@@ -1,319 +1,19 @@
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __commonJS = (cb, mod) => function __require() {
-  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-
-// ../../node_modules/.pnpm/react@18.3.1/node_modules/react/cjs/react.production.min.js
-var require_react_production_min = __commonJS({
-  "../../node_modules/.pnpm/react@18.3.1/node_modules/react/cjs/react.production.min.js"(exports) {
-    "use strict";
-    var l = Symbol.for("react.element");
-    var n = Symbol.for("react.portal");
-    var p = Symbol.for("react.fragment");
-    var q = Symbol.for("react.strict_mode");
-    var r = Symbol.for("react.profiler");
-    var t = Symbol.for("react.provider");
-    var u = Symbol.for("react.context");
-    var v = Symbol.for("react.forward_ref");
-    var w = Symbol.for("react.suspense");
-    var x = Symbol.for("react.memo");
-    var y = Symbol.for("react.lazy");
-    var z = Symbol.iterator;
-    function A(a2) {
-      if (null === a2 || "object" !== typeof a2) return null;
-      a2 = z && a2[z] || a2["@@iterator"];
-      return "function" === typeof a2 ? a2 : null;
-    }
-    var B = { isMounted: function() {
-      return false;
-    }, enqueueForceUpdate: function() {
-    }, enqueueReplaceState: function() {
-    }, enqueueSetState: function() {
-    } };
-    var C = Object.assign;
-    var D = {};
-    function E(a2, b, e) {
-      this.props = a2;
-      this.context = b;
-      this.refs = D;
-      this.updater = e || B;
-    }
-    E.prototype.isReactComponent = {};
-    E.prototype.setState = function(a2, b) {
-      if ("object" !== typeof a2 && "function" !== typeof a2 && null != a2) throw Error("setState(...): takes an object of state variables to update or a function which returns an object of state variables.");
-      this.updater.enqueueSetState(this, a2, b, "setState");
-    };
-    E.prototype.forceUpdate = function(a2) {
-      this.updater.enqueueForceUpdate(this, a2, "forceUpdate");
-    };
-    function F() {
-    }
-    F.prototype = E.prototype;
-    function G(a2, b, e) {
-      this.props = a2;
-      this.context = b;
-      this.refs = D;
-      this.updater = e || B;
-    }
-    var H = G.prototype = new F();
-    H.constructor = G;
-    C(H, E.prototype);
-    H.isPureReactComponent = true;
-    var I = Array.isArray;
-    var J = Object.prototype.hasOwnProperty;
-    var K = { current: null };
-    var L = { key: true, ref: true, __self: true, __source: true };
-    function M(a2, b, e) {
-      var d, c = {}, k = null, h = null;
-      if (null != b) for (d in void 0 !== b.ref && (h = b.ref), void 0 !== b.key && (k = "" + b.key), b) J.call(b, d) && !L.hasOwnProperty(d) && (c[d] = b[d]);
-      var g = arguments.length - 2;
-      if (1 === g) c.children = e;
-      else if (1 < g) {
-        for (var f = Array(g), m = 0; m < g; m++) f[m] = arguments[m + 2];
-        c.children = f;
-      }
-      if (a2 && a2.defaultProps) for (d in g = a2.defaultProps, g) void 0 === c[d] && (c[d] = g[d]);
-      return { $$typeof: l, type: a2, key: k, ref: h, props: c, _owner: K.current };
-    }
-    function N(a2, b) {
-      return { $$typeof: l, type: a2.type, key: b, ref: a2.ref, props: a2.props, _owner: a2._owner };
-    }
-    function O(a2) {
-      return "object" === typeof a2 && null !== a2 && a2.$$typeof === l;
-    }
-    function escape(a2) {
-      var b = { "=": "=0", ":": "=2" };
-      return "$" + a2.replace(/[=:]/g, function(a3) {
-        return b[a3];
-      });
-    }
-    var P = /\/+/g;
-    function Q(a2, b) {
-      return "object" === typeof a2 && null !== a2 && null != a2.key ? escape("" + a2.key) : b.toString(36);
-    }
-    function R(a2, b, e, d, c) {
-      var k = typeof a2;
-      if ("undefined" === k || "boolean" === k) a2 = null;
-      var h = false;
-      if (null === a2) h = true;
-      else switch (k) {
-        case "string":
-        case "number":
-          h = true;
-          break;
-        case "object":
-          switch (a2.$$typeof) {
-            case l:
-            case n:
-              h = true;
-          }
-      }
-      if (h) return h = a2, c = c(h), a2 = "" === d ? "." + Q(h, 0) : d, I(c) ? (e = "", null != a2 && (e = a2.replace(P, "$&/") + "/"), R(c, b, e, "", function(a3) {
-        return a3;
-      })) : null != c && (O(c) && (c = N(c, e + (!c.key || h && h.key === c.key ? "" : ("" + c.key).replace(P, "$&/") + "/") + a2)), b.push(c)), 1;
-      h = 0;
-      d = "" === d ? "." : d + ":";
-      if (I(a2)) for (var g = 0; g < a2.length; g++) {
-        k = a2[g];
-        var f = d + Q(k, g);
-        h += R(k, b, e, f, c);
-      }
-      else if (f = A(a2), "function" === typeof f) for (a2 = f.call(a2), g = 0; !(k = a2.next()).done; ) k = k.value, f = d + Q(k, g++), h += R(k, b, e, f, c);
-      else if ("object" === k) throw b = String(a2), Error("Objects are not valid as a React child (found: " + ("[object Object]" === b ? "object with keys {" + Object.keys(a2).join(", ") + "}" : b) + "). If you meant to render a collection of children, use an array instead.");
-      return h;
-    }
-    function S(a2, b, e) {
-      if (null == a2) return a2;
-      var d = [], c = 0;
-      R(a2, d, "", "", function(a3) {
-        return b.call(e, a3, c++);
-      });
-      return d;
-    }
-    function T(a2) {
-      if (-1 === a2._status) {
-        var b = a2._result;
-        b = b();
-        b.then(function(b2) {
-          if (0 === a2._status || -1 === a2._status) a2._status = 1, a2._result = b2;
-        }, function(b2) {
-          if (0 === a2._status || -1 === a2._status) a2._status = 2, a2._result = b2;
-        });
-        -1 === a2._status && (a2._status = 0, a2._result = b);
-      }
-      if (1 === a2._status) return a2._result.default;
-      throw a2._result;
-    }
-    var U = { current: null };
-    var V = { transition: null };
-    var W = { ReactCurrentDispatcher: U, ReactCurrentBatchConfig: V, ReactCurrentOwner: K };
-    function X() {
-      throw Error("act(...) is not supported in production builds of React.");
-    }
-    exports.Children = { map: S, forEach: function(a2, b, e) {
-      S(a2, function() {
-        b.apply(this, arguments);
-      }, e);
-    }, count: function(a2) {
-      var b = 0;
-      S(a2, function() {
-        b++;
-      });
-      return b;
-    }, toArray: function(a2) {
-      return S(a2, function(a3) {
-        return a3;
-      }) || [];
-    }, only: function(a2) {
-      if (!O(a2)) throw Error("React.Children.only expected to receive a single React element child.");
-      return a2;
-    } };
-    exports.Component = E;
-    exports.Fragment = p;
-    exports.Profiler = r;
-    exports.PureComponent = G;
-    exports.StrictMode = q;
-    exports.Suspense = w;
-    exports.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED = W;
-    exports.act = X;
-    exports.cloneElement = function(a2, b, e) {
-      if (null === a2 || void 0 === a2) throw Error("React.cloneElement(...): The argument must be a React element, but you passed " + a2 + ".");
-      var d = C({}, a2.props), c = a2.key, k = a2.ref, h = a2._owner;
-      if (null != b) {
-        void 0 !== b.ref && (k = b.ref, h = K.current);
-        void 0 !== b.key && (c = "" + b.key);
-        if (a2.type && a2.type.defaultProps) var g = a2.type.defaultProps;
-        for (f in b) J.call(b, f) && !L.hasOwnProperty(f) && (d[f] = void 0 === b[f] && void 0 !== g ? g[f] : b[f]);
-      }
-      var f = arguments.length - 2;
-      if (1 === f) d.children = e;
-      else if (1 < f) {
-        g = Array(f);
-        for (var m = 0; m < f; m++) g[m] = arguments[m + 2];
-        d.children = g;
-      }
-      return { $$typeof: l, type: a2.type, key: c, ref: k, props: d, _owner: h };
-    };
-    exports.createContext = function(a2) {
-      a2 = { $$typeof: u, _currentValue: a2, _currentValue2: a2, _threadCount: 0, Provider: null, Consumer: null, _defaultValue: null, _globalName: null };
-      a2.Provider = { $$typeof: t, _context: a2 };
-      return a2.Consumer = a2;
-    };
-    exports.createElement = M;
-    exports.createFactory = function(a2) {
-      var b = M.bind(null, a2);
-      b.type = a2;
-      return b;
-    };
-    exports.createRef = function() {
-      return { current: null };
-    };
-    exports.forwardRef = function(a2) {
-      return { $$typeof: v, render: a2 };
-    };
-    exports.isValidElement = O;
-    exports.lazy = function(a2) {
-      return { $$typeof: y, _payload: { _status: -1, _result: a2 }, _init: T };
-    };
-    exports.memo = function(a2, b) {
-      return { $$typeof: x, type: a2, compare: void 0 === b ? null : b };
-    };
-    exports.startTransition = function(a2) {
-      var b = V.transition;
-      V.transition = {};
-      try {
-        a2();
-      } finally {
-        V.transition = b;
-      }
-    };
-    exports.unstable_act = X;
-    exports.useCallback = function(a2, b) {
-      return U.current.useCallback(a2, b);
-    };
-    exports.useContext = function(a2) {
-      return U.current.useContext(a2);
-    };
-    exports.useDebugValue = function() {
-    };
-    exports.useDeferredValue = function(a2) {
-      return U.current.useDeferredValue(a2);
-    };
-    exports.useEffect = function(a2, b) {
-      return U.current.useEffect(a2, b);
-    };
-    exports.useId = function() {
-      return U.current.useId();
-    };
-    exports.useImperativeHandle = function(a2, b, e) {
-      return U.current.useImperativeHandle(a2, b, e);
-    };
-    exports.useInsertionEffect = function(a2, b) {
-      return U.current.useInsertionEffect(a2, b);
-    };
-    exports.useLayoutEffect = function(a2, b) {
-      return U.current.useLayoutEffect(a2, b);
-    };
-    exports.useMemo = function(a2, b) {
-      return U.current.useMemo(a2, b);
-    };
-    exports.useReducer = function(a2, b, e) {
-      return U.current.useReducer(a2, b, e);
-    };
-    exports.useRef = function(a2) {
-      return U.current.useRef(a2);
-    };
-    exports.useState = function(a2) {
-      return U.current.useState(a2);
-    };
-    exports.useSyncExternalStore = function(a2, b, e) {
-      return U.current.useSyncExternalStore(a2, b, e);
-    };
-    exports.useTransition = function() {
-      return U.current.useTransition();
-    };
-    exports.version = "18.3.1";
-  }
-});
-
-// ../../node_modules/.pnpm/react@18.3.1/node_modules/react/index.js
-var require_react = __commonJS({
-  "../../node_modules/.pnpm/react@18.3.1/node_modules/react/index.js"(exports, module) {
-    "use strict";
-    if (true) {
-      module.exports = require_react_production_min();
-    } else {
-      module.exports = null;
+// 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) => {
+var makeSyncWorker = (offlineWorker2, methodNames, dbg) => {
   const dic = {};
   const cbks = {};
-  const fn2 = ({ data: { eventId, methodName, results, error, arg } = {} } = {}) => {
+  const fn = ({ data: { eventId, methodName, results, error, arg } = {} } = {}) => {
     if (eventId && eventId in dic) {
       if (error) {
         dic[eventId].reject(error);
@@ -322,53 +22,93 @@ var makeSyncWorker = (offlineWorker, methodNames, dbg) => {
       }
     } else {
       if (methodName && !methodName.startsWith("async") && !(methodName in cbks)) {
-        console.error(`syncWorker: ${dbg}`, eventId, methodName, error);
+        console.error(`syncWorker: unknown methodName cbk ${dbg}`, eventId, methodName, error);
       }
     }
     methodName && cbks[methodName]?.(arg);
   };
-  offlineWorker.onmessage = fn2;
   const makeFn = (methodName) => {
     return ({ ports, ...arg } = {}) => {
       return new Promise((resolve, reject) => {
         const eventId = `${methodName}:${Date.now()}`;
         dic[eventId] = { resolve, reject };
-        offlineWorker.postMessage({ eventId, methodName, arg }, ports);
+        offlineWorker2.postMessage({ eventId, methodName, arg }, ports);
       });
     };
   };
   const obj = Object.assign(Object.fromEntries(methodNames.map((name) => [name, makeFn(name)])), {
-    on: (key, fn3) => {
-      cbks[key] = fn3;
+    on: (key, fn2) => {
+      cbks[key] = fn2;
     }
   });
-  return obj;
+  return {
+    ...obj,
+    handler: {
+      canHandle: (methodName) => {
+        return methodName in cbks || methodNames.includes(methodName);
+      },
+      handle: fn
+    }
+  };
 };
 var a = (a2) => a2;
 var makeSyncHandler = a(
-  (sender, services) => async ({ data: { eventId, methodName, arg } = {}, ports }) => {
-    try {
-      if (typeof methodName === "string" && methodName in services && services[methodName]) {
-        const results = await services[methodName](arg, { ports });
-        sender.postMessage({ eventId, methodName, results });
-        return;
+  (sender, services) => ({
+    canHandle: (methodName) => {
+      return methodName in services;
+    },
+    handle: async ({ data: { eventId, methodName, arg } = {}, ports }) => {
+      try {
+        if (typeof methodName === "string" && methodName in services && services[methodName]) {
+          const results = await services[methodName](arg, { ports });
+          sender.postMessage({ eventId, methodName, results });
+          return;
+        }
+        throw new Error(`invalid methodName ${Object.keys(services)} |${String(methodName)}`);
+      } catch (e) {
+        console.debug("failed", e);
+        sender.postMessage({ eventId, methodName, error: e });
       }
-      throw new Error(`invalid methodName ${String(methodName)}`);
-    } catch (e) {
-      console.debug("failed", e);
-      sender.postMessage({ eventId, methodName, error: e });
     }
-  }
+  })
 );
+var combineHandlers = (...handlers) => {
+  return ({ data: { methodName, ...data } = {}, ports }) => {
+    for (const h of handlers) {
+      if (h.canHandle(String(methodName))) {
+        return h.handle({ data: { methodName, ...data }, ports });
+      }
+    }
+    console.error("no handlers matched", methodName);
+  };
+};
 
 // src/hooks/useOfflineWorker.ts
-var import_react = __toESM(require_react(), 1);
-var offlineWorkerSync = makeSyncWorker(
-  // @ts-ignore: TODO
-  new Worker("/src/worker/offlineWorker.js", { type: "module" }),
-  ["initChannel", "readZipEntry", "loadPreload", "loadBooks"],
+import { useCallback, useEffect, useState } from "react";
+var offlineWorker = new Worker("/src/worker/offline-worker.js", { type: "module" });
+var { handler, ...offlineWorkerSync } = makeSyncWorker(
+  offlineWorker,
+  ["initChannel", "readZipEntry", "configure", "loadPreload", "loadBooks", "loadBook"],
   "app:offlineWorker"
 );
+var fetchWorkerPromise = new Promise(
+  tryCatch(async () => {
+    let fetchWorker = null;
+    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;
@@ -377,54 +117,83 @@ var setBooksLoaded;
 var setBooksLoadedPromise = new Promise((resolve) => {
   setBooksLoaded = resolve;
 });
-var fn = async () => {
-  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) {
-    return;
+var installWorker = async ({
+  skipLoadBooks = false,
+  primaryOnly = false,
+  nativeReadFile,
+  nativeWriteFile,
+  nativeListZips,
+  storage,
+  zipBaseUrl,
+  checkUpdates
+} = {}) => {
+  const fetchWorker = await fetchWorkerPromise;
+  const configureOptions = { storage, zipBaseUrl, checkUpdates };
+  if (nativeReadFile) {
+    const wwHandler = makeSyncHandler(offlineWorker, { nativeReadFile, nativeWriteFile, nativeListZips });
+    offlineWorker.onmessage = combineHandlers(handler, wwHandler);
+    if (storage !== "native") {
+      console.warn("nativeReadFile given, ignoring storage", storage);
+    }
+    offlineWorkerSync.configure({ ...configureOptions, storage: "native" });
+  } else {
+    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]);
-  await offlineWorkerSync.loadPreload();
-  await offlineWorkerSync.loadBooks();
+  fetchWorker.postMessage({ methodName: "configure", arg: { storage } });
+  offlineWorkerSync.on("opfsProgress", () => {
+  });
+  if (!primaryOnly) {
+    await offlineWorkerSync.loadPreload();
+  }
+  if (!skipLoadBooks) {
+    await offlineWorkerSync.loadBooks({ primaryOnly });
+  }
   setBooksLoaded();
 };
-fn();
-var useOfflineWorker_default = () => {
-  const [ready, setReady] = (0, import_react.useState)(false);
-  (0, import_react.useEffect)(() => {
-    const fn2 = async () => {
+var useOfflineWorker_default = ({
+  primaryOnly = false,
+  nativeReadFile,
+  nativeWriteFile,
+  nativeListZips,
+  checkUpdates,
+  storage,
+  zipBaseUrl
+} = {}) => {
+  const [ready, setReady] = useState(false);
+  useEffect(() => {
+    const fn = async () => {
+      await installWorker({
+        primaryOnly,
+        nativeReadFile,
+        nativeWriteFile,
+        nativeListZips,
+        storage,
+        zipBaseUrl,
+        checkUpdates
+      });
       await Promise.all([workersReadyPromise, setBooksLoadedPromise]);
+      fetch(window.location.href.replace(window.location.search, ""));
       setReady(true);
     };
-    fn2();
-  }, []);
-  return ready;
+    fn();
+  }, [primaryOnly, nativeReadFile, nativeWriteFile, nativeListZips, storage, zipBaseUrl, checkUpdates]);
+  const loadBook = useCallback(
+    async ({ id, forceRefresh }, cbk) => {
+      offlineWorkerSync.on("opfsProgress", cbk);
+      return await offlineWorkerSync.loadBook({ id, forceRefresh });
+    },
+    []
+  );
+  return {
+    ready,
+    loadBook
+  };
 };
 export {
   useOfflineWorker_default as useOfflineWorker
 };
-/*! Bundled license information:
-
-react/cjs/react.production.min.js:
-  (**
-   * @license React
-   * react.production.min.js
-   *
-   * Copyright (c) Facebook, Inc. and its affiliates.
-   *
-   * This source code is licensed under the MIT license found in the
-   * LICENSE file in the root directory of this source tree.
-   *)
-*/

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lls/offline",
-  "version": "24.20.0-debug",
+  "version": "24.22.0-34f32711",
   "description": "offline",
   "main": "./lib/index.js",
   "module": "./lib/index.js",
@@ -36,10 +36,12 @@
   "devDependencies": {
     "@biomejs/biome": "1.9.4",
     "@happy-dom/global-registrator": "15.11.0",
+    "@ladle/react": "5.0.3",
     "@testing-library/react": "16.3.0",
     "@types/react": "18.3.12",
     "@types/react-dom": "18.3.1",
     "@vitejs/plugin-react": "4.5.1",
+    "@vitejs/plugin-react-swc": "3.10.1",
     "esbuild": "0.24.0",
     "happy-dom": "15.11.0",
     "lodash": "4.17.21",
@@ -48,17 +50,21 @@
     "react-dom": "18.3.1",
     "typescript": "5.8.3",
     "vite": "7.0.0",
+    "vite-tsconfig-paths": "5.1.4",
     "zod": "3.25.50",
-    "@lls/vitescripts": "24.20.0"
+    "@lls/vitescripts": "24.22.0-34f32711"
   },
   "dependencies": {
     "fflate": "0.8.2"
   },
   "scripts": {
-    "start": "echo no devserver",
+    "start": "pnpm ladle serve",
     "dts": "pnpm tsc --project tsconfig.production.json",
-    "build": "node build",
-    "test": "bun test --bail",
-    "lint": "pnpm biome check --apply src __tests__"
+    "build": "NODE_ENV=production node build.js",
+    "deploy-ladle": "PUBLISH=1 pnpm ladle build",
+    "deploy-ladle-pr": "pnpm ladle build && s5cmd sync --delete --acl public-read --destination-region eu-west-1 'dist/*' s3://build.lelivrescolaire.fr/storybook/viewer-pr-$PR_NUMBER/",
+    "test": "bun test --bail __tests__/unit __tests__/e2e",
+    "lint": "pnpm biome check --apply src __tests__ stories",
+    "precommit": "pnpm lint"
   }
 }