stratal 0.0.22 → 0.0.24

package/dist/router-Cy6DjkvP.mjs

@@ -1,1852 +0,0 @@
-import { n as getContainer, r as runWithContainer } from "./container-storage-GpNNz79X.mjs";
-import { _ as getMethodInjections, c as DI_TOKENS, l as Request, m as inject, o as ROUTER_TOKENS, s as CONTAINER_TOKEN, u as Singleton } from "./di-BO1QIb5H.mjs";
-import { n as getMetadata, t as defineMetadata } from "./metadata-BVkc4aUu.mjs";
-import { n as __decorateParam, t as __decorate } from "./decorate-HgTKAYK8.mjs";
-import { LOGGER_TOKENS } from "./logger/index.mjs";
-import { d as abort, u as HttpException } from "./errors-BBZTnjdq.mjs";
-import { a as RouterContext, c as METHOD_STATUS_CODES, d as SECURITY_SCHEMES, f as VERSION_NEUTRAL, l as ROUTER_CONTEXT_KEYS, o as DEFAULT_CONTENT_TYPE, r as createHttpExceptionContext, s as HTTP_METHODS, u as ROUTE_METADATA_KEYS } from "./exception-context-B4kM-M53.mjs";
-import { o as RouterError, s as createThrottleMiddleware } from "./module-xYoHba6B.mjs";
-import { t as I18N_TOKENS } from "./i18n.tokens-hwRpmjRq.mjs";
-import { i as zod_exports, r as z, t as OpenAPIHono } from "./zod-hMa3rSHV.mjs";
-import { a as OPENAPI_TOKENS } from "./openapi-C6lm0RmV.mjs";
-import { i as getMethodGuards, r as getControllerGuards, t as GuardExecutionService } from "./guards-Ced-uNIF.mjs";
-import { n as getRateLimits } from "./rate-limit.decorator-D69zdZbp.mjs";
-import { n as getControllerOptions, r as getControllerRoute } from "./controller.decorator-DIUazNU7.mjs";
-import { a as getWsOnCloseMethod, o as getWsOnErrorMethod, s as getWsOnMessageMethod, t as GatewayContext, u as isGateway } from "./gateway-context-CFe6a9gz.mjs";
-import "./http-method.decorator-CdjKFJZZ.mjs";
-import { n as verifySignedUrl, t as signUrl } from "./signed-url-BqUqt5dF.mjs";
-import { languageDetector } from "hono/language";
-//#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/errors/schema-validation.error.ts
-var SchemaValidationError = class extends HttpException {
-	issues;
-	constructor(zodError) {
-		super(400, "Schema validation failed");
-		this.issues = zodError.issues.map((err) => ({
-			path: err.path.join("."),
-			message: err.message,
-			code: err.code
-		}));
-	}
-};
-//#endregion
-//#region src/router/errors/index.ts
-/**
-* Error thrown when a signed URL has an invalid or expired signature.
-*
-* HTTP Status: 403 Forbidden
-*/
-var InvalidSignatureError = class extends HttpException {
-	constructor() {
-		super(403, "Invalid or expired signature");
-	}
-};
-/**
-* ResponseValidationError
-*
-* Thrown when a controller's response body does not match the declared Zod response schema.
-* Indicates a server-side schema mismatch — the controller is returning data that
-* violates its own API contract.
-*/
-var ResponseValidationError = class extends HttpException {
-	issues;
-	constructor(zodError) {
-		super(500, "Response validation failed");
-		this.issues = zodError.issues.map((err) => ({
-			path: err.path.join("."),
-			message: err.message,
-			code: err.code
-		}));
-	}
-};
-//#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/middleware/domain.middleware.ts
-/**
-* Parse a domain pattern into a regex and extract parameter names.
-*
-* @example
-* parseDomainPattern('{tenant}.example.com')
-* // => { regex: /^([^.]+)\.example\.com$/, paramNames: ['tenant'] }
-*
-* parseDomainPattern('{region}.{tenant}.example.com')
-* // => { regex: /^([^.]+)\.([^.]+)\.example\.com$/, paramNames: ['region', 'tenant'] }
-*/
-function parseDomainPattern(pattern) {
-	const paramNames = [];
-	const escaped = pattern.replace(/\{([a-zA-Z_][a-zA-Z0-9_]*)\}/g, (_match, paramName) => {
-		paramNames.push(paramName);
-		return "([^.]+)";
-	}).replace(/\./g, "\\.");
-	return {
-		regex: new RegExp(`^${escaped}$`),
-		paramNames
-	};
-}
-/**
-* Strip port number from a host header value.
-* 'example.com:8787' => 'example.com'
-*/
-function stripPort(host) {
-	const colonIdx = host.lastIndexOf(":");
-	if (colonIdx === -1) return host;
-	const afterColon = host.slice(colonIdx + 1);
-	return /^\d+$/.test(afterColon) ? host.slice(0, colonIdx) : host;
-}
-/**
-* Create a Hono middleware that matches the request host against a domain pattern.
-*
-* When the host matches, domain parameters are extracted and stored in context
-* variables accessible via `ctx.domain(key)`.
-*
-* When the host does NOT match, aborts with 404.
-*
-* @param pattern - Domain pattern with `{param}` placeholders (e.g., '{tenant}.myapp.com')
-*
-* @example
-* ```typescript
-* // Applied automatically by RouteRegistrationService for controllers with domain config
-* @Controller('/dashboard', { domain: '{tenant}.myapp.com' })
-* export class DashboardController {
-*   async index(ctx: RouterContext) {
-*     const tenant = ctx.domain('tenant')
-*   }
-* }
-* ```
-*/
-function createDomainMiddleware(pattern) {
-	const { regex, paramNames } = parseDomainPattern(pattern);
-	return async (c, next) => {
-		const host = stripPort(c.req.header("host") ?? "");
-		const match = regex.exec(host);
-		if (!match) abort(404, "Domain mismatch");
-		for (let i = 0; i < paramNames.length; i++) c.set(`domain:${paramNames[i]}`, match[i + 1]);
-		await next();
-	};
-}
-//#endregion
-//#region src/router/middleware/middleware-chain.ts
-/**
-* Create a Hono middleware handler that executes a chain of Stratal middleware classes.
-*
-* Each middleware is resolved from the request-scoped container per request,
-* then executed in order (first registered = outermost in the chain).
-*
-* @param classes - Middleware classes to chain
-* @returns Hono middleware handler
-*/
-function createMiddlewareChain(classes) {
-	return async (c, next) => {
-		const requestContainer = c.get(ROUTER_CONTEXT_KEYS.REQUEST_CONTAINER);
-		const ctx = new RouterContext(c);
-		let current = next;
-		for (let i = classes.length - 1; i >= 0; i--) {
-			const prevNext = current;
-			const middlewareClass = classes[i];
-			current = () => {
-				const middleware = requestContainer.resolve(middlewareClass);
-				let called = false;
-				const guardedNext = () => {
-					if (called) return Promise.reject(new RouterError(`Middleware "${middlewareClass.name ?? "anonymous"}" called next() multiple times`));
-					called = true;
-					return prevNext();
-				};
-				return middleware.handle(ctx, guardedNext);
-			};
-		}
-		const result = await current();
-		if (result instanceof Response) return result;
-	};
-}
-//#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.
-*
-* **Cannot be mixed with HTTP method decorators** (`@Get`, `@Post`, `@Put`, `@Patch`,
-* `@Delete`, `@All`) in the same controller. Use one pattern or the other.
-*
-* Stores route configuration (schemas, response, tags, security) in metadata.
-* HTTP method, path, and success status code are auto-derived from the method name:
-* - index() → GET /base-path → 200
-* - show() → GET /base-path/:id → 200
-* - create() → POST /base-path → 201
-* - update() → PUT /base-path/:id → 200
-* - patch() → PATCH /base-path/:id → 200
-* - destroy() → DELETE /base-path/:id → 200
-*
-* @param config - Route configuration (schemas, response, tags, security)
-*
-* @example
-* ```typescript
-* @Controller('/api/v1/notes', {
-*   tags: ['Notes'],
-*   security: ['bearerAuth']
-* })
-* export class NotesController implements Controller {
-*   @Route({
-*     body: createNoteSchema,
-*     response: noteSchema, // 201 auto-derived from 'create' method
-*     tags: ['Mutations'],
-*     description: 'Create a new note'
-*   })
-*   async create(ctx: RouterContext): Promise<Response> {
-*     // POST /api/v1/notes (auto-derived from method name)
-*     // Body schema: createNoteSchema (auto-validated)
-*     // Response: 201 → noteSchema (status auto-derived)
-*     // Tags: ['Notes', 'Mutations'] (merged with controller)
-*     // Security: ['bearerAuth'] (inherited from controller)
-*     const body = ctx.body()
-*     const note = await this.notesService.create(body)
-*     return ctx.json(note, 201)
-*   }
-*
-*   @Route({
-*     query: paginationSchema,
-*     response: z.array(noteSchema) // 200 auto-derived from 'index' method
-*   })
-*   async index(ctx: RouterContext): Promise<Response> {
-*     // GET /api/v1/notes (auto-derived)
-*     // Query params auto-validated
-*     const notes = await this.notesService.list()
-*     return ctx.json(notes)
-*   }
-*
-*   @Route({
-*     params: z.object({ id: z.string().uuid() }),
-*     response: {
-*       schema: noteSchema,
-*       description: 'Note details'
-*     },
-*     security: [] // Override to make public
-*   })
-*   async show(ctx: RouterContext): Promise<Response> {
-*     // GET /api/v1/notes/:id (auto-derived)
-*     // URL params auto-validated
-*     // Response: 200 → noteSchema (status auto-derived)
-*     // Security: [] (public route, override controller security)
-*     const id = ctx.param('id')
-*     const note = await this.notesService.findById(id)
-*     return ctx.json(note)
-*   }
-* }
-* ```
-*/
-function Route(config) {
-	return function(target, propertyKey, descriptor) {
-		const metadata = {
-			type: "convention",
-			config
-		};
-		defineMetadata(ROUTE_METADATA_KEYS.ROUTE_CONFIG, metadata, target, propertyKey);
-		const existing = getMetadata(ROUTE_METADATA_KEYS.DECORATED_METHODS, target) ?? [];
-		existing.push(propertyKey);
-		defineMetadata(ROUTE_METADATA_KEYS.DECORATED_METHODS, existing, target);
-		return descriptor;
-	};
-}
-/**
-* Get the route metadata from a controller method
-*
-* @param target - Controller instance or prototype
-* @param methodName - Name of the method
-* @returns Route metadata or undefined if not decorated
-*/
-function getRouteMetadata(target, methodName) {
-	return getMetadata(ROUTE_METADATA_KEYS.ROUTE_CONFIG, target, methodName);
-}
-/**
-* Get all methods with route decorators (@Route, @Get, @Post, etc.) from a controller
-*
-* @param ControllerClass - Controller class
-* @returns Array of method names that have route metadata
-*/
-function getRouteDecoratedMethods(ControllerClass) {
-	const methods = /* @__PURE__ */ new Set();
-	let proto = ControllerClass.prototype;
-	while (proto && proto !== Object.prototype) {
-		const own = getMetadata(ROUTE_METADATA_KEYS.DECORATED_METHODS, proto);
-		if (own) for (const m of own) methods.add(m);
-		proto = Object.getPrototypeOf(proto);
-	}
-	return [...methods];
-}
-//#endregion
-//#region src/router/schemas/common.schemas.ts
-/**
-* Common OpenAPI Schemas
-*
-* Reusable schema definitions for common API patterns:
-* - Error responses
-* - Pagination
-* - Common parameters
-*/
-/**
-* Generic error response schema
-* Used for all error responses (4xx, 5xx)
-* Matches the ErrorResponse shape produced by ExceptionHandler
-*/
-const errorResponseSchema = z.object({
-	message: z.string().describe("Human-readable error message"),
-	timestamp: z.string().datetime().describe("ISO timestamp when error occurred"),
-	stack: z.string().optional().describe("Stack trace (development only)")
-}).openapi("ErrorResponse");
-/**
-* Validation error response schema
-* Used for 400 Bad Request with validation failures
-* Matches the ErrorResponse shape produced by ExceptionHandler
-*/
-const validationErrorResponseSchema = errorResponseSchema.openapi("ValidationErrorResponse");
-/**
-* Pagination query parameters schema
-* Used for list endpoints
-*/
-const paginationQuerySchema = z.object({
-	page: z.coerce.number().int().positive().default(1).describe("Page number (1-indexed)"),
-	limit: z.coerce.number().int().positive().max(100).default(20).describe("Items per page (max 100)")
-}).openapi("PaginationQuery");
-/**
-* Paginated response wrapper schema
-* Generic wrapper for paginated list responses
-*/
-const paginatedResponseSchema = (itemSchema) => z.object({
-	data: z.array(itemSchema).describe("Array of items for current page"),
-	pagination: z.object({
-		page: z.number().int().positive().describe("Current page number"),
-		limit: z.number().int().positive().describe("Items per page"),
-		total: z.number().int().nonnegative().describe("Total number of items"),
-		totalPages: z.number().int().nonnegative().describe("Total number of pages")
-	})
-});
-/**
-* UUID parameter schema
-* Used for :id parameters in RESTful routes
-*/
-const uuidParamSchema = z.object({ id: z.string().uuid().describe("Resource UUID") }).openapi("UUIDParam");
-/**
-* Success message response schema
-* Used for operations that don't return data (e.g., DELETE)
-*/
-const successMessageSchema = z.object({
-	message: z.string().describe("Success message"),
-	data: z.record(z.string(), z.unknown()).optional().describe("Optional additional data")
-}).openapi("SuccessMessage");
-/**
-* Common HTTP status error schemas
-* Pre-configured for standard error responses
-*/
-const commonErrorSchemas = {
-	400: {
-		schema: validationErrorResponseSchema,
-		description: "Validation error"
-	},
-	401: {
-		schema: errorResponseSchema,
-		description: "Unauthorized"
-	},
-	403: {
-		schema: errorResponseSchema,
-		description: "Forbidden"
-	},
-	404: {
-		schema: errorResponseSchema,
-		description: "Not found"
-	},
-	409: {
-		schema: errorResponseSchema,
-		description: "Conflict"
-	},
-	500: {
-		schema: errorResponseSchema,
-		description: "Internal server error"
-	}
-};
-//#endregion
-//#region src/router/utils/path.ts
-/**
-* Path normalization and route ordering utilities.
-*
-* Users always write Hono-style `:param` paths (`:companyId`, `:id`).
-* OpenAPI requires `{param}` style — conversion happens only at registration time.
-*/
-/**
-* Convert Hono-style `:param` path segments to OpenAPI-style `{param}`.
-* Strips regex constraints (e.g., `:locale{sw}` → `{locale}`).
-*
-* @example
-* toOpenAPIPath('/users/:id')                    // '/users/{id}'
-* toOpenAPIPath('/:companyId/users/:userId')     // '/{companyId}/users/{userId}'
-* toOpenAPIPath('/users/:id/posts')              // '/users/{id}/posts'
-* toOpenAPIPath('/:locale{en|fr}/users')         // '/{locale}/users'
-*/
-function toOpenAPIPath(path) {
-	return path.replace(/:([a-zA-Z_][a-zA-Z0-9_]*)(\{[^}]*\})?/g, "{$1}");
-}
-/**
-* Convert Hono-style `:param` path segments to OpenAPI-style `{param}`,
-* preserving regex constraints.
-*
-* Used for Hono route registration via `app.openapi()`. The non-greedy
-* regex in `@hono/zod-openapi` (`\/{(.+?)}/g`) converts `{param}` back
-* to `:param` while leaving the constraint suffix intact.
-*
-* @example
-* toRoutingOpenAPIPath('/:locale{sw}/users/:id')  // '/{locale}{sw}/users/{id}'
-* toRoutingOpenAPIPath('/users/:id')               // '/users/{id}'
-*/
-function toRoutingOpenAPIPath(path) {
-	return path.replace(/:([a-zA-Z_][a-zA-Z0-9_]*)(\{[^}]*\})?/g, (_, name, constraint) => constraint ? `{${name}}${constraint}` : `{${name}}`);
-}
-/**
-* Compute a packed specificity key for route ordering.
-* Encodes both score and segment count into a single number to avoid object allocation.
-*
-* Lower score = higher priority (registered first in Hono).
-* 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(route) {
-	const segmentCount = countSegments(route.path);
-	const scoringPath = route.isLocaleVariant ? route.path.replace(/^\/:locale\{[^}]*\}/, "") || "/" : route.path;
-	let score = 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) {
-			i++;
-			continue;
-		}
-		let end = path.indexOf("/", i);
-		if (end === -1) end = path.length;
-		count++;
-		i = end;
-	}
-	return count;
-}
-/**
-* Compute a specificity score for route ordering.
-* Lower score = higher priority (registered first in Hono).
-*
-* Scoring: static = 0, `:param{constraint}` = 5, `:param` = 10, wildcard `{.+}` / `{.*}` = 100.
-*/
-function getPathSpecificityScore(path) {
-	const segments = path.split("/").filter(Boolean);
-	let score = 0;
-	for (const segment of segments) if (segment.includes("{.+}") || segment.includes("{.*}")) score += 100;
-	else if (segment.startsWith(":") && segment.includes("{")) score += 5;
-	else if (segment.startsWith(":")) score += 10;
-	return score;
-}
-/**
-* Sort routes by specificity so Hono registers them in the correct order.
-*
-* 1. Static paths before parameterized before wildcards
-* 2. More segments = more specific (tie-breaker)
-* 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));
-	const copy = routes.slice();
-	copy.sort((a, b) => keys.get(a) - keys.get(b));
-	return copy;
-}
-//#endregion
-//#region src/router/utils/route-name.ts
-/**
-* Route naming utilities.
-*
-* Extracts parameter names from paths and domains,
-* and generates convention-based route names.
-*/
-/**
-* Extract parameter names from a Hono-style path.
-*
-* @example
-* extractParamNames('/users/:id')                     // ['id']
-* extractParamNames('/:companyId/users/:userId')      // ['companyId', 'userId']
-* extractParamNames('/users')                         // []
-*/
-function extractParamNames(path) {
-	if (!path.includes(":")) return [];
-	return [...path.matchAll(/:([a-zA-Z_][a-zA-Z0-9_]*)/g)].map((m) => m[1]);
-}
-/**
-* Extract parameter names from a domain pattern.
-*
-* @example
-* extractDomainParamNames('{tenant}.example.com')           // ['tenant']
-* extractDomainParamNames('{region}.{tenant}.example.com')  // ['region', 'tenant']
-* extractDomainParamNames('example.com')                    // []
-*/
-function extractDomainParamNames(domain) {
-	if (!domain.includes("{")) return [];
-	return [...domain.matchAll(/\{([a-zA-Z_][a-zA-Z0-9_]*)\}/g)].map((m) => m[1]);
-}
-/**
-* Auto-generate a route name for convention-based `@Route` methods.
-*
-* Strips common prefixes (`/api/`, `/v{N}/`) and parameter segments,
-* then joins remaining static segments with dots and appends the method name.
-*
-* @example
-* generateConventionRouteName('/users', 'index')                         // 'users.index'
-* generateConventionRouteName('/users', 'show')                          // 'users.show'
-* generateConventionRouteName('/api/v1/users', 'create')                 // 'users.create'
-* generateConventionRouteName('/api/v1/users/:userId/notes', 'index')    // 'users.notes.index'
-* generateConventionRouteName('/:companyId/users', 'index')              // 'users.index'
-* generateConventionRouteName('/users/:userId/notes/:noteId/tags', 'index') // 'users.notes.tags.index'
-*/
-function generateConventionRouteName(basePath, methodName) {
-	const parts = basePath.split("/");
-	const segments = [];
-	for (const s of parts) if (s && s !== "api" && !s.startsWith(":") && !/^v\d+$/.test(s)) segments.push(s);
-	if (segments.length === 0) return methodName;
-	return `${segments.join(".")}.${methodName}`;
-}
-//#endregion
-//#region src/router/services/route-registration.service.ts
-const invokeHandler = (instance, method, ...args) => {
-	try {
-		return Promise.resolve(instance[method](...args));
-	} catch (err) {
-		return Promise.reject(err);
-	}
-};
-let RouteRegistrationService = class RouteRegistrationService {
-	logger;
-	registry;
-	routerResolver;
-	localePathService;
-	app;
-	moduleRegistry;
-	controllerClasses = /* @__PURE__ */ new Map();
-	upgradeWebSocketFn = null;
-	constructor(logger, registry, routerResolver, localePathService, app, moduleRegistry) {
-		this.logger = logger;
-		this.registry = registry;
-		this.routerResolver = routerResolver;
-		this.localePathService = localePathService;
-		this.app = app;
-		this.moduleRegistry = moduleRegistry;
-	}
-	/**
-	* Configure router with controllers and global middleware.
-	* Resolves controllers from ModuleRegistry and global middleware from RouterResolver.
-	*/
-	async configure() {
-		const controllers = this.moduleRegistry.getAllControllers();
-		const globalMiddleware = this.routerResolver?.getGlobalMiddleware() ?? [];
-		this.logger.info("Registering controllers", { controllerCount: controllers.length });
-		if (globalMiddleware.length > 0) this.app.use("*", createMiddlewareChain(globalMiddleware));
-		if (controllers.some(isGateway)) {
-			const { upgradeWebSocket } = await import("hono/cloudflare-workers");
-			this.upgradeWebSocketFn = upgradeWebSocket;
-		}
-		const actions = /* @__PURE__ */ new WeakMap();
-		for (const ControllerClass of controllers) this.collectRoutes(ControllerClass, actions);
-		for (const route of this.registry.all()) actions.get(route)?.();
-		this.logger.info("Controller registration complete");
-	}
-	/**
-	* Pass 1: Collect routes from a controller into RouteRegistry and store Hono actions.
-	* Versioning and locale expansion are handled by RouteRegistry.register().
-	*/
-	collectRoutes(ControllerClass, actions) {
-		const isWsGateway = isGateway(ControllerClass);
-		const controllerRoute = getControllerRoute(ControllerClass);
-		if (!controllerRoute) throw new RouterError(`Controller "${ControllerClass.name}" registration failed: ${isWsGateway ? "Missing @Gateway decorator or route metadata" : "Missing @Controller decorator or route metadata"}`);
-		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,
-				version: effectiveVersion,
-				domain: effectiveDomain,
-				controller: ControllerClass.name,
-				action: "ws",
-				hidden: routerConfig.hideFromDocs ?? false,
-				middleware: wsMiddleware.map((m) => m.name)
-			});
-			for (const route of expandedRoutes) actions.set(route, () => {
-				if (wsMiddleware.length > 0) this.app.use(route.path, createMiddlewareChain(wsMiddleware));
-				if (effectiveDomain) {
-					const domainHandler = createDomainMiddleware(effectiveDomain);
-					this.app.use(route.path, domainHandler);
-					this.app.use(`${route.path}/*`, domainHandler);
-				}
-				this.registerGatewayForPath(ControllerClass, route.path, controllerGuards);
-			});
-			return;
-		}
-		const className = ControllerClass.name;
-		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,
-				version: effectiveVersion,
-				domain: effectiveDomain,
-				controller: className,
-				action: "handle",
-				hidden: routerConfig.hideFromDocs ?? false,
-				middleware: wildcardMiddleware.map((m) => m.name)
-			});
-			for (const route of expandedRoutes) actions.set(route, () => {
-				if (wildcardMiddleware.length > 0) this.app.use(route.path, createMiddlewareChain(wildcardMiddleware));
-				this.registerWildcardRoute(ControllerClass, route.path);
-			});
-			return;
-		}
-		const decoratedMethods = getRouteDecoratedMethods(ControllerClass);
-		if (decoratedMethods.length === 0) throw new RouterError(`Controller "${ControllerClass.name}" registration failed: No route decorators found. Use @Route() or HTTP method decorators (@Get, @Post, etc.) on controller methods.`);
-		const methodMetadata = [];
-		let hasConvention = false;
-		let hasExplicit = false;
-		for (const m of decoratedMethods) {
-			const meta = getRouteMetadata(prototype, m);
-			if (!meta) continue;
-			methodMetadata.push({
-				method: m,
-				meta
-			});
-			if (meta.type === "convention") hasConvention = true;
-			else if (meta.type === "explicit") hasExplicit = true;
-		}
-		if (hasConvention && hasExplicit) throw new RouterError(`Controller "${ControllerClass.name}" registration failed: Cannot mix @Route() with HTTP method decorators (@Get, @Post, etc.) in the same controller. Use one pattern or the other.`);
-		const routerHidden = routerConfig.hideFromDocs;
-		const controllerHidden = controllerOpts?.hideFromDocs ?? false;
-		const routerName = routerConfig.name;
-		const controllerName = controllerOpts?.name;
-		const effectiveNamePrefix = routerName && controllerName ? `${routerName}${controllerName}` : routerName ?? controllerName;
-		for (const { method: methodName, meta } of methodMetadata) {
-			const resolved = this.resolveMethodAndPath(meta, methodName, basePath, className);
-			if (!resolved) continue;
-			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;
-			else if (meta.type === "convention") {
-				const autoName = generateConventionRouteName(basePath, methodName);
-				routeName = effectiveNamePrefix ? `${effectiveNamePrefix}${autoName}` : autoName;
-			}
-			const expandedRoutes = this.registry.register({
-				name: routeName,
-				method: httpMethod,
-				basePath: fullPath,
-				version: effectiveVersion,
-				domain: effectiveDomain,
-				controller: className,
-				action: methodName,
-				hidden: hideFromDocs,
-				middleware: middlewareNames
-			});
-			const methodGuards = getMethodGuards(prototype, methodName)?.guards ?? [];
-			const allGuards = methodGuards.length > 0 ? [...controllerGuards, ...methodGuards] : controllerGuards;
-			const responseSchema = httpMethod !== "all" ? this.extractResponseSchema(routeConfig) : null;
-			const handler = this.createControllerHandler(ControllerClass, methodName, responseSchema);
-			for (const route of expandedRoutes) actions.set(route, () => {
-				if (effectiveDomain) {
-					const domainHandler = createDomainMiddleware(effectiveDomain);
-					this.app.use(route.path, domainHandler);
-					this.app.use(`${route.path}/*`, domainHandler);
-				}
-				if (allGuards.length > 0) this.logger.info(`Route guards`, {
-					controller: className,
-					method: httpMethod.toUpperCase(),
-					path: route.path,
-					methodName,
-					guardCount: allGuards.length
-				});
-				if (httpMethod === "all") {
-					this.logger.info(`Registering @All route`, {
-						controller: className,
-						path: route.path,
-						methodName
-					});
-					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;
-				}
-				const metadata = this.mergeMetadata(controllerOpts, routeConfig, ControllerClass, methodName);
-				const openApiRoute = this.buildOpenAPIRoute(httpMethod, route.path, routeConfig, metadata, meta.type === "convention" ? methodName : void 0, statusCodeOverride, route.isLocaleVariant ?? false);
-				this.logger.info(`Registering route`, {
-					controller: className,
-					method: httpMethod.toUpperCase(),
-					path: route.path,
-					methodName,
-					tags: metadata.tags,
-					hidden: route.hidden
-				});
-				const wrappedHandler = this.wrapHandlerWithChain(handler, effectiveMiddleware, allGuards);
-				this.app.openapi(openApiRoute, wrappedHandler);
-				if (!route.hidden) {
-					const { hide: _, ...specRoute } = openApiRoute;
-					this.app.openAPIRegistry.registerPath({
-						...specRoute,
-						path: toOpenAPIPath(route.path)
-					});
-				}
-			});
-		}
-	}
-	/**
-	* Register a single WebSocket gateway route
-	*/
-	registerGatewayForPath(GatewayClass, fullPath, guards) {
-		const onMsgMethod = getWsOnMessageMethod(GatewayClass);
-		const onCloseMethod = getWsOnCloseMethod(GatewayClass);
-		const onErrMethod = getWsOnErrorMethod(GatewayClass);
-		const wsHandler = this.upgradeWebSocketFn((c) => {
-			const gateway = new RouterContext(c).getContainer().resolve(GatewayClass);
-			const events = {};
-			const bindWsHandler = (method, onCatch) => {
-				return (evt, ws) => {
-					invokeHandler(gateway, method, evt, new GatewayContext(c, ws)).catch((err) => {
-						this.logger.error(`WebSocket ${method} handler error`, err, { gateway: GatewayClass.name });
-						onCatch?.(err, ws);
-					});
-				};
-			};
-			if (onMsgMethod) events.onMessage = bindWsHandler(onMsgMethod, (_err, ws) => ws.close(1011, "Internal Error"));
-			if (onCloseMethod) events.onClose = bindWsHandler(onCloseMethod);
-			else events.onClose = (_evt, ws) => {
-				ws.close();
-			};
-			if (onErrMethod) events.onError = bindWsHandler(onErrMethod);
-			return events;
-		});
-		this.nameHandler(wsHandler, GatewayClass.name, onMsgMethod ?? "[anonymous]", "ws");
-		this.logger.info("Registering WebSocket gateway", {
-			gateway: GatewayClass.name,
-			path: fullPath
-		});
-		const handlers = [];
-		if (guards.length > 0) {
-			this.logger.info("Gateway guards", {
-				gateway: GatewayClass.name,
-				path: fullPath,
-				guardCount: guards.length
-			});
-			handlers.push(this.createGuardMiddleware(guards));
-		}
-		handlers.push(wsHandler);
-		this.app.get(fullPath, ...handlers);
-	}
-	/**
-	* Create a guard execution middleware
-	*
-	* This middleware executes all guards for a route before the handler.
-	* Guards are executed in order; all must pass for the request to proceed.
-	*
-	* @param guards - Array of guards to execute
-	* @returns Hono middleware function
-	*/
-	createGuardMiddleware(guards) {
-		const guardService = new GuardExecutionService(this.logger);
-		return async (c, next) => {
-			const ctx = new RouterContext(c);
-			const container = ctx.getContainer();
-			await guardService.executeGuards(guards, ctx, container);
-			await next();
-		};
-	}
-	/**
-	* Wrap a controller handler with a `scopedMiddleware → guards → handler`
-	* chain that runs *inside* the Hono route handler — after request
-	* validators have populated `c.req.valid(...)`. This is the only place
-	* we can run user middleware after `@hono/zod-openapi`'s validators in
-	* the same pipeline.
-	*
-	* Returns a Hono handler with the same signature as the original so
-	* `app.openapi(route, wrapped)` works transparently.
-	*/
-	wrapHandlerWithChain(handler, scopedMiddleware, guards) {
-		if (scopedMiddleware.length === 0 && guards.length === 0) return handler;
-		const scopedChain = scopedMiddleware.length > 0 ? createMiddlewareChain(scopedMiddleware) : null;
-		const guardChain = guards.length > 0 ? this.createGuardMiddleware(guards) : null;
-		return async (c) => {
-			let captured;
-			const runHandler = async () => {
-				captured = await handler(c);
-			};
-			const runGuards = guardChain ? () => guardChain(c, runHandler) : runHandler;
-			const result = await (scopedChain ? () => scopedChain(c, runGuards) : runGuards)();
-			if (result instanceof Response) return result;
-			return captured;
-		};
-	}
-	/**
-	* Register wildcard route for non-RESTful controllers
-	*/
-	registerWildcardRoute(ControllerClass, route) {
-		this.logger.info(`Registering wildcard route`, {
-			controller: ControllerClass.name,
-			route: `${route}/:path{.+}`,
-			method: "ALL"
-		});
-		const handler = this.createControllerHandler(ControllerClass, "handle");
-		this.app.all(route, handler);
-		this.app.all(`${route}/:path{.+}`, handler);
-	}
-	/**
-	* Resolve HTTP method, path, route config, and status code from route metadata.
-	*/
-	resolveMethodAndPath(meta, methodName, basePath, className) {
-		if (meta.type === "convention") {
-			const derived = this.deriveHttpMethodAndPath(methodName, basePath);
-			if (!derived) throw new RouterError(`Cannot derive HTTP method/path for convention-based route "${className}.${methodName}". Ensure the method name follows the naming convention (e.g., index, create, show).`);
-			return {
-				httpMethod: derived.method,
-				fullPath: derived.path,
-				routeConfig: meta.config,
-				statusCodeOverride: meta.config.statusCode
-			};
-		}
-		return {
-			httpMethod: meta.method,
-			fullPath: this.joinPaths(basePath, meta.path),
-			routeConfig: meta.config,
-			statusCodeOverride: meta.config.statusCode
-		};
-	}
-	/**
-	* Join a base path and a route path, normalizing slashes
-	*/
-	joinPaths(basePath, routePath) {
-		if (basePath.endsWith("/")) basePath = basePath.slice(0, -1);
-		if (routePath === "/" || routePath === "") return basePath || "/";
-		if (!routePath.startsWith("/")) routePath = "/" + routePath;
-		return basePath + routePath;
-	}
-	/**
-	* Auto-derive HTTP method and path from controller method name
-	* Uses HTTP_METHODS constant for RESTful convention mapping
-	*/
-	deriveHttpMethodAndPath(methodName, basePath) {
-		if (!(methodName in HTTP_METHODS)) return null;
-		const mapping = HTTP_METHODS[methodName];
-		return {
-			method: mapping.method,
-			path: basePath + mapping.path
-		};
-	}
-	/**
-	* Merge controller-level and route-level metadata
-	* Tags are merged (appended), security is merged (union)
-	* Guards automatically add sessionCookie security if present
-	*/
-	mergeMetadata(controllerOpts, routeConfig, ControllerClass, methodName) {
-		const tags = [...controllerOpts?.tags ?? [], ...routeConfig.tags ?? []];
-		const prototype = ControllerClass.prototype;
-		const hasMethodGuards = (getMethodGuards(prototype, methodName)?.guards.length ?? 0) > 0;
-		const hasControllerGuards = (getControllerGuards(ControllerClass)?.guards.length ?? 0) > 0;
-		const requiresAuth = hasMethodGuards || hasControllerGuards;
-		let security = [];
-		if (routeConfig.security !== void 0) security = [...controllerOpts?.security ?? [], ...routeConfig.security];
-		else if (controllerOpts?.security) security = controllerOpts.security;
-		if (requiresAuth && !security.includes(SECURITY_SCHEMES.SESSION_COOKIE)) security.push(SECURITY_SCHEMES.SESSION_COOKIE);
-		return {
-			tags,
-			security: security.length > 0 ? security.map((scheme) => ({ [scheme]: [] })) : []
-		};
-	}
-	/**
-	* Build OpenAPI route configuration from metadata
-	* Creates a route definition compatible with @hono/zod-openapi.
-	*
-	* Scoped middleware and guards are NOT attached to `route.middleware`
-	* here — they're composed into a wrapped handler in `collectRoutes` so
-	* they run after Hono's request validators. See `wrapHandlerWithChain`.
-	*/
-	buildOpenAPIRoute(method, path, routeConfig, metadata, methodName, statusCodeOverride, hasLocaleParam = false) {
-		try {
-			const route = {
-				method,
-				path: toRoutingOpenAPIPath(path),
-				request: {},
-				responses: {},
-				hide: true
-			};
-			if (routeConfig.body) {
-				const bodySchema = this.isRouteBodyObject(routeConfig.body) ? routeConfig.body.schema : routeConfig.body;
-				const bodyContentType = this.isRouteBodyObject(routeConfig.body) ? routeConfig.body.contentType ?? "application/json" : DEFAULT_CONTENT_TYPE;
-				route.request = {
-					...route.request,
-					body: { content: { [bodyContentType]: { schema: bodySchema } } }
-				};
-			}
-			if (routeConfig.query) route.request = {
-				...route.request,
-				query: routeConfig.query
-			};
-			if (routeConfig.params) route.request = {
-				...route.request,
-				params: routeConfig.params
-			};
-			const localeConfig = this.localePathService.localePathConfig;
-			if (hasLocaleParam && localeConfig) {
-				const localeParam = z.object({ locale: z.enum(localeConfig.prefixedLocales).openapi({ param: {
-					name: "locale",
-					in: "path"
-				} }).optional() });
-				route.request = {
-					...route.request,
-					params: route.request.params ? route.request.params.extend(localeParam.shape) : localeParam
-				};
-			}
-			const successStatus = statusCodeOverride ?? (methodName && METHOD_STATUS_CODES[methodName]) ?? 200;
-			const responses = {};
-			const responseDef = routeConfig.response;
-			if (responseDef) if (typeof responseDef === "object" && "schema" in responseDef) responses[successStatus] = {
-				content: { [responseDef.contentType ?? "application/json"]: { schema: responseDef.schema } },
-				description: responseDef.description ?? `Response ${successStatus}`
-			};
-			else responses[successStatus] = {
-				content: { [DEFAULT_CONTENT_TYPE]: { schema: responseDef } },
-				description: `Response ${successStatus}`
-			};
-			for (const [statusStr, schema] of Object.entries(commonErrorSchemas)) {
-				const status = parseInt(statusStr);
-				responses[status] ??= schema;
-			}
-			route.responses = responses;
-			if (metadata.tags.length > 0) route.tags = metadata.tags;
-			if (metadata.security.length > 0) route.security = metadata.security;
-			if (routeConfig.description) route.description = routeConfig.description;
-			if (routeConfig.summary) route.summary = routeConfig.summary;
-			return (0, zod_exports.createRoute)(route);
-		} catch (error) {
-			throw new RouterError(`OpenAPI route registration failed for "${path}": ${error instanceof Error ? error.message : String(error)}`);
-		}
-	}
-	/**
-	* Check if a body definition is a RouteBodyObject (has schema key) vs bare ZodType
-	*/
-	isRouteBodyObject(body) {
-		return typeof body === "object" && "schema" in body;
-	}
-	/**
-	* Resolve method parameter injections from the container
-	*
-	* @param prototype - Controller prototype
-	* @param methodName - Method name to get injections for
-	* @param container - Request-scoped container
-	* @returns Array of resolved dependencies in parameter order
-	*/
-	resolveMethodInjections(prototype, methodName, container) {
-		const injections = getMethodInjections(prototype, methodName);
-		if (!injections.length) return [];
-		return injections.map((inj) => container.resolve(inj.token));
-	}
-	/**
-	* Name a handler function so Hono's inspectRoutes() can identify it.
-	* Format: `{type}:{Controller}.{method}` (e.g. `http:UsersController.create`)
-	*/
-	nameHandler(fn, controller, method, type = "http") {
-		Object.defineProperty(fn, "name", { value: `${type}:${controller}.${method}` });
-	}
-	/**
-	* Create controller handler that resolves controller from request-scoped container
-	* This ensures each request gets a fresh controller with request-scoped context
-	*/
-	createControllerHandler(ControllerClass, methodName, responseSchema = null) {
-		const handler = async (c) => {
-			const ctx = new RouterContext(c);
-			const requestContainer = ctx.getContainer();
-			const controller = requestContainer.resolve(ControllerClass);
-			const method = controller[methodName];
-			if (typeof method === "function") {
-				const injectedArgs = this.resolveMethodInjections(ControllerClass.prototype, methodName, requestContainer);
-				const response = await method.apply(controller, [ctx, ...injectedArgs]);
-				if (responseSchema && c.env.ENVIRONMENT !== "production") return this.validateResponse(response, responseSchema);
-				return response;
-			}
-			throw new RouterError(`Method "${methodName}" not found on controller "${ControllerClass.name}"`);
-		};
-		this.nameHandler(handler, ControllerClass.name, methodName);
-		return handler;
-	}
-	/**
-	* Extract the Zod schema from a RouteResponse definition.
-	* Returns null for non-JSON content types or when no response is defined.
-	*/
-	extractResponseSchema(routeConfig) {
-		const responseDef = routeConfig.response;
-		if (!responseDef) return null;
-		if (this.isRouteResponseObject(responseDef)) {
-			if (!(responseDef.contentType ?? "application/json").includes("application/json")) return null;
-			return responseDef.schema;
-		}
-		return responseDef;
-	}
-	/**
-	* Check if a response definition is a RouteResponseObject (has schema key) vs bare ZodType
-	*/
-	isRouteResponseObject(response) {
-		return typeof response === "object" && "schema" in response;
-	}
-	/**
-	* Validate a Response body against its declared Zod schema.
-	*
-	* Skips validation for:
-	* - Non-JSON content types
-	* - Empty bodies (204 No Content, 304 Not Modified)
-	*
-	* Clones the response to read the body without consuming the original stream.
-	*/
-	async validateResponse(response, schema) {
-		const contentType = response.headers.get("content-type");
-		if (!contentType || !contentType.includes("application/json")) return response;
-		if (response.status === 204 || response.status === 304) return response;
-		const cloned = response.clone();
-		let body;
-		try {
-			body = await cloned.json();
-		} catch {
-			return response;
-		}
-		const result = schema.safeParse(body);
-		if (!result.success) throw new ResponseValidationError(result.error);
-		return response;
-	}
-};
-RouteRegistrationService = __decorate([
-	Singleton(),
-	__decorateParam(0, inject(LOGGER_TOKENS.LoggerService)),
-	__decorateParam(1, inject(ROUTER_TOKENS.RouteRegistry)),
-	__decorateParam(2, inject(ROUTER_TOKENS.RouterResolver, { isOptional: true })),
-	__decorateParam(3, inject(ROUTER_TOKENS.LocalePathService)),
-	__decorateParam(4, inject(ROUTER_TOKENS.HonoApp)),
-	__decorateParam(5, inject(DI_TOKENS.ModuleRegistry))
-], RouteRegistrationService);
-//#endregion
-//#region src/router/hono-app.ts
-const isMiddlewareClass = (arg) => typeof arg === "function" && arg.prototype && "handle" in arg.prototype;
-let HonoApp = class HonoApp extends OpenAPIHono {
-	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,
-			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;
-		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);
-		});
-		const trailingSlashRedirect = createTrailingSlashRedirect(trailingSlash);
-		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.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 handler = (c.get(ROUTER_CONTEXT_KEYS.REQUEST_CONTAINER) ?? this._container).resolve(DI_TOKENS.ExceptionHandler);
-		const ctx = createHttpExceptionContext(c);
-		return 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
-//#region src/i18n/i18n.options.ts
-/**
-* Resolve I18n options with defaults
-*/
-function resolveI18nOptions(options) {
-	const detection = options?.detection;
-	const enabled = detection ? detection.enabled !== false : true;
-	const strategy = detection && "strategy" in detection ? detection.strategy ?? "cookie" : "cookie";
-	const prefixDefaultLocale = detection && "prefixDefaultLocale" in detection && detection.prefixDefaultLocale !== void 0 ? detection.prefixDefaultLocale : false;
-	return {
-		defaultLocale: options?.defaultLocale ?? "en",
-		fallbackLocale: options?.fallbackLocale ?? "en",
-		locales: options?.locales ?? ["en"],
-		detection: {
-			enabled,
-			strategy,
-			prefixDefaultLocale
-		}
-	};
-}
-/**
-* Build Hono languageDetector options from I18n module options
-*/
-function buildDetectorOptions(options) {
-	const resolved = resolveI18nOptions(options);
-	const strategy = resolved.detection.strategy;
-	const detectorOptions = {
-		order: [strategy],
-		fallbackLanguage: resolved.defaultLocale,
-		supportedLanguages: resolved.locales,
-		lookupCookie: "locale",
-		lookupQueryString: "locale",
-		lookupFromPathIndex: 0,
-		ignoreCase: true
-	};
-	if (strategy === "cookie") {
-		detectorOptions.caches = ["cookie"];
-		if (options?.detection && "cookieOptions" in options.detection && options.detection.cookieOptions) detectorOptions.cookieOptions = options.detection.cookieOptions;
-	} else detectorOptions.caches = false;
-	return detectorOptions;
-}
-//#endregion
-//#region src/router/services/locale-path.service.ts
-let LocalePathService = class LocalePathService {
-	honoApp;
-	_config;
-	_pathDetectionEnabled;
-	_prefixDefaultLocale;
-	constructor(container, honoApp) {
-		this.honoApp = honoApp;
-		const i18nOptions = container.isRegistered(I18N_TOKENS.Options) ? container.resolve(I18N_TOKENS.Options) : void 0;
-		const detection = i18nOptions?.detection;
-		const detectionEnabled = detection ? detection.enabled !== false : true;
-		const strategy = (detection && "strategy" in detection && detection.strategy) ?? "cookie";
-		this._pathDetectionEnabled = detectionEnabled && strategy === "path";
-		this._prefixDefaultLocale = detection && "prefixDefaultLocale" in detection && detection.prefixDefaultLocale !== void 0 ? detection.prefixDefaultLocale : false;
-		if (this._pathDetectionEnabled) {
-			const allLocales = i18nOptions?.locales ?? ["en"];
-			const defaultLocale = i18nOptions?.defaultLocale ?? "en";
-			this._config = this._prefixDefaultLocale === true ? {
-				allLocales,
-				prefixedLocales: allLocales,
-				defaultLocale: null
-			} : {
-				allLocales,
-				prefixedLocales: allLocales.filter((l) => l !== defaultLocale),
-				defaultLocale
-			};
-		} else this._config = null;
-		if (detectionEnabled) this.setupLanguageDetection(i18nOptions);
-		if (this._config?.defaultLocale && this._prefixDefaultLocale === "redirect") this.setupDefaultLocaleRedirect(this._config.defaultLocale);
-	}
-	/** Whether path-based locale detection is enabled */
-	get enabled() {
-		return this._pathDetectionEnabled;
-	}
-	/** The computed locale path config, or null if path detection is disabled */
-	get localePathConfig() {
-		return this._config;
-	}
-	/** The prefixDefaultLocale setting (false, true, or 'redirect') */
-	get prefixDefaultLocale() {
-		return this._prefixDefaultLocale;
-	}
-	/**
-	* Expand a path into primary + locale-prefixed variants.
-	*
-	* @param path - The base path to expand
-	* @returns Array of resolved paths with locale metadata
-	*/
-	resolve(path) {
-		if (!this._config) return [{
-			path,
-			isLocaleVariant: false
-		}];
-		const constraint = this.buildLocaleConstraint();
-		const suffix = path === "/" ? "" : path;
-		if (this._config.defaultLocale === null) return [{
-			path: `/:locale${constraint}${suffix}`,
-			isLocaleVariant: true
-		}];
-		const result = [{
-			path,
-			isLocaleVariant: false
-		}];
-		if (this._config.prefixedLocales.length > 0) result.push({
-			path: `/:locale${constraint}${suffix}`,
-			isLocaleVariant: true
-		});
-		return result;
-	}
-	/**
-	* Build a Hono regex constraint from prefixed locales.
-	* e.g., `{en|de|fr}` — restricts `:locale` to only match known values.
-	*/
-	buildLocaleConstraint() {
-		return `{${(this._config.defaultLocale === null ? this._config.allLocales : this._config.prefixedLocales).join("|")}}`;
-	}
-	/**
-	* Apply Hono's languageDetector middleware and bridge the detected language
-	* to Stratal's LOCALE context variable.
-	*/
-	setupLanguageDetection(i18nOptions) {
-		const detectorOptions = buildDetectorOptions(i18nOptions);
-		this.honoApp.use("*", languageDetector(detectorOptions));
-		this.honoApp.use("*", async (c, next) => {
-			const language = c.get("language");
-			if (language) c.set(ROUTER_CONTEXT_KEYS.LOCALE, language);
-			await next();
-		});
-	}
-	/**
-	* Redirect requests that include the default locale prefix to the unprefixed path.
-	* For example, `/en/users` → 301 redirect to `/users`.
-	*
-	* Only active when `prefixDefaultLocale` is `'redirect'`.
-	*/
-	setupDefaultLocaleRedirect(defaultLocale) {
-		const prefix = `/${defaultLocale}`;
-		this.honoApp.use("*", async (c, next) => {
-			const path = new URL(c.req.url).pathname;
-			if (path === prefix || path.startsWith(`${prefix}/`)) {
-				const stripped = path.slice(prefix.length) || "/";
-				return c.redirect(stripped, 301);
-			}
-			await next();
-		});
-	}
-};
-LocalePathService = __decorate([
-	Singleton(),
-	__decorateParam(0, inject(CONTAINER_TOKEN)),
-	__decorateParam(1, inject(ROUTER_TOKENS.HonoApp))
-], LocalePathService);
-//#endregion
-//#region src/router/services/versioning.service.ts
-let VersioningService = class VersioningService {
-	options;
-	constructor(app) {
-		this.options = app.config.versioning ?? null;
-	}
-	/** Whether versioning is enabled */
-	get enabled() {
-		return this.options !== null;
-	}
-	/**
-	* Resolve versioned paths for a base path.
-	*
-	* @param basePath - The base path (e.g., '/users')
-	* @param version - Explicit version from controller/router config
-	* @returns Array of versioned path strings (e.g., ['/v1/users', '/v2/users'])
-	*/
-	resolve(basePath, version) {
-		if (!this.options) return [basePath];
-		if (version === VERSION_NEUTRAL) return [basePath];
-		const prefix = this.options.prefix ?? "v";
-		if (version !== void 0) return (Array.isArray(version) ? version : [version]).map((v) => `/${prefix}${v}${basePath}`);
-		if (this.options.defaultVersion !== void 0) return (Array.isArray(this.options.defaultVersion) ? this.options.defaultVersion : [this.options.defaultVersion]).map((v) => `/${prefix}${v}${basePath}`);
-		return [basePath];
-	}
-};
-VersioningService = __decorate([Singleton(), __decorateParam(0, inject(DI_TOKENS.Application))], 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;
-	}
-	/**
-	* Register a route. Expands via VersioningService + LocalePathService.
-	* Named routes must have unique names.
-	*
-	* @returns Array of expanded RegisteredRoute entries (primary + locale variants)
-	* @throws RouterError if a named route with the same name already exists
-	*/
-	register(input) {
-		const domainParamNames = input.domainParamNames ?? (input.domain ? extractDomainParamNames(input.domain) : []);
-		const versionedPaths = this.versioningService.resolve(input.basePath, input.version);
-		const expandedRoutes = [];
-		const localeEnabled = this.localePathService.enabled;
-		for (const versionedPath of versionedPaths) {
-			const resolvedPaths = this.localePathService.resolve(versionedPath);
-			let localeVariantPaths;
-			if (localeEnabled) {
-				const variants = resolvedPaths.filter((p) => p.isLocaleVariant);
-				localeVariantPaths = variants.length > 0 ? variants.map((p) => p.path) : void 0;
-			}
-			for (const resolved of resolvedPaths) {
-				const route = {
-					name: resolved.isLocaleVariant ? void 0 : input.name,
-					method: input.method,
-					path: resolved.path,
-					localePaths: resolved.isLocaleVariant ? void 0 : localeVariantPaths,
-					paramNames: extractParamNames(resolved.path),
-					domain: input.domain,
-					domainParamNames,
-					controller: input.controller,
-					action: input.action,
-					hidden: input.hidden,
-					middleware: input.middleware,
-					isLocaleVariant: resolved.isLocaleVariant || void 0
-				};
-				if (route.name) {
-					if (this.namedRoutes.has(route.name)) {
-						const existing = this.namedRoutes.get(route.name);
-						throw new RouterError(`Duplicate route name "${route.name}": already registered by ${existing.controller}.${existing.action}, cannot register ${route.controller}.${route.action}`);
-					}
-					this.namedRoutes.set(route.name, route);
-				}
-				this.routes.push(route);
-				expandedRoutes.push(route);
-			}
-		}
-		this._sortedCache = null;
-		this._routeToNameCache = null;
-		return expandedRoutes;
-	}
-	/** Get a named route by name */
-	get(name) {
-		return this.namedRoutes.get(name);
-	}
-	/** Check if a named route exists */
-	has(name) {
-		return this.namedRoutes.has(name);
-	}
-	/**
-	* 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;
-	}
-	/** Get only named routes */
-	named() {
-		return [...this.namedRoutes.values()];
-	}
-};
-RouteRegistry = __decorate([
-	Singleton(),
-	__decorateParam(0, inject(ROUTER_TOKENS.VersioningService)),
-	__decorateParam(1, inject(ROUTER_TOKENS.LocalePathService))
-], RouteRegistry);
-//#endregion
-//#region src/router/route-url.ts
-/**
-* Generate a URL from a named route.
-*
-* Keys in `params` matching `:param` placeholders fill the path.
-* Domain params (`{tenant}`) are also consumed from `params`.
-* Extra keys become query string parameters.
-*
-* Resolves RouteRegistry from the application container via AsyncLocalStorage.
-* Available after `Application.initialize()` has been called.
-*
-* @param name - Named route identifier
-* @param params - Route params + domain params + extra query params
-* @returns Generated URL string
-*
-* @example
-* ```typescript
-* // In a controller (preferred):
-* ctx.route('users.show', { id: '1' })
-*
-* // Outside controllers (standalone function):
-* import { route } from 'stratal/router'
-*
-* route('users.show', { id: '1' })
-* ```
-*/
-function route(name, params, options) {
-	return getContainer().resolve(ROUTER_TOKENS.Uri).route(name, params, options);
-}
-//#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.
-*
-* @param route - The registered route to build a URL for
-* @param name - Route name (used in error messages)
-* @param params - Path params, domain params, and extra query params
-* @returns Relative URL string (or absolute with domain prefix if route has a domain pattern)
-*
-* @throws RouterError if a required path or domain param is missing
-*/
-function buildRouteUrl(route, name, params) {
-	const allParams = { ...params };
-	const consumedKeys = /* @__PURE__ */ new Set();
-	let url = route.path;
-	if (allParams.locale && route.localePaths?.length) {
-		url = `/${allParams.locale}${url === "/" ? "" : url}`;
-		consumedKeys.add("locale");
-	}
-	for (const paramName of route.paramNames) {
-		const value = allParams[paramName];
-		if (value === void 0) throw new RouterError(`Missing required route parameter "${paramName}" for route "${name}" (path: ${route.path})`);
-		url = url.replace(new RegExp(`:${paramName}(\\{[^}]*\\})?`), encodePathParam(value));
-		consumedKeys.add(paramName);
-	}
-	let domain;
-	if (route.domain) {
-		domain = route.domain;
-		for (const domainParam of route.domainParamNames) {
-			const value = allParams[domainParam];
-			if (value === void 0) throw new RouterError(`Missing required domain parameter "${domainParam}" for route "${name}" (domain: ${route.domain})`);
-			domain = domain.replace(`{${domainParam}}`, encodeURIComponent(value));
-			consumedKeys.add(domainParam);
-		}
-	}
-	const queryEntries = Object.entries(allParams).filter(([key]) => !consumedKeys.has(key));
-	if (queryEntries.length > 0) {
-		const queryString = queryEntries.filter(([, value]) => Boolean(value)).map(([key, value]) => `${encodeURIComponent(key)}=${encodeURIComponent(value)}`).join("&");
-		url = `${url}${queryString.length ? `?${queryString}` : ""}`;
-	}
-	if (domain) url = `https://${domain}${url}`;
-	return url;
-}
-let Uri = class Uri {
-	registry;
-	routerContext;
-	_defaults = {};
-	trailingSlash;
-	constructor(registry, routerContext, application) {
-		this.registry = registry;
-		this.routerContext = routerContext;
-		this.trailingSlash = application.config.trailingSlash ?? "ignore";
-	}
-	/**
-	* Set default URL parameters for this request.
-	* Applied to all subsequent `route()` calls — explicit params override defaults.
-	*
-	* @param params - Default parameters (e.g., `{ locale: 'en' }`)
-	*/
-	defaults(params) {
-		this._defaults = {
-			...this._defaults,
-			...params
-		};
-	}
-	/**
-	* 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.
-	* Domain params (`{tenant}`) are consumed from the same object.
-	* Extra keys become query string parameters.
-	* Default params (from `defaults()`) are merged — explicit params override.
-	*
-	* @param name - Named route identifier
-	* @param params - Route params + domain params + extra query params
-	* @param options - URL generation options
-	* @returns Generated URL string
-	*
-	* @throws RouterError if route name not found or required params missing
-	*/
-	route(name, params, options) {
-		const registeredRoute = this.registry.get(name);
-		if (!registeredRoute) throw new RouterError(`Route name "${name}" was not found in the registry`);
-		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;
-	}
-	/**
-	* Generate a signed URL from a named route.
-	*
-	* @param name - Named route identifier
-	* @param params - Route params + domain params + extra query params
-	* @param options - Signing options (e.g., expiresIn) and URL options
-	* @returns Signed URL string with signature query param
-	*
-	* @throws Error if APP_SECRET environment variable is not set
-	*/
-	async signedRoute(name, params, options) {
-		return signUrl(this.route(name, params, options), this.getAppSecret(), options);
-	}
-	/**
-	* Generate a temporary signed URL from a named route.
-	*
-	* @param name - Named route identifier
-	* @param expiresIn - Time-to-live in seconds
-	* @param params - Route params + domain params + extra query params
-	* @param options - URL generation options
-	* @returns Signed URL string with signature and expires query params
-	*
-	* @throws Error if APP_SECRET environment variable is not set
-	*/
-	async temporarySignedRoute(name, expiresIn, params, options) {
-		return this.signedRoute(name, params, {
-			...options,
-			expiresIn
-		});
-	}
-	/**
-	* Check if the current request has a valid signature.
-	*
-	* @returns true if the URL signature is valid and not expired
-	*/
-	async hasValidSignature() {
-		const secret = this.routerContext.c.env.APP_SECRET;
-		if (!secret) return false;
-		return verifySignedUrl(this.routerContext.c.req.url, secret);
-	}
-	/**
-	* Get the current request URL pathname (without query string).
-	*/
-	current() {
-		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 applyTrailingSlash(`${parsed.pathname}${parsed.search}`, this.trailingSlash);
-	}
-	/**
-	* Get the previous request URL from the Referer header.
-	*
-	* @param fallback - URL to return if no Referer header (default: '/')
-	*/
-	previous(fallback = "/") {
-		return this.routerContext.c.req.header("referer") ?? fallback;
-	}
-	/**
-	* Get the previous request URL pathname (no query string or host) from the Referer header.
-	*
-	* @param fallback - Path to return if no Referer header (default: '/')
-	*/
-	previousPath(fallback = "/") {
-		const referer = this.routerContext.c.req.header("referer");
-		if (!referer) return fallback;
-		try {
-			return new URL(referer).pathname;
-		} catch {
-			return referer;
-		}
-	}
-	/**
-	* Build a URL to a raw path (not a named route) with optional query params.
-	*
-	* @param path - URL path (e.g., '/users')
-	* @param queryParams - Query parameters to append
-	* @param options - URL generation options
-	*/
-	to(path, queryParams, options) {
-		let url = applyTrailingSlash(path, this.trailingSlash);
-		if (queryParams) {
-			const entries = Object.entries(queryParams);
-			if (entries.length > 0) {
-				const queryString = entries.map(([key, value]) => `${encodeURIComponent(key)}=${encodeURIComponent(value)}`).join("&");
-				url = url.includes("?") ? `${url}&${queryString}` : `${url}?${queryString}`;
-			}
-		}
-		if (options?.absolute && !url.startsWith("http")) url = `${new URL(this.routerContext.c.req.url).origin}${url}`;
-		return url;
-	}
-	/**
-	* Build a URL with query string parameters. Merges with existing query params in path.
-	*
-	* @param path - URL path, may already contain query params
-	* @param queryParams - Query parameters to merge (new values override existing)
-	*/
-	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 applyTrailingSlash(`${parsed.pathname}${parsed.search}`, this.trailingSlash);
-	}
-	getAppSecret() {
-		const secret = this.routerContext.c.env.APP_SECRET;
-		if (!secret) throw new Error("APP_SECRET environment variable is required for signed URLs");
-		return secret;
-	}
-};
-Uri = __decorate([
-	Request(),
-	__decorateParam(0, inject(ROUTER_TOKENS.RouteRegistry)),
-	__decorateParam(1, inject(ROUTER_TOKENS.RouterContext)),
-	__decorateParam(2, inject(DI_TOKENS.Application))
-], Uri);
-//#endregion
-//#region src/router/middleware/verify-signature.middleware.ts
-/**
-* Middleware that verifies signed URLs.
-*
-* Checks the `signature` (and optionally `expires`) query params against the
-* request URL using HMAC-SHA256 via `crypto.subtle.verify()`.
-*
-* Requires `APP_SECRET` in the Cloudflare Workers environment bindings.
-*
-* @throws InvalidSignatureError (403) if signature is missing, invalid, or expired
-*
-* @example
-* ```typescript
-* @Module({ controllers: [UnsubscribeController], providers: [VerifySignatureMiddleware] })
-* export class EmailModule implements RouteConfigurable {
-*   configureRoutes(router: Router): void {
-*     router.middleware(VerifySignatureMiddleware)
-*   }
-* }
-* ```
-*/
-var VerifySignatureMiddleware = class {
-	async handle(ctx, next) {
-		const url = ctx.c.req.url;
-		const secret = ctx.c.env.APP_SECRET;
-		if (!secret) throw new RouterError("Missing required environment variable \"APP_SECRET\"");
-		if (!await verifySignedUrl(url, secret)) throw new InvalidSignatureError();
-		await next();
-	}
-};
-//#endregion
-export { parseDomainPattern as A, uuidParamSchema as C, getRouteMetadata as D, getRouteDecoratedMethods as E, ResponseValidationError as M, SchemaValidationError as N, createMiddlewareChain as O, RouteNotFoundError as P, successMessageSchema as S, Route as T, toOpenAPIPath as _, RouteRegistry as a, paginatedResponseSchema as b, buildDetectorOptions as c, RouteRegistrationService as d, extractDomainParamNames as f, sortRoutesBySpecificity as g, getPathSpecificityScore as h, route as i, InvalidSignatureError as j, createDomainMiddleware as k, resolveI18nOptions as l, generateConventionRouteName as m, Uri as n, VersioningService as o, extractParamNames as p, buildRouteUrl as r, LocalePathService as s, VerifySignatureMiddleware as t, HonoApp as u, commonErrorSchemas as v, validationErrorResponseSchema as w, paginationQuerySchema as x, errorResponseSchema as y };
-
-//# sourceMappingURL=router-Cy6DjkvP.mjs.map