env-runner 0.2.1 → 0.2.3

package/dist/_chunks/netlify-runner.d.mts

@@ -1,39 +1,20 @@
 import { WorkerHooks } from "./types.mjs";
 import { EnvRunnerData } from "./common-base-runner.mjs";
 import { NodeWorkerEnvRunner } from "./node-worker-runner.mjs";
-interface NetlifyEnvRunnerOptions {
+export interface NetlifyEnvRunnerOptions {
   name: string;
   workerEntry?: string;
   hooks?: WorkerHooks;
   data?: EnvRunnerData;
   /**
-   * Module specifier for the `@netlify/runtime` package, used inside the
-   * worker to call `startRuntime()` (full `globalThis.Netlify` + `caches`
-   * setup). `env-runner` does not depend on `@netlify/runtime`.
-   *
-   * Unlike the other runtime-dependency options, this one takes a **specifier
-   * only**: the runtime has to be instantiated inside the worker thread, and a
-   * live module instance cannot cross that boundary.
-   *
-   * ```ts
-   * new NetlifyEnvRunner({
-   *   name: "app",
-   *   netlifyRuntime: import.meta.resolve("@netlify/runtime"),
-   *   data: { entry },
-   * });
-   * ```
-   *
-   * A bare specifier (e.g. `"@netlify/runtime"`) is resolved from the current
-   * working directory. When omitted, the worker tries
-   * `import("@netlify/runtime")` and falls back to a lightweight
-   * `globalThis.Netlify` shim (env access only) if it isn't installed. Pass
-   * `false` to always use the shim.
+   * `@netlify/runtime` specifier (resolved from cwd), imported inside the worker
+   * since a module instance can't cross into it. Omitted: imported optionally,
+   * else an env-only `globalThis.Netlify` shim. `false` forces the shim.
    */
   netlifyRuntime?: string | URL | false;
 }
-declare class NetlifyEnvRunner extends NodeWorkerEnvRunner {
+export declare class NetlifyEnvRunner extends NodeWorkerEnvRunner {
   constructor(opts: NetlifyEnvRunnerOptions);
   fetch(input: string | URL | Request, init?: RequestInit): Promise<Response>;
   protected _runtimeType(): string;
-}
-export { NetlifyEnvRunner, NetlifyEnvRunnerOptions };
+}

package/dist/_chunks/node-worker-runner.d.mts

@@ -1,6 +1,6 @@
 import { WorkerHooks } from "./types.mjs";
 import { BaseEnvRunner, EnvRunnerData } from "./common-base-runner.mjs";
-declare class NodeWorkerEnvRunner extends BaseEnvRunner {
+export declare class NodeWorkerEnvRunner extends BaseEnvRunner {
   #private;
   constructor(opts: {
     name: string;
@@ -12,5 +12,4 @@ declare class NodeWorkerEnvRunner extends BaseEnvRunner {
   protected _hasRuntime(): boolean;
   protected _runtimeType(): string;
   protected _closeRuntime(): Promise<void>;
-}
-export { NodeWorkerEnvRunner };
+}

package/dist/_chunks/types.d.mts

@@ -1,28 +1,23 @@
 import { IncomingMessage } from "node:http";
 import { Socket } from "node:net";
-/**
- * Handler for proxying HTTP requests to the worker.
- *
- * A relative string input (e.g. `"/path"`) is resolved against a placeholder
- * `http://localhost` origin before dispatching.
- */
-type FetchHandler = (input: string | URL | Request, init?: RequestInit) => Promise<Response>;
+/** Proxy a request to the worker; relative inputs resolve against `http://localhost`. */
+export type FetchHandler = (input: string | URL | Request, init?: RequestInit) => Promise<Response>;
 /** Callback for receiving messages from the worker. */
-type RunnerMessageListener = (data: unknown) => void;
+export type RunnerMessageListener = (data: unknown) => void;
 /** Raw Node.js upgrade request context. */
-interface NodeUpgradeContext {
+export interface NodeUpgradeContext {
   req: IncomingMessage;
   socket: Socket;
   head: any;
 }
 /** Context passed to the upgrade handler for WebSocket upgrades. */
-interface UpgradeContext {
+export interface UpgradeContext {
   node: NodeUpgradeContext;
 }
 /** Handler for proxying WebSocket upgrade requests to the worker. */
-type UpgradeHandler = (context: UpgradeContext) => void;
+export type UpgradeHandler = (context: UpgradeContext) => void;
 /** Bidirectional RPC messaging interface between the runner and worker. */
-interface RunnerRPCHooks {
+export interface RunnerRPCHooks {
   /** Send a message to the worker. */
   sendMessage: (message: unknown) => void;
   /** Register a listener for messages from the worker. */
@@ -30,12 +25,8 @@ interface RunnerRPCHooks {
   /** Remove a previously registered message listener. */
   offMessage: (listener: RunnerMessageListener) => void;
 }
-/**
- * Address reported by the worker once it is ready.
- *
- * Either a TCP `host`/`port` pair or a Unix `socketPath`.
- */
-type WorkerAddress = {
+/** Address reported by the worker once it is ready. */
+export type WorkerAddress = {
   host?: string;
   port: number;
   socketPath?: undefined;
@@ -45,19 +36,19 @@ type WorkerAddress = {
   socketPath: string;
 };
 /** Lifecycle hooks for observing runner state changes. */
-interface WorkerHooks {
+export interface WorkerHooks {
   /** Called when the worker closes, optionally with the cause. */
   onClose?: (worker: EnvRunner, cause?: unknown) => void;
   /** Called when the worker is ready and listening at the given address. */
   onReady?: (worker: EnvRunner, address?: WorkerAddress) => void;
 }
 /** Options for the `rpc()` method. */
-interface RPCOptions {
+export interface RPCOptions {
   /** Timeout in milliseconds before the RPC call rejects. Default: 3000. */
   timeout?: number;
 }
 /** Core runner interface combining lifecycle hooks, RPC, and request proxying. */
-interface EnvRunner extends RunnerRPCHooks, AsyncDisposable {
+export interface EnvRunner extends RunnerRPCHooks, AsyncDisposable {
   /** Whether the worker is ready to accept requests. */
   readonly ready: boolean;
   /** Whether the runner has been closed. */
@@ -83,5 +74,4 @@ interface EnvRunner extends RunnerRPCHooks, AsyncDisposable {
   close(): Promise<void>;
   /** Alias for `close()`, enabling `await using` (explicit resource management). */
   [Symbol.asyncDispose](): Promise<void>;
-}
-export { EnvRunner, FetchHandler, NodeUpgradeContext, RPCOptions, RunnerMessageListener, RunnerRPCHooks, UpgradeContext, UpgradeHandler, WorkerAddress, WorkerHooks };
+}

package/dist/_chunks/vercel-runner.d.mts

@@ -1,7 +1,7 @@
 import { WorkerHooks } from "./types.mjs";
 import { EnvRunnerData } from "./common-base-runner.mjs";
 import { NodeWorkerEnvRunner } from "./node-worker-runner.mjs";
-declare class VercelEnvRunner extends NodeWorkerEnvRunner {
+export declare class VercelEnvRunner extends NodeWorkerEnvRunner {
   constructor(opts: {
     name: string;
     workerEntry?: string;
@@ -10,5 +10,4 @@ declare class VercelEnvRunner extends NodeWorkerEnvRunner {
   });
   fetch(input: string | URL | Request, init?: RequestInit): Promise<Response>;
   protected _runtimeType(): string;
-}
-export { VercelEnvRunner };
+}

package/dist/_chunks/vercel-runner.mjs

@@ -61,6 +61,7 @@ var VercelEnvRunner = class extends NodeWorkerEnvRunner {
 		input = this._resolveFetchInput(input);
 		const headers = new Headers(input instanceof Request ? input.headers : init?.headers);
 		const requestId = generateVercelId();
+		await this._waitForAddress();
 		if (this._address && this._address.port != null && !headers.has("x-vercel-deployment-url")) {
 			const host = this._address.host || "127.0.0.1";
 			headers.set("x-vercel-deployment-url", `http://${host}:${this._address.port}`);

package/dist/cli.mjs

@@ -1,7 +1,7 @@
 import { EnvServer } from "./_chunks/server.mjs";
 import { resolve } from "node:path";
-import { serve } from "srvx";
 import { parseArgs } from "node:util";
+import { serve } from "srvx";
 const { values, positionals } = parseArgs({
 	allowPositionals: true,
 	options: {

package/dist/index.d.mts

@@ -7,11 +7,8 @@ import { VercelEnvRunner } from "./_chunks/vercel-runner.mjs";
 import { NetlifyEnvRunner } from "./_chunks/netlify-runner.mjs";
 import { ServerOptions, ServerPlugin } from "srvx";
 import { Hooks } from "crossws";
-/**
- * Manages an active `EnvRunner` instance, proxying all calls to it.
- * Supports hot-reload, auto-restart on unexpected exit, and message queueing.
- */
-declare class RunnerManager implements EnvRunner, AsyncDisposable {
+/** Proxies an active `EnvRunner` with hot-reload, auto-restart and message queueing. */
+export declare class RunnerManager implements EnvRunner, AsyncDisposable {
   private _runner;
   private _messageQueue;
   private _messageListeners;
@@ -27,30 +24,18 @@ declare class RunnerManager implements EnvRunner, AsyncDisposable {
   get closed(): boolean;
   get address(): WorkerAddress | undefined;
   /**
-   * Replace the active runner with a new one. Closes the previous runner.
-   *
-   * When called without a runner, a fresh one is created via `_createRunner()`
-   * (only available on subclasses with a runner factory, e.g. `EnvServer`).
+   * Replace (and close) the active runner. Without an argument, subclasses with
+   * `_createRunner()` (e.g. `EnvServer`) create a fresh one.
    */
   reload(runner?: EnvRunner): Promise<void>;
   /** Create a fresh runner for argument-less `reload()`. Overridden by subclasses with a runner factory. */
   protected _createRunner(): EnvRunner | Promise<EnvRunner>;
   fetch: FetchHandler;
   protected _fetch(input: string | URL | Request, init?: RequestInit): Promise<Response>;
-  /**
-   * Lazily satisfy a pending `invalidateModule()` with a single entry reload
-   * before serving — concurrent fetches share the same reload. A failed reload
-   * keeps the invalidation pending, so the next fetch retries.
-   */
+  /** Apply a pending invalidation with one shared reload; a failure retries on the next fetch. */
   private _flushInvalidation;
   upgrade: UpgradeHandler;
-  /**
-   * Create a runtime-native WebSocket reverse-proxy plugin for the public srvx
-   * server. Attach it via `serve({ plugins: [await manager.wsSrvxPlugin()] })`:
-   * on Node it proxies the raw upgrade socket to the worker, and on Bun/Deno it
-   * bridges the WebSocket with crossws. The plugin reads the active runner
-   * lazily, so it keeps working across hot-reloads.
-   */
+  /** WebSocket proxy plugin: `serve({ plugins: [await manager.wsSrvxPlugin()] })`. */
   wsSrvxPlugin(): Promise<ServerPlugin>;
   sendMessage(message: unknown): void;
   onMessage(listener: RunnerMessageListener): void;
@@ -60,11 +45,7 @@ declare class RunnerManager implements EnvRunner, AsyncDisposable {
     timeout?: number;
   }): Promise<T>;
   reloadModule(timeout?: number): Promise<void>;
-  /**
-   * Invalidate a virtual module on the active runner and mark the manager
-   * dirty: the next `fetch()` reloads the entry automatically, so callers
-   * don't need to pair the call with an explicit `reloadModule()`.
-   */
+  /** Invalidate a virtual module; the next `fetch()` reloads the entry automatically. */
   invalidateModule(specifier: string, timeout?: number): Promise<void>;
   close(): Promise<void>;
   [Symbol.asyncDispose](): Promise<void>;
@@ -85,14 +66,10 @@ interface LoadRunnerOptions {
   hooks?: WorkerHooks;
   data?: EnvRunnerData;
   execArgv?: string[];
-  /**
-   * Additional runner-specific options (passed through to the runner
-   * constructor) — e.g. `miniflare` (the imported `miniflare` package) for the
-   * `miniflare` runner, which this package never imports itself.
-   */
+  /** Runner-specific constructor options (e.g. `miniflare` for the `miniflare` runner). */
   [key: string]: unknown;
 }
-declare function loadRunner(runner: RunnerName, opts: LoadRunnerOptions): Promise<EnvRunner>;
+export declare function loadRunner(runner: RunnerName, opts: LoadRunnerOptions): Promise<EnvRunner>;
 interface EnvServerOptions {
   /** Runner implementation to use (defaults to `"node-worker"`). */
   runner?: RunnerName;
@@ -110,16 +87,10 @@ interface EnvServerOptions {
   watch?: boolean;
   /** Additional paths to watch (directories or files). */
   watchPaths?: string[];
-  /**
-   * Extra runner-specific constructor options, spread into the runner.
-   *
-   * Runners that build on external packages take them as explicit options —
-   * e.g. `{ miniflare }` for the `miniflare` runner (env-runner never imports
-   * those packages itself).
-   */
+  /** Runner-specific constructor options (e.g. `{ miniflare }`). */
   runnerOptions?: Record<string, unknown>;
 }
-declare class EnvServer extends RunnerManager {
+export declare class EnvServer extends RunnerManager {
   private _opts;
   private _watchers;
   private _reloadTimeout;
@@ -132,17 +103,11 @@ declare class EnvServer extends RunnerManager {
   offReload(listener: () => void): void;
   constructor(opts: EnvServerOptions);
   /**
-   * Start the server by loading and attaching the runner.
-   *
-   * Idempotent — concurrent and repeated calls share one startup. Calling
-   * `start()` explicitly is optional: the first `fetch()` auto-starts the
-   * server. A failed start resets so a later call can retry.
+   * Load and attach the runner. Idempotent and optional (the first `fetch()`
+   * auto-starts); a failed start can be retried.
    */
   start(): Promise<this>;
-  /**
-   * Replace the active runner. When called without an argument, a fresh
-   * runner is created from the server options.
-   */
+  /** Replace the active runner; without an argument, create one from the server options. */
   reload(runner?: EnvRunner): Promise<void>;
   close(): Promise<void>;
   /** Auto-start on first fetch so an explicit `start()` call is optional. */
@@ -161,12 +126,27 @@ interface AppEntryIPC {
   onMessage?: (message: unknown) => void | Promise<void>;
   onClose?: () => void | Promise<void>;
 }
-interface AppEntry {
+/**
+ * User entry module. Other srvx `ServerOptions` are forwarded to `serve()`,
+ * except {@link RESERVED_SERVER_OPTIONS}.
+ */
+interface AppEntry extends Omit<ServerOptions, "fetch"> {
   fetch: ServerOptions["fetch"];
   upgrade?: (context: UpgradeContext) => void;
   websocket?: Partial<Hooks>;
-  middleware?: ServerOptions["middleware"];
-  plugins?: ServerOptions["plugins"];
   ipc?: AppEntryIPC;
 }
-export { type AppEntry, type AppEntryIPC, type AppEntryIPCContext, BaseEnvRunner, DenoProcessEnvRunner, type EnvRunnerData as DenoProcessEnvRunnerData, type EnvRunner, type EnvRunnerData, EnvServer, type EnvServerOptions, type FetchHandler, type LoadRunnerOptions, MiniflareEnvRunner, type MiniflareEnvRunnerOptions, type MiniflareExportInfo, NetlifyEnvRunner, type NodeUpgradeContext, type RPCOptions, RunnerManager, type RunnerMessageListener, type RunnerName, type RunnerRPCHooks, type RuntimeDep, type TransformResult, type UpgradeContext, type UpgradeHandler, VercelEnvRunner, type VirtualModuleSource, type VirtualModules, type WorkerAddress, type WorkerHooks, loadRunner, resolveRuntimeDep };
+/** Worker-owned srvx options: the worker listens on a random loopback port behind the proxy. */
+export declare const RESERVED_SERVER_OPTIONS: ["port", "hostname", "protocol", "tls", "silent", "manual", "gracefulShutdown"];
+/**
+ * srvx spreads `node`/`bun`/`deno` after its resolved listener options, so
+ * these would bypass {@link RESERVED_SERVER_OPTIONS}. `node.http2` needs TLS.
+ */
+export declare const RESERVED_RUNTIME_OPTIONS: {
+  readonly node: readonly ["port", "host", "path", "http2", "cert", "key", "passphrase"];
+  readonly bun: readonly ["port", "hostname", "unix", "tls"];
+  readonly deno: readonly ["port", "hostname", "path", "cert", "key"];
+};
+/** Callers add `fetch` (bound lazily so reloads swap it) and the crossws plugin. */
+export declare function toServerOptions(entry: AppEntry): Omit<ServerOptions, "fetch">;
+export { type AppEntry, type AppEntryIPC, type AppEntryIPCContext, BaseEnvRunner, DenoProcessEnvRunner, type EnvRunnerData as DenoProcessEnvRunnerData, type EnvRunner, type EnvRunnerData, type EnvServerOptions, type FetchHandler, type LoadRunnerOptions, MiniflareEnvRunner, type MiniflareEnvRunnerOptions, type MiniflareExportInfo, NetlifyEnvRunner, type NodeUpgradeContext, type RPCOptions, type RunnerMessageListener, type RunnerName, type RunnerRPCHooks, type RuntimeDep, type TransformResult, type UpgradeContext, type UpgradeHandler, VercelEnvRunner, type VirtualModuleSource, type VirtualModules, type WorkerAddress, type WorkerHooks, resolveRuntimeDep };

package/dist/index.mjs

@@ -1,8 +1,9 @@
 import { BaseEnvRunner } from "./_chunks/common-base-runner.mjs";
 import { EnvServer, RunnerManager, loadRunner } from "./_chunks/server.mjs";
+import { RESERVED_RUNTIME_OPTIONS, RESERVED_SERVER_OPTIONS, toServerOptions } from "./_chunks/common-worker-utils.mjs";
 import { resolveRuntimeDep } from "./_chunks/common-runtime-deps.mjs";
 import { DenoProcessEnvRunner } from "./_chunks/deno-process-runner.mjs";
 import { MiniflareEnvRunner } from "./_chunks/miniflare-runner.mjs";
 import { VercelEnvRunner } from "./_chunks/vercel-runner.mjs";
 import { NetlifyEnvRunner } from "./_chunks/netlify-runner.mjs";
-export { BaseEnvRunner, DenoProcessEnvRunner, EnvServer, MiniflareEnvRunner, NetlifyEnvRunner, RunnerManager, VercelEnvRunner, loadRunner, resolveRuntimeDep };
+export { BaseEnvRunner, DenoProcessEnvRunner, EnvServer, MiniflareEnvRunner, NetlifyEnvRunner, RESERVED_RUNTIME_OPTIONS, RESERVED_SERVER_OPTIONS, RunnerManager, VercelEnvRunner, loadRunner, resolveRuntimeDep, toServerOptions };

package/dist/runners/bun-process/runner.d.mts

@@ -1,6 +1,6 @@
 import { WorkerHooks } from "../../_chunks/types.mjs";
 import { BaseEnvRunner, EnvRunnerData } from "../../_chunks/common-base-runner.mjs";
-declare class BunProcessEnvRunner extends BaseEnvRunner {
+export declare class BunProcessEnvRunner extends BaseEnvRunner {
   #private;
   constructor(opts: {
     name: string;
@@ -14,4 +14,4 @@ declare class BunProcessEnvRunner extends BaseEnvRunner {
   protected _runtimeType(): string;
   protected _closeRuntime(): Promise<void>;
 }
-export { BunProcessEnvRunner, type EnvRunnerData as BunProcessEnvRunnerData };
+export type { EnvRunnerData as BunProcessEnvRunnerData };

package/dist/runners/bun-process/runner.mjs

@@ -2,8 +2,8 @@ import { BaseEnvRunner } from "../../_chunks/common-base-runner.mjs";
 import { hostEnv } from "../../_chunks/common-host-env.mjs";
 import { fileURLToPath } from "node:url";
 import { existsSync } from "node:fs";
-import { execSync, spawn } from "node:child_process";
 import { join } from "node:path";
+import { execSync, spawn } from "node:child_process";
 import { homedir } from "node:os";
 let _defaultEntry;
 let _bunPath;

package/dist/runners/bun-process/worker.mjs

@@ -1,4 +1,4 @@
-import { handleInvalidateModule, isVirtualSpecifier, parseServerAddress, registerVirtualModules, reloadEntryModule, resolveEntry } from "../../_chunks/common-worker-utils.mjs";
+import { handleInvalidateModule, isVirtualSpecifier, parseServerAddress, registerVirtualModules, reloadEntryModule, resolveEntry, toServerOptions } from "../../_chunks/common-worker-utils.mjs";
 import { serve } from "srvx";
 import { plugin } from "crossws/server";
 process.on("disconnect", () => process.exit(0));
@@ -7,9 +7,16 @@ const sendMessage = (message) => process.send(message);
 const virtualEntry = isVirtualSpecifier(data.entry, data.virtual);
 let unregisterVirtualModules;
 let entry;
+let server;
 try {
 	unregisterVirtualModules = await registerVirtualModules(data.virtual);
 	entry = await resolveEntry(data.entry, virtualEntry);
+	server = serve({
+		...toServerOptions(entry),
+		fetch: (request) => entry.fetch(request),
+		plugins: [...entry.plugins || [], ...entry.websocket ? [plugin(entry.websocket)] : []]
+	});
+	await server.ready();
 } catch (error) {
 	const message = error?.message || String(error);
 	sendMessage({
@@ -19,16 +26,6 @@ try {
 	console.error(`[env-runner] worker init failed: ${message}`);
 	process.exit(1);
 }
-const server = serve({
-	port: 0,
-	hostname: "127.0.0.1",
-	silent: true,
-	fetch: (request) => entry.fetch(request),
-	middleware: entry.middleware,
-	plugins: [...entry.plugins || [], ...entry.websocket ? [plugin(entry.websocket)] : []],
-	gracefulShutdown: false
-});
-await server.ready();
 if (entry.upgrade) server.node?.server?.on("upgrade", (req, socket, head) => {
 	entry.upgrade({ node: {
 		req,

package/dist/runners/deno-process/worker.mjs

@@ -1,16 +1,22 @@
-import { handleInvalidateModule, isVirtualSpecifier, parseServerAddress, registerVirtualModules, reloadEntryModule, resolveEntry } from "../../_chunks/common-worker-utils.mjs";
+import { handleInvalidateModule, isVirtualSpecifier, parseServerAddress, registerVirtualModules, reloadEntryModule, resolveEntry, toServerOptions } from "../../_chunks/common-worker-utils.mjs";
 import { serve } from "srvx";
 import { plugin } from "crossws/server";
+process.on("disconnect", () => process.exit(0));
 const data = JSON.parse(process.env.ENV_RUNNER_DATA || "{}");
-const _stdout = globalThis.Deno?.stdout ? { write: (s) => globalThis.Deno.stdout.writeSync(new TextEncoder().encode(s)) } : process.stdout;
-const sendMessage = (message) => _stdout.write(JSON.stringify(message) + "\n");
-const _stdin = globalThis.Deno?.stdin?.readable || process.stdin;
+const sendMessage = (message) => process.send(message);
 const virtualEntry = isVirtualSpecifier(data.entry, data.virtual);
 let unregisterVirtualModules;
 let entry;
+let server;
 try {
 	unregisterVirtualModules = await registerVirtualModules(data.virtual);
 	entry = await resolveEntry(data.entry, virtualEntry);
+	server = serve({
+		...toServerOptions(entry),
+		fetch: (request) => entry.fetch(request),
+		plugins: [...entry.plugins || [], ...entry.websocket ? [plugin(entry.websocket)] : []]
+	});
+	await server.ready();
 } catch (error) {
 	const message = error?.message || String(error);
 	sendMessage({
@@ -20,16 +26,6 @@ try {
 	console.error(`[env-runner] worker init failed: ${message}`);
 	process.exit(1);
 }
-const server = serve({
-	port: 0,
-	hostname: "127.0.0.1",
-	silent: true,
-	fetch: (request) => entry.fetch(request),
-	middleware: entry.middleware,
-	plugins: [...entry.plugins || [], ...entry.websocket ? [plugin(entry.websocket)] : []],
-	gracefulShutdown: false
-});
-await server.ready();
 if (entry.upgrade) server.node?.server?.on("upgrade", (req, socket, head) => {
 	entry.upgrade({ node: {
 		req,
@@ -38,41 +34,21 @@ if (entry.upgrade) server.node?.server?.on("upgrade", (req, socket, head) => {
 	} });
 });
 if (entry.ipc) await entry.ipc.onOpen?.({ sendMessage });
-sendMessage({ address: parseServerAddress(server) });
-async function readMessages() {
-	const decoder = new TextDecoder();
-	let buffer = "";
-	for await (const chunk of _stdin) {
-		buffer += decoder.decode(chunk, { stream: true });
-		let newlineIdx;
-		while ((newlineIdx = buffer.indexOf("\n")) !== -1) {
-			const line = buffer.slice(0, newlineIdx);
-			buffer = buffer.slice(newlineIdx + 1);
-			if (!line) continue;
-			let message;
-			try {
-				message = JSON.parse(line);
-			} catch {
-				continue;
-			}
-			await handleMessage(message);
-		}
-	}
-}
-async function handleMessage(message) {
+process.send({ address: parseServerAddress(server) });
+process.on("message", async (message) => {
 	if (message?.event === "shutdown") {
 		Promise.resolve(entry.ipc?.onClose?.()).then(() => server.close()).then(() => {
 			unregisterVirtualModules();
-			sendMessage({ event: "exit" });
+			process.send({ event: "exit" });
 		});
 		return;
 	}
 	if (message?.event === "reload-module") {
 		try {
 			entry = await reloadEntryModule(data.entry, entry, sendMessage, virtualEntry);
-			sendMessage({ event: "module-reloaded" });
+			process.send({ event: "module-reloaded" });
 		} catch (error) {
-			sendMessage({
+			process.send({
 				event: "module-reloaded",
 				error: error?.message || String(error)
 			});
@@ -84,13 +60,12 @@ async function handleMessage(message) {
 		return;
 	}
 	if (message?.type === "ping") {
-		sendMessage({
+		process.send({
 			type: "pong",
 			data: message.data
 		});
 		return;
 	}
 	entry.ipc?.onMessage?.(message);
-}
-readMessages().catch(() => {});
+});
 export {};

package/dist/runners/node-process/runner.d.mts

@@ -1,6 +1,6 @@
 import { WorkerHooks } from "../../_chunks/types.mjs";
 import { BaseEnvRunner, EnvRunnerData } from "../../_chunks/common-base-runner.mjs";
-declare class NodeProcessEnvRunner extends BaseEnvRunner {
+export declare class NodeProcessEnvRunner extends BaseEnvRunner {
   #private;
   constructor(opts: {
     name: string;
@@ -14,4 +14,4 @@ declare class NodeProcessEnvRunner extends BaseEnvRunner {
   protected _runtimeType(): string;
   protected _closeRuntime(): Promise<void>;
 }
-export { NodeProcessEnvRunner, type EnvRunnerData as ProcessEnvRunnerData };
+export type { EnvRunnerData as ProcessEnvRunnerData };

package/dist/runners/node-process/worker.mjs

@@ -1,4 +1,4 @@
-import { handleInvalidateModule, isVirtualSpecifier, parseServerAddress, registerVirtualModules, reloadEntryModule, resolveEntry } from "../../_chunks/common-worker-utils.mjs";
+import { handleInvalidateModule, isVirtualSpecifier, parseServerAddress, registerVirtualModules, reloadEntryModule, resolveEntry, toServerOptions } from "../../_chunks/common-worker-utils.mjs";
 import { serve } from "srvx";
 import { plugin } from "crossws/server";
 process.on("disconnect", () => process.exit(0));
@@ -7,9 +7,16 @@ const sendMessage = (message) => process.send(message);
 const virtualEntry = isVirtualSpecifier(data.entry, data.virtual);
 let unregisterVirtualModules;
 let entry;
+let server;
 try {
 	unregisterVirtualModules = await registerVirtualModules(data.virtual);
 	entry = await resolveEntry(data.entry, virtualEntry);
+	server = serve({
+		...toServerOptions(entry),
+		fetch: (request) => entry.fetch(request),
+		plugins: [...entry.plugins || [], ...entry.websocket ? [plugin(entry.websocket)] : []]
+	});
+	await server.ready();
 } catch (error) {
 	const message = error?.message || String(error);
 	sendMessage({
@@ -19,16 +26,6 @@ try {
 	console.error(`[env-runner] worker init failed: ${message}`);
 	process.exit(1);
 }
-const server = serve({
-	port: 0,
-	hostname: "127.0.0.1",
-	silent: true,
-	fetch: (request) => entry.fetch(request),
-	middleware: entry.middleware,
-	plugins: [...entry.plugins || [], ...entry.websocket ? [plugin(entry.websocket)] : []],
-	gracefulShutdown: false
-});
-await server.ready();
 if (entry.upgrade) server.node?.server?.on("upgrade", (req, socket, head) => {
 	entry.upgrade({ node: {
 		req,

package/dist/runners/node-worker/worker.mjs

@@ -1,4 +1,4 @@
-import { handleInvalidateModule, isVirtualSpecifier, parseServerAddress, registerVirtualModules, reloadEntryModule, resolveEntry } from "../../_chunks/common-worker-utils.mjs";
+import { handleInvalidateModule, isVirtualSpecifier, parseServerAddress, registerVirtualModules, reloadEntryModule, resolveEntry, toServerOptions } from "../../_chunks/common-worker-utils.mjs";
 import { parentPort, workerData } from "node:worker_threads";
 import { serve } from "srvx";
 import { plugin } from "crossws/server";
@@ -7,9 +7,16 @@ const sendMessage = (message) => parentPort?.postMessage(message);
 const virtualEntry = isVirtualSpecifier(data.entry, data.virtual);
 let unregisterVirtualModules;
 let entry;
+let server;
 try {
 	unregisterVirtualModules = await registerVirtualModules(data.virtual);
 	entry = await resolveEntry(data.entry, virtualEntry);
+	server = serve({
+		...toServerOptions(entry),
+		fetch: (request) => entry.fetch(request),
+		plugins: [...entry.plugins || [], ...entry.websocket ? [plugin(entry.websocket)] : []]
+	});
+	await server.ready();
 } catch (error) {
 	const message = error?.message || String(error);
 	sendMessage({
@@ -19,16 +26,6 @@ try {
 	console.error(`[env-runner] worker init failed: ${message}`);
 	process.exit(1);
 }
-const server = serve({
-	port: 0,
-	hostname: "127.0.0.1",
-	silent: true,
-	fetch: (request) => entry.fetch(request),
-	middleware: entry.middleware,
-	plugins: [...entry.plugins || [], ...entry.websocket ? [plugin(entry.websocket)] : []],
-	gracefulShutdown: false
-});
-await server.ready();
 if (entry.upgrade) server.node?.server?.on("upgrade", (req, socket, head) => {
 	entry.upgrade({ node: {
 		req,

package/dist/runners/self/runner.d.mts

@@ -1,6 +1,6 @@
 import { WorkerHooks } from "../../_chunks/types.mjs";
 import { BaseEnvRunner, EnvRunnerData } from "../../_chunks/common-base-runner.mjs";
-declare class SelfEnvRunner extends BaseEnvRunner {
+export declare class SelfEnvRunner extends BaseEnvRunner {
   #private;
   constructor(opts: {
     name: string;
@@ -22,4 +22,4 @@ declare class SelfEnvRunner extends BaseEnvRunner {
   protected _runtimeType(): string;
   protected _closeRuntime(): Promise<void>;
 }
-export { SelfEnvRunner, type EnvRunnerData as SelfEnvRunnerData };
+export type { EnvRunnerData as SelfEnvRunnerData };