env-runner 0.1.16 → 0.2.0

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-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/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 };

package/dist/_chunks/miniflare-runner.mjs

@@ -1,5 +1,6 @@
 import { expandVirtualInvalidation, stripVirtualTypeScript, virtualModuleFormat } from "./virtual-loader.mjs";
 import { BaseEnvRunner } from "./common-base-runner.mjs";
+import { resolveRuntimeDep } from "./common-runtime-deps.mjs";
 import { init, parse } from "./libs/cjs-module-lexer.mjs";
 import { init as init$1, parse as parse$1 } from "./libs/es-module-lexer.mjs";
 import { isVirtualSpecifier } from "./common-worker-utils.mjs";
@@ -7,8 +8,8 @@ import { createRequire } from "node:module";
 import { proxyUpgrade } from "httpxy";
 import { fileURLToPath } from "node:url";
 import { existsSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
-import { basename, dirname, extname, isAbsolute, join, resolve } from "node:path";
 import { resolveModulePath } from "exsolve";
+import { basename, dirname, extname, isAbsolute, join, resolve } from "node:path";
 import { tmpdir } from "node:os";
 const IPC_PATH = "/__env_runner_ipc";
 const IPC_BINDING = "__ENV_RUNNER_IPC";
@@ -180,10 +181,6 @@ export default {
 };
 `;
 }
-function importWrangler() {
-	return import("wrangler");
-}
-let _warnedNoWrangler = false;
 const WRANGLER_CONFIG_FILENAMES = [
 	"wrangler.json",
 	"wrangler.jsonc",
@@ -207,7 +204,7 @@ function isPlainObject(value) {
 function isInlineWranglerConfig(opt) {
 	return isPlainObject(opt);
 }
-async function loadWranglerConfig(opt, env, entryPath) {
+async function loadWranglerConfig(opt, env, entryPath, wranglerModule) {
 	if (!opt) return;
 	const inline = isInlineWranglerConfig(opt) ? opt : void 0;
 	let configPath;
@@ -224,16 +221,12 @@ async function loadWranglerConfig(opt, env, entryPath) {
 			return;
 		}
 	} else configPath = findWranglerConfig(entryPath);
-	let wrangler;
-	try {
-		wrangler = await importWrangler();
-	} catch {
-		if (!_warnedNoWrangler) {
-			_warnedNoWrangler = true;
-			console.warn("[env-runner] 'wrangler' is not installed; using the built-in minimal config reader (plain JSON, common fields only). Install 'wrangler' for full fidelity (JSONC, TOML, env inheritance, all binding types).");
-		}
-		return mergeWranglerMiniflareOptions(configPath ? readWranglerConfigMinimal(configPath, env) : void 0, inline ? mapWranglerConfigToMiniflare(applyWranglerEnv(inline, env)) : void 0);
-	}
+	const wrangler = await resolveRuntimeDep({
+		name: "wrangler",
+		option: "wranglerModule",
+		value: wranglerModule
+	});
+	if (!wrangler?.unstable_readConfig || !wrangler.unstable_getMiniflareWorkerOptions) return mergeWranglerMiniflareOptions(configPath ? readWranglerConfigMinimal(configPath, env) : void 0, inline ? mapWranglerConfigToMiniflare(applyWranglerEnv(inline, env)) : void 0);
 	try {
 		return mergeWranglerMiniflareOptions(configPath ? pickWranglerMiniflareOptions(wrangler.unstable_getMiniflareWorkerOptions(wrangler.unstable_readConfig({
 			config: configPath,
@@ -374,11 +367,14 @@ var MiniflareEnvRunner = class extends BaseEnvRunner {
 	#exportConditions;
 	#wrangler;
 	#wranglerEnv;
+	#wranglerModule;
+	#miniflareModule;
 	constructor(opts) {
 		super({
 			...opts,
 			workerEntry: ""
 		});
+		this.#miniflareModule = opts.miniflare;
 		this.#miniflareOptions = opts.miniflareOptions || {};
 		this.#transformRequest = opts.transformRequest;
 		this.#persistent = opts.persistent ?? false;
@@ -387,6 +383,7 @@ var MiniflareEnvRunner = class extends BaseEnvRunner {
 		this.#exportConditions = opts.exportConditions ?? ["workerd", "worker"];
 		this.#wrangler = opts.wrangler ?? false;
 		this.#wranglerEnv = opts.wranglerEnv ?? process.env.CLOUDFLARE_ENV;
+		this.#wranglerModule = opts.wranglerModule;
 		this._initWithVirtualData(() => this.#init());
 	}
 	static async disposeAll() {
@@ -482,6 +479,17 @@ var MiniflareEnvRunner = class extends BaseEnvRunner {
 		} else await this.#miniflare.dispose();
 		this.#miniflare = void 0;
 	}
+	async #resolveMiniflare() {
+		this.#miniflareModule = await resolveRuntimeDep({
+			name: "miniflare",
+			option: "miniflare",
+			value: this.#miniflareModule,
+			expect: "Miniflare",
+			required: true,
+			hint: "MiniflareEnvRunner cannot run without it (`import * as miniflare from \"miniflare\"`)."
+		});
+		return this.#miniflareModule;
+	}
 	#init() {
 		this.#initAsync().catch((error) => {
 			console.error("Miniflare runner init error:", error);
@@ -517,11 +525,11 @@ var MiniflareEnvRunner = class extends BaseEnvRunner {
 		});
 	}
 	async #initAsync() {
-		const { Miniflare, supportedCompatibilityDate } = await import("miniflare");
+		const { Miniflare, supportedCompatibilityDate } = await this.#resolveMiniflare();
 		const entryPath = this._data?.entry;
 		const virtual = await this.#prepareVirtualModules();
 		this.#virtual = virtual;
-		const wranglerOptions = await loadWranglerConfig(this.#wrangler, this.#wranglerEnv, entryPath);
+		const wranglerOptions = await loadWranglerConfig(this.#wrangler, this.#wranglerEnv, entryPath, this.#wranglerModule);
 		const userFlags = this.#miniflareOptions.compatibilityFlags || [];
 		const wranglerFlags = wranglerOptions?.compatibilityFlags || [];
 		const userDirectSockets = this.#miniflareOptions.unsafeDirectSockets || [];
@@ -662,7 +670,8 @@ var MiniflareEnvRunner = class extends BaseEnvRunner {
 						}
 					} else {
 						const referrerKey = referrer.startsWith("/") ? referrer.slice(1) : referrer;
-						const referrerDir = dirname(modulePathMap.get(referrerKey) || (referrer.startsWith("/") ? referrer : "/" + referrer));
+						const referrerReal = modulePathMap.get(referrerKey) || (referrer.startsWith("/") ? referrer : "/" + referrer);
+						const referrerDir = dirname(referrerReal);
 						const raw = cleanRaw || cleanSpecifier;
 						if (raw.startsWith(".")) resolvedPath = resolve(referrerDir, raw);
 						else if (cleanSpecifier.startsWith("/")) resolvedPath = cleanSpecifier;

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

@@ -1,14 +1,39 @@
 import { WorkerHooks } from "./types.mjs";
 import { EnvRunnerData } from "./common-base-runner.mjs";
 import { NodeWorkerEnvRunner } from "./node-worker-runner.mjs";
+interface NetlifyEnvRunnerOptions {
+  name: string;
+  workerEntry?: string;
+  hooks?: WorkerHooks;
+  data?: EnvRunnerData;
+  /**
+   * Module specifier for the `@netlify/runtime` package, used inside the
+   * worker to call `startRuntime()` (full `globalThis.Netlify` + `caches`
+   * setup). `env-runner` does not depend on `@netlify/runtime`.
+   *
+   * Unlike the other runtime-dependency options, this one takes a **specifier
+   * only**: the runtime has to be instantiated inside the worker thread, and a
+   * live module instance cannot cross that boundary.
+   *
+   * ```ts
+   * new NetlifyEnvRunner({
+   *   name: "app",
+   *   netlifyRuntime: import.meta.resolve("@netlify/runtime"),
+   *   data: { entry },
+   * });
+   * ```
+   *
+   * A bare specifier (e.g. `"@netlify/runtime"`) is resolved from the current
+   * working directory. When omitted, the worker tries
+   * `import("@netlify/runtime")` and falls back to a lightweight
+   * `globalThis.Netlify` shim (env access only) if it isn't installed. Pass
+   * `false` to always use the shim.
+   */
+  netlifyRuntime?: string | URL | false;
+}
 declare class NetlifyEnvRunner extends NodeWorkerEnvRunner {
-  constructor(opts: {
-    name: string;
-    workerEntry?: string;
-    hooks?: WorkerHooks;
-    data?: EnvRunnerData;
-  });
+  constructor(opts: NetlifyEnvRunnerOptions);
   fetch(input: string | URL | Request, init?: RequestInit): Promise<Response>;
   protected _runtimeType(): string;
 }
-export { NetlifyEnvRunner };
+export { NetlifyEnvRunner, NetlifyEnvRunnerOptions };

package/dist/_chunks/netlify-runner.mjs

@@ -1,12 +1,18 @@
+import { resolveRuntimeDepSpecifier } from "./common-runtime-deps.mjs";
 import { NodeWorkerEnvRunner } from "./node-worker-runner.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"));
+		const netlifyRuntime = resolveNetlifyRuntime(opts.netlifyRuntime);
 		super({
 			...opts,
-			workerEntry: opts.workerEntry || _defaultEntry
+			workerEntry: opts.workerEntry || _defaultEntry,
+			data: netlifyRuntime === void 0 ? opts.data : {
+				...opts.data,
+				netlifyRuntime
+			}
 		});
 	}
 	async fetch(input, init) {
@@ -43,4 +49,7 @@ var NetlifyEnvRunner = class extends NodeWorkerEnvRunner {
 		return "netlify";
 	}
 };
+function resolveNetlifyRuntime(runtime) {
+	return resolveRuntimeDepSpecifier(runtime, "netlifyRuntime");
+}
 export { NetlifyEnvRunner };

package/dist/_chunks/server.mjs

@@ -300,6 +300,7 @@ var EnvServer = class extends RunnerManager {
 	}
 	async _createRunner() {
 		return loadRunner(this._opts.runner || "node-worker", {
+			...this._opts.runnerOptions,
 			name: this._opts.name || this._opts.entry,
 			hooks: this._opts.hooks,
 			data: {

package/dist/cli.d.mts

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

package/dist/index.d.mts

@@ -1,5 +1,6 @@
 import { EnvRunner, FetchHandler, NodeUpgradeContext, RPCOptions, RunnerMessageListener, RunnerRPCHooks, UpgradeContext, UpgradeHandler, WorkerAddress, WorkerHooks } from "./_chunks/types.mjs";
 import { BaseEnvRunner, EnvRunnerData, VirtualModuleSource, VirtualModules } from "./_chunks/common-base-runner.mjs";
+import { RuntimeDep, resolveRuntimeDep } from "./_chunks/common-runtime-deps.mjs";
 import { DenoProcessEnvRunner } from "./_chunks/deno-process-runner.mjs";
 import { MiniflareEnvRunner, MiniflareEnvRunnerOptions, MiniflareExportInfo, TransformResult } from "./_chunks/miniflare-runner.mjs";
 import { VercelEnvRunner } from "./_chunks/vercel-runner.mjs";
@@ -84,7 +85,11 @@ interface LoadRunnerOptions {
   hooks?: WorkerHooks;
   data?: EnvRunnerData;
   execArgv?: string[];
-  /** Additional runner-specific options (passed through to the runner constructor). */
+  /**
+   * Additional runner-specific options (passed through to the runner
+   * constructor) — e.g. `miniflare` (the imported `miniflare` package) for the
+   * `miniflare` runner, which this package never imports itself.
+   */
   [key: string]: unknown;
 }
 declare function loadRunner(runner: RunnerName, opts: LoadRunnerOptions): Promise<EnvRunner>;
@@ -105,6 +110,14 @@ interface EnvServerOptions {
   watch?: boolean;
   /** Additional paths to watch (directories or files). */
   watchPaths?: string[];
+  /**
+   * Extra runner-specific constructor options, spread into the runner.
+   *
+   * Runners that build on external packages take them as explicit options —
+   * e.g. `{ miniflare }` for the `miniflare` runner (env-runner never imports
+   * those packages itself).
+   */
+  runnerOptions?: Record<string, unknown>;
 }
 declare class EnvServer extends RunnerManager {
   private _opts;
@@ -156,4 +169,4 @@ interface AppEntry {
   plugins?: ServerOptions["plugins"];
   ipc?: AppEntryIPC;
 }
-export { type AppEntry, type AppEntryIPC, type AppEntryIPCContext, BaseEnvRunner, DenoProcessEnvRunner, type EnvRunnerData as DenoProcessEnvRunnerData, type EnvRunner, type EnvRunnerData, EnvServer, type EnvServerOptions, type FetchHandler, type LoadRunnerOptions, MiniflareEnvRunner, type MiniflareEnvRunnerOptions, type MiniflareExportInfo, NetlifyEnvRunner, type NodeUpgradeContext, type RPCOptions, RunnerManager, type RunnerMessageListener, type RunnerName, type RunnerRPCHooks, type TransformResult, type UpgradeContext, type UpgradeHandler, VercelEnvRunner, type VirtualModuleSource, type VirtualModules, type WorkerAddress, type WorkerHooks, loadRunner };
+export { type AppEntry, type AppEntryIPC, type AppEntryIPCContext, BaseEnvRunner, DenoProcessEnvRunner, type EnvRunnerData as DenoProcessEnvRunnerData, type EnvRunner, type EnvRunnerData, EnvServer, type EnvServerOptions, type FetchHandler, type LoadRunnerOptions, MiniflareEnvRunner, type MiniflareEnvRunnerOptions, type MiniflareExportInfo, NetlifyEnvRunner, type NodeUpgradeContext, type RPCOptions, RunnerManager, type RunnerMessageListener, type RunnerName, type RunnerRPCHooks, type RuntimeDep, type TransformResult, type UpgradeContext, type UpgradeHandler, VercelEnvRunner, type VirtualModuleSource, type VirtualModules, type WorkerAddress, type WorkerHooks, loadRunner, resolveRuntimeDep };

package/dist/index.mjs

@@ -1,7 +1,8 @@
 import { BaseEnvRunner } from "./_chunks/common-base-runner.mjs";
 import { EnvServer, RunnerManager, loadRunner } from "./_chunks/server.mjs";
+import { resolveRuntimeDep } from "./_chunks/common-runtime-deps.mjs";
 import { DenoProcessEnvRunner } from "./_chunks/deno-process-runner.mjs";
 import { MiniflareEnvRunner } from "./_chunks/miniflare-runner.mjs";
 import { VercelEnvRunner } from "./_chunks/vercel-runner.mjs";
 import { NetlifyEnvRunner } from "./_chunks/netlify-runner.mjs";
-export { BaseEnvRunner, DenoProcessEnvRunner, EnvServer, MiniflareEnvRunner, NetlifyEnvRunner, RunnerManager, VercelEnvRunner, loadRunner };
+export { BaseEnvRunner, DenoProcessEnvRunner, EnvServer, MiniflareEnvRunner, NetlifyEnvRunner, RunnerManager, VercelEnvRunner, loadRunner, resolveRuntimeDep };

package/dist/runners/bun-process/worker.d.mts

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

package/dist/runners/deno-process/worker.d.mts

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

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

@@ -1,3 +1,3 @@
 import { EnvRunnerData } from "../../_chunks/common-base-runner.mjs";
-import { MiniflareEnvRunner, MiniflareEnvRunnerOptions, MiniflareExportInfo, TransformResult, WranglerInlineConfig } from "../../_chunks/miniflare-runner.mjs";
-export { MiniflareEnvRunner, type EnvRunnerData as MiniflareEnvRunnerData, MiniflareEnvRunnerOptions, MiniflareExportInfo, TransformResult, type WranglerInlineConfig };
+import { MiniflareEnvRunner, MiniflareEnvRunnerOptions, MiniflareExportInfo, MiniflareModule, TransformResult, WranglerInlineConfig, WranglerModule } from "../../_chunks/miniflare-runner.mjs";
+export { MiniflareEnvRunner, type EnvRunnerData as MiniflareEnvRunnerData, MiniflareEnvRunnerOptions, MiniflareExportInfo, MiniflareModule, TransformResult, type WranglerInlineConfig, type WranglerModule };

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

@@ -1,3 +1,3 @@
 import { EnvRunnerData } from "../../_chunks/common-base-runner.mjs";
-import { NetlifyEnvRunner } from "../../_chunks/netlify-runner.mjs";
-export { type EnvRunnerData, NetlifyEnvRunner };
+import { NetlifyEnvRunner, NetlifyEnvRunnerOptions } from "../../_chunks/netlify-runner.mjs";
+export { type EnvRunnerData, NetlifyEnvRunner, NetlifyEnvRunnerOptions };

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

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

package/dist/runners/netlify/worker.mjs

@@ -1,41 +1,40 @@
-try {
-	const { startRuntime } = await import("@netlify/runtime");
+import { resolveRuntimeDep } from "../../_chunks/common-runtime-deps.mjs";
+import { workerData } from "node:worker_threads";
+const netlifyEnv = {
+	get: (key) => process.env[key],
+	has: (key) => key in process.env,
+	set: (key, value) => {
+		process.env[key] = value;
+	},
+	delete: (key) => {
+		delete process.env[key];
+	},
+	toObject: () => ({ ...process.env })
+};
+const runtimeSpecifier = (workerData || {}).netlifyRuntime;
+let started = false;
+if (runtimeSpecifier !== false) try {
+	const startRuntime = (await resolveRuntimeDep({
+		name: "@netlify/runtime",
+		option: "netlifyRuntime",
+		value: runtimeSpecifier,
+		expect: "startRuntime"
+	}))?.startRuntime;
+	if (!startRuntime) throw new Error("`@netlify/runtime` is not installed");
 	startRuntime({
 		deployID: "0",
 		siteID: "0",
-		env: {
-			get: (key) => process.env[key],
-			has: (key) => key in process.env,
-			set: (key, value) => {
-				process.env[key] = value;
-			},
-			delete: (key) => {
-				delete process.env[key];
-			},
-			toObject: () => ({ ...process.env })
-		},
+		env: netlifyEnv,
 		getRequestContext: () => null,
 		cache: { getCacheAPIContext: () => null }
 	});
-} catch {
-	if (!process.env.__ENV_RUNNER_NETLIFY_WARNED) {
-		process.env.__ENV_RUNNER_NETLIFY_WARNED = "1";
-		console.warn("@netlify/runtime is not installed. Install it for full Netlify runtime emulation: npx nypm i -D @netlify/runtime");
-	}
-	globalThis.Netlify = {
-		context: null,
-		env: {
-			get: (key) => process.env[key],
-			has: (key) => key in process.env,
-			set: (key, value) => {
-				process.env[key] = value;
-			},
-			delete: (key) => {
-				delete process.env[key];
-			},
-			toObject: () => ({ ...process.env })
-		}
-	};
+	started = true;
+} catch (error) {
+	if (runtimeSpecifier) console.warn(`[env-runner] failed to start the Netlify runtime from "${runtimeSpecifier}": ${error?.cause?.message || error?.message || error}`);
 }
+if (!started) globalThis.Netlify = {
+	context: null,
+	env: netlifyEnv
+};
 await import("../node-worker/worker.mjs");
 export {};

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

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

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

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

package/dist/runners/vercel/queue-dev.d.mts

@@ -1,9 +1,64 @@
-import { MessageHandler, RetryHandler } from "@vercel/queue";
+import { RuntimeDep } from "../../_chunks/common-runtime-deps.mjs";
+/** Metadata passed alongside each delivered message (`MessageMetadata`). */
+interface VercelQueueMessageMetadata {
+  messageId: string;
+  deliveryCount: number;
+  createdAt: Date;
+  expiresAt: Date;
+  topicName: string;
+  consumerGroup: string;
+  /** Vercel region the client is targeting. */
+  region: string;
+}
+/** Instruction returned by a retry handler when the message handler throws. */
+type VercelQueueRetryDirective = {
+  afterSeconds: number;
+} | {
+  acknowledge: true;
+};
+/** Function invoked with each delivered message (`MessageHandler`). */
+type VercelQueueMessageHandler<T = unknown> = (message: T, metadata: VercelQueueMessageMetadata) => Promise<void> | void;
+/** Called when the message handler throws (`RetryHandler`). */
+type VercelQueueRetryHandler = (error: unknown, metadata: VercelQueueMessageMetadata) => VercelQueueRetryDirective | void | undefined;
+/**
+ * The `@vercel/queue` package, as imported by the consumer
+ * (`import * as queue from "@vercel/queue"`). Structurally typed so the real
+ * module namespace is assignable without env-runner depending on the package.
+ */
+interface VercelQueueSdk {
+  QueueClient: new (options?: any) => any;
+  registerDevConsumer?: (options: {
+    topic: string;
+    client: any;
+    handler: VercelQueueMessageHandler;
+    consumerGroup?: string;
+    visibilityTimeoutSeconds?: number;
+    retry?: VercelQueueRetryHandler;
+  }) => () => void;
+  [key: string]: unknown;
+}
 interface VercelQueueDevConsumer {
+  /**
+   * The `@vercel/queue` package: the imported module, or a specifier for it.
+   *
+   * ```ts
+   * import * as sdk from "@vercel/queue";
+   * await registerVercelQueueConsumer({ sdk, topic: "orders", handler });
+   *
+   * // or, equivalently
+   * await registerVercelQueueConsumer({ sdk: "@vercel/queue", topic, handler });
+   * ```
+   *
+   * Passing it explicitly is preferred (`@vercel/queue` is not a dependency of
+   * `env-runner`). Bare specifiers resolve from the current working directory.
+   * When omitted, `@vercel/queue` is imported optionally and registration
+   * becomes a no-op if the package isn't installed.
+   */
+  sdk?: RuntimeDep<VercelQueueSdk>;
   /** Topic name. Wildcard patterns (e.g. `"user-*"`) are supported. */
   topic: string;
   /** Function invoked with each delivered message. */
-  handler: MessageHandler;
+  handler: VercelQueueMessageHandler;
   /**
    * Logical consumer identifier. Re-registering with the same group on the same
    * topic replaces the previous handler (HMR-safe). Use distinct groups to fan
@@ -27,18 +82,18 @@ interface VercelQueueDevConsumer {
    * `{ afterSeconds }` to reschedule, `{ acknowledge: true }` to drop, or
    * `undefined` to let the error propagate.
    */
-  retry?: RetryHandler;
+  retry?: VercelQueueRetryHandler;
 }
 /**
  * Bind a handler to a topic. Resolves to an unregister function.
  *
- * The first call across the worker process lazily loads `@vercel/queue` and
- * constructs a shared `QueueClient`. Re-registering with the same topic
+ * A shared `QueueClient` is constructed from `sdk` on first use and reused for
+ * later registrations with the same SDK. Re-registering with the same topic
  * replaces the handler (HMR-safe; the SDK keys consumers by `consumerGroup`,
  * so calling unregister on a replaced registration is a no-op).
  *
- * If `@vercel/queue` is not installed or does not expose `registerDevConsumer`,
+ * If no SDK is available, or it does not expose `registerDevConsumer`,
  * resolves to a no-op unregister and logs a one-time warning.
  */
 declare function registerVercelQueueConsumer(consumer: VercelQueueDevConsumer): Promise<() => void>;
-export { VercelQueueDevConsumer, registerVercelQueueConsumer };
+export { VercelQueueDevConsumer, VercelQueueMessageHandler, VercelQueueMessageMetadata, VercelQueueRetryDirective, VercelQueueRetryHandler, VercelQueueSdk, registerVercelQueueConsumer };

package/dist/runners/vercel/queue-dev.mjs

@@ -1,10 +1,31 @@
+import { resolveRuntimeDep } from "../../_chunks/common-runtime-deps.mjs";
 const DEFAULT_CONSUMER_GROUP = "env-runner-vercel-dev";
-let sdkPromise;
-let client;
+const _clients = /* @__PURE__ */ new WeakMap();
+const _warned = /* @__PURE__ */ new WeakSet();
+let _warnedMissing = false;
+let _importedSdk;
 const noop = () => {};
 async function registerVercelQueueConsumer(consumer) {
-	const sdk = await ensureSdk();
-	if (!sdk || !client) return noop;
+	const sdk = await resolveSdk(consumer.sdk);
+	if (!sdk) {
+		if (!_warnedMissing) {
+			_warnedMissing = true;
+			console.warn("[env-runner:vercel-queue] `@vercel/queue` is not installed and no `sdk` was passed. Local queue delivery is disabled.");
+		}
+		return noop;
+	}
+	if (typeof sdk.registerDevConsumer !== "function") {
+		if (!_warned.has(sdk)) {
+			_warned.add(sdk);
+			console.warn("[env-runner:vercel-queue] The `@vercel/queue` SDK in use does not export `registerDevConsumer`. Upgrade @vercel/queue@^0.2.0 to enable local queue delivery.");
+		}
+		return noop;
+	}
+	let client = _clients.get(sdk);
+	if (!client) {
+		client = new sdk.QueueClient();
+		_clients.set(sdk, client);
+	}
 	return sdk.registerDevConsumer({
 		topic: consumer.topic,
 		client,
@@ -14,23 +35,16 @@ async function registerVercelQueueConsumer(consumer) {
 		retry: consumer.retry ?? (consumer.retryAfterSeconds === void 0 ? void 0 : () => ({ afterSeconds: consumer.retryAfterSeconds }))
 	});
 }
-function ensureSdk() {
-	if (sdkPromise) return sdkPromise;
-	sdkPromise = (async () => {
-		let mod;
-		try {
-			mod = await import("@vercel/queue");
-		} catch {
-			console.warn("[env-runner:vercel-queue] `@vercel/queue` is not installed. Local queue delivery is disabled.");
-			return null;
-		}
-		if (typeof mod.registerDevConsumer !== "function") {
-			console.warn("[env-runner:vercel-queue] Installed `@vercel/queue` does not export `registerDevConsumer`. Upgrade @vercel/queue@^0.2.0 to enable local queue delivery.");
-			return null;
-		}
-		client = new mod.QueueClient();
-		return mod;
-	})();
-	return sdkPromise;
+function resolveSdk(value) {
+	if (value !== void 0) return resolveRuntimeDep({
+		name: "@vercel/queue",
+		option: "sdk",
+		value
+	});
+	_importedSdk ??= resolveRuntimeDep({
+		name: "@vercel/queue",
+		option: "sdk"
+	});
+	return _importedSdk;
 }
 export { registerVercelQueueConsumer };

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

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "env-runner",
-  "version": "0.1.16",
+  "version": "0.2.0",
   "description": "Generic environment runner for JavaScript runtimes.",
   "license": "MIT",
   "repository": "unjs/env-runner",
@@ -40,52 +40,31 @@
     "env-runner": "node ./src/cli.ts",
     "release": "pnpm test && pnpm build && changelogen --release && npm publish && git push --follow-tags",
     "test": "pnpm lint && pnpm typecheck && vitest run --coverage",
-    "typecheck": "tsgo --noEmit --skipLibCheck"
+    "typecheck": "tsc --noEmit --skipLibCheck"
   },
   "dependencies": {
-    "crossws": "^0.4.8",
-    "exsolve": "^1.1.0",
-    "httpxy": "^0.5.4",
-    "srvx": "^0.11.19"
+    "crossws": "^0.4.11",
+    "exsolve": "^1.1.1",
+    "httpxy": "^0.5.5",
+    "srvx": "^0.12.7"
   },
   "devDependencies": {
-    "@netlify/runtime": "^4.1.25",
-    "@types/node": "^26.0.1",
-    "@typescript/native-preview": "7.0.0-dev.20260629.1",
-    "@vercel/queue": "^0.3.1",
-    "@vitest/coverage-v8": "^4.1.9",
+    "@netlify/runtime": "^5",
+    "@types/node": "^26.2.0",
+    "@vercel/queue": "^0.4",
+    "@vitest/coverage-v8": "^4.1.11",
     "automd": "^0.4.3",
     "changelogen": "^0.6.2",
-    "cjs-module-lexer": "^2.2.0",
+    "cjs-module-lexer": "^2.2.1",
     "env-runner-fixture": "link:",
-    "es-module-lexer": "^2.2.0",
-    "miniflare": "^4.20260625.0",
-    "obuild": "^0.4.37",
-    "oxfmt": "^0.56.0",
-    "oxlint": "^1.71.0",
-    "typescript": "^6.0.3",
-    "vitest": "^4.1.9",
-    "wrangler": "^4.105.0"
+    "es-module-lexer": "^2.3.2",
+    "miniflare": "^4",
+    "obuild": "^0.4.38",
+    "oxfmt": ">=0.64.0",
+    "oxlint": "^1.79.0",
+    "typescript": "^7",
+    "vitest": "^4.1.11",
+    "wrangler": "^4.124.0"
   },
-  "peerDependencies": {
-    "@netlify/runtime": "^4.1.23",
-    "@vercel/queue": ">=0.2.0",
-    "miniflare": "^4.20260515.0",
-    "wrangler": "^4.0.0"
-  },
-  "peerDependenciesMeta": {
-    "miniflare": {
-      "optional": true
-    },
-    "@netlify/runtime": {
-      "optional": true
-    },
-    "@vercel/queue": {
-      "optional": true
-    },
-    "wrangler": {
-      "optional": true
-    }
-  },
-  "packageManager": "pnpm@11.9.0"
+  "packageManager": "pnpm@11.22.0"
 }