@evolu/nodejs 3.0.0-next.2 → 3.0.0-next.3

package/dist/src/Sqlite.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Sqlite.d.ts","sourceRoot":"","sources":["../../src/Sqlite.ts"],"names":[],"mappings":"AAAA,OAAO,EAIL,KAAK,kBAAkB,EAGxB,MAAM,eAAe,CAAC;AAGvB,eAAO,MAAM,wBAAwB,EAAE,kBAiDpC,CAAC"}
+{"version":3,"file":"Sqlite.d.ts","sourceRoot":"","sources":["../../src/Sqlite.ts"],"names":[],"mappings":"AAAA,OAAO,EAIL,KAAK,kBAAkB,EAExB,MAAM,eAAe,CAAC;AAIvB,eAAO,MAAM,wBAAwB,EAAE,kBAoEpC,CAAC"}

package/dist/src/Sqlite.js

@@ -1,38 +1,128 @@
+var __addDisposableResource = (this && this.__addDisposableResource) || function (env, value, async) {
+    if (value !== null && value !== void 0) {
+        if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
+        var dispose, inner;
+        if (async) {
+            if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
+            dispose = value[Symbol.asyncDispose];
+        }
+        if (dispose === void 0) {
+            if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
+            dispose = value[Symbol.dispose];
+            if (async) inner = dispose;
+        }
+        if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
+        if (inner) dispose = function() { try { inner.call(this); } catch (e) { return Promise.reject(e); } };
+        env.stack.push({ value: value, dispose: dispose, async: async });
+    }
+    else if (async) {
+        env.stack.push({ async: true });
+    }
+    return value;
+};
+var __disposeResources = (this && this.__disposeResources) || (function (SuppressedError) {
+    return function (env) {
+        function fail(e) {
+            env.error = env.hasError ? new SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
+            env.hasError = true;
+        }
+        var r, s = 0;
+        function next() {
+            while (r = env.stack.pop()) {
+                try {
+                    if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
+                    if (r.dispose) {
+                        var result = r.dispose.call(r.value);
+                        if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) { fail(e); return next(); });
+                    }
+                    else s |= 1;
+                }
+                catch (e) {
+                    fail(e);
+                }
+            }
+            if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
+            if (env.hasError) throw env.error;
+        }
+        return next();
+    };
+})(typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+});
 import { createPreparedStatementsCache, lazyVoid, ok, } from "@evolu/common";
 import BetterSQLite, {} from "better-sqlite3";
+import { rmSync } from "fs";
 export const createBetterSqliteDriver = (name, options) => () => {
-    const filename = options?.mode === "memory" ? ":memory:" : `${name}.db`;
-    const stack = new globalThis.DisposableStack();
-    const db = stack.adopt(new BetterSQLite(filename), (db) => {
-        db.close();
-    });
-    const cache = stack.use(createPreparedStatementsCache((sql) => db.prepare(sql), 
-    // Not needed.
-    // https://github.com/WiseLibs/better-sqlite3/blob/master/docs/api.md#class-statement
-    lazyVoid));
-    const driver = {
-        exec: (query) => {
-            // Always prepare is recommended for better-sqlite3
-            const prepared = cache.get(query, true);
-            if (prepared.reader) {
-                const rows = prepared.all(query.parameters);
-                return { rows, changes: 0 };
-            }
-            const changes = prepared.run(query.parameters).changes;
-            return { rows: [], changes };
-        },
-        export: () => {
-            const file = db.serialize();
-            const { buffer } = file;
-            if (buffer instanceof ArrayBuffer) {
-                return new Uint8Array(buffer, file.byteOffset, file.byteLength);
-            }
-            // Ensure export uses transferable ArrayBuffer backing.
-            return new Uint8Array(file);
-        },
-        [Symbol.dispose]: () => {
-            stack.dispose();
-        },
-    };
-    return ok(driver);
+    const env_1 = { stack: [], error: void 0, hasError: false };
+    try {
+        const filename = options?.mode === "memory" ? ":memory:" : `${name}.db`;
+        const filenamesToDelete = options?.mode === "memory"
+            ? []
+            : [
+                filename,
+                `${filename}-shm`,
+                `${filename}-wal`,
+                `${filename}-journal`,
+            ];
+        const disposer = __addDisposableResource(env_1, new DisposableStack(), false);
+        const db = disposer.adopt(new BetterSQLite(filename), (db) => {
+            db.close();
+        });
+        const cache = disposer.use(createPreparedStatementsCache((sql) => db.prepare(sql), 
+        // Not needed.
+        // https://github.com/WiseLibs/better-sqlite3/blob/master/docs/api.md#class-statement
+        lazyVoid));
+        const disposables = disposer.move();
+        return ok({
+            exec: (query) => {
+                // Always prepare is recommended for better-sqlite3
+                const prepared = cache.get(query, true);
+                if (prepared.reader) {
+                    const rows = prepared.all(query.parameters);
+                    return { rows, changes: 0 };
+                }
+                const changes = prepared.run(query.parameters).changes;
+                return { rows: [], changes };
+            },
+            export: () => {
+                const file = db.serialize();
+                const { buffer } = file;
+                if (buffer instanceof ArrayBuffer) {
+                    return new Uint8Array(buffer, file.byteOffset, file.byteLength);
+                }
+                // Ensure export uses transferable ArrayBuffer backing.
+                return new Uint8Array(file);
+            },
+            deleteDatabase: () => {
+                const env_2 = { stack: [], error: void 0, hasError: false };
+                try {
+                    const deleteDisposer = __addDisposableResource(env_2, new DisposableStack(), false);
+                    for (const filename of filenamesToDelete) {
+                        deleteDisposer.defer(() => {
+                            rmSync(filename, { force: true });
+                        });
+                    }
+                    deleteDisposer.use(disposables);
+                }
+                catch (e_2) {
+                    env_2.error = e_2;
+                    env_2.hasError = true;
+                }
+                finally {
+                    __disposeResources(env_2);
+                }
+            },
+            [Symbol.dispose]: () => {
+                disposables.dispose();
+            },
+        });
+    }
+    catch (e_1) {
+        env_1.error = e_1;
+        env_1.hasError = true;
+    }
+    finally {
+        __disposeResources(env_1);
+    }
 };

package/dist/src/Task.d.ts

@@ -3,7 +3,7 @@
  *
  * @module
  */
-import { type CreateRun, type RunDeps } from "@evolu/common";
+import { type CreateRun, type RunDefaultDeps } from "@evolu/common";
 /**
  * A promise that resolves when a termination signal is received.
  *
@@ -32,14 +32,14 @@ export interface ShutdownDep {
  * const deps = { ...createRelayDeps(), console };
  *
  * await using run = createRun(deps);
- * await using stack = new AsyncDisposableStack();
+ * await using disposer = new AsyncDisposableStack();
  *
- * stack.use(await run.orThrow(startRelay({ port: 4000 })));
+ * disposer.use(await run.orThrow(startRelay({ port: 4000 })));
  *
  * await run.deps.shutdown;
  * ```
  *
  * @group Node.js Run
  */
-export declare const createRun: CreateRun<RunDeps & ShutdownDep>;
+export declare const createRun: CreateRun<RunDefaultDeps & ShutdownDep>;
 //# sourceMappingURL=Task.d.ts.map

package/dist/src/Task.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Task.d.ts","sourceRoot":"","sources":["../../src/Task.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAGL,KAAK,SAAS,EAEd,KAAK,OAAO,EACb,MAAM,eAAe,CAAC;AAEvB;;;;;;;;GAQG;AACH,MAAM,MAAM,QAAQ,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;AAErC,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,QAAQ,EAAE,QAAQ,CAAC;CAC7B;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,eAAO,MAAM,SAAS,EAAE,SAAS,CAAC,OAAO,GAAG,WAAW,CAuCtD,CAAC"}
+{"version":3,"file":"Task.d.ts","sourceRoot":"","sources":["../../src/Task.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAGL,KAAK,SAAS,EAEd,KAAK,cAAc,EACpB,MAAM,eAAe,CAAC;AAEvB;;;;;;;;GAQG;AACH,MAAM,MAAM,QAAQ,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;AAErC,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,QAAQ,EAAE,QAAQ,CAAC;CAC7B;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,eAAO,MAAM,SAAS,EAAE,SAAS,CAAC,cAAc,GAAG,WAAW,CAuC7D,CAAC"}

package/dist/src/Task.js

@@ -19,9 +19,9 @@ import { createRun as createCommonRun, createUnknownError, } from "@evolu/common
  * const deps = { ...createRelayDeps(), console };
  *
  * await using run = createRun(deps);
- * await using stack = new AsyncDisposableStack();
+ * await using disposer = new AsyncDisposableStack();
  *
- * stack.use(await run.orThrow(startRelay({ port: 4000 })));
+ * disposer.use(await run.orThrow(startRelay({ port: 4000 })));
  *
  * await run.deps.shutdown;
  * ```

package/dist/src/Worker.d.ts

@@ -1,2 +1,4 @@
-export {};
+import type { CreateBroadcastChannel } from "@evolu/common";
+/** Creates a {@link BroadcastChannel} from a Node.js BroadcastChannel. */
+export declare const createBroadcastChannel: CreateBroadcastChannel;
 //# sourceMappingURL=Worker.d.ts.map

package/dist/src/Worker.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Worker.d.ts","sourceRoot":"","sources":["../../src/Worker.ts"],"names":[],"mappings":""}
+{"version":3,"file":"Worker.d.ts","sourceRoot":"","sources":["../../src/Worker.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAoB,sBAAsB,EAAE,MAAM,eAAe,CAAC;AAG9E,0EAA0E;AAC1E,eAAO,MAAM,sBAAsB,EAAE,sBAoCpC,CAAC"}

package/dist/src/Worker.js

@@ -1,4 +1,97 @@
-export {};
+var __addDisposableResource = (this && this.__addDisposableResource) || function (env, value, async) {
+    if (value !== null && value !== void 0) {
+        if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
+        var dispose, inner;
+        if (async) {
+            if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
+            dispose = value[Symbol.asyncDispose];
+        }
+        if (dispose === void 0) {
+            if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
+            dispose = value[Symbol.dispose];
+            if (async) inner = dispose;
+        }
+        if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
+        if (inner) dispose = function() { try { inner.call(this); } catch (e) { return Promise.reject(e); } };
+        env.stack.push({ value: value, dispose: dispose, async: async });
+    }
+    else if (async) {
+        env.stack.push({ async: true });
+    }
+    return value;
+};
+var __disposeResources = (this && this.__disposeResources) || (function (SuppressedError) {
+    return function (env) {
+        function fail(e) {
+            env.error = env.hasError ? new SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
+            env.hasError = true;
+        }
+        var r, s = 0;
+        function next() {
+            while (r = env.stack.pop()) {
+                try {
+                    if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
+                    if (r.dispose) {
+                        var result = r.dispose.call(r.value);
+                        if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) { fail(e); return next(); });
+                    }
+                    else s |= 1;
+                }
+                catch (e) {
+                    fail(e);
+                }
+            }
+            if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
+            if (env.hasError) throw env.error;
+        }
+        return next();
+    };
+})(typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+});
+import { assertNotDisposed } from "@evolu/common";
+/** Creates a {@link BroadcastChannel} from a Node.js BroadcastChannel. */
+export const createBroadcastChannel = (name) => {
+    const env_1 = { stack: [], error: void 0, hasError: false };
+    try {
+        const nativeBroadcastChannel = new globalThis.BroadcastChannel(name);
+        const disposer = __addDisposableResource(env_1, new DisposableStack(), false);
+        disposer.defer(() => {
+            nativeBroadcastChannel.onmessage = null;
+            nativeBroadcastChannel.close();
+        });
+        const disposables = disposer.move();
+        let onMessageHandler = null;
+        return {
+            postMessage: (message) => {
+                assertNotDisposed(disposables);
+                nativeBroadcastChannel.postMessage(message);
+            },
+            get onMessage() {
+                return disposables.disposed ? null : onMessageHandler;
+            },
+            set onMessage(fn) {
+                if (disposables.disposed)
+                    return;
+                onMessageHandler = fn;
+                nativeBroadcastChannel.onmessage = fn
+                    ? (event) => {
+                        fn(event.data);
+                    }
+                    : null;
+            },
+            [Symbol.dispose]: () => disposables.dispose(),
+        };
+    }
+    catch (e_1) {
+        env_1.error = e_1;
+        env_1.hasError = true;
+    }
+    finally {
+        __disposeResources(env_1);
+    }
+};
 // TODO: Implement Node.js Worker API
 //
 // This module should provide Node.js implementations of the common Worker API:

package/dist/src/index.d.ts

@@ -3,4 +3,5 @@ export * from "./Crypto.js";
 export * from "./local-first/Relay.js";
 export * from "./Task.js";
 export * from "./WebSocket.js";
+export * from "./Worker.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/src/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,aAAa,CAAC;AAC5B,cAAc,aAAa,CAAC;AAC5B,cAAc,wBAAwB,CAAC;AACvC,cAAc,WAAW,CAAC;AAC1B,cAAc,gBAAgB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,aAAa,CAAC;AAC5B,cAAc,aAAa,CAAC;AAC5B,cAAc,wBAAwB,CAAC;AACvC,cAAc,WAAW,CAAC;AAC1B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,aAAa,CAAC"}

package/dist/src/index.js

@@ -3,3 +3,4 @@ export * from "./Crypto.js";
 export * from "./local-first/Relay.js";
 export * from "./Task.js";
 export * from "./WebSocket.js";
+export * from "./Worker.js";

package/dist/src/local-first/Relay.d.ts

@@ -30,9 +30,9 @@ export declare const createRelayDeps: () => RelayDeps;
  * const deps = { ...createRelayDeps(), console };
  *
  * await using run = createRun(deps);
- * await using stack = new AsyncDisposableStack();
+ * await using disposer = new AsyncDisposableStack();
  *
- * stack.use(
+ * disposer.use(
  *   await run.orThrow(
  *     startRelay({
  *       port: 4000,

package/dist/src/local-first/Relay.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Relay.d.ts","sourceRoot":"","sources":["../../../src/local-first/Relay.ts"],"names":[],"mappings":"AAAA,OAAO,EAOL,KAAK,qBAAqB,EAI1B,KAAK,SAAS,EACd,KAAK,IAAI,EACT,KAAK,kBAAkB,EAExB,MAAM,eAAe,CAAC;AACvB,OAAO,EAQL,KAAK,KAAK,EACV,KAAK,WAAW,EACjB,MAAM,2BAA2B,CAAC;AAQnC,MAAM,WAAW,iBAAkB,SAAQ,WAAW;IACpD,2CAA2C;IAC3C,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;CACxB;AAED,MAAM,MAAM,SAAS,GAAG,qBAAqB,GAAG,SAAS,GAAG,kBAAkB,CAAC;AAE/E,gEAAgE;AAChE,eAAO,MAAM,eAAe,QAAO,SAIjC,CAAC;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2CG;AACH,eAAO,MAAM,UAAU,GACpB,qDAKE,iBAAiB,KAAG,IAAI,CAAC,KAAK,EAAE,KAAK,EAAE,SAAS,CA6MlD,CAAC"}
+{"version":3,"file":"Relay.d.ts","sourceRoot":"","sources":["../../../src/local-first/Relay.ts"],"names":[],"mappings":"AAAA,OAAO,EAOL,KAAK,qBAAqB,EAI1B,KAAK,SAAS,EACd,KAAK,IAAI,EACT,KAAK,kBAAkB,EAExB,MAAM,eAAe,CAAC;AACvB,OAAO,EAQL,KAAK,KAAK,EACV,KAAK,WAAW,EACjB,MAAM,2BAA2B,CAAC;AAQnC,MAAM,WAAW,iBAAkB,SAAQ,WAAW;IACpD,2CAA2C;IAC3C,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;CACxB;AAED,MAAM,MAAM,SAAS,GAAG,qBAAqB,GAAG,SAAS,GAAG,kBAAkB,CAAC;AAE/E,gEAAgE;AAChE,eAAO,MAAM,eAAe,QAAO,SAIjC,CAAC;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2CG;AACH,eAAO,MAAM,UAAU,GACpB,qDAKE,iBAAiB,KAAG,IAAI,CAAC,KAAK,EAAE,KAAK,EAAE,SAAS,CA8MlD,CAAC"}

package/dist/src/local-first/Relay.js

@@ -87,9 +87,9 @@ export const createRelayDeps = () => ({
  * const deps = { ...createRelayDeps(), console };
  *
  * await using run = createRun(deps);
- * await using stack = new AsyncDisposableStack();
+ * await using disposer = new AsyncDisposableStack();
  *
- * stack.use(
+ * disposer.use(
  *   await run.orThrow(
  *     startRelay({
  *       port: 4000,
@@ -111,23 +111,23 @@ export const createRelayDeps = () => ({
 export const startRelay = ({ port = 443, name = Name.orThrow("evolu-relay"), isOwnerAllowed, isOwnerWithinQuota, }) => async (run) => {
     const env_1 = { stack: [], error: void 0, hasError: false };
     try {
-        const stack = __addDisposableResource(env_1, new AsyncDisposableStack(), true);
+        const disposer = __addDisposableResource(env_1, new AsyncDisposableStack(), true);
         const console = run.deps.console.child("relay");
-        stack.defer(() => {
+        disposer.defer(() => {
             console.info("Shutdown complete");
         });
         const dbFileExists = existsSync(`${name}.db`);
-        const sqlite = stack.use(await run.orThrow(createSqlite(name)));
+        const sqlite = disposer.use(await run.orThrow(createSqlite(name)));
         const deps = { ...run.deps, sqlite };
         if (!dbFileExists) {
             createBaseSqliteStorageTables(deps);
             createRelayStorageTables(deps);
         }
-        const server = stack.use(createServer());
+        const server = disposer.use(createServer());
         server.once("close", () => {
             console.info("HTTP server closed");
         });
-        const wss = stack.adopt(new WebSocketServer({
+        const wss = disposer.adopt(new WebSocketServer({
             maxPayload: defaultProtocolMessageMaxSize,
             noServer: true,
         }), (wss) => new Promise((resolve) => {
@@ -137,7 +137,8 @@ export const startRelay = ({ port = 443, name = Name.orThrow("evolu-relay"), isO
             });
         }));
         const ownerSocketRelation = createRelation();
-        const relayRun = stack.use(run.create().addDeps({
+        const relayRun = disposer.use(run.create({
+            ...run.deps,
             storage: createRelaySqliteStorage(deps)({
                 isOwnerWithinQuota,
             }),
@@ -234,7 +235,7 @@ export const startRelay = ({ port = 443, name = Name.orThrow("evolu-relay"), isO
                 console.debug("ws close", wss.clients.size);
             });
         });
-        stack.defer(() => {
+        disposer.defer(() => {
             console.info("Shutting down...");
             for (const client of wss.clients) {
                 if (client.readyState === WebSocket.OPEN) {
@@ -246,11 +247,11 @@ export const startRelay = ({ port = 443, name = Name.orThrow("evolu-relay"), isO
         await once(server, "listening");
         const address = server.address();
         assert(address && typeof address !== "string", "Expected TCP address");
-        const moved = stack.move();
+        const disposables = disposer.move();
         console.info(`Started on port ${address.port}`);
         return ok({
             port: address.port,
-            [Symbol.asyncDispose]: () => moved.disposeAsync(),
+            [Symbol.asyncDispose]: () => disposables.disposeAsync(),
         });
     }
     catch (e_1) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@evolu/nodejs",
-  "version": "3.0.0-next.2",
+  "version": "3.0.0-next.3",
   "description": "Evolu for Node.js",
   "author": "Daniel Steigerwald <daniel@steigerwald.cz>",
   "license": "MIT",
@@ -35,7 +35,7 @@
     "@types/node": "^24.10.9",
     "@types/ws": "^8.18.1",
     "typescript": "^6",
-    "@evolu/common": "8.0.0-next.2",
+    "@evolu/common": "8.0.0-next.5",
     "@evolu/typescript-config": "0.0.2"
   },
   "peerDependencies": {

package/src/Sqlite.ts

@@ -3,20 +3,29 @@ import {
   lazyVoid,
   ok,
   type CreateSqliteDriver,
-  type SqliteDriver,
   type SqliteRow,
 } from "@evolu/common";
 import BetterSQLite, { type Statement } from "better-sqlite3";
+import { rmSync } from "fs";
 
 export const createBetterSqliteDriver: CreateSqliteDriver =
   (name, options) => () => {
     const filename = options?.mode === "memory" ? ":memory:" : `${name}.db`;
-    const stack = new globalThis.DisposableStack();
-    const db = stack.adopt(new BetterSQLite(filename), (db) => {
+    const filenamesToDelete =
+      options?.mode === "memory"
+        ? []
+        : [
+            filename,
+            `${filename}-shm`,
+            `${filename}-wal`,
+            `${filename}-journal`,
+          ];
+    using disposer = new DisposableStack();
+    const db = disposer.adopt(new BetterSQLite(filename), (db) => {
       db.close();
     });
 
-    const cache = stack.use(
+    const cache = disposer.use(
       createPreparedStatementsCache<Statement>(
         (sql) => db.prepare(sql),
         // Not needed.
@@ -25,7 +34,9 @@ export const createBetterSqliteDriver: CreateSqliteDriver =
       ),
     );
 
-    const driver: SqliteDriver = {
+    const disposables = disposer.move();
+
+    return ok({
       exec: (query) => {
         // Always prepare is recommended for better-sqlite3
         const prepared = cache.get(query, true);
@@ -51,10 +62,18 @@ export const createBetterSqliteDriver: CreateSqliteDriver =
         return new Uint8Array(file);
       },
 
-      [Symbol.dispose]: () => {
-        stack.dispose();
+      deleteDatabase: () => {
+        using deleteDisposer = new DisposableStack();
+        for (const filename of filenamesToDelete) {
+          deleteDisposer.defer(() => {
+            rmSync(filename, { force: true });
+          });
+        }
+        deleteDisposer.use(disposables);
       },
-    };
 
-    return ok(driver);
+      [Symbol.dispose]: () => {
+        disposables.dispose();
+      },
+    });
   };

package/src/Task.ts

@@ -9,7 +9,7 @@ import {
   createUnknownError,
   type CreateRun,
   type Run,
-  type RunDeps,
+  type RunDefaultDeps,
 } from "@evolu/common";
 
 /**
@@ -42,18 +42,18 @@ export interface ShutdownDep {
  * const deps = { ...createRelayDeps(), console };
  *
  * await using run = createRun(deps);
- * await using stack = new AsyncDisposableStack();
+ * await using disposer = new AsyncDisposableStack();
  *
- * stack.use(await run.orThrow(startRelay({ port: 4000 })));
+ * disposer.use(await run.orThrow(startRelay({ port: 4000 })));
  *
  * await run.deps.shutdown;
  * ```
  *
  * @group Node.js Run
  */
-export const createRun: CreateRun<RunDeps & ShutdownDep> = <D>(
+export const createRun: CreateRun<RunDefaultDeps & ShutdownDep> = <D>(
   deps?: D,
-): Run<RunDeps & ShutdownDep & D> => {
+): Run<RunDefaultDeps & ShutdownDep & D> => {
   const { promise: shutdown, resolve: resolveShutdown } =
     Promise.withResolvers<void>();
 

package/src/Worker.ts

@@ -1,3 +1,45 @@
+import type { BroadcastChannel, CreateBroadcastChannel } from "@evolu/common";
+import { assertNotDisposed } from "@evolu/common";
+
+/** Creates a {@link BroadcastChannel} from a Node.js BroadcastChannel. */
+export const createBroadcastChannel: CreateBroadcastChannel = <
+  Input,
+  Output = Input,
+>(
+  name: string,
+): BroadcastChannel<Input, Output> => {
+  const nativeBroadcastChannel = new globalThis.BroadcastChannel(name);
+  using disposer = new DisposableStack();
+
+  disposer.defer(() => {
+    nativeBroadcastChannel.onmessage = null;
+    nativeBroadcastChannel.close();
+  });
+
+  const disposables = disposer.move();
+  let onMessageHandler: ((message: Output) => void) | null = null;
+
+  return {
+    postMessage: (message) => {
+      assertNotDisposed(disposables);
+      nativeBroadcastChannel.postMessage(message);
+    },
+    get onMessage() {
+      return disposables.disposed ? null : onMessageHandler;
+    },
+    set onMessage(fn) {
+      if (disposables.disposed) return;
+      onMessageHandler = fn;
+      nativeBroadcastChannel.onmessage = fn
+        ? (event: MessageEvent<Output>) => {
+            fn(event.data);
+          }
+        : null;
+    },
+    [Symbol.dispose]: () => disposables.dispose(),
+  };
+};
+
 // TODO: Implement Node.js Worker API
 //
 // This module should provide Node.js implementations of the common Worker API:

package/src/index.ts

@@ -3,3 +3,4 @@ export * from "./Crypto.js";
 export * from "./local-first/Relay.js";
 export * from "./Task.js";
 export * from "./WebSocket.js";
+export * from "./Worker.js";

package/src/local-first/Relay.ts

@@ -69,9 +69,9 @@ export const createRelayDeps = (): RelayDeps => ({
  * const deps = { ...createRelayDeps(), console };
  *
  * await using run = createRun(deps);
- * await using stack = new AsyncDisposableStack();
+ * await using disposer = new AsyncDisposableStack();
  *
- * stack.use(
+ * disposer.use(
  *   await run.orThrow(
  *     startRelay({
  *       port: 4000,
@@ -98,15 +98,15 @@ export const startRelay =
     isOwnerWithinQuota,
   }: NodeJsRelayConfig): Task<Relay, never, RelayDeps> =>
   async (run) => {
-    await using stack = new AsyncDisposableStack();
+    await using disposer = new AsyncDisposableStack();
     const console = run.deps.console.child("relay");
 
-    stack.defer(() => {
+    disposer.defer(() => {
       console.info("Shutdown complete");
     });
 
     const dbFileExists = existsSync(`${name}.db`);
-    const sqlite = stack.use(await run.orThrow(createSqlite(name)));
+    const sqlite = disposer.use(await run.orThrow(createSqlite(name)));
     const deps = { ...run.deps, sqlite };
 
     if (!dbFileExists) {
@@ -114,12 +114,12 @@ export const startRelay =
       createRelayStorageTables(deps);
     }
 
-    const server = stack.use(createServer());
+    const server = disposer.use(createServer());
     server.once("close", () => {
       console.info("HTTP server closed");
     });
 
-    const wss = stack.adopt(
+    const wss = disposer.adopt(
       new WebSocketServer({
         maxPayload: defaultProtocolMessageMaxSize,
         noServer: true,
@@ -135,8 +135,9 @@ export const startRelay =
 
     const ownerSocketRelation = createRelation<OwnerId, WebSocket>();
 
-    const relayRun = stack.use(
-      run.create().addDeps({
+    const relayRun = disposer.use(
+      run.create({
+        ...run.deps,
         storage: createRelaySqliteStorage(deps)({
           isOwnerWithinQuota,
         }),
@@ -278,7 +279,7 @@ export const startRelay =
       });
     });
 
-    stack.defer(() => {
+    disposer.defer(() => {
       console.info("Shutting down...");
       for (const client of wss.clients) {
         if (client.readyState === WebSocket.OPEN) {
@@ -293,13 +294,13 @@ export const startRelay =
     const address = server.address();
     assert(address && typeof address !== "string", "Expected TCP address");
 
-    const moved = stack.move();
+    const disposables = disposer.move();
 
     console.info(`Started on port ${address.port}`);
 
     return ok({
       port: address.port,
-      [Symbol.asyncDispose]: () => moved.disposeAsync(),
+      [Symbol.asyncDispose]: () => disposables.disposeAsync(),
     });
   };