env-runner 0.2.0 → 0.2.2

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

@@ -11,19 +11,19 @@ import { Socket } from "node:net";
  * dependency stays owned by the application. It is only imported here as a
  * fallback when neither is passed.
  */
-interface WranglerModule {
+export interface WranglerModule {
   unstable_readConfig?: (...args: any[]) => any;
   unstable_getMiniflareWorkerOptions?: (...args: any[]) => any;
   [key: string]: unknown;
 }
 /** Raw (snake_case) Wrangler config object, mirroring `wrangler.json` contents. */
-type WranglerInlineConfig = Record<string, unknown>;
+export type WranglerInlineConfig = Record<string, unknown>;
 /** Result from a module transform (compatible with Vite's `TransformResult`). */
-interface TransformResult {
+export interface TransformResult {
   code: string;
 }
 /** Detected or declared export for auto-wiring Durable Object / Entrypoint bindings. */
-interface MiniflareExportInfo {
+export interface MiniflareExportInfo {
   type?: "DurableObject" | "WorkerEntrypoint" | "class";
 }
 /**
@@ -34,7 +34,7 @@ interface MiniflareExportInfo {
  * the application. The runner only falls back to importing it itself when this
  * is omitted.
  */
-interface MiniflareModule {
+export interface MiniflareModule {
   Miniflare: new (options: any) => any;
   /**
    * Newest compatibility date supported by the installed `workerd` binary,
@@ -43,7 +43,7 @@ interface MiniflareModule {
   supportedCompatibilityDate?: string;
   [key: string]: unknown;
 }
-interface MiniflareEnvRunnerOptions {
+export interface MiniflareEnvRunnerOptions {
   name: string;
   hooks?: WorkerHooks;
   data?: EnvRunnerData;
@@ -143,7 +143,7 @@ interface MiniflareEnvRunnerOptions {
    */
   wranglerModule?: RuntimeDep<WranglerModule>;
 }
-declare class MiniflareEnvRunner extends BaseEnvRunner {
+export declare class MiniflareEnvRunner extends BaseEnvRunner {
   #private;
   constructor(opts: MiniflareEnvRunnerOptions);
   /** Dispose all persistent Miniflare instances from the cache. */
@@ -182,5 +182,4 @@ declare class MiniflareEnvRunner extends BaseEnvRunner {
       head: any;
     };
   }): Promise<void>;
-}
-export { MiniflareEnvRunner, MiniflareEnvRunnerOptions, MiniflareExportInfo, MiniflareModule, TransformResult, WranglerInlineConfig, WranglerModule };
+}

package/dist/_chunks/miniflare-runner.mjs

@@ -1,23 +1,24 @@
 import { expandVirtualInvalidation, stripVirtualTypeScript, virtualModuleFormat } from "./virtual-loader.mjs";
 import { BaseEnvRunner } from "./common-base-runner.mjs";
+import { isVirtualSpecifier } from "./common-worker-utils.mjs";
 import { resolveRuntimeDep } from "./common-runtime-deps.mjs";
 import { init, parse } from "./libs/cjs-module-lexer.mjs";
 import { init as init$1, parse as parse$1 } from "./libs/es-module-lexer.mjs";
-import { isVirtualSpecifier } from "./common-worker-utils.mjs";
 import { createRequire } from "node:module";
 import { proxyUpgrade } from "httpxy";
 import { fileURLToPath } from "node:url";
 import { existsSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
-import { resolveModulePath } from "exsolve";
 import { basename, dirname, extname, isAbsolute, join, resolve } from "node:path";
+import { resolveModulePath } from "exsolve";
 import { tmpdir } from "node:os";
 const IPC_PATH = "/__env_runner_ipc";
 const IPC_BINDING = "__ENV_RUNNER_IPC";
+const UNSAFE_EVAL_BINDING = "__ENV_RUNNER_UNSAFE_EVAL__";
 function generateWrapper(entryPath, opts) {
 	const staticReExport = opts?.dynamicOnly ? "" : `export * from ${JSON.stringify(entryPath)};`;
 	const explicitExports = opts?.dynamicOnly && opts.exports?.length ? opts.exports.map((name) => `export { ${name} } from ${JSON.stringify(entryPath)};`).join("\n") : "";
 	const fetchBody = opts?.captureErrors ?? true ? `try {
-      return await entryFetch(request, env, ctx);
+      return await __server.fetch(request, env, ctx);
     } catch (e) {
       const error = e instanceof Error ? e : new Error(String(e));
       const body = JSON.stringify({
@@ -29,7 +30,7 @@ function generateWrapper(entryPath, opts) {
         status: 500,
         headers: { "Content-Type": "application/json", "X-Env-Runner-Error": "1" },
       });
-    }` : `return entryFetch(request, env, ctx);`;
+    }` : `return __server.fetch(request, env, ctx);`;
 	return `import __process from "node:process";
 if (!globalThis.process) { globalThis.process = __process; }
 ${staticReExport}
@@ -37,12 +38,87 @@ ${explicitExports}
 
 const __IPC_PATH = "${IPC_PATH}";
 const __IPC_BINDING = "${IPC_BINDING}";
+const __UNSAFE_EVAL_BINDING = "${UNSAFE_EVAL_BINDING}";
 const __entryPath = ${JSON.stringify(entryPath)};
 let __userEntry;
+let __server;
 let __ipcInitialized = false;
 let __serverWs;
 let __currentEnv;
 
+const __userEnvs = new WeakMap();
+
+// \`env\` without env-runner's internal bindings (cached per env object).
+function __userEnv(env) {
+  let userEnv = __userEnvs.get(env);
+  if (!userEnv) {
+    userEnv = { ...env };
+    delete userEnv[__IPC_BINDING];
+    delete userEnv[__UNSAFE_EVAL_BINDING];
+    __userEnvs.set(env, userEnv);
+  }
+  return userEnv;
+}
+
+// Mirrors srvx's CloudflareServer (srvx/cloudflare): plugins, then the
+// \`error\` handler as the outermost middleware, then the middleware chain.
+function __createServer(entry) {
+  const server = {
+    runtime: "cloudflare",
+    options: {
+      ...entry,
+      middleware: [...(entry.middleware || [])],
+      fetch: entry.fetch
+        ? (request) =>
+            entry.fetch(request, request.runtime?.cloudflare?.env, request.runtime?.cloudflare?.context)
+        : () => new Response("No fetch handler exported", { status: 500 }),
+    },
+    serve() {},
+    ready: () => Promise.resolve(server),
+    close: () => Promise.resolve(),
+  };
+  for (const plugin of entry.plugins || []) {
+    plugin(server);
+  }
+  const errorHandler = server.options.error;
+  if (errorHandler) {
+    server.options.middleware.unshift((_request, next) => {
+      try {
+        const res = next();
+        return typeof res?.then === "function" ? res.then(undefined, (error) => errorHandler(error)) : res;
+      } catch (error) {
+        return errorHandler(error);
+      }
+    });
+  }
+  let handler = server.options.fetch;
+  const middleware = server.options.middleware;
+  for (let i = middleware.length - 1; i >= 0; i--) {
+    const mw = middleware[i];
+    const next = handler;
+    handler = (request) => mw(request, () => next(request));
+  }
+  server.fetch = (request, env, context) => {
+    const userEnv = __userEnv(env);
+    Object.defineProperties(request, {
+      waitUntil: { value: context.waitUntil.bind(context) },
+      runtime: {
+        enumerable: true,
+        value: { name: "cloudflare", cloudflare: { env: userEnv, context } },
+      },
+      ip: {
+        enumerable: true,
+        configurable: true,
+        get() {
+          return request.headers.get("cf-connecting-ip");
+        },
+      },
+    });
+    return handler(request);
+  };
+  return server;
+}
+
 async function __loadEntry(env, path) {
   globalThis.__ENV_RUNNER_UNSAFE_EVAL__ = env.__ENV_RUNNER_UNSAFE_EVAL__;
   const importFn = env.__ENV_RUNNER_UNSAFE_EVAL__.newAsyncFunction(
@@ -84,10 +160,12 @@ async function __handleWsMessage(env, data) {
     const version = msg.version || 0;
     try {
       const newEntry = await __loadEntry(env, __entryPath + "?t=" + version);
+      const newServer = __createServer(newEntry);
       if (__userEntry?.ipc?.onClose) {
         await __userEntry.ipc.onClose();
       }
       __userEntry = newEntry;
+      __server = newServer;
       __crosswsAdapter = undefined;
       __ipcInitialized = false;
       if (__userEntry.ipc?.onOpen) {
@@ -130,7 +208,9 @@ export default {
     if (url.pathname === __IPC_PATH && request.headers.get("upgrade") === "websocket") {
       try {
         if (!__userEntry) {
-          __userEntry = await __loadEntry(env, __entryPath);
+          const entry = await __loadEntry(env, __entryPath);
+          __server = __createServer(entry);
+          __userEntry = entry;
         }
       } catch (e) {
         return new Response("Failed to load entry: " + String(e), { status: 500 });
@@ -164,13 +244,9 @@ export default {
     // Handle WebSocket upgrade via crossws cloudflare adapter
     if (__userEntry.websocket && request.headers.get("upgrade") === "websocket") {
       const adapter = await __initCrossws(env, __userEntry.websocket);
-      return adapter.handleUpgrade(request, env, ctx);
+      return adapter.handleUpgrade(request, __userEnv(env), ctx);
     }
 
-    const entryFetch = __userEntry.fetch;
-    if (!entryFetch) {
-      return new Response("No fetch handler exported", { status: 500 });
-    }
     __currentEnv = env;
     try {
       ${fetchBody}
@@ -408,8 +484,12 @@ var MiniflareEnvRunner = class extends BaseEnvRunner {
 		for (let i = 0; i < 5 && !this._address && !this.closed; i++) await new Promise((r) => setTimeout(r, 100 * Math.pow(2, i)));
 		if (!this.#miniflare || this.closed) return new Response("miniflare env runner is unavailable", { status: 503 });
 		const resolved = this._resolveFetchInput(input);
-		const url = typeof resolved === "string" ? resolved : resolved instanceof URL ? resolved.href : resolved.url;
-		const res = await this.#miniflare.dispatchFetch(url, init);
+		const request = typeof resolved === "string" || resolved instanceof URL ? new Request(resolved, init) : new Request(new Request(resolved.url, resolved), {
+			...init,
+			referrer: init?.referrer ?? resolved.referrer,
+			referrerPolicy: init?.referrerPolicy ?? resolved.referrerPolicy
+		});
+		const res = await this.#miniflare.dispatchFetch(request.url, request);
 		if (res instanceof Response) return res;
 		return new Response(res.body, {
 			status: res.status,
@@ -578,7 +658,7 @@ var MiniflareEnvRunner = class extends BaseEnvRunner {
 			});
 			options.scriptPath = entryDir + "/__env_runner_wrapper.mjs";
 			if (!options.modulesRoot) options.modulesRoot = "/";
-			options.unsafeEvalBinding = "__ENV_RUNNER_UNSAFE_EVAL__";
+			options.unsafeEvalBinding = UNSAFE_EVAL_BINDING;
 			options.serviceBindings = {
 				...options.serviceBindings || {},
 				[IPC_BINDING]: async (request) => {
@@ -799,16 +879,15 @@ function applyVirtualVersions(code, versions) {
 	let out = "";
 	let last = 0;
 	for (const imp of imports) {
-		let specifier = imp.n;
-		if (specifier === void 0 && imp.d > -1) {
-			const expr = code.slice(imp.s, imp.e);
-			if (expr.length > 1 && expr[0] === "`" && expr.endsWith("`") && !expr.includes("${")) specifier = expr.slice(1, -1);
-		}
+		if (imp.type === "import-meta") continue;
+		const dynamic = imp.type === "dynamic";
+		if (dynamic && imp.glob) continue;
+		const specifier = imp.specifier;
 		const version = specifier === void 0 ? void 0 : versions.get(specifier);
 		if (!version) continue;
 		const versioned = `${specifier}?v=${version}`;
-		out += code.slice(last, imp.s) + (imp.d > -1 ? JSON.stringify(versioned) : versioned);
-		last = imp.e;
+		out += code.slice(last, imp.start) + (dynamic ? JSON.stringify(versioned) : versioned);
+		last = imp.end;
 	}
 	return out + code.slice(last);
 }

package/dist/_chunks/netlify-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";
-interface NetlifyEnvRunnerOptions {
+export interface NetlifyEnvRunnerOptions {
   name: string;
   workerEntry?: string;
   hooks?: WorkerHooks;
@@ -31,9 +31,8 @@ interface NetlifyEnvRunnerOptions {
    */
   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/node-worker-runner.mjs

@@ -1,4 +1,5 @@
 import { BaseEnvRunner } from "./common-base-runner.mjs";
+import { hostEnv } from "./common-host-env.mjs";
 import { fileURLToPath } from "node:url";
 import { existsSync } from "node:fs";
 import { Worker } from "node:worker_threads";
@@ -37,7 +38,7 @@ var NodeWorkerEnvRunner = class extends BaseEnvRunner {
 			return;
 		}
 		const worker = new Worker(this._workerEntry, {
-			env: { ...process.env },
+			env: hostEnv(),
 			workerData: {
 				name: this._name,
 				...this._data

package/dist/_chunks/types.d.mts

@@ -6,23 +6,23 @@ import { Socket } from "node:net";
  * 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>;
+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. */
@@ -35,7 +35,7 @@ interface RunnerRPCHooks {
  *
  * Either a TCP `host`/`port` pair or a Unix `socketPath`.
  */
-type WorkerAddress = {
+export type WorkerAddress = {
   host?: string;
   port: number;
   socketPath?: undefined;
@@ -45,19 +45,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 +83,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/index.d.mts

@@ -11,7 +11,7 @@ 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 {
+export declare class RunnerManager implements EnvRunner, AsyncDisposable {
   private _runner;
   private _messageQueue;
   private _messageListeners;
@@ -92,7 +92,7 @@ interface LoadRunnerOptions {
    */
   [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;
@@ -119,7 +119,7 @@ interface EnvServerOptions {
    */
   runnerOptions?: Record<string, unknown>;
 }
-declare class EnvServer extends RunnerManager {
+export declare class EnvServer extends RunnerManager {
   private _opts;
   private _watchers;
   private _reloadTimeout;
@@ -161,12 +161,43 @@ interface AppEntryIPC {
   onMessage?: (message: unknown) => void | Promise<void>;
   onClose?: () => void | Promise<void>;
 }
-interface AppEntry {
+/**
+ * User entry module shape. Besides `fetch` and the env-runner specific hooks
+ * (`upgrade`, `websocket`, `ipc`), any srvx `ServerOptions` (e.g. `error`,
+ * `maxRequestBodySize`, `trustProxy`, `node`/`bun`/`deno`) is forwarded to
+ * `serve()` by the built-in workers. The listener-related keys in
+ * {@link RESERVED_SERVER_OPTIONS} are owned by the worker (it sits behind the
+ * runner's proxy) and are ignored if set.
+ */
+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 };
+/**
+ * srvx options the built-in workers always control themselves: the worker
+ * listens on a random loopback port behind the runner's proxy, so the entry
+ * must not be able to relocate or TLS-terminate it.
+ */
+export declare const RESERVED_SERVER_OPTIONS: ["port", "hostname", "protocol", "tls", "silent", "manual", "gracefulShutdown"];
+/**
+ * Listener/TLS keys inside the runtime-specific option objects. srvx spreads
+ * `node`/`bun`/`deno` *after* its resolved port/host/tls, so these would
+ * otherwise bypass {@link RESERVED_SERVER_OPTIONS}. `node.http2` is dropped
+ * too: srvx requires a TLS certificate for it, which the worker never has.
+ */
+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"];
+};
+/**
+ * Build the srvx `serve()` options for a user entry: forwards every srvx
+ * option exported by the entry, drops env-runner specific keys (`fetch`,
+ * `upgrade`, `websocket`, `ipc`) and pins the worker-owned listener options
+ * (top-level and nested in `node`/`bun`/`deno`). Callers add `fetch` (bound
+ * lazily so module reloads swap the handler) and the crossws plugin themselves.
+ */
+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

@@ -1,8 +1,9 @@
 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;
@@ -56,11 +57,10 @@ var BunProcessEnvRunner = class extends BaseEnvRunner {
 			this.close(`process entry not found in "${this._workerEntry}".`);
 			return;
 		}
-		const env = {
-			...process.env,
+		const env = hostEnv({
 			ENV_RUNNER_NAME: this._name,
 			ENV_RUNNER_DATA: JSON.stringify(this._data || {})
-		};
+		});
 		if (_isBun) this.#initBunProcess(execArgv, env);
 		else this.#initNodeProcess(execArgv, env);
 	}

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,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";
 const data = JSON.parse(process.env.ENV_RUNNER_DATA || "{}");
@@ -8,9 +8,16 @@ const _stdin = globalThis.Deno?.stdin?.readable || process.stdin;
 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 +27,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-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/runner.mjs

@@ -1,4 +1,5 @@
 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 { fork } from "node:child_process";
@@ -35,11 +36,10 @@ var NodeProcessEnvRunner = class extends BaseEnvRunner {
 			return;
 		}
 		const child = fork(this._workerEntry, [], {
-			env: {
-				...process.env,
+			env: hostEnv({
 				ENV_RUNNER_NAME: this._name,
 				ENV_RUNNER_DATA: JSON.stringify(this._data || {})
-			},
+			}),
 			stdio: [
 				"pipe",
 				"pipe",