intor 2.3.13 → 2.3.15

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

@@ -2,7 +2,6 @@ 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 'keyv';
 import { getLocaleCookieBrowser } from '../../../shared/utils/locale/get-locale-cookie-browser.js';
 import { setLocaleCookieBrowser } from '../../../shared/utils/locale/set-locale-cookie-browser.js';
 import { setDocumentLocale } from '../../../shared/utils/locale/set-document-locale.js';

package/dist/svelte/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/svelte/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/types/export/index.d.ts

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

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

@@ -12,8 +12,9 @@ declare global {
             };
             locale: string;
             localeSource: RoutingLocaleSource;
-            t: TranslatorInstance<LocaleMessages, undefined, "string">["t"];
             hasKey: TranslatorInstance<LocaleMessages, undefined, "string">["hasKey"];
+            t: TranslatorInstance<LocaleMessages, undefined, "string">["t"];
+            tRaw: TranslatorInstance<LocaleMessages, undefined, "string">["tRaw"];
         }
     }
 }

package/dist/types/src/adapters/express/helpers/get-translator.d.ts

@@ -3,7 +3,7 @@ import type { GenConfigKeys, GenMessages } from "../../../core";
 import type { GetTranslatorParams, TranslatorInstanceServer } from "../../../server";
 import type { Request } from "express";
 import type { LocalizedNodeKeys } from "intor-translator";
-type GetTranslatorExpressParams = Omit<GetTranslatorParams, "locale" | "allowCacheWrite">;
+type GetTranslatorExpressParams = Omit<GetTranslatorParams, "locale">;
 /**
  * Get a server-side translator for the current execution context.
  *

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

@@ -2,7 +2,7 @@ import type { IntorResolvedConfig } from "../../../config";
 import type { GenConfigKeys, GenMessages } from "../../../core";
 import type { GetTranslatorParams, TranslatorInstanceServer } from "../../../server";
 import type { LocalizedNodeKeys } from "intor-translator";
-type GetTranslatorNextParams = Omit<GetTranslatorParams, "locale" | "allowCacheWrite">;
+type GetTranslatorNextParams = Omit<GetTranslatorParams, "locale">;
 /**
  * Get a server-side translator for the current execution context.
  *

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

@@ -1,5 +1,5 @@
 import type { IntorResolvedConfig } from "../../../config";
-import type { MessagesReadOptions } from "../../../core";
+import type { MessagesReaders } from "../../../core";
 import { type GenConfigKeys } from "../../../core";
 import { type IntorResult } from "../../../server";
 /**
@@ -9,4 +9,4 @@ import { type IntorResult } from "../../../server";
  * - Acts as the bootstrap entry where cache writes are permitted.
  * @platform Next.js
  */
-export declare function intor<CK extends GenConfigKeys = "__default__">(config: IntorResolvedConfig, readOptions?: MessagesReadOptions): Promise<IntorResult<CK>>;
+export declare function intor<CK extends GenConfigKeys = "__default__">(config: IntorResolvedConfig, readers?: MessagesReaders): Promise<IntorResult<CK>>;

package/dist/types/src/client/svelte/runtime/create-intor-api.d.ts

@@ -6,8 +6,10 @@ export declare function createIntorApi(translator: Readable<Translator>): {
     scoped: (preKey: string) => {
         scoped: /*elided*/ any;
         t: Readable<(key: string, replacements?: Replacement) => string>;
+        tRaw: Readable<(key: string, replacements?: Replacement) => import("intor-translator").MessageValue | undefined>;
         tRich: Readable<(key: string, tagRenderers?: SvelteTagRenderers, replacements?: Replacement) => string>;
     };
     t: Readable<(key: string, replacements?: Replacement) => string>;
+    tRaw: Readable<(key: string, replacements?: Replacement) => import("intor-translator").MessageValue | undefined>;
     tRich: Readable<(key: string, tagRenderers?: SvelteTagRenderers, replacements?: Replacement) => string>;
 };

package/dist/types/src/client/svelte/runtime/types.d.ts

@@ -1,7 +1,7 @@
 import type { SvelteTagRenderers } from "../render";
 import type { BootstrapCore, GenConfigKeys, GenLocale, GenMessages, MessageKey } from "../../../core";
 import type { KeyMode } from "../../../core";
-import type { TranslateHandlers, TranslateHook, TranslatorPlugin } from "intor-translator";
+import type { MessageValue, TranslateHandlers, TranslateHook, TranslatorPlugin } from "intor-translator";
 import type { Readable } from "svelte/store";
 import { type Locale, type LocalizedNodeKeys, type Replacement } from "intor-translator";
 export interface SvelteBootstrap<CK extends GenConfigKeys = "__default__"> extends Omit<BootstrapCore<CK>, "messages"> {
@@ -27,6 +27,8 @@ export type IntorRuntime<CK extends GenConfigKeys = "__default__", Mode extends
 interface ReactiveTranslator<CK extends GenConfigKeys = "__default__", PK extends string | undefined = undefined, Mode extends KeyMode = "auto"> {
     /** Reactive translation function for Svelte templates */
     t: Readable<(key?: MessageKey<GenMessages<CK>, PK, Mode>, replacements?: Replacement) => string>;
+    /** Reactive translation function that returns the raw message value. */
+    tRaw: Readable<(key?: MessageKey<GenMessages<CK>, PK, Mode>, replacements?: Replacement) => MessageValue | undefined>;
     /** Reactive rich translation function for Svelte templates */
     tRich: Readable<(key: MessageKey<GenMessages<CK>, PK, Mode>, tagRenderers?: SvelteTagRenderers, replacements?: Replacement) => string>;
 }

package/dist/types/src/client/vue/provider/resolver/resolve-runtime.d.ts

@@ -2,7 +2,7 @@ import type { IntorProviderProps } from "../types";
 export declare function resolveRuntime(props: IntorProviderProps): {
     config: import("vue").ComputedRef<import("../../../../config").IntorResolvedConfig>;
     locale: import("vue").ComputedRef<string>;
-    messages: import("vue").ComputedRef<import("../../../../core").GenMessages<"__default__"> | undefined>;
+    messages: import("vue").ComputedRef<import("intor-translator").LocaleMessages | undefined>;
     isLoading: import("vue").ComputedRef<boolean>;
     onLocaleChange: import("vue").ComputedRef<((newLocale: import("../../../../core").GenLocale<"__default__">) => Promise<void> | void) | undefined>;
     handlers: import("vue").Ref<import("intor-translator").TranslateHandlers | undefined, import("intor-translator").TranslateHandlers | undefined> | undefined;

package/dist/types/src/config/constants/index.d.ts

@@ -1,3 +1,2 @@
 export { DEFAULT_ROUTING_OPTIONS } from "./routing";
 export { DEFAULT_COOKIE_OPTIONS } from "./cookie";
-export { DEFAULT_CACHE_OPTIONS } from "./cache";

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

@@ -1,3 +1,3 @@
 export { defineIntorConfig } from "./define-intor-config";
-export { DEFAULT_ROUTING_OPTIONS, DEFAULT_COOKIE_OPTIONS, DEFAULT_CACHE_OPTIONS, } from "./constants";
-export type { IntorRawConfig, IntorResolvedConfig, LoaderOptions, RemoteHeaders, TranslatorOptions, RoutingResolvedOptions, CookieResolvedOptions, LoggerOptions, CacheResolvedOptions, } from "./types";
+export { DEFAULT_ROUTING_OPTIONS, DEFAULT_COOKIE_OPTIONS } from "./constants";
+export type { IntorRawConfig, IntorResolvedConfig, LoaderOptions, RemoteHeaders, TranslatorOptions, RoutingResolvedOptions, CookieResolvedOptions, LoggerOptions, } from "./types";

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

@@ -4,4 +4,3 @@ export type { TranslatorOptions } from "./translator";
 export type { RoutingResolvedOptions } from "./routing";
 export type { CookieRawOptions, CookieResolvedOptions } from "./cookie";
 export type { LoggerOptions } from "./logger";
-export type { CacheRawOptions, CacheResolvedOptions } from "./cache";

package/dist/types/src/config/types/intor-config.d.ts

@@ -1,4 +1,3 @@
-import type { CacheRawOptions, CacheResolvedOptions } from "./cache";
 import type { CookieRawOptions, CookieResolvedOptions } from "./cookie";
 import type { ClientLoaderOptions, LoaderOptions, ServerLoaderOptions } from "./loader";
 import type { LoggerOptions } from "./logger";
@@ -35,8 +34,6 @@ export type IntorRawConfig = {
     };
     /** Logging and diagnostic configuration. */
     readonly logger?: Omit<LoggerOptions, "id">;
-    /** Cache policy used by remote messages loading. */
-    readonly cache?: CacheRawOptions;
 };
 /** Fully resolved configuration after validation and normalization. */
 export type IntorResolvedConfig = {
@@ -56,5 +53,4 @@ export type IntorResolvedConfig = {
         loader?: ClientLoaderOptions;
     };
     readonly logger: LoggerOptions;
-    readonly cache: CacheResolvedOptions;
 };

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, setGlobalMessagesPool, mergeMessages, isValidMessages, type Messages, type MessagesReader, type MessagesReadOptions, } from "./messages";
+export { loadRemoteMessages, type MessagesPool, getGlobalMessagesPool, clearMessagesPool, mergeMessages, isValidMessages, type MessagesReader, type MessagesReaders, } from "./messages";
 export type { INTOR_GENERATED_KEY, IfGen, GenConfigKeys, GenConfig, GenMessages, GenLocale, BootstrapCore, MessageKey, TranslatorInstance, KeyMode, RoutingLocaleSource, RoutingLocaleCarrier, LocalePathPrefix, } from "./types";

package/dist/types/src/core/messages/global-messages-pool.d.ts

@@ -1,22 +1,25 @@
 import type { LocaleMessages } from "intor-translator";
-import Keyv from "keyv";
 /**
- * Global messages pool (cross-module + hot-reload safe)
+ * Global messages pool (process-level, hot-reload safe).
+ *
+ * This pool is intentionally minimal:
+ * - No TTL
+ * - No eviction
+ * - No external backends
+ *
+ * Messages are treated as immutable within a process lifecycle.
  */
-export type MessagesPool = Keyv<LocaleMessages>;
+export type MessagesPool = Map<string, LocaleMessages>;
 declare global {
     var __INTOR_MESSAGES_POOL__: MessagesPool | undefined;
 }
-export declare function getGlobalMessagesPool(): MessagesPool;
 /**
- * Replace the global messages pool.
+ * Get the global messages pool.
  *
- * - Intended for advanced usage (e.g. Redis, custom cache backends).
- * - Must be called during application bootstrap.
- */
-export declare function setGlobalMessagesPool(pool: MessagesPool): void;
-/**
- * Optional: clear all cache
- * - Useful in tests or dynamic reloads.
+ * Lazily initialized to ensure:
+ * - Cross-module sharing
+ * - Dev / HMR safety
  */
+export declare function getGlobalMessagesPool(): MessagesPool;
+/** Clear all cached messages. */
 export declare function clearMessagesPool(): void;

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

@@ -1,5 +1,5 @@
 export { loadRemoteMessages } from "./load-remote-messages";
-export { type MessagesPool, getGlobalMessagesPool, clearMessagesPool, setGlobalMessagesPool, } from "./global-messages-pool";
+export { type MessagesPool, getGlobalMessagesPool, clearMessagesPool, } from "./global-messages-pool";
 export { mergeMessages } from "./merge-messages";
 export { isValidMessages } from "./utils/is-valid-messages";
-export type { Messages, MessagesReader, MessagesReadOptions } from "./types";
+export type { MessagesReader, MessagesReaders } from "./types";

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

@@ -7,9 +7,8 @@ import type { LocaleMessages } from "intor-translator";
  * 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.
  */
-export declare const loadRemoteMessages: ({ id, locale, fallbackLocales, namespaces, rootDir, url, headers, signal, pool, cacheOptions, allowCacheWrite, loggerOptions, }: LoadRemoteMessagesParams) => Promise<LocaleMessages | undefined>;
+export declare const loadRemoteMessages: ({ locale, fallbackLocales, namespaces, rootDir, url, headers, signal, loggerOptions, }: LoadRemoteMessagesParams) => Promise<LocaleMessages | undefined>;

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

@@ -1,7 +1,5 @@
-import type { RemoteHeaders, LoggerOptions, CacheResolvedOptions } from "../../../config";
-import type { MessagesPool } from "../../../core";
+import type { RemoteHeaders, LoggerOptions } from "../../../config";
 export interface LoadRemoteMessagesParams {
-    id: string;
     locale: string;
     fallbackLocales?: string[];
     namespaces?: string[];
@@ -9,8 +7,5 @@ export interface LoadRemoteMessagesParams {
     url: string;
     headers?: RemoteHeaders;
     signal?: AbortSignal;
-    pool?: MessagesPool;
-    cacheOptions: CacheResolvedOptions;
-    allowCacheWrite?: boolean;
     loggerOptions: LoggerOptions;
 }

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

@@ -1,37 +1,13 @@
-import type { NestedMessage } from "intor-translator";
 /**
- * Represents a collection of messages for a single locale.
+ * A function that reads and parses a message file.
  *
- * - This type does NOT include a locale layer.
- * - Each key represents a namespace or message group, and the value is a
- *   `NestedMessage` object that can contain nested message structures.
- *
- *
- * @example
- * ```ts
- * const messages: Messages = {
- *   ui: {
- *     greeting: "Hello",
- *     farewell: "Goodbye"
- *   },
- *   errors: {
- *     network: "Network error occurred"
- *   }
- * };
- * ```
- */
-export type Messages = Record<string, NestedMessage>;
-/**
- * A function that reads messages from a given file path.
- *
- * - This function is expected to return a `Promise` that resolves to a `Messages` object
- *   representing messages for a single locale.
- * - It can be implemented to support different file formats such as YAML, TOML, or others.
+ * This function is format-specific (YAML, TOML, etc.)
+ * and is NOT responsible for validating the returned structure.
  *
  * @param filePath - The path to the message file to read.
- * @returns A Promise that resolves to a `Messages` object.
+ * @returns A Promise that resolves to parsed, unvalidated content.
  *
- * @example
+ *   @example
  * ```ts
  * const reader: MessagesReader = async (filePath) => {
  *   const content = await fs.promises.readFile(filePath, "utf-8");
@@ -39,13 +15,15 @@ export type Messages = Record<string, NestedMessage>;
  * };
  * ```
  */
-export type MessagesReader = (filePath: string) => Promise<Messages>;
+export type MessagesReader = (filePath: string) => Promise<unknown>;
 /**
- * Options for reading locale messages.
+ * A map of file extension (without dot) to message reader.
  *
- * Used across loaders and runtimes to control how messages are read.
+ * Example:
+ * {
+ *   yaml: yamlReader,
+ *   yml: yamlReader,
+ *   toml: tomlReader,
+ * }
  */
-export interface MessagesReadOptions {
-    exts?: string[];
-    messagesReader?: MessagesReader;
-}
+export type MessagesReaders = Record<string, MessagesReader>;

package/dist/types/src/core/messages/utils/is-valid-messages.d.ts

@@ -1,15 +1,10 @@
-import type { Messages } from "../types";
+import type { MessageObject } from "intor-translator";
 /** Check if a value is a plain object (not null, not array) */
 export declare function isPlainObject(value: unknown): value is Record<string, unknown>;
 /**
- * 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.
  */
-export declare function isValidMessages(value: unknown): value is Messages;
+export declare function isValidMessages(value: unknown): value is MessageObject;

package/dist/types/src/core/types/translator-instance.d.ts

@@ -1,4 +1,4 @@
-import { type Locale, type Replacement, type ScopedLeafKeys, type LocalizedLeafKeys, type LocaleMessages } from "intor-translator";
+import { type Locale, type Replacement, type ScopedLeafKeys, type LocalizedLeafKeys, type LocaleMessages, type MessageValue } from "intor-translator";
 /** Key resolution strategy. */
 export type KeyMode = "auto" | "strict" | "string";
 /** Only allows keys resolved from message definitions. */
@@ -24,5 +24,7 @@ export type TranslatorInstance<M extends LocaleMessages, PK extends string | und
     hasKey: (key?: MessageKey<M, PK, Mode>, targetLocale?: Locale<M>) => boolean;
     /** Translate a given key into its string representation. */
     t: (key?: MessageKey<M, PK, Mode>, replacements?: Replacement) => string;
+    /** Translate a given key and return its raw message value. */
+    tRaw: (key?: MessageKey<M, PK, Mode>, replacements?: Replacement) => MessageValue | undefined;
 };
 export {};

package/dist/types/src/routing/inbound/resolve-locale/resolve-locale.d.ts

@@ -1,9 +1,10 @@
 import type { LocaleContext, ResolvedLocale } from "./types";
 import type { IntorResolvedConfig } from "../../../config";
 /**
- * Resolves the active locale from inbound routing configuration.
+ * Resolve the active locale from inbound routing configuration.
  *
- * The first matching locale from the configured sources is used,
- * with the detected locale as a guaranteed fallback.
+ * Iterates through configured locale sources and returns the first
+ * normalized, supported locale. Falls back to the detected locale
+ * or the default locale if none match.
  */
 export declare function resolveLocale(config: IntorResolvedConfig, context: LocaleContext): ResolvedLocale;

package/dist/types/src/routing/locale/get-locale-from-accept-language.d.ts

@@ -1,19 +1,17 @@
 import type { IntorResolvedConfig } from "../../config";
 /**
- * Resolve locale from the `Accept-Language` header.
+ * Get locale candidate from the `Accept-Language` header.
  *
- * - Parses language priorities (`q` values) from the header.
- * - Selects the highest-priority language supported by the application.
- * - Normalizes the matched locale against `supportedLocales`.
- *
- * If no supported locale can be resolved, `undefined` is returned.
+ * Parses language priorities and returns the highest-priority
+ * language present in `supportedLocales`, without normalization.
  *
  * @example
  * ```ts
  * getLocaleFromAcceptLanguage("en-US,en;q=0.8,zh-TW;q=0.9", ["en-US", "zh-TW"])
  * // => "en-US"
+ *
  * getLocaleFromAcceptLanguage("fr,ja;q=0.9", ["en", "zh-TW"])
  * // => undefined
  * ```
  */
-export declare const getLocaleFromAcceptLanguage: (config: IntorResolvedConfig, acceptLanguageHeader: string | undefined | null) => string | undefined;
+export declare const getLocaleFromAcceptLanguage: (acceptLanguageHeader: string | undefined | null, supportedLocales: IntorResolvedConfig["supportedLocales"]) => string | undefined;

package/dist/types/src/routing/locale/get-locale-from-host.d.ts

@@ -1,17 +1,21 @@
-import type { IntorResolvedConfig } from "../../config";
 /**
- * Extract locale from hostname.
+ * Get locale candidate from hostname.
  *
- * Only the left-most subdomain is considered as a locale candidate, if present.
+ * Returns the left-most hostname label, without validation or normalization.
  *
  * @example
  * ```ts
- * getLocaleFromHost(config, "en.example.com")
+ * getLocaleFromHost("en.example.com")
  * // => "en"
- * getLocaleFromHost(config, "example.com")
- * // => undefined
- * getLocaleFromHost(config, "api.jp.example.com")
+ *
+ * getLocaleFromHost("example.com")
+ * // => "example"
+ *
+ * getLocaleFromHost("api.jp.example.com")
+ * // => "api"
+ *
+ * getLocaleFromHost("localhost")
  * // => undefined
  * ```
  */
-export declare function getLocaleFromHost(config: IntorResolvedConfig, host: string | undefined): string | undefined;
+export declare function getLocaleFromHost(host: string | undefined): string | undefined;

package/dist/types/src/routing/locale/get-locale-from-pathname.d.ts

@@ -1,18 +1,9 @@
 import type { IntorResolvedConfig } from "../../config";
 /**
- * Extracts the locale from a pathname, if present.
+ * Get locale from pathname.
  *
- * - Normalizes the raw pathname.
- * - Strips the configured basePath.
- * - Inspects the first path segment to determine whether
- *   it matches a supported locale.
- *
- * If no locale segment is found, `undefined` is returned.
- *
- * Note:
- * - The pathname is treated as a canonical source.
- * - Only exact matches against `supportedLocales` are accepted.
- * - ___Locale normalization is intentionally not applied here.___
+ * Extracts the first pathname segment (after basePath) as a locale
+ * if it exactly matches one of the supported locales.
  *
  * @example
  * ```ts
@@ -28,4 +19,4 @@ import type { IntorResolvedConfig } from "../../config";
  * // => "en"
  * ```
  */
-export declare function getLocaleFromPathname(config: IntorResolvedConfig, pathname: string): string | undefined;
+export declare function getLocaleFromPathname(pathname: string, config: IntorResolvedConfig): string | undefined;

package/dist/types/src/routing/locale/get-locale-from-query.d.ts

@@ -1,20 +1,19 @@
-import type { IntorResolvedConfig } from "../../config";
 /**
- * Extracts locale from URL query parameters.
+ * Get locale candidate from URL query parameters.
  *
- * - Reads the configured locale query key.
- * - Normalizes the value against supported locales.
- *
- * If no valid locale is found, `undefined` is returned.
+ * Extracts the value of the configured query key, without
+ * validation or normalization.
  *
  * @example
  * ```ts
- * getLocaleFromQuery(config, { locale: "en" })
+ * getLocaleFromQuery({ locale: "en" }, "locale")
  * // => "en"
- * getLocaleFromQuery(config, {})
+ *
+ * getLocaleFromQuery({}, "locale")
  * // => undefined
- * getLocaleFromQuery(config, { locale: ["zh-TW"] })
+ *
+ * getLocaleFromQuery({ locale: ["zh-TW"] }, "locale")
  * // => "zh-TW"
  * ```
  */
-export declare function getLocaleFromQuery(config: IntorResolvedConfig, query: Record<string, string | string[] | undefined> | undefined): string | undefined;
+export declare function getLocaleFromQuery(query: Record<string, string | string[] | undefined> | undefined, queryKey: string): string | undefined;

package/dist/types/src/server/helpers/get-translator.d.ts

@@ -1,13 +1,12 @@
 import type { TranslatorInstanceServer } from "../translator/translator-instance";
 import type { IntorResolvedConfig } from "../../config";
-import type { GenConfigKeys, GenMessages } from "../../core";
-import type { MessagesReadOptions } from "../../core";
+import type { GenConfigKeys, GenMessages, MessagesReaders } from "../../core";
 import type { LocalizedNodeKeys, TranslateHandlers, TranslateHook, TranslatorPlugin } from "intor-translator";
 export interface GetTranslatorParams {
     locale: string;
     handlers?: TranslateHandlers;
     plugins?: (TranslatorPlugin | TranslateHook)[];
-    readOptions?: MessagesReadOptions;
+    readers?: MessagesReaders;
     allowCacheWrite?: boolean;
 }
 /**

package/dist/types/src/server/messages/load-local-messages/load-local-messages.d.ts

@@ -7,12 +7,12 @@ import type { LocaleMessages } from "intor-translator";
  * 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.
  */
-export declare const loadLocalMessages: ({ id, locale, fallbackLocales, namespaces, rootDir, concurrency, readOptions, pool, allowCacheWrite, loggerOptions, }: LoadLocalMessagesParams) => Promise<LocaleMessages | undefined>;
+export declare const loadLocalMessages: ({ id, locale, fallbackLocales, namespaces, rootDir, concurrency, readers, pool, allowCacheWrite, loggerOptions, }: LoadLocalMessagesParams) => Promise<LocaleMessages | undefined>;