diff --git a/src/content/docs/pt-br/basics/astro-components.mdx b/src/content/docs/pt-br/basics/astro-components.mdx
index c8dde452abd20..05bc40d3300ed 100644
--- a/src/content/docs/pt-br/basics/astro-components.mdx
+++ b/src/content/docs/pt-br/basics/astro-components.mdx
@@ -1,32 +1,40 @@
 ---
 title: Componentes
-description: Uma introdução à sintaxe de componentes .astro.
+description: Uma introdução aos componentes Astro.
 i18nReady: true
 ---
+import ReadMore from '~/components/ReadMore.astro';
+
+**Componentes Astro** são os elementos básicos de qualquer projeto Astro. São componentes de template com apenas HTML sem execução no lado do cliente e que usam a extensão de arquivo `.astro`.
 
-**Componentes Astro** são parte fundamental de qualquer projeto Astro. São componentes de template com apenas HTML e sem execução no lado do cliente. Você pode localizar um componente Astro por sua extensão de arquivo: `.astro`.
+:::note
+Se você conhece HTML, já sabe o suficiente para escrever seu primeiro componente Astro.
 
-Componentes Astro são extremamente flexíveis. Geralmente, um componente Astro irá conter alguma **UI reutilizável na página**, como um cabeçalho ou um cartão de perfil. Outras vezes, um componente Astro pode conter um pedaço menor de HTML, como uma coleção de tags `<meta>` comuns que facilitam trabalhar com SEO. Componentes Astro podem até mesmo conter o layout inteiro de uma página.
+<ReadMore>Saiba mais na [referência da sintaxe Astro](/pt-br/reference/astro-syntax/).</ReadMore>
+:::
 
-A coisa mais importante de entender sobre componentes Astro é que eles **não renderizam no lado do cliente**. Eles renderizam para HTML em tempo de build ou sob demanda usando [renderização no lado do servidor (SSR)](/pt-br/guides/on-demand-rendering/). Você pode incluir código JavaScript dentro do frontmatter do seu componente, e todo esse código vai ser removido da página final enviada para o navegador dos seus usuários. O resultado é um site mais rápido, sem nenhum JavaScript adicionado por padrão.
+Componentes Astro são extremamente flexíveis. Um componente Astro pode ser tão pequeno quanto um trecho de HTML, como uma coleção de tags `<meta>` comuns que facilitam trabalhar com SEO. Componentes podem ser elementos de UI reutilizáveis, como um cabeçalho ou um cartão de perfil. Componentes Astro podem até mesmo conter o layout inteiro de uma página ou, quando estão na pasta especial `src/pages/`, ser uma página completa.
 
-Quando seu componente Astro realmente precisar de interatividade no lado do cliente, você pode adicionar [tags `<script>` tradicionais do HTML](/pt-br/guides/client-side-scripts/) ou [componentes de um Framework de UI](/pt-br/guides/framework-components/#hydrating-interactive-components).
+A coisa mais importante de entender sobre componentes Astro é que eles **não renderizam no lado do cliente**. Eles renderizam para HTML em tempo de build ou sob demanda. Você pode incluir código JavaScript dentro do frontmatter do seu componente, e todo esse código vai ser removido da página final enviada para o navegador dos seus usuários. O resultado é um site mais rápido, sem nenhum JavaScript adicionado por padrão.
 
+Quando seu componente Astro precisar de interatividade no lado do cliente, você poderá adicionar [tags `<script>` tradicionais do HTML](/pt-br/guides/client-side-scripts/) ou [componentes de um Framework de UI](/pt-br/guides/framework-components/#hydrating-interactive-components) como "ilhas de cliente".
+
+Para componentes que precisam renderizar conteúdo personalizado ou dinâmico, você pode adiar a renderização no servidor adicionando uma [diretiva do servidor](/pt-br/reference/directives-reference/#server-directives). Essas "ilhas de servidor" renderizarão seu conteúdo quando ele estiver disponível, sem atrasar o carregamento da página inteira.
 
 ## Estrutura do Componente
 
-Um componente Astro é feito de duas partes principais: o **Script do Componente** e o **Template do Componente**. Cada parte executa um trabalho diferente, porém juntos eles fornecem um framework que é ao mesmo tempo fácil de utilizar e expressivo o bastante para lidar com o que quer que seja que você deseja construir.
+Um componente Astro é feito de duas partes principais: o **Script do Componente** e o **Template do Componente**. Cada parte desempenha uma função diferente, mas juntas elas fornecem um framework fácil de usar e expressivo o bastante para lidar com tudo o que você quiser criar.
 
 ```astro title="src/components/ComponenteVazio.astro"
 ---
 // Script do Componente (JavaScript)
 ---
-<!-- Template do Componente (HTML + Expressões do JS) -->
+<!-- Template do Componente (HTML + Expressões em JS) -->
 ```
 
 ### O Script do Componente
 
-Astro utiliza uma cerca de código (`---`) para identificar o script do seu componente Astro. Se você já escreveu Markdown antes, você já deve estar familiar com um conceito similar chamado de *frontmatter*. A ideia do Astro de um script do componente foi diretamente inspirado por este conceito.
+Astro utiliza uma cerca de código (`---`) para identificar o script do seu componente Astro. Se você já escreveu Markdown antes, você já deve estar familiar com um conceito similar chamado *frontmatter*. A ideia do Astro de um script de componente foi diretamente inspirado por este conceito.
 
 Você pode utilizar o script do componente para escrever qualquer código JavaScript necessário para renderizar o seu template. Isso pode incluir:
 
@@ -36,7 +44,6 @@ Você pode utilizar o script do componente para escrever qualquer código JavaSc
 - buscar conteúdo de uma API ou banco de dados
 - criar variáveis que você vai referenciar no seu template
 
-
 ```astro title="src/components/MeuComponente.astro"
 ---
 import UmComponenteAstro from '../components/UmComponenteAstro.astro';
@@ -45,6 +52,7 @@ import algunsDados from '../dados/pokemon.json';
 
 // Acesse props passadas ao componente, como `<X titulo="Olá, Mundo!" />`
 const { titulo } = Astro.props;
+
 // Busque dados externos, até mesmo de uma API privada ou banco de dados
 const dados = await fetch('ALGUMA_URL_SECRETA_API/usuarios').then(r => r.json());
 ---
@@ -53,8 +61,10 @@ const dados = await fetch('ALGUMA_URL_SECRETA_API/usuarios').then(r => r.json())
 
 A cerca de código é projetada para garantir que o JavaScript que você escreve nela está "cercado". Ele não irá escapar para a sua aplicação frontend ou cair nas mãos dos seus usuários. Você pode com segurança escrever aqui código que é custoso ou sensível (como uma chamada ao seu banco de dados privado) sem se preocupar com ele indo parar no navegador do seu usuário em algum momento.
 
-:::tip
-Você pode até mesmo escrever TypeScript no script do componente!
+:::note
+O script de um componente Astro é TypeScript, o que permite adicionar sintaxe extra ao JavaScript para oferecer ferramentas no editor e verificação de erros.
+
+<ReadMore>Saiba mais sobre o [suporte integrado a TypeScript](/pt-br/guides/typescript/) do Astro.</ReadMore>
 :::
 
 ### O Template do Componente
@@ -63,12 +73,13 @@ O template do componente está abaixo da cerca do código e determina o HTML que
 
 Se você escrever HTML puro aqui, o seu componente irá renderizar esse HTML em qualquer página Astro em que ele é importado e utilizado.
 
-Porém, a [sintaxe do template do componente Astro](/pt-br/reference/astro-syntax/) também suporta **expressões JavaScript**, tags [`<style>`](/pt-br/guides/styling/#styling-in-astro) e [`<script>`](/pt-br/guides/client-side-scripts/#client-side-scripts) do Astro, **componentes importados**, e [**diretivas especiais do Astro**](/pt-br/reference/directives-reference/). Dados e valores definidos no script do componente podem ser utilizados no template do componente para produzir HTML criado dinamicamente.
+Porém, a [sintaxe do template de componentes Astro](/pt-br/reference/astro-syntax/) também suporta **expressões JavaScript**, tags [`<style>`](/pt-br/guides/styling/#styling-in-astro) e [`<script>`](/pt-br/guides/client-side-scripts/) do Astro, **componentes importados** e [**diretivas especiais do Astro**](/pt-br/reference/directives-reference/). Dados e valores definidos no script do componente podem ser utilizados no template do componente para produzir HTML criado dinamicamente.
 
 ```astro title="src/components/MeuPokemonFavorito.astro"
 ---
 // O script do seu componente está aqui!
 import Banner from '../components/Banner.astro';
+import Avatar from '../components/Avatar.astro';
 import ComponentePokemonReact from '../components/ComponentePokemonReact.jsx';
 const meuPokemonFavorito = [/* ... */];
 const { titulo } = Astro.props;
@@ -82,6 +93,11 @@ const { titulo } = Astro.props;
 <!-- Use props e outras variáveis do script do componente: -->
 <p>{titulo}</p>
 
+<!-- Adie a renderização do componente e forneça um conteúdo alternativo durante o carregamento: -->
+<Avatar server:defer>
+  <svg slot="fallback" class="avatar-generico" transition:name="avatar">...</svg>
+</Avatar>
+
 <!-- Inclua outros componentes de frameworks de UI com a diretiva `client:` para hidratá-los: -->
 <ComponentePokemonReact client:visible />
 
@@ -91,10 +107,10 @@ const { titulo } = Astro.props;
 </ul>
 
 <!-- Use uma diretiva de template para construir nomes de classe a partir de múltiplas strings ou até mesmo objetos! -->
-<p class:list={["adicione", "dinâmicos", {classNames: true}]} />
+<p class:list={["adicione", "dinâmicos", { classNames: true }]} />
 ```
 
-## Design baseado em componente
+## Design Baseado em Componente
 
 Componentes são projetados para serem **reutilizáveis** e **combináveis**. Você pode utilizar componentes dentro de outros componentes para criar UIs cada vez mais avançadas. Por exemplo, um componente `Botao` pode ser utilizado para criar um componente `GrupoBotoes`:
 
@@ -109,7 +125,6 @@ import Botao from './Botao.astro';
 </div>
 ```
 
-
 ## Props do Componente
 
 Um componente Astro pode definir e aceitar props. Essas props então se tornam disponíveis ao template do componente para renderizar HTML. Props estão disponíveis na global `Astro.props` no script do frontmatter.
@@ -153,7 +168,7 @@ const { saudacao = "Olá", nome } = Astro.props;
 <h2>{saudacao}, {nome}!</h2>
 ```
 
-Props do componente podem receber valores padrões para serem utilizados quando nenhum é fornecido.
+Props do componente podem receber valores padrão para serem utilizados quando nenhum é fornecido.
 
 ```astro ins="= \"Olá\"" ins="= \"Astronauta\""
 ---
@@ -165,12 +180,12 @@ const { saudacao = "Olá", nome = "Astronauta" } = Astro.props;
 
 ## Slots
 
-O elemento `<slot />` é um placeholder para conteúdo HTML externo, permitindo que você injete elementos filhos de outros arquivos no template do seu componente.
+O elemento `<slot />` é um placeholder para conteúdo HTML externo, permitindo que você injete (ou "encaixe") elementos filhos de outros arquivos no template do seu componente.
 
 Por padrão, todos os elementos filhos passados para o componente serão renderizados em seu `<slot />`.
 
 :::note
-Diferente de _props_, que são atributos passados para um componente Astro, disponível para uso dentro de si com `Astro.props()`, _slots_ renderizam elementos filhos HTML onde eles estão escritos.
+Diferente de _props_, que são atributos passados para um componente Astro e ficam disponíveis em todo o seu componente com `Astro.props`, _slots_ renderizam elementos HTML filhos onde eles estsão escritos.
 :::
 
 ```astro "<slot />"
@@ -202,13 +217,13 @@ import Involucro from '../components/Involucro.astro';
 </Involucro>
 ```
 
-Este padrão é a base de um [componente de layout Astro](/pt-br/basics/layouts/): uma página inteira de conteúdo HTML pode ser "envolta" com tags `<AlgumComponenteDeLayout></AlgumComponenteDeLayout>` e enviadas até o componente para serem renderizadas dentro de elementos comuns da página definidos nele.
-
+Este padrão é a base de um [componente de layout Astro](/pt-br/basics/layouts/): uma página inteira de conteúdo HTML pode ser "envolvida" com tags `<AlgumComponenteDeLayout></AlgumComponenteDeLayout>` e enviada ao componente para ser renderizada dentro dos elementos comuns de página definidos nele.
 
+<ReadMore>Consulte as [funções utilitárias de `Astro.slots`](/pt-br/reference/astro-syntax/#astroslots) para conhecer outras maneiras de acessar e renderizar o conteúdo de slots.</ReadMore>
 
 ### Slots Nomeados
 
-Um componente Astro também pode ter slots nomeados. Isto permite que você passe apenas elementos HTML com o nome de slot correspondente para a localização do slot.
+Um componente Astro também pode ter slots nomeados. Isso permite que você passe apenas elementos HTML com o nome de slot correspondente para a localização do slot.
 
 Slots são nomeados usando o atributo `name`:
 
@@ -223,25 +238,27 @@ const { titulo } = Astro.props;
 ---
 <div id="invólucro-do-conteúdo">
   <Cabecalho />
-  <slot name="depois-do-cabecalho"/>  <!--  filhos com o atributo `slot="depois-do-cabecalho"` virão para cá -->
+  <!-- filhos com o atributo `slot="depois-do-cabecalho"` virão para cá -->
+  <slot name="depois-do-cabecalho" />
   <Logo />
   <h1>{titulo}</h1>
-  <slot />  <!--  filhos sem um atributo `slot`, ou com `slot="default"` virão para cá -->
+  <!-- filhos sem um atributo `slot`, ou com `slot="default"`, virão para cá -->
+  <slot />
   <Rodape />
-  <slot name="depois-do-rodape"/>  <!--  filhos com o atributo `slot="depois-do-rodape"` virão para cá -->
+  <!-- filhos com o atributo `slot="depois-do-rodape"` virão para cá -->
+  <slot name="depois-do-rodape" />
 </div>
 ```
 
-Para injetar conteúdo HTML dentro de um slot em particular, use o atributo `slot` em qualquer elemento filho para especificar o nome do slot. Todos os outros elementos filhos do componentes serão injetados no `<slot />` padrão (não nomeado).
-
+Para injetar conteúdo HTML dentro de um slot em particular, use o atributo `slot` em qualquer elemento filho para especificar o nome do slot. Todos os outros elementos filhos do componente serão injetados no `<slot />` padrão (não nomeado).
 
 ```astro /slot=".*?"/
 ---
 // src/pages/fred.astro
 import Involucro from '../components/Involucro.astro';
 ---
-<Involucro title="Página do Fred">
-  <img src="https://minha.foto/fred.jpg" slot="depois-do-cabecalho">
+<Involucro titulo="Página do Fred">
+  <img src="https://minha.foto/fred.jpg" slot="depois-do-cabecalho" />
   <h2>Tudo sobre Fred</h2>
   <p>Aqui estão algumas coisas sobre Fred.</p>
   <p slot="depois-do-rodape">Copyright 2022</p>
@@ -249,24 +266,24 @@ import Involucro from '../components/Involucro.astro';
 ```
 
 :::tip
-Use um atributo `slot="meu-slot"` no elemento filho que você quer passar para um placeholder `<slot name="meu-slot"/>` correspondente no seu componente.
+Use um atributo `slot="meu-slot"` no elemento filho que você quer passar para um placeholder `<slot name="meu-slot" />` correspondente no seu componente.
 :::
 
-Para passar múltiplos elementos HTML para um placeholder `<slot/>` de um componente sem ter uma `<div>` envolta, use o atributo `slot=""` no [Componente `<Fragment/>` do Astro](/pt-br/reference/astro-syntax/#fragmentos):
+Para passar múltiplos elementos HTML para o placeholder `<slot />` de um componente sem ter uma `<div>` envolta, use o atributo `slot=""` no [componente `<Fragment />` do Astro](/pt-br/reference/astro-syntax/#fragmentos):
 
-```astro title="src/components/TabelaCustomizada.astro" "<slot name="cabecalho"/>" "<slot name="corpo"/>"
+```astro title="src/components/TabelaCustomizada.astro" '<slot name="cabecalho" />' '<slot name="corpo" />'
 ---
 // Cria uma tabela customizada com slots nomeados para o conteúdo do cabeçalho e do corpo
 ---
 <table class="bg-white">
-  <thead class="sticky top-0 bg-white"><slot name="cabecalho"/></thead>
-  <tbody class="[&_tr:nth-child(odd)]:bg-gray-100"><slot name="corpo"/></tbody>
+  <thead class="sticky top-0 bg-white"><slot name="cabecalho" /></thead>
+  <tbody class="[&_tr:nth-child(odd)]:bg-gray-100"><slot name="corpo" /></tbody>
 </table>
 ```
 
-Injete múltiplas linhas e colunas de conteúdo HTML usando o atributo `slot=""` para especificar o conteúdo do `"cabecalho"` e `"corpo"`. Elementos inviduais do HTML também podem ser estilizados:
+Injete múltiplas linhas e colunas de conteúdo HTML usando o atributo `slot=""` para especificar o conteúdo do `"cabecalho"` e `"corpo"`. Elementos individuais do HTML também podem ser estilizados:
 
-```astro title="src/components/TabelaDeEstoque.astro" {5-7, 9-13} '<Fragment slot="cabecalho">' '<Fragment slot="corpo">'
+```astro title="src/components/TabelaDeEstoque.astro" {5-7, 9-13} '<Fragment slot="cabecalho">' '<Fragment slot="corpo">' '</Fragment>'
 ---
 import TabelaCustomizada from './TabelaCustomizada.astro';
 ---
@@ -290,12 +307,12 @@ Slots nomeados também podem ser passados para [componentes de frameworks de UI]
 :::
 
 :::note
-Não é possível gerar dinamicamente o nome de um slot no Astro, como por exemplo dentro de uma função map. Se essa funcionalidade é necessária dentro de um componente de um framework de UI, o melhor é gerar esses slots dinâmicos dentro do próprio framework.
+Não é possível gerar dinamicamente o nome de um slot Astro, como dentro de uma função [`map`](https://developer.mozilla.org/pt-BR/docs/Web/JavaScript/Reference/Global_Objects/Array/map). Se essa funcionalidade é necessária dentro de componentes de frameworks de UI, talvez seja melhor gerar esses slots dinâmicos dentro do próprio framework.
 :::
 
-
 ### Conteúdo de Fallback para Slots
-Slots também podem renderizar **conteúdo de fallback**. Quando não existirem filhos correspondentes passados a um slot, um elemento `<slot />` irá renderizar os elementos filhos que ele possui como placeholder.
+
+Slots também podem renderizar **conteúdo de fallback**. Quando nenhum filho correspondente for passado a um slot, um elemento `<slot />` irá renderizar seus próprios filhos como conteúdo substituto.
 
 ```astro {14}
 ---
@@ -317,25 +334,24 @@ const { titulo } = Astro.props;
 </div>
 ```
 
-Conteúdo de fallback será mostrado somente quando não houver elementos correspondentes com o atributo slot="nome" sendo passados para dentro de um slot nomeado.
+Conteúdo de fallback só será mostrado quando não houver elementos correspondentes com o atributo `slot="nome"` sendo passados para um slot nomeado.
 
 Astro vai passar um slot vazio quando um elemento de slot existir, mas não tiver nenhum conteúdo para passar. Conteúdo de fallback não pode ser utilizado como um padrão no caso de um slot vazio ser passado. Conteúdo de fallback só é exibido quando nenhum elemento de slot é encontrado.
 
-### Transferindo slots
+### Transferindo Slots
 
 Slots podem ser transferidos para outros componentes. Por exemplo, quando criando layouts aninhados:
 
 ```astro title="src/layouts/BaseLayout.astro" {9,12}
 ---
 ---
-
 <html lang="pt-BR">
 	<head>
 		<meta charset="utf-8" />
 		<link rel="icon" type="image/svg+xml" href="/favicon.svg" />
 		<meta name="viewport" content="width=device-width" />
 		<meta name="generator" content={Astro.generator} />
-    <slot name="cabecalho"/>
+    <slot name="cabecalho" />
 	</head>
 	<body>
 		<slot />
@@ -348,9 +364,8 @@ Slots podem ser transferidos para outros componentes. Por exemplo, quando criand
 ---
 import LayoutBase from './LayoutBase.astro';
 ---
-
 <LayoutBase>
-  <slot name="cabecalho" slot="cabecalho"/>
+  <slot name="cabecalho" slot="cabecalho" />
   <slot />
 </LayoutBase>
 ```
@@ -359,36 +374,33 @@ import LayoutBase from './LayoutBase.astro';
 Slots nomeados podem ser transferidos para outro componente usando ambos os atributos `name` e `slot` em uma tag `<slot />`
 :::
 
-Agora, os slots padrão e `cabecalho` passados para `LayoutInicio` vão ser transferidos para o pai `LayoutBase`
+Agora, os slots padrão e `cabecalho` passados para `LayoutInicio` vão ser transferidos para o pai `LayoutBase`.
 
 ```astro
 // src/pages/index.astro
 ---
 import LayoutInicio from '../layouts/LayoutInicio.astro';
 ---
-
 <LayoutInicio>
 	<title slot="cabecalho">Astro</title>
 	<h1>Astro</h1>
 </LayoutInicio>
 ```
 
-
 ## Componentes HTML
 
 Astro suporta a importação e uso de arquivos `.html` como componentes ou colocando esses arquivos no subdiretório `src/pages/` como páginas. Você pode querer utilizar componentes HTML se você estiver reutilizando código de um site já construído sem um framework ou se você quer se certificar de que seu componente não tem funcionalidades dinâmicas.
 
 Componentes HTML devem conter apenas HTML válido, e portanto não tem as funcionalidades principais de componentes Astro:
+
 - Eles não suportam frontmatter, importações no lado do servidor ou expressões dinâmicas.
-- Quaisquer tags `<script>` deixam de fazer parte do bundle, sendo tratadas como se tivessem `is:inline`. 
+- Quaisquer tags `<script>` deixam de fazer parte do bundle, sendo tratadas como se tivessem uma [diretiva `is:inline`](/pt-br/reference/directives-reference/#isinline).
 - Eles podem apenas [referenciar assets que estão no diretório `public/`](/pt-br/basics/project-structure/#public).
 
 :::note
-Um [elemento `<slot />`](/pt-br/basics/astro-components/#slots) dentro de um componente HTML irá funcionar assim como funcionaria em um componente Astro. Para utilizar o [Componente Web HTML Slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) no lugar, adicione `is:inline` ao seu elemento `<slot>`.
+Um [elemento `<slot />`](/pt-br/basics/astro-components/#slots) dentro de um componente HTML irá funcionar assim como funcionaria em um componente Astro. Para utilizar o elemento [slot de Web Components do HTML](https://developer.mozilla.org/pt-BR/docs/Web/HTML/Element/slot) no lugar, adicione `is:inline` ao seus elemento `<slot>`.
 :::
 
 ## Próximos Passos
 
-import ReadMore from '~/components/ReadMore.astro';
-
 <ReadMore>Leia mais sobre como utilizar [componentes de frameworks de UI](/pt-br/guides/framework-components/) em seu projeto Astro.</ReadMore>
diff --git a/src/content/docs/pt-br/basics/astro-pages.mdx b/src/content/docs/pt-br/basics/astro-pages.mdx
index aeaaab32e2d16..82e26a8a5a74e 100644
--- a/src/content/docs/pt-br/basics/astro-pages.mdx
+++ b/src/content/docs/pt-br/basics/astro-pages.mdx
@@ -1,17 +1,17 @@
 ---
 title: Páginas
-description: Uma introdução à páginas Astro
+description: Uma introdução às páginas Astro.
 i18nReady: true
 ---
-
 import ReadMore from '~/components/ReadMore.astro';
 import Since from '~/components/Since.astro'
 
-**Páginas** são arquivos que vivem dentro do subdiretório `src/pages/` do seu projeto Astro. Elas são responsáveis por manipular o roteamento, o carregamento de dados e com o layout de toda página do seu website.
+**Páginas** são arquivos que vivem dentro do subdiretório `src/pages/` do seu projeto Astro. Elas são responsáveis por manipular o roteamento, o carregamento de dados e o layout geral de todas as páginas do seu site.
 
 ## Tipos de arquivos suportados
 
 Astro suporta os seguintes tipos de arquivo no diretório `src/pages/`:
+
 - [`.astro`](#páginas-astro)
 - [`.md`](#páginas-markdownmdx)
 - `.mdx` (com a [Integração MDX instalada](/pt-br/guides/integrations-guide/mdx/#installation))
@@ -20,13 +20,13 @@ Astro suporta os seguintes tipos de arquivo no diretório `src/pages/`:
 
 ## Roteamento baseado em arquivos
 
-Astro aproveita uma estratégia de roteamento chamada **roteamento baseado em arquivos**. Cada arquivo no diretório `src/pages` torna-se um endpoint no site com base no caminho do arquivo.
+Astro aproveita uma estratégia de roteamento chamada **roteamento baseado em arquivos**. Cada arquivo no diretório `src/pages` se torna um endpoint no site com base no caminho do arquivo.
 
 Um único arquivo também pode gerar múltiplas páginas utilizando [roteamento dinâmico](/pt-br/guides/routing/#dynamic-routes). Isso permite que você crie páginas mesmo que seu conteúdo esteja fora do diretório especial `/pages/`, como em uma [coleção de conteúdo](/pt-br/guides/content-collections/) ou em um [CMS](/pt-br/guides/cms/).
 
 <ReadMore>Leia mais sobre [Roteamento no Astro](/pt-br/guides/routing/).</ReadMore>
 
-### Link entre páginas
+### Link Entre Páginas
 
 Escreva [elementos `<a>`](https://developer.mozilla.org/pt-BR/docs/Web/HTML/Element/a) padrão HTML em suas páginas Astro para ligar a outras páginas no site. Utilize como link o **caminho URL relativo ao domínio raiz**, não um caminho de arquivo relativo.
 
@@ -53,14 +53,13 @@ Páginas Astro usam a extensão de arquivo `.astro` e suportam as mesmas funcion
 </html>
 ```
 
-Uma página deve produzir um documento HTML completo. Se não for explicitamente incluído, Astro adicionará a declaração `<!DOCTYPE html>` necessária e conteúdo `<head>` em qualquer componente `.astro` localizado em `src/pages/` por padrão. Você pode optar não utilizar esse comportamento de maneira individual por componente, marcando-o como uma página [parcial](#parciais-de-páginas).
+Uma página deve produzir um documento HTML completo. Se não for explicitamente incluído, Astro adicionará a declaração `<!DOCTYPE html>` necessária e conteúdo `<head>` em qualquer componente `.astro` localizado em `src/pages/` por padrão. Você pode optar não utilizar esse comportamento de maneira individual por componente, marcando-o como uma página [parcial](#páginas-parciais).
 
 Para evitar repetir os mesmos elementos HTML em cada página, você pode mover elementos `<head>` e `<body>` comuns em seus próprios [componentes de layout](/pt-br/basics/layouts/). Você pode usar quantos componentes de layout você quiser.
 
-```astro {3} /</?LayoutDoMeuSite>/
+```astro title="src/pages/index.astro" /</?LayoutDoMeuSite>/ {2}
 ---
-// Example: src/pages/index.astro
-import LayoutDoMeuSite from '../layouts/LayoutDoMeuSite.astro';
+import LayoutDoMeuSite from "../layouts/LayoutDoMeuSite.astro";
 ---
 <LayoutDoMeuSite>
   <p>O conteúdo da minha página, envolto em um layout!</p>
@@ -77,17 +76,17 @@ Astro trata quaisquer arquivos Markdown (`.md`) dentro de `src/pages/` como pág
 Considere criar [coleções de conteúdo](/pt-br/guides/content-collections/) em vez de páginas para diretórios de arquivos Markdown relacionados que partilham estrutura similar, como posts de blog ou produtos.
 :::
 
-Arquivos Markdown podem usar a propriedade frontmatter especial `layout` para especificar um [layout de componente](/pt-br/basics/layouts/) que envolverá o conteúdo Markdown em um documento `<html>...</html>`.
+Arquivos Markdown podem usar a propriedade especial `layout` do frontmatter para especificar um [componente de layout](/pt-br/basics/layouts/) que envolverá o conteúdo Markdown em um documento de página `<html>...</html>`.
 
 ```md {3}
 ---
-# Example: src/pages/page.md
-layout: '../layouts/LayoutDoMeuSite.astro'
-title: 'Minha página Markdown'
+# Exemplo: src/pages/pagina.md
+layout: ../layouts/LayoutDoMeuSite.astro
+title: Minha página Markdown
 ---
 # Título
 
-Está é minha página, escrita em **Markdown.**
+Esta é a minha página, escrita em **Markdown.**
 ```
 
 <ReadMore>Leia mais sobre [Markdown](/pt-br/guides/markdown-content/) no Astro.</ReadMore>
@@ -116,30 +115,29 @@ Durante o desenvolvimento, se você tiver um `500.astro`, o erro lançado em tem
 
 <p><Since v="4.11.0" /></p>
 
-`src/pages/500.astro` é uma página especial que recebe automaticamente uma prop `error` para qualquer erro lançado durante a apresentação. Isso permite que você use os detalhes de um erro (como de uma página, de um middleware, etc.) para mostrar informações ao seu visitante.
+`src/pages/500.astro` é uma página especial que recebe automaticamente uma prop `error` para qualquer erro lançado durante a apresentação. Isso permite que você use os detalhes de um erro (por exemplo, como de uma página, de um middleware, etc.) para mostrar informações ao seu visitante.
 
-O tipo de dado da prop error pode ser qualquer coisa, que pode afetar como você tipa ou usa o valor no seu código:
+O tipo de dado da prop `error` pode ser qualquer um, o que pode afetar como você tipa ou usa o valor no seu código:
 
 ```astro title="src/pages/500.astro"
 ---
 interface Props {
-    error: unknown
+  error: unknown;
 }
 
-const { error } = Astro.props
+const { error } = Astro.props;
 ---
-
-<div>{error instanceof Error ? error.message : 'Erro desconhecido'}</div>
+<div>{error instanceof Error ? error.message : "Erro desconhecido"}</div>
 ```
 
 Para evitar vazar informações snsíveis ao mostrar o conteúdo da prop `error`, considere avaliar o erro primeiro, e retornar o conteúdo apropriado baseado no erro lançado. Por exemplo, você deve evitar mostrar a pilha do erro pois ela contém informações sobre como seu código é estruturado no servidor
 
-## Parciais de páginas
+## Páginas Parciais
 
 <p><Since v="3.4.0" /></p>
 
 :::caution
-Parciais de páginas são projetadas para serem utlizadas em conjunto com uma biblioteca front-end, como [htmx](https://htmx.org/) ou [Unpoly](https://unpoly.com/). Você também pode usá-las caso se sinta confortável escrevendo front-end JavaScript em baixo nível. Por esse motivo são um recurso avançado.
+Páginas parciais foram projetadas para serem utilizadas em conjunto com uma biblioteca front-end, como [htmx](https://htmx.org/) ou [Unpoly](https://unpoly.com/). Você também pode usá-las caso se sinta confortável escrevendo front-end JavaScript em baixo nível. Por esse motivo elas são um recurso avançado.
 
 Adicionalmente, parciais não devem ser usadas se o componente contém estilos em escopo ou scripts, pois esses elementos serão removidos do HTML gerado. Se você precisa de estilos em escopo, é melhor utilizar páginas não-parciais regulares em conjunto com uma biblioteca front-end que saiba mesclar conteúdos ao head.
 :::
@@ -148,34 +146,26 @@ Parciais são componentes de página localizados em `src/pages/` que não têm c
 
 Como componentes localizados fora dessa pasta, esses arquivos não incluem automaticamente a declaração `<!DOCTYPE html>`, nem qualquer outro conteúdo do `<head>` como estilos em escopo e scripts.
 
-Entretanto, por estarem localizados no diretório especial `src/pages/`, o HTML gerado fica disponível em uma URL que corresponde ao caminho do arquivo. Isso permite que uma biblioteca de renderização (como htmx, Stimulus, jQuery) possa acessá-lo no cliente e carregar seções do HTML dinamicamente em uma página sem recarregar o navegador ou navegar entre páginas.
+Entretanto, por estarem localizados no diretório especial `src/pages/`, o HTML gerado fica disponível em uma URL que correspondente ao caminho do arquivo. Isso permite que uma biblioteca de renderização (por exemplo, [htmx](https://htmx.org/), [Stimulus](https://stimulus.hotwired.dev/) ou [jQuery](https://jquery.com/)) possa acessá-lo no cliente e carregar seções do HTML dinamicamente em uma página sem recarregar o navegador ou navegar entre páginas.
 
 Parciais, quando combinados com uma biblioteca de renderização, proporcionam uma alternativa às [Ilhas Astro](/pt-br/concepts/islands/) e [tags `<script>`](/pt-br/guides/client-side-scripts/) na construção de conteúdo dinâmico em Astro.
 
-Arquivos de página que podem exportar um valor (ex: `.astro`, `.mdx`) podem ser marcadas como parciais.
-
-Configure um arquivo no diretório `src/pages/` para ser uma parcial adicionando a seguinte exportação:
+Arquivos de página que podem exportar um valor para [`partial`](/pt-br/reference/routing-reference/#partial) (por exemplo, `.astro` e `.mdx`, mas não `.md`) podem ser marcados como parciais.
 
 ```astro title="src/pages/parcial.astro" ins={2}
 ---
 export const partial = true;
 ---
-
-<li>Eu sou uma parcial!</li>
+<li>Eu sou um parcial!</li>
 ```
 
-O `export const partial` deve ser identificável estaticamente. Ele pode ter o valor de:
-
-- O booleano __`true`__.
-- Uma variável de ambiente usando import.meta.env como `import.meta.env.USE_PARTIALS`.
-
-### Usando com uma biblioteca
+### Usando com uma Biblioteca
 
 Parciais são usadas para atualizar dinamicamente a seção de uma página usando bibliotecas como [htmx](https://htmx.org/).
 
 O exemplo a seguir mostra um atributo `hx-post` direcionado para a URL de uma parcial. O conteúdo da página parcial será usado para atualizar o elemento HTML escolhido na página.
 
-```astro title="src/pages/index.astro" 'hx-post="/partials/clicked/"'
+```astro title="src/pages/index.astro" 'hx-post="/parciais/clicado/"'
 <html>
   <head>
     <title>Minha página</title>
@@ -183,21 +173,23 @@ O exemplo a seguir mostra um atributo `hx-post` direcionado para a URL de uma pa
       integrity="sha384-FhXw7b6AlE/jyjlZH5iHa/tTe9EpJ1Y55RjcgPbjeWMskSxZt1v9qkxLJWNJaGni"
       crossorigin="anonymous"></script>
   </head>
+  <body>
+    <section>
+      <div id="parent-div">Alvo aqui</div>
+
+      <button hx-post="/parciais/clicado/"
+        hx-trigger="click"
+        hx-target="#parent-div"
+        hx-swap="innerHTML"
+      >
+        Clique em mim!
+      </button>
+    </section>
+  </body>
 </html>
-<section>
-  <div id="parent-div">Mude aqui</div>
-
-  <button hx-post="/parciais/clicado/"
-    hx-trigger="click"
-    hx-target="#parent-div"
-    hx-swap="innerHTML"
-  >
-      Clique em mim!
-  </button>
-</section>
 ```
 
-A parcial `.astro` deve existir no caminho correspondente e incluir uma exportação definindo a página como uma parcial.
+O parcial `.astro` deve existir no caminho de arquivo correspondente e incluir uma exportação que o defina como parcial:
 
 ```astro title="src/pages/parciais/clicado.astro" {2}
 ---
diff --git a/src/content/docs/pt-br/basics/layouts.mdx b/src/content/docs/pt-br/basics/layouts.mdx
index fbd6e09d82758..a405b21aecb9d 100644
--- a/src/content/docs/pt-br/basics/layouts.mdx
+++ b/src/content/docs/pt-br/basics/layouts.mdx
@@ -1,6 +1,6 @@
 ---
 title: Layouts
-description: Uma introdução a layouts, um tipo de componente Astro que é compartilhado entre páginas para layouts comuns.
+description: Uma introdução aos layouts no Astro.
 i18nReady: true
 ---
 
@@ -8,15 +8,17 @@ import ReadMore from '~/components/ReadMore.astro';
 
 **Layouts** são [componentes Astro](/pt-br/basics/astro-components/) usados para fornecer uma estrutura de UI reutilizável, como um template de página.
 
-Nós convenientemente utilizamos o termo "layout" para componentes Astro que fornecem elementos comuns de UI compartilhados entre páginas como cabeçalhos, barras de navegação e rodapés. Um típico componente de layout Astro fornece [páginas Astro, Markdown ou MDX](/pt-br/basics/astro-pages/) com:
-- uma **casco da página** (tags `<html>`, `<head>` e `<body>`)
-- um [**`<slot />`**](/pt-br/basics/astro-components/#slots) para especificar onde o conteúdo individual da página deve ser injetado.
+Convencionalmente, usamos o termo "layout" para componentes Astro que fornecem elementos comuns de UI compartilhados entre páginas, como cabeçalhos, barras de navegação e rodapés. Um componente de layout Astro típico fornece às [páginas Astro, Markdown ou MDX](/pt-br/basics/astro-pages/):
+- uma **estrutura de página** (tags `<html>`, `<head>` e `<body>`)
+- um [**`<slot />`**](/pt-br/basics/astro-components/#slots) para especificar onde o conteúdo individual da página deve ser inserido.
 
- Porém, não há nada de especial sobre um componente de layout! Eles podem [receber props](/pt-br/basics/astro-components/#props-do-componente) e [importar e utilizar outros componentes](/pt-br/basics/astro-components/#estrutura-do-componente) como qualquer outro componente Astro. Eles podem incluir [componentes de frameworks de UI](/pt-br/guides/framework-components/) e [scripts no lado do cliente](/pt-br/guides/client-side-scripts/). Eles nem precisam fornecer uma casco completo da página, e podem ser utilizados como templates parciais de UI ao invés disso.
+ Porém, não há nada de especial em componentes de layout! Eles podem [receber props](/pt-br/basics/astro-components/#props-do-componente) e [importar e usar outros componentes](/pt-br/basics/astro-components/#estrutura-do-componente) como qualquer outro componente Astro. Eles podem incluir [componentes de frameworks de UI](/pt-br/guides/framework-components/) e [scripts no lado do cliente](/pt-br/guides/client-side-scripts/). Eles nem precisam fornecer uma estrutura de página completa e podem ser usados como templates parciais de UI.
 
-Componentes de layout são comumente inseridos em um diretório `src/layouts` no seu projeto por organização, mas isso não é uma obrigação; você pode escolher colocar eles em qualquer lugar em seu projeto. Você pode até colocar componentes de layout juntamente das suas páginas [prefixando os nomes dos layouts com `_`](/pt-br/guides/routing/#excluding-pages).
+No entanto, se um componente de layout contiver uma estrutura de página, seu elemento `<html>` deverá ser o pai de todos os outros elementos do componente.
 
-## Layout de Exemplo
+Componentes de layout são normalmente colocados em um diretório `src/layouts` no seu projeto para organização, mas isso não é obrigatório; você pode colocá-los onde preferir. Você pode até manter os componentes de layout junto às suas páginas ao [prefixar os nomes dos layouts com `_`](/pt-br/guides/routing/#excluding-pages).
+
+## Exemplo de layout
 
 ```astro "<slot />"
 ---
@@ -43,6 +45,11 @@ const { titulo } = Astro.props;
     </article>
     <Rodape />
   </body>
+  <style>
+    h1 {
+      font-size: 2rem;
+    }
+  </style>
 </html>
 ```
 
@@ -55,59 +62,93 @@ import LayoutDoMeuSite from '../layouts/LayoutDoMeuSite.astro';
 </LayoutDoMeuSite>
 ```
 
-
 <ReadMore>Aprenda mais sobre [slots](/pt-br/basics/astro-components/#slots).</ReadMore>
 
+## Usando TypeScript com layouts
+
+Qualquer layout Astro pode ser modificado para introduzir segurança de tipos e preenchimento automático ao fornecer os tipos de suas props:
+
+```astro ins={2-7} title="src/components/MeuLayout.astro"
+---
+interface Props {
+  titulo: string;
+  descricao: string;
+  dataPublicacao: string;
+  numeroVisualizacoes: number;
+}
+const { titulo, descricao, dataPublicacao, numeroVisualizacoes } = Astro.props;
+---
+<html lang="pt-BR">
+  <head>
+    <meta charset="UTF-8">
+    <meta name="description" content={descricao}>
+    <title>{titulo}</title>
+  </head>
+  <body>
+    <header>
+      <p>Publicado em {dataPublicacao}</p>
+      <p>Visualizado por {numeroVisualizacoes} pessoas</p>
+    </header>
+    <main>
+      <slot />
+    </main>
+  </body>
+</html>
+```
+
 ## Layouts Markdown
 
-Layouts de páginas são especialmente úteis para [páginas Markdown e MDX](/pt-br/guides/markdown-content/#individual-markdown-pages) que caso contrário não teriam nenhuma formatação.
+Layouts de página são especialmente úteis para páginas Markdown individuais que, de outra forma, não teriam nenhuma formatação.
+
+O Astro fornece uma propriedade especial `layout` no frontmatter destinada a [arquivos `.md` individuais localizados em `src/pages/` que usam roteamento baseado em arquivos](/pt-br/guides/markdown-content/#individual-markdown-pages). Essa propriedade especifica qual componente `.astro` deve ser usado como layout da página. O componente permite fornecer conteúdo para o `<head>`, como metatags (por exemplo, `<meta charset="utf-8">`) e estilos para a página Markdown. Por padrão, esse componente especificado pode acessar automaticamente os dados do arquivo Markdown.
 
-Astro fornece a propriedade frontmatter especial `layout` para especificar qual componente `.astro` deve ser utilizado como o layout da página.
+Essa propriedade não é reconhecida como especial ao usar [coleções de conteúdo](/pt-br/guides/content-collections/) para consultar e renderizar seu conteúdo.
 
 ```markdown title="src/pages/pagina.md" {2}
 ---
-layout: ../layouts/LayoutBase.astro
+layout: ../layouts/LayoutPostagemBlog.astro
 titulo: "Olá, Mundo!"
 autor: "Matthew Phillips"
 data: "09 Ago 2022"
 ---
 Todas as propriedades do frontmatter estão disponíveis como props para um componente de layout Astro.
 
-A propriedade `layout` é a única especialmente fornecida pelo Astro.
+A propriedade `layout` é a única propriedade especial fornecida pelo Astro.
 
-Você pode usá-la em ambos arquivos Markdown e MDX localizados dentro de `src/pages/`.
+Você pode usá-la em arquivos Markdown localizados em `src/pages/`.
 
 ```
 
-Um layout típico para páginas Markdown ou MDX inclui:
+Um layout típico para uma página Markdown inclui:
 
-1. A prop `frontmatter` para acessar o frontmatter da página Markdown ou MDX e outros dados.
-2. Um slot [`<slot />`](/pt-br/basics/astro-components/#slots) padrão para indicar onde o conteúdo da página Markdown/MDX deve ser renderizado.
+1. A prop `frontmatter` para acessar o frontmatter da página Markdown e outros dados.
+2. Um [`<slot />`](/pt-br/basics/astro-components/#slots) padrão para indicar onde o conteúdo Markdown da página deve ser renderizado.
 
-```astro /(?<!//.*){?frontmatter(?:\\.\w+)?}?/ "<slot />"
+```astro title="src/layouts/LayoutPostagemBlog.astro" /(?<!//.*){?frontmatter(?:\\.\w+)?}?/ "<slot />"
 ---
-// src/layouts/LayoutBase.astro
-// 1. A prop frontmatter prop dá acesso ao frontmatter e outros dados
+// 1. A prop frontmatter dá acesso ao frontmatter e a outros dados
 const { frontmatter } = Astro.props;
 ---
 <html>
   <head>
-    <!-- Adicione outros elementos da head aqui, como estilos e tags de meta. -->
+    <!-- Adicione outros elementos de head aqui, como estilos e metatags. -->
+    <meta name="viewport" content="width=device-width, initial-scale=1">
+    <meta charset="utf-8">
     <title>{frontmatter.titulo}</title>
   </head>
   <body>
     <!-- Adicione outros componentes de UI aqui, como cabeçalhos e rodapés comuns. -->
     <h1>{frontmatter.titulo} por {frontmatter.autor}</h1>
-    <!-- 2. HTML renderizado será passado para o slot padrão. -->
+    <!-- 2. O HTML renderizado será passado para o slot padrão. -->
     <slot />
     <p>Escrito em: {frontmatter.data}</p>
   </body>
 </html>
 ```
 
-Você pode definir o [tipo `Props`](/pt-br/guides/typescript/#component-props) de um layout com os tipos utilitários `MarkdownLayoutProps` ou `MDXLayoutProps`:
+Você pode definir o [tipo `Props`](/pt-br/guides/typescript/#component-props) de um layout com o tipo utilitário `MarkdownLayoutProps`:
 
-```astro title="src/layouts/LayoutBase.astro" ins={2,4-9}
+```astro title="src/layouts/LayoutPostagemBlog.astro" ins={2,4-9}
 ---
 import type { MarkdownLayoutProps } from 'astro';
 
@@ -118,12 +159,13 @@ type Props = MarkdownLayoutProps<{
   data: string;
 }>;
 
-// Agora, `frontmatter`, `url`, e outras propriedades do layout Markdown
+// Agora, `frontmatter`, `url` e outras propriedades do layout Markdown
 // são acessíveis com segurança de tipos
 const { frontmatter, url } = Astro.props;
 ---
 <html>
   <head>
+    <meta charset="utf-8">
     <link rel="canonical" href={new URL(url, Astro.site).pathname}>
     <title>{frontmatter.titulo}</title>
   </head>
@@ -137,125 +179,79 @@ const { frontmatter, url } = Astro.props;
 
 ### Props de Layout Markdown
 
-Um layout Markdown/MDX terá acesso as seguintes informações pelo `Astro.props`:
-
-- **`file`** - O caminho absoluto deste arquivo (e.x. `/home/usuario/projetos/.../arquivo.md`).
-- **`url`** - Se for uma página, a URL da página (e.x. `/pt-br/guides/markdown-content`).
-- **`frontmatter`** - todo o frontmatter do documento Markdown ou MDX.
-  - **`frontmatter.file`** - O mesmo que a propriedade superior `file`.
-  - **`frontmatter.url`** - O mesmo que a propriedade superior `url`.
-- **`headings`** - Uma lista dos títulos (`h1 -> h6`) no documento Markdown ou MDX com os metadados associados. Esta lista segue o tipo: `{ depth: number; slug: string; text: string }[]`.
-- **(Apenas Markdown) `rawContent()`** - Uma função que retorna o documento Markdown bruto como uma string.
-- **(Apenas Markdown) `compiledContent()`** - Uma função que retorna o documento Markdown compilado como uma string de HTML.
-
-Uma postagem de blog Markdown de exemplo pode passar o seguinte objeto `Astro.props` para seu layout:
-
-```js
-Astro.props = {
-  file: "/home/usuario/projetos/.../arquivo.md",
-  url: "/pt-br/guides/markdown-content/",
-  frontmatter: {
-    /** Frontmatter de uma postagem de blog */
-    title: "Lançamento do Astro 0.18",
-    date: "Terça-feira, 27 de Julho, 2021",
-    author: "Matthew Phillips",
-    description: "Astro 0.18 é o nosso maior lançamento desde o lançamento do Astro.",
-    /** Valores gerados */
-    file: "/home/usuario/projetos/.../arquivo.md",
-    url: "/pt-br/guides/markdown-content/"
-  },
-  headings: [
-    {
-      "depth": 1,
-      "text": "Lançamento do Astro 0.18",
-      "slug": "lançamento-astro-018"
-    },
-    {
-      "depth": 2,
-      "text": "Hidratação parcial responsiva",
-      "slug": "hidratação-partial-responsiva"
-    }
-    /* ... */
-  ],
+Um layout Markdown terá acesso às seguintes informações por meio de `Astro.props`:
 
-  /** Disponível apenas em Markdown */
-  rawContent: () => "# Lançamento do Astro 0.18\nA um pouco menos de um mês atrás, a primeira beta pública [...]",
-  compiledContent: () => "<h1>Lançamento do Astro 0.18</h1>\n<p>A um pouco menos de um mês atrás, a primeira beta pública [...]</p>",
-}
-```
+- **`file`** - O caminho absoluto desse arquivo (por exemplo, `/home/usuario/projetos/.../arquivo.md`).
+- **`url`** - A URL da página (por exemplo, `/pt-br/guides/markdown-content`).
+- **`frontmatter`** - Todo o frontmatter do documento Markdown ou MDX.
+  - **`frontmatter.file`** - O mesmo que a propriedade de nível superior `file`.
+  - **`frontmatter.url`** - O mesmo que a propriedade de nível superior `url`.
+- **`headings`** - Uma lista dos títulos (`h1 -> h6`) do documento Markdown ou MDX e seus metadados associados. Essa lista segue o tipo `{ depth: number; slug: string; text: string }[]`.
+- **`rawContent()`** - Uma função que retorna o documento Markdown bruto como uma string.
+- **`compiledContent()`** - Uma função assíncrona que retorna o documento Markdown compilado como uma string de HTML.
 
 :::note
-Um layout Markdown/MDX terá acesso a todas as [propriedades exportadas](/pt-br/guides/markdown-content/#importing-markdown) do arquivo pelo `Astro.props` **com algumas diferenças principais:**
+Um layout Markdown terá acesso a todas as [propriedades disponíveis](/pt-br/guides/markdown-content/#available-properties) do arquivo Markdown por meio de `Astro.props`, **com duas diferenças importantes:**
 
-* Informação de título (ou seja, elementos `h1 -> h6`) está disponível a partir do array `headings`, ao invés de pela função `getHeadings()`.
+*   As informações dos títulos (ou seja, elementos `h1 -> h6`) estão disponíveis no array `headings`, em vez de em uma função `getHeadings()`.
 
-* `file` e `url` *também* estão disponíveis como propriedades aninhadas de `frontmatter` (ou seja, `frontmatter.url` e `frontmatter.file`).
+*   `file` e `url` *também* estão disponíveis como propriedades aninhadas de `frontmatter` (ou seja, `frontmatter.url` e `frontmatter.file`).
 
-* Valores definidos fora do frontmatter (e.x. declarações de `export` no MDX) não estão disponíveis. Considere [importar um layout](#importando-layouts-manualmente-mdx) no lugar.
 :::
 
 ### Importando Layouts Manualmente (MDX)
 
-Você pode precisar passar informação para o seu layout MDX que não existe (ou não pode existir) no seu frontmatter. Neste caso, você pode importar e utilizar um [componente `<Layout />`](/pt-br/basics/layouts/) no lugar e passar props a ele como qualquer outro componente:
+Você também pode usar a propriedade especial de layout Markdown no frontmatter de arquivos MDX para passar as props `frontmatter` e `headings` diretamente a um componente de layout especificado, da mesma maneira.
+
+Para passar ao seu layout MDX informações que não existem (ou não podem existir) no frontmatter, você pode importar e usar um componente `<Layout />`. Ele funciona como qualquer outro componente Astro e não recebe nenhuma prop automaticamente. Passe diretamente todas as props necessárias:
 
-```mdx title="src/pages/postagens/primeira-postagem.mdx" ins={6} del={2} /</?LayoutBase>/ /</?LayoutBase titulo={frontmatter.titulo} utilitarioSofisticadoJS={utilitarioSofisticadoJS}>/
+```mdx title="src/pages/postagens/primeira-postagem.mdx" ins={6} del={2} /</?LayoutBase>/ /</?LayoutBase title={frontmatter.title} utilitarioSofisticadoJS={utilitarioSofisticadoJS}>/
 ---
 layout: ../../layouts/LayoutBase.astro
 title: 'Minha primeira postagem MDX'
-publishDate: '21 Setembro 2022'
+publishDate: '21 de Setembro de 2022'
 ---
 import LayoutBase from '../../layouts/LayoutBase.astro';
 
 export function utilitarioSofisticadoJS() {
-  return "Tenta fazer isso com YAML!";
+  return 'Tenta fazer isso com YAML!';
 }
 
-<LayoutBase titulo={frontmatter.titulo} utilitarioSofisticadoJS={utilitarioSofisticadoJS}>
+<LayoutBase title={frontmatter.title} utilitarioSofisticadoJS={utilitarioSofisticadoJS}>
   Bem-vindo ao meu novo blog Astro, usando MDX!
 </LayoutBase>
 ```
 
-Agora, seus valores estão disponíveis través do `Astro.props` em seu layout, e seu conteúdo MDX será injetado na página onde o `<slot />` do componente está escrito:
-
-```astro /{?titulo}?/ "utilitarioSofisticadoJS" "{utilitarioSofisticadoJS()}"
----
-// src/layouts/LayoutBase.astro
-const { titulo, utilitarioSofisticadoJS } = Astro.props;
----
-<!-- -->
-<h1>{titulo}</h1>
-<slot /> <!-- seu conteúdo é injetado aqui -->
-<p>{utilitarioSofisticadoJS()}</p>
-<!-- -->
-```
-
-<ReadMore>Aprenda mais sobre o suporte para Markdown e MDDX do Astro em nosso [guia de Markdown/MDX](/pt-br/guides/markdown-content/).</ReadMore>
+Em seguida, seus valores estarão disponíveis por meio de `Astro.props` no layout, e o conteúdo MDX será inserido na página onde o componente `<slot />` estiver escrito:
 
-## Usando um Layout para `.md`, `.mdx` e `.astro`
-
-Um único layout Astro pode ser escrito para receber o objeto `frontmatter` de arquivos `.md` e `.mdx`, assim como quaisquer props nomeadas passadas por arquivos `.astro`.
-
-No exemplo abaixo, o layout irá mostrar o título da página seja pela propriedade `title` do frontmatter YAML ou por um componente Astro passando o atributo `titulo`:
-
-```astro /{?titulo}?/ /Astro.props[.a-z]*/
+```astro title="src/layouts/LayoutBase.astro" /{?title}?/ "utilitarioSofisticadoJS" "{utilitarioSofisticadoJS()}"
 ---
-// src/components/MeuLayout.astro
-const { titulo } = Astro.props.frontmatter || Astro.props;
+const { title, utilitarioSofisticadoJS } = Astro.props;
 ---
 <html>
-  <head></head>
+  <head>
+    <!-- -->
+    <meta charset="utf-8">
+  </head>
   <body>
-    <h1>{titulo}</h1>
-    <slot />
+    <!-- -->
+    <h1>{title}</h1>
+    <slot /> <!-- seu conteúdo é inserido aqui -->
+    <p>{utilitarioSofisticadoJS()}</p>
+    <!-- -->
   </body>
 </html>
 ```
 
+Ao usar qualquer layout (pela propriedade `layout` do frontmatter ou pela importação de um layout), inclua a tag `<meta charset="utf-8">` no layout, pois o Astro não a adicionará mais automaticamente à sua página MDX.
+
+<ReadMore>Saiba mais sobre o suporte do Astro a Markdown e MDX em nosso [guia de Markdown](/pt-br/guides/markdown-content/).</ReadMore>
+
 ## Aninhando Layouts
 
-Componentes de layout não precisam conter uma página inteira de HTML. Você pode separar seus layouts em pequenos componentes e então, combinar componentes de layout para criar templates de páginas ainda mais flexíveis. Esse padrão é útil quando você quer compartilhar algum código através de múltiplos layouts.
+Componentes de layout não precisam conter uma página inteira de HTML. Você pode separar seus layouts em componentes menores e combiná-los para criar templates de página ainda mais flexíveis. Esse padrão é útil quando você quer compartilhar algum código através de múltiplos layouts.
 
-Por exemplo, um componente de layout `LayoutPostagemBlog.astro` pode estilizar um título de uma postagem, data e autor. Então, um `LayoutBase.astro` de todo o site poderia lidar com o resto do template da sua página, como navegação, rodapés, meta tags SEO, estilos globais e fontes. Você também pode passar props recebidas da sua postagem para outro layout, assim como em qualquer outro componente aninhado.
+Por exemplo, um componente de layout `LayoutPostagemBlog.astro` pode estilizar o título, a data e o autor de uma postagem. Então, um `LayoutBase.astro` de todo o site poderia lidar com o resto do template da sua página, como navegação, rodapés, metatags de SEO, estilos globais e fontes. Você também pode passar props recebidas da sua postagem para outro layout, assim como em qualquer outro componente aninhado.
 
 ```astro {3} /</?LayoutBase>/ /</?LayoutBase url={frontmatter.url}>/
 ---
diff --git a/src/content/docs/pt-br/basics/project-structure.mdx b/src/content/docs/pt-br/basics/project-structure.mdx
index fe4109666ca88..a301b77bd60fd 100644
--- a/src/content/docs/pt-br/basics/project-structure.mdx
+++ b/src/content/docs/pt-br/basics/project-structure.mdx
@@ -1,6 +1,6 @@
 ---
 title: Estrutura de Projetos
-description: Aprenda a estruturar um projeto com Astro.
+description: Uma introdução à estrutura básica de arquivos de um projeto Astro.
 i18nReady: true
 ---
 import { FileTree } from '@astrojs/starlight/components';
@@ -13,7 +13,7 @@ Aqui está como um projeto Astro é organizado e alguns arquivos que você irá
 
 Astro inclui uma estrutura de diretórios padronizados para o seu projeto. A raiz de qualquer projeto Astro deve incluir os seguintes diretórios e arquivos:
 
-- `src/*` - O código-fonte do seu projeto (componentes, páginas, estilos, etc.)
+- `src/*` - O código-fonte do seu projeto (componentes, páginas, estilos, imagens, etc.)
 - `public/*` - Seus arquivos sem código, assets não processados (fontes, ícones, etc.)
 - `package.json` - Um manifesto do projeto.
 - `astro.config.mjs` - Um arquivo de configuração do Astro. (recomendado)
@@ -43,8 +43,8 @@ Os diretórios de um projeto Astro comum devem se aparecer com isto:
   - layouts/
     - LayoutPostagem.astro
   - pages/
-    - postagems/
-      - [post].astro
+    - postagens/
+      - [postagem].astro
     - sobre.astro
     - **index.astro**
     - rss.xml.js
@@ -58,7 +58,7 @@ Os diretórios de um projeto Astro comum devem se aparecer com isto:
 
 ### `src/`
 
-A pasta src é onde a maioria do código-fonte do seu projeto está. Isso inclui:
+A pasta `src/` é onde a maioria do código-fonte do seu projeto está. Isso inclui:
 
 - [Páginas](/pt-br/basics/astro-pages/)
 - [Layouts](/pt-br/basics/layouts/)
@@ -94,7 +94,7 @@ Essa é uma prática comum em projetos Astro, porém não é obrigatória. Sinta
 
 [Layouts](/pt-br/basics/layouts/) são componentes do Astro que definem a estrutura de UI compartilhada por uma ou mais [páginas](/pt-br/basics/astro-pages/).
 
-Assim como o diretório `src/components`, é uma prática comum porém não obrigatória.
+Assim como `src/components`, esse diretório é uma prática comum porém não obrigatória.
 
 ### `src/styles`
 
@@ -114,7 +114,7 @@ Como uma regra geral, qualquer CSS ou JavaScript que você mesmo escrever deve e
 
 ### `package.json`
 
-Este é um arquivo utilizado por gerenciadores de pacotes de JavaScript para gerenciar suas dependências. Ele também define scripts que são comumente usados para executar o Astro (ex: `npm start`, `npm run build`).
+Este é um arquivo utilizado por gerenciadores de pacotes de JavaScript para gerenciar suas dependências. Ele também define scripts que são comumente usados para executar o Astro (por exemplo, `npm run dev` e `npm run build`).
 
 Existem [dois tipos de dependências](https://docs.npmjs.com/specifying-dependencies-and-devdependencies-in-a-package-json-file) que você pode especificar em um arquivo `package.json`: `dependencies` e `devDependencies`. Na maioria dos casos, elas funcionam da mesma forma: Astro precisa de todas as dependências em tempo de build e seu gerenciador de pacotes irá instalar ambas. Nós recomendados colocar todas as suas dependências em `dependencies` de início e apenas utilizar `devDependencies` se você tiver um motivo específico para fazer isso.
 
@@ -128,7 +128,7 @@ Astro suporta vários formatos de arquivo para seu arquivo de configuração Jav
 
 O arquivo de configuração TypeScript é processado usando [`tsm`](https://github.com/lukeed/tsm) e vai respeitar as opções do `tsconfig` do seu projeto.
 
-Veja o guia [Configurando Astro](/pt-br/reference/configuration-reference/) para mais detalhes em como definir configurações.
+Consulte a [referência de configuração](/pt-br/reference/configuration-reference/) para ver todos os detalhes.
 
 ### `tsconfig.json`