env-runner 0.1.6 → 0.1.7

package/README.md

@@ -7,7 +7,7 @@
 
 <!-- /automd -->
 
-Generic environment runner for JavaScript runtimes. Run your server apps across Node.js worker threads, child processes, Bun, Deno, Cloudflare Workers (via miniflare), or in-process — with hot-reload, WebSocket proxying, and bidirectional messaging.
+Generic environment runner for JavaScript runtimes. Run your server apps across Node.js worker threads, child processes, Bun, Deno, Cloudflare Workers (via miniflare), Vercel, Netlify, or in-process — with hot-reload, WebSocket proxying, and bidirectional messaging.
 
 ## Usage
 
@@ -120,6 +120,8 @@ import { BunProcessEnvRunner } from "env-runner/runners/bun-process";
 import { DenoProcessEnvRunner } from "env-runner/runners/deno-process";
 import { SelfEnvRunner } from "env-runner/runners/self";
 import { MiniflareEnvRunner } from "env-runner/runners/miniflare";
+import { VercelEnvRunner } from "env-runner/runners/vercel";
+import { NetlifyEnvRunner } from "env-runner/runners/netlify";
 ```
 
 All runners implement the [`EnvRunner`](./src/types.ts) interface:
@@ -160,14 +162,16 @@ await runner.close();
 
 **Available runners:**
 
-| Runner                 | Isolation                      | IPC mechanism                      |
-| ---------------------- | ------------------------------ | ---------------------------------- |
-| `NodeWorkerEnvRunner`  | Worker thread                  | `workerData` / `parentPort`        |
-| `NodeProcessEnvRunner` | Child process (`fork`)         | `ENV_RUNNER_DATA` / `process.send` |
-| `BunProcessEnvRunner`  | Bun or Node.js process         | `Bun.spawn` IPC or `fork()`        |
-| `DenoProcessEnvRunner` | Deno process                   | `deno run` with IPC channel        |
-| `SelfEnvRunner`        | In-process                     | In-memory channel                  |
-| `MiniflareEnvRunner`   | Cloudflare Workers (miniflare) | WebSocket pair via `dispatchFetch` |
+| Runner                 | Isolation                       | IPC mechanism                      |
+| ---------------------- | ------------------------------- | ---------------------------------- |
+| `NodeWorkerEnvRunner`  | Worker thread                   | `workerData` / `parentPort`        |
+| `NodeProcessEnvRunner` | Child process (`fork`)          | `ENV_RUNNER_DATA` / `process.send` |
+| `BunProcessEnvRunner`  | Bun or Node.js process          | `Bun.spawn` IPC or `fork()`        |
+| `DenoProcessEnvRunner` | Deno process                    | `deno run` with IPC channel        |
+| `SelfEnvRunner`        | In-process                      | In-memory channel                  |
+| `MiniflareEnvRunner`   | Cloudflare Workers (miniflare)  | WebSocket pair via `dispatchFetch` |
+| `VercelEnvRunner`      | Worker thread (Vercel context)  | `workerData` / `parentPort`        |
+| `NetlifyEnvRunner`     | Worker thread (Netlify context) | `workerData` / `parentPort`        |
 
 #### Miniflare Runner
 
@@ -289,6 +293,32 @@ const runner2 = new MiniflareEnvRunner({
 // Fully destroy: runner.dispose() or MiniflareEnvRunner.disposeAll()
 ```
 
+#### Vercel Runner
+
+Simulates a Vercel deployment environment with automatic header injection (`x-vercel-deployment-url`, `x-vercel-forwarded-for`, forwarding headers) and global context.
+
+```ts
+import { VercelEnvRunner } from "env-runner/runners/vercel";
+
+const runner = new VercelEnvRunner({
+  name: "my-app",
+  data: { entry: "./app.ts" },
+});
+```
+
+#### Netlify Runner
+
+Simulates a Netlify deployment environment with automatic header injection (`x-nf-client-connection-ip`, `x-nf-account-id`, `x-nf-site-id`, `x-nf-deploy-id`, `x-nf-deploy-context`, `x-nf-geo`, `x-nf-request-id`, forwarding headers) and `globalThis.Netlify` setup:
+
+```ts
+import { NetlifyEnvRunner } from "env-runner/runners/netlify";
+
+const runner = new NetlifyEnvRunner({
+  name: "my-app",
+  data: { entry: "./app.ts" },
+});
+```
+
 ### Vite Environment API
 
 env-runner provides helpers for integrating with Vite's [Environment API](https://vite.dev/guide/api-environment-runtimes.html):

package/dist/_chunks/runner.mjs

@@ -44,8 +44,9 @@ var DenoProcessEnvRunner = class extends BaseEnvRunner {
 		};
 		const child = spawn("deno", [
 			"run",
-			"--allow-all",
+			"-A",
 			"--node-modules-dir=auto",
+			"--no-lock",
 			...execArgv || [],
 			this._workerEntry
 		], {
@@ -53,8 +54,7 @@ var DenoProcessEnvRunner = class extends BaseEnvRunner {
 			stdio: [
 				"pipe",
 				"pipe",
-				"pipe",
-				"ipc"
+				"pipe"
 			]
 		});
 		const exited = new Promise((resolve) => {
@@ -63,7 +63,9 @@ var DenoProcessEnvRunner = class extends BaseEnvRunner {
 		const handle = {
 			pid: child.pid,
 			kill: () => child.kill(),
-			send: (message) => child.send(message),
+			send: (message) => {
+				child.stdin.write(JSON.stringify(message) + "\n");
+			},
 			exited,
 			_exitCode: void 0,
 			removeAllListeners: () => child.removeAllListeners()
@@ -78,8 +80,17 @@ var DenoProcessEnvRunner = class extends BaseEnvRunner {
 				this.close(error);
 			}
 		});
-		child.on("message", (message) => {
-			this._handleMessage(message);
+		let buffer = "";
+		child.stdout.on("data", (chunk) => {
+			buffer += chunk.toString();
+			let newlineIdx;
+			while ((newlineIdx = buffer.indexOf("\n")) !== -1) {
+				const line = buffer.slice(0, newlineIdx);
+				buffer = buffer.slice(newlineIdx + 1);
+				if (line.startsWith("{")) try {
+					this._handleMessage(JSON.parse(line));
+				} catch {}
+			}
 		});
 		this.#process = handle;
 	}

package/dist/_chunks/runner2.d.mts

@@ -46,6 +46,14 @@ interface MiniflareEnvRunnerOptions {
   persistent?: boolean;
   /** Wrap the user's `fetch` in a try/catch that returns structured JSON error responses. Default: `true`. */
   captureErrors?: boolean;
+  /**
+   * Export conditions for bare-specifier module resolution in the module
+   * fallback service. Ensures packages with conditional exports (e.g.
+   * `"workerd"`) resolve to the correct entry instead of the Node.js one.
+   *
+   * Defaults to `["workerd", "worker"]`.
+   */
+  exportConditions?: string[];
 }
 declare class MiniflareEnvRunner extends BaseEnvRunner {
   #private;

package/dist/_chunks/runner2.mjs

@@ -5,6 +5,7 @@ import { proxyUpgrade } from "httpxy";
 import { readFileSync } from "node:fs";
 import { fileURLToPath } from "node:url";
 import { basename, dirname, resolve } from "node:path";
+import { resolveModulePath } from "exsolve";
 //#region src/runners/miniflare/wrapper.ts
 const IPC_PATH$1 = "/__env_runner_ipc";
 /** Service binding name used for cross-request IPC (worker → runner). */
@@ -207,6 +208,7 @@ var MiniflareEnvRunner = class extends BaseEnvRunner {
 	#cacheKey;
 	#exports;
 	#captureErrors;
+	#exportConditions;
 	constructor(opts) {
 		super({
 			...opts,
@@ -217,6 +219,7 @@ var MiniflareEnvRunner = class extends BaseEnvRunner {
 		this.#persistent = opts.persistent ?? false;
 		this.#exports = opts.exports ?? {};
 		this.#captureErrors = opts.captureErrors ?? true;
+		this.#exportConditions = opts.exportConditions ?? ["workerd", "worker"];
 		this.#init();
 	}
 	/** Dispose all persistent Miniflare instances from the cache. */
@@ -399,6 +402,7 @@ var MiniflareEnvRunner = class extends BaseEnvRunner {
 			if (!options.unsafeModuleFallbackService) {
 				const _require = createRequire(resolvedEntry);
 				const _transformRequest = this.#transformRequest;
+				const _exportConditions = this.#exportConditions;
 				options.unsafeUseModuleFallbackService = true;
 				const modulePathMap = /* @__PURE__ */ new Map();
 				const _cjsLexerReady = ensureCjsLexer();
@@ -422,6 +426,7 @@ var MiniflareEnvRunner = class extends BaseEnvRunner {
 						const referrerKey = referrer.startsWith("/") ? referrer.slice(1) : referrer;
 						const referrerReal = modulePathMap.get(referrerKey);
 						const contextRequire = referrerReal ? createRequire(referrerReal) : _require;
+						if (cleanRaw.startsWith("cloudflare:")) return new Response(null, { status: 404 });
 						if (cleanRaw.startsWith("node:")) {
 							const nodeName = cleanRaw.slice(5);
 							try {
@@ -430,7 +435,11 @@ var MiniflareEnvRunner = class extends BaseEnvRunner {
 								return new Response(null, { status: 404 });
 							}
 						} else try {
-							resolvedPath = contextRequire.resolve(cleanRaw);
+							resolvedPath = resolveModulePath(cleanRaw, {
+								from: referrerReal || resolvedEntry,
+								conditions: _exportConditions,
+								try: true
+							}) || contextRequire.resolve(cleanRaw);
 						} catch {
 							const name = cleanSpecifier.startsWith("/") ? cleanSpecifier.slice(1) : cleanSpecifier;
 							return Response.json({
@@ -486,7 +495,10 @@ var MiniflareEnvRunner = class extends BaseEnvRunner {
 			}
 		}
 		if (this.#persistent && entryPath) {
-			this.#cacheKey = computeCacheKey(entryPath, this.#miniflareOptions);
+			this.#cacheKey = computeCacheKey(entryPath, {
+				...this.#miniflareOptions,
+				_exportConditions: this.#exportConditions
+			});
 			const cached = _miniflareCache.get(this.#cacheKey);
 			if (cached) {
 				this.#miniflare = cached.mf;

package/dist/_chunks/runner3.d.mts

@@ -0,0 +1,19 @@
+import { u as WorkerHooks } from "./types.mjs";
+import { n as EnvRunnerData, t as BaseEnvRunner } from "./base-runner.mjs";
+
+//#region src/runners/node-worker/runner.d.ts
+declare class NodeWorkerEnvRunner extends BaseEnvRunner {
+  #private;
+  constructor(opts: {
+    name: string;
+    workerEntry?: string;
+    hooks?: WorkerHooks;
+    data?: EnvRunnerData;
+  });
+  sendMessage(message: unknown): void;
+  protected _hasRuntime(): boolean;
+  protected _runtimeType(): string;
+  protected _closeRuntime(): Promise<void>;
+}
+//#endregion
+export { NodeWorkerEnvRunner as t };

package/dist/_chunks/runner3.mjs

@@ -0,0 +1,62 @@
+import { t as BaseEnvRunner } from "./base-runner.mjs";
+import { existsSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+import { Worker } from "node:worker_threads";
+//#region src/runners/node-worker/runner.ts
+let _defaultEntry;
+var NodeWorkerEnvRunner = class extends BaseEnvRunner {
+	#worker;
+	constructor(opts) {
+		_defaultEntry ||= fileURLToPath(import.meta.resolve("env-runner/runners/node-worker/worker"));
+		super({
+			...opts,
+			workerEntry: opts.workerEntry || _defaultEntry
+		});
+		this.#initWorker();
+	}
+	sendMessage(message) {
+		if (!this.#worker) throw new Error("Worker thread should be initialized before sending messages.");
+		this.#worker.postMessage(message);
+	}
+	_hasRuntime() {
+		return Boolean(this.#worker);
+	}
+	_runtimeType() {
+		return "worker";
+	}
+	async _closeRuntime() {
+		if (!this.#worker) return;
+		this.#worker.removeAllListeners();
+		await this.#worker.terminate().catch((error) => {
+			console.error(error);
+		});
+		this.#worker = void 0;
+	}
+	#initWorker() {
+		if (!existsSync(this._workerEntry)) {
+			this.close(`worker entry not found in "${this._workerEntry}".`);
+			return;
+		}
+		const worker = new Worker(this._workerEntry, {
+			env: { ...process.env },
+			workerData: {
+				name: this._name,
+				...this._data
+			}
+		});
+		worker.once("exit", (code) => {
+			worker._exitCode = code;
+			this.close(`worker exited with code ${code}`);
+		});
+		worker.once("error", (error) => {
+			console.error(`Worker error:`, error);
+			this.close(error);
+		});
+		worker.on("message", (message) => {
+			this._handleMessage(message);
+		});
+		this.#worker = worker;
+	}
+};
+//#endregion
+export { NodeWorkerEnvRunner as t };

package/dist/_chunks/runner4.d.mts

@@ -0,0 +1,17 @@
+import { u as WorkerHooks } from "./types.mjs";
+import { n as EnvRunnerData } from "./base-runner.mjs";
+import { t as NodeWorkerEnvRunner } from "./runner3.mjs";
+
+//#region src/runners/vercel/runner.d.ts
+declare class VercelEnvRunner extends NodeWorkerEnvRunner {
+  constructor(opts: {
+    name: string;
+    workerEntry?: string;
+    hooks?: WorkerHooks;
+    data?: EnvRunnerData;
+  });
+  fetch(input: string | URL | Request, init?: RequestInit): Promise<Response>;
+  protected _runtimeType(): string;
+}
+//#endregion
+export { VercelEnvRunner as t };

package/dist/_chunks/runner4.mjs

@@ -0,0 +1,42 @@
+import { t as NodeWorkerEnvRunner } from "./runner3.mjs";
+import { fileURLToPath } from "node:url";
+//#region src/runners/vercel/runner.ts
+let _defaultEntry;
+var VercelEnvRunner = class extends NodeWorkerEnvRunner {
+	constructor(opts) {
+		_defaultEntry ||= fileURLToPath(import.meta.resolve("env-runner/runners/vercel/worker"));
+		super({
+			...opts,
+			workerEntry: opts.workerEntry || _defaultEntry
+		});
+	}
+	async fetch(input, init) {
+		const headers = new Headers(input instanceof Request ? input.headers : init?.headers);
+		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}`);
+		}
+		const clientIp = headers.get("x-forwarded-for")?.split(",")[0]?.trim() || headers.get("x-real-ip") || "127.0.0.1";
+		if (!headers.has("x-vercel-forwarded-for")) headers.set("x-vercel-forwarded-for", clientIp);
+		if (!headers.has("x-forwarded-for")) headers.set("x-forwarded-for", clientIp);
+		if (!headers.has("x-real-ip")) headers.set("x-real-ip", clientIp);
+		try {
+			const url = new URL(input instanceof Request ? input.url : input.toString());
+			if (!headers.has("x-forwarded-proto")) headers.set("x-forwarded-proto", url.protocol.replace(":", ""));
+			if (!headers.has("x-forwarded-host")) headers.set("x-forwarded-host", headers.get("host") || url.host);
+		} catch {}
+		if (input instanceof Request) return super.fetch(new Request(input, {
+			...init,
+			headers
+		}));
+		return super.fetch(input, {
+			...init,
+			headers
+		});
+	}
+	_runtimeType() {
+		return "vercel";
+	}
+};
+//#endregion
+export { VercelEnvRunner as t };

package/dist/_chunks/runner5.d.mts

@@ -0,0 +1,17 @@
+import { u as WorkerHooks } from "./types.mjs";
+import { n as EnvRunnerData } from "./base-runner.mjs";
+import { t as NodeWorkerEnvRunner } from "./runner3.mjs";
+
+//#region src/runners/netlify/runner.d.ts
+declare class NetlifyEnvRunner extends NodeWorkerEnvRunner {
+  constructor(opts: {
+    name: string;
+    workerEntry?: string;
+    hooks?: WorkerHooks;
+    data?: EnvRunnerData;
+  });
+  fetch(input: string | URL | Request, init?: RequestInit): Promise<Response>;
+  protected _runtimeType(): string;
+}
+//#endregion
+export { NetlifyEnvRunner as t };

package/dist/_chunks/runner5.mjs

@@ -0,0 +1,47 @@
+import { t as NodeWorkerEnvRunner } from "./runner3.mjs";
+import { fileURLToPath } from "node:url";
+//#region src/runners/netlify/runner.ts
+let _defaultEntry;
+var NetlifyEnvRunner = class extends NodeWorkerEnvRunner {
+	constructor(opts) {
+		_defaultEntry ||= fileURLToPath(import.meta.resolve("env-runner/runners/netlify/worker"));
+		super({
+			...opts,
+			workerEntry: opts.workerEntry || _defaultEntry
+		});
+	}
+	async fetch(input, init) {
+		const headers = new Headers(input instanceof Request ? input.headers : init?.headers);
+		const clientIp = headers.get("x-forwarded-for")?.split(",")[0]?.trim() || headers.get("x-real-ip") || "127.0.0.1";
+		if (!headers.has("x-nf-client-connection-ip")) headers.set("x-nf-client-connection-ip", clientIp);
+		if (!headers.has("x-nf-account-id")) headers.set("x-nf-account-id", "0");
+		if (!headers.has("x-nf-site-id")) headers.set("x-nf-site-id", "0");
+		if (!headers.has("x-nf-deploy-id")) headers.set("x-nf-deploy-id", "0");
+		if (!headers.has("x-nf-deploy-context")) headers.set("x-nf-deploy-context", "dev");
+		if (!headers.has("x-nf-geo")) headers.set("x-nf-geo", btoa(JSON.stringify({
+			city: "localhost",
+			country: { code: "dev" }
+		})));
+		if (!headers.has("x-nf-request-id")) headers.set("x-nf-request-id", crypto.randomUUID());
+		if (!headers.has("x-forwarded-for")) headers.set("x-forwarded-for", clientIp);
+		if (!headers.has("x-real-ip")) headers.set("x-real-ip", clientIp);
+		try {
+			const url = new URL(input instanceof Request ? input.url : input.toString());
+			if (!headers.has("x-forwarded-proto")) headers.set("x-forwarded-proto", url.protocol.replace(":", ""));
+			if (!headers.has("x-forwarded-host")) headers.set("x-forwarded-host", headers.get("host") || url.host);
+		} catch {}
+		if (input instanceof Request) return super.fetch(new Request(input, {
+			...init,
+			headers
+		}));
+		return super.fetch(input, {
+			...init,
+			headers
+		});
+	}
+	_runtimeType() {
+		return "netlify";
+	}
+};
+//#endregion
+export { NetlifyEnvRunner as t };

package/dist/_chunks/server.mjs

@@ -175,7 +175,9 @@ const loaders = {
 	"bun-process": () => import("env-runner/runners/bun-process").then((m) => m.BunProcessEnvRunner),
 	"deno-process": () => import("env-runner/runners/deno-process").then((m) => m.DenoProcessEnvRunner),
 	self: () => import("env-runner/runners/self").then((m) => m.SelfEnvRunner),
-	miniflare: () => import("env-runner/runners/miniflare").then((m) => m.MiniflareEnvRunner)
+	miniflare: () => import("env-runner/runners/miniflare").then((m) => m.MiniflareEnvRunner),
+	vercel: () => import("env-runner/runners/vercel").then((m) => m.VercelEnvRunner),
+	netlify: () => import("env-runner/runners/netlify").then((m) => m.NetlifyEnvRunner)
 };
 async function loadRunner(runner, opts) {
 	return new (await (loaders[runner]()))(opts);

package/dist/index.d.mts

@@ -2,6 +2,8 @@ import { a as RunnerMessageListener, c as UpgradeHandler, i as RPCOptions, l as
 import { n as EnvRunnerData, t as BaseEnvRunner } from "./_chunks/base-runner.mjs";
 import { t as DenoProcessEnvRunner } from "./_chunks/runner.mjs";
 import { i as TransformResult, n as MiniflareEnvRunnerOptions, r as MiniflareExportInfo, t as MiniflareEnvRunner } from "./_chunks/runner2.mjs";
+import { t as VercelEnvRunner } from "./_chunks/runner4.mjs";
+import { t as NetlifyEnvRunner } from "./_chunks/runner5.mjs";
 import { ServerOptions } from "srvx";
 import { Hooks } from "crossws";
 
@@ -46,13 +48,15 @@ declare class RunnerManager implements EnvRunner {
 }
 //#endregion
 //#region src/loader.d.ts
-type RunnerName = "node-worker" | "node-process" | "bun-process" | "deno-process" | "self" | "miniflare";
+type RunnerName = "node-worker" | "node-process" | "bun-process" | "deno-process" | "self" | "miniflare" | "vercel" | "netlify";
 interface LoadRunnerOptions {
   name: string;
   workerEntry?: string;
   hooks?: WorkerHooks;
   data?: EnvRunnerData;
   execArgv?: string[];
+  /** Additional runner-specific options (passed through to the runner constructor). */
+  [key: string]: unknown;
 }
 declare function loadRunner(runner: RunnerName, opts: LoadRunnerOptions): Promise<EnvRunner>;
 //#endregion
@@ -113,4 +117,4 @@ interface AppEntry {
   ipc?: AppEntryIPC;
 }
 //#endregion
-export { type AppEntry, type AppEntryIPC, type AppEntryIPCContext, BaseEnvRunner, DenoProcessEnvRunner, type EnvRunnerData as DenoProcessEnvRunnerData, type EnvRunnerData, type EnvRunner, EnvServer, type EnvServerOptions, type FetchHandler, type LoadRunnerOptions, MiniflareEnvRunner, type MiniflareEnvRunnerOptions, type MiniflareExportInfo, type NodeUpgradeContext, type RPCOptions, RunnerManager, type RunnerMessageListener, type RunnerName, type RunnerRPCHooks, type TransformResult, type UpgradeContext, type UpgradeHandler, type WorkerAddress, type WorkerHooks, loadRunner };
+export { type AppEntry, type AppEntryIPC, type AppEntryIPCContext, BaseEnvRunner, DenoProcessEnvRunner, type EnvRunnerData as DenoProcessEnvRunnerData, type EnvRunnerData, type EnvRunner, 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 TransformResult, type UpgradeContext, type UpgradeHandler, VercelEnvRunner, type WorkerAddress, type WorkerHooks, loadRunner };

package/dist/index.mjs

@@ -1,6 +1,7 @@
 import { t as BaseEnvRunner } from "./_chunks/base-runner.mjs";
 import { n as loadRunner, r as RunnerManager, t as EnvServer } from "./_chunks/server.mjs";
 import { t as DenoProcessEnvRunner } from "./_chunks/runner.mjs";
-import "./_chunks/libs/cjs-module-lexer.mjs";
 import { t as MiniflareEnvRunner } from "./_chunks/runner2.mjs";
-export { BaseEnvRunner, DenoProcessEnvRunner, EnvServer, MiniflareEnvRunner, RunnerManager, loadRunner };
+import { t as VercelEnvRunner } from "./_chunks/runner4.mjs";
+import { t as NetlifyEnvRunner } from "./_chunks/runner5.mjs";
+export { BaseEnvRunner, DenoProcessEnvRunner, EnvServer, MiniflareEnvRunner, NetlifyEnvRunner, RunnerManager, VercelEnvRunner, loadRunner };

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

@@ -1,3 +1,2 @@
-import "../../_chunks/base-runner.mjs";
 import { t as DenoProcessEnvRunner } from "../../_chunks/runner.mjs";
 export { DenoProcessEnvRunner };

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

@@ -4,7 +4,9 @@ import { plugin } from "crossws/server";
 //#region src/runners/deno-process/worker.ts
 const data = JSON.parse(process.env.ENV_RUNNER_DATA || "{}");
 let entry = await resolveEntry(data.entry);
-const sendMessage = (message) => process.send(message);
+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 server = serve({
 	port: 0,
 	hostname: "127.0.0.1",
@@ -23,20 +25,40 @@ if (entry.upgrade) server.node?.server?.on("upgrade", (req, socket, head) => {
 	} });
 });
 if (entry.ipc) await entry.ipc.onOpen?.({ sendMessage });
-process.send({ address: parseServerAddress(server) });
-process.on("message", async (message) => {
+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) {
 	if (message?.event === "shutdown") {
 		Promise.resolve(entry.ipc?.onClose?.()).then(() => server.close()).then(() => {
-			process.send({ event: "exit" });
+			sendMessage({ event: "exit" });
 		});
 		return;
 	}
 	if (message?.event === "reload-module") {
 		try {
 			entry = await reloadEntryModule(data.entry, entry, sendMessage);
-			process.send({ event: "module-reloaded" });
+			sendMessage({ event: "module-reloaded" });
 		} catch (error) {
-			process.send({
+			sendMessage({
 				event: "module-reloaded",
 				error: error?.message || String(error)
 			});
@@ -44,13 +66,14 @@ process.on("message", async (message) => {
 		return;
 	}
 	if (message?.type === "ping") {
-		process.send({
+		sendMessage({
 			type: "pong",
 			data: message.data
 		});
 		return;
 	}
 	entry.ipc?.onMessage?.(message);
-});
+}
+readMessages().catch(() => {});
 //#endregion
 export {};

package/dist/runners/miniflare/runner.mjs

@@ -1,4 +1,2 @@
-import "../../_chunks/base-runner.mjs";
-import "../../_chunks/libs/cjs-module-lexer.mjs";
 import { t as MiniflareEnvRunner } from "../../_chunks/runner2.mjs";
 export { MiniflareEnvRunner };

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

@@ -0,0 +1,3 @@
+import { n as EnvRunnerData } from "../../_chunks/base-runner.mjs";
+import { t as NetlifyEnvRunner } from "../../_chunks/runner5.mjs";
+export { EnvRunnerData, NetlifyEnvRunner };

package/dist/runners/netlify/runner.mjs

@@ -0,0 +1,2 @@
+import { t as NetlifyEnvRunner } from "../../_chunks/runner5.mjs";
+export { NetlifyEnvRunner };

package/dist/runners/netlify/worker.d.mts

@@ -0,0 +1 @@
+export { };

package/dist/runners/netlify/worker.mjs

@@ -0,0 +1,43 @@
+//#region src/runners/netlify/worker.ts
+try {
+	const { startRuntime } = await import("@netlify/runtime");
+	startRuntime({
+		deployID: "0",
+		siteID: "0",
+		env: {
+			get: (key) => process.env[key],
+			has: (key) => key in process.env,
+			set: (key, value) => {
+				process.env[key] = value;
+			},
+			delete: (key) => {
+				delete process.env[key];
+			},
+			toObject: () => ({ ...process.env })
+		},
+		getRequestContext: () => null,
+		cache: { getCacheAPIContext: () => null }
+	});
+} catch {
+	if (!process.env.__ENV_RUNNER_NETLIFY_WARNED) {
+		process.env.__ENV_RUNNER_NETLIFY_WARNED = "1";
+		console.warn("@netlify/runtime is not installed. Install it for full Netlify runtime emulation: npx nypm i -D @netlify/runtime");
+	}
+	globalThis.Netlify = {
+		context: null,
+		env: {
+			get: (key) => process.env[key],
+			has: (key) => key in process.env,
+			set: (key, value) => {
+				process.env[key] = value;
+			},
+			delete: (key) => {
+				delete process.env[key];
+			},
+			toObject: () => ({ ...process.env })
+		}
+	};
+}
+await import("../node-worker/worker.mjs");
+//#endregion
+export {};

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

@@ -1,19 +1,3 @@
-import { u as WorkerHooks } from "../../_chunks/types.mjs";
-import { n as EnvRunnerData, t as BaseEnvRunner } from "../../_chunks/base-runner.mjs";
-
-//#region src/runners/node-worker/runner.d.ts
-declare class NodeWorkerEnvRunner extends BaseEnvRunner {
-  #private;
-  constructor(opts: {
-    name: string;
-    workerEntry?: string;
-    hooks?: WorkerHooks;
-    data?: EnvRunnerData;
-  });
-  sendMessage(message: unknown): void;
-  protected _hasRuntime(): boolean;
-  protected _runtimeType(): string;
-  protected _closeRuntime(): Promise<void>;
-}
-//#endregion
-export { type EnvRunnerData, NodeWorkerEnvRunner };
+import { n as EnvRunnerData } from "../../_chunks/base-runner.mjs";
+import { t as NodeWorkerEnvRunner } from "../../_chunks/runner3.mjs";
+export { EnvRunnerData, NodeWorkerEnvRunner };

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

@@ -1,62 +1,2 @@
-import { t as BaseEnvRunner } from "../../_chunks/base-runner.mjs";
-import { existsSync } from "node:fs";
-import { fileURLToPath } from "node:url";
-import { Worker } from "node:worker_threads";
-//#region src/runners/node-worker/runner.ts
-let _defaultEntry;
-var NodeWorkerEnvRunner = class extends BaseEnvRunner {
-	#worker;
-	constructor(opts) {
-		_defaultEntry ||= fileURLToPath(import.meta.resolve("env-runner/runners/node-worker/worker"));
-		super({
-			...opts,
-			workerEntry: opts.workerEntry || _defaultEntry
-		});
-		this.#initWorker();
-	}
-	sendMessage(message) {
-		if (!this.#worker) throw new Error("Node env worker should be initialized before sending messages.");
-		this.#worker.postMessage(message);
-	}
-	_hasRuntime() {
-		return Boolean(this.#worker);
-	}
-	_runtimeType() {
-		return "worker";
-	}
-	async _closeRuntime() {
-		if (!this.#worker) return;
-		this.#worker.removeAllListeners();
-		await this.#worker.terminate().catch((error) => {
-			console.error(error);
-		});
-		this.#worker = void 0;
-	}
-	#initWorker() {
-		if (!existsSync(this._workerEntry)) {
-			this.close(`worker entry not found in "${this._workerEntry}".`);
-			return;
-		}
-		const worker = new Worker(this._workerEntry, {
-			env: { ...process.env },
-			workerData: {
-				name: this._name,
-				...this._data
-			}
-		});
-		worker.once("exit", (code) => {
-			worker._exitCode = code;
-			this.close(`worker exited with code ${code}`);
-		});
-		worker.once("error", (error) => {
-			console.error(`Worker error:`, error);
-			this.close(error);
-		});
-		worker.on("message", (message) => {
-			this._handleMessage(message);
-		});
-		this.#worker = worker;
-	}
-};
-//#endregion
+import { t as NodeWorkerEnvRunner } from "../../_chunks/runner3.mjs";
 export { NodeWorkerEnvRunner };

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

@@ -0,0 +1,3 @@
+import { n as EnvRunnerData } from "../../_chunks/base-runner.mjs";
+import { t as VercelEnvRunner } from "../../_chunks/runner4.mjs";
+export { EnvRunnerData, VercelEnvRunner };

package/dist/runners/vercel/runner.mjs

@@ -0,0 +1,2 @@
+import { t as VercelEnvRunner } from "../../_chunks/runner4.mjs";
+export { VercelEnvRunner };

package/dist/runners/vercel/worker.d.mts

@@ -0,0 +1 @@
+export { };

package/dist/runners/vercel/worker.mjs

@@ -0,0 +1,50 @@
+//#region src/runners/vercel/worker.ts
+const SYMBOL_FOR_REQ_CONTEXT = Symbol.for("@vercel/request-context");
+const waitUntilPromises = /* @__PURE__ */ new Set();
+const cacheStore = /* @__PURE__ */ new Map();
+const cacheTags = /* @__PURE__ */ new Set();
+globalThis[SYMBOL_FOR_REQ_CONTEXT] = { get: () => ({
+	waitUntil(promise) {
+		waitUntilPromises.add(promise);
+		promise.finally(() => waitUntilPromises.delete(promise));
+	},
+	cache: {
+		async get(key) {
+			const entry = cacheStore.get(key);
+			if (!entry) return null;
+			if (entry.ttl && entry.lastModified + entry.ttl * 1e3 < Date.now()) {
+				cacheStore.delete(key);
+				return null;
+			}
+			return JSON.parse(entry.value);
+		},
+		async set(key, value, options) {
+			cacheStore.set(key, {
+				value: JSON.stringify(value ?? null),
+				lastModified: Date.now(),
+				ttl: options?.ttl,
+				tags: new Set(options?.tags || [])
+			});
+		},
+		async delete(key) {
+			cacheStore.delete(key);
+		},
+		async expireTag(tag) {
+			const tags = Array.isArray(tag) ? tag : [tag];
+			for (const [key, entry] of cacheStore) if (tags.some((t) => entry.tags.has(t))) cacheStore.delete(key);
+		}
+	},
+	purge: {
+		invalidateByTag: (_tag) => Promise.resolve(),
+		dangerouslyDeleteByTag: (_tag) => Promise.resolve(),
+		invalidateBySrcImage: (_src) => Promise.resolve(),
+		dangerouslyDeleteBySrcImage: (_src) => Promise.resolve()
+	},
+	addCacheTag(tag) {
+		for (const t of Array.isArray(tag) ? tag : [tag]) cacheTags.add(t);
+		return Promise.resolve();
+	}
+}) };
+await import("../node-worker/worker.mjs");
+//#endregion
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "env-runner",
-  "version": "0.1.6",
+  "version": "0.1.7",
   "description": "Generic environment runner for JavaScript runtimes.",
   "license": "MIT",
   "repository": "unjs/env-runner",
@@ -24,6 +24,10 @@
     "./runners/deno-process/worker": "./dist/runners/deno-process/worker.mjs",
     "./runners/self": "./dist/runners/self/runner.mjs",
     "./runners/miniflare": "./dist/runners/miniflare/runner.mjs",
+    "./runners/vercel": "./dist/runners/vercel/runner.mjs",
+    "./runners/vercel/worker": "./dist/runners/vercel/worker.mjs",
+    "./runners/netlify": "./dist/runners/netlify/runner.mjs",
+    "./runners/netlify/worker": "./dist/runners/netlify/worker.mjs",
     "./vite": "./dist/vite.mjs"
   },
   "scripts": {
@@ -39,31 +43,37 @@
   },
   "dependencies": {
     "crossws": "^0.4.4",
-    "httpxy": "^0.3.1",
-    "srvx": "^0.11.9"
+    "exsolve": "^1.0.8",
+    "httpxy": "^0.5.0",
+    "srvx": "^0.11.13"
   },
   "devDependencies": {
-    "@types/node": "latest",
-    "@typescript/native-preview": "latest",
-    "@vitest/coverage-v8": "latest",
-    "automd": "latest",
-    "changelogen": "latest",
+    "@netlify/runtime": "^4.1.20",
+    "@types/node": "^25.5.0",
+    "@typescript/native-preview": "^7.0.0-dev.20260327.2",
+    "@vitest/coverage-v8": "^4.1.2",
+    "automd": "^0.4.3",
+    "changelogen": "^0.6.2",
     "cjs-module-lexer": "^2.2.0",
-    "env-runner-fixture": "link:.",
-    "miniflare": "^4.20260301.1",
-    "obuild": "latest",
-    "oxfmt": "latest",
-    "oxlint": "latest",
-    "typescript": "latest",
-    "vitest": "latest"
+    "env-runner-fixture": "link:",
+    "miniflare": "^4.20260317.3",
+    "obuild": "^0.4.32",
+    "oxfmt": "^0.42.0",
+    "oxlint": "^1.57.0",
+    "typescript": "^6.0.2",
+    "vitest": "^4.1.2"
   },
   "peerDependencies": {
-    "miniflare": "^4.0.0"
+    "@netlify/runtime": "^4",
+    "miniflare": "^4.20260317.3"
   },
   "peerDependenciesMeta": {
     "miniflare": {
       "optional": true
+    },
+    "@netlify/runtime": {
+      "optional": true
     }
   },
-  "packageManager": "pnpm@10.29.3"
+  "packageManager": "pnpm@10.33.0"
 }