@inkandswitch/patchwork-bootloader 0.4.1 → 0.4.3

package/CHANGELOG.md

@@ -1,5 +1,75 @@
 # @inkandswitch/patchwork-bootloader
 
+## 0.4.3
+
+### Patch Changes
+
+- bd9cd3d: Reliability and boot-speed fixes:
+
+  - The service worker no longer blocks responses on cache writes (they move to
+    `waitUntil`), page caching writes its three entries in parallel, non-GET
+    requests bypass the worker entirely, cache-write failures (e.g. quota) are
+    always logged, the cache is capped at 2000 entries with oldest-first
+    trimming, and boot requests persistent storage so cache growth can't trip
+    origin-wide eviction of user data.
+  - `automerge.wasm` is fetched under one URL from both the tab and the
+    automerge worker (the `?main`/`?worker` tracing query strings defeated the
+    HTTP cache, the SW cache, and the sites' preload — the ~3MB body downloaded
+    twice).
+  - Tabs now recover when the automerge SharedWorker dies or its connection is
+    stranded. Previously death was only logged and tabs silently stopped syncing
+    until reload. Silence alone never tears anything down (a slow-booting or
+    busy worker delivers everything queued once it catches up): a silent port
+    first starts a non-destructive probe — a second connection to the same
+    instance — and only when the probe gets a `hello` while the original port
+    stays silent (proving a live instance with a stranded port) is the worker
+    handle recreated, with sync-state subscriptions replayed and every
+    subscriber's repo re-wired onto a fresh port. This rescues boots whose
+    initial SharedWorker port comes up deaf (~6s), including in hidden
+    background tabs; a port `close` event still recovers immediately.
+  - The worker no longer rescans every doc handle on every
+    `subduction-remote-heads` event (quadratic during sync bursts); it tracks
+    just the reported doc.
+  - `ModuleWatcher` announces are generation-tracked, so a stale retry of an
+    older module version can no longer land after a newer version and roll the
+    registry back.
+  - `resolveAccountHandle` never overwrites a valid stored account pointer when
+    `repo.find` fails: it retries briefly and then throws, instead of silently
+    creating a fresh account and orphaning the user's workspace.
+  - `OverlayRepo` no longer memoizes rejected resolutions: a `find` that failed
+    because the doc (or its keyhive access) hadn't synced yet used to pin every
+    later `find` of that url to the same cached rejection, so the views' "retry
+    once access syncs" recovery could never reach the base repo. Rejections now
+    evict and the next `find` re-resolves. `findWithProgress().subscribe` also
+    no longer leaks its inner subscription (or fires the callback) when
+    unsubscribed before the resolution settles.
+
+- Updated dependencies [bd9cd3d]
+  - @inkandswitch/patchwork-filesystem@0.2.1
+  - @inkandswitch/patchwork-plugins@1.0.1
+  - @inkandswitch/patchwork-providers@0.4.1
+
+## 0.4.2
+
+### Patch Changes
+
+- 82bee46: A doc's `suggestedImportUrl` may now be an `automerge:` folder-doc URL as well
+  as an `http(s):` module bundle. When a view finds no built-in tool for a doc, it
+  loads the suggested module either way. Adds `importPackage` (which dispatches on
+  the URL scheme) and `isImportableSuggestedUrl` to `patchwork-filesystem`, and
+  `getSuggestedImportUrl` now honors automerge URLs.
+
+  The package-importing helpers are renamed from `module` to `package`, since they
+  resolve a `package.json` entry point: `importModuleFromFolderDocUrl` →
+  `importPackageFromFolderDocUrl`, `importModuleFromHttpUrl` →
+  `importPackageFromHttpUrl`, and the `ModuleWatcher` `importAutomergeModule` hook
+  (with bootloader's `importAutomergeModuleViaWorker`) → `importAutomergePackage`.
+
+- Updated dependencies [82bee46]
+  - @inkandswitch/patchwork-filesystem@0.2.0
+  - @inkandswitch/patchwork-elements@4.0.0
+  - @inkandswitch/patchwork-plugins@1.0.0
+
 ## 0.4.1
 
 ### Patch Changes

package/dist/automerge-worker.js

@@ -172,11 +172,9 @@ setInterval(() => {
     const gap = now - watchdogLast;
     watchdogLast = now;
     if (gap > WATCHDOG_TICK_MS * WATCHDOG_GAP_FACTOR) {
-        console.warn(`[lifecycle] worker resumed after ~${Math.round(gap / 1000)}s gap ` +
-            `(timer expected every ${WATCHDOG_TICK_MS / 1000}s) — likely ` +
-            `suspended/frozen/throttled; WebSocket keepalive pongs were not sent ` +
-            `during this window, so the sync server may have reaped us. at ` +
-            `${new Date(now).toISOString()}`);
+        console.warn(`[lifecycle] ${new Date(now).toISOString()} watchdog timer gap ` +
+            `~${Math.round(gap / 1000)}s (expected every ` +
+            `${WATCHDOG_TICK_MS / 1000}s)`);
     }
 }, WATCHDOG_TICK_MS);
 // Sync server selection. Sub is the default. Build with KEYHIVE_SYNC_SERVER=true
@@ -225,9 +223,7 @@ function getSubductionEndpoints() {
                 : [
                     new WorkerWebSocketEndpoint(SUBDUCTION_SYNC_URL, {
                         worker: subductionPortProvider.source,
-                        ...(WS_WINDOW_FRAMES
-                            ? { windowFrames: WS_WINDOW_FRAMES }
-                            : {}),
+                        ...(WS_WINDOW_FRAMES ? { windowFrames: WS_WINDOW_FRAMES } : {}),
                     }),
                 ];
     }
@@ -273,7 +269,7 @@ async function connectClassicSyncNetwork(server) {
         throw err;
     }
 }
-const siteName = typeof __SITE_NAME__ !== "undefined" ? __SITE_NAME__ : "tiny-patchwork";
+const siteName = typeof __SITE_NAME__ !== "undefined" ? __SITE_NAME__ : "patchwork.inkandswitch.com";
 const cacheableStatuses = [200, 203, 204];
 function log(...args) {
     if (!debugging)
@@ -288,7 +284,7 @@ function getRepoHive() {
             log("getRepo: starting");
             log("fetching wasm modules");
             const [amWasmBuf, sdnWasmBuf] = await Promise.all([
-                fetch("/automerge.wasm?worker").then((r) => r.arrayBuffer()),
+                fetch("/automerge.wasm").then((r) => r.arrayBuffer()),
                 fetch("/subduction.wasm").then((r) => r.arrayBuffer()),
             ]);
             initSubductionSync(new Uint8Array(sdnWasmBuf));
@@ -612,8 +608,13 @@ function setupSyncStateBroadcast(repo, identity) {
         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();
+        // our own heads for it too. Track just this doc: a full scanOwnHandles()
+        // per event is O(all handles) and goes quadratic during sync bursts,
+        // starving the thread that's doing the syncing. The 3s tick still covers
+        // general discovery.
+        const handle = repo.handles[documentId];
+        if (handle)
+            trackOwnHandle(handle);
         reviewResync(documentId);
     });
     repo.on("subduction-connection", ({ connected: isConnected }) => {
@@ -717,6 +718,16 @@ async function connectPort(port, connection) {
 }
 function handleControlMessage(event, controlPort, connection) {
     const data = event.data;
+    // Tally of control messages received, readable from the SharedWorker console
+    // as `self.patchworkControl`. Not using log(): that's gated on `debugging`,
+    // which is only enabled by a {type:"debug"} message arriving over this same
+    // channel.
+    const stats = (self.patchworkControl ??= {
+        connects: 0,
+        byType: {},
+    });
+    stats.byType[String(data?.type ?? "<untyped>")] =
+        (stats.byType[String(data?.type ?? "<untyped>")] ?? 0) + 1;
     if (data?.type === "port") {
         log("received repo channel");
         const [repoPort] = event.ports;
@@ -777,6 +788,7 @@ function handleControlMessage(event, controlPort, connection) {
 self.addEventListener("connect", (event) => {
     const controlPort = event.ports[0];
     const connection = { channels: new Set() };
+    (self.patchworkControl ??= { connects: 0, byType: {} }).connects++;
     controlPort.addEventListener("message", (messageEvent) => {
         handleControlMessage(messageEvent, controlPort, connection);
     });
@@ -848,6 +860,13 @@ function waitForHeads(handle, hexHeads, signal) {
         check();
     });
 }
+/**
+ * Thrown instead of returning a Response when the request should fail as a
+ * network error rather than resolve to something the caller can memoize.
+ * See {@link HandoffAbortMessage}.
+ */
+class AbortHandoff extends Error {
+}
 async function resolveAutomergeUrl(automergeURL) {
     const { repo } = await getRepoHive();
     const href = automergeURL.href;
@@ -878,7 +897,10 @@ async function resolveAutomergeUrl(automergeURL) {
     // The heads may not have synced to us yet — give them the rest of the
     // resolve window to arrive before giving up.
     if (!(await waitForHeads(baseHandle, hexHeads ?? [], signal))) {
-        return new Response("heads not found", { status: 404 });
+        // Not a 404: the heads may still be on their way, and this exact URL will
+        // be requested again once they land. Fail it as a network error so the
+        // caller doesn't memoize the miss.
+        throw new AbortHandoff(`heads not found for ${maybeAutomergeUrl} within ${RESOLVE_TIMEOUT_MS}ms`);
     }
     const rootHandle = baseHandle.view(heads);
     const resolved = await resolvePath(repo, rootHandle, path.map(decodeURIComponent));
@@ -949,6 +971,14 @@ async function handleHandoffRequest(message) {
         ]);
     }
     catch (error) {
+        if (error instanceof AbortHandoff) {
+            handoffChannel.postMessage({
+                id,
+                type: "abort",
+                reason: error.message,
+            });
+            return;
+        }
         const body = error instanceof Error
             ? `${error.message}\n\n${error.stack}`
             : String(error);

package/dist/module-loader-worker.js

@@ -10,7 +10,7 @@
 //
 // Created with type:"module"; its dynamic `import()` of `/<automergeUrl>/…`
 // entry points is served by the service worker that controls this worker.
-import { importModuleFromFolderDocUrl } from "@inkandswitch/patchwork-filesystem";
+import { importPackageFromFolderDocUrl } from "@inkandswitch/patchwork-filesystem";
 // Keep only the structured-cloneable description fields. `load` is a closure
 // and `module` is the (possibly already-loaded) implementation — neither can
 // cross the worker boundary. `import` is droppable too: the main thread
@@ -33,7 +33,7 @@ self.addEventListener("message", (event) => {
     if (!isDiscoverRequest(data))
         return;
     const { id, url } = data;
-    importModuleFromFolderDocUrl(url)
+    importPackageFromFolderDocUrl(url)
         .then((mod) => {
         const plugins = Array.isArray(mod?.plugins) ? mod.plugins : [];
         const descriptors = plugins.map(toDescriptor);

package/dist/module-loader.d.ts

@@ -3,11 +3,11 @@ type Descriptor = Record<string, unknown> & {
     type?: string;
 };
 /**
- * ModuleWatcher `importAutomergeModule` hook: discover descriptors in the
+ * ModuleWatcher `importAutomergePackage` hook: discover descriptors in the
  * worker, then return the `{ plugins }` shape with a main-thread `load()` per
  * plugin that imports the package at heads and calls its real loader.
  */
-export declare function importAutomergeModuleViaWorker(urlAtHeads: string): Promise<{
+export declare function importAutomergePackageViaWorker(urlAtHeads: string): Promise<{
     plugins: Descriptor[];
 }>;
 export {};

package/dist/module-loader.js

@@ -1,6 +1,6 @@
 // Main-thread client for the module-loader worker (see module-loader-worker.ts).
 //
-// `importAutomergeModuleViaWorker` is wired into the ModuleWatcher in place of
+// `importAutomergePackageViaWorker` is wired into the ModuleWatcher in place of
 // its default (direct, main-thread) package import. It asks the worker to
 // import the package entry point and report which plugins it exports, then
 // returns the same `{ plugins }` shape the watcher already feeds to
@@ -50,11 +50,11 @@ function discoverDescriptors(urlAtHeads) {
     });
 }
 /**
- * ModuleWatcher `importAutomergeModule` hook: discover descriptors in the
+ * ModuleWatcher `importAutomergePackage` hook: discover descriptors in the
  * worker, then return the `{ plugins }` shape with a main-thread `load()` per
  * plugin that imports the package at heads and calls its real loader.
  */
-export async function importAutomergeModuleViaWorker(urlAtHeads) {
+export async function importAutomergePackageViaWorker(urlAtHeads) {
     const url = urlAtHeads;
     const descriptors = await discoverDescriptors(url);
     const plugins = descriptors.map((descriptor) => {

package/dist/service-worker.js

@@ -135,6 +135,9 @@ handoffChannel.addEventListener("message", (event) => {
         }
     }
 });
+/** Signals that respondWith should reject; see {@link HandoffAbortMessage}. */
+class HandoffAborted extends Error {
+}
 function handoff(request, handoffURL) {
     const id = crypto.randomUUID();
     const resolvers = Promise.withResolvers();
@@ -190,19 +193,34 @@ function rootRequestFor(request) {
 }
 async function cachePage(cache, request, response) {
     const indexRequest = indexRequestFor(request);
-    if (indexRequest)
-        await cache.put(indexRequest, response.clone());
     const rootRequest = rootRequestFor(request);
-    if (rootRequest)
-        await cache.put(rootRequest, response.clone());
-    await cache.put(request, response);
+    await Promise.all([
+        indexRequest && cache.put(indexRequest, response.clone()),
+        rootRequest && cache.put(rootRequest, response.clone()),
+        cache.put(request, response),
+    ]);
+}
+// Write to the cache without blocking the response: cache.put only resolves
+// once the whole body has been consumed and persisted, so awaiting it before
+// returning would turn time-to-first-byte into time-to-last-byte-plus-disk
+// for every proxied asset. waitUntil keeps the worker alive for the write.
+function cacheInBackground(fetchEvent, cache, request, response) {
+    fetchEvent.waitUntil((request.mode === "navigate" || request.destination === "document"
+        ? cachePage(cache, request, response)
+        : cache.put(request, response)).catch((error) => {
+        // Always loud (not gated on debugging): a QuotaExceededError here is
+        // the first sign the origin is under storage pressure.
+        console.warn(`error caching ${request.url} in ${cachename}`, error);
+    }));
 }
 // ── Fetch handler ──────────────────────────────────────────────────────
 self.addEventListener("fetch", (fetchEvent) => {
     log("fetch event", fetchEvent.request.url);
     const request = fetchEvent.request;
+    // Not calling respondWith at all lets the browser handle non-GETs natively
+    // instead of proxying their bodies through this worker.
     if (request.method !== "GET")
-        return fetchEvent.respondWith(fetch(request));
+        return;
     const url = new URL(fetchEvent.request.url);
     let handoffURL;
     if (url.hostname == self.location.hostname &&
@@ -227,6 +245,13 @@ self.addEventListener("fetch", (fetchEvent) => {
                 const replyPromise = handoff(request, handoffURL);
                 fetchEvent.waitUntil(replyPromise.catch(() => { }));
                 const reply = await replyPromise;
+                if (reply.type === "abort") {
+                    // Rejecting respondWith gives the caller a network error rather
+                    // than a response it can memoize. Rethrown past the catch below,
+                    // which would otherwise turn this into a 556.
+                    log(`aborting ${handoffURL}: ${reply.reason}`);
+                    throw new HandoffAborted(reply.reason);
+                }
                 if (reply.type === "response") {
                     // errors, redirects and other things that shouldn't be cached
                     log(`serving handed-off response for ${handoffURL}`, reply);
@@ -258,13 +283,7 @@ self.addEventListener("fetch", (fetchEvent) => {
                     if ((response.status === 0 ||
                         cacheableStatuses.includes(response.status)) &&
                         /^https?:/.test(request.url)) {
-                        const cachedResponse = response.clone();
-                        await (request.mode === "navigate" ||
-                            request.destination === "document"
-                            ? cachePage(cache, request, cachedResponse)
-                            : cache.put(request, cachedResponse)).catch((error) => {
-                            log(`error caching ${request.url} in ${cachename}`, error);
-                        });
+                        cacheInBackground(fetchEvent, cache, request, response.clone());
                     }
                     else {
                         log(`skipping uncacheable response code from cache: ${response.status} for ${request.url}`);
@@ -277,6 +296,9 @@ self.addEventListener("fetch", (fetchEvent) => {
             }
         }
         catch (error) {
+            // Deliberate: fail the request as a network error, no response.
+            if (error instanceof HandoffAborted)
+                throw error;
             const message = error instanceof Error
                 ? `${error.message}\n\n${error.stack}`
                 : String(error);