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

package/docs/pl/dynamic_dictionaries/index.md

@@ -1,48 +1,54 @@
 ---
 createdAt: 2026-06-12
-updatedAt: 2026-06-12
-title: Słowniki Dynamiczne
-description: Omówienie trzech funkcji dynamicznych słowników w Intlayer — kolekcji, wariantów i rekordów dynamicznych — do budowania elastycznych, sterowanych w czasie wykonania treści i18n.
+updatedAt: 2026-06-26
+title: Słowniki dynamiczne
+description: Przegląd funkcji słowników dynamicznych Intlayer — kolekcji i wariantów — do tworzenia elastycznej, sterowanej w czasie wykonywania treści i18n.
 keywords:
-  - Słowniki Dynamiczne
+  - Słowniki dynamiczne
   - Kolekcje
   - Warianty
-  - Rekordy Dynamiczne
   - Intlayer
-  - Umiędzynarodowienie
+  - Internacjonalizacja
 slugs:
   - doc
   - concept
   - dynamic-dictionaries
 history:
-  - version: 8.13.0
+  - version: 9.0.0
     date: 2026-06-12
     changes: "Wydanie funkcji słowników dynamicznych"
+  - version: 9.1.0
+    date: 2026-06-26
+    changes: "Scalono rekordy dynamiczne z wariantami — `variant` przyjmuje teraz ciąg znaków lub obiekt"
 author: aymericzip
 ---
 
-# Słowniki Dynamiczne
+# Słowniki dynamiczne
 
-Intlayer obsługuje trzy mechanizmy definiowania treści wykraczających poza pojedynczy, statyczny słownik na klucz. Każdy z nich jest deklarowany poprzez **pole metadanych najwyższego poziomu** w pliku zawartości; funkcja opakowująca (wrapper) nie jest wymagana.
+Intlayer obsługuje dwa mechanizmy wyrażania treści wykraczającej poza pojedynczy statyczny słownik na klucz. Każdy jest deklarowany przez **pole metadanych najwyższego poziomu** w pliku treści; nie jest potrzebna żadna funkcja opakowująca.
 
-| Funkcja                                                                                                                     | Pole metadanych   | Selektor w `useIntlayer` |
-| --------------------------------------------------------------------------------------------------------------------------- | ----------------- | ------------------------ |
-| [Kolekcje](https://github.com/aymericzip/intlayer/blob/main/docs/docs/pl/dynamic_dictionaries/collections.md)               | `item: N`         | `{ item: N }`            |
-| [Warianty](https://github.com/aymericzip/intlayer/blob/main/docs/docs/pl/dynamic_dictionaries/variants.md)                  | `variant: "name"` | `{ variant: "name" }`    |
-| [Rekordy Dynamiczne](https://github.com/aymericzip/intlayer/blob/main/docs/docs/pl/dynamic_dictionaries/dynamic_content.md) | `meta: { id, … }` | `{ id, … }`              |
+| Funkcja                                                                                                       | Pole metadanych                          | Selektor w `useIntlayer`                         |
+| ------------------------------------------------------------------------------------------------------------- | ---------------------------------------- | ------------------------------------------------ |
+| [Kolekcje](https://github.com/aymericzip/intlayer/blob/main/docs/docs/pl/dynamic_dictionaries/collections.md) | `item: N`                                | `{ item: N }`                                    |
+| [Warianty](https://github.com/aymericzip/intlayer/blob/main/docs/docs/pl/dynamic_dictionaries/variants.md)    | `variant: "name"` _lub_ `variant: { … }` | `{ variant: "name" }` _lub_ `{ variant: { … } }` |
 
-Wszystkie trzy łączą się z argumentem lokalizacji i obsługują wybiórcze / leniwe ładowanie (lazy loading) za pomocą `importMode`.
+Oba łączą się z argumentem locale i obsługują selektywne / leniwe ładowanie przez `importMode`.
 
-## Kiedy używać którego rozwiązania
+## Kiedy czego używać
 
 - **Kolekcje** — uporządkowana lista elementów zarządzanych w osobnych plikach (wpisy FAQ, posty na blogu, produkty).
-- **Warianty** — nazwane alternatywy treści dla testów A/B, banerów sezonowych lub flag funkcji (feature flags).
-- **Rekordy dynamiczne** — treści pobierane w czasie wykonania za pomocą nieprzezroczystego identyfikatora ID (rekordy CMS, treści specyficzne dla użytkownika).
+- **Warianty** — nazwane lub strukturalne alternatywy treści:
+  - wariant **tekstowy** do testów A/B, banerów sezonowych lub feature flag;
+  - wariant **obiektowy** dla rekordów CMS, treści zależnej od użytkownika lub dowolnej treści adresowanej zestawem pól (dawne „rekordy dynamiczne").
 
-## Rozstrzyganie konfliktów selektorów
+> Wcześniejsze wersje udostępniały osobne pole `meta` dla treści indeksowanej rekordami. Zostało scalone z `variant`: przekaż do `variant` **obiekt** zamiast używać `meta`.
 
-Gdy słownik posiada wiele selektorów, kolejność ich rozstrzygania to:
+## Ujednoznacznianie selektora
+
+Klucz może deklarować obydwa wymiary jednocześnie (np. kolekcja, której elementy mają wariant). Są one rozwiązywane w kolejności:
 
 ```
-variant → meta → item
+variant → item
 ```
+
+Zatem `{ variant: "promo" }` dla klucza variant × item zwraca wszystkie elementy promo jako tablicę, a dodanie `{ item: 2 }` zawęża wynik do pojedynczego wpisu.

package/docs/pl/dynamic_dictionaries/variants.md

@@ -1,33 +1,45 @@
 ---
 createdAt: 2026-06-12
-updatedAt: 2026-06-12
+updatedAt: 2026-06-26
 title: Warianty
-description: Użyj pola metadanych variant w plikach zawartości Intlayer, aby deklarować nazwane alternatywne wersje treści (testy A/B, banery sezonowe, treści z flagami funkcji) i przełączać się między nimi w czasie wykonywania bez modyfikacji kodu.
+description: Użyj pola metadanych variant w plikach treści Intlayer, aby zadeklarować nazwane lub strukturalne alternatywy treści — testy A/B, banery sezonowe, teksty z feature flag, rekordy CMS, treść zależną od użytkownika — i przełączać się między nimi w czasie wykonywania bez zmian w kodzie.
 keywords:
   - Warianty
   - Testy A/B
-  - Flagi Funkcji
-  - Zawartość Dynamiczna
+  - Feature flagi
+  - Treść dynamiczna
+  - Rekordy dynamiczne
+  - CMS
   - Intlayer
-  - Umiędzynarodowienie
+  - Internacjonalizacja
 slugs:
   - doc
   - concept
   - variants
 history:
-  - version: 8.13.0
+  - version: 9.0.0
     date: 2026-06-12
-    changes: "Wydanie funkcji wariantów słowników"
+    changes: "Wydanie funkcji wariantów"
+  - version: 9.1.0
+    date: 2026-06-26
+    changes: "`variant` przyjmuje teraz ciąg znaków lub obiekt — dawne `meta` / rekordy dynamiczne deklaruje się jako warianty obiektowe"
 author: aymericzip
 ---
 
 # Warianty
 
-**Wariant** (Variant) to zestaw plików zawartości, które współdzielą ten sam klucz słownika (`key`), ale każdy ma inną nazwę wariantu (`variant`). Intlayer serwuje odpowiedni plik na podstawie selektora przekazanego do `useIntlayer`.
+**Wariant** to zestaw plików treści, które dzielą ten sam klucz słownika (`key`), lecz każdy ma inną wartość `variant`. Intlayer udostępnia odpowiedni plik na podstawie selektora przekazanego do `useIntlayer`.
 
-## Deklarowanie wariantów
+Wartość `variant` może przyjmować **dwie formy**:
 
-Każdy plik reprezentuje jedną nazwaną alternatywę. Pominięcie klucza `variant` (lub ustawienie go na `"default"`) oznacza dany plik jako wariant domyślny (fallback).
+- **Ciąg znaków** — pojedyncza nazwana alternatywa (testy A/B, banery sezonowe, feature flagi).
+- **Obiekt** — strukturalny dyskryminator adresowany zestawem pól (rekordy CMS, treść zależna od użytkownika, dowolna treść z nieprzezroczystym ID jako kluczem). Tożsamością jest cały obiekt: selektor musi dostarczyć **równy** obiekt, aby rozwiązać wpis.
+
+> Forma obiektowa zastępuje dawne pole `meta`. Wszędzie, gdzie wcześniej pisałeś `meta: { id, … }`, napisz `variant: { id, … }` i wybierz ją przez `{ variant: { id, … } }`.
+
+## Warianty nazwane (tekstowe)
+
+Każdy plik reprezentuje jedną nazwaną alternatywę. Pominięcie `variant` (lub ustawienie na `"default"`) oznacza go jako domyślny.
 
 ```ts fileName="hero-banner.content.ts" contentDeclarationFormat={["typescript", "esm", "commonjs"]}
 import { t, type Dictionary } from "intlayer";
@@ -65,9 +77,9 @@ const dictionary = {
 export default dictionary;
 ```
 
-## Używanie wariantów
+### Korzystanie z wariantów nazwanych
 
-### Wariant domyślny
+#### Wariant domyślny
 
 <Tabs group="framework">
   <Tab label="React" value="react">
@@ -209,7 +221,7 @@ export default dictionary;
   </Tab>
 </Tabs>
 
-### Nazwany wariant
+#### Wariant nazwany
 
 ```tsx
 const { headline, cta } = useIntlayer("hero-banner", {
@@ -217,18 +229,264 @@ const { headline, cta } = useIntlayer("hero-banner", {
 });
 ```
 
-### Nazwany wariant z jawnym wskazaniem lokalizacji
+#### Wariant nazwany z jawnym locale
 
 ```tsx
 const content = useIntlayer("hero-banner", {
   variant: "black_friday",
-  locale: "pl",
+  locale: "fr",
 });
 ```
 
+## Warianty obiektowe (strukturalne)
+
+Wariant obiektowy adresuje treść dowolnym zestawem par klucz-wartość zadeklarowanych w polu `variant` — co umożliwia modelowanie rekordów CMS, treści zależnej od użytkownika lub dowolnej treści z nieprzezroczystym ID jako kluczem. Tożsamością jest **cały obiekt**: selektor musi dostarczyć równy obiekt, aby wpis został rozwiązany.
+
+```ts fileName="product.abc.content.ts" contentDeclarationFormat={["typescript", "esm", "commonjs"]}
+import { t, type Dictionary } from "intlayer";
+
+const dictionary = {
+  key: "product",
+  variant: { id: "prod_abc", userId: "user_123" },
+  content: {
+    name: t({ en: "Widget Pro", fr: "Widget Pro" }),
+    description: t({ en: "The best widget.", fr: "Le meilleur widget." }),
+  },
+} satisfies Dictionary;
+
+export default dictionary;
+```
+
+```ts fileName="product.abcd.content.ts" contentDeclarationFormat={["typescript", "esm", "commonjs"]}
+import { t, type Dictionary } from "intlayer";
+
+const dictionary = {
+  key: "product",
+  variant: { id: "prod_abcd", userId: "user_123" },
+  content: {
+    name: t({ en: "Widget Lite", fr: "Widget Lite" }),
+    description: t({ en: "A lighter option.", fr: "Une option plus légère." }),
+  },
+} satisfies Dictionary;
+
+export default dictionary;
+```
+
+### Korzystanie z wariantów obiektowych
+
+Przekaż pasujący obiekt do `variant`. Każde pole zadeklarowane w słowniku musi zostać podane i być równe; w przeciwnym razie wynik to `null`. Kolejność pól nie ma znaczenia.
+
+<Tabs group="framework">
+  <Tab label="React" value="react">
+    ```tsx fileName="Product.tsx" contentDeclarationFormat={["typescript", "esm", "commonjs"]}
+    import { useIntlayer } from "react-intlayer";
+
+    export const Product = ({
+      productId,
+      userId,
+    }: {
+      productId: string;
+      userId: string;
+    }) => {
+      const content = useIntlayer("product", {
+        variant: { id: productId, userId },
+      });
+
+      if (!content) return null;
+
+      return <p>{content.description}</p>;
+    };
+    ```
+
+  </Tab>
+  <Tab label="Next.js" value="nextjs">
+    ```tsx fileName="Product.tsx" contentDeclarationFormat={["typescript", "esm", "commonjs"]}
+    import { useIntlayer } from "next-intlayer";
+
+    export const Product = ({
+      productId,
+      userId,
+    }: {
+      productId: string;
+      userId: string;
+    }) => {
+      const content = useIntlayer("product", {
+        variant: { id: productId, userId },
+      });
+
+      if (!content) return null;
+
+      return <p>{content.description}</p>;
+    };
+    ```
+
+  </Tab>
+  <Tab label="Vue" value="vue">
+    ```vue fileName="Product.vue" contentDeclarationFormat={["typescript", "esm", "commonjs"]}
+    <script setup>
+    import { useIntlayer } from "vue-intlayer";
+
+    const props = defineProps({
+      productId: String,
+      userId: String,
+    });
+
+    const content = useIntlayer("product", {
+      variant: { id: props.productId, userId: props.userId },
+    });
+    </script>
+
+    <template>
+      <p v-if="content">{{ content.description }}</p>
+    </template>
+    ```
+
+  </Tab>
+  <Tab label="Svelte" value="svelte">
+    ```svelte fileName="Product.svelte" contentDeclarationFormat={["typescript", "esm", "commonjs"]}
+    <script lang="ts">
+    import { useIntlayer } from "svelte-intlayer";
+
+    export let productId: string;
+    export let userId: string;
+
+    const content = useIntlayer("product", {
+      variant: { id: productId, userId },
+    });
+    </script>
+
+    {#if $content}
+      <p>{$content.description}</p>
+    {/if}
+    ```
+
+  </Tab>
+  <Tab label="Preact" value="preact">
+    ```tsx fileName="Product.tsx" contentDeclarationFormat={["typescript", "esm", "commonjs"]}
+    import { useIntlayer } from "preact-intlayer";
+
+    export const Product = ({
+      productId,
+      userId,
+    }: {
+      productId: string;
+      userId: string;
+    }) => {
+      const content = useIntlayer("product", {
+        variant: { id: productId, userId },
+      });
+
+      if (!content) return null;
+
+      return <p>{content.description}</p>;
+    };
+    ```
+
+  </Tab>
+  <Tab label="Solid" value="solid">
+    ```tsx fileName="Product.tsx" contentDeclarationFormat={["typescript", "esm", "commonjs"]}
+    import { useIntlayer } from "solid-intlayer";
+
+    export const Product = (props: {
+      productId: string;
+      userId: string;
+    }) => {
+      const content = useIntlayer("product", {
+        variant: { id: props.productId, userId: props.userId },
+      });
+
+      return (
+        <>
+          {content() && <p>{content().description}</p>}
+        </>
+      );
+    };
+    ```
+
+  </Tab>
+  <Tab label="Angular" value="angular">
+    ```typescript fileName="product.component.ts" contentDeclarationFormat={["typescript", "esm", "commonjs"]}
+    import { Component, Input, OnInit } from "@angular/core";
+    import { useIntlayer } from "angular-intlayer";
+
+    @Component({
+      selector: "app-product",
+      template: `
+        @if (content()) {
+          <p>{{ content().description }}</p>
+        }
+      `,
+    })
+    export class ProductComponent implements OnInit {
+      @Input() productId!: string;
+      @Input() userId!: string;
+
+      content: any;
+
+      ngOnInit() {
+        this.content = useIntlayer("product", {
+          variant: { id: this.productId, userId: this.userId },
+        });
+      }
+    }
+    ```
+
+  </Tab>
+  <Tab label="Vanilla JS" value="vanilla">
+    ```javascript fileName="product.js"
+    import { useIntlayer } from "vanilla-intlayer";
+
+    const content = useIntlayer("product", {
+      variant: { id: "prod_abcd", userId: "user_123" },
+    });
+
+    if (content) {
+      document.body.innerHTML = `<p>${content.description}</p>`;
+    }
+    ```
+
+  </Tab>
+</Tabs>
+
+#### Z jawnym locale
+
+```tsx
+const content = useIntlayer("product", {
+  variant: { id: "prod_abc", userId: "user_123" },
+  locale: "fr",
+});
+```
+
+#### Brakujące pole — brak dopasowania
+
+```ts
+// Zwraca null: brakuje `userId`, więc obiekt nie pasuje do zadeklarowanego wariantu
+const content = useIntlayer("product", { variant: { id: "prod_abc" } });
+```
+
+## Tryb ładowania
+
+Warianty obiektowe są często ładowane leniwie. Ustaw `importMode` w słowniku, aby to kontrolować:
+
+```ts contentDeclarationFormat={["typescript", "esm", "commonjs"]}
+const dictionary = {
+  key: "product",
+  importMode: "fetch", // or "dynamic"
+  variant: { id: "prod_abc", userId: "user_123" },
+  content: { … },
+} satisfies Dictionary;
+
+export default dictionary;
+```
+
+Zobacz [optymalizację bundla](https://github.com/aymericzip/intlayer/blob/main/docs/docs/pl/bundle_optimization.md), aby poznać szczegóły trybów `static`, `dynamic` i `fetch`.
+
 ## Typowe przypadki użycia
 
-- Testy A/B kopii sterowane przez klucz eksperymentu
+- Testy A/B tekstu sterowane kluczem eksperymentu
 - Banery sezonowe lub promocyjne
-- Komunikaty powiązane z flagami funkcji (feature flags)
-- Lokalne kampanie marketingowe specyficzne dla danego obszaru
+- Komunikaty z feature flag
+- Kampanie marketingowe specyficzne dla locale
+- Teksty marketingowe per produkt zarządzane w CMS
+- Treść zależna od użytkownika lub konta
+- Dowolna treść adresowana nieprzezroczystym ID w czasie wykonywania

package/docs/pl/formatters.md

@@ -53,6 +53,8 @@ author: aymericzip
 
 Intlayer dostarcza zestaw lekkich helperów opartych na natywnych API `Intl`, oraz opakowanie `Intl` z pamięcią podręczną, które zapobiega wielokrotnemu tworzeniu ciężkich formatterów. Te narzędzia są w pełni świadome lokalizacji i mogą być używane z głównego pakietu `intlayer`.
 
+## React Formatters
+
 ### Import
 
 ```ts
@@ -80,6 +82,61 @@ import {
 
 Jeśli używasz React, dostępne są również hooki; zobacz `react-intlayer/format`.
 
+### Dostępne Hooks
+
+Wszystkie hooks automatycznie używają locale z `IntlayerProvider` lub `IntlayerServerProvider`.
+
+| Hook                | Opis                                     | Przykładowe wyjście           |
+| ------------------- | ---------------------------------------- | ----------------------------- |
+| `useNumber()`       | Formatuj liczby z grupowaniem            | `"123,456.789"`               |
+| `useCurrency()`     | Formatuj wartości waluty                 | `"€1,234.50"`                 |
+| `usePercentage()`   | Formatuj procenty                        | `"25%"`                       |
+| `useDate()`         | Formatuj daty i godziny                  | `"Aug 2, 2025"`               |
+| `useRelativeTime()` | Formatuj czas względny                   | `"in 3 days"`                 |
+| `useUnit()`         | Formatuj wartości z jednostkami          | `"5 kilometers"`              |
+| `useCompact()`      | Formatuj liczby w notacji zwartej        | `"1.2K"`                      |
+| `useList()`         | Formatuj tablice jako listy              | `"apple, banana, and orange"` |
+| `useIntl()`         | Pobierz obiekt `Intl` powiązany z locale | Pełny dostęp do API `Intl`    |
+
+### Pełny Przykład
+
+```tsx
+import {
+  useNumber,
+  useCurrency,
+  useDate,
+  usePercentage,
+  useCompact,
+  useList,
+  useRelativeTime,
+  useUnit,
+} from "react-intlayer/format";
+
+const MyComponent = () => {
+  const number = useNumber();
+  const currency = useCurrency();
+  const date = useDate();
+  const percentage = usePercentage();
+  const compact = useCompact();
+  const list = useList();
+  const relativeTime = useRelativeTime();
+  const unit = useUnit();
+
+  return (
+    <div>
+      <p>{number(123456.789)}</p>
+      <p>{currency(1234.5, { currency: "EUR" })}</p>
+      <p>{date(new Date(), "short")}</p>
+      <p>{percentage(0.25)}</p>
+      <p>{compact(1200)}</p>
+      <p>{list(["apple", "banana", "orange"])}</p>
+      <p>{relativeTime(new Date(), new Date(Date.now() + 86400000))}</p>
+      <p>{unit(5, { unit: "kilometer" })}</p>
+    </div>
+  );
+};
+```
+
 ## Buforowany Intl
 
 Eksportowany `Intl` to cienkie, buforowane opakowanie wokół globalnego `Intl`. Zapamiętuje instancje `NumberFormat`, `DateTimeFormat`, `RelativeTimeFormat`, `ListFormat`, `DisplayNames`, `Collator` oraz `PluralRules`, co zapobiega wielokrotnemu tworzeniu tego samego formattera.
@@ -134,6 +191,61 @@ const regionNames = new Intl.DisplayNames("fr", { type: "region" });
 regionNames.of("US"); // "États-Unis"
 ```
 
+### Dostępne Composables
+
+Wszystkie composables zwracają computed refs, które automatycznie używają locale'a z wstrzykniętego `IntlayerProvider`.
+
+| Composable          | Description                              | Example Output                |
+| ------------------- | ---------------------------------------- | ----------------------------- |
+| `useNumber()`       | Formatowanie liczb z grupowaniem         | `"123,456.789"`               |
+| `useCurrency()`     | Formatowanie wartości walut              | `"€1,234.50"`                 |
+| `usePercentage()`   | Formatowanie procentów                   | `"25%"`                       |
+| `useDate()`         | Formatowanie dat i czasów                | `"Aug 2, 2025"`               |
+| `useRelativeTime()` | Formatowanie czasu względnego            | `"in 3 days"`                 |
+| `useUnit()`         | Formatowanie wartości z jednostkami      | `"5 kilometers"`              |
+| `useCompact()`      | Formatowanie liczb w notacji zwartej     | `"1.2K"`                      |
+| `useList()`         | Formatowanie tablic jako listy           | `"apple, banana, and orange"` |
+| `useIntl()`         | Pobierz obiekt `Intl` powiązany z locale | Pełny dostęp do API `Intl`    |
+
+### Kompletny Przykład
+
+```vue
+<script setup>
+import {
+  useNumber,
+  useCurrency,
+  useDate,
+  usePercentage,
+  useCompact,
+  useList,
+  useRelativeTime,
+  useUnit,
+} from "vue-intlayer/format";
+
+const number = useNumber();
+const currency = useCurrency();
+const date = useDate();
+const percentage = usePercentage();
+const compact = useCompact();
+const list = useList();
+const relativeTime = useRelativeTime();
+const unit = useUnit();
+</script>
+
+<template>
+  <div>
+    <p>{{ number.value(123456.789) }}</p>
+    <p>{{ currency.value(1234.5, { currency: "EUR" }) }}</p>
+    <p>{{ date.value(new Date(), "short") }}</p>
+    <p>{{ percentage.value(0.25) }}</p>
+    <p>{{ compact.value(1200) }}</p>
+    <p>{{ list.value(["apple", "banana", "orange"]) }}</p>
+    <p>{{ relativeTime.value(new Date(), new Date(Date.now() + 86400000)) }}</p>
+    <p>{{ unit.value(5, { unit: "kilometer" }) }}</p>
+  </div>
+</template>
+```
+
 ### `Intl.Collator`
 
 Do porównywania i sortowania łańcuchów znaków z uwzględnieniem lokalizacji:
@@ -150,6 +262,10 @@ const words = ["äpfel", "zebra", "100", "20"];
 words.sort(collator.compare); // ["20", "100", "äpfel", "zebra"]
 ```
 
+## Vanilla JS / Node.js Formatters
+
+W kontekstach bez frameworka, importuj formatters bezpośrednio z `intlayer`. Pamiętaj, że musisz ręcznie przekazać locale.
+
 ### `Intl.PluralRules`
 
 Do określania form liczby mnogiej w różnych lokalizacjach:
@@ -303,6 +419,8 @@ const content = getTranslation(
 - **locale**: Docelowa lokalizacja (domyślnie skonfigurowana lokalizacja domyślna)
 - **fallback**: Czy użyć lokalizacji domyślnej jako zapasowej (domyślnie true)
 
+### Dodatkowe funkcje Intl
+
 ### `getIntlayer(dictionaryKey, locale?, plugins?)`
 
 Pobiera i transformuje treść ze słownika na podstawie klucza:
@@ -468,6 +586,8 @@ list(["red", "green", "blue"], { locale: "fr", type: "disjunction" }); // "rouge
 list([1, 2, 3], { type: "unit" }); // "1, 2, 3"
 ```
 
+## Narzędzia do obsługi zawartości
+
 ## Uwagi
 
 - Wszystkie helpery akceptują dane wejściowe typu `string`; są one wewnętrznie konwertowane na liczby lub daty.

package/docs/pl/intlayer_CMS.md

@@ -1,6 +1,6 @@
 ---
 createdAt: 2025-08-23
-updatedAt: 2025-08-23
+updatedAt: 2026-06-30
 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,9 @@ slugs:
   - cms
 youtubeVideo: https://www.youtube.com/watch?v=UDDTnirwi_4
 history:
+  - 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"
@@ -384,6 +387,18 @@ Uwagi i ograniczenia:
 - 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`.
 
+## Samodzielne hostowanie (Self-Hosting)
+
+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:
+
+```sh
+curl -fsSL https://intlayer.org/install.sh | sh
+```
+
+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).
+
+---
+
 ## Debug
 
 Jeśli napotkasz jakiekolwiek problemy z CMS, sprawdź następujące kwestie:

package/docs/pl/intlayer_with_adonisjs.md

@@ -59,24 +59,40 @@ Zobacz [Application Template](https://github.com/aymericzip/intlayer-adonisjs-te
 
 Aby zacząć korzystać z `adonis-intlayer`, zainstaluj pakiet za pomocą npm:
 
+```bash packageManager="npm"
+npx intlayer-cli init --interactive
+```
+
+```bash packageManager="pnpm"
+pnpm dlx intlayer-cli init --interactive
+```
+
+```bash packageManager="yarn"
+yarn dlx intlayer-cli init --interactive
+```
+
+```bash packageManager="bun"
+bunx intlayer-cli init --interactive
+```
+
+> flaga `--interactive` jest opcjonalna. Użyj `intlayer-cli init`, jeśli jesteś agentem AI.
+
+> To polecenie wykryje Twoje środowisko i zainstaluje wymagane pakiety. Na przykład:
+
 ```bash packageManager="npm"
 npm install intlayer adonis-intlayer
-npx intlayer init
 ```
 
 ```bash packageManager="pnpm"
 pnpm add intlayer adonis-intlayer
-pnpm intlayer init
 ```
 
 ```bash packageManager="yarn"
 yarn add intlayer adonis-intlayer
-yarn intlayer init
 ```
 
 ```bash packageManager="bun"
 bun add intlayer adonis-intlayer
-bun x intlayer init
 ```
 
 ### Konfiguracja