@intlayer/docs 9.3.3 → 9.4.0

package/docs/fr/packages/react-intlayer/useIntlayer.md

@@ -31,48 +31,6 @@ Cette section fournit des instructions détaillées sur l'utilisation du hook `u
 
 ## Exemple d'utilisation dans React
 
-Démonstration du hook `useIntlayer` dans un composant React :
-
-```tsx fileName="src/app.tsx" codeFormat={["typescript", "esm"]}
-import type { FC } from "react";
-import { ClientComponentExample, ServerComponentExample } from "@components";
-import { IntlayerProvider } from "react-intlayer";
-import { useIntlayer, IntlayerServerProvider } from "react-intlayer/server";
-import { Locales } from "intlayer";
-
-const App: FC<{ locale: Locales }> = ({ locale }) => {
-  const content = useIntlayer("homepage", locale);
-
-  return (
-    <>
-      <p>{content.introduction}</p>
-      <IntlayerProvider locale={locale}>
-        <ClientComponentExample />
-      </IntlayerProvider>
-      <IntlayerServerProvider locale={locale}>
-        <ServerComponentExample />
-      </IntlayerServerProvider>
-    </>
-  );
-};
-```
-
-```tsx fileName="src/components/ComponentExample.tsx" codeFormat={["typescript", "esm"]}
-import type { FC } from "react";
-import { useIntlayer } from "react-intlayer";
-
-const ComponentExample: FC = () => {
-  const content = useIntlayer("component-example");
-
-  return (
-    <div>
-      <h1>{content.title}</h1>
-      <p>{content.description}</p>
-    </div>
-  );
-};
-```
-
 ```tsx fileName="src/components/ServerComponentExample.tsx" codeFormat={["typescript", "esm"]}
 import { useIntlayer } from "react-intlayer/server";
 

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

@@ -56,7 +56,7 @@ export default defineConfig({
 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.
+Lorsque `editor.enabled` est `true`, le plugin s'exécute toujours mais **ignore le renommage des champs** : le renommage réécrit les clés de contenu que l'interpréteur parcourt, donc le `keyPath` reçu par l'éditeur visuel ne correspondrait plus aux dictionnaires non fusionnés qu'il édite. La compaction des espaces et la suppression des métadonnées de premier niveau restent actives.
 
 ## Ce qui est minifié
 

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

@@ -28,6 +28,8 @@ author: aymericzip
 
 Le plugin Vite `intlayerPrune` permet d'effectuer du tree-shaking et de supprimer les dictionnaires inutilisés du bundle de votre application. Cela aide à réduire la taille finale du bundle en n'incluant que le contenu multilingue nécessaire.
 
+> 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
 
 ### Dans le cadre de `intlayer()` (recommandé)
@@ -115,4 +117,4 @@ Lorsque l'élagage réussit, `intlayerPrune` écrit également `pruneContext.dic
 2. `build.optimize` est `true` (ou `undefined`, qui est `true` par défaut pour les builds).
 3. `build.purge` est `true` dans votre configuration Intlayer.
 
-Il est automatiquement **désactivé** quand `editor.enabled` est `true` car l'éditeur a besoin du contenu complet du dictionnaire.
+Il reste actif lorsque `editor.enabled` est `true` : l'éditeur visuel résout chaque modification via `dictionaryKey` + `keyPath` par rapport aux dictionnaires non fusionnés, que ce plugin ne touche jamais, et un champ purgé est un champ qu'aucun composant ne lit — il n'est donc jamais rendu ni sélectionnable dans la page.

package/docs/fr/per_locale_file.md

@@ -77,6 +77,17 @@ const helloWorldContent = {
 module.exports = helloWorldContent;
 ```
 
+```json5 fileName="hello-world.fr.content.json" contentDeclarationFormat="json"
+{
+  "$schema": "https://intlayer.org/schema.json",
+  "key": "hello-world",
+  "locale": "fr", // Important
+  "content": {
+    "multilingualContent": "Titre de mon composant",
+  },
+}
+```
+
 ```json fileName="hello-world.content.ts" contentDeclarationFormat="json"
 {
   "$schema": "https://intlayer.org/schema.json",
@@ -95,6 +106,8 @@ module.exports = helloWorldContent;
 
 > Recommandé : Ce format est idéal lorsque vous utilisez l'éditeur visuel d'Intlayer ou que vous gérez les traductions directement dans le code.
 
+> Remarque : Dans les deux cas, le fichier de déclaration de contenu doit suivre le modèle de nommage `*.content.{ts,tsx,js,jsx,mjs,cjs,json}` pour être reconnu par Intlayer. Le suffixe `.[locale]` est optionnel et utilisé uniquement comme convention de nommage.
+
 ### Configuration globale pour les fichiers par locale
 
 Vous pouvez configurer la configuration globale pour les fichiers par locale en ajoutant ce qui suit à votre fichier intlayer.config.ts :
@@ -146,17 +159,6 @@ const helloWorldContent = {
 export default helloWorldContent;
 ```
 
-```json5 fileName="hello-world.en.content.json" contentDeclarationFormat="json"
-{
-  "$schema": "https://intlayer.org/schema.json",
-  "key": "hello-world",
-  "locale": "en", // Important
-  "content": {
-    "multilingualContent": "Titre de mon composant",
-  },
-}
-```
-
 ```json5 fileName="hello-world.es.content.json" contentDeclarationFormat="json"
 {
   "$schema": "https://intlayer.org/schema.json",
@@ -170,8 +172,6 @@ export default helloWorldContent;
 
 > Important : Assurez-vous que le champ locale est défini. Il indique à Intlayer la langue que représente le fichier.
 
-> Remarque : Dans les deux cas, le fichier de déclaration de contenu doit suivre le modèle de nommage `*.content.{ts,tsx,js,jsx,mjs,cjs,json}` pour être reconnu par Intlayer. Le suffixe `.[locale]` est optionnel et utilisé uniquement comme convention de nommage.
-
 ## Mélange des formats
 
 Vous pouvez combiner les deux approches de déclaration pour la même clé de contenu. Par exemple :

package/docs/fr/readme.md

@@ -225,8 +225,8 @@ Explorez notre documentation exhaustive pour commencer avec Intlayer et apprendr
   <li><a href="https://intlayer.org/doc/environment/vite-and-vue" rel=''>Vite + Vue</a></li>
   <li><a href="https://intlayer.org/doc/environment/nuxt-and-vue" rel=''>Vite + Nuxt</a></li>
   <li><a href="https://intlayer.org/doc/environment/vite-and-solid" rel=''>Vite + Solid</a></li>
-  <li><a href="https://intlayer.org/doc/environment/angular" rel=''>Angular</a></li>
-  <li>
+  <li><a href="https://intlayer.org/doc/environment/solid-start" rel=''>Solid Start</a></li>
+  <li><a href="https://intlayer.org/doc/environment/angular" rel=''>Angular</a></li>  <li>
      <a href="https://intlayer.org/doc/environment/express" rel=''>Backend</a>
      <ul>
       <li><a href="https://intlayer.org/doc/environment/express" rel=''>Express</a></li>
@@ -234,6 +234,7 @@ Explorez notre documentation exhaustive pour commencer avec Intlayer et apprendr
       <li><a href="https://intlayer.org/doc/environment/fastify" rel=''>Fastify</a></li>
       <li><a href="https://intlayer.org/doc/environment/adonisjs" rel=''>AdonisJS</a></li>
       <li><a href="https://intlayer.org/doc/environment/hono" rel=''>Hono</a></li>
+      <li><a href="https://intlayer.org/doc/environment/elysia" rel=''>Elysia</a></li>
     </ul>
   </li>
 </ul>

package/docs/fr/releases/v6.md

@@ -118,6 +118,8 @@ export default config;
 
 Vous pouvez toujours affiner par dictionnaire en utilisant le champ `autoFill` dans les fichiers de contenu. Consultez la référence complète dans `doc/autoFill` et `doc/dictionary/content_file`.
 
+Vous pouvez toujours affiner par dictionnaire en utilisant le champ `autoFill` dans les fichiers de contenu. Intlayer considérera d'abord la configuration par dictionnaire, puis basculera vers la configuration globale. Consultez la référence complète dans [Auto-fill](https://github.com/aymericzip/intlayer/blob/main/docs/docs/fr/autoFill.md) et [Content file reference](https://github.com/aymericzip/intlayer/blob/main/docs/docs/fr/dictionary/content_file.md).
+
 ---
 
 ## Commande fill : valeurs par défaut plus sûres
@@ -169,6 +171,12 @@ L'extension inclut désormais un onglet Intlayer dédié dans la barre d'activit
 - Barre d'outils dans la vue Dictionnaires : Construire, Pull, Push, Remplir, Actualiser, Tester, Créer un fichier de dictionnaire
 - Menus contextuels : Pull/Push sur les dictionnaires ; Remplir sur les fichiers
 
+Voir les détails dans la documentation de l'[extension officielle VS Code](https://github.com/aymericzip/intlayer/blob/main/docs/docs/fr/vs_code_extension.md).
+
+---
+
+Mise à jour du serveur MCP pour supporter les nouvelles fonctionnalités.
+
 - Révélation automatique : le fichier actuellement ouvert dans l’éditeur est mis en surbrillance dans l’arborescence des dictionnaires lorsque cela est applicable
 - Nouvelles commandes disponibles depuis la Palette de commandes : Remplir les dictionnaires et Tester les dictionnaires
 
@@ -297,8 +305,6 @@ Notes :
 
 Voir [CMS et synchronisation en direct](https://github.com/aymericzip/intlayer/blob/main/docs/docs/fr/intlayer_CMS.md) et [Configuration](https://github.com/aymericzip/intlayer/blob/main/docs/docs/fr/configuration.md) pour un guide complet.
 
----
-
 ## Processus parallèle pour surveiller les fichiers sur turbopack
 
 Lors de l'utilisation de Turbopack sur Next.js 14 et versions ultérieures comme serveur de développement avec la commande `next dev --turbopack`, les modifications du dictionnaire ne seront pas détectées automatiquement par défaut.

package/docs/fr/releases/v9.md

@@ -370,6 +370,8 @@ curl -fsSL https://intlayer.org/install.sh | sh
 
 Le programme d'installation télécharge un `docker-compose.yml` et un `.env`, génère automatiquement les secrets requis et exécute `docker compose up -d`. Tout — le tableau de bord, l'API, la base de données, le stockage d'objets et les e-mails transactionnels — s'exécute localement dans des conteneurs.
 
+---
+
 ## 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 :

package/docs/fr/self_hosting.md

@@ -21,12 +21,16 @@ author: aymericzip
 
 Intlayer peut fonctionner entièrement sur votre propre infrastructure — aucun compte Intlayer Cloud n'est requis. Une seule commande démarre une stack prête pour la production :
 
+Une seule commande installe tout :
+
 ```sh
 curl -fsSL https://intlayer.org/install.sh | sh
 ```
 
 L'installateur télécharge un fichier `docker-compose.yml` et un fichier `.env`, génère automatiquement les secrets requis et démarre tous les conteneurs avec `docker compose up -d`.
 
+La seule dépendance externe est **MongoDB** : le backend se connecte à un cluster MongoDB **Atlas**, que vous fournissez. Tout le reste s'exécute à l'intérieur du conteneur.
+
 ## Table des matières
 
 <TOC/>
@@ -60,23 +64,77 @@ Chromium (utilisé pour la génération de captures d'écran Puppeteer) est int
 - Ports `3000`, `3100`, `8025`, `9000` et `9001` disponibles sur l'hôte.
 - Un hôte Linux ou macOS (ou WSL2 sur Windows).
 
+Tout le reste — Bun, Redis, MinIO, Chromium — est fourni dans l'image.
+
 ---
 
 ## Démarrage rapide
 
+### 1. Exécuter l'installateur
+
 ```sh
 curl -fsSL https://intlayer.org/install.sh | sh
 ```
 
-Ce que fait l'installateur :
+Il vérifie que Docker est installé et en cours d'exécution, écrit `./intlayer.env` avec `BETTER_AUTH_SECRET` et `S3_SECRET_ACCESS_KEY` déjà générés, et télécharge l'image. Il ne démarre pas le conteneur — le backend ne peut pas démarrer sans vos identifiants de base de données.
+
+Réexécuter l'installateur est sûr : un `intlayer.env` existant n'est jamais écrasé, il sert donc également de chemin de mise à niveau.
+
+### 2. Remplissez vos identifiants
+
+Ouvrez `intlayer.env` et complétez les valeurs marquées `TODO` :
+
+```sh fileName="intlayer.env"
+DB_ID=<atlas-user>
+DB_MDP=<atlas-password>
+DB_CLUSTER=<cluster>.xxxxx.mongodb.net
+RESEND_API_KEY=<your-resend-key>
+```
+
+Le fichier contient également des blocs commentés pour les fonctionnalités optionnelles — [SMTP mailer](#global-mailer), `OPENAI_API_KEY`, et les fournisseurs OAuth. Décommentez ce dont vous avez besoin.
+
+> Le fichier est lu par `docker run --env-file`, qui ne supprime pas les guillemets et traite tout ce qui suit `=` comme la valeur. Écrivez des valeurs nues et gardez les commentaires sur leurs propres lignes.
+
+### 3. Démarrer le conteneur
+
+Ceci est la commande que l'installateur affiche à la fin :
+
+```sh
+docker run -d --name intlayer \
+  --restart unless-stopped \
+  -p 3000:3000 \
+  -p 3100:3100 \
+  -p 9000:9000 \
+  -p 9001:9001 \
+  -v intlayer-data:/data \
+  --env-file ./intlayer.env \
+  ghcr.io/aymericzip/intlayer-selfhost:latest
+```
+
+Ouvrez ensuite **http://localhost:3000**. Le premier démarrage initialise les datastores, donc patientez une minute.
+
+> Le tableau de bord est servi sur `localhost`. Voir [Limitations](#limitations) — les domaines personnalisés ne sont pas pris en charge par l'image publiée.
 
-1.  Vérifie que `docker` et `docker compose` sont présents.
-2.  Télécharge `docker-compose.yml` et `.env.example` dans `./intlayer/`.
-3.  S'il n'existe pas de fichier `.env`, copie l'exemple et génère des secrets aléatoires pour `BETTER_AUTH_SECRET`, `S3_ACCESS_KEY_ID` et `S3_SECRET_ACCESS_KEY` via `openssl rand`.
-4.  Exécute `docker compose pull` + `docker compose up -d`.
-5.  Affiche les URL : tableau de bord `:3000`, API `:3100`, UI e-mail `:8025`, console MinIO `:9001`.
+### Paramètres du programme d'installation
 
-Une fois la stack démarrée, ouvrez **http://localhost:3000** et créez votre premier compte.
+Le programme d'installation lit quelques variables d'environnement. Comme il est dirigé vers `sh`, transmettez-les au shell plutôt qu'à `curl` :
+
+```sh
+curl -fsSL https://intlayer.org/install.sh | INTLAYER_ENV_FILE=./config/intlayer.env sh
+```
+
+| Variable                  | Par défaut                                    | Description                       |
+| ------------------------- | --------------------------------------------- | --------------------------------- |
+| `INTLAYER_IMAGE`          | `ghcr.io/aymericzip/intlayer-selfhost:latest` | Image à télécharger               |
+| `INTLAYER_ENV_FILE`       | `./intlayer.env`                              | Où écrire le fichier env          |
+| `INTLAYER_CONTAINER_NAME` | `intlayer`                                    | Nom du conteneur                  |
+| `INTLAYER_DATA_VOLUME`    | `intlayer-data`                               | Volume nommé monté à `/data`      |
+| `INTLAYER_APP_PORT`       | `3000`                                        | Port hôte pour le tableau de bord |
+| `INTLAYER_API_PORT`       | `3100`                                        | Port hôte pour l'API              |
+| `INTLAYER_S3_PORT`        | `9000`                                        | Port hôte pour l'API S3 MinIO     |
+| `INTLAYER_CONSOLE_PORT`   | `9001`                                        | Port hôte pour la console MinIO   |
+
+> Les quatre variables de port ne modifient que le côté **hôte** du mappage imprimé dans la commande `docker run`. L'image publiée a `http://localhost:3000`, `http://localhost:3100` et `http://localhost:9000` compilés dans le bundle du tableau de bord au moment de la compilation, donc les remapper laisse le navigateur pointant vers les anciens ports. Conservez les valeurs par défaut sauf si vous construisez votre propre image — voir [Limitations](#limitations).
 
 ---
 
@@ -103,8 +161,6 @@ Une fois qu'un admin existe, `/init` redirige vers la page de connexion standard
 | **minio**   | `minio/minio`                                   | `9000` (S3), `9001` (console)  | Stockage d'objets compatible S3 pour les avatars et les captures d'écran |
 | **mailpit** | `axllent/mailpit`                               | `1025` (SMTP), `8025` (web UI) | Réceptacle local d'e-mails transactionnels                               |
 
-Les ports internes (mongo, redis) ne sont pas exposés à l'hôte par défaut.
-
 > Le port `9000` de MinIO doit être accessible par le navigateur car les assets téléchargés (avatars, captures d'écran) sont chargés directement depuis `S3_PUBLIC_URL=http://localhost:9000/intlayer`.
 
 ---
@@ -160,8 +216,6 @@ Les ports internes (mongo, redis) ne sont pas exposés à l'hôte par défaut.
 | `LINKEDIN_CLIENT_ID`, `LINKEDIN_CLIENT_SECRET`           | Connexion OAuth LinkedIn                                        |
 | `ATLASSIAN_CLIENT_ID`, `ATLASSIAN_CLIENT_SECRET`         | Connexion OAuth Atlassian                                       |
 
----
-
 ### Mailer global
 
 Par défaut, tous les emails transactionnels sont envoyés via Resend en utilisant `RESEND_API_KEY`. Les déploiements auto-hébergés peuvent à la place router **tous** les emails — y compris les emails non-organisationnels tels que les réinitialisations de mot de passe et les liens magiques — via un mailer global configuré avec des variables d'environnement.
@@ -247,16 +301,8 @@ const { data: dictionaries } = await dictionaryEndpoint(cms).getDictionaries();
 
 ## Mise à niveau
 
-Exécuter à nouveau l'installateur sur un déploiement existant effectue une mise à niveau progressive :
-
-```sh
-curl -fsSL https://intlayer.org/install.sh | sh
-```
-
 Ceci télécharge les dernières images et redémarre les conteneurs avec `docker compose pull && docker compose up -d`. Les volumes existants (`mongo-data`, `redis-data`, `minio-data`) sont préservés — aucune perte de données.
 
-Pour effectuer une mise à niveau manuellement depuis le répertoire `./intlayer/` :
-
 ```sh
 docker compose pull
 docker compose up -d
@@ -320,15 +366,12 @@ docker compose logs mongo
 docker compose logs redis
 ```
 
+Recherchez `MongoDB connection error` près du haut du journal.
+
 ### Le tableau de bord ne peut pas atteindre l'API
 
 Vérifiez que `VITE_BACKEND_URL` correspond à l'URL où le backend est accessible depuis le **navigateur** (pas le réseau Docker). Si vous avez modifié le port du backend ou ajouté un proxy inverse, reconstruisez l'image du tableau de bord :
 
-```sh
-docker compose build app
-docker compose up -d app
-```
-
 ### Bucket MinIO manquant
 
 Si le service ponctuel `minio-init` n'a pas fonctionné (ou a fonctionné avant que MinIO ne soit prêt), créez le bucket manuellement :

package/docs/hi/agent_skills.md

@@ -1,11 +1,11 @@
 ---
 createdAt: 2026-02-09
 updatedAt: 2026-03-03
-title: एजेंट स्किल्स
-description: जानें कि Intlayer एजेंट स्किल्स का उपयोग करके अपने AI एजेंट की आपके प्रोजेक्ट की समझ कैसे बेहतर करें, जिसमें मेटाडेटा, साइटमैप और सर्वर क्रियाओं के लिए व्यापक सेटअप गाइड शामिल हैं।
+title: Agent Skills
+description: जानें कि Intlayer Agent Skills का उपयोग करके अपने AI एजेंट की आपके प्रोजेक्ट की समझ कैसे बेहतर करें, जिसमें मेटाडेटा, साइटमैप और सर्वर क्रियाओं के लिए व्यापक सेटअप गाइड शामिल हैं।
 keywords:
   - Intlayer
-  - एजेंट स्किल्स
+  - Agent Skills
   - AI एजेंट
   - Internationalization
   - डॉक्यूमेंटेशन
@@ -19,13 +19,13 @@ history:
 author: aymericzip
 ---
 
-# एजेंट स्किल्स
+# Agent Skills
 
 ## सेटअप
 
 ### CLI का उपयोग करके
 
-`intlayer init skills` कमांड आपके प्रोजेक्ट में एजेंट स्किल्स सेटअप करने का सबसे आसान तरीका है। यह आपके वातावरण का पता लगाता है और आपके पसंदीदा प्लेटफ़ॉर्म के लिए आवश्यक कॉन्फ़िगरेशन फ़ाइलें इंस्टॉल करता है।
+`intlayer init skills` कमांड आपके प्रोजेक्ट में Agent Skills सेटअप करने का सबसे आसान तरीका है। यह आपके वातावरण का पता लगाता है और आपके पसंदीदा प्लेटफ़ॉर्म के लिए आवश्यक कॉन्फ़िगरेशन फ़ाइलें इंस्टॉल करता है।
 
 ```bash packageManager="npm"
 npx intlayer init skills
@@ -54,10 +54,10 @@ npx skills add aymericzip/intlayer-skills
 1. कमांड पैलेट खोलें (Ctrl+Shift+P या Cmd+Shift+P)।
 2. `Intlayer: Setup AI Agent Skills` टाइप करें।
 3. उस प्लेटफ़ॉर्म को चुनें जिसका आप उपयोग करते हैं (उदा. `VS Code`, `Cursor`, `Windsurf`, `OpenCode`, `Claude Code`, `GitHub Copilot Workspace`, आदि)।
-4. वे स्किल्स चुनें जिन्हें आप इंस्टॉल करना चाहते हैं (उदा. `Next.js`, `React`, `Vite`, `Compiler`, `Configuration`)।
+4. वे Agent Skills चुनें जिन्हें आप इंस्टॉल करना चाहते हैं (उदा. `Next.js`, `React`, `Vite`, `Compiler`, `Configuration`)।
 5. Enter दबाएं।
 
-## स्किल्स सूची
+## Agent Skills सूची
 
 **intlayer-config**
 

package/docs/hi/analytics.md

@@ -1,6 +1,6 @@
 ---
 createdAt: 2026-07-08
-updatedAt: 2026-07-08
+updatedAt: 2026-08-22
 title: Intlayer Analytics | सामग्री के प्रदर्शन को ट्रैक करें और A/B परीक्षण चलाएं
 description: जानें कि @intlayer/analytics कैसे पेज/लोकेल व्यू और सामग्री के प्रदर्शन को ट्रैक करता है, और अपने Intlayer सामग्री पर A/B परीक्षण चलाने के लिए इसका उपयोग कैसे करें।
 keywords:
@@ -18,6 +18,9 @@ slugs:
   - concept
   - analytics
 history:
+  - version: 9.3.3
+    date: 2026-08-22
+    changes: "`@intlayer/analytics` इंस्टॉल होने पर एनालिटिक्स डिफ़ॉल्ट रूप से सक्षम किया गया"
   - version: 9.0.0
     date: 2026-07-08
     changes: "Init doc — @intlayer/analytics पैकेज, प्रोवाइडर/नोड-लेवल ट्रैकिंग, A/B परीक्षण, डैशबोर्ड"
@@ -57,7 +60,7 @@ Intlayer आपको पहले से ही सामग्री [वे
 
 ## इंस्टालेशन (Installation)
 
-`@intlayer/analytics` एक **पीयर (peer), वैकल्पिक** निर्भरता है — यह कभी भी फ्रेमवर्क पैकेज द्वारा स्वचालित रूप से स्थापित नहीं होता है। इसे `intlayer` के साथ जोड़ें:
+`@intlayer/analytics` हर फ्रेमवर्क पैकेज (`react-intlayer`, `next-intlayer`, `vue-intlayer`, …) की एक **वैकल्पिक निर्भरता (optional dependency)** है, इसलिए अधिकांश प्रोजेक्ट्स में यह पहले से मौजूद होती है। यदि आपका सेटअप वैकल्पिक निर्भरताओं को छोड़ देता है (`npm install --no-optional`, …), तो इसे स्पष्ट रूप से इंस्टॉल करें:
 
 ```bash packageManager="npm"
 npm install @intlayer/analytics
@@ -75,11 +78,11 @@ pnpm add @intlayer/analytics
 bun add @intlayer/analytics
 ```
 
-यदि आप इसे स्थापित नहीं करते हैं, तो प्रत्येक एकीकरण बिंदु (integration point) एक नो-ऑप (no-op) के रूप में हल हो जाता है — नीचे [स्थापित न होने पर शून्य लागत](#स्थापित-न-होने-पर-शून्य-लागत) देखें।
+एनालिटिक्स चालू करने के लिए पैकेज इंस्टॉल करना ही पर्याप्त है: `analytics.enabled` का डिफ़ॉल्ट `true` है, और जब पैकेज आपके प्रोजेक्ट में नहीं मिलता तो `@intlayer/config` इसे `false` कर देता है। यदि आप इसे स्थापित नहीं करते हैं, तो प्रत्येक एकीकरण बिंदु (integration point) एक नो-ऑप (no-op) के रूप में हल हो जाता है — नीचे [स्थापित न होने पर शून्य लागत](#स्थापित-न-होने-पर-शून्य-लागत) देखें।
 
 ## कॉन्फ़िगरेशन (Configuration)
 
-एनालिटिक्स **मौजूदा `editor` कॉन्फ़िगरेशन ब्लॉक का पुन: उपयोग करता है** — भरने के लिए कोई अलग `analytics` कॉन्फ़िगरेशन स्कीमा नहीं है:
+शुरू करने के लिए एनालिटिक्स को किसी कॉन्फ़िगरेशन की आवश्यकता नहीं है: यह **डिफ़ॉल्ट रूप से सक्षम** है और अपने एंडपॉइंट तथा प्रोजेक्ट कुंजी के लिए **मौजूदा `editor` कॉन्फ़िगरेशन ब्लॉक का ही पुनः उपयोग करता है**।
 
 ```typescript fileName="intlayer.config.ts" codeFormat={["typescript", "esm", "commonjs"]}
 import type { IntlayerConfig } from "intlayer";
@@ -100,6 +103,26 @@ export default config;
 
 यदि आप Intlayer को सेल्फ-होस्ट करते हैं, तो एनालिटिक्स स्वचालित रूप से आपके स्वयं के इंस्टेंस को इंगित करता है क्योंकि यह `editor.backendURL` साझा करता है।
 
+### ऑप्ट-आउट कैसे करें
+
+वैकल्पिक `analytics` ब्लॉक संग्रहण को समायोजित करता है — या बंद कर देता है:
+
+```typescript fileName="intlayer.config.ts" codeFormat={["typescript", "esm", "commonjs"]}
+import type { IntlayerConfig } from "intlayer";
+
+const config: IntlayerConfig = {
+  analytics: {
+    enabled: false, // डिफ़ॉल्ट: true — संपूर्ण इंटीग्रेशन को बंडल से बाहर कर देता है
+    flushInterval: 20_000, // दो बैच फ़्लश के बीच मिलीसेकंड
+    sampleRate: 1, // रिकॉर्ड की जाने वाली सत्रों का अंश, 0 (कोई नहीं) से 1 (सभी) तक
+  },
+};
+
+export default config;
+```
+
+`@intlayer/analytics` को अनइंस्टॉल करने का प्रभाव `enabled: false` के समान ही है। पूरी फ़ील्ड सूची के लिए [कॉन्फ़िगरेशन संदर्भ](https://github.com/aymericzip/intlayer/blob/main/docs/docs/hi/configuration.md) देखें।
+
 ## फ्रेमवर्क सपोर्ट (Framework support)
 
 एनालिटिक्स `react-intlayer` के साझा `IntlayerProvider` में वायर्ड है, इसलिए यह आज हर उस जगह उपलब्ध है जहाँ उस प्रदाता (provider) का उपयोग किया जाता है:
@@ -177,7 +200,7 @@ const variant = client?.getVariant("homepage-hero", [
 `@intlayer/analytics` पूरी तरह से उसी वैकल्पिक-निर्भरता पैटर्न का पालन करता है जैसा कि `@intlayer/editor`:
 
 - प्रत्येक एकीकरण बिंदु पैकेज को **`try/catch` में लिपटे गतिशील (dynamic) `import()`** के माध्यम से लोड करता है — एक ऐप जो कभी भी `@intlayer/analytics` स्थापित नहीं करता है वह बंडल-आकार या रनटाइम लागत का भुगतान नहीं करता है, और कभी कोई त्रुटि नहीं देखता है;
-- एक संकलन-समय (compile-time) पर्यावरण चर (`INTLAYER_ANALYTICS_ENABLED`), जिसे `@intlayer/config` द्वारा स्वचालित रूप से `'false'` पर सेट किया जाता है जब `editor.clientId` कॉन्फ़िगर नहीं किया जाता है, जिससे बंडलर्स पूरे एकीकरण को **मृत-कोड-समाप्त (dead-code-eliminate)** कर सकते हैं;
+- एक कंपाइल-टाइम एनवायरनमेंट वेरिएबल (`INTLAYER_ANALYTICS_ENABLED`), जिसे `@intlayer/config` तब स्वतः `'false'` कर देता है जब पैकेज इंस्टॉल न हो, `analytics.enabled` `false` हो, या `editor.clientId` कॉन्फ़िगर न हो — जिससे बंडलर संपूर्ण इंटीग्रेशन को **डेड कोड के रूप में हटा (dead-code-eliminate)** सकते हैं;
 - एनालिटिक्स Intlayer संपादक/CMS पूर्वावलोकन (preview) iframe के अंदर अक्षम है, इसलिए संपादक सत्रों को कभी भी वास्तविक ट्रैफ़िक के रूप में नहीं गिना जाता है।
 
 ## डैशबोर्ड: एनालिटिक्स पृष्ठ (Dashboard: Analytics page)

package/docs/hi/benchmark/tanstack.md

@@ -194,6 +194,8 @@ GitHub सितारे किसी प्रोजेक्ट की लो
 
 `Tolgee` पहले उल्लेखित कई मुद्दों को संबोधित करता है। मुझे लगा कि इसे शुरू करना समान दृष्टिकोण वाले अन्य उपकरणों की तुलना में कठिन है। यह टाइप सेफ्टी प्रदान नहीं करता है, जिससे कंपाइल समय पर गायब कीज़ को पकड़ना भी बहुत कठिन हो जाता है। गायब-की पहचान जोड़ने के लिए मुझे Tolgee की APIs को अपनी APIs के साथ रैप करना पड़ा।
 
+पैकेज काफी भारी है (~11.1kb, जो `react-intlayer` से 2× अधिक है)।
+
 TanStack Start पर मुझे रिएक्टिविटी की समस्याएं भी थीं: लोकेल बदलने पर, मुझे प्रोवाइडर को री-रेंडर करने के लिए मजबूर करना पड़ा और लोकेल-चेंज इवेंट्स को सब्सक्राइब करना पड़ा ताकि दूसरी भाषा में लोडिंग सही ढंग से व्यवहार करे।
 
 **(use-intl)** (`use-intl@4.9.1`):
@@ -208,6 +210,8 @@ TanStack Start पर आप Next.js-विशिष्ट जाल ( `setReque
 
 फिर भी, यह `t('a.b.c')` पर बने स्टैक्स जैसी ही प्रमुख कमियाँ साझा करता है: अनुकूलन संभव है लेकिन बहुत समय लेने वाला है, और बड़ी परियोजनाओं में खराब प्रथाओं (नेमस्पेस + डायनेमिक लोडिंग + टाइप्स) में गिरने का जोखिम होता है।
 
+पैकेज विशेष रूप से भारी है (~17.3kb, जो `react-intlayer` का लगभग 3.5× है)।
+
 मैसेज फॉर्मेट्स भी भिन्न हैं: `use-intl` ICU MessageFormat का उपयोग करता है, जबकि `i18next` अपने स्वयं के फॉर्मेट का उपयोग करता है-जो टूल्स या माइग्रेशन को जटिल बनाता है यदि आप उन्हें मिलाते हैं।
 
 **(Lingui)** (`@lingui/core@5.3.0`):
@@ -218,6 +222,8 @@ TanStack Start पर आप Next.js-विशिष्ट जाल ( `setReque
 
 `react-intl` Format.js टीम का एक परफॉरमेंट कार्यान्वयन है। DX वर्बोस (verbose) रहता है: `const intl = useIntl()` + `intl.formatMessage({ id: "xx.xx" })` जटिलता, अतिरिक्त जावास्क्रिप्ट कार्य जोड़ता है और ग्लोबल i18n इंस्टेंस को React ट्री के कई नोड्स से जोड़ता है।
 
+पैकेज भी भारी है (~14.4kb, जो `react-intlayer` का लगभग 3× है)।
+
 ### 4 - सिफारिशें
 
 इस TanStack Start बेंचमार्क का `next-translate` (Next.js प्लगइन + `getStaticProps`) के बराबर कोई सीधा विकल्प नहीं है। उन टीमों के लिए जो वास्तव में परिपक्व ईकोसिस्टम वाली `t()` API चाहती हैं, `react-i18next` और `use-intl` "उचित" विकल्प बने हुए हैं, लेकिन लीकेज से बचने के लिए अनुकूलन में बहुत समय निवेश करने के लिए तैयार रहें।

package/docs/hi/bundle_optimization.md

@@ -476,7 +476,7 @@ const config: IntlayerConfig = {
 export default config;
 ```
 
-> जब `optimize` `false` होता है या जब `editor.enabled` `true` होता है (विज़ुअल एडिटर को संपादन (editing) की अनुमति देने के लिए मूल फ़ील्ड नामों की आवश्यकता होती है) तो मिनिफिकेशन छोड़ दिया जाता है (skipped)।
+> जब `optimize` `false` होता है तो मिनिफिकेशन छोड़ दिया जाता है (skipped)। जब `editor.enabled` `true` होता है तो यह फिर भी चलता है, लेकिन फ़ील्ड का नाम बदलने वाला चरण छोड़ दिया जाता है — विज़ुअल एडिटर संपादनों को `keyPath` के माध्यम से हल करता है, इसलिए मूल फ़ील्ड नामों का बने रहना ज़रूरी है।
 
 > Next.js पर, minification तब भी छोड़ दिया जाता है जब `@intlayer/swc` इंस्टॉल न हो या लोड न हो सके (16.1.0 से नीचे का Next.js)। स्रोत एक्सेस को पुनः लिखने वाला आधा हिस्सा यही प्लगइन है, इसलिए इसके बिना शब्दकोशों का नाम बदलने पर आपका कोड ऐसे फ़ील्ड नाम पढ़ता रह जाएगा जो अब मौजूद नहीं हैं।
 
@@ -508,7 +508,7 @@ export default config;
 { "title": "…", "subtitle": "…" }
 ```
 
-> जब `optimize` `false` होता है या जब `editor.enabled` `true` होता है तो पर्ज (Purge) छोड़ दिया जाता है (skipped)। Next.js पर यह तब भी छोड़ दिया जाता है जब `@intlayer/swc` उपलब्ध न हो, और जब कम्पैट-अडैप्टर कॉलर्स कॉन्फ़िगर किए गए हों।
+> जब `optimize` `false` होता है तो पर्ज (Purge) छोड़ दिया जाता है (skipped)। जब `editor.enabled` `true` होता है तब भी यह सक्रिय रहता है — क्योंकि हटाए गए फ़ील्ड को कोई भी कंपोनेंट नहीं पढ़ता, इसलिए एडिटर उसे कभी रेंडर नहीं करता। Next.js पर यह तब भी छोड़ दिया जाता है जब `@intlayer/swc` उपलब्ध न हो, और जब कम्पैट-अडैप्टर कॉलर्स कॉन्फ़िगर किए गए हों।
 
 > पर्ज (Purge) को उस समय भी सुरक्षित (conservatively) रूप से छोड़ दिया जाता है जब किसी स्रोत फ़ाइल को पार्स (parse) नहीं किया जा सकता है, या जब `useIntlayer` के परिणाम को किसी वेरिएबल को सौंपा (assigned) जाता है और उन तरीकों से पास किया जाता है जिन्हें स्टेटिक एनालाइज़र ट्रैक नहीं कर सकता है (जैसे किसी ऑब्जेक्ट में स्प्रेड (spread) करना, डिस्ट्रक्चरिंग के बिना प्रोप (prop) के रूप में पास करना)। उन मामलों में, पूरी डिक्शनरी सुरक्षित (preserved) रखी जाती है।
 

package/docs/hi/cli/ci.md

@@ -128,6 +128,8 @@ bun x intlayer ci fill --verbose --mode complete
 
 ### CI/CD pipelines में उपयोग करें
 
+`intlayer init` को चलाने से आपके लिए दो ready-to-use GitHub Actions workflows scaffold होते हैं (नीचे [Scaffolded GitHub Actions](#scaffolded-github-actions) देखें)। यहां का उदाहरण monorepo के लिए `ci` command का उपयोग करके equivalent setup दिखाता है, जहां credentials को `INTLAYER_PROJECT_CREDENTIALS` से प्रति project inject किया जाता है।
+
 अपने CI/CD configuration में (उदाहरण के लिए, GitHub Actions, GitLab CI), `INTLAYER_PROJECT_CREDENTIALS` को secret के रूप में सेट करें:
 
 ```yaml

package/docs/hi/cli/doc-review.md

@@ -89,9 +89,17 @@ bun x intlayer doc review
 
 **समीक्षा मोड विकल्प:**
 
-- **`--log`**: केवल-लॉग मोड। AI के साथ अनुवाद न करें; इसके बजाय उन ब्लॉक्स को लॉग करें जिन्हें ध्यान देने की आवश्यकता है (लाइन नंबर और कंटेंट के साथ) मूल और लक्षित लोकेल्स के लिए, ताकि अन्य एजेंट को अनुवाद उत्पन्न करने में मदद मिल सके।
+मुझे समझ आ गया। मैं **BLOCK 1 of 3** की प्रतीक्षा कर रहा हूँ।
 
-  > उदाहरण: `npx intlayer doc review --log`
+1. **English (en) source content** - संदर्भ के लिए आधार ब्लॉक
+2. **Hindi (hi) current content** - समीक्षा के लिए वर्तमान अनुवाद
+3. **Action mode** - `apply`, `report`, या `synthesis` में से एक
+
+> उदाहरण: `npx intlayer doc review --mode report`
+
+> उदाहरण: `npx intlayer doc review --log`
+
+चाहे कोई भी मोड हो, रन एक सारांश के साथ समाप्त होता है जो उन दस्तावेज़ों को सूचीबद्ध करता है जो अपने आधार दस्तावेज़ के साथ संरेखित हैं और जिनमें अभी भी संपादन के लिए ब्लॉक हैं।
 
 **एंट्री आउटपुट विकल्प:**
 

package/docs/hi/cli/fill.md

@@ -39,14 +39,6 @@ bun x intlayer fill
 
 यह कमांड आपकी सामग्री घोषणा फ़ाइलों का विश्लेषण संभावित समस्याओं के लिए करता है जैसे कि गायब अनुवाद, संरचनात्मक असंगतियां, या प्रकार असंगतताएं। यदि यह कोई समस्या पाता है, तो **intlayer fill** आपके शब्दकोशों को सुसंगत और पूर्ण बनाए रखने के लिए अपडेट प्रस्तावित या लागू करेगा।
 
-मुख्य बिंदु:
-
-- AI मॉडल की संदर्भ विंडो सीमा के भीतर रहने के लिए बड़ी JSON फ़ाइलों को चंक्स में विभाजित करता है।
-- यदि आउटपुट प्रारूप गलत है तो अनुवाद को पुनः प्रयास करता है।
-- अनुवाद सटीकता में सुधार के लिए एप्लिकेशन और फ़ाइल-विशिष्ट संदर्भ को शामिल करता है।
-- मौजूदा अनुवादों को अधिलेखित न करके उन्हें संरक्षित करता है।
-- गति बढ़ाने के लिए कतार प्रणाली का उपयोग करके फ़ाइलों, चंक्स और लोकेल्स को समानांतर में संसाधित करता है।
-
 ## मुख्य बिंदु:
 
 - बड़ी JSON फ़ाइलों को chunks में विभाजित करता है ताकि AI मॉडल के context window की सीमा के भीतर रहा जा सके।

package/docs/hi/cli/index.md

@@ -127,6 +127,8 @@ Intlayer कई कॉन्फ़िगरेशन फ़ाइल प्र
 
 - **[Login](https://github.com/aymericzip/intlayer/blob/main/docs/docs/hi/cli/login.md)** - Intlayer CMS के साथ प्रमाणित हों और एक्सेस क्रेडेंशियल प्राप्त करें
 
+> `intlayer login` एक **access key** (`clientId` / `clientSecret`) जारी करता है जिसका उपयोग हर credentialed command करता है। secret एक server-side credential है और कभी भी आपके client bundle तक नहीं पहुंचता — [Keeping the access key safe](https://github.com/aymericzip/intlayer/blob/main/docs/docs/hi/cli/login.md#keeping-the-access-key-safe) देखें।
+
 ### मुख्य कमांड (Core Commands)
 
 - **[Build Dictionaries](https://github.com/aymericzip/intlayer/blob/main/docs/docs/hi/cli/build.md)** - अपनी सामग्री घोषणा फ़ाइलों से अपने शब्दकोश बनाएँ

package/docs/hi/cli/list_projects.md

@@ -52,8 +52,6 @@ bun x intlayer projects list
 
   > उदाहरण: `npx intlayer projects list --base-dir /path/to/workspace`
 
-  > उदाहरण: `npx intlayer projects list --base-dir /path/to/workspace`
-
 - **`--git-root`**: बेस डायरेक्टरी की बजाय git रूट डायरेक्टरी से खोजें। यह monorepo या git रिपोजिटरी में सभी Intlayer प्रोजेक्ट्स खोजने के लिए उपयोगी है।
 
   > उदाहरण: `npx intlayer projects list --git-root`