stratal 0.0.21 → 0.0.22

package/dist/guards-Ced-uNIF.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"guards-Ced-uNIF.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,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ACf9D,SAAgB,UAAU,GAAG,QAAmD;CAC9E,QAAQ,QAAgB,gBAAkC;EACxD,MAAM,WAA0B,EAAE,QAAQ;EAE1C,IAAI,gBAAgB,KAAA,GAElB,eAAe,oBAAoB,UAAU,QAAQ,YAAY;OAGjE,eAAe,oBAAoB,UAAU,OAAO;;;;;;;;;AAW1D,SAAgB,oBAAoB,QAA2C;CAC7E,OAAO,YAA2B,oBAAoB,OAAO;;;;;;;;;AAU/D,SAAgB,gBAAgB,QAAgB,aAAyD;CACvG,OAAO,YAA2B,oBAAoB,QAAQ,YAAY;;;;;;;;;;AC/E5E,IAAa,wBAAb,MAAmC;CACJ;CAA7B,YAAY,QAAwC;EAAvB,KAAA,SAAA;;;;;;;;;;;CAW7B,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;GACvB,CAAC;EAEF,KAAK,MAAM,SAAS,QAIlB,IAAI,CAAC,MAHiB,KAAK,aAAa,OAAO,UACR,CAAC,YAAY,QAAQ,EAE1C;GAChB,KAAK,OAAO,MAAM,uBAAuB;IAEvC,OAAO,MAAM,aAAa,QAAQ;IAClC,MAAM,QAAQ,EAAE,IAAI;IACrB,CAAC;GACF,OAAO;;EAIX,KAAK,OAAO,MAAM,qBAAqB;GACrC,YAAY,OAAO;GACnB,MAAM,QAAQ,EAAE,IAAI;GACrB,CAAC;EAEF,OAAO;;;;;;;;;CAUT,aAAqB,OAAc,WAAmC;EAEpE,IAAI,KAAK,gBAAgB,MAAM,EAC7B,OAAO;EAIT,OAAO,UAAU,QAAqB,MAAM;;;;;CAM9C,gBAAwB,OAAoC;EAC1D,OACE,OAAO,UAAU,YAEjB,UAAU,QACV,iBAAiB,SACjB,OAAO,MAAM,gBAAgB"}

package/dist/{http-method.decorator-BrgHMdLQ.mjs → http-method.decorator-CdjKFJZZ.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-BVkc4aUu.mjs";
+import { u as ROUTE_METADATA_KEYS } from "./exception-context-B4kM-M53.mjs";
+import { r as z } from "./zod-hMa3rSHV.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-CdjKFJZZ.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"http-method.decorator-CdjKFJZZ.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,KAAK,EAAE;IACxC;GAED,eACE,oBAAoB,cACpB,UACA,QACA,YACD;GAGD,MAAM,WACJ,YAAsB,oBAAoB,mBAAmB,OAAO,IAAI,EAAE;GAC5E,SAAS,KAAK,YAAY;GAC1B,eAAe,oBAAoB,mBAAmB,UAAU,OAAO;GAEvE,OAAO;;;;;;;;;;;;;;;;;;;;;;AAuBb,MAAa,MAAM,0BAA0B,MAAM;;;;;;;;;;;;;;;;AAiBnD,MAAa,OAAO,0BAA0B,OAAO;;;;;;;AAQrD,MAAa,MAAM,0BAA0B,MAAM;;;;;;;AAQnD,MAAa,QAAQ,0BAA0B,QAAQ;;;;;;;AAQvD,MAAa,SAAS,0BAA0B,SAAS;;;;;;;;;AAUzD,MAAa,MAAM,0BAA0B,MAAM"}

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 { On as ModuleContext, jn as OnInitialize, wn as DynamicModule, xr as ApplicationError } from "../index-DEncMcC6.mjs";
+import { _ as Prefixes, d as AppMessages, f as DeepKeys, g as MessageParams, h as MessageKeys, l as AppMessageKeys, m as MessageKeyPrefix, p as II18nService, u as AppMessageNamespaces, v as SystemMessageKeys } from "../zod-DvWTfRpI.mjs";
+import { t as index_d_exports } from "../index-KMgSCSM7.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, 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,gBAAA;;;;;;;;;ACgB/B;;KAAY,iBAAA;AAAA,UAEF,aAAA;EAFmB;EAI3B,OAAA;AAAA;;;;AA0BF;;;;;;;;;;;;;;;;;;;;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;;;;;;AAmBF;;;;;EA/CI,mBAAA;AAAA;EAEE,OAAA;AAAA;;;;;;AA4DN;;;;;;;;UA7CiB,iBAAA;EAiED;;;;EA5Dd,aAAA;EA4DiE;;;;EAtDjE,cAAA;EAsDiE;;;;EAhDjE,OAAA;;;ACzFF;;ED+FE,SAAA,GAAY,wBAAA;AAAA;;;;;UAOG,mBAAA;EACf,aAAA;EACA,cAAA;EACA,OAAA;EACA,SAAA;IACE,OAAA;IACA,QAAA,EAAU,iBAAA,ECpGC;IDsGX,mBAAA;EAAA;AAAA;;;;iBAOY,kBAAA,CAAmB,OAAA,GAAU,iBAAA,GAAoB,mBAAA;;;;iBAoBjD,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,8BAAQ;EAAA;;;;;;;;;cIWlB,QAAA;EAAA,oBAA0B,eAAA;AAAA;AHKvC;;;AAAA,KGAY,QAAA,UAAkB,QAAA;;AHA8C;;iBGK5D,WAAA,CAAA,GAAe,MAAA,SAAe,MAAA;;;AHyB9C;iBGlBgB,UAAA,CAAA;;;;;;;;;AJ5BhB;;;cK+Ba,eAAA;EL/BkC;;;EAAA,OKmCtC,WAAA,CAAY,QAAA,EAAU,MAAA,SAAe,MAAA;EJnBlC;;;EI4BV,iBAAA,CAAA,GAAqB,MAAA,SAAe,MAAA;EJ5BT;AAA+C;;;EAA/C,OI+CpB,KAAA,CAAA;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,CAAA;EAIA,iBAAA,CAAkB,MAAA;EAIlB,gBAAA,CAAA;EAIA,mBAAA,CACE,MAAA,UACA,OAAA;IAAY,IAAA,GAAO,gBAAA;EAAA,IAClB,MAAA;EAAA,QAeK,mBAAA;EAAA,QAmBA,eAAA;AAAA;;;;;;;;ANxGV;;;;;;;;ACgBA;;;;;AAA4E;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-GpNNz79X.mjs";
+import "../errors-BBZTnjdq.mjs";
+import { t as I18N_TOKENS } from "../i18n.tokens-hwRpmjRq.mjs";
+import { c as buildDetectorOptions, l as resolveI18nOptions } from "../router-Cy6DjkvP.mjs";
+import { a as getMessages, i as getLocales, n as MessageRegistry, o as messages, r as MessageLoaderService, t as I18nModule } from "../i18n.module-BlXrtAlV.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;;;;;;;;;;;;;;;;;;;;;;ACqBhD,SAAgB,SAAS,KAAkB,QAAgC;CACzE,IAAI;EAGF,OAFkB,cACI,CAAC,QAAsB,YAAY,YAC9C,CAAC,EAAE,KAAK,OAAO;SACpB;EACN,OAAO"}

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-KMgSCSM7.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-BPP6h6y5.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"}

package/dist/i18n/utils/index.mjs

@@ -1,2 +1,2 @@
-import { t as setupI18nCompiler } from "../../setup-CefZKV_e.mjs";
-export { setupI18nCompiler };
+import { t as deepMerge } from "../../deep-merge-C8NgcXw4.mjs";
+export { deepMerge };

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

@@ -1,4 +1,5 @@
-import { c as runWithErrorMapContext, d as LocaleProvider, f as ZodCustomIssue, h as withI18n, i as ZodError, l as ErrorMapContext, m as cuid2, n as OpenAPIObject, o as z, p as CUID2_REGEX, r as PathItemObject, s as backendErrorMap, t as OpenAPIHono, u as I18nErrorMetadata } from "../../index-Bnpfq6uk.mjs";
+import { a as z, b as cuid2, c as ZodCustomIssue, i as ZodError, n as OpenAPIObject, r as PathItemObject, s as I18nErrorMetadata, t as OpenAPIHono, y as CUID2_REGEX } from "../../zod-DvWTfRpI.mjs";
+import { n as withZodI18n, t as zodErrorMap } from "../../index-Dj5IMwtr.mjs";
 export * from "@hono/zod-openapi";
 export * from "zod";
-export { CUID2_REGEX, ErrorMapContext, I18nErrorMetadata, LocaleProvider, OpenAPIHono, OpenAPIObject, PathItemObject, ZodCustomIssue, ZodError, backendErrorMap, cuid2, runWithErrorMapContext, withI18n, z };
+export { CUID2_REGEX, I18nErrorMetadata, OpenAPIHono, OpenAPIObject, PathItemObject, ZodCustomIssue, ZodError, cuid2, withZodI18n, z, zodErrorMap };

package/dist/i18n/validation/index.mjs

@@ -1,3 +1,5 @@
-import { a as CUID2_REGEX, c as backendErrorMap, i as z, l as runWithErrorMapContext, n as ZodError, o as cuid2, s as withI18n, t as OpenAPIHono } from "../../validation-DtJwAv7O.mjs";
+import { a as CUID2_REGEX, n as ZodError, o as cuid2, r as z, t as OpenAPIHono } from "../../zod-hMa3rSHV.mjs";
+import { t as zodErrorMap } from "../../validation.context-XTysWJ3b.mjs";
+import { t as withZodI18n } from "../../validation-DUzcjb8Q.mjs";
 export * from "@hono/zod-openapi";
-export { CUID2_REGEX, OpenAPIHono, ZodError, backendErrorMap, cuid2, runWithErrorMapContext, withI18n, z };
+export { CUID2_REGEX, OpenAPIHono, ZodError, cuid2, withZodI18n, z, zodErrorMap };

package/dist/i18n.module-BlXrtAlV.mjs

@@ -0,0 +1,219 @@
+import { l as Request, m as inject, o as ROUTER_TOKENS, u as Singleton } from "./di-BO1QIb5H.mjs";
+import { n as __decorateParam, t as __decorate } from "./decorate-HgTKAYK8.mjs";
+import { f as Module } from "./module-xYoHba6B.mjs";
+import { t as I18N_TOKENS } from "./i18n.tokens-hwRpmjRq.mjs";
+import { r as z } from "./zod-hMa3rSHV.mjs";
+import "./router-Cy6DjkvP.mjs";
+import { t as en_exports } from "./en-BPP6h6y5.mjs";
+import { t as deepMerge } from "./deep-merge-C8NgcXw4.mjs";
+import { t as zodErrorMap } from "./validation.context-XTysWJ3b.mjs";
+import IntlMessageFormat from "intl-messageformat";
+//#region src/i18n/services/i18n.service.ts
+let I18nService = class I18nService {
+	loader;
+	routerContext;
+	constructor(loader, routerContext) {
+		this.loader = loader;
+		this.routerContext = routerContext;
+	}
+	t(key, params) {
+		return this.loader.translate(this.getLocale(), key, params);
+	}
+	getLocale() {
+		return this.routerContext?.getLocale() ?? "en";
+	}
+};
+I18nService = __decorate([
+	Request(I18N_TOKENS.I18nService),
+	__decorateParam(0, inject(I18N_TOKENS.MessageLoader)),
+	__decorateParam(1, inject(ROUTER_TOKENS.RouterContext, { isOptional: true }))
+], I18nService);
+//#endregion
+//#region src/i18n/messages/index.ts
+/**
+* Core Messages
+*
+* Messages used by packages/modules infrastructure.
+* These are automatically merged with application-specific messages.
+*/
+/**
+* All locale messages
+* Explicitly import and export (no filesystem scanning - Cloudflare Workers compatible)
+*/
+const messages = { en: en_exports };
+/**
+* Get messages for all locales
+*/
+function getMessages() {
+	return messages;
+}
+/**
+* Get available locales
+*/
+function getLocales() {
+	return Object.keys(messages);
+}
+//#endregion
+//#region src/i18n/services/message-loader.service.ts
+let MessageLoaderService = class MessageLoaderService {
+	registry;
+	options;
+	cache;
+	compiledCache;
+	locales;
+	defaultLocale;
+	constructor(registry, options) {
+		this.registry = registry;
+		this.options = options;
+		this.defaultLocale = this.options?.defaultLocale ?? "en";
+		this.cache = /* @__PURE__ */ new Map();
+		this.compiledCache = /* @__PURE__ */ new Map();
+		const coreMessages = getMessages();
+		const coreLocales = getLocales();
+		const registryMessages = this.registry.getMergedMessages();
+		const registryLocales = Object.keys(registryMessages);
+		const allLocales = [...new Set([...coreLocales, ...registryLocales])];
+		this.locales = allLocales;
+		for (const locale of allLocales) {
+			const merged = deepMerge(coreMessages[locale] ?? {}, registryMessages[locale] ?? {});
+			this.cache.set(locale, merged);
+		}
+	}
+	translate(locale, key, params) {
+		const fn = this.getCompiledMessages(locale)[key];
+		if (!fn) return key;
+		return fn(params);
+	}
+	getMessages(locale) {
+		return this.cache.get(locale) ?? this.cache.get(this.defaultLocale) ?? {};
+	}
+	getAvailableLocales() {
+		return this.locales;
+	}
+	isLocaleSupported(locale) {
+		return this.cache.has(locale);
+	}
+	getDefaultLocale() {
+		return this.defaultLocale;
+	}
+	getFilteredMessages(locale, options) {
+		const messages = this.getMessages(locale);
+		const flattened = this.flattenMessages(messages);
+		if (!options?.only?.length) return flattened;
+		const result = {};
+		for (const [key, value] of Object.entries(flattened)) if (options.only.some((prefix) => key === prefix || key.startsWith(`${prefix}.`))) result[key] = value;
+		return result;
+	}
+	getCompiledMessages(locale) {
+		const effectiveLocale = this.cache.has(locale) ? locale : this.defaultLocale;
+		const cached = this.compiledCache.get(effectiveLocale);
+		if (cached) return cached;
+		const messages = this.cache.get(effectiveLocale) ?? {};
+		const flattened = this.flattenMessages(messages);
+		const compiled = {};
+		for (const [key, value] of Object.entries(flattened)) {
+			const msg = new IntlMessageFormat(value, effectiveLocale);
+			compiled[key] = (params) => String(msg.format(params));
+		}
+		this.compiledCache.set(effectiveLocale, compiled);
+		return compiled;
+	}
+	flattenMessages(messages, prefix = "") {
+		const result = {};
+		for (const key of Object.keys(messages)) {
+			const value = messages[key];
+			const newKey = prefix ? `${prefix}.${key}` : key;
+			if (typeof value === "object" && value !== null && !Array.isArray(value)) Object.assign(result, this.flattenMessages(value, newKey));
+			else result[newKey] = String(value);
+		}
+		return result;
+	}
+};
+MessageLoaderService = __decorate([
+	Singleton(I18N_TOKENS.MessageLoader),
+	__decorateParam(0, inject(I18N_TOKENS.MessageRegistry)),
+	__decorateParam(1, inject(I18N_TOKENS.Options, { isOptional: true }))
+], MessageLoaderService);
+//#endregion
+//#region src/i18n/services/message-registry.ts
+/**
+* Global key for the shared contributions array.
+*
+* When stratal is installed via portal/symlink (e.g., in monorepos), bundlers
+* like esbuild may inline multiple copies of this module. Each copy gets its
+* own static class fields, so messages registered by one copy are invisible
+* to another. Using a `Symbol.for()` key on `globalThis` ensures all copies
+* share the same contributions array.
+*/
+const CONTRIBUTIONS_KEY = Symbol.for("stratal:i18n:message-registry:contributions");
+function getContributions() {
+	const g = globalThis;
+	g[CONTRIBUTIONS_KEY] ??= [];
+	return g[CONTRIBUTIONS_KEY];
+}
+let MessageRegistry = class MessageRegistry {
+	/**
+	* Add messages (called statically by I18nModule.registerMessages)
+	*/
+	static addMessages(messages) {
+		if (Boolean(messages) && typeof messages === "object" && Object.keys(messages).length > 0) getContributions().push(messages);
+	}
+	/**
+	* Get all messages deep-merged in registration order
+	*/
+	getMergedMessages() {
+		const merged = {};
+		for (const contribution of getContributions()) for (const locale of Object.keys(contribution)) merged[locale] = deepMerge(merged[locale] ?? {}, contribution[locale]);
+		return merged;
+	}
+	/**
+	* Reset registry (for testing)
+	* @internal
+	*/
+	static reset() {
+		globalThis[CONTRIBUTIONS_KEY] = [];
+	}
+};
+MessageRegistry = __decorate([Singleton(I18N_TOKENS.MessageRegistry)], MessageRegistry);
+//#endregion
+//#region src/i18n/i18n.module.ts
+var _I18nModule;
+let I18nModule = _I18nModule = class I18nModule {
+	onInitialize(_context) {
+		z.config({ customError: zodErrorMap });
+	}
+	static forRoot(options = {}) {
+		return {
+			module: _I18nModule,
+			providers: [{
+				provide: I18N_TOKENS.Options,
+				useValue: options
+			}]
+		};
+	}
+	static registerMessages(messages) {
+		MessageRegistry.addMessages(messages);
+		return {
+			module: _I18nModule,
+			providers: []
+		};
+	}
+};
+I18nModule = _I18nModule = __decorate([Module({ providers: [
+	{
+		provide: I18N_TOKENS.MessageRegistry,
+		useClass: MessageRegistry
+	},
+	{
+		provide: I18N_TOKENS.MessageLoader,
+		useClass: MessageLoaderService
+	},
+	{
+		provide: I18N_TOKENS.I18nService,
+		useClass: I18nService
+	}
+] })], I18nModule);
+//#endregion
+export { getMessages as a, getLocales as i, MessageRegistry as n, messages as o, MessageLoaderService as r, I18nModule as t };
+
+//# sourceMappingURL=i18n.module-BlXrtAlV.mjs.map