intor 2.3.8 → 2.3.9

package/README.md

@@ -21,82 +21,3 @@ Fast to start, easy to extend, and free from the usual i18n heaviness.
 #### 🍳 Cooking the Intor v2 docs, crafting them to perfection...
 
 </div>
-
----
-
-Intor separates language translation from semantic rendering.  
-ICU operates at the text-translation layer, while semantic tags  
-are parsed and rendered in a dedicated AST-based rendering phase.
-
-```
-┌──────────────────────────────────────────────┐
-│                Application                   │
-│                                              │
-│  t() / tRich() / <T />                       │
-└───────────────────────────┬──────────────────┘
-                            │
-                            ▼
-┌──────────────────────────────────────────────┐
-│        Translator (Language / Semantic)      │
-│              intor-translator                │
-│                                              │
-│  Responsibilities:                           │
-│  - Resolve message key                       │
-│  - Locale resolution & fallback              │
-│  - Message loading                           │
-│  - Text-level interpolation                  │
-│    • {name}, {count}                         │
-│    • plural / select                         │
-│    • ICU MessageFormat (optional)            │
-│      (ignoreTag: true)                       │
-│                                              │
-│  Output:                                     │
-│  - Translated string                         │
-│  - May still contain <semantic tags>         │
-└───────────────────────────┬──────────────────┘
-                            │
-                            ▼
-┌──────────────────────────────────────────────┐
-│      Semantic Parsing & AST Construction     │
-│                                              │
-│  Responsibilities:                           │
-│  - Tokenize semantic tags                    │
-│    • <b>, <link>, <Component>                │
-│  - Build semantic AST                        │
-│    • TextNode                                │
-│    • TagNode                                 │
-│                                              │
-│  Note:                                       │
-│  - Independent from ICU / formatter          │
-│  - Pure semantic structure                   │
-└───────────────────────────┬──────────────────┘
-                            │
-                            ▼
-┌──────────────────────────────────────────────┐
-│        Semantic Rendering (Renderer)         │
-│                                              │
-│  Responsibilities:                           │
-│  - Traverse semantic AST                     │
-│  - Render TextNode                           │
-│  - Render TagNode                            │
-│                                              │
-│  Renderer decides output type:               │
-│  - string                                    │
-│  - ReactNode                                 │
-│  - Vue / Svelte nodes                        │
-│  - Markdown / CLI output                     │
-│                                              │
-│  Optional extensions:                        │
-│  - Custom tag renderers                      │
-│  - Rich components                           │
-└───────────────────────────┬──────────────────┘
-                            │
-                            ▼
-┌──────────────────────────────────────────────┐
-│                 Final Output                 │
-│                                              │
-│  - Rendered rich content                     │
-│  - Framework-specific result                 │
-│                                              │
-└──────────────────────────────────────────────┘
-```

package/dist/core/export/index.js

@@ -1,9 +1,12 @@
 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';
+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/export/server/index.js

@@ -1,4 +1,8 @@
 export { intor } from '../../src/server/intor/intor.js';
 export { loadMessages } from '../../src/server/messages/load-messages.js';
-export { getTranslator } from '../../src/server/translator/get-translator.js';
+import 'intor-translator';
+import '../../src/core/error/intor-error.js';
+import 'logry';
+import 'keyv';
+export { getTranslator } from '../../src/server/helpers/get-translator.js';
 export { loadMessagesFromUrl } from '../../src/server/helpers/local-messages-from-url.js';

package/dist/core/src/config/constants/cookie.js

@@ -3,7 +3,7 @@ const DEFAULT_COOKIE_OPTIONS = {
     enabled: true,
     persist: true,
     name: "intor.locale",
-    domain: null,
+    domain: undefined,
     path: "/",
     maxAge: 60 * 60 * 24 * 365, // 365 days
     httpOnly: false,

package/dist/core/src/config/constants/routing.js

@@ -2,9 +2,14 @@
 const DEFAULT_ROUTING_OPTIONS = {
     locale: {
         sources: ["path", "query", "cookie", "detected"],
-        queryKey: "locale",
+        query: { key: "locale" },
+    },
+    navigation: {
+        carrier: "path",
+        path: { prefix: "none" },
+        query: { key: "locale" },
+        host: { map: {} },
     },
-    prefix: "none",
     firstVisit: {
         localeSource: "browser",
         redirect: true,

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

@@ -13,6 +13,26 @@ const resolveRoutingOptions = (routing = {}) => {
         locale: {
             ...DEFAULT_ROUTING_OPTIONS.locale,
             ...routing.locale,
+            query: {
+                ...DEFAULT_ROUTING_OPTIONS.locale.query,
+                ...routing.locale?.query,
+            },
+        },
+        navigation: {
+            ...DEFAULT_ROUTING_OPTIONS.navigation,
+            ...routing.navigation,
+            path: {
+                ...DEFAULT_ROUTING_OPTIONS.navigation.path,
+                ...routing.navigation?.path,
+            },
+            query: {
+                ...DEFAULT_ROUTING_OPTIONS.navigation.query,
+                ...routing.navigation?.query,
+            },
+            host: {
+                ...DEFAULT_ROUTING_OPTIONS.navigation.host,
+                ...routing.navigation?.host,
+            },
         },
         firstVisit: {
             ...DEFAULT_ROUTING_OPTIONS.firstVisit,

package/dist/core/src/core/error/intor-error.js

@@ -12,10 +12,12 @@ class IntorError extends Error {
 }
 var IntorErrorCode;
 (function (IntorErrorCode) {
-    // intor-config
+    // config
     IntorErrorCode["MISSING_SUPPORTED_LOCALES"] = "INTOR_MISSING_SUPPORTED_LOCALES";
     IntorErrorCode["MISSING_DEFAULT_LOCALE"] = "INTOR_MISSING_DEFAULT_LOCALE";
     IntorErrorCode["UNSUPPORTED_DEFAULT_LOCALE"] = "INTOR_UNSUPPORTED_DEFAULT_LOCALE";
+    // runtime
+    IntorErrorCode["RUNTIME_NOT_INITIALIZED"] = "INTOR_RUNTIME_NOT_INITIALIZED";
 })(IntorErrorCode || (IntorErrorCode = {}));
 
 export { IntorError, IntorErrorCode };

package/dist/core/src/{core/utils → routing}/pathname/get-unprefixed-pathname.js

@@ -1,4 +1,7 @@
-import { normalizePathname } from '../normalizers/normalize-pathname.js';
+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/{react/src/core/utils → core/src/routing}/pathname/locale-prefix-pathname.js

@@ -1,5 +1,8 @@
-import { PREFIX_PLACEHOLDER } from '../../constants/prefix-placeholder.js';
-import { normalizePathname } from '../normalizers/normalize-pathname.js';
+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 routing prefix strategy by resolving the locale placeholder.
@@ -16,8 +19,7 @@ import { normalizePathname } from '../normalizers/normalize-pathname.js';
  * ```
  */
 const localePrefixPathname = (config, standardizedPathname, locale) => {
-    const { routing } = config;
-    const { prefix } = routing;
+    const { prefix } = config.routing.navigation.path;
     if (prefix !== "none" && !locale) {
         throw new Error('No locale when using prefix "all", "except-default"');
     }

package/dist/{react/src/core/utils → core/src/routing}/pathname/localize-pathname.js

@@ -25,11 +25,11 @@ const localizePathname = (config, rawPathname, locale) => {
     // 2. Standardize: build a pathname with locale placeholder
     const standardizedPathname = standardizePathname(config, unprefixedPathname);
     // 3. Apply strategy: resolve locale prefix based on routing rules
-    const localizedPathname = localePrefixPathname(config, standardizedPathname, locale);
+    const pathname = localePrefixPathname(config, standardizedPathname, locale);
     return {
+        pathname,
         unprefixedPathname,
         standardizedPathname,
-        localizedPathname,
     };
 };
 

package/dist/core/src/{core/utils → routing}/pathname/standardize-pathname.js

@@ -1,5 +1,8 @@
-import { PREFIX_PLACEHOLDER } from '../../constants/prefix-placeholder.js';
-import { normalizePathname } from '../normalizers/normalize-pathname.js';
+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

@@ -0,0 +1,27 @@
+import { createIntorRuntime } from '../runtime/create-intor-runtime.js';
+
+// Implementation
+async function getTranslator(config, params) {
+    const { readOptions, allowCacheWrite, preKey, handlers, plugins } = params;
+    const locale = params.locale;
+    // Create runtime (request-scoped, no cache write)
+    const runtime = createIntorRuntime(config, {
+        readOptions,
+        allowCacheWrite,
+    });
+    // Ensure messages & create translator snapshot
+    await runtime.ensureMessages(locale);
+    const translator = runtime.translator(locale, {
+        preKey,
+        plugins,
+        handlers,
+    });
+    return {
+        messages: translator.messages,
+        locale,
+        hasKey: translator.hasKey,
+        t: translator.t,
+    };
+}
+
+export { getTranslator };

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

@@ -42,8 +42,7 @@ async function loadMessagesFromUrl(url, options) {
         namespaces,
         fallbackLocales,
         concurrency: options?.concurrency,
-        exts: options?.exts,
-        messagesReader: options?.messagesReader,
+        readOptions: options?.readOptions,
         pool: options?.pool,
         cacheOptions: options?.cacheOptions || { enabled: false, ttl: 0 },
         allowCacheWrite: options?.allowCacheWrite,

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

@@ -1,53 +1,36 @@
 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 { createIntorRuntime } from '../runtime/create-intor-runtime.js';
 
 /**
- * Entry point for initializing Intor.
+ * Initializes Intor for the current execution context.
  *
- * This function orchestrates the initialization flow:
- *
- * - Resolves the initial locale using a provided locale resolver
- * - Loads locale messages if the message loader is enabled
- * - Returns a fully-initialized Intor result
- *
- * This function does not perform routing decisions itself.
- * Locale resolution is delegated to the provided `getLocale` implementation.
+ * Provides server-side bootstrap logic for SSR-based
+ * full-stack frameworks.
  */
-const intor = async (config, getLocale, loadMessagesOptions = {}) => {
+async function intor(config, localeOrResolver, options) {
     const baseLogger = getLogger(config.logger);
     const logger = baseLogger.child({ scope: "intor" });
     logger.info("Start Intor initialization.");
-    // Resolve initial locale
-    const isLocaleFunction = typeof getLocale === "function";
+    // Create runtime (request-scoped)
+    const runtime = createIntorRuntime(config, options);
+    // Resolve locale
+    const isLocaleFunction = typeof localeOrResolver === "function";
     const locale = isLocaleFunction
-        ? await getLocale(config)
-        : getLocale || config.defaultLocale;
-    const source = typeof getLocale === "function" ? "resolver" : "static";
+        ? await localeOrResolver(config)
+        : localeOrResolver || config.defaultLocale;
+    const source = typeof localeOrResolver === "function" ? "resolver" : "static";
     logger.debug(`Initial locale resolved as "${locale}" via "${source}".`);
-    // Load messages during initialization when a loader is configured.
-    let loadedMessages;
-    const loader = resolveLoaderOptions(config);
-    if (loader) {
-        loadedMessages = await loadMessages({
-            config,
-            locale,
-            extraOptions: {
-                exts: loadMessagesOptions.exts,
-                messagesReader: loadMessagesOptions.messagesReader,
-            },
-            allowCacheWrite: true, // Intor is the primary cache writer during initialization.
-        });
-    }
+    // Ensure messages & create translator snapshot
+    await runtime.ensureMessages(locale);
+    const translator = runtime.translator(locale);
     logger.info("Intor initialized.");
     return {
         config,
-        initialLocale: locale,
-        initialMessages: deepMerge(config.messages, loadedMessages),
+        locale,
+        messages: translator.messages,
     };
-};
+}
 
 export { intor };

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

@@ -9,16 +9,16 @@ import { readLocaleMessages } from './read-locale-messages/read-locale-messages.
 /**
  * Load locale messages from the local file system.
  *
- * This function acts as the orchestration layer for local message loading.
- * It is responsible for:
+ * This function serves as the orchestration layer for local message loading.
+ * It coordinates:
  *
- * - Resolving fallback locales in order
- * - Coordinating cache read / write behavior
- * - Limiting concurrent file reads for performance
+ * - Locale resolution with fallbacks
+ * - Cache read / write behavior
+ * - Concurrency control for file system access
  *
- * File system traversal, parsing, and message validation are delegated to lower-level utilities.
+ * File traversal, parsing, and validation are delegated to lower-level utilities.
  */
-const loadLocalMessages = async ({ locale, fallbackLocales, namespaces, rootDir = "messages", concurrency = 10, exts, messagesReader, pool = getGlobalMessagesPool(), cacheOptions, allowCacheWrite = false, loggerOptions, }) => {
+const loadLocalMessages = async ({ locale, fallbackLocales, namespaces, rootDir = "messages", concurrency = 10, readOptions, pool = getGlobalMessagesPool(), cacheOptions, allowCacheWrite = false, loggerOptions, }) => {
     const baseLogger = getLogger(loggerOptions);
     const logger = baseLogger.child({ scope: "load-local-messages" });
     const start = performance.now();
@@ -26,7 +26,9 @@ const loadLocalMessages = async ({ locale, fallbackLocales, namespaces, rootDir
         rootDir,
         resolvedRootDir: path.resolve(process.cwd(), rootDir),
     });
-    // --- Cache key ---
+    // ---------------------------------------------------------------------------
+    // Cache key resolution
+    // ---------------------------------------------------------------------------
     const cacheKey = normalizeCacheKey([
         loggerOptions.id,
         "loaderType:local",
@@ -35,18 +37,24 @@ const loadLocalMessages = async ({ locale, fallbackLocales, namespaces, rootDir
         (fallbackLocales || []).toSorted().join(","),
         (namespaces || []).toSorted().join(","),
     ]);
-    // --- Cache read ---
-    if (cacheOptions.enabled && cacheKey) {
-        const cached = await pool?.get(cacheKey);
-        if (cached) {
-            logger.debug("Messages cache hit.", { key: cacheKey });
-            return cached;
+    // ---------------------------------------------------------------------------
+    // Cache read
+    // ---------------------------------------------------------------------------
+    if (cacheOptions.enabled) {
+        if (cacheKey) {
+            const cached = await pool?.get(cacheKey);
+            if (cached) {
+                logger.debug("Messages cache hit.", { key: cacheKey });
+                return cached;
+            }
         }
     }
+    // ---------------------------------------------------------------------------
+    // Resolve locale messages with ordered fallback strategy
+    // ---------------------------------------------------------------------------
     const limit = pLimit(concurrency);
     const candidateLocales = [locale, ...(fallbackLocales || [])];
     let messages;
-    // Try each candidate locale in order and stop at the first successful result
     for (let i = 0; i < candidateLocales.length; i++) {
         const candidateLocale = candidateLocales[i];
         const isLast = i === candidateLocales.length - 1;
@@ -56,7 +64,8 @@ const loadLocalMessages = async ({ locale, fallbackLocales, namespaces, rootDir
                 namespaces,
                 rootDir,
                 limit,
-                extraOptions: { exts, messagesReader, loggerOptions },
+                readOptions,
+                loggerOptions,
             });
             // Stop at the first locale that yields non-empty messages
             if (Object.values(result[candidateLocale] || {}).length > 0) {
@@ -76,9 +85,13 @@ const loadLocalMessages = async ({ locale, fallbackLocales, namespaces, rootDir
             }
         }
     }
-    // --- Cache write ---
-    if (cacheOptions.enabled && allowCacheWrite && cacheKey && messages) {
-        await pool?.set(cacheKey, messages, cacheOptions.ttl);
+    // ---------------------------------------------------------------------------
+    // Cache write (explicitly permitted)
+    // ---------------------------------------------------------------------------
+    if (cacheOptions.enabled && allowCacheWrite) {
+        if (cacheKey && messages) {
+            await pool?.set(cacheKey, messages, cacheOptions.ttl);
+        }
     }
     // 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

@@ -5,10 +5,10 @@ import { getLogger } from '../../../../../core/logger/get-logger.js';
 import 'keyv';
 
 /**
- * Recursively collects all message files under a given root directory.
+ * Recursively collects message file metadata under a given locale root.
  *
- * - Supports filtering by allowed file extensions and optional namespaces.
- * - Processes directories concurrently using the provided `limit` function.
+ * - Traverses directories and collects matching message files
+ * - Supports filtering by file extensions and optional namespaces
  *
  * @example
  * ```ts
@@ -21,12 +21,15 @@ import 'keyv';
  * }, ... ];
  * ```
  */
-async function collectFileEntries({ readdir = fs.readdir, namespaces, rootDir, limit, extraOptions: { 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 fileEntries = [];
+    // Recursive directory walk
     const walk = async (currentDir) => {
-        // Read current directory entries
+        // -------------------------------------------------------------------------
+        // Read directory entries
+        // -------------------------------------------------------------------------
         let entries = [];
         try {
             entries = await readdir(currentDir, { withFileTypes: true });
@@ -37,17 +40,22 @@ async function collectFileEntries({ readdir = fs.readdir, namespaces, rootDir, l
             });
             return;
         }
-        // Process each directory entry and collect valid files
+        // -------------------------------------------------------------------------
+        // Process entries (files & sub-directories)
+        // -------------------------------------------------------------------------
         const tasks = entries.map((entry) => limit(async () => {
             const fullPath = path.join(currentDir, entry.name);
-            // If entry is a directory, recurse into it
+            // Recurse into sub-directories
             if (entry.isDirectory()) {
                 await walk(fullPath);
                 return;
             }
-            // Only include files with extensions in exts[]
+            // Skip unsupported file extensions
             if (!exts.some((ext) => entry.name.endsWith(ext)))
                 return;
+            // ---------------------------------------------------------------------
+            // Resolve file entry
+            // ---------------------------------------------------------------------
             const relativePath = path.relative(rootDir, fullPath);
             const ext = path.extname(relativePath);
             const withoutExt = relativePath.slice(0, -ext.length);
@@ -55,7 +63,7 @@ async function collectFileEntries({ readdir = fs.readdir, namespaces, rootDir, l
             const namespace = segments.at(0);
             if (!namespace)
                 return;
-            // Filter namespaces if a list is provided (always include "index")
+            // Apply namespace filter (always allow "index")
             if (namespaces && namespace !== "index") {
                 if (!namespaces.includes(namespace))
                     return;

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

@@ -8,12 +8,12 @@ import { jsonReader } from './utils/json-reader.js';
 import { nestObjectFromPath } from './utils/nest-object-from-path.js';
 
 /**
- * Parse locale message files (JSON or custom formats) into a unified LocaleMessages object.
+ * Parse locale message files into a unified Messages object (single-locale).
  *
- * - Supports JSON and custom formats (via `customReader`)
- * - Uses optional concurrency control (`limit`)
+ * - Reads JSON or custom formats (via `messagesReader`)
+ * - Validates message structure
  * - Builds nested objects based on file path segments
- * - Deep-merges entries that belong to the same namespace
+ * - Deep-merges entries by namespace
  *
  * @example
  * ```plain
@@ -24,42 +24,47 @@ import { nestObjectFromPath } from './utils/nest-object-from-path.js';
  *   - en/auth/verify.json  = { d: "D" }
  *```
 
- * The final return value is a LocaleMessages object:
+ * The final return value is a `Messages` object:
  * ```ts
  * {
- *   en: {
- *     a: "A",
- *     ui: { b: "B" },
- *     auth: {
- *       c: "C",
- *       verify: { d: "D" },
- *     },
+ *   a: "A",
+ *   ui: { b: "B" },
+ *   auth: {
+ *     c: "C",
+ *     verify: { d: "D" },
  *   },
  * }
  * ```
  */
-async function parseFileEntries({ fileEntries, limit, extraOptions: { messagesReader, loggerOptions }, }) {
+async function parseFileEntries({ fileEntries, limit, messagesReader, loggerOptions, }) {
     const baseLogger = getLogger(loggerOptions);
     const logger = baseLogger.child({ scope: "parse-file-entries" });
     // Read and parse all file entries
     const parsedFileEntries = [];
     const tasks = fileEntries.map(({ namespace, segments, basename, fullPath, relativePath }) => limit(async () => {
         try {
-            const segsWithoutNs = segments.slice(1);
+            // -------------------------------------------------------------------
+            // Read and validate file content
+            // -------------------------------------------------------------------
             const ext = path.extname(fullPath);
-            // Use a custom reader if provided (e.g., for YAML)
-            const json = ext !== ".json" && messagesReader
+            const raw = ext !== ".json" && messagesReader
                 ? await messagesReader(fullPath)
                 : await jsonReader(fullPath);
             // Validate messages structure
-            if (!isValidMessages(json)) {
-                throw new Error("JSON file does not match NamespaceMessages structure");
+            if (!isValidMessages(raw)) {
+                throw new Error("Parsed content does not match expected Messages structure");
             }
-            const isIndex = basename === "index";
-            const keyPath = isIndex ? segsWithoutNs.slice(0, -1) : segsWithoutNs;
+            // -------------------------------------------------------------------
+            // Build nested message object from path segments
+            // -------------------------------------------------------------------
+            const segmentsWithoutNamespace = segments.slice(1);
+            const isIndexFile = basename === "index";
+            const keyPath = isIndexFile
+                ? segmentsWithoutNamespace.slice(0, -1)
+                : segmentsWithoutNamespace;
             // Nest the parsed content based on the path segments
-            const nested = nestObjectFromPath(keyPath, json);
-            parsedFileEntries.push({ namespace, messages: nested });
+            const nestedMessages = nestObjectFromPath(keyPath, raw);
+            parsedFileEntries.push({ namespace, messages: nestedMessages });
             logger.trace(`Parsed message file: ${relativePath}`);
         }
         catch (error) {
@@ -70,10 +75,12 @@ async function parseFileEntries({ fileEntries, limit, extraOptions: { messagesRe
         }
     }));
     await Promise.all(tasks);
-    // Merge all entries belonging to the same namespace
+    // ---------------------------------------------------------------------------
+    // Merge parsed entries by namespace
+    // ---------------------------------------------------------------------------
     const result = {};
     for (const { namespace, messages } of parsedFileEntries) {
-        // Handle root-level namespace (i.e., [rootDir]/index.json)
+        // Root-level namespace (e.g. [locale]/index.json)
         if (namespace === "index") {
             Object.assign(result, deepMerge(result, messages));
         }