env-runner 0.1.16 → 0.2.1

package/README.md

@@ -41,6 +41,8 @@ npx env-runner app.ts
 | `--host <host>`   | Host to bind to                                                                                   | `localhost`    |
 | `-w, --watch`     | Watch entry file for changes and auto-reload                                                      |                |
 
+`--runner miniflare` needs `miniflare` installed in your project — the runner imports it optionally when no module is passed.
+
 ### Server (`EnvServer`)
 
 High-level API that combines runner loading, file watching, and auto-reload:
@@ -54,6 +56,8 @@ const envServer = new EnvServer({
   entry: "./app.ts",
   watch: true,
   watchPaths: ["./src"],
+  // Runner-specific constructor options, e.g. `{ miniflare }` for `runner: "miniflare"`
+  runnerOptions: {},
 });
 
 envServer.onReady((_runner, address) => {
@@ -157,6 +161,29 @@ import { VercelEnvRunner } from "env-runner/runners/vercel";
 import { NetlifyEnvRunner } from "env-runner/runners/netlify";
 ```
 
+#### Runtime dependencies
+
+`env-runner` declares **no peer dependencies**. Runners that build on external packages take them as explicit options instead, and every such option accepts the **same three shapes**:
+
+| Value                                                                       | Meaning                                                                                                     |
+| --------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------- |
+| the imported module (`import * as miniflare from "miniflare"`)              | the version you installed is the version that runs                                                          |
+| a specifier — `"miniflare"`, `import.meta.resolve("miniflare")`, or a `URL` | resolved from the current working directory, so bare specifiers hit your `node_modules`, not `env-runner`'s |
+| `false`                                                                     | opt out of the package entirely                                                                             |
+
+Omitting the option falls back to an optional dynamic import of the package; only then does the runner error (`miniflare`) or degrade (minimal wrangler reader, Netlify shim, queue no-op).
+
+| Runner      | Package            | Option                                   | Without it                            |
+| ----------- | ------------------ | ---------------------------------------- | ------------------------------------- |
+| `miniflare` | `miniflare`        | `miniflare`                              | throws — the runner cannot run        |
+| `miniflare` | `wrangler`         | `wranglerModule`                         | built-in minimal JSON reader          |
+| `vercel`    | `@vercel/queue`    | `sdk` (on `registerVercelQueueConsumer`) | warn-once no-op                       |
+| `netlify`   | `@netlify/runtime` | `netlifyRuntime`                         | lightweight `globalThis.Netlify` shim |
+
+`netlifyRuntime` is the one exception to the table above: the runtime has to start **inside** the worker thread, where a live module instance cannot be handed over, so it accepts a specifier (or `false`) only.
+
+The shared resolver is exported as `resolveRuntimeDep()` (type `RuntimeDep<T>`) if you build runners of your own.
+
 All runners implement the [`EnvRunner`](./src/types.ts) interface:
 
 ```ts
@@ -315,16 +342,20 @@ On `MiniflareEnvRunner` there is no in-worker registration: the runner's module
 
 #### Miniflare Runner
 
-Run your app in the Cloudflare Workers runtime using [miniflare](https://github.com/cloudflare/workers-sdk/tree/main/packages/miniflare):
+Run your app in the Cloudflare Workers runtime using [miniflare](https://github.com/cloudflare/workers-sdk/tree/main/packages/miniflare).
+
+`env-runner` declares no peer dependencies — install `miniflare` yourself and pass it to the runner (see [Runtime dependencies](#runtime-dependencies)):
 
 ```bash
 npm install miniflare
 ```
 
 ```ts
+import * as miniflare from "miniflare";
 import { MiniflareEnvRunner } from "env-runner/runners/miniflare";
 
 await using runner = new MiniflareEnvRunner({
+  miniflare,
   name: "my-worker",
   data: { entry: "./worker.ts" },
   miniflareOptions: {
@@ -336,7 +367,7 @@ await using runner = new MiniflareEnvRunner({
 const response = await runner.fetch("http://localhost/api");
 ```
 
-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.
+Passing `miniflare` explicitly is preferred — the version you install is then the version that runs. A specifier works too (`miniflare: "miniflare"`). If you omit it, the runner imports `miniflare` itself and only fails (with an actionable error) when the package isn't installed either. 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.
 
 When you don't set a `compatibilityDate` (via `miniflareOptions` or a wrangler config), it defaults to the date supported by the installed `workerd` binary rather than today's date — the binary always lags the calendar slightly, and pinning a future date makes `workerd` refuse to start.
 
@@ -348,6 +379,7 @@ Set the `wrangler` option to load a Cloudflare [Wrangler config](https://develop
 import { MiniflareEnvRunner } from "env-runner/runners/miniflare";
 
 await using runner = new MiniflareEnvRunner({
+  miniflare,
   name: "my-worker",
   data: { entry: "./worker.ts" },
   wrangler: true, // auto-discover wrangler.{json,jsonc,toml} next to the entry, then cwd
@@ -362,6 +394,7 @@ You can also pass an **inline** config object (raw `wrangler.json` shape) instea
 
 ```ts
 await using runner = new MiniflareEnvRunner({
+  miniflare,
   name: "my-worker",
   data: { entry: "./worker.ts" },
   wrangler: {
@@ -375,7 +408,22 @@ await using runner = new MiniflareEnvRunner({
 
 When an inline config is passed, a `wrangler.{json,jsonc,toml}` file is still auto-discovered (next to the entry, then cwd) and loaded, and the inline config is **merged on top of it** — inline values win per key, binding records (e.g. `vars`) merge, and `compatibilityFlags` are unioned. This lets you keep a committed `wrangler` file and override a few fields programmatically.
 
-When the [`wrangler`](https://www.npmjs.com/package/wrangler) package is installed (an optional peer dependency), it is used for full fidelity — TOML, `env` inheritance, `.dev.vars`, and every binding type. When `wrangler` is **not** installed, a built-in minimal reader handles plain JSON files and inline objects (common fields only) and logs a one-time warning; JSONC and TOML files are skipped with a warning (they need `wrangler` to parse). Values you pass in `miniflareOptions` always take precedence over config-derived ones — binding records (e.g. `bindings`) merge per key, and `compatibilityFlags` are merged.
+Pass the [`wrangler`](https://www.npmjs.com/package/wrangler) package as `wranglerModule` — the imported module or a specifier — for full fidelity: TOML, `env` inheritance, `.dev.vars`, and every binding type.
+
+```ts
+import * as miniflare from "miniflare";
+import * as wrangler from "wrangler";
+
+await using runner = new MiniflareEnvRunner({
+  miniflare,
+  wranglerModule: wrangler,
+  name: "my-worker",
+  data: { entry: "./worker.ts" },
+  wrangler: true,
+});
+```
+
+Without `wranglerModule`, `wrangler` is imported optionally; if that fails too, a built-in minimal reader handles plain JSON files and inline objects (common fields only) and JSONC/TOML files are skipped with a warning (they need `wrangler` to parse). Pass `wranglerModule: false` to always use the minimal reader. Values you pass in `miniflareOptions` always take precedence over config-derived ones — binding records (e.g. `bindings`) merge per key, and `compatibilityFlags` are merged.
 
 #### Module Transform Pipeline
 
@@ -385,6 +433,7 @@ Pass a `transformRequest` callback to route module resolution through Vite's (or
 import { MiniflareEnvRunner } from "env-runner/runners/miniflare";
 
 await using runner = new MiniflareEnvRunner({
+  miniflare,
   name: "my-worker",
   data: { entry: "./worker.ts" },
   // Route module resolution through Vite's transform pipeline
@@ -424,6 +473,7 @@ To explicitly declare exports or override auto-detection:
 
 ```ts
 await using runner = new MiniflareEnvRunner({
+  miniflare,
   name: "my-worker",
   data: { entry: "./worker.ts" },
   // Explicit exports (merged with auto-detected ones)
@@ -453,6 +503,7 @@ By default, `close()` disposes the Miniflare instance. With `persistent: true`,
 
 ```ts
 const runner1 = new MiniflareEnvRunner({
+  miniflare,
   name: "my-worker",
   data: { entry: "./worker.ts" },
   persistent: true,
@@ -463,6 +514,7 @@ const runner1 = new MiniflareEnvRunner({
 await runner1.close();
 
 const runner2 = new MiniflareEnvRunner({
+  miniflare,
   name: "my-worker",
   data: { entry: "./worker.ts" },
   persistent: true,
@@ -484,6 +536,25 @@ await using runner = new VercelEnvRunner({
 });
 ```
 
+#### Vercel Queues (local delivery)
+
+Framework integrations running inside the vercel runner can bind a topic to a handler for local delivery. Pass [`@vercel/queue`](https://www.npmjs.com/package/@vercel/queue) as `sdk` — the imported module or a specifier (omit it and the SDK is imported optionally; if it isn't installed, registration warns once and becomes a no-op so dev startup is never blocked):
+
+```ts
+import * as sdk from "@vercel/queue";
+import { registerVercelQueueConsumer } from "env-runner/runners/vercel/queue-dev";
+
+const unregister = await registerVercelQueueConsumer({
+  sdk,
+  topic: "orders",
+  handler: (message, metadata) => dispatch(message, metadata),
+  consumerGroup: "my-framework", // re-registering the same group replaces the handler (HMR-safe)
+  retryAfterSeconds: 5, // or `retry: (error, metadata) => ({ acknowledge: true })`
+});
+```
+
+One `QueueClient` is constructed per SDK instance and shared across registrations.
+
 #### 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:
@@ -497,6 +568,18 @@ await using runner = new NetlifyEnvRunner({
 });
 ```
 
+For the full compute runtime — `globalThis.Netlify` with context plus `globalThis.caches` — install [`@netlify/runtime`](https://www.npmjs.com/package/@netlify/runtime) and point the runner at it with `netlifyRuntime`:
+
+```ts
+await using runner = new NetlifyEnvRunner({
+  name: "my-app",
+  netlifyRuntime: import.meta.resolve("@netlify/runtime"),
+  data: { entry: "./app.ts" },
+});
+```
+
+The runtime has to start inside the worker thread, so this is the one runtime-dependency option that takes a module _specifier_ rather than an imported instance — a live module cannot cross that boundary. A bare specifier (`"@netlify/runtime"`) is resolved from the current working directory. If it cannot be imported, the runner warns and falls back to the shim, and `netlifyRuntime: false` forces the shim outright.
+
 ### Vite Environment API
 
 env-runner provides helpers for integrating with Vite's [Environment API](https://vite.dev/guide/api-environment-runtimes.html):
@@ -536,6 +619,7 @@ import { MiniflareEnvRunner } from "env-runner/runners/miniflare";
 import { createViteHotChannel } from "env-runner/vite";
 
 const runner = new MiniflareEnvRunner({
+  miniflare,
   name: "worker",
   data: { entry: "./src/worker.ts" },
   transformRequest: (id) => devEnvironment.transformRequest(id),

package/dist/_chunks/common-host-env.mjs

@@ -0,0 +1,11 @@
+function hostEnv(extra) {
+	const env = {
+		...process.env,
+		...extra
+	};
+	const stdout = process.stdout;
+	if (!("FORCE_COLOR" in env) && !env.NO_COLOR && stdout?.isTTY) env.FORCE_COLOR = "1";
+	if (!("COLUMNS" in env) && stdout?.columns) env.COLUMNS = String(stdout.columns);
+	return env;
+}
+export { hostEnv };

package/dist/_chunks/common-runtime-deps.d.mts

@@ -0,0 +1,51 @@
+/**
+ * A runtime dependency the application owns, not `env-runner`.
+ *
+ * Every runner option that names an external package accepts the same three
+ * shapes, so the choice is about ergonomics rather than per-runner API:
+ *
+ * - the **imported module** (`import * as miniflare from "miniflare"`) — the
+ *   version installed by the app is the version that runs
+ * - a **module specifier** (`"miniflare"`, `import.meta.resolve("miniflare")`,
+ *   or a `URL`) — resolved from {@link ResolveRuntimeDepOptions.from} (cwd by
+ *   default), so a bare specifier resolves against the app rather than against
+ *   `env-runner`'s own `node_modules`
+ * - `false` — opt out of the package entirely
+ *
+ * Omitting the option falls back to an optional `import()` of the package.
+ */
+type RuntimeDep<T> = T | string | URL | false;
+interface ResolveRuntimeDepOptions<T> {
+  /** Package name, used for the fallback import and in messages. */
+  name: string;
+  /** Constructor/function option name, used in messages. */
+  option: string;
+  /** Value as passed by the caller. */
+  value?: RuntimeDep<T>;
+  /**
+   * Named export the resolved module must expose. A module that lacks it is
+   * treated as the wrong package (throws for an explicit value).
+   */
+  expect?: string;
+  /** Directory bare specifiers resolve from. @default process.cwd() */
+  from?: string;
+  /**
+   * Throw when the package cannot be resolved at all. Otherwise an
+   * unavailable optional package resolves to `undefined` and the caller
+   * degrades (minimal reader, shim, no-op).
+   */
+  required?: boolean;
+  /** Extra sentence appended to the "not installed" error when `required`. */
+  hint?: string;
+}
+/**
+ * Resolve a {@link RuntimeDep} to an imported module.
+ *
+ * Resolution order: `false` → `undefined`; an imported module → validated and
+ * returned as-is; a specifier → imported (errors propagate, since an explicit
+ * specifier that cannot load is a mistake worth surfacing); omitted → optional
+ * `import(name)`, which yields `undefined` when the package isn't installed
+ * unless {@link ResolveRuntimeDepOptions.required} is set.
+ */
+declare function resolveRuntimeDep<T>(opts: ResolveRuntimeDepOptions<T>): Promise<T | undefined>;
+export { RuntimeDep, resolveRuntimeDep };

package/dist/_chunks/common-runtime-deps.mjs

@@ -0,0 +1,46 @@
+import { pathToFileURL } from "node:url";
+import { resolveModulePath } from "exsolve";
+function isSpecifier(value) {
+	return typeof value === "string" || value instanceof URL;
+}
+function resolveSpecifier(value, from = process.cwd()) {
+	if (value instanceof URL) return value.href;
+	if (value.includes("://")) return value;
+	const resolved = resolveModulePath(value, {
+		from: from.endsWith("/") ? from : from + "/",
+		try: true
+	});
+	return resolved ? pathToFileURL(resolved).href : value;
+}
+async function resolveRuntimeDep(opts) {
+	const { name, option, value, expect, from, required, hint } = opts;
+	if (value === false) return;
+	if (value !== void 0) {
+		if (!isSpecifier(value)) return validate(value, expect, name, option);
+		const raw = typeof value === "string" ? value : value.href;
+		let mod;
+		try {
+			mod = await import(resolveSpecifier(value, from));
+		} catch (error) {
+			throw new TypeError(`[env-runner] failed to import \`${name}\` from the \`${option}\` specifier "${raw}".`, { cause: error });
+		}
+		return validate(mod, expect, name, option);
+	}
+	try {
+		return validate(await import(resolveSpecifier(name, from)), expect, name, option);
+	} catch (error) {
+		if (required) throw new TypeError(`[env-runner] the \`${name}\` package is required: install it, or pass it as the \`${option}\` option (the imported module or a specifier).` + (hint ? ` ${hint}` : ""), { cause: error });
+		return;
+	}
+}
+function validate(mod, expect, name, option) {
+	if (expect && typeof mod?.[expect] !== "function") throw new TypeError(`[env-runner] the \`${option}\` option does not export \`${expect}\` — pass the imported \`${name}\` package or a specifier for it.`);
+	return mod;
+}
+function resolveRuntimeDepSpecifier(value, option, from) {
+	if (value === false) return false;
+	if (value === void 0) return;
+	if (!isSpecifier(value)) throw new TypeError(`[env-runner] the \`${option}\` option must be a module specifier (string or URL): the package is imported inside the worker, so an imported module cannot be passed. Use \`import.meta.resolve()\`.`);
+	return resolveSpecifier(value, from);
+}
+export { resolveRuntimeDep, resolveRuntimeDepSpecifier };

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

@@ -1,4 +1,5 @@
 import { BaseEnvRunner } from "./common-base-runner.mjs";
+import { hostEnv } from "./common-host-env.mjs";
 import { fileURLToPath } from "node:url";
 import { existsSync } from "node:fs";
 import { spawn } from "node:child_process";
@@ -36,11 +37,10 @@ var DenoProcessEnvRunner = class extends BaseEnvRunner {
 			this.close(`process entry not found in "${this._workerEntry}".`);
 			return;
 		}
-		const env = {
-			...process.env,
+		const env = hostEnv({
 			ENV_RUNNER_NAME: this._name,
 			ENV_RUNNER_DATA: JSON.stringify(this._data || {})
-		};
+		});
 		const child = spawn("deno", [
 			"run",
 			"-A",

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

@@ -2,82 +2,82 @@
 	return A[A.Static = 1] = "Static", A[A.Dynamic = 2] = "Dynamic", A[A.ImportMeta = 3] = "ImportMeta", A[A.StaticSourcePhase = 4] = "StaticSourcePhase", A[A.DynamicSourcePhase = 5] = "DynamicSourcePhase", A[A.StaticDeferPhase = 6] = "StaticDeferPhase", A[A.DynamicDeferPhase = 7] = "DynamicDeferPhase", A;
 })({});
 const A = 1 === new Uint8Array(new Uint16Array([1]).buffer)[0];
-function parse(E, g = "@") {
-	if (!C) return init.then(() => parse(E));
-	const I = E.length + 1, D = (C.__heap_base.value || C.__heap_base) + 4 * I - C.memory.buffer.byteLength;
-	D > 0 && C.memory.grow(Math.ceil(D / 65536));
-	const w = C.sa(I - 1);
-	if ((A ? B : Q)(E, new Uint16Array(C.memory.buffer, w, I)), !C.parse()) throw Object.assign(/* @__PURE__ */ new Error(`Parse error ${g}:${E.slice(0, C.e()).split("\n").length}:${C.e() - E.lastIndexOf("\n", C.e() - 1)}`), { idx: C.e() });
-	const i = [], G = [];
-	for (; C.ri();) {
-		const A = C.is(), Q = C.ie(), B = C.it(), g = C.ai(), I = C.id(), D = C.ss(), w = C.se();
+function parse(C, g = "@") {
+	if (!E) return init.then(() => parse(C, g));
+	const I = C.length + 1, w = (E.__heap_base.value || E.__heap_base) + 4 * I - E.memory.buffer.byteLength;
+	w > 0 && E.memory.grow(Math.ceil(w / 65536));
+	const D = E.sa(I - 1);
+	if ("undefined" != typeof Buffer ? Buffer.from(E.memory.buffer, D, 2 * (I - 1)).write(C, "utf16le") : (A ? Q : B)(C, new Uint16Array(E.memory.buffer, D, I)), !E.parse()) throw Object.assign(/* @__PURE__ */ new Error(`Parse error ${g}:${C.slice(0, E.e()).split("\n").length}:${E.e() - C.lastIndexOf("\n", E.e() - 1)}`), { idx: E.e() });
+	const o = [], G = [];
+	for (; E.ri();) {
+		const A = E.is(), B = E.ie(), Q = E.it(), g = E.ai(), I = E.id(), w = E.ss(), D = E.se();
 		let G;
-		C.ip() && (G = o(E.slice(-1 === I ? A - 1 : A, -1 === I ? Q + 1 : Q)));
-		const R = [];
-		for (C.rsa(); C.ra();) {
-			const A = C.aks(), Q = C.ake(), B = C.avs(), g = C.ave();
-			R.push([s(E.slice(A, Q)), s(E.slice(B, g))]);
+		E.ip() && (G = i(C.slice(-1 === I ? A - 1 : A, -1 === I ? B + 1 : B)));
+		let J = null;
+		for (J = [], E.rsa(); E.ra();) {
+			const A = E.aks(), B = E.ake(), Q = E.avs(), g = E.ave();
+			J.push([s(C.slice(A, B)), s(C.slice(Q, g))]);
 		}
-		i.push({
+		0 === J.length && (J = null), o.push({
 			n: G,
-			t: B,
+			t: Q,
 			s: A,
-			e: Q,
-			ss: D,
-			se: w,
+			e: B,
+			ss: w,
+			se: D,
 			d: I,
 			a: g,
-			at: R.length > 0 ? R : null
+			at: J
 		});
 	}
-	for (; C.re();) {
-		const A = C.es(), Q = C.ee(), B = C.els(), g = C.ele(), I = C.ess(), D = s(E.slice(A, Q)), w = B < 0 ? void 0 : s(E.slice(B, g));
+	for (; E.re();) {
+		const A = E.es(), B = E.ee(), Q = E.els(), g = E.ele(), I = Q < 0 ? void 0 : s(C.slice(Q, g)), w = s(C.slice(A, B));
 		G.push({
 			s: A,
-			e: Q,
-			ls: B,
+			e: B,
+			ls: Q,
 			le: g,
-			ss: I,
-			n: D,
-			ln: w
+			ss: E.ess(),
+			n: w,
+			ln: I
 		});
 	}
-	function o(A) {
+	function i(A) {
 		try {
 			return (0, eval)(A);
 		} catch (A) {}
 	}
 	function s(A) {
 		if (!A) return A;
-		const Q = A[0];
-		return ("\"" === Q || "'" === Q) && o(A) || A;
+		const B = A[0];
+		return ("\"" === B || "'" === B) && i(A) || A;
 	}
 	return [
-		i,
+		o,
 		G,
-		!!C.f(),
-		!!C.ms()
+		!!E.f(),
+		!!E.ms()
 	];
 }
-function Q(A, Q) {
-	const B = A.length;
-	let C = 0;
-	for (; C < B;) {
-		const B = A.charCodeAt(C);
-		Q[C++] = (255 & B) << 8 | B >>> 8;
+function B(A, B) {
+	const Q = A.length;
+	let E = 0;
+	for (; E < Q;) {
+		const Q = A.charCodeAt(E);
+		B[E++] = (255 & Q) << 8 | Q >>> 8;
 	}
 }
-function B(A, Q) {
-	const B = A.length;
-	let C = 0;
-	for (; C < B;) Q[C] = A.charCodeAt(C++);
+function Q(A, B) {
+	const Q = A.length;
+	let E = 0;
+	for (; E < Q;) B[E] = A.charCodeAt(E++);
 }
-let C;
-const E = () => {
-	return A = "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", "undefined" != typeof Buffer ? Buffer.from(A, "base64") : Uint8Array.from(atob(A), (A) => A.charCodeAt(0));
+let E;
+const C = () => {
+	return A = "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", "undefined" != typeof Buffer ? Buffer.from(A, "base64") : Uint8Array.from(atob(A), (A) => A.charCodeAt(0));
 	var A;
 };
-const init = WebAssembly.compile(E()).then(WebAssembly.instantiate).then(({ exports: A }) => {
-	C = A;
+const init = WebAssembly.compile(C()).then(WebAssembly.instantiate).then(({ exports: A }) => {
+	E = A;
 });
 export { init, parse };

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

@@ -1,7 +1,21 @@
 import { WorkerHooks } from "./types.mjs";
 import { BaseEnvRunner, EnvRunnerData } from "./common-base-runner.mjs";
+import { RuntimeDep } from "./common-runtime-deps.mjs";
 import { IncomingMessage } from "node:http";
 import { Socket } from "node:net";
+/**
+ * The `wrangler` package, as imported by the consumer.
+ *
+ * `wrangler` is not a dependency of `env-runner` — pass the module namespace
+ * (`import * as wrangler from "wrangler"`) or a specifier for it, so the
+ * dependency stays owned by the application. It is only imported here as a
+ * fallback when neither is passed.
+ */
+interface WranglerModule {
+  unstable_readConfig?: (...args: any[]) => any;
+  unstable_getMiniflareWorkerOptions?: (...args: any[]) => any;
+  [key: string]: unknown;
+}
 /** Raw (snake_case) Wrangler config object, mirroring `wrangler.json` contents. */
 type WranglerInlineConfig = Record<string, unknown>;
 /** Result from a module transform (compatible with Vite's `TransformResult`). */
@@ -12,10 +26,45 @@ interface TransformResult {
 interface MiniflareExportInfo {
   type?: "DurableObject" | "WorkerEntrypoint" | "class";
 }
+/**
+ * The `miniflare` package, as imported by the consumer.
+ *
+ * `miniflare` is not a dependency of `env-runner` — pass the module namespace
+ * (`import * as miniflare from "miniflare"`) so the dependency stays owned by
+ * the application. The runner only falls back to importing it itself when this
+ * is omitted.
+ */
+interface MiniflareModule {
+  Miniflare: new (options: any) => any;
+  /**
+   * Newest compatibility date supported by the installed `workerd` binary,
+   * clamped to today. Used as the default `compatibilityDate`.
+   */
+  supportedCompatibilityDate?: string;
+  [key: string]: unknown;
+}
 interface MiniflareEnvRunnerOptions {
   name: string;
   hooks?: WorkerHooks;
   data?: EnvRunnerData;
+  /**
+   * The `miniflare` package: the imported module, or a specifier for it.
+   *
+   * ```ts
+   * import * as miniflare from "miniflare";
+   * new MiniflareEnvRunner({ name: "app", miniflare, data: { entry } });
+   *
+   * // or, equivalently
+   * new MiniflareEnvRunner({ name: "app", miniflare: "miniflare", data: { entry } });
+   * ```
+   *
+   * Passing it explicitly is preferred (`miniflare` is not a dependency of
+   * `env-runner`, so the version you install is the version that runs). Bare
+   * specifiers resolve from the current working directory. When omitted, the
+   * runner falls back to importing `miniflare` itself and only fails if that
+   * is unavailable too.
+   */
+  miniflare?: RuntimeDep<MiniflareModule>;
   /** Options passed directly to the Miniflare constructor. */
   miniflareOptions?: Record<string, unknown>;
   /**
@@ -68,12 +117,12 @@ interface MiniflareEnvRunnerOptions {
    *   merged on top of it (inline wins per key, binding records merge,
    *   `compatibilityFlags` are unioned).
    *
-   * The installed `wrangler` package is preferred (full fidelity: TOML,
+   * The `wrangler` package is used for full fidelity when available (TOML,
    * `env` inheritance, `.dev.vars`, every binding type; an inline config is
-   * normalized through a short-lived temp file). When `wrangler` is not
-   * installed, a built-in minimal reader handles plain JSON files and inline
-   * objects (common fields only) and a one-time warning is logged. JSONC and
-   * TOML files without `wrangler` are skipped with a warning. Values from
+   * normalized through a short-lived temp file) — passed explicitly as
+   * `wranglerModule`, or imported optionally. Otherwise a built-in minimal
+   * reader handles plain JSON files and inline objects (common fields only);
+   * JSONC and TOML files are skipped with a warning. Values from
    * `miniflareOptions` always win over config-derived ones; binding records
    * (e.g. `bindings`) merge per key and `compatibilityFlags` are unioned.
    */
@@ -83,6 +132,16 @@ interface MiniflareEnvRunnerOptions {
    * Defaults to the `CLOUDFLARE_ENV` environment variable.
    */
   wranglerEnv?: string;
+  /**
+   * The imported `wrangler` package (`import * as wrangler from "wrangler"`),
+   * used to parse the {@link MiniflareEnvRunnerOptions.wrangler} config with
+   * full fidelity. When omitted, `import("wrangler")` is tried, and a built-in
+   * minimal reader (plain JSON configs and inline objects) handles the rest.
+   *
+   * Pass `false` to skip the `wrangler` package entirely and always use the
+   * built-in minimal reader.
+   */
+  wranglerModule?: RuntimeDep<WranglerModule>;
 }
 declare class MiniflareEnvRunner extends BaseEnvRunner {
   #private;
@@ -124,4 +183,4 @@ declare class MiniflareEnvRunner extends BaseEnvRunner {
     };
   }): Promise<void>;
 }
-export { MiniflareEnvRunner, MiniflareEnvRunnerOptions, MiniflareExportInfo, TransformResult, WranglerInlineConfig };
+export { MiniflareEnvRunner, MiniflareEnvRunnerOptions, MiniflareExportInfo, MiniflareModule, TransformResult, WranglerInlineConfig, WranglerModule };