env-runner 0.2.3 → 0.3.1

package/dist/_chunks/common-process-data.mjs

@@ -0,0 +1,13 @@
+function receiveProcessData() {
+	return new Promise((resolve) => {
+		const onMessage = (message) => {
+			if (message?.event === "init-data") {
+				process.off("message", onMessage);
+				resolve(message.data);
+			}
+		};
+		process.on("message", onMessage);
+		process.send({ event: "request-init-data" });
+	}).then((json) => JSON.parse(json));
+}
+export { receiveProcessData };

package/dist/_chunks/common-worker-utils.mjs

@@ -1,111 +1,7 @@
-import { createVirtualHooks, expandVirtualInvalidation, stripVirtualTypeScript, virtualModuleFormat } from "./virtual-loader.mjs";
-import { pathToFileURL } from "node:url";
-import { existsSync, readFileSync } from "node:fs";
+import { PLUGINS_DATA_KEY, findVirtualPathKey, refreshVirtualModule, registerPluginHooks, registerVirtualModules, registeredVirtualModules, servedByPluginHooks } from "./plugin-hooks.mjs";
+import { createRequire } from "node:module";
 import { isAbsolute } from "node:path";
-async function registerVirtualModules(virtual) {
-	if (!virtual || Object.keys(virtual).length === 0) return _noop;
-	const { registerHooks, stripTypeScriptTypes } = await import("node:module");
-	if (typeof registerHooks === "function") {
-		const isDeno = "Deno" in globalThis;
-		let transformSource;
-		if (isDeno) {
-			transformSource = (specifier, source) => _transformSourceForDeno(specifier, source, stripTypeScriptTypes);
-			const transformed = {};
-			for (const [specifier, source] of Object.entries(virtual)) transformed[specifier] = transformSource(specifier, source);
-			virtual = transformed;
-		}
-		const registration = {
-			virtual,
-			versions: /* @__PURE__ */ new Map(),
-			transformSource
-		};
-		const hooks = registerHooks(createVirtualHooks(virtual, registration.versions, void 0, isDeno));
-		_hooksRegistrations.unshift(registration);
-		return _once(() => {
-			const index = _hooksRegistrations.indexOf(registration);
-			if (index !== -1) _hooksRegistrations.splice(index, 1);
-			hooks.deregister();
-		});
-	}
-	if (typeof globalThis.Bun?.plugin === "function") {
-		_bunVirtual = virtual;
-		_registerBunModules(Object.keys(virtual));
-		return _once(() => {
-			if (_bunVirtual === virtual) _bunVirtual = void 0;
-		});
-	}
-	console.warn("[env-runner] virtual modules require `module.registerHooks` (Node.js >= 22.15 / Deno >= 2.x) or `Bun.plugin`; skipping registration.");
-	return _noop;
-}
-function refreshVirtualModule(specifier) {
-	if (_bunVirtual?.[specifier] === void 0) return false;
-	_registerBunModules([specifier]);
-	return true;
-}
-function invalidateVirtualModule(specifier, source) {
-	for (const registration of _hooksRegistrations) {
-		if (!Object.hasOwn(registration.virtual, specifier)) continue;
-		const { virtual, versions, transformSource } = registration;
-		if (source !== void 0) virtual[specifier] = transformSource ? transformSource(specifier, source) : source;
-		for (const key of expandVirtualInvalidation(virtual, specifier)) versions.set(key, (versions.get(key) ?? 0) + 1);
-		return true;
-	}
-	if (_bunVirtual && Object.hasOwn(_bunVirtual, specifier)) {
-		if (source !== void 0) _bunVirtual[specifier] = source;
-		_registerBunModules(expandVirtualInvalidation(_bunVirtual, specifier));
-		return true;
-	}
-	return false;
-}
-function handleInvalidateModule(message, sendMessage) {
-	const ok = invalidateVirtualModule(message.specifier, message.source);
-	sendMessage({
-		event: "module-invalidated",
-		specifier: message.specifier,
-		error: ok ? void 0 : `Cannot invalidate "${message.specifier}" (not a registered virtual module)`
-	});
-}
-const _hooksRegistrations = [];
-let _bunVirtual;
-function _registerBunModules(specifiers) {
-	globalThis.Bun.plugin({
-		name: "env-runner-virtual",
-		setup(build) {
-			for (const specifier of specifiers) build.module(specifier, () => {
-				const source = _bunVirtual?.[specifier];
-				if (source === void 0) throw new Error(`Cannot find virtual module "${specifier}" (unregistered)`);
-				const format = virtualModuleFormat(specifier);
-				if (format === "json") return {
-					exports: { default: JSON.parse(source) },
-					loader: "object"
-				};
-				return {
-					contents: source,
-					loader: format === "module-typescript" ? "ts" : "js"
-				};
-			});
-		}
-	});
-}
-function _transformSourceForDeno(specifier, source, stripTypeScriptTypes) {
-	const format = virtualModuleFormat(specifier);
-	if (format === "module-typescript") return stripVirtualTypeScript(specifier, source, stripTypeScriptTypes, {
-		requirement: "(custom load hooks bypass Deno's native type stripping)",
-		remedy: "upgrade Deno"
-	});
-	if (format === "json") return `export default JSON.parse(${JSON.stringify(source)});`;
-	return source;
-}
-const _noop = () => {};
-function _once(fn) {
-	let done = false;
-	return () => {
-		if (!done) {
-			done = true;
-			fn();
-		}
-	};
-}
+import { fileURLToPath, pathToFileURL } from "node:url";
 const RESERVED_SERVER_OPTIONS = [
 	"port",
 	"hostname",
@@ -155,8 +51,22 @@ function toServerOptions(entry) {
 		gracefulShutdown: false
 	};
 }
-function isVirtualSpecifier(specifier, virtual) {
-	return Boolean(specifier && virtual && Object.hasOwn(virtual, specifier));
+function isVirtualSpecifier(specifier, virtual, matchPaths = false) {
+	if (!specifier || !virtual) return false;
+	return Object.hasOwn(virtual, specifier) || matchPaths && findVirtualPathKey(virtual, specifier) !== void 0;
+}
+function isVirtualEntry(entry, virtual = registeredVirtualModules()) {
+	const registerHooks = process.getBuiltinModule?.("node:module")?.registerHooks;
+	return isVirtualSpecifier(entry, virtual, typeof registerHooks === "function");
+}
+async function registerWorkerHooks(data) {
+	const unregisterVirtualFirst = "Bun" in globalThis ? await registerVirtualModules(data.virtual) : void 0;
+	const unregisterPlugins = await registerPluginHooks(data[PLUGINS_DATA_KEY], data.entry);
+	const unregisterVirtual = unregisterVirtualFirst ?? await registerVirtualModules(data.virtual);
+	return () => {
+		unregisterVirtual();
+		unregisterPlugins();
+	};
 }
 async function resolveEntry(entryPath, virtual) {
 	const mod = await (virtual ? import(entryPath) : import(_toImportPath(entryPath)));
@@ -164,6 +74,19 @@ async function resolveEntry(entryPath, virtual) {
 	if (typeof entry.fetch !== "function") throw new Error(`[env-runner] Entry module "${entryPath}" must export a \`fetch\` handler (export default { fetch(req) { ... } }).`);
 	return entry;
 }
+function formatInitError(error) {
+	const message = (error?.message || String(error)).replace(/^(?:Error: )+(?=\[env-runner\])/, "");
+	if (message.startsWith("[env-runner]") || /:\d+:\d+/.test(message)) return message;
+	const location = _errorLocation(error);
+	return location ? `${message} (at ${location})` : message;
+}
+function _errorLocation(error) {
+	const position = error?.position;
+	if (position?.file) return `${position.file}:${position.line}:${position.column}`;
+	const stack = typeof error?.stack === "string" ? error.stack : "";
+	const location = stack.startsWith(String(error?.name)) ? /\n\s+at (?:async )?(?:.* \()?([^\n()]+:\d+:\d+)\)?/.exec(stack)?.[1] : /^([^\n]+:\d+)\n/.exec(stack)?.[1];
+	return location && !/^(?:node|ext|native):/.test(location) ? location : void 0;
+}
 function parseServerAddress(server) {
 	const url = new URL(server.url);
 	return {
@@ -184,18 +107,28 @@ function _toImportPath(entryPath) {
 	if (isAbsolute(filePath)) return pathToFileURL(filePath).href + query;
 	return entryPath;
 }
+function _toReloadPath(entryPath) {
+	if (!("Bun" in globalThis)) return _toImportPath(entryPath);
+	if (!entryPath.startsWith("file:")) return entryPath;
+	const qIndex = entryPath.indexOf("?");
+	return qIndex === -1 ? fileURLToPath(entryPath) : fileURLToPath(entryPath.slice(0, qIndex)) + entryPath.slice(qIndex);
+}
 let _reloadCounter = 0;
 async function _importFresh(entryPath, virtual) {
 	const qIndex = entryPath.indexOf("?");
 	const filePath = qIndex === -1 ? entryPath : entryPath.slice(0, qIndex);
 	let mod;
-	if (!virtual && existsSync(filePath)) {
-		const code = readFileSync(filePath, "utf8");
-		mod = await import("data:text/javascript;base64," + Buffer.from(code).toString("base64"));
+	const bunPath = filePath.startsWith("file:") ? fileURLToPath(filePath) : filePath;
+	if (!virtual && "Bun" in globalThis && servedByPluginHooks(bunPath)) {
+		delete createRequire(import.meta.url).cache[bunPath];
+		mod = await import(bunPath);
 	} else if (virtual && refreshVirtualModule(filePath)) mod = await import(filePath);
-	else mod = await import(entryPath + (qIndex === -1 ? "?" : "&") + "__envRunnerReload=" + _reloadCounter++);
+	else {
+		const importPath = virtual ? entryPath : _toReloadPath(entryPath);
+		mod = await import(importPath + (importPath.includes("?") ? "&" : "?") + "__envRunnerReload=" + _reloadCounter++);
+	}
 	const entry = mod.default || mod;
 	if (typeof entry.fetch !== "function") throw new Error(`[env-runner] Entry module "${entryPath}" must export a \`fetch\` handler (export default { fetch(req) { ... } }).`);
 	return entry;
 }
-export { RESERVED_RUNTIME_OPTIONS, RESERVED_SERVER_OPTIONS, handleInvalidateModule, isVirtualSpecifier, parseServerAddress, registerVirtualModules, reloadEntryModule, resolveEntry, toServerOptions };
+export { RESERVED_RUNTIME_OPTIONS, RESERVED_SERVER_OPTIONS, formatInitError, isVirtualEntry, parseServerAddress, registerWorkerHooks, reloadEntryModule, resolveEntry, toServerOptions };

package/dist/_chunks/deno-process-runner.d.mts

@@ -1,5 +1,5 @@
 import { WorkerHooks } from "./types.mjs";
-import { BaseEnvRunner, EnvRunnerData } from "./common-base-runner.mjs";
+import { BaseEnvRunner, EnvRunnerData, EnvRunnerPluginOption } from "./common-base-runner.mjs";
 export declare class DenoProcessEnvRunner extends BaseEnvRunner {
   #private;
   constructor(opts: {
@@ -7,10 +7,13 @@ export declare class DenoProcessEnvRunner extends BaseEnvRunner {
     workerEntry?: string;
     hooks?: WorkerHooks;
     data?: EnvRunnerData;
+    /** Host-side transform plugins (see `EnvRunnerPluginOption`). */
+    plugins?: EnvRunnerPluginOption[];
     execArgv?: string[];
   });
   sendMessage(message: unknown): void;
   protected _hasRuntime(): boolean;
   protected _runtimeType(): string;
+  protected _resolveConditions(): string[];
   protected _closeRuntime(): Promise<void>;
 }

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

@@ -1,5 +1,4 @@
 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";
@@ -24,6 +23,13 @@ var DenoProcessEnvRunner = class extends BaseEnvRunner {
 	_runtimeType() {
 		return "process";
 	}
+	_resolveConditions() {
+		return [
+			"deno",
+			"node",
+			"import"
+		];
+	}
 	async _closeRuntime() {
 		if (!this.#process) return;
 		this.#process.removeAllListeners();
@@ -45,10 +51,7 @@ var DenoProcessEnvRunner = class extends BaseEnvRunner {
 			...execArgv || [],
 			this._workerEntry
 		], {
-			env: hostEnv({
-				ENV_RUNNER_NAME: this._name,
-				ENV_RUNNER_DATA: JSON.stringify(this._data || {})
-			}),
+			env: this._processEnv(),
 			stdio: [
 				"pipe",
 				"pipe",
@@ -68,7 +71,7 @@ var DenoProcessEnvRunner = class extends BaseEnvRunner {
 			}
 		});
 		child.on("message", (message) => {
-			this._handleMessage(message);
+			this._handleProcessMessage(message);
 		});
 		child.stdout?.pipe(process.stdout);
 		child.stderr?.pipe(process.stderr);

package/dist/_chunks/lexer.mjs

@@ -0,0 +1,2 @@
+import { init, initSync, parse } from "./libs/cjs-module-lexer.mjs";
+export { init, initSync, parse };

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

@@ -142,4 +142,9 @@ function init() {
 		A = Q;
 	})());
 }
-export { init, parse };
+function initSync() {
+	if (A) return;
+	const B = new WebAssembly.Module(w()), { exports: Q } = new WebAssembly.Instance(B);
+	A = Q;
+}
+export { init, initSync, parse };

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

@@ -1,8 +1,8 @@
-import { WorkerHooks } from "./types.mjs";
-import { BaseEnvRunner, EnvRunnerData } from "./common-base-runner.mjs";
+import { ResolvedVirtualModule, WorkerHooks } from "./types.mjs";
+import { BaseEnvRunner, EnvRunnerData, EnvRunnerPluginOption } from "./common-base-runner.mjs";
 import { RuntimeDep } from "./common-runtime-deps.mjs";
-import { IncomingMessage } from "node:http";
 import { Socket } from "node:net";
+import { IncomingMessage } from "node:http";
 /** The `wrangler` package namespace, as imported by the app. */
 export interface WranglerModule {
   unstable_readConfig?: (...args: any[]) => any;
@@ -19,17 +19,21 @@ export interface TransformResult {
 export interface MiniflareExportInfo {
   type?: "DurableObject" | "WorkerEntrypoint" | "class";
 }
-/** The `miniflare` package namespace, as imported by the app. */
+/** The `miniflare` package namespace (v4 or v5), as imported by the app. */
 export interface MiniflareModule {
   Miniflare: new (options: any) => any;
-  /** Newest date the installed `workerd` supports, clamped to today. */
+  /** Newest date the installed `workerd` supports, clamped to today (v4 only). */
   supportedCompatibilityDate?: string;
+  /** Converts v4 options, which the runner builds, to the v5 format (v5 only). */
+  convertV4MiniflareOptions?: (options: any) => any;
   [key: string]: unknown;
 }
 export interface MiniflareEnvRunnerOptions {
   name: string;
   hooks?: WorkerHooks;
   data?: EnvRunnerData;
+  /** Host-side transform plugins (see `EnvRunnerPluginOption`). */
+  plugins?: EnvRunnerPluginOption[];
   /**
    * The `miniflare` package (`import * as miniflare from "miniflare"`) or a
    * specifier resolved from cwd. Omitted: imported optionally.
@@ -51,9 +55,15 @@ export interface MiniflareEnvRunnerOptions {
   transformRequest?: (id: string) => Promise<TransformResult | null | undefined>;
   /**
    * Named exports (Durable Objects, WorkerEntrypoints) to bind and re-export.
-   * `true` detects `export class`; a record merges with detected ones.
+   * Default (or `true`): detect `export class` in the entry and auto-bind them;
+   * a record merges with detected ones; `false` disables it.
+   * A module specifier (absolute path or `data.virtual` key; relative paths
+   * resolve from the entry's directory) is re-exported with `export *` instead:
+   * nothing is detected or auto-bound (configure bindings with `wrangler` or
+   * `miniflareOptions`) and the entry's own classes are not re-exported.
+   * Exports load at startup, so changes need a new runner (not `reloadModule()`).
    */
-  exports?: Record<string, MiniflareExportInfo> | boolean;
+  exports?: Record<string, MiniflareExportInfo> | boolean | string;
   /** Reuse the Miniflare instance across runner swaps; only `dispose()` destroys it. */
   persistent?: boolean;
   /** Wrap the user's `fetch` in a try/catch that returns structured JSON error responses. Default: `true`. */
@@ -71,10 +81,11 @@ export interface MiniflareEnvRunnerOptions {
    *
    * Options a single dev worker can't run (`assets`, services, queue consumers,
    * workflows, tails, other-script Durable Objects) are dropped with a warning.
-   * `defaultPersistRoot` defaults to `.wrangler/state/v3` next to the config
-   * (else cwd), shared with `wrangler dev`. The `wrangler` package gives full
-   * fidelity (and may run its npm update check); without it only plain JSON is
-   * read. `miniflareOptions` always win.
+   * `defaultPersistRoot` (v5: `resourcePersistencePath`) defaults to
+   * `.wrangler/state/v3` next to the config (else cwd), shared with
+   * `wrangler dev`. The `wrangler` package gives full fidelity (and may run its
+   * npm update check); without it only plain JSON is read. `miniflareOptions`
+   * always win.
    */
   wrangler?: boolean | string | WranglerInlineConfig;
   /**
@@ -108,12 +119,13 @@ export declare class MiniflareEnvRunner extends BaseEnvRunner {
   /** Hot-reload the entry without recreating the Miniflare instance. */
   reloadModule(timeout?: number): Promise<void>;
   /**
-   * Host-side only: the fallback service serves a live map, so bumping versions
-   * (see {@link rewriteVirtualImports}) is enough.
+   * Host-side only: the fallback service serves a live map, so changing it and
+   * bumping versions (see {@link applyVirtualVersions}) is enough.
    */
-  invalidateModule(specifier: string, _timeout?: number): Promise<void>;
+  protected _applyVirtualUpdates(changes: Record<string, ResolvedVirtualModule | null>): Promise<void>;
   protected _hasRuntime(): boolean;
   protected _runtimeType(): string;
+  protected _resolveConditions(): string[];
   protected _closeRuntime(): Promise<void>;
   upgrade(context: {
     node: {