stratal 0.0.20 → 0.0.22

package/dist/{index-D0US0X14.d.mts → index-DEncMcC6.d.mts}

@@ -1,269 +1,48 @@
-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-B4UBK-2T.mjs";
+import { t as StratalEnv } from "./env-DKSbuBi5.mjs";
+import { a as z, i as ZodError, o as zod_d_exports, t as OpenAPIHono } from "./zod-DvWTfRpI.mjs";
+import { c as LogLevel, r as LoggerService } from "./index-BtlE9RuO.mjs";
+import { t as Constructor } from "./types-BaeHi67f.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 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 +137,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 +213,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 +250,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 +270,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
@@ -865,667 +460,159 @@ 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).
- *
- * **Lifecycle:**
- * 1. The framework resolves this from the DI container (once at init time).
- * 2. `register()` is called to let the user configure reporting / rendering.
- * 3. Module `onException()` hooks contribute additional configuration.
- * 4. On every error, `handle()` runs the pipeline: normalize → report → render → respond.
- *
- * **Usage — extend and override `register()`:**
+ * Controller interface for handling HTTP requests
  *
- * @example
- * ```typescript
- * export class AppExceptionHandler extends ExceptionHandler {
- *   register(): void {
- *     this.reportable(PaymentError, (e, ctx) => {
- *       this.resolve(SentryService).captureException(e)
- *     }).stop()
+ * Controllers can implement RESTful methods or a custom handle() method.
+ * The route for the controller is set via the `@Controller` decorator.
  *
- *     this.renderable(MaintenanceError, (e, ctx) => {
- *       if (ctx.type === 'http') return ctx.ctx.html('<h1>Maintenance</h1>', 503)
- *     })
+ * 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
  *
- *     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 {
   /**
@@ -1730,7 +817,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 +830,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 +873,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 +915,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 +929,30 @@ 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
-   */
   registerAll(modules: (ModuleClass | DynamicModule)[]): void;
-  /**
-   * Initialize all modules (call configure and onInitialize hooks)
-   */
   initialize(): Promise<void>;
-  /**
-   * Get all controllers registered from all modules
-   */
   getAllControllers(): Constructor[];
-  /**
-   * Get all consumers registered from all modules
-   */
   getAllConsumers(): Constructor[];
-  /**
-   * Get all jobs registered from all modules
-   */
   getAllJobs(): Constructor[];
-  /**
-   * Get all listeners registered from all modules
-   */
   getAllListeners(): Constructor[];
-  /**
-   * Get all commands registered from all modules
-   */
   getAllCommands(): Constructor[];
-  /**
-   * Get all seeders registered from all modules
-   */
   getAllSeeders(): Constructor[];
-  /**
-   * Get all Router configurations from modules implementing RouteConfigurable.
-   * Runs configureRoutes() lazily on first call (deferred from initialize()).
-   */
   getAllRouterConfigs(): {
     router: Router;
     controllers: Constructor[];
   }[];
-  /**
-   * Call `onException()` on all modules that implement the OnException interface.
-   * Invoked by Application after the ExceptionHandler is resolved and `register()` is called.
-   *
-   * @param handler - The resolved ExceptionHandler instance
-   */
   configureExceptionHandlers(handler: ExceptionHandler): void;
-  /**
-   * Shutdown all modules (call onShutdown hooks in reverse order)
-   */
   shutdown(): Promise<void>;
-  /**
-   * Type guard for RouteConfigurable
-   */
   private hasRouteConfigurable;
-  /**
-   * Type guard for OnInitialize
-   */
   private hasOnInitialize;
-  /**
-   * Type guard for OnShutdown
-   */
   private hasOnShutdown;
-  /**
-   * Type guard for OnException
-   */
   private hasOnException;
-  /**
-   * Resolve module class and options from static or dynamic module
-   *
-   * For DynamicModules, merges the decorator metadata (consumers, controllers, jobs)
-   * with the DynamicModule options (providers, imports). This ensures modules using
-   * forRoot/forRootAsync patterns still have their decorator-defined consumers registered.
-   */
   private resolveModule;
-  /**
-   * Type guard for DynamicModule
-   */
   private isDynamicModule;
-  /**
-   * Register a single provider in the container
-   */
   private registerProvider;
-  /**
-   * Check if a class is a `Command` and collect it for auto-wiring
-   */
   private collectIfCommand;
-  /**
-   * Check if a class is a `Seeder` and collect it for auto-wiring
-   */
   private collectIfSeeder;
-  /**
-   * Check if a class is a `@Listener()` and collect it for auto-wiring
-   */
   private collectIfListener;
 }
 //#endregion
@@ -2044,7 +1043,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 */
@@ -2059,7 +1058,7 @@ declare class RouteRegistry {
    */
   findNameByRoute(method: string, path: string): string | undefined;
   private buildRouteToNameCache;
-  /** Get all routes sorted by specificity (static > param > wildcard, primary before locale) */
+  /** Get all routes sorted by specificity (static > param > wildcard, locale variant before its primary) */
   all(): RegisteredRoute[];
   /** Get only named routes */
   named(): RegisteredRoute[];
@@ -2077,7 +1076,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.
@@ -2322,7 +1321,7 @@ 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/utils/path.d.ts
 /**
@@ -2354,10 +1353,13 @@ declare function getPathSpecificityScore(path: string): number;
  *
  * 1. Static paths before parameterized before wildcards
  * 2. More segments = more specific (tie-breaker)
- * 3. Primary paths before locale-prefixed variants
+ * 3. Locale-prefixed variants before their primary (so a locale-prefixed
+ *    request matches the variant first; a primary catch-all would otherwise
+ *    swallow the locale prefix into its param)
  */
 declare function sortRoutesBySpecificity<T extends {
   path: string;
+  isLocaleVariant?: boolean;
 }>(routes: T[]): T[];
 //#endregion
 //#region src/router/utils/route-name.d.ts
@@ -2627,31 +1629,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>;
 /**
@@ -2697,66 +1689,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";
@@ -2784,7 +1758,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')
  *
@@ -2863,237 +1837,67 @@ 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.
- *
- * HTTP Status: 403 Forbidden
- */
-declare class InvalidSignatureError extends HttpException {
-  constructor();
-}
-/**
- * Thrown when a required environment variable is not set.
- *
- * Maps to HTTP 500 via error code range (9xxx → 500).
- */
-declare class MissingEnvironmentVariableError extends ApplicationError {
-  constructor(variable: string);
-}
-/**
- * Thrown when a required path or domain parameter is missing during URL generation.
- *
- * Error Code: 9012
- */
-declare class MissingRouteParamError extends ApplicationError {
-  constructor(param: string, name: string, path: string);
-}
-/**
- * ResponseValidationError
- *
- * Thrown when a controller's response body does not match the declared Zod response schema.
- * Indicates a server-side schema mismatch — the controller is returning data that
- * violates its own API contract.
- */
-declare class ResponseValidationError extends ApplicationError {
-  constructor(zodError: ZodError);
-}
-/**
- * Thrown when attempting to generate a URL for a route name that doesn't exist in the registry.
- *
- * Error Code: 9011
- */
-declare class RouteNameNotFoundError extends ApplicationError {
-  constructor(name: string);
-}
-/**
- * Thrown when `router.use()` is called inside a `group()` callback.
- * `use()` registers global middleware and is only allowed on the root Router.
+ * Error thrown when a signed URL has an invalid or expired signature.
  *
- * Error Code: 9013
+ * HTTP Status: 403 Forbidden
  */
-declare class RouterUseScopeError extends ApplicationError {
+declare class InvalidSignatureError extends HttpException {
   constructor();
 }
 /**
- * Thrown when a middleware calls next() more than once.
- * This is a programming error — each middleware must call next() at most once.
+ * ResponseValidationError
  *
- * Error Code: 9014
+ * 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 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;
@@ -3110,79 +1914,27 @@ 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.
-   */
-  private initializeHandlers;
-  /**
-   * Register routing services, resolve HonoApp, and configure routes.
-   * Called lazily on first fetch — not during scheduled/queue handling.
-   */
+  initializeHandlers(): Promise<void>;
   private initializeRouting;
-  /**
-   * Resolve a service from the container
-   */
   resolve<T>(token: symbol): T;
-  /**
-   * Handle queue batch processing
-   */
   handleQueue(batch: MessageBatch, queueName: string): Promise<void>;
-  /**
-   * Handle scheduled cron trigger
-   */
   handleScheduled(controller: ScheduledController): Promise<void>;
-  /**
-   * Create mock RouterContext for queue/cron/seeder processing
-   */
   createMockRouterContext(locale?: string): RouterContext;
   shutdown(): Promise<void>;
-  /**
-   * Execute a command by name in a request-scoped container.
-   */
   handleCommand(name: string, input?: CommandInput): Promise<CommandResult>;
   private registerCommands;
   private registerSeeders;
   private registerQueueConsumers;
   private registerCronJobs;
-  /**
-   * Auto-wire `@Listener()` classes with the EventRegistry.
-   */
   private registerEventListeners;
-  /**
-   * Register LoggerService and dependencies
-   */
   private registerLoggerService;
-  /**
-   * Register core services with explicit scope
-   */
   private registerCoreServices;
-  /**
-   * Initialize the ExceptionHandler: call register(), then module onException hooks.
-   */
   private initializeExceptionHandler;
 }
 //#endregion
@@ -3208,7 +1960,7 @@ 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;
 /**
@@ -3264,8 +2016,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;
   /**
@@ -3434,6 +2185,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
@@ -3535,6 +2335,154 @@ 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;
+  scope: Scope;
+}
+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 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;
+  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;
+  private resolveRegistration;
+  private resolveClass;
+  private instantiate;
+  findRegistration(token: InjectionToken): Registration | undefined;
+  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.
@@ -3604,641 +2552,135 @@ declare function createQueueExceptionContext(queueName: string): QueueExceptionC
  *
  * @returns A {@link CronExceptionContext}
  */
-declare function createCronExceptionContext(): CronExceptionContext;
-/**
- * Create a CLI command exception context.
- *
- * @param commandName - The name of the command that threw
- * @returns A {@link CliExceptionContext}
- */
-declare function createCliExceptionContext(commandName: string): CliExceptionContext;
-//#endregion
-//#region src/i18n/errors/locale-not-supported.error.d.ts
-declare class LocaleNotSupportedError extends ApplicationError {
-  constructor(locale: string, supportedLocales: string[]);
-}
-//#endregion
-//#region src/i18n/errors/translation-missing.error.d.ts
-declare class TranslationMissingError extends ApplicationError {
-  constructor(key: string, locale: string);
-}
-//#endregion
-//#region src/i18n/i18n.options.d.ts
-/**
- * Detection strategy for locale resolution
- *
- * - `'cookie'` — reads from the `locale` cookie (default)
- * - `'header'` — reads from the `Accept-Language` header
- * - `'querystring'` — reads from the `?locale=` query parameter
- * - `'path'` — reads from the first URL path segment (e.g., `/en/api/users`)
- */
-type DetectionStrategy = 'cookie' | 'header' | 'querystring' | 'path';
-interface BaseDetection {
-  /** Set to false to disable language detection entirely. @default true */
-  enabled?: boolean;
-}
-/**
- * Language detection options (discriminated by strategy)
- *
- * @example Cookie detection (default)
- * ```typescript
- * { strategy: 'cookie' }
- * ```
- *
- * @example Header detection
- * ```typescript
- * { strategy: 'header' }
- * ```
- *
- * @example Path detection
- * ```typescript
- * { strategy: 'path' }
- * ```
- *
- * @example Disable detection
- * ```typescript
- * { enabled: false }
- * ```
- */
-type LanguageDetectionOptions = (BaseDetection & {
-  strategy?: 'cookie';
-  cookieOptions?: DetectorOptions['cookieOptions'];
-}) | (BaseDetection & {
-  strategy: 'header';
-}) | (BaseDetection & {
-  strategy: 'querystring';
-}) | (BaseDetection & {
-  strategy: 'path';
-  /**
-   * Controls whether the default locale gets a URL path prefix.
-   *
-   * - `false` (default) — The default locale has no prefix (`/users`), other locales
-   *   are prefixed (`/fr/users`). Requests to the prefixed default locale (`/en/users`) return 404.
-   * - `'redirect'` — Same as `false`, but requests to the prefixed default locale
-   *   (`/en/users`) are 301-redirected to the unprefixed path (`/users`).
-   * - `true` — All locales are prefixed (`/en/users`, `/fr/users`).
-   *
-   * @default false
-   */
-  prefixDefaultLocale?: false | true | 'redirect';
-}) | {
-  enabled: false;
-};
-/**
- * Options for configuring the I18n module
- *
- * @example
- * ```typescript
- * I18nModule.forRoot({
- *   defaultLocale: 'en',
- *   fallbackLocale: 'en',
- *   locales: ['en', 'fr'],
- *   detection: { strategy: 'header' },
- * })
- * ```
- */
-interface I18nModuleOptions {
-  /**
-   * Default locale for the application
-   * @default 'en'
-   */
-  defaultLocale?: string;
-  /**
-   * Fallback locale when translation is missing
-   * @default 'en'
-   */
-  fallbackLocale?: string;
-  /**
-   * List of supported locales
-   * Request locales not in this list will fall back to defaultLocale
-   */
-  locales?: string[];
-  /**
-   * Language detection configuration
-   * Controls how the locale is extracted from incoming requests
-   */
-  detection?: LanguageDetectionOptions;
-}
-/**
- * Resolved options with all defaults applied
- * Used internally by I18n services
- */
-interface ResolvedI18nOptions {
-  defaultLocale: string;
-  fallbackLocale: string;
-  locales: string[];
-  detection: {
-    enabled: boolean;
-    strategy: DetectionStrategy; /** Resolved value of the path detection `prefixDefaultLocale` option. Only meaningful when `strategy` is `'path'`. */
-    prefixDefaultLocale: false | true | 'redirect';
-  };
-}
-/**
- * Resolve I18n options with defaults
- */
-declare function resolveI18nOptions(options?: I18nModuleOptions): ResolvedI18nOptions;
-/**
- * Build Hono languageDetector options from I18n module options
- */
-declare function buildDetectorOptions(options?: I18nModuleOptions): Partial<DetectorOptions>;
-//#endregion
-//#region src/i18n/i18n.module.d.ts
-declare class I18nModule implements RouteConfigurable {
-  /**
-   * Configure I18n locale settings
-   *
-   * Call once in the root module. Does not accept messages —
-   * use `registerMessages()` to add translations.
-   *
-   * @param options - Locale configuration (defaultLocale, fallbackLocale, locales)
-   */
-  static forRoot(options?: I18nModuleOptions): DynamicModule;
-  /**
-   * Register i18n messages
-   *
-   * Can be called from any module, as many times as needed.
-   * Messages are deep-merged in registration order — later calls override earlier ones at leaf level.
-   *
-   * @param messages - Messages keyed by locale code
-   *
-   * @example App-level messages
-   * ```typescript
-   * I18nModule.registerMessages({
-   *   en: { common: { hello: 'Hello' }, errors: { notFound: 'Not found' } },
-   *   fr: { common: { hello: 'Bonjour' }, errors: { notFound: 'Introuvable' } },
-   * })
-   * ```
-   *
-   * @example Package-level messages
-   * ```typescript
-   * I18nModule.registerMessages({
-   *   en: { tenancy: { tenantNotFound: 'Tenant not found' } },
-   * })
-   * ```
-   */
-  static registerMessages(messages: Record<string, Record<string, unknown>>): DynamicModule;
-  configureRoutes(router: Router): void;
-}
-//#endregion
-//#region src/i18n/i18n.tokens.d.ts
-/**
- * I18n Module DI Tokens
- * Symbol-based tokens to avoid string collisions
- */
-declare const I18N_TOKENS: {
-  /** MessageLoaderService - loads and caches locale messages */readonly MessageLoader: symbol; /** I18nService - request-scoped translation service */
-  readonly I18nService: symbol; /** I18nModuleOptions - configuration options from forRoot() */
-  readonly Options: symbol; /** MessageRegistry - singleton accumulator for registerMessages() contributions */
-  readonly MessageRegistry: symbol;
-};
-//#endregion
-//#region src/i18n/messages/index.d.ts
-/**
- * All locale messages
- * Explicitly import and export (no filesystem scanning - Cloudflare Workers compatible)
- */
-declare const messages: {
-  readonly en: typeof index_d_exports;
-};
+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
- *
- * Provides internationalization (i18n) support for the application.
- * Injects RouterContext to access request-specific locale.
+ * Callback invoked to post-process every error Response before it is returned.
  *
- * @example Usage in services
- * ```typescript
- * @Transient(MY_TOKENS.UserService)
- * export class UserService {
- *   constructor(
- *     @inject(I18N_TOKENS.I18nService) private readonly i18n: II18nService
- *   ) {}
+ * Use this to add headers, change the response body, swap content type, etc.
  *
- *   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;
-  /**
-   * Get current locale
-   *
-   * @returns Current locale code from RouterContext or default locale
-   */
-  getLocale(): string;
-}
-//#endregion
-//#region src/i18n/middleware/i18n-context.middleware.d.ts
-declare class I18nContextMiddleware implements Middleware {
-  private readonly i18n;
-  constructor(i18n: I18nService);
-  handle(ctx: RouterContext, next: Next$1): Promise<void>;
-}
-//#endregion
-//#region src/errors/error-codes.d.ts
+type RespondCallback = (response: Response, error: ApplicationError, context: ExceptionContext) => Response;
 /**
- * Centralized Error Code Registry
+ * Callback that returns additional context data to include in all exception logs.
  *
- * 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
+ * @returns Key-value pairs merged into every log entry
  */
-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;
-  };
-};
+type ContextCallback = () => Record<string, unknown>;
 /**
- * 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
+ * Handle returned by `reportable()` to control whether default reporting runs.
  */
-type DeepValues<T> = T extends object ? { [K in keyof T]: DeepValues<T[K]> }[keyof T] : T;
+interface Reportable {
+  /**
+   * Prevent the default logger from reporting this exception
+   * after the custom reportable callback has run.
+   */
+  stop(): void;
+}
 /**
- * Type helper to extract all error code values
- * Union type of all numeric error codes defined in ERROR_CODES
- *
- * Type: 2000 | 2001 | 2002 | ... | 9203
+ * Constructor type for ApplicationError subclasses.
  */
-type ErrorCode = DeepValues<typeof ERROR_CODES>;
-//#endregion
-//#region src/errors/application-error.d.ts
+type ApplicationErrorConstructor<T extends ApplicationError = ApplicationError> = new (...args: any[]) => T;
 /**
- * ApplicationError
+ * Callback invoked to render the HTML error page for HTTP requests that
+ * accept `text/html`. Registered via {@link ExceptionHandler.errorPage}.
  *
- * Abstract base class for all application errors.
+ * 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.
  *
- * @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.
+ * 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.
  *
- * 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
+ * @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
  */
-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;
+type ErrorPageCallback = (errorResponse: ErrorResponse, status: ContentfulStatusCode, context: HttpExceptionContext, error: ApplicationError) => Response | Promise<Response | undefined> | undefined;
+//#endregion
+//#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
@@ -4265,163 +2707,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-D0US0X14.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 $, RouteResponseObject as $n, ROUTER_TOKENS as $t, ErrorResponse as A, OnException as An, uuidParamSchema as At, Transient as B, LazyToken as Bn, Put as Bt, HttpExceptionContext as C, ClassProvider as Cn, createDomainMiddleware as Ct, createHttpExceptionContext as D, ModuleClass as Dn, paginatedResponseSchema as Dt, createCronExceptionContext as E, FactoryProvider as En, errorResponseSchema as Et, defineMetadata as F, ContainerLike as Fn, All as Ft, InjectParam as G, ConventionRouteMetadata as Gn, createMiddlewareChain as Gt, getInjectionTokens as H, lazy as Hn, getControllerOptions as Ht, getMetadata as I, ExtensionDecorator as In, Delete as It, ContainerError as J, RouteBody as Jn, generateConventionRouteName as Jt, ParamInjection as K, ExplicitRouteMetadata as Kn, extractDomainParamNames as Kt, hasMetadata as L, InjectionToken as Ln, Get as Lt, containerStorage as M, OnShutdown as Mn, Route as Mt, getContainer as N, Provider as Nn, getRouteDecoratedMethods as Nt, createQueueExceptionContext as O, ModuleContext as On, paginationQuerySchema as Ot, runWithContainer as P, ValueProvider as Pn, getRouteMetadata as Pt, ConditionalBindingBuilderImpl as Q, RouteResponse as Qn, route as Qt, Request as R, Scope as Rn, Patch as Rt, ExceptionContext as S, AsyncModuleOptions as Sn, VerifySignatureMiddleware as St, createCliExceptionContext as T, ExistingProvider as Tn, commonErrorSchemas as Tt, inject as U, StratalExecutionContext as Un, getControllerRoute as Ut, getClassMetadata as V, isLazyToken as Vn, Controller as Vt, INJECT_PARAM_METADATA_KEY as W, ControllerOptions as Wn, getControllerVersion as Wt, ContainerOptions as X, RouteConfig as Xn, sortRoutesBySpecificity as Xt, Container as Y, RouteBodyObject as Yn, getPathSpecificityScore as Yt, ConditionalBindingBuilder as Z, RouteMetadata as Zn, toOpenAPIPath as Zt, Reportable as _, CommandResult as _n, StratalRouteMap as _r, RouteNotFoundError as _t, isApplicationError as a, ModuleRegistry as an, HTTP_METHODS as ar, Uri as at, CliExceptionContext as b, ParsedSignature as bn, DI_TOKENS as br, signUrl as bt, HttpException as c, RouterGroupConfig as cn, SECURITY_SCHEMES as cr, Application as ct, ExceptionHandler as d, HonoApp as dn, RouteMatcher as dr, SSEMessage as dt, RouteRegistrationService as en, RouterEnv as er, ConditionalBindingUse as et, ApplicationErrorConstructor as f, Middleware as fn, RouteName as fr, SSEStreamingApi$1 as ft, RenderableCallback as g, CommandInternals as gn, SerializedRoutes as gr, SchemaValidationError as gt, LogSeverity as h, CommandInput as hn, SerializedRoute as hr, ResponseValidationError as ht, ContainerNotInitializedError as i, VersioningService as in, VersioningOptions as ir, SignedUriOptions as it, isErrorResponse as j, OnInitialize as jn, validationErrorResponseSchema as jt, Environment as k, ModuleOptions as kn, successMessageSchema as kt, abort as l, LocalePathService as ln, VERSION_NEUTRAL as lr, ApplicationConfig as lt, ErrorPageCallback as m, IController as mn, RoutePrefixes as mr, InvalidSignatureError as mt, DatabaseError as n, RouteRegistrationInput as nn, SecurityScheme as nr, ContextQueryResult as nt, InternalError as o, RouteConfigurable as on, ROUTER_CONTEXT_KEYS as or, UriOptions as ot, ContextCallback as p, Next$1 as pn, RouteParams as pr, StreamingApi$1 as pt, getMethodInjections as q, LocalePathConfig as qn, extractParamNames as qt, StratalNotInitializedError as r, RouteRegistry as rn, TrailingSlashMode as rr, RouterContext as rt, HTTP_STATUS_MESSAGES as s, Router as sn, ROUTE_METADATA_KEYS as sr, buildRouteUrl as st, AuthError as t, RegisteredRoute as tn, RouterVariables as tr, PredicateContainer as tt, DefaultExceptionHandler as u, ResolvedPath as un, CurrentRoute as ur, ApplicationOptions as ut, ReportableCallback as v, ParsedArgument as vn, CONTAINER_TOKEN as vr, RouterError as vt, QueueExceptionContext as w, DynamicModule as wn, parseDomainPattern as wt, CronExceptionContext as x, Quarry as xn, ApplicationError as xr, verifySignedUrl as xt, RespondCallback as y, ParsedOption as yn, DIToken as yr, SignedUrlOptions as yt, Singleton as z, WhenOptions as zn, Post as zt };
+//# sourceMappingURL=index-DEncMcC6.d.mts.map