env-runner 0.0.0 → 0.1.1

package/LICENSE

@@ -0,0 +1,21 @@
+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/README.md

@@ -0,0 +1,261 @@
+# env-runner
+
+<!-- automd:badges color=yellow -->
+
+[![npm version](https://img.shields.io/npm/v/env-runner?color=yellow)](https://npmjs.com/package/env-runner)
+[![npm downloads](https://img.shields.io/npm/dm/env-runner?color=yellow)](https://npm.chart.dev/env-runner)
+
+<!-- /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.
+
+## Usage
+
+### App Entry
+
+Create a server entry module that exports a `fetch` handler:
+
+```ts
+// app.ts
+export default {
+  fetch(request: Request) {
+    return new Response("Hello!");
+  },
+};
+```
+
+### CLI
+
+The quickest way to run your app:
+
+```bash
+npx env-runner app.ts
+```
+
+**Flags:**
+
+| Flag              | Description                                                                                       | Default        |
+| ----------------- | ------------------------------------------------------------------------------------------------- | -------------- |
+| `--runner <name>` | Runner to use (`node-worker`, `node-process`, `bun-process`, `deno-process`, `self`, `miniflare`) | `node-process` |
+| `--port <port>`   | Port to listen on                                                                                 | `3000`         |
+| `--host <host>`   | Host to bind to                                                                                   | `localhost`    |
+| `-w, --watch`     | Watch entry file for changes and auto-reload                                                      |                |
+
+### Server (`EnvServer`)
+
+High-level API that combines runner loading, file watching, and auto-reload:
+
+```ts
+import { serve } from "srvx";
+import { EnvServer } from "env-runner";
+
+const envServer = new EnvServer({
+  runner: "node-process",
+  entry: "./app.ts",
+  watch: true,
+  watchPaths: ["./src"],
+});
+
+envServer.onReady = (_runner, address) => {
+  console.log(`Worker ready on ${address?.host}:${address?.port}`);
+};
+
+envServer.onReload = () => {
+  console.log("Reloaded!");
+};
+
+await envServer.start();
+
+// Use with any HTTP server
+const server = serve({
+  fetch: (request) => envServer.fetch(request),
+});
+```
+
+### Manager (`RunnerManager`)
+
+Proxy manager for hot-reload with message queueing and listener forwarding:
+
+```ts
+import { RunnerManager, NodeProcessEnvRunner } from "env-runner";
+
+const manager = new RunnerManager();
+
+manager.onReady = (_runner, address) => {
+  console.log("Ready:", address);
+};
+
+// Load initial runner
+const runner = new NodeProcessEnvRunner({
+  name: "my-app",
+  data: { entry: "./app.ts" },
+});
+await manager.reload(runner);
+
+// Proxy requests
+const response = await manager.fetch("http://localhost/hello");
+
+// Hot-reload with a new runner
+const newRunner = new NodeProcessEnvRunner({
+  name: "my-app",
+  data: { entry: "./app.ts" },
+});
+await manager.reload(newRunner); // old runner is closed automatically
+
+// Bidirectional messaging (queued until runner is ready)
+manager.sendMessage({ type: "config", value: 42 });
+manager.onMessage((msg) => console.log("From worker:", msg));
+
+await manager.close();
+```
+
+### Runners
+
+Use runners directly for lower-level control:
+
+```ts
+import { NodeWorkerEnvRunner } from "env-runner/runners/node-worker";
+import { NodeProcessEnvRunner } from "env-runner/runners/node-process";
+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";
+```
+
+All runners implement the [`EnvRunner`](./src/types.ts) interface:
+
+```ts
+const runner = new NodeProcessEnvRunner({
+  name: "my-app",
+  data: { entry: "./app.ts" },
+  hooks: {
+    onReady: (runner, address) => console.log("Listening on", address),
+    onClose: (runner, cause) => console.log("Closed", cause),
+  },
+  execArgv: ["--inspect"], // Node.js flags (process-based runners)
+});
+
+// Proxy HTTP requests (retries with exponential backoff)
+const response = await runner.fetch("http://localhost/api");
+
+// Proxy WebSocket upgrades
+runner.upgrade?.({ node: { req, socket, head } });
+
+// Bidirectional messaging
+runner.sendMessage({ type: "ping" });
+runner.onMessage((msg) => console.log(msg));
+
+// Graceful shutdown
+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) | `serviceBindings` + `dispatchFetch` |
+
+#### Miniflare Runner
+
+Run your app in the Cloudflare Workers runtime using [miniflare](https://github.com/cloudflare/workers-sdk/tree/main/packages/miniflare):
+
+```bash
+npm install miniflare
+```
+
+```ts
+import { MiniflareEnvRunner } from "env-runner/runners/miniflare";
+
+const runner = new MiniflareEnvRunner({
+  name: "my-worker",
+  data: { entry: "./worker.ts" },
+  miniflareOptions: {
+    compatibilityDate: "2024-01-01",
+    kvNamespaces: ["MY_KV"],
+  },
+});
+
+const response = await runner.fetch("http://localhost/api");
+await runner.close();
+```
+
+The `miniflareOptions` object is passed directly to the [Miniflare constructor](https://developers.cloudflare.com/workers/testing/miniflare/) — you can configure bindings, KV, D1, Durable Objects, and any other Miniflare option.
+
+You can also use `loadRunner()` to dynamically load a runner by name:
+
+```ts
+import { loadRunner } from "env-runner";
+
+const runner = await loadRunner("node-worker", {
+  name: "my-app",
+  data: { entry: "./app.ts" },
+});
+```
+
+### Workers
+
+Each IPC-based runner includes a built-in worker that handles the srvx server boilerplate. You just provide an entry module:
+
+```ts
+// app.ts
+export default {
+  fetch(request: Request) {
+    return new Response("Hello!");
+  },
+  middleware: [], // Optional srvx middleware
+  plugins: [], // Optional srvx plugins
+  ipc: {
+    onOpen({ sendMessage }) {
+      // IPC channel is ready — send messages back to the runner
+      sendMessage({ type: "hello", from: "worker" });
+    },
+    onMessage(message) {
+      // Receive messages from the runner
+      console.log("Got message:", message);
+    },
+    onClose() {
+      // Runner is shutting down
+    },
+  },
+};
+```
+
+The built-in worker automatically:
+
+1. Imports your entry module
+2. Starts a [srvx](https://srvx.h3.dev) server on a random port
+3. Reports the address back to the runner via IPC
+4. Handles graceful shutdown
+
+For advanced use cases, you can provide a custom worker entry:
+
+```ts
+const runner = new NodeProcessEnvRunner({
+  name: "my-app",
+  workerEntry: "/path/to/custom-worker.ts",
+  data: { entry: "./app.ts" },
+});
+```
+
+## Development
+
+<details>
+
+<summary>local development</summary>
+
+- Clone this repository
+- Install latest LTS version of [Node.js](https://nodejs.org/en/)
+- Enable [Corepack](https://github.com/nodejs/corepack) using `corepack enable`
+- Install dependencies using `pnpm install`
+- Run interactive tests using `pnpm dev`
+
+</details>
+
+## License
+
+Published under the [MIT](https://github.com/unjs/env-runner/blob/main/LICENSE) license 💛.

package/dist/THIRD-PARTY-LICENSES.md

@@ -0,0 +1,33 @@
+# Licenses of Bundled Dependencies
+
+The published artifact additionally contains code with the following licenses:
+MIT
+
+# Bundled Dependencies
+
+## 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

@@ -0,0 +1,105 @@
+import { IncomingMessage } from "node:http";
+import { Socket } from "node:net";
+
+//#region src/types.d.ts
+/** Handler for proxying HTTP requests to the worker. */
+type FetchHandler = (input: string | URL | Request, init?: RequestInit) => Promise<Response>;
+/** Callback for receiving messages from the worker. */
+type RunnerMessageListener = (data: unknown) => void;
+/** Raw Node.js upgrade request context. */
+interface NodeUpgradeContext {
+  req: IncomingMessage;
+  socket: Socket;
+  head: any;
+}
+/** Context passed to the upgrade handler for WebSocket upgrades. */
+interface UpgradeContext {
+  node: NodeUpgradeContext;
+}
+/** Handler for proxying WebSocket upgrade requests to the worker. */
+type UpgradeHandler = (context: UpgradeContext) => void;
+/** Bidirectional RPC messaging interface between the runner and worker. */
+interface RunnerRPCHooks {
+  /** Send a message to the worker. */
+  sendMessage: (message: unknown) => void;
+  /** Register a listener for messages from the worker. */
+  onMessage: (listener: RunnerMessageListener) => void;
+  /** Remove a previously registered message listener. */
+  offMessage: (listener: RunnerMessageListener) => void;
+}
+/**
+ * Address reported by the worker once it is ready.
+ *
+ * Either a TCP `host`/`port` pair or a Unix `socketPath`.
+ */
+type WorkerAddress = {
+  host?: string;
+  port: number;
+  socketPath?: undefined;
+} | {
+  host?: undefined;
+  port?: undefined;
+  socketPath: string;
+};
+/** Lifecycle hooks for observing runner state changes. */
+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;
+}
+/** Core runner interface combining lifecycle hooks, RPC, and request proxying. */
+interface EnvRunner extends WorkerHooks, RunnerRPCHooks {
+  /** Whether the worker is ready to accept requests. */
+  readonly ready: boolean;
+  /** Whether the runner has been closed. */
+  readonly closed: boolean;
+  /** Proxy an HTTP request to the worker. */
+  fetch: FetchHandler;
+  /** Proxy a WebSocket upgrade request to the worker. */
+  upgrade?: UpgradeHandler;
+  /** Gracefully shut down the worker. */
+  close(): Promise<void>;
+}
+//#endregion
+//#region src/common/base-runner.d.ts
+interface EnvRunnerData {
+  name?: string;
+  [key: string]: unknown;
+}
+declare abstract class BaseEnvRunner implements EnvRunner {
+  closed: boolean;
+  protected _name: string;
+  protected _workerEntry: string;
+  protected _data?: EnvRunnerData;
+  protected _hooks: Partial<WorkerHooks>;
+  protected _address?: WorkerAddress;
+  protected _messageListeners: Set<(data: unknown) => void>;
+  constructor(opts: {
+    name: string;
+    workerEntry: string;
+    hooks?: WorkerHooks;
+    data?: EnvRunnerData;
+  });
+  get ready(): boolean;
+  fetch(input: string | URL | Request, init?: RequestInit): Promise<Response>;
+  upgrade(context: {
+    node: {
+      req: IncomingMessage;
+      socket: Socket;
+      head: any;
+    };
+  }): Promise<void>;
+  abstract sendMessage(message: unknown): void;
+  onMessage(listener: RunnerMessageListener): void;
+  offMessage(listener: RunnerMessageListener): void;
+  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;
+}
+//#endregion
+export { NodeUpgradeContext as a, UpgradeContext as c, WorkerHooks as d, FetchHandler as i, UpgradeHandler as l, EnvRunnerData as n, RunnerMessageListener as o, EnvRunner as r, RunnerRPCHooks as s, BaseEnvRunner as t, WorkerAddress as u };

package/dist/_chunks/base-runner.mjs

@@ -0,0 +1,79 @@
+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
+var BaseEnvRunner = class {
+	closed = false;
+	_name;
+	_workerEntry;
+	_data;
+	_hooks;
+	_address;
+	_messageListeners;
+	constructor(opts) {
+		this._name = opts.name;
+		this._workerEntry = opts.workerEntry;
+		this._data = opts.data;
+		this._hooks = opts.hooks || {};
+		this._messageListeners = /* @__PURE__ */ new Set();
+	}
+	get ready() {
+		return Boolean(!this.closed && this._address && this._hasRuntime());
+	}
+	async fetch(input, init) {
+		for (let i = 0; i < 5 && !this._address && !this.closed; i++) await new Promise((r) => setTimeout(r, 100 * Math.pow(2, i)));
+		if (!this._address) return new Response(`${this._runtimeType()} env runner is unavailable`, { status: 503 });
+		return proxyFetch(this._address, input, init);
+	}
+	async upgrade(context) {
+		if (!this.ready || !this._address) return;
+		await proxyUpgrade(this._address, context.node.req, context.node.socket, context.node.head);
+	}
+	onMessage(listener) {
+		this._messageListeners.add(listener);
+	}
+	offMessage(listener) {
+		this._messageListeners.delete(listener);
+	}
+	async close(cause) {
+		if (this.closed) return;
+		this.closed = true;
+		this._hooks.onClose?.(this, cause);
+		this._hooks = {};
+		const onError = (error) => console.error(error);
+		await this._closeRuntime().catch(onError);
+		await this._closeSocket().catch(onError);
+	}
+	[Symbol.for("nodejs.util.inspect.custom")]() {
+		const status = this.closed ? "closed" : this.ready ? "ready" : "pending";
+		return `${this.constructor.name}#${this._name}(${status})`;
+	}
+	_handleMessage(message) {
+		if (message?.address) {
+			this._address = message.address;
+			this._hooks.onReady?.(this, this._address);
+		}
+		for (const listener of this._messageListeners) listener(message);
+	}
+	async _closeSocket() {
+		const socketPath = this._address?.socketPath;
+		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/std-env.mjs

@@ -0,0 +1,171 @@
+//#region node_modules/.deno/std-env@4.0.0-rc.1/node_modules/std-env/dist/index.mjs
+const e = globalThis.process?.env || Object.create(null), t = globalThis.process || { env: e }, n = t !== void 0 && t.env && t.env.NODE_ENV || void 0, r = [
+	[`claude`, [`CLAUDECODE`, `CLAUDE_CODE`]],
+	[`replit`, [`REPL_ID`]],
+	[`gemini`, [`GEMINI_CLI`]],
+	[`codex`, [`CODEX_SANDBOX`, `CODEX_THREAD_ID`]],
+	[`opencode`, [`OPENCODE`]],
+	[`pi`, [i(`PATH`, /\.pi[\\/]agent/)]],
+	[`auggie`, [`AUGMENT_AGENT`]],
+	[`goose`, [`GOOSE_PROVIDER`]],
+	[`devin`, [i(`EDITOR`, /devin/)]],
+	[`cursor`, [`CURSOR_AGENT`]],
+	[`kiro`, [i(`TERM_PROGRAM`, /kiro/)]]
+];
+function i(t, n) {
+	return () => {
+		let r = e[t];
+		return r ? n.test(r) : !1;
+	};
+}
+function a() {
+	let t = e.AI_AGENT;
+	if (t) return { name: t.toLowerCase() };
+	for (let [t, n] of r) for (let r of n) if (typeof r == `string` ? e[r] : r()) return { name: t };
+	return {};
+}
+const o = a();
+o.name;
+o.name;
+const l = [
+	[`APPVEYOR`],
+	[
+		`AWS_AMPLIFY`,
+		`AWS_APP_ID`,
+		{ ci: !0 }
+	],
+	[`AZURE_PIPELINES`, `SYSTEM_TEAMFOUNDATIONCOLLECTIONURI`],
+	[`AZURE_STATIC`, `INPUT_AZURE_STATIC_WEB_APPS_API_TOKEN`],
+	[`APPCIRCLE`, `AC_APPCIRCLE`],
+	[`BAMBOO`, `bamboo_planKey`],
+	[`BITBUCKET`, `BITBUCKET_COMMIT`],
+	[`BITRISE`, `BITRISE_IO`],
+	[`BUDDY`, `BUDDY_WORKSPACE_ID`],
+	[`BUILDKITE`],
+	[`CIRCLE`, `CIRCLECI`],
+	[`CIRRUS`, `CIRRUS_CI`],
+	[
+		`CLOUDFLARE_PAGES`,
+		`CF_PAGES`,
+		{ ci: !0 }
+	],
+	[
+		`CLOUDFLARE_WORKERS`,
+		`WORKERS_CI`,
+		{ ci: !0 }
+	],
+	[`GOOGLE_CLOUDRUN`, `K_SERVICE`],
+	[`GOOGLE_CLOUDRUN_JOB`, `CLOUD_RUN_JOB`],
+	[`CODEBUILD`, `CODEBUILD_BUILD_ARN`],
+	[`CODEFRESH`, `CF_BUILD_ID`],
+	[`DRONE`],
+	[`DRONE`, `DRONE_BUILD_EVENT`],
+	[`DSARI`],
+	[`GITHUB_ACTIONS`],
+	[`GITLAB`, `GITLAB_CI`],
+	[`GITLAB`, `CI_MERGE_REQUEST_ID`],
+	[`GOCD`, `GO_PIPELINE_LABEL`],
+	[`LAYERCI`],
+	[`JENKINS`, `JENKINS_URL`],
+	[`HUDSON`, `HUDSON_URL`],
+	[`MAGNUM`],
+	[`NETLIFY`],
+	[
+		`NETLIFY`,
+		`NETLIFY_LOCAL`,
+		{ ci: !1 }
+	],
+	[`NEVERCODE`],
+	[`RENDER`],
+	[`SAIL`, `SAILCI`],
+	[`SEMAPHORE`],
+	[`SCREWDRIVER`],
+	[`SHIPPABLE`],
+	[`SOLANO`, `TDDIUM`],
+	[`STRIDER`],
+	[`TEAMCITY`, `TEAMCITY_VERSION`],
+	[`TRAVIS`],
+	[`VERCEL`, `NOW_BUILDER`],
+	[
+		`VERCEL`,
+		`VERCEL`,
+		{ ci: !1 }
+	],
+	[
+		`VERCEL`,
+		`VERCEL_ENV`,
+		{ ci: !1 }
+	],
+	[`APPCENTER`, `APPCENTER_BUILD_ID`],
+	[
+		`CODESANDBOX`,
+		`CODESANDBOX_SSE`,
+		{ ci: !1 }
+	],
+	[
+		`CODESANDBOX`,
+		`CODESANDBOX_HOST`,
+		{ ci: !1 }
+	],
+	[`STACKBLITZ`],
+	[`STORMKIT`],
+	[`CLEAVR`],
+	[`ZEABUR`],
+	[
+		`CODESPHERE`,
+		`CODESPHERE_APP_ID`,
+		{ ci: !0 }
+	],
+	[`RAILWAY`, `RAILWAY_PROJECT_ID`],
+	[`RAILWAY`, `RAILWAY_SERVICE_ID`],
+	[`DENO-DEPLOY`, `DENO_DEPLOY`],
+	[`DENO-DEPLOY`, `DENO_DEPLOYMENT_ID`],
+	[
+		`FIREBASE_APP_HOSTING`,
+		`FIREBASE_APP_HOSTING`,
+		{ ci: !0 }
+	]
+];
+function u() {
+	for (let t of l) if (e[t[1] || t[0]]) return {
+		name: t[0].toLowerCase(),
+		...t[2]
+	};
+	return e.SHELL === `/bin/jsh` && t.versions?.webcontainer ? {
+		name: `stackblitz`,
+		ci: !1
+	} : {
+		name: ``,
+		ci: !1
+	};
+}
+const d = u();
+d.name;
+const p = t.platform || ``, m = !!e.CI || d.ci !== !1, h = !!t.stdout?.isTTY;
+e.DEBUG;
+const v = n === `test` || !!e.TEST;
+n === `production` || e.MODE;
+n === `dev` || n === `development` || e.MODE;
+e.MINIMAL;
+const S = /^win/i.test(p);
+/^linux/i.test(p);
+/^darwin/i.test(p);
+!e.NO_COLOR && (e.FORCE_COLOR || (h || S) && e.TERM);
+const E = (t.versions?.node || ``).replace(/^v/, ``) || null;
+Number(E?.split(`.`)[0]);
+const O = !!t?.versions?.node, k = `Bun` in globalThis, A = `Deno` in globalThis, j = `fastly` in globalThis, M = `Netlify` in globalThis, N = `EdgeRuntime` in globalThis, P = globalThis.navigator?.userAgent === `Cloudflare-Workers`, F = [
+	[M, `netlify`],
+	[N, `edge-light`],
+	[P, `workerd`],
+	[j, `fastly`],
+	[A, `deno`],
+	[k, `bun`],
+	[O, `node`]
+];
+function I() {
+	let e = F.find((e) => e[0]);
+	if (e) return { name: e[1] };
+}
+I()?.name;
+//#endregion
+export { v as n, m as t };

package/dist/_chunks/runner.d.mts

@@ -0,0 +1,19 @@
+import { d as WorkerHooks, 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: {
+    name: string;
+    workerEntry?: string;
+    hooks?: WorkerHooks;
+    data?: EnvRunnerData;
+    execArgv?: string[];
+  });
+  sendMessage(message: unknown): void;
+  protected _hasRuntime(): boolean;
+  protected _runtimeType(): string;
+  protected _closeRuntime(): Promise<void>;
+}
+//#endregion
+export { DenoProcessEnvRunner as t };