diff --git a/src/content/docs/pt-br/concepts/why-astro.mdx b/src/content/docs/pt-br/concepts/why-astro.mdx
index 580558e9a4b19..b7a38ebfe64b3 100644
--- a/src/content/docs/pt-br/concepts/why-astro.mdx
+++ b/src/content/docs/pt-br/concepts/why-astro.mdx
@@ -74,6 +74,6 @@ Um dos nossos provérbios favoritos é: **opte por mais complexidade.** Nós fiz
 
 **Astro é um framework web tudo em um que vem com tudo o que você precisa para construir um website.** Astro inclui uma sintaxe de componentes, roteamento baseado em arquivos, manipulação de assetes, processo de build, bundling, otimizações, busca de dados e mais. Você pode construir ótimos websites sem se aproximar de funcionalidades fora do núcleo do Astro.
 
-Se você precisar de mais controle, você pode expandir o Astro com [+100 integrações](https://astro.build/integrations/) como [React](https://www.npmjs.com/package/@astrojs/react), [Svelte](https://www.npmjs.com/package/@astrojs/svelte), [Vue](https://www.npmjs.com/package/@astrojs/vue), [Tailwind CSS](https://www.npmjs.com/package/@astrojs/tailwind), [MDX](https://www.npmjs.com/package/@astrojs/mdx), [otimização de imagens](https://www.npmjs.com/package/@astrojs/image) e mais. [Conectar o seu CMS favorito](/pt-br/guides/cms/) ou [fazer deploy para seu host favorito](/pt-br/guides/deploy/) com apenas um comando.
+Se você precisar de mais controle, você pode expandir o Astro com [+100 integrações](https://astro.build/integrations/) como [React](https://www.npmjs.com/package/@astrojs/react), [Svelte](https://www.npmjs.com/package/@astrojs/svelte), [Vue](https://www.npmjs.com/package/@astrojs/vue), [Tailwind CSS](https://www.npmjs.com/package/@astrojs/tailwind), [MDX](https://www.npmjs.com/package/@astrojs/mdx) e mais. [Conectar o seu CMS favorito](/pt-br/guides/cms/) ou [fazer deploy para seu host favorito](/pt-br/guides/deploy/) com apenas um comando.
 
 Astro é agnóstico a UI, o que significa que você pode **Trazer o seu Próprio Framework de UI (BYOF, do inglês, "Bring Your Own Ui Framework")**. React, Preact, Solid, Svelte, Vue e Lit são todos oficialmente suportados no Astro. Você pode até misturar diferentes frameworks na mesma página, fazendo migrações futuras mais fáceis e prevenindo que você fique preso a um único framework.
diff --git a/src/content/docs/pt-br/core-concepts/endpoints.mdx b/src/content/docs/pt-br/core-concepts/endpoints.mdx
index c99826d2e6cd2..30b1008949bdc 100644
--- a/src/content/docs/pt-br/core-concepts/endpoints.mdx
+++ b/src/content/docs/pt-br/core-concepts/endpoints.mdx
@@ -10,34 +10,31 @@ O Astro permite que você crie endpoints customizados para servir e processar to
 Em sites gerados de forma estática, seus endpoints customizados são chamados durante a fase de build para produzir arquivos estáticos. Já em sites usando o [modo SSR](/pt-br/guides/server-side-rendering/#habilitando-o-ssr-em-seu-projeto) seus endpoints customizados se tornarão endpoints reais executados a cada requisição. Endpoints estáticos e SSR são definidos de maneira similar, mas os endpoints SSR suportam funcionalidades adicionais.
 
 ## Endpoints de Arquivos Estáticos
+
 Para criar um endpoint customizado, adicione um arquivo `.js` ou `.ts` no diretório `/pages`. A extensão do arquivo será removida durante o processo de build, portanto o nome do arquivo deve conter a extensão que você deseja que os dados usem, por exemplo `src/pages/data.json.ts` se tornará a rota `/data.json`.
 
-Seus endpoints devem exportar uma função `get` (opcionalmente assíncrona) que recebe um [objeto de contexto](/pt-br/reference/api-reference/#contexto-de-endpoint) com propriedades similares a global `Astro`. Ele retorna um objeto com um `body`, que o Astro irá chamar durante a build e utilizar seu conteúdo para gerar o arquivo.
+Seus endpoints devem exportar uma função `GET` (opcionalmente assíncrona) que recebe um [objeto de contexto](/pt-br/reference/api-reference/#contexto-de-endpoint) com propriedades similares a global `Astro`. Aqui, ele retorna um objeto `Response` com um `name` e `url`, que o Astro irá chamar durante a build e utilizar seu conteúdo para gerar o arquivo.
 
 ```ts
 // Exemplo: src/pages/builtwith.json.ts
 // Se tornará: /builtwith.json
-export async function get({params, request}) {
-  return {
-    body: JSON.stringify({
+export async function GET({params, request}) {
+  return new Response(
+    JSON.stringify({
       name: 'Astro',
-      url: 'https://astro.build/',
-    }),
-  };
+      url: 'https://astro.build/'
+    })
+  )
 }
 ```
 
-O objeto retornado também pode conter a propriedade `encoding`. Ela deve ser uma string válida do tipo [`BufferEncoding`](https://github.com/DefinitelyTyped/DefinitelyTyped/blob/bdd02508ddb5eebcf701fdb8ffd6e84eabf47885/types/node/buffer.d.ts#L169) aceita pelo método `fs.writeFile` do Node.js. Por exemplo, para gerar uma imagem no formato png retornamos:
+Desde o Astro v3.0, 0 objeto `Response` retornado não tem mais que incluir a propriedade `encoding`. Por exemplo, para produzir uma imagem binária png:
 
-```ts title="src/pages/builtwith.json.ts" {6}
-export async function get({ params, request }) {
+```ts title="src/pages/builtwith.json.ts" {3}
+export async function GET({ params, request }) {
   const response = await fetch("https://docs.astro.build/assets/full-logo-light.png");
-  const buffer = Buffer.from(await response.arrayBuffer());
-  return {
-    body: buffer,
-    encoding: 'binary',
-  };
-};
+  return new Response(await response.arrayBuffer());
+}
 ```
 
 Também é possível adicionar validação de tipo à sua função com o tipo `APIRoute`:
@@ -45,8 +42,7 @@ Também é possível adicionar validação de tipo à sua função com o tipo `A
 ```ts
 import type { APIRoute } from 'astro';
 
-export const get: APIRoute = async ({ params, request }) => {
-...
+export const GET: APIRoute = async ({ params, request }) => {...}
 ```
 
 ### Roteamento dinâmico e a propriedade `params`
@@ -56,45 +52,47 @@ Os endpoints suportam as mesmas funcionalidades de [roteamento dinâmico](/pt-br
 ```ts title="src/pages/api/[id].json.ts"
 import type { APIRoute } from 'astro';
 
-const usuarios = ["Sarah", "Chris", "Dan"]
+const usuarios = ["Sarah", "Chris", "Yan", "Elian"]
 
-export const get: APIRoute = ({ params, request }) => {
+export const GET: APIRoute = ({ params, request }) => {
   const id = params.id;
-  return {
-    body: JSON.stringify({
+  return new Response(
+    JSON.stringify({
       name: usuarios[id]
     })
-  }
-};
+  )
+}
 
-export function getStaticPaths () {
+export function getStaticPaths() {
   return [ 
     { params: { id: "0"} },
     { params: { id: "1"} },
     { params: { id: "2"} },
+    { params: { id: "3"} }
   ]
 }
 ```
 
-Dessa forma serão gerados três endpoints JSON durante a build: `/api/0.json`, `/api/1.json` e `/api/2.json`. O roteamento dinâmico com endpoints funciona da mesma forma que nas páginas, porém, como um endpoint é uma função e não uma página, [props](/pt-br/reference/api-reference/#passagem-de-dados-com-props) não são suportadas.
+Isso irá gerar quatro endpoints JSON durante a build: `/api/0.json`, `/api/1.json`, `/api/2.json` e `/api/3.json`. O roteamento dinâmico com endpoints funciona da mesma forma que nas páginas, porém, como um endpoint é uma função e não uma página, [props](/pt-br/reference/api-reference/#passagem-de-dados-com-props) não são suportadas.
 
 ### `request`
+
 Todos os endpoints recebem uma propriedade `request`, porém no modo estático você só tem acesso a propriedade `request.url`. Ela retorna o URL completo do endpoint atual e funciona da mesma forma que [Astro.request.url](/pt-br/reference/api-reference/#astrorequest) funciona em páginas.
 
 ```ts title="src/pages/request-path.json.ts"
 import type { APIRoute } from 'astro';
 
-export const get: APIRoute = ({ params, request }) => {
-  return {
-    body: JSON.stringify({
+export const GET: APIRoute = ({ params, request }) => {
+  return new Response(JSON.stringify({
       path: new URL(request.url).pathname
     })
-  };
+  )
 }
 ```
 
 ## Endpoints do Servidor (Rotas de API)
-Tudo descrito na seção de endpoints de arquivos estáticos também pode ser utilizado no modo SSR: arquivos podem exportar uma função `get` que recebe um [objeto de contexto](/pt-br/reference/api-reference/#contexto-de-endpoint) com propriedades similares a global `Astro`.
+
+Tudo descrito na seção de endpoints de arquivos estáticos também pode ser utilizado no modo SSR: arquivos podem exportar uma função `GET` que recebe um [objeto de contexto](/pt-br/reference/api-reference/#contexto-de-endpoint) com propriedades similares a global `Astro`.
 
 Porém, diferente do modo `static`, quando você configura o modo `server`, os endpoints serão construídos no momento em que são requisitados. Isso desbloqueia novas funcionalidades que estão indisponíveis durante a build e permite que você construa rotas de API que respondem requisições e seguramente executam código no servidor em runtime.
 
@@ -109,7 +107,7 @@ Os endpoints do servidor tem acesso a propriedade `params` sem exportar a funç
 ```js title="src/pages/[id].json.js"
 import { getProduct } from '../db';
 
-export async function get({ params }) {
+export async function GET({ params }) {
   const id = params.id;
   const product = await getProduct(id);
 
@@ -120,12 +118,14 @@ export async function get({ params }) {
     });
   }
 
-  return new Response(JSON.stringify(product), {
-    status: 200,
-    headers: {
-      "Content-Type": "application/json"
+  return new Response(
+    JSON.stringify(product), {
+      status: 200,
+      headers: {
+        "Content-Type": "application/json"
+      }
     }
-  });
+  );
 }
 ```
 
@@ -134,7 +134,7 @@ Esse código responderá a qualquer requisição que corresponda à rota dinâmi
 No modo SSR, certos provedores requerem que o cabeçalho `Content-Type` retorne uma imagem. Neste caso, utilize um objeto `Response` para especificar uma propriedade `headers`. Por exemplo, para produzir uma imagem `.png` binária:
 
 ```ts title="src/pages/astro-logo.png.ts"
-export async function get({ params, request }) {
+export async function GET({ params, request }) {
   const response = await fetch("https://docs.astro.build/assets/full-logo-light.png");
   const buffer = Buffer.from(await response.arrayBuffer());
   return new Response(buffer, {
@@ -144,55 +144,49 @@ export async function get({ params, request }) {
 ```
 
 ### Métodos HTTP
-Além da função `get`, você pode exportar uma função com o nome de qualquer [método HTTP](https://developer.mozilla.org/pt-BR/docs/Web/HTTP/Methods). Assim, quando uma requisição for recebida, o Astro irá checar o método e chamar a função correspondente.
 
-Também é possível exportar uma função `all` para corresponder a todos os métodos que já não tenham suas respectivas funções exportadas. Se houver uma requisição sem método correspondente, ela será redirecionada para a sua [página de 404](/pt-br/core-concepts/astro-pages/#página-customizada-de-erro-404).
+Além da função `GET`, você pode exportar uma função com o nome de qualquer [método HTTP](https://developer.mozilla.org/pt-BR/docs/Web/HTTP/Methods). Assim, quando uma requisição for recebida, o Astro irá checar o método e chamar a função correspondente.
 
-:::note
-Como `delete` é uma palavra reservada do JavaScript, exporte uma função chamada `del` para corresponder ao método delete.
-:::
+Também é possível exportar uma função `ALL` para corresponder a todos os métodos que já não tenham suas respectivas funções exportadas. Se houver uma requisição sem método correspondente, ela será redirecionada para a sua [página de 404](/pt-br/core-concepts/astro-pages/#página-customizada-de-erro-404).
 
 ```ts title="src/pages/methods.json.ts"
-export const get: APIRoute = ({ params, request }) => {
-  return {
-    body: JSON.stringify({
-      message: "Método GET"
+export const GET: APIRoute = ({ params, request }) => {
+  return new Response(JSON.stringify({
+      message: "Isso foi um GET!"
     })
-  }
-};
+  )
+}
 
-export const post: APIRoute = ({ request }) => {
-  return {
-    body: JSON.stringify({
-      message: "Método POST!"
+export const POST: APIRoute = ({ request }) => {
+  return new Response(JSON.stringify({
+      message: "Isso foi um POST!"
     })
-  }
+  )
 }
 
-export const del: APIRoute = ({ request }) => {
-  return {
-    body: JSON.stringify({
-      message: "Método DELETE!"
+export const DELETE: APIRoute = ({ request }) => {
+  return new Response(JSON.stringify({
+      message: "Isso foi um DELETE!"
     })
-  }
+  )
 }
 
-export const all: APIRoute = ({ request }) => {
-  return {
-    body: JSON.stringify({
-      message: `Método ${request.method}!`
+export const ALL: APIRoute = ({ request }) => {
+  return new Resonse(JSON.stringify({
+      message: `Isso foi um ${request.method}!`
     })
-  }
+  )
 }
 ```
 
 <RecipeLinks slugs={["pt-br/recipes/captcha", "pt-br/recipes/build-forms-api" ]}/>
 
 ### `request`
+
 No modo SSR, a propriedade `request` retorna um objeto [`Request`](https://developer.mozilla.org/pt-BR/docs/Web/API/Request) completamente utilizável que se refere a requisição atual. Isso permite que você aceite dados e cheque cabeçalhos:
 
 ```ts title="src/pages/test-post.json.ts"
-export const post: APIRoute = async ({ request }) => {
+export const POST: APIRoute = async ({ request }) => {
   if (request.headers.get("Content-Type") === "application/json") {
     const body = await request.json();
     const name = body.name;
@@ -207,12 +201,13 @@ export const post: APIRoute = async ({ request }) => {
 ```
 
 ### Redirecionamentos
+
 O contexto do endpoint exporta um utilitário `redirect()` similar ao `Astro.redirect`:
 
 ```js title="src/pages/links/[id].js" {14}
 import { getLinkUrl } from '../db';
 
-export async function get({ params, redirect }) {
+export async function GET({ params, redirect }) {
   const { id } = params;
   const link = await getLinkUrl(id);
 
diff --git a/src/content/docs/pt-br/core-concepts/project-structure.mdx b/src/content/docs/pt-br/core-concepts/project-structure.mdx
index 27ef7e458b90d..18c5c996e66d8 100644
--- a/src/content/docs/pt-br/core-concepts/project-structure.mdx
+++ b/src/content/docs/pt-br/core-concepts/project-structure.mdx
@@ -66,10 +66,6 @@ Alguns arquivos (como componentes Astro) nem sequer são enviados ao navegador c
 Enquanto esse guia descreve algumas convenções populares usadas na comunidade do Astro, as únicas pastas reservadas pelo Astro são `src/pages/` e `src/content`. Você é livre para renomear e reorganizar quaisquer outras pastas de uma forma que funciona melhor para você.
 :::
 
-### `src/assets`
-
-A pasta [`src/assets`](/pt-br/guides/assets/) é a pasta recomendada para armazenar assets (e.x. imagens) a serem processados pelo Astro. Isso não é obrigatório, e esta não é uma pasta especial reservada.
-
 ### `src/components`
 
 **Componentes** são pedaços reutilizáveis de código para suas páginas HTML. Eles podem ser [componentes Astro](/pt-br/core-concepts/astro-components/) ou [componentes de frameworks de UI](/pt-br/core-concepts/framework-components/) como React ou Vue. É comum agrupar e organizar todos os componentes do seu projeto nesta pasta.
diff --git a/src/content/docs/pt-br/guides/content-collections.mdx b/src/content/docs/pt-br/guides/content-collections.mdx
index b03443ff35896..5e5812fd242ce 100644
--- a/src/content/docs/pt-br/guides/content-collections.mdx
+++ b/src/content/docs/pt-br/guides/content-collections.mdx
@@ -395,6 +395,17 @@ const entradasPublicadasBlog = await getCollection('blog', ({ data }) => {
 });
 ```
 
+
+Você também pode criar páginas de rascunho que são disponibilizadas ao executar o servidor de desenvolvimento, mas não são construídas em produção:
+
+```js
+// Exemplo: Filtrar entradas de conteúdo com `draft: true` apenas ao fazer build para produção
+import { getCollection } from 'astro:content';
+const entradasBlog = await getCollection('blog', ({ data }) => {
+  return import.meta.env.PROD ? data.draft !== true : true;
+});
+```
+
 O argumento de filtragem também suporta filtragem por pastas aninhadas dentro de uma coleção. Já que o `id` inclui o caminho aninhado completo, você pode filtrar pelo começo de cada `id` para retornar somente itens de uma pasta aninhada específica:
 
 ```js
@@ -706,7 +717,7 @@ Esse guia mostra como converter um projeto com Astro existente com arquivos Mark
     import rss from "@astrojs/rss";
     import { getCollection } from "astro:content";
 
-    export async function get() {
+    export async function GET() {
       const postagens = await getCollection('postagens');
       return rss({
         title: 'Astro Learner | Blog',
diff --git a/src/content/docs/pt-br/guides/deploy/netlify.mdx b/src/content/docs/pt-br/guides/deploy/netlify.mdx
index d1cbd2cb2b307..03697ed085763 100644
--- a/src/content/docs/pt-br/guides/deploy/netlify.mdx
+++ b/src/content/docs/pt-br/guides/deploy/netlify.mdx
@@ -121,7 +121,7 @@ Você também pode criar um site na Netlify e vincular o seu repositório Git in
 
 ### Defina uma versão do Node.js
 
-Se você está usando uma [imagem de build](https://docs.netlify.com/configure-builds/get-started/#build-image-selection) legada (Xenial) na Netlify, certifique-se de que a versão do Node.js está definida. Astro requer `v16.12.0` ou superior.
+Se você está usando uma [imagem de build](https://docs.netlify.com/configure-builds/get-started/#build-image-selection) legada (Xenial) na Netlify, certifique-se de que a versão do Node.js está definida. Astro requer `v18.14.1` ou superior.
 
 Você pode [especificar a versão do Node.js na Netlify](https://docs.netlify.com/configure-builds/manage-dependencies/#node-js-and-javascript) usando:
 - um arquivo [`.nvmrc`](https://github.com/nvm-sh/nvm#nvmrc) em seu diretório base.
diff --git a/src/content/docs/pt-br/guides/deploy/render.mdx b/src/content/docs/pt-br/guides/deploy/render.mdx
index 934edb6b16e92..c05b44a1d9765 100644
--- a/src/content/docs/pt-br/guides/deploy/render.mdx
+++ b/src/content/docs/pt-br/guides/deploy/render.mdx
@@ -15,5 +15,5 @@ Você pode fazer deploy do seu projeto Astro no [Render](https://render.com/), u
 4. Dê um nome ao seu site, selecione a branch e especifique o comando de build e diretório de publicação
    - **build command:** `npm run build`
    - **publish directory:** `dist`
-   - **Environment variables (advanced)**: Por padrão, o Render utiliza Node.js 14.17.0, mas o Astro [requer uma versão maior](/pt-br/install/auto/#pré-requisitos). Adicione uma variável de ambiente com uma **Variable key** de `NODE_VERSION` e um **Value** de `16.12.0` ou maior para instruir o Render a usar uma versão compatível do Node.js. Alternativamente, adicione um arquivo [`.node-version`](https://render.com/docs/node-version) ou [`.nvmrc`](https://render.com/docs/node-version) em seu projeto para especificar uma versão do Node.js.
+   - **Environment variables (advanced)**: Por padrão, o Render utiliza Node.js 14.17.0, mas o Astro [requer uma versão maior](/pt-br/install/auto/#pré-requisitos). Adicione uma variável de ambiente com uma **Variable key** de `NODE_VERSION` e um **Value** de `18.14.1` ou maior para instruir o Render a usar uma versão compatível do Node.js. Alternativamente, adicione um arquivo [`.node-version`](https://render.com/docs/node-version) ou [`.nvmrc`](https://render.com/docs/node-version) em seu projeto para especificar uma versão do Node.js.
 5. Clique no botão **Create Static Site**
diff --git a/src/content/docs/pt-br/guides/deploy/vercel.mdx b/src/content/docs/pt-br/guides/deploy/vercel.mdx
index fe505b5665004..4e3dbafaa9d9e 100644
--- a/src/content/docs/pt-br/guides/deploy/vercel.mdx
+++ b/src/content/docs/pt-br/guides/deploy/vercel.mdx
@@ -84,4 +84,4 @@ Você pode utilizar `vercel.json` para sobrescrever o comportamento padrão da V
 
 ### Atualizando para Astro 2.0
 
-Astro v2.0 remove suporte para Node 14, então certifique-se de que seu projeto está utilizando **Node `16.12.0` ou maior**. Você pode [definir a versão do Node.js](https://vercel.com/changelog/node-js-version-now-customizable-in-the-project-settings) usada durante a Etapa de Build e Funções Serverless pela página "General" em "Project Settings".
+Astro v2.0 remove suporte para Node 14, então certifique-se de que seu projeto está utilizando **Node `18.14.1` ou maior**. Você pode [definir a versão do Node.js](https://vercel.com/changelog/node-js-version-now-customizable-in-the-project-settings) usada durante a Etapa de Build e Funções Serverless pela página "General" em "Project Settings".
diff --git a/src/content/docs/pt-br/guides/integrations-guide.mdx b/src/content/docs/pt-br/guides/integrations-guide.mdx
index bc1dc1933f289..8b9e3c79b15c8 100644
--- a/src/content/docs/pt-br/guides/integrations-guide.mdx
+++ b/src/content/docs/pt-br/guides/integrations-guide.mdx
@@ -126,17 +126,17 @@ Para remover uma integração, primeiro desinstale a integração do seu projeto
 <PackageManagerTabs>
   <Fragment slot="npm">
   ```shell
-  npm uninstall @astrojs/image
+  npm uninstall @astrojs/react
   ```
   </Fragment>
   <Fragment slot="pnpm">
   ```shell
-  pnpm uninstall @astrojs/image
+  pnpm uninstall @astrojs/react
   ```
   </Fragment>
   <Fragment slot="yarn">
   ```shell
-  yarn remove @astrojs/image
+  yarn remove @astrojs/react
   ```
   </Fragment>
 </PackageManagerTabs>
@@ -146,11 +146,11 @@ Depois, remova a integração do seu arquivo `astro.config.*`:
 ```js title="astro.config.mjs" del={3,7}
 import { defineConfig } from 'astro/config'
 
-import image from "@astrojs/image";
+import react from "@astrojs/react";
 
 export default defineConfig({
   integrations: [
-    image()
+    react()
   ]
 })
 ```
diff --git a/src/content/docs/pt-br/guides/markdown-content.mdx b/src/content/docs/pt-br/guides/markdown-content.mdx
index 6c41fa67c052f..2e9ed87ff8e20 100644
--- a/src/content/docs/pt-br/guides/markdown-content.mdx
+++ b/src/content/docs/pt-br/guides/markdown-content.mdx
@@ -58,65 +58,6 @@ Provavelmente não está muito estiloso, porém o Markdown suporta:
 
 📚 Leia mais sobre o [roteamento baseado em arquivos](/pt-br/core-concepts/routing/) do Astro ou opções para criar [rotas dinâmicas](/pt-br/core-concepts/routing/#rotas-dinâmicas).
 
-### Páginas de Rascunho
-
-`draft: true` é um valor opcional de frontmatter irá marcar uma individual página ou postagem Markdown ou MDX como "não publicada". Por padrão, essa página será:
-
-- excluída da build do site (a página não será construída)
-
-- retornada por `Astro.glob()` (visível na lista de postagens)
-
-```markdown {5}
----
-# src/pages/post/postagem-blog.md
-layout: ../../layouts/LayoutBase.astro
-title: Minha Postagem do Blog
-draft: true
----
-
-Esta é a postagem que eu estou fazendo no meu blog.
-
-Nenhuma página terá build feito para esta postagem.
-
-Para fazer a build e publicar esta postagem:
-
-- atualize o frontmatter para `draft: false` ou
-- remova a propriedade `draft` completamente.
-
-Porém, esta página _será_ retornada por quaisquer requisições `Astro.glob()` correspondentes.
-```
-
-Para excluir postagens de rascunho de serem inclusas no arquivo de postagens, ou listar as postagens mais recentes, você pode filtrar os resultados retornados pelo `Astro.glob()`:
-
-```js
-const postagens = await Astro.glob('../pages/postagens/*.md');
-const postagensSemRascunhos = postagens.filter((postagem) => !postagem.frontmatter.draft);
-```
-
-:::note[Usando coleções de conteúdo?]
-Essa funcionalidade não suporta coleções de conteúdo, entretanto você pode utilizar um [filtro de consulta de coleção](/pt-br/guides/content-collections/#filtrando-consultas-de-coleção) para filtrar seus rascunhos de postagens.
-:::
-
-#### Habilitando a build de páginas de rascunho
-
-Para habilitar a build de páginas de rascunho por padrão, atualize `astro.config.mjs` adicionando `drafts: true` em `markdown` ou na integração `mdx`:
-
-```js title="astro.config.mjs" ins={5, 8}
-import { defineConfig } from 'astro/config';
-
-export default defineConfig({
-  markdown: {
-    drafts: true,
-  },
-  integrations: [mdx({
-    drafts: true,
-  })],
-});
-```
-
-:::tip
-Você também pode passar a flag `--drafts` ao executar `astro build` para fazer a build de páginas de rascunho!
-:::
 
 ## Funcionalidades do Markdown
 
@@ -186,7 +127,7 @@ Por exemplo, para prevenir `<` de ser interpretado como o começo de um elemento
 
 Adicionar a [integração MDX](/pt-br/guides/integrations-guide/mdx/) do Astro aprimora sua experiência de autoria com Markdown com variáveis JSX, expressões e componentes.
 
-Ela também adiciona funcionalidades extras ao MDX padrão, incluindo suporte para [frontmatter estilo Markdown no MDX](https://mdxjs.com/guides/frontmatter/). Isso te permite utilizar a maioria das funcionalidades integradas para Markdown do Astro como a propriedade [frontmatter `layout`](#frontmatter-layout) e a configuração de [páginas de rascunho](#páginas-de-rascunho).
+Ela também adiciona funcionalidades extras ao MDX padrão, incluindo suporte para [frontmatter estilo Markdown no MDX](https://mdxjs.com/guides/frontmatter/). Isso te permite utilizar a maioria das funcionalidades integradas para Markdown do Astro como a propriedade [frontmatter `layout`](#frontmatter-layout).
 
 Arquivos `.mdx` devem ser escritos na [sintaxe do MDX](https://mdxjs.com/docs/what-is-mdx/#mdx-syntax) ao invés da sintaxe semelhante ao HTML do Astro.
 
diff --git a/src/content/docs/pt-br/guides/middleware.mdx b/src/content/docs/pt-br/guides/middleware.mdx
index 22e7b53b9d53c..a9e270525b193 100644
--- a/src/content/docs/pt-br/guides/middleware.mdx
+++ b/src/content/docs/pt-br/guides/middleware.mdx
@@ -45,7 +45,7 @@ Você pode importar e utilizar a função utilitária `defineMiddleware()` para
 
 ```ts
 // src/middleware.ts
-import { defineMiddleware } from "astro/middleware";
+import { defineMiddleware } from "astro:middleware";
 
 // `context` e `next` são tipados automaticamente
 export const onRequest = defineMiddleware((context, next) => {
@@ -138,7 +138,7 @@ export const onRequest = async (context, next) => {
 Múltiplos middlewares podem ser conectados em uma sequência ordenada utilizando [`sequence()`](#sequence):
 
 ```js title="src/middleware.js"
-import { sequence } from "astro/middleware";
+import { sequence } from "astro:middleware";
 
 async function validacao(_, next) {
     console.log("validação da requisição");
diff --git a/src/content/docs/pt-br/guides/rss.mdx b/src/content/docs/pt-br/guides/rss.mdx
index 9afe081bf01cf..ce36f06d90e81 100644
--- a/src/content/docs/pt-br/guides/rss.mdx
+++ b/src/content/docs/pt-br/guides/rss.mdx
@@ -47,7 +47,7 @@ O arquivo de exemplo abaixo `src/pages/rss.xml.js` vai criar um feed RSS em `sit
 ```js title="src/pages/rss.xml.js"
 import rss from '@astrojs/rss';
 
-export function get(context) {
+export function GET(context) {
   return rss({
     // campo `<title>` no xml final
     title: 'Blog do Buzz',
@@ -81,7 +81,7 @@ Para criar um feed RSS de páginas gerenciadas em [coleções de conteúdo](/pt-
 import rss from '@astrojs/rss';
 import { getCollection } from 'astro:content';
 
-export async function get(context) {
+export async function GET(context) {
   const blog = await getCollection('blog');
   return rss({
     title: 'Blog do Buzz',
@@ -128,7 +128,7 @@ Essa função assume, mas não verifica, que todas as propriedades necessárias
 ```js title="src/pages/rss.xml.js" "pagesGlobToRssItems" "await pagesGlobToRssItems("
 import rss, { pagesGlobToRssItems } from '@astrojs/rss';
 
-export async function get(context) {
+export async function GET(context) {
   return rss({
     title: 'Blog do Buzz',
     description: 'O guia de um humilde Astronauta para as estrelas',
@@ -166,7 +166,7 @@ import sanitizeHtml from 'sanitize-html';
 import MarkdownIt from 'markdown-it';
 const parser = new MarkdownIt();
 
-export async function get(context) {
+export async function GET(context) {
   const blog = await getCollection('blog');
   return rss({
     title: 'Blog do Buzz',
@@ -188,7 +188,7 @@ Ao utilizar importações de glob com Markdown, você pode utilizar o utilitári
 import rss from '@astrojs/rss';
 import sanitizeHtml from 'sanitize-html';
 
-export function get(context) {
+export function GET(context) {
   const resultadoImportacaoPostagem = import.meta.glob('../postagens/**/*.md', { eager: true });
   const postagens = Object.values(resultadoImportacaoPostagem);
   return rss({
diff --git a/src/content/docs/pt-br/guides/server-side-rendering.mdx b/src/content/docs/pt-br/guides/server-side-rendering.mdx
index c9248e622d11e..cd9f64b4651a6 100644
--- a/src/content/docs/pt-br/guides/server-side-rendering.mdx
+++ b/src/content/docs/pt-br/guides/server-side-rendering.mdx
@@ -172,7 +172,7 @@ E para um endpoint:
 ```js title="src/pages/meuendpoint.js" {1}
 export const prerender = true;
 
-export async function get() {
+export async function GET() {
   return {
     body: JSON.stringify({ message: `Este é meu endpoint estático` }),
   };
@@ -186,7 +186,7 @@ Para um aplicação majoritariamente estática configurada como `output: hybrid`
 ```js title="src/pages/numeroaleatorio.js" {1}
 export const prerender = false;
 
-export async function get() {
+export async function GET() {
   let numero = Math.random();
   return {
     body: JSON.stringify({ numero, mensagem: `Aqui está um número aleatório: ${numero}` }),
diff --git a/src/content/docs/pt-br/guides/styling.mdx b/src/content/docs/pt-br/guides/styling.mdx
index 6f2764d526e56..979ef61efedea 100644
--- a/src/content/docs/pt-br/guides/styling.mdx
+++ b/src/content/docs/pt-br/guides/styling.mdx
@@ -41,11 +41,11 @@ Este CSS:
 Compila para isto:
 ```astro
 <style>
-  h1:where(.astro-HHNQFKH6) {
+  h1[data-astro-cid-hhnqfkh6] {
      color: red;
   }
 
-  .text:where(.astro-HHNQFKH6) {
+  .text[data-astro-cid-hhnqfkh6] {
     color: blue;
   }
 </style>
@@ -159,7 +159,7 @@ import MeuComponente from "../components/MeuComponente.astro"
 <MeuComponente class="vermelho">Isso será vermelho!</MeuComponente>
 ```
 
-Esse padrão te permite estilizar componentes filhos diretamente. Astro irá passar o nome de classe com escopo do pai (e.x. `astro-HHNQFKH6`) através da prop `class` automaticamente, incluindo o filho no seu escopo de pai.
+Esse padrão te permite estilizar componentes filhos diretamente. Astro irá passar o nome de classe com escopo do pai (e.x. `astro-hhnqfkh6`) através da prop `class` automaticamente, incluindo o filho no seu escopo de pai. Note que esse padrão funciona apenas quando sua [opção `scopedStyleStrategy`](/pt-br/reference/configuration-reference/#scopedstylestrategy) é `'where'` ou `'class'`.
 
 :::note[Classes com escopo de componentes pai]
 Por conta da prop `class` incluir o filho no escopo do seu pai, é possível que estilos cascatem do pai para o filho. Para evitar que isso tenha efeitos colaterais indesejados, certifique-se de utilizar nomes de classe únicos no componente filho.
@@ -529,26 +529,38 @@ Se você estiver utilizando Tailwind, o [plugin typography](https://tailwindcss.
 
 ## Produção
 
-### Controle de pacote
+### Controle de bundle
 
-Quando o Astro faz a build do seu site para lançamento em produção, ele combina seu CSS em pedaços. Cada página no seu site é seu próprio pedaço, e adicionalmente, o CSS que é compartilhado entre múltiplas páginas é dividido em seus próprios pedaços para reutilização.
+Quando o Astro faz a build do seu site para lançamento em produção, ele minifica e combina seu CSS em pedaços. Cada página no seu site ganha seu próprio pedaço, e adicionalmente, o CSS que é compartilhado entre múltiplas páginas é dividido em seus próprios pedaços para reutilização.
 
-Em cada um dos seus arquivos HTML vai ter tags `<link rel="stylesheet">` adicionadas, uma para cada pedaço que a página precisa.
+Contudo, quando você tem diversas páginas compartilhando estilos, alguns pedaços compartilhados podem se tornar realmente pequenos. Se todos eles fossem enviados separadamente, isso levaria a muitas requisições de folhas de estilo e afetaria a performance do site. Portanto, por padrão o Astro irá fazer link apenas daquelas no seu HTML acima de 4kB em tamanho como tags `<link rel="stylesheet">`, enquanto adiciona inline as menores como `<style type="text/css">`. Essa abordagem fornece um equilíbrio entre o número de requisições adicionais e o volume de CSS que pode ser cacheado entre páginas.
 
-Sites com um grande número de páginas e muitos estilos diferentes compartilhados podem ocasionar em várias requisições de folhas de estilo e afetar o desempenho do site. Você pode configurar a opção `inlineStylesheets` para reduzir o número dessas requisições colocando as folhas de estilo (minimizadas) em uma tag `<style>` ao invés de requisitar elas externamente.
+Você pode configurar o tamanho no qual folhas de estilo serão adicionadas com links externos (em bytes) utilizando a opção da build do vite `assetsInlineLimit`. Note que essa pção afeta a adição inline de scripts e imagens também.
+
+```js
+import { defineConfig } from 'astro/config';
+
+export default defineConfig({
+  vite: {
+    build: {
+      assetsInlineLimit: 1024,
+    }
+  };
+});
+```
+
+Se você preferir que todos os estilos do projeto continuem externos, você pode configurar a opção da build `inlineStylesheets`.
 
 ```js
 import { defineConfig } from 'astro/config';
 
 export default defineConfig({
   build: {
-    inlineStylesheets: 'auto'
+    inlineStylesheets: 'never'
   }
 });
 ```
 
-A opção `'auto'` vai colocar em linha apenas as folhas de estilo que estão abaixo do limite de `vite.build.assetsInlineLimit`, reduzindo o número de requisições por folhas menores. Grandes folhas de estilo, como as globais usadas por todas as páginas, ainda serão buscadas externamente e armazenadas em cache. Essa opção fornece um balanço entre o número de folhas de estilos carregadas e os estilos que podem ser armazenados em cache entre páginas.
-
 Você também pode definir essa opção como `'always'` que vai colocar em linha todas as folhas de estilo.
 
 ## Avançado
diff --git a/src/content/docs/pt-br/guides/troubleshooting.mdx b/src/content/docs/pt-br/guides/troubleshooting.mdx
index 4496b973013e5..7353cfdfc550f 100644
--- a/src/content/docs/pt-br/guides/troubleshooting.mdx
+++ b/src/content/docs/pt-br/guides/troubleshooting.mdx
@@ -198,7 +198,7 @@ Para te ajudar a depurar seus componentes Astro, Astro providencia um componente
 
 ```astro {2,7}
 ---
-import { Debug } from 'astro/components';
+import { Debug } from 'astro:components';
 const soma = (a, b) => a + b;
 ---
 
@@ -210,7 +210,7 @@ O componente Debug suporta uma variedade de opções de sintaxe para uma depura
 
 ```astro {2,7-9}
 ---
-import { Debug } from 'astro/components';
+import { Debug } from 'astro:components';
 const soma = (a, b) => a + b;
 const answer = soma(2, 4);
 ---
diff --git a/src/content/docs/pt-br/guides/upgrade-to/v3.mdx b/src/content/docs/pt-br/guides/upgrade-to/v3.mdx
new file mode 100644
index 0000000000000..7ce5da79218d2
--- /dev/null
+++ b/src/content/docs/pt-br/guides/upgrade-to/v3.mdx
@@ -0,0 +1,639 @@
+---
+title: Atualize para o Astro v3
+description: Como atualizar seu projeto para a versão mais recente do Astro (v3.0).
+i18nReady: true
+---
+import PackageManagerTabs from '~/components/tabs/PackageManagerTabs.astro'
+import FileTree from '~/components/FileTree.astro'
+
+Este guia vai te ajudar a migrar do Astro v2 para o Astro v3.
+
+Precisa atualizar um projeto antigo para a v2? Veja nosso [antigo guia de migração](/pt-br/guides/upgrade-to/v2/).
+
+## Atualize Astro
+
+Atualize a versão do Astro de seu projeto para a versão mais recente utilizando seu gerenciador de pacotes. Se você está utilizando integrações Astro, por favor também as atualize para a versão mais recente.
+
+<PackageManagerTabs>
+  <Fragment slot="npm">
+  ```shell
+  # Atualize para Astro v3.x
+  npm install astro@latest
+  
+  # Exemplo: atualize as integrações React e Tailwind
+  npm install @astrojs/react@latest @astrojs/tailwind@latest
+  ```
+  </Fragment>
+  <Fragment slot="pnpm">
+  ```shell
+  # Atualize para v3.x
+  pnpm install astro@latest
+
+  # Exemplo: atualize as integrações React e Tailwind
+  pnpm install @astrojs/react@latest @astrojs/tailwind@latest
+  ```
+  </Fragment>
+  <Fragment slot="yarn">
+  ```shell
+  # Atualize para v3.x
+  yarn add astro@latest
+  
+  # Exemplo: atualize as integrações React e Tailwind
+  yarn add @astrojs/react@latest @astrojs/tailwind@latest
+  ```
+  </Fragment>
+</PackageManagerTabs>
+
+:::note[É necessário continuar?]
+Após atualizar Astro para a versão mais recente, você pode não precisar fazer quaisquer mudanças ao seu projeto afinal!
+Porém, se você notar erros ou comportamentos inesperados, por favor veja abaixo o que mudou que pode precisar ser atualizado em seu projeto.
+:::
+
+## Flags Experimentais Removidas do Astro v3.0
+
+Remova as seguintes flags experimentais de `astro.config.mjs`:
+
+```js del={5-8}
+// astro.config.mjs
+import { defineConfig } from 'astro/config';
+
+export default defineConfig({
+  experimental: {
+    assets: true,
+    viewTransitions: true,
+  },
+})
+```
+
+Essas funcionalidades agora estão disponíveis por padrão:
+
+- Transições de Visualização para transições de página animadas e ilhas persistentes. Veja as [mudanças radicais da API de transições de visualização e dicas para atualização](/pt-br/guides/view-transitions/#atualize-para-v30-da-v2x) se você estava utilizando essa flag experimental.
+- Uma nova API de serviço de imagem `astro:assets` para utilizar imagens no Astro, incluindo um novo componente `<Image />` e a função `getImage()`. Por favor leia as detalhadas [dicas de atualização para imagens](/pt-br/guides/images/#atualize-para-v30-da-v2x) **se você estava ou não utilizando essa flag experimental** para ver como isso pode afetar seu projeto.
+
+Leia mais sobre essas duas funcionalidades eletrizantes e mais na postagem do blog sobre a 3.0!
+
+
+## Mudanças Radicais do Astro v3.0
+
+Astro v3.0 inclui algumas mudanças radicais, assim como a remoção de algumas funcionalidades anteriormente depreciadas. Se o seu projeto não funciona como esperado após atualizar para a v3.0, veja este guia para uma visão geral sobre todas as mudanças radicais e instruções em como atualizar sua base de código.
+
+Veja o [registro de mudanças](https://github.com/withastro/astro/blob/main/packages/astro/CHANGELOG.md) para as notas completas do lançamento.
+
+### Removido: Suporte para o Node 16
+
+Node 16 está marcado para chegar seu Fim de Vida em setembro de 2023.
+
+Astro v3.0 tira o suporte para Node 16 completamente para que todos os usuários do Astro se aproveitem das funcionalidades mais modernas do Node.
+
+#### O que devo fazer?
+
+ Verifique eu tanto seu ambiente de desenvolvimento quanto seu ambiente de deployment estão utilizando **Node `18.14.1` ou superior**.
+
+1. Verifique sua versão local do Node utilizando:
+
+    ```sh
+    node -v
+    ```
+
+
+
+2. Verifique a própria documentação do seu [ambiente de deployment](/pt-br/guides/deploy/) para verificar que ele suporta Node 18. 
+
+    Você pode especificar Node `18.14.1` para seu projeto Astro tanto em uma opção da configuração do painel de controle ou em um arquivo `.nvmrc`.
+
+```bash title=".nvmrc"
+18.14.1
+```
+### Removido: Suporte para TypeScript 4
+
+Na Astro v2.x, as predefinições de `tsconfig.json` incluiam suporte para ambos TypeScript 4.x e 5.x.
+
+Astro v3.0 atualiza as predefinições de `tsconfig.json` para apenas suportar TypeScript 5.x. Astro agora assume que você utiliza TypeScript 5.0 (Março de 2023), ou que seu editor o inclui (e.x. VS Code 1.77).
+
+#### O que devo fazer?
+
+Se você tem o TypeScript instalado localmente, atualize pelo menos para a v5.0.
+
+```bash
+npm install typescript@latest --save-dev
+```
+
+### Removido: `@astrojs/image`
+
+No Astro v2.x, Astro oferecia uma integração de imagens oficial que incluia os componentes Astro `<Image />` e `<Picture />`.
+
+Astro v3.0 remove essa integração da base de código completamente. A nova solução para imagens do Astro é uma API integrada de serviços de imagem: `astro:assets`.
+
+#### O que devo fazer?
+
+Remova a integração `@astrojs/image` do seu projeto. Você irá precisar não só desinstalar a integração mas também atualizar ou remover quaisquer declarações de importação e quaisquer componentes `<Image />` e `<Picture />` existentes. Você também vai precisar configurar um serviço de processamento de imagem padrão de sua preferência.
+
+Você irá encontrar [instruções passo a passo completas para remover a integração de imagens antiga](/pt-br/guides/images/#remova-astrojsimage) em nosso guia de Imagens.
+
+Migrar para `astro:assets` também irá trazer algumas novas opções de imagem e funcionalidades que você pode desejar utilizar agora. Por favor veja as [dicas de atualização para imagens da v3.0](/pt-br/guides/images/#atualize-para-v30-da-v2x) para mais detalhes!
+
+```js del={3,7}
+// astro.config.mjs
+import { defineConfig } from 'astro/config';
+import image from '@astrojs/image';
+
+export default defineConfig({
+  integrations: [
+    image(),
+  ]
+})
+```
+
+### Removido: Componente `<Markdown />`
+
+No Astro v1.x, Astro depreciou o componente `<Markdown />` e o moveu para um pacote externo.
+
+Astro v3.0 remove completamente o pacote `@astrojs/markdown-component`. O componente `<Markdown />` do Astro não irá mais funcionar no seu projeto.
+
+#### O que devo fazer?
+
+Remova todas as instâncias de `@astrojs/markdown-component`.
+
+```astro del={2} title="src/components/MeuComponenteAstro.astro"
+---
+import Markdown from '@astrojs/markdown-component';
+---
+```
+
+Para continuar utilizando um componente `<Markdown />` similar no seu código, considere utilizar [integrações da comunidade](https://astro.build/integrations/) assim como [`astro-remote`](https://github.com/natemoo-re/astro-remote). Certifique-se de atualizar as importações e atributos do seu componente `<Markdown />` conforme necessário, de acordo com a documentação da própria integração. 
+
+Como alternativa, delete todas as referências importando o componente `<Markdown />` do Astro e o próprio componente em seus arquivos `.astro`. Você vai precisar escrever novamente seu conteúdo como HTML diretamente ou [importar Markdown](/pt-br/guides/markdown-content/#importando-markdown) de um arquivo `.md`.
+
+### Removido: APIs depreciadas da 1.x
+
+No Astro v1.x, Astro depreciou opções da configuração assim como os tipos de atributo de script/style `global` e `hoist`. Esses foram mantidos por compatibilidade com versões anteriores.
+
+Astro v3.0 remove essas APIs depreciadas completamente. Elas não podem mais ser usadas no seu projeto Astro.
+
+#### O que devo fazer?
+
+Se você continua utilizando APIs da v1.x, utilize as novas APIs para cada uma das funcionalidades no lugar:
+
+- Opções depreciadas da configuração: Veja [o guia de migração da 0.26](/pt-br/guides/upgrade-to/v1/#new-configuration-api)
+- Tipos de atributo de script/style depreciados: Veja [o guia de migração da 0.26](/pt-br/guides/upgrade-to/v1/#new-default-script-behavior)
+
+### Removido: `image` do `astro:content` no esquema de coleções de conteúdo
+
+No Astro v2.x, a API de coleções de conteúdo depreciou a exportação `image` do `astro:content` utilizada no esquema de suas coleções de conteúdo.
+
+Astro v3.0 remove essa exportação completamente.
+
+#### O que devo fazer?
+
+Se você está utilizando o `image()` depreciado do `astro:content`, o remova, já que ele não existe mais. Valide imagens através do [utilitário `image` de `schema`](/pt-br/guides/images/#atualize-esquemas-de-coleções-de-conteúdo) no lugar:
+
+ ```ts title="astro.config.mjs" del={1} ins={2} "({ image })"
+import { defineCollection, z, image } from "astro:content";
+import { defineCollection, z } from "astro:content";
+
+ defineCollection({
+   schema: ({ image }) =>
+     z.object({
+       image: image(),
+    }),
+});
+```
+
+### Removido: nomes de temas do Shiki pré-0.14
+
+No Astro v2.x, alguns nomes de tema do Shiki foram renomeados, mas os nomes originais foram mantidos por compatibilidade com versões anteriores.
+
+Astro v3.0 remove os nomes originais em favor dos nomes de tema renomeados.
+
+#### O que devo fazer?
+
+Se o seu projeto utiliza qualquer um dos temas abaixo, os renomeie para seu nome atualizado:
+
+- `material-darker` -> `material-theme-darker`
+- `material-default` -> `material-theme`
+- `material-lighter` -> `material-theme-lighter`
+- `material-ocean` -> `material-theme-ocean`
+- `material-palenight` -> `material-theme-palenight`
+
+### Removido: Funcionalidades do `class:list`
+
+No Astro v2.x, a [diretiva `class:list`](/pt-br/reference/directives-reference/#classlist) utilizava uma implementação customizada, inspirada por [`clsx`](https://github.com/lukeed/clsx) com algumas funcionalidades extras como desduplicação e suporte para `Set`.
+
+Astro v3.0 agora utiliza `clsx` diretamente para `class:list`, que não suporta desduplicação ou valores `Set`.
+
+#### O que devo fazer?
+
+Substitua quaisquer elementos `Set` passados para a diretiva `class:list` com um `Array` plano.
+
+```astro title="src/components/MeuComponenteAstro.astro" del={4} ins={5}
+<Componente class:list={[
+  'a',
+  'b',
+  new Set(['c', 'd'])
+  ['c', 'd'] 
+]} />
+```
+
+### Removido: passar `class:list` como uma prop
+
+No Astro v2.x, [valores de `class:list`](/pt-br/reference/directives-reference/#classlist) eram passados para componentes através de [`Astro.props['class:list']`](/pt-br/reference/api-reference/#astroprops).
+
+Astro v3.0 normaliza valores de `class:list` em uma string antes de os enviar para componentes através de `Astro.props['class']`
+
+#### O que devo fazer?
+
+Remova qualquer código que espera receber a prop `class:list`.
+
+```astro title="src/components/MeuComponenteAstro.astro" del={2,3,7} ins={4,8} "classList" "'class:list': classList"
+---
+import { clsx } from 'clsx';
+const { class: className, 'class:list': classList } = Astro.props;
+const { class: className } = Astro.props;
+---
+<div
+  class:list={[className, classList]}
+  class:list={[className]}
+/>
+```
+
+### Removido: transformação de variáveis CSS de camelCase para kebab-case
+
+No Astro v2.x, [variáveis CSS](/pt-br/guides/styling/#variáveis-no-css) camelCase passadoas para o atributo `style` eram renderizadas tanto como camelCase (assim como foi escrito) como em kebab-case (mantido por compatibilidade com versões anteriores).
+
+Astro v3.0 remove a transformação para kebab-case de nomes de variáveis CSS em camelCase, e apenas a variável CSS original em camelCase é renderizada.
+
+```astro "meu-valor"
+---
+// src/components/MeuComponenteAstro.astro
+const meuValor = "red"
+---
+<!-- input -->
+<div style={{ "--meuValor": meuValor }}></div>
+
+<!-- resultado (Astro 2.x) -->
+<div style="--meu-valor:var(--meuValor);--meuValor:red"></div>
+<!-- resultado (Astro 3.0) -->
+<div style="--meuValor:red"></div>
+```
+
+#### O que devo fazer?
+
+Se você dependia no Astro para transformar em kebab-case em seus estilos, atualize seus estilos existentes para camelCase para prevenir estilos faltando. Por exemplo:
+
+```astro del={3} ins={4} title="src/components/MeuComponenteAstro.astro"
+<style>
+  div {
+   color: var(--meu-valor);
+   color: var(--meuValor);
+  }
+</style>
+```
+
+### Removido: Planificação automática do valor de retorno de `getStaticPaths()`
+
+No Astro v2.x, o valor de retorno de [`getStaticPaths()`](/pt-br/reference/api-reference/#getstaticpaths) era automaticamente planificado para te permitir retornar um array sem nenhum erro.
+
+Astro v3.0 remove a planificação automática do resultado de `getStaticPaths()`.
+
+#### O que devo fazer?
+
+Se você está retornando um array de arrays no lugar de um array de _objetos_ (como é esperado), `.flatMap` e `.flat` agora devem ser usados para garantir que você está retornando um array plano.
+
+Uma [mensagem de erro indicando que o valor de retorno de `getStaticPath()` deve ser um array de objetos](/pt-br/reference/errors/invalid-get-static-paths-entry/#what-went-wrong) será providenciado se você precisa atualizar seu código.
+
+### Movido: `astro check` agora requer um pacote externo
+
+No Astro v2.x, [`astro check`](/pt-br/reference/cli-reference/#astro-check) era incluso com o Astro por padrão, e suas dependências eram embutidas no Astro. Isso significava em um pacote maior, independente se você usava ou não `astro check`. Isso também te prevenia de ter controle sobre a versão do TypeScript e o Servidor de Linguagem do Astro a se utilizar.
+
+
+Astro v3.0 move o comando `astro check` para fora do núcleo do Astro e agora requer o pacote externo `@astrojs/check`. Adicionalmente, você deve instalar `typescript` em seu projeto para utilizar o comando `astro check`.
+
+#### O que devo fazer?
+
+Execute o comando `astro check` após atualizar para o Astro v3.0 e siga as instruções para instalar as dependências necessárias, ou manualmente instale `@astrojs/check` e `typescript` em seu projeto.
+
+### Depreciado: `build.excludeMiddleware` e `build.split`
+
+No Astro v2.x, `build.excludeMiddleware` e `build.split` eram utilizados para mudar como arquivos específicos eram emitidos ao utilizar um adaptador no modo SSR.
+
+Astro v3.0 substitui essas opções de configuração da build com novas [opções de configuração de adaptadores SSR](/pt-br/guides/integrations-guide/#integrações-oficiais) para realizar as mesmas tarefas: `edgeMiddleware` e `functionPerRoute`.
+
+#### O que devo fazer?
+
+Atualize o arquivo de configuração do Astro para agora utilizar as novas opções **na configuração do adaptador** diretamente.
+
+```js title="astro.config.mjs" del={5-7} ins={9}
+import { defineConfig } from "astro/config";
+import vercel from "@astrojs/vercel/serverless";
+
+export default defineConfig({
+    build: {
+      excludeMiddleware: true
+    },
+    adapter: vercel({
+      edgeMiddleware: true
+    }),
+});
+```
+
+```js title="astro.config.mjs" del={5-7} ins={9}
+import { defineConfig } from "astro/config";
+import netlify from "@astrojs/netlify/functions";
+
+export default defineConfig({
+     build: {
+        split: true
+     },
+     adapter: netlify({
+        functionPerRoute: true
+     }),
+});
+```
+
+### Depreciado: `markdown.drafts`
+
+No Astro v2.x, a configuração `markdown.drafts` te permitia ter páginas de rascunho que eram disponibilizadas ao executar o servidor de desenvolvimento, mas não na build para produção.
+
+Astro v3.0 deprecia essa funcionalidade em favor do método de coleções de conteúdo de manipular páginas de rascunho filtrando manualmente no lugar, o que te dá mais controle sobre a funcionalidade.
+
+#### O que devo fazer?
+
+Para continuar a marcar algumas páginas em seu projeto como rascunhos, [migue para coleções de conteúdo](/pt-br/guides/content-collections/#migrando-do-roteamento-baseado-em-arquivos) e [filtre páginas manualmente](/pt-br/guides/content-collections/#filtrando-consultas-de-coleção) com a propriedade do frontmatter `draft: true` no lugar.
+
+### Depreciado: retornar um objeto simples de endpoints
+
+No Astro v2.x, endpoints podiam retornar um objeto simples, que seria convertido para uma resposta JSON.
+
+Astro v3.0 deprecia esse comportamento em favor de retornar um objeto `Response` diretamente.
+
+#### O que devo fazer?
+
+Atualize seus endpoints para reotrnar um objeto `Response` diretamente.
+
+```ts title="endpoint.json.ts" del={2} ins={3}
+export async function GET() {
+  return { body: { "titulo": "Blog do Bob" }};
+  return new Response(JSON.stringify({ "titulo": "Blog do Bob" }));
+}
+```
+
+Se você realmente precisar manter o formato anterior, você pode utilizar o objeto `ResponseWithEncoding`, mas isso será depreciado no futuro.
+
+```ts title="endpoint.json.ts" del={2} ins={3}
+export async function GET() {
+  return { body: { "titulo": "Blog do Bob" } };
+  return new ResponseWithEncoding({ body: { "titulo": "Blog do Bob" }});
+}
+```
+
+
+### Padrão modificado: porta `3000`
+
+No Astro v2.x, Astro era executado na porta `3000` por padrão.
+
+Astro v3.0 muda a [porta padrão](/pt-br/reference/cli-reference/#--port) para `4321`. 🚀
+
+#### O que devo fazer?
+
+Atualize quaisquer referências a `localhost:3000`, por exemplo em testes ou em seu `README`, para refletir a nova porta `localhost:4321`.
+
+
+### Padrão modificado: import.meta.env.BASE_URL `trailingSlash`
+
+No Astro v2.x, `import.meta.env.BASE_URL` anexava sua opção [`base`](/pt-br/reference/configuration-reference/#base) com [`trailingSlash`](/pt-br/reference/configuration-reference/#trailingslash) por padrão. `trailingSlash: "ignore"` também anexava com uma barra final.
+
+Astro v3.0 não mais anexa `import.meta.env.BASE_URL` com uma barra final por padrão, nem quando `trailingSlash: "ignore"` é definido. (O comportamento existente de `base` em combinação com `trailingSlash: "always"` ou `trailingSlash: "never"` não mudou.)
+
+#### O que devo fazer?
+
+Se sua `base` já tem uma barra final, nenhuma mudança é necessária.
+
+Se sua `base` não tem uma barra final, adicione uma se você deseja preservar o comportamento padrão anterior (ou `trailingSlash: "ignore"`):
+
+```js title="astro.config.mjs" del={4} ins={5}
+import { defineConfig } from "astro/config";
+
+export default defineConfig({
+  base: 'minha-base',
+  base: 'minha-base/',
+});
+```
+
+### Padrão modificado: `compressHTML`
+
+No Astro v2.x, Astro apenas comprimia seu HTML emitido quando [`compressHTML`](/pt-br/reference/configuration-reference/#compresshtml) era explicitamente definido como `true`. O valor padrão era `false`.
+
+Astro v3.0 agora comprime HTML emitido por padrão.
+
+#### O que devo fazer?
+
+Agora você pode remover `compressHTML: true` de sua configuração já que esse é o novo comportamento padrão.
+
+```js title="astro.config.mjs" del={4}
+import { defineConfig } from "astro/config";
+
+export default defineConfig({
+  compressHTML: true
+})
+```
+
+Agora você deve definir `compressHTML: false` para optar por sair da compressão de HTML.
+
+### Padrão modificado: `scopedStyleStrategy`
+
+No Astro v2.x, o valor padrão de [`scopedStyleStrategy`](/pt-br/reference/configuration-reference/#scopedstylestrategy) era `"where"`.
+
+Astro v3.0 introduz um novo valor padrão: `"attribute"`. Por padrão, estilos agora são aplicados utilizando atributos `data-*`.
+
+#### O que devo fazer?
+
+Para manter o [escopo dos estilos](/pt-br/guides/styling/#estilos-com-escopo), atualize o arquivo de configuração para o valor padrão anterior: 
+
+
+```js title="astro.config.mjs" ins={4}
+import { defineConfig } from "astro/config";
+
+export default defineConfig({
+  scopedStyleStrategy: "where"
+})
+```
+
+### Padrão modificado: `inlineStyleSheets`
+
+No Astro v2.x, todas as folhas de estilo foram enviadas como tags link por padrão. Você poderia optar por adicioná-las inline em tags `<style>` toda vez com `"always"`, ou adicionar inline apenas folhas de estilo abaixo de um certo tamanho com `"auto"` definindo a configuração [`build.inlineStylesheets`](/pt-br/reference/configuration-reference/#buildinlinestylesheets). A opção padrão era `"never"`.
+
+Astro v3.0 modifica o valor padrão de `inlineStylesheets` para `"auto"`. Folhas de estilo menores que `ViteConfig.build.assetsInlineLimit` (padrão: 4kb) são adicionadas inline por padrão. Caso contrário, estilos do projeto eram enviados como folhas de estilo externas.
+
+#### O que devo fazer?
+
+Se você quer manter o comportamento atual do seu projeto, defina `build.inlineStylesheets` para o padrão anterior, `"never"`:
+
+
+```js title="astro.config.mjs" ins={4-6}
+import { defineConfig } from "astro/config";
+
+export default defineConfig({
+	 build: {
+    inlineStylesheets: "never"
+  }
+})
+```
+
+### Padrão modificado: serviço de imagem
+
+No Astro v2.x, Squoosh era o [serviço padrão de processamento de imagem](/pt-br/guides/images/#serviço-de-imagem-padrão).
+
+Astro v3.0 agora inclui Sharp como o novo serviço de processamento de imagem padrão e fornece uma opção da configuração para utilizar Squoosh no lugar.
+
+#### O que devo fazer?
+
+Se você preferir continuar a usar Squoosh para transformar suas imagens, atualize sua configuração com o seguinte: 
+
+```ts title="astro.config.mjs" ins={4-6}
+import { defineConfig, squooshImageService } from "astro/config";
+
+export default defineConfig({
+  image: {
+    service: squooshImageService(),
+  }
+})
+```
+
+### Modificado: Capitalização dos métodos de requisição HTTP
+
+No Astro v2.x, [métodos de requisição HTTP](/pt-br/core-concepts/endpoints/#métodos-http) eram escritos usando nomes de função em letras minúsculas: `get`, `post`, `put`, `all` e `del`.
+
+Astro v3.0 utiliza nomes de função em letras maiúsculas, incluindo `DELETE` ao invés de `del`.
+
+#### O que devo fazer?
+
+Renomeie todas as funções para seus equivalentes em letras maiúsculas:
+
+- `get` para `GET`
+- `post` para `POST`
+- `put` para `PUT`
+- `all` para `ALL`
+- `del` para `DELETE`
+
+```js title="endpoint.ts" del={1} ins={2}
+export function get() {
+export function GET() {
+    return new Response(JSON.stringify({ "titulo": "Blog do Bob" }));
+}
+```
+
+### Modificado: Configuração de múltiplos frameworks JSX
+
+No Astro v2.x, você poderia utilizar [múltiplas integrações de frameworks JSX](/pt-br/guides/integrations-guide/#integrações-oficiais) (React, Solid, Preact) no mesmo projeto sem precisar identificar quais arquivos pertenciam a qual framework.
+
+Astro v3.0 agora requer que você especifique qual framework utilizar para seus arquivos com as novas opções `include` e `exclude` da configuração de integrações quando você tiver integrações de frameworks JSX instaladas. Isso permite Astro suportar melhor o uso de um único framework, assim como funcionalidades avançadas como Fast Refresh do React.
+
+#### O que devo fazer?
+
+Se você estiver utilizando múltiplos frameworks JSX no mesmo projeto, defina `include` (e opcionalmente `exclude`) como um array de arquivos e/ou pastas. Coringas podem ser utilizados para incluir o caminho de múltiplos arquivos.
+
+Nós recomendamos colocar componentes de frameworks em comum na mesma pasta (e.x. `/components/react/` e `/components/solid/`) para fazer especificar suas inclusões mais fácil, mas isso não é necessário:
+
+```js ins={13,16,19}
+import { defineConfig } from 'astro/config';
+import preact from '@astrojs/preact';
+import react from '@astrojs/react';
+import svelte from '@astrojs/svelte';
+import vue from '@astrojs/vue';
+import solid from '@astrojs/solid-js';
+
+export default defineConfig({
+  // Habilite múltiplos frameworks a suportarem todos os tipos de componentes.
+  // Nenhum `include` é necessário se você está usando apenas um único framework!
+  integrations: [
+    preact({
+      include: ['**/preact/*']
+    }),
+    react({
+      include: ['**/react/*']
+    }),
+    solid({
+      include: ['**/solid/*'],
+    }),
+  ]
+});
+```
+
+### Modificado: `Astro.cookies.get(key)` pode retornar `undefined`
+
+No Astro v2.x, [`Astro.cookies.get(key)`](/pt-br/reference/api-reference/#astrocookies) sempre retornaria um [objeto `AstroCookie`](/pt-br/reference/api-reference/#astrocookie), mesmo se o cookie não existisse. Para verificar sua existência, você precisava utilizar `Astro.cookies.has(key)`.
+
+Astro v3.0 retorna `undefined` em `Astro.cookies.get(key)` se o cookie não existir.
+
+#### O que devo fazer?
+
+Esta mudança não irá quebrar nenhum código que verifica pela existência do objeto `Astro.cookie` antes de utilizar `Astro.cookies.get(key)`, mas não é mais necessário.
+
+Você pode com segurança remover qualquer código que utiliza `has()` para verificar se o valor de `Astro.cookies` é `undefined`:
+
+```js del={1-3} ins={5-7}
+if (Astro.cookies.has(id)) {
+  const id = Astro.cookies.get(id)!;
+}
+
+const id = Astro.cookies.get(id);
+if (id) {
+}
+```
+
+### Modificado: executando a CLI do Astro programaticamente
+
+No Astro v2.x, o entrypoint do pacote `"astro"` exportava e executava a CLI do Astro diretamente. Não é recomendado executar Astro dessa forma na prática.
+
+Astro v3.0 remove a CLI do entrypoint, e exporta um novo conjunto de APIs experimentais JavaScript, incluindo `dev()`, `build()`, `preview()` e `sync()`.
+
+#### O que devo fazer?
+
+Para [executar a CLI do Astro programaticamente](/pt-br/reference/cli-reference/#apis-avançadas-experimental), utilize as novas APIs JavaScript experimentais:
+
+```js
+import { dev, build } from "astro";
+
+// Inicie o servidor de desenvolvimento do Astro
+const devServer = await dev();
+await devServer.stop();
+
+// Faça a build do seu projeto Astro
+await build();
+```
+
+
+### Modificado: caminhos de exportação do entrypoint interno da API do Astro
+
+No Astro v2.x, você poderia importar APIs internas do Astro a partir de `astro/internal/*` e `astro/runtime/server/*`.
+
+Astro v3.0 remove os dois entrypoints em favor do entrypoint existente `astro/runtime/*`. Adicionalmente, uma nova exportação `astro/compiler-runtime` foi adicionada para código em runtime específico do compilador.
+
+#### O que devo fazer?
+
+Esses entrypoints são para APIs internas do Astro e não devem afetar seu projeto. Mas se você utiliza esses entrypoints, atualize como mostrado abaixo:
+
+```js del={1,4,10} ins={2,5,11}
+import 'astro/internal/index.js';
+import 'astro/runtime/server/index.js';
+
+import 'astro/server/index.js';
+import 'astro/runtime/server/index.js';
+```
+
+```js ins={5} del={4}
+import { transform } from '@astrojs/compiler';
+
+const resultado = await transform(source, {
+  internalURL: 'astro/runtime/server/index.js',
+  internalURL: 'astro/compiler-runtime',
+  // ...
+});
+```
+
+
+
+## Problemas Conhecidos
+
+Atualmente, não há problemas conhecidos.
+
diff --git a/src/content/docs/pt-br/install/auto.mdx b/src/content/docs/pt-br/install/auto.mdx
index eeb1dbfe1269c..1713104ea8123 100644
--- a/src/content/docs/pt-br/install/auto.mdx
+++ b/src/content/docs/pt-br/install/auto.mdx
@@ -14,7 +14,7 @@ Leia nosso [guia de instalação manual passo a passo](/pt-br/install/manual/) n
 
 #### Pré-requisitos
 
-- **Node.js** - `v16.12.0` ou superior.
+- **Node.js** - `v18.14.1` ou superior.
 - **Editor de Texto** - Recomendamos o [VS Code](https://code.visualstudio.com/) com a nossa [extensão oficial Astro](https://marketplace.visualstudio.com/items?itemName=astro-build.astro-vscode).
 - **Terminal** - Astro é acessado através da sua Interface de Linha de Comando.
 
diff --git a/src/content/docs/pt-br/install/manual.mdx b/src/content/docs/pt-br/install/manual.mdx
index fccf0c2379e33..5342497b594ba 100644
--- a/src/content/docs/pt-br/install/manual.mdx
+++ b/src/content/docs/pt-br/install/manual.mdx
@@ -16,7 +16,7 @@ Este guia irá te orientar através das etapas necessárias para instalar e conf
 
 #### Pré-requisitos
 
-- **Node.js** - `v16.12.0` ou superior.
+- **Node.js** - `v18.14.1` ou superior.
 - **Editor de Texto** - Recomendamos o [VS Code](https://code.visualstudio.com/) com a nossa [extensão oficial Astro](https://marketplace.visualstudio.com/items?itemName=astro-build.astro-vscode).
 - **Terminal** - Astro é acessado através da sua Interface de Linha de Comando.
 
diff --git a/src/content/docs/pt-br/recipes/call-endpoints.mdx b/src/content/docs/pt-br/recipes/call-endpoints.mdx
index ee71527d53472..382666043b4f9 100644
--- a/src/content/docs/pt-br/recipes/call-endpoints.mdx
+++ b/src/content/docs/pt-br/recipes/call-endpoints.mdx
@@ -18,7 +18,7 @@ Endpoints podem ser usados para prover vários tipos de dados. Essa receita cham
     ```ts title="src/pages/api/ola.ts"
     import type { APIRoute } from 'astro'
 
-    export const get: APIRoute = () => {
+    export const GET: APIRoute = () => {
       return new Response(
         JSON.stringify({
           saudacoes: 'Olá',
@@ -27,13 +27,13 @@ Endpoints podem ser usados para prover vários tipos de dados. Essa receita cham
     }
     ```
 
-2. Em qualquer página Astro, importe o método `get()` do endpoint. Chame-o com a [global `Astro`](/pt-br/reference/api-reference/#global-astro) para prover o contexto da requisição, e use a resposta na página:
+2. Em qualquer página Astro, importe o método `GET()` do endpoint. Chame-o com a [global `Astro`](/pt-br/reference/api-reference/#global-astro) para prover o contexto da requisição, e use a resposta na página:
 
     ```astro title="src/pages/index.astro"
     ---
-    import { get } from './api/ola.ts'
+    import { GET } from './api/ola.ts'
 
-    let resposta = await get(Astro)
+    let resposta = await GET(Astro)
     const dados = await resposta.json()
     ---
 
diff --git a/src/content/docs/pt-br/reference/api-reference.mdx b/src/content/docs/pt-br/reference/api-reference.mdx
index 2acf6440e5f91..39b5d09848218 100644
--- a/src/content/docs/pt-br/reference/api-reference.mdx
+++ b/src/content/docs/pt-br/reference/api-reference.mdx
@@ -459,7 +459,7 @@ const pedidos = Array.from(Astro.locals.pedidos.entries());
 ```ts title="endpoint.json.ts"
 import type { APIContext } from 'astro';
 
-export function get(context: APIContext) {
+export function GET(context: APIContext) {
   // ...
 }
 ```
@@ -483,7 +483,7 @@ export function getStaticPaths() {
   ];
 }
 
-export function get({ params }: APIContext) {
+export function GET({ params }: APIContext) {
 	return {
 		body: JSON.stringify({ id: params.id })
 	};
@@ -507,7 +507,7 @@ export function getStaticPaths() {
   ];
 }
 
-export function get({ props }: APIContext) {
+export function GET({ props }: APIContext) {
 	return {
 		body: JSON.stringify({ autor: props.autor }),
 	};
@@ -523,7 +523,7 @@ Um objeto [Request](https://developer.mozilla.org/pt-BR/docs/Web/API/Request) pa
 ```ts
 import type { APIContext } from 'astro';
 
-export function get({ request }: APIContext) {
+export function GET({ request }: APIContext) {
   return {
     body: `Olá ${request.url}`
   }
@@ -551,7 +551,7 @@ Especifica o [endereço de IP](https://pt.wikipedia.org/wiki/Endere%C3%A7o_IP) d
 ```ts
 import type { APIContext } from 'astro';
 
-export function get({ clientAddress }: APIContext) {
+export function GET({ clientAddress }: APIContext) {
   return {
     body: `Seu endereço de IP é: ${clientAddress}`
   }
@@ -574,7 +574,7 @@ Veja também: [Astro.site](#astrosite)
 ```ts title="src/pages/informacao-site.json.ts"
 import type { APIContext } from 'astro';
 
-export function get({ generator, site }: APIContext) {
+export function GET({ generator, site }: APIContext) {
   const body = JSON.stringify({ generator, site });
   return new Response(body);
 }
@@ -589,7 +589,7 @@ Veja também: [Astro.generator](#astrogenerator)
 ```ts
 import type { APIContext } from 'astro';
 
-export function get({ redirect }: APIContext) {
+export function GET({ redirect }: APIContext) {
   return redirect('/login', 302);
 }
 ```
@@ -618,7 +618,7 @@ Endpoints de API so podem ler informações do `context.locals`:
 ```ts title="src/pages/hello.ts"
 import type { APIContext } from 'astro';
 
-export function get({ locals }: APIContext) {
+export function GET({ locals }: APIContext) {
   return {
     body: locals.titulo // "Título Padrão"
   }
@@ -1044,17 +1044,13 @@ export default function () {
 
 ## Componentes Integrados
 
-Astro inclui vários componentes integrados para você utilizar em seus projetos. Todos os componentes integrados estão disponíveis em arquivos `.astro` via `import {} from 'astro/components';`.
-
-### `<Markdown />`
-
-O componente Markdown não é mais incluso no Astro. Veja como [importar Markdown em seus arquivos Astro](/pt-br/guides/markdown-content/#importando-markdown) em nossa página sobre Markdown.
+Astro inclui vários componentes integrados para você utilizar em seus projetos. Todos os componentes integrados estão disponíveis em arquivos `.astro` via `import {} from 'astro:components';`.
 
 ### `<Code />`
 
 ```astro 'theme="dark-plus"' /wrap\b/ /(inline) \/>/
 ---
-import { Code } from 'astro/components';
+import { Code } from 'astro:components';
 ---
 <!-- Adicione syntax highlight de algum código JavaScript. -->
 <Code code={`const foo = 'bar';`} lang="js" />
@@ -1116,7 +1112,7 @@ Veja a [lista de linguagens suportadas pelo Prism](https://prismjs.com/#supporte
 
 ```astro
 ---
-import { Debug } from 'astro/components';
+import { Debug } from 'astro:components';
 const objetoDoServidor = {
   a: 0,
   b: "string",
diff --git a/src/content/docs/pt-br/reference/directives-reference.mdx b/src/content/docs/pt-br/reference/directives-reference.mdx
index 6fb0aafa76fbe..be4bb959f33af 100644
--- a/src/content/docs/pt-br/reference/directives-reference.mdx
+++ b/src/content/docs/pt-br/reference/directives-reference.mdx
@@ -24,24 +24,22 @@ Uma diretiva de template nunca é inclusa diretamente no HTML final resultante d
 ## Diretivas Comuns
 ### `class:list`
 
-`class:list={...}` recebe um array de valores de classes e as converte em uma string de classes. Isso é inspirado pela famosa biblioteca utilitária [clsx](https://github.com/lukeed/clsx) feita por @lukeed, mas inserida diretamente no próprio Astro.
+`class:list={...}` recebe um array de valores de classes e as converte em uma string de classes. Isso é fornecido pela famosa biblioteca utilitária [clsx](https://github.com/lukeed/clsx) feita por @lukeed.
 
 `class:list` recebe um array de vários diferentes tipos de valores:
 - `string`: Adicionadas ao elemento `class`
 - `Object`: Todas as chaves com valor `truthy` são adicionadas ao elemento `class`
 - `Array`: Inserido como uma string dos valores
 - `Set`: Inserido como uma string dos valores
-- `false` ou `null`: pulado
+- `false`, `null` ou `undefined`: pulado
 
 ```astro
 <!-- Isso -->
-<span class:list={[ 'ola tchau', { ola: true, mundo: true }, new Set([ 'ola', 'amigo' ]) ]} />
+<span class:list={[ 'ola tchau', { mundo: true }, [ 'amigo' ] ]} />
 <!-- Se torna -->
 <span class="olá tchau mundo amigo"></span>
 ```
 
-Valores duplicados são removidos automaticamente.
-
 ### `set:html`
 
 `set:html={string}` injeta uma string HTML em um elemento, similar a se utilizar `el.innerHTML`.
diff --git a/src/content/docs/pt-br/reference/error-reference.mdx b/src/content/docs/pt-br/reference/error-reference.mdx
index 83f895dc46b73..9ab0a59e5b283 100644
--- a/src/content/docs/pt-br/reference/error-reference.mdx
+++ b/src/content/docs/pt-br/reference/error-reference.mdx
@@ -48,6 +48,7 @@ A referência a seguir é uma lista completa dos erros que você pode encontrar
 - [**AstroGlobNoMatch**](/pt-br/reference/errors/astro-glob-no-match/)<br/>Astro.glob() did not match any files.
 - [**RedirectWithNoLocation**](/pt-br/reference/errors/redirect-with-no-location/)<br/>A redirect must be given a location with the `Location` header.
 - [**InvalidDynamicRoute**](/pt-br/reference/errors/invalid-dynamic-route/)<br/>Invalid dynamic route.
+- [**MissingSharp**](/pt-br/reference/errors/missing-sharp/)<br/>Could not find Sharp.
 - [**UnknownViteError**](/pt-br/reference/errors/unknown-vite-error/)<br/>Unknown Vite Error.
 - [**FailedToLoadModuleSSR**](/pt-br/reference/errors/failed-to-load-module-ssr/)<br/>Could not import file.
 - [**InvalidGlob**](/pt-br/reference/errors/invalid-glob/)<br/>Invalid glob pattern.
diff --git a/src/content/docs/pt-br/reference/errors/expected-image-options.mdx b/src/content/docs/pt-br/reference/errors/expected-image-options.mdx
index f6683ef8f12af..ef00d6cbdc5d2 100644
--- a/src/content/docs/pt-br/reference/errors/expected-image-options.mdx
+++ b/src/content/docs/pt-br/reference/errors/expected-image-options.mdx
@@ -20,4 +20,4 @@ const imagemOtimizada = await getImage({src: minhaImagem, width: 300, height: 30
 Na maioria dos casos, este erro acontece pois os parâmetros foram passados diretamente, ao invés de dentro de um objeto.
 
 **Veja Também:**
--  [Assets (Experimental)](/pt-br/guides/assets/)
+-  [Imagens](/pt-br/guides/images/)
diff --git a/src/content/docs/pt-br/reference/errors/expected-image.mdx b/src/content/docs/pt-br/reference/errors/expected-image.mdx
index 5b6c48b23d15b..0170033a610f3 100644
--- a/src/content/docs/pt-br/reference/errors/expected-image.mdx
+++ b/src/content/docs/pt-br/reference/errors/expected-image.mdx
@@ -23,4 +23,4 @@ import minhaImagem from "../assets/minha_imagem.png";
 Na maioria dos casos, este erro acontece quando o valor passado a `src` é undefined.
 
 **Veja Também:**
--  [Assets (Experimental)](/pt-br/guides/assets/)
+-  [Imagens](/pt-br/guides/images/)
diff --git a/src/content/docs/pt-br/reference/errors/image-missing-alt.mdx b/src/content/docs/pt-br/reference/errors/image-missing-alt.mdx
index 49065c936156c..b19085dbd0278 100644
--- a/src/content/docs/pt-br/reference/errors/image-missing-alt.mdx
+++ b/src/content/docs/pt-br/reference/errors/image-missing-alt.mdx
@@ -13,6 +13,6 @@ A propriedade `alt` permite que você providencie texto alternativo descritivo p
 Se a imagem é meramente decorativa (isto é, não contribui para a compreensão da página), defina `alt=""` para que leitores de tela consigam ignorar a imagem.
 
 **Veja Também:**
--  [Assets (Experimental)](/pt-br/guides/assets/)
--  [Componente Image](/pt-br/guides/assets/#image--astroassets)
--  [Componente Image#alt](/pt-br/guides/assets/#alt-required)
+-  [Imagens](/pt-br/guides/images/)
+-  [Componente Image](/pt-br/guides/images/#image--astroassets)
+-  [Componente Image#alt](/pt-br/guides/images/#alt-obrigatório)
diff --git a/src/content/docs/pt-br/reference/errors/markdown-image-not-found.mdx b/src/content/docs/pt-br/reference/errors/markdown-image-not-found.mdx
index 5c298487ff0a0..2ad09da832e10 100644
--- a/src/content/docs/pt-br/reference/errors/markdown-image-not-found.mdx
+++ b/src/content/docs/pt-br/reference/errors/markdown-image-not-found.mdx
@@ -13,4 +13,4 @@ Astro não foi capaz de encontrar uma imagem que você incluiu no seu conteúdo
 Imagens no Markdown são relativas ao arquivo atual. Para se referir a uma imagem que não está localizada na mesma pastas que o arquivo `.md`, o caminho deve começar com `./`
 
 **Veja Também:**
--  [Assets (Experimental)](/pt-br/guides/assets/)
+-  [Imagens](/pt-br/guides/images/)
diff --git a/src/content/docs/pt-br/reference/errors/missing-image-dimension.mdx b/src/content/docs/pt-br/reference/errors/missing-image-dimension.mdx
index ac6785d86f181..991c70c456bdd 100644
--- a/src/content/docs/pt-br/reference/errors/missing-image-dimension.mdx
+++ b/src/content/docs/pt-br/reference/errors/missing-image-dimension.mdx
@@ -13,5 +13,5 @@ Para imagens remotas, `width` e `height` não podem ser inferidos a partir do ar
 Se sua imagem está dentro do seu diretório `src`, você provavelmente quis importá-lo no lugar. Veja [o guia de Importações para mais informações](/pt-br/guides/imports/#outros-assets).
 
 **Veja Também:**
--  [Assets (Experimental)](/pt-br/guides/assets/)
--  [Componente Image#width-e-height](/pt-br/guides/assets/#width-and-height)
+-  [Imagens](/pt-br/guides/images/)
+-  [Componente Image#width-e-height-obrigatório](/pt-br/guides/images/#width-e-height-obrigatório-para-imagens-remotas-e-de-public)
diff --git a/src/content/docs/pt-br/reference/errors/static-redirect-not-available.mdx b/src/content/docs/pt-br/reference/errors/static-redirect-not-available.mdx
index 043dac56a8173..0a03f96486838 100644
--- a/src/content/docs/pt-br/reference/errors/static-redirect-not-available.mdx
+++ b/src/content/docs/pt-br/reference/errors/static-redirect-not-available.mdx
@@ -4,8 +4,8 @@ i18nReady: true
 githubURL: https://github.com/withastro/astro/blob/main/packages/astro/src/core/errors/errors-data.ts
 ---
 
-:::caution[Descontinuado]
-desde a versão 2.6
+:::caution[Depreciado]
+Depreciado desde a versão 2.6.
 :::
 
 > **StaticRedirectNotAvailable**: Redirecionamentos só estão disponíveis ao utilizar `output: 'server'` ou `output: 'hybrid'`. Atualize sua configuração do Astro se você precisa de funcionalidades de SSR.
diff --git a/src/content/docs/pt-br/reference/errors/unsupported-image-format.mdx b/src/content/docs/pt-br/reference/errors/unsupported-image-format.mdx
index 5b5a459821a01..f37f69a98d34d 100644
--- a/src/content/docs/pt-br/reference/errors/unsupported-image-format.mdx
+++ b/src/content/docs/pt-br/reference/errors/unsupported-image-format.mdx
@@ -10,10 +10,10 @@ githubURL: https://github.com/withastro/astro/blob/main/packages/astro/src/core/
 ## O que deu errado?
 Os serviços de imagem integrados atualmente não suportam otimizar todos os formatos de imagem.
 
-Para formatos não suportados como SVGs e GIFs, você pode ser capaz de usar uma tag `img` diretamente:
+Para formatos não suportados como GIFs, você pode ser capaz de usar uma tag `img` diretamente:
 ```astro
 ---
-import foguete from '../assets/images/foguete.svg'
+import foguete from '../assets/images/foguete.gif'
 ---
 
 <img src={foguete.src} width={foguete.width} height={foguete.height} alt="Um foguete no espaço." />
diff --git a/src/content/docs/pt-br/tutorial/1-setup/1.mdx b/src/content/docs/pt-br/tutorial/1-setup/1.mdx
index 1569b6b641cbb..571659ba62db9 100644
--- a/src/content/docs/pt-br/tutorial/1-setup/1.mdx
+++ b/src/content/docs/pt-br/tutorial/1-setup/1.mdx
@@ -29,7 +29,7 @@ Você pode acessar a linha de comando através de um programa de terminal local
 
 ### Node.js
 
-Para que o Astro execute no seu sistema, você também irá precisar ter o [**Node.js**](https://nodejs.org/pt-br/) instalado, versão `v16.12.0` ou superior.
+Para que o Astro execute no seu sistema, você também irá precisar ter o [**Node.js**](https://nodejs.org/pt-br/) instalado, versão `v18.14.1` ou superior.
 
 Para verificar se você já tem uma versão compatível instalada, execute o seguinte comando no seu terminal:
 
@@ -37,12 +37,12 @@ Para verificar se você já tem uma versão compatível instalada, execute o seg
 node -v
 
 // Resultado de exemplo
-v16.14.0
+v18.14.1
 ```
 
-Se o comando retorna um número de versão maior que `v16.12.0`, você está pronto para continuar!
+Se o comando retorna um número de versão maior que `v18.14.1`, você está pronto para continuar!
 
-Se o comando retorna uma mensagem de erro como `Command 'node' not found`, ou um número de versão inferior a `v16.12.0`, então você precisa [instalar uma versão compatível do Node.js](https://docs.npmjs.com/downloading-and-installing-node-js-and-npm).
+Se o comando retorna uma mensagem de erro como `Command 'node' not found`, ou um número de versão inferior a `v18.14.1`, então você precisa [instalar uma versão compatível do Node.js](https://docs.npmjs.com/downloading-and-installing-node-js-and-npm).
 
 ### Editor de Código
 
diff --git a/src/content/docs/pt-br/tutorial/5-astro-api/4.mdx b/src/content/docs/pt-br/tutorial/5-astro-api/4.mdx
index a4e975638c1c9..c9da8fbd79d47 100644
--- a/src/content/docs/pt-br/tutorial/5-astro-api/4.mdx
+++ b/src/content/docs/pt-br/tutorial/5-astro-api/4.mdx
@@ -77,7 +77,7 @@ Indivíduos podem se inscrever em seu feed em um leitor de feed, e receber uma n
 
     import rss, { pagesGlobToRssItems } from '@astrojs/rss';
 
-    export async function get() {
+    export async function GET() {
       return rss({
         title: 'Aluno de Astro | Blog',
         description: 'Minha jornada aprendendo Astro',