env-runner 0.2.2 → 0.3.0

package/dist/_chunks/miniflare-runner.mjs

@@ -1,22 +1,24 @@
-import { expandVirtualInvalidation, stripVirtualTypeScript, virtualModuleFormat } from "./virtual-loader.mjs";
+import { encodeVirtualModules, expandVirtualInvalidation, stripVirtualTypeScript, unsupportedVirtualJSXError, virtualModuleCode, virtualModuleCodeSource, virtualModuleFormat } from "./virtual-loader.mjs";
 import { BaseEnvRunner } from "./common-base-runner.mjs";
-import { isVirtualSpecifier } from "./common-worker-utils.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 { 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 { basename, dirname, extname, isAbsolute, join, relative, resolve, sep } from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { existsSync, mkdtempSync, readFileSync, rmSync, statSync, writeFileSync } from "node:fs";
 import { resolveModulePath } from "exsolve";
 import { tmpdir } from "node:os";
-const IPC_PATH = "/__env_runner_ipc";
+import { parseEnv } from "node:util";
+const IPC_PATH$1 = "/__env_runner_ipc";
 const IPC_BINDING = "__ENV_RUNNER_IPC";
 const UNSAFE_EVAL_BINDING = "__ENV_RUNNER_UNSAFE_EVAL__";
 function generateWrapper(entryPath, opts) {
+	const processShim = opts?.nodeCompat === false ? "" : `import __process from "node:process";
+if (!globalThis.process) { globalThis.process = __process; }`;
 	const staticReExport = opts?.dynamicOnly ? "" : `export * from ${JSON.stringify(entryPath)};`;
-	const explicitExports = opts?.dynamicOnly && opts.exports?.length ? opts.exports.map((name) => `export { ${name} } from ${JSON.stringify(entryPath)};`).join("\n") : "";
+	const explicitExports = typeof opts?.exports === "string" ? `export * from ${JSON.stringify(opts.exports)};` : opts?.dynamicOnly && opts.exports?.length ? opts.exports.map((name) => `export { ${name} } from ${JSON.stringify(entryPath)};`).join("\n") : "";
 	const fetchBody = opts?.captureErrors ?? true ? `try {
       return await __server.fetch(request, env, ctx);
     } catch (e) {
@@ -31,12 +33,11 @@ function generateWrapper(entryPath, opts) {
         headers: { "Content-Type": "application/json", "X-Env-Runner-Error": "1" },
       });
     }` : `return __server.fetch(request, env, ctx);`;
-	return `import __process from "node:process";
-if (!globalThis.process) { globalThis.process = __process; }
+	return `${processShim}
 ${staticReExport}
 ${explicitExports}
 
-const __IPC_PATH = "${IPC_PATH}";
+const __IPC_PATH = "${IPC_PATH$1}";
 const __IPC_BINDING = "${IPC_BINDING}";
 const __UNSAFE_EVAL_BINDING = "${UNSAFE_EVAL_BINDING}";
 const __entryPath = ${JSON.stringify(entryPath)};
@@ -44,7 +45,10 @@ let __userEntry;
 let __server;
 let __ipcInitialized = false;
 let __serverWs;
-let __currentEnv;
+// Raw env of the latest user request. Kept after the request ends: requests
+// overlap and streamed bodies outlive fetch(), and unlike \`__serverWs\` the
+// IPC binding works from any request context.
+let __ipcEnv;
 
 const __userEnvs = new WeakMap();
 
@@ -130,9 +134,16 @@ async function __loadEntry(env, path) {
   return mod.default || mod;
 }
 
+// Where an entry load error was thrown (first stack frame), so one thrown by a
+// virtual module names its key (\`#config:2:7\`). workerd's messages don't.
+function __errorLocation(e) {
+  const location = /\\n\\s+at (?:async )?(?:.* \\()?([^\\n()]+:\\d+:\\d+)\\)?/.exec(String(e?.stack))?.[1];
+  return location ? " (at " + location + ")" : "";
+}
+
 function __sendMessage(message) {
   const payload = JSON.stringify(message);
-  const env = __currentEnv;
+  const env = __ipcEnv;
   if (env && env[__IPC_BINDING]) {
     env[__IPC_BINDING].fetch("http://localhost/__ipc", {
       method: "POST",
@@ -204,8 +215,9 @@ export default {
   async fetch(request, env, ctx) {
     const url = new URL(request.url);
 
-    // WebSocket IPC handshake
-    if (url.pathname === __IPC_PATH && request.headers.get("upgrade") === "websocket") {
+    // IPC: a plain request loads the entry (204, or a 500 with the error), then
+    // the WebSocket upgrade opens the channel.
+    if (url.pathname === __IPC_PATH) {
       try {
         if (!__userEntry) {
           const entry = await __loadEntry(env, __entryPath);
@@ -213,7 +225,11 @@ export default {
           __userEntry = entry;
         }
       } catch (e) {
-        return new Response("Failed to load entry: " + String(e), { status: 500 });
+        const message = "Failed to load entry: " + String(e) + __errorLocation(e);
+        return new Response(message, { status: 500 });
+      }
+      if (request.headers.get("upgrade") !== "websocket") {
+        return new Response(null, { status: 204 });
       }
 
       const pair = new WebSocketPair();
@@ -241,22 +257,80 @@ export default {
       return new Response("Worker not initialized", { status: 503 });
     }
 
+    __ipcEnv = env;
+
     // Handle WebSocket upgrade via crossws cloudflare adapter
     if (__userEntry.websocket && request.headers.get("upgrade") === "websocket") {
       const adapter = await __initCrossws(env, __userEntry.websocket);
       return adapter.handleUpgrade(request, __userEnv(env), ctx);
     }
 
-    __currentEnv = env;
-    try {
-      ${fetchBody}
-    } finally {
-      __currentEnv = undefined;
-    }
+    ${fetchBody}
   }
 };
 `;
 }
+function expandDotenv(parsed, processEnv) {
+	const running = {};
+	for (const [key, raw] of Object.entries(parsed)) running[key] = processEnv[key] = (processEnv[key] && processEnv[key] !== raw ? processEnv[key] : expandDotenvValue(raw, processEnv, running)).replace(/\\\$/g, "$");
+	return processEnv;
+}
+function expandDotenvValue(value, processEnv, running) {
+	const env = {
+		...running,
+		...processEnv
+	};
+	const regex = /(?<!\\)\$\{([^{}]+)\}|(?<!\\)\$([A-Za-z_][A-Za-z0-9_]*)/g;
+	const seen = /* @__PURE__ */ new Set();
+	let result = value;
+	let match;
+	while ((match = regex.exec(result)) !== null) {
+		seen.add(result);
+		const [template, braced, unbraced] = match;
+		const expression = braced || unbraced;
+		const splitter = expression.match(/(:\+|\+|:-|-)/)?.[0];
+		const parts = splitter ? expression.split(splitter) : [expression];
+		const key = parts.shift();
+		let replacement;
+		if (splitter === ":+" || splitter === "+") replacement = env[key] ? parts.join(splitter) : "";
+		else {
+			const found = env[key];
+			replacement = found && !seen.has(found) ? found : parts.join(splitter ?? "");
+		}
+		result = result.replace(template, replacement);
+		if (result === running[key]) break;
+		regex.lastIndex = 0;
+	}
+	return result;
+}
+function readDotenvFile(path) {
+	return existsSync(path) ? parseEnv(readFileSync(path, "utf8")) : void 0;
+}
+function booleanEnv(name, defaultValue) {
+	const value = process.env[name]?.toLowerCase();
+	return value === "true" ? true : value === "false" ? false : defaultValue;
+}
+function loadDevVars(opts) {
+	const { configDir, env, envFiles } = opts;
+	if (!envFiles?.length) {
+		const devVars = resolve(configDir, ".dev.vars");
+		const loaded = env !== void 0 && readDotenvFile(`${devVars}.${env}`) || readDotenvFile(devVars);
+		if (loaded) return loaded;
+	}
+	if (!booleanEnv("CLOUDFLARE_LOAD_DEV_VARS_FROM_DOT_ENV", true)) return;
+	const files = envFiles ?? [
+		".env",
+		".env.local",
+		...env ? [`.env.${env}`, `.env.${env}.local`] : []
+	];
+	const parsed = {};
+	for (const file of files) Object.assign(parsed, readDotenvFile(resolve(configDir, file)));
+	const processEnv = {};
+	if (opts.hasSecrets || booleanEnv("CLOUDFLARE_INCLUDE_PROCESS_ENV", false)) {
+		for (const [key, value] of Object.entries(process.env)) if (typeof value === "string") processEnv[key] = value;
+	}
+	return expandDotenv(parsed, processEnv);
+}
 const WRANGLER_CONFIG_FILENAMES = [
 	"wrangler.json",
 	"wrangler.jsonc",
@@ -274,45 +348,143 @@ const WRANGLER_OPTION_DENYLIST = /* @__PURE__ */ new Set([
 	"unsafeModuleFallbackService",
 	"unsafeUseModuleFallbackService"
 ]);
+const WRANGLER_OPTION_DROPLIST = /* @__PURE__ */ new Set([
+	"assets",
+	"serviceBindings",
+	"workflows",
+	"queueConsumers",
+	"tails",
+	"streamingTails"
+]);
+const WRANGLER_DROPPED_OPTION_NAMES = {
+	assets: "assets",
+	serviceBindings: "services",
+	workflows: "workflows",
+	queueConsumers: "queues.consumers",
+	tails: "tail_consumers",
+	streamingTails: "streaming_tail_consumers",
+	durableObjects: "durable_objects"
+};
+function addDropped(dropped, name, details) {
+	let set = dropped.get(name);
+	if (!set) {
+		set = /* @__PURE__ */ new Set();
+		dropped.set(name, set);
+	}
+	for (const detail of details) set.add(detail);
+}
+function warnDroppedWranglerOptions(dropped) {
+	if (dropped.size === 0) return;
+	const list = [...dropped].map(([name, details]) => details.size > 0 ? `${name} (${[...details].join(", ")})` : name).join(", ");
+	console.warn(`[env-runner] wrangler config options not supported by the miniflare dev runner were ignored: ${list}; pass them via miniflareOptions to opt in.`);
+}
 function isPlainObject(value) {
 	return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function isInlineWranglerConfig(opt) {
 	return isPlainObject(opt);
 }
-async function loadWranglerConfig(opt, env, entryPath, wranglerModule) {
-	if (!opt) return;
+async function loadWranglerConfig(opts) {
+	const { wrangler: opt, env, entryPath, wranglerModule, envFiles } = opts;
+	if (!opt) return {};
 	const inline = isInlineWranglerConfig(opt) ? opt : void 0;
 	let configPath;
-	if (typeof opt === "string") {
-		configPath = resolve(opt);
+	const explicitPath = typeof opt === "string" ? opt : opts.configPath;
+	if (explicitPath) {
+		configPath = resolve(explicitPath);
 		if (!existsSync(configPath)) {
 			console.warn(`[env-runner] wrangler config requested but not found at "${configPath}"`);
-			return;
+			if (!inline) return {};
+			configPath = void 0;
 		}
-	} else if (opt === true) {
+	} else {
 		configPath = findWranglerConfig(entryPath);
-		if (!configPath) {
-			console.warn("[env-runner] wrangler config requested but none found near the entry or cwd");
-			return;
+		if (!configPath && !inline) {
+			console.warn("[env-runner] wrangler config requested but none found (searched the entry's directory, then from the cwd up to the filesystem root)");
+			return {};
 		}
-	} else configPath = findWranglerConfig(entryPath);
+	}
 	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({
+	const dropped = /* @__PURE__ */ new Map();
+	if (!wrangler?.unstable_readConfig || !wrangler.unstable_getMiniflareWorkerOptions) {
+		const unsupported = /* @__PURE__ */ new Map();
+		const file = configPath ? readWranglerConfigMinimal(configPath, env) : void 0;
+		const inlineConfig = inline ? applyWranglerEnv(inline, env) : void 0;
+		let options = mergeWranglerMiniflareOptions(file && (mapWranglerConfigToMiniflare(file.config, dropped, unsupported) ?? {}), inlineConfig && mapWranglerConfigToMiniflare(inlineConfig, dropped, unsupported));
+		if (file || inlineConfig) options = applyMinimalDevVars(options, [file?.config, inlineConfig], {
+			configDir: configPath ? dirname(configPath) : process.cwd(),
+			env,
+			envFiles
+		});
+		filterLocalDurableObjects(options, dropped, (inline && wranglerWorkerName(inline, env)) ?? file?.workerName);
+		warnDroppedWranglerOptions(dropped);
+		warnUnsupportedMinimalBindings(unsupported);
+		return {
+			options,
+			configFile: file ? configPath : void 0
+		};
+	}
+	let fileLoaded = false;
+	let fileOptions;
+	let fileSecrets;
+	let fileWorkerName;
+	if (configPath) try {
+		const config = wrangler.unstable_readConfig({
 			config: configPath,
 			env
-		}, { hideWarnings: true }), env).workerOptions) : void 0, inline ? pickWranglerMiniflareOptions(wrangler.unstable_getMiniflareWorkerOptions(readInlineWranglerConfig(wrangler, inline, env), env).workerOptions) : void 0);
+		}, { hideWarnings: !claimWranglerWarnings(configPath, env) });
+		fileOptions = pickWranglerMiniflareOptions(wrangler.unstable_getMiniflareWorkerOptions(config, env, { envFiles }).workerOptions, dropped);
+		fileWorkerName = config?.name;
+		fileSecrets = config?.secrets;
+		fileLoaded = true;
 	} catch (error) {
-		const desc = [configPath && `"${configPath}"`, inline && "(inline)"].filter(Boolean).join(" + ");
-		console.warn(`[env-runner] failed to load wrangler config ${desc}: ${error.message}`);
-		return;
+		warnWranglerLoadError(`"${configPath}"`, error);
+	}
+	let inlineOptions;
+	if (inline) try {
+		const inlineEnv = env && isPlainObject(inline.env) && inline.env[env] ? env : void 0;
+		const { env: _env, ...inlineTopLevel } = inline;
+		const inlineConfig = readInlineWranglerConfig(wrangler, inlineEnv ? inline : inlineTopLevel, inlineEnv);
+		inlineConfig.userConfigPath = configPath;
+		if (fileLoaded && inlineConfig.secrets === void 0) inlineConfig.secrets = fileSecrets;
+		inlineOptions = pickWranglerMiniflareOptions(wrangler.unstable_getMiniflareWorkerOptions(inlineConfig, env, { envFiles }).workerOptions, dropped);
+		if (inlineOptions) {
+			delete inlineOptions.rootPath;
+			if (fileLoaded) filterInlineDevVarBindings(inlineOptions, fileOptions, inlineConfig);
+		}
+	} catch (error) {
+		warnWranglerLoadError("(inline)", error);
 	}
+	const options = mergeWranglerMiniflareOptions(fileOptions, inlineOptions);
+	filterLocalDurableObjects(options, dropped, (inline && wranglerWorkerName(inline, env)) ?? fileWorkerName);
+	warnDroppedWranglerOptions(dropped);
+	return {
+		options,
+		configFile: fileLoaded ? configPath : void 0
+	};
+}
+const _shownWranglerWarnings = /* @__PURE__ */ new Set();
+function claimWranglerWarnings(configPath, env) {
+	let version = "";
+	try {
+		const stat = statSync(configPath);
+		version = `${stat.mtimeMs}:${stat.size}`;
+	} catch {}
+	const key = JSON.stringify([
+		resolve(configPath),
+		env ?? null,
+		version
+	]);
+	if (_shownWranglerWarnings.has(key)) return false;
+	_shownWranglerWarnings.add(key);
+	return true;
+}
+function warnWranglerLoadError(desc, error) {
+	console.warn(`[env-runner] failed to load wrangler config ${desc}: ${error.message}`);
 }
 function mergeWranglerMiniflareOptions(base, override) {
 	if (!base) return override;
@@ -329,6 +501,12 @@ function mergeWranglerMiniflareOptions(base, override) {
 	}
 	return out;
 }
+function filterInlineDevVarBindings(inlineOptions, fileOptions, inlineConfig) {
+	if (!isPlainObject(inlineOptions.bindings)) return;
+	const fileBindings = isPlainObject(fileOptions?.bindings) ? fileOptions.bindings : {};
+	const declared = /* @__PURE__ */ new Set([...Object.keys(inlineConfig.vars ?? {}), ...inlineConfig.secrets?.required ?? []]);
+	inlineOptions.bindings = Object.fromEntries(Object.entries(inlineOptions.bindings).filter(([key]) => declared.has(key) || Object.hasOwn(fileBindings, key)));
+}
 function readInlineWranglerConfig(wrangler, inline, env) {
 	const dir = mkdtempSync(join(tmpdir(), "env-runner-wrangler-"));
 	const file = join(dir, "wrangler.json");
@@ -345,29 +523,173 @@ function readInlineWranglerConfig(wrangler, inline, env) {
 		});
 	}
 }
+const _announcedWranglerConfigs = /* @__PURE__ */ new Set();
 function findWranglerConfig(entryPath) {
-	const dirs = [];
+	const cwd = process.cwd();
+	let start = cwd;
 	if (entryPath) {
-		const resolved = isAbsolute(entryPath) ? entryPath : resolve(entryPath);
-		dirs.push(dirname(resolved));
+		const entryDir = dirname(resolve(entryPath));
+		const rel = relative(cwd, entryDir);
+		if (rel === "" || rel !== ".." && !rel.startsWith(`..${sep}`) && !isAbsolute(rel)) start = entryDir;
+		else {
+			const local = findWranglerConfigInDir(entryDir);
+			if (local) return local;
+		}
+	}
+	for (let dir = start;; dir = dirname(dir)) {
+		const found = findWranglerConfigInDir(dir);
+		if (found) {
+			if (dir !== cwd && dir !== start && !_announcedWranglerConfigs.has(found)) {
+				_announcedWranglerConfigs.add(found);
+				console.info(`[env-runner] using wrangler config from a parent directory: ${found}`);
+			}
+			return found;
+		}
+		if (dirname(dir) === dir) return;
 	}
-	dirs.push(process.cwd());
-	for (const dir of dirs) for (const name of WRANGLER_CONFIG_FILENAMES) {
+}
+function findWranglerConfigInDir(dir) {
+	for (const name of WRANGLER_CONFIG_FILENAMES) {
 		const candidate = join(dir, name);
 		if (existsSync(candidate)) return candidate;
 	}
 }
-function pickWranglerMiniflareOptions(workerOptions) {
+function pickWranglerMiniflareOptions(workerOptions, dropped) {
 	const out = {};
 	for (const [key, value] of Object.entries(workerOptions)) {
 		if (value === void 0 || WRANGLER_OPTION_DENYLIST.has(key)) continue;
+		if (WRANGLER_OPTION_DROPLIST.has(key)) {
+			if (!isEmptyOption(value)) addDropped(dropped, WRANGLER_DROPPED_OPTION_NAMES[key], describeDroppedOption(value));
+			continue;
+		}
+		if (isEmptyPickedOption(key, value)) continue;
 		out[key] = value;
 	}
 	return Object.keys(out).length > 0 ? out : void 0;
 }
+function isEmptyPickedOption(key, value) {
+	const isEmptyArray = (v) => Array.isArray(v) && v.length === 0;
+	if (isEmptyArray(value) || isPlainObject(value) && Object.keys(value).length === 0) return true;
+	return key !== "bindings" && isPlainObject(value) && Object.values(value).every(isEmptyArray);
+}
+function isEmptyOption(value) {
+	return !value || Array.isArray(value) && value.length === 0 || isPlainObject(value) && Object.keys(value).length === 0;
+}
+function describeDroppedOption(value) {
+	if (Array.isArray(value)) return value.map((entry) => entry?.name).filter((name) => typeof name === "string");
+	if (isPlainObject(value)) {
+		if ("directory" in value) return typeof value.binding === "string" ? [value.binding] : [];
+		return Object.keys(value);
+	}
+	return [];
+}
+function filterLocalDurableObjects(options, dropped, workerName) {
+	const value = options?.durableObjects;
+	if (!options || !isPlainObject(value)) return;
+	const out = {};
+	for (const [name, binding] of Object.entries(value)) if (typeof binding === "string" || isPlainObject(binding) && !binding.scriptName) out[name] = binding;
+	else if (isPlainObject(binding) && workerName && binding.scriptName === workerName) {
+		const { scriptName: _scriptName, ...local } = binding;
+		out[name] = local;
+	} else {
+		const scriptName = isPlainObject(binding) ? binding.scriptName : void 0;
+		addDropped(dropped, "durable_objects", [`${name} → script "${String(scriptName)}"`]);
+	}
+	if (Object.keys(out).length > 0) options.durableObjects = out;
+	else delete options.durableObjects;
+}
+const WRANGLER_NON_INHERITABLE_KEYS = /* @__PURE__ */ new Set([
+	"vars",
+	"secrets",
+	"define",
+	"durable_objects",
+	"workflows",
+	"kv_namespaces",
+	"cloudchamber",
+	"containers",
+	"send_email",
+	"queues",
+	"connect",
+	"r2_buckets",
+	"d1_databases",
+	"vectorize",
+	"ai_search_namespaces",
+	"ai_search",
+	"websearch",
+	"agent_memory",
+	"hyperdrive",
+	"services",
+	"analytics_engine_datasets",
+	"dispatch_namespaces",
+	"mtls_certificates",
+	"tail_consumers",
+	"streaming_tail_consumers",
+	"unsafe",
+	"browser",
+	"ai",
+	"images",
+	"stream",
+	"media",
+	"pipelines",
+	"secrets_store_secrets",
+	"artifacts",
+	"unsafe_hello_world",
+	"flagship",
+	"worker_loaders",
+	"ratelimits",
+	"vpc_services",
+	"vpc_networks",
+	"version_metadata"
+]);
+const MINIMAL_UNSUPPORTED_BINDING_KEYS = [
+	"hyperdrive",
+	"analytics_engine_datasets",
+	"ai",
+	"ai_search_namespaces",
+	"ai_search",
+	"websearch",
+	"agent_memory",
+	"version_metadata",
+	"ratelimits",
+	"send_email",
+	"secrets_store_secrets",
+	"vectorize",
+	"browser",
+	"images",
+	"stream",
+	"media",
+	"pipelines",
+	"dispatch_namespaces",
+	"mtls_certificates",
+	"worker_loaders",
+	"vpc_services",
+	"vpc_networks",
+	"artifacts",
+	"flagship",
+	"containers",
+	"unsafe",
+	"unsafe_hello_world",
+	"logfwdr",
+	"wasm_modules",
+	"text_blobs",
+	"data_blobs"
+];
+const MINIMAL_BINDING_OPTIONS = [
+	"kvNamespaces",
+	"r2Buckets",
+	"d1Databases",
+	"queueProducers",
+	"durableObjects"
+];
+function warnUnsupportedMinimalBindings(unsupported) {
+	if (unsupported.size === 0) return;
+	const list = [...unsupported].map(([name, details]) => details.size > 0 ? `${name} (${[...details].join(", ")})` : name).join(", ");
+	console.warn(`[env-runner] wrangler config bindings not supported by the built-in minimal wrangler config reader were ignored: ${list}; install 'wrangler' (or pass it as \`wranglerModule\`) to use them.`);
+}
 function readWranglerConfigMinimal(configPath, env) {
-	if (extname(configPath).toLowerCase() !== ".json") {
-		console.warn(`[env-runner] reading "${basename(configPath)}" requires the 'wrangler' package; the built-in reader supports plain JSON only (install 'wrangler' for JSONC/TOML).`);
+	const ext = extname(configPath).toLowerCase();
+	if (ext !== ".json" && ext !== ".jsonc") {
+		console.warn(`[env-runner] reading "${basename(configPath)}" requires the 'wrangler' package; the built-in reader supports JSON/JSONC only (install 'wrangler' for TOML).`);
 		return;
 	}
 	let raw;
@@ -378,45 +700,203 @@ function readWranglerConfigMinimal(configPath, env) {
 	}
 	let config;
 	try {
-		config = JSON.parse(raw);
+		config = parseJSONC(raw);
 	} catch (error) {
 		console.warn(`[env-runner] failed to parse wrangler config "${configPath}": ${error.message}`);
 		return;
 	}
-	return mapWranglerConfigToMiniflare(applyWranglerEnv(config, env));
+	if (!isPlainObject(config)) {
+		warnWranglerLoadError(`"${configPath}"`, /* @__PURE__ */ new Error("config must be an object"));
+		return;
+	}
+	let envConfig;
+	try {
+		envConfig = applyWranglerEnv(config, env, configPath);
+	} catch (error) {
+		warnWranglerLoadError(`"${configPath}"`, error);
+		return;
+	}
+	return {
+		config: envConfig,
+		workerName: wranglerWorkerName(config, env)
+	};
+}
+function applyWranglerEnv(config, env, configPath) {
+	const { env: envs, ...topLevel } = config;
+	if (!env) return topLevel;
+	const rawEnv = isPlainObject(envs) ? envs[env] : void 0;
+	const warnings = [];
+	let out;
+	if (isPlainObject(rawEnv)) {
+		out = {};
+		for (const [key, value] of Object.entries(topLevel)) if (!WRANGLER_NON_INHERITABLE_KEYS.has(key)) out[key] = value;
+		else if (rawEnv[key] === void 0) warnings.push(`"${key}" exists at the top level, but is not inherited by "env.${env}"`);
+		Object.assign(out, rawEnv);
+	} else {
+		if (configPath && isPlainObject(envs)) throw new Error(`No environment found in configuration with name "${env}". The available configured environment names are: ${JSON.stringify(Object.keys(envs))}`);
+		warnings.push(`No environment found in configuration with name "${env}"`);
+		out = topLevel;
+	}
+	if (configPath && warnings.length > 0 && claimWranglerWarnings(configPath, env)) console.warn(`[env-runner] wrangler config "${configPath}": ${warnings.join("; ")}.`);
+	return out;
 }
-function applyWranglerEnv(config, env) {
-	return env && config.env?.[env] ? {
-		...config,
-		...config.env[env]
-	} : config;
+function wranglerWorkerName(config, env) {
+	const envName = env ? config.env?.[env]?.name : void 0;
+	if (typeof envName === "string") return envName;
+	if (typeof config.name !== "string" || !config.name) return void 0;
+	return env ? `${config.name}-${env}` : config.name;
 }
-function mapWranglerConfigToMiniflare(config) {
+function mapWranglerConfigToMiniflare(config, dropped, unsupported) {
 	const out = {};
+	for (const [name, value, field] of [
+		[
+			"services",
+			config.services,
+			"binding"
+		],
+		[
+			"assets",
+			config.assets,
+			"binding"
+		],
+		[
+			"queues.consumers",
+			config.queues?.consumers,
+			"queue"
+		],
+		[
+			"workflows",
+			config.workflows,
+			"binding"
+		],
+		[
+			"tail_consumers",
+			config.tail_consumers,
+			"service"
+		],
+		[
+			"streaming_tail_consumers",
+			config.streaming_tail_consumers,
+			"service"
+		]
+	]) if (!isEmptyOption(value)) addDropped(dropped, name, (Array.isArray(value) ? value : [value]).map((e) => e?.[field]).filter((d) => typeof d === "string"));
+	for (const key of MINIMAL_UNSUPPORTED_BINDING_KEYS) {
+		const value = config[key];
+		const bindings = isPlainObject(value) && Array.isArray(value.bindings) ? value.bindings : value;
+		if (!isEmptyOption(bindings)) addDropped(unsupported, key, describeBindingNames(bindings));
+	}
 	if (typeof config.compatibility_date === "string") out.compatibilityDate = config.compatibility_date;
 	if (Array.isArray(config.compatibility_flags)) out.compatibilityFlags = config.compatibility_flags;
 	if (config.vars && typeof config.vars === "object") out.bindings = { ...config.vars };
-	const kv = mapBindingArray(config.kv_namespaces, "binding", (n) => n.id ?? n.binding);
+	const kv = mapBindingArray(config.kv_namespaces, "binding", (n) => firstString(n.preview_id, n.id, n.binding));
 	if (kv) out.kvNamespaces = kv;
-	const r2 = mapBindingArray(config.r2_buckets, "binding", (n) => n.bucket_name ?? n.binding);
+	const r2 = mapBindingArray(config.r2_buckets, "binding", (n) => firstString(n.preview_bucket_name, n.bucket_name, n.binding));
 	if (r2) out.r2Buckets = r2;
-	const d1 = mapBindingArray(config.d1_databases, "binding", (n) => n.database_id ?? n.preview_database_id ?? n.binding);
+	const d1 = mapBindingArray(config.d1_databases, "binding", (n) => firstString(n.preview_database_id, n.database_id, n.binding));
 	if (d1) out.d1Databases = d1;
 	const queues = mapBindingArray(config.queues?.producers, "binding", (n) => n.queue);
 	if (queues) out.queueProducers = queues;
-	if (Array.isArray(config.durable_objects?.bindings)) {
-		const dos = {};
-		for (const b of config.durable_objects.bindings) {
-			if (!b?.name || !b?.class_name) continue;
-			dos[b.name] = b.script_name ? {
-				className: b.class_name,
-				scriptName: b.script_name
-			} : b.class_name;
-		}
-		if (Object.keys(dos).length > 0) out.durableObjects = dos;
+	const useSQLite = durableObjectClassStorage(config);
+	const doBindings = Array.isArray(config.durable_objects?.bindings) ? config.durable_objects.bindings : [];
+	const dos = {};
+	for (const b of doBindings) {
+		if (!b?.name || !b?.class_name) continue;
+		dos[b.name] = {
+			className: b.class_name,
+			...b.script_name ? { scriptName: b.script_name } : {},
+			...useSQLite.has(b.class_name) ? { useSQLite: useSQLite.get(b.class_name) } : {}
+		};
 	}
+	if (Object.keys(dos).length > 0) out.durableObjects = dos;
+	const unbound = [...useSQLite].filter(([className]) => !doBindings.some((b) => b?.class_name === className)).map(([className, sqlite]) => ({
+		className,
+		useSQLite: sqlite
+	}));
+	if (unbound.length > 0) out.additionalUnboundDurableObjects = unbound;
 	return Object.keys(out).length > 0 ? out : void 0;
 }
+function durableObjectClassStorage(config) {
+	const classes = /* @__PURE__ */ new Map();
+	for (const migration of Array.isArray(config.migrations) ? config.migrations : []) {
+		for (const name of migration?.deleted_classes ?? []) classes.delete(name);
+		for (const { from, to } of migration?.renamed_classes ?? []) {
+			const sqlite = classes.get(from);
+			if (sqlite !== void 0) {
+				classes.delete(from);
+				classes.set(to, sqlite);
+			}
+		}
+		for (const name of migration?.new_classes ?? []) classes.set(name, false);
+		for (const name of migration?.new_sqlite_classes ?? []) classes.set(name, true);
+	}
+	if (isPlainObject(config.exports)) for (const [name, entry] of Object.entries(config.exports)) {
+		const state = entry?.state;
+		if (entry?.type === "durable-object" && (state === void 0 || state === "created" || state === "expecting-transfer")) classes.set(name, entry.storage === "sqlite");
+	}
+	return classes;
+}
+function describeBindingNames(value) {
+	if (isPlainObject(value) && typeof value.binding !== "string") return Object.keys(value);
+	return (Array.isArray(value) ? value : [value]).map((e) => e?.binding ?? e?.name ?? e?.class_name).filter((name) => typeof name === "string");
+}
+function applyMinimalDevVars(options, configs, opts) {
+	const secrets = configs.map((c) => c?.secrets).filter(isPlainObject);
+	const loaded = loadDevVars({
+		...opts,
+		hasSecrets: secrets.length > 0
+	});
+	if (!loaded) return options;
+	const out = { ...options };
+	const bindings = isPlainObject(out.bindings) ? { ...out.bindings } : {};
+	const taken = new Set(MINIMAL_BINDING_OPTIONS.flatMap((key) => isPlainObject(out[key]) ? Object.keys(out[key]) : []));
+	const required = new Set(secrets.flatMap((s) => Array.isArray(s.required) ? s.required : []));
+	let changed = false;
+	for (const [key, value] of Object.entries(loaded)) {
+		if (taken.has(key) || secrets.length > 0 && !Object.hasOwn(bindings, key) && !required.has(key)) continue;
+		bindings[key] = value;
+		changed = true;
+	}
+	const missing = [...required].filter((key) => !Object.hasOwn(loaded, key));
+	if (missing.length > 0) console.warn(`[env-runner] missing required wrangler secrets: ${missing.join(", ")}. Add them to .dev.vars, .env, or set as environment variables.`);
+	if (!changed) return options;
+	out.bindings = bindings;
+	return out;
+}
+function firstString(...values) {
+	return values.find((value) => typeof value === "string");
+}
+function parseJSONC(text) {
+	let out = "";
+	let comma = -1;
+	const src = text.charCodeAt(0) === 65279 ? text.slice(1) : text;
+	for (let i = 0; i < src.length; i++) {
+		const ch = src[i];
+		if (ch === "/" && (src[i + 1] === "/" || src[i + 1] === "*")) {
+			const line = src[i + 1] === "/";
+			let end = line ? src.indexOf("\n", i) : src.indexOf("*/", i + 2);
+			end = end === -1 ? src.length : line ? end : end + 2;
+			out += src.slice(i, end).replace(/[^\n]/g, " ");
+			i = end - 1;
+			continue;
+		}
+		if (/\s/.test(ch)) {
+			out += ch;
+			continue;
+		}
+		if ((ch === "}" || ch === "]") && comma !== -1) out = `${out.slice(0, comma)} ${out.slice(comma + 1)}`;
+		comma = -1;
+		if (ch === "\"") {
+			let end = i + 1;
+			while (end < src.length && src[end] !== "\"") end += src[end] === "\\" ? 2 : 1;
+			out += src.slice(i, end + 1);
+			i = end;
+			continue;
+		}
+		if (ch === ",") comma = out.length;
+		out += ch;
+	}
+	return JSON.parse(out);
+}
 function mapBindingArray(arr, keyField, value) {
 	if (!Array.isArray(arr)) return;
 	const out = {};
@@ -426,6 +906,7 @@ function mapBindingArray(arr, keyField, value) {
 	}
 	return Object.keys(out).length > 0 ? out : void 0;
 }
+const IPC_PATH = "/__env_runner_ipc";
 const _miniflareCache = /* @__PURE__ */ new Map();
 var MiniflareEnvRunner = class extends BaseEnvRunner {
 	#miniflare;
@@ -433,7 +914,6 @@ var MiniflareEnvRunner = class extends BaseEnvRunner {
 	#transformRequest;
 	#reloadCounter = 0;
 	#virtual;
-	#virtualVersions = /* @__PURE__ */ new Map();
 	#cacheEntry;
 	#ws;
 	#persistent;
@@ -443,6 +923,9 @@ var MiniflareEnvRunner = class extends BaseEnvRunner {
 	#exportConditions;
 	#wrangler;
 	#wranglerEnv;
+	#wranglerConfigPath;
+	#wranglerEnvFiles;
+	#compatibilityDate;
 	#wranglerModule;
 	#miniflareModule;
 	constructor(opts) {
@@ -460,6 +943,9 @@ var MiniflareEnvRunner = class extends BaseEnvRunner {
 		this.#wrangler = opts.wrangler ?? false;
 		this.#wranglerEnv = opts.wranglerEnv ?? process.env.CLOUDFLARE_ENV;
 		this.#wranglerModule = opts.wranglerModule;
+		this.#wranglerConfigPath = opts.wranglerConfigPath;
+		this.#wranglerEnvFiles = opts.wranglerEnvFiles;
+		this.#compatibilityDate = opts.compatibilityDate;
 		this._initWithVirtualData(() => this.#init());
 	}
 	static async disposeAll() {
@@ -484,8 +970,12 @@ var MiniflareEnvRunner = class extends BaseEnvRunner {
 		for (let i = 0; i < 5 && !this._address && !this.closed; i++) await new Promise((r) => setTimeout(r, 100 * Math.pow(2, i)));
 		if (!this.#miniflare || this.closed) return new Response("miniflare env runner is unavailable", { status: 503 });
 		const resolved = this._resolveFetchInput(input);
-		const request = typeof resolved === "string" || resolved instanceof URL ? new Request(resolved, init) : new Request(new Request(resolved.url, resolved), {
+		const request = typeof resolved === "string" || resolved instanceof URL ? new Request(resolved, {
 			...init,
+			redirect: "manual"
+		}) : new Request(new Request(resolved.url, resolved), {
+			...init,
+			redirect: "manual",
 			referrer: init?.referrer ?? resolved.referrer,
 			referrerPolicy: init?.referrerPolicy ?? resolved.referrerPolicy
 		});
@@ -512,6 +1002,7 @@ var MiniflareEnvRunner = class extends BaseEnvRunner {
 		}));
 	}
 	async reloadModule(timeout = 5e3) {
+		await this._virtualUpdates;
 		if (!this.#ws) throw new Error("Miniflare env runner should be initialized before reloading.");
 		if (!this._data?.entry) return;
 		this.#reloadCounter++;
@@ -525,15 +1016,27 @@ var MiniflareEnvRunner = class extends BaseEnvRunner {
 			send: (message) => this.#ws.send(JSON.stringify(message))
 		});
 	}
-	async invalidateModule(specifier, _timeout) {
+	async _applyVirtualUpdates(changes) {
 		const virtual = this.#virtual;
-		if (!virtual || !Object.hasOwn(virtual, specifier)) {
-			const hasVirtual = Object.keys(this._data?.virtual ?? {}).length > 0;
-			throw !virtual && hasVirtual && !this.closed ? /* @__PURE__ */ new Error("Miniflare env runner should be initialized before invalidating modules.") : /* @__PURE__ */ new Error(`Cannot invalidate "${specifier}" (not a registered virtual module)`);
+		if (!virtual) throw new Error("Miniflare env runner should be initialized before updating modules.");
+		const prepared = {};
+		for (const [key, module] of Object.entries(changes)) if (module !== null) prepared[key] = await this.#prepareVirtualModule(key, module);
+		await init$1;
+		const merged = {
+			...virtual.sources,
+			...prepared
+		};
+		const importers = virtualImporters(merged, createVirtualKeyResolver(Object.keys(merged)));
+		const invalidated = expandVirtualInvalidation(merged, Object.keys(changes), importers);
+		for (const key of Object.keys(changes)) if (Object.hasOwn(prepared, key)) {
+			virtual.sources[key] = prepared[key];
+			virtual.removed.delete(key);
+		} else if (Object.hasOwn(virtual.sources, key)) {
+			delete virtual.sources[key];
+			virtual.removed.add(key);
 		}
-		const source = await this._refreshVirtualSource(specifier);
-		if (source !== void 0) virtual[specifier] = await this.#prepareVirtualSource(specifier, source);
-		for (const key of expandVirtualInvalidation(virtual, specifier)) this.#virtualVersions.set(key, (this.#virtualVersions.get(key) ?? 0) + 1);
+		for (const key of invalidated) virtual.versions.set(key, ++virtual.version);
+		refreshVirtualKeyResolvers(virtual);
 		if (this.#cacheKey && _miniflareCache.get(this.#cacheKey) === this.#cacheEntry) _miniflareCache.delete(this.#cacheKey);
 	}
 	_hasRuntime() {
@@ -591,38 +1094,60 @@ var MiniflareEnvRunner = class extends BaseEnvRunner {
 		} catch {}
 	}
 	async #prepareVirtualModules() {
-		const virtual = this._data?.virtual;
-		if (!virtual || Object.keys(virtual).length === 0) return;
+		const virtual = this._data?.virtual ?? {};
 		const out = {};
-		for (const [specifier, source] of Object.entries(virtual)) out[specifier] = await this.#prepareVirtualSource(specifier, source);
+		for (const [key, module] of Object.entries(virtual)) out[key] = await this.#prepareVirtualModule(key, module);
 		return out;
 	}
-	async #prepareVirtualSource(specifier, source) {
-		if (virtualModuleFormat(specifier) !== "module-typescript") return source;
-		return stripVirtualTypeScript(specifier, source, await _getStripTypeScriptTypes(), {
-			requirement: "on the host (workerd does not parse TypeScript)",
-			remedy: "upgrade Node.js"
-		});
+	async #prepareVirtualModule(key, module) {
+		const format = virtualModuleFormat(key, module);
+		const source = typeof module === "string" ? module : module.source;
+		switch (format) {
+			case "module-typescript":
+			case "commonjs-typescript": return {
+				source: stripVirtualTypeScript(key, source, await _getStripTypeScriptTypes(), {
+					requirement: "on the host (workerd does not parse TypeScript)",
+					remedy: "upgrade Node.js"
+				}),
+				format: format === "module-typescript" ? "module" : "commonjs"
+			};
+			case "jsx":
+			case "tsx": throw unsupportedVirtualJSXError(key, format, "workerd");
+		}
+		return {
+			source,
+			format
+		};
 	}
 	async #initAsync() {
-		const { Miniflare, supportedCompatibilityDate } = await this.#resolveMiniflare();
+		const miniflare = await this.#resolveMiniflare();
+		const supportedCompatibilityDate = await resolveSupportedCompatibilityDate(miniflare);
 		const entryPath = this._data?.entry;
-		const virtual = await this.#prepareVirtualModules();
+		const initialVirtual = await this.#prepareVirtualModules();
+		const virtual = createMiniflareVirtualModules({ ...initialVirtual });
 		this.#virtual = virtual;
-		const wranglerOptions = await loadWranglerConfig(this.#wrangler, this.#wranglerEnv, entryPath, this.#wranglerModule);
+		const { options: wranglerOptions, configFile: wranglerConfigFile } = await loadWranglerConfig({
+			wrangler: this.#wrangler,
+			env: this.#wranglerEnv,
+			entryPath,
+			configPath: this.#wranglerConfigPath,
+			wranglerModule: this.#wranglerModule,
+			envFiles: this.#wranglerEnvFiles
+		});
 		const userFlags = this.#miniflareOptions.compatibilityFlags || [];
 		const wranglerFlags = wranglerOptions?.compatibilityFlags || [];
 		const userDirectSockets = this.#miniflareOptions.unsafeDirectSockets || [];
 		const options = {
-			compatibilityDate: supportedCompatibilityDate,
 			modules: true,
+			...this.#wrangler && !hasUserPersistOptions(this.#miniflareOptions) ? { defaultPersistRoot: wranglerPersistRoot(wranglerConfigFile, typeof this.#wrangler === "string" ? this.#wrangler : this.#wranglerConfigPath) } : void 0,
 			...wranglerOptions,
 			...this.#miniflareOptions,
-			compatibilityFlags: [.../* @__PURE__ */ new Set([
-				"nodejs_compat",
-				...wranglerFlags,
-				...userFlags
-			])],
+			compatibilityDate: resolveCompatibilityDate([
+				this.#miniflareOptions.compatibilityDate,
+				this.#compatibilityDate === "latest" ? supportedCompatibilityDate : this.#compatibilityDate,
+				wranglerOptions?.compatibilityDate
+			], supportedCompatibilityDate),
+			compatibilityFlags: resolveCompatibilityFlags(wranglerFlags, userFlags),
 			unsafeDirectSockets: [{
 				host: "127.0.0.1",
 				port: 0
@@ -635,28 +1160,42 @@ var MiniflareEnvRunner = class extends BaseEnvRunner {
 				...uValue
 			};
 		}
+		const ipc = { runner: this };
 		if (entryPath && !options.script && !options.scriptPath) {
-			const entryIsVirtual = isVirtualSpecifier(entryPath, virtual);
-			const resolvedEntry = entryIsVirtual ? entryPath : resolve(entryPath);
+			const entryKey = virtual.keyOf(entryPath) ?? virtual.keyOf(resolve(entryPath));
+			const entryIsVirtual = entryKey !== void 0;
+			const resolvedEntry = entryIsVirtual ? virtualKeyPath(entryKey) ?? entryKey : resolve(entryPath);
 			const entryBase = isAbsolute(resolvedEntry) ? resolvedEntry : resolve("__env_runner_virtual_entry__.mjs");
 			const entryDir = dirname(entryBase);
-			const entrySource = entryIsVirtual ? virtual[entryPath] : _tryReadFile(resolvedEntry);
-			const detectedExports = this.#exports === false || this.#exports === void 0 ? [] : detectExportedClasses(entrySource, typeof this.#exports === "object" ? this.#exports : {});
-			if (entryIsVirtual && detectedExports.length > 0) throw new Error(`[env-runner] named exports (${detectedExports.join(", ")}) are not supported with a virtual entry on the miniflare runner; pass \`exports: false\` or use a real entry file.`);
-			if (detectedExports.length > 0 && !options.durableObjects) {
-				const autoDOs = { ...this.#miniflareOptions.durableObjects || {} };
+			const entrySource = entryIsVirtual ? virtualModuleCodeSource(entryKey, virtual.sources[entryKey]) : _tryReadFile(resolvedEntry);
+			const detectedExports = this.#exports === false || typeof this.#exports === "string" ? [] : detectExportedClasses(entrySource, typeof this.#exports === "object" ? this.#exports : {});
+			if (detectedExports.length > 0) {
+				const existingDOs = isPlainObject(options.durableObjects) ? options.durableObjects : {};
+				const boundClasses = new Set(Object.values(existingDOs).map((b) => typeof b === "string" ? b : isPlainObject(b) && !b.scriptName ? b.className : void 0));
+				const autoDOs = { ...existingDOs };
 				for (const name of detectedExports) {
 					const bindingName = toScreamingSnakeCase(name);
-					if (!autoDOs[bindingName]) autoDOs[bindingName] = name;
+					if (!autoDOs[bindingName] && !boundClasses.has(name)) autoDOs[bindingName] = name;
 				}
 				options.durableObjects = autoDOs;
 			}
-			options.script = generateWrapper(resolvedEntry, {
+			const script = generateWrapper(entryIsVirtual ? toWorkerdPath(resolvedEntry) : resolvedEntry, {
 				dynamicOnly: true,
 				captureErrors: this.#captureErrors,
-				exports: detectedExports
+				exports: typeof this.#exports === "string" ? this.#exports : detectedExports,
+				nodeCompat: !options.compatibilityFlags.includes("no_nodejs_compat")
 			});
-			options.scriptPath = entryDir + "/__env_runner_wrapper.mjs";
+			const scriptPath = entryDir + "/__env_runner_wrapper.mjs";
+			const skipLocator = typeof this.#exports === "string" || entryIsVirtual && detectedExports.length > 0;
+			if (skipLocator) options.modules = [{
+				type: "ESModule",
+				path: scriptPath,
+				contents: script
+			}];
+			else {
+				options.script = script;
+				options.scriptPath = scriptPath;
+			}
 			if (!options.modulesRoot) options.modulesRoot = "/";
 			options.unsafeEvalBinding = UNSAFE_EVAL_BINDING;
 			options.serviceBindings = {
@@ -664,12 +1203,12 @@ var MiniflareEnvRunner = class extends BaseEnvRunner {
 				[IPC_BINDING]: async (request) => {
 					try {
 						const message = await request.json();
-						this._handleMessage(message);
+						ipc.runner._handleMessage(message);
 					} catch {}
 					return new Response(null, { status: 204 });
 				}
 			};
-			if (this.#transformRequest && !options.modulesRules) options.modulesRules = [{
+			if (this.#transformRequest && !options.modulesRules && !miniflare.convertV4MiniflareOptions && !skipLocator) options.modulesRules = [{
 				type: "ESModule",
 				include: [
 					"**/*.ts",
@@ -681,10 +1220,23 @@ var MiniflareEnvRunner = class extends BaseEnvRunner {
 			if (!options.unsafeModuleFallbackService) {
 				const _require = createRequire(entryBase);
 				const _virtual = virtual;
-				const _virtualVersions = this.#virtualVersions;
 				const _transformRequest = this.#transformRequest;
 				const _exportConditions = this.#exportConditions;
-				const _applyVirtualVersions = (code) => applyVirtualVersions(code, _virtualVersions);
+				const _applyVirtualVersions = (code, modulePath) => applyVirtualVersions(code, _virtual.versions, (specifier) => _virtual.versionedKeyOf(specifier, modulePath));
+				const _serveVirtual = (module, modulePath) => {
+					const { source } = module;
+					switch (module.format) {
+						case "module": return { esModule: _applyVirtualVersions(source, modulePath) };
+						case "commonjs": return {
+							commonJsModule: source,
+							namedExports: commonJSExports(source).filter((e) => e !== "default")
+						};
+						case "json": return { json: source };
+						case "text": return { text: source };
+						case "bytes": return { esModule: virtualModuleCode("bytes", source) };
+						case "wasm": return { wasm: Array.from(source) };
+					}
+				};
 				options.unsafeUseModuleFallbackService = true;
 				const modulePathMap = /* @__PURE__ */ new Map();
 				const _lexersReady = Promise.all([ensureCjsLexer(), init$1]);
@@ -697,24 +1249,30 @@ var MiniflareEnvRunner = class extends BaseEnvRunner {
 					if (!specifier) return new Response(null, { status: 404 });
 					const cleanSpecifier = specifier.split("?")[0] || specifier;
 					const cleanRaw = rawSpecifier?.split("?")[0];
-					if (_virtual) {
-						const bareSpecifier = cleanSpecifier.startsWith("/") ? cleanSpecifier.slice(1) : cleanSpecifier;
-						const virtualKey = [
-							cleanRaw,
-							cleanSpecifier,
-							bareSpecifier
-						].find((key) => key !== void 0 && Object.hasOwn(_virtual, key));
-						if (virtualKey !== void 0) {
-							const name = bareSpecifier + (specifier.includes("?") ? specifier.slice(specifier.indexOf("?")) : "");
-							const source = _virtual[virtualKey];
-							return virtualModuleFormat(virtualKey) === "json" ? Response.json({
-								name,
-								json: source
-							}) : Response.json({
-								name,
-								esModule: _applyVirtualVersions(source)
+					const bareSpecifier = cleanSpecifier.startsWith("/") ? cleanSpecifier.slice(1) : cleanSpecifier;
+					const referrerKey = referrer.startsWith("/") ? referrer.slice(1) : referrer;
+					const referrerPath = modulePathMap.get(referrerKey);
+					const virtualKey = [
+						cleanRaw,
+						cleanSpecifier,
+						bareSpecifier
+					].find((key) => key !== void 0 && Object.hasOwn(_virtual.sources, key)) ?? (cleanRaw ? _virtual.keyOf(cleanRaw, referrerPath) : void 0) ?? _virtual.keyOf(cleanSpecifier);
+					if (virtualKey !== void 0) {
+						const query = specifier.includes("?") ? specifier.slice(specifier.indexOf("?")) : "";
+						const keyPath = virtualKeyPath(virtualKey);
+						if (keyPath && cleanRaw?.startsWith("file:") && cleanSpecifier !== keyPath && cleanSpecifier.includes("file:")) {
+							const location = Buffer.from(toWorkerdPath(keyPath) + query, "utf8").toString("latin1");
+							return new Response(null, {
+								status: 301,
+								headers: { location }
 							});
 						}
+						const name = bareSpecifier + query;
+						if (keyPath) modulePathMap.set(name, keyPath);
+						return Response.json({
+							name,
+							..._serveVirtual(_virtual.sources[virtualKey], keyPath)
+						});
 					}
 					let resolvedPath;
 					const fileUrlRaw = cleanRaw || cleanSpecifier;
@@ -723,9 +1281,8 @@ var MiniflareEnvRunner = class extends BaseEnvRunner {
 					} catch {
 						return new Response(null, { status: 404 });
 					}
-					else if (cleanRaw && !cleanRaw.startsWith(".") && !cleanRaw.startsWith("/")) {
-						const referrerKey = referrer.startsWith("/") ? referrer.slice(1) : referrer;
-						const referrerReal = modulePathMap.get(referrerKey);
+					else if (cleanRaw && !cleanRaw.startsWith(".") && !cleanRaw.startsWith("/") && !isAbsolute(cleanRaw)) {
+						const referrerReal = referrerPath;
 						const contextRequire = referrerReal ? createRequire(referrerReal) : _require;
 						if (cleanRaw.startsWith("cloudflare:")) return new Response(null, { status: 404 });
 						if (cleanRaw.startsWith("node:")) {
@@ -749,11 +1306,11 @@ var MiniflareEnvRunner = class extends BaseEnvRunner {
 							});
 						}
 					} else {
-						const referrerKey = referrer.startsWith("/") ? referrer.slice(1) : referrer;
-						const referrerReal = modulePathMap.get(referrerKey) || (referrer.startsWith("/") ? referrer : "/" + referrer);
+						const referrerReal = referrerPath || (referrer.startsWith("/") ? referrer : "/" + referrer);
 						const referrerDir = dirname(referrerReal);
 						const raw = cleanRaw || cleanSpecifier;
 						if (raw.startsWith(".")) resolvedPath = resolve(referrerDir, raw);
+						else if (cleanRaw && isAbsolute(cleanRaw) && !cleanRaw.startsWith("/")) resolvedPath = cleanRaw;
 						else if (cleanSpecifier.startsWith("/")) resolvedPath = cleanSpecifier;
 						else try {
 							resolvedPath = _require.resolve(raw);
@@ -769,7 +1326,7 @@ var MiniflareEnvRunner = class extends BaseEnvRunner {
 							modulePathMap.set(name, resolvedPath);
 							return Response.json({
 								name,
-								esModule: _applyVirtualVersions(result.code)
+								esModule: _applyVirtualVersions(result.code, resolvedPath)
 							});
 						}
 					} catch {}
@@ -778,7 +1335,7 @@ var MiniflareEnvRunner = class extends BaseEnvRunner {
 						modulePathMap.set(name, resolvedPath);
 						if (resolvedPath.endsWith(".mjs") || !resolvedPath.endsWith(".cjs") && /\b(import\s|import\(|export\s|export\{|import\.meta\b)/.test(contents)) return Response.json({
 							name,
-							esModule: _applyVirtualVersions(contents)
+							esModule: _applyVirtualVersions(contents, resolvedPath)
 						});
 						const cjsSuffix = "?__cjs";
 						if (specifier.endsWith(cjsSuffix)) return Response.json({
@@ -800,31 +1357,35 @@ var MiniflareEnvRunner = class extends BaseEnvRunner {
 			this.#cacheKey = computeCacheKey(entryPath, {
 				...this.#miniflareOptions,
 				_exportConditions: this.#exportConditions,
-				_virtual: virtual
+				_exports: this.#exports,
+				_virtual: encodeVirtualModules(initialVirtual)
 			});
 			const cached = _miniflareCache.get(this.#cacheKey);
 			if (cached) {
 				this.#miniflare = cached.mf;
 				cached.refCount++;
 				this.#cacheEntry = cached;
+				cached.ipc.runner = this;
 				this.#virtual = cached.virtual;
-				this.#virtualVersions = cached.versions;
 			}
 		}
 		if (!this.#miniflare) {
-			this.#miniflare = new Miniflare(options);
+			this.#miniflare = new miniflare.Miniflare(toMiniflareOptions(miniflare, options));
 			await this.#miniflare.ready;
 			if (this.#persistent && this.#cacheKey) {
 				this.#cacheEntry = {
 					mf: this.#miniflare,
 					refCount: 1,
 					virtual,
-					versions: this.#virtualVersions
+					ipc
 				};
 				_miniflareCache.set(this.#cacheKey, this.#cacheEntry);
 			}
 		}
-		const initRes = await this.#miniflare.dispatchFetch("http://localhost/__env_runner_ipc", { headers: { upgrade: "websocket" } });
+		const loadRes = await this.#miniflare.dispatchFetch("http://localhost" + IPC_PATH);
+		const loadBody = await loadRes.text().catch(() => "");
+		if (!loadRes.ok) throw new Error(`Failed to establish WebSocket IPC channel (${loadRes.status}: ${loadBody})`);
+		const initRes = await this.#miniflare.dispatchFetch("http://localhost" + IPC_PATH, { headers: { upgrade: "websocket" } });
 		const ws = initRes.webSocket;
 		if (!ws) {
 			const body = await initRes.text().catch(() => "");
@@ -853,6 +1414,55 @@ function detectExportedClasses(entrySource, explicit) {
 	}
 	return [...names];
 }
+function toMiniflareOptions(miniflare, options) {
+	if (!miniflare.convertV4MiniflareOptions) return options;
+	const { defaultPersistRoot, ...rest } = options;
+	return miniflare.convertV4MiniflareOptions({
+		resourcePersistencePath: defaultPersistRoot,
+		...rest
+	});
+}
+async function resolveSupportedCompatibilityDate(miniflare) {
+	if (typeof miniflare.supportedCompatibilityDate === "string") return miniflare.supportedCompatibilityDate;
+	try {
+		const from = [process.cwd() + "/", import.meta.url];
+		const miniflarePath = resolveModulePath("miniflare", {
+			from,
+			try: true
+		});
+		const workerdPath = resolveModulePath("workerd", { from: miniflarePath || from });
+		const { compatibilityDate } = await import(pathToFileURL(workerdPath).href);
+		if (!_isDateString(compatibilityDate)) return;
+		const today = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+		return compatibilityDate > today ? today : compatibilityDate;
+	} catch {
+		return;
+	}
+}
+function resolveCompatibilityDate(candidates, supported) {
+	const date = candidates.find((d) => typeof d === "string" && d) ?? supported;
+	if (date && supported && _isDateString(date) && _isDateString(supported) && date > supported) {
+		console.warn(`[env-runner] compatibility date "${date}" is newer than the installed workerd supports; falling back to "${supported}".`);
+		return supported;
+	}
+	return date;
+}
+function resolveCompatibilityFlags(wranglerFlags, userFlags) {
+	const opposite = (flag) => flag === "nodejs_compat" ? "no_nodejs_compat" : flag === "no_nodejs_compat" ? "nodejs_compat" : void 0;
+	const flags = [...wranglerFlags.filter((flag) => !userFlags.includes(opposite(flag))), ...userFlags];
+	const defaults = flags.includes("no_nodejs_compat") ? [] : ["nodejs_compat"];
+	return [.../* @__PURE__ */ new Set([...defaults, ...flags])];
+}
+function _isDateString(value) {
+	return /^\d{4}-\d{2}-\d{2}$/.test(value);
+}
+function hasUserPersistOptions(options) {
+	return Object.keys(options).some((key) => key === "defaultPersistRoot" || key === "resourcePersistencePath" || key.endsWith("Persist"));
+}
+function wranglerPersistRoot(configFile, explicitPath) {
+	const file = configFile ?? (explicitPath ? resolve(explicitPath) : void 0);
+	return join(file ? dirname(file) : process.cwd(), ".wrangler/state/v3");
+}
 function _tryReadFile(path) {
 	try {
 		return readFileSync(path, "utf8");
@@ -868,26 +1478,93 @@ function computeCacheKey(entryPath, opts) {
 	for (const [k, v] of Object.entries(opts)) if (typeof v !== "function") serializableOpts[k] = v;
 	return `${resolve(entryPath)}::${JSON.stringify(serializableOpts)}`;
 }
-function applyVirtualVersions(code, versions) {
-	if (versions.size === 0) return code;
+const _isWin = process.platform === "win32";
+function virtualKeyPath(key) {
+	if (_isWin && /^\/[A-Za-z]:\//.test(key)) key = key.slice(1);
+	if (key.startsWith("file:")) try {
+		return fileURLToPath(key);
+	} catch {
+		return;
+	}
+	return isAbsolute(key) ? resolve(key) : void 0;
+}
+function toWorkerdPath(path) {
+	return _isWin && /^[A-Za-z]:[\\/]/.test(path) ? "/" + path.replaceAll("\\", "/") : path;
+}
+function createMiniflareVirtualModules(sources) {
+	return refreshVirtualKeyResolvers({
+		sources,
+		removed: /* @__PURE__ */ new Set(),
+		versions: /* @__PURE__ */ new Map(),
+		version: 0
+	});
+}
+function refreshVirtualKeyResolvers(virtual) {
+	const keys = Object.keys(virtual.sources);
+	virtual.keyOf = createVirtualKeyResolver(keys);
+	virtual.versionedKeyOf = virtual.removed.size > 0 ? createVirtualKeyResolver([...keys, ...virtual.removed]) : virtual.keyOf;
+	return virtual;
+}
+function createVirtualKeyResolver(keys) {
+	const verbatim = new Set(keys);
+	const pathKeys = /* @__PURE__ */ new Map();
+	for (const key of verbatim) {
+		const path = virtualKeyPath(key);
+		if (path !== void 0) pathKeys.set(path, key);
+	}
+	return (specifier, importerPath) => {
+		const clean = specifier.split("?")[0];
+		if (verbatim.has(clean)) return clean;
+		if (pathKeys.size === 0) return;
+		const path = /^\.\.?\//.test(clean) ? importerPath && resolve(dirname(importerPath), clean) : virtualKeyPath(clean);
+		return path ? pathKeys.get(path) : void 0;
+	};
+}
+function virtualImporters(virtual, keyOf) {
+	const importers = /* @__PURE__ */ new Map();
+	for (const [importer, { source, format }] of Object.entries(virtual)) {
+		if (format !== "module") continue;
+		const importerPath = virtualKeyPath(importer);
+		for (const { specifier } of versionableImports(source) ?? []) {
+			const key = keyOf(specifier, importerPath);
+			if (key !== void 0 && key !== importer) {
+				let set = importers.get(key);
+				if (!set) importers.set(key, set = /* @__PURE__ */ new Set());
+				set.add(importer);
+			}
+		}
+	}
+	return importers;
+}
+function versionableImports(code) {
 	let imports;
 	try {
 		[imports] = parse$1(code);
 	} catch {
-		return code;
+		return;
 	}
+	const result = [];
+	for (const imp of imports) {
+		if (typeof imp.specifier !== "string" || imp.type === "dynamic" && imp.glob) continue;
+		result.push({
+			specifier: imp.specifier,
+			end: imp.type === "dynamic" ? imp.end - 1 : imp.end
+		});
+	}
+	return result;
+}
+function applyVirtualVersions(code, versions, keyOf) {
+	if (versions.size === 0) return code;
+	const imports = versionableImports(code);
+	if (!imports) return code;
 	let out = "";
 	let last = 0;
-	for (const imp of imports) {
-		if (imp.type === "import-meta") continue;
-		const dynamic = imp.type === "dynamic";
-		if (dynamic && imp.glob) continue;
-		const specifier = imp.specifier;
-		const version = specifier === void 0 ? void 0 : versions.get(specifier);
+	for (const { specifier, end } of imports) {
+		const key = keyOf(specifier);
+		const version = key === void 0 ? void 0 : versions.get(key);
 		if (!version) continue;
-		const versioned = `${specifier}?v=${version}`;
-		out += code.slice(last, imp.start) + (dynamic ? JSON.stringify(versioned) : versioned);
-		last = imp.end;
+		out += code.slice(last, end) + (specifier.includes("?") ? "&" : "?") + `v=${version}`;
+		last = end;
 	}
 	return out + code.slice(last);
 }
@@ -901,12 +1578,15 @@ function ensureCjsLexer() {
 	if (!_cjsLexerReady) _cjsLexerReady = init();
 	return _cjsLexerReady;
 }
-function createCjsEsmShim(cjsSpecifier, contents) {
-	let namedExports = [];
+function commonJSExports(contents) {
 	try {
-		const { exports } = parse(contents);
-		namedExports = exports.filter((e) => e !== "default" && e !== "__esModule");
-	} catch {}
+		return parse(contents).exports;
+	} catch {
+		return [];
+	}
+}
+function createCjsEsmShim(cjsSpecifier, contents) {
+	const namedExports = commonJSExports(contents).filter((e) => e !== "default" && e !== "__esModule");
 	let shim = `import __cjs_mod__ from ${JSON.stringify(cjsSpecifier)};\nexport default __cjs_mod__;\n`;
 	for (const name of namedExports) shim += `export var ${name} = __cjs_mod__["${name}"];\n`;
 	return shim;