@inkandswitch/patchwork-bootloader 0.2.5 → 0.2.7

package/dist/service-worker.js

@@ -1,60 +1,28 @@
 /// <reference types="service-worker-types" />
-import { SwLogger } from "./sw-logger.js";
-// Heavy imports — marked external by the service-worker vite plugin,
-// resolved to /packages/... URLs at build time. The SW is registered with
-// type:"module" so the browser fetches these as regular network requests.
-// 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, 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 { 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)
+// The service worker holds no automerge repo — that lives in the automerge
+// SharedWorker (automerge-worker.ts). This worker manages the cache. When a
+// special URL misses the cache it broadcasts a handoff request; the
+// automerge worker resolves it, puts the response in our cache, and replies
+// "cached" (or "response" for errors and other things that shouldn't be
+// cached).
+import { HANDOFF_CHANNEL, } from "./types.js";
 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(),
-// self.exportLogs(), self.clearLogs().
-const slog = SwLogger.open().then((logger) => {
-    self.slog = logger;
-    self.printLogs = async (n = 200) => {
-        const entries = await logger.tail(n);
-        for (const e of entries) {
-            const prefix = `[${e.ts}] [${e.level}]`;
-            if (e.data !== undefined) {
-                console.log(prefix, e.msg, e.data);
-            }
-            else {
-                console.log(prefix, e.msg);
-            }
-        }
-        console.log(`--- ${entries.length} entries ---`);
-    };
-    self.tailLogs = (n = 200) => logger.tail(n);
-    self.exportLogs = () => logger.exportAll();
-    self.clearLogs = () => logger.clear();
-    logger.info("sw-logger initialized");
-    return logger;
-});
 const cacheableStatuses = [200, 203, 204, 206];
+// The automerge worker times its own resolution out after 30s and replies
+// with an error, so this only fires when nobody is listening at all.
+const HANDOFF_TIMEOUT_MS = 35_000;
 function log(...args) {
     if (!debugging)
         return;
     console.log.call(console, `%cpatchwork:serviceworker%c\n`, `color: #00ffcc; font-weight: bold`, "color: inherit", ...args);
 }
-self.addEventListener("install", () => self.skipWaiting());
+self.addEventListener("install", (event) => {
+    // waitUntil keeps the worker alive until skipWaiting resolves, so a freshly
+    // installed SW reliably jumps the "waiting" queue instead of stalling until
+    // every old tab closes.
+    event.waitUntil(self.skipWaiting());
+});
 async function clearOldCaches() {
     const cacheWhitelist = [cachename];
     const cacheNames = await caches.keys();
@@ -65,104 +33,17 @@ async function clearOldCaches() {
     });
     await Promise.all(deletePromises);
 }
-self.addEventListener("activate", async () => {
-    await clearOldCaches();
-    clients.claim();
+self.addEventListener("activate", (event) => {
+    // Without waitUntil the activate event settles immediately and clients.claim()
+    // runs detached — the new worker can be killed before it takes control, so
+    // existing tabs keep talking to the old SW. Extend the event instead.
+    event.waitUntil((async () => {
+        await clearOldCaches();
+        await self.clients.claim();
+    })());
 });
-let repoPromise = null;
-function getRepo() {
-    if (!repoPromise) {
-        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?sw").then((r) => r.arrayBuffer()),
-                fetch("/subduction.wasm").then((r) => r.arrayBuffer()),
-            ]);
-            initSubductionSync(new Uint8Array(sdnWasmBuf));
-            await initializeWasm(new Uint8Array(amWasmBuf));
-            logger.info("wasm initialized");
-            const signer = await WebCryptoSigner.setup();
-            const repo = new Repo({
-                storage: new IndexedDBStorageAdapter(),
-                signer,
-                peerId: ("service-worker-" +
-                    (Math.random() * 10000).toString(36).slice(2)),
-                async sharePolicy(peerId) {
-                    return peerId.includes("storage-server");
-                },
-                enableRemoteHeadsGossiping: true,
-                subductionWebsocketEndpoints: SUBDUCTION_ENDPOINTS,
-                network: [new WebSocketClientAdapter("wss://sync3.automerge.org")],
-            });
-            self.repo = repo;
-            logger.info("repo constructed, waiting for network subsystem");
-            // Don't block getRepo() on whenReady() — the network subsystem starts
-            // with only the subduction adapter, and the MessageChannel adapter is
-            // added later via connectPort (which awaits getRepo). Blocking here
-            // would deadlock that path and starve the fetch handler.
-            repo.networkSubsystem.whenReady().then(() => {
-                logger.info("repo network subsystem ready");
-            });
-            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;
-}
-// Connect client MessagePorts to the repo for sync
-async function connectPort(port) {
-    const repo = await getRepo();
-    repo.networkSubsystem.addNetworkAdapter(new MessageChannelNetworkAdapter(port, { useWeakRef: true }));
-}
 self.addEventListener("message", async (event) => {
-    if (event.data.type == "ping") {
-        // Keepalive — Chromium idles out service workers after ~30s of inactivity.
-        // Reply via the provided port if any; the message event itself also resets
-        // the idle timer.
-        const [pongPort] = event.ports;
-        log("ping");
-        if (pongPort) {
-            pongPort.postMessage({ type: "pong", workerInstanceId });
-            log("pong");
-            pongPort.close();
-        }
-        else if (event.source) {
-            event.source.postMessage({
-                type: "pong",
-                workerInstanceId,
-            });
-            log("pong");
-        }
-    }
-    else if (event.data.type == "port") {
-        log("received messagechannel");
-        const [port] = event.ports;
-        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") {
+    if (event.data.type == "cachename") {
         const nextCachename = event.data.cachename;
         if (cachename == nextCachename) {
             return;
@@ -176,49 +57,62 @@ self.addEventListener("message", async (event) => {
         log("serviceworker debugging enabled");
     }
 });
-// ── Automerge URL resolution ───────────────────────────────────────────
-async function resolveAutomergeUrl(automergeURL) {
-    const repo = await getRepo();
-    const href = automergeURL.href;
-    const [maybeAutomergeUrl, ...path] = href.split("/");
-    if (!isValidAutomergeUrl(maybeAutomergeUrl)) {
-        return new Response("invalid automerge url", { status: 400 });
+// ── Handoff to the automerge worker ────────────────────────────────────
+const handoffChannel = new BroadcastChannel(HANDOFF_CHANNEL);
+const pendingHandoffs = new Map();
+handoffChannel.addEventListener("message", (event) => {
+    const data = event.data;
+    if (data?.type === "cached" || data?.type === "response") {
+        const pending = pendingHandoffs.get(data.id);
+        if (!pending) {
+            return log(`no pending handoff for id ${data.id}`);
+        }
+        pending.resolvers.resolve(data);
     }
-    // Trim trailing empty path segment
-    if (path.length && !path[path.length - 1])
-        path.pop();
-    const { heads, hexHeads, documentId } = parseAutomergeUrl(maybeAutomergeUrl);
-    const signal = AbortSignal.timeout(RESOLVE_TIMEOUT_MS);
-    if (!heads) {
-        const folder = await repo.find(maybeAutomergeUrl, { signal });
-        const latestHeads = folder.heads();
-        const url = stringifyAutomergeUrl({ documentId, heads: latestHeads });
-        let location = `/${encodeURIComponent(url)}`;
-        if (path.length)
-            location += `/${path.join("/")}`;
-        return Response.redirect(location, 307);
+    else if (data?.type === "online") {
+        // The automerge worker (re)started — re-broadcast anything still in
+        // flight so requests that raced its boot aren't stranded.
+        for (const { message } of pendingHandoffs.values()) {
+            log(`re-broadcasting handoff ${message.id} to the fresh worker`);
+            handoffChannel.postMessage(message);
+        }
     }
-    // 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,
+});
+function handoff(request, handoffURL) {
+    const id = crypto.randomUUID();
+    const resolvers = Promise.withResolvers();
+    const message = {
+        id,
+        type: "request",
+        cachename,
+        request: {
+            url: request.url,
+            handoffURL: handoffURL.href,
+            headers: Object.fromEntries(request.headers.entries()),
+            method: request.method,
+            destination: request.destination,
+            referrer: request.referrer,
+        },
+    };
+    pendingHandoffs.set(id, { message, resolvers });
+    log(`broadcasting handoff request for cache ${cachename}`, message);
+    handoffChannel.postMessage(message);
+    const timeout = setTimeout(() => {
+        resolvers.reject(new Error(`no reply from the automerge worker after ${HANDOFF_TIMEOUT_MS}ms`));
+    }, HANDOFF_TIMEOUT_MS);
+    return resolvers.promise.finally(() => {
+        clearTimeout(timeout);
+        pendingHandoffs.delete(id);
     });
-    if (!hasHeads(baseHandle.doc(), hexHeads ?? [])) {
-        return new Response("heads not found", { status: 404 });
-    }
-    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 body = resolved.content instanceof Uint8Array
-        ? new Uint8Array(resolved.content)
-        : resolved.content;
-    const headers = new Headers({ "content-type": resolved.type });
+}
+function withSpecialHeaders(response) {
+    const headers = new Headers(response.headers);
     headers.set("cross-origin-embedder-policy", "credentialless");
     headers.set("cross-origin-resource-policy", "cross-origin");
-    return new Response(body, { status: 200, headers });
+    return new Response(response.body ?? null, {
+        status: response.status ?? 200,
+        headers,
+    });
 }
 // ── Fetch handler ──────────────────────────────────────────────────────
 self.addEventListener("fetch", (fetchEvent) => {
@@ -227,13 +121,13 @@ self.addEventListener("fetch", (fetchEvent) => {
     if (request.method !== "GET")
         return fetchEvent.respondWith(fetch(request));
     const url = new URL(fetchEvent.request.url);
-    let specialURL;
+    let handoffURL;
     if (url.hostname == self.location.hostname &&
         url.port == self.location.port &&
         url.protocol == self.location.protocol) {
         try {
-            specialURL = new URL(decodeURIComponent(url.pathname.slice(1)));
-            log(`received special request ${specialURL}`);
+            handoffURL = new URL(decodeURIComponent(url.pathname.slice(1)));
+            log(`received special request ${handoffURL}`);
         }
         catch { }
     }
@@ -241,29 +135,28 @@ self.addEventListener("fetch", (fetchEvent) => {
         const cache = await caches.open(cachename);
         const match = await cache.match(request);
         try {
-            if (specialURL) {
+            if (handoffURL) {
                 if (match) {
-                    log(`serving ${specialURL} from cache ${cachename}`);
-                    const headers = new Headers(match.headers);
-                    headers.set("cross-origin-embedder-policy", "credentialless");
-                    headers.set("cross-origin-resource-policy", "cross-origin");
-                    return new Response(match.body, {
-                        status: match.status,
-                        headers,
-                    });
+                    log(`serving ${handoffURL} from cache ${cachename}`);
+                    return withSpecialHeaders(match);
                 }
-                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;
+                log(`handing ${handoffURL} off to the automerge worker`);
+                const replyPromise = handoff(request, handoffURL);
+                fetchEvent.waitUntil(replyPromise.catch(() => { }));
+                const reply = await replyPromise;
+                if (reply.type === "response") {
+                    // errors, redirects and other things that shouldn't be cached
+                    log(`serving handed-off response for ${handoffURL}`, reply);
+                    return withSpecialHeaders(reply.response);
                 }
-                if (cacheableStatuses.includes(response.status)) {
-                    log(`caching ${specialURL}`);
-                    await cache.put(request, response.clone());
+                // reply.type === "cached": the automerge worker has put the
+                // response in our cache
+                const cached = await cache.match(request);
+                if (!cached) {
+                    return new Response(`the automerge worker reported ${handoffURL} cached, but it has no match in ${cachename}`, { status: 500 });
                 }
-                return response;
+                log(`serving ${handoffURL} from cache ${cachename} after handoff`);
+                return withSpecialHeaders(cached);
             }
             else {
                 const response = await fetch(request).catch(() => null);
@@ -286,7 +179,7 @@ self.addEventListener("fetch", (fetchEvent) => {
             const message = error instanceof Error
                 ? `${error.message}\n\n${error.stack}`
                 : String(error);
-            console.error(`service worker error resolving ${request.url}${specialURL ? ` (for: ${specialURL})` : ""}.\n${message}`);
+            console.error(`service worker error resolving ${request.url}${handoffURL ? ` (for: ${handoffURL})` : ""}`, error);
             if (match)
                 return match;
             return new Response(message, {

package/dist/setup.d.ts

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

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 () => { };
         },
     };
 }