intor 2.3.10 → 2.3.11

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

@@ -1,22 +1,18 @@
 // Default routing options
 const DEFAULT_ROUTING_OPTIONS = {
-    locale: {
-        sources: ["path", "query", "cookie", "detected"],
-        query: { key: "locale" },
-    },
-    navigation: {
-        carrier: "path",
-        path: { prefix: "none" },
-        query: { key: "locale" },
-        host: { map: {} },
+    basePath: "/",
+    localePrefix: "none",
+    inbound: {
+        localeSources: ["path", "query", "cookie", "detected"],
+        queryKey: "locale",
+        firstVisit: { localeSource: "browser", persist: true, redirect: true },
     },
-    firstVisit: {
-        localeSource: "browser",
-        redirect: true,
-        persist: true,
+    outbound: {
+        localeCarrier: "path",
+        queryKey: "locale",
+        host: { map: {}, default: undefined },
+        forceFullReload: false,
     },
-    basePath: "/",
-    forceFullReload: false,
 };
 
 export { DEFAULT_ROUTING_OPTIONS };

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

@@ -3,34 +3,34 @@ import { resolveCookieOptions } from './resolvers/resolve-cookie-options.js';
 import { resolveFallbackLocales } from './resolvers/resolve-fallback-locales.js';
 import { resolveRoutingOptions } from './resolvers/resolve-routing-options.js';
 import { validateDefaultLocale } from './validators/validate-default-locale.js';
+import { validateId } from './validators/validate-id.js';
 import { validateSupportedLocales } from './validators/validate-supported-locales.js';
 
 /**
- * Defines and resolves an Intor configuration.
+ * Defines the canonical Intor configuration.
  *
- * This is the canonical entry point for transforming a raw configuration
- * into a fully validated and resolved Intor config.
+ * Transforms a raw config into a validated and runtime-ready form by:
+ * - enforcing required invariants
+ * - resolving derived options
+ * - applying stable defaults
  *
- * Responsibilities:
- * - Validate required invariants
- * - Resolve and normalize derived options
- * - Apply stable defaults
- *
- * This function is purely declarative and side-effect free.
- * It does not create runtime instances or attach dynamic behavior.
- *
- * Intended to run once during application initialization.
+ * This function is declarative and side-effect free.
  */
 const defineIntorConfig = (config) => {
+    // -----------------------------------------------------------------------------
     // Validators
-    const supportedLocales = validateSupportedLocales(config);
-    const defaultLocale = validateDefaultLocale(config, supportedLocales);
+    // -----------------------------------------------------------------------------
+    const id = validateId(config.id ?? "default");
+    const supportedLocales = validateSupportedLocales(id, config.supportedLocales);
+    const supportedSet = new Set(supportedLocales);
+    const defaultLocale = validateDefaultLocale(id, config.defaultLocale, supportedSet);
+    // -----------------------------------------------------------------------------
     // Resolvers
-    const fallbackLocales = resolveFallbackLocales(config, supportedLocales);
+    // -----------------------------------------------------------------------------
+    const fallbackLocales = resolveFallbackLocales(config, id, supportedSet);
     const cookie = resolveCookieOptions(config.cookie);
     const routing = resolveRoutingOptions(config.routing);
     const cache = resolveCacheOptions(config.cache);
-    const id = config.id ?? "default";
     return {
         id,
         messages: config.messages,

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

@@ -1,50 +1,60 @@
+import '../../core/error/intor-error.js';
+import { getLogger } from '../../core/logger/get-logger.js';
+import 'keyv';
+
 /**
- * Resolves and normalizes fallback locale mappings.
- *
- * This utility validates the user-defined `fallbackLocales` configuration
- * against the provided `supportedLocales` list and the configured `defaultLocale`.
- *
- * Resolution rules:
- * - Only locales listed in `supportedLocales` are considered valid fallbacks.
- * - The literal value `"default"` is always allowed and represents the configured default locale.
- * - Fallback entries matching `defaultLocale` are treated as valid.
- * - Invalid fallback locales are ignored and reported via warnings.
+ * Resolves fallbackLocales into a runtime-safe mapping.
  *
- * Notes:
- * - This function is purely defensive and does not throw on invalid input.
- * - Only validated fallback mappings are included in the returned result.
- * - Logging is used for diagnostics only and does not affect the output.
+ * Invalid entries are ignored and reported via warnings.
  */
-const resolveFallbackLocales = (config, supportedLocales) => {
+const resolveFallbackLocales = (config, id, supportedSet) => {
     const { defaultLocale, fallbackLocales } = config;
+    // Fast exit: no fallback configuration provided
     if (!fallbackLocales || typeof fallbackLocales !== "object") {
         return {};
     }
-    const supportedSet = new Set(supportedLocales);
-    const validMap = {}; // Collected valid fallbacks
-    const invalidFallbackMap = new Map(); // Track invalid ones
+    const logger = getLogger({ id }).child({
+        scope: "resolve-fallback-locales",
+    });
+    const resolvedMap = {};
+    const invalidMap = new Map();
+    // ---------------------------------------------------------------------------
+    // Normalize each fallback rule
+    // ---------------------------------------------------------------------------
     for (const [locale, fallbacks] of Object.entries(fallbackLocales)) {
-        const fallbackArray = Array.isArray(fallbacks) ? fallbacks : [];
-        // Valid: in supported list, matches default, or literal "default"
-        const validFallbacks = fallbackArray.filter((fallback) => fallback === "default" ||
-            supportedSet.has(fallback) ||
-            fallback === defaultLocale);
-        // Invalid: not "default", not supported, and not defaultLocale
-        const invalidFallbacks = fallbackArray.filter((fallback) => fallback !== "default" &&
-            !supportedSet.has(fallback) &&
-            fallback !== defaultLocale);
-        if (invalidFallbacks.length > 0) {
-            invalidFallbackMap.set(locale, invalidFallbacks);
+        // Guard: fallback rules for unreachable locales are ignored.
+        if (!supportedSet.has(locale) && locale !== defaultLocale) {
+            logger.warn(`Fallback locale "${locale}" is not listed in supportedLocales.`);
+            continue;
         }
-        if (validFallbacks.length > 0) {
-            validMap[locale] = validFallbacks;
+        const fallbackArray = Array.isArray(fallbacks) ? fallbacks : [];
+        const validFallbacks = [];
+        const invalidFallbacks = [];
+        for (const fallback of fallbackArray) {
+            // A fallback target is considered valid if:
+            // - It exists in `supportedLocales`
+            // - It is the literal value "default"
+            if (fallback === "default" || supportedSet.has(fallback)) {
+                validFallbacks.push(fallback);
+            }
+            else {
+                invalidFallbacks.push(fallback);
+            }
         }
+        if (invalidFallbacks.length > 0)
+            invalidMap.set(locale, invalidFallbacks);
+        if (validFallbacks.length > 0)
+            resolvedMap[locale] = validFallbacks;
     }
-    // Log out invalid fallback locales
-    for (const [locale, invalids] of invalidFallbackMap.entries()) {
-        console.warn(`Invalid fallback locales for "${locale}"`, { invalids: [...invalids] }, { scope: "resolveFallbackLocales" });
+    // ---------------------------------------------------------------------------
+    // Diagnostics: report ignored fallback entries
+    // ---------------------------------------------------------------------------
+    for (const [locale, invalids] of invalidMap.entries()) {
+        logger.warn(`Invalid fallback locales for "${locale}".`, {
+            invalids: invalids.join(", "),
+        });
     }
-    return validMap;
+    return resolvedMap;
 };
 
 export { resolveFallbackLocales };

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

@@ -1,45 +1,65 @@
 import '../../core/error/intor-error.js';
-import { normalizePathname } from '../../core/utils/normalizers/normalize-pathname.js';
+import { deepMerge } from '../../core/utils/deep-merge.js';
 import 'logry';
 import 'keyv';
 import { DEFAULT_ROUTING_OPTIONS } from '../constants/routing.js';
 import '../constants/cookie.js';
 import '../constants/cache.js';
 
-const resolveRoutingOptions = (routing = {}) => {
-    return {
-        ...DEFAULT_ROUTING_OPTIONS,
-        ...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,
-            ...routing.firstVisit,
-        },
-        basePath: normalizePathname(routing?.basePath || ""),
-    };
-};
+/**
+ * Resolves routing configuration into a fully normalized form.
+ *
+ * - Flat shortcuts are projected into structured options.
+ * - Structured options override projected values.
+ * - Defaults are applied last.
+ */
+function resolveRoutingOptions(raw) {
+    if (!raw)
+        return DEFAULT_ROUTING_OPTIONS;
+    const projectedFromFlat = projectFlatToStructured(raw);
+    const structuredOverrides = stripFlatShortcuts(raw);
+    const defined = deepMerge(projectedFromFlat, structuredOverrides);
+    return deepMerge(DEFAULT_ROUTING_OPTIONS, defined);
+}
+/** Assigns a value to the target only if it is explicitly defined. */
+function assignIfDefined(target, key, value) {
+    if (value !== undefined)
+        target[key] = value;
+}
+/** Projects flat routing shortcuts into structured options. */
+function projectFlatToStructured(flat) {
+    const structured = {};
+    assignIfDefined(structured, "basePath", flat.basePath);
+    assignIfDefined(structured, "localePrefix", flat.localePrefix);
+    // inbound
+    const inbound = {};
+    assignIfDefined(inbound, "localeSources", flat.localeSources);
+    assignIfDefined(inbound, "queryKey", flat.queryKey);
+    assignIfDefined(inbound, "firstVisit", flat.firstVisit);
+    if (Object.keys(inbound).length > 0)
+        structured.inbound = inbound;
+    // outbound
+    const outbound = {};
+    assignIfDefined(outbound, "localeCarrier", flat.localeCarrier);
+    assignIfDefined(outbound, "queryKey", flat.queryKey);
+    assignIfDefined(outbound, "host", flat.host);
+    assignIfDefined(outbound, "forceFullReload", flat.forceFullReload);
+    if (Object.keys(outbound).length > 0)
+        structured.outbound = outbound;
+    return structured;
+}
+/** Removes flat shortcuts, preserving structured overrides only. */
+function stripFlatShortcuts(raw) {
+    const structured = {};
+    if ("basePath" in raw)
+        structured.basePath = raw.basePath;
+    if ("localePrefix" in raw)
+        structured.localePrefix = raw.localePrefix;
+    if ("inbound" in raw)
+        structured.inbound = raw.inbound;
+    if ("outbound" in raw)
+        structured.outbound = raw.outbound;
+    return structured;
+}
 
 export { resolveRoutingOptions };

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

@@ -3,30 +3,16 @@ import 'logry';
 import 'keyv';
 
 /**
- * Validates the configured default locale.
+ * Validates that the configured defaultLocale is supported.
  *
- * - Ensures that `defaultLocale` is explicitly defined.
- * - Ensures that `defaultLocale` is included in `supportedLocales`.
- *
- * This validation is part of the configuration initialization phase
- * and is expected to fail fast when misconfigured.
+ * Fails fast if `defaultLocale` is not included in `supportedLocales`.
  */
-const validateDefaultLocale = (config, supportedLocales) => {
-    const { id, defaultLocale } = config;
-    // Throw error if defaultLocale is undefined
-    if (!defaultLocale) {
-        throw new IntorError({
-            id,
-            code: IntorErrorCode.MISSING_DEFAULT_LOCALE,
-            message: `The defaultLocale is undefined`,
-        });
-    }
-    // Throw error if defaultLocale is not listed in supportedLocales
-    if (!supportedLocales.includes(defaultLocale)) {
+const validateDefaultLocale = (id, defaultLocale, supportedSet) => {
+    if (!supportedSet.has(defaultLocale)) {
         throw new IntorError({
             id,
             code: IntorErrorCode.UNSUPPORTED_DEFAULT_LOCALE,
-            message: `The defaultLocale "${defaultLocale}" is not included in the supportedLocales.`,
+            message: `"defaultLocale" must be included in "supportedLocales".`,
         });
     }
     return defaultLocale;

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

@@ -0,0 +1,21 @@
+import { IntorError, IntorErrorCode } from '../../core/error/intor-error.js';
+import 'logry';
+import 'keyv';
+
+/**
+ * Validates that the given id is a non-empty string.
+ *
+ * Fails fast if the id is empty or whitespace-only.
+ */
+const validateId = (id) => {
+    if (id.trim() === "") {
+        throw new IntorError({
+            id,
+            code: IntorErrorCode.INVALID_CONFIG_ID,
+            message: `"id" must be a non-empty string.`,
+        });
+    }
+    return id;
+};
+
+export { validateId };

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

@@ -3,29 +3,19 @@ import 'logry';
 import 'keyv';
 
 /**
- * Validates and resolves the list of supported locales.
+ * Validates that supportedLocales is provided and non-empty.
  *
- * - Ensures `supportedLocales` is explicitly provided when a loader is used.
- * - Falls back to inferring locales from static message keys when no loader
- *   is configured.
- *
- * This validation runs during configuration initialization and is expected
- * to fail fast when required inputs are missing.
+ * Fails fast when missing.
  */
-const validateSupportedLocales = (config) => {
-    const { id, supportedLocales } = config;
-    const hasAnyLoader = !!config.loader || !!config.server?.loader || !!config.client?.loader;
-    // Ensure supportedLocales is set when using loader
-    if (hasAnyLoader && !supportedLocales) {
+const validateSupportedLocales = (id, supportedLocales) => {
+    if (!supportedLocales || supportedLocales.length === 0) {
         throw new IntorError({
             id,
             code: IntorErrorCode.MISSING_SUPPORTED_LOCALES,
-            message: `"supportedLocales" is required when using message loaders. 
-                 Please specify all supported locales explicitly.`,
+            message: `"supportedLocales" must be specified.`,
         });
     }
-    // Return supportedLocales or infer from message keys
-    return supportedLocales || Object.keys(config.messages || {});
+    return supportedLocales;
 };
 
 export { validateSupportedLocales };

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

@@ -13,8 +13,8 @@ class IntorError extends Error {
 var IntorErrorCode;
 (function (IntorErrorCode) {
     // config
+    IntorErrorCode["INVALID_CONFIG_ID"] = "INTOR_INVALID_CONFIG_ID";
     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";

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

@@ -5,35 +5,35 @@ import 'logry';
 import 'keyv';
 
 /**
- * Applies routing prefix strategy by resolving the locale placeholder.
+ * Applies the configured locale prefix behavior to a standardized pathname.
  *
  * @example
  * ```ts
- * // config.routing.prefix: "all"
+ * // config.routing.localePrefix: "all"
  * localePrefixPathname({ config, pathname: "/app/{locale}/about", locale: "en-US" });
  * // => /app/en-US/about
  *
- * // config.routing.prefix: "none"
+ * // config.routing.localePrefix: "none"
  * localePrefixPathname({ config, pathname: "/app/{locale}/about", locale: "en-US" });
  * // => /app/about
  * ```
  */
 const localePrefixPathname = (config, standardizedPathname, locale) => {
-    const { prefix } = config.routing.navigation.path;
-    if (prefix !== "none" && !locale) {
-        throw new Error('No locale when using prefix "all", "except-default"');
+    const { localePrefix } = config.routing;
+    if (localePrefix !== "none" && !locale) {
+        throw new Error('No locale when using localePrefix "all", "except-default"');
     }
-    // prefix: "all"
-    if (prefix === "all") {
+    // localePrefix: "all"
+    if (localePrefix === "all") {
         return normalizePathname(standardizedPathname.replaceAll(PREFIX_PLACEHOLDER, locale));
     }
-    // prefix: "except-default"
-    if (prefix === "except-default") {
+    // localePrefix: "except-default"
+    if (localePrefix === "except-default") {
         return locale === config.defaultLocale
             ? normalizePathname(standardizedPathname.replaceAll(`/${PREFIX_PLACEHOLDER}`, ""))
             : normalizePathname(standardizedPathname.replaceAll(PREFIX_PLACEHOLDER, locale));
     }
-    // prefix: "none"
+    // localePrefix: "none"
     return normalizePathname(standardizedPathname.replaceAll(`/${PREFIX_PLACEHOLDER}`, ""));
 };
 

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

@@ -45,7 +45,6 @@ async function loadMessagesFromUrl(url, options) {
         concurrency: options?.concurrency,
         readOptions: options?.readOptions,
         pool: options?.pool,
-        cacheOptions: options?.cacheOptions || { enabled: false, ttl: 0 },
         allowCacheWrite: options?.allowCacheWrite,
         loggerOptions: options?.loggerOptions || { id: "default" },
     });

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

@@ -13,18 +13,21 @@ import { readLocaleMessages } from './read-locale-messages/read-locale-messages.
  * It coordinates:
  *
  * - Locale resolution with fallbacks
- * - Cache read / write behavior
+ * - Process-level memoization (read by default, write by ownership)
  * - Concurrency control for file system access
  *
+ * Local messages are cached for the lifetime of the process.
+ * Cache writes are restricted to the primary initialization flow.
+ *
  * File traversal, parsing, and validation are delegated to lower-level utilities.
  */
-const loadLocalMessages = async ({ id, locale, fallbackLocales, namespaces, rootDir = "messages", concurrency = 10, readOptions, pool = getGlobalMessagesPool(), cacheOptions, allowCacheWrite = false, loggerOptions, }) => {
+const loadLocalMessages = async ({ id, locale, fallbackLocales, namespaces, rootDir = "messages", concurrency = 10, readOptions, pool = getGlobalMessagesPool(), 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),
+        resolvedRootDir: path.resolve(rootDir),
     });
     // ---------------------------------------------------------------------------
     // Cache key resolution
@@ -40,13 +43,11 @@ const loadLocalMessages = async ({ id, locale, fallbackLocales, namespaces, root
     // ---------------------------------------------------------------------------
     // Cache read
     // ---------------------------------------------------------------------------
-    if (cacheOptions.enabled) {
-        if (cacheKey) {
-            const cached = await pool?.get(cacheKey);
-            if (cached) {
-                logger.debug("Messages cache hit.", { key: cacheKey });
-                return cached;
-            }
+    if (cacheKey) {
+        const cached = await pool?.get(cacheKey);
+        if (cached) {
+            logger.debug("Messages cache hit.", { key: cacheKey });
+            return cached;
         }
     }
     // ---------------------------------------------------------------------------
@@ -88,9 +89,9 @@ const loadLocalMessages = async ({ id, locale, fallbackLocales, namespaces, root
     // ---------------------------------------------------------------------------
     // Cache write (explicitly permitted)
     // ---------------------------------------------------------------------------
-    if (cacheOptions.enabled && allowCacheWrite) {
+    if (allowCacheWrite) {
         if (cacheKey && messages) {
-            await pool?.set(cacheKey, messages, cacheOptions.ttl);
+            await pool?.set(cacheKey, messages);
         }
     }
     // Final success log with resolved locale and timing

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

@@ -18,7 +18,7 @@ const readLocaleMessages = async ({ locale, namespaces, rootDir = "messages", li
     // ---------------------------------------------------------------------------
     const fileEntries = await collectFileEntries({
         namespaces,
-        rootDir: path.resolve(process.cwd(), rootDir, locale),
+        rootDir: path.resolve(rootDir, locale),
         limit,
         exts,
         loggerOptions,

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

@@ -52,7 +52,6 @@ const loadMessages = async ({ config, locale, readOptions, allowCacheWrite = fal
             rootDir: loader.rootDir,
             concurrency: loader.concurrency,
             readOptions,
-            cacheOptions: config.cache,
             allowCacheWrite,
             loggerOptions: config.logger,
         });

package/dist/express/src/adapters/express/middleware/create-intor.js

@@ -16,8 +16,8 @@ import { getTranslator } from '../../../server/helpers/get-translator.js';
  *
  * The resolved routing state is exposed via response headers.
  *
- * - Convenience routing shortcuts are also bound to the request for downstream consumption.
  * - Acts as the bootstrap entry where cache writes are permitted.
+ * - Convenience routing shortcuts are also bound to the request for downstream consumption.
  *
  * @platform Express
  */
@@ -26,14 +26,18 @@ function createIntor(config, options) {
         // locale from accept-language header
         const acceptLanguage = req.headers["accept-language"];
         const localeFromAcceptLanguage = getLocaleFromAcceptLanguage(config, acceptLanguage);
-        // Resolve routing decision (locale + pathname)
-        const { locale, localeSource, pathname } = resolveInbound(config, req.path, {
+        // ----------------------------------------------------------
+        // Resolve inbound routing decision (pure computation)
+        // ----------------------------------------------------------
+        const { locale, localeSource, pathname } = await resolveInbound(config, req.path, false, {
             host: req.hostname,
             query: normalizeQuery(req.query),
             cookie: req.cookies?.[config.cookie.name],
             detected: localeFromAcceptLanguage || config.defaultLocale,
         });
-        // Attach resolved routing metadata to response headers
+        // --------------------------------------------------
+        // Attach routing metadata to response headers
+        // --------------------------------------------------
         req.headers[INTOR_HEADERS.LOCALE] = locale;
         req.headers[INTOR_HEADERS.LOCALE_SOURCE] = localeSource;
         req.headers[INTOR_HEADERS.PATHNAME] = pathname;

package/dist/express/src/core/constants/headers.js

@@ -1,7 +1,6 @@
 const INTOR_HEADERS = {
     LOCALE: "x-intor-locale",
     LOCALE_SOURCE: "x-intor-locale-source",
-    PATHNAME: "x-intor-pathname",
-};
+    PATHNAME: "x-intor-pathname"};
 
 export { INTOR_HEADERS };

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

@@ -13,8 +13,8 @@ class IntorError extends Error {
 var IntorErrorCode;
 (function (IntorErrorCode) {
     // config
+    IntorErrorCode["INVALID_CONFIG_ID"] = "INTOR_INVALID_CONFIG_ID";
     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";

package/dist/express/src/routing/inbound/resolve-inbound.js

@@ -16,25 +16,26 @@ import { resolvePathname } from './resolve-pathname/resolve-pathname.js';
  *
  * No side effects. No navigation.
  */
-function resolveInbound(config, rawPathname, localeInputs) {
+async function resolveInbound(config, rawPathname, hasRedirected, localeInputs) {
     const { host, query, cookie, detected } = localeInputs;
-    // --------------------------------------------------
+    // ------------------------------------------------------
     // Resolve locale from inbound inputs
-    // --------------------------------------------------
+    // ------------------------------------------------------
+    const pathLocale = getLocaleFromPathname(config, rawPathname);
     const { locale, localeSource } = resolveLocale(config, {
-        path: { locale: getLocaleFromPathname(config, rawPathname) },
+        path: { locale: pathLocale },
         host: { locale: getLocaleFromHost(config, host) },
         query: { locale: getLocaleFromQuery(config, query) },
         cookie: { locale: cookie },
         detected: { locale: detected },
     });
-    // --------------------------------------------------
+    // ------------------------------------------------------
     // Resolve localized pathname and redirect requirement
-    // --------------------------------------------------
+    // ------------------------------------------------------
     const { pathname, shouldRedirect } = resolvePathname(config, rawPathname, {
         locale,
-        localeSource,
-    });
+        hasPathLocale: !!pathLocale,
+        hasPersisted: !!cookie});
     return {
         locale,
         localeSource,

package/dist/express/src/routing/inbound/resolve-locale/resolve-locale.js

@@ -1,19 +1,12 @@
 /**
- * Resolve the final locale based on routing configuration.
+ * Resolves the active locale from inbound routing configuration.
  *
- * - This function iterates through locale sources defined in
- * `config.routing.locale.sources` and returns the first
- * matching locale found in the provided context.
- *
- * - If no configured source yields a locale, the detected
- * locale is used as a guaranteed fallback.
- *
- * - The returned locale represents the single source of truth
- * for the remainder of the routing flow.
+ * The first matching locale from the configured sources is used,
+ * with the detected locale as a guaranteed fallback.
  */
 function resolveLocale(config, context) {
-    const { sources } = config.routing.locale;
-    for (const source of sources) {
+    const { localeSources } = config.routing.inbound;
+    for (const source of localeSources) {
         const locale = context[source]?.locale;
         if (!locale)
             continue;