@intlayer/docs 9.0.0-canary.6 → 9.0.0-canary.8

package/docs/pl/packages/vite-intlayer/intlayerCompiler.md

@@ -0,0 +1,120 @@
+---
+createdAt: 2026-06-25
+updatedAt: 2026-06-25
+title: Dokumentacja wtyczki Vite intlayerCompiler | vite-intlayer
+description: Wtyczka Vite, która ekstrahuje wbudowane deklaracje zawartości Intlayer z plików komponentów i zapisuje je do plików JSON słownika w czasie budowania/transformacji.
+keywords:
+  - intlayerCompiler
+  - vite
+  - wtyczka
+  - kompilator
+  - zawartość
+  - słownik
+  - umiędzynarodowienie
+  - i18n
+slugs:
+  - doc
+  - packages
+  - vite-intlayer
+  - intlayerCompiler
+history:
+  - version: 9.0.0
+    date: 2026-06-25
+    changes: "Zintegrowano z intlayer(); inicjalizacja dokumentacji"
+author: aymericzip
+---
+
+# intlayerCompiler
+
+`intlayerCompiler` to wtyczka Vite, która skanuje pliki źródłowe komponentów w poszukiwaniu **wbudowanych deklaracji zawartości Intlayer** (inline declarations) — zawartości zdefiniowanej bezpośrednio w komponencie, a nie w osobnym pliku `.content.ts` — i zapisuje je do plików JSON słownika podczas fazy transformacji.
+
+> **Od Intlayer v9** `intlayerCompiler` jest automatycznie dołączany do głównej wtyczki [`intlayer()`](https://github.com/aymericzip/intlayer/blob/main/docs/docs/pl/packages/vite-intlayer/intlayer.md), gdy zarówno `compiler.enabled` ma wartość `true`, jak i `compiler.output` jest ustawiony w konfiguracji Intlayer. Musisz go zarejestrować osobno tylko wtedy, gdy chcesz mieć pełną kontrolę nad konfiguracją specyficzną dla kompilatora.
+
+## Użycie
+
+### Jako część `intlayer()` (zalecane, v9+)
+
+Włącz kompilator w konfiguracji Intlayer:
+
+```ts
+// intlayer.config.ts
+import { defineConfig } from "intlayer";
+
+export default defineConfig({
+  compiler: {
+    enabled: true,
+    output: "./src/dictionaries", // gdzie zapisywane są wyekstrahowane słowniki
+  },
+});
+```
+
+Następnie użyj standardowej wtyczki bez dodatkowej rejestracji:
+
+```ts
+// vite.config.ts
+import { defineConfig } from "vite";
+import { intlayer } from "vite-intlayer";
+
+export default defineConfig({
+  plugins: [intlayer()],
+});
+```
+
+### Samodzielnie (w razie potrzeby)
+
+```ts
+// vite.config.ts
+import { defineConfig } from "vite";
+import { intlayerCompiler } from "vite-intlayer";
+
+export default defineConfig({
+  plugins: [intlayerCompiler()],
+});
+```
+
+## Opcje
+
+```ts
+import type { IntlayerCompilerOptions } from "vite-intlayer";
+```
+
+| Opcja            | Typ                       | Opis                                                                                                |
+| ---------------- | ------------------------- | --------------------------------------------------------------------------------------------------- |
+| `configOptions`  | `GetConfigurationOptions` | Nadpisania konfiguracji Intlayer przekazywane do `getConfiguration()`.                              |
+| `compilerConfig` | `Partial<CompilerConfig>` | Nadpisania sekcji konfiguracji specyficznej dla kompilatora (np. `enabled`, `output`, `filesList`). |
+
+### Przykład
+
+```ts
+intlayerCompiler({
+  configOptions: { configFile: "./config/intlayer.config.ts" },
+  compilerConfig: { enabled: true, output: "./src/dictionaries" },
+});
+```
+
+## Jak to działa
+
+### Faza transformacji
+
+Dla każdego pliku źródłowego, który pasuje do `compiler.filesList`, wtyczka kompilatora:
+
+1. Przekazuje zawartość pliku do `extractContent` z pakietu `@intlayer/babel`.
+2. Wywołuje `onExtract` dla każdej znalezionej deklaracji, co zapisuje wynikowy słownik JSON do ścieżki `compiler.output`.
+3. Zwraca przetransformowany kod źródłowy z wbudowanymi deklaracjami zastąpionymi standardowymi wywołaniami `useIntlayer('key')` / `getIntlayer('key')`.
+
+Obsługiwane typy plików: `.ts`, `.tsx`, `.js`, `.jsx`, `.vue`, `.svelte`, `.astro`.
+
+### HMR (Hot Module Replacement)
+
+Gdy plik komponentu zostanie zapisany w trybie deweloperskim, kompilator:
+
+1. Wykrywa zmianę pliku za pomocą hooka `handleHotUpdate` w Vite.
+2. Ponownie ekstrahuje zawartość ze zaktualizowanego pliku.
+3. Zapisuje zaktualizowany słownik JSON.
+4. Wyzwala pełne przeładowanie strony (`server.ws.send({ type: 'full-reload' })`).
+
+Debounce o wartości 500 ms zapobiega zapętleniu ponownej ekstrakcji spowodowanemu przez sam zapis słownika (który również wyzwala zdarzenie zmiany pliku).
+
+### Deduplikacja
+
+`intlayerCompiler` używa tego samego mechanizmu deduplikacji `createPrimaryInstanceGuard` co inne wbudowane wtyczki. Gdy obecne są zarówno `intlayer()` (który zawiera kompilator), jak i ręczne wywołanie `intlayerCompiler()`, uruchamiana jest tylko pierwsza zarejestrowana instancja — żadne słowniki nie są zapisywane dwukrotnie.

package/docs/pl/packages/vite-intlayer/intlayerMinify.md

@@ -0,0 +1,92 @@
+---
+createdAt: 2026-06-25
+updatedAt: 2026-06-25
+title: Dokumentacja wtyczki Vite intlayerMinify | vite-intlayer
+description: Wtyczka Vite, która minifikuje skompilowane pliki JSON słownika Intlayer i opcjonalnie maskuje nazwy pól zawartości w celu zmniejszenia rozmiaru pakietu.
+keywords:
+  - intlayerMinify
+  - vite
+  - wtyczka
+  - minifikacja
+  - rozmiar pakietu
+  - słownik
+  - umiędzynarodowienie
+  - i18n
+slugs:
+  - doc
+  - packages
+  - vite-intlayer
+  - intlayerMinify
+history:
+  - version: 9.0.0
+    date: 2026-06-25
+    changes: "Inicjalizacja dokumentacji"
+author: aymericzip
+---
+
+# intlayerMinify
+
+`intlayerMinify` to wtyczka Vite, która minifikuje skompilowane pliki JSON słowników podczas kompilacji produkcyjnej. Usuwa wszystkie niepotrzebne białe znaki i, w połączeniu z `intlayerPrune`, opcjonalnie zmienia nazwy pól zawartości na krótkie alfabetyczne aliasy (`a`, `b`, `c`, …), aby jeszcze bardziej zmniejszyć rozmiar pakietu (bundle'a).
+
+> Ta wtyczka jest automatycznie dołączana i konfigurowana, gdy używasz wtyczki [`intlayer()`](https://github.com/aymericzip/intlayer/blob/main/docs/docs/pl/packages/vite-intlayer/intlayer.md). Musisz ją zarejestrować ręcznie tylko wtedy, gdy samodzielnie tworzysz stos wtyczek.
+
+## Użycie
+
+```ts
+// vite.config.ts
+import { defineConfig } from "vite";
+import { intlayerMinify, intlayerPrune } from "vite-intlayer";
+import { createPruneContext } from "@intlayer/babel";
+
+const pruneContext = createPruneContext();
+
+export default defineConfig({
+  plugins: [
+    intlayerPrune(intlayerConfig, pruneContext),
+    intlayerMinify(intlayerConfig, pruneContext),
+  ],
+});
+```
+
+## Warunki aktywacji
+
+`intlayerMinify` jest aktywna **tylko** wtedy, gdy spełnione są wszystkie trzy poniższe warunki:
+
+1. Polecenie Vite to `build` (nie `serve` / dev).
+2. Opcja `build.optimize` ma wartość `true` (lub `undefined`, co dla kompilacji domyślnie oznacza `true`).
+3. Opcja `build.minify` w konfiguracji Intlayer ma wartość `true`.
+
+Wtyczka jest automatycznie **wyłączana**, gdy `editor.enabled` ma wartość `true`, ponieważ edytor wymaga pełnej, czytelnej dla człowieka zawartości słownika.
+
+## Co podlega minifikacji
+
+Wtyczka kieruje swoje działanie na dwie lokalizacje słowników (rozpoznane na podstawie `intlayer.system`):
+
+- `dictionariesDir` — statyczne słowniki dla wszystkich języków (np. `.intlayer/dictionaries/*.json`)
+- `dynamicDictionariesDir` — dynamiczne słowniki dla poszczególnych języków
+
+> Słowniki w trybie pobierania (`fetchDictionariesDir`) **nigdy** nie są minifikowane, ponieważ są serwowane z zewnętrznego API w czasie rzeczywistym przy użyciu ich oryginalnych nazw pól. Zmiana nazw pól stworzyłaby niezgodność między odpowiedzią serwera a dostępem do właściwości po stronie klienta.
+
+## Maskowanie nazw pól (minifikacja właściwości)
+
+Gdy wtyczka `intlayerPrune` przeanalizuje bazę kodu i uzupełni `pruneContext.dictionaryKeyToFieldRenameMap`, wtyczka `intlayerMinify` również zmienia nazwy pól zawartości na krótkie aliasy. Na przykład:
+
+```json
+// przed
+{ "key": "myDict", "content": { "title": "Hello", "description": "World" } }
+
+// po (z maskowaniem)
+{ "key": "myDict", "content": { "a": "Hello", "b": "World" } }
+```
+
+Odpowiednie odwołania do właściwości w plikach źródłowych są zmieniane przez przebieg Babel wewnątrz `intlayerOptimize`, więc zachowanie w czasie rzeczywistym pozostaje niezmienione.
+
+Wewnętrzne pola Intlayer (`nodeType`, `translation` itp.) nigdy nie zmieniają nazw.
+
+## Słowniki z przypadkami brzegowymi
+
+Słowniki oznaczone w `pruneContext.dictionariesWithEdgeCases` (anomalie strukturalne wykryte podczas fazy oczyszczania/prune) są całkowicie pomijane — nie są minifikowane ani maskowane — aby uniknąć dostarczenia uszkodzonych danych.
+
+## Grupy kwalifikowane (kolekcje / warianty / metarekordy)
+
+W przypadku słowników z tablicą `qualifierTypes` (kolekcje, warianty i metarekordy), wtyczka zachowuje tablicę `qualifierTypes` oraz mapę poboczną `meta` w oryginalnej formie. Maskowane są tylko nazwy pól wewnątrz wpisów `content`. Złożone klucze (używane do dopasowywania selektorów w czasie rzeczywistym) nigdy nie są modyfikowane.

package/docs/pl/packages/vite-intlayer/intlayerProxy.md

@@ -0,0 +1,172 @@
+---
+createdAt: 2026-06-25
+updatedAt: 2026-06-25
+title: Dokumentacja wtyczki Vite intlayerProxy | vite-intlayer
+description: Oprogramowanie pośredniczące (middleware) do routingu języków dla serwerów deweloperskich i podglądu Vite oraz produkcyjnego SSR. Obsługuje wykrywanie języka, przekierowania URL i wewnętrzne przepisywanie ścieżek.
+keywords:
+  - intlayerProxy
+  - vite
+  - wtyczka
+  - middleware
+  - język
+  - routing
+  - umiędzynarodowienie
+  - i18n
+  - SSR
+slugs:
+  - doc
+  - packages
+  - vite-intlayer
+  - intlayerProxy
+history:
+  - version: 9.0.0
+    date: 2026-06-25
+    changes: "Scalono configOptions w jeden obiekt opcji; proxy jest wbudowane w intlayer()"
+author: aymericzip
+---
+
+# intlayerProxy
+
+`intlayerProxy` to wtyczka Vite, która rejestruje oprogramowanie pośredniczące (middleware) do routingu języków dla **każdego środowiska**: serwera deweloperskiego, serwera podglądu i produkcyjnego SSR (Nitro / TanStack Start).
+
+> **Od Intlayer v9** `intlayerProxy` jest automatycznie dołączany do głównej wtyczki [`intlayer()`](https://github.com/aymericzip/intlayer/blob/main/docs/docs/pl/packages/vite-intlayer/intlayer.md) i domyślnie włączony poprzez `routing.enableProxy: true`. Musisz go zarejestrować osobno tylko wtedy, gdy potrzebujesz kontroli na niższym poziomie lub używasz go poza standardową konfiguracją `intlayer()`.
+
+## Użycie
+
+### Jako część `intlayer()` (zalecane, v9+)
+
+Przekaż opcje `proxy` do głównej wtyczki zamiast rejestrować `intlayerProxy` osobno:
+
+```ts
+// vite.config.ts
+import { defineConfig } from "vite";
+import { intlayer } from "vite-intlayer";
+
+export default defineConfig({
+  plugins: [
+    intlayer({
+      proxy: {
+        ignore: (req) => req.url?.startsWith("/api"),
+      },
+    }),
+  ],
+});
+```
+
+### Samodzielnie (w razie potrzeby)
+
+```ts
+// vite.config.ts
+import { defineConfig } from "vite";
+import { intlayer } from "vite-intlayer";
+
+export default defineConfig({
+  plugins: [intlayer()],
+});
+```
+
+## Opcje
+
+```ts
+import type { IntlayerProxyPluginOptions } from "vite-intlayer";
+```
+
+Wszystkie opcje są opcjonalne i przekazywane jako pojedynczy obiekt:
+
+| Opcja           | Typ                                 | Opis                                                                                                                                                                     |
+| --------------- | ----------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| `ignore`        | `(req: IncomingMessage) => boolean` | Predykat wykluczający żądania z routingu języków. Zwróć `true`, aby pominąć żądanie (np. ścieżki API, testy kondycji/health checki).                                     |
+| `configOptions` | `GetConfigurationOptions`           | Nadpisania konfiguracji Intlayer przekazywane do `getConfiguration()`. Użyj, gdy potrzebujesz, aby proxy czytało określony plik konfiguracyjny lub nadpisywało wartości. |
+
+### Przykład
+
+```ts
+intlayerProxy({
+  ignore: (req) => req.url?.startsWith("/api"),
+  configOptions: { configFile: "./config/intlayer.config.ts" },
+});
+```
+
+## createIntlayerProxyHandler
+
+`createIntlayerProxyHandler` tworzy samodzielne, niezależne od frameworka oprogramowanie pośredniczące Node.js `(req, res, next)`, które zawiera całą logikę routingu języków. Jest przydatne w środowiskach, w których API wtyczek Vite jest niedostępne (np. czysty serwer Node.js lub niestandardowy moduł Nitro).
+
+```ts
+import { createIntlayerProxyHandler } from "vite-intlayer";
+
+const handler = createIntlayerProxyHandler({
+  ignore: (req) => req.url?.startsWith("/api"),
+  configOptions: { configFile: "./config/intlayer.config.ts" },
+});
+
+// Express / Connect
+app.use(handler);
+```
+
+### Produkcyjny SSR (TanStack Start / Nitro przez h3)
+
+```ts
+// server/middleware/intlayerProxy.ts
+import { fromNodeMiddleware } from "h3";
+import { createIntlayerProxyHandler } from "vite-intlayer";
+
+export default fromNodeMiddleware(
+  createIntlayerProxyHandler({
+    ignore: (req) => req.url?.startsWith("/api"),
+  })
+);
+```
+
+## Zachowanie routingu
+
+Oprogramowanie pośredniczące odzwierciedla logikę routingu z middleware `next-intlayer` i obsługuje wszystkie tryby routingu Intlayer.
+
+### Tryby routingu
+
+| Tryb            | Widoczność URL w przeglądarce | Zachowanie                                                                                                                                                          |
+| --------------- | ----------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `prefix`        | `/pl/about`                   | Domyślny. Prefiks języka w adresie URL. Domyślny język przekierowuje do adresu URL bez prefiksu, chyba że włączono `prefix-all`.                                    |
+| `prefix-all`    | `/en/about`, `/pl/about`      | Wszystkie języki — w tym domyślny — są zawsze poprzedzone prefiksem.                                                                                                |
+| `no-prefix`     | `/about`                      | Brak języka w adresie URL. Język jest przechowywany wyłącznie w plikach cookie; przepisywanie URL odbywa się wewnętrznie.                                           |
+| `search-params` | `/about?locale=pl`            | Język przekazywany jako parametr zapytania (query parameter). Przekierowuje w celu dodania/aktualizacji parametru `locale`, jeśli go brakuje lub jest przestarzały. |
+
+### Priorytet wykrywania
+
+1. Prefiks ścieżki URL (np. `/pl/about` → `pl`).
+2. Wartość pliku cookie / localStorage (`intlayer-locale`).
+3. Nagłówek `Accept-Language`.
+4. `defaultLocale` z konfiguracji.
+
+### Automatyczne pomijanie (bypass)
+
+Oprogramowanie pośredniczące zawsze przepuszcza te żądania bezpośrednio, bez obsługi języka:
+
+- Żądania pasujące do predykatu `ignore`.
+- `/node_modules/**`
+- `/@**` – wewnętrzne zasoby Vite (`@vite/`, `@fs/`, `@id/` itp.).
+- `/_**` – wewnętrzne zasoby serwera (`__vite_ping`, `__manifest` itp.).
+- Żądania, których ścieżka kończy się rozszerzeniem pliku (zasoby statyczne). Jeśli w ścieżce zasobu statycznego obecny jest prefiks języka (np. `/pl/logo.png`), zostaje on usunięty, aby plik mógł być serwowany poprawnie.
+
+### Routing domenowy
+
+Gdy w konfiguracji Intlayer skonfigurowano `routing.domains`, oprogramowanie pośredniczące obsługuje routing językowy między różnymi domenami:
+
+- Żądanie dla `/zh/about` w domenie `intlayer.org` jest przekierowywane na `https://intlayer.zh/about`, gdy `domains.zh = "intlayer.zh"`.
+- Żądanie do `intlayer.zh/about` jest wewnętrznie przepisywane na `/zh/about`, aby parametr trasy `[locale]` został uzupełniony.
+
+### Ochrona przed pętlą przekierowań
+
+Oprogramowanie pośredniczące śledzi liczbę przekierowań dla pary `originalUrl → newUrl` w ruchomym oknie 2 sekund. Więcej niż 10 przekierowań w tym oknie zwraca odpowiedź `500` z opisowym błędem zamiast zapętlania się w nieskończoność.
+
+## Nitro / produkcyjny SSR (automatyczna iniekcja, v9+)
+
+Gdy `intlayerProxy` jest używany jako wtyczka Vite, niesie ze sobą właściwość `.nitro`. Wtyczka budująca `nitro/vite` odczytuje tę właściwość i wstrzykuje ją do `nitroConfig.modules`, dzięki czemu `intlayerNitroHandler` rejestruje się jako serwerowe oprogramowanie pośredniczące Nitro automatycznie — dla produkcyjnego SSR nie jest wymagana żadna ręczna konfiguracja.
+
+Handler Nitro korzysta z modelu zdarzeń Web Fetch API h3 v2 (nie `fromNodeMiddleware`), więc jest kompatybilny ze wszystkimi szablonami (presets) Nitro: Node, Bun, Deno, środowiskami edge.
+
+## Zdeprecjonowane aliasy
+
+| Zdeprecjonowany eksport    | Zamiennik       |
+| -------------------------- | --------------- |
+| `intlayerMiddleware`       | `intlayerProxy` |
+| `intLayerMiddlewarePlugin` | `intlayerProxy` |

package/docs/pl/plugins/sync-json.md

@@ -105,7 +105,6 @@ const config: IntlayerConfig = {
      * Will load, and write the output and translations back to the JSON files in the locales directory
      */
     syncJSON({
-      format: "i18next",
       source: ({ key, locale }) => `./locales/${locale}/${key}.json`,
       priority: 0,
       format: "i18next",

package/docs/pl/releases/v9.md

@@ -1,15 +1,14 @@
 ---
 createdAt: 2026-06-14
-updatedAt: 2026-06-14
+updatedAt: 2026-06-26
 title: Nowy Intlayer v9 - Co nowego?
-description: Odkryj nowości w Intlayer v9. Przedstawiamy pakiety kompatybilności typu drop-in dla popularnych bibliotek i18n oraz wsparcie dla Kolekcji (Collections), Wariantów (Variants) i Dynamicznych Rekordów (Dynamic Records).
+description: Odkryj nowości w Intlayer v9. Przedstawiamy pakiety kompatybilności typu drop-in dla popularnych bibliotek i18n oraz wsparcie dla Kolekcji (Collections) i Wariantów (Variants).
 keywords:
   - Intlayer
   - Kompatybilność
   - Migracja
   - Kolekcje
   - Warianty
-  - Dynamiczne Rekordy
   - i18next
   - next-intl
   - vue-i18n
@@ -22,7 +21,7 @@ author: aymericzip
 
 # Nowy Intlayer v9 - Co nowego?
 
-Witaj w Intlayer v9! To główne wydanie (major release) stanowi ogromny krok milowy w upraszczaniu ścieżki migracji do Intlayer dzięki **pakietom kompatybilności (Compat Adapter Packages)** dla najpopularniejszych bibliotek i18n (takich jak `react-i18next`, `next-intl`, `vue-i18n` itp.) oraz wprowadza wsparcie dla bogatych struktur treści: **Kolekcji (Collections)**, **Wariantów (Variants)** i **Dynamicznych Rekordów (Dynamic Records)**.
+Witaj w Intlayer v9! To główne wydanie (major release) stanowi ogromny krok milowy w upraszczaniu ścieżki migracji do Intlayer dzięki **pakietom kompatybilności (Compat Adapter Packages)** dla najpopularniejszych bibliotek i18n (takich jak `react-i18next`, `next-intl`, `vue-i18n` itp.) oraz wprowadza wsparcie dla bogatych struktur treści: **Kolekcji (Collections)** i **Wariantów (Variants)**.
 
 ## Spis treści
 
@@ -41,8 +40,10 @@ Zastępując importy, zyskujesz wszystkie zalety Intlayer (w tym bezpieczeństwo
 - `@intlayer/i18next`
 - `@intlayer/react-i18next`
 - `@intlayer/next-intl`
+- `@intlayer/react-intl`
 - `@intlayer/next-i18next`
 - `@intlayer/vue-i18n`
+- `@intlayer/lingui`
 
 Na przykład, po prostu zmień:
 
@@ -100,7 +101,7 @@ Wszystkie adaptery kompatybilności kierują teraz proces rozwiązywania tłumac
 
 ---
 
-## Specyfikacja funkcji: Kolekcje, Warianty i Dynamiczne Rekordy
+## Specyfikacja funkcji: Kolekcje i Warianty
 
 Intlayer v9 wykracza poza statyczne obiekty klucz-wartość, umożliwiając słownikom deklarowanie dynamicznych struktur układu, które są w pełni typowane od początku do końca (end-to-end).
 
@@ -144,6 +145,8 @@ const faq = useIntlayer("faq", { item: 1 }); // -> { question: string, answer: s
 
 Dostarczaj testy A/B, nagłówki sezonowe, flagi funkcji (feature flags) lub niestandardowe strony docelowe (landing pages):
 
+#### Warianty tekstowe (np. testy A/B)
+
 ```ts fileName="hero.content.ts"
 import { t, type Dictionary } from "intlayer";
 
@@ -167,16 +170,14 @@ export default {
 const banner = useIntlayer("hero-banner", { variant: "black_friday" });
 ```
 
-### 3. Dynamiczne Rekordy (Dynamic Records)
-
-Definiuj słowniki, których wpisy są ładowane dynamicznie w czasie działania aplikacji (runtime) za pomocą identyfikatorów zapytań (query IDs):
+#### Warianty obiektowe (np. Dynamic Records)
 
 ```ts fileName="product.content.ts"
 import { t, type Dictionary } from "intlayer";
 
 export default {
   key: "product-copy",
-  meta: {
+  variant: {
     id: "prod_123",
     category: "books",
   },
@@ -229,7 +230,7 @@ export default defineConfig({
 });
 ```
 
-- **Compiler**: Aktywuje się automatycznie, gdy `compiler.enabled` jest ustawione i skonfigurowana jest ścieżka `compiler.output`. Nie musisz już rejestrować `intlayerCompiler()` osobno.
+- **Compiler**: Aktywuje się automatycznie, gdy `compiler.enabled` jest ustawione na `true` i skonfigurowana jest ścieżka `compiler.output`. Nie musisz już rejestrować `intlayerCompiler()` osobno.
 - **Proxy**: Aktywuje się automatycznie w oparciu o nową opcję `routing.enableProxy` (domyślnie `true`). Podłącza middleware do wykrywania locale'ów / przekierowywania / przepisywania w developmencie, preview i produkcyjnym SSR. Nie musisz już rejestrować `intlayerProxy()` osobno.
 
 ### Opcja `routing.enableProxy`
@@ -252,17 +253,61 @@ Autonomiczne pluginy `intlayerCompiler()` i `intlayerProxy()` pozostają eksport
 
 ---
 
+## Kompilator domyślnie wyłączony
+
+Od Intlayer v9 **kompilator jest domyślnie wyłączony** (`compiler.enabled` ma teraz domyślnie wartość `false`). Aby włączyć ekstrakcję plików `.content.ts` w czasie budowania, ustaw `compiler.enabled: true` w swojej konfiguracji:
+
+```ts fileName="intlayer.config.ts"
+import type { IntlayerConfig } from "intlayer";
+
+const config: IntlayerConfig = {
+  compiler: {
+    enabled: true, // Domyślnie: false — wymagane do włączenia kompilatora od wersji v9
+    output: ({ fileName }) => `./${fileName}.content.ts`,
+  },
+};
+
+export default config;
+```
+
+Gdy kompilator jest wyłączony, Intlayer pomija krok ekstrakcji w czasie budowania i opiera się na już zadeklarowanych słownikach. Włącz go tylko wtedy, gdy chcesz, aby plugin bundlera (`@intlayer/swc`, `@intlayer/babel` lub plugin Vite `intlayer()`) automatycznie wyodrębniał zawartość.
+
+---
+
+## React Native: importy z jednego pakietu
+
+W aplikacji React Native lub Expo nie musisz już żonglować pakietami `react-intlayer` i `react-native-intlayer`. Pakiet `react-native-intlayer` teraz **ponownie eksportuje pełne API `react-intlayer`** (hooki, narzędzia oraz podścieżki `/format`, `/html` i `/markdown`), a jego `IntlayerProvider` automatycznie stosuje polyfille React Native.
+
+Importuj wszystko z jednego pakietu `react-native-intlayer`:
+
+```tsx
+import {
+  IntlayerProvider,
+  useIntlayer,
+  useLocale,
+} from "react-native-intlayer";
+```
+
+```bash
+npm install intlayer react-native-intlayer
+```
+
+> Importowanie z `react-intlayer` nadal działa, ale `react-native-intlayer` jest teraz zalecanym pojedynczym punktem wejścia dla React Native — jego provider zawiera polyfille, których nie posiada zorientowany na web provider `react-intlayer`.
+
+---
+
 ## Uwagi dotyczące migracji z wersji v8
 
 Jeśli aktualizujesz aplikację z wersji v8, pamiętaj, że wersja v9 nie zawiera zmian wprowadzających niekompatybilność wsteczną (breaking changes). Oto jednak kluczowe zmiany:
 
+- **Kompilator domyślnie wyłączony**: `compiler.enabled` ma teraz domyślnie wartość `false`. Jeśli polegasz na ekstrakcji plików `.content.ts` w czasie budowania, ustaw `compiler.enabled: true` w swoim `intlayer.config.ts`.
 - **Języki i dialekty (Locales & Dialects)**: Jeśli używasz zewnętrznych zależności i18n, dodaj odpowiednie pluginy adapterów kompatybilności w swojej konfiguracji lub konfiguracji bundlera, aby automatycznie przepisywać importy.
-- **Niestandardowe selektory (Custom Selectors)**: Podczas wywoływania `useIntlayer`, drugi parametr jest teraz zarezerwowany dla obiektu opcji zawierającego `{ locale, item, variant, id }`. Jeśli wcześniej przekazywałeś bezpośrednio ciąg znaków języka (locale string), nadal możesz to robić, jednak zaleca się używanie obiektu opcji przy bardziej zaawansowanych wyborach.
+- **Niestandardowe selektory (Custom Selectors)**: Podczas wywoływania `useIntlayer`, drugi parametr jest teraz zarezerwowany dla obiektu opcji zawierającego `{ locale, item, variant }`. Jeśli wcześniej przekazywałeś bezpośrednio ciąg znaków języka (locale string), nadal możesz to robić, jednak zaleca się używanie obiektu opcji przy bardziej zaawansowanych wyborach.
 
 ---
 
 ## Przydatne linki
 
 - [Przewodnik po pakietach kompatybilności (Compat Adapter Packages)](https://github.com/aymericzip/intlayer/blob/main/docs/docs/pl/compat/index.md)
-- [Dynamiczne słowniki - Kolekcje, Warianty i Dynamiczne Rekordy](https://github.com/aymericzip/intlayer/blob/main/docs/docs/pl/dynamic_dictionaries/index.md)
+- [Dynamiczne słowniki - Kolekcje i Warianty](https://github.com/aymericzip/intlayer/blob/main/docs/docs/pl/dynamic_dictionaries/index.md)
 - [Dokumentacja konfiguracji](https://github.com/aymericzip/intlayer/blob/main/docs/docs/pl/configuration.md)

package/docs/pt/compiler.md

@@ -79,12 +79,15 @@ Atualize seu `vite.config.ts` para incluir el plugin `intlayerCompiler`:
 
 ```ts fileName="vite.config.ts"
 import { defineConfig } from "vite";
-import { intlayer, intlayerCompiler } from "vite-intlayer";
+import { intlayer } from "vite-intlayer";
 
 export default defineConfig({
   plugins: [
-    intlayer(),
-    intlayerCompiler(), // Adiciona o plugin do compilador
+    intlayer({
+      proxy: {
+        ignore: (req) => req.url?.startsWith("/api"),
+      },
+    }),
   ],
 });
 ```

package/docs/pt/custom_domains.md

@@ -167,10 +167,16 @@ O plugin Vite `intlayerProxy` aplica a mesma lógica durante o desenvolvimento:
 
 ```typescript fileName="vite.config.ts"
 import { defineConfig } from "vite";
-import { intlayerProxy } from "vite-intlayer";
+import { intlayer } from "vite-intlayer";
 
 export default defineConfig({
-  plugins: [intlayerProxy()],
+  plugins: [
+    intlayer({
+      proxy: {
+        ignore: (req) => req.url?.startsWith("/api"),
+      },
+    }),
+  ],
 });
 ```
 

package/docs/pt/custom_url_rewrites.md

@@ -342,10 +342,16 @@ Para SolidJS, Vue e Svelte, o plugin Vite `intlayerProxy` gerencia as reescritas
 
 ```typescript fileName="vite.config.ts"
 import { defineConfig } from "vite";
-import { intlayerProxy } from "vite-intlayer";
+import { intlayer } from "vite-intlayer";
 
 export default defineConfig({
-  plugins: [intlayerProxy()],
+  plugins: [
+    intlayer({
+      proxy: {
+        ignore: (req) => req.url?.startsWith("/api"),
+      },
+    }),
+  ],
 });
 ```