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

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/plugins/sync-json.md

@@ -108,7 +108,6 @@ const config: IntlayerConfig = {
      * Irá carregar e escrever a saída e as traduções de volta para os arquivos JSON no diretório de localidades
      */
     syncJSON({
-      format: "i18next",
       source: ({ key, locale }) => `./locales/${locale}/${key}.json`,
       priority: 0,
       format: "i18next",

package/docs/pt/releases/v9.md

@@ -1,15 +1,14 @@
 ---
 createdAt: 2026-06-14
-updatedAt: 2026-06-23
+updatedAt: 2026-06-26
 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.
+description: Descubra o que há de novo no Intlayer v9. Apresentando pacotes de compatibilidade drop-in para bibliotecas i18n populares e suporte para Collections e Variants.
 keywords:
   - Intlayer
   - Compatibility
   - Migration
   - Collections
   - Variants
-  - Dynamic Records
   - i18next
   - next-intl
   - vue-i18n
@@ -22,7 +21,7 @@ author: aymericzip
 
 # Novo Intlayer v9 - O que há de novo?
 
-Bem-vindo ao Intlayer v9! Este grande lançamento marca um marco enorme na simplificação do caminho de migração para o Intlayer com **Compat Adapter Packages** para as principais bibliotecas de i18n (`react-i18next`, `next-intl`, `vue-i18n`, etc.) e adiciona suporte para estruturas de conteúdo ricas: **Collections**, **Variants** e **Dynamic Records**.
+Bem-vindo ao Intlayer v9! Este grande lançamento marca um marco enorme na simplificação do caminho de migração para o Intlayer com **Compat Adapter Packages** para as principais bibliotecas de i18n (`react-i18next`, `next-intl`, `vue-i18n`, etc.) e adiciona suporte para estruturas de conteúdo ricas: **Collections** e **Variants**.
 
 ## Tabela de conteúdos
 
@@ -41,8 +40,10 @@ Ao substituir os imports, você obtém todos os benefícios do Intlayer (incluin
 - `@intlayer/i18next`
 - `@intlayer/react-i18next`
 - `@intlayer/next-intl`
+- `@intlayer/react-intl`
 - `@intlayer/next-i18next`
 - `@intlayer/vue-i18n`
+- `@intlayer/lingui`
 
 Por exemplo, basta alterar:
 
@@ -100,7 +101,7 @@ Todos os adaptadores de compatibilidade agora roteiam a resolução de traduçã
 
 ---
 
-## Especificação de Recursos: Collections, Variants & Dynamic Records
+## Especificação de Recursos: Collections & Variants
 
 O Intlayer v9 vai além de objetos estáticos de chave-valor, permitindo que os dicionários declarem estruturas de layout dinâmicas que são totalmente tipadas de ponta a ponta.
 
@@ -144,6 +145,8 @@ const faq = useIntlayer("faq", { item: 1 }); // -> { question: string, answer: s
 
 Entregue testes A/B, cabeçalhos sazonais, feature flags ou landing pages personalizadas:
 
+#### Variantes de string (ex. testes A/B)
+
 ```ts fileName="hero.content.ts"
 import { t, type Dictionary } from "intlayer";
 
@@ -167,16 +170,14 @@ export default {
 const banner = useIntlayer("hero-banner", { variant: "black_friday" });
 ```
 
-### 3. Dynamic Records
-
-Defina dicionários cujas entradas são carregadas dinamicamente em runtime via IDs de consulta:
+#### Variantes de objeto (ex. Dynamic Records)
 
 ```ts fileName="product.content.ts"
 import { t, type Dictionary } from "intlayer";
 
 export default {
   key: "product-copy",
-  meta: {
+  variant: {
     id: "prod_123",
     category: "books",
   },
@@ -229,7 +230,7 @@ export default defineConfig({
 });
 ```
 
-- **Compilador**: Ativa automaticamente quando `compiler.enabled` é definido e um caminho `compiler.output` é configurado. Você não precisa mais registrar `intlayerCompiler()` separadamente.
+- **Compilador**: Ativa automaticamente quando `compiler.enabled` é definido como `true` e um caminho `compiler.output` é configurado. Você não precisa mais registrar `intlayerCompiler()` separadamente.
 - **Proxy**: Ativa automaticamente com base na nova opção `routing.enableProxy` (`true` por padrão). Ele conecta o middleware de detecção de localidade / redirecionamento / reescrita em desenvolvimento, visualização e SSR de produção. Você não precisa mais registrar `intlayerProxy()` separadamente.
 
 ### Opção `routing.enableProxy`
@@ -252,17 +253,61 @@ Os plugins standalone `intlayerCompiler()` e `intlayerProxy()` permanecem export
 
 ---
 
+## Compilador desativado por padrão
+
+A partir do Intlayer v9, o **compilador está desativado por padrão** (`compiler.enabled` agora tem o valor padrão `false`). Para ativar a extração dos seus arquivos `.content.ts` em tempo de build, defina `compiler.enabled: true` na sua configuração:
+
+```ts fileName="intlayer.config.ts"
+import type { IntlayerConfig } from "intlayer";
+
+const config: IntlayerConfig = {
+  compiler: {
+    enabled: true, // Padrão: false — necessário para ativar o compilador desde a v9
+    output: ({ fileName }) => `./${fileName}.content.ts`,
+  },
+};
+
+export default config;
+```
+
+Quando o compilador está desativado, o Intlayer pula a etapa de extração em tempo de build e depende dos dicionários que você já declarou. Ative-o apenas quando quiser que o plugin do bundler (`@intlayer/swc`, `@intlayer/babel` ou o plugin Vite `intlayer()`) extraia o conteúdo automaticamente.
+
+---
+
+## 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:
 
+- **Compilador desativado por padrão**: `compiler.enabled` agora tem o valor padrão `false`. Se você depende da extração dos seus arquivos `.content.ts` em tempo de build, defina `compiler.enabled: true` no seu `intlayer.config.ts`.
 - **Locales & Dialects**: Se estiver usando dependências externas de i18n, adicione seus respectivos plugins de compatibilidade na sua configuração ou setup do bundler para reescrever os imports automaticamente.
-- **Custom Selectors**: Ao chamar `useIntlayer`, o segundo parâmetro agora é reservado para um objeto de opções contendo `{ locale, item, variant, id }`. Se você passava anteriormente uma string de locale diretamente, ainda pode fazer isso, mas o uso do objeto de opções é recomendado para seleções avançadas.
+- **Custom Selectors**: Ao chamar `useIntlayer`, o segundo parâmetro agora é reservado para um objeto de opções contendo `{ locale, item, variant }`. Se você passava anteriormente uma string de locale diretamente, ainda pode fazer isso, mas o uso do objeto de opções é recomendado para seleções avançadas.
 
 ---
 
 ## Links úteis
 
 - [Guia de Compat Adapter Packages](https://github.com/aymericzip/intlayer/blob/main/docs/docs/pt/compat/index.md)
-- [Dicionários Dinâmicos - Collections, Variants & Dynamic Records](https://github.com/aymericzip/intlayer/blob/main/docs/docs/pt/dynamic_dictionaries/index.md)
+- [Dicionários Dinâmicos - Collections & Variants](https://github.com/aymericzip/intlayer/blob/main/docs/docs/pt/dynamic_dictionaries/index.md)
 - [Referência de Configuração](https://github.com/aymericzip/intlayer/blob/main/docs/docs/pt/configuration.md)

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"),
+      },
+    }),
+  ],
 });
 ```