@inkandswitch/patchwork-bootloader 0.2.5 → 0.2.7

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,
@@ -28,19 +28,25 @@ import {
 } from "@automerge/vanillajs/slim";
 import * as Automerge from "@automerge/automerge/slim";
 import * as AutomergeRepo from "@automerge/automerge-repo/slim";
+import {
+  initKeyhiveWasm,
+  initializeAutomergeRepoKeyhive,
+  type AutomergeRepoKeyhive,
+} from "@automerge/automerge-repo-keyhive";
 // 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";
 
+declare const __SITE_NAME__: string;
+const siteName =
+  typeof __SITE_NAME__ !== "undefined" ? __SITE_NAME__ : "tiny-patchwork";
+
 import { ModuleWatcher } from "@inkandswitch/patchwork-filesystem";
 import {
   openDocument,
   registerPatchworkViewElement,
 } from "@inkandswitch/patchwork-elements";
-import {
-  registerFallbackProviderElement,
-  registerRepoProviderElement,
-} from "@inkandswitch/patchwork-providers";
+import { registerRepoProviderElement } from "@inkandswitch/patchwork-providers";
 import {
   type AccountDoc,
   type DatatypeDescription,
@@ -54,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");
 
@@ -64,16 +69,15 @@ declare global {
     Automerge: typeof import("@automerge/automerge");
     AutomergeRepo: typeof import("@automerge/automerge-repo");
     repo: Repo;
+    hive?: AutomergeRepoKeyhive;
+    getRepoChannel: () => MessagePort;
     patchwork: {
       repo: Repo;
       packages: ModuleWatcher;
       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>;
@@ -120,6 +124,13 @@ export interface SiteConfig {
    * Ink & Switch's production Subduction storage.
    */
   remoteStorageIds?: StorageId[];
+
+  /**
+   * When true, initialize keyhive for access control.
+   * The Repo will use keyhive's network adapter, peerId, and idFactory
+   * instead of a sharePolicy.
+   */
+  keyhive?: boolean;
 }
 
 export interface BootResult {
@@ -158,37 +169,63 @@ export async function bootPatchworkSite(
   await initializeWasm(automergeWasm);
   initSubductionSync(subductionWasm);
 
-  const repo = new Repo({
-    storage: new IndexedDBStorageAdapter(),
-    async sharePolicy(peerId) {
-      return peerId.includes("service-worker");
-    },
-    enableRemoteHeadsGossiping: true,
-    peerId:
-      `${config.titleSuffix}-tab-${crypto.randomUUID()}` as AutomergeRepo.PeerId,
-  });
+  const sw = await setupServiceWorker();
+  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();
+
+    hive = await initializeAutomergeRepoKeyhive({
+      storage: new IndexedDBStorageAdapter(`${siteName}-keyhive`),
+      peerIdSuffix: siteName + Math.random().toString(36).slice(2),
+      networkAdapter: new MessageChannelNetworkAdapter(workerPort),
+      automaticArchiveIngestion: true,
+      cachingMode: "periodic",
+      onlyShareWithHardcodedServerPeerId: false,
+    });
+  }
 
+  const repo = hive
+    ? new Repo({
+        storage: new IndexedDBStorageAdapter(),
+        enableRemoteHeadsGossiping: true,
+        network: [hive.networkAdapter],
+        peerId: hive.peerId,
+        idFactory: hive.idFactory,
+      })
+    : new Repo({
+        network: [new MessageChannelNetworkAdapter(workerPort)],
+        storage: new IndexedDBStorageAdapter(),
+        async sharePolicy(peerId) {
+          return peerId.includes("automerge-worker");
+        },
+        enableRemoteHeadsGossiping: true,
+        peerId:
+          `${config.titleSuffix}-tab-${crypto.randomUUID()}` as AutomergeRepo.PeerId,
+      });
   repo.subscribeToRemotes(
     config.remoteStorageIds ?? [DEFAULT_REMOTE_STORAGE_ID]
   );
 
-  const sw = await setupServiceWorker();
-  if (!sw) throw new Error("Failed to set up service worker");
-  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);
+  await repo.networkSubsystem.whenReady();
+  if (hive) {
 
-  installDevConsoleGlobals(repo);
+    (hive.networkAdapter as any).syncKeyhive?.();
+  }
 
-  registerRepoProviderElement(repo);
-  registerFallbackProviderElement();
+  installDevConsoleGlobals(repo, hive, sw.getRepoChannel);
+
+  registerRepoProviderElement(repo as any);
 
   const rootElement = document.getElementById(config.rootElementId ?? "root");
   if (!rootElement) {
@@ -197,14 +234,10 @@ export async function bootPatchworkSite(
     );
   }
   const repoProvider = document.createElement("repo-provider");
-  const fallbackProvider = document.createElement("fallback-provider");
-  rootElement.parentElement!.insertBefore(fallbackProvider, rootElement);
-  fallbackProvider.appendChild(repoProvider);
+  rootElement.parentElement!.insertBefore(repoProvider, rootElement);
   repoProvider.appendChild(rootElement);
 
-  // Registers `<patchwork-view>` and the `<patchwork-view-legacy>` it
-  // delegates to in one go.
-  registerPatchworkViewElement();
+  registerPatchworkViewElement(hive ? { hive } : {});
 
   // The watcher is started with the site's default-tools bundle alone so that
   // `resolveAccountHandle` below has something to await on (the `account`
@@ -217,9 +250,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;
 
@@ -234,7 +270,7 @@ export async function bootPatchworkSite(
     plugins,
     accountDocHandle,
     sw: {
-      ...buildSwLogApi(),
+      connectClassicSync: sw.connectClassicSync,
       subscribeToRepoChannel: sw.subscribeToRepoChannel,
     },
   };
@@ -270,10 +306,18 @@ function resolveDefaultModulesUrl(builtin: AutomergeUrl): AutomergeUrl {
   return builtin;
 }
 
-function installDevConsoleGlobals(repo: Repo): void {
+function installDevConsoleGlobals(
+  repo: Repo,
+  hive: AutomergeRepoKeyhive | undefined,
+  getRepoChannel: () => MessagePort
+): void {
   window.repo = repo;
   window.Automerge = Automerge;
   window.AutomergeRepo = AutomergeRepo;
+  if (hive) {
+    window.hive = hive;
+  }
+  window.getRepoChannel = getRepoChannel;
 }
 
 function onModuleLoaded(name: string, mod: any): void {
@@ -353,26 +397,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;
+};