stratal 0.0.13 → 0.0.14

package/dist/errors-BRJgVd5-.mjs

@@ -0,0 +1,704 @@
+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-Bg-CuidS.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
+	}
+};
+//#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")
+};
+//#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-BRJgVd5-.mjs.map