@inkandswitch/patchwork-bootloader 0.2.8 → 0.3.1

package/src/setup.ts

@@ -12,6 +12,34 @@ 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(): boolean {
+  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(): void {
+  if (swLifecycleListenerInstalled) return;
+  if (typeof navigator === "undefined" || !navigator.serviceWorker) return;
+  swLifecycleListenerInstalled = true;
+  navigator.serviceWorker.addEventListener("message", (event: MessageEvent) => {
+    const data = event.data;
+    if (data?.type !== "sw-lifecycle") return;
+    if (!lifecycleLoggingEnabled()) return;
+    const fn = (console as any)[data.level] ?? console.log;
+    fn(`[service-worker] ${data.msg}`);
+  });
+}
+
 const key = "patchworkServiceWorkerCacheVersion";
 let nextRepoChannelId = 0;
 
@@ -67,7 +95,7 @@ function configureServiceWorker(sw: ServiceWorker | null) {
 let automergeWorkerPath = "/automerge-worker.js";
 let automergeWorker: SharedWorker | undefined;
 
-function getAutomergeWorker(): SharedWorker {
+export function getAutomergeWorker(): SharedWorker {
   if (!automergeWorker) {
     automergeWorker = new SharedWorker(automergeWorkerPath, {
       name: "patchwork-automerge",
@@ -76,11 +104,107 @@ function getAutomergeWorker(): SharedWorker {
     // 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: MessageEvent) => {
+      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 as any)[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: SharedWorker): void {
+  const stamp = () => new Date().toISOString();
+  const warn = (msg: string) => {
+    if (lifecycleLoggingEnabled()) console.warn(`[lifecycle] ${stamp()} ${msg}`);
+  };
+  const info = (msg: string) => {
+    if (lifecycleLoggingEnabled()) console.info(`[lifecycle] ${stamp()} ${msg}`);
+  };
+
+  let instanceId: string | undefined;
+  let lastPongAt = Date.now();
+  let warnedUnresponsive = false;
+
+  worker.port.addEventListener("message", (event: MessageEvent) => {
+    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 as ErrorEvent).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: string = readClassicSyncServer()
 ): Promise<void> {
@@ -104,11 +228,7 @@ export function connectClassicSync(
       if (event.data?.type === "connect-classic-sync-ready") {
         resolve();
       } else {
-        reject(
-          new Error(
-            event.data?.error ?? "connect-classic-sync failed"
-          )
-        );
+        reject(new Error(event.data?.error ?? "connect-classic-sync failed"));
       }
     };
     worker.port.postMessage({ type: "connect-classic-sync", server: url }, [
@@ -188,11 +308,16 @@ function getRepoChannel(): MessagePort {
 export default async function setupServiceWorker(
   options?: SetupServiceWorkerOptions
 ): Promise<SetupServiceWorkerResult> {
+  // 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
@@ -230,7 +355,16 @@ export default async function setupServiceWorker(
     "background: #fcf2f0; color: #333; border: 2px solid; border-radius: 4px"
   );
 
+  // todon't
+  (window as any).killsw = () => {
+    if (automergeWorker) {
+      automergeWorker.port.close();
+      automergeWorker = undefined;
+    }
+  };
+
   return {
+    shared,
     connectClassicSync,
     getRepoChannel,
     async subscribeToRepoChannel(listener: ServiceWorkerRepoChannelListener) {

package/src/site.ts

@@ -13,7 +13,6 @@
  */
 import {
   type DocHandle,
-  IndexedDBStorageAdapter,
   initializeWasm,
   isValidAutomergeUrl,
   isValidDocumentId,
@@ -23,14 +22,14 @@ import {
   stringifyAutomergeUrl,
   type AutomergeUrl,
   type DocumentId,
-  type StorageId,
   type UrlHeads,
 } 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,
+  initializeAutomergeRepoKeyhiveWithRepo,
   type AutomergeRepoKeyhive,
 } from "@automerge/automerge-repo-keyhive";
 // eslint-disable-next-line
@@ -41,7 +40,16 @@ declare const __SITE_NAME__: string;
 const siteName =
   typeof __SITE_NAME__ !== "undefined" ? __SITE_NAME__ : "tiny-patchwork";
 
+// Sync-server selection for keyhive. Defaults to "subduction". Build with
+// KEYHIVE_SYNC_SERVER=true to target keyhive.sync.automerge.org. This must match
+// the automerge-worker (SharedWorker) selection so the tab and the SW grant relay
+// access to the same server.
+declare const __KEYHIVE_SYNC_SERVER__: boolean;
+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,
@@ -58,7 +66,10 @@ import {
 } from "@inkandswitch/patchwork-plugins";
 import * as plugins from "@inkandswitch/patchwork-plugins";
 
-import setupServiceWorker from "./setup.js";
+import setupServiceWorker, {
+  getAutomergeWorker,
+  lifecycleLoggingEnabled,
+} from "./setup.js";
 import type { ServiceWorkerRepoChannelListener } from "./types.js";
 import debug from "debug";
 const log = debug("patchwork:bootloader:site");
@@ -89,16 +100,33 @@ 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
@@ -119,12 +147,6 @@ export interface SiteConfig {
    */
   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
@@ -139,9 +161,6 @@ export interface BootResult {
   accountDocHandle: DocHandle<AccountDoc>;
 }
 
-const DEFAULT_REMOTE_STORAGE_ID =
-  "3760df37-a4c6-4f66-9ecd-732039a9385d" as StorageId;
-
 // 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>\?=[^&?]+)?/;
@@ -163,49 +182,67 @@ const [automergeWasm, subductionWasm] = await Promise.all([
 export async function bootPatchworkSite(
   config: SiteConfig
 ): Promise<BootResult> {
-  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: AutomergeRepoKeyhive | undefined;
-  // Get the initial automerge-worker port via subscribeToRepoChannel,
-  // then pass it to keyhive init which wraps it in its own network adapter.
-  let resolvePort!: (port: MessagePort) => void;
-  const portPromise = new Promise<MessagePort>((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: 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;
+  } 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!: (port: MessagePort) => void;
+    const portPromise = new Promise<MessagePort>((r) => {
+      resolvePort = r;
     });
-  }
-
-  const repo = hive
-    ? new Repo({
-        storage: new IndexedDBStorageAdapter(),
-        enableRemoteHeadsGossiping: true,
-        network: [hive.networkAdapter],
-        peerId: hive.peerId,
-        idFactory: hive.idFactory,
-      })
-    : new Repo({
+    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" as const } : {}),
+        repo: {
+          storage: new IndexedDBWorkerStorageAdapter(),
+          enableRemoteHeadsGossiping: true,
+        },
+      }));
+      log("keyhive setup complete");
+    } else {
+      log("creating repo");
+      repo = new Repo({
         network: [new MessageChannelNetworkAdapter(workerPort)],
-        storage: new IndexedDBStorageAdapter(),
+        storage: new IndexedDBWorkerStorageAdapter(),
         async sharePolicy(peerId) {
           return peerId.includes("automerge-worker");
         },
@@ -213,11 +250,16 @@ export async function bootPatchworkSite(
         peerId:
           `${config.titleSuffix}-tab-${crypto.randomUUID()}` as AutomergeRepo.PeerId,
       });
-  repo.subscribeToRemotes(
-    config.remoteStorageIds ?? [DEFAULT_REMOTE_STORAGE_ID]
-  );
+      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 as any).syncKeyhive?.();
   }
@@ -246,9 +288,12 @@ export async function bootPatchworkSite(
   // is added lazily once it appears on the account doc — see below.
   const moduleWatcher = new ModuleWatcher(
     repo,
-    { system: defaultModulesUrl },
+    buildSystemSources(defaultModuleSources),
     onModuleLoaded,
-    unregisterPlugins
+    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, {
@@ -290,21 +335,67 @@ export async function bootPatchworkSite(
 
 // ─── Internals ──────────────────────────────────────────────────────────
 
-function resolveDefaultModulesUrl(builtin: AutomergeUrl): AutomergeUrl {
+/**
+ * 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: string): boolean {
+  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: SiteConfig): string[] {
+  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`
+    );
   }
-  console.warn(
-    `ignoring invalid defaultToolsUrl in localStorage: ${override}; using built-in default`
-  );
-  return builtin;
+
+  if (builtinList.length === 0) {
+    throw new Error(
+      "bootPatchworkSite: no default module sources configured (set `defaultModules`)"
+    );
+  }
+  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: string[]): Record<string, string> {
+  const map: Record<string, string> = {};
+  sources.forEach((source, index) => {
+    const name = index === 0 ? "system" : `system-${index}`;
+    map[name] = source;
+  });
+  return map;
 }
 
 function installDevConsoleGlobals(
@@ -321,6 +412,46 @@ function installDevConsoleGlobals(
   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(): void {
+  if (typeof document === "undefined") return;
+  const opts = { capture: true } as const;
+  const note = (label: string, extra?: unknown) => {
+    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 as PageTransitionEvent).persisted }),
+    opts
+  );
+  window.addEventListener(
+    "pagehide",
+    e => note("pagehide", { persisted: (e as PageTransitionEvent).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: string, mod: any): void {
   if (Array.isArray(mod.plugins)) {
     log(
@@ -372,7 +503,7 @@ function primeRootElement(
   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 as DocumentId })
       : accountDocHandle.url;
@@ -558,15 +689,24 @@ function installHashRouting(params: HashRoutingParams): void {
       return;
     }
 
+    // Bare automerge URL in hash: /#automerge:<documentId>
+    if (isValidAutomergeUrl(hash as AutomergeUrl)) {
+      const { documentId, heads } = parseAutomergeUrl(hash as AutomergeUrl);
+      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("|") as UrlHeads | undefined;
     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

package/src/types.ts

@@ -6,6 +6,13 @@
  */
 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";
+
 /**
  * The special URL to resolve, plus enough of the {@link Request} the service
  * worker is holding that the automerge worker can construct one that
@@ -105,6 +112,8 @@ export type ServiceWorkerRepoChannelListener = (
 ) => 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: (

package/src/vite/service-worker-plugin.ts

@@ -14,6 +14,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(): Plugin {