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

package/docs/fr/dynamic_dictionaries/variants.md

@@ -1,13 +1,15 @@
 ---
 createdAt: 2026-06-12
-updatedAt: 2026-06-12
+updatedAt: 2026-06-26
 title: Variantes
-description: Utilisez le champ de métadonnées de variante dans les fichiers de contenu Intlayer pour déclarer des alternatives de contenu nommées (tests A/B, bannières saisonnières, texte avec feature flags) et basculez entre elles au moment de l'exécution sans modification de code.
+description: Utilisez le champ de métadonnées variant dans les fichiers de contenu Intlayer pour déclarer des alternatives de contenu nommées ou structurées — tests A/B, bannières saisonnières, contenu sous feature flag, enregistrements de CMS, contenu propre à un utilisateur — et basculer entre elles à l'exécution sans changement de code.
 keywords:
   - Variantes
   - Tests A/B
   - Feature Flags
-  - Contenu Dynamique
+  - Contenu dynamique
+  - Enregistrements dynamiques
+  - CMS
   - Intlayer
   - Internationalisation
 slugs:
@@ -17,15 +19,25 @@ slugs:
 history:
   - version: 9.0.0
     date: 2026-06-12
-    changes: "Lancement de la fonctionnalité des variantes de dictionnaires"
+    changes: "Sortie de la fonctionnalité des variantes"
+  - version: 9.1.0
+    date: 2026-06-26
+    changes: "`variant` accepte désormais une chaîne ou un objet — les anciens `meta` / enregistrements dynamiques se déclarent comme variantes objet"
 author: aymericzip
 ---
 
 # Variantes
 
-Une **variante** est un ensemble de fichiers de contenu qui partagent la même clé de dictionnaire (`key`) mais portent chacun un nom de variante (`variant`) différent. Intlayer sert le fichier approprié en fonction du sélecteur passé à `useIntlayer`.
+Une **variante** est un ensemble de fichiers de contenu qui partagent la même clé de dictionnaire (`key`) mais portent chacun une valeur `variant` différente. Intlayer sert le fichier approprié en fonction du sélecteur passé à `useIntlayer`.
 
-## Déclarer des variantes
+La valeur `variant` peut prendre **deux formes** :
+
+- **Une chaîne** — une seule alternative nommée (tests A/B, bannières saisonnières, feature flags).
+- **Un objet** — un discriminant structuré adressé par un ensemble de champs (enregistrements de CMS, contenu propre à un utilisateur, tout contenu indexé par un identifiant opaque). L'objet entier constitue l'identité : le sélecteur doit fournir un objet **égal** pour résoudre l'entrée.
+
+> La forme objet remplace l'ancien champ `meta`. Partout où vous écriviez `meta: { id, … }`, écrivez `variant: { id, … }`, et sélectionnez-la avec `{ variant: { id, … } }`.
+
+## Variantes nommées (chaîne)
 
 Chaque fichier représente une alternative nommée. Omettre `variant` (ou le définir sur `"default"`) le marque comme valeur par défaut (fallback).
 
@@ -65,9 +77,9 @@ const dictionary = {
 export default dictionary;
 ```
 
-## Consommer des variantes
+### Consommer des variantes nommées
 
-### Variante par défaut
+#### Variante par défaut
 
 <Tabs group="framework">
   <Tab label="React" value="react">
@@ -209,7 +221,7 @@ export default dictionary;
   </Tab>
 </Tabs>
 
-### Variante nommée
+#### Variante nommée
 
 ```tsx
 const { headline, cta } = useIntlayer("hero-banner", {
@@ -217,7 +229,7 @@ const { headline, cta } = useIntlayer("hero-banner", {
 });
 ```
 
-### Variante nommée avec locale explicite
+#### Variante nommée avec locale explicite
 
 ```tsx
 const content = useIntlayer("hero-banner", {
@@ -226,9 +238,255 @@ const content = useIntlayer("hero-banner", {
 });
 ```
 
-## Cas d'utilisation typiques
+## Variantes objet (structurées)
+
+Une variante objet adresse le contenu par un ensemble arbitraire de paires clé-valeur déclarées dans le champ `variant` — permettant de modéliser des enregistrements de CMS, du contenu propre à un utilisateur ou tout contenu dont la clé est un identifiant opaque. L'**objet entier** constitue l'identité : le sélecteur doit fournir un objet égal pour que l'entrée soit résolue.
+
+```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;
+```
+
+### Consommer des variantes objet
+
+Passez l'objet correspondant à `variant`. Chaque champ déclaré sur le dictionnaire doit être fourni et égal ; sinon le résultat est `null`. L'ordre des champs n'a pas d'importance.
+
+<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>
+
+#### Avec une locale explicite
+
+```tsx
+const content = useIntlayer("product", {
+  variant: { id: "prod_abc", userId: "user_123" },
+  locale: "fr",
+});
+```
+
+#### Champ manquant — aucune correspondance
+
+```ts
+// Renvoie null : `userId` est manquant, donc l'objet ne correspond pas à la variante déclarée
+const content = useIntlayer("product", { variant: { id: "prod_abc" } });
+```
+
+## Mode de chargement
+
+Les variantes objet sont souvent chargées de façon différée. Définissez `importMode` sur le dictionnaire pour contrôler ce comportement :
+
+```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;
+```
+
+Voir [optimisation du bundle](https://github.com/aymericzip/intlayer/blob/main/docs/docs/fr/bundle_optimization.md) pour les détails sur les modes `static`, `dynamic` et `fetch`.
+
+## Cas d'usage typiques
 
-- Tests A/B pilotés par une clé d'expérimentation
-- Bannières promotionnelles ou saisonnières
-- Messages soumis à des feature flags
-- Campagnes marketing spécifiques à une zone géographique
+- Tests A/B de texte pilotés par une clé d'expérience
+- Bannières saisonnières ou promotionnelles
+- Messages sous feature flag
+- Campagnes marketing spécifiques à une locale
+- Texte marketing par produit géré dans un CMS
+- Contenu propre à un utilisateur ou à un compte
+- Tout contenu indexé par un identifiant opaque à l'exécution

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

@@ -108,7 +108,6 @@ const config: IntlayerConfig = {
      * Chargera et écrira la sortie et les traductions dans les fichiers JSON du répertoire locales
      */
     syncJSON({
-      format: "i18next",
       source: ({ key, locale }) => `./locales/${locale}/${key}.json`,
       priority: 0,
       format: "i18next",

package/docs/fr/releases/v9.md

@@ -1,15 +1,14 @@
 ---
 createdAt: 2026-06-14
-updatedAt: 2026-06-25
+updatedAt: 2026-06-26
 title: Nouvel Intlayer v9 - Quoi de neuf ?
-description: Découvrez les nouveautés d'Intlayer v9. Présentation des packages de compatibilité prêts à l'emploi pour les bibliothèques i18n populaires et prise en charge des Collections, Variants et Dynamic Records.
+description: Découvrez les nouveautés d'Intlayer v9. Présentation des packages de compatibilité prêts à l'emploi pour les bibliothèques i18n populaires et prise en charge des Collections et Variants.
 keywords:
   - Intlayer
   - Compatibility
   - Migration
   - Collections
   - Variants
-  - Dynamic Records
   - i18next
   - next-intl
   - vue-i18n
@@ -22,7 +21,7 @@ author: aymericzip
 
 # Nouvel Intlayer v9 - Quoi de neuf ?
 
-Bienvenue sur Intlayer v9 ! Cette version majeure marque une étape importante dans la simplification du chemin de migration vers Intlayer avec les **packages d'adaptateurs de compatibilité** pour les principales bibliothèques i18n (`react-i18next`, `next-intl`, `vue-i18n`, etc.) et ajoute la prise en charge de structures de contenu riches : les **Collections**, les **Variants** et les **Dynamic Records**.
+Bienvenue sur Intlayer v9 ! Cette version majeure marque une étape importante dans la simplification du chemin de migration vers Intlayer avec les **packages d'adaptateurs de compatibilité** pour les principales bibliothèques i18n (`react-i18next`, `next-intl`, `vue-i18n`, etc.) et ajoute la prise en charge de structures de contenu riches : les **Collections** et les **Variants**.
 
 ## Table des matières
 
@@ -41,8 +40,10 @@ En remplaçant les imports, vous bénéficiez de tous les avantages d'Intlayer (
 - `@intlayer/i18next`
 - `@intlayer/react-i18next`
 - `@intlayer/next-intl`
+- `@intlayer/react-intl`
 - `@intlayer/next-i18next`
 - `@intlayer/vue-i18n`
+- `@intlayer/lingui`
 
 Par exemple, changez simplement :
 
@@ -100,7 +101,7 @@ Tous les adaptateurs de compatibilité acheminent désormais la résolution des
 
 ---
 
-## Spécification des fonctionnalités : Collections, Variants & Dynamic Records
+## Spécification des fonctionnalités : Collections & Variants
 
 Intlayer v9 va au-delà des objets clé-valeur statiques, permettant aux dictionnaires de déclarer des structures de mise en page dynamiques entièrement typées de bout en bout.
 
@@ -136,6 +137,8 @@ const faq = useIntlayer("faq", { item: 1 }); // -> { question: string, answer: s
 
 Proposez des tests A/B, des en-têtes saisonniers, des feature flags ou des pages de destination personnalisées :
 
+#### Variantes de chaîne (ex. tests A/B)
+
 ```ts fileName="hero.content.ts"
 import { t, type Dictionary } from "intlayer";
 
@@ -155,16 +158,14 @@ export default {
 const banner = useIntlayer("hero-banner", { variant: "black_friday" });
 ```
 
-### 3. Dynamic Records
-
-Définissez des dictionnaires dont les entrées sont chargées dynamiquement au moment de l'exécution via des ID de requête :
+#### Variantes d'objet (ex. 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",
   },
@@ -217,7 +218,7 @@ export default defineConfig({
 });
 ```
 
-- **Compilateur** : S'active automatiquement lorsque `compiler.enabled` est défini et qu'un chemin `compiler.output` est configuré. Vous n'avez plus besoin d'enregistrer `intlayerCompiler()` séparément.
+- **Compilateur** : S'active automatiquement lorsque `compiler.enabled` est défini à `true` et qu'un chemin `compiler.output` est configuré. Vous n'avez plus besoin d'enregistrer `intlayerCompiler()` séparément.
 - **Proxy** : S'active automatiquement en fonction de la nouvelle option `routing.enableProxy` (`true` par défaut). Il connecte le middleware de détection de locale / redirection / réécriture en développement, en aperçu et en SSR de production. Vous n'avez plus besoin d'enregistrer `intlayerProxy()` séparément.
 
 ### Option `routing.enableProxy`
@@ -240,6 +241,27 @@ Les plugins autonomes `intlayerCompiler()` et `intlayerProxy()` restent exporté
 
 ---
 
+## Compilateur désactivé par défaut
+
+Depuis Intlayer v9, le **compilateur est désactivé par défaut** (`compiler.enabled` vaut désormais `false` par défaut). Pour activer l'extraction de vos fichiers `.content.ts` au moment du build, définissez `compiler.enabled: true` dans votre configuration :
+
+```ts fileName="intlayer.config.ts"
+import type { IntlayerConfig } from "intlayer";
+
+const config: IntlayerConfig = {
+  compiler: {
+    enabled: true, // Par défaut : false — requis pour activer le compilateur depuis la v9
+    output: ({ fileName }) => `./${fileName}.content.ts`,
+  },
+};
+
+export default config;
+```
+
+Lorsque le compilateur est désactivé, Intlayer ignore l'étape d'extraction au build et s'appuie sur vos dictionnaires déjà déclarés. Activez-le uniquement lorsque vous souhaitez que le plugin de bundler (`@intlayer/swc`, `@intlayer/babel`, ou le plugin Vite `intlayer()`) extraie le contenu automatiquement.
+
+---
+
 ## React Native : imports depuis un seul package
 
 Dans une application React Native ou Expo, vous n'avez plus besoin de jongler entre `react-intlayer` et `react-native-intlayer`. Le package `react-native-intlayer` **réexporte désormais l'intégralité de l'API `react-intlayer`** (hooks, utilitaires et les sous-chemins `/format`, `/html`, et `/markdown`), et son `IntlayerProvider` applique automatiquement les polyfills React Native.
@@ -266,13 +288,14 @@ npm install intlayer react-native-intlayer
 
 Si vous effectuez une mise à niveau depuis la v8, notez que la v9 n'inclut pas de changements majeurs (breaking changes). Voici cependant les changements clés :
 
+- **Compilateur désactivé par défaut** : `compiler.enabled` vaut désormais `false` par défaut. Si vous dépendez de l'extraction de vos fichiers `.content.ts` au build, définissez `compiler.enabled: true` dans votre `intlayer.config.ts`.
 - **Locales et dialectes** : Si vous utilisez des dépendances i18n externes, ajoutez leurs plugins d'adaptateur de compatibilité respectifs dans votre configuration ou votre setup de bundler pour réécrire automatiquement les imports.
-- **Sélecteurs personnalisés** : Lors de l'appel de `useIntlayer`, le deuxième paramètre est désormais réservé à un objet d'options contenant `{ locale, item, variant, id }`. Si vous passiez auparavant une chaîne de caractères de locale directement, vous pouvez toujours le faire, mais l'utilisation de l'objet d'options est recommandée pour les sélections avancées.
+- **Sélecteurs personnalisés** : Lors de l'appel de `useIntlayer`, le deuxième paramètre est désormais réservé à un objet d'options contenant `{ locale, item, variant }`. Si vous passiez auparavant une chaîne de caractères de locale directement, vous pouvez toujours le faire, mais l'utilisation de l'objet d'options est recommandée pour les sélections avancées.
 
 ---
 
 ## Liens utiles
 
 - [Guide des packages d'adaptateurs de compatibilité](https://github.com/aymericzip/intlayer/blob/main/docs/docs/fr/compat/index.md)
-- [Dictionnaires dynamiques - Collections, Variants & Dynamic Records](https://github.com/aymericzip/intlayer/blob/main/docs/docs/fr/dynamic_dictionaries/index.md)
+- [Dictionnaires dynamiques - Collections & Variants](https://github.com/aymericzip/intlayer/blob/main/docs/docs/fr/dynamic_dictionaries/index.md)
 - [Référence de configuration](https://github.com/aymericzip/intlayer/blob/main/docs/docs/fr/configuration.md)

package/docs/hi/dynamic_dictionaries/index.md

@@ -1,13 +1,12 @@
 ---
 createdAt: 2026-06-12
-updatedAt: 2026-06-12
-title: डायनेमिक डिक्शनरीज़
-description: लचीली, रनटाइम-संचालित i18n सामग्री के निर्माण के लिए Intlayer की तीन डायनेमिक डिक्शनरी सुविधाओं — संग्रह, वेरिएंट और डायनेमिक रिकॉर्ड का अवलोकन।
+updatedAt: 2026-06-26
+title: डायनेमिक डिक्शनरी
+description: Intlayer की डायनेमिक डिक्शनरी सुविधाओं — कलेक्शन और वैरिएंट — का अवलोकन, लचीली, रनटाइम-संचालित i18n सामग्री बनाने के लिए।
 keywords:
-  - डायनेमिक डिक्शनरीज़
-  - संग्रह
-  - वेरिएंट
-  - डायनेमिक रिकॉर्ड
+  - डायनेमिक डिक्शनरी
+  - कलेक्शन
+  - वैरिएंट
   - Intlayer
   - अंतर्राष्ट्रीयकरण
 slugs:
@@ -17,32 +16,39 @@ slugs:
 history:
   - version: 9.0.0
     date: 2026-06-12
-    changes: "डायनेमिक डिक्शनरी सुविधा का विमोचन"
+    changes: "डायनेमिक डिक्शनरी सुविधा का रिलीज़"
+  - version: 9.1.0
+    date: 2026-06-26
+    changes: "डायनेमिक रिकॉर्ड को वैरिएंट में मिला दिया गया — अब `variant` एक स्ट्रिंग या ऑब्जेक्ट स्वीकार करता है"
 author: aymericzip
 ---
 
-# डायनेमिक डिक्शनरीज़
+# डायनेमिक डिक्शनरी
 
-Intlayer सामग्री को व्यक्त करने के लिए तीन तंत्रों का समर्थन करता है जो प्रति कुंजी एकल स्थिर डिक्शनरी से परे जाते हैं। प्रत्येक को सामग्री फ़ाइल में **शीर्ष-स्तरीय मेटाडेटा फ़ील्ड** के माध्यम से घोषित किया जाता है; किसी रैपर फ़ंक्शन की आवश्यकता नहीं होती है।
+Intlayer ऐसी सामग्री व्यक्त करने के लिए दो तंत्रों का समर्थन करता है जो प्रति key एक ही स्थिर डिक्शनरी से आगे जाती है। प्रत्येक को सामग्री फ़ाइल में एक **शीर्ष-स्तरीय मेटाडेटा फ़ील्ड** के माध्यम से घोषित किया जाता है; किसी रैपर फ़ंक्शन की आवश्यकता नहीं है।
 
-| विशेषता                                                                                                                   | मेटाडेटा फ़ील्ड   | `useIntlayer` में चयनकर्ता |
-| ------------------------------------------------------------------------------------------------------------------------- | ----------------- | -------------------------- |
-| [संग्रह](https://github.com/aymericzip/intlayer/blob/main/docs/docs/hi/dynamic_dictionaries/collections.md)               | `item: N`         | `{ item: N }`              |
-| [वेरिएंट](https://github.com/aymericzip/intlayer/blob/main/docs/docs/hi/dynamic_dictionaries/variants.md)                 | `variant: "name"` | `{ variant: "name" }`      |
-| [डायनेमिक रिकॉर्ड](https://github.com/aymericzip/intlayer/blob/main/docs/docs/hi/dynamic_dictionaries/dynamic_content.md) | `meta: { id, … }` | `{ id, … }`                |
+| सुविधा                                                                                                       | मेटाडेटा फ़ील्ड                         | `useIntlayer` में सेलेक्टर                      |
+| ------------------------------------------------------------------------------------------------------------ | --------------------------------------- | ----------------------------------------------- |
+| [कलेक्शन](https://github.com/aymericzip/intlayer/blob/main/docs/docs/hi/dynamic_dictionaries/collections.md) | `item: N`                               | `{ item: N }`                                   |
+| [वैरिएंट](https://github.com/aymericzip/intlayer/blob/main/docs/docs/hi/dynamic_dictionaries/variants.md)    | `variant: "name"` _या_ `variant: { … }` | `{ variant: "name" }` _या_ `{ variant: { … } }` |
 
-तीनों भाषा विकल्प (locale) तर्क के साथ मिलकर काम करते हैं और `importMode` के माध्यम से चुनिंदा / आलसी (lazy) लोडिंग का समर्थन करते हैं।
+दोनों locale तर्क के साथ संयोजित होते हैं और `importMode` के माध्यम से चयनात्मक / आलसी लोडिंग का समर्थन करते हैं।
 
 ## कब किसका उपयोग करें
 
-- **संग्रह (Collections)** — अलग फ़ाइलों में प्रबंधित वस्तुओं की क्रमबद्ध सूची (FAQ प्रविष्टियां, ब्लॉग पोस्ट, उत्पाद)।
-- **वेरिएंट (Variants)** — A/B परीक्षण, मौसमी बैनर, या फीचर फ़्लैग के लिए नामांकित सामग्री विकल्प।
-- **डायनेमिक रिकॉर्ड (Dynamic records)** — अपारदर्शी आईडी द्वारा रनटाइम पर प्राप्त सामग्री (CMS रिकॉर्ड, उपयोगकर्ता-विशिष्ट प्रतिलिपि)।
+- **कलेक्शन** — अलग-अलग फ़ाइलों में प्रबंधित आइटम की क्रमबद्ध सूची (FAQ प्रविष्टियाँ, ब्लॉग पोस्ट, उत्पाद)।
+- **वैरिएंट** — नामित या संरचित सामग्री विकल्प:
+  - A/B परीक्षण, मौसमी बैनर या फ़ीचर फ़्लैग के लिए एक **स्ट्रिंग** वैरिएंट;
+  - CMS रिकॉर्ड, उपयोगकर्ता-विशिष्ट सामग्री, या फ़ील्ड के सेट द्वारा संबोधित किसी भी सामग्री के लिए एक **ऑब्जेक्ट** वैरिएंट (पूर्व "डायनेमिक रिकॉर्ड")।
 
-## चयनकर्ता स्पष्टीकरण
+> पुराने संस्करण रिकॉर्ड-कुंजीबद्ध सामग्री के लिए एक अलग `meta` फ़ील्ड प्रदान करते थे। इसे `variant` में मिला दिया गया है: `meta` का उपयोग करने के बजाय `variant` में एक **ऑब्जेक्ट** पास करें।
 
-जब किसी डिक्शनरी पर एकाधिक चयनकर्ता मौजूद होते हैं, तो रिज़ॉल्यूशन का क्रम होता है:
+## सेलेक्टर असंदिग्धीकरण
+
+एक key एक साथ दोनों आयाम घोषित कर सकती है (उदा. एक कलेक्शन जिसके प्रत्येक आइटम का एक वैरिएंट हो)। इन्हें इस क्रम में हल किया जाता है:
 
 ```
-variant → meta → item
+variant → item
 ```
+
+इस प्रकार, किसी variant × item key पर `{ variant: "promo" }` सभी promo आइटम को एक array के रूप में लौटाता है, और `{ item: 2 }` जोड़ने से यह एक ही प्रविष्टि तक सीमित हो जाता है।