@evolu/nodejs 3.0.0-next.2 → 3.0.0

package/dist/src/TestBundle.d.ts

@@ -0,0 +1,113 @@
+/**
+ * Node.js utilities for testing production bundles.
+ *
+ * These utilities use the dedicated `@evolu/nodejs/TestBundle` entry point so
+ * normal `@evolu/nodejs` imports do not evaluate the test toolchain, while
+ * bundle tests do not evaluate unrelated Evolu Node.js adapters.
+ *
+ * The {@link testBundle} function loads its optional Webpack and Vite peer
+ * dependencies only when called.
+ *
+ * @module
+ */
+import { type PositiveDuration, type ReadonlyRecord } from "@evolu/common";
+/** The measured sizes of one bundle. */
+export interface TestBundleSize {
+    readonly rawSizeInBytes: number;
+    /** The Brotli-compressed size using quality 11. */
+    readonly brotliSizeInBytes: number;
+}
+/** Bundle sizes keyed by bundler name and version. */
+export type TestBundleCaseResult = ReadonlyRecord<string, TestBundleSize>;
+/** Case results keyed by case name for size snapshots. */
+export type TestBundleResult = ReadonlyRecord<string, TestBundleCaseResult>;
+/** The measured output supplied to {@link TestBundleCase.verify}. */
+export interface TestBundle extends TestBundleSize {
+    /** The bundler name and version, for example `"vite@8.1.5"`. */
+    readonly bundler: string;
+    readonly code: string;
+    /** The copied artifact, or `null` when no output directory was requested. */
+    readonly outputPath: string | null;
+}
+/** One named bundle test case. */
+export interface TestBundleCase {
+    /**
+     * A JavaScript or erasable-TypeScript entry.
+     *
+     * TypeScript dependencies are supported. TSX and TypeScript syntax that
+     * requires JavaScript generation are not supported by Webpack.
+     */
+    readonly entryPath: string;
+    /** Verifies the default export returned by each emitted bundle. */
+    readonly verify: (value: unknown, bundle: TestBundle) => void | Promise<void>;
+}
+/** Options for producing and verifying equivalent bundles. */
+export interface TestBundleOptions {
+    /** Named cases bundled with every supported bundler. */
+    readonly cases: ReadonlyRecord<string, TestBundleCase>;
+    /**
+     * Package aliases resolved for every case and bundler. Targets must be
+     * absolute paths to modules using JavaScript syntax.
+     */
+    readonly aliases?: ReadonlyRecord<string, string>;
+    /**
+     * Copies emitted bundles into this directory for later inspection. Relative
+     * paths are resolved from the current working directory.
+     */
+    readonly outputDirectory?: string;
+    /** Maximum duration for producing each bundle. Defaults to `"30s"`. */
+    readonly bundlingTimeout?: PositiveDuration;
+    /** Maximum duration for executing each emitted bundle. Defaults to `"5s"`. */
+    readonly timeout?: PositiveDuration;
+}
+/**
+ * Bundles, executes, measures, and verifies named cases with every supported
+ * bundler.
+ *
+ * The fixture must default-export either a value, a promise, or a function that
+ * returns one. The resolved value must be structured-cloneable so it can cross
+ * the worker boundary. All asynchronous work started by the fixture must be
+ * awaited by that returned promise; detached work scheduled after it settles is
+ * outside the execution contract. Verification runs outside the measured
+ * bundle. Each emitted bundle runs in an isolated worker so evaluation errors,
+ * rejected promises, uncaught errors and unhandled rejections observed before
+ * completion, and timeouts fail the test without affecting the test process.
+ * Cases and bundlers form one flattened job list that runs concurrently,
+ * bounded by the CPU parallelism available to the process. If multiple jobs
+ * fail, all failures are reported together with their case and bundler names.
+ * The returned record contains only raw and Brotli byte counts grouped by case
+ * and versioned bundler name, so it can be compared directly with an inline
+ * snapshot.
+ *
+ * ### Example
+ *
+ * ```ts
+ * import { mkdtemp, rm, writeFile } from "node:fs/promises";
+ * import { tmpdir } from "node:os";
+ * import { join } from "node:path";
+ * import { testBundle } from "@evolu/nodejs/TestBundle";
+ *
+ * const directory = await mkdtemp(join(tmpdir(), "evolu-test-bundle-"));
+ * try {
+ *   const entryPath = join(directory, "entry.ts");
+ *   await writeFile(entryPath, "export default { answer: 42 };\n");
+ *   const result = await testBundle({
+ *     cases: {
+ *       example: {
+ *         entryPath,
+ *         verify: (value) => {
+ *           expect(value).toEqual({ answer: 42 });
+ *         },
+ *       },
+ *     },
+ *   });
+ *   for (const size of Object.values(result.example)) {
+ *     expect(size.brotliSizeInBytes).toBeGreaterThan(0);
+ *   }
+ * } finally {
+ *   await rm(directory, { recursive: true });
+ * }
+ * ```
+ */
+export declare const testBundle: ({ cases, aliases, outputDirectory, bundlingTimeout, timeout: executionTimeout, }: TestBundleOptions) => Promise<TestBundleResult>;
+//# sourceMappingURL=TestBundle.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"TestBundle.d.ts","sourceRoot":"","sources":["../../src/TestBundle.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,EAYL,KAAK,gBAAgB,EACrB,KAAK,cAAc,EAQpB,MAAM,eAAe,CAAC;AA4CvB,wCAAwC;AACxC,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC;IAChC,mDAAmD;IACnD,QAAQ,CAAC,iBAAiB,EAAE,MAAM,CAAC;CACpC;AAED,sDAAsD;AACtD,MAAM,MAAM,oBAAoB,GAAG,cAAc,CAAC,MAAM,EAAE,cAAc,CAAC,CAAC;AAE1E,0DAA0D;AAC1D,MAAM,MAAM,gBAAgB,GAAG,cAAc,CAAC,MAAM,EAAE,oBAAoB,CAAC,CAAC;AAE5E,qEAAqE;AACrE,MAAM,WAAW,UAAW,SAAQ,cAAc;IAChD,gEAAgE;IAChE,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,6EAA6E;IAC7E,QAAQ,CAAC,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;CACpC;AAED,kCAAkC;AAClC,MAAM,WAAW,cAAc;IAC7B;;;;;OAKG;IACH,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,mEAAmE;IACnE,QAAQ,CAAC,MAAM,EAAE,CAAC,KAAK,EAAE,OAAO,EAAE,MAAM,EAAE,UAAU,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CAC/E;AAED,8DAA8D;AAC9D,MAAM,WAAW,iBAAiB;IAChC,wDAAwD;IACxD,QAAQ,CAAC,KAAK,EAAE,cAAc,CAAC,MAAM,EAAE,cAAc,CAAC,CAAC;IACvD;;;OAGG;IACH,QAAQ,CAAC,OAAO,CAAC,EAAE,cAAc,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAClD;;;OAGG;IACH,QAAQ,CAAC,eAAe,CAAC,EAAE,MAAM,CAAC;IAClC,uEAAuE;IACvE,QAAQ,CAAC,eAAe,CAAC,EAAE,gBAAgB,CAAC;IAC5C,8EAA8E;IAC9E,QAAQ,CAAC,OAAO,CAAC,EAAE,gBAAgB,CAAC;CACrC;AAOD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgDG;AACH,eAAO,MAAM,UAAU,qFAMpB,iBAAiB,KAAG,OAAO,CAAC,gBAAgB,CAgK9C,CAAC"}

package/dist/src/TestBundle.js

@@ -0,0 +1,503 @@
+/**
+ * Node.js utilities for testing production bundles.
+ *
+ * These utilities use the dedicated `@evolu/nodejs/TestBundle` entry point so
+ * normal `@evolu/nodejs` imports do not evaluate the test toolchain, while
+ * bundle tests do not evaluate unrelated Evolu Node.js adapters.
+ *
+ * The {@link testBundle} function loads its optional Webpack and Vite peer
+ * dependencies only when called.
+ *
+ * @module
+ */
+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 { allSettled, assert, assertType, instanceOf, createRun, durationToMillis, escapeRegExp, filterArray, isErr, mapArray, safelyStringifyUnknownValue, String as StringType, timeout, TimeoutError, tryAsync, } from "@evolu/common";
+import { mkdir, mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { dirname, isAbsolute, join, resolve } from "node:path";
+import { pathToFileURL } from "node:url";
+import { promisify } from "node:util";
+import { isMainThread, parentPort, Worker, workerData, } from "node:worker_threads";
+import { brotliCompressSync, constants as zlibConstants } from "node:zlib";
+import { availableParallelism } from "./Platform.js";
+/**
+ * Bundles, executes, measures, and verifies named cases with every supported
+ * bundler.
+ *
+ * The fixture must default-export either a value, a promise, or a function that
+ * returns one. The resolved value must be structured-cloneable so it can cross
+ * the worker boundary. All asynchronous work started by the fixture must be
+ * awaited by that returned promise; detached work scheduled after it settles is
+ * outside the execution contract. Verification runs outside the measured
+ * bundle. Each emitted bundle runs in an isolated worker so evaluation errors,
+ * rejected promises, uncaught errors and unhandled rejections observed before
+ * completion, and timeouts fail the test without affecting the test process.
+ * Cases and bundlers form one flattened job list that runs concurrently,
+ * bounded by the CPU parallelism available to the process. If multiple jobs
+ * fail, all failures are reported together with their case and bundler names.
+ * The returned record contains only raw and Brotli byte counts grouped by case
+ * and versioned bundler name, so it can be compared directly with an inline
+ * snapshot.
+ *
+ * ### Example
+ *
+ * ```ts
+ * import { mkdtemp, rm, writeFile } from "node:fs/promises";
+ * import { tmpdir } from "node:os";
+ * import { join } from "node:path";
+ * import { testBundle } from "@evolu/nodejs/TestBundle";
+ *
+ * const directory = await mkdtemp(join(tmpdir(), "evolu-test-bundle-"));
+ * try {
+ *   const entryPath = join(directory, "entry.ts");
+ *   await writeFile(entryPath, "export default { answer: 42 };\n");
+ *   const result = await testBundle({
+ *     cases: {
+ *       example: {
+ *         entryPath,
+ *         verify: (value) => {
+ *           expect(value).toEqual({ answer: 42 });
+ *         },
+ *       },
+ *     },
+ *   });
+ *   for (const size of Object.values(result.example)) {
+ *     expect(size.brotliSizeInBytes).toBeGreaterThan(0);
+ *   }
+ * } finally {
+ *   await rm(directory, { recursive: true });
+ * }
+ * ```
+ */
+export const testBundle = async ({ cases, aliases = {}, outputDirectory, bundlingTimeout = "30s", timeout: executionTimeout = "5s", }) => {
+    const env_1 = { stack: [], error: void 0, hasError: false };
+    try {
+        const caseEntries = Object.entries(cases);
+        assert(caseEntries.length > 0, "Bundle tests require at least one case.");
+        for (const [name, path] of Object.entries(aliases)) {
+            assert(isAbsolute(path), `Bundle alias "${name}" target must be an absolute path.`);
+        }
+        const disposer = __addDisposableResource(env_1, new AsyncDisposableStack(), true);
+        const temporaryDirectory = disposer.adopt(await mkdtemp(join(tmpdir(), "evolu-bundle-")), async (temporaryDirectory) => {
+            await rm(temporaryDirectory, { recursive: true, force: true });
+        });
+        const jobs = caseEntries.flatMap(([caseName, testCase]) => testBundlers.map((bundler) => ({ caseName, testCase, bundler })));
+        const run = __addDisposableResource(env_1, createRun(), true);
+        const results = await run.ok(allSettled(jobs, ({ caseName, testCase, bundler }, jobIndex) => async (run) => tryAsync(async () => {
+            const sourceEntryPath = resolve(testCase.entryPath);
+            const bundlerDirectory = join(temporaryDirectory, `${jobIndex}-${bundler.name}`);
+            await mkdir(bundlerDirectory, { recursive: true });
+            const bundlingResult = await run(timeout(runTestBundler(bundler.name, {
+                entryPath: sourceEntryPath,
+                outputDirectory: bundlerDirectory,
+                aliases,
+            }), bundlingTimeout));
+            if (!bundlingResult.ok) {
+                if (TimeoutError.is(bundlingResult.error)) {
+                    throw new Error(`Bundle production timed out after ${durationToMillis(bundlingTimeout)} ms.`);
+                }
+                throw bundlingResult.error;
+            }
+            const output = bundlingResult.value;
+            const executablePath = join(bundlerDirectory, "bundle.mjs");
+            await writeFile(executablePath, output.code);
+            let persistedOutputPath = null;
+            if (outputDirectory) {
+                persistedOutputPath = join(outputDirectory, `${encodeURIComponent(caseName)}.${bundler.name}.mjs`);
+                await mkdir(outputDirectory, { recursive: true });
+                await writeFile(persistedOutputPath, output.code);
+            }
+            const bundle = {
+                bundler: `${bundler.name}@${output.version}`,
+                code: output.code,
+                outputPath: persistedOutputPath,
+                rawSizeInBytes: Buffer.byteLength(output.code),
+                brotliSizeInBytes: brotliCompressSync(output.code, {
+                    params: {
+                        [zlibConstants.BROTLI_PARAM_QUALITY]: 11,
+                    },
+                }).byteLength,
+            };
+            const executionResult = await run(timeout(runTestBundle(executablePath), executionTimeout));
+            if (!executionResult.ok) {
+                if (TimeoutError.is(executionResult.error)) {
+                    throw new Error(`Bundle execution timed out after ${durationToMillis(executionTimeout)} ms.`);
+                }
+                throw executionResult.error;
+            }
+            await testCase.verify(executionResult.value, bundle);
+            return { caseName, bundle };
+        }, (error) => {
+            run.signal.throwIfAborted();
+            return {
+                caseName,
+                bundler: bundler.name,
+                error,
+            };
+        }), { concurrency: availableParallelism() }));
+        const failures = filterArray(results, isErr);
+        if (failures.length > 0) {
+            const errors = mapArray(failures, ({ error: { caseName, bundler, error } }) => {
+                const message = error instanceof Error
+                    ? error.message
+                    : safelyStringifyUnknownValue(error);
+                return Object.assign(new Error(`${caseName} / ${bundler}: ${message}`, { cause: error }), { caseName, bundler });
+            });
+            throw new AggregateError(errors, [
+                "Bundle tests failed.",
+                ...mapArray(errors, (error) => `- ${error.message}`),
+            ].join("\n"));
+        }
+        const bundleEntriesByCase = new Map();
+        for (const [caseName] of caseEntries)
+            bundleEntriesByCase.set(caseName, []);
+        for (const result of results) {
+            assert(result.ok, "Expected every bundle test to succeed.");
+            const { caseName, bundle } = result.value;
+            const entries = bundleEntriesByCase.get(caseName);
+            assert(entries, `Missing bundle test case "${caseName}".`);
+            entries.push([
+                bundle.bundler,
+                {
+                    rawSizeInBytes: bundle.rawSizeInBytes,
+                    brotliSizeInBytes: bundle.brotliSizeInBytes,
+                },
+            ]);
+        }
+        return Object.fromEntries(Array.from(bundleEntriesByCase, ([caseName, entries]) => [
+            caseName,
+            Object.fromEntries(entries),
+        ]));
+    }
+    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;
+    }
+};
+/** A Webpack production adapter for {@link testBundle}. */
+const testWebpackBundler = {
+    name: "webpack",
+    bundle: async ({ entryPath, outputDirectory, aliases }) => {
+        const env_2 = { stack: [], error: void 0, hasError: false };
+        try {
+            const { default: webpack } = await import("webpack");
+            const filename = "webpack.js";
+            const disposer = __addDisposableResource(env_2, new AsyncDisposableStack(), true);
+            const compiler = disposer.adopt(webpack({
+                mode: "production",
+                target: ["web", "es2020"],
+                entry: entryPath,
+                experiments: { outputModule: true, typescript: true },
+                output: {
+                    path: outputDirectory,
+                    filename,
+                    module: true,
+                    library: { type: "module" },
+                },
+                resolve: {
+                    alias: Object.fromEntries(Object.entries(aliases).map(([name, path]) => [`${name}$`, path])),
+                },
+                optimization: {
+                    usedExports: true,
+                    sideEffects: true,
+                    minimize: true,
+                },
+                stats: "errors-only",
+            }), async (compiler) => {
+                await promisify(compiler.close.bind(compiler))();
+            });
+            const stats = await promisify(compiler.run.bind(compiler))();
+            if (stats?.hasErrors())
+                throw new Error(stats.toString("errors-only"));
+            return {
+                code: await readFile(join(outputDirectory, filename), "utf8"),
+                version: webpack.version,
+            };
+        }
+        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;
+        }
+    },
+};
+/** A Vite production adapter for {@link testBundle}. */
+const testViteBundler = {
+    name: "vite",
+    bundle: async ({ entryPath, aliases }) => {
+        const vite = await import("vite");
+        const output = await vite.build({
+            root: dirname(entryPath),
+            configFile: false,
+            envFile: false,
+            logLevel: "silent",
+            resolve: {
+                alias: Object.entries(aliases).map(([name, replacement]) => ({
+                    find: new RegExp(`^${escapeRegExp(name)}$`),
+                    replacement,
+                })),
+            },
+            build: {
+                write: false,
+                minify: true,
+                target: "es2020",
+                lib: {
+                    entry: entryPath,
+                    formats: ["es"],
+                    fileName: () => "vite.js",
+                },
+                rolldownOptions: {
+                    cwd: dirname(entryPath),
+                    output: { codeSplitting: false, comments: false, minify: true },
+                },
+            },
+        });
+        assert(Array.isArray(output), "Vite did not return build outputs.");
+        const outputs = output;
+        assert(outputs.length === 1, "Vite did not return one build output.");
+        const viteOutput = outputs[0];
+        assert(viteOutput, "Vite did not return a build output.");
+        assert(viteOutput.output.length === 1, "Vite did not emit one JavaScript chunk.");
+        const chunk = viteOutput.output[0];
+        assert(chunk, "Vite did not emit a JavaScript chunk.");
+        assertType(StringType, chunk.code);
+        return {
+            code: chunk.code,
+            version: vite.version,
+        };
+    },
+};
+const testBundlers = [
+    testWebpackBundler,
+    testViteBundler,
+];
+const testBundlerWorkerType = "evolu.test-bundler";
+const isTestBundlerWorkerData = (value) => typeof value === "object" &&
+    value !== null &&
+    "type" in value &&
+    value.type === testBundlerWorkerType;
+const runTestBundlerWorker = async ({ bundlerName, options, }) => {
+    try {
+        const bundler = testBundlers.find(({ name }) => name === bundlerName);
+        assert(bundler, `Unknown test bundler "${bundlerName}".`);
+        const value = await bundler.bundle(options);
+        parentPort?.postMessage({
+            ok: true,
+            value,
+        });
+    }
+    catch (error) {
+        const normalized = error instanceof Error ? error : new Error(String(error));
+        parentPort?.postMessage({
+            ok: false,
+            error: {
+                name: normalized.name,
+                message: normalized.message,
+                stack: normalized.stack ?? `${normalized.name}: ${normalized.message}`,
+            },
+        });
+    }
+};
+if (!isMainThread && isTestBundlerWorkerData(workerData)) {
+    void runTestBundlerWorker(workerData);
+}
+const runTestBundler = (bundlerName, options) => async (run) => tryAsync(async () => {
+    const env_3 = { stack: [], error: void 0, hasError: false };
+    try {
+        const worker = __addDisposableResource(env_3, new Worker(new URL(import.meta.url), {
+            execArgv: process.execArgv.filter((argument, index, execArgv) => argument !== "--input-type" &&
+                argument !== "--eval" &&
+                argument !== "-e" &&
+                argument !== "--print" &&
+                argument !== "-p" &&
+                !argument.startsWith("--input-type=") &&
+                !argument.startsWith("--eval=") &&
+                !argument.startsWith("--print=") &&
+                !["--input-type", "--eval", "-e", "--print", "-p"].includes(execArgv[index - 1] ?? "")),
+            workerData: {
+                type: testBundlerWorkerType,
+                bundlerName,
+                options,
+            },
+        }), true);
+        const _ = __addDisposableResource(env_3, run.onAbort(() => {
+            void worker.terminate();
+        }), false);
+        return await new Promise((resolve, reject) => {
+            worker.once("message", (message) => {
+                if (message.ok) {
+                    resolve(message.value);
+                    return;
+                }
+                reject(testBundleWorkerErrorToError(message.error));
+            });
+            worker.once("error", (error) => {
+                assertType(ErrorType, error);
+                reject(error);
+            });
+            worker.once("exit", (code) => {
+                reject(new Error(`Test bundler worker exited with code ${code} before returning a value.`));
+            });
+        });
+    }
+    catch (e_3) {
+        env_3.error = e_3;
+        env_3.hasError = true;
+    }
+    finally {
+        const result_3 = __disposeResources(env_3);
+        if (result_3)
+            await result_3;
+    }
+}, (error) => {
+    run.signal.throwIfAborted();
+    assertType(ErrorType, error);
+    return error;
+});
+const ErrorType = /*#__PURE__*/ instanceOf(globalThis.Error);
+// TODO: Replace the evaluated CommonJS worker with an ESM module worker.
+const testBundleWorkerSource = String.raw `
+const { parentPort, workerData } = require("node:worker_threads");
+
+let completed = false;
+
+const fail = (error) => {
+  if (completed) return;
+  completed = true;
+  const normalized = error instanceof Error ? error : new Error(String(error));
+  parentPort.postMessage({
+    ok: false,
+    error: {
+      name: normalized.name,
+      message: normalized.message,
+      stack: normalized.stack ?? normalized.name + ": " + normalized.message,
+    },
+  });
+};
+
+process.on("unhandledRejection", fail);
+
+(async () => {
+  const module = await import(workerData);
+  if (!("default" in module)) {
+    throw new Error("A bundle test fixture must have a default export.");
+  }
+
+  const exported = module.default;
+  const value = await (typeof exported === "function" ? exported() : exported);
+
+  // Give unhandledRejection one event-loop turn to report detached rejections.
+  await new Promise((resolve) => setImmediate(resolve));
+  if (completed) return;
+  // Keep completed false until cloning succeeds so DataCloneError reaches fail.
+  parentPort.postMessage({ ok: true, value });
+  completed = true;
+})().catch(fail);
+`;
+const testBundleWorkerErrorToError = (workerError) => {
+    const error = new Error(workerError.message);
+    error.name = workerError.name;
+    error.stack = workerError.stack;
+    return error;
+};
+const runTestBundle = (bundlePath) => async (run) => tryAsync(async () => {
+    const env_4 = { stack: [], error: void 0, hasError: false };
+    try {
+        const worker = __addDisposableResource(env_4, new Worker(testBundleWorkerSource, {
+            eval: true,
+            workerData: pathToFileURL(bundlePath).href,
+        }), true);
+        const _ = __addDisposableResource(env_4, run.onAbort(() => {
+            void worker.terminate();
+        }), false);
+        return await new Promise((resolve, reject) => {
+            worker.once("message", (workerMessage) => {
+                if (workerMessage.ok) {
+                    resolve(workerMessage.value);
+                    return;
+                }
+                reject(testBundleWorkerErrorToError(workerMessage.error));
+            });
+            worker.once("error", (error) => {
+                assertType(ErrorType, error);
+                reject(error);
+            });
+            worker.once("exit", (code) => {
+                reject(new Error(`Bundle worker exited with code ${code} before returning a value.`));
+            });
+        });
+    }
+    catch (e_4) {
+        env_4.error = e_4;
+        env_4.hasError = true;
+    }
+    finally {
+        const result_4 = __disposeResources(env_4);
+        if (result_4)
+            await result_4;
+    }
+}, (error) => {
+    run.signal.throwIfAborted();
+    assertType(ErrorType, error);
+    return error;
+});

package/dist/src/Time.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Node.js-specific time utilities.
+ *
+ * @module
+ */
+import { type Brand, Millis, type Time } from "@evolu/common";
+/** {@link Time} with Node.js high-resolution nanosecond readings. */
+export interface NodejsTime extends Time {
+    /** Returns a monotonic high-resolution timestamp in nanoseconds. */
+    readonly hrtime: () => HrTime;
+}
+/** Monotonic high-resolution timestamp in nanoseconds. */
+export type HrTime = bigint & Brand<"HrTime">;
+/** Elapsed nanoseconds measured using {@link HrTime}. */
+export type HrDuration = bigint & Brand<"HrDuration">;
+/** Creates a {@link NodejsTime} using `process.hrtime.bigint()`. */
+export declare const createNodejsTime: () => NodejsTime;
+/**
+ * Returns the elapsed nanoseconds between two high-resolution timestamps.
+ *
+ * Throws if `end` precedes `start`.
+ */
+export declare const hrDurationBetween: (start: HrTime, end: HrTime) => HrDuration;
+/** Converts a high-resolution duration to the nearest millisecond. */
+export declare const hrDurationToMillis: (duration: HrDuration) => Millis;
+/** Converts milliseconds to an exact high-resolution duration. */
+export declare const millisToHrDuration: (millis: Millis) => HrDuration;
+//# sourceMappingURL=Time.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Time.d.ts","sourceRoot":"","sources":["../../src/Time.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAGL,KAAK,KAAK,EACV,MAAM,EACN,KAAK,IAAI,EACV,MAAM,eAAe,CAAC;AAEvB,qEAAqE;AACrE,MAAM,WAAW,UAAW,SAAQ,IAAI;IACtC,oEAAoE;IACpE,QAAQ,CAAC,MAAM,EAAE,MAAM,MAAM,CAAC;CAC/B;AAED,0DAA0D;AAC1D,MAAM,MAAM,MAAM,GAAG,MAAM,GAAG,KAAK,CAAC,QAAQ,CAAC,CAAC;AAE9C,yDAAyD;AACzD,MAAM,MAAM,UAAU,GAAG,MAAM,GAAG,KAAK,CAAC,YAAY,CAAC,CAAC;AAEtD,oEAAoE;AACpE,eAAO,MAAM,gBAAgB,QAAO,UAGlC,CAAC;AAEH;;;;GAIG;AACH,eAAO,MAAM,iBAAiB,UAAW,MAAM,OAAO,MAAM,KAAG,UAG9D,CAAC;AAEF,sEAAsE;AACtE,eAAO,MAAM,kBAAkB,aAAc,UAAU,KAAG,MAKvD,CAAC;AAEJ,kEAAkE;AAClE,eAAO,MAAM,kBAAkB,WAAY,MAAM,KAAG,UACQ,CAAC"}

package/dist/src/Time.js

@@ -0,0 +1,25 @@
+/**
+ * Node.js-specific time utilities.
+ *
+ * @module
+ */
+import { assert, createTime, Millis, } from "@evolu/common";
+/** Creates a {@link NodejsTime} using `process.hrtime.bigint()`. */
+export const createNodejsTime = () => ({
+    ...createTime(),
+    hrtime: () => process.hrtime.bigint(),
+});
+/**
+ * Returns the elapsed nanoseconds between two high-resolution timestamps.
+ *
+ * Throws if `end` precedes `start`.
+ */
+export const hrDurationBetween = (start, end) => {
+    assert(end >= start, "High-resolution end time must not precede start time");
+    return (end - start);
+};
+/** Converts a high-resolution duration to the nearest millisecond. */
+export const hrDurationToMillis = (duration) => Millis.orThrow(Number((duration + nanosecondsPerMillisecond / 2n) / nanosecondsPerMillisecond));
+/** Converts milliseconds to an exact high-resolution duration. */
+export const millisToHrDuration = (millis) => (BigInt(millis) * nanosecondsPerMillisecond);
+const nanosecondsPerMillisecond = 1000000n;

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

@@ -1 +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"}
+{"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,SACrC,MAAM,QACN,MAAM,KACX,gCAWF,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,+BAA+B,SACpC,MAAM,QACN,MAAM,KACX,OAAO,CAAC,eAAe,CAezB,CAAC"}