env-runner 0.1.6 → 0.1.8

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/base-runner.d.mts

@@ -1,8 +1,6 @@
 import { a as RunnerMessageListener, l as WorkerAddress, t as EnvRunner, u as WorkerHooks } from "./types.mjs";
 import { IncomingMessage } from "node:http";
 import { Socket } from "node:net";
-
-//#region src/common/base-runner.d.ts
 interface EnvRunnerData {
   name?: string;
   [key: string]: unknown;
@@ -45,5 +43,4 @@ declare abstract class BaseEnvRunner implements EnvRunner {
   protected abstract _closeRuntime(): Promise<void>;
   protected abstract _runtimeType(): string;
 }
-//#endregion
 export { EnvRunnerData as n, BaseEnvRunner as t };

package/dist/_chunks/base-runner.mjs

@@ -1,6 +1,5 @@
 import { rm } from "node:fs/promises";
 import { proxyFetch, proxyUpgrade } from "httpxy";
-//#region src/common/base-runner.ts
 var BaseEnvRunner = class {
 	closed = false;
 	_name;
@@ -125,5 +124,4 @@ var BaseEnvRunner = class {
 		this._address = void 0;
 	}
 };
-//#endregion
 export { BaseEnvRunner as t };

package/dist/_chunks/libs/cjs-module-lexer.mjs

@@ -1,4 +1,3 @@
-//#region node_modules/.pnpm/cjs-module-lexer@2.2.0/node_modules/cjs-module-lexer/dist/lexer.mjs
 let A;
 const B = 1 === new Uint8Array(new Uint16Array([1]).buffer)[0];
 function parse(E, g = "@") {
@@ -143,5 +142,4 @@ function init() {
 		A = Q;
 	})());
 }
-//#endregion
 export { parse as n, init as t };

package/dist/_chunks/runner.d.mts

@@ -1,7 +1,5 @@
 import { u as WorkerHooks } from "./types.mjs";
 import { n as EnvRunnerData, t as BaseEnvRunner } from "./base-runner.mjs";
-
-//#region src/runners/deno-process/runner.d.ts
 declare class DenoProcessEnvRunner extends BaseEnvRunner {
   #private;
   constructor(opts: {
@@ -16,5 +14,4 @@ declare class DenoProcessEnvRunner extends BaseEnvRunner {
   protected _runtimeType(): string;
   protected _closeRuntime(): Promise<void>;
 }
-//#endregion
 export { DenoProcessEnvRunner as t };

package/dist/_chunks/runner.mjs

@@ -2,7 +2,6 @@ import { t as BaseEnvRunner } from "./base-runner.mjs";
 import { existsSync } from "node:fs";
 import { spawn } from "node:child_process";
 import { fileURLToPath } from "node:url";
-//#region src/runners/deno-process/runner.ts
 let _defaultEntry;
 var DenoProcessEnvRunner = class extends BaseEnvRunner {
 	#process;
@@ -44,8 +43,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 +53,7 @@ var DenoProcessEnvRunner = class extends BaseEnvRunner {
 			stdio: [
 				"pipe",
 				"pipe",
-				"pipe",
-				"ipc"
+				"pipe"
 			]
 		});
 		const exited = new Promise((resolve) => {
@@ -63,7 +62,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,11 +79,19 @@ 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;
 	}
 };
-//#endregion
 export { DenoProcessEnvRunner as t };

package/dist/_chunks/runner2.d.mts

@@ -2,8 +2,6 @@ import { u as WorkerHooks } from "./types.mjs";
 import { n as EnvRunnerData, t as BaseEnvRunner } from "./base-runner.mjs";
 import { IncomingMessage } from "node:http";
 import { Socket } from "node:net";
-
-//#region src/runners/miniflare/runner.d.ts
 /** Result from a module transform (compatible with Vite's `TransformResult`). */
 interface TransformResult {
   code: string;
@@ -46,6 +44,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;
@@ -75,5 +81,4 @@ declare class MiniflareEnvRunner extends BaseEnvRunner {
     };
   }): Promise<void>;
 }
-//#endregion
 export { TransformResult as i, MiniflareEnvRunnerOptions as n, MiniflareExportInfo as r, MiniflareEnvRunner as t };

package/dist/_chunks/runner2.mjs

@@ -5,26 +5,9 @@ import { proxyUpgrade } from "httpxy";
 import { readFileSync } from "node:fs";
 import { fileURLToPath } from "node:url";
 import { basename, dirname, resolve } from "node:path";
-//#region src/runners/miniflare/wrapper.ts
-const IPC_PATH$1 = "/__env_runner_ipc";
-/** Service binding name used for cross-request IPC (worker → runner). */
+import { resolveModulePath } from "exsolve";
+const IPC_PATH = "/__env_runner_ipc";
 const IPC_BINDING = "__ENV_RUNNER_IPC";
-/**
-* Generates a wrapper module that imports the user entry and adds IPC glue.
-*
-* The user module is expected to export `fetch` and optionally `ipc`.
-* The wrapper uses a persistent WebSocket pair for bidirectional IPC:
-* - Init: `fetch` with `upgrade: websocket` creates a WebSocketPair
-* - Messages: JSON over the WebSocket (no per-message `dispatchFetch`)
-* - Reload: `{ type: "reload" }` triggers cache-busted re-import
-* - Shutdown: `{ type: "shutdown" }` calls `ipc.onClose()`
-*
-* For outgoing messages during fetch request handling, uses a service binding
-* (`__ENV_RUNNER_IPC`) to avoid workerd's cross-request I/O restriction on
-* the WebSocket object.
-*
-* Passed as an in-memory `script` to Miniflare (no temp files needed).
-*/
 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") : "";
@@ -47,7 +30,7 @@ if (!globalThis.process) { globalThis.process = __process; }
 ${staticReExport}
 ${explicitExports}
 
-const __IPC_PATH = "${IPC_PATH$1}";
+const __IPC_PATH = "${IPC_PATH}";
 const __IPC_BINDING = "${IPC_BINDING}";
 const __entryPath = ${JSON.stringify(entryPath)};
 let __userEntry;
@@ -193,9 +176,6 @@ export default {
 };
 `;
 }
-//#endregion
-//#region src/runners/miniflare/runner.ts
-const IPC_PATH = "/__env_runner_ipc";
 const _miniflareCache = /* @__PURE__ */ new Map();
 var MiniflareEnvRunner = class extends BaseEnvRunner {
 	#miniflare;
@@ -207,6 +187,7 @@ var MiniflareEnvRunner = class extends BaseEnvRunner {
 	#cacheKey;
 	#exports;
 	#captureErrors;
+	#exportConditions;
 	constructor(opts) {
 		super({
 			...opts,
@@ -217,15 +198,14 @@ 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. */
 	static async disposeAll() {
 		const entries = [..._miniflareCache.values()];
 		_miniflareCache.clear();
 		for (const entry of entries) await entry.mf.dispose().catch(() => {});
 	}
-	/** Fully dispose the Miniflare instance (even if persistent). */
 	async dispose() {
 		if (this.#miniflare) {
 			if (this.#ws) {
@@ -264,13 +244,6 @@ var MiniflareEnvRunner = class extends BaseEnvRunner {
 			data: message
 		}));
 	}
-	/**
-	* Hot-reload the user entry module without recreating the Miniflare instance.
-	*
-	* Sends `reload-module` event over the WebSocket. The worker wrapper uses
-	* `unsafeEvalBinding` to re-import the entry with a cache-busting query string
-	* and responds with `module-reloaded` when done.
-	*/
 	async reloadModule(timeout = 5e3) {
 		if (!this.#ws) throw new Error("Miniflare env runner should be initialized before reloading.");
 		if (!this._data?.entry) return;
@@ -399,6 +372,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 +396,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 +405,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 +465,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;
@@ -501,7 +483,7 @@ var MiniflareEnvRunner = class extends BaseEnvRunner {
 				refCount: 1
 			});
 		}
-		const initRes = await this.#miniflare.dispatchFetch("http://localhost" + IPC_PATH, { headers: { upgrade: "websocket" } });
+		const initRes = await this.#miniflare.dispatchFetch("http://localhost/__env_runner_ipc", { headers: { upgrade: "websocket" } });
 		const ws = initRes.webSocket;
 		if (!ws) {
 			const body = await initRes.text().catch(() => "");
@@ -521,10 +503,6 @@ var MiniflareEnvRunner = class extends BaseEnvRunner {
 		} });
 	}
 };
-/**
-* Detect `export class` declarations in the entry file.
-* Merges with explicitly declared exports from options.
-*/
 function detectExportedClasses(entryPath, explicit) {
 	const names = new Set(Object.keys(explicit));
 	try {
@@ -535,11 +513,9 @@ function detectExportedClasses(entryPath, explicit) {
 	} catch {}
 	return [...names];
 }
-/** Convert PascalCase/camelCase to SCREAMING_SNAKE_CASE (e.g. `Counter` → `COUNTER`, `MyDurableObject` → `MY_DURABLE_OBJECT`). */
 function toScreamingSnakeCase(name) {
 	return name.replace(/([a-z0-9])([A-Z])/g, "$1_$2").toUpperCase();
 }
-/** Compute a stable cache key for persistent Miniflare instances. */
 function computeCacheKey(entryPath, opts) {
 	const serializableOpts = {};
 	for (const [k, v] of Object.entries(opts)) if (typeof v !== "function") serializableOpts[k] = v;
@@ -560,5 +536,4 @@ function createCjsEsmShim(cjsSpecifier, contents) {
 	for (const name of namedExports) shim += `export var ${name} = __cjs_mod__["${name}"];\n`;
 	return shim;
 }
-//#endregion
 export { MiniflareEnvRunner as t };

package/dist/_chunks/runner3.d.mts

@@ -0,0 +1,16 @@
+import { u as WorkerHooks } from "./types.mjs";
+import { n as EnvRunnerData, t as BaseEnvRunner } from "./base-runner.mjs";
+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>;
+}
+export { NodeWorkerEnvRunner as t };

package/dist/_chunks/runner3.mjs

@@ -0,0 +1,60 @@
+import { t as BaseEnvRunner } from "./base-runner.mjs";
+import { existsSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+import { Worker } from "node:worker_threads";
+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;
+	}
+};
+export { NodeWorkerEnvRunner as t };

package/dist/_chunks/runner4.d.mts

@@ -0,0 +1,14 @@
+import { u as WorkerHooks } from "./types.mjs";
+import { n as EnvRunnerData } from "./base-runner.mjs";
+import { t as NodeWorkerEnvRunner } from "./runner3.mjs";
+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;
+}
+export { VercelEnvRunner as t };

package/dist/_chunks/runner4.mjs

@@ -0,0 +1,93 @@
+import { t as NodeWorkerEnvRunner } from "./runner3.mjs";
+import { fileURLToPath } from "node:url";
+import { randomBytes } from "node:crypto";
+let _warned = false;
+function warnIfVercelOidcTokenInvalid(token) {
+	const result = _checkVercelOidcToken(token);
+	if (_warned) return result;
+	if (result.status === "missing") {
+		_warned = true;
+		console.warn("[env-runner:vercel] VERCEL_OIDC_TOKEN is not set. Vercel SDK features (e.g. @vercel/functions waitUntil, cache) may not work. Run `vercel env pull` to set it.");
+	} else if (result.status === "expired") {
+		_warned = true;
+		console.warn(`[env-runner:vercel] VERCEL_OIDC_TOKEN expired at ${result.expiresAt.toISOString()}. Vercel SDK authentication will fail. Run \`vercel env pull\` to refresh it.`);
+	} else if (result.status === "invalid") {
+		_warned = true;
+		console.warn("[env-runner:vercel] VERCEL_OIDC_TOKEN is malformed (not a valid JWT). Vercel SDK authentication will fail. Run `vercel env pull` to get a fresh token.");
+	}
+	return result;
+}
+function _checkVercelOidcToken(token = process.env.VERCEL_OIDC_TOKEN) {
+	if (!token) return { status: "missing" };
+	const parts = token.split(".");
+	if (parts.length !== 3) return { status: "invalid" };
+	let payload;
+	try {
+		const json = Buffer.from(parts[1], "base64url").toString("utf8");
+		payload = JSON.parse(json);
+	} catch {
+		return { status: "invalid" };
+	}
+	if (!payload || typeof payload !== "object") return { status: "invalid" };
+	const exp = payload.exp;
+	if (typeof exp !== "number" || !Number.isFinite(exp)) return { status: "invalid" };
+	const expiresAt = /* @__PURE__ */ new Date(exp * 1e3);
+	if (expiresAt.getTime() <= Date.now()) return {
+		status: "expired",
+		expiresAt
+	};
+	return {
+		status: "valid",
+		expiresAt
+	};
+}
+let _defaultEntry;
+const _podId = Math.random().toString(32).slice(-5);
+function generateVercelId() {
+	return `dev1::${_podId}-${Date.now().toString(36)}-${randomBytes(6).toString("hex")}`;
+}
+var VercelEnvRunner = class extends NodeWorkerEnvRunner {
+	constructor(opts) {
+		_defaultEntry ||= fileURLToPath(import.meta.resolve("env-runner/runners/vercel/worker"));
+		super({
+			...opts,
+			workerEntry: opts.workerEntry || _defaultEntry
+		});
+		warnIfVercelOidcTokenInvalid();
+	}
+	async fetch(input, init) {
+		const headers = new Headers(input instanceof Request ? input.headers : init?.headers);
+		const requestId = generateVercelId();
+		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}`);
+		}
+		if (!headers.has("x-vercel-id")) headers.set("x-vercel-id", requestId);
+		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 {}
+		const res = await super.fetch(input, {
+			...init,
+			headers
+		});
+		const resHeaders = new Headers(res.headers);
+		if (!resHeaders.has("server")) resHeaders.set("server", "Vercel");
+		if (!resHeaders.has("x-vercel-id")) resHeaders.set("x-vercel-id", requestId);
+		if (!resHeaders.has("x-vercel-cache")) resHeaders.set("x-vercel-cache", "MISS");
+		return new Response(res.body, {
+			status: res.status,
+			statusText: res.statusText,
+			headers: resHeaders
+		});
+	}
+	_runtimeType() {
+		return "vercel";
+	}
+};
+export { VercelEnvRunner as t };

package/dist/_chunks/runner5.d.mts

@@ -0,0 +1,14 @@
+import { u as WorkerHooks } from "./types.mjs";
+import { n as EnvRunnerData } from "./base-runner.mjs";
+import { t as NodeWorkerEnvRunner } from "./runner3.mjs";
+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;
+}
+export { NetlifyEnvRunner as t };

package/dist/_chunks/runner5.mjs

@@ -0,0 +1,45 @@
+import { t as NodeWorkerEnvRunner } from "./runner3.mjs";
+import { fileURLToPath } from "node:url";
+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";
+	}
+};
+export { NetlifyEnvRunner as t };