@inkandswitch/patchwork 0.7.4 → 0.8.1

package/src/site-kit/sync-servers.ts

@@ -2,9 +2,10 @@ import type { PatchworkSiteOptions } from "./options.js";
 import type { SyncServerSelection } from "@automerge/automerge-repo-keyhive";
 
 // Mirrors core/bootloader/src/sync-config.ts's DEFAULT_CLASSIC_SYNC_SERVER
-// and automerge-worker.ts's SUBDUCTION_SYNC_URL selection — kept here as
-// plain constants (rather than importing those runtime modules) since this
-// only needs the hostnames, not the browser-only logic that reads them.
+// and automerge-protocol-handler-worker.ts's SUBDUCTION_SYNC_URL selection —
+// kept here as plain constants (rather than importing those runtime modules)
+// since this only needs the hostnames, not the browser-only logic that reads
+// them.
 export const DEFAULT_SYNC_SERVERS = {
   classic: "wss://sync3.automerge.org",
   subduction: "wss://subduction.sync.inkandswitch.com",
@@ -14,24 +15,26 @@ export const DEFAULT_SYNC_SERVERS = {
 export function resolvePrimarySyncServer(options: PatchworkSiteOptions): {
   url: string;
   keyhive?: SyncServerSelection;
+  useIdFactory?: boolean;
 } {
-  const servers = options.syncServers || undefined;
-  if (servers?.keyhive) {
-    if (typeof servers.keyhive === "string") {
-      return {
-        keyhive: servers.keyhive,
-        url: DEFAULT_SYNC_SERVERS[servers.keyhive],
-      };
-    }
-    const { url, ...identity } = servers.keyhive;
+  const subduction = (options.syncServers || undefined)?.subduction;
+  if (!options.keyhive) {
+    return { url: subduction ?? DEFAULT_SYNC_SERVERS.subduction };
+  }
+  const keyhive = options.keyhive === true ? {} : options.keyhive;
+  const useIdFactory = keyhive.useIdFactory ?? true;
+  const syncServer = keyhive.syncServer ?? "subduction";
+  if (typeof syncServer === "string") {
     return {
-      keyhive: identity,
-      url,
+      keyhive: syncServer,
+      url: subduction ?? DEFAULT_SYNC_SERVERS[syncServer],
+      useIdFactory,
     };
   }
-  return {
-    url: servers?.subduction ?? DEFAULT_SYNC_SERVERS.subduction,
-  };
+  // A custom relay carries the only URL it can be reached on, so it wins over
+  // `syncServers.subduction`.
+  const { url, ...identity } = syncServer;
+  return { keyhive: identity, url, useIdFactory };
 }
 
 function wsToHttpOrigin(wsUrl: string): string {

package/src/types.ts

@@ -8,21 +8,27 @@ import type {
   AccountCreator,
   AccountDoc,
 } from "@inkandswitch/patchwork-plugins";
-import type {
-  ServiceWorkerRepoChannelListener,
-  SyncStateDocMessage,
-} from "@inkandswitch/patchwork-bootloader/types";
 import type * as pluginsNS from "@inkandswitch/patchwork-plugins";
 
 export type PluginsApi = typeof pluginsNS;
 
 export type SignerIdentity = { peerId: string; verifyingKey: string };
 
+/** The sync server's last-known heads for one document, as it reports them. */
+export interface SyncStateDocMessage {
+  type: "sync-state";
+  documentId: string;
+  storageId: string;
+  heads: string[];
+  timestamp: number;
+}
+
 export interface ServiceWorkerApi {
   connectClassicSync: (server?: string) => Promise<void>;
-  subscribeToRepoChannel: (
-    listener: ServiceWorkerRepoChannelListener
-  ) => Promise<() => void>;
+  /**
+   * Watch one document's heads at the sync server. Calls `listener` with
+   * what the server holds now, then on every update. Returns unsubscribe.
+   */
   subscribeSyncState: (
     documentId: string,
     listener: (update: SyncStateDocMessage) => void
@@ -91,7 +97,8 @@ export interface PatchworkOptions {
   /**
    * Bring your own Repo. When provided, setup skips wasm initialization and
    * repo creation entirely — you are responsible for having initialized
-   * automerge/subduction and wired the automerge-worker port yourself.
+   * automerge/subduction and wired the automerge-protocol-handler-worker
+   * port yourself.
    */
   repo?: Repo;
 

package/src/vite/config-plugin.ts

@@ -40,9 +40,7 @@ export function buildDefines(
  * used to hand-write in its own vite.config.ts. Each is switched off
  * individually via the matching `false` option.
  */
-export function config(
-  options: PatchworkVitePluginOptions = {}
-): Plugin {
+export function config(options: PatchworkVitePluginOptions = {}): Plugin {
   return {
     name: "@patchwork/config",
     config() {
@@ -87,11 +85,11 @@ export function config(
         },
       };
     },
-    // The shared automerge-worker's chunk imports bypass the page's service
-    // worker, so offline boot needs the browser's HTTP cache to serve them
-    // without revalidating. Content hashes make that safe; a new build gets
-    // new URLs. Production gets this from the generated _headers file — vite
-    // preview doesn't read that, so mirror it here.
+    // The shared automerge-protocol-handler-worker's chunk imports bypass the
+    // page's service worker, so offline boot needs the browser's HTTP cache to
+    // serve them without revalidating. Content hashes make that safe; a new
+    // build gets new URLs. Production gets this from the generated _headers
+    // file — vite preview doesn't read that, so mirror it here.
     configurePreviewServer(server) {
       if (
         options.netlify === false ||
@@ -101,10 +99,7 @@ export function config(
       }
       server.middlewares.use((req, res, next) => {
         if (req.url?.startsWith("/assets/")) {
-          res.setHeader(
-            "Cache-Control",
-            "public, max-age=31536000, immutable"
-          );
+          res.setHeader("Cache-Control", "public, max-age=31536000, immutable");
         }
         next();
       });

package/src/vite/patches-plugin.ts

@@ -0,0 +1,184 @@
+import { readFile } from "node:fs/promises";
+import { join } from "node:path";
+import type { Plugin } from "vite";
+
+/**
+ * Source patches to @automerge/automerge-repo, applied as it passes through
+ * the bundler.
+ *
+ * The same edits live in this repo's `patches/` as a pnpm patch, which is what
+ * makes our own typecheck see the widened `role` type. A pnpm patch only
+ * exists in this repo's node_modules, though: a site that installs
+ * @inkandswitch/patchwork resolves automerge-repo out of its own tree and
+ * would bundle it unpatched. These run there too.
+ *
+ * Both edits are upstream-shaped and meant to be deleted once subduction takes
+ * them. Until then they are pinned to one automerge-repo version and every
+ * anchor has to match, so a dependency bump fails the build instead of quietly
+ * un-patching it.
+ */
+const AUTOMERGE_REPO = "@automerge/automerge-repo";
+const VERSION = "2.6.0-subduction.48";
+
+type Edit = { find: string; replace: string };
+
+const PATCHES: Record<string, Edit[]> = {
+  "dist/subduction/AdapterConnections.js": [
+    {
+      find: `            if (role === "accept") {
+                await subduction.acceptTransport(transport, serviceName);
+            }
+            else {
+                await subduction.connectTransport(transport, serviceName);
+            }`,
+      replace: `            const initiate = role === "mesh" ? this.#localPeerId < peerId : role !== "accept";
+            if (initiate) {
+                await subduction.connectTransport(transport, serviceName);
+            }
+            else {
+                await subduction.acceptTransport(transport, serviceName);
+            }`,
+    },
+  ],
+  "dist/subduction/SubductionConnections.js": [
+    {
+      find: `            if (state === "connecting")
+                return true;`,
+      replace: `            // "awaiting-reconnect" counts: the loop is between attempts, not
+            // given up, so a query should wait rather than report unavailable.
+            if (state === "connecting" || state === "awaiting-reconnect")
+                return true;`,
+    },
+  ],
+};
+
+function match(id: string): { file: string; root: string } | undefined {
+  const path = id.replace(/\\/g, "/").split("?")[0];
+  for (const file of Object.keys(PATCHES)) {
+    const suffix = `/${AUTOMERGE_REPO}/${file}`;
+    if (path.endsWith(suffix)) {
+      return {
+        file,
+        root: path.slice(0, -suffix.length) + `/${AUTOMERGE_REPO}`,
+      };
+    }
+  }
+}
+
+const versions = new Map<string, Promise<string>>();
+
+async function assertVersion(root: string, file: string): Promise<void> {
+  let version = versions.get(root);
+  if (!version) {
+    version = readFile(join(root, "package.json"), "utf8").then(
+      (json) => JSON.parse(json).version,
+      (error) => {
+        throw new Error(
+          `@inkandswitch/patchwork: couldn't read ${root}/package.json to ` +
+            `check the version the source patches are written against. ` +
+            `Has the package's layout changed? (${error})`
+        );
+      }
+    );
+    versions.set(root, version);
+  }
+  if ((await version) !== VERSION) {
+    throw new Error(
+      `@inkandswitch/patchwork: ${AUTOMERGE_REPO} is ${await version}, and the ` +
+        `source patches in patches-plugin.ts are written against ${VERSION}. ` +
+        `Re-check them against the new version (${file} is one of the files ` +
+        `they edit), then bump VERSION.`
+    );
+  }
+}
+
+function apply(code: string, file: string): string {
+  return PATCHES[file].reduce((code, { find, replace }) => {
+    if (code.includes(replace)) return code;
+    const matches = code.split(find).length - 1;
+    if (matches !== 1) {
+      throw new Error(
+        `@inkandswitch/patchwork: the source patch for ${AUTOMERGE_REPO}'s ` +
+          `${file} matched ${matches} times, expected 1. The file is the ` +
+          `version it says it is, so the patch needs rewriting against it.`
+      );
+    }
+    return code.replace(find, replace);
+  }, code);
+}
+
+async function patchFile(id: string): Promise<string | undefined> {
+  const found = match(id);
+  if (!found) return;
+  await assertVersion(found.root, found.file);
+  return apply(await readFile(id, "utf8"), found.file);
+}
+
+export function patches(): Plugin {
+  const seen = new Set<string>();
+  let serve = false;
+
+  return {
+    name: "@patchwork/patches",
+    enforce: "pre",
+
+    // Dep pre-bundling runs esbuild directly, outside the plugin pipeline that
+    // applies `transform`. Without this the dev server would serve an
+    // unpatched automerge-repo while the build patched it.
+    config() {
+      return {
+        optimizeDeps: {
+          esbuildOptions: {
+            plugins: [
+              {
+                name: "patchwork-automerge-repo-patches",
+                setup(build: {
+                  onLoad(
+                    options: { filter: RegExp },
+                    callback: (args: {
+                      path: string;
+                    }) => Promise<
+                      { contents: string; loader: "js" } | undefined
+                    >
+                  ): void;
+                }) {
+                  build.onLoad(
+                    { filter: /automerge-repo[\\/]dist[\\/]subduction[\\/]/ },
+                    async ({ path }) => {
+                      const contents = await patchFile(path);
+                      return contents ? { contents, loader: "js" } : undefined;
+                    }
+                  );
+                },
+              },
+            ],
+          },
+        },
+      };
+    },
+
+    configResolved(config) {
+      serve = config.command === "serve";
+    },
+
+    async transform(code, id) {
+      const found = match(id);
+      if (!found) return;
+      await assertVersion(found.root, found.file);
+      seen.add(found.file);
+      return apply(code, found.file);
+    },
+
+    buildEnd() {
+      if (serve) return;
+      const missing = Object.keys(PATCHES).filter((file) => !seen.has(file));
+      if (missing.length) {
+        throw new Error(
+          `@inkandswitch/patchwork: ${AUTOMERGE_REPO}'s ${missing.join(", ")} ` +
+            `never reached the bundler, so the source patches for them didn't ` +
+            `apply. Has the package's layout changed?`
+        );
+      }
+    },
+  };
+}

package/src/vite/patchwork-plugin.ts

@@ -1,6 +1,7 @@
 import type { Plugin, ServerOptions, PreviewOptions, BuildOptions } from "vite";
 
 import { importmap } from "./importmap-plugin.js";
+import { patches } from "./patches-plugin.js";
 import { serviceworker } from "./service-worker-plugin.js";
 import { config, wasm } from "./config-plugin.js";
 import { dev } from "./dev-plugin.js";
@@ -42,6 +43,7 @@ export default function patchwork(options?: PatchworkVitePluginOptions) {
     manifest(options),
     netlify(options),
     importmap(options),
+    patches(),
     serviceworker(),
     dev(options),
     statics(options),
@@ -50,6 +52,7 @@ export default function patchwork(options?: PatchworkVitePluginOptions) {
 }
 
 export { importmap, builtins, devDependencyId } from "./importmap-plugin.js";
+export { patches } from "./patches-plugin.js";
 export { serviceworker, workers } from "./service-worker-plugin.js";
 export { config, buildDefines, wasm } from "./config-plugin.js";
 export { dev } from "./dev-plugin.js";
@@ -74,6 +77,7 @@ export type {
   PatchworkHtmlOptions,
   PatchworkNetlifyOptions,
   PatchworkKeyhiveSyncServer,
+  PatchworkKeyhiveOptions,
   PatchworkSyncServersOptions,
 } from "../site-kit/options.js";
 

package/src/vite/service-worker-plugin.ts

@@ -19,8 +19,9 @@ export const workers = [
     fileName: "service-worker.js",
   },
   {
-    specifier: "@inkandswitch/patchwork-bootloader/automerge-worker",
-    fileName: "automerge-worker.js",
+    specifier:
+      "@inkandswitch/patchwork-bootloader/automerge-protocol-handler-worker",
+    fileName: "automerge-protocol-handler-worker.js",
   },
   {
     specifier: "@inkandswitch/patchwork-bootloader/module-loader-worker",