@inkandswitch/patchwork-bootloader 0.0.9 → 0.1.1

package/CHANGELOG.md

@@ -1,5 +1,28 @@
 # @inkandswitch/patchwork-bootloader
 
+## 0.1.0
+
+### Minor Changes
+
+- e6afa48: Add `@inkandswitch/patchwork-bootloader/site` entry point exporting
+  `bootPatchworkSite(config)`, a full browser-app boot sequence that constructs
+  the Repo, wires the service-worker port, loads plugins via the ModuleWatcher,
+  resolves the user's account, and installs URL-hash routing + dev globals. This
+  lets per-site `main.ts` collapse to a ~10-line config object and keeps two
+  sibling sites from drifting apart.
+
+  Also removes the unused `@inkandswitch/patchwork-bootloader` devDependency from
+  `@inkandswitch/patchwork-plugins`, which eliminated a cyclic workspace edge.
+
+### Patch Changes
+
+- a847c4f: release
+- Updated dependencies [e6afa48]
+- Updated dependencies [a847c4f]
+  - @inkandswitch/patchwork-plugins@0.0.8
+  - @inkandswitch/patchwork-elements@0.0.8
+  - @inkandswitch/patchwork-filesystem@0.0.6
+
 ## 0.0.4
 
 ### Patch Changes

package/dist/externals.js

@@ -9,6 +9,9 @@ const externals = [
     "@automerge/automerge-repo-network-messagechannel",
     "@automerge/automerge-repo-storage-indexeddb",
     "@automerge/automerge-repo-keyhive",
+    "@automerge/automerge-repo-react-hooks",
+    "@automerge/automerge-repo-network-messagechannel",
+    "@automerge/automerge-repo-storage-indexeddb",
     "@automerge/automerge-subduction",
     "@automerge/automerge-subduction/slim",
     "@keyhive/keyhive",

package/dist/service-worker.js

@@ -6,21 +6,22 @@ import { SwLogger } from "./sw-logger.js";
 // Uses /slim to avoid top-level await (disallowed in service workers).
 // Wasm is fetched from /automerge.wasm (emitted by the vite plugin) instead
 // of bundling the ~3MB base64 string.
-import { initializeWasm } from "@automerge/automerge/slim";
+import { initializeWasm, hasHeads } from "@automerge/automerge/slim";
 // 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";
 import { WebCryptoSigner } from "@automerge/automerge-subduction/slim";
 import { Repo, isValidAutomergeUrl, parseAutomergeUrl, stringifyAutomergeUrl, } from "@automerge/automerge-repo/slim";
-import { findHandleInFolderHandle, resolvePackageExport, } from "@inkandswitch/patchwork-filesystem";
+import { resolvePath } from "@inkandswitch/patchwork-filesystem";
 // Small adapters — bundled directly into the SW
 import { IndexedDBStorageAdapter } from "@automerge/automerge-repo-storage-indexeddb";
 import { MessageChannelNetworkAdapter } from "@automerge/automerge-repo-network-messagechannel";
-import { WebSocketClientAdapter } from "@automerge/automerge-repo-network-websocket";
 // TEMPORARY: enable debug npm module in SW context (no localStorage available)
 let cachename = "default";
 let debugging = false;
+const workerInstanceId = crypto.randomUUID();
 const SUBDUCTION_ENDPOINTS = ["wss://subduction.sync.inkandswitch.com"];
+const RESOLVE_TIMEOUT_MS = 30_000;
 // ── Persistent logger ───────────────────────────────────────────────────
 // Initialized eagerly so it's available for the entire SW lifetime.
 // Access from the SW inspector console via self.printLogs(), self.tailLogs(),
@@ -46,9 +47,7 @@ const slog = SwLogger.open().then((logger) => {
     logger.info("sw-logger initialized");
     return logger;
 });
-const cacheableStatuses = [
-    200, 203, 204, 206, 300, 301, 404, 405, 410, 414, 501,
-];
+const cacheableStatuses = [200, 203, 204, 206];
 function log(...args) {
     if (!debugging)
         return;
@@ -72,11 +71,12 @@ self.addEventListener("activate", async () => {
 let repoPromise = null;
 function getRepo() {
     if (!repoPromise) {
-        repoPromise = (async () => {
+        const p = (async () => {
             const logger = await slog;
+            logger.info("getRepo: starting");
             logger.info("fetching wasm modules");
             const [amWasmBuf, sdnWasmBuf] = await Promise.all([
-                fetch("/automerge.wasm").then((r) => r.arrayBuffer()),
+                fetch("/automerge.wasm?sw").then((r) => r.arrayBuffer()),
                 fetch("/subduction.wasm").then((r) => r.arrayBuffer()),
             ]);
             initSubductionSync(new Uint8Array(sdnWasmBuf));
@@ -93,7 +93,7 @@ function getRepo() {
                 },
                 enableRemoteHeadsGossiping: true,
                 subductionWebsocketEndpoints: SUBDUCTION_ENDPOINTS,
-                network: [new WebSocketClientAdapter("wss://sync3.automerge.org")],
+                //network: [new WebSocketClientAdapter("wss://sync3.automerge.org")],
             });
             self.repo = repo;
             logger.info("repo constructed, waiting for network subsystem");
@@ -106,6 +106,14 @@ function getRepo() {
             });
             return repo;
         })();
+        // If construction fails (e.g. wasm fetch errors out because the SW was
+        // terminated mid-flight), don't permanently cache the rejection — clear
+        // the slot so the next caller can retry from scratch.
+        p.catch(() => {
+            if (repoPromise === p)
+                repoPromise = null;
+        });
+        repoPromise = p;
     }
     return repoPromise;
 }
@@ -122,19 +130,36 @@ self.addEventListener("message", async (event) => {
         const [pongPort] = event.ports;
         log("ping");
         if (pongPort) {
-            pongPort.postMessage({ type: "pong" });
+            pongPort.postMessage({ type: "pong", workerInstanceId });
             log("pong");
             pongPort.close();
         }
         else if (event.source) {
-            event.source.postMessage({ type: "pong" });
+            event.source.postMessage({
+                type: "pong",
+                workerInstanceId,
+            });
             log("pong");
         }
     }
     else if (event.data.type == "port") {
         log("received messagechannel");
         const [port] = event.ports;
-        connectPort(port);
+        const source = event.source;
+        const id = event.data.id;
+        // event.waitUntil keeps the SW alive until the work completes. Without
+        // it, the browser can terminate the SW the moment this synchronous block
+        // returns, killing the in-flight wasm fetch.
+        event.waitUntil(connectPort(port).then(() => source?.postMessage({ type: "port-ready", id, workerInstanceId }), (err) => {
+            console.error("connectPort failed", err);
+            // Tell the client we failed so it doesn't hang forever.
+            source?.postMessage({
+                type: "port-failed",
+                id,
+                error: String(err),
+                workerInstanceId,
+            });
+        }));
     }
     else if (event.data.type == "cachename") {
         const nextCachename = event.data.cachename;
@@ -161,10 +186,10 @@ async function resolveAutomergeUrl(automergeURL) {
     // Trim trailing empty path segment
     if (path.length && !path[path.length - 1])
         path.pop();
-    const { heads, documentId } = parseAutomergeUrl(maybeAutomergeUrl);
+    const { heads, hexHeads, documentId } = parseAutomergeUrl(maybeAutomergeUrl);
+    const signal = AbortSignal.timeout(RESOLVE_TIMEOUT_MS);
     if (!heads) {
-        // Redirect to pinned-heads URL
-        const folder = await repo.find(maybeAutomergeUrl);
+        const folder = await repo.find(maybeAutomergeUrl, { signal });
         const latestHeads = folder.heads();
         const url = stringifyAutomergeUrl({ documentId, heads: latestHeads });
         let location = `/${encodeURIComponent(url)}`;
@@ -172,67 +197,24 @@ async function resolveAutomergeUrl(automergeURL) {
             location += `/${path.join("/")}`;
         return Response.redirect(location, 307);
     }
-    // If no path, check if this is a package with exports to resolve
-    // e.g. /automerge%3Adocid/abc → resolve "abc" via package.json exports
-    const folderHandle = await repo.find(maybeAutomergeUrl);
-    let fileHandle;
-    if (path.length) {
-        // Try direct file navigation first
-        fileHandle = await findHandleInFolderHandle(repo, folderHandle, path.map(decodeURIComponent));
-        // If not found as a direct path, try resolving as a package subpath export
-        // e.g. /automerge%3Adocid/abc → exports["./abc"] → "./dist/abc.js"
-        if (!fileHandle) {
-            const subpath = "./" + path.map(decodeURIComponent).join("/");
-            const pkgFileHandle = await findHandleInFolderHandle(repo, folderHandle, ["package.json"]);
-            if (pkgFileHandle) {
-                const pkgDoc = pkgFileHandle.doc();
-                if (pkgDoc?.content) {
-                    const pkgJson = JSON.parse(String(pkgDoc.content));
-                    try {
-                        const resolved = resolvePackageExport(pkgJson, subpath);
-                        if (resolved) {
-                            const resolvedPath = resolved.replace(/^\.\//, "").split("/");
-                            fileHandle = await findHandleInFolderHandle(repo, folderHandle, resolvedPath);
-                        }
-                    }
-                    catch {
-                        // not a valid export subpath, fall through to error
-                    }
-                }
-            }
-        }
-    }
-    else {
-        // No path — resolve the root export (like "." in package.json)
-        const pkgFileHandle = await findHandleInFolderHandle(repo, folderHandle, ["package.json"]);
-        if (pkgFileHandle) {
-            const pkgDoc = pkgFileHandle.doc();
-            if (pkgDoc?.content) {
-                const pkgJson = JSON.parse(String(pkgDoc.content));
-                try {
-                    const resolved = resolvePackageExport(pkgJson);
-                    if (resolved) {
-                        const resolvedPath = resolved.replace(/^\.\//, "").split("/");
-                        fileHandle = await findHandleInFolderHandle(repo, folderHandle, resolvedPath);
-                    }
-                }
-                catch { }
-            }
-        }
+    // Load by documentId only so we can verify the requested heads are actually
+    // in our local history. repo.find with a heads-bearing URL returns a view
+    // at those heads, which silently materializes garbage if we never synced them.
+    const baseHandle = await repo.find(stringifyAutomergeUrl({ documentId }), {
+        signal,
+    });
+    if (!hasHeads(baseHandle.doc(), hexHeads ?? [])) {
+        return new Response("heads not found", { status: 404 });
     }
-    if (!fileHandle) {
+    const rootHandle = baseHandle.view(heads);
+    const resolved = await resolvePath(repo, rootHandle, path.map(decodeURIComponent));
+    if (!resolved) {
         throw new Error(`couldn't resolve ${path.join("/")} in folder at ${maybeAutomergeUrl}`);
     }
-    const fileDoc = fileHandle.doc();
-    const content = fileDoc?.content;
-    if (!content) {
-        throw new Error(`file at ${href} has no content`);
-    }
-    let body = content instanceof Uint8Array
-        ? new Uint8Array(content)
-        : String(content);
-    const mimeType = fileDoc.mimeType ?? "text/plain";
-    const headers = new Headers({ "content-type": mimeType });
+    const body = resolved.content instanceof Uint8Array
+        ? new Uint8Array(resolved.content)
+        : resolved.content;
+    const headers = new Headers({ "content-type": resolved.type });
     headers.set("cross-origin-embedder-policy", "credentialless");
     headers.set("cross-origin-resource-policy", "cross-origin");
     return new Response(body, { status: 200, headers });
@@ -269,7 +251,10 @@ self.addEventListener("fetch", (fetchEvent) => {
                         headers,
                     });
                 }
-                const response = await resolveAutomergeUrl(specialURL);
+                const response = await Promise.race([
+                    resolveAutomergeUrl(specialURL),
+                    new Promise((_, reject) => setTimeout(() => reject(new Error(`resolve timeout after ${RESOLVE_TIMEOUT_MS}ms`)), RESOLVE_TIMEOUT_MS)),
+                ]);
                 if (response.status === 307) {
                     return response;
                 }

package/dist/setup.d.ts

@@ -1,5 +1,3 @@
-import type { SetupServiceWorkerOptions } from "./types.js";
+import type { SetupServiceWorkerOptions, SetupServiceWorkerResult } from "./types.js";
 export declare function bumpServiceWorkerCache(sw?: ServiceWorker | null): void;
-export default function setupServiceWorker(options?: SetupServiceWorkerOptions): Promise<{
-    port: MessagePort;
-}>;
+export default function setupServiceWorker(options?: SetupServiceWorkerOptions): Promise<SetupServiceWorkerResult>;

package/dist/setup.js

@@ -1,6 +1,8 @@
 import debug from "debug";
 const debugging = debug.enabled("patchwork:serviceworker");
 const key = "patchworkServiceWorkerCacheVersion";
+let nextRepoChannelId = 0;
+let serviceWorkerInstanceId;
 function bumpServiceWorkerCacheVersion() {
     const version = new Date().valueOf().toString(36);
     localStorage.setItem(key, version);
@@ -29,6 +31,21 @@ export function bumpServiceWorkerCache(sw = navigator.serviceWorker.controller)
     setServiceWorkerCacheName(sw);
 }
 window.bumpServiceWorkerCache = bumpServiceWorkerCache;
+function configureServiceWorker(sw) {
+    if (!sw)
+        return;
+    sw.postMessage({ type: "debug", debug: debugging });
+    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;
+}
 /** Wait for a registration to have an active worker */
 function waitForActive(reg) {
     if (reg.active)
@@ -43,51 +60,154 @@ 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
+    // 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).
+    const id = ++nextRepoChannelId;
+    let workerInstanceChanged = false;
+    const { port1, port2 } = new MessageChannel();
+    const swReady = new Promise((resolve, reject) => {
+        let timeout;
+        const cleanup = () => {
+            clearTimeout(timeout);
+            navigator.serviceWorker.removeEventListener("message", listener);
+        };
+        const listener = (event) => {
+            if (event.data?.id != null && 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}`));
+            }
+        };
+        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
+        // blank page.
+        timeout = setTimeout(() => {
+            cleanup();
+            reject(new Error("service worker port-ready timeout"));
+        }, 30_000);
+    });
+    controller.postMessage({ type: "port", id }, [port2]);
+    try {
+        await swReady;
+    }
+    catch (err) {
+        console.warn("proceeding without SW ready ack:", err instanceof Error ? err.message : err);
+    }
+    return { port: port1, workerInstanceChanged };
+}
 export default async function setupServiceWorker(options) {
-    // Backwards compat: if an old service worker sends handoff "request" messages,
-    // immediately reject them so its fetch handler doesn't hang forever.
-    navigator.serviceWorker.addEventListener("message", (event) => {
-        if (event.data?.type === "request" && event.data.id != null) {
-            navigator.serviceWorker.controller?.postMessage({
-                type: "response",
-                id: event.data.id,
-                response: {
-                    body: "service worker upgraded, please refresh",
-                    status: 503,
-                    headers: { "content-type": "text/plain" },
-                },
-            });
+    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);
+        }
+    };
     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
+    // activation so the app boots with the SW in control of generated fetches.
     const reg = await navigator.serviceWorker.register(path, { type: "module" });
     // If there's an update waiting or installing, wait for it to activate
+    let active = reg.active;
     if (reg.installing || reg.waiting) {
-        await waitForActive(reg);
+        active = await waitForActive(reg);
     }
-    const active = reg.active;
-    active.postMessage({ type: "debug", debug: debugging });
+    configureServiceWorker(active);
     // Wait for the controller to be available
     if (!navigator.serviceWorker.controller) {
         await new Promise((resolve) => {
             navigator.serviceWorker.addEventListener("controllerchange", () => resolve(), { once: true });
         });
     }
-    // Send a MessagePort so the SW's repo can sync with clients
-    const { port1, port2 } = new MessageChannel();
-    navigator.serviceWorker.controller.postMessage({ type: "port" }, [port2]);
     // 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. Send a ping every 20s while the page is visible to keep it warm.
+    // 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(() => {
-        navigator.serviceWorker.controller?.postMessage({ type: "ping" });
+        void pingServiceWorker();
     }, 20_000);
-    // Reload on future SW updates (added after setup so the initial
-    // activation doesn't trigger a reload loop).
+    // Reconnect on future SW updates (added after setup so the initial
+    // activation doesn't notify before callers subscribe).
     navigator.serviceWorker.addEventListener("controllerchange", function () {
-        console.info("%cnew service worker took control, reloading...", "color: pink; font-weight: bold");
-        location.reload();
+        void reconnectRepoChannels("took control").catch((err) => {
+            console.error("service worker reconnect failed", err);
+        });
     });
     console.log("service worker alive, loading %c patchwork system ", "background: #fcf2f0; color: #333; border: 2px solid; border-radius: 4px");
-    return { port: port1 };
+    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);
+        },
+    };
 }

package/dist/site.d.ts

@@ -15,6 +15,7 @@ import { type DocHandle, Repo, type AutomergeUrl, type StorageId } from "@autome
 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 {
@@ -22,10 +23,9 @@ declare global {
         Automerge: typeof import("@automerge/automerge");
         AutomergeRepo: typeof import("@automerge/automerge-repo");
         repo: Repo;
-        getRepoChannel: () => MessagePort;
         patchwork: {
             repo: Repo;
-            modules: ModuleWatcher;
+            packages: ModuleWatcher;
             plugins: typeof plugins;
             accountDocHandle: DocHandle<AccountDoc>;
             sw: {
@@ -33,6 +33,7 @@ declare global {
                 tailLogs: (n?: number) => ReturnType<typeof SwLogReader.tail>;
                 exportLogs: () => Promise<string>;
                 clearLogs: () => Promise<void>;
+                subscribeToRepoChannel: (listener: ServiceWorkerRepoChannelListener) => Promise<() => void>;
             };
         };
         uncache: (match: string) => Promise<void>;

package/dist/site.js

@@ -19,13 +19,19 @@ import * as AutomergeRepo from "@automerge/automerge-repo/slim";
 import { initSync as initSubductionSync } from "@automerge/automerge-subduction/slim";
 import { ModuleWatcher } from "@inkandswitch/patchwork-filesystem";
 import { openDocument, registerPatchworkViewElement, } from "@inkandswitch/patchwork-elements";
-import { getRegistry, registerPlugins, resolveAccountHandle, } from "@inkandswitch/patchwork-plugins";
+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";
 // Legacy big-patchwork hash shape: `slug--<documentId>[?=type]`.
 const BIG_PATCHWORK_HASH_REGEX = /(?<title>[A-Za-z0-9-]+)--(?<docId>[1-9A-HJ-NP-Za-km-z]+)(?<type>\?=[^&?]+)?/;
+const [automergeWasm, subductionWasm] = await Promise.all([
+    fetch("/automerge.wasm?main").then((r) => r.bytes()),
+    fetch("/subduction.wasm").then((r) => r.bytes()),
+]);
 /**
  * Boot a Patchwork browser site.
  *
@@ -37,11 +43,8 @@ const BIG_PATCHWORK_HASH_REGEX = /(?<title>[A-Za-z0-9-]+)--(?<docId>[1-9A-HJ-NP-
  */
 export async function bootPatchworkSite(config) {
     const defaultModulesUrl = resolveDefaultModulesUrl(config.defaultModulesUrl);
-    // Fetch both Wasm binaries in parallel, then compile
-    const [automergeWasm, subductionWasm] = await Promise.all([
-        fetch("/automerge.wasm").then((r) => r.bytes()),
-        fetch("/subduction.wasm").then((r) => r.bytes()),
-    ]);
+    showLoadingAnimation();
+    log(`booting`, config);
     await initializeWasm(automergeWasm);
     initSubductionSync(subductionWasm);
     const repo = new Repo({
@@ -50,21 +53,29 @@ export async function bootPatchworkSite(config) {
             return peerId.includes("service-worker");
         },
         enableRemoteHeadsGossiping: true,
+        peerId: `${config.titleSuffix}-tab-${crypto.randomUUID()}`,
     });
     repo.subscribeToRemotes(config.remoteStorageIds ?? [DEFAULT_REMOTE_STORAGE_ID]);
     const sw = await setupServiceWorker();
     if (!sw)
         throw new Error("Failed to set up service worker");
-    const net = new MessageChannelNetworkAdapter(sw.port);
-    repo.networkSubsystem.addNetworkAdapter(net);
-    await net.whenReady();
+    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);
     registerPatchworkViewElement({ repo });
     // The watcher is started with the site's default-tools bundle alone so that
     // `resolveAccountHandle` below has something to await on (the `account`
     // 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, [defaultModulesUrl], onModuleLoaded);
+    const moduleWatcher = new ModuleWatcher(repo, { system: defaultModulesUrl }, onModuleLoaded, unregisterPlugins);
     const accountDocHandle = await resolveAccountHandle(repo, {
         storageKey: config.accountStorageKey,
     });
@@ -78,10 +89,13 @@ export async function bootPatchworkSite(config) {
     logToolRegistryWhenLoaded(moduleWatcher);
     window.patchwork = {
         repo,
-        modules: moduleWatcher,
+        packages: moduleWatcher,
         plugins,
         accountDocHandle,
-        sw: buildSwLogApi(),
+        sw: {
+            ...buildSwLogApi(),
+            subscribeToRepoChannel: sw.subscribeToRepoChannel,
+        },
     };
     window.uncache = uncache;
     installHashRouting({
@@ -111,19 +125,14 @@ function installDevConsoleGlobals(repo) {
     window.repo = repo;
     window.Automerge = Automerge;
     window.AutomergeRepo = AutomergeRepo;
-    window.getRepoChannel = () => {
-        const { port1, port2 } = new MessageChannel();
-        navigator.serviceWorker.controller.postMessage({ type: "port" }, [port2]);
-        return port1;
-    };
 }
 function onModuleLoaded(name, mod) {
     if (Array.isArray(mod.plugins)) {
-        console.log(`[site] registering ${mod.plugins.length} plugin(s) from ${name.slice(0, 30)}...`, mod.plugins.map((p) => `${p.type}:${p.id}`));
+        log(`registering ${mod.plugins.length} plugin(s) from ${name.slice(0, 30)}...`, mod.plugins.map((p) => `${p.type}:${p.id}`));
         registerPlugins(mod.plugins, name);
     }
     else {
-        console.warn(`[site] module ${name.slice(0, 30)}... has no plugins array`, Object.keys(mod));
+        console.warn(`module ${name.slice(0, 30)}... has no plugins array`, Object.keys(mod));
     }
 }
 /**
@@ -136,7 +145,7 @@ function wireModuleSettingsWhenReady(accountDocHandle, moduleWatcher) {
         const url = accountDocHandle.doc()?.moduleSettingsUrl;
         if (!url)
             return;
-        void moduleWatcher.addUrl(url);
+        void moduleWatcher.addUrl("user", url);
         accountDocHandle.off("change", wire);
     };
     wire();
@@ -151,7 +160,6 @@ function wireModuleSettingsWhenReady(accountDocHandle, moduleWatcher) {
  */
 function primeRootElement(rootElement, accountDocHandle) {
     rootElement.style.visibility = "hidden";
-    showLoadingAnimation();
     const initialParams = new URLSearchParams(location.hash.slice(1));
     if (initialParams.has("frame")) {
         rootElement.setAttribute("tool-id", initialParams.get("frame"));
@@ -171,10 +179,10 @@ function logToolRegistryWhenLoaded(moduleWatcher) {
         .then(() => {
         const toolReg = getRegistry("patchwork:tool");
         const tools = toolReg.all();
-        console.log(`[site] doneLoading: ${tools.length} tools registered:`, tools.map((t) => t.id));
+        log(`doneLoading: ${tools.length} tools registered:`, tools.map((t) => t.id));
     })
         .catch((err) => {
-        console.error("[site] doneLoading rejected:", err);
+        console.error("doneLoading rejected:", err);
     });
 }
 function buildSwLogApi() {
@@ -184,11 +192,11 @@ function buildSwLogApi() {
             for (const e of entries) {
                 const prefix = `[${e.ts}] [${e.level}]`;
                 if (e.data !== undefined)
-                    console.log(prefix, e.msg, e.data);
+                    log(prefix, e.msg, e.data);
                 else
-                    console.log(prefix, e.msg);
+                    log(prefix, e.msg);
             }
-            console.log(`--- ${entries.length} entries ---`);
+            log(`--- ${entries.length} entries ---`);
         },
         tailLogs: (n = 200) => SwLogReader.tail(n),
         exportLogs: () => SwLogReader.exportAll(),
@@ -218,6 +226,10 @@ function showLoadingAnimation() {
           radial-gradient(ellipse 65% 55% at 50% 50%, #f1e6f6, transparent 80%);
         animation: pw-bootloader-pulse 3.5s ease-in-out infinite;
         transition: opacity 0.6s ease-out;
+        top: 0;
+        left: 0;
+        right: 0;
+        bottom: 0;
       }
       @media (prefers-color-scheme: dark) {
         #${LOADING_ELEMENT_ID} {

package/dist/types.d.ts

@@ -5,3 +5,7 @@ export type SetupServiceWorkerOptions = {
      */
     path?: string;
 };
+export type ServiceWorkerRepoChannelListener = (port: MessagePort) => void | Promise<void>;
+export type SetupServiceWorkerResult = {
+    subscribeToRepoChannel: (listener: ServiceWorkerRepoChannelListener) => Promise<() => void>;
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@inkandswitch/patchwork-bootloader",
-  "version": "0.0.9",
+  "version": "0.1.1",
   "author": "chee",
   "type": "module",
   "license": "MIT",
@@ -40,27 +40,27 @@
     }
   },
   "dependencies": {
-    "@automerge/automerge": "3.2.5",
-    "@automerge/automerge-repo": "2.6.0-subduction.15",
-    "@automerge/automerge-subduction": "0.8.1",
-    "@automerge/automerge-repo-network-messagechannel": "2.6.0-subduction.15",
-    "@automerge/automerge-repo-network-websocket": "2.6.0-subduction.15",
-    "@automerge/automerge-repo-storage-indexeddb": "2.6.0-subduction.15",
-    "@automerge/vanillajs": "2.6.0-subduction.15",
+    "@automerge/automerge": "3.2.6",
+    "@automerge/automerge-repo": "2.6.0-subduction.20",
+    "@automerge/automerge-subduction": "0.12.1",
+    "@automerge/automerge-repo-network-messagechannel": "2.6.0-subduction.20",
+    "@automerge/automerge-repo-network-websocket": "2.6.0-subduction.20",
+    "@automerge/automerge-repo-storage-indexeddb": "2.6.0-subduction.20",
+    "@automerge/vanillajs": "2.6.0-subduction.20",
     "@types/debug": "^4.1.12",
     "debug": "^4.4.3",
     "resolve.exports": "^2.0.3",
     "service-worker-types": "npm:@types/serviceworker@^0.0.153",
     "tinyargs": "^0.1.4",
-    "@inkandswitch/patchwork-elements": "^0.0.7",
-    "@inkandswitch/patchwork-filesystem": "^0.0.5",
-    "@inkandswitch/patchwork-plugins": "^0.0.7"
+    "@inkandswitch/patchwork-elements": "^0.0.8",
+    "@inkandswitch/patchwork-plugins": "^0.0.8",
+    "@inkandswitch/patchwork-filesystem": "^0.0.7"
   },
   "peerDependencies": {
-    "@automerge/automerge": "3.2.5",
-    "@automerge/automerge-repo": "2.6.0-subduction.15",
+    "@automerge/automerge": "3.2.6",
+    "@automerge/automerge-repo": "2.6.0-subduction.20",
     "@automerge/automerge-repo-keyhive": "0.2.0-alpha.1d",
-    "@automerge/vanillajs": "2.6.0-subduction.15"
+    "@automerge/vanillajs": "2.6.0-subduction.20"
   },
   "scripts": {
     "build": "tsc",

package/src/externals.ts

@@ -9,6 +9,9 @@ const externals = [
   "@automerge/automerge-repo-network-messagechannel",
   "@automerge/automerge-repo-storage-indexeddb",
   "@automerge/automerge-repo-keyhive",
+  "@automerge/automerge-repo-react-hooks",
+  "@automerge/automerge-repo-network-messagechannel",
+  "@automerge/automerge-repo-storage-indexeddb",
   "@automerge/automerge-subduction",
   "@automerge/automerge-subduction/slim",
   "@keyhive/keyhive",

package/src/service-worker.ts

@@ -8,7 +8,7 @@ import { SwLogger } from "./sw-logger.js";
 // Uses /slim to avoid top-level await (disallowed in service workers).
 // Wasm is fetched from /automerge.wasm (emitted by the vite plugin) instead
 // of bundling the ~3MB base64 string.
-import { initializeWasm } from "@automerge/automerge/slim";
+import { initializeWasm, hasHeads } from "@automerge/automerge/slim";
 // 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";
@@ -31,6 +31,7 @@ import { WebSocketClientAdapter } from "@automerge/automerge-repo-network-websoc
 // TEMPORARY: enable debug npm module in SW context (no localStorage available)
 let cachename = "default";
 let debugging = false;
+const workerInstanceId = crypto.randomUUID();
 
 const SUBDUCTION_ENDPOINTS = ["wss://subduction.sync.inkandswitch.com"];
 const RESOLVE_TIMEOUT_MS = 30_000;
@@ -166,27 +167,36 @@ self.addEventListener("message", async (event) => {
     const [pongPort] = event.ports;
     log("ping");
     if (pongPort) {
-      pongPort.postMessage({ type: "pong" });
+      pongPort.postMessage({ type: "pong", workerInstanceId });
       log("pong");
       pongPort.close();
     } else if (event.source) {
-      (event.source as unknown as Client).postMessage({ type: "pong" });
+      (event.source as unknown as Client).postMessage({
+        type: "pong",
+        workerInstanceId,
+      });
       log("pong");
     }
   } else if (event.data.type == "port") {
     log("received messagechannel");
     const [port] = event.ports;
     const source = event.source as Client | null;
+    const id = event.data.id;
     // event.waitUntil keeps the SW alive until the work completes. Without
     // it, the browser can terminate the SW the moment this synchronous block
     // returns, killing the in-flight wasm fetch.
     (event as unknown as FetchEvent).waitUntil(
       connectPort(port).then(
-        () => source?.postMessage({ type: "port-ready" }),
+        () => source?.postMessage({ type: "port-ready", id, workerInstanceId }),
         (err) => {
           console.error("connectPort failed", err);
           // Tell the client we failed so it doesn't hang forever.
-          source?.postMessage({ type: "port-failed", error: String(err) });
+          source?.postMessage({
+            type: "port-failed",
+            id,
+            error: String(err),
+            workerInstanceId,
+          });
         }
       )
     );
@@ -220,7 +230,7 @@ async function resolveAutomergeUrl(automergeURL: URL): Promise<Response> {
   // Trim trailing empty path segment
   if (path.length && !path[path.length - 1]) path.pop();
 
-  const { heads, documentId } = parseAutomergeUrl(maybeAutomergeUrl);
+  const { heads, hexHeads, documentId } = parseAutomergeUrl(maybeAutomergeUrl);
   const signal = AbortSignal.timeout(RESOLVE_TIMEOUT_MS);
 
   if (!heads) {
@@ -232,7 +242,16 @@ async function resolveAutomergeUrl(automergeURL: URL): Promise<Response> {
     return Response.redirect(location, 307);
   }
 
-  const rootHandle = await repo.find(maybeAutomergeUrl, { signal });
+  // Load by documentId only so we can verify the requested heads are actually
+  // in our local history. repo.find with a heads-bearing URL returns a view
+  // at those heads, which silently materializes garbage if we never synced them.
+  const baseHandle = await repo.find(stringifyAutomergeUrl({ documentId }), {
+    signal,
+  });
+  if (!hasHeads(baseHandle.doc(), hexHeads ?? [])) {
+    return new Response("heads not found", { status: 404 });
+  }
+  const rootHandle = baseHandle.view(heads);
 
   const resolved = await resolvePath(
     repo,

package/src/setup.ts

@@ -1,9 +1,15 @@
-import type { SetupServiceWorkerOptions } from "./types.js";
+import type {
+  ServiceWorkerRepoChannelListener,
+  SetupServiceWorkerOptions,
+  SetupServiceWorkerResult,
+} from "./types.js";
 import debug from "debug";
 
 const debugging = debug.enabled("patchwork:serviceworker");
 
 const key = "patchworkServiceWorkerCacheVersion";
+let nextRepoChannelId = 0;
+let serviceWorkerInstanceId: string | undefined;
 
 function bumpServiceWorkerCacheVersion() {
   const version = new Date().valueOf().toString(36);
@@ -40,6 +46,21 @@ export function bumpServiceWorkerCache(
 
 (window as any).bumpServiceWorkerCache = bumpServiceWorkerCache;
 
+function configureServiceWorker(sw: ServiceWorker | null) {
+  if (!sw) return;
+  sw.postMessage({ type: "debug", debug: debugging });
+  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;
+}
+
 /** Wait for a registration to have an active worker */
 function waitForActive(reg: ServiceWorkerRegistration): Promise<ServiceWorker> {
   if (reg.active) return Promise.resolve(reg.active);
@@ -53,50 +74,13 @@ function waitForActive(reg: ServiceWorkerRegistration): Promise<ServiceWorker> {
   });
 }
 
-export default async function setupServiceWorker(
-  options?: SetupServiceWorkerOptions
-) {
-  // Backwards compat: if an old service worker sends handoff "request" messages,
-  // immediately reject them so its fetch handler doesn't hang forever.
-  navigator.serviceWorker.addEventListener("message", (event) => {
-    if (event.data?.type === "request" && event.data.id != null) {
-      navigator.serviceWorker.controller?.postMessage({
-        type: "response",
-        id: event.data.id,
-        response: {
-          body: "service worker upgraded, please refresh",
-          status: 503,
-          headers: { "content-type": "text/plain" },
-        },
-      });
-    }
-  });
-
-  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). We'll
-  // reload after activation so the page boots with the SW in control of its
-  // initial fetches.
-  //const isFirstInstall = !navigator.serviceWorker.controller;
-  const reg = await navigator.serviceWorker.register(path, { type: "module" });
-
-  // If there's an update waiting or installing, wait for it to activate
-  if (reg.installing || reg.waiting) {
-    await waitForActive(reg);
-  }
-
-  const active = reg.active!;
-  active.postMessage({ type: "debug", debug: debugging });
-
-  // Wait for the controller to be available
-  if (!navigator.serviceWorker.controller) {
-    await new Promise<void>((resolve) => {
-      navigator.serviceWorker.addEventListener(
-        "controllerchange",
-        () => resolve(),
-        { once: true }
-      );
-    });
+async function openRepoChannel(): Promise<{
+  port: MessagePort;
+  workerInstanceChanged: boolean;
+}> {
+  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
@@ -104,6 +88,8 @@ export default async function setupServiceWorker(
   // 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).
+  const id = ++nextRepoChannelId;
+  let workerInstanceChanged = false;
   const { port1, port2 } = new MessageChannel();
   const swReady = new Promise<void>((resolve, reject) => {
     let timeout: ReturnType<typeof setTimeout>;
@@ -112,10 +98,17 @@ export default async function setupServiceWorker(
       navigator.serviceWorker.removeEventListener("message", listener);
     };
     const listener = (event: MessageEvent) => {
+      if (event.data?.id != null && 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}`));
       }
@@ -129,7 +122,7 @@ export default async function setupServiceWorker(
       reject(new Error("service worker port-ready timeout"));
     }, 30_000);
   });
-  navigator.serviceWorker.controller!.postMessage({ type: "port" }, [port2]);
+  controller.postMessage({ type: "port", id }, [port2]);
   try {
     await swReady;
   } catch (err) {
@@ -138,22 +131,105 @@ export default async function setupServiceWorker(
       err instanceof Error ? err.message : err
     );
   }
+  return { port: port1, workerInstanceChanged };
+}
+
+export default async function setupServiceWorker(
+  options?: SetupServiceWorkerOptions
+): Promise<SetupServiceWorkerResult> {
+  const repoChannelListeners = new Set<ServiceWorkerRepoChannelListener>();
+  let reconnectPromise: Promise<void> | null = null;
+
+  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
+      );
+    }
+  };
+
+  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
+  // activation so the app boots with the SW in control of generated fetches.
+  const reg = await navigator.serviceWorker.register(path, { type: "module" });
+
+  // If there's an update waiting or installing, wait for it to activate
+  let active = reg.active;
+  if (reg.installing || reg.waiting) {
+    active = await waitForActive(reg);
+  }
+
+  configureServiceWorker(active);
+
+  // Wait for the controller to be available
+  if (!navigator.serviceWorker.controller) {
+    await new Promise<void>((resolve) => {
+      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. Send a ping every 20s while the page is visible to keep it warm.
+  // 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(() => {
-    navigator.serviceWorker.controller?.postMessage({ type: "ping" });
+    void pingServiceWorker();
   }, 20_000);
 
-  // Reload on future SW updates (added after setup so the initial
-  // activation doesn't trigger a reload loop).
+  // Reconnect on future SW updates (added after setup so the initial
+  // activation doesn't notify before callers subscribe).
   navigator.serviceWorker.addEventListener("controllerchange", function () {
-    console.info(
-      "%cnew service worker took control, reloading...",
-      "color: pink; font-weight: bold"
-    );
-    location.reload();
+    void reconnectRepoChannels("took control").catch((err) => {
+      console.error("service worker reconnect failed", err);
+    });
   });
 
   console.log(
@@ -161,5 +237,20 @@ export default async function setupServiceWorker(
     "background: #fcf2f0; color: #333; border: 2px solid; border-radius: 4px"
   );
 
-  return { port: port1 };
+  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);
+    },
+  };
 }

package/src/site.ts

@@ -49,6 +49,7 @@ import {
 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");
@@ -59,7 +60,6 @@ declare global {
     Automerge: typeof import("@automerge/automerge");
     AutomergeRepo: typeof import("@automerge/automerge-repo");
     repo: Repo;
-    getRepoChannel: () => MessagePort;
     patchwork: {
       repo: Repo;
       packages: ModuleWatcher;
@@ -70,6 +70,9 @@ declare global {
         tailLogs: (n?: number) => ReturnType<typeof SwLogReader.tail>;
         exportLogs: () => Promise<string>;
         clearLogs: () => Promise<void>;
+        subscribeToRepoChannel: (
+          listener: ServiceWorkerRepoChannelListener
+        ) => Promise<() => void>;
       };
     };
     uncache: (match: string) => Promise<void>;
@@ -167,9 +170,16 @@ export async function bootPatchworkSite(
 
   const sw = await setupServiceWorker();
   if (!sw) throw new Error("Failed to set up service worker");
-  const net = new MessageChannelNetworkAdapter(sw.port);
-  repo.networkSubsystem.addNetworkAdapter(net);
-  await net.whenReady();
+  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);
   registerPatchworkViewElement({ repo });
@@ -208,7 +218,10 @@ export async function bootPatchworkSite(
     packages: moduleWatcher,
     plugins,
     accountDocHandle,
-    sw: buildSwLogApi(),
+    sw: {
+      ...buildSwLogApi(),
+      subscribeToRepoChannel: sw.subscribeToRepoChannel,
+    },
   };
   window.uncache = uncache;
 
@@ -246,11 +259,6 @@ function installDevConsoleGlobals(repo: Repo): void {
   window.repo = repo;
   window.Automerge = Automerge;
   window.AutomergeRepo = AutomergeRepo;
-  window.getRepoChannel = () => {
-    const { port1, port2 } = new MessageChannel();
-    navigator.serviceWorker.controller!.postMessage({ type: "port" }, [port2]);
-    return port1;
-  };
 }
 
 function onModuleLoaded(name: string, mod: any): void {
@@ -329,7 +337,10 @@ function logToolRegistryWhenLoaded(moduleWatcher: ModuleWatcher): void {
     });
 }
 
-function buildSwLogApi(): Window["patchwork"]["sw"] {
+function buildSwLogApi(): Omit<
+  Window["patchwork"]["sw"],
+  "subscribeToRepoChannel"
+> {
   return {
     printLogs: async (n = 200) => {
       const entries = await SwLogReader.tail(n);

package/src/types.ts

@@ -5,3 +5,13 @@ export type SetupServiceWorkerOptions = {
    */
   path?: string;
 };
+
+export type ServiceWorkerRepoChannelListener = (
+  port: MessagePort
+) => void | Promise<void>;
+
+export type SetupServiceWorkerResult = {
+  subscribeToRepoChannel: (
+    listener: ServiceWorkerRepoChannelListener
+  ) => Promise<() => void>;
+};