intor 2.3.6 → 2.3.7

package/dist/core/export/config/index.js

@@ -1 +1,3 @@
 export { defineIntorConfig } from '../../src/config/define-intor-config.js';
+import '../../src/config/constants/cookie.js';
+import '../../src/config/constants/cache.js';

package/dist/core/export/index.js

@@ -1,5 +1,9 @@
-export { PREFIX_PLACEHOLDER } from '../src/shared/constants/prefix-placeholder.js';
-export { deepMerge } from '../src/shared/utils/deep-merge.js';
-export { localizePathname } from '../src/shared/utils/pathname/localize-pathname.js';
-export { IntorError, IntorErrorCode } from '../src/shared/error/intor-error.js';
+export { PREFIX_PLACEHOLDER } from '../src/core/constants/prefix-placeholder.js';
+export { IntorError, IntorErrorCode } from '../src/core/error/intor-error.js';
+export { deepMerge } from '../src/core/utils/deep-merge.js';
+export { localizePathname } from '../src/core/utils/pathname/localize-pathname.js';
+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';
 import 'intor-translator';

package/dist/core/export/server/index.js

@@ -1,7 +1,4 @@
 export { intor } from '../../src/server/intor/intor.js';
 export { loadMessages } from '../../src/server/messages/load-messages.js';
-export { isValidMessages } from '../../src/server/messages/shared/utils/is-valid-messages.js';
 export { getTranslator } from '../../src/server/translator/get-translator.js';
-export { clearLoggerPool } from '../../src/server/shared/logger/global-logger-pool.js';
-export { clearMessagesPool, setGlobalMessagesPool } from '../../src/server/shared/messages/global-messages-pool.js';
-export { loadLocalMessagesFromUrl } from '../../src/server/helpers/local-messages-from-url.js';
+export { loadMessagesFromUrl } from '../../src/server/helpers/local-messages-from-url.js';

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

@@ -30,8 +30,9 @@ const defineIntorConfig = (config) => {
     const cookie = resolveCookieOptions(config.cookie);
     const routing = resolveRoutingOptions(config.routing);
     const cache = resolveCacheOptions(config.cache);
+    const id = config.id ?? "default";
     return {
-        id: config.id ?? "default",
+        id,
         messages: config.messages,
         loader: config.loader,
         defaultLocale,
@@ -40,8 +41,10 @@ const defineIntorConfig = (config) => {
         translator: config.translator,
         cookie,
         routing,
-        logger: config.logger,
+        logger: { id, ...config.logger },
         cache,
+        client: config.client,
+        server: config.server,
     };
 };
 

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

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

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

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

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

@@ -1,5 +1,10 @@
-import { DEFAULT_ROUTING_OPTIONS } from '../constants/routing.constants.js';
-import { normalizePathname } from '../../shared/utils/normalizers/normalize-pathname.js';
+import '../../core/error/intor-error.js';
+import { normalizePathname } from '../../core/utils/normalizers/normalize-pathname.js';
+import 'logry';
+import 'keyv';
+import { DEFAULT_ROUTING_OPTIONS } from '../constants/routing.js';
+import '../constants/cookie.js';
+import '../constants/cache.js';
 
 const resolveRoutingOptions = (routing = {}) => {
     return {

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

@@ -1,4 +1,6 @@
-import { IntorError, IntorErrorCode } from '../../shared/error/intor-error.js';
+import { IntorError, IntorErrorCode } from '../../core/error/intor-error.js';
+import 'logry';
+import 'keyv';
 
 /**
  * Validates the configured default locale.

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

@@ -1,4 +1,6 @@
-import { IntorError, IntorErrorCode } from '../../shared/error/intor-error.js';
+import { IntorError, IntorErrorCode } from '../../core/error/intor-error.js';
+import 'logry';
+import 'keyv';
 
 /**
  * Validates and resolves the list of supported locales.
@@ -11,13 +13,15 @@ import { IntorError, IntorErrorCode } from '../../shared/error/intor-error.js';
  * to fail fast when required inputs are missing.
  */
 const validateSupportedLocales = (config) => {
-    const { id, loader, supportedLocales } = config;
+    const { id, supportedLocales } = config;
+    const hasAnyLoader = !!config.loader || !!config.server?.loader || !!config.client?.loader;
     // Ensure supportedLocales is set when using loader
-    if (loader && !supportedLocales) {
+    if (hasAnyLoader && !supportedLocales) {
         throw new IntorError({
             id,
             code: IntorErrorCode.MISSING_SUPPORTED_LOCALES,
-            message: `"supportedLocales" is required when using loader, but it is missing.`,
+            message: `"supportedLocales" is required when using message loaders. 
+                 Please specify all supported locales explicitly.`,
         });
     }
     // Return supportedLocales or infer from message keys

package/dist/{react/src/server → core/src/core}/messages/load-remote-messages/fetch-locale-messages/fetch-locale-messages.js

@@ -1,5 +1,6 @@
-import { isValidMessages } from '../../shared/utils/is-valid-messages.js';
-import { getLogger } from '../../../shared/logger/get-logger.js';
+import { getLogger } from '../../../logger/get-logger.js';
+import { isValidMessages } from '../../utils/is-valid-messages.js';
+import { buildSearchParams } from './utils/build-search-params.js';
 
 /**
  * Fetches locale messages from a remote API.
@@ -7,22 +8,21 @@ import { getLogger } from '../../../shared/logger/get-logger.js';
  * - Validates that the returned JSON matches the expected `NamespaceMessages` structure.
  * - Uses `fetch` with `no-store` cache to always get fresh data.
  */
-const fetchLocaleMessages = async ({ remoteUrl, remoteHeaders, searchParams, locale, extraOptions: { loggerOptions } = {}, signal, }) => {
-    const baseLogger = getLogger({ ...loggerOptions });
+const fetchLocaleMessages = async ({ locale, namespaces, rootDir, url: rawUrl, headers: rawHeaders, signal, extraOptions: { loggerOptions }, }) => {
+    const baseLogger = getLogger(loggerOptions);
     const logger = baseLogger.child({ scope: "fetch-locale-messages" });
+    const searchParams = buildSearchParams({ locale, rootDir, namespaces });
+    const url = `${rawUrl}?${searchParams.toString()}`;
     try {
-        const params = new URLSearchParams(searchParams);
-        params.append("locale", locale);
-        const url = `${remoteUrl}?${params.toString()}`;
         // Headers
         const headers = {
             "Content-Type": "application/json",
-            ...remoteHeaders,
+            ...rawHeaders,
         };
         // Fetch
         const response = await fetch(url, {
             method: "GET",
-            headers,
+            headers: headers,
             cache: "no-store",
             signal,
         });
@@ -39,12 +39,12 @@ const fetchLocaleMessages = async ({ remoteUrl, remoteHeaders, searchParams, loc
     }
     catch (error) {
         if (error instanceof Error && error.name === "AbortError") {
-            logger.debug("Fetching locale messages aborted.", { locale, remoteUrl });
+            logger.debug("Fetching locale messages aborted.", { locale, url });
             return;
         }
         logger.warn("Fetching locale messages failed.", {
             locale,
-            remoteUrl,
+            url,
             searchParams: decodeURIComponent(searchParams.toString()),
             error,
         });

package/dist/core/src/{server → core}/messages/load-remote-messages/load-remote-messages.js

@@ -1,9 +1,6 @@
-import { DEFAULT_CACHE_OPTIONS } from '../../../config/constants/cache.constants.js';
+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';
-import { buildSearchParams } from './fetch-locale-messages/utils/build-search-params.js';
-import { getLogger } from '../../shared/logger/get-logger.js';
-import { getGlobalMessagesPool } from '../../shared/messages/global-messages-pool.js';
-import { normalizeCacheKey } from '../../../shared/utils/normalizers/normalize-cache-key.js';
 
 /**
  * Load locale messages from a remote API.
@@ -17,8 +14,8 @@ import { normalizeCacheKey } from '../../../shared/utils/normalizers/normalize-c
  *
  * Network fetching and data validation are delegated to lower-level utilities.
  */
-const loadRemoteMessages = async ({ pool = getGlobalMessagesPool(), rootDir, locale, fallbackLocales, namespaces, remoteUrl, remoteHeaders, extraOptions: { cacheOptions = DEFAULT_CACHE_OPTIONS, loggerOptions = { id: "default" }, } = {}, allowCacheWrite = false, signal, }) => {
-    const baseLogger = getLogger({ ...loggerOptions });
+const loadRemoteMessages = async ({ locale, fallbackLocales, namespaces, rootDir, url, headers, signal, pool, cacheOptions, allowCacheWrite = false, loggerOptions, }) => {
+    const baseLogger = getLogger(loggerOptions);
     const logger = baseLogger.child({ scope: "load-remote-messages" });
     // Abort early if the request has already been cancelled
     if (signal?.aborted) {
@@ -26,8 +23,8 @@ const loadRemoteMessages = async ({ pool = getGlobalMessagesPool(), rootDir, loc
         return;
     }
     const start = performance.now();
-    logger.debug("Loading remote messages.", { remoteUrl });
-    // --- Cache key
+    logger.debug("Loading remote messages.", { url });
+    // --- Cache key ---
     const cacheKey = normalizeCacheKey([
         loggerOptions.id,
         "loaderType:remote",
@@ -36,7 +33,7 @@ const loadRemoteMessages = async ({ pool = getGlobalMessagesPool(), rootDir, loc
         (fallbackLocales ?? []).toSorted().join(","),
         (namespaces ?? []).toSorted().join(","),
     ]);
-    // --- Cache read --------------------------------------------------
+    // --- Cache read ---
     if (cacheOptions.enabled && cacheKey) {
         const cached = await pool?.get(cacheKey);
         if (signal?.aborted) {
@@ -56,12 +53,13 @@ const loadRemoteMessages = async ({ pool = getGlobalMessagesPool(), rootDir, loc
         const isLast = i === candidateLocales.length - 1;
         try {
             const fetched = await fetchLocaleMessages({
-                remoteUrl,
-                remoteHeaders,
                 locale: candidateLocale,
-                searchParams: buildSearchParams({ rootDir, namespaces }),
-                extraOptions: { loggerOptions },
+                namespaces,
+                rootDir,
+                url,
+                headers,
                 signal,
+                extraOptions: { loggerOptions },
             });
             // Stop at the first locale that yields non-empty messages
             if (fetched && Object.values(fetched[candidateLocale] || {}).length > 0) {
@@ -89,7 +87,7 @@ const loadRemoteMessages = async ({ pool = getGlobalMessagesPool(), rootDir, loc
             });
         }
     }
-    // --- Cache write --------------------------------------------------
+    // --- Cache write ---
     if (cacheOptions.enabled && allowCacheWrite && cacheKey && messages) {
         if (signal?.aborted) {
             logger.debug("Remote message loading aborted before cache write.");

package/dist/core/src/core/utils/resolve-loader-options.js

@@ -0,0 +1,25 @@
+/**
+ * Resolve the effective message loader for a given runtime.
+ *
+ * Loader resolution follows an inheritance-based priority model:
+ *
+ * - client runtime:
+ *   client.loader → server.loader → root loader
+ *
+ * - server runtime:
+ *   server.loader → root loader
+ *
+ * This allows the client runtime to inherit server behavior
+ * when no explicit client loader is provided.
+ *
+ * Notes:
+ * - Static `messages` are intentionally NOT handled here.
+ * - Returning `undefined` indicates that no loader is enabled
+ *   for the given runtime.
+ */
+const resolveLoaderOptions = (config, runtime) => {
+    // --- runtime: server ---
+    return config.server?.loader ?? config.loader;
+};
+
+export { resolveLoaderOptions };

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

@@ -11,9 +11,9 @@ function parseMultiValueParam(values) {
     return result.length > 0 ? result : undefined;
 }
 /**
- * Load local locale messages from a URL-based query protocol.
+ * Load locale messages from a URL-based query protocol.
  *
- * - A convenience helper for exposing local messages through a URL-accessible interface.
+ * - This helper is intended for building custom HTTP endpoints
  *
  * @example
  * ```ts
@@ -26,10 +26,10 @@ function parseMultiValueParam(values) {
  *   "&fallbackLocales=zh-TW"
  * );
  *
- * const messages = await loadLocalMessagesFromUrl(url);
+ * const messages = await loadMessagesFromUrl(url);
  * ```
  */
-async function loadLocalMessagesFromUrl(url, extraOptions) {
+async function loadMessagesFromUrl(url, options) {
     // Parse query parameters
     const rootDir = url.searchParams.get("rootDir") ?? "";
     const locale = url.searchParams.get("locale") ?? "en-US";
@@ -41,8 +41,14 @@ async function loadLocalMessagesFromUrl(url, extraOptions) {
         locale,
         namespaces,
         fallbackLocales,
-        extraOptions,
+        concurrency: options?.concurrency,
+        exts: options?.exts,
+        messagesReader: options?.messagesReader,
+        pool: options?.pool,
+        cacheOptions: options?.cacheOptions || { enabled: false, ttl: 0 },
+        allowCacheWrite: options?.allowCacheWrite,
+        loggerOptions: options?.loggerOptions || { id: "default" },
     });
 }
 
-export { loadLocalMessagesFromUrl };
+export { loadMessagesFromUrl };

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

@@ -1,6 +1,9 @@
+import '../../core/error/intor-error.js';
+import { deepMerge } from '../../core/utils/deep-merge.js';
+import { resolveLoaderOptions } from '../../core/utils/resolve-loader-options.js';
+import { getLogger } from '../../core/logger/get-logger.js';
+import 'keyv';
 import { loadMessages } from '../messages/load-messages.js';
-import { getLogger } from '../shared/logger/get-logger.js';
-import { deepMerge } from '../../shared/utils/deep-merge.js';
 
 /**
  * Entry point for initializing Intor.
@@ -15,7 +18,7 @@ import { deepMerge } from '../../shared/utils/deep-merge.js';
  * Locale resolution is delegated to the provided `getLocale` implementation.
  */
 const intor = async (config, getLocale, loadMessagesOptions = {}) => {
-    const baseLogger = getLogger({ id: config.id, ...config.logger });
+    const baseLogger = getLogger(config.logger);
     const logger = baseLogger.child({ scope: "intor" });
     logger.info("Start Intor initialization.");
     // Resolve initial locale
@@ -25,9 +28,10 @@ const intor = async (config, getLocale, loadMessagesOptions = {}) => {
         : getLocale || config.defaultLocale;
     const source = typeof getLocale === "function" ? "resolver" : "static";
     logger.debug(`Initial locale resolved as "${locale}" via "${source}".`);
-    // Load messages (if enabled)
+    // Load messages during initialization when a loader is configured.
     let loadedMessages;
-    if (config.loader) {
+    const loader = resolveLoaderOptions(config);
+    if (loader) {
         loadedMessages = await loadMessages({
             config,
             locale,
@@ -35,14 +39,14 @@ const intor = async (config, getLocale, loadMessagesOptions = {}) => {
                 exts: loadMessagesOptions.exts,
                 messagesReader: loadMessagesOptions.messagesReader,
             },
-            allowCacheWrite: true,
+            allowCacheWrite: true, // Intor is the primary cache writer during initialization.
         });
     }
     logger.info("Intor initialized.");
     return {
         config,
         initialLocale: locale,
-        messages: deepMerge(config.messages, loadedMessages) || {},
+        initialMessages: deepMerge(config.messages, loadedMessages),
     };
 };
 

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

@@ -1,10 +1,10 @@
 import path from 'node:path';
 import pLimit from 'p-limit';
-import { DEFAULT_CACHE_OPTIONS } from '../../../config/constants/cache.constants.js';
+import '../../../core/error/intor-error.js';
+import { normalizeCacheKey } from '../../../core/utils/normalizers/normalize-cache-key.js';
+import { getLogger } from '../../../core/logger/get-logger.js';
+import { getGlobalMessagesPool } from '../../../core/messages/global-messages-pool.js';
 import { readLocaleMessages } from './read-locale-messages/read-locale-messages.js';
-import { getLogger } from '../../shared/logger/get-logger.js';
-import { getGlobalMessagesPool } from '../../shared/messages/global-messages-pool.js';
-import { normalizeCacheKey } from '../../../shared/utils/normalizers/normalize-cache-key.js';
 
 /**
  * Load locale messages from the local file system.
@@ -18,15 +18,15 @@ import { normalizeCacheKey } from '../../../shared/utils/normalizers/normalize-c
  *
  * File system traversal, parsing, and message validation are delegated to lower-level utilities.
  */
-const loadLocalMessages = async ({ pool = getGlobalMessagesPool(), rootDir = "messages", locale, fallbackLocales, namespaces, extraOptions: { concurrency = 10, cacheOptions = DEFAULT_CACHE_OPTIONS, loggerOptions = { id: "default" }, exts, messagesReader, } = {}, allowCacheWrite = false, }) => {
-    const baseLogger = getLogger({ ...loggerOptions });
+const loadLocalMessages = async ({ locale, fallbackLocales, namespaces, rootDir = "messages", concurrency = 10, exts, messagesReader, pool = getGlobalMessagesPool(), cacheOptions, allowCacheWrite = false, loggerOptions, }) => {
+    const baseLogger = getLogger(loggerOptions);
     const logger = baseLogger.child({ scope: "load-local-messages" });
     const start = performance.now();
     logger.debug("Loading local messages.", {
         rootDir,
         resolvedRootDir: path.resolve(process.cwd(), rootDir),
     });
-    // --- Cache key
+    // --- Cache key ---
     const cacheKey = normalizeCacheKey([
         loggerOptions.id,
         "loaderType:local",
@@ -35,7 +35,7 @@ const loadLocalMessages = async ({ pool = getGlobalMessagesPool(), rootDir = "me
         (fallbackLocales || []).toSorted().join(","),
         (namespaces || []).toSorted().join(","),
     ]);
-    // --- Cache read --------------------------------------------------
+    // --- Cache read ---
     if (cacheOptions.enabled && cacheKey) {
         const cached = await pool?.get(cacheKey);
         if (cached) {
@@ -51,16 +51,16 @@ const loadLocalMessages = async ({ pool = getGlobalMessagesPool(), rootDir = "me
         const candidateLocale = candidateLocales[i];
         const isLast = i === candidateLocales.length - 1;
         try {
-            const readed = await readLocaleMessages({
-                limit,
-                rootDir,
+            const result = await readLocaleMessages({
                 locale: candidateLocale,
                 namespaces,
-                extraOptions: { loggerOptions, exts, messagesReader },
+                rootDir,
+                limit,
+                extraOptions: { exts, messagesReader, loggerOptions },
             });
             // Stop at the first locale that yields non-empty messages
-            if (Object.values(readed[candidateLocale] || {}).length > 0) {
-                messages = readed;
+            if (Object.values(result[candidateLocale] || {}).length > 0) {
+                messages = result;
                 break;
             }
         }
@@ -76,8 +76,8 @@ const loadLocalMessages = async ({ pool = getGlobalMessagesPool(), rootDir = "me
             }
         }
     }
-    // --- Cache write --------------------------------------------------
-    if (allowCacheWrite && cacheOptions.enabled && cacheKey && messages) {
+    // --- Cache write ---
+    if (cacheOptions.enabled && allowCacheWrite && cacheKey && messages) {
         await pool?.set(cacheKey, messages, cacheOptions.ttl);
     }
     // Final success log with resolved locale and timing

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

@@ -1,6 +1,8 @@
 import fs from 'node:fs/promises';
 import path from 'node:path';
-import { getLogger } from '../../../../shared/logger/get-logger.js';
+import '../../../../../core/error/intor-error.js';
+import { getLogger } from '../../../../../core/logger/get-logger.js';
+import 'keyv';
 
 /**
  * Recursively collects all message files under a given root directory.
@@ -19,8 +21,8 @@ import { getLogger } from '../../../../shared/logger/get-logger.js';
  * }, ... ];
  * ```
  */
-async function collectFileEntries({ readdir = fs.readdir, limit, rootDir, namespaces, extraOptions: { exts = [".json"], loggerOptions } = {}, }) {
-    const baseLogger = getLogger({ ...loggerOptions });
+async function collectFileEntries({ readdir = fs.readdir, namespaces, rootDir, limit, extraOptions: { exts = [".json"], loggerOptions }, }) {
+    const baseLogger = getLogger(loggerOptions);
     const logger = baseLogger.child({ scope: "collect-file-entries" });
     const fileEntries = [];
     const walk = async (currentDir) => {

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

@@ -1,7 +1,9 @@
 import path from 'node:path';
-import { isValidMessages } from '../../../shared/utils/is-valid-messages.js';
-import { getLogger } from '../../../../shared/logger/get-logger.js';
-import { deepMerge } from '../../../../../shared/utils/deep-merge.js';
+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,8 +38,8 @@ import { nestObjectFromPath } from './utils/nest-object-from-path.js';
  * }
  * ```
  */
-async function parseFileEntries({ fileEntries, limit, extraOptions: { messagesReader, loggerOptions } = {}, }) {
-    const baseLogger = getLogger({ ...loggerOptions });
+async function parseFileEntries({ fileEntries, limit, extraOptions: { messagesReader, loggerOptions }, }) {
+    const baseLogger = getLogger(loggerOptions);
     const logger = baseLogger.child({ scope: "parse-file-entries" });
     // Read and parse all file entries
     const parsedFileEntries = [];

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

@@ -9,11 +9,11 @@ import { parseFileEntries } from './parse-file-entries/parse-file-entries.js';
  * 2. Parses each file into a messages object.
  * 3. Wraps the parsed messages under the locale key.
  */
-const readLocaleMessages = async ({ limit, rootDir = "messages", locale, namespaces, extraOptions: { exts, messagesReader, loggerOptions } = {}, }) => {
+const readLocaleMessages = async ({ locale, namespaces, rootDir = "messages", limit, extraOptions: { exts, messagesReader, loggerOptions }, }) => {
     // 1. Collect file entries
     const fileEntries = await collectFileEntries({
-        rootDir: path.resolve(process.cwd(), rootDir, locale),
         namespaces,
+        rootDir: path.resolve(process.cwd(), rootDir, locale),
         limit,
         extraOptions: { exts, loggerOptions },
     });

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

@@ -1,6 +1,9 @@
+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';
-import { loadRemoteMessages } from './load-remote-messages/load-remote-messages.js';
-import { getLogger } from '../shared/logger/get-logger.js';
 
 /**
  * Load locale messages based on the resolved Intor configuration.
@@ -14,14 +17,15 @@ import { getLogger } from '../shared/logger/get-logger.js';
  * It does not perform message normalization or transformation itself.
  */
 const loadMessages = async ({ config, locale, extraOptions: { exts, messagesReader } = {}, allowCacheWrite = false, }) => {
-    const baseLogger = getLogger({ id: config.id, ...config.logger });
+    const baseLogger = getLogger(config.logger);
     const logger = baseLogger.child({ scope: "load-messages" });
+    const loader = resolveLoaderOptions(config);
     // Guard: no loader configured
-    if (!config.loader) {
+    if (!loader) {
         logger.warn("No loader options have been configured in the current config.");
         return;
     }
-    const { type, concurrency, rootDir, namespaces } = config.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.", {
@@ -30,41 +34,43 @@ const loadMessages = async ({ config, locale, extraOptions: { exts, messagesRead
         fallbackLocales,
         namespaces: namespaces && namespaces.length > 0 ? [...namespaces] : "[ALL]",
         cache: config.cache,
-        concurrency: concurrency ?? 10,
     });
     let loadedMessages;
-    // --- loader type: local
+    // ====== loader type: local ======
     if (type === "local") {
         loadedMessages = await loadLocalMessages({
+            // --- Messages Scope ---
             locale,
             fallbackLocales,
             namespaces,
             rootDir,
-            extraOptions: {
-                concurrency,
-                cacheOptions: config.cache,
-                loggerOptions: { id: config.id, ...config.logger },
-                exts,
-                messagesReader,
-            },
+            // --- Execution ---
+            concurrency: loader.concurrency,
+            exts,
+            messagesReader,
+            // --- Caching ---
+            cacheOptions: config.cache,
             allowCacheWrite,
+            // --- Observability ---
+            loggerOptions: config.logger,
         });
     }
-    // --- loader type: remote
+    // ====== loader type: remote ======
     else if (type === "remote") {
-        // Fetch messages from remote
         loadedMessages = await loadRemoteMessages({
+            // --- Messages Scope ---
             locale,
             fallbackLocales,
             namespaces,
             rootDir,
-            remoteUrl: config.loader.remoteUrl,
-            remoteHeaders: config.loader.remoteHeaders,
-            extraOptions: {
-                cacheOptions: config.cache,
-                loggerOptions: { id: config.id, ...config.logger },
-            },
+            // --- Remote Source ---
+            url: loader.url,
+            headers: loader.headers,
+            // --- Caching ---
             allowCacheWrite,
+            cacheOptions: config.cache,
+            // --- Observability ---
+            loggerOptions: config.logger,
         });
     }
     // No messages found

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

@@ -2,32 +2,27 @@ import { Translator } from 'intor-translator';
 import { loadMessages } from '../messages/load-messages.js';
 
 // Implementation
-async function getTranslator(options) {
-    const { config, locale, preKey } = options;
-    const messages = await loadMessages({
-        config,
-        locale,
-        extraOptions: options.extraOptions,
-    });
-    // Create a Translator instance
+async function getTranslator(params) {
+    const { config, locale, preKey, extraOptions } = params;
+    const messages = await loadMessages({ config, locale, extraOptions });
     const translator = new Translator({
         locale,
         messages,
         fallbackLocales: config.fallbackLocales,
         loadingMessage: config.translator?.loadingMessage,
-        placeholder: config.translator?.placeholder,
-        handlers: options.handlers,
-        plugins: options.plugins,
+        missingMessage: config.translator?.missingMessage,
+        handlers: params.handlers,
+        plugins: params.plugins,
     });
-    const props = { messages, locale };
     const scoped = translator.scoped(preKey);
     return {
-        ...props,
+        messages,
+        locale,
         hasKey: preKey ? scoped.hasKey : translator.hasKey,
         t: preKey ? scoped.t : translator.t,
         // NOTE:
-        // Return type is fully validated by overload signatures.
-        // Assertion here is intentional due to TS inference limitations.
+        // The runtime implementation is intentionally erased.
+        // Type safety is guaranteed by public type contracts.
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
     };
 }