env-runner 0.2.3 → 0.3.0

package/dist/_chunks/miniflare-runner.mjs

@@ -1,25 +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, statSync, writeFileSync } from "node:fs";
 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";
 import { parseEnv } from "node:util";
-const IPC_PATH = "/__env_runner_ipc";
+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) {
@@ -38,7 +37,7 @@ if (!globalThis.process) { globalThis.process = __process; }`;
 ${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)};
@@ -46,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();
 
@@ -132,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",
@@ -206,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);
@@ -215,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();
@@ -243,18 +257,15 @@ 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}
   }
 };
 `;
@@ -895,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;
@@ -902,7 +914,6 @@ var MiniflareEnvRunner = class extends BaseEnvRunner {
 	#transformRequest;
 	#reloadCounter = 0;
 	#virtual;
-	#virtualVersions = /* @__PURE__ */ new Map();
 	#cacheEntry;
 	#ws;
 	#persistent;
@@ -959,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
 		});
@@ -987,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++;
@@ -1000,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() {
@@ -1066,23 +1094,37 @@ 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 { options: wranglerOptions, configFile: wranglerConfigFile } = await loadWranglerConfig({
 			wrangler: this.#wrangler,
@@ -1118,14 +1160,15 @@ 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.`);
+			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));
@@ -1136,13 +1179,23 @@ var MiniflareEnvRunner = class extends BaseEnvRunner {
 				}
 				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 = {
@@ -1150,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",
@@ -1167,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]);
@@ -1183,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;
@@ -1209,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:")) {
@@ -1235,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);
@@ -1255,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 {}
@@ -1264,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({
@@ -1286,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(() => "");
@@ -1339,6 +1414,31 @@ 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) {
@@ -1357,7 +1457,7 @@ function _isDateString(value) {
 	return /^\d{4}-\d{2}-\d{2}$/.test(value);
 }
 function hasUserPersistOptions(options) {
-	return Object.keys(options).some((key) => key === "defaultPersistRoot" || key.endsWith("Persist"));
+	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);
@@ -1378,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);
 }
@@ -1411,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;

package/dist/_chunks/node-worker-runner.mjs

@@ -1,5 +1,4 @@
-import { BaseEnvRunner } from "./common-base-runner.mjs";
-import { hostEnv } from "./common-host-env.mjs";
+import { BaseEnvRunner, hostEnv } from "./common-base-runner.mjs";
 import { fileURLToPath } from "node:url";
 import { existsSync } from "node:fs";
 import { Worker } from "node:worker_threads";