@intlayer/docs 8.12.1 → 8.12.3

package/docs/cs/intlayer_with_fastify.md

@@ -145,7 +145,7 @@ export default indexContent;
 }
 ```
 
-> Deklarace obsahu lze definovat kdekoli ve vaší aplikaci, pokud jsou zahrnuty v adresáři `contentDir` (ve výchozím nastavení `./src`). A musí odpovídat příponě souboru deklarace obsahu (ve výchozím nastavení `.content.{json,ts,tsx,js,jsx,mjs,cjs}`).
+> Deklarace obsahu lze definovat kdekoli ve vaší aplikaci, pokud jsou zahrnuty v adresáři `contentDir` (ve výchozím nastavení `./src`). A musí odpovídat příponě souboru deklarace obsahu (ve výchozím nastavení `.content.{json,ts,tsx,js,jsx,mjs,cjs,md,mdx,yaml,yml}`).
 
 > Další podrobnosti naleznete v [dokumentaci k deklaraci obsahu](https://github.com/aymericzip/intlayer/blob/main/docs/docs/cs/dictionary/content_file.md).
 

package/docs/cs/intlayer_with_hono.md

@@ -162,7 +162,7 @@ module.exports = indexContent;
 }
 ```
 
-> Deklarace vašeho obsahu lze definovat kdekoli ve vaší aplikaci, pokud jsou zahrnuty do adresáře `contentDir` (ve výchozím nastavení `./src`) a odpovídají příponě souboru deklarace obsahu (ve výchozím nastavení `.content.{json,ts,tsx,js,jsx,mjs,cjs}`).
+> Deklarace vašeho obsahu lze definovat kdekoli ve vaší aplikaci, pokud jsou zahrnuty do adresáře `contentDir` (ve výchozím nastavení `./src`) a odpovídají příponě souboru deklarace obsahu (ve výchozím nastavení `.content.{json,ts,tsx,js,jsx,mjs,cjs,md,mdx,yaml,yml}`).
 
 > Další podrobnosti naleznete v [dokumentaci deklarace obsahu](https://github.com/aymericzip/intlayer/blob/main/docs/docs/cs/dictionary/content_file.md).
 

package/docs/cs/intlayer_with_vanilla.md

@@ -290,7 +290,7 @@ export default appContent;
 }
 ```
 
-> Deklarace obsahu mohou být definovány kdekoli ve vaší aplikaci, pokud jsou zahrnuty v adresáři `contentDir` (ve výchozím nastavení `./src`). A odpovídají příponě souboru s deklarací obsahu (ve výchozím nastavení `.content.{json,ts,tsx,js,jsx,mjs,cjs}`).
+> Deklarace obsahu mohou být definovány kdekoli ve vaší aplikaci, pokud jsou zahrnuty v adresáři `contentDir` (ve výchozím nastavení `./src`). A odpovídají příponě souboru s deklarací obsahu (ve výchozím nastavení `.content.{json,ts,tsx,js,jsx,mjs,cjs,md,mdx,yaml,yml}`).
 >
 > Další podrobnosti naleznete v [dokumentaci k deklaraci obsahu](https://github.com/aymericzip/intlayer/blob/main/docs/docs/cs/dictionary/content_file.md).
 

package/docs/cs/intlayer_with_vite+lit.md

@@ -267,7 +267,7 @@ export default appContent;
 }
 ```
 
-> Vaše deklarace obsahu mohou být definovány kdekoli ve vaší aplikaci, pokud jsou zahrnuty v adresáři `contentDir` (ve výchozím nastavení `./src`) a odpovídají příponě souboru deklarace obsahu (ve výchozím nastavení `.content.{json,ts,tsx,js,jsx,mjs,cjs}`).
+> Vaše deklarace obsahu mohou být definovány kdekoli ve vaší aplikaci, pokud jsou zahrnuty v adresáři `contentDir` (ve výchozím nastavení `./src`) a odpovídají příponě souboru deklarace obsahu (ve výchozím nastavení `.content.{json,ts,tsx,js,jsx,mjs,cjs,md,mdx,yaml,yml}`).
 >
 > Pro více informací se podívejte do [dokumentace deklarace obsahu](https://github.com/aymericzip/intlayer/blob/main/docs/docs/cs/dictionary/content_file.md).
 

package/docs/cs/intlayer_with_vite+vanilla.md

@@ -259,7 +259,7 @@ export default appContent;
 }
 ```
 
-> Vaše deklarace obsahu mohou být definovány kdekoli ve vaší aplikaci, pokud jsou zahrnuty v adresáři `contentDir` (ve výchozím nastavení `./src`). A odpovídají příponě souboru deklarace obsahu (ve výchozím nastavení `.content.{json,ts,tsx,js,jsx,mjs,cjs}`).
+> Vaše deklarace obsahu mohou být definovány kdekoli ve vaší aplikaci, pokud jsou zahrnuty v adresáři `contentDir` (ve výchozím nastavení `./src`). A odpovídají příponě souboru deklarace obsahu (ve výchozím nastavení `.content.{json,ts,tsx,js,jsx,mjs,cjs,md,mdx,yaml,yml}`).
 >
 > Více podrobností naleznete v [dokumentaci k deklaraci obsahu](https://github.com/aymericzip/intlayer/blob/main/docs/docs/cs/dictionary/content_file.md).
 

package/docs/de/bundle_optimization.md

@@ -1,10 +1,10 @@
 ---
 createdAt: 2025-11-25
-updatedAt: 2026-04-08
-title: Optimierung der i18n-Bundle-Größe und Leistung
-description: Reduzieren Sie die Bundle-Größe Ihrer Anwendung, indem Sie Internationalisierungs-Inhalte (i18n) optimieren. Erfahren Sie, wie Sie Tree Shaking und Lazy Loading für Wörterbücher mit Intlayer nutzen.
+updatedAt: 2026-06-07
+title: Optimierung der i18n-Bundle-Größe & Leistung
+description: Reduzieren Sie die Bundle-Größe Ihrer Anwendung, indem Sie den Inhalt der Internationalisierung (i18n) optimieren. Erfahren Sie, wie Sie Tree Shaking und Lazy Loading für Wörterbücher mit Intlayer nutzen.
 keywords:
-  - Bundle-Optimierung
+  - Bundle Optimierung
   - Inhaltsautomatisierung
   - Dynamischer Inhalt
   - Intlayer
@@ -16,33 +16,36 @@ slugs:
   - concept
   - bundle-optimization
 history:
+  - version: 8.12.0
+    date: 2026-06-07
+    changes: "Hinzufügen von `intlayerPurgeBabelPlugin` und `intlayerMinifyBabelPlugin` für Babel/Webpack; Klarstellung der Plugin-Pipeline"
   - version: 8.7.0
     date: 2026-04-08
-    changes: "Optionen `minify` und `purge` zur Build-Konfiguration hinzugefügt"
+    changes: "Hinzufügen der Optionen `minify` und `purge` zur Build-Konfiguration"
 ---
 
-# Optimierung der i18n-Bundle-Größe und Leistung
+# Optimierung der i18n-Bundle-Größe & Leistung
 
-Eine der häufigsten Herausforderungen bei traditionellen i18n-Lösungen, die auf JSON-Dateien basieren, ist die Verwaltung der Inhaltsgröße. Wenn Entwickler Inhalte nicht manuell in Namensräume trennen, laden Benutzer oft Übersetzungen für jede Seite und potenziell jede Sprache herunter, nur um eine einzige Seite anzuzeigen.
+Eine der häufigsten Herausforderungen bei traditionellen i18n-Lösungen, die auf JSON-Dateien basieren, ist die Verwaltung der Inhaltsgröße. Wenn Entwickler den Inhalt nicht manuell in Namespaces trennen, laden Benutzer oft Übersetzungen für jede Seite und möglicherweise jede Sprache herunter, nur um eine einzige Seite anzuzeigen.
 
-Beispielsweise könnte eine Anwendung mit 10 Seiten, die in 10 Sprachen übersetzt wurden, dazu führen, dass ein Benutzer den Inhalt von 100 Seiten herunterlädt, obwohl er nur **eine** benötigt (die aktuelle Seite in der aktuellen Sprache). Dies führt zu verschwendeter Bandbreite und langsameren Ladezeiten.
+Beispielsweise könnte eine Anwendung mit 10 Seiten, die in 10 Sprachen übersetzt sind, dazu führen, dass ein Benutzer den Inhalt von 100 Seiten herunterlädt, obwohl er nur **eine** (die aktuelle Seite in der aktuellen Sprache) benötigt. Dies führt zu verschwendeter Bandbreite und langsameren Ladezeiten.
 
-**Intlayer löst dieses Problem durch Optimierung zur Build-Zeit.** Es analysiert Ihren Code, um festzustellen, welche Wörterbücher tatsächlich pro Komponente verwendet werden, und fügt nur den erforderlichen Inhalt in Ihr Bundle ein.
+**Intlayer löst dieses Problem durch Optimierung zur Build-Zeit.** Es analysiert Ihren Code, um zu erkennen, welche Wörterbücher pro Komponente tatsächlich verwendet werden, und fügt nur den notwendigen Inhalt in Ihr Bundle ein.
 
 ## Inhaltsverzeichnis
 
 <TOC />
 
-## Bundle scannen
+## Analysieren Sie Ihr Bundle
 
-Die Analyse Ihres Bundles ist der erste Schritt zur Identifizierung „schwerer“ JSON-Dateien und Möglichkeiten zum Code-Splitting. Diese Tools generieren eine visuelle Treemap des kompilierten Codes Ihrer Anwendung, sodass Sie genau sehen können, welche Bibliotheken den meisten Platz verbrauchen.
+Die Analyse Ihres Bundles ist der erste Schritt zur Identifizierung "schwerer" JSON-Dateien und Möglichkeiten zum Code-Splitting. Diese Tools generieren eine visuelle Treemap des kompilierten Codes Ihrer Anwendung, sodass Sie genau sehen können, welche Bibliotheken den meisten Platz beanspruchen.
 
 <Tabs>
  <Tab value="vite">
 
 ### Vite / Rollup
 
-Vite verwendet Rollup unter der Haube. Das Plugin `rollup-plugin-visualizer` generiert eine interaktive HTML-Datei, die die Größe jedes Moduls in Ihrem Graphen anzeigt.
+Vite verwendet Rollup im Hintergrund. Das Plugin `rollup-plugin-visualizer` generiert eine interaktive HTML-Datei, die die Größe jedes Moduls in Ihrem Diagramm anzeigt.
 
 ```bash
 npm install -D rollup-plugin-visualizer
@@ -55,7 +58,7 @@ import { visualizer } from "rollup-plugin-visualizer";
 export default defineConfig({
   plugins: [
     visualizer({
-      open: true, // Bericht automatisch im Browser öffnen
+      open: true, // Öffnet den Bericht automatisch in Ihrem Browser
       filename: "stats.html",
       gzipSize: true,
       brotliSize: true,
@@ -92,7 +95,7 @@ bun next experimental-analyze
 
 ### Next.js (Webpack)
 
-Wenn Sie den Standard-Webpack-Bundler in Next.js verwenden, nutzen Sie den offiziellen Bundle-Analyzer. Aktivieren Sie ihn, indem Sie während des Builds eine Umgebungsvariable setzen.
+Wenn Sie den Standard-Webpack-Bundler in Next.js verwenden, verwenden Sie den offiziellen Bundle-Analyzer. Lösen Sie ihn aus, indem Sie während Ihres Builds eine Umgebungsvariable festlegen.
 
 ```bash packageManager='npm'
 npm install -D @next/bundle-analyzer
@@ -116,7 +119,7 @@ const withBundleAnalyzer = require("@next/bundle-analyzer")({
 });
 
 module.exports = withBundleAnalyzer({
-  // Ihre Next.js-Konfiguration
+  // Ihre Next.js Konfiguration
 });
 ```
 
@@ -131,7 +134,7 @@ ANALYZE=true npm run build
 
 ### Standard Webpack
 
-Für Create React App (ejected), Angular oder benutzerdefinierte Webpack-Setups verwenden Sie den Branchenstandard `webpack-bundle-analyzer`.
+Verwenden Sie für Create React App (ejected), Angular oder benutzerdefinierte Webpack-Setups den branchenüblichen `webpack-bundle-analyzer`.
 
 ```bash packageManager='npm'
 npm install -D webpack-bundle-analyzer
@@ -166,29 +169,66 @@ export default {
  </Tab>
 </Tabs>
 
-## Funktionsweise
+## Wie es funktioniert
 
-Intlayer verwendet einen **Ansatz pro Komponente**. Im Gegensatz zu globalen JSON-Dateien wird Ihr Inhalt neben oder innerhalb Ihrer Komponenten definiert. Während des Build-Prozesses führt Intlayer folgende Schritte aus:
+Intlayer verwendet einen **pro-Komponente-Ansatz**. Im Gegensatz zu globalen JSON-Dateien wird Ihr Inhalt neben oder in Ihren Komponenten definiert. Während des Build-Prozesses führt Intlayer Folgendes aus:
 
-1.  **Analysiert** Ihren Code, um `useIntlayer`-Aufrufe zu finden.
-2.  **Erstellt** den entsprechenden Wörterbuchinhalt.
-3.  **Ersetzt** den `useIntlayer`-Aufruf durch optimierten Code basierend auf Ihrer Konfiguration.
+1. **Analysiert** Ihren Code, um `useIntlayer`-Aufrufe zu finden.
+2. **Baut** den entsprechenden Wörterbuchinhalt auf.
+3. **Ersetzt** den `useIntlayer`-Aufruf durch optimierten Code basierend auf Ihrer Konfiguration.
 
 Dies stellt sicher, dass:
 
-- Wenn eine Komponente nicht importiert wird, ihr Inhalt nicht im Bundle enthalten ist (Dead Code Elimination).
-- Wenn eine Komponente per Lazy Loading geladen wird, ihr Inhalt ebenfalls per Lazy Loading geladen wird.
+- Wenn eine Komponente nicht importiert wird, deren Inhalt nicht im Bundle enthalten ist (Dead Code Elimination).
+- Wenn eine Komponente verzögert geladen wird (lazy loaded), ihr Inhalt ebenfalls verzögert geladen wird.
 
-## Einrichtung nach Plattform
+## Plugin-Referenz
+
+Die Build-Optimierung von Intlayer ist auf mehrere diskrete Plugins aufgeteilt, von denen jedes eine einzige Aufgabe hat. Zu verstehen, was jedes Plugin tut, verhindert Verwirrung beim Einrichten.
+
+### Babel Plugins (`@intlayer/babel`)
+
+Diese werden direkt in der `babel.config.js` für Webpack-basierte Setups verwendet (Next.js mit Babel, CRA, benutzerdefiniertes Webpack usw.).
+
+| Plugin                        | Was es tut                                                                                                                  |
+| :---------------------------- | :-------------------------------------------------------------------------------------------------------------------------- |
+| `intlayerExtractBabelPlugin`  | Scannt `.content.ts`-Dateien und schreibt kompilierte Wörterbücher nach `.intlayer/`                                        |
+| `intlayerOptimizeBabelPlugin` | Schreibt `useIntlayer('key')` → `useDictionary(hash)` um und fügt den passenden `import` des Wörterbuchs ein                |
+| `intlayerPurgeBabelPlugin`    | Scannt alle Quelldateien und entfernt **nicht verwendete Inhaltsfelder** aus den kompilierten `.intlayer/**/*.json`-Dateien |
+| `intlayerMinifyBabelPlugin`   | **Benennt Inhaltsfeld-Schlüssel um** in kurze alphabetische Aliase (`title` → `a`) in JSON-Dateien und im Quellcode         |
+
+> **Die Reihenfolge der Plugins ist wichtig.** In Ihrer `babel.config.js` müssen das Purge- und Minify-Plugin **vor** dem Optimize-Plugin aufgeführt sein. Der Optimize-Pass ersetzt `useIntlayer('key')` durch einen undurchsichtigen `useDictionary(hash)`-Aufruf, wodurch die Information über den Wörterbuchschlüssel gelöscht wird, die der Purge- und Minify-Pass benötigen, um zu identifizieren, welche Felder verwendet werden.
+
+Jedes Babel-Plugin verfügt über einen entsprechenden Options-Helfer, der Ihre `intlayer.config.ts` einmal zur Konfigurationsladezeit liest und vorab aufgelöste Werte zurückgibt:
+
+| Options-Helfer               | Verwendet mit                 |
+| :--------------------------- | :---------------------------- |
+| `getExtractPluginOptions()`  | `intlayerExtractBabelPlugin`  |
+| `getOptimizePluginOptions()` | `intlayerOptimizeBabelPlugin` |
+| `getPurgePluginOptions()`    | `intlayerPurgeBabelPlugin`    |
+| `getMinifyPluginOptions()`   | `intlayerMinifyBabelPlugin`   |
+
+### Vite Plugins (`vite-intlayer`)
+
+Vite-Benutzer **konfigurieren diese nie direkt**. Sie werden automatisch eingerichtet, wenn Sie `withIntlayer()` in der `vite.config.ts` aufrufen. Die Flags `build.purge` und `build.minify` in der `intlayer.config.ts` schalten das entsprechende Verhalten ohne zusätzliche Plugin-Registrierung um.
+
+| Internes Vite Plugin | Äquivalentes Verhalten                                                                               |
+| :------------------- | :--------------------------------------------------------------------------------------------------- |
+| Usage analyzer       | Gleich wie die Analysephase des `intlayerPurgeBabelPlugin`                                           |
+| Dictionary prune     | Gleich wie die JSON-Schreibphase des `intlayerPurgeBabelPlugin`                                      |
+| Dictionary minify    | Gleich wie die JSON-Schreibphase des `intlayerMinifyBabelPlugin`                                     |
+| Babel transform      | Gleich wie die Quellcode-Umbenennung des `intlayerMinifyBabelPlugin` + `intlayerOptimizeBabelPlugin` |
+
+## Setup nach Plattform
 
 <Tabs>
  <Tab value="nextjs">
 
 ### Next.js
 
-Next.js benötigt das `@intlayer/swc`-Plugin, um die Transformation zu handhaben, da Next.js SWC für Builds verwendet.
+Next.js erfordert das Plugin `@intlayer/swc` für den Optimize-Pass (Import-Umschreibung), da Next.js SWC für Builds verwendet.
 
-> Dieses Plugin ist standardmäßig nicht installiert, da SWC-Plugins für Next.js noch experimentell sind. Dies kann sich in Zukunft ändern.
+> Dieses Plugin ist nicht standardmäßig installiert, da SWC-Plugins für Next.js noch experimentell sind. Dies kann sich in Zukunft ändern.
 
 ```bash packageManager="npm"
 npm install -D @intlayer/swc
@@ -206,21 +246,63 @@ pnpm add -D @intlayer/swc
 bun add -d @intlayer/swc
 ```
 
-Nach der Installation erkennt und verwendet Intlayer das Plugin automatisch.
+Nach der Installation erkennt Intlayer das Plugin automatisch und verwendet es.
+
+Für die **Purge- und Minify**-Durchgänge (Feldentfernung und Feldumbenennung) installieren Sie parallel `@intlayer/babel` und fügen Sie die Babel-Plugins hinzu. Da Next.js SWC für die Transformation verwendet, aber weiterhin `babel.config.js` für die Plugin-Konfiguration auswertet, werden die Babel-Plugins als Vorpass vor SWC ausgeführt.
+
+```bash packageManager="npm"
+npm install -D @intlayer/babel
+```
+
+```javascript fileName="babel.config.js"
+const {
+  intlayerPurgeBabelPlugin,
+  intlayerMinifyBabelPlugin,
+  getPurgePluginOptions,
+  getMinifyPluginOptions,
+} = require("@intlayer/babel");
+
+module.exports = {
+  presets: ["next/babel"],
+  plugins: [
+    // Purge: Entfernt nicht verwendete Inhaltsfelder aus .intlayer/**/*.json
+    [intlayerPurgeBabelPlugin, getPurgePluginOptions()],
+    // Minify: Benennt Inhaltsfeld-Schlüssel im JSON + Quellcode um
+    [intlayerMinifyBabelPlugin, getMinifyPluginOptions()],
+    // Hinweis: intlayerOptimizeBabelPlugin wird hier NICHT benötigt, da
+    // @intlayer/swc die Umschreibung useIntlayer → useDictionary übernimmt.
+  ],
+};
+```
 
  </Tab>
  <Tab value="vite">
 
 ### Vite
 
-Vite verwendet das `@intlayer/babel`-Plugin, das als Abhängigkeit von `vite-intlayer` enthalten ist. Die Optimierung ist standardmäßig aktiviert. Es ist nichts weiter zu tun.
+Vite verwendet das Plugin `@intlayer/babel`, das als Abhängigkeit von `vite-intlayer` enthalten ist. Die gesamte Optimierungspipeline — Importumschreibung, Purge und Minify — ist standardmäßig aktiviert und erfordert keine zusätzliche Plugin-Registrierung.
+
+Aktivieren Sie Purge und Minify, indem Sie die entsprechenden Flags in `intlayer.config.ts` festlegen:
+
+```typescript fileName="intlayer.config.ts"
+import type { IntlayerConfig } from "intlayer";
+
+const config: IntlayerConfig = {
+  build: {
+    purge: true, // Entfernt nicht verwendete Inhaltsfelder aus gebündelten JSONs
+    minify: true, // Benennt Inhaltsfeld-Schlüssel in kurze Aliase um
+  },
+};
+
+export default config;
+```
 
  </Tab>
  <Tab value="webpack">
 
-### Webpack
+### Webpack (und Next.js mit Babel)
 
-Um die Bundle-Optimierung mit Intlayer in Webpack zu aktivieren, müssen Sie das entsprechende Babel- (`@intlayer/babel`) oder SWC- (`@intlayer/swc`) Plugin installieren und konfigurieren.
+Installieren Sie `@intlayer/babel`:
 
 ```bash packageManager="npm"
 npm install -D @intlayer/babel
@@ -238,14 +320,37 @@ pnpm add -D @intlayer/babel
 bun add -d @intlayer/babel
 ```
 
-```typescript fileName="babel.config.js"
+Fügen Sie alle vier Plugins in der richtigen Reihenfolge zur `babel.config.js` hinzu:
+
+```javascript fileName="babel.config.js"
 const {
-  getOptimizePluginOptions,
+  intlayerExtractBabelPlugin,
+  intlayerPurgeBabelPlugin,
+  intlayerMinifyBabelPlugin,
   intlayerOptimizeBabelPlugin,
+  getExtractPluginOptions,
+  getPurgePluginOptions,
+  getMinifyPluginOptions,
+  getOptimizePluginOptions,
 } = require("@intlayer/babel");
 
 module.exports = {
-  plugins: [[intlayerOptimizeBabelPlugin, getOptimizePluginOptions()]],
+  plugins: [
+    // Extract: kompiliert .content.ts Dateien → .intlayer/**/*.json
+    [intlayerExtractBabelPlugin, getExtractPluginOptions()],
+
+    // Purge: entfernt nicht verwendete Felder aus .intlayer/**/*.json
+    //    (liest das Flag build.purge aus intlayer.config.ts)
+    [intlayerPurgeBabelPlugin, getPurgePluginOptions()],
+
+    // Minify: benennt Feld-Schlüssel in JSON + Quellcode um
+    //    (liest das Flag build.minify aus intlayer.config.ts)
+    [intlayerMinifyBabelPlugin, getMinifyPluginOptions()],
+
+    // Optimize: schreibt useIntlayer('key') → useDictionary(hash) um
+    //    Muss zuletzt stehen, da es den Wörterbuchschlüssel löscht.
+    [intlayerOptimizeBabelPlugin, getOptimizePluginOptions()],
+  ],
 };
 ```
 
@@ -254,57 +359,62 @@ module.exports = {
 
 ## Konfiguration
 
-Sie können steuern, wie Intlayer Ihr Bundle optimiert, indem Sie die Eigenschaft `build` in Ihrer `intlayer.config.ts` verwenden.
+Sie können steuern, wie Intlayer Ihr Bundle optimiert, über die Eigenschaft `build` in Ihrer `intlayer.config.ts`.
 
 ```typescript fileName="intlayer.config.ts"
 import { Locales, type IntlayerConfig } from "intlayer";
 
 const config: IntlayerConfig = {
   internationalization: {
-    locales: [Locales.ENGLISH, Locales.FRENCH],
+    locales: [Locales.ENGLISH, Locales.GERMAN],
     defaultLocale: Locales.ENGLISH,
   },
   dictionary: {
     importMode: "dynamic",
   },
   build: {
-    /**
-     * Wörterbücher minimieren, um die Bundle-Größe zu reduzieren.
-     */
-     minify: true;
-
-    /**
-     * Nicht verwendete Schlüssel in Wörterbüchern entfernen (Purge)
-     */
-     purge: true;
-
-    /**
-     * Gibt an, ob beim Build TypeScript-Typen geprüft werden sollen
-     */
-    checkTypes: false;
+    // Ersetzt useIntlayer() Aufrufe zur Build-Zeit durch direkte Wörterbuch-Importe.
+    // undefined = auto (aktiviert in der Produktion), true = immer, false = nie.
+    optimize: undefined,
+
+    // Benennt Inhaltsfeld-Schlüssel in kompilierten Wörterbüchern in kurze alphabetische
+    // Aliase um (z.B. title → a). Reduziert die JSON-Größe; erfordert optimize.
+    minify: true,
+
+    // Entfernt Inhaltsfelder, die im Quellcode nie aufgerufen werden.
+    // Erfordert optimize.
+    purge: true,
   },
 };
 
 export default config;
 ```
 
-> In den meisten Fällen wird empfohlen, die Standardoption für `optimize` beizubehalten.
+> Es wird empfohlen, in den meisten Fällen den Standardwert (`undefined`) für `optimize` beizubehalten.
 
-> Weitere Details finden Sie in der Konfigurationsdokumentation: [Konfiguration](https://github.com/aymericzip/intlayer/blob/main/docs/docs/de/configuration.md)
+> Siehe die Konferenzreferenz für alle Optionen: [Konfiguration](https://github.com/aymericzip/intlayer/blob/main/docs/docs/de/configuration.md)
 
 ### Build-Optionen
 
-Folgende Optionen sind im `build`-Konfigurationsobjekt verfügbar:
+| Eigenschaft    | Typ                    | Standard    | Beschreibung                                                                                                                                                                                                                    |
+| :------------- | :--------------------- | :---------- | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| **`optimize`** | `boolean \| undefined` | `undefined` | Aktiviert den Import-Umschreibungspass. `undefined` = nur in Produktionsbuilds aktiv. `false` deaktiviert auch Purge und Minify.                                                                                                |
+| **`minify`**   | `boolean`              | `false`     | Benennt Inhaltsfeld-Schlüssel in kompilierten JSON-Dateien in kurze alphabetische Aliase um. Schreibt auch entsprechende Eigenschaftszugriffe im Quellcode um. Hat keine Auswirkungen, wenn `optimize` auf `false` gesetzt ist. |
+| **`purge`**    | `boolean`              | `false`     | Entfernt Inhaltsfelder, auf die nie statisch im Quellcode zugegriffen wird, aus den kompilierten JSON-Dateien. Hat keine Auswirkungen, wenn `optimize` auf `false` gesetzt ist.                                                 |
 
-| Eigenschaft    | Typ       | Standard    | Beschreibung                                                                                                                                                                                                                    |
-| :------------- | :-------- | :---------- | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
-| **`optimize`** | `boolean` | `undefined` | Steuert, ob die Build-Optimierung aktiviert ist. Wenn `true`, ersetzt Intlayer Wörterbuchaufrufe durch optimierte Injektionen. Wenn `false`, ist die Optimierung deaktiviert. Im Idealfall in der Produktion auf `true` setzen. |
-| **`minify`**   | `boolean` | `false`     | Ob die Wörterbücher minimiert werden sollen, um die Bundle-Größe zu reduzieren.                                                                                                                                                 |
-| **`purge`**    | `boolean` | `false`     | Ob nicht verwendete Schlüssel in Wörterbüchern entfernt werden sollen.                                                                                                                                                          |
+### Minifizierung (Feld-Schlüssel-Umbennung)
 
-### Minimierung
+`build.minify` verkleinert **nicht** Ihr JavaScript-Bundle — das erledigt Ihr Bundler. Stattdessen schrumpft es die kompilierten Wörterbuch-JSON-Dateien, indem jeder benutzerdefinierte Inhaltsfeld-Schlüssel durch einen kurzen alphabetischen Alias ersetzt wird:
 
-Die Minimierung von Wörterbüchern entfernt unnötige Leerzeichen, Kommentare und reduziert die Größe des JSON-Inhalts. Dies ist besonders nützlich für große Wörterbücher.
+```
+// Vor der Minifizierung
+{ "title": "Hallo", "subtitle": "Welt" }
+
+// Nach der Minifizierung
+{ "a": "Hallo", "b": "Welt" }
+```
+
+Dieselbe Umbenennung wird auf alle Eigenschaftszugriffe in Ihrem Quellcode angewendet, sodass `content.title` in der kompilierten Ausgabe zu `content.a` wird. Das Verhalten zur Laufzeit bleibt identisch.
 
 ```typescript fileName="intlayer.config.ts"
 import type { IntlayerConfig } from "intlayer";
@@ -318,11 +428,13 @@ const config: IntlayerConfig = {
 export default config;
 ```
 
-> Hinweis: Die Minimierung wird ignoriert, wenn `optimize` deaktiviert ist oder wenn der Visual Editor aktiviert ist (da der Editor den vollständigen Inhalt benötigt, um Bearbeitungen zu ermöglichen).
+> Die Minifizierung wird übersprungen, wenn `optimize` auf `false` gesetzt ist oder wenn `editor.enabled` auf `true` steht (der visuelle Editor benötigt die ursprünglichen Feldnamen, um die Bearbeitung zu ermöglichen).
+
+> Die Minifizierung wird ebenfalls für Wörterbücher übersprungen, die über `importMode: 'fetch'` geladen werden, da deren JSON von einer Remote-API mit den ursprünglichen Feldnamen bereitgestellt wird — das Umbenennen der clientseitigen Schlüssel würde den Server/Client-Vertrag brechen.
 
-### Purging (Bereinigung)
+### Purging (Entfernen ungenutzter Felder)
 
-Purging stellt sicher, dass nur die tatsächlich in Ihrem Code verwendeten Schlüssel im finalen Wörterbuch-Bundle enthalten sind. Dies kann die Größe Ihres Bundles erheblich reduzieren, wenn Sie große Wörterbücher mit vielen Schlüsseln haben, die nicht in jedem Teil Ihrer Anwendung verwendet werden.
+`build.purge` analysiert, auf welche Inhaltsfelder in Ihrem Quellcode tatsächlich zugegriffen wird, und entfernt alle anderen aus den kompilierten JSON-Dateien.
 
 ```typescript fileName="intlayer.config.ts"
 import type { IntlayerConfig } from "intlayer";
@@ -336,34 +448,50 @@ const config: IntlayerConfig = {
 export default config;
 ```
 
-> Hinweis: Purging wird ignoriert, wenn `optimize` deaktiviert ist.
+**Beispiel:** Ein Wörterbuch mit fünf Feldern, von denen nur zwei verwendet werden:
+
+```
+// Vor dem Purge
+{ "title": "…", "subtitle": "…", "cta": "…", "footer": "…", "badge": "…" }
+
+// Nach dem Purge (nur auf title + subtitle wird im Quellcode zugegriffen)
+{ "title": "…", "subtitle": "…" }
+```
+
+> Der Purge wird übersprungen, wenn `optimize` auf `false` oder `editor.enabled` auf `true` gesetzt ist.
+
+> Der Purge wird auch konservativ übersprungen, wenn eine Quelldatei nicht analysiert werden kann, oder wenn das Ergebnis von `useIntlayer` einer Variablen zugewiesen und auf eine Weise weitergegeben wird, die der statische Analysator nicht verfolgen kann (z.B. in ein Objekt eingefügt oder als Prop ohne Destrukturierung übergeben). In diesen Fällen wird das gesamte Wörterbuch beibehalten.
 
 ### Import-Modus
 
-Für große Anwendungen, die mehrere Seiten und Sprachen umfassen, können Ihre JSON-Dateien einen erheblichen Teil Ihrer Bundle-Größe ausmachen. Intlayer ermöglicht es Ihnen zu steuern, wie Wörterbücher geladen werden.
+Für große Anwendungen, die mehrere Seiten und Sprachen umfassen, kann das JSON einen erheblichen Teil der Größe Ihres Bundles ausmachen. Intlayer ermöglicht es Ihnen zu steuern, wie Wörterbücher mit der `importMode`-Option geladen werden.
+
+### Globale Definition
 
-Der Import-Modus kann standardmäßig global in Ihrer `intlayer.config.ts`-Datei definiert werden.
+Der Import-Modus kann global in Ihrer `intlayer.config.ts`-Datei definiert werden.
 
 ```typescript fileName="intlayer.config.ts"
 import type { IntlayerConfig } from "intlayer";
 
 const config: IntlayerConfig = {
-  build: {
-    minify: true,
+  dictionary: {
+    importMode: "dynamic", // Standard ist 'static'
   },
 };
 
 export default config;
 ```
 
-Ebenso wie für jedes Wörterbuch in Ihren `.content.{{ts|tsx|js|jsx|mjs|cjs|json|jsonc|json5}}`-Dateien.
+### Pro-Wörterbuch-Definition
+
+Sie können den Import-Modus für einzelne Wörterbücher in deren `.content.{{ts|tsx|js|jsx|mjs|cjs|json|jsonc|json5|md|mdx|yaml|yml}}`-Dateien überschreiben.
 
 ```ts
 import { type Dictionary, t } from "intlayer";
 
 const appContent: Dictionary = {
   key: "app",
-  importMode: "dynamic", // Standard-Importmodus überschreiben
+  importMode: "dynamic", // Überschreibt den standardmäßigen Import-Modus
   content: {
     // ...
   },
@@ -372,20 +500,19 @@ const appContent: Dictionary = {
 export default appContent;
 ```
 
-| Eigenschaft      | Typ                                | Standard   | Beschreibung                                                                                                                      |
-| :--------------- | :--------------------------------- | :--------- | :-------------------------------------------------------------------------------------------------------------------------------- |
-| **`importMode`** | `'static'`, `'dynamic'`, `'fetch'` | `'static'` | **Veraltet**: Verwenden Sie stattdessen `dictionary.importMode`. Bestimmt, wie Wörterbücher geladen werden (siehe Details unten). |
+| Eigenschaft      | Typ                                | Standard   | Beschreibung                                                                                                               |
+| :--------------- | :--------------------------------- | :--------- | :------------------------------------------------------------------------------------------------------------------------- |
+| **`importMode`** | `'static'`, `'dynamic'`, `'fetch'` | `'static'` | **Veraltet**: Verwenden Sie stattdessen `dictionary.importMode`. Legt fest, wie Wörterbücher geladen werden (siehe unten). |
 
-Die Einstellung `importMode` legt fest, wie der Wörterbuchinhalt in Ihre Komponente eingefügt wird.
-Sie können dies global in der Datei `intlayer.config.ts` unter dem Objekt `dictionary` definieren oder für ein bestimmtes Wörterbuch in dessen `.content.ts`-Datei überschreiben.
+Die Einstellung `importMode` bestimmt, wie der Wörterbuchinhalt in Ihre Komponente eingefügt wird. Sie können dies global in der `intlayer.config.ts` unter dem Objekt `dictionary` definieren oder für jedes Wörterbuch einzeln in dessen `.content.ts`-Datei überschreiben.
 
 ### 1. Statischer Modus (`default`)
 
-Im statischen Modus ersetzt Intlayer `useIntlayer` durch `useDictionary` und fügt das Wörterbuch direkt in das JavaScript-Bundle ein.
+Im statischen Modus ersetzt Intlayer `useIntlayer` durch `useDictionary` und injiziert das Wörterbuch direkt ins JavaScript-Bundle.
 
-- **Vorteile:** Sofortiges Rendering (synchron), keine zusätzlichen Netzwerkanfragen während der Hydrierung.
+- **Vorteile:** Sofortiges Rendering (synchron), keine zusätzlichen Netzwerkanfragen während der Hydratation.
 - **Nachteile:** Das Bundle enthält Übersetzungen für **alle** verfügbaren Sprachen für diese spezifische Komponente.
-- **Ideal für:** Single Page Applications (SPA).
+- **Am besten für:** Single Page Applications (SPA).
 
 **Beispiel für transformierten Code:**
 
@@ -393,14 +520,15 @@ Im statischen Modus ersetzt Intlayer `useIntlayer` durch `useDictionary` und fü
 // Ihr Code
 const content = useIntlayer("my-key");
 
-// Optimierter Code (Statisch)
+// Veranschaulichung des optimierten Codes nach der Transformation (Statisch)
+// Dies dient nur zur Veranschaulichung, der tatsächliche Code unterscheidet sich aus Optimierungsgründen
 const content = useDictionary({
   key: "my-key",
   content: {
     nodeType: "translation",
     translation: {
       en: "My title",
-      fr: "Mon titre",
+      de: "Mein Titel",
     },
   },
 });
@@ -408,11 +536,11 @@ const content = useDictionary({
 
 ### 2. Dynamischer Modus
 
-Im dynamischen Modus ersetzt Intlayer `useIntlayer` durch `useDictionaryAsync`. Dies verwendet `import()` (ähnlich wie Suspense), um speziell das JSON für die aktuelle Sprache nachzuladen (Lazy Loading).
+Im dynamischen Modus ersetzt Intlayer `useIntlayer` durch `useDictionaryAsync`. Dies verwendet `import()` (ähnlich dem Suspense-Mechanismus), um spezifisch das JSON für die aktuelle Sprache verzögert zu laden.
 
-- **Vorteile:** **Tree Shaking auf Sprach-Ebene.** Ein Benutzer, der die englische Version ansieht, lädt _nur_ das englische Wörterbuch herunter. Das französische Wörterbuch wird nie geladen.
-- **Nachteile:** Löst pro Komponente während der Hydrierung eine Netzwerkanfrage (Asset-Abruf) aus.
-- **Ideal für:** Große Textblöcke, Artikel oder Anwendungen, die viele Sprachen unterstützen, bei denen die Bundle-Größe kritisch ist.
+- **Vorteile:** **Tree Shaking auf Länderebene.** Ein Benutzer, der die englische Version ansieht, wird _nur_ das englische Wörterbuch herunterladen. Das deutsche Wörterbuch wird nie geladen.
+- **Nachteile:** Löst eine Netzwerkanfrage (Asset-Abruf) pro Komponente während der Hydratation aus.
+- **Am besten für:** Große Textblöcke, Artikel oder Anwendungen, die viele Sprachen unterstützen, bei denen die Bundle-Größe entscheidend ist.
 
 **Beispiel für transformierten Code:**
 
@@ -420,35 +548,55 @@ Im dynamischen Modus ersetzt Intlayer `useIntlayer` durch `useDictionaryAsync`.
 // Ihr Code
 const content = useIntlayer("my-key");
 
-// Optimierter Code (Dynamisch)
+// Veranschaulichung des optimierten Codes nach der Transformation (Dynamisch)
+// Dies dient nur zur Veranschaulichung, der tatsächliche Code unterscheidet sich aus Optimierungsgründen
 const content = useDictionaryAsync({
   en: () =>
     import(".intlayer/dynamic_dictionary/my-key/en.json").then(
       (mod) => mod.default
     ),
-  fr: () =>
-    import(".intlayer/dynamic_dictionary/my-key/fr.json").then(
+  de: () =>
+    import(".intlayer/dynamic_dictionary/my-key/de.json").then(
       (mod) => mod.default
     ),
 });
 ```
 
-> Wenn Sie `importMode: 'dynamic'` verwenden und 100 Komponenten `useIntlayer` auf einer einzigen Seite nutzen, wird der Browser versuchen, 100 separate Abrufe durchzuführen. Um diesen „Wasserfall“ an Anfragen zu vermeiden, gruppieren Sie Inhalte in weniger `.content`-Dateien (z. B. ein Wörterbuch pro Seitenabschnitt) statt einer Datei pro Atom-Komponente.
+> Wenn Sie `importMode: 'dynamic'` verwenden und auf einer einzigen Seite 100 Komponenten haben, die `useIntlayer` aufrufen, versucht der Browser, 100 separate Abrufe durchzuführen. Um diese "Wasserfall"-Anfragen zu vermeiden, gruppieren Sie Inhalte in weniger `.content`-Dateien (z.B. ein Wörterbuch pro Seitenabschnitt) anstatt in eines pro Atom-Komponente. Sie können auch mehrere `.content`-Dateien mit demselben Schlüssel verwenden. Intlayer wird sie dann zu einem einzigen Wörterbuch zusammenführen.
 
 ### 3. Fetch-Modus
 
-Verhält sich ähnlich wie der dynamische Modus, versucht jedoch zuerst, Wörterbücher von der Intlayer Live Sync API abzurufen. Wenn der API-Aufruf fehlschlägt oder der Inhalt nicht für Live-Updates markiert ist, erfolgt ein Fallback auf den dynamischen Import.
+Verhält sich ähnlich wie der dynamische Modus, versucht jedoch zuerst, Wörterbücher von der Intlayer Live Sync API abzurufen. Wenn der API-Aufruf fehlschlägt oder der Inhalt nicht für Live-Updates markiert ist, wird auf den dynamischen Import zurückgegriffen.
+
+**Beispiel für transformierten Code:**
+
+```tsx
+// Ihr Code
+const content = useIntlayer("my-key");
+
+// Veranschaulichung des optimierten Codes (Fetch)
+const content = useDictionaryAsync({
+  en: () =>
+    fetch("https://intlayer.my-domain.com/dictionary/my-key/en").then((res) =>
+      res.json()
+    ),
+  de: () =>
+    fetch("https://intlayer.my-domain.com/dictionary/my-key/de").then((res) =>
+      res.json()
+    ),
+});
+```
 
 > Weitere Details finden Sie in der CMS-Dokumentation: [CMS](https://github.com/aymericzip/intlayer/blob/main/docs/docs/de/intlayer_CMS.md)
 
-> Im Fetch-Modus können Purge und Minimierung nicht verwendet werden.
+> Im Fetch-Modus werden Purge und Minifizierung nicht angewendet, da das JSON von einer Remote-API mit den ursprünglichen Feldnamen bereitgestellt wird.
 
-## Zusammenfassung: Statisch vs. Dynamisch
+## Zusammenfassung: Statisch vs Dynamisch
 
-| Merkmal                   | Statischer Modus                                  | Dynamischer Modus                    |
-| :------------------------ | :------------------------------------------------ | :----------------------------------- |
-| **JS-Bundle-Größe**       | Größer (enthält alle Sprachen für die Komponente) | Kleiner (nur Code, kein Inhalt)      |
-| **Initiales Laden**       | Sofort (Inhalt ist im Bundle)                     | Leichte Verzögerung (lädt JSON)      |
-| **Netzwerkanfragen**      | 0 zusätzliche Anfragen                            | 1 Anfrage pro Wörterbuch             |
-| **Tree Shaking**          | Komponentenebene                                  | Komponentenebene + Sprach-Ebene      |
-| **Bester Anwendungsfall** | UI-Komponenten, kleine Anwendungen                | Seiten mit viel Text, viele Sprachen |
+| Feature                   | Statischer Modus                                  | Dynamischer Modus                      |
+| :------------------------ | :------------------------------------------------ | :------------------------------------- |
+| **JS Bundle-Größe**       | Größer (enthält alle Sprachen für die Komponente) | Kleinstmöglich (nur Code, kein Inhalt) |
+| **Initiales Laden**       | Sofortig (Inhalt ist im Bundle)                   | Leichte Verzögerung (lädt JSON)        |
+| **Netzwerkanfragen**      | 0 zusätzliche Anfragen                            | 1 Anfrage pro Wörterbuch-Schlüssel     |
+| **Tree Shaking**          | Auf Komponentenebene                              | Auf Komponenten- + Länderebene         |
+| **Bester Anwendungsfall** | UI-Komponenten, Kleine Apps                       | Textreiche Seiten, Viele Sprachen      |