@intlayer/docs 9.0.0-canary.6 → 9.0.0-canary.8

package/docs/es/packages/vite-intlayer/intlayerMinify.md

@@ -0,0 +1,92 @@
+---
+createdAt: 2026-06-25
+updatedAt: 2026-06-25
+title: Documentación del plugin Vite intlayerMinify | vite-intlayer
+description: Plugin de Vite que minifica los archivos JSON de diccionarios Intlayer compilados y, opcionalmente, ofusca los nombres de los campos de contenido para reducir el tamaño del bundle.
+keywords:
+  - intlayerMinify
+  - vite
+  - plugin
+  - minificar
+  - tamaño del bundle
+  - diccionario
+  - internacionalización
+  - i18n
+slugs:
+  - doc
+  - packages
+  - vite-intlayer
+  - intlayerMinify
+history:
+  - version: 9.0.0
+    date: 2026-06-25
+    changes: "Inicialización de doc"
+author: aymericzip
+---
+
+# intlayerMinify
+
+`intlayerMinify` es un plugin de Vite que minifica archivos JSON de diccionarios compilados durante una compilación de producción. Elimina todos los espacios en blanco innecesarios y, cuando se combina con `intlayerPrune`, opcionalmente renombra los nombres de los campos de contenido a alias alfabéticos cortos (`a`, `b`, `c`, ...) para reducir aún más el tamaño del bundle.
+
+> El plugin ya está incluido y configurado automáticamente cuando utiliza [`intlayer()`](https://github.com/aymericzip/intlayer/blob/main/docs/docs/es/packages/vite-intlayer/intlayer.md). Solo necesita registrarlo manualmente si está componiendo la pila de plugins usted mismo.
+
+## Uso
+
+```ts
+// vite.config.ts
+import { defineConfig } from "vite";
+import { intlayerMinify, intlayerPrune } from "vite-intlayer";
+import { createPruneContext } from "@intlayer/babel";
+
+const pruneContext = createPruneContext();
+
+export default defineConfig({
+  plugins: [
+    intlayerPrune(intlayerConfig, pruneContext),
+    intlayerMinify(intlayerConfig, pruneContext),
+  ],
+});
+```
+
+## Condiciones de activación
+
+`intlayerMinify` está activo **solo** cuando se cumplen las tres condiciones siguientes:
+
+1. El comando de Vite es `build` (no `serve` / dev).
+2. `build.optimize` es `true` (o `undefined`, que por defecto es `true` para compilaciones).
+3. `build.minify` es `true` en su configuración de Intlayer.
+
+Se **desactiva** automáticamente cuando `editor.enabled` es `true` porque el editor necesita el contenido del diccionario completo y legible por humanos.
+
+## Qué se minifica
+
+El plugin apunta a dos ubicaciones de diccionarios (según lo resuelto a partir de `intlayer.system`):
+
+- `dictionariesDir` — diccionarios estáticos para todos los idiomas (por ejemplo, `.intlayer/dictionaries/*.json`)
+- `dynamicDictionariesDir` — diccionarios dinámicos por idioma
+
+> Los diccionarios en modo fetch (`fetchDictionariesDir`) **nunca** se minifican porque se sirven desde una API remota en tiempo de ejecución utilizando sus nombres de campo originales. Cambiar el nombre de los campos crearía una discrepancia entre la respuesta del servidor y los accesos a propiedades en el lado del cliente.
+
+## Ofuscación de nombres de campo (minificación de propiedades)
+
+Cuando `intlayerPrune` ha analizado el código fuente y ha llenado `pruneContext.dictionaryKeyToFieldRenameMap`, `intlayerMinify` también cambia el nombre de los campos de contenido a alias cortos. Por ejemplo:
+
+```json
+// antes
+{ "key": "myDict", "content": { "title": "Hello", "description": "World" } }
+
+// después (con ofuscación)
+{ "key": "myDict", "content": { "a": "Hello", "b": "World" } }
+```
+
+Los accesos a propiedades de archivos fuente correspondientes se renombran mediante el paso de Babel dentro de `intlayerOptimize`, por lo que el comportamiento en tiempo de ejecución no cambia.
+
+Los campos internos de Intlayer (`nodeType`, `translation`, etc.) nunca se renombran.
+
+## Dicionarios de casos extremos (Edge cases)
+
+Los diccionarios marcados en `pruneContext.dictionariesWithEdgeCases` (anomalías estructurales detectadas durante la fase de prune) se omiten por completo — ni se minifican ni se ofuscan — para evitar el envío de datos dañados.
+
+## Grupos calificados (colecciones / variantes / registros meta)
+
+Para diccionarios con una matriz `qualifierTypes` (colecciones, variantes y registros meta), el plugin conserva la matriz `qualifierTypes` y el mapa lateral `meta` literalmente. Solo las entradas de `content` tienen sus nombres de campo ofuscados. Las claves compuestas (utilizadas para la coincidencia de selectores en tiempo de ejecución) nunca se tocan.

package/docs/es/packages/vite-intlayer/intlayerProxy.md

@@ -0,0 +1,172 @@
+---
+createdAt: 2026-06-25
+updatedAt: 2026-06-25
+title: Documentación del plugin Vite intlayerProxy | vite-intlayer
+description: Middleware de enrutamiento de idiomas para los servidores dev/preview de Vite y SSR de producción. Maneja la detección de idioma, redireccionamientos de URL y reescrituras internas.
+keywords:
+  - intlayerProxy
+  - vite
+  - plugin
+  - middleware
+  - idioma
+  - enrutamiento
+  - internacionalización
+  - i18n
+  - SSR
+slugs:
+  - doc
+  - packages
+  - vite-intlayer
+  - intlayerProxy
+history:
+  - version: 9.0.0
+    date: 2026-06-25
+    changes: "Se fusionó configOptions en un solo objeto de opciones; proxy integrado en intlayer()"
+author: aymericzip
+---
+
+# intlayerProxy
+
+`intlayerProxy` es un plugin de Vite que registra un middleware de enrutamiento de idiomas para **todos los entornos**: servidor de desarrollo, servidor de vista previa y SSR de producción (Nitro / TanStack Start).
+
+> **Desde Intlayer v9**, `intlayerProxy` se incluye automáticamente dentro del plugin principal [`intlayer()`](https://github.com/aymericzip/intlayer/blob/main/docs/docs/es/packages/vite-intlayer/intlayer.md) y está habilitado por defecto mediante `routing.enableProxy: true`. Solo necesita registrarlo por separado si requiere un control de nivel inferior o si lo está utilizando fuera de la configuración estándar de `intlayer()`.
+
+## Uso
+
+### Como parte de `intlayer()` (recomendado, v9+)
+
+Pase las opciones de `proxy` al plugin principal en lugar de registrar `intlayerProxy` por separado:
+
+```ts
+// vite.config.ts
+import { defineConfig } from "vite";
+import { intlayer } from "vite-intlayer";
+
+export default defineConfig({
+  plugins: [
+    intlayer({
+      proxy: {
+        ignore: (req) => req.url?.startsWith("/api"),
+      },
+    }),
+  ],
+});
+```
+
+### Autónomo (cuando sea necesario)
+
+```ts
+// vite.config.ts
+import { defineConfig } from "vite";
+import { intlayer } from "vite-intlayer";
+
+export default defineConfig({
+  plugins: [intlayer()],
+});
+```
+
+## Opciones
+
+```ts
+import type { IntlayerProxyPluginOptions } from "vite-intlayer";
+```
+
+Todas las opciones son opcionales y se pasan como un único objeto:
+
+| Opción          | Tipo                                | Descripción                                                                                                                                                                |
+| --------------- | ----------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `ignore`        | `(req: IncomingMessage) => boolean` | Predicado que excluye solicitudes del enrutamiento de idiomas. Devuelva `true` para omitir una solicitud (por ejemplo, rutas de API, controles de salud).                  |
+| `configOptions` | `GetConfigurationOptions`           | Anulaciones de configuración de Intlayer reenviadas a `getConfiguration()`. Úselo cuando necesite que el proxy lea un archivo de configuración específico o anule valores. |
+
+### Ejemplo
+
+```ts
+intlayerProxy({
+  ignore: (req) => req.url?.startsWith("/api"),
+  configOptions: { configFile: "./config/intlayer.config.ts" },
+});
+```
+
+## createIntlayerProxyHandler
+
+`createIntlayerProxyHandler` crea un middleware Node.js `(req, res, next)` independiente del framework que contiene toda la lógica de enrutamiento de idiomas. Es útil en entornos donde la API del plugin de Vite no está disponible (por ejemplo, un servidor Node.js simple o un módulo Nitro personalizado).
+
+```ts
+import { createIntlayerProxyHandler } from "vite-intlayer";
+
+const handler = createIntlayerProxyHandler({
+  ignore: (req) => req.url?.startsWith("/api"),
+  configOptions: { configFile: "./config/intlayer.config.ts" },
+});
+
+// Express / Connect
+app.use(handler);
+```
+
+### SSR de producción (TanStack Start / Nitro a través de h3)
+
+```ts
+// server/middleware/intlayerProxy.ts
+import { fromNodeMiddleware } from "h3";
+import { createIntlayerProxyHandler } from "vite-intlayer";
+
+export default fromNodeMiddleware(
+  createIntlayerProxyHandler({
+    ignore: (req) => req.url?.startsWith("/api"),
+  })
+);
+```
+
+## Comportamiento de enrutamiento
+
+El middleware refleja la lógica de enrutamiento del middleware de `next-intlayer` y es compatible con todos los modos de enrutamiento de Intlayer.
+
+### Modos de enrutamiento
+
+| Modo            | URL visible en el navegador | Comportamiento                                                                                                                          |
+| --------------- | --------------------------- | --------------------------------------------------------------------------------------------------------------------------------------- |
+| `prefix`        | `/es/about`                 | Por defecto. Prefijo de idioma en la URL. El idioma por defecto redirige a la URL sin prefijo a menos que `prefix-all` esté habilitado. |
+| `prefix-all`    | `/en/about`, `/es/about`    | Todos los idiomas — incluido el por defecto — siempre tienen prefijo.                                                                   |
+| `no-prefix`     | `/about`                    | Sin idioma en la URL. El idioma se almacena únicamente en las cookies; las reescrituras de URL ocurren internamente.                    |
+| `search-params` | `/about?locale=es`          | Idioma pasado como parámetro de consulta. Redirige para agregar/actualizar el parámetro `locale` cuando falta o está obsoleto.          |
+
+### Prioridad de detección
+
+1. Prefijo de ruta URL (por ejemplo, `/es/about` → `es`).
+2. Valor de cookie / localStorage (`intlayer-locale`).
+3. Cabecera `Accept-Language`.
+4. `defaultLocale` de la configuración.
+
+### Omisión automática
+
+El middleware siempre deja pasar estas solicitudes directamente sin manejo de idioma:
+
+- Solicitudes que coinciden con el predicado `ignore`.
+- `/node_modules/**`
+- `/@**` – Componentes internos de Vite (`@vite/`, `@fs/`, `@id/`, etc.).
+- `/_**` – Componentes internos del servidor (`__vite_ping`, `__manifest`, etc.).
+- Solicitudes cuya ruta termina con una extensión de archivo (activos estáticos). Si hay un prefijo de idioma presente en la ruta de un activo estático (por ejemplo, `/es/logo.png`), se elimina para que el archivo se pueda servir correctamente.
+
+### Enrutamiento de dominio
+
+Cuando `routing.domains` está configurado en su configuración de Intlayer, el middleware maneja el enrutamiento de idiomas entre dominios:
+
+- Una solicitud para `/zh/about` en `intlayer.org` se redirige a `https://intlayer.zh/about` cuando `domains.zh = "intlayer.zh"`.
+- Una solicitud a `intlayer.zh/about` se reescribe internamente a `/zh/about` para que se complete el parámetro de ruta `[locale]`.
+
+### Protección contra bucles de redirección
+
+El middleware realiza un seguimiento de los recuentos de redireccionamientos por par `originalUrl → newUrl` dentro de una ventana deslizante de 2 segundos. Más de 10 redireccionamientos dentro de esa ventana devuelven una respuesta `500` con un error descriptivo en lugar de entrar en un bucle infinito.
+
+## Nitro / SSR de producción (inyección automática, v9+)
+
+Cuando se usa `intlayerProxy` como plugin de Vite, lleva una propiedad `.nitro`. El plugin de compilación `nitro/vite` lee esta propiedad y la agrega a `nitroConfig.modules`, por lo que `intlayerNitroHandler` se registra como middleware del servidor Nitro automáticamente; no se necesita configuración manual para el SSR de producción.
+
+El controlador Nitro utiliza el modelo de eventos de la API Web Fetch de h3 v2 (no `fromNodeMiddleware`), por lo que es compatible con todos los preajustes de Nitro: Node, Bun, Deno, entornos de ejecución edge.
+
+## Alias obsoletos
+
+| Exportación obsoleta       | Reemplazo       |
+| -------------------------- | --------------- |
+| `intlayerMiddleware`       | `intlayerProxy` |
+| `intLayerMiddlewarePlugin` | `intlayerProxy` |

package/docs/es/plugins/sync-json.md

@@ -108,7 +108,6 @@ const config: IntlayerConfig = {
      * Cargará y escribirá la salida y las traducciones de vuelta a los archivos JSON en el directorio locales
      */
     syncJSON({
-      format: "i18next",
       source: ({ key, locale }) => `./locales/${locale}/${key}.json`,
       priority: 0,
       format: "i18next",

package/docs/es/releases/v9.md

@@ -1,15 +1,14 @@
 ---
 createdAt: 2026-06-14
-updatedAt: 2026-06-23
+updatedAt: 2026-06-26
 title: Nuevo Intlayer v9 - ¿Qué hay de nuevo?
-description: Descubre las novedades de Intlayer v9. Presentamos paquetes de compatibilidad directos para librerías i18n populares y soporte para Colecciones, Variantes y Registros Dinámicos.
+description: Descubre las novedades de Intlayer v9. Presentamos paquetes de compatibilidad directos para librerías i18n populares y soporte para Colecciones y Variantes.
 keywords:
   - Intlayer
   - Compatibility
   - Migration
   - Collections
   - Variants
-  - Dynamic Records
   - i18next
   - next-intl
   - vue-i18n
@@ -22,7 +21,7 @@ author: aymericzip
 
 # Nuevo Intlayer v9 - ¿Qué hay de nuevo?
 
-¡Bienvenido a Intlayer v9! Esta importante versión marca un gran hito al simplificar la ruta de migración a Intlayer con **Paquetes Adaptadores de Compatibilidad** para las principales librerías i18n (`react-i18next`, `next-intl`, `vue-i18n`, etc.) y añade soporte para estructuras de contenido enriquecido: **Colecciones**, **Variantes** y **Registros Dinámicos**.
+¡Bienvenido a Intlayer v9! Esta importante versión marca un gran hito al simplificar la ruta de migración a Intlayer con **Paquetes Adaptadores de Compatibilidad** para las principales librerías i18n (`react-i18next`, `next-intl`, `vue-i18n`, etc.) y añade soporte para estructuras de contenido enriquecido: **Colecciones** y **Variantes**.
 
 ## Tabla de contenidos
 
@@ -41,8 +40,10 @@ Al reemplazar los imports, obtienes todos los beneficios de Intlayer (incluida l
 - `@intlayer/i18next`
 - `@intlayer/react-i18next`
 - `@intlayer/next-intl`
+- `@intlayer/react-intl`
 - `@intlayer/next-i18next`
 - `@intlayer/vue-i18n`
+- `@intlayer/lingui`
 
 Por ejemplo, simplemente cambia:
 
@@ -100,7 +101,7 @@ Todos los adaptadores de compatibilidad ahora enrutan la resolución de traducci
 
 ---
 
-## Especificación de Características: Colecciones, Variantes y Registros Dinámicos
+## Especificación de Características: Colecciones y Variantes
 
 Intlayer v9 se expande más allá de los objetos estáticos clave-valor, permitiendo que los diccionarios declaren estructuras de diseño dinámicas que están completamente tipadas de principio a fin.
 
@@ -144,6 +145,8 @@ const faq = useIntlayer("faq", { item: 1 }); // -> { question: string, answer: s
 
 Ofrece pruebas A/B, encabezados de temporada, feature flags o landing pages personalizadas:
 
+#### Variantes de cadena (por ejemplo, pruebas A/B)
+
 ```ts fileName="hero.content.ts"
 import { t, type Dictionary } => "intlayer";
 
@@ -163,16 +166,14 @@ export default {
 const banner = useIntlayer("hero-banner", { variant: "black_friday" });
 ```
 
-### 3. Registros Dinámicos
-
-Define diccionarios cuyas entradas se cargan dinámicamente en tiempo de ejecución a través de IDs de consulta:
+#### Variantes de objeto (por ejemplo, Dynamic Records)
 
 ```ts fileName="product.content.ts"
 import { t, type Dictionary } from "intlayer";
 
 export default {
   key: "product-copy",
-  meta: {
+  variant: {
     id: "prod_123",
     category: "books",
   },
@@ -225,7 +226,7 @@ export default defineConfig({
 });
 ```
 
-- **Compilador**: Se activa automáticamente cuando `compiler.enabled` está configurado y se define una ruta `compiler.output`. Ya no necesitas registrar `intlayerCompiler()` por separado.
+- **Compilador**: Se activa automáticamente cuando `compiler.enabled` está configurado en `true` y se define una ruta `compiler.output`. Ya no necesitas registrar `intlayerCompiler()` por separado.
 - **Proxy**: Se activa automáticamente basado en la nueva opción `routing.enableProxy` (`true` por defecto). Conecta el middleware de detección de locales / redirección / reescritura en desarrollo, vista previa y SSR de producción. Ya no necesitas registrar `intlayerProxy()` por separado.
 
 ### Opción `routing.enableProxy`
@@ -248,17 +249,61 @@ Los plugins independientes `intlayerCompiler()` e `intlayerProxy()` siguen siend
 
 ---
 
+## Compilador deshabilitado por defecto
+
+A partir de Intlayer v9, el **compilador está deshabilitado por defecto** (`compiler.enabled` ahora tiene el valor predeterminado `false`). Para habilitar la extracción de tus archivos `.content.ts` en tiempo de compilación, establece `compiler.enabled: true` en tu configuración:
+
+```ts fileName="intlayer.config.ts"
+import type { IntlayerConfig } from "intlayer";
+
+const config: IntlayerConfig = {
+  compiler: {
+    enabled: true, // Por defecto: false — requerido para habilitar el compilador desde la v9
+    output: ({ fileName }) => `./${fileName}.content.ts`,
+  },
+};
+
+export default config;
+```
+
+Cuando el compilador está deshabilitado, Intlayer omite el paso de extracción en tiempo de compilación y se basa en tus diccionarios ya declarados. Habilítalo solo cuando quieras que el plugin del bundler (`@intlayer/swc`, `@intlayer/babel` o el plugin de Vite `intlayer()`) extraiga el contenido automáticamente.
+
+---
+
+## React Native: importaciones desde un solo paquete
+
+En una aplicación de React Native o Expo, ya no necesitas alternar entre `react-intlayer` y `react-native-intlayer`. El paquete `react-native-intlayer` ahora **reexporta la API completa de `react-intlayer`** (hooks, utilidades y las subrutas `/format`, `/html`, y `/markdown`), y su `IntlayerProvider` aplica automáticamente los polyfills de React Native.
+
+Importa todo desde el paquete único `react-native-intlayer`:
+
+```tsx
+import {
+  IntlayerProvider,
+  useIntlayer,
+  useLocale,
+} from "react-native-intlayer";
+```
+
+```bash
+npm install intlayer react-native-intlayer
+```
+
+> Importar desde `react-intlayer` sigue funcionando, pero `react-native-intlayer` es ahora el punto de entrada único recomendado para React Native — su provider incluye los polyfills que el provider de `react-intlayer` (orientado a la web) no contiene.
+
+---
+
 ## Notas de migración desde v8
 
 Si estás actualizando desde v8, ten en cuenta que la v9 no incluye cambios disruptivos. Pero aquí están los cambios clave:
 
+- **Compilador deshabilitado por defecto**: `compiler.enabled` ahora tiene el valor predeterminado `false`. Si dependes de la extracción de tus archivos `.content.ts` en tiempo de compilación, establece `compiler.enabled: true` en tu `intlayer.config.ts`.
 - **Locales y Dialectos**: Si utilizas dependencias i18n externas, añade sus respectivos plugins adaptadores de compatibilidad en tu configuración o setup del bundler para reescribir automáticamente los imports.
-- **Selectores Personalizados**: Al llamar a `useIntlayer`, el segundo parámetro ahora está reservado para un objeto de opciones que contiene `{ locale, item, variant, id }`. Si anteriormente pasabas una cadena de locale directamente, aún puedes hacerlo, pero se recomienda usar el objeto de opciones para selecciones avanzadas.
+- **Selectores Personalizados**: Al llamar a `useIntlayer`, el segundo parámetro ahora está reservado para un objeto de opciones que contiene `{ locale, item, variant }`. Si anteriormente pasabas una cadena de locale directamente, aún puedes hacerlo, pero se recomienda usar el objeto de opciones para selecciones avanzadas.
 
 ---
 
 ## Enlaces útiles
 
 - [Guía de Paquetes Adaptadores de Compatibilidad](https://github.com/aymericzip/intlayer/blob/main/docs/docs/es/compat/index.md)
-- [Diccionarios Dinámicos - Colecciones, Variantes y Registros Dinámicos](https://github.com/aymericzip/intlayer/blob/main/docs/docs/es/dynamic_dictionaries/index.md)
+- [Diccionarios Dinámicos - Colecciones y Variantes](https://github.com/aymericzip/intlayer/blob/main/docs/docs/es/dynamic_dictionaries/index.md)
 - [Referencia de Configuración](https://github.com/aymericzip/intlayer/blob/main/docs/docs/es/configuration.md)

package/docs/fr/compiler.md

@@ -81,12 +81,15 @@ Mettez à jour votre `vite.config.ts` pour inclure le plugin `intlayerCompiler`
 
 ```ts fileName="vite.config.ts"
 import { defineConfig } from "vite";
-import { intlayer, intlayerCompiler } from "vite-intlayer";
+import { intlayer } from "vite-intlayer";
 
 export default defineConfig({
   plugins: [
-    intlayer(),
-    intlayerCompiler(), // Ajoute le plugin du compilateur
+    intlayer({
+      proxy: {
+        ignore: (req) => req.url?.startsWith("/api"),
+      },
+    }),
   ],
 });
 ```

package/docs/fr/custom_domains.md

@@ -172,10 +172,16 @@ Le plugin Vite `intlayerProxy` applique la même logique pendant le développeme
 
 ```typescript fileName="vite.config.ts"
 import { defineConfig } from "vite";
-import { intlayerProxy } from "vite-intlayer";
+import { intlayer } from "vite-intlayer";
 
 export default defineConfig({
-  plugins: [intlayerProxy()],
+  plugins: [
+    intlayer({
+      proxy: {
+        ignore: (req) => req.url?.startsWith("/api"),
+      },
+    }),
+  ],
 });
 ```
 

package/docs/fr/custom_url_rewrites.md

@@ -342,10 +342,16 @@ Pour SolidJS, Vue et Svelte, le plugin Vite `intlayerProxy` gère les réécritu
 
 ```typescript fileName="vite.config.ts"
 import { defineConfig } from "vite";
-import { intlayerProxy } from "vite-intlayer";
+import { intlayer } from "vite-intlayer";
 
 export default defineConfig({
-  plugins: [intlayerProxy()],
+  plugins: [
+    intlayer({
+      proxy: {
+        ignore: (req) => req.url?.startsWith("/api"),
+      },
+    }),
+  ],
 });
 ```
 

package/docs/fr/dynamic_dictionaries/index.md

@@ -1,13 +1,12 @@
 ---
 createdAt: 2026-06-12
-updatedAt: 2026-06-12
-title: Dictionnaires Dynamiques
-description: Présentation des trois fonctionnalités de dictionnaire dynamique d'Intlayer — collections, variantes et enregistrements dynamiques — pour créer un contenu i18n flexible et piloté à l'exécution.
+updatedAt: 2026-06-26
+title: Dictionnaires dynamiques
+description: Vue d'ensemble des fonctionnalités de dictionnaires dynamiques d'Intlayer — collections et variantes — pour créer du contenu i18n flexible et piloté à l'exécution.
 keywords:
-  - Dictionnaires Dynamiques
+  - Dictionnaires dynamiques
   - Collections
   - Variantes
-  - Enregistrements Dynamiques
   - Intlayer
   - Internationalisation
 slugs:
@@ -17,32 +16,39 @@ slugs:
 history:
   - version: 9.0.0
     date: 2026-06-12
-    changes: "Lancement de la fonctionnalité des dictionnaires dynamiques"
+    changes: "Sortie de la fonctionnalité des dictionnaires dynamiques"
+  - version: 9.1.0
+    date: 2026-06-26
+    changes: "Fusion des enregistrements dynamiques dans les variantes — `variant` accepte désormais une chaîne ou un objet"
 author: aymericzip
 ---
 
-# Dictionnaires Dynamiques
+# Dictionnaires dynamiques
 
-Intlayer prend en charge trois mécanismes pour exprimer un contenu qui va au-delà d'un seul dictionnaire statique par clé. Chacun est déclaré via un **champ de métadonnées de premier niveau** dans le fichier de contenu ; aucune fonction d'enveloppement (wrapper) n'est nécessaire.
+Intlayer prend en charge deux mécanismes pour exprimer du contenu qui dépasse un simple dictionnaire statique par clé. Chacun est déclaré via un **champ de métadonnées de premier niveau** dans le fichier de contenu ; aucune fonction d'encapsulation n'est nécessaire.
 
-| Fonctionnalité                                                                                                                      | Champ de métadonnées | Sélecteur dans `useIntlayer` |
-| ----------------------------------------------------------------------------------------------------------------------------------- | -------------------- | ---------------------------- |
-| [Collections](https://github.com/aymericzip/intlayer/blob/main/docs/docs/fr/dynamic_dictionaries/collections.md)                    | `item: N`            | `{ item: N }`                |
-| [Variantes](https://github.com/aymericzip/intlayer/blob/main/docs/docs/fr/dynamic_dictionaries/variants.md)                         | `variant: "name"`    | `{ variant: "name" }`        |
-| [Enregistrements Dynamiques](https://github.com/aymericzip/intlayer/blob/main/docs/docs/fr/dynamic_dictionaries/dynamic_content.md) | `meta: { id, … }`    | `{ id, … }`                  |
+| Fonctionnalité                                                                                                   | Champ de métadonnées                    | Sélecteur dans `useIntlayer`                    |
+| ---------------------------------------------------------------------------------------------------------------- | --------------------------------------- | ----------------------------------------------- |
+| [Collections](https://github.com/aymericzip/intlayer/blob/main/docs/docs/fr/dynamic_dictionaries/collections.md) | `item: N`                               | `{ item: N }`                                   |
+| [Variantes](https://github.com/aymericzip/intlayer/blob/main/docs/docs/fr/dynamic_dictionaries/variants.md)      | `variant: "name"` _ou_ `variant: { … }` | `{ variant: "name" }` _ou_ `{ variant: { … } }` |
 
-Tous trois se composent avec l'argument de locale et prennent en charge le chargement sélectif / différé via `importMode`.
+Les deux se combinent avec l'argument de locale et prennent en charge le chargement sélectif / différé via `importMode`.
 
-## Quand utiliser lequel
+## Quand utiliser quoi
 
 - **Collections** — liste ordonnée d'éléments gérés dans des fichiers séparés (entrées de FAQ, articles de blog, produits).
-- **Variantes** — alternatives de contenu nommées pour les tests A/B, les bannières saisonnières ou les feature flags (drapeaux de fonctionnalités).
-- **Enregistrements dynamiques** — contenu récupéré au moment de l'exécution à l'aide d'un identifiant opaque (enregistrements CMS, copie spécifique à l'utilisateur).
+- **Variantes** — alternatives de contenu nommées ou structurées :
+  - une variante **chaîne** pour les tests A/B, les bannières saisonnières ou les feature flags ;
+  - une variante **objet** pour les enregistrements de CMS, le contenu propre à un utilisateur ou tout contenu adressé par un ensemble de champs (les anciens « enregistrements dynamiques »).
 
-## Résolution des conflits de sélecteurs
+> Les versions précédentes exposaient un champ `meta` distinct pour le contenu indexé par enregistrement. Il a été fusionné dans `variant` : passez un **objet** à `variant` au lieu d'utiliser `meta`.
 
-Lorsque plusieurs sélecteurs sont présents sur un dictionnaire, l'ordre de résolution est :
+## Désambiguïsation du sélecteur
+
+Une clé peut déclarer les deux dimensions à la fois (par ex. une collection dont chaque élément possède une variante). Elles sont résolues dans l'ordre :
 
 ```
-variant → meta → item
+variant → item
 ```
+
+Ainsi `{ variant: "promo" }` sur une clé variante × item renvoie tous les éléments promo sous forme de tableau, et ajouter `{ item: 2 }` réduit le résultat à une seule entrée.