@intlayer/docs 9.1.3 → 9.3.0

package/docs/es/analytics.md

@@ -0,0 +1,222 @@
+---
+createdAt: 2026-07-08
+updatedAt: 2026-07-08
+title: Intlayer Analytics | Seguimiento de la exposición del contenido y pruebas A/B
+description: Descubre cómo @intlayer/analytics rastrea las vistas de páginas/configuraciones regionales y la exposición del contenido, y cómo usarlo para ejecutar pruebas A/B en tu contenido de Intlayer.
+keywords:
+  - Analítica
+  - Pruebas A/B
+  - Audiencia
+  - Internacionalización
+  - Documentación
+  - Intlayer
+  - Next.js
+  - JavaScript
+  - React
+slugs:
+  - doc
+  - concept
+  - analytics
+history:
+  - version: 9.0.0
+    date: 2026-07-08
+    changes: "Init doc — paquete @intlayer/analytics, seguimiento a nivel de proveedor/nodo, pruebas A/B, panel de control"
+author: aymericzip
+---
+
+# Documentación de Intlayer Analytics
+
+`@intlayer/analytics` es un paquete complementario opcional que te indica **qué contenido se muestra realmente** a tus visitantes — qué página, en qué configuración regional (locale) y qué fragmento específico de contenido traducido — para que puedas entender a tu audiencia y ejecutar **pruebas A/B en el contenido**.
+
+## Tabla de Contenidos
+
+<TOC/>
+
+---
+
+## Qué rastrea
+
+`@intlayer/analytics` agrupa tres tipos de eventos anónimos:
+
+| Evento             | Dónde se captura                           | Qué te indica                                                                                                                 |
+| ------------------ | ------------------------------------------ | ----------------------------------------------------------------------------------------------------------------------------- |
+| `page_view`        | Nivel de proveedor (`IntlayerProvider`)    | Qué página y locale vio una sesión, en la carga inicial, cambio de ruta o cambio de locale.                                   |
+| `content_exposure` | Nivel de nodo (`useIntlayer` / plugins)    | Qué clave de diccionario / ruta de clave se resolvió y mostró realmente — y, si es parte de un experimento, qué **variante**. |
+| `conversion`       | Dondequiera que llames a `useConversion()` | Un objetivo alcanzado (registro, clic, compra...) atribuido a la variante A/B a la que se expuso la sesión.                   |
+
+Los eventos se recopilan en memoria y se envían como una **sola solicitud por lotes aproximadamente cada 20 segundos** — nunca en cada pulsación de tecla o renderizado — por lo que la analítica nunca afecta el tiempo de primer renderizado ni añade una solicitud por cada interacción.
+
+## Cómo impulsa las pruebas A/B en el contenido
+
+Intlayer ya te permite declarar [Variantes](https://github.com/aymericzip/intlayer/blob/main/docs/docs/es/dynamic_dictionaries/index.md) de contenido (por ejemplo, un diccionario `hero-banner` con una variante `control` y una `black_friday`). `@intlayer/analytics` cierra el ciclo:
+
+1. `getVariant(experimentKey, variants)` asigna de manera determinista cada sesión anónima a una variante — una función pura del id de sesión y la clave del experimento, por lo que la asignación es **estable durante toda la sesión** y no requiere **ida y vuelta al servidor** antes del primer renderizado (sin parpadeos, sin cambios de diseño).
+2. Cada evento de `content_exposure` lleva la `variant` que se mostró.
+3. `useConversion()` te permite atribuir un objetivo (por ejemplo, `"cta_click"`) a esa variante.
+4. El endpoint de resultados de experimentos del panel de control compara las tasas de conversión por variante, incluyendo la significancia estadística (una prueba z).
+
+## Instalación
+
+`@intlayer/analytics` es una dependencia **par y opcional** — nunca instalada automáticamente por un paquete de framework. Añádela junto a `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
+```
+
+Si no lo instalas, todos los puntos de integración se resuelven como una operación nula (no-op) — consulta [Costo cero cuando no está instalado](#costo-cero-cuando-no-esta-instalado) a continuación.
+
+## Configuración
+
+Analytics **reutiliza el bloque de configuración `editor` existente** — no hay un esquema de configuración `analytics` separado que rellenar:
+
+```typescript fileName="intlayer.config.ts" codeFormat={["typescript", "esm", "commonjs"]}
+import type { IntlayerConfig } from "intlayer";
+
+const config: IntlayerConfig = {
+  editor: {
+    backendURL: "https://back.intlayer.org", // También usado como endpoint de ingesta de analíticas
+    clientId: "your-client-id", // También usado como clave de proyecto de analíticas
+    clientSecret: "your-client-secret",
+  },
+};
+
+export default config;
+```
+
+- `editor.backendURL` — la URL base a la que se envían los eventos de analíticas (`POST {backendURL}/api/analytics/events`).
+- `editor.clientId` — la clave pública del proyecto atribuida a cada evento ingerido. También actúa como el **interruptor de encendido**: las analíticas permanecen totalmente desactivadas (y eliminadas del código final) hasta que se configura el `clientId`.
+
+Si autoalojas Intlayer, las analíticas apuntan automáticamente a tu propia instancia, ya que comparte `editor.backendURL`.
+
+## Soporte de frameworks
+
+Analytics está integrado en el `IntlayerProvider` compartido de `react-intlayer`, por lo que está disponible hoy en cualquier lugar donde se use ese proveedor:
+
+| Framework                                                | Estado                                                                                              |
+| -------------------------------------------------------- | --------------------------------------------------------------------------------------------------- |
+| React                                                    | ✅ Disponible                                                                                       |
+| Next.js (`next-intlayer`)                                | ✅ Disponible (a través de `react-intlayer`)                                                        |
+| React Native / Expo (`react-native-intlayer`)            | ✅ Disponible (a través de `react-intlayer`)                                                        |
+| Vue, Svelte, Angular, Solid, Preact, Lit, Astro, Vanilla | 🚧 Planeado — mismo cliente, enlaces a nivel de proveedor siguiendo el modelo de `@intlayer/editor` |
+
+## Uso
+
+### Seguimiento automático a nivel de proveedor
+
+No se requieren cambios en el código. Una vez que `@intlayer/analytics` está instalado y `editor.clientId` está configurado, `IntlayerProvider` automáticamente:
+
+- inicializa el cliente de analíticas al montarse,
+- registra un `page_view` en la carga inicial,
+- registra un `page_view` en cada cambio de locale,
+- inicia el ciclo de vaciado (flush) de ~20s y envía cualquier evento restante al desmontar / cerrar pestaña (vía `navigator.sendBeacon`, con respaldo a `fetch(..., { keepalive: true })`).
+
+### Seguimiento automático a nivel de nodo
+
+Cada vez que `useIntlayer` resuelve un fragmento de contenido para mostrar, el intérprete reporta un evento de `content_exposure` para esa exacta `dictionaryKey` + ruta de clave + locale — de nuevo, no se requieren cambios en el código. Las exposiciones repetidas del mismo nodo dentro de una ventana de vaciado se fusionan en un solo evento con un contador (`count`), por lo que una lista que se vuelve a renderizar 50 veces no envía 50 eventos.
+
+### Seguimiento de conversiones para pruebas A/B
+
+Usa `useConversion()` para atribuir un objetivo a la variante que vio una sesión:
+
+```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",
+        })
+      }
+    >
+      Empezar
+    </button>
+  );
+};
+```
+
+### Resolución de una variante en el lado del cliente
+
+```tsx fileName="useHeroVariant.ts" codeFormat="tsx"
+import { getGlobalAnalyticsClient } from "@intlayer/analytics/client";
+
+const client = getGlobalAnalyticsClient();
+const variant = client?.getVariant("homepage-hero", [
+  "control",
+  "black_friday",
+]);
+```
+
+## Privacidad y rendimiento
+
+- **Anónimo por diseño**: las sesiones se identifican mediante una ID rotatoria; el backend solo almacena un **hash SHA-256** de esa ID — nunca la ID en crudo, nunca una dirección IP.
+- **La ubicación es aproximada**: solo un código de país, derivado de las cabeceras de geolocalización del CDN (`cf-ipcountry`, `x-vercel-ip-country`, ...) — no se lee ni almacena ninguna IP.
+- **Las URLs excluyen los parámetros de búsqueda** por defecto, por lo que las cadenas de consulta nunca se capturan.
+- **Muestreo**: `sampleRate` te permite conservar solo una fracción de los eventos de exposición de contenido en aplicaciones con mucho tráfico.
+- **Por lotes**: una solicitud aproximadamente cada 20 segundos (`flushInterval`), o antes si el búfer se llena (`maxBufferSize`) — nunca una solicitud por evento.
+
+### Costo cero cuando no está instalado
+
+`@intlayer/analytics` sigue exactamente el mismo patrón de dependencia opcional que `@intlayer/editor`:
+
+- cada punto de integración carga el paquete a través de un **`import()` dinámico envuelto en `try/catch`** — una app que nunca instala `@intlayer/analytics` nunca paga un costo de tamaño de bundle o tiempo de ejecución, y nunca ve un error;
+- una variable de entorno en tiempo de compilación (`INTLAYER_ANALYTICS_ENABLED`), configurada automáticamente en `'false'` por `@intlayer/config` cuando `editor.clientId` no está configurado, permite a los empaquetadores **eliminar el código muerto** de toda la integración;
+- las analíticas se desactivan dentro del iframe de vista previa del editor/CMS de Intlayer, por lo que las sesiones de edición nunca se cuentan como tráfico real.
+
+## Panel de control: Página de Analíticas
+
+Una vez que tu proyecto haya recopilado eventos, la página de **Analytics** en el [panel de control de Intlayer](https://app.intlayer.org/analytics) (visible en la barra lateral una vez que se selecciona un proyecto) muestra:
+
+- **Usuarios activos** — visitantes únicos durante el período móvil seleccionado (7 / 30 / 90 días).
+- **Usuarios hoy** y **usuarios en los últimos 7 días**.
+- **Vistas de página** durante el período seleccionado.
+- Un **gráfico de evolución** de visitantes únicos diarios.
+- Pestañas de desglose de **Configuraciones regionales (Locales)** y **Ubicación**, clasificando tu audiencia por locale y por país.
+
+## Referencia de la API del Backend
+
+Todos los endpoints de lectura requieren autenticación; la ingesta es pública y se atribuye por el `clientId`.
+
+| Método | Endpoint                                    | Descripción                                                                           |
+| ------ | ------------------------------------------- | ------------------------------------------------------------------------------------- |
+| `POST` | `/api/analytics/events`                     | Ingerir un lote de eventos (público, atribuido por `clientId` en el cuerpo).          |
+| `GET`  | `/api/analytics/overview`                   | Totales de páginas/locales para el proyecto autenticado.                              |
+| `GET`  | `/api/analytics/audience?days=30`           | Visitantes únicos, vistas de página, serie diaria, desgloses por locale + país.       |
+| `GET`  | `/api/analytics/content-stats`              | Totales de exposición por contenido, agrupados por clave de diccionario/ruta/locale.  |
+| `GET`  | `/api/analytics/experiments/:experimentKey` | Tasas de conversión por variante y significancia estadística para un experimento A/B. |
+
+También puedes llamar a estos programáticamente con el [SDK del CMS](https://github.com/aymericzip/intlayer/blob/main/docs/docs/es/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);
+```
+
+## Enlaces útiles
+
+- [Diccionarios Dinámicos - Colecciones y Variantes](https://github.com/aymericzip/intlayer/blob/main/docs/docs/es/dynamic_dictionaries/index.md)
+- [CMS de Intlayer - SDK del CMS](https://github.com/aymericzip/intlayer/blob/main/docs/docs/es/intlayer_CMS.md)
+- [Editor Visual de Intlayer](https://github.com/aymericzip/intlayer/blob/main/docs/docs/es/intlayer_visual_editor.md)
+- [Referencia de Configuración](https://github.com/aymericzip/intlayer/blob/main/docs/docs/es/configuration.md)
+- [Guía de Autoalojamiento](https://github.com/aymericzip/intlayer/blob/main/docs/docs/es/self_hosting.md)

package/docs/es/autoFill.md

@@ -75,11 +75,30 @@ En v7, el comportamiento del comando `fill` ha sido actualizado:
 
 Cuando se utiliza una opción de ruta para escribir en otro archivo, el mecanismo de completación funciona a través de una relación _maestro-esclavo_ entre archivos de declaración de contenido. El archivo principal (maestro) sirve como la fuente de verdad, y cuando se actualiza, Intlayer aplicará automáticamente esos cambios a los archivos de declaración completados (derivados) especificados por la ruta.
 
-# Traducciones de Archivos de Declaración de Contenido con Relleno Automático
+### Personalización por Locale
 
-**Los archivos de declaración de contenido con relleno automático** son una forma de acelerar tu flujo de trabajo de desarrollo.
+También puedes personalizar el comportamiento de cada locale utilizando un objeto:
 
-El mecanismo de relleno automático funciona mediante una relación _maestro-esclavo_ entre archivos de declaración de contenido. Cuando el archivo principal (maestro) se actualiza, Intlayer aplicará automáticamente esos cambios a los archivos de declaración derivados (rellenados automáticamente).
+```ts fileName="intlayer.config.ts"
+const config: IntlayerConfig = {
+  content: {
+    internationalization: {
+      locales: [Locales.ENGLISH, Locales.FRENCH, Locales.POLISH],
+      defaultLocale: Locales.ENGLISH,
+      requiredLocales: [Locales.ENGLISH], // Recomendado para evitar Property 'pl' is missing in type '{ en: string; xxx } on your t function if
+    },
+  },
+  dictionary: {
+    fill: {
+      en: true, // Llenar y editar el archivo actual para inglés
+      fr: "./translations/fr.json", // Crear archivo separado para francés
+      es: false, // Desactivar fill para español
+    },
+  },
+};
+```
+
+Esto te permite tener diferentes comportamientos de fill para diferentes locales dentro del mismo proyecto.
 
 ```ts fileName="src/components/example/example.content.ts"
 import { Locales, type Dictionary } from "intlayer";
@@ -87,16 +106,16 @@ import { Locales, type Dictionary } from "intlayer";
 const exampleContent = {
   key: "example",
   locale: Locales.ENGLISH,
-  autoFill: "./example.content.json",
+  fill: "./example.content.json",
   content: {
-    contentExample: "Este es un ejemplo de contenido",
+    contentExample: "This is an example of content",
   },
 } satisfies Dictionary;
 
 export default exampleContent;
 ```
 
-Aquí hay un [archivo de declaración de contenido por idioma](https://github.com/aymericzip/intlayer/blob/main/docs/docs/es/per_locale_file.md) que usa la instrucción `autoFill`.
+Aquí hay un [archivo de declaración de contenido por locale](https://github.com/aymericzip/intlayer/blob/main/docs/docs/es/per_locale_file.md) usando la instrucción `fill`.
 
 Luego, cuando ejecutes el siguiente comando:
 
@@ -116,7 +135,7 @@ pnpm intlayer fill --file 'src/components/example/example.content.ts'
 bun x intlayer fill --file 'src/components/example/example.content.ts'
 ```
 
-Intlayer generará automáticamente el archivo de declaración derivado en `src/components/example/example.content.json`, completando todos los locales que no estén ya declarados en el archivo principal.
+Intlayer generará automáticamente el archivo de declaración derivado en `src/components/example/example.content.json`, llenando todos los locales que aún no estén declarados en el archivo principal.
 
 ```json5 fileName="src/components/example/example.content.json"
 {
@@ -125,15 +144,15 @@ Intlayer generará automáticamente el archivo de declaración derivado en `src/
     "contentExample": {
       "nodeType": "translation",
       "translation": {
-        "fr": "Ceci est un exemple de contenu",
         "es": "Este es un ejemplo de contenido",
+        "fr": "Ceci est un exemple de contenu",
       },
     },
   },
 }
 ```
 
-Después, ambos archivos de declaración se fusionarán en un único diccionario, accesible mediante el hook estándar `useIntlayer("example")` (react) / composable (vue).
+Posteriormente, ambos archivos de declaración se fusionarán en un único diccionario, accesible mediante el hook `useIntlayer("example")` estándar (react) / composable (vue).
 
 ## Configuración Global
 

package/docs/es/bundle_optimization.md

@@ -1,6 +1,6 @@
 ---
 createdAt: 2025-11-25
-updatedAt: 2026-06-07
+updatedAt: 2026-08-09
 title: Optimización del tamaño y rendimiento del paquete i18n
 description: Reduce el tamaño del paquete de tu aplicación optimizando el contenido de internacionalización (i18n). Aprende cómo aprovechar el tree shaking y el lazy loading para diccionarios con Intlayer.
 keywords:
@@ -16,6 +16,12 @@ slugs:
   - concept
   - bundle-optimization
 history:
+  - version: 9.2.1
+    date: 2026-08-09
+    changes: "`purge` y `minify` ahora funcionan en Next.js a través de `@intlayer/swc` — no se requiere `babel.config.js`"
+  - version: 8.12.0
+    date: 2026-06-24
+    changes: "Listar los plugins de Babel en el orden de pipeline requerido (extract → purge → minify → optimize) en las tablas de referencia"
   - version: 8.12.0
     date: 2026-06-07
     changes: "Añadidos `intlayerPurgeBabelPlugin` y `intlayerMinifyBabelPlugin` para Babel/Webpack; aclaración del flujo de plugins"
@@ -191,12 +197,14 @@ La optimización de compilación de Intlayer se divide en varios complementos di
 
 Se utilizan directamente en `babel.config.js` para configuraciones basadas en Webpack (Next.js con Babel, CRA, Webpack personalizado, etc.).
 
+La siguiente tabla los enumera en su orden de pipeline requerido (el mismo orden en que deben aparecer en `babel.config.js`):
+
 | Plugin                        | Qué hace                                                                                                                                    |
 | :---------------------------- | :------------------------------------------------------------------------------------------------------------------------------------------ |
 | `intlayerExtractBabelPlugin`  | Analiza archivos `.content.ts` y escribe los diccionarios compilados en `.intlayer/`                                                        |
-| `intlayerOptimizeBabelPlugin` | Reescribe `useIntlayer('key')` → `useDictionary(hash)` e inyecta la declaración `import` del diccionario correspondiente                    |
 | `intlayerPurgeBabelPlugin`    | Analiza todos los archivos fuente y elimina **los campos de contenido no utilizados** de los archivos JSON `.intlayer/**/*.json`            |
 | `intlayerMinifyBabelPlugin`   | **Renombra las claves de campos de contenido** por alias alfabéticos cortos (`title` → `a`) tanto en archivos JSON como en el código fuente |
+| `intlayerOptimizeBabelPlugin` | Reescribe `useIntlayer('key')` → `useDictionary(hash)` e inyecta la declaración `import` del diccionario correspondiente                    |
 
 > **El orden de los plugins es importante.** En tu `babel.config.js`, los complementos de purga (purge) y minificación (minify) deben aparecer **antes** del complemento de optimización. La fase de optimización reemplaza `useIntlayer('key')` con una llamada opaca `useDictionary(hash)`, lo que borra la información de clave del diccionario que las fases de purga y minificación necesitan para saber qué campos se usan.
 
@@ -205,9 +213,9 @@ Cada complemento de Babel cuenta con una función auxiliar de opciones que lee t
 | Helper de opciones           | Utilizado con                 |
 | :--------------------------- | :---------------------------- |
 | `getExtractPluginOptions()`  | `intlayerExtractBabelPlugin`  |
-| `getOptimizePluginOptions()` | `intlayerOptimizeBabelPlugin` |
 | `getPurgePluginOptions()`    | `intlayerPurgeBabelPlugin`    |
 | `getMinifyPluginOptions()`   | `intlayerMinifyBabelPlugin`   |
+| `getOptimizePluginOptions()` | `intlayerOptimizeBabelPlugin` |
 
 ### Plugins de Vite (`vite-intlayer`)
 
@@ -220,6 +228,20 @@ Los usuarios de Vite **nunca los configuran directamente**. Se vinculan de forma
 | Minificar diccionario  | Igual que la fase de escritura JSON del `intlayerMinifyBabelPlugin`                                          |
 | Transformación Babel   | Igual que la fase de renombramiento en código de `intlayerMinifyBabelPlugin` + `intlayerOptimizeBabelPlugin` |
 
+### Plugin SWC (`@intlayer/swc`)
+
+Los usuarios de Next.js **tampoco configuran esto directamente**. Desde la **v9.2.1**, `withIntlayer()` en `next.config.ts` ejecuta el pipeline completo — purga, minificación y reescritura de imports — únicamente a partir de las banderas `build.purge` y `build.minify`.
+
+El trabajo se divide en dos, porque un plugin Wasm de SWC transforma un archivo a la vez y sin acceso al sistema de archivos:
+
+| Pasada                                                 | Dónde se ejecuta                 | Qué hace                                                                                                  |
+| :----------------------------------------------------- | :------------------------------- | :-------------------------------------------------------------------------------------------------------- |
+| Análisis de uso + purga/minificación de JSON           | Node, dentro de `withIntlayer()` | Lee cada archivo fuente de componente, reescribe `.intlayer/**/*.json` y produce las tablas de renombrado |
+| Reescritura del código fuente (`content.title` → `.a`) | `@intlayer/swc` (Wasm)           | Aplica las tablas de renombrado a los accesos a propiedades correspondientes en tu código                 |
+| Reescritura de imports (`useIntlayer` → dict)          | `@intlayer/swc` (Wasm)           | Igual que `intlayerOptimizeBabelPlugin`                                                                   |
+
+Decidir _qué_ campos no se usan y _qué_ alias recibe cada uno requiere estado entre archivos y E/S de archivos, por lo que esa mitad se ejecuta en Node; el plugin SWC solo recibe las tablas resultantes.
+
 ## Configuración por plataforma
 
 <Tabs>
@@ -227,10 +249,12 @@ Los usuarios de Vite **nunca los configuran directamente**. Se vinculan de forma
 
 ### Next.js
 
-Next.js requiere el complemento `@intlayer/swc` para la fase de optimización (reescritura de importaciones) ya que Next.js emplea SWC en las compilaciones.
+Next.js requiere el plugin `@intlayer/swc`, porque Next.js usa SWC para las compilaciones. Desde la **v9.2.1**, este único paquete cubre todo el pipeline: optimización (reescritura de imports), purga y minificación.
 
 > Este complemento no se instala por defecto ya que los complementos SWC son experimentales en Next.js. Podría cambiar en el futuro.
 
+> **Next.js 16.1.0 es la versión mínima.** Es la primera versión construida sobre la ABI de plugins Wasm compatible hacia adelante de SWC; las versiones anteriores rechazan el plugin. `withIntlayer` lee tu versión de Next.js y simplemente no registra el plugin por debajo de 16.1.0 — esas compilaciones siguen teniendo éxito, solo se ejecutan sin la optimización del bundle.
+
 <Tabs>
  <Tab value="npm">
 
@@ -265,33 +289,40 @@ intlayer-swc-plugin = "*"
 
 Una vez instalado, Intlayer detectará y utilizará automáticamente el complemento.
 
-Para las fases de **purga y minificación** (eliminación de campos y renombramiento), instala de manera adicional `@intlayer/babel` y añade los complementos de Babel. Debido a que Next.js usa SWC para la transformación pero aún evalúa `babel.config.js` para la configuración, estos complementos de Babel se ejecutan en un paso previo antes de SWC.
+Las pasadas de **purga y minificación** (eliminación y renombrado de campos) no requieren ningún paquete adicional ni `babel.config.js`. Envuelve tu configuración con `withIntlayer` y activa las banderas en `intlayer.config.ts`:
 
-```bash packageManager="npm"
-npm install -D @intlayer/babel
+```typescript fileName="next.config.ts"
+import { withIntlayer } from "next-intlayer/server";
+import type { NextConfig } from "next";
+
+const nextConfig: NextConfig = {/* tu configuración */};
+
+export default withIntlayer(nextConfig);
 ```
 
-```javascript fileName="babel.config.js"
-const {
-  intlayerPurgeBabelPlugin,
-  intlayerMinifyBabelPlugin,
-  getPurgePluginOptions,
-  getMinifyPluginOptions,
-} = require("@intlayer/babel");
+```typescript fileName="intlayer.config.ts"
+import type { IntlayerConfig } from "intlayer";
 
-module.exports = {
-  presets: ["next/babel"],
-  plugins: [
-    // Purga: eliminar los campos de contenido no usados de .intlayer/**/*.json
-    [intlayerPurgeBabelPlugin, getPurgePluginOptions()],
-    // Minificar: renombrar claves de campos en el JSON y el código fuente
-    [intlayerMinifyBabelPlugin, getMinifyPluginOptions()],
-    // Nota: intlayerOptimizeBabelPlugin NO es necesario aquí porque
-    // @intlayer/swc se encarga de reescribir useIntlayer → useDictionary.
-  ],
+const config: IntlayerConfig = {
+  build: {
+    purge: true, // elimina los campos de contenido no usados del JSON empaquetado
+    minify: true, // renombra las claves de campos a alias cortos
+  },
 };
+
+export default config;
 ```
 
+Durante `next build`, `withIntlayer` analiza tus fuentes, reescribe los diccionarios compilados y pasa las tablas de renombrado resultantes a `@intlayer/swc`, que actualiza los accesos a propiedades correspondientes en tu código.
+
+> Usa el `withIntlayer` asíncrono, no `withIntlayerSync`. La variante síncrona no ejecuta el pipeline de análisis, por lo que la purga y la minificación no tienen efecto con ella.
+
+> La purga y la minificación solo se ejecutan en `next build` — el pipeline de optimización está desactivado durante `next dev`.
+
+> También se desactivan cuando hay llamadores de adaptadores de compatibilidad configurados (`swcExtraCallers`, establecidos por los paquetes de compatibilidad como `@intlayer/next-intl` o `@intlayer/react-i18next`): esos puntos de llamada son invisibles para el analizador de uso, por lo que purgar eliminaría campos que el código todavía lee. La reescritura de imports permanece activa.
+
+**Las versiones anteriores (antes de 9.2.1)** requerían `@intlayer/babel` y un `babel.config.js` que declarara `intlayerPurgeBabelPlugin` e `intlayerMinifyBabelPlugin`. Ese archivo ya no es necesario y puede eliminarse.
+
  </Tab>
  <Tab value="vite">
 
@@ -447,6 +478,8 @@ export default config;
 
 > La minificación se omite cuando `optimize` es `false` o cuando `editor.enabled` es `true` (el Editor Visual requiere de los nombres de los campos originales para editarlos).
 
+> En Next.js, la minificación también se omite cuando `@intlayer/swc` no está instalado o no puede cargarse (Next.js por debajo de 16.1.0). El plugin es la mitad que reescribe los accesos en el código fuente, así que renombrar los diccionarios sin él dejaría tu código leyendo nombres de campos que ya no existen.
+
 > La minificación también se omite con diccionarios de `importMode: 'fetch'`, dado que esos JSON son provistos por una API de terceros bajo sus nombres de campos originales; renombrarlo en el cliente perjudicaría a esa sincronización.
 
 ### Purga (eliminación de campos no utilizados)
@@ -475,7 +508,7 @@ export default config;
 { "title": "…", "subtitle": "…" }
 ```
 
-> La purga se omite cuando `optimize` es `false` o cuando `editor.enabled` es `true`.
+> La purga se omite cuando `optimize` es `false` o cuando `editor.enabled` es `true`. En Next.js se omite además cuando `@intlayer/swc` no está disponible y cuando hay llamadores de adaptadores de compatibilidad configurados.
 
 > La purga también se omite por protección cuando un archivo del código fuente sea irreparable y no logre ejecutarse `useIntlayer` al mismo tiempo que una destructuración. Por lo cual todo el diccionario pasaría a formar parte por completo y sin purgar.
 

package/docs/es/configuration.md

@@ -1,6 +1,6 @@
 ---
 createdAt: 2024-08-13
-updatedAt: 2026-07-11
+updatedAt: 2026-08-06
 title: Configuración (Configuration)
 description: Aprenda a configure Intlayer para su aplicación. Entienda los diversos ajustes y opciones disponibles para personalizar Intlayer según sus necesidades.
 keywords:
@@ -14,6 +14,9 @@ slugs:
   - concept
   - configuration
 history:
+  - version: 9.1.3
+    date: 2026-08-06
+    changes: "Hacer `routing.enableProxy` de tres estados: sin definir (auto), `true`, `false`"
   - version: 9.0.0
     date: 2026-07-11
     changes: "Se añadió la configuración `analytics`"
@@ -235,6 +238,19 @@ const config: IntlayerConfig = {
      */
     mode: "prefix-no-default",
 
+    /**
+     * Activa el proxy de enrutamiento de locales de Intlayer (middleware).
+     * Gestiona la detección de locale, redirecciones y reescrituras en dev, preview y SSR.
+     * - sin definir (auto): los servidores de dev y preview mantienen el enrutamiento
+     *   guiado por la URL ignorando el locale almacenado en cookies y cabeceras.
+     *   Los prefijos se siguen resolviendo, el locale se sigue persistiendo y la
+     *   detección Accept-Language se sigue aplicando. En producción se comporta como `true`.
+     * - true: comportamiento completo en todos los entornos.
+     * - false: sin enrutamiento de locales.
+     * Por defecto: undefined (auto)
+     */
+    enableProxy: undefined,
+
     /**
      * Dónde almacenar la localidad seleccionada por el usuario.
      * Opciones: 'cookie', 'localStorage', 'sessionStorage', 'header' o una combinación de estos.
@@ -716,12 +732,13 @@ Las analíticas son estrictamente opcionales (opt-in): no se recopila nada a men
 
 Ajustes que controlan el comportamiento del enrutamiento, incluida la estructura de la URL, el almacenamiento de localidades y el manejo del middleware.
 
-| Campo      | Descripción                                                                                                                                                  | Tipo                                                                                                                                                                                                         | Predeterminado         | Ejemplo                                                                                                                                                                                         | Nota                                                                                                                                                                                                                                                                                                              |
-| ---------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ---------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `mode`     | Modo de enrutamiento de URL para el manejo de localidades (locales).                                                                                         | `'prefix-no-default'` &#124; <br/> `'prefix-all'` &#124; <br/> `'no-prefix'` &#124; <br/> `'search-params'`                                                                                                  | `'prefix-no-default'`  | `'prefix-no-default'`: `/dashboard` (en) o `/fr/dashboard` (fr). `'prefix-all'`: `/en/dashboard`. `'no-prefix'`: localidad manejada por otros medios. `'search-params'`: `/dashboard?locale=fr` | No afecta la gestión de galletas (cookies) o el almacenamiento de localidades.                                                                                                                                                                                                                                    |
-| `storage`  | Configuración para almacenar la localidad (locale) en el cliente.                                                                                            | `false` &#124; <br/> `'cookie'` &#124; <br/> `'localStorage'` &#124; <br/> `'sessionStorage'` &#124; <br/> `'header'` &#124; <br/> `CookiesAttributes` &#124; <br/> `StorageAttributes` &#124; <br/> `Array` | `['cookie', 'header']` | `'localStorage'` <br/> `[{ type: 'cookie', name: 'custom-locale', secure: true }]`                                                                                                              | Consulte la tabla de Opciones de Almacenamiento más abajo.                                                                                                                                                                                                                                                        |
-| `basePath` | Ruta base para las URL de la aplicación.                                                                                                                     | `string`                                                                                                                                                                                                     | `''`                   | `'/my-app'`                                                                                                                                                                                     | Si la aplicación está en `https://example.com/my-app`, basePath es `'/my-app'` y las URL se convierten en `https://example.com/my-app/en`.                                                                                                                                                                        |
-| `rewrite`  | Reglas de reescritura de URL personalizadas que anulan el modo de enrutamiento predeterminado para rutas específicas. Admite parámetros dinámicos `[param]`. | `Record<string, StrictModeLocaleMap<string>>`                                                                                                                                                                | `undefined`            | Ver ejemplo abajo                                                                                                                                                                               | • Las reglas de reescritura tienen prioridad sobre `mode`.<br/>• Funciona con Next.js y Vite.<br/>• `getLocalizedUrl()` aplica automáticamente las reglas correspondientes.<br/>• Ver [Reescrituras de URL Personalizadas](https://github.com/aymericzip/intlayer/blob/main/docs/docs/es/custom_url_rewrites.md). |
+| Campo         | Descripción                                                                                                                                                  | Tipo                                                                                                                                                                                                         | Predeterminado         | Ejemplo                                                                                                                                                                                         | Nota                                                                                                                                                                                                                                                                                                                                                                                                                                 |
+| ------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ---------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| `mode`        | Modo de enrutamiento de URL para el manejo de localidades (locales).                                                                                         | `'prefix-no-default'` &#124; <br/> `'prefix-all'` &#124; <br/> `'no-prefix'` &#124; <br/> `'search-params'`                                                                                                  | `'prefix-no-default'`  | `'prefix-no-default'`: `/dashboard` (en) o `/fr/dashboard` (fr). `'prefix-all'`: `/en/dashboard`. `'no-prefix'`: localidad manejada por otros medios. `'search-params'`: `/dashboard?locale=fr` | No afecta la gestión de galletas (cookies) o el almacenamiento de localidades.                                                                                                                                                                                                                                                                                                                                                       |
+| `enableProxy` | Activa el proxy de enrutamiento de locales de Intlayer (middleware).                                                                                         | `boolean` &#124; <br/> `undefined`                                                                                                                                                                           | `undefined` (auto)     | `true`                                                                                                                                                                                          | • Sin definir (auto): los servidores de dev y preview ignoran el locale almacenado en cookies/cabeceras como fuente de redirección; los prefijos, la persistencia y la detección `Accept-Language` se siguen aplicando. En producción se comporta como `true`.<br/>• `true`: comportamiento completo en todas partes.<br/>• `false`: sin enrutamiento de locales. En Next.js, el middleware `intlayerProxy` pasa a ser transparente. |
+| `storage`     | Configuración para almacenar la localidad (locale) en el cliente.                                                                                            | `false` &#124; <br/> `'cookie'` &#124; <br/> `'localStorage'` &#124; <br/> `'sessionStorage'` &#124; <br/> `'header'` &#124; <br/> `CookiesAttributes` &#124; <br/> `StorageAttributes` &#124; <br/> `Array` | `['cookie', 'header']` | `'localStorage'` <br/> `[{ type: 'cookie', name: 'custom-locale', secure: true }]`                                                                                                              | Consulte la tabla de Opciones de Almacenamiento más abajo.                                                                                                                                                                                                                                                                                                                                                                           |
+| `basePath`    | Ruta base para las URL de la aplicación.                                                                                                                     | `string`                                                                                                                                                                                                     | `''`                   | `'/my-app'`                                                                                                                                                                                     | Si la aplicación está en `https://example.com/my-app`, basePath es `'/my-app'` y las URL se convierten en `https://example.com/my-app/en`.                                                                                                                                                                                                                                                                                           |
+| `rewrite`     | Reglas de reescritura de URL personalizadas que anulan el modo de enrutamiento predeterminado para rutas específicas. Admite parámetros dinámicos `[param]`. | `Record<string, StrictModeLocaleMap<string>>`                                                                                                                                                                | `undefined`            | Ver ejemplo abajo                                                                                                                                                                               | • Las reglas de reescritura tienen prioridad sobre `mode`.<br/>• Funciona con Next.js y Vite.<br/>• `getLocalizedUrl()` aplica automáticamente las reglas correspondientes.<br/>• Ver [Reescrituras de URL Personalizadas](https://github.com/aymericzip/intlayer/blob/main/docs/docs/es/custom_url_rewrites.md).                                                                                                                    |
 
 **Ejemplo de `rewrite`**:
 

package/docs/es/dictionary/file.md

@@ -23,7 +23,9 @@ history:
 author: aymericzip
 ---
 
-# Contenido de Archivo / Incrustar Archivos en Intlayer
+# Contenido de Archivo / Integración de Archivos en Intlayer
+
+En Intlayer, la función `file` permite incrustar contenido de archivos externos en un diccionario. Este enfoque garantiza que Intlayer reconozca el archivo fuente, permitiendo una integración fluida con el Editor Visual de Intlayer y CMS.
 
 ## Cómo Funciona la Incrustación de Archivos