@inkandswitch/patchwork 0.8.0 → 0.8.1

package/CHANGELOG.md

@@ -1,5 +1,25 @@
 # @inkandswitch/patchwork
 
+## 0.8.1
+
+### Patch Changes
+
+- 5462610: Apply Patchwork's automerge-repo source patches at bundle time, so a site that installs `@inkandswitch/patchwork` gets them. They were only a pnpm patch, which exists in this repo's node_modules and nowhere else, so every consumer bundled an automerge-repo without the `mesh` subduction role or the `awaiting-reconnect` fix to `isConnecting()`.
+
+  The new `patches` plugin is part of `patchwork()` and also exported on its own. It rewrites the two files as they pass through rollup, and registers the same rewrite as an esbuild plugin for dep pre-bundling, which runs outside the plugin pipeline. It is pinned to one automerge-repo version and every anchor has to match, so bumping the dependency fails the build rather than quietly dropping the patches. A copy that already carries the edits — this repo's, via the pnpm patch — is left alone.
+
+- 5462610: Move keyhive out of `syncServers` and into its own top-level site option: `keyhive?: boolean | { syncServer?, useIdFactory? }`. `keyhive: true` enables it against the `"subduction"` relay; the object form picks a different relay (or a custom `{url, contactCardJson, peerId}` identity) and turns individual behaviour off. `keyhive.useIdFactory: false` drops the `idFactory` ARK injects into the repo config, so document ids are generated the Repo's own way instead of derived from keyhive. It reaches both the tab repo and the automerge protocol handler worker through the `__SYNC_SERVER__` define.
+
+  `syncServers` is now just URLs — `subduction` and `classic`, no longer mutually exclusive with anything. Sites passing `syncServers: { keyhive: X }` should pass `keyhive: { syncServer: X }` instead; `syncServers.subduction` still overrides the URL a named relay implies.
+
+- 5462610: Persist the Subduction signer so every context on an origin presents the same identity. The seed lives in the shared IndexedDB, so tabs and the automerge protocol handler worker adopt one signer instead of each minting a fresh `MemorySigner` on load. Generating it takes a Web Lock, so a cold profile opening two contexts at once still settles on one seed.
+
+  `@inkandswitch/patchwork-bootloader/signer` is a new export: `loadOrCreateSigner(storage)` returns the origin's `MemorySigner`, generating and storing a seed the first time.
+
+- Updated dependencies [5462610]
+- Updated dependencies [5462610]
+  - @inkandswitch/patchwork-bootloader@0.7.1
+
 ## 0.8.0
 
 ### Minor Changes

package/dist/repo.js

@@ -1,11 +1,11 @@
 import { initializeWasm, Repo } from "@automerge/vanillajs/slim";
 import { IndexedDBWorkerStorageAdapter } from "@automerge/automerge-repo-storage-indexeddb/IndexedDBWorkerStorageAdapter";
 import { siblingAdapters } from "@inkandswitch/patchwork-bootloader/siblings";
+import { loadOrCreateSigner } from "@inkandswitch/patchwork-bootloader/signer";
 import { initKeyhiveWasm, initializeAutomergeRepoKeyhive, } from "@automerge/automerge-repo-keyhive";
 // 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";
 import { keyhiveStorageName, storagePrefix, } from "@inkandswitch/patchwork-bootloader/storage";
 import debug from "debug";
 const log = debug("patchwork:setup:repo");
@@ -39,7 +39,11 @@ export async function createRepo() {
         log("setting up keyhive");
         initKeyhiveWasm();
         const { hive, repo } = await initializeAutomergeRepoKeyhive({
-            createRepo: (repoConfig) => new Repo(repoConfig),
+            // ARK injects an `idFactory` deriving document ids from keyhive. A site
+            // can opt out of it with `keyhive: { useIdFactory: false }`.
+            createRepo: ({ idFactory, ...repoConfig }) => new Repo(syncServer.useIdFactory === false
+                ? repoConfig
+                : { ...repoConfig, idFactory }),
             storage: new IndexedDBWorkerStorageAdapter(keyhiveStorageName),
             peerIdSuffix: storagePrefix + Math.random().toString(36).slice(2),
             automaticArchiveIngestion: true,
@@ -56,12 +60,14 @@ export async function createRepo() {
         log("keyhive setup complete");
         return { repo, hive };
     }
-    // The signer is explicit rather than the Repo's internal default so the
-    // identity the tab presents to the server can be shown on window.patchwork.
-    const signer = new MemorySigner();
+    // The signer is explicit rather than the Repo's internal default so that
+    // every tab on this origin signs as the same peer, and so the identity the
+    // tab presents to the server can be shown on window.patchwork.
+    const storage = new IndexedDBWorkerStorageAdapter();
+    const signer = await loadOrCreateSigner(storage);
     const repo = new Repo({
         signer,
-        storage: new IndexedDBWorkerStorageAdapter(),
+        storage,
         peerId: `${storagePrefix}-tab-${crypto.randomUUID()}`,
         subductionWebsocketEndpoints: [syncServer.url],
         subductionAdapters: siblingAdapters(),

package/dist/site-kit/index.d.ts

@@ -7,7 +7,7 @@
  * wires these into vite's plugin hooks (dev middleware, emitFile, virtual
  * modules, config()).
  */
-export type { PatchworkSiteOptions, PatchworkIconsOptions, PatchworkHtmlOptions, PatchworkNetlifyOptions, PatchworkKeyhiveSyncServer, PatchworkSyncServersOptions, } from "./options.js";
+export type { PatchworkSiteOptions, PatchworkIconsOptions, PatchworkHtmlOptions, PatchworkNetlifyOptions, PatchworkKeyhiveSyncServer, PatchworkKeyhiveOptions, PatchworkSyncServersOptions, } from "./options.js";
 export { resolveSyncServers, PRELOAD_WASM_ASSETS } from "./sync-servers.js";
 export { getIcons, ICON_SPECS, type IconSpec } from "./icons.js";
 export { buildHtml, escapeHtml } from "./html.js";

package/dist/site-kit/options.d.ts

@@ -31,20 +31,28 @@ export interface PatchworkNetlifyOptions {
     /** Cache-Control: immutable on /assets/*. Default true. */
     immutableAssets?: boolean;
 }
-type PatchworkPrimarySyncServerOptions = {
-    subduction?: string;
-    keyhive?: never;
-} | {
-    subduction?: never;
-    keyhive: PatchworkKeyhiveSyncServer;
-};
 export type PatchworkKeyhiveSyncServer = "keyhive" | "subduction" | ({
     url: string;
 } & SyncServerIdentity);
+export interface PatchworkKeyhiveOptions {
+    /**
+     * Which relay ARK registers and grants access to. Default `"subduction"`.
+     * A custom identity also carries the WebSocket URL to reach it on.
+     */
+    syncServer?: PatchworkKeyhiveSyncServer;
+    /**
+     * Use the `idFactory` ARK injects into the repo config, which derives
+     * document ids from keyhive. Default true. `false` drops it and lets the
+     * Repo generate ids its own way.
+     */
+    useIdFactory?: boolean;
+}
 export type PatchworkSyncServersOptions = {
     /** wss:// URL for the legacy automerge-repo sync-server channel (connected on demand via connectClassicSync). Default: wss://sync3.automerge.org. Pass false to skip its preconnect hint. */
     classic?: string | false;
-} & PatchworkPrimarySyncServerOptions;
+    /** wss:// URL for the subduction channel. Default: wss://subduction.sync.inkandswitch.com. Overrides the URL a named `keyhive.syncServer` would otherwise imply. */
+    subduction?: string;
+};
 export declare const DEFAULT_TITLE = "Patchwork";
 export interface PatchworkSiteOptions {
     /**
@@ -76,12 +84,14 @@ export interface PatchworkSiteOptions {
     /** manifest background_color */
     backgroundColor?: string;
     /**
-     * Sync-server configuration for this build. Providing `keyhive` enables
-     * keyhive and selects the relay identity ARK grants access to. Custom
-     * identities also require their WebSocket URL. `subduction` and `keyhive`
-     * are mutually exclusive. The live server and `classic` are also emitted as
-     * connection hints. Pass `false` to keep the default servers but skip those
-     * hints.
+     * Enables keyhive for this build. `true` takes every default; an object
+     * picks the relay and turns individual behaviour off. Omitted or `false`
+     * builds a plain subduction repo.
+     */
+    keyhive?: boolean | PatchworkKeyhiveOptions;
+    /**
+     * The sync-server URLs for this build. Also emitted as connection hints;
+     * pass `false` to keep the URLs but skip the hints.
      */
     syncServers?: false | PatchworkSyncServersOptions;
     icons?: false | PatchworkIconsOptions;
@@ -89,4 +99,3 @@ export interface PatchworkSiteOptions {
     manifest?: false | Record<string, unknown>;
     netlify?: false | PatchworkNetlifyOptions;
 }
-export {};

package/dist/site-kit/sync-servers.d.ts

@@ -8,6 +8,7 @@ export declare const DEFAULT_SYNC_SERVERS: {
 export declare function resolvePrimarySyncServer(options: PatchworkSiteOptions): {
     url: string;
     keyhive?: SyncServerSelection;
+    useIdFactory?: boolean;
 };
 /**
  * Resolves which sync-server origins are actually live for this build: the

package/dist/site-kit/sync-servers.js

@@ -9,23 +9,24 @@ export const DEFAULT_SYNC_SERVERS = {
     keyhive: "wss://keyhive.sync.automerge.org",
 };
 export function resolvePrimarySyncServer(options) {
-    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) {
     return wsUrl.replace(/^ws/, "http");

package/dist/vite/patches-plugin.d.ts

@@ -0,0 +1,2 @@
+import type { Plugin } from "vite";
+export declare function patches(): Plugin;

package/dist/vite/patches-plugin.js

@@ -0,0 +1,149 @@
+import { readFile } from "node:fs/promises";
+import { join } from "node:path";
+/**
+ * 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";
+const PATCHES = {
+    "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) {
+    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();
+async function assertVersion(root, file) {
+    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, file) {
+    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) {
+    const found = match(id);
+    if (!found)
+        return;
+    await assertVersion(found.root, found.file);
+    return apply(await readFile(id, "utf8"), found.file);
+}
+export function patches() {
+    const seen = new Set();
+    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) {
+                                    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/dist/vite/patchwork-plugin.d.ts

@@ -24,6 +24,7 @@ import type { PatchworkSiteOptions } from "../site-kit/options.js";
  */
 export default function patchwork(options?: PatchworkVitePluginOptions): Plugin<any>[];
 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";
@@ -43,7 +44,7 @@ export type ImportMap = {
     };
 };
 export type { PatchworkStaticSource } from "./static-plugin.js";
-export type { PatchworkSiteOptions, PatchworkIconsOptions, PatchworkHtmlOptions, PatchworkNetlifyOptions, PatchworkKeyhiveSyncServer, PatchworkSyncServersOptions, } from "../site-kit/options.js";
+export type { PatchworkSiteOptions, PatchworkIconsOptions, PatchworkHtmlOptions, PatchworkNetlifyOptions, PatchworkKeyhiveSyncServer, PatchworkKeyhiveOptions, PatchworkSyncServersOptions, } from "../site-kit/options.js";
 export interface PatchworkVitePluginOptions extends PatchworkSiteOptions {
     importmap?: ImportMap;
     /**

package/dist/vite/patchwork-plugin.js

@@ -1,4 +1,5 @@
 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";
@@ -38,6 +39,7 @@ export default function patchwork(options) {
         manifest(options),
         netlify(options),
         importmap(options),
+        patches(),
         serviceworker(),
         dev(options),
         statics(options),
@@ -45,6 +47,7 @@ export default function patchwork(options) {
     ].filter((plugin) => plugin != null);
 }
 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";

package/package.json

@@ -5,7 +5,7 @@
     "url": "git+https://github.com/inkandswitch/patchwork-system.git",
     "directory": "core/patchwork"
   },
-  "version": "0.8.0",
+  "version": "0.8.1",
   "author": "Ink & Switch",
   "type": "module",
   "license": "MIT",
@@ -83,11 +83,11 @@
     "esbuild": "^0.23.1",
     "sharp": "^0.35.3",
     "vite-plugin-wasm": "^3.6.0",
-    "@inkandswitch/patchwork-bootloader": "^0.7.0",
+    "@inkandswitch/patchwork-bootloader": "^0.7.1",
+    "@inkandswitch/patchwork-elements": "^6.0.2",
     "@inkandswitch/patchwork-filesystem": "^0.2.9",
     "@inkandswitch/patchwork-plugins": "^1.2.4",
-    "@inkandswitch/patchwork-providers": "^0.5.2",
-    "@inkandswitch/patchwork-elements": "^6.0.2"
+    "@inkandswitch/patchwork-providers": "^0.5.2"
   },
   "devDependencies": {
     "rollup": "^4.61.1",

package/src/repo.ts

@@ -1,6 +1,7 @@
 import { initializeWasm, Repo } from "@automerge/vanillajs/slim";
 import { IndexedDBWorkerStorageAdapter } from "@automerge/automerge-repo-storage-indexeddb/IndexedDBWorkerStorageAdapter";
 import { siblingAdapters } from "@inkandswitch/patchwork-bootloader/siblings";
+import { loadOrCreateSigner } from "@inkandswitch/patchwork-bootloader/signer";
 import * as AutomergeRepo from "@automerge/automerge-repo/slim";
 import {
   initKeyhiveWasm,
@@ -11,7 +12,6 @@ import {
 // 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";
 import {
   keyhiveStorageName,
   storagePrefix,
@@ -24,6 +24,7 @@ const log = debug("patchwork:setup:repo");
 declare const __SYNC_SERVER__: {
   url: string;
   keyhive?: SyncServerSelection;
+  useIdFactory?: boolean;
 };
 const syncServer =
   typeof __SYNC_SERVER__ !== "undefined"
@@ -64,7 +65,14 @@ export async function createRepo(): Promise<TabRepo> {
     log("setting up keyhive");
     initKeyhiveWasm();
     const { hive, repo } = await initializeAutomergeRepoKeyhive({
-      createRepo: (repoConfig) => new Repo(repoConfig),
+      // ARK injects an `idFactory` deriving document ids from keyhive. A site
+      // can opt out of it with `keyhive: { useIdFactory: false }`.
+      createRepo: ({ idFactory, ...repoConfig }) =>
+        new Repo(
+          syncServer.useIdFactory === false
+            ? repoConfig
+            : { ...repoConfig, idFactory }
+        ),
       storage: new IndexedDBWorkerStorageAdapter(keyhiveStorageName),
       peerIdSuffix: storagePrefix + Math.random().toString(36).slice(2),
       automaticArchiveIngestion: true,
@@ -82,12 +90,14 @@ export async function createRepo(): Promise<TabRepo> {
     return { repo, hive };
   }
 
-  // The signer is explicit rather than the Repo's internal default so the
-  // identity the tab presents to the server can be shown on window.patchwork.
-  const signer = new MemorySigner();
+  // The signer is explicit rather than the Repo's internal default so that
+  // every tab on this origin signs as the same peer, and so the identity the
+  // tab presents to the server can be shown on window.patchwork.
+  const storage = new IndexedDBWorkerStorageAdapter();
+  const signer = await loadOrCreateSigner(storage);
   const repo = new Repo({
     signer,
-    storage: new IndexedDBWorkerStorageAdapter(),
+    storage,
     peerId:
       `${storagePrefix}-tab-${crypto.randomUUID()}` as AutomergeRepo.PeerId,
     subductionWebsocketEndpoints: [syncServer.url],

package/src/site-kit/index.ts

@@ -13,6 +13,7 @@ export type {
   PatchworkHtmlOptions,
   PatchworkNetlifyOptions,
   PatchworkKeyhiveSyncServer,
+  PatchworkKeyhiveOptions,
   PatchworkSyncServersOptions,
 } from "./options.js";
 

package/src/site-kit/options.ts

@@ -36,19 +36,31 @@ export interface PatchworkNetlifyOptions {
   immutableAssets?: boolean;
 }
 
-type PatchworkPrimarySyncServerOptions =
-  | { subduction?: string; keyhive?: never }
-  | { subduction?: never; keyhive: PatchworkKeyhiveSyncServer };
-
 export type PatchworkKeyhiveSyncServer =
   | "keyhive"
   | "subduction"
   | ({ url: string } & SyncServerIdentity);
 
+export interface PatchworkKeyhiveOptions {
+  /**
+   * Which relay ARK registers and grants access to. Default `"subduction"`.
+   * A custom identity also carries the WebSocket URL to reach it on.
+   */
+  syncServer?: PatchworkKeyhiveSyncServer;
+  /**
+   * Use the `idFactory` ARK injects into the repo config, which derives
+   * document ids from keyhive. Default true. `false` drops it and lets the
+   * Repo generate ids its own way.
+   */
+  useIdFactory?: boolean;
+}
+
 export type PatchworkSyncServersOptions = {
   /** wss:// URL for the legacy automerge-repo sync-server channel (connected on demand via connectClassicSync). Default: wss://sync3.automerge.org. Pass false to skip its preconnect hint. */
   classic?: string | false;
-} & PatchworkPrimarySyncServerOptions;
+  /** wss:// URL for the subduction channel. Default: wss://subduction.sync.inkandswitch.com. Overrides the URL a named `keyhive.syncServer` would otherwise imply. */
+  subduction?: string;
+};
 
 export const DEFAULT_TITLE = "Patchwork";
 
@@ -81,12 +93,15 @@ export interface PatchworkSiteOptions {
   backgroundColor?: string;
 
   /**
-   * Sync-server configuration for this build. Providing `keyhive` enables
-   * keyhive and selects the relay identity ARK grants access to. Custom
-   * identities also require their WebSocket URL. `subduction` and `keyhive`
-   * are mutually exclusive. The live server and `classic` are also emitted as
-   * connection hints. Pass `false` to keep the default servers but skip those
-   * hints.
+   * Enables keyhive for this build. `true` takes every default; an object
+   * picks the relay and turns individual behaviour off. Omitted or `false`
+   * builds a plain subduction repo.
+   */
+  keyhive?: boolean | PatchworkKeyhiveOptions;
+
+  /**
+   * The sync-server URLs for this build. Also emitted as connection hints;
+   * pass `false` to keep the URLs but skip the hints.
    */
   syncServers?: false | PatchworkSyncServersOptions;
 

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

@@ -15,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/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";