@wolfstar/plugin-api 1.0.0

package/dist/register.js

@@ -0,0 +1,31 @@
+import { n as loadListeners, r as ApiServer, t as loadMiddlewares } from "./src-CaHcVzFG.js";
+import { Client, Plugin, container, postInitialization, postListen } from "@wolfstar/http-framework";
+//#region src/register.ts
+/**
+* Registers a standalone {@link ApiServer} for auxiliary REST routes (health checks, dashboards,
+* webhooks from other services, etc), independent from the Discord interactions webhook server.
+*
+* Activate by importing the side-effecting entrypoint before creating the client:
+*
+* ```ts
+* import '@wolfstar/plugin-api/register';
+* ```
+*/
+var ApiPlugin = class extends Plugin {
+	static [postInitialization](options) {
+		const server = new ApiServer(options.api);
+		container.stores.register(server.routes).register(server.middlewares);
+		loadListeners().catch((error) => console.error("[plugin-api] Failed to load listeners:", error));
+		loadMiddlewares().catch((error) => console.error("[plugin-api] Failed to load middlewares:", error));
+	}
+	static async [postListen](options) {
+		if ((options.api?.automaticallyConnect ?? true) === false) return;
+		await container.server.connect();
+	}
+};
+Client.plugins.registerPostInitializationHook(ApiPlugin[postInitialization], "WolfStar-Api-PostInitialization");
+Client.plugins.registerPostListenHook(ApiPlugin[postListen], "WolfStar-Api-PostListen");
+//#endregion
+export { ApiPlugin };
+
+//# sourceMappingURL=register.js.map

package/dist/register.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"register.js","names":[],"sources":["../src/register.ts"],"sourcesContent":["import {\n  Client,\n  container,\n  Plugin,\n  postInitialization,\n  postListen,\n  type ClientOptions,\n} from \"@wolfstar/http-framework\";\nimport \"./index\";\nimport { ApiServer } from \"./lib/http/ApiServer\";\nimport { loadListeners } from \"./listeners/_load\";\nimport { loadMiddlewares } from \"./middlewares/_load\";\n\n/**\n * Registers a standalone {@link ApiServer} for auxiliary REST routes (health checks, dashboards,\n * webhooks from other services, etc), independent from the Discord interactions webhook server.\n *\n * Activate by importing the side-effecting entrypoint before creating the client:\n *\n * ```ts\n * import '@wolfstar/plugin-api/register';\n * ```\n */\nexport class ApiPlugin extends Plugin {\n  public static [postInitialization](this: Client, options: ClientOptions): void {\n    const server = new ApiServer(options.api);\n\n    container.stores //\n      .register(server.routes)\n      .register(server.middlewares);\n\n    loadListeners().catch((error: unknown) =>\n      console.error(\"[plugin-api] Failed to load listeners:\", error),\n    );\n    loadMiddlewares().catch((error: unknown) =>\n      console.error(\"[plugin-api] Failed to load middlewares:\", error),\n    );\n  }\n\n  public static async [postListen](this: Client, options: ClientOptions): Promise<void> {\n    if ((options.api?.automaticallyConnect ?? true) === false) return;\n    await container.server.connect();\n  }\n}\n\nClient.plugins.registerPostInitializationHook(\n  ApiPlugin[postInitialization],\n  \"WolfStar-Api-PostInitialization\",\n);\nClient.plugins.registerPostListenHook(ApiPlugin[postListen], \"WolfStar-Api-PostListen\");\n"],"mappings":";;;;;;;;;;;;;AAuBA,IAAa,YAAb,cAA+B,OAAO;CACpC,QAAe,oBAAkC,SAA8B;EAC7E,MAAM,SAAS,IAAI,UAAU,QAAQ,GAAG;EAExC,UAAU,OACP,SAAS,OAAO,MAAM,CAAC,CACvB,SAAS,OAAO,WAAW;EAE9B,cAAc,CAAC,CAAC,OAAO,UACrB,QAAQ,MAAM,0CAA0C,KAAK,CAC/D;EACA,gBAAgB,CAAC,CAAC,OAAO,UACvB,QAAQ,MAAM,4CAA4C,KAAK,CACjE;CACF;CAEA,cAAqB,YAA0B,SAAuC;EACpF,KAAK,QAAQ,KAAK,wBAAwB,UAAU,OAAO;EAC3D,MAAM,UAAU,OAAO,QAAQ;CACjC;AACF;AAEA,OAAO,QAAQ,+BACb,UAAU,qBACV,iCACF;AACA,OAAO,QAAQ,uBAAuB,UAAU,aAAa,yBAAyB"}

package/dist/src-CaHcVzFG.js

@@ -0,0 +1,642 @@
+import { IncomingMessage, ServerResponse, createServer } from "node:http";
+import { HttpCodes, Listener, container } from "@wolfstar/http-framework";
+import { AsyncEventEmitter } from "@vladfrangu/async_event_emitter";
+import { LoaderStrategy, Piece, Store } from "@sapphire/pieces";
+//#region src/lib/http/ApiRequest.ts
+var ApiRequest = class extends IncomingMessage {
+	/**
+	* The parsed query string parameters.
+	*/
+	query = new URLSearchParams();
+	/**
+	* The extracted dynamic (`[param]`) path segment values.
+	*/
+	params = {};
+	/**
+	* The matched router branch for this request's pathname, if any.
+	*/
+	routerNode = null;
+	/**
+	* The matched route for this request's pathname and method, if any.
+	*/
+	route = null;
+	/**
+	* Reads the full request body as a UTF-8 string.
+	* @param limit The maximum number of bytes to read before rejecting. Defaults to 1 MiB.
+	*/
+	async readBodyText(limit = 1024 * 1024) {
+		const chunks = [];
+		let size = 0;
+		for await (const chunk of this) {
+			size += chunk.length;
+			if (size > limit) throw new RangeError(`Request body exceeded the ${limit} byte limit`);
+			chunks.push(chunk);
+		}
+		return Buffer.concat(chunks).toString("utf8");
+	}
+	/**
+	* Reads and parses the request body as JSON.
+	* @param limit The maximum number of bytes to read before rejecting. Defaults to 1 MiB.
+	*/
+	async readBodyJson(limit) {
+		const text = await this.readBodyText(limit);
+		return JSON.parse(text);
+	}
+};
+//#endregion
+//#region src/lib/http/ApiResponse.ts
+var ApiResponse = class extends ServerResponse {
+	status(statusCode) {
+		this.statusCode = statusCode;
+		return this;
+	}
+	json(body, statusCode = HttpCodes.OK) {
+		this.statusCode = statusCode;
+		if (!this.hasHeader("Content-Type")) this.setHeader("Content-Type", "application/json; charset=utf-8");
+		this.end(JSON.stringify(body));
+		return this;
+	}
+	text(body, statusCode = HttpCodes.OK) {
+		this.statusCode = statusCode;
+		if (!this.hasHeader("Content-Type")) this.setHeader("Content-Type", "text/plain; charset=utf-8");
+		this.end(body);
+		return this;
+	}
+	noContent() {
+		this.statusCode = HttpCodes.NoContent;
+		this.end();
+		return this;
+	}
+	notFound(body = { error: "Not Found" }) {
+		return this.json(body, HttpCodes.NotFound);
+	}
+	methodNotAllowed(body = { error: "Method Not Allowed" }) {
+		return this.json(body, HttpCodes.MethodNotAllowed);
+	}
+	badRequest(body = { error: "Bad Request" }) {
+		return this.json(body, HttpCodes.BadRequest);
+	}
+	error(statusCode = HttpCodes.InternalServerError, body = { error: "Internal Server Error" }) {
+		return this.json(body, statusCode);
+	}
+};
+//#endregion
+//#region src/lib/structures/Middleware.ts
+/**
+* A piece that runs on every incoming request, in ascending {@link Middleware.position} order,
+* before route dispatch. A middleware stops the chain implicitly by ending the response
+* (`response.writableEnded`); there is no explicit `next()` callback.
+*/
+var Middleware = class extends Piece {
+	/**
+	* The built-in middlewares use the following positions:
+	* - `headers`: 10 (CORS headers, 404/405 short-circuit)
+	* - `body`: 20 (`Content-Length` validation)
+	*/
+	position;
+	constructor(context, options) {
+		super(context, options);
+		this.position = options.position ?? 1e3;
+	}
+};
+//#endregion
+//#region src/lib/structures/MiddlewareStore.ts
+var MiddlewareStore = class extends Store {
+	/**
+	* Enabled middlewares, kept sorted in ascending {@link Middleware.position} order.
+	*/
+	sortedMiddlewares = [];
+	constructor() {
+		super(Middleware, { name: "middlewares" });
+	}
+	/**
+	* Runs every enabled middleware in order, stopping early once the response has ended.
+	*/
+	async run(request, response) {
+		for (const middleware of this.sortedMiddlewares) {
+			if (response.writableEnded) return;
+			if (middleware.enabled) await middleware.run(request, response);
+		}
+	}
+	set(key, value) {
+		const index = this.sortedMiddlewares.findIndex((middleware) => middleware.position >= value.position);
+		if (index === -1) this.sortedMiddlewares.push(value);
+		else this.sortedMiddlewares.splice(index, 0, value);
+		return super.set(key, value);
+	}
+	delete(key) {
+		const index = this.sortedMiddlewares.findIndex((middleware) => middleware.name === key);
+		if (index !== -1) this.sortedMiddlewares.splice(index, 1);
+		return super.delete(key);
+	}
+	clear() {
+		this.sortedMiddlewares.length = 0;
+		super.clear();
+	}
+};
+//#endregion
+//#region src/lib/http/HttpMethod.ts
+/**
+* The HTTP methods that a {@link Route} can be registered for.
+*/
+const HttpMethods = [
+	"DELETE",
+	"GET",
+	"HEAD",
+	"OPTIONS",
+	"PATCH",
+	"POST",
+	"PUT"
+];
+//#endregion
+//#region src/lib/structures/router/RouterNode.ts
+/**
+* A single path segment's registered routes, keyed by HTTP method.
+*/
+var RouterNode = class extends Map {
+	branch;
+	constructor(branch) {
+		super();
+		this.branch = branch;
+	}
+	/**
+	* Walks up the branch chain collecting the values captured by dynamic (`[param]`) segments.
+	* @param parts The path segments of the matched request, in the same order used to reach this node.
+	*/
+	extractParameters(parts) {
+		const params = {};
+		let branch = this.branch;
+		let index = parts.length - 1;
+		while (branch && branch.parent) {
+			if (branch.dynamic) params[branch.name] = decodeURIComponent(parts[index]);
+			branch = branch.parent;
+			index -= 1;
+		}
+		return params;
+	}
+};
+//#endregion
+//#region src/lib/structures/router/RouterBranch.ts
+/**
+* A single segment of the route trie. Each branch owns exactly one {@link RouterNode} (its
+* method-to-route map) and may have any number of static children plus at most one dynamic
+* (`[param]`) child, which is only checked after every static child fails to match.
+*/
+var RouterBranch = class RouterBranch {
+	name;
+	dynamic;
+	parent;
+	node;
+	staticChildren = [];
+	dynamicChild = null;
+	constructor(name, dynamic, parent) {
+		this.name = name;
+		this.dynamic = dynamic;
+		this.parent = parent;
+		this.node = new RouterNode(this);
+	}
+	matches(part) {
+		return this.dynamic || this.name === part;
+	}
+	insertAt(parts, index, route) {
+		if (index >= parts.length) {
+			for (const method of route.methods) this.node.set(method, route);
+			return this.node;
+		}
+		const part = parts[index];
+		if (part.startsWith("[") && part.endsWith("]")) {
+			if (this.dynamicChild) return this.dynamicChild.insertAt(parts, index + 1, route);
+			const branch = new RouterBranch(part.slice(1, -1), true, this);
+			this.dynamicChild = branch;
+			return branch.insertAt(parts, index + 1, route);
+		}
+		const staticChild = this.staticChildren.find((branch) => branch.name === part);
+		if (staticChild) return staticChild.insertAt(parts, index + 1, route);
+		const branch = new RouterBranch(part, false, this);
+		this.staticChildren.push(branch);
+		return branch.insertAt(parts, index + 1, route);
+	}
+	removeAt(parts, index, route) {
+		if (index >= parts.length) {
+			let removed = false;
+			for (const method of route.methods) if (this.node.delete(method)) removed = true;
+			return removed;
+		}
+		const part = parts[index];
+		const child = this.staticChildren.find((branch) => branch.matches(part)) ?? this.dynamicChild;
+		return child ? child.removeAt(parts, index + 1, route) : false;
+	}
+	findAt(parts, index) {
+		if (index >= parts.length) return this;
+		const part = parts[index];
+		const child = this.staticChildren.find((branch) => branch.matches(part)) ?? this.dynamicChild;
+		return child ? child.findAt(parts, index + 1) : null;
+	}
+};
+//#endregion
+//#region src/lib/structures/router/RouterRoot.ts
+const ROOT_NAME = "::ROOT::";
+/**
+* The root of the route trie, owned by {@link RouteStore.router}. Provides the public
+* add/remove/find API plus the static path-parsing helpers used by {@link Route}'s constructor.
+*/
+var RouterRoot = class extends RouterBranch {
+	constructor() {
+		super(ROOT_NAME, false, null);
+	}
+	add(route) {
+		return this.insertAt(route.path, 0, route);
+	}
+	remove(route) {
+		return this.removeAt(route.path, 0, route);
+	}
+	find(parts) {
+		return this.findAt(parts, 0);
+	}
+	/**
+	* Splits a `/`-delimited path into its non-empty segments.
+	*/
+	static normalize(path) {
+		if (!path) return [];
+		return path.split("/").filter((part) => part.length > 0);
+	}
+	/**
+	* Builds a route path from a piece's directory structure and file name: `(group)`-style
+	* directories are skipped, and a file named `index` collapses into its parent directory.
+	*/
+	static makeRoutePathForPiece(directories, name) {
+		const parts = [];
+		for (const directory of directories) {
+			const trimmed = directory.trim();
+			if (trimmed.length === 0) continue;
+			if (trimmed.startsWith("(") && trimmed.endsWith(")")) continue;
+			parts.push(trimmed);
+		}
+		const trimmedName = name.trim();
+		if (trimmedName !== "index") parts.push(trimmedName);
+		return parts.join("/");
+	}
+	/**
+	* Extracts a trailing `.<method>` suffix from a piece name, e.g. `hello.post` → `POST`.
+	*/
+	static extractMethod(name) {
+		const index = name.lastIndexOf(".");
+		if (index === -1) return null;
+		const method = name.slice(index + 1).toUpperCase();
+		return HttpMethods.includes(method) ? method : null;
+	}
+};
+//#endregion
+//#region src/lib/structures/Route.ts
+/**
+* A single HTTP endpoint. The route's path and methods are either given explicitly via
+* {@link Route.Options.route}/{@link Route.Options.methods}, or inferred from the piece's file
+* system location: directories become path segments (`(group)`-style directories are skipped,
+* `index` collapses into its parent), `[param]` segments become dynamic, and a `.<method>`
+* filename suffix (e.g. `hello.post.ts`) implies that HTTP method.
+*/
+var Route = class extends Piece {
+	/**
+	* The normalized path segments this route is registered under, e.g. `['users', '[id]']`.
+	*/
+	path;
+	/**
+	* The HTTP methods this route responds to.
+	*/
+	methods;
+	constructor(context, options) {
+		super(context, options);
+		const methods = new Set(options.methods ?? []);
+		let path;
+		if (options.route) path = options.route;
+		else {
+			let name = context.name;
+			const implied = RouterRoot.extractMethod(name);
+			if (implied) {
+				name = name.slice(0, name.length - implied.length - 1);
+				methods.add(implied);
+			}
+			path = RouterRoot.makeRoutePathForPiece(this.location.directories, name);
+		}
+		if (methods.size === 0) methods.add("GET");
+		this.path = RouterRoot.normalize(path);
+		this.methods = methods;
+	}
+};
+//#endregion
+//#region src/lib/structures/RouteLoaderStrategy.ts
+/**
+* Keeps {@link RouteStore.router} in sync as route pieces are loaded and unloaded.
+*/
+var RouteLoaderStrategy = class extends LoaderStrategy {
+	onLoad(store, piece) {
+		super.onLoad(store, piece);
+		store.router.add(piece);
+	}
+	onUnload(store, piece) {
+		super.onUnload(store, piece);
+		store.router.remove(piece);
+	}
+};
+//#endregion
+//#region src/lib/structures/RouteStore.ts
+var RouteStore = class extends Store {
+	/**
+	* The trie used to match an incoming request's pathname to a registered {@link Route}.
+	*/
+	router = new RouterRoot();
+	constructor() {
+		super(Route, {
+			name: "routes",
+			strategy: new RouteLoaderStrategy()
+		});
+	}
+};
+//#endregion
+//#region src/lib/http/ApiServer.ts
+let ApiServerEvent = /* @__PURE__ */ function(ApiServerEvent) {
+	ApiServerEvent["Error"] = "error";
+	ApiServerEvent["Request"] = "request";
+	ApiServerEvent["RouterBranchNotFound"] = "routerBranchNotFound";
+	ApiServerEvent["RouterBranchMethodNotAllowed"] = "routerBranchMethodNotAllowed";
+	ApiServerEvent["RouterFound"] = "routerFound";
+	ApiServerEvent["RouteError"] = "routeError";
+	ApiServerEvent["MiddlewareError"] = "middlewareError";
+	return ApiServerEvent;
+}({});
+/**
+* A standalone HTTP server for auxiliary REST routes (health checks, dashboards, webhooks from
+* other services, etc). It is deliberately independent from {@link Client.server}, which is
+* reserved for the Discord interactions webhook.
+*/
+var ApiServer = class extends AsyncEventEmitter {
+	routes;
+	middlewares;
+	server;
+	options;
+	constructor(options = {}) {
+		super();
+		container.server = this;
+		this.options = options;
+		const serverOptions = {
+			...options.server,
+			IncomingMessage: ApiRequest,
+			ServerResponse: ApiResponse
+		};
+		this.server = createServer(serverOptions);
+		this.routes = new RouteStore();
+		this.middlewares = new MiddlewareStore();
+		this.server.on("error", (error) => this.emit("error", error));
+		this.server.on("request", (request, response) => this.emit("request", request, response));
+	}
+	/**
+	* Starts listening for requests.
+	*/
+	connect() {
+		return new Promise((resolve, reject) => {
+			const onError = (error) => {
+				this.server.off("listening", onListening);
+				reject(error);
+			};
+			const onListening = () => {
+				this.server.off("error", onError);
+				resolve();
+			};
+			this.server.once("error", onError);
+			this.server.once("listening", onListening);
+			this.server.listen({
+				port: 4e3,
+				...this.options.listenOptions
+			});
+		});
+	}
+	/**
+	* Stops the server from accepting new connections.
+	*/
+	disconnect() {
+		return new Promise((resolve, reject) => {
+			this.server.close((error) => error ? reject(error) : resolve());
+		});
+	}
+};
+//#endregion
+//#region src/listeners/PluginRouteError.ts
+/**
+* Logs and responds with a 500 when a route's `run` method throws.
+*/
+var PluginRouteErrorListener = class extends Listener {
+	constructor(context) {
+		super(context, {
+			emitter: "server",
+			event: "routeError"
+		});
+	}
+	run(error, _request, response) {
+		console.error("[plugin-api] Route error:", error);
+		if (!response.writableEnded) response.error();
+	}
+};
+//#endregion
+//#region src/listeners/PluginServerMiddlewareError.ts
+/**
+* Logs and responds with a 500 when a middleware throws.
+*/
+var PluginServerMiddlewareErrorListener = class extends Listener {
+	constructor(context) {
+		super(context, {
+			emitter: "server",
+			event: "middlewareError"
+		});
+	}
+	run(error, _request, response) {
+		console.error("[plugin-api] Middleware error:", error);
+		if (!response.writableEnded) response.error();
+	}
+};
+//#endregion
+//#region src/listeners/PluginServerRequest.ts
+/**
+* Parses the request URL, matches it against the route trie, runs every middleware, then emits
+* the outcome (`routerFound`, `routerBranchNotFound`, or `routerBranchMethodNotAllowed`) for the
+* downstream listeners to handle.
+*/
+var PluginServerRequestListener = class extends Listener {
+	constructor(context) {
+		super(context, {
+			emitter: "server",
+			event: "request"
+		});
+	}
+	async run(request, response) {
+		const [pathname, querystring] = splitUrl(request.url);
+		request.query = new URLSearchParams(querystring);
+		const parts = RouterRoot.normalize(pathname);
+		const branch = container.server.routes.router.find(parts);
+		const node = branch?.node ?? null;
+		const route = node?.get(request.method ?? "GET") ?? null;
+		if (node) request.params = node.extractParameters(parts);
+		request.routerNode = branch;
+		request.route = route;
+		try {
+			await container.server.middlewares.run(request, response);
+		} catch (error) {
+			container.server.emit("middlewareError", error, request, response);
+			return;
+		}
+		if (response.writableEnded) return;
+		if (branch === null) container.server.emit("routerBranchNotFound", request, response);
+		else if (route === null) container.server.emit("routerBranchMethodNotAllowed", request, response);
+		else container.server.emit("routerFound", request, response);
+	}
+};
+function splitUrl(url = "/") {
+	const index = url.indexOf("?");
+	return index === -1 ? [url, ""] : [url.slice(0, index), url.slice(index + 1)];
+}
+//#endregion
+//#region src/listeners/PluginServerRouterBranchMethodNotAllowed.ts
+/**
+* Responds with a 405 when the pathname matched but no route handles this HTTP method.
+*/
+var PluginServerRouterBranchMethodNotAllowedListener = class extends Listener {
+	constructor(context) {
+		super(context, {
+			emitter: "server",
+			event: "routerBranchMethodNotAllowed"
+		});
+	}
+	run(_request, response) {
+		if (!response.writableEnded) response.methodNotAllowed();
+	}
+};
+//#endregion
+//#region src/listeners/PluginServerRouterBranchNotFound.ts
+/**
+* Responds with a 404 when no route matched the request's pathname.
+*/
+var PluginServerRouterBranchNotFoundListener = class extends Listener {
+	constructor(context) {
+		super(context, {
+			emitter: "server",
+			event: "routerBranchNotFound"
+		});
+	}
+	run(_request, response) {
+		if (!response.writableEnded) response.notFound();
+	}
+};
+//#endregion
+//#region src/listeners/PluginServerRouterFound.ts
+/**
+* Invokes the matched route's `run` method, emitting `routeError` if it throws.
+*/
+var PluginServerRouterFoundListener = class extends Listener {
+	constructor(context) {
+		super(context, {
+			emitter: "server",
+			event: "routerFound"
+		});
+	}
+	async run(request, response) {
+		try {
+			await request.route.run(request, response);
+		} catch (error) {
+			container.server.emit("routeError", error, request, response);
+		}
+	}
+};
+//#endregion
+//#region src/listeners/_load.ts
+/**
+* Registers the built-in dispatch-pipeline listeners into the framework's existing listener
+* store, targeting the `server` container entry (see {@link ApiServer}).
+*/
+async function loadListeners() {
+	await Promise.all([
+		container.stores.loadPiece({
+			store: "listeners",
+			name: "pluginServerRequest",
+			piece: PluginServerRequestListener
+		}),
+		container.stores.loadPiece({
+			store: "listeners",
+			name: "pluginServerRouterFound",
+			piece: PluginServerRouterFoundListener
+		}),
+		container.stores.loadPiece({
+			store: "listeners",
+			name: "pluginServerRouterBranchNotFound",
+			piece: PluginServerRouterBranchNotFoundListener
+		}),
+		container.stores.loadPiece({
+			store: "listeners",
+			name: "pluginServerRouterBranchMethodNotAllowed",
+			piece: PluginServerRouterBranchMethodNotAllowedListener
+		}),
+		container.stores.loadPiece({
+			store: "listeners",
+			name: "pluginServerMiddlewareError",
+			piece: PluginServerMiddlewareErrorListener
+		}),
+		container.stores.loadPiece({
+			store: "listeners",
+			name: "pluginRouteError",
+			piece: PluginRouteErrorListener
+		})
+	]);
+}
+//#endregion
+//#region src/middlewares/body.ts
+/**
+* Rejects requests whose declared `Content-Length` exceeds {@link ApiServerOptions.maximumBodyLength}.
+* Runs second (position 20), after CORS headers have been set.
+*/
+var BodyMiddleware = class extends Middleware {
+	constructor(context) {
+		super(context, { position: 20 });
+	}
+	run(request, response) {
+		const limit = container.server.options.maximumBodyLength ?? 1024 * 1024 * 50;
+		if (Number(request.headers["content-length"] ?? 0) > limit) response.json({ error: "Payload Too Large" }, HttpCodes.PayloadTooLarge);
+	}
+};
+//#endregion
+//#region src/middlewares/headers.ts
+/**
+* Sets CORS headers on every response and short-circuits `OPTIONS` pre-flight requests.
+* Runs first (position 10); 404/405 handling stays the sole responsibility of the router
+* listeners, so it is not duplicated here.
+*/
+var HeadersMiddleware = class extends Middleware {
+	constructor(context) {
+		super(context, { position: 10 });
+	}
+	run(request, response) {
+		const origin = container.server.options.origin ?? "*";
+		response.setHeader("Access-Control-Allow-Origin", origin);
+		response.setHeader("Access-Control-Allow-Headers", "Content-Type, Authorization");
+		response.setHeader("Access-Control-Allow-Methods", "GET, POST, PUT, PATCH, DELETE, HEAD, OPTIONS");
+		response.setHeader("Date", (/* @__PURE__ */ new Date()).toUTCString());
+		if (request.method === "OPTIONS") response.noContent();
+	}
+};
+//#endregion
+//#region src/middlewares/_load.ts
+/**
+* Registers the built-in middlewares (`headers`, `body`) into {@link ApiServer.middlewares}.
+*/
+async function loadMiddlewares() {
+	await Promise.all([container.stores.loadPiece({
+		store: "middlewares",
+		name: "headers",
+		piece: HeadersMiddleware
+	}), container.stores.loadPiece({
+		store: "middlewares",
+		name: "body",
+		piece: BodyMiddleware
+	})]);
+}
+//#endregion
+export { RouteStore as a, RouterBranch as c, MiddlewareStore as d, Middleware as f, ApiServerEvent as i, RouterNode as l, ApiRequest as m, loadListeners as n, Route as o, ApiResponse as p, ApiServer as r, RouterRoot as s, loadMiddlewares as t, HttpMethods as u };
+
+//# sourceMappingURL=src-CaHcVzFG.js.map