@evolu/nodejs 3.0.0-next.2 → 3.0.0

package/dist/src/Cli.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Abort-aware CLI process utilities.
+ *
+ * @module
+ */
+import { type Task, type Typed } from "@evolu/common";
+/** Runs a command with inherited stdio. */
+export type Spawn = (file: string, args: ReadonlyArray<string>, options?: {
+    readonly cwd?: string | URL;
+}) => Task<void, SpawnError>;
+/** Failure to start a command or an unsuccessful command exit. */
+export interface SpawnError extends Typed<"SpawnError"> {
+    readonly command: string;
+    readonly exitCode: number | null;
+    readonly signal: NodeJS.Signals | null;
+    readonly message: string;
+}
+/** Dependency wrapper for {@link spawn}. */
+export interface SpawnDep {
+    readonly spawn: Spawn;
+}
+/**
+ * Runs a command with inherited stdio and aborts it with the current Run.
+ *
+ * A zero exit code succeeds. A start failure, non-zero exit code, or signal
+ * exit returns {@link SpawnError}.
+ */
+export declare const spawn: Spawn;
+//# sourceMappingURL=Cli.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Cli.d.ts","sourceRoot":"","sources":["../../src/Cli.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAqB,KAAK,IAAI,EAAE,KAAK,KAAK,EAAE,MAAM,eAAe,CAAC;AAGzE,2CAA2C;AAC3C,MAAM,MAAM,KAAK,GAAG,CAClB,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,aAAa,CAAC,MAAM,CAAC,EAC3B,OAAO,CAAC,EAAE;IACR,QAAQ,CAAC,GAAG,CAAC,EAAE,MAAM,GAAG,GAAG,CAAC;CAC7B,KACE,IAAI,CAAC,IAAI,EAAE,UAAU,CAAC,CAAC;AAE5B,kEAAkE;AAClE,MAAM,WAAW,UAAW,SAAQ,KAAK,CAAC,YAAY,CAAC;IACrD,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IACjC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC,OAAO,GAAG,IAAI,CAAC;IACvC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;CAC1B;AAED,4CAA4C;AAC5C,MAAM,WAAW,QAAQ;IACvB,QAAQ,CAAC,KAAK,EAAE,KAAK,CAAC;CACvB;AAED;;;;;GAKG;AACH,eAAO,MAAM,KAAK,EAAE,KAwCnB,CAAC"}

package/dist/src/Cli.js

@@ -0,0 +1,49 @@
+/**
+ * Abort-aware CLI process utilities.
+ *
+ * @module
+ */
+import { callback, err, ok } from "@evolu/common";
+import { spawn as nodeSpawn } from "node:child_process";
+/**
+ * Runs a command with inherited stdio and aborts it with the current Run.
+ *
+ * A zero exit code succeeds. A start failure, non-zero exit code, or signal
+ * exit returns {@link SpawnError}.
+ */
+export const spawn = (file, args, { cwd } = {}) => {
+    const command = [file, ...args].join(" ");
+    return callback(({ run, resolve }) => {
+        const child = nodeSpawn(file, args, {
+            cwd,
+            signal: run.signal,
+            stdio: "inherit",
+        });
+        child.once("error", (error) => {
+            if (run.signal.aborted)
+                return;
+            resolve(err({
+                type: "SpawnError",
+                command,
+                exitCode: null,
+                signal: null,
+                message: `Failed to start ${command}: ${error.message}`,
+            }));
+        });
+        child.once("close", (exitCode, signal) => {
+            if (run.signal.aborted)
+                return;
+            resolve(exitCode === 0
+                ? ok()
+                : err({
+                    type: "SpawnError",
+                    command,
+                    exitCode,
+                    signal,
+                    message: signal == null
+                        ? `${command} exited with code ${exitCode}.`
+                        : `${command} exited from ${signal}.`,
+                }));
+        });
+    });
+};

package/dist/src/Platform.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Node.js platform utilities.
+ *
+ * @module
+ */
+import { PositiveInt } from "@evolu/common";
+/** Returns the recommended amount of parallelism available to this process. */
+export type AvailableParallelism = () => PositiveInt;
+/** Dependency wrapper for {@link availableParallelism}. */
+export interface AvailableParallelismDep {
+    readonly availableParallelism: AvailableParallelism;
+}
+/** Returns the recommended amount of parallelism available to this process. */
+export declare const availableParallelism: AvailableParallelism;
+//# sourceMappingURL=Platform.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Platform.d.ts","sourceRoot":"","sources":["../../src/Platform.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAG5C,+EAA+E;AAC/E,MAAM,MAAM,oBAAoB,GAAG,MAAM,WAAW,CAAC;AAErD,2DAA2D;AAC3D,MAAM,WAAW,uBAAuB;IACtC,QAAQ,CAAC,oBAAoB,EAAE,oBAAoB,CAAC;CACrD;AAED,+EAA+E;AAC/E,eAAO,MAAM,oBAAoB,EAAE,oBACc,CAAC"}

package/dist/src/Platform.js

@@ -0,0 +1,9 @@
+/**
+ * Node.js platform utilities.
+ *
+ * @module
+ */
+import { PositiveInt } from "@evolu/common";
+import { availableParallelism as nodeAvailableParallelism } from "node:os";
+/** Returns the recommended amount of parallelism available to this process. */
+export const availableParallelism = () => PositiveInt.orThrow(nodeAvailableParallelism());

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 @@
-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);
+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);
+                }
             }
-            // Ensure export uses transferable ArrayBuffer backing.
-            return new Uint8Array(file);
-        },
-        [Symbol.dispose]: () => {
-            stack.dispose();
-        },
+            if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
+            if (env.hasError) throw env.error;
+        }
+        return next();
     };
-    return ok(driver);
+})(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 { constVoid, createPreparedStatementsCache, ok, } from "@evolu/common";
+import BetterSQLite, {} from "better-sqlite3";
+import { rmSync } from "fs";
+export const createBetterSqliteDriver = (name, options) => () => {
+    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
+        constVoid));
+        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,43 +3,88 @@
  *
  * @module
  */
-import { type CreateRun, type RunDeps } from "@evolu/common";
+import { type Resource, type RunCustomDeps, type Task, type Typed } from "@evolu/common";
 /**
- * A promise that resolves when a termination signal is received.
+ * An abort requested by a Node.js termination signal.
  *
- * Resolves on `SIGINT` (Ctrl-C), `SIGTERM` (OS/k8s/Docker termination),
- * `SIGHUP` (console close/terminal disconnect), or `SIGBREAK` (Windows
- * Ctrl-Break).
- *
- * @group Node.js Run
+ * @group Node.js Task
  */
-export type Shutdown = Promise<void>;
-export interface ShutdownDep {
-    readonly shutdown: Shutdown;
+export interface NodeSignalAbortReason extends Typed<"NodeSignalAbortReason"> {
+    readonly signal: NodeSignal;
+}
+/** A Node.js termination signal handled by {@link runMain}. */
+export type NodeSignal = "SIGINT" | "SIGTERM" | "SIGBREAK";
+/** Process lifecycle behavior for {@link runMain}. */
+export type RunMainMode = "service" | "command";
+/** Options for {@link runMain}. */
+export interface RunMainOptions {
+    /**
+     * How termination signals affect the process exit status.
+     *
+     * Services treat a gracefully handled signal as a successful shutdown.
+     * Commands use the conventional `128 + signal number` exit status unless a
+     * reported defect has already set a failure status.
+     *
+     * @default "service"
+     */
+    readonly mode?: RunMainMode;
 }
 /**
- * Creates {@link Run} for Node.js with global error handling and graceful
- * shutdown.
+ * Runs the main Task as the Node.js program lifecycle.
+ *
+ * Creates one root {@link Run} and aborts it on:
+ *
+ * - `SIGINT`: Ctrl-C on all platforms.
+ * - `SIGTERM`: OS, service, Docker, or Kubernetes termination on Unix.
+ * - `SIGBREAK`: Ctrl-Break on Windows.
+ *
+ * The first signal logs shutdown progress, aborts the root Run, and waits for
+ * the main Task and structured cleanup to finish. A subsequent signal exits
+ * immediately with its conventional signal status, abandoning cleanup. A signal
+ * received during final cleanup still applies signal shutdown behavior.
+ *
+ * A main Task returning {@link Resource} keeps the program running until a
+ * termination signal and is disposed during shutdown. A main Task returning
+ * `void` completes the program immediately. A Resource result transfers
+ * ownership of a live resource that must remain valid after its creating Task
+ * settles.
+ *
+ * Service mode treats graceful signal shutdown as successful. Command mode
+ * preserves conventional signal exit statuses. Every defect reported through
+ * `reportDefect`, including an observer defect that does not abort the Run,
+ * sets `process.exitCode` to 1. The default reporter logs to the configured
+ * Evolu console.
  *
- * 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.
+ * Escaped uncaught exceptions and unhandled rejections remain under Node.js
+ * native reporting and termination.
  *
- * ### Example
+ * ### Service Example
  *
  * ```ts
- * const deps = { ...createRelayDeps(), console };
+ * const deps = { ...createRelayDeps(), console: createConsole() };
  *
- * await using run = createRun(deps);
- * await using stack = new AsyncDisposableStack();
+ * await runMain(deps)(createRelay({ port: 4000 }));
+ * ```
+ *
+ * A Task returning `void` can keep a service alive explicitly when no Resource
+ * owns its lifetime:
+ *
+ * ```ts
+ * await runMain(deps)(async (run) => {
+ *   void run(processMessages);
+ *   return await run(waitForAbort);
+ * });
+ * ```
  *
- * stack.use(await run.orThrow(startRelay({ port: 4000 })));
+ * ### Command Example
  *
- * await run.deps.shutdown;
+ * ```ts
+ * await runMain(command, { mode: "command" });
  * ```
  *
- * @group Node.js Run
+ * @group Node.js Task
  */
-export declare const createRun: CreateRun<RunDeps & ShutdownDep>;
+export declare function runMain<T extends void | Resource>(main: Task<T>, options?: RunMainOptions): Promise<void>;
+/** With custom dependencies. */
+export declare function runMain<D extends object>(deps: RunCustomDeps<D>, options?: RunMainOptions): <T extends void | Resource>(main: Task<T, never, D>) => Promise<void>;
 //# 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,EAQL,KAAK,QAAQ,EAEb,KAAK,aAAa,EAClB,KAAK,IAAI,EACT,KAAK,KAAK,EACX,MAAM,eAAe,CAAC;AAEvB;;;;GAIG;AACH,MAAM,WAAW,qBAAsB,SAAQ,KAAK,CAAC,uBAAuB,CAAC;IAC3E,QAAQ,CAAC,MAAM,EAAE,UAAU,CAAC;CAC7B;AAED,+DAA+D;AAC/D,MAAM,MAAM,UAAU,GAAG,QAAQ,GAAG,SAAS,GAAG,UAAU,CAAC;AAE3D,sDAAsD;AACtD,MAAM,MAAM,WAAW,GAAG,SAAS,GAAG,SAAS,CAAC;AAEhD,mCAAmC;AACnC,MAAM,WAAW,cAAc;IAC7B;;;;;;;;OAQG;IACH,QAAQ,CAAC,IAAI,CAAC,EAAE,WAAW,CAAC;CAC7B;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsDG;AACH,wBAAgB,OAAO,CAAC,CAAC,SAAS,IAAI,GAAG,QAAQ,EAC/C,IAAI,EAAE,IAAI,CAAC,CAAC,CAAC,EACb,OAAO,CAAC,EAAE,cAAc,GACvB,OAAO,CAAC,IAAI,CAAC,CAAC;AACjB,gCAAgC;AAChC,wBAAgB,OAAO,CAAC,CAAC,SAAS,MAAM,EACtC,IAAI,EAAE,aAAa,CAAC,CAAC,CAAC,EACtB,OAAO,CAAC,EAAE,cAAc,GACvB,CAAC,CAAC,SAAS,IAAI,GAAG,QAAQ,EAAE,IAAI,EAAE,IAAI,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,CAAC,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC"}

package/dist/src/Task.js

@@ -3,57 +3,153 @@
  *
  * @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();
+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();
     };
-    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;
+})(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 { createConsole, createRun, isDisposable, ok, waitForAbort, } from "@evolu/common";
+export function runMain(mainOrDeps, { mode = "service" } = {}) {
+    return typeof mainOrDeps === "function"
+        ? runMainInternal(mainOrDeps, {}, mode)
+        : (main) => runMainInternal(main, mainOrDeps, mode);
+}
+const commandExitCodeBySignal = {
+    SIGINT: 130,
+    SIGTERM: 143,
+    SIGBREAK: 149,
+};
+const runMainInternal = async (main, deps, mode) => {
+    const env_1 = { stack: [], error: void 0, hasError: false };
+    try {
+        const console = deps.console ?? createConsole();
+        const mainConsole = console.child("main");
+        let defectReported = false;
+        let receivedSignal = null;
+        const disposer = __addDisposableResource(env_1, new AsyncDisposableStack(), true);
+        const run = disposer.use(createRun({
+            ...deps,
+            console,
+            reportDefect: (reported) => {
+                defectReported = true;
+                process.exitCode = 1;
+                if (deps.reportDefect)
+                    deps.reportDefect(reported);
+                else
+                    console.error(reported);
+            },
+        }));
+        ["SIGINT", "SIGTERM", "SIGBREAK"].forEach((signal) => {
+            const handleSignal = () => {
+                if (receivedSignal !== null) {
+                    mainConsole.warn("Forcing shutdown...");
+                    process.exit(commandExitCodeBySignal[signal]);
+                    return;
+                }
+                receivedSignal = signal;
+                mainConsole.info("Shutting down...");
+                run.abort({ type: "NodeSignalAbortReason", signal });
+            };
+            process.on(signal, handleSignal);
+            run.defer(() => {
+                process.off(signal, handleSignal);
+            });
+        });
+        try {
+            await run(async (run) => {
+                const env_2 = { stack: [], error: void 0, hasError: false };
+                try {
+                    const resource = await run.ok(main);
+                    if (!isDisposable(resource))
+                        return ok();
+                    const _resource = __addDisposableResource(env_2, resource, true);
+                    return await run(waitForAbort);
+                }
+                catch (e_2) {
+                    env_2.error = e_2;
+                    env_2.hasError = true;
+                }
+                finally {
+                    const result_2 = __disposeResources(env_2);
+                    if (result_2)
+                        await result_2;
+                }
+            });
+        }
+        catch {
+            // Aborts are control flow; defects are already handled by reportDefect.
+        }
+        // Move ownership out of the await-using setup safety net so an already
+        // reported finalizer defect can be suppressed during explicit disposal.
+        try {
+            await disposer.move().disposeAsync();
+        }
+        catch {
+            // Finalizer defects are already handled by reportDefect.
+        }
+        if (receivedSignal !== null) {
+            if (defectReported)
+                mainConsole.warn("Shutdown finished with errors");
+            else
+                mainConsole.info("Shutdown complete");
+            if (mode === "command")
+                process.exitCode ??= commandExitCodeBySignal[receivedSignal];
+        }
+    }
+    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;
+    }
 };