@inkandswitch/patchwork-bootloader 0.4.2 → 0.4.3

package/dist/site.js

@@ -20,7 +20,7 @@ import { initKeyhiveWasm, initializeAutomergeRepoKeyhiveWithRepo, } from "@autom
 // @ts-ignore — initSync is a wasm-bindgen runtime helper not in the .d.ts
 import { initSync as initSubductionSync } from "@automerge/automerge-subduction/slim";
 import { MemorySigner } from "@automerge/automerge-subduction/slim";
-const siteName = typeof __SITE_NAME__ !== "undefined" ? __SITE_NAME__ : "tiny-patchwork";
+const siteName = typeof __SITE_NAME__ !== "undefined" ? __SITE_NAME__ : "patchwork.inkandswitch.com";
 const useKeyhiveSyncServer = typeof __KEYHIVE_SYNC_SERVER__ !== "undefined" && __KEYHIVE_SYNC_SERVER__;
 import { ModuleWatcher } from "@inkandswitch/patchwork-filesystem";
 import { importAutomergePackageViaWorker } from "./module-loader.js";
@@ -28,7 +28,7 @@ import { openDocument, registerPatchworkViewElement, } from "@inkandswitch/patch
 import { registerRepoProviderElement } from "@inkandswitch/patchwork-providers";
 import { getRegistry, registerPlugins, resolveAccountHandle, unregisterPlugins, } from "@inkandswitch/patchwork-plugins";
 import * as plugins from "@inkandswitch/patchwork-plugins";
-import setupServiceWorker, { lifecycleLoggingEnabled, } from "./setup.js";
+import setupServiceWorker, { lifecycleLoggingEnabled } from "./setup.js";
 import debug from "debug";
 const log = debug("patchwork:bootloader:site");
 // Legacy big-patchwork hash shape: `<slug>--<documentId>[?…]`. The slug can
@@ -37,7 +37,7 @@ const log = debug("patchwork:bootloader:site");
 // characters ahead of it rather than a strict slug charset.
 const BIG_PATCHWORK_HASH_REGEX = /^(?<title>[^=&?/#]*)--(?<docId>[1-9A-HJ-NP-Za-km-z]+)/;
 const [automergeWasm, subductionWasm] = await Promise.all([
-    fetch("/automerge.wasm?main").then((r) => r.bytes()),
+    fetch("/automerge.wasm").then((r) => r.bytes()),
     fetch("/subduction.wasm").then((r) => r.bytes()),
 ]);
 /**
@@ -64,6 +64,9 @@ export async function bootPatchworkSite(config) {
     let hive;
     let repo;
     let tabSignerIdentity;
+    // Called with a fresh port when the automerge worker dies and is recreated
+    // (see recoverAutomergeWorker in setup.ts); assigned once the repo exists.
+    let onWorkerPortRenewed;
     // If a Repo is already on `window` — an embedding context provided one before
     // this entry ran — reuse it and its keyhive instead of standing up a fresh
     // realm-local Repo, so we share the same documents and sync/keyhive context.
@@ -76,14 +79,34 @@ export async function bootPatchworkSite(config) {
     else {
         // Get the initial automerge-worker port via subscribeToRepoChannel,
         // then pass it to keyhive init which wraps it in its own network adapter.
-        let resolvePort;
-        const portPromise = new Promise((r) => {
-            resolvePort = r;
+        // The listener is called again with a fresh port if the worker is ever
+        // recreated after dying.
+        let resolveFirstPort;
+        const firstPortPromise = new Promise((r) => {
+            resolveFirstPort = r;
         });
+        let seenFirstPort = false;
         log("subscribing to repo channel");
-        await sw.subscribeToRepoChannel(resolvePort);
+        // Deliberately not awaited: subscribeToRepoChannel resolves only after
+        // the boot channel's port-ready handshake, which can take its full 30s
+        // timeout against a stranded worker connection. Boot should block on the
+        // first *delivered* port instead — if the boot channel stalls, worker
+        // recovery hands the listener a good port long before that timeout.
+        void sw.subscribeToRepoChannel((port) => {
+            if (!seenFirstPort) {
+                seenFirstPort = true;
+                resolveFirstPort(port);
+            }
+            else if (onWorkerPortRenewed) {
+                onWorkerPortRenewed(port);
+            }
+            else {
+                console.warn("automerge worker port renewed before the repo existed; dropping it");
+            }
+        });
+        const workerPort = await firstPortPromise;
         log("repo channel subscribed");
-        const workerPort = await portPromise;
+        let workerAdapter = new MessageChannelNetworkAdapter(workerPort);
         if (config.keyhive) {
             log("setting up keyhive");
             initKeyhiveWasm();
@@ -91,7 +114,7 @@ export async function bootPatchworkSite(config) {
                 createRepo: (config) => new Repo(config),
                 storage: new IndexedDBWorkerStorageAdapter(`${siteName}-keyhive`),
                 peerIdSuffix: siteName + Math.random().toString(36).slice(2),
-                networkAdapter: new MessageChannelNetworkAdapter(workerPort),
+                networkAdapter: workerAdapter,
                 automaticArchiveIngestion: true,
                 cachingMode: "periodic",
                 onlyShareWithHardcodedServerPeerId: false,
@@ -113,7 +136,7 @@ export async function bootPatchworkSite(config) {
             // id never goes on the wire.
             const tabSigner = new MemorySigner();
             repo = new Repo({
-                network: [new MessageChannelNetworkAdapter(workerPort)],
+                network: [workerAdapter],
                 storage: new IndexedDBWorkerStorageAdapter(),
                 signer: tabSigner,
                 async sharePolicy(peerId) {
@@ -129,6 +152,37 @@ export async function bootPatchworkSite(config) {
             console.log("[patchwork] tab subduction identity:", tabSignerIdentity);
             log("repo created");
         }
+        // The worker was recreated with cold state: wire the repo onto the fresh
+        // port and drop the adapter stranded on the dead one. `repo`/`hive` are
+        // settled by the time this can fire (recovery needs a missed heartbeat).
+        const bootHive = hive;
+        onWorkerPortRenewed = (port) => {
+            const fresh = new MessageChannelNetworkAdapter(port);
+            // Mirror the boot wiring: a keyhive repo talks to the worker through a
+            // keyhive adapter wrapped around the message channel (same parameters
+            // the worker uses for its side of the pair).
+            const registered = bootHive
+                ? bootHive.createKeyhiveNetworkAdapter(fresh, false, false, 2000)
+                : fresh;
+            repo.networkSubsystem.addNetworkAdapter(registered);
+            for (const adapter of [...repo.networkSubsystem.adapters]) {
+                if (adapter === registered)
+                    continue;
+                // The keyhive wrapper keeps the wrapped adapter on `.networkAdapter`.
+                const base = adapter.networkAdapter ?? adapter;
+                if (base !== workerAdapter)
+                    continue;
+                try {
+                    repo.networkSubsystem.removeNetworkAdapter(adapter);
+                }
+                catch (err) {
+                    console.error("failed to remove stale worker network adapter", err);
+                }
+            }
+            workerAdapter = fresh;
+            console.warn(`[lifecycle] ${new Date().toISOString()} repo re-wired to the ` +
+                `recreated automerge worker`);
+        };
     }
     log("popping repo on window");
     window.repo = repo;
@@ -272,8 +326,8 @@ function installLifecycleLogging() {
     document.addEventListener("visibilitychange", () => note(`visibilitychange → ${document.visibilityState}`), opts);
     document.addEventListener("freeze", () => note("freeze (tab suspended)"), opts);
     document.addEventListener("resume", () => note("resume (tab unsuspended)"), opts);
-    window.addEventListener("pageshow", e => note("pageshow", { persisted: e.persisted }), opts);
-    window.addEventListener("pagehide", e => note("pagehide", { persisted: e.persisted }), opts);
+    window.addEventListener("pageshow", (e) => note("pageshow", { persisted: e.persisted }), opts);
+    window.addEventListener("pagehide", (e) => note("pagehide", { persisted: e.persisted }), opts);
     window.addEventListener("online", () => note("online"), opts);
     window.addEventListener("offline", () => note("offline"), opts);
     note(`lifecycle logging installed (visibilityState=${document.visibilityState}, hasFocus=${document.hasFocus()})`);

package/dist/types.d.ts

@@ -133,7 +133,24 @@ export interface HandoffResponseMessage {
     type: "response";
     response: HandoffResponse;
 }
-export type HandoffReplyMessage = HandoffCachedMessage | HandoffResponseMessage;
+/**
+ * Automerge worker → service worker: fail the request as a network error
+ * rather than serving any response at all.
+ *
+ * "Heads haven't arrived yet" is not a 404 — the document may well exist, so
+ * a status implying it doesn't is a lie any HTTP cache is entitled to store.
+ * A network error is the honest answer and isn't storable as a response.
+ *
+ * This does *not* help with `import()`: the ES module map memoizes failed
+ * fetches, network errors included, so a retry needs a distinct URL either
+ * way (see `importModule` in patchwork-filesystem).
+ */
+export interface HandoffAbortMessage {
+    id: string;
+    type: "abort";
+    reason: string;
+}
+export type HandoffReplyMessage = HandoffCachedMessage | HandoffResponseMessage | HandoffAbortMessage;
 /**
  * Automerge worker → world: broadcast once on startup so the service worker
  * can re-send any handoff requests that raced the worker's boot.

package/dist/vite/importmap-plugin.js

@@ -1,5 +1,6 @@
 import { readFileSync } from "node:fs";
 import { createRequire } from "node:module";
+import { fileURLToPath } from "node:url";
 const require = createRequire(import.meta.url);
 /**
  * these dependencies will be built into the outdir,
@@ -7,6 +8,29 @@ const require = createRequire(import.meta.url);
  */
 import externals from "../externals.js";
 export const builtins = externals.reduce((builtins, name) => ((builtins[name] = `/packages/${name}.js`), builtins), {});
+/**
+ * pretend the import came from inside this package, so node_modules resolution
+ * walks up from *our* directory and finds our copy of each external. that's why
+ * a consuming site never has to install them or agree with us about versions.
+ */
+const self = fileURLToPath(import.meta.url);
+/**
+ * resolve an external from our node_modules rather than the site's.
+ *
+ * this goes through rollup's resolver rather than import.meta.resolve or
+ * require.resolve because those apply node's conditions: subduction (and
+ * others) would hand us `dist/esm/node.js`, which imports node:path and blows
+ * up at bundle time. rollup applies the browser conditions vite configured.
+ */
+async function resolveExternal(name) {
+    const resolved = await this.resolve(name, self, { skipSelf: true });
+    if (!resolved) {
+        throw new Error(`@patchwork/vite: couldn't resolve the external "${name}" from ` +
+            `@inkandswitch/patchwork-bootloader. it should be one of the ` +
+            `bootloader's own dependencies.`);
+    }
+    return resolved.id;
+}
 /**
  * merge the importmap option with our builtins
  */
@@ -26,7 +50,7 @@ export function importmap(options) {
                 this.emitFile({
                     type: "chunk",
                     fileName: fileName.slice(1),
-                    id,
+                    id: await resolveExternal.call(this, id),
                     preserveSignature: "strict",
                 });
             }
@@ -51,8 +75,14 @@ export function importmap(options) {
                 source: readFileSync(subdWasmPath),
             });
         },
-        resolveId(id) {
-            if (id in importmap.imports && !(id in builtins)) {
+        async resolveId(id) {
+            if (id in builtins) {
+                // point the site's own imports at the same copy we emit as a chunk,
+                // otherwise rollup bundles a second one out of the site's node_modules
+                // and you end up with two automerges racing to init the same wasm
+                return resolveExternal.call(this, id);
+            }
+            if (id in importmap.imports) {
                 return { id: importmap.imports[id], external: true };
             }
         },

package/package.json

@@ -1,11 +1,10 @@
 {
   "name": "@inkandswitch/patchwork-bootloader",
-  "version": "0.4.2",
+  "version": "0.4.3",
   "author": "chee",
   "type": "module",
   "license": "MIT",
   "devDependencies": {
-    "@automerge/automerge-repo-keyhive": "0.3.0-alpha.sub.8b",
     "esbuild": "^0.23.1",
     "rollup": "^4.61.1"
   },
@@ -46,27 +45,47 @@
   "dependencies": {
     "@automerge/automerge": "3.3.2",
     "@automerge/automerge-repo": "2.6.0-subduction.46",
-    "@automerge/automerge-repo-network-messagechannel": "2.6.0-subduction.45",
-    "@automerge/automerge-repo-network-websocket": "2.6.0-subduction.45",
-    "@automerge/automerge-repo-storage-indexeddb": "2.6.0-subduction.45",
+    "@automerge/automerge-repo-keyhive": "0.3.0-alpha.sub.8b",
+    "@automerge/automerge-repo-network-messagechannel": "2.6.0-subduction.46",
+    "@automerge/automerge-repo-network-websocket": "2.6.0-subduction.46",
+    "@automerge/automerge-repo-storage-indexeddb": "2.6.0-subduction.46",
     "@automerge/automerge-subduction": "0.16.0",
-    "@automerge/vanillajs": "2.6.0-subduction.45",
+    "@automerge/vanillajs": "2.6.0-subduction.46",
+    "@codemirror/commands": "^6.10.4",
+    "@codemirror/language": "^6.12.4",
+    "@codemirror/state": "^6.7.1",
+    "@codemirror/view": "^6.43.6",
     "@keyhive/keyhive": "0.1.0-alpha.5",
     "@types/debug": "^4.1.13",
     "debug": "^4.4.3",
     "resolve.exports": "^2.0.3",
     "service-worker-types": "npm:@types/serviceworker@^0.0.153",
+    "solid-js": "^1.9.13",
     "tinyargs": "^0.1.4",
     "@inkandswitch/patchwork-elements": "^4.0.0",
-    "@inkandswitch/patchwork-filesystem": "^0.2.0",
-    "@inkandswitch/patchwork-plugins": "^1.0.0",
-    "@inkandswitch/patchwork-providers": "^0.4.0"
+    "@inkandswitch/patchwork-filesystem": "^0.2.1",
+    "@inkandswitch/patchwork-plugins": "^1.0.1",
+    "@inkandswitch/patchwork-providers": "^0.4.1"
   },
   "peerDependencies": {
     "@automerge/automerge": "3.3.2",
     "@automerge/automerge-repo": "2.6.0-subduction.46",
     "@automerge/automerge-repo-keyhive": "0.3.0-alpha.sub.8b",
-    "@automerge/vanillajs": "2.6.0-subduction.45"
+    "@automerge/vanillajs": "2.6.0-subduction.46"
+  },
+  "peerDependenciesMeta": {
+    "@automerge/automerge": {
+      "optional": true
+    },
+    "@automerge/automerge-repo": {
+      "optional": true
+    },
+    "@automerge/automerge-repo-keyhive": {
+      "optional": true
+    },
+    "@automerge/vanillajs": {
+      "optional": true
+    }
   },
   "scripts": {
     "build": "tsc",

package/src/automerge-worker.ts

@@ -49,6 +49,7 @@ import {
   type HandoffCachedMessage,
   type HandoffOnlineMessage,
   type HandoffRequest,
+  type HandoffAbortMessage,
   type HandoffRequestMessage,
   type HandoffResponseMessage,
   type SyncStateBroadcast,
@@ -219,11 +220,9 @@ setInterval(() => {
   watchdogLast = now;
   if (gap > WATCHDOG_TICK_MS * WATCHDOG_GAP_FACTOR) {
     console.warn(
-      `[lifecycle] worker resumed after ~${Math.round(gap / 1000)}s gap ` +
-        `(timer expected every ${WATCHDOG_TICK_MS / 1000}s) — likely ` +
-        `suspended/frozen/throttled; WebSocket keepalive pongs were not sent ` +
-        `during this window, so the sync server may have reaped us. at ` +
-        `${new Date(now).toISOString()}`
+      `[lifecycle] ${new Date(now).toISOString()} watchdog timer gap ` +
+        `~${Math.round(gap / 1000)}s (expected every ` +
+        `${WATCHDOG_TICK_MS / 1000}s)`
     );
   }
 }, WATCHDOG_TICK_MS);
@@ -283,9 +282,7 @@ function getSubductionEndpoints(): (WorkerWebSocketEndpoint | string)[] {
         : [
             new WorkerWebSocketEndpoint(SUBDUCTION_SYNC_URL, {
               worker: subductionPortProvider.source,
-              ...(WS_WINDOW_FRAMES
-                ? { windowFrames: WS_WINDOW_FRAMES }
-                : {}),
+              ...(WS_WINDOW_FRAMES ? { windowFrames: WS_WINDOW_FRAMES } : {}),
             }),
           ];
   }
@@ -339,7 +336,7 @@ async function connectClassicSyncNetwork(server: string): Promise<void> {
 }
 
 const siteName =
-  typeof __SITE_NAME__ !== "undefined" ? __SITE_NAME__ : "tiny-patchwork";
+  typeof __SITE_NAME__ !== "undefined" ? __SITE_NAME__ : "patchwork.inkandswitch.com";
 
 const cacheableStatuses = [200, 203, 204];
 
@@ -365,10 +362,9 @@ function getRepoHive() {
   if (!repoHivePromise) {
     repoHivePromise = (async () => {
       log("getRepo: starting");
-
       log("fetching wasm modules");
       const [amWasmBuf, sdnWasmBuf] = await Promise.all([
-        fetch("/automerge.wasm?worker").then((r) => r.arrayBuffer()),
+        fetch("/automerge.wasm").then((r) => r.arrayBuffer()),
         fetch("/subduction.wasm").then((r) => r.arrayBuffer()),
       ]);
       initSubductionSync(new Uint8Array(sdnWasmBuf));
@@ -646,8 +642,9 @@ function setupSyncStateBroadcast(
   >();
   // Inspectable from the SharedWorker console as `self.patchworkResync` to see
   // whether/how often a doc is being re-synced and against which server heads.
-  const resyncDiag: { fires: number; byDoc: Record<string, unknown> } =
-    ((self as any).patchworkResync ??= { fires: 0, byDoc: {} });
+  const resyncDiag: { fires: number; byDoc: Record<string, unknown> } = ((
+    self as any
+  ).patchworkResync ??= { fires: 0, byDoc: {} });
   const reviewResync = (documentId: string) => {
     if (!identity || !connected) {
       resyncState.delete(documentId);
@@ -732,8 +729,12 @@ function setupSyncStateBroadcast(
       byStorage.set(storageId, { heads: headsCopy, timestamp });
       postHeads(documentId, storageId, headsCopy, timestamp);
       // A doc the server reported is one we hold — make sure we're advertising
-      // our own heads for it too.
-      scanOwnHandles();
+      // our own heads for it too. Track just this doc: a full scanOwnHandles()
+      // per event is O(all handles) and goes quadratic during sync bursts,
+      // starving the thread that's doing the syncing. The 3s tick still covers
+      // general discovery.
+      const handle = repo.handles[documentId as DocumentId];
+      if (handle) trackOwnHandle(handle as never);
       reviewResync(documentId);
     }
   );
@@ -870,6 +871,16 @@ function handleControlMessage(
   connection: Connection
 ) {
   const data = event.data;
+  // Tally of control messages received, readable from the SharedWorker console
+  // as `self.patchworkControl`. Not using log(): that's gated on `debugging`,
+  // which is only enabled by a {type:"debug"} message arriving over this same
+  // channel.
+  const stats = ((self as any).patchworkControl ??= {
+    connects: 0,
+    byType: {} as Record<string, number>,
+  });
+  stats.byType[String(data?.type ?? "<untyped>")] =
+    (stats.byType[String(data?.type ?? "<untyped>")] ?? 0) + 1;
   if (data?.type === "port") {
     log("received repo channel");
     const [repoPort] = event.ports;
@@ -930,6 +941,7 @@ function handleControlMessage(
 self.addEventListener("connect", (event) => {
   const controlPort = (event as MessageEvent).ports[0];
   const connection: Connection = { channels: new Set() };
+  ((self as any).patchworkControl ??= { connects: 0, byType: {} }).connects++;
 
   controlPort.addEventListener("message", (messageEvent) => {
     handleControlMessage(messageEvent as MessageEvent, controlPort, connection);
@@ -1010,6 +1022,13 @@ function waitForHeads(
   });
 }
 
+/**
+ * Thrown instead of returning a Response when the request should fail as a
+ * network error rather than resolve to something the caller can memoize.
+ * See {@link HandoffAbortMessage}.
+ */
+class AbortHandoff extends Error {}
+
 async function resolveAutomergeUrl(automergeURL: URL): Promise<Response> {
   const { repo } = await getRepoHive();
   const href = automergeURL.href;
@@ -1043,7 +1062,12 @@ async function resolveAutomergeUrl(automergeURL: URL): Promise<Response> {
   // The heads may not have synced to us yet — give them the rest of the
   // resolve window to arrive before giving up.
   if (!(await waitForHeads(baseHandle, hexHeads ?? [], signal))) {
-    return new Response("heads not found", { status: 404 });
+    // Not a 404: the heads may still be on their way, and this exact URL will
+    // be requested again once they land. Fail it as a network error so the
+    // caller doesn't memoize the miss.
+    throw new AbortHandoff(
+      `heads not found for ${maybeAutomergeUrl} within ${RESOLVE_TIMEOUT_MS}ms`
+    );
   }
   const rootHandle = baseHandle.view(heads);
 
@@ -1137,6 +1161,14 @@ async function handleHandoffRequest(message: HandoffRequestMessage) {
       ),
     ]);
   } catch (error) {
+    if (error instanceof AbortHandoff) {
+      handoffChannel.postMessage({
+        id,
+        type: "abort",
+        reason: error.message,
+      } satisfies HandoffAbortMessage);
+      return;
+    }
     const body =
       error instanceof Error
         ? `${error.message}\n\n${error.stack}`

package/src/service-worker.ts

@@ -184,6 +184,9 @@ handoffChannel.addEventListener("message", (event) => {
   }
 });
 
+/** Signals that respondWith should reject; see {@link HandoffAbortMessage}. */
+class HandoffAborted extends Error {}
+
 function handoff(
   request: Request,
   handoffURL: URL
@@ -259,10 +262,34 @@ async function cachePage(
   response: Response
 ) {
   const indexRequest = indexRequestFor(request);
-  if (indexRequest) await cache.put(indexRequest, response.clone());
   const rootRequest = rootRequestFor(request);
-  if (rootRequest) await cache.put(rootRequest, response.clone());
-  await cache.put(request, response);
+  await Promise.all([
+    indexRequest && cache.put(indexRequest, response.clone()),
+    rootRequest && cache.put(rootRequest, response.clone()),
+    cache.put(request, response),
+  ]);
+}
+
+// Write to the cache without blocking the response: cache.put only resolves
+// once the whole body has been consumed and persisted, so awaiting it before
+// returning would turn time-to-first-byte into time-to-last-byte-plus-disk
+// for every proxied asset. waitUntil keeps the worker alive for the write.
+function cacheInBackground(
+  fetchEvent: FetchEvent,
+  cache: Cache,
+  request: Request,
+  response: Response
+) {
+  fetchEvent.waitUntil(
+    (request.mode === "navigate" || request.destination === "document"
+      ? cachePage(cache, request, response)
+      : cache.put(request, response)
+    ).catch((error) => {
+      // Always loud (not gated on debugging): a QuotaExceededError here is
+      // the first sign the origin is under storage pressure.
+      console.warn(`error caching ${request.url} in ${cachename}`, error);
+    })
+  );
 }
 
 // ── Fetch handler ──────────────────────────────────────────────────────
@@ -270,7 +297,9 @@ async function cachePage(
 self.addEventListener("fetch", (fetchEvent: FetchEvent) => {
   log("fetch event", fetchEvent.request.url);
   const request = fetchEvent.request;
-  if (request.method !== "GET") return fetchEvent.respondWith(fetch(request));
+  // Not calling respondWith at all lets the browser handle non-GETs natively
+  // instead of proxying their bodies through this worker.
+  if (request.method !== "GET") return;
   const url = new URL(fetchEvent.request.url);
 
   let handoffURL: URL | undefined;
@@ -303,6 +332,14 @@ self.addEventListener("fetch", (fetchEvent: FetchEvent) => {
           fetchEvent.waitUntil(replyPromise.catch(() => {}));
           const reply = await replyPromise;
 
+          if (reply.type === "abort") {
+            // Rejecting respondWith gives the caller a network error rather
+            // than a response it can memoize. Rethrown past the catch below,
+            // which would otherwise turn this into a 556.
+            log(`aborting ${handoffURL}: ${reply.reason}`);
+            throw new HandoffAborted(reply.reason);
+          }
+
           if (reply.type === "response") {
             // errors, redirects and other things that shouldn't be cached
             log(`serving handed-off response for ${handoffURL}`, reply);
@@ -341,15 +378,7 @@ self.addEventListener("fetch", (fetchEvent: FetchEvent) => {
                 cacheableStatuses.includes(response.status)) &&
               /^https?:/.test(request.url)
             ) {
-              const cachedResponse = response.clone();
-              await (
-                request.mode === "navigate" ||
-                request.destination === "document"
-                  ? cachePage(cache, request, cachedResponse)
-                  : cache.put(request, cachedResponse)
-              ).catch((error) => {
-                log(`error caching ${request.url} in ${cachename}`, error);
-              });
+              cacheInBackground(fetchEvent, cache, request, response.clone());
             } else {
               log(
                 `skipping uncacheable response code from cache: ${response.status} for ${request.url}`
@@ -366,6 +395,8 @@ self.addEventListener("fetch", (fetchEvent: FetchEvent) => {
           );
         }
       } catch (error) {
+        // Deliberate: fail the request as a network error, no response.
+        if (error instanceof HandoffAborted) throw error;
         const message =
           error instanceof Error
             ? `${error.message}\n\n${error.stack}`