@inkandswitch/patchwork-bootloader 0.2.6 → 0.2.8

package/dist/service-worker.js

@@ -1,61 +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 { initializeAutomergeRepoKeyhiveRust, initKeyhiveWasm, } from "@automerge/automerge-repo-keyhive";
-// 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 siteName = typeof __SITE_NAME__ !== "undefined" ? __SITE_NAME__ : "tiny-patchwork";
-const cacheableStatuses = [200, 203, 204, 206];
+const cacheableStatuses = [200, 203, 204];
+// 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();
@@ -66,166 +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 repoHivePromise = null;
-const useKeyhive = typeof __KEYHIVE__ !== "undefined" && __KEYHIVE__;
-function getRepoHive() {
-    if (!repoHivePromise) {
-        repoHivePromise = (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");
-            if (!useKeyhive) {
-                const signer = await WebCryptoSigner.setup();
-                const repo = new Repo({
-                    storage: new IndexedDBStorageAdapter(),
-                    signer,
-                    peerId: ("service-worker-" +
-                        Math.random().toString(36).slice(2)),
-                    async sharePolicy(peerId) {
-                        return peerId.includes("storage-server");
-                    },
-                    enableRemoteHeadsGossiping: true,
-                    subductionWebsocketEndpoints: SUBDUCTION_ENDPOINTS,
-                });
-                self.repo = repo;
-                logger.info("repo constructed (no keyhive), waiting for network subsystem");
-                repo.networkSubsystem.whenReady().then(() => {
-                    logger.info("repo network subsystem ready");
-                });
-                return { repo };
-            }
-            initKeyhiveWasm();
-            const keyhiveStorage = new IndexedDBStorageAdapter(`${siteName}-keyhive`);
-            // Keyhive bootstrap needs to run before Repo creation but
-            // the adapter needs the subduction instance from the Repo.
-            // A deferred promise breaks the cycle.
-            let resolveRepoSubduction;
-            const repoSubductionPromise = new Promise((resolve) => {
-                resolveRepoSubduction = resolve;
-            });
-            // We use the Rust variant of Keyhive initialization to talk
-            // to the Rust keyhive-enabled subduction sync server.
-            const hive = await initializeAutomergeRepoKeyhiveRust({
-                storage: keyhiveStorage,
-                peerIdSuffix: `${siteName}-worker` + Math.random().toString(36).slice(2),
-                subduction: repoSubductionPromise,
-                automaticArchiveIngestion: true,
-                cachingMode: "periodic",
-            });
-            const signer = await hive.constructSubductionSigner();
-            const repo = new Repo({
-                storage: new IndexedDBStorageAdapter(),
-                signer,
-                subductionWebsocketEndpoints: SUBDUCTION_ENDPOINTS,
-                peerId: hive.peerId,
-                enableRemoteHeadsGossiping: true,
-                idFactory: hive.idFactory,
-                //network: [new WebSocketClientAdapter("wss://sync3.automerge.org")],
-            });
-            repo.subduction.then(resolveRepoSubduction);
-            hive.linkRepo(repo);
-            self.repo = repo;
-            self.hive = hive;
-            logger.info("repo constructed, waiting for network subsystem");
-            // Don't block getRepoHive() on whenReady() — the network subsystem starts
-            // with only the subduction adapter, and the MessageChannel adapter is
-            // added later via connectPort (which awaits getRepoHive). Blocking here
-            // would deadlock that path and starve the fetch handler.
-            repo.networkSubsystem.whenReady().then(() => {
-                logger.info("repo network subsystem ready");
-            });
-            hive.networkAdapter.whenReady().then(() => {
-                hive.networkAdapter.syncKeyhive();
-            });
-            return { hive, 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.
-        repoHivePromise.catch(() => {
-            repoHivePromise = null;
-        });
-    }
-    return repoHivePromise;
-}
-// Connect client MessagePorts to the repo for sync
-async function connectPort(port) {
-    const { hive, repo } = await getRepoHive();
-    const networkAdapter = new MessageChannelNetworkAdapter(port, { useWeakRef: true });
-    if (!hive) {
-        repo.networkSubsystem.addNetworkAdapter(networkAdapter);
-        return;
-    }
-    const onlyShareWithHardcodedServerPeerId = false;
-    const periodicallyRequestKeyhiveSync = false;
-    const keyhiveNetworkAdapter = hive.createKeyhiveNetworkAdapter(networkAdapter, onlyShareWithHardcodedServerPeerId, periodicallyRequestKeyhiveSync, 2000);
-    keyhiveNetworkAdapter.on("message", async (msg) => {
-        if ((msg.type === "sync" || msg.type === "request") && msg.documentId) {
-            const handle = repo.handles[msg.documentId];
-            if (!handle || handle.state === "unavailable") {
-                const url = `automerge:${msg.documentId}`;
-                repo.findWithProgress(url);
-                repo.shareConfigChanged();
-            }
-        }
-    });
-    keyhiveNetworkAdapter.on("ingest-remote", () => {
-        hive.networkAdapter.syncKeyhive?.();
-        repo.shareConfigChanged();
-    });
-    repo.networkSubsystem.addNetworkAdapter(keyhiveNetworkAdapter);
-}
 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;
@@ -239,49 +57,62 @@ self.addEventListener("message", async (event) => {
         log("serviceworker debugging enabled");
     }
 });
-// ── Automerge URL resolution ───────────────────────────────────────────
-async function resolveAutomergeUrl(automergeURL) {
-    const { repo } = await getRepoHive();
-    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) => {
@@ -290,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 { }
     }
@@ -304,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);
@@ -349,11 +179,7 @@ self.addEventListener("fetch", (fetchEvent) => {
             const message = error instanceof Error
                 ? `${error.message}\n\n${error.stack}`
                 : String(error);
-            const logger = await slog;
-            logger.error(`service worker error resolving ${request.url}${specialURL ? ` (for: ${specialURL})` : ""}`, {
-                message: error instanceof Error ? error.message : String(error),
-                stack: error instanceof Error ? error.stack : undefined,
-            });
+            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>;