@inkandswitch/patchwork-bootloader 0.2.5 → 0.2.7

package/src/service-worker.ts

@@ -1,71 +1,27 @@
 /// <reference types="service-worker-types" />
 
-import { SwLogger } from "./sw-logger.js";
-
-// Heavy imports — marked external by the service-worker vite plugin,
-// resolved to /packages/... URLs at build time. The SW is registered with
-// type:"module" so the browser fetches these as regular network requests.
-// Uses /slim to avoid top-level await (disallowed in service workers).
-// Wasm is fetched from /automerge.wasm (emitted by the vite plugin) instead
-// of bundling the ~3MB base64 string.
-import { initializeWasm, hasHeads } from "@automerge/automerge/slim";
-// eslint-disable-next-line
-// @ts-ignore — initSync is a wasm-bindgen runtime helper not in the .d.ts
-import { initSync as initSubductionSync } from "@automerge/automerge-subduction/slim";
-import { WebCryptoSigner } from "@automerge/automerge-subduction/slim";
+// The service worker holds no automerge repo — that lives in the automerge
+// SharedWorker (automerge-worker.ts). This worker manages the cache. When a
+// special URL misses the cache it broadcasts a handoff request; the
+// automerge worker resolves it, puts the response in our cache, and replies
+// "cached" (or "response" for errors and other things that shouldn't be
+// cached).
 
 import {
-  Repo,
-  isValidAutomergeUrl,
-  parseAutomergeUrl,
-  stringifyAutomergeUrl,
-  type PeerId,
-} from "@automerge/automerge-repo/slim";
-import { resolvePath } from "@inkandswitch/patchwork-filesystem";
-
-// Small adapters — bundled directly into the SW
-import { IndexedDBStorageAdapter } from "@automerge/automerge-repo-storage-indexeddb";
-import { MessageChannelNetworkAdapter } from "@automerge/automerge-repo-network-messagechannel";
-import { WebSocketClientAdapter } from "@automerge/automerge-repo-network-websocket";
+  HANDOFF_CHANNEL,
+  type HandoffReplyMessage,
+  type HandoffRequestMessage,
+} from "./types.js";
 
-// TEMPORARY: enable debug npm module in SW context (no localStorage available)
 let cachename = "default";
 let debugging = false;
-const workerInstanceId = crypto.randomUUID();
-
-const SUBDUCTION_ENDPOINTS = ["wss://subduction.sync.inkandswitch.com"];
-const RESOLVE_TIMEOUT_MS = 30_000;
-
-// ── Persistent logger ───────────────────────────────────────────────────
-// Initialized eagerly so it's available for the entire SW lifetime.
-// Access from the SW inspector console via self.printLogs(), self.tailLogs(),
-// self.exportLogs(), self.clearLogs().
-const slog = SwLogger.open().then((logger) => {
-  (self as any).slog = logger;
-
-  (self as any).printLogs = async (n = 200) => {
-    const entries = await logger.tail(n);
-    for (const e of entries) {
-      const prefix = `[${e.ts}] [${e.level}]`;
-      if (e.data !== undefined) {
-        console.log(prefix, e.msg, e.data);
-      } else {
-        console.log(prefix, e.msg);
-      }
-    }
-    console.log(`--- ${entries.length} entries ---`);
-  };
-
-  (self as any).tailLogs = (n = 200) => logger.tail(n);
-  (self as any).exportLogs = () => logger.exportAll();
-  (self as any).clearLogs = () => logger.clear();
-
-  logger.info("sw-logger initialized");
-  return logger;
-});
 
 const cacheableStatuses = [200, 203, 204, 206];
 
+// The automerge worker times its own resolution out after 30s and replies
+// with an error, so this only fires when nobody is listening at all.
+const HANDOFF_TIMEOUT_MS = 35_000;
+
 function log(...args: any[]) {
   if (!debugging) return;
   console.log.call(
@@ -77,7 +33,12 @@ function log(...args: any[]) {
   );
 }
 
-self.addEventListener("install", () => self.skipWaiting());
+self.addEventListener("install", (event) => {
+  // waitUntil keeps the worker alive until skipWaiting resolves, so a freshly
+  // installed SW reliably jumps the "waiting" queue instead of stalling until
+  // every old tab closes.
+  (event as ExtendableEvent).waitUntil(self.skipWaiting());
+});
 
 async function clearOldCaches() {
   const cacheWhitelist = [cachename];
@@ -90,117 +51,20 @@ async function clearOldCaches() {
   await Promise.all(deletePromises);
 }
 
-self.addEventListener("activate", async () => {
-  await clearOldCaches();
-  clients.claim();
-});
-
-let repoPromise: Promise<Repo> | null = null;
-
-function getRepo() {
-  if (!repoPromise) {
-    const p: Promise<Repo> = (async () => {
-      const logger = await slog;
-      logger.info("getRepo: starting");
-
-      logger.info("fetching wasm modules");
-      const [amWasmBuf, sdnWasmBuf] = await Promise.all([
-        fetch("/automerge.wasm?sw").then((r) => r.arrayBuffer()),
-        fetch("/subduction.wasm").then((r) => r.arrayBuffer()),
-      ]);
-      initSubductionSync(new Uint8Array(sdnWasmBuf));
-      await initializeWasm(new Uint8Array(amWasmBuf));
-      logger.info("wasm initialized");
-
-      const signer = await WebCryptoSigner.setup();
-
-      const repo = new Repo({
-        storage: new IndexedDBStorageAdapter(),
-        signer,
-        peerId: ("service-worker-" +
-          (Math.random() * 10000).toString(36).slice(2)) as PeerId,
-        async sharePolicy(peerId) {
-          return peerId.includes("storage-server");
-        },
-        enableRemoteHeadsGossiping: true,
-        subductionWebsocketEndpoints: SUBDUCTION_ENDPOINTS,
-        network: [new WebSocketClientAdapter("wss://sync3.automerge.org")],
-      });
-
-      (self as any).repo = repo;
-      logger.info("repo constructed, waiting for network subsystem");
-
-      // Don't block getRepo() on whenReady() — the network subsystem starts
-      // with only the subduction adapter, and the MessageChannel adapter is
-      // added later via connectPort (which awaits getRepo). Blocking here
-      // would deadlock that path and starve the fetch handler.
-      repo.networkSubsystem.whenReady().then(() => {
-        logger.info("repo network subsystem ready");
-      });
-
-      return repo;
-    })();
-    // If construction fails (e.g. wasm fetch errors out because the SW was
-    // terminated mid-flight), don't permanently cache the rejection — clear
-    // the slot so the next caller can retry from scratch.
-    p.catch(() => {
-      if (repoPromise === p) repoPromise = null;
-    });
-    repoPromise = p;
-  }
-  return repoPromise;
-}
-
-// Connect client MessagePorts to the repo for sync
-async function connectPort(port: MessagePort) {
-  const repo = await getRepo();
-  repo.networkSubsystem.addNetworkAdapter(
-    new MessageChannelNetworkAdapter(port, { useWeakRef: true })
+self.addEventListener("activate", (event) => {
+  // Without waitUntil the activate event settles immediately and clients.claim()
+  // runs detached — the new worker can be killed before it takes control, so
+  // existing tabs keep talking to the old SW. Extend the event instead.
+  (event as ExtendableEvent).waitUntil(
+    (async () => {
+      await clearOldCaches();
+      await self.clients.claim();
+    })()
   );
-}
+});
 
 self.addEventListener("message", async (event) => {
-  if (event.data.type == "ping") {
-    // Keepalive — Chromium idles out service workers after ~30s of inactivity.
-    // Reply via the provided port if any; the message event itself also resets
-    // the idle timer.
-    const [pongPort] = event.ports;
-    log("ping");
-    if (pongPort) {
-      pongPort.postMessage({ type: "pong", workerInstanceId });
-      log("pong");
-      pongPort.close();
-    } else if (event.source) {
-      (event.source as unknown as Client).postMessage({
-        type: "pong",
-        workerInstanceId,
-      });
-      log("pong");
-    }
-  } else if (event.data.type == "port") {
-    log("received messagechannel");
-    const [port] = event.ports;
-    const source = event.source as Client | null;
-    const id = event.data.id;
-    // event.waitUntil keeps the SW alive until the work completes. Without
-    // it, the browser can terminate the SW the moment this synchronous block
-    // returns, killing the in-flight wasm fetch.
-    (event as unknown as FetchEvent).waitUntil(
-      connectPort(port).then(
-        () => source?.postMessage({ type: "port-ready", id, workerInstanceId }),
-        (err) => {
-          console.error("connectPort failed", err);
-          // Tell the client we failed so it doesn't hang forever.
-          source?.postMessage({
-            type: "port-failed",
-            id,
-            error: String(err),
-            workerInstanceId,
-          });
-        }
-      )
-    );
-  } else if (event.data.type == "cachename") {
+  if (event.data.type == "cachename") {
     const nextCachename = event.data.cachename;
     if (cachename == nextCachename) {
       return;
@@ -216,65 +80,82 @@ self.addEventListener("message", async (event) => {
   }
 });
 
-// ── Automerge URL resolution ───────────────────────────────────────────
+// ── Handoff to the automerge worker ────────────────────────────────────
 
-async function resolveAutomergeUrl(automergeURL: URL): Promise<Response> {
-  const repo = await getRepo();
-  const href = automergeURL.href;
-  const [maybeAutomergeUrl, ...path] = href.split("/");
+const handoffChannel = new BroadcastChannel(HANDOFF_CHANNEL);
 
-  if (!isValidAutomergeUrl(maybeAutomergeUrl)) {
-    return new Response("invalid automerge url", { status: 400 });
-  }
+type PendingHandoff = {
+  message: HandoffRequestMessage;
+  resolvers: PromiseWithResolvers<HandoffReplyMessage>;
+};
 
-  // Trim trailing empty path segment
-  if (path.length && !path[path.length - 1]) path.pop();
+const pendingHandoffs = new Map<string, PendingHandoff>();
 
-  const { heads, hexHeads, documentId } = parseAutomergeUrl(maybeAutomergeUrl);
-  const signal = AbortSignal.timeout(RESOLVE_TIMEOUT_MS);
-
-  if (!heads) {
-    const folder = await repo.find(maybeAutomergeUrl, { signal });
-    const latestHeads = folder.heads();
-    const url = stringifyAutomergeUrl({ documentId, heads: latestHeads });
-    let location = `/${encodeURIComponent(url)}`;
-    if (path.length) location += `/${path.join("/")}`;
-    return Response.redirect(location, 307);
-  }
-
-  // Load by documentId only so we can verify the requested heads are actually
-  // in our local history. repo.find with a heads-bearing URL returns a view
-  // at those heads, which silently materializes garbage if we never synced them.
-  const baseHandle = await repo.find(stringifyAutomergeUrl({ documentId }), {
-    signal,
-  });
-  if (!hasHeads(baseHandle.doc(), hexHeads ?? [])) {
-    return new Response("heads not found", { status: 404 });
+handoffChannel.addEventListener("message", (event) => {
+  const data = event.data;
+  if (data?.type === "cached" || data?.type === "response") {
+    const pending = pendingHandoffs.get(data.id);
+    if (!pending) {
+      return log(`no pending handoff for id ${data.id}`);
+    }
+    pending.resolvers.resolve(data as HandoffReplyMessage);
+  } else if (data?.type === "online") {
+    // The automerge worker (re)started — re-broadcast anything still in
+    // flight so requests that raced its boot aren't stranded.
+    for (const { message } of pendingHandoffs.values()) {
+      log(`re-broadcasting handoff ${message.id} to the fresh worker`);
+      handoffChannel.postMessage(message);
+    }
   }
-  const rootHandle = baseHandle.view(heads);
-
-  const resolved = await resolvePath(
-    repo,
-    rootHandle,
-    path.map(decodeURIComponent)
-  );
+});
 
-  if (!resolved) {
-    throw new Error(
-      `couldn't resolve ${path.join("/")} in folder at ${maybeAutomergeUrl}`
+function handoff(
+  request: Request,
+  handoffURL: URL
+): Promise<HandoffReplyMessage> {
+  const id = crypto.randomUUID();
+  const resolvers = Promise.withResolvers<HandoffReplyMessage>();
+  const message: HandoffRequestMessage = {
+    id,
+    type: "request",
+    cachename,
+    request: {
+      url: request.url,
+      handoffURL: handoffURL.href,
+      headers: Object.fromEntries(request.headers.entries()),
+      method: request.method,
+      destination: request.destination,
+      referrer: request.referrer,
+    },
+  };
+  pendingHandoffs.set(id, { message, resolvers });
+  log(`broadcasting handoff request for cache ${cachename}`, message);
+  handoffChannel.postMessage(message);
+  const timeout = setTimeout(() => {
+    resolvers.reject(
+      new Error(
+        `no reply from the automerge worker after ${HANDOFF_TIMEOUT_MS}ms`
+      )
     );
-  }
-
-  const body: BodyInit =
-    resolved.content instanceof Uint8Array
-      ? (new Uint8Array(resolved.content) as BlobPart)
-      : resolved.content;
+  }, HANDOFF_TIMEOUT_MS);
+  return resolvers.promise.finally(() => {
+    clearTimeout(timeout);
+    pendingHandoffs.delete(id);
+  });
+}
 
-  const headers = new Headers({ "content-type": resolved.type });
+function withSpecialHeaders(response: {
+  body?: BodyInit | ReadableStream<Uint8Array> | null;
+  status?: number;
+  headers?: HeadersInit;
+}): Response {
+  const headers = new Headers(response.headers);
   headers.set("cross-origin-embedder-policy", "credentialless");
   headers.set("cross-origin-resource-policy", "cross-origin");
-
-  return new Response(body, { status: 200, headers });
+  return new Response(response.body ?? null, {
+    status: response.status ?? 200,
+    headers,
+  });
 }
 
 // ── Fetch handler ──────────────────────────────────────────────────────
@@ -285,7 +166,7 @@ self.addEventListener("fetch", (fetchEvent: FetchEvent) => {
   if (request.method !== "GET") return fetchEvent.respondWith(fetch(request));
   const url = new URL(fetchEvent.request.url);
 
-  let specialURL: URL | undefined;
+  let handoffURL: URL | undefined;
 
   if (
     url.hostname == self.location.hostname &&
@@ -293,8 +174,8 @@ self.addEventListener("fetch", (fetchEvent: FetchEvent) => {
     url.protocol == self.location.protocol
   ) {
     try {
-      specialURL = new URL(decodeURIComponent(url.pathname.slice(1)));
-      log(`received special request ${specialURL}`);
+      handoffURL = new URL(decodeURIComponent(url.pathname.slice(1)));
+      log(`received special request ${handoffURL}`);
     } catch {}
   }
 
@@ -304,41 +185,34 @@ self.addEventListener("fetch", (fetchEvent: FetchEvent) => {
       const match = await cache.match(request);
 
       try {
-        if (specialURL) {
+        if (handoffURL) {
           if (match) {
-            log(`serving ${specialURL} from cache ${cachename}`);
-            const headers = new Headers(match.headers);
-            headers.set("cross-origin-embedder-policy", "credentialless");
-            headers.set("cross-origin-resource-policy", "cross-origin");
-            return new Response(match.body, {
-              status: match.status,
-              headers,
-            });
+            log(`serving ${handoffURL} from cache ${cachename}`);
+            return withSpecialHeaders(match);
           }
 
-          const response = await Promise.race([
-            resolveAutomergeUrl(specialURL),
-            new Promise<never>((_, reject) =>
-              setTimeout(
-                () =>
-                  reject(
-                    new Error(`resolve timeout after ${RESOLVE_TIMEOUT_MS}ms`)
-                  ),
-                RESOLVE_TIMEOUT_MS
-              )
-            ),
-          ]);
+          log(`handing ${handoffURL} off to the automerge worker`);
+          const replyPromise = handoff(request, handoffURL);
+          fetchEvent.waitUntil(replyPromise.catch(() => {}));
+          const reply = await replyPromise;
 
-          if (response.status === 307) {
-            return response;
+          if (reply.type === "response") {
+            // errors, redirects and other things that shouldn't be cached
+            log(`serving handed-off response for ${handoffURL}`, reply);
+            return withSpecialHeaders(reply.response);
           }
 
-          if (cacheableStatuses.includes(response.status)) {
-            log(`caching ${specialURL}`);
-            await cache.put(request, response.clone());
+          // reply.type === "cached": the automerge worker has put the
+          // response in our cache
+          const cached = await cache.match(request);
+          if (!cached) {
+            return new Response(
+              `the automerge worker reported ${handoffURL} cached, but it has no match in ${cachename}`,
+              { status: 500 }
+            );
           }
-
-          return response;
+          log(`serving ${handoffURL} from cache ${cachename} after handoff`);
+          return withSpecialHeaders(cached);
         } else {
           const response = await fetch(request).catch(() => null);
           if (response) {
@@ -363,7 +237,8 @@ self.addEventListener("fetch", (fetchEvent: FetchEvent) => {
             ? `${error.message}\n\n${error.stack}`
             : String(error);
         console.error(
-          `service worker error resolving ${request.url}${specialURL ? ` (for: ${specialURL})` : ""}.\n${message}`
+          `service worker error resolving ${request.url}${handoffURL ? ` (for: ${handoffURL})` : ""}`,
+          error
         );
         if (match) return match;