env-runner 0.3.0 → 0.3.1

package/dist/_chunks/miniflare-runner.mjs

@@ -1,15 +1,15 @@
-import { encodeVirtualModules, expandVirtualInvalidation, stripVirtualTypeScript, unsupportedVirtualJSXError, virtualModuleCode, virtualModuleCodeSource, virtualModuleFormat } from "./virtual-loader.mjs";
+import { encodeVirtualModules, expandVirtualInvalidation, jsonModuleCode, queryOf, restoreInternalQuery, stripInternalQuery, stripQuery, stripVirtualTypeScript, transformedFormat, unsupportedVirtualJSXError, virtualModuleCode, virtualModuleCodeSource, virtualModuleFormat } from "./plugin-hooks.mjs";
 import { BaseEnvRunner } from "./common-base-runner.mjs";
+import { init, parse } from "./libs/es-module-lexer.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 { init as init$1, parse as parse$1 } from "./libs/cjs-module-lexer.mjs";
 import { createRequire } from "node:module";
 import { proxyUpgrade } from "httpxy";
 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 { resolveModulePath } from "exsolve";
 import { parseEnv } from "node:util";
 const IPC_PATH$1 = "/__env_runner_ipc";
 const IPC_BINDING = "__ENV_RUNNER_IPC";
@@ -170,7 +170,7 @@ async function __handleWsMessage(env, data) {
   if (msg.type === "reload" && env.__ENV_RUNNER_UNSAFE_EVAL__) {
     const version = msg.version || 0;
     try {
-      const newEntry = await __loadEntry(env, __entryPath + "?t=" + version);
+      const newEntry = await __loadEntry(env, __entryPath + "?__envRunnerReload=" + version);
       const newServer = __createServer(newEntry);
       if (__userEntry?.ipc?.onClose) {
         await __userEntry.ipc.onClose();
@@ -1021,7 +1021,7 @@ var MiniflareEnvRunner = class extends BaseEnvRunner {
 		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;
+		await init;
 		const merged = {
 			...virtual.sources,
 			...prepared
@@ -1045,6 +1045,9 @@ var MiniflareEnvRunner = class extends BaseEnvRunner {
 	_runtimeType() {
 		return "miniflare";
 	}
+	_resolveConditions() {
+		return this.#exportConditions;
+	}
 	async _closeRuntime() {
 		if (!this.#miniflare) return;
 		if (this.#ws) {
@@ -1208,19 +1211,22 @@ var MiniflareEnvRunner = class extends BaseEnvRunner {
 					return new Response(null, { status: 204 });
 				}
 			};
-			if (this.#transformRequest && !options.modulesRules && !miniflare.convertV4MiniflareOptions && !skipLocator) options.modulesRules = [{
+			if ((this.#transformRequest || this._plugins) && !options.modulesRules && !miniflare.convertV4MiniflareOptions && !skipLocator) options.modulesRules = [{
 				type: "ESModule",
 				include: [
-					"**/*.ts",
-					"**/*.tsx",
-					"**/*.jsx",
-					"**/*.mts"
-				]
+					".ts",
+					".tsx",
+					".jsx",
+					".mts",
+					...this._plugins ? [".cts"] : []
+				].map((ext) => `**/*${ext}`)
 			}];
 			if (!options.unsafeModuleFallbackService) {
 				const _require = createRequire(entryBase);
 				const _virtual = virtual;
 				const _transformRequest = this.#transformRequest;
+				const _livePlugins = () => ipc.runner._plugins;
+				const _cjsOutput = /* @__PURE__ */ new Map();
 				const _exportConditions = this.#exportConditions;
 				const _applyVirtualVersions = (code, modulePath) => applyVirtualVersions(code, _virtual.versions, (specifier) => _virtual.versionedKeyOf(specifier, modulePath));
 				const _serveVirtual = (module, modulePath) => {
@@ -1237,9 +1243,33 @@ var MiniflareEnvRunner = class extends BaseEnvRunner {
 						case "wasm": return { wasm: Array.from(source) };
 					}
 				};
+				const _pluginCode = async (id, result) => {
+					if (result.moduleType !== "ts") return result.code;
+					const strip = await _getStripTypeScriptTypes();
+					if (typeof strip !== "function") throw new TypeError(`[env-runner] "${id}" is still TypeScript after its plugins, which needs \`module.stripTypeScriptTypes\` on the host: upgrade Node.js or compile it in a plugin.`);
+					return strip(result.code);
+				};
+				const _servePluginModule = async (id, result) => {
+					if (result.moduleType === "json") return { esModule: jsonModuleCode(id, result.code) };
+					const code = await _pluginCode(id, result);
+					if (transformedFormat(id, code) === "module") return { esModule: _applyVirtualVersions(code, void 0) };
+					return {
+						commonJsModule: code,
+						namedExports: commonJSExports(code).filter((e) => e !== "default")
+					};
+				};
+				const _pluginModuleIds = /* @__PURE__ */ new Map();
+				const _pluginErrorModule = (name, error) => {
+					const message = error?.message || String(error);
+					console.error(message);
+					return Response.json({
+						name,
+						esModule: `throw new Error(${JSON.stringify(message)});`
+					});
+				};
 				options.unsafeUseModuleFallbackService = true;
 				const modulePathMap = /* @__PURE__ */ new Map();
-				const _lexersReady = Promise.all([ensureCjsLexer(), init$1]);
+				const _lexersReady = Promise.all([ensureCjsLexer(), init]);
 				options.unsafeModuleFallbackService = async (request) => {
 					await _lexersReady;
 					const url = new URL(request.url);
@@ -1274,9 +1304,54 @@ var MiniflareEnvRunner = class extends BaseEnvRunner {
 							..._serveVirtual(_virtual.sources[virtualKey], keyPath)
 						});
 					}
+					const rawQuery = specifier.includes("?") ? specifier.slice(specifier.indexOf("?")) : "";
+					const name = (cleanSpecifier.startsWith("/") ? cleanSpecifier.slice(1) : cleanSpecifier) + rawQuery;
+					const versionedKey = _virtual.versionedKeyOf(cleanRaw || cleanSpecifier, referrerPath);
+					const version = versionedKey === void 0 ? void 0 : _virtual.versions.get(versionedKey);
+					const query = queryOf(stripInternalQuery(specifier, version));
 					let resolvedPath;
+					let resolvedId;
+					let pluginResolved = false;
+					const _resolvePlugins = _livePlugins();
+					const rawSource = rawSpecifier ? stripInternalQuery(rawSpecifier, version) : bareSpecifier + query;
+					const _pluginResolve = async (fallback) => {
+						if (!_resolvePlugins) return;
+						try {
+							const source = rawSource.startsWith("file:") ? fileURLToPath(stripQuery(rawSource)) + queryOf(rawSource) : rawSource;
+							if (!_resolvePlugins.resolveFilter(source, fallback)) return;
+							const resolved = await _resolvePlugins.resolveId(source, _pluginModuleIds.get(referrerKey) ?? referrerPath, { fallback });
+							if (!resolved || resolved.external) return;
+							const id = resolved.id;
+							const idPath = stripQuery(id);
+							const pathKey = isAbsolute(idPath) ? _virtual.keyOf(idPath) : void 0;
+							const keyPath = pathKey === void 0 ? void 0 : virtualKeyPath(pathKey);
+							if (keyPath) {
+								const location = restoreInternalQuery(toWorkerdPath(keyPath) + queryOf(id), specifier);
+								return new Response(null, {
+									status: 301,
+									headers: { location: Buffer.from(location, "utf8").toString("latin1") }
+								});
+							}
+							if (isAbsolute(idPath)) {
+								resolvedId = id;
+								pluginResolved = true;
+								return idPath;
+							}
+							const result = await _resolvePlugins.load(id);
+							_pluginModuleIds.set(name, id);
+							return Response.json({
+								name,
+								...await _servePluginModule(id, result)
+							});
+						} catch (error) {
+							return _pluginErrorModule(name, error);
+						}
+					};
+					const pluginPath = await _pluginResolve(false);
+					if (pluginPath instanceof Response) return pluginPath;
+					resolvedPath = pluginPath;
 					const fileUrlRaw = cleanRaw || cleanSpecifier;
-					if (fileUrlRaw.startsWith("file://")) try {
+					if (resolvedPath !== void 0) {} else if (fileUrlRaw.startsWith("file://")) try {
 						resolvedPath = fileURLToPath(fileUrlRaw);
 					} catch {
 						return new Response(null, { status: 404 });
@@ -1299,11 +1374,16 @@ var MiniflareEnvRunner = class extends BaseEnvRunner {
 								try: true
 							}) || contextRequire.resolve(cleanRaw);
 						} catch {
-							const name = cleanSpecifier.startsWith("/") ? cleanSpecifier.slice(1) : cleanSpecifier;
-							return Response.json({
-								name,
-								esModule: "export default undefined;"
-							});
+							const failed = await _pluginResolve(true);
+							if (failed instanceof Response) return failed;
+							if (failed === void 0) {
+								const name = cleanSpecifier.startsWith("/") ? cleanSpecifier.slice(1) : cleanSpecifier;
+								return Response.json({
+									name,
+									esModule: "export default undefined;"
+								});
+							}
+							resolvedPath = failed;
 						}
 					} else {
 						const referrerReal = referrerPath || (referrer.startsWith("/") ? referrer : "/" + referrer);
@@ -1315,11 +1395,17 @@ var MiniflareEnvRunner = class extends BaseEnvRunner {
 						else try {
 							resolvedPath = _require.resolve(raw);
 						} catch {
-							return new Response(null, { status: 404 });
+							const failed = await _pluginResolve(true);
+							if (failed === void 0) return new Response(null, { status: 404 });
+							if (failed instanceof Response) return failed;
+							resolvedPath = failed;
 						}
 					}
-					const rawQuery = specifier.includes("?") ? specifier.slice(specifier.indexOf("?")) : "";
-					const name = (cleanSpecifier.startsWith("/") ? cleanSpecifier.slice(1) : cleanSpecifier) + rawQuery;
+					if (!pluginResolved && _resolvePlugins && !existsSync(resolvedPath)) {
+						const failed = await _pluginResolve(true);
+						if (failed instanceof Response) return failed;
+						resolvedPath = failed ?? resolvedPath;
+					}
 					if (_transformRequest) try {
 						const result = await _transformRequest(resolvedPath);
 						if (result?.code) {
@@ -1330,26 +1416,65 @@ var MiniflareEnvRunner = class extends BaseEnvRunner {
 							});
 						}
 					} catch {}
+					let contents;
 					try {
-						const contents = readFileSync(resolvedPath, "utf8");
-						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, resolvedPath)
-						});
-						const cjsSuffix = "?__cjs";
-						if (specifier.endsWith(cjsSuffix)) return Response.json({
-							name,
-							commonJsModule: contents
-						});
-						const esModule = createCjsEsmShim("./" + basename(resolvedPath) + cjsSuffix, contents);
-						return Response.json({
-							name,
-							esModule
-						});
-					} catch {
-						return new Response(null, { status: 404 });
+						contents = readFileSync(resolvedPath, "utf8");
+					} catch {}
+					const _plugins = _livePlugins();
+					const cjsRequest = /[?&]__cjs$/.test(specifier);
+					const id = resolvedId ?? resolvedPath + query;
+					const cachedCJS = cjsRequest && _cjsOutput.has(id);
+					const pluginFile = !cachedCJS && _plugins?.filter(id, void 0, pluginResolved);
+					if (contents === void 0 && !cachedCJS && !pluginFile) return new Response(null, { status: 404 });
+					modulePathMap.set(name, resolvedPath);
+					if (id !== resolvedPath) _pluginModuleIds.set(name, id);
+					let transformed;
+					if (cachedCJS) {
+						transformed = _cjsOutput.get(id);
+						_cjsOutput.delete(id);
+					} else if (pluginFile) {
+						try {
+							const file = resolvedPath;
+							const result = await _plugins.load(id, () => {
+								if (contents === void 0) throw new Error(`Cannot find module "${file}"`);
+								return contents;
+							}, { resolved: pluginResolved });
+							if (result?.moduleType === "json") return Response.json({
+								name,
+								esModule: jsonModuleCode(file, result.code)
+							});
+							transformed = result && await _pluginCode(id, result);
+						} catch (error) {
+							return _pluginErrorModule(name, error);
+						}
+						if (transformed === void 0 && contents === void 0) return new Response(null, { status: 404 });
+					}
+					if (transformed === void 0 && resolvedPath.endsWith(".wasm")) return Response.json({
+						name,
+						wasm: Array.from(readFileSync(resolvedPath))
+					});
+					let isESM;
+					if (transformed === void 0) {
+						contents = contents;
+						isESM = resolvedPath.endsWith(".mjs") || !resolvedPath.endsWith(".cjs") && /\b(import\s|import\(|export\s|export\{|import\.meta\b)/.test(contents);
+					} else {
+						contents = transformed;
+						isESM = transformedFormat(resolvedPath, contents) === "module";
 					}
+					if (isESM) return Response.json({
+						name,
+						esModule: _applyVirtualVersions(contents, resolvedPath)
+					});
+					if (cjsRequest) return Response.json({
+						name,
+						commonJsModule: contents
+					});
+					if (transformed !== void 0) _cjsOutput.set(id, transformed);
+					const esModule = createCjsEsmShim("./" + basename(resolvedPath) + (query ? `${query}&` : "?") + "__cjs", contents);
+					return Response.json({
+						name,
+						esModule
+					});
 				};
 			}
 		}
@@ -1358,6 +1483,7 @@ var MiniflareEnvRunner = class extends BaseEnvRunner {
 				...this.#miniflareOptions,
 				_exportConditions: this.#exportConditions,
 				_exports: this.#exports,
+				_plugins: Boolean(this._plugins),
 				_virtual: encodeVirtualModules(initialVirtual)
 			});
 			const cached = _miniflareCache.get(this.#cacheKey);
@@ -1539,7 +1665,7 @@ function virtualImporters(virtual, keyOf) {
 function versionableImports(code) {
 	let imports;
 	try {
-		[imports] = parse$1(code);
+		[imports] = parse(code);
 	} catch {
 		return;
 	}
@@ -1575,12 +1701,12 @@ function _getStripTypeScriptTypes() {
 }
 let _cjsLexerReady;
 function ensureCjsLexer() {
-	if (!_cjsLexerReady) _cjsLexerReady = init();
+	if (!_cjsLexerReady) _cjsLexerReady = init$1();
 	return _cjsLexerReady;
 }
 function commonJSExports(contents) {
 	try {
-		return parse(contents).exports;
+		return parse$1(contents).exports;
 	} catch {
 		return [];
 	}

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

@@ -1,11 +1,13 @@
 import { WorkerHooks } from "./types.mjs";
-import { EnvRunnerData } from "./common-base-runner.mjs";
+import { EnvRunnerData, EnvRunnerPluginOption } from "./common-base-runner.mjs";
 import { NodeWorkerEnvRunner } from "./node-worker-runner.mjs";
 export interface NetlifyEnvRunnerOptions {
   name: string;
   workerEntry?: string;
   hooks?: WorkerHooks;
   data?: EnvRunnerData;
+  /** Host-side transform plugins (see `EnvRunnerPluginOption`). */
+  plugins?: EnvRunnerPluginOption[];
   /**
    * `@netlify/runtime` specifier (resolved from cwd), imported inside the worker
    * since a module instance can't cross into it. Omitted: imported optionally,

package/dist/_chunks/node-worker-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 NodeWorkerEnvRunner extends BaseEnvRunner {
   #private;
   constructor(opts: {
@@ -7,6 +7,8 @@ export declare class NodeWorkerEnvRunner extends BaseEnvRunner {
     workerEntry?: string;
     hooks?: WorkerHooks;
     data?: EnvRunnerData;
+    /** Host-side transform plugins (see `EnvRunnerPluginOption`). */
+    plugins?: EnvRunnerPluginOption[];
   });
   sendMessage(message: unknown): void;
   protected _hasRuntime(): boolean;

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

@@ -1,3 +1,4 @@
+import { PLUGINS_DATA_KEY } from "./plugin-hooks.mjs";
 import { BaseEnvRunner, hostEnv } from "./common-base-runner.mjs";
 import { fileURLToPath } from "node:url";
 import { existsSync } from "node:fs";
@@ -36,12 +37,16 @@ var NodeWorkerEnvRunner = class extends BaseEnvRunner {
 			this.close(`worker entry not found in "${this._workerEntry}".`);
 			return;
 		}
+		const plugins = this._pluginWorkerData("port");
+		const port = plugins[PLUGINS_DATA_KEY]?.port;
 		const worker = new Worker(this._workerEntry, {
 			env: hostEnv(),
 			workerData: {
 				name: this._name,
-				...this._data
-			}
+				...this._data,
+				...plugins
+			},
+			transferList: port ? [port] : void 0
 		});
 		worker.once("exit", (code) => {
 			worker._exitCode = code;