@inkandswitch/patchwork-bootloader 0.3.0 → 0.3.2

package/dist/site.js

@@ -11,24 +11,26 @@
  * 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, 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";
+import { MemorySigner } 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([
@@ -48,53 +50,88 @@ export async function bootPatchworkSite(config) {
     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;
     let 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" } : {}),
-            repo: {
-                storage: new IndexedDBStorageAdapter(),
-                enableRemoteHeadsGossiping: true,
-            },
-        }));
+    let tabSignerIdentity;
+    // 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()}`,
+        // 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;
         });
+        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");
+            // 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()}`,
+            });
+            tabSignerIdentity = {
+                peerId: tabSigner.peerId().toString(),
+                verifyingKey: tabSigner.verifyingKey().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.syncKeyhive?.();
     }
@@ -114,7 +151,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, buildSystemSources(defaultModuleSources), 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,
@@ -130,9 +170,11 @@ export async function bootPatchworkSite(config) {
         packages: moduleWatcher,
         plugins,
         accountDocHandle,
+        ...(tabSignerIdentity ? { signer: tabSignerIdentity } : {}),
         sw: {
             connectClassicSync: sw.connectClassicSync,
             subscribeToRepoChannel: sw.subscribeToRepoChannel,
+            subscribeSyncState: sw.subscribeSyncState,
         },
     };
     window.uncache = uncache;
@@ -164,9 +206,7 @@ function isValidModuleSource(source) {
  * built-in default bundle).
  */
 function resolveDefaultModules(config) {
-    const builtin = config.defaultModules ??
-        config.defaultModulesUrl ??
-        [];
+    const builtin = config.defaultModules ?? config.defaultModulesUrl ?? [];
     const builtinList = (Array.isArray(builtin) ? builtin : [builtin]).filter(Boolean);
     const override = globalThis.localStorage?.getItem("defaultToolsUrl");
     if (override) {
@@ -206,6 +246,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}`));
@@ -244,10 +311,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")?.replace(/^automerge:/, "");
-        const docUrl = docId
-            ? stringifyAutomergeUrl({ documentId: docId })
-            : accountDocHandle.url;
+        const docUrl = docParamToUrl(initialParams.get("doc")) ?? accountDocHandle.url;
         rootElement.setAttribute("doc-url", docUrl);
     }
     else {
@@ -333,20 +397,55 @@ async function uncache(match) {
         }
     }
 }
+// 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) {
+    const emitted = new Set();
+    const parts = [];
+    const emit = (key) => {
+        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) {
+    if (!docParam)
+        return undefined;
+    if (isValidAutomergeUrl(docParam))
+        return docParam;
+    const documentId = docParam.replace(/^automerge:/, "");
+    if (isValidDocumentId(documentId)) {
+        return stringifyAutomergeUrl({ documentId: documentId });
+    }
+    return undefined;
+}
 function installHashRouting(params) {
     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;
-        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
@@ -359,9 +458,9 @@ function installHashRouting(params) {
             params.set("type", type);
         else
             params.delete("type");
-        window.location.hash = params.toString();
+        window.location.hash = serializeHashParams(params);
         try {
-            const docHandle = await repo.find(stringifyAutomergeUrl({ documentId, heads }));
+            const docHandle = await repo.find(url);
             const doc = docHandle.doc();
             const docType = type || doc?.["@patchwork"]?.type;
             if (!docType)
@@ -379,6 +478,29 @@ function installHashRouting(params) {
             console.error("Failed to update document title", e);
         }
     });
+    // 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) => {
+        const detail = event.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).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)
@@ -388,6 +510,7 @@ function installHashRouting(params) {
         hideLoadingAnimation();
     };
     rootElement.addEventListener("patchwork:mounted", (event) => {
+        recordInUsePackage(event);
         handleHashChange();
         if (event.target !== rootElement)
             return;
@@ -412,34 +535,34 @@ function installHashRouting(params) {
         }
         // Bare automerge URL in hash: /#automerge:<documentId>
         if (isValidAutomergeUrl(hash)) {
-            const { documentId, heads } = parseAutomergeUrl(hash);
+            const url = hash;
             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("|");
+        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/dist/types.d.ts

@@ -5,6 +5,68 @@
  * 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";
+/**
+ * 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;
+}
+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;
+}
+/** 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
@@ -93,9 +155,19 @@ 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>;
     /** 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/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.3.0",
+  "version": "0.3.2",
   "author": "chee",
   "type": "module",
   "license": "MIT",
   "devDependencies": {
-    "@automerge/automerge-repo-keyhive": "0.3.0-alpha.sub.6c",
+    "@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.34",
-    "@automerge/automerge-repo-network-messagechannel": "2.6.0-subduction.34",
-    "@automerge/automerge-repo-network-websocket": "2.6.0-subduction.34",
-    "@automerge/automerge-repo-storage-indexeddb": "2.6.0-subduction.34",
+    "@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.34",
-    "@keyhive/keyhive": "0.1.0-alpha.3",
+    "@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.1.0",
+    "@inkandswitch/patchwork-elements": "^2.0.0",
+    "@inkandswitch/patchwork-filesystem": "^0.1.1",
     "@inkandswitch/patchwork-plugins": "^0.0.11",
-    "@inkandswitch/patchwork-providers": "^0.3.0",
-    "@inkandswitch/patchwork-elements": "^2.0.0"
+    "@inkandswitch/patchwork-providers": "^0.3.0"
   },
   "peerDependencies": {
     "@automerge/automerge": "3.3.0-fragments.1",
-    "@automerge/automerge-repo": "2.6.0-subduction.34",
-    "@automerge/automerge-repo-keyhive": "0.3.0-alpha.sub.6c",
-    "@automerge/vanillajs": "2.6.0-subduction.34"
+    "@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",