@intlayer/docs 8.12.5-canary.0 → 9.0.0-canary.11

package/docs/cs/releases/v9.md

@@ -0,0 +1,358 @@
+---
+createdAt: 2026-06-14
+updatedAt: 2026-06-30
+title: Nový Intlayer v9 - Co je nového?
+description: Zjistěte, co je nového v Intlayer v9. Představujeme drop-in balíčky kompatibility pro oblíbené i18n knihovny, podporu pro Kolekce a Varianty a vlastní hostování přes Docker Compose.
+keywords:
+  - Intlayer
+  - Compatibility
+  - Migration
+  - Collections
+  - Variants
+  - CMS SDK
+  - Self-Hosting
+  - Docker
+  - i18next
+  - next-intl
+  - vue-i18n
+slugs:
+  - doc
+  - releases
+  - v9
+author: aymericzip
+---
+
+# Nový Intlayer v9 - Co je nového?
+
+Vítejte v Intlayer v9! Toto hlavní vydání představuje obrovský milník ve zjednodušení migrace na Intlayer díky **balíčkům compat adaptérů** pro hlavní i18n knihovny (`react-i18next`, `next-intl`, `vue-i18n` atd.) a přidává podporu pro bohaté struktury obsahu: **Kolekce** a **Varianty**.
+
+## Obsah
+
+<TOC levels={[2]} maxDepth={1} />
+
+---
+
+## Balíčky compat adaptérů
+
+Migrace na Intlayer z oblíbených i18n knihoven je nyní snazší než kdykoli předtím. Vytvořili jsme pět balíčků kompatibility, které vystavují **přesně stejná veřejná API** jako standardní i18n knihovny, ale při běhu delegují veškerou překladovou práci na Intlayer.
+
+### Vystavení stejného veřejného API se striktním typováním
+
+Nahrazením importů získáte všechny výhody Intlayeru (včetně typové bezpečnosti v době kompilace vůči vašim skutečným slovníkům) s minimálními změnami kódu:
+
+- `@intlayer/i18next`
+- `@intlayer/react-i18next`
+- `@intlayer/next-intl`
+- `@intlayer/react-intl`
+- `@intlayer/next-i18next`
+- `@intlayer/vue-i18n`
+- `@intlayer/lingui`
+
+Jednoduše například změňte:
+
+```ts
+import { useTranslation } from "react-i18next";
+```
+
+na:
+
+```ts
+import { useTranslation } from "@intlayer/react-i18next";
+```
+
+Vaše klíče budou nyní **striktně typovány** vůči vašim Intlayer slovníkům a nabídnou plné automatické doplňování tečkových cest ve vašem IDE!
+
+### Pluginy pro aliasy bundlerů (Vite, Next.js, Turbopack)
+
+Aby bylo možné migrovat bez ručního přepisování všech importů, každý balíček compat adaptéru obsahuje **vlastní plugin pro bundler** (Vite nebo Next.js) pod subcestou `/plugin`.
+
+Tyto pluginy automaticky přepisují stávající importy (např. `react-i18next` nebo `next-intl`) na jejich ekvivalenty `@intlayer/*` v době sestavení.
+
+#### Příklad Next.js (Webpack / Turbopack)
+
+Místo `withIntlayer` zabalte konfiguraci Next.js pomocí pluginu kompatibility:
+
+```ts fileName="next.config.ts"
+import { createNextI18nPlugin } from "@intlayer/next-i18next/plugin";
+import type { NextConfig } from "next";
+
+const withIntlayer = createNextI18nPlugin();
+const nextConfig: NextConfig = {};
+
+export default withIntlayer(nextConfig);
+```
+
+#### Příklad Vite (React, Vue, Solid, Svelte)
+
+```ts fileName="vite.config.ts"
+import vueI18nVitePlugin from "@intlayer/vue-i18n/plugin";
+
+export default defineConfig({
+  plugins: [vueI18nVitePlugin()],
+});
+```
+
+---
+
+## Sdílený runtime resolver
+
+Všechny compat adaptéry nyní směrují rozlišení překladů přes jeden vysoce optimalizovaný runtime parser: `@intlayer/core/messageFormat`.
+
+- **Interpolace zpráv**: Zpracovává standardní `{{var}}` (bílé znaky a tečkové cesty), argumenty ve formátu ICU (`{v, number, percent}` atd.) a holé šablony `{var}`.
+- **Resolver uzlů zpráv**: Zpracovává vnořené uzly: `insert()`, `plural()` (pravidla CLDR pro množné číslo), `enu()` (výčet), `gender()`, HTML tagy, pole a volatelné funkční uzly.
+- **Tokenizovaný parser tagů**: Podporuje vložené XML/HTML tagy a číslované tagy (např. `<1>children</1>`) pro vykreslování formátovaného textu přímo z krabice.
+
+---
+
+## Specifikace funkcí: Kolekce a varianty
+
+Intlayer v9 jde za hranice statických objektů klíč–hodnota a umožňuje slovníkům deklarovat dynamické rozložení struktur, které jsou plně typovány end-to-end.
+
+### 1. Kolekce
+
+Definujte seznam seřazených položek spravovaných CMS (např. FAQ, produkty nebo seznamy blogů). Každá položka žije ve vlastním souboru `.content.ts` se stejným `key` a číslem `item`:
+
+```ts fileName="faq.1.content.ts"
+import { t, type Dictionary } from "intlayer";
+
+export default {
+  key: "faq",
+  item: 1,
+  content: {
+    question: t({ en: "What is Intlayer?", fr: "Qu'est-ce qu'Intlayer ?" }),
+    answer: t({ en: "An i18n toolkit.", fr: "Une boîte à outils i18n." }),
+  },
+} satisfies Dictionary;
+```
+
+```ts fileName="faq.2.content.ts"
+import { t, type Dictionary } from "intlayer";
+
+export default {
+  key: "faq",
+  item: 2,
+  content: {
+    question: t({ en: "Is it free?", fr: "Est-ce gratuit ?" }),
+    answer: t({ en: "Yes, open-source.", fr: "Oui, open-source." }),
+  },
+} satisfies Dictionary;
+```
+
+#### Použití:
+
+```ts
+// Načíst všechny položky jako pole
+const allFaqs = useIntlayer("faq"); // -> { question: string, answer: string }[]
+
+// Načíst jednu položku podle indexu
+const faq = useIntlayer("faq", { item: 2 }); // -> { question: string, answer: string }
+```
+
+### 2. Varianty
+
+Poskytujte A/B testy, sezónní záhlaví, příznaky funkcí nebo vlastní vstupní stránky:
+
+#### Textové varianty (např. A/B testování)
+
+```ts fileName="hero.content.ts"
+import { t, type Dictionary } from "intlayer";
+
+export default {
+  key: "hero-banner",
+  variant: "default",
+  content: {
+    control: t({ en: "Welcome", fr: "Bienvenue" }),
+    black_friday: t({ en: "Shop now", fr: "Acheter maintenant" }),
+  },
+} satisfies Dictionary;
+```
+
+#### Použití:
+
+```ts
+const banner = useIntlayer("hero-banner", { variant: "black_friday" });
+```
+
+#### Objektové varianty (např. Dynamické záznamy)
+
+```ts fileName="product.content.ts"
+import { t, type Dictionary } from "intlayer";
+
+export default {
+  key: "product-copy",
+  variant: {
+    id: "prod_123",
+    category: "books",
+  },
+  content: {
+    title: t({ en: "Clean Code", fr: "Code Propre" }),
+  },
+} satisfies Dictionary;
+```
+
+#### Použití:
+
+```ts
+// Načte pouze požadovaný záznam dynamicky (vyžaduje Suspense)
+const product = useIntlayer("product-copy", {
+  variant: { id: "prod_123", category: "books" },
+});
+```
+
+---
+
+## Dynamické načítání a optimalizace velikosti bundlu
+
+Aby byly bundly extrémně malé, Intlayer v9 podporuje dynamické líné načítání.
+
+Ve své konfiguraci nastavte `importMode` na `'dynamic'` nebo `'fetch'`:
+
+```ts fileName="intlayer.config.ts"
+export default {
+  dictionary: {
+    importMode: "dynamic", // "static" | "dynamic" | "fetch"
+  },
+};
+```
+
+V době sestavení `@intlayer/swc` a `@intlayer/babel` prohledají vaše soubory a nahradí volání `useIntlayer`/`getIntlayer` wrappers tree-shakeable (`useDictionary`/`useDictionaryDynamic`). Načítá se pouze obsah potřebný pro vybranou položku kolekce, variantu nebo jazyk, čímž se zabrání tomu, aby váš produkční bundle obsahoval nevyužité překlady.
+
+---
+
+## Vite plugin: zabudovaný kompilátor a proxy
+
+Plugin Vite `intlayer()` nyní přímo sdružuje **kompilátor** a **proxy pro směrování jazyků**, takže většina projektů potřebuje pouze jeden plugin v `vite.config.ts`:
+
+```ts fileName="vite.config.ts"
+import { defineConfig } from "vite";
+import { intlayer } from "vite-intlayer";
+
+export default defineConfig({
+  plugins: [intlayer()],
+});
+```
+
+- **Kompilátor**: Aktivuje se automaticky, když je `compiler.enabled` nastaveno na `true` a je nakonfigurována cesta `compiler.output`. `intlayerCompiler()` již není třeba registrovat samostatně.
+- **Proxy**: Aktivuje se automaticky na základě nové možnosti `routing.enableProxy` (výchozí hodnota `true`). Propojuje middleware pro detekci jazyka, přesměrování a přepisování ve vývoji, náhledu a produkčním SSR. `intlayerProxy()` již není třeba registrovat samostatně.
+
+### Možnost `routing.enableProxy`
+
+Nová možnost `routing.enableProxy` řídí, zda je proxy pro směrování jazyků zapojena. Výchozí hodnota je `true`. Vypněte ji, když chcete směrování jazyků zpracovávat sami:
+
+```ts fileName="intlayer.config.ts"
+import type { IntlayerConfig } from "intlayer";
+
+const config: IntlayerConfig = {
+  routing: {
+    enableProxy: false, // Výchozí: true
+  },
+};
+
+export default config;
+```
+
+Samostatné pluginy `intlayerCompiler()` a `intlayerProxy()` zůstávají exportovány pro pokročilá nastavení. Jejich registrace společně s `intlayer()` je bezpečná — každý plugin se deduplikuje a spustí se pouze jednou.
+
+---
+
+## Kompilátor je ve výchozím nastavení zakázán
+
+Počínaje Intlayer v9 je **kompilátor ve výchozím nastavení zakázán** (`compiler.enabled` nyní výchozí hodnota je `false`). Chcete-li zapnout extrakci vašich souborů `.content.ts` v době sestavení, nastavte `compiler.enabled: true` ve své konfiguraci:
+
+```ts fileName="intlayer.config.ts"
+import type { IntlayerConfig } from "intlayer";
+
+const config: IntlayerConfig = {
+  compiler: {
+    enabled: true, // Výchozí: false — vyžadováno pro povolení kompilátoru od v9
+    output: ({ fileName }) => `./${fileName}.content.ts`,
+  },
+};
+
+export default config;
+```
+
+Když je kompilátor zakázán, Intlayer přeskočí krok extrakce v době sestavení a spoléhá na vaše již deklarované slovníky. Povolte jej pouze tehdy, když chcete, aby plugin bundleru (`@intlayer/swc`, `@intlayer/babel` nebo plugin Vite `intlayer()`) automaticky extrahoval obsah.
+
+---
+
+## React Native: importy z jednoho balíčku
+
+V aplikaci React Native nebo Expo již nemusíte žonglovat s `react-intlayer` i `react-native-intlayer`. Balíček `react-native-intlayer` nyní **znovu exportuje celé API `react-intlayer`** (hooks, utility a subcesty `/format`, `/html` a `/markdown`) a jeho `IntlayerProvider` automaticky aplikuje polyfilly React Native.
+
+Importujte vše z jediného balíčku `react-native-intlayer`:
+
+```tsx
+import {
+  IntlayerProvider,
+  useIntlayer,
+  useLocale,
+} from "react-native-intlayer";
+```
+
+```bash
+npm install intlayer react-native-intlayer
+```
+
+> Import z `react-intlayer` nadále funguje, ale `react-native-intlayer` je nyní doporučeným jediným vstupním bodem pro React Native — jeho provider dodává polyfilly, které webově orientovaný provider `react-intlayer` nemá.
+
+---
+
+## CMS SDK: použijte Intlayer jako headless databázi obsahu
+
+Intlayer v9 dodává přehledné, automaticky autentizující SDK v `@intlayer/api` pro programatickou interakci s CMS — načítejte projekty, načítejte slovníky a odesílejte nebo aktualizujte je z vlastního serveru, skriptů nebo CI. Autentizace (OAuth2 `client_credentials`) je spravována a obnovována za vás.
+
+SDK je rozděleno do **dvou samostatných importů**, aby váš bundle obsahoval pouze domény, které skutečně používáte:
+
+1. `createIntlayerCMS` — lehký **autentizátor** uchovávající přihlašovací údaje a spravovaný token (žádný klientský bundle domény není součástí).
+2. `dictionaryEndpoint`, `projectEndpoint`, … — **binery endpointů** pro jednotlivé domény, každý importovaný z vlastní subcesty.
+
+```ts fileName="cms.ts"
+import { createIntlayerCMS } from "@intlayer/api";
+import { dictionaryEndpoint } from "@intlayer/api/dictionary";
+
+const cms = createIntlayerCMS();
+
+// Čtení
+const { data: dictionaries } = await dictionaryEndpoint(cms).getDictionaries();
+
+// Zápis — použijte CMS jako databázi
+await dictionaryEndpoint(cms).pushDictionaries([myDictionary]);
+```
+
+> Zabezpečení: přihlašovací údaje CMS udělují oprávnění k zápisu vašeho obsahu. Autentizátor vytvářejte vždy pouze **na straně serveru** — nikdy neodesílejte `clientId`/`clientSecret` do prohlížeče.
+
+---
+
+## Vlastní hostování
+
+Intlayer v9 poskytuje prvotřídní podporu pro provozování vlastní instance Intlayeru jediným příkazem — bez nutnosti účtu Intlayer Cloud.
+
+```sh
+curl -fsSL https://intlayer.org/install.sh | sh
+```
+
+Instalátor stáhne `docker-compose.yml` a `.env`, automaticky vygeneruje požadovaná tajemství a spustí `docker compose up -d`. Vše — dashboard, API, databáze, objektové úložiště a transakční e-mail — běží lokálně v kontejnerech.
+
+---
+
+## Poznámky k migraci z v8
+
+Pokud provádíte upgrade z v8, vezměte na vědomí, že v9 neobsahuje žádné zlomové změny. Zde jsou však klíčové změny:
+
+- **Kompilátor ve výchozím nastavení zakázán**: `compiler.enabled` nyní výchozí hodnota je `false`. Pokud se spoléháte na extrakci souborů `.content.ts` v době sestavení, nastavte `compiler.enabled: true` v `intlayer.config.ts`.
+- **Plugin Vite**: Kompilátor a proxy pro směrování jazyků jsou nyní součástí `intlayer()`. Pokud jste dříve ručně registrovali `intlayerCompiler()` nebo `intlayerProxy()`, můžete je odstranit — jsou automaticky deduplikovány, takže jejich ponechání je neškodné. Použijte `routing.enableProxy: false` pro vypnutí proxy.
+- **Jazyky a dialekty**: Pokud používáte externí závislosti i18n, přidejte příslušné compat adaptérové pluginy do vaší konfigurace nebo nastavení bundleru pro automatické přepisování importů.
+- **Vlastní selektory**: Při volání `useIntlayer` je druhý parametr nyní vyhrazen pro objekt možností obsahující `{ locale, item, variant }`. Pokud jste dříve předávali řetězec jazyka přímo, stále to lze, ale použití objektu možností je doporučeno pro pokročilé výběry.
+- **React Native**: `react-native-intlayer` nyní znovu exportuje celé API `react-intlayer`. V aplikaci React Native importujte vše z `react-native-intlayer` a odeberte přímou závislost na `react-intlayer`. Stávající importy z `react-intlayer` nadále fungují.
+
+---
+
+## Užitečné odkazy
+
+- [Průvodce balíčky compat adaptérů](https://github.com/aymericzip/intlayer/blob/main/docs/docs/cs/compat/index.md)
+- [Dynamické slovníky - Kolekce a varianty](https://github.com/aymericzip/intlayer/blob/main/docs/docs/cs/dynamic_dictionaries/index.md)
+- [Reference konfigurace](https://github.com/aymericzip/intlayer/blob/main/docs/docs/cs/configuration.md)
+- [Průvodce React Native a Expo](https://github.com/aymericzip/intlayer/blob/main/docs/docs/cs/intlayer_with_react_native+expo.md)
+- [CMS SDK - Programatický přístup s @intlayer/api](https://github.com/aymericzip/intlayer/blob/main/docs/docs/cs/intlayer_CMS.md)
+- [Průvodce vlastním hostováním](https://github.com/aymericzip/intlayer/blob/main/docs/docs/cs/self_hosting.md)

package/docs/de/CI_CD.md

@@ -26,6 +26,10 @@ author: aymericzip
 
 Intlayer ermöglicht die automatische Generierung von Übersetzungen für Ihre Content-Deklarationsdateien. Es gibt verschiedene Möglichkeiten, dies je nach Ihrem Workflow zu realisieren.
 
+## Inhaltsverzeichnis
+
+<TOC/>
+
 ## Verwendung des CMS
 
 Mit Intlayer können Sie einen Workflow verwenden, bei dem nur eine einzige Locale lokal deklariert wird, während alle Übersetzungen remote über das CMS verwaltet werden. Dies ermöglicht es, Inhalte und Übersetzungen vollständig von der Codebasis zu trennen, bietet mehr Flexibilität für Content-Editoren und ermöglicht ein Hot Content Reloading (kein erneutes Bauen der Anwendung erforderlich, um Änderungen anzuwenden).

package/docs/de/autoFill.md

@@ -28,6 +28,53 @@ history:
 author: aymericzip
 ---
 
+# Füllen Sie Content Declaration File Translations aus
+
+**Autofill content declaration files** in Ihrer CI sind eine Möglichkeit, Ihren Entwicklungs-Workflow zu beschleunigen.
+
+## Das Verhalten verstehen
+
+Der `fill`-Befehl umfasst zwei Modi:
+
+- **Complete**: Füllt automatisch alle fehlenden Inhalte für jedes Locale aus und bearbeitet die aktuelle Datei oder eine andere angegebene Datei. Das heißt, der Complete-Modus überspringt die Übersetzung bereits vorhandener Inhalte, falls diese bereits übersetzt wurden.
+- **Review**: Füllt automatisch **alle** Inhalte für jedes Locale aus und generiert für eine bestimmte Datei oder eine andere angegebene Datei.
+
+Der `fill`-Befehl verarbeitet alle Ihre Locale-Content-Deklarationsdateien. Das heißt, er verarbeitet nicht Ihre Remote-Inhalte aus dem CMS. Das CMS umfasst sein eigenes Übersetzungsverwaltungssystem.
+Wenn Sie Plugins wie `@intlayer/sync-json-plugin` verwenden, wird Intlayer die JSON-Dateien in Locale-Content-Deklarationsdateien umwandeln. Das heißt, sie werden vom `fill`-Befehl verarbeitet.
+
+Die neu generierten Dateien enthalten eine `filled`-Anweisung als Dictionary-Metadaten. Diese Anweisung wird von Intlayer verwendet, um zu erkennen, ob die Datei automatisch ausgefüllt wurde oder nicht, und überspringt diese Datei, falls vorhanden, vor erneuter Übersetzung.
+
+Intlayer berücksichtigt auch die folgende Anweisung zum automatischen Ausfüllen:
+
+- Aus Ihrer `.content.{ts|js|json}` → `fill`-Anweisung
+- Aus Ihrer Konfigurationsdatei `.intlayer.config.ts` → `dictionary.fill`-Anweisung
+- Wird standardmäßig auf `true` gesetzt, ansonsten
+
+Bei Pro-Locale-Content-Deklarationsdateien wird die `true`-Anweisung durch `./{{fileName}}.fill.content.json` ersetzt. Dies ist der Fall, da eine Pro-Locale-Content-Deklarationsdatei keine zusätzlichen lokalisierten Inhalte erhalten kann. Daher wird eine neue Datei generiert, um die vorhandene Datei nicht zu überschreiben.
+
+## Standardverhalten
+
+Standardmäßig ist `fill` global auf `true` eingestellt, was bedeutet, dass Intlayer automatisch alle Content-Dateien ausfüllt und die Datei selbst bearbeitet. Dieses Verhalten kann auf verschiedene Weise angepasst werden:
+
+### Globale Konfigurationsoptionen
+
+1. **`fill: true` (Standard)** - Füllt automatisch alle Locales aus und bearbeitet die aktuelle Datei
+2. **`fill: false`** - Deaktiviert das automatische Ausfüllen für diese Content-Datei
+3. **`fill: "./relative/path/to/file"`** - Erstellt/aktualisiert die angegebene Datei, ohne die aktuelle zu bearbeiten, indem auf einen relativen Pfad verwiesen wird, der basierend auf dem Speicherort der aktuellen Datei aufgelöst wird
+4. **`fill: "/absolute/path/to/file"`** - Erstellt/aktualisiert die angegebene Datei, ohne die aktuelle zu bearbeiten, indem auf einen relativen Pfad verwiesen wird, der basierend auf dem Speicherort des Basisverzeichnisses aufgelöst wird (Feld `baseDir` in der Konfigurationsdatei `.intlayer.config.ts`)
+5. **`fill: "C:\\absolute\path\to\file"`** - Erstellt/aktualisiert die angegebene Datei, ohne die aktuelle zu bearbeiten, indem auf einen absoluten Pfad verwiesen wird, der basierend auf Ihrem Betriebssystem aufgelöst wird
+6. **`fill: { [key in Locales]?: string }`** - Erstellt/aktualisiert die angegebene Datei für jede Locale
+
+### v7 Behavior Changes
+
+In v7 hat sich das Verhalten des `fill`-Befehls aktualisiert:
+
+- **`fill: true`** - Schreibt die aktuelle Datei mit gefülltem Inhalt für alle Locales um
+- **`fill: "path/to/file"`** - Füllt die angegebene Datei, ohne die aktuelle Datei zu ändern
+- **`fill: false`** - Deaktiviert Auto-Fill vollständig
+
+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
 
 **Deklarationsdateien für automatisches Ausfüllen von Inhalten** sind eine Möglichkeit, Ihren Entwicklungsworkflow zu beschleunigen.
@@ -88,6 +135,40 @@ 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.
 
+## Globale Konfiguration
+
+Sie können die globale Auto-Fill-Konfiguration in der Datei `intlayer.config.ts` konfigurieren.
+
+```ts fileName="intlayer.config.ts"
+import { type IntlayerConfig, Locales } from "intlayer";
+
+const config: IntlayerConfig = {
+  internationalization: {
+    locales: [Locales.ENGLISH, Locales.FRENCH, Locales.SPANISH],
+    defaultLocale: Locales.ENGLISH,
+    requiredLocales: [Locales.ENGLISH, Locales.FRENCH],
+  },
+  dictionary: {
+    // Fehlende Übersetzungen automatisch für alle Wörterbücher generieren
+    fill: "./{{fileName}}Filled.content.ts",
+    //
+    // fill: "/messages/{{locale}}/{{key}}/{{fileName}}.content.json",
+    //
+    // fill: true, // Fehlende Übersetzungen automatisch für alle Wörterbücher generieren wie die Verwendung von "./{{fileName}}.content.json"
+    //
+    // fill: {
+    //   en: "./{{fileName}}.en.content.json",
+    //   fr: "./{{fileName}}.fr.content.json",
+    //   es: "./{{fileName}}.es.content.json",
+    // },
+  },
+};
+
+export default config;
+```
+
+Sie können die Konfiguration pro Wörterbuch noch optimieren, indem Sie das Feld `fill` in Content-Dateien verwenden. Intlayer berücksichtigt zunächst die Pro-Wörterbuch-Konfiguration und fällt dann auf die globale Konfiguration zurück.
+
 ## Automatisch ausgefülltes Dateiformat
 
 Das empfohlene Format für automatisch ausgefüllte Deklarationsdateien ist **JSON**, da es Formatierungsbeschränkungen vermeidet. Intlayer unterstützt jedoch auch `.ts`, `.js`, `.mjs`, `.cjs` und andere Formate.

package/docs/de/benchmark/solid.md

@@ -118,6 +118,28 @@ Wir haben **vier Ladestrategien** verglichen:
 - **Scoped static**: Hält den Code organisiert (logische Trennung) ohne komplexe zusätzliche Netzwerkanfragen.
 - **Scoped dynamic**: Bester Ansatz für _Code-Splitting_ und Leistung. Minimiert den Speicherverbrauch, indem nur das geladen wird, was die aktuelle Ansicht und die aktive Locale benötigen.
 
+### Was ich gemessen habe:
+
+Ich habe dieselbe mehrsprachige App in einem echten Browser für jeden Stack ausgeführt und dann notiert, was tatsächlich übertragen wurde und wie lange es dauerte. Größen werden **nach normaler Web-Komprimierung** gemeldet, da dies näher an dem liegt, was Benutzer herunterladen, als an rohen Quellzählungen.
+
+- **Internationalization-Bibliotheksgröße**: Nach dem Bundling, Tree-Shaking und Minifizierung ist die Größe der i18n-Bibliothek die Größe der Provider + Hooks/Primitives-Code in einer leeren Komponente. Sie beinhaltet nicht das Laden von Übersetzungsdateien. Sie antwortet darauf, wie teuer die Bibliothek ist, bevor Ihr Inhalt ins Spiel kommt.
+
+- **JavaScript pro Seite**: Für jede Benchmark-Route, wie viel Skript der Browser bei diesem Besuch abruft, gemittelt über die Seiten in der Suite (und über Sprachen, wenn der Bericht sie zusammenfasst). Schwere Seiten sind langsame Seiten.
+
+- **Leakage von anderen Sprachen**: Es ist der Inhalt derselben Seite, aber in einer anderen Sprache, die versehentlich auf der überprüften Seite geladen würde. Dieser Inhalt ist unnötig und sollte vermieden werden. (z. B. Inhalt der Seite `/fr/about` im Bundle `/en/about`)
+
+- **Leakage von anderen Routes**: Die gleiche Idee für **andere Bildschirme** in der App: ob ihr Text mitlädt, wenn Sie nur eine Seite öffnen. (z. B. Inhalt der Seite `/en/about` im Bundle `/en/contact`). Eine hohe Punktzahl deutet auf schwache Aufteilung oder zu breite Bundles hin.
+
+- **Durchschnittliche Komponenten-Bundle-Größe**: Häufige UI-Elemente werden **einzeln** gemessen, anstatt sich in einer großen App-Nummer zu verstecken. Es zeigt, ob die Internationalisierung alltägliche Komponenten stillschweigend aufbläht. Wenn beispielsweise Ihre Komponente neu gerendert wird, lädt sie alle diese Daten aus dem Speicher. Das Anhängen eines großen JSON an eine Komponente ist wie das Verbinden mit einem großen Speicher von ungenutzten Daten, die die Leistung Ihrer Komponenten verlangsamen.
+
+- **Responsivität beim Sprachenwechsel**: Ich wechsle die Sprache mit dem eigenen Steuerelement der App und messe, wie lange es dauert, bis die Seite deutlich gewechselt hat, was ein Besucher bemerken würde, nicht ein Lab-Micro-Schritt.
+
+- **Rendering-Arbeit nach einem Sprachenwechsel**: Eine engere Nachverfolgung: wie viel Aufwand die Schnittstelle brauchte, um für die neue Sprache neu zu zeichnen, sobald der Wechsel im Fluss ist. Nützlich, wenn sich die „gefühlte" Zeit und die Framework-Kosten unterscheiden.
+
+- **Anfängliche Seitenladezeit**: Von der Navigation bis der Browser die Seite für die getesteten Szenarien als vollständig geladen betrachtet. Gut für den Vergleich von Cold Starts.
+
+- **Hydration-Zeit**: Wenn die App es offenlegt, wie lange der Client damit verbringt, Server-HTML in etwas umzuwandeln, das Sie tatsächlich anklicken können. Ein Bindestrich in den Tabellen bedeutet, dass diese Implementierung in diesem Benchmark keine zuverlässige Hydration-Zahl lieferte.
+
 ## GitHub-Sterne
 
 GitHub-Sterne sind ein starker Indikator für die Popularität eines Projekts, das Vertrauen der Community und die langfristige Relevanz. Sie sind zwar kein direktes Maß für die technische Qualität, spiegeln jedoch wider, wie viele Entwickler das Projekt nützlich finden, seinen Fortschritt verfolgen und es wahrscheinlich übernehmen werden. Um den Wert eines Projekts einzuschätzen, helfen Sterne dabei, die Traktion verschiedener Alternativen zu vergleichen und Einblicke in das Wachstum des Ökosystems zu gewinnen.

package/docs/de/benchmark/svelte.md

@@ -116,6 +116,28 @@ Wir haben **vier Ladestrategien** verglichen:
 - **Scoped static**: Hält den Code organisiert (logische Trennung) ohne komplexe zusätzliche Netzwerkanfragen.
 - **Scoped dynamic**: Bester Ansatz für _Code-Splitting_ und Leistung. Minimiert den Speicherverbrauch, indem nur das geladen wird, was die aktuelle Ansicht und die aktive Locale benötigen.
 
+### Was ich gemessen habe:
+
+Ich habe dieselbe mehrsprachige App in einem echten Browser für jeden Stack ausgeführt und dann notiert, was tatsächlich auf der Leitung angezeigt wurde und wie lange es dauerte. Die Größen werden **nach normaler Webkomprimierung** angegeben, da dies näher daran liegt, was Benutzer herunterladen, als rohe Quellzählungen.
+
+- **Größe der Internationalisierungsbibliothek**: Nach dem Bundeln, Tree-Shaking und der Minifizierung ist die Größe der i18n-Bibliothek die Größe des Providers + Stores-Code in einer leeren Komponente. Sie beinhaltet nicht das Laden von Übersetzungsdateien. Sie beantwortet die Frage, wie teuer die Bibliothek ist, bevor Ihr Inhalt ins Spiel kommt.
+
+- **JavaScript pro Seite**: Für jede Benchmark-Route, wie viel Skript der Browser bei diesem Besuch abruft, gemittelt über die Seiten in der Suite (und über Sprachen, in denen der Bericht diese zusammenfasst). Schwere Seiten sind langsame Seiten.
+
+- **Speicherleck aus anderen Sprachen**: Es ist der Inhalt derselben Seite in einer anderen Sprache, der versehentlich auf die audited Seite geladen würde. Dieser Inhalt ist unnötig und sollte vermieden werden. (z. B. Inhalt der Seite `/fr/about` im Bundle der Seite `/en/about`)
+
+- **Speicherleck aus anderen Routen**: Dieselbe Idee für **andere Bildschirme** in der App: ob deren Kopie mitlädt, wenn Sie nur eine Seite geöffnet haben. (z. B. Inhalt der Seite `/en/about` im Bundle der Seite `/en/contact`). Ein hoher Wert deutet auf schwaches Splitting oder über-breite Bundles hin.
+
+- **Durchschnittliche Komponentenbündelgröße**: Häufige UI-Teile werden **einzeln** gemessen, anstatt sich in einer großen App-Nummer zu verstecken. Es zeigt, ob die Internationalisierung alltägliche Komponenten unauffällig aufbläht. Wenn Ihre Komponente beispielsweise neu gerendert wird, wird sie alle diese Daten aus dem Speicher laden. Das Anhängen eines großen JSON an eine Komponente ist wie das Verbinden mit einem großen Speicher ungenutzter Daten, der die Leistung Ihrer Komponenten verlangsamt.
+
+- **Sprachschalter-Reaktionsfähigkeit**: Ich wechsle die Sprache mit dem eigenen Steuerelement der App und messe, wie lange es dauert, bis sich die Seite klar gewechselt hat, was ein Besucher bemerken würde, nicht ein Lab-Mikro-Schritt.
+
+- **Rendering-Arbeit nach einem Sprachwechsel**: Ein engerer Nachfolger: wie viel Aufwand die Benutzeroberfläche brauchte, um sich für die neue Sprache neu zu streichen, sobald der Wechsel in Gang ist. Nützlich, wenn sich die „gefühlte" Zeit und die Framework-Kosten unterscheiden.
+
+- **Anfängliche Seitenladezeit**: Von der Navigation zum Browser, der die Seite für die von mir getesteten Szenarien vollständig geladen betrachtet. Gut zum Vergleichen kalter Starts.
+
+- **Hydrationisierungszeit**: Wenn die App es offenlegt, wie lange der Client damit verbringt, Server-HTML in etwas zu verwandeln, das Sie tatsächlich anklicken können. Ein Bindestrich in den Tabellen bedeutet, dass diese Implementierung in dieser Benchmark keine zuverlässige Hydrationsfigur bereitgestellt hat.
+
 ## GitHub-Sterne
 
 GitHub-Sterne sind ein starker Indikator für die Popularität eines Projekts, das Vertrauen der Community und die langfristige Relevanz. Sie sind zwar kein direktes Maß für die technische Qualität, spiegeln jedoch wider, wie viele Entwickler das Projekt nützlich finden, seinen Fortschritt verfolgen und es wahrscheinlich übernehmen werden. Um den Wert eines Projekts einzuschätzen, helfen Sterne dabei, die Traktion verschiedener Alternativen zu vergleichen und Einblicke in das Wachstum des Ökosystems zu gewinnen.

package/docs/de/benchmark/tanstack.md

@@ -124,6 +124,28 @@ Wir haben **vier Ladestrategien** verglichen:
 - **Scoped static**: Hält den Code organisiert (logische Trennung) ohne komplexe zusätzliche Netzwerkanfragen.
 - **Scoped dynamic**: Bester Ansatz für _Code-Splitting_ und Performance. Minimiert den Speicherbedarf, indem nur das geladen wird, was der aktuelle View und die aktive Sprache benötigen.
 
+### Was ich gemessen habe:
+
+Ich habe dieselbe mehrsprachige App in einem echten Browser für jeden Stack ausgeführt, dann notiert, was tatsächlich über die Leitung ging und wie lange es dauerte. Die Größen werden **nach normaler Webekomprimierung** angegeben, da dies näher an dem liegt, was Benutzer herunterladen, als rohe Quellzählungen.
+
+- **Größe der Internationalisierungsbibliothek**: Nach Bundling, Tree-Shaking und Minifizierung ist die Größe der i18n-Bibliothek die Größe der Provider (z. B. `NextIntlClientProvider`) + Hooks (z. B. `useTranslations`) Code in einer leeren Komponente. Sie umfasst nicht das Laden von Übersetzungsdateien. Sie beantwortet die Frage, wie teuer die Bibliothek ist, bevor Ihr Inhalt ins Spiel kommt.
+
+- **JavaScript pro Seite**: Für jede Benchmark-Route, wie viel Skript der Browser bei diesem Besuch abruft, gemittelt über die Seiten in der Suite (und über Locales, wo der Bericht sie zusammenführt). Schwere Seiten sind langsame Seiten.
+
+- **Leckage aus anderen Locales**: Es ist der Inhalt derselben Seite, aber in einer anderen Sprache, der versehentlich in die geprüfte Seite geladen würde. Dieser Inhalt ist unnötig und sollte vermieden werden. (z. B. Inhalt der Seite `/fr/about` im Bundle der Seite `/en/about`)
+
+- **Leckage aus anderen Routes**: Dieselbe Idee für **andere Bildschirme** in der App: ob ihre Kopie mitkommen, wenn Sie nur eine Seite öffnen. (z. B. Inhalt der Seite `/en/about` im Bundle der Seite `/en/contact`). Ein hoher Wert deutet auf schwache Aufteilung oder zu breite Bundles hin.
+
+- **Durchschnittliche Komponentenbundel-Größe**: Häufig verwendete UI-Elemente werden **einzeln** gemessen, anstatt sie in einer riesigen App-Nummer zu verbergen. Es zeigt, ob die Internationalisierung alltägliche Komponenten stillschweigend aufbläht. Wenn Ihre Komponente beispielsweise neu gerendert wird, werden alle diese Daten aus dem Speicher geladen. Das Anhängen einer riesigen JSON an eine Komponente ist wie das Verbinden mit einem großen Speicher ungenutzter Daten, die die Leistung Ihrer Komponenten verlangsamen.
+
+- **Responsivität des Sprachwechsels**: Ich wechsle die Sprache mit der eigenen Kontrolle der App und messe, wie lange es dauert, bis die Seite eindeutig gewechselt hat, was ein Besucher bemerken würde, nicht ein Lab-Mikro-Schritt.
+
+- **Rendering-Arbeit nach einem Sprachwechsel**: Eine engere Folgefrage: wie viel Aufwand die Schnittstelle aufgewandt hat, um für die neue Sprache neu zu zeichnen, sobald der Wechsel im Gange ist. Nützlich, wenn die „gefühlte" Zeit und die Framework-Kosten auseinandergehen.
+
+- **Anfängliche Seitenladezeit**: Von der Navigation bis zur Annahme der vollständig geladenen Seite durch den Browser für die getesteten Szenarien. Gut zum Vergleichen von Kaltstart.
+
+- **Hydrationsdauer**: Wenn die App sie offenlegt, wie lange der Client damit verbringt, Server-HTML in etwas Klickbares umzuwandeln. Ein Bindestrich in den Tabellen bedeutet, dass diese Implementierung in diesem Benchmark keine zuverlässige Hydrationszahl bereitgestellt hat.
+
 ## GitHub-Sterne
 
 GitHub-Sterne sind ein starker Indikator für die Popularität eines Projekts, das Vertrauen der Community und die langfristige Relevanz. Sie sind zwar kein direktes Maß für die technische Qualität, spiegeln jedoch wider, wie viele Entwickler das Projekt nützlich finden, seinen Fortschritt verfolgen und es wahrscheinlich übernehmen werden. Um den Wert eines Projekts einzuschätzen, helfen Sterne dabei, die Traktion verschiedener Alternativen zu vergleichen und Einblicke in das Wachstum des Ökosystems zu gewinnen.

package/docs/de/cli/ci.md

@@ -140,6 +140,28 @@ steps:
     run: npx intlayer ci fill
 ```
 
+## Gerüstete GitHub Actions
+
+Wenn Sie `intlayer init` ausführen, erkennt Intlayer Ihren Paketmanager (npm, yarn, pnpm oder bun) und erstellt zwei GitHub Actions-Workflows unter `.github/workflows/` mit Befehlen, die diesem Paketmanager entsprechen:
+
+- **`intlayer-fill.yml`** — Bei jedem Pull Request werden die Wörterbücher erstellt und `intlayer fill --git-diff --mode complete` ausgeführt, um fehlende Übersetzungen für die geänderten Wörterbücher zu generieren, und dann wird das Ergebnis auf den PR-Branch committed.
+- **`intlayer-test.yml`** — Bei jedem Pull Request werden die Wörterbücher erstellt und `intlayer test` ausgeführt, wobei die Prüfung fehlschlägt, wenn erforderliche Lokalisierungen fehlende Übersetzungen haben.
+
+Vorhandene Workflow-Dateien werden niemals überschrieben. Um das Scaffolding vollständig zu überspringen, führen Sie aus:
+
+```bash
+npx intlayer init --no-github-actions
+```
+
+### AI-Zugriff für den Fill-Workflow bereitstellen
+
+Die gerüstete `intlayer-fill.yml` erfordert AI-Zugriff. Es stehen zwei Optionen zur Verfügung (konfiguriert im `env`-Block des Workflows):
+
+1. **Ihr eigener AI-Provider-Schlüssel** — Fügen Sie ein `AI_API_KEY`-Secret in Ihren Repository-Einstellungen hinzu (Settings → Secrets and variables → Actions). Der Workflow leitet ihn über `--provider`, `--model` und `--api-key` weiter.
+2. **Intlayer CMS-Zugangsschlüssel** — Fügen Sie `INTLAYER_CLIENT_ID` und `INTLAYER_CLIENT_SECRET`-Secrets hinzu und verbinden Sie sie mit Ihrem `intlayer.config` `editor`-Abschnitt. CMS-Zugangsschlüssel gewähren AI-Zugriff über das Intlayer-Backend.
+
+Der `intlayer-test.yml`-Workflow erfordert keinen AI-Zugriff.
+
 ## Fehlerbehandlung
 
 - Wenn `INTLAYER_PROJECT_CREDENTIALS` nicht gesetzt ist, beendet sich der Befehl mit einem Fehler.