stratal 0.0.17 → 0.0.19

package/dist/errors-DSKapqD8.mjs

@@ -1,707 +0,0 @@
-import { a as __decorate, d as Transient, g as DI_TOKENS, h as CONTAINER_TOKEN, o as __decorateParam, s as __decorateMetadata, u as LOGGER_TOKENS } from "./logger-CGT91VY6.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";
-//#region src/errors/application-error.ts
-/**
-* ApplicationError
-*
-* Abstract base class for all application errors.
-* This class should never be used directly - always extend it to create specific error types.
-*
-* Features:
-* - Type-safe error codes from ERROR_CODES registry
-* - Type-safe message keys from i18n module
-* - Localized message keys (translated by GlobalErrorHandler)
-* - Structured metadata for logging and interpolation
-* - Proper Error prototype chain
-* - Automatic timestamp generation
-* - Serialization for RPC transmission
-*
-* 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' })
-* - GlobalErrorHandler translates the message key using I18nService before sending response
-* - This ensures errors are localized based on the user's locale (from X-Locale header)
-*/
-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 GlobalErrorHandler)
-	* @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 GlobalErrorHandler for proper localization
-	*/
-	toJSON() {
-		return this.toErrorResponse("development");
-	}
-};
-//#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/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
-	},
-	ROUTER: {
-		CONTROLLER_REGISTRATION_ERROR: 9005,
-		CONTROLLER_METHOD_NOT_FOUND: 9006,
-		OPENAPI_ROUTE_REGISTRATION: 9008
-	},
-	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
-	}
-};
-//#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;
-}
-//#endregion
-//#region src/router/router.tokens.ts
-/**
-* Dependency injection tokens for the router system
-*/
-const ROUTER_TOKENS = { RouterContext: Symbol.for("stratal:router:context") };
-//#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/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/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/global-error-handler.ts
-let GlobalErrorHandler = class GlobalErrorHandler {
-	environment;
-	constructor(logger, i18n, env) {
-		this.logger = logger;
-		this.i18n = i18n;
-		this.env = env;
-		this.environment = this.env.ENVIRONMENT;
-	}
-	/**
-	* Handle an error, log it, and serialize for response
-	*
-	* @param error - The error to handle
-	* @returns Serialized ErrorResponse for RPC transmission
-	*/
-	handle(error) {
-		if (isApplicationError(error)) {
-			const translatedMessage = this.translateError(error);
-			this.log(error, translatedMessage);
-			return error.toErrorResponse(this.environment, translatedMessage);
-		}
-		this.logUnexpectedError(error);
-		const internalError = new InternalError({
-			originalError: error instanceof Error ? error.message : String(error),
-			stack: error instanceof Error ? error.stack : void 0
-		});
-		const translatedMessage = this.translateError(internalError);
-		return internalError.toErrorResponse(this.environment, translatedMessage);
-	}
-	/**
-	* Translate error message key using I18nService
-	* Uses error metadata as interpolation parameters
-	*
-	* No try/catch - if translation fails, it's a bug that should fail loudly
-	*
-	* **Note**: This method is only called when isAvailable() returns true,
-	* so the service is guaranteed to be resolved.
-	*
-	* @param error - ApplicationError with messageKey and metadata
-	* @returns Translated message string
-	*/
-	translateError(error) {
-		const params = error.metadata;
-		return this.i18n.t(error.message, params);
-	}
-	/**
-	* Log an ApplicationError with appropriate severity
-	*/
-	log(error, translatedMessage) {
-		const severity = this.getSeverity(error.code);
-		const logData = {
-			code: error.code,
-			message: translatedMessage,
-			timestamp: error.timestamp,
-			metadata: error.metadata,
-			name: error.name
-		};
-		switch (severity) {
-			case "error":
-				this.logger.error("[ApplicationError]", logData);
-				break;
-			case "warn":
-				this.logger.warn("[ApplicationError]", logData);
-				break;
-			case "info":
-				this.logger.info("[ApplicationError]", logData);
-				break;
-		}
-	}
-	/**
-	* Log an unexpected error
-	*/
-	logUnexpectedError(error) {
-		this.logger.error("[UnexpectedError]", {
-			error: error instanceof Error ? {
-				message: error.message,
-				stack: error.stack,
-				name: error.name
-			} : String(error),
-			timestamp: (/* @__PURE__ */ new Date()).toISOString()
-		});
-	}
-	/**
-	* Determine log severity based on error code
-	*/
-	getSeverity(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";
-	}
-};
-GlobalErrorHandler = __decorate([
-	Transient(),
-	__decorateParam(0, inject(LOGGER_TOKENS.LoggerService)),
-	__decorateParam(1, inject(I18N_TOKENS.I18nService)),
-	__decorateParam(2, inject(DI_TOKENS.CloudflareEnv)),
-	__decorateMetadata("design:paramtypes", [
-		Object,
-		Object,
-		Object
-	])
-], GlobalErrorHandler);
-//#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 { ApplicationError as S, ConditionalBindingFallbackError as _, InternalError as a, ERROR_CODES as b, Container as c, inject$1 as d, injectable$1 as f, RequestScopeOperationNotAllowedError as g, ConditionalBindingBuilderImpl as h, isApplicationError as i, container$1 as l, singleton as m, RequestContainerNotInitializedError as n, I18N_TOKENS as o, instancePerContainerCachingFactory$1 as p, GlobalErrorHandler as r, Scope as s, StratalNotInitializedError as t, delay as u, ROUTER_TOKENS as v, isErrorResponse as x, getHttpStatus as y };
-
-//# sourceMappingURL=errors-DSKapqD8.mjs.map