@inkandswitch/patchwork-bootloader 0.4.1 → 0.4.3

package/package.json

@@ -1,11 +1,10 @@
 {
   "name": "@inkandswitch/patchwork-bootloader",
-  "version": "0.4.1",
+  "version": "0.4.3",
   "author": "chee",
   "type": "module",
   "license": "MIT",
   "devDependencies": {
-    "@automerge/automerge-repo-keyhive": "0.3.0-alpha.sub.8b",
     "esbuild": "^0.23.1",
     "rollup": "^4.61.1"
   },
@@ -46,27 +45,47 @@
   "dependencies": {
     "@automerge/automerge": "3.3.2",
     "@automerge/automerge-repo": "2.6.0-subduction.46",
-    "@automerge/automerge-repo-network-messagechannel": "2.6.0-subduction.45",
-    "@automerge/automerge-repo-network-websocket": "2.6.0-subduction.45",
-    "@automerge/automerge-repo-storage-indexeddb": "2.6.0-subduction.45",
+    "@automerge/automerge-repo-keyhive": "0.3.0-alpha.sub.8b",
+    "@automerge/automerge-repo-network-messagechannel": "2.6.0-subduction.46",
+    "@automerge/automerge-repo-network-websocket": "2.6.0-subduction.46",
+    "@automerge/automerge-repo-storage-indexeddb": "2.6.0-subduction.46",
     "@automerge/automerge-subduction": "0.16.0",
-    "@automerge/vanillajs": "2.6.0-subduction.45",
+    "@automerge/vanillajs": "2.6.0-subduction.46",
+    "@codemirror/commands": "^6.10.4",
+    "@codemirror/language": "^6.12.4",
+    "@codemirror/state": "^6.7.1",
+    "@codemirror/view": "^6.43.6",
     "@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",
+    "solid-js": "^1.9.13",
     "tinyargs": "^0.1.4",
-    "@inkandswitch/patchwork-elements": "^3.0.0",
-    "@inkandswitch/patchwork-filesystem": "^0.1.3",
-    "@inkandswitch/patchwork-providers": "^0.4.0",
-    "@inkandswitch/patchwork-plugins": "^0.0.11"
+    "@inkandswitch/patchwork-elements": "^4.0.0",
+    "@inkandswitch/patchwork-filesystem": "^0.2.1",
+    "@inkandswitch/patchwork-plugins": "^1.0.1",
+    "@inkandswitch/patchwork-providers": "^0.4.1"
   },
   "peerDependencies": {
     "@automerge/automerge": "3.3.2",
     "@automerge/automerge-repo": "2.6.0-subduction.46",
     "@automerge/automerge-repo-keyhive": "0.3.0-alpha.sub.8b",
-    "@automerge/vanillajs": "2.6.0-subduction.45"
+    "@automerge/vanillajs": "2.6.0-subduction.46"
+  },
+  "peerDependenciesMeta": {
+    "@automerge/automerge": {
+      "optional": true
+    },
+    "@automerge/automerge-repo": {
+      "optional": true
+    },
+    "@automerge/automerge-repo-keyhive": {
+      "optional": true
+    },
+    "@automerge/vanillajs": {
+      "optional": true
+    }
   },
   "scripts": {
     "build": "tsc",

package/src/automerge-worker.ts

@@ -49,6 +49,7 @@ import {
   type HandoffCachedMessage,
   type HandoffOnlineMessage,
   type HandoffRequest,
+  type HandoffAbortMessage,
   type HandoffRequestMessage,
   type HandoffResponseMessage,
   type SyncStateBroadcast,
@@ -219,11 +220,9 @@ setInterval(() => {
   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()}`
+      `[lifecycle] ${new Date(now).toISOString()} watchdog timer gap ` +
+        `~${Math.round(gap / 1000)}s (expected every ` +
+        `${WATCHDOG_TICK_MS / 1000}s)`
     );
   }
 }, WATCHDOG_TICK_MS);
@@ -283,9 +282,7 @@ function getSubductionEndpoints(): (WorkerWebSocketEndpoint | string)[] {
         : [
             new WorkerWebSocketEndpoint(SUBDUCTION_SYNC_URL, {
               worker: subductionPortProvider.source,
-              ...(WS_WINDOW_FRAMES
-                ? { windowFrames: WS_WINDOW_FRAMES }
-                : {}),
+              ...(WS_WINDOW_FRAMES ? { windowFrames: WS_WINDOW_FRAMES } : {}),
             }),
           ];
   }
@@ -339,7 +336,7 @@ async function connectClassicSyncNetwork(server: string): Promise<void> {
 }
 
 const siteName =
-  typeof __SITE_NAME__ !== "undefined" ? __SITE_NAME__ : "tiny-patchwork";
+  typeof __SITE_NAME__ !== "undefined" ? __SITE_NAME__ : "patchwork.inkandswitch.com";
 
 const cacheableStatuses = [200, 203, 204];
 
@@ -365,10 +362,9 @@ function getRepoHive() {
   if (!repoHivePromise) {
     repoHivePromise = (async () => {
       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));
@@ -646,8 +642,9 @@ function setupSyncStateBroadcast(
   >();
   // 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: { fires: number; byDoc: Record<string, unknown> } =
-    ((self as any).patchworkResync ??= { fires: 0, byDoc: {} });
+  const resyncDiag: { fires: number; byDoc: Record<string, unknown> } = ((
+    self as any
+  ).patchworkResync ??= { fires: 0, byDoc: {} });
   const reviewResync = (documentId: string) => {
     if (!identity || !connected) {
       resyncState.delete(documentId);
@@ -732,8 +729,12 @@ function setupSyncStateBroadcast(
       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 as DocumentId];
+      if (handle) trackOwnHandle(handle as never);
       reviewResync(documentId);
     }
   );
@@ -870,6 +871,16 @@ function handleControlMessage(
   connection: 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 as any).patchworkControl ??= {
+    connects: 0,
+    byType: {} as Record<string, number>,
+  });
+  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;
@@ -930,6 +941,7 @@ function handleControlMessage(
 self.addEventListener("connect", (event) => {
   const controlPort = (event as MessageEvent).ports[0];
   const connection: Connection = { channels: new Set() };
+  ((self as any).patchworkControl ??= { connects: 0, byType: {} }).connects++;
 
   controlPort.addEventListener("message", (messageEvent) => {
     handleControlMessage(messageEvent as MessageEvent, controlPort, connection);
@@ -1010,6 +1022,13 @@ function waitForHeads(
   });
 }
 
+/**
+ * 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: URL): Promise<Response> {
   const { repo } = await getRepoHive();
   const href = automergeURL.href;
@@ -1043,7 +1062,12 @@ async function resolveAutomergeUrl(automergeURL: URL): Promise<Response> {
   // 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);
 
@@ -1137,6 +1161,14 @@ async function handleHandoffRequest(message: HandoffRequestMessage) {
       ),
     ]);
   } catch (error) {
+    if (error instanceof AbortHandoff) {
+      handoffChannel.postMessage({
+        id,
+        type: "abort",
+        reason: error.message,
+      } satisfies HandoffAbortMessage);
+      return;
+    }
     const body =
       error instanceof Error
         ? `${error.message}\n\n${error.stack}`

package/src/module-loader-worker.ts

@@ -11,7 +11,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";
 import type { AutomergeUrl } from "@automerge/automerge-repo/slim";
 
 type DiscoverRequest = {
@@ -45,7 +45,7 @@ self.addEventListener("message", (event: MessageEvent) => {
   if (!isDiscoverRequest(data)) return;
   const { id, url } = data;
 
-  importModuleFromFolderDocUrl(url)
+  importPackageFromFolderDocUrl(url)
     .then((mod) => {
       const plugins: any[] = Array.isArray(mod?.plugins) ? mod.plugins : [];
       const descriptors = plugins.map(toDescriptor);

package/src/module-loader.ts

@@ -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
@@ -62,11 +62,11 @@ function discoverDescriptors(urlAtHeads: AutomergeUrl): Promise<Descriptor[]> {
 }
 
 /**
- * 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(
+export async function importAutomergePackageViaWorker(
   urlAtHeads: string
 ): Promise<{ plugins: Descriptor[] }> {
   const url = urlAtHeads as AutomergeUrl;

package/src/service-worker.ts

@@ -184,6 +184,9 @@ handoffChannel.addEventListener("message", (event) => {
   }
 });
 
+/** Signals that respondWith should reject; see {@link HandoffAbortMessage}. */
+class HandoffAborted extends Error {}
+
 function handoff(
   request: Request,
   handoffURL: URL
@@ -259,10 +262,34 @@ async function cachePage(
   response: 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: FetchEvent,
+  cache: Cache,
+  request: Request,
+  response: 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 ──────────────────────────────────────────────────────
@@ -270,7 +297,9 @@ async function cachePage(
 self.addEventListener("fetch", (fetchEvent: FetchEvent) => {
   log("fetch event", fetchEvent.request.url);
   const request = fetchEvent.request;
-  if (request.method !== "GET") return fetchEvent.respondWith(fetch(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;
   const url = new URL(fetchEvent.request.url);
 
   let handoffURL: URL | undefined;
@@ -303,6 +332,14 @@ self.addEventListener("fetch", (fetchEvent: FetchEvent) => {
           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);
@@ -341,15 +378,7 @@ self.addEventListener("fetch", (fetchEvent: FetchEvent) => {
                 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}`
@@ -366,6 +395,8 @@ self.addEventListener("fetch", (fetchEvent: 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}`