srvx 0.10.1 → 0.11.0

package/dist/cli.mjs

@@ -1,170 +1,63 @@
-import { a as green, c as url, i as gray, l as yellow, n as bold, o as magenta, r as cyan, s as red } from "./_chunks/_color.mjs";
+import { a as green, c as yellow, i as gray, n as bold, o as red, r as cyan, s as url } from "./_chunks/_utils.mjs";
+import { r as loadServerEntry } from "./_chunks/loader.mjs";
 import { parseArgs } from "node:util";
-import { fileURLToPath, pathToFileURL } from "node:url";
-import * as nodeHTTP$1 from "node:http";
-import { dirname, extname, relative, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
 import { fork } from "node:child_process";
-import { existsSync } from "node:fs";
-
-//#region src/cli.ts
-const defaultEntries = [
-	"server",
-	"index",
-	"src/server",
-	"src/index",
-	"server/index"
-];
-const defaultExts = [
-	".mts",
-	".ts",
-	".cts",
-	".js",
-	".mjs",
-	".cjs",
-	".jsx",
-	".tsx"
-];
-const args = process.argv.slice(2);
-const options = parseArgs$1(args);
-if (process.send) {
-	setupProcessErrorHandlers();
-	await serve();
-}
-async function main(mainOpts) {
-	setupProcessErrorHandlers();
-	if (options._version) {
-		console.log(await version());
-		process.exit(0);
-	}
-	if (options._help) {
-		console.log(usage(mainOpts));
-		process.exit(options._help ? 0 : 1);
-	}
-	const isBun = !!process.versions.bun;
-	const isDeno = !!process.versions.deno;
-	const isNode = !isBun && !isDeno;
-	const runtimeArgs = [];
-	if (!options._prod) runtimeArgs.push("--watch");
-	if (isNode || isDeno) runtimeArgs.push(...[".env", options._prod ? ".env.production" : ".env.local"].filter((f) => existsSync(f)).map((f) => `--env-file=${f}`));
-	if (isNode) {
-		const [major, minor] = process.versions.node.split(".");
-		if (major === "22" && +minor >= 6) runtimeArgs.push("--experimental-strip-types");
-		if (options._import) runtimeArgs.push(`--import=${options._import}`);
-	}
-	const child = fork(fileURLToPath(import.meta.url), args, { execArgv: [...process.execArgv, ...runtimeArgs].filter(Boolean) });
-	child.on("error", (error) => {
-		console.error("Error in child process:", error);
-		process.exit(1);
-	});
-	child.on("exit", (code) => {
-		if (code !== 0) {
-			console.error(`Child process exited with code ${code}`);
-			process.exit(code);
-		}
-	});
-	let cleanupCalled = false;
-	const cleanup = (signal, exitCode) => {
-		if (cleanupCalled) return;
-		cleanupCalled = true;
-		try {
-			child.kill(signal || "SIGTERM");
-		} catch (error) {
-			console.error("Error killing child process:", error);
-		}
-		if (exitCode !== void 0) process.exit(exitCode);
-	};
-	process.on("exit", () => cleanup("SIGTERM"));
-	process.on("SIGINT", () => cleanup("SIGINT", 130));
-	process.on("SIGTERM", () => cleanup("SIGTERM", 143));
-}
-async function serve() {
+import { createReadStream, existsSync, statSync } from "node:fs";
+import { dirname, relative, resolve } from "node:path";
+import { Readable } from "node:stream";
+var version = "0.11.0";
+const NO_ENTRY_ERROR = "No server entry or public directory found";
+async function cliServe(cliOpts) {
 	try {
-		if (!process.env.NODE_ENV) process.env.NODE_ENV = options._prod ? "production" : "development";
-		const entry = await loadEntry(options);
-		const { serve: srvxServe } = entry._legacyNode ? await import("srvx/node") : await import("srvx");
+		if (!process.env.NODE_ENV) process.env.NODE_ENV = cliOpts.prod ? "production" : "development";
+		const loaded = await loadServerEntry({
+			entry: cliOpts.entry,
+			dir: cliOpts.dir
+		});
+		const { serve: srvxServe } = loaded.nodeCompat ? await import("srvx/node") : await import("srvx");
 		const { serveStatic } = await import("srvx/static");
 		const { log } = await import("srvx/log");
-		const staticDir = resolve(options._dir, options._static);
-		options._static = existsSync(staticDir) ? staticDir : "";
-		const server = srvxServe({
+		const staticDir = resolve(cliOpts.dir || (loaded.url ? dirname(fileURLToPath(loaded.url)) : "."), cliOpts.static || "public");
+		cliOpts.static = existsSync(staticDir) ? staticDir : "";
+		if (loaded.notFound && !cliOpts.static) {
+			process.send?.({ error: "no-entry" });
+			throw new Error(NO_ENTRY_ERROR, { cause: cliOpts });
+		}
+		const serverOptions = {
+			...loaded.module?.default,
+			default: void 0,
+			...loaded.module
+		};
+		printInfo(cliOpts, loaded);
+		await (globalThis.__srvx__ = srvxServe({
+			...serverOptions,
+			gracefulShutdown: cliOpts.prod,
+			port: cliOpts.port ?? serverOptions.port,
+			hostname: cliOpts.hostname ?? cliOpts.host ?? serverOptions.hostname,
+			tls: cliOpts.tls ? {
+				cert: cliOpts.cert,
+				key: cliOpts.key
+			} : void 0,
 			error: (error) => {
 				console.error(error);
-				return renderError(error);
+				return renderError(cliOpts, error);
 			},
-			...entry,
+			fetch: loaded.fetch || (() => renderError(cliOpts, loaded.notFound ? "Server Entry Not Found" : "No Fetch Handler Exported", 501)),
 			middleware: [
 				log(),
-				options._static ? serveStatic({ dir: options._static }) : void 0,
-				...entry.middleware || []
+				cliOpts.static ? serveStatic({ dir: cliOpts.static }) : void 0,
+				...serverOptions.middleware || []
 			].filter(Boolean)
-		});
-		globalThis.__srvx__ = server;
-		await server.ready();
-		await globalThis.__srvx_listen_cb__?.();
-		printInfo(entry);
+		})).ready();
 	} catch (error) {
 		console.error(error);
 		process.exit(1);
 	}
 }
-async function loadEntry(opts) {
-	try {
-		if (!opts._entry) for (const entry of defaultEntries) {
-			for (const ext of defaultExts) {
-				const entryPath = resolve(opts._dir, `${entry}${ext}`);
-				if (existsSync(entryPath)) {
-					opts._entry = entryPath;
-					break;
-				}
-			}
-			if (opts._entry) break;
-		}
-		if (!opts._entry) {
-			const _error$1 = `No server entry file found.\nPlease specify an entry file or ensure one of the default entries exists (${defaultEntries.join(", ")}).`;
-			return {
-				_error: _error$1,
-				fetch: () => renderError(_error$1, 404, "No Server Entry"),
-				...opts
-			};
-		}
-		const entryURL = opts._entry.startsWith("file://") ? opts._entry : pathToFileURL(resolve(opts._entry)).href;
-		const { res: mod, listenHandler } = await interceptListen(() => import(entryURL));
-		let fetchHandler = mod.fetch || mod.default?.fetch || mod.default?.default?.fetch;
-		let _legacyNode = false;
-		if (!fetchHandler) {
-			const nodeHandler = listenHandler || (typeof mod.default === "function" ? mod.default : void 0);
-			if (nodeHandler) {
-				_legacyNode = true;
-				const { callNodeHandler } = await import("./_chunks/call2.mjs");
-				fetchHandler = (webReq) => callNodeHandler(nodeHandler, webReq);
-			}
-		}
-		let _error;
-		if (!fetchHandler) {
-			_error = `The entry file "${relative(".", opts._entry)}" does not export a valid fetch handler.`;
-			fetchHandler = () => renderError(_error, 500, "Invalid Entry");
-		}
-		return {
-			...mod,
-			...mod.default,
-			...opts,
-			_error,
-			_legacyNode,
-			fetch: fetchHandler
-		};
-	} catch (error) {
-		if (error?.code === "ERR_UNKNOWN_FILE_EXTENSION") {
-			const message = String(error);
-			if (/"\.(m|c)?ts"/g.test(message)) console.error(red(`\nMake sure you're using Node.js v22.18+ or v24+ for TypeScript support (current version: ${process.versions.node})\n\n`));
-			else if (/"\.(m|c)?tsx"/g.test(message)) console.error(red(`\nYou need a compatible loader for JSX support (Deno, Bun or srvx --register jiti/register)\n\n`));
-		}
-		if (error instanceof Error) Error.captureStackTrace?.(error, serve);
-		throw error;
-	}
-}
-function renderError(error, status = 500, title = "Server Error") {
+function renderError(cliOpts, error, status = 500, title = "Server Error") {
 	let html = `<!DOCTYPE html><html><head><title>${title}</title></head><body>`;
-	if (options._prod) html += `<h1>${title}</h1><p>Something went wrong while processing your request.</p>`;
+	if (cliOpts.prod) html += `<h1>${title}</h1><p>Something went wrong while processing your request.</p>`;
 	else html += `
     <style>
       body { font-family: Arial, sans-serif; margin: 0; padding: 20px; background: #f8f9fa; color: #333; }
@@ -180,139 +73,141 @@ function renderError(error, status = 500, title = "Server Error") {
 		headers: { "Content-Type": "text/html; charset=utf-8" }
 	});
 }
-function printInfo(entry) {
+function printInfo(cliOpts, loaded) {
 	let entryInfo;
-	if (options._entry) entryInfo = cyan("./" + relative(".", options._entry));
-	else entryInfo = gray(`(create ${bold(`server.ts`)} to enable)`);
-	console.log(gray(`${bold(gray("λ"))} Server handler: ${entryInfo}`));
-	if (options._entry && entry._error) console.error(red(`  ${entry._error}`));
+	if (loaded.notFound) entryInfo = gray(`(create ${bold(`server.ts`)})`);
+	else entryInfo = loaded.fetch ? cyan("./" + relative(".", fileURLToPath(loaded.url))) : red(`No fetch handler exported from ${loaded.url}`);
+	console.log(gray(`${bold(gray("◆"))} Server handler: ${entryInfo}`));
 	let staticInfo;
-	if (options._static) staticInfo = cyan("./" + relative(".", options._static) + "/");
-	else staticInfo = gray(`(add ${bold("public/")} dir to enable)`);
-	console.log(gray(`${bold(gray("∘"))} Static files:   ${staticInfo}`));
+	if (cliOpts.static) staticInfo = cyan("./" + relative(".", cliOpts.static) + "/");
+	else staticInfo = gray(`(create ${bold("public/")} dir)`);
+	console.log(gray(`${bold(gray("◇"))} Static files:   ${staticInfo}`));
+	console.log("");
 }
-async function interceptListen(cb) {
-	const originalListen = nodeHTTP$1.Server.prototype.listen;
-	let res;
-	let listenHandler;
-	try {
-		nodeHTTP$1.Server.prototype.listen = function(arg1, arg2) {
-			listenHandler = this._events.request;
-			if (Array.isArray(listenHandler)) listenHandler = listenHandler[0];
-			nodeHTTP$1.Server.prototype.listen = originalListen;
-			globalThis.__srvx_listen_cb__ = [arg1, arg2].find((arg) => typeof arg === "function");
-			return new Proxy({}, { get(_, prop) {
-				return globalThis.__srvx__?.node?.server?.[prop];
-			} });
-		};
-		res = await cb();
-	} finally {
-		nodeHTTP$1.Server.prototype.listen = originalListen;
+async function cliFetch(cliOpts) {
+	const stdin = cliOpts.stdin || process.stdin;
+	const stdout = cliOpts.stdout || process.stdout;
+	const stderr = cliOpts.stderr || process.stderr;
+	let fetchHandler = globalThis.fetch;
+	let inputURL = cliOpts.url || "/";
+	if (inputURL[0] === "/") {
+		const loaded = await loadServerEntry({
+			dir: cliOpts.dir,
+			entry: cliOpts.entry,
+			...cliOpts?.loader
+		});
+		if (cliOpts.verbose && loaded.url) {
+			stderr.write(`* Entry: ${fileURLToPath(loaded.url)}\n`);
+			if (loaded.nodeCompat) stderr.write(`* Using node compat mode\n`);
+		}
+		if (loaded.notFound) throw new Error(`Server entry file not found in ${resolve(cliOpts.dir || ".")}`, { cause: {
+			dir: cliOpts.dir || process.cwd(),
+			entry: cliOpts.entry || void 0
+		} });
+		else if (!loaded.fetch) throw new Error("No fetch handler exported", { cause: {
+			dir: cliOpts.dir || process.cwd(),
+			entry: cliOpts.entry || void 0,
+			loaded
+		} });
+		fetchHandler = loaded.fetch;
+	} else {
+		stderr.write(`* Fetching remote URL: ${inputURL}\n`);
+		if (!URL?.canParse(inputURL)) inputURL = `http${cliOpts.tls ? "s" : ""}://${inputURL}`;
+		fetchHandler = globalThis.fetch;
 	}
-	return {
-		res,
-		listenHandler
-	};
-}
-async function version() {
-	return `srvx ${globalThis.__srvx_version__ || "unknown"}\n${runtime()}`;
-}
-function runtime() {
-	if (process.versions.bun) return `bun ${process.versions.bun}`;
-	else if (process.versions.deno) return `deno ${process.versions.deno}`;
-	else return `node ${process.versions.node}`;
-}
-function parseArgs$1(args$1) {
-	const { values, positionals } = parseArgs({
-		args: args$1,
-		allowPositionals: true,
-		options: {
-			help: {
-				type: "boolean",
-				short: "h"
-			},
-			version: {
-				type: "boolean",
-				short: "v"
-			},
-			prod: { type: "boolean" },
-			port: {
-				type: "string",
-				short: "p"
-			},
-			host: {
-				type: "string",
-				short: "H"
-			},
-			static: {
-				type: "string",
-				short: "s"
-			},
-			import: { type: "string" },
-			tls: { type: "boolean" },
-			cert: { type: "string" },
-			key: { type: "string" }
+	const headers = new Headers();
+	if (cliOpts.header) for (const header of cliOpts.header) {
+		const colonIndex = header.indexOf(":");
+		if (colonIndex > 0) {
+			const name = header.slice(0, colonIndex).trim();
+			const value = header.slice(colonIndex + 1).trim();
+			headers.append(name, value);
 		}
+	}
+	if (!headers.has("User-Agent")) headers.set("User-Agent", "srvx (curl)");
+	if (!headers.has("Accept")) headers.set("Accept", "text/markdown, application/json;q=0.9, text/plain;q=0.8, text/html;q=0.7, text/*;q=0.6, */*;q=0.5");
+	let body;
+	if (cliOpts.data !== void 0) if (cliOpts.data === "@-") body = new ReadableStream({ async start(controller) {
+		for await (const chunk of stdin) controller.enqueue(chunk);
+		controller.close();
+	} });
+	else if (cliOpts.data.startsWith("@")) body = Readable.toWeb(createReadStream(cliOpts.data.slice(1)));
+	else body = cliOpts.data;
+	const method = cliOpts.method || (body === void 0 ? "GET" : "POST");
+	const url = new URL(inputURL, `http${cliOpts.tls ? "s" : ""}://${cliOpts.host || cliOpts.hostname || "localhost"}`);
+	const req = new Request(url, {
+		method,
+		headers,
+		body
 	});
-	const input = positionals[0] || ".";
-	let dir;
-	let entry = "";
-	if (extname(input) === "") dir = resolve(input);
-	else {
-		entry = resolve(input);
-		dir = dirname(entry);
+	if (cliOpts.verbose) {
+		const parsedUrl = new URL(url);
+		stderr.write(`> ${method} ${parsedUrl.pathname}${parsedUrl.search} HTTP/1.1\n`);
+		stderr.write(`> Host: ${parsedUrl.host}\n`);
+		for (const [name, value] of headers) stderr.write(`> ${name}: ${value}\n`);
+		stderr.write(">\n");
 	}
-	if (!existsSync(dir)) {
-		console.error(red(`Directory "${dir}" does not exist.\n`));
-		process.exit(1);
+	const res = await fetchHandler(req);
+	if (cliOpts.verbose) {
+		stderr.write(`< HTTP/1.1 ${res.status} ${res.statusText}\n`);
+		for (const [name, value] of res.headers) stderr.write(`< ${name}: ${value}\n`);
+		stderr.write("<\n");
 	}
+	if (res.body) {
+		const { isBinary, encoding } = getResponseFormat(res);
+		if (isBinary) for await (const chunk of res.body) stdout.write(chunk);
+		else {
+			const decoder = new TextDecoder(encoding);
+			for await (const chunk of res.body) stdout.write(decoder.decode(chunk, { stream: true }));
+			const remaining = decoder.decode();
+			if (remaining) stdout.write(remaining);
+			if (stdout.isTTY) stdout.write("\n");
+		}
+	}
+	return res;
+}
+function getResponseFormat(res) {
+	const contentType = res.headers.get("content-type") || "";
 	return {
-		_dir: dir,
-		_entry: entry,
-		_prod: values.prod ?? process.env.NODE_ENV === "production",
-		_help: values.help,
-		_static: values.static || "public",
-		_version: values.version,
-		_import: values.import,
-		port: values.port ? Number.parseInt(values.port, 10) : void 0,
-		hostname: values.host,
-		tls: values.tls ? {
-			cert: values.cert,
-			key: values.key
-		} : void 0
+		isBinary: contentType.startsWith("application/octet-stream") || contentType.startsWith("image/") || contentType.startsWith("audio/") || contentType.startsWith("video/") || contentType.startsWith("application/pdf") || contentType.startsWith("application/zip") || contentType.startsWith("application/gzip"),
+		encoding: contentType.includes("charset=") ? contentType.split("charset=")[1].split(";")[0].trim() : "utf8"
 	};
 }
-function example() {
-	const useTs = !options._entry || options._entry.endsWith(".ts");
-	return `${bold(gray("// server.ts"))}
-${magenta("export default")} {
-  ${cyan("fetch")}(req${useTs ? ": Request" : ""}) {
-    ${magenta("return")} new Response(${green("\"Hello, World!\"")});
-  }
-}`;
-}
 function usage(mainOpts) {
-	const command = mainOpts.command;
+	const command = mainOpts.usage?.command || "srvx";
 	return `
-${cyan(command)} - Start an HTTP server with the specified entry path.
+${cyan(command)} - Universal Server CLI
+
+${bold("SERVE MODE")}
 
-${bold("USAGE")}
-${existsSync(options._entry) ? "" : `\n${example()}\n`}
-${gray("# srvx [options] [entry]")}
-${gray("$")} ${cyan(command)} ${gray("./server.ts")}            ${gray("# Start development server")}
-${gray("$")} ${cyan(command)} --prod                 ${gray("# Start production  server")}
-${gray("$")} ${cyan(command)} --port=8080            ${gray("# Listen on port 8080")}
-${gray("$")} ${cyan(command)} --host=localhost       ${gray("# Bind to localhost only")}
-${gray("$")} ${cyan(command)} --import=jiti/register ${gray(`# Enable ${url("jiti", "https://github.com/unjs/jiti")} loader`)}
-${gray("$")} ${cyan(command)} --tls --cert=cert.pem --key=key.pem  ${gray("# Enable TLS (HTTPS/HTTP2)")}
+${bold(green(`# ${command} serve [options]`))}
+${gray("$")} ${cyan(command)} serve --entry ${gray("./server.ts")}    ${gray("# Start development server")}
+${gray("$")} ${cyan(command)} serve --prod                 ${gray("# Start production  server")}
+${gray("$")} ${cyan(command)} serve --port=8080            ${gray("# Listen on port 8080")}
+${gray("$")} ${cyan(command)} serve --host=localhost       ${gray("# Bind to localhost only")}
+${gray("$")} ${cyan(command)} serve --import=jiti/register ${gray(`# Enable ${url("jiti", "https://github.com/unjs/jiti")} loader`)}
+${gray("$")} ${cyan(command)} serve --tls --cert=cert.pem --key=key.pem  ${gray("# Enable TLS (HTTPS/HTTP2)")}
 
+${bold("FETCH MODE")}
 
-${bold("ARGUMENTS")}
+${bold(green(`# ${command} fetch|curl [options] [url]`))}
+${gray("$")} ${cyan(command)} fetch                  ${gray("# Fetch from default entry")}
+${gray("$")} ${cyan(command)} fetch /api/users       ${gray("# Fetch a specific URL/path")}
+${gray("$")} ${cyan(command)} fetch --entry ./server.ts /api/users ${gray("# Fetch using a specific entry")}
+${gray("$")} ${cyan(command)} fetch -X POST /api/users ${gray("# POST request")}
+${gray("$")} ${cyan(command)} fetch -H "Content-Type: application/json" /api ${gray("# With headers")}
+${gray("$")} ${cyan(command)} fetch -d '{"name":"foo"}' /api ${gray("# With request body")}
+${gray("$")} ${cyan(command)} fetch -v /api/users    ${gray("# Verbose output (show headers)")}
+${gray("$")} echo '{"name":"foo"}' | ${cyan(command)} fetch -d @- /api ${gray("# Body from stdin")}
 
-  ${yellow("<entry>")}                  Server entry path to serve.
-                           Default: ${defaultEntries.map((e) => cyan(e)).join(", ")} ${gray(`(${defaultExts.join(",")})`)}
+${bold("COMMON OPTIONS")}
 
-${bold("OPTIONS")}
+  ${green("--entry")} ${yellow("<file>")}           Server entry file to use
+  ${green("--dir")} ${yellow("<dir>")}              Working directory for resolving entry file
+  ${green("-h, --help")}               Show this help message
+  ${green("--version")}                Show server and runtime versions
+
+${bold("SERVE OPTIONS")}
 
   ${green("-p, --port")} ${yellow("<port>")}        Port to listen on (default: ${yellow("3000")})
   ${green("--host")} ${yellow("<host>")}            Host to bind to (default: all interfaces)
@@ -322,8 +217,13 @@ ${bold("OPTIONS")}
   ${green("--tls")}                    Enable TLS (HTTPS/HTTP2)
   ${green("--cert")} ${yellow("<file>")}            TLS certificate file
   ${green("--key")}  ${yellow("<file>")}            TLS private key file
-  ${green("-h, --help")}               Show this help message
-  ${green("-v, --version")}            Show server and runtime versions
+
+${bold("FETCH OPTIONS")}
+
+  ${green("-X, --request")} ${yellow("<method>")}   HTTP method (default: ${yellow("GET")}, or ${yellow("POST")} if body is provided)
+  ${green("-H, --header")} ${yellow("<header>")}    Add header (format: "Name: Value", can be used multiple times)
+  ${green("-d, --data")} ${yellow("<data>")}        Request body (use ${yellow("@-")} for stdin, ${yellow("@file")} for file)
+  ${green("-v, --verbose")}            Show request and response headers
 
 ${bold("ENVIRONMENT")}
 
@@ -331,10 +231,158 @@ ${bold("ENVIRONMENT")}
   ${green("HOST")}                     Override host
   ${green("NODE_ENV")}                 Set to ${yellow("production")} for production mode.
 
-➤ ${url("Documentation", mainOpts.docs || "https://srvx.h3.dev")}
-➤ ${url("Report issues", mainOpts.issues || "https://github.com/h3js/srvx/issues")}
+${mainOpts.usage?.docs ? `➤ ${url("Documentation", mainOpts.usage.docs)}` : ""}
+${mainOpts.usage?.issues ? `➤ ${url("Report issues", mainOpts.usage.issues)}` : ""}
 `.trim();
 }
+async function main(mainOpts) {
+	const args = process.argv.slice(2);
+	const cliOpts = parseArgs$1(args);
+	if (cliOpts.version) {
+		console.log(`srvx ${version}\n${runtime()}`);
+		process.exit(0);
+	}
+	if (cliOpts.help) {
+		console.log(usage(mainOpts));
+		process.exit(cliOpts.help ? 0 : 1);
+	}
+	if (process.send) {
+		console.log(gray(`srvx ${version} - ${runtime()}`));
+		setupProcessErrorHandlers();
+		await cliServe(cliOpts);
+		return;
+	}
+	if (cliOpts.mode === "fetch") try {
+		const res = await cliFetch(cliOpts);
+		process.exit(res.ok ? 0 : 22);
+	} catch (error) {
+		console.error(error);
+		process.exit(1);
+	}
+	const isBun = !!process.versions.bun;
+	const isDeno = !!process.versions.deno;
+	const isNode = !isBun && !isDeno;
+	const runtimeArgs = [];
+	if (!cliOpts.prod) runtimeArgs.push("--watch");
+	if (isNode || isDeno) runtimeArgs.push(...[".env", cliOpts.prod ? ".env.production" : ".env.local"].filter((f) => existsSync(f)).map((f) => `--env-file=${f}`));
+	if (isNode) {
+		const [major, minor] = process.versions.node.split(".");
+		if (major === "22" && +minor >= 6) runtimeArgs.push("--experimental-strip-types");
+		if (cliOpts.import) runtimeArgs.push(`--import=${cliOpts.import}`);
+	}
+	const child = fork(fileURLToPath(new URL("../bin/srvx.mjs", import.meta.url)), args, { execArgv: [...process.execArgv, ...runtimeArgs].filter(Boolean) });
+	child.on("error", (error) => {
+		console.error("Error in child process:", error);
+		process.exit(1);
+	});
+	child.on("exit", (code) => {
+		if (code !== 0) {
+			console.error(`Child process exited with code ${code}`);
+			process.exit(code);
+		}
+	});
+	child.on("message", (msg) => {
+		if (msg && msg.error === "no-entry") {
+			console.error("\n" + red(NO_ENTRY_ERROR) + "\n");
+			process.exit(3);
+		}
+	});
+	let cleanupCalled = false;
+	const cleanup = (signal, exitCode) => {
+		if (cleanupCalled) return;
+		cleanupCalled = true;
+		try {
+			child.kill(signal || "SIGTERM");
+		} catch (error) {
+			console.error("Error killing child process:", error);
+		}
+		if (exitCode !== void 0) process.exit(exitCode);
+	};
+	process.on("exit", () => cleanup("SIGTERM"));
+	process.on("SIGINT", () => cleanup("SIGINT", 130));
+	process.on("SIGTERM", () => cleanup("SIGTERM", 143));
+}
+function parseArgs$1(args) {
+	const pArg0 = args.find((a) => !a.startsWith("-"));
+	const mode = pArg0 === "fetch" || pArg0 === "curl" ? "fetch" : "serve";
+	const commonArgs = {
+		help: { type: "boolean" },
+		version: { type: "boolean" },
+		dir: { type: "string" },
+		entry: { type: "string" },
+		host: { type: "string" },
+		hostname: { type: "string" },
+		tls: { type: "boolean" }
+	};
+	if (mode === "serve") {
+		const { values, positionals } = parseArgs({
+			args,
+			allowPositionals: true,
+			options: {
+				...commonArgs,
+				url: { type: "string" },
+				prod: { type: "boolean" },
+				port: {
+					type: "string",
+					short: "p"
+				},
+				static: {
+					type: "string",
+					short: "s"
+				},
+				import: { type: "string" },
+				cert: { type: "string" },
+				key: { type: "string" }
+			}
+		});
+		if (positionals[0] === "serve") positionals.shift();
+		const maybeEntryOrDir = positionals[0];
+		if (maybeEntryOrDir) {
+			if (values.entry || values.dir) throw new Error("Cannot specify entry or dir as positional argument when --entry or --dir is used!");
+			if (statSync(maybeEntryOrDir).isDirectory()) values.dir = maybeEntryOrDir;
+			else values.entry = maybeEntryOrDir;
+		}
+		return {
+			mode,
+			...values
+		};
+	}
+	const { values, positionals } = parseArgs({
+		args,
+		allowPositionals: true,
+		options: {
+			...commonArgs,
+			url: { type: "string" },
+			method: {
+				type: "string",
+				short: "X"
+			},
+			request: { type: "string" },
+			header: {
+				type: "string",
+				multiple: true,
+				short: "H"
+			},
+			verbose: {
+				type: "boolean",
+				short: "v"
+			},
+			data: {
+				type: "string",
+				short: "d"
+			}
+		}
+	});
+	if (positionals[0] === "fetch" || positionals[0] === "curl") positionals.shift();
+	const method = values.method || values.request;
+	const url = values.url || positionals[0] || "/";
+	return {
+		mode,
+		...values,
+		url,
+		method
+	};
+}
 function setupProcessErrorHandlers() {
 	process.on("uncaughtException", (error) => {
 		console.error("Uncaught exception:", error);
@@ -345,6 +393,9 @@ function setupProcessErrorHandlers() {
 		process.exit(1);
 	});
 }
-
-//#endregion
-export { main, usage };
+function runtime() {
+	if (process.versions.bun) return `bun ${process.versions.bun}`;
+	else if (process.versions.deno) return `deno ${process.versions.deno}`;
+	else return `node ${process.versions.node}`;
+}
+export { cliFetch, main };

package/dist/loader.d.mts

@@ -0,0 +1,2 @@
+import { a as loadServerEntry, i as defaultExts, n as LoadedServerEntry, r as defaultEntries, t as LoadOptions } from "./_chunks/loader.mjs";
+export { LoadOptions, LoadedServerEntry, defaultEntries, defaultExts, loadServerEntry };

package/dist/loader.mjs

@@ -0,0 +1,2 @@
+import { n as defaultExts, r as loadServerEntry, t as defaultEntries } from "./_chunks/loader.mjs";
+export { defaultEntries, defaultExts, loadServerEntry };

package/dist/log.d.mts

@@ -1,4 +1,4 @@
-import { v as ServerMiddleware } from "./_chunks/types.mjs";
+import { ServerMiddleware } from "./types.mjs";
 
 //#region src/log.d.ts
 interface LogOptions {}