env-runner 0.1.5 → 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
 
@@ -56,13 +56,13 @@ const envServer = new EnvServer({
   watchPaths: ["./src"],
 });
 
-envServer.onReady = (_runner, address) => {
+envServer.onReady((_runner, address) => {
   console.log(`Worker ready on ${address?.host}:${address?.port}`);
-};
+});
 
-envServer.onReload = () => {
+envServer.onReload(() => {
   console.log("Reloaded!");
-};
+});
 
 await envServer.start();
 
@@ -81,9 +81,9 @@ import { RunnerManager, NodeProcessEnvRunner } from "env-runner";
 
 const manager = new RunnerManager();
 
-manager.onReady = (_runner, address) => {
+manager.onReady((_runner, address) => {
   console.log("Ready:", address);
-};
+});
 
 // Load initial runner
 const runner = new NodeProcessEnvRunner({
@@ -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/THIRD-PARTY-LICENSES.md

@@ -21,32 +21,3 @@ Repository: https://github.com/nodejs/cjs-module-lexer
 > The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
 > 
 > THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-
----------------------------------------
-
-## std-env
-
-License: MIT
-Repository: https://github.com/unjs/std-env
-
-> MIT License
-> 
-> Copyright (c) Pooya Parsa <pooya@pi0.io>
-> 
-> Permission is hereby granted, free of charge, to any person obtaining a copy
-> of this software and associated documentation files (the "Software"), to deal
-> in the Software without restriction, including without limitation the rights
-> to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-> copies of the Software, and to permit persons to whom the Software is
-> furnished to do so, subject to the following conditions:
-> 
-> The above copyright notice and this permission notice shall be included in all
-> copies or substantial portions of the Software.
-> 
-> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-> IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-> FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-> AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-> LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-> OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-> SOFTWARE.

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

@@ -41,7 +41,6 @@ declare abstract class BaseEnvRunner implements EnvRunner {
   close(cause?: unknown): Promise<void>;
   protected _handleMessage(message: any): void;
   protected _closeSocket(): Promise<void>;
-  protected _requestGracefulShutdown(sendShutdown: () => void, listenForExit: (resolve: () => void) => void, hasExited: () => boolean): Promise<void>;
   protected abstract _hasRuntime(): boolean;
   protected abstract _closeRuntime(): Promise<void>;
   protected abstract _runtimeType(): string;

package/dist/_chunks/base-runner.mjs

@@ -1,4 +1,3 @@
-import { n as v, t as m } from "./libs/std-env.mjs";
 import { rm } from "node:fs/promises";
 import { proxyFetch, proxyUpgrade } from "httpxy";
 //#region src/common/base-runner.ts
@@ -125,20 +124,6 @@ var BaseEnvRunner = class {
 		if (socketPath && socketPath[0] !== "\0" && !socketPath.startsWith(String.raw`\\.\\pipe`)) await rm(socketPath).catch(() => {});
 		this._address = void 0;
 	}
-	async _requestGracefulShutdown(sendShutdown, listenForExit, hasExited) {
-		sendShutdown();
-		if (!hasExited() && !v && !m) await new Promise((resolve) => {
-			const gracefulShutdownTimeoutMs = Number.parseInt(process.env.ENV_RUNNER_SHUTDOWN_TIMEOUT || "", 10) || 5e3;
-			const timeout = setTimeout(() => {
-				console.warn(`force closing node env runner ${this._runtimeType()}...`);
-				resolve();
-			}, gracefulShutdownTimeoutMs);
-			listenForExit(() => {
-				clearTimeout(timeout);
-				resolve();
-			});
-		});
-	}
 };
 //#endregion
 export { BaseEnvRunner as t };

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

@@ -1,4 +1,4 @@
-//#region node_modules/.deno/cjs-module-lexer@2.2.0/node_modules/cjs-module-lexer/dist/lexer.mjs
+//#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 = "@") {

package/dist/_chunks/runner.mjs

@@ -26,13 +26,6 @@ var DenoProcessEnvRunner = class extends BaseEnvRunner {
 	}
 	async _closeRuntime() {
 		if (!this.#process) return;
-		if (this.#process._exitCode == null) await this._requestGracefulShutdown(() => {
-			try {
-				this.#process.send({ event: "shutdown" });
-			} catch {}
-		}, (resolve) => {
-			this.#process?.exited.then(() => resolve());
-		}, () => this.#process?._exitCode != null);
 		this.#process.removeAllListeners?.();
 		try {
 			this.#process.kill();
@@ -51,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
 		], {
@@ -60,8 +54,7 @@ var DenoProcessEnvRunner = class extends BaseEnvRunner {
 			stdio: [
 				"pipe",
 				"pipe",
-				"pipe",
-				"ipc"
+				"pipe"
 			]
 		});
 		const exited = new Promise((resolve) => {
@@ -70,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()
@@ -85,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

@@ -10,6 +10,8 @@ var RunnerManager = class {
 	_messageListeners = /* @__PURE__ */ new Set();
 	_closed = false;
 	_reloading = false;
+	_closeListeners = /* @__PURE__ */ new Set();
+	_readyListeners = /* @__PURE__ */ new Set();
 	constructor(runner) {
 		if (runner) this._attach(runner);
 	}
@@ -106,12 +108,22 @@ var RunnerManager = class {
 		this._detach();
 		if (runner) await runner.close();
 	}
-	onClose;
-	onReady;
+	onClose(listener) {
+		this._closeListeners.add(listener);
+	}
+	offClose(listener) {
+		this._closeListeners.delete(listener);
+	}
+	onReady(listener) {
+		this._readyListeners.add(listener);
+	}
+	offReady(listener) {
+		this._readyListeners.delete(listener);
+	}
 	_internalListener = (message) => {
 		if (message?.address) {
 			this._flushQueue();
-			this.onReady?.(this, message.address);
+			for (const fn of this._readyListeners) fn(this, message.address);
 		}
 	};
 	_attach(runner) {
@@ -123,7 +135,7 @@ var RunnerManager = class {
 			await originalClose();
 			if (this._runner === runner) {
 				this._runner = void 0;
-				this.onClose?.(this);
+				for (const fn of this._closeListeners) fn(this);
 			}
 		};
 		if (runner.ready) this._flushQueue();
@@ -163,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);
@@ -174,9 +188,16 @@ var EnvServer = class extends RunnerManager {
 	_opts;
 	_watchers = [];
 	_reloadTimeout;
+	_reloadListeners = /* @__PURE__ */ new Set();
 	runner = null;
-	/** Called when the runner is reloaded due to a file change. */
-	onReload;
+	/** Register a listener called when the runner is reloaded due to a file change. */
+	onReload(listener) {
+		this._reloadListeners.add(listener);
+	}
+	/** Remove a previously registered reload listener. */
+	offReload(listener) {
+		this._reloadListeners.delete(listener);
+	}
 	constructor(opts) {
 		super();
 		this._opts = opts;
@@ -223,7 +244,7 @@ var EnvServer = class extends RunnerManager {
 			try {
 				this.runner = await this._createRunner();
 				await this.reload(this.runner);
-				this.onReload?.();
+				for (const fn of this._reloadListeners) fn();
 			} catch (error) {
 				console.error("Failed to reload runner:", error);
 			}

package/dist/_chunks/types.d.mts

@@ -54,7 +54,7 @@ interface RPCOptions {
   timeout?: number;
 }
 /** Core runner interface combining lifecycle hooks, RPC, and request proxying. */
-interface EnvRunner extends WorkerHooks, RunnerRPCHooks {
+interface EnvRunner extends RunnerRPCHooks {
   /** Whether the worker is ready to accept requests. */
   readonly ready: boolean;
   /** Whether the runner has been closed. */

package/dist/cli.mjs

@@ -40,12 +40,12 @@ const envServer = new EnvServer({
 	entry: resolve(entry),
 	watch: values.watch
 });
-envServer.onReady = (_runner, address) => {
+envServer.onReady((_runner, address) => {
 	console.log(`\x1B[2m➜ Worker ready on ${address?.host}:${address?.port || address?.socketPath}\x1B[0m`);
-};
-envServer.onReload = () => {
+});
+envServer.onReload(() => {
 	console.log(`\x1B[2m↻ Reloading...\x1B[0m`);
-};
+});
 await envServer.start();
 const server = serve({
 	port: values.port,