sevok 0.0.2

package/dist/core-CmUugTW7.mjs

@@ -0,0 +1,732 @@
+import { i as extractParams, n as compilePath, o as normalizePathname, r as extractKeys, t as canonicalizePath } from "./_shared-38k_JIsU.mjs";
+import { t as _color_default } from "./_color-B42q-MpL.mjs";
+import { EventDispatcher } from "@hornjs/evt";
+//#region \0rolldown/runtime.js
+var __defProp = Object.defineProperty;
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+//#endregion
+//#region src/_plugins.ts
+/**
+* Wrap the request pipeline with the user-provided error handler.
+*
+* The plugin inserts a middleware at the front of the stack so both thrown
+* exceptions and rejected downstream promises are normalized through
+* `server.options.error`.
+*/
+const errorPlugin = (server) => {
+	const errorHandler = server.options.error;
+	if (!errorHandler) return;
+	server.options.middleware.unshift((ctx, next) => {
+		try {
+			const res = next(ctx);
+			return res instanceof Promise ? res.catch((error) => errorHandler(error)) : res;
+		} catch (error) {
+			return errorHandler(error);
+		}
+	});
+};
+/**
+* Register process signal handlers that close the server gracefully.
+*
+* The first `SIGINT` / `SIGTERM` starts a graceful shutdown countdown. A second
+* `SIGINT` forces active connections to close immediately.
+*/
+const gracefulShutdownPlugin = (server) => {
+	const config = server.options?.gracefulShutdown;
+	if (!globalThis.process?.on || config === false || config === void 0 && (process.env.CI || process.env.TEST)) return;
+	const gracefulTimeout = config === true || !config?.gracefulTimeout ? Number.parseInt(process.env.SERVER_SHUTDOWN_TIMEOUT || "") || 5 : config.gracefulTimeout;
+	let isClosing = false;
+	let isClosed = false;
+	const write = server.options.silent ? () => {} : process.stderr.write.bind(process.stderr);
+	/**
+	* Forcefully close active connections once graceful shutdown times out or the
+	* user presses Ctrl+C again.
+	*/
+	const forceClose = async () => {
+		if (isClosed) return;
+		write(_color_default.red("\x1B[2K\rForcibly closing connections...\n"));
+		isClosed = true;
+		await server.close(true);
+	};
+	/**
+	* Attempt to close the server cleanly while printing countdown updates.
+	*/
+	const shutdown = async () => {
+		if (isClosing || isClosed) return;
+		setTimeout(() => {
+			globalThis.process.once("SIGINT", forceClose);
+		}, 100);
+		isClosing = true;
+		const closePromise = server.close();
+		for (let remaining = gracefulTimeout; remaining > 0; remaining--) {
+			write(_color_default.gray(`\rStopping server gracefully (${remaining}s)... Press ${_color_default.bold("Ctrl+C")} again to force close.`));
+			if (await Promise.race([closePromise.then(() => true), new Promise((r) => setTimeout(() => r(false), 1e3))])) {
+				write("\x1B[2K\r" + _color_default.green("Server closed successfully.\n"));
+				isClosed = true;
+				return;
+			}
+		}
+		write("\x1B[2K\rGraceful shutdown timed out.\n");
+		await forceClose();
+	};
+	for (const sig of ["SIGINT", "SIGTERM"]) globalThis.process.on(sig, shutdown);
+};
+//#endregion
+//#region src/core.ts
+var core_exports = /* @__PURE__ */ __exportAll({
+	InvocationContext: () => InvocationContext,
+	Server: () => Server,
+	ServerCloseEvent: () => ServerCloseEvent,
+	ServerErrorEvent: () => ServerErrorEvent,
+	ServerServeEvent: () => ServerServeEvent,
+	createContextKey: () => createContextKey,
+	createWaitUntil: () => createWaitUntil,
+	isServerHandlerObject: () => isServerHandlerObject,
+	loadServerAdapter: () => loadServerAdapter,
+	raceRequestAbort: () => raceRequestAbort,
+	runMiddleware: () => runMiddleware,
+	serve: () => serve,
+	toServerHandlerObject: () => toServerHandlerObject,
+	unstable_buildRouteTree: () => unstable_buildRouteTree,
+	unstable_convertRoutesToHandler: () => unstable_convertRoutesToHandler,
+	unstable_match: () => unstable_match,
+	wrapFetch: () => wrapFetch
+});
+/**
+* Create an invocation context key with an optional default value.
+*
+* When a default value is provided, `InvocationContext#get()` can always
+* return a value for that key even if nothing has been explicitly written yet.
+*
+* @param defaultValue The default value for the context key
+* @returns The new context key
+*/
+function createContextKey(defaultValue) {
+	return { defaultValue };
+}
+/**
+* A context object that contains information about the current invocation.
+* Each handler and middleware receives its own context instance, which may be
+* derived from a parent context via `with()`.
+*
+* Context values are immutable - use `with()` to create a modified copy.
+*/
+var InvocationContext = class InvocationContext {
+	/**
+	* The original request that was dispatched to the router.
+	*
+	* Note: The request body may already have been consumed by middleware
+	* (available as `context.get(FormData)`). Use `context.with({ request })`
+	* if you need to pass a modified request downstream.
+	*/
+	request;
+	/**
+	* Cached parsed URL for middleware and handlers that need repeated URL access.
+	*/
+	url;
+	/**
+	* Runtime specific invocation context.
+	*/
+	capabilities;
+	/**
+	* The current route parameters for this request.
+	*
+	* This reflects the active matched route and returns an empty object before
+	* routing has resolved a match.
+	*/
+	params;
+	/**
+	* Tell the runtime about an ongoing operation that shouldn't close until the
+	* promise resolves.
+	*
+	* This mirrors service-worker-style `waitUntil()` semantics and is wired into
+	* `Server.close()`.
+	*/
+	waitUntil;
+	#contextMap;
+	constructor(init) {
+		this.request = init.request;
+		this.capabilities = init.capabilities;
+		this.params = init.params ?? emptyRouteParams;
+		this.waitUntil = init.waitUntil;
+		this.#contextMap = /* @__PURE__ */ new Map();
+	}
+	/**
+	* Create a derived context with optional overrides.
+	* Copies all context values to the new instance.
+	*/
+	with(overrides) {
+		const child = new InvocationContext({
+			request: overrides.request ?? this.request,
+			capabilities: overrides.capabilities ?? this.capabilities,
+			params: overrides.params ?? this.params,
+			waitUntil: overrides.waitUntil ?? this.waitUntil
+		});
+		for (const [key, value] of this.#contextMap) child.#contextMap.set(key, value);
+		return child;
+	}
+	/**
+	* Get a value from invocation context.
+	*
+	* @param TKey The key to read
+	* @returns The value for the given key
+	*/
+	get(key) {
+		if (this.#contextMap.has(key)) return this.#contextMap.get(key);
+		const contextKey = key;
+		if (contextKey.defaultValue === void 0) throw new Error(`Missing default value in context for key ${key}`);
+		return contextKey.defaultValue;
+	}
+	/**
+	* Check whether a value exists in invocation context.
+	*
+	* @param TKey The key to check
+	* @returns `true` if a value has been set for the key
+	*/
+	has(key) {
+		return this.#contextMap.has(key);
+	}
+	/**
+	* Set a value in invocation context.
+	*
+	* @param key The key to write
+	* @param value The value to write
+	*/
+	set(key, value) {
+		this.#contextMap.set(key, value);
+	}
+};
+/**
+* Reject when the request abort signal fires before the promise settles.
+*
+* This keeps long-running async work aligned with fetch semantics: once the
+* request has been aborted, downstream work should stop surfacing successful
+* results for it.
+*/
+function raceRequestAbort(promise, request) {
+	let signal = request.signal;
+	if (signal.aborted) throw signal.reason;
+	return new Promise((resolve, reject) => {
+		let onAbort = () => reject(signal.reason);
+		signal.addEventListener("abort", onAbort, { once: true });
+		promise.then((value) => {
+			signal.removeEventListener("abort", onAbort);
+			resolve(value);
+		}, (error) => {
+			signal.removeEventListener("abort", onAbort);
+			reject(error);
+		});
+	});
+}
+/**
+* Create a `waitUntil()` registry that keeps track of pending background work.
+*
+* Rejected tasks are logged and removed from the registry so shutdown can
+* continue cleanly.
+*/
+function createWaitUntil() {
+	const promises = /* @__PURE__ */ new Set();
+	return {
+		waitUntil: (promise) => {
+			if (typeof promise?.then !== "function") return;
+			let tracked;
+			tracked = Promise.resolve(promise).catch(console.error).finally(() => promises.delete(tracked));
+			promises.add(tracked);
+		},
+		wait: () => {
+			return Promise.all(promises);
+		}
+	};
+}
+/**
+* Normalize handlers so middleware runners can treat function and object forms
+* uniformly.
+*
+* A bare handler becomes `{ handleRequest }`, while object handlers are returned
+* unchanged.
+*/
+function toServerHandlerObject(handler) {
+	if (typeof handler === "function") return { handleRequest: 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
+* 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";
+}
+/**
+* Execute middleware in sequence and then hand off to the terminal handler.
+*
+* Middleware may:
+* - return a `Response` to short-circuit downstream execution
+* - call `next()` and return its result
+* - call `next()` without returning it, in which case the downstream response
+*   is still used
+*
+* If the terminal handler is a `ServerHandlerObject`, its own `middleware`
+* array is executed after the outer middleware chain completes.
+*/
+function runMiddleware(context, middleware, terminal) {
+	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);
+		}
+		let nextPromise;
+		let next = (nextContext) => {
+			nextPromise = dispatch(nextContext, i + 1);
+			return nextPromise;
+		};
+		let response = await raceRequestAbort(Promise.resolve(fn(context, next)), context.request);
+		if (response instanceof Response) return response;
+		if (nextPromise != null) return nextPromise;
+		return next(context);
+	};
+	return dispatch(context, 0);
+}
+function resolveRouteHandler(route, method) {
+	if (typeof route === "function" || isServerHandlerObject(route)) return route;
+	if (method && route[method]) return route[method];
+	if (method === "HEAD" && route.GET) return route.GET;
+}
+function resolveRouteMethods(route) {
+	if (typeof route === "function" || isServerHandlerObject(route)) return [];
+	const methods = Object.keys(route);
+	if (methods.includes("GET") && !methods.includes("HEAD")) methods.push("HEAD");
+	return methods;
+}
+function resolveRouteInput(input) {
+	if (typeof input === "string") try {
+		return { pathname: new URL(input).pathname };
+	} catch {
+		return { pathname: input };
+	}
+	if (input instanceof URL) return { pathname: input.pathname };
+	if (input instanceof Request) return {
+		pathname: new URL(input.url).pathname,
+		method: input.method
+	};
+	return {
+		pathname: typeof input.url === "string" ? new URL(input.url).pathname : input.url.pathname,
+		method: input.method
+	};
+}
+/**
+* Compile a declarative `ServerRoutes` table into precedence buckets for fast
+* request matching.
+*
+* The build step also rejects conflicting route shapes such as duplicate exact
+* routes or parameter routes that collapse to the same canonical pattern.
+*/
+function unstable_buildRouteTree(routes) {
+	const tree = {
+		exact: /* @__PURE__ */ new Map(),
+		param: [],
+		wildcard: []
+	};
+	const seen = /* @__PURE__ */ new Map();
+	for (const [path, route] of Object.entries(routes)) {
+		const normalized = normalizePathname(path);
+		const canonical = canonicalizePath(normalized);
+		const previous = seen.get(canonical);
+		if (previous) throw new Error(`Conflicting routes: "${previous}" and "${path}" both resolve to "${canonical}".`);
+		seen.set(canonical, path);
+		const compiled = {
+			path: normalized,
+			route,
+			regexp: compilePath(normalized),
+			keys: extractKeys(normalized)
+		};
+		if (normalized === "/*") {
+			tree.catchAll = compiled;
+			continue;
+		}
+		if (normalized.includes("*")) {
+			tree.wildcard.push(compiled);
+			continue;
+		}
+		if (normalized.includes(":")) {
+			tree.param.push(compiled);
+			continue;
+		}
+		tree.exact.set(normalized, route);
+	}
+	return tree;
+}
+/**
+* Match a request-like input against a compiled route tree.
+*
+* `all` contains every pathname candidate in precedence order, while
+* `matched` further filters that list by HTTP method and resolves the concrete
+* handler that would run.
+*/
+function unstable_match(tree, input) {
+	const all = [];
+	const { pathname, method } = resolveRouteInput(input);
+	const normalized = normalizePathname(pathname);
+	const exact = tree.exact.get(normalized);
+	if (exact) all.push({
+		path: normalized,
+		route: exact,
+		params: {}
+	});
+	for (const compiled of tree.param) {
+		const result = compiled.regexp.exec(normalized);
+		if (!result) continue;
+		all.push({
+			path: compiled.path,
+			route: compiled.route,
+			params: extractParams(compiled.keys, result)
+		});
+	}
+	for (const compiled of tree.wildcard) {
+		if (!compiled.regexp.test(normalized)) continue;
+		all.push({
+			path: compiled.path,
+			route: compiled.route,
+			params: {}
+		});
+	}
+	if (tree.catchAll && tree.catchAll.regexp.test(normalized)) all.push({
+		path: tree.catchAll.path,
+		route: tree.catchAll.route,
+		params: {}
+	});
+	return {
+		all,
+		matched: all.flatMap((candidate) => {
+			const handler = resolveRouteHandler(candidate.route, method);
+			if (!handler) return [];
+			return [{
+				...candidate,
+				handler,
+				method
+			}];
+		})
+	};
+}
+/**
+* Turn a precompiled route tree into a `ServerHandler`.
+*
+* Pathname matches are resolved using Bun-style precedence. When a pathname
+* matches but the method does not, the returned handler responds with `405`
+* and an `Allow` header. If no route matches, `fallback` is used when
+* provided; otherwise a `404` response is returned.
+*/
+function unstable_convertRoutesToHandler({ input, fallback, runRouteMiddleware }) {
+	return async (context) => {
+		const result = unstable_match(input, context.request);
+		const route = result.matched[0];
+		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 (!runRouteMiddleware) throw new Error("Route handler middleware requires `runRouteMiddleware`.");
+			return runRouteMiddleware(context, route.handler.middleware, route.handler);
+		}
+		if (result.all.length > 0) {
+			const allow = /* @__PURE__ */ new Set();
+			for (const candidate of result.all) for (const method of resolveRouteMethods(candidate.route)) allow.add(method);
+			const headers = allow.size > 0 ? { Allow: [...allow].join(", ") } : void 0;
+			return new Response("Method Not Allowed", {
+				status: 405,
+				headers
+			});
+		}
+		if (fallback) return fallback(context);
+		return new Response("Not Found", { status: 404 });
+	};
+}
+const emptyRouteParams = Object.freeze({});
+/**
+* Resolve the runtime adapter for the current process.
+*
+* The adapter is chosen lazily so the package can stay portable across Bun,
+* Deno, and Node without importing runtime-specific code up front.
+*/
+async function loadServerAdapter() {
+	if (process.versions.bun) {
+		const { BunRuntimeAdapter } = await import("./bun.mjs");
+		return new BunRuntimeAdapter();
+	} else if (process.versions.deno) {
+		const { DenoRuntimeAdapter } = await import("./deno.mjs");
+		return new DenoRuntimeAdapter();
+	} else {
+		const { NodeRuntimeAdapter } = await import("./node.mjs");
+		return new NodeRuntimeAdapter();
+	}
+}
+/**
+* Temporary adapter that rejects server operations until the real runtime
+* adapter has been resolved asynchronously.
+*/
+var PlaceholderRuntimeAdapter = class {
+	#callback;
+	constructor(callback) {
+		this.#callback = callback;
+	}
+	get capabilities() {
+		throw new Error("Server runtime adapter is still initializing.");
+	}
+	setup() {
+		loadServerAdapter().then((adapter) => this.#callback(null, adapter), (error) => this.#callback(error, null));
+	}
+	async serve() {
+		throw new Error("Server runtime adapter is still initializing.");
+	}
+	async close() {}
+};
+/**
+* Emitted after the server starts accepting requests.
+*/
+var ServerServeEvent = class extends Event {
+	constructor() {
+		super("serve");
+	}
+};
+/**
+* Emitted after the server has fully closed.
+*/
+var ServerCloseEvent = class extends Event {
+	constructor() {
+		super("close");
+	}
+};
+/**
+* Emitted when server startup or runtime handling raises an error.
+*/
+var ServerErrorEvent = class extends Event {
+	error;
+	constructor(error) {
+		super("error");
+		this.error = error;
+	}
+};
+/**
+* Convenience factory for creating a `Server` without `new`.
+*/
+function serve(init) {
+	return new Server(init);
+}
+/**
+* Runtime-agnostic fetch server.
+*
+* `Server` owns middleware composition, per-invocation context setup, background
+* task tracking, and runtime lifecycle coordination. Concrete adapters handle
+* the host-specific details of listening for requests.
+*/
+var Server = class extends EventDispatcher {
+	/**
+	* Server options.
+	*/
+	options;
+	/**
+	* Register a background task that the server should await before closing.
+	*
+	* Same as `request.waitUntil` but available at the server level for use
+	* outside of request handlers.
+	*/
+	waitUntil;
+	#wait;
+	#kernel;
+	#adapter;
+	#url;
+	#adapterPromise;
+	#rejectAdapter;
+	#readyPromise;
+	#rejectReady;
+	#closePromise;
+	/**
+	* Create a server, apply plugins, prepare the runtime adapter, and optionally
+	* start listening immediately.
+	*/
+	constructor({ middleware = [], plugins = [], adapter, ...options }) {
+		super();
+		this.options = {
+			...options,
+			middleware: [...middleware]
+		};
+		for (const plugin of plugins) plugin(this);
+		errorPlugin(this);
+		if (!this.options.fetch) {
+			if (!this.options.routes || !this.options.routes["/*"]) throw new Error("Server requires either `fetch` or a `routes` table with `/*`.");
+		}
+		this.#wait = createWaitUntil();
+		this.waitUntil = this.#wait.waitUntil;
+		this.#kernel = () => {
+			throw new Error("Server request handler is not ready until the runtime adapter finishes initializing.");
+		};
+		const initializeAdapter = (adapter, resolve) => {
+			if (adapter.graceful) gracefulShutdownPlugin(this);
+			const kernel = wrapFetch(this);
+			adapter.setup(this);
+			this.#adapter = adapter;
+			this.#kernel = kernel;
+			if (!options.manual) this.#startServing();
+			resolve?.();
+		};
+		if (adapter) {
+			this.#adapter = adapter;
+			initializeAdapter(adapter);
+			return;
+		}
+		const { promise, resolve, reject } = Promise.withResolvers();
+		this.#adapterPromise = promise;
+		this.#rejectAdapter = reject;
+		promise.catch(() => {}).finally(() => {
+			this.#adapterPromise = void 0;
+			this.#rejectAdapter = void 0;
+		});
+		this.#adapter = new PlaceholderRuntimeAdapter((error, adapter) => {
+			if (adapter != null) initializeAdapter(adapter, resolve);
+			else {
+				reject(error);
+				if (!(error instanceof Error) || error.name !== "AbortError") this.dispatchEvent(new ServerErrorEvent(error));
+			}
+		});
+		this.#adapter.setup(this);
+	}
+	/**
+	* Listener URL reported by the runtime adapter after `serve()` succeeds.
+	*/
+	get url() {
+		return this.#url;
+	}
+	/**
+	* Create a `InvocationContext` view over an arbitrary `Request`.
+	*
+	* This preserves the upstream request object and pairs it with sevok
+	* invocation state such as runtime capabilities, `waitUntil`, and `params`.
+	*/
+	createContext(request, params) {
+		return new InvocationContext({
+			request,
+			capabilities: this.#adapter.capabilities,
+			waitUntil: this.#wait?.waitUntil,
+			params
+		});
+	}
+	/**
+	* Invoke the composed request pipeline directly.
+	*/
+	handle(context) {
+		if (this.#adapterPromise) return this.#adapterPromise.then(() => this.#kernel(context));
+		return this.#kernel(context);
+	}
+	/**
+	* Adapt an arbitrary `Request` into an `InvocationContext` and invoke the handler pipeline.
+	*/
+	async fetch(request) {
+		if (this.#adapterPromise) await this.#adapterPromise;
+		return await this.handle(this.createContext(request));
+	}
+	#startServing() {
+		if (this.#readyPromise) return;
+		const { promise, resolve, reject } = Promise.withResolvers();
+		this.#readyPromise = promise;
+		this.#rejectReady = reject;
+		this.#url = void 0;
+		this.#adapter.serve(this).then((info) => {
+			this.#url = info?.url;
+			this.dispatchEvent(new ServerServeEvent());
+			resolve();
+		}, reject);
+	}
+	/**
+	* Start the runtime adapter if it has not been started already.
+	*
+	* The returned promise resolves once the adapter reports the final listener
+	* URL. Repeated calls reuse the same in-flight startup.
+	*/
+	async serve() {
+		if (this.#readyPromise) return;
+		if (this.#adapterPromise) await this.#adapterPromise;
+		this.#startServing();
+	}
+	/**
+	* Wait until the server has completed startup and then return the instance.
+	*
+	* This is mainly a convenience for fluent startup code.
+	*/
+	async ready() {
+		if (this.#adapterPromise) await this.#adapterPromise;
+		if (!this.#readyPromise) throw new Error("Server has not been started. Call serve() first.");
+		return Promise.resolve(this.#readyPromise).then(() => this);
+	}
+	/**
+	* Close the runtime adapter and wait for outstanding `waitUntil()` tasks.
+	*
+	* If startup was still in progress, `ready()` is rejected with an
+	* `AbortError`.
+	*/
+	async close(closeActiveConnections = false) {
+		if (this.#closePromise) return this.#closePromise;
+		const finalizeClose = async () => {
+			try {
+				if (this.#rejectAdapter) {
+					const error = /* @__PURE__ */ new Error("Server closed before adapter initialization completed.");
+					error.name = "AbortError";
+					this.#rejectAdapter(error);
+				}
+				await Promise.all([this.#adapter.close(closeActiveConnections), this.#wait?.wait()]);
+			} finally {
+				if (this.#rejectReady) {
+					const error = /* @__PURE__ */ new Error("Server closed before becoming ready.");
+					error.name = "AbortError";
+					this.#rejectReady(error);
+					this.#rejectReady = void 0;
+				}
+				this.dispatchEvent(new ServerCloseEvent());
+			}
+		};
+		this.#closePromise = finalizeClose().finally(() => {
+			this.#readyPromise = void 0;
+			this.#closePromise = void 0;
+		});
+		return this.#closePromise;
+	}
+};
+/**
+* Compose fetch handler, middleware, and optional error handling into the
+* single request kernel used by `Server`.
+*/
+function wrapFetch(server) {
+	const fetchHandler = server.options.fetch;
+	const routes = server.options.routes;
+	const middleware = server.options.middleware || [];
+	let handler;
+	if (!routes) {
+		if (!fetchHandler) throw new Error("Server requires either `routes` or `fetch`.");
+		handler = fetchHandler;
+	} else {
+		if (!routes["/*"]) {
+			if (!fetchHandler) throw new Error("Route tables without `/*` require a fallback `fetch` handler.");
+		}
+		handler = unstable_convertRoutesToHandler({
+			input: unstable_buildRouteTree(routes),
+			fallback: fetchHandler,
+			runRouteMiddleware: runMiddleware
+		});
+	}
+	return middleware.length === 0 ? handler : (context) => runMiddleware(context, middleware, 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 };