@inkandswitch/patchwork-bootloader 0.3.0 → 0.3.2

package/src/site.ts

@@ -13,7 +13,6 @@
  */
 import {
   type DocHandle,
-  IndexedDBStorageAdapter,
   initializeWasm,
   isValidAutomergeUrl,
   isValidDocumentId,
@@ -23,9 +22,8 @@ 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 {
@@ -36,6 +34,7 @@ import {
 // 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 { MemorySigner } from "@automerge/automerge-subduction/slim";
 
 declare const __SITE_NAME__: string;
 const siteName =
@@ -50,6 +49,7 @@ 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,
@@ -66,8 +66,14 @@ import {
 } from "@inkandswitch/patchwork-plugins";
 import * as plugins from "@inkandswitch/patchwork-plugins";
 
-import setupServiceWorker from "./setup.js";
-import type { ServiceWorkerRepoChannelListener } from "./types.js";
+import setupServiceWorker, {
+  getAutomergeWorker,
+  lifecycleLoggingEnabled,
+} from "./setup.js";
+import type {
+  ServiceWorkerRepoChannelListener,
+  SyncStateDocMessage,
+} from "./types.js";
 import debug from "debug";
 const log = debug("patchwork:bootloader:site");
 
@@ -84,11 +90,19 @@ declare global {
       packages: ModuleWatcher;
       plugins: typeof plugins;
       accountDocHandle: DocHandle<AccountDoc>;
+      signer?: {
+        peerId: string;
+        verifyingKey: string;
+      };
       sw: {
         connectClassicSync: (server?: string) => Promise<void>;
         subscribeToRepoChannel: (
           listener: ServiceWorkerRepoChannelListener
         ) => Promise<() => void>;
+        subscribeSyncState: (
+          documentId: string,
+          listener: (update: SyncStateDocMessage) => void
+        ) => () => void;
       };
     };
     uncache: (match: string) => Promise<void>;
@@ -144,12 +158,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
@@ -164,9 +172,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>\?=[^&?]+)?/;
@@ -191,59 +196,97 @@ export async function bootPatchworkSite(
   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;
-
   let repo: Repo;
-  if (config.keyhive) {
-    initKeyhiveWasm();
-
-    ({ hive, repo } = await initializeAutomergeRepoKeyhiveWithRepo({
-      createRepo: (config) => new Repo(config),
-      storage: new IndexedDBStorageAdapter(`${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 IndexedDBStorageAdapter(),
-        enableRemoteHeadsGossiping: true,
-      },
-    }));
+  let tabSignerIdentity: { peerId: string; verifyingKey: string } | undefined;
+
+  // 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 {
-    repo = 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()}` as AutomergeRepo.PeerId,
+    // 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;
     });
+    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");
+      // Pass an explicit signer (instead of the Repo's internal default) so we
+      // can expose tab signer identity on window.patchwork for dev inspection.
+      // The tab never connects via Subduction (no endpoints/adapters), so this
+      // id never goes on the wire.
+      const tabSigner = new MemorySigner();
+      repo = new Repo({
+        network: [new MessageChannelNetworkAdapter(workerPort)],
+        storage: new IndexedDBWorkerStorageAdapter(),
+        signer: tabSigner,
+        async sharePolicy(peerId) {
+          return peerId.includes("automerge-worker");
+        },
+        enableRemoteHeadsGossiping: true,
+        peerId:
+          `${config.titleSuffix}-tab-${crypto.randomUUID()}` as AutomergeRepo.PeerId,
+      });
+      tabSignerIdentity = {
+        peerId: tabSigner.peerId().toString(),
+        verifyingKey: (
+          tabSigner.verifyingKey() as Uint8Array<ArrayBufferLike> & {
+            toHex(): string;
+          }
+        ).toHex(),
+      };
+      console.log("[patchwork] tab subduction identity:", tabSignerIdentity);
+      log("repo created");
+    }
   }
-  repo.subscribeToRemotes(
-    config.remoteStorageIds ?? [DEFAULT_REMOTE_STORAGE_ID]
-  );
+  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?.();
   }
@@ -274,7 +317,10 @@ export async function bootPatchworkSite(
     repo,
     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, {
@@ -296,9 +342,11 @@ export async function bootPatchworkSite(
     packages: moduleWatcher,
     plugins,
     accountDocHandle,
+    ...(tabSignerIdentity ? { signer: tabSignerIdentity } : {}),
     sw: {
       connectClassicSync: sw.connectClassicSync,
       subscribeToRepoChannel: sw.subscribeToRepoChannel,
+      subscribeSyncState: sw.subscribeSyncState,
     },
   };
   window.uncache = uncache;
@@ -336,10 +384,7 @@ function isValidModuleSource(source: string): boolean {
  * built-in default bundle).
  */
 function resolveDefaultModules(config: SiteConfig): string[] {
-  const builtin =
-    config.defaultModules ??
-    config.defaultModulesUrl ??
-    [];
+  const builtin = config.defaultModules ?? config.defaultModulesUrl ?? [];
   const builtinList = (Array.isArray(builtin) ? builtin : [builtin]).filter(
     Boolean
   );
@@ -396,6 +441,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(
@@ -447,10 +532,8 @@ 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")?.replace(/^automerge:/, "");
-    const docUrl = docId
-      ? stringifyAutomergeUrl({ documentId: docId as DocumentId })
-      : accountDocHandle.url;
+    const docUrl =
+      docParamToUrl(initialParams.get("doc")) ?? accountDocHandle.url;
     rootElement.setAttribute("doc-url", docUrl);
   } else {
     rootElement.setAttribute("tool-id", accountDocHandle.doc().frameToolId);
@@ -542,6 +625,43 @@ async function uncache(match: string): Promise<void> {
   }
 }
 
+// Keys whose values are automerge URLs — we keep the `:` (and any `#`/`|`
+// heads) literal rather than percent-encoding them so links stay readable.
+const RAW_HASH_KEYS = new Set(["doc", "package"]);
+// Emit hash params in a stable order so re-serializing the same logical
+// params yields a byte-identical string (avoids spurious `hashchange`).
+const HASH_KEY_ORDER = ["doc", "package", "tool", "type", "title", "frame"];
+
+function serializeHashParams(params: URLSearchParams): string {
+  const emitted = new Set<string>();
+  const parts: string[] = [];
+  const emit = (key: string) => {
+    if (emitted.has(key)) return;
+    const value = params.get(key);
+    if (!value) return;
+    emitted.add(key);
+    parts.push(`${key}=${RAW_HASH_KEYS.has(key) ? value : encodeURIComponent(value)}`);
+  };
+  for (const key of HASH_KEY_ORDER) emit(key);
+  for (const key of params.keys()) emit(key);
+  return parts.join("&");
+}
+
+/**
+ * Coerce a `doc=` hash param to a full automerge URL. Accepts a full URL
+ * (`automerge:<id>[#heads]`) or a bare document id for backwards
+ * compatibility with older links.
+ */
+function docParamToUrl(docParam: string | null): AutomergeUrl | undefined {
+  if (!docParam) return undefined;
+  if (isValidAutomergeUrl(docParam as AutomergeUrl)) return docParam as AutomergeUrl;
+  const documentId = docParam.replace(/^automerge:/, "");
+  if (isValidDocumentId(documentId)) {
+    return stringifyAutomergeUrl({ documentId: documentId as DocumentId });
+  }
+  return undefined;
+}
+
 interface HashRoutingParams {
   rootElement: HTMLElement;
   repo: Repo;
@@ -554,10 +674,6 @@ function installHashRouting(params: HashRoutingParams): void {
   const { rootElement, repo, accountDocHandle, moduleWatcher, titleSuffix } =
     params;
 
-  rootElement.addEventListener("patchwork:no-tool", (event) => {
-    moduleWatcher.loadSuggestedImportUrl(event.detail.url);
-  });
-
   rootElement.addEventListener("patchwork:open-document", async (event) => {
     const params = new URLSearchParams(window.location.hash.slice(1));
     const { url, toolId, type, title } = event.detail as {
@@ -566,22 +682,21 @@ function installHashRouting(params: HashRoutingParams): void {
       type?: string;
       title?: string;
     };
-    const { documentId, heads } = parseAutomergeUrl(url);
-    params.set("doc", documentId);
-    if (heads) params.set("heads", heads.join("|"));
-    else params.delete("heads");
+    // `doc` is now the full automerge URL (heads, if any, live in it). The
+    // in-use package is recorded separately in `package=` when a tool mounts.
+    params.delete("heads");
+    params.set("doc", url);
     if (toolId) params.set("tool", toolId);
     else params.delete("tool");
     if (title) params.set("title", title);
     else params.delete("title");
     if (type) params.set("type", type);
     else params.delete("type");
-    window.location.hash = params.toString();
+    window.location.hash = serializeHashParams(params);
 
     try {
-      const docHandle = await repo.find<{ "@patchwork"?: { type?: string } }>(
-        stringifyAutomergeUrl({ documentId, heads })
-      );
+      const docHandle =
+        await repo.find<{ "@patchwork"?: { type?: string } }>(url);
       const doc = docHandle.doc();
       const docType = type || doc?.["@patchwork"]?.type;
       if (!docType) return;
@@ -599,6 +714,29 @@ function installHashRouting(params: HashRoutingParams): void {
     }
   });
 
+  // When a tool mounts we know the package actually rendering the top-level
+  // document, so record its (heads-pinned) importUrl in `package=`.
+  const recordInUsePackage = (event: Event) => {
+    const detail = (event as CustomEvent).detail;
+    if (!detail || !("url" in detail) || !detail.importUrl) return;
+    const params = new URLSearchParams(window.location.hash.slice(1));
+    const docUrl = docParamToUrl(params.get("doc"));
+    if (!docUrl) return;
+    // Ignore nested branch / side-by-side views: only the top-level doc's
+    // package belongs in the hash.
+    if (
+      parseAutomergeUrl(docUrl).documentId !==
+      parseAutomergeUrl(detail.url as AutomergeUrl).documentId
+    ) {
+      return;
+    }
+    if (params.get("package") === detail.importUrl) return;
+    params.set("package", detail.importUrl);
+    // Replace rather than push: recording the in-use package shouldn't add a
+    // back-button entry (and replaceState avoids a `hashchange` round-trip).
+    history.replaceState(null, "", `#${serializeHashParams(params)}`);
+  };
+
   let firstMount = true;
   const reveal = () => {
     if (!firstMount) return;
@@ -608,6 +746,7 @@ function installHashRouting(params: HashRoutingParams): void {
   };
 
   rootElement.addEventListener("patchwork:mounted", (event) => {
+    recordInUsePackage(event);
     handleHashChange();
     if (event.target !== rootElement) return;
     console.info("root element mounted");
@@ -635,41 +774,40 @@ function installHashRouting(params: HashRoutingParams): void {
 
     // Bare automerge URL in hash: /#automerge:<documentId>
     if (isValidAutomergeUrl(hash as AutomergeUrl)) {
-      const { documentId, heads } = parseAutomergeUrl(hash as AutomergeUrl);
+      const url = hash as AutomergeUrl;
       window.location.hash = "";
-      openDocument(
-        rootElement,
-        stringifyAutomergeUrl({ documentId, heads })
-      );
+      openDocument(rootElement, url);
       return;
     }
 
     const params = new URLSearchParams(hash);
-    const documentId = params.get("doc")?.replace(/^automerge:/, "");
-    const heads = params.get("heads")?.split("|") as UrlHeads | undefined;
+    const docUrl = docParamToUrl(params.get("doc"));
+    const packageUrl = params.get("package");
     const toolId = params.get("tool");
     const title = params.get("title");
     const type = params.get("type");
     const frame = params.get("frame");
+
+    // Load the package that produced this document so its tool is available
+    // even when it isn't in the user's module settings.
+    if (packageUrl) {
+      void moduleWatcher.loadModules([packageUrl]);
+    }
+
     if (frame) {
-      const docUrl = params.get("doc")?.replace(/^automerge:/, "") ?? accountDocHandle.url;
+      const frameDocUrl = docUrl ?? accountDocHandle.url;
       if (
         rootElement.getAttribute("tool-id") !== frame ||
-        rootElement.getAttribute("doc-url") !== docUrl
+        rootElement.getAttribute("doc-url") !== frameDocUrl
       ) {
         rootElement.setAttribute("tool-id", frame);
-        rootElement.setAttribute("doc-url", docUrl);
+        rootElement.setAttribute("doc-url", frameDocUrl);
       }
     }
-    if (isValidDocumentId(documentId)) {
+    if (docUrl) {
       rootElement.dispatchEvent(
         new CustomEvent("patchwork:open-document", {
-          detail: {
-            url: stringifyAutomergeUrl({ documentId, heads }),
-            toolId,
-            title,
-            type,
-          },
+          detail: { url: docUrl, toolId, title, type },
         })
       );
     }

package/src/types.ts

@@ -6,6 +6,90 @@
  */
 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";
+
+/**
+ * Worker → tabs: the worker's Subduction link to the sync server flipped.
+ * `serverPeerIds` are the directly-connected sync-server peer ids (their
+ * verifying keys), so a tab can tell which peer rows are *the server* and
+ * judge "synced" against them specifically.
+ */
+export interface SyncStateConnectionMessage {
+  type: "connection";
+  connected: boolean;
+  serverPeerIds: string[];
+}
+
+/**
+ * Worker → tabs: the shared worker's own Subduction identity, so a tab can
+ * tell which peer rows are "us". `peerId` is `signer.peerId().toString()` (the
+ * value that shows up as a peer id); `verifyingKey` is its hex Ed25519 key.
+ */
+export interface SyncStateWhoAmIMessage {
+  type: "whoami";
+  peerId: string;
+  verifyingKey: string;
+}
+
+// What the worker broadcasts on SYNCSTATE_CHANNEL: only the *global* signals
+// now. Per-document heads are addressed to subscribers over the control port
+// instead (see SyncStateDocMessage) rather than fanned out to every tab.
+export type SyncStateBroadcast =
+  | SyncStateConnectionMessage
+  | SyncStateWhoAmIMessage;
+
+/**
+ * Tab → worker: please replay the current global sync signals (whoami +
+ * connection) so a freshly-opened tab can orient immediately. Per-document
+ * heads are no longer replayed here — a tab subscribes to the specific docs it
+ * cares about over its control port instead (see {@link SyncSubscribeMessage}).
+ */
+export interface SyncStateRequestMessage {
+  type: "request";
+  /** @deprecated ignored — per-doc state is delivered via sync-sub now. */
+  documentId?: string;
+}
+
+// ── Per-tab sync-state subscription (over the SharedWorker control port) ──
+//
+// The broadcast SyncState* messages above are global (connection/whoami).
+// Per-document heads, by contrast, are addressed: a tab subscribes its control
+// port to just the documents it cares about and the worker pushes only those
+// docs' heads back down that port. The worker drops a port's whole
+// subscription set automatically when the port closes (the tab went away), so
+// there's no reference counting or heartbeat to leak.
+
+/** Tab → worker: start pushing me this document's heads (replays current state). */
+export interface SyncSubscribeMessage {
+  type: "sync-sub";
+  documentId: string;
+}
+
+/** Tab → worker: stop pushing me this document's heads. */
+export interface SyncUnsubscribeMessage {
+  type: "sync-unsub";
+  documentId: string;
+}
+
+/**
+ * Worker → tab (control port): a peer's heads for a subscribed document — the
+ * worker's own (keyed by its peerId) or a Subduction peer's (keyed by its
+ * verifying-key storageId). Same payload as the old broadcast remote-heads
+ * message, but delivered only to the tabs that asked for this document.
+ */
+export interface SyncStateDocMessage {
+  type: "sync-state";
+  documentId: string;
+  storageId: string;
+  heads: string[];
+  timestamp: number;
+}
+
 /**
  * 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 +189,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: (
@@ -112,4 +198,15 @@ export type SetupServiceWorkerResult = {
   ) => Promise<() => void>;
   /** Open a fresh repo sync port to the automerge worker (dev console). */
   getRepoChannel: () => MessagePort;
+  /**
+   * Watch one document's sync heads (this tab's own and each Subduction peer's,
+   * as the worker learns them). Calls `listener` on every update for that doc,
+   * replaying the current state on subscribe. Returns an unsubscribe function;
+   * the worker stops pushing the doc once the last local watcher drops it (and
+   * automatically if this tab goes away).
+   */
+  subscribeSyncState: (
+    documentId: string,
+    listener: (update: SyncStateDocMessage) => void
+  ) => () => void;
 };

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 {