@inkandswitch/patchwork-bootloader 0.3.1 → 0.3.2

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # @inkandswitch/patchwork-bootloader
 
+## 0.3.2
+
+### Patch Changes
+
+- 0e1eb95: add syncstate info shape
+
 ## 0.3.1
 
 ### Patch Changes

package/dist/automerge-worker.js

@@ -24,7 +24,7 @@ import { IndexedDBWorkerStorageAdapter } from "@automerge/automerge-repo-storage
 import { MessageChannelNetworkAdapter } from "@automerge/automerge-repo-network-messagechannel";
 import { WebSocketWorkerClientAdapter } from "@automerge/automerge-repo-network-websocket";
 import { initializeAutomergeRepoKeyhiveRustWithRepo, initKeyhiveWasm, } from "@automerge/automerge-repo-keyhive";
-import { HANDOFF_CHANNEL, } from "./types.js";
+import { HANDOFF_CHANNEL, SYNCSTATE_CHANNEL, } from "./types.js";
 let debugging = false;
 // Per-boot identity so a tab can detect a worker *restart*: a fresh instance
 // means a new repo peerId + cold in-memory state, so the tab's docs must be
@@ -36,6 +36,42 @@ const WORKER_BOOT_TIME = Date.now();
 // → shared workers). Patch console.* and the global error handlers to also
 // post back over every connected tab's control port, tagged [automerge-worker].
 const controlPorts = new Set();
+// ── Per-tab sync-state subscriptions ────────────────────────────────────
+// Each tab's control port subscribes to the documents it cares about; we push
+// only those docs' heads back down that port (addressed — tab A never sees tab
+// B's docs), and drop a port's whole subscription set when it closes (the tab
+// went away), so there's nothing to reference-count or time out. The global
+// connection/whoami signals still go over SYNCSTATE_CHANNEL.
+const syncWatchers = new Map();
+// Installed by setupSyncStateBroadcast once the repo's snapshot exists, so a
+// fresh `sync-sub` can be replayed the doc's current heads immediately. Null
+// until then; subscriptions taken during boot are replayed when it installs.
+let replaySyncForPort = null;
+function syncSubscribe(port, documentId) {
+    let docs = syncWatchers.get(port);
+    if (!docs)
+        syncWatchers.set(port, (docs = new Set()));
+    if (docs.has(documentId))
+        return;
+    docs.add(documentId);
+    replaySyncForPort?.(documentId, port);
+}
+function syncUnsubscribe(port, documentId) {
+    syncWatchers.get(port)?.delete(documentId);
+}
+// Push one document's heads to every control port currently watching it.
+function pushSyncState(message) {
+    for (const [port, docs] of syncWatchers) {
+        if (!docs.has(message.documentId))
+            continue;
+        try {
+            port.postMessage(message);
+        }
+        catch {
+            // Port already gone; its close handler will reap the entry.
+        }
+    }
+}
 // Logs emitted before any tab has connected (e.g. during wasm boot) would
 // otherwise be lost — buffer a bounded number and flush on first connect.
 const preConnectBuffer = [];
@@ -130,6 +166,13 @@ const SUBDUCTION_ENDPOINTS = [
         : "wss://subduction.sync.inkandswitch.com",
 ];
 const RESOLVE_TIMEOUT_MS = 30_000;
+// Backoff re-sync of stuck/diverged docs. Only this worker is connected to the
+// sync server, so it's the only place that can notice a doc whose heads have
+// settled out of sync with the server and re-arm a sync round for it.
+const RESYNC_GRACE_MS = 8_000; // must be *stably* diverged this long first
+const RESYNC_INITIAL_DELAY_MS = 5_000; // first backoff cooldown after a resync
+const RESYNC_MAX_DELAY_MS = 60_000; // backoff cap
+const RESYNC_REVIEW_INTERVAL_MS = 5_000; // how often stuck docs are re-checked
 const DEFAULT_CLASSIC_SYNC_SERVER = "wss://sync3.automerge.org";
 let classicSyncServer = DEFAULT_CLASSIC_SYNC_SERVER;
 let classicSyncAdapter = null;
@@ -185,6 +228,11 @@ function getRepoHive() {
             log("wasm initialized");
             if (!useKeyhive) {
                 const signer = await WebCryptoSigner.setup();
+                const identity = {
+                    peerId: signer.peerId().toString(),
+                    verifyingKey: signer.verifyingKey().toHex(),
+                };
+                console.log("[patchwork] shared-worker subduction identity:", identity);
                 const repo = new Repo({
                     storage: new IndexedDBWorkerStorageAdapter(),
                     signer,
@@ -199,6 +247,8 @@ function getRepoHive() {
                     subductionWebsocketEndpoints: SUBDUCTION_ENDPOINTS,
                 });
                 self.repo = repo;
+                self.syncIdentity = identity;
+                setupSyncStateBroadcast(repo, identity);
                 log("repo constructed (no keyhive), waiting for network subsystem");
                 repo.networkSubsystem.whenReady().then(() => {
                     log("repo network subsystem ready");
@@ -225,6 +275,7 @@ function getRepoHive() {
             });
             self.repo = repo;
             self.hive = hive;
+            setupSyncStateBroadcast(repo);
             log("repo constructed, waiting for network subsystem");
             // Don't block getRepoHive() on whenReady() — the network subsystem starts
             // with only the subduction adapter, and the MessageChannel adapter is
@@ -247,6 +298,285 @@ function getRepoHive() {
     }
     return repoHivePromise;
 }
+// ── Sync-state broadcast ───────────────────────────────────────────────
+//
+// Only this worker is directly connected to the sync server, so it's the only
+// place that learns the server's heads (the repo's "subduction-remote-heads"
+// event, keyed by each Subduction peer's verifying-key storageId) and whether
+// the server link is up ("subduction-connection"). We rebroadcast both on
+// SYNCSTATE_CHANNEL so every tab can render a sync indicator without holding
+// its own server connection. A tab that opens mid-stream posts {type:"request"}
+// to get the current snapshot replayed.
+let syncStateWired = false;
+function setupSyncStateBroadcast(repo, identity) {
+    if (syncStateWired)
+        return;
+    syncStateWired = true;
+    const channel = new BroadcastChannel(SYNCSTATE_CHANNEL);
+    // documentId -> storageId (verifying key) -> last-known heads
+    const snapshot = new Map();
+    let connected = repo.isSubductionConnected();
+    // Directly-connected sync-server peer ids (verifying keys). Stable once
+    // known; tabs use this to judge "synced" against the server specifically.
+    let serverPeerIds = [];
+    const postWhoAmI = () => {
+        if (!identity)
+            return;
+        channel.postMessage({
+            type: "whoami",
+            peerId: identity.peerId,
+            verifyingKey: identity.verifyingKey,
+        });
+    };
+    // Announce our identity so tabs can label which peer rows are this worker.
+    postWhoAmI();
+    // Heads are addressed, not broadcast: push a doc's heads only to the control
+    // ports that subscribed to it (see syncWatchers / pushSyncState).
+    const postHeads = (documentId, storageId, heads, timestamp) => pushSyncState({
+        type: "sync-state",
+        documentId,
+        storageId,
+        heads,
+        timestamp,
+    });
+    // Let a `sync-sub` (which may have arrived while the repo was still booting)
+    // replay this doc's current snapshot to the subscribing port immediately.
+    const replayDoc = (documentId, port) => {
+        const byStorage = snapshot.get(documentId);
+        if (!byStorage)
+            return;
+        for (const [storageId, { heads, timestamp }] of byStorage) {
+            try {
+                port.postMessage({
+                    type: "sync-state",
+                    documentId,
+                    storageId,
+                    heads,
+                    timestamp,
+                });
+            }
+            catch {
+                // Port gone; its close handler reaps it.
+            }
+        }
+    };
+    replaySyncForPort = replayDoc;
+    // Catch up any ports that subscribed before this wiring existed.
+    for (const [port, docs] of syncWatchers) {
+        for (const documentId of docs)
+            replayDoc(documentId, port);
+    }
+    const postConnection = () => channel.postMessage({
+        type: "connection",
+        connected,
+        serverPeerIds,
+    });
+    // Learn (and re-announce) which connected Subduction peer is the sync server.
+    // The peer list is empty until the handshake finishes, so retry briefly.
+    const refreshServerPeers = async () => {
+        for (let attempt = 0; attempt < 6; attempt++) {
+            try {
+                const ids = await repo.connectedSubductionPeerIds();
+                if (ids.length > 0) {
+                    serverPeerIds = ids;
+                    postConnection();
+                    return;
+                }
+            }
+            catch {
+                // repo has no subduction source / not ready yet
+            }
+            await new Promise((r) => setTimeout(r, 500));
+        }
+    };
+    // Advertise the worker's OWN heads for every doc it holds (keyed by our
+    // verifying key), so the worker hop is visible on every document.
+    //
+    // Docs pushed in by Subduction that this worker never explicitly opened don't
+    // surface via the repo's "document" event, so we discover them by re-scanning
+    // repo.handles (on a tick, and whenever the server reports a doc) and attach a
+    // heads-changed listener once per doc. No-op when there's no identity (keyhive
+    // path).
+    const ownTracked = new Set();
+    const broadcastOwnHeads = (handle) => {
+        if (!identity)
+            return;
+        const documentId = handle.documentId;
+        let heads;
+        try {
+            heads = [...handle.heads()];
+        }
+        catch {
+            return; // handle not ready yet
+        }
+        const timestamp = Date.now();
+        let byStorage = snapshot.get(documentId);
+        if (!byStorage) {
+            byStorage = new Map();
+            snapshot.set(documentId, byStorage);
+        }
+        byStorage.set(identity.peerId, { heads, timestamp });
+        postHeads(documentId, identity.peerId, heads, timestamp);
+        reviewResync(documentId);
+    };
+    const trackOwnHandle = (handle) => {
+        if (!identity || ownTracked.has(handle.documentId))
+            return;
+        ownTracked.add(handle.documentId);
+        handle.on("heads-changed", () => broadcastOwnHeads(handle));
+        broadcastOwnHeads(handle);
+    };
+    const scanOwnHandles = () => {
+        if (!identity)
+            return;
+        for (const handle of Object.values(repo.handles)) {
+            trackOwnHandle(handle);
+        }
+    };
+    // ── Backoff re-sync of stuck/diverged docs ──────────────────────────
+    //
+    // Subduction sync is event-driven and only retries syncs it observed *fail*;
+    // a doc that settles missing commits the server holds — or whose heal retries
+    // were exhausted — is otherwise never retried. When we're behind and the
+    // server's advertised heads haven't advanced for a grace window (so it's
+    // genuinely stuck, not just lagging a live edit), we re-arm its sync round
+    // with per-doc exponential backoff. Convergence clears the state.
+    const serverHeadSetsFor = (documentId) => {
+        const byStorage = snapshot.get(documentId);
+        if (!byStorage)
+            return [];
+        const sets = [];
+        for (const [storageId, { heads }] of byStorage) {
+            if (serverPeerIds.includes(storageId))
+                sets.push(heads);
+        }
+        return sets;
+    };
+    const resyncState = new Map();
+    // Inspectable from the SharedWorker console as `self.patchworkResync` to see
+    // whether/how often a doc is being re-synced and against which server heads.
+    const resyncDiag = (self.patchworkResync ??= { fires: 0, byDoc: {} });
+    const reviewResync = (documentId) => {
+        if (!identity || !connected) {
+            resyncState.delete(documentId);
+            return;
+        }
+        const handle = repo.handles[documentId];
+        if (!handle)
+            return;
+        const serverSets = serverHeadSetsFor(documentId);
+        if (serverSets.length === 0) {
+            resyncState.delete(documentId); // no server signal to compare against
+            return;
+        }
+        // The server advertises subduction *sedimentree* heads (loose-commit +
+        // fragment-boundary commit ids), which are NOT the Automerge frontier — so
+        // never compare them to handle.heads() for equality. Instead ask whether we
+        // already hold every commit the server advertises (`DocHandle.containsHeads`).
+        // If we do, the server has nothing we're missing → caught up. If not, we're
+        // genuinely behind and a re-sync can pull the rest.
+        const serverHeadsUrl = [...new Set(serverSets.flat())];
+        let haveAll;
+        try {
+            haveAll = handle.containsHeads(serverHeadsUrl);
+        }
+        catch {
+            return; // doc not ready, or an undecodable head
+        }
+        if (haveAll) {
+            resyncState.delete(documentId); // we hold everything the server has
+            return;
+        }
+        // Behind. "Stuck" = the server's advertised set hasn't advanced (no
+        // progress) for a while. Key the grace timer on the server heads only, so
+        // your own edits churning don't keep resetting it.
+        const serverSig = [...serverHeadsUrl].sort().join(",");
+        const now = Date.now();
+        const prev = resyncState.get(documentId);
+        if (!prev || prev.serverSig !== serverSig) {
+            // First sighting, or the server advanced its view (progress): restart.
+            resyncState.set(documentId, {
+                serverSig,
+                since: now,
+                delay: RESYNC_INITIAL_DELAY_MS,
+                lastResyncAt: 0,
+            });
+            return;
+        }
+        if (now - prev.since < RESYNC_GRACE_MS)
+            return; // not stuck long enough yet
+        if (now - prev.lastResyncAt < prev.delay)
+            return; // within backoff cooldown
+        log("re-syncing behind doc", documentId, { serverSets });
+        resyncDiag.fires++;
+        resyncDiag.byDoc[documentId] = {
+            at: now,
+            count: (resyncDiag.byDoc[documentId]
+                ?.count ?? 0) + 1,
+            serverSets,
+        };
+        try {
+            repo.resyncSubduction(documentId);
+        }
+        catch (e) {
+            log("resyncSubduction failed", e);
+        }
+        prev.lastResyncAt = now;
+        prev.delay = Math.min(prev.delay * 2, RESYNC_MAX_DELAY_MS);
+    };
+    const reviewAllResync = () => {
+        if (!identity)
+            return;
+        for (const documentId of snapshot.keys())
+            reviewResync(documentId);
+        for (const id of [...resyncState.keys()]) {
+            if (!snapshot.has(id))
+                resyncState.delete(id);
+        }
+    };
+    repo.on("subduction-remote-heads", ({ documentId, storageId, heads, timestamp }) => {
+        const headsCopy = [...heads];
+        let byStorage = snapshot.get(documentId);
+        if (!byStorage) {
+            byStorage = new Map();
+            snapshot.set(documentId, byStorage);
+        }
+        byStorage.set(storageId, { heads: headsCopy, timestamp });
+        postHeads(documentId, storageId, headsCopy, timestamp);
+        // A doc the server reported is one we hold — make sure we're advertising
+        // our own heads for it too.
+        scanOwnHandles();
+        reviewResync(documentId);
+    });
+    repo.on("subduction-connection", ({ connected: isConnected }) => {
+        connected = isConnected;
+        postConnection();
+        if (isConnected)
+            void refreshServerPeers();
+    });
+    // A BroadcastChannel never receives its own posts, so this only sees tabs'
+    // requests, never our own broadcasts. We replay just the global signals here;
+    // a late tab gets per-doc heads by subscribing (sync-sub), not from this.
+    channel.addEventListener("message", (event) => {
+        const data = event.data;
+        if (data?.type !== "request")
+            return;
+        postWhoAmI();
+        postConnection();
+    });
+    // In case we're already connected by the time this wires up.
+    void refreshServerPeers();
+    // Discover the worker's docs by re-scanning repo.handles initially and on a
+    // tick (Subduction-pushed docs don't surface via the "document" event).
+    scanOwnHandles();
+    if (identity)
+        setInterval(scanOwnHandles, 3000);
+    // Drive the backoff re-sync of stuck/diverged docs. A tick is essential here:
+    // the "stuck" case is precisely when no head events are firing, so the
+    // grace/backoff timers can only advance on a timer.
+    if (identity)
+        setInterval(reviewAllResync, RESYNC_REVIEW_INTERVAL_MS);
+}
 function dropRepoChannel(repo, channel) {
     // removeNetworkAdapter pulls the adapter out of networkSubsystem.adapters and
     // calls adapter.disconnect(), which (for the MessageChannel adapter) emits the
@@ -329,6 +659,16 @@ function handleControlMessage(event, controlPort, connection) {
             });
         });
     }
+    else if (data?.type === "sync-sub") {
+        if (typeof data.documentId === "string") {
+            syncSubscribe(controlPort, data.documentId);
+        }
+    }
+    else if (data?.type === "sync-unsub") {
+        if (typeof data.documentId === "string") {
+            syncUnsubscribe(controlPort, data.documentId);
+        }
+    }
     else if (data?.type === "debug") {
         debugging = data.debug;
         log("automerge worker debugging enabled");
@@ -372,6 +712,9 @@ self.addEventListener("connect", (event) => {
     // event fall back to the adapters' lazy useWeakRef cleanup.
     controlPort.addEventListener("close", () => {
         controlPorts.delete(controlPort);
+        // The tab is gone — drop its sync subscriptions wholesale so we stop
+        // pushing it heads (no per-doc unsub needed, no leak).
+        syncWatchers.delete(controlPort);
         void dropConnection(connection);
     });
     controlPort.start();

package/dist/setup.d.ts

@@ -1,6 +1,9 @@
-import type { SetupServiceWorkerOptions, SetupServiceWorkerResult } from "./types.js";
+import type { SetupServiceWorkerOptions, SetupServiceWorkerResult, SyncStateDocMessage } from "./types.js";
 export declare function lifecycleLoggingEnabled(): boolean;
 export declare function bumpServiceWorkerCache(sw?: ServiceWorker | null): void;
 export declare function getAutomergeWorker(): SharedWorker;
+type SyncStateListener = (update: SyncStateDocMessage) => void;
+export declare function subscribeSyncState(documentId: string, listener: SyncStateListener): () => void;
 export declare function connectClassicSync(server?: string): Promise<void>;
 export default function setupServiceWorker(options?: SetupServiceWorkerOptions): Promise<SetupServiceWorkerResult>;
+export {};

package/dist/setup.js

@@ -91,6 +91,10 @@ export function getAutomergeWorker() {
         // 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 === "sync-state") {
+                dispatchSyncState(event.data);
+                return;
+            }
             if (event.data?.type !== "console")
                 return;
             const { level, args } = event.data;
@@ -181,6 +185,44 @@ function installWorkerDeathDetection(worker) {
         }
     }, HEARTBEAT_MS);
 }
+const syncStateListeners = new Map();
+function dispatchSyncState(update) {
+    const listeners = syncStateListeners.get(update.documentId);
+    if (!listeners)
+        return;
+    for (const listener of listeners) {
+        try {
+            listener(update);
+        }
+        catch (err) {
+            console.error("sync-state listener threw", err);
+        }
+    }
+}
+export function subscribeSyncState(documentId, listener) {
+    const worker = getAutomergeWorker();
+    let listeners = syncStateListeners.get(documentId);
+    if (!listeners) {
+        syncStateListeners.set(documentId, (listeners = new Set()));
+        // First local watcher for this doc — ask the worker to start pushing it.
+        worker.port.postMessage({ type: "sync-sub", documentId });
+    }
+    listeners.add(listener);
+    let active = true;
+    return () => {
+        if (!active)
+            return; // idempotent
+        active = false;
+        const set = syncStateListeners.get(documentId);
+        if (!set)
+            return;
+        set.delete(listener);
+        if (set.size === 0) {
+            syncStateListeners.delete(documentId);
+            worker.port.postMessage({ type: "sync-unsub", documentId });
+        }
+    };
+}
 export function connectClassicSync(server = readClassicSyncServer()) {
     const url = server.trim() || DEFAULT_CLASSIC_SYNC_SERVER;
     if (!/^wss?:\/\//.test(url)) {
@@ -318,6 +360,7 @@ export default async function setupServiceWorker(options) {
         shared,
         connectClassicSync,
         getRepoChannel,
+        subscribeSyncState,
         async subscribeToRepoChannel(listener) {
             // The automerge worker outlives the page, so unlike the old in-service-
             // worker repo there's nothing to reconnect: one port, handed over once.

package/dist/site.d.ts

@@ -16,7 +16,7 @@ import { type AutomergeRepoKeyhive } from "@automerge/automerge-repo-keyhive";
 import { ModuleWatcher } from "@inkandswitch/patchwork-filesystem";
 import { type AccountDoc } from "@inkandswitch/patchwork-plugins";
 import * as plugins from "@inkandswitch/patchwork-plugins";
-import type { ServiceWorkerRepoChannelListener } from "./types.js";
+import type { ServiceWorkerRepoChannelListener, SyncStateDocMessage } from "./types.js";
 declare global {
     interface Window {
         accountDocHandle: DocHandle<AccountDoc>;
@@ -30,9 +30,14 @@ 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>;