@inkandswitch/patchwork-bootloader 0.2.5 → 0.2.7

package/src/types.ts

@@ -1,9 +1,103 @@
+/**
+ * The BroadcastChannel the service worker and the automerge shared worker
+ * use to hand requests off to each other. Broadcast (rather than a
+ * MessagePort handed from one to the other) so the two never need to be
+ * reintroduced when either of them restarts — and so tabs can listen in.
+ */
+export const HANDOFF_CHANNEL = "@patchwork/handoff";
+
+/**
+ * The special URL to resolve, plus enough of the {@link Request} the service
+ * worker is holding that the automerge worker can construct one that
+ * `cache.match`es it.
+ *
+ * Stale workers on either side of the channel can outlive a deploy, so the
+ * shape can only ever change additively: `url` must stay the http request
+ * URL old automerge workers decode the special URL out of, and new meaning
+ * goes in new fields old receivers ignore.
+ */
+export interface HandoffRequest {
+  /**
+   * The URL of the request the service worker is holding (the encoded
+   * `https://…/automerge%3Aabc/…` form) — the cache key.
+   */
+  url: string;
+  /** the decoded special URL, e.g. `automerge:abc/some/path` */
+  handoffURL: string;
+  /**
+   * @deprecated A briefly-deployed shape put the special URL in `url` and
+   * the cache key here. Only read, never sent.
+   */
+  cacheKey?: string;
+  headers: Record<string, string>;
+  method: string;
+  destination: RequestDestination;
+  referrer: string;
+}
+
+/**
+ * Service worker → automerge worker: please resolve this request and put
+ * the response in my cache.
+ */
+export interface HandoffRequestMessage {
+  id: string;
+  type: "request";
+  /** the current name of the service worker cache */
+  cachename: string;
+  request: HandoffRequest;
+}
+
+/**
+ * Automerge worker → service worker: the response is stored in the cache
+ * under the request you're holding. Serve `cache.match`.
+ */
+export interface HandoffCachedMessage {
+  id: string;
+  type: "cached";
+}
+
+/**
+ * An inline response for things that shouldn't be cached: errors, redirects
+ * &c.
+ */
+export interface HandoffResponse {
+  body?: string | Uint8Array<ArrayBuffer>;
+  /** defaults to 200 */
+  status?: number;
+  headers?: Record<string, string>;
+}
+
+/**
+ * Automerge worker → service worker: don't cache anything, serve this
+ * response directly.
+ */
+export interface HandoffResponseMessage {
+  id: string;
+  type: "response";
+  response: HandoffResponse;
+}
+
+export type HandoffReplyMessage = HandoffCachedMessage | HandoffResponseMessage;
+
+/**
+ * Automerge worker → world: broadcast once on startup so the service worker
+ * can re-send any handoff requests that raced the worker's boot.
+ */
+export interface HandoffOnlineMessage {
+  type: "online";
+}
+
 export type SetupServiceWorkerOptions = {
   /**
    * The public path to the service worker file.
    * Defaults to `/service-worker.js`
    */
   path?: string;
+  /**
+   * The public path to the automerge shared worker file.
+   * Defaults to `/automerge-worker.js`
+   */
+  workerPath?: string;
 };
 
 export type ServiceWorkerRepoChannelListener = (
@@ -11,7 +105,11 @@ export type ServiceWorkerRepoChannelListener = (
 ) => void | Promise<void>;
 
 export type SetupServiceWorkerResult = {
+  /** Open a classic Automerge sync WebSocket from the automerge worker. */
+  connectClassicSync: (server?: string) => Promise<void>;
   subscribeToRepoChannel: (
     listener: ServiceWorkerRepoChannelListener
   ) => Promise<() => void>;
+  /** Open a fresh repo sync port to the automerge worker (dev console). */
+  getRepoChannel: () => MessagePort;
 };

package/src/vite/importmap-plugin.ts

@@ -45,12 +45,22 @@ export function importmap(options?: PatchworkVitePluginOptions): Plugin {
         });
       }
 
-      // Emit automerge wasm so the service worker can fetch it
-      const wasmPath = require.resolve("@automerge/automerge/automerge.wasm");
+      // Emit automerge, keyhive, and subduction wasm so the service worker can fetch them
+      const automergeWasmPath = require.resolve(
+        "@automerge/automerge/automerge.wasm"
+      );
       this.emitFile({
         type: "asset",
         fileName: "automerge.wasm",
-        source: readFileSync(wasmPath),
+        source: readFileSync(automergeWasmPath),
+      });
+      const keyhiveWasmPath = require.resolve(
+        "@keyhive/keyhive/keyhive_wasm.wasm"
+      );
+      this.emitFile({
+        type: "asset",
+        fileName: "keyhive_wasm.wasm",
+        source: readFileSync(keyhiveWasmPath),
       });
 
       // Emit subduction wasm so the service worker can fetch it

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

@@ -1,25 +1,40 @@
 import type { Plugin } from "vite";
 import { builtins } from "./importmap-plugin.js";
 
+// The service worker and the automerge shared worker are emitted as their
+// own chunks. Their heavy imports are marked external and resolved to
+// /packages/... URLs (both workers are created with type:"module", so the
+// browser fetches those as regular network requests).
+const workers = [
+  {
+    specifier: "@inkandswitch/patchwork-bootloader/service-worker",
+    fileName: "service-worker.js",
+  },
+  {
+    specifier: "@inkandswitch/patchwork-bootloader/automerge-worker",
+    fileName: "automerge-worker.js",
+  },
+];
+
 export function serviceworker(): Plugin {
-  let swEntryId: string | undefined;
+  const entryIds = new Set<string>();
 
   return {
     name: "@patchwork/service-worker",
     enforce: "pre",
     async buildStart() {
-      const resolved = await this.resolve(
-        "@inkandswitch/patchwork-bootloader/service-worker"
-      );
-      swEntryId = resolved!.id;
-      this.emitFile({
-        type: "chunk",
-        id: resolved!.id,
-        fileName: "service-worker.js",
-      });
+      for (const { specifier, fileName } of workers) {
+        const resolved = await this.resolve(specifier);
+        entryIds.add(resolved!.id);
+        this.emitFile({
+          type: "chunk",
+          id: resolved!.id,
+          fileName,
+        });
+      }
     },
     resolveId(source, importer) {
-      if (importer && swEntryId && importer === swEntryId && source in builtins) {
+      if (importer && entryIds.has(importer) && source in builtins) {
         return { id: builtins[source], external: true };
       }
     },

package/tsconfig.json

@@ -9,5 +9,5 @@
     "skipLibCheck": true,
     "isolatedModules": true
   },
-  "include": ["src", "../../sites/tiny-patchwork/shared-worker.ts"]
+  "include": ["src"]
 }

package/dist/sw-logger.d.ts

@@ -1,105 +0,0 @@
-/**
- * Persistent ring-buffer logger for service workers.
- *
- * Stores log entries in a dedicated IndexedDB database (`sw-logs`) that is
- * completely separate from the `automerge` database used by the Repo, so
- * writes here never contend with storage or hydration transactions.
- *
- * Entries are accumulated in memory and batch-flushed to IDB periodically
- * (every {@link FLUSH_INTERVAL_MS}) or when the buffer reaches
- * {@link FLUSH_THRESHOLD} entries — whichever comes first.
- *
- * The on-disk store is a ring buffer capped at {@link MAX_ENTRIES}. Oldest
- * entries are pruned on each flush when the cap is exceeded.
- *
- * ## Usage
- *
- * ```ts
- * import { SwLogger } from "./sw-logger.js"
- *
- * const log = await SwLogger.open()
- * log.info("repo initialized")
- * log.warn("connection dropped", { url })
- * log.error("sync threw", error)
- *
- * // From the SW inspector console:
- * self.printLogs()         // prints last 200 entries
- * self.printLogs(5000)     // prints last 5 000 entries
- * self.tailLogs(100)       // returns last 100 entries as an array
- * self.exportLogs()        // returns all entries as JSON string
- * self.clearLogs()         // wipes the log database
- * ```
- */
-export interface LogEntry {
-    /** Auto-incremented IDB key (doubles as ordering index). */
-    id?: number;
-    /** ISO-8601 timestamp */
-    ts: string;
-    /** Monotonic high-res timestamp (ms since SW start) */
-    hrt: number;
-    /** Log level */
-    level: "debug" | "info" | "warn" | "error";
-    /** Log message */
-    msg: string;
-    /** Optional structured data (must be cloneable) */
-    data?: unknown;
-}
-export interface SwLoggerInterface {
-    debug(msg: string, data?: unknown): void;
-    info(msg: string, data?: unknown): void;
-    warn(msg: string, data?: unknown): void;
-    error(msg: string, data?: unknown): void;
-    flush(): Promise<void>;
-    tail(n?: number): Promise<LogEntry[]>;
-    exportAll(): Promise<string>;
-    clear(): Promise<void>;
-    dispose(): void;
-}
-export declare class SwLogger implements SwLoggerInterface {
-    #private;
-    private constructor();
-    /**
-     * Open (or create) the log database and return a ready logger.
-     * If the database cannot be opened (quota, permissions, etc.),
-     * returns a {@link NoopLogger} that writes to the console only.
-     */
-    static open(): Promise<SwLoggerInterface>;
-    debug(msg: string, data?: unknown): void;
-    info(msg: string, data?: unknown): void;
-    warn(msg: string, data?: unknown): void;
-    error(msg: string, data?: unknown): void;
-    /** Force an immediate flush of the in-memory buffer to IDB. */
-    flush(): Promise<void>;
-    /** Read the last `n` entries (default 200). */
-    tail(n?: number): Promise<LogEntry[]>;
-    /** Return all entries as a JSON string (for copy-paste from console). */
-    exportAll(): Promise<string>;
-    /** Delete all log entries. */
-    clear(): Promise<void>;
-    /** Stop the periodic flush timer. */
-    dispose(): void;
-}
-/**
- * Read-only accessor for the SW log database.
- *
- * Unlike {@link SwLogger}, this class does not hold a persistent IDB
- * connection — each method opens a fresh connection and closes it after
- * use. This avoids interfering with the SW's write transactions.
- *
- * @example
- * ```ts
- * import { SwLogReader } from "@inkandswitch/patchwork-bootloader/sw-logger"
- *
- * const last100 = await SwLogReader.tail(100)
- * const json    = await SwLogReader.exportAll()
- * await SwLogReader.clear()
- * ```
- */
-export declare class SwLogReader {
-    /** Read the last `n` entries (default 200), oldest-first. */
-    static tail(n?: number): Promise<LogEntry[]>;
-    /** Return all entries as a JSON string. */
-    static exportAll(): Promise<string>;
-    /** Delete all log entries. */
-    static clear(): Promise<void>;
-}

package/dist/sw-logger.js

@@ -1,366 +0,0 @@
-/**
- * Persistent ring-buffer logger for service workers.
- *
- * Stores log entries in a dedicated IndexedDB database (`sw-logs`) that is
- * completely separate from the `automerge` database used by the Repo, so
- * writes here never contend with storage or hydration transactions.
- *
- * Entries are accumulated in memory and batch-flushed to IDB periodically
- * (every {@link FLUSH_INTERVAL_MS}) or when the buffer reaches
- * {@link FLUSH_THRESHOLD} entries — whichever comes first.
- *
- * The on-disk store is a ring buffer capped at {@link MAX_ENTRIES}. Oldest
- * entries are pruned on each flush when the cap is exceeded.
- *
- * ## Usage
- *
- * ```ts
- * import { SwLogger } from "./sw-logger.js"
- *
- * const log = await SwLogger.open()
- * log.info("repo initialized")
- * log.warn("connection dropped", { url })
- * log.error("sync threw", error)
- *
- * // From the SW inspector console:
- * self.printLogs()         // prints last 200 entries
- * self.printLogs(5000)     // prints last 5 000 entries
- * self.tailLogs(100)       // returns last 100 entries as an array
- * self.exportLogs()        // returns all entries as JSON string
- * self.clearLogs()         // wipes the log database
- * ```
- */
-// ── Configuration ───────────────────────────────────────────────────────
-const DB_NAME = "sw-logs";
-const DB_VERSION = 1;
-const STORE_NAME = "entries";
-const MAX_ENTRIES = 50_000;
-const FLUSH_INTERVAL_MS = 1_000;
-const FLUSH_THRESHOLD = 128;
-// ── Console method lookup ───────────────────────────────────────────────
-const consoleMethods = {
-    debug: console.debug.bind(console),
-    info: console.info.bind(console),
-    warn: console.warn.bind(console),
-    error: console.error.bind(console),
-};
-// ── No-op fallback (used when IDB is unavailable) ───────────────────────
-class NoopLogger {
-    debug(msg, data) {
-        consoleMethods.debug(`[sw:debug]`, msg, ...(data !== undefined ? [data] : []));
-    }
-    info(msg, data) {
-        consoleMethods.info(`[sw:info]`, msg, ...(data !== undefined ? [data] : []));
-    }
-    warn(msg, data) {
-        consoleMethods.warn(`[sw:warn]`, msg, ...(data !== undefined ? [data] : []));
-    }
-    error(msg, data) {
-        consoleMethods.error(`[sw:error]`, msg, ...(data !== undefined ? [data] : []));
-    }
-    async flush() { }
-    async tail() {
-        return [];
-    }
-    async exportAll() {
-        return "[]";
-    }
-    async clear() { }
-    dispose() { }
-}
-// ── Implementation ──────────────────────────────────────────────────────
-export class SwLogger {
-    #db;
-    #buffer = [];
-    #flushTimer = null;
-    constructor(db) {
-        this.#db = db;
-        this.#flushTimer = setInterval(() => this.flush(), FLUSH_INTERVAL_MS);
-    }
-    /**
-     * Open (or create) the log database and return a ready logger.
-     * If the database cannot be opened (quota, permissions, etc.),
-     * returns a {@link NoopLogger} that writes to the console only.
-     */
-    static async open() {
-        try {
-            const db = await new Promise((resolve, reject) => {
-                const req = indexedDB.open(DB_NAME, DB_VERSION);
-                req.onupgradeneeded = () => {
-                    const db = req.result;
-                    if (!db.objectStoreNames.contains(STORE_NAME)) {
-                        db.createObjectStore(STORE_NAME, {
-                            keyPath: "id",
-                            autoIncrement: true,
-                        });
-                    }
-                };
-                req.onsuccess = () => resolve(req.result);
-                req.onerror = () => reject(req.error);
-            });
-            return new SwLogger(db);
-        }
-        catch (e) {
-            console.warn("[sw-logger] failed to open IDB, falling back to console-only:", e);
-            return new NoopLogger();
-        }
-    }
-    // ── Public API ──────────────────────────────────────────────────────
-    debug(msg, data) {
-        this.#append("debug", msg, data);
-    }
-    info(msg, data) {
-        this.#append("info", msg, data);
-    }
-    warn(msg, data) {
-        this.#append("warn", msg, data);
-    }
-    error(msg, data) {
-        this.#append("error", msg, data);
-    }
-    /** Force an immediate flush of the in-memory buffer to IDB. */
-    async flush() {
-        if (this.#buffer.length === 0)
-            return;
-        const batch = this.#buffer.splice(0);
-        try {
-            const tx = this.#db.transaction(STORE_NAME, "readwrite");
-            const store = tx.objectStore(STORE_NAME);
-            for (const entry of batch) {
-                store.add(entry);
-            }
-            await txComplete(tx);
-        }
-        catch (e) {
-            // If the write fails, put the entries back so the next flush retries.
-            this.#buffer.unshift(...batch);
-            console.warn("[sw-logger] flush failed:", e);
-            return;
-        }
-        try {
-            await this.#prune();
-        }
-        catch (e) {
-            // Prune failures are non-fatal — entries are already committed.
-            console.warn("[sw-logger] prune failed:", e);
-        }
-    }
-    /** Read the last `n` entries (default 200). */
-    async tail(n = 200) {
-        // Flush pending entries first so the tail is up to date.
-        await this.flush();
-        const tx = this.#db.transaction(STORE_NAME, "readonly");
-        const store = tx.objectStore(STORE_NAME);
-        return new Promise((resolve, reject) => {
-            const entries = [];
-            const req = store.openCursor(null, "prev");
-            req.onsuccess = () => {
-                const cursor = req.result;
-                if (cursor && entries.length < n) {
-                    entries.push(cursor.value);
-                    cursor.continue();
-                }
-                else {
-                    resolve(entries.reverse());
-                }
-            };
-            req.onerror = () => reject(req.error);
-        });
-    }
-    /** Return all entries as a JSON string (for copy-paste from console). */
-    async exportAll() {
-        await this.flush();
-        const tx = this.#db.transaction(STORE_NAME, "readonly");
-        const store = tx.objectStore(STORE_NAME);
-        return new Promise((resolve, reject) => {
-            const req = store.getAll();
-            req.onsuccess = () => resolve(JSON.stringify(req.result, null, 2));
-            req.onerror = () => reject(req.error);
-        });
-    }
-    /** Delete all log entries. */
-    async clear() {
-        const tx = this.#db.transaction(STORE_NAME, "readwrite");
-        tx.objectStore(STORE_NAME).clear();
-        await txComplete(tx);
-    }
-    /** Stop the periodic flush timer. */
-    dispose() {
-        if (this.#flushTimer) {
-            clearInterval(this.#flushTimer);
-            this.#flushTimer = null;
-        }
-    }
-    // ── Internals ─────────────────────────────────────────────────────
-    #append(level, msg, data) {
-        this.#buffer.push({
-            ts: new Date().toISOString(),
-            hrt: performance.now(),
-            level,
-            msg,
-            data: data !== undefined ? safeClone(data) : undefined,
-        });
-        // Mirror to console using the appropriate severity method.
-        const log = consoleMethods[level];
-        const tag = `[sw:${level}]`;
-        if (data !== undefined) {
-            log(tag, msg, data);
-        }
-        else {
-            log(tag, msg);
-        }
-        if (this.#buffer.length >= FLUSH_THRESHOLD) {
-            this.flush();
-        }
-    }
-    async #prune() {
-        // Count in a separate readonly transaction to avoid
-        // TransactionInactiveError from awaiting within a single transaction.
-        const count = await new Promise((resolve, reject) => {
-            const tx = this.#db.transaction(STORE_NAME, "readonly");
-            const store = tx.objectStore(STORE_NAME);
-            const req = store.count();
-            req.onsuccess = () => resolve(req.result);
-            req.onerror = () => reject(req.error);
-            tx.onabort = () => reject(tx.error ?? new Error("sw-logs count transaction aborted"));
-        });
-        if (count <= MAX_ENTRIES)
-            return;
-        // Delete the oldest entries in a separate readwrite transaction.
-        const excess = count - MAX_ENTRIES;
-        await new Promise((resolve, reject) => {
-            const tx = this.#db.transaction(STORE_NAME, "readwrite");
-            const store = tx.objectStore(STORE_NAME);
-            let deleted = 0;
-            const req = store.openCursor();
-            req.onsuccess = () => {
-                const cursor = req.result;
-                if (cursor && deleted < excess) {
-                    cursor.delete();
-                    deleted++;
-                    cursor.continue();
-                }
-            };
-            req.onerror = () => reject(req.error);
-            tx.oncomplete = () => resolve();
-            tx.onabort = () => reject(tx.error ?? new Error("sw-logs prune transaction aborted"));
-        });
-    }
-}
-// ── Helpers ──────────────────────────────────────────────────────────────
-function txComplete(tx) {
-    return new Promise((resolve, reject) => {
-        tx.oncomplete = () => resolve();
-        tx.onerror = () => reject(tx.error);
-        tx.onabort = () => reject(tx.error ?? new Error("transaction aborted"));
-    });
-}
-// ── Read-only access (usable from any context, including main thread) ───
-/**
- * Read-only accessor for the SW log database.
- *
- * Unlike {@link SwLogger}, this class does not hold a persistent IDB
- * connection — each method opens a fresh connection and closes it after
- * use. This avoids interfering with the SW's write transactions.
- *
- * @example
- * ```ts
- * import { SwLogReader } from "@inkandswitch/patchwork-bootloader/sw-logger"
- *
- * const last100 = await SwLogReader.tail(100)
- * const json    = await SwLogReader.exportAll()
- * await SwLogReader.clear()
- * ```
- */
-export class SwLogReader {
-    /** Read the last `n` entries (default 200), oldest-first. */
-    static async tail(n = 200) {
-        const db = await openDb();
-        try {
-            const tx = db.transaction(STORE_NAME, "readonly");
-            const store = tx.objectStore(STORE_NAME);
-            return await new Promise((resolve, reject) => {
-                const entries = [];
-                const req = store.openCursor(null, "prev");
-                req.onsuccess = () => {
-                    const cursor = req.result;
-                    if (cursor && entries.length < n) {
-                        entries.push(cursor.value);
-                        cursor.continue();
-                    }
-                    else {
-                        resolve(entries.reverse());
-                    }
-                };
-                req.onerror = () => reject(req.error);
-            });
-        }
-        finally {
-            db.close();
-        }
-    }
-    /** Return all entries as a JSON string. */
-    static async exportAll() {
-        const db = await openDb();
-        try {
-            const tx = db.transaction(STORE_NAME, "readonly");
-            const store = tx.objectStore(STORE_NAME);
-            return await new Promise((resolve, reject) => {
-                const req = store.getAll();
-                req.onsuccess = () => resolve(JSON.stringify(req.result, null, 2));
-                req.onerror = () => reject(req.error);
-            });
-        }
-        finally {
-            db.close();
-        }
-    }
-    /** Delete all log entries. */
-    static async clear() {
-        const db = await openDb();
-        try {
-            const tx = db.transaction(STORE_NAME, "readwrite");
-            tx.objectStore(STORE_NAME).clear();
-            await txComplete(tx);
-        }
-        finally {
-            db.close();
-        }
-    }
-}
-/** Open a short-lived connection to the log database. */
-function openDb() {
-    return new Promise((resolve, reject) => {
-        const req = indexedDB.open(DB_NAME, DB_VERSION);
-        req.onupgradeneeded = () => {
-            const db = req.result;
-            if (!db.objectStoreNames.contains(STORE_NAME)) {
-                db.createObjectStore(STORE_NAME, {
-                    keyPath: "id",
-                    autoIncrement: true,
-                });
-            }
-        };
-        req.onsuccess = () => resolve(req.result);
-        req.onerror = () => reject(req.error);
-    });
-}
-/** Best-effort structured clone for the `data` field. Falls back to string. */
-function safeClone(value) {
-    if (value === null || value === undefined)
-        return value;
-    if (typeof value === "string" ||
-        typeof value === "number" ||
-        typeof value === "boolean") {
-        return value;
-    }
-    if (value instanceof Error) {
-        return { name: value.name, message: value.message, stack: value.stack };
-    }
-    try {
-        return structuredClone(value);
-    }
-    catch {
-        return String(value);
-    }
-}