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

package/docs/pt/releases/v7.md

@@ -25,6 +25,10 @@ author: aymericzip
 
 Bem-vindo à Intlayer v7! Esta grande versão traz melhorias significativas em desempenho, segurança de tipos e experiência do desenvolvedor. Abaixo estão os destaques, com notas de migração e exemplos práticos.
 
+## Índice
+
+<TOC levels={[2]} maxDepth={1} />
+
 ## Destaques
 
 - Estratégia de cache para builds mais rápidos
@@ -260,6 +264,126 @@ Isso resulta em tempos de download mais rápidos e melhor desempenho em tempo de
 
 ---
 
+## Formatação Automática de Código: configuração formatCommand
+
+v7 introduz a opção `formatCommand` na configuração do editor, permitindo que você formate automaticamente os arquivos de conteúdo quando forem escritos pelo Intlayer. Isso garante um estilo de código e formatação consistentes em seus arquivos de declaração de conteúdo.
+
+Se não definido, Intlayer tentará detectar o comando de formatação automaticamente. Tentando resolver os seguintes comandos: prettier, biome, eslint.
+
+### Configuração
+
+A opção `formatCommand` aceita um template de string onde `{{file}}` será substituído pelo caminho do arquivo real:
+
+```typescript fileName="intlayer.config.ts"
+export default {
+  content: {
+    formatCommand: 'bun x biome format "{{file}}" --write --log-level none',
+  },
+};
+```
+
+### Formatadores suportados
+
+Você pode usar qualquer formatador de código que aceite caminhos de arquivo como argumentos:
+
+**Usando Biome:**
+
+```typescript
+formatCommand: 'bun x biome format "{{file}}" --write --log-level none';
+```
+
+**Usando Prettier:**
+
+```typescript
+formatCommand: 'npx prettier --write "{{file}}" --log-level silent';
+```
+
+**Usando ESLint:**
+
+```typescript
+formatCommand: 'npx eslint --fix "{{file}}" --quiet';
+```
+
+**Usando o formatador integrado do Bun:**
+
+```typescript
+formatCommand: 'bun format "{{file}}"';
+```
+
+### Benefícios
+
+- **Formatação consistente**: Todos os arquivos de conteúdo são automaticamente formatados de acordo com as diretrizes de estilo do seu projeto
+- **Experiência do desenvolvedor**: Sem necessidade de formatar manualmente arquivos após o Intlayer escrevê-los
+- **Consistência da equipe**: Garante que todos os membros da equipe tenham a mesma formatação aplicada aos arquivos de conteúdo
+- **Integração CI/CD**: Arquivos de conteúdo mantêm formatação consistente em fluxos de trabalho automatizados
+
+### Como funciona
+
+When Intlayer writes or updates a content declaration file (`.content.ts`, `.content.js`, etc.), it automatically runs the specified format command on the file. The `{{file}}` placeholder is replaced with the actual file path, and the command is executed in the project's base directory.
+
+---
+
+## Configuração de Dicionário: Melhor organização e estrutura
+
+v7 introduz uma nova seção de configuração `dictionary` dedicada que oferece melhor organização para configurações relacionadas a dicionários e gerenciamento de conteúdo aprimorado.
+
+### Nova estrutura de configuração de dicionário
+
+A propriedade `fill` foi movida da seção `content` para uma nova seção `dictionary`, proporcionando uma separação de responsabilidades mais clara:
+
+**Configuração v6:**
+
+```typescript fileName="intlayer.config.ts"
+export default {
+  content: {
+    autoFill: "./{{fileName}}.content.json",
+    contentDir: ["src"],
+  },
+};
+```
+
+**Configuração v7:**
+
+```typescript fileName="intlayer.config.ts"
+export default {
+  content: {
+    contentDir: ["src"],
+  },
+  dictionary: {
+    fill: "./{{fileName}}.content.json",
+  },
+};
+```
+
+### Benefícios da nova estrutura
+
+- **Organização mais clara**: As configurações específicas do dicionário agora estão agrupadas
+- **Melhor separação de responsabilidades**: A descoberta de conteúdo versus operações de dicionário estão claramente separadas
+- **Manutenibilidade aprimorada**: Mais fácil entender e modificar as configurações relacionadas ao dicionário
+- **Extensibilidade futura**: A seção de dicionário pode acomodar configurações adicionais específicas do dicionário
+- **Gerenciamento abrangente de dicionário**: Inclui propriedades como `title`, `live`, `priority`, `tags`, `version` e `description` para criar e gerenciar novos dicionários
+
+### Uso da configuração
+
+A configuração do dicionário serve dois propósitos principais:
+
+1. **Valores padrão**: Definir valores padrão ao criar ficheiros de declaração de conteúdo
+2. **Comportamento de fallback**: Fornecer valores de fallback quando campos específicos não estão definidos, permitindo-lhe definir o comportamento da operação do dicionário globalmente
+
+A seção do dicionário inclui propriedades abrangentes para gerenciamento de dicionário:
+
+- **`fill`**: Comportamento de preenchimento automático para geração de conteúdo
+- **`title`**: Título padrão para novos dicionários
+- **`live`**: Configuração de sincronização em tempo real para atualizações em tempo real
+- **`priority`**: Configurações de prioridade para resolução de dicionário
+- **`tags`**: Tags padrão para organização de conteúdo
+- **`version`**: Gerenciamento de versão para atualizações de dicionário
+- **`description`**: Descrição padrão para novo conteúdo
+
+Para mais informações sobre ficheiros de declaração de conteúdo e como os valores de configuração são aplicados, consulte a [Documentação de Ficheiros de Conteúdo](https://github.com/aymericzip/intlayer/blob/main/docs/docs/pt/dictionary/content_file.md).
+
+---
+
 ## Comando fill: comportamento atualizado para melhor gerenciamento de conteúdo
 
 A versão 7 introduz um comportamento aprimorado para o comando `fill`, proporcionando um gerenciamento de conteúdo mais previsível e flexível:
@@ -407,6 +531,10 @@ O sistema automaticamente:
 - **`middleware.prefixDefault`**: Substituído por `routing.mode`
 - **`middleware.noPrefix`**: Substituído por `routing.mode`
 
+### Novas configurações
+
+- **`editor.formatCommand`**: Nova opção para formatação automática de código em arquivos de conteúdo
+
 ### Mapeamento de migração
 
 #### Mapeamento de configuração

package/docs/pt/releases/v8.md

@@ -1,6 +1,6 @@
 ---
 createdAt: 2025-09-22
-updatedAt: 2026-01-26
+updatedAt: 2026-06-14
 title: Novo Intlayer v8 - O que há de novo?
 description: Descubra as novidades do Intlayer v8. Principais melhorias na experiência do desenvolvedor, validação de esquemas e gestão de dicionários.
 keywords:
@@ -409,6 +409,16 @@ Para mais detalhes, consulte a [Documentação de Conteúdo HTML](https://github
 
 ---
 
+## Ficheiros de Conteúdo YAML & Markdown (v8.10.0)
+
+Agora pode declarar conteúdo diretamente usando as extensões de ficheiro `.content.md` e `.content.yaml`. Isto é perfeito para conteúdos longos, blogs, documentação e políticas de privacidade.
+
+Estes ficheiros são totalmente editáveis a partir do Visual Editor, proporcionando um fluxo de trabalho simplificado para membros não técnicos da equipa.
+
+Para mais detalhes, consulte a [Documentação de Ficheiros de Conteúdo YAML](https://intlayer.org/doc/concept/content#yaml-content-file) e a [Documentação de Ficheiros de Conteúdo Markdown](https://intlayer.org/doc/concept/content/markdown).
+
+---
+
 ## Reescritas de URL Personalizadas
 
 O Intlayer v8 introduz suporte para **Reescritas de URL Personalizadas**, permitindo que você defina caminhos específicos por localidade que diferem da estrutura padrão `/locale/path`. Este é um recurso poderoso para melhorar o local SEO e proporcionar uma experiência de usuário mais natural para usuários que não falam inglês.
@@ -753,6 +763,58 @@ export default {
   </Tab>
 </Tabs>
 
+## Regras de Plural Unicode CLDR (v8.8.0)
+
+Foi introduzido um novo helper de nó `plural` baseado nas regras de plural definidas pelo Projeto Unicode CLDR, melhorando o suporte para idiomas complexos.
+
+```typescript fileName="src/openings.content.ts"
+import { plural, t, type Dictionary } from "intlayer";
+
+const openingsContent = {
+  key: "total_openings",
+  content: {
+    totalOpenings: t({
+      en: plural({
+        one: "{{count}} opening",
+        other: "{{count}} openings",
+      }),
+      fr: plural({
+        one: "{{count}} offre",
+        other: "{{count}} offres",
+      }),
+    }),
+  },
+} satisfies Dictionary;
+
+export default openingsContent;
+```
+
+Você pode então passar a contagem dinamicamente no componente do seu framework:
+
+```tsx
+import type { FC } from "react";
+import { useIntlayer } from "react-intlayer";
+
+const OpeningsComponent: FC<{ count: number }> = ({ count }) => {
+  const { totalOpenings } = useIntlayer("total_openings");
+
+  return (
+    <div>
+      {/* Em Inglês:                                  */}
+      {/*  count=0  → "0 openings"   (other)           */}
+      {/*  count=1  → "1 opening"    (one)             */}
+      {/*  count=2  → "2 openings"   (other)           */}
+      {/*  count=21 → "21 openings"  (other)           */}
+      <p>{totalOpenings(count)}</p>
+    </div>
+  );
+};
+```
+
+Para mais informações, consulte a [Documentação de Pluralização](https://intlayer.org/doc/concept/content/plural).
+
+---
+
 ## Validação de Esquema de Conteúdo
 
 O Intlayer v8 introduz a validação de esquema para dicionários. Agora você pode definir esquemas de validação reutilizáveis em sua configuração usando Zod e aplicá-los aos seus arquivos de conteúdo. Isso garante que seu conteúdo sempre adira à estrutura esperada, capturando erros em tempo de build.
@@ -797,6 +859,34 @@ Se o conteúdo não corresponder ao esquema (por exemplo, o título é muito cur
 
 ---
 
+## TypeScript: Acessores Primitivos IntlayerNode
+
+O tipo `IntlayerNode` foi atualizado para permitir a chamada de métodos JavaScript primitivos diretamente nos nós de conteúdo. Isto torna possível interagir com o seu conteúdo localizado diretamente como se fosse uma primitiva padrão de string, number, boolean ou array.
+
+Suportado em React, Preact, Solid, Svelte, Vue e Angular.
+
+### Exemplo de String
+
+```typescript
+content.placeholder; // Retorna IntlayerNode<string>
+content.placeholder.value; // Retorna string
+content.placeholder.toString(); // Retorna string
+content.placeholder.toLowerCase(); // Retorna string
+String(content.placeholder); // Retorna string
+content.placeholder.toUpperCase(); // Retorna string em maiúsculas
+content.placeholder.replace("a", "b"); // Retorna string modificada
+```
+
+### Exemplo de Array
+
+```typescript
+content.myArrayOfString             // Retorna IntlayerNode<Array<string>>
+content.myArrayOfString.find(...)   // Retorna elemento
+content.myArrayOfString.join(', ')  // Retorna string unida
+```
+
+---
+
 ### Detecção Automática de Conteúdo Aprimorada
 
 Na v8, o Intlayer detecta inteligentemente a sintaxe Markdown, tags HTML e inserções de variáveis em suas strings de conteúdo. Isso significa que muitas vezes você pode omitir funções auxiliares como `md()`, `html()` ou `insert()`.
@@ -1002,6 +1092,17 @@ A extensão Intlayer para VSCode recebe atualizações significativas na v8 para
 
 ---
 
+## Ferramentas: Watcher C++ & LSP baseado em OXC (v8.12.0)
+
+O Intlayer v8.12.0 traz grandes melhorias para a experiência do desenvolvedor:
+
+- **Parcel Watcher**: O watcher de conteúdo foi migrado de `chokidar` para `@parcel/watcher`, aproveitando a monitorização nativa de ficheiros em C++ para fornecer atualizações mais rápidas e um consumo de memória significativamente menor.
+- **Novo Language Server Protocol (LSP)**: Um novo LSP está agora disponível. Construído com análise baseada em OXC, ajuda o seu IDE e agentes de IA a ligar perfeitamente as chamadas `useIntlayer('my-key')` aos seus ficheiros `.content` correspondentes, e vice-versa.
+
+Para mais detalhes, consulte a [Documentação do LSP](https://intlayer.org/doc/lsp).
+
+---
+
 ## Otimizações do Compilador
 
 Intlayer v8 inclui uma nova camada de cache para o compilador Markdown e HTML. Isso garante que strings de conteúdo idênticas com a mesma configuração sejam analisadas apenas uma vez, reduzindo significativamente a sobrecarga durante re-renders ou quando o mesmo conteúdo é usado em vários lugares.
@@ -1057,6 +1158,48 @@ Intlayer v8 inclui uma nova camada de cache para o compilador Markdown e HTML. I
 
 ---
 
+## Otimizações de Build Experimentais: Minify & Purge (v8.7.0)
+
+O Intlayer v8.7.0 introduz novos recursos experimentais de build no seu `intlayer.config.ts` projetados para otimizar o seu bundle de produção:
+
+- **Minimização de Dicionários (Minify)**: Minimiza os ficheiros de dicionário para reduzir o tamanho.
+- **Purga de Chaves Não Utilizadas (Purge)**: Varre e remove chaves de tradução não utilizadas dos dicionários, renomeando as chaves ativas para caracteres curtos (por exemplo, `"products" -> "a"`, `"pricing" -> "b"`). Isto reduz o tamanho do bundle em até 5%.
+- **Desativar Verificações TypeScript**: Acelera as builds desativando a verificação de tipos TypeScript durante a etapa de compilação.
+
+```typescript fileName="intlayer.config.ts"
+import { Locales, type IntlayerConfig } from "intlayer";
+
+const config: IntlayerConfig = {
+  internationalization: {
+    locales: [Locales.ENGLISH, Locales.FRENCH],
+    defaultLocale: Locales.ENGLISH,
+  },
+  dictionary: {
+    importMode: "dynamic",
+  },
+  build: {
+    /**
+     * Minimiza os dicionários para reduzir o tamanho do bundle.
+     */
+    minify: true,
+
+    /**
+     * Purga as chaves não utilizadas nos dicionários
+     */
+    purge: true,
+
+    /**
+     * Indica se a build deve verificar os tipos TypeScript
+     */
+    checkTypes: false,
+  },
+};
+
+export default config;
+```
+
+---
+
 ## Flexibilidade: Modo Unificado de Importação
 
 A propriedade booleana `live` foi descontinuada em favor de uma propriedade mais abrangente `importMode`. Isso permite a definição explícita de como os dicionários devem ser carregados: estaticamente, dinamicamente ou via sincronização ao vivo.
@@ -1204,6 +1347,49 @@ Conteúdo Markdown e HTML no Svelte agora é automaticamente convertido para HTM
 
 ---
 
+## Suporte Angular: Vite Bundler (v8.11.0)
+
+Para utilizadores do Angular, o Intlayer agora suporta nativamente o bundler Vite através de um novo plugin esbuild personalizado, acelerando os tempos de desenvolvimento e build.
+
+Para detalhes sobre a configuração, consulte a [Documentação do Ambiente Angular](https://intlayer.org/doc/environment/angular).
+
+---
+
+## Geração de Sitemap (v8.6.0)
+
+O Intlayer agora gera sitemaps automaticamente com base nas suas localidades e modo de roteamento. Isto é particularmente útil para otimização de SEO em arquiteturas de roteador como o TanStack Router:
+
+```typescript fileName="src/routes/sitemap.xml.ts"
+import { createFileRoute } from "@tanstack/react-router";
+import { generateSitemap } from "intlayer";
+
+const SITE_URL = (
+  import.meta.env.VITE_SITE_URL ?? "http://localhost:3000"
+).replace(/\/$/, "");
+
+export const Route = createFileRoute("/sitemap.xml")({
+  server: {
+    handlers: {
+      GET: async () => {
+        const sitemap = generateSitemap(
+          [
+            { path: "/", changefreq: "daily", priority: 1.0 },
+            { path: "/about", changefreq: "monthly", priority: 0.8 },
+          ],
+          { siteUrl: SITE_URL }
+        );
+
+        return new Response(sitemap, {
+          headers: { "Content-Type": "application/xml" },
+        });
+      },
+    },
+  },
+});
+```
+
+---
+
 ## Notas de migração da v7
 
 ### Alterações na Configuração

package/docs/pt/releases/v9.md

@@ -0,0 +1,316 @@
+---
+createdAt: 2026-06-14
+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 e Variants.
+keywords:
+  - Intlayer
+  - Compatibility
+  - Migration
+  - Collections
+  - Variants
+  - i18next
+  - next-intl
+  - vue-i18n
+slugs:
+  - doc
+  - releases
+  - v9
+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** e **Variants**.
+
+## Tabela de conteúdos
+
+<TOC levels={[2]} maxDepth={1} />
+
+---
+
+## Compat Adapter Packages
+
+Migrar para o Intlayer a partir de bibliotecas i18n populares agora é mais fácil do que nunca. Criamos cinco pacotes de compatibilidade que expõem as **mesmas APIs públicas** que as bibliotecas i18n padrão, mas delegam todo o trabalho de tradução para o Intlayer em runtime.
+
+### Expor a Mesma API Pública com Strict Typing
+
+Ao substituir os imports, você obtém todos os benefícios do Intlayer (incluindo type safety em tempo de compilação contra seus dicionários reais) com o mínimo de alterações no código:
+
+- `@intlayer/i18next`
+- `@intlayer/react-i18next`
+- `@intlayer/next-intl`
+- `@intlayer/react-intl`
+- `@intlayer/next-i18next`
+- `@intlayer/vue-i18n`
+- `@intlayer/lingui`
+
+Por exemplo, basta alterar:
+
+```ts
+import { useTranslation } from "react-i18next";
+```
+
+para:
+
+```ts
+import { useTranslation } from "@intlayer/react-i18next";
+```
+
+Suas chaves agora serão **strictly typed** (fortemente tipadas) contra seus dicionários Intlayer, oferecendo auto-complete completo de dot-path na sua IDE!
+
+### Plugins de Alias de Bundler (Vite, Next.js, Turbopack)
+
+Para permitir a migração sem reescrever todas as suas declarações de import manualmente, cada pacote de compatibilidade inclui um **plugin de bundler personalizado** (Vite ou Next.js) sob o subcaminho `/plugin`.
+
+Esses plugins reescrevem automaticamente os imports existentes (ex: `react-i18next` ou `next-intl`) para seus equivalentes `@intlayer/*` em tempo de build.
+
+#### Exemplo de Next.js (Webpack / Turbopack)
+
+Em vez de `withIntlayer`, envolva sua configuração do Next.js com o plugin de compatibilidade:
+
+```ts fileName="next.config.ts"
+import { createNextI18nPlugin } from "@intlayer/next-i18next/plugin";
+import type { NextConfig } from "next";
+
+const withIntlayer = createNextI18nPlugin();
+const nextConfig: NextConfig = {};
+
+export default withIntlayer(nextConfig);
+```
+
+#### Exemplo de Vite (React, Vue, Solid, Svelte)
+
+```ts fileName="vite.config.ts"
+import vueI18nVitePlugin from "@intlayer/vue-i18n/plugin";
+
+export default defineConfig({
+  plugins: [vueI18nVitePlugin()],
+});
+```
+
+---
+
+## Mutualized Runtime Resolver
+
+Todos os adaptadores de compatibilidade agora roteiam a resolução de tradução através de um único parser de runtime altamente otimizado: `@intlayer/core/messageFormat`.
+
+- **Interpolate Message**: Resolve `{{var}}` padrão (espaços em branco e dot-paths), argumentos formatados em ICU (`{v, number, percent}` etc.) e templates simples `{var}`.
+- **Message Node Resolver**: Resolve nós aninhados: `insert()`, `plural()` (regras de plural CLDR), `enu()` (enumeração), `gender()`, tags HTML, arrays e nós de funções chamáveis.
+- **Tokenized Tag Parser**: Suporta tags XML/HTML inline e tags numeradas (ex: `<1>children</1>`) para habilitar renderização de rich-text nativamente.
+
+---
+
+## 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.
+
+### 1. Collections
+
+Defina uma lista gerenciada por CMS de itens ordenados (ex: FAQs, produtos ou listas de blog):
+
+```ts fileName="faq.1.content.ts"
+import { t, type Dictionary } from "intlayer";
+
+export default {
+  key: "faq",
+  item: 1,
+  content: {
+    question: t({ en: "What is Intlayer?", fr: "Qu'est-ce qu'Intlayer ?" }),
+    answer: t({ en: "An i18n toolkit.", fr: "Une boîte à outils i18n." }),
+  },
+} satisfies Dictionary;
+```
+
+```ts fileName="faq.2.content.ts"
+import { t, type Dictionary } from "intlayer";
+
+export default {
+  key: "faq",
+  item: 2,
+  content: {
+    question: t({ en: "Is it free?", fr: "Est-ce gratuit ?" }),
+    answer: t({ en: "Yes, open-source.", fr: "Oui, open-source." }),
+  },
+} satisfies Dictionary;
+```
+
+#### Uso:
+
+```ts
+// Fetch all items as an array
+const allFaqs = useIntlayer("faq"); // -> { question: string, answer: string }[]
+
+// Fetch a single item by index
+const faq = useIntlayer("faq", { item: 2 }); // -> { question: string, answer: string }
+```
+
+### 2. Variants
+
+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";
+
+export default {
+  key: "hero-banner",
+  variant: "default",
+  content: {
+    control: t({ pt: "Bem-vindo", en: "Welcome", fr: "Bienvenue" }),
+    black_friday: t({
+      pt: "Compre agora",
+      en: "Shop now",
+      fr: "Acheter maintenant",
+    }),
+  },
+} satisfies Dictionary;
+```
+
+#### Uso:
+
+```ts
+const banner = useIntlayer("hero-banner", { variant: "black_friday" });
+```
+
+#### Variantes de objeto (ex. Dynamic Records)
+
+```ts fileName="product.content.ts"
+import { t, type Dictionary } from "intlayer";
+
+export default {
+  key: "product-copy",
+  variant: {
+    id: "prod_123",
+    category: "books",
+  },
+  content: {
+    title: t({ pt: "Código Limpo", en: "Clean Code", fr: "Code Propre" }),
+  },
+} satisfies Dictionary;
+```
+
+#### Uso:
+
+```ts
+// Busca apenas o item solicitado dinamicamente (requer Suspense)
+const product = useIntlayer("product-copy", {
+  variant: { id: "prod_123", category: "books" },
+});
+```
+
+---
+
+## Carregamento Dinâmico & Otimizações de Tamanho de Bundle
+
+Para manter os bundles extremamente pequenos, o Intlayer v9 suporta dynamic lazy loading.
+
+Na sua configuração, defina `importMode` como `'dynamic'` ou `'fetch'`:
+
+```ts fileName="intlayer.config.ts"
+export default {
+  dictionary: {
+    importMode: "dynamic", // "static" | "dynamic" | "fetch"
+  },
+};
+```
+
+Em tempo de build, o `@intlayer/swc` e o `@intlayer/babel` escaneiam seus arquivos e substituem as chamadas de `useIntlayer` / `getIntlayer` por wrappers tree-shakeable (`useDictionary` / `useDictionaryDynamic`). Apenas o conteúdo necessário para o item da coleção, variante ou locale selecionado é carregado, evitando que seu bundle de produção contenha traduções não utilizadas.
+
+---
+
+## Vite Plugin: Compilador Agrupado & Proxy
+
+O plugin Vite `intlayer()` agora agrupa o **compilador** e o **proxy de roteamento de localidade** diretamente, então a maioria dos projetos precisa apenas de um único plugin em `vite.config.ts`:
+
+```ts fileName="vite.config.ts"
+import { defineConfig } from "vite";
+import { intlayer } from "vite-intlayer";
+
+export default defineConfig({
+  plugins: [intlayer()],
+});
+```
+
+- **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`
+
+Uma nova opção `routing.enableProxy` controla se o proxy de roteamento de locale está conectado. O padrão é `true`. Desative-o quando quiser lidar com o roteamento de locale você mesmo:
+
+```ts fileName="intlayer.config.ts"
+import type { IntlayerConfig } from "intlayer";
+
+const config: IntlayerConfig = {
+  routing: {
+    enableProxy: false, // Padrão: true
+  },
+};
+
+export default config;
+```
+
+Os plugins standalone `intlayerCompiler()` e `intlayerProxy()` permanecem exportados para configurações avançadas. Registrá-los junto com `intlayer()` é seguro — cada plugin se deduplica e é executado apenas uma vez.
+
+---
+
+## 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 }`. 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](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)