@inkandswitch/patchwork-bootloader 0.0.4 → 0.0.5

package/dist/sw-logger.js

@@ -0,0 +1,366 @@
+/**
+ * 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);
+    }
+}

package/dist/types.d.ts

@@ -1,30 +1,3 @@
-export interface HandoffRequest {
-    url: string;
-    headers: Record<string, string>;
-    method: string;
-    destination: RequestDestination;
-    referrer: string;
-}
-export interface HandoffResponse {
-    body?: string | Uint8Array<ArrayBuffer> | ReadableStream;
-    /** defaults to 200 */
-    status?: number;
-    headers?: [string, string][] | Record<string, string>;
-    cache?: boolean;
-}
-export interface HandoffRequestMessage {
-    id: number;
-    type: "request";
-    /** the current name of the service worker cache */
-    cachename: string;
-    request: HandoffRequest;
-}
-export interface HandoffResponseMessage {
-    id: number;
-    type: "response";
-    response: HandoffResponse;
-}
-export type HandoffHandler = (href: string, request: HandoffRequest) => Promise<HandoffResponse | void | string | Uint8Array<ArrayBuffer>>;
 export type SetupServiceWorkerOptions = {
     /**
      * The public path to the service worker file.

package/dist/vite/importmap-plugin.js

@@ -1,3 +1,6 @@
+import { readFileSync } from "node:fs";
+import { createRequire } from "node:module";
+const require = createRequire(import.meta.url);
 /**
  * these dependencies will be built into the outdir,
  * and injected into the importmap
@@ -19,16 +22,28 @@ export function importmap(options) {
     return {
         name: "@patchwork/vite",
         async buildStart() {
-            if (this.environment.mode == "build") {
-                for (const [id, fileName] of Object.entries(builtins)) {
-                    this.emitFile({
-                        type: "chunk",
-                        fileName: fileName.slice(1),
-                        id,
-                        preserveSignature: "strict",
-                    });
-                }
+            for (const [id, fileName] of Object.entries(builtins)) {
+                this.emitFile({
+                    type: "chunk",
+                    fileName: fileName.slice(1),
+                    id,
+                    preserveSignature: "strict",
+                });
             }
+            // Emit automerge wasm so the service worker can fetch it
+            const wasmPath = require.resolve("@automerge/automerge/automerge.wasm");
+            this.emitFile({
+                type: "asset",
+                fileName: "automerge.wasm",
+                source: readFileSync(wasmPath),
+            });
+            // Emit subduction wasm so the service worker can fetch it
+            const subdWasmPath = require.resolve("@automerge/automerge-subduction/wasm");
+            this.emitFile({
+                type: "asset",
+                fileName: "subduction.wasm",
+                source: readFileSync(subdWasmPath),
+            });
         },
         resolveId(id) {
             if (id in importmap.imports && !(id in builtins)) {
@@ -37,21 +52,14 @@ export function importmap(options) {
         },
         transformIndexHtml: {
             order: "pre",
-            handler(html, ctx) {
-                const map = structuredClone(importmap);
-                if (ctx.server) {
-                    // serve builtins from dev server in dev mode
-                    for (const id of Object.keys(builtins)) {
-                        map.imports[id] = `/@id/${id}`;
-                    }
-                }
+            handler(html) {
                 return {
                     html,
                     tags: [
                         {
                             tag: "script",
                             attrs: { type: "importmap" },
-                            children: JSON.stringify(map, null, 2),
+                            children: JSON.stringify(importmap, null, 2),
                         },
                     ],
                 };

package/dist/vite/service-worker-plugin.d.ts

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

package/dist/vite/service-worker-plugin.js

@@ -1,38 +1,21 @@
-import { transformWithEsbuild } from "vite";
+import { builtins } from "./importmap-plugin.js";
 export function serviceworker() {
-    const moduleId = "service-worker.js";
-    const path = `/${moduleId}`;
-    const ids = [moduleId, path];
-    const serviceWorkerExport = "@inkandswitch/patchwork-bootloader/service-worker";
-    async function transform(resolve, fs) {
-        const exportPath = await resolve(serviceWorkerExport);
-        const file = await fs.readFile(exportPath.id, {
-            encoding: "utf8",
-        });
-        const transformation = await transformWithEsbuild(file, serviceWorkerExport, { format: "iife" });
-        return transformation;
-    }
+    let swEntryId;
     return {
-        name: "@patchwork/vite",
+        name: "@patchwork/service-worker",
+        enforce: "pre",
         async buildStart() {
-            if (this.environment.mode == "build") {
-                const trans = await transform(this.resolve.bind(this), this.fs);
-                this.emitFile({
-                    type: "prebuilt-chunk",
-                    fileName: path.slice(1),
-                    code: trans.code,
-                    map: trans.map,
-                });
-            }
-        },
-        resolveId(id) {
-            if (ids.includes(id)) {
-                return moduleId;
-            }
+            const resolved = await this.resolve("@inkandswitch/patchwork-bootloader/service-worker");
+            swEntryId = resolved.id;
+            this.emitFile({
+                type: "chunk",
+                id: resolved.id,
+                fileName: "service-worker.js",
+            });
         },
-        async load(id) {
-            if (ids.includes(id)) {
-                return transform(this.resolve.bind(this), this.fs);
+        resolveId(source, importer) {
+            if (importer && swEntryId && importer === swEntryId && source in builtins) {
+                return { id: builtins[source], external: true };
             }
         },
     };

package/package.json

@@ -1,12 +1,11 @@
 {
   "name": "@inkandswitch/patchwork-bootloader",
-  "version": "0.0.4",
+  "version": "0.0.5",
   "author": "chee",
   "type": "module",
   "license": "MIT",
   "devDependencies": {
-    "@automerge/automerge-repo-keyhive": "0.0.0-alpha.71",
-    "@keyhive/keyhive": "0.0.0-alpha.40",
+    "@automerge/automerge-repo-keyhive": "0.2.0-alpha.1d",
     "esbuild": "^0.23.1",
     "rollup": "^4.53.3"
   },
@@ -27,27 +26,41 @@
       "import": "./dist/service-worker.js",
       "types": "./dist/service-worker.d.ts"
     },
+    "./site": {
+      "import": "./dist/site.js",
+      "types": "./dist/site.d.ts"
+    },
     "./types": {
       "import": "./dist/types.js",
       "types": "./dist/types.d.ts"
+    },
+    "./sw-logger": {
+      "import": "./dist/sw-logger.js",
+      "types": "./dist/sw-logger.d.ts"
     }
   },
   "dependencies": {
-    "@automerge/automerge": "3.2.1",
-    "@automerge/automerge-repo": "2.5.0",
-    "@automerge/vanillajs": "2.5.0",
+    "@automerge/automerge": "3.2.5",
+    "@automerge/automerge-repo": "2.6.0-subduction.15",
+    "@automerge/automerge-subduction": "0.8.1",
+    "@automerge/automerge-repo-network-messagechannel": "2.6.0-subduction.15",
+    "@automerge/automerge-repo-network-websocket": "2.6.0-subduction.15",
+    "@automerge/automerge-repo-storage-indexeddb": "2.6.0-subduction.15",
+    "@automerge/vanillajs": "2.6.0-subduction.15",
     "@types/debug": "^4.1.12",
     "debug": "^4.4.3",
     "resolve.exports": "^2.0.3",
     "service-worker-types": "npm:@types/serviceworker@^0.0.153",
-    "tinyargs": "^0.1.4"
+    "tinyargs": "^0.1.4",
+    "@inkandswitch/patchwork-plugins": "^0.0.6",
+    "@inkandswitch/patchwork-elements": "^0.0.6",
+    "@inkandswitch/patchwork-filesystem": "^0.0.4"
   },
   "peerDependencies": {
-    "@automerge/automerge": "3.2.1",
-    "@automerge/automerge-repo": "2.5.0",
-    "@automerge/automerge-repo-keyhive": "0.0.0-alpha.71",
-    "@automerge/vanillajs": "2.5.0",
-    "@keyhive/keyhive": "0.0.0-alpha.40"
+    "@automerge/automerge": "3.2.5",
+    "@automerge/automerge-repo": "2.6.0-subduction.15",
+    "@automerge/automerge-repo-keyhive": "0.2.0-alpha.1d",
+    "@automerge/vanillajs": "2.6.0-subduction.15"
   },
   "scripts": {
     "build": "tsc",

package/src/externals.ts

@@ -7,6 +7,8 @@ const externals = [
   "@automerge/automerge-repo",
   "@automerge/automerge-repo/slim",
   "@automerge/automerge-repo-keyhive",
+  "@automerge/automerge-subduction",
+  "@automerge/automerge-subduction/slim",
   "@keyhive/keyhive",
   "@keyhive/keyhive/slim",
   "@inkandswitch/patchwork-bootloader",
@@ -17,5 +19,14 @@ const externals = [
   // sad
   "@codemirror/state",
   "@codemirror/view",
+  "@codemirror/language",
+
+  // rip
+  "solid-js",
+  "solid-js/html",
+  "solid-js/web",
+  "solid-js/h",
+  "solid-js/store",
+  "solid-js/jsx-runtime",
 ];
 export default externals;