sevok 0.0.2

package/dist/deno.d.mts

@@ -0,0 +1,32 @@
+import { d as RuntimeAdapter, f as RuntimeCapabilities, p as Server } from "./core-BGp2ZR_k.mjs";
+
+//#region src/deno.d.ts
+/**
+ * Runtime adapter that backs `Server` with `Deno.serve()`.
+ */
+declare class DenoRuntimeAdapter implements RuntimeAdapter {
+  #private;
+  readonly graceful = true;
+  get capabilities(): RuntimeCapabilities;
+  /**
+   * Translate generic server options into Deno's `serve` options.
+   */
+  setup(server: Server): void;
+  /**
+   * Start Deno's HTTP server and resolve only after the runtime reports the
+   * bound address via `onListen`.
+   */
+  serve(server: Server): Promise<{
+    url: string | undefined;
+  }>;
+  /**
+   * Derive the public URL from the last `onListen` callback.
+   */
+  get url(): string | undefined;
+  /**
+   * Gracefully shut down the Deno server, if one is active.
+   */
+  close(): Promise<void>;
+}
+//#endregion
+export { DenoRuntimeAdapter };

package/dist/deno.mjs

@@ -0,0 +1,65 @@
+import { n as resolveTLSOptions, r as runtimeCapabilities, t as printListening } from "./_node_like-BRaAGeNM.mjs";
+import { a as fmtURL, s as resolvePortAndHost } from "./_shared-38k_JIsU.mjs";
+//#region src/deno.ts
+/**
+* Runtime adapter that backs `Server` with `Deno.serve()`.
+*/
+var DenoRuntimeAdapter = class {
+	#server;
+	#listeningPromise;
+	#listeningInfo;
+	#serveOptions;
+	graceful = true;
+	get capabilities() {
+		return runtimeCapabilities;
+	}
+	/**
+	* Translate generic server options into Deno's `serve` options.
+	*/
+	setup(server) {
+		const { options } = server;
+		const tls = resolveTLSOptions(options);
+		this.#serveOptions = {
+			...resolvePortAndHost(options),
+			reusePort: options.reusePort,
+			onError: options.error,
+			...tls,
+			...options.deno
+		};
+	}
+	/**
+	* Start Deno's HTTP server and resolve only after the runtime reports the
+	* bound address via `onListen`.
+	*/
+	async serve(server) {
+		if (this.#server) return Promise.resolve(this.#listeningPromise).then(() => ({ url: this.url }));
+		const onListenPromise = Promise.withResolvers();
+		this.#listeningPromise = onListenPromise.promise;
+		this.#server = Deno.serve({
+			...this.#serveOptions,
+			onListen: (info) => {
+				this.#listeningInfo = info;
+				if (this.#serveOptions?.onListen) this.#serveOptions.onListen(info);
+				printListening(server.options, this.url);
+				onListenPromise.resolve();
+			}
+		}, (request) => server.fetch(request));
+		return Promise.resolve(this.#listeningPromise).then(() => ({ url: this.url }));
+	}
+	/**
+	* Derive the public URL from the last `onListen` callback.
+	*/
+	get url() {
+		return this.#listeningInfo ? fmtURL(this.#listeningInfo.hostname, this.#listeningInfo.port, !!this.#serveOptions.cert) : void 0;
+	}
+	/**
+	* Gracefully shut down the Deno server, if one is active.
+	*/
+	async close() {
+		return Promise.resolve(this.#server?.shutdown()).then(() => {
+			this.#server = void 0;
+		});
+	}
+};
+//#endregion
+export { DenoRuntimeAdapter };

package/dist/index.d.mts

@@ -0,0 +1,2 @@
+import { A as WaitUntil, B as unstable_buildRouteTree, C as ServerPlugin, D as UnstableConvertRoutesToHandlerOptions, E as TLSOptions, F as loadServerAdapter, H as unstable_match, I as raceRequestAbort, L as runMiddleware, M as createContextKey, N as createWaitUntil, O as UnstableRouteMatch, P as isServerHandlerObject, R as serve, S as ServerOptions, T as ServerServeEvent, U as wrapFetch, V as unstable_convertRoutesToHandler, _ as ServerEventMapCustom, a as InvocationContext, b as ServerInit, c as InvocationContextValue, d as RuntimeAdapter, f as RuntimeCapabilities, g as ServerEventMap, h as ServerErrorEvent, i as HTTPMethod, j as WaitUntilFunction, k as UnstableRouteMatchResult, l as MaybePromise, m as ServerCloseEvent, n as DenoServerOptions, o as InvocationContextInit, p as Server, r as ErrorHandler, s as InvocationContextKey, t as BunServerOptions, u as NodeServerOptions, v as ServerHandler, w as ServerRoutes, x as ServerMiddleware, y as ServerHandlerObject, z as toServerHandlerObject } from "./core-BGp2ZR_k.mjs";
+export { BunServerOptions, DenoServerOptions, ErrorHandler, HTTPMethod, InvocationContext, InvocationContextInit, InvocationContextKey, InvocationContextValue, MaybePromise, NodeServerOptions, RuntimeAdapter, RuntimeCapabilities, Server, ServerCloseEvent, ServerErrorEvent, ServerEventMap, ServerEventMapCustom, ServerHandler, ServerHandlerObject, ServerInit, ServerMiddleware, ServerOptions, ServerPlugin, ServerRoutes, ServerServeEvent, TLSOptions, UnstableConvertRoutesToHandlerOptions, UnstableRouteMatch, UnstableRouteMatchResult, WaitUntil, WaitUntilFunction, createContextKey, createWaitUntil, isServerHandlerObject, loadServerAdapter, raceRequestAbort, runMiddleware, serve, toServerHandlerObject, unstable_buildRouteTree, unstable_convertRoutesToHandler, unstable_match, wrapFetch };

package/dist/index.mjs

@@ -0,0 +1,2 @@
+import { _ as unstable_match, a as ServerServeEvent, c as createWaitUntil, d as raceRequestAbort, f as runMiddleware, g as unstable_convertRoutesToHandler, h as unstable_buildRouteTree, i as ServerErrorEvent, l as isServerHandlerObject, m as toServerHandlerObject, n as Server, p as serve, r as ServerCloseEvent, s as createContextKey, t as InvocationContext, u as loadServerAdapter, v as wrapFetch } from "./core-CmUugTW7.mjs";
+export { InvocationContext, Server, ServerCloseEvent, ServerErrorEvent, ServerServeEvent, createContextKey, createWaitUntil, isServerHandlerObject, loadServerAdapter, raceRequestAbort, runMiddleware, serve, toServerHandlerObject, unstable_buildRouteTree, unstable_convertRoutesToHandler, unstable_match, wrapFetch };

package/dist/log.d.mts

@@ -0,0 +1,27 @@
+import { x as ServerMiddleware } from "./core-BGp2ZR_k.mjs";
+
+//#region src/log.d.ts
+/**
+ * Logging middleware options.
+ *
+ * Reserved for future customization of log format and destination.
+ *
+ * @example
+ * ```ts
+ * declare module "sevok/log" {
+ *   interface LogOptions {
+ *     requestId?: boolean;
+ *   }
+ * }
+ * ```
+ */
+interface LogOptions {}
+/**
+ * Create a request logger middleware.
+ *
+ * Each completed request prints timestamp, method, url, status code, and total
+ * response time using simple terminal colors.
+ */
+declare const log: (_options?: LogOptions) => ServerMiddleware;
+//#endregion
+export { LogOptions, log };

package/dist/log.mjs

@@ -0,0 +1,26 @@
+import { t as _color_default } from "./_color-B42q-MpL.mjs";
+//#region src/log.ts
+const statusColors = {
+	1: _color_default.blue,
+	2: _color_default.green,
+	3: _color_default.yellow
+};
+/**
+* Create a request logger middleware.
+*
+* Each completed request prints timestamp, method, url, status code, and total
+* response time using simple terminal colors.
+*/
+const log = (_options = {}) => {
+	return async (ctx, next) => {
+		const start = performance.now();
+		const req = ctx.request;
+		const res = await next(ctx);
+		const duration = performance.now() - start;
+		const statusColor = statusColors[Math.floor(res.status / 100)] || _color_default.red;
+		console.log(`${_color_default.gray(`[${(/* @__PURE__ */ new Date()).toLocaleTimeString()}]`)} ${_color_default.bold(req.method)} ${_color_default.blue(req.url)} [${statusColor(res.status + "")}] ${_color_default.gray(`(${duration.toFixed(2)}ms)`)}`);
+		return res;
+	};
+};
+//#endregion
+export { log };

package/dist/node.d.mts

@@ -0,0 +1,32 @@
+import { d as RuntimeAdapter, f as RuntimeCapabilities, p as Server } from "./core-BGp2ZR_k.mjs";
+
+//#region src/node.d.ts
+/**
+ * Runtime adapter that backs `Server` with Node's HTTP, HTTPS, or HTTP/2
+ * servers depending on the effective TLS configuration.
+ */
+declare class NodeRuntimeAdapter implements RuntimeAdapter {
+  #private;
+  readonly graceful = true;
+  get capabilities(): RuntimeCapabilities;
+  /**
+   * Create the underlying Node server instance but do not start listening yet.
+   */
+  setup(server: Server): void;
+  /**
+   * Start the Node server once and reuse the same ready promise afterwards.
+   */
+  serve(server: Server): Promise<{
+    url: string | undefined;
+  }>;
+  /**
+   * Return either a socket path or a formatted origin for TCP listeners.
+   */
+  get url(): string | undefined;
+  /**
+   * Stop accepting new work and optionally close active HTTP connections.
+   */
+  close(closeActiveConnections: boolean): Promise<void>;
+}
+//#endregion
+export { NodeRuntimeAdapter };

package/dist/node.mjs

@@ -0,0 +1,139 @@
+import { n as resolveTLSOptions, r as runtimeCapabilities, t as printListening } from "./_node_like-BRaAGeNM.mjs";
+import { a as fmtURL, s as resolvePortAndHost } from "./_shared-38k_JIsU.mjs";
+import nodeHTTP from "node:http";
+import nodeHTTPS from "node:https";
+import nodeHTTP2 from "node:http2";
+//#region src/node.ts
+/**
+* Runtime adapter that backs `Server` with Node's HTTP, HTTPS, or HTTP/2
+* servers depending on the effective TLS configuration.
+*/
+var NodeRuntimeAdapter = class {
+	#server;
+	#serveOptions;
+	#isSecure;
+	#listeningPromise;
+	graceful = true;
+	get capabilities() {
+		return runtimeCapabilities;
+	}
+	/**
+	* Create the underlying Node server instance but do not start listening yet.
+	*/
+	setup(server) {
+		const { options } = server;
+		const { hostname, port } = resolvePortAndHost(options);
+		const tls = resolveTLSOptions(options);
+		const isSecure = !!tls?.cert && options.protocol !== "http";
+		const isHttp2 = options.node?.http2 ?? isSecure;
+		this.#isSecure = isSecure;
+		this.#serveOptions = {
+			port,
+			host: hostname,
+			exclusive: !server.options.reusePort,
+			...tls ? {
+				cert: tls.cert,
+				key: tls.key,
+				passphrase: tls.passphrase
+			} : {},
+			...options.node
+		};
+		const handler = async (request, response) => {
+			await handleNodeRequest(server, request, response);
+		};
+		if (isHttp2) if (isSecure) this.#server = nodeHTTP2.createSecureServer({
+			allowHTTP1: true,
+			...this.#serveOptions
+		}, handler);
+		else throw new Error("node.http2 option requires tls certificate!");
+		else if (isSecure) this.#server = nodeHTTPS.createServer(this.#serveOptions, handler);
+		else this.#server = nodeHTTP.createServer(this.#serveOptions, handler);
+	}
+	/**
+	* Start the Node server once and reuse the same ready promise afterwards.
+	*/
+	async serve(server) {
+		if (this.#listeningPromise) return Promise.resolve(this.#listeningPromise).then(() => ({ url: this.url }));
+		this.#listeningPromise = new Promise((resolve) => {
+			this.#server.listen(this.#serveOptions, () => {
+				printListening(server.options, this.url);
+				resolve({ url: this.url });
+			});
+		});
+		return this.#listeningPromise;
+	}
+	/**
+	* Return either a socket path or a formatted origin for TCP listeners.
+	*/
+	get url() {
+		const addr = this.#server?.address();
+		if (!addr) return;
+		return typeof addr === "string" ? addr : fmtURL(addr.address, addr.port, this.#isSecure);
+	}
+	/**
+	* Stop accepting new work and optionally close active HTTP connections.
+	*/
+	close(closeActiveConnections) {
+		return new Promise((resolve, reject) => {
+			const server = this.#server;
+			if (server && closeActiveConnections && "closeAllConnections" in server) server.closeAllConnections();
+			if (!server || !server.listening) return resolve();
+			server.close((error) => error ? reject(error) : resolve());
+		});
+	}
+};
+/**
+* Convert a Node request/response pair into fetch primitives and forward
+* framework-level errors through the configured error handler.
+*/
+async function handleNodeRequest(server, request, response) {
+	try {
+		const nextRequest = await toRequest(request);
+		await writeResponse(response, await server.fetch(nextRequest));
+	} catch (error) {
+		await writeResponse(response, server.options.error ? await server.options.error(error) : new Response("Internal Server Error", { status: 500 }));
+	}
+}
+/**
+* Convert Node's `IncomingMessage` into a standard `Request`.
+*/
+async function toRequest(request) {
+	const protocol = request.socket.encrypted ? "https" : "http";
+	const host = request.headers.host ?? "127.0.0.1";
+	const url = new URL(request.url ?? "/", `${protocol}://${host}`);
+	const headers = new Headers();
+	for (const [key, value] of Object.entries(request.headers)) {
+		if (Array.isArray(value)) {
+			for (const entry of value) headers.append(key, entry);
+			continue;
+		}
+		if (typeof value === "string") headers.set(key, value);
+	}
+	const init = {
+		method: request.method,
+		headers
+	};
+	if (request.method !== "GET" && request.method !== "HEAD") {
+		const { Readable } = await import("node:stream");
+		init.body = Readable.toWeb(request);
+		init.duplex = "half";
+	}
+	return new Request(url.toString(), init);
+}
+/**
+* Write a fetch `Response` back to Node's `ServerResponse`.
+*/
+async function writeResponse(response, nextResponse) {
+	response.statusCode = nextResponse.status;
+	response.statusMessage = nextResponse.statusText;
+	nextResponse.headers.forEach((value, key) => {
+		response.setHeader(key, value);
+	});
+	if (!nextResponse.body) {
+		response.end();
+		return;
+	}
+	response.end(Buffer.from(await nextResponse.arrayBuffer()));
+}
+//#endregion
+export { NodeRuntimeAdapter };

package/dist/static.d.mts

@@ -0,0 +1,35 @@
+import { l as MaybePromise, x as ServerMiddleware } from "./core-BGp2ZR_k.mjs";
+
+//#region src/static.d.ts
+/**
+ * Configuration for `serveStatic()`.
+ */
+interface ServeStaticOptions {
+  /**
+   * The directory to serve static files from.
+   */
+  dir: string;
+  /**
+   * The HTTP methods to allow for serving static files.
+   */
+  methods?: string[];
+  /**
+   * A function to modify the HTML content before serving it.
+   */
+  renderHTML?: (ctx: {
+    request: Request;
+    html: string;
+    filename: string;
+  }) => MaybePromise<Response>;
+}
+/**
+ * Create middleware that serves files from a runtime-provided filesystem.
+ *
+ * Resolution follows common static-site conventions:
+ * - `/` maps to `index.html`
+ * - extensionless paths try `name.html` and `name/index.html`
+ * - explicit extensions are used as-is
+ */
+declare function serveStatic(options: ServeStaticOptions): ServerMiddleware;
+//#endregion
+export { ServeStaticOptions, serveStatic };

package/dist/static.mjs

@@ -0,0 +1,100 @@
+//#region src/static.ts
+const COMMON_MIME_TYPES = {
+	".html": "text/html",
+	".htm": "text/html",
+	".css": "text/css",
+	".js": "text/javascript",
+	".mjs": "text/javascript",
+	".json": "application/json",
+	".txt": "text/plain",
+	".xml": "application/xml",
+	".gif": "image/gif",
+	".ico": "image/vnd.microsoft.icon",
+	".jpeg": "image/jpeg",
+	".jpg": "image/jpeg",
+	".png": "image/png",
+	".svg": "image/svg+xml",
+	".webp": "image/webp",
+	".woff": "font/woff",
+	".woff2": "font/woff2",
+	".mp4": "video/mp4",
+	".webm": "video/webm",
+	".zip": "application/zip",
+	".pdf": "application/pdf"
+};
+/**
+* Create middleware that serves files from a runtime-provided filesystem.
+*
+* Resolution follows common static-site conventions:
+* - `/` maps to `index.html`
+* - extensionless paths try `name.html` and `name/index.html`
+* - explicit extensions are used as-is
+*/
+function serveStatic(options) {
+	const methods = new Set((options.methods || ["GET", "HEAD"]).map((m) => m.toUpperCase()));
+	return async (ctx, next) => {
+		const req = ctx.request;
+		if (!methods.has(req.method)) return next(ctx);
+		const path = (ctx.url ??= new URL(req.url)).pathname.slice(1).replace(/\/$/, "");
+		let paths;
+		if (path === "") paths = ["index.html"];
+		else if (extname(path) === "") paths = [`${path}.html`, `${path}/index.html`];
+		else paths = [path];
+		const fs = ctx.capabilities;
+		for (const path of paths) {
+			const filePath = await fs.resolve(options.dir, path);
+			if (!filePath) continue;
+			const file = await fs.open(filePath);
+			if (file?.isFile) {
+				const fileExt = extname(filePath);
+				const headers = new Headers({
+					"Content-Length": file.size.toString(),
+					"Content-Type": COMMON_MIME_TYPES[fileExt] || "application/octet-stream"
+				});
+				const stream = file.stream();
+				if (options.renderHTML && fileExt === ".html") {
+					const html = await read(stream);
+					return options.renderHTML({
+						html,
+						filename: filePath,
+						request: req
+					});
+				}
+				const acceptEncoding = req.headers.get("accept-encoding") || "";
+				if (acceptEncoding.includes("br")) {
+					headers.set("Content-Encoding", "br");
+					headers.delete("Content-Length");
+					headers.set("Vary", "Accept-Encoding");
+					const { readable, writable } = await fs.createBrotliCompress();
+					await stream.pipeTo(writable);
+					return new Response(readable, { headers });
+				} else if (acceptEncoding.includes("gzip")) {
+					headers.set("Content-Encoding", "gzip");
+					headers.delete("Content-Length");
+					headers.set("Vary", "Accept-Encoding");
+					const { readable, writable } = await fs.createGzip();
+					await stream.pipeTo(writable);
+					return new Response(readable, { headers });
+				} else return new Response(stream, { headers });
+			}
+		}
+		return next(ctx);
+	};
+}
+/**
+* Extract a file extension without relying on Node's path helpers so the
+* function also works in non-Node runtimes.
+*/
+function extname(path) {
+	const lastSlash = Math.max(path.lastIndexOf("/"), path.lastIndexOf("\\"));
+	const lastDot = path.lastIndexOf(".");
+	return lastDot > lastSlash ? path.slice(lastDot) : "";
+}
+/**
+* Consume a `ReadableStream` into a UTF-8 string.
+*/
+async function read(stream) {
+	return await new Response(stream).text();
+}
+//#endregion
+export { serveStatic };

package/dist/stream.d.mts

@@ -0,0 +1,56 @@
+import { d as RuntimeAdapter, f as RuntimeCapabilities, j as WaitUntilFunction, p as Server } from "./core-BGp2ZR_k.mjs";
+
+//#region src/stream.d.ts
+/**
+ * Minimal request entry shape consumed by `handleRequestEntry()`.
+ *
+ * This intentionally matches service-worker-like runtimes that expose a request
+ * plus completion hooks rather than direct socket APIs.
+ */
+interface RequestEntry {
+  readonly request: Request;
+  readonly waitUntil?: WaitUntilFunction;
+  completeWith(promise: Promise<Response>): void;
+}
+/**
+ * Options for consuming fetch events from an async stream.
+ */
+type StreamServerOptions = {
+  /**
+   * Source of runtime-specific fetch events to dispatch through `Server`.
+   */
+  stream: AsyncIterableIterator<RequestEntry>;
+  /**
+   * The path to the stream worker file or address to be registered.
+   */
+  url?: string;
+};
+/**
+ * Complete a runtime request entry by routing it through `Server.fetch()`.
+ */
+declare function handleRequestEntry(server: Server, entry: RequestEntry): void;
+/**
+ * Adapter for environments that expose requests as an async iterator instead of
+ * a socket listener.
+ */
+declare class StreamRuntimeAdapter implements RuntimeAdapter {
+  #private;
+  constructor(options: StreamServerOptions);
+  get capabilities(): RuntimeCapabilities;
+  /**
+   * No-op because the stream runtime does not need listener setup.
+   */
+  setup(): void;
+  /**
+   * Start consuming the event stream once and dispatch each event to `Server`.
+   */
+  serve(server: Server): Promise<{
+    url: string | undefined;
+  }>;
+  /**
+   * Stop dispatching future events from the stream.
+   */
+  close(): Promise<void>;
+}
+//#endregion
+export { RequestEntry, StreamRuntimeAdapter, StreamServerOptions, handleRequestEntry };

package/dist/stream.mjs

@@ -0,0 +1,68 @@
+//#region src/stream.ts
+/**
+* Complete a runtime request entry by routing it through `Server.fetch()`.
+*/
+function handleRequestEntry(server, entry) {
+	const { request, waitUntil } = entry;
+	let context = server.createContext(request);
+	if (typeof waitUntil === "function") context = context.with({ waitUntil: (p) => waitUntil(p) });
+	entry.completeWith(Promise.resolve(server.handle(context)));
+}
+/**
+* Adapter for environments that expose requests as an async iterator instead of
+* a socket listener.
+*/
+var StreamRuntimeAdapter = class {
+	#options;
+	#served = false;
+	#closed = false;
+	constructor(options) {
+		this.#options = options;
+	}
+	get capabilities() {
+		return streamCapabilities;
+	}
+	/**
+	* No-op because the stream runtime does not need listener setup.
+	*/
+	setup() {}
+	/**
+	* Start consuming the event stream once and dispatch each event to `Server`.
+	*/
+	async serve(server) {
+		if (this.#served) return { url: this.#options.url };
+		this.#served = true;
+		queueMicrotask(async () => {
+			for await (const event of this.#options.stream) {
+				if (this.#closed) return;
+				handleRequestEntry(server, event);
+			}
+		});
+		return { url: this.#options.url };
+	}
+	/**
+	* Stop dispatching future events from the stream.
+	*/
+	async close() {
+		this.#closed = true;
+		this.#served = false;
+	}
+};
+/**
+* Minimal capabilities available in stream-only environments.
+*/
+const streamCapabilities = {
+	resolve: () => Promise.resolve(null),
+	open: () => Promise.resolve(null),
+	createGzip: () => createCompressionStream("gzip"),
+	createBrotliCompress() {
+		throw new Error("Does not provide Brotli compression.");
+	}
+};
+function createCompressionStream(format) {
+	const CompressionStreamCtor = globalThis.CompressionStream;
+	if (typeof CompressionStreamCtor !== "function") throw new Error("Does not provide CompressionStream.");
+	return new CompressionStreamCtor(format);
+}
+//#endregion
+export { StreamRuntimeAdapter, handleRequestEntry };

package/package.json

@@ -0,0 +1,68 @@
+{
+  "name": "sevok",
+  "version": "0.0.2",
+  "description": "Composable Server Primitives Across Runtimes",
+  "homepage": "https://sevok.pages.dev",
+  "license": "MIT",
+  "author": "Maofeng <hornjs@qq.com>",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/hornjs/sevok.git"
+  },
+  "files": [
+    "LICENSE",
+    "README.md",
+    "README.zh-CN.md",
+    "bin",
+    "dist"
+  ],
+  "type": "module",
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.mts",
+      "default": "./dist/index.mjs"
+    },
+    "./bun": {
+      "types": "./dist/bun.d.mts",
+      "default": "./dist/bun.mjs"
+    },
+    "./cli": {
+      "types": "./dist/cli.d.mts",
+      "default": "./dist/cli.mjs"
+    },
+    "./deno": {
+      "types": "./dist/deno.d.mts",
+      "default": "./dist/deno.mjs"
+    },
+    "./log": {
+      "types": "./dist/log.d.mts",
+      "default": "./dist/log.mjs"
+    },
+    "./node": {
+      "types": "./dist/node.d.mts",
+      "default": "./dist/node.mjs"
+    },
+    "./static": {
+      "types": "./dist/static.d.mts",
+      "default": "./dist/static.mjs"
+    },
+    "./stream": {
+      "types": "./dist/stream.d.mts",
+      "default": "./dist/stream.mjs"
+    },
+    "./package.json": "./package.json"
+  },
+  "dependencies": {
+    "@hornjs/evt": "^0.0.4",
+    "@types/bun": "^1.3.10",
+    "@types/deno": "^2.5.0"
+  },
+  "bin": {
+    "sevok": "./bin/sevok.mjs"
+  },
+  "types": "./dist/index.d.mts",
+  "publishConfig": {
+    "access": "public"
+  }
+}