@intlayer/docs 9.1.3 → 9.3.0

package/docs/cs/intlayer_with_angular_21.md

@@ -1,8 +1,8 @@
 ---
 createdAt: 2025-04-18
 updatedAt: 2026-05-31
-title: "Angular 21 i18n - Kompletní průvodce překladem vaší aplikace"
-description: "Žádný i18next. Průvodce 2026 pro vytváření vícejazyčné (i18n) aplikace Angular 21. Překládejte pomocí agentů AI a optimalizujte velikost bundlu, SEO a výkon."
+title: "Angular 22 i18n - Kompletní průvodce překladem vaší aplikace"
+description: "Žádný i18next. Průvodce 2026 pro vytváření vícejazyčné (i18n) aplikace Angular 22. Překládejte pomocí agentů AI a optimalizujte velikost bundlu, SEO a výkon."
 keywords:
   - Internacionalizace
   - Dokumentace
@@ -13,8 +13,8 @@ slugs:
   - doc
   - environment
   - angular
-applicationTemplate: https://github.com/aymericzip/intlayer-angular-21-template
-applicationShowcase: https://intlayer-angular-21-template.vercel.app/
+applicationTemplate: https://github.com/aymericzip/intlayer-angular-22-template
+applicationShowcase: https://intlayer-angular-22-template.vercel.app/
 history:
   - version: 8.9.0
     date: 2026-05-04
@@ -31,7 +31,7 @@ history:
 author: aymericzip
 ---
 
-# Přeložte svůj web Angular 21 (Vite) pomocí Intlayer | Internacionalizace (i18n)
+# Přeložte svůj web Angular 22 (Vite) pomocí Intlayer | Internacionalizace (i18n)
 
 ## Obsah
 
@@ -56,7 +56,7 @@ S Intlayer můžete:
   <Tab label="Kód" value="code">
 
 <iframe
-  src="https://ide.intlayer.org/aymericzip/intlayer-angular-21-template?file=intlayer.config.ts"
+  src="https://ide.intlayer.org/aymericzip/intlayer-angular-22-template?file=intlayer.config.ts"
   className="m-auto overflow-hidden rounded-lg border-0 max-md:size-full max-md:h-[700px] md:aspect-16/9 md:w-full"
   title="Demo CodeSandbox - Jak internacionalizovat vaši aplikaci pomocí Intlayer"
   sandbox="allow-forms allow-modals allow-popups allow-presentation allow-same-origin allow-scripts"
@@ -67,7 +67,7 @@ S Intlayer můžete:
   <Tab label="Demo" value="demo">
 
 <iframe
-  src="https://intlayer-angular-21-template.vercel.app/"
+  src="https://intlayer-angular-22-template.vercel.app/"
   className="m-auto overflow-hidden rounded-lg border-0 max-md:size-full max-md:h-[700px] md:aspect-16/9 md:w-full"
   title="Demo - intlayer-angular-template"
   sandbox="allow-forms allow-modals allow-popups allow-presentation allow-same-origin allow-scripts"
@@ -77,7 +77,7 @@ S Intlayer můžete:
   </Tab>
 </Tabs>
 
-Podívejte se na [šablonu aplikace](https://github.com/aymericzip/intlayer-angular-21-template) na GitHubu.
+Podívejte se na [šablonu aplikace](https://github.com/aymericzip/intlayer-angular-22-template) na GitHubu.
 
 <Steps>
 
@@ -165,7 +165,7 @@ export default config;
 
 <Step number={3} title="Integrace Intlayer do vaší konfigurace Angular">
 
-K integraci Intlayer s Angular CLI je nutné použít vlastní builder. Tento průvodce předpokládá, že používáte Vite/esbuild (výchozí pro projekty Angular 21).
+K integraci Intlayer s Angular CLI je nutné použít vlastní builder. Tento průvodce předpokládá, že používáte Vite/esbuild (výchozí pro projekty Angular 22).
 
 Nejprve upravte svůj `angular.json` tak, aby používal vlastní esbuild builder. Aktualizujte konfigurace pro `build` a `serve`:
 

package/docs/de/analytics.md

@@ -0,0 +1,222 @@
+---
+createdAt: 2026-07-08
+updatedAt: 2026-07-08
+title: Intlayer Analytics | Inhalte nachverfolgen und A/B-Tests durchführen
+description: Erfahren Sie, wie @intlayer/analytics Seiten-/Gebietsschema-Aufrufe und die Anzeige von Inhalten nachverfolgt und wie Sie damit A/B-Tests für Ihre Intlayer-Inhalte durchführen können.
+keywords:
+  - Analytics
+  - A/B-Tests
+  - Zielgruppe
+  - Internationalisierung
+  - Dokumentation
+  - Intlayer
+  - Next.js
+  - JavaScript
+  - React
+slugs:
+  - doc
+  - concept
+  - analytics
+history:
+  - version: 9.0.0
+    date: 2026-07-08
+    changes: "Init doc — @intlayer/analytics Paket, Nachverfolgung auf Provider-/Node-Ebene, A/B-Tests, Dashboard"
+author: aymericzip
+---
+
+# Intlayer Analytics Dokumentation
+
+`@intlayer/analytics` ist ein optionales Begleitpaket, das Ihnen mitteilt, **welche Inhalte Ihren Besuchern tatsächlich angezeigt werden** — welche Seite, in welchem Gebietsschema (Locale) und welcher spezifische Teil des übersetzten Inhalts — damit Sie Ihr Publikum verstehen und **A/B-Tests für Inhalte** durchführen können.
+
+## Inhaltsverzeichnis
+
+<TOC/>
+
+---
+
+## Was es nachverfolgt
+
+`@intlayer/analytics` bündelt drei Arten von anonymen Ereignissen:
+
+| Ereignis           | Wo erfasst                                       | Was es Ihnen sagt                                                                                                                               |
+| ------------------ | ------------------------------------------------ | ----------------------------------------------------------------------------------------------------------------------------------------------- |
+| `page_view`        | Provider-Ebene (`IntlayerProvider`)              | Welche Seite und welches Gebietsschema eine Sitzung beim ersten Laden, beim Routenwechsel oder Gebietsschema-Wechsel aufgerufen hat.            |
+| `content_exposure` | Node-Ebene (`useIntlayer` / Interpreter-Plugins) | Welcher Wörterbuchschlüssel / Schlüsselpfad tatsächlich aufgelöst und angezeigt wurde — und, falls Teil eines Experiments, welche **Variante**. |
+| `conversion`       | Überall dort, wo Sie `useConversion()` aufrufen  | Ein erreichtes Ziel (Anmeldung, Klick, Kauf...), das der A/B-Variante zugeschrieben wird, der die Sitzung ausgesetzt war.                       |
+
+Ereignisse werden im Speicher gesammelt und als **einzelne Batch-Anfrage etwa alle 20 Sekunden** gesendet — niemals bei jedem Tastendruck oder Rendern — sodass die Analytik niemals die erste Renderzeit beeinträchtigt oder eine Anfrage pro Interaktion hinzufügt.
+
+## Wie es A/B-Tests für Inhalte ermöglicht
+
+Mit Intlayer können Sie bereits inhaltliche [Varianten](https://github.com/aymericzip/intlayer/blob/main/docs/docs/de/dynamic_dictionaries/index.md) deklarieren (z. B. ein `hero-banner` Wörterbuch mit einer `control` und einer `black_friday` Variante). `@intlayer/analytics` schließt den Kreis:
+
+1. `getVariant(experimentKey, variants)` weist jede anonyme Sitzung deterministisch einer Variante zu — eine reine Funktion der Sitzungs-ID und des Experimentschlüssels, sodass die Zuweisung **über die gesamte Sitzung hinweg stabil** ist und **keine Server-Roundtrips** vor dem ersten Rendern erfordert (kein Flackern, keine Layout-Verschiebung).
+2. Jedes `content_exposure` Ereignis enthält die `variant`, die angezeigt wurde.
+3. Mit `useConversion()` können Sie dieser Variante ein Ziel (z. B. `"cta_click"`) zuschreiben.
+4. Der Endpunkt für die Experimentergebnisse des Dashboards vergleicht die Konversionsraten pro Variante, einschließlich der statistischen Signifikanz (ein z-Test).
+
+## Installation
+
+`@intlayer/analytics` ist eine **optionale Peer-Abhängigkeit** — sie wird niemals automatisch durch ein Framework-Paket installiert. Fügen Sie es neben `intlayer` hinzu:
+
+```bash packageManager="npm"
+npm install @intlayer/analytics
+```
+
+```bash packageManager="yarn"
+yarn add @intlayer/analytics
+```
+
+```bash packageManager="pnpm"
+pnpm add @intlayer/analytics
+```
+
+```bash packageManager="bun"
+bun add @intlayer/analytics
+```
+
+Wenn Sie es nicht installieren, wird jeder Integrationspunkt in ein No-Op aufgelöst — siehe [Keine Kosten, wenn nicht installiert](#keine-kosten-wenn-nicht-installiert) unten.
+
+## Konfiguration
+
+Analytics **verwendet den vorhandenen `editor` Konfigurationsblock wieder** — es gibt kein separates `analytics` Konfigurationsschema auszufüllen:
+
+```typescript fileName="intlayer.config.ts" codeFormat={["typescript", "esm", "commonjs"]}
+import type { IntlayerConfig } from "intlayer";
+
+const config: IntlayerConfig = {
+  editor: {
+    backendURL: "https://back.intlayer.org", // Wird auch als Analytics-Ingestion-Endpunkt verwendet
+    clientId: "your-client-id", // Wird auch als Analytics-Projektschlüssel verwendet
+    clientSecret: "your-client-secret",
+  },
+};
+
+export default config;
+```
+
+- `editor.backendURL` — die Basis-URL, an die Analytics-Ereignisse gesendet werden (`POST {backendURL}/api/analytics/events`).
+- `editor.clientId` — der öffentliche Projektschlüssel, der jedem aufgenommenen Ereignis zugeschrieben wird. Es fungiert auch als **Aktivierungsschalter**: Analytics bleibt vollständig deaktiviert (und als Dead-Code eliminiert, siehe unten), bis `clientId` konfiguriert ist.
+
+Wenn Sie Intlayer selbst hosten, verweist die Analytik automatisch auf Ihre eigene Instanz, da sie `editor.backendURL` teilt.
+
+## Framework-Unterstützung
+
+Analytics ist mit dem freigegebenen `IntlayerProvider` von `react-intlayer` verdrahtet und steht daher heute überall dort zur Verfügung, wo dieser Provider verwendet wird:
+
+| Framework                                                | Status                                                                                            |
+| -------------------------------------------------------- | ------------------------------------------------------------------------------------------------- |
+| React                                                    | ✅ Verfügbar                                                                                      |
+| Next.js (`next-intlayer`)                                | ✅ Verfügbar (über `react-intlayer`)                                                              |
+| React Native / Expo (`react-native-intlayer`)            | ✅ Verfügbar (über `react-intlayer`)                                                              |
+| Vue, Svelte, Angular, Solid, Preact, Lit, Astro, Vanilla | 🚧 Geplant — gleicher Client, Provider-Level-Bindungen nach dem `@intlayer/editor` Rollout-Muster |
+
+## Verwendung
+
+### Automatische Nachverfolgung auf Provider-Ebene
+
+Es sind keine Codeänderungen erforderlich. Sobald `@intlayer/analytics` installiert und `editor.clientId` konfiguriert ist, führt der `IntlayerProvider` automatisch Folgendes aus:
+
+- initialisiert den Analytics-Client beim Mounten,
+- zeichnet einen `page_view` beim ersten Laden auf,
+- zeichnet einen `page_view` bei jedem Gebietsschema-Wechsel auf,
+- startet die ca. 20-sekündige Flush-Schleife und flusht verbleibende Ereignisse beim Unmounten / Schließen des Tabs (über `navigator.sendBeacon`, andernfalls `fetch(..., { keepalive: true })`).
+
+### Automatische Nachverfolgung auf Node-Ebene
+
+Jedes Mal, wenn `useIntlayer` einen Inhalt zur Anzeige auflöst, meldet der Interpreter ein `content_exposure` Ereignis für genau diese `dictionaryKey` + Schlüsselpfad + Gebietsschema — auch hier sind keine Codeänderungen erforderlich. Wiederholte Expositionen desselben Knotens innerhalb eines Flush-Fensters werden zu einem einzigen Ereignis mit einem `count` zusammengefasst, sodass eine Liste, die 50 Mal neu gerendert wird, nicht 50 Ereignisse sendet.
+
+### Nachverfolgung von Konversionen für A/B-Tests
+
+Verwenden Sie `useConversion()`, um einer Variante, die eine Sitzung gesehen hat, ein Ziel zuzuschreiben:
+
+```tsx fileName="CTAButton.tsx" codeFormat="tsx"
+import { useConversion } from "react-intlayer";
+
+const CTAButton = () => {
+  const trackConversion = useConversion();
+
+  return (
+    <button
+      onClick={() =>
+        trackConversion({
+          experimentKey: "homepage-hero",
+          variant: "black_friday",
+          goal: "cta_click",
+        })
+      }
+    >
+      Loslegen
+    </button>
+  );
+};
+```
+
+### Auflösung einer Variante auf der Clientseite
+
+```tsx fileName="useHeroVariant.ts" codeFormat="tsx"
+import { getGlobalAnalyticsClient } from "@intlayer/analytics/client";
+
+const client = getGlobalAnalyticsClient();
+const variant = client?.getVariant("homepage-hero", [
+  "control",
+  "black_friday",
+]);
+```
+
+## Datenschutz & Leistung
+
+- **Anonym durch Design**: Sitzungen werden durch eine rotierende ID identifiziert; das Backend speichert nur einen **SHA-256-Hash** dieser ID — niemals die rohe ID, niemals eine IP-Adresse.
+- **Standort ist grob**: nur ein Ländercode, der aus CDN-Geolokalisierungs-Headern (`cf-ipcountry`, `x-vercel-ip-country`, ...) abgeleitet wird — es wird keine IP gelesen oder gespeichert.
+- **URLs schließen Suchparameter aus**: standardmäßig werden Query-Strings nie erfasst.
+- **Sampling**: `sampleRate` ermöglicht es Ihnen, bei Traffic-starken Apps nur einen Bruchteil der Content-Exposure-Ereignisse zu behalten.
+- **Gepoolt**: eine Anfrage ungefähr alle 20 Sekunden (`flushInterval`), oder früher, wenn der Puffer voll ist (`maxBufferSize`) — niemals eine Anfrage pro Ereignis.
+
+### Keine Kosten, wenn nicht installiert
+
+`@intlayer/analytics` folgt genau dem gleichen optionalen Abhängigkeitsmuster wie `@intlayer/editor`:
+
+- Jeder Integrationspunkt lädt das Paket über einen **dynamischen `import()` umhüllt in `try/catch`** — eine App, die `@intlayer/analytics` nie installiert, zahlt weder für Bundle-Größe noch Laufzeitkosten und sieht nie einen Fehler;
+- eine Umgebungsvariable zur Kompilierzeit (`INTLAYER_ANALYTICS_ENABLED`), die von `@intlayer/config` automatisch auf `'false'` gesetzt wird, wenn `editor.clientId` nicht konfiguriert ist, ermöglicht es Bundlern, die gesamte Integration **als Dead-Code zu eliminieren**;
+- Analytics ist im Intlayer Editor/CMS-Vorschau-Iframe deaktiviert, sodass Editor-Sitzungen niemals als echter Traffic gewertet werden.
+
+## Dashboard: Analytics-Seite
+
+Sobald Ihr Projekt Ereignisse gesammelt hat, zeigt die Seite **Analytics** im [Intlayer Dashboard](https://app.intlayer.org/analytics) (sichtbar in der Seitenleiste, sobald ein Projekt ausgewählt ist) Folgendes an:
+
+- **Aktive Nutzer** — eindeutige Besucher über das ausgewählte rollierende Zeitfenster (7 / 30 / 90 Tage).
+- **Nutzer heute** und **Nutzer in den letzten 7 Tagen**.
+- **Seitenaufrufe** über das ausgewählte Zeitfenster.
+- Ein **Verlaufsdiagramm** der täglichen eindeutigen Besucher.
+- Registerkarten für die Aufschlüsselung nach **Gebietsschemas (Locales)** und **Standort**, die Ihre Zielgruppe nach Gebietsschema und Land einordnen.
+
+## Backend-API-Referenz
+
+Alle Lese-Endpunkte erfordern Authentifizierung; die Ingestion ist öffentlich und wird durch `clientId` zugeordnet.
+
+| Methode | Endpunkt                                    | Beschreibung                                                                                |
+| ------- | ------------------------------------------- | ------------------------------------------------------------------------------------------- |
+| `POST`  | `/api/analytics/events`                     | Aufnahme eines Batches von Ereignissen (öffentlich, zugewiesen durch `clientId` im Body).   |
+| `GET`   | `/api/analytics/overview`                   | Seiten-/Gebietsschema-Gesamtwerte für das authentifizierte Projekt.                         |
+| `GET`   | `/api/analytics/audience?days=30`           | Eindeutige Besucher, Seitenaufrufe, Tagesserien, Gebietsschema- + Länder-Aufschlüsselungen. |
+| `GET`   | `/api/analytics/content-stats`              | Content-Exposure-Gesamtwerte, gruppiert nach Wörterbuchschlüssel / Pfad / Gebietsschema.    |
+| `GET`   | `/api/analytics/experiments/:experimentKey` | Konversionsraten pro Variante und statistische Signifikanz für ein A/B-Experiment.          |
+
+Sie können diese auch programmgesteuert mit dem [CMS SDK](https://github.com/aymericzip/intlayer/blob/main/docs/docs/de/intlayer_CMS.md) aufrufen:
+
+```ts fileName="analytics.ts"
+import { createIntlayerCMS } from "@intlayer/api";
+import { analyticsEndpoint } from "@intlayer/api/analytics";
+
+const cms = createIntlayerCMS();
+
+const { data: audience } = await analyticsEndpoint(cms).getAudience(30);
+```
+
+## Nützliche Links
+
+- [Dynamische Wörterbücher - Kollektionen & Varianten](https://github.com/aymericzip/intlayer/blob/main/docs/docs/de/dynamic_dictionaries/index.md)
+- [Intlayer CMS - CMS SDK](https://github.com/aymericzip/intlayer/blob/main/docs/docs/de/intlayer_CMS.md)
+- [Intlayer Visueller Editor](https://github.com/aymericzip/intlayer/blob/main/docs/docs/de/intlayer_visual_editor.md)
+- [Konfigurationsreferenz](https://github.com/aymericzip/intlayer/blob/main/docs/docs/de/configuration.md)
+- [Self-Hosting-Leitfaden](https://github.com/aymericzip/intlayer/blob/main/docs/docs/de/self_hosting.md)

package/docs/de/autoFill.md

@@ -75,11 +75,30 @@ In v7 hat sich das Verhalten des `fill`-Befehls aktualisiert:
 
 Bei Verwendung einer Path-Option zum Schreiben in eine andere Datei funktioniert der Fill-Mechanismus über eine _Master-Slave_-Beziehung zwischen Content-Declaration-Dateien. Die Hauptdatei (Master) dient als Single Source of Truth, und wenn sie aktualisiert wird, wendet Intlayer diese Änderungen automatisch auf die abgeleiteten (gefüllten) Declaration-Dateien an, die durch den Path angegeben werden.
 
-# Übersetzungen der Deklarationsdatei für automatisches Ausfüllen von Inhalten
+### Pro-Locale-Anpassung
 
-**Deklarationsdateien für automatisches Ausfüllen von Inhalten** sind eine Möglichkeit, Ihren Entwicklungsworkflow zu beschleunigen.
+Sie können das Verhalten für jedes Locale auch anpassen, indem Sie ein Objekt verwenden:
 
-Der Mechanismus des automatischen Ausfüllens funktioniert durch eine _Master-Slave_-Beziehung zwischen Inhaltsdeklarationsdateien. Wenn die Hauptdatei (Master) aktualisiert wird, wendet Intlayer diese Änderungen automatisch auf die abgeleiteten (automatisch ausgefüllten) Deklarationsdateien an.
+```ts fileName="intlayer.config.ts"
+const config: IntlayerConfig = {
+  content: {
+    internationalization: {
+      locales: [Locales.ENGLISH, Locales.FRENCH, Locales.POLISH],
+      defaultLocale: Locales.ENGLISH,
+      requiredLocales: [Locales.ENGLISH], // Empfohlen, um zu vermeiden, dass Property 'pl' in type '{ en: string; xxx } on your t function fehlt
+    },
+  },
+  dictionary: {
+    fill: {
+      en: true, // Aktuelle Datei für Englisch ausfüllen und bearbeiten
+      fr: "./translations/fr.json", // Separate Datei für Französisch erstellen
+      es: false, // Ausfüllen für Spanisch deaktivieren
+    },
+  },
+};
+```
+
+Dies ermöglicht es Ihnen, verschiedene Fill-Verhalten für verschiedene Locales innerhalb desselben Projekts zu haben.
 
 ```ts fileName="src/components/example/example.content.ts"
 import { Locales, type Dictionary } from "intlayer";
@@ -87,18 +106,18 @@ import { Locales, type Dictionary } from "intlayer";
 const exampleContent = {
   key: "example",
   locale: Locales.ENGLISH,
-  autoFill: "./example.content.json",
+  fill: "./example.content.json",
   content: {
-    contentExample: "Dies ist ein Beispielinhalt", // Beispielinhalt
+    contentExample: "This is an example of content",
   },
 } satisfies Dictionary;
 
 export default exampleContent;
 ```
 
-Hier ist eine [pro-Locale Inhaltsdeklarationsdatei](https://github.com/aymericzip/intlayer/blob/main/docs/docs/de/per_locale_file.md) mit der `autoFill`-Anweisung.
+Hier ist eine [Pro-Locale-Inhaltsdeklarationsdatei](https://github.com/aymericzip/intlayer/blob/main/docs/docs/de/per_locale_file.md), die die `fill`-Anweisung verwendet.
 
-Dann, wenn Sie den folgenden Befehl ausführen:
+Wenn Sie dann den folgenden Befehl ausführen:
 
 ```bash packageManager="npm"
 npx intlayer fill --file 'src/components/example/example.content.ts'
@@ -116,7 +135,7 @@ pnpm intlayer fill --file 'src/components/example/example.content.ts'
 bun x intlayer fill --file 'src/components/example/example.content.ts'
 ```
 
-Intlayer generiert automatisch die abgeleitete Deklarationsdatei unter `src/components/example/example.content.json` und füllt alle Lokalisierungen aus, die in der Hauptdatei noch nicht deklariert sind.
+Intlayer generiert automatisch die abgeleitete Deklarationsdatei unter `src/components/example/example.content.json` und füllt alle Locales aus, die nicht bereits in der Hauptdatei deklariert sind.
 
 ```json5 fileName="src/components/example/example.content.json"
 {
@@ -133,7 +152,7 @@ Intlayer generiert automatisch die abgeleitete Deklarationsdatei unter `src/comp
 }
 ```
 
-Anschließend werden beide Deklarationsdateien zu einem einzigen Wörterbuch zusammengeführt, das über den Standard-`useIntlayer("example")` Hook (React) / Composable (Vue) zugänglich ist.
+Danach werden beide Deklarationsdateien in ein einzelnes Wörterbuch zusammengeführt, das mit dem Standard-`useIntlayer("example")`-Hook (React) / Composable (Vue) zugänglich ist.
 
 ## Globale Konfiguration
 

package/docs/de/bundle_optimization.md

@@ -1,6 +1,6 @@
 ---
 createdAt: 2025-11-25
-updatedAt: 2026-06-07
+updatedAt: 2026-08-09
 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:
@@ -16,6 +16,12 @@ slugs:
   - concept
   - bundle-optimization
 history:
+  - version: 9.2.1
+    date: 2026-08-09
+    changes: "`purge` und `minify` funktionieren jetzt in Next.js über `@intlayer/swc` — kein `babel.config.js` erforderlich"
+  - version: 8.12.0
+    date: 2026-06-24
+    changes: "Babel-Plugins in den Referenztabellen in der erforderlichen Pipeline-Reihenfolge auflisten (extract → purge → minify → optimize)"
   - version: 8.12.0
     date: 2026-06-07
     changes: "Hinzufügen von `intlayerPurgeBabelPlugin` und `intlayerMinifyBabelPlugin` für Babel/Webpack; Klarstellung der Plugin-Pipeline"
@@ -191,12 +197,14 @@ Die Build-Optimierung von Intlayer ist auf mehrere diskrete Plugins aufgeteilt,
 
 Diese werden direkt in der `babel.config.js` für Webpack-basierte Setups verwendet (Next.js mit Babel, CRA, benutzerdefiniertes Webpack usw.).
 
+Die folgende Tabelle listet sie in der erforderlichen Pipeline-Reihenfolge auf (dieselbe Reihenfolge, in der sie in `babel.config.js` erscheinen müssen):
+
 | 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         |
+| `intlayerOptimizeBabelPlugin` | Schreibt `useIntlayer('key')` → `useDictionary(hash)` um und fügt den passenden `import` des Wörterbuchs ein                |
 
 > **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.
 
@@ -205,9 +213,9 @@ Jedes Babel-Plugin verfügt über einen entsprechenden Options-Helfer, der Ihre
 | Options-Helfer               | Verwendet mit                 |
 | :--------------------------- | :---------------------------- |
 | `getExtractPluginOptions()`  | `intlayerExtractBabelPlugin`  |
-| `getOptimizePluginOptions()` | `intlayerOptimizeBabelPlugin` |
 | `getPurgePluginOptions()`    | `intlayerPurgeBabelPlugin`    |
 | `getMinifyPluginOptions()`   | `intlayerMinifyBabelPlugin`   |
+| `getOptimizePluginOptions()` | `intlayerOptimizeBabelPlugin` |
 
 ### Vite Plugins (`vite-intlayer`)
 
@@ -220,6 +228,20 @@ Vite-Benutzer **konfigurieren diese nie direkt**. Sie werden automatisch eingeri
 | Dictionary minify    | Gleich wie die JSON-Schreibphase des `intlayerMinifyBabelPlugin`                                     |
 | Babel transform      | Gleich wie die Quellcode-Umbenennung des `intlayerMinifyBabelPlugin` + `intlayerOptimizeBabelPlugin` |
 
+### SWC-Plugin (`@intlayer/swc`)
+
+Auch Next.js-Nutzer **konfigurieren diese nie direkt**. Seit **v9.2.1** führt `withIntlayer()` in `next.config.ts` die vollständige Pipeline aus — Purge, Minify und Import-Umschreibung — allein anhand der Flags `build.purge` und `build.minify`.
+
+Die Arbeit ist zweigeteilt, denn ein SWC-Wasm-Plugin transformiert jeweils nur eine Datei und hat keinen Dateisystemzugriff:
+
+| Durchlauf                                       | Wo er läuft                          | Was er tut                                                                                              |
+| :---------------------------------------------- | :----------------------------------- | :------------------------------------------------------------------------------------------------------ |
+| Nutzungsanalyse + JSON-Purge/Minify             | Node, innerhalb von `withIntlayer()` | Liest jede Komponenten-Quelldatei, schreibt `.intlayer/**/*.json` neu, erzeugt die Umbenennungstabellen |
+| Quellcode-Umschreibung (`content.title` → `.a`) | `@intlayer/swc` (Wasm)               | Wendet die Umbenennungstabellen auf die passenden Eigenschaftszugriffe in Ihrem Code an                 |
+| Import-Umschreibung (`useIntlayer` → dict)      | `@intlayer/swc` (Wasm)               | Wie `intlayerOptimizeBabelPlugin`                                                                       |
+
+Zu entscheiden, _welche_ Felder ungenutzt sind und _welchen_ Alias jedes erhält, erfordert dateiübergreifenden Zustand und Datei-I/O; diese Hälfte läuft daher in Node, und das SWC-Plugin erhält nur die resultierenden Tabellen.
+
 ## Setup nach Plattform
 
 <Tabs>
@@ -227,10 +249,12 @@ Vite-Benutzer **konfigurieren diese nie direkt**. Sie werden automatisch eingeri
 
 ### Next.js
 
-Next.js erfordert das Plugin `@intlayer/swc` für den Optimize-Pass (Import-Umschreibung), da Next.js SWC für Builds verwendet.
+Next.js benötigt das `@intlayer/swc`-Plugin, da Next.js SWC für Builds verwendet. Seit **v9.2.1** deckt dieses eine Paket die gesamte Pipeline ab — Optimierung (Import-Umschreibung), Purge und Minify.
 
 > Dieses Plugin ist nicht standardmäßig installiert, da SWC-Plugins für Next.js noch experimentell sind. Dies kann sich in Zukunft ändern.
 
+> **Next.js 16.1.0 ist die Mindestversion.** Es ist die erste Version, die auf SWCs vorwärtskompatibler Wasm-Plugin-ABI aufbaut; frühere Versionen weisen das Plugin ab. `withIntlayer` liest Ihre Next.js-Version und registriert das Plugin unterhalb von 16.1.0 einfach nicht — diese Builds sind weiterhin erfolgreich, sie laufen nur ohne Bundle-Optimierung.
+
 <Tabs>
  <Tab value="npm">
 
@@ -265,33 +289,40 @@ intlayer-swc-plugin = "*"
 
 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.
+Die **Purge- und Minify-Durchläufe** (Feldentfernung und Feldumbenennung) benötigen kein zusätzliches Paket und kein `babel.config.js`. Umschließen Sie Ihre Konfiguration mit `withIntlayer` und schalten Sie die Flags in `intlayer.config.ts` um:
 
-```bash packageManager="npm"
-npm install -D @intlayer/babel
+```typescript fileName="next.config.ts"
+import { withIntlayer } from "next-intlayer/server";
+import type { NextConfig } from "next";
+
+const nextConfig: NextConfig = {/* Ihre Konfiguration */};
+
+export default withIntlayer(nextConfig);
 ```
 
-```javascript fileName="babel.config.js"
-const {
-  intlayerPurgeBabelPlugin,
-  intlayerMinifyBabelPlugin,
-  getPurgePluginOptions,
-  getMinifyPluginOptions,
-} = require("@intlayer/babel");
+```typescript fileName="intlayer.config.ts"
+import type { IntlayerConfig } from "intlayer";
 
-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.
-  ],
+const config: IntlayerConfig = {
+  build: {
+    purge: true, // entfernt ungenutzte Inhaltsfelder aus dem gebündelten JSON
+    minify: true, // benennt Inhaltsfeldschlüssel in kurze Aliase um
+  },
 };
+
+export default config;
 ```
 
+Während `next build` analysiert `withIntlayer` Ihre Quellen, schreibt die kompilierten Wörterbücher neu und übergibt die resultierenden Feldumbenennungstabellen an `@intlayer/swc`, das die passenden Eigenschaftszugriffe in Ihrem Code aktualisiert.
+
+> Verwenden Sie das asynchrone `withIntlayer`, nicht `withIntlayerSync`. Die synchrone Variante führt die Analyse-Pipeline nicht aus, sodass Purge und Minify damit keine Wirkung haben.
+
+> Purge und Minify laufen nur bei `next build` — die Optimierungs-Pipeline ist während `next dev` deaktiviert.
+
+> Sie sind außerdem deaktiviert, wenn Kompatibilitäts-Adapter-Aufrufer konfiguriert sind (`swcExtraCallers`, gesetzt von den Kompatibilitätspaketen wie `@intlayer/next-intl` oder `@intlayer/react-i18next`): Diese Aufrufstellen sind für den Nutzungsanalysator unsichtbar, sodass Purge Felder entfernen würde, die der Code noch liest. Die Import-Umschreibung bleibt aktiv.
+
+**Frühere Versionen (vor 9.2.1)** benötigten `@intlayer/babel` und eine `babel.config.js`, die `intlayerPurgeBabelPlugin` und `intlayerMinifyBabelPlugin` deklariert. Diese Datei wird nicht mehr benötigt und kann gelöscht werden.
+
  </Tab>
  <Tab value="vite">
 
@@ -447,6 +478,8 @@ export default config;
 
 > 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).
 
+> Unter Next.js wird die Minifizierung außerdem übersprungen, wenn `@intlayer/swc` nicht installiert ist oder nicht geladen werden kann (Next.js unterhalb von 16.1.0). Das Plugin ist die Hälfte, die die Quellcode-Zugriffe umschreibt; die Wörterbücher ohne es umzubenennen, würde Ihren Code Feldnamen lesen lassen, die es nicht mehr gibt.
+
 > 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 (Entfernen ungenutzter Felder)
@@ -475,7 +508,7 @@ export default config;
 { "title": "…", "subtitle": "…" }
 ```
 
-> Der Purge wird übersprungen, wenn `optimize` auf `false` oder `editor.enabled` auf `true` gesetzt ist.
+> Der Purge wird übersprungen, wenn `optimize` auf `false` oder `editor.enabled` auf `true` gesetzt ist. Unter Next.js wird sie zusätzlich übersprungen, wenn `@intlayer/swc` nicht verfügbar ist und wenn Kompatibilitäts-Adapter-Aufrufer konfiguriert sind.
 
 > 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.
 

package/docs/de/configuration.md

@@ -1,6 +1,6 @@
 ---
 createdAt: 2024-08-13
-updatedAt: 2026-07-11
+updatedAt: 2026-08-06
 title: Konfiguration (Configuration)
 description: Erfahren Sie, wie Sie Intlayer für Ihre Anwendung konfigurieren. Verstehen Sie die verschiedenen Einstellungen und Optionen, um Intlayer an Ihre Bedürfnisse anzupassen.
 keywords:
@@ -14,6 +14,9 @@ slugs:
   - concept
   - configuration
 history:
+  - version: 9.1.3
+    date: 2026-08-06
+    changes: "`routing.enableProxy` dreistufig machen: nicht gesetzt (auto), `true`, `false`"
   - version: 9.0.0
     date: 2026-07-11
     changes: "`analytics` Konfiguration hinzugefügt"
@@ -235,6 +238,19 @@ const config: IntlayerConfig = {
      */
     mode: "prefix-no-default",
 
+    /**
+     * Aktiviert den Intlayer-Proxy für Locale-Routing (Middleware).
+     * Übernimmt Locale-Erkennung, Weiterleitungen und Rewrites in Dev, Preview und SSR.
+     * - nicht gesetzt (auto): Dev- und Preview-Server halten das Routing URL-gesteuert
+     *   und ignorieren die in Cookies und Headern gespeicherte Locale. Präfixe werden
+     *   weiterhin aufgelöst, die Locale wird weiterhin persistiert und die
+     *   Accept-Language-Erkennung greift weiterhin. In Produktion wie `true`.
+     * - true: volles Verhalten in jeder Umgebung.
+     * - false: kein Locale-Routing.
+     * Standard: undefined (auto)
+     */
+    enableProxy: undefined,
+
     /**
      * Wo die vom Benutzer gewählte Sprache gespeichert werden soll.
      * Optionen: 'cookie', 'localStorage', 'sessionStorage', 'header' oder ein Array davon.
@@ -716,13 +732,14 @@ Analytics ist streng Opt-in: Es wird nichts erfasst, es sei denn, `analytics.ena
 
 Einstellungen, die das Routing-Verhalten steuern, einschließlich URL-Struktur, Sprachspeicherung und Middleware-Handhabung.
 
-| Feld       | Beschreibung                                                                                                                                                                                                 | Typ                                                                                                                                                                                                          | Standard               | Beispiel                                                                                                                                                                                          | Hinweis                                                                                                                                                                                                                                                                                   |
-| ---------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ---------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `mode`     | URL-Routing-Modus für die Sprachbehandlung.                                                                                                                                                                  | `'prefix-no-default'` &#124; <br/> `'prefix-all'` &#124; <br/> `'no-prefix'` &#124; <br/> `'search-params'`                                                                                                  | `'prefix-no-default'`  | `'prefix-no-default'`: `/dashboard` (en) oder `/fr/dashboard` (fr). `'prefix-all'`: `/en/dashboard`. `'no-prefix'`: Sprache wird anderweitig behandelt. `'search-params'`: `/dashboard?locale=fr` | Beeinflusst nicht das Cookie- oder Sprachspeicher-Management.                                                                                                                                                                                                                             |
-| `storage`  | Konfiguration für die Speicherung der Sprache im Client.                                                                                                                                                     | `false` &#124; <br/> `'cookie'` &#124; <br/> `'localStorage'` &#124; <br/> `'sessionStorage'` &#124; <br/> `'header'` &#124; <br/> `CookiesAttributes` &#124; <br/> `StorageAttributes` &#124; <br/> `Array` | `['cookie', 'header']` | `'localStorage'` <br/> `[{ type: 'cookie', name: 'custom-locale', secure: true }]`                                                                                                                | Siehe Tabelle Speicheroptionen unten.                                                                                                                                                                                                                                                     |
-| `basePath` | Der Basispfad für die Anwendungs-URLs.                                                                                                                                                                       | `string`                                                                                                                                                                                                     | `''`                   | `'/my-app'`                                                                                                                                                                                       | Wenn die App unter `https://example.com/my-app` erreichbar ist, ist basePath `'/my-app'` und URLs werden zu `https://example.com/my-app/en`.                                                                                                                                              |
-| `rewrite`  | Benutzerdefinierte URL-Rewrite-Regeln, die den Standard-Routing-Modus für bestimmte Pfade überschreiben. Unterstützt dynamische `[param]` Parameter.                                                         | `Record<string, StrictModeLocaleMap<string>>`                                                                                                                                                                | `undefined`            | Siehe Beispiel unten                                                                                                                                                                              | • Rewrite-Regeln haben Vorrang vor `mode`.<br/>• Funktioniert mit Next.js und Vite.<br/>• `getLocalizedUrl()` wendet passende Regeln automatisch an.<br/>• Siehe [Benutzerdefinierte URL-Rewrites](https://github.com/aymericzip/intlayer/blob/main/docs/docs/en/custom_url_rewrites.md). |
-| `domains`  | Verknüpft Sprachen mit Domain-Hostnamen für domainbasiertes Routing. Wenn festgelegt, verwenden URLs für eine Sprache diese Domain als Basis (absolute URL) und dem Pfad wird kein Sprachpräfix hinzugefügt. | `Partial<Record<Locale, string>>`                                                                                                                                                                            | `undefined`            | `{ zh: 'intlayer.zh', fr: 'intlayer.org' }`                                                                                                                                                       | • Protokoll ist standardmäßig `https://`, wenn es nicht im Hostnamen enthalten ist.<br/>• Die Domain selbst identifiziert die Sprache, daher wird kein `/zh/`-Präfix hinzugefügt.<br/>• `getLocalizedUrl('/', 'zh')` gibt `https://intlayer.zh/` zurück.                                  |
+| Feld          | Beschreibung                                                                                                                                                                                                 | Typ                                                                                                                                                                                                          | Standard               | Beispiel                                                                                                                                                                                          | Hinweis                                                                                                                                                                                                                                                                                                                                                                        |
+| ------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ---------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| `mode`        | URL-Routing-Modus für die Sprachbehandlung.                                                                                                                                                                  | `'prefix-no-default'` &#124; <br/> `'prefix-all'` &#124; <br/> `'no-prefix'` &#124; <br/> `'search-params'`                                                                                                  | `'prefix-no-default'`  | `'prefix-no-default'`: `/dashboard` (en) oder `/fr/dashboard` (fr). `'prefix-all'`: `/en/dashboard`. `'no-prefix'`: Sprache wird anderweitig behandelt. `'search-params'`: `/dashboard?locale=fr` | Beeinflusst nicht das Cookie- oder Sprachspeicher-Management.                                                                                                                                                                                                                                                                                                                  |
+| `enableProxy` | Aktiviert den Intlayer-Proxy für Locale-Routing (Middleware).                                                                                                                                                | `boolean` &#124; <br/> `undefined`                                                                                                                                                                           | `undefined` (auto)     | `true`                                                                                                                                                                                            | • Nicht gesetzt (auto): Dev- und Preview-Server ignorieren die in Cookies/Headern gespeicherte Locale als Weiterleitungsquelle; Präfixe, Persistenz und `Accept-Language`-Erkennung greifen weiterhin. In Produktion wie `true`.<br/>• `true`: volles Verhalten überall.<br/>• `false`: kein Locale-Routing. Bei Next.js wird die `intlayerProxy`-Middleware zum Durchreicher. |
+| `storage`     | Konfiguration für die Speicherung der Sprache im Client.                                                                                                                                                     | `false` &#124; <br/> `'cookie'` &#124; <br/> `'localStorage'` &#124; <br/> `'sessionStorage'` &#124; <br/> `'header'` &#124; <br/> `CookiesAttributes` &#124; <br/> `StorageAttributes` &#124; <br/> `Array` | `['cookie', 'header']` | `'localStorage'` <br/> `[{ type: 'cookie', name: 'custom-locale', secure: true }]`                                                                                                                | Siehe Tabelle Speicheroptionen unten.                                                                                                                                                                                                                                                                                                                                          |
+| `basePath`    | Der Basispfad für die Anwendungs-URLs.                                                                                                                                                                       | `string`                                                                                                                                                                                                     | `''`                   | `'/my-app'`                                                                                                                                                                                       | Wenn die App unter `https://example.com/my-app` erreichbar ist, ist basePath `'/my-app'` und URLs werden zu `https://example.com/my-app/en`.                                                                                                                                                                                                                                   |
+| `rewrite`     | Benutzerdefinierte URL-Rewrite-Regeln, die den Standard-Routing-Modus für bestimmte Pfade überschreiben. Unterstützt dynamische `[param]` Parameter.                                                         | `Record<string, StrictModeLocaleMap<string>>`                                                                                                                                                                | `undefined`            | Siehe Beispiel unten                                                                                                                                                                              | • Rewrite-Regeln haben Vorrang vor `mode`.<br/>• Funktioniert mit Next.js und Vite.<br/>• `getLocalizedUrl()` wendet passende Regeln automatisch an.<br/>• Siehe [Benutzerdefinierte URL-Rewrites](https://github.com/aymericzip/intlayer/blob/main/docs/docs/en/custom_url_rewrites.md).                                                                                      |
+| `domains`     | Verknüpft Sprachen mit Domain-Hostnamen für domainbasiertes Routing. Wenn festgelegt, verwenden URLs für eine Sprache diese Domain als Basis (absolute URL) und dem Pfad wird kein Sprachpräfix hinzugefügt. | `Partial<Record<Locale, string>>`                                                                                                                                                                            | `undefined`            | `{ zh: 'intlayer.zh', fr: 'intlayer.org' }`                                                                                                                                                       | • Protokoll ist standardmäßig `https://`, wenn es nicht im Hostnamen enthalten ist.<br/>• Die Domain selbst identifiziert die Sprache, daher wird kein `/zh/`-Präfix hinzugefügt.<br/>• `getLocalizedUrl('/', 'zh')` gibt `https://intlayer.zh/` zurück.                                                                                                                       |
 
 **`rewrite` Beispiel**:
 

package/docs/de/dictionary/file.md

@@ -23,7 +23,9 @@ history:
 author: aymericzip
 ---
 
-# Dateiinhalte / Einbetten von Dateien in Intlayer
+# Dateiinhalte / Einbettung von Dateien in Intlayer
+
+In Intlayer ermöglicht die `file`-Funktion das Einbetten von externem Dateiinhalt in ein Dictionary. Dieser Ansatz stellt sicher, dass Intlayer die Quelldatei erkennt und ermöglicht eine nahtlose Integration mit dem Intlayer Visual Editor und CMS.
 
 ## Wie das Einbetten von Dateien funktioniert