next-intlayer 9.5.9 → 9.5.10

package/dist/cjs/rsc/index.cjs

@@ -3,15 +3,15 @@ const require_generateStaticParams = require('../generateStaticParams.cjs');
 const require_client_IntlayerClientProvider = require('../client/IntlayerClientProvider.cjs');
 const require_client_usePathname = require('../client/usePathname.cjs');
 const require_client_useLocalePageRouter = require('../client/useLocalePageRouter.cjs');
-const require_server_useIntlayer = require('../server/useIntlayer.cjs');
-const require_server_useIntl = require('../server/useIntl.cjs');
-const require_server_useDictionaryDynamic = require('../server/useDictionaryDynamic.cjs');
-const require_server_useLocale = require('../server/useLocale.cjs');
 const require_server_IntlayerProvider = require('../server/IntlayerProvider.cjs');
 const require_server_t = require('../server/t.cjs');
 const require_server_useDictionary = require('../server/useDictionary.cjs');
 const require_server_useDictionaryAsync = require('../server/useDictionaryAsync.cjs');
+const require_server_useDictionaryDynamic = require('../server/useDictionaryDynamic.cjs');
 const require_server_useI18n = require('../server/useI18n.cjs');
+const require_server_useIntl = require('../server/useIntl.cjs');
+const require_server_useIntlayer = require('../server/useIntlayer.cjs');
+const require_server_useLocale = require('../server/useLocale.cjs');
 let react_intlayer = require("react-intlayer");
 let react_intlayer_server = require("react-intlayer/server");
 

package/dist/cjs/server/ambientLocale.cjs

@@ -29,6 +29,17 @@ const needsRequestLocale = (localeOrSelector) => !hasExplicitLocale(localeOrSele
 */
 const readStoredLocale = require_server_suspendingReader.createSuspendingReader(require_server_getLocale.getLocale);
 /**
+* Resolves after one macrotask.
+*
+* Next.js renders a page concurrently with its layout, and the layout usually
+* awaits `params` before `IntlayerProvider` renders and seeds the server
+* context. A synchronous page therefore reads the context before it is seeded.
+* Yielding once lets the provider run first, so a full render (including the
+* build-time prerender) never reaches request storage and stays static.
+*/
+const yieldToProvider = () => new Promise((resolve) => setTimeout(() => resolve(true), 0));
+const waitForProvider = require_server_suspendingReader.createSuspendingReader(yieldToProvider);
+/**
 * Fallback locale for the synchronous server hooks, so a page does not need a
 * provider of its own. Not a React hook despite suspending — it holds no
 * positional state, which is what lets it run conditionally (see
@@ -36,15 +47,25 @@ const readStoredLocale = require_server_suspendingReader.createSuspendingReader(
 * page segment, the layout — and with it `IntlayerProvider` — does not re-run,
 * and the locale carried by the request takes over.
 *
-* Suspends until the request storage resolves. Returns `undefined` when the
-* call site or the server context already carries the locale.
+* On a context miss, first suspends once so a concurrently rendering provider
+* can seed the context, then suspends until the request storage resolves.
+* Returns `undefined` when the call site or the server context already carries
+* the locale.
 */
-const resolveFallbackLocale = (localeOrSelector) => needsRequestLocale(localeOrSelector) ? readStoredLocale() : void 0;
+const resolveFallbackLocale = (localeOrSelector) => {
+	if (!needsRequestLocale(localeOrSelector)) return void 0;
+	waitForProvider();
+	return needsRequestLocale(localeOrSelector) ? readStoredLocale() : void 0;
+};
 /**
 * Asynchronous twin of {@link resolveFallbackLocale}, for the hooks that are
 * already async and can await the request storage instead of suspending on it.
 */
-const getFallbackLocale = async (localeOrSelector) => needsRequestLocale(localeOrSelector) ? await require_server_getLocale.getLocale() : void 0;
+const getFallbackLocale = async (localeOrSelector) => {
+	if (!needsRequestLocale(localeOrSelector)) return void 0;
+	await yieldToProvider();
+	return needsRequestLocale(localeOrSelector) ? await require_server_getLocale.getLocale() : void 0;
+};
 /**
 * Full ambient locale for the server APIs that take a plain locale argument
 * (or none at all): call site → server context → locale carried by the

package/dist/cjs/server/ambientLocale.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"ambientLocale.cjs","names":["getServerContext","IntlayerServer","createSuspendingReader","getLocale"],"sources":["../../../src/server/ambientLocale.ts"],"sourcesContent":["import type { Locale } from '@intlayer/types/allLocales';\nimport type { LocalesValues } from '@intlayer/types/module_augmentation';\nimport { getServerContext, IntlayerServer } from 'react-intlayer/server';\nimport { getLocale } from './getLocale';\nimport { createSuspendingReader } from './suspendingReader';\n\n/**\n * Whether the call site already carries a locale — either a plain locale\n * argument or a selector object with an explicit `locale` field.\n */\nconst hasExplicitLocale = (localeOrSelector?: unknown): boolean =>\n  typeof localeOrSelector === 'string' ||\n  (typeof localeOrSelector === 'object' &&\n    localeOrSelector !== null &&\n    Boolean((localeOrSelector as { locale?: unknown }).locale));\n\n/**\n * Whether the request-derived locale is worth reading at all.\n *\n * The base hooks in `react-intlayer/server` already prefer, in order, the\n * locale passed at the call site and the request-scoped server context seeded\n * by `IntlayerProvider`; they only fall back to the third argument these\n * helpers produce. Reading request storage means calling `headers()` /\n * `cookies()`, which opts the route into dynamic rendering — so it must stay\n * behind both of those, and never run when either already answers.\n */\nconst needsRequestLocale = (localeOrSelector?: unknown): boolean =>\n  !hasExplicitLocale(localeOrSelector) && !getServerContext(IntlayerServer);\n\n/**\n * Reads the locale carried by the request: the `x-intlayer-locale` header set\n * by the intlayer proxy, then the locale cookie, then `accept-language`.\n *\n * Errors are not swallowed — during prerendering Next.js relies on the throw\n * from `headers()` to mark the route dynamic.\n */\nconst readStoredLocale = createSuspendingReader<Locale>(getLocale);\n\n/**\n * Fallback locale for the synchronous server hooks, so a page does not need a\n * provider of its own. Not a React hook despite suspending — it holds no\n * positional state, which is what lets it run conditionally (see\n * {@link createSuspendingReader}): on a client-side navigation that re-renders only the\n * page segment, the layout — and with it `IntlayerProvider` — does not re-run,\n * and the locale carried by the request takes over.\n *\n * Suspends until the request storage resolves. Returns `undefined` when the\n * call site or the server context already carries the locale.\n */\nexport const resolveFallbackLocale = (\n  localeOrSelector?: unknown\n): Locale | undefined =>\n  needsRequestLocale(localeOrSelector) ? readStoredLocale() : undefined;\n\n/**\n * Asynchronous twin of {@link resolveFallbackLocale}, for the hooks that are\n * already async and can await the request storage instead of suspending on it.\n */\nexport const getFallbackLocale = async (\n  localeOrSelector?: unknown\n): Promise<Locale | undefined> =>\n  needsRequestLocale(localeOrSelector) ? await getLocale() : undefined;\n\n/**\n * Full ambient locale for the server APIs that take a plain locale argument\n * (or none at all): call site → server context → locale carried by the\n * request.\n *\n * {@link resolveFallbackLocale} only yields the last rung, because the base hooks\n * in `react-intlayer/server` consult the first two themselves. The APIs\n * reimplemented here have no such fallback slot, so they need the resolved\n * value.\n */\nexport const resolveAmbientLocale = (\n  locale?: LocalesValues\n): LocalesValues | undefined =>\n  locale ??\n  getServerContext<LocalesValues>(IntlayerServer) ??\n  resolveFallbackLocale(locale);\n"],"mappings":";;;;;;;;;;AAUA,MAAM,qBAAqB,qBACzB,OAAO,qBAAqB,YAC3B,OAAO,qBAAqB,YAC3B,qBAAqB,QACrB,QAAS,iBAA0C,MAAM;;;;;;;;;;;AAY7D,MAAM,sBAAsB,qBAC1B,CAAC,kBAAkB,gBAAgB,KAAK,KAACA,wCAAiBC,oCAAc;;;;;;;;AAS1E,MAAM,mBAAmBC,uDAA+BC,kCAAS;;;;;;;;;;;;AAajE,MAAa,yBACX,qBAEA,mBAAmB,gBAAgB,IAAI,iBAAiB,IAAI;;;;;AAM9D,MAAa,oBAAoB,OAC/B,qBAEA,mBAAmB,gBAAgB,IAAI,MAAMA,mCAAU,IAAI;;;;;;;;;;;AAY7D,MAAa,wBACX,WAEA,cACAH,wCAAgCC,oCAAc,KAC9C,sBAAsB,MAAM"}
+{"version":3,"file":"ambientLocale.cjs","names":["getServerContext","IntlayerServer","createSuspendingReader","getLocale"],"sources":["../../../src/server/ambientLocale.ts"],"sourcesContent":["import type { Locale } from '@intlayer/types/allLocales';\nimport type { LocalesValues } from '@intlayer/types/module_augmentation';\nimport { getServerContext, IntlayerServer } from 'react-intlayer/server';\nimport { getLocale } from './getLocale';\nimport { createSuspendingReader } from './suspendingReader';\n\n/**\n * Whether the call site already carries a locale — either a plain locale\n * argument or a selector object with an explicit `locale` field.\n */\nconst hasExplicitLocale = (localeOrSelector?: unknown): boolean =>\n  typeof localeOrSelector === 'string' ||\n  (typeof localeOrSelector === 'object' &&\n    localeOrSelector !== null &&\n    Boolean((localeOrSelector as { locale?: unknown }).locale));\n\n/**\n * Whether the request-derived locale is worth reading at all.\n *\n * The base hooks in `react-intlayer/server` already prefer, in order, the\n * locale passed at the call site and the request-scoped server context seeded\n * by `IntlayerProvider`; they only fall back to the third argument these\n * helpers produce. Reading request storage means calling `headers()` /\n * `cookies()`, which opts the route into dynamic rendering — so it must stay\n * behind both of those, and never run when either already answers.\n */\nconst needsRequestLocale = (localeOrSelector?: unknown): boolean =>\n  !hasExplicitLocale(localeOrSelector) && !getServerContext(IntlayerServer);\n\n/**\n * Reads the locale carried by the request: the `x-intlayer-locale` header set\n * by the intlayer proxy, then the locale cookie, then `accept-language`.\n *\n * Errors are not swallowed — during prerendering Next.js relies on the throw\n * from `headers()` to mark the route dynamic.\n */\nconst readStoredLocale = createSuspendingReader<Locale>(getLocale);\n\n/**\n * Resolves after one macrotask.\n *\n * Next.js renders a page concurrently with its layout, and the layout usually\n * awaits `params` before `IntlayerProvider` renders and seeds the server\n * context. A synchronous page therefore reads the context before it is seeded.\n * Yielding once lets the provider run first, so a full render (including the\n * build-time prerender) never reaches request storage and stays static.\n */\nconst yieldToProvider = (): Promise<true> =>\n  new Promise((resolve) => setTimeout(() => resolve(true), 0));\n\nconst waitForProvider = createSuspendingReader<true>(yieldToProvider);\n\n/**\n * Fallback locale for the synchronous server hooks, so a page does not need a\n * provider of its own. Not a React hook despite suspending — it holds no\n * positional state, which is what lets it run conditionally (see\n * {@link createSuspendingReader}): on a client-side navigation that re-renders only the\n * page segment, the layout — and with it `IntlayerProvider` — does not re-run,\n * and the locale carried by the request takes over.\n *\n * On a context miss, first suspends once so a concurrently rendering provider\n * can seed the context, then suspends until the request storage resolves.\n * Returns `undefined` when the call site or the server context already carries\n * the locale.\n */\nexport const resolveFallbackLocale = (\n  localeOrSelector?: unknown\n): Locale | undefined => {\n  if (!needsRequestLocale(localeOrSelector)) return undefined;\n\n  waitForProvider();\n\n  return needsRequestLocale(localeOrSelector) ? readStoredLocale() : undefined;\n};\n\n/**\n * Asynchronous twin of {@link resolveFallbackLocale}, for the hooks that are\n * already async and can await the request storage instead of suspending on it.\n */\nexport const getFallbackLocale = async (\n  localeOrSelector?: unknown\n): Promise<Locale | undefined> => {\n  if (!needsRequestLocale(localeOrSelector)) return undefined;\n\n  await yieldToProvider();\n\n  return needsRequestLocale(localeOrSelector) ? await getLocale() : undefined;\n};\n\n/**\n * Full ambient locale for the server APIs that take a plain locale argument\n * (or none at all): call site → server context → locale carried by the\n * request.\n *\n * {@link resolveFallbackLocale} only yields the last rung, because the base hooks\n * in `react-intlayer/server` consult the first two themselves. The APIs\n * reimplemented here have no such fallback slot, so they need the resolved\n * value.\n */\nexport const resolveAmbientLocale = (\n  locale?: LocalesValues\n): LocalesValues | undefined =>\n  locale ??\n  getServerContext<LocalesValues>(IntlayerServer) ??\n  resolveFallbackLocale(locale);\n"],"mappings":";;;;;;;;;;AAUA,MAAM,qBAAqB,qBACzB,OAAO,qBAAqB,YAC3B,OAAO,qBAAqB,YAC3B,qBAAqB,QACrB,QAAS,iBAA0C,MAAM;;;;;;;;;;;AAY7D,MAAM,sBAAsB,qBAC1B,CAAC,kBAAkB,gBAAgB,KAAK,KAACA,wCAAiBC,oCAAc;;;;;;;;AAS1E,MAAM,mBAAmBC,uDAA+BC,kCAAS;;;;;;;;;;AAWjE,MAAM,wBACJ,IAAI,SAAS,YAAY,iBAAiB,QAAQ,IAAI,GAAG,CAAC,CAAC;AAE7D,MAAM,kBAAkBD,uDAA6B,eAAe;;;;;;;;;;;;;;AAepE,MAAa,yBACX,qBACuB;CACvB,IAAI,CAAC,mBAAmB,gBAAgB,GAAG,OAAO;CAElD,gBAAgB;CAEhB,OAAO,mBAAmB,gBAAgB,IAAI,iBAAiB,IAAI;AACrE;;;;;AAMA,MAAa,oBAAoB,OAC/B,qBACgC;CAChC,IAAI,CAAC,mBAAmB,gBAAgB,GAAG,OAAO;CAElD,MAAM,gBAAgB;CAEtB,OAAO,mBAAmB,gBAAgB,IAAI,MAAMC,mCAAU,IAAI;AACpE;;;;;;;;;;;AAYA,MAAa,wBACX,WAEA,cACAH,wCAAgCC,oCAAc,KAC9C,sBAAsB,MAAM"}

package/dist/cjs/server/index.cjs

@@ -1,16 +1,16 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
-const require_server_withIntlayer = require('./withIntlayer.cjs');
-const require_server_getLocale = require('./getLocale.cjs');
-const require_server_useIntlayer = require('./useIntlayer.cjs');
-const require_server_useIntl = require('./useIntl.cjs');
-const require_server_useDictionaryDynamic = require('./useDictionaryDynamic.cjs');
-const require_server_useLocale = require('./useLocale.cjs');
 const require_server_IntlayerProvider = require('./IntlayerProvider.cjs');
-const require_server_IntlayerServerProvider = require('./IntlayerServerProvider.cjs');
+const require_server_getLocale = require('./getLocale.cjs');
 const require_server_t = require('./t.cjs');
 const require_server_useDictionary = require('./useDictionary.cjs');
 const require_server_useDictionaryAsync = require('./useDictionaryAsync.cjs');
+const require_server_useDictionaryDynamic = require('./useDictionaryDynamic.cjs');
 const require_server_useI18n = require('./useI18n.cjs');
+const require_server_useIntl = require('./useIntl.cjs');
+const require_server_useIntlayer = require('./useIntlayer.cjs');
+const require_server_useLocale = require('./useLocale.cjs');
+const require_server_withIntlayer = require('./withIntlayer.cjs');
+const require_server_IntlayerServerProvider = require('./IntlayerServerProvider.cjs');
 let react_intlayer_server = require("react-intlayer/server");
 
 exports.IntlayerProvider = require_server_IntlayerProvider.IntlayerProvider;

package/dist/cjs/server/withIntlayer.cjs

@@ -10,8 +10,8 @@ let _intlayer_config_logger = require("@intlayer/config/logger");
 let _intlayer_config_node = require("@intlayer/config/node");
 let _intlayer_config_utils = require("@intlayer/config/utils");
 let _intlayer_engine_utils = require("@intlayer/engine/utils");
-let _intlayer_config_callers = require("@intlayer/config/callers");
 let _intlayer_config_defaultValues = require("@intlayer/config/defaultValues");
+let _intlayer_config_callers = require("@intlayer/config/callers");
 let _intlayer_config_envVars = require("@intlayer/config/envVars");
 let _intlayer_core_dictionaryManipulator = require("@intlayer/core/dictionaryManipulator");
 let _intlayer_dictionaries_entry = require("@intlayer/dictionaries-entry");

package/dist/esm/server/ambientLocale.mjs

@@ -28,6 +28,17 @@ const needsRequestLocale = (localeOrSelector) => !hasExplicitLocale(localeOrSele
 */
 const readStoredLocale = createSuspendingReader(getLocale);
 /**
+* Resolves after one macrotask.
+*
+* Next.js renders a page concurrently with its layout, and the layout usually
+* awaits `params` before `IntlayerProvider` renders and seeds the server
+* context. A synchronous page therefore reads the context before it is seeded.
+* Yielding once lets the provider run first, so a full render (including the
+* build-time prerender) never reaches request storage and stays static.
+*/
+const yieldToProvider = () => new Promise((resolve) => setTimeout(() => resolve(true), 0));
+const waitForProvider = createSuspendingReader(yieldToProvider);
+/**
 * Fallback locale for the synchronous server hooks, so a page does not need a
 * provider of its own. Not a React hook despite suspending — it holds no
 * positional state, which is what lets it run conditionally (see
@@ -35,15 +46,25 @@ const readStoredLocale = createSuspendingReader(getLocale);
 * page segment, the layout — and with it `IntlayerProvider` — does not re-run,
 * and the locale carried by the request takes over.
 *
-* Suspends until the request storage resolves. Returns `undefined` when the
-* call site or the server context already carries the locale.
+* On a context miss, first suspends once so a concurrently rendering provider
+* can seed the context, then suspends until the request storage resolves.
+* Returns `undefined` when the call site or the server context already carries
+* the locale.
 */
-const resolveFallbackLocale = (localeOrSelector) => needsRequestLocale(localeOrSelector) ? readStoredLocale() : void 0;
+const resolveFallbackLocale = (localeOrSelector) => {
+	if (!needsRequestLocale(localeOrSelector)) return void 0;
+	waitForProvider();
+	return needsRequestLocale(localeOrSelector) ? readStoredLocale() : void 0;
+};
 /**
 * Asynchronous twin of {@link resolveFallbackLocale}, for the hooks that are
 * already async and can await the request storage instead of suspending on it.
 */
-const getFallbackLocale = async (localeOrSelector) => needsRequestLocale(localeOrSelector) ? await getLocale() : void 0;
+const getFallbackLocale = async (localeOrSelector) => {
+	if (!needsRequestLocale(localeOrSelector)) return void 0;
+	await yieldToProvider();
+	return needsRequestLocale(localeOrSelector) ? await getLocale() : void 0;
+};
 /**
 * Full ambient locale for the server APIs that take a plain locale argument
 * (or none at all): call site → server context → locale carried by the

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

@@ -1 +1 @@
-{"version":3,"file":"ambientLocale.mjs","names":[],"sources":["../../../src/server/ambientLocale.ts"],"sourcesContent":["import type { Locale } from '@intlayer/types/allLocales';\nimport type { LocalesValues } from '@intlayer/types/module_augmentation';\nimport { getServerContext, IntlayerServer } from 'react-intlayer/server';\nimport { getLocale } from './getLocale';\nimport { createSuspendingReader } from './suspendingReader';\n\n/**\n * Whether the call site already carries a locale — either a plain locale\n * argument or a selector object with an explicit `locale` field.\n */\nconst hasExplicitLocale = (localeOrSelector?: unknown): boolean =>\n  typeof localeOrSelector === 'string' ||\n  (typeof localeOrSelector === 'object' &&\n    localeOrSelector !== null &&\n    Boolean((localeOrSelector as { locale?: unknown }).locale));\n\n/**\n * Whether the request-derived locale is worth reading at all.\n *\n * The base hooks in `react-intlayer/server` already prefer, in order, the\n * locale passed at the call site and the request-scoped server context seeded\n * by `IntlayerProvider`; they only fall back to the third argument these\n * helpers produce. Reading request storage means calling `headers()` /\n * `cookies()`, which opts the route into dynamic rendering — so it must stay\n * behind both of those, and never run when either already answers.\n */\nconst needsRequestLocale = (localeOrSelector?: unknown): boolean =>\n  !hasExplicitLocale(localeOrSelector) && !getServerContext(IntlayerServer);\n\n/**\n * Reads the locale carried by the request: the `x-intlayer-locale` header set\n * by the intlayer proxy, then the locale cookie, then `accept-language`.\n *\n * Errors are not swallowed — during prerendering Next.js relies on the throw\n * from `headers()` to mark the route dynamic.\n */\nconst readStoredLocale = createSuspendingReader<Locale>(getLocale);\n\n/**\n * Fallback locale for the synchronous server hooks, so a page does not need a\n * provider of its own. Not a React hook despite suspending — it holds no\n * positional state, which is what lets it run conditionally (see\n * {@link createSuspendingReader}): on a client-side navigation that re-renders only the\n * page segment, the layout — and with it `IntlayerProvider` — does not re-run,\n * and the locale carried by the request takes over.\n *\n * Suspends until the request storage resolves. Returns `undefined` when the\n * call site or the server context already carries the locale.\n */\nexport const resolveFallbackLocale = (\n  localeOrSelector?: unknown\n): Locale | undefined =>\n  needsRequestLocale(localeOrSelector) ? readStoredLocale() : undefined;\n\n/**\n * Asynchronous twin of {@link resolveFallbackLocale}, for the hooks that are\n * already async and can await the request storage instead of suspending on it.\n */\nexport const getFallbackLocale = async (\n  localeOrSelector?: unknown\n): Promise<Locale | undefined> =>\n  needsRequestLocale(localeOrSelector) ? await getLocale() : undefined;\n\n/**\n * Full ambient locale for the server APIs that take a plain locale argument\n * (or none at all): call site → server context → locale carried by the\n * request.\n *\n * {@link resolveFallbackLocale} only yields the last rung, because the base hooks\n * in `react-intlayer/server` consult the first two themselves. The APIs\n * reimplemented here have no such fallback slot, so they need the resolved\n * value.\n */\nexport const resolveAmbientLocale = (\n  locale?: LocalesValues\n): LocalesValues | undefined =>\n  locale ??\n  getServerContext<LocalesValues>(IntlayerServer) ??\n  resolveFallbackLocale(locale);\n"],"mappings":";;;;;;;;;AAUA,MAAM,qBAAqB,qBACzB,OAAO,qBAAqB,YAC3B,OAAO,qBAAqB,YAC3B,qBAAqB,QACrB,QAAS,iBAA0C,MAAM;;;;;;;;;;;AAY7D,MAAM,sBAAsB,qBAC1B,CAAC,kBAAkB,gBAAgB,KAAK,CAAC,iBAAiB,cAAc;;;;;;;;AAS1E,MAAM,mBAAmB,uBAA+B,SAAS;;;;;;;;;;;;AAajE,MAAa,yBACX,qBAEA,mBAAmB,gBAAgB,IAAI,iBAAiB,IAAI;;;;;AAM9D,MAAa,oBAAoB,OAC/B,qBAEA,mBAAmB,gBAAgB,IAAI,MAAM,UAAU,IAAI;;;;;;;;;;;AAY7D,MAAa,wBACX,WAEA,UACA,iBAAgC,cAAc,KAC9C,sBAAsB,MAAM"}
+{"version":3,"file":"ambientLocale.mjs","names":[],"sources":["../../../src/server/ambientLocale.ts"],"sourcesContent":["import type { Locale } from '@intlayer/types/allLocales';\nimport type { LocalesValues } from '@intlayer/types/module_augmentation';\nimport { getServerContext, IntlayerServer } from 'react-intlayer/server';\nimport { getLocale } from './getLocale';\nimport { createSuspendingReader } from './suspendingReader';\n\n/**\n * Whether the call site already carries a locale — either a plain locale\n * argument or a selector object with an explicit `locale` field.\n */\nconst hasExplicitLocale = (localeOrSelector?: unknown): boolean =>\n  typeof localeOrSelector === 'string' ||\n  (typeof localeOrSelector === 'object' &&\n    localeOrSelector !== null &&\n    Boolean((localeOrSelector as { locale?: unknown }).locale));\n\n/**\n * Whether the request-derived locale is worth reading at all.\n *\n * The base hooks in `react-intlayer/server` already prefer, in order, the\n * locale passed at the call site and the request-scoped server context seeded\n * by `IntlayerProvider`; they only fall back to the third argument these\n * helpers produce. Reading request storage means calling `headers()` /\n * `cookies()`, which opts the route into dynamic rendering — so it must stay\n * behind both of those, and never run when either already answers.\n */\nconst needsRequestLocale = (localeOrSelector?: unknown): boolean =>\n  !hasExplicitLocale(localeOrSelector) && !getServerContext(IntlayerServer);\n\n/**\n * Reads the locale carried by the request: the `x-intlayer-locale` header set\n * by the intlayer proxy, then the locale cookie, then `accept-language`.\n *\n * Errors are not swallowed — during prerendering Next.js relies on the throw\n * from `headers()` to mark the route dynamic.\n */\nconst readStoredLocale = createSuspendingReader<Locale>(getLocale);\n\n/**\n * Resolves after one macrotask.\n *\n * Next.js renders a page concurrently with its layout, and the layout usually\n * awaits `params` before `IntlayerProvider` renders and seeds the server\n * context. A synchronous page therefore reads the context before it is seeded.\n * Yielding once lets the provider run first, so a full render (including the\n * build-time prerender) never reaches request storage and stays static.\n */\nconst yieldToProvider = (): Promise<true> =>\n  new Promise((resolve) => setTimeout(() => resolve(true), 0));\n\nconst waitForProvider = createSuspendingReader<true>(yieldToProvider);\n\n/**\n * Fallback locale for the synchronous server hooks, so a page does not need a\n * provider of its own. Not a React hook despite suspending — it holds no\n * positional state, which is what lets it run conditionally (see\n * {@link createSuspendingReader}): on a client-side navigation that re-renders only the\n * page segment, the layout — and with it `IntlayerProvider` — does not re-run,\n * and the locale carried by the request takes over.\n *\n * On a context miss, first suspends once so a concurrently rendering provider\n * can seed the context, then suspends until the request storage resolves.\n * Returns `undefined` when the call site or the server context already carries\n * the locale.\n */\nexport const resolveFallbackLocale = (\n  localeOrSelector?: unknown\n): Locale | undefined => {\n  if (!needsRequestLocale(localeOrSelector)) return undefined;\n\n  waitForProvider();\n\n  return needsRequestLocale(localeOrSelector) ? readStoredLocale() : undefined;\n};\n\n/**\n * Asynchronous twin of {@link resolveFallbackLocale}, for the hooks that are\n * already async and can await the request storage instead of suspending on it.\n */\nexport const getFallbackLocale = async (\n  localeOrSelector?: unknown\n): Promise<Locale | undefined> => {\n  if (!needsRequestLocale(localeOrSelector)) return undefined;\n\n  await yieldToProvider();\n\n  return needsRequestLocale(localeOrSelector) ? await getLocale() : undefined;\n};\n\n/**\n * Full ambient locale for the server APIs that take a plain locale argument\n * (or none at all): call site → server context → locale carried by the\n * request.\n *\n * {@link resolveFallbackLocale} only yields the last rung, because the base hooks\n * in `react-intlayer/server` consult the first two themselves. The APIs\n * reimplemented here have no such fallback slot, so they need the resolved\n * value.\n */\nexport const resolveAmbientLocale = (\n  locale?: LocalesValues\n): LocalesValues | undefined =>\n  locale ??\n  getServerContext<LocalesValues>(IntlayerServer) ??\n  resolveFallbackLocale(locale);\n"],"mappings":";;;;;;;;;AAUA,MAAM,qBAAqB,qBACzB,OAAO,qBAAqB,YAC3B,OAAO,qBAAqB,YAC3B,qBAAqB,QACrB,QAAS,iBAA0C,MAAM;;;;;;;;;;;AAY7D,MAAM,sBAAsB,qBAC1B,CAAC,kBAAkB,gBAAgB,KAAK,CAAC,iBAAiB,cAAc;;;;;;;;AAS1E,MAAM,mBAAmB,uBAA+B,SAAS;;;;;;;;;;AAWjE,MAAM,wBACJ,IAAI,SAAS,YAAY,iBAAiB,QAAQ,IAAI,GAAG,CAAC,CAAC;AAE7D,MAAM,kBAAkB,uBAA6B,eAAe;;;;;;;;;;;;;;AAepE,MAAa,yBACX,qBACuB;CACvB,IAAI,CAAC,mBAAmB,gBAAgB,GAAG,OAAO;CAElD,gBAAgB;CAEhB,OAAO,mBAAmB,gBAAgB,IAAI,iBAAiB,IAAI;AACrE;;;;;AAMA,MAAa,oBAAoB,OAC/B,qBACgC;CAChC,IAAI,CAAC,mBAAmB,gBAAgB,GAAG,OAAO;CAElD,MAAM,gBAAgB;CAEtB,OAAO,mBAAmB,gBAAgB,IAAI,MAAM,UAAU,IAAI;AACpE;;;;;;;;;;;AAYA,MAAa,wBACX,WAEA,UACA,iBAAgC,cAAc,KAC9C,sBAAsB,MAAM"}

package/dist/types/generateStaticParams.d.ts

@@ -1,4 +1,3 @@
-import { Locale } from "./intlayer/dist/types/index.js";
 //#region src/generateStaticParams.d.ts
 /**
  * Generates static parameters for Next.js's dynamic routes based on the configured locales.
@@ -19,7 +18,7 @@ import { Locale } from "./intlayer/dist/types/index.js";
  * ```
  */
 export declare const generateStaticParams: () => {
-  locale: Locale;
+  locale: import("@intlayer/types").Locale;
 }[];
 //#endregion
 //# sourceMappingURL=generateStaticParams.d.ts.map

package/dist/types/generateStaticParams.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"generateStaticParams.d.ts","names":[],"sources":["../../src/generateStaticParams.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;qBAsBa;UAAA"}
+{"version":3,"file":"generateStaticParams.d.ts","names":[],"sources":["../../src/generateStaticParams.ts"],"mappings":";;;;;;;;;;;;;;;;;;;qBAsBa;EAAA,kCAAA"}

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

@@ -9,8 +9,10 @@ import { Locale } from "@intlayer/types/allLocales";
  * page segment, the layout — and with it `IntlayerProvider` — does not re-run,
  * and the locale carried by the request takes over.
  *
- * Suspends until the request storage resolves. Returns `undefined` when the
- * call site or the server context already carries the locale.
+ * On a context miss, first suspends once so a concurrently rendering provider
+ * can seed the context, then suspends until the request storage resolves.
+ * Returns `undefined` when the call site or the server context already carries
+ * the locale.
  */
 export declare const resolveFallbackLocale: (localeOrSelector?: unknown) => Locale | undefined;
 /**

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

@@ -1 +1 @@
-{"version":3,"file":"ambientLocale.d.ts","names":[],"sources":["../../../src/server/ambientLocale.ts"],"mappings":";;;;;;;;;;;;;;qBAiDa,wBAAqB,+BAE/B;;;;;qBAOU,oBAAiB,+BAE3B,QAAQ;;;;;;;;;;;qBAaE,uBAAoB,SACtB,kBACR"}
+{"version":3,"file":"ambientLocale.d.ts","names":[],"sources":["../../../src/server/ambientLocale.ts"],"mappings":";;;;;;;;;;;;;;;;qBAiEa,wBAAqB,+BAE/B;;;;;qBAYU,oBAAiB,+BAE3B,QAAQ;;;;;;;;;;;qBAkBE,uBAAoB,SACtB,kBACR"}

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

@@ -1,8 +1,8 @@
-import { IntlayerConfig } from "@intlayer/types/config";
 import { Dictionary } from "@intlayer/types/dictionary";
 import { CallerDescriptor } from "@intlayer/config/callers";
 import { GetConfigurationOptions } from "@intlayer/config/node";
 import { SerializedFieldRenameMap } from "@intlayer/babel";
+import { IntlayerConfig } from "@intlayer/types/config";
 //#region src/server/prepareSwcOptimization.d.ts
 /**
  * Field-rename tables keyed by dictionary key, forwarded to the

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

@@ -1,6 +1,6 @@
 import { DeclaredLocales, LocalesValues } from "@intlayer/types/module_augmentation";
-import { Dictionary, DictionarySelectorForGroup, QualifiedDictionaryGroup } from "@intlayer/types/dictionary";
 import { useDictionary as useDictionary$1 } from "react-intlayer/server";
+import { Dictionary, DictionarySelectorForGroup, QualifiedDictionaryGroup } from "@intlayer/types/dictionary";
 //#region src/server/useDictionary.d.ts
 /**
  * On the server side, hook that transforms a dictionary (or qualified

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

@@ -1,6 +1,6 @@
 import { DeclaredLocales, LocalesValues, StrictModeLocaleMap } from "@intlayer/types/module_augmentation";
-import { Dictionary } from "@intlayer/types/dictionary";
 import { useDictionaryAsync as useDictionaryAsync$1 } from "react-intlayer/server";
+import { Dictionary } from "@intlayer/types/dictionary";
 //#region src/server/useDictionaryAsync.d.ts
 /**
  * On the server side, hook that transforms a dictionary and returns the content

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

@@ -1,6 +1,6 @@
 import { DeclaredLocales, LocalesValues, StrictModeLocaleMap } from "@intlayer/types/module_augmentation";
-import { Dictionary, DictionarySelector } from "@intlayer/types/dictionary";
 import { useDictionaryDynamic as useDictionaryDynamic$1 } from "react-intlayer/server";
+import { Dictionary, DictionarySelector } from "@intlayer/types/dictionary";
 import { QualifiedDynamicLoaderMap } from "@intlayer/core/dictionaryManipulator";
 //#region src/server/useDictionaryDynamic.d.ts
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "next-intlayer",
-  "version": "9.5.9",
+  "version": "9.5.10",
   "private": false,
   "description": "Simplify internationalization i18n in Next.js with context providers, hooks, locale detection, and multilingual content integration.",
   "keywords": [
@@ -147,14 +147,14 @@
     "typecheck": "tsc --noEmit --project tsconfig.types.json"
   },
   "dependencies": {
-    "@intlayer/config": "9.5.9",
-    "@intlayer/core": "9.5.9",
-    "@intlayer/dictionaries-entry": "9.5.9",
-    "@intlayer/engine": "9.5.9",
-    "@intlayer/types": "9.5.9",
+    "@intlayer/config": "9.5.10",
+    "@intlayer/core": "9.5.10",
+    "@intlayer/dictionaries-entry": "9.5.10",
+    "@intlayer/engine": "9.5.10",
+    "@intlayer/types": "9.5.10",
     "defu": "6.1.7",
     "node-loader": "2.1.0",
-    "react-intlayer": "9.5.9"
+    "react-intlayer": "9.5.10"
   },
   "devDependencies": {
     "@types/node": "^22",
@@ -166,7 +166,7 @@
     "rimraf": "6.1.3",
     "tsdown": "0.23.0",
     "typescript": "7.0.2",
-    "vitest": "5.0.1"
+    "vitest": "5.0.2"
   },
   "peerDependencies": {
     "next": ">=14.0.0",

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

@@ -1,14 +0,0 @@
-import { DeclaredLocales } from "@intlayer/types/module_augmentation";
-import { IntlayerConfig } from "@intlayer/types/config";
-import { Dictionary } from "@intlayer/types/dictionary";
-import { Locale as Locale$1 } from "@intlayer/types/allLocales";
-import "@intlayer/types/locales";
-import "@intlayer/config/built";
-import "@intlayer/core/file";
-import "@intlayer/core/formatters";
-import "@intlayer/core/interpreter";
-import "@intlayer/core/localization";
-import "@intlayer/core/markdown";
-import "@intlayer/core/transpiler";
-import "@intlayer/core/utils";
-export type { Locale$1 as Locale };