stratal 0.0.27 → 0.1.0

package/dist/hono-app-IhdqL0Fk.mjs

@@ -0,0 +1,399 @@
+import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.mjs";
+import { C as ROUTER_TOKENS, l as Singleton, n as CONTAINER_TOKEN, p as inject, r as DI_TOKENS } from "./di-DQ3xbjgf.mjs";
+import { r as runWithContainer } from "./container-storage-DfF7SXdV.mjs";
+import { n as __decorateParam, t as __decorate } from "./decorate-C79yt3Wt.mjs";
+import { LOGGER_TOKENS } from "./logger/index.mjs";
+import { d as HttpException } from "./errors-CrOXI_y5.mjs";
+import { a as RouterContext, l as ROUTER_CONTEXT_KEYS, r as createHttpExceptionContext } from "./exception-context-CdnGTQNF.mjs";
+import { o as RouterError } from "./module-registry-lkQPDuQe.mjs";
+import { t as isGatewayMode } from "./gateway-mode-0rUaeW3g.mjs";
+import { n as OPENAPI_TOKENS } from "./openapi-tools.service-VKZJlTIX.mjs";
+import { o as createMiddlewareChain, t as RouteRegistrationService } from "./route-registration.service-COKBZTsn.mjs";
+import { i as representationOf, n as setResponseHeaders, o as shouldLoopback, r as REPRESENTATION_PROP, t as isSharedCacheable } from "./response-headers-BqA57S_X.mjs";
+import { d as resolveCachedEntrypoint, l as RESPONSE_CACHE_TOKENS } from "./route-cache-binding-CrLh8tB6.mjs";
+import { n as PER_CALLER_RATE_LIMIT_HEADERS } from "./limit-BE0HNAF6.mjs";
+import { r as resolveTrailingSlash, t as applyTrailingSlash } from "./trailing-slash-2SctvePW.mjs";
+import { Hono } from "hono";
+import { matchedRoutes } from "hono/route";
+//#region src/router/errors/route-not-found.error.ts
+var RouteNotFoundError = class extends HttpException {
+	path;
+	method;
+	constructor(path, method) {
+		super(404, `Route not found: ${method} ${path}`);
+		this.path = path;
+		this.method = method;
+	}
+};
+//#endregion
+//#region src/router/middleware/logger.middleware.ts
+/**
+* Create a Hono middleware that logs HTTP requests using our Logger service
+*
+* Logs request method, path, status code, and duration in milliseconds.
+* Format: [HTTP] METHOD /path -> STATUS (duration ms)
+*
+* @param logger - Logger service instance
+* @returns Hono middleware handler
+*
+* @example
+* ```typescript
+* const logger = container.resolve<LoggerService>(LOGGER_TOKENS.LoggerService)
+* app.use('*', createLoggerMiddleware(logger))
+* ```
+*/
+function createLoggerMiddleware(logger) {
+	return async (c, next) => {
+		const start = Date.now();
+		const method = c.req.method;
+		const path = c.req.path;
+		await next();
+		const duration = Date.now() - start;
+		const status = c.res.status;
+		logger.info(`[HTTP] ${method} ${path} -> ${status}`, {
+			method,
+			path,
+			status,
+			duration
+		});
+	};
+}
+//#endregion
+//#region src/router/nested-dispatch.ts
+/**
+* Requests the application dispatched into its own router while another
+* request was already running.
+*
+* A nested dispatch is not an eyeball request, and the difference is not
+* cosmetic: it exists to render something the caller asked for *indirectly*,
+* so a route is entitled to answer it differently — that is the whole point of
+* one, and the reason a route can recognise it at all. Its response is
+* therefore not the response the same URL would give a client, and anything
+* that stores responses by URL must never see it.
+*
+* The mark lives in a module-private `WeakSet` keyed on the `Request` object,
+* for the reasons `markGatewayMode` uses one for the `ExecutionContext`:
+* nothing reachable from a request can add to it, so it cannot be forged the
+* way a header or a query parameter can. Keyed on the request rather than on
+* the context because a nested dispatch shares the outer request's execution
+* context — it needs the same `waitUntil` and the same bindings — and one
+* `Request` is one dispatch.
+*/
+const NESTED_DISPATCHES = /* @__PURE__ */ new WeakSet();
+/**
+* Mark a request as dispatched into this app from inside another request.
+*
+* Returns the same object it was given, so it can be used inline.
+*/
+function markNestedDispatch(request) {
+	NESTED_DISPATCHES.add(request);
+	return request;
+}
+/** Whether this request was marked by {@link markNestedDispatch}. */
+function isNestedDispatch(request) {
+	return NESTED_DISPATCHES.has(request);
+}
+//#endregion
+//#region src/router/middleware/gateway-dispatch.middleware.ts
+/**
+* `c.executionCtx` is a Hono getter that throws when the context was built
+* without one (a bare `app.fetch(request)`), so it can only be read through a
+* `try`/`catch`.
+*/
+function executionContextOf(c) {
+	try {
+		return c.executionCtx;
+	} catch {
+		return;
+	}
+}
+/**
+* Find the binding for the route that will actually handle this request.
+*
+* `routePath(c)` inside a `use('*')` middleware returns `'*'` — the path *this
+* handler* was registered under, which Hono's own docstring shows — so it
+* cannot be used directly.
+*
+* `matchedRoutes(c)` returns **every** pattern that matched, in registration
+* order, which is more than the one that will run. Scanning it backward is
+* wrong, and dangerously so:
+*
+* ```ts
+* @Get('/summary') @Cacheable({ partitionBy: ['user'] })   summary() {}
+* @Get('/:id')     @Cacheable({ partitionBy: ['tenant'] }) show() {}
+* ```
+*
+* `GET /reports/summary` matches both, and static-before-parameterised is the
+* ordinary registration order. A backward scan picks `/reports/:id` and
+* forwards `{ tenant }`, while the cached entrypoint dispatches `summary()` —
+* storing a per-user response under a tenant-only key, so every user in that
+* tenant is served the first one's page.
+*
+* Scanning **forward from the handler after this middleware** picks the next
+* route that will run, which is the one whose `@Cacheable` governs the
+* response. `c.req.routeIndex` is this middleware's own position in the
+* matched list, so `+ 1` starts at the first candidate.
+*
+* This is the primary defence. `RouteRegistrationService.partitionsResolved`
+* is the second: inside the cached entrypoint it verifies that `ctx.props`
+* actually covers the executing route's declared partitions, so even a
+* mis-selected binding fails closed rather than caching under the wrong key.
+*/
+function lookupRoute(c, table) {
+	const routes = matchedRoutes(c);
+	const method = c.req.method;
+	for (let i = c.req.routeIndex + 1; i < routes.length; i++) {
+		const entry = table.lookup(method, routes[i].path);
+		if (entry) return entry;
+	}
+}
+/**
+* Forward partitioned cacheable reads to the cached entrypoint.
+*
+* Both entrypoints run the *same* Hono app. This middleware is the only thing
+* that differs between them, and it differs on one bit that no client can
+* touch: whether `Stratal.fetch` marked this request's `ExecutionContext` as
+* the gateway (see `markGatewayMode`). In the cached entrypoint the mark is
+* absent, so this is a straight `next()` — which is what makes a loopback
+* loop impossible.
+*
+* In gateway mode, for a `GET`/`HEAD` on a route whose effective `partitionBy`
+* is non-empty, it primes the request container, resolves the declared
+* partitions, and re-dispatches through `ctx.exports.<Cached>({ props })` —
+* `ctx.props` being the part of the Workers Caching key that Cloudflare
+* documents as impossible to bypass, and therefore what keeps one caller's
+* cached response away from another.
+*
+* **Everything else runs inline**, which is always the safe direction: an
+* inline response never enters the cached entrypoint at all, so it can never
+* be stored. That covers a table miss, a non-`GET`/`HEAD` method, a request
+* the app dispatched into itself (`markNestedDispatch`), a primer that
+* short-circuited, and any partition resolver that returned `null`/`undefined`
+* or threw.
+*
+* ### Placement
+*
+* Registered in `HonoApp`'s constructor, after the request-scope and logger
+* middleware and before every application middleware:
+*
+* - **Inside** `createNoStoreFallbackMiddleware`, so a forwarded response that
+*   somehow carried no `Cache-Control` still leaves with an explicit decision.
+* - **Inside** the trailing-slash redirect, so a non-canonical URL is
+*   redirected once, by the gateway, rather than forwarded and cached under a
+*   path that would then redirect again.
+* - **Inside** the request-scope middleware, because primers and partition
+*   resolvers resolve out of the request-scoped container (`ctx.user()` is a
+*   macro over the request-scoped `AuthContext`).
+* - **Inside** the logger middleware, so the gateway logs the requests it
+*   forwards — on a cache hit the app never runs, so this is the only place
+*   that observes them at all.
+* - **Outside** every application middleware (global `Router.use()`,
+*   group/route middleware, guards, validators), because on a cache hit none
+*   of those run. Running them in the gateway would double their side effects
+*   on a miss and produce behaviour a hit could never reproduce.
+*/
+function createGatewayDispatchMiddleware(container) {
+	let table;
+	let looked = false;
+	let bootChecked = false;
+	let bootFailure;
+	return async (c, next) => {
+		if (!looked) {
+			looked = true;
+			table = container.tryResolve(RESPONSE_CACHE_TOKENS.GatewayRouteTable);
+		}
+		const routeTable = table;
+		const entrypoint = routeTable?.entrypoint;
+		if (!routeTable || !entrypoint) return next();
+		const ctx = executionContextOf(c);
+		if (!isGatewayMode(ctx)) return next();
+		if (isNestedDispatch(c.req.raw)) return next();
+		if (!bootChecked) {
+			bootChecked = true;
+			try {
+				resolveCachedEntrypoint(ctx, entrypoint);
+			} catch (error) {
+				bootFailure = error;
+			}
+		}
+		if (bootFailure) throw bootFailure;
+		if (routeTable.isEmpty) return next();
+		const entry = lookupRoute(c, routeTable);
+		if (!entry) return next();
+		if (!shouldLoopback(c.req.method, entry)) return next();
+		const routerContext = new RouterContext(c);
+		const primers = container.tryResolve(RESPONSE_CACHE_TOKENS.GatewayPrimerService);
+		if (primers && !await primers.prime(routerContext)) return next();
+		const resolver = container.tryResolve(RESPONSE_CACHE_TOKENS.PartitionResolverService);
+		if (!resolver) return next();
+		const { props, resolved } = await resolver.resolve(routerContext, entry.partitionBy);
+		if (!resolved) return next();
+		const representation = representationOf(c.req.raw.headers, routeTable.keyBy);
+		if (representation !== void 0) props[REPRESENTATION_PROP] = representation;
+		return resolveCachedEntrypoint(ctx, entrypoint)({ props }).fetch(c.req.raw);
+	};
+}
+//#endregion
+//#region src/router/middleware/no-store-fallback.middleware.ts
+const NO_STORE = "private, no-store";
+/** `{ 'X-RateLimit-Limit': null, … }` — the delete form `setResponseHeaders` takes. */
+const DROP_PER_CALLER_HEADERS = Object.fromEntries(PER_CALLER_RATE_LIMIT_HEADERS.map((name) => [name, null]));
+/**
+* The single outermost safety net behind Stratal's caching-decision
+* guarantee: every response leaving a Stratal app carries an explicit
+* `Cache-Control` header. Workers Caching applies RFC 9111 heuristic
+* freshness to anything that doesn't — a header-less `200` is cached for two
+* hours (§4.2.1), and `404`/`405`/`410`/`501` are heuristically cacheable too
+* (§4.2.2), same for a redirect like the trailing-slash `308`.
+*
+* `RouteRegistrationService.applyCacheDecision` already stamps a decision for
+* every ordinary controller response — `@Cacheable` routes get their computed
+* headers, everything else is left alone for this middleware to catch. This
+* is the backstop for everything that path never sees: thrown errors (404s,
+* 500s rendered by the exception handler), guard/scoped-middleware
+* short-circuits (`wrapHandlerWithChain` returning a middleware's `Response`
+* directly), the trailing-slash redirect, wildcard/`@All` controller routes,
+* and any future response path that forgets to call it.
+*
+* Registered as the very first global middleware, so it wraps everything
+* else. Hono's `compose()` fully resolves a thrown error or a middleware
+* short-circuit into `context.res` at the layer where it happens, then
+* returns *normally* to every middleware further out — the same guarantee
+* `createLoggerMiddleware` already depends on to log the right status for a
+* 404. By the time `next()` resolves here, `c.res` holds the final response,
+* whichever code path produced it.
+*/
+function createNoStoreFallbackMiddleware() {
+	return async (c, next) => {
+		await next();
+		if (!c.res.headers.has("Cache-Control")) {
+			const stamped = setResponseHeaders(c.res, { "Cache-Control": NO_STORE });
+			if (stamped !== c.res) c.res = stamped;
+		}
+		if (isSharedCacheable(c.res)) {
+			const stripped = setResponseHeaders(c.res, DROP_PER_CALLER_HEADERS);
+			if (stripped !== c.res) c.res = stripped;
+		}
+	};
+}
+//#endregion
+//#region src/router/middleware/trailing-slash-redirect.ts
+const REDIRECT_STATUS = 308;
+/**
+* Create a Hono middleware that canonicalises trailing slashes via 308 redirects.
+*
+* - `'ignore'` — returns `null`; routes match both `/foo` and `/foo/` natively
+*   (Hono handles this when constructed with `strict: false`).
+* - `'always'` — non-trailing requests redirect to the trailing-slash form.
+*   Paths whose last segment contains `.` (e.g. `/api/openapi.json`) are skipped.
+* - `'never'`  — trailing requests redirect to the non-trailing form.
+*
+* Paths in the config's `exclude` list are never redirected — both forms
+* are served as requested (routes match either, `strict: false`). When
+* `getLocales` is provided, exclusions also match locale-prefixed request
+* paths (`/fr/callback` for exclude `'/callback'`). It is a thunk because
+* the middleware is created before the i18n module resolves its locales.
+*
+* Root (`/`) is always passed through unchanged.
+*
+* 308 is used so that POST/PUT/PATCH bodies survive the redirect.
+*
+* Location headers are emitted as path-relative URIs so the user agent
+* resolves them against the effective request URI — sidestepping scheme
+* mismatches behind HTTPS-terminating proxies that proxy HTTPS pages to an
+* HTTP-speaking backend (which would otherwise produce a mixed-content block).
+*/
+function createTrailingSlashRedirect(config, getLocales) {
+	const options = resolveTrailingSlash(config);
+	if (options.mode === "ignore") return null;
+	return async (c, next) => {
+		const url = new URL(c.req.url);
+		const canonicalPath = applyTrailingSlash(url.pathname, options, getLocales?.());
+		if (canonicalPath === url.pathname) return next();
+		return c.redirect(`${canonicalPath}${url.search}`, REDIRECT_STATUS);
+	};
+}
+//#endregion
+//#region src/router/hono-app.ts
+var hono_app_exports = /* @__PURE__ */ __exportAll({ HonoApp: () => HonoApp });
+const isMiddlewareClass = (arg) => typeof arg === "function" && arg.prototype && "handle" in arg.prototype;
+let HonoApp = class HonoApp extends Hono {
+	configured = false;
+	_container;
+	_logger;
+	/**
+	* Reference to the original Hono `use` implementation.
+	* Captured in constructor after super() sets it as an instance property.
+	* Used by private methods to register middleware without going through the override.
+	*/
+	nativeUse;
+	constructor(container, logger, application) {
+		const trailingSlash = application.config.trailingSlash ?? "ignore";
+		super({ strict: false });
+		this._container = container;
+		this._logger = logger;
+		this.nativeUse = this.use;
+		this.use = ((...args) => {
+			if (isMiddlewareClass(args[0])) {
+				this.nativeUse("*", createMiddlewareChain(args));
+				return this;
+			}
+			if (typeof args[0] === "string" && args.length > 1 && isMiddlewareClass(args[1])) {
+				this.nativeUse(args[0], createMiddlewareChain(args.slice(1)));
+				return this;
+			}
+			return this.nativeUse(...args);
+		});
+		this.nativeUse("*", createNoStoreFallbackMiddleware());
+		const trailingSlashRedirect = createTrailingSlashRedirect(trailingSlash, () => this._container.tryResolve(ROUTER_TOKENS.LocalePathService)?.localePathConfig?.allLocales);
+		if (trailingSlashRedirect) this.nativeUse("*", trailingSlashRedirect);
+		this.setupRequestScope();
+		this.applyGlobalMiddleware();
+	}
+	/**
+	* Apply global middleware (logger + error handler).
+	* Called by Application after locale middleware is applied by LocalePathService.
+	*/
+	applyGlobalMiddleware() {
+		this.nativeUse("*", createLoggerMiddleware(this._logger));
+		this.nativeUse("*", createGatewayDispatchMiddleware(this._container));
+		this.onError((err, c) => this.handleException(c, err));
+	}
+	/**
+	* Configure OpenAPI endpoints, controller routes, and 404 handler.
+	* Called once by Application.initialize().
+	*/
+	async configure() {
+		if (this.configured) throw new RouterError("HonoApp has already been configured");
+		this._container.resolve(OPENAPI_TOKENS.OpenAPIService).setupEndpoints(this, this._container);
+		await this._container.resolve(RouteRegistrationService).configure();
+		this.notFound((c) => {
+			throw new RouteNotFoundError(c.req.path, c.req.method);
+		});
+		this.configured = true;
+	}
+	setupRequestScope() {
+		this.nativeUse("*", async (c, next) => {
+			const routerContext = new RouterContext(c);
+			const requestContainer = this._container.createRequestScope(routerContext);
+			c.set(ROUTER_CONTEXT_KEYS.REQUEST_CONTAINER, requestContainer);
+			await runWithContainer(requestContainer, next);
+		});
+	}
+	handleException(c, err) {
+		const requestContainer = c.get(ROUTER_CONTEXT_KEYS.REQUEST_CONTAINER) ?? this._container;
+		const handler = requestContainer.resolve(DI_TOKENS.ExceptionHandler);
+		const ctx = createHttpExceptionContext(c);
+		return runWithContainer(requestContainer, () => handler.handle(err, ctx));
+	}
+};
+HonoApp = __decorate([
+	Singleton(),
+	__decorateParam(0, inject(CONTAINER_TOKEN)),
+	__decorateParam(1, inject(LOGGER_TOKENS.LoggerService)),
+	__decorateParam(2, inject(DI_TOKENS.Application))
+], HonoApp);
+//#endregion
+export { RouteNotFoundError as a, markNestedDispatch as i, hono_app_exports as n, isNestedDispatch as r, HonoApp as t };
+
+//# sourceMappingURL=hono-app-IhdqL0Fk.mjs.map

package/dist/hono-app-IhdqL0Fk.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"hono-app-IhdqL0Fk.mjs","names":[],"sources":["../src/router/errors/route-not-found.error.ts","../src/router/middleware/logger.middleware.ts","../src/router/nested-dispatch.ts","../src/router/middleware/gateway-dispatch.middleware.ts","../src/router/middleware/no-store-fallback.middleware.ts","../src/router/middleware/trailing-slash-redirect.ts","../src/router/hono-app.ts"],"sourcesContent":["import { HttpException } from '../../errors'\n\nexport class RouteNotFoundError extends HttpException {\n  public readonly path: string\n  public readonly method: string\n\n  constructor(path: string, method: string) {\n    super(404, `Route not found: ${method} ${path}`)\n    this.path = path\n    this.method = method\n  }\n}\n","import type { MiddlewareHandler } from 'hono'\nimport type { LoggerService } from '../../logger'\n\n/**\n * Create a Hono middleware that logs HTTP requests using our Logger service\n *\n * Logs request method, path, status code, and duration in milliseconds.\n * Format: [HTTP] METHOD /path -> STATUS (duration ms)\n *\n * @param logger - Logger service instance\n * @returns Hono middleware handler\n *\n * @example\n * ```typescript\n * const logger = container.resolve<LoggerService>(LOGGER_TOKENS.LoggerService)\n * app.use('*', createLoggerMiddleware(logger))\n * ```\n */\nexport function createLoggerMiddleware(logger: LoggerService): MiddlewareHandler {\n  return async (c, next) => {\n    const start = Date.now()\n    const method = c.req.method\n    const path = c.req.path\n\n    await next()\n\n    const duration = Date.now() - start\n    const status = c.res.status\n\n    logger.info(`[HTTP] ${method} ${path} -> ${status}`, {\n      method,\n      path,\n      status,\n      duration,\n    })\n  }\n}\n","/**\n * Requests the application dispatched into its own router while another\n * request was already running.\n *\n * A nested dispatch is not an eyeball request, and the difference is not\n * cosmetic: it exists to render something the caller asked for *indirectly*,\n * so a route is entitled to answer it differently — that is the whole point of\n * one, and the reason a route can recognise it at all. Its response is\n * therefore not the response the same URL would give a client, and anything\n * that stores responses by URL must never see it.\n *\n * The mark lives in a module-private `WeakSet` keyed on the `Request` object,\n * for the reasons `markGatewayMode` uses one for the `ExecutionContext`:\n * nothing reachable from a request can add to it, so it cannot be forged the\n * way a header or a query parameter can. Keyed on the request rather than on\n * the context because a nested dispatch shares the outer request's execution\n * context — it needs the same `waitUntil` and the same bindings — and one\n * `Request` is one dispatch.\n */\nconst NESTED_DISPATCHES = new WeakSet<Request>()\n\n/**\n * Mark a request as dispatched into this app from inside another request.\n *\n * Returns the same object it was given, so it can be used inline.\n */\nexport function markNestedDispatch(request: Request): Request {\n  NESTED_DISPATCHES.add(request)\n  return request\n}\n\n/** Whether this request was marked by {@link markNestedDispatch}. */\nexport function isNestedDispatch(request: Request): boolean {\n  return NESTED_DISPATCHES.has(request)\n}\n","import type { Context, MiddlewareHandler } from 'hono'\nimport { matchedRoutes } from 'hono/route'\nimport type { Container } from '../../di/container'\nimport { shouldLoopback } from '../../response-cache/cached-entrypoint'\nimport { resolveCachedEntrypoint } from '../../response-cache/gateway-binding'\nimport { isGatewayMode } from '../../response-cache/gateway-mode'\nimport { REPRESENTATION_PROP, representationOf } from '../../response-cache/representation'\nimport { RESPONSE_CACHE_TOKENS } from '../../response-cache/response-cache.tokens'\nimport type { GatewayPrimerService } from '../../response-cache/services/gateway-primer.service'\nimport type { GatewayRouteEntry, GatewayRouteTable } from '../../response-cache/services/gateway-route-table'\nimport type { PartitionResolverService } from '../../response-cache/services/partition-resolver.service'\nimport { isNestedDispatch } from '../nested-dispatch'\nimport { RouterContext } from '../router-context'\nimport type { RouterEnv } from '../types'\n\n/**\n * `c.executionCtx` is a Hono getter that throws when the context was built\n * without one (a bare `app.fetch(request)`), so it can only be read through a\n * `try`/`catch`.\n */\nfunction executionContextOf(c: Context<RouterEnv>): unknown {\n  try {\n    return c.executionCtx\n  } catch {\n    return undefined\n  }\n}\n\n/**\n * Find the binding for the route that will actually handle this request.\n *\n * `routePath(c)` inside a `use('*')` middleware returns `'*'` — the path *this\n * handler* was registered under, which Hono's own docstring shows — so it\n * cannot be used directly.\n *\n * `matchedRoutes(c)` returns **every** pattern that matched, in registration\n * order, which is more than the one that will run. Scanning it backward is\n * wrong, and dangerously so:\n *\n * ```ts\n * @Get('/summary') @Cacheable({ partitionBy: ['user'] })   summary() {}\n * @Get('/:id')     @Cacheable({ partitionBy: ['tenant'] }) show() {}\n * ```\n *\n * `GET /reports/summary` matches both, and static-before-parameterised is the\n * ordinary registration order. A backward scan picks `/reports/:id` and\n * forwards `{ tenant }`, while the cached entrypoint dispatches `summary()` —\n * storing a per-user response under a tenant-only key, so every user in that\n * tenant is served the first one's page.\n *\n * Scanning **forward from the handler after this middleware** picks the next\n * route that will run, which is the one whose `@Cacheable` governs the\n * response. `c.req.routeIndex` is this middleware's own position in the\n * matched list, so `+ 1` starts at the first candidate.\n *\n * This is the primary defence. `RouteRegistrationService.partitionsResolved`\n * is the second: inside the cached entrypoint it verifies that `ctx.props`\n * actually covers the executing route's declared partitions, so even a\n * mis-selected binding fails closed rather than caching under the wrong key.\n */\nfunction lookupRoute(\n  c: Context<RouterEnv>,\n  table: GatewayRouteTable,\n): GatewayRouteEntry | undefined {\n  const routes = matchedRoutes(c)\n  const method = c.req.method\n\n  for (let i = c.req.routeIndex + 1; i < routes.length; i++) {\n    const entry = table.lookup(method, routes[i].path)\n    if (entry) return entry\n  }\n\n  return undefined\n}\n\n/**\n * Forward partitioned cacheable reads to the cached entrypoint.\n *\n * Both entrypoints run the *same* Hono app. This middleware is the only thing\n * that differs between them, and it differs on one bit that no client can\n * touch: whether `Stratal.fetch` marked this request's `ExecutionContext` as\n * the gateway (see `markGatewayMode`). In the cached entrypoint the mark is\n * absent, so this is a straight `next()` — which is what makes a loopback\n * loop impossible.\n *\n * In gateway mode, for a `GET`/`HEAD` on a route whose effective `partitionBy`\n * is non-empty, it primes the request container, resolves the declared\n * partitions, and re-dispatches through `ctx.exports.<Cached>({ props })` —\n * `ctx.props` being the part of the Workers Caching key that Cloudflare\n * documents as impossible to bypass, and therefore what keeps one caller's\n * cached response away from another.\n *\n * **Everything else runs inline**, which is always the safe direction: an\n * inline response never enters the cached entrypoint at all, so it can never\n * be stored. That covers a table miss, a non-`GET`/`HEAD` method, a request\n * the app dispatched into itself (`markNestedDispatch`), a primer that\n * short-circuited, and any partition resolver that returned `null`/`undefined`\n * or threw.\n *\n * ### Placement\n *\n * Registered in `HonoApp`'s constructor, after the request-scope and logger\n * middleware and before every application middleware:\n *\n * - **Inside** `createNoStoreFallbackMiddleware`, so a forwarded response that\n *   somehow carried no `Cache-Control` still leaves with an explicit decision.\n * - **Inside** the trailing-slash redirect, so a non-canonical URL is\n *   redirected once, by the gateway, rather than forwarded and cached under a\n *   path that would then redirect again.\n * - **Inside** the request-scope middleware, because primers and partition\n *   resolvers resolve out of the request-scoped container (`ctx.user()` is a\n *   macro over the request-scoped `AuthContext`).\n * - **Inside** the logger middleware, so the gateway logs the requests it\n *   forwards — on a cache hit the app never runs, so this is the only place\n *   that observes them at all.\n * - **Outside** every application middleware (global `Router.use()`,\n *   group/route middleware, guards, validators), because on a cache hit none\n *   of those run. Running them in the gateway would double their side effects\n *   on a miss and produce behaviour a hit could never reproduce.\n */\nexport function createGatewayDispatchMiddleware(container: Container): MiddlewareHandler<RouterEnv> {\n  // `ResponseCacheModule` is opt-in and registers after `HonoApp` is\n  // constructed, so the table is looked up on first use, not here. The\n  // separate `looked` flag matters: `??=` would reassign on every request for\n  // apps *without* the module — exactly the apps that must pay nothing —\n  // because `tryResolve` keeps returning `undefined`, so the memo never takes.\n  let table: GatewayRouteTable | undefined\n  let looked = false\n\n  // Latches the *result* of the `ctx.exports` reachability check, not merely\n  // that it ran. A typo'd entrypoint name cannot start resolving later in the\n  // isolate's life, so failing exactly one arbitrary request and then silently\n  // running every partitioned route inline forever is the outcome to avoid.\n  let bootChecked = false\n  let bootFailure: Error | undefined\n\n  return async (c, next) => {\n    // Deliberately before the `executionCtx` read. `c.executionCtx` is a getter\n    // that *throws* when the context was built without one, and a caught throw\n    // per request is far from free — the request/response benchmark moved 2-5%\n    // when this ran first. Checking the memoised table costs a boolean and a\n    // property read, and short-circuits every app that configures no gateway,\n    // which is the population that must pay as close to nothing as possible.\n    if (!looked) {\n      looked = true\n      table = container.tryResolve<GatewayRouteTable>(RESPONSE_CACHE_TOKENS.GatewayRouteTable)\n    }\n\n    const routeTable = table\n    const entrypoint = routeTable?.entrypoint\n    if (!routeTable || !entrypoint) return next()\n\n    const ctx = executionContextOf(c)\n    if (!isGatewayMode(ctx)) return next()\n\n    // A request the app dispatched into itself renders inline, always. It can\n    // be answered differently from the same URL asked for by a client — that\n    // is what a route recognising one is for — so forwarding it would store\n    // that answer under the client's key, and hand it to the next client the\n    // key matches. It is also the only request whose answer depends on\n    // reaching the same isolate: a route tells a nested dispatch apart from a\n    // client by a value minted in this one, which nothing on the far side of\n    // `ctx.exports` can be handed.\n    if (isNestedDispatch(c.req.raw)) return next()\n\n    if (!bootChecked) {\n      bootChecked = true\n      try {\n        resolveCachedEntrypoint(ctx, entrypoint)\n      } catch (error) {\n        bootFailure = error as Error\n      }\n    }\n    if (bootFailure) throw bootFailure\n\n    // An app that configures a gateway but declares no partitioned route pays\n    // exactly this check per request.\n    if (routeTable.isEmpty) return next()\n\n    const entry = lookupRoute(c, routeTable)\n    if (!entry) return next()\n    if (!shouldLoopback(c.req.method, entry)) return next()\n\n    const routerContext = new RouterContext(c)\n\n    const primers = container.tryResolve<GatewayPrimerService>(RESPONSE_CACHE_TOKENS.GatewayPrimerService)\n    if (primers && !(await primers.prime(routerContext))) return next()\n\n    const resolver = container.tryResolve<PartitionResolverService>(\n      RESPONSE_CACHE_TOKENS.PartitionResolverService,\n    )\n    if (!resolver) return next()\n\n    const { props, resolved } = await resolver.resolve(routerContext, entry.partitionBy)\n    if (!resolved) return next()\n\n    // The representation joins the partitions in the key. A route that answers\n    // one URL with both a document and a JSON payload has two bodies to keep\n    // apart, and `Vary` alone has been measured failing to keep them apart on a\n    // URL with a query string — see `representation.ts`.\n    const representation = representationOf(c.req.raw.headers, routeTable.keyBy)\n    if (representation !== undefined) props[REPRESENTATION_PROP] = representation\n\n    // The callable form of a loopback binding is what selects the callee's\n    // `ctx.props`; `.fetch` on the binding itself would forward with the\n    // gateway's own props and collapse every caller onto one cache entry.\n    return resolveCachedEntrypoint(ctx, entrypoint)({ props }).fetch(c.req.raw)\n  }\n}\n","import type { MiddlewareHandler } from 'hono'\nimport { PER_CALLER_RATE_LIMIT_HEADERS } from '../../rate-limiter/limit'\nimport { isSharedCacheable, setResponseHeaders } from '../../response-cache/response-headers'\nimport type { RouterEnv } from '../types'\n\nconst NO_STORE = 'private, no-store'\n\n/** `{ 'X-RateLimit-Limit': null, … }` — the delete form `setResponseHeaders` takes. */\nconst DROP_PER_CALLER_HEADERS = Object.fromEntries(\n  PER_CALLER_RATE_LIMIT_HEADERS.map((name) => [name, null]),\n) as Record<string, string | null>\n\n/**\n * The single outermost safety net behind Stratal's caching-decision\n * guarantee: every response leaving a Stratal app carries an explicit\n * `Cache-Control` header. Workers Caching applies RFC 9111 heuristic\n * freshness to anything that doesn't — a header-less `200` is cached for two\n * hours (§4.2.1), and `404`/`405`/`410`/`501` are heuristically cacheable too\n * (§4.2.2), same for a redirect like the trailing-slash `308`.\n *\n * `RouteRegistrationService.applyCacheDecision` already stamps a decision for\n * every ordinary controller response — `@Cacheable` routes get their computed\n * headers, everything else is left alone for this middleware to catch. This\n * is the backstop for everything that path never sees: thrown errors (404s,\n * 500s rendered by the exception handler), guard/scoped-middleware\n * short-circuits (`wrapHandlerWithChain` returning a middleware's `Response`\n * directly), the trailing-slash redirect, wildcard/`@All` controller routes,\n * and any future response path that forgets to call it.\n *\n * Registered as the very first global middleware, so it wraps everything\n * else. Hono's `compose()` fully resolves a thrown error or a middleware\n * short-circuit into `context.res` at the layer where it happens, then\n * returns *normally* to every middleware further out — the same guarantee\n * `createLoggerMiddleware` already depends on to log the right status for a\n * 404. By the time `next()` resolves here, `c.res` holds the final response,\n * whichever code path produced it.\n */\nexport function createNoStoreFallbackMiddleware(): MiddlewareHandler<RouterEnv> {\n  return async (c, next) => {\n    await next()\n\n    if (!c.res.headers.has('Cache-Control')) {\n      const stamped = setResponseHeaders(c.res, { 'Cache-Control': NO_STORE })\n      // Only reassign `c.res` when a new object was actually produced —\n      // Hono's `res` setter merges the *previous* `c.res`'s headers onto\n      // whatever is assigned, so reassigning the same (in-place-mutated)\n      // object would immediately re-clone it for nothing.\n      if (stamped !== c.res) c.res = stamped\n    }\n\n    // `X-RateLimit-*` describe one caller's remaining budget, so they must not survive on a\n    // response a shared cache may store: the entry is replayed to every other caller, and a cache\n    // hit never runs the throttle middleware, so the figure counts down for nobody.\n    //\n    // This is the only layer where the cache decision is already on the response — it is stamped\n    // inside the route handler, and Hono's `res` setter merges headers as the chain unwinds, so a\n    // middleware testing `Cache-Control` after its own `next()` races the header it depends on.\n    //\n    // The limit is still consumed and enforced; only the reporting is withheld.\n    if (isSharedCacheable(c.res)) {\n      const stripped = setResponseHeaders(c.res, DROP_PER_CALLER_HEADERS)\n      if (stripped !== c.res) c.res = stripped\n    }\n  }\n}\n","import type { MiddlewareHandler } from 'hono'\nimport { applyTrailingSlash, resolveTrailingSlash } from '../trailing-slash'\nimport type { RouterEnv, TrailingSlashConfig } from '../types'\n\nconst REDIRECT_STATUS = 308\n\n/**\n * Create a Hono middleware that canonicalises trailing slashes via 308 redirects.\n *\n * - `'ignore'` — returns `null`; routes match both `/foo` and `/foo/` natively\n *   (Hono handles this when constructed with `strict: false`).\n * - `'always'` — non-trailing requests redirect to the trailing-slash form.\n *   Paths whose last segment contains `.` (e.g. `/api/openapi.json`) are skipped.\n * - `'never'`  — trailing requests redirect to the non-trailing form.\n *\n * Paths in the config's `exclude` list are never redirected — both forms\n * are served as requested (routes match either, `strict: false`). When\n * `getLocales` is provided, exclusions also match locale-prefixed request\n * paths (`/fr/callback` for exclude `'/callback'`). It is a thunk because\n * the middleware is created before the i18n module resolves its locales.\n *\n * Root (`/`) is always passed through unchanged.\n *\n * 308 is used so that POST/PUT/PATCH bodies survive the redirect.\n *\n * Location headers are emitted as path-relative URIs so the user agent\n * resolves them against the effective request URI — sidestepping scheme\n * mismatches behind HTTPS-terminating proxies that proxy HTTPS pages to an\n * HTTP-speaking backend (which would otherwise produce a mixed-content block).\n */\nexport function createTrailingSlashRedirect(\n  config: TrailingSlashConfig,\n  getLocales?: () => readonly string[] | undefined,\n): MiddlewareHandler<RouterEnv> | null {\n  const options = resolveTrailingSlash(config)\n  if (options.mode === 'ignore') return null\n\n  return async (c, next) => {\n    const url = new URL(c.req.url)\n    const canonicalPath = applyTrailingSlash(url.pathname, options, getLocales?.())\n    if (canonicalPath === url.pathname) return next()\n    return c.redirect(`${canonicalPath}${url.search}`, REDIRECT_STATUS)\n  }\n}\n","import { Hono } from 'hono'\nimport type { Context, MiddlewareHandler } from 'hono'\nimport { inject } from '../di'\nimport type { Application } from '../application'\nimport type { Container } from '../di/container'\nimport { runWithContainer } from '../di/container-storage'\nimport { Singleton } from '../di/decorators'\nimport { CONTAINER_TOKEN, DI_TOKENS } from '../di/tokens'\nimport { createHttpExceptionContext } from '../errors/exception-context'\nimport type { ExceptionHandler } from '../errors/exception-handler'\nimport { LOGGER_TOKENS, type LoggerService } from '../logger'\nimport { OPENAPI_TOKENS, type OpenAPIService } from '../openapi'\nimport type { Constructor } from '../types'\nimport { ROUTER_CONTEXT_KEYS } from './constants'\nimport { RouteNotFoundError } from './errors'\nimport { RouterError } from './router.error'\nimport { createGatewayDispatchMiddleware, createLoggerMiddleware, createMiddlewareChain, createNoStoreFallbackMiddleware, createTrailingSlashRedirect } from './middleware'\nimport type { Middleware } from './middleware.interface'\nimport { RouterContext } from './router-context'\nimport { ROUTER_TOKENS } from './router.tokens'\nimport type { LocalePathService } from './services/locale-path.service'\nimport { RouteRegistrationService } from './services/route-registration.service'\nimport type { RouterEnv, TrailingSlashConfig } from './types'\n\nconst isMiddlewareClass = (arg: unknown): arg is Constructor<Middleware> =>\n  // eslint-disable-next-line @typescript-eslint/no-unsafe-return\n  typeof arg === 'function' && arg.prototype && 'handle' in arg.prototype\n\n\n/**\n * HonoApp — extends plain Hono with Stratal-specific setup\n *\n * - Request scope middleware (child container per request)\n * - Global middleware (CORS, logging, error handling)\n * - `use()` overload for Stratal middleware classes\n * - `configure()` for OpenAPI, routes, and 404\n *\n * Request validation is attached per-route via `hono/validator` middleware (see\n * route-registration), not a base-class hook, so schema-less routes pull in no\n * validation/zod code.\n */\n@Singleton()\nexport class HonoApp extends Hono<RouterEnv> {\n  private configured = false\n  private readonly _container: Container\n  private readonly _logger: LoggerService\n\n  /**\n   * Reference to the original Hono `use` implementation.\n   * Captured in constructor after super() sets it as an instance property.\n   * Used by private methods to register middleware without going through the override.\n   */\n  private nativeUse!: typeof this.use\n\n  constructor(\n    @inject(CONTAINER_TOKEN) container: Container,\n    @inject(LOGGER_TOKENS.LoggerService) logger: LoggerService,\n    @inject(DI_TOKENS.Application) application: Application,\n  ) {\n    const trailingSlash: TrailingSlashConfig = application.config.trailingSlash ?? 'ignore'\n\n    super({\n      // Always non-strict: a registered `/foo` route matches both `/foo` and `/foo/`.\n      // For the redirect modes, the trailing-slash middleware runs first and\n      // canonicalises via 308 before matching reaches the registered route.\n      strict: false,\n    })\n\n    this._container = container\n    this._logger = logger\n\n    // Capture Hono's original `use` (set by super() as an instance property)\n    this.nativeUse = this.use\n\n    // Override `use` to support Stratal middleware classes alongside Hono-native handlers\n    this.use = ((...args: unknown[]) => {\n      if (isMiddlewareClass(args[0])) {\n        this.nativeUse('*', createMiddlewareChain(args as Constructor<Middleware>[]))\n        return this\n      }\n\n      if (typeof args[0] === 'string' && args.length > 1 && isMiddlewareClass(args[1])) {\n        this.nativeUse(args[0], createMiddlewareChain(args.slice(1) as Constructor<Middleware>[]))\n        return this\n      }\n\n      return (this.nativeUse as (...a: unknown[]) => unknown)(...args)\n    }) as typeof this.use\n\n    // Registered before anything else — including the trailing-slash\n    // redirect — so it wraps every other middleware, every route, and every\n    // error path. See its own docstring for why registration order matters\n    // here: it relies on Hono's compose() resolving thrown errors and\n    // short-circuits into `context.res` before unwinding back through\n    // earlier middleware, so it only needs to run once, after `next()`.\n    this.nativeUse('*', createNoStoreFallbackMiddleware())\n\n    // Trailing-slash redirect runs first (of the request-handling middleware)\n    // so redirected requests skip request-scope and logger overhead. Locales\n    // are read lazily — the i18n module (and thus LocalePathService)\n    // initialises after HonoApp is constructed.\n    const trailingSlashRedirect = createTrailingSlashRedirect(trailingSlash, () =>\n      this._container.tryResolve<LocalePathService>(ROUTER_TOKENS.LocalePathService)?.localePathConfig?.allLocales)\n    if (trailingSlashRedirect) {\n      this.nativeUse('*', trailingSlashRedirect)\n    }\n\n    // Internal setup — uses nativeUse to bypass the override\n    this.setupRequestScope()\n    this.applyGlobalMiddleware()\n  }\n\n  /**\n   * Apply global middleware (logger + error handler).\n   * Called by Application after locale middleware is applied by LocalePathService.\n   */\n  private applyGlobalMiddleware(): void {\n    this.nativeUse('*', createLoggerMiddleware(this._logger) as MiddlewareHandler<RouterEnv>)\n\n    // Last of the framework's own middleware, and therefore the innermost\n    // layer that still sits *outside* every application middleware: on a cache\n    // hit the app never runs, so the gateway must not run anything the hit\n    // would skip. It is inside request-scope (partition resolvers need the\n    // request container) and inside the logger (the gateway is the only place\n    // that observes a request served from cache). See the factory's docstring.\n    this.nativeUse('*', createGatewayDispatchMiddleware(this._container))\n\n    this.onError((err, c) => this.handleException(c, err))\n  }\n\n  /**\n   * Configure OpenAPI endpoints, controller routes, and 404 handler.\n   * Called once by Application.initialize().\n   */\n  async configure(): Promise<void> {\n    if (this.configured) throw new RouterError('HonoApp has already been configured')\n\n    // OpenAPI endpoints\n    const openAPIService = this._container.resolve<OpenAPIService>(OPENAPI_TOKENS.OpenAPIService)\n    openAPIService.setupEndpoints(this, this._container)\n\n    // Controller routes + global middleware\n    const routeRegistrationService = this._container.resolve<RouteRegistrationService>(RouteRegistrationService)\n    await routeRegistrationService.configure()\n\n    // 404 handler (must be last)\n    this.notFound((c) => { throw new RouteNotFoundError(c.req.path, c.req.method) })\n\n    this.configured = true\n  }\n\n  private setupRequestScope(): void {\n    this.nativeUse('*', async (c: Context<RouterEnv>, next: () => Promise<void>) => {\n      const routerContext = new RouterContext(c)\n      const requestContainer = this._container.createRequestScope(routerContext)\n      c.set(ROUTER_CONTEXT_KEYS.REQUEST_CONTAINER, requestContainer)\n\n      await runWithContainer(requestContainer, next)\n    })\n  }\n\n  private handleException(c: Context<RouterEnv>, err: unknown) {\n    // Fallback to global container if request scope setup failed before storing REQUEST_CONTAINER\n    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition -- runtime guard: REQUEST_CONTAINER may be unset if request scope middleware throws\n    const requestContainer = c.get(ROUTER_CONTEXT_KEYS.REQUEST_CONTAINER) ?? this._container\n    const handler = requestContainer.resolve<ExceptionHandler>(DI_TOKENS.ExceptionHandler)\n    const ctx = createHttpExceptionContext(c)\n    // Run the handler within the request container's async context so standalone\n    // helpers like `route()` (which read the ambient container via getContainer)\n    // resolve correctly. Errors thrown before the request-scope middleware's\n    // `runWithContainer` body — e.g. route-param validation failures — otherwise\n    // reach here outside any container scope, breaking redirect-back rendering.\n    return runWithContainer(requestContainer, () => handler.handle(err, ctx))\n  }\n}\n"],"mappings":"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"}

package/dist/{http-method.decorator-BljM8BDj.mjs → http-method.decorator-BDi9LTWj.mjs}

@@ -1,6 +1,5 @@
-import { n as getMetadata, t as defineMetadata } from "./metadata-DzzprcID.mjs";
-import { u as ROUTE_METADATA_KEYS } from "./exception-context-D-kvney-.mjs";
-import { r as z } from "./zod-eKqqhZ5_.mjs";
+import { _ as defineMetadata, v as getMetadata } from "./di-DQ3xbjgf.mjs";
+import { u as ROUTE_METADATA_KEYS } from "./exception-context-CdnGTQNF.mjs";
 //#region src/router/decorators/http-method.decorator.ts
 /**
 * Creates an HTTP method decorator factory for the given HTTP method.
@@ -16,7 +15,7 @@ function createHttpMethodDecorator(method) {
 				type: "explicit",
 				method,
 				path,
-				config: config ?? { response: z.any() }
+				config: config ?? {}
 			};
 			defineMetadata(ROUTE_METADATA_KEYS.ROUTE_CONFIG, metadata, target, propertyKey);
 			const existing = getMetadata(ROUTE_METADATA_KEYS.DECORATED_METHODS, target) ?? [];
@@ -34,12 +33,14 @@ function createHttpMethodDecorator(method) {
 *
 * @example
 * ```typescript
-* @Controller('/api/v1/users')
+* import { array, object, uuid } from 'zod/mini'
+*
+* @Controller('/users', { version: '1' })
 * class UsersController {
-*   @Get('/', { response: z.array(userSchema), summary: 'List users' })
+*   @Get('/', { response: array(userSchema), summary: 'List users' })
 *   async list(ctx: RouterContext) { ... }
 *
-*   @Get('/:id', { params: z.object({ id: z.string().uuid() }), response: userSchema })
+*   @Get('/:id', { params: object({ id: uuid() }), response: userSchema })
 *   async getUser(ctx: RouterContext) { ... }
 * }
 * ```
@@ -94,4 +95,4 @@ const All = createHttpMethodDecorator("all");
 //#endregion
 export { Post as a, Patch as i, Delete as n, Put as o, Get as r, All as t };
 
-//# sourceMappingURL=http-method.decorator-BljM8BDj.mjs.map
+//# sourceMappingURL=http-method.decorator-BDi9LTWj.mjs.map

package/dist/http-method.decorator-BDi9LTWj.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"http-method.decorator-BDi9LTWj.mjs","names":[],"sources":["../src/router/decorators/http-method.decorator.ts"],"sourcesContent":["import { defineMetadata, getMetadata } from '../../di/metadata'\nimport { ROUTE_METADATA_KEYS } from '../constants'\nimport type { ExplicitRouteMetadata, HttpMethod, RouteConfig } from '../types'\n\n/**\n * Creates an HTTP method decorator factory for the given HTTP method.\n *\n * The returned decorator stores {@link ExplicitRouteMetadata} on the method and\n * tracks the method name under {@link ROUTE_METADATA_KEYS.DECORATED_METHODS}\n * on the controller prototype so they can be discovered at registration time.\n */\nfunction createHttpMethodDecorator(method: HttpMethod) {\n  return function (path: string, config?: RouteConfig) {\n    return function (\n      target: object,\n      propertyKey: string,\n      descriptor: PropertyDescriptor\n    ) {\n      const metadata: ExplicitRouteMetadata = {\n        type: 'explicit',\n        method,\n        path,\n        config: config ?? {},\n      }\n\n      defineMetadata(\n        ROUTE_METADATA_KEYS.ROUTE_CONFIG,\n        metadata,\n        target,\n        propertyKey\n      )\n\n      // Track this method as decorated on the prototype\n      const existing: string[] =\n        getMetadata<string[]>(ROUTE_METADATA_KEYS.DECORATED_METHODS, target) ?? []\n      existing.push(propertyKey)\n      defineMetadata(ROUTE_METADATA_KEYS.DECORATED_METHODS, existing, target)\n\n      return descriptor\n    }\n  }\n}\n\n/**\n * Registers a GET route on the controller method.\n *\n * @param path - Route path relative to the controller base path\n * @param config - Optional route configuration (response schema, body, params, etc.)\n *\n * @example\n * ```typescript\n * import { array, object, uuid } from 'zod/mini'\n *\n * @Controller('/users', { version: '1' })\n * class UsersController {\n *   @Get('/', { response: array(userSchema), summary: 'List users' })\n *   async list(ctx: RouterContext) { ... }\n *\n *   @Get('/:id', { params: object({ id: uuid() }), response: userSchema })\n *   async getUser(ctx: RouterContext) { ... }\n * }\n * ```\n */\nexport const Get = createHttpMethodDecorator('get')\n\n/**\n * Registers a POST route on the controller method.\n *\n * @param path - Route path relative to the controller base path\n * @param config - Optional route configuration (response schema, body, params, etc.)\n *\n * @example\n * ```typescript\n * @Controller('/api/v1/users')\n * class UsersController {\n *   @Post('/', { body: createUserSchema, response: userSchema, statusCode: 201 })\n *   async createUser(ctx: RouterContext) { ... }\n * }\n * ```\n */\nexport const Post = createHttpMethodDecorator('post')\n\n/**\n * Registers a PUT route on the controller method.\n *\n * @param path - Route path relative to the controller base path\n * @param config - Optional route configuration\n */\nexport const Put = createHttpMethodDecorator('put')\n\n/**\n * Registers a PATCH route on the controller method.\n *\n * @param path - Route path relative to the controller base path\n * @param config - Optional route configuration\n */\nexport const Patch = createHttpMethodDecorator('patch')\n\n/**\n * Registers a DELETE route on the controller method.\n *\n * @param path - Route path relative to the controller base path\n * @param config - Optional route configuration\n */\nexport const Delete = createHttpMethodDecorator('delete')\n\n/**\n * Registers an ALL (any HTTP method) route on the controller method.\n * Routes using @All are registered without OpenAPI validation\n * since OpenAPI does not support a catch-all HTTP method.\n *\n * @param path - Route path relative to the controller base path\n * @param config - Optional route configuration\n */\nexport const All = createHttpMethodDecorator('all')\n"],"mappings":";;;;;;;;;;AAWA,SAAS,0BAA0B,QAAoB;CACrD,OAAO,SAAU,MAAc,QAAsB;EACnD,OAAO,SACL,QACA,aACA,YACA;GACA,MAAM,WAAkC;IACtC,MAAM;IACN;IACA;IACA,QAAQ,UAAU,CAAC;GACrB;GAEA,eACE,oBAAoB,cACpB,UACA,QACA,WACF;GAGA,MAAM,WACJ,YAAsB,oBAAoB,mBAAmB,MAAM,KAAK,CAAC;GAC3E,SAAS,KAAK,WAAW;GACzB,eAAe,oBAAoB,mBAAmB,UAAU,MAAM;GAEtE,OAAO;EACT;CACF;AACF;;;;;;;;;;;;;;;;;;;;;AAsBA,MAAa,MAAM,0BAA0B,KAAK;;;;;;;;;;;;;;;;AAiBlD,MAAa,OAAO,0BAA0B,MAAM;;;;;;;AAQpD,MAAa,MAAM,0BAA0B,KAAK;;;;;;;AAQlD,MAAa,QAAQ,0BAA0B,OAAO;;;;;;;AAQtD,MAAa,SAAS,0BAA0B,QAAQ;;;;;;;;;AAUxD,MAAa,MAAM,0BAA0B,KAAK"}