sevok 0.0.2 → 0.0.3

package/dist/bun.d.mts

@@ -1,4 +1,4 @@
-import { d as RuntimeAdapter, f as RuntimeCapabilities, p as Server } from "./core-BGp2ZR_k.mjs";
+import { f as RuntimeAdapter, m as Server, p as RuntimeCapabilities } from "./core-D6CtUiKb.mjs";
 
 //#region src/bun.d.ts
 /**

package/dist/cli.d.mts

@@ -1,4 +1,4 @@
-import { d as RuntimeAdapter, v as ServerHandler } from "./core-BGp2ZR_k.mjs";
+import { b as ServerHandlerFunction, f as RuntimeAdapter } from "./core-D6CtUiKb.mjs";
 
 //#region src/cli.d.ts
 declare const defaultExts: string[];
@@ -15,7 +15,7 @@ type LoadedServerEntry = {
    * - `module.default.fetch`
    * - or a default-exported function with fewer than two parameters
    */
-  fetch?: ServerHandler;
+  fetch?: ServerHandlerFunction;
   /**
    * The normalized loaded module.
    *

package/dist/cli.mjs

@@ -1,4 +1,4 @@
-import { u as loadServerAdapter } from "./core-CmUugTW7.mjs";
+import { u as loadServerAdapter } from "./core-Cb5IXDeA.mjs";
 import { t as _color_default } from "./_color-B42q-MpL.mjs";
 import { existsSync, statSync } from "node:fs";
 import { parseArgs } from "node:util";
@@ -9,7 +9,7 @@ import { dirname, relative, resolve } from "node:path";
 //#region src/_meta.ts
 const pkgMeta = {
 	name: "sevok",
-	version: "0.0.2",
+	version: "0.0.3",
 	description: "Composable Server Primitives Across Runtimes"
 };
 //#endregion
@@ -371,7 +371,7 @@ async function cliServe(cliOpts) {
 			entry: cliOpts.entry,
 			dir: cliOpts.dir
 		});
-		const { serve } = await import("./core-CmUugTW7.mjs").then((n) => n.o);
+		const { serve } = await import("./core-Cb5IXDeA.mjs").then((n) => n.o);
 		const { serveStatic } = await import("./static.mjs");
 		const { log } = await import("./log.mjs");
 		const staticDir = resolve(cliOpts.dir || (loaded.url ? dirname(fileURLToPath(loaded.url)) : "."), cliOpts.static || "public");

package/dist/{core-CmUugTW7.mjs → core-Cb5IXDeA.mjs}

@@ -250,21 +250,21 @@ function createWaitUntil() {
 * Normalize handlers so middleware runners can treat function and object forms
 * uniformly.
 *
-* A bare handler becomes `{ handleRequest }`, while object handlers are returned
+* A bare handler becomes `{ handle }`, while object handlers are returned
 * unchanged.
 */
 function toServerHandlerObject(handler) {
-	if (typeof handler === "function") return { handleRequest: handler };
+	if (typeof handler === "function") return { handle: handler };
 	return handler;
 }
 /**
 * Type guard to check if a value conforms to the `ServerHandlerObject` shape.
 *
-* This is used to distinguish between a bare `ServerHandler` function and an
+* This is used to distinguish between a bare `ServerHandlerFunction` and an
 * object wrapper that may also carry per-route middleware.
 */
 function isServerHandlerObject(value) {
-	return value != null && !Array.isArray(value) && typeof value === "object" && "handleRequest" in value && typeof value.handleRequest === "function";
+	return value != null && !Array.isArray(value) && typeof value === "object" && "handle" in value && typeof value.handle === "function";
 }
 /**
 * Execute middleware in sequence and then hand off to the terminal handler.
@@ -278,23 +278,30 @@ function isServerHandlerObject(value) {
 * If the terminal handler is a `ServerHandlerObject`, its own `middleware`
 * array is executed after the outer middleware chain completes.
 */
-function runMiddleware(context, middleware, terminal) {
+function runMiddleware({ context, middleware, terminal, resolve }) {
 	let index = -1;
 	const dispatch = async (context, i) => {
 		if (i <= index) throw new Error("next() called multiple times");
 		index = i;
 		if (context.request.signal.aborted) throw context.request.signal.reason;
-		const fn = middleware[i];
-		if (!fn) {
-			const { middleware, handleRequest } = toServerHandlerObject(terminal);
-			if (middleware?.length) return runMiddleware(context, middleware, { handleRequest });
-			return await raceRequestAbort(Promise.resolve(handleRequest(context)), context.request);
+		const entry = middleware[i];
+		if (entry == null) {
+			const { middleware, handle } = toServerHandlerObject(terminal);
+			if (middleware?.length) return runMiddleware({
+				context,
+				middleware,
+				terminal: handle,
+				resolve
+			});
+			return await raceRequestAbort(Promise.resolve(handle(context)), context.request);
 		}
 		let nextPromise;
 		let next = (nextContext) => {
 			nextPromise = dispatch(nextContext, i + 1);
 			return nextPromise;
 		};
+		const fn = typeof entry === "function" ? entry : resolve?.(entry);
+		if (!fn) return next(context);
 		let response = await raceRequestAbort(Promise.resolve(fn(context, next)), context.request);
 		if (response instanceof Response) return response;
 		if (nextPromise != null) return nextPromise;
@@ -424,7 +431,7 @@ function unstable_match(tree, input) {
 	};
 }
 /**
-* Turn a precompiled route tree into a `ServerHandler`.
+* Turn a precompiled route tree into a `ServerHandlerFunction`.
 *
 * Pathname matches are resolved using Bun-style precedence. When a pathname
 * matches but the method does not, the returned handler responds with `405`
@@ -438,9 +445,13 @@ function unstable_convertRoutesToHandler({ input, fallback, runRouteMiddleware }
 		if (route) {
 			context = context.with({ params: route.params });
 			if (typeof route.handler === "function") return route.handler(context);
-			if (!route.handler.middleware?.length) return route.handler.handleRequest(context);
+			if (!route.handler.middleware?.length) return route.handler.handle(context);
 			if (!runRouteMiddleware) throw new Error("Route handler middleware requires `runRouteMiddleware`.");
-			return runRouteMiddleware(context, route.handler.middleware, route.handler);
+			return runRouteMiddleware({
+				context,
+				middleware: route.handler.middleware,
+				terminal: route.handler.handle
+			});
 		}
 		if (result.all.length > 0) {
 			const allow = /* @__PURE__ */ new Set();
@@ -626,6 +637,9 @@ var Server = class extends EventDispatcher {
 	}
 	/**
 	* Invoke the composed request pipeline directly.
+	*
+	* If runtime adapter initialization is still in flight, this waits for the
+	* adapter setup to finish before dispatching the request.
 	*/
 	handle(context) {
 		if (this.#adapterPromise) return this.#adapterPromise.then(() => this.#kernel(context));
@@ -712,6 +726,10 @@ function wrapFetch(server) {
 	const fetchHandler = server.options.fetch;
 	const routes = server.options.routes;
 	const middleware = server.options.middleware || [];
+	const callMiddleware = (options) => runMiddleware({
+		...options,
+		resolve: server.options.middlewareResolver
+	});
 	let handler;
 	if (!routes) {
 		if (!fetchHandler) throw new Error("Server requires either `routes` or `fetch`.");
@@ -723,10 +741,14 @@ function wrapFetch(server) {
 		handler = unstable_convertRoutesToHandler({
 			input: unstable_buildRouteTree(routes),
 			fallback: fetchHandler,
-			runRouteMiddleware: runMiddleware
+			runRouteMiddleware: callMiddleware
 		});
 	}
-	return middleware.length === 0 ? handler : (context) => runMiddleware(context, middleware, handler);
+	return middleware.length === 0 ? handler : (context) => callMiddleware({
+		context,
+		middleware,
+		terminal: handler
+	});
 }
 //#endregion
 export { unstable_match as _, ServerServeEvent as a, createWaitUntil as c, raceRequestAbort as d, runMiddleware as f, unstable_convertRoutesToHandler as g, unstable_buildRouteTree as h, ServerErrorEvent as i, isServerHandlerObject as l, toServerHandlerObject as m, Server as n, core_exports as o, serve as p, ServerCloseEvent as r, createContextKey as s, InvocationContext as t, loadServerAdapter as u, wrapFetch as v };

package/dist/{core-BGp2ZR_k.d.mts → core-D6CtUiKb.d.mts}

@@ -15,9 +15,39 @@ type HTTPMethod = "GET" | "POST" | "PUT" | "DELETE" | "PATCH" | "HEAD" | "OPTION
  *
  * Receives an `InvocationContext` containing the request and invocation state.
  * Runtime adapters, middleware, and higher-level helpers all eventually resolve down to a
- * `ServerHandler`.
+ * `ServerHandlerFunction`.
  */
-type ServerHandler = (context: InvocationContext) => MaybePromise<Response>;
+type ServerHandlerFunction = (context: InvocationContext) => MaybePromise<Response>;
+/**
+ * Object form of a handler.
+ *
+ * This makes it possible to attach middleware at the leaf of a middleware
+ * chain, which is useful for composing route handlers or feature modules.
+ */
+type ServerHandlerObject = {
+  /**
+   * Additional middleware to apply immediately before `handle`.
+   */
+  middleware?: ServerMiddleware[];
+  /**
+   * Final request handler invoked after middleware has run.
+   */
+  handle: ServerHandlerFunction;
+};
+/**
+ * A request handler in either function or object form.
+ *
+ * This lets higher-level APIs accept a bare handler function for simple cases
+ * or a handler object when route-local middleware needs to be attached.
+ */
+type ServerHandler = ServerHandlerFunction | ServerHandlerObject;
+/**
+ * Per-method handlers for a single route path.
+ *
+ * This is the route-table branch used when the same pathname needs distinct
+ * handlers for different HTTP methods.
+ */
+type ServerMethodHandlers = Partial<Record<HTTPMethod, ServerHandler>>;
 /**
  * Error handler for failures raised during request handling.
  *
@@ -31,23 +61,51 @@ type ErrorHandler = (error: unknown) => MaybePromise<Response>;
  * `next` keeps the same handler signature so middleware can replace the request
  * object before passing control downstream.
  */
-type ServerMiddleware = (context: InvocationContext, next: ServerHandler) => MaybePromise<Response>;
+type ServerMiddlewareFunction = (context: InvocationContext, next: ServerHandlerFunction) => MaybePromise<Response>;
 /**
- * Object form of a handler.
+ * A named middleware reference resolved at execution time.
  *
- * This makes it possible to attach middleware at the leaf of a middleware
- * chain, which is useful for composing route handlers or feature modules.
+ * Use this when middleware registration and middleware lookup need to be
+ * decoupled, for example when an application maintains its own middleware
+ * registry.
+ *
+ * Consumers can extend `ServerMiddlewareNameMap` with module augmentation to
+ * surface application-specific named middleware entries in the type system.
+ *
+ * @example
+ * ```ts
+ * declare module "sevok" {
+ *   interface ServerMiddlewareNameMap {
+ *     auth: true;
+ *     cache: true;
+ *   }
+ * }
+ * ```
  */
-type ServerHandlerObject = {
-  /**
-   * Additional middleware to apply immediately before `handleRequest`.
-   */
-  middleware?: ServerMiddleware[];
-  /**
-   * Final request handler invoked after middleware has run.
-   */
-  handleRequest: ServerHandler;
-};
+type ServerMiddlewareName = keyof ServerMiddlewareNameMap | (string & {});
+/**
+ * Augmentation hook for adding application-specific named middleware entries.
+ *
+ * Consumers can extend this interface with module augmentation so known
+ * middleware names appear in `ServerMiddlewareName`.
+ */
+interface ServerMiddlewareNameMap {}
+/**
+ * A middleware entry accepted by server and handler middleware arrays.
+ *
+ * Entries can be either executable middleware functions or named references
+ * resolved through `ServerMiddlewareResolver`.
+ */
+type ServerMiddleware = ServerMiddlewareFunction | ServerMiddlewareName;
+/**
+ * Resolve a named middleware entry into an executable middleware function.
+ *
+ * Returning `undefined` indicates that the name could not be resolved. The
+ * middleware runner intentionally treats unresolved names as skipped entries and
+ * continues the chain. Consumers that require fail-fast behavior should throw
+ * from their resolver instead of returning `undefined`.
+ */
+type ServerMiddlewareResolver = (name: ServerMiddlewareName) => ServerMiddlewareFunction | undefined;
 /**
  * Route-table shorthand keyed by pathname.
  *
@@ -55,7 +113,7 @@ type ServerHandlerObject = {
  * middleware, or a method map when the same path needs different handlers for
  * different HTTP verbs.
  */
-type ServerRoutes<TPath extends string = string> = { [Path in TPath]: ServerHandler | ServerHandlerObject | Partial<Record<HTTPMethod, ServerHandler | ServerHandlerObject>> };
+type ServerRoutes<TPath extends string = string> = { [Path in TPath]: ServerHandler | ServerMethodHandlers };
 /**
  * A type-safe key for storing and retrieving values from
  * {@link InvocationContext}.
@@ -197,17 +255,29 @@ declare function createWaitUntil(): WaitUntil;
  * Normalize handlers so middleware runners can treat function and object forms
  * uniformly.
  *
- * A bare handler becomes `{ handleRequest }`, while object handlers are returned
+ * A bare handler becomes `{ handle }`, while object handlers are returned
  * unchanged.
  */
-declare function toServerHandlerObject(handler: ServerHandler | ServerHandlerObject): ServerHandlerObject;
+declare function toServerHandlerObject(handler: ServerHandler): ServerHandlerObject;
 /**
  * Type guard to check if a value conforms to the `ServerHandlerObject` shape.
  *
- * This is used to distinguish between a bare `ServerHandler` function and an
+ * This is used to distinguish between a bare `ServerHandlerFunction` and an
  * object wrapper that may also carry per-route middleware.
  */
 declare function isServerHandlerObject(value: unknown): value is ServerHandlerObject;
+/**
+ * Input for running a middleware chain against a terminal handler.
+ *
+ * `resolve` is only needed when the middleware array may contain named
+ * middleware entries instead of executable middleware functions.
+ */
+type RunMiddlewareOptions = {
+  context: InvocationContext;
+  middleware: ServerMiddleware[];
+  terminal: ServerHandler;
+  resolve?: ServerMiddlewareResolver;
+};
 /**
  * Execute middleware in sequence and then hand off to the terminal handler.
  *
@@ -220,12 +290,17 @@ declare function isServerHandlerObject(value: unknown): value is ServerHandlerOb
  * If the terminal handler is a `ServerHandlerObject`, its own `middleware`
  * array is executed after the outer middleware chain completes.
  */
-declare function runMiddleware(context: InvocationContext, middleware: ServerMiddleware[], terminal: ServerHandler | ServerHandlerObject): Promise<Response>;
+declare function runMiddleware({
+  context,
+  middleware,
+  terminal,
+  resolve
+}: RunMiddlewareOptions): Promise<Response>;
 type RouteInput = Request | URL | string | {
   url: string | URL;
   method?: HTTPMethod;
 };
-type RouteValue = ServerHandler | ServerHandlerObject | Partial<Record<HTTPMethod, ServerHandler | ServerHandlerObject>>;
+type RouteValue = ServerHandler | ServerMethodHandlers;
 type CompiledRoute = {
   path: string;
   route: RouteValue;
@@ -257,7 +332,7 @@ type RouteCandidate = {
  * method.
  */
 type UnstableRouteMatch = RouteCandidate & {
-  handler: ServerHandler | ServerHandlerObject;
+  handler: ServerHandler;
   method?: HTTPMethod;
 };
 /**
@@ -286,11 +361,11 @@ declare function unstable_buildRouteTree(routes: ServerRoutes): RouteTree;
 declare function unstable_match(tree: RouteTree, input: RouteInput): UnstableRouteMatchResult;
 type UnstableConvertRoutesToHandlerOptions = {
   input: RouteTree;
-  fallback?: ServerHandler;
-  runRouteMiddleware?: (context: InvocationContext, middleware: ServerMiddleware[], terminal: ServerHandlerObject) => Promise<Response>;
+  fallback?: ServerHandlerFunction;
+  runRouteMiddleware?: (options: Omit<RunMiddlewareOptions, "resolve">) => Promise<Response>;
 };
 /**
- * Turn a precompiled route tree into a `ServerHandler`.
+ * Turn a precompiled route tree into a `ServerHandlerFunction`.
  *
  * Pathname matches are resolved using Bun-style precedence. When a pathname
  * matches but the method does not, the returned handler responds with `405`
@@ -301,7 +376,7 @@ declare function unstable_convertRoutesToHandler({
   input,
   fallback,
   runRouteMiddleware
-}: UnstableConvertRoutesToHandlerOptions): ServerHandler;
+}: UnstableConvertRoutesToHandlerOptions): ServerHandlerFunction;
 /**
  * Host capabilities required by middleware and helpers that need filesystem or
  * compression support.
@@ -450,7 +525,7 @@ interface ServerOptions {
    * route table. When `routes` is omitted, this acts as the primary request
    * handler.
    */
-  fetch?: ServerHandler;
+  fetch?: ServerHandlerFunction;
   /**
    * Handle errors raised while processing requests.
    *
@@ -463,6 +538,13 @@ interface ServerOptions {
    * Middleware is executed in the order provided.
    */
   middleware: ServerMiddleware[];
+  /**
+   * Resolve named middleware entries at request execution time.
+   *
+   * When omitted, named middleware entries are skipped. Throw from the resolver
+   * if unresolved names should fail the request instead.
+   */
+  middlewareResolver?: ServerMiddlewareResolver;
   /**
    * If set to `true`, server will not start listening automatically.
    */
@@ -629,6 +711,9 @@ declare class Server extends EventDispatcher<ServerEventMap> {
   createContext(request: Request, params?: Readonly<Record<string, string>>): InvocationContext;
   /**
    * Invoke the composed request pipeline directly.
+   *
+   * If runtime adapter initialization is still in flight, this waits for the
+   * adapter setup to finish before dispatching the request.
    */
   handle(context: InvocationContext): MaybePromise<Response>;
   /**
@@ -660,6 +745,6 @@ declare class Server extends EventDispatcher<ServerEventMap> {
  * Compose fetch handler, middleware, and optional error handling into the
  * single request kernel used by `Server`.
  */
-declare function wrapFetch(server: Server): ServerHandler;
+declare function wrapFetch(server: Server): ServerHandlerFunction;
 //#endregion
-export { WaitUntil as A, unstable_buildRouteTree as B, ServerPlugin as C, UnstableConvertRoutesToHandlerOptions as D, TLSOptions as E, loadServerAdapter as F, unstable_match as H, raceRequestAbort as I, runMiddleware as L, createContextKey as M, createWaitUntil as N, UnstableRouteMatch as O, isServerHandlerObject as P, serve as R, ServerOptions as S, ServerServeEvent as T, wrapFetch as U, unstable_convertRoutesToHandler as V, ServerEventMapCustom as _, InvocationContext as a, ServerInit as b, InvocationContextValue as c, RuntimeAdapter as d, RuntimeCapabilities as f, ServerEventMap as g, ServerErrorEvent as h, HTTPMethod as i, WaitUntilFunction as j, UnstableRouteMatchResult as k, MaybePromise as l, ServerCloseEvent as m, DenoServerOptions as n, InvocationContextInit as o, Server as p, ErrorHandler as r, InvocationContextKey as s, BunServerOptions as t, NodeServerOptions as u, ServerHandler as v, ServerRoutes as w, ServerMiddleware as x, ServerHandlerObject as y, toServerHandlerObject as z };
+export { ServerPlugin as A, createWaitUntil as B, ServerMethodHandlers as C, ServerMiddlewareNameMap as D, ServerMiddlewareName as E, UnstableRouteMatch as F, serve as G, loadServerAdapter as H, UnstableRouteMatchResult as I, unstable_convertRoutesToHandler as J, toServerHandlerObject as K, WaitUntil as L, ServerServeEvent as M, TLSOptions as N, ServerMiddlewareResolver as O, UnstableConvertRoutesToHandlerOptions as P, WaitUntilFunction as R, ServerInit as S, ServerMiddlewareFunction as T, raceRequestAbort as U, isServerHandlerObject as V, runMiddleware as W, wrapFetch as X, unstable_match as Y, ServerEventMap as _, InvocationContext as a, ServerHandlerFunction as b, InvocationContextValue as c, RunMiddlewareOptions as d, RuntimeAdapter as f, ServerErrorEvent as g, ServerCloseEvent as h, HTTPMethod as i, ServerRoutes as j, ServerOptions as k, MaybePromise as l, Server as m, DenoServerOptions as n, InvocationContextInit as o, RuntimeCapabilities as p, unstable_buildRouteTree as q, ErrorHandler as r, InvocationContextKey as s, BunServerOptions as t, NodeServerOptions as u, ServerEventMapCustom as v, ServerMiddleware as w, ServerHandlerObject as x, ServerHandler as y, createContextKey as z };

package/dist/deno.d.mts

@@ -1,4 +1,4 @@
-import { d as RuntimeAdapter, f as RuntimeCapabilities, p as Server } from "./core-BGp2ZR_k.mjs";
+import { f as RuntimeAdapter, m as Server, p as RuntimeCapabilities } from "./core-D6CtUiKb.mjs";
 
 //#region src/deno.d.ts
 /**

package/dist/index.d.mts

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

@@ -1,2 +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";
+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-Cb5IXDeA.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

@@ -1,4 +1,4 @@
-import { x as ServerMiddleware } from "./core-BGp2ZR_k.mjs";
+import { T as ServerMiddlewareFunction } from "./core-D6CtUiKb.mjs";
 
 //#region src/log.d.ts
 /**
@@ -22,6 +22,6 @@ interface LogOptions {}
  * Each completed request prints timestamp, method, url, status code, and total
  * response time using simple terminal colors.
  */
-declare const log: (_options?: LogOptions) => ServerMiddleware;
+declare const log: (_options?: LogOptions) => ServerMiddlewareFunction;
 //#endregion
 export { LogOptions, log };

package/dist/node.d.mts

@@ -1,4 +1,4 @@
-import { d as RuntimeAdapter, f as RuntimeCapabilities, p as Server } from "./core-BGp2ZR_k.mjs";
+import { f as RuntimeAdapter, m as Server, p as RuntimeCapabilities } from "./core-D6CtUiKb.mjs";
 
 //#region src/node.d.ts
 /**

package/dist/static.d.mts

@@ -1,4 +1,4 @@
-import { l as MaybePromise, x as ServerMiddleware } from "./core-BGp2ZR_k.mjs";
+import { T as ServerMiddlewareFunction, l as MaybePromise } from "./core-D6CtUiKb.mjs";
 
 //#region src/static.d.ts
 /**
@@ -30,6 +30,6 @@ interface ServeStaticOptions {
  * - extensionless paths try `name.html` and `name/index.html`
  * - explicit extensions are used as-is
  */
-declare function serveStatic(options: ServeStaticOptions): ServerMiddleware;
+declare function serveStatic(options: ServeStaticOptions): ServerMiddlewareFunction;
 //#endregion
 export { ServeStaticOptions, serveStatic };

package/dist/stream.d.mts

@@ -1,4 +1,4 @@
-import { d as RuntimeAdapter, f as RuntimeCapabilities, j as WaitUntilFunction, p as Server } from "./core-BGp2ZR_k.mjs";
+import { R as WaitUntilFunction, f as RuntimeAdapter, m as Server, p as RuntimeCapabilities } from "./core-D6CtUiKb.mjs";
 
 //#region src/stream.d.ts
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sevok",
-  "version": "0.0.2",
+  "version": "0.0.3",
   "description": "Composable Server Primitives Across Runtimes",
   "homepage": "https://sevok.pages.dev",
   "license": "MIT",
@@ -58,6 +58,9 @@
     "@types/bun": "^1.3.10",
     "@types/deno": "^2.5.0"
   },
+  "resolutions": {
+    "sevok": "link:."
+  },
   "bin": {
     "sevok": "./bin/sevok.mjs"
   },