@inkandswitch/patchwork-bootloader 0.3.1 → 0.3.2

package/dist/site.js

@@ -19,6 +19,7 @@ import { initKeyhiveWasm, initializeAutomergeRepoKeyhiveWithRepo, } from "@autom
 // 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";
@@ -59,6 +60,7 @@ export async function bootPatchworkSite(config) {
     log("workers ready");
     let hive;
     let repo;
+    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.
@@ -102,15 +104,26 @@ export async function bootPatchworkSite(config) {
         }
         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");
         }
     }
@@ -157,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;
@@ -296,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 {
@@ -385,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
@@ -411,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)
@@ -431,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)
@@ -440,6 +510,7 @@ function installHashRouting(params) {
         hideLoadingAnimation();
     };
     rootElement.addEventListener("patchwork:mounted", (event) => {
+        recordInUsePackage(event);
         handleHashChange();
         if (event.target !== rootElement)
             return;
@@ -464,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

@@ -11,6 +11,62 @@ export declare const HANDOFF_CHANNEL = "@patchwork/handoff";
  * 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
@@ -106,4 +162,12 @@ export type SetupServiceWorkerResult = {
     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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@inkandswitch/patchwork-bootloader",
-  "version": "0.3.1",
+  "version": "0.3.2",
   "author": "chee",
   "type": "module",
   "license": "MIT",
@@ -57,10 +57,10 @@
     "resolve.exports": "^2.0.3",
     "service-worker-types": "npm:@types/serviceworker@^0.0.153",
     "tinyargs": "^0.1.4",
-    "@inkandswitch/patchwork-filesystem": "^0.1.1",
     "@inkandswitch/patchwork-elements": "^2.0.0",
-    "@inkandswitch/patchwork-providers": "^0.3.0",
-    "@inkandswitch/patchwork-plugins": "^0.0.11"
+    "@inkandswitch/patchwork-filesystem": "^0.1.1",
+    "@inkandswitch/patchwork-plugins": "^0.0.11",
+    "@inkandswitch/patchwork-providers": "^0.3.0"
   },
   "peerDependencies": {
     "@automerge/automerge": "3.3.0-fragments.1",