@intlayer/docs 9.4.0-canary.0 → 9.4.0

package/docs/de/benchmark/tanstack.md

@@ -194,6 +194,8 @@ Die Idee hinter `Wuchale` ist interessant, aber noch keine tragfähige Lösung.
 
 `Tolgee` adressiert viele der oben genannten Probleme. Ich fand den Einstieg schwieriger als bei anderen Tools mit ähnlichen Ansätzen. Es bietet keine Typsicherheit, was es zudem sehr schwer macht, fehlende Schlüssel zur Kompilierzeit zu finden. Ich musste die Tolgee-APIs mit eigenen Funktionen umhüllen, um eine Erkennung fehlender Schlüssel hinzuzufügen.
 
+Das Paket ist relativ groß (~11,1 KB, was mehr als 2× `react-intlayer` ist).
+
 Auf TanStack Start hatte ich ebenfalls Reaktivitätsprobleme: Beim Sprachwechsel musste ich den Provider zum Re-render zwingen und Locale-Wechsel-Events abonnieren, damit das Laden in einer anderen Sprache korrekt funktionierte.
 
 **(use-intl)** (`use-intl@4.9.1`):
@@ -208,6 +210,8 @@ Bei TanStack Start vermeiden Sie Next.js-spezifische Fallen (`setRequestLocale`,
 
 Dennoch teilt es dieselben großen Nachteile wie Stacks, die auf `t('a.b.c')` basieren: Optimierungen sind möglich, aber sehr zeitaufwendig, und große Projekte riskieren schlechte Praktiken (Namespaces + dynamisches Laden + Typen).
 
+Das Package ist besonders schwer (~17.3kb, etwa 3,5× `react-intlayer`).
+
 Die Nachrichtenformate weichen ebenfalls voneinander ab: `use-intl` verwendet ICU MessageFormat, während `i18next` sein eigenes Format nutzt – was Tooling oder Migrationen kompliziert macht, wenn man sie mischt.
 
 **(Lingui)** (`@lingui/core@5.3.0`):
@@ -218,6 +222,8 @@ Die Nachrichtenformate weichen ebenfalls voneinander ab: `use-intl` verwendet IC
 
 `react-intl` ist eine performante Implementierung des Format.js-Teams. Die DX bleibt wortreich: `const intl = useIntl()` + `intl.formatMessage({ id: "xx.xx" })` erhöht die Komplexität, den zusätzlichen JavaScript-Aufwand und bindet die globale i18n-Instanz an viele Knoten im React-Tree.
 
+Das Package ist auch schwer (~14.4kb, was etwa 3× `react-intlayer` ist).
+
 ### 4 - Empfehlungen
 
 Dieser TanStack Start-Benchmark hat kein direktes Äquivalent zu `next-translate` (Next.js-Plugin + `getStaticProps`). Für Teams, die unbedingt eine `t()`-API mit einem ausgereiften Ökosystem wollen, bleiben `react-i18next` und `use-intl` "vernünftige" Entscheidungen, aber stellen Sie sich darauf ein, viel Zeit in die Optimierung zu investieren, um Leakage zu vermeiden.

package/docs/de/cli/ci.md

@@ -128,6 +128,8 @@ bun x intlayer ci fill --verbose --mode complete
 
 ### Verwendung in CI/CD-Pipelines
 
+Das Ausführen von `intlayer init` erstellt zwei einsatzbereite GitHub Actions-Workflows für Sie (siehe [Scaffolded GitHub Actions](#scaffolded-github-actions) unten). Das Beispiel hier zeigt das äquivalente Setup mit dem `ci`-Befehl für ein Monorepo, bei dem Anmeldedaten pro Projekt aus `INTLAYER_PROJECT_CREDENTIALS` injiziert werden.
+
 In Ihrer CI/CD-Konfiguration (z. B. GitHub Actions, GitLab CI) setzen Sie `INTLAYER_PROJECT_CREDENTIALS` als Geheimnis:
 
 ```yaml

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

@@ -91,7 +91,15 @@ Für die meisten Anwendungsfälle,
 
 - **`--log`**: Nur-Protokollierungsmodus. Nicht mit KI übersetzen; stattdessen die Blöcke, die Aufmerksamkeit erfordern (mit Zeilennummern und Inhalt), für die Basis- und Ziel-Locales protokollieren, um einem anderen Agenten bei der Generierung der Übersetzungen zu helfen.
 
-  > Beispiel: `npx intlayer doc review --log`
+- **Bei `apply`**: Die Übersetzung aktualisieren und die vollständige deutsche Datei zurückgeben
+- **Bei `report`**: Die Blöcke dokumentieren, die Aufmerksamkeit benötigen (mit Zeilennummern und Inhalten)
+- **Bei `synthesis`**: Eine Zusammenfassung der aktuellen und zu bearbeitenden Dokumente liefern
+
+> Beispiel: `npx intlayer doc review --mode report`
+
+> Beispiel: `npx intlayer doc review --log`
+
+Unabhängig vom Modus endet der Durchlauf mit einer Zusammenfassung, die die Dokumente auflistet, die mit ihrem Basisdokument abgestimmt sind, und diejenigen, die noch zu bearbeitende Blöcke haben.
 
 **Optionen für die Ausgabe der Einträge:**
 

package/docs/de/cli/fill.md

@@ -39,14 +39,6 @@ bun x intlayer fill
 
 Dieser Befehl analysiert Ihre Content-Deklarationsdateien auf potenzielle Probleme wie fehlende Übersetzungen, strukturelle Inkonsistenzen oder Typabweichungen. Wenn Probleme gefunden werden, schlägt **intlayer fill** Aktualisierungen vor oder wendet sie an, um Ihre Wörterbücher konsistent und vollständig zu halten.
 
-Wichtige Punkte:
-
-- Teilt große JSON-Dateien in Chunks auf, um innerhalb der Kontextfenster-Grenzen des KI-Modells zu bleiben.
-- Wiederholt die Übersetzung, wenn das Ausgabeformat falsch ist.
-- Integriert anwendungs- und dateispezifischen Kontext für verbesserte Übersetzungsgenauigkeit.
-- Erhält bestehende Übersetzungen, indem sie nicht überschrieben werden.
-- Verarbeitet Dateien, Chunks und Locales parallel mithilfe eines Warteschlangensystems, um die Geschwindigkeit zu erhöhen.
-
 ## Wichtige Punkte:
 
 - Teilt große JSON-Dateien in Chunks auf, um innerhalb der Kontextfenster-Limits des AI-Modells zu bleiben.

package/docs/de/cli/index.md

@@ -127,6 +127,8 @@ Um zu erfahren, wie Sie verfügbare Sprachen oder andere Parameter konfigurieren
 
 - **[Anmelden](https://github.com/aymericzip/intlayer/blob/main/docs/docs/de/cli/login.md)** - Bei Intlayer CMS authentifizieren und Zugangsdaten erhalten
 
+> `intlayer login` stellt einen **Zugangsschlüssel** (`clientId` / `clientSecret`) aus, den jeder authentifizierte Befehl verwendet. Das Geheimnis ist eine serverseitige Anmeldeinformation und gelangt niemals in Ihr Client-Bundle — siehe [Zugangsschlüssel sichern](https://github.com/aymericzip/intlayer/blob/main/docs/docs/de/cli/login.md#zugangsschlüssel-sichern).
+
 ### Kernbefehle
 
 - **[Wörterbücher erstellen (Build)](https://github.com/aymericzip/intlayer/blob/main/docs/docs/de/cli/build.md)** - Erstellen Sie Ihre Wörterbücher aus Inhaltsdeklarationsdateien

package/docs/de/cli/init.md

@@ -50,14 +50,6 @@ Der `init`-Befehl richtet Intlayer automatisch in Ihrem Projekt ein, indem er di
 
 ## Was es macht:
 
-Der `init`-Befehl führt die folgenden Einrichtungsaufgaben aus:
-
-1. **Validiert die Projektstruktur** - Stellt sicher, dass Sie sich in einem gültigen Projektverzeichnis mit einer `package.json`-Datei befinden
-2. **Aktualisiert `.gitignore`** - Fügt `.intlayer` zu Ihrer `.gitignore`-Datei hinzu, um generierte Dateien von der Versionskontrolle auszuschließen
-3. **Konfiguriert TypeScript** - Aktualisiert alle `tsconfig.json`-Dateien, um Intlayer-Typdefinitionen einzuschließen (`.intlayer/**/*.ts`)
-4. **Erstellt Konfigurationsdatei** - Generiert eine `intlayer.config.ts` (für TypeScript-Projekte) oder `intlayer.config.mjs` (für JavaScript-Projekte) mit Standardeinstellungen
-5. **Aktualisiert Vite-Konfiguration** - Wenn eine Vite-Konfigurationsdatei erkannt wird, fügt es den Import des `vite-intlayer`-Plugins hinzu
-
 Der `init`-Befehl führt die folgenden Einrichtungsschritte aus:
 
 1. **Validiert Projektstruktur** - Stellt sicher, dass Sie sich in einem gültigen Projektverzeichnis mit einer `package.json`-Datei befinden

package/docs/de/cli/list_projects.md

@@ -52,8 +52,6 @@ Dieser Befehl sucht nach und listet alle Intlayer-Projekte, indem er Verzeichnis
 
   > Beispiel: `npx intlayer projects list --base-dir /path/to/workspace`
 
-  > Beispiel: `npx intlayer projects list --base-dir /path/to/workspace`
-
 - **`--git-root`**: Suche vom Git-Root-Verzeichnis aus statt vom Basisverzeichnis. Das ist nützlich, um alle Intlayer-Projekte in einem Monorepo oder Git-Repository zu finden.
 
   > Beispiel: `npx intlayer projects list --git-root`

package/docs/de/cli/login.md

@@ -118,6 +118,34 @@ INTLAYER_CLIENT_SECRET=your_client_secret
 }
 ```
 
+## Zugriffsschlüssel sicher aufbewahren
+
+`intlayer login` gibt einen **Zugriffsschlüssel** aus: ein `clientId` / `clientSecret` Paar, das von jedem authentifizierten Befehl (`push`, `pull`, `fill`, `configuration push`, `live`, …) zur Authentifizierung verwendet wird.
+
+```typescript fileName="intlayer.config.ts" codeFormat={["typescript", "esm", "commonjs"]}
+import type { IntlayerConfig } from "intlayer";
+
+const config: IntlayerConfig = {
+  editor: {
+    clientId: process.env.INTLAYER_CLIENT_ID,
+    clientSecret: process.env.INTLAYER_CLIENT_SECRET,
+  },
+};
+
+export default config;
+```
+
+> **`clientSecret` ist eine serverseitige Anmeldedaten.** Sie gewährt vollständigen projektbezogenen API-Zugriff — Lesen und Schreiben Ihrer Wörterbücher, Ihres Projekts und Ihrer Organisation. Bewahren Sie es in `.env` (von git ignoriert) oder in Ihrem CI-Geheimnisspeicher auf und fügen Sie es niemals inline in die Konfigurationsdatei ein.
+
+Intlayer erzwingt dies, anstatt es nur zu dokumentieren:
+
+- `clientSecret` wird **aus der Konfiguration entfernt, die Ihr Bundler inline setzt**, sodass es unabhängig von der Framework-Integration kein Browser-Bundle erreichen kann. Es wird nur serverseitig zur Laufzeit aus der Umgebung gelesen.
+- `clientId` ist anders: Es ist der **öffentliche** Projektschlüssel, sicher zu versenden und wird von [`@intlayer/analytics`](https://github.com/aymericzip/intlayer/blob/main/docs/docs/de/analytics.md#how-events-are-authenticated) verwendet, um ein kurzlebiges, nur zum Erfassen bestimmtes Token zu erhalten.
+
+Das Auskommentieren von `clientId` reicht aus, um jedes authentifizierte Verhalten zu deaktivieren — Remote-Wörterbuchabruf, CMS-Zugriff, Analytics — auch wenn die Umgebungsvariablen noch definiert sind.
+
+Für CI-Pipelines bevorzugen Sie den [`ci` Befehl](https://github.com/aymericzip/intlayer/blob/main/docs/docs/de/cli/ci.md), der die Anmeldedaten für die Dauer eines einzelnen Laufs injiziert, anstatt sie dauerhaft zu speichern.
+
 ## Manuelle Konfiguration
 
 Wenn der Browser nicht automatisch geöffnet wird, können Sie die im Terminal angezeigte URL manuell aufrufen.

package/docs/de/compiler.md

@@ -40,6 +40,12 @@ Der **Intlayer Compiler** ist ein leistungsstarkes Werkzeug, das entwickelt wurd
 
 ## Warum den Intlayer Compiler verwenden?
 
+- **Automatisierung**: Eliminiert das manuelle Kopieren von Inhalten in Wörterbücher.
+
+- **Speed**: Optimierte Content-Extraktion, die sicherstellt, dass dein Build-Prozess schnell bleibt.
+
+- **Developer Experience**: Halten Sie Content-Deklarationen dort, wo sie verwendet werden, um die Wartbarkeit zu verbessern.
+
 - **Automatisierung**: Beseitigt das manuelle Kopieren und Einfügen von Inhalten in Wörterbücher.
 - **Geschwindigkeit**: Optimierte Inhaltsextraktion, die sicherstellt, dass Ihr Build-Prozess schnell bleibt.
 - **Entwicklererfahrung**: Behalten Sie Inhaltsdeklarationen genau dort, wo sie verwendet werden, und verbessern Sie so die Wartbarkeit.
@@ -54,6 +60,8 @@ Während der Compiler eine ausgezeichnete "funktioniert einfach so"-Erfahrung bi
 - **Heuristische Mehrdeutigkeit**: Der Compiler muss erraten, was benutzerorientierter Inhalt im Gegensatz zur Anwendungslogik ist (z. B. `className="active"`, Statuscodes, Produkt-IDs). In komplexen Codebasen kann dies zu falschen Positiven oder übersehenen Zeichenketten führen, die manuelle Anmerkungen und Ausnahmen erfordern.
 - **Nur statische Extraktion**: Die compilerbasierte Extraktion basiert auf statischer Analyse. Zeichenketten, die nur zur Laufzeit existieren (API-Fehlercodes, CMS-Felder usw.), können vom Compiler allein nicht entdeckt oder übersetzt werden, daher benötigen Sie immer noch eine ergänzende Laufzeit-i18n-Strategie.
 
+- **Nur statische Extraktion**: Die compiler-basierte Extraktion basiert auf statischer Analyse. Strings, die nur zur Laufzeit existieren (API-Fehlercodes, CMS-Felder usw.), können vom Compiler allein nicht erkannt oder übersetzt werden, daher benötigen Sie immer noch eine komplementäre i18n-Strategie zur Laufzeit.
+
 Für einen tieferen architektonischen Vergleich siehe den Blogbeitrag [Compiler vs. Declarative i18n](https://github.com/aymericzip/intlayer/blob/main/docs/blog/de/compiler_vs_declarative_i18n.md).
 
 Als Alternative, um Ihren i18n-Prozess zu automatisieren und gleichzeitig die volle Kontrolle über Ihren Inhalt zu behalten, bietet Intlayer auch einen Auto-Extraktionsbefehl `intlayer extract` (siehe [CLI-Dokumentation](https://github.com/aymericzip/intlayer/blob/main/docs/docs/de/cli/extract.md)) oder den Befehl `Intlayer: extract content to Dictionary` aus der Intlayer VS Code-Erweiterung (siehe [VS Code-Erweiterungsdokumentation](https://github.com/aymericzip/intlayer/blob/main/docs/docs/de/vs_code_extension.md)).
@@ -94,12 +102,18 @@ export default defineConfig({
 });
 ```
 
+> Das eigenständige `intlayerCompiler()`-Plugin wird weiterhin für erweiterte Setups exportiert. Die Registrierung zusammen mit `intlayer()` ist sicher — der Compiler dedupliziert sich selbst und wird nur einmal ausgeführt.
+
 See complete tutorial: [Intlayer Compiler with Vite+React](https://github.com/aymericzip/intlayer/blob/main/docs/docs/en/intlayer_with_vite+react_compiler.md)
 
 #### Framework-Unterstützung
 
 Das Vite-Plugin erkennt und verarbeitet automatisch verschiedene Dateitypen:
 
+- **React / JSX / TSX**: Nativ unterstützt.
+
+- **Vue**: Requires `@intlayer/vue-compiler`.
+
 - **React / JSX / TSX**: Wird nativ unterstützt.
 - **Vue**: Erfordert `@intlayer/vue-compiler`.
 - **Svelte**: Erfordert `@intlayer/svelte-compiler`.

package/docs/de/configuration.md

@@ -738,8 +738,6 @@ Definiert Einstellungen für den integrierten Editor, einschließlich Server-Por
 | `liveSyncPort`               | Der Port des Live Sync Servers.                                                                                                                                                      | `number`                          | `4000`                              | `4000`                                                                                          |                                                                                                                                                                                                                                                                            |
 | `liveSyncURL`                | Die URL des Live Sync Servers.                                                                                                                                                       | `string`                          | `'http://localhost:{liveSyncPort}'` | `'https://example.com'`                                                                         | Zeigt standardmäßig auf localhost; kann für einen entfernten Live Sync Server geändert werden.                                                                                                                                                                             |
 
----
-
 ### Analytics-Konfiguration (Analytics Configuration)
 
 Definiert Einstellungen für Intlayer Analytics: die Erfassung, welche Inhalte Nutzern tatsächlich angezeigt werden (Seitenaufrufe, Content-Expositionen), und die Unterstützung von A/B-Tests für Inhalte.
@@ -991,6 +989,13 @@ Einstellungen für interne Pfade und Ausgabeergebnisse von Intlayer. Diese Einst
 
 Einstellungen, die Wörterbuchoperationen steuern, einschließlich automatischem Ausfüllverhalten und Inhaltsgenerierung.
 
+Diese Dictionary-Konfiguration dient zwei Hauptzwecken:
+
+1. **Standardwerte**: Definieren Sie Standardwerte beim Erstellen von Content-Deklarationsdateien
+2. **Fallback-Verhalten**: Stellen Sie Fallback-Werte bereit, wenn bestimmte Felder nicht definiert sind, sodass Sie das Verhalten des Wörterbuchbetriebs global definieren können
+
+Weitere Informationen zu Content-Deklarationsdateien und wie Konfigurationswerte angewendet werden, finden Sie in der [Content-Datei-Dokumentation](https://github.com/aymericzip/intlayer/blob/main/docs/docs/de/dictionary/content_file.md).
+
 | Feld                        | Beschreibung                                                                                                                                                                           | Typ                                                                                                             | Standard              | Beispiel                                                                                    | Hinweis                                                                                                                                                                                                                                                                                                                                                                                                                         |
 | --------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------- | --------------------- | ------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
 | `fill`                      | Steuert, wie die Ausgabedateien für das automatische Ausfüllen (KI-Übersetzung) generiert werden.                                                                                      | `boolean` &#124; <br/> `FilePathPattern` &#124; <br/> `Partial<Record<Locale, boolean &#124; FilePathPattern>>` | `true`                | `{ en: '/locales/en/{{key}}.json', fr: ({ key }) => '/locales/fr/${key}.json', es: false }` | • `true`: Standardpfad (gleiche Datei wie Quelle).<br/>• `false`: Deaktivieren.<br/>• String-/Funktionsmuster erzeugt Dateien pro Sprache.<br/>• Objekt pro Sprache: Jede Sprache entspricht ihrem eigenen Muster; `false` ignoriert diese Sprache.<br/>• Das Einschließen von `{{locale}}` aktiviert die Pro-Sprache-Generierung.<br/>• `fill` auf Wörterbuchebene hat immer Vorrang vor dieser globalen Einstellung.          |
@@ -1030,8 +1035,6 @@ Einstellungen zur Anpassung der Protokollausgabe (Logs) von Intlayer.
 | `mode`   | Steuert den Modus des Loggers.       | `'default'` &#124; <br/> `'verbose'` &#124; <br/> `'disabled'` | `'default'`     | `'verbose'`        | • `'verbose'`: Protokolliert mehr Informationen für das Debugging.<br/>• `'disabled'`: Deaktiviert den Logger vollständig. |
 | `prefix` | Das Präfix für Protokollnachrichten. | `string`                                                       | `'[intlayer] '` | `'[mein präfix] '` |                                                                                                                            |
 
----
-
 ### KI-Konfiguration
 
 Einstellungen, die die KI-Funktionen von Intlayer steuern, einschließlich Anbieter, Modell und API-Schlüssel.
@@ -1071,8 +1074,6 @@ Intlayer unterstützt mehrere KI-Anbieter für maximale Flexibilität. Derzeit u
 | `baseURL`            | Die Basis-URL für die KI-API.                                                                                                                    | `string`                                                                                                                                                                                                                                                                                                                                                                                                                                             | Keines      | `'https://api.openai.com/v1'` <br/> `'http://localhost:5000'` | Kann auf einen lokalen oder benutzerdefinierten KI-API-Endpunkt zeigen.                                                                                                                                           |
 | `dataSerialization`  | Datenserialisierungsformat für die KI-Funktionen.                                                                                                | `'json'` &#124; <br/> `'toon'`                                                                                                                                                                                                                                                                                                                                                                                                                       | `undefined` | `'toon'`                                                      | • `'json'`: Standard, zuverlässig; verbraucht mehr Tokens.<br/>• `'toon'`: Weniger Tokens, weniger konsistent.<br/>• Zusätzliche Parameter werden an das Modell als Kontext übergeben (Abstraktionsaufwand etc.). |
 
----
-
 ### Build-Konfiguration
 
 Einstellungen, die steuern, wie Intlayer die Internationalisierung Ihrer Anwendung optimiert und erstellt.
@@ -1110,8 +1111,6 @@ Einstellungen, die den Intlayer-Compiler steuern, der Wörterbücher direkt aus
 | `noMetadata`          | Wenn `true`, lässt der Compiler die Metadaten des Wörterbuchs (Schlüssel, Inhalts-Wrapper) in der Ausgabe weg.                                                                                                                                                                                                        | `boolean`                                                                                                       | `false`     | `false` → `{"key":"mein-schlüssel","content":{"key":"wert"}}` <br/> `true` → `{"key":"wert"}`                                                            | • Nützlich für i18next oder ICU MessageFormat JSON-Ausgaben.<br/>• Funktioniert gut mit dem `loadJSON` Plugin.                                                                                                                                                                                                               |
 | `dictionaryKeyPrefix` | Wörterbuch-Schlüsselpräfix                                                                                                                                                                                                                                                                                            | `string`                                                                                                        | `''`        |                                                                                                                                                          | Fügen Sie ein optionales Präfix für die extrahierten Wörterbuchschlüssel hinzu                                                                                                                                                                                                                                               |
 
----
-
 ### Benutzerdefinierte Schemata (Custom Schemas)
 
 | Feld      | Beschreibung                                                                             | Typ                         |

package/docs/de/custom_domains.md

@@ -138,6 +138,38 @@ getMultilingualUrls("/about", { currentDomain: "intlayer.org" });
 
 Diese absoluten URLs können direkt in `<link rel="alternate" hreflang="...">`-Tags für SEO verwendet werden.
 
+## Typinferenz
+
+`routing.domains` wird in die generierte Modulgaugmentierung serialisiert, daher
+verengen `getLocalizedUrl` und `getLocalizedPath` ihren Rückgabetyp auf die exakte
+URL, die ein domänengestütztes Locale auflöst — einschließlich der Präfixunterdrückung.
+
+```ts
+// routing: { mode: 'prefix-no-default', domains: { en: 'intlayer.org', zh: 'intlayer.zh' } }
+
+getLocalizedUrl("/about", "zh");
+//     ^? "https://intlayer.zh/about" | "/about"
+
+getLocalizedPath("/about", "zh");
+//     ^? "/about"   (niemals ein origin, und kein /zh/ Präfix)
+```
+
+Der URL-Typ ist die **Union** der zwei Werte, die die Funktion zurückgeben kann: die
+absolute URL auf der Domäne des Locales und die relative URL, die sie zurückgibt, wenn die
+gerenderte Seite bereits auf dieser Domäne lebt. `getLocalizedPath` hat diese
+Mehrdeutigkeit nicht — es gibt niemals einen origin aus — daher bleibt es ein einzelnes Literal.
+
+Locales, die sich eine Domäne teilen, behalten ihr normales Präfix im Typ ebenfalls:
+
+```ts
+getLocalizedUrl("/about", "fr");
+//     ^? "https://intlayer.org/fr/about" | "/fr/about"
+```
+
+> Regeneriere die Typen (`npx intlayer build` oder ein beliebiger dev server run) nach dem
+> Ändern von `routing.domains` — die Verengung kommt aus der generierten
+> `__RoutingRegistry`, nicht aus der Konfigurationsdatei selbst.
+
 ## Proxy-Verhalten
 
 ### Next.js
@@ -170,6 +202,8 @@ GET intlayer.zh/about
 
 Das `intlayerProxy` Vite-Plugin wendet die gleiche Logik während der Entwicklung an:
 
+> Seit Intlayer v9 ist `intlayerProxy()` direkt in das `intlayer()`-Plugin integriert und standardmäßig durch die Option `routing.enableProxy` aktiviert (`true` standardmäßig). Die separate Registrierung wie unten gezeigt ist nun optional — sie wird aus Gründen der Abwärtskompatibilität und für Setups beibehalten, die die Plugin-Reihenfolge kontrollieren müssen. Setzen Sie `routing.enableProxy: false`, um sich abzumelden. Siehe die [v9-Versionshinweise](https://github.com/aymericzip/intlayer/blob/main/docs/docs/de/releases/v9.md).
+
 ```typescript fileName="vite.config.ts"
 import { defineConfig } from "vite";
 import { intlayer } from "vite-intlayer";

package/docs/de/custom_url_rewrites.md

@@ -248,7 +248,7 @@ Um sicherzustellen, dass die Adressleiste des Browsers stets die "schöne" lokal
 
 <Tabs group='framework'>
   <Tab label="Next.js" value="nextjs">
-  
+
     ```tsx
     'use client';
 
@@ -263,7 +263,7 @@ Um sicherzustellen, dass die Adressleiste des Browsers stets die "schöne" lokal
   </Tab>
 
   <Tab label="React Router" value="reactrouter">
-  
+
     ```tsx
     'use client';
 
@@ -279,7 +279,7 @@ Um sicherzustellen, dass die Adressleiste des Browsers stets die "schöne" lokal
   </Tab>
 
   <Tab label="Vue" value="vue">
-  
+
     ```vue
     <script setup>
     import { useRewriteURL } from "vue-intlayer";
@@ -291,7 +291,7 @@ Um sicherzustellen, dass die Adressleiste des Browsers stets die "schöne" lokal
 
   </Tab>
   <Tab label="Solid" value="solid">
-  
+
     ```tsx
     import { useRewriteURL } from "solid-intlayer";
 
@@ -303,7 +303,7 @@ Um sicherzustellen, dass die Adressleiste des Browsers stets die "schöne" lokal
 
   </Tab>
   <Tab label="Svelte" value="svelte">
-  
+
     ```svelte
     <script>
     import { useRewriteURL } from "svelte-intlayer";
@@ -340,6 +340,8 @@ export function middleware(request: NextRequest) {
 
 Für SolidJS, Vue und Svelte verwaltet das `intlayerProxy`-Vite-Plugin die Rewrites während der Entwicklung.
 
+> Seit Intlayer v9 ist `intlayerProxy()` direkt in das `intlayer()` Plugin integriert und standardmäßig durch die Option `routing.enableProxy` (`true` standardmäßig) aktiviert. Eine separate Registrierung wie unten gezeigt ist nun optional — sie wird für Rückwärtskompatibilität und für Setups beibehalten, die die Plugin-Reihenfolge kontrollieren müssen. Setzen Sie `routing.enableProxy: false`, um sich abzumelden. Siehe die [v9 Release Notes](https://github.com/aymericzip/intlayer/blob/main/docs/docs/de/releases/v9.md).
+
 ```typescript fileName="vite.config.ts"
 import { defineConfig } from "vite";
 import { intlayer } from "vite-intlayer";

package/docs/de/dictionary/enumeration.md

@@ -27,191 +27,8 @@ author: aymericzip
 
 ## Wie Enumeration funktioniert
 
-<Tabs group="framework">
-  <Tab label="React" value="react">
-
-To use enumeration in a React component, you can leverage the `useIntlayer` hook from the `react-intlayer` package. This hook retrieves the correct content based on the specified ID. Here's an example of how to use it:
-
-```tsx fileName="**/*.tsx" codeFormat={["typescript", "esm"]}
-import type { FC } from "react";
-import { useIntlayer } from "react-intlayer";
-
-const CarComponent: FC = () => {
-  const { numberOfCar } = useIntlayer("car_count");
-
-  return (
-    <div>
-      <p>
-        {
-          numberOfCar(0) // Output: No cars
-        }
-      </p>
-      <p>
-        {
-          numberOfCar(6) // Output: Some cars
-        }
-      </p>
-      <p>
-        {
-          numberOfCar(20) // Output: Many cars
-        }
-      </p>
-      <p>
-        {
-          numberOfCar(0.01) // Output: Fallback value
-        }
-      </p>
-    </div>
-  );
-};
-```
-
-  </Tab>
-  <Tab label="Next.js" value="nextjs">
-
 To use enumeration in Next.js Client Components, retrieve it via the `useIntlayer` hook. Here's an example:
 
-```tsx fileName="**/*.tsx" codeFormat={["typescript", "esm"]}
-"use client";
-
-import type { FC } from "react";
-import { useIntlayer } from "next-intlayer";
-
-const CarComponent: FC = () => {
-  const { numberOfCar } = useIntlayer("car_count");
-
-  return (
-    <div>
-      <p>{numberOfCar(6)}</p>
-    </div>
-  );
-};
-
-export default CarComponent;
-```
-
-  </Tab>
-  <Tab label="Vue" value="vue">
-
-To use enumeration in Vue components, retrieve it via the `useIntlayer` hook. Here's an example:
-
-```vue fileName="**/*.vue"
-<script setup lang="ts">
-import { useIntlayer } from "vue-intlayer";
-
-const { numberOfCar } = useIntlayer("car_count");
-</script>
-
-<template>
-  <div>
-    <p>{{ numberOfCar(6) }}</p>
-  </div>
-</template>
-```
-
-  </Tab>
-  <Tab label="Svelte" value="svelte">
-
-To use enumeration in Svelte components, retrieve it via the `useIntlayer` hook. The store is accessed with `$`. Here's an example:
-
-```svelte fileName="**/*.svelte"
-<script lang="ts">
-import { useIntlayer } from "svelte-intlayer";
-
-const content = useIntlayer("car_count");
-</script>
-
-<div>
-  <p>{$content.numberOfCar(6)}</p>
-</div>
-```
-
-  </Tab>
-  <Tab label="Preact" value="preact">
-
-To use enumeration in Preact components, retrieve it via the `useIntlayer` hook. Here's an example:
-
-```tsx fileName="**/*.tsx" codeFormat={["typescript", "esm"]}
-import type { FC } from "preact";
-import { useIntlayer } from "preact-intlayer";
-
-const CarComponent: FC = () => {
-  const { numberOfCar } = useIntlayer("car_count");
-
-  return (
-    <div>
-      <p>{numberOfCar(6)}</p>
-    </div>
-  );
-};
-
-export default CarComponent;
-```
-
-  </Tab>
-  <Tab label="Solid" value="solid">
-
-To use enumeration in SolidJS components, retrieve it via the `useIntlayer` hook. Here's an example:
-
-```tsx fileName="**/*.tsx" codeFormat={["typescript", "esm"]}
-import type { Component } from "solid-js";
-import { useIntlayer } from "solid-intlayer";
-
-const CarComponent: Component = () => {
-  const { numberOfCar } = useIntlayer("car_count");
-
-  return (
-    <div>
-      <p>{numberOfCar(6)}</p>
-    </div>
-  );
-};
-
-export default CarComponent;
-```
-
-  </Tab>
-  <Tab label="Angular" value="angular">
-
-To use enumeration in Angular components, retrieve it via the `useIntlayer` hook. Here's an example:
-
-```typescript fileName="app.component.ts" codeFormat="typescript"
-import { Component } from "@angular/core";
-import { useIntlayer } from "angular-intlayer";
-
-@Component({
-  selector: "app-car",
-  template: `
-    <div>
-      <p>{{ content().numberOfCar(6) }}</p>
-    </div>
-  `,
-})
-export class CarComponent {
-  content = useIntlayer("car_count");
-}
-```
-
-  </Tab>
-  <Tab label="Vanilla JS" value="vanilla">
-
-To use enumeration with `vanilla-intlayer`, retrieve it via the `useIntlayer` hook. Here's an example:
-
-```typescript fileName="**/*.ts" codeFormat={["typescript", "esm"]}
-import { installIntlayer, useIntlayer } from "vanilla-intlayer";
-
-installIntlayer();
-
-const content = useIntlayer("car_count").onChange((newContent) => {
-  document.getElementById("cars")!.textContent = newContent.numberOfCar(6);
-});
-
-// Initial render
-document.getElementById("cars")!.textContent = content.numberOfCar(6);
-```
-
-  </Tab>
-</Tabs>
 ## Einrichtung der Enumeration
 
 Um eine Enumeration in Ihrem Intlayer-Projekt einzurichten, müssen Sie ein Inhaltsmodul erstellen, das Enumeration-Definitionen enthält. Hier ist ein Beispiel für eine einfache Enumeration der Anzahl von Autos:

package/docs/de/dictionary/html.md

@@ -245,7 +245,7 @@ Sie können das HTML-Rendering global für Ihre gesamte Anwendung konfigurieren.
 
 <Tabs group="framework">
   <Tab label="React / Next.js" value="react">
-  
+
     ```tsx fileName="AppProvider.tsx"
     import { HTMLProvider } from "react-intlayer/html";
 
@@ -282,7 +282,7 @@ Sie können das HTML-Rendering global für Ihre gesamte Anwendung konfigurieren.
 
   </Tab>
   <Tab label="Vue" value="vue">
-  
+
     ```typescript fileName="main.ts"
     import { createApp, h } from "vue";
     import { intlayer } from "vue-intlayer";
@@ -327,7 +327,7 @@ Sie können das HTML-Rendering global für Ihre gesamte Anwendung konfigurieren.
 
   </Tab>
   <Tab label="Svelte" value="svelte">
-   
+
     ```svelte fileName="App.svelte"
     <script lang="ts">
       import { HTMLProvider } from "svelte-intlayer/html";
@@ -364,7 +364,7 @@ Sie können das HTML-Rendering global für Ihre gesamte Anwendung konfigurieren.
 
   </Tab>
   <Tab label="Preact" value="preact">
-   
+
     ```tsx fileName="AppProvider.tsx"
     import { HTMLProvider } from "preact-intlayer/html";
 
@@ -400,7 +400,7 @@ Sie können das HTML-Rendering global für Ihre gesamte Anwendung konfigurieren.
 
   </Tab>
   <Tab label="Solid" value="solid">
-   
+
     ```tsx fileName="AppProvider.tsx"
     import { HTMLProvider } from "solid-intlayer/html";
 
@@ -460,9 +460,9 @@ Sie können das HTML-Rendering global für Ihre gesamte Anwendung konfigurieren.
     export const appConfig: ApplicationConfig = {
       providers: [
         createIntlayerHTMLProvider({
-          renderMarkdown: async (html) => {
-            const { renderMarkdown } = await import('angular-intlayer/html');
-            return renderMarkdown(html);
+          renderHTML: async (html) => {
+            const { renderHTML } = await import('angular-intlayer/html');
+            return renderHTML(html);
           },
         }),
       ],
@@ -519,9 +519,9 @@ Wenn Sie rohe HTML-Strings rendern müssen oder mehr Kontrolle über die Kompone
 
   </Tab>
   <Tab label="Vue" value="vue">
-   
+
     #### `<HTMLRenderer />` Komponente
-   
+
     ```vue
     <script setup>
     import { HTMLRenderer } from "vue-intlayer/html";
@@ -534,9 +534,9 @@ Wenn Sie rohe HTML-Strings rendern müssen oder mehr Kontrolle über die Kompone
 
   </Tab>
   <Tab label="Svelte" value="svelte">
-  
+
     #### `<HTMLRenderer />` Komponente
-   
+
     ```svelte
     <script lang="ts">
     import { HTMLRenderer } from "svelte-intlayer/html";
@@ -568,9 +568,9 @@ Wenn Sie rohe HTML-Strings rendern müssen oder mehr Kontrolle über die Kompone
 
   </Tab>
   <Tab label="Preact" value="preact">
-   
+
     #### `<HTMLRenderer />` Komponente
-   
+
     ```tsx
     import { HTMLRenderer } from "preact-intlayer/html";
 
@@ -599,9 +599,9 @@ Wenn Sie rohe HTML-Strings rendern müssen oder mehr Kontrolle über die Kompone
 
   </Tab>
   <Tab label="Solid" value="solid">
-   
+
     #### `<HTMLRenderer />` Komponente
-   
+
     ```tsx
     import { HTMLRenderer } from "solid-intlayer/html";
 
@@ -634,13 +634,13 @@ Wenn Sie rohe HTML-Strings rendern müssen oder mehr Kontrolle über die Kompone
     Rendern Sie einen HTML-String mit dem Service.
 
     ```typescript
-    import { IntlayerHTMLService } from "angular-intlayer";
+    import { IntlayerHTMLService } from "angular-intlayer/html";
 
     export class MyComponent {
       constructor(private markdownService: IntlayerHTMLService) {}
 
       renderHTML(html: string) {
-        return this.markdownService.renderMarkdown(html);
+        return this.markdownService.renderHTML(html);
       }
     }
     ```