@intlayer/docs 9.0.0-canary.9 → 9.0.1

package/docs/nl/releases/v9.md

@@ -0,0 +1,349 @@
+---
+createdAt: 2026-06-14
+updatedAt: 2026-06-30
+title: Nieuwe Intlayer v9 - Wat is er nieuw?
+description: Ontdek wat er nieuw is in Intlayer v9. Introductie van drop-in compatibiliteitspakketten voor populaire i18n-bibliotheken, ondersteuning voor Verzamelingen en Varianten, en zelf hosten via Docker Compose.
+keywords:
+  - Intlayer
+  - Compatibility
+  - Migration
+  - Collections
+  - Variants
+  - CMS SDK
+  - Self-Hosting
+  - Docker
+  - i18next
+  - next-intl
+  - vue-i18n
+youtubeVideo: https://www.youtube.com/watch?v=zmCN4z_B4jk
+slugs:
+  - doc
+  - releases
+  - v9
+author: aymericzip
+---
+
+# Nieuwe Intlayer v9 - Wat is er nieuw?
+
+Welkom bij Intlayer v9! Deze grote release markeert een enorme mijlpaal in het vereenvoudigen van het migratiepad naar Intlayer met **Compat-adapterpakketten** voor grote i18n-bibliotheken (`react-i18next`, `next-intl`, `vue-i18n`, enz.) en voegt ondersteuning toe voor rijke inhoudsstructuren: **Verzamelingen** en **Varianten**.
+
+<iframe
+  src="https://www.youtube.com/embed/zmCN4z_B4jk"
+  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 Video - New Intlayer v9 - What's new?"
+  sandbox="allow-forms allow-modals allow-popups allow-presentation allow-same-origin allow-scripts"
+  loading="lazy"
+/>
+
+## Inhoudsopgave
+
+<TOC levels={[2]} maxDepth={1} />
+
+---
+
+## Compat-adapterpakketten
+
+Migreren naar Intlayer vanuit populaire i18n-bibliotheken is nu eenvoudiger dan ooit. We hebben vijf compatibiliteitspakketten gemaakt die exact dezelfde publieke API's blootstellen als standaard i18n-bibliotheken, maar al het vertaalwerk tijdens uitvoering delegeren aan Intlayer.
+
+### Dezelfde publieke API blootstellen met strikte typering
+
+Door imports te vervangen, profiteert u van alle voordelen van Intlayer (inclusief compilatietijd type-veiligheid ten opzichte van uw werkelijke woordenboeken) met minimale codewijzigingen:
+
+- `@intlayer/i18next`
+- `@intlayer/react-i18next`
+- `@intlayer/next-intl`
+- `@intlayer/react-intl`
+- `@intlayer/next-i18next`
+- `@intlayer/vue-i18n`
+- `@intlayer/lingui`
+
+Wijzig bijvoorbeeld eenvoudig:
+
+```ts
+import { useTranslation } from "react-i18next";
+```
+
+naar:
+
+```ts
+import { useTranslation } from "@intlayer/react-i18next";
+```
+
+Uw sleutels worden nu **strikt getypeerd** op basis van uw Intlayer-woordenboeken, wat volledige dot-pad-autoaanvulling biedt in uw IDE!
+
+### Bundler-aliasplugins (Vite, Next.js, Turbopack)
+
+Om te migreren zonder alle importstatements handmatig te herschrijven, bevat elk compat-adapterpakket een **aangepaste bundler-plugin** (Vite of Next.js) onder het `/plugin`-subpad.
+
+Deze plugins herschrijven automatisch bestaande imports (bijv. `react-i18next` of `next-intl`) naar hun `@intlayer/*`-equivalenten tijdens het bouwen.
+
+#### Next.js (Webpack / Turbopack) Voorbeeld
+
+Gebruik in plaats van `withIntlayer` de compat-plugin om uw Next.js-configuratie te wikkelen:
+
+```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);
+```
+
+#### Vite (React, Vue, Solid, Svelte) Voorbeeld
+
+```ts fileName="vite.config.ts"
+import vueI18nVitePlugin from "@intlayer/vue-i18n/plugin";
+
+export default defineConfig({
+  plugins: [vueI18nVitePlugin()],
+});
+```
+
+---
+
+## Gedeelde runtime-resolver
+
+Alle compat-adapters routeren vertaalresolutie nu via één sterk geoptimaliseerde runtime-parser: `@intlayer/core/messageFormat`.
+
+- **Berichtinterpolatie**: Verwerkt standaard `{{var}}` (witruimte & dot-paden), ICU-geformatteerde argumenten (`{v, number, percent}` enz.) en gewone `{var}`-sjablonen.
+- **Berichtknooppuntresolver**: Verwerkt geneste knooppunten: `insert()`, `plural()` (CLDR meervoudsregels), `enu()` (opsomming), `gender()`, HTML-tags, arrays en aanroepbare functieknooppunten.
+- **Getokeniseerde tagparser**: Ondersteunt inline XML/HTML-tags en genummerde tags (bijv. `<1>children</1>`) voor rijke-tekstweergave zonder extra configuratie.
+
+---
+
+## Functiespecificaties: Verzamelingen en varianten
+
+Intlayer v9 gaat verder dan statische sleutel-waardeparen en stelt woordenboeken in staat dynamische layoutstructuren te declareren die end-to-end volledig getypeerd zijn.
+
+### 1. Verzamelingen
+
+Definieer een door CMS beheerde lijst met geordende items (bijv. FAQ's, producten of bloglijsten). Elk item bevindt zich in een eigen `.content.ts`-bestand met dezelfde `key` en een `item`-nummer:
+
+```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;
+```
+
+#### Gebruik:
+
+```ts
+// Alle items als array ophalen
+const allFaqs = useIntlayer("faq"); // -> { question: string, answer: string }[]
+
+// Eén item ophalen op index
+const faq = useIntlayer("faq", { item: 2 }); // -> { question: string, answer: string }
+```
+
+### 2. Varianten
+
+Lever A/B-tests, seizoensgebonden koppen, functievlaggen of aangepaste landingspagina's:
+
+#### Tekstvarianten (bijv. A/B-testen)
+
+```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;
+```
+
+#### Gebruik:
+
+```ts
+const banner = useIntlayer("hero-banner", { variant: "black_friday" });
+```
+
+#### Objectvarianten (bijv. Dynamische records)
+
+```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;
+```
+
+#### Gebruik:
+
+```ts
+// Haalt alleen het gevraagde record dynamisch op (vereist Suspense)
+const product = useIntlayer("product-copy", {
+  variant: { id: "prod_123", category: "books" },
+});
+```
+
+---
+
+## Vite-plugin: ingebouwde compiler en proxy
+
+De `intlayer()` Vite-plugin bundelt nu de **compiler** en de **locale-routeringsproxy** rechtstreeks, zodat de meeste projecten slechts één plugin nodig hebben in `vite.config.ts`:
+
+```ts fileName="vite.config.ts"
+import { defineConfig } from "vite";
+import { intlayer } from "vite-intlayer";
+
+export default defineConfig({
+  plugins: [intlayer()],
+});
+```
+
+- **Compiler**: Wordt automatisch geactiveerd wanneer `compiler.enabled` is ingesteld op `true` en een `compiler.output`-pad is geconfigureerd. U hoeft `intlayerCompiler()` niet langer afzonderlijk te registreren.
+- **Proxy**: Wordt automatisch geactiveerd op basis van de nieuwe optie `routing.enableProxy` (standaard `true`). Het koppelt de middleware voor taaldetedering, omleiding en herschrijving in ontwikkeling, voorvertoning en productie-SSR. U hoeft `intlayerProxy()` niet langer afzonderlijk te registreren.
+
+### De optie `routing.enableProxy`
+
+Een nieuwe optie `routing.enableProxy` bepaalt of de locale-routeringsproxy wordt gekoppeld. De standaardwaarde is `true`. Schakel deze uit wanneer u de taalroutering zelf wilt afhandelen:
+
+```ts fileName="intlayer.config.ts"
+import type { IntlayerConfig } from "intlayer";
+
+const config: IntlayerConfig = {
+  routing: {
+    enableProxy: false, // Standaard: true
+  },
+};
+
+export default config;
+```
+
+De zelfstandige plugins `intlayerCompiler()` en `intlayerProxy()` blijven beschikbaar voor geavanceerde installaties. Het is veilig om ze samen met `intlayer()` te registreren — elke plugin dedupliceert zichzelf en wordt slechts één keer uitgevoerd.
+
+---
+
+## Compiler standaard uitgeschakeld
+
+Vanaf Intlayer v9 is de **compiler standaard uitgeschakeld** (`compiler.enabled` is nu standaard `false`). Om build-tijdextractie van uw `.content.ts`-bestanden in te schakelen, stelt u `compiler.enabled: true` in uw configuratie in:
+
+```ts fileName="intlayer.config.ts"
+import type { IntlayerConfig } from "intlayer";
+
+const config: IntlayerConfig = {
+  compiler: {
+    enabled: true, // Standaard: false — vereist om de compiler in te schakelen sinds v9
+    output: ({ fileName }) => `./${fileName}.content.ts`,
+  },
+};
+
+export default config;
+```
+
+Wanneer de compiler is uitgeschakeld, slaat Intlayer de build-tijdextractiestap over en vertrouwt op uw reeds gedeclareerde woordenboeken. Schakel deze alleen in wanneer u wilt dat de bundler-plugin (`@intlayer/swc`, `@intlayer/babel` of de `intlayer()` Vite-plugin) inhoud automatisch extraheert.
+
+---
+
+## React Native: importeren vanuit één pakket
+
+In een React Native- of Expo-app hoeft u niet langer zowel `react-intlayer` als `react-native-intlayer` te beheren. Het pakket `react-native-intlayer` **herexporteert nu de volledige `react-intlayer`-API** (hooks, hulpprogramma's en de subpaden `/format`, `/html` en `/markdown`), en de `IntlayerProvider` past de React Native polyfills automatisch toe.
+
+Importeer alles vanuit het enkele pakket `react-native-intlayer`:
+
+```tsx
+import {
+  IntlayerProvider,
+  useIntlayer,
+  useLocale,
+} from "react-native-intlayer";
+```
+
+```bash
+npm install intlayer react-native-intlayer
+```
+
+> Importeren vanuit `react-intlayer` blijft werken, maar `react-native-intlayer` is nu het aanbevolen enkelvoudige invoerpunt voor React Native — de provider bevat de polyfills die de webgerichte `react-intlayer`-provider niet heeft.
+
+---
+
+## CMS SDK: gebruik Intlayer als headless-contentdatabase
+
+Intlayer v9 levert een overzichtelijke, automatisch authenticerende SDK in `@intlayer/api` om programmatisch met de CMS te communiceren — haal projecten op, haal woordenboeken op en duw of update ze vanuit uw eigen server, scripts of CI. Authenticatie (OAuth2 `client_credentials`) wordt voor u beheerd en vernieuwd.
+
+De SDK is opgesplitst in **twee afzonderlijke imports** zodat uw bundel alleen de domeinen bevat die u daadwerkelijk gebruikt:
+
+1. `createIntlayerCMS` — een lichtgewicht **authenticator** die de referenties en het beheerde token bewaart (geen domein-client gebundeld).
+2. `dictionaryEndpoint`, `projectEndpoint`, … — per-domein **endpoint-binders**, elk geïmporteerd vanuit hun eigen subpad.
+
+```ts fileName="cms.ts"
+import { createIntlayerCMS } from "@intlayer/api";
+import { dictionaryEndpoint } from "@intlayer/api/dictionary";
+
+const cms = createIntlayerCMS();
+
+// Lezen
+const { data: dictionaries } = await dictionaryEndpoint(cms).getDictionaries();
+
+// Schrijven — gebruik de CMS als een database
+await dictionaryEndpoint(cms).pushDictionaries([myDictionary]);
+```
+
+> Beveiliging: de CMS-referenties verlenen schrijftoegang tot uw inhoud. Maak de authenticator altijd alleen aan **aan de serverzijde** — stuur `clientId`/`clientSecret` nooit naar de browser.
+
+---
+
+## Zelf hosten
+
+Intlayer v9 biedt eersteklas ondersteuning voor het uitvoeren van uw eigen Intlayer-instantie met één opdracht — geen Intlayer Cloud-account vereist.
+
+```sh
+curl -fsSL https://intlayer.org/install.sh | sh
+```
+
+Het installatieprogramma downloadt een `docker-compose.yml` en een `.env`, genereert automatisch de vereiste geheimen en voert `docker compose up -d` uit. Alles — het dashboard, de API, de database, objectopslag en transactionele e-mail — wordt lokaal in containers uitgevoerd.
+
+---
+
+## Migratienotities vanuit v8
+
+Als u upgradet vanuit v8, let dan op dat v9 geen breaking changes bevat. Maar dit zijn de belangrijkste wijzigingen:
+
+- **Compiler standaard uitgeschakeld**: `compiler.enabled` is nu standaard `false`. Als u afhankelijk bent van build-tijdextractie van uw `.content.ts`-bestanden, stelt u `compiler.enabled: true` in uw `intlayer.config.ts` in.
+- **Vite-plugin**: De compiler en locale-routeringsproxy zijn nu gebundeld in `intlayer()`. Als u eerder `intlayerCompiler()` of `intlayerProxy()` handmatig registreerde, kunt u ze verwijderen — ze worden automatisch gededupliceerd, dus ze bewaren is onschadelijk. Gebruik `routing.enableProxy: false` om de proxy uit te schakelen.
+- **Talen en dialecten**: Als u externe i18n-afhankelijkheden gebruikt, voeg dan de bijbehorende compat-adapterplugins toe in uw configuratie of bundler-installatie om imports automatisch te herschrijven.
+- **Aangepaste selectors**: Bij het aanroepen van `useIntlayer` is de tweede parameter nu gereserveerd voor een optieobject met `{ locale, item, variant }`. Als u eerder een taalstring direct doorgaf, kunt u dat nog steeds doen, maar het gebruik van het optieobject wordt aanbevolen voor geavanceerde selecties.
+- **React Native**: `react-native-intlayer` herexporteert nu de volledige `react-intlayer`-API. Importeer in een React Native-app alles vanuit `react-native-intlayer` en verwijder de directe `react-intlayer`-afhankelijkheid. Bestaande `react-intlayer`-imports blijven werken.
+
+---
+
+## Nuttige links
+
+- [Handleiding voor compat-adapterpakketten](https://github.com/aymericzip/intlayer/blob/main/docs/docs/nl/compat/index.md)
+- [Dynamische woordenboeken - Verzamelingen en varianten](https://github.com/aymericzip/intlayer/blob/main/docs/docs/nl/dynamic_dictionaries/index.md)
+- [Configuratiereferentie](https://github.com/aymericzip/intlayer/blob/main/docs/docs/nl/configuration.md)
+- [Handleiding voor React Native en Expo](https://github.com/aymericzip/intlayer/blob/main/docs/docs/nl/intlayer_with_react_native+expo.md)
+- [CMS SDK - Programmatische toegang met @intlayer/api](https://github.com/aymericzip/intlayer/blob/main/docs/docs/nl/intlayer_CMS.md)
+- [Handleiding voor zelf hosten](https://github.com/aymericzip/intlayer/blob/main/docs/docs/nl/self_hosting.md)

package/docs/pl/bundle_optimization.md

@@ -231,6 +231,9 @@ Next.js wymaga instalacji wtyczki `@intlayer/swc` na etapie optymalizacji (przep
 
 > Ta wtyczka nie jest instalowana domyślnie, ponieważ wtyczki SWC dla Next.js mają wciąż charakter eksperymentalny. Może się to zmienić w przyszłości.
 
+<Tabs>
+ <Tab value="npm">
+
 ```bash packageManager="npm"
 npm install -D @intlayer/swc
 ```
@@ -247,6 +250,19 @@ pnpm add -D @intlayer/swc
 bun add -d @intlayer/swc
 ```
 
+ </Tab>
+ <Tab value="Crates.io (rust)">
+
+```toml fileName="Cargo.toml"
+[dependencies]
+intlayer-swc-plugin = "*"
+```
+
+[View on Crates.io](https://crates.io/crates/intlayer-swc-plugin)
+
+ </Tab>
+</Tabs>
+
 Po jej zainstalowaniu Intlayer automatycznie wykryje i wykorzysta tę wtyczkę.
 
 Do przejścia etapów **purge i minify** (usuwania i skracania pól), należy zainstalować równolegle `@intlayer/babel` i dodać wtyczki Babel. Choć Next.js do transformacji korzysta z SWC, wciąż interpretuje `babel.config.js` w zakresie konfiguracji wtyczek, co sprawia, że wtyczki dla Babel uruchamiane są jeszcze przed etapem SWC.

package/docs/pl/cli/index.md

@@ -125,7 +125,7 @@ Aby dowiedzieć się, jak skonfigurować dostępne języki lub inne parametry, z
 
 ### Uwierzytelnianie
 
-- **[Zaloguj](https://github.com/aymericzip/intlayer/blob/main/docs/docs/pl/login.md)** - Uwierzytelnij się w Intlayer CMS i uzyskaj dane dostępu
+- **[Zaloguj](https://github.com/aymericzip/intlayer/blob/main/docs/docs/pl/cli/login.md)** - Uwierzytelnij się w Intlayer CMS i uzyskaj dane dostępu
 
 ### Polecenia Podstawowe
 

package/docs/pl/cli/scan.md

@@ -150,10 +150,10 @@ await scan("https://example.com", {
 });
 ```
 
-W przypadku dostępu niskopoziomowego funkcja `scanWebsite` z modułu `@intlayer/chokidar/scan` zwraca ustrukturyzowany obiekt `ScanResult`:
+W przypadku dostępu niskopoziomowego funkcja `scanWebsite` z modułu `@intlayer/engine/scan` zwraca ustrukturyzowany obiekt `ScanResult`:
 
 ```ts
-import { scanWebsite } from "@intlayer/chokidar/scan";
+import { scanWebsite } from "@intlayer/engine/scan";
 
 const result = await scanWebsite("https://example.com", { deep: false });
 console.log(result.score, result.totalPageSize, result.events);

package/docs/pl/configuration.md

@@ -1,6 +1,6 @@
 ---
 createdAt: 2024-08-13
-updatedAt: 2026-06-17
+updatedAt: 2026-07-11
 title: Konfiguracja
 description: Dowiedz się, jak skonfigurować Intlayer dla swojej aplikacji. Zrozum różne ustawienia i opcje dostępne do dostosowania Intlayer do Twoich potrzeb.
 keywords:
@@ -14,6 +14,12 @@ slugs:
   - concept
   - configuration
 history:
+  - version: 9.0.0
+    date: 2026-07-11
+    changes: "Dodano konfigurację `analytics`"
+  - version: 9.0.0
+    date: 2026-06-24
+    changes: "Add `enableProxy` option to the routing configuration"
   - version: 8.10.0
     date: 2026-06-17
     changes: "Dodano opcję `format` do konfiguracji słownika"
@@ -352,6 +358,30 @@ const config: IntlayerConfig = {
     liveSync: true,
   },
 
+  /**
+   * Konfiguracja analityki (analytics).
+   */
+  analytics: {
+    /**
+     * Czy zbieranie danych analitycznych jest włączone (odsłony strony, ekspozycje treści, zdarzenia A/B).
+     * Wymaga ustawienia `editor.clientId` na potrzeby atrybucji.
+     * Domyślnie: false
+     */
+    enabled: true,
+
+    /**
+     * Milisekundy między automatycznymi zbiorczymi wysyłkami do backendu.
+     * Domyślnie: 20000
+     */
+    flushInterval: 20000,
+
+    /**
+     * Ułamek sesji do rejestrowania, od 0 (brak) do 1 (wszystkie).
+     * Domyślnie: 1
+     */
+    sampleRate: 1,
+  },
+
   /**
    * Ustawienia tłumaczenia i generowania opartego na AI.
    */
@@ -665,6 +695,20 @@ Definiuje ustawienia edytora wizualnego, w tym port serwera i status aktywacji.
 
 ---
 
+### Konfiguracja analityki (Analytics)
+
+Definiuje ustawienia związane z analityką Intlayer: zbieranie informacji o tym, jakie treści są faktycznie wyświetlane użytkownikom (odsłony strony, ekspozycje treści) oraz obsługę testów A/B treści.
+
+Analityka jest ściśle opt-in: nic nie jest zbierane, dopóki `analytics.enabled` nie zostanie jawnie ustawione na `true` **i** nie skonfigurowano klucza projektu (`editor.clientId`) na potrzeby atrybucji. Gdy jest wyłączona (domyślnie), cała integracja analityczna jest usuwana z pakietu aplikacji (dead-code elimination).
+
+| Pole            | Opis                                                                                      | Typ       | Domyślnie | Przykład | Uwaga                                                                                                                                             |
+| --------------- | ----------------------------------------------------------------------------------------- | --------- | --------- | -------- | ------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `enabled`       | Włącza zbieranie danych analitycznych (odsłony strony, ekspozycje treści, zdarzenia A/B). | `boolean` | `false`   | `true`   | Wymaga ustawienia `editor.clientId` na potrzeby atrybucji; w przeciwnym razie analityka pozostaje wyłączona, nawet jeśli `enabled` wynosi `true`. |
+| `flushInterval` | Milisekundy między automatycznymi zbiorczymi wysyłkami do backendu.                       | `number`  | `20000`   | `10000`  |                                                                                                                                                   |
+| `sampleRate`    | Ułamek sesji do rejestrowania, od `0` (brak) do `1` (wszystkie).                          | `number`  | `1`       | `0.5`    | Próbkowanie jest deterministyczne dla sesji, więc zarejestrowana sesja raportuje wszystkie swoje zdarzenia (bez częściowych lejków).              |
+
+---
+
 ### Konfiguracja routingu (Routing)
 
 Ustawienia kontrolujące zachowanie routingu, w tym strukturę URL, przechowywanie locale i obsługę middleware.

package/docs/pl/how_works_intlayer.md

@@ -220,9 +220,9 @@ Pakiet `@intlayer/mcp` dostarcza serwer MCP (Model Context Protocol), który ofe
 
 Pakiety `@intlayer/dictionaries-entry`, `@intlayer/unmerged-dictionaries-entry` oraz `@intlayer/dynamic-dictionaries-entry` zwracają ścieżkę wejściową słowników Intlayer. Ponieważ przeszukiwanie systemu plików z poziomu przeglądarki jest niemożliwe, używanie bundlerów takich jak Webpack czy Rollup do pobrania ścieżki wejściowej słowników również nie jest możliwe. Te pakiety zostały zaprojektowane do aliasowania, co pozwala na optymalizację bundlowania w różnych bundlerach, takich jak Vite, Webpack i Turbopack.
 
-### @intlayer/chokidar
+### @intlayer/engine
 
-Pakiet `@intlayer/chokidar` służy do monitorowania plików z zawartością i regenerowania zmodyfikowanego słownika przy każdej zmianie.
+Pakiet `@intlayer/engine` służy do monitorowania plików z zawartością i regenerowania zmodyfikowanego słownika przy każdej zmianie.
 
 ### @intlayer/editor
 

package/docs/pl/intlayer_CMS.md

@@ -1,6 +1,6 @@
 ---
 createdAt: 2025-08-23
-updatedAt: 2025-08-23
+updatedAt: 2026-07-08
 title: Intlayer CMS | Zewnętrzne zarządzanie treścią w Intlayer CMS
 description: Zewnętrzne zarządzanie treścią w Intlayer CMS, aby delegować zarządzanie treścią do Twojego zespołu.
 keywords:
@@ -18,6 +18,12 @@ slugs:
   - cms
 youtubeVideo: https://www.youtube.com/watch?v=UDDTnirwi_4
 history:
+  - version: 9.0.0
+    date: 2026-07-08
+    changes: "Przeniesiono sekcję „Synchronizacja na żywo” na osobną stronę (live-sync.md), pozostawiając tu krótkie wprowadzenie i link"
+  - version: 9.0.0
+    date: 2026-06-30
+    changes: "Dodano sekcję samodzielnego hostowania"
   - version: 6.0.1
     date: 2025-09-22
     changes: "Dodano dokumentację synchronizacji na żywo"
@@ -245,144 +251,19 @@ Następnie będziesz mógł zobaczyć i zarządzać swoim słownikiem w [Intlaye
 
 Synchronizacja na żywo pozwala Twojej aplikacji odzwierciedlać zmiany treści CMS w czasie rzeczywistym. Nie jest wymagane ponowne budowanie ani wdrażanie. Po włączeniu aktualizacje są przesyłane do serwera synchronizacji na żywo, który odświeża słowniki odczytywane przez Twoją aplikację.
 
-Włącz synchronizację na żywo, aktualizując konfigurację Intlayer:
+Pełny przewodnik po konfiguracji (włączanie, uruchamianie serwera Live Sync, lokalny przepływ pracy programistycznej i ograniczenia) znajdziesz w [dokumentacji Live Sync](https://github.com/aymericzip/intlayer/blob/main/docs/docs/pl/live-sync.md).
 
-```typescript fileName="intlayer.config.ts" codeFormat={["typescript", "esm", "commonjs"]}
-import type { IntlayerConfig } from "intlayer";
-
-const config: IntlayerConfig = {
-  // ... inne ustawienia konfiguracyjne
-  editor: {
-    /**
-     * Włącza hot reloading konfiguracji lokalizacji, gdy wykryte zostaną zmiany.
-     * Na przykład, gdy słownik zostanie dodany lub zaktualizowany, aplikacja aktualizuje
-     * wyświetlaną na stronie zawartość.
-     *
-     * Ponieważ hot reloading wymaga ciągłego połączenia z serwerem,
-     * jest dostępny tylko dla klientów planu `enterprise`.
-     *
-     * Domyślnie: false
-     */
-    liveSync: true,
-  },
-  dictionary: {
-    /**
-     * Kontroluje sposób importowania słowników:
-     *
-     * - "live": Słowniki są pobierane dynamicznie za pomocą API Live Sync.
-     *   Zastępuje useIntlayer funkcją useDictionaryDynamic.
-     *
-     * Uwaga: Tryb live korzysta z API Live Sync do pobierania słowników. Jeśli wywołanie API
-     * zakończy się niepowodzeniem, słowniki są importowane dynamicznie.
-     * Uwaga: Tryb live jest używany tylko dla słowników zdalnych i oznaczonych flagą "live".
-     * Pozostałe używają trybu dynamicznego dla wydajności.
-     */
-    importMode: "fetch",
-  },
-};
-
-export default config;
-```
-
-Uruchom serwer Live Sync, aby otoczyć swoją aplikację:
-
-Przykład użycia samodzielnego serwera:
-
-```json5 fileName="package.json"
-{
-  "scripts": {
-    // ... inne skrypty
-    "live:start": "npx intlayer live",
-  },
-}
-```
-
-Możesz również używać swojego serwera aplikacji równolegle, korzystając z argumentu `--process`.
-
-Przykład użycia Next.js:
-
-```json5 fileName="package.json"
-{
-  "scripts": {
-    // ... inne skrypty
-    "build": "next build",
-    "dev": "next dev",
-    "start": "npx intlayer live --with 'next start'",
-  },
-}
-```
+## Samodzielne hostowanie (Self-Hosting)
 
-Przykład użycia Vite:
+Intlayer może działać w całości na Twojej własnej infrastrukturze. Jedna komenda uruchamia pełny stos (panel, API, bazę danych, magazyn obiektów i pocztę e-mail) za pomocą Docker Compose:
 
-```json5 fileName="package.json"
-{
-  "scripts": {
-    // ... inne skrypty
-    "build": "vite build",
-    "dev": "vite dev",
-    "start": "npx intlayer live --with 'vite start'",
-  },
-}
+```sh
+curl -fsSL https://intlayer.org/install.sh | sh
 ```
 
-Serwer Live Sync otacza Twoją aplikację i automatycznie stosuje zaktualizowaną zawartość w momencie jej pojawienia się.
-
-Aby otrzymywać powiadomienia o zmianach z CMS, serwer Live Sync utrzymuje połączenie SSE z backendem. Gdy zawartość w CMS ulega zmianie, backend przekazuje aktualizację do serwera Live Sync, który zapisuje nowe słowniki. Twoja aplikacja odzwierciedli aktualizację przy następnej nawigacji lub przeładowaniu przeglądarki, nie jest wymagane ponowne budowanie.
-
-Schemat przepływu (CMS/Backend -> Serwer Live Sync -> Serwer aplikacji -> Frontend):
-
-![Schemat przepływu Live Sync CMS/Backend/Serwer Live Sync/Serwer aplikacji/Frontend](https://github.com/aymericzip/intlayer/blob/main/docs/assets/live_sync_flow_scema.svg)
-
-Jak to działa:
-
-![Schemat logiki Live Sync](https://github.com/aymericzip/intlayer/blob/main/docs/assets/live_sync_logic_schema.svg)
-
-### Przebieg pracy podczas developmentu (lokalnie)
+Pełny przewodnik konfiguracji, dokumentację zmiennych środowiskowych, instrukcje aktualizacji oraz procedury tworzenia kopii zapasowych i przywracania znajdziesz w [Przewodniku po samodzielnym hostowaniu](https://github.com/aymericzip/intlayer/blob/main/docs/docs/pl/self_hosting.md).
 
-- Podczas developmentu wszystkie zdalne słowniki są pobierane przy starcie aplikacji, dzięki czemu możesz szybko testować aktualizacje.
-- Aby przetestować Live Sync lokalnie z Next.js, opakuj swój serwer deweloperski:
-
-```json5 fileName="package.json"
-{
-  "scripts": {
-    // ... inne skrypty
-    "dev": "npx intlayer live --with 'next dev'",
-    // "dev": "npx intlayer live --with 'vite dev'", // Dla Vite
-  },
-}
-```
-
-Włącz optymalizację, aby Intlayer stosował transformacje importu Live podczas developmentu:
-
-```typescript fileName="intlayer.config.ts" codeFormat={["typescript", "esm", "commonjs"]}
-import type { IntlayerConfig } from "intlayer";
-
-const config: IntlayerConfig = {
-  editor: {
-    applicationURL: "http://localhost:5173",
-    liveSyncURL: "http://localhost:4000",
-    liveSync: true,
-  },
-  dictionary: {
-    importMode: "fetch",
-  },
-  build: {
-    optimize: true,
-  },
-};
-
-export default config;
-```
-
-To ustawienie owija Twój serwer deweloperski serwerem Live Sync, pobiera zdalne słowniki podczas uruchamiania i przesyła aktualizacje z CMS za pomocą SSE. Odśwież stronę, aby zobaczyć zmiany.
-
-Uwagi i ograniczenia:
-
-- Dodaj pochodzenie live sync do polityki bezpieczeństwa swojej strony (CSP). Upewnij się, że adres URL live sync jest dozwolony w `connect-src` (oraz `frame-ancestors`, jeśli ma to zastosowanie).
-- Live Sync nie działa ze statycznym outputem. W Next.js strona musi być dynamiczna, aby otrzymywać aktualizacje w czasie wykonywania (np. użyj `generateStaticParams`, `generateMetadata`, `getServerSideProps` lub `getStaticProps` odpowiednio, aby uniknąć pełnych ograniczeń statycznych).
-- W CMS każdy słownik ma flagę `live`. Tylko słowniki z `live=true` są pobierane przez API live sync; pozostałe są importowane dynamicznie i pozostają niezmienione w czasie wykonywania.
-- Flaga `live` jest oceniana dla każdego słownika podczas budowania (build time). Jeśli zdalna zawartość nie była oznaczona jako `live=true` podczas budowania (build time), musisz przebudować projekt, aby włączyć Live Sync dla tego słownika.
-- Serwer live sync musi mieć możliwość zapisu do `.intlayer`. W kontenerach upewnij się, że masz dostęp do zapisu do `/.intlayer`.
+---
 
 ## Debug