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

package/docs/pt/intlayer_with_vite+vue.md

@@ -619,14 +619,17 @@ Paralelamente, você também pode usar o `intlayerProxy` para adicionar roteamen
 ```typescript {3,7} fileName="vite.config.ts" codeFormat={["typescript", "esm", "commonjs"]}
 import { defineConfig } from "vite";
 import vue from "@vitejs/plugin-vue";
-import { intlayer, intlayerProxy } from "vite-intlayer";
+import { intlayer } from "vite-intlayer";
 
 // https://vitejs.dev/config/
 export default defineConfig({
   plugins: [
-    intlayerProxy(), // should be placed first
     vue(),
-    intlayer(),
+    intlayer({
+      proxy: {
+        ignore: (req) => req.url?.startsWith("/api"),
+      },
+    }),
   ],
 });
 ```
@@ -1005,6 +1008,8 @@ bun x intlayer extract
  </Tab>
  <Tab value='Compilador Babel'>
 
+> Since v9, the `intlayerCompiler` is included in the `intlayer` plugin. So you don't need to add it manually.
+
 Atualize seu `vite.config.ts` para incluir o plugin `intlayerCompiler`:
 
 ```ts fileName="vite.config.ts"
@@ -1014,7 +1019,7 @@ import { intlayer, intlayerCompiler } from "vite-intlayer";
 export default defineConfig({
   plugins: [
     intlayer(),
-    intlayerCompiler(), // Adiciona o plugin do compilador
+    intlayerCompiler(), // Adds the compiler plugin
   ],
 });
 ```

package/docs/pt/packages/@intlayer_babel/export.md

@@ -0,0 +1,131 @@
+---
+createdAt: 2026-06-25
+updatedAt: 2026-06-25
+title: "Documentação do pacote @intlayer/babel"
+description: Plugins do Babel para o Intlayer para lidar com extração de conteúdo, otimização de importação, limpeza de campos não utilizados e ofuscação de nomes de campos durante a compilação.
+keywords:
+  - "@intlayer/babel"
+  - babel
+  - plugin
+  - internacionalização
+  - i18n
+  - compilador
+  - otimizar
+  - limpar
+  - minificar
+slugs:
+  - doc
+  - packages
+  - "@intlayer/babel"
+  - export
+history:
+  - version: 9.0.0
+    date: 2026-06-25
+    changes: "Documentação unificada de todas as exportações"
+author: aymericzip
+---
+
+# Pacote @intlayer/babel
+
+O pacote `@intlayer/babel` fornece um conjunto de plugins especializados do Babel para o Intlayer. Esses plugins cobrem todo o ciclo de build: extração de declarações de conteúdo, reescrita de chamadas `useIntlayer` / `getIntlayer` para importações de dicionário otimizadas, limpeza de campos não utilizados e minificação de nomes de campos.
+
+## Instalação
+
+```bash
+npm install @intlayer/babel
+```
+
+## Exportações
+
+Importar:
+
+```ts
+import { ... } from "@intlayer/babel";
+```
+
+---
+
+### Plugins
+
+| Função / Classe                | Descrição                                                                                                                                                                                                                |
+| ------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| `intlayerExtractBabelPlugin`   | Plugin do Babel que extrai conteúdo traduzível de arquivos-fonte e injeta ganchos (hooks) `useIntlayer` / `getIntlayer` automaticamente. Projetado para uso com o Next.js e ferramentas de compilação baseadas em Babel. |
+| `intlayerOptimizeBabelPlugin`  | Plugin do Babel que transforma chamadas `useIntlayer` e `getIntlayer` e reescreve suas importações para importações de dicionário JSON otimizadas (estáticas, dinâmicas ou via fetch).                                   |
+| `intlayerPurgeBabelPlugin`     | Plugin do Babel que analisa arquivos-fonte e reescreve arquivos JSON de dicionário compilados para remover campos não utilizados (`build.purge`) ou renomeá-los para aliases curtos (`build.minify`).                    |
+| `intlayerMinifyBabelPlugin`    | Plugin do Babel que reescreve arquivos-fonte para usar os aliases curtos de campo atribuídos durante a fase de minificação (por exemplo, `content.title` ← `content.a`). Depende do `intlayerPruneBabelPlugin`.          |
+| `makeFieldRenameBabelPlugin`   | Função factory que produz um plugin do Babel para renomear acessos a campos de conteúdo de dicionário em arquivos-fonte de acordo com o `dictionaryKeyToFieldRenameMap` preenchido no `PruneContext`.                    |
+| `makeUsageAnalyzerBabelPlugin` | Função factory que produz um plugin do Babel para analisar o uso de `useIntlayer` / `getIntlayer` no código-fonte e agregar dados de uso de campo no `PruneContext` compartilhado.                                       |
+| `getSharedPruneContext`        | Função auxiliar que retorna o objeto `PruneContext` compartilhado para o diretório base especificado, ou `null` se ainda não tiver sido inicializado.                                                                    |
+
+---
+
+### Utilitários de Configuração de Plugins
+
+| Função                     | Descrição                                                                                                                                              |
+| -------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| `getExtractPluginOptions`  | Carrega a configuração do Intlayer e retorna `ExtractPluginOptions` prontas para uso com o `intlayerExtractBabelPlugin`.                               |
+| `getOptimizePluginOptions` | Carrega a configuração do Intlayer e os dicionários compilados e retorna `OptimizePluginOptions` prontas para uso com o `intlayerOptimizeBabelPlugin`. |
+| `getPurgePluginOptions`    | Carrega a configuração do Intlayer e retorna `PurgePluginOptions` prontas para uso com o `intlayerPurgeBabelPlugin`.                                   |
+| `getMinifyPluginOptions`   | Carrega a configuração do Intlayer e retorna `MinifyPluginOptions` prontas para uso com o `intlayerMinifyBabelPlugin`.                                 |
+
+---
+
+### Tipos
+
+| Tipo                    | Descrição                                                                                                                                    |
+| ----------------------- | -------------------------------------------------------------------------------------------------------------------------------------------- |
+| `CompilerMode`          | Modo do compilador: `'dev'` para desenvolvimento com suporte HMR, ou `'build'` para compilações de produção.                                 |
+| `ExtractPluginOptions`  | Opções para o `intlayerExtractBabelPlugin`: lista de arquivos, configuração, callback `onExtract`, etc.                                      |
+| `ExtractResult`         | Resultado da extração: chave do dicionário, caminho do arquivo, conteúdo e idioma.                                                           |
+| `OptimizePluginOptions` | Opções para o `intlayerOptimizeBabelPlugin`: caminhos do dicionário, modo de importação, mapa de modos por dicionário, etc.                  |
+| `PurgePluginOptions`    | Opções para o `intlayerPurgeBabelPlugin`: diretório base, sinalizadores de limpeza/minificação/otimização, lista de arquivos de componentes. |
+| `MinifyPluginOptions`   | Opções para o `intlayerMinifyBabelPlugin`: diretório base, sinalizadores de minificação/otimização/editorEnabled.                            |
+| `PruneContext`          | Estado compartilhado entre plugins de análise e limpeza: mapas de uso de campo, mapas de renomeação, etc.                                    |
+| `DictionaryFieldUsage`  | Resultado do uso do campo para um único dicionário: `Set<string>` ou `'all'` quando a análise estática é inconclusiva.                       |
+| `NestedRenameEntry`     | Nó na árvore de renomeação: o `shortName` e o mapa de filhos.                                                                                |
+| `NestedRenameMap`       | Um nível na árvore de renomeação: `Map<string, NestedRenameEntry>`.                                                                          |
+| `CompatCallerConfig`    | Configuração para um analisador de uso compatível para pacotes compat-adapter (nome do chamador e opções de processamento).                  |
+| `ScriptBlock`           | Bloco de script extraído de um arquivo SFC (Vue ou Svelte): conteúdo, deslocamento de início e deslocamento de fim.                          |
+
+---
+
+### Funções Utilitárias
+
+| Função                            | Descrição                                                                                                                                                                             |
+| --------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `generateShortFieldName`          | Converte um número inteiro (começando do zero) em um identificador alfabético curto: `0` → `'a'`, `25` → `'z'`, `26` → `'aa'`, etc.                                                   |
+| `buildNestedRenameMapFromContent` | Constrói recursivamente um `NestedRenameMap` a partir do valor do conteúdo de um dicionário compilado, respeitando as estruturas de nós do Intlayer (translation, enumeration, etc.). |
+| `createPruneContext`              | Cria um novo objeto `PruneContext` vazio inicializado com valores padrão.                                                                                                             |
+| `extractScriptBlocks`             | Extrai blocos `<script>` de arquivos SFC (Vue / Svelte) para análise subsequente do Babel.                                                                                            |
+| `BABEL_PARSER_OPTIONS`            | Constante que representa as opções do analisador do Babel que cobrem os frameworks suportados (React/Vue/Svelte/Angular/...).                                                         |
+| `INTLAYER_CALLER_NAMES`           | Lista constante de nomes de chamadores originais do Intlayer: `['useIntlayer', 'getIntlayer']`.                                                                                       |
+
+---
+
+## Exemplo de Uso
+
+```js
+// babel.config.js
+const {
+  intlayerExtractBabelPlugin,
+  intlayerPurgeBabelPlugin,
+  intlayerMinifyBabelPlugin,
+  intlayerOptimizeBabelPlugin,
+  getExtractPluginOptions,
+  getPurgePluginOptions,
+  getMinifyPluginOptions,
+  getOptimizePluginOptions,
+} = require("@intlayer/babel");
+
+module.exports = {
+  presets: ["next/babel"],
+  plugins: [
+    [intlayerExtractBabelPlugin, getExtractPluginOptions()],
+    [intlayerPurgeBabelPlugin, getPurgePluginOptions()],
+    [intlayerMinifyBabelPlugin, getMinifyPluginOptions()],
+    [intlayerOptimizeBabelPlugin, getOptimizePluginOptions()],
+  ],
+};
+```
+
+> **Nota:** O plugin `intlayerPurgeBabelPlugin` deve ser declarado **antes** do `intlayerMinifyBabelPlugin`, porque o último lê o mapa de renomeação construído pelo primeiro. Além disso, ambos devem ser precedidos pelo `intlayerOptimizeBabelPlugin` para que ele possa ver as chaves do dicionário antes que as chamadas do `useIntlayer` sejam reescritas.

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

@@ -0,0 +1,120 @@
+---
+createdAt: 2026-06-25
+updatedAt: 2026-06-25
+title: Documentação do plugin Vite intlayerCompiler | vite-intlayer
+description: Plugin do Vite que extrai declarações de conteúdo embutidas do Intlayer de arquivos de componentes e as grava em arquivos JSON de dicionário no momento da compilação/transformação.
+keywords:
+  - intlayerCompiler
+  - vite
+  - plugin
+  - compilador
+  - conteúdo
+  - dicionário
+  - internacionalização
+  - i18n
+slugs:
+  - doc
+  - packages
+  - vite-intlayer
+  - intlayerCompiler
+history:
+  - version: 9.0.0
+    date: 2026-06-25
+    changes: "Integrado no intlayer(); inicialização da doc"
+author: aymericzip
+---
+
+# intlayerCompiler
+
+O `intlayerCompiler` é um plugin do Vite que varre os arquivos de código-fonte dos componentes em busca de **declarações de conteúdo embutidas do Intlayer** — conteúdo definido diretamente dentro de um componente, em vez de em um arquivo `.content.ts` separado — e as grava em arquivos JSON de dicionário durante a fase de transformação.
+
+> **A partir do Intlayer v9**, o `intlayerCompiler` é incluído automaticamente dentro do plugin principal [`intlayer()`](https://github.com/aymericzip/intlayer/blob/main/docs/docs/pt/packages/vite-intlayer/intlayer.md) quando `compiler.enabled` é `true` e `compiler.output` está configurado nas suas configurações do Intlayer. Você só precisa registrá-lo separadamente quando desejar controle total sobre as configurações específicas do compilador.
+
+## Uso
+
+### Como parte do `intlayer()` (recomendado, v9+)
+
+Ative o compilador através das configurações do Intlayer:
+
+```ts
+// intlayer.config.ts
+import { defineConfig } from "intlayer";
+
+export default defineConfig({
+  compiler: {
+    enabled: true,
+    output: "./src/dictionaries", // onde os dicionários extraídos são gravados
+  },
+});
+```
+
+Em seguida, use o plugin padrão sem nenhum registro adicional:
+
+```ts
+// vite.config.ts
+import { defineConfig } from "vite";
+import { intlayer } from "vite-intlayer";
+
+export default defineConfig({
+  plugins: [intlayer()],
+});
+```
+
+### Standalone (quando necessário)
+
+```ts
+// vite.config.ts
+import { defineConfig } from "vite";
+import { intlayerCompiler } from "vite-intlayer";
+
+export default defineConfig({
+  plugins: [intlayerCompiler()],
+});
+```
+
+## Opções
+
+```ts
+import type { IntlayerCompilerOptions } from "vite-intlayer";
+```
+
+| Opção            | Tipo                      | Descrição                                                                                                   |
+| ---------------- | ------------------------- | ----------------------------------------------------------------------------------------------------------- |
+| `configOptions`  | `GetConfigurationOptions` | Substituições de configuração do Intlayer encaminhadas para `getConfiguration()`.                           |
+| `compilerConfig` | `Partial<CompilerConfig>` | Substituições para a seção de configuração específica do compilador (ex: `enabled`, `output`, `filesList`). |
+
+### Exemplo
+
+```ts
+intlayerCompiler({
+  configOptions: { configFile: "./config/intlayer.config.ts" },
+  compilerConfig: { enabled: true, output: "./src/dictionaries" },
+});
+```
+
+## Como funciona
+
+### Fase de transformação
+
+Para cada arquivo fonte que corresponda a `compiler.filesList`, o plugin do compilador:
+
+1. Passa o conteúdo do arquivo através de `extractContent` do `@intlayer/babel`.
+2. Chama `onExtract` para cada declaração encontrada, gravando o JSON do dicionário resultante em `compiler.output`.
+3. Retorna o código-fonte transformado com as declarações embutidas substituídas por chamadas padrão `useIntlayer('key')` / `getIntlayer('key')`.
+
+Tipos de arquivos suportados: `.ts`, `.tsx`, `.js`, `.jsx`, `.vue`, `.svelte`, `.astro`.
+
+### HMR (Hot Module Replacement)
+
+Quando um arquivo de componente é salvo no modo de desenvolvimento, o compilador:
+
+1. Detecta a alteração do arquivo por meio do gancho (hook) `handleHotUpdate` do Vite.
+2. Extrai novamente o conteúdo do arquivo atualizado.
+3. Grava o JSON do dicionário atualizado.
+4. Dispara uma atualização completa da página (`server.ws.send({ type: 'full-reload' })`).
+
+Um debounce de 500 ms impede que a gravação do dicionário em si (que também dispara um evento de alteração de arquivo) cause um loop infinito de extração.
+
+### Eliminação de duplicatas (Deduplicação)
+
+O `intlayerCompiler` usa o mesmo mecanismo de deduplicação `createPrimaryInstanceGuard` que os outros plugins integrados. Quando tanto `intlayer()` (que empacota o compilador) quanto uma chamada manual ao `intlayerCompiler()` estão presentes, apenas a primeira instância registrada é executada — nenhum dicionário é gravado duas vezes.

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

@@ -0,0 +1,92 @@
+---
+createdAt: 2026-06-25
+updatedAt: 2026-06-25
+title: Documentação do plugin Vite intlayerMinify | vite-intlayer
+description: Plugin do Vite que minifica os arquivos JSON de dicionário compilados do Intlayer e, opcionalmente, ofusca os nomes dos campos de conteúdo para reduzir o tamanho do bundle.
+keywords:
+  - intlayerMinify
+  - vite
+  - plugin
+  - minificar
+  - tamanho do bundle
+  - dicionário
+  - internacionalização
+  - i18n
+slugs:
+  - doc
+  - packages
+  - vite-intlayer
+  - intlayerMinify
+history:
+  - version: 9.0.0
+    date: 2026-06-25
+    changes: "Inicialização da doc"
+author: aymericzip
+---
+
+# intlayerMinify
+
+O `intlayerMinify` é um plugin do Vite que minifica arquivos JSON de dicionário compilados durante um build de produção. Ele remove todos os espaços em branco desnecessários e, quando combinado com o `intlayerPrune`, opcionalmente renomeia os nomes dos campos de conteúdo para apelidos (aliases) alfabéticos curtos (`a`, `b`, `c`, …) para reduzir ainda mais o tamanho do bundle.
+
+> O plugin já está incluído e configurado automaticamente quando você usa o [`intlayer()`](https://github.com/aymericzip/intlayer/blob/main/docs/docs/pt/packages/vite-intlayer/intlayer.md). Você só precisa registrá-lo manualmente se estiver compondo a pilha de plugins por conta própria.
+
+## Uso
+
+```ts
+// vite.config.ts
+import { defineConfig } from "vite";
+import { intlayerMinify, intlayerPrune } from "vite-intlayer";
+import { createPruneContext } from "@intlayer/babel";
+
+const pruneContext = createPruneContext();
+
+export default defineConfig({
+  plugins: [
+    intlayerPrune(intlayerConfig, pruneContext),
+    intlayerMinify(intlayerConfig, pruneContext),
+  ],
+});
+```
+
+## Condições de ativação
+
+O `intlayerMinify` fica ativo **apenas** quando todas as três condições a seguir forem verdadeiras:
+
+1. O comando do Vite é `build` (não `serve` / dev).
+2. `build.optimize` é `true` (ou `undefined`, que assume o padrão `true` para builds).
+3. `build.minify` é `true` na sua configuração do Intlayer.
+
+Ele é desativado automaticamente quando `editor.enabled` é `true` porque o editor precisa do conteúdo do dicionário completo e legível por humanos.
+
+## O que é minificado
+
+O plugin tem como alvo dois locais de dicionário (conforme resolvido a partir de `intlayer.system`):
+
+- `dictionariesDir` — dicionários estáticos de todos os idiomas (ex: `.intlayer/dictionaries/*.json`)
+- `dynamicDictionariesDir` — dicionários dinâmicos por idioma
+
+> Os dicionários no modo fetch (`fetchDictionariesDir`) **nunca** são minificados porque são servidos a partir de uma API remota em tempo de execução usando seus nomes de campo originais. Renomear os campos criaria uma incompatibilidade entre a resposta do servidor e os acessos às propriedades no lado do cliente.
+
+## Ofuscação de nomes de campos (minificação de propriedades)
+
+Quando o `intlayerPrune` analisa o código-fonte e preenche `pruneContext.dictionaryKeyToFieldRenameMap`, o `intlayerMinify` também renomeia os nomes dos campos de conteúdo para aliases curtos. Por exemplo:
+
+```json
+// antes
+{ "key": "myDict", "content": { "title": "Hello", "description": "World" } }
+
+// depois (com ofuscação)
+{ "key": "myDict", "content": { "a": "Hello", "b": "World" } }
+```
+
+Os acessos correspondentes às propriedades do arquivo fonte são renomeados pela passagem do Babel dentro do `intlayerOptimize`, de modo que o comportamento em tempo de execução permanece inalterado.
+
+Campos internos do Intlayer (`nodeType`, `translation`, etc.) nunca são renomeados.
+
+## Dicionários de casos extremos (Edge-cases)
+
+Dicionários sinalizados em `pruneContext.dictionariesWithEdgeCases` (anomalias estruturais detectadas durante a fase de eliminação) são ignorados inteiramente — não são minificados nem ofuscados — para evitar o envio de dados corrompidos.
+
+## Grupos qualificados (coleções / variantes / registros meta)
+
+Para dicionários com uma matriz `qualifierTypes` (coleções, variantes e registros meta), o plugin preserva a matriz `qualifierTypes` e o mapa lateral `meta` literalmente. Apenas as entradas de `content` têm seus nomes de campo ofuscados. As chaves compostas (usadas para correspondência de seletores em tempo de execução) nunca são tocadas.

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

@@ -0,0 +1,172 @@
+---
+createdAt: 2026-06-25
+updatedAt: 2026-06-25
+title: Documentação do plugin Vite intlayerProxy | vite-intlayer
+description: Middleware de roteamento de idioma para servidores dev/preview do Vite e SSR de produção. Lida com detecção de idioma, redirecionamentos de URL e reescritas internas.
+keywords:
+  - intlayerProxy
+  - vite
+  - plugin
+  - middleware
+  - idioma
+  - roteamento
+  - internacionalização
+  - i18n
+  - SSR
+slugs:
+  - doc
+  - packages
+  - vite-intlayer
+  - intlayerProxy
+history:
+  - version: 9.0.0
+    date: 2026-06-25
+    changes: "Mesclado configOptions em um único objeto de opções; proxy empacotado no intlayer()"
+author: aymericzip
+---
+
+# intlayerProxy
+
+O `intlayerProxy` é um plugin do Vite que registra o middleware de roteamento de idioma para **todos os ambientes**: servidor de desenvolvimento (dev server), servidor de visualização (preview server) e SSR de produção (Nitro / TanStack Start).
+
+> **A partir do Intlayer v9**, o `intlayerProxy` é incluído automaticamente dentro do plugin principal [`intlayer()`](https://github.com/aymericzip/intlayer/blob/main/docs/docs/pt/packages/vite-intlayer/intlayer.md) e ativado por padrão via `routing.enableProxy: true`. Você só precisa registrá-lo separadamente se precisar de controle de nível mais baixo ou se estiver usando-o fora da configuração padrão do `intlayer()`.
+
+## Uso
+
+### Como parte do `intlayer()` (recomendado, v9+)
+
+Passe as opções do `proxy` para o plugin principal em vez de registrar o `intlayerProxy` separadamente:
+
+```ts
+// vite.config.ts
+import { defineConfig } from "vite";
+import { intlayer } from "vite-intlayer";
+
+export default defineConfig({
+  plugins: [
+    intlayer({
+      proxy: {
+        ignore: (req) => req.url?.startsWith("/api"),
+      },
+    }),
+  ],
+});
+```
+
+### Standalone (quando necessário)
+
+```ts
+// vite.config.ts
+import { defineConfig } from "vite";
+import { intlayer } from "vite-intlayer";
+
+export default defineConfig({
+  plugins: [intlayer()],
+});
+```
+
+## Opções
+
+```ts
+import type { IntlayerProxyPluginOptions } from "vite-intlayer";
+```
+
+Todas as opções são opcionais e passadas como um único objeto:
+
+| Opção           | Tipo                                | Descrição                                                                                                                                                                          |
+| --------------- | ----------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `ignore`        | `(req: IncomingMessage) => boolean` | Predicado que exclui requisições do roteamento de idioma. Retorne `true` para ignorar uma requisição (ex: rotas de API, verificações de integridade).                              |
+| `configOptions` | `GetConfigurationOptions`           | Substituições de configuração do Intlayer encaminhadas para `getConfiguration()`. Use quando precisar que o proxy leia um arquivo de configuração específico ou substitua valores. |
+
+### Exemplo
+
+```ts
+intlayerProxy({
+  ignore: (req) => req.url?.startsWith("/api"),
+  configOptions: { configFile: "./config/intlayer.config.ts" },
+});
+```
+
+## createIntlayerProxyHandler
+
+O `createIntlayerProxyHandler` cria um middleware Node.js `(req, res, next)` independente de framework que contém toda a lógica de roteamento de idioma. É útil em ambientes onde a API do plugin do Vite não está disponível (ex: um servidor Node.js simples ou um módulo Nitro personalizado).
+
+```ts
+import { createIntlayerProxyHandler } from "vite-intlayer";
+
+const handler = createIntlayerProxyHandler({
+  ignore: (req) => req.url?.startsWith("/api"),
+  configOptions: { configFile: "./config/intlayer.config.ts" },
+});
+
+// Express / Connect
+app.use(handler);
+```
+
+### SSR de Produção (TanStack Start / Nitro via h3)
+
+```ts
+// server/middleware/intlayerProxy.ts
+import { fromNodeMiddleware } from "h3";
+import { createIntlayerProxyHandler } from "vite-intlayer";
+
+export default fromNodeMiddleware(
+  createIntlayerProxyHandler({
+    ignore: (req) => req.url?.startsWith("/api"),
+  })
+);
+```
+
+## Comportamento de roteamento
+
+O middleware espelha a lógica de roteamento do middleware `next-intlayer` e suporta todos os modos de roteamento do Intlayer.
+
+### Modos de roteamento
+
+| Modo            | URL visível no navegador | Comportamento                                                                                                                            |
+| --------------- | ------------------------ | ---------------------------------------------------------------------------------------------------------------------------------------- |
+| `prefix`        | `/pt/about`              | Padrão. Prefixo de idioma na URL. O idioma padrão redireciona para a URL sem prefixo, a menos que `prefix-all` esteja ativo.             |
+| `prefix-all`    | `/en/about`, `/pt/about` | Todos os idiomas — incluindo o padrão — são sempre prefixados.                                                                           |
+| `no-prefix`     | `/about`                 | Sem idioma na URL. O idioma é armazenado apenas em cookies; as reescritas de URL ocorrem internamente.                                   |
+| `search-params` | `/about?locale=pt`       | Idioma passado como um parâmetro de consulta. Redireciona para adicionar/atualizar o parâmetro `locale` quando ausente ou desatualizado. |
+
+### Prioridade de detecção
+
+1. Prefixo do caminho da URL (ex: `/pt/about` → `pt`).
+2. Valor do cookie / localStorage (`intlayer-locale`).
+3. Cabeçalho `Accept-Language`.
+4. `defaultLocale` da configuração.
+
+### Desvio automático (Bypass)
+
+O middleware sempre passa essas requisições diretamente sem manipulação de idioma:
+
+- Requisições que correspondem ao predicado `ignore`.
+- `/node_modules/**`
+- `/@**` – Recursos internos do Vite (`@vite/`, `@fs/`, `@id/`, etc.).
+- `/_**` – Recursos internos do servidor (`__vite_ping`, `__manifest`, etc.).
+- Requisições cujo caminho termina com uma extensão de arquivo (recursos estáticos). Se um prefixo de idioma estiver presente em um caminho de recurso estático (ex: `/pt/logo.png`), ele será removido para que o arquivo possa ser servido corretamente.
+
+### Roteamento por domínio
+
+Quando `routing.domains` está configurado nas suas configurações do Intlayer, o middleware lida com o roteamento de idioma entre domínios:
+
+- Uma requisição para `/zh/about` em `intlayer.org` é redirecionada para `https://intlayer.zh/about` quando `domains.zh = "intlayer.zh"`.
+- Uma requisição para `intlayer.zh/about` é reescrita internamente para `/zh/about` para que o parâmetro de rota `[locale]` seja preenchido.
+
+### Proteção contra loops de redirecionamento
+
+O middleware rastreia as contagens de redirecionamento por par `originalUrl → newUrl` dentro de uma janela deslizante de 2 segundos. Mais de 10 redirecionamentos dentro dessa janela retornam uma resposta `500` com um erro descritivo em vez de entrar em loop eterno.
+
+## Nitro / SSR de produção (injeção automática, v9+)
+
+Quando o `intlayerProxy` é usado como um plugin do Vite, ele carrega uma propriedade `.nitro`. O plugin de compilação `nitro/vite` lê esta propriedade e a insere em `nitroConfig.modules`, de modo que o `intlayerNitroHandler` é registrado como um middleware do servidor Nitro automaticamente — nenhuma configuração manual é necessária para o SSR de produção.
+
+O manipulador Nitro usa o modelo de evento Web Fetch API da h3 v2 (não o `fromNodeMiddleware`), por isso é compatível com todas as predefinições do Nitro: Node, Bun, Deno, runtimes edge.
+
+## Aliases depreciados
+
+| Exportação depreciada      | Substituição    |
+| -------------------------- | --------------- |
+| `intlayerMiddleware`       | `intlayerProxy` |
+| `intLayerMiddlewarePlugin` | `intlayerProxy` |

package/docs/pt/releases/v9.md

@@ -1,6 +1,6 @@
 ---
 createdAt: 2026-06-14
-updatedAt: 2026-06-23
+updatedAt: 2026-06-25
 title: Novo Intlayer v9 - O que há de novo?
 description: Descubra o que há de novo no Intlayer v9. Apresentando pacotes de compatibilidade drop-in para bibliotecas i18n populares e suporte para Collections, Variants e Dynamic Records.
 keywords:
@@ -252,6 +252,28 @@ Os plugins standalone `intlayerCompiler()` e `intlayerProxy()` permanecem export
 
 ---
 
+## React Native: importações de um único pacote
+
+Em um aplicativo React Native ou Expo, você não precisa mais alternar entre `react-intlayer` e `react-native-intlayer`. O pacote `react-native-intlayer` agora **reexporta toda a API do `react-intlayer`** (hooks, utilitários e os subcaminhos `/format`, `/html` e `/markdown`), e seu `IntlayerProvider` aplica automaticamente os polyfills do React Native.
+
+Importe tudo do único pacote `react-native-intlayer`:
+
+```tsx
+import {
+  IntlayerProvider,
+  useIntlayer,
+  useLocale,
+} from "react-native-intlayer";
+```
+
+```bash
+npm install intlayer react-native-intlayer
+```
+
+> Importar do `react-intlayer` continua funcionando, mas `react-native-intlayer` agora é o ponto de entrada único recomendado para React Native — seu provider inclui os polyfills que o provider do `react-intlayer` (orientado para web) não possui.
+
+---
+
 ## Notas de migração da v8
 
 Se você estiver atualizando da v8, observe que a v9 não inclui breaking changes. Mas aqui estão as principais mudanças:

package/docs/ru/compiler.md

@@ -81,12 +81,15 @@ npm install vite-intlayer
 
 ```ts fileName="vite.config.ts"
 import { defineConfig } from "vite";
-import { intlayer, intlayerCompiler } from "vite-intlayer";
+import { intlayer } from "vite-intlayer";
 
 export default defineConfig({
   plugins: [
-    intlayer(),
-    intlayerCompiler(), // Добавляет плагин компилятора
+    intlayer({
+      proxy: {
+        ignore: (req) => req.url?.startsWith("/api"),
+      },
+    }),
   ],
 });
 ```

package/docs/ru/custom_domains.md

@@ -172,10 +172,16 @@ GET intlayer.zh/about
 
 ```typescript fileName="vite.config.ts"
 import { defineConfig } from "vite";
-import { intlayerProxy } from "vite-intlayer";
+import { intlayer } from "vite-intlayer";
 
 export default defineConfig({
-  plugins: [intlayerProxy()],
+  plugins: [
+    intlayer({
+      proxy: {
+        ignore: (req) => req.url?.startsWith("/api"),
+      },
+    }),
+  ],
 });
 ```
 

package/docs/ru/custom_url_rewrites.md

@@ -340,10 +340,16 @@ export function middleware(request: NextRequest) {
 
 ```typescript fileName="vite.config.ts"
 import { defineConfig } from "vite";
-import { intlayerProxy } from "vite-intlayer";
+import { intlayer } from "vite-intlayer";
 
 export default defineConfig({
-  plugins: [intlayerProxy()],
+  plugins: [
+    intlayer({
+      proxy: {
+        ignore: (req) => req.url?.startsWith("/api"),
+      },
+    }),
+  ],
 });
 ```
 

package/docs/ru/intlayer_with_analog.md

@@ -207,7 +207,11 @@ import analog from "@analogjs/platform";
 export default defineConfig(() => ({
   plugins: [
     analog(),
-    intlayer(), // Добавьте плагин Intlayer
+    intlayer({
+      proxy: {
+        ignore: (req) => req.url?.startsWith("/api"),
+      },
+    }),
   ],
 }));
 ```