@inkandswitch/patchwork-bootloader 0.2.8 → 0.3.1

package/dist/setup.js

@@ -2,6 +2,37 @@ import { readClassicSyncServer, DEFAULT_CLASSIC_SYNC_SERVER, } from "./sync-conf
 import debug from "debug";
 const serviceWorkerDebugging = debug.enabled("patchwork:serviceworker");
 const workerDebugging = debug.enabled("patchwork:automergeworker");
+// Diagnostic [lifecycle] logging, on by default. Disable via
+// localStorage["patchwork:lifecycle-logs"] = "off". Read live at log time.
+const LIFECYCLE_LOG_KEY = "patchwork:lifecycle-logs";
+export function lifecycleLoggingEnabled() {
+    try {
+        const v = globalThis.localStorage?.getItem(LIFECYCLE_LOG_KEY);
+        return v !== "off" && v !== "false" && v !== "0" && v !== "no";
+    }
+    catch {
+        return true;
+    }
+}
+// The SW can't read localStorage, so it always emits [lifecycle] markers and
+// forwards them as `sw-lifecycle`; gate rendering here on the live toggle.
+let swLifecycleListenerInstalled = false;
+function installServiceWorkerLogForwarding() {
+    if (swLifecycleListenerInstalled)
+        return;
+    if (typeof navigator === "undefined" || !navigator.serviceWorker)
+        return;
+    swLifecycleListenerInstalled = true;
+    navigator.serviceWorker.addEventListener("message", (event) => {
+        const data = event.data;
+        if (data?.type !== "sw-lifecycle")
+            return;
+        if (!lifecycleLoggingEnabled())
+            return;
+        const fn = console[data.level] ?? console.log;
+        fn(`[service-worker] ${data.msg}`);
+    });
+}
 const key = "patchworkServiceWorkerCacheVersion";
 let nextRepoChannelId = 0;
 function bumpServiceWorkerCacheVersion() {
@@ -48,7 +79,7 @@ function configureServiceWorker(sw) {
 // port; it talks to the service worker over a BroadcastChannel.
 let automergeWorkerPath = "/automerge-worker.js";
 let automergeWorker;
-function getAutomergeWorker() {
+export function getAutomergeWorker() {
     if (!automergeWorker) {
         automergeWorker = new SharedWorker(automergeWorkerPath, {
             name: "patchwork-automerge",
@@ -57,10 +88,99 @@ function getAutomergeWorker() {
         // Control replies (port-ready &c) come back on this port, so it needs
         // start() — we listen with addEventListener, not onmessage.
         automergeWorker.port.start();
+        // Surface the SharedWorker's console output and uncaught errors in this
+        // tab's console (it has its own console that's awkward to find otherwise).
+        automergeWorker.port.addEventListener("message", (event) => {
+            if (event.data?.type !== "console")
+                return;
+            const { level, args } = event.data;
+            // Gate forwarded [lifecycle] logs on the toggle too.
+            if (!lifecycleLoggingEnabled() &&
+                typeof args?.[0] === "string" &&
+                args[0].includes("[lifecycle]")) {
+                return;
+            }
+            const fn = console[level] ?? console.log;
+            // The worker's logs (debug library, the worker's own log()) carry %c
+            // format directives in args[0] with CSS in the following args. Prefix
+            // the tag into the format string rather than as a separate positional,
+            // or the %c would no longer be in arg 0 and the CSS would print raw.
+            if (typeof args[0] === "string") {
+                fn(`[automerge-worker] ${args[0]}`, ...args.slice(1));
+            }
+            else {
+                fn("[automerge-worker]", ...args);
+            }
+        });
         automergeWorker.port.postMessage({ type: "debug", debug: workerDebugging });
+        installWorkerDeathDetection(automergeWorker);
     }
     return automergeWorker;
 }
+/**
+ * Detect when the automerge SharedWorker dies or restarts: control-port close,
+ * worker error, changed instance id, or an unanswered heartbeat while the tab
+ * is visible (a miss while hidden is more likely suspension). [lifecycle]-tagged.
+ */
+function installWorkerDeathDetection(worker) {
+    const stamp = () => new Date().toISOString();
+    const warn = (msg) => {
+        if (lifecycleLoggingEnabled())
+            console.warn(`[lifecycle] ${stamp()} ${msg}`);
+    };
+    const info = (msg) => {
+        if (lifecycleLoggingEnabled())
+            console.info(`[lifecycle] ${stamp()} ${msg}`);
+    };
+    let instanceId;
+    let lastPongAt = Date.now();
+    let warnedUnresponsive = false;
+    worker.port.addEventListener("message", (event) => {
+        const data = event.data;
+        if (data?.type !== "hello" && data?.type !== "pong")
+            return;
+        if (data.type === "pong") {
+            lastPongAt = Date.now();
+            warnedUnresponsive = false;
+        }
+        if (instanceId === undefined) {
+            instanceId = data.instanceId;
+            info(`automerge SharedWorker instance ${data.instanceId} (via ${data.type})`);
+        }
+        else if (data.instanceId && data.instanceId !== instanceId) {
+            warn(`automerge SharedWorker RESTARTED (instance ${data.instanceId}, ` +
+                `was ${instanceId}) — fresh peerId + cold state; docs need re-subscribe`);
+            instanceId = data.instanceId;
+        }
+    });
+    // Fires when the SharedWorker is destroyed (where supported).
+    worker.port.addEventListener("close", () => {
+        warn("automerge SharedWorker control port CLOSED — worker terminated");
+    });
+    worker.addEventListener("error", event => {
+        warn(`automerge SharedWorker error: ${event.message || event}`);
+    });
+    // A missed pong while the tab is visible means the worker likely died (an
+    // active tab keeps it alive); a miss while hidden is more likely suspension.
+    const HEARTBEAT_MS = 10_000;
+    const HEARTBEAT_TIMEOUT_MS = 25_000;
+    let seq = 0;
+    setInterval(() => {
+        try {
+            worker.port.postMessage({ type: "ping", id: ++seq });
+        }
+        catch {
+            // Port already torn down — the "close" handler covers that case.
+        }
+        const silentMs = Date.now() - lastPongAt;
+        const visible = typeof document === "undefined" || document.visibilityState === "visible";
+        if (silentMs > HEARTBEAT_TIMEOUT_MS && visible && !warnedUnresponsive) {
+            warnedUnresponsive = true;
+            warn(`automerge SharedWorker UNRESPONSIVE ~${Math.round(silentMs / 1000)}s ` +
+                `while tab visible — likely died/crashed`);
+        }
+    }, HEARTBEAT_MS);
+}
 export function connectClassicSync(server = readClassicSyncServer()) {
     const url = server.trim() || DEFAULT_CLASSIC_SYNC_SERVER;
     if (!/^wss?:\/\//.test(url)) {
@@ -155,11 +275,15 @@ function getRepoChannel() {
     return port1;
 }
 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();
     if (options?.workerPath)
         automergeWorkerPath = options.workerPath;
     // Start the automerge worker right away so it boots (wasm, repo) while the
     // service worker installs.
-    getAutomergeWorker();
+    const shared = getAutomergeWorker();
+    // todo delete
     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
@@ -183,7 +307,15 @@ export default async function setupServiceWorker(options) {
         configureServiceWorker(navigator.serviceWorker.controller);
     });
     console.log("service worker alive, loading %c patchwork system ", "background: #fcf2f0; color: #333; border: 2px solid; border-radius: 4px");
+    // todon't
+    window.killsw = () => {
+        if (automergeWorker) {
+            automergeWorker.port.close();
+            automergeWorker = undefined;
+        }
+    };
     return {
+        shared,
         connectClassicSync,
         getRepoChannel,
         async subscribeToRepoChannel(listener) {

package/dist/site.d.ts

@@ -11,7 +11,7 @@
  * site's `main.ts`. Non-UI consumers should import the package default (which
  * only does SW registration and the automerge-worker handoff).
  */
-import { type DocHandle, Repo, type AutomergeUrl, type StorageId } from "@automerge/vanillajs/slim";
+import { type DocHandle, Repo, type AutomergeUrl } from "@automerge/vanillajs/slim";
 import { type AutomergeRepoKeyhive } from "@automerge/automerge-repo-keyhive";
 import { ModuleWatcher } from "@inkandswitch/patchwork-filesystem";
 import { type AccountDoc } from "@inkandswitch/patchwork-plugins";
@@ -40,16 +40,32 @@ declare global {
 }
 export interface SiteConfig {
     /**
-     * Automerge URL of the site's default module-settings document — the bundle
-     * of tools every user of this site gets out of the box. Must contribute at
-     * least a `patchwork:datatype` registration for `"account"` (typically the
-     * one supplied by `@inkandswitch/patchwork-frame`).
+     * The site's default tool bundle — the tools every user of this site gets
+     * out of the box. Must collectively contribute at least a
+     * `patchwork:datatype` registration for `"account"` (typically the one
+     * supplied by `@inkandswitch/patchwork-frame`).
+     *
+     * Each entry is a *module-list source* and may be either:
+     *  - an Automerge module-settings doc URL (`automerge:...`), which is
+     *    live-reloaded, or
+     *  - an HTTP(S) URL (absolute or site-relative, e.g. `/modules.json`) to a
+     *    static JSON manifest of the shape `{ modules: string[], branches? }`,
+     *    fetched once at boot.
+     *
+     * The module URLs *inside* either kind of source may themselves be Automerge
+     * folder docs or plain HTTP(S) bundles, so deployment targets can be freely
+     * mixed.
      *
      * Can be overridden at runtime by setting `localStorage.defaultToolsUrl` to
-     * another automerge: URL — useful for local development against an
-     * unpublished tool set.
+     * another `automerge:` URL or manifest URL — useful for local development
+     * against an unpublished tool set.
+     */
+    defaultModules?: string | string[];
+    /**
+     * @deprecated Use {@link SiteConfig.defaultModules}. Retained for backwards
+     * compatibility with existing sites.
      */
-    defaultModulesUrl: AutomergeUrl;
+    defaultModulesUrl?: AutomergeUrl;
     /**
      * `localStorage` key under which this site remembers which account document
      * belongs to the current user. Sites sharing an origin MUST use distinct
@@ -66,11 +82,6 @@ export interface SiteConfig {
      * Defaults to `"root"`.
      */
     rootElementId?: string;
-    /**
-     * Storage IDs to subscribe to for remote-heads gossiping. Defaults to
-     * Ink & Switch's production Subduction storage.
-     */
-    remoteStorageIds?: StorageId[];
     /**
      * When true, initialize keyhive for access control.
      * The Repo will use keyhive's network adapter, peerId, and idFactory

package/dist/site.js

@@ -11,23 +11,25 @@
  * site's `main.ts`. Non-UI consumers should import the package default (which
  * only does SW registration and the automerge-worker handoff).
  */
-import { IndexedDBStorageAdapter, initializeWasm, isValidAutomergeUrl, isValidDocumentId, MessageChannelNetworkAdapter, parseAutomergeUrl, Repo, stringifyAutomergeUrl, } from "@automerge/vanillajs/slim";
+import { initializeWasm, isValidAutomergeUrl, isValidDocumentId, MessageChannelNetworkAdapter, parseAutomergeUrl, Repo, stringifyAutomergeUrl, } from "@automerge/vanillajs/slim";
+import { IndexedDBWorkerStorageAdapter } from "@automerge/automerge-repo-storage-indexeddb/IndexedDBWorkerStorageAdapter";
 import * as Automerge from "@automerge/automerge/slim";
 import * as AutomergeRepo from "@automerge/automerge-repo/slim";
-import { initKeyhiveWasm, initializeAutomergeRepoKeyhive, } from "@automerge/automerge-repo-keyhive";
+import { initKeyhiveWasm, initializeAutomergeRepoKeyhiveWithRepo, } from "@automerge/automerge-repo-keyhive";
 // 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";
 const siteName = typeof __SITE_NAME__ !== "undefined" ? __SITE_NAME__ : "tiny-patchwork";
+const useKeyhiveSyncServer = typeof __KEYHIVE_SYNC_SERVER__ !== "undefined" && __KEYHIVE_SYNC_SERVER__;
 import { ModuleWatcher } from "@inkandswitch/patchwork-filesystem";
+import { importAutomergeModuleViaWorker } from "./module-loader.js";
 import { openDocument, registerPatchworkViewElement, } from "@inkandswitch/patchwork-elements";
 import { registerRepoProviderElement } from "@inkandswitch/patchwork-providers";
 import { getRegistry, registerPlugins, resolveAccountHandle, unregisterPlugins, } from "@inkandswitch/patchwork-plugins";
 import * as plugins from "@inkandswitch/patchwork-plugins";
-import setupServiceWorker from "./setup.js";
+import setupServiceWorker, { lifecycleLoggingEnabled, } from "./setup.js";
 import debug from "debug";
 const log = debug("patchwork:bootloader:site");
-const DEFAULT_REMOTE_STORAGE_ID = "3760df37-a4c6-4f66-9ecd-732039a9385d";
 // Legacy big-patchwork hash shape: `slug--<documentId>[?=type]`.
 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([
@@ -44,53 +46,79 @@ const [automergeWasm, subductionWasm] = await Promise.all([
  * do additional wiring after boot.
  */
 export async function bootPatchworkSite(config) {
-    const defaultModulesUrl = resolveDefaultModulesUrl(config.defaultModulesUrl);
+    const defaultModuleSources = resolveDefaultModules(config);
     showLoadingAnimation();
     log(`booting`, config);
+    installLifecycleLogging();
     await initializeWasm(automergeWasm);
     initSubductionSync(subductionWasm);
+    log("enabling workers");
     const sw = await setupServiceWorker();
     if (!sw)
         throw new Error("Failed to set up service worker");
+    log("workers ready");
     let hive;
-    // Get the initial automerge-worker port via subscribeToRepoChannel,
-    // then pass it to keyhive init which wraps it in its own network adapter.
-    let resolvePort;
-    const portPromise = new Promise((r) => {
-        resolvePort = r;
-    });
-    await sw.subscribeToRepoChannel(resolvePort);
-    const workerPort = await portPromise;
-    if (config.keyhive) {
-        initKeyhiveWasm();
-        hive = await initializeAutomergeRepoKeyhive({
-            storage: new IndexedDBStorageAdapter(`${siteName}-keyhive`),
-            peerIdSuffix: siteName + Math.random().toString(36).slice(2),
-            networkAdapter: new MessageChannelNetworkAdapter(workerPort),
-            automaticArchiveIngestion: true,
-            cachingMode: "periodic",
-            onlyShareWithHardcodedServerPeerId: false,
-        });
+    let repo;
+    // If a Repo is already on `window` — an embedding context provided one before
+    // this entry ran — reuse it and its keyhive instead of standing up a fresh
+    // realm-local Repo, so we share the same documents and sync/keyhive context.
+    // Otherwise create our own below.
+    if (window.repo) {
+        log("using existing Repo from window");
+        repo = window.repo;
+        hive = window.hive;
     }
-    const repo = hive
-        ? new Repo({
-            storage: new IndexedDBStorageAdapter(),
-            enableRemoteHeadsGossiping: true,
-            network: [hive.networkAdapter],
-            peerId: hive.peerId,
-            idFactory: hive.idFactory,
-        })
-        : new Repo({
-            network: [new MessageChannelNetworkAdapter(workerPort)],
-            storage: new IndexedDBStorageAdapter(),
-            async sharePolicy(peerId) {
-                return peerId.includes("automerge-worker");
-            },
-            enableRemoteHeadsGossiping: true,
-            peerId: `${config.titleSuffix}-tab-${crypto.randomUUID()}`,
+    else {
+        // Get the initial automerge-worker port via subscribeToRepoChannel,
+        // then pass it to keyhive init which wraps it in its own network adapter.
+        let resolvePort;
+        const portPromise = new Promise((r) => {
+            resolvePort = r;
         });
-    repo.subscribeToRemotes(config.remoteStorageIds ?? [DEFAULT_REMOTE_STORAGE_ID]);
+        log("subscribing to repo channel");
+        await sw.subscribeToRepoChannel(resolvePort);
+        log("repo channel subscribed");
+        const workerPort = await portPromise;
+        if (config.keyhive) {
+            log("setting up keyhive");
+            initKeyhiveWasm();
+            ({ hive, repo } = await initializeAutomergeRepoKeyhiveWithRepo({
+                createRepo: (config) => new Repo(config),
+                storage: new IndexedDBWorkerStorageAdapter(`${siteName}-keyhive`),
+                peerIdSuffix: siteName + Math.random().toString(36).slice(2),
+                networkAdapter: new MessageChannelNetworkAdapter(workerPort),
+                automaticArchiveIngestion: true,
+                cachingMode: "periodic",
+                onlyShareWithHardcodedServerPeerId: false,
+                // ARK selects the relay via `syncServer` ("keyhive" | "subduction").
+                // Defaults to "subduction".
+                ...(useKeyhiveSyncServer ? { syncServer: "keyhive" } : {}),
+                repo: {
+                    storage: new IndexedDBWorkerStorageAdapter(),
+                    enableRemoteHeadsGossiping: true,
+                },
+            }));
+            log("keyhive setup complete");
+        }
+        else {
+            log("creating repo");
+            repo = new Repo({
+                network: [new MessageChannelNetworkAdapter(workerPort)],
+                storage: new IndexedDBWorkerStorageAdapter(),
+                async sharePolicy(peerId) {
+                    return peerId.includes("automerge-worker");
+                },
+                enableRemoteHeadsGossiping: true,
+                peerId: `${config.titleSuffix}-tab-${crypto.randomUUID()}`,
+            });
+            log("repo created");
+        }
+    }
+    log("popping repo on window");
+    window.repo = repo;
+    log("await repo.networkSubsystem.whenReady()");
     await repo.networkSubsystem.whenReady();
+    log("networkSubsystem ready");
     if (hive) {
         hive.networkAdapter.syncKeyhive?.();
     }
@@ -110,7 +138,10 @@ export async function bootPatchworkSite(config) {
     // `resolveAccountHandle` below has something to await on (the `account`
     // datatype lives in that bundle today). The user's own module-settings URL
     // is added lazily once it appears on the account doc — see below.
-    const moduleWatcher = new ModuleWatcher(repo, { system: defaultModulesUrl }, onModuleLoaded, unregisterPlugins);
+    const moduleWatcher = new ModuleWatcher(repo, buildSystemSources(defaultModuleSources), onModuleLoaded, unregisterPlugins, 
+    // Discover an Automerge package's plugin descriptors off the main thread;
+    // each plugin's load() re-imports the package (at heads) on this thread.
+    importAutomergeModuleViaWorker);
     const accountDocHandle = (await resolveAccountHandle(repo, {
         storageKey: config.accountStorageKey,
         hive,
@@ -142,18 +173,54 @@ export async function bootPatchworkSite(config) {
     return { repo, moduleWatcher, accountDocHandle };
 }
 // ─── Internals ──────────────────────────────────────────────────────────
-function resolveDefaultModulesUrl(builtin) {
+/**
+ * A module-list source is valid if it is an Automerge URL or looks like an
+ * HTTP(S)/site-relative manifest URL.
+ */
+function isValidModuleSource(source) {
+    if (isValidAutomergeUrl(source))
+        return true;
+    return (source.startsWith("/") ||
+        source.startsWith("http://") ||
+        source.startsWith("https://") ||
+        source.startsWith("./"));
+}
+/**
+ * Resolve the site's default module-list sources, honouring the
+ * `localStorage.defaultToolsUrl` dev override (which replaces the entire
+ * built-in default bundle).
+ */
+function resolveDefaultModules(config) {
+    const builtin = config.defaultModules ?? config.defaultModulesUrl ?? [];
+    const builtinList = (Array.isArray(builtin) ? builtin : [builtin]).filter(Boolean);
     const override = globalThis.localStorage?.getItem("defaultToolsUrl");
-    if (!override)
-        return builtin;
-    if (isValidAutomergeUrl(override)) {
-        if (override !== builtin) {
-            console.info(`using defaultToolsUrl override from localStorage: ${override}`);
+    if (override) {
+        if (isValidModuleSource(override)) {
+            if (!builtinList.includes(override)) {
+                console.info(`using defaultToolsUrl override from localStorage: ${override}`);
+            }
+            return [override];
         }
-        return override;
+        console.warn(`ignoring invalid defaultToolsUrl in localStorage: ${override}; using built-in default`);
+    }
+    if (builtinList.length === 0) {
+        throw new Error("bootPatchworkSite: no default module sources configured (set `defaultModules`)");
     }
-    console.warn(`ignoring invalid defaultToolsUrl in localStorage: ${override}; using built-in default`);
-    return builtin;
+    return builtinList;
+}
+/**
+ * Turn an ordered list of module-list sources into the name-keyed map the
+ * ModuleWatcher expects. The first source keeps the canonical `system` name;
+ * additional sources get suffixed names. None may be `user` (reserved for the
+ * per-account settings doc, which has branch-override precedence).
+ */
+function buildSystemSources(sources) {
+    const map = {};
+    sources.forEach((source, index) => {
+        const name = index === 0 ? "system" : `system-${index}`;
+        map[name] = source;
+    });
+    return map;
 }
 function installDevConsoleGlobals(repo, hive, getRepoChannel) {
     window.repo = repo;
@@ -164,6 +231,33 @@ function installDevConsoleGlobals(repo, hive, getRepoChannel) {
     }
     window.getRepoChannel = getRepoChannel;
 }
+/**
+ * Log this tab's Page Lifecycle + connectivity transitions (visibility,
+ * freeze, bfcache, online/offline) so they line up against the SharedWorker's
+ * sync-socket reaps. [lifecycle]-tagged, on by default.
+ */
+function installLifecycleLogging() {
+    if (typeof document === "undefined")
+        return;
+    const opts = { capture: true };
+    const note = (label, extra) => {
+        if (!lifecycleLoggingEnabled())
+            return;
+        const msg = `[lifecycle] ${new Date().toISOString()} ${label}`;
+        if (extra === undefined)
+            console.info(msg);
+        else
+            console.info(msg, extra);
+    };
+    document.addEventListener("visibilitychange", () => note(`visibilitychange → ${document.visibilityState}`), opts);
+    document.addEventListener("freeze", () => note("freeze (tab suspended)"), opts);
+    document.addEventListener("resume", () => note("resume (tab unsuspended)"), opts);
+    window.addEventListener("pageshow", e => note("pageshow", { persisted: e.persisted }), opts);
+    window.addEventListener("pagehide", e => note("pagehide", { persisted: e.persisted }), opts);
+    window.addEventListener("online", () => note("online"), opts);
+    window.addEventListener("offline", () => note("offline"), opts);
+    note(`lifecycle logging installed (visibilityState=${document.visibilityState}, hasFocus=${document.hasFocus()})`);
+}
 function onModuleLoaded(name, mod) {
     if (Array.isArray(mod.plugins)) {
         log(`registering ${mod.plugins.length} plugin(s) from ${name.slice(0, 30)}...`, mod.plugins.map((p) => `${p.type}:${p.id}`));
@@ -202,7 +296,7 @@ function primeRootElement(rootElement, accountDocHandle) {
     const initialParams = new URLSearchParams(location.hash.slice(1));
     if (initialParams.has("frame")) {
         rootElement.setAttribute("tool-id", initialParams.get("frame"));
-        const docId = initialParams.get("doc");
+        const docId = initialParams.get("doc")?.replace(/^automerge:/, "");
         const docUrl = docId
             ? stringifyAutomergeUrl({ documentId: docId })
             : accountDocHandle.url;
@@ -368,15 +462,22 @@ function installHashRouting(params) {
             }
             return;
         }
+        // Bare automerge URL in hash: /#automerge:<documentId>
+        if (isValidAutomergeUrl(hash)) {
+            const { documentId, heads } = parseAutomergeUrl(hash);
+            window.location.hash = "";
+            openDocument(rootElement, stringifyAutomergeUrl({ documentId, heads }));
+            return;
+        }
         const params = new URLSearchParams(hash);
-        const documentId = params.get("doc");
+        const documentId = params.get("doc")?.replace(/^automerge:/, "");
         const heads = params.get("heads")?.split("|");
         const toolId = params.get("tool");
         const title = params.get("title");
         const type = params.get("type");
         const frame = params.get("frame");
         if (frame) {
-            const docUrl = params.get("doc") ?? accountDocHandle.url;
+            const docUrl = params.get("doc")?.replace(/^automerge:/, "") ?? accountDocHandle.url;
             if (rootElement.getAttribute("tool-id") !== frame ||
                 rootElement.getAttribute("doc-url") !== docUrl) {
                 rootElement.setAttribute("tool-id", frame);

package/dist/types.d.ts

@@ -5,6 +5,12 @@
  * reintroduced when either of them restarts — and so tabs can listen in.
  */
 export declare const HANDOFF_CHANNEL = "@patchwork/handoff";
+/**
+ * BroadcastChannel on which the automerge shared worker announces remote
+ * heads it learns about from the sync server. Any tab can listen to stay
+ * informed of sync progress without repo-to-repo gossiping.
+ */
+export declare const SYNCSTATE_CHANNEL = "@patchwork/syncstate";
 /**
  * The special URL to resolve, plus enough of the {@link Request} the service
  * worker is holding that the automerge worker can construct one that
@@ -93,6 +99,8 @@ export type SetupServiceWorkerOptions = {
 };
 export type ServiceWorkerRepoChannelListener = (port: MessagePort) => void | Promise<void>;
 export type SetupServiceWorkerResult = {
+    shared?: SharedWorker;
+    kill?: () => void;
     /** Open a classic Automerge sync WebSocket from the automerge worker. */
     connectClassicSync: (server?: string) => Promise<void>;
     subscribeToRepoChannel: (listener: ServiceWorkerRepoChannelListener) => Promise<() => void>;

package/dist/types.js

@@ -5,3 +5,9 @@
  * reintroduced when either of them restarts — and so tabs can listen in.
  */
 export const HANDOFF_CHANNEL = "@patchwork/handoff";
+/**
+ * BroadcastChannel on which the automerge shared worker announces remote
+ * heads it learns about from the sync server. Any tab can listen to stay
+ * informed of sync progress without repo-to-repo gossiping.
+ */
+export const SYNCSTATE_CHANNEL = "@patchwork/syncstate";

package/dist/vite/service-worker-plugin.js

@@ -12,6 +12,10 @@ const workers = [
         specifier: "@inkandswitch/patchwork-bootloader/automerge-worker",
         fileName: "automerge-worker.js",
     },
+    {
+        specifier: "@inkandswitch/patchwork-bootloader/module-loader-worker",
+        fileName: "module-loader-worker.js",
+    },
 ];
 export function serviceworker() {
     const entryIds = new Set();

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "@inkandswitch/patchwork-bootloader",
-  "version": "0.2.8",
+  "version": "0.3.1",
   "author": "chee",
   "type": "module",
   "license": "MIT",
   "devDependencies": {
-    "@automerge/automerge-repo-keyhive": "0.3.0-alpha.sub.1c",
+    "@automerge/automerge-repo-keyhive": "0.3.0-alpha.sub.8b",
     "esbuild": "^0.23.1",
     "rollup": "^4.61.1"
   },
@@ -30,6 +30,10 @@
       "import": "./dist/automerge-worker.js",
       "types": "./dist/automerge-worker.d.ts"
     },
+    "./module-loader-worker": {
+      "import": "./dist/module-loader-worker.js",
+      "types": "./dist/module-loader-worker.d.ts"
+    },
     "./site": {
       "import": "./dist/site.js",
       "types": "./dist/site.d.ts"
@@ -41,28 +45,28 @@
   },
   "dependencies": {
     "@automerge/automerge": "3.3.0-fragments.1",
-    "@automerge/automerge-repo": "2.6.0-subduction.29",
-    "@automerge/automerge-repo-network-messagechannel": "2.6.0-subduction.29",
-    "@automerge/automerge-repo-network-websocket": "2.6.0-subduction.29",
-    "@automerge/automerge-repo-storage-indexeddb": "2.6.0-subduction.29",
-    "@automerge/automerge-subduction": "0.15.0",
-    "@automerge/vanillajs": "2.6.0-subduction.29",
-    "@keyhive/keyhive": "0.0.0-alpha.56",
+    "@automerge/automerge-repo": "2.6.0-subduction.39",
+    "@automerge/automerge-repo-network-messagechannel": "2.6.0-subduction.39",
+    "@automerge/automerge-repo-network-websocket": "2.6.0-subduction.39",
+    "@automerge/automerge-repo-storage-indexeddb": "2.6.0-subduction.39",
+    "@automerge/automerge-subduction": "0.16.0",
+    "@automerge/vanillajs": "2.6.0-subduction.39",
+    "@keyhive/keyhive": "0.1.0-alpha.5",
     "@types/debug": "^4.1.13",
     "debug": "^4.4.3",
     "resolve.exports": "^2.0.3",
     "service-worker-types": "npm:@types/serviceworker@^0.0.153",
     "tinyargs": "^0.1.4",
-    "@inkandswitch/patchwork-filesystem": "^0.0.8",
-    "@inkandswitch/patchwork-plugins": "^0.0.11",
+    "@inkandswitch/patchwork-filesystem": "^0.1.1",
+    "@inkandswitch/patchwork-elements": "^2.0.0",
     "@inkandswitch/patchwork-providers": "^0.3.0",
-    "@inkandswitch/patchwork-elements": "^2.0.0"
+    "@inkandswitch/patchwork-plugins": "^0.0.11"
   },
   "peerDependencies": {
     "@automerge/automerge": "3.3.0-fragments.1",
-    "@automerge/automerge-repo": "2.6.0-subduction.29",
-    "@automerge/automerge-repo-keyhive": "0.3.0-alpha.sub.1c",
-    "@automerge/vanillajs": "2.6.0-subduction.29"
+    "@automerge/automerge-repo": "2.6.0-subduction.39",
+    "@automerge/automerge-repo-keyhive": "0.3.0-alpha.sub.8b",
+    "@automerge/vanillajs": "2.6.0-subduction.39"
   },
   "scripts": {
     "build": "tsc",