@inkandswitch/patchwork-bootloader 0.3.2 → 0.4.0

package/CHANGELOG.md

@@ -1,5 +1,15 @@
 # @inkandswitch/patchwork-bootloader
 
+## 0.4.0
+
+### Minor Changes
+
+- b1bd763: Hash routing: `doc=` now holds the full (un-encoded) automerge URL — heads, if
+  any, live inside it — and the separate `heads=` param is gone. `doc=` values
+  that are a bare document id are still accepted for backwards compatibility, and
+  legacy big-patchwork links (`<slug>--<docId>?…`, including slugs with
+  characters like `drawing-(branch-1)`) are normalized to `#doc=automerge:<docId>`.
+
 ## 0.3.2
 
 ### Patch Changes

package/dist/automerge-worker.js

@@ -17,7 +17,8 @@ import { initializeWasm, hasHeads } from "@automerge/automerge/slim";
 // @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 { makePortProvider } from "@automerge/automerge-repo/worker-port";
+import { Repo, WorkerWebSocketEndpoint, isValidAutomergeUrl, parseAutomergeUrl, stringifyAutomergeUrl, } from "@automerge/automerge-repo/slim";
 import { resolvePath } from "@inkandswitch/patchwork-filesystem";
 // Small adapters — bundled directly into the worker
 import { IndexedDBWorkerStorageAdapter } from "@automerge/automerge-repo-storage-indexeddb/IndexedDBWorkerStorageAdapter";
@@ -36,6 +37,35 @@ const WORKER_BOOT_TIME = Date.now();
 // → shared workers). Patch console.* and the global error handlers to also
 // post back over every connected tab's control port, tagged [automerge-worker].
 const controlPorts = new Set();
+// ── Keepalive-drift probe (bench instrumentation) ───────────────────────
+// Measures how late a 1s timer fires on this thread — i.e. how late an
+// in-thread keepalive would be under sync/wasm load. Cheap (one Date.now()
+// per second); samples are batched to every connected tab as drift-samples
+// messages, which setup.ts accumulates on window.__driftSamples for the
+// Playwright bench (e2e/tests/bench-ws.spec.ts).
+const DRIFT_INTERVAL_MS = 1_000;
+const DRIFT_BATCH_SIZE = 5;
+{
+    let expected = Date.now() + DRIFT_INTERVAL_MS;
+    let batch = [];
+    setInterval(() => {
+        const now = Date.now();
+        batch.push(Math.max(0, now - expected));
+        expected = now + DRIFT_INTERVAL_MS;
+        if (batch.length >= DRIFT_BATCH_SIZE) {
+            const samples = batch;
+            batch = [];
+            for (const port of controlPorts) {
+                try {
+                    port.postMessage({ type: "drift-samples", samples });
+                }
+                catch {
+                    // Port torn down mid-iteration — its close handler cleans up.
+                }
+            }
+        }
+    }, DRIFT_INTERVAL_MS);
+}
 // ── Per-tab sync-state subscriptions ────────────────────────────────────
 // Each tab's control port subscribes to the documents it cares about; we push
 // only those docs' heads back down that port (addressed — tab A never sees tab
@@ -160,11 +190,49 @@ if (useKeyhiveSyncServer) {
         KEYHIVE_SERVER_IDENTITY: "keyhive-sync",
     };
 }
-const SUBDUCTION_ENDPOINTS = [
-    useKeyhiveSyncServer
-        ? "wss://keyhive.sync.automerge.org"
-        : "wss://subduction.sync.inkandswitch.com",
-];
+const SUBDUCTION_SYNC_URL = useKeyhiveSyncServer
+    ? "wss://keyhive.sync.automerge.org"
+    : "wss://subduction.sync.inkandswitch.com";
+// The subduction WebSocket lives in its own worker so socket I/O (and
+// keepalive pongs) keep flowing even when this SharedWorker's thread is busy
+// syncing. We can't spawn that worker ourselves — Chrome doesn't expose the
+// Worker constructor inside SharedWorkerGlobalScope — so tabs spawn the
+// shipped SharedWorker proxy entry and donate its port to us (donatePort in
+// setup.ts). The provider hands WorkerWebSocketEndpoint whichever port is
+// current, healing across late arrival and proxy-worker restarts.
+const subductionPortProvider = makePortProvider();
+// A/B bench toggle: the tab appends ?ws-mode=inline to our URL (SharedWorker
+// scope has no localStorage; see getAutomergeWorker in setup.ts). "inline"
+// passes the bare URL string so the socket lives on this thread — the
+// pre-worker behaviour — as the control arm for benchmarking the
+// worker-based endpoint. Default: "worker".
+const WS_MODE = new URL(self.location.href).searchParams.get("ws-mode") === "inline"
+    ? "inline"
+    : "worker";
+// Optional windowFrames override (bench knob — max un-acked frames the io
+// proxy delivers before pausing; endpoint default is 128).
+const WS_WINDOW_FRAMES = Number(new URL(self.location.href).searchParams.get("ws-window")) ||
+    undefined;
+// Memoized so a repo-construction retry (getRepoHive clears its promise on
+// failure) reuses the same endpoint instead of leaking one per attempt.
+let subductionEndpoints = null;
+function getSubductionEndpoints() {
+    if (!subductionEndpoints) {
+        log(`subduction websocket mode: ${WS_MODE}`);
+        subductionEndpoints =
+            WS_MODE === "inline"
+                ? [SUBDUCTION_SYNC_URL]
+                : [
+                    new WorkerWebSocketEndpoint(SUBDUCTION_SYNC_URL, {
+                        worker: subductionPortProvider.source,
+                        ...(WS_WINDOW_FRAMES
+                            ? { windowFrames: WS_WINDOW_FRAMES }
+                            : {}),
+                    }),
+                ];
+    }
+    return subductionEndpoints;
+}
 const RESOLVE_TIMEOUT_MS = 30_000;
 // Backoff re-sync of stuck/diverged docs. Only this worker is connected to the
 // sync server, so it's the only place that can notice a doc whose heads have
@@ -232,7 +300,6 @@ function getRepoHive() {
                     peerId: signer.peerId().toString(),
                     verifyingKey: signer.verifyingKey().toHex(),
                 };
-                console.log("[patchwork] shared-worker subduction identity:", identity);
                 const repo = new Repo({
                     storage: new IndexedDBWorkerStorageAdapter(),
                     signer,
@@ -244,8 +311,9 @@ function getRepoHive() {
                         return peerId.includes("storage-server");
                     },
                     enableRemoteHeadsGossiping: true,
-                    subductionWebsocketEndpoints: SUBDUCTION_ENDPOINTS,
+                    subductionWebsocketEndpoints: getSubductionEndpoints(),
                 });
+                console.log("[patchwork] shared-worker subduction identity:", identity, "networkSubsystem.adapters:", repo.networkSubsystem.adapters.length);
                 self.repo = repo;
                 self.syncIdentity = identity;
                 setupSyncStateBroadcast(repo, identity);
@@ -269,7 +337,7 @@ function getRepoHive() {
                 ...(useKeyhiveSyncServer ? { syncServer: "keyhive" } : {}),
                 repo: {
                     storage: new IndexedDBWorkerStorageAdapter(),
-                    subductionWebsocketEndpoints: SUBDUCTION_ENDPOINTS,
+                    subductionWebsocketEndpoints: getSubductionEndpoints(),
                     enableRemoteHeadsGossiping: true,
                 },
             });
@@ -592,11 +660,15 @@ function dropRepoChannel(repo, channel) {
     try {
         channel.mcAdapter.disconnect();
     }
-    catch { }
+    catch {
+        // Already disconnected by removeNetworkAdapter above.
+    }
     try {
         channel.port.close();
     }
-    catch { }
+    catch {
+        // Port already closed by the departing tab.
+    }
 }
 async function dropConnection(connection) {
     if (!connection.channels.size || !repoHivePromise)
@@ -708,6 +780,10 @@ self.addEventListener("connect", (event) => {
     controlPort.addEventListener("message", (messageEvent) => {
         handleControlMessage(messageEvent, controlPort, connection);
     });
+    // Let the subduction port provider negotiate over this tab's control port
+    // (the tab side runs donatePort; the messages are channel-tagged so they
+    // coexist with our control protocol above).
+    subductionPortProvider.attachClient(controlPort);
     // Fires when the owning page is destroyed. Browsers without the close
     // event fall back to the adapters' lazy useWeakRef cleanup.
     controlPort.addEventListener("close", () => {
@@ -812,10 +888,10 @@ async function resolveAutomergeUrl(automergeURL) {
     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 });
+    return new Response(body, {
+        status: 200,
+        headers: { "content-type": resolved.type },
+    });
 }
 // ── Handoff: resolve special URLs for the service worker ──────────────
 const handoffChannel = new BroadcastChannel(HANDOFF_CHANNEL);

package/dist/externals.js

@@ -6,6 +6,11 @@ const externals = [
     "@automerge/automerge/slim",
     "@automerge/automerge-repo",
     "@automerge/automerge-repo/slim",
+    // Port-donation plumbing for WorkerWebSocketEndpoint: tabs spawn the shared
+    // proxy entry and donate its port to the automerge worker (Chrome can't
+    // spawn workers from inside a SharedWorker). See setup.ts/automerge-worker.ts.
+    "@automerge/automerge-repo/worker-port",
+    "@automerge/automerge-repo/subduction-websocket-worker-shared",
     "@automerge/automerge-repo-network-messagechannel",
     "@automerge/automerge-repo-network-websocket",
     "@automerge/automerge-repo-storage-indexeddb",

package/dist/service-worker.js

@@ -6,9 +6,11 @@
 // "cached" (or "response" for errors and other things that shouldn't be
 // cached).
 import { HANDOFF_CHANNEL, } from "./types.js";
-let cachename = "default";
+const DEFAULT_CACHE_NAME = "patchwork";
+let cachename = DEFAULT_CACHE_NAME;
 let debugging = false;
-const cacheableStatuses = [200, 203, 204];
+// 0 is an opaque response, that also needs cached
+const cacheableStatuses = [0, 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;
@@ -52,20 +54,16 @@ self.addEventListener("install", (event) => {
     // every old tab closes.
     event.waitUntil(self.skipWaiting());
 });
-async function clearOldCaches() {
-    const cacheWhitelist = [cachename];
-    const cacheNames = await caches.keys();
-    const deletePromises = cacheNames.map((cacheName) => {
-        if (!cacheWhitelist.includes(cacheName)) {
+async function clearOtherCaches() {
+    await Promise.all((await caches.keys()).map((cacheName) => {
+        if (cacheName !== cachename)
             return caches.delete(cacheName);
-        }
-    });
-    await Promise.all(deletePromises);
+    }));
 }
 self.addEventListener("activate", (event) => {
     lifecycle("info", "activate (claiming clients)");
     event.waitUntil((async () => {
-        await clearOldCaches();
+        await clearOtherCaches();
         await self.clients.claim();
         // Pre-cache pages of already-open clients so they survive going offline
         // before the next navigation.
@@ -77,7 +75,7 @@ self.addEventListener("activate", (event) => {
                 if (!existing) {
                     const response = await fetch(client.url);
                     if (cacheableStatuses.includes(response.status)) {
-                        await cache.put(client.url, response);
+                        await cachePage(cache, client.url, response);
                     }
                 }
             }
@@ -93,9 +91,18 @@ self.addEventListener("message", async (event) => {
         if (cachename == nextCachename) {
             return;
         }
-        console.info(`deleting ${cachename} and setting cache name to ${nextCachename}`);
-        caches.delete(cachename);
+        console.info(`moving from cache ${cachename} to ${nextCachename}`);
+        if (cachename === DEFAULT_CACHE_NAME) {
+            const defaultCache = await caches.open(cachename);
+            const nextCache = await caches.open(nextCachename);
+            await Promise.all((await defaultCache.keys()).map(async (request) => {
+                const response = await defaultCache.match(request);
+                if (response)
+                    await nextCache.put(request, response);
+            }));
+        }
         cachename = nextCachename;
+        await clearOtherCaches();
     }
     else if (event.data.type == "debug") {
         debugging = event.data.debug;
@@ -157,15 +164,39 @@ function handoff(request, handoffURL) {
         pendingHandoffs.delete(id);
     });
 }
-function withSpecialHeaders(response) {
-    const headers = new Headers(response.headers);
-    headers.set("cross-origin-embedder-policy", "credentialless");
-    headers.set("cross-origin-resource-policy", "cross-origin");
+function makeResponse(response) {
     return new Response(response.body ?? null, {
         status: response.status ?? 200,
-        headers,
+        headers: response.headers,
     });
 }
+function indexRequestFor(request) {
+    const url = new URL(typeof request === "string" ? request : request.url);
+    if (url.origin !== self.location.origin)
+        return undefined;
+    url.pathname = "/index.html";
+    url.search = "";
+    url.hash = "";
+    return new Request(url.href);
+}
+function rootRequestFor(request) {
+    const url = new URL(typeof request === "string" ? request : request.url);
+    if (url.origin !== self.location.origin)
+        return undefined;
+    url.pathname = "/";
+    url.search = "";
+    url.hash = "";
+    return new Request(url.href);
+}
+async function cachePage(cache, request, response) {
+    const indexRequest = indexRequestFor(request);
+    if (indexRequest)
+        await cache.put(indexRequest, response.clone());
+    const rootRequest = rootRequestFor(request);
+    if (rootRequest)
+        await cache.put(rootRequest, response.clone());
+    await cache.put(request, response);
+}
 // ── Fetch handler ──────────────────────────────────────────────────────
 self.addEventListener("fetch", (fetchEvent) => {
     log("fetch event", fetchEvent.request.url);
@@ -190,7 +221,7 @@ self.addEventListener("fetch", (fetchEvent) => {
             if (handoffURL) {
                 if (match) {
                     log(`serving ${handoffURL} from cache ${cachename}`);
-                    return withSpecialHeaders(match);
+                    return match;
                 }
                 log(`handing ${handoffURL} off to the automerge worker`);
                 const replyPromise = handoff(request, handoffURL);
@@ -199,7 +230,7 @@ self.addEventListener("fetch", (fetchEvent) => {
                 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);
+                    return makeResponse(reply.response);
                 }
                 // reply.type === "cached": the automerge worker has put the
                 // response in our cache
@@ -208,25 +239,41 @@ self.addEventListener("fetch", (fetchEvent) => {
                     return new Response(`the automerge worker reported ${handoffURL} cached, but it has no match in ${cachename}`, { status: 555 });
                 }
                 log(`serving ${handoffURL} from cache ${cachename} after handoff`);
-                return withSpecialHeaders(cached);
+                return cached;
             }
             else {
-                const response = await fetch(request).catch(() => null);
-                if (response) {
-                    if (cacheableStatuses.includes(response.status) &&
-                        response.url.match(/^https?\:/)) {
-                        await cache.put(request, response.clone()).catch((error) => {
+                // fetch() rejects on network error / abort rather than resolving;
+                // keep the error so we can surface it in the 503 body below.
+                const result = await fetch(request).catch((error) => error instanceof Error ? error : new Error(String(error)));
+                if (result instanceof Response) {
+                    const response = result;
+                    // Tool subresources (<link>/<script>) are requested from srcdoc
+                    // frames whose origin is "null", so they come back as opaque
+                    // cross-origin `no-cors` responses: status 0 and an empty url. They
+                    // render fine while online but were being excluded from the cache,
+                    // so e.g. a theme stylesheet vanished on an offline refresh. Opaque
+                    // responses are cacheable and replay to the same no-cors consumer,
+                    // so treat status 0 as cacheable and gate the scheme on request.url
+                    // (an opaque response's own url is "").
+                    if ((response.status === 0 ||
+                        cacheableStatuses.includes(response.status)) &&
+                        /^https?:/.test(request.url)) {
+                        const cachedResponse = response.clone();
+                        await (request.mode === "navigate" ||
+                            request.destination === "document"
+                            ? cachePage(cache, request, cachedResponse)
+                            : cache.put(request, cachedResponse)).catch((error) => {
                             log(`error caching ${request.url} in ${cachename}`, error);
                         });
                     }
                     else {
-                        log(`skipping uncacheable response code from cache: ${response.status} for ${response.url}`);
+                        log(`skipping uncacheable response code from cache: ${response.status} for ${request.url}`);
                     }
                     return response;
                 }
                 if (match)
                     return match;
-                return new Response("couldnt fetch and no stale", { status: 503 });
+                return new Response(`couldnt fetch ${request.url} and no stale copy in ${cachename}\n\n${result.stack ?? result.message}`, { status: 503, headers: { "content-type": "text/plain" } });
             }
         }
         catch (error) {

package/dist/setup.js

@@ -1,5 +1,6 @@
 import { readClassicSyncServer, DEFAULT_CLASSIC_SYNC_SERVER, } from "./sync-config.js";
 import debug from "debug";
+import { donatePort, isWorkerErrorMessage, } from "@automerge/automerge-repo/worker-port";
 const serviceWorkerDebugging = debug.enabled("patchwork:serviceworker");
 const workerDebugging = debug.enabled("patchwork:automergeworker");
 // Diagnostic [lifecycle] logging, on by default. Disable via
@@ -34,6 +35,7 @@ function installServiceWorkerLogForwarding() {
     });
 }
 const key = "patchworkServiceWorkerCacheVersion";
+const defaultServiceWorkerCacheName = "patchwork";
 let nextRepoChannelId = 0;
 function bumpServiceWorkerCacheVersion() {
     const version = new Date().valueOf().toString(36);
@@ -43,19 +45,13 @@ function bumpServiceWorkerCacheVersion() {
 function getServiceWorkerCacheVersion() {
     return localStorage.getItem(key);
 }
-function getOrCreateServiceWorkerCacheVersion() {
-    const existing = getServiceWorkerCacheVersion();
-    if (existing)
-        return existing;
-    return bumpServiceWorkerCacheVersion();
-}
 function setServiceWorkerCacheName(sw) {
     if (!sw) {
         throw new Error("no service worker!");
     }
     sw.postMessage({
         type: "cachename",
-        cachename: getOrCreateServiceWorkerCacheVersion(),
+        cachename: getServiceWorkerCacheVersion() ?? defaultServiceWorkerCacheName,
     });
 }
 export function bumpServiceWorkerCache(sw = navigator.serviceWorker.controller) {
@@ -67,9 +63,10 @@ function configureServiceWorker(sw) {
     if (!sw)
         return;
     sw.postMessage({ type: "debug", debug: serviceWorkerDebugging });
-    const cachename = getServiceWorkerCacheVersion();
-    if (cachename)
-        sw.postMessage({ type: "cachename", cachename });
+    sw.postMessage({
+        type: "cachename",
+        cachename: getServiceWorkerCacheVersion() ?? defaultServiceWorkerCacheName,
+    });
 }
 // ── The automerge worker ───────────────────────────────────────────────
 // The automerge repo lives in a SharedWorker (not the service worker). One
@@ -79,9 +76,41 @@ function configureServiceWorker(sw) {
 // port; it talks to the service worker over a BroadcastChannel.
 let automergeWorkerPath = "/automerge-worker.js";
 let automergeWorker;
+// SharedWorker proxy entry that owns the subduction WebSocket. Chrome can't
+// spawn workers from inside a SharedWorker, so each tab offers this proxy's
+// port to the automerge worker (which requests one via its port provider).
+// Being a SharedWorker itself, the proxy — and the donated worker↔worker
+// port — outlives the donor tab. Emitted at /packages/... via externals.ts.
+const SUBDUCTION_IO_WORKER_URL = "/packages/@automerge/automerge-repo/subduction-websocket-worker-shared.js";
+// Bench toggles for the subduction socket (see getSubductionEndpoints in
+// automerge-worker.ts), passed as query params because SharedWorker scope
+// has no localStorage — which also gives each configuration its own worker
+// instance, so bench arms can't share state.
+//   localStorage["patchwork:ws-mode"] = "inline"  → socket on worker thread
+//   localStorage["patchwork:ws-window"] = "16"    → WorkerWebSocketEndpoint
+//                                                    windowFrames override
+function workerBenchParams() {
+    const params = new URLSearchParams();
+    try {
+        for (const [key, param] of [
+            ["patchwork:ws-mode", "ws-mode"],
+            ["patchwork:ws-window", "ws-window"],
+        ]) {
+            const value = globalThis.localStorage?.getItem(key);
+            if (value)
+                params.set(param, value);
+        }
+    }
+    catch {
+        // No localStorage (shouldn't happen in a tab) — use defaults.
+    }
+    const qs = params.toString();
+    return qs ? `?${qs}` : "";
+}
 export function getAutomergeWorker() {
     if (!automergeWorker) {
-        automergeWorker = new SharedWorker(automergeWorkerPath, {
+        const workerUrl = `${automergeWorkerPath}${workerBenchParams()}`;
+        automergeWorker = new SharedWorker(workerUrl, {
             name: "patchwork-automerge",
             type: "module",
         });
@@ -95,6 +124,22 @@ export function getAutomergeWorker() {
                 dispatchSyncState(event.data);
                 return;
             }
+            if (isWorkerErrorMessage(event.data)) {
+                // Crash/skew reports relayed from the subduction io proxy (e.g.
+                // protocol-mismatch from a stale SW-cached worker chunk). Surface
+                // loudly — these otherwise only exist in chrome://inspect.
+                console.error("[subduction-io]", event.data);
+                return;
+            }
+            if (event.data?.type === "drift-samples") {
+                // Keepalive-drift samples from the worker's bench probe. Kept on a
+                // bounded window global for the Playwright bench to harvest.
+                const sink = (window.__driftSamples ??= []);
+                sink.push(...event.data.samples);
+                if (sink.length > 10_000)
+                    sink.splice(0, sink.length - 10_000);
+                return;
+            }
             if (event.data?.type !== "console")
                 return;
             const { level, args } = event.data;
@@ -117,6 +162,15 @@ export function getAutomergeWorker() {
             }
         });
         automergeWorker.port.postMessage({ type: "debug", debug: workerDebugging });
+        // Offer the subduction io proxy's port; the worker's port provider pulls
+        // it when (re)constructing its WorkerWebSocketEndpoint.
+        donatePort(automergeWorker.port, () => {
+            const io = new SharedWorker(SUBDUCTION_IO_WORKER_URL, {
+                type: "module",
+                name: "subduction-websocket",
+            });
+            return io.port;
+        });
         installWorkerDeathDetection(automergeWorker);
     }
     return automergeWorker;
@@ -320,6 +374,7 @@ export default async function setupServiceWorker(options) {
     // Attach the SW→tab [lifecycle] log bridge as early as possible so boot /
     // install / activate markers from the controlling worker are rendered here.
     installServiceWorkerLogForwarding();
+    localStorage.removeItem(key);
     if (options?.workerPath)
         automergeWorkerPath = options.workerPath;
     // Start the automerge worker right away so it boots (wasm, repo) while the