@evolu/nodejs 2.4.0 → 3.0.0-next.1

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/WebSocket.d.ts

@@ -0,0 +1,19 @@
+import { type ClientRequest, type IncomingMessage } from "http";
+/**
+ * A raw WebSocket upgrade request prepared for tests by
+ * {@link testSetupWebSocketUpgradeRequest}.
+ */
+export interface TestSetupWebSocketUpgradeRequest extends AsyncDisposable {
+    readonly req: ClientRequest;
+}
+/**
+ * Creates a raw WebSocket upgrade request test setup for tests that need manual
+ * request control.
+ */
+export declare const testSetupWebSocketUpgradeRequest: (port: number, path: string) => TestSetupWebSocketUpgradeRequest;
+/**
+ * Sends a raw WebSocket upgrade request and resolves with the rejection
+ * response.
+ */
+export declare const testSendWebSocketUpgradeRequest: (port: number, path: string) => Promise<IncomingMessage>;
+//# sourceMappingURL=WebSocket.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"WebSocket.d.ts","sourceRoot":"","sources":["../../src/WebSocket.ts"],"names":[],"mappings":"AAAA,OAAO,EAAW,KAAK,aAAa,EAAE,KAAK,eAAe,EAAE,MAAM,MAAM,CAAC;AAEzE;;;GAGG;AACH,MAAM,WAAW,gCAAiC,SAAQ,eAAe;IACvE,QAAQ,CAAC,GAAG,EAAE,aAAa,CAAC;CAC7B;AAED;;;GAGG;AACH,eAAO,MAAM,gCAAgC,GAC3C,MAAM,MAAM,EACZ,MAAM,MAAM,KACX,gCAWF,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,+BAA+B,GAC1C,MAAM,MAAM,EACZ,MAAM,MAAM,KACX,OAAO,CAAC,eAAe,CAezB,CAAC"}

package/dist/src/WebSocket.js

@@ -0,0 +1,46 @@
+import { request } from "http";
+/**
+ * Creates a raw WebSocket upgrade request test setup for tests that need manual
+ * request control.
+ */
+export const testSetupWebSocketUpgradeRequest = (port, path) => {
+    const req = createWebSocketUpgradeRequest(port, path);
+    req.on("error", () => undefined);
+    return {
+        req,
+        [Symbol.asyncDispose]: () => {
+            req.destroy();
+            return Promise.resolve();
+        },
+    };
+};
+/**
+ * Sends a raw WebSocket upgrade request and resolves with the rejection
+ * response.
+ */
+export const testSendWebSocketUpgradeRequest = async (port, path) => {
+    const req = createWebSocketUpgradeRequest(port, path);
+    return new Promise((resolve, reject) => {
+        req.once("response", (response) => {
+            response.resume();
+            resolve(response);
+        });
+        req.once("upgrade", (_response, socket) => {
+            socket.destroy();
+            reject(new Error("Expected HTTP upgrade rejection"));
+        });
+        req.once("error", reject);
+        req.end();
+    });
+};
+const createWebSocketUpgradeRequest = (port, path) => request({
+    host: "127.0.0.1",
+    port,
+    path,
+    headers: {
+        Connection: "Upgrade",
+        Upgrade: "websocket",
+        "Sec-WebSocket-Version": "13",
+        "Sec-WebSocket-Key": "dGhlIHNhbXBsZSBub25jZQ==",
+    },
+});

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,6 @@
+export * from "./Sqlite.js";
+export * from "./Crypto.js";
+export * from "./local-first/Relay.js";
+export * from "./Task.js";
+export * from "./WebSocket.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;AAC1B,cAAc,gBAAgB,CAAC"}

package/dist/src/index.js

@@ -0,0 +1,5 @@
+export * from "./Sqlite.js";
+export * from "./Crypto.js";
+export * from "./local-first/Relay.js";
+export * from "./Task.js";
+export * from "./WebSocket.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=<ownerId>
+ *       // isOwnerAllowed: (_ownerId, { signal: _signal }) => 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,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"}

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

@@ -0,0 +1,270 @@
+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 { AbortError, assert, callback, createRandom, createRelation, createSqlite, Name, ok, OwnerId, Uint8Array, } from "@evolu/common";
+import { applyProtocolMessageAsRelay, createBaseSqliteStorageTables, createRelaySqliteStorage, createRelayStorageTables, defaultProtocolMessageMaxSize, parseOwnerIdFromOwnerWebSocketTransportUrl, } from "@evolu/common/local-first";
+import { once } from "events";
+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=<ownerId>
+ *       // isOwnerAllowed: (_ownerId, { signal: _signal }) => 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");
+        stack.defer(() => {
+            console.info("Shutdown complete");
+        });
+        const dbFileExists = existsSync(`${name}.db`);
+        const sqlite = stack.use(await run.orThrow(createSqlite(name)));
+        const deps = { ...run.deps, sqlite };
+        if (!dbFileExists) {
+            createBaseSqliteStorageTables(deps);
+            createRelayStorageTables(deps);
+        }
+        const server = stack.use(createServer());
+        server.once("close", () => {
+            console.info("HTTP server closed");
+        });
+        const wss = stack.adopt(new WebSocketServer({
+            maxPayload: defaultProtocolMessageMaxSize,
+            noServer: true,
+        }), (wss) => new Promise((resolve) => {
+            wss.close(() => {
+                console.info("WebSocketServer closed");
+                resolve();
+            });
+        }));
+        const ownerSocketRelation = createRelation();
+        const relayRun = stack.use(run.create().addDeps({
+            storage: createRelaySqliteStorage(deps)({
+                isOwnerWithinQuota,
+            }),
+        }));
+        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 respondAndDestroy = (statusCode) => {
+                if (socket.destroyed)
+                    return;
+                socket.write(`HTTP/1.1 ${statusCode} ${HttpStatusTextByCode[statusCode]}\r\n\r\n`);
+                socket.destroy();
+            };
+            const requestUrl = request.url;
+            const ownerId = requestUrl
+                ? parseOwnerIdFromOwnerWebSocketTransportUrl(requestUrl)
+                : undefined;
+            if (!ownerId) {
+                console.debug("invalid or missing ownerId in URL", requestUrl);
+                respondAndDestroy(400);
+                return;
+            }
+            const authorizationFiber = relayRun(callback(({ ok, err, signal }) => {
+                void Promise.try(() => isOwnerAllowed(ownerId, { signal })).then(ok, err);
+            }));
+            const abortAuthorization = () => {
+                authorizationFiber.abort("WebSocket upgrade request socket closed");
+            };
+            socket.once("close", abortAuthorization);
+            socket.once("error", abortAuthorization);
+            void authorizationFiber.then((result) => {
+                socket.removeListener("close", abortAuthorization);
+                socket.removeListener("error", abortAuthorization);
+                if (!result.ok) {
+                    if (!AbortError.is(result.error)) {
+                        console.error("isOwnerAllowed failed", ownerId, result.error);
+                        respondAndDestroy(503);
+                        return;
+                    }
+                    socket.destroy();
+                    return;
+                }
+                if (!result.value) {
+                    console.debug("unauthorized owner", ownerId);
+                    respondAndDestroy(401);
+                    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);
+            });
+        });
+        stack.defer(() => {
+            console.info("Shutting down...");
+            for (const client of wss.clients) {
+                if (client.readyState === WebSocket.OPEN) {
+                    client.close(1000, "Evolu Relay shutting down");
+                }
+            }
+        });
+        server.listen(port);
+        await once(server, "listening");
+        const address = server.address();
+        assert(address && typeof address !== "string", "Expected TCP address");
+        const moved = stack.move();
+        console.info(`Started on port ${address.port}`);
+        return ok({
+            port: address.port,
+            [Symbol.asyncDispose]: () => moved.disposeAsync(),
+        });
+    }
+    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;
+    }
+};
+const HttpStatusTextByCode = {
+    400: "Bad Request",
+    401: "Unauthorized",
+    503: "Service Unavailable",
+};