stratal 0.0.21 → 0.0.23

package/dist/{index-ByOyTmqf.d.mts → index-B_JoEl3V.d.mts}

@@ -1,269 +1,49 @@
-import { t as Constructor } from "./types-cySNS_lp.mjs";
-import { t as Macroable } from "./index-7-hU3GTV.mjs";
-import { t as StratalEnv } from "./env-D1rcZ8_r.mjs";
-import { t as index_d_exports } from "./index-C1KvMncZ.mjs";
-import { C as MessageParams, S as MessageKeys, a as index_d_exports$1, b as II18nService, i as ZodError, o as z, t as OpenAPIHono, x as MessageKeyPrefix } from "./index-Bnpfq6uk.mjs";
-import { i as LoggerService, l as LogLevel } from "./index-DBd_2wv8.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 { t as Macroable } from "./index-0ItCjaqw.mjs";
+import { t as StratalEnv } from "./env-ug22bJj7.mjs";
+import { a as z, i as ZodError, o as zod_d_exports, t as OpenAPIHono } from "./zod-wecrEVAs.mjs";
+import { c as LogLevel, r as LoggerService } from "./index-BUt92sAE.mjs";
+import { t as Constructor } from "./types-CmV_9xBD.mjs";
 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 { Context, MiddlewareHandler, Next } from "hono";
+import { CookieOptions } from "hono/utils/cookie";
 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>;
+//#region src/errors/application-error.d.ts
+declare class ApplicationError extends Error {
+  readonly timestamp: string;
+  constructor(message?: string, cause?: unknown);
 }
 //#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;
-}
+//#region src/di/tokens.d.ts
 /**
- * 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)
- * })
- * ```
+ * Token for the Container instance
+ * Used for injecting the Container into services that need dynamic resolution
  */
-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;
+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 LazyModuleLoader: symbol;
+  readonly ExceptionHandler: symbol;
+  readonly Database: symbol;
+  readonly Queue: symbol;
+  readonly ConsumerRegistry: symbol;
+  readonly Cron: symbol;
+  readonly EventRegistry: symbol;
+  readonly Quarry: symbol;
   /**
-   * Get underlying tsyringe container
+   * AuthContext: Use for services that need user authentication (userId).
    */
-  getTsyringeContainer(): DependencyContainer;
-  dispose(): void | Promise<void>;
-}
+  readonly AuthContext: symbol;
+  readonly DurableObjectState: symbol;
+  readonly DurableObjectId: symbol;
+};
+type DIToken = typeof DI_TOKENS[keyof typeof DI_TOKENS];
 //#endregion
 //#region src/router/route-map.d.ts
 /**
@@ -358,228 +138,44 @@ type RouteMatcher = keyof StratalRouteMap extends never ? string : RouteName | `
  */
 type RoutePrefixes<S extends string> = S extends `${infer Head}.${infer Rest}` ? Head | `${Head}.${RoutePrefixes<Rest>}` : never;
 //#endregion
-//#region src/di/tokens.d.ts
+//#region src/router/constants.d.ts
 /**
- * Token for the Container instance
- * Used for injecting the Container into services that need dynamic resolution
+ * Type-safe context keys for Hono router variables
+ * Using symbols to avoid string collisions
  */
-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;
+declare const ROUTER_CONTEXT_KEYS: {
+  readonly REQUEST_CONTAINER: "requestContainer";
+  readonly LOCALE: "locale";
 };
-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
+ * Metadata keys for storing route and controller configuration
+ * Using symbols to avoid collisions with other decorators
  */
-interface ParamInjection {
-  /** Parameter index in the method signature (0-based) */
-  index: number;
-  /** DI token to resolve */
-  token: InjectionToken$1;
-}
+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;
+  readonly RATE_LIMIT: symbol;
+};
 /**
- * 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
- * ) { }
- * ```
+ * Security scheme identifiers for OpenAPI
+ * These reference the security scheme definitions in security.schemas.ts
  */
-declare function InjectParam<T>(token: InjectionToken$1<T>): ParameterDecorator;
+declare const SECURITY_SCHEMES: {
+  readonly BEARER_AUTH: "bearerAuth";
+  readonly API_KEY: "apiKey";
+  readonly SESSION_COOKIE: "sessionCookie";
+};
 /**
- * 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;
-  readonly RATE_LIMIT: 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
+ * HTTP method mapping for RESTful controller methods
+ * Maps controller method names to HTTP verbs and path patterns
  */
 declare const HTTP_METHODS: {
   readonly index: {
@@ -618,7 +214,7 @@ declare const VERSION_NEUTRAL: unique symbol;
  * 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 ZodObjectWithEffect = zod_d_exports.ZodObject<any> | zod_d_exports.ZodPipe<any, any>;
 type RouteParameter = ZodObjectWithEffect | undefined;
 /**
  * Hono context variables with type-safe keys
@@ -655,19 +251,19 @@ type HttpMethod = 'get' | 'post' | 'put' | 'delete' | 'patch' | 'head' | 'option
  * Object form for request body with optional content type
  */
 interface RouteBodyObject {
-  schema: index_d_exports$1.ZodType;
+  schema: zod_d_exports.ZodType;
   contentType?: string;
 }
 /**
  * Request body definition for @Route() decorator
  * Bare ZodType defaults to application/json
  */
-type RouteBody = index_d_exports$1.ZodType | RouteBodyObject;
+type RouteBody = zod_d_exports.ZodType | RouteBodyObject;
 /**
  * Object form for response with optional description and content type
  */
 interface RouteResponseObject {
-  schema: index_d_exports$1.ZodType;
+  schema: zod_d_exports.ZodType;
   description?: string;
   contentType?: string;
 }
@@ -675,7 +271,7 @@ interface RouteResponseObject {
  * 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;
+type RouteResponse = zod_d_exports.ZodType | RouteResponseObject;
 /**
  * Route configuration for @Route() decorator
  * Defines OpenAPI metadata for a controller method
@@ -859,673 +455,173 @@ interface LocalePathConfig {
    */
   defaultLocale: string | null;
 }
+/**
+ * Locale configuration for URL generation.
+ * Controls whether the default locale gets a path prefix in generated URLs.
+ */
+interface LocaleUrlConfig {
+  defaultLocale: string | null;
+  prefixDefaultLocale: false | true | 'redirect';
+}
 //#endregion
 //#region src/execution-context.d.ts
 interface StratalExecutionContext {
   waitUntil(promise: Promise<unknown>): void;
 }
 //#endregion
-//#region src/errors/exception-handler.types.d.ts
+//#region src/di/lazy.d.ts
+declare const LAZY_MARKER: unique symbol;
+interface LazyToken<T = unknown> {
+  [LAZY_MARKER]: true;
+  factory: () => Constructor<T>;
+}
+declare function lazy<T>(factory: () => Constructor<T>): LazyToken<T>;
+declare function isLazyToken(value: unknown): value is LazyToken;
+//#endregion
+//#region src/di/types.d.ts
+type InjectionToken<T = unknown> = Constructor<T> | string | symbol | LazyToken<T>;
+declare enum Scope {
+  Transient = 0,
+  Singleton = 1,
+  Request = 2
+}
+interface WhenOptions {
+  cache?: boolean;
+}
+type ExtensionDecorator<T> = (service: T, container: ContainerLike) => T;
+interface ContainerLike {
+  resolve<T>(token: InjectionToken<T>): T;
+}
+//#endregion
+//#region src/module/types.d.ts
+interface ClassProvider<T extends object = object> {
+  provide: InjectionToken<T>;
+  useClass: Constructor<T>;
+}
+interface ValueProvider<T extends object = object> {
+  provide: InjectionToken<T>;
+  useValue: T;
+}
+interface FactoryProvider<T extends object = object> {
+  provide: InjectionToken<T>;
+  useFactory: (...deps: any[]) => T | Promise<T>;
+  inject?: InjectionToken[];
+}
+interface ExistingProvider<T extends object = object> {
+  provide: InjectionToken<T>;
+  useExisting: InjectionToken<T>;
+}
+type Provider<T extends object = object> = Constructor<T> | ClassProvider<T> | ValueProvider<T> | FactoryProvider<T> | ExistingProvider<T>;
+interface ModuleClass<T extends object = object> extends Constructor<T> {
+  forRoot?: (...args: unknown[]) => DynamicModule;
+  forRootAsync?: <TOptions>(options: AsyncModuleOptions<TOptions>) => DynamicModule;
+}
+interface ModuleOptions {
+  imports?: (ModuleClass | DynamicModule)[];
+  providers?: Provider[];
+  controllers?: Constructor[];
+  consumers?: Constructor[];
+  jobs?: Constructor[];
+}
+interface DynamicModule extends Omit<ModuleOptions, 'imports'> {
+  module: Constructor;
+}
+interface AsyncModuleOptions<TOptions> {
+  inject?: InjectionToken[];
+  useFactory: (...deps: any[]) => TOptions | Promise<TOptions>;
+}
+interface ModuleContext {
+  container: Container;
+  logger: LoggerService;
+}
+interface OnInitialize {
+  onInitialize(context: ModuleContext): void | Promise<void>;
+}
+interface OnShutdown {
+  onShutdown(context: ModuleContext): void | Promise<void>;
+}
+interface OnException {
+  onException(handler: ExceptionHandler): void;
+}
+//#endregion
+//#region src/quarry/types.d.ts
 /**
- * Log severity levels for exception reporting.
+ * Flat input object for programmatic command invocation.
  */
-type LogSeverity = 'error' | 'warn' | 'info' | 'debug';
+type CommandInput = Record<string, unknown>;
 /**
- * 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
+ * Result of a command execution.
  */
-type ReportableCallback<T extends ApplicationError> = (error: T, context: ExceptionContext) => void | Promise<void>;
+interface CommandResult {
+  exitCode: number;
+  output: string[];
+  errors: string[];
+}
 /**
- * Callback invoked to render a specific exception type into a Response.
- *
- * Return `undefined` to fall through to the default renderer.
+ * User-facing Quarry interface. Only exposes the `call()` method.
  *
- * @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
+ * Inject via `@inject(DI_TOKENS.Quarry)` and type as `Quarry`.
  */
-type RenderableCallback<T extends ApplicationError> = (error: T, context: ExceptionContext) => Response | ErrorResponse | Promise<Response> | undefined;
+interface Quarry {
+  call(name: string, input?: CommandInput): Promise<CommandResult>;
+}
 /**
- * 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
+ * Internal mutable state stored on Command instances via Symbol key.
+ * @internal
  */
-type RespondCallback = (response: Response, error: ApplicationError, context: ExceptionContext) => Response;
+interface CommandInternals {
+  inputs: CommandInput;
+  output: string[];
+  errors: string[];
+  exitCode: number;
+  quarry: Quarry | null;
+}
 /**
- * Callback that returns additional context data to include in all exception logs.
- *
- * @returns Key-value pairs merged into every log entry
+ * A parsed argument from a Laravel-style signature string.
  */
-type ContextCallback = () => Record<string, unknown>;
+interface ParsedArgument {
+  name: string;
+  required: boolean;
+  default?: string;
+  description?: string;
+  isArray: boolean;
+}
 /**
- * Handle returned by `reportable()` to control whether default reporting runs.
+ * A parsed option from a Laravel-style signature string.
  */
-interface Reportable {
-  /**
-   * Prevent the default logger from reporting this exception
-   * after the custom reportable callback has run.
-   */
-  stop(): void;
+interface ParsedOption {
+  name: string;
+  alias?: string;
+  isFlag: boolean;
+  isArray: boolean;
+  default?: string;
+  description?: string;
 }
 /**
- * Constructor type for ApplicationError subclasses.
+ * Fully parsed command signature.
  */
-type ApplicationErrorConstructor<T extends ApplicationError = ApplicationError> = new (...args: any[]) => T;
+interface ParsedSignature {
+  name: string;
+  arguments: ParsedArgument[];
+  options: ParsedOption[];
+}
 //#endregion
-//#region src/errors/exception-handler.d.ts
+//#region src/router/controller.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).
+ * Controller interface for handling HTTP requests
  *
- * **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.
+ * Controllers can implement RESTful methods or a custom handle() method.
+ * The route for the controller is set via the `@Controller` decorator.
  *
- * **Usage — extend and override `register()`:**
+ * 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
  *
- * @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()
+ * For non-RESTful routes (wildcards, custom patterns), implement handle()
  */
 interface IController {
   /**
@@ -1699,6 +795,31 @@ declare class LocalePathService {
   private setupDefaultLocaleRedirect;
 }
 //#endregion
+//#region src/router/services/locale-url.service.d.ts
+/**
+ * DI-friendly wrapper around the pure locale-url helpers.
+ *
+ * Binds {@link LocalePathService} config so consumers can call `applyPrefix`,
+ * `stripPrefix`, and `shouldPrefix` without passing config every time.
+ *
+ * Useful for canonical URL generation, sitemap builders, redirect middleware,
+ * hreflang link emission, and anywhere else a request handler needs to compute
+ * locale-aware path variants.
+ */
+declare class LocaleUrlService {
+  private readonly localePath;
+  constructor(localePath: LocalePathService);
+  /** Whether path-based locale detection is enabled — i.e., locales have URL-distinct path variants. */
+  get pathEnabled(): boolean;
+  /** Whether the given locale should get a URL prefix under the current config. */
+  shouldPrefix(locale: string): boolean;
+  /** Prepend `/{locale}` to a pathname, respecting `prefixDefaultLocale`. */
+  applyPrefix(pathname: string, locale: string): string;
+  /** Strip a known-locale prefix from the start of a pathname. */
+  stripPrefix(pathname: string): string;
+  private toUrlConfig;
+}
+//#endregion
 //#region src/router/router.internals.d.ts
 /**
  * Symbol keys for Router internal accessors.
@@ -1730,7 +851,7 @@ interface RouterGroupConfig {
   middleware?: Constructor<Middleware>[];
   version?: string | string[];
   hideFromDocs?: boolean;
-  params?: index_d_exports$1.ZodObject<any>;
+  params?: zod_d_exports.ZodObject<any>;
 }
 /**
  * Internal entry representing a sub-group or the default scope.
@@ -1743,7 +864,7 @@ interface RouterEntry {
   middleware: Constructor<Middleware>[];
   version?: string | string[];
   hideFromDocs?: boolean;
-  params?: index_d_exports$1.ZodObject<any>;
+  params?: zod_d_exports.ZodObject<any>;
   /** Controllers in this entry. undefined = all controllers not in any sub-group */
   controllers?: Constructor[];
 }
@@ -1786,7 +907,7 @@ declare class Router {
   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;
+  prefix(path: string, params?: zod_d_exports.ZodObject<any>): this;
   /** Domain pattern for controllers in this scope */
   domain(pattern: string): this;
   /** Name prefix for routes in this scope */
@@ -1828,18 +949,6 @@ declare class Router {
 }
 //#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;
@@ -1854,106 +963,58 @@ declare class ModuleRegistry {
   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
+   * Register a module on demand (NestJS-style lazy loading). Registers nested
+   * imports recursively and providers, then runs `onInitialize` immediately
+   * (the bootstrap-time batch {@link initialize} has already completed).
+   *
+   * Controllers, queue consumers, and cron jobs are SKIPPED — route, queue, and
+   * cron wiring is finalized at bootstrap and cannot be extended at runtime.
    */
+  registerLazy(moduleOrDynamic: ModuleClass | DynamicModule): Promise<void>;
   registerAll(modules: (ModuleClass | DynamicModule)[]): void;
+  hasRegistered(moduleClass: Constructor): boolean;
   /**
-   * Initialize all modules (call configure and onInitialize hooks)
+   * Handle re-registration of an already-known module. For a DynamicModule,
+   * its extra providers are wired (without re-running lifecycle); for a plain
+   * class it is a no-op. Returns true when the module was already registered.
    */
-  initialize(): Promise<void>;
+  private handleAlreadyRegistered;
   /**
-   * Get all controllers registered from all modules
+   * Register a single module's providers (and, for eager registration, its
+   * controllers/consumers/jobs), detect lifecycle hooks, and record it.
+   * Assumes the module's `imports` have already been registered by the caller.
    */
+  private registerModuleNode;
+  initialize(): Promise<void>;
   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
-   */
+  resolveModule(moduleOrDynamic: ModuleClass | DynamicModule): {
+    moduleClass: Constructor;
+    options: ModuleOptions;
+  };
+  isDynamicModule(value: unknown): value is DynamicModule;
   private registerProvider;
-  /**
-   * Check if a class is a `Command` and collect it for auto-wiring
-   */
+  /** The DI token a provider binds, for collision detection. */
+  private providerToken;
+  private describeToken;
   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
@@ -2044,7 +1105,7 @@ declare class RouteRegistry {
    * 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
+   * @throws RouterError if a named route with the same name already exists
    */
   register(input: RouteRegistrationInput): RegisteredRoute[];
   /** Get a named route by name */
@@ -2077,7 +1138,7 @@ interface ResolvedRouterConfig {
   middleware: Constructor<Middleware>[];
   version?: string | string[];
   hideFromDocs?: boolean;
-  params?: index_d_exports$1.ZodObject<any>;
+  params?: zod_d_exports.ZodObject<any>;
 }
 /**
  * Internal resolver that computes the effective Router config for each controller.
@@ -2279,6 +1340,12 @@ declare const ROUTER_TOKENS: {
    * Resolves locale path variants and computes LocalePathConfig
    */
   readonly LocalePathService: symbol;
+  /**
+   * Token for LocaleUrlService (singleton)
+   * Ergonomic wrapper around the pure locale-url helpers — applies, strips,
+   * and tests locale prefixes against the resolved LocalePathService config.
+   */
+  readonly LocaleUrlService: symbol;
   /**
    * Token for RouterResolver (singleton, may be null)
    * Internal resolver that computes effective Router config per controller
@@ -2322,7 +1389,52 @@ declare const ROUTER_TOKENS: {
  * route('users.show', { id: '1' })
  * ```
  */
-declare function route<N extends RouteName>(name: N, params?: RouteParams<N>): string;
+declare function route<N extends RouteName>(name: N, params?: RouteParams<N>, options?: UriOptions): string;
+//#endregion
+//#region src/router/locale-url.d.ts
+/**
+ * Pure helpers for locale-aware URL path manipulation.
+ *
+ * Each function takes config explicitly so it can run anywhere (no DI, no request
+ * context). For ergonomic DI-driven access, see {@link LocaleUrlService} which
+ * binds these to the resolved {@link LocalePathService} config.
+ */
+/**
+ * Whether a locale should be URL-prefixed under the given config.
+ *
+ * - No config → always prefix (caller didn't opt into locale-aware URLs).
+ * - `prefixDefaultLocale: true` → every locale, including the default, is prefixed.
+ * - Otherwise → only non-default locales are prefixed.
+ */
+declare function shouldPrefixLocale(locale: string, config: LocaleUrlConfig | undefined): boolean;
+/**
+ * Prepend `/{locale}` to a pathname, respecting `prefixDefaultLocale`.
+ * Returns the pathname unchanged when the locale shouldn't be prefixed.
+ */
+declare function applyLocalePrefix(pathname: string, locale: string, config: LocaleUrlConfig | undefined): string;
+/**
+ * Strip a known-locale prefix from the start of a pathname.
+ * Returns the pathname unchanged if the first segment isn't in `knownLocales`.
+ */
+declare function stripLocalePrefix(pathname: string, knownLocales: readonly string[]): string;
+//#endregion
+//#region src/router/trailing-slash.d.ts
+/**
+ * Apply a trailing-slash mode to a URL or path.
+ *
+ * - `'ignore'` — return as-is.
+ * - `'always'` — append `/` to the pathname unless it already has one.
+ *   Skipped when the last segment contains `.` (file-like paths) and for the
+ *   root `/` path.
+ * - `'never'`  — strip a trailing `/` from the pathname. Skipped for root.
+ *
+ * Preserves query string and hash. Handles both relative paths
+ * (`/foo?x=1`) and absolute URLs (`https://host/foo?x=1`).
+ *
+ * Used by URL-generation helpers and the redirect middleware so canonical
+ * form is computed in one place.
+ */
+declare function applyTrailingSlash(url: string, mode: TrailingSlashMode): string;
 //#endregion
 //#region src/router/utils/path.d.ts
 /**
@@ -2630,31 +1742,21 @@ declare function getRouteDecoratedMethods(ControllerClass: new (...args: unknown
 /**
  * Generic error response schema
  * Used for all error responses (4xx, 5xx)
- * Matches ApplicationError.toErrorResponse() structure
+ * Matches the ErrorResponse shape produced by ExceptionHandler
  */
 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
+ * Matches the ErrorResponse shape produced by ExceptionHandler
  */
 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>;
 /**
@@ -2700,66 +1802,48 @@ declare const successMessageSchema: z.ZodObject<{
 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";
@@ -2787,7 +1871,7 @@ declare function parseDomainPattern(pattern: string): {
  * 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).
+ * When the host does NOT match, aborts with 404.
  *
  * @param pattern - Domain pattern with `{param}` placeholders (e.g., '{tenant}.myapp.com')
  *
@@ -2866,105 +1950,27 @@ declare function signUrl(url: string, secret: string, options?: SignedUrlOptions
  */
 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);
-}
+//#region src/router/router.error.d.ts
+declare class RouterError extends ApplicationError {}
 //#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 {
+declare class RouteNotFoundError extends HttpException {
+  readonly path: string;
+  readonly method: string;
   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 {
+declare class SchemaValidationError extends HttpException {
+  readonly issues: {
+    path: string;
+    message: string;
+    code: string;
+  }[];
   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.
  *
@@ -2973,139 +1979,50 @@ declare class DuplicateRouteNameError extends ApplicationError {
 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
+ * violates its own API contract.
  */
-declare class MiddlewareNextCalledMultipleTimesError extends ApplicationError {
-  constructor(middlewareName: string);
+declare class ResponseValidationError extends HttpException {
+  readonly issues: {
+    path: string;
+    message: string;
+    code: string;
+  }[];
+  constructor(zodError: ZodError);
 }
 //#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;
-  /**
-   * Trailing-slash handling for incoming requests.
-   *
-   * Defaults to `'ignore'` — both `/foo` and `/foo/` resolve to the same route.
-   *
-   * - `'ignore'` — match both, no redirect.
-   * - `'always'` — non-trailing requests redirect (308) to the trailing-slash form.
-   * - `'never'`  — trailing requests redirect (308) to the non-trailing form.
-   */
   trailingSlash?: TrailingSlashMode;
-  /**
-   * 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 cronManager?;
   private quarry;
   private initialized;
   private routingInitPromise;
-  private handlerInitPromise;
+  private eventsInitPromise;
+  private queueInitPromise;
+  private i18nInitPromise;
+  private cronInitPromise;
   readonly env: StratalEnv;
   private readonly appConfig;
   constructor({
@@ -3113,79 +2030,72 @@ declare class Application {
     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.
+   * Load the events subsystem and wire listeners. Needed by the HTTP, queue,
+   * and scheduled paths (handlers emit events). Independent of the queue
+   * subsystem so HTTP-only apps never load queue code. EventsModule is
+   * registered before the (possibly empty) listener wiring so `emit()` works
+   * even with zero listeners; dedups against the framework's own load.
    */
-  private initializeHandlers;
+  private initializeEventListeners;
   /**
-   * Register routing services, resolve HonoApp, and configure routes.
-   * Called lazily on first fetch — not during scheduled/queue handling.
+   * Wire event and queue handlers for any non-HTTP request scope — queue
+   * batches, scheduled/cron runs, CLI commands, Durable Objects, Workflows,
+   * WorkerEntrypoints — all of which may emit events or dispatch to queues from
+   * arbitrary user code. This is the single source of truth for that wiring:
+   * every non-HTTP entry point routes through it rather than open-coding which
+   * subsystems to init, so a subsystem can't be silently dropped by a future
+   * refactor (the queue half was once lost from the command path that way).
+   *
+   * HTTP (`fetch`) deliberately does NOT use this: a fetch worker only enqueues
+   * to the async Cloudflare queue and never processes consumers inline, so it
+   * skips queue init via `initializeRouting`.
    */
-  private initializeRouting;
+  ensureScopedHandlers(): Promise<void>;
   /**
-   * Resolve a service from the container
+   * Load the queue subsystem on demand (first queue/scheduled trigger). i18n is
+   * ensured first because the queue registry depends on it.
    */
-  resolve<T>(token: symbol): T;
+  private initializeQueue;
   /**
-   * Handle queue batch processing
+   * Load i18n on demand. Coupled to the request path (Zod validation error maps,
+   * OpenAPI descriptions, queue registry), so it loads before routing/queue
+   * handling. Uses `registerLazy` because I18nModule has an `onInitialize` hook
+   * (configures the Zod error map). Dedups if the app already imported i18n.
    */
-  handleQueue(batch: MessageBatch, queueName: string): Promise<void>;
+  private ensureI18n;
   /**
-   * Handle scheduled cron trigger
+   * Load the cron subsystem on demand (first scheduled trigger, or at bootstrap
+   * when the app declares jobs).
    */
+  private ensureCron;
+  resolve<T>(token: symbol): T;
+  handleQueue(batch: MessageBatch, queueName: string): Promise<void>;
   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 initializeRouting;
   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
+   * Bootstrap kernel — registered imperatively because they cannot be expressed
+   * as ordinary module providers: ExceptionHandler is a user-overridable forced
+   * singleton (a module ClassProvider derives scope from the class decorator,
+   * which a user handler may not carry), and LazyModuleLoader is the loader
+   * itself. Subsystem registries (events/cron/quarry/seeder) are modules.
    */
   private registerCoreServices;
-  /**
-   * Initialize the ExceptionHandler: call register(), then module onException hooks.
-   */
   private initializeExceptionHandler;
 }
 //#endregion
@@ -3211,9 +2121,9 @@ interface SignedUriOptions extends UriOptions, SignedUrlOptions {}
  * @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
+ * @throws RouterError if a required path or domain param is missing
  */
-declare function buildRouteUrl(route: RegisteredRoute, name: string, params?: Record<string, string>): string;
+declare function buildRouteUrl(route: RegisteredRoute, name: string, params?: Record<string, string>, localeConfig?: LocaleUrlConfig): string;
 /**
  * URL generation service for named routes, signed URLs, and request URL access.
  *
@@ -3238,7 +2148,8 @@ declare class Uri {
   private readonly routerContext;
   private _defaults;
   private readonly trailingSlash;
-  constructor(registry: RouteRegistry, routerContext: RouterContext, application: Application);
+  private readonly localeConfig;
+  constructor(registry: RouteRegistry, routerContext: RouterContext, application: Application, localePathService: LocalePathService);
   /**
    * Set default URL parameters for this request.
    * Applied to all subsequent `route()` calls — explicit params override defaults.
@@ -3267,8 +2178,7 @@ declare class Uri {
    * @param options - URL generation options
    * @returns Generated URL string
    *
-   * @throws RouteNameNotFoundError if route name not found
-   * @throws MissingRouteParamError if required params missing
+   * @throws RouterError if route name not found or required params missing
    */
   route<N extends RouteName>(name: N, params?: RouteParams<N>, options?: UriOptions): string;
   /**
@@ -3437,6 +2347,55 @@ declare class RouterContext<T extends RouterEnv = RouterEnv> extends Macroable {
    * @param name - Header name (case-insensitive)
    */
   header(name: string): string | undefined;
+  /**
+   * Read a cookie value from the current request.
+   *
+   * @param name - Cookie name
+   * @returns The cookie value, or `undefined` if the cookie is not present
+   *
+   * @example
+   * ```typescript
+   * const redirectTo = ctx.getCookie('redirectTo')
+   * ```
+   */
+  getCookie(name: string): string | undefined;
+  /**
+   * Set a cookie on the response.
+   *
+   * Cookie operations must run while the response is mutable — call this
+   * before returning the final `Response` from the handler.
+   *
+   * @param name - Cookie name
+   * @param value - Cookie value
+   * @param options - Cookie attributes (httpOnly, secure, sameSite, path, etc.)
+   *
+   * @example
+   * ```typescript
+   * ctx.setCookie('redirectTo', '/app/', {
+   *   httpOnly: true,
+   *   secure: true,
+   *   sameSite: 'lax',
+   *   path: '/',
+   * })
+   * ```
+   */
+  setCookie(name: string, value: string, options?: CookieOptions): void;
+  /**
+   * Delete a cookie from the response.
+   *
+   * Pass the same `path` and `domain` options that were used when the cookie
+   * was set, otherwise the browser will not clear the matching cookie.
+   *
+   * @param name - Cookie name
+   * @param options - Cookie attributes used at set time (path, domain, etc.)
+   * @returns The deleted cookie's previous value, or `undefined`
+   *
+   * @example
+   * ```typescript
+   * ctx.deleteCookie('redirectTo', { path: '/' })
+   * ```
+   */
+  deleteCookie(name: string, options?: CookieOptions): string | undefined;
   /**
    * Get validated request body from OpenAPI route
    * Returns pre-validated data that has passed schema validation
@@ -3538,6 +2497,197 @@ declare class RouterContext<T extends RouterEnv = RouterEnv> extends Macroable {
   private resolveUri;
 }
 //#endregion
+//#region src/di/conditional-binding-builder.d.ts
+interface PredicateContainer {
+  resolve<T>(token: InjectionToken<T>): T;
+  isRegistered<T>(token: InjectionToken<T>): boolean;
+}
+interface ConditionalBindingBuilder {
+  use<T extends object>(token: InjectionToken<T>): ConditionalBindingUse<T>;
+}
+interface ConditionalBindingUse<T extends object> {
+  give(implementation: Constructor<T>): ConditionalBindingGive<T>;
+}
+interface ConditionalBindingGive<T extends object> {
+  otherwise(implementation: Constructor<T>): void;
+}
+declare class ConditionalBindingBuilderImpl implements ConditionalBindingBuilder {
+  private readonly container;
+  private readonly predicate;
+  private readonly options;
+  constructor(container: Container, predicate: (container: PredicateContainer) => boolean, options: WhenOptions);
+  use<T extends object>(token: InjectionToken<T>): ConditionalBindingUse<T>;
+}
+//#endregion
+//#region src/di/container.d.ts
+interface ClassRegistration {
+  kind: 'class';
+  useClass: Constructor;
+  scope: Scope;
+}
+interface LazyClassRegistration {
+  kind: 'lazy';
+  factory: () => Constructor;
+}
+interface ValueRegistration {
+  kind: 'value';
+  value: unknown;
+}
+interface FactoryRegistration {
+  kind: 'factory';
+  factory: (container: Container) => unknown;
+}
+interface AliasRegistration {
+  kind: 'alias';
+  target: InjectionToken;
+}
+type Registration = ClassRegistration | LazyClassRegistration | ValueRegistration | FactoryRegistration | AliasRegistration;
+interface ContainerOptions {
+  parent?: Container;
+  isRequestScoped?: boolean;
+}
+declare class Container {
+  private readonly registrations;
+  private readonly singletons;
+  private readonly requestCache;
+  private readonly requestCacheDeps;
+  /**
+   * Classes currently being constructed, held on the root so it spans the
+   * global ↔ request-scope boundary. Used to turn an otherwise-opaque stack
+   * overflow on a circular dependency into a clear error naming the cycle.
+   */
+  private readonly resolutionStack;
+  private readonly parent;
+  private readonly isRequestScoped;
+  constructor(options?: ContainerOptions);
+  register<T extends object>(serviceClass: Constructor<T>): void;
+  register<T extends object>(token: InjectionToken<T>, serviceClassOrLazy: Constructor<T> | LazyToken<T>): void;
+  registerSingleton<T extends object>(serviceClass: Constructor<T>): void;
+  registerSingleton<T extends object>(token: InjectionToken<T>, serviceClass: Constructor<T>): void;
+  registerValue<T>(token: InjectionToken<T>, value: T): void;
+  registerFactory<T>(token: InjectionToken<T>, factory: (container: Container) => T): void;
+  registerExisting<T>(alias: InjectionToken<T>, target: InjectionToken<T>): void;
+  resolve<T>(token: InjectionToken<T>): T;
+  tryResolve<T>(token: InjectionToken<T>): T | undefined;
+  isRegistered<T>(token: InjectionToken<T>): boolean;
+  /**
+   * Whether a token has anything to resolve to: an explicit registration, or a
+   * bare class constructor (auto-resolvable). Distinct from {@link isRegistered}
+   * so {@link tryResolve} can tell "no provider" (→ undefined) apart from
+   * "provider exists but failed" (→ rethrow).
+   */
+  private isResolvable;
+  when(predicate: (container: PredicateContainer) => boolean, options?: WhenOptions): ConditionalBindingBuilder;
+  extend<T>(token: InjectionToken<T>, decorator: ExtensionDecorator<T>): void;
+  runInRequestScope<T>(routerContext: RouterContext, callback: (requestContainer: Container) => T | Promise<T>): Promise<T>;
+  createRequestScope(routerContext: RouterContext): Container;
+  dispose(): void;
+  /**
+   * Transitive constructor dependency tokens of a class, with lazy tokens
+   * unwrapped to the concrete token they resolve to. Recorded when a
+   * request-scoped instance is cached so {@link invalidateRequestCache} can find
+   * dependents.
+   *
+   * The walk follows class/alias registrations through transient intermediaries:
+   * a cached service A that depends on a (non-cached) transient B which depends
+   * on token C must still be invalidated when C is re-registered, even though B
+   * itself is never cached. Value/factory/lazy providers are not traversed —
+   * their dependencies aren't introspectable (factory) or would re-enter a
+   * cycle (lazy). Over-collecting is safe: it only rebuilds extra request-scoped
+   * instances, which is correct.
+   */
+  private collectDependencyTokens;
+  /** The implementing class for a token, following class/alias registrations. */
+  private classForToken;
+  /**
+   * Evict a token from the request cache along with every cached request-scoped
+   * instance that transitively depends on it. Re-registering a value must
+   * rebuild its dependents (so they pick up the new value) while leaving
+   * unrelated cached services intact.
+   */
+  private invalidateRequestCache;
+  private resolveRegistration;
+  private resolveClass;
+  private instantiate;
+  findRegistration(token: InjectionToken): Registration | undefined;
+  /**
+   * The global (non-request-scoped) container at the top of the parent chain.
+   * Lazy module loading registers providers here so singletons persist across
+   * requests even when `load()` is called from within a request scope.
+   */
+  getRootContainer(): Container;
+  private getRoot;
+}
+//#endregion
+//#region src/di/container.error.d.ts
+declare class ContainerError extends ApplicationError {}
+//#endregion
+//#region src/di/decorators/inject-param.decorator.d.ts
+declare const INJECT_PARAM_METADATA_KEY: unique symbol;
+interface ParamInjection {
+  index: number;
+  token: InjectionToken;
+}
+declare function InjectParam<T>(token: InjectionToken<T>): ParameterDecorator;
+declare function getMethodInjections(target: object, propertyKey: string | symbol): ParamInjection[];
+//#endregion
+//#region src/di/decorators/inject.decorator.d.ts
+interface InjectionEntry {
+  token: InjectionToken;
+  optional: boolean;
+}
+declare function inject<T>(token: InjectionToken<T>, options?: {
+  isOptional?: boolean;
+}): ParameterDecorator;
+declare function getInjectionTokens(target: object): Map<number, InjectionEntry>;
+//#endregion
+//#region src/di/decorators.d.ts
+interface ClassMetadata {
+  scope: Scope;
+  token?: InjectionToken;
+}
+declare const Singleton: <T>(token?: InjectionToken<T>) => <TFunction extends abstract new (...args: never[]) => unknown>(target: TFunction) => TFunction;
+declare const Request: <T>(token?: InjectionToken<T>) => <TFunction extends abstract new (...args: never[]) => unknown>(target: TFunction) => TFunction;
+declare const Transient: <T>(token?: InjectionToken<T>) => <TFunction extends abstract new (...args: never[]) => unknown>(target: TFunction) => TFunction;
+declare function getClassMetadata(target: object): ClassMetadata | undefined;
+//#endregion
+//#region src/di/metadata.d.ts
+declare function defineMetadata(key: symbol, value: unknown, target: object, propertyKey?: string | symbol): void;
+declare function getMetadata<T = unknown>(key: symbol, target: object, propertyKey?: string | symbol): T | undefined;
+declare function hasMetadata(key: symbol, target: object, propertyKey?: string | symbol): boolean;
+//#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.
+ */
+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/errors/error-response.d.ts
+type Environment = 'development' | 'staging' | 'production';
+interface ErrorResponse {
+  message: string;
+  timestamp: string;
+  stack?: string;
+}
+declare function isErrorResponse(obj: unknown): obj is ErrorResponse;
+//#endregion
 //#region src/errors/exception-context.d.ts
 /**
  * Exception context for errors occurring during HTTP request handling.
@@ -3603,645 +2753,139 @@ declare function createHttpExceptionContext(c: Context<RouterEnv>): HttpExceptio
  */
 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)
+ * Create a cron exception context.
+ *
+ * @returns A {@link CronExceptionContext}
  */
-declare const messages: {
-  readonly en: typeof index_d_exports;
-};
+declare function createCronExceptionContext(): CronExceptionContext;
 /**
- * Type for all messages
+ * Create a CLI command exception context.
+ *
+ * @param commandName - The name of the command that threw
+ * @returns A {@link CliExceptionContext}
  */
-type Messages = typeof messages;
+declare function createCliExceptionContext(commandName: string): CliExceptionContext;
+//#endregion
+//#region src/errors/exception-handler.types.d.ts
 /**
- * Get messages for all locales
+ * Log severity levels for exception reporting.
  */
-declare function getMessages(): Record<string, Record<string, unknown>>;
+type LogSeverity = 'error' | 'warn' | 'info' | 'debug';
 /**
- * Get available locales
+ * 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
  */
-declare function getLocales(): string[];
-//#endregion
-//#region src/i18n/services/message-registry.d.ts
+type ReportableCallback<T extends ApplicationError> = (error: T, context: ExceptionContext) => void | Promise<void>;
 /**
- * Message Registry
+ * Callback invoked to render a specific exception type into a Response.
  *
- * 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`.
+ * Return `undefined` to fall through to the default renderer.
  *
- * Later registrations override earlier ones at leaf level.
+ * @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
  */
-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
+type RenderableCallback<T extends ApplicationError> = (error: T, context: ExceptionContext) => Response | ErrorResponse | Promise<Response> | undefined;
 /**
- * I18n Service
+ * Callback invoked to post-process every error Response before it is returned.
  *
- * Provides internationalization (i18n) support for the application.
- * Injects RouterContext to access request-specific locale.
+ * Use this to add headers, change the response body, swap content type, etc.
  *
- * @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')
- *   }
- * }
- * ```
+ * @param response - The rendered Response
+ * @param error - The original exception
+ * @param context - The execution context where the error occurred
+ * @returns The (possibly modified) Response
  */
-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;
+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 {
   /**
-   * Get current locale
-   *
-   * @returns Current locale code from RouterContext or default locale
+   * Prevent the default logger from reporting this exception
+   * after the custom reportable callback has run.
    */
-  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>;
+  stop(): 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; /** Rate limit exceeded */
-    readonly TOO_MANY_REQUESTS: 4290;
-  };
-  /**
-   * 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
+ * Constructor type for ApplicationError subclasses.
  */
-type DeepValues<T> = T extends object ? { [K in keyof T]: DeepValues<T[K]> }[keyof T] : T;
+type ApplicationErrorConstructor<T extends ApplicationError = ApplicationError> = new (...args: any[]) => T;
 /**
- * Type helper to extract all error code values
- * Union type of all numeric error codes defined in ERROR_CODES
+ * Callback invoked to render the HTML error page for HTTP requests that
+ * accept `text/html`. Registered via {@link ExceptionHandler.errorPage}.
  *
- * Type: 2000 | 2001 | 2002 | ... | 9203
+ * Runs after content negotiation, after translation, after status resolution —
+ * everything is computed and handed to the callback. Return `undefined` to
+ * defer to the next registered `errorPage` callback, or — if none match —
+ * to the built-in minimal HTML page.
+ *
+ * Callbacks are walked in registration order (first non-undefined wins).
+ * Since the consumer's `register()` runs before module `onException()` hooks,
+ * user overrides take precedence over module-supplied defaults.
+ *
+ * @param errorResponse - The translated, env-stripped error response payload
+ * @param status - The resolved HTTP status code
+ * @param context - The HTTP exception context (with full RouterContext access)
+ * @param error - The original ApplicationError (escape hatch for metadata, etc.)
+ * @returns A Response, or undefined to defer to the next callback / default
  */
-type ErrorCode = DeepValues<typeof ERROR_CODES>;
+type ErrorPageCallback = (errorResponse: ErrorResponse, status: ContentfulStatusCode, context: HttpExceptionContext, error: ApplicationError) => Response | Promise<Response | undefined> | undefined;
 //#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;
+//#region src/errors/exception-handler.d.ts
+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 errorPages;
+  private readonly environment;
+  constructor(logger: LoggerService, env: StratalEnv, container: Container, executionContext: StratalExecutionContext);
+  abstract register(): void;
+  reportable<T extends ApplicationError>(errorClass: ApplicationErrorConstructor<T>, callback: ReportableCallback<T>): Reportable;
+  renderable<T extends ApplicationError>(errorClass: ApplicationErrorConstructor<T>, callback: RenderableCallback<T>): void;
+  dontReport(errorClasses: ApplicationErrorConstructor[]): void;
+  level(errorClass: ApplicationErrorConstructor, severity: LogSeverity): void;
+  context(callback: ContextCallback): void;
+  respond(callback: RespondCallback): void;
+  errorPage(callback: ErrorPageCallback): void;
+  resolve<T>(token: symbol | (new (...args: unknown[]) => T)): T;
+  handle(error: unknown, context: ExceptionContext): Promise<Response>;
+  private normalizeError;
+  private performReport;
+  private performRender;
+  private applyRespondCallbacks;
+  private shouldNotReport;
+  private findReportable;
+  private findRenderable;
+  private matchesErrorClass;
+  private defaultReport;
+  private defaultRender;
+  protected wantsHtml(context: HttpExceptionContext): boolean;
+  protected renderDefaultHtml(errorResponse: ErrorResponse, status: ContentfulStatusCode): Response;
+  private resolveStatus;
+  private buildErrorResponse;
+  private escapeHtml;
+  private toResponse;
+  private resolveSeverity;
+  private getDefaultSeverity;
+  private gatherContext;
 }
 //#endregion
 //#region src/errors/default-exception-handler.d.ts
@@ -4268,163 +2912,41 @@ 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 const HTTP_STATUS_MESSAGES: Partial<Record<number, string>>;
 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);
+  constructor(httpStatus: ContentfulStatusCode, message?: string, cause?: unknown);
 }
-/**
- * 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;
+declare function abort(status: ContentfulStatusCode, message?: 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>);
+  constructor(cause?: 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 { DuplicateRouteNameError as $, TrailingSlashMode as $n, ModuleRegistry as $t, LocaleNotSupportedError as A, ValueProvider as An, container$1 as Ar, Delete as At, ContextQueryResult as B, ControllerOptions as Bn, PredicateContainer as Br, extractDomainParamNames as Bt, DetectionStrategy as C, ModuleContext as Cn, RoutePrefixes as Cr, successMessageSchema as Ct, buildDetectorOptions as D, OnShutdown as Dn, Container as Dr, getRouteDecoratedMethods as Dt, ResolvedI18nOptions as E, OnInitialize as En, StratalRouteMap as Er, Route as Et, QueueExceptionContext as F, RenderableCallback as Fn, singleton as Fr, Controller as Ft, buildRouteUrl as G, RouteBodyObject as Gn, Environment as Gr, toOpenAPIPath as Gt, SignedUriOptions as H, ExplicitRouteMetadata as Hn, ExtensionDecorator as Hr, generateConventionRouteName as Ht, createCliExceptionContext as I, Reportable as In, ConditionalBindingBuilder as Ir, getControllerOptions as It, ApplicationOptions as J, RouteResponse as Jn, RouteRegistrationService as Jt, Application as K, RouteConfig as Kn, ErrorResponse as Kr, route as Kt, createCronExceptionContext as L, ReportableCallback as Ln, ConditionalBindingBuilderImpl as Lr, getControllerRoute as Lt, CronExceptionContext as M, ApplicationErrorConstructor as Mn, inject$1 as Mr, Patch as Mt, ExceptionContext as N, ContextCallback as Nn, injectable$1 as Nr, Post as Nt, resolveI18nOptions as O, Provider as On, ContainerOptions as Or, getRouteMetadata as Ot, HttpExceptionContext as P, LogSeverity as Pn, instancePerContainerCachingFactory$1 as Pr, Put as Pt, DomainMismatchError as Q, SecurityScheme as Qn, VersioningService as Qt, createHttpExceptionContext as R, RespondCallback as Rn, ConditionalBindingGive as Rr, getControllerVersion as Rt, I18nModule as S, ModuleClass as Sn, RouteParams as Sr, paginationQuerySchema as St, LanguageDetectionOptions as T, OnException as Tn, SerializedRoutes as Tr, validationErrorResponseSchema as Tt, Uri as U, LocalePathConfig as Un, Scope as Ur, getPathSpecificityScore as Ut, RouterContext as V, ConventionRouteMetadata as Vn, ContainerLike as Vr, extractParamNames as Vt, UriOptions as W, RouteBody as Wn, WhenOptions as Wr, sortRoutesBySpecificity as Wt, SSEStreamingApi$1 as X, RouterEnv as Xn, RouteRegistrationInput as Xt, SSEMessage as Y, RouteResponseObject as Yn, RegisteredRoute as Yt, StreamingApi$1 as Z, RouterVariables as Zn, RouteRegistry as Zt, Messages as _, ClassProvider as _n, DIToken as _r, createDomainMiddleware as _t, InternalError as a, HonoApp as an, VERSION_NEUTRAL as ar, RouteNameNotFoundError as at, messages as b, FactoryProvider as bn, RouteMatcher as br, errorResponseSchema as bt, getHttpStatus as c, IController as cn, runWithContainer as cr, RouteNotFoundError as ct, ApplicationError as d, CommandResult as dn, Transient as dr, HonoAppAlreadyConfiguredError as dt, RouteConfigurable as en, VersioningOptions as er, InvalidSignatureError as et, ERROR_CODES as f, ParsedArgument as fn, INJECT_PARAM_METADATA_KEY as fr, ControllerRegistrationError as ft, MessageRegistry as g, AsyncModuleOptions as gn, CONTAINER_TOKEN as gr, VerifySignatureMiddleware as gt, MessageLoaderService as h, Quarry as hn, getMethodInjections as hr, verifySignedUrl as ht, isApplicationError as i, ResolvedPath as in, SECURITY_SCHEMES as ir, ResponseValidationError as it, CliExceptionContext as j, ExceptionHandler as jn, delay as jr, Get as jt, TranslationMissingError as k, RegistryEntry as kn, DependencyContainer$1 as kr, All as kt, resolveHttpStatus as l, CommandInput as ln, RequestScopeOperationNotAllowedError as lr, OpenAPIValidationError as lt, I18nContextMiddleware as m, ParsedSignature as mn, ParamInjection as mr, signUrl as mt, RequestContainerNotInitializedError as n, RouterGroupConfig as nn, ROUTER_CONTEXT_KEYS as nr, MissingEnvironmentVariableError as nt, HttpException as o, Middleware as on, containerStorage as or, RouterUseScopeError as ot, ErrorCode as p, ParsedOption as pn, InjectParam as pr, SignedUrlOptions as pt, ApplicationConfig as q, RouteMetadata as qn, isErrorResponse as qr, ROUTER_TOKENS as qt, ContainerNotInitializedError as r, LocalePathService as rn, ROUTE_METADATA_KEYS as rr, MissingRouteParamError as rt, abort as s, Next$1 as sn, getContainer as sr, SchemaValidationError as st, StratalNotInitializedError as t, Router as tn, HTTP_METHODS as tr, MiddlewareNextCalledMultipleTimesError as tt, DefaultExceptionHandler as u, CommandInternals as un, ConditionalBindingFallbackError as ur, OpenAPIRouteRegistrationError as ut, getLocales as v, DynamicModule as vn, DI_TOKENS as vr, parseDomainPattern as vt, I18nModuleOptions as w, ModuleOptions as wn, SerializedRoute as wr, uuidParamSchema as wt, I18N_TOKENS as x, InjectionToken$2 as xn, RouteName as xr, paginatedResponseSchema as xt, getMessages as y, ExistingProvider as yn, CurrentRoute as yr, commonErrorSchemas as yt, createQueueExceptionContext as z, StratalExecutionContext as zn, ConditionalBindingUse as zr, createMiddlewareChain as zt };
-//# sourceMappingURL=index-ByOyTmqf.d.mts.map
+//#region src/errors/database.error.d.ts
+declare class DatabaseError extends ApplicationError {
+  constructor(message?: string, cause?: unknown);
+}
+//#endregion
+//#region src/errors/auth.error.d.ts
+declare class AuthError extends ApplicationError {
+  constructor(message?: string, cause?: unknown);
+}
+//#endregion
+export { ConditionalBindingGive as $, LocaleUrlConfig as $n, applyLocalePrefix as $t, ErrorResponse as A, ExistingProvider as An, uuidParamSchema as At, Transient as B, ContainerLike as Bn, Put as Bt, HttpExceptionContext as C, ParsedArgument as Cn, StratalRouteMap as Cr, createDomainMiddleware as Ct, createHttpExceptionContext as D, AsyncModuleOptions as Dn, ApplicationError as Dr, paginatedResponseSchema as Dt, createCronExceptionContext as E, Quarry as En, DI_TOKENS as Er, errorResponseSchema as Et, defineMetadata as F, OnException as Fn, All as Ft, InjectParam as G, LazyToken as Gn, createMiddlewareChain as Gt, getInjectionTokens as H, InjectionToken as Hn, getControllerOptions as Ht, getMetadata as I, OnInitialize as In, Delete as It, ContainerError as J, StratalExecutionContext as Jn, generateConventionRouteName as Jt, ParamInjection as K, isLazyToken as Kn, extractDomainParamNames as Kt, hasMetadata as L, OnShutdown as Ln, Get as Lt, containerStorage as M, ModuleClass as Mn, Route as Mt, getContainer as N, ModuleContext as Nn, getRouteDecoratedMethods as Nt, createQueueExceptionContext as O, ClassProvider as On, paginationQuerySchema as Ot, runWithContainer as P, ModuleOptions as Pn, getRouteMetadata as Pt, ConditionalBindingBuilderImpl as Q, LocalePathConfig as Qn, applyTrailingSlash as Qt, Request as R, Provider as Rn, Patch as Rt, ExceptionContext as S, CommandResult as Sn, SerializedRoutes as Sr, VerifySignatureMiddleware as St, createCliExceptionContext as T, ParsedSignature as Tn, DIToken as Tr, commonErrorSchemas as Tt, inject as U, Scope as Un, getControllerRoute as Ut, getClassMetadata as V, ExtensionDecorator as Vn, Controller as Vt, INJECT_PARAM_METADATA_KEY as W, WhenOptions as Wn, getControllerVersion as Wt, ContainerOptions as X, ConventionRouteMetadata as Xn, sortRoutesBySpecificity as Xt, Container as Y, ControllerOptions as Yn, getPathSpecificityScore as Yt, ConditionalBindingBuilder as Z, ExplicitRouteMetadata as Zn, toOpenAPIPath as Zt, Reportable as _, Middleware as _n, RouteMatcher as _r, RouteNotFoundError as _t, isApplicationError as a, RegisteredRoute as an, RouteResponseObject as ar, Uri as at, CliExceptionContext as b, CommandInput as bn, RoutePrefixes as br, signUrl as bt, HttpException as c, VersioningService as cn, SecurityScheme as cr, Application as ct, ExceptionHandler as d, Router as dn, HTTP_METHODS as dr, SSEMessage as dt, shouldPrefixLocale as en, RouteBody as er, ConditionalBindingUse as et, ApplicationErrorConstructor as f, RouterGroupConfig as fn, ROUTER_CONTEXT_KEYS as fr, SSEStreamingApi$1 as ft, RenderableCallback as g, HonoApp as gn, CurrentRoute as gr, SchemaValidationError as gt, LogSeverity as h, ResolvedPath as hn, VERSION_NEUTRAL as hr, ResponseValidationError as ht, ContainerNotInitializedError as i, RouteRegistrationService as in, RouteResponse as ir, SignedUriOptions as it, isErrorResponse as j, FactoryProvider as jn, validationErrorResponseSchema as jt, Environment as k, DynamicModule as kn, successMessageSchema as kt, abort as l, ModuleRegistry as ln, TrailingSlashMode as lr, ApplicationConfig as lt, ErrorPageCallback as m, LocalePathService as mn, SECURITY_SCHEMES as mr, InvalidSignatureError as mt, DatabaseError as n, route as nn, RouteConfig as nr, ContextQueryResult as nt, InternalError as o, RouteRegistrationInput as on, RouterEnv as or, UriOptions as ot, ContextCallback as p, LocaleUrlService as pn, ROUTE_METADATA_KEYS as pr, StreamingApi$1 as pt, getMethodInjections as q, lazy as qn, extractParamNames as qt, StratalNotInitializedError as r, ROUTER_TOKENS as rn, RouteMetadata as rr, RouterContext as rt, HTTP_STATUS_MESSAGES as s, RouteRegistry as sn, RouterVariables as sr, buildRouteUrl as st, AuthError as t, stripLocalePrefix as tn, RouteBodyObject as tr, PredicateContainer as tt, DefaultExceptionHandler as u, RouteConfigurable as un, VersioningOptions as ur, ApplicationOptions as ut, ReportableCallback as v, Next$1 as vn, RouteName as vr, RouterError as vt, QueueExceptionContext as w, ParsedOption as wn, CONTAINER_TOKEN as wr, parseDomainPattern as wt, CronExceptionContext as x, CommandInternals as xn, SerializedRoute as xr, verifySignedUrl as xt, RespondCallback as y, IController as yn, RouteParams as yr, SignedUrlOptions as yt, Singleton as z, ValueProvider as zn, Post as zt };
+//# sourceMappingURL=index-B_JoEl3V.d.mts.map