sevok 0.0.2

package/dist/_color-B42q-MpL.mjs

@@ -0,0 +1,34 @@
+//#region src/_color.ts
+const noColor = /* @__PURE__ */ (() => {
+	const p = globalThis.process || {};
+	const argv = p.argv || [];
+	const env = p.env || {};
+	return !(!(!!env.NO_COLOR || argv.includes("--no-color")) && (!!env.FORCE_COLOR || argv.includes("--color") || p.platform === "win32" || (p.stdout || {}).isTTY && env.TERM !== "dumb" || !!env.CI));
+})();
+const w = (c, r = 39) => {
+	return (t) => noColor ? t : `\u001B[${c}m${t}\u001B[${r}m`;
+};
+const bold = /* @__PURE__ */ w(1, 22);
+const red = /* @__PURE__ */ w(31);
+const green = /* @__PURE__ */ w(32);
+const yellow = /* @__PURE__ */ w(33);
+const blue = /* @__PURE__ */ w(34);
+const magenta = /* @__PURE__ */ w(35);
+const cyan = /* @__PURE__ */ w(36);
+const gray = /* @__PURE__ */ w(90);
+const url = (title, url) => {
+	return noColor ? `[${title}](${url})` : `\u001B]8;;${url}\u001B\\${title}\u001B]8;;\u001B\\`;
+};
+var _color_default = {
+	bold,
+	red,
+	green,
+	yellow,
+	blue,
+	magenta,
+	cyan,
+	gray,
+	url
+};
+//#endregion
+export { _color_default as t };

package/dist/_node_like-BRaAGeNM.mjs

@@ -0,0 +1,112 @@
+import { readFileSync } from "node:fs";
+//#region src/_node_like.ts
+/**
+* Normalize TLS options for runtimes that accept PEM strings.
+*
+* Certificate and key values may be supplied inline or as filesystem paths.
+*/
+function resolveTLSOptions(opts) {
+	if (!opts.tls || opts.protocol === "http") return;
+	const cert = resolveCertOrKey(opts.tls.cert);
+	const key = resolveCertOrKey(opts.tls.key);
+	if (!cert && !key) {
+		if (opts.protocol === "https") throw new TypeError("TLS `cert` and `key` must be provided for `https` protocol.");
+		return;
+	}
+	if (!cert || !key) throw new TypeError("TLS `cert` and `key` must be provided together.");
+	return {
+		cert,
+		key,
+		passphrase: opts.tls.passphrase
+	};
+}
+/**
+* Accept either inline PEM content or a path to a PEM file on disk.
+*/
+function resolveCertOrKey(value) {
+	if (!value) return;
+	if (typeof value !== "string") throw new TypeError("TLS certificate and key must be strings in PEM format or file paths.");
+	if (value.startsWith("-----BEGIN ")) return value;
+	return readFileSync(value, "utf8");
+}
+/**
+* Print the listener address unless output is silenced.
+*
+* When the runtime binds to all interfaces, the displayed URL is rewritten to
+* `localhost` so the message remains copy-pastable for local development.
+*/
+function printListening(opts, url) {
+	if (!url || (opts.silent ?? globalThis.process?.env?.TEST)) return;
+	let additionalInfo = "";
+	try {
+		const _url = new URL(url);
+		if (_url.hostname === "[::]" || _url.hostname === "0.0.0.0") {
+			_url.hostname = "localhost";
+			url = _url.href;
+			additionalInfo = " (all interfaces)";
+		}
+	} catch {}
+	let listeningOn = `➜ Listening on:`;
+	if (globalThis.process.stdout?.isTTY) {
+		listeningOn = `\u001B[32m${listeningOn}\u001B[0m`;
+		url = `\u001B[36m${url}\u001B[0m`;
+		additionalInfo = `\u001B[2m${additionalInfo}\u001B[0m`;
+	}
+	console.log(`${listeningOn} ${url}${additionalInfo}`);
+}
+/**
+* Runtime helpers shared by Bun and Node-style adapters.
+*/
+const runtimeCapabilities = {
+	resolve: resolveNodeLikePath,
+	open: openNodeLikePath,
+	createGzip: createNodeLikeGzip,
+	createBrotliCompress: createNodeLikeBrotliCompress
+};
+/**
+* Resolve a candidate path and reject traversal outside the configured root.
+*/
+async function resolveNodeLikePath(root, ...components) {
+	const { resolve, sep } = await import("node:path");
+	const resolvedRoot = resolve(root);
+	const resolvedPath = resolve(resolvedRoot, ...components);
+	return resolvedPath === resolvedRoot || resolvedPath.startsWith(`${resolvedRoot}${sep}`) ? resolvedPath : null;
+}
+/**
+* Open a file lazily and expose it as a Web `ReadableStream`.
+*/
+async function openNodeLikePath(path) {
+	const { stat } = await import("node:fs/promises");
+	const fileStat = await stat(path).catch(() => null);
+	if (!fileStat) return null;
+	const { createReadStream } = await import("node:fs");
+	const { Readable } = await import("node:stream");
+	return {
+		isFile: fileStat.isFile(),
+		size: fileStat.size,
+		stream(start, end) {
+			return Readable.toWeb(createReadStream(path, {
+				start,
+				end: typeof end === "number" ? end - 1 : void 0
+			}));
+		}
+	};
+}
+/**
+* Adapt Node's gzip transform to the Web Streams API used by this package.
+*/
+async function createNodeLikeGzip() {
+	const { createGzip } = await import("node:zlib");
+	const { Duplex } = await import("node:stream");
+	return Duplex.toWeb(createGzip());
+}
+/**
+* Adapt Node's Brotli transform to the Web Streams API used by this package.
+*/
+async function createNodeLikeBrotliCompress() {
+	const { createBrotliCompress } = await import("node:zlib");
+	const { Duplex } = await import("node:stream");
+	return Duplex.toWeb(createBrotliCompress());
+}
+//#endregion
+export { resolveTLSOptions as n, runtimeCapabilities as r, printListening as t };

package/dist/_shared-38k_JIsU.mjs

@@ -0,0 +1,92 @@
+//#region src/_shared.ts
+/**
+* Normalize a pathname to a leading-slash, no-trailing-slash form.
+*/
+function normalizePathname(pathname) {
+	if (pathname.length === 0 || pathname === "/") return "/";
+	let normalized = pathname.startsWith("/") ? pathname : `/${pathname}`;
+	normalized = normalized.replace(/\/+/g, "/");
+	if (normalized.length > 1 && normalized.endsWith("/")) normalized = normalized.slice(0, -1);
+	return normalized;
+}
+/**
+* Split a normalized pathname into path segments.
+*/
+function splitPathname(pathname) {
+	const normalized = normalizePathname(pathname);
+	return normalized === "/" ? [] : normalized.slice(1).split("/");
+}
+/**
+* Escape a string for safe inclusion in a regular expression.
+*/
+function escapeRegExp(value) {
+	return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+/**
+* Compile a route pathname into a matching regular expression.
+*/
+function compilePath(path) {
+	const segments = splitPathname(path);
+	if (segments.length === 0) return /^\/$/;
+	const source = segments.map((segment) => {
+		if (segment === "*") return "(?:/.*)?";
+		if (segment.startsWith(":")) return "/([^/]+)";
+		return `/${escapeRegExp(segment)}`;
+	}).join("");
+	return new RegExp(`^${source}$`);
+}
+/**
+* Extract route parameter names from a path pattern.
+*/
+function extractKeys(path) {
+	return splitPathname(path).filter((segment) => segment.startsWith(":")).map((segment) => segment.slice(1));
+}
+/**
+* Collapse dynamic route segments into a canonical conflict-detection pattern.
+*/
+function canonicalizePath(path) {
+	const segments = splitPathname(path).map((segment) => {
+		if (segment === "*") return "*";
+		if (segment.startsWith(":")) return ":";
+		return segment;
+	});
+	return segments.length === 0 ? "/" : `/${segments.join("/")}`;
+}
+/**
+* Extract named params from a regular-expression route match.
+*/
+function extractParams(keys, match) {
+	const params = {};
+	for (const [index, key] of keys.entries()) {
+		const value = match[index + 1];
+		if (value != null) params[key] = decodeURIComponent(value);
+	}
+	return params;
+}
+/**
+* Resolve the effective listening port and hostname from explicit options or
+* the conventional `PORT` and `HOST` environment variables.
+*/
+function resolvePortAndHost(opts) {
+	const _port = opts.port ?? globalThis.process?.env.PORT ?? 3e3;
+	const port = typeof _port === "number" ? _port : Number.parseInt(_port, 10);
+	if (port < 0 || port > 65535) throw new RangeError(`Port must be between 0 and 65535 (got "${port}").`);
+	return {
+		port,
+		hostname: opts.hostname ?? globalThis.process?.env.HOST
+	};
+}
+/**
+* Format a listener address as a fetch-compatible origin.
+*
+* Returns `undefined` when either host or port is missing, which keeps callers
+* from printing misleading partial URLs before the runtime has finished
+* listening.
+*/
+function fmtURL(host, port, secure) {
+	if (!host || !port) return;
+	if (host.includes(":")) host = `[${host}]`;
+	return `http${secure ? "s" : ""}://${host}:${port}/`;
+}
+//#endregion
+export { fmtURL as a, extractParams as i, compilePath as n, normalizePathname as o, extractKeys as r, resolvePortAndHost as s, canonicalizePath as t };

package/dist/bun.d.mts

@@ -0,0 +1,31 @@
+import { d as RuntimeAdapter, f as RuntimeCapabilities, p as Server } from "./core-BGp2ZR_k.mjs";
+
+//#region src/bun.d.ts
+/**
+ * Runtime adapter that backs `Server` with `Bun.serve()`.
+ */
+declare class BunRuntimeAdapter implements RuntimeAdapter {
+  #private;
+  readonly graceful = true;
+  get capabilities(): RuntimeCapabilities;
+  /**
+   * Merge generic server options with Bun-specific listener options.
+   */
+  setup(server: Server): void;
+  /**
+   * Start Bun's native server once and reuse the same instance for later calls.
+   */
+  serve(server: Server): Promise<{
+    url: string | undefined;
+  }>;
+  /**
+   * Expose Bun's resolved listener URL.
+   */
+  get url(): string | undefined;
+  /**
+   * Stop the active Bun server and clear the cached instance.
+   */
+  close(closeActiveConnections?: boolean): Promise<void>;
+}
+//#endregion
+export { BunRuntimeAdapter };

package/dist/bun.mjs

@@ -0,0 +1,58 @@
+import { n as resolveTLSOptions, r as runtimeCapabilities, t as printListening } from "./_node_like-BRaAGeNM.mjs";
+import { s as resolvePortAndHost } from "./_shared-38k_JIsU.mjs";
+//#region src/bun.ts
+/**
+* Runtime adapter that backs `Server` with `Bun.serve()`.
+*/
+var BunRuntimeAdapter = class {
+	#server;
+	#serveOptions;
+	graceful = true;
+	get capabilities() {
+		return runtimeCapabilities;
+	}
+	/**
+	* Merge generic server options with Bun-specific listener options.
+	*/
+	setup(server) {
+		const { options } = server;
+		const { hostname, port } = resolvePortAndHost(options);
+		const tls = resolveTLSOptions(options);
+		this.#serveOptions = {
+			hostname,
+			port,
+			reusePort: options.reusePort,
+			error: options.error,
+			...options.bun,
+			fetch: (request) => server.fetch(request),
+			tls: {
+				...tls,
+				...options.bun?.tls
+			}
+		};
+	}
+	/**
+	* Start Bun's native server once and reuse the same instance for later calls.
+	*/
+	serve(server) {
+		if (!this.#server) this.#server = Bun.serve(this.#serveOptions);
+		printListening(server.options, this.url);
+		return Promise.resolve({ url: this.url });
+	}
+	/**
+	* Expose Bun's resolved listener URL.
+	*/
+	get url() {
+		return this.#server?.url.href;
+	}
+	/**
+	* Stop the active Bun server and clear the cached instance.
+	*/
+	async close(closeActiveConnections = false) {
+		return Promise.resolve(this.#server?.stop(closeActiveConnections)).then(() => {
+			this.#server = void 0;
+		});
+	}
+};
+//#endregion
+export { BunRuntimeAdapter };

package/dist/cli.d.mts

@@ -0,0 +1,142 @@
+import { d as RuntimeAdapter, v as ServerHandler } from "./core-BGp2ZR_k.mjs";
+
+//#region src/cli.d.ts
+declare const defaultExts: string[];
+declare const defaultEntries: string[];
+/**
+ * Result of loading a server entry module.
+ */
+type LoadedServerEntry = {
+  /**
+   * The web fetch handler extracted from the loaded module.
+   *
+   * This is resolved by `loadServerEntry()` from:
+   * - `module.fetch`
+   * - `module.default.fetch`
+   * - or a default-exported function with fewer than two parameters
+   */
+  fetch?: ServerHandler;
+  /**
+   * The normalized loaded module.
+   *
+   * In practice this is usually the user entry object shape after
+   * `loadServerEntry()` unwraps a plain object default export.
+   *
+   * This follows the `UserServerEntry` structure for value access,
+   * though typed as `any` for flexibility.
+   */
+  module?: any;
+  /**
+   * The resolved `file://` URL of the loaded entry module.
+   */
+  url?: string;
+  /**
+   * Whether the specified entry file was not found.
+   *
+   * When `true`, no valid entry point could be located.
+   */
+  notFound?: boolean;
+  /**
+   * Runtime adapter selected for the current process.
+   *
+   * This value is resolved by `loadServerAdapter()` based on the active runtime
+   * (Bun, Deno, or Node.js) together with any runtime-specific options exposed
+   * from the user entry module.
+   */
+  adapter: RuntimeAdapter;
+};
+/**
+ * Options for loading a server entry module.
+ */
+type LoadOptions = {
+  /**
+   * Path or URL to the server entry file.
+   *
+   * If not provided, common entry points will be searched automatically.
+   */
+  entry?: string;
+  /**
+   * Base directory for resolving relative paths.
+   *
+   * @default "."
+   */
+  dir?: string;
+  /**
+   * Hook called after the module is loaded to allow for custom processing.
+   *
+   * You can return a modified version of the module if needed.
+   */
+  onLoad?: (module: unknown) => any;
+};
+/**
+ * Resolve and import a user server entry module.
+ *
+ * The loader can work with an explicit `entry` path or fall back to a list of
+ * conventional filenames such as `server.ts` and `src/server.ts`. After the
+ * module is imported, plain object default exports are unwrapped, a fetch
+ * handler is extracted, and a runtime adapter is selected for the current
+ * process.
+ */
+declare function loadServerEntry(opts: LoadOptions): Promise<LoadedServerEntry>;
+/**
+ * Command-line flags accepted by the `sevok` CLI.
+ */
+type CLIOptions = {
+  /** Show help message */help?: boolean; /** Show server and runtime versions */
+  version?: boolean; /** Working directory for resolving entry file */
+  dir?: string; /** Server entry file to use */
+  entry?: string; /** Run in production mode (no watch, no debug) */
+  prod?: boolean; /** Serve static files from the specified directory (default: "public") */
+  static?: string; /** ES module to preload */
+  import?: string; /** Host to bind to (default: all interfaces) */
+  hostname?: string; /** (alias to hostname) */
+  host?: string; /** Port to listen on (default: "3000") */
+  port?: string; /** Enable TLS (HTTPS/HTTP2) */
+  tls?: boolean; /** TLS certificate file */
+  cert?: string; /** TLS private key file */
+  key?: string;
+};
+/**
+ * Programmatic options for invoking the CLI entrypoint.
+ *
+ * Extends parsed CLI flags with metadata and usage text used by wrappers like
+ * the published bin entry.
+ */
+type MainOptions = CLIOptions & {
+  /**
+   * Explicit argv payload for programmatic invocation.
+   *
+   * CLI entry files should pass `process.argv.slice(2)` here so `main()` can
+   * stay independent from process globals.
+   */
+  args?: string[]; /** Optional package metadata for `--version` and help output. */
+  meta?: {
+    name?: string;
+    version?: string;
+    description?: string;
+  }; /** Optional usage metadata shown in generated help text. */
+  usage?: {
+    command?: string;
+    docs?: string;
+    issues?: string;
+  };
+};
+/**
+ * Main CLI entrypoint.
+ *
+ * Handles top-level flags, resolves environment files, and decides whether the
+ * current process should serve directly or fork a watched child process.
+ */
+declare function main(mainOpts: MainOptions): Promise<void>;
+/**
+ * Render the CLI help output.
+ */
+declare function usage(mainOpts: MainOptions): string;
+declare const NO_ENTRY_ERROR = "No server entry or public directory found";
+/**
+ * Resolve the user entry module, attach default middleware, and start the
+ * runtime adapter-backed server instance.
+ */
+declare function cliServe(cliOpts: CLIOptions): Promise<void>;
+//#endregion
+export { CLIOptions, LoadOptions, LoadedServerEntry, MainOptions, NO_ENTRY_ERROR, cliServe, defaultEntries, defaultExts, loadServerEntry, main, usage };