@velajs/vela 1.9.0 → 1.12.0

package/dist/http/route.manager.js

@@ -1,10 +1,11 @@
 import { Hono } from "hono";
+import { contextStorage } from "hono/context-storage";
 import { HttpMethod } from "../constants.js";
 import { HttpException } from "../errors/http-exception.js";
 import { getMetadata } from "../metadata.js";
 import { joinPaths } from "../registry/paths.js";
 import { ArgumentResolver } from "./argument-resolver.js";
-import { getCrudBridge } from "./crud-bridge.js";
+import { getRouteContributors } from "./route-contributor.js";
 import { buildMiddlewareExecutionContext } from "./execution-context.js";
 import { HandlerExecutor } from "./handler-executor.js";
 import { instantiate, instantiateMany } from "./instantiate.js";
@@ -14,6 +15,39 @@ import { ComponentManager } from "../pipeline/component.manager.js";
 import { shouldFilterCatch } from "../pipeline/decorators.js";
 import { MetadataRegistry } from "../registry/metadata.registry.js";
 const defaultGetClientIp = (c)=>c.req.raw.headers.get('x-forwarded-for')?.split(',')[0]?.trim() ?? c.req.raw.headers.get('x-real-ip') ?? null;
+// Mirror a response body stream, invoking `onDone` exactly once when it is fully
+// read, errors, or is cancelled. Lets request-scoped resources be disposed only
+// after the body has drained — never mid-stream.
+function disposeStreamWhenDone(body, onDone) {
+    const reader = body.getReader();
+    let finished = false;
+    const finish = ()=>{
+        if (!finished) {
+            finished = true;
+            onDone();
+        }
+    };
+    return new ReadableStream({
+        async pull (controller) {
+            try {
+                const { done, value } = await reader.read();
+                if (done) {
+                    controller.close();
+                    finish();
+                    return;
+                }
+                controller.enqueue(value);
+            } catch (error) {
+                controller.error(error);
+                finish();
+            }
+        },
+        cancel (reason) {
+            finish();
+            return reader.cancel(reason);
+        }
+    });
+}
 export class RouteManager {
     container;
     static METHOD_REGISTRAR = new Map([
@@ -59,8 +93,10 @@ export class RouteManager {
     globalPrefix = '';
     consumerMiddlewareDefinitions = [];
     handlerExecutor;
+    ambientContainer;
     constructor(container, options = {}){
         this.container = container;
+        this.ambientContainer = options.ambientContainer ?? false;
         const argumentResolver = new ArgumentResolver(options.getClientIp ?? defaultGetClientIp);
         this.handlerExecutor = new HandlerExecutor(argumentResolver, ()=>({
                 guards: this.globalGuards,
@@ -69,6 +105,19 @@ export class RouteManager {
                 filters: this.globalFilters
             }), (c)=>this.getRequestContainer(c));
     }
+    /**
+   * The global-tier components (`APP_*` provider tokens + imperative
+   * `app.useGlobalX()` instances). Exposed so non-HTTP transports (the
+   * WebSocket dispatcher) can apply the same app-wide guards/pipes/interceptors/
+   * filters as HTTP routes, read live so late registrations propagate.
+   */ getGlobalComponents() {
+        return {
+            guards: this.globalGuards,
+            pipes: this.globalPipes,
+            interceptors: this.globalInterceptors,
+            filters: this.globalFilters
+        };
+    }
     registerConsumerMiddleware(definitions) {
         this.consumerMiddlewareDefinitions.push(...definitions);
         return this;
@@ -221,6 +270,41 @@ export class RouteManager {
     }
     async build() {
         const app = new Hono();
+        // Outermost: dispose the per-request child container once the request is
+        // fully done. Fast-paths out when the child has no request-scoped
+        // disposables (the common case → zero overhead / no behavior change).
+        // Streaming-safe: when a response body is present, disposal is deferred
+        // until the body is fully read (or errors/cancels), never mid-stream.
+        app.use('*', async (c, next)=>{
+            let threw = false;
+            try {
+                await next();
+            } catch (error) {
+                threw = true;
+                throw error;
+            } finally{
+                const child = c.get('container');
+                if (child?.hasDisposables()) {
+                    const body = threw ? null : c.res?.body ?? null;
+                    if (body) {
+                        // Defer disposal to when the runtime finishes reading the body.
+                        c.res = new Response(disposeStreamWhenDone(body, ()=>void child.dispose()), {
+                            status: c.res.status,
+                            statusText: c.res.statusText,
+                            headers: c.res.headers
+                        });
+                    } else {
+                        // No body (or error path) — nothing streaming, dispose now.
+                        await child.dispose();
+                    }
+                }
+            }
+        });
+        // Opt-in ambient container: contextStorage() must be an early middleware so
+        // getContext() is available to everything downstream.
+        if (this.ambientContainer) {
+            app.use('*', contextStorage());
+        }
         // Sort global middleware by priority (lower runs first) with insertion
         // index as tiebreaker so equal priorities preserve registration order.
         const sortedGlobal = this.globalMiddleware.map((entry, index)=>({
@@ -264,7 +348,9 @@ export class RouteManager {
                 for (const route of routes){
                     const effectiveVersion = route.version ?? metadata.version;
                     const versionedPaths = this.buildVersionedPaths(this.globalPrefix, metadata.prefix, route.path, effectiveVersion);
-                    const middlewareItems = ComponentManager.getComponents('middleware', controller, route.handlerName);
+                    // Scoped (controller/handler) middleware only — global middleware is
+                    // applied once by this manager's own global pass, never re-read here.
+                    const middlewareItems = ComponentManager.getScopedComponents('middleware', controller, route.handlerName);
                     const handler = this.handlerExecutor.create(route, controller, allParamMetadata);
                     for (const fullPath of versionedPaths){
                         for (const middlewareItem of middlewareItems){
@@ -279,26 +365,33 @@ export class RouteManager {
                 }
             }
         }
-        // Second pass: mount CRUD sub-apps (/:id routes registered last).
-        //
-        // Routes are produced by a registered CrudBridge — usually contributed
-        // by `@velajs/crud` as an import side effect. Inversion was deliberate:
-        // a previous implementation called `await import('@velajs/crud')` via
-        // an indirect variable to dodge esbuild's static analysis, which made
-        // Cloudflare Workers unable to resolve the module at runtime. The
-        // bridge contract removes that hazard — no runtime resolver involved.
+        // Second pass: route contributors (generated routes registered last, so a
+        // contributor's `/:id` catch-alls never shadow explicit routes). Each
+        // contributor claims controllers by class-level metadata; `@velajs/crud`
+        // registers one as an import side effect. The registry contract (instead
+        // of dynamic `import()`) exists because esbuild leaves
+        // `await import(variable)` as a runtime import Cloudflare Workers cannot
+        // resolve.
+        const contributors = getRouteContributors();
         for (const { controller, metadata } of this.controllers){
-            const crudConfig = getMetadata('vela:crud', controller);
-            if (!crudConfig) continue;
-            const bridge = getCrudBridge();
-            if (!bridge) {
+            for (const contributor of contributors){
+                const meta = getMetadata(contributor.claimsMetaKey, controller);
+                if (meta === undefined) continue;
+                await contributor.buildRoutes(app, {
+                    controller,
+                    controllerPrefix: metadata.prefix,
+                    meta,
+                    globalPrefix: this.globalPrefix,
+                    globalGuards: instantiateMany(this.globalGuards, this.container),
+                    container: this.container,
+                    joinPaths
+                });
+            }
+            // DX guard for the common mistake: @Crud() metadata present but the
+            // contributor package never imported.
+            if (getMetadata('vela:crud', controller) !== undefined && !contributors.some((c)=>c.claimsMetaKey === 'vela:crud')) {
                 throw new Error("@Crud() requires '@velajs/crud'. Install it: pnpm add @velajs/crud");
             }
-            await bridge.buildRoutes(app, controller, metadata.prefix, crudConfig, {
-                globalPrefix: this.globalPrefix,
-                globalGuards: instantiateMany(this.globalGuards, this.container),
-                joinPaths
-            });
         }
         return app;
     }

package/dist/i18n/deep-merge.d.ts

@@ -0,0 +1,2 @@
+/** Deep-merge two message trees; source overrides target at the leaf level. */
+export declare function deepMerge(target: Record<string, unknown>, source: Record<string, unknown>): Record<string, unknown>;

package/dist/i18n/deep-merge.js

@@ -0,0 +1,15 @@
+/** Deep-merge two message trees; source overrides target at the leaf level. */ export function deepMerge(target, source) {
+    const result = {
+        ...target
+    };
+    for (const key of Object.keys(source)){
+        const targetValue = target[key];
+        const sourceValue = source[key];
+        if (typeof targetValue === 'object' && targetValue !== null && !Array.isArray(targetValue) && typeof sourceValue === 'object' && sourceValue !== null && !Array.isArray(sourceValue)) {
+            result[key] = deepMerge(targetValue, sourceValue);
+        } else {
+            result[key] = sourceValue;
+        }
+    }
+    return result;
+}

package/dist/i18n/i18n.middleware.d.ts

@@ -0,0 +1,15 @@
+import type { Context, Next } from 'hono';
+import type { NestMiddleware } from '../pipeline/types';
+import { type I18nModuleOptions } from './i18n.options';
+/**
+ * Detects the request locale and stashes it on the per-request RequestContext
+ * bag under {@link I18N_LOCALE_KEY}, where {@link I18nService} reads it.
+ * Registered globally via APP_MIDDLEWARE by {@link I18nModule}. Holds no
+ * per-request state (reads the RequestContext off the request container each
+ * call), so a singleton instance is safe.
+ */
+export declare class I18nLocaleMiddleware implements NestMiddleware {
+    private readonly resolved;
+    constructor(options: I18nModuleOptions);
+    use(c: Context, next: Next): Promise<Response | void>;
+}

package/dist/i18n/i18n.middleware.js

@@ -0,0 +1,94 @@
+function _ts_decorate(decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+function _ts_metadata(k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+function _ts_param(paramIndex, decorator) {
+    return function(target, key) {
+        decorator(target, key, paramIndex);
+    };
+}
+import { Inject, Injectable } from "../container/decorators.js";
+import { REQUEST_CONTEXT } from "../http/request-context.js";
+import { resolveI18nOptions } from "./i18n.options.js";
+import { I18N_LOCALE_KEY, I18N_OPTIONS } from "./i18n.tokens.js";
+export class I18nLocaleMiddleware {
+    resolved;
+    constructor(options){
+        this.resolved = resolveI18nOptions(options);
+    }
+    async use(c, next) {
+        const container = c.get('container');
+        if (container) {
+            const ctx = container.resolve(REQUEST_CONTEXT);
+            ctx.set(I18N_LOCALE_KEY, detectLocale(c, this.resolved));
+        }
+        return next();
+    }
+}
+I18nLocaleMiddleware = _ts_decorate([
+    Injectable(),
+    _ts_param(0, Inject(I18N_OPTIONS)),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof I18nModuleOptions === "undefined" ? Object : I18nModuleOptions
+    ])
+], I18nLocaleMiddleware);
+function detectLocale(c, resolved) {
+    if (!resolved.detection.enabled) return resolved.defaultLocale;
+    const { strategy, lookupKey } = resolved.detection;
+    // Candidate tags in preference order.
+    const candidates = strategy === 'query' ? [
+        new URL(c.req.url).searchParams.get(lookupKey) ?? ''
+    ] : strategy === 'cookie' ? [
+        readCookie(c.req.raw.headers.get('cookie'), lookupKey) ?? ''
+    ] : parseAcceptLanguage(c.req.raw.headers.get('accept-language'));
+    for (const candidate of candidates){
+        const match = matchLocale(candidate, resolved.locales);
+        if (match) return match;
+    }
+    return resolved.defaultLocale;
+}
+/** Case-insensitive locale match with region fallback (en-US -> en); returns the configured casing. */ function matchLocale(candidate, locales) {
+    if (!candidate) return undefined;
+    const lc = candidate.toLowerCase();
+    const exact = locales.find((l)=>l.toLowerCase() === lc);
+    if (exact) return exact;
+    const base = lc.split('-')[0];
+    return locales.find((l)=>l.toLowerCase().split('-')[0] === base);
+}
+/** Parse Accept-Language into tags ordered by descending q-value (RFC 7231). */ function parseAcceptLanguage(header) {
+    if (!header) return [];
+    return header.split(',').map((part)=>{
+        const [tag, ...params] = part.trim().split(';');
+        let q = 1;
+        for (const p of params){
+            const m = p.trim().match(/^q=([\d.]+)$/);
+            if (m) q = Number.parseFloat(m[1]);
+        }
+        return {
+            tag: (tag ?? '').trim(),
+            q: Number.isNaN(q) ? 0 : q
+        };
+    }).filter((e)=>e.tag && e.tag !== '*').sort((a, b)=>b.q - a.q).map((e)=>e.tag);
+}
+function readCookie(header, name) {
+    if (!header) return undefined;
+    for (const part of header.split(';')){
+        const [rawKey, ...rest] = part.split('=');
+        if (rawKey?.trim() === name) {
+            const raw = rest.join('=').trim();
+            try {
+                return decodeURIComponent(raw);
+            } catch  {
+                // Malformed percent-encoding must not crash locale detection.
+                return raw;
+            }
+        }
+    }
+    return undefined;
+}

package/dist/i18n/i18n.module.d.ts

@@ -0,0 +1,13 @@
+import type { DynamicModule } from '../module/types';
+import type { I18nModuleOptions } from './i18n.options';
+declare const ConfigurableModuleClass: import("..").ConfigurableModuleClassType<I18nModuleOptions, "forRoot", "create", {
+    isGlobal?: boolean;
+}>;
+export declare class I18nModule extends ConfigurableModuleClass {
+    /**
+     * forFeature-style: contribute a message tree (`{ [locale]: { ...messages } }`).
+     * Contributions are collected statically at module-load and deep-merged.
+     */
+    static registerMessages(messages: Record<string, Record<string, unknown>>): DynamicModule;
+}
+export {};

package/dist/i18n/i18n.module.js

@@ -0,0 +1,64 @@
+function _ts_decorate(decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+import { Module } from "../module/decorators.js";
+import { ConfigurableModuleBuilder } from "../module/configurable-module.builder.js";
+import { stableHash } from "../module/stable-hash.js";
+import { APP_MIDDLEWARE } from "../pipeline/tokens.js";
+import { I18nLocaleMiddleware } from "./i18n.middleware.js";
+import { I18nService } from "./i18n.service.js";
+import { I18N_OPTIONS } from "./i18n.tokens.js";
+import { MessageLoaderService } from "./message-loader.service.js";
+import { MessageRegistry } from "./message-registry.js";
+const { ConfigurableModuleClass } = new ConfigurableModuleBuilder({
+    moduleName: 'I18n',
+    optionsInjectionToken: I18N_OPTIONS
+}).build();
+// Empty marker module for `registerMessages`. The contribution is a side-effect
+// on the global MessageRegistry; this carries NO providers so it never
+// duplicates I18nModule's providers (which would trip vela's multi-instance
+// encapsulation → MultipleProvidersFoundError). New modules whose contribution
+// is providers (not an external registry) should use `sideEffectModule` from
+// the authoring kit; this predates it and keeps a shared-class identity so
+// identical message trees dedup as one module instance.
+let I18nMessagesModule = class I18nMessagesModule {
+};
+I18nMessagesModule = _ts_decorate([
+    Module({})
+], I18nMessagesModule);
+export class I18nModule extends ConfigurableModuleClass {
+    /**
+   * forFeature-style: contribute a message tree (`{ [locale]: { ...messages } }`).
+   * Contributions are collected statically at module-load and deep-merged.
+   */ static registerMessages(messages) {
+        MessageRegistry.addMessages(messages);
+        return {
+            module: I18nMessagesModule,
+            key: `messages:${stableHash(messages)}`,
+            providers: []
+        };
+    }
+}
+I18nModule = _ts_decorate([
+    Module({
+        providers: [
+            MessageRegistry,
+            MessageLoaderService,
+            I18nService,
+            I18nLocaleMiddleware,
+            // Register the locale middleware globally (NestJS APP_MIDDLEWARE convention).
+            {
+                provide: APP_MIDDLEWARE,
+                useExisting: I18nLocaleMiddleware
+            }
+        ],
+        exports: [
+            I18nService,
+            MessageLoaderService,
+            I18N_OPTIONS
+        ]
+    })
+], I18nModule);

package/dist/i18n/i18n.options.d.ts

@@ -0,0 +1,30 @@
+/** How the request locale is detected. */
+export type DetectionStrategy = 'header' | 'query' | 'cookie';
+export interface I18nModuleOptions {
+    /** Default locale. @default 'en' */
+    defaultLocale?: string;
+    /** Fallback when a translation is missing. @default defaultLocale */
+    fallbackLocale?: string;
+    /** Supported locales; request locales outside this list fall back to default. @default ['en'] */
+    locales?: string[];
+    /** Locale detection config. */
+    detection?: {
+        /** Set false to disable detection (always use defaultLocale). @default true */
+        enabled?: boolean;
+        /** @default 'header' (Accept-Language) */
+        strategy?: DetectionStrategy;
+        /** Cookie/query parameter name. @default 'locale' */
+        lookupKey?: string;
+    };
+}
+export interface ResolvedI18nOptions {
+    defaultLocale: string;
+    fallbackLocale: string;
+    locales: string[];
+    detection: {
+        enabled: boolean;
+        strategy: DetectionStrategy;
+        lookupKey: string;
+    };
+}
+export declare function resolveI18nOptions(options?: I18nModuleOptions): ResolvedI18nOptions;

package/dist/i18n/i18n.options.js

@@ -0,0 +1,16 @@
+/** How the request locale is detected. */ export function resolveI18nOptions(options) {
+    const detection = options?.detection;
+    const defaultLocale = options?.defaultLocale ?? 'en';
+    return {
+        defaultLocale,
+        fallbackLocale: options?.fallbackLocale ?? defaultLocale,
+        locales: options?.locales ?? [
+            'en'
+        ],
+        detection: {
+            enabled: detection?.enabled !== false,
+            strategy: detection?.strategy ?? 'header',
+            lookupKey: detection?.lookupKey ?? 'locale'
+        }
+    };
+}

package/dist/i18n/i18n.service.d.ts

@@ -0,0 +1,20 @@
+import { type RequestContext } from '../http/request-context';
+import type { I18nModuleOptions } from './i18n.options';
+import type { II18nService } from './i18n.types';
+import { MessageLoaderService } from './message-loader.service';
+/**
+ * Request-scoped translation facade. Reads the locale resolved by
+ * {@link I18nLocaleMiddleware} from the per-request RequestContext.
+ *
+ * Injecting it into a controller/service is safe: vela's request-scope bubbling
+ * promotes the consumer to request scope automatically, so no captive-dependency
+ * hazard and no `ambientContainer` flag required.
+ */
+export declare class I18nService implements II18nService {
+    private readonly loader;
+    private readonly ctx;
+    private readonly options;
+    constructor(loader: MessageLoaderService, ctx: RequestContext, options: I18nModuleOptions);
+    t(key: string, params?: Record<string, unknown>): string;
+    getLocale(): string;
+}

package/dist/i18n/i18n.service.js

@@ -0,0 +1,49 @@
+function _ts_decorate(decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+function _ts_metadata(k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+function _ts_param(paramIndex, decorator) {
+    return function(target, key) {
+        decorator(target, key, paramIndex);
+    };
+}
+import { Scope } from "../constants.js";
+import { Inject, Injectable } from "../container/decorators.js";
+import { REQUEST_CONTEXT } from "../http/request-context.js";
+import { I18N_LOCALE_KEY, I18N_OPTIONS } from "./i18n.tokens.js";
+import { MessageLoaderService } from "./message-loader.service.js";
+export class I18nService {
+    loader;
+    ctx;
+    options;
+    constructor(loader, ctx, options){
+        this.loader = loader;
+        this.ctx = ctx;
+        this.options = options;
+    }
+    t(key, params) {
+        return this.loader.translate(this.getLocale(), key, params);
+    }
+    getLocale() {
+        return this.ctx.get(I18N_LOCALE_KEY) ?? this.options.defaultLocale ?? 'en';
+    }
+}
+I18nService = _ts_decorate([
+    Injectable({
+        scope: Scope.REQUEST
+    }),
+    _ts_param(0, Inject(MessageLoaderService)),
+    _ts_param(1, Inject(REQUEST_CONTEXT)),
+    _ts_param(2, Inject(I18N_OPTIONS)),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof MessageLoaderService === "undefined" ? Object : MessageLoaderService,
+        typeof RequestContext === "undefined" ? Object : RequestContext,
+        typeof I18nModuleOptions === "undefined" ? Object : I18nModuleOptions
+    ])
+], I18nService);

package/dist/i18n/i18n.tokens.d.ts

@@ -0,0 +1,6 @@
+import { InjectionToken } from '../container/types';
+import type { I18nModuleOptions } from './i18n.options';
+/** Options bag from `I18nModule.forRoot()` (the ConfigurableModuleBuilder options token). */
+export declare const I18N_OPTIONS: InjectionToken<I18nModuleOptions>;
+/** Key under which the resolved locale is stashed on the per-request RequestContext bag. */
+export declare const I18N_LOCALE_KEY: unique symbol;

package/dist/i18n/i18n.tokens.js

@@ -0,0 +1,3 @@
+import { InjectionToken } from "../container/types.js";
+/** Options bag from `I18nModule.forRoot()` (the ConfigurableModuleBuilder options token). */ export const I18N_OPTIONS = new InjectionToken('I18N_OPTIONS');
+/** Key under which the resolved locale is stashed on the per-request RequestContext bag. */ export const I18N_LOCALE_KEY = Symbol.for('vela:i18n:locale');

package/dist/i18n/i18n.types.d.ts

@@ -0,0 +1,6 @@
+export interface II18nService {
+    /** Translate `key` (dot-path into the message tree) with optional ICU params. */
+    t(key: string, params?: Record<string, unknown>): string;
+    /** The resolved locale for the current request. */
+    getLocale(): string;
+}

package/dist/i18n/i18n.types.js

@@ -0,0 +1 @@
+export { };

package/dist/i18n/index.d.ts

@@ -0,0 +1,10 @@
+export { I18nModule } from './i18n.module';
+export { I18nService } from './i18n.service';
+export { MessageLoaderService } from './message-loader.service';
+export { MessageRegistry } from './message-registry';
+export { I18nLocaleMiddleware } from './i18n.middleware';
+export { I18N_OPTIONS, I18N_LOCALE_KEY } from './i18n.tokens';
+export { resolveI18nOptions } from './i18n.options';
+export { deepMerge } from './deep-merge';
+export type { I18nModuleOptions, ResolvedI18nOptions, DetectionStrategy } from './i18n.options';
+export type { II18nService } from './i18n.types';

package/dist/i18n/index.js

@@ -0,0 +1,8 @@
+export { I18nModule } from "./i18n.module.js";
+export { I18nService } from "./i18n.service.js";
+export { MessageLoaderService } from "./message-loader.service.js";
+export { MessageRegistry } from "./message-registry.js";
+export { I18nLocaleMiddleware } from "./i18n.middleware.js";
+export { I18N_OPTIONS, I18N_LOCALE_KEY } from "./i18n.tokens.js";
+export { resolveI18nOptions } from "./i18n.options.js";
+export { deepMerge } from "./deep-merge.js";

package/dist/i18n/message-loader.service.d.ts

@@ -0,0 +1,21 @@
+import type { I18nModuleOptions } from './i18n.options';
+import { MessageRegistry } from './message-registry';
+/**
+ * Compiles and caches ICU messages (via `intl-messageformat`). Singleton: reads
+ * the merged registry once at construction (all `registerMessages` calls run at
+ * module-load, before providers are instantiated), flattens each locale to
+ * dot-paths, and compiles lazily per locale.
+ */
+export declare class MessageLoaderService {
+    private readonly cache;
+    private readonly compiledCache;
+    private readonly defaultLocale;
+    private readonly fallbackLocale;
+    constructor(registry: MessageRegistry, options: I18nModuleOptions);
+    translate(locale: string, key: string, params?: Record<string, unknown>): string;
+    getAvailableLocales(): string[];
+    isLocaleSupported(locale: string): boolean;
+    getDefaultLocale(): string;
+    private getCompiledMessages;
+    private flattenMessages;
+}