@inkandswitch/patchwork-bootloader 0.2.6 → 0.2.7

package/dist/setup.js

@@ -1,8 +1,9 @@
+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;
 function bumpServiceWorkerCacheVersion() {
     const version = new Date().valueOf().toString(36);
     localStorage.setItem(key, version);
@@ -34,17 +35,58 @@ window.bumpServiceWorkerCache = bumpServiceWorkerCache;
 function configureServiceWorker(sw) {
     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) {
-    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;
+function getAutomergeWorker() {
+    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 = readClassicSyncServer()) {
+    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 */
 function waitForActive(reg) {
@@ -61,106 +103,63 @@ function waitForActive(reg) {
     });
 }
 async function openRepoChannel() {
-    const controller = navigator.serviceWorker.controller;
-    if (!controller) {
-        throw new Error("no service worker controller");
-    }
-    // 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
+    const worker = getAutomergeWorker();
+    // 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((resolve, reject) => {
+    const workerReady = new Promise((resolve, reject) => {
         let timeout;
         const cleanup = () => {
             clearTimeout(timeout);
-            navigator.serviceWorker.removeEventListener("message", listener);
+            worker.port.removeEventListener("message", listener);
         };
         const listener = (event) => {
-            if (event.data?.id != null && event.data.id !== id)
+            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:", err instanceof Error ? err.message : err);
+        console.warn("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() {
+    const worker = getAutomergeWorker();
+    const { port1, port2 } = new MessageChannel();
+    worker.port.postMessage({ type: "port", id: ++nextRepoChannelId }, [port2]);
+    return port1;
 }
 export default async function setupServiceWorker(options) {
-    const repoChannelListeners = new Set();
-    let reconnectPromise = null;
-    const reconnectRepoChannels = (reason) => {
-        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((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);
-        }
-    };
+    if (options?.workerPath)
+        automergeWorkerPath = options.workerPath;
+    // 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
     // worker — i.e. this is a first-time install (or a hard reload). Wait for
@@ -178,36 +177,20 @@ export default async function setupServiceWorker(options) {
             navigator.serviceWorker.addEventListener("controllerchange", () => resolve(), { once: true });
         });
     }
-    // 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("service worker alive, loading %c patchwork system ", "background: #fcf2f0; color: #333; border: 2px solid; border-radius: 4px");
     return {
+        connectClassicSync,
+        getRepoChannel,
         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);
+            // 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/dist/site.d.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, Repo, type AutomergeUrl, type StorageId } from "@automerge/vanillajs/slim";
 import { type AutomergeRepoKeyhive } from "@automerge/automerge-repo-keyhive";
@@ -17,7 +17,6 @@ import { ModuleWatcher } from "@inkandswitch/patchwork-filesystem";
 import { type AccountDoc } from "@inkandswitch/patchwork-plugins";
 import * as plugins from "@inkandswitch/patchwork-plugins";
 import type { ServiceWorkerRepoChannelListener } from "./types.js";
-import { SwLogReader } from "./sw-logger.js";
 declare global {
     interface Window {
         accountDocHandle: DocHandle<AccountDoc>;
@@ -32,10 +31,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>;
             };
         };

package/dist/site.js

@@ -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 { IndexedDBStorageAdapter, initializeWasm, isValidAutomergeUrl, isValidDocumentId, MessageChannelNetworkAdapter, parseAutomergeUrl, Repo, stringifyAutomergeUrl, } from "@automerge/vanillajs/slim";
 import * as Automerge from "@automerge/automerge/slim";
@@ -25,7 +25,6 @@ import { registerRepoProviderElement } from "@inkandswitch/patchwork-providers";
 import { getRegistry, registerPlugins, resolveAccountHandle, unregisterPlugins, } from "@inkandswitch/patchwork-plugins";
 import * as plugins from "@inkandswitch/patchwork-plugins";
 import setupServiceWorker from "./setup.js";
-import { SwLogReader } from "./sw-logger.js";
 import debug from "debug";
 const log = debug("patchwork:bootloader:site");
 const DEFAULT_REMOTE_STORAGE_ID = "3760df37-a4c6-4f66-9ecd-732039a9385d";
@@ -54,19 +53,20 @@ export async function bootPatchworkSite(config) {
     if (!sw)
         throw new Error("Failed to set up service worker");
     let hive;
+    // 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;
+    });
+    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;
-        const portPromise = new Promise((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),
+            peerIdSuffix: siteName + Math.random().toString(36).slice(2),
+            networkAdapter: new MessageChannelNetworkAdapter(workerPort),
             automaticArchiveIngestion: true,
             cachingMode: "periodic",
             onlyShareWithHardcodedServerPeerId: false,
@@ -81,31 +81,20 @@ export async function bootPatchworkSite(config) {
             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: `${config.titleSuffix}-tab-${crypto.randomUUID()}`,
         });
     repo.subscribeToRemotes(config.remoteStorageIds ?? [DEFAULT_REMOTE_STORAGE_ID]);
+    await repo.networkSubsystem.whenReady();
     if (hive) {
-        await repo.networkSubsystem.whenReady();
         hive.networkAdapter.syncKeyhive?.();
     }
-    else {
-        let activeServiceWorkerPort;
-        const connectServiceWorkerPort = async (port) => {
-            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);
     const rootElement = document.getElementById(config.rootElementId ?? "root");
     if (!rootElement) {
@@ -120,10 +109,12 @@ export async function bootPatchworkSite(config) {
     // datatype lives in that bundle today). The user's own module-settings URL
     // is added lazily once it appears on the account doc — see below.
     const moduleWatcher = new ModuleWatcher(repo, { system: defaultModulesUrl }, onModuleLoaded, unregisterPlugins);
-    const accountDocHandle = await resolveAccountHandle(repo, {
+    const accountDocHandle = (await resolveAccountHandle(repo, {
         storageKey: config.accountStorageKey,
         hive,
-    });
+    }));
+    // TODO: something we (Orion & pvh) changed in the types made this necessary
+    //       fix this before merging to main!
     window.accountDocHandle = accountDocHandle;
     wireModuleSettingsWhenReady(accountDocHandle, moduleWatcher);
     primeRootElement(rootElement, accountDocHandle);
@@ -134,7 +125,7 @@ export async function bootPatchworkSite(config) {
         plugins,
         accountDocHandle,
         sw: {
-            ...buildSwLogApi(),
+            connectClassicSync: sw.connectClassicSync,
             subscribeToRepoChannel: sw.subscribeToRepoChannel,
         },
     };
@@ -162,18 +153,14 @@ function resolveDefaultModulesUrl(builtin) {
     console.warn(`ignoring invalid defaultToolsUrl in localStorage: ${override}; using built-in default`);
     return builtin;
 }
-function installDevConsoleGlobals(repo, hive) {
+function installDevConsoleGlobals(repo, hive, getRepoChannel) {
     window.repo = repo;
     window.Automerge = Automerge;
     window.AutomergeRepo = AutomergeRepo;
     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, mod) {
     if (Array.isArray(mod.plugins)) {
@@ -235,24 +222,6 @@ function logToolRegistryWhenLoaded(moduleWatcher) {
         console.error("doneLoading rejected:", err);
     });
 }
-function buildSwLogApi() {
-    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";
 function showLoadingAnimation() {

package/dist/sync-config.d.ts

@@ -0,0 +1,8 @@
+/** localStorage key: optional override for the classic sync WebSocket URL. */
+export declare const CLASSIC_SYNC_SERVER_KEY = "patchworkClassicSyncServer";
+export declare const DEFAULT_CLASSIC_SYNC_SERVER = "wss://sync3.automerge.org";
+export declare function readClassicSyncServer(storage?: Pick<Storage, "getItem">): string;
+export type ConnectClassicSyncMessage = {
+    type: "connect-classic-sync";
+    server: string;
+};

package/dist/sync-config.js

@@ -0,0 +1,13 @@
+/** 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 = globalThis.localStorage) {
+    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;
+}

package/dist/types.d.ts

@@ -1,11 +1,101 @@
+/**
+ * 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 declare 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 = (port: MessagePort) => 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;
 };

package/dist/types.js

@@ -1 +1,7 @@
-export {};
+/**
+ * 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";

package/dist/vite/service-worker-plugin.js

@@ -1,20 +1,36 @@
 import { builtins } from "./importmap-plugin.js";
+// The service worker and the automerge shared worker are emitted as their
+// own chunks. Their heavy imports are marked external and resolved to
+// /packages/... URLs (both workers are created with type:"module", so the
+// browser fetches those as regular network requests).
+const workers = [
+    {
+        specifier: "@inkandswitch/patchwork-bootloader/service-worker",
+        fileName: "service-worker.js",
+    },
+    {
+        specifier: "@inkandswitch/patchwork-bootloader/automerge-worker",
+        fileName: "automerge-worker.js",
+    },
+];
 export function serviceworker() {
-    let swEntryId;
+    const entryIds = new Set();
     return {
         name: "@patchwork/service-worker",
         enforce: "pre",
         async buildStart() {
-            const resolved = await this.resolve("@inkandswitch/patchwork-bootloader/service-worker");
-            swEntryId = resolved.id;
-            this.emitFile({
-                type: "chunk",
-                id: resolved.id,
-                fileName: "service-worker.js",
-            });
+            for (const { specifier, fileName } of workers) {
+                const resolved = await this.resolve(specifier);
+                entryIds.add(resolved.id);
+                this.emitFile({
+                    type: "chunk",
+                    id: resolved.id,
+                    fileName,
+                });
+            }
         },
         resolveId(source, importer) {
-            if (importer && swEntryId && importer === swEntryId && source in builtins) {
+            if (importer && entryIds.has(importer) && source in builtins) {
                 return { id: builtins[source], external: true };
             }
         },