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

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

@@ -0,0 +1,92 @@
+---
+createdAt: 2026-06-25
+updatedAt: 2026-06-25
+title: Documentation du plugin Vite intlayerMinify | vite-intlayer
+description: Plugin Vite qui minifie les fichiers JSON de dictionnaire Intlayer compilés et réduit éventuellement la taille du bundle en masquant les noms des champs de contenu.
+keywords:
+  - intlayerMinify
+  - vite
+  - plugin
+  - minifier
+  - taille du bundle
+  - dictionnaire
+  - internationalisation
+  - i18n
+slugs:
+  - doc
+  - packages
+  - vite-intlayer
+  - intlayerMinify
+history:
+  - version: 9.0.0
+    date: 2026-06-25
+    changes: "Initialisation de la doc"
+author: aymericzip
+---
+
+# intlayerMinify
+
+`intlayerMinify` est un plugin Vite qui minifie les fichiers JSON de dictionnaire compilés lors d'un build de production. Il supprime tous les espaces inutiles et, lorsqu'il est combiné avec `intlayerPrune`, renomme éventuellement les noms des champs de contenu en alias alphabétiques courts (`a`, `b`, `c`, …) pour réduire davantage la taille du bundle.
+
+> Le plugin est déjà inclus et configuré automatiquement lorsque vous utilisez [`intlayer()`](https://github.com/aymericzip/intlayer/blob/main/docs/docs/fr/packages/vite-intlayer/intlayer.md). Vous n'avez besoin de l'enregistrer manuellement que si vous composez vous-même la pile de plugins.
+
+## Utilisation
+
+```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),
+  ],
+});
+```
+
+## Conditions d'activation
+
+`intlayerMinify` est actif **uniquement** lorsque les trois conditions suivantes sont remplies :
+
+1. La commande Vite est `build` (pas `serve` / dev).
+2. `build.optimize` est à `true` (ou `undefined`, qui vaut par défaut `true` pour les builds).
+3. `build.minify` est à `true` dans votre configuration Intlayer.
+
+Il est automatiquement **désactivé** lorsque `editor.enabled` est à `true` car l'éditeur a besoin du contenu complet et lisible par l'homme du dictionnaire.
+
+## Ce qui est minifié
+
+Le plugin cible deux emplacements de dictionnaire (tels que résolus depuis `intlayer.system`) :
+
+- `dictionariesDir` — dictionnaires statiques toutes langues (ex. `.intlayer/dictionaries/*.json`)
+- `dynamicDictionariesDir` — dictionnaires dynamiques par langue
+
+> Les dictionnaires en mode fetch (`fetchDictionariesDir`) ne sont **jamais** minifiés car ils sont servis depuis une API distante au moment de l'exécution en utilisant leurs noms de champs d'origine. Renommer les champs créerait un décalage entre la réponse du serveur et les accès aux propriétés côté client.
+
+## Masquage des noms de champs (minification des propriétés)
+
+Lorsque `intlayerPrune` a analysé la codebase et rempli `pruneContext.dictionaryKeyToFieldRenameMap`, `intlayerMinify` renomme également les noms de champs de contenu en alias courts. Par exemple :
+
+```json
+// avant
+{ "key": "myDict", "content": { "title": "Hello", "description": "World" } }
+
+// après (avec masquage)
+{ "key": "myDict", "content": { "a": "Hello", "b": "World" } }
+```
+
+Les accès aux propriétés correspondants dans les fichiers sources sont renommés par la passe Babel dans `intlayerOptimize`, le comportement au runtime reste donc inchangé.
+
+Les champs internes d'Intlayer (`nodeType`, `translation`, etc.) ne sont jamais renommés.
+
+## Dictionnaires de cas limites (Edge-cases)
+
+Les dictionnaires signalés dans `pruneContext.dictionariesWithEdgeCases` (anomalies structurelles détectées lors de la phase de prune) sont entièrement ignorés — ni minifiés ni masqués — pour éviter de livrer des données corrompues.
+
+## Groupes qualifiés (collections / variantes / enregistrements méta)
+
+Pour les dictionnaires avec un tableau `qualifierTypes` (collections, variantes et enregistrements méta), le plugin préserve le tableau `qualifierTypes` et la table de correspondance `meta` textuellement. Seules les entrées de `content` ont leurs noms de champs masqués. Les clés composites (utilisées pour la correspondance des sélecteurs au runtime) ne sont jamais touchées.

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

@@ -0,0 +1,172 @@
+---
+createdAt: 2026-06-25
+updatedAt: 2026-06-25
+title: Documentation du plugin Vite intlayerProxy | vite-intlayer
+description: Middleware de routage par langue pour les serveurs dev/preview de Vite et le SSR en production. Gère la détection de la langue, les redirections d'URL et les réécritures internes.
+keywords:
+  - intlayerProxy
+  - vite
+  - plugin
+  - middleware
+  - langue
+  - routage
+  - internationalisation
+  - i18n
+  - SSR
+slugs:
+  - doc
+  - packages
+  - vite-intlayer
+  - intlayerProxy
+history:
+  - version: 9.0.0
+    date: 2026-06-25
+    changes: "Fusion de configOptions dans un seul objet d'options ; proxy intégré dans intlayer()"
+author: aymericzip
+---
+
+# intlayerProxy
+
+`intlayerProxy` est un plugin Vite qui enregistre un middleware de routage par langue pour **chaque environnement** : serveur de développement, serveur de prévisualisation et SSR en production (Nitro / TanStack Start).
+
+> **Depuis Intlayer v9**, `intlayerProxy` est automatiquement inclus dans le plugin principal [`intlayer()`](https://github.com/aymericzip/intlayer/blob/main/docs/docs/fr/packages/vite-intlayer/intlayer.md) et activé par défaut via `routing.enableProxy: true`. Vous n'avez besoin de l'enregistrer séparément que si vous avez besoin d'un contrôle de plus bas niveau ou si vous l'utilisez en dehors de la configuration standard d'`intlayer()`.
+
+## Utilisation
+
+### En tant que partie de `intlayer()` (recommandé, v9+)
+
+Transmettez les options `proxy` au plugin principal au lieu d'enregistrer `intlayerProxy` séparément :
+
+```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"),
+      },
+    }),
+  ],
+});
+```
+
+### Autonome (si nécessaire)
+
+```ts
+// vite.config.ts
+import { defineConfig } from "vite";
+import { intlayer } from "vite-intlayer";
+
+export default defineConfig({
+  plugins: [intlayer()],
+});
+```
+
+## Options
+
+```ts
+import type { IntlayerProxyPluginOptions } from "vite-intlayer";
+```
+
+Toutes les options sont facultatives et transmises sous la forme d'un seul objet :
+
+| Option          | Type                                | Description                                                                                                                                                                                    |
+| --------------- | ----------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `ignore`        | `(req: IncomingMessage) => boolean` | Prédicat qui exclut des requêtes du routage par langue. Retournez `true` pour ignorer une requête (ex. routes d'API, vérifications de santé).                                                  |
+| `configOptions` | `GetConfigurationOptions`           | Surcharges de configuration Intlayer transmises à `getConfiguration()`. À utiliser lorsque vous avez besoin que le proxy lise un fichier de configuration spécifique ou surcharge des valeurs. |
+
+### Exemple
+
+```ts
+intlayerProxy({
+  ignore: (req) => req.url?.startsWith("/api"),
+  configOptions: { configFile: "./config/intlayer.config.ts" },
+});
+```
+
+## createIntlayerProxyHandler
+
+`createIntlayerProxyHandler` crée un middleware Node.js `(req, res, next)` autonome et indépendant du framework qui contient toute la logique de routage par langue. Il est utile dans les environnements où l'API du plugin Vite n'est pas disponible (ex. un serveur Node.js brut ou un module Nitro personnalisé).
+
+```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 en production (TanStack Start / Nitro via 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"),
+  })
+);
+```
+
+## Comportement de routage
+
+Le middleware reproduit la logique de routage du middleware de `next-intlayer` et prend en charge tous les modes de routage d'Intlayer.
+
+### Modes de routage
+
+| Mode            | URL visible dans le navigateur | Comportement                                                                                                                          |
+| --------------- | ------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------- |
+| `prefix`        | `/fr/about`                    | Par défaut. Préfixe de langue dans l'URL. La langue par défaut redirige vers l'URL sans préfixe, sauf si `prefix-all` est activé.     |
+| `prefix-all`    | `/en/about`, `/fr/about`       | Toutes les langues — y compris celle par défaut — sont toujours préfixées.                                                            |
+| `no-prefix`     | `/about`                       | Aucune langue dans l'URL. La langue est stockée uniquement dans les cookies ; les réécritures d'URL se font en interne.               |
+| `search-params` | `/about?locale=fr`             | Langue transmise comme paramètre de requête. Redirige pour ajouter/mettre à jour le paramètre `locale` s'il est manquant ou obsolète. |
+
+### Priorité de détection
+
+1. Préfixe du chemin de l'URL (ex. `/fr/about` → `fr`).
+2. Valeur du cookie / localStorage (`intlayer-locale`).
+3. En-tête `Accept-Language`.
+4. `defaultLocale` de la configuration.
+
+### Contournement automatique
+
+Le middleware laisse toujours passer ces requêtes directement sans gestion de la langue :
+
+- Requêtes correspondant au prédicat `ignore`.
+- `/node_modules/**`
+- `/@**` – Internes de Vite (`@vite/`, `@fs/`, `@id/`, etc.).
+- `/_**` – Internes du serveur (`__vite_ping`, `__manifest`, etc.).
+- Requêtes dont le chemin se termine par une extension de fichier (actifs statiques). Si un préfixe de langue est présent sur le chemin d'un actif statique (ex. `/fr/logo.png`), il est supprimé afin que le fichier puisse être servi correctement.
+
+### Routage par domaine
+
+Lorsque `routing.domains` est configuré dans votre configuration Intlayer, le middleware gère le routage de langue inter-domaines :
+
+- Une requête pour `/zh/about` sur `intlayer.org` est redirigée vers `https://intlayer.zh/about` quand `domains.zh = "intlayer.zh"`.
+- Une requête vers `intlayer.zh/about` est réécrite en interne en `/zh/about` afin que le paramètre de route `[locale]` soit renseigné.
+
+### Protection contre les boucles de redirection
+
+Le middleware suit le nombre de redirections par paire `originalUrl → newUrl` dans une fenêtre glissante de 2 secondes. Plus de 10 redirections dans cette fenêtre renvoient une réponse `500` avec une erreur descriptive au lieu de boucler indéfiniment.
+
+## Nitro / SSR en production (injection automatique, v9+)
+
+Lorsque `intlayerProxy` est utilisé comme plugin Vite, il porte une propriété `.nitro`. Le plugin de build `nitro/vite` lit cette propriété et l'ajoute dans `nitroConfig.modules`, de sorte qu'`intlayerNitroHandler` est enregistré automatiquement comme middleware de serveur Nitro — aucune configuration manuelle n'est nécessaire pour le SSR en production.
+
+Le gestionnaire Nitro utilise le modèle d'événement Web Fetch API d'h3 v2 (pas `fromNodeMiddleware`), il est donc compatible avec tous les profils de Nitro : Node, Bun, Deno, les runtimes edge.
+
+## Alias obsolètes
+
+| Export obsolète            | Remplacement    |
+| -------------------------- | --------------- |
+| `intlayerMiddleware`       | `intlayerProxy` |
+| `intLayerMiddlewarePlugin` | `intlayerProxy` |

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-23
+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,17 +241,61 @@ 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.
+
+Importez tout depuis le package unique `react-native-intlayer` :
+
+```tsx
+import {
+  IntlayerProvider,
+  useIntlayer,
+  useLocale,
+} from "react-native-intlayer";
+```
+
+```bash
+npm install intlayer react-native-intlayer
+```
+
+> L'importation depuis `react-intlayer` continue de fonctionner, mais `react-native-intlayer` est désormais le point d'entrée unique recommandé pour React Native — son provider inclut les polyfills que le provider `react-intlayer` (orienté web) ne contient pas.
+
+---
+
 ## Notes de migration depuis la v8
 
 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/compiler.md

@@ -81,12 +81,15 @@ npm install vite-intlayer
 
 ```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(), // कंपाइलर प्लगइन जोड़ता है
+    intlayer({
+      proxy: {
+        ignore: (req) => req.url?.startsWith("/api"),
+      },
+    }),
   ],
 });
 ```

package/docs/hi/custom_domains.md

@@ -172,10 +172,16 @@ GET intlayer.zh/about
 
 ```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/hi/custom_url_rewrites.md

@@ -343,10 +343,16 @@ SolidJS, Vue, और Svelte के लिए, `intlayerProxy` Vite प्लग
 
 ```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/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 }` जोड़ने से यह एक ही प्रविष्टि तक सीमित हो जाता है।