@inkandswitch/patchwork-bootloader 0.0.8 → 0.0.9

package/dist/externals.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@inkandswitch/patchwork-bootloader",
-  "version": "0.0.8",
+  "version": "0.0.9",
   "author": "chee",
   "type": "module",
   "license": "MIT",

package/src/externals.ts

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

package/src/service-worker.ts

@@ -21,11 +21,7 @@ import {
   stringifyAutomergeUrl,
   type PeerId,
 } from "@automerge/automerge-repo/slim";
-import {
-  findHandleInFolderHandle,
-  resolvePackageExport,
-  type FolderDoc,
-} 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";
@@ -37,6 +33,7 @@ let cachename = "default";
 let debugging = false;
 
 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.
@@ -66,9 +63,7 @@ const slog = SwLogger.open().then((logger) => {
   return logger;
 });
 
-const cacheableStatuses = [
-  200, 203, 204, 206, 300, 301, 404, 405, 410, 414, 501,
-];
+const cacheableStatuses = [200, 203, 204, 206];
 
 function log(...args: any[]) {
   if (!debugging) return;
@@ -103,12 +98,13 @@ let repoPromise: Promise<Repo> | null = null;
 
 function getRepo() {
   if (!repoPromise) {
-    repoPromise = (async () => {
+    const p: Promise<Repo> = (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));
@@ -127,7 +123,7 @@ function getRepo() {
         },
         enableRemoteHeadsGossiping: true,
         subductionWebsocketEndpoints: SUBDUCTION_ENDPOINTS,
-        network: [new WebSocketClientAdapter("wss://sync3.automerge.org")],
+        //network: [new WebSocketClientAdapter("wss://sync3.automerge.org")],
       });
 
       (self as any).repo = repo;
@@ -143,6 +139,13 @@ 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;
 }
@@ -173,7 +176,20 @@ self.addEventListener("message", async (event) => {
   } else if (event.data.type == "port") {
     log("received messagechannel");
     const [port] = event.ports;
-    connectPort(port);
+    const source = event.source as Client | null;
+    // 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" }),
+        (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) });
+        }
+      )
+    );
   } else if (event.data.type == "cachename") {
     const nextCachename = event.data.cachename;
     if (cachename == nextCachename) {
@@ -190,11 +206,6 @@ self.addEventListener("message", async (event) => {
   }
 });
 
-interface FileDoc {
-  content: string | Uint8Array;
-  mimeType?: string;
-}
-
 // ── Automerge URL resolution ───────────────────────────────────────────
 
 async function resolveAutomergeUrl(automergeURL: URL): Promise<Response> {
@@ -210,10 +221,10 @@ async function resolveAutomergeUrl(automergeURL: URL): Promise<Response> {
   if (path.length && !path[path.length - 1]) path.pop();
 
   const { heads, 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)}`;
@@ -221,93 +232,26 @@ async function resolveAutomergeUrl(automergeURL: URL): Promise<Response> {
     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<FolderDoc>(maybeAutomergeUrl);
-
-  let fileHandle;
-  if (path.length) {
-    // Try direct file navigation first
-    fileHandle = await findHandleInFolderHandle<FileDoc>(
-      repo,
-      folderHandle,
-      path.map(decodeURIComponent)
-    );
+  const rootHandle = await repo.find(maybeAutomergeUrl, { signal });
 
-    // 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<FileDoc>(
-        repo,
-        folderHandle,
-        ["package.json"]
-      );
-      if (pkgFileHandle) {
-        const pkgDoc = pkgFileHandle.doc() as FileDoc | undefined;
-        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<FileDoc>(
-                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<FileDoc>(
-      repo,
-      folderHandle,
-      ["package.json"]
-    );
-    if (pkgFileHandle) {
-      const pkgDoc = pkgFileHandle.doc() as FileDoc | undefined;
-      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<FileDoc>(
-              repo,
-              folderHandle,
-              resolvedPath
-            );
-          }
-        } catch {}
-      }
-    }
-  }
+  const resolved = await resolvePath(
+    repo,
+    rootHandle,
+    path.map(decodeURIComponent)
+  );
 
-  if (!fileHandle) {
+  if (!resolved) {
     throw new Error(
       `couldn't resolve ${path.join("/")} in folder at ${maybeAutomergeUrl}`
     );
   }
 
-  const fileDoc = fileHandle.doc() as unknown as FileDoc;
-  const content = fileDoc?.content;
-  if (!content) {
-    throw new Error(`file at ${href} has no content`);
-  }
-
-  let body: BodyInit =
-    content instanceof Uint8Array
-      ? (new Uint8Array(content) as BlobPart)
-      : String(content);
-  const mimeType = fileDoc.mimeType ?? "text/plain";
+  const body: BodyInit =
+    resolved.content instanceof Uint8Array
+      ? (new Uint8Array(resolved.content) as BlobPart)
+      : resolved.content;
 
-  const headers = new Headers({ "content-type": mimeType });
+  const headers = new Headers({ "content-type": resolved.type });
   headers.set("cross-origin-embedder-policy", "credentialless");
   headers.set("cross-origin-resource-policy", "cross-origin");
 
@@ -353,7 +297,18 @@ self.addEventListener("fetch", (fetchEvent: FetchEvent) => {
             });
           }
 
-          const response = await resolveAutomergeUrl(specialURL);
+          const response = await Promise.race([
+            resolveAutomergeUrl(specialURL),
+            new Promise<never>((_, reject) =>
+              setTimeout(
+                () =>
+                  reject(
+                    new Error(`resolve timeout after ${RESOLVE_TIMEOUT_MS}ms`)
+                  ),
+                RESOLVE_TIMEOUT_MS
+              )
+            ),
+          ]);
 
           if (response.status === 307) {
             return response;

package/src/setup.ts

@@ -73,6 +73,11 @@ export default async function setupServiceWorker(
   });
 
   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
@@ -94,9 +99,45 @@ export default async function setupServiceWorker(
     });
   }
 
-  // Send a MessagePort so the SW's repo can sync with clients
+  // 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 { port1, port2 } = new MessageChannel();
+  const swReady = new Promise<void>((resolve, reject) => {
+    let timeout: ReturnType<typeof setTimeout>;
+    const cleanup = () => {
+      clearTimeout(timeout);
+      navigator.serviceWorker.removeEventListener("message", listener);
+    };
+    const listener = (event: MessageEvent) => {
+      if (event.data?.type === "port-ready") {
+        cleanup();
+        resolve();
+      } else if (event.data?.type === "port-failed") {
+        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);
+  });
   navigator.serviceWorker.controller!.postMessage({ type: "port" }, [port2]);
+  try {
+    await swReady;
+  } catch (err) {
+    console.warn(
+      "proceeding without SW ready ack:",
+      err instanceof Error ? err.message : err
+    );
+  }
 
   // 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

package/src/site.ts

@@ -44,11 +44,14 @@ 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");
 
 declare global {
   interface Window {
@@ -59,7 +62,7 @@ declare global {
     getRepoChannel: () => MessagePort;
     patchwork: {
       repo: Repo;
-      modules: ModuleWatcher;
+      packages: ModuleWatcher;
       plugins: typeof plugins;
       accountDocHandle: DocHandle<AccountDoc>;
       sw: {
@@ -125,6 +128,11 @@ const DEFAULT_REMOTE_STORAGE_ID =
 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.
  *
@@ -138,12 +146,8 @@ export async function bootPatchworkSite(
   config: SiteConfig
 ): Promise<BootResult> {
   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);
 
@@ -153,7 +157,10 @@ export async function bootPatchworkSite(
       return peerId.includes("service-worker");
     },
     enableRemoteHeadsGossiping: true,
+    peerId:
+      `${config.titleSuffix}-tab-${crypto.randomUUID()}` as AutomergeRepo.PeerId,
   });
+
   repo.subscribeToRemotes(
     config.remoteStorageIds ?? [DEFAULT_REMOTE_STORAGE_ID]
   );
@@ -173,8 +180,9 @@ export async function bootPatchworkSite(
   // is added lazily once it appears on the account doc — see below.
   const moduleWatcher = new ModuleWatcher(
     repo,
-    [defaultModulesUrl],
-    onModuleLoaded
+    { system: defaultModulesUrl },
+    onModuleLoaded,
+    unregisterPlugins
   );
 
   const accountDocHandle = await resolveAccountHandle(repo, {
@@ -197,7 +205,7 @@ export async function bootPatchworkSite(
 
   window.patchwork = {
     repo,
-    modules: moduleWatcher,
+    packages: moduleWatcher,
     plugins,
     accountDocHandle,
     sw: buildSwLogApi(),
@@ -247,14 +255,14 @@ function installDevConsoleGlobals(repo: Repo): void {
 
 function onModuleLoaded(name: string, mod: any): void {
   if (Array.isArray(mod.plugins)) {
-    console.log(
-      `[site] registering ${mod.plugins.length} plugin(s) from ${name.slice(0, 30)}...`,
+    log(
+      `registering ${mod.plugins.length} plugin(s) from ${name.slice(0, 30)}...`,
       mod.plugins.map((p: any) => `${p.type}:${p.id}`)
     );
     registerPlugins(mod.plugins, name);
   } else {
     console.warn(
-      `[site] module ${name.slice(0, 30)}... has no plugins array`,
+      `module ${name.slice(0, 30)}... has no plugins array`,
       Object.keys(mod)
     );
   }
@@ -272,7 +280,7 @@ function wireModuleSettingsWhenReady(
   const wire = () => {
     const url = accountDocHandle.doc()?.moduleSettingsUrl;
     if (!url) return;
-    void moduleWatcher.addUrl(url);
+    void moduleWatcher.addUrl("user", url);
     accountDocHandle.off("change", wire);
   };
   wire();
@@ -291,7 +299,6 @@ function primeRootElement(
   accountDocHandle: DocHandle<AccountDoc>
 ): void {
   rootElement.style.visibility = "hidden";
-  showLoadingAnimation();
 
   const initialParams = new URLSearchParams(location.hash.slice(1));
   if (initialParams.has("frame")) {
@@ -312,13 +319,13 @@ function logToolRegistryWhenLoaded(moduleWatcher: ModuleWatcher): void {
     .then(() => {
       const toolReg = getRegistry("patchwork:tool");
       const tools = toolReg.all();
-      console.log(
-        `[site] doneLoading: ${tools.length} tools registered:`,
+      log(
+        `doneLoading: ${tools.length} tools registered:`,
         tools.map((t: any) => t.id)
       );
     })
     .catch((err: unknown) => {
-      console.error("[site] doneLoading rejected:", err);
+      console.error("doneLoading rejected:", err);
     });
 }
 
@@ -328,10 +335,10 @@ function buildSwLogApi(): Window["patchwork"]["sw"] {
       const entries = await SwLogReader.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);
+        if (e.data !== undefined) log(prefix, e.msg, e.data);
+        else log(prefix, e.msg);
       }
-      console.log(`--- ${entries.length} entries ---`);
+      log(`--- ${entries.length} entries ---`);
     },
     tailLogs: (n = 200) => SwLogReader.tail(n),
     exportLogs: () => SwLogReader.exportAll(),
@@ -363,6 +370,10 @@ function showLoadingAnimation(): void {
           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} {