@inkandswitch/patchwork-bootloader 0.3.2 → 0.4.0

package/src/setup.ts

@@ -9,6 +9,10 @@ import {
   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");
@@ -42,6 +46,7 @@ function installServiceWorkerLogForwarding(): void {
 }
 
 const key = "patchworkServiceWorkerCacheVersion";
+const defaultServiceWorkerCacheName = "patchwork";
 let nextRepoChannelId = 0;
 
 function bumpServiceWorkerCacheVersion() {
@@ -54,19 +59,13 @@ function getServiceWorkerCacheVersion() {
   return localStorage.getItem(key);
 }
 
-function getOrCreateServiceWorkerCacheVersion() {
-  const existing = getServiceWorkerCacheVersion();
-  if (existing) return existing;
-  return bumpServiceWorkerCacheVersion();
-}
-
 function setServiceWorkerCacheName(sw: ServiceWorker | null) {
   if (!sw) {
     throw new Error("no service worker!");
   }
   sw.postMessage({
     type: "cachename",
-    cachename: getOrCreateServiceWorkerCacheVersion(),
+    cachename: getServiceWorkerCacheVersion() ?? defaultServiceWorkerCacheName,
   });
 }
 
@@ -82,8 +81,10 @@ export function bumpServiceWorkerCache(
 function configureServiceWorker(sw: ServiceWorker | null) {
   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 ───────────────────────────────────────────────
@@ -96,9 +97,42 @@ function configureServiceWorker(sw: ServiceWorker | null) {
 let automergeWorkerPath = "/automerge-worker.js";
 let automergeWorker: SharedWorker | undefined;
 
+// 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(): string {
+  const params = new URLSearchParams();
+  try {
+    for (const [key, param] of [
+      ["patchwork:ws-mode", "ws-mode"],
+      ["patchwork:ws-window", "ws-window"],
+    ] as const) {
+      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(): SharedWorker {
   if (!automergeWorker) {
-    automergeWorker = new SharedWorker(automergeWorkerPath, {
+    const workerUrl = `${automergeWorkerPath}${workerBenchParams()}`;
+    automergeWorker = new SharedWorker(workerUrl, {
       name: "patchwork-automerge",
       type: "module",
     });
@@ -112,6 +146,21 @@ export function getAutomergeWorker(): SharedWorker {
         dispatchSyncState(event.data as SyncStateDocMessage);
         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 as any).__driftSamples ??= []) as number[];
+        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;
       // Gate forwarded [lifecycle] logs on the toggle too.
@@ -135,6 +184,16 @@ export function getAutomergeWorker(): SharedWorker {
     });
     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;
@@ -363,6 +422,7 @@ export default async function setupServiceWorker(
   // 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;
 

package/src/site.ts

@@ -17,7 +17,6 @@ import {
   isValidAutomergeUrl,
   isValidDocumentId,
   MessageChannelNetworkAdapter,
-  parseAutomergeUrl,
   Repo,
   stringifyAutomergeUrl,
   type AutomergeUrl,
@@ -172,9 +171,12 @@ export interface BootResult {
   accountDocHandle: DocHandle<AccountDoc>;
 }
 
-// Legacy big-patchwork hash shape: `slug--<documentId>[?=type]`.
+// Legacy big-patchwork hash shape: `<slug>--<documentId>[?…]`. The slug can
+// contain characters we don't otherwise permit (e.g. `drawing-(branch-1)`), so
+// we anchor on the `--` before the base58 document id and allow any non-query
+// characters ahead of it rather than a strict slug charset.
 const BIG_PATCHWORK_HASH_REGEX =
-  /(?<title>[A-Za-z0-9-]+)--(?<docId>[1-9A-HJ-NP-Za-km-z]+)(?<type>\?=[^&?]+)?/;
+  /^(?<title>[^=&?/#]*)--(?<docId>[1-9A-HJ-NP-Za-km-z]+)/;
 
 const [automergeWasm, subductionWasm] = await Promise.all([
   fetch("/automerge.wasm?main").then((r) => r.bytes()),
@@ -355,7 +357,6 @@ export async function bootPatchworkSite(
     rootElement,
     repo,
     accountDocHandle,
-    moduleWatcher,
     titleSuffix: config.titleSuffix,
   });
 
@@ -625,12 +626,12 @@ async function uncache(match: string): Promise<void> {
   }
 }
 
-// Keys whose values are automerge URLs — we keep the `:` (and any `#`/`|`
-// heads) literal rather than percent-encoding them so links stay readable.
-const RAW_HASH_KEYS = new Set(["doc", "package"]);
-// Emit hash params in a stable order so re-serializing the same logical
-// params yields a byte-identical string (avoids spurious `hashchange`).
-const HASH_KEY_ORDER = ["doc", "package", "tool", "type", "title", "frame"];
+// The `doc=` value is an automerge URL — we keep its `:` (and any `#`/`|`
+// heads) literal rather than percent-encoding it so links stay readable.
+const RAW_HASH_KEYS = new Set(["doc"]);
+// Emit hash params in a stable order so re-serializing the same logical params
+// yields a byte-identical string (avoids spurious `hashchange` round-trips).
+const HASH_KEY_ORDER = ["doc", "tool", "type", "title", "frame"];
 
 function serializeHashParams(params: URLSearchParams): string {
   const emitted = new Set<string>();
@@ -640,7 +641,9 @@ function serializeHashParams(params: URLSearchParams): string {
     const value = params.get(key);
     if (!value) return;
     emitted.add(key);
-    parts.push(`${key}=${RAW_HASH_KEYS.has(key) ? value : encodeURIComponent(value)}`);
+    parts.push(
+      `${key}=${RAW_HASH_KEYS.has(key) ? value : encodeURIComponent(value)}`
+    );
   };
   for (const key of HASH_KEY_ORDER) emit(key);
   for (const key of params.keys()) emit(key);
@@ -649,12 +652,14 @@ function serializeHashParams(params: URLSearchParams): string {
 
 /**
  * Coerce a `doc=` hash param to a full automerge URL. Accepts a full URL
- * (`automerge:<id>[#heads]`) or a bare document id for backwards
- * compatibility with older links.
+ * (`automerge:<id>[#heads]`) or a bare document id for backwards compatibility
+ * with older links.
  */
 function docParamToUrl(docParam: string | null): AutomergeUrl | undefined {
   if (!docParam) return undefined;
-  if (isValidAutomergeUrl(docParam as AutomergeUrl)) return docParam as AutomergeUrl;
+  if (isValidAutomergeUrl(docParam as AutomergeUrl)) {
+    return docParam as AutomergeUrl;
+  }
   const documentId = docParam.replace(/^automerge:/, "");
   if (isValidDocumentId(documentId)) {
     return stringifyAutomergeUrl({ documentId: documentId as DocumentId });
@@ -666,13 +671,11 @@ interface HashRoutingParams {
   rootElement: HTMLElement;
   repo: Repo;
   accountDocHandle: DocHandle<AccountDoc>;
-  moduleWatcher: ModuleWatcher;
   titleSuffix: string;
 }
 
 function installHashRouting(params: HashRoutingParams): void {
-  const { rootElement, repo, accountDocHandle, moduleWatcher, titleSuffix } =
-    params;
+  const { rootElement, repo, accountDocHandle, titleSuffix } = params;
 
   rootElement.addEventListener("patchwork:open-document", async (event) => {
     const params = new URLSearchParams(window.location.hash.slice(1));
@@ -682,8 +685,8 @@ function installHashRouting(params: HashRoutingParams): void {
       type?: string;
       title?: string;
     };
-    // `doc` is now the full automerge URL (heads, if any, live in it). The
-    // in-use package is recorded separately in `package=` when a tool mounts.
+    // `doc` is now the full automerge URL — heads, if any, live inside it, so
+    // the separate `heads=` param is gone.
     params.delete("heads");
     params.set("doc", url);
     if (toolId) params.set("tool", toolId);
@@ -695,8 +698,9 @@ function installHashRouting(params: HashRoutingParams): void {
     window.location.hash = serializeHashParams(params);
 
     try {
-      const docHandle =
-        await repo.find<{ "@patchwork"?: { type?: string } }>(url);
+      const docHandle = await repo.find<{ "@patchwork"?: { type?: string } }>(
+        url
+      );
       const doc = docHandle.doc();
       const docType = type || doc?.["@patchwork"]?.type;
       if (!docType) return;
@@ -714,29 +718,6 @@ function installHashRouting(params: HashRoutingParams): void {
     }
   });
 
-  // When a tool mounts we know the package actually rendering the top-level
-  // document, so record its (heads-pinned) importUrl in `package=`.
-  const recordInUsePackage = (event: Event) => {
-    const detail = (event as CustomEvent).detail;
-    if (!detail || !("url" in detail) || !detail.importUrl) return;
-    const params = new URLSearchParams(window.location.hash.slice(1));
-    const docUrl = docParamToUrl(params.get("doc"));
-    if (!docUrl) return;
-    // Ignore nested branch / side-by-side views: only the top-level doc's
-    // package belongs in the hash.
-    if (
-      parseAutomergeUrl(docUrl).documentId !==
-      parseAutomergeUrl(detail.url as AutomergeUrl).documentId
-    ) {
-      return;
-    }
-    if (params.get("package") === detail.importUrl) return;
-    params.set("package", detail.importUrl);
-    // Replace rather than push: recording the in-use package shouldn't add a
-    // back-button entry (and replaceState avoids a `hashchange` round-trip).
-    history.replaceState(null, "", `#${serializeHashParams(params)}`);
-  };
-
   let firstMount = true;
   const reveal = () => {
     if (!firstMount) return;
@@ -746,7 +727,6 @@ function installHashRouting(params: HashRoutingParams): void {
   };
 
   rootElement.addEventListener("patchwork:mounted", (event) => {
-    recordInUsePackage(event);
     handleHashChange();
     if (event.target !== rootElement) return;
     console.info("root element mounted");
@@ -762,13 +742,17 @@ function installHashRouting(params: HashRoutingParams): void {
 
   const handleHashChange = async () => {
     const hash = window.location.hash.slice(1);
-    const legacy = BIG_PATCHWORK_HASH_REGEX.exec(hash);
 
-    if (legacy) {
-      const documentId = legacy.groups?.docId;
-      if (isValidDocumentId(documentId)) {
-        openDocument(rootElement, stringifyAutomergeUrl({ documentId }));
-      }
+    // Legacy big-patchwork link (`<slug>--<docId>?…`): if the hash carries a
+    // `--` followed by a valid document id, normalize it to the canonical
+    // `#doc=automerge:<docId>` form and let routing re-run on the hashchange.
+    const legacyDocId = BIG_PATCHWORK_HASH_REGEX.exec(hash)?.groups?.docId;
+    if (legacyDocId && isValidDocumentId(legacyDocId)) {
+      window.location.hash = serializeHashParams(
+        new URLSearchParams({
+          doc: stringifyAutomergeUrl({ documentId: legacyDocId as DocumentId }),
+        })
+      );
       return;
     }
 
@@ -782,18 +766,10 @@ function installHashRouting(params: HashRoutingParams): void {
 
     const params = new URLSearchParams(hash);
     const docUrl = docParamToUrl(params.get("doc"));
-    const packageUrl = params.get("package");
     const toolId = params.get("tool");
     const title = params.get("title");
     const type = params.get("type");
     const frame = params.get("frame");
-
-    // Load the package that produced this document so its tool is available
-    // even when it isn't in the user's module settings.
-    if (packageUrl) {
-      void moduleWatcher.loadModules([packageUrl]);
-    }
-
     if (frame) {
       const frameDocUrl = docUrl ?? accountDocHandle.url;
       if (