@evolu/nodejs 2.4.0 → 3.0.0-next.0

package/README.md

@@ -1,4 +1,6 @@
-# Evolu Relay for Node.js and SQLite
+# Evolu for Node.js
+
+This package provides Evolu for [Node.js](https://nodejs.org) 24+.
 
 ## Documentation
 
@@ -10,4 +12,4 @@ The Evolu community is on [GitHub Discussions](https://github.com/evoluhq/evolu/
 
 To chat with other community members, you can join the [Evolu Discord](https://discord.gg/2J8yyyyxtZ).
 
-[![Twitter URL](https://img.shields.io/twitter/url/https/twitter.com/evoluhq.svg?style=social&label=Follow%20%40evoluhq)](https://twitter.com/evoluhq)
+[![X](https://img.shields.io/twitter/url/https/x.com/evoluhq.svg?style=social&label=Follow%20%40evoluhq)](https://x.com/evoluhq)

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

@@ -0,0 +1 @@
+{"version":3,"file":"Crypto.d.ts","sourceRoot":"","sources":["../../src/Crypto.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,eAAe,CAAC;AAGrD,eAAO,MAAM,qBAAqB,QAAO,eAAkC,CAAC"}

package/dist/src/Sqlite.d.ts

@@ -0,0 +1,3 @@
+import { type CreateSqliteDriver } from "@evolu/common";
+export declare const createBetterSqliteDriver: CreateSqliteDriver;
+//# sourceMappingURL=Sqlite.d.ts.map

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

@@ -0,0 +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"}

package/dist/src/Sqlite.js

@@ -0,0 +1,38 @@
+import { createPreparedStatementsCache, lazyVoid, ok, } from "@evolu/common";
+import BetterSQLite, {} from "better-sqlite3";
+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);
+};

package/dist/src/Task.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Node.js-specific Task utilities.
+ *
+ * @module
+ */
+import { type CreateRun, type RunDeps } from "@evolu/common";
+/**
+ * A promise that resolves when a termination signal is received.
+ *
+ * Resolves on `SIGINT` (Ctrl-C), `SIGTERM` (OS/k8s/Docker termination),
+ * `SIGHUP` (console close/terminal disconnect), or `SIGBREAK` (Windows
+ * Ctrl-Break).
+ *
+ * @group Node.js Run
+ */
+export type Shutdown = Promise<void>;
+export interface ShutdownDep {
+    readonly shutdown: Shutdown;
+}
+/**
+ * Creates {@link Run} for Node.js with global error handling and graceful
+ * shutdown.
+ *
+ * Registers `uncaughtException` and `unhandledRejection` handlers that log
+ * errors and initiate graceful shutdown. Adds a `shutdown` promise to deps that
+ * resolves on termination signals (`SIGINT`, `SIGTERM`, `SIGHUP`). Handlers are
+ * removed when the Run is disposed.
+ *
+ * ### Example
+ *
+ * ```ts
+ * const deps = { ...createRelayDeps(), console };
+ *
+ * await using run = createRun(deps);
+ * await using stack = new AsyncDisposableStack();
+ *
+ * stack.use(await run.orThrow(startRelay({ port: 4000 })));
+ *
+ * await run.deps.shutdown;
+ * ```
+ *
+ * @group Node.js Run
+ */
+export declare const createRun: CreateRun<RunDeps & ShutdownDep>;
+//# sourceMappingURL=Task.d.ts.map

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

@@ -0,0 +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"}

package/dist/src/Task.js

@@ -0,0 +1,59 @@
+/**
+ * Node.js-specific Task utilities.
+ *
+ * @module
+ */
+import { createRun as createCommonRun, createUnknownError, } from "@evolu/common";
+/**
+ * Creates {@link Run} for Node.js with global error handling and graceful
+ * shutdown.
+ *
+ * Registers `uncaughtException` and `unhandledRejection` handlers that log
+ * errors and initiate graceful shutdown. Adds a `shutdown` promise to deps that
+ * resolves on termination signals (`SIGINT`, `SIGTERM`, `SIGHUP`). Handlers are
+ * removed when the Run is disposed.
+ *
+ * ### Example
+ *
+ * ```ts
+ * const deps = { ...createRelayDeps(), console };
+ *
+ * await using run = createRun(deps);
+ * await using stack = new AsyncDisposableStack();
+ *
+ * stack.use(await run.orThrow(startRelay({ port: 4000 })));
+ *
+ * await run.deps.shutdown;
+ * ```
+ *
+ * @group Node.js Run
+ */
+export const createRun = (deps) => {
+    const { promise: shutdown, resolve: resolveShutdown } = Promise.withResolvers();
+    const run = createCommonRun({ ...deps, shutdown });
+    const console = run.deps.console.child("global");
+    const handleError = (source) => (error) => {
+        console.error(source, createUnknownError(error));
+        process.exitCode = 1;
+        // Resolve shutdown so `await run.deps.shutdown` unblocks
+        // and allows the stack to be disposed.
+        resolveShutdown();
+    };
+    const handleUncaughtException = handleError("uncaughtException");
+    const handleUnhandledRejection = handleError("unhandledRejection");
+    process.on("uncaughtException", handleUncaughtException);
+    process.on("unhandledRejection", handleUnhandledRejection);
+    process.on("SIGINT", resolveShutdown); // Ctrl-C (all platforms)
+    process.on("SIGTERM", resolveShutdown); // OS/k8s/Docker termination (Unix)
+    process.on("SIGHUP", resolveShutdown); // Console close (Windows), terminal disconnect (Unix)
+    process.on("SIGBREAK", resolveShutdown); // Ctrl-Break (Windows)
+    run.onAbort(() => {
+        process.off("uncaughtException", handleUncaughtException);
+        process.off("unhandledRejection", handleUnhandledRejection);
+        process.off("SIGINT", resolveShutdown);
+        process.off("SIGTERM", resolveShutdown);
+        process.off("SIGHUP", resolveShutdown);
+        process.off("SIGBREAK", resolveShutdown);
+    });
+    return run;
+};

package/dist/src/Worker.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=Worker.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Worker.d.ts","sourceRoot":"","sources":["../../src/Worker.ts"],"names":[],"mappings":""}

package/dist/src/Worker.js

@@ -0,0 +1,12 @@
+export {};
+// TODO: Implement Node.js Worker API
+//
+// This module should provide Node.js implementations of the common Worker API:
+// - createWorker
+// - createWorkerSelf (with onError hooking process.on('uncaughtException') and
+//   process.on('unhandledRejection'))
+// - createMessageChannel
+// - createMessagePort
+//
+// Node.js uses worker_threads module for Worker/MessageChannel/MessagePort.
+// Error handling uses process events instead of globalThis.onerror.

package/dist/src/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./Sqlite.js";
+export * from "./Crypto.js";
+export * from "./local-first/Relay.js";
+export * from "./Task.js";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +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"}

package/dist/src/index.js

@@ -0,0 +1,4 @@
+export * from "./Sqlite.js";
+export * from "./Crypto.js";
+export * from "./local-first/Relay.js";
+export * from "./Task.js";

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

@@ -0,0 +1,55 @@
+import { type CreateSqliteDriverDep, type RandomDep, type Task, type TimingSafeEqualDep } from "@evolu/common";
+import { type Relay, type RelayConfig } from "@evolu/common/local-first";
+export interface NodeJsRelayConfig extends RelayConfig {
+    /** The port number for the HTTP server. */
+    readonly port?: number;
+}
+export type RelayDeps = CreateSqliteDriverDep & RandomDep & TimingSafeEqualDep;
+/** Dependencies for {@link startRelay} using better-sqlite3. */
+export declare const createRelayDeps: () => RelayDeps;
+/**
+ * Starts an Evolu relay server using Node.js.
+ *
+ * Use {@link createRelayDeps} to create dependencies for better-sqlite3, or
+ * provide a custom SQLite driver implementation.
+ *
+ * ### Example
+ *
+ * ```ts
+ * // Ensure the database is created in a predictable location for Docker.
+ * mkdirSync("data", { recursive: true });
+ * process.chdir("data");
+ *
+ * const console = createConsole({
+ *   // level: "debug",
+ *   formatter: createConsoleFormatter()({
+ *     timestampFormat: "relative",
+ *   }),
+ * });
+ *
+ * const deps = { ...createRelayDeps(), console };
+ *
+ * await using run = createRun(deps);
+ * await using stack = new AsyncDisposableStack();
+ *
+ * stack.use(
+ *   await run.orThrow(
+ *     startRelay({
+ *       port: 4000,
+ *
+ *       // Note: Relay requires URL in format ws://host:port/<ownerId>
+ *       // isOwnerAllowed: (_ownerId) => true,
+ *
+ *       isOwnerWithinQuota: (_ownerId, requiredBytes) => {
+ *         const maxBytes = 1024 * 1024; // 1MB
+ *         return requiredBytes <= maxBytes;
+ *       },
+ *     }),
+ *   ),
+ * );
+ *
+ * await run.deps.shutdown;
+ * ```
+ */
+export declare const startRelay: ({ port, name, isOwnerAllowed, isOwnerWithinQuota, }: NodeJsRelayConfig) => Task<Relay, never, RelayDeps>;
+//# sourceMappingURL=Relay.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Relay.d.ts","sourceRoot":"","sources":["../../../src/local-first/Relay.ts"],"names":[],"mappings":"AAAA,OAAO,EAIL,KAAK,qBAAqB,EAK1B,KAAK,SAAS,EACd,KAAK,IAAI,EACT,KAAK,kBAAkB,EAExB,MAAM,eAAe,CAAC;AACvB,OAAO,EAQL,KAAK,KAAK,EACV,KAAK,WAAW,EACjB,MAAM,2BAA2B,CAAC;AAOnC,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,CAoKlD,CAAC"}

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

@@ -0,0 +1,243 @@
+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 { createRandom, createRelation, createSqlite, isPromiseLike, Name, ok, OwnerId, Uint8Array, } from "@evolu/common";
+import { applyProtocolMessageAsRelay, createBaseSqliteStorageTables, createRelaySqliteStorage, createRelayStorageTables, defaultProtocolMessageMaxSize, parseOwnerIdFromOwnerWebSocketTransportUrl, } from "@evolu/common/local-first";
+import { existsSync } from "fs";
+import { createServer } from "http";
+import { WebSocket, WebSocketServer } from "ws";
+import { createTimingSafeEqual } from "../Crypto.js";
+import { createBetterSqliteDriver } from "../Sqlite.js";
+/** Dependencies for {@link startRelay} using better-sqlite3. */
+export const createRelayDeps = () => ({
+    createSqliteDriver: createBetterSqliteDriver,
+    random: createRandom(),
+    timingSafeEqual: createTimingSafeEqual(),
+});
+/**
+ * Starts an Evolu relay server using Node.js.
+ *
+ * Use {@link createRelayDeps} to create dependencies for better-sqlite3, or
+ * provide a custom SQLite driver implementation.
+ *
+ * ### Example
+ *
+ * ```ts
+ * // Ensure the database is created in a predictable location for Docker.
+ * mkdirSync("data", { recursive: true });
+ * process.chdir("data");
+ *
+ * const console = createConsole({
+ *   // level: "debug",
+ *   formatter: createConsoleFormatter()({
+ *     timestampFormat: "relative",
+ *   }),
+ * });
+ *
+ * const deps = { ...createRelayDeps(), console };
+ *
+ * await using run = createRun(deps);
+ * await using stack = new AsyncDisposableStack();
+ *
+ * stack.use(
+ *   await run.orThrow(
+ *     startRelay({
+ *       port: 4000,
+ *
+ *       // Note: Relay requires URL in format ws://host:port/<ownerId>
+ *       // isOwnerAllowed: (_ownerId) => true,
+ *
+ *       isOwnerWithinQuota: (_ownerId, requiredBytes) => {
+ *         const maxBytes = 1024 * 1024; // 1MB
+ *         return requiredBytes <= maxBytes;
+ *       },
+ *     }),
+ *   ),
+ * );
+ *
+ * await run.deps.shutdown;
+ * ```
+ */
+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 console = run.deps.console.child("relay");
+        const dbFileExists = existsSync(`${name}.db`);
+        const sqliteResult = await run(createSqlite(name));
+        if (!sqliteResult.ok)
+            return sqliteResult;
+        const sqlite = stack.use(sqliteResult.value);
+        const deps = { ...run.deps, sqlite };
+        if (!dbFileExists) {
+            createBaseSqliteStorageTables(deps);
+            createRelayStorageTables(deps);
+        }
+        const relayRun = run.create().addDeps({
+            storage: createRelaySqliteStorage(deps)({
+                isOwnerWithinQuota,
+            }),
+        });
+        const server = createServer();
+        const wss = new WebSocketServer({
+            maxPayload: defaultProtocolMessageMaxSize,
+            noServer: true,
+        });
+        const ownerSocketRelation = createRelation();
+        server.on("upgrade", (request, socket, head) => {
+            socket.on("error", console.debug);
+            const completeUpgrade = () => {
+                socket.removeListener("error", console.debug);
+                wss.handleUpgrade(request, socket, head, (ws) => {
+                    wss.emit("connection", ws, request);
+                });
+            };
+            if (!isOwnerAllowed) {
+                completeUpgrade();
+                return;
+            }
+            const ownerId = parseOwnerIdFromOwnerWebSocketTransportUrl(request.url ?? "");
+            if (!ownerId) {
+                console.debug("invalid or missing ownerId in URL", request.url);
+                socket.write("HTTP/1.1 400 Bad Request\r\n\r\n");
+                socket.destroy();
+                return;
+            }
+            void (async () => {
+                const result = isOwnerAllowed(ownerId);
+                const isAllowed = isPromiseLike(result) ? await result : result;
+                if (!isAllowed) {
+                    console.debug("unauthorized owner", ownerId);
+                    socket.write("HTTP/1.1 401 Unauthorized\r\n\r\n");
+                    socket.destroy();
+                    return;
+                }
+                completeUpgrade();
+            })();
+        });
+        wss.on("connection", (ws) => {
+            console.debug("on connection", wss.clients.size);
+            const options = {
+                subscribe: (ownerId) => {
+                    ownerSocketRelation.add(ownerId, ws);
+                    console.debug("subscribe", ownerId, ownerSocketRelation.bCountForA(ownerId));
+                },
+                unsubscribe: (ownerId) => {
+                    ownerSocketRelation.remove(ownerId, ws);
+                    console.debug("unsubscribe", ownerId, ownerSocketRelation.bCountForA(ownerId));
+                },
+                broadcast: (ownerId, message) => {
+                    for (const socket of ownerSocketRelation.iterateB(ownerId)) {
+                        if (socket !== ws && socket.readyState === WebSocket.OPEN) {
+                            socket.send(message, { binary: true });
+                        }
+                    }
+                    console.debug("broadcast", ownerId, ownerSocketRelation.bCountForA(ownerId));
+                },
+            };
+            ws.on("message", (message) => {
+                if (!Uint8Array.is(message))
+                    return;
+                void (async () => {
+                    const response = await relayRun(applyProtocolMessageAsRelay(message, options));
+                    if (!response.ok) {
+                        console.error(response);
+                        return;
+                    }
+                    ws.send(response.value.message, { binary: true });
+                })();
+            });
+            ws.on("close", () => {
+                ownerSocketRelation.removeByB(ws);
+                console.debug("ws close", wss.clients.size);
+            });
+        });
+        // Cleanup runs in LIFO order: clients → WebSocketServer → HTTP server
+        stack.defer(() => {
+            console.info("Shutdown complete");
+        });
+        stack.defer(() => {
+            server.close(() => {
+                console.info("HTTP server closed");
+            });
+        });
+        stack.defer(() => {
+            // wss.close() emits 'close' when all clients have disconnected
+            // https://github.com/websockets/ws/blob/master/doc/ws.md#serverclosecallback
+            wss.close(() => {
+                console.info("WebSocketServer closed");
+                ok();
+            });
+        });
+        stack.defer(() => {
+            console.info("Shutting down...");
+            for (const client of wss.clients) {
+                if (client.readyState === WebSocket.OPEN) {
+                    client.close(1000, "Evolu Relay shutting down");
+                }
+            }
+        });
+        stack.use(relayRun);
+        server.listen(port);
+        console.info(`Started on port ${port}`);
+        return ok(stack.move());
+    }
+    catch (e_1) {
+        env_1.error = e_1;
+        env_1.hasError = true;
+    }
+    finally {
+        const result_1 = __disposeResources(env_1);
+        if (result_1)
+            await result_1;
+    }
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@evolu/nodejs",
-  "version": "2.4.0",
+  "version": "3.0.0-next.0",
   "description": "Evolu for Node.js",
   "author": "Daniel Steigerwald <daniel@steigerwald.cz>",
   "license": "MIT",
@@ -10,41 +10,43 @@
   },
   "homepage": "https://evolu.dev",
   "type": "module",
-  "types": "./dist/index.d.ts",
+  "types": "./dist/src/index.d.ts",
   "exports": {
-    ".": "./dist/index.js"
+    ".": {
+      "types": "./dist/src/index.d.ts",
+      "import": "./dist/src/index.js",
+      "default": "./dist/src/index.js"
+    }
   },
   "files": [
-    "dist/**",
+    "dist/src/**",
     "src/**",
     "README.md"
   ],
+  "scripts": {
+    "build": "tsc --build tsconfig.build.json",
+    "prepack": "npm run build",
+    "format": "prettier --write \"src/*.{ts,tsx,md}\""
+  },
   "dependencies": {
-    "better-sqlite3": "^12.1.1",
-    "ws": "^8.18.2"
+    "better-sqlite3": "^12.6.2",
+    "ws": "^8.19.0"
   },
   "devDependencies": {
+    "@evolu/common": "8.0.0-next.0",
+    "@evolu/typescript-config": "*",
     "@types/better-sqlite3": "^7.6.13",
-    "@types/node": "^22.17.1",
+    "@types/node": "^24.10.9",
     "@types/ws": "^8.18.1",
-    "typescript": "^5.9.2",
-    "vitest": "^4.0.4",
-    "@evolu/common": "7.4.0",
-    "@evolu/tsconfig": "0.0.2"
+    "typescript": "^5.9.3"
   },
   "peerDependencies": {
-    "@evolu/common": "^7.4.0"
+    "@evolu/common": "^8.0.0-next.0"
   },
   "engines": {
-    "node": ">=22.0.0"
+    "node": ">=24.0.0"
   },
   "publishConfig": {
     "access": "public"
-  },
-  "scripts": {
-    "dev": "tsc --watch",
-    "build": "rimraf dist && tsc",
-    "clean": "rimraf .turbo node_modules dist",
-    "format": "prettier --write \"src/*.{ts,tsx,md}\""
   }
-}
+}

package/src/Crypto.ts

@@ -1,4 +1,4 @@
-import { timingSafeEqual } from "node:crypto";
 import type { TimingSafeEqual } from "@evolu/common";
+import { timingSafeEqual } from "node:crypto";
 
 export const createTimingSafeEqual = (): TimingSafeEqual => timingSafeEqual;

package/src/Sqlite.ts

@@ -0,0 +1,60 @@
+import {
+  createPreparedStatementsCache,
+  lazyVoid,
+  ok,
+  type CreateSqliteDriver,
+  type SqliteDriver,
+  type SqliteRow,
+} from "@evolu/common";
+import BetterSQLite, { type Statement } from "better-sqlite3";
+
+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) => {
+      db.close();
+    });
+
+    const cache = stack.use(
+      createPreparedStatementsCache<Statement>(
+        (sql) => db.prepare(sql),
+        // Not needed.
+        // https://github.com/WiseLibs/better-sqlite3/blob/master/docs/api.md#class-statement
+        lazyVoid,
+      ),
+    );
+
+    const driver: SqliteDriver = {
+      exec: (query) => {
+        // Always prepare is recommended for better-sqlite3
+        const prepared = cache.get(query, true);
+
+        if (prepared.reader) {
+          const rows = prepared.all(query.parameters) as Array<SqliteRow>;
+          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);
+  };