stratal 0.0.17 → 0.0.18

package/dist/errors--RBIvDXr.mjs

@@ -0,0 +1,1560 @@
+import { a as __decorate, d as CONTAINER_TOKEN, f as DI_TOKENS, o as __decorateParam, p as Transient, s as __decorateMetadata, u as LOGGER_TOKENS } from "./logger-c0ftIK4G.mjs";
+import { Lifecycle, container as container$1, delay, inject, inject as inject$1, injectable as injectable$1, instancePerContainerCachingFactory as instancePerContainerCachingFactory$1, predicateAwareClassFactory, singleton } from "tsyringe";
+import { AsyncLocalStorage } from "node:async_hooks";
+import { stream, streamSSE, streamText } from "hono/streaming";
+//#region src/errors/application-error.ts
+/**
+* ApplicationError
+*
+* Abstract base class for all application errors.
+*
+* @deprecated Use {@link HttpException} for new error classes. `HttpException` provides
+* a simpler constructor that takes `(httpStatus, message?)` and derives the error code
+* automatically. Existing subclasses will continue to work but should be migrated over time.
+*
+* Features:
+* - Type-safe error codes from ERROR_CODES registry
+* - Type-safe message keys from i18n module
+* - Localized message keys (translated by ExceptionHandler)
+* - Structured metadata for logging and interpolation
+* - Proper Error prototype chain
+* - Automatic timestamp generation
+* - Serialization for RPC transmission
+* - Optional self-reporting via `report()` method
+* - Optional self-rendering via `render()` method
+*
+* Message Localization:
+* - Each error class passes an i18n key (e.g., 'errors.userNotFound') to super()
+* - `Error.message` contains the i18n key for useful stack traces and fallback display
+* - Metadata provides interpolation parameters (e.g., { userId: '123' })
+* - ExceptionHandler translates the message key using I18nService before sending response
+* - This ensures errors are localized based on the user's locale
+*/
+var ApplicationError = 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 = true;
+	/**
+	* Type-safe error code from ERROR_CODES registry
+	* See error-codes.ts for the complete registry
+	*/
+	code;
+	/**
+	* ISO timestamp when the error was created
+	*/
+	timestamp;
+	/**
+	* Additional structured data about the error
+	* Used for:
+	* 1. Logging and debugging
+	* 2. Message interpolation (e.g., { userId: '123', email: 'user@example.com' })
+	*/
+	metadata;
+	/**
+	* @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, code, metadata) {
+		super(i18nKey);
+		Object.setPrototypeOf(this, new.target.prototype);
+		this.name = this.constructor.name;
+		this.code = code;
+		this.timestamp = (/* @__PURE__ */ new Date()).toISOString();
+		this.metadata = metadata;
+		if (ApplicationError.captureStackTraces && Error.captureStackTrace) Error.captureStackTrace(this, this.constructor);
+	}
+	/**
+	* 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
+	*/
+	static filterMetadata(metadata) {
+		if (!metadata) return void 0;
+		const whitelist = [
+			"issues",
+			"fields",
+			"field"
+		];
+		const filtered = {};
+		let hasUserFacingData = false;
+		for (const key of whitelist) if (key in metadata && metadata[key] !== void 0) {
+			filtered[key] = metadata[key];
+			hasUserFacingData = true;
+		}
+		return hasUserFacingData ? filtered : void 0;
+	}
+	/**
+	* 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, translatedMessage) {
+		const message = translatedMessage ?? this.message;
+		return {
+			code: this.code,
+			message,
+			timestamp: this.timestamp,
+			metadata: ApplicationError.filterMetadata(this.metadata),
+			stack: env === "development" ? this.stack?.replace(this.message, message) : void 0
+		};
+	}
+	/**
+	* 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() {
+		return this.toErrorResponse("development");
+	}
+};
+//#endregion
+//#region src/router/router.tokens.ts
+/**
+* Dependency injection tokens for the router system
+*/
+const ROUTER_TOKENS = {
+	RouterContext: Symbol.for("stratal:router:context"),
+	RouteRegistry: Symbol.for("stratal:router:route-registry"),
+	VersioningService: Symbol.for("stratal:router:versioning-service"),
+	LocalePathService: Symbol.for("stratal:router:locale-path-service"),
+	RouterResolver: Symbol.for("stratal:router:router-resolver"),
+	HonoApp: Symbol.for("stratal:router:hono-app"),
+	Uri: Symbol.for("stratal:router:uri")
+};
+//#endregion
+//#region src/di/errors/conditional-binding-fallback.error.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
+*/
+var ConditionalBindingFallbackError = class extends ApplicationError {
+	constructor(token) {
+		super("errors.conditionalBindingFallback", ERROR_CODES.SYSTEM.INFRASTRUCTURE_ERROR, { token });
+	}
+};
+//#endregion
+//#region src/di/errors/request-scope-operation-not-allowed.error.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
+*/
+var RequestScopeOperationNotAllowedError = class extends ApplicationError {
+	constructor(methodName) {
+		super("errors.requestScopeOperationNotAllowed", ERROR_CODES.SYSTEM.INFRASTRUCTURE_ERROR, { methodName });
+	}
+};
+//#endregion
+//#region src/di/conditional-binding-builder.ts
+/**
+* Implementation of ConditionalBindingBuilder
+*
+* @internal
+*/
+var ConditionalBindingBuilderImpl = class {
+	constructor(tsyringeContainer, predicateContainer, predicate, options) {
+		this.tsyringeContainer = tsyringeContainer;
+		this.predicateContainer = predicateContainer;
+		this.predicate = predicate;
+		this.options = options;
+	}
+	use(token) {
+		return new ConditionalBindingUseImpl(this.tsyringeContainer, this.predicateContainer, this.predicate, this.options, token);
+	}
+};
+/**
+* Implementation of ConditionalBindingUse
+*
+* @internal
+*/
+var ConditionalBindingUseImpl = class {
+	constructor(tsyringeContainer, predicateContainer, predicate, options, token) {
+		this.tsyringeContainer = tsyringeContainer;
+		this.predicateContainer = predicateContainer;
+		this.predicate = predicate;
+		this.options = options;
+		this.token = token;
+	}
+	give(trueImplementation) {
+		const falseImplementation = this.getFallbackImplementation();
+		this.registerWithPredicate(trueImplementation, falseImplementation);
+		return { otherwise: (implementation) => {
+			this.registerWithPredicate(trueImplementation, implementation);
+		} };
+	}
+	/**
+	* Get fallback implementation: existing registration or throw-on-resolve class
+	*/
+	getFallbackImplementation() {
+		if (this.tsyringeContainer.isRegistered(this.token)) {
+			const existingInstance = this.tsyringeContainer.resolve(this.token);
+			return class ExistingInstanceWrapper {
+				static instance = existingInstance;
+				constructor() {
+					return ExistingInstanceWrapper.instance;
+				}
+			};
+		}
+		const tokenStr = typeof this.token === "symbol" ? this.token.description ?? "unknown" : typeof this.token === "function" ? this.token.name : String(this.token);
+		return class NoFallbackError {
+			constructor() {
+				throw new ConditionalBindingFallbackError(tokenStr);
+			}
+		};
+	}
+	registerWithPredicate(trueImplementation, falseImplementation) {
+		const { predicate, predicateContainer, options } = this;
+		this.tsyringeContainer.register(this.token, { useFactory: predicateAwareClassFactory(() => predicate(predicateContainer), trueImplementation, falseImplementation, options.cache ?? false) });
+	}
+};
+//#endregion
+//#region src/di/container.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)
+* })
+* ```
+*/
+var Container = class Container {
+	container;
+	isRequestScoped;
+	constructor(options) {
+		this.isRequestScoped = options.isRequestScoped ?? false;
+		this.container = options.container;
+		if (!this.isRequestScoped) this.container.register(CONTAINER_TOKEN, { useValue: this });
+	}
+	register(tokenOrClass, serviceClassOrScope, scope) {
+		let token;
+		let serviceClass;
+		let lifecycle;
+		if (typeof serviceClassOrScope === "function") {
+			token = tokenOrClass;
+			serviceClass = serviceClassOrScope;
+			lifecycle = scope;
+		} else {
+			token = tokenOrClass;
+			serviceClass = tokenOrClass;
+			lifecycle = serviceClassOrScope;
+		}
+		if (lifecycle !== void 0) this.container.register(token, { useClass: serviceClass }, { lifecycle });
+		else this.container.register(token, { useClass: serviceClass });
+	}
+	registerSingleton(tokenOrClass, serviceClass) {
+		if (serviceClass !== void 0) this.container.registerSingleton(tokenOrClass, serviceClass);
+		else {
+			const targetClass = tokenOrClass;
+			this.container.registerSingleton(targetClass, targetClass);
+		}
+	}
+	/**
+	* Register a value (instance) directly
+	*/
+	registerValue(token, value) {
+		this.container.register(token, { useValue: value });
+	}
+	/**
+	* Register with factory function
+	*/
+	registerFactory(token, factory) {
+		this.container.register(token, { useFactory: () => factory(this) });
+	}
+	/**
+	* Register an alias to an existing token
+	*/
+	registerExisting(alias, target) {
+		this.container.register(alias, { useToken: target });
+	}
+	/**
+	* Resolve a service from the container
+	*/
+	resolve(token) {
+		return this.container.resolve(token);
+	}
+	/**
+	* Check if a token is registered
+	*/
+	isRegistered(token) {
+		return this.container.isRegistered(token);
+	}
+	/**
+	* Start a conditional binding with predicate evaluation
+	*/
+	when(predicate, options = {}) {
+		return new ConditionalBindingBuilderImpl(this.container, this, predicate, options);
+	}
+	/**
+	* Replace a service registration with a decorated version
+	*/
+	extend(token, decorator) {
+		const decoratedInstance = decorator(this.container.resolve(token), this);
+		this.container.register(token, { useValue: decoratedInstance });
+	}
+	/**
+	* 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).
+	*/
+	async runInRequestScope(routerContext, callback) {
+		if (this.isRequestScoped) throw new RequestScopeOperationNotAllowedError("runInRequestScope");
+		const requestContainer = this.createRequestScope(routerContext);
+		try {
+			return await callback(requestContainer);
+		} finally {
+			await requestContainer.dispose();
+		}
+	}
+	/**
+	* Create request scope container
+	*
+	* Can only be called on global container (not request-scoped).
+	*/
+	createRequestScope(routerContext) {
+		if (this.isRequestScoped) throw new RequestScopeOperationNotAllowedError("createRequestScope");
+		const childContainer = this.container.createChildContainer();
+		childContainer.register(ROUTER_TOKENS.RouterContext, { useValue: routerContext });
+		return new Container({
+			container: childContainer,
+			isRequestScoped: true
+		});
+	}
+	/**
+	* Get underlying tsyringe container
+	*/
+	getTsyringeContainer() {
+		return this.container;
+	}
+	dispose() {
+		return this.container.dispose();
+	}
+};
+//#endregion
+//#region src/di/types.ts
+/**
+* DI Type Definitions
+*
+* Core type definitions for the dependency injection system.
+* Simplified after removing LazyProxy - no more type wrappers needed.
+*/
+/**
+* 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)
+* ```
+*/
+let Scope = /* @__PURE__ */ function(Scope) {
+	/** New instance per resolution (default) */
+	Scope[Scope["Transient"] = Lifecycle.Transient] = "Transient";
+	/** Single instance shared globally */
+	Scope[Scope["Singleton"] = Lifecycle.Singleton] = "Singleton";
+	/** New instance per child container (per request) */
+	Scope[Scope["Request"] = Lifecycle.ContainerScoped] = "Request";
+	return Scope;
+}({});
+//#endregion
+//#region src/errors/error-codes.ts
+/**
+* Centralized Error Code Registry
+*
+* Error codes are organized by category with specific ranges:
+* - 1000-1999: Validation errors
+* - 2000-2999: Database errors (generic)
+* - 3000-3999: Authentication & Authorization
+* - 4000-4999: Resource errors
+* - 5000-5999: Domain-specific business logic (per module)
+* - 9000-9999: System/Internal errors
+*   - 9000-9099: Router errors
+*   - 9100-9199: Configuration errors
+*   - 9200-9299: Infrastructure errors
+*   - 9300-9399: I18n errors
+*/
+const ERROR_CODES = {
+	DATABASE: {
+		GENERIC: 2e3,
+		RECORD_NOT_FOUND: 2001,
+		UNIQUE_CONSTRAINT: 2002,
+		FOREIGN_KEY_CONSTRAINT: 2003,
+		CONNECTION_FAILED: 2004,
+		TIMEOUT: 2005,
+		NULL_CONSTRAINT: 2006,
+		TOO_MANY_CONNECTIONS: 2007,
+		TRANSACTION_CONFLICT: 2008
+	},
+	AUTH: {
+		INVALID_CREDENTIALS: 3e3,
+		SESSION_EXPIRED: 3001,
+		ACCOUNT_LOCKED: 3002,
+		INVALID_TOKEN: 3003,
+		CONTEXT_NOT_INITIALIZED: 3004,
+		USER_NOT_AUTHENTICATED: 3005,
+		EMAIL_NOT_VERIFIED: 3007,
+		PASSWORD_TOO_SHORT: 3008,
+		PASSWORD_TOO_LONG: 3009,
+		ACCOUNT_ALREADY_EXISTS: 3010,
+		FAILED_TO_CREATE_USER: 3011,
+		FAILED_TO_CREATE_SESSION: 3012,
+		FAILED_TO_UPDATE_USER: 3013,
+		SOCIAL_ACCOUNT_LINKED: 3014,
+		CANNOT_UNLINK_LAST_ACCOUNT: 3015
+	},
+	AUTHZ: {
+		FORBIDDEN: 3100,
+		ACCESS_DENIED: 3101,
+		INSUFFICIENT_PERMISSIONS: 3102
+	},
+	RESOURCE: {
+		NOT_FOUND: 4e3,
+		ROUTE_NOT_FOUND: 4004,
+		CONFLICT: 4100,
+		ALREADY_EXISTS: 4101
+	},
+	VALIDATION: {
+		GENERIC: 1e3,
+		REQUIRED_FIELD: 1001,
+		INVALID_FORMAT: 1002,
+		SCHEMA_VALIDATION: 1003,
+		REQUEST_VALIDATION: 1004,
+		RESPONSE_VALIDATION: 1005
+	},
+	ROUTER: {
+		CONTROLLER_REGISTRATION_ERROR: 9005,
+		CONTROLLER_METHOD_NOT_FOUND: 9006,
+		OPENAPI_ROUTE_REGISTRATION: 9008,
+		DUPLICATE_ROUTE_NAME: 9010,
+		ROUTE_NAME_NOT_FOUND: 9011,
+		MISSING_ROUTE_PARAM: 9012,
+		USE_SCOPE_VIOLATION: 9013
+	},
+	I18N: {
+		TRANSLATION_MISSING: 9300,
+		LOCALE_NOT_SUPPORTED: 9301
+	},
+	SYSTEM: {
+		INTERNAL_ERROR: 9e3,
+		CONFIGURATION_ERROR: 9100,
+		CONFIG_NOT_INITIALIZED: 9101,
+		MODULE_ALREADY_REGISTERED: 9102,
+		MODULE_CIRCULAR_DEPENDENCY: 9103,
+		MODULE_DEPENDENCY_NOT_FOUND: 9104,
+		INVALID_ERROR_CODE_RANGE: 9105,
+		INVALID_MODULE_PROVIDER: 9106,
+		CONFIG_MODULE_NOT_INITIALIZED: 9107,
+		INFRASTRUCTURE_ERROR: 9200,
+		EXECUTION_CONTEXT_NOT_INITIALIZED: 9201,
+		REQUEST_CONTAINER_NOT_INITIALIZED: 9202,
+		QUEUE_BINDING_NOT_FOUND: 9203,
+		CRON_EXECUTION_FAILED: 9204,
+		QUEUE_PROVIDER_NOT_SUPPORTED: 9205,
+		WEBSOCKET_BODY_NOT_AVAILABLE: 9206,
+		WEBSOCKET_DUPLICATE_EVENT_HANDLER: 9207,
+		SEEDER_NAME_COLLISION: 9208,
+		SEEDER_NOT_REGISTERED: 9209,
+		CONTAINER_NOT_INITIALIZED: 9210,
+		MISSING_ENVIRONMENT_VARIABLE: 9211
+	}
+};
+//#endregion
+//#region src/errors/container-not-initialized.error.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.
+*/
+var ContainerNotInitializedError = class extends ApplicationError {
+	constructor() {
+		super("errors.containerNotInitialized", ERROR_CODES.SYSTEM.CONTAINER_NOT_INITIALIZED);
+	}
+};
+//#endregion
+//#region src/di/container-storage.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`.
+*/
+const containerStorage = new AsyncLocalStorage();
+/**
+* Get the application container from AsyncLocalStorage.
+*
+* @throws ContainerNotInitializedError if called outside `Application.initialize()` scope
+*/
+function getContainer() {
+	const container = containerStorage.getStore();
+	if (!container) throw new ContainerNotInitializedError();
+	return container;
+}
+/**
+* Run a function within a container context.
+*
+* @param container - The application container to store
+* @param fn - The function to execute with container access
+*/
+function runWithContainer(container, fn) {
+	return containerStorage.run(container, fn);
+}
+//#endregion
+//#region src/i18n/i18n.tokens.ts
+/**
+* I18n Module DI Tokens
+* Symbol-based tokens to avoid string collisions
+*/
+const I18N_TOKENS = {
+	MessageLoader: Symbol.for("stratal:i18n:message:loader"),
+	I18nService: Symbol.for("stratal:i18n:service"),
+	Options: Symbol.for("stratal:i18n:options"),
+	MessageRegistry: Symbol.for("stratal:i18n:message:registry")
+};
+//#endregion
+//#region src/errors/http-exception.ts
+/**
+* Maps common HTTP status codes to their default error codes.
+* Used by {@link HttpException} to derive the error code automatically.
+*/
+const HTTP_STATUS_TO_ERROR_CODE = {
+	400: ERROR_CODES.VALIDATION.GENERIC,
+	401: ERROR_CODES.AUTH.USER_NOT_AUTHENTICATED,
+	403: ERROR_CODES.AUTHZ.FORBIDDEN,
+	404: ERROR_CODES.RESOURCE.NOT_FOUND,
+	409: ERROR_CODES.RESOURCE.CONFLICT,
+	422: ERROR_CODES.VALIDATION.GENERIC,
+	500: ERROR_CODES.SYSTEM.INTERNAL_ERROR
+};
+/**
+* Default human-readable messages for common HTTP status codes.
+* Used as fallback when no message is provided to {@link HttpException}.
+*/
+const HTTP_STATUS_MESSAGES = {
+	400: "Bad Request",
+	401: "Unauthorized",
+	403: "Forbidden",
+	404: "Not Found",
+	409: "Conflict",
+	422: "Unprocessable Entity",
+	500: "Internal Server Error"
+};
+/**
+* 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')
+*   }
+* }
+* ```
+*/
+var HttpException = class extends ApplicationError {
+	/**
+	* The HTTP status code for this exception.
+	* Used by the {@link ExceptionHandler} to set the response status.
+	*/
+	httpStatus;
+	/**
+	* @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, message) {
+		const code = HTTP_STATUS_TO_ERROR_CODE[httpStatus] ?? ERROR_CODES.SYSTEM.INTERNAL_ERROR;
+		const messageStr = message ?? HTTP_STATUS_MESSAGES[httpStatus] ?? "Internal Server Error";
+		super(messageStr, code);
+		this.httpStatus = httpStatus;
+	}
+};
+/**
+* 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')
+* ```
+*/
+function abort(status, message) {
+	throw new HttpException(status, message);
+}
+//#endregion
+//#region src/errors/get-http-status.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)
+*/
+function getHttpStatus(code) {
+	if (code >= 1e3 && code < 2e3) return 400;
+	if (code >= 2e3 && code < 3e3) {
+		if (code === ERROR_CODES.DATABASE.RECORD_NOT_FOUND) return 404;
+		if (code === ERROR_CODES.DATABASE.UNIQUE_CONSTRAINT) return 409;
+		return 500;
+	}
+	if (code >= 3e3 && code < 3100) return 401;
+	if (code >= 3100 && code < 3200) return 403;
+	if (code >= 4e3 && code < 4100) return 404;
+	if (code >= 4100 && code < 4200) return 409;
+	if (code >= 5e3 && code < 6e3) {
+		if (code === 5e3 || code === 5100 || code === 5200) return 404;
+		return 422;
+	}
+	if (code >= 9e3) return 500;
+	return 500;
+}
+/**
+* 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
+*/
+function resolveHttpStatus(error) {
+	if (error instanceof HttpException) return error.httpStatus;
+	return getHttpStatus(error.code);
+}
+//#endregion
+//#region src/errors/internal-error.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
+*/
+var InternalError = class extends ApplicationError {
+	constructor(metadata) {
+		super("errors.internalError", ERROR_CODES.SYSTEM.INTERNAL_ERROR, metadata);
+	}
+};
+//#endregion
+//#region src/errors/is-application-error.ts
+/**
+* Type guard to check if an error is an ApplicationError
+*
+* @param error - The error to check
+* @returns True if the error is an ApplicationError instance
+*/
+function isApplicationError(error) {
+	return error instanceof ApplicationError;
+}
+//#endregion
+//#region src/errors/exception-handler.ts
+let ExceptionHandler = class ExceptionHandler {
+	reportables = [];
+	renderables = [];
+	dontReportSet = /* @__PURE__ */ new Set();
+	levelOverrides = /* @__PURE__ */ new Map();
+	contextCallbacks = [];
+	respondCallbacks = [];
+	environment;
+	constructor(logger, env, container, executionContext) {
+		this.logger = logger;
+		this.env = env;
+		this.container = container;
+		this.executionContext = executionContext;
+		this.environment = this.env.ENVIRONMENT;
+	}
+	/**
+	* 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(errorClass, callback) {
+		const entry = {
+			errorClass,
+			callback,
+			shouldStop: false
+		};
+		this.reportables.push(entry);
+		return { stop: () => {
+			entry.shouldStop = true;
+		} };
+	}
+	/**
+	* 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(errorClass, callback) {
+		this.renderables.push({
+			errorClass,
+			callback
+		});
+	}
+	/**
+	* 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) {
+		for (const cls of errorClasses) this.dontReportSet.add(cls);
+	}
+	/**
+	* 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, severity) {
+		this.levelOverrides.set(errorClass, severity);
+	}
+	/**
+	* 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) {
+		this.contextCallbacks.push(callback);
+	}
+	/**
+	* 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) {
+		this.respondCallbacks.push(callback);
+	}
+	/**
+	* 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(token) {
+		return this.container.resolve(token);
+	}
+	/**
+	* 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)
+	*/
+	async handle(error, context) {
+		const appError = this.normalizeError(error);
+		this.executionContext.waitUntil(this.performReport(appError, context));
+		const response = await this.performRender(appError, context);
+		return this.applyRespondCallbacks(response, appError, context);
+	}
+	/**
+	* Normalize an unknown error into an ApplicationError.
+	* Non-ApplicationError values are wrapped in InternalError.
+	*/
+	normalizeError(error) {
+		if (isApplicationError(error)) return error;
+		const originalMessage = error instanceof Error ? error.message : String(error);
+		const internalError = new InternalError({
+			originalError: originalMessage,
+			stack: error instanceof Error ? error.stack : void 0
+		});
+		if (this.environment === "development") {
+			internalError.message = originalMessage;
+			if (error instanceof Error && error.stack) internalError.stack = error.stack;
+		}
+		return internalError;
+	}
+	/**
+	* Run the reporting pipeline for an error.
+	*/
+	async performReport(error, context) {
+		if (typeof error.report === "function") {
+			if (error.report() !== false) return;
+		}
+		if (this.shouldNotReport(error)) return;
+		const entry = this.findReportable(error);
+		if (entry) {
+			await entry.callback(error, context);
+			if (entry.shouldStop) return;
+		}
+		this.defaultReport(error, context);
+	}
+	/**
+	* Run the rendering pipeline for an error, producing a Response.
+	*/
+	async performRender(error, context) {
+		if (typeof error.render === "function") {
+			const result = error.render(context);
+			if (result !== void 0) return this.toResponse(result, error);
+		}
+		const entry = this.findRenderable(error);
+		if (entry) {
+			const result = entry.callback(error, context);
+			if (result !== void 0) return this.toResponse(await result, error);
+		}
+		return this.defaultRender(error, context);
+	}
+	/**
+	* Apply all respond() callbacks to post-process a Response.
+	*/
+	applyRespondCallbacks(response, error, context) {
+		let result = response;
+		for (const callback of this.respondCallbacks) result = callback(result, error, context);
+		return result;
+	}
+	/**
+	* Check if an error is in the dontReport set.
+	*/
+	shouldNotReport(error) {
+		for (const cls of this.dontReportSet) if (error instanceof cls) return true;
+		return false;
+	}
+	/**
+	* Find the most-specific reportable entry for an error.
+	* Walks entries in registration order; picks the most-specific `instanceof` match.
+	*/
+	findReportable(error) {
+		let best;
+		for (const entry of this.reportables) if (error instanceof entry.errorClass) {
+			if (!best || !(error instanceof best.errorClass) || entry.errorClass.prototype instanceof best.errorClass) best = entry;
+		}
+		return best;
+	}
+	/**
+	* Find the most-specific renderable entry for an error.
+	*/
+	findRenderable(error) {
+		let best;
+		for (const entry of this.renderables) if (error instanceof entry.errorClass) {
+			if (!best || !(error instanceof best.errorClass) || entry.errorClass.prototype instanceof best.errorClass) best = entry;
+		}
+		return best;
+	}
+	/**
+	* Default reporting — log with appropriate severity and i18n translation.
+	*/
+	defaultReport(error, context) {
+		const translatedMessage = this.translateError(error, context);
+		const severity = this.resolveSeverity(error);
+		const globalContext = this.gatherContext();
+		const logData = {
+			code: error.code,
+			message: translatedMessage,
+			timestamp: error.timestamp,
+			metadata: error.metadata,
+			name: error.name,
+			...globalContext
+		};
+		switch (severity) {
+			case "debug":
+				this.logger.debug("[ApplicationError]", logData);
+				break;
+			case "info":
+				this.logger.info("[ApplicationError]", logData);
+				break;
+			case "warn":
+				this.logger.warn("[ApplicationError]", logData);
+				break;
+			case "error":
+				this.logger.error("[ApplicationError]", logData);
+				break;
+		}
+	}
+	/**
+	* 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.
+	*/
+	defaultRender(error, context) {
+		const translatedMessage = this.translateError(error, context);
+		const errorResponse = error.toErrorResponse(this.environment, translatedMessage);
+		const status = resolveHttpStatus(error);
+		if (context.type === "http" && this.wantsHtml(context)) return this.renderDefaultHtml(errorResponse, status);
+		return Response.json(errorResponse, { status });
+	}
+	/**
+	* 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.
+	*/
+	wantsHtml(context) {
+		return (context.ctx.c.req.header("accept") ?? "").includes("text/html");
+	}
+	/**
+	* Minimal production HTML error page with inline styles.
+	*/
+	renderDefaultHtml(errorResponse, status) {
+		const title = this.escapeHtml(errorResponse.message);
+		const html = `<!DOCTYPE html>
+<html lang="en"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1">
+<title>${status} - ${title}</title>
+<style>*{margin:0;padding:0;box-sizing:border-box}body{font-family:system-ui,-apple-system,sans-serif;min-height:100vh;display:flex;align-items:center;justify-content:center;background:#f8fafc;color:#334155}.container{text-align:center;padding:2rem}.status{font-size:6rem;font-weight:800;color:#13c397;line-height:1}.message{font-size:1.25rem;color:#64748b;margin-top:1rem}</style>
+</head><body><div class="container"><div class="status">${status}</div><div class="message">${title}</div></div></body></html>`;
+		return new Response(html, {
+			status,
+			headers: { "content-type": "text/html; charset=utf-8" }
+		});
+	}
+	escapeHtml(str) {
+		return str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+	}
+	/**
+	* Convert a render result (Response or ErrorResponse) into a Response.
+	*/
+	toResponse(result, error) {
+		if (result instanceof Response) return result;
+		const status = resolveHttpStatus(error);
+		return Response.json(result, { status });
+	}
+	/**
+	* 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.
+	*/
+	translateError(error, context) {
+		try {
+			const i18n = (context.type === "http" ? context.ctx.getContainer() : this.container).resolve(I18N_TOKENS.I18nService);
+			const params = error.metadata;
+			return i18n.t(error.message, params);
+		} catch {
+			return error.message;
+		}
+	}
+	/**
+	* Resolve the log severity for an error.
+	* Checks level overrides first, then falls back to code-range-based severity.
+	*/
+	resolveSeverity(error) {
+		let bestClass;
+		let bestSeverity;
+		for (const [cls, severity] of this.levelOverrides) if (error instanceof cls) {
+			if (!bestClass || cls.prototype instanceof bestClass) {
+				bestClass = cls;
+				bestSeverity = severity;
+			}
+		}
+		return bestSeverity ?? this.getDefaultSeverity(error.code);
+	}
+	/**
+	* Determine default log severity based on error code range.
+	*/
+	getDefaultSeverity(code) {
+		if (code >= 9e3) return "error";
+		if (code >= 2e3 && code < 3e3) return "error";
+		if (code >= 5e3 && code < 6e3) return "warn";
+		if (code >= 1e3 && code < 2e3) return "info";
+		if (code >= 3e3 && code < 5e3) return "warn";
+		return "error";
+	}
+	/**
+	* Gather all global context data from registered callbacks.
+	*/
+	gatherContext() {
+		if (this.contextCallbacks.length === 0) return {};
+		const merged = {};
+		for (const callback of this.contextCallbacks) Object.assign(merged, callback());
+		return merged;
+	}
+};
+ExceptionHandler = __decorate([
+	Transient(),
+	__decorateParam(0, inject(LOGGER_TOKENS.LoggerService)),
+	__decorateParam(1, inject(DI_TOKENS.CloudflareEnv)),
+	__decorateParam(2, inject(CONTAINER_TOKEN)),
+	__decorateParam(3, inject(DI_TOKENS.ExecutionContext)),
+	__decorateMetadata("design:paramtypes", [
+		Object,
+		Object,
+		Object,
+		Object
+	])
+], ExceptionHandler);
+//#endregion
+//#region src/errors/default-exception-handler.ts
+let DefaultExceptionHandler = class DefaultExceptionHandler extends ExceptionHandler {
+	register() {}
+};
+DefaultExceptionHandler = __decorate([Transient()], DefaultExceptionHandler);
+//#endregion
+//#region src/errors/error-response.ts
+/**
+* Type guard to check if an object is an ErrorResponse
+*/
+function isErrorResponse(obj) {
+	return typeof obj === "object" && obj !== null && "code" in obj && typeof obj.code === "number" && "message" in obj && typeof obj.message === "string" && "timestamp" in obj && typeof obj.timestamp === "string";
+}
+//#endregion
+//#region src/router/constants.ts
+/**
+* Type-safe context keys for Hono router variables
+* Using symbols to avoid string collisions
+*/
+const ROUTER_CONTEXT_KEYS = {
+	REQUEST_CONTAINER: "requestContainer",
+	LOCALE: "locale"
+};
+/**
+* Metadata keys for storing route and controller configuration
+* Using symbols to avoid collisions with other decorators
+*/
+const ROUTE_METADATA_KEYS = {
+	CONTROLLER_ROUTE: Symbol.for("stratal:controller:route"),
+	CONTROLLER_OPTIONS: Symbol.for("stratal:controller:options"),
+	CONTROLLER_MIDDLEWARES: Symbol.for("stratal:controller:middlewares"),
+	ROUTE_CONFIG: Symbol.for("stratal:route:config"),
+	DECORATED_METHODS: Symbol.for("stratal:decorated:methods"),
+	AUTH_GUARD: Symbol.for("stratal:auth:guard"),
+	GATEWAY_MARKER: Symbol.for("stratal:gateway:marker"),
+	WS_ON_MESSAGE: Symbol.for("stratal:ws:on-message"),
+	WS_ON_CLOSE: Symbol.for("stratal:ws:on-close"),
+	WS_ON_ERROR: Symbol.for("stratal:ws:on-error")
+};
+/**
+* Security scheme identifiers for OpenAPI
+* These reference the security scheme definitions in security.schemas.ts
+*/
+const SECURITY_SCHEMES = {
+	BEARER_AUTH: "bearerAuth",
+	API_KEY: "apiKey",
+	SESSION_COOKIE: "sessionCookie"
+};
+/**
+* HTTP method mapping for RESTful controller methods
+* Maps controller method names to HTTP verbs and path patterns
+*/
+const HTTP_METHODS = {
+	index: {
+		method: "get",
+		path: ""
+	},
+	show: {
+		method: "get",
+		path: "/:id"
+	},
+	create: {
+		method: "post",
+		path: ""
+	},
+	update: {
+		method: "put",
+		path: "/:id"
+	},
+	patch: {
+		method: "patch",
+		path: "/:id"
+	},
+	destroy: {
+		method: "delete",
+		path: "/:id"
+	}
+};
+/**
+* Default success status codes for RESTful controller methods
+* Used by @Route() decorator to auto-derive response status
+*/
+const METHOD_STATUS_CODES = {
+	index: 200,
+	show: 200,
+	create: 201,
+	update: 200,
+	patch: 200,
+	destroy: 200
+};
+/**
+* Sentinel symbol to opt a controller out of versioning.
+* When used as the version, no prefix is applied even when defaultVersion is set.
+*/
+const VERSION_NEUTRAL = Symbol.for("stratal:version:neutral");
+/**
+* Default content type for request bodies and responses
+*/
+const DEFAULT_CONTENT_TYPE = "application/json";
+//#endregion
+//#region src/router/router-context.ts
+/**
+* Router context wrapper with helper methods
+*
+* Provides convenient access to Hono's context and common request/response operations.
+* The native Hono context is available via the `c` property for advanced use cases.
+*
+* @example
+* ```typescript
+* async index(ctx: RouterContext): Promise<Response> {
+*   // Use helper methods
+*   const users = await this.service.findAll()
+*   return ctx.json(users)
+* }
+*
+* async show(ctx: RouterContext): Promise<Response> {
+*   // Access route params
+*   const id = ctx.param('id')
+*   const user = await this.service.findById(id)
+*   return ctx.json(user)
+* }
+*
+* async create(ctx: RouterContext): Promise<Response> {
+*   // Parse request body
+*   const body = await ctx.body<CreateUserInput>()
+*   const user = await this.service.create(body)
+*   return ctx.json(user, 201)
+* }
+* ```
+*/
+var RouterContext = class {
+	/**
+	* Native Hono context
+	* Access for advanced use cases not covered by helper methods
+	*/
+	constructor(c) {
+		this.c = c;
+	}
+	/**
+	* Get request-scoped DI container
+	* Contains request-specific services and context (AuthContext)
+	*
+	* @throws Error if container not initialized
+	*/
+	getContainer() {
+		const container = this.c.get(ROUTER_CONTEXT_KEYS.REQUEST_CONTAINER);
+		if (!container) throw new RequestContainerNotInitializedError();
+		return container;
+	}
+	/**
+	* Set locale for the current request
+	*
+	* @param locale - Locale code (e.g., 'en', 'fr')
+	*/
+	setLocale(locale) {
+		this.c.set(ROUTER_CONTEXT_KEYS.LOCALE, locale);
+	}
+	/**
+	* Get locale for the current request
+	*
+	* @returns Current locale code
+	*/
+	getLocale() {
+		return this.c.get(ROUTER_CONTEXT_KEYS.LOCALE) || "en";
+	}
+	/**
+	* Return JSON response
+	*
+	* When data is null, automatically returns 204 No Content (configurable via status param).
+	*
+	* @param data - Data to serialize as JSON, or null for 204
+	* @param status - HTTP status code (default: 200, or 204 when data is null)
+	*/
+	json(data, status) {
+		if (data === null) return this.c.body(null, status ?? 204);
+		return this.c.json(data, status);
+	}
+	/**
+	* Get route parameter value
+	*
+	* @param key - Parameter name (e.g., 'id' for /users/:id)
+	*/
+	param(key) {
+		return this.c.req.valid("param")[key];
+	}
+	/**
+	* Get query parameter value
+	*
+	* @param key - Query parameter name
+	*/
+	query(key) {
+		const validated = this.c.req.valid("query");
+		return key ? validated[key] : validated;
+	}
+	/**
+	* Get request header value
+	*
+	* @param name - Header name (case-insensitive)
+	*/
+	header(name) {
+		return this.c.req.header(name);
+	}
+	/**
+	* Get validated request body from OpenAPI route
+	* Returns pre-validated data that has passed schema validation
+	*
+	* @returns Validated JSON body
+	*/
+	body() {
+		return this.c.req.valid("json");
+	}
+	/**
+	* Return text response
+	*
+	* @param text - Text content
+	* @param status - HTTP status code (default: 200)
+	*/
+	text(text, status) {
+		return this.c.text(text, status);
+	}
+	/**
+	* Return HTML response
+	*
+	* @param html - HTML content
+	* @param status - HTTP status code (default: 200)
+	*/
+	html(html, status) {
+		return this.c.html(html, status);
+	}
+	/**
+	* Generate a URL from a named route.
+	*
+	* Keys matching `:param` placeholders fill the path.
+	* Domain params are consumed from the same object.
+	* Extra keys become query string parameters.
+	*
+	* @param name - Named route identifier
+	* @param params - Route params + domain params + extra query params
+	* @param options - URL generation options (e.g., `{ absolute: true }`)
+	*
+	* @example
+	* ```typescript
+	* ctx.route('users.show', { id: '1' })           // '/v1/users/1'
+	* ctx.route('users.show', { id: '1', q: 'test' }) // '/v1/users/1?q=test'
+	* ```
+	*/
+	route(name, params, options) {
+		return this.resolveUri().route(name, params, options);
+	}
+	/**
+	* Get a domain parameter value from the current request.
+	* Domain params are set by the domain matching middleware.
+	*
+	* @param key - Domain parameter name (e.g., 'tenant' from '{tenant}.myapp.com')
+	*
+	* @example
+	* ```typescript
+	* const tenant = ctx.domain('tenant')
+	* ```
+	*/
+	domain(key) {
+		return this.c.get(`domain:${key}`);
+	}
+	/**
+	* Generate a signed URL from a named route.
+	*
+	* @param name - Named route identifier
+	* @param params - Route params (same as route())
+	* @param options - Signing options (e.g., expiresIn) and URL options
+	* @returns Signed URL string with signature query param
+	*/
+	async signedUrl(name, params, options) {
+		return this.resolveUri().signedRoute(name, params, options);
+	}
+	/**
+	* Check if the current request has a valid signature.
+	*
+	* @returns true if the URL signature is valid and not expired
+	*/
+	async hasValidSignature() {
+		return this.resolveUri().hasValidSignature();
+	}
+	/**
+	* Redirect to another URL
+	*
+	* @param url - Target URL
+	* @param status - HTTP status code (default: 302)
+	*/
+	redirect(url, status) {
+		return this.c.redirect(url, status);
+	}
+	/**
+	* Return a streaming response (binary/generic)
+	*
+	* @param callback - Async function that writes to the stream
+	* @param onError - Optional error handler called if an error occurs during streaming
+	*/
+	stream(callback, onError) {
+		return stream(this.c, callback, onError);
+	}
+	/**
+	* Return a streaming text response
+	*
+	* Automatically sets `Content-Encoding: Identity` for Cloudflare Workers compatibility.
+	*
+	* @param callback - Async function that writes text to the stream
+	* @param onError - Optional error handler called if an error occurs during streaming
+	*/
+	streamText(callback, onError) {
+		this.c.header("Content-Encoding", "Identity");
+		return streamText(this.c, callback, onError);
+	}
+	/**
+	* Return a Server-Sent Events (SSE) streaming response
+	*
+	* Automatically sets `Content-Encoding: Identity` for Cloudflare Workers compatibility.
+	*
+	* @param callback - Async function that writes SSE events to the stream
+	* @param onError - Optional error handler called if an error occurs during streaming
+	*/
+	streamSSE(callback, onError) {
+		this.c.header("Content-Encoding", "Identity");
+		return streamSSE(this.c, callback, onError);
+	}
+	resolveUri() {
+		return this.getContainer().resolve(ROUTER_TOKENS.Uri);
+	}
+};
+//#endregion
+//#region src/errors/exception-context.ts
+/**
+* Create an HTTP exception context from a Hono context.
+*
+* @param c - The raw Hono context from the request
+* @returns An {@link HttpExceptionContext} wrapping a RouterContext
+*/
+function createHttpExceptionContext(c) {
+	return {
+		type: "http",
+		ctx: new RouterContext(c)
+	};
+}
+/**
+* Create a queue exception context.
+*
+* @param queueName - The name of the queue being processed
+* @returns A {@link QueueExceptionContext}
+*/
+function createQueueExceptionContext(queueName) {
+	return {
+		type: "queue",
+		queueName
+	};
+}
+/**
+* Create a cron exception context.
+*
+* @returns A {@link CronExceptionContext}
+*/
+function createCronExceptionContext() {
+	return { type: "cron" };
+}
+/**
+* Create a CLI command exception context.
+*
+* @param commandName - The name of the command that threw
+* @returns A {@link CliExceptionContext}
+*/
+function createCliExceptionContext(commandName) {
+	return {
+		type: "cli",
+		commandName
+	};
+}
+//#endregion
+//#region src/errors/request-container-not-initialized.error.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.
+*/
+var RequestContainerNotInitializedError = class extends ApplicationError {
+	constructor() {
+		super("errors.requestContainerNotInitialized", ERROR_CODES.SYSTEM.REQUEST_CONTAINER_NOT_INITIALIZED);
+	}
+};
+//#endregion
+//#region src/errors/stratal-not-initialized.error.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.
+*/
+var StratalNotInitializedError = class extends ApplicationError {
+	constructor() {
+		super("errors.stratalNotInitialized", ERROR_CODES.SYSTEM.INFRASTRUCTURE_ERROR);
+	}
+};
+//#endregion
+export { Scope as A, ConditionalBindingFallbackError as B, abort as C, runWithContainer as D, getContainer as E, injectable$1 as F, ApplicationError as H, instancePerContainerCachingFactory$1 as I, singleton as L, container$1 as M, delay as N, ContainerNotInitializedError as O, inject$1 as P, ConditionalBindingBuilderImpl as R, HttpException as S, containerStorage as T, ROUTER_TOKENS as V, ExceptionHandler as _, createHttpExceptionContext as a, getHttpStatus as b, DEFAULT_CONTENT_TYPE as c, ROUTER_CONTEXT_KEYS as d, ROUTE_METADATA_KEYS as f, DefaultExceptionHandler as g, isErrorResponse as h, createCronExceptionContext as i, Container as j, ERROR_CODES as k, HTTP_METHODS as l, VERSION_NEUTRAL as m, RequestContainerNotInitializedError as n, createQueueExceptionContext as o, SECURITY_SCHEMES as p, createCliExceptionContext as r, RouterContext as s, StratalNotInitializedError as t, METHOD_STATUS_CODES as u, isApplicationError as v, I18N_TOKENS as w, resolveHttpStatus as x, InternalError as y, RequestScopeOperationNotAllowedError as z };
+
+//# sourceMappingURL=errors--RBIvDXr.mjs.map