stratal 0.0.21 → 0.0.23

package/dist/{guards-DU1_J9YA.mjs → guards-DALPXy3_.mjs}

@@ -1,3 +1,4 @@
+import { n as getMetadata, t as defineMetadata } from "./metadata-DzzprcID.mjs";
 //#region src/guards/types.ts
 /**
 * Metadata key for guard storage
@@ -63,8 +64,8 @@ const GUARD_METADATA_KEY = Symbol.for("stratal:guards");
 function UseGuards(...guards) {
 	return (target, propertyKey) => {
 		const metadata = { guards };
-		if (propertyKey !== void 0) Reflect.defineMetadata(GUARD_METADATA_KEY, metadata, target, propertyKey);
-		else Reflect.defineMetadata(GUARD_METADATA_KEY, metadata, target);
+		if (propertyKey !== void 0) defineMetadata(GUARD_METADATA_KEY, metadata, target, propertyKey);
+		else defineMetadata(GUARD_METADATA_KEY, metadata, target);
 	};
 }
 /**
@@ -74,7 +75,7 @@ function UseGuards(...guards) {
 * @returns Guard metadata or undefined if not decorated
 */
 function getControllerGuards(target) {
-	return Reflect.getMetadata(GUARD_METADATA_KEY, target);
+	return getMetadata(GUARD_METADATA_KEY, target);
 }
 /**
 * Get method-level guard metadata
@@ -84,7 +85,7 @@ function getControllerGuards(target) {
 * @returns Guard metadata or undefined if not decorated
 */
 function getMethodGuards(target, propertyKey) {
-	return Reflect.getMetadata(GUARD_METADATA_KEY, target, propertyKey);
+	return getMetadata(GUARD_METADATA_KEY, target, propertyKey);
 }
 //#endregion
 //#region src/guards/guard-execution.service.ts
@@ -149,4 +150,4 @@ var GuardExecutionService = class {
 //#endregion
 export { GUARD_METADATA_KEY as a, getMethodGuards as i, UseGuards as n, getControllerGuards as r, GuardExecutionService as t };
 
-//# sourceMappingURL=guards-DU1_J9YA.mjs.map
+//# sourceMappingURL=guards-DALPXy3_.mjs.map

package/dist/guards-DALPXy3_.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"guards-DALPXy3_.mjs","names":[],"sources":["../src/guards/types.ts","../src/guards/use-guards.decorator.ts","../src/guards/guard-execution.service.ts"],"sourcesContent":["import type { RouterContext } from '../router'\nimport type { Constructor } from '../types'\n\n/**\n * Interface for guards that control access to routes\n *\n * Guards are executed after middlewares but before route handlers.\n * They determine if a request should be allowed to proceed.\n *\n * @example\n * ```typescript\n * class RoleGuard implements CanActivate {\n *   constructor(private readonly role: string) {}\n *\n *   async canActivate(context: RouterContext): Promise<boolean> {\n *     const user = context.getUser()\n *     return user?.roles.includes(this.role) ?? false\n *   }\n * }\n * ```\n */\nexport interface CanActivate {\n  /**\n   * Determine if the request should be allowed\n   *\n   * @param context - Router context with request/response helpers\n   * @returns true to allow, false to deny (throws 403)\n   */\n  canActivate(context: RouterContext): boolean | Promise<boolean>\n}\n\n/**\n * Type for guard class constructors\n */\nexport type GuardClass = Constructor<CanActivate>\n\n/**\n * Guard can be a class constructor or an instance\n * Instances are used for factory-created guards with configuration\n */\nexport type Guard = GuardClass | CanActivate\n\n/**\n * Options for AuthGuard factory\n */\nexport interface AuthGuardOptions {\n  /**\n   * Required permissions for authorization as `\"resource:action\"` strings.\n   * If provided, permission check is performed after authentication.\n   * If omitted, only authentication is required.\n   *\n   * Multiple permissions are combined with AND logic (all must be satisfied).\n   *\n   * @example\n   * ```typescript\n   * @UseGuards(AuthGuard({ permissions: 'posts:update' }))\n   * @UseGuards(AuthGuard({ permissions: ['posts:update', 'posts:delete'] }))\n   * @UseGuards(AuthGuard({ permissions: 'admin:access' }))\n   * ```\n   */\n  permissions?: string | string[]\n}\n\n/**\n * Metadata stored by `@UseGuards` decorator\n */\nexport interface GuardMetadata {\n  guards: Guard[]\n}\n\n/**\n * Metadata key for guard storage\n */\nexport const GUARD_METADATA_KEY = Symbol.for('stratal:guards')\n","import { defineMetadata, getMetadata } from '../di/metadata'\nimport { GUARD_METADATA_KEY, type Guard, type GuardMetadata } from './types'\n\n/**\n * UseGuards Decorator\n *\n * Applies one or more guards to a controller or method.\n * Guards are executed in order and all must pass for the request to proceed.\n *\n * **Execution Order:**\n * 1. Request → Global Middlewares → Route Middlewares\n * 2. **Guards (controller-level, then method-level)**\n * 3. Route Handler\n *\n * **Guard Resolution:**\n * - Guard classes are resolved from the request-scoped DI container\n * - Guard instances (from factory functions) are used directly\n *\n * @param guards - Guard classes or instances to apply\n *\n * @example Authentication only\n * ```typescript\n * @Controller('/api/v1/profile')\n * @UseGuards(AuthGuard())\n * export class ProfileController {\n *   show() { } // Requires authentication\n * }\n * ```\n *\n * @example Authentication with permissions\n * ```typescript\n * @Controller('/api/v1/students')\n * @UseGuards(AuthGuard({ scopes: ['students:read'] }))\n * export class StudentsController {\n *   index() { } // Requires 'students:read' permission\n * }\n * ```\n *\n * @example Method-level guards\n * ```typescript\n * @Controller('/api/v1/students')\n * @UseGuards(AuthGuard()) // Controller-level: auth only\n * export class StudentsController {\n *   index() { } // Auth only (inherited)\n *\n *   @UseGuards(AuthGuard({ scopes: ['students:create'] }))\n *   create() { } // Auth + 'students:create' permission\n * }\n * ```\n *\n * @example Multiple guards\n * ```typescript\n * @UseGuards(AuthGuard(), RateLimitGuard(), CustomGuard())\n * export class SecureController {\n *   // All guards must pass\n * }\n * ```\n */\nexport function UseGuards(...guards: Guard[]): ClassDecorator & MethodDecorator {\n  return (target: object, propertyKey?: string | symbol) => {\n    const metadata: GuardMetadata = { guards }\n\n    if (propertyKey !== undefined) {\n      // Method decorator - store on method\n      defineMetadata(GUARD_METADATA_KEY, metadata, target, propertyKey)\n    } else {\n      // Class decorator - store on class\n      defineMetadata(GUARD_METADATA_KEY, metadata, target)\n    }\n  }\n}\n\n/**\n * Get controller-level guard metadata\n *\n * @param target - Controller class\n * @returns Guard metadata or undefined if not decorated\n */\nexport function getControllerGuards(target: object): GuardMetadata | undefined {\n  return getMetadata<GuardMetadata>(GUARD_METADATA_KEY, target)\n}\n\n/**\n * Get method-level guard metadata\n *\n * @param target - Controller prototype\n * @param propertyKey - Method name\n * @returns Guard metadata or undefined if not decorated\n */\nexport function getMethodGuards(target: object, propertyKey: string | symbol): GuardMetadata | undefined {\n  return getMetadata<GuardMetadata>(GUARD_METADATA_KEY, target, propertyKey)\n}\n","import type { Container } from '../di'\nimport type { LoggerService } from '../logger'\nimport type { RouterContext } from '../router'\nimport type { CanActivate, Guard } from './types'\n\n/**\n * Guard Execution Service\n *\n * Executes guards for a route and determines if the request should proceed.\n * Guards are executed in order; all must pass for the request to proceed.\n */\nexport class GuardExecutionService {\n  constructor(private readonly logger: LoggerService) { }\n\n  /**\n   * Execute all guards for a route\n   *\n   * @param guards - Array of guards (classes or instances)\n   * @param context - Router context\n   * @param container - Request-scoped DI container\n   * @returns true if all guards pass\n   * @throws Error from first failing guard\n   */\n  async executeGuards(\n    guards: Guard[],\n    context: RouterContext,\n    container: Container\n  ): Promise<boolean> {\n    if (guards.length === 0) {\n      return true\n    }\n\n    this.logger.debug('Executing guards', {\n      guardCount: guards.length,\n      path: context.c.req.path,\n      method: context.c.req.method,\n    })\n\n    for (const guard of guards) {\n      const guardInstance = this.resolveGuard(guard, container)\n      const canActivate = await guardInstance.canActivate(context)\n\n      if (!canActivate) {\n        this.logger.debug('Guard denied access', {\n          // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition -- guard.constructor may be null at runtime\n          guard: guard.constructor?.name || 'AnonymousGuard',\n          path: context.c.req.path,\n        })\n        return false\n      }\n    }\n\n    this.logger.debug('All guards passed', {\n      guardCount: guards.length,\n      path: context.c.req.path,\n    })\n\n    return true\n  }\n\n  /**\n   * Resolve a guard to an instance\n   *\n   * @param guard - Guard class or instance\n   * @param container - Request-scoped DI container\n   * @returns Guard instance\n   */\n  private resolveGuard(guard: Guard, container: Container): CanActivate {\n    // If already an instance (has canActivate method), use directly\n    if (this.isGuardInstance(guard)) {\n      return guard\n    }\n\n    // Otherwise, resolve from container\n    return container.resolve<CanActivate>(guard)\n  }\n\n  /**\n   * Type guard to check if value is a guard instance\n   */\n  private isGuardInstance(guard: Guard): guard is CanActivate {\n    return (\n      typeof guard === 'object' &&\n      // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition -- typeof null === 'object', null check is required\n      guard !== null &&\n      'canActivate' in guard &&\n      typeof guard.canActivate === 'function'\n    )\n  }\n}\n"],"mappings":";;;;;AAyEA,MAAa,qBAAqB,OAAO,IAAI,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ACf7D,SAAgB,UAAU,GAAG,QAAmD;CAC9E,QAAQ,QAAgB,gBAAkC;EACxD,MAAM,WAA0B,EAAE,OAAO;EAEzC,IAAI,gBAAgB,KAAA,GAElB,eAAe,oBAAoB,UAAU,QAAQ,WAAW;OAGhE,eAAe,oBAAoB,UAAU,MAAM;CAEvD;AACF;;;;;;;AAQA,SAAgB,oBAAoB,QAA2C;CAC7E,OAAO,YAA2B,oBAAoB,MAAM;AAC9D;;;;;;;;AASA,SAAgB,gBAAgB,QAAgB,aAAyD;CACvG,OAAO,YAA2B,oBAAoB,QAAQ,WAAW;AAC3E;;;;;;;;;AChFA,IAAa,wBAAb,MAAmC;CACJ;CAA7B,YAAY,QAAwC;EAAvB,KAAA,SAAA;CAAyB;;;;;;;;;;CAWtD,MAAM,cACJ,QACA,SACA,WACkB;EAClB,IAAI,OAAO,WAAW,GACpB,OAAO;EAGT,KAAK,OAAO,MAAM,oBAAoB;GACpC,YAAY,OAAO;GACnB,MAAM,QAAQ,EAAE,IAAI;GACpB,QAAQ,QAAQ,EAAE,IAAI;EACxB,CAAC;EAED,KAAK,MAAM,SAAS,QAIlB,IAAI,CAAC,MAHiB,KAAK,aAAa,OAAO,SACT,EAAE,YAAY,OAAO,GAEzC;GAChB,KAAK,OAAO,MAAM,uBAAuB;IAEvC,OAAO,MAAM,aAAa,QAAQ;IAClC,MAAM,QAAQ,EAAE,IAAI;GACtB,CAAC;GACD,OAAO;EACT;EAGF,KAAK,OAAO,MAAM,qBAAqB;GACrC,YAAY,OAAO;GACnB,MAAM,QAAQ,EAAE,IAAI;EACtB,CAAC;EAED,OAAO;CACT;;;;;;;;CASA,aAAqB,OAAc,WAAmC;EAEpE,IAAI,KAAK,gBAAgB,KAAK,GAC5B,OAAO;EAIT,OAAO,UAAU,QAAqB,KAAK;CAC7C;;;;CAKA,gBAAwB,OAAoC;EAC1D,OACE,OAAO,UAAU,YAEjB,UAAU,QACV,iBAAiB,SACjB,OAAO,MAAM,gBAAgB;CAEjC;AACF"}

package/dist/hono-app-CvV3hOfT.mjs

@@ -0,0 +1,161 @@
+import { t as __exportAll } from "./chunk-BBjsoOtd.mjs";
+import { d as inject, n as CONTAINER_TOKEN, r as DI_TOKENS, s as Singleton } from "./di-DseMn-z9.mjs";
+import { r as runWithContainer } from "./container-storage-BmOJ4_Na.mjs";
+import { n as __decorateParam, t as __decorate } from "./decorate-CuAoSZvs.mjs";
+import { LOGGER_TOKENS } from "./logger/index.mjs";
+import { a as RouterContext, l as ROUTER_CONTEXT_KEYS, r as createHttpExceptionContext } from "./exception-context-kEoMFwze.mjs";
+import { o as RouterError } from "./module-registry-Dm-pqHd3.mjs";
+import { t as OpenAPIHono } from "./zod-eKqqhZ5_.mjs";
+import { n as OPENAPI_TOKENS } from "./openapi-tools.service-BC5EC3R3.mjs";
+import "./openapi-CstuTM8S.mjs";
+import { p as createMiddlewareChain, t as RouteRegistrationService, v as SchemaValidationError, y as RouteNotFoundError } from "./route-registration.service-D6vSwiKP.mjs";
+import { t as applyTrailingSlash } from "./trailing-slash-CFyw8nYu.mjs";
+//#region src/router/middleware/logger.middleware.ts
+/**
+* Create a Hono middleware that logs HTTP requests using our Logger service
+*
+* Logs request method, path, status code, and duration in milliseconds.
+* Format: [HTTP] METHOD /path -> STATUS (duration ms)
+*
+* @param logger - Logger service instance
+* @returns Hono middleware handler
+*
+* @example
+* ```typescript
+* const logger = container.resolve<LoggerService>(LOGGER_TOKENS.LoggerService)
+* app.use('*', createLoggerMiddleware(logger))
+* ```
+*/
+function createLoggerMiddleware(logger) {
+	return async (c, next) => {
+		const start = Date.now();
+		const method = c.req.method;
+		const path = c.req.path;
+		await next();
+		const duration = Date.now() - start;
+		const status = c.res.status;
+		logger.info(`[HTTP] ${method} ${path} -> ${status}`, {
+			method,
+			path,
+			status,
+			duration
+		});
+	};
+}
+//#endregion
+//#region src/router/middleware/trailing-slash-redirect.ts
+const REDIRECT_STATUS = 308;
+/**
+* Create a Hono middleware that canonicalises trailing slashes via 308 redirects.
+*
+* - `'ignore'` — returns `null`; routes match both `/foo` and `/foo/` natively
+*   (Hono handles this when constructed with `strict: false`).
+* - `'always'` — non-trailing requests redirect to the trailing-slash form.
+*   Paths whose last segment contains `.` (e.g. `/api/openapi.json`) are skipped.
+* - `'never'`  — trailing requests redirect to the non-trailing form.
+*
+* Root (`/`) is always passed through unchanged.
+*
+* 308 is used so that POST/PUT/PATCH bodies survive the redirect.
+*
+* Location headers are emitted as path-relative URIs so the user agent
+* resolves them against the effective request URI — sidestepping scheme
+* mismatches behind HTTPS-terminating proxies that proxy HTTPS pages to an
+* HTTP-speaking backend (which would otherwise produce a mixed-content block).
+*/
+function createTrailingSlashRedirect(mode) {
+	if (mode === "ignore") return null;
+	return async (c, next) => {
+		const url = new URL(c.req.url);
+		const canonicalPath = applyTrailingSlash(url.pathname, mode);
+		if (canonicalPath === url.pathname) return next();
+		return c.redirect(`${canonicalPath}${url.search}`, REDIRECT_STATUS);
+	};
+}
+//#endregion
+//#region src/router/hono-app.ts
+var hono_app_exports = /* @__PURE__ */ __exportAll({ HonoApp: () => HonoApp });
+const isMiddlewareClass = (arg) => typeof arg === "function" && arg.prototype && "handle" in arg.prototype;
+let HonoApp = class HonoApp extends OpenAPIHono {
+	configured = false;
+	_container;
+	_logger;
+	/**
+	* Reference to the original Hono `use` implementation.
+	* Captured in constructor after super() sets it as an instance property.
+	* Used by private methods to register middleware without going through the override.
+	*/
+	nativeUse;
+	constructor(container, logger, application) {
+		const trailingSlash = application.config.trailingSlash ?? "ignore";
+		super({
+			strict: false,
+			defaultHook: (result) => {
+				if (!result.success) throw new SchemaValidationError(result.error);
+			}
+		});
+		this._container = container;
+		this._logger = logger;
+		this.nativeUse = this.use;
+		this.use = ((...args) => {
+			if (isMiddlewareClass(args[0])) {
+				this.nativeUse("*", createMiddlewareChain(args));
+				return this;
+			}
+			if (typeof args[0] === "string" && args.length > 1 && isMiddlewareClass(args[1])) {
+				this.nativeUse(args[0], createMiddlewareChain(args.slice(1)));
+				return this;
+			}
+			return this.nativeUse(...args);
+		});
+		const trailingSlashRedirect = createTrailingSlashRedirect(trailingSlash);
+		if (trailingSlashRedirect) this.nativeUse("*", trailingSlashRedirect);
+		this.setupRequestScope();
+		this.applyGlobalMiddleware();
+	}
+	/**
+	* Apply global middleware (logger + error handler).
+	* Called by Application after locale middleware is applied by LocalePathService.
+	*/
+	applyGlobalMiddleware() {
+		this.nativeUse("*", createLoggerMiddleware(this._logger));
+		this.onError((err, c) => this.handleException(c, err));
+	}
+	/**
+	* Configure OpenAPI endpoints, controller routes, and 404 handler.
+	* Called once by Application.initialize().
+	*/
+	async configure() {
+		if (this.configured) throw new RouterError("HonoApp has already been configured");
+		this._container.resolve(OPENAPI_TOKENS.OpenAPIService).setupEndpoints(this, this._container);
+		await this._container.resolve(RouteRegistrationService).configure();
+		this.notFound((c) => {
+			throw new RouteNotFoundError(c.req.path, c.req.method);
+		});
+		this.configured = true;
+	}
+	setupRequestScope() {
+		this.nativeUse("*", async (c, next) => {
+			const routerContext = new RouterContext(c);
+			const requestContainer = this._container.createRequestScope(routerContext);
+			c.set(ROUTER_CONTEXT_KEYS.REQUEST_CONTAINER, requestContainer);
+			await runWithContainer(requestContainer, next);
+		});
+	}
+	handleException(c, err) {
+		const requestContainer = c.get(ROUTER_CONTEXT_KEYS.REQUEST_CONTAINER) ?? this._container;
+		const handler = requestContainer.resolve(DI_TOKENS.ExceptionHandler);
+		const ctx = createHttpExceptionContext(c);
+		return runWithContainer(requestContainer, () => handler.handle(err, ctx));
+	}
+};
+HonoApp = __decorate([
+	Singleton(),
+	__decorateParam(0, inject(CONTAINER_TOKEN)),
+	__decorateParam(1, inject(LOGGER_TOKENS.LoggerService)),
+	__decorateParam(2, inject(DI_TOKENS.Application))
+], HonoApp);
+//#endregion
+export { hono_app_exports as n, HonoApp as t };
+
+//# sourceMappingURL=hono-app-CvV3hOfT.mjs.map

package/dist/hono-app-CvV3hOfT.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"hono-app-CvV3hOfT.mjs","names":[],"sources":["../src/router/middleware/logger.middleware.ts","../src/router/middleware/trailing-slash-redirect.ts","../src/router/hono-app.ts"],"sourcesContent":["import type { MiddlewareHandler } from 'hono'\nimport type { LoggerService } from '../../logger'\n\n/**\n * Create a Hono middleware that logs HTTP requests using our Logger service\n *\n * Logs request method, path, status code, and duration in milliseconds.\n * Format: [HTTP] METHOD /path -> STATUS (duration ms)\n *\n * @param logger - Logger service instance\n * @returns Hono middleware handler\n *\n * @example\n * ```typescript\n * const logger = container.resolve<LoggerService>(LOGGER_TOKENS.LoggerService)\n * app.use('*', createLoggerMiddleware(logger))\n * ```\n */\nexport function createLoggerMiddleware(logger: LoggerService): MiddlewareHandler {\n  return async (c, next) => {\n    const start = Date.now()\n    const method = c.req.method\n    const path = c.req.path\n\n    await next()\n\n    const duration = Date.now() - start\n    const status = c.res.status\n\n    logger.info(`[HTTP] ${method} ${path} -> ${status}`, {\n      method,\n      path,\n      status,\n      duration,\n    })\n  }\n}\n","import type { MiddlewareHandler } from 'hono'\nimport { applyTrailingSlash } from '../trailing-slash'\nimport type { RouterEnv, TrailingSlashMode } from '../types'\n\nconst REDIRECT_STATUS = 308\n\n/**\n * Create a Hono middleware that canonicalises trailing slashes via 308 redirects.\n *\n * - `'ignore'` — returns `null`; routes match both `/foo` and `/foo/` natively\n *   (Hono handles this when constructed with `strict: false`).\n * - `'always'` — non-trailing requests redirect to the trailing-slash form.\n *   Paths whose last segment contains `.` (e.g. `/api/openapi.json`) are skipped.\n * - `'never'`  — trailing requests redirect to the non-trailing form.\n *\n * Root (`/`) is always passed through unchanged.\n *\n * 308 is used so that POST/PUT/PATCH bodies survive the redirect.\n *\n * Location headers are emitted as path-relative URIs so the user agent\n * resolves them against the effective request URI — sidestepping scheme\n * mismatches behind HTTPS-terminating proxies that proxy HTTPS pages to an\n * HTTP-speaking backend (which would otherwise produce a mixed-content block).\n */\nexport function createTrailingSlashRedirect(\n  mode: TrailingSlashMode,\n): MiddlewareHandler<RouterEnv> | null {\n  if (mode === 'ignore') return null\n\n  return async (c, next) => {\n    const url = new URL(c.req.url)\n    const canonicalPath = applyTrailingSlash(url.pathname, mode)\n    if (canonicalPath === url.pathname) return next()\n    return c.redirect(`${canonicalPath}${url.search}`, REDIRECT_STATUS)\n  }\n}\n","import type { Context, MiddlewareHandler } from 'hono'\nimport { inject } from '../di'\nimport type { Application } from '../application'\nimport type { Container } from '../di/container'\nimport { runWithContainer } from '../di/container-storage'\nimport { Singleton } from '../di/decorators'\nimport { CONTAINER_TOKEN, DI_TOKENS } from '../di/tokens'\nimport { createHttpExceptionContext } from '../errors/exception-context'\nimport type { ExceptionHandler } from '../errors/exception-handler'\nimport { OpenAPIHono } from '../i18n/validation/zod'\nimport { LOGGER_TOKENS, type LoggerService } from '../logger'\nimport { OPENAPI_TOKENS, type OpenAPIService } from '../openapi'\nimport type { Constructor } from '../types'\nimport { ROUTER_CONTEXT_KEYS } from './constants'\nimport { RouteNotFoundError, SchemaValidationError } from './errors'\nimport { RouterError } from './router.error'\nimport { createLoggerMiddleware, createMiddlewareChain, createTrailingSlashRedirect } from './middleware'\nimport type { Middleware } from './middleware.interface'\nimport { RouterContext } from './router-context'\nimport { RouteRegistrationService } from './services/route-registration.service'\nimport type { RouterEnv, TrailingSlashMode } from './types'\n\nconst isMiddlewareClass = (arg: unknown): arg is Constructor<Middleware> =>\n  // eslint-disable-next-line @typescript-eslint/no-unsafe-return\n  typeof arg === 'function' && arg.prototype && 'handle' in arg.prototype\n\n\n/**\n * HonoApp — extends OpenAPIHono with Stratal-specific setup\n *\n * - Request scope middleware (child container per request)\n * - Global middleware (CORS, logging, error handling)\n * - defaultHook for validation errors\n * - `use()` overload for Stratal middleware classes\n * - `configure()` for OpenAPI, routes, and 404\n */\n@Singleton()\nexport class HonoApp extends OpenAPIHono<RouterEnv> {\n  private configured = false\n  private readonly _container: Container\n  private readonly _logger: LoggerService\n\n  /**\n   * Reference to the original Hono `use` implementation.\n   * Captured in constructor after super() sets it as an instance property.\n   * Used by private methods to register middleware without going through the override.\n   */\n  private nativeUse!: typeof this.use\n\n  constructor(\n    @inject(CONTAINER_TOKEN) container: Container,\n    @inject(LOGGER_TOKENS.LoggerService) logger: LoggerService,\n    @inject(DI_TOKENS.Application) application: Application,\n  ) {\n    const trailingSlash: TrailingSlashMode = application.config.trailingSlash ?? 'ignore'\n\n    super({\n      // Always non-strict: a registered `/foo` route matches both `/foo` and `/foo/`.\n      // For the redirect modes, the trailing-slash middleware runs first and\n      // canonicalises via 308 before matching reaches the registered route.\n      strict: false,\n      defaultHook: (result) => {\n        if (!result.success) {\n          throw new SchemaValidationError(result.error)\n        }\n      },\n    })\n\n    this._container = container\n    this._logger = logger\n\n    // Capture Hono's original `use` (set by super() as an instance property)\n    this.nativeUse = this.use\n\n    // Override `use` to support Stratal middleware classes alongside Hono-native handlers\n    this.use = ((...args: unknown[]) => {\n      if (isMiddlewareClass(args[0])) {\n        this.nativeUse('*', createMiddlewareChain(args as Constructor<Middleware>[]))\n        return this\n      }\n\n      if (typeof args[0] === 'string' && args.length > 1 && isMiddlewareClass(args[1])) {\n        this.nativeUse(args[0], createMiddlewareChain(args.slice(1) as Constructor<Middleware>[]))\n        return this\n      }\n\n      return (this.nativeUse as (...a: unknown[]) => unknown)(...args)\n    }) as typeof this.use\n\n    // Trailing-slash redirect runs first so redirected requests skip request-scope\n    // and logger overhead.\n    const trailingSlashRedirect = createTrailingSlashRedirect(trailingSlash)\n    if (trailingSlashRedirect) {\n      this.nativeUse('*', trailingSlashRedirect)\n    }\n\n    // Internal setup — uses nativeUse to bypass the override\n    this.setupRequestScope()\n    this.applyGlobalMiddleware()\n  }\n\n  /**\n   * Apply global middleware (logger + error handler).\n   * Called by Application after locale middleware is applied by LocalePathService.\n   */\n  private applyGlobalMiddleware(): void {\n    this.nativeUse('*', createLoggerMiddleware(this._logger) as MiddlewareHandler<RouterEnv>)\n    this.onError((err, c) => this.handleException(c, err))\n  }\n\n  /**\n   * Configure OpenAPI endpoints, controller routes, and 404 handler.\n   * Called once by Application.initialize().\n   */\n  async configure(): Promise<void> {\n    if (this.configured) throw new RouterError('HonoApp has already been configured')\n\n    // OpenAPI endpoints\n    const openAPIService = this._container.resolve<OpenAPIService>(OPENAPI_TOKENS.OpenAPIService)\n    openAPIService.setupEndpoints(this, this._container)\n\n    // Controller routes + global middleware\n    const routeRegistrationService = this._container.resolve<RouteRegistrationService>(RouteRegistrationService)\n    await routeRegistrationService.configure()\n\n    // 404 handler (must be last)\n    this.notFound((c) => { throw new RouteNotFoundError(c.req.path, c.req.method) })\n\n    this.configured = true\n  }\n\n  private setupRequestScope(): void {\n    this.nativeUse('*', async (c: Context<RouterEnv>, next: () => Promise<void>) => {\n      const routerContext = new RouterContext(c)\n      const requestContainer = this._container.createRequestScope(routerContext)\n      c.set(ROUTER_CONTEXT_KEYS.REQUEST_CONTAINER, requestContainer)\n\n      await runWithContainer(requestContainer, next)\n    })\n  }\n\n  private handleException(c: Context<RouterEnv>, err: unknown) {\n    // Fallback to global container if request scope setup failed before storing REQUEST_CONTAINER\n    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition -- runtime guard: REQUEST_CONTAINER may be unset if request scope middleware throws\n    const requestContainer = c.get(ROUTER_CONTEXT_KEYS.REQUEST_CONTAINER) ?? this._container\n    const handler = requestContainer.resolve<ExceptionHandler>(DI_TOKENS.ExceptionHandler)\n    const ctx = createHttpExceptionContext(c)\n    // Run the handler within the request container's async context so standalone\n    // helpers like `route()` (which read the ambient container via getContainer)\n    // resolve correctly. Errors thrown before the request-scope middleware's\n    // `runWithContainer` body — e.g. route-param validation failures — otherwise\n    // reach here outside any container scope, breaking redirect-back rendering.\n    return runWithContainer(requestContainer, () => handler.handle(err, ctx))\n  }\n}\n"],"mappings":"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"}

package/dist/{http-method.decorator-BrgHMdLQ.mjs → http-method.decorator-ByWZb9DO.mjs}

@@ -1,5 +1,6 @@
-import { f as ROUTE_METADATA_KEYS } from "./errors-COW9-Mar.mjs";
-import { i as z } from "./validation-DtJwAv7O.mjs";
+import { n as getMetadata, t as defineMetadata } from "./metadata-DzzprcID.mjs";
+import { u as ROUTE_METADATA_KEYS } from "./exception-context-kEoMFwze.mjs";
+import { r as z } from "./zod-eKqqhZ5_.mjs";
 //#region src/router/decorators/http-method.decorator.ts
 /**
 * Creates an HTTP method decorator factory for the given HTTP method.
@@ -17,10 +18,10 @@ function createHttpMethodDecorator(method) {
 				path,
 				config: config ?? { response: z.any() }
 			};
-			Reflect.defineMetadata(ROUTE_METADATA_KEYS.ROUTE_CONFIG, metadata, target, propertyKey);
-			const existing = Reflect.getOwnMetadata(ROUTE_METADATA_KEYS.DECORATED_METHODS, target) ?? [];
+			defineMetadata(ROUTE_METADATA_KEYS.ROUTE_CONFIG, metadata, target, propertyKey);
+			const existing = getMetadata(ROUTE_METADATA_KEYS.DECORATED_METHODS, target) ?? [];
 			existing.push(propertyKey);
-			Reflect.defineMetadata(ROUTE_METADATA_KEYS.DECORATED_METHODS, existing, target);
+			defineMetadata(ROUTE_METADATA_KEYS.DECORATED_METHODS, existing, target);
 			return descriptor;
 		};
 	};
@@ -93,4 +94,4 @@ const All = createHttpMethodDecorator("all");
 //#endregion
 export { Post as a, Patch as i, Delete as n, Put as o, Get as r, All as t };
 
-//# sourceMappingURL=http-method.decorator-BrgHMdLQ.mjs.map
+//# sourceMappingURL=http-method.decorator-ByWZb9DO.mjs.map

package/dist/http-method.decorator-ByWZb9DO.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"http-method.decorator-ByWZb9DO.mjs","names":[],"sources":["../src/router/decorators/http-method.decorator.ts"],"sourcesContent":["import { defineMetadata, getMetadata } from '../../di/metadata'\nimport { z } from '../../i18n/validation/zod'\nimport { ROUTE_METADATA_KEYS } from '../constants'\nimport type { ExplicitRouteMetadata, HttpMethod, RouteConfig } from '../types'\n\n/**\n * Creates an HTTP method decorator factory for the given HTTP method.\n *\n * The returned decorator stores {@link ExplicitRouteMetadata} on the method and\n * tracks the method name under {@link ROUTE_METADATA_KEYS.DECORATED_METHODS}\n * on the controller prototype so they can be discovered at registration time.\n */\nfunction createHttpMethodDecorator(method: HttpMethod) {\n  return function (path: string, config?: RouteConfig) {\n    return function (\n      target: object,\n      propertyKey: string,\n      descriptor: PropertyDescriptor\n    ) {\n      const metadata: ExplicitRouteMetadata = {\n        type: 'explicit',\n        method,\n        path,\n        config: config ?? { response: z.any() },\n      }\n\n      defineMetadata(\n        ROUTE_METADATA_KEYS.ROUTE_CONFIG,\n        metadata,\n        target,\n        propertyKey\n      )\n\n      // Track this method as decorated on the prototype\n      const existing: string[] =\n        getMetadata<string[]>(ROUTE_METADATA_KEYS.DECORATED_METHODS, target) ?? []\n      existing.push(propertyKey)\n      defineMetadata(ROUTE_METADATA_KEYS.DECORATED_METHODS, existing, target)\n\n      return descriptor\n    }\n  }\n}\n\n/**\n * Registers a GET route on the controller method.\n *\n * @param path - Route path relative to the controller base path\n * @param config - Optional route configuration (response schema, body, params, etc.)\n *\n * @example\n * ```typescript\n * @Controller('/api/v1/users')\n * class UsersController {\n *   @Get('/', { response: z.array(userSchema), summary: 'List users' })\n *   async list(ctx: RouterContext) { ... }\n *\n *   @Get('/:id', { params: z.object({ id: z.string().uuid() }), response: userSchema })\n *   async getUser(ctx: RouterContext) { ... }\n * }\n * ```\n */\nexport const Get = createHttpMethodDecorator('get')\n\n/**\n * Registers a POST route on the controller method.\n *\n * @param path - Route path relative to the controller base path\n * @param config - Optional route configuration (response schema, body, params, etc.)\n *\n * @example\n * ```typescript\n * @Controller('/api/v1/users')\n * class UsersController {\n *   @Post('/', { body: createUserSchema, response: userSchema, statusCode: 201 })\n *   async createUser(ctx: RouterContext) { ... }\n * }\n * ```\n */\nexport const Post = createHttpMethodDecorator('post')\n\n/**\n * Registers a PUT route on the controller method.\n *\n * @param path - Route path relative to the controller base path\n * @param config - Optional route configuration\n */\nexport const Put = createHttpMethodDecorator('put')\n\n/**\n * Registers a PATCH route on the controller method.\n *\n * @param path - Route path relative to the controller base path\n * @param config - Optional route configuration\n */\nexport const Patch = createHttpMethodDecorator('patch')\n\n/**\n * Registers a DELETE route on the controller method.\n *\n * @param path - Route path relative to the controller base path\n * @param config - Optional route configuration\n */\nexport const Delete = createHttpMethodDecorator('delete')\n\n/**\n * Registers an ALL (any HTTP method) route on the controller method.\n * Routes using @All are registered without OpenAPI validation\n * since OpenAPI does not support a catch-all HTTP method.\n *\n * @param path - Route path relative to the controller base path\n * @param config - Optional route configuration\n */\nexport const All = createHttpMethodDecorator('all')\n"],"mappings":";;;;;;;;;;;AAYA,SAAS,0BAA0B,QAAoB;CACrD,OAAO,SAAU,MAAc,QAAsB;EACnD,OAAO,SACL,QACA,aACA,YACA;GACA,MAAM,WAAkC;IACtC,MAAM;IACN;IACA;IACA,QAAQ,UAAU,EAAE,UAAU,EAAE,IAAI,EAAE;GACxC;GAEA,eACE,oBAAoB,cACpB,UACA,QACA,WACF;GAGA,MAAM,WACJ,YAAsB,oBAAoB,mBAAmB,MAAM,KAAK,CAAC;GAC3E,SAAS,KAAK,WAAW;GACzB,eAAe,oBAAoB,mBAAmB,UAAU,MAAM;GAEtE,OAAO;EACT;CACF;AACF;;;;;;;;;;;;;;;;;;;AAoBA,MAAa,MAAM,0BAA0B,KAAK;;;;;;;;;;;;;;;;AAiBlD,MAAa,OAAO,0BAA0B,MAAM;;;;;;;AAQpD,MAAa,MAAM,0BAA0B,KAAK;;;;;;;AAQlD,MAAa,QAAQ,0BAA0B,OAAO;;;;;;;AAQtD,MAAa,SAAS,0BAA0B,QAAQ;;;;;;;;;AAUxD,MAAa,MAAM,0BAA0B,KAAK"}

package/dist/i18n/index.d.mts

@@ -1,3 +1,238 @@
-import { A as LocaleNotSupportedError, C as DetectionStrategy, D as buildDetectorOptions, E as ResolvedI18nOptions, O as resolveI18nOptions, S as I18nModule, T as LanguageDetectionOptions, _ as Messages, b as messages, g as MessageRegistry, h as MessageLoaderService, k as TranslationMissingError, m as I18nContextMiddleware, v as getLocales, w as I18nModuleOptions, x as I18N_TOKENS, y as getMessages } from "../index-ByOyTmqf.mjs";
-import { C as MessageParams, S as MessageKeys, T as SystemMessageKeys, _ as AppMessageNamespaces, b as II18nService, g as AppMessageKeys, v as AppMessages, w as Prefixes, x as MessageKeyPrefix, y as DeepKeys } from "../index-Bnpfq6uk.mjs";
-export { AppMessageKeys, AppMessageNamespaces, AppMessages, DeepKeys, DetectionStrategy, I18N_TOKENS, I18nContextMiddleware, I18nModule, I18nModuleOptions, II18nService, LanguageDetectionOptions, LocaleNotSupportedError, MessageKeyPrefix, MessageKeys, MessageLoaderService, MessageParams, MessageRegistry, Messages, Prefixes, ResolvedI18nOptions, SystemMessageKeys, TranslationMissingError, buildDetectorOptions, getLocales, getMessages, messages, resolveI18nOptions };
+import { Dr as ApplicationError, In as OnInitialize, Nn as ModuleContext, kn as DynamicModule } from "../index-B_JoEl3V.mjs";
+import { _ as MessageParams, d as AppMessages, f as DeepKeys, g as MessageKeys, h as MessageKeyPrefix, l as AppMessageKeys, m as II18nService, p as FilterByPrefix, u as AppMessageNamespaces, v as Prefixes, y as SystemMessageKeys } from "../zod-wecrEVAs.mjs";
+import { t as index_d_exports } from "../index-HgOLNruQ.mjs";
+import { DetectorOptions } from "hono/language";
+
+//#region src/i18n/i18n.error.d.ts
+declare class I18nError extends ApplicationError {}
+//#endregion
+//#region src/i18n/i18n.options.d.ts
+/**
+ * Detection strategy for locale resolution
+ *
+ * - `'cookie'` — reads from the `locale` cookie (default)
+ * - `'header'` — reads from the `Accept-Language` header
+ * - `'querystring'` — reads from the `?locale=` query parameter
+ * - `'path'` — reads from the first URL path segment (e.g., `/en/api/users`)
+ */
+type DetectionStrategy = 'cookie' | 'header' | 'querystring' | 'path';
+interface BaseDetection {
+  /** Set to false to disable language detection entirely. @default true */
+  enabled?: boolean;
+}
+/**
+ * Language detection options (discriminated by strategy)
+ *
+ * @example Cookie detection (default)
+ * ```typescript
+ * { strategy: 'cookie' }
+ * ```
+ *
+ * @example Header detection
+ * ```typescript
+ * { strategy: 'header' }
+ * ```
+ *
+ * @example Path detection
+ * ```typescript
+ * { strategy: 'path' }
+ * ```
+ *
+ * @example Disable detection
+ * ```typescript
+ * { enabled: false }
+ * ```
+ */
+type LanguageDetectionOptions = (BaseDetection & {
+  strategy?: 'cookie';
+  cookieOptions?: DetectorOptions['cookieOptions'];
+}) | (BaseDetection & {
+  strategy: 'header';
+}) | (BaseDetection & {
+  strategy: 'querystring';
+}) | (BaseDetection & {
+  strategy: 'path';
+  /**
+   * Controls whether the default locale gets a URL path prefix.
+   *
+   * - `false` (default) — The default locale has no prefix (`/users`), other locales
+   *   are prefixed (`/fr/users`). Requests to the prefixed default locale (`/en/users`) return 404.
+   * - `'redirect'` — Same as `false`, but requests to the prefixed default locale
+   *   (`/en/users`) are 301-redirected to the unprefixed path (`/users`).
+   * - `true` — All locales are prefixed (`/en/users`, `/fr/users`).
+   *
+   * @default false
+   */
+  prefixDefaultLocale?: false | true | 'redirect';
+}) | {
+  enabled: false;
+};
+/**
+ * Options for configuring the I18n module
+ *
+ * @example
+ * ```typescript
+ * I18nModule.forRoot({
+ *   defaultLocale: 'en',
+ *   fallbackLocale: 'en',
+ *   locales: ['en', 'fr'],
+ *   detection: { strategy: 'header' },
+ * })
+ * ```
+ */
+interface I18nModuleOptions {
+  /**
+   * Default locale for the application
+   * @default 'en'
+   */
+  defaultLocale?: string;
+  /**
+   * Fallback locale when translation is missing
+   * @default 'en'
+   */
+  fallbackLocale?: string;
+  /**
+   * List of supported locales
+   * Request locales not in this list will fall back to defaultLocale
+   */
+  locales?: string[];
+  /**
+   * Language detection configuration
+   * Controls how the locale is extracted from incoming requests
+   */
+  detection?: LanguageDetectionOptions;
+}
+/**
+ * Resolved options with all defaults applied
+ * Used internally by I18n services
+ */
+interface ResolvedI18nOptions {
+  defaultLocale: string;
+  fallbackLocale: string;
+  locales: string[];
+  detection: {
+    enabled: boolean;
+    strategy: DetectionStrategy; /** Resolved value of the path detection `prefixDefaultLocale` option. Only meaningful when `strategy` is `'path'`. */
+    prefixDefaultLocale: false | true | 'redirect';
+  };
+}
+/**
+ * Resolve I18n options with defaults
+ */
+declare function resolveI18nOptions(options?: I18nModuleOptions): ResolvedI18nOptions;
+/**
+ * Build Hono languageDetector options from I18n module options
+ */
+declare function buildDetectorOptions(options?: I18nModuleOptions): Partial<DetectorOptions>;
+//#endregion
+//#region src/i18n/i18n.module.d.ts
+declare class I18nModule implements OnInitialize {
+  onInitialize(_context: ModuleContext): void;
+  static forRoot(options?: I18nModuleOptions): DynamicModule;
+  static registerMessages(messages: Record<string, Record<string, unknown>>): DynamicModule;
+}
+//#endregion
+//#region src/i18n/i18n.tokens.d.ts
+/**
+ * I18n Module DI Tokens
+ * Symbol-based tokens to avoid string collisions
+ */
+declare const I18N_TOKENS: {
+  /** MessageLoaderService - loads and caches locale messages */readonly MessageLoader: symbol; /** I18nService - request-scoped translation service */
+  readonly I18nService: symbol; /** I18nModuleOptions - configuration options from forRoot() */
+  readonly Options: symbol; /** MessageRegistry - singleton accumulator for registerMessages() contributions */
+  readonly MessageRegistry: symbol;
+};
+//#endregion
+//#region src/i18n/messages/index.d.ts
+/**
+ * All locale messages
+ * Explicitly import and export (no filesystem scanning - Cloudflare Workers compatible)
+ */
+declare const messages: {
+  readonly en: typeof index_d_exports;
+};
+/**
+ * Type for all messages
+ */
+type Messages = typeof messages;
+/**
+ * Get messages for all locales
+ */
+declare function getMessages(): Record<string, Record<string, unknown>>;
+/**
+ * Get available locales
+ */
+declare function getLocales(): string[];
+//#endregion
+//#region src/i18n/services/message-registry.d.ts
+/**
+ * Message Registry
+ *
+ * Accumulates i18n messages from multiple `I18nModule.registerMessages()` calls.
+ * Messages are collected statically (at module import time) and deep-merged
+ * when `getMergedMessages()` is called by `MessageLoaderService`.
+ *
+ * Later registrations override earlier ones at leaf level.
+ */
+declare class MessageRegistry {
+  /**
+   * Add messages (called statically by I18nModule.registerMessages)
+   */
+  static addMessages(messages: Record<string, Record<string, unknown>>): void;
+  /**
+   * Get all messages deep-merged in registration order
+   */
+  getMergedMessages(): Record<string, Record<string, unknown>>;
+  /**
+   * Reset registry (for testing)
+   * @internal
+   */
+  static reset(): void;
+}
+//#endregion
+//#region src/i18n/services/message-loader.service.d.ts
+declare class MessageLoaderService {
+  private readonly registry;
+  private readonly options?;
+  private readonly cache;
+  private readonly compiledCache;
+  private readonly locales;
+  private readonly defaultLocale;
+  constructor(registry: MessageRegistry, options?: I18nModuleOptions | undefined);
+  translate(locale: string, key: string, params?: Record<string, unknown>): string;
+  getMessages(locale: string): Record<string, unknown>;
+  getAvailableLocales(): string[];
+  isLocaleSupported(locale: string): boolean;
+  getDefaultLocale(): string;
+  getFilteredMessages(locale: string, options?: {
+    only?: MessageKeyPrefix[];
+  }): Record<string, string>;
+  private getCompiledMessages;
+  private flattenMessages;
+}
+//#endregion
+//#region src/i18n/with-i18n.d.ts
+/**
+ * Translate a message key using I18nService from the DI container.
+ *
+ * Works in both request scope (uses the request's detected locale) and
+ * global scope (defaults to 'en'). Can be used anywhere — services,
+ * middleware, error handlers, cron jobs, queue consumers, etc.
+ *
+ * @param key - Message key (e.g., 'common.welcome', 'errors.notFound')
+ * @param params - Optional interpolation parameters
+ * @returns Translated string, or the key itself if no container is available
+ *
+ * @example
+ * ```typescript
+ * import { withI18n } from 'stratal/i18n'
+ *
+ * const message = withI18n('errors.notFound')
+ * const greeting = withI18n('common.welcome', { name: 'Alice' })
+ * ```
+ */
+declare function withI18n(key: MessageKeys, params?: MessageParams): string;
+//#endregion
+export { AppMessageKeys, AppMessageNamespaces, AppMessages, DeepKeys, DetectionStrategy, FilterByPrefix, I18N_TOKENS, I18nError, I18nModule, I18nModuleOptions, II18nService, LanguageDetectionOptions, MessageKeyPrefix, MessageKeys, MessageLoaderService, MessageParams, MessageRegistry, type Messages, Prefixes, ResolvedI18nOptions, SystemMessageKeys, buildDetectorOptions, getLocales, getMessages, messages, resolveI18nOptions, withI18n };
+//# sourceMappingURL=index.d.mts.map

package/dist/i18n/index.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.mts","names":[],"sources":["../../src/i18n/i18n.error.ts","../../src/i18n/i18n.options.ts","../../src/i18n/i18n.module.ts","../../src/i18n/i18n.tokens.ts","../../src/i18n/messages/index.ts","../../src/i18n/services/message-registry.ts","../../src/i18n/services/message-loader.service.ts","../../src/i18n/with-i18n.ts"],"mappings":";;;;;;cAEa,SAAA,SAAkB,gBAAgB;;;;;AAAA;;;;ACgB/C;;KAAY,iBAAA;AAAA,UAEF,aAAA;EAFmB;EAI3B,OAAO;AAAA;;;AAAA;AA0BT;;;;;;;;;;;;;;;;;;;;KAAY,wBAAA,IACP,aAAA;EAAkB,QAAA;EAAqB,aAAA,GAAgB,eAAA;AAAA,MACvD,aAAA;EAAkB,QAAA;AAAA,MAClB,aAAA;EAAkB,QAAA;AAAA,MAClB,aAAA;EACD,QAAA;EAwCF;;;;;AAYoC;AAOtC;;;;;EA/CI,mBAAA;AAAA;EAEE,OAAA;AAAA;;;;;AAqDiB;AAOvB;;;;;;;;UA7CiB,iBAAA;EAiED;;;;EA5Dd,aAAA;EA4DiE;;;;EAtDjE,cAAA;EAsDiE;;;AAAuB;EAhDxF,OAAA;;;ACzFF;;ED+FE,SAAA,GAAY,wBAAwB;AAAA;;;;;UAOrB,mBAAA;EACf,aAAA;EACA,cAAA;EACA,OAAA;EACA,SAAA;IACE,OAAA;IACA,QAAA,EAAU,iBAAiB,ECpGhB;IDsGX,mBAAA;EAAA;AAAA;;;;iBAOY,kBAAA,CAAmB,OAAA,GAAU,iBAAA,GAAoB,mBAAmB;;;;iBAoBpE,oBAAA,CAAqB,OAAA,GAAU,iBAAA,GAAoB,OAAA,CAAQ,eAAA;;;cClI9D,UAAA,YAAsB,YAAA;EACjC,YAAA,CAAa,QAAA,EAAU,aAAA;EAAA,OAIhB,OAAA,CAAQ,OAAA,GAAS,iBAAA,GAAyB,aAAA;EAAA,OAS1C,gBAAA,CAAiB,QAAA,EAAU,MAAA,SAAe,MAAA,qBAA2B,aAAA;AAAA;;;;;;;cC1BjE,WAAA;gGHHU;EAAA,8BAAwB;EAAA;;;;;;;;AAAA;cIWlC,QAAA;EAAA,oBAA0B,eAAA;AAAA;AHKvC;;;AAAA,KGAY,QAAA,UAAkB,QAAQ;AHAT;AAA+C;;AAA/C,iBGKb,WAAA,IAAe,MAAM,SAAS,MAAA;;AHDrC;AA0BT;iBGlBgB,UAAA;;;;;;;;;AJ5BhB;;;cK+Ba,eAAA;EL/BkC;;;EAAA,OKmCtC,WAAA,CAAY,QAAA,EAAU,MAAA,SAAe,MAAA;EJnBlC;;;EI4BV,iBAAA,IAAqB,MAAA,SAAe,MAAA;EJ5BT;AAA+C;;;EAA/C,OI+CpB,KAAA;AAAA;;;cCpDI,oBAAA;EAAA,iBAO6C,QAAA;EAAA,iBAErC,OAAA;EAAA,iBARF,KAAA;EAAA,iBACA,aAAA;EAAA,iBACA,OAAA;EAAA,iBACA,aAAA;cAGuC,QAAA,EAAU,eAAA,EAE/C,OAAA,GAAU,iBAAA;EAwB7B,SAAA,CAAU,MAAA,UAAgB,GAAA,UAAa,MAAA,GAAS,MAAA;EAOhD,WAAA,CAAY,MAAA,WAAiB,MAAA;EAI7B,mBAAA;EAIA,iBAAA,CAAkB,MAAA;EAIlB,gBAAA;EAIA,mBAAA,CACE,MAAA,UACA,OAAA;IAAY,IAAA,GAAO,gBAAA;EAAA,IAClB,MAAA;EAAA,QAeK,mBAAA;EAAA,QAmBA,eAAA;AAAA;;;;;;;;ANxGV;;;;AAA+C;;;;ACgB/C;;;;AAA6B;AAA+C;iBMK5D,QAAA,CAAS,GAAA,EAAK,WAAA,EAAa,MAAA,GAAS,aAAa"}

package/dist/i18n/index.mjs

@@ -1,3 +1,39 @@
-import { w as I18N_TOKENS } from "../errors-COW9-Mar.mjs";
-import { B as LocaleNotSupportedError, F as getMessages, H as I18nContextMiddleware, I as messages, L as buildDetectorOptions, M as MessageRegistry, N as MessageLoaderService, P as getLocales, R as resolveI18nOptions, t as I18nModule, z as TranslationMissingError } from "../i18n.module-CzXLW9Hy.mjs";
-export { I18N_TOKENS, I18nContextMiddleware, I18nModule, LocaleNotSupportedError, MessageLoaderService, MessageRegistry, TranslationMissingError, buildDetectorOptions, getLocales, getMessages, messages, resolveI18nOptions };
+import { a as ApplicationError, n as getContainer } from "../container-storage-BmOJ4_Na.mjs";
+import "../errors-mXYxG0XB.mjs";
+import { t as I18N_TOKENS } from "../i18n.tokens-CZ_v8oyS.mjs";
+import { i as resolveI18nOptions, r as buildDetectorOptions } from "../locale-path.service-D-dHiIPc.mjs";
+import { a as getLocales, i as MessageLoaderService, o as getMessages, r as MessageRegistry, s as messages, t as I18nModule } from "../i18n.module-DRQAZoSZ.mjs";
+//#region src/i18n/i18n.error.ts
+var I18nError = class extends ApplicationError {};
+//#endregion
+//#region src/i18n/with-i18n.ts
+/**
+* Translate a message key using I18nService from the DI container.
+*
+* Works in both request scope (uses the request's detected locale) and
+* global scope (defaults to 'en'). Can be used anywhere — services,
+* middleware, error handlers, cron jobs, queue consumers, etc.
+*
+* @param key - Message key (e.g., 'common.welcome', 'errors.notFound')
+* @param params - Optional interpolation parameters
+* @returns Translated string, or the key itself if no container is available
+*
+* @example
+* ```typescript
+* import { withI18n } from 'stratal/i18n'
+*
+* const message = withI18n('errors.notFound')
+* const greeting = withI18n('common.welcome', { name: 'Alice' })
+* ```
+*/
+function withI18n(key, params) {
+	try {
+		return getContainer().resolve(I18N_TOKENS.I18nService).t(key, params);
+	} catch {
+		return key;
+	}
+}
+//#endregion
+export { I18N_TOKENS, I18nError, I18nModule, MessageLoaderService, MessageRegistry, buildDetectorOptions, getLocales, getMessages, messages, resolveI18nOptions, withI18n };
+
+//# sourceMappingURL=index.mjs.map

package/dist/i18n/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","names":[],"sources":["../../src/i18n/i18n.error.ts","../../src/i18n/with-i18n.ts"],"sourcesContent":["import { ApplicationError } from '../errors'\n\nexport class I18nError extends ApplicationError {}\n","import { getContainer } from '../di/container-storage'\nimport { I18N_TOKENS } from './i18n.tokens'\nimport type { II18nService, MessageKeys, MessageParams } from './i18n.types'\n\n/**\n * Translate a message key using I18nService from the DI container.\n *\n * Works in both request scope (uses the request's detected locale) and\n * global scope (defaults to 'en'). Can be used anywhere — services,\n * middleware, error handlers, cron jobs, queue consumers, etc.\n *\n * @param key - Message key (e.g., 'common.welcome', 'errors.notFound')\n * @param params - Optional interpolation parameters\n * @returns Translated string, or the key itself if no container is available\n *\n * @example\n * ```typescript\n * import { withI18n } from 'stratal/i18n'\n *\n * const message = withI18n('errors.notFound')\n * const greeting = withI18n('common.welcome', { name: 'Alice' })\n * ```\n */\nexport function withI18n(key: MessageKeys, params?: MessageParams): string {\n  try {\n    const container = getContainer()\n    const i18n = container.resolve<II18nService>(I18N_TOKENS.I18nService)\n    return i18n.t(key, params)\n  } catch {\n    return key\n  }\n}\n"],"mappings":";;;;;;AAEA,IAAa,YAAb,cAA+B,iBAAiB,CAAC;;;;;;;;;;;;;;;;;;;;;;ACqBjD,SAAgB,SAAS,KAAkB,QAAgC;CACzE,IAAI;EAGF,OAFkB,aACG,EAAE,QAAsB,YAAY,WAC/C,EAAE,EAAE,KAAK,MAAM;CAC3B,QAAQ;EACN,OAAO;CACT;AACF"}

package/dist/i18n/messages/en/index.d.mts

@@ -1,2 +1,2 @@
-import { a as errors, i as emails, n as zodI18n, o as common, r as validation } from "../../../index-C1KvMncZ.mjs";
-export { common, emails, errors, validation, zodI18n };
+import { a as common, i as emails, n as zodI18n, r as validation } from "../../../index-HgOLNruQ.mjs";
+export { common, emails, validation, zodI18n };

package/dist/i18n/messages/en/index.mjs

@@ -1,2 +1,2 @@
-import { a as errors, i as emails, n as zodI18n, o as common, r as validation } from "../../../en-DSH_bhh6.mjs";
-export { common, emails, errors, validation, zodI18n };
+import { a as common, i as emails, n as zodI18n, r as validation } from "../../../en-CDZBMcc1.mjs";
+export { common, emails, validation, zodI18n };

package/dist/i18n/utils/index.d.mts

@@ -1,30 +1,8 @@
-//#region src/i18n/utils/setup.d.ts
+//#region src/i18n/utils/deep-merge.d.ts
 /**
- * I18n Setup - Message Compiler Registration
- *
- * Registers a JIT (Just-In-Time) message compiler for @intlify/core-base
- * that works in Cloudflare Workers edge runtime.
- *
- * This must be called ONCE at application startup, before any I18nService instances are created.
+ * Deep merge two objects. Source values override target at leaf level.
  */
-/**
- * Setup JIT message compiler for i18n
- *
- * Registers a message compiler that uses JIT compilation mode.
- * In @intlify/core-base v10+, JIT mode is enabled by default, which generates
- * AST (Abstract Syntax Tree) instead of JavaScript code, making it compatible
- * with CSP-restricted environments like Cloudflare Workers.
- *
- * **IMPORTANT:** Call this function once at application startup before creating
- * any I18nService instances. Safe to call multiple times (only registers once).
- *
- * @example
- * ```typescript
- * // In application entry point (before app.initialize())
- * setupI18nCompiler()
- * ```
- */
-declare function setupI18nCompiler(): void;
+declare function deepMerge(target: Record<string, unknown>, source: Record<string, unknown>): Record<string, unknown>;
 //#endregion
-export { setupI18nCompiler };
+export { deepMerge };
 //# sourceMappingURL=index.d.mts.map

package/dist/i18n/utils/index.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.mts","names":[],"sources":["../../../src/i18n/utils/setup.ts"],"mappings":";;AA8BA;;;;;;;;;;;;;;;;;;;;;;;;iBAAgB,iBAAA,CAAA"}
+{"version":3,"file":"index.d.mts","names":[],"sources":["../../../src/i18n/utils/deep-merge.ts"],"mappings":";;AAGA;;iBAAgB,SAAA,CACd,MAAA,EAAQ,MAAA,mBACR,MAAA,EAAQ,MAAA,oBACP,MAAA"}