@inkandswitch/patchwork-bootloader 0.0.8 → 0.1.0

package/CHANGELOG.md

@@ -1,5 +1,28 @@
 # @inkandswitch/patchwork-bootloader
 
+## 0.1.0
+
+### Minor Changes
+
+- e6afa48: Add `@inkandswitch/patchwork-bootloader/site` entry point exporting
+  `bootPatchworkSite(config)`, a full browser-app boot sequence that constructs
+  the Repo, wires the service-worker port, loads plugins via the ModuleWatcher,
+  resolves the user's account, and installs URL-hash routing + dev globals. This
+  lets per-site `main.ts` collapse to a ~10-line config object and keeps two
+  sibling sites from drifting apart.
+
+  Also removes the unused `@inkandswitch/patchwork-bootloader` devDependency from
+  `@inkandswitch/patchwork-plugins`, which eliminated a cyclic workspace edge.
+
+### Patch Changes
+
+- a847c4f: release
+- Updated dependencies [e6afa48]
+- Updated dependencies [a847c4f]
+  - @inkandswitch/patchwork-plugins@0.0.8
+  - @inkandswitch/patchwork-elements@0.0.8
+  - @inkandswitch/patchwork-filesystem@0.0.6
+
 ## 0.0.4
 
 ### Patch Changes

package/dist/externals.js

@@ -6,7 +6,12 @@ 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-repo-react-hooks",
+    "@automerge/automerge-repo-network-messagechannel",
+    "@automerge/automerge-repo-storage-indexeddb",
     "@automerge/automerge-subduction",
     "@automerge/automerge-subduction/slim",
     "@keyhive/keyhive",

package/dist/service-worker.js

@@ -6,21 +6,22 @@ import { SwLogger } from "./sw-logger.js";
 // 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 } from "@automerge/automerge/slim";
+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 { findHandleInFolderHandle, resolvePackageExport, } 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";
 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)
 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(),
@@ -46,9 +47,7 @@ const slog = SwLogger.open().then((logger) => {
     logger.info("sw-logger initialized");
     return logger;
 });
-const cacheableStatuses = [
-    200, 203, 204, 206, 300, 301, 404, 405, 410, 414, 501,
-];
+const cacheableStatuses = [200, 203, 204, 206];
 function log(...args) {
     if (!debugging)
         return;
@@ -72,11 +71,12 @@ self.addEventListener("activate", async () => {
 let repoPromise = null;
 function getRepo() {
     if (!repoPromise) {
-        repoPromise = (async () => {
+        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").then((r) => r.arrayBuffer()),
+                fetch("/automerge.wasm?sw").then((r) => r.arrayBuffer()),
                 fetch("/subduction.wasm").then((r) => r.arrayBuffer()),
             ]);
             initSubductionSync(new Uint8Array(sdnWasmBuf));
@@ -93,7 +93,7 @@ function getRepo() {
                 },
                 enableRemoteHeadsGossiping: true,
                 subductionWebsocketEndpoints: SUBDUCTION_ENDPOINTS,
-                network: [new WebSocketClientAdapter("wss://sync3.automerge.org")],
+                //network: [new WebSocketClientAdapter("wss://sync3.automerge.org")],
             });
             self.repo = repo;
             logger.info("repo constructed, waiting for network subsystem");
@@ -106,6 +106,14 @@ 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;
 }
@@ -122,19 +130,36 @@ self.addEventListener("message", async (event) => {
         const [pongPort] = event.ports;
         log("ping");
         if (pongPort) {
-            pongPort.postMessage({ type: "pong" });
+            pongPort.postMessage({ type: "pong", workerInstanceId });
             log("pong");
             pongPort.close();
         }
         else if (event.source) {
-            event.source.postMessage({ type: "pong" });
+            event.source.postMessage({
+                type: "pong",
+                workerInstanceId,
+            });
             log("pong");
         }
     }
     else if (event.data.type == "port") {
         log("received messagechannel");
         const [port] = event.ports;
-        connectPort(port);
+        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") {
         const nextCachename = event.data.cachename;
@@ -161,10 +186,10 @@ async function resolveAutomergeUrl(automergeURL) {
     // Trim trailing empty path segment
     if (path.length && !path[path.length - 1])
         path.pop();
-    const { heads, documentId } = parseAutomergeUrl(maybeAutomergeUrl);
+    const { heads, hexHeads, 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)}`;
@@ -172,67 +197,24 @@ async function resolveAutomergeUrl(automergeURL) {
             location += `/${path.join("/")}`;
         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(maybeAutomergeUrl);
-    let fileHandle;
-    if (path.length) {
-        // Try direct file navigation first
-        fileHandle = await findHandleInFolderHandle(repo, folderHandle, path.map(decodeURIComponent));
-        // 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(repo, folderHandle, ["package.json"]);
-            if (pkgFileHandle) {
-                const pkgDoc = pkgFileHandle.doc();
-                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(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(repo, folderHandle, ["package.json"]);
-        if (pkgFileHandle) {
-            const pkgDoc = pkgFileHandle.doc();
-            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(repo, folderHandle, resolvedPath);
-                    }
-                }
-                catch { }
-            }
-        }
+    // 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,
+    });
+    if (!hasHeads(baseHandle.doc(), hexHeads ?? [])) {
+        return new Response("heads not found", { status: 404 });
     }
-    if (!fileHandle) {
+    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 fileDoc = fileHandle.doc();
-    const content = fileDoc?.content;
-    if (!content) {
-        throw new Error(`file at ${href} has no content`);
-    }
-    let body = content instanceof Uint8Array
-        ? new Uint8Array(content)
-        : String(content);
-    const mimeType = fileDoc.mimeType ?? "text/plain";
-    const headers = new Headers({ "content-type": mimeType });
+    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 });
@@ -269,7 +251,10 @@ self.addEventListener("fetch", (fetchEvent) => {
                         headers,
                     });
                 }
-                const response = await resolveAutomergeUrl(specialURL);
+                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;
                 }

package/dist/setup.d.ts

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

package/dist/setup.js

@@ -1,6 +1,8 @@
 import debug from "debug";
 const debugging = debug.enabled("patchwork:serviceworker");
 const key = "patchworkServiceWorkerCacheVersion";
+let nextRepoChannelId = 0;
+let serviceWorkerInstanceId;
 function bumpServiceWorkerCacheVersion() {
     const version = new Date().valueOf().toString(36);
     localStorage.setItem(key, version);
@@ -29,6 +31,21 @@ export function bumpServiceWorkerCache(sw = navigator.serviceWorker.controller)
     setServiceWorkerCacheName(sw);
 }
 window.bumpServiceWorkerCache = bumpServiceWorkerCache;
+function configureServiceWorker(sw) {
+    if (!sw)
+        return;
+    sw.postMessage({ type: "debug", debug: debugging });
+    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;
+}
 /** Wait for a registration to have an active worker */
 function waitForActive(reg) {
     if (reg.active)
@@ -43,51 +60,154 @@ 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
+    // 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 id = ++nextRepoChannelId;
+    let workerInstanceChanged = false;
+    const { port1, port2 } = new MessageChannel();
+    const swReady = new Promise((resolve, reject) => {
+        let timeout;
+        const cleanup = () => {
+            clearTimeout(timeout);
+            navigator.serviceWorker.removeEventListener("message", listener);
+        };
+        const listener = (event) => {
+            if (event.data?.id != null && 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}`));
+            }
+        };
+        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);
+    });
+    controller.postMessage({ type: "port", id }, [port2]);
+    try {
+        await swReady;
+    }
+    catch (err) {
+        console.warn("proceeding without SW ready ack:", err instanceof Error ? err.message : err);
+    }
+    return { port: port1, workerInstanceChanged };
+}
 export default async function setupServiceWorker(options) {
-    // Backwards compat: if an old service worker sends handoff "request" messages,
-    // immediately reject them so its fetch handler doesn't hang forever.
-    navigator.serviceWorker.addEventListener("message", (event) => {
-        if (event.data?.type === "request" && event.data.id != null) {
-            navigator.serviceWorker.controller?.postMessage({
-                type: "response",
-                id: event.data.id,
-                response: {
-                    body: "service worker upgraded, please refresh",
-                    status: 503,
-                    headers: { "content-type": "text/plain" },
-                },
-            });
+    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);
+        }
+    };
     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
+    // activation so the app boots with the SW in control of generated fetches.
     const reg = await navigator.serviceWorker.register(path, { type: "module" });
     // If there's an update waiting or installing, wait for it to activate
+    let active = reg.active;
     if (reg.installing || reg.waiting) {
-        await waitForActive(reg);
+        active = await waitForActive(reg);
     }
-    const active = reg.active;
-    active.postMessage({ type: "debug", debug: debugging });
+    configureServiceWorker(active);
     // Wait for the controller to be available
     if (!navigator.serviceWorker.controller) {
         await new Promise((resolve) => {
             navigator.serviceWorker.addEventListener("controllerchange", () => resolve(), { once: true });
         });
     }
-    // Send a MessagePort so the SW's repo can sync with clients
-    const { port1, port2 } = new MessageChannel();
-    navigator.serviceWorker.controller.postMessage({ type: "port" }, [port2]);
     // 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. Send a ping every 20s while the page is visible to keep it warm.
+    // 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(() => {
-        navigator.serviceWorker.controller?.postMessage({ type: "ping" });
+        void pingServiceWorker();
     }, 20_000);
-    // Reload on future SW updates (added after setup so the initial
-    // activation doesn't trigger a reload loop).
+    // Reconnect on future SW updates (added after setup so the initial
+    // activation doesn't notify before callers subscribe).
     navigator.serviceWorker.addEventListener("controllerchange", function () {
-        console.info("%cnew service worker took control, reloading...", "color: pink; font-weight: bold");
-        location.reload();
+        void reconnectRepoChannels("took control").catch((err) => {
+            console.error("service worker reconnect failed", err);
+        });
     });
     console.log("service worker alive, loading %c patchwork system ", "background: #fcf2f0; color: #333; border: 2px solid; border-radius: 4px");
-    return { port: port1 };
+    return {
+        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);
+        },
+    };
 }

package/dist/site.d.ts

@@ -15,6 +15,7 @@ import { type DocHandle, Repo, type AutomergeUrl, type StorageId } from "@autome
 import { ModuleWatcher } from "@inkandswitch/patchwork-filesystem";
 import { type AccountDoc } from "@inkandswitch/patchwork-plugins";
 import * as plugins from "@inkandswitch/patchwork-plugins";
+import type { ServiceWorkerRepoChannelListener } from "./types.js";
 import { SwLogReader } from "./sw-logger.js";
 declare global {
     interface Window {
@@ -22,10 +23,9 @@ declare global {
         Automerge: typeof import("@automerge/automerge");
         AutomergeRepo: typeof import("@automerge/automerge-repo");
         repo: Repo;
-        getRepoChannel: () => MessagePort;
         patchwork: {
             repo: Repo;
-            modules: ModuleWatcher;
+            packages: ModuleWatcher;
             plugins: typeof plugins;
             accountDocHandle: DocHandle<AccountDoc>;
             sw: {
@@ -33,6 +33,7 @@ declare global {
                 tailLogs: (n?: number) => ReturnType<typeof SwLogReader.tail>;
                 exportLogs: () => Promise<string>;
                 clearLogs: () => Promise<void>;
+                subscribeToRepoChannel: (listener: ServiceWorkerRepoChannelListener) => Promise<() => void>;
             };
         };
         uncache: (match: string) => Promise<void>;