stratal 0.0.19 → 0.0.21

package/dist/{http-method.decorator-BT3ufnz8.mjs.map → http-method.decorator-BrgHMdLQ.mjs.map}

@@ -1 +1 @@
-{"version":3,"file":"http-method.decorator-BT3ufnz8.mjs","names":[],"sources":["../src/router/decorators/http-method.decorator.ts"],"sourcesContent":["import { z } from '../../i18n/validation'\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 ?? { response: z.any() },\n      }\n\n      Reflect.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        (Reflect.getOwnMetadata(ROUTE_METADATA_KEYS.DECORATED_METHODS, target) as string[] | undefined) ?? []\n      existing.push(propertyKey)\n      Reflect.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 * @Controller('/api/v1/users')\n * class UsersController {\n *   @Get('/', { response: z.array(userSchema), summary: 'List users' })\n *   async list(ctx: RouterContext) { ... }\n *\n *   @Get('/:id', { params: z.object({ id: z.string().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;AACrD,QAAO,SAAU,MAAc,QAAsB;AACnD,SAAO,SACL,QACA,aACA,YACA;GACA,MAAM,WAAkC;IACtC,MAAM;IACN;IACA;IACA,QAAQ,UAAU,EAAE,UAAU,EAAE,KAAK,EAAE;IACxC;AAED,WAAQ,eACN,oBAAoB,cACpB,UACA,QACA,YACD;GAGD,MAAM,WACH,QAAQ,eAAe,oBAAoB,mBAAmB,OAAO,IAA6B,EAAE;AACvG,YAAS,KAAK,YAAY;AAC1B,WAAQ,eAAe,oBAAoB,mBAAmB,UAAU,OAAO;AAE/E,UAAO;;;;;;;;;;;;;;;;;;;;;;AAuBb,MAAa,MAAM,0BAA0B,MAAM;;;;;;;;;;;;;;;;AAiBnD,MAAa,OAAO,0BAA0B,OAAO;;;;;;;AAQrD,MAAa,MAAM,0BAA0B,MAAM;;;;;;;AAQnD,MAAa,QAAQ,0BAA0B,QAAQ;;;;;;;AAQvD,MAAa,SAAS,0BAA0B,SAAS;;;;;;;;;AAUzD,MAAa,MAAM,0BAA0B,MAAM"}
+{"version":3,"file":"http-method.decorator-BrgHMdLQ.mjs","names":[],"sources":["../src/router/decorators/http-method.decorator.ts"],"sourcesContent":["import { z } from '../../i18n/validation'\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 ?? { response: z.any() },\n      }\n\n      Reflect.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        (Reflect.getOwnMetadata(ROUTE_METADATA_KEYS.DECORATED_METHODS, target) as string[] | undefined) ?? []\n      existing.push(propertyKey)\n      Reflect.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 * @Controller('/api/v1/users')\n * class UsersController {\n *   @Get('/', { response: z.array(userSchema), summary: 'List users' })\n *   async list(ctx: RouterContext) { ... }\n *\n *   @Get('/:id', { params: z.object({ id: z.string().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,EAAE,UAAU,EAAE,KAAK,EAAE;IACxC;GAED,QAAQ,eACN,oBAAoB,cACpB,UACA,QACA,YACD;GAGD,MAAM,WACH,QAAQ,eAAe,oBAAoB,mBAAmB,OAAO,IAA6B,EAAE;GACvG,SAAS,KAAK,YAAY;GAC1B,QAAQ,eAAe,oBAAoB,mBAAmB,UAAU,OAAO;GAE/E,OAAO;;;;;;;;;;;;;;;;;;;;;;AAuBb,MAAa,MAAM,0BAA0B,MAAM;;;;;;;;;;;;;;;;AAiBnD,MAAa,OAAO,0BAA0B,OAAO;;;;;;;AAQrD,MAAa,MAAM,0BAA0B,MAAM;;;;;;;AAQnD,MAAa,QAAQ,0BAA0B,QAAQ;;;;;;;AAQvD,MAAa,SAAS,0BAA0B,SAAS;;;;;;;;;AAUzD,MAAa,MAAM,0BAA0B,MAAM"}

package/dist/i18n/index.d.mts

@@ -1,3 +1,3 @@
-import { A as LocaleNotSupportedError, C as DetectionStrategy, D as buildDetectorOptions, E as ResolvedI18nOptions, O as resolveI18nOptions, S as I18nModule, T as LanguageDetectionOptions, _ as Messages, b as messages, g as MessageRegistry, h as MessageLoaderService, k as TranslationMissingError, m as I18nContextMiddleware, v as getLocales, w as I18nModuleOptions, x as I18N_TOKENS, y as getMessages } from "../index-DPFqRs8L.mjs";
-import { C as SystemMessageKeys, S as Prefixes, _ as DeepKeys, b as MessageKeys, g as AppMessages, h as AppMessageNamespaces, m as AppMessageKeys, v as II18nService, x as MessageParams, y as MessageKeyPrefix } from "../index-B437eK7p.mjs";
+import { A as LocaleNotSupportedError, C as DetectionStrategy, D as buildDetectorOptions, E as ResolvedI18nOptions, O as resolveI18nOptions, S as I18nModule, T as LanguageDetectionOptions, _ as Messages, b as messages, g as MessageRegistry, h as MessageLoaderService, k as TranslationMissingError, m as I18nContextMiddleware, v as getLocales, w as I18nModuleOptions, x as I18N_TOKENS, y as getMessages } from "../index-ByOyTmqf.mjs";
+import { C as MessageParams, S as MessageKeys, T as SystemMessageKeys, _ as AppMessageNamespaces, b as II18nService, g as AppMessageKeys, v as AppMessages, w as Prefixes, x as MessageKeyPrefix, y as DeepKeys } from "../index-Bnpfq6uk.mjs";
 export { AppMessageKeys, AppMessageNamespaces, AppMessages, DeepKeys, DetectionStrategy, I18N_TOKENS, I18nContextMiddleware, I18nModule, I18nModuleOptions, II18nService, LanguageDetectionOptions, LocaleNotSupportedError, MessageKeyPrefix, MessageKeys, MessageLoaderService, MessageParams, MessageRegistry, Messages, Prefixes, ResolvedI18nOptions, SystemMessageKeys, TranslationMissingError, buildDetectorOptions, getLocales, getMessages, messages, resolveI18nOptions };

package/dist/i18n/index.mjs

@@ -1,3 +1,3 @@
-import { w as I18N_TOKENS } from "../errors-B4pYgYON.mjs";
-import { B as LocaleNotSupportedError, F as getMessages, H as I18nContextMiddleware, I as messages, L as buildDetectorOptions, M as MessageRegistry, N as MessageLoaderService, P as getLocales, R as resolveI18nOptions, t as I18nModule, z as TranslationMissingError } from "../i18n.module-CI_prYFD.mjs";
+import { w as I18N_TOKENS } from "../errors-COW9-Mar.mjs";
+import { B as LocaleNotSupportedError, F as getMessages, H as I18nContextMiddleware, I as messages, L as buildDetectorOptions, M as MessageRegistry, N as MessageLoaderService, P as getLocales, R as resolveI18nOptions, t as I18nModule, z as TranslationMissingError } from "../i18n.module-CzXLW9Hy.mjs";
 export { I18N_TOKENS, I18nContextMiddleware, I18nModule, LocaleNotSupportedError, MessageLoaderService, MessageRegistry, TranslationMissingError, buildDetectorOptions, getLocales, getMessages, messages, resolveI18nOptions };

package/dist/i18n/messages/en/index.d.mts

@@ -1,2 +1,2 @@
-import { a as errors, i as emails, n as zodI18n, o as common, r as validation } from "../../../index-DFhEeFfC.mjs";
+import { a as errors, i as emails, n as zodI18n, o as common, r as validation } from "../../../index-C1KvMncZ.mjs";
 export { common, emails, errors, validation, zodI18n };

package/dist/i18n/messages/en/index.mjs

@@ -1,2 +1,2 @@
-import { a as errors, i as emails, n as zodI18n, o as common, r as validation } from "../../../en-rHmW6vD9.mjs";
+import { a as errors, i as emails, n as zodI18n, o as common, r as validation } from "../../../en-DSH_bhh6.mjs";
 export { common, emails, errors, validation, zodI18n };

package/dist/i18n/utils/index.mjs

@@ -1,2 +1,2 @@
-import { t as setupI18nCompiler } from "../../setup-CtekcwuO.mjs";
+import { t as setupI18nCompiler } from "../../setup-CefZKV_e.mjs";
 export { setupI18nCompiler };

package/dist/i18n/validation/index.d.mts

@@ -1,4 +1,4 @@
-import { c as runWithErrorMapContext, d as LocaleProvider, f as ZodCustomIssue, i as ZodError, l as ErrorMapContext, n as OpenAPIObject, o as z, p as withI18n, r as PathItemObject, s as backendErrorMap, t as OpenAPIHono, u as I18nErrorMetadata } from "../../index-B437eK7p.mjs";
+import { c as runWithErrorMapContext, d as LocaleProvider, f as ZodCustomIssue, h as withI18n, i as ZodError, l as ErrorMapContext, m as cuid2, n as OpenAPIObject, o as z, p as CUID2_REGEX, r as PathItemObject, s as backendErrorMap, t as OpenAPIHono, u as I18nErrorMetadata } from "../../index-Bnpfq6uk.mjs";
 export * from "@hono/zod-openapi";
 export * from "zod";
-export { ErrorMapContext, I18nErrorMetadata, LocaleProvider, OpenAPIHono, OpenAPIObject, PathItemObject, ZodCustomIssue, ZodError, backendErrorMap, runWithErrorMapContext, withI18n, z };
+export { CUID2_REGEX, ErrorMapContext, I18nErrorMetadata, LocaleProvider, OpenAPIHono, OpenAPIObject, PathItemObject, ZodCustomIssue, ZodError, backendErrorMap, cuid2, runWithErrorMapContext, withI18n, z };

package/dist/i18n/validation/index.mjs

@@ -1,3 +1,3 @@
-import { a as withI18n, i as z, n as ZodError, o as backendErrorMap, s as runWithErrorMapContext, t as OpenAPIHono } from "../../validation-Dbg3ehdP.mjs";
+import { a as CUID2_REGEX, c as backendErrorMap, i as z, l as runWithErrorMapContext, n as ZodError, o as cuid2, s as withI18n, t as OpenAPIHono } from "../../validation-DtJwAv7O.mjs";
 export * from "@hono/zod-openapi";
-export { OpenAPIHono, ZodError, backendErrorMap, runWithErrorMapContext, withI18n, z };
+export { CUID2_REGEX, OpenAPIHono, ZodError, backendErrorMap, cuid2, runWithErrorMapContext, withI18n, z };

package/dist/{i18n.module-CI_prYFD.mjs → i18n.module-CzXLW9Hy.mjs}

@@ -1,15 +1,16 @@
-import { A as Scope, D as runWithContainer, E as getContainer, H as ApplicationError, V as ROUTER_TOKENS, a as createHttpExceptionContext, c as DEFAULT_CONTENT_TYPE, d as ROUTER_CONTEXT_KEYS, f as ROUTE_METADATA_KEYS, k as ERROR_CODES, l as HTTP_METHODS, m as VERSION_NEUTRAL, p as SECURITY_SCHEMES, s as RouterContext, u as METHOD_STATUS_CODES, w as I18N_TOKENS } from "./errors-B4pYgYON.mjs";
-import { a as __decorate, d as CONTAINER_TOKEN, f as DI_TOKENS, g as getMethodInjections, o as __decorateParam, p as Transient, s as __decorateMetadata, u as LOGGER_TOKENS } from "./logger-V6Ms3QnQ.mjs";
-import { C as Module, b as ControllerRegistrationError, c as InvalidSignatureError, d as MissingRouteParamError, f as ResponseValidationError, g as RouteNotFoundError, h as SchemaValidationError, l as MiddlewareNextCalledMultipleTimesError, o as DomainMismatchError, p as RouteNameNotFoundError, s as DuplicateRouteNameError, u as MissingEnvironmentVariableError, v as OpenAPIRouteRegistrationError, x as ControllerMethodNotFoundError, y as HonoAppAlreadyConfiguredError } from "./module-qGE_1duv.mjs";
-import { i as z, o as backendErrorMap, r as validation_exports, s as runWithErrorMapContext, t as OpenAPIHono } from "./validation-Dbg3ehdP.mjs";
-import { n as OPENAPI_TOKENS } from "./openapi-tools.service-CYWGuhue.mjs";
-import { t as en_exports } from "./en-rHmW6vD9.mjs";
-import { i as getMethodGuards, r as getControllerGuards, t as GuardExecutionService } from "./guards-DMbsAxSX.mjs";
-import { n as getControllerOptions, r as getControllerRoute } from "./controller.decorator-LZY9aHYG.mjs";
-import { c as getWsOnMessageMethod, d as isGateway, o as getWsOnCloseMethod, s as getWsOnErrorMethod, t as GatewayContext } from "./gateway-context-cqZ8wMoi.mjs";
-import "./http-method.decorator-BT3ufnz8.mjs";
-import { n as verifySignedUrl, t as signUrl } from "./signed-url-COX7cCWR.mjs";
-import { t as setupI18nCompiler } from "./setup-CtekcwuO.mjs";
+import { A as Scope, D as runWithContainer, E as getContainer, H as ApplicationError, V as ROUTER_TOKENS, a as createHttpExceptionContext, c as DEFAULT_CONTENT_TYPE, d as ROUTER_CONTEXT_KEYS, f as ROUTE_METADATA_KEYS, k as ERROR_CODES, l as HTTP_METHODS, m as VERSION_NEUTRAL, p as SECURITY_SCHEMES, s as RouterContext, u as METHOD_STATUS_CODES, w as I18N_TOKENS } from "./errors-COW9-Mar.mjs";
+import { a as __decorate, d as CONTAINER_TOKEN, f as DI_TOKENS, g as getMethodInjections, o as __decorateParam, p as Transient, s as __decorateMetadata, u as LOGGER_TOKENS } from "./logger-DlV7NtvD.mjs";
+import { S as createThrottleMiddleware, b as ControllerRegistrationError, c as InvalidSignatureError, d as MissingRouteParamError, f as ResponseValidationError, g as RouteNotFoundError, h as SchemaValidationError, k as Module, l as MiddlewareNextCalledMultipleTimesError, o as DomainMismatchError, p as RouteNameNotFoundError, s as DuplicateRouteNameError, u as MissingEnvironmentVariableError, v as OpenAPIRouteRegistrationError, x as ControllerMethodNotFoundError, y as HonoAppAlreadyConfiguredError } from "./module-BzLg57FK.mjs";
+import { c as backendErrorMap, i as z, l as runWithErrorMapContext, r as validation_exports, t as OpenAPIHono } from "./validation-DtJwAv7O.mjs";
+import { n as OPENAPI_TOKENS } from "./openapi-tools.service-Zs-Ewv7F.mjs";
+import { t as en_exports } from "./en-DSH_bhh6.mjs";
+import { i as getMethodGuards, r as getControllerGuards, t as GuardExecutionService } from "./guards-DU1_J9YA.mjs";
+import { n as getControllerOptions, r as getControllerRoute } from "./controller.decorator-B9vwn0zK.mjs";
+import { c as getWsOnMessageMethod, d as isGateway, o as getWsOnCloseMethod, s as getWsOnErrorMethod, t as GatewayContext } from "./gateway-context-CXmXtaUP.mjs";
+import "./http-method.decorator-BrgHMdLQ.mjs";
+import { n as getRateLimits } from "./rate-limit.decorator-6qzNcSOt.mjs";
+import { n as verifySignedUrl, t as signUrl } from "./signed-url-BQPbv2In.mjs";
+import { t as setupI18nCompiler } from "./setup-CefZKV_e.mjs";
 import { inject } from "tsyringe";
 import { createCoreContext, translate } from "@intlify/core-base";
 import { swaggerUI } from "@hono/swagger-ui";
@@ -22,6 +23,7 @@ import { languageDetector } from "hono/language";
 * Must run after LocaleExtractionMiddleware sets the locale.
 */
 let I18nContextMiddleware = class I18nContextMiddleware {
+	i18n;
 	constructor(i18n) {
 		this.i18n = i18n;
 	}
@@ -40,6 +42,7 @@ I18nContextMiddleware = __decorate([
 //#endregion
 //#region src/openapi/services/openapi-config.service.ts
 let OpenAPIConfigService = class OpenAPIConfigService {
+	baseOptions;
 	overrides = [];
 	constructor(baseOptions) {
 		this.baseOptions = baseOptions;
@@ -209,6 +212,8 @@ function deepMerge(target, source) {
 //#endregion
 //#region src/i18n/services/message-loader.service.ts
 let MessageLoaderService = class MessageLoaderService {
+	registry;
+	options;
 	cache;
 	contextCache;
 	locales;
@@ -730,6 +735,67 @@ function createMiddlewareChain(classes) {
 	};
 }
 //#endregion
+//#region src/router/trailing-slash.ts
+/**
+* Apply a trailing-slash mode to a URL or path.
+*
+* - `'ignore'` — return as-is.
+* - `'always'` — append `/` to the pathname unless it already has one.
+*   Skipped when the last segment contains `.` (file-like paths) and for the
+*   root `/` path.
+* - `'never'`  — strip a trailing `/` from the pathname. Skipped for root.
+*
+* Preserves query string and hash. Handles both relative paths
+* (`/foo?x=1`) and absolute URLs (`https://host/foo?x=1`).
+*
+* Used by URL-generation helpers and the redirect middleware so canonical
+* form is computed in one place.
+*/
+function applyTrailingSlash(url, mode) {
+	if (mode === "ignore") return url;
+	const isAbsolute = /^https?:\/\//i.test(url);
+	const parsed = isAbsolute ? new URL(url) : new URL(url, "http://placeholder.local");
+	const path = parsed.pathname;
+	if (path === "/") return url;
+	const hasTrailing = path.endsWith("/");
+	if (mode === "always" && !hasTrailing) {
+		if (path.slice(path.lastIndexOf("/") + 1).includes(".")) return url;
+		parsed.pathname = `${path}/`;
+	} else if (mode === "never" && hasTrailing) parsed.pathname = path.slice(0, -1);
+	else return url;
+	return isAbsolute ? parsed.toString() : `${parsed.pathname}${parsed.search}${parsed.hash}`;
+}
+//#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.
+*
+* 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(mode) {
+	if (mode === "ignore") return null;
+	return async (c, next) => {
+		const url = new URL(c.req.url);
+		const canonicalPath = applyTrailingSlash(url.pathname, mode);
+		if (canonicalPath === url.pathname) return next();
+		return c.redirect(`${canonicalPath}${url.search}`, REDIRECT_STATUS);
+	};
+}
+//#endregion
 //#region src/router/decorators/route.decorator.ts
 /**
 * Decorator to add OpenAPI metadata to a controller method using convention-based routing.
@@ -988,10 +1054,34 @@ function toRoutingOpenAPIPath(path) {
 * Scoring: static = 0, `:param{constraint}` = 5, `:param` = 10, wildcard `{.+}` / `{.*}` = 100.
 *
 * Packed as: score * 10000 - segmentCount (negative segment count so more segments = lower key = higher priority)
+*
+* Locale variants score against the path with the leading `/:locale{…}` segment
+* stripped — the variant's score therefore matches its primary, but its larger
+* segment count makes it sort just before the primary. Without this, a primary
+* catch-all (e.g. `/:slug{.+}`) gobbles locale-prefixed URLs because Hono picks
+* whichever matching route was registered first.
 */
-function getPathSpecificityKey(path) {
+function getPathSpecificityKey(route) {
+	const segmentCount = countSegments(route.path);
+	const scoringPath = route.isLocaleVariant ? route.path.replace(/^\/:locale\{[^}]*\}/, "") || "/" : route.path;
 	let score = 0;
-	let segmentCount = 0;
+	let i = 0;
+	while (i < scoringPath.length) {
+		if (scoringPath.charCodeAt(i) === 47) {
+			i++;
+			continue;
+		}
+		let end = scoringPath.indexOf("/", i);
+		if (end === -1) end = scoringPath.length;
+		const segment = scoringPath.substring(i, end);
+		if (segment.includes("{.+}") || segment.includes("{.*}")) score += 100;
+		else if (segment.charCodeAt(0) === 58) score += segment.includes("{") ? 5 : 10;
+		i = end;
+	}
+	return score * 1e4 - segmentCount;
+}
+function countSegments(path) {
+	let count = 0;
 	let i = 0;
 	while (i < path.length) {
 		if (path.charCodeAt(i) === 47) {
@@ -1000,13 +1090,10 @@ function getPathSpecificityKey(path) {
 		}
 		let end = path.indexOf("/", i);
 		if (end === -1) end = path.length;
-		segmentCount++;
-		const segment = path.substring(i, end);
-		if (segment.includes("{.+}") || segment.includes("{.*}")) score += 100;
-		else if (segment.charCodeAt(0) === 58) score += segment.includes("{") ? 5 : 10;
+		count++;
 		i = end;
 	}
-	return score * 1e4 - segmentCount;
+	return count;
 }
 /**
 * Compute a specificity score for route ordering.
@@ -1027,11 +1114,13 @@ function getPathSpecificityScore(path) {
 *
 * 1. Static paths before parameterized before wildcards
 * 2. More segments = more specific (tie-breaker)
-* 3. Primary paths before locale-prefixed variants
+* 3. Locale-prefixed variants before their primary (so a locale-prefixed
+*    request matches the variant first; a primary catch-all would otherwise
+*    swallow the locale prefix into its param)
 */
 function sortRoutesBySpecificity(routes) {
 	const keys = /* @__PURE__ */ new Map();
-	for (const route of routes) keys.set(route, getPathSpecificityKey(route.path));
+	for (const route of routes) keys.set(route, getPathSpecificityKey(route));
 	const copy = routes.slice();
 	copy.sort((a, b) => keys.get(a) - keys.get(b));
 	return copy;
@@ -1099,6 +1188,12 @@ const invokeHandler = (instance, method, ...args) => {
 	}
 };
 let RouteRegistrationService = class RouteRegistrationService {
+	logger;
+	registry;
+	routerResolver;
+	localePathService;
+	app;
+	moduleRegistry;
 	controllerClasses = /* @__PURE__ */ new Map();
 	upgradeWebSocketFn = null;
 	constructor(logger, registry, routerResolver, localePathService, app, moduleRegistry) {
@@ -1138,10 +1233,12 @@ let RouteRegistrationService = class RouteRegistrationService {
 		const controllerOpts = getControllerOptions(ControllerClass);
 		const controllerGuards = getControllerGuards(ControllerClass)?.guards ?? [];
 		const routerConfig = this.routerResolver?.resolveForController(ControllerClass) ?? { middleware: [] };
+		const classThrottleMiddleware = Array.from(new Set(getRateLimits(ControllerClass).map(createThrottleMiddleware)));
 		const basePath = routerConfig.prefix ? this.joinPaths(routerConfig.prefix, controllerRoute) : controllerRoute;
 		const effectiveVersion = controllerOpts?.version ?? routerConfig.version;
 		const effectiveDomain = controllerOpts?.domain ?? routerConfig.domain;
 		if (isWsGateway) {
+			const wsMiddleware = [...routerConfig.middleware, ...classThrottleMiddleware];
 			const expandedRoutes = this.registry.register({
 				method: "ws",
 				basePath,
@@ -1150,10 +1247,10 @@ let RouteRegistrationService = class RouteRegistrationService {
 				controller: ControllerClass.name,
 				action: "ws",
 				hidden: routerConfig.hideFromDocs ?? false,
-				middleware: routerConfig.middleware.map((m) => m.name)
+				middleware: wsMiddleware.map((m) => m.name)
 			});
 			for (const route of expandedRoutes) actions.set(route, () => {
-				if (routerConfig.middleware.length > 0) this.app.use(route.path, createMiddlewareChain(routerConfig.middleware));
+				if (wsMiddleware.length > 0) this.app.use(route.path, createMiddlewareChain(wsMiddleware));
 				if (effectiveDomain) {
 					const domainHandler = createDomainMiddleware(effectiveDomain);
 					this.app.use(route.path, domainHandler);
@@ -1167,6 +1264,7 @@ let RouteRegistrationService = class RouteRegistrationService {
 		this.controllerClasses.set(className, ControllerClass);
 		const prototype = ControllerClass.prototype;
 		if (prototype.handle) {
+			const wildcardMiddleware = [...routerConfig.middleware, ...classThrottleMiddleware];
 			const expandedRoutes = this.registry.register({
 				method: "all",
 				basePath,
@@ -1175,10 +1273,10 @@ let RouteRegistrationService = class RouteRegistrationService {
 				controller: className,
 				action: "handle",
 				hidden: routerConfig.hideFromDocs ?? false,
-				middleware: routerConfig.middleware.map((m) => m.name)
+				middleware: wildcardMiddleware.map((m) => m.name)
 			});
 			for (const route of expandedRoutes) actions.set(route, () => {
-				if (routerConfig.middleware.length > 0) this.app.use(route.path, createMiddlewareChain(routerConfig.middleware));
+				if (wildcardMiddleware.length > 0) this.app.use(route.path, createMiddlewareChain(wildcardMiddleware));
 				this.registerWildcardRoute(ControllerClass, route.path);
 			});
 			return;
@@ -1204,12 +1302,26 @@ let RouteRegistrationService = class RouteRegistrationService {
 		const routerName = routerConfig.name;
 		const controllerName = controllerOpts?.name;
 		const effectiveNamePrefix = routerName && controllerName ? `${routerName}${controllerName}` : routerName ?? controllerName;
-		const middlewareNames = routerConfig.middleware.map((m) => m.name);
 		for (const { method: methodName, meta } of methodMetadata) {
 			const resolved = this.resolveMethodAndPath(meta, methodName, basePath, className);
 			if (!resolved) continue;
-			const { httpMethod, fullPath, routeConfig, statusCodeOverride } = resolved;
-			if (routerConfig.params) routeConfig.params = routeConfig.params ? routerConfig.params.extend(routeConfig.params.shape) : routerConfig.params;
+			const methodThrottleMiddleware = getRateLimits(prototype, methodName).map(createThrottleMiddleware);
+			const effectiveMiddleware = Array.from(new Set([
+				...routerConfig.middleware,
+				...classThrottleMiddleware,
+				...methodThrottleMiddleware
+			]));
+			const middlewareNames = effectiveMiddleware.map((m) => m.name);
+			const { httpMethod, fullPath, routeConfig: rawRouteConfig, statusCodeOverride } = resolved;
+			let mergedParams = rawRouteConfig.params;
+			if (routerConfig.params) {
+				const prefixShape = routerConfig.params.shape;
+				mergedParams = mergedParams ? mergedParams.extend(prefixShape) : routerConfig.params.extend({});
+			}
+			const routeConfig = mergedParams === rawRouteConfig.params ? rawRouteConfig : {
+				...rawRouteConfig,
+				params: mergedParams
+			};
 			const hideFromDocs = routeConfig.hideFromDocs ?? routerHidden ?? controllerHidden;
 			let routeName;
 			if (routeConfig.name) routeName = effectiveNamePrefix ? `${effectiveNamePrefix}${routeConfig.name}` : routeConfig.name;
@@ -1251,7 +1363,7 @@ let RouteRegistrationService = class RouteRegistrationService {
 						path: route.path,
 						methodName
 					});
-					if (routerConfig.middleware.length > 0) this.app.use(route.path, createMiddlewareChain(routerConfig.middleware));
+					if (effectiveMiddleware.length > 0) this.app.use(route.path, createMiddlewareChain(effectiveMiddleware));
 					if (allGuards.length > 0) this.app.use(route.path, this.createGuardMiddleware(allGuards));
 					this.app.all(route.path, handler);
 					return;
@@ -1266,7 +1378,7 @@ let RouteRegistrationService = class RouteRegistrationService {
 					tags: metadata.tags,
 					hidden: route.hidden
 				});
-				const wrappedHandler = this.wrapHandlerWithChain(handler, routerConfig.middleware, allGuards);
+				const wrappedHandler = this.wrapHandlerWithChain(handler, effectiveMiddleware, allGuards);
 				this.app.openapi(openApiRoute, wrappedHandler);
 				if (!route.hidden) {
 					const { hide: _, ...specRoute } = openApiRoute;
@@ -1629,12 +1741,16 @@ let HonoApp = class HonoApp extends OpenAPIHono {
 	* Used by private methods to register middleware without going through the override.
 	*/
 	nativeUse;
-	constructor(container, logger) {
-		super({ defaultHook: (result, c) => {
-			if (!result.success) throw new SchemaValidationError(result.error);
-			const override = c.get("validationSuccessResponse");
-			if (override) return override;
-		} });
+	constructor(container, logger, application) {
+		const trailingSlash = application.config.trailingSlash ?? "ignore";
+		super({
+			strict: false,
+			defaultHook: (result, c) => {
+				if (!result.success) throw new SchemaValidationError(result.error);
+				const override = c.get("validationSuccessResponse");
+				if (override) return override;
+			}
+		});
 		this._container = container;
 		this._logger = logger;
 		this.nativeUse = this.use;
@@ -1649,6 +1765,8 @@ let HonoApp = class HonoApp extends OpenAPIHono {
 			}
 			return this.nativeUse(...args);
 		});
+		const trailingSlashRedirect = createTrailingSlashRedirect(trailingSlash);
+		if (trailingSlashRedirect) this.nativeUse("*", trailingSlashRedirect);
 		this.setupRequestScope();
 		this.applyGlobalMiddleware();
 	}
@@ -1691,11 +1809,17 @@ HonoApp = __decorate([
 	Transient(),
 	__decorateParam(0, inject(CONTAINER_TOKEN)),
 	__decorateParam(1, inject(LOGGER_TOKENS.LoggerService)),
-	__decorateMetadata("design:paramtypes", [Object, Object])
+	__decorateParam(2, inject(DI_TOKENS.Application)),
+	__decorateMetadata("design:paramtypes", [
+		Object,
+		Object,
+		Object
+	])
 ], HonoApp);
 //#endregion
 //#region src/router/services/locale-path.service.ts
 let LocalePathService = class LocalePathService {
+	honoApp;
 	_config;
 	_pathDetectionEnabled;
 	_prefixDefaultLocale;
@@ -1840,10 +1964,23 @@ VersioningService = __decorate([
 ], VersioningService);
 //#endregion
 //#region src/router/route-registry.ts
+const CONCRETE_HTTP_METHODS = [
+	"get",
+	"post",
+	"put",
+	"delete",
+	"patch",
+	"head",
+	"options",
+	"trace"
+];
 let RouteRegistry = class RouteRegistry {
+	versioningService;
+	localePathService;
 	routes = [];
 	namedRoutes = /* @__PURE__ */ new Map();
 	_sortedCache = null;
+	_routeToNameCache = null;
 	constructor(versioningService, localePathService) {
 		this.versioningService = versioningService;
 		this.localePathService = localePathService;
@@ -1894,6 +2031,7 @@ let RouteRegistry = class RouteRegistry {
 			}
 		}
 		this._sortedCache = null;
+		this._routeToNameCache = null;
 		return expandedRoutes;
 	}
 	/** Get a named route by name */
@@ -1904,7 +2042,26 @@ let RouteRegistry = class RouteRegistry {
 	has(name) {
 		return this.namedRoutes.has(name);
 	}
-	/** Get all routes sorted by specificity (static > param > wildcard, primary before locale) */
+	/**
+	* Resolve a Hono-style route path pattern (e.g. as exposed by `c.req.routePath`)
+	* back to its registered name, scoped to the request's HTTP method. Locale variant
+	* paths resolve to the canonical primary route name. Method matching is
+	* case-insensitive; routes registered with `'all'` resolve under any verb.
+	*/
+	findNameByRoute(method, path) {
+		this._routeToNameCache ??= this.buildRouteToNameCache();
+		return this._routeToNameCache.get(`${method.toLowerCase()}:${path}`);
+	}
+	buildRouteToNameCache() {
+		const cache = /* @__PURE__ */ new Map();
+		for (const route of this.namedRoutes.values()) {
+			const methods = route.method === "all" ? CONCRETE_HTTP_METHODS : [route.method];
+			const paths = route.localePaths ? [route.path, ...route.localePaths] : [route.path];
+			for (const m of methods) for (const p of paths) cache.set(`${m}:${p}`, route.name);
+		}
+		return cache;
+	}
+	/** Get all routes sorted by specificity (static > param > wildcard, locale variant before its primary) */
 	all() {
 		this._sortedCache ??= sortRoutesBySpecificity(this.routes);
 		return this._sortedCache;
@@ -1923,6 +2080,17 @@ RouteRegistry = __decorate([
 //#endregion
 //#region src/router/uri.ts
 /**
+* Encode a value for use as a path parameter.
+*
+* Splits on `/` and encodes each segment with `encodeURIComponent`, so callers
+* can pass slash-containing values for catch-all params (e.g. `:slug{.+}`) and
+* still get a usable URL — `'auth/login'` becomes `'auth/login'`, not
+* `'auth%2Flogin'`. Single segments behave exactly like `encodeURIComponent`.
+*/
+function encodePathParam(value) {
+	return value.split("/").map(encodeURIComponent).join("/");
+}
+/**
 * Build a URL from a registered route, filling path/domain params and appending extras as query string.
 *
 * Pure function — no request context needed. Used by both the `Uri` class and the standalone `route()` function.
@@ -1945,7 +2113,7 @@ function buildRouteUrl(route, name, params) {
 	for (const paramName of route.paramNames) {
 		const value = allParams[paramName];
 		if (value === void 0) throw new MissingRouteParamError(paramName, name, route.path);
-		url = url.replace(new RegExp(`:${paramName}(\\{[^}]*\\})?`), encodeURIComponent(value));
+		url = url.replace(new RegExp(`:${paramName}(\\{[^}]*\\})?`), encodePathParam(value));
 		consumedKeys.add(paramName);
 	}
 	let domain;
@@ -1967,10 +2135,14 @@ function buildRouteUrl(route, name, params) {
 	return url;
 }
 let Uri = class Uri {
+	registry;
+	routerContext;
 	_defaults = {};
-	constructor(registry, routerContext) {
+	trailingSlash;
+	constructor(registry, routerContext, application) {
 		this.registry = registry;
 		this.routerContext = routerContext;
+		this.trailingSlash = application.config.trailingSlash ?? "ignore";
 	}
 	/**
 	* Set default URL parameters for this request.
@@ -1985,6 +2157,16 @@ let Uri = class Uri {
 		};
 	}
 	/**
+	* Read the currently configured default URL parameters.
+	*
+	* Used by frameworks that need to share these with the client (e.g. the
+	* Inertia adapter ships them as a shared prop so `route()` calls in the
+	* browser auto-fill the same sticky params as the server).
+	*/
+	getDefaults() {
+		return { ...this._defaults };
+	}
+	/**
 	* Generate a URL from a named route.
 	*
 	* Keys matching `:param` placeholders fill the path.
@@ -2003,10 +2185,10 @@ let Uri = class Uri {
 	route(name, params, options) {
 		const registeredRoute = this.registry.get(name);
 		if (!registeredRoute) throw new RouteNameNotFoundError(name);
-		let url = buildRouteUrl(registeredRoute, name, {
+		let url = applyTrailingSlash(buildRouteUrl(registeredRoute, name, {
 			...this._defaults,
 			...params
-		});
+		}), this.trailingSlash);
 		if (options?.absolute && !url.startsWith("http")) url = `${new URL(this.routerContext.c.req.url).origin}${url}`;
 		return url;
 	}
@@ -2054,14 +2236,14 @@ let Uri = class Uri {
 	* Get the current request URL pathname (without query string).
 	*/
 	current() {
-		return new URL(this.routerContext.c.req.url).pathname;
+		return applyTrailingSlash(new URL(this.routerContext.c.req.url).pathname, this.trailingSlash);
 	}
 	/**
 	* Get the current request URL with query string (pathname + search).
 	*/
 	full() {
 		const parsed = new URL(this.routerContext.c.req.url);
-		return `${parsed.pathname}${parsed.search}`;
+		return applyTrailingSlash(`${parsed.pathname}${parsed.search}`, this.trailingSlash);
 	}
 	/**
 	* Get the previous request URL from the Referer header.
@@ -2093,7 +2275,7 @@ let Uri = class Uri {
 	* @param options - URL generation options
 	*/
 	to(path, queryParams, options) {
-		let url = path;
+		let url = applyTrailingSlash(path, this.trailingSlash);
 		if (queryParams) {
 			const entries = Object.entries(queryParams);
 			if (entries.length > 0) {
@@ -2113,7 +2295,7 @@ let Uri = class Uri {
 	query(path, queryParams) {
 		const parsed = new URL(path, "https://placeholder.local");
 		for (const [key, value] of Object.entries(queryParams)) parsed.searchParams.set(key, value);
-		return `${parsed.pathname}${parsed.search}`;
+		return applyTrailingSlash(`${parsed.pathname}${parsed.search}`, this.trailingSlash);
 	}
 	getAppSecret() {
 		const secret = this.routerContext.c.env.APP_SECRET;
@@ -2125,7 +2307,12 @@ Uri = __decorate([
 	Transient(),
 	__decorateParam(0, inject(ROUTER_TOKENS.RouteRegistry)),
 	__decorateParam(1, inject(ROUTER_TOKENS.RouterContext)),
-	__decorateMetadata("design:paramtypes", [Object, Object])
+	__decorateParam(2, inject(DI_TOKENS.Application)),
+	__decorateMetadata("design:paramtypes", [
+		Object,
+		Object,
+		Object
+	])
 ], Uri);
 //#endregion
 //#region src/router/route-url.ts
@@ -2155,9 +2342,12 @@ Uri = __decorate([
 * ```
 */
 function route(name, params) {
-	const registeredRoute = getContainer().resolve(ROUTER_TOKENS.RouteRegistry).get(name);
+	const container = getContainer();
+	const registry = container.resolve(ROUTER_TOKENS.RouteRegistry);
+	const application = container.resolve(DI_TOKENS.Application);
+	const registeredRoute = registry.get(name);
 	if (!registeredRoute) throw new RouteNameNotFoundError(name);
-	return buildRouteUrl(registeredRoute, name, params);
+	return applyTrailingSlash(buildRouteUrl(registeredRoute, name, params), application.config.trailingSlash ?? "ignore");
 }
 //#endregion
 //#region src/router/middleware/verify-signature.middleware.ts
@@ -2200,6 +2390,8 @@ var VerifySignatureMiddleware = class {
 * Uses pre-built CoreContext from MessageLoaderService (singleton) for zero-cost lookups.
 */
 let I18nService = class I18nService {
+	loader;
+	routerContext;
 	constructor(loader, routerContext) {
 		this.loader = loader;
 		this.routerContext = routerContext;
@@ -2337,4 +2529,4 @@ I18nModule = _I18nModule = __decorate([Module({ providers: [
 //#endregion
 export { OpenAPIModule as A, LocaleNotSupportedError as B, validationErrorResponseSchema as C, createMiddlewareChain as D, getRouteMetadata as E, getMessages as F, I18nContextMiddleware as H, messages as I, buildDetectorOptions as L, MessageRegistry as M, MessageLoaderService as N, createDomainMiddleware as O, getLocales as P, resolveI18nOptions as R, uuidParamSchema as S, getRouteDecoratedMethods as T, OpenAPIConfigService as V, commonErrorSchemas as _, buildRouteUrl as a, paginationQuerySchema as b, LocalePathService as c, extractDomainParamNames as d, extractParamNames as f, toOpenAPIPath as g, sortRoutesBySpecificity as h, Uri as i, OpenAPIService as j, parseDomainPattern as k, HonoApp as l, getPathSpecificityScore as m, VerifySignatureMiddleware as n, RouteRegistry as o, generateConventionRouteName as p, route as r, VersioningService as s, I18nModule as t, RouteRegistrationService as u, errorResponseSchema as v, Route as w, successMessageSchema as x, paginatedResponseSchema as y, TranslationMissingError as z };
 
-//# sourceMappingURL=i18n.module-CI_prYFD.mjs.map
+//# sourceMappingURL=i18n.module-CzXLW9Hy.mjs.map