env-runner 0.2.2 → 0.3.0

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

@@ -7,27 +7,9 @@ export interface NetlifyEnvRunnerOptions {
   hooks?: WorkerHooks;
   data?: EnvRunnerData;
   /**
-   * Module specifier for the `@netlify/runtime` package, used inside the
-   * worker to call `startRuntime()` (full `globalThis.Netlify` + `caches`
-   * setup). `env-runner` does not depend on `@netlify/runtime`.
-   *
-   * Unlike the other runtime-dependency options, this one takes a **specifier
-   * only**: the runtime has to be instantiated inside the worker thread, and a
-   * live module instance cannot cross that boundary.
-   *
-   * ```ts
-   * new NetlifyEnvRunner({
-   *   name: "app",
-   *   netlifyRuntime: import.meta.resolve("@netlify/runtime"),
-   *   data: { entry },
-   * });
-   * ```
-   *
-   * A bare specifier (e.g. `"@netlify/runtime"`) is resolved from the current
-   * working directory. When omitted, the worker tries
-   * `import("@netlify/runtime")` and falls back to a lightweight
-   * `globalThis.Netlify` shim (env access only) if it isn't installed. Pass
-   * `false` to always use the shim.
+   * `@netlify/runtime` specifier (resolved from cwd), imported inside the worker
+   * since a module instance can't cross into it. Omitted: imported optionally,
+   * else an env-only `globalThis.Netlify` shim. `false` forces the shim.
    */
   netlifyRuntime?: string | URL | false;
 }

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";

package/dist/_chunks/server.mjs

@@ -168,9 +168,16 @@ var RunnerManager = class {
 		await this._runner.reloadModule(timeout);
 		this._moduleInvalidated = false;
 	}
+	async updateVirtualModules(changes, timeout) {
+		const runner = await this._waitForRunner();
+		if (!runner?.updateVirtualModules) throw new Error("Active runner does not support updateVirtualModules()");
+		await runner.updateVirtualModules(changes, timeout);
+		this._moduleInvalidated = true;
+	}
 	async invalidateModule(specifier, timeout) {
-		if (!this._runner?.invalidateModule) throw new Error("Active runner does not support invalidateModule()");
-		await this._runner.invalidateModule(specifier, timeout);
+		const runner = await this._waitForRunner();
+		if (!runner?.invalidateModule) throw new Error("Active runner does not support invalidateModule()");
+		await runner.invalidateModule(specifier, timeout);
 		this._moduleInvalidated = true;
 	}
 	async close() {
@@ -208,11 +215,11 @@ var RunnerManager = class {
 		runner.onMessage(this._internalListener);
 		for (const listener of this._messageListeners) runner.onMessage(listener);
 		const originalClose = runner.close.bind(runner);
-		runner.close = async () => {
-			await originalClose();
+		runner.close = async (cause) => {
+			await originalClose(cause);
 			if (this._runner === runner) {
 				this._runner = void 0;
-				for (const fn of this._closeListeners) fn(this);
+				for (const fn of this._closeListeners) fn(this, cause);
 			}
 		};
 		if (runner.ready) this._flushQueue();
@@ -263,6 +270,7 @@ var EnvServer = class extends RunnerManager {
 	_reloadTimeout;
 	_reloadListeners = /* @__PURE__ */ new Set();
 	_startPromise;
+	_virtual;
 	runner = null;
 	onReload(listener) {
 		this._reloadListeners.add(listener);
@@ -285,6 +293,12 @@ var EnvServer = class extends RunnerManager {
 		this.runner = runner ?? await this._createRunner();
 		await super.reload(this.runner);
 	}
+	async updateVirtualModules(changes, timeout) {
+		const virtual = this._virtual ??= { ...this._opts.data?.virtual };
+		for (const [key, source] of Object.entries(changes)) if (source === null) delete virtual[key];
+		else if (source !== void 0) virtual[key] = source;
+		if (await this._waitForRunner()) await super.updateVirtualModules(changes, timeout);
+	}
 	async close() {
 		this._stopWatching();
 		await super.close();
@@ -305,6 +319,7 @@ var EnvServer = class extends RunnerManager {
 			hooks: this._opts.hooks,
 			data: {
 				...this._opts.data,
+				...this._virtual && { virtual: { ...this._virtual } },
 				entry: this._opts.entry
 			},
 			execArgv: this._opts.execArgv

package/dist/_chunks/types.d.mts

@@ -1,11 +1,36 @@
 import { IncomingMessage } from "node:http";
 import { Socket } from "node:net";
 /**
- * Handler for proxying HTTP requests to the worker.
- *
- * A relative string input (e.g. `"/path"`) is resolved against a placeholder
- * `http://localhost` origin before dispatching.
+ * How a virtual module is served. Code formats are Node's load formats, plus
+ * `jsx`/`tsx` (Bun only). Raw formats follow import attribute types: `text`
+ * default-exports a string, `bytes` a `Uint8Array`, and `wasm` a compiled
+ * `WebAssembly.Module` (like workerd's Wasm modules).
  */
+export type VirtualModuleFormat = "module" | "commonjs" | "module-typescript" | "commonjs-typescript" | "jsx" | "tsx" | "json" | "text" | "bytes" | "wasm";
+/** A source with an explicit format. */
+export interface VirtualModule {
+  /** Code or text; a `Uint8Array` for the `bytes` and `wasm` formats. */
+  source: string | Uint8Array;
+  /**
+   * Default: by the key's extension (`.cjs`, `.json`, `.ts`, `.wasm`, ...),
+   * else `module` for a string and `bytes` for a `Uint8Array`.
+   */
+  format?: VirtualModuleFormat;
+}
+/** A source whose format follows its key (string or bytes), or a source with its format. */
+export type VirtualModuleContent = string | Uint8Array | VirtualModule;
+/** Factories run on the host: before the worker spawns, and on updates. */
+export type VirtualModuleSource = VirtualModuleContent | (() => VirtualModuleContent | Promise<VirtualModuleContent>);
+/** Virtual modules as a `specifier => source` map. */
+export type VirtualModules = Record<string, VirtualModuleSource>;
+/** Changes to apply to a running map: a source sets (adds or replaces) a key, `null` removes it. */
+export type VirtualModuleUpdates = Record<string, VirtualModuleSource | null>;
+/**
+ * A validated module, as workers receive it: a string follows its key's
+ * extension, any other source carries its format.
+ */
+export type ResolvedVirtualModule = string | Required<VirtualModule>;
+/** Proxy a request to the worker; relative inputs resolve against `http://localhost`. */
 export type FetchHandler = (input: string | URL | Request, init?: RequestInit) => Promise<Response>;
 /** Callback for receiving messages from the worker. */
 export type RunnerMessageListener = (data: unknown) => void;
@@ -30,11 +55,7 @@ export interface RunnerRPCHooks {
   /** Remove a previously registered message listener. */
   offMessage: (listener: RunnerMessageListener) => void;
 }
-/**
- * Address reported by the worker once it is ready.
- *
- * Either a TCP `host`/`port` pair or a Unix `socketPath`.
- */
+/** Address reported by the worker once it is ready. */
 export type WorkerAddress = {
   host?: string;
   port: number;
@@ -74,6 +95,12 @@ export interface EnvRunner extends RunnerRPCHooks, AsyncDisposable {
   rpc<T = unknown>(name: string, data?: unknown, opts?: RPCOptions): Promise<T>;
   /** Re-import the entry module without restarting the worker/process. */
   reloadModule?(timeout?: number): Promise<void>;
+  /**
+   * Set (add or replace) and remove (`null`) virtual modules in one round trip.
+   * Changed and removed modules, and their importers, evaluate fresh on the
+   * next `reloadModule()`; a removed key falls through to normal resolution.
+   */
+  updateVirtualModules?(changes: VirtualModuleUpdates, timeout?: number): Promise<void>;
   /**
    * Invalidate a virtual module so the next `reloadModule()` re-evaluates it.
    * A factory-valued source is re-run for fresh contents.

package/dist/_chunks/vercel-runner.mjs

@@ -61,6 +61,7 @@ var VercelEnvRunner = class extends NodeWorkerEnvRunner {
 		input = this._resolveFetchInput(input);
 		const headers = new Headers(input instanceof Request ? input.headers : init?.headers);
 		const requestId = generateVercelId();
+		await this._waitForAddress();
 		if (this._address && this._address.port != null && !headers.has("x-vercel-deployment-url")) {
 			const host = this._address.host || "127.0.0.1";
 			headers.set("x-vercel-deployment-url", `http://${host}:${this._address.port}`);

package/dist/_chunks/virtual-loader.mjs

@@ -1,71 +1,345 @@
-import { pathToFileURL } from "node:url";
+import { Buffer } from "node:buffer";
+import { isAbsolute } from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+const VIRTUAL_MODULE_FORMATS = /* @__PURE__ */ new Set([
+	"module",
+	"commonjs",
+	"module-typescript",
+	"commonjs-typescript",
+	"jsx",
+	"tsx",
+	"json",
+	"text",
+	"bytes",
+	"wasm"
+]);
+const EXTENSION_FORMATS = {
+	".cjs": "commonjs",
+	".json": "json",
+	".ts": "module-typescript",
+	".mts": "module-typescript",
+	".cts": "commonjs-typescript",
+	".jsx": "jsx",
+	".tsx": "tsx",
+	".wasm": "wasm"
+};
+function virtualModuleFormat(key, module) {
+	return typeof module === "object" ? module.format : _extensionFormat(key) ?? "module";
+}
+function virtualModuleCodeSource(key, module) {
+	if (module === void 0) return;
+	const format = virtualModuleFormat(key, module);
+	if (format === "json" || format === "text" || _isBinaryFormat(format)) return;
+	return typeof module === "string" ? module : module.source;
+}
+function normalizeVirtualModule(key, content) {
+	const module = typeof content === "string" || content instanceof Uint8Array ? { source: content } : content;
+	const source = module?.source;
+	if (typeof source !== "string" && !(source instanceof Uint8Array)) throw new TypeError(`[env-runner] virtual module "${key}" must be a string, a Uint8Array or { source, format }.`);
+	const binary = typeof source !== "string";
+	const format = module.format ?? _extensionFormat(key) ?? (binary ? "bytes" : "module");
+	if (!VIRTUAL_MODULE_FORMATS.has(format)) throw new TypeError(`[env-runner] virtual module "${key}" has an unknown format "${format}" (expected one of: ${[...VIRTUAL_MODULE_FORMATS].join(", ")}).`);
+	if (binary !== _isBinaryFormat(format)) throw new TypeError(`[env-runner] virtual module "${key}" has format "${format}", which needs ${binary ? "a string" : "a Uint8Array"} source.`);
+	if (format === "wasm" && !WebAssembly.validate(source)) throw new TypeError(`[env-runner] virtual module "${key}" is not a valid WebAssembly binary.`);
+	if (typeof content === "string") return content;
+	return {
+		source: binary ? new Uint8Array(source) : source,
+		format
+	};
+}
+function normalizeVirtualModules(virtual) {
+	const out = {};
+	for (const [key, content] of Object.entries(virtual)) out[key] = normalizeVirtualModule(key, content);
+	return out;
+}
 async function resolveVirtualModules(virtual) {
-	const entries = await Promise.all(Object.entries(virtual).map(async ([key, value]) => [key, typeof value === "function" ? await value() : value]));
+	const entries = await Promise.all(Object.entries(virtual).map(async ([key, value]) => {
+		return [key, normalizeVirtualModule(key, typeof value === "function" ? await value() : value)];
+	}));
 	return Object.fromEntries(entries);
 }
+function encodeVirtualModules(virtual) {
+	const out = {};
+	for (const [key, module] of Object.entries(virtual)) out[key] = module !== null && typeof module === "object" && typeof module.source !== "string" ? {
+		source: _toBase64(module.source),
+		format: module.format,
+		encoding: "base64"
+	} : module;
+	return out;
+}
+function decodeVirtualModules(virtual) {
+	const out = {};
+	for (const [key, module] of Object.entries(virtual)) out[key] = module !== null && typeof module === "object" && "encoding" in module ? {
+		source: new Uint8Array(Buffer.from(module.source, "base64")),
+		format: module.format
+	} : module;
+	return out;
+}
+function virtualModuleCode(format, source) {
+	if (format === "text") return `export default ${JSON.stringify(source)};\n`;
+	const bytes = [
+		`const base64 = ${JSON.stringify(_toBase64(source))};`,
+		`let bytes;`,
+		`if (typeof Uint8Array.fromBase64 === "function") {`,
+		`  bytes = Uint8Array.fromBase64(base64);`,
+		`} else {`,
+		`  const binary = atob(base64);`,
+		`  bytes = new Uint8Array(binary.length);`,
+		`  for (let i = 0; i < binary.length; i++) bytes[i] = binary.charCodeAt(i);`,
+		`}`
+	];
+	const value = format === "wasm" ? "new WebAssembly.Module(bytes)" : "bytes";
+	return `${bytes.join("\n")}\nexport default ${value};\n`;
+}
+function unsupportedVirtualJSXError(key, format, runtime) {
+	return /* @__PURE__ */ new TypeError(`[env-runner] virtual module "${key}" has format "${format}", which ${runtime} can't load from memory; pre-transpile it to JavaScript (and pass { source, format: "module" } to keep the key).`);
+}
 const VIRTUAL_SCHEME = "virtual:";
-function createVirtualHooks(virtual, versions, parentURL = _defaultParentURL(), forcePlainModule = false) {
+function createVirtualHooks(virtual, opts = {}) {
+	const { versions, importers, forcePlainModule } = opts;
+	const baseURL = opts.baseURL ?? _defaultBaseURL();
+	const keyURLs = /* @__PURE__ */ new Map();
+	const urlKeys = /* @__PURE__ */ new Map();
+	for (const key of Object.keys(virtual)) {
+		const url = _virtualKeyURL(key);
+		if (url) {
+			keyURLs.set(key, url);
+			urlKeys.set(url, key);
+		}
+	}
+	const keyOf = (url) => {
+		if (url.startsWith(VIRTUAL_SCHEME)) {
+			const key = _virtualURLKey(url);
+			return key !== void 0 && Object.hasOwn(virtual, key) ? key : void 0;
+		}
+		return urlKeys.size > 0 && url.startsWith("file:") ? urlKeys.get(_bareURL(url)) : void 0;
+	};
+	const moduleFiles = importers && /* @__PURE__ */ new Set();
+	const track = (node, context) => {
+		const { parentURL } = context;
+		if (!importers || !parentURL) return;
+		let importer = keyOf(parentURL);
+		if (importer === void 0 && !context.conditions?.includes("require")) {
+			const file = _bareURL(parentURL);
+			importer = moduleFiles.has(file) ? file : void 0;
+		}
+		if (importer !== void 0 && importer !== node) {
+			let set = importers.get(node);
+			if (!set) importers.set(node, set = /* @__PURE__ */ new Set());
+			set.add(importer);
+		}
+	};
+	const serve = (key, url, context) => {
+		track(key, context);
+		if (opts.opaquePathURL && keyURLs.has(key) && opts.opaquePathURL(keyURLs.get(key))) url = _virtualURL(key) + url.slice(_bareURL(url).length);
+		const version = versions?.get(key);
+		return {
+			url: version ? _appendQuery(url, `v=${version}`) : url,
+			shortCircuit: true
+		};
+	};
 	const resolve = (specifier, context, nextResolve) => {
 		const key = _stripQuery(specifier);
 		if (Object.hasOwn(virtual, key)) {
-			const version = versions?.get(key);
-			return {
-				url: VIRTUAL_SCHEME + encodeURIComponent(specifier) + (version ? `?v=${version}` : ""),
-				shortCircuit: true
-			};
+			const keyURL = keyURLs.get(key);
+			const url = keyURL ? keyURL + specifier.slice(key.length) : _virtualURL(specifier);
+			return serve(key, url, context);
+		}
+		let parentURL = context.parentURL;
+		if (parentURL?.startsWith(VIRTUAL_SCHEME)) {
+			const parentKey = keyOf(parentURL);
+			parentURL = parentKey !== void 0 && keyURLs.get(parentKey) || baseURL;
 		}
-		if (context.parentURL?.startsWith(VIRTUAL_SCHEME)) return nextResolve(specifier, {
+		if (urlKeys.size > 0) {
+			const url = _resolvePathSpecifier(specifier, parentURL);
+			const pathKey = url && urlKeys.get(_bareURL(url));
+			if (pathKey) return serve(pathKey, url, context);
+		}
+		const result = nextResolve(specifier, parentURL === context.parentURL ? context : {
 			...context,
 			parentURL
 		});
-		return nextResolve(specifier, context);
+		const resolvedKey = urlKeys.size > 0 ? urlKeys.get(_bareURL(result.url)) : void 0;
+		if (resolvedKey) return serve(resolvedKey, result.url, context);
+		if (result.url.startsWith("file:")) {
+			const file = _bareURL(result.url);
+			track(file, context);
+			const version = versions?.get(file);
+			if (version) return {
+				...result,
+				url: _appendQuery(result.url, `v=${version}`)
+			};
+		}
+		return result;
 	};
 	const load = (url, context, nextLoad) => {
-		if (url.startsWith(VIRTUAL_SCHEME)) {
-			const key = _stripQuery(decodeURIComponent(url.slice(8)));
-			if (Object.hasOwn(virtual, key)) return {
-				format: forcePlainModule ? "module" : virtualModuleFormat(key),
-				source: virtual[key],
+		const key = keyOf(url);
+		if (key !== void 0) {
+			const module = virtual[key];
+			if (forcePlainModule) return {
+				format: "module",
+				source: module,
+				shortCircuit: true
+			};
+			return {
+				..._nodeLoadResult(key, module),
 				shortCircuit: true
 			};
 		}
-		return nextLoad(url, context);
+		const result = nextLoad(url, context);
+		if (moduleFiles && url.startsWith("file:") && _isModuleFormat(result.format)) moduleFiles.add(_bareURL(url));
+		return result;
+	};
+	const updateKeys = (keys) => {
+		for (const key of keys) {
+			const url = keyURLs.get(key) ?? _virtualKeyURL(key);
+			if (!url) continue;
+			if (Object.hasOwn(virtual, key)) {
+				keyURLs.set(key, url);
+				urlKeys.set(url, key);
+				continue;
+			}
+			keyURLs.delete(key);
+			if (urlKeys.get(url) === key) {
+				urlKeys.delete(url);
+				for (const [other, otherURL] of keyURLs) if (otherURL === url) urlKeys.set(url, other);
+			}
+		}
 	};
 	return {
 		resolve,
-		load
+		load,
+		updateKeys
 	};
 }
-function virtualModuleFormat(specifier) {
-	if (specifier.endsWith(".json")) return "json";
-	if (specifier.endsWith(".ts") || specifier.endsWith(".mts")) return "module-typescript";
-	return "module";
+function _nodeLoadResult(key, module) {
+	const format = virtualModuleFormat(key, module);
+	const source = typeof module === "string" ? module : module.source;
+	if (format === "text" || format === "bytes" || format === "wasm") return {
+		format: "module",
+		source: virtualModuleCode(format, source)
+	};
+	if (format === "jsx" || format === "tsx") throw unsupportedVirtualJSXError(key, format, "Node.js");
+	return {
+		format,
+		source
+	};
 }
 function stripVirtualTypeScript(specifier, source, stripTypeScriptTypes, hints) {
 	if (typeof stripTypeScriptTypes !== "function") throw new TypeError(`[env-runner] virtual TypeScript module "${specifier}" requires \`module.stripTypeScriptTypes\` ${hints.requirement}; ${hints.remedy} or provide a pre-transpiled JavaScript source instead.`);
-	return stripTypeScriptTypes(source);
+	try {
+		return stripTypeScriptTypes(source);
+	} catch (error) {
+		throw new SyntaxError(`[env-runner] failed to strip types from virtual module "${specifier}": ${error?.message || error}`, { cause: error });
+	}
 }
-function expandVirtualInvalidation(virtual, specifier) {
-	const invalidated = [specifier];
+function expandVirtualInvalidation(virtual, specifier, importers) {
+	const invalidated = [...new Set(typeof specifier === "string" ? [specifier] : specifier)];
 	const seen = new Set(invalidated);
+	const add = (key) => {
+		if (!seen.has(key)) {
+			seen.add(key);
+			invalidated.push(key);
+		}
+	};
 	for (const target of invalidated) {
+		for (const key of importers?.get(target) ?? []) add(key);
+		if (!Object.hasOwn(virtual, target)) continue;
 		const refs = [
 			`"${target}"`,
 			`'${target}'`,
 			"`" + target + "`"
 		];
-		for (const [key, source] of Object.entries(virtual)) if (!seen.has(key) && refs.some((ref) => source.includes(ref))) {
-			seen.add(key);
-			invalidated.push(key);
+		for (const [key, module] of Object.entries(virtual)) {
+			const code = virtualModuleCodeSource(key, module);
+			if (code !== void 0 && refs.some((ref) => code.includes(ref))) add(key);
 		}
 	}
 	return invalidated;
 }
+function findVirtualPathKey(virtual, specifier) {
+	const url = _virtualKeyURL(_stripQuery(specifier));
+	if (!url) return;
+	let match;
+	for (const key of Object.keys(virtual)) if (_virtualKeyURL(key) === url) match = key;
+	return match;
+}
+const _warnedPathCollisions = /* @__PURE__ */ new Set();
+function warnVirtualPathCollisions(keys) {
+	try {
+		const urlKeys = /* @__PURE__ */ new Map();
+		for (const key of keys) {
+			const url = _virtualKeyURL(key);
+			if (!url) continue;
+			const other = urlKeys.get(url);
+			if (other !== void 0 && !_warnedPathCollisions.has(`${other}\0${key}`)) {
+				_warnedPathCollisions.add(`${other}\0${key}`);
+				console.warn(`[env-runner] virtual modules "${other}" and "${key}" name the same file; keep only one of them (which one is served depends on the runtime).`);
+			}
+			urlKeys.set(url, key);
+		}
+	} catch {}
+}
+const virtualKeyURL = _virtualKeyURL;
+function virtualModuleCacheId(key) {
+	const url = _virtualKeyURL(key);
+	return url ? fileURLToPath(url) : _virtualURL(key);
+}
+function _virtualKeyURL(key) {
+	if (key.startsWith("file:")) try {
+		return _bareURL(new URL(key).href);
+	} catch {
+		return;
+	}
+	return isAbsolute(key) ? pathToFileURL(key).href : void 0;
+}
+function _virtualURL(specifier) {
+	return VIRTUAL_SCHEME + specifier.replace(/[\0-\x20"%<>`\x7F-\u{10FFFF}]/gu, encodeURIComponent);
+}
+function _virtualURLKey(url) {
+	try {
+		return decodeURIComponent(_stripQuery(url.slice(8)));
+	} catch {
+		return;
+	}
+}
+function _extensionFormat(key) {
+	const extension = /\.[^./\\]+$/.exec(key)?.[0];
+	return extension === void 0 ? void 0 : EXTENSION_FORMATS[extension];
+}
+function _isBinaryFormat(format) {
+	return format === "bytes" || format === "wasm";
+}
+function _toBase64(bytes) {
+	return Buffer.from(bytes.buffer, bytes.byteOffset, bytes.byteLength).toString("base64");
+}
+function _isModuleFormat(format) {
+	return format == null || format === "module" || format === "module-typescript";
+}
 function _stripQuery(specifier) {
 	const qIndex = specifier.indexOf("?");
 	return qIndex === -1 ? specifier : specifier.slice(0, qIndex);
 }
-function _defaultParentURL() {
+function _bareURL(url) {
+	const index = url.search(/[?#]/);
+	return index === -1 ? url : url.slice(0, index);
+}
+function _appendQuery(url, param) {
+	const hashIndex = url.startsWith(VIRTUAL_SCHEME) ? -1 : url.indexOf("#");
+	const base = hashIndex === -1 ? url : url.slice(0, hashIndex);
+	const hash = hashIndex === -1 ? "" : url.slice(hashIndex);
+	return base + (base.includes("?") ? "&" : "?") + param + hash;
+}
+function _resolvePathSpecifier(specifier, parentURL) {
+	try {
+		if (/^\.{0,2}\//.test(specifier) || specifier.startsWith("file:")) return new URL(specifier, parentURL).href;
+		if (isAbsolute(specifier)) {
+			const path = _stripQuery(specifier);
+			return pathToFileURL(path).href + specifier.slice(path.length);
+		}
+	} catch {}
+}
+function _defaultBaseURL() {
 	return pathToFileURL(process.cwd() + "/").href;
 }
-export { createVirtualHooks, expandVirtualInvalidation, resolveVirtualModules, stripVirtualTypeScript, virtualModuleFormat };
+export { createVirtualHooks, decodeVirtualModules, encodeVirtualModules, expandVirtualInvalidation, findVirtualPathKey, normalizeVirtualModules, resolveVirtualModules, stripVirtualTypeScript, unsupportedVirtualJSXError, virtualKeyURL, virtualModuleCacheId, virtualModuleCode, virtualModuleCodeSource, virtualModuleFormat, warnVirtualPathCollisions };

package/dist/cli.mjs

@@ -1,7 +1,7 @@
 import { EnvServer } from "./_chunks/server.mjs";
 import { resolve } from "node:path";
-import { serve } from "srvx";
 import { parseArgs } from "node:util";
+import { serve } from "srvx";
 const { values, positionals } = parseArgs({
 	allowPositionals: true,
 	options: {