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

package/docs/es/dynamic_dictionaries/variants.md

@@ -1,13 +1,15 @@
 ---
 createdAt: 2026-06-12
-updatedAt: 2026-06-12
+updatedAt: 2026-06-26
 title: Variantes
-description: Utilice el campo de metadatos de variante en los archivos de contenido de Intlayer para declarar alternativas de contenido nombradas (pruebas A/B, banners de temporada, copia con indicadores de función) y cambie entre ellas en tiempo de ejecución sin cambios de código.
+description: Use el campo de metadatos variant en los archivos de contenido de Intlayer para declarar alternativas de contenido con nombre o estructuradas — pruebas A/B, banners de temporada, copia con feature flag, registros de CMS, contenido específico de usuario — y cambiar entre ellas en tiempo de ejecución sin cambios de código.
 keywords:
   - Variantes
   - Pruebas A/B
-  - Indicadores de Funciones
-  - Contenido Dinámico
+  - Feature Flags
+  - Contenido dinámico
+  - Registros dinámicos
+  - CMS
   - Intlayer
   - Internacionalización
 slugs:
@@ -17,17 +19,27 @@ slugs:
 history:
   - version: 9.0.0
     date: 2026-06-12
-    changes: "Lanzamiento de la función de variantes de diccionarios"
+    changes: "Lanzamiento de la función de variantes"
+  - version: 9.1.0
+    date: 2026-06-26
+    changes: "`variant` ahora acepta una cadena o un objeto — los antiguos `meta` / registros dinámicos se declaran como variantes de objeto"
 author: aymericzip
 ---
 
 # Variantes
 
-Una **variante** es un conjunto de archivos de contenido que comparten la misma clave de diccionario (`key`) pero cada uno lleva un nombre de variante (`variant`) diferente. Intlayer sirve el archivo apropiado en función del selector pasado a `useIntlayer`.
+Una **variante** es un conjunto de archivos de contenido que comparten la misma clave de diccionario (`key`) pero llevan cada uno un valor `variant` diferente. Intlayer sirve el archivo adecuado según el selector pasado a `useIntlayer`.
 
-## Declarar variantes
+El valor de `variant` puede adoptar **dos formas**:
 
-Cada archivo representa una alternativa nombrada. Omitir `variant` (o establecerlo en `"default"`) lo marca como la variante por defecto (fallback).
+- **Una cadena** — una única alternativa con nombre (pruebas A/B, banners de temporada, feature flags).
+- **Un objeto** — un discriminador estructurado direccionado por un conjunto de campos (registros de CMS, contenido específico de usuario, cualquier contenido indexado por un ID opaco). El objeto completo es la identidad: el selector debe proporcionar un objeto **igual** para resolver la entrada.
+
+> La forma de objeto sustituye al antiguo campo `meta`. Donde antes escribía `meta: { id, … }`, escriba `variant: { id, … }`, y selecciónela con `{ variant: { id, … } }`.
+
+## Variantes con nombre (cadena)
+
+Cada archivo representa una alternativa con nombre. Omitir `variant` (o establecerlo en `"default"`) lo marca como el valor de reserva.
 
 ```ts fileName="hero-banner.content.ts" contentDeclarationFormat={["typescript", "esm", "commonjs"]}
 import { t, type Dictionary } from "intlayer";
@@ -65,9 +77,9 @@ const dictionary = {
 export default dictionary;
 ```
 
-## Consumir variantes
+### Consumir variantes con nombre
 
-### Variante por defecto
+#### Variante por defecto
 
 <Tabs group="framework">
   <Tab label="React" value="react">
@@ -209,7 +221,7 @@ export default dictionary;
   </Tab>
 </Tabs>
 
-### Variante nombrada
+#### Variante con nombre
 
 ```tsx
 const { headline, cta } = useIntlayer("hero-banner", {
@@ -217,18 +229,264 @@ const { headline, cta } = useIntlayer("hero-banner", {
 });
 ```
 
-### Variante nombrada con configuración regional explícita
+#### Variante con nombre con locale explícito
 
 ```tsx
 const content = useIntlayer("hero-banner", {
   variant: "black_friday",
-  locale: "es",
+  locale: "fr",
 });
 ```
 
+## Variantes de objeto (estructuradas)
+
+Una variante de objeto direcciona el contenido mediante un conjunto arbitrario de pares clave-valor declarados en el campo `variant` — lo que permite modelar registros de CMS, contenido específico de usuario o cualquier contenido cuya clave sea un ID opaco. El **objeto completo** es la identidad: el selector debe proporcionar un objeto igual para que la entrada se resuelva.
+
+```ts fileName="product.abc.content.ts" contentDeclarationFormat={["typescript", "esm", "commonjs"]}
+import { t, type Dictionary } from "intlayer";
+
+const dictionary = {
+  key: "product",
+  variant: { id: "prod_abc", userId: "user_123" },
+  content: {
+    name: t({ en: "Widget Pro", fr: "Widget Pro" }),
+    description: t({ en: "The best widget.", fr: "Le meilleur widget." }),
+  },
+} satisfies Dictionary;
+
+export default dictionary;
+```
+
+```ts fileName="product.abcd.content.ts" contentDeclarationFormat={["typescript", "esm", "commonjs"]}
+import { t, type Dictionary } from "intlayer";
+
+const dictionary = {
+  key: "product",
+  variant: { id: "prod_abcd", userId: "user_123" },
+  content: {
+    name: t({ en: "Widget Lite", fr: "Widget Lite" }),
+    description: t({ en: "A lighter option.", fr: "Une option plus légère." }),
+  },
+} satisfies Dictionary;
+
+export default dictionary;
+```
+
+### Consumir variantes de objeto
+
+Pase el objeto coincidente a `variant`. Cada campo declarado en el diccionario debe proporcionarse e ser igual; de lo contrario el resultado es `null`. El orden de los campos no importa.
+
+<Tabs group="framework">
+  <Tab label="React" value="react">
+    ```tsx fileName="Product.tsx" contentDeclarationFormat={["typescript", "esm", "commonjs"]}
+    import { useIntlayer } from "react-intlayer";
+
+    export const Product = ({
+      productId,
+      userId,
+    }: {
+      productId: string;
+      userId: string;
+    }) => {
+      const content = useIntlayer("product", {
+        variant: { id: productId, userId },
+      });
+
+      if (!content) return null;
+
+      return <p>{content.description}</p>;
+    };
+    ```
+
+  </Tab>
+  <Tab label="Next.js" value="nextjs">
+    ```tsx fileName="Product.tsx" contentDeclarationFormat={["typescript", "esm", "commonjs"]}
+    import { useIntlayer } from "next-intlayer";
+
+    export const Product = ({
+      productId,
+      userId,
+    }: {
+      productId: string;
+      userId: string;
+    }) => {
+      const content = useIntlayer("product", {
+        variant: { id: productId, userId },
+      });
+
+      if (!content) return null;
+
+      return <p>{content.description}</p>;
+    };
+    ```
+
+  </Tab>
+  <Tab label="Vue" value="vue">
+    ```vue fileName="Product.vue" contentDeclarationFormat={["typescript", "esm", "commonjs"]}
+    <script setup>
+    import { useIntlayer } from "vue-intlayer";
+
+    const props = defineProps({
+      productId: String,
+      userId: String,
+    });
+
+    const content = useIntlayer("product", {
+      variant: { id: props.productId, userId: props.userId },
+    });
+    </script>
+
+    <template>
+      <p v-if="content">{{ content.description }}</p>
+    </template>
+    ```
+
+  </Tab>
+  <Tab label="Svelte" value="svelte">
+    ```svelte fileName="Product.svelte" contentDeclarationFormat={["typescript", "esm", "commonjs"]}
+    <script lang="ts">
+    import { useIntlayer } from "svelte-intlayer";
+
+    export let productId: string;
+    export let userId: string;
+
+    const content = useIntlayer("product", {
+      variant: { id: productId, userId },
+    });
+    </script>
+
+    {#if $content}
+      <p>{$content.description}</p>
+    {/if}
+    ```
+
+  </Tab>
+  <Tab label="Preact" value="preact">
+    ```tsx fileName="Product.tsx" contentDeclarationFormat={["typescript", "esm", "commonjs"]}
+    import { useIntlayer } from "preact-intlayer";
+
+    export const Product = ({
+      productId,
+      userId,
+    }: {
+      productId: string;
+      userId: string;
+    }) => {
+      const content = useIntlayer("product", {
+        variant: { id: productId, userId },
+      });
+
+      if (!content) return null;
+
+      return <p>{content.description}</p>;
+    };
+    ```
+
+  </Tab>
+  <Tab label="Solid" value="solid">
+    ```tsx fileName="Product.tsx" contentDeclarationFormat={["typescript", "esm", "commonjs"]}
+    import { useIntlayer } from "solid-intlayer";
+
+    export const Product = (props: {
+      productId: string;
+      userId: string;
+    }) => {
+      const content = useIntlayer("product", {
+        variant: { id: props.productId, userId: props.userId },
+      });
+
+      return (
+        <>
+          {content() && <p>{content().description}</p>}
+        </>
+      );
+    };
+    ```
+
+  </Tab>
+  <Tab label="Angular" value="angular">
+    ```typescript fileName="product.component.ts" contentDeclarationFormat={["typescript", "esm", "commonjs"]}
+    import { Component, Input, OnInit } from "@angular/core";
+    import { useIntlayer } from "angular-intlayer";
+
+    @Component({
+      selector: "app-product",
+      template: `
+        @if (content()) {
+          <p>{{ content().description }}</p>
+        }
+      `,
+    })
+    export class ProductComponent implements OnInit {
+      @Input() productId!: string;
+      @Input() userId!: string;
+
+      content: any;
+
+      ngOnInit() {
+        this.content = useIntlayer("product", {
+          variant: { id: this.productId, userId: this.userId },
+        });
+      }
+    }
+    ```
+
+  </Tab>
+  <Tab label="Vanilla JS" value="vanilla">
+    ```javascript fileName="product.js"
+    import { useIntlayer } from "vanilla-intlayer";
+
+    const content = useIntlayer("product", {
+      variant: { id: "prod_abcd", userId: "user_123" },
+    });
+
+    if (content) {
+      document.body.innerHTML = `<p>${content.description}</p>`;
+    }
+    ```
+
+  </Tab>
+</Tabs>
+
+#### Con locale explícito
+
+```tsx
+const content = useIntlayer("product", {
+  variant: { id: "prod_abc", userId: "user_123" },
+  locale: "fr",
+});
+```
+
+#### Campo faltante — sin coincidencia
+
+```ts
+// Devuelve null: falta `userId`, por lo que el objeto no coincide con la variante declarada
+const content = useIntlayer("product", { variant: { id: "prod_abc" } });
+```
+
+## Modo de carga
+
+Las variantes de objeto suelen cargarse de forma diferida. Establezca `importMode` en el diccionario para controlarlo:
+
+```ts contentDeclarationFormat={["typescript", "esm", "commonjs"]}
+const dictionary = {
+  key: "product",
+  importMode: "fetch", // or "dynamic"
+  variant: { id: "prod_abc", userId: "user_123" },
+  content: { … },
+} satisfies Dictionary;
+
+export default dictionary;
+```
+
+Consulte [optimización del bundle](https://github.com/aymericzip/intlayer/blob/main/docs/docs/es/bundle_optimization.md) para detalles sobre los modos `static`, `dynamic` y `fetch`.
+
 ## Casos de uso típicos
 
-- Pruebas A/B impulsadas por una clave de experimento
-- Banners promocionales o estacionales
-- Mensajes bajo indicadores de función (feature flags)
-- Campañas de marketing específicas para una región
+- Pruebas A/B de texto dirigidas por una clave de experimento
+- Banners de temporada o promocionales
+- Mensajería con feature flag
+- Campañas de marketing específicas por locale
+- Copia de marketing por producto gestionada en un CMS
+- Contenido específico de usuario o de cuenta
+- Cualquier contenido indexado por un ID opaco en tiempo de ejecución

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-25
+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,6 +249,27 @@ 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.
@@ -274,13 +296,14 @@ npm install intlayer react-native-intlayer
 
 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/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.