intor 2.3.32 → 2.3.34

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

@@ -18,16 +18,20 @@
  *   for the given runtime.
  */
 const resolveLoaderOptions = (config, runtime) => {
-    // --- runtime: client ---
+    // ------------------------------------------------
+    // runtime: client
+    // ------------------------------------------------
     if (runtime === "client") {
         const client = config.client?.loader;
         if (client) {
             // Client loader is always remote by design
-            return { type: "remote", ...client };
+            return { mode: "remote", ...client };
         }
         return config.server?.loader ?? config.loader;
     }
-    // --- runtime: server ---
+    // ------------------------------------------------
+    // runtime: server
+    // ------------------------------------------------
     return config.server?.loader ?? config.loader;
 };
 

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

@@ -29,12 +29,12 @@ const loadMessages = async ({ config, locale, readers, allowCacheWrite = false,
         logger.warn("No loader options have been configured in the current config.");
         return;
     }
-    const { type, namespaces, concurrency } = loader;
+    const { mode, namespaces, concurrency } = loader;
     const fallbackLocales = config.fallbackLocales[locale] || [];
     logger.info(`Loading messages for locale "${locale}".`);
     logger.trace("Starting to load messages with runtime context.", {
-        loaderType: type,
-        ...(type === "local" ? { rootDir: loader.rootDir } : {}),
+        loaderMode: mode,
+        ...(mode === "local" ? { rootDir: loader.rootDir } : {}),
         locale,
         fallbackLocales: fallbackLocales.join(", "),
         namespaces: namespaces && namespaces.length > 0 ? [...namespaces] : "*",
@@ -43,7 +43,7 @@ const loadMessages = async ({ config, locale, readers, allowCacheWrite = false,
     // Dispatch to loader implementation
     // ---------------------------------------------------------------------------
     let loadedMessages;
-    if (type === "local") {
+    if (mode === "local") {
         loadedMessages = await loadLocalMessages({
             id: config.id,
             locale,
@@ -56,7 +56,7 @@ const loadMessages = async ({ config, locale, readers, allowCacheWrite = false,
             loggerOptions: config.logger,
         });
     }
-    else if (type === "remote") {
+    else if (mode === "remote") {
         loadedMessages = await loadRemoteMessages({
             locale,
             fallbackLocales,

package/dist/express/export/express/index.js

@@ -1,2 +1,2 @@
-export { createIntorMiddleware } from '../../src/adapters/express/middleware/create-intor-middleware.js';
-export { getTranslator } from '../../src/adapters/express/helpers/get-translator.js';
+export { createIntorHandler } from '../../src/adapters/express/create-intor-handler.js';
+export { getTranslator } from '../../src/adapters/express/get-translator.js';

package/dist/express/src/adapters/express/{middleware/create-intor-middleware.js → create-intor-handler.js}

@@ -1,14 +1,14 @@
-import '../../../core/error/intor-error.js';
-import { normalizeQuery } from '../../../core/utils/normalizers/normalize-query.js';
+import '../../core/error/intor-error.js';
+import { normalizeQuery } from '../../core/utils/normalizers/normalize-query.js';
 import 'logry';
 import 'p-limit';
 import 'intor-translator';
-import { resolveInbound } from '../../../routing/inbound/resolve-inbound.js';
-import { getLocaleFromAcceptLanguage } from '../../../routing/locale/get-locale-from-accept-language.js';
+import { resolveInbound } from '../../routing/inbound/resolve-inbound.js';
+import { getLocaleFromAcceptLanguage } from '../../routing/locale/get-locale-from-accept-language.js';
 import 'node:path';
 import 'node:fs/promises';
-import { getTranslator } from '../../../server/helpers/get-translator.js';
-import { parseCookieHeader } from '../../../server/shared/utils/parse-cookie-header.js';
+import { getTranslator } from '../../server/helpers/get-translator.js';
+import { parseCookieHeader } from '../../server/shared/utils/parse-cookie-header.js';
 
 /**
  * Resolves locale-aware routing for the current execution context.
@@ -20,15 +20,15 @@ import { parseCookieHeader } from '../../../server/shared/utils/parse-cookie-hea
  *
  * @platform Express
  */
-function createIntorMiddleware(config, options) {
-    return async function intorMiddleware(req, _res, next) {
+function createIntorHandler(config, options) {
+    return async function intorHandler(req, _res, next) {
         // Locale from Accept-Language header
         const acceptLanguage = req.headers["accept-language"];
         const localeFromAcceptLanguage = getLocaleFromAcceptLanguage(acceptLanguage, config.supportedLocales);
         // ----------------------------------------------------------
         // Resolve inbound routing decision (pure computation)
         // ----------------------------------------------------------
-        const { locale, localeSource, pathname } = await resolveInbound(config, req.path, false, {
+        const { locale, localeSource, pathname } = await resolveInbound(config, req.path, {
             host: req.hostname,
             query: normalizeQuery(req.query),
             cookie: parseCookieHeader(req.headers.cookie)[config.cookie.name],
@@ -38,19 +38,20 @@ function createIntorMiddleware(config, options) {
         // Bind inbound routing context
         // --------------------------------------------------
         req.intor = { locale, localeSource, pathname };
-        const { hasKey, t } = (await getTranslator(config, {
+        const { hasKey, t, tRich } = await getTranslator(config, {
             locale,
             handlers: options?.handlers,
             plugins: options?.plugins,
             readers: options?.readers,
             allowCacheWrite: true,
-        }));
+        });
         // DX shortcuts (optional)
         req.locale = locale;
         req.hasKey = hasKey;
         req.t = t;
+        req.tRich = tRich;
         return next();
     };
 }
 
-export { createIntorMiddleware };
+export { createIntorHandler };

package/dist/express/src/adapters/express/{helpers/get-translator.js → get-translator.js}

@@ -1,10 +1,10 @@
-import '../../../core/error/intor-error.js';
+import '../../core/error/intor-error.js';
 import 'logry';
 import 'p-limit';
 import 'intor-translator';
 import 'node:path';
 import 'node:fs/promises';
-import { getTranslator as getTranslator$1 } from '../../../server/helpers/get-translator.js';
+import { getTranslator as getTranslator$1 } from '../../server/helpers/get-translator.js';
 
 // Implementation
 async function getTranslator(config, req, params) {
@@ -16,10 +16,6 @@ async function getTranslator(config, req, params) {
         plugins,
         readers,
         allowCacheWrite,
-        // NOTE:
-        // The runtime implementation is intentionally erased.
-        // Type safety is guaranteed by public type contracts.
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
     });
 }
 

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

@@ -18,7 +18,9 @@
  *   for the given runtime.
  */
 const resolveLoaderOptions = (config, runtime) => {
-    // --- runtime: server ---
+    // ------------------------------------------------
+    // runtime: server
+    // ------------------------------------------------
     return config.server?.loader ?? config.loader;
 };
 

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

@@ -13,7 +13,8 @@ import { resolvePathname } from './resolve-pathname/resolve-pathname.js';
  *
  * No side effects. No navigation.
  */
-async function resolveInbound(config, rawPathname, hasRedirected, localeInputs) {
+async function resolveInbound(config, rawPathname, localeInputs, options) {
+    const { queryKey } = config.routing.inbound;
     const { host, query, cookie, detected } = localeInputs;
     // ------------------------------------------------------
     // Resolve locale from inbound inputs
@@ -22,9 +23,7 @@ async function resolveInbound(config, rawPathname, hasRedirected, localeInputs)
     const { locale, localeSource } = resolveLocale(config, {
         path: { locale: pathLocale },
         host: { locale: getLocaleFromHost(host) },
-        query: {
-            locale: getLocaleFromQuery(query, config.routing.inbound.queryKey),
-        },
+        query: { locale: getLocaleFromQuery(query, queryKey) },
         cookie: { locale: cookie },
         detected: { locale: detected },
     });

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

@@ -7,9 +7,9 @@ import 'intor-translator';
 /**
  * Resolve the active locale from inbound routing configuration.
  *
- * 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.
+ * 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.
  */
 function resolveLocale(config, context) {
     const { localeSources } = config.routing.inbound;
@@ -24,9 +24,10 @@ function resolveLocale(config, context) {
         };
     }
     // Fallback: detected is always available
+    const fallback = normalizeLocale(context.detected.locale, config.supportedLocales) ||
+        config.defaultLocale;
     return {
-        locale: normalizeLocale(context.detected.locale, config.supportedLocales) ||
-            config.defaultLocale,
+        locale: fallback,
         localeSource: "detected",
     };
 }

package/dist/express/src/routing/locale/get-locale-from-query.js

@@ -11,19 +11,11 @@
  *
  * getLocaleFromQuery({}, "locale")
  * // => undefined
- *
- * getLocaleFromQuery({ locale: ["zh-TW"] }, "locale")
- * // => "zh-TW"
- * ```
  */
 function getLocaleFromQuery(query, queryKey) {
     if (!query)
         return;
-    const raw = query[queryKey];
-    if (!raw)
-        return;
-    const value = Array.isArray(raw) ? raw[0] : raw;
-    return value;
+    return query[queryKey];
 }
 
 export { getLocaleFromQuery };

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

@@ -29,12 +29,12 @@ const loadMessages = async ({ config, locale, readers, allowCacheWrite = false,
         logger.warn("No loader options have been configured in the current config.");
         return;
     }
-    const { type, namespaces, concurrency } = loader;
+    const { mode, namespaces, concurrency } = loader;
     const fallbackLocales = config.fallbackLocales[locale] || [];
     logger.info(`Loading messages for locale "${locale}".`);
     logger.trace("Starting to load messages with runtime context.", {
-        loaderType: type,
-        ...(type === "local" ? { rootDir: loader.rootDir } : {}),
+        loaderMode: mode,
+        ...(mode === "local" ? { rootDir: loader.rootDir } : {}),
         locale,
         fallbackLocales: fallbackLocales.join(", "),
         namespaces: namespaces && namespaces.length > 0 ? [...namespaces] : "*",
@@ -43,7 +43,7 @@ const loadMessages = async ({ config, locale, readers, allowCacheWrite = false,
     // Dispatch to loader implementation
     // ---------------------------------------------------------------------------
     let loadedMessages;
-    if (type === "local") {
+    if (mode === "local") {
         loadedMessages = await loadLocalMessages({
             id: config.id,
             locale,
@@ -56,7 +56,7 @@ const loadMessages = async ({ config, locale, readers, allowCacheWrite = false,
             loggerOptions: config.logger,
         });
     }
-    else if (type === "remote") {
+    else if (mode === "remote") {
         loadedMessages = await loadRemoteMessages({
             locale,
             fallbackLocales,

package/dist/next/export/next/index.js

@@ -1,3 +1,4 @@
-export { Link } from '../../src/adapters/next/navigation/link.js';
-export { useRouter } from '../../src/adapters/next/navigation/use-router.js';
-export { redirect } from '../../src/adapters/next/navigation/redirect.js';
+export { Link } from '../../src/adapters/next/link.js';
+export { useRouter } from '../../src/adapters/next/use-router.js';
+export { redirect } from '../../src/adapters/next/redirect.js';
+export { createIntorHandler } from '../../src/adapters/next/create-intor-handler.js';

package/dist/next/src/adapters/next/{proxy/intor-proxy.js → create-intor-handler.js}

@@ -1,12 +1,12 @@
 import { NextResponse } from 'next/server';
-import { INTOR_HEADERS } from '../../../core/constants/headers.js';
-import '../../../core/error/intor-error.js';
-import { normalizeQuery } from '../../../core/utils/normalizers/normalize-query.js';
+import { INTOR_HEADERS } from '../../core/constants/headers.js';
+import '../../core/error/intor-error.js';
+import { normalizeQuery } from '../../core/utils/normalizers/normalize-query.js';
 import 'logry';
 import 'p-limit';
 import 'intor-translator';
-import { resolveInbound } from '../../../routing/inbound/resolve-inbound.js';
-import { getLocaleFromAcceptLanguage } from '../../../routing/locale/get-locale-from-accept-language.js';
+import { resolveInbound } from '../../routing/inbound/resolve-inbound.js';
+import { getLocaleFromAcceptLanguage } from '../../routing/locale/get-locale-from-accept-language.js';
 
 /**
  * Resolves locale-aware routing for the current execution context.
@@ -17,21 +17,22 @@ import { getLocaleFromAcceptLanguage } from '../../../routing/locale/get-locale-
  *
  * @platform Next.js
  */
-const intorProxy = async (config, request) => {
+const createIntorHandler = async (config, request) => {
+    const { host, searchParams, pathname: rawPathname } = request.nextUrl;
     // Locale from Accept-Language header
     const acceptLanguageHeader = request.headers.get("accept-language");
     const localeFromAcceptLanguage = getLocaleFromAcceptLanguage(acceptLanguageHeader, config.supportedLocales);
     // Check whether this navigation flow has already redirected
-    const hasRedirectedForLocale = request.headers.get("x-intor-redirected") === "1";
+    const hasRedirected = request.headers.get(INTOR_HEADERS.REDIRECTED) === "1";
     // ----------------------------------------------------------
     // Resolve inbound routing decision (pure computation)
     // ----------------------------------------------------------
-    const { locale, localeSource, pathname, shouldRedirect } = await resolveInbound(config, request.nextUrl.pathname, hasRedirectedForLocale, {
-        host: request.nextUrl.host,
-        query: normalizeQuery(Object.fromEntries(request.nextUrl.searchParams.entries())),
+    const { locale, localeSource, pathname, shouldRedirect } = await resolveInbound(config, rawPathname, {
+        host,
+        query: normalizeQuery(Object.fromEntries(searchParams.entries())),
         cookie: request.cookies.get(config.cookie.name)?.value,
         detected: localeFromAcceptLanguage || config.defaultLocale,
-    });
+    }, { hasRedirected });
     // ----------------------------------------------------------
     // Prepare Next.js response (redirect or pass-through)
     // ----------------------------------------------------------
@@ -52,4 +53,4 @@ const intorProxy = async (config, request) => {
     return response;
 };
 
-export { intorProxy };
+export { createIntorHandler };

package/dist/next/src/adapters/next/{navigation/link.js → link.js}

@@ -4,13 +4,13 @@ import { formatUrl } from 'next/dist/shared/lib/router/utils/format-url';
 import NextLink from 'next/link';
 import { usePathname } from 'next/navigation';
 import 'react';
-import { executeNavigation } from '../../../client/shared/navigation/execute-navigation.js';
+import { executeNavigation } from '../../client/shared/navigation/execute-navigation.js';
 import { useIntorContext } from 'intor/react';
-import '../../../core/error/intor-error.js';
+import '../../core/error/intor-error.js';
 import 'logry';
 import 'p-limit';
 import 'intor-translator';
-import { resolveNavigation } from '../../../routing/navigation/resolve-navigation.js';
+import { resolveOutbound } from '../../routing/outbound/resolve-outbound.js';
 
 /**
  * Render a locale-aware link for the current execution context.
@@ -26,7 +26,7 @@ const Link = ({ href, locale, children, onClick, ...props }) => {
     // Normalize href into a string destination
     const rawDestination = typeof href === "string" ? href : href ? formatUrl(href) : undefined;
     // Resolve navigation result for this link
-    const navigationResult = resolveNavigation(config, currentLocale, currentPathname, { destination: rawDestination, locale });
+    const outboundResult = resolveOutbound(config, currentLocale, currentPathname, { destination: rawDestination, locale });
     // --------------------------------------------------
     // Execute navigation on user interaction
     // --------------------------------------------------
@@ -34,9 +34,9 @@ const Link = ({ href, locale, children, onClick, ...props }) => {
         onClick?.(e);
         if (e.defaultPrevented)
             return;
-        executeNavigation(navigationResult, { config, currentLocale, setLocale }, e);
+        executeNavigation(outboundResult, { config, currentLocale, setLocale }, e);
     };
-    return (jsx(NextLink, { href: navigationResult.destination, onClick: handleClick, ...props, children: children }));
+    return (jsx(NextLink, { href: outboundResult.destination, onClick: handleClick, ...props, children: children }));
 };
 
 export { Link };

package/dist/next/src/adapters/next/{navigation/redirect.js → redirect.js}

@@ -1,10 +1,10 @@
 import { redirect as redirect$1 } from 'next/navigation';
-import '../../../core/error/intor-error.js';
+import '../../core/error/intor-error.js';
 import 'logry';
 import 'p-limit';
 import 'intor-translator';
-import { resolveNavigation } from '../../../routing/navigation/resolve-navigation.js';
-import { getLocale } from '../server/get-locale.js';
+import { resolveOutbound } from '../../routing/outbound/resolve-outbound.js';
+import { getLocale } from './server/get-locale.js';
 
 /**
  * Redirect to a locale-aware destination for the current execution context.
@@ -16,7 +16,7 @@ import { getLocale } from '../server/get-locale.js';
  */
 const redirect = async (config, url, { locale, type }) => {
     const currentLocale = await getLocale(config);
-    const { destination, kind } = resolveNavigation(config, currentLocale, url, {
+    const { destination, kind } = resolveOutbound(config, currentLocale, url, {
         locale,
     });
     if (kind === "external") {

package/dist/next/src/adapters/next/server/get-translator.js

@@ -17,10 +17,6 @@ async function getTranslator(config, params) {
         plugins,
         readers,
         allowCacheWrite,
-        // NOTE:
-        // The runtime implementation is intentionally erased.
-        // Type safety is guaranteed by public type contracts.
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
     });
 }
 

package/dist/next/src/adapters/next/{navigation/use-router.js → use-router.js}

@@ -1,11 +1,11 @@
 import { usePathname, useRouter as useRouter$1 } from 'next/navigation';
-import { executeNavigation } from '../../../client/shared/navigation/execute-navigation.js';
+import { executeNavigation } from '../../client/shared/navigation/execute-navigation.js';
 import { useIntorContext } from 'intor/react';
-import '../../../core/error/intor-error.js';
+import '../../core/error/intor-error.js';
 import 'logry';
 import 'p-limit';
 import 'intor-translator';
-import { resolveNavigation } from '../../../routing/navigation/resolve-navigation.js';
+import { resolveOutbound } from '../../routing/outbound/resolve-outbound.js';
 
 /**
  * Locale-aware router hook for the current execution context.
@@ -23,23 +23,23 @@ const useRouter = () => {
     // push
     // --------------------------------------------------
     const push = (href, options) => {
-        const navigationResult = resolveNavigation(config, currentLocale, currentPathname, { destination: href, locale: options?.locale });
-        executeNavigation(navigationResult, { config, currentLocale, setLocale });
-        nextRouterPush(navigationResult.destination, options);
+        const outboundResult = resolveOutbound(config, currentLocale, currentPathname, { destination: href, locale: options?.locale });
+        executeNavigation(outboundResult, { config, currentLocale, setLocale });
+        nextRouterPush(outboundResult.destination, options);
     };
     // --------------------------------------------------
     // replace
     // --------------------------------------------------
     const replace = (href, options) => {
-        const navigationResult = resolveNavigation(config, currentLocale, currentPathname, { destination: href, locale: options?.locale });
-        executeNavigation(navigationResult, { config, currentLocale, setLocale });
-        nextRouterReplace(navigationResult.destination, options);
+        const outboundResult = resolveOutbound(config, currentLocale, currentPathname, { destination: href, locale: options?.locale });
+        executeNavigation(outboundResult, { config, currentLocale, setLocale });
+        nextRouterReplace(outboundResult.destination, options);
     };
     // --------------------------------------------------
     // prefetch
     // --------------------------------------------------
     const prefetch = (href, options) => {
-        const { kind, destination } = resolveNavigation(config, currentLocale, currentPathname, { destination: href, locale: options?.locale });
+        const { kind, destination } = resolveOutbound(config, currentLocale, currentPathname, { destination: href, locale: options?.locale });
         if (kind !== "client")
             return; // Prefetch only makes sense for client-side navigation
         nextRouterPrefetch(destination, options);

package/dist/next/src/client/shared/navigation/execute-navigation.js

@@ -6,17 +6,17 @@ import { shouldSyncLocale } from '../../../policies/should-sync-locale.js';
 import { setLocaleCookie } from '../utils/locale/set-locale-cookie.js';
 
 /**
- * Executes a resolved navigation result.
+ * Executes a resolved outbound routing result.
  *
- * Applies all imperative side effects required to complete navigation,
- * including locale synchronization, cookie persistence, and full reloads.
+ * Applies all imperative side effects required to realize the outbound decision,
+ * including locale synchronization, cookie persistence, and full page reloads.
  *
- * This function must be called after `resolveNavigation`.
+ * This function must be called after `resolveOutbound`.
  */
-function executeNavigation(navigationResult, context, e) {
+function executeNavigation(outboundResult, context, e) {
     const { config, currentLocale, setLocale } = context;
     const { cookie } = config;
-    const { destination, kind, locale } = navigationResult;
+    const { destination, kind, locale } = outboundResult;
     // ------------------------------------------------------
     // External navigation: let browser handle it
     // ------------------------------------------------------

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

@@ -18,16 +18,20 @@
  *   for the given runtime.
  */
 const resolveLoaderOptions = (config, runtime) => {
-    // --- runtime: client ---
+    // ------------------------------------------------
+    // runtime: client
+    // ------------------------------------------------
     if (runtime === "client") {
         const client = config.client?.loader;
         if (client) {
             // Client loader is always remote by design
-            return { type: "remote", ...client };
+            return { mode: "remote", ...client };
         }
         return config.server?.loader ?? config.loader;
     }
-    // --- runtime: server ---
+    // ------------------------------------------------
+    // runtime: server
+    // ------------------------------------------------
     return config.server?.loader ?? config.loader;
 };
 

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

@@ -9,7 +9,7 @@ import 'intor-translator';
  */
 function shouldFullReload(config) {
     const loader = resolveLoaderOptions(config, "client");
-    return (loader?.type === "local" || config.routing.outbound.forceFullReload === true);
+    return (loader?.mode === "local" || config.routing.outbound.forceFullReload === true);
 }
 
 export { shouldFullReload };

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

@@ -13,7 +13,8 @@ import { resolvePathname } from './resolve-pathname/resolve-pathname.js';
  *
  * No side effects. No navigation.
  */
-async function resolveInbound(config, rawPathname, hasRedirected, localeInputs) {
+async function resolveInbound(config, rawPathname, localeInputs, options) {
+    const { queryKey } = config.routing.inbound;
     const { host, query, cookie, detected } = localeInputs;
     // ------------------------------------------------------
     // Resolve locale from inbound inputs
@@ -22,9 +23,7 @@ async function resolveInbound(config, rawPathname, hasRedirected, localeInputs)
     const { locale, localeSource } = resolveLocale(config, {
         path: { locale: pathLocale },
         host: { locale: getLocaleFromHost(host) },
-        query: {
-            locale: getLocaleFromQuery(query, config.routing.inbound.queryKey),
-        },
+        query: { locale: getLocaleFromQuery(query, queryKey) },
         cookie: { locale: cookie },
         detected: { locale: detected },
     });
@@ -35,7 +34,7 @@ async function resolveInbound(config, rawPathname, hasRedirected, localeInputs)
         locale,
         hasPathLocale: !!pathLocale,
         hasPersisted: !!cookie,
-        hasRedirected,
+        hasRedirected: !!options?.hasRedirected,
     });
     return {
         locale,

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

@@ -7,9 +7,9 @@ import 'intor-translator';
 /**
  * Resolve the active locale from inbound routing configuration.
  *
- * 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.
+ * 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.
  */
 function resolveLocale(config, context) {
     const { localeSources } = config.routing.inbound;
@@ -24,9 +24,10 @@ function resolveLocale(config, context) {
         };
     }
     // Fallback: detected is always available
+    const fallback = normalizeLocale(context.detected.locale, config.supportedLocales) ||
+        config.defaultLocale;
     return {
-        locale: normalizeLocale(context.detected.locale, config.supportedLocales) ||
-            config.defaultLocale,
+        locale: fallback,
         localeSource: "detected",
     };
 }

package/dist/next/src/routing/locale/get-locale-from-query.js

@@ -11,19 +11,11 @@
  *
  * getLocaleFromQuery({}, "locale")
  * // => undefined
- *
- * getLocaleFromQuery({ locale: ["zh-TW"] }, "locale")
- * // => "zh-TW"
- * ```
  */
 function getLocaleFromQuery(query, queryKey) {
     if (!query)
         return;
-    const raw = query[queryKey];
-    if (!raw)
-        return;
-    const value = Array.isArray(raw) ? raw[0] : raw;
-    return value;
+    return query[queryKey];
 }
 
 export { getLocaleFromQuery };

package/dist/next/src/routing/{navigation → outbound}/decide-strategy.js

@@ -2,16 +2,13 @@ import { shouldFullReload } from '../../policies/shoud-full-reload.js';
 
 /**
  * Decide how a resolved navigation target should be executed.
- *
- * This function determines whether navigation should be handled
- * by the browser, performed client-side, or forced to reload.
  */
 function decideStrategy(config, target) {
     // External destinations are always handled by the browser
     if (target.isExternal) {
-        return { kind: "external" };
+        return "external";
     }
-    return shouldFullReload(config) ? { kind: "reload" } : { kind: "client" };
+    return shouldFullReload(config) ? "reload" : "client";
 }
 
 export { decideStrategy };

package/dist/{svelte-kit/src/routing/navigation/derive-target.js → next/src/routing/outbound/determine-target.js}

@@ -5,12 +5,9 @@ import { deriveQueryDestination } from './utils/derive-query-destination.js';
 import { isExternalDestination } from './utils/is-external-destination.js';
 
 /**
- * Derives a navigation target for a single navigation attempt.
- *
- * This function computes the final destination URL and execution flags
- * based on the current routing configuration and locale context.
+ * Determines the outbound routing target.
  */
-function deriveTarget(config, currentLocale, currentPathname, intent) {
+function determineTarget(config, currentLocale, currentPathname, intent) {
     const { supportedLocales, routing } = config;
     // ----------------------------------------------------------------
     // Resolve effective locale
@@ -55,4 +52,4 @@ function deriveTarget(config, currentLocale, currentPathname, intent) {
     };
 }
 
-export { deriveTarget };
+export { determineTarget };