intor 2.3.13 → 2.3.15

package/dist/core/export/index.js

@@ -5,10 +5,9 @@ export { resolveLoaderOptions } from '../src/core/utils/resolve-loader-options.j
 import 'logry';
 export { clearLoggerPool } from '../src/core/logger/global-logger-pool.js';
 export { isValidMessages } from '../src/core/messages/utils/is-valid-messages.js';
-export { clearMessagesPool, setGlobalMessagesPool } from '../src/core/messages/global-messages-pool.js';
+export { clearMessagesPool } from '../src/core/messages/global-messages-pool.js';
 export { mergeMessages } from '../src/core/messages/merge-messages.js';
 export { defineIntorConfig } from '../src/config/define-intor-config.js';
 import '../src/config/constants/cookie.js';
-import '../src/config/constants/cache.js';
 export { localizePathname } from '../src/routing/pathname/localize-pathname.js';
 export { Translator } from 'intor-translator';

package/dist/core/src/config/define-intor-config.js

@@ -1,4 +1,3 @@
-import { resolveCacheOptions } from './resolvers/resolve-cache-options.js';
 import { resolveCookieOptions } from './resolvers/resolve-cookie-options.js';
 import { resolveFallbackLocales } from './resolvers/resolve-fallback-locales.js';
 import { resolveRoutingOptions } from './resolvers/resolve-routing-options.js';
@@ -30,7 +29,6 @@ const defineIntorConfig = (config) => {
     const fallbackLocales = resolveFallbackLocales(config, id, supportedSet);
     const cookie = resolveCookieOptions(config.cookie);
     const routing = resolveRoutingOptions(config.routing);
-    const cache = resolveCacheOptions(config.cache);
     return {
         id,
         messages: config.messages,
@@ -42,7 +40,6 @@ const defineIntorConfig = (config) => {
         cookie,
         routing,
         logger: { id, ...config.logger },
-        cache,
         client: config.client,
         server: config.server,
     };

package/dist/core/src/config/resolvers/resolve-cookie-options.js

@@ -1,5 +1,4 @@
 import { DEFAULT_COOKIE_OPTIONS } from '../constants/cookie.js';
-import '../constants/cache.js';
 
 const resolveCookieOptions = (cookie = {}) => {
     return {

package/dist/core/src/config/resolvers/resolve-fallback-locales.js

@@ -1,6 +1,5 @@
 import '../../core/error/intor-error.js';
 import { getLogger } from '../../core/logger/get-logger.js';
-import 'keyv';
 
 /**
  * Resolves fallbackLocales into a runtime-safe mapping.
@@ -13,7 +12,7 @@ const resolveFallbackLocales = (config, id, supportedSet) => {
     if (!fallbackLocales || typeof fallbackLocales !== "object") {
         return {};
     }
-    const logger = getLogger({ id }).child({
+    const logger = getLogger({ ...config.logger, id }).child({
         scope: "resolve-fallback-locales",
     });
     const resolvedMap = {};

package/dist/core/src/config/resolvers/resolve-routing-options.js

@@ -1,10 +1,8 @@
 import '../../core/error/intor-error.js';
 import { deepMerge } from '../../core/utils/deep-merge.js';
 import 'logry';
-import 'keyv';
 import { DEFAULT_ROUTING_OPTIONS } from '../constants/routing.js';
 import '../constants/cookie.js';
-import '../constants/cache.js';
 
 /**
  * Resolves routing configuration into a fully normalized form.

package/dist/core/src/config/validators/validate-default-locale.js

@@ -1,6 +1,5 @@
 import { IntorError, IntorErrorCode } from '../../core/error/intor-error.js';
 import 'logry';
-import 'keyv';
 
 /**
  * Validates that the configured defaultLocale is supported.

package/dist/core/src/config/validators/validate-id.js

@@ -1,6 +1,5 @@
 import { IntorError, IntorErrorCode } from '../../core/error/intor-error.js';
 import 'logry';
-import 'keyv';
 
 /**
  * Validates that the given id is a non-empty string.

package/dist/core/src/config/validators/validate-supported-locales.js

@@ -1,6 +1,5 @@
 import { IntorError, IntorErrorCode } from '../../core/error/intor-error.js';
 import 'logry';
-import 'keyv';
 
 /**
  * Validates that supportedLocales is provided and non-empty.

package/dist/core/src/core/messages/global-messages-pool.js

@@ -1,27 +1,21 @@
-import Keyv from 'keyv';
-
+/**
+ * Get the global messages pool.
+ *
+ * Lazily initialized to ensure:
+ * - Cross-module sharing
+ * - Dev / HMR safety
+ */
 function getGlobalMessagesPool() {
     if (!globalThis.__INTOR_MESSAGES_POOL__) {
-        globalThis.__INTOR_MESSAGES_POOL__ = new Keyv();
+        const pool = new Map();
+        globalThis.__INTOR_MESSAGES_POOL__ = pool;
     }
     return globalThis.__INTOR_MESSAGES_POOL__;
 }
-/**
- * Replace the global messages pool.
- *
- * - Intended for advanced usage (e.g. Redis, custom cache backends).
- * - Must be called during application bootstrap.
- */
-function setGlobalMessagesPool(pool) {
-    globalThis.__INTOR_MESSAGES_POOL__ = pool;
-}
-/**
- * Optional: clear all cache
- * - Useful in tests or dynamic reloads.
- */
+/** Clear all cached messages. */
 function clearMessagesPool() {
     const pool = getGlobalMessagesPool();
     pool.clear();
 }
 
-export { clearMessagesPool, getGlobalMessagesPool, setGlobalMessagesPool };
+export { clearMessagesPool, getGlobalMessagesPool };

package/dist/core/src/core/messages/load-remote-messages/load-remote-messages.js

@@ -1,5 +1,4 @@
 import { getLogger } from '../../logger/get-logger.js';
-import { normalizeCacheKey } from '../../utils/normalizers/normalize-cache-key.js';
 import { fetchLocaleMessages } from './fetch-locale-messages/fetch-locale-messages.js';
 
 /**
@@ -9,12 +8,11 @@ import { fetchLocaleMessages } from './fetch-locale-messages/fetch-locale-messag
  * It coordinates:
  *
  * - Locale resolution with fallbacks
- * - Cache read / write behavior
  * - Respecting abort signals across the entire async flow
  *
  * Network fetching and data validation are delegated to lower-level utilities.
  */
-const loadRemoteMessages = async ({ id, locale, fallbackLocales, namespaces, rootDir, url, headers, signal, pool, cacheOptions, allowCacheWrite = false, loggerOptions, }) => {
+const loadRemoteMessages = async ({ locale, fallbackLocales, namespaces, rootDir, url, headers, signal, loggerOptions, }) => {
     const baseLogger = getLogger(loggerOptions);
     const logger = baseLogger.child({ scope: "load-remote-messages" });
     // Abort early if the request has already been cancelled
@@ -25,31 +23,6 @@ const loadRemoteMessages = async ({ id, locale, fallbackLocales, namespaces, roo
     const start = performance.now();
     logger.debug("Loading remote messages.", { url });
     // ---------------------------------------------------------------------------
-    // Cache key resolution
-    // ---------------------------------------------------------------------------
-    const cacheKey = normalizeCacheKey([
-        id,
-        "loaderType:remote",
-        rootDir,
-        locale,
-        (fallbackLocales || []).toSorted().join(","),
-        (namespaces || []).toSorted().join(","),
-    ]);
-    // ---------------------------------------------------------------------------
-    // Cache read
-    // ---------------------------------------------------------------------------
-    if (cacheOptions.enabled && cacheKey) {
-        const cached = await pool?.get(cacheKey);
-        if (signal?.aborted) {
-            logger.debug("Remote message loading aborted after cache read.");
-            return;
-        }
-        if (cached) {
-            logger.debug("Messages cache hit.", { key: cacheKey });
-            return cached;
-        }
-    }
-    // ---------------------------------------------------------------------------
     // Resolve locale messages with ordered fallback strategy
     // ---------------------------------------------------------------------------
     const candidateLocales = [locale, ...(fallbackLocales || [])];
@@ -93,18 +66,6 @@ const loadRemoteMessages = async ({ id, locale, fallbackLocales, namespaces, roo
             });
         }
     }
-    // ---------------------------------------------------------------------------
-    // Cache write (explicitly permitted)
-    // ---------------------------------------------------------------------------
-    if (cacheOptions.enabled && allowCacheWrite) {
-        if (signal?.aborted) {
-            logger.debug("Remote message loading aborted before cache write.");
-            return;
-        }
-        if (cacheKey && messages) {
-            await pool?.set(cacheKey, messages, cacheOptions.ttl);
-        }
-    }
     // Final success log with resolved locale and timing
     if (messages) {
         logger.trace("Finished loading remote messages.", {

package/dist/core/src/core/messages/utils/is-valid-messages.js

@@ -3,15 +3,10 @@ function isPlainObject(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 /**
- * Check if a value is a valid **Messages** object.
+ * Check if a value is a valid MessageObject.
  *
- * - Uses an iterative approach to avoid stack overflow with deeply nested objects.
- *
- * @example
- * ```ts
- * isValidMessages({ en: { hello: "Hello" } }) // true
- * isValidMessages({ en: { count: 5 } }) // false
- * ```
+ * - Supports all MessageValue variants (primitive, array, object).
+ * - Uses an iterative approach to avoid stack overflow.
  */
 function isValidMessages(value) {
     if (!isPlainObject(value))
@@ -19,16 +14,29 @@ function isValidMessages(value) {
     const stack = [value];
     while (stack.length > 0) {
         const current = stack.pop();
-        for (const v of Object.values(current)) {
-            if (typeof v === "string")
-                continue;
-            if (isPlainObject(v)) {
-                stack.push(v);
+        // primitives are always valid
+        if (current === null ||
+            typeof current === "string" ||
+            typeof current === "number" ||
+            typeof current === "boolean") {
+            continue;
+        }
+        // array → validate each item
+        if (Array.isArray(current)) {
+            for (const item of current) {
+                stack.push(item);
             }
-            else {
-                return false;
+            continue;
+        }
+        // object → validate each value
+        if (isPlainObject(current)) {
+            for (const v of Object.values(current)) {
+                stack.push(v);
             }
+            continue;
         }
+        // everything else is invalid
+        return false;
     }
     return true;
 }

package/dist/core/src/routing/pathname/get-unprefixed-pathname.js

@@ -1,7 +1,6 @@
 import '../../core/error/intor-error.js';
 import { normalizePathname } from '../../core/utils/normalizers/normalize-pathname.js';
 import 'logry';
-import 'keyv';
 
 /**
  * Returns a canonical, locale-agnostic pathname.

package/dist/core/src/routing/pathname/locale-prefix-pathname.js

@@ -2,7 +2,6 @@ import { PREFIX_PLACEHOLDER } from '../../core/constants/prefix-placeholder.js';
 import '../../core/error/intor-error.js';
 import { normalizePathname } from '../../core/utils/normalizers/normalize-pathname.js';
 import 'logry';
-import 'keyv';
 
 /**
  * Applies the configured locale prefix behavior to a standardized pathname.

package/dist/core/src/routing/pathname/standardize-pathname.js

@@ -2,7 +2,6 @@ import { PREFIX_PLACEHOLDER } from '../../core/constants/prefix-placeholder.js';
 import '../../core/error/intor-error.js';
 import { normalizePathname } from '../../core/utils/normalizers/normalize-pathname.js';
 import 'logry';
-import 'keyv';
 
 /**
  * Standardizes a canonical pathname by applying the base path

package/dist/core/src/server/helpers/get-translator.js

@@ -2,11 +2,11 @@ import { createIntorRuntime } from '../runtime/create-intor-runtime.js';
 
 // Implementation
 async function getTranslator(config, params) {
-    const { readOptions, allowCacheWrite, preKey, handlers, plugins } = params;
+    const { readers, allowCacheWrite, preKey, handlers, plugins } = params;
     const locale = params.locale;
     // Create runtime (request-scoped, no cache write)
     const runtime = createIntorRuntime(config, {
-        readOptions,
+        readers,
         allowCacheWrite,
     });
     // Ensure messages & create translator snapshot
@@ -21,6 +21,7 @@ async function getTranslator(config, params) {
         locale,
         hasKey: translator.hasKey,
         t: translator.t,
+        tRaw: translator.tRaw,
     };
 }
 

package/dist/core/src/server/helpers/local-messages-from-url.js

@@ -43,7 +43,7 @@ async function loadMessagesFromUrl(url, options) {
         namespaces,
         fallbackLocales,
         concurrency: options?.concurrency,
-        readOptions: options?.readOptions,
+        readers: options?.readers,
         pool: options?.pool,
         allowCacheWrite: options?.allowCacheWrite,
         loggerOptions: options?.loggerOptions || { id: "default" },

package/dist/core/src/server/intor/intor.js

@@ -1,6 +1,5 @@
 import '../../core/error/intor-error.js';
 import { getLogger } from '../../core/logger/get-logger.js';
-import 'keyv';
 import { createIntorRuntime } from '../runtime/create-intor-runtime.js';
 
 /**

package/dist/core/src/server/messages/load-local-messages/load-local-messages.js

@@ -13,16 +13,15 @@ import { readLocaleMessages } from './read-locale-messages/read-locale-messages.
  * It coordinates:
  *
  * - Locale resolution with fallbacks
- * - Process-level memoization (read by default, write by ownership)
  * - Concurrency control for file system access
+ * - Process-level memoization (read by default, write by ownership)
  *
  * Local messages are cached for the lifetime of the process.
  * Cache writes are restricted to the primary initialization flow.
  *
  * File traversal, parsing, and validation are delegated to lower-level utilities.
  */
-const loadLocalMessages = async ({ id, locale, fallbackLocales, namespaces, rootDir = "messages", concurrency = 10, readOptions, pool = getGlobalMessagesPool(), allowCacheWrite = false, loggerOptions, }) => {
-    const isProd = process.env.NODE_ENV === "production";
+const loadLocalMessages = async ({ id, locale, fallbackLocales, namespaces, rootDir = "messages", concurrency = 10, readers, pool = getGlobalMessagesPool(), allowCacheWrite = false, loggerOptions, }) => {
     const baseLogger = getLogger(loggerOptions);
     const logger = baseLogger.child({ scope: "load-local-messages" });
     const start = performance.now();
@@ -38,14 +37,14 @@ const loadLocalMessages = async ({ id, locale, fallbackLocales, namespaces, root
         "loaderType:local",
         rootDir,
         locale,
-        (fallbackLocales || []).toSorted().join(","),
-        (namespaces || []).toSorted().join(","),
-    ]);
+        fallbackLocales?.toSorted().join(","),
+        namespaces?.toSorted().join(","),
+    ].filter(Boolean));
     // ---------------------------------------------------------------------------
     // Cache read
     // ---------------------------------------------------------------------------
     if (cacheKey) {
-        const cached = await pool?.get(cacheKey);
+        const cached = pool.get(cacheKey);
         if (cached) {
             logger.debug("Messages cache hit.", { key: cacheKey });
             return cached;
@@ -66,7 +65,7 @@ const loadLocalMessages = async ({ id, locale, fallbackLocales, namespaces, root
                 namespaces,
                 rootDir,
                 limit,
-                readOptions,
+                readers,
                 loggerOptions,
             });
             // Stop at the first locale that yields non-empty messages
@@ -90,10 +89,10 @@ const loadLocalMessages = async ({ id, locale, fallbackLocales, namespaces, root
     // ---------------------------------------------------------------------------
     // Cache write (explicitly permitted)
     // ---------------------------------------------------------------------------
-    if (allowCacheWrite && isProd) {
-        if (cacheKey && messages) {
-            await pool?.set(cacheKey, messages);
-        }
+    const isProd = process.env.NODE_ENV === "production";
+    const canWriteCache = isProd && allowCacheWrite;
+    if (canWriteCache && cacheKey && messages) {
+        pool.set(cacheKey, messages);
     }
     // Final success log with resolved locale and timing
     if (messages) {

package/dist/core/src/server/messages/load-local-messages/read-locale-messages/collect-file-entries/collect-file-entries.js

@@ -2,7 +2,6 @@ import fs from 'node:fs/promises';
 import path from 'node:path';
 import '../../../../../core/error/intor-error.js';
 import { getLogger } from '../../../../../core/logger/get-logger.js';
-import 'keyv';
 
 /**
  * Recursively collects message file metadata under a given locale root.
@@ -21,9 +20,10 @@ import 'keyv';
  * }, ... ];
  * ```
  */
-async function collectFileEntries({ readdir = fs.readdir, namespaces, rootDir, limit, exts = [".json"], loggerOptions, }) {
+async function collectFileEntries({ readdir = fs.readdir, namespaces, rootDir, limit, exts = ["json"], loggerOptions, }) {
     const baseLogger = getLogger(loggerOptions);
     const logger = baseLogger.child({ scope: "collect-file-entries" });
+    const supportedExts = new Set(["json", ...exts]);
     const fileEntries = [];
     // Recursive directory walk
     const walk = async (currentDir) => {
@@ -51,14 +51,14 @@ async function collectFileEntries({ readdir = fs.readdir, namespaces, rootDir, l
                 return;
             }
             // Skip unsupported file extensions
-            if (!exts.some((ext) => entry.name.endsWith(ext)))
+            const ext = path.extname(entry.name).slice(1); // "json", "yaml"
+            if (!ext || !supportedExts.has(ext))
                 return;
             // ---------------------------------------------------------------------
             // Resolve file entry
             // ---------------------------------------------------------------------
             const relativePath = path.relative(rootDir, fullPath);
-            const ext = path.extname(relativePath);
-            const withoutExt = relativePath.slice(0, -ext.length);
+            const withoutExt = relativePath.slice(0, relativePath.length - (ext.length + 1));
             const segments = withoutExt.split(path.sep).filter(Boolean);
             const namespace = segments.at(0);
             if (!namespace)
@@ -73,7 +73,7 @@ async function collectFileEntries({ readdir = fs.readdir, namespaces, rootDir, l
                 fullPath,
                 relativePath,
                 segments,
-                basename: path.basename(entry.name, ext),
+                basename: path.basename(entry.name, `.${ext}`),
             });
         }));
         await Promise.all(tasks);

package/dist/core/src/server/messages/load-local-messages/read-locale-messages/parse-file-entries/parse-file-entries.js

@@ -3,7 +3,6 @@ import '../../../../../core/error/intor-error.js';
 import { deepMerge } from '../../../../../core/utils/deep-merge.js';
 import { getLogger } from '../../../../../core/logger/get-logger.js';
 import { isValidMessages } from '../../../../../core/messages/utils/is-valid-messages.js';
-import 'keyv';
 import { jsonReader } from './utils/json-reader.js';
 import { nestObjectFromPath } from './utils/nest-object-from-path.js';
 
@@ -36,7 +35,7 @@ import { nestObjectFromPath } from './utils/nest-object-from-path.js';
  * }
  * ```
  */
-async function parseFileEntries({ fileEntries, limit, messagesReader, loggerOptions, }) {
+async function parseFileEntries({ fileEntries, limit, readers, loggerOptions, }) {
     const baseLogger = getLogger(loggerOptions);
     const logger = baseLogger.child({ scope: "parse-file-entries" });
     // Read and parse all file entries
@@ -46,10 +45,19 @@ async function parseFileEntries({ fileEntries, limit, messagesReader, loggerOpti
             // -------------------------------------------------------------------
             // Read and validate file content
             // -------------------------------------------------------------------
-            const ext = path.extname(fullPath);
-            const raw = ext !== ".json" && messagesReader
-                ? await messagesReader(fullPath)
-                : await jsonReader(fullPath);
+            const ext = path.extname(fullPath).slice(1); // remove dot
+            let raw;
+            if (ext === "json") {
+                raw = await jsonReader(fullPath);
+            }
+            else {
+                const reader = readers?.[ext];
+                if (!reader) {
+                    throw new Error(`No message reader registered for .${ext} files. ` +
+                        `Please register a reader for the "${ext}" extension.`);
+                }
+                raw = await reader(fullPath);
+            }
             // Validate messages structure
             if (!isValidMessages(raw)) {
                 throw new Error("Parsed content does not match expected Messages structure");

package/dist/core/src/server/messages/load-local-messages/read-locale-messages/read-locale-messages.js

@@ -12,7 +12,7 @@ import { parseFileEntries } from './parse-file-entries/parse-file-entries.js';
  *
  * It does not perform validation or transformation itself.
  */
-const readLocaleMessages = async ({ locale, namespaces, rootDir = "messages", limit, readOptions: { exts, messagesReader } = {}, loggerOptions, }) => {
+const readLocaleMessages = async ({ locale, namespaces, rootDir = "messages", limit, readers, loggerOptions, }) => {
     // ---------------------------------------------------------------------------
     // Collect message file entries for the locale
     // ---------------------------------------------------------------------------
@@ -20,7 +20,7 @@ const readLocaleMessages = async ({ locale, namespaces, rootDir = "messages", li
         namespaces,
         rootDir: path.resolve(rootDir, locale),
         limit,
-        exts,
+        exts: Object.keys(readers || {}),
         loggerOptions,
     });
     // ---------------------------------------------------------------------------
@@ -29,7 +29,7 @@ const readLocaleMessages = async ({ locale, namespaces, rootDir = "messages", li
     const messages = await parseFileEntries({
         fileEntries,
         limit,
-        messagesReader,
+        readers,
         loggerOptions,
     });
     // ---------------------------------------------------------------------------

package/dist/core/src/server/messages/load-messages.js

@@ -2,7 +2,6 @@ import '../../core/error/intor-error.js';
 import { resolveLoaderOptions } from '../../core/utils/resolve-loader-options.js';
 import { getLogger } from '../../core/logger/get-logger.js';
 import { loadRemoteMessages } from '../../core/messages/load-remote-messages/load-remote-messages.js';
-import 'keyv';
 import { loadLocalMessages } from './load-local-messages/load-local-messages.js';
 
 /**
@@ -18,7 +17,7 @@ import { loadLocalMessages } from './load-local-messages/load-local-messages.js'
  * Message traversal, parsing, fallback resolution, and caching logic
  * are delegated to the selected loader.
  */
-const loadMessages = async ({ config, locale, readOptions, allowCacheWrite = false, }) => {
+const loadMessages = async ({ config, locale, readers, allowCacheWrite = false, }) => {
     const baseLogger = getLogger(config.logger);
     const logger = baseLogger.child({ scope: "load-messages" });
     // ---------------------------------------------------------------------------
@@ -29,15 +28,15 @@ const loadMessages = async ({ config, locale, readOptions, allowCacheWrite = fal
         logger.warn("No loader options have been configured in the current config.");
         return;
     }
-    const { type, namespaces } = loader;
+    const { type, namespaces, rootDir } = loader;
     const fallbackLocales = config.fallbackLocales[locale] || [];
     logger.info(`Loading messages for locale "${locale}".`);
     logger.trace("Starting to load messages with runtime context.", {
         loaderType: type,
+        rootDir,
         locale,
-        fallbackLocales,
-        namespaces: namespaces && namespaces.length > 0 ? [...namespaces] : ["*"],
-        cache: config.cache,
+        fallbackLocales: fallbackLocales.join(", "),
+        namespaces: namespaces && namespaces.length > 0 ? [...namespaces] : "*",
     });
     // ---------------------------------------------------------------------------
     // Dispatch to loader implementation
@@ -49,24 +48,21 @@ const loadMessages = async ({ config, locale, readOptions, allowCacheWrite = fal
             locale,
             fallbackLocales,
             namespaces,
-            rootDir: loader.rootDir,
+            rootDir,
             concurrency: loader.concurrency,
-            readOptions,
+            readers,
             allowCacheWrite,
             loggerOptions: config.logger,
         });
     }
     else if (type === "remote") {
         loadedMessages = await loadRemoteMessages({
-            id: config.id,
             locale,
             fallbackLocales,
             namespaces,
-            rootDir: loader.rootDir,
+            rootDir,
             url: loader.url,
             headers: loader.headers,
-            allowCacheWrite,
-            cacheOptions: config.cache,
             loggerOptions: config.logger,
         });
     }

package/dist/core/src/server/runtime/create-intor-runtime.js

@@ -1,6 +1,6 @@
 import { IntorError, IntorErrorCode } from '../../core/error/intor-error.js';
+import { resolveLoaderOptions } from '../../core/utils/resolve-loader-options.js';
 import 'logry';
-import 'keyv';
 import { loadMessages } from '../messages/load-messages.js';
 import { createTranslator } from '../translator/create-translator.js';
 
@@ -14,20 +14,24 @@ import { createTranslator } from '../translator/create-translator.js';
  * before a translator snapshot can be created.
  */
 function createIntorRuntime(config, options) {
+    const loader = resolveLoaderOptions(config, "server");
     // Locale that has completed the ensureMessages() phase
     let ensuredLocale;
     // Messages prepared during ensureMessages(); may be empty
     let ensuredMessages;
     return {
         async ensureMessages(locale) {
-            const messages = await loadMessages({
-                config,
-                locale,
-                readOptions: options?.readOptions,
-                allowCacheWrite: options?.allowCacheWrite ?? false,
-            });
+            let messages;
+            if (loader) {
+                messages = await loadMessages({
+                    config,
+                    locale,
+                    readers: options?.readers,
+                    allowCacheWrite: options?.allowCacheWrite || false,
+                });
+            }
             ensuredLocale = locale;
-            ensuredMessages = messages;
+            ensuredMessages = messages || {};
         },
         translator(locale, options) {
             // Guard: translator requires ensureMessages() to be completed for this locale

package/dist/core/src/server/translator/create-translator.js

@@ -34,6 +34,7 @@ function createTranslator(params) {
         locale,
         hasKey: scoped ? scoped.hasKey : translator.hasKey,
         t: scoped ? scoped.t : translator.t,
+        tRaw: scoped ? scoped.tRaw : translator.tRaw,
     };
 }
 

package/dist/express/src/adapters/express/helpers/get-translator.js

@@ -1,6 +1,5 @@
 import '../../../core/error/intor-error.js';
 import 'logry';
-import 'keyv';
 import 'node:path';
 import 'p-limit';
 import 'node:fs/promises';
@@ -9,14 +8,14 @@ import { getTranslator as getTranslator$1 } from '../../../server/helpers/get-tr
 
 // Implementation
 async function getTranslator(config, req, params) {
-    const { preKey, handlers, plugins, readOptions } = params || {};
+    const { preKey, handlers, plugins, readers, allowCacheWrite } = params || {};
     return getTranslator$1(config, {
         locale: req.intor?.locale || config.defaultLocale,
         preKey,
         handlers,
         plugins,
-        readOptions,
-        allowCacheWrite: false,
+        readers,
+        allowCacheWrite,
     });
 }