@inkandswitch/patchwork-bootloader 0.2.6 → 0.2.8

package/src/setup.ts

@@ -3,13 +3,17 @@ import type {
   SetupServiceWorkerOptions,
   SetupServiceWorkerResult,
 } from "./types.js";
+import {
+  readClassicSyncServer,
+  DEFAULT_CLASSIC_SYNC_SERVER,
+} from "./sync-config.js";
 import debug from "debug";
 
-const debugging = debug.enabled("patchwork:serviceworker");
+const serviceWorkerDebugging = debug.enabled("patchwork:serviceworker");
+const workerDebugging = debug.enabled("patchwork:automergeworker");
 
 const key = "patchworkServiceWorkerCacheVersion";
 let nextRepoChannelId = 0;
-let serviceWorkerInstanceId: string | undefined;
 
 function bumpServiceWorkerCacheVersion() {
   const version = new Date().valueOf().toString(36);
@@ -48,17 +52,69 @@ export function bumpServiceWorkerCache(
 
 function configureServiceWorker(sw: ServiceWorker | null) {
   if (!sw) return;
-  sw.postMessage({ type: "debug", debug: debugging });
+  sw.postMessage({ type: "debug", debug: serviceWorkerDebugging });
   const cachename = getServiceWorkerCacheVersion();
   if (cachename) sw.postMessage({ type: "cachename", cachename });
 }
 
-function updateServiceWorkerInstanceId(next: unknown) {
-  if (typeof next !== "string") return false;
-  const changed =
-    serviceWorkerInstanceId != null && serviceWorkerInstanceId !== next;
-  serviceWorkerInstanceId = next;
-  return changed;
+// ── The automerge worker ───────────────────────────────────────────────
+// The automerge repo lives in a SharedWorker (not the service worker). One
+// instance is shared by every tab and lives exactly as long as any tab
+// does, so there's no keepalive ping and no restart detection: if we're
+// alive, it's alive. Repo sync ports are passed to it over its connect
+// port; it talks to the service worker over a BroadcastChannel.
+
+let automergeWorkerPath = "/automerge-worker.js";
+let automergeWorker: SharedWorker | undefined;
+
+function getAutomergeWorker(): SharedWorker {
+  if (!automergeWorker) {
+    automergeWorker = new SharedWorker(automergeWorkerPath, {
+      name: "patchwork-automerge",
+      type: "module",
+    });
+    // Control replies (port-ready &c) come back on this port, so it needs
+    // start() — we listen with addEventListener, not onmessage.
+    automergeWorker.port.start();
+    automergeWorker.port.postMessage({ type: "debug", debug: workerDebugging });
+  }
+  return automergeWorker;
+}
+
+export function connectClassicSync(
+  server: string = readClassicSyncServer()
+): Promise<void> {
+  const url = server.trim() || DEFAULT_CLASSIC_SYNC_SERVER;
+  if (!/^wss?:\/\//.test(url)) {
+    return Promise.reject(
+      new Error(`invalid classic sync server URL: ${server}`)
+    );
+  }
+
+  const worker = getAutomergeWorker();
+  const { port1, port2 } = new MessageChannel();
+  return new Promise((resolve, reject) => {
+    const timeout = setTimeout(() => {
+      port1.close();
+      reject(new Error("connect-classic-sync timeout"));
+    }, 30_000);
+    port1.onmessage = (event) => {
+      clearTimeout(timeout);
+      port1.close();
+      if (event.data?.type === "connect-classic-sync-ready") {
+        resolve();
+      } else {
+        reject(
+          new Error(
+            event.data?.error ?? "connect-classic-sync failed"
+          )
+        );
+      }
+    };
+    worker.port.postMessage({ type: "connect-classic-sync", server: url }, [
+      port2,
+    ]);
+  });
 }
 
 /** Wait for a registration to have an active worker */
@@ -74,122 +130,69 @@ function waitForActive(reg: ServiceWorkerRegistration): Promise<ServiceWorker> {
   });
 }
 
-async function openRepoChannel(): Promise<{
-  port: MessagePort;
-  workerInstanceChanged: boolean;
-}> {
-  const controller = navigator.serviceWorker.controller;
-  if (!controller) {
-    throw new Error("no service worker controller");
-  }
+async function openRepoChannel(): Promise<MessagePort> {
+  const worker = getAutomergeWorker();
 
-  // Send a MessagePort so the SW's repo can sync with clients, and wait for
-  // the SW to confirm its repo is constructed before returning. The
+  // Send a MessagePort so the worker's repo can sync with this tab, and wait
+  // for the worker to confirm its repo is constructed before returning. The
   // MessageChannel adapter's whenReady() force-resolves after 100ms regardless
   // of the other end's state, so it can't be used as a real readiness signal
-  // on first install (when the SW still has to fetch wasm and build its repo).
+  // on first boot (when the worker still has to fetch wasm and build its repo).
   const id = ++nextRepoChannelId;
-  let workerInstanceChanged = false;
   const { port1, port2 } = new MessageChannel();
-  const swReady = new Promise<void>((resolve, reject) => {
+  const workerReady = new Promise<void>((resolve, reject) => {
     let timeout: ReturnType<typeof setTimeout>;
     const cleanup = () => {
       clearTimeout(timeout);
-      navigator.serviceWorker.removeEventListener("message", listener);
+      worker.port.removeEventListener("message", listener);
     };
     const listener = (event: MessageEvent) => {
-      if (event.data?.id != null && event.data.id !== id) return;
+      if (event.data?.id !== id) return;
       if (event.data?.type === "port-ready") {
-        workerInstanceChanged = updateServiceWorkerInstanceId(
-          event.data.workerInstanceId
-        );
         cleanup();
         resolve();
       } else if (event.data?.type === "port-failed") {
-        workerInstanceChanged = updateServiceWorkerInstanceId(
-          event.data.workerInstanceId
-        );
         cleanup();
-        reject(new Error(`service worker init failed: ${event.data.error}`));
+        reject(new Error(`automerge worker init failed: ${event.data.error}`));
       }
     };
-    navigator.serviceWorker.addEventListener("message", listener);
-    // Failsafe: don't block boot forever if the SW never replies. Surface the
-    // issue and let the rest of the site come up rather than hanging on a
+    worker.port.addEventListener("message", listener);
+    // Failsafe: don't block boot forever if the worker never replies. Surface
+    // the issue and let the rest of the site come up rather than hanging on a
     // blank page.
     timeout = setTimeout(() => {
       cleanup();
-      reject(new Error("service worker port-ready timeout"));
+      reject(new Error("automerge worker port-ready timeout"));
     }, 30_000);
   });
-  controller.postMessage({ type: "port", id }, [port2]);
+  worker.port.postMessage({ type: "port", id }, [port2]);
   try {
-    await swReady;
+    await workerReady;
   } catch (err) {
     console.warn(
-      "proceeding without SW ready ack:",
+      "proceeding without worker ready ack:",
       err instanceof Error ? err.message : err
     );
   }
-  return { port: port1, workerInstanceChanged };
+  return port1;
+}
+
+/** Open a fresh repo sync port to the automerge worker (dev console). */
+function getRepoChannel(): MessagePort {
+  const worker = getAutomergeWorker();
+  const { port1, port2 } = new MessageChannel();
+  worker.port.postMessage({ type: "port", id: ++nextRepoChannelId }, [port2]);
+  return port1;
 }
 
 export default async function setupServiceWorker(
   options?: SetupServiceWorkerOptions
 ): Promise<SetupServiceWorkerResult> {
-  const repoChannelListeners = new Set<ServiceWorkerRepoChannelListener>();
-  let reconnectPromise: Promise<void> | null = null;
+  if (options?.workerPath) automergeWorkerPath = options.workerPath;
 
-  const reconnectRepoChannels = (reason: string) => {
-    if (reconnectPromise) return reconnectPromise;
-    reconnectPromise = (async () => {
-      console.info(
-        `%cservice worker ${reason}, reconnecting repo channels...`,
-        "color: pink; font-weight: bold"
-      );
-      configureServiceWorker(navigator.serviceWorker.controller);
-      for (const listener of repoChannelListeners) {
-        try {
-          const { port } = await openRepoChannel();
-          await listener(port);
-        } catch (err) {
-          console.error("service worker repo channel listener failed", err);
-        }
-      }
-    })().finally(() => {
-      reconnectPromise = null;
-    });
-    return reconnectPromise;
-  };
-
-  const pingServiceWorker = async () => {
-    const controller = navigator.serviceWorker.controller;
-    if (!controller) return;
-    const { port1, port2 } = new MessageChannel();
-    const pong = new Promise<unknown>((resolve, reject) => {
-      const timeout = setTimeout(() => {
-        port1.close();
-        reject(new Error("service worker pong timeout"));
-      }, 5_000);
-      port1.onmessage = (event) => {
-        clearTimeout(timeout);
-        port1.close();
-        resolve(event.data?.workerInstanceId);
-      };
-    });
-    controller.postMessage({ type: "ping" }, [port2]);
-    try {
-      const restarted = updateServiceWorkerInstanceId(await pong);
-      if (restarted) {
-        await reconnectRepoChannels("restarted");
-      }
-    } catch (err) {
-      console.warn(
-        "service worker ping failed:",
-        err instanceof Error ? err.message : err
-      );
-    }
-  };
+  // Start the automerge worker right away so it boots (wasm, repo) while the
+  // service worker installs.
+  getAutomergeWorker();
 
   const path = options?.path ?? "/service-worker.js";
   // No controller at this point means the page loaded without a service
@@ -216,20 +219,10 @@ export default async function setupServiceWorker(
     });
   }
 
-  // Keepalive — Chromium idles out service workers after ~30s of inactivity,
-  // which tears down the in-memory Repo and forces a cold restart on the next
-  // fetch. Ping through a MessageChannel so we can detect when a restarted SW
-  // has a new in-memory Repo and reconnect all repo channels.
-  setInterval(() => {
-    void pingServiceWorker();
-  }, 20_000);
-
-  // Reconnect on future SW updates (added after setup so the initial
-  // activation doesn't notify before callers subscribe).
-  navigator.serviceWorker.addEventListener("controllerchange", function () {
-    void reconnectRepoChannels("took control").catch((err) => {
-      console.error("service worker reconnect failed", err);
-    });
+  // A replacement service worker boots with the default cache name — re-send
+  // its configuration whenever a new one takes control.
+  navigator.serviceWorker.addEventListener("controllerchange", () => {
+    configureServiceWorker(navigator.serviceWorker.controller);
   });
 
   console.log(
@@ -238,19 +231,13 @@ export default async function setupServiceWorker(
   );
 
   return {
-    async subscribeToRepoChannel(listener) {
-      const { port, workerInstanceChanged } = await openRepoChannel();
-      if (workerInstanceChanged) {
-        await reconnectRepoChannels("restarted");
-      }
-      repoChannelListeners.add(listener);
-      try {
-        await listener(port);
-      } catch (err) {
-        repoChannelListeners.delete(listener);
-        throw err;
-      }
-      return () => repoChannelListeners.delete(listener);
+    connectClassicSync,
+    getRepoChannel,
+    async subscribeToRepoChannel(listener: ServiceWorkerRepoChannelListener) {
+      // The automerge worker outlives the page, so unlike the old in-service-
+      // worker repo there's nothing to reconnect: one port, handed over once.
+      await listener(await openRepoChannel());
+      return () => {};
     },
   };
 }

package/src/site.ts

@@ -2,14 +2,14 @@
  * High-level browser-app boot sequence for a Patchwork site.
  *
  * Layers on top of {@link setupServiceWorker} (the package default export) to
- * construct the Repo, wire up the service-worker port, load plugins via the
+ * construct the Repo, wire up the automerge-worker port, load plugins via the
  * ModuleWatcher, resolve the user's account document, and hand control to the
  * configured root tool.
  *
  * This entry point pulls in DOM- and plugin-layer dependencies (patchwork
  * elements, plugins, filesystem) and is intended for use only from a browser
  * site's `main.ts`. Non-UI consumers should import the package default (which
- * only does SW registration and port handoff).
+ * only does SW registration and the automerge-worker handoff).
  */
 import {
   type DocHandle,
@@ -60,7 +60,6 @@ import * as plugins from "@inkandswitch/patchwork-plugins";
 
 import setupServiceWorker from "./setup.js";
 import type { ServiceWorkerRepoChannelListener } from "./types.js";
-import { SwLogReader } from "./sw-logger.js";
 import debug from "debug";
 const log = debug("patchwork:bootloader:site");
 
@@ -78,10 +77,7 @@ declare global {
       plugins: typeof plugins;
       accountDocHandle: DocHandle<AccountDoc>;
       sw: {
-        printLogs: (n?: number) => Promise<void>;
-        tailLogs: (n?: number) => ReturnType<typeof SwLogReader.tail>;
-        exportLogs: () => Promise<string>;
-        clearLogs: () => Promise<void>;
+        connectClassicSync: (server?: string) => Promise<void>;
         subscribeToRepoChannel: (
           listener: ServiceWorkerRepoChannelListener
         ) => Promise<() => void>;
@@ -177,24 +173,22 @@ export async function bootPatchworkSite(
   if (!sw) throw new Error("Failed to set up service worker");
 
   let hive: AutomergeRepoKeyhive | undefined;
+  // Get the initial automerge-worker port via subscribeToRepoChannel,
+  // then pass it to keyhive init which wraps it in its own network adapter.
+  let resolvePort!: (port: MessagePort) => void;
+  const portPromise = new Promise<MessagePort>((r) => {
+    resolvePort = r;
+  });
+  await sw.subscribeToRepoChannel(resolvePort);
+  const workerPort = await portPromise;
+
   if (config.keyhive) {
     initKeyhiveWasm();
 
-    // Get the initial SW port via subscribeToRepoChannel, then pass it
-    // to keyhive init which wraps it in its own network adapter.
-    let resolvePort!: (port: MessagePort) => void;
-    const portPromise = new Promise<MessagePort>((r) => { resolvePort = r; });
-    sw.subscribeToRepoChannel((port) => { resolvePort(port); });
-    const swPort = await portPromise;
-
     hive = await initializeAutomergeRepoKeyhive({
-      storage: new IndexedDBStorageAdapter(
-        `${siteName}-keyhive`
-      ),
-      peerIdSuffix:
-        siteName +
-        Math.random().toString(36).slice(2),
-      networkAdapter: new MessageChannelNetworkAdapter(swPort),
+      storage: new IndexedDBStorageAdapter(`${siteName}-keyhive`),
+      peerIdSuffix: siteName + Math.random().toString(36).slice(2),
+      networkAdapter: new MessageChannelNetworkAdapter(workerPort),
       automaticArchiveIngestion: true,
       cachingMode: "periodic",
       onlyShareWithHardcodedServerPeerId: false,
@@ -210,9 +204,10 @@ export async function bootPatchworkSite(
         idFactory: hive.idFactory,
       })
     : new Repo({
+        network: [new MessageChannelNetworkAdapter(workerPort)],
         storage: new IndexedDBStorageAdapter(),
         async sharePolicy(peerId) {
-          return peerId.includes("service-worker");
+          return peerId.includes("automerge-worker");
         },
         enableRemoteHeadsGossiping: true,
         peerId:
@@ -222,25 +217,14 @@ export async function bootPatchworkSite(
     config.remoteStorageIds ?? [DEFAULT_REMOTE_STORAGE_ID]
   );
 
+  await repo.networkSubsystem.whenReady();
   if (hive) {
-    await repo.networkSubsystem.whenReady();
     (hive.networkAdapter as any).syncKeyhive?.();
-  } else {
-    let activeServiceWorkerPort: MessagePort | undefined;
-    const connectServiceWorkerPort = async (port: MessagePort) => {
-      const previousPort = activeServiceWorkerPort;
-      activeServiceWorkerPort = port;
-      const net = new MessageChannelNetworkAdapter(port);
-      repo.networkSubsystem.addNetworkAdapter(net);
-      await net.whenReady();
-      previousPort?.close();
-    };
-    await sw.subscribeToRepoChannel(connectServiceWorkerPort);
   }
 
-  installDevConsoleGlobals(repo, hive);
+  installDevConsoleGlobals(repo, hive, sw.getRepoChannel);
 
-  registerRepoProviderElement(repo);
+  registerRepoProviderElement(repo as any);
 
   const rootElement = document.getElementById(config.rootElementId ?? "root");
   if (!rootElement) {
@@ -248,11 +232,13 @@ export async function bootPatchworkSite(
       `bootPatchworkSite: no element with id="${config.rootElementId ?? "root"}"`
     );
   }
+  // `<repo-provider>` sits above the root and answers `repo:handle-descriptor`
+  // for any view outside a remapper (resolving to the requested url unchanged).
   const repoProvider = document.createElement("repo-provider");
   rootElement.parentElement!.insertBefore(repoProvider, rootElement);
   repoProvider.appendChild(rootElement);
 
-  registerPatchworkViewElement(hive ? { hive } : {});
+  registerPatchworkViewElement({ hive, repo });
 
   // The watcher is started with the site's default-tools bundle alone so that
   // `resolveAccountHandle` below has something to await on (the `account`
@@ -265,10 +251,12 @@ export async function bootPatchworkSite(
     unregisterPlugins
   );
 
-  const accountDocHandle = await resolveAccountHandle(repo, {
+  const accountDocHandle = (await resolveAccountHandle(repo, {
     storageKey: config.accountStorageKey,
     hive,
-  });
+  })) as DocHandle<AccountDoc>;
+  // TODO: something we (Orion & pvh) changed in the types made this necessary
+  //       fix this before merging to main!
 
   window.accountDocHandle = accountDocHandle;
 
@@ -283,7 +271,7 @@ export async function bootPatchworkSite(
     plugins,
     accountDocHandle,
     sw: {
-      ...buildSwLogApi(),
+      connectClassicSync: sw.connectClassicSync,
       subscribeToRepoChannel: sw.subscribeToRepoChannel,
     },
   };
@@ -321,7 +309,8 @@ function resolveDefaultModulesUrl(builtin: AutomergeUrl): AutomergeUrl {
 
 function installDevConsoleGlobals(
   repo: Repo,
-  hive: AutomergeRepoKeyhive | undefined
+  hive: AutomergeRepoKeyhive | undefined,
+  getRepoChannel: () => MessagePort
 ): void {
   window.repo = repo;
   window.Automerge = Automerge;
@@ -329,11 +318,7 @@ function installDevConsoleGlobals(
   if (hive) {
     window.hive = hive;
   }
-  window.getRepoChannel = () => {
-    const { port1, port2 } = new MessageChannel();
-    navigator.serviceWorker.controller!.postMessage({ type: "port" }, [port2]);
-    return port1;
-  };
+  window.getRepoChannel = getRepoChannel;
 }
 
 function onModuleLoaded(name: string, mod: any): void {
@@ -413,26 +398,6 @@ function logToolRegistryWhenLoaded(moduleWatcher: ModuleWatcher): void {
     });
 }
 
-function buildSwLogApi(): Omit<
-  Window["patchwork"]["sw"],
-  "subscribeToRepoChannel"
-> {
-  return {
-    printLogs: async (n = 200) => {
-      const entries = await SwLogReader.tail(n);
-      for (const e of entries) {
-        const prefix = `[${e.ts}] [${e.level}]`;
-        if (e.data !== undefined) log(prefix, e.msg, e.data);
-        else log(prefix, e.msg);
-      }
-      log(`--- ${entries.length} entries ---`);
-    },
-    tailLogs: (n = 200) => SwLogReader.tail(n),
-    exportLogs: () => SwLogReader.exportAll(),
-    clearLogs: () => SwLogReader.clear(),
-  };
-}
-
 const LOADING_STYLE_ID = "pw-bootloader-loading-styles";
 const LOADING_ELEMENT_ID = "pw-bootloader-loading";
 

package/src/sync-config.ts

@@ -0,0 +1,23 @@
+/** localStorage key: optional override for the classic sync WebSocket URL. */
+export const CLASSIC_SYNC_SERVER_KEY = "patchworkClassicSyncServer";
+
+export const DEFAULT_CLASSIC_SYNC_SERVER = "wss://sync3.automerge.org";
+
+export function readClassicSyncServer(
+  storage: Pick<Storage, "getItem"> = globalThis.localStorage
+): string {
+  const override = storage.getItem(CLASSIC_SYNC_SERVER_KEY)?.trim();
+  if (!override) return DEFAULT_CLASSIC_SYNC_SERVER;
+  if (!/^wss?:\/\//.test(override)) {
+    console.warn(
+      `ignoring invalid ${CLASSIC_SYNC_SERVER_KEY} in localStorage: ${override}; using ${DEFAULT_CLASSIC_SYNC_SERVER}`
+    );
+    return DEFAULT_CLASSIC_SYNC_SERVER;
+  }
+  return override;
+}
+
+export type ConnectClassicSyncMessage = {
+  type: "connect-classic-sync";
+  server: string;
+};

package/src/types.ts

@@ -1,9 +1,103 @@
+/**
+ * The BroadcastChannel the service worker and the automerge shared worker
+ * use to hand requests off to each other. Broadcast (rather than a
+ * MessagePort handed from one to the other) so the two never need to be
+ * reintroduced when either of them restarts — and so tabs can listen in.
+ */
+export const HANDOFF_CHANNEL = "@patchwork/handoff";
+
+/**
+ * The special URL to resolve, plus enough of the {@link Request} the service
+ * worker is holding that the automerge worker can construct one that
+ * `cache.match`es it.
+ *
+ * Stale workers on either side of the channel can outlive a deploy, so the
+ * shape can only ever change additively: `url` must stay the http request
+ * URL old automerge workers decode the special URL out of, and new meaning
+ * goes in new fields old receivers ignore.
+ */
+export interface HandoffRequest {
+  /**
+   * The URL of the request the service worker is holding (the encoded
+   * `https://…/automerge%3Aabc/…` form) — the cache key.
+   */
+  url: string;
+  /** the decoded special URL, e.g. `automerge:abc/some/path` */
+  handoffURL: string;
+  /**
+   * @deprecated A briefly-deployed shape put the special URL in `url` and
+   * the cache key here. Only read, never sent.
+   */
+  cacheKey?: string;
+  headers: Record<string, string>;
+  method: string;
+  destination: RequestDestination;
+  referrer: string;
+}
+
+/**
+ * Service worker → automerge worker: please resolve this request and put
+ * the response in my cache.
+ */
+export interface HandoffRequestMessage {
+  id: string;
+  type: "request";
+  /** the current name of the service worker cache */
+  cachename: string;
+  request: HandoffRequest;
+}
+
+/**
+ * Automerge worker → service worker: the response is stored in the cache
+ * under the request you're holding. Serve `cache.match`.
+ */
+export interface HandoffCachedMessage {
+  id: string;
+  type: "cached";
+}
+
+/**
+ * An inline response for things that shouldn't be cached: errors, redirects
+ * &c.
+ */
+export interface HandoffResponse {
+  body?: string | Uint8Array<ArrayBuffer>;
+  /** defaults to 200 */
+  status?: number;
+  headers?: Record<string, string>;
+}
+
+/**
+ * Automerge worker → service worker: don't cache anything, serve this
+ * response directly.
+ */
+export interface HandoffResponseMessage {
+  id: string;
+  type: "response";
+  response: HandoffResponse;
+}
+
+export type HandoffReplyMessage = HandoffCachedMessage | HandoffResponseMessage;
+
+/**
+ * Automerge worker → world: broadcast once on startup so the service worker
+ * can re-send any handoff requests that raced the worker's boot.
+ */
+export interface HandoffOnlineMessage {
+  type: "online";
+}
+
 export type SetupServiceWorkerOptions = {
   /**
    * The public path to the service worker file.
    * Defaults to `/service-worker.js`
    */
   path?: string;
+  /**
+   * The public path to the automerge shared worker file.
+   * Defaults to `/automerge-worker.js`
+   */
+  workerPath?: string;
 };
 
 export type ServiceWorkerRepoChannelListener = (
@@ -11,7 +105,11 @@ export type ServiceWorkerRepoChannelListener = (
 ) => void | Promise<void>;
 
 export type SetupServiceWorkerResult = {
+  /** Open a classic Automerge sync WebSocket from the automerge worker. */
+  connectClassicSync: (server?: string) => Promise<void>;
   subscribeToRepoChannel: (
     listener: ServiceWorkerRepoChannelListener
   ) => Promise<() => void>;
+  /** Open a fresh repo sync port to the automerge worker (dev console). */
+  getRepoChannel: () => MessagePort;
 };