stratal 0.0.17 → 0.0.19

package/dist/index-DPFqRs8L.d.mts

@@ -0,0 +1,4318 @@
+import { t as Constructor } from "./types-DIWemRad.mjs";
+import { t as Macroable } from "./index-SHx31sBJ.mjs";
+import { t as StratalEnv } from "./env-CamWD-U1.mjs";
+import { t as index_d_exports } from "./index-DFhEeFfC.mjs";
+import { a as index_d_exports$1, b as MessageKeys, i as ZodError, o as z, t as OpenAPIHono, v as II18nService, x as MessageParams, y as MessageKeyPrefix } from "./index-B437eK7p.mjs";
+import { i as LoggerService, l as LogLevel } from "./index-CWRS7Ri3.mjs";
+import { DependencyContainer, DependencyContainer as DependencyContainer$1, container as container$1, delay, inject as inject$1, injectable as injectable$1, instancePerContainerCachingFactory as instancePerContainerCachingFactory$1, singleton } from "tsyringe";
+import { AsyncLocalStorage } from "node:async_hooks";
+import { SSEMessage, SSEStreamingApi, SSEStreamingApi as SSEStreamingApi$1 } from "hono/streaming";
+import { CoreContext } from "@intlify/core-base";
+import { DetectorOptions } from "hono/language";
+import { Context, MiddlewareHandler, Next } from "hono";
+import { ContentfulStatusCode, RedirectStatusCode } from "hono/utils/http-status";
+import { StreamingApi, StreamingApi as StreamingApi$1 } from "hono/utils/stream";
+import InjectionToken$1, { default as InjectionToken$2 } from "tsyringe/dist/typings/providers/injection-token";
+
+//#region src/errors/error-response.d.ts
+type Environment = 'development' | 'staging' | 'production';
+interface ErrorResponse {
+  /**
+   * Numeric error code for identification and escalation
+   * See error-codes.ts for the complete registry
+   */
+  code: number;
+  /**
+   * Human-readable error message
+   * Fixed per error type, not customizable
+   */
+  message: string;
+  /**
+   * ISO timestamp when the error occurred
+   */
+  timestamp: string;
+  /**
+   * Additional structured data about the error
+   * Only included in development environment
+   */
+  metadata?: Record<string, unknown>;
+  /**
+   * Stack trace for debugging
+   * Only included in development environment
+   */
+  stack?: string;
+}
+/**
+ * Type guard to check if an object is an ErrorResponse
+ */
+declare function isErrorResponse(obj: unknown): obj is ErrorResponse;
+//#endregion
+//#region src/di/types.d.ts
+/**
+ * Service scope for DI registration
+ *
+ * Maps directly to tsyringe's Lifecycle enum.
+ * Scope is specified at registration time via provider configuration,
+ * not at class decoration time.
+ *
+ * @example
+ * ```typescript
+ * // In module providers:
+ * { provide: MY_TOKEN, useClass: MyService, scope: Scope.Singleton }
+ *
+ * // In Application.ts:
+ * container.register(MY_TOKEN, MyService, Scope.Request)
+ * ```
+ */
+declare enum Scope {
+  /** New instance per resolution (default) */
+  Transient = 0,
+  /** Single instance shared globally */
+  Singleton = 1,
+  /** New instance per child container (per request) */
+  Request = 3
+}
+/**
+ * Options for conditional binding with `when()` method
+ */
+interface WhenOptions {
+  /**
+   * Cache predicate result after first evaluation.
+   * When true, the predicate is evaluated once and the result is reused.
+   * When false (default), predicate is evaluated on each resolution.
+   */
+  cache?: boolean;
+}
+/**
+ * Decorator function type for extend() method
+ *
+ * @template T The service type being decorated
+ */
+type ExtensionDecorator<T> = (service: T, container: ContainerLike) => T;
+/**
+ * Minimal container interface for decorator functions
+ * Avoids circular dependency with Container class
+ */
+interface ContainerLike {
+  resolve<T>(token: InjectionToken$1<T>): T;
+}
+//#endregion
+//#region src/di/conditional-binding-builder.d.ts
+/**
+ * Container interface for predicate functions
+ * Using a minimal interface to avoid circular imports
+ */
+interface PredicateContainer {
+  resolve<T>(token: InjectionToken$1<T>): T;
+  isRegistered<T>(token: InjectionToken$1<T>): boolean;
+}
+/**
+ * Initial builder returned by container.when()
+ */
+interface ConditionalBindingBuilder {
+  /**
+   * Specify the token to conditionally bind
+   *
+   * @param token - DI token for the service
+   * @returns Builder for specifying implementations
+   */
+  use<T extends object>(token: InjectionToken$1<T>): ConditionalBindingUse<T>;
+}
+/**
+ * Builder after specifying token with use()
+ */
+interface ConditionalBindingUse<T extends object> {
+  /**
+   * Specify the implementation when predicate returns true.
+   * Registration is completed immediately.
+   *
+   * If predicate is false at resolution time:
+   * - Uses `otherwise()` implementation if provided
+   * - Falls back to existing registration if available
+   * - Throws error if no fallback exists
+   *
+   * @param implementation - Service class to use when predicate is true
+   * @returns Builder for optional fallback specification
+   */
+  give(implementation: Constructor<T>): ConditionalBindingGive<T>;
+}
+/**
+ * Builder after specifying true implementation with give()
+ * Registration is already complete at this point.
+ */
+interface ConditionalBindingGive<T extends object> {
+  /**
+   * Optionally specify a fallback implementation when predicate returns false.
+   * This re-registers with the explicit fallback instead of existing registration.
+   *
+   * @param implementation - Service class to use when predicate is false
+   */
+  otherwise(implementation: Constructor<T>): void;
+}
+/**
+ * Implementation of ConditionalBindingBuilder
+ *
+ * @internal
+ */
+declare class ConditionalBindingBuilderImpl implements ConditionalBindingBuilder {
+  private readonly tsyringeContainer;
+  private readonly predicateContainer;
+  private readonly predicate;
+  private readonly options;
+  constructor(tsyringeContainer: DependencyContainer, predicateContainer: PredicateContainer, predicate: (container: PredicateContainer) => boolean, options: WhenOptions);
+  use<T extends object>(token: InjectionToken$1<T>): ConditionalBindingUse<T>;
+}
+//#endregion
+//#region src/di/container.d.ts
+/**
+ * Options for creating a Container instance
+ */
+interface ContainerOptions {
+  /** Pre-created DependencyContainer */
+  container: DependencyContainer;
+  /** Whether this is a request-scoped container */
+  isRequestScoped?: boolean;
+}
+/**
+ * Unified Container for DI management
+ *
+ * Manages the two-tier container hierarchy:
+ * - Global scope: Singletons, base instances of request-scoped services
+ * - Request scope: Context-enriched instances per HTTP request
+ *
+ * @example Basic registration
+ * ```typescript
+ * import { container as tsyringeRootContainer } from 'tsyringe'
+ *
+ * const container = new Container({
+ *   container: tsyringeRootContainer.createChildContainer()
+ * })
+ *
+ * container.register(I18nService)
+ * container.register(MY_TOKEN, MyService)
+ * container.registerSingleton(ConfigService)
+ * container.registerValue(MY_TOKEN, myInstance)
+ * ```
+ *
+ * @example Request scope (automatic lifecycle)
+ * ```typescript
+ * await container.runInRequestScope(routerContext, async (requestContainer) => {
+ *   const i18n = requestContainer.resolve(I18N_TOKEN)
+ * })
+ * ```
+ */
+declare class Container {
+  private readonly container;
+  private readonly isRequestScoped;
+  constructor(options: ContainerOptions);
+  /**
+   * Register a service with optional explicit token and scope
+   */
+  register<T extends object>(serviceClass: Constructor<T>, scope?: Scope): void;
+  register<T extends object>(token: InjectionToken$1<T>, serviceClass: Constructor<T>, scope?: Scope): void;
+  /**
+   * Register a service as singleton
+   */
+  registerSingleton<T extends object>(serviceClass: Constructor<T>): void;
+  registerSingleton<T extends object>(token: InjectionToken$1<T>, serviceClass: Constructor<T>): void;
+  /**
+   * Register a value (instance) directly
+   */
+  registerValue<T>(token: InjectionToken$1<T>, value: T): void;
+  /**
+   * Register with factory function
+   */
+  registerFactory<T>(token: InjectionToken$1<T>, factory: (container: Container) => T): void;
+  /**
+   * Register an alias to an existing token
+   */
+  registerExisting<T>(alias: InjectionToken$1<T>, target: InjectionToken$1<T>): void;
+  /**
+   * Resolve a service from the container
+   */
+  resolve<T>(token: InjectionToken$1<T>): T;
+  /**
+   * Check if a token is registered
+   */
+  isRegistered<T>(token: InjectionToken$1<T>): boolean;
+  /**
+   * Start a conditional binding with predicate evaluation
+   */
+  when(predicate: (container: PredicateContainer) => boolean, options?: WhenOptions): ConditionalBindingBuilder;
+  /**
+   * Replace a service registration with a decorated version
+   */
+  extend<T>(token: InjectionToken$1<T>, decorator: ExtensionDecorator<T>): void;
+  /**
+   * Run callback within request scope
+   *
+   * Creates a child container with fresh instances for services registered with `scope: Scope.Request`.
+   * Callback receives the request-scoped container as argument.
+   *
+   * Can only be called on global container (not request-scoped).
+   */
+  runInRequestScope<T>(routerContext: RouterContext, callback: (requestContainer: Container) => T | Promise<T>): Promise<T>;
+  /**
+   * Create request scope container
+   *
+   * Can only be called on global container (not request-scoped).
+   */
+  createRequestScope(routerContext: RouterContext): Container;
+  /**
+   * Get underlying tsyringe container
+   */
+  getTsyringeContainer(): DependencyContainer;
+  dispose(): void | Promise<void>;
+}
+//#endregion
+//#region src/router/route-map.d.ts
+/**
+ * Augmentable route map for type-safe URL generation.
+ *
+ * Users augment this interface via `declare module 'stratal/router'` to get
+ * autocomplete on `route()` calls and type-checked params.
+ * Generated automatically by `quarry route:types`.
+ *
+ * Follows the same augmentation pattern as `CustomEventRegistry` in `stratal/events`.
+ *
+ * @example
+ * ```typescript
+ * declare module 'stratal/router' {
+ *   interface StratalRouteMap {
+ *     'users.index': { params: never }
+ *     'users.show': { params: { id: string } }
+ *     'tenant.dashboard': { params: { tenant: string } }
+ *   }
+ * }
+ * ```
+ */
+interface StratalRouteMap {}
+/**
+ * All valid route names.
+ * Falls back to `string` when no routes are registered in StratalRouteMap.
+ */
+type RouteName = keyof StratalRouteMap extends never ? string : Extract<keyof StratalRouteMap, string>;
+/**
+ * Resolves the required params for a named route.
+ * When StratalRouteMap is augmented, provides type-safe param objects.
+ * Falls back to `Record<string, string> | undefined` for untyped routes.
+ */
+type RouteParams<N extends RouteName> = N extends keyof StratalRouteMap ? StratalRouteMap[N] extends {
+  params: infer P;
+} ? [P] extends [never] ? Record<string, string> | undefined : P : Record<string, string> | undefined : Record<string, string> | undefined;
+/**
+ * Minimal route data for client-side URL generation.
+ * Contains only the fields needed by URL building logic — no server metadata.
+ */
+interface SerializedRoute {
+  path: string;
+  paramNames: string[];
+  domain?: string;
+  domainParamNames: string[];
+  localePaths?: string[];
+}
+/**
+ * A record of named routes keyed by route name, used for client-side URL building.
+ * Serialized from `RouteRegistry.named()` on the server, consumed by `useRoute()` on the client.
+ */
+type SerializedRoutes = Record<string, SerializedRoute>;
+//#endregion
+//#region src/di/tokens.d.ts
+/**
+ * Token for the Container instance
+ * Used for injecting the Container into services that need dynamic resolution
+ */
+declare const CONTAINER_TOKEN: unique symbol;
+declare const DI_TOKENS: {
+  readonly CloudflareEnv: symbol;
+  readonly ExecutionContext: symbol;
+  readonly Container: typeof CONTAINER_TOKEN;
+  readonly Application: symbol;
+  readonly ModuleRegistry: symbol;
+  readonly ExceptionHandler: symbol;
+  readonly Database: symbol;
+  readonly Queue: symbol;
+  readonly ConsumerRegistry: symbol;
+  readonly Cron: symbol;
+  readonly EventRegistry: symbol;
+  readonly Quarry: symbol;
+  /**
+   * AuthContext: Use for services that need user authentication (userId).
+   */
+  readonly AuthContext: symbol;
+  readonly DurableObjectState: symbol;
+  readonly DurableObjectId: symbol;
+};
+type DIToken = typeof DI_TOKENS[keyof typeof DI_TOKENS];
+//#endregion
+//#region src/di/decorators/inject-param.decorator.d.ts
+/**
+ * Metadata key for storing parameter injection information
+ */
+declare const INJECT_PARAM_METADATA_KEY: unique symbol;
+/**
+ * Describes a parameter injection
+ */
+interface ParamInjection {
+  /** Parameter index in the method signature (0-based) */
+  index: number;
+  /** DI token to resolve */
+  token: InjectionToken$1;
+}
+/**
+ * Mark a method parameter for DI injection
+ *
+ * The parameter will be resolved from the request-scoped container
+ * when the controller method is invoked.
+ *
+ * @param token - DI token to resolve (class or symbol)
+ *
+ * @example With class token
+ * ```typescript
+ * async show(
+ *   ctx: RouterContext,
+ *   @InjectParam(UserService) userService: UserService
+ * ) { }
+ * ```
+ *
+ * @example With symbol token
+ * ```typescript
+ * async show(
+ *   ctx: RouterContext,
+ *   @InjectParam(DI_TOKENS.Cache) cache: ICacheService
+ * ) { }
+ * ```
+ */
+declare function InjectParam<T>(token: InjectionToken$1<T>): ParameterDecorator;
+/**
+ * Get method parameter injections
+ *
+ * @param target - Controller prototype
+ * @param propertyKey - Method name
+ * @returns Array of parameter injections sorted by index
+ */
+declare function getMethodInjections(target: object, propertyKey: string | symbol): ParamInjection[];
+//#endregion
+//#region src/di/decorators.d.ts
+/**
+ * Mark a class as injectable
+ *
+ * This decorator wraps tsyringe's `@injectable` decorator and optionally
+ * associates a token with the class. The actual lifecycle (Singleton, Request,
+ * Transient) is determined at registration time, not decoration time.
+ *
+ * **Lifecycle Control:**
+ * - Use `scope: Scope.Singleton` in module providers for singleton
+ * - Use `scope: Scope.Request` in module providers for request-scoped
+ * - Default is Transient (new instance per resolution)
+ *
+ * @param token - Optional DI token for service resolution
+ *
+ * @example Basic usage (no token)
+ * ```typescript
+ * @Transient()
+ * export class UserService {
+ *   constructor(@inject(DI_TOKENS.Database) private db: DatabaseService) {}
+ * }
+ *
+ * // In module:
+ * @Module({
+ *   providers: [UserService]  // Transient by default
+ * })
+ * ```
+ *
+ * @example With token
+ * ```typescript
+ * @Transient(DI_TOKENS.ConnectionManager)
+ * export class ConnectionManager implements Disposable {
+ *   // ...
+ * }
+ *
+ * // In Application.ts:
+ * container.register(DI_TOKENS.ConnectionManager, ConnectionManager, Scope.Request)
+ * ```
+ *
+ * @example Singleton via provider scope
+ * ```typescript
+ * @Transient()
+ * export class ConsumerRegistry {
+ *   // ...
+ * }
+ *
+ * // In module:
+ * @Module({
+ *   providers: [
+ *     { provide: DI_TOKENS.ConsumerRegistry, useClass: ConsumerRegistry, scope: Scope.Singleton }
+ *   ]
+ * })
+ * ```
+ */
+declare function Transient<T>(token?: InjectionToken$1<T>): <TFunction extends abstract new (...args: never[]) => unknown>(target: TFunction) => TFunction;
+//#endregion
+//#region src/di/errors/conditional-binding-fallback.error.d.ts
+/**
+ * ConditionalBindingFallbackError
+ *
+ * Thrown when a conditional binding predicate returns false but no fallback
+ * implementation was provided and no existing registration exists for the token.
+ *
+ * This typically indicates a misconfiguration in the DI setup where:
+ * - A `when().use().give()` chain was used without `otherwise()`
+ * - AND the token wasn't previously registered
+ * - AND the predicate evaluated to false at resolution time
+ */
+declare class ConditionalBindingFallbackError extends ApplicationError {
+  constructor(token: string);
+}
+//#endregion
+//#region src/di/errors/request-scope-operation-not-allowed.error.d.ts
+/**
+ * RequestScopeOperationNotAllowedError
+ *
+ * Thrown when attempting to call a method that is not allowed on the current container scope.
+ * - `createRequestScope()` and `runInRequestScope()` can only be called on global containers
+ */
+declare class RequestScopeOperationNotAllowedError extends ApplicationError {
+  constructor(methodName: string);
+}
+//#endregion
+//#region src/di/container-storage.d.ts
+/**
+ * AsyncLocalStorage for the application container.
+ *
+ * Set by `Application.initialize()` — all code from that point onward
+ * (Stratal handlers, TestingModuleBuilder, standalone functions like `route()`)
+ * can access the container without DI or static singletons.
+ *
+ * Follows the same pattern as `errorMapContextStorage` in `i18n/validation/validation.context.ts`.
+ */
+declare const containerStorage: AsyncLocalStorage<Container>;
+/**
+ * Get the application container from AsyncLocalStorage.
+ *
+ * @throws ContainerNotInitializedError if called outside `Application.initialize()` scope
+ */
+declare function getContainer(): Container;
+/**
+ * Run a function within a container context.
+ *
+ * @param container - The application container to store
+ * @param fn - The function to execute with container access
+ */
+declare function runWithContainer<T>(container: Container, fn: () => T): T;
+//#endregion
+//#region src/router/constants.d.ts
+/**
+ * Type-safe context keys for Hono router variables
+ * Using symbols to avoid string collisions
+ */
+declare const ROUTER_CONTEXT_KEYS: {
+  readonly REQUEST_CONTAINER: "requestContainer";
+  readonly LOCALE: "locale";
+};
+/**
+ * Metadata keys for storing route and controller configuration
+ * Using symbols to avoid collisions with other decorators
+ */
+declare const ROUTE_METADATA_KEYS: {
+  readonly CONTROLLER_ROUTE: symbol;
+  readonly CONTROLLER_OPTIONS: symbol;
+  readonly CONTROLLER_MIDDLEWARES: symbol;
+  readonly ROUTE_CONFIG: symbol;
+  readonly DECORATED_METHODS: symbol;
+  readonly AUTH_GUARD: symbol;
+  readonly GATEWAY_MARKER: symbol;
+  readonly WS_ON_MESSAGE: symbol;
+  readonly WS_ON_CLOSE: symbol;
+  readonly WS_ON_ERROR: symbol;
+};
+/**
+ * Security scheme identifiers for OpenAPI
+ * These reference the security scheme definitions in security.schemas.ts
+ */
+declare const SECURITY_SCHEMES: {
+  readonly BEARER_AUTH: "bearerAuth";
+  readonly API_KEY: "apiKey";
+  readonly SESSION_COOKIE: "sessionCookie";
+};
+/**
+ * HTTP method mapping for RESTful controller methods
+ * Maps controller method names to HTTP verbs and path patterns
+ */
+declare const HTTP_METHODS: {
+  readonly index: {
+    readonly method: "get";
+    readonly path: "";
+  };
+  readonly show: {
+    readonly method: "get";
+    readonly path: "/:id";
+  };
+  readonly create: {
+    readonly method: "post";
+    readonly path: "";
+  };
+  readonly update: {
+    readonly method: "put";
+    readonly path: "/:id";
+  };
+  readonly patch: {
+    readonly method: "patch";
+    readonly path: "/:id";
+  };
+  readonly destroy: {
+    readonly method: "delete";
+    readonly path: "/:id";
+  };
+};
+/**
+ * Sentinel symbol to opt a controller out of versioning.
+ * When used as the version, no prefix is applied even when defaultVersion is set.
+ */
+declare const VERSION_NEUTRAL: unique symbol;
+//#endregion
+//#region src/router/types.d.ts
+/**
+ * Route parameter type for OpenAPI
+ * ZodObject or ZodPipe (piped validation)
+ */
+type ZodObjectWithEffect = index_d_exports$1.ZodObject<any> | index_d_exports$1.ZodPipe<any, any>;
+type RouteParameter = ZodObjectWithEffect | undefined;
+/**
+ * Hono context variables with type-safe keys
+ */
+interface RouterVariables {
+  [ROUTER_CONTEXT_KEYS.REQUEST_CONTAINER]: Container;
+  [ROUTER_CONTEXT_KEYS.LOCALE]?: string;
+  /**
+   * When set by middleware, the defaultHook returns this response after
+   * successful validation — skipping the controller handler entirely.
+   * Used by packages like `@stratal/inertia` for precognition support.
+   */
+  validationSuccessResponse?: Response;
+  /** Domain parameters set by the domain matching middleware (e.g., `domain:tenant`) */
+  [key: `domain:${string}`]: string;
+}
+/**
+ * Hono environment type for router
+ */
+interface RouterEnv {
+  Bindings: StratalEnv;
+  Variables: RouterVariables;
+}
+/**
+ * Security scheme identifier type
+ * Matches the keys in SECURITY_SCHEMES constant
+ */
+type SecurityScheme = typeof SECURITY_SCHEMES[keyof typeof SECURITY_SCHEMES];
+/**
+ * HTTP method type from OpenAPI spec
+ */
+type HttpMethod = 'get' | 'post' | 'put' | 'delete' | 'patch' | 'head' | 'options' | 'trace' | 'all';
+/**
+ * Object form for request body with optional content type
+ */
+interface RouteBodyObject {
+  schema: index_d_exports$1.ZodType;
+  contentType?: string;
+}
+/**
+ * Request body definition for @Route() decorator
+ * Bare ZodType defaults to application/json
+ */
+type RouteBody = index_d_exports$1.ZodType | RouteBodyObject;
+/**
+ * Object form for response with optional description and content type
+ */
+interface RouteResponseObject {
+  schema: index_d_exports$1.ZodType;
+  description?: string;
+  contentType?: string;
+}
+/**
+ * Single response definition for @Route() decorator
+ * Status code is auto-derived from method name (create->201, others->200)
+ */
+type RouteResponse = index_d_exports$1.ZodType | RouteResponseObject;
+/**
+ * Route configuration for @Route() decorator
+ * Defines OpenAPI metadata for a controller method
+ */
+interface RouteConfig {
+  /**
+   * Request body schema (for POST, PUT, PATCH)
+   * @example z.object({}) or { schema: z.object({}), contentType: 'multipart/form-data' }
+   */
+  body?: RouteBody;
+  /**
+   * URL parameters schema (e.g., { id: z.string().uuid() })
+   * Must be ZodObject or ZodPipe for OpenAPI compatibility
+   */
+  params?: RouteParameter;
+  /**
+   * Query parameters schema (e.g., pagination, filters)
+   * Must be ZodObject or ZodPipe for OpenAPI compatibility
+   */
+  query?: RouteParameter;
+  /**
+   * Response schema for success case
+   * Status code auto-derived: create()->201, others->200
+   * @example userSchema or { schema: userSchema, description: 'User details' }
+   */
+  response?: RouteResponse;
+  /**
+   * OpenAPI tags for grouping endpoints
+   * Merged with controller-level tags
+   */
+  tags?: string[];
+  /**
+   * Security schemes required for this route
+   * Merged with controller-level security
+   * Empty array = public route (no auth)
+   */
+  security?: SecurityScheme[];
+  /**
+   * Human-readable description for OpenAPI docs
+   */
+  description?: string;
+  /**
+   * Detailed summary for OpenAPI docs
+   */
+  summary?: string;
+  /**
+   * Hide this route from OpenAPI documentation
+   * Route remains functional but won't appear in /api/docs or /api/openapi.json
+   * Useful for internal-only endpoints, debug routes, or work-in-progress features
+   */
+  hideFromDocs?: boolean;
+  /**
+   * HTTP success status code for the response
+   * Used by HTTP method decorators (@Get, @Post, etc.) to set the success status
+   * For @Route() decorator, status code is auto-derived from method name
+   */
+  statusCode?: number;
+  /**
+   * Explicit route name for URL generation.
+   * Used with the `route()` helper and type generation.
+   * For convention-based @Route(), names are auto-generated if not provided.
+   * For explicit @Get/@Post/etc., names must be provided manually.
+   *
+   * @example 'users.show', 'health.check'
+   */
+  name?: string;
+}
+/**
+ * Metadata for convention-based routes (@Route decorator)
+ * HTTP method and path are auto-derived from the method name
+ */
+interface ConventionRouteMetadata {
+  type: 'convention';
+  config: RouteConfig;
+}
+/**
+ * Metadata for explicit routes (@Get, @Post, @Put, @Patch, @Delete, @All decorators)
+ * HTTP method and path are explicitly specified
+ */
+interface ExplicitRouteMetadata {
+  type: 'explicit';
+  method: HttpMethod;
+  path: string;
+  config: RouteConfig;
+}
+/**
+ * Discriminated union for all route metadata
+ * Stored under a single metadata key for unified registration
+ */
+type RouteMetadata = ConventionRouteMetadata | ExplicitRouteMetadata;
+/**
+ * Controller options for @Controller() decorator
+ * Provides default configuration for all routes in the controller
+ */
+interface ControllerOptions {
+  /**
+   * Default tags applied to all routes in this controller
+   * Routes can append additional tags
+   */
+  tags?: string[];
+  /**
+   * Default security schemes applied to all routes
+   * Routes can add more schemes or override with empty array
+   */
+  security?: SecurityScheme[];
+  /**
+   * Hide all routes in this controller from OpenAPI documentation
+   * Routes remain functional but won't appear in /api/docs or /api/openapi.json
+   * Can be overridden at route level with hideFromDocs: false
+   * Useful for internal-only controllers, debug endpoints, or utilities
+   */
+  hideFromDocs?: boolean;
+  /**
+   * API version(s) for this controller.
+   * When versioning is enabled, routes are prefixed with the version (e.g., /v1/users).
+   * Use VERSION_NEUTRAL to opt out of versioning (no prefix applied).
+   * Can be a single version string, array of versions, or VERSION_NEUTRAL symbol.
+   */
+  version?: string | string[] | typeof VERSION_NEUTRAL;
+  /**
+   * Route name prefix for this controller.
+   * Prepended to all route names in this controller.
+   * Overrides the Router-level name prefix entirely.
+   *
+   * @example 'admin.' — routes become 'admin.users.index', 'admin.users.show'
+   */
+  name?: string;
+  /**
+   * Domain pattern for this controller.
+   * Overrides the Router-level domain.
+   * Use `{param}` for dynamic subdomain segments.
+   *
+   * @example '{tenant}.myapp.com', 'admin.myapp.com'
+   */
+  domain?: string;
+}
+/**
+ * Versioning configuration for the application.
+ * Enables URI-based API versioning when provided to Stratal config.
+ */
+interface VersioningOptions {
+  /**
+   * Prefix for version segments in the URL.
+   * @default 'v'
+   * @example 'v' produces /v1, /v2; 'api/v' produces /api/v1, /api/v2
+   */
+  prefix?: string;
+  /**
+   * Default version applied to controllers without explicit version.
+   * Controllers with VERSION_NEUTRAL are not affected.
+   */
+  defaultVersion?: string | string[];
+}
+/**
+ * Locale path configuration for route registration.
+ * Controls how locale prefixes are applied to route paths.
+ *
+ * Built from {@link I18nModuleOptions} when path-based locale detection is enabled.
+ */
+interface LocalePathConfig {
+  /** All supported locale codes (e.g., `['en', 'fr']`) */
+  allLocales: string[];
+  /**
+   * Locales that require a `/{locale}` path prefix.
+   * Excludes `defaultLocale` when `prefixDefaultLocale` is not `true`.
+   */
+  prefixedLocales: string[];
+  /**
+   * The default locale used as the unprefixed root, derived from
+   * {@link I18nModuleOptions.defaultLocale}.
+   * `null` when all locales are prefixed (`prefixDefaultLocale: true`).
+   */
+  defaultLocale: string | null;
+}
+//#endregion
+//#region src/router/hono-app.d.ts
+/**
+ * HonoApp — extends OpenAPIHono with Stratal-specific setup
+ *
+ * - Request scope middleware (child container per request)
+ * - Global middleware (CORS, logging, error handling)
+ * - defaultHook for validation errors
+ * - `use()` overload for Stratal middleware classes
+ * - `configure()` for OpenAPI, routes, and 404
+ */
+declare class HonoApp extends OpenAPIHono<RouterEnv> {
+  private configured;
+  private readonly _container;
+  private readonly _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.
+   */
+  private nativeUse;
+  constructor(container: Container, logger: LoggerService);
+  /**
+   * Apply global middleware (logger + error handler).
+   * Called by Application after locale middleware is applied by LocalePathService.
+   */
+  private applyGlobalMiddleware;
+  /**
+   * Configure OpenAPI endpoints, controller routes, and 404 handler.
+   * Called once by Application.initialize().
+   */
+  configure(): Promise<void>;
+  private setupRequestScope;
+  private handleException;
+}
+//#endregion
+//#region src/router/services/locale-path.service.d.ts
+/**
+ * A resolved path with locale variant metadata.
+ */
+interface ResolvedPath {
+  /** The fully resolved path (may include /:locale prefix) */
+  path: string;
+  /** Whether this path is a locale-prefixed variant */
+  isLocaleVariant: boolean;
+}
+/**
+ * Resolves locale path variants for route paths.
+ *
+ * Computes `LocalePathConfig` from `I18nModuleOptions` and provides
+ * path expansion for locale-prefixed route variants.
+ *
+ * Also applies language detection and default locale redirect middleware
+ * to HonoApp when resolved from the container.
+ *
+ * Registered as a singleton in the container.
+ */
+declare class LocalePathService {
+  private readonly honoApp;
+  private readonly _config;
+  private readonly _pathDetectionEnabled;
+  private readonly _prefixDefaultLocale;
+  constructor(container: Container, honoApp: HonoApp);
+  /** Whether path-based locale detection is enabled */
+  get enabled(): boolean;
+  /** The computed locale path config, or null if path detection is disabled */
+  get localePathConfig(): LocalePathConfig | null;
+  /** The prefixDefaultLocale setting (false, true, or 'redirect') */
+  get prefixDefaultLocale(): false | true | 'redirect';
+  /**
+   * 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: string): ResolvedPath[];
+  /**
+   * Build a Hono regex constraint from prefixed locales.
+   * e.g., `{en|de|fr}` — restricts `:locale` to only match known values.
+   */
+  private buildLocaleConstraint;
+  /**
+   * Apply Hono's languageDetector middleware and bridge the detected language
+   * to Stratal's LOCALE context variable.
+   */
+  private setupLanguageDetection;
+  /**
+   * 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'`.
+   */
+  private setupDefaultLocaleRedirect;
+}
+//#endregion
+//#region src/execution-context.d.ts
+interface StratalExecutionContext {
+  waitUntil(promise: Promise<unknown>): void;
+}
+//#endregion
+//#region src/errors/exception-handler.types.d.ts
+/**
+ * Log severity levels for exception reporting.
+ */
+type LogSeverity = 'error' | 'warn' | 'info' | 'debug';
+/**
+ * Callback invoked when a specific exception type is reported.
+ *
+ * @typeParam T - The exception type this callback handles
+ * @param error - The matched exception instance
+ * @param context - The execution context where the error occurred
+ */
+type ReportableCallback<T extends ApplicationError> = (error: T, context: ExceptionContext) => void | Promise<void>;
+/**
+ * Callback invoked to render a specific exception type into a Response.
+ *
+ * Return `undefined` to fall through to the default renderer.
+ *
+ * @typeParam T - The exception type this callback handles
+ * @param error - The matched exception instance
+ * @param context - The execution context where the error occurred
+ * @returns A Response, ErrorResponse, or undefined to fall through
+ */
+type RenderableCallback<T extends ApplicationError> = (error: T, context: ExceptionContext) => Response | ErrorResponse | Promise<Response> | undefined;
+/**
+ * Callback invoked to post-process every error Response before it is returned.
+ *
+ * Use this to add headers, change the response body, swap content type, etc.
+ *
+ * @param response - The rendered Response
+ * @param error - The original exception
+ * @param context - The execution context where the error occurred
+ * @returns The (possibly modified) Response
+ */
+type RespondCallback = (response: Response, error: ApplicationError, context: ExceptionContext) => Response;
+/**
+ * Callback that returns additional context data to include in all exception logs.
+ *
+ * @returns Key-value pairs merged into every log entry
+ */
+type ContextCallback = () => Record<string, unknown>;
+/**
+ * Handle returned by `reportable()` to control whether default reporting runs.
+ */
+interface Reportable {
+  /**
+   * Prevent the default logger from reporting this exception
+   * after the custom reportable callback has run.
+   */
+  stop(): void;
+}
+/**
+ * Constructor type for ApplicationError subclasses.
+ */
+type ApplicationErrorConstructor<T extends ApplicationError = ApplicationError> = new (...args: any[]) => T;
+//#endregion
+//#region src/errors/exception-handler.d.ts
+/**
+ * ExceptionHandler — Laravel-inspired exception handling for Stratal.
+ *
+ * Provides a composable, expressive API for controlling how exceptions are
+ * reported (logged / sent to external services) and rendered (turned into
+ * HTTP Responses or ErrorResponse objects).
+ *
+ * **Lifecycle:**
+ * 1. The framework resolves this from the DI container (once at init time).
+ * 2. `register()` is called to let the user configure reporting / rendering.
+ * 3. Module `onException()` hooks contribute additional configuration.
+ * 4. On every error, `handle()` runs the pipeline: normalize → report → render → respond.
+ *
+ * **Usage — extend and override `register()`:**
+ *
+ * @example
+ * ```typescript
+ * export class AppExceptionHandler extends ExceptionHandler {
+ *   register(): void {
+ *     this.reportable(PaymentError, (e, ctx) => {
+ *       this.resolve(SentryService).captureException(e)
+ *     }).stop()
+ *
+ *     this.renderable(MaintenanceError, (e, ctx) => {
+ *       if (ctx.type === 'http') return ctx.ctx.html('<h1>Maintenance</h1>', 503)
+ *     })
+ *
+ *     this.dontReport([RouteNotFoundError])
+ *     this.level(RecordNotFoundError, 'warn')
+ *     this.context(() => ({ region: 'us-east-1' }))
+ *     this.respond((res, err) => {
+ *       res.headers.set('X-Error-Code', String(err.code))
+ *       return res
+ *     })
+ *   }
+ * }
+ * ```
+ */
+declare abstract class ExceptionHandler {
+  protected readonly logger: LoggerService;
+  protected readonly env: StratalEnv;
+  private readonly container;
+  private readonly executionContext;
+  private readonly reportables;
+  private readonly renderables;
+  private readonly dontReportSet;
+  private readonly levelOverrides;
+  private readonly contextCallbacks;
+  private readonly respondCallbacks;
+  private readonly environment;
+  constructor(logger: LoggerService, env: StratalEnv, container: Container, executionContext: StratalExecutionContext);
+  /**
+   * Configure exception reporting and rendering.
+   *
+   * Override this method in your handler class to register custom
+   * `reportable()`, `renderable()`, `dontReport()`, `level()`,
+   * `context()`, and `respond()` callbacks.
+   */
+  abstract register(): void;
+  /**
+   * Register a custom reporting callback for a specific exception type.
+   *
+   * The callback is invoked when an error matching `errorClass` (via `instanceof`)
+   * is thrown. Chain `.stop()` to prevent the default logger from also reporting.
+   *
+   * @typeParam T - The exception type to match
+   * @param errorClass - Constructor of the exception to match
+   * @param callback - Reporting function receiving the typed error and context
+   * @returns A {@link Reportable} with a `stop()` method
+   *
+   * @example
+   * ```typescript
+   * this.reportable(PaymentError, (e, ctx) => {
+   *   sentry.captureException(e)
+   * }).stop() // skip default logging
+   * ```
+   */
+  reportable<T extends ApplicationError>(errorClass: ApplicationErrorConstructor<T>, callback: ReportableCallback<T>): Reportable;
+  /**
+   * Register a custom rendering callback for a specific exception type.
+   *
+   * The callback should return a `Response` (for HTTP contexts), an `ErrorResponse`,
+   * or `undefined` to fall through to the default renderer.
+   *
+   * @typeParam T - The exception type to match
+   * @param errorClass - Constructor of the exception to match
+   * @param callback - Rendering function receiving the typed error and context
+   *
+   * @example
+   * ```typescript
+   * this.renderable(MaintenanceError, (e, ctx) => {
+   *   if (ctx.type === 'http') {
+   *     return ctx.ctx.html('<h1>Down for maintenance</h1>', 503)
+   *   }
+   * })
+   * ```
+   */
+  renderable<T extends ApplicationError>(errorClass: ApplicationErrorConstructor<T>, callback: RenderableCallback<T>): void;
+  /**
+   * Suppress reporting (logging) for the given exception types.
+   *
+   * Errors matching these classes will still be rendered into responses
+   * but will not be logged or sent to external reporters.
+   *
+   * @param errorClasses - Array of exception constructors to suppress
+   *
+   * @example
+   * ```typescript
+   * this.dontReport([RouteNotFoundError, SchemaValidationError])
+   * ```
+   */
+  dontReport(errorClasses: ApplicationErrorConstructor[]): void;
+  /**
+   * Override the log severity for a specific exception type.
+   *
+   * By default, severity is derived from the error code range.
+   * Use this to promote or demote specific errors.
+   *
+   * @param errorClass - Constructor of the exception to override
+   * @param severity - The log severity to use
+   *
+   * @example
+   * ```typescript
+   * this.level(RecordNotFoundError, 'warn')
+   * ```
+   */
+  level(errorClass: ApplicationErrorConstructor, severity: LogSeverity): void;
+  /**
+   * Add global context data to all exception log entries.
+   *
+   * The callback is invoked on every reported error and its return value
+   * is merged into the log data.
+   *
+   * @param callback - Function returning key-value pairs to include in logs
+   *
+   * @example
+   * ```typescript
+   * this.context(() => ({
+   *   appVersion: '1.2.3',
+   *   region: env.CF_REGION,
+   * }))
+   * ```
+   */
+  context(callback: ContextCallback): void;
+  /**
+   * Register a callback to post-process every error Response before it is returned.
+   *
+   * Use this to add headers, modify the body, change content type, or
+   * transform the response in any way.
+   *
+   * @param callback - Function receiving (response, error, context) and returning a Response
+   *
+   * @example
+   * ```typescript
+   * this.respond((response, error, ctx) => {
+   *   response.headers.set('X-Error-Code', String(error.code))
+   *   return response
+   * })
+   * ```
+   */
+  respond(callback: RespondCallback): void;
+  /**
+   * Resolve a service from the DI container.
+   *
+   * Useful inside `register()` callbacks for accessing injected services
+   * (e.g., Sentry, analytics, custom loggers).
+   *
+   * @typeParam T - The type of the service to resolve
+   * @param token - DI token (symbol or constructor)
+   * @returns The resolved service instance
+   *
+   * @example
+   * ```typescript
+   * this.reportable(CriticalError, (e) => {
+   *   this.resolve(SentryService).captureException(e)
+   * })
+   * ```
+   */
+  resolve<T>(token: symbol | (new (...args: unknown[]) => T)): T;
+  /**
+   * Handle an error through the full exception pipeline.
+   *
+   * This is the single entry point used by all contexts (HTTP, queue, cron, CLI).
+   * It normalizes the error, reports it (non-blocking via `waitUntil`),
+   * renders it into a Response, and applies post-processing.
+   *
+   * @param error - The thrown error (may or may not be an ApplicationError)
+   * @param context - The execution context where the error occurred
+   * @returns A Response (JSON by default, customizable via renderable/respond)
+   */
+  handle(error: unknown, context: ExceptionContext): Promise<Response>;
+  /**
+   * Normalize an unknown error into an ApplicationError.
+   * Non-ApplicationError values are wrapped in InternalError.
+   */
+  private normalizeError;
+  /**
+   * Run the reporting pipeline for an error.
+   */
+  private performReport;
+  /**
+   * Run the rendering pipeline for an error, producing a Response.
+   */
+  private performRender;
+  /**
+   * Apply all respond() callbacks to post-process a Response.
+   */
+  private applyRespondCallbacks;
+  /**
+   * Check if an error is in the dontReport set.
+   */
+  private shouldNotReport;
+  /**
+   * Find the most-specific reportable entry for an error.
+   * Walks entries in registration order; picks the most-specific `instanceof` match.
+   */
+  private findReportable;
+  /**
+   * Find the most-specific renderable entry for an error.
+   */
+  private findRenderable;
+  /**
+   * Default reporting — log with appropriate severity and i18n translation.
+   */
+  private defaultReport;
+  /**
+   * Default rendering — content-negotiated.
+   *
+   * For HTTP requests that accept HTML: renders a minimal branded HTML page.
+   * For everything else (API, queue, cron, CLI): returns JSON.
+   *
+   * Errors are always logged via `performReport` (non-blocking waitUntil),
+   * so they appear in the console regardless of the rendered response format.
+   */
+  private defaultRender;
+  /**
+   * Check if the HTTP request prefers an HTML response.
+   *
+   * Uses the `Accept` header to determine format. Inertia v3 XHR requests
+   * send `Accept: text/html, application/xhtml+xml`, so they naturally
+   * receive HTML error pages (displayed in Inertia's error modal in dev).
+   *
+   * Override in a subclass to customize content negotiation logic.
+   */
+  protected wantsHtml(context: HttpExceptionContext): boolean;
+  /**
+   * Minimal production HTML error page with inline styles.
+   */
+  private renderDefaultHtml;
+  private escapeHtml;
+  /**
+   * Convert a render result (Response or ErrorResponse) into a Response.
+   */
+  private toResponse;
+  /**
+   * Translate an error's message key via i18n.
+   * Uses the request container (from HTTP context) for correct locale,
+   * falling back to the global container or raw message string.
+   */
+  private translateError;
+  /**
+   * Resolve the log severity for an error.
+   * Checks level overrides first, then falls back to code-range-based severity.
+   */
+  private resolveSeverity;
+  /**
+   * Determine default log severity based on error code range.
+   */
+  private getDefaultSeverity;
+  /**
+   * Gather all global context data from registered callbacks.
+   */
+  private gatherContext;
+}
+//#endregion
+//#region src/module/types.d.ts
+/**
+ * Provider that uses a class constructor
+ *
+ * @example Transient (default)
+ * ```typescript
+ * { provide: UserService, useClass: UserService }
+ * ```
+ *
+ * @example Singleton
+ * ```typescript
+ * { provide: DI_TOKENS.ConsumerRegistry, useClass: ConsumerRegistry, scope: Scope.Singleton }
+ * ```
+ *
+ * @example Request-scoped
+ * ```typescript
+ * { provide: DI_TOKENS.ConnectionManager, useClass: ConnectionManager, scope: Scope.Request }
+ * ```
+ */
+interface ClassProvider<T extends object = object> {
+  provide: InjectionToken$2<T>;
+  useClass: Constructor<T>;
+  /** Lifecycle scope - defaults to Transient if not specified */
+  scope?: Scope;
+}
+/**
+ * Provider that uses a pre-created value
+ *
+ * Note: Values are inherently singleton-like (same instance always returned).
+ * No scope option needed.
+ */
+interface ValueProvider<T extends object = object> {
+  provide: InjectionToken$2<T>;
+  useValue: T;
+}
+/**
+ * Provider that uses a factory function with auto-injection support
+ *
+ * Note: Factory providers do not support scope/lifecycle in tsyringe.
+ * Factories are always called fresh on each resolution (transient-like behavior).
+ *
+ * @example Factory with dependencies
+ * ```typescript
+ * {
+ *   provide: LOGGER_TOKENS.Transports,
+ *   useFactory: (console) => [console],
+ *   inject: [LOGGER_TOKENS.ConsoleTransport]
+ * }
+ * ```
+ */
+interface FactoryProvider<T extends object = object> {
+  provide: InjectionToken$2<T>;
+  useFactory: (...deps: any[]) => T | Promise<T>;
+  inject?: InjectionToken$2<unknown>[];
+}
+/**
+ * Provider that creates an alias to an existing token
+ *
+ * When the `provide` token is resolved, the container resolves `useExisting` instead.
+ * Both tokens return the same instance (for singleton/request-scoped services).
+ *
+ * Use cases:
+ * - Creating interface tokens that alias concrete implementations
+ * - Multiple tokens resolving to the same service
+ *
+ * @example Basic alias
+ * ```typescript
+ * {
+ *   provide: 'IUserService',
+ *   useExisting: UserService
+ * }
+ * // Resolving 'IUserService' returns the UserService instance
+ * ```
+ *
+ * @example Interface abstraction
+ * ```typescript
+ * providers: [
+ *   UserService,
+ *   { provide: I_USER_SERVICE, useExisting: UserService }
+ * ]
+ * // Both UserService and I_USER_SERVICE resolve to the same instance
+ * ```
+ */
+interface ExistingProvider<T extends object = object> {
+  provide: InjectionToken$2<T>;
+  useExisting: InjectionToken$2<T>;
+}
+/**
+ * Union type for all provider types
+ */
+type Provider<T extends object = object> = Constructor<T> | ClassProvider<T> | ValueProvider<T> | FactoryProvider<T> | ExistingProvider<T>;
+/**
+ * Module class type (decorated with @Module)
+ *
+ * Static methods for dynamic module configuration:
+ * - forRoot: Synchronous configuration (like NestJS forRoot)
+ * - forRootAsync: Async configuration with factory (like NestJS forRootAsync)
+ */
+interface ModuleClass<T extends object = object> extends Constructor<T> {
+  /**
+   * Synchronous module configuration
+   *
+   * Use for global singleton modules with static configuration
+   *
+   * @example
+   * ```typescript
+   * @Module({ providers: [] })
+   * export class ConfigModule {
+   *   static forRoot(options: ConfigOptions): DynamicModule {
+   *     return {
+   *       providers: [
+   *         { provide: CONFIG_TOKEN, useValue: options }
+   *       ]
+   *     }
+   *   }
+   * }
+   *
+   * // Usage in AppModule
+   * @Module({ imports: [ConfigModule.forRoot({ apiKey: '...' })] })
+   * ```
+   */
+  forRoot?: (...args: unknown[]) => DynamicModule;
+  /**
+   * Async module configuration with dependency injection
+   *
+   * Use when configuration depends on other services
+   *
+   * @example
+   * ```typescript
+   * @Module({ providers: [] })
+   * export class DatabaseModule {
+   *   static forRootAsync<T>(options: AsyncModuleOptions<T>): DynamicModule {
+   *     return {
+   *       providers: [
+   *         {
+   *           provide: DB_TOKEN,
+   *           useFactory: options.useFactory,
+   *           inject: options.inject
+   *         }
+   *       ]
+   *     }
+   *   }
+   * }
+   *
+   * // Usage in AppModule
+   * @Module({
+   *   imports: [
+   *     DatabaseModule.forRootAsync({
+   *       inject: [CONFIG_TOKEN],
+   *       useFactory: (config) => ({ url: config.databaseUrl })
+   *     })
+   *   ]
+   * })
+   * ```
+   */
+  forRootAsync?: <TOptions>(options: AsyncModuleOptions<TOptions>) => DynamicModule;
+}
+/**
+ * Module options for `@Module` decorator
+ *
+ * Note: Middlewares are configured via the RouteConfigurable interface's
+ * configureRoutes() method, not via this options object. See router/router.ts.
+ */
+interface ModuleOptions {
+  imports?: (ModuleClass | DynamicModule)[];
+  providers?: Provider[];
+  controllers?: Constructor[];
+  consumers?: Constructor[];
+  jobs?: Constructor[];
+}
+/**
+ * Dynamic module returned by forRoot/forRootAsync
+ *
+ * Contains additional providers, controllers, consumers, and jobs
+ * that are added to the module when configured dynamically.
+ */
+interface DynamicModule extends Omit<ModuleOptions, 'imports'> {
+  /**
+   * Reference to the module class that created this dynamic module
+   *
+   * Required for dynamic modules to support lifecycle methods (configure, onInitialize, onShutdown).
+   * ModuleRegistry uses this to instantiate the actual module class instead of an anonymous wrapper.
+   *
+   * Note: This is NOT for provider scoping (tsyringe is always global).
+   * It's purely for preserving the class reference for lifecycle method calls.
+   */
+  module: Constructor;
+}
+/**
+ * Async configuration options for forRootAsync
+ */
+interface AsyncModuleOptions<TOptions> {
+  inject?: InjectionToken$2<unknown>[];
+  useFactory: (...deps: any[]) => TOptions | Promise<TOptions>;
+}
+/**
+ * Context passed to lifecycle hooks
+ */
+interface ModuleContext {
+  container: Container;
+  logger: LoggerService;
+}
+/**
+ * Lifecycle hook: called after all providers are registered
+ */
+interface OnInitialize {
+  onInitialize(context: ModuleContext): void | Promise<void>;
+}
+/**
+ * Lifecycle hook: called during application shutdown
+ */
+interface OnShutdown {
+  onShutdown(context: ModuleContext): void | Promise<void>;
+}
+/**
+ * Lifecycle hook: called after the {@link ExceptionHandler} is initialized.
+ *
+ * Implement this interface on a module class to contribute custom
+ * `reportable()`, `renderable()`, `dontReport()`, etc. registrations
+ * to the application's exception handler.
+ *
+ * @example
+ * ```typescript
+ * @Module({ providers: [PaymentService] })
+ * export class PaymentModule implements OnException {
+ *   onException(handler: ExceptionHandler): void {
+ *     handler.reportable(PaymentError, (e) => { ... })
+ *     handler.renderable(PaymentDeclinedError, (e, ctx) => {
+ *       if (ctx.type === 'http') return ctx.ctx.json({ retryable: true }, 402)
+ *     })
+ *   }
+ * }
+ * ```
+ */
+interface OnException {
+  onException(handler: ExceptionHandler): void;
+}
+/**
+ * Tsyringe registry entry type (for internal use)
+ *
+ * Note: useFactory receives DependencyContainer from tsyringe,
+ * but we resolve our Container via CONTAINER_TOKEN for consistency.
+ */
+interface RegistryEntry<T extends object = object> {
+  token: InjectionToken$2<T>;
+  useClass?: Constructor<T>;
+  useValue?: T;
+  useFactory?: (dependencyContainer: DependencyContainer) => T;
+  useToken?: InjectionToken$2<T>;
+}
+//#endregion
+//#region src/quarry/types.d.ts
+/**
+ * Flat input object for programmatic command invocation.
+ */
+type CommandInput = Record<string, unknown>;
+/**
+ * Result of a command execution.
+ */
+interface CommandResult {
+  exitCode: number;
+  output: string[];
+  errors: string[];
+}
+/**
+ * User-facing Quarry interface. Only exposes the `call()` method.
+ *
+ * Inject via `@inject(DI_TOKENS.Quarry)` and type as `Quarry`.
+ */
+interface Quarry {
+  call(name: string, input?: CommandInput): Promise<CommandResult>;
+}
+/**
+ * Internal mutable state stored on Command instances via Symbol key.
+ * @internal
+ */
+interface CommandInternals {
+  inputs: CommandInput;
+  output: string[];
+  errors: string[];
+  exitCode: number;
+  quarry: Quarry | null;
+}
+/**
+ * A parsed argument from a Laravel-style signature string.
+ */
+interface ParsedArgument {
+  name: string;
+  required: boolean;
+  default?: string;
+  description?: string;
+  isArray: boolean;
+}
+/**
+ * A parsed option from a Laravel-style signature string.
+ */
+interface ParsedOption {
+  name: string;
+  alias?: string;
+  isFlag: boolean;
+  isArray: boolean;
+  default?: string;
+  description?: string;
+}
+/**
+ * Fully parsed command signature.
+ */
+interface ParsedSignature {
+  name: string;
+  arguments: ParsedArgument[];
+  options: ParsedOption[];
+}
+//#endregion
+//#region src/router/controller.d.ts
+/**
+ * Controller interface for handling HTTP requests
+ *
+ * Controllers can implement RESTful methods or a custom handle() method.
+ * The route for the controller is set via the `@Controller` decorator.
+ *
+ * RESTful methods auto-map to HTTP verbs:
+ * - index() → GET /route
+ * - show() → GET /route/:id
+ * - create() → POST /route
+ * - update() → PUT /route/:id
+ * - patch() → PATCH /route/:id
+ * - destroy() → DELETE /route/:id
+ *
+ * For non-RESTful routes (wildcards, custom patterns), implement handle()
+ */
+interface IController {
+  /**
+   * GET /route
+   * List all resources
+   */
+  index?(ctx: RouterContext): Promise<Response> | Response;
+  /**
+   * GET /route/:id
+   * Show a specific resource
+   */
+  show?(ctx: RouterContext): Promise<Response> | Response;
+  /**
+   * POST /route
+   * Create a new resource
+   */
+  create?(ctx: RouterContext): Promise<Response> | Response;
+  /**
+   * PUT /route/:id
+   * Update a resource (full replacement)
+   */
+  update?(ctx: RouterContext): Promise<Response> | Response;
+  /**
+   * PATCH /route/:id
+   * Patch a resource (partial update)
+   */
+  patch?(ctx: RouterContext): Promise<Response> | Response;
+  /**
+   * DELETE /route/:id
+   * Delete a resource
+   */
+  destroy?(ctx: RouterContext): Promise<Response> | Response;
+  /**
+   * Custom handler for non-RESTful routes
+   * Use this for wildcards (e.g., /api/v1/auth/*) or custom patterns
+   * Takes precedence over RESTful methods if defined
+   */
+  handle?(ctx: RouterContext): Promise<Response> | Response;
+}
+//#endregion
+//#region src/router/middleware.interface.d.ts
+type Next$1 = Next;
+/**
+ * Middleware interface for request processing
+ *
+ * Middlewares use the `@Transient()` decorator and are registered via
+ * `configureRoutes(router)` in modules implementing `RouteConfigurable`.
+ *
+ * @example
+ * ```typescript
+ * @Transient()
+ * export class LoggingMiddleware implements Middleware {
+ *   async handle(ctx: RouterContext, next: () => Promise<void>): Promise<void> {
+ *     const start = Date.now()
+ *     await next()
+ *     console.log(`Request took ${Date.now() - start}ms`)
+ *   }
+ * }
+ *
+ * // Register in module:
+ * @Module({ providers: [LoggingMiddleware] })
+ * export class AppModule implements RouteConfigurable {
+ *   configureRoutes(router: Router): void {
+ *     router.middleware(LoggingMiddleware)
+ *   }
+ * }
+ * ```
+ */
+interface Middleware {
+  /**
+   * Handle middleware logic
+   * Call next() to continue the middleware chain
+   *
+   * @param ctx - Router context with request/response helpers
+   * @param next - Function to call the next middleware or route handler
+   */
+  handle(ctx: RouterContext, next: Next$1): Promise<Response | void>;
+}
+//#endregion
+//#region src/router/router.internals.d.ts
+/**
+ * Symbol keys for Router internal accessors.
+ *
+ * These symbols are NOT exported from the public `stratal/router` barrel.
+ * Only internal modules (RouterResolver) import them, keeping the Router's
+ * public API clean — users never see these methods.
+ *
+ * Declared as individual unique symbols so TypeScript can distinguish
+ * their return types in computed property access.
+ *
+ * @internal
+ */
+/** @internal */
+declare const getDefaultEntry: unique symbol;
+/** @internal */
+declare const getGroups: unique symbol;
+/** @internal */
+declare const getGlobalMiddleware: unique symbol;
+//#endregion
+//#region src/router/router.d.ts
+/**
+ * Configuration for a sub-group created via `router.group()`.
+ */
+interface RouterGroupConfig {
+  prefix?: string;
+  domain?: string;
+  name?: string;
+  middleware?: Constructor<Middleware>[];
+  version?: string | string[];
+  hideFromDocs?: boolean;
+  params?: index_d_exports$1.ZodObject<any>;
+}
+/**
+ * Internal entry representing a sub-group or the default scope.
+ * @internal — used by RouterResolver, not exported publicly.
+ */
+interface RouterEntry {
+  prefix?: string;
+  domain?: string;
+  name?: string;
+  middleware: Constructor<Middleware>[];
+  version?: string | string[];
+  hideFromDocs?: boolean;
+  params?: index_d_exports$1.ZodObject<any>;
+  /** Controllers in this entry. undefined = all controllers not in any sub-group */
+  controllers?: Constructor[];
+}
+/**
+ * Modules implement this to configure routes and middleware.
+ * Replaces `MiddlewareConfigurable`.
+ *
+ * @example
+ * ```typescript
+ * @Module({ controllers: [UsersController, PostsController] })
+ * export class ApiModule implements RouteConfigurable {
+ *   configureRoutes(router: Router): void {
+ *     router
+ *       .name('api.')
+ *       .middleware(CorsMiddleware)
+ *       .version('1')
+ *   }
+ * }
+ * ```
+ */
+interface RouteConfigurable {
+  configureRoutes(router: Router): void;
+}
+/**
+ * Fluent builder for route and middleware configuration.
+ *
+ * Scoped methods (`middleware()`, `prefix()`, `domain()`, `name()`, `version()`, `hideFromDocs()`)
+ * apply only to this module's controllers or the sub-group's controllers.
+ *
+ * `use()` registers global middleware (all routes in the entire app).
+ * Only callable on the root Router — throws inside `group()` callbacks.
+ *
+ * `group()` creates sub-groups for specific controllers with a callback.
+ * Controllers in a sub-group are excluded from the parent scope.
+ */
+declare class Router {
+  private readonly _isChild;
+  private readonly _defaultEntry;
+  private readonly _groups;
+  private readonly _globalMiddleware;
+  constructor(isChild?: boolean);
+  /** Dynamic path prefix. For shared segments like `/:companyId` */
+  prefix(path: string, params?: index_d_exports$1.ZodObject<any>): this;
+  /** Domain pattern for controllers in this scope */
+  domain(pattern: string): this;
+  /** Name prefix for routes in this scope */
+  name(prefix: string): this;
+  /** Middleware applied to controllers in this scope */
+  middleware(...middlewares: Constructor<Middleware>[]): this;
+  /** API version for controllers in this scope */
+  version(version: string | string[]): this;
+  /** Hide/show routes in this scope from OpenAPI docs */
+  hideFromDocs(hide?: boolean): this;
+  /**
+   * Global middleware — applied to ALL routes in the entire app.
+   * Only callable on the root Router. Throws if called inside `group()`.
+   */
+  use(...middlewares: Constructor<Middleware>[]): this;
+  /**
+   * Create a sub-group for specific controllers/gateways.
+   * Controllers in a sub-group are excluded from the parent (default) scope.
+   * The callback receives a new Router (without `use()`) for fluent configuration.
+   */
+  group(controllers: Constructor[], callback: (router: Omit<Router, 'use'>) => void): this;
+  [getDefaultEntry](): RouterEntry;
+  [getGroups](): RouterEntry[];
+  [getGlobalMiddleware](): Constructor<Middleware>[];
+}
+//#endregion
+//#region src/module/module-registry.d.ts
+/**
+ * ModuleRegistry - manages module lifecycle
+ *
+ * @example
+ * ```typescript
+ * const registry = new ModuleRegistry(container, logger)
+ * registry.register(AppModule)  // Traverses imports recursively
+ * await registry.initialize()
+ * // ... application running ...
+ * await registry.shutdown()
+ * ```
+ */
+declare class ModuleRegistry {
+  private readonly container;
+  private readonly logger;
+  private modules;
+  private registeredClasses;
+  private initialized;
+  private allControllers;
+  private allConsumers;
+  private allJobs;
+  private allListeners;
+  private allCommands;
+  private allSeeders;
+  private allRouterConfigs;
+  constructor(container: Container, logger: LoggerService);
+  /**
+   * Register a module (static or dynamic)
+   *
+   * @param moduleOrDynamic - Module class decorated with `@Module` or DynamicModule from configure()
+   */
+  register(moduleOrDynamic: ModuleClass | DynamicModule): void;
+  /**
+   * Register multiple modules in order
+   */
+  registerAll(modules: (ModuleClass | DynamicModule)[]): void;
+  /**
+   * Initialize all modules (call configure and onInitialize hooks)
+   */
+  initialize(): Promise<void>;
+  /**
+   * Get all controllers registered from all modules
+   */
+  getAllControllers(): Constructor[];
+  /**
+   * Get all consumers registered from all modules
+   */
+  getAllConsumers(): Constructor[];
+  /**
+   * Get all jobs registered from all modules
+   */
+  getAllJobs(): Constructor[];
+  /**
+   * Get all listeners registered from all modules
+   */
+  getAllListeners(): Constructor[];
+  /**
+   * Get all commands registered from all modules
+   */
+  getAllCommands(): Constructor[];
+  /**
+   * Get all seeders registered from all modules
+   */
+  getAllSeeders(): Constructor[];
+  /**
+   * Get all Router configurations from modules implementing RouteConfigurable.
+   * Runs configureRoutes() lazily on first call (deferred from initialize()).
+   */
+  getAllRouterConfigs(): {
+    router: Router;
+    controllers: Constructor[];
+  }[];
+  /**
+   * Call `onException()` on all modules that implement the OnException interface.
+   * Invoked by Application after the ExceptionHandler is resolved and `register()` is called.
+   *
+   * @param handler - The resolved ExceptionHandler instance
+   */
+  configureExceptionHandlers(handler: ExceptionHandler): void;
+  /**
+   * Shutdown all modules (call onShutdown hooks in reverse order)
+   */
+  shutdown(): Promise<void>;
+  /**
+   * Type guard for RouteConfigurable
+   */
+  private hasRouteConfigurable;
+  /**
+   * Type guard for OnInitialize
+   */
+  private hasOnInitialize;
+  /**
+   * Type guard for OnShutdown
+   */
+  private hasOnShutdown;
+  /**
+   * Type guard for OnException
+   */
+  private hasOnException;
+  /**
+   * Resolve module class and options from static or dynamic module
+   *
+   * For DynamicModules, merges the decorator metadata (consumers, controllers, jobs)
+   * with the DynamicModule options (providers, imports). This ensures modules using
+   * forRoot/forRootAsync patterns still have their decorator-defined consumers registered.
+   */
+  private resolveModule;
+  /**
+   * Type guard for DynamicModule
+   */
+  private isDynamicModule;
+  /**
+   * Register a single provider in the container
+   */
+  private registerProvider;
+  /**
+   * Check if a class is a `Command` and collect it for auto-wiring
+   */
+  private collectIfCommand;
+  /**
+   * Check if a class is a `Seeder` and collect it for auto-wiring
+   */
+  private collectIfSeeder;
+  /**
+   * Check if a class is a `@Listener()` and collect it for auto-wiring
+   */
+  private collectIfListener;
+}
+//#endregion
+//#region src/router/router-resolver.d.ts
+/**
+ * Resolved configuration for a single controller.
+ * Merges Router default entry, sub-group overrides, and inheritance rules.
+ */
+interface ResolvedRouterConfig {
+  prefix?: string;
+  domain?: string;
+  name?: string;
+  middleware: Constructor<Middleware>[];
+  version?: string | string[];
+  hideFromDocs?: boolean;
+  params?: index_d_exports$1.ZodObject<any>;
+}
+/**
+ * Internal resolver that computes the effective Router config for each controller.
+ *
+ * Inheritance rules:
+ * - `middleware`: parent middleware runs first, then child (concatenated)
+ * - `prefix`: concatenated (parent + child)
+ * - `name`: concatenated (parent + child)
+ * - `domain`: child overrides parent
+ * - `version`: child overrides parent
+ * - `hideFromDocs`: child overrides parent
+ *
+ * @internal — not exported from stratal/router
+ */
+declare class RouterResolver {
+  private readonly routers;
+  constructor(routers: {
+    router: Router;
+    controllers: Constructor[];
+  }[]);
+  /**
+   * Resolve the effective config for a given controller class.
+   * Searches through all module routers to find the one owning this controller.
+   */
+  resolveForController(controller: Constructor): ResolvedRouterConfig;
+  /**
+   * Collect all global middleware registered via `router.use()` across all modules.
+   */
+  getGlobalMiddleware(): Constructor<Middleware>[];
+  /**
+   * Merge parent default entry with child group entry following inheritance rules.
+   */
+  private mergeEntries;
+  private entryToConfig;
+  private mergeParams;
+  private concatPrefixes;
+  private concatNames;
+}
+//#endregion
+//#region src/router/services/route-registration.service.d.ts
+/**
+ * Route registration service
+ * Manages controller and route registration with OpenAPI support
+ *
+ * Responsibilities:
+ * - Register RESTful controllers with OpenAPI metadata
+ * - Auto-derive HTTP methods/paths from controller method names
+ * - Build OpenAPI route configurations with guard execution
+ * - Validate all controllers have access decorators (strict mode)
+ * - Create controller handlers with DI resolution
+ *
+ * Two-pass strategy:
+ * 1. Collect: iterate controllers, register in RouteRegistry, store Hono actions
+ * 2. Register: iterate registry.all() (sorted), execute stored actions in Hono
+ */
+declare class RouteRegistrationService {
+  private logger;
+  private registry;
+  private routerResolver;
+  private localePathService;
+  private app;
+  private moduleRegistry;
+  private controllerClasses;
+  private upgradeWebSocketFn;
+  constructor(logger: LoggerService, registry: RouteRegistry, routerResolver: RouterResolver | null, localePathService: LocalePathService, app: HonoApp, moduleRegistry: ModuleRegistry);
+  /**
+   * Configure router with controllers and global middleware.
+   * Resolves controllers from ModuleRegistry and global middleware from RouterResolver.
+   */
+  configure(): Promise<void>;
+  /**
+   * Pass 1: Collect routes from a controller into RouteRegistry and store Hono actions.
+   * Versioning and locale expansion are handled by RouteRegistry.register().
+   */
+  private collectRoutes;
+  /**
+   * Register a single WebSocket gateway route
+   */
+  private registerGatewayForPath;
+  /**
+   * 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
+   */
+  private createGuardMiddleware;
+  /**
+   * 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.
+   */
+  private wrapHandlerWithChain;
+  /**
+   * Register wildcard route for non-RESTful controllers
+   */
+  private registerWildcardRoute;
+  /**
+   * Resolve HTTP method, path, route config, and status code from route metadata.
+   */
+  private resolveMethodAndPath;
+  /**
+   * Join a base path and a route path, normalizing slashes
+   */
+  private joinPaths;
+  /**
+   * Auto-derive HTTP method and path from controller method name
+   * Uses HTTP_METHODS constant for RESTful convention mapping
+   */
+  private deriveHttpMethodAndPath;
+  /**
+   * Merge controller-level and route-level metadata
+   * Tags are merged (appended), security is merged (union)
+   * Guards automatically add sessionCookie security if present
+   */
+  private mergeMetadata;
+  /**
+   * 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`.
+   */
+  private buildOpenAPIRoute;
+  /**
+   * Check if a body definition is a RouteBodyObject (has schema key) vs bare ZodType
+   */
+  private isRouteBodyObject;
+  /**
+   * 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
+   */
+  private resolveMethodInjections;
+  /**
+   * Name a handler function so Hono's inspectRoutes() can identify it.
+   * Format: `{type}:{Controller}.{method}` (e.g. `http:UsersController.create`)
+   */
+  private nameHandler;
+  /**
+   * Create controller handler that resolves controller from request-scoped container
+   * This ensures each request gets a fresh controller with request-scoped context
+   */
+  private createControllerHandler;
+  /**
+   * Extract the Zod schema from a RouteResponse definition.
+   * Returns null for non-JSON content types or when no response is defined.
+   */
+  private extractResponseSchema;
+  /**
+   * Check if a response definition is a RouteResponseObject (has schema key) vs bare ZodType
+   */
+  private isRouteResponseObject;
+  /**
+   * 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.
+   */
+  private validateResponse;
+}
+//#endregion
+//#region src/router/router.tokens.d.ts
+/**
+ * Dependency injection tokens for the router system
+ */
+declare const ROUTER_TOKENS: {
+  /**
+   * Token for RouterContext (request-scoped)
+   * Contains Hono context wrapper with helper methods
+   */
+  readonly RouterContext: symbol;
+  /**
+   * Token for RouteRegistry (singleton)
+   * Central registry of all application routes — source of truth for route:list, route:types, URL generation
+   */
+  readonly RouteRegistry: symbol;
+  /**
+   * Token for VersioningService (singleton)
+   * Resolves version prefixes for route paths
+   */
+  readonly VersioningService: symbol;
+  /**
+   * Token for LocalePathService (singleton)
+   * Resolves locale path variants and computes LocalePathConfig
+   */
+  readonly LocalePathService: symbol;
+  /**
+   * Token for RouterResolver (singleton, may be null)
+   * Internal resolver that computes effective Router config per controller
+   */
+  readonly RouterResolver: symbol;
+  /**
+   * Token for HonoApp (singleton)
+   * The Hono application instance with Stratal-specific setup
+   */
+  readonly HonoApp: symbol;
+  /**
+   * Token for Uri (request-scoped)
+   * URL generation service — route URLs, signed URLs, current/previous URL access
+   */
+  readonly Uri: symbol;
+};
+//#endregion
+//#region src/router/route-url.d.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' })
+ * ```
+ */
+declare function route<N extends RouteName>(name: N, params?: RouteParams<N>): string;
+//#endregion
+//#region src/router/utils/path.d.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'
+ */
+declare function toOpenAPIPath(path: string): string;
+/**
+ * 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.
+ */
+declare function getPathSpecificityScore(path: string): number;
+/**
+ * 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. Primary paths before locale-prefixed variants
+ */
+declare function sortRoutesBySpecificity<T extends {
+  path: string;
+}>(routes: T[]): T[];
+//#endregion
+//#region src/router/utils/route-name.d.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')                         // []
+ */
+declare function extractParamNames(path: string): string[];
+/**
+ * Extract parameter names from a domain pattern.
+ *
+ * @example
+ * extractDomainParamNames('{tenant}.example.com')           // ['tenant']
+ * extractDomainParamNames('{region}.{tenant}.example.com')  // ['region', 'tenant']
+ * extractDomainParamNames('example.com')                    // []
+ */
+declare function extractDomainParamNames(domain: string): string[];
+/**
+ * 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'
+ */
+declare function generateConventionRouteName(basePath: string, methodName: string): string;
+//#endregion
+//#region src/router/middleware/middleware-chain.d.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
+ */
+declare function createMiddlewareChain(classes: Constructor<Middleware>[]): MiddlewareHandler<RouterEnv>;
+//#endregion
+//#region src/router/decorators/controller.decorator.d.ts
+/**
+ * Base controller decorator for route registration
+ *
+ * This is the core controller decorator that handles:
+ * - Transient scope registration (request-scoped)
+ * - Route metadata storage
+ * - Controller options (tags, security schemes, hideFromDocs)
+ *
+ * @param route - Base route for this controller (e.g., '/api/v1/users')
+ * @param options - Optional configuration (tags, security schemes, hideFromDocs)
+ *
+ * @example
+ * ```typescript
+ * import { Controller } from 'stratal/router'
+ *
+ * @Controller('/api/v1/users', { tags: ['Users'] })
+ * export class UsersController implements IController {
+ *   // All routes accessible
+ * }
+ * ```
+ */
+declare function Controller(route: string, options?: ControllerOptions): <T extends Constructor>(target: T) => T;
+/**
+ * Get the route from controller class metadata
+ *
+ * @param target - Controller class or instance
+ * @returns Route string or undefined if not set
+ */
+declare function getControllerRoute(target: object): string | undefined;
+/**
+ * Get the options from controller class metadata
+ *
+ * @param target - Controller class or instance
+ * @returns Controller options or undefined if not set
+ */
+declare function getControllerOptions(target: object): ControllerOptions | undefined;
+/**
+ * Get the version from controller class metadata
+ *
+ * @param target - Controller class or instance
+ * @returns Version string, array, VERSION_NEUTRAL symbol, or undefined if not set
+ */
+declare function getControllerVersion(target: object): ControllerOptions['version'];
+//#endregion
+//#region src/router/decorators/http-method.decorator.d.ts
+/**
+ * Registers a GET route on the controller method.
+ *
+ * @param path - Route path relative to the controller base path
+ * @param config - Optional route configuration (response schema, body, params, etc.)
+ *
+ * @example
+ * ```typescript
+ * @Controller('/api/v1/users')
+ * class UsersController {
+ *   @Get('/', { response: z.array(userSchema), summary: 'List users' })
+ *   async list(ctx: RouterContext) { ... }
+ *
+ *   @Get('/:id', { params: z.object({ id: z.string().uuid() }), response: userSchema })
+ *   async getUser(ctx: RouterContext) { ... }
+ * }
+ * ```
+ */
+declare const Get: (path: string, config?: RouteConfig) => (target: object, propertyKey: string, descriptor: PropertyDescriptor) => PropertyDescriptor;
+/**
+ * Registers a POST route on the controller method.
+ *
+ * @param path - Route path relative to the controller base path
+ * @param config - Optional route configuration (response schema, body, params, etc.)
+ *
+ * @example
+ * ```typescript
+ * @Controller('/api/v1/users')
+ * class UsersController {
+ *   @Post('/', { body: createUserSchema, response: userSchema, statusCode: 201 })
+ *   async createUser(ctx: RouterContext) { ... }
+ * }
+ * ```
+ */
+declare const Post: (path: string, config?: RouteConfig) => (target: object, propertyKey: string, descriptor: PropertyDescriptor) => PropertyDescriptor;
+/**
+ * Registers a PUT route on the controller method.
+ *
+ * @param path - Route path relative to the controller base path
+ * @param config - Optional route configuration
+ */
+declare const Put: (path: string, config?: RouteConfig) => (target: object, propertyKey: string, descriptor: PropertyDescriptor) => PropertyDescriptor;
+/**
+ * Registers a PATCH route on the controller method.
+ *
+ * @param path - Route path relative to the controller base path
+ * @param config - Optional route configuration
+ */
+declare const Patch: (path: string, config?: RouteConfig) => (target: object, propertyKey: string, descriptor: PropertyDescriptor) => PropertyDescriptor;
+/**
+ * Registers a DELETE route on the controller method.
+ *
+ * @param path - Route path relative to the controller base path
+ * @param config - Optional route configuration
+ */
+declare const Delete: (path: string, config?: RouteConfig) => (target: object, propertyKey: string, descriptor: PropertyDescriptor) => PropertyDescriptor;
+/**
+ * Registers an ALL (any HTTP method) route on the controller method.
+ * Routes using @All are registered without OpenAPI validation
+ * since OpenAPI does not support a catch-all HTTP method.
+ *
+ * @param path - Route path relative to the controller base path
+ * @param config - Optional route configuration
+ */
+declare const All: (path: string, config?: RouteConfig) => (target: object, propertyKey: string, descriptor: PropertyDescriptor) => PropertyDescriptor;
+//#endregion
+//#region src/router/decorators/route.decorator.d.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)
+ *   }
+ * }
+ * ```
+ */
+declare function Route(config: Omit<RouteConfig, 'statusCode'>): (target: object, propertyKey: string, descriptor: PropertyDescriptor) => PropertyDescriptor;
+/**
+ * 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
+ */
+declare function getRouteMetadata(target: object, methodName: string): RouteMetadata | undefined;
+/**
+ * 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
+ */
+declare function getRouteDecoratedMethods(ControllerClass: new (...args: unknown[]) => object): string[];
+//#endregion
+//#region src/router/schemas/common.schemas.d.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 ApplicationError.toErrorResponse() structure
+ */
+declare const errorResponseSchema: z.ZodObject<{
+  code: z.ZodNumber;
+  message: z.ZodString;
+  timestamp: z.ZodString;
+  metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+  stack: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+/**
+ * Validation error response schema
+ * Used for 400 Bad Request with validation failures
+ * Matches ApplicationError.toErrorResponse() structure with validation-specific metadata
+ */
+declare const validationErrorResponseSchema: z.ZodObject<{
+  code: z.ZodNumber;
+  message: z.ZodString;
+  timestamp: z.ZodString;
+  metadata: z.ZodObject<{
+    issues: z.ZodArray<z.ZodObject<{
+      path: z.ZodString;
+      message: z.ZodString;
+      code: z.ZodString;
+    }, z.core.$strip>>;
+  }, z.core.$strip>;
+  stack: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+/**
+ * Pagination query parameters schema
+ * Used for list endpoints
+ */
+declare const paginationQuerySchema: z.ZodObject<{
+  page: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+  limit: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+}, z.core.$strip>;
+/**
+ * Paginated response wrapper schema
+ * Generic wrapper for paginated list responses
+ */
+declare const paginatedResponseSchema: <T extends z.ZodType>(itemSchema: T) => z.ZodObject<{
+  data: z.ZodArray<T>;
+  pagination: z.ZodObject<{
+    page: z.ZodNumber;
+    limit: z.ZodNumber;
+    total: z.ZodNumber;
+    totalPages: z.ZodNumber;
+  }, z.core.$strip>;
+}, z.core.$strip>;
+/**
+ * UUID parameter schema
+ * Used for :id parameters in RESTful routes
+ */
+declare const uuidParamSchema: z.ZodObject<{
+  id: z.ZodString;
+}, z.core.$strip>;
+/**
+ * Success message response schema
+ * Used for operations that don't return data (e.g., DELETE)
+ */
+declare const successMessageSchema: z.ZodObject<{
+  message: z.ZodString;
+  data: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>;
+/**
+ * Common HTTP status error schemas
+ * Pre-configured for standard error responses
+ */
+declare const commonErrorSchemas: {
+  readonly 400: {
+    readonly schema: z.ZodObject<{
+      code: z.ZodNumber;
+      message: z.ZodString;
+      timestamp: z.ZodString;
+      metadata: z.ZodObject<{
+        issues: z.ZodArray<z.ZodObject<{
+          path: z.ZodString;
+          message: z.ZodString;
+          code: z.ZodString;
+        }, z.core.$strip>>;
+      }, z.core.$strip>;
+      stack: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    readonly description: "Validation error";
+  };
+  readonly 401: {
+    readonly schema: z.ZodObject<{
+      code: z.ZodNumber;
+      message: z.ZodString;
+      timestamp: z.ZodString;
+      metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+      stack: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    readonly description: "Unauthorized";
+  };
+  readonly 403: {
+    readonly schema: z.ZodObject<{
+      code: z.ZodNumber;
+      message: z.ZodString;
+      timestamp: z.ZodString;
+      metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+      stack: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    readonly description: "Forbidden";
+  };
+  readonly 404: {
+    readonly schema: z.ZodObject<{
+      code: z.ZodNumber;
+      message: z.ZodString;
+      timestamp: z.ZodString;
+      metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+      stack: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    readonly description: "Not found";
+  };
+  readonly 409: {
+    readonly schema: z.ZodObject<{
+      code: z.ZodNumber;
+      message: z.ZodString;
+      timestamp: z.ZodString;
+      metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+      stack: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    readonly description: "Conflict";
+  };
+  readonly 500: {
+    readonly schema: z.ZodObject<{
+      code: z.ZodNumber;
+      message: z.ZodString;
+      timestamp: z.ZodString;
+      metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+      stack: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    readonly description: "Internal server error";
+  };
+};
+//#endregion
+//#region src/router/middleware/domain.middleware.d.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'] }
+ */
+declare function parseDomainPattern(pattern: string): {
+  regex: RegExp;
+  paramNames: string[];
+};
+/**
+ * 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, throws `DomainMismatchError` (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')
+ *   }
+ * }
+ * ```
+ */
+declare function createDomainMiddleware(pattern: string): MiddlewareHandler<RouterEnv>;
+//#endregion
+//#region src/router/middleware/verify-signature.middleware.d.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)
+ *   }
+ * }
+ * ```
+ */
+declare class VerifySignatureMiddleware implements Middleware {
+  handle(ctx: RouterContext, next: Next$1): Promise<void>;
+}
+//#endregion
+//#region src/router/signed-url.d.ts
+/**
+ * Signed URL utilities using HMAC-SHA256 via Web Crypto API.
+ *
+ * Follows the Cloudflare Workers signing pattern:
+ * https://developers.cloudflare.com/workers/examples/signing-requests/
+ *
+ * Uses `crypto.subtle.verify()` for timing-attack-safe comparison.
+ */
+/**
+ * Options for signing a URL.
+ */
+interface SignedUrlOptions {
+  /** Time-to-live in seconds. URL expires after this duration. */
+  expiresIn?: number;
+}
+/**
+ * Sign a URL with HMAC-SHA256.
+ *
+ * Appends `signature` and optionally `expires` query parameters.
+ * The signature covers the pathname + search (excluding the signature params themselves).
+ *
+ * @param url - Full URL or path to sign
+ * @param secret - HMAC secret key (e.g., from env.APP_SECRET)
+ * @param options - Optional expiration
+ * @returns URL string with `signature` (and `expires`) query params appended
+ */
+declare function signUrl(url: string, secret: string, options?: SignedUrlOptions): Promise<string>;
+/**
+ * Verify a signed URL using `crypto.subtle.verify()` (timing-attack-safe).
+ *
+ * @param url - Full URL or path with signature query param
+ * @param secret - HMAC secret key (same key used for signing)
+ * @returns true if signature is valid and not expired
+ */
+declare function verifySignedUrl(url: string, secret: string): Promise<boolean>;
+//#endregion
+//#region src/router/errors/controller-registration.error.d.ts
+/**
+ * Error thrown when a controller fails to register
+ *
+ * This typically happens when:
+ * - Controller is missing the `@Controller` decorator
+ * - Controller route metadata is not set
+ * - Controller class name is invalid
+ *
+ * Error Code: 9005
+ */
+declare class ControllerRegistrationError extends ApplicationError {
+  constructor(controllerName: string, reason?: string);
+}
+//#endregion
+//#region src/router/errors/hono-app-already-configured.error.d.ts
+/**
+ * Error thrown when HonoApp.configure() is called more than once.
+ *
+ * HonoApp can only be configured a single time during application bootstrap.
+ */
+declare class HonoAppAlreadyConfiguredError extends ApplicationError {
+  constructor();
+}
+//#endregion
+//#region src/router/errors/openapi-route-registration.error.d.ts
+/**
+ * OpenAPIRouteRegistrationError
+ *
+ * Thrown when an OpenAPI route fails to register properly
+ * This indicates a configuration issue with route decorators or metadata
+ * Uses i18n key for localized error messages
+ *
+ * @example
+ * ```typescript
+ * throw new OpenAPIRouteRegistrationError('/api/v1/users', 'Missing response schema')
+ * ```
+ */
+declare class OpenAPIRouteRegistrationError extends ApplicationError {
+  constructor(path: string, reason: string);
+}
+//#endregion
+//#region src/router/errors/openapi-validation.error.d.ts
+/**
+ * OpenAPIValidationError
+ *
+ * Thrown when OpenAPI request/response validation fails
+ * Uses i18n key for localized error messages
+ *
+ * HTTP Status: 400 Bad Request
+ * Error Code: 1004
+ *
+ * @example
+ * ```typescript
+ * throw new OpenAPIValidationError('Request body missing required field: email')
+ * ```
+ */
+declare class OpenAPIValidationError extends ApplicationError {
+  constructor(details: string);
+}
+//#endregion
+//#region src/router/errors/route-not-found.error.d.ts
+/**
+ * Error thrown when a requested route is not found
+ *
+ * HTTP Status: 404 Not Found
+ * Error Code: 4004
+ */
+declare class RouteNotFoundError extends ApplicationError {
+  constructor(path: string, method: string);
+}
+//#endregion
+//#region src/router/errors/schema-validation.error.d.ts
+/**
+ * SchemaValidationError
+ *
+ * Thrown when Zod schema validation fails
+ */
+declare class SchemaValidationError extends ApplicationError {
+  constructor(zodError: ZodError);
+}
+//#endregion
+//#region src/router/errors/index.d.ts
+/**
+ * Error thrown when a request's host header does not match the expected domain pattern.
+ *
+ * HTTP Status: 404 Not Found
+ */
+declare class DomainMismatchError extends HttpException {
+  constructor();
+}
+/**
+ * Thrown when registering a named route that conflicts with an existing route name.
+ *
+ * Error Code: 9010
+ */
+declare class DuplicateRouteNameError extends ApplicationError {
+  constructor(name: string, existingHandler: string, newHandler: string);
+}
+/**
+ * Error thrown when a signed URL has an invalid or expired signature.
+ *
+ * HTTP Status: 403 Forbidden
+ */
+declare class InvalidSignatureError extends HttpException {
+  constructor();
+}
+/**
+ * Thrown when a required environment variable is not set.
+ *
+ * Maps to HTTP 500 via error code range (9xxx → 500).
+ */
+declare class MissingEnvironmentVariableError extends ApplicationError {
+  constructor(variable: string);
+}
+/**
+ * Thrown when a required path or domain parameter is missing during URL generation.
+ *
+ * Error Code: 9012
+ */
+declare class MissingRouteParamError extends ApplicationError {
+  constructor(param: string, name: string, path: string);
+}
+/**
+ * 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.
+ */
+declare class ResponseValidationError extends ApplicationError {
+  constructor(zodError: ZodError);
+}
+/**
+ * Thrown when attempting to generate a URL for a route name that doesn't exist in the registry.
+ *
+ * Error Code: 9011
+ */
+declare class RouteNameNotFoundError extends ApplicationError {
+  constructor(name: string);
+}
+/**
+ * Thrown when `router.use()` is called inside a `group()` callback.
+ * `use()` registers global middleware and is only allowed on the root Router.
+ *
+ * Error Code: 9013
+ */
+declare class RouterUseScopeError extends ApplicationError {
+  constructor();
+}
+/**
+ * Thrown when a middleware calls next() more than once.
+ * This is a programming error — each middleware must call next() at most once.
+ *
+ * Error Code: 9014
+ */
+declare class MiddlewareNextCalledMultipleTimesError extends ApplicationError {
+  constructor(middlewareName: string);
+}
+//#endregion
+//#region src/application.d.ts
+interface ApplicationConfig {
+  /** Root application module */
+  module: ModuleClass | DynamicModule;
+  /** Logging configuration. Defaults: level=INFO, formatter='json' */
+  logging?: {
+    level?: LogLevel;
+    formatter?: 'json' | 'pretty';
+  };
+  /**
+   * API versioning configuration.
+   * When provided, enables URI-based versioning for controllers.
+   */
+  versioning?: VersioningOptions;
+  /**
+   * Custom exception handler class.
+   *
+   * Extend {@link ExceptionHandler} and override `register()` to configure
+   * custom reporting, rendering, and post-processing of exceptions.
+   *
+   * When not provided, {@link DefaultExceptionHandler} is used (standard
+   * severity-based logging and JSON error responses).
+   *
+   * @example
+   * ```typescript
+   * new Stratal({
+   *   module: AppModule,
+   *   exceptionHandler: AppExceptionHandler,
+   * })
+   * ```
+   */
+  exceptionHandler?: Constructor<ExceptionHandler>;
+}
+interface ApplicationOptions extends ApplicationConfig {
+  env: StratalEnv;
+  ctx: StratalExecutionContext;
+}
+/**
+ * Application
+ *
+ * Main application class managing the two-tier container hierarchy:
+ * - Global Container: All services (singletons via tsyringe native)
+ * - Request Container: Child of global, context-enriched instances per request
+ *
+ * @example
+ * ```typescript
+ * const app = new Application({ module: AppModule, env, ctx })
+ * await app.initialize()
+ *
+ * // Access container via getter
+ * const service = app.container.resolve(MY_TOKEN)
+ *
+ * // Handle HTTP request (via HonoApp)
+ * // Handle queue batch
+ * await app.handleQueue(batch, 'my-queue')
+ * ```
+ */
+declare class Application {
+  /**
+   * Unified Container - manages all DI operations
+   */
+  private _container;
+  private honoApp;
+  private moduleRegistry;
+  private consumerRegistry;
+  private cronManager;
+  private quarry;
+  private initialized;
+  private routingInitPromise;
+  private handlerInitPromise;
+  readonly env: StratalEnv;
+  private readonly appConfig;
+  constructor({
+    env,
+    ctx,
+    ...config
+  }: ApplicationOptions);
+  /**
+   * Get the Container instance
+   */
+  get container(): Container;
+  /**
+   * Lazily initialize routing and return the HonoApp instance.
+   *
+   * Routing (service registration, HonoApp resolution, route configuration)
+   * is deferred so that `scheduled` and `queue` handlers don't pay the CPU
+   * cost of route setup on cold start.
+   */
+  ensureHono(): Promise<HonoApp>;
+  /**
+   * Get the application configuration
+   */
+  get config(): ApplicationConfig;
+  initialize(): Promise<void>;
+  private initializeInternal;
+  /**
+   * Register routing services as singletons in the container.
+   * Called after module initialization so I18N_TOKENS.Options is available.
+   */
+  private registerRoutingServices;
+  /**
+   * Wire up queue consumers and event listeners.
+   * Called lazily on first fetch/queue — not during scheduled handling.
+   */
+  private initializeHandlers;
+  /**
+   * Register routing services, resolve HonoApp, and configure routes.
+   * Called lazily on first fetch — not during scheduled/queue handling.
+   */
+  private initializeRouting;
+  /**
+   * Resolve a service from the container
+   */
+  resolve<T>(token: symbol): T;
+  /**
+   * Handle queue batch processing
+   */
+  handleQueue(batch: MessageBatch, queueName: string): Promise<void>;
+  /**
+   * Handle scheduled cron trigger
+   */
+  handleScheduled(controller: ScheduledController): Promise<void>;
+  /**
+   * Create mock RouterContext for queue/cron/seeder processing
+   */
+  createMockRouterContext(locale?: string): RouterContext;
+  shutdown(): Promise<void>;
+  /**
+   * Execute a command by name in a request-scoped container.
+   */
+  handleCommand(name: string, input?: CommandInput): Promise<CommandResult>;
+  private registerCommands;
+  private registerSeeders;
+  private registerQueueConsumers;
+  private registerCronJobs;
+  /**
+   * Auto-wire `@Listener()` classes with the EventRegistry.
+   */
+  private registerEventListeners;
+  /**
+   * Register LoggerService and dependencies
+   */
+  private registerLoggerService;
+  /**
+   * Register core services with explicit scope
+   */
+  private registerCoreServices;
+  /**
+   * Initialize the ExceptionHandler: call register(), then module onException hooks.
+   */
+  private initializeExceptionHandler;
+}
+//#endregion
+//#region src/router/services/versioning.service.d.ts
+/**
+ * Resolves version prefixes for route paths.
+ *
+ * Handles VERSION_NEUTRAL, multi-version arrays, default version fallback,
+ * and configurable prefix (default: 'v').
+ *
+ * Registered as a singleton in the container.
+ */
+declare class VersioningService {
+  private readonly options;
+  constructor(app: Application);
+  /** Whether versioning is enabled */
+  get enabled(): boolean;
+  /**
+   * 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: string, version?: string | string[] | typeof VERSION_NEUTRAL): string[];
+}
+//#endregion
+//#region src/router/route-registry.d.ts
+/**
+ * A single registered route in the application.
+ * Tracks both named and unnamed routes, HTTP and WebSocket.
+ */
+interface RegisteredRoute {
+  /** Route name for URL generation (undefined = unnamed, still tracked) */
+  name?: string;
+  /** HTTP method or 'ws' for WebSocket gateways */
+  method: HttpMethod | 'ws';
+  /** Primary path in Hono-style :param format */
+  path: string;
+  /** Locale-prefixed path variants (e.g., '/:locale/users/:id') */
+  localePaths?: string[];
+  /** Parameter names extracted from path */
+  paramNames: string[];
+  /** Domain pattern (e.g., '{tenant}.example.com') */
+  domain?: string;
+  /** Parameter names extracted from domain */
+  domainParamNames: string[];
+  /** Controller class name */
+  controller: string;
+  /** Controller method name */
+  action: string;
+  /** Whether the route is hidden from OpenAPI docs */
+  hidden: boolean;
+  /** Middleware class names applied to this route */
+  middleware: string[];
+  /** Whether this is a locale-prefixed variant */
+  isLocaleVariant?: boolean;
+}
+/**
+ * Input for registering a route. The registry auto-extracts param names
+ * and expands versioned/locale paths via injected services.
+ */
+type RouteRegistrationInput = Omit<RegisteredRoute, 'paramNames' | 'domainParamNames' | 'path' | 'localePaths' | 'isLocaleVariant'> & {
+  /** Base path before versioning/locale expansion */basePath: string; /** Version from controller/router config (used by VersioningService). Accepts VERSION_NEUTRAL symbol. */
+  version?: string | string[] | typeof VERSION_NEUTRAL; /** Pre-computed param names (optional, auto-extracted if omitted) */
+  paramNames?: string[]; /** Pre-computed domain param names (optional, auto-extracted if omitted) */
+  domainParamNames?: string[];
+};
+/**
+ * Central registry for all application routes.
+ * Single source of truth — used by `route:list`, `route:types`, and URL generation.
+ *
+ * Routes are automatically expanded via VersioningService and LocalePathService
+ * during registration, and sorted by specificity when retrieved via `all()`.
+ *
+ * Registered as a singleton in the container.
+ */
+declare class RouteRegistry {
+  private readonly versioningService;
+  private readonly localePathService;
+  private readonly routes;
+  private readonly namedRoutes;
+  private _sortedCache;
+  constructor(versioningService: VersioningService, 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 DuplicateRouteNameError if a named route with the same name already exists
+   */
+  register(input: RouteRegistrationInput): RegisteredRoute[];
+  /** Get a named route by name */
+  get(name: string): RegisteredRoute | undefined;
+  /** Check if a named route exists */
+  has(name: string): boolean;
+  /** Get all routes sorted by specificity (static > param > wildcard, primary before locale) */
+  all(): RegisteredRoute[];
+  /** Get only named routes */
+  named(): RegisteredRoute[];
+}
+//#endregion
+//#region src/router/uri.d.ts
+/**
+ * Options for URL generation methods.
+ */
+interface UriOptions {
+  /** Generate absolute URL (scheme + host). Defaults to false. */
+  absolute?: boolean;
+}
+/**
+ * Options for signed URL generation methods.
+ */
+interface SignedUriOptions extends UriOptions, SignedUrlOptions {}
+/**
+ * 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 MissingRouteParamError if a required path or domain param is missing
+ */
+declare function buildRouteUrl(route: RegisteredRoute, name: string, params?: Record<string, string>): string;
+/**
+ * URL generation service for named routes, signed URLs, and request URL access.
+ *
+ * Registered as request-scoped in the container — has access to the current request
+ * via RouterContext for features like `current()`, `full()`, and signed URLs.
+ *
+ * @example
+ * ```typescript
+ * // In a controller:
+ * const uri = ctx.getContainer().resolve<Uri>(ROUTER_TOKENS.Uri)
+ * uri.route('users.show', { id: '1' })
+ * uri.current()
+ * await uri.signedRoute('unsubscribe', { user: '1' }, { expiresIn: 3600 })
+ *
+ * // Set defaults (e.g., in middleware):
+ * uri.defaults({ locale: 'en' })
+ * uri.route('posts.index') // auto-fills :locale param
+ * ```
+ */
+declare class Uri {
+  private readonly registry;
+  private readonly routerContext;
+  private _defaults;
+  constructor(registry: RouteRegistry, routerContext: RouterContext);
+  /**
+   * 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: Record<string, string>): void;
+  /**
+   * 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 RouteNameNotFoundError if route name not found
+   * @throws MissingRouteParamError if required params missing
+   */
+  route<N extends RouteName>(name: N, params?: RouteParams<N>, options?: UriOptions): string;
+  /**
+   * 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
+   */
+  signedRoute<N extends RouteName>(name: N, params?: RouteParams<N>, options?: SignedUriOptions): Promise<string>;
+  /**
+   * 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
+   */
+  temporarySignedRoute<N extends RouteName>(name: N, expiresIn: number, params?: RouteParams<N>, options?: UriOptions): Promise<string>;
+  /**
+   * Check if the current request has a valid signature.
+   *
+   * @returns true if the URL signature is valid and not expired
+   */
+  hasValidSignature(): Promise<boolean>;
+  /**
+   * Get the current request URL pathname (without query string).
+   */
+  current(): string;
+  /**
+   * Get the current request URL with query string (pathname + search).
+   */
+  full(): string;
+  /**
+   * Get the previous request URL from the Referer header.
+   *
+   * @param fallback - URL to return if no Referer header (default: '/')
+   */
+  previous(fallback?: string): string;
+  /**
+   * 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?: string): string;
+  /**
+   * 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: string, queryParams?: Record<string, string>, options?: UriOptions): string;
+  /**
+   * 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: string, queryParams: Record<string, string>): string;
+  private getAppSecret;
+}
+//#endregion
+//#region src/router/router-context.d.ts
+type ContextQueryResult<R extends Record<string, unknown> | undefined, K extends string | undefined> = K extends string ? string : R extends undefined ? Record<string, unknown> : R;
+/**
+ * Router context wrapper with helper methods
+ *
+ * Provides convenient access to Hono's context and common request/response operations.
+ * The native Hono context is available via the `c` property for advanced use cases.
+ *
+ * @example
+ * ```typescript
+ * async index(ctx: RouterContext): Promise<Response> {
+ *   // Use helper methods
+ *   const users = await this.service.findAll()
+ *   return ctx.json(users)
+ * }
+ *
+ * async show(ctx: RouterContext): Promise<Response> {
+ *   // Access route params
+ *   const id = ctx.param('id')
+ *   const user = await this.service.findById(id)
+ *   return ctx.json(user)
+ * }
+ *
+ * async create(ctx: RouterContext): Promise<Response> {
+ *   // Parse request body
+ *   const body = await ctx.body<CreateUserInput>()
+ *   const user = await this.service.create(body)
+ *   return ctx.json(user, 201)
+ * }
+ * ```
+ */
+declare class RouterContext<T extends RouterEnv = RouterEnv> extends Macroable {
+  readonly c: Context<T>;
+  /**
+   * Native Hono context
+   * Access for advanced use cases not covered by helper methods
+   */
+  constructor(c: Context<T>);
+  /**
+   * Get request-scoped DI container
+   * Contains request-specific services and context (AuthContext)
+   *
+   * @throws Error if container not initialized
+   */
+  getContainer(): Container;
+  /**
+   * Set locale for the current request
+   *
+   * @param locale - Locale code (e.g., 'en', 'fr')
+   */
+  setLocale(locale: string): void;
+  /**
+   * Get locale for the current request
+   *
+   * @returns Current locale code
+   */
+  getLocale(): string;
+  /**
+   * Return JSON response
+   *
+   * When data is null, automatically returns 204 No Content (configurable via status param).
+   *
+   * @param data - Data to serialize as JSON, or null for 204
+   * @param status - HTTP status code (default: 200, or 204 when data is null)
+   */
+  json(data: object | null, status?: ContentfulStatusCode): Response;
+  /**
+   * Get route parameter value
+   *
+   * @param key - Parameter name (e.g., 'id' for /users/:id)
+   */
+  param(key: string): string;
+  /**
+   * Get query parameter value
+   *
+   * @param key - Query parameter name
+   */
+  query<R extends Record<string, unknown> | undefined = undefined, K extends string | undefined = undefined>(key?: K): ContextQueryResult<R, K>;
+  /**
+   * Get request header value
+   *
+   * @param name - Header name (case-insensitive)
+   */
+  header(name: string): string | undefined;
+  /**
+   * Get validated request body from OpenAPI route
+   * Returns pre-validated data that has passed schema validation
+   *
+   * @returns Validated JSON body
+   */
+  body<T>(): Promise<T>;
+  /**
+   * Return text response
+   *
+   * @param text - Text content
+   * @param status - HTTP status code (default: 200)
+   */
+  text(text: string, status?: ContentfulStatusCode): Response;
+  /**
+   * Return HTML response
+   *
+   * @param html - HTML content
+   * @param status - HTTP status code (default: 200)
+   */
+  html(html: string, status?: ContentfulStatusCode): Response;
+  /**
+   * Generate a URL from a named route.
+   *
+   * Keys matching `:param` placeholders fill the path.
+   * Domain params are consumed from the same object.
+   * Extra keys become query string parameters.
+   *
+   * @param name - Named route identifier
+   * @param params - Route params + domain params + extra query params
+   * @param options - URL generation options (e.g., `{ absolute: true }`)
+   *
+   * @example
+   * ```typescript
+   * ctx.route('users.show', { id: '1' })           // '/v1/users/1'
+   * ctx.route('users.show', { id: '1', q: 'test' }) // '/v1/users/1?q=test'
+   * ```
+   */
+  route<N extends RouteName>(name: N, params?: RouteParams<N>, options?: UriOptions): string;
+  /**
+   * Get a domain parameter value from the current request.
+   * Domain params are set by the domain matching middleware.
+   *
+   * @param key - Domain parameter name (e.g., 'tenant' from '{tenant}.myapp.com')
+   *
+   * @example
+   * ```typescript
+   * const tenant = ctx.domain('tenant')
+   * ```
+   */
+  domain(key: string): string;
+  /**
+   * Generate a signed URL from a named route.
+   *
+   * @param name - Named route identifier
+   * @param params - Route params (same as route())
+   * @param options - Signing options (e.g., expiresIn) and URL options
+   * @returns Signed URL string with signature query param
+   */
+  signedUrl<N extends RouteName>(name: N, params?: RouteParams<N>, options?: SignedUriOptions): Promise<string>;
+  /**
+   * Check if the current request has a valid signature.
+   *
+   * @returns true if the URL signature is valid and not expired
+   */
+  hasValidSignature(): Promise<boolean>;
+  /**
+   * Redirect to another URL
+   *
+   * @param url - Target URL
+   * @param status - HTTP status code (default: 302)
+   */
+  redirect(url: string, status?: RedirectStatusCode): Response;
+  /**
+   * Return a streaming response (binary/generic)
+   *
+   * @param callback - Async function that writes to the stream
+   * @param onError - Optional error handler called if an error occurs during streaming
+   */
+  stream(callback: (stream: StreamingApi) => Promise<void>, onError?: (err: Error, stream: StreamingApi) => Promise<void>): Response;
+  /**
+   * Return a streaming text response
+   *
+   * Automatically sets `Content-Encoding: Identity` for Cloudflare Workers compatibility.
+   *
+   * @param callback - Async function that writes text to the stream
+   * @param onError - Optional error handler called if an error occurs during streaming
+   */
+  streamText(callback: (stream: StreamingApi) => Promise<void>, onError?: (err: Error, stream: StreamingApi) => Promise<void>): Response;
+  /**
+   * Return a Server-Sent Events (SSE) streaming response
+   *
+   * Automatically sets `Content-Encoding: Identity` for Cloudflare Workers compatibility.
+   *
+   * @param callback - Async function that writes SSE events to the stream
+   * @param onError - Optional error handler called if an error occurs during streaming
+   */
+  streamSSE(callback: (stream: SSEStreamingApi) => Promise<void>, onError?: (err: Error, stream: SSEStreamingApi) => Promise<void>): Response;
+  private resolveUri;
+}
+//#endregion
+//#region src/errors/exception-context.d.ts
+/**
+ * Exception context for errors occurring during HTTP request handling.
+ *
+ * Provides access to the full {@link RouterContext} for building responses
+ * with `ctx.json()`, `ctx.text()`, `ctx.html()`, etc.
+ */
+interface HttpExceptionContext {
+  readonly type: 'http';
+  /** Stratal RouterContext — use for building HTTP responses */
+  readonly ctx: RouterContext;
+}
+/**
+ * Exception context for errors occurring during queue message processing.
+ */
+interface QueueExceptionContext {
+  readonly type: 'queue';
+  /** Name of the queue being processed */
+  readonly queueName: string;
+}
+/**
+ * Exception context for errors occurring during scheduled cron execution.
+ */
+interface CronExceptionContext {
+  readonly type: 'cron';
+}
+/**
+ * Exception context for errors occurring during CLI command execution.
+ */
+interface CliExceptionContext {
+  readonly type: 'cli';
+  /** Name of the command that threw */
+  readonly commandName: string;
+}
+/**
+ * Discriminated union of all exception context types.
+ *
+ * Narrow via `ctx.type` to access context-specific properties:
+ *
+ * @example
+ * ```typescript
+ * handler.renderable(MyError, (error, ctx) => {
+ *   if (ctx.type === 'http') {
+ *     return ctx.ctx.json({ message: 'Something went wrong' }, 500)
+ *   }
+ *   // Non-HTTP contexts: return undefined to use default rendering
+ * })
+ * ```
+ */
+type ExceptionContext = HttpExceptionContext | QueueExceptionContext | CronExceptionContext | CliExceptionContext;
+/**
+ * Create an HTTP exception context from a Hono context.
+ *
+ * @param c - The raw Hono context from the request
+ * @returns An {@link HttpExceptionContext} wrapping a RouterContext
+ */
+declare function createHttpExceptionContext(c: Context<RouterEnv>): HttpExceptionContext;
+/**
+ * Create a queue exception context.
+ *
+ * @param queueName - The name of the queue being processed
+ * @returns A {@link QueueExceptionContext}
+ */
+declare function createQueueExceptionContext(queueName: string): QueueExceptionContext;
+/**
+ * Create a cron exception context.
+ *
+ * @returns A {@link CronExceptionContext}
+ */
+declare function createCronExceptionContext(): CronExceptionContext;
+/**
+ * Create a CLI command exception context.
+ *
+ * @param commandName - The name of the command that threw
+ * @returns A {@link CliExceptionContext}
+ */
+declare function createCliExceptionContext(commandName: string): CliExceptionContext;
+//#endregion
+//#region src/i18n/errors/locale-not-supported.error.d.ts
+declare class LocaleNotSupportedError extends ApplicationError {
+  constructor(locale: string, supportedLocales: string[]);
+}
+//#endregion
+//#region src/i18n/errors/translation-missing.error.d.ts
+declare class TranslationMissingError extends ApplicationError {
+  constructor(key: string, locale: string);
+}
+//#endregion
+//#region src/i18n/i18n.options.d.ts
+/**
+ * Detection strategy for locale resolution
+ *
+ * - `'cookie'` — reads from the `locale` cookie (default)
+ * - `'header'` — reads from the `Accept-Language` header
+ * - `'querystring'` — reads from the `?locale=` query parameter
+ * - `'path'` — reads from the first URL path segment (e.g., `/en/api/users`)
+ */
+type DetectionStrategy = 'cookie' | 'header' | 'querystring' | 'path';
+interface BaseDetection {
+  /** Set to false to disable language detection entirely. @default true */
+  enabled?: boolean;
+}
+/**
+ * Language detection options (discriminated by strategy)
+ *
+ * @example Cookie detection (default)
+ * ```typescript
+ * { strategy: 'cookie' }
+ * ```
+ *
+ * @example Header detection
+ * ```typescript
+ * { strategy: 'header' }
+ * ```
+ *
+ * @example Path detection
+ * ```typescript
+ * { strategy: 'path' }
+ * ```
+ *
+ * @example Disable detection
+ * ```typescript
+ * { enabled: false }
+ * ```
+ */
+type LanguageDetectionOptions = (BaseDetection & {
+  strategy?: 'cookie';
+  cookieOptions?: DetectorOptions['cookieOptions'];
+}) | (BaseDetection & {
+  strategy: 'header';
+}) | (BaseDetection & {
+  strategy: 'querystring';
+}) | (BaseDetection & {
+  strategy: 'path';
+  /**
+   * Controls whether the default locale gets a URL path prefix.
+   *
+   * - `false` (default) — The default locale has no prefix (`/users`), other locales
+   *   are prefixed (`/fr/users`). Requests to the prefixed default locale (`/en/users`) return 404.
+   * - `'redirect'` — Same as `false`, but requests to the prefixed default locale
+   *   (`/en/users`) are 301-redirected to the unprefixed path (`/users`).
+   * - `true` — All locales are prefixed (`/en/users`, `/fr/users`).
+   *
+   * @default false
+   */
+  prefixDefaultLocale?: false | true | 'redirect';
+}) | {
+  enabled: false;
+};
+/**
+ * Options for configuring the I18n module
+ *
+ * @example
+ * ```typescript
+ * I18nModule.forRoot({
+ *   defaultLocale: 'en',
+ *   fallbackLocale: 'en',
+ *   locales: ['en', 'fr'],
+ *   detection: { strategy: 'header' },
+ * })
+ * ```
+ */
+interface I18nModuleOptions {
+  /**
+   * Default locale for the application
+   * @default 'en'
+   */
+  defaultLocale?: string;
+  /**
+   * Fallback locale when translation is missing
+   * @default 'en'
+   */
+  fallbackLocale?: string;
+  /**
+   * List of supported locales
+   * Request locales not in this list will fall back to defaultLocale
+   */
+  locales?: string[];
+  /**
+   * Language detection configuration
+   * Controls how the locale is extracted from incoming requests
+   */
+  detection?: LanguageDetectionOptions;
+}
+/**
+ * Resolved options with all defaults applied
+ * Used internally by I18n services
+ */
+interface ResolvedI18nOptions {
+  defaultLocale: string;
+  fallbackLocale: string;
+  locales: string[];
+  detection: {
+    enabled: boolean;
+    strategy: DetectionStrategy; /** Resolved value of the path detection `prefixDefaultLocale` option. Only meaningful when `strategy` is `'path'`. */
+    prefixDefaultLocale: false | true | 'redirect';
+  };
+}
+/**
+ * Resolve I18n options with defaults
+ */
+declare function resolveI18nOptions(options?: I18nModuleOptions): ResolvedI18nOptions;
+/**
+ * Build Hono languageDetector options from I18n module options
+ */
+declare function buildDetectorOptions(options?: I18nModuleOptions): Partial<DetectorOptions>;
+//#endregion
+//#region src/i18n/i18n.module.d.ts
+declare class I18nModule implements RouteConfigurable {
+  /**
+   * Configure I18n locale settings
+   *
+   * Call once in the root module. Does not accept messages —
+   * use `registerMessages()` to add translations.
+   *
+   * @param options - Locale configuration (defaultLocale, fallbackLocale, locales)
+   */
+  static forRoot(options?: I18nModuleOptions): DynamicModule;
+  /**
+   * Register i18n messages
+   *
+   * Can be called from any module, as many times as needed.
+   * Messages are deep-merged in registration order — later calls override earlier ones at leaf level.
+   *
+   * @param messages - Messages keyed by locale code
+   *
+   * @example App-level messages
+   * ```typescript
+   * I18nModule.registerMessages({
+   *   en: { common: { hello: 'Hello' }, errors: { notFound: 'Not found' } },
+   *   fr: { common: { hello: 'Bonjour' }, errors: { notFound: 'Introuvable' } },
+   * })
+   * ```
+   *
+   * @example Package-level messages
+   * ```typescript
+   * I18nModule.registerMessages({
+   *   en: { tenancy: { tenantNotFound: 'Tenant not found' } },
+   * })
+   * ```
+   */
+  static registerMessages(messages: Record<string, Record<string, unknown>>): DynamicModule;
+  configureRoutes(router: Router): void;
+}
+//#endregion
+//#region src/i18n/i18n.tokens.d.ts
+/**
+ * I18n Module DI Tokens
+ * Symbol-based tokens to avoid string collisions
+ */
+declare const I18N_TOKENS: {
+  /** MessageLoaderService - loads and caches locale messages */readonly MessageLoader: symbol; /** I18nService - request-scoped translation service */
+  readonly I18nService: symbol; /** I18nModuleOptions - configuration options from forRoot() */
+  readonly Options: symbol; /** MessageRegistry - singleton accumulator for registerMessages() contributions */
+  readonly MessageRegistry: symbol;
+};
+//#endregion
+//#region src/i18n/messages/index.d.ts
+/**
+ * All locale messages
+ * Explicitly import and export (no filesystem scanning - Cloudflare Workers compatible)
+ */
+declare const messages: {
+  readonly en: typeof index_d_exports;
+};
+/**
+ * Type for all messages
+ */
+type Messages = typeof messages;
+/**
+ * Get messages for all locales
+ */
+declare function getMessages(): Record<string, Record<string, unknown>>;
+/**
+ * Get available locales
+ */
+declare function getLocales(): string[];
+//#endregion
+//#region src/i18n/services/message-registry.d.ts
+/**
+ * Message Registry
+ *
+ * Accumulates i18n messages from multiple `I18nModule.registerMessages()` calls.
+ * Messages are collected statically (at module import time) and deep-merged
+ * when `getMergedMessages()` is called by `MessageLoaderService`.
+ *
+ * Later registrations override earlier ones at leaf level.
+ */
+declare class MessageRegistry {
+  /**
+   * Add messages (called statically by I18nModule.registerMessages)
+   */
+  static addMessages(messages: Record<string, Record<string, unknown>>): void;
+  /**
+   * Get all messages deep-merged in registration order
+   */
+  getMergedMessages(): Record<string, Record<string, unknown>>;
+  /**
+   * Reset registry (for testing)
+   * @internal
+   */
+  static reset(): void;
+}
+//#endregion
+//#region src/i18n/services/message-loader.service.d.ts
+declare class MessageLoaderService {
+  private readonly registry;
+  private readonly options?;
+  private readonly cache;
+  private readonly contextCache;
+  private readonly locales;
+  private readonly defaultLocale;
+  constructor(registry: MessageRegistry, options?: I18nModuleOptions | undefined);
+  /**
+   * Get CoreContext for a locale (lazily built and cached on first access)
+   * Falls back to default locale if locale not found
+   */
+  getCoreContext(locale: string): CoreContext;
+  /**
+   * Get messages for a specific locale.
+   * Falls back to default locale if not found.
+   */
+  getMessages(locale: string): Record<string, unknown>;
+  /** Get list of available locale codes */
+  getAvailableLocales(): string[];
+  /** Check if a locale is supported */
+  isLocaleSupported(locale: string): boolean;
+  /** Get default locale */
+  getDefaultLocale(): string;
+  /**
+   * Get flattened (dot-notation) messages for a locale, optionally filtered by namespace prefixes.
+   *
+   * Returns flat key-value pairs matching the format used by `@intlify/core-base`'s
+   * `createCoreContext`. Requires `registerMessageCompiler(compile)` to be called
+   * before `translate()` can resolve these flat keys.
+   *
+   * @param locale - Locale code (falls back to default locale if not found)
+   * @param options - Optional filter configuration
+   * @param options.only - Dot-notation prefixes to include (e.g., `['common', 'nav.sidebar']`)
+   * @returns Flattened messages as `{ 'key.path': 'translated value' }`
+   *
+   * @example
+   * ```typescript
+   * // All messages for the locale
+   * loader.getFilteredMessages('en')
+   *
+   * // Only 'common' and 'nav' namespaces
+   * loader.getFilteredMessages('en', { only: ['common', 'nav'] })
+   *
+   * // Deeply nested prefix
+   * loader.getFilteredMessages('en', { only: ['common.actions'] })
+   * ```
+   */
+  getFilteredMessages(locale: string, options?: {
+    only?: MessageKeyPrefix[];
+  }): Record<string, string>;
+  /**
+   * Flatten nested messages to dot-notation.
+   * e.g. `{ a: { b: 'hello' } }` → `{ 'a.b': 'hello' }`
+   */
+  private flattenMessages;
+}
+//#endregion
+//#region src/i18n/services/i18n.service.d.ts
+/**
+ * I18n Service
+ *
+ * Provides internationalization (i18n) support for the application.
+ * Injects RouterContext to access request-specific locale.
+ *
+ * @example Usage in services
+ * ```typescript
+ * @Transient(MY_TOKENS.UserService)
+ * export class UserService {
+ *   constructor(
+ *     @inject(I18N_TOKENS.I18nService) private readonly i18n: II18nService
+ *   ) {}
+ *
+ *   getWelcomeMessage(): string {
+ *     return this.i18n.t('common.welcome')
+ *   }
+ * }
+ * ```
+ */
+declare class I18nService implements II18nService {
+  private readonly loader;
+  private readonly routerContext?;
+  constructor(loader: MessageLoaderService, routerContext?: RouterContext | undefined);
+  /**
+   * Translate a message key
+   *
+   * @param key - Message key (e.g., 'common.actions.save')
+   * @param params - Optional parameters for interpolation
+   * @returns Translated string
+   */
+  t(key: MessageKeys, params?: MessageParams): string;
+  /**
+   * Get current locale
+   *
+   * @returns Current locale code from RouterContext or default locale
+   */
+  getLocale(): string;
+}
+//#endregion
+//#region src/i18n/middleware/i18n-context.middleware.d.ts
+declare class I18nContextMiddleware implements Middleware {
+  private readonly i18n;
+  constructor(i18n: I18nService);
+  handle(ctx: RouterContext, next: Next$1): Promise<void>;
+}
+//#endregion
+//#region src/errors/error-codes.d.ts
+/**
+ * Centralized Error Code Registry
+ *
+ * Error codes are organized by category with specific ranges:
+ * - 1000-1999: Validation errors
+ * - 2000-2999: Database errors (generic)
+ * - 3000-3999: Authentication & Authorization
+ * - 4000-4999: Resource errors
+ * - 5000-5999: Domain-specific business logic (per module)
+ * - 9000-9999: System/Internal errors
+ *   - 9000-9099: Router errors
+ *   - 9100-9199: Configuration errors
+ *   - 9200-9299: Infrastructure errors
+ *   - 9300-9399: I18n errors
+ */
+declare const ERROR_CODES: {
+  /**
+   * Database Errors (2000-2999)
+   * Generic database errors thrown by Prisma client extensions
+   */
+  readonly DATABASE: {
+    /** Generic database error */readonly GENERIC: 2000; /** Record not found in database */
+    readonly RECORD_NOT_FOUND: 2001; /** Unique constraint violation */
+    readonly UNIQUE_CONSTRAINT: 2002; /** Foreign key constraint violation */
+    readonly FOREIGN_KEY_CONSTRAINT: 2003; /** Database connection failed */
+    readonly CONNECTION_FAILED: 2004; /** Database timeout */
+    readonly TIMEOUT: 2005; /** Null constraint violation */
+    readonly NULL_CONSTRAINT: 2006; /** Too many database connections */
+    readonly TOO_MANY_CONNECTIONS: 2007; /** Transaction conflict or deadlock */
+    readonly TRANSACTION_CONFLICT: 2008;
+  };
+  /**
+   * Authentication Errors (3000-3099)
+   * Authentication-related failures
+   */
+  readonly AUTH: {
+    /** Invalid credentials provided */readonly INVALID_CREDENTIALS: 3000; /** Session expired or invalid */
+    readonly SESSION_EXPIRED: 3001; /** Account locked or disabled */
+    readonly ACCOUNT_LOCKED: 3002; /** Invalid or expired token */
+    readonly INVALID_TOKEN: 3003; /** Context not initialized */
+    readonly CONTEXT_NOT_INITIALIZED: 3004; /** User not authenticated */
+    readonly USER_NOT_AUTHENTICATED: 3005; /** Email verification required before login */
+    readonly EMAIL_NOT_VERIFIED: 3007; /** Password doesn't meet minimum length */
+    readonly PASSWORD_TOO_SHORT: 3008; /** Password exceeds maximum length */
+    readonly PASSWORD_TOO_LONG: 3009; /** Account with email already exists */
+    readonly ACCOUNT_ALREADY_EXISTS: 3010; /** User creation failed */
+    readonly FAILED_TO_CREATE_USER: 3011; /** Session creation failed */
+    readonly FAILED_TO_CREATE_SESSION: 3012; /** User update failed */
+    readonly FAILED_TO_UPDATE_USER: 3013; /** Social account already linked */
+    readonly SOCIAL_ACCOUNT_LINKED: 3014; /** Last account cannot be unlinked */
+    readonly CANNOT_UNLINK_LAST_ACCOUNT: 3015; /** Organization not found */
+    readonly ORGANIZATION_NOT_FOUND: 3020; /** Organization member not found */
+    readonly MEMBER_NOT_FOUND: 3021; /** Organization invitation not found */
+    readonly INVITATION_NOT_FOUND: 3022; /** Invitation recipient mismatch */
+    readonly INVITATION_RECIPIENT_MISMATCH: 3023; /** Organization limit reached */
+    readonly ORGANIZATION_LIMIT_REACHED: 3024; /** Organization membership constraint violation */
+    readonly ORGANIZATION_MEMBERSHIP_REQUIRED: 3025;
+  };
+  /**
+   * Authorization Errors (3100-3199)
+   * Permission and access control failures
+   */
+  readonly AUTHZ: {
+    /** Insufficient permissions */readonly FORBIDDEN: 3100; /** Resource access denied */
+    readonly ACCESS_DENIED: 3101; /** User lacks required role */
+    readonly INSUFFICIENT_PERMISSIONS: 3102;
+  };
+  /**
+   * Resource Errors (4000-4999)
+   * Generic resource-related errors
+   */
+  readonly RESOURCE: {
+    /** Generic resource not found */readonly NOT_FOUND: 4000; /** Route/endpoint not found */
+    readonly ROUTE_NOT_FOUND: 4004; /** Resource conflict or duplicate */
+    readonly CONFLICT: 4100; /** Resource already exists */
+    readonly ALREADY_EXISTS: 4101;
+  };
+  /**
+   * Validation Errors (1000-1999)
+   * Input validation failures
+   */
+  readonly VALIDATION: {
+    /** Generic validation error */readonly GENERIC: 1000; /** Required field missing */
+    readonly REQUIRED_FIELD: 1001; /** Invalid format */
+    readonly INVALID_FORMAT: 1002; /** Schema validation failed */
+    readonly SCHEMA_VALIDATION: 1003; /** Request validation failed (OpenAPI, etc.) */
+    readonly REQUEST_VALIDATION: 1004; /** Response validation failed (response body doesn't match declared schema) */
+    readonly RESPONSE_VALIDATION: 1005;
+  };
+  /**
+   * Router Errors (9000-9099)
+   * Router and controller-related INTERNAL errors
+   */
+  readonly ROUTER: {
+    /** Controller registration error */readonly CONTROLLER_REGISTRATION_ERROR: 9005; /** Controller method not found */
+    readonly CONTROLLER_METHOD_NOT_FOUND: 9006; /** OpenAPI route registration failed */
+    readonly OPENAPI_ROUTE_REGISTRATION: 9008; /** Duplicate route name in RouteRegistry */
+    readonly DUPLICATE_ROUTE_NAME: 9010; /** Named route not found in RouteRegistry */
+    readonly ROUTE_NAME_NOT_FOUND: 9011; /** Required route parameter missing during URL generation */
+    readonly MISSING_ROUTE_PARAM: 9012; /** router.use() called inside group() callback */
+    readonly USE_SCOPE_VIOLATION: 9013; /** next() called more than once in a middleware */
+    readonly MIDDLEWARE_NEXT_CALLED_MULTIPLE_TIMES: 9014;
+  };
+  /**
+   * I18n Errors (9300-9399)
+   * Internationalization and localization errors
+   */
+  readonly I18N: {
+    /** Translation key missing from all locales */readonly TRANSLATION_MISSING: 9300; /** Requested locale not supported */
+    readonly LOCALE_NOT_SUPPORTED: 9301;
+  };
+  /**
+   * System Errors (9000-9999)
+   * Internal system errors and unexpected failures
+   */
+  readonly SYSTEM: {
+    /** Internal server error */readonly INTERNAL_ERROR: 9000; /** Generic configuration error */
+    readonly CONFIGURATION_ERROR: 9100; /** ConfigService not initialized */
+    readonly CONFIG_NOT_INITIALIZED: 9101; /** Module already registered */
+    readonly MODULE_ALREADY_REGISTERED: 9102; /** Circular module dependency detected */
+    readonly MODULE_CIRCULAR_DEPENDENCY: 9103; /** Module dependency not found */
+    readonly MODULE_DEPENDENCY_NOT_FOUND: 9104; /** Invalid error code range */
+    readonly INVALID_ERROR_CODE_RANGE: 9105; /** Invalid module provider configuration */
+    readonly INVALID_MODULE_PROVIDER: 9106; /** ConfigModule.forRoot() was not called */
+    readonly CONFIG_MODULE_NOT_INITIALIZED: 9107; /** Generic infrastructure error */
+    readonly INFRASTRUCTURE_ERROR: 9200; /** Execution context not initialized */
+    readonly EXECUTION_CONTEXT_NOT_INITIALIZED: 9201; /** Request container not initialized */
+    readonly REQUEST_CONTAINER_NOT_INITIALIZED: 9202; /** Queue binding not found */
+    readonly QUEUE_BINDING_NOT_FOUND: 9203; /** Cron job execution failed */
+    readonly CRON_EXECUTION_FAILED: 9204; /** Queue provider not supported */
+    readonly QUEUE_PROVIDER_NOT_SUPPORTED: 9205; /** body() called on WebSocket gateway context */
+    readonly WEBSOCKET_BODY_NOT_AVAILABLE: 9206; /** Duplicate WebSocket event decorator on a gateway */
+    readonly WEBSOCKET_DUPLICATE_EVENT_HANDLER: 9207; /** Seeder name collision — two seeders share the same class name */
+    readonly SEEDER_NAME_COLLISION: 9208; /** Seeder not registered in the SeederRegistry */
+    readonly SEEDER_NOT_REGISTERED: 9209; /** Application container not initialized (AsyncLocalStorage) */
+    readonly CONTAINER_NOT_INITIALIZED: 9210; /** Required environment variable not set */
+    readonly MISSING_ENVIRONMENT_VARIABLE: 9211;
+  };
+};
+/**
+ * Recursively extract all leaf values from a nested object type
+ * Similar to DeepKeys but extracts values instead of keys
+ *
+ * Example:
+ *   { DATABASE: { GENERIC: 2000, NOT_FOUND: 2001 }, AUTH: { INVALID: 3000 } }
+ *   becomes
+ *   2000 | 2001 | 3000
+ */
+type DeepValues<T> = T extends object ? { [K in keyof T]: DeepValues<T[K]> }[keyof T] : T;
+/**
+ * Type helper to extract all error code values
+ * Union type of all numeric error codes defined in ERROR_CODES
+ *
+ * Type: 2000 | 2001 | 2002 | ... | 9203
+ */
+type ErrorCode = DeepValues<typeof ERROR_CODES>;
+//#endregion
+//#region src/errors/application-error.d.ts
+/**
+ * ApplicationError
+ *
+ * Abstract base class for all application errors.
+ *
+ * @deprecated Use {@link HttpException} for new error classes. `HttpException` provides
+ * a simpler constructor that takes `(httpStatus, message?)` and derives the error code
+ * automatically. Existing subclasses will continue to work but should be migrated over time.
+ *
+ * Features:
+ * - Type-safe error codes from ERROR_CODES registry
+ * - Type-safe message keys from i18n module
+ * - Localized message keys (translated by ExceptionHandler)
+ * - Structured metadata for logging and interpolation
+ * - Proper Error prototype chain
+ * - Automatic timestamp generation
+ * - Serialization for RPC transmission
+ * - Optional self-reporting via `report()` method
+ * - Optional self-rendering via `render()` method
+ *
+ * Message Localization:
+ * - Each error class passes an i18n key (e.g., 'errors.userNotFound') to super()
+ * - `Error.message` contains the i18n key for useful stack traces and fallback display
+ * - Metadata provides interpolation parameters (e.g., { userId: '123' })
+ * - ExceptionHandler translates the message key using I18nService before sending response
+ * - This ensures errors are localized based on the user's locale
+ */
+declare abstract class ApplicationError extends Error {
+  /**
+   * Controls whether stack traces are captured.
+   * Set to false in production to skip the expensive Error.captureStackTrace() call,
+   * since stack traces are stripped from responses in production anyway.
+   */
+  static captureStackTraces: boolean;
+  /**
+   * Type-safe error code from ERROR_CODES registry
+   * See error-codes.ts for the complete registry
+   */
+  readonly code: ErrorCode;
+  /**
+   * ISO timestamp when the error was created
+   */
+  readonly timestamp: string;
+  /**
+   * Additional structured data about the error
+   * Used for:
+   * 1. Logging and debugging
+   * 2. Message interpolation (e.g., { userId: '123', email: 'user@example.com' })
+   */
+  readonly metadata?: Record<string, unknown>;
+  /**
+   * @param i18nKey - Type-safe i18n message key (e.g., 'errors.userNotFound')
+   * @param code - Type-safe error code from ERROR_CODES registry
+   * @param metadata - Optional data for logging and interpolation
+   */
+  constructor(i18nKey: MessageKeys, code: ErrorCode, metadata?: Record<string, unknown>);
+  /**
+   * Filter metadata to include only user-facing properties
+   *
+   * User-facing properties (validation/constraint errors):
+   * - issues: Validation errors from SchemaValidationError
+   * - fields: Constraint violation fields
+   * - field: Single field constraint/foreign key
+   *
+   * Internal properties (excluded from response):
+   * - path, method: Route debugging
+   * - controllerName, reason: Controller errors
+   * - details, etc.: Internal debugging info
+   *
+   * @param metadata - Raw metadata object
+   * @returns Filtered metadata with only whitelisted properties
+   */
+  private static filterMetadata;
+  /**
+   * Serialize error to ErrorResponse format for RPC transmission
+   *
+   * @param env - Environment (development | production)
+   * @param translatedMessage - Optional translated message (from ExceptionHandler)
+   * @returns ErrorResponse object suitable for JSON serialization
+   */
+  toErrorResponse(env: Environment, translatedMessage?: string): ErrorResponse;
+  /**
+   * JSON serialization (used by JSON.stringify)
+   * Defaults to development mode for backward compatibility
+   * Note: This will use the untranslated message key - use ExceptionHandler for proper localization
+   */
+  toJSON(): ErrorResponse;
+  /**
+   * Self-reporting hook. Override in subclasses to define custom reporting logic
+   * that runs instead of the default logger.
+   *
+   * - Return `void` (or nothing) to **skip** default reporting after this runs.
+   * - Return `false` to **also run** default reporting after this runs.
+   *
+   * @example
+   * ```typescript
+   * class PaymentError extends HttpException {
+   *   report(): void {
+   *     sentry.captureException(this)
+   *     // Default logging is skipped
+   *   }
+   * }
+   *
+   * class SoftError extends HttpException {
+   *   report(): false {
+   *     analytics.track(this)
+   *     return false // Default logging also runs
+   *   }
+   * }
+   * ```
+   */
+  report?(): void | false;
+  /**
+   * Self-rendering hook. Override in subclasses to define how this error
+   * is rendered into a Response.
+   *
+   * Return `undefined` to fall through to the default renderer.
+   *
+   * @param ctx - The execution context (narrow via `ctx.type` for HTTP helpers)
+   * @returns A Response, ErrorResponse, or undefined to use default rendering
+   *
+   * @example
+   * ```typescript
+   * class MaintenanceError extends HttpException {
+   *   render(ctx: ExceptionContext): Response | undefined {
+   *     if (ctx.type === 'http') {
+   *       return ctx.ctx.html('<h1>Down for maintenance</h1>', 503)
+   *     }
+   *   }
+   * }
+   * ```
+   */
+  render?(ctx: ExceptionContext): Response | ErrorResponse | undefined;
+}
+//#endregion
+//#region src/errors/default-exception-handler.d.ts
+/**
+ * DefaultExceptionHandler — the built-in exception handler used when no
+ * custom handler is provided via `ApplicationConfig.exceptionHandler`.
+ *
+ * Has an empty `register()` method, so all exceptions flow through the
+ * default pipeline: severity-based logging, i18n translation, and JSON
+ * error response serialization.
+ *
+ * To customize exception handling, extend {@link ExceptionHandler} and
+ * override `register()`, then pass your class to the Stratal config:
+ *
+ * @example
+ * ```typescript
+ * new Stratal({
+ *   module: AppModule,
+ *   exceptionHandler: AppExceptionHandler,
+ * })
+ * ```
+ */
+declare class DefaultExceptionHandler extends ExceptionHandler {
+  register(): void;
+}
+//#endregion
+//#region src/errors/get-http-status.d.ts
+/**
+ * Maps error codes to HTTP status codes
+ *
+ * This utility is used by the frontend to set appropriate HTTP status codes
+ * when returning errors from API routes.
+ *
+ * @param code - Numeric error code from ERROR_CODES registry
+ * @returns HTTP status code (200-599)
+ */
+declare function getHttpStatus(code: number): ContentfulStatusCode;
+/**
+ * Resolve the HTTP status code for an ApplicationError.
+ *
+ * If the error is an {@link HttpException}, its `httpStatus` property takes precedence.
+ * Otherwise, falls back to the code-range-based mapping via {@link getHttpStatus}.
+ *
+ * @param error - The application error to resolve the status for
+ * @returns HTTP status code
+ */
+declare function resolveHttpStatus(error: ApplicationError): ContentfulStatusCode;
+//#endregion
+//#region src/errors/http-exception.d.ts
+/**
+ * HTTP-centric exception base class.
+ *
+ * Unlike {@link ApplicationError} which requires `(i18nKey, code, metadata)`,
+ * `HttpException` takes just `(httpStatus, message?)` and derives the error code
+ * from the HTTP status automatically.
+ *
+ * The message can be a plain string or an i18n key — the {@link ExceptionHandler}
+ * tries to translate it via `i18n.t()`, falling back to the raw string if the
+ * key is not found.
+ *
+ * Existing {@link ApplicationError} subclasses can be migrated to this gradually.
+ *
+ * @example
+ * ```typescript
+ * // Simple usage with plain message
+ * throw new HttpException(404, 'User not found')
+ *
+ * // With i18n key (auto-translated if key exists)
+ * throw new HttpException(422, 'errors.invalidInput')
+ *
+ * // Default message for status code
+ * throw new HttpException(500)
+ *
+ * // Subclass for domain-specific errors
+ * class PaymentDeclinedError extends HttpException {
+ *   constructor() {
+ *     super(402, 'errors.paymentDeclined')
+ *   }
+ * }
+ * ```
+ */
+declare class HttpException extends ApplicationError {
+  /**
+   * The HTTP status code for this exception.
+   * Used by the {@link ExceptionHandler} to set the response status.
+   */
+  readonly httpStatus: ContentfulStatusCode;
+  /**
+   * @param httpStatus - HTTP status code (e.g., 404, 422, 500)
+   * @param message - Optional message string or i18n key. Defaults to the
+   *   standard HTTP status message (e.g., "Not Found" for 404).
+   */
+  constructor(httpStatus: ContentfulStatusCode, message?: string);
+}
+/**
+ * Throw an HTTP exception from anywhere in the application.
+ *
+ * The message can be a plain string or an i18n key — the {@link ExceptionHandler}
+ * translates it automatically, falling back to the raw string if the key is not found.
+ *
+ * @param status - HTTP status code
+ * @param message - Optional message (plain string or i18n key)
+ * @throws {@link HttpException} — always throws, never returns
+ *
+ * @example
+ * ```typescript
+ * // With plain message
+ * abort(404, 'User not found')
+ *
+ * // Default message for status
+ * abort(403)
+ *
+ * // With i18n key
+ * abort(422, 'errors.invalidInput')
+ * ```
+ */
+declare function abort(status: ContentfulStatusCode, message?: MessageKeys | string & {}): never;
+//#endregion
+//#region src/errors/internal-error.d.ts
+/**
+ * InternalError
+ *
+ * Represents an unexpected internal server error.
+ * Used to wrap unknown errors that don't fit into specific error categories.
+ *
+ * This error is thrown when:
+ * - An unexpected exception occurs
+ * - An error type is not recognized
+ * - A system-level failure happens
+ */
+declare class InternalError extends ApplicationError {
+  constructor(metadata?: Record<string, unknown>);
+}
+//#endregion
+//#region src/errors/is-application-error.d.ts
+/**
+ * Type guard to check if an error is an ApplicationError.
+ *
+ * Uses `instanceof` first, then falls back to a structural check
+ * for the `code` and `timestamp` properties that all ApplicationError
+ * instances have. This handles cross-module boundary cases where
+ * `instanceof` fails due to duplicate class identities (e.g., Vite's
+ * module graph in workerd).
+ *
+ * @param error - The error to check
+ * @returns True if the error is an ApplicationError instance
+ */
+declare function isApplicationError(error: unknown): error is ApplicationError;
+//#endregion
+//#region src/errors/container-not-initialized.error.d.ts
+/**
+ * Thrown when attempting to access the application container via AsyncLocalStorage
+ * before `Application.initialize()` has been called.
+ *
+ * This typically means `route()` or another standalone function is being called
+ * outside the application lifecycle.
+ */
+declare class ContainerNotInitializedError extends ApplicationError {
+  constructor();
+}
+//#endregion
+//#region src/errors/request-container-not-initialized.error.d.ts
+/**
+ * RequestContainerNotInitializedError
+ *
+ * Thrown when attempting to access the request-scoped container before it has been initialized.
+ * This typically indicates that the RouterService middleware hasn't run yet,
+ * or the router context is being accessed outside of a request lifecycle.
+ */
+declare class RequestContainerNotInitializedError extends ApplicationError {
+  constructor();
+}
+//#endregion
+//#region src/errors/stratal-not-initialized.error.d.ts
+/**
+ * StratalNotInitializedError
+ *
+ * Thrown when attempting to resolve the Application instance before Stratal has been instantiated.
+ * This typically indicates that the Stratal instance is not exported as the default export.
+ */
+declare class StratalNotInitializedError extends ApplicationError {
+  constructor();
+}
+//#endregion
+export { SSEMessage as $, VersioningOptions as $n, ModuleRegistry as $t, LocaleNotSupportedError as A, ContextCallback as An, instancePerContainerCachingFactory$1 as Ar, Route as At, ContextQueryResult as B, ControllerOptions as Bn, WhenOptions as Br, getControllerOptions as Bt, DetectionStrategy as C, OnInitialize as Cn, Container as Cr, commonErrorSchemas as Ct, buildDetectorOptions as D, ValueProvider as Dn, delay as Dr, successMessageSchema as Dt, ResolvedI18nOptions as E, RegistryEntry as En, container$1 as Er, paginationQuerySchema as Et, QueueExceptionContext as F, RespondCallback as Fn, ConditionalBindingUse as Fr, Get as Ft, buildRouteUrl as G, RouteBodyObject as Gn, extractParamNames as Gt, SignedUriOptions as H, ExplicitRouteMetadata as Hn, ErrorResponse as Hr, getControllerVersion as Ht, createCliExceptionContext as I, StratalExecutionContext as In, PredicateContainer as Ir, Patch as It, RouteRegistry as J, RouteResponse as Jn, sortRoutesBySpecificity as Jt, RegisteredRoute as K, RouteConfig as Kn, generateConventionRouteName as Kt, createCronExceptionContext as L, LocalePathService as Ln, ContainerLike as Lr, Post as Lt, CronExceptionContext as M, RenderableCallback as Mn, ConditionalBindingBuilder as Mr, getRouteMetadata as Mt, ExceptionContext as N, Reportable as Nn, ConditionalBindingBuilderImpl as Nr, All as Nt, resolveI18nOptions as O, ExceptionHandler as On, inject$1 as Or, uuidParamSchema as Ot, HttpExceptionContext as P, ReportableCallback as Pn, ConditionalBindingGive as Pr, Delete as Pt, ApplicationOptions as Q, SecurityScheme as Qn, RouteRegistrationService as Qt, createHttpExceptionContext as R, ResolvedPath as Rn, ExtensionDecorator as Rr, Put as Rt, I18nModule as S, OnException as Sn, StratalRouteMap as Sr, parseDomainPattern as St, LanguageDetectionOptions as T, Provider as Tn, DependencyContainer$1 as Tr, paginatedResponseSchema as Tt, Uri as U, LocalePathConfig as Un, isErrorResponse as Ur, createMiddlewareChain as Ut, RouterContext as V, ConventionRouteMetadata as Vn, Environment as Vr, getControllerRoute as Vt, UriOptions as W, RouteBody as Wn, extractDomainParamNames as Wt, Application as X, RouterEnv as Xn, route as Xt, VersioningService as Y, RouteResponseObject as Yn, toOpenAPIPath as Yt, ApplicationConfig as Z, RouterVariables as Zn, ROUTER_TOKENS as Zt, Messages as _, FactoryProvider as _n, DI_TOKENS as _r, SignedUrlOptions as _t, InternalError as a, IController as an, containerStorage as ar, MiddlewareNextCalledMultipleTimesError as at, messages as b, ModuleContext as bn, SerializedRoute as br, VerifySignatureMiddleware as bt, getHttpStatus as c, CommandResult as cn, RequestScopeOperationNotAllowedError as cr, ResponseValidationError as ct, ApplicationError as d, ParsedSignature as dn, INJECT_PARAM_METADATA_KEY as dr, SchemaValidationError as dt, RouteConfigurable as en, HTTP_METHODS as er, SSEStreamingApi$1 as et, ERROR_CODES as f, Quarry as fn, InjectParam as fr, RouteNotFoundError as ft, MessageRegistry as g, ExistingProvider as gn, DIToken as gr, ControllerRegistrationError as gt, MessageLoaderService as h, DynamicModule as hn, CONTAINER_TOKEN as hr, HonoAppAlreadyConfiguredError as ht, isApplicationError as i, Next$1 as in, VERSION_NEUTRAL as ir, InvalidSignatureError as it, CliExceptionContext as j, LogSeverity as jn, singleton as jr, getRouteDecoratedMethods as jt, TranslationMissingError as k, ApplicationErrorConstructor as kn, injectable$1 as kr, validationErrorResponseSchema as kt, resolveHttpStatus as l, ParsedArgument as ln, ConditionalBindingFallbackError as lr, RouteNameNotFoundError as lt, I18nContextMiddleware as m, ClassProvider as mn, getMethodInjections as mr, OpenAPIRouteRegistrationError as mt, RequestContainerNotInitializedError as n, RouterGroupConfig as nn, ROUTE_METADATA_KEYS as nr, DomainMismatchError as nt, HttpException as o, CommandInput as on, getContainer as or, MissingEnvironmentVariableError as ot, ErrorCode as p, AsyncModuleOptions as pn, ParamInjection as pr, OpenAPIValidationError as pt, RouteRegistrationInput as q, RouteMetadata as qn, getPathSpecificityScore as qt, ContainerNotInitializedError as r, Middleware as rn, SECURITY_SCHEMES as rr, DuplicateRouteNameError as rt, abort as s, CommandInternals as sn, runWithContainer as sr, MissingRouteParamError as st, StratalNotInitializedError as t, Router as tn, ROUTER_CONTEXT_KEYS as tr, StreamingApi$1 as tt, DefaultExceptionHandler as u, ParsedOption as un, Transient as ur, RouterUseScopeError as ut, getLocales as v, InjectionToken$2 as vn, RouteName as vr, signUrl as vt, I18nModuleOptions as w, OnShutdown as wn, ContainerOptions as wr, errorResponseSchema as wt, I18N_TOKENS as x, ModuleOptions as xn, SerializedRoutes as xr, createDomainMiddleware as xt, getMessages as y, ModuleClass as yn, RouteParams as yr, verifySignedUrl as yt, createQueueExceptionContext as z, HonoApp as zn, Scope as zr, Controller as zt };
+//# sourceMappingURL=index-DPFqRs8L.d.mts.map