@inkandswitch/patchwork-bootloader 0.2.8 → 0.3.1

package/src/automerge-worker.ts

@@ -30,11 +30,11 @@ import {
 import { resolvePath } from "@inkandswitch/patchwork-filesystem";
 
 // Small adapters — bundled directly into the worker
-import { IndexedDBStorageAdapter } from "@automerge/automerge-repo-storage-indexeddb";
+import { IndexedDBWorkerStorageAdapter } from "@automerge/automerge-repo-storage-indexeddb/IndexedDBWorkerStorageAdapter";
 import { MessageChannelNetworkAdapter } from "@automerge/automerge-repo-network-messagechannel";
-import { WebSocketClientAdapter } from "@automerge/automerge-repo-network-websocket";
+import { WebSocketWorkerClientAdapter } from "@automerge/automerge-repo-network-websocket";
 import {
-  initializeAutomergeRepoKeyhiveRust,
+  initializeAutomergeRepoKeyhiveRustWithRepo,
   initKeyhiveWasm,
   type AutomergeRepoKeyhiveRust,
 } from "@automerge/automerge-repo-keyhive";
@@ -54,6 +54,103 @@ declare const __KEYHIVE_SYNC_SERVER__: boolean;
 
 let debugging = false;
 
+// Per-boot identity so a tab can detect a worker *restart*: a fresh instance
+// means a new repo peerId + cold in-memory state, so the tab's docs must be
+// re-subscribed. Sent in `hello` (on connect) and every `pong`.
+const WORKER_INSTANCE_ID = Math.random().toString(36).slice(2);
+const WORKER_BOOT_TIME = Date.now();
+
+// ── Forward console output + uncaught errors to the main thread ─────────
+// The SharedWorker has its own console that's a pain to find (chrome://inspect
+// → shared workers). Patch console.* and the global error handlers to also
+// post back over every connected tab's control port, tagged [automerge-worker].
+
+const controlPorts = new Set<MessagePort>();
+// Logs emitted before any tab has connected (e.g. during wasm boot) would
+// otherwise be lost — buffer a bounded number and flush on first connect.
+const preConnectBuffer: Array<{ level: string; args: string[] }> = [];
+const MAX_BUFFER = 200;
+
+function serializeArg(arg: any): string {
+  if (typeof arg === "string") return arg;
+  if (arg instanceof Error) return arg.stack || `${arg.name}: ${arg.message}`;
+  try {
+    return JSON.stringify(arg);
+  } catch {
+    return String(arg);
+  }
+}
+
+function forwardToMainThread(level: string, rawArgs: any[]) {
+  const args = rawArgs.map(serializeArg);
+  if (!controlPorts.size) {
+    if (preConnectBuffer.length < MAX_BUFFER) {
+      preConnectBuffer.push({ level, args });
+    }
+    return;
+  }
+  for (const port of controlPorts) {
+    try {
+      port.postMessage({ type: "console", level, args });
+    } catch {
+      // Port may be closing — ignore.
+    }
+  }
+}
+
+for (const level of ["log", "info", "warn", "error", "debug"] as const) {
+  const original = console[level].bind(console);
+  console[level] = (...args: any[]) => {
+    original(...args);
+    forwardToMainThread(level, args);
+  };
+}
+
+self.addEventListener("error", (event) => {
+  const e = event as ErrorEvent;
+  forwardToMainThread("error", [
+    `uncaught error: ${e.message}`,
+    e.error instanceof Error ? e.error.stack : undefined,
+  ]);
+});
+
+self.addEventListener("unhandledrejection", (event) => {
+  const reason = (event as PromiseRejectionEvent).reason;
+  forwardToMainThread("error", [
+    "unhandled rejection:",
+    reason instanceof Error ? reason.stack || reason.message : reason,
+  ]);
+});
+
+// Boot marker, buffered until the first tab connects. A new instance id means
+// the worker restarted (fresh peerId + cold state).
+console.warn(
+  `[lifecycle] ${new Date(WORKER_BOOT_TIME).toISOString()} automerge ` +
+    `SharedWorker started (instance ${WORKER_INSTANCE_ID})`
+);
+
+// ── Suspension watchdog ─────────────────────────────────────────────────
+// A SharedWorker gets no lifecycle events, so infer freeze/suspend from timer
+// drift. A large gap means keepalive pongs stalled and the server may have
+// reaped us.
+const WATCHDOG_TICK_MS = 5_000;
+const WATCHDOG_GAP_FACTOR = 2;
+let watchdogLast = Date.now();
+setInterval(() => {
+  const now = Date.now();
+  const gap = now - watchdogLast;
+  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()}`
+    );
+  }
+}, WATCHDOG_TICK_MS);
+
 // Sync server selection. Sub is the default. Build with KEYHIVE_SYNC_SERVER=true
 // to target keyhive.sync.automerge.org.
 const useKeyhiveSyncServer =
@@ -68,12 +165,6 @@ if (useKeyhiveSyncServer) {
   };
 }
 
-// keyhive.sync.automerge.org's keyhive identity (issuer d7f41e6f…).
-const KEYHIVE_SYNC_SERVER_PEER_ID =
-  "1/Qebw9O69oH8T/ejYMhFup0tNBh69I3ytGqsmIl358=";
-const KEYHIVE_SYNC_SERVER_CONTACT_CARD_JSON =
-  '{"Rotate":{"payload":{"old":[73,163,230,244,111,233,153,119,133,211,134,237,111,36,52,131,22,50,54,144,150,45,227,235,128,36,33,217,190,198,55,75],"new":[109,115,204,144,178,114,182,238,113,124,4,139,249,76,220,44,128,104,194,68,187,184,82,241,94,145,104,198,159,122,186,43]},"issuer":[215,244,30,111,15,78,235,218,7,241,63,222,141,131,33,22,234,116,180,208,97,235,210,55,202,209,170,178,98,37,223,159],"signature":[178,64,85,76,51,199,196,151,129,14,191,53,127,191,34,223,97,238,95,109,118,179,152,17,205,188,204,177,116,166,147,231,192,201,48,137,19,214,180,45,108,104,34,8,14,63,115,139,215,142,4,179,233,89,150,218,174,168,107,23,8,109,228,6]}}';
-
 const SUBDUCTION_ENDPOINTS = [
   useKeyhiveSyncServer
     ? "wss://keyhive.sync.automerge.org"
@@ -84,7 +175,7 @@ const RESOLVE_TIMEOUT_MS = 30_000;
 const DEFAULT_CLASSIC_SYNC_SERVER = "wss://sync3.automerge.org";
 
 let classicSyncServer = DEFAULT_CLASSIC_SYNC_SERVER;
-let classicSyncAdapter: WebSocketClientAdapter | null = null;
+let classicSyncAdapter: WebSocketWorkerClientAdapter | null = null;
 let classicSyncConnectPromise: Promise<void> | null = null;
 
 async function connectClassicSyncNetwork(server: string): Promise<void> {
@@ -103,7 +194,7 @@ async function connectClassicSyncNetwork(server: string): Promise<void> {
   classicSyncConnectPromise = (async () => {
     const { repo } = await getRepoHive();
     if (!classicSyncAdapter) {
-      classicSyncAdapter = new WebSocketClientAdapter(url);
+      classicSyncAdapter = new WebSocketWorkerClientAdapter(url);
       repo.networkSubsystem.addNetworkAdapter(classicSyncAdapter);
     }
     await classicSyncAdapter.whenReady();
@@ -159,7 +250,7 @@ function getRepoHive() {
         const signer = await WebCryptoSigner.setup();
 
         const repo = new Repo({
-          storage: new IndexedDBStorageAdapter(),
+          storage: new IndexedDBWorkerStorageAdapter(),
           signer,
           peerId: ("automerge-worker-" +
             Math.random()
@@ -183,48 +274,26 @@ function getRepoHive() {
       }
 
       initKeyhiveWasm();
-      const keyhiveStorage = new IndexedDBStorageAdapter(`${siteName}-keyhive`);
-
-      // Keyhive bootstrap needs to run before Repo creation but
-      // the adapter needs the subduction instance from the Repo.
-      // A deferred promise breaks the cycle.
-      let resolveRepoSubduction!: (s: any) => void;
-      const repoSubductionPromise = new Promise((resolve) => {
-        resolveRepoSubduction = resolve;
-      });
 
-      // We use the Rust variant of Keyhive initialization to talk
-      // to the Rust keyhive-enabled subduction sync server.
-      const hive = await initializeAutomergeRepoKeyhiveRust({
-        storage: keyhiveStorage,
+      // ARK variant for talking to the keyhive-enabled subduction sync server.
+      const { hive, repo } = await initializeAutomergeRepoKeyhiveRustWithRepo({
+        createRepo: (config) => new Repo(config),
+        storage: new IndexedDBWorkerStorageAdapter(`${siteName}-keyhive`),
         peerIdSuffix:
           `${siteName}-worker` + Math.random().toString(36).slice(2),
-        subduction: repoSubductionPromise as any,
         automaticArchiveIngestion: true,
         cachingMode: "periodic",
-        ...(useKeyhiveSyncServer
-          ? {
-              serverPeerId: KEYHIVE_SYNC_SERVER_PEER_ID as any,
-              serverContactCardJson: KEYHIVE_SYNC_SERVER_CONTACT_CARD_JSON,
-            }
-          : {}),
-      });
-
-      const signer = await hive.constructSubductionSigner();
-
-      const repo = new Repo({
-        storage: new IndexedDBStorageAdapter(),
-        signer,
-        subductionWebsocketEndpoints: SUBDUCTION_ENDPOINTS,
-        peerId: hive.peerId,
-        enableRemoteHeadsGossiping: true,
-        idFactory: hive.idFactory,
+        // ARK selects the relay via `syncServer` ("keyhive" | "subduction"),
+        // which pairs the contact card with the matching peer id. Omitting it
+        // defaults to "subduction".
+        ...(useKeyhiveSyncServer ? { syncServer: "keyhive" as const } : {}),
+        repo: {
+          storage: new IndexedDBWorkerStorageAdapter(),
+          subductionWebsocketEndpoints: SUBDUCTION_ENDPOINTS,
+          enableRemoteHeadsGossiping: true,
+        },
       });
 
-      repo.subduction.then(resolveRepoSubduction);
-
-      hive.linkRepo(repo);
-
       (self as any).repo = repo;
       (self as any).hive = hive;
       log("repo constructed, waiting for network subsystem");
@@ -336,6 +405,7 @@ async function connectPort(port: MessagePort, connection: Connection) {
   });
 
   (keyhiveNetworkAdapter as any).on("ingest-remote", () => {
+    hive.notifySameAgentKeyhiveChange();
     (hive.networkAdapter as any).syncKeyhive?.();
     repo.shareConfigChanged();
   });
@@ -389,6 +459,13 @@ function handleControlMessage(
         });
         replyPort?.close();
       });
+  } else if (data?.type === "ping") {
+    // Heartbeat: reply so the tab can detect our death or restart.
+    controlPort.postMessage({
+      type: "pong",
+      id: data.id,
+      instanceId: WORKER_INSTANCE_ID,
+    });
   }
 }
 
@@ -403,10 +480,32 @@ self.addEventListener("connect", (event) => {
   // Fires when the owning page is destroyed. Browsers without the close
   // event fall back to the adapters' lazy useWeakRef cleanup.
   controlPort.addEventListener("close", () => {
+    controlPorts.delete(controlPort);
     void dropConnection(connection);
   });
 
   controlPort.start();
+
+  // Greet the tab with our per-boot instance id so it can detect a restart
+  // (a different id than last seen) even if no port "close" fired.
+  controlPort.postMessage({
+    type: "hello",
+    instanceId: WORKER_INSTANCE_ID,
+    bootTime: WORKER_BOOT_TIME,
+  });
+
+  // Start forwarding console output to this tab, and flush anything buffered
+  // while no tab was connected (e.g. boot-time logs) to the first arrival.
+  controlPorts.add(controlPort);
+  if (preConnectBuffer.length) {
+    for (const { level, args } of preConnectBuffer.splice(0)) {
+      try {
+        controlPort.postMessage({ type: "console", level, args });
+      } catch {
+        // Port may already be gone — ignore.
+      }
+    }
+  }
 });
 
 // ── Automerge URL resolution ───────────────────────────────────────────
@@ -582,7 +681,7 @@ async function handleHandoffRequest(message: HandoffRequestMessage) {
       id,
       type: "response",
       response: {
-        status: 500,
+        status: 557,
         body,
         headers: { "content-type": "text/plain" },
       },
@@ -628,7 +727,7 @@ async function handleHandoffRequest(message: HandoffRequestMessage) {
       id,
       type: "response",
       response: {
-        status: 500,
+        status: 558,
         body: String(error),
         headers: { "content-type": "text/plain" },
       },

package/src/externals.ts

@@ -7,10 +7,9 @@ const externals = [
   "@automerge/automerge-repo",
   "@automerge/automerge-repo/slim",
   "@automerge/automerge-repo-network-messagechannel",
+  "@automerge/automerge-repo-network-websocket",
   "@automerge/automerge-repo-storage-indexeddb",
   "@automerge/automerge-repo-keyhive",
-  "@automerge/automerge-repo-network-messagechannel",
-  "@automerge/automerge-repo-storage-indexeddb",
   "@automerge/automerge-subduction",
   "@automerge/automerge-subduction/slim",
   "@keyhive/keyhive",
@@ -19,6 +18,7 @@ const externals = [
   "@inkandswitch/patchwork-elements",
   "@inkandswitch/patchwork-filesystem",
   "@inkandswitch/patchwork-plugins",
+  "@inkandswitch/patchwork-providers",
 
   // sad
   "@codemirror/state",

package/src/module-loader-worker.ts

@@ -0,0 +1,68 @@
+// Dedicated module worker for plugin-descriptor discovery.
+//
+// A module-settings doc lists Automerge folder-doc packages. To register the
+// plugins a package provides we only need their *descriptions* (id, type,
+// name, icon…), not their implementations. This worker imports a package's
+// entry point off the main thread purely to read its exported `plugins` array,
+// strips the non-cloneable `load()` / `import` machinery, and posts the plain
+// descriptors back. The main thread re-imports the package (at the same heads)
+// only when a plugin is actually loaded — see `importPluginFromFolderDocUrl`.
+//
+// Created with type:"module"; its dynamic `import()` of `/<automergeUrl>/…`
+// entry points is served by the service worker that controls this worker.
+
+import { importModuleFromFolderDocUrl } from "@inkandswitch/patchwork-filesystem";
+import type { AutomergeUrl } from "@automerge/automerge-repo/slim";
+
+type DiscoverRequest = {
+  type: "discover";
+  id: number;
+  url: AutomergeUrl;
+};
+
+// Keep only the structured-cloneable description fields. `load` is a closure
+// and `module` is the (possibly already-loaded) implementation — neither can
+// cross the worker boundary. `import` is droppable too: the main thread
+// rebuilds loading by re-importing the package and calling the live plugin.
+function toDescriptor(plugin: any): Record<string, unknown> {
+  if (!plugin || typeof plugin !== "object") return {};
+  const { load, import: _import, module, ...description } = plugin;
+  return description;
+}
+
+function isDiscoverRequest(data: unknown): data is DiscoverRequest {
+  return (
+    typeof data === "object" &&
+    data !== null &&
+    (data as any).type === "discover" &&
+    typeof (data as any).id === "number" &&
+    typeof (data as any).url === "string"
+  );
+}
+
+self.addEventListener("message", (event: MessageEvent) => {
+  const data = event.data;
+  if (!isDiscoverRequest(data)) return;
+  const { id, url } = data;
+
+  importModuleFromFolderDocUrl(url)
+    .then((mod) => {
+      const plugins: any[] = Array.isArray(mod?.plugins) ? mod.plugins : [];
+      const descriptors = plugins.map(toDescriptor);
+      (self as unknown as Worker).postMessage({
+        type: "descriptors",
+        id,
+        descriptors,
+      });
+    })
+    .catch((error) => {
+      (self as unknown as Worker).postMessage({
+        type: "error",
+        id,
+        error:
+          error instanceof Error
+            ? (error.stack ?? error.message)
+            : String(error),
+      });
+    });
+});

package/src/module-loader.ts

@@ -0,0 +1,85 @@
+// Main-thread client for the module-loader worker (see module-loader-worker.ts).
+//
+// `importAutomergeModuleViaWorker` is wired into the ModuleWatcher in place of
+// its default (direct, main-thread) package import. It asks the worker to
+// import the package entry point and report which plugins it exports, then
+// returns the same `{ plugins }` shape the watcher already feeds to
+// `registerPlugins` — except each plugin's `load()` re-imports the package
+// (pinned to the same heads) on this thread and runs the real plugin loader.
+
+import { importPluginFromFolderDocUrl } from "@inkandswitch/patchwork-filesystem";
+import type { AutomergeUrl } from "@automerge/automerge-repo/slim";
+
+type Descriptor = Record<string, unknown> & { id?: string; type?: string };
+
+type WorkerReply =
+  | { type: "descriptors"; id: number; descriptors: Descriptor[] }
+  | { type: "error"; id: number; error: string };
+
+const WORKER_PATH = "/module-loader-worker.js";
+
+let worker: Worker | undefined;
+let nextRequestId = 1;
+const pending = new Map<
+  number,
+  { resolve: (d: Descriptor[]) => void; reject: (e: Error) => void }
+>();
+
+function getWorker(): Worker {
+  if (worker) return worker;
+  worker = new Worker(WORKER_PATH, {
+    type: "module",
+    name: "patchwork-module-loader",
+  });
+  worker.addEventListener("message", (event: MessageEvent<WorkerReply>) => {
+    const data = event.data;
+    if (!data || (data.type !== "descriptors" && data.type !== "error")) return;
+    const entry = pending.get(data.id);
+    if (!entry) return;
+    pending.delete(data.id);
+    if (data.type === "descriptors") entry.resolve(data.descriptors);
+    else entry.reject(new Error(data.error));
+  });
+  worker.addEventListener("error", (event) => {
+    // An uncaught worker error can't be tied to a single request — fail every
+    // outstanding one so callers don't hang.
+    const error = new Error(
+      `module-loader worker error: ${event.message ?? "unknown"}`
+    );
+    for (const [, entry] of pending) entry.reject(error);
+    pending.clear();
+  });
+  return worker;
+}
+
+/** Ask the worker which plugins the package at `urlAtHeads` exports. */
+function discoverDescriptors(urlAtHeads: AutomergeUrl): Promise<Descriptor[]> {
+  const id = nextRequestId++;
+  return new Promise<Descriptor[]>((resolve, reject) => {
+    pending.set(id, { resolve, reject });
+    getWorker().postMessage({ type: "discover", id, url: urlAtHeads });
+  });
+}
+
+/**
+ * ModuleWatcher `importAutomergeModule` hook: discover descriptors in the
+ * worker, then return the `{ plugins }` shape with a main-thread `load()` per
+ * plugin that imports the package at heads and calls its real loader.
+ */
+export async function importAutomergeModuleViaWorker(
+  urlAtHeads: string
+): Promise<{ plugins: Descriptor[] }> {
+  const url = urlAtHeads as AutomergeUrl;
+  const descriptors = await discoverDescriptors(url);
+  const plugins = descriptors.map((descriptor) => {
+    const { id, type } = descriptor;
+    // A plugin id is only unique within a plugin type, so both are needed to
+    // re-select the right plugin when its load() re-imports the package.
+    if (typeof id !== "string" || typeof type !== "string") return descriptor;
+    return {
+      ...descriptor,
+      load: () => importPluginFromFolderDocUrl(url, type, id),
+    };
+  });
+  return { plugins };
+}

package/src/service-worker.ts

@@ -33,7 +33,49 @@ function log(...args: any[]) {
   );
 }
 
+// ── Lifecycle diagnostics ──────────────────────────────────────────────
+// [lifecycle] markers for SW (re)boots, install/activate, crashes, and stranded
+// handoffs. The SW can't read localStorage, so it always emits and forwards to
+// the tab, which gates rendering on the live toggle. The SW holds no sync
+// socket — observability only.
+
+async function postToClients(message: unknown) {
+  const clients = await self.clients.matchAll({
+    type: "window",
+    includeUncontrolled: true,
+  });
+  for (const client of clients) client.postMessage(message);
+}
+
+function lifecycle(level: "info" | "warn", text: string) {
+  const msg = `[lifecycle] ${new Date().toISOString()} ${text}`;
+  console[level](msg);
+  void postToClients({ type: "sw-lifecycle", level, msg });
+}
+
+lifecycle("info", `booted (scope ${self.registration?.scope ?? "?"})`);
+
+self.addEventListener("error", (event) => {
+  const e = event as ErrorEvent;
+  lifecycle(
+    "warn",
+    `uncaught error: ${e.message}` +
+      (e.filename ? ` @ ${e.filename}:${e.lineno}:${e.colno}` : "")
+  );
+});
+
+self.addEventListener("unhandledrejection", (event) => {
+  const reason = (event as PromiseRejectionEvent).reason;
+  lifecycle(
+    "warn",
+    `unhandled rejection: ${
+      reason instanceof Error ? reason.stack || reason.message : String(reason)
+    }`
+  );
+});
+
 self.addEventListener("install", (event) => {
+  lifecycle("info", "install (skipWaiting)");
   // 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.
@@ -52,13 +94,30 @@ async function clearOldCaches() {
 }
 
 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.
+  lifecycle("info", "activate (claiming clients)");
   (event as ExtendableEvent).waitUntil(
     (async () => {
       await clearOldCaches();
       await self.clients.claim();
+      // Pre-cache pages of already-open clients so they survive going offline
+      // before the next navigation.
+      const allClients = await self.clients.matchAll({ type: "window" });
+      const cache = await caches.open(cachename);
+      await Promise.all(
+        allClients.map(async (client) => {
+          try {
+            const existing = await cache.match(client.url);
+            if (!existing) {
+              const response = await fetch(client.url);
+              if (cacheableStatuses.includes(response.status)) {
+                await cache.put(client.url, response);
+              }
+            }
+          } catch {
+            // Network may be unavailable during activation
+          }
+        })
+      );
     })()
   );
 });
@@ -102,7 +161,15 @@ handoffChannel.addEventListener("message", (event) => {
   } 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()) {
+    const stranded = [...pendingHandoffs.values()];
+    if (stranded.length > 0) {
+      lifecycle(
+        "info",
+        `automerge worker (re)started; re-broadcasting ${stranded.length} ` +
+          `in-flight asset handoff(s)`
+      );
+    }
+    for (const { message } of stranded) {
       log(`re-broadcasting handoff ${message.id} to the fresh worker`);
       handoffChannel.postMessage(message);
     }
@@ -132,6 +199,11 @@ function handoff(
   log(`broadcasting handoff request for cache ${cachename}`, message);
   handoffChannel.postMessage(message);
   const timeout = setTimeout(() => {
+    lifecycle(
+      "warn",
+      `asset handoff ${id} stranded: no reply from the automerge worker after ` +
+        `${HANDOFF_TIMEOUT_MS}ms (${handoffURL.href})`
+    );
     resolvers.reject(
       new Error(
         `no reply from the automerge worker after ${HANDOFF_TIMEOUT_MS}ms`
@@ -208,7 +280,7 @@ self.addEventListener("fetch", (fetchEvent: FetchEvent) => {
           if (!cached) {
             return new Response(
               `the automerge worker reported ${handoffURL} cached, but it has no match in ${cachename}`,
-              { status: 500 }
+              { status: 555 }
             );
           }
           log(`serving ${handoffURL} from cache ${cachename} after handoff`);
@@ -220,7 +292,9 @@ self.addEventListener("fetch", (fetchEvent: FetchEvent) => {
               cacheableStatuses.includes(response.status) &&
               response.url.match(/^https?\:/)
             ) {
-              await cache.put(request, response.clone());
+              await cache.put(request, response.clone()).catch((error) => {
+                log(`error caching ${request.url} in ${cachename}`, error);
+              });
             } else {
               log(
                 `skipping uncacheable response code from cache: ${response.status} for ${response.url}`
@@ -243,7 +317,7 @@ self.addEventListener("fetch", (fetchEvent: FetchEvent) => {
         if (match) return match;
 
         return new Response(message, {
-          status: 500,
+          status: 556,
           headers: { "content-type": "text/plain" },
         });
       }