@intlayer/next-intl 9.0.0-canary.3 → 9.0.0-canary.4

package/dist/cjs/client/NextIntlClientProvider.cjs

@@ -6,6 +6,8 @@ let _intlayer_config_built = require("@intlayer/config/built");
 let next_intlayer = require("next-intlayer");
 let _intlayer_config_colors = require("@intlayer/config/colors");
 let _intlayer_config_logger = require("@intlayer/config/logger");
+let _intlayer_core_localization = require("@intlayer/core/localization");
+let next_navigation = require("next/navigation");
 let react_jsx_runtime = require("react/jsx-runtime");
 
 //#region src/client/NextIntlClientProvider.tsx
@@ -16,11 +18,13 @@ let react_jsx_runtime = require("react/jsx-runtime");
 */
 const NextIntlClientProvider = ({ locale, children, messages: _messages, timeZone: _timeZone, now: _now, ...rest }) => {
 	if (process.env.NODE_ENV === "development" && typeof _messages !== "undefined") (0, _intlayer_config_logger.getAppLogger)({ log: _intlayer_config_built.log })(`${(0, _intlayer_config_logger.colorize)("NextIntlClientProvider", _intlayer_config_colors.CYAN)} do not pass the messages prop with intlayer. Messages are loaded automatically under the hood for bundle optimization reason`);
+	const pathname = (0, next_navigation.usePathname)();
+	const resolvedLocale = locale ?? (0, _intlayer_core_localization.getLocaleFromPath)(pathname);
 	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(next_intlayer.IntlayerClientProvider, {
-		locale,
+		locale: resolvedLocale,
 		...rest,
 		children
-	}, String(locale));
+	}, String(resolvedLocale));
 };
 
 //#endregion

package/dist/cjs/client/NextIntlClientProvider.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"NextIntlClientProvider.cjs","names":["CYAN","IntlayerClientProvider"],"sources":["../../../src/client/NextIntlClientProvider.tsx"],"sourcesContent":["'use client';\n\nimport { log } from '@intlayer/config/built';\nimport { CYAN } from '@intlayer/config/colors';\nimport { colorize, getAppLogger } from '@intlayer/config/logger';\nimport type { LocalesValues } from '@intlayer/types/module_augmentation';\nimport type { NextIntlClientProvider as _NextIntlClientProvider } from 'next-intl';\nimport { IntlayerClientProvider } from 'next-intlayer';\nimport type { ComponentProps } from 'react';\n\n/**\n * Drop-in for next-intl's `NextIntlClientProvider`.\n * `messages`, `timeZone`, and `now` are accepted for API compatibility\n * but have no effect — Intlayer uses its own compiled dictionaries.\n */\nexport const NextIntlClientProvider: typeof _NextIntlClientProvider = ({\n  locale,\n  children,\n  messages: _messages,\n  timeZone: _timeZone,\n  now: _now,\n  ...rest\n}) => {\n  if (\n    process.env.NODE_ENV === 'development' &&\n    typeof _messages !== 'undefined'\n  ) {\n    const appLogger = getAppLogger({ log });\n    appLogger(\n      `${colorize('NextIntlClientProvider', CYAN)} do not pass the messages prop with intlayer. Messages are loaded automatically under the hood for bundle optimization reason`\n    );\n  }\n\n  // `key={locale}` remounts the provider when the locale changes via navigation\n  // (next-intl switches locale by routing to a locale-prefixed path). This\n  // re-seeds the client locale context from the new `locale` prop so client\n  // components re-render in the new language instead of keeping the previous one.\n  return (\n    <IntlayerClientProvider key={String(locale)} locale={locale} {...rest}>\n      {children}\n    </IntlayerClientProvider>\n  );\n};\n\n/**\n *\n */\nexport type NextIntlClientProviderProps = Omit<\n  ComponentProps<typeof _NextIntlClientProvider>,\n  'messages'\n> & {\n  /**\n   * @deprecated\n   * has no use case with intlayer. Messages are loaded automatically under the hood for bundle optimization reason\n   */\n  messages?: never;\n  /**\n   * locale\n   */\n  locale: LocalesValues;\n};\n"],"mappings":";;;;;;;;;;;;;;;;AAeA,MAAa,0BAA0D,EACrE,QACA,UACA,UAAU,WACV,UAAU,WACV,KAAK,MACL,GAAG,WACC;AACJ,KACE,QAAQ,IAAI,aAAa,iBACzB,OAAO,cAAc,YAGrB,2CAD+B,EAAE,iCAAK,CAC7B,CACP,yCAAY,0BAA0BA,6BAAK,CAAC,+HAC7C;AAOH,QACE,2CAACC,sCAAD;EAAqD;EAAQ,GAAI;EAC9D;EACsB,EAFI,OAAO,OAAO,CAElB"}
+{"version":3,"file":"NextIntlClientProvider.cjs","names":["CYAN","IntlayerClientProvider"],"sources":["../../../src/client/NextIntlClientProvider.tsx"],"sourcesContent":["'use client';\n\nimport { log } from '@intlayer/config/built';\nimport { CYAN } from '@intlayer/config/colors';\nimport { colorize, getAppLogger } from '@intlayer/config/logger';\nimport { getLocaleFromPath } from '@intlayer/core/localization';\nimport type { LocalesValues } from '@intlayer/types/module_augmentation';\nimport { usePathname } from 'next/navigation';\nimport type { NextIntlClientProvider as _NextIntlClientProvider } from 'next-intl';\nimport { IntlayerClientProvider } from 'next-intlayer';\nimport type { ComponentProps } from 'react';\n\n/**\n * Drop-in for next-intl's `NextIntlClientProvider`.\n * `messages`, `timeZone`, and `now` are accepted for API compatibility\n * but have no effect — Intlayer uses its own compiled dictionaries.\n */\nexport const NextIntlClientProvider: typeof _NextIntlClientProvider = ({\n  locale,\n  children,\n  messages: _messages,\n  timeZone: _timeZone,\n  now: _now,\n  ...rest\n}) => {\n  if (\n    process.env.NODE_ENV === 'development' &&\n    typeof _messages !== 'undefined'\n  ) {\n    const appLogger = getAppLogger({ log });\n    appLogger(\n      `${colorize('NextIntlClientProvider', CYAN)} do not pass the messages prop with intlayer. Messages are loaded automatically under the hood for bundle optimization reason`\n    );\n  }\n\n  // next-intl drives the locale from the request: apps render\n  // `<NextIntlClientProvider>` without a `locale` prop and the server resolves it\n  // from the `[locale]` route segment. As a client component we cannot read the\n  // server request here, so when no explicit `locale` is given we derive it from\n  // the URL (the same `[locale]` segment) using Intlayer's routing config. This\n  // keeps `useLocale`, `Link` and the locale switcher in sync with the URL\n  // instead of falling back to the stored cookie / default locale.\n  const pathname = usePathname();\n  const resolvedLocale = locale ?? getLocaleFromPath(pathname);\n\n  // `key={resolvedLocale}` remounts the provider when the locale changes via\n  // navigation (next-intl switches locale by routing to a locale-prefixed path).\n  // This re-seeds the client locale context so client components re-render in\n  // the new language instead of keeping the previous one.\n  return (\n    <IntlayerClientProvider\n      key={String(resolvedLocale)}\n      locale={resolvedLocale}\n      {...rest}\n    >\n      {children}\n    </IntlayerClientProvider>\n  );\n};\n\n/**\n *\n */\nexport type NextIntlClientProviderProps = Omit<\n  ComponentProps<typeof _NextIntlClientProvider>,\n  'messages'\n> & {\n  /**\n   * @deprecated\n   * has no use case with intlayer. Messages are loaded automatically under the hood for bundle optimization reason\n   */\n  messages?: never;\n  /**\n   * locale\n   */\n  locale: LocalesValues;\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;AAiBA,MAAa,0BAA0D,EACrE,QACA,UACA,UAAU,WACV,UAAU,WACV,KAAK,MACL,GAAG,WACC;AACJ,KACE,QAAQ,IAAI,aAAa,iBACzB,OAAO,cAAc,YAGrB,2CAD+B,EAAE,iCAAK,CAC7B,CACP,yCAAY,0BAA0BA,6BAAK,CAAC,+HAC7C;CAUH,MAAM,6CAAwB;CAC9B,MAAM,iBAAiB,6DAA4B,SAAS;AAM5D,QACE,2CAACC,sCAAD;EAEE,QAAQ;EACR,GAAI;EAEH;EACsB,EALlB,OAAO,eAAe,CAKJ"}

package/dist/cjs/navigation/Link.cjs

@@ -4,10 +4,10 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 const require_runtime = require('../_virtual/_rolldown/runtime.cjs');
 const require_navigation_localizeHref = require('./localizeHref.cjs');
 let next_intlayer = require("next-intlayer");
+let react = require("react");
 let react_jsx_runtime = require("react/jsx-runtime");
 let next_link = require("next/link");
 next_link = require_runtime.__toESM(next_link);
-let react = require("react");
 
 //#region src/navigation/Link.tsx
 /**

package/dist/cjs/server/getLocale.cjs

@@ -1,12 +1,26 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 const require_runtime = require('../_virtual/_rolldown/runtime.cjs');
+const require_server_requestLocaleCache = require('./requestLocaleCache.cjs');
 let next_intlayer_server = require("next-intlayer/server");
 
 //#region src/server/getLocale.ts
 /**
 * Drop-in for next-intl's `getLocale()` server function.
+*
+* Resolution order mirrors next-intl's per-request model:
+*
+* 1. The locale forwarded through `setRequestLocale(locale)` (the `[locale]`
+*    route segment) — the source of truth for URL-driven routing. This is what
+*    keeps server-rendered content and the locale switcher in sync with the URL
+*    instead of a stale cookie.
+* 2. Otherwise Intlayer's own resolution (cookie / header / Accept-Language),
+*    for apps that drive the locale from storage rather than the route.
 */
-const getLocale = async () => await (0, next_intlayer_server.getLocale)();
+const getLocale = async () => {
+	const requestLocale = require_server_requestLocaleCache.getCachedRequestLocale();
+	if (requestLocale) return requestLocale;
+	return await (0, next_intlayer_server.getLocale)();
+};
 
 //#endregion
 exports.getLocale = getLocale;

package/dist/cjs/server/getLocale.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"getLocale.cjs","names":[],"sources":["../../../src/server/getLocale.ts"],"sourcesContent":["import type { getLocale as _getLocale } from 'next-intl/server';\nimport { getLocale as getLocaleIntlayer } from 'next-intlayer/server';\n\n/**\n * Drop-in for next-intl's `getLocale()` server function.\n */\nexport const getLocale: typeof _getLocale = async (): Promise<string> =>\n  (await getLocaleIntlayer()) as string;\n"],"mappings":";;;;;;;;AAMA,MAAa,YAA+B,YACzC,2CAAyB"}
+{"version":3,"file":"getLocale.cjs","names":["getCachedRequestLocale"],"sources":["../../../src/server/getLocale.ts"],"sourcesContent":["import type { getLocale as _getLocale } from 'next-intl/server';\nimport { getLocale as getLocaleIntlayer } from 'next-intlayer/server';\nimport { getCachedRequestLocale } from './requestLocaleCache';\n\n/**\n * Drop-in for next-intl's `getLocale()` server function.\n *\n * Resolution order mirrors next-intl's per-request model:\n *\n * 1. The locale forwarded through `setRequestLocale(locale)` (the `[locale]`\n *    route segment) — the source of truth for URL-driven routing. This is what\n *    keeps server-rendered content and the locale switcher in sync with the URL\n *    instead of a stale cookie.\n * 2. Otherwise Intlayer's own resolution (cookie / header / Accept-Language),\n *    for apps that drive the locale from storage rather than the route.\n */\nexport const getLocale: typeof _getLocale = async (): Promise<string> => {\n  const requestLocale = getCachedRequestLocale();\n  if (requestLocale) return requestLocale as string;\n\n  return (await getLocaleIntlayer()) as string;\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;AAgBA,MAAa,YAA+B,YAA6B;CACvE,MAAM,gBAAgBA,0DAAwB;AAC9C,KAAI,cAAe,QAAO;AAE1B,QAAQ,2CAAyB"}

package/dist/cjs/server/requestLocaleCache.cjs

@@ -0,0 +1,36 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_runtime = require('../_virtual/_rolldown/runtime.cjs');
+let react = require("react");
+
+//#region src/server/requestLocaleCache.ts
+/**
+* Request-scoped holder for the locale provided through {@link setRequestLocale}.
+*
+* next-intl resolves the active locale per request from the `[locale]` route
+* segment, which the app forwards via `setRequestLocale(locale)`. React's
+* `cache()` gives a per-request singleton (the same trick next-intl uses in its
+* own `RequestLocaleCache`), so the value set in the layout/page is readable by
+* the other server APIs (`getLocale`, `getTranslations`, …) during the same
+* render.
+*
+* @see https://github.com/vercel/next.js/discussions/58862
+*/
+const getRequestLocaleHolder = (0, react.cache)(() => ({ locale: void 0 }));
+/**
+* Read the locale stored for the current request, or `undefined` when
+* `setRequestLocale` has not been called.
+*/
+const getCachedRequestLocale = () => getRequestLocaleHolder().locale;
+/**
+* Store the locale for the current request. Called by `setRequestLocale`.
+*
+* @param locale - The locale resolved from the `[locale]` route segment.
+*/
+const setCachedRequestLocale = (locale) => {
+	getRequestLocaleHolder().locale = locale;
+};
+
+//#endregion
+exports.getCachedRequestLocale = getCachedRequestLocale;
+exports.setCachedRequestLocale = setCachedRequestLocale;
+//# sourceMappingURL=requestLocaleCache.cjs.map

package/dist/cjs/server/requestLocaleCache.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"requestLocaleCache.cjs","names":[],"sources":["../../../src/server/requestLocaleCache.ts"],"sourcesContent":["import type { LocalesValues } from '@intlayer/types/module_augmentation';\nimport { cache } from 'react';\n\n/**\n * Request-scoped holder for the locale provided through {@link setRequestLocale}.\n *\n * next-intl resolves the active locale per request from the `[locale]` route\n * segment, which the app forwards via `setRequestLocale(locale)`. React's\n * `cache()` gives a per-request singleton (the same trick next-intl uses in its\n * own `RequestLocaleCache`), so the value set in the layout/page is readable by\n * the other server APIs (`getLocale`, `getTranslations`, …) during the same\n * render.\n *\n * @see https://github.com/vercel/next.js/discussions/58862\n */\nconst getRequestLocaleHolder = cache((): { locale?: LocalesValues } => ({\n  locale: undefined,\n}));\n\n/**\n * Read the locale stored for the current request, or `undefined` when\n * `setRequestLocale` has not been called.\n */\nexport const getCachedRequestLocale = (): LocalesValues | undefined =>\n  getRequestLocaleHolder().locale;\n\n/**\n * Store the locale for the current request. Called by `setRequestLocale`.\n *\n * @param locale - The locale resolved from the `[locale]` route segment.\n */\nexport const setCachedRequestLocale = (locale: LocalesValues): void => {\n  getRequestLocaleHolder().locale = locale;\n};\n"],"mappings":";;;;;;;;;;;;;;;;;AAeA,MAAM,iDAAkE,EACtE,QAAQ,QACT,EAAE;;;;;AAMH,MAAa,+BACX,wBAAwB,CAAC;;;;;;AAO3B,MAAa,0BAA0B,WAAgC;AACrE,yBAAwB,CAAC,SAAS"}

package/dist/cjs/server/setRequestLocale.cjs

@@ -1,28 +1,31 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
-const require_runtime = require('../_virtual/_rolldown/runtime.cjs');
-let _intlayer_config_built = require("@intlayer/config/built");
-let _intlayer_config_colors = require("@intlayer/config/colors");
-let _intlayer_config_logger = require("@intlayer/config/logger");
+const require_server_requestLocaleCache = require('./requestLocaleCache.cjs');
 
 //#region src/server/setRequestLocale.ts
 /**
 * Drop-in for next-intl's `setRequestLocale`.
 *
-* In next-intl this stores the locale in a request-scoped cache to opt into
-* static rendering. Intlayer resolves the active locale from the configured
-* `routing.storage` (cookie / header) or the localized route segment, so there
-* is nothing to set here — this is a no-op kept for API compatibility.
+* In next-intl this stores the locale (typically the `[locale]` route segment)
+* in a request-scoped cache so the rest of the request can render in that
+* locale and opt into static rendering. The compat keeps the same contract:
+* the locale is stored per-request and read back by `getLocale()` (and, through
+* it, `getTranslations` / `getDictionary` / metadata). This is what makes the
+* per-request locale — and therefore the locale switcher — work without relying
+* on a cookie.
 *
-* @deprecated setRequestLocale has no use case with intlayer. The locale is
-* resolved automatically from routing / storage.
+* @param locale - The locale resolved from the `[locale]` route segment.
 *
 * @example
 * ```ts
-* setRequestLocale(locale); // safe to keep, but has no effect
+* export default async function LocaleLayout({ params }) {
+*   const { locale } = await params;
+*   setRequestLocale(locale);
+*   // …
+* }
 * ```
 */
-const setRequestLocale = (_locale) => {
-	if (process.env.NODE_ENV === "development") (0, _intlayer_config_logger.getAppLogger)({ log: _intlayer_config_built.log })(`${(0, _intlayer_config_logger.colorize)("setRequestLocale", _intlayer_config_colors.CYAN)} has no use case with intlayer. The locale is resolved automatically from routing and storage`);
+const setRequestLocale = (locale) => {
+	require_server_requestLocaleCache.setCachedRequestLocale(locale);
 };
 
 //#endregion

package/dist/cjs/server/setRequestLocale.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"setRequestLocale.cjs","names":["CYAN"],"sources":["../../../src/server/setRequestLocale.ts"],"sourcesContent":["import { log } from '@intlayer/config/built';\nimport { CYAN } from '@intlayer/config/colors';\nimport { colorize, getAppLogger } from '@intlayer/config/logger';\nimport type { setRequestLocale as _setRequestLocale } from 'next-intl/server';\n\n/**\n * Drop-in for next-intl's `setRequestLocale`.\n *\n * In next-intl this stores the locale in a request-scoped cache to opt into\n * static rendering. Intlayer resolves the active locale from the configured\n * `routing.storage` (cookie / header) or the localized route segment, so there\n * is nothing to set here — this is a no-op kept for API compatibility.\n *\n * @deprecated setRequestLocale has no use case with intlayer. The locale is\n * resolved automatically from routing / storage.\n *\n * @example\n * ```ts\n * setRequestLocale(locale); // safe to keep, but has no effect\n * ```\n */\nexport const setRequestLocale: typeof _setRequestLocale = (_locale): void => {\n  if (process.env.NODE_ENV === 'development') {\n    const appLogger = getAppLogger({ log });\n    appLogger(\n      `${colorize('setRequestLocale', CYAN)} has no use case with intlayer. The locale is resolved automatically from routing and storage`\n    );\n  }\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;AAqBA,MAAa,oBAA8C,YAAkB;AAC3E,KAAI,QAAQ,IAAI,aAAa,cAE3B,2CAD+B,EAAE,iCAAK,CAC7B,CACP,yCAAY,oBAAoBA,6BAAK,CAAC,+FACvC"}
+{"version":3,"file":"setRequestLocale.cjs","names":[],"sources":["../../../src/server/setRequestLocale.ts"],"sourcesContent":["import type { LocalesValues } from '@intlayer/types/module_augmentation';\nimport type { setRequestLocale as _setRequestLocale } from 'next-intl/server';\nimport { setCachedRequestLocale } from './requestLocaleCache';\n\n/**\n * Drop-in for next-intl's `setRequestLocale`.\n *\n * In next-intl this stores the locale (typically the `[locale]` route segment)\n * in a request-scoped cache so the rest of the request can render in that\n * locale and opt into static rendering. The compat keeps the same contract:\n * the locale is stored per-request and read back by `getLocale()` (and, through\n * it, `getTranslations` / `getDictionary` / metadata). This is what makes the\n * per-request locale — and therefore the locale switcher — work without relying\n * on a cookie.\n *\n * @param locale - The locale resolved from the `[locale]` route segment.\n *\n * @example\n * ```ts\n * export default async function LocaleLayout({ params }) {\n *   const { locale } = await params;\n *   setRequestLocale(locale);\n *   // …\n * }\n * ```\n */\nexport const setRequestLocale: typeof _setRequestLocale = (locale): void => {\n  setCachedRequestLocale(locale as LocalesValues);\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;AA0BA,MAAa,oBAA8C,WAAiB;AAC1E,0DAAuB,OAAwB"}

package/dist/esm/client/NextIntlClientProvider.mjs

@@ -1,9 +1,11 @@
 'use client';
 
-import { log } from "@intlayer/config/built";
+import { log, routing } from "@intlayer/config/built";
 import { IntlayerClientProvider } from "next-intlayer";
 import { CYAN } from "@intlayer/config/colors";
 import { colorize, getAppLogger } from "@intlayer/config/logger";
+import { getLocaleFromPath } from "@intlayer/core/localization";
+import { usePathname } from "next/navigation";
 import { jsx } from "react/jsx-runtime";
 
 //#region src/client/NextIntlClientProvider.tsx
@@ -14,11 +16,14 @@ import { jsx } from "react/jsx-runtime";
 */
 const NextIntlClientProvider = ({ locale, children, messages: _messages, timeZone: _timeZone, now: _now, ...rest }) => {
 	if (typeof _messages !== "undefined") getAppLogger({ log })(`${colorize("NextIntlClientProvider", CYAN)} do not pass the messages prop with intlayer. Messages are loaded automatically under the hood for bundle optimization reason`);
+	const pathname = usePathname();
+	const mode = routing?.mode ?? "prefix-no-default";
+	const resolvedLocale = locale ?? (mode === "prefix-all" || mode === "prefix-no-default" ? getLocaleFromPath(pathname) : void 0);
 	return /* @__PURE__ */ jsx(IntlayerClientProvider, {
-		locale,
+		locale: resolvedLocale,
 		...rest,
 		children
-	}, String(locale));
+	}, String(resolvedLocale));
 };
 
 //#endregion

package/dist/esm/client/NextIntlClientProvider.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"NextIntlClientProvider.mjs","names":[],"sources":["../../../src/client/NextIntlClientProvider.tsx"],"sourcesContent":["'use client';\n\nimport { log } from '@intlayer/config/built';\nimport { CYAN } from '@intlayer/config/colors';\nimport { colorize, getAppLogger } from '@intlayer/config/logger';\nimport type { LocalesValues } from '@intlayer/types/module_augmentation';\nimport type { NextIntlClientProvider as _NextIntlClientProvider } from 'next-intl';\nimport { IntlayerClientProvider } from 'next-intlayer';\nimport type { ComponentProps } from 'react';\n\n/**\n * Drop-in for next-intl's `NextIntlClientProvider`.\n * `messages`, `timeZone`, and `now` are accepted for API compatibility\n * but have no effect — Intlayer uses its own compiled dictionaries.\n */\nexport const NextIntlClientProvider: typeof _NextIntlClientProvider = ({\n  locale,\n  children,\n  messages: _messages,\n  timeZone: _timeZone,\n  now: _now,\n  ...rest\n}) => {\n  if (\n    process.env.NODE_ENV === 'development' &&\n    typeof _messages !== 'undefined'\n  ) {\n    const appLogger = getAppLogger({ log });\n    appLogger(\n      `${colorize('NextIntlClientProvider', CYAN)} do not pass the messages prop with intlayer. Messages are loaded automatically under the hood for bundle optimization reason`\n    );\n  }\n\n  // `key={locale}` remounts the provider when the locale changes via navigation\n  // (next-intl switches locale by routing to a locale-prefixed path). This\n  // re-seeds the client locale context from the new `locale` prop so client\n  // components re-render in the new language instead of keeping the previous one.\n  return (\n    <IntlayerClientProvider key={String(locale)} locale={locale} {...rest}>\n      {children}\n    </IntlayerClientProvider>\n  );\n};\n\n/**\n *\n */\nexport type NextIntlClientProviderProps = Omit<\n  ComponentProps<typeof _NextIntlClientProvider>,\n  'messages'\n> & {\n  /**\n   * @deprecated\n   * has no use case with intlayer. Messages are loaded automatically under the hood for bundle optimization reason\n   */\n  messages?: never;\n  /**\n   * locale\n   */\n  locale: LocalesValues;\n};\n"],"mappings":";;;;;;;;;;;;;;AAeA,MAAa,0BAA0D,EACrE,QACA,UACA,UAAU,WACV,UAAU,WACV,KAAK,MACL,GAAG,WACC;AACJ,KAEE,OAAO,cAAc,YAGrB,CADkB,aAAa,EAAE,KAAK,CAC7B,CACP,GAAG,SAAS,0BAA0B,KAAK,CAAC,+HAC7C;AAOH,QACE,oBAAC,wBAAD;EAAqD;EAAQ,GAAI;EAC9D;EACsB,EAFI,OAAO,OAAO,CAElB"}
+{"version":3,"file":"NextIntlClientProvider.mjs","names":[],"sources":["../../../src/client/NextIntlClientProvider.tsx"],"sourcesContent":["'use client';\n\nimport { log, routing } from '@intlayer/config/built';\nimport { CYAN } from '@intlayer/config/colors';\nimport { colorize, getAppLogger } from '@intlayer/config/logger';\nimport { getLocaleFromPath } from '@intlayer/core/localization';\nimport type { LocalesValues } from '@intlayer/types/module_augmentation';\nimport { usePathname } from 'next/navigation';\nimport type { NextIntlClientProvider as _NextIntlClientProvider } from 'next-intl';\nimport { IntlayerClientProvider } from 'next-intlayer';\nimport type { ComponentProps } from 'react';\n\n/**\n * Drop-in for next-intl's `NextIntlClientProvider`.\n * `messages`, `timeZone`, and `now` are accepted for API compatibility\n * but have no effect — Intlayer uses its own compiled dictionaries.\n */\nexport const NextIntlClientProvider: typeof _NextIntlClientProvider = ({\n  locale,\n  children,\n  messages: _messages,\n  timeZone: _timeZone,\n  now: _now,\n  ...rest\n}) => {\n  if (\n    process.env.NODE_ENV === 'development' &&\n    typeof _messages !== 'undefined'\n  ) {\n    const appLogger = getAppLogger({ log });\n    appLogger(\n      `${colorize('NextIntlClientProvider', CYAN)} do not pass the messages prop with intlayer. Messages are loaded automatically under the hood for bundle optimization reason`\n    );\n  }\n\n  // next-intl drives the locale from the request: apps render\n  // `<NextIntlClientProvider>` without a `locale` prop and the server resolves it\n  // from the `[locale]` route segment. As a client component we cannot read the\n  // server request here, so when no explicit `locale` is given we derive it from\n  // the URL (the same `[locale]` segment) using Intlayer's routing config. This\n  // keeps `useLocale`, `Link` and the locale switcher in sync with the URL\n  // instead of falling back to the stored cookie / default locale.\n  //\n  // Only prefix-based routing carries the locale in the path. For `no-prefix` /\n  // `search-params` the path has no locale segment, so we leave `locale`\n  // undefined and let the provider resolve it from storage (cookie) — deriving\n  // from the path there would wrongly clobber the cookie with the default locale.\n  const pathname = usePathname();\n  const mode = routing?.mode ?? 'prefix-no-default';\n  const isPrefixMode = mode === 'prefix-all' || mode === 'prefix-no-default';\n  const resolvedLocale =\n    locale ?? (isPrefixMode ? getLocaleFromPath(pathname) : undefined);\n\n  // `key={resolvedLocale}` remounts the provider when the locale changes via\n  // navigation (next-intl switches locale by routing to a locale-prefixed path).\n  // This re-seeds the client locale context so client components re-render in\n  // the new language instead of keeping the previous one.\n  return (\n    <IntlayerClientProvider\n      key={String(resolvedLocale)}\n      locale={resolvedLocale}\n      {...rest}\n    >\n      {children}\n    </IntlayerClientProvider>\n  );\n};\n\n/**\n *\n */\nexport type NextIntlClientProviderProps = Omit<\n  ComponentProps<typeof _NextIntlClientProvider>,\n  'messages'\n> & {\n  /**\n   * @deprecated\n   * has no use case with intlayer. Messages are loaded automatically under the hood for bundle optimization reason\n   */\n  messages?: never;\n  /**\n   * locale\n   */\n  locale: LocalesValues;\n};\n"],"mappings":";;;;;;;;;;;;;;;;AAiBA,MAAa,0BAA0D,EACrE,QACA,UACA,UAAU,WACV,UAAU,WACV,KAAK,MACL,GAAG,WACC;AACJ,KAEE,OAAO,cAAc,YAGrB,CADkB,aAAa,EAAE,KAAK,CAC7B,CACP,GAAG,SAAS,0BAA0B,KAAK,CAAC,+HAC7C;CAeH,MAAM,WAAW,aAAa;CAC9B,MAAM,OAAO,SAAS,QAAQ;CAE9B,MAAM,iBACJ,WAFmB,SAAS,gBAAgB,SAAS,sBAE3B,kBAAkB,SAAS,GAAG;AAM1D,QACE,oBAAC,wBAAD;EAEE,QAAQ;EACR,GAAI;EAEH;EACsB,EALlB,OAAO,eAAe,CAKJ"}

package/dist/esm/navigation/Link.mjs

@@ -2,9 +2,9 @@
 
 import { localizeHref } from "./localizeHref.mjs";
 import { useLocale } from "next-intlayer";
+import { forwardRef } from "react";
 import { jsx } from "react/jsx-runtime";
 import NextLink from "next/link";
-import { forwardRef } from "react";
 
 //#region src/navigation/Link.tsx
 /**

package/dist/esm/server/getLocale.mjs

@@ -1,10 +1,24 @@
+import { getCachedRequestLocale } from "./requestLocaleCache.mjs";
 import { getLocale as getLocale$1 } from "next-intlayer/server";
 
 //#region src/server/getLocale.ts
 /**
 * Drop-in for next-intl's `getLocale()` server function.
+*
+* Resolution order mirrors next-intl's per-request model:
+*
+* 1. The locale forwarded through `setRequestLocale(locale)` (the `[locale]`
+*    route segment) — the source of truth for URL-driven routing. This is what
+*    keeps server-rendered content and the locale switcher in sync with the URL
+*    instead of a stale cookie.
+* 2. Otherwise Intlayer's own resolution (cookie / header / Accept-Language),
+*    for apps that drive the locale from storage rather than the route.
 */
-const getLocale = async () => await getLocale$1();
+const getLocale = async () => {
+	const requestLocale = getCachedRequestLocale();
+	if (requestLocale) return requestLocale;
+	return await getLocale$1();
+};
 
 //#endregion
 export { getLocale };

package/dist/esm/server/getLocale.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"getLocale.mjs","names":["getLocaleIntlayer"],"sources":["../../../src/server/getLocale.ts"],"sourcesContent":["import type { getLocale as _getLocale } from 'next-intl/server';\nimport { getLocale as getLocaleIntlayer } from 'next-intlayer/server';\n\n/**\n * Drop-in for next-intl's `getLocale()` server function.\n */\nexport const getLocale: typeof _getLocale = async (): Promise<string> =>\n  (await getLocaleIntlayer()) as string;\n"],"mappings":";;;;;;AAMA,MAAa,YAA+B,YACzC,MAAMA,aAAmB"}
+{"version":3,"file":"getLocale.mjs","names":["getLocaleIntlayer"],"sources":["../../../src/server/getLocale.ts"],"sourcesContent":["import type { getLocale as _getLocale } from 'next-intl/server';\nimport { getLocale as getLocaleIntlayer } from 'next-intlayer/server';\nimport { getCachedRequestLocale } from './requestLocaleCache';\n\n/**\n * Drop-in for next-intl's `getLocale()` server function.\n *\n * Resolution order mirrors next-intl's per-request model:\n *\n * 1. The locale forwarded through `setRequestLocale(locale)` (the `[locale]`\n *    route segment) — the source of truth for URL-driven routing. This is what\n *    keeps server-rendered content and the locale switcher in sync with the URL\n *    instead of a stale cookie.\n * 2. Otherwise Intlayer's own resolution (cookie / header / Accept-Language),\n *    for apps that drive the locale from storage rather than the route.\n */\nexport const getLocale: typeof _getLocale = async (): Promise<string> => {\n  const requestLocale = getCachedRequestLocale();\n  if (requestLocale) return requestLocale as string;\n\n  return (await getLocaleIntlayer()) as string;\n};\n"],"mappings":";;;;;;;;;;;;;;;;AAgBA,MAAa,YAA+B,YAA6B;CACvE,MAAM,gBAAgB,wBAAwB;AAC9C,KAAI,cAAe,QAAO;AAE1B,QAAQ,MAAMA,aAAmB"}

package/dist/esm/server/requestLocaleCache.mjs

@@ -0,0 +1,33 @@
+import { cache } from "react";
+
+//#region src/server/requestLocaleCache.ts
+/**
+* Request-scoped holder for the locale provided through {@link setRequestLocale}.
+*
+* next-intl resolves the active locale per request from the `[locale]` route
+* segment, which the app forwards via `setRequestLocale(locale)`. React's
+* `cache()` gives a per-request singleton (the same trick next-intl uses in its
+* own `RequestLocaleCache`), so the value set in the layout/page is readable by
+* the other server APIs (`getLocale`, `getTranslations`, …) during the same
+* render.
+*
+* @see https://github.com/vercel/next.js/discussions/58862
+*/
+const getRequestLocaleHolder = cache(() => ({ locale: void 0 }));
+/**
+* Read the locale stored for the current request, or `undefined` when
+* `setRequestLocale` has not been called.
+*/
+const getCachedRequestLocale = () => getRequestLocaleHolder().locale;
+/**
+* Store the locale for the current request. Called by `setRequestLocale`.
+*
+* @param locale - The locale resolved from the `[locale]` route segment.
+*/
+const setCachedRequestLocale = (locale) => {
+	getRequestLocaleHolder().locale = locale;
+};
+
+//#endregion
+export { getCachedRequestLocale, setCachedRequestLocale };
+//# sourceMappingURL=requestLocaleCache.mjs.map

package/dist/esm/server/requestLocaleCache.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"requestLocaleCache.mjs","names":[],"sources":["../../../src/server/requestLocaleCache.ts"],"sourcesContent":["import type { LocalesValues } from '@intlayer/types/module_augmentation';\nimport { cache } from 'react';\n\n/**\n * Request-scoped holder for the locale provided through {@link setRequestLocale}.\n *\n * next-intl resolves the active locale per request from the `[locale]` route\n * segment, which the app forwards via `setRequestLocale(locale)`. React's\n * `cache()` gives a per-request singleton (the same trick next-intl uses in its\n * own `RequestLocaleCache`), so the value set in the layout/page is readable by\n * the other server APIs (`getLocale`, `getTranslations`, …) during the same\n * render.\n *\n * @see https://github.com/vercel/next.js/discussions/58862\n */\nconst getRequestLocaleHolder = cache((): { locale?: LocalesValues } => ({\n  locale: undefined,\n}));\n\n/**\n * Read the locale stored for the current request, or `undefined` when\n * `setRequestLocale` has not been called.\n */\nexport const getCachedRequestLocale = (): LocalesValues | undefined =>\n  getRequestLocaleHolder().locale;\n\n/**\n * Store the locale for the current request. Called by `setRequestLocale`.\n *\n * @param locale - The locale resolved from the `[locale]` route segment.\n */\nexport const setCachedRequestLocale = (locale: LocalesValues): void => {\n  getRequestLocaleHolder().locale = locale;\n};\n"],"mappings":";;;;;;;;;;;;;;;AAeA,MAAM,yBAAyB,aAAyC,EACtE,QAAQ,QACT,EAAE;;;;;AAMH,MAAa,+BACX,wBAAwB,CAAC;;;;;;AAO3B,MAAa,0BAA0B,WAAgC;AACrE,yBAAwB,CAAC,SAAS"}

package/dist/esm/server/setRequestLocale.mjs

@@ -1,26 +1,30 @@
-import { log } from "@intlayer/config/built";
-import { CYAN } from "@intlayer/config/colors";
-import { colorize, getAppLogger } from "@intlayer/config/logger";
+import { setCachedRequestLocale } from "./requestLocaleCache.mjs";
 
 //#region src/server/setRequestLocale.ts
 /**
 * Drop-in for next-intl's `setRequestLocale`.
 *
-* In next-intl this stores the locale in a request-scoped cache to opt into
-* static rendering. Intlayer resolves the active locale from the configured
-* `routing.storage` (cookie / header) or the localized route segment, so there
-* is nothing to set here — this is a no-op kept for API compatibility.
+* In next-intl this stores the locale (typically the `[locale]` route segment)
+* in a request-scoped cache so the rest of the request can render in that
+* locale and opt into static rendering. The compat keeps the same contract:
+* the locale is stored per-request and read back by `getLocale()` (and, through
+* it, `getTranslations` / `getDictionary` / metadata). This is what makes the
+* per-request locale — and therefore the locale switcher — work without relying
+* on a cookie.
 *
-* @deprecated setRequestLocale has no use case with intlayer. The locale is
-* resolved automatically from routing / storage.
+* @param locale - The locale resolved from the `[locale]` route segment.
 *
 * @example
 * ```ts
-* setRequestLocale(locale); // safe to keep, but has no effect
+* export default async function LocaleLayout({ params }) {
+*   const { locale } = await params;
+*   setRequestLocale(locale);
+*   // …
+* }
 * ```
 */
-const setRequestLocale = (_locale) => {
-	getAppLogger({ log })(`${colorize("setRequestLocale", CYAN)} has no use case with intlayer. The locale is resolved automatically from routing and storage`);
+const setRequestLocale = (locale) => {
+	setCachedRequestLocale(locale);
 };
 
 //#endregion

package/dist/esm/server/setRequestLocale.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"setRequestLocale.mjs","names":[],"sources":["../../../src/server/setRequestLocale.ts"],"sourcesContent":["import { log } from '@intlayer/config/built';\nimport { CYAN } from '@intlayer/config/colors';\nimport { colorize, getAppLogger } from '@intlayer/config/logger';\nimport type { setRequestLocale as _setRequestLocale } from 'next-intl/server';\n\n/**\n * Drop-in for next-intl's `setRequestLocale`.\n *\n * In next-intl this stores the locale in a request-scoped cache to opt into\n * static rendering. Intlayer resolves the active locale from the configured\n * `routing.storage` (cookie / header) or the localized route segment, so there\n * is nothing to set here — this is a no-op kept for API compatibility.\n *\n * @deprecated setRequestLocale has no use case with intlayer. The locale is\n * resolved automatically from routing / storage.\n *\n * @example\n * ```ts\n * setRequestLocale(locale); // safe to keep, but has no effect\n * ```\n */\nexport const setRequestLocale: typeof _setRequestLocale = (_locale): void => {\n  if (process.env.NODE_ENV === 'development') {\n    const appLogger = getAppLogger({ log });\n    appLogger(\n      `${colorize('setRequestLocale', CYAN)} has no use case with intlayer. The locale is resolved automatically from routing and storage`\n    );\n  }\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;AAqBA,MAAa,oBAA8C,YAAkB;AAGzE,CADkB,aAAa,EAAE,KAAK,CAC7B,CACP,GAAG,SAAS,oBAAoB,KAAK,CAAC,+FACvC"}
+{"version":3,"file":"setRequestLocale.mjs","names":[],"sources":["../../../src/server/setRequestLocale.ts"],"sourcesContent":["import type { LocalesValues } from '@intlayer/types/module_augmentation';\nimport type { setRequestLocale as _setRequestLocale } from 'next-intl/server';\nimport { setCachedRequestLocale } from './requestLocaleCache';\n\n/**\n * Drop-in for next-intl's `setRequestLocale`.\n *\n * In next-intl this stores the locale (typically the `[locale]` route segment)\n * in a request-scoped cache so the rest of the request can render in that\n * locale and opt into static rendering. The compat keeps the same contract:\n * the locale is stored per-request and read back by `getLocale()` (and, through\n * it, `getTranslations` / `getDictionary` / metadata). This is what makes the\n * per-request locale — and therefore the locale switcher — work without relying\n * on a cookie.\n *\n * @param locale - The locale resolved from the `[locale]` route segment.\n *\n * @example\n * ```ts\n * export default async function LocaleLayout({ params }) {\n *   const { locale } = await params;\n *   setRequestLocale(locale);\n *   // …\n * }\n * ```\n */\nexport const setRequestLocale: typeof _setRequestLocale = (locale): void => {\n  setCachedRequestLocale(locale as LocalesValues);\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AA0BA,MAAa,oBAA8C,WAAiB;AAC1E,wBAAuB,OAAwB"}

package/dist/types/client/NextIntlClientProvider.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"NextIntlClientProvider.d.ts","names":[],"sources":["../../../src/client/NextIntlClientProvider.tsx"],"mappings":";;;;;;;AAeA;;;cAAa,sBAAA,SAA+B,wBAAA;;AAgC5C;;KAAY,2BAAA,GAA8B,IAAA,CACxC,cAAA,QAAsB,wBAAA;EAAA;;;;EAOtB,QAAA;EAIqB;;;EAArB,MAAA,EAAQ,aAAA;AAAA"}
+{"version":3,"file":"NextIntlClientProvider.d.ts","names":[],"sources":["../../../src/client/NextIntlClientProvider.tsx"],"mappings":";;;;;;;AAiBA;;;cAAa,sBAAA,SAA+B,wBAAA;;AAsD5C;;KAAY,2BAAA,GAA8B,IAAA,CACxC,cAAA,QAAsB,wBAAA;EAAA;;;;EAOtB,QAAA;EAIqB;;;EAArB,MAAA,EAAQ,aAAA;AAAA"}

package/dist/types/server/getLocale.d.ts

@@ -3,6 +3,15 @@ import { getLocale as getLocale$1 } from "next-intl/server";
 //#region src/server/getLocale.d.ts
 /**
  * Drop-in for next-intl's `getLocale()` server function.
+ *
+ * Resolution order mirrors next-intl's per-request model:
+ *
+ * 1. The locale forwarded through `setRequestLocale(locale)` (the `[locale]`
+ *    route segment) — the source of truth for URL-driven routing. This is what
+ *    keeps server-rendered content and the locale switcher in sync with the URL
+ *    instead of a stale cookie.
+ * 2. Otherwise Intlayer's own resolution (cookie / header / Accept-Language),
+ *    for apps that drive the locale from storage rather than the route.
  */
 declare const getLocale: typeof getLocale$1;
 //#endregion

package/dist/types/server/getLocale.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"getLocale.d.ts","names":[],"sources":["../../../src/server/getLocale.ts"],"mappings":";;;;;AAMA;cAAa,SAAA,SAAkB,WAAA"}
+{"version":3,"file":"getLocale.d.ts","names":[],"sources":["../../../src/server/getLocale.ts"],"mappings":";;;;;AAgBA;;;;;;;;;;cAAa,SAAA,SAAkB,WAAA"}

package/dist/types/server/requestLocaleCache.d.ts

@@ -0,0 +1,17 @@
+import { LocalesValues } from "@intlayer/types/module_augmentation";
+
+//#region src/server/requestLocaleCache.d.ts
+/**
+ * Read the locale stored for the current request, or `undefined` when
+ * `setRequestLocale` has not been called.
+ */
+declare const getCachedRequestLocale: () => LocalesValues | undefined;
+/**
+ * Store the locale for the current request. Called by `setRequestLocale`.
+ *
+ * @param locale - The locale resolved from the `[locale]` route segment.
+ */
+declare const setCachedRequestLocale: (locale: LocalesValues) => void;
+//#endregion
+export { getCachedRequestLocale, setCachedRequestLocale };
+//# sourceMappingURL=requestLocaleCache.d.ts.map

package/dist/types/server/requestLocaleCache.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"requestLocaleCache.d.ts","names":[],"sources":["../../../src/server/requestLocaleCache.ts"],"mappings":";;;;;AAuBA;;cAAa,sBAAA,QAA6B,aAAA;;;AAQ1C;;;cAAa,sBAAA,GAA0B,MAAA,EAAQ,aAAA"}

package/dist/types/server/setRequestLocale.d.ts

@@ -4,17 +4,23 @@ import { setRequestLocale as setRequestLocale$1 } from "next-intl/server";
 /**
  * Drop-in for next-intl's `setRequestLocale`.
  *
- * In next-intl this stores the locale in a request-scoped cache to opt into
- * static rendering. Intlayer resolves the active locale from the configured
- * `routing.storage` (cookie / header) or the localized route segment, so there
- * is nothing to set here — this is a no-op kept for API compatibility.
+ * In next-intl this stores the locale (typically the `[locale]` route segment)
+ * in a request-scoped cache so the rest of the request can render in that
+ * locale and opt into static rendering. The compat keeps the same contract:
+ * the locale is stored per-request and read back by `getLocale()` (and, through
+ * it, `getTranslations` / `getDictionary` / metadata). This is what makes the
+ * per-request locale — and therefore the locale switcher — work without relying
+ * on a cookie.
  *
- * @deprecated setRequestLocale has no use case with intlayer. The locale is
- * resolved automatically from routing / storage.
+ * @param locale - The locale resolved from the `[locale]` route segment.
  *
  * @example
  * ```ts
- * setRequestLocale(locale); // safe to keep, but has no effect
+ * export default async function LocaleLayout({ params }) {
+ *   const { locale } = await params;
+ *   setRequestLocale(locale);
+ *   // …
+ * }
  * ```
  */
 declare const setRequestLocale: typeof setRequestLocale$1;

package/dist/types/server/setRequestLocale.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"setRequestLocale.d.ts","names":[],"sources":["../../../src/server/setRequestLocale.ts"],"mappings":";;;;;AAqBA;;;;;;;;;;;;;;cAAa,gBAAA,SAAyB,kBAAA"}
+{"version":3,"file":"setRequestLocale.d.ts","names":[],"sources":["../../../src/server/setRequestLocale.ts"],"mappings":";;;;;AA0BA;;;;;;;;;;;;;;;;;;;;cAAa,gBAAA,SAAyB,kBAAA"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@intlayer/next-intl",
-  "version": "9.0.0-canary.3",
+  "version": "9.0.0-canary.4",
   "private": false,
   "description": "next-intl API adapter for intlayer — useTranslations, useLocale, getTranslations, getLocale, NextIntlClientProvider backed by next-intlayer",
   "keywords": [
@@ -36,37 +36,31 @@
   "exports": {
     ".": {
       "types": "./dist/types/index.d.ts",
-      "require": "./dist/cjs/index.cjs",
       "import": "./dist/esm/index.mjs"
     },
     "./server": {
       "types": "./dist/types/server/index.d.ts",
-      "require": "./dist/cjs/server/index.cjs",
       "import": "./dist/esm/server/index.mjs"
     },
     "./routing": {
       "types": "./dist/types/routing.d.ts",
-      "require": "./dist/cjs/routing.cjs",
       "import": "./dist/esm/routing.mjs"
     },
     "./navigation": {
       "types": "./dist/types/navigation/index.d.ts",
-      "require": "./dist/cjs/navigation/index.cjs",
       "import": "./dist/esm/navigation/index.mjs"
     },
     "./middleware": {
       "types": "./dist/types/middleware.d.ts",
-      "require": "./dist/cjs/middleware.cjs",
       "import": "./dist/esm/middleware.mjs"
     },
     "./plugin": {
       "types": "./dist/types/plugin/index.d.ts",
-      "require": "./dist/cjs/plugin/index.cjs",
       "import": "./dist/esm/plugin/index.mjs"
     },
     "./package.json": "./package.json"
   },
-  "main": "dist/cjs/index.cjs",
+  "main": "dist/esm/index.mjs",
   "module": "dist/esm/index.mjs",
   "types": "dist/types/index.d.ts",
   "typesVersions": {
@@ -110,17 +104,17 @@
     "typecheck": "tsc --noEmit --project tsconfig.types.json"
   },
   "dependencies": {
-    "@intlayer/chokidar": "9.0.0-canary.3",
-    "@intlayer/config": "9.0.0-canary.3",
-    "@intlayer/core": "9.0.0-canary.3",
-    "@intlayer/dictionaries-entry": "9.0.0-canary.3",
-    "@intlayer/types": "9.0.0-canary.3",
-    "@intlayer/use-intl": "9.0.0-canary.3",
-    "next-intlayer": "9.0.0-canary.3",
-    "react-intlayer": "9.0.0-canary.3"
+    "@intlayer/chokidar": "9.0.0-canary.4",
+    "@intlayer/config": "9.0.0-canary.4",
+    "@intlayer/core": "9.0.0-canary.4",
+    "@intlayer/dictionaries-entry": "9.0.0-canary.4",
+    "@intlayer/types": "9.0.0-canary.4",
+    "@intlayer/use-intl": "9.0.0-canary.4",
+    "next-intlayer": "9.0.0-canary.4",
+    "react-intlayer": "9.0.0-canary.4"
   },
   "devDependencies": {
-    "@types/node": "25.9.3",
+    "@types/node": "25.9.4",
     "@types/react": "19.2.17",
     "@utils/ts-config": "1.0.4",
     "@utils/ts-config-types": "1.0.4",