intor 2.3.27 → 2.3.29

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

@@ -1,18 +1,24 @@
+import pLimit from 'p-limit';
 import { getLogger } from '../../logger/get-logger.js';
-import { fetchLocaleMessages } from './fetch-locale-messages/fetch-locale-messages.js';
+import { collectRemoteResources } from './collect-remote-resources.js';
+import { fetchRemoteResource } from './fetch-remote-resource.js';
+import { resolveRemoteResources } from './resolve-remote-resources.js';
 
 /**
- * Load locale messages from a remote API.
+ * Load locale messages from a remote source.
  *
  * This function serves as the orchestration layer for remote message loading.
  * It coordinates:
  *
  * - Locale resolution with fallbacks
- * - Respecting abort signals across the entire async flow
+ * - Concurrency control for network requests
+ * - Remote resource fetching and message merging
  *
- * Network fetching and data validation are delegated to lower-level utilities.
+ * Remote messages are fetched on demand and are not memoized at the process level.
+ *
+ * Network requests and response validation are delegated to lower-level utilities.
  */
-const loadRemoteMessages = async ({ locale, fallbackLocales, namespaces, rootDir, url, headers, signal, loggerOptions, }) => {
+const loadRemoteMessages = async ({ locale, fallbackLocales, namespaces, concurrency, url: baseUrl, headers, signal, loggerOptions, }) => {
     const baseLogger = getLogger(loggerOptions);
     const logger = baseLogger.child({ scope: "load-remote-messages" });
     // Abort early if the request has already been cancelled
@@ -21,33 +27,45 @@ const loadRemoteMessages = async ({ locale, fallbackLocales, namespaces, rootDir
         return;
     }
     const start = performance.now();
-    logger.debug("Loading remote messages.", { url });
-    // ---------------------------------------------------------------------------
+    logger.debug("Loading remote messages.", { baseUrl });
+    // ----------------------------------------------------------------
     // Resolve locale messages with ordered fallback strategy
-    // ---------------------------------------------------------------------------
+    // ----------------------------------------------------------------
+    const limit = concurrency ? pLimit(concurrency) : undefined;
     const candidateLocales = [locale, ...(fallbackLocales || [])];
     let messages;
     for (let i = 0; i < candidateLocales.length; i++) {
         const candidateLocale = candidateLocales[i];
         const isLast = i === candidateLocales.length - 1;
         try {
-            const fetched = await fetchLocaleMessages({
+            // -----------------------------------------------------------------
+            // Collect remote message resources for the locale
+            // -----------------------------------------------------------------
+            const resources = collectRemoteResources({
                 locale: candidateLocale,
+                baseUrl,
                 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) {
-                messages = fetched;
-                break;
-            }
+            // -----------------------------------------------------------------
+            // Fetch all message chunks in parallel
+            // -----------------------------------------------------------------
+            const fetchUrl = (url) => fetchRemoteResource({ url, headers, signal, loggerOptions });
+            const results = await Promise.all(resources.map(({ url }) => limit ? limit(() => fetchUrl(url)) : fetchUrl(url)));
+            // Guard: no valid remote resources
+            if (!results.some(Boolean))
+                continue;
+            // -----------------------------------------------------------------
+            // Resolve and merge remote message resources
+            // -----------------------------------------------------------------
+            const resolved = resolveRemoteResources(resources.map((res, i) => ({ path: res.path, data: results[i] })));
+            // -----------------------------------------------------------------
+            // Wrap resolved messages into locale-scoped LocaleMessages
+            // -----------------------------------------------------------------
+            messages = { [candidateLocale]: resolved };
+            break;
         }
-        catch (error) {
-            if (error instanceof Error && error.name === "AbortError") {
+        catch {
+            if (signal?.aborted) {
                 logger.debug("Remote message loading aborted.");
                 return;
             }
@@ -58,18 +76,14 @@ const loadRemoteMessages = async ({ locale, fallbackLocales, namespaces, rootDir
                 });
             }
             else {
-                logger.warn(`Failed to fetch locale messages for "${candidateLocale}", trying next fallback.`);
+                logger.warn(`Failed to load locale messages for "${candidateLocale}", trying next fallback.`);
             }
-            logger.trace("Remote fetch error detail.", {
-                locale: candidateLocale,
-                error,
-            });
         }
     }
     // Final success log with resolved locale and timing
     if (messages) {
         logger.trace("Finished loading remote messages.", {
-            loadedLocale: messages ? Object.keys(messages)[0] : undefined,
+            loadedLocale: Object.keys(messages)[0],
             duration: `${Math.round(performance.now() - start)} ms`,
         });
     }

package/dist/react/src/core/messages/load-remote-messages/resolve-remote-resources.js

@@ -0,0 +1,24 @@
+import { deepMerge } from '../../utils/deep-merge.js';
+import { nestObjectFromPath } from '../utils/nest-object-from-path.js';
+
+/**
+ * Resolve remote message resources into a single MessageObject.
+ *
+ * - Applies semantic nesting based on resource path
+ * - Merges all resolved message chunks
+ *
+ * Always returns a MessageObject.
+ * An empty object represents an empty translation domain.
+ */
+function resolveRemoteResources(resources) {
+    let result = {};
+    for (const { path, data } of resources) {
+        if (!data)
+            continue;
+        const resolved = path.length > 0 ? nestObjectFromPath(path, data) : data;
+        result = deepMerge(result, resolved);
+    }
+    return result;
+}
+
+export { resolveRemoteResources };

package/dist/react/src/core/messages/utils/nest-object-from-path.js

@@ -0,0 +1,21 @@
+/**
+ * Wraps a value inside nested objects according to a given path.
+ *
+ * @example
+ * ```ts
+ * const value = { a: "A" };
+ *
+ * nestObjectFromPath(["auth", "verify"], value); // → { auth: { verify: { a: "A" } } }
+ *
+ * nestObjectFromPath([], value); // →  { a: "A" }
+ * ```
+ */
+function nestObjectFromPath(path, value) {
+    let obj = value;
+    for (let i = path.length - 1; i >= 0; i--) {
+        obj = { [path[i]]: obj };
+    }
+    return obj;
+}
+
+export { nestObjectFromPath };

package/dist/react/src/policies/shoud-full-reload.js

@@ -1,6 +1,7 @@
 import '../core/error/intor-error.js';
 import { resolveLoaderOptions } from '../core/utils/resolve-loader-options.js';
 import 'logry';
+import 'p-limit';
 
 /**
  * Determine whether client-side navigation must be forced to reload.

package/dist/react/src/routing/pathname/canonicalize-pathname.js

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

package/dist/react/src/routing/pathname/materialize-pathname.js

@@ -2,6 +2,7 @@ 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 'p-limit';
 
 /**
  * Materializes a standardized pathname by applying

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

@@ -2,6 +2,7 @@ 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 'p-limit';
 
 /**
  * Standardizes a canonical pathname into an internal routing template

package/dist/svelte/src/client/shared/helpers/get-client-locale.js

@@ -1,6 +1,7 @@
 import '../../../core/error/intor-error.js';
 import { normalizeLocale } from '../../../core/utils/normalizers/normalize-locale.js';
 import 'logry';
+import 'p-limit';
 import { detectBrowserLocale } from '../utils/locale/detect-browser-locale.js';
 import { getLocaleFromCookie } from '../utils/locale/get-locale-from-cookie.js';
 

package/dist/svelte/src/client/shared/messages/create-refetch-messages.js

@@ -29,7 +29,7 @@ const createRefetchMessages = ({ config, onLoadingStart, onLoadingEnd, onMessage
                 locale: newLocale,
                 fallbackLocales: config.fallbackLocales[newLocale] || [],
                 namespaces: loader.namespaces,
-                rootDir: loader.rootDir,
+                concurrency: loader.concurrency,
                 url: loader.url,
                 headers: loader.headers,
                 signal: currentController.signal,

package/dist/svelte/src/client/svelte/helpers/create-intor.js

@@ -1,6 +1,7 @@
 import { writable } from 'svelte/store';
 import '../../../core/error/intor-error.js';
 import 'logry';
+import 'p-limit';
 import { mergeMessages } from '../../../core/messages/merge-messages.js';
 import { getClientLocale } from '../../shared/helpers/get-client-locale.js';
 

package/dist/svelte/src/client/svelte/store/effects/locale-effects.js

@@ -1,7 +1,7 @@
-import { shouldPersist } from '../../../../policies/should-persist.js';
 import { shouldPersistOnFirstVisit } from '../../../../policies/should-persist-on-first-visit.js';
 import '../../../../core/error/intor-error.js';
 import 'logry';
+import 'p-limit';
 import { getLocaleFromCookie } from '../../../shared/utils/locale/get-locale-from-cookie.js';
 import { setLocaleCookie } from '../../../shared/utils/locale/set-locale-cookie.js';
 import { setDocumentLocale } from '../../../shared/utils/locale/set-document-locale.js';
@@ -20,7 +20,7 @@ function attachLocaleEffects(locale, config) {
             const localeCookie = getLocaleFromCookie(cookie.name);
             const isFirstVisit = !localeCookie;
             if (shouldPersistOnFirstVisit(isFirstVisit, routing.inbound.firstVisit.persist) &&
-                shouldPersist(cookie)) {
+                cookie.persist) {
                 setLocaleCookie(cookie, currentLocale);
             }
             return;
@@ -28,7 +28,7 @@ function attachLocaleEffects(locale, config) {
         // -------------------------------------------------------------
         // Subsequent locale changes (user-driven)
         // -------------------------------------------------------------
-        if (shouldPersist(cookie)) {
+        if (cookie.persist) {
             setLocaleCookie(cookie, currentLocale);
         }
     });

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

@@ -4,8 +4,6 @@ var IntorErrorCode;
     IntorErrorCode["INVALID_CONFIG_ID"] = "INTOR_INVALID_CONFIG_ID";
     IntorErrorCode["MISSING_SUPPORTED_LOCALES"] = "INTOR_MISSING_SUPPORTED_LOCALES";
     IntorErrorCode["UNSUPPORTED_DEFAULT_LOCALE"] = "INTOR_UNSUPPORTED_DEFAULT_LOCALE";
-    // runtime
-    IntorErrorCode["RUNTIME_NOT_INITIALIZED"] = "INTOR_RUNTIME_NOT_INITIALIZED";
 })(IntorErrorCode || (IntorErrorCode = {}));
 
 export { IntorErrorCode };

package/dist/svelte/src/core/messages/load-remote-messages/collect-remote-resources.js

@@ -0,0 +1,25 @@
+/**
+ * Collect remote message resources for a given locale.
+ *
+ * - Always includes the root `index.json`
+ * - Optionally includes namespace-specific resources
+ * - Produces semantic paths for later message nesting
+ *
+ * This function performs no I/O and does not validate resource existence.
+ */
+function collectRemoteResources({ locale, baseUrl, namespaces, }) {
+    const basePath = `${baseUrl}/${locale}`;
+    // Root translation resource (always loaded)
+    const indexResource = { url: `${basePath}/index.json`, path: [] };
+    // When no namespaces are provided, the locale domain consists of index only
+    if (!namespaces || namespaces.length === 0)
+        return [indexResource];
+    // Namespace-specific resources are nested under their namespace key
+    const nsResources = namespaces.map((ns) => ({
+        url: `${basePath}/${ns}.json`,
+        path: [ns],
+    }));
+    return [indexResource, ...nsResources];
+}
+
+export { collectRemoteResources };

package/dist/svelte/src/core/messages/load-remote-messages/fetch-remote-resource.js

@@ -0,0 +1,47 @@
+import { getLogger } from '../../logger/get-logger.js';
+import { isValidMessages } from '../utils/is-valid-messages.js';
+
+/**
+ * Fetch a single remote messages resource.
+ *
+ * This function performs a single HTTP request to retrieve
+ * a remote translation messages payload.
+ *
+ * It is responsible for:
+ * - Issuing the network request
+ * - Validating the returned message structure
+ * - Handling abort and network errors
+ */
+async function fetchRemoteResource({ url, headers, signal, loggerOptions, }) {
+    const baseLogger = getLogger(loggerOptions);
+    const logger = baseLogger.child({ scope: "fetch-locale-messages" });
+    try {
+        // Fetch
+        const response = await fetch(url, {
+            method: "GET",
+            headers: { "Content-Type": "application/json", ...headers },
+            cache: "no-store",
+            signal,
+        });
+        if (!response.ok) {
+            throw new Error(`HTTP ${response.status} ${response.statusText}`);
+        }
+        // Parse JSON body
+        const data = await response.json();
+        // Validate messages structure
+        if (!isValidMessages(data)) {
+            throw new Error("Invalid messages structure");
+        }
+        return data;
+    }
+    catch (error) {
+        if (error instanceof Error && error.name === "AbortError") {
+            logger.debug("Remote fetch aborted.", { url });
+            return;
+        }
+        logger.warn("Failed to fetch remote messages.", { url, error });
+        return;
+    }
+}
+
+export { fetchRemoteResource };

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

@@ -1,18 +1,24 @@
+import pLimit from 'p-limit';
 import { getLogger } from '../../logger/get-logger.js';
-import { fetchLocaleMessages } from './fetch-locale-messages/fetch-locale-messages.js';
+import { collectRemoteResources } from './collect-remote-resources.js';
+import { fetchRemoteResource } from './fetch-remote-resource.js';
+import { resolveRemoteResources } from './resolve-remote-resources.js';
 
 /**
- * Load locale messages from a remote API.
+ * Load locale messages from a remote source.
  *
  * This function serves as the orchestration layer for remote message loading.
  * It coordinates:
  *
  * - Locale resolution with fallbacks
- * - Respecting abort signals across the entire async flow
+ * - Concurrency control for network requests
+ * - Remote resource fetching and message merging
  *
- * Network fetching and data validation are delegated to lower-level utilities.
+ * Remote messages are fetched on demand and are not memoized at the process level.
+ *
+ * Network requests and response validation are delegated to lower-level utilities.
  */
-const loadRemoteMessages = async ({ locale, fallbackLocales, namespaces, rootDir, url, headers, signal, loggerOptions, }) => {
+const loadRemoteMessages = async ({ locale, fallbackLocales, namespaces, concurrency, url: baseUrl, headers, signal, loggerOptions, }) => {
     const baseLogger = getLogger(loggerOptions);
     const logger = baseLogger.child({ scope: "load-remote-messages" });
     // Abort early if the request has already been cancelled
@@ -21,33 +27,45 @@ const loadRemoteMessages = async ({ locale, fallbackLocales, namespaces, rootDir
         return;
     }
     const start = performance.now();
-    logger.debug("Loading remote messages.", { url });
-    // ---------------------------------------------------------------------------
+    logger.debug("Loading remote messages.", { baseUrl });
+    // ----------------------------------------------------------------
     // Resolve locale messages with ordered fallback strategy
-    // ---------------------------------------------------------------------------
+    // ----------------------------------------------------------------
+    const limit = concurrency ? pLimit(concurrency) : undefined;
     const candidateLocales = [locale, ...(fallbackLocales || [])];
     let messages;
     for (let i = 0; i < candidateLocales.length; i++) {
         const candidateLocale = candidateLocales[i];
         const isLast = i === candidateLocales.length - 1;
         try {
-            const fetched = await fetchLocaleMessages({
+            // -----------------------------------------------------------------
+            // Collect remote message resources for the locale
+            // -----------------------------------------------------------------
+            const resources = collectRemoteResources({
                 locale: candidateLocale,
+                baseUrl,
                 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) {
-                messages = fetched;
-                break;
-            }
+            // -----------------------------------------------------------------
+            // Fetch all message chunks in parallel
+            // -----------------------------------------------------------------
+            const fetchUrl = (url) => fetchRemoteResource({ url, headers, signal, loggerOptions });
+            const results = await Promise.all(resources.map(({ url }) => limit ? limit(() => fetchUrl(url)) : fetchUrl(url)));
+            // Guard: no valid remote resources
+            if (!results.some(Boolean))
+                continue;
+            // -----------------------------------------------------------------
+            // Resolve and merge remote message resources
+            // -----------------------------------------------------------------
+            const resolved = resolveRemoteResources(resources.map((res, i) => ({ path: res.path, data: results[i] })));
+            // -----------------------------------------------------------------
+            // Wrap resolved messages into locale-scoped LocaleMessages
+            // -----------------------------------------------------------------
+            messages = { [candidateLocale]: resolved };
+            break;
         }
-        catch (error) {
-            if (error instanceof Error && error.name === "AbortError") {
+        catch {
+            if (signal?.aborted) {
                 logger.debug("Remote message loading aborted.");
                 return;
             }
@@ -58,18 +76,14 @@ const loadRemoteMessages = async ({ locale, fallbackLocales, namespaces, rootDir
                 });
             }
             else {
-                logger.warn(`Failed to fetch locale messages for "${candidateLocale}", trying next fallback.`);
+                logger.warn(`Failed to load locale messages for "${candidateLocale}", trying next fallback.`);
             }
-            logger.trace("Remote fetch error detail.", {
-                locale: candidateLocale,
-                error,
-            });
         }
     }
     // Final success log with resolved locale and timing
     if (messages) {
         logger.trace("Finished loading remote messages.", {
-            loadedLocale: messages ? Object.keys(messages)[0] : undefined,
+            loadedLocale: Object.keys(messages)[0],
             duration: `${Math.round(performance.now() - start)} ms`,
         });
     }

package/dist/svelte/src/core/messages/load-remote-messages/resolve-remote-resources.js

@@ -0,0 +1,24 @@
+import { deepMerge } from '../../utils/deep-merge.js';
+import { nestObjectFromPath } from '../utils/nest-object-from-path.js';
+
+/**
+ * Resolve remote message resources into a single MessageObject.
+ *
+ * - Applies semantic nesting based on resource path
+ * - Merges all resolved message chunks
+ *
+ * Always returns a MessageObject.
+ * An empty object represents an empty translation domain.
+ */
+function resolveRemoteResources(resources) {
+    let result = {};
+    for (const { path, data } of resources) {
+        if (!data)
+            continue;
+        const resolved = path.length > 0 ? nestObjectFromPath(path, data) : data;
+        result = deepMerge(result, resolved);
+    }
+    return result;
+}
+
+export { resolveRemoteResources };

package/dist/svelte/src/core/messages/utils/nest-object-from-path.js

@@ -0,0 +1,21 @@
+/**
+ * Wraps a value inside nested objects according to a given path.
+ *
+ * @example
+ * ```ts
+ * const value = { a: "A" };
+ *
+ * nestObjectFromPath(["auth", "verify"], value); // → { auth: { verify: { a: "A" } } }
+ *
+ * nestObjectFromPath([], value); // →  { a: "A" }
+ * ```
+ */
+function nestObjectFromPath(path, value) {
+    let obj = value;
+    for (let i = path.length - 1; i >= 0; i--) {
+        obj = { [path[i]]: obj };
+    }
+    return obj;
+}
+
+export { nestObjectFromPath };

package/dist/types/export/express/index.d.ts

@@ -1 +1 @@
-export { createIntor, getTranslator } from "../../src/adapters/express";
+export { createIntorMiddleware, getTranslator } from "../../src/adapters/express";

package/dist/types/export/index.d.ts

@@ -1,4 +1,4 @@
-export { PREFIX_PLACEHOLDER, IntorError, IntorErrorCode, deepMerge, type DeepMergeOverrideEvent, resolveLoaderOptions, clearLoggerPool, clearMessagesPool, mergeMessages, isValidMessages, type MessagesReader, type MessagesReaders, INTOR_PREFIX, INTOR_MESSAGES_KIND_KEY, INTOR_MESSAGES_KIND, getMessagesKind, type IntorMessagesKind, } from "../src/core";
+export { PREFIX_PLACEHOLDER, IntorError, IntorErrorCode, deepMerge, type DeepMergeOverrideEvent, resolveLoaderOptions, clearLoggerPool, mergeMessages, isValidMessages, type MessagesReader, type MessagesReaders, INTOR_PREFIX, INTOR_MESSAGES_KIND_KEY, INTOR_MESSAGES_KIND, getMessagesKind, type IntorMessagesKind, } from "../src/core";
 export { defineIntorConfig, type IntorRawConfig, type IntorResolvedConfig, } from "../src/config";
 export { localizePathname } from "../src/routing";
 export { Translator, type TranslatorPlugin, type TranslateContext, type TranslateHook, type TranslateHandlers, type HandlerContext, type FormatHandler, type LoadingHandler, type MissingHandler, type LocaleMessages, type MessageObject, type MessageValue, tokenize, type Token, } from "intor-translator";

package/dist/types/export/server/index.d.ts

@@ -1 +1 @@
-export { intor, type IntorValue, loadMessages, getTranslator, loadMessagesFromUrl, } from "../../src/server";
+export { intor, type IntorValue, loadMessages, clearMessagesPool, getTranslator, } from "../../src/server";

package/dist/types/src/adapters/express/index.d.ts

@@ -1,3 +1,3 @@
-export { createIntor } from "./middleware";
+export { createIntorMiddleware } from "./middleware";
 export { getTranslator } from "./helpers";
 export * from "./global";

package/dist/types/src/adapters/express/middleware/{create-intor.d.ts → create-intor-middleware.d.ts}

@@ -11,4 +11,4 @@ import { type GetTranslatorParams } from "../../../server";
  *
  * @platform Express
  */
-export declare function createIntor(config: IntorResolvedConfig, options?: Omit<GetTranslatorParams, "locale">): (req: Request, _res: Response, next: NextFunction) => Promise<void>;
+export declare function createIntorMiddleware(config: IntorResolvedConfig, options?: Omit<GetTranslatorParams, "locale">): (req: Request, _res: Response, next: NextFunction) => Promise<void>;

package/dist/types/src/adapters/express/middleware/index.d.ts

@@ -1 +1 @@
-export { createIntor } from "./create-intor";
+export { createIntorMiddleware } from "./create-intor-middleware";

package/dist/types/src/adapters/next/server/get-locale.d.ts

@@ -3,7 +3,7 @@ import type { GenConfigKeys, GenLocale } from "../../../core";
 /**
  * Get the locale for the current execution context.
  *
- * @note Requires inbound routing context; otherwise the result may be inferred.
+ * @note Uses inbound routing context when available, otherwise falls back to persisted state.
  * @platform Next.js
  */
 export declare const getLocale: <CK extends GenConfigKeys = "__default__">(config: IntorResolvedConfig) => Promise<GenLocale<CK>>;

package/dist/types/src/adapters/next/server/intor.d.ts

@@ -9,4 +9,7 @@ import { type IntorValue } from "../../../server";
  * - Permits cache writes during server execution.
  * @platform Next.js
  */
-export declare function intor<CK extends GenConfigKeys = "__default__">(config: IntorResolvedConfig, readers?: MessagesReaders): Promise<IntorValue<CK>>;
+export declare function intor<CK extends GenConfigKeys = "__default__">(config: IntorResolvedConfig, options?: {
+    readers?: MessagesReaders;
+    allowCacheWrite?: boolean;
+}): Promise<IntorValue<CK>>;

package/dist/types/src/config/types/cookie.d.ts

@@ -1,6 +1,4 @@
 export type CookieRawOptions = {
-    /** Enable cookie read/write behavior. Defaults to true */
-    enabled?: boolean;
     /** Whether to persist the resolved locale in a cookie. Defaults to true */
     persist?: boolean;
     /** Cookie name used to store the locale. Defaults to "intor.locale" */

package/dist/types/src/config/types/loader.d.ts

@@ -11,21 +11,21 @@ export interface RemoteHeaders {
 interface LocalLoader {
     /** Use local filesystem-based message loading. */
     type: "local";
-    /** Root location for resolving message loading sources. */
-    rootDir?: string;
     /** Namespaces to load for all routes. */
     namespaces?: string[];
     /** Maximum number of concurrent loading tasks. */
     concurrency?: number;
+    /** Root location for resolving message loading sources. */
+    rootDir?: string;
 }
 /** Remote message loader options. */
 export interface RemoteLoader {
     /** Use remote API-based message loading. */
     type: "remote";
-    /** Root location for resolving message loading sources. */
-    rootDir?: string;
     /** Namespaces to load for all routes. */
     namespaces?: string[];
+    /** Maximum number of concurrent loading tasks. */
+    concurrency?: number;
     /** Base URL for fetching remote messages. */
     url: string;
     /** Optional headers sent with remote requests. */

package/dist/types/src/core/error/intor-error.d.ts

@@ -11,7 +11,6 @@ export declare class IntorError extends Error {
 export declare enum IntorErrorCode {
     INVALID_CONFIG_ID = "INTOR_INVALID_CONFIG_ID",
     MISSING_SUPPORTED_LOCALES = "INTOR_MISSING_SUPPORTED_LOCALES",
-    UNSUPPORTED_DEFAULT_LOCALE = "INTOR_UNSUPPORTED_DEFAULT_LOCALE",
-    RUNTIME_NOT_INITIALIZED = "INTOR_RUNTIME_NOT_INITIALIZED"
+    UNSUPPORTED_DEFAULT_LOCALE = "INTOR_UNSUPPORTED_DEFAULT_LOCALE"
 }
 export {};

package/dist/types/src/core/index.d.ts

@@ -2,5 +2,5 @@ export { PREFIX_PLACEHOLDER, INTOR_HEADERS } from "./constants";
 export { IntorError, IntorErrorCode } from "./error";
 export { deepMerge, type PlainObject, type DeepMergeOverrideEvent, resolveLoaderOptions, normalizePathname, normalizeCacheKey, normalizeLocale, normalizeQuery, } from "./utils";
 export { getLogger, clearLoggerPool } from "./logger";
-export { loadRemoteMessages, type MessagesPool, getGlobalMessagesPool, clearMessagesPool, mergeMessages, isValidMessages, type MessagesReader, type MessagesReaders, INTOR_PREFIX, INTOR_MESSAGES_KIND_KEY, INTOR_MESSAGES_KIND, getMessagesKind, type IntorMessagesKind, } from "./messages";
+export { loadRemoteMessages, mergeMessages, isValidMessages, nestObjectFromPath, type MessagesReader, type MessagesReaders, INTOR_PREFIX, INTOR_MESSAGES_KIND_KEY, INTOR_MESSAGES_KIND, getMessagesKind, type IntorMessagesKind, } from "./messages";
 export type { INTOR_GENERATED_KEY, IfGen, GenConfigKeys, GenConfig, GenMessages, GenLocale, GenReplacements, GenRich, TranslatorInstance, RoutingLocaleSource, RoutingLocaleCarrier, LocalePathPrefix, } from "./types";

package/dist/types/src/core/messages/index.d.ts

@@ -1,6 +1,5 @@
 export { loadRemoteMessages } from "./load-remote-messages";
-export { type MessagesPool, getGlobalMessagesPool, clearMessagesPool, } from "./global-messages-pool";
 export { mergeMessages } from "./merge-messages";
-export { isValidMessages } from "./utils/is-valid-messages";
+export { isValidMessages, nestObjectFromPath } from "./utils";
 export type { MessagesReader, MessagesReaders } from "./types";
 export { INTOR_PREFIX, INTOR_MESSAGES_KIND_KEY, INTOR_MESSAGES_KIND, getMessagesKind, type IntorMessagesKind, } from "./internal-metadata";

package/dist/types/src/core/messages/load-remote-messages/collect-remote-resources.d.ts

@@ -0,0 +1,19 @@
+interface CollectRemoteResourcesParams {
+    locale: string;
+    baseUrl: string;
+    namespaces?: string[];
+}
+/**
+ * Collect remote message resources for a given locale.
+ *
+ * - Always includes the root `index.json`
+ * - Optionally includes namespace-specific resources
+ * - Produces semantic paths for later message nesting
+ *
+ * This function performs no I/O and does not validate resource existence.
+ */
+export declare function collectRemoteResources({ locale, baseUrl, namespaces, }: CollectRemoteResourcesParams): Array<{
+    url: string;
+    path: string[];
+}>;
+export {};