@intlayer/docs 9.0.0-canary.9 → 9.0.1

package/docs/de/self_hosting.md

@@ -0,0 +1,350 @@
+---
+createdAt: 2026-06-30
+updatedAt: 2026-06-30
+title: "Intlayer selbst hosten"
+description: "Betreiben Sie eine komplette Intlayer-Instanz auf Ihrer eigenen Infrastruktur mit einem einzigen Befehl. Kein Intlayer Cloud-Konto erforderlich."
+keywords:
+  - Selbst-Hosting
+  - Docker
+  - Docker Compose
+  - Intlayer
+  - CMS
+  - Installation
+  - Infrastruktur
+slugs:
+  - doc
+  - self-hosting
+author: aymericzip
+---
+
+# Intlayer selbst hosten
+
+Intlayer kann vollständig auf Ihrer eigenen Infrastruktur ausgeführt werden – kein Intlayer Cloud-Konto erforderlich. Ein einziger Befehl startet einen produktionsbereiten Stack:
+
+```sh
+curl -fsSL https://intlayer.org/install.sh | sh
+```
+
+Der Installer lädt eine `docker-compose.yml` und eine `.env` herunter, generiert automatisch die erforderlichen Secrets und startet alle Container mit `docker compose up -d`.
+
+## Inhaltsverzeichnis
+
+<TOC/>
+
+---
+
+## Architektur
+
+```
+                ┌─────────────────────────────┐
+ browser ──────▶ │  app  (TanStack Start)  :3000│ ──┐
+                └─────────────────────────────┘   │ VITE_BACKEND_URL
+                ┌─────────────────────────────┐   │
+                │  backend (Fastify/Bun)  :3100│ ◀─┘
+                └──────────────┬──────────────┘
+          ┌──────────┬─────────┼──────────┬───────────┐
+          ▼          ▼         ▼          ▼           ▼
+     mongo:27017  redis:6379  minio:9000  mailpit:1025  Chromium
+     (1-node RS)             (S3 API)     (SMTP)        (in-image)
+                             minio:9001   mailpit:8025
+                             (console)    (web UI)
+```
+
+Chromium (wird für die Erzeugung von Puppeteer-Screenshots verwendet) ist im Backend-Image gebündelt – es wird kein separater Container benötigt.
+
+---
+
+## Voraussetzungen
+
+- **Docker** ≥ 24 und **Docker Compose** ≥ v2. Fehlt eines davon, gibt der Installer den Installationslink aus und beendet sich.
+- Ports `3000`, `3100`, `8025`, `9000` und `9001` auf dem Host verfügbar.
+- Ein Linux- oder macOS-Host (oder WSL2 unter Windows).
+
+---
+
+## Schnellstart
+
+```sh
+curl -fsSL https://intlayer.org/install.sh | sh
+```
+
+Was der Installer tut:
+
+1.  Überprüft, ob `docker` und `docker compose` vorhanden sind.
+2.  Lädt `docker-compose.yml` und `.env.example` in `./intlayer/` herunter.
+3.  Falls keine `.env` existiert, kopiert er das Beispiel und generiert zufällige Secrets für `BETTER_AUTH_SECRET`, `S3_ACCESS_KEY_ID` und `S3_SECRET_ACCESS_KEY` mittels `openssl rand`.
+4.  Führt `docker compose pull` + `docker compose up -d` aus.
+5.  Gibt die URLs aus: Dashboard `:3000`, API `:3100`, E-Mail-UI `:8025`, MinIO-Konsole `:9001`.
+
+Nachdem der Stack gestartet ist, öffnen Sie **http://localhost:3000** und erstellen Sie Ihr erstes Konto.
+
+---
+
+## Dienste
+
+| Service     | Image                                | Host port(s)                                   | Zweck                                                     |
+| :---------- | :----------------------------------- | :--------------------------------------------- | :-------------------------------------------------------- |
+| **app**     | built from `apps/app/Dockerfile`     | `3000`                                         | TanStack Start Dashboard (CMS-Benutzeroberfläche)         |
+| **backend** | built from `apps/backend/Dockerfile` | `3100`                                         | Fastify REST API (`/health` Endpunkt)                     |
+| **mongo**   | `mongo:7`                            | intern                                         | Einzelknoten-Replica Set (`rs0`)                          |
+| **redis**   | `redis:7-alpine`                     | intern                                         | Job-Warteschlangen (BullMQ) und Caching (ioredis)         |
+| **minio**   | `minio/minio`                        | `9000` (S3), `9001` (Konsole)                  | S3-kompatibler Objektspeicher für Avatare und Screenshots |
+| **mailpit** | `axllent/mailpit`                    | `1025` (SMTP), `8025` (Web-Benutzeroberfläche) | Lokale Transaktions-E-Mail-Senke                          |
+
+Interne Ports (mongo, redis) werden standardmäßig nicht zum Host exponiert.
+
+> MinIO-Port `9000` muss vom Browser erreichbar sein, da hochgeladene Assets (Avatare, Screenshots) direkt von `S3_PUBLIC_URL=http://localhost:9000/intlayer` geladen werden.
+
+---
+
+## Umgebungsvariablen
+
+Der Installer generiert eine gebrauchsfertige `.env`. Die folgende Tabelle beschreibt jede Variable.
+
+### Erforderlich (automatisch generiert oder abgefragt)
+
+| Variable               | Beispiel                                        | Beschreibung                                                     |
+| :--------------------- | :---------------------------------------------- | :--------------------------------------------------------------- |
+| `NODE_ENV`             | `production`                                    | Laufzeitumgebung                                                 |
+| `PORT`                 | `3100`                                          | Backend-Listenport                                               |
+| `BACKEND_URL`          | `http://localhost:3100`                         | Öffentliche URL der Backend-API                                  |
+| `APP_URL`              | `http://localhost:3000`                         | Öffentliche URL des Dashboards                                   |
+| `DOMAIN`               | `localhost`                                     | Cookie-Domain                                                    |
+| `MONGODB_URI`          | `mongodb://mongo:27017/intlayer?replicaSet=rs0` | Vollständige MongoDB-Verbindungs-URI                             |
+| `REDIS_URL`            | `redis://redis:6379`                            | Redis-Verbindungs-URL                                            |
+| `BETTER_AUTH_SECRET`   | _(generiert)_                                   | 32-Byte-Secret für die Session-Signierung                        |
+| `MAIL_PROVIDER`        | `smtp`                                          | Mail-Transport: `smtp` oder `resend`                             |
+| `MAIL_SMTP_HOST`       | `mailpit`                                       | SMTP-Hostname (Mailpit Container-Name)                           |
+| `MAIL_SMTP_PORT`       | `1025`                                          | SMTP-Port                                                        |
+| `MAIL_FROM`            | `Intlayer <no-reply@localhost>`                 | Absenderadresse                                                  |
+| `S3_ENDPOINT`          | `http://minio:9000`                             | S3-kompatibler Endpunkt                                          |
+| `S3_PUBLIC_URL`        | `http://localhost:9000/intlayer`                | Öffentliche URL für das Laden von Browser-Assets                 |
+| `S3_BUCKET_NAME`       | `intlayer`                                      | Bucket-Name                                                      |
+| `S3_ACCESS_KEY_ID`     | _(generiert)_                                   | MinIO-Zugangsschlüssel                                           |
+| `S3_SECRET_ACCESS_KEY` | _(generiert)_                                   | MinIO-Geheimschlüssel                                            |
+| `VITE_BACKEND_URL`     | `http://localhost:3100`                         | Backend-URL, die zur Build-Zeit in das Dashboard integriert wird |
+| `VITE_DOMAIN`          | `localhost`                                     | Domain, die zur Build-Zeit in das Dashboard integriert wird      |
+
+### Optional (Funktionen funktionieren bei Abwesenheit eingeschränkt)
+
+| Variable                                                 | Funktion                                                             |
+| :------------------------------------------------------- | :------------------------------------------------------------------- |
+| `OPENAI_API_KEY`                                         | KI-gestützte Übersetzung und Inhaltsprüfung                          |
+| `STRIPE_SECRET_KEY`, `STRIPE_WEBHOOK_SECRET`, `STRIPE_*` | Abrechnung und Abonnementverwaltung                                  |
+| `RESEND_API_KEY`                                         | Transaktions-E-Mail über Resend (überschreibt Mailpit, wenn gesetzt) |
+| `GITHUB_CLIENT_ID`, `GITHUB_CLIENT_SECRET`               | GitHub OAuth-Login                                                   |
+| `GOOGLE_CLIENT_ID`, `GOOGLE_CLIENT_SECRET`               | Google OAuth-Login                                                   |
+| `GITLAB_CLIENT_ID`, `GITLAB_CLIENT_SECRET`               | GitLab OAuth-Login                                                   |
+| `MICROSOFT_CLIENT_ID`, `MICROSOFT_CLIENT_SECRET`         | Microsoft OAuth-Login                                                |
+| `LINKEDIN_CLIENT_ID`, `LINKEDIN_CLIENT_SECRET`           | LinkedIn OAuth-Login                                                 |
+| `ATLASSIAN_CLIENT_ID`, `ATLASSIAN_CLIENT_SECRET`         | Atlassian OAuth-Login                                                |
+
+---
+
+## Ihr Intlayer-Projekt verbinden
+
+Sobald der Stack läuft, verweisen Sie Ihr Projekt auf das selbst gehostete Backend und Dashboard anstelle von `intlayer.org`.
+
+### Projektkonfiguration
+
+```typescript fileName="intlayer.config.ts" codeFormat={["typescript", "esm", "commonjs"]}
+import type { IntlayerConfig } from "intlayer";
+
+const config: IntlayerConfig = {
+  editor: {
+    clientId: process.env.INTLAYER_CLIENT_ID,
+    clientSecret: process.env.INTLAYER_CLIENT_SECRET,
+
+    /**
+     * URL des selbst gehosteten CMS-Dashboards.
+     * Standard: https://app.intlayer.org
+     */
+    cmsURL: process.env.INTLAYER_CMS_URL, // e.g. http://localhost:3000
+
+    /**
+     * URL der selbst gehosteten Backend-API.
+     * Standard: https://back.intlayer.org
+     */
+    backendURL: process.env.INTLAYER_BACKEND_URL, // e.g. http://localhost:3100
+  },
+};
+
+export default config;
+```
+
+Setzen Sie die Umgebungsvariablen in der `.env` Ihres Projekts:
+
+```sh
+INTLAYER_CMS_URL=http://localhost:3000
+INTLAYER_BACKEND_URL=http://localhost:3100
+INTLAYER_CLIENT_ID=<your-client-id>
+INTLAYER_CLIENT_SECRET=<your-client-secret>
+```
+
+Erstellen Sie Zugangsdaten in Ihrem selbst gehosteten Dashboard unter **Projects → Access keys** unter `http://localhost:3000/projects`.
+
+### `@intlayer/api` SDK
+
+Wenn Sie das `@intlayer/api` SDK programmatisch verwenden, übergeben Sie `backendURL` explizit:
+
+```typescript fileName="cms.ts" codeFormat="typescript"
+import { createIntlayerCMS } from "@intlayer/api";
+import { dictionaryEndpoint } from "@intlayer/api/dictionary";
+
+const cms = createIntlayerCMS({
+  editor: {
+    clientId: process.env.INTLAYER_CLIENT_ID,
+    clientSecret: process.env.INTLAYER_CLIENT_SECRET,
+    backendURL: process.env.INTLAYER_BACKEND_URL, // http://localhost:3100
+  },
+});
+
+const { data: dictionaries } = await dictionaryEndpoint(cms).getDictionaries();
+```
+
+---
+
+## Upgrade
+
+Ein erneutes Ausführen des Installers auf einer bestehenden Bereitstellung führt ein Rolling-Upgrade durch:
+
+```sh
+curl -fsSL https://intlayer.org/install.sh | sh
+```
+
+Dies zieht die neuesten Images und startet Container neu mit `docker compose pull && docker compose up -d`. Bestehende Volumes (`mongo-data`, `redis-data`, `minio-data`) bleiben erhalten – kein Datenverlust.
+
+Um manuell aus dem `./intlayer/`-Verzeichnis ein Upgrade durchzuführen:
+
+```sh
+docker compose pull
+docker compose up -d
+```
+
+---
+
+## Backup und Wiederherstellung
+
+Alle persistenten Daten befinden sich in drei benannten Docker-Volumes.
+
+### Backup
+
+```sh
+docker run --rm \
+  -v intlayer_mongo-data:/data \
+  -v "$(pwd)":/backup \
+  busybox tar czf /backup/mongo-data.tar.gz /data
+
+docker run --rm \
+  -v intlayer_redis-data:/data \
+  -v "$(pwd)":/backup \
+  busybox tar czf /backup/redis-data.tar.gz /data
+
+docker run --rm \
+  -v intlayer_minio-data:/data \
+  -v "$(pwd)":/backup \
+  busybox tar czf /backup/minio-data.tar.gz /data
+```
+
+### Wiederherstellung
+
+```sh
+docker run --rm \
+  -v intlayer_mongo-data:/data \
+  -v "$(pwd)":/backup \
+  busybox tar xzf /backup/mongo-data.tar.gz -C /
+
+# Wiederholen Sie dies für redis-data und minio-data
+```
+
+---
+
+## Verwendung eines Reverse-Proxys (Nginx / Caddy)
+
+Für Produktionsbereitstellungen platzieren Sie einen Reverse-Proxy vor den App- und Backend-Containern, anstatt sie direkt zu exponieren.
+
+### Nginx-Beispiel
+
+```nginx
+server {
+    listen 80;
+    server_name cms.example.com;
+
+    location / {
+        proxy_pass http://localhost:3000;
+        proxy_set_header Host $host;
+        proxy_set_header X-Real-IP $remote_addr;
+    }
+}
+
+server {
+    listen 80;
+    server_name api.example.com;
+
+    location / {
+        proxy_pass http://localhost:3100;
+        proxy_set_header Host $host;
+        proxy_set_header X-Real-IP $remote_addr;
+    }
+}
+```
+
+Aktualisieren Sie die folgenden `.env`-Variablen, um sie an Ihre öffentlichen Domains anzupassen:
+
+```sh
+BACKEND_URL=https://api.example.com
+APP_URL=https://cms.example.com
+DOMAIN=example.com
+VITE_BACKEND_URL=https://api.example.com
+VITE_DOMAIN=example.com
+```
+
+> `VITE_*`-Variablen werden zur Build-Zeit in das Dashboard-Image integriert. Wenn Sie diese nach dem Bau des Images ändern, müssen Sie das `app`-Image neu erstellen (`docker compose build app`) oder die Laufzeitkonfigurationsinjektion verwenden.
+
+---
+
+## Fehlerbehebung
+
+### Backend-Absturzschleifen beim ersten Start
+
+MongoDB und Redis müssen fehlerfrei sein, bevor das Backend startet. Die Compose-Datei verwendet `depends_on` mit `condition: service_healthy`. Wenn Sie wiederholte Backend-Neustarts sehen, überprüfen Sie, ob die `mongo`- und `redis`-Healthchecks erfolgreich sind:
+
+```sh
+docker compose ps
+docker compose logs mongo
+docker compose logs redis
+```
+
+### Dashboard kann die API nicht erreichen
+
+Stellen Sie sicher, dass `VITE_BACKEND_URL` der URL entspricht, unter der das Backend vom **Browser** (nicht vom Docker-Netzwerk) aus erreichbar ist. Wenn Sie den Backend-Port geändert oder einen Reverse-Proxy hinzugefügt haben, erstellen Sie das Dashboard-Image neu:
+
+```sh
+docker compose build app
+docker compose up -d app
+```
+
+### E-Mail wird nicht gesendet
+
+Standardmäßig werden alle ausgehenden E-Mails von Mailpit abgefangen. Öffnen Sie `http://localhost:8025`, um gesendete Nachrichten anzuzeigen. Um echte E-Mails zu senden, setzen Sie `MAIL_PROVIDER=resend` und `RESEND_API_KEY=<Ihr-Schlüssel>` in `.env` und starten Sie dann das Backend neu:
+
+```sh
+docker compose restart backend
+```
+
+### MinIO-Bucket fehlt
+
+Wenn der `minio-init`-One-Shot-Service nicht ausgeführt wurde (oder vor der Bereitschaft von MinIO lief), erstellen Sie den Bucket manuell:
+
+```sh
+docker compose run --rm minio-init
+```
+
+---
+
+## Nützliche Links
+
+- [Intlayer CMS-Dokumentation](https://github.com/aymericzip/intlayer/blob/main/docs/docs/de/intlayer_CMS.md)
+- [Konfigurationsreferenz](https://github.com/aymericzip/intlayer/blob/main/docs/docs/de/configuration.md)
+- [CMS SDK — `@intlayer/api`](https://github.com/aymericzip/intlayer/blob/main/docs/docs/de/intlayer_CMS.md#programmatic-access-with-the-intlayerapi-sdk)
+- [Docker Image (aymercizip/intlayer-selfhost)](https://hub.docker.com/repository/docker/aymercizip/intlayer-selfhost/general)

package/docs/en/analytics.md

@@ -0,0 +1,222 @@
+---
+createdAt: 2026-07-08
+updatedAt: 2026-07-08
+title: Intlayer Analytics | Track content exposure and run A/B tests
+description: Discover how @intlayer/analytics tracks page/locale views and content exposure, and how to use it to run A/B tests on your Intlayer content.
+keywords:
+  - Analytics
+  - A/B Testing
+  - Audience
+  - Internationalization
+  - Documentation
+  - Intlayer
+  - Next.js
+  - JavaScript
+  - React
+slugs:
+  - doc
+  - concept
+  - analytics
+history:
+  - version: 9.0.0
+    date: 2026-07-08
+    changes: "Init doc — @intlayer/analytics package, provider/node-level tracking, A/B testing, dashboard"
+author: aymericzip
+---
+
+# Intlayer Analytics Documentation
+
+`@intlayer/analytics` is an optional companion package that tells you **which content is actually shown** to your visitors — which page, in which locale, and which specific piece of translated content — so you can understand your audience and run **A/B tests on content**.
+
+## Table of Contents
+
+<TOC/>
+
+---
+
+## What it tracks
+
+`@intlayer/analytics` batches three kinds of anonymous events:
+
+| Event              | Captured where                                   | What it tells you                                                                                                         |
+| ------------------ | ------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------- |
+| `page_view`        | Provider level (`IntlayerProvider`)              | Which page and locale a session viewed, on first load, route change, or locale switch.                                    |
+| `content_exposure` | Node level (`useIntlayer` / interpreter plugins) | Which dictionary key / key path was actually resolved and displayed — and, when part of an experiment, which **variant**. |
+| `conversion`       | Wherever you call `useConversion()`              | A goal reached (signup, click, purchase…) attributed to the A/B variant the session was exposed to.                       |
+
+Events are collected in memory and sent as a **single batched request roughly every 20 seconds** — never on every keystroke or render — so analytics never impacts first render time or adds a request per interaction.
+
+## How it powers A/B testing on content
+
+Intlayer already lets you declare content [Variants](https://github.com/aymericzip/intlayer/blob/main/docs/docs/en/dynamic_dictionaries/index.md) (e.g. a `hero-banner` dictionary with a `control` and a `black_friday` variant). `@intlayer/analytics` closes the loop:
+
+1. `getVariant(experimentKey, variants)` deterministically assigns each anonymous session to a variant — a pure function of the session id and the experiment key, so the assignment is **stable across the session** and requires **no server round-trip** before first render (no flicker, no layout shift).
+2. Every `content_exposure` event carries the `variant` that was shown.
+3. `useConversion()` lets you attribute a goal (e.g. `"cta_click"`) to that variant.
+4. The dashboard's experiment results endpoint compares conversion rates per variant, including statistical significance (a z-test).
+
+## Installation
+
+`@intlayer/analytics` is a **peer, optional** dependency — never installed automatically by a framework package. Add it alongside `intlayer`:
+
+```bash packageManager="npm"
+npm install @intlayer/analytics
+```
+
+```bash packageManager="yarn"
+yarn add @intlayer/analytics
+```
+
+```bash packageManager="pnpm"
+pnpm add @intlayer/analytics
+```
+
+```bash packageManager="bun"
+bun add @intlayer/analytics
+```
+
+If you don't install it, every integration point resolves to a no-op — see [Zero-cost when not installed](#zero-cost-when-not-installed) below.
+
+## Configuration
+
+Analytics **reuses the existing `editor` configuration block** — there is no separate `analytics` config schema to fill in:
+
+```typescript fileName="intlayer.config.ts" codeFormat={["typescript", "esm", "commonjs"]}
+import type { IntlayerConfig } from "intlayer";
+
+const config: IntlayerConfig = {
+  editor: {
+    backendURL: "https://back.intlayer.org", // Also used as the analytics ingestion endpoint
+    clientId: "your-client-id", // Also used as the analytics project key
+    clientSecret: "your-client-secret",
+  },
+};
+
+export default config;
+```
+
+- `editor.backendURL` — the base URL analytics events are sent to (`POST {backendURL}/api/analytics/events`).
+- `editor.clientId` — the public project key attributed to every ingested event. It also acts as the **enable switch**: analytics stays fully disabled (and tree-shaken, see below) until `clientId` is configured.
+
+If you self-host Intlayer, analytics automatically points at your own instance since it shares `editor.backendURL`.
+
+## Framework support
+
+Analytics is wired into the shared `IntlayerProvider` from `react-intlayer`, so it is available today anywhere that provider is used:
+
+| Framework                                                | Status                                                                                             |
+| -------------------------------------------------------- | -------------------------------------------------------------------------------------------------- |
+| React                                                    | ✅ Available                                                                                       |
+| Next.js (`next-intlayer`)                                | ✅ Available (via `react-intlayer`)                                                                |
+| React Native / Expo (`react-native-intlayer`)            | ✅ Available (via `react-intlayer`)                                                                |
+| Vue, Svelte, Angular, Solid, Preact, Lit, Astro, Vanilla | 🚧 Planned — same client, provider-level bindings following the `@intlayer/editor` rollout pattern |
+
+## Usage
+
+### Automatic provider-level tracking
+
+No code changes are required. Once `@intlayer/analytics` is installed and `editor.clientId` is configured, `IntlayerProvider` automatically:
+
+- initializes the analytics client on mount,
+- records a `page_view` on initial load,
+- records a `page_view` on every locale change,
+- starts the ~20s flush loop and flushes any remaining events on unmount / tab close (via `navigator.sendBeacon`, falling back to `fetch(..., { keepalive: true })`).
+
+### Automatic node-level tracking
+
+Every time `useIntlayer` resolves a piece of content for display, the interpreter reports a `content_exposure` event for that exact `dictionaryKey` + key path + locale — again, no code changes required. Repeated exposures of the same node within a flush window are coalesced into a single event with a `count`, so a list re-rendering 50 times doesn't send 50 events.
+
+### Tracking conversions for A/B tests
+
+Use `useConversion()` to attribute a goal to the variant a session saw:
+
+```tsx fileName="CTAButton.tsx" codeFormat="tsx"
+import { useConversion } from "react-intlayer";
+
+const CTAButton = () => {
+  const trackConversion = useConversion();
+
+  return (
+    <button
+      onClick={() =>
+        trackConversion({
+          experimentKey: "homepage-hero",
+          variant: "black_friday",
+          goal: "cta_click",
+        })
+      }
+    >
+      Get started
+    </button>
+  );
+};
+```
+
+### Resolving a variant client-side
+
+```tsx fileName="useHeroVariant.ts" codeFormat="tsx"
+import { getGlobalAnalyticsClient } from "@intlayer/analytics/client";
+
+const client = getGlobalAnalyticsClient();
+const variant = client?.getVariant("homepage-hero", [
+  "control",
+  "black_friday",
+]);
+```
+
+## Privacy & performance
+
+- **Anonymous by design**: sessions are identified by a rotating id; the backend only ever stores a **SHA-256 hash** of that id — never the raw id, never an IP address.
+- **Location is coarse**: only a country code, derived from CDN geolocation headers (`cf-ipcountry`, `x-vercel-ip-country`, …) — no IP is read or stored.
+- **URLs exclude search params** by default, so query strings are never captured.
+- **Sampling**: `sampleRate` lets you keep only a fraction of content-exposure events on high-traffic apps.
+- **Batched**: one request roughly every 20 seconds (`flushInterval`), or earlier if the buffer fills up (`maxBufferSize`) — never one request per event.
+
+### Zero-cost when not installed
+
+`@intlayer/analytics` follows the exact same optional-dependency pattern as `@intlayer/editor`:
+
+- every integration point loads the package via a **dynamic `import()` wrapped in `try/catch`** — an app that never installs `@intlayer/analytics` never pays a bundle-size or runtime cost, and never sees an error;
+- a compile-time env var (`INTLAYER_ANALYTICS_ENABLED`), automatically set to `'false'` by `@intlayer/config` whenever `editor.clientId` is not configured, lets bundlers **dead-code-eliminate** the whole integration;
+- analytics is disabled inside the Intlayer editor/CMS preview iframe, so editor sessions are never counted as real traffic.
+
+## Dashboard: Analytics page
+
+Once your project has collected events, the **Analytics** page in the [Intlayer dashboard](https://app.intlayer.org/analytics) (visible in the sidebar once a project is selected) shows:
+
+- **Active users** — distinct visitors over the selected rolling window (7 / 30 / 90 days).
+- **Users today** and **users over the last 7 days**.
+- **Page views** over the selected window.
+- An **evolution graph** of daily distinct visitors.
+- **Locales** and **Location** breakdown tabs, ranking your audience by locale and by country.
+
+## Backend API reference
+
+All read endpoints require authentication; ingestion is public and attributed by `clientId`.
+
+| Method | Endpoint                                    | Description                                                                      |
+| ------ | ------------------------------------------- | -------------------------------------------------------------------------------- |
+| `POST` | `/api/analytics/events`                     | Ingest a batch of events (public, attributed by `clientId` in the body).         |
+| `GET`  | `/api/analytics/overview`                   | Page/locale totals for the authenticated project.                                |
+| `GET`  | `/api/analytics/audience?days=30`           | Distinct visitors, page views, daily series, locale + country breakdowns.        |
+| `GET`  | `/api/analytics/content-stats`              | Per-content exposure totals, grouped by dictionary key / key path / locale.      |
+| `GET`  | `/api/analytics/experiments/:experimentKey` | Per-variant conversion rates and statistical significance for an A/B experiment. |
+
+You can also call these programmatically with the [CMS SDK](https://github.com/aymericzip/intlayer/blob/main/docs/docs/en/intlayer_CMS.md):
+
+```ts fileName="analytics.ts"
+import { createIntlayerCMS } from "@intlayer/api";
+import { analyticsEndpoint } from "@intlayer/api/analytics";
+
+const cms = createIntlayerCMS();
+
+const { data: audience } = await analyticsEndpoint(cms).getAudience(30);
+```
+
+## Useful links
+
+- [Dynamic Dictionaries - Collections & Variants](https://github.com/aymericzip/intlayer/blob/main/docs/docs/en/dynamic_dictionaries/index.md)
+- [Intlayer CMS - CMS SDK](https://github.com/aymericzip/intlayer/blob/main/docs/docs/en/intlayer_CMS.md)
+- [Intlayer Visual Editor](https://github.com/aymericzip/intlayer/blob/main/docs/docs/en/intlayer_visual_editor.md)
+- [Configuration Reference](https://github.com/aymericzip/intlayer/blob/main/docs/docs/en/configuration.md)
+- [Self-Hosting Guide](https://github.com/aymericzip/intlayer/blob/main/docs/docs/en/self_hosting.md)

package/docs/en/bundle_optimization.md

@@ -236,6 +236,9 @@ Next.js requires the `@intlayer/swc` plugin for the optimize (import rewriting)
 
 > This plugin is not installed by default because SWC plugins are still experimental for Next.js. It may change in the future.
 
+<Tabs>
+ <Tab value="npm">
+
 ```bash packageManager="npm"
 npm install -D @intlayer/swc
 ```
@@ -252,6 +255,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>
+
 Once installed, Intlayer will automatically detect and use the plugin.
 
 For the **purge and minify** passes (field removal and field renaming), install `@intlayer/babel` alongside and add the Babel plugins. Because Next.js uses SWC for transform but still evaluates `babel.config.js` for plugin configuration, the Babel plugins run as a pre-pass before SWC.

package/docs/en/cli/index.md

@@ -125,7 +125,7 @@ To see how to configure available locales, or other parameters, refer to the [co
 
 ### Authentication
 
-- **[Login](https://github.com/aymericzip/intlayer/blob/main/docs/docs/en/login.md)** - Authenticate with the Intlayer CMS and get access credentials
+- **[Login](https://github.com/aymericzip/intlayer/blob/main/docs/docs/en/cli/login.md)** - Authenticate with the Intlayer CMS and get access credentials
 
 ### Core Commands
 

package/docs/en/cli/scan.md

@@ -150,10 +150,10 @@ await scan("https://example.com", {
 });
 ```
 
-For lower-level access, `scanWebsite` from `@intlayer/chokidar/scan` returns a structured `ScanResult` object:
+For lower-level access, `scanWebsite` from `@intlayer/engine/scan` returns a structured `ScanResult` object:
 
 ```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);