diff --git a/src/content/docs/es/basics/astro-components.mdx b/src/content/docs/es/basics/astro-components.mdx
index 8605428a47cea..d76f6052a153e 100644
--- a/src/content/docs/es/basics/astro-components.mdx
+++ b/src/content/docs/es/basics/astro-components.mdx
@@ -17,7 +17,7 @@ Los componentes de Astro son extremadamente flexibles. Un componente de Astro pu
 
 Lo más importante que hay que saber sobre los componentes de Astro es que **no se renderizan en el cliente**. Se renderizan en HTML en el momento de la compilación o bajo demanda. Puedes incluir código JavaScript dentro del frontmatter de tu componente, y todo será eliminado de la página final enviada a los navegadores de tus usuarios. El resultado es un sitio más rápido, sin ninguna huella de JavaScript añadida por defecto.
  
-Cuando tu componente Astro necesite interactividad en el lado del cliente, puedes añadir [etiquetas HTML estándar `<script>`](/es/guides/client-side-scripts/) o [componentes UI Framework](/es/guides/framework-components/#hidratando-componentes-interactivos) como "islas cliente".
+Cuando tu componente Astro necesite interactividad en el lado del cliente, puedes añadir [etiquetas HTML estándar `<script>`](/es/guides/client-side-scripts/) o [componentes UI Framework](/es/guides/framework-components/#hydrating-interactive-components) como "islas cliente".
  
 Para los componentes que necesitan mostrar contenido personalizado o dinámico, puede aplazar su presentación en el servidor añadiendo una [directiva de servidor] (/es/reference/directives-reference/#directivas-del-servidor). Estas "islas de servidor" renderizarán su contenido cuando esté disponible, sin retrasar la carga completa de la página.
 
diff --git a/src/content/docs/es/basics/astro-pages.mdx b/src/content/docs/es/basics/astro-pages.mdx
index d128bd94ed896..2ab349d142e7f 100644
--- a/src/content/docs/es/basics/astro-pages.mdx
+++ b/src/content/docs/es/basics/astro-pages.mdx
@@ -14,7 +14,7 @@ Astro es compatible con los siguientes tipos de archivos en el directorio `src/p
 
 - [`.astro`](#páginas-de-astro)
 - [`.md`](#páginas-markdownmdx)
-- `.mdx` (con la [integración de MDX](/es/guides/integrations-guide/mdx/#instalación)) instalada
+- `.mdx` (con la [integración de MDX](/es/guides/integrations-guide/mdx/#installation)) instalada
 - [`.html`](#páginas-html)
 - [`.js`/`.ts`] (como [endpoints](/es/guides/endpoints/))
 
@@ -23,7 +23,7 @@ Astro es compatible con los siguientes tipos de archivos en el directorio `src/p
 
 Astro aprovecha una estrategia de enrutamiento llamada **enrutamiento basado en archivos**. Cada archivo `.astro` en la carpeta `src/pages` se convierte en una página o un endpoint en tu proyecto de acuerdo a su ruta.
 
-Un archivo puede generar múltiples páginas usando [enrutamiento dinámico](/es/guides/routing/#rutas-dinámicas). Esto te permite crear páginas incluso si tu contenido está fuera del directorio especial `/pages/`, como en una [colección de contenido](/es/guides/content-collections/) o un [CMS](/es/guides/cms/).
+Un archivo puede generar múltiples páginas usando [enrutamiento dinámico](/es/guides/routing/#dynamic-routes). Esto te permite crear páginas incluso si tu contenido está fuera del directorio especial `/pages/`, como en una [colección de contenido](/es/guides/content-collections/) o un [CMS](/es/guides/cms/).
 
 <ReadMore>Lee más sobre [enrutamiento en Astro](/es/guides/routing/)</ReadMore>
 
@@ -71,7 +71,7 @@ import MySiteLayout from "../layouts/MySiteLayout.astro";
 
 ## Páginas Markdown/MDX
 
-Astro trata los archivos Markdown (`.md`) dentro de `src/pages/` como páginas en tu proyecto. Si tienes la [integración de MDX instalada](/es/guides/integrations-guide/mdx/#instalación), también procesa los archivos MDX (`.mdx`) de la misma manera.
+Astro trata los archivos Markdown (`.md`) dentro de `src/pages/` como páginas en tu proyecto. Si tienes la [integración de MDX instalada](/es/guides/integrations-guide/mdx/#installation), también procesa los archivos MDX (`.mdx`) de la misma manera.
 
 :::tip
 Considera crear [colecciones de contenido](/es/guides/content-collections/) en lugar de páginas para directorios de archivos Markdown relacionados que comparten una estructura similar, como publicaciones de blog o elementos de productos.
diff --git a/src/content/docs/es/basics/layouts.mdx b/src/content/docs/es/basics/layouts.mdx
index c9c26593170c6..b7e25a4edc8cb 100644
--- a/src/content/docs/es/basics/layouts.mdx
+++ b/src/content/docs/es/basics/layouts.mdx
@@ -15,7 +15,7 @@ Pero, ¡no hay nada especial acerca de los componentes plantilla! Pueden [acepta
 
 Sin embargo, si un componente de plantilla contiene una página shell, su elemento `<html>` debe ser el padre de todos los demás elementos en el componente.
 
-Los componentes de plantilla se colocan comúnmente en la carpeta `src/layouts` en tu proyecto, pero esto no es un requisito; puedes elegir ubicarlos en cualquier lugar de tu proyecto. Incluso puedes colocar las plantillas junto a tus páginas mediante [el uso de un prefijo `_` en los nombres de las plantillas](/es/guides/routing/#excluyendo-páginas).
+Los componentes de plantilla se colocan comúnmente en la carpeta `src/layouts` en tu proyecto, pero esto no es un requisito; puedes elegir ubicarlos en cualquier lugar de tu proyecto. Incluso puedes colocar las plantillas junto a tus páginas mediante [el uso de un prefijo `_` en los nombres de las plantillas](/es/guides/routing/#excluding-pages).
 
 ## Plantilla de ejemplo
 
@@ -100,7 +100,7 @@ const { title, description, publishDate, viewCount } = Astro.props;
 
 Las plantillas son especialmente útiles para páginas de Markdown de lo contrario no tendría ningún estilo de página.  
 
-Astro proporciona una propiedad especial `layout` en el frontmatter destinada a [archivos individuales `.md` ubicados dentro de `src/pages/` utilizando enrutamiento basado en archivos](/es/guides/markdown-content/#páginas-de-markdown-y-mdx) para especificar qué componente `.astro` utilizar como diseño de página. Este componente le permite proporcionar contenido `<head>` como meta-etiquetas (por ejemplo, `<meta charset="utf-8">`) y estilos para la página Markdown. Por defecto, este componente especificado puede acceder automáticamente a los datos del archivo Markdown.
+Astro proporciona una propiedad especial `layout` en el frontmatter destinada a [archivos individuales `.md` ubicados dentro de `src/pages/` utilizando enrutamiento basado en archivos](/es/guides/markdown-content/#individual-markdown-pages) para especificar qué componente `.astro` utilizar como diseño de página. Este componente le permite proporcionar contenido `<head>` como meta-etiquetas (por ejemplo, `<meta charset="utf-8">`) y estilos para la página Markdown. Por defecto, este componente especificado puede acceder automáticamente a los datos del archivo Markdown.
  
 Esto no se reconoce como una propiedad especial cuando se utiliza [colecciones de contenido](/es/guides/content-collections/) para consultar y renderizar su contenido.
 
@@ -144,7 +144,7 @@ const { frontmatter } = Astro.props;
 </html>
 ```
 
-Puedes establecer el tipo de una plantilla como [`Props`](/es/guides/typescript/#props-de-componentes) con el ayudante `MarkdownLayoutProps`:
+Puedes establecer el tipo de una plantilla como [`Props`](/es/guides/typescript/#component-props) con el ayudante `MarkdownLayoutProps`:
 
 ```astro title="src/layouts/BlogPostLayout.astro" ins={2,4-9}
 ---
@@ -190,7 +190,7 @@ Una plantilla Markdown/MDX tendrá acceso a la siguiente información a través
 **`compiledContent()`** - Función asíncrona que devuelve el documento Markdown compilado a una cadena HTML.
 
 :::note
-Una plantilla Markdown tendrá acceso a todas sus [propiedades exportadas](/es/guides/markdown-content/#propiedades-exportadas) del archivo Markdown desde `Astro.props` **con dos diferencias clave:**
+Una plantilla Markdown tendrá acceso a todas sus [propiedades exportadas](/es/guides/markdown-content/#importing-markdown) del archivo Markdown desde `Astro.props` **con dos diferencias clave:**
 
 *   Información de encabezados (es decir, elementos `h1 -> h6`) están disponibles a través del array `headings`, en lugar de la función `getHeadings()`.
 
diff --git a/src/content/docs/es/guides/actions.mdx b/src/content/docs/es/guides/actions.mdx
index 3d79632960401..5574b8295f7d1 100644
--- a/src/content/docs/es/guides/actions.mdx
+++ b/src/content/docs/es/guides/actions.mdx
@@ -709,7 +709,7 @@ export const onRequest = defineMiddleware(async (context, next) => {
 
 ## Llamar a acciones desde componentes Astro y endpoints del servidor
 
-Puedes llamar a acciones directamente desde los scripts de componentes Astro usando el envoltorio `Astro.callAction()` (o `context.callAction()` cuando usas un [endpoint del servidor](/es/guides/endpoints/#endpoints-del-servidor-rutas-de-api)). Esto es común para reutilizar la lógica de tus acciones en otro código del servidor.
+Puedes llamar a acciones directamente desde los scripts de componentes Astro usando el envoltorio `Astro.callAction()` (o `context.callAction()` cuando usas un [endpoint del servidor](/es/guides/endpoints/#server-endpoints-api-routes)). Esto es común para reutilizar la lógica de tus acciones en otro código del servidor.
 
 Pasa la acción como primer argumento y cualquier parámetro de entrada como segundo argumento. Esto devuelve los mismos objetos `data` y `error` que recibes al llamar a acciones desde el cliente:
 
diff --git a/src/content/docs/es/guides/astro-db.mdx b/src/content/docs/es/guides/astro-db.mdx
deleted file mode 100644
index abce18e62e3f7..0000000000000
--- a/src/content/docs/es/guides/astro-db.mdx
+++ /dev/null
@@ -1,573 +0,0 @@
----
-title: 'Astro DB'
-description: Aprende a usar Astro DB, una base de datos SQL de gestión integral diseñada exclusivamente para Astro.
-githubIntegrationURL: 'https://github.com/withastro/astro/tree/main/packages/db/'
-i18nReady: true
----
-import { FileTree } from '@astrojs/starlight/components';
-import PackageManagerTabs from '~/components/tabs/PackageManagerTabs.astro';
-import ReadMore from '~/components/ReadMore.astro';
-import StudioHeading from '~/components/StudioHeading.astro';
-
-Astro DB es una base de datos SQL de gestión integral diseñada exclusivamente para Astro. Desarrolla localmente o conéctate a una base de datos alojada gestionada en nuestra plataforma [Astro Studio](#astro-studio).
-
-## Instalación
-
-Añade Astro DB a un proyecto de Astro nuevo o existente (requiere `astro@4.5` o posterior) con la [integración `@astrojs/db`](/es/guides/integrations-guide/db/) (`v0.8.0` o posterior). Astro incluye un comando `astro add` incorporado para automatizar este proceso de configuración por ti.
-
-<PackageManagerTabs>
-  <Fragment slot="npm">
-  ```sh
-  npx astro add db
-  ```
-  </Fragment>
-  <Fragment slot="pnpm">
-  ```sh
-  pnpm astro add db
-  ```
-  </Fragment>
-  <Fragment slot="yarn">
-  ```sh
-  yarn astro add db
-  ```
-  </Fragment>
-</PackageManagerTabs>
-
-Si lo prefieres, puedes [instalar `@astrojs/db` manualmente](/es/guides/integrations-guide/db/#instalación-manual) en su lugar.
-
-## Define tu base de datos
-
-Astro DB es una solución completa para configurar, desarrollar y consultar tus datos. Se crea una base de datos local cada vez que ejecutas `astro dev`, utilizando LibSQL para administrar tus datos sin la necesidad de Docker o una conexión de red.
-
-La instalación de `@astrojs/db` con el comando `astro add` creará un archivo `db/config.ts` en tu proyecto, donde definirás las tablas de tu base de datos:
-
-```ts title="db/config.ts"
-import { defineDb } from 'astro:db';
-
-export default defineDb({
-  tables: { },
-})
-```
-
-### Columnas
-
-Los datos en Astro DB se almacenan utilizando tablas SQL. Las tablas estructuran tus datos en filas y columnas, donde las columnas hacen cumplir el tipo de cada valor de fila. Astro DB admite los siguientes tipos de columnas:
-
-```ts title="db/config.ts" "column.text()" "column.number()" "column.boolean()" "column.date()" "column.json()"
-
-const Comment = defineTable({
-  columns: {
-    // Una cadena de texto.
-    author: column.text(),
-    // Un valor entero.
-    likes: column.number(),
-    // Un valor verdadero o falso.
-    flagged: column.boolean(),
-    // Valores de fecha/hora consultados como objetos de fecha de JavaScript.
-    published: column.date(),
-    // Un objeto JSON sin tipo.
-    metadata: column.json(),
-  }
-});
-```
-
-### Tablas
-
-Las tablas potencian los tipados automáticos de TypeScript de Astro para tu contenido. Cuando defines una tabla, Astro generará y aplicará automáticamente una interfaz de TypeScript a la misma. El resultado es un soporte completo de TypeScript cuando consultas tus datos, incluyendo autocompletado de propiedades y comprobación de tipos.
-
-Para configurar una tabla de base de datos individual, importa y utiliza las utilidades `defineTable()` y `column` de `astro:db`.
-
-Este ejemplo configura una tabla `Comment` con columnas de texto requeridas para `author` y `body` y luego la pone disponible para tu proyecto a través de la exportación `defineDb()`.
-
-```ts title="db/config.ts" "Comment"
-import { defineDb, defineTable, column } from 'astro:db';
-
-const Comment = defineTable({
-  columns: {
-    author: column.text(),
-    body: column.text(),
-  }
-})
-
-export default defineDb({
-  tables: { Comment },
-})
-```
-
-<ReadMore>Ver la [referencia de configuración de la tabla](/es/guides/integrations-guide/db/#configuración-de-la-tabla-de-referencia) para una referencia completa de las opciones de la tabla.</ReadMore>
-
-### Referencias de Tablas
-
-Las relaciones entre tablas son un patrón común en el diseño de bases de datos. Por ejemplo, una tabla `Blog` puede estar estrechamente relacionada con otras tablas como `Comment`, `Author` y `Category`.
-
-Puedes definir estas relaciones entre tablas y guardarlas en el esquema de tu base de datos usando **columnas de referencia**. Para establecer una relación, necesitarás:
-
-- Una **columna de identificador** en la tabla referenciada. Esta suele ser una columna `id` con la propiedad `primaryKey`.
-- Una columna en la tabla base para **almacenar el `id` referenciado**. Esto utiliza la propiedad `references` para establecer una relación.
-
-Este ejemplo muestra la columna `authorId` de una tabla `Comment` haciendo referencia a la columna `id` de una tabla `Author`.
-
-```ts title="db/config.ts" {3, 10}
-const Author = defineTable({
-  columns: {
-    id: column.number({ primaryKey: true }),
-    name: column.text(),
-  }
-});
-
-const Comment = defineTable({
-  columns: {
-    authorId: column.number({ references: () => Author.columns.id }),
-    body: column.text(),
-  }
-});
-```
-
-## Sembrar tu base de datos
-
-En desarrollo, Astro utilizará la configuración de tu base de datos para generar tipos locales según tus esquemas. Estos se generarán frescos cada vez que se inicie el servidor de desarrollo, y te permitirán consultar y trabajar con la forma de tus datos con seguridad de tipos y autocompletado.
-
-Para sembrar datos de desarrollo para pruebas y depuración en tu proyecto de Astro, crea un archivo `db/seed.ts`. Importa tanto el objeto `db` como cualquier tabla configurada desde `astro:db`. Utiliza la función `db.insert()` para proporcionar una matriz de objetos de datos de filas de tabla.
-
-El siguiente ejemplo define dos filas de datos de desarrollo para una tabla `Comment`:
-
-
-```ts title="db/seed.ts"
-import { db, Comment } from 'astro:db';
-
-export default async function() {
-    await db.insert(Author).values([
-    { id: 1, name: "Kasim" },
-    { id: 2, name: "Mina" },
-  ]);
-  
-  await db.insert(Comment).values([
-    { authorId: 1, body: 'Espero que te guste Astro DB!' },
-    { authorId: 2, body: 'Disfruta!'},
-  ])
-}
-```
-
-Tu servidor de desarrollo reiniciará automáticamente tu base de datos cada vez que este archivo cambie, regenerando tus tipos y sembrando tus datos de desarrollo desde `seed.ts`.
-
-## Consulta tu base de datos
-
-Puedes consultar tu base de datos desde cualquier [página de Astro](/es/basics/astro-pages/#páginas-de-astro) o [endpoint](/es/guides/endpoints/) en tu proyecto utilizando el ORM `db` proporcionado y el generador de consultas.
-
-
-### Drizzle ORM
-
-```
-import { db } from 'astro:db';
-```
-
-Astro DB incluye un cliente incorporado de [Drizzle ORM](https://orm.drizzle.team/). No se requiere instalación ni configuración manual para usar el cliente. El cliente `db` de Astro DB se configura automáticamente para comunicarse con tu base de datos (local o remota) cuando ejecutas Astro. Utiliza la definición exacta de tu esquema de base de datos para consultas SQL seguras con tipos, y muestra errores de TypeScript cuando haces referencia a una columna o tabla que no existe.
-
-
-### Seleccionar 
-
-El siguiente ejemplo selecciona todas las filas de una tabla `Comentario`. Esto devuelve la matriz completa de datos de desarrollo sembrados desde `db/seed.ts`, la cual luego está disponible para su uso en tu plantilla de página:
-
-```astro title="src/pages/index.astro"
----
-import { db, Comment } from 'astro:db';
-
-const comentarios = await db.select().from(Comment);
----
-
-<h2>Comentarios</h2>
-
-{
-  comentarios.map(({ author, body }) => (
-    <article>
-      <p>Autor: {author}</p>
-      <p>{body}</p>
-    </article>
-  ))
-}
-```
-
-<ReadMore>Consulta la [referencia de API `select()` de Drizzle](https://orm.drizzle.team/docs/select) para obtener una descripción completa.</ReadMore>
-
-### Insertar
-
-Para aceptar las entradas del usuario, como manejar solicitudes de formulario e insertar datos en tu base de datos alojada remotamente, configura tu proyecto Astro para el [renderizado bajo demanda](/es/guides/on-demand-rendering/) y [añade un adaptador SSR](/es/guides/on-demand-rendering/#agrega-un-adaptador) para tu entorno de implementación.
-
-Este ejemplo inserta una fila en una tabla `Comment` basada en una solicitud POST de formulario analizada:
-
-
-```astro
----
-// src/pages/index.astro
-import { db, Comment } from 'astro:db';
-
-if (Astro.request.method === 'POST') {
-  // Analizar datos de formulario
-  const formData = await Astro.request.formData();
-  const author = formData.get('author');
-  const content = formData.get('content');
-  if (typeof author === 'string' && typeof content === 'string') {
-    // Insertar datos de formulario en un Comment
-    await db.insert(Comment).values({ author, content });
-  }
-}
-
-//Renderizar una nueva lista de comentarios en cada petición
-const comments = await db.select().from(Comment);
----
-
-<form method="POST" style="display: grid">
-	<label for="author">Autor</label>
-	<input id="author" name="author" />
-
-	<textarea name="content"></textarea>
-
-	<button type="submit">Enviar</button>
-</form>
-
-<!--renderizar `comments`-->
-```
-
-Puedes también consultar tu base de datos desde un endpoint de API. Este ejemplo elimina una fila de la tabla `Comment` utilizando el parámetro `id`.
-
-```ts
-// src/pages/api/comments/[id].ts
-import type { APIRoute } from "astro";
-import { db, Comment } from 'astro:db';
-
-export const DELETE: APIRoute = async (ctx) => {
-  await db.delete(Comment).where({ id: ctx.params.id });
-  return new Response(null, { status: 204 });
-}
-```
-
-<ReadMore>
-
-Consulta la [referencia de API `insert()` de Drizzle](https://orm.drizzle.team/docs/insert) para obtener una descripción completa.
-
-</ReadMore>
-
-### Filtrado
-
-Para consultar resultados de tabla por una propiedad específica, utiliza [las opciones de Drizzle para selecciones parciales](https://orm.drizzle.team/docs/select#partial-select). Por ejemplo, añade [una llamada `.where()`](https://orm.drizzle.team/docs/select#filtering) a tu consulta `select()` y pasa la comparación que deseas realizar.
-
-El siguiente ejemplo consulta todas las filas en una tabla `Comment` que contienen la frase "Astro DB". Utiliza [el operador `like()`](https://orm.drizzle.team/docs/operators#like) para verificar si una frase está presente dentro del `body`:
-
-
-```astro title="src/pages/index.astro"
----
-import { db, Comment, like } from 'astro:db';
-
-const comments = await db.select().from(Comment).where(
-    like(Comment.body, '%Astro DB%')
-);
----
-```
-
-### Utilidades de Drizzle
-
-Todas las utilidades de Drizzle para construir consultas están expuestas en el módulo `astro:db`. Esto incluye:
-
-- [Operadores de filtro](https://orm.drizzle.team/docs/operators) como `eq()` y `gt()`
-- [Ayudantes de agregación](https://orm.drizzle.team/docs/select#aggregations-helpers) como `count()`
-- [El ayudante `sql`](https://orm.drizzle.team/docs/sql) para escribir consultas SQL en bruto
-
-```ts
-import { eq, gt, count, sql } from 'astro:db';
-```
-
-### Relaciones
-
-Puedes consultar datos relacionados de múltiples tablas utilizando un join SQL. Para crear una consulta join, extiende tu declaración `db.select()` con un operador join. Cada función acepta una tabla para unir y una condición para hacer coincidir filas entre las dos tablas.
-
-Este ejemplo utiliza una función `innerJoin()` para unir los autores de `Comentarios` con su información de `Autor` relacionada basada en la columna `authorId`. Esto devuelve una matriz de objetos con cada fila de `Autor` y `Comentario` como propiedades de nivel superior:
-
-```astro title="src/pages/index.astro"
----
-import { db, eq, Comment, Author } from 'astro:db';
-
-const comentarios = await db.select()
-  .from(Comment)
-  .innerJoin(Author, eq(Comment.authorId, Author.id));
----
-
-<h2>Comentarios</h2>
-
-{
-  comentarios.map(({ Author, Comment }) => (
-    <article>
-      <p>Autor: {Author.name}</p>
-      <p>{Comment.body}</p>
-    </article>
-  ))
-}
-```
-
-<ReadMore>
-
-Consulta la [referencia de joins de Drizzle](https://orm.drizzle.team/docs/joins#join-types) para ver todos los operadores de join y opciones de configuración disponibles.
-
-</ReadMore>
-
-### Transacciones por lotes
-
-Todas las consultas a la base de datos remota se realizan como una solicitud de red. Es posible que necesites "agrupar" consultas en una sola transacción cuando realices un gran número de consultas, o para tener retrocesos automáticos si alguna consulta falla.
-
-Este ejemplo siembra varias filas en una sola solicitud utilizando el método `db.batch()`:
-
-```ts
-// db/seed.ts
-import { db, Author, Comment } from 'astro:db';
-
-export default async function () {
-  let queries;
-  // Sembrar 100 comentarios de muestra en tu base de datos remota
-  // con una única solicitud de red.
-  for (let i = 0; i < 100; i++) {
-    queries.push(db.insert(Comment).values({ body: `Comentario test ${i}` }));
-  }
-  await db.batch(queries);
-}
-```
-
-<ReadMore>
-
-Consulta la documentación de [Drizzle `db.batch()`](https://orm.drizzle.team/docs/batch-api) para más detalles.
-
-</ReadMore>
-
-<StudioHeading>
-## Astro Studio
-</StudioHeading>
-
-Astro DB puede conectarse a la plataforma Astro Studio para agregar rápidamente una base de datos alojada a tu proyecto. Puedes ver, gestionar y implementar nuevas bases de datos alojadas, todo desde el portal web de Astro Studio.
-
-El [portal web de Astro Studio](http://studio.astro.build/) te permite conectar y gestionar tus bases de datos de Astro DB alojadas de forma remota a través de una interfaz web o mediante [comandos de CLI](/es/reference/cli-reference/#cli-de-astro-studio).
-
-Desde tu panel de Studio, tienes acceso a la gestión de cuentas, artículos de ayuda y una consola de mensajes de soporte.
-
-Visita [Astro Studio](http://studio.astro.build) para registrarte o iniciar sesión.
-
-<StudioHeading>
-### Despliega con una conexión a Studio
-</StudioHeading>
-
-Puedes desplegar tu proyecto de Astro DB con una conexión en vivo a tu base de datos de Studio. Esto es posible con cualquier plataforma de despliegue que utilice compilaciones estáticas o un [adaptador SSR](/es/guides/on-demand-rendering/).
-
-Primero, configura tu comando de compilación para conectar con Studio utilizando el indicador `--remote`. Este ejemplo aplica el indicador a un script `"build"` en el archivo `package.json` de tu proyecto. Si tu plataforma de despliegue acepta un comando de compilación, asegúrate de configurarlo como `npm run build`.
-
-```json title="package.json" "--remote"
-{
-  "scripts": {
-    "build": "astro build --remote"
-  }
-}
-```
-
-<StudioHeading>
-#### Crear un token de aplicación para Studio
-</StudioHeading>
-
-Necesitas crear un token de aplicación para acceder a tu base de datos de Studio desde un despliegue de producción. Puedes crear un token de aplicación desde el panel de tu proyecto de Studio navegando a la pestaña **Settings** y seleccionando **Tokens**. 
-
-Copia el token generado y aplícalo como una variable de entorno / secreto de entorno en tu plataforma de despliegue usando el nombre `ASTRO_STUDIO_APP_TOKEN`. 
-
-<StudioHeading>
-### Configurar la acción de CI de GitHub
-</StudioHeading>
-
-Puedes enviar automáticamente los cambios de esquema a tu base de datos de Studio con la acción de CI de Studio. Esto verifica que los cambios se puedan realizar de manera segura y mantiene tu configuración actualizada cada vez que fusionas a `main`.
-
-[Sigue la documentación de GitHub](https://docs.github.com/es/actions/security-guides/using-secrets-in-github-actions#creating-secrets-for-a-repository) para configurar un nuevo secreto en tu repositorio con el nombre `ASTRO_STUDIO_APP_TOKEN` y tu token de aplicación de Studio como el valor del secreto.
-
-Una vez configurado tu secreto, crea un nuevo archivo de flujo de trabajo de GitHub Actions en el directorio `.github/workflows` de tu proyecto para verificar el repositorio e instala Node.js siguiendo los pasos, y usa la acción `withastro/action-studio` para sincronizar los cambios de esquema.
-
-La acción ejecutará `astro db verify` en todos los [activadores de eventos](https://docs.github.com/es/actions/using-workflows/events-that-trigger-workflows) para asegurar que los cambios de esquema se puedan aplicar de manera segura. Si agregas específicamente el activador **[push](https://docs.github.com/es/actions/using-workflows/events-that-trigger-workflows#push)**, la acción enviará esos cambios a tu base de datos de Studio.
-
-Este ejemplo de acción de GitHub `_studio.yml` envía cambios siempre que se actualice la rama `main`:
-
-```yaml title=".github/workflows/_studio.yml"
-name: Astro Studio
-
-env:
-  ASTRO_STUDIO_APP_TOKEN: ${{secrets.ASTRO_STUDIO_APP_TOKEN }}
-
-on:
-  push:
-    branches:
-      - main
-  pull_request:
-    types: [opened, reopened, synchronize]
-
-jobs:
-  DB:
-    permissions:
-      contents: read
-      actions: read
-      pull-requests: write
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-      - uses: actions/setup-node@v4
-        with:
-          node-version: 20
-      - uses: jaid/action-npm-install@v1.2.1
-      - uses: withastro/action-studio@main
-```
-
-<StudioHeading>
-### Subiendo esquemas de tablas
-</StudioHeading>
-
-El esquema de tu tabla cambiará con el tiempo a medida que tu proyecto crezca. Puedes probar cambios de configuración de forma segura localmente y subirlos a tu base de datos de Studio cuando implementes.
-
-Cuando [crees un proyecto de Studio desde el panel](#astro-studio), tendrás la opción de crear una acción de CI de GitHub. Esto migrará automáticamente los cambios de esquema al fusionar con la rama principal de tu repositorio.
-
-También puedes subir cambios de esquema a través del CLI usando el comando `astro db push`:
-
-<PackageManagerTabs>
-  <Fragment slot="npm">
-  ```sh
-  npm run astro db push
-  ```
-  </Fragment>
-  <Fragment slot="pnpm">
-  ```sh
-  pnpm astro db push
-  ```
-  </Fragment>
-  <Fragment slot="yarn">
-  ```sh
-  yarn astro db push
-  ```
-  </Fragment>
-</PackageManagerTabs>
-
-Este comando verificará que los cambios puedan realizarse sin pérdida de datos y guiará sobre cambios de esquema recomendados para resolver conflictos. Si se _debe_ realizar un cambio de esquema que rompa, añade la bandera `--force-reset` para restablecer todos los datos de producción.
-
-<StudioHeading>
-### Subiendo datos
-</StudioHeading>
-
-Es posible que necesites subir datos a tu base de datos de Studio para sembrar o migrar datos. Puedes crear un archivo `.ts` con el módulo `astro:db` para escribir consultas seguras de tipos. Luego, ejecuta el archivo contra tu base de datos de Studio utilizando el comando `astro db execute <ruta-del-archivo> --remote`:
-
-Los siguientes comentarios pueden ser sembrados utilizando el comando `astro db execute db/seed.ts --remote`:
-
-```ts
-// db/seed.ts
-import { Comment } from 'astro:db';
-
-export default async function () {
-  await db.insert(Comment).values([
-    { authorId: 1, body: 'Espero que disfrutes Astro DB!' },
-    { authorId: 2, body: 'Disfruta!' },
-  ])
-}
-```
-
-<ReadMore>
-
-Consulta la [referencia del CLI](/es/guides/integrations-guide/db/#referencia-de-la-cli-de-astro-db) para obtener una lista completa de comandos.
-
-</ReadMore>
-
-<StudioHeading>
-### Conecta con Astro Studio
-</StudioHeading>
-
-Por defecto, Astro utilizará un archivo de base de datos local cada vez que ejecutes los comandos `dev` o `build`. Las tablas se recrean desde cero cuando se ejecuta cada comando, y se insertarán datos de desarrollo sembrados.
-
-Para conectarte a tu base de datos de Studio alojada, puedes añadir la bandera `--remote`. Usa esta bandera para implementaciones en producción y así tener acceso tanto de lectura como de escritura a tu base de datos de Studio. Esto te permitirá [aceptar y persistir datos de usuario](#insertar).
-
-```bash
-# Compilar con una conexión remota
-astro build --remote
-
-# Desarrollar con una conexión remota
-astro dev --remote
-```
-
-:::caution
-
-Ten cuidado al usar `--remote` en desarrollo. Esto se conectará a una base de datos de producción en vivo, y todas las inserciones, actualizaciones o eliminaciones persistirán.
-
-:::
-
-Para usar una conexión remota, necesitarás un token de aplicación para autenticarte con Studio. Visita el panel de Studio para obtener instrucciones sobre cómo crear y configurar un token.
-
-<ReadMore>
-
-Cuando estés listo para implementar, consulta nuestra [guía de Implementación con una Conexión a Studio](#despliega-con-una-conexión-a-studio).
-
-</ReadMore>
-
-## Construyendo integraciones de Astro DB
-
-Las [integraciones de Astro](/es/reference/integrations-reference/) pueden extender los proyectos de los usuarios con tablas y datos sembrados adicionales de Astro DB.
-
-Utiliza el método `extendDb()` en el gancho `astro:db:setup` para registrar configuraciones adicionales de Astro DB y archivos de semilla.
-El ayudante `defineDbIntegration()` proporciona soporte TypeScript y autocompletado para el gancho `astro:db:setup`.
-
-```js {8-13}
-// my-integration/index.ts
-import { defineDbIntegration } from '@astrojs/db/utils';
-
-export default function MyIntegration() {
-  return defineDbIntegration({
-    name: 'my-astro-db-powered-integration',
-    hooks: {
-      'astro:db:setup': ({ extendDb }) => {
-        extendDb({
-          configEntrypoint: '@astronaut/my-package/config',
-          seedEntrypoint: '@astronaut/my-package/seed',
-        });
-      },
-      // Otros hooks...
-    },
-  });
-}
-```
-
-Los archivos de [configuración](#define-tu-base-de-datos) y [semilla](#sembrar-tu-base-de-datos) de integración siguen el mismo formato que sus equivalentes definidos por el usuario.
-
-### Operaciones seguras de tipos en integraciones
-
-Mientras trabajas en integraciones, es posible que no puedas beneficiarte de los tipos de tabla generados por Astro exportados desde `astro:db`.
-Para obtener una seguridad completa de tipos, utiliza la utilidad `asDrizzleTable()` para crear un objeto de referencia de tabla que puedas utilizar para operaciones de base de datos.
-
-Por ejemplo, dado una integración configurando la siguiente tabla de base de datos `Mascotas`:
-
-```js
-// my-integration/config.ts
-import { defineDb, defineTable, column } from 'astro:db';
-
-export const Mascotas = defineTable({
-  columns: {
-    name: column.text(),
-    species: column.text(),
-  },
-});
-
-export default defineDb({ tables: { Mascotas } });
-```
-
-El archivo de semilla puede importar `Mascotas` y utilizar `asDrizzleTable()` para insertar filas en tu tabla con verificación de tipos:
-
-```js {2,7} /typeSafePets(?! )/
-// my-integration/seed.ts
-import { asDrizzleTable } from '@astrojs/db/utils';
-import { db } from 'astro:db';
-import { Mascotas } from './config';
-
-export default async function() {
-  const typeSafePets = asDrizzleTable('Mascotas', Mascotas);
-
-  await db.insert(typeSafePets).values([
-    { name: 'Palomita', species: 'cat' },
-    { name: 'Pan', species: 'dog' },
-  ]);
-}
-```
-
-El valor devuelto por `asDrizzleTable('Mascotas', Mascotas)` es equivalente a `import { Mascotas } from 'astro:db'`, pero está disponible incluso cuando la generación de tipos de Astro no puede ejecutarse.
-Puedes usarlo en cualquier código de integración que necesite consultar o insertar en la base de datos.
diff --git a/src/content/docs/es/guides/cms/apostrophecms.mdx b/src/content/docs/es/guides/cms/apostrophecms.mdx
deleted file mode 100644
index d504c8cbdd802..0000000000000
--- a/src/content/docs/es/guides/cms/apostrophecms.mdx
+++ /dev/null
@@ -1,463 +0,0 @@
----
-title: ApostropheCMS y Astro
-description: Edita contenido en la página en tu proyecto de Astro usando Apostrophe como tu CMS.
-type: cms
-stub: true
-service: Apostrophe
-i18nReady: true
----
-import { FileTree } from '@astrojs/starlight/components';
-import PackageManagerTabs from '~/components/tabs/PackageManagerTabs.astro'
-
-[ApostropheCMS](https://apostrophecms.com/) es un sistema de gestión de contenido que admite la edición en la página en Astro.
-
-## Integración con Astro
-
-En esta sección, utilizarás la [integración de Apostrophe](https://apostrophecms.com/extensions/astro-integration) para conectar ApostropheCMS con Astro.
-
-### Prerrequisitos
-
-Para comenzar, necesitarás lo siguiente:
-
-1. **Un proyecto de Astro renderizado bajo demanda** con el [adaptador Node.js](/es/guides/integrations-guide/node/) instalado y configurado con `output: 'server'` - Si aún no tienes un proyecto de Astro, nuestra [guía de instalación](/es/install-and-setup/) te pondrá en marcha en poco tiempo.
-
-2. **Un proyecto de ApostropheCMS con una variable de entorno configurada llamada `APOS_EXTERNAL_FRONT_KEY`** - Esta variable de entorno puede configurarse con cualquier cadena aleatoria. Si aún no tienes un proyecto de ApostropheCMS, la [guía de instalación](https://docs.apostrophecms.org/guide/development-setup.html) te ayudará a configurar uno rápidamente. Recomendamos encarecidamente utilizar la [herramienta de línea de comandos de Apostrophe](https://apostrophecms.com/extensions/apos-cli) para facilitar este proceso.
-
-
-### Configuración de la comunicación entre proyectos
-
-Tu proyecto de Astro necesita tener una variable de entorno `APOS_EXTERNAL_FRONT_KEY` configurada con el mismo valor que la de tu proyecto de ApostropheCMS para permitir la comunicación entre ambos. Esta clave compartida actúa como un medio para verificar las solicitudes entre el frontend (Astro) y el backend (ApostropheCMS).
-
-Crea un archivo `.env` en la raíz de tu proyecto de Astro con la siguiente variable:
-
-```ini title=".env"
-APOS_EXTERNAL_FRONT_KEY='StringAleatoriaConAltaSeguridad'
-```
-
-Tu directorio raíz ahora debería incluir este nuevo archivo:
-
-<FileTree title="Estructura de Proyecto">
-- src/
-- **.env**
-- astro.config.mjs
-- package.json
-</FileTree>
-
-### Instalación de dependencias
-
-Para conectar Astro con tu proyecto de ApostropheCMS, instala la integración oficial de Apostrophe en tu proyecto de Astro usando el siguiente comando para tu gestor de paquetes preferido.
-<PackageManagerTabs>
-  <Fragment slot="npm">
-  ```shell
-  npm install @apostrophecms/apostrophe-astro vite @astro/node
-  ```
-  </Fragment>
-  <Fragment slot="pnpm">
-  ```shell
-  pnpm add @apostrophecms/apostrophe-astro vite @astro/node
-  ```
-  </Fragment>
-  <Fragment slot="yarn">
-  ```shell
-  yarn add @apostrophecms/apostrophe-astro vite @astro/node
-  ```
-  </Fragment>
-</PackageManagerTabs>
-
-### Configuración de Astro
-
-Configura ambas integraciones `apostrophe-astro` y `vite` en tu archivo `astro.config.mjs`.
-
-El siguiente ejemplo proporciona la URL base de tu instancia de Apostrophe y las rutas a las carpetas de tu proyecto para mapear entre los [widgets](https://docs.apostrophecms.org/guide/core-widgets.html) y los [tipos de plantilla de página](https://docs.apostrophecms.org/guide/pages.html) de ApostropheCMS y tu proyecto de Astro. También configura el renderizado del lado del servidor de Vite.
-
-```js title="astro.config.mjs"
-import { defineConfig } from 'astro/config';
-import node from '@astrojs/node';
-import apostrophe from '@apostrophecms/apostrophe-astro';
-import { loadEnv } from 'vite';
-
-const env = loadEnv("", process.cwd(), 'APOS');
-
-export default defineConfig({
-  output: 'server',
-  adapter: node({
-    mode: 'standalone'
-  }),
-  integrations: [
-    apostrophe({
-      aposHost: 'http://localhost:3000',
-      widgetsMapping: './src/widgets',
-      templatesMapping: './src/templates'
-    })
-  ],
-  vite: {
-    ssr: {
-      // No externalizar el complemento @apostrophecms/apostrophe-astro, necesitamos
-      // poder usar URLs virtuales allí
-      noExternal: [ '@apostrophecms/apostrophe-astro' ],
-    },
-    define: {
-      'process.env.APOS_EXTERNAL_FRONT_KEY': JSON.stringify(env.APOS_EXTERNAL_FRONT_KEY),
-      'process.env.APOS_HOST': JSON.stringify(env.APOS_HOST)
-    }
-  }
-});
-```
-
-Para opciones de configuración completas y explicaciones, consulta la [documentación de `apostrophe-astro`](https://apostrophecms.com/extensions/astro-integration#configuration-astro).
-
-### Conexión de widgets de ApostropheCMS a componentes de Astro
-Los widgets de ApostropheCMS son bloques de contenido estructurado que se pueden agregar a la página, como columnas de diseño, imágenes y bloques de texto. Necesitarás crear un componente de Astro para cada widget en tu proyecto de Apostrophe, además de un archivo para mapear esos componentes al widget de Apostrophe correspondiente.
-
-Crea un nuevo directorio en `src/widgets/` para tus componentes de Astro y el archivo de mapeo, `index.js`.
-
-Componentes mapeados ubicados en esta carpeta reciben una propiedad `widget` que contiene los campos del esquema de tu widget, y cualquier propiedad personalizada, a través de `Astro.props`. Estos valores están disponibles para la edición en la página.
-
-El siguiente ejemplo muestra un componente `RichTextWidget.astro` accediendo al contenido de su widget correspondiente de ApostropheCMS para permitir la edición en contexto:
-
-```js title="src/widgets/RichTextWidget.astro"
----
-const { widget } = Astro.props;
-const { content } = widget;
----
-<Fragment set:html={ content }></Fragment>
-```
-
-Algunos widgets estándar de Apostrophe, como imágenes y videos, requieren **marcadores de posición** porque no contienen contenido editable de forma predeterminada. El siguiente ejemplo crea un componente estándar `ImageWidget.astro` que establece el valor de `src` condicionalmente al valor de la imagen `aposPlaceholder` pasada por el widget, una imagen de respaldo del proyecto Astro, o la imagen seleccionada por el administrador de contenido utilizando el ayudante `attachment` de Apostrophe:
-
-```js title="src/widgets/ImageWidget.astro"
----
-const { widget } = Astro.props;
-const placeholder = widget?.aposPlaceholder;
-const src = placeholder ?
-  '/images/image-widget-placeholder.jpg' :
-  widget?._image[0]?.attachment?._urls['full'];
----
-<style>
-  .img-widget {
-    width: 100%;
-  }
-</style>
-<img class="img-widget" {src} />
-```
-
-Para más ejemplos, consulta [los ejemplos de widgets del proyecto de inicio `astro-frontend`](https://github.com/apostrophecms/astro-frontend/tree/main/src/widgets).
-
-Cada componente `.astro` debe mapearse al widget de Apostrophe correspondiente en `src/widgets/index.js`.
-
-El ejemplo de abajo agrega los dos componentes anteriores a este archivo:
-
-```js title="src/widgets/index.js"
-import RichTextWidget from './RichTextWidget.astro';
-import ImageWidget from './ImageWidget.astro';
-
-const widgetComponents = {
-  '@apostrophecms/rich-text': RichTextWidget,
-  '@apostrophecms/image': ImageWidget
-};
-
-export default widgetComponents;
-```
-
-Consulta la [documentación de ApostropheCMS](https://apostrophecms.com/extensions/astro-integration) para conocer las convenciones de nomenclatura para widgets estándar, pro y de nivel de proyecto personalizado
-
-El directorio del proyecto debería verse así:
-
-<FileTree title="Estructura de Proyecto">
-- src/
-  - widgets/
-    - **index.js**
-    - **ImageWidget.astro**
-    - **RichTextWidget.astro**
-- .env
-- astro.config.mjs
-- package.json
-</FileTree>
-
-### Agregar tipos de página
-
-Como los widgets, cualquier plantilla de tipo de página en tu proyecto de ApostropheCMS necesita tener un componente de plantilla correspondiente en tu proyecto de Astro. También necesitarás un archivo que mapee los tipos de página de Apostrophe a componentes individuales.
-
-Crea un nuevo directorio en `src/templates/` para tus componentes de Astro y el archivo de mapeo, `index.js`. Los componentes mapeados ubicados en esta carpeta reciben una propiedad `page` que contiene los campos del esquema de tu página, y cualquier propiedad personalizada, a través de `Astro.props`. Estos valores están disponibles para la edición en la página.
-
-El siguiente ejemplo muestra un componente `HomePage.astro` que renderiza una plantilla de página de su tipo de página `home-page` de ApostropheCMS, incluyendo un campo de esquema de área llamado `main`:
-
-```js title="src/templates/HomePage.astro"
----
-import AposArea from '@apostrophecms/apostrophe-astro/components/AposArea.astro';
-const { page, user, query } = Astro.props.aposData;
-const { main } = page;
----
-
-<section class="bp-content">
-  <h1>{ page.title }</h1>
-  <AposArea area={main} />
-</section>
-```
-
-Cada componente `.astro` debe mapearse al tipo de página de Apostrophe correspondiente en `src/templates/index.js`.
-
-El siguiente ejemplo agrega el componente `HomePage.astro` anterior a este archivo:
-
-```js title="src/templates/index.js"
-import HomePage from './HomePage.astro';
-
-const templateComponents = {
-  '@apostrophecms/home-page': HomePage
-};
-
-export default templateComponents;
-```
-
-Consulta la [documentación de ApostropheCMS](https://apostrophecms.com/extensions/astro-integration/#how-apostrophe-template-names-work) para conocer las convenciones de nomenclatura para tipos de página especiales y tipos de página de piezas.
-
-El directorio del proyecto debería verse así:
-
-<FileTree title="Estructura de Proyecto">
-- src/
-  - widgets/
-    - index.js
-    - ImageWidget.astro
-    - RichTextWidget.astro
-  - templates/
-    - **HomePage.astro**
-    - **index.js**
-- .env
-- astro.config.mjs
-- package.json
-</FileTree>
-
-### Creación del componente [...slug.astro] y obtención de datos de Apostrophe
-
-Desde que Apostrophe es responsable de conectar URLs con contenido, incluyendo la creación de nuevo contenido y páginas sobre la marcha, solo necesitarás un componente de página de Astro de nivel superior: la ruta `[...slug].astro`.
-
-El siguiente ejemplo muestra un componente básico `[...slug].astro`:
-
-```js title="src/pages/[...slug].astro"
----
-import aposPageFetch from '@apostrophecms/apostrophe-astro/lib/aposPageFetch.js';
-import AposLayout from '@apostrophecms/apostrophe-astro/components/layouts/AposLayout.astro';
-import AposTemplate from '@apostrophecms/apostrophe-astro/components/AposTemplate.astro';
-
-const aposData = await aposPageFetch(Astro.request);
-const bodyClass = `myclass`;
-
-if (aposData.redirect) {
-  return Astro.redirect(aposData.url, aposData.status);
-}
-if (aposData.notFound) {
-  Astro.response.status = 404;
-}
----
-<AposLayout title={aposData.page?.title} {aposData} {bodyClass}>
-    <Fragment slot="standardHead">
-      <meta name="description" content={aposData.page?.seoDescription} />
-      <meta name="viewport" content="width=device-width, initial-scale=1" />
-      <meta charset="UTF-8" />
-    </Fragment>
-    <AposTemplate {aposData} slot="main"/>
-</AposLayout>
-```
-Consulta la [documentación de ApostropheCMS](https://apostrophecms.com/extensions/astro-integration#creating-the-slugastro-component-and-fetching-apostrophe-data) para obtener opciones de plantillas adicionales, incluidos los espacios disponibles en el componente `AposTemplate`.
-
-## Creación de un blog con Astro y ApostropheCMS
-
-Con la integración configurada, ahora puedes crear un blog con Astro y ApostropheCMS. Tu blog utilizará una pieza de Apostrophe, un tipo de contenido independiente que se puede incluir en cualquier página, y un tipo de página de pieza, un tipo de página especializado que se utiliza para mostrar esas piezas individualmente o colectivamente.
-
-### Prerrequisitos
-
-1. **Un proyecto de ApostropheCMS con la herramienta de línea de comandos de Apostrophe instalada** - Puedes crear un nuevo proyecto o utilizar uno existente. Sin embargo, este tutorial solo mostrará cómo crear un tipo de pieza de blog y un tipo de página de pieza. Deberás integrar cualquier otro código de proyecto existente de forma independiente. Si no tienes la herramienta de línea de comandos instalada, consulta las [instrucciones de instalación de Apostrophe CLI](https://docs.apostrophecms.org/guide/setting-up.html#the-apostrophe-cli-tool).
-2. **Un proyecto de Astro integrado con ApostropheCMS** - Para crear un proyecto desde cero, consulta [integración con Astro](#integración-con-astro) para obtener instrucciones sobre cómo configurar la integración, o utiliza el proyecto de inicio [astro-frontend](https://github.com/apostrophecms/astro-frontend).
-
-### Creación de un tipo de pieza de blog y un tipo de página de pieza
-
-Para crear tu tipo de pieza de blog y tu tipo de página de pieza para su visualización, navega a la raíz de tu proyecto de ApostropheCMS en tu terminal. Utiliza la herramienta de línea de comandos de ApostropheCMS para crear el nuevo tipo de pieza y el tipo de página de pieza con el siguiente comando:
-
-```sh
-apos add piece blog --page
-```
-
-Esto creará dos nuevos módulos en tu proyecto, uno para el tipo de pieza de blog y otro para el tipo de página de pieza correspondiente. A continuación, abre el archivo `app.js` en la raíz de tu proyecto de ApostropheCMS en tu editor de código y agrega tus nuevos módulos.
-
-```js title="app.js"
-require('apostrophe')({
-  // otras opciones de configuración
-  modules: {
-    // otros módulos del proyecto
-    blog: {},
-    'blog-page': {}
-  }
-});
-```
-
-El módulo `blog-page` también debe agregarse al array de opciones `types` del módulo `@apostrophecms/page` para que pueda seleccionarse en el modal de creación de página. En tu proyecto de ApostropheCMS, abre el archivo `modules/@apostrophecms/page/index.js` y agrega el `blog-page`.
-
-```js title="modules/@apostrophecms/page/index.js"
-module.exports = {
-  options: {
-    types: [
-      {
-        name: '@apostrophecms/home-page',
-        label: 'Home'
-      },
-      // Cualquier otra página del proyecto
-      {
-        name: 'blog-page',
-        label: 'Blog'
-      }
-    ]
-  }
-};
-```
-
-### Creación del esquema del blog
-
-En un proyecto de ApostropheCMS, los editores tienen un conjunto de campos de entrada para agregar contenido. Aquí tienes un ejemplo de una publicación de blog simple que agrega tres campos de entrada, un `authorName`, `publicationDate` y un área de `content` donde los administradores de contenido pueden agregar múltiples instancias de widgets. En este caso, estamos especificando que pueden agregar los widgets de imagen y texto enriquecido que creamos durante la [configuración de la integración](#conexión-de-widgets-de-apostrophecms-a-componentes-de-astro).
-
-```js title="modules/blog/index.js"
-module.exports = {
-  extend: '@apostrophecms/piece-type',
-  options: {
-    label: 'Blog',
-    // Adicionalmente, añade una opción `pluralLabel` si es necesario.
-  },
-  fields: {
-    add: {
-      authorName: {
-        type: 'string',
-        label: 'Author'
-      },
-      publicationDate: {
-        type: 'date',
-        label: 'Publication date'
-      },
-      content: {
-        type: 'area',
-        label: 'Content',
-        options: {
-          widgets: {
-            '@apostrophecms/rich-text': {},
-            '@apostrophecms/image': {}
-          }
-        }
-      }
-    },
-    group: {
-      basics: {
-        label: 'Basic',
-        fields: [ 'authorName', 'publicationDate', 'content' ]
-      }
-    }
-  }
-};
-```
-
-En este punto, todos los componentes provenientes del proyecto de ApostropheCMS están configurados. Inicia el sitio local desde la línea de comandos usando `npm run dev`, asegurándote de pasar la variable de entorno `APOS_EXTERNAL_FRONT_KEY` configurada con tu cadena seleccionada:
-
-```bash
-APOS_EXTERNAL_FRONT_KEY='MyRandomString' npm run dev
-```
-
-### Mostrando las publicaciones del blog
-Para mostrar una página con todas las publicaciones del blog, crea un archivo de componente `BlogIndex.astro` en el directorio `src/templates` de tu proyecto de Astro y agrega el siguiente código:
-
-Después de obtener los datos de la página y las piezas de la propiedad `aposData`, este componente crea el marcado utilizando los campos del esquema de la pieza de blog que creamos, pero también del `piece.title` y `piece._url` que se agrega a cada pieza por Apostrophe.
-
-```js title="src/templates/BlogIndex.astro"
----
-import dayjs from 'dayjs';
-
-const { page, pieces } = Astro.props.aposData;
----
-
-<section class="bp-content">
-  <h1>{ page.title }</h1>
-
-  <h2>Publicaciones de Blog</h2>
-
-  {pieces.map(piece => (
-    <h4>
-      Publicados el { dayjs(piece.publicationDate).format('MMMM D, YYYY') }
-    </h4>
-    <h3>
-      <a href={ piece._url }>{ piece.title }</a>
-    </h3>
-    <h4>{ piece.authorName }</h4>
-  ))}
-</section>
-```
-
-Para mostrar publicaciones individuales del blog, crea un archivo `BlogShow.astro` en el directorio `src/templates` de tu proyecto de Astro con el siguiente código:
-
-Este componente usa el componente `<AposArea>` para mostrar cualquier widget agregado al área `content` y el contenido `authorName` y `publicationDate` ingresado en los campos del mismo nombre.
-
-```js title="src/templates/BlogShow.astro"
----
-import AposArea from '@apostrophecms/apostrophe-astro/components/AposArea.astro';
-import dayjs from 'dayjs';
-
-const { page, piece } = Astro.props.aposData;
-const { main } = piece;
----
-
-<section class="bp-content">
-  <h1>{ piece.title }</h1>
-  <h3>Creado por: { piece.authorName }
-  <h4>
-    Publicado el { dayjs(piece.publicationDate).format('MMMM D, YYYY') }
-  </h4>
-  <AposArea area={content} />
-</section>
-```
-
-Finalmente, estos componentes de Astro deben mapearse a los tipos de página correspondientes de ApostropheCMS. Abre el archivo `src/templates/index.js` del proyecto de Astro y modifícalo para que contenga el siguiente código:
-
-```js title="src/templates/index.js"
-import HomePage from './HomePage.astro';
-import BlogIndexPage from './BlogIndexPage.astro';
-import BlogShowPage from './BlogShowPage.astro';
-
-const templateComponents = {
-  '@apostrophecms/home-page': HomePage,
-  '@apostrophecms/blog-page:index': BlogIndexPage,
-  '@apostrophecms/blog-page:show': BlogShowPage
-};
-
-export default templateComponents;
-```
-
-### Creación de publicaciones de blog
-
-Agregar publicaciones de blog a tu sitio se logra utilizando las herramientas de contenido y gestión de ApostropheCMS para crear esas publicaciones y publicando al menos una página de índice para mostrarlas.
-
-Con el servidor de desarrollo de Astro en funcionamiento, navega a la página de inicio de sesión ubicada en [http://localhost:4321/login](http://localhost:4321/login) en tu navegador. Utiliza las credenciales que se agregaron durante la [creación del proyecto de ApostropheCMS](https://docs.apostrophecms.org/guide/development-setup.html#creating-a-project) para iniciar sesión como administrador. Tu proyecto de ApostropheCMS debería seguir en funcionamiento.
-
-Una vez que hayas iniciado sesión, tu navegador se redirigirá a la página de inicio de tu proyecto y mostrará una barra de administración en la parte superior para editar contenido y administrar tu proyecto.
-
-Para publicar tu primera publicación de blog, haz clic en el botón `Blogs` en la barra de administración para abrir el modal de creación de piezas de blog. Haciendo clic en el botón `New Blog` en la esquina superior derecha se abrirá un modal de edición donde podrás agregar contenido. El campo de área `content` te permitirá agregar tantos widgets de imagen y texto enriquecido como desees.
-
-Puedes repetir este paso y agregar tantas publicaciones como desees. También seguirás estos pasos cada vez que quieras agregar una nueva publicación.
-
-Para publicar una página para mostrar todas tus publicaciones, haz clic en el botón `Pages` en la barra de administración. Desde el modal del árbol de páginas, haz clic en el botón `New Page`. En el menú desplegable `Type` en la columna derecha, selecciona `Blog`. Agrega un título para la página y luego haz clic en `Publish and View`. Solo necesitarás hacer esto una vez.
-
-Cualquier nueva publicación de blog que se cree se mostrará automáticamente en esta página. Las publicaciones de blog individuales se pueden mostrar haciendo clic en el enlace creado en la página de índice.
-
-El área `content` de las publicaciones individuales se puede editar directamente en la página navegando a la publicación y haciendo clic en `edit` en la barra de administración. Otros campos se pueden editar utilizando el modal de edición que se abre al hacer clic el menú `Blogs` en la barra de administración.
-
-### Despliegue de tu sitio
-Para desplegar tu sitio web, necesitas alojar tanto tus proyectos de Astro como de ApostropheCMS.
-
-Para Astro, visita nuestras [guías de despliegue](/es/guides/deploy/) y sigue las instrucciones para tu proveedor de alojamiento preferido.
-
-Para el proyecto de ApostropheCMS, sigue las instrucciones para tu tipo de alojamiento en nuestra [guía de alojamiento](https://docs.apostrophecms.org/guide/hosting.html). Finalmente, deberás proporcionar una variable de entorno `APOS_HOST` al proyecto de Astro para reflejar la URL correcta donde se ha desplegado tu sitio de ApostropheCMS.
-
-## Recursos Oficiales
-
-- [Integración de ApostropheCMS con Astro](https://apostrophecms.com/extensions/astro-integration) - Plugin de ApostropheCMS para Astro, guía de integración y proyectos de inicio para Apostrophe y Astro
-- [Proyecto de muestra de Astro para usar con ApostropheCMS](https://github.com/apostrophecms/astro-frontend) - Un proyecto simple de Astro con varias páginas y widgets de Apostrophe ya creados.
-- [Kit de muestra de inicio de ApostropheCMS para usar con Astro](https://apostrophecms.com/starter-kits/astro-integration-starter-kit) - Un proyecto de ApostropheCMS con modificaciones de página básicas para usar con Astro.
-
-## Recursos de la Comunidad
-- [Integrando ApostropheCMS con Astro, Parte 1](https://apostrophecms.com/blog/how-to-integrate-astro-with-apostrophecms-pt-1) por Antonello Zaini
-- [Integrando ApostropheCMS con Astro, Parte 2](https://apostrophecms.com/blog/how-to-integrate-astro-with-apostrophecms-pt-2) por Antonello Zaini
-- [Mostrar y contar en vivo | Astro & Apostrophe](https://youtu.be/cwJhtJhAhwA?si=6iUU9EjidfdnOdCh) (en inglés)
diff --git a/src/content/docs/es/guides/cms/builderio.mdx b/src/content/docs/es/guides/cms/builderio.mdx
index 84614186232af..57b821a13159d 100644
--- a/src/content/docs/es/guides/cms/builderio.mdx
+++ b/src/content/docs/es/guides/cms/builderio.mdx
@@ -246,7 +246,7 @@ Si estás usando un framework de JavaScript (por ejemplo, Svelte, Vue o React) e
 
 ### Mostrar una entrada de blog individual
 
-Crea la página `src/pages/posts/[slug].astro` que [generará dinámicamente una página](/es/guides/routing/#rutas-dinámicas) para cada entrada.
+Crea la página `src/pages/posts/[slug].astro` que [generará dinámicamente una página](/es/guides/routing/#dynamic-routes) para cada entrada.
 
 <FileTree title="Estructura del proyecto">
 - src/
diff --git a/src/content/docs/es/guides/cms/buttercms.mdx b/src/content/docs/es/guides/cms/buttercms.mdx
deleted file mode 100644
index d6b0c0503f6c8..0000000000000
--- a/src/content/docs/es/guides/cms/buttercms.mdx
+++ /dev/null
@@ -1,131 +0,0 @@
----
-title: ButterCMS y Astro
-description: Agrega contenido a tu proyecto Astro usando ButterCMS
-type: cms
-service: ButterCMS
-stub: false
-i18nReady: true
----
-import PackageManagerTabs from '~/components/tabs/PackageManagerTabs.astro'
-import { Steps } from '@astrojs/starlight/components';
-
-[ButterCMS](https://buttercms.com/) es un CMS headless y un motor de blogs que te permite publicar contenido estructurado para usarlo en tu proyecto.
-
-## Integrandolo con Astro
-:::note
-Para ver un ejemplo completo de un sitio de blog, revisa el [Proyecto de inicio de Astro + ButterCMS](https://buttercms.com/starters/astro-starter-project/).
-::: 
-En esta sección, usaremos el [SDK de ButterCMS](https://www.npmjs.com/package/buttercms) para traer tus datos a tu proyecto Astro.
-Para empezar, necesitarás lo siguiente:
-### Prerequisitos
-
-1. **Un proyecto Astro** - Si aún no tienes un proyecto Astro, nuestra [Guía de instalación](/es/install-and-setup/) te ayudará a comenzar en cuestión de minutos.
-
-2. **Una cuenta de ButterCMS**. Si aún no tienes una cuenta, puedes [registrarte](https://buttercms.com/join/) para una prueba gratuita.
-
-3. **Tu token de API de ButterCMS** - Puedes encontrar tu token de API en la página de [Configuración](https://buttercms.com/settings/).
-
-### Configuración
-
-<Steps>
-1. Crea un archivo `.env` en la raíz de tu proyecto y agrega tu token de API como una variable de entorno:
-
-    ```ini title=".env"
-    BUTTER_TOKEN=TU_TOKEN_DE_API_AQUI
-    ```
-
-    :::tip
-    Lee más sobre [usar variables de entorno](/es/guides/environment-variables/) y archivos `.env` en Astro.
-    :::
-
-2. Instala el SDK de ButterCMS como una dependencia:
-    <PackageManagerTabs>
-      <Fragment slot="npm">
-      ```shell
-      npm install buttercms
-      ```
-      </Fragment>
-      <Fragment slot="pnpm">
-      ```shell
-      pnpm add buttercms
-      ```
-      </Fragment>
-      <Fragment slot="yarn">
-      ```shell
-      yarn add buttercms
-      ```
-      </Fragment>
-    </PackageManagerTabs>
-
-3. Crea un archivo `buttercms.js` en un nuevo directorio `src/lib/` en tu proyecto:
-
-    ```js title="src/lib/buttercms.js"
-    import Butter from "buttercms";
-
-    export const butterClient = Butter(import.meta.env.BUTTER_TOKEN);
-    ```
-</Steps>
-
-**Esto autentica el SDK usando tu token de API y lo exporta para ser usado en todo tu proyecto.**
-
-### Obteniendo datos
-Para obtener contenido, importa este cliente y usa una de sus funciones `retrieve`.
-
-En este ejemplo, [obtenemos una colección](https://buttercms.com/docs/api/#retrieve-a-collection) que tiene tres campos: un texto corto `name`, un número `price`, y un WYSIWYG `description`.
-
-```astro title="src/pages/ShopItem.astro"
----
-import { butterClient } from "../lib/buttercms";
-const response = await butterClient.content.retrieve(["shopitem"]);
-
-interface ShopItem {
-	name: string,
-	price: number,
-	description: string,
-}
-
-const items = response.data.data.shopitem as ShopItem[];
----
-<body>
-	{items.map(item => <div>
-		<h2>{item.name} - ${item.price}</h2>
-		<p set:html={item.description}></p>
-	</div>)}
-</body>
-```
-
-La interfaz refleja los tipos de campo. El campo WYSIWYG `description` se carga como una cadena de HTML y [`set:html`](/es/reference/directives-reference/#sethtml) te permite renderizarlo.
-
-Similarmente, puedes [obtener una página](https://buttercms.com/docs/api/#get-a-single-page) y mostrar sus campos:
-
-```astro title="src/pages/ShopItem.astro"
----
-import { butterClient } from "../lib/buttercms";
-const response = await butterClient.page.retrieve("*", "simple-page");
-const pageData = response.data.data;
-
-interface Fields {
-  seo_title: string,
-  headline: string,
-  hero_image: string,
-}
-
-const fields = pageData.fields as Fields;
----
-<html>
-  <title>{fields.seo_title}</title>
-  <body>
-    <h1>{fields.headline}</h1>
-    <img src={fields.hero_image} />
-  </body>
-</html>
-```
-
-## Recursos Oficiales
-
-- [Astro + Tutorial ButterCMS](https://buttercms.com/starters/astro-starter-project/)
-- La [documentación completa de la API de ButterCMS](https://buttercms.com/docs/api/)
-- La guía de [ButterCMS](https://buttercms.com/docs/api-client/javascript/)
-
-## Recursos de la comunidad
-- ¡Agrega el tuyo!
diff --git a/src/content/docs/es/guides/cms/caisy.mdx b/src/content/docs/es/guides/cms/caisy.mdx
deleted file mode 100644
index 0331435e6e3da..0000000000000
--- a/src/content/docs/es/guides/cms/caisy.mdx
+++ /dev/null
@@ -1,62 +0,0 @@
----
-title: Caisy y Astro
-description: Agrega contenido a tu proyecto de Astro utilizando Caisy como CMS 
-type: cms
-service: Caisy
-i18nReady: true
-stub: true
----
-
-[Caisy](https://caisy.io/) es un CMS headless que expone una API de GraphQL para acceder al contenido.
-
-## Utilizando Caisy con Astro
-
-Usa `graphql-request` y el renderizador de texto enriquecido de Caisy para Astro para obtener los datos de tu CMS y mostrar tu contenido en una página de Astro.
-
-```astro title="src/pages/blog/[...slug].astro"
----
-import RichTextRenderer from '@caisy/rich-text-astro-renderer';
-import { gql, GraphQLClient } from 'graphql-request';
-
-const params = Astro.params;
-
-const client = new GraphQLClient(
-	`https://cloud.caisy.io/api/v3/e/${import.meta.env.CAISY_PROJECT_ID}/graphql`,
-	{
-		headers: {
-			'x-caisy-apikey': import.meta.env.CAISY_API_KEY
-		}
-	}
-);
-const gqlResponse = await client.request(
-	gql`
-		query allBlogArticle($slug: String) {
-			allBlogArticle(where: { slug: { eq: $slug } }) {
-				edges {
-					node {
-						text {
-							json
-						}
-						title
-						slug
-						id
-					}
-				}
-			}
-		}
-	`,
-	{ slug: params.slug }
-);
-
-const post = gqlResponse?.allBlogArticle?.edges?.[0]?.node;
----
-<h1>{post.title}</h1>
-<RichTextRenderer node={post.text.json} />
-```
-
-## Recursos oficiales
-
-- Mira el ejemplo de Caisy + Astro en [GitHub](https://github.com/caisy-io/caisy-example-astro) o [Stackblitz](https://stackblitz.com/github/caisy-io/caisy-example-astro?file=src%2Fpages%2Fblog%2F%5B...slug%5D.astro)
-- Realiza consultas a tus documentos en [modo borrador](https://caisy.io/developer/docs/external-api/localization-and-preview#preview-mode-15) y múltiples [idiomas](https://caisy.io/developer/docs/external-api/localization-and-preview#localization-in-a-graphql-query-8).
-- Utiliza [paginación](https://caisy.io/developer/docs/external-api/queries-pagination) para consultar un gran número de documentos.
-- Emplea [filtros](https://caisy.io/developer/docs/external-api/external-filter-and-sorting) en tus consultas y [ordena](https://caisy.io/developer/docs/external-api/external-filter-and-sorting#sorting-8) los resultados.
diff --git a/src/content/docs/es/guides/cms/cloudcannon.mdx b/src/content/docs/es/guides/cms/cloudcannon.mdx
deleted file mode 100644
index fc22ee69ba18a..0000000000000
--- a/src/content/docs/es/guides/cms/cloudcannon.mdx
+++ /dev/null
@@ -1,30 +0,0 @@
----
-title: CloudCannon y Astro
-description: Agrega contenido a tu proyecto de Astro utilizando CloudCannon como CMS
-type: cms
-stub: true
-service: CloudCannon
-i18nReady: true
----
-import Grid from '~/components/FluidGrid.astro'
-import Card from '~/components/ShowcaseCard.astro'
-
-[CloudCannon](https://cloudcannon.com) es un sistema de gestión de contenido basado en Git que proporciona un editor visual para tu contenido.
-
-## Recursos oficiales
-
-- [Guía de inicio de Astro](https://cloudcannon.com/documentation/guides/astro-starter-guide/)
-- [Guía de Bookshop y Astro](https://cloudcannon.com/documentation/guides/bookshop-astro-guide/)
-- [Serie de tutoriales para principiantes de Astro](https://cloudcannon.com/tutorials/astro-beginners-tutorial-series/)
-- Blog: [Cómo funciona la edición en vivo de CloudCannon con Astro y Bookshop](https://cloudcannon.com/blog/how-cloudcannons-live-editing-works-with-astro-and-bookshop/)
-- Blog: [Soporte excepcional para todos los usuarios de Astro](https://cloudcannon.com/blog/out-of-this-world-support-for-all-astro-users/)
-
-## Recursos de la comunidad
-
-- [CloudCannon anuncia soporte oficial para Astro](https://astro.build/blog/astro-cloudcannon-support/)
-
-## Temas
-
-<Grid>
-  <Card title="Sendit" href="https://astro.build/themes/details/sendit/" thumbnail="sendit.png"/>
-</Grid>
\ No newline at end of file
diff --git a/src/content/docs/es/guides/cms/contentful.mdx b/src/content/docs/es/guides/cms/contentful.mdx
deleted file mode 100644
index 5b5c67b1d969a..0000000000000
--- a/src/content/docs/es/guides/cms/contentful.mdx
+++ /dev/null
@@ -1,573 +0,0 @@
----
-title: Contentful & Astro
-description: Agrega contenido a tu proyecto Astro usando Contentful como CMS
-type: cms
-service: Contentful
-i18nReady: true
----
-import { FileTree } from '@astrojs/starlight/components';
-import PackageManagerTabs from '~/components/tabs/PackageManagerTabs.astro'
-import { Steps } from '@astrojs/starlight/components';
-
-[Contentful](https://www.contentful.com/) es un CMS headless que te permite administrar contenido, integrar con otros servicios y publicar en múltiples plataformas.
-
-## Integración con Astro
-
-En esta sección, usaremos el [SDK de Contentful](https://github.com/contentful/contentful.js) para conectar tu espacio de Contentful con Astro sin JavaScript en el lado del cliente.
-
-### Prerrequisitos
-
-Para empezar, necesitarás lo siguiente:
-
-1. **Un proyecto Astro** - Si aún no tienes un proyecto Astro, nuestra [guía de instalación](/es/install-and-setup/) te ayudará a comenzar en cuestión de minutos.
-
-2. **Una cuenta de Contentful y un espacio de Contentful**. Si aún no tienes una cuenta, puedes [registrarte](https://www.contentful.com/sign-up/) para obtener una cuenta gratuita y crear un nuevo espacio de Contentful. También puedes usar un espacio existente si ya tienes uno.
-
-3. **Credenciales de Contentful** - Puedes encontrar las siguientes credenciales en tu panel de control de Contentful **Settings > API keys**. Si no tienes ninguna clave de API, crea una seleccionando **Add API key**.
-
-    - **ID del espacio de Contentful** - El ID de tu espacio de Contentful.
-    - **Token de acceso de entrega de Contentful** - El token de acceso para consumir contenido _publicado_ de tu espacio de Contentful.
-    - **Token de acceso de previsualización de Contentful** - El token de acceso para consumir contenido _no publicado_ de tu espacio de Contentful.
-
-### Configurando credenciales
-
-Para agregar las credenciales de tu espacio de Contentful a Astro, crea un archivo `.env` en la raíz de tu proyecto con las siguientes variables:
-
-```ini title=".env"
-CONTENTFUL_SPACE_ID=TU_ID_DE_ESPACIO
-CONTENTFUL_DELIVERY_TOKEN=TU_TOKEN_DE_ENTREGA
-CONTENTFUL_PREVIEW_TOKEN=TU_TOKEN_DE_PREVISUALIZACION
-```
-
-Ahora, puedes usar estas variables de entorno en tu proyecto.
-
-Si deseas tener IntelliSense para tus variables de entorno de Contentful, puedes crear un archivo `env.d.ts` en el directorio `src/` y configurar `ImportMetaEnv` de la siguiente manera:
-
-```ts title="src/env.d.ts"
-interface ImportMetaEnv {
-  readonly CONTENTFUL_SPACE_ID: string;
-  readonly CONTENTFUL_DELIVERY_TOKEN: string;
-  readonly CONTENTFUL_PREVIEW_TOKEN: string;
-}
-```
-:::tip
-Lee más acerca de [usar variables de entorno](/es/guides/environment-variables/) y archivos `.env` en Astro.
-:::
-
-Tu directorio raíz ahora debería incluir estos nuevos archivos:
-
-<FileTree title="Estructura del proyecto">
-- src/
-  - **env.d.ts**
-- **.env**
-- astro.config.mjs
-- package.json
-</FileTree>
-
-### Instalando dependencias
-
-Para conectar tu proyecto Astro con tu espacio de Contentful, instala los siguientes paquetes usando el comando de tu gestor de paquetes preferido:
-- [`contentful.js`](https://github.com/contentful/contentful.js), el SDK oficial de Contentful para JavaScript
-- [`rich-text-html-renderer`](https://github.com/contentful/rich-text/tree/master/packages/rich-text-html-renderer), un paquete para renderizar los campos de texto enriquecido de Contentful a HTML.
-
-<PackageManagerTabs>
-  <Fragment slot="npm">
-  ```shell
-  npm install contentful @contentful/rich-text-html-renderer
-  ```
-  </Fragment>
-  <Fragment slot="pnpm">
-  ```shell
-  pnpm add contentful @contentful/rich-text-html-renderer
-  ```
-  </Fragment>
-  <Fragment slot="yarn">
-  ```shell
-  yarn add contentful @contentful/rich-text-html-renderer
-  ```
-  </Fragment>
-</PackageManagerTabs>
-
-Después, crea un nuevo archivo llamado `contentful.ts` en el directorio `src/lib/` de tu proyecto.
-
-```ts title="src/lib/contentful.ts"
-import contentful from "contentful";
-
-export const contentfulClient = contentful.createClient({
-  space: import.meta.env.CONTENTFUL_SPACE_ID,
-  accessToken: import.meta.env.DEV
-    ? import.meta.env.CONTENTFUL_PREVIEW_TOKEN
-    : import.meta.env.CONTENTFUL_DELIVERY_TOKEN,
-  host: import.meta.env.DEV ? "preview.contentful.com" : "cdn.contentful.com",
-});
-
-```
-
-La viñeta de código de arriba crea un nuevo cliente de Contentful, pasando las credenciales del archivo `.env`.
-
-:::caution
-Mientras estés en modo de desarrollo, tu contenido se obtendrá desde la **API de previsualización de Contentful**. Esto significa que podrás ver contenido no publicado desde la aplicación web de Contentful.
-
-En el momento de la compilación, tu contenido se obtendrá desde la **API de entrega de Contentful**. Esto significa que solo el contenido publicado estará disponible en el momento de la compilación.
-:::
-
-Finalmente, tu directorio raíz ahora debería incluir estos nuevos archivos:
-
-<FileTree title="Estructura del proyecto">
-- src/
-  - env.d.ts
-  - lib/
-    - **contentful.ts**
-- .env
-- astro.config.mjs
-- package.json
-</FileTree>
-
-### Obteniendo datos
-
-Los componentes de Astro pueden obtener datos de tu cuenta de Contentful usando el `contentfulClient` y especificando el `content_type`.
-
-Por ejemplo, si tienes un tipo de contenido "blogPost" que tiene un campo de texto para un título y un campo de texto enriquecido para el contenido, tu componente podría verse así:
-
-```astro
----
-import { contentfulClient } from "../lib/contentful";
-import { documentToHtmlString } from "@contentful/rich-text-html-renderer";
-import type { EntryFieldTypes } from "contentful";
-
-interface BlogPost {
-  contentTypeId: "blogPost",
-  fields: {
-    title: EntryFieldTypes.Text
-    content: EntryFieldTypes.RichText,
-  }
-}
-
-const entries = await contentfulClient.getEntries<BlogPost>({
-  content_type: "blogPost",
-});
----
-<body>
-  {entries.items.map((item) => (
-    <section>
-      <h2>{item.fields.title}</h2>
-      <article set:html={documentToHtmlString(item.fields.content)}></article>
-    </section>
-  ))}
-</body>
-```
-
-:::tip
-Si tienes un espacio de Contentful vacío, consulta [configurar un modelo de Contentful](#configurando-un-modelo-de-contentful) para aprender cómo crear un modelo básico de blog para tu contenido.
-:::
-
-Puedes encontrar más opciones de consulta en la [documentación de Contentful](https://contentful.github.io/contentful.js/).
-
-## Creando un blog con Astro y Contentful
- 
-Con la configuración de arriba, ahora puedes crear un blog que use Contentful como CMS.
-
-### Prerequisitos
-
-1. **Un espacio Contentful** - Para este tutorial recomendamos comenzar con un espacio vacío. Si ya tienes un modelo de contenido, puedes usarlo, pero deberás modificar nuestros fragmentos de código para que coincidan con tu modelo de contenido.
-2. **Un proyecto Astro integrado con el [SDK de Contentful](https://github.com/contentful/contentful.js)** - Consulta [integrando con Astro](#integración-con-astro) para obtener más detalles sobre cómo configurar un proyecto Astro con Contentful.
-
-### Configurando un modelo de Contentful
-
-Dentro de tu espacio de Contentful, en la sección **Content model**, crea un nuevo modelo de contenido con los siguientes campos y valores:
-
-- **Nombre:** Publicación de Blog
-- **Identificador de API:** `blogPost`
-- **Descripción:** Este tipo de contenido es para una publicación de blog
-
-En el tipo de contenido recién creado, usa el botón **Add Field** para agregar 5 nuevos campos con los siguientes parámetros:
-
-1. Campo de texto
-    - **Nombre:** título 
-    - **Identificador de API:** `title`
-    (deja los otros parámetros con sus valores predeterminados)
-2. Campo de fecha y hora
-    - **Nombre:** fecha
-    - **Identificador de API:** `date`
-3. Campo de texto
-    - **Nombre:** slug
-    - **Identificador de API:** `slug`
-    (deja los otros parámetros con sus valores predeterminados)
-4. Campo de texto
-    - **Nombre:** descripción
-    - **Identificador de API:** `description`
-5. Campo de texto enriquecido
-    - **Nombre:** contenido
-    - **Identificador de API:** `content`
-
-Presiona **Save** para guardar los cambios.
-
-En la sección **Content**  de tu espacion de Contentful, crea una nueva entrada haciendo clic en el botón **Add Entry**. Luego, completa los campos:
-
-- **Title:** `¡Astro es increíble!`
-- **Slug:** `astro-es-increíble`
-- **Descripción:** `Astro es un nuevo generador de sitios estáticos que es increíblemente rápido y fácil de usar.`
-- **Fecha:** `2022-10-05`
-- **Content:** `¡Este es mi primer publicación blog!`
-
-Presiona **Publish** para guardar la entrada. Acabas de crear tu primer post.
-
-¡Siéntete libre de agregar tantos posts como quieras, luego cambia a tu editor de código favorito para comenzar a hackear con Astro!
-
-### Mostrando una lista de publicaciones de blog
-
-Crea una nueva interfaz llamada `BlogPost` y agrégala a tu archivo `contentful.ts` en `src/lib/`. Esta interfaz coincidirá con los campos de tu tipo de contenido de publicación de blog en Contentful. Lo usarás para tipar tu respuesta de entradas de publicaciones de blog.
-
-```ts title="src/lib/contentful.ts" ins=", { EntryFieldTypes }" ins={3-12}
-import contentful, { EntryFieldTypes } from "contentful";
-
-export interface BlogPost {
-  contentTypeId: "blogPost",
-  fields: {
-    title: EntryFieldTypes.Text
-    content: EntryFieldTypes.RichText,
-    date: EntryFieldTypes.Date,
-    description: EntryFieldTypes.Text,
-    slug: EntryFieldTypes.Text
-  }
-}
-
-export const contentfulClient = contentful.createClient({
-  space: import.meta.env.CONTENTFUL_SPACE_ID,
-  accessToken: import.meta.env.DEV
-    ? import.meta.env.CONTENTFUL_PREVIEW_TOKEN
-    : import.meta.env.CONTENTFUL_DELIVERY_TOKEN,
-  host: import.meta.env.DEV ? "preview.contentful.com" : "cdn.contentful.com",
-});
-
-```
-
-Ahora, ve a la página de Astro donde obtendrás los datos de Contentful. En este ejemplo usaremos la página de inicio `index.astro` en `src/pages/`.
-
-Importa la interfaz `BlogPost` y `contentfulClient` de `src/lib/contentful.ts`. 
-
-Obtén todos los registros de Contentful con un tipo de contenido de `blogPost` mientras pasas la interfaz `BlogPost` para tipar tu respuesta.
-
-```astro title="src/pages/index.astro"
----
-import { contentfulClient } from "../lib/contentful";
-import type { BlogPost } from "../lib/contentful";
-
-const entries = await contentfulClient.getEntries<BlogPost>({
-  content_type: "blogPost",
-});
----
-```
-
-Esta llamada de búsqueda devolverá una arreglo de tus publicaciones en `entries.items`. Puedes usar `map()` para crear una nueva matriz (`posts`) que formatee tus datos devueltos.
-
-El ejemplo de abajo devuelve las propiedades `items.fields` de nuestro modelo de contenido para crear una vista previa de la publicación del blog, y al mismo tiempo, reformatea la fecha a un formato más legible.
-
-```astro title="src/pages/index.astro" ins={9-17}
----
-import { contentfulClient } from "../lib/contentful";
-import type { BlogPost } from "../lib/contentful";
-
-const entries = await contentfulClient.getEntries<BlogPost>({
-  content_type: "blogPost",
-});
-
-const posts = entries.items.map((item) => {
-  const { title, date, description, slug } = item.fields;
-  return {
-    title,
-    slug,
-    description,
-    date: new Date(date).toLocaleDateString()
-  };
-});
----
-```
-
-Finalmente, puedes usar `posts` en tu plantilla para mostrar una vista previa de cada publicación.
-
-```astro astro title="src/pages/index.astro" ins={19-37}
----
-import { contentfulClient } from "../lib/contentful";
-import type { BlogPost } from "../lib/contentful";
-
-const entries = await contentfulClient.getEntries<BlogPost>({
-  content_type: "blogPost",
-});
-
-const posts = entries.items.map((item) => {
-  const { title, date, description, slug } = item.fields;
-  return {
-    title,
-    slug,
-    description,
-    date: new Date(date).toLocaleDateString()
-  };
-});
----
-<html lang="es">
-  <head>
-    <title>Mi Blog</title>
-  </head>
-  <body>
-    <h1>Mi Blog</h1>
-    <ul>
-      {posts.map((post) => (
-        <li>
-          <a href={`/posts/${post.slug}/`}>
-            <h2>{post.title}</h2>
-          </a>
-          <time>{post.date}</time>
-          <p>{post.description}</p>
-        </li>
-      ))}
-    </ul>
-  </body>
-</html>
-```
-
-### Generando publicaciones de blog individuales
-
-Usa el mismo método para obtener tus datos de Contentful que arriba, pero esta vez, en una página que creará una ruta de página única para cada entrada del blog.
-
-
-#### Generación de sitios estáticos
-
-Si estás usando el modo estático predeterminado de Astro, usarás [rutas dinámicas](/es/guides/routing/#rutas-dinámicas) y la función `getStaticPaths()`. Esta función se llamará en tiempo de compilación para generar la lista de rutas que se convierten en páginas.
-
-Crea un archivo nuevo llamado `[slug].astro` en `src/pages/posts/`.
-
-De la misma manera que importaste en `index.astro`, importa la interfaz `BlogPost` y `contentfulClient` de `src/lib/contentful.ts`.
-
-
-Esta vez, obtén tus datos dentro de una función `getStaticPaths()`.
-
-```astro title="src/pages/posts/[slug].astro"
----
-import { contentfulClient } from "../../lib/contentful";
-import type { BlogPost } from "../../lib/contentful";
-
-export async function getStaticPaths() {
-  const entries = await contentfulClient.getEntries<BlogPost>({
-    content_type: "blogPost",
-  });
-}
----
-```
-
-Luego, mapea cada elemento a un objeto con una propiedad `params` y `props`. La propiedad `params` se usará para generar la URL de la página y la propiedad `props` se pasará al componente de página como props.
-
-```astro title="src/pages/posts/[slug].astro" ins={3,11-19}
----
-import { contentfulClient } from "../../lib/contentful";
-import { documentToHtmlString } from "@contentful/rich-text-html-renderer";
-import type { BlogPost } from "../../lib/contentful";
-
-export async function getStaticPaths() {
-  const entries = await contentfulClient.getEntries<BlogPost>({
-    content_type: "blogPost",
-  });
-
-  const pages = entries.items.map((item) => ({
-    params: { slug: item.fields.slug },
-    props: {
-      title: item.fields.title,
-      content: documentToHtmlString(item.fields.content),
-      date: new Date(item.fields.date).toLocaleDateString(),
-    },
-  }));
-  return pages;
-}
----
-```
-
-La propiedad dentro de `params` debe coincidir con el nombre de la ruta dinámica. Como nuestro nombre de archivo es `[slug].astro`, usamos `slug`.
-
-En nuestro ejemplo, el objeto `props` pasa tres propiedades a la página:
-- título (una cadena)
-- contenido (un documento de texto enriquecido convertido a HTML usando `documentToHtmlString`)
-- fecha (formateada usando el constructor `Date`)
-
-Finalmente, puedes usar las propiedades de la página para mostrar tu publicación.
-
-```astro title="src/pages/posts/[slug].astro" ins={21,23-32}
----
-import { contentfulClient } from "../../lib/contentful";
-import { documentToHtmlString } from "@contentful/rich-text-html-renderer";
-import type { BlogPost } from "../../lib/contentful";
-
-export async function getStaticPaths() {
-  const { items } = await contentfulClient.getEntries<BlogPost>({
-    content_type: "blogPost",
-  });
-  const pages = items.map((item) => ({
-    params: { slug: item.fields.slug },
-    props: {
-      title: item.fields.title,
-      content: documentToHtmlString(item.fields.content),
-      date: new Date(item.fields.date).toLocaleDateString(),
-    },
-  }));
-  return pages;
-}
-
-const { content, title, date } = Astro.props;
----
-<html lang="en">
-  <head>
-    <title>{title}</title>
-  </head>
-  <body>
-    <h1>{title}</h1>
-    <time>{date}</time>
-    <article set:html={content} />
-  </body>
-</html>
-```
-
-Navega a http://localhost:4321/ y haz clic en uno de tus artículos para asegurarte de que tu ruta dinámica esté funcionando.
-
-#### Renderizado del lado del servidor
-
-Si has [optado por el modo SSR](/es/guides/on-demand-rendering/), usarás una ruta dinámica que usa un parámetro `slug` para obtener los datos de Contentful.
-
-Crea un archivo nuevo llamado `[slug].astro` en `src/pages/posts/`. Usa [`Astro.params`](/es/reference/api-reference/#astroparams) para obtener el slug de la URL, luego pásalo a `getEntries`:
-
-```astro title="src/pages/posts/[slug].astro"
----
-import { contentfulClient } from "../../lib/contentful";
-import type { BlogPost } from "../../lib/contentful";
-
-const { slug } = Astro.params;
-
-const data = await contentfulClient.getEntries<BlogPost>({
-  content_type: "blogPost",
-  "fields.slug": slug,
-});
----
-```
-
-Si la entrada no fue encontrada, puedes redirigir al usuario a la página 404 usando [`Astro.redirect`](/es/guides/routing/#redirecciones-dinámicas).
-
-```astro title="src/pages/posts/[slug].astro" ins={7, 12-13}
----
-import { contentfulClient } from "../../lib/contentful";
-import type { BlogPost } from "../../lib/contentful";
-
-const { slug } = Astro.params;
-
-try {
-  const data = await contentfulClient.getEntries<BlogPost>({
-    content_type: "blogPost",
-    "fields.slug": slug,
-  });
-} catch (error) {
-  return Astro.redirect("/404");
-}
----
-```
-Para pasar los datos de la publicación a la sección de plantilla, crea un objeto `post` fuera del bloque `try/catch`.
-
-Usa `documentToHtmlString` para convertir `content` de un documento a HTML, y usa el constructor de `Date` para formatear la fecha. `title` se puede dejar como está. Luego, agrega estas propiedades a tu objeto `post`.
-
-```astro title="src/pages/posts/[slug].astro" ins={7,14-19}
----
-import Layout from "../../layouts/Layout.astro";
-import { contentfulClient } from "../../lib/contentful";
-import { documentToHtmlString } from "@contentful/rich-text-html-renderer";
-import type { BlogPost } from "../../lib/contentful";
-
-let post;
-const { slug } = Astro.params;
-try {
-  const data = await contentfulClient.getEntries<BlogPost>({
-    content_type: "blogPost",
-    "fields.slug": slug,
-  });
-  const { title, date, content } = data.items[0].fields;
-  post = {
-    title,
-    date: new Date(date).toLocaleDateString(),
-    content: documentToHtmlString(content),
-  };
-} catch (error) {
-  return Astro.redirect("/404");
-}
----
-```
-  
-Finalmente, puedes usar `post` para mostrar tu publicación en la sección de plantilla.
-
-```astro title="src/pages/posts/[slug].astro" ins={24-33}
----
-import Layout from "../../layouts/Layout.astro";
-import { contentfulClient } from "../../lib/contentful";
-import { documentToHtmlString } from "@contentful/rich-text-html-renderer";
-import type { BlogPost } from "../../lib/contentful";
-
-let post;
-const { slug } = Astro.params;
-try {
-  const data = await contentfulClient.getEntries<BlogPost>({
-    content_type: "blogPost",
-    "fields.slug": slug,
-  });
-  const { title, date, content } = data.items[0].fields;
-  post = {
-    title,
-    date: new Date(date).toLocaleDateString(),
-    content: documentToHtmlString(content),
-  };
-} catch (error) {
-  return Astro.redirect("/404");
-}
----
-<html lang="en">
-  <head>
-    <title>{post?.title}</title>
-  </head>
-  <body>
-    <h1>{post?.title}</h1>
-    <time>{post?.date}</time>
-    <article set:html={post?.content} />
-  </body>
-</html>
-```
-
-### Publicando tu sitio
-
-Para desplegar tu sitio web, visita nuestras [guías de despliegue](/es/guides/deploy/) y sigue las instrucciones de tu proveedor de alojamiento preferido.
-
-#### Reconstrucción al cambiar contenido en Contentful
-
-Si tu proyecto esta usando el modo estático por defecto de Astro, necesitarás configurar un webhook para que se ejecute una nueva compilación cuando tu contenido cambie. Si estás usando Netlify o Vercel como proveedor de alojamiento, puedes usar su función de webhook para ejecutar una nueva compilación desde eventos de Contentful.
-
-##### Netlify
-
-Para configurar un webhook en Netlify:
-
-<Steps> 
-1. Ve a tu panel de control y haz clic en **Build & deploy**.
-
-2. En la pestaña **Continuous Deployment**, encuentra la sección **Build hooks** y haz clic en **Add build hook**.
-
-3. Proporciona un nombre para tu webhook y selecciona la rama en la que quieres que se ejecute la compilación. Haz clic en **Save** y copia la URL generada.
-</Steps>
-
-##### Vercel
-
-Para configurar un webhook en Vercel:
-
-<Steps> 
-1. Ve a tu panel de control y haz clic en **Settings**.
-
-2. En la pestaña **Git**, encuentra la sección **Deploy Hooks**.
-
-3. Proporciona un nombre para tu webhook y selecciona la rama en la que quieres que se ejecute la compilación. Haz clic en **Add** y copia la URL generada.
-</Steps>
-
-##### Agregando un webhook a Contentful
-
-En tu espacio de Contentful, ve a **settings** y haz clic en la pestaña **Webhooks**. Crea un nuevo webhook haciendo clic en el botón **Add Webhook**. Proporciona un nombre para tu webhook y pega la URL del webhook que copiaste en la sección anterior. Finalmente, haz clic en **Save** para crear el webhook.
-
-Ahora, cada vez que publiques una nueva publicación de blog en Contentful, se iniciará una nueva compilación y se actualizará tu blog.
diff --git a/src/content/docs/es/guides/cms/cosmic.mdx b/src/content/docs/es/guides/cms/cosmic.mdx
deleted file mode 100644
index 85c5a3461ae40..0000000000000
--- a/src/content/docs/es/guides/cms/cosmic.mdx
+++ /dev/null
@@ -1,254 +0,0 @@
----
-title: Cosmic y Astro
-description: Agrega contenido a tu proyecto Astro usando Cosmic como CMS
-type: cms
-service: Cosmic
-i18nReady: true
----
-import PackageManagerTabs from '~/components/tabs/PackageManagerTabs.astro'
-import Grid from '~/components/FluidGrid.astro'
-import Card from '~/components/ShowcaseCard.astro'
-import { Steps } from '@astrojs/starlight/components';
-
-[Cosmic](https://www.cosmicjs.com/) es un [CMS headless](https://www.cosmicjs.com/headless-cms) que ofrece un panel de administración para gestionar contenido y una API que puede integrarse con una variedad de herramientas frontend.
-
-## Prerrequisitos
-
-1. **Un proyecto de Astro**- Si deseas comenzar con un proyecto de Astro nuevo, lee la [guía de instalación](/es/install-and-setup/). Esta guía sigue una versión simplificada del [Tema de Astro Headless CMS](https://astro.build/themes/details/cosmic-cms-blog/) con [Tailwind CSS](https://tailwindcss.com/) para estilizar.
-2. **Una cuenta y un Bucket en Cosmic** - [Crea una cuenta gratuita en Cosmic](https://app.cosmicjs.com/signup) si no tienes una. Después de crear tu cuenta, se te pedirá que crees un nuevo proyecto vacío. También hay disponible una [plantilla Simple de Blog para Astro](https://www.cosmicjs.com/marketplace/templates/simple-astro-blog) (es la misma plantilla que el Tema Astro Headless CMS) para importar automáticamente todo el contenido utilizado en esta guía.
-3. **Tus claves de API de Cosmic** - Desde tu panel de Cosmic, necesitarás encontrar tanto el **slug del Bucket** como la **clave de lectura del Bucket** para conectarte a Cosmic.
-
-## Integrando Cosmic con Astro
-
-
-### Instalando las Dependencias Necesarias
-
-Agrega el [SDK de Cosmic para JavaScript](https://www.npmjs.com/package/@cosmicjs/sdk) para obtener datos de tu Bucket en Cosmic.
-
-<PackageManagerTabs>
-  <Fragment slot="npm">
-  ```shell
-  npm install @cosmicjs/sdk
-  ```
-  </Fragment>
-  <Fragment slot="pnpm">
-  ```shell
-  pnpm add @cosmicjs/sdk
-  ```
-  </Fragment>
-  <Fragment slot="yarn">
-  ```shell
-  yarn add @cosmicjs/sdk
-  ```
-  </Fragment>
-</PackageManagerTabs>
-
-### Configurando Claves de API
-
-Crea un archivo `.env` en la raíz de tu proyecto de Astro (si aún no existe). Agrega tanto el **slug del Bucket** como la **clave de lectura del Bucket** disponibles en tu panel de control de Cosmic como variables de entorno públicas.
-
-```ini title=".env"
-PUBLIC_COSMIC_BUCKET_SLUG=EL_SLUG_DE_TU_BUCKET
-PUBLIC_COSMIC_READ_KEY=TU_CLAVE_DE_LECTURA
-```
-
-## Obteniendo Datos de Cosmic
-
-<Steps>
-1. Crea un nuevo archivo llamado `cosmic.js`. Coloca este archivo dentro de la carpeta `src/lib` en tu proyecto.
-2. Agrega el siguiente código para obtener datos de Cosmic usando el SDK y tus variables de entorno.
-
-    El siguiente ejemplo crea una función llamada `getAllPosts()` para obtener metadatos de objetos `posts` de Cosmic:
-
-    ```js
-    // src/lib/cosmic.js
-    import { createBucketClient } from '@cosmicjs/sdk'
-
-    const cosmic = createBucketClient({
-      bucketSlug: import.meta.env.PUBLIC_COSMIC_BUCKET_SLUG,
-      readKey: import.meta.env.PUBLIC_COSMIC_READ_KEY
-    })
-
-    export async function getAllPosts() {
-      const data = await cosmic.objects
-        .find({
-          type: 'posts'
-        })
-        .props('title,slug,metadata,created_at')
-      return data.objects
-    }
-    ```
-
-    Lee más sobre [consultas en la documentación de Cosmic](https://www.cosmicjs.com/docs/api/queries).
-
-3. Importa tu función de consulta en un componente `.astro`. Después de obtener los datos, los resultados de la consulta pueden utilizarse en tu plantilla de Astro.
-
-    El siguiente ejemplo muestra cómo obtener metadatos de los `posts` de Cosmic y pasar estos valores como props a un componente `<Card />` para crear una lista de publicaciones de blog:
-
-    ```astro
-    ---
-    // src/pages/index.astro
-    import Card from '../components/Card.astro'
-    import { getAllPosts } from '../lib/cosmic'
-
-    const data = await getAllPosts()
-    ---
-
-    <section>
-      <ul class="grid gap-8 md:grid-cols-2">
-        {
-          data.map((post) => (
-            <Card
-              title={post.title}
-              href={post.slug}
-              body={post.metadata.excerpt}
-              tags={post.metadata.tags.map((tag) => tag)}
-            />
-          ))
-        }
-      </ul>
-    </section>
-    ```
-
-    [Mira el código fuente del componente Card](https://github.com/cosmicjs/simple-astro-blog/blob/main/src/components/Card.astro)
-</Steps>
-
-## Construyendo un Blog con Astro y Cosmic
-
-Puedes gestionar el contenido de tu blog de Astro mediante Cosmic y crear webhooks para volver a implementar automáticamente tu sitio web cuando actualizas o agregas nuevo contenido.
-
-### Objetos de Contenido de Cosmic
-
-Las siguientes instrucciones asumen que tienes un **Tipo de Objeto** en Cosmic llamado **posts**. Cada publicación individual de blog es un `post` que se define en el panel de control de Cosmic con los siguientes Metafields:
-
-1. **Text input** - Autor
-2. **Image** - Imagen de portada
-3. **Repeater** - Etiquetas
-    - **Text input** - Título
-4. **Text area** - Extracto  
-5. **Rich Text** - Contenido
-
-### Mostrando una lista de publicaciones de blog en Astro
-
-Utilizando el mismo [método de obtención de datos](#obteniendo-datos-de-cosmic) que se muestra anteriormente, importa la consulta `getAllPosts()` desde tu archivo de script y espera a que se obtengan los datos. Esta función proporciona metadatos sobre cada `post` que se pueden mostrar dinámicamente.
-
-El ejemplo a continuación pasa estos valores a un componente `<Card />` para mostrar una lista formateada de publicaciones de blog:
-
-```astro
----
-// src/pages/index.astro
-import Card from '../components/Card.astro'
-import { getAllPosts } from '../lib/cosmic'
-
-const data = await getAllPosts()
----
-
-<section>
-  <ul class="grid gap-8 md:grid-cols-2">
-    {
-      data.map((post) => (
-        <Card
-          title={post.title}
-          href={post.slug}
-          body={post.metadata.excerpt}
-          tags={post.metadata.tags.map((tag) => tag)}
-        />
-      ))
-    }
-  </ul>
-</section>
-```
-
-### Generando publicaciones individuales de blog con Astro
-
-Para generar una página individual con contenido completo para cada publicación de blog, crea una [página de enrutamiento dinámico](/es/guides/routing/#rutas-dinámicas) en `src/pages/blog/[slug].astro`.
-
-Esta página exportará una función `getStaticPaths()` para generar una ruta de página en el `slug` devuelto por cada objeto `post`. Esta función se llama en tiempo de compilación y genera y renderiza todas tus publicaciones de blog de una vez.
-
-Para acceder a tus datos desde Cosmic:
-
-- Realiza una consulta a Cosmic dentro de `getStaticPaths()` para obtener datos sobre cada publicación y proporcionarlos a la función.
-- Utiliza cada `post.slug` como un parámetro de ruta, creando las URLs para cada publicación de blog.
-- Devuelve cada `post` dentro de `Astro.props`, haciendo que los datos de la publicación estén disponibles en la parte de la plantilla HTML del componente de la página para su renderización.
-
-El marcado HTML a continuación utiliza varios datos de Cosmic, como el título de la publicación, la imagen de portada y el **contenido en texto enriquecido** (contenido completo de la publicación de blog). Utiliza [set&colon;html](/es/reference/directives-reference/#sethtml) en el elemento que muestra el contenido en texto enriquecido de Cosmic para renderizar elementos HTML en la página exactamente como se obtienen de Cosmic.
-
-```astro
----
-// src/pages/blog/[slug].astro
-import { getAllPosts } from '../../lib/cosmic'
-import { Image } from 'astro:assets'
-
-export async function getStaticPaths() {
-  const data = (await getAllPosts()) || []
-
-  return data.map((post) => {
-    return {
-      params: { slug: post.slug },
-      props: { post }
-    }
-  })
-}
-
-const { post } = Astro.props
----
-
-<article class="mx-auto max-w-screen-md pt-20">
-  <section class="border-b pb-8">
-    <h1 class="text-4xl font-bold">{post.title}</h1>
-    <div class="my-4"></div>
-    <span class="text-sm font-semibold">{post.metadata.author?.title}</span>
-  </section>
-  {
-    post.metadata.cover_image && (
-      <Image
-        src={post.metadata.cover_image.imgix_url}
-        format="webp"
-        width={1200}
-        height={675}
-        aspectRatio={16 / 9}
-        quality={50}
-        alt={`Imagen de portada del blog ${post.title}`}
-        class={'my-12 rounded-md shadow-lg'}
-      />
-    )
-  }
-  <div set:html={post.metadata.content} />
-</article>
-```
-
-### Publicando tu sitio
-
-Para desplegar tu sitio web, visita las [guías de despliegue](/es/guides/deploy/) y sigue las instrucciones para tu proveedor de alojamiento preferido.
-
-#### Reconstruir en actualizaciones de contenido en Cosmic
-
-Puedes configurar un webhook directamente en Cosmic para desencadenar una nueva implementación de tu sitio en tu plataforma de alojamiento (p. ej. Vercel) cada vez que actualices o añadas objetos de contenido.
-
-En "Settings" > "webhooks", agrega el endpoint de URL de Vercel y selecciona el Tipo de Objeto que deseas usar para activar el webhook. Haz clic en "Add webhook" para guardarlo.
-
-##### Netlify
-
-Para configurar un webhook en Netlify:
-
-1. Ve a tu panel de control del sitio y haz clic en **Build & deploy**.
-2. En la pestaña de **Continuous Deployment**, busca la sección de **Build hooks** y haz clic en **Add build hook**.
-3. Proporciona un nombre para tu webhook y selecciona la rama en la que deseas activar la compilación. Haz clic en **Save** y copia la URL generada.
-
-##### Vercel
-
-Para configurar un webhook en Vercel:
-
-<Steps>
-1. Ve a tu panel de control del proyecto y haz clic en **Settings**.
-
-2. En la pestaña de **Git**, busca la sección de **Deploy Hooks**.
-
-3. Proporciona un nombre para tu webhook y la rama en la que deseas activar la compilación. Haz clic en **Add** y copia la URL generada.
-</Steps>
-
-## Temas
-
-<Grid>
-  <Card title="Astro Headless CMS Blog" href="https://astro.build/themes/details/cosmic-cms-blog/" thumbnail="simple-astro-blog.png" />
-</Grid>
diff --git a/src/content/docs/es/guides/cms/crystallize.mdx b/src/content/docs/es/guides/cms/crystallize.mdx
deleted file mode 100644
index e0aeda71d2436..0000000000000
--- a/src/content/docs/es/guides/cms/crystallize.mdx
+++ /dev/null
@@ -1,46 +0,0 @@
----
-title: Crystallize y Astro
-description: Agrega contenido a tu proyecto Astro usando Crystallize como CMS
-type: cms
-stub: true
-service: Crystallize
-i18nReady: true
----
-[Crystallize](https://crystallize.com/) es un sistema de gestión de contenido headless para el comercio electrónico que expone una API de GraphQL.
-## Ejemplo
-
-```astro title="src/pages/index.astro"
----
-// Obtén las rutas de tu catálogo desde la API de GraphQL de Crystallize
-
-import BaseLayout from '../../layouts/BaseLayout.astro';
-import { createClient } from '@crystallize/js-api-client';
-
-const apiClient = createClient({
-  tenantIdentifier: 'furniture'
-});
-
-const query = `
-  query getCataloguePaths{
-    catalogue(language: "en", path: "/shop") {
-      name
-      children {
-        name
-        path
-      }
-    }
-  }
-`
-const { data: { catalogue } } = await apiClient.catalogueApi(query)
----
-<BaseLayout>
-  <h1>{catalogue.name}</h1>
-  <nav>
-    <ul>
-      {catalogue.children.map(child => (
-        <li><a href={child.path}>{child.name}</a></li>
-      ))}
-    </ul>
-  </nav>
-</BaseLayout>
-```
diff --git a/src/content/docs/es/guides/cms/datocms.mdx b/src/content/docs/es/guides/cms/datocms.mdx
deleted file mode 100644
index d55c66a908705..0000000000000
--- a/src/content/docs/es/guides/cms/datocms.mdx
+++ /dev/null
@@ -1,212 +0,0 @@
----
-title: DatoCMS y Astro
-description: Agrega contenido a tu proyecto de Astro utilizando DatoCMS
-type: cms
-stub: false
-service: DatoCMS
-i18nReady: true
----
-import { Steps } from '@astrojs/starlight/components';
-import { FileTree } from '@astrojs/starlight/components';
-
-[DatoCMS](https://datocms.com/) es un CMS headless basado en la web para gestionar contenido digital en tus sitios y aplicaciones.
-
-## Integración con Astro
-
-En esta guía, obtendrás datos de contenido desde DatoCMS en tu proyecto de Astro y luego los mostrarás en una página.
-
-## Prerrequisitos
-
-Para comenzar, necesitarás tener lo siguiente:
-
-- **Un proyecto de Astro** - Si aún no tienes un proyecto de Astro, puedes seguir las instrucciones en nuestra [guía de instalación](/es/install-and-setup/).
-- **Una cuenta y proyecto de DatoCMS** - Si no tienes una cuenta, puedes [registrarte para obtener una cuenta gratuita](https://dashboard.datocms.com/signup).
-- **La clave de API de solo lectura para tu proyecto de DatoCMS** - Puedes encontrarla en el panel de administración de tu proyecto, en "Settings" > "API Tokens".
-
-## Configurando las credenciales
-
-Crea un nuevo archivo (si aún no existe) llamado `.env` en la raíz de tu proyecto de Astro. Agrega una nueva variable de entorno de la siguiente manera, utilizando la clave de API que se encuentra en el panel de administración de DatoCMS:
-
-```ini title=".env"
-DATOCMS_API_KEY=TU_API_KEY
-```
-
-Para soportar TypeScript, declara el tipo de esta variable de entorno en el archivo `env.d.ts` en la carpeta `src/`. Si este archivo no existe, puedes crearlo y agregar lo siguiente:
-
-```ts title="src/env.d.ts"
-interface ImportMetaEnv {
-  readonly DATOCMS_API_KEY: string;
-}
-```
-
-Tu directorio raíz debería incluir ahora estos archivos:
-
-<FileTree title="Estructura del proyecto">
-- src/
-  - **env.d.ts**
-- **.env**
-- astro.config.mjs
-- package.json
-</FileTree>
-
-## Crear un modelo en DatoCMS
-
-En el panel de administración de DatoCMS de tu proyecto, ve a "Settings" > "Models" y crea un nuevo modelo llamado "Home" con la opción "Single Instance" seleccionada. Esto creará una página de inicio para tu proyecto. En este modelo, agrega un nuevo campo de texto para el título de la página.
-
-Ve a la pestaña "Content" en tu proyecto y haz clic en tu página de inicio recién creada. Ahora puedes agregar un título. Guarda la página y continúa.
-
-## Obteniendo datos
-
-En tu proyecto de Astro, navega a la página que obtendrá y mostrará tu contenido del CMS. Agrega la siguiente consulta para obtener el contenido de `home` utilizando la API de GraphQL de DatoCMS.
-
-Este ejemplo muestra el título de la página de DatoCMS en `src/pages/index.astro`:
-
-```astro title="src/pages/index.astro"
----
-const response = await fetch('https://graphql.datocms.com/', {
-	method: 'POST',
-	headers: {
-		'Content-Type': 'application/json',
-		Accept: 'application/json',
-		Authorization: `Bearer ${import.meta.env.DATOCMS_API_KEY}`,
-	},
-	body: JSON.stringify({
-		query: `query Homepage {
-          home {
-            title
-          }
-        }
-      `,
-	}),
-});
-
-const json = await response.json();
-const data = json.data.home;
----
-
-<h1>{data.title}</h1>
-```
-
-Esta consulta de GraphQL obtendrá el campo `title` en la página `home` de tu proyecto de DatoCMS. Cuando actualices tu navegador, deberías ver el título en tu página.
-
-## Agregando bloques de contenido modular dinámico.
-
-Si tu proyecto DatosCMS incluye [contenido modular](https://www.datocms.com/docs/content-modelling/modular-content), entonces deberás construir un componente `.astro` correspondiente para cada bloque de contenido (p. ej. una sección de texto, un video, un bloque de cita, etc.) que el campo modular permita en tu proyecto.
-
-El ejemplo a continuación es un componente `<Text />` en Astro para mostrar un bloque de "Texto con múltiples párrafos" de DatoCMS. 
-
-```astro title="src/components/Text.astro"
----
-export interface TextProps {
-	text: string
-}
-
-export interface Props {
-	item: TextProps
-}
-
-const { item } = Astro.props;
----
-
-<div set:html={item.text} />
-
-```
-Para obtener estos bloques, edita tu consulta GraphQL para incluir el bloque de contenido modular que creaste en DatoCMS.
-
-En este ejemplo, el bloque de contenido modular se llama **content** en DatoCMS. Esta consulta también incluye el `_modelApiKey` único de cada elemento para verificar qué bloque debe mostrarse en el campo modular, según el bloque elegido por el autor del contenido en el editor de DatoCMS. Utiliza una declaración `switch` en la plantilla de Astro para permitir la representación dinámica basada en los datos recibidos de la consulta.
-
-El siguiente ejemplo representa un bloque de contenido modular de DatoCMS que permite al autor elegir entre un campo de texto (`<Text />`) y una imagen (`<Image />`)  para renderizar en la página de inicio:
-
-```astro title="src/pages/index.astro" ins={2,3, 16-27, 39-50}
----
-import Image from '../components/Image.astro';
-import Text from '../components/Text.astro';
-
-const response = await fetch('https://graphql.datocms.com/', {
-	method: 'POST',
-	headers: {
-		'Content-Type': 'application/json',
-		Accept: 'application/json',
-		Authorization: `Bearer ${import.meta.env.DATOCMS_API_KEY}`,
-	},
-	body: JSON.stringify({
-		query: `query Homepage {
-          home {
-            title
-            content {
-              ... on ImageRecord {
-                _modelApiKey
-               image{
-                url
-               }
-              }
-              ... on TextRecord {
-                _modelApiKey
-                text(markdown: true)
-              }
-            }
-          }
-        }
-      `,
-	}),
-});
-
-const json = await response.json();
-const data = json.data.home;
----
-
-<h1>{data.title}</h1>
-{
-  data.content.map((item: any) => {
-    switch (item._modelApiKey) {
-      case 'image':
-        return <Image item={item} />;
-      case 'text':
-        return <Text item={item} />;
-      default:
-        return null;
-    }
-  })
-}
-
-```
-
-## Publicando tu sitio
-
-Para desplegar tu sitio web, visita nuestras [guías de despliegue](/es/guides/deploy/) y sigue las instrucciones para tu proveedor de alojamiento preferido.
-
-## Publicar cambios de contenido en DatoCMS
-
-Si tu proyecto está utilizando el modo estático predeterminado de Astro, necesitarás configurar un webhook para iniciar una nueva construcción cuando tu contenido cambie. Si estás utilizando Netlify o Vercel como tu proveedor de alojamiento, puedes utilizar su función de webhook para iniciar una nueva construcción cuando cambies el contenido en DatoCMS.
-
-### Netlify
-
-Para configurar un webhook en Netlify:
-
-<Steps>
-1. Ve a tu panel de control del sitio y haz clic en **Build & deploy**.
-
-2. En la pestaña de **Continuous Deployment**, busca la sección de **Build hooks** y haz clic en **Add build hook**.
-
-3. Proporciona un nombre para tu webhook y selecciona la rama en la que deseas activar la compilación. Haz clic en **Save** y copia la URL generada.
-</Steps>
-
-### Vercel
-
-Para configurar un webhook en Vercel:
-
-<Steps>
-1. Ve a tu panel de control del proyecto y haz clic en **Settings**.
-
-2. En la pestaña de **Git**, busca la sección de **Deploy Hooks**.
-
-3. Proporciona un nombre para tu webhook y la rama en la que deseas activar la compilación. Haz clic en **Add** y copia la URL generada.
-</Steps>
-
-### Agregando un webhook a DatoCMS
-
-En el panel de administración de tu proyecto en DatoCMS, ve a la pestaña de **Settings** y haz clic en **Webhooks**. Haz clic en el ícono de más para crear un nuevo webhook y asígnale un nombre. En el campo de URL, pega la URL generada por tu servicio de alojamiento preferido. Como Trigger, selecciona la opción que mejor se ajuste a tus necesidades (por ejemplo: compilar cada vez que se publique un nuevo registro).
-
-## Proyecto de inicio
-
-También puedes consultar la [plantilla de blog Astro](https://www.datocms.com/marketplace/starters/astro-template-blog) en el mercado de DatoCMS para aprender cómo crear un blog con Astro y DatoCMS.
diff --git a/src/content/docs/es/guides/cms/decap-cms.mdx b/src/content/docs/es/guides/cms/decap-cms.mdx
deleted file mode 100644
index 94a728dd7e2a0..0000000000000
--- a/src/content/docs/es/guides/cms/decap-cms.mdx
+++ /dev/null
@@ -1,156 +0,0 @@
----
-title: Decap CMS y Astro
-description: Añade contenido a tu proyecto Astro usando Decap como CMS
-type: cms
-stub: true
-service: Decap CMS
-i18nReady: true
----
-import Grid from '~/components/FluidGrid.astro'
-import Card from '~/components/ShowcaseCard.astro'
-import { Steps } from '@astrojs/starlight/components';
-import { FileTree } from '@astrojs/starlight/components'
-import PackageManagerTabs from '~/components/tabs/PackageManagerTabs.astro'
-
-[Decap CMS](https://www.decapcms.org/) (anteriormente Netlify CMS) es un sistema de gestión de contenido de código abierto basado en Git.
-
-Decap te permite aprovechar al máximo todas las funciones de Astro, incluida la optimización de imágenes y las colecciones de contenido.
-
-Decap añade una ruta (normalmente `/admin`) a tu proyecto que cargará una aplicación React para permitir a los usuarios autorizados administrar el contenido directamente desde el sitio web desplegado. Decap enviará los cambios directamente al repositorio fuente de su proyecto Astro.
-
-## Instalar DecapCMS
-
-Hay dos opciones para añadir Decap a Astro:
-
-1. [Instala Decap a través de un administrador de paquetes](https://decapcms.org/docs/install-decap-cms/#installing-with-npm) con el siguiente comando:
-
-  <PackageManagerTabs>
-      <Fragment slot="npm">
-      ```shell
-      npm install decap-cms-app
-      ```
-      </Fragment>
-      <Fragment slot="pnpm">
-      ```shell
-      pnpm add decap-cms-app
-      ```
-      </Fragment>
-      <Fragment slot="yarn">
-      ```shell
-      yarn add decap-cms-app
-      ```
-      </Fragment>
-    </PackageManagerTabs>
-
-2. Importa el paquete a una etiqueta `<script>` dentro del `<body>` de tu página.
-
-```html title='/admin'
-     <body>
-       <!-- Incluye el script que crea la página y alimenta Decap CMS -->
-       <script src="https://unpkg.com/decap-cms@^3.1.2/dist/decap-cms.js"></script>
-    </body>
-```
-
-## Configuración
-
-<Steps>
-1. Crea una carpeta de administración estática en `public/admin/`
-
-2. Agrega `config.yml` a `public/admin/`:
-     <FileTree>
-      - public
-        - admin
-          - config.yml
-    </FileTree>
-
-3. Para agregar soporte para colecciones de contenido, configura cada esquema en `config.yml`. El siguiente ejemplo configura una colección `blog`, definiendo una `etiqueta` para la propiedad frontmatter de cada entrada:
-     ```yml title="/public/admin/config.yml"
-     collections:
-       - name: "blog" # Usado en rutas, por ejemplo, /admin/collections/blog
-         label: "Blog" # Usado en la interfaz de usuario
-         folder: "src/content/blog" # La ruta a la carpeta donde se almacenan los documentos
-         create: true # Permitir a los usuarios crear nuevos documentos en esta colección
-         fields: # Los campos para cada documento, generalmente al principio
-            - { label: "Layout", name: "layout", widget: "hidden", default: "blog" }
-            - { label: "Title", name: "title", widget: "string" }
-            - { label: "Publish Date", name: "date", widget: "datetime" }
-            - { label: "Featured Image", name: "thumbnail", widget: "image" }
-            - { label: "Rating (scale of 1-5)", name: "rating", widget: "number" }
-            - { label: "Body", name: "body", widget: "markdown" }
-     ```
-
-4. Agregar la ruta `admin` para tu aplicación React. Este archivo puede ser `public/admin/index.html` junto con `config.yml` o, si prefieres utilizar una ruta de Astro, `src/pages/admin.astro`.
-     <FileTree>
-     - public
-       - admin
-          -config.yml
-          - index.html
-     </FileTree>
-     ```html title="/public/admin/index.html" {7, 11}
-     <!doctype html>
-     <html lang="es">
-       <head>
-        <meta charset="utf-8" />
-        <meta name="viewport" content="width=device-width, initial-scale=1.0" />
-        <meta name="robots" content="noindex" />
-        <link href="/admin/config.yml" type="text/yaml" rel="cms-config-url" />
-        <title>Administrador de contenidos</title>
-       </head>
-      <body>
-        <script src="https://unpkg.com/decap-cms@^3.1.2/dist/decap-cms.js"></script>
-      </body>
-    </html>
-    ```
-
-5. Para habilitar la carga de medios a una carpeta específica a través del editor de Decap, agrega una ruta adecuada:
-     ```yml title="/public/admin/config.yml"
-     media_folder: "src/assets/images" # Ubicación donde se almacenarán los archivos en el repositorio
-     public_folder: "src/assets/images" # El atributo src para los medios cargados
-     ```
-</Steps>
-
-Consulta la [documentación de configuración de Decap CMS](https://decapcms.org/docs/configure-decap-cms/) para obtener instrucciones y opciones completas.
-
-## Uso
-Navega hasta `yoursite.com/admin/` para usar el editor de Decap CMS.
-
-## Autenticación
-
-### Decap CMS con Netlify Identity
-
-Decap CMS fue desarrollado originalmente por Netlify y tiene soporte de primera clase para [Netlify Identity](https://docs.netlify.com/security/secure-access-to-sites/identity/).
-
-Cuando despliegues en netlify, configura la identidad para tu proyecto a través del panel de Netlify e incluye el [Netlify Identity Widget](https://github.com/netlify/netlify-identity-widget) en la ruta `admin` de tu proyecto. Opcionalmente, incluye el widget de identidad en la página de inicio de tu sitio si planeas invitar a nuevos usuarios por correo electrónico.
-
-### Decap CMS con clientes OAuth externos
-
-Cuando despliegues en proveedores de hosting distintos de Netlify, debes crear tus propias rutas OAuth.
-
-En Astro, esto se puede hacer con rutas renderizadas bajo demanda en tu proyecto configurado con la [salida `server`](/es/guides/on-demand-rendering/) activada.
-
-Consulta los [Documentos OAuth de Decap](https://decapcms.org/docs/external-oauth-clients/) para obtener una lista de clientes OAuth compatibles mantenidos por la comunidad.
-
-## Recursos de la comunidad
-
-- Plantilla de identidad de Netlify: [astro-decap-ssg-netlify](https://github.com/OliverSpeir/astro-decap-ssg-netlify-identity)
-
-- Representación bajo demanda de rutas Oauth con plantilla Astro: [astro-decap-starter-ssr](https://github.com/OliverSpeir/astro-decap-starter-ssr)
-
-- Publicación de blog: [Crea el contenido de tu sitio Astro con CMS basados en Git] (https://aalam.vercel.app/blog/astro-and-git-cms-netlify) por Aftab Alam
-
-- Tutorial de Youtube: [¡Crea un blog personalizado con Astro y NetlifyCMS en MINUTOS!](https://www.youtube.com/watch?v=3yip2wSRX_4) por Kumail Pirzada
-
-## Sitios en producción
-
-Los siguientes sitios usan Astro + Decap CMS en producción:
-
-- [yunielacosta.com](https://www.yunielacosta.com/) por Yuniel Acosta - [código fuente en GitHub](https://github.com/yacosta738/yacosta738.github.io) (Netlify CMS)
-- [portfolioris.nl](https://www.portfolioris.nl/) por Joris Hulsbosch – [código fuente en GitHub](https://github.com/portfolioris/portfolioris.nl)
-
-## Temas
-
-<Grid>
-  <Card title="Astros" href="https://astro.build/themes/details/astros" thumbnail="astros.png"/>
-  <Card title="Enhanced Astro Starter" href="https://astro.build/themes/details/enhanced-astro-starter" thumbnail="enhanced-astro-starter.png"/>
-  <Card title="Astro Decap CMS Starter" href="https://astro.build/themes/details/astro-decap-cms-starter" thumbnail="astro-decap-starter.png"/>
-</Grid>
diff --git a/src/content/docs/es/guides/cms/directus.mdx b/src/content/docs/es/guides/cms/directus.mdx
deleted file mode 100644
index ae774c826e60b..0000000000000
--- a/src/content/docs/es/guides/cms/directus.mdx
+++ /dev/null
@@ -1,18 +0,0 @@
----
-title: Directus y Astro
-description: Agrega contenido a tu proyecto de Astro utilizando Directus como CMS.
-type: cms
-stub: true
-service: Directus
-i18nReady: true
----
-
-[Directus](https://directus.io/) es un backend como servicio que se puede utilizar para alojar datos y contenido para tu proyecto de Astro.
-
-## Recursos oficiales
-
-- [Empezando con Directus y Astro](https://docs.directus.io/blog/getting-started-directus-astro.html).
-
-## Recursos de la comunidad
-
-- ¡Agrega el tuyo!
diff --git a/src/content/docs/es/guides/cms/drupal.mdx b/src/content/docs/es/guides/cms/drupal.mdx
index 812f265317e1c..332c13cf9282c 100644
--- a/src/content/docs/es/guides/cms/drupal.mdx
+++ b/src/content/docs/es/guides/cms/drupal.mdx
@@ -419,7 +419,7 @@ Con la configuración anterior, ahora puedes crear un blog que use Drupal como C
 
 Usa el mismo método para obtener tus datos de Drupal como arriba, pero esta vez, en una página que creará una ruta de página única para cada artículo.
 
-Este ejemplo utiliza el modo estático predeterminado de Astro y crea [un archivo de página de enrutamiento dinámico](/es/guides/routing/#rutas-dinámicas) con la función `getStaticPaths()`. Esta función se llamará en tiempo de compilación para generar la lista de rutas que se convierten en páginas.
+Este ejemplo utiliza el modo estático predeterminado de Astro y crea [un archivo de página de enrutamiento dinámico](/es/guides/routing/#dynamic-routes) con la función `getStaticPaths()`. Esta función se llamará en tiempo de compilación para generar la lista de rutas que se convierten en páginas.
 
 <Steps>
 1. Crea un nuevo archivo `src/pages/articles/[path].astro` e importa la interfaz `DrupalNode` y `getArticle()` desde `src/api/drupal.ts`. Obtén tus datos dentro de una función `getStaticPaths()` para crear rutas para tu blog.
diff --git a/src/content/docs/es/guides/cms/frontmatter-cms.mdx b/src/content/docs/es/guides/cms/frontmatter-cms.mdx
deleted file mode 100644
index fe339f13919ba..0000000000000
--- a/src/content/docs/es/guides/cms/frontmatter-cms.mdx
+++ /dev/null
@@ -1,192 +0,0 @@
----
-title: Front Matter CMS y Astro
-description: Añade contenido a tu proyecto Astro usando Front Matter CMS
-type: cms
-service: Front Matter CMS
-i18nReady: true
----
-import { FileTree } from '@astrojs/starlight/components';
-
-[Front Matter CMS](https://frontmatter.codes/) trae el CMS a tu editor, se ejecuta dentro de Visual Studio Code, GitPod y muchos más.
-
-## Integración con Astro
-
-En esta sección, veremos cómo agregar Front Matter CMS a tu proyecto de Astro.
- 
-### Prerrequistos
-
-- Visual Studio Code
-- Usa la [plantilla de Astro Blog](https://github.com/withastro/astro/tree/main/examples/blog) para proporcionar la configuración base y el contenido de ejemplo para comenzar con Front Matter CMS.
-
-### Instala la extensión de Front Matter CMS
-
-Puedes obtener la extensión desde la [Plataforma de Visual Studio Code - Front Matter](https://marketplace.visualstudio.com/items?itemName=eliostruyf.vscode-front-matter) o haciendo clic en el siguiente enlace: [abrir la extensión de Front Matter CMS en VS Code](vscode:extension/eliostruyf.vscode-front-matter)
-
-### Inicialización del proyecto
-
-Una vez instalado Front Matter CMS, obtendrás un nuevo icono en la barra de actividad. Se abrirá el panel **Front Matter CMS** en la barra lateral principal cuando hagas clic en él. Sigue los siguientes pasos para inicializar tu proyecto:
-
-- Haz clic en el botón **Initialize project** en el panel de Front Matter
-- La pantalla de bienvenida se abrirá y podrás comenzar a inicializar el proyecto
-- Haz clic en el primer paso para **Initialize project**
-- Como Astro es uno de los frameworks soportados, puedes seleccionarlo de la lista
-- Registra tus carpetas de contenido, en este caso, la carpeta `src/content/blog`.
-
-  :::note
-  El registro de la carpeta es necesario para que Front Matter CMS sepa dónde puede encontrar y crear tu contenido. Puedes tener varios tipos de carpetas como páginas, blog, docs y muchos más.
-  :::
-
-- Se te pedirá que introduzcas el nombre de la carpeta. De forma predeterminada, toma el nombre de la carpeta.
-
-  :::note
-  El nombre se usa durante el proceso de creación de nuevo contenido. Por ejemplo, tener varios registros de carpetas te permite elegir el tipo de contenido que deseas crear.
-  :::
-
-- Haz clic en **Start the dashboard** para abrir el panel de contenido
-
-  :::tip
-  Una vez que Front Matter CMS es inicializado, puedes abrir el panel de contenido de las siguientes maneras:
-
-  - Usando los combinaciones del teclado: <kbd>alt</kbd> + <kbd>d</kbd> (Windows & Linux) o <kbd>options</kbd> + <kbd>d</kbd> (macOS)
-  - Abre la paleta de comandos y busca `Front Matter: Open dashboard`
-  - Haz clic en el icono de **Front Matter** en la barra de título del panel o en los archivos.
-  :::
-
-### Configuración del proyecto
-
-Una vez que el proyecto esté inicializado, obtendrás un archivo de configuración `frontmatter.json` y una carpeta `.frontmatter` en la raíz de tu proyecto.
-
-<FileTree title="Estructura del proyecto">
-- .frontmatter/
-  - database/
-    - mediaDb.json
-- src/
-- astro.config.mjs
-- **frontmatter.json**
-- package.json
-</FileTree>
-
-#### Configuración del tipo de contenido
-
-Los tipos de contenido(content-types) son la forma en que Front Matter CMS gestiona tu contenido. Cada tipo de contenido contiene un conjunto de campos, que se pueden definir por tipo de contenido que deseas usar para tu sitio web.
-
-Los campos corresponden al front matter de tu contenido de página.
-
-Puedes configurar los tipos de contenido en el archivo `frontmatter.json`.
-
-- Abre el archivo `frontmatter.json`
-- Reemplaza el arreglo `frontMatter.taxonomy.contentTypes` con la siguiente configuración de tipos de contenido:
-
-```json title="frontmatter.json"
-"frontMatter.taxonomy.contentTypes": [
-  {
-    "name": "default",
-    "pageBundle": false,
-    "previewPath": "'blog'",
-    "filePrefix": null,
-    "fields": [
-      {
-        "title": "Title",
-        "name": "title",
-        "type": "string",
-        "single": true
-      },
-      {
-        "title": "Description",
-        "name": "description",
-        "type": "string"
-      },
-      {
-        "title": "Publishing date",
-        "name": "pubDate",
-        "type": "datetime",
-        "default": "{{now}}",
-        "isPublishDate": true
-      },
-      {
-        "title": "Content preview",
-        "name": "heroImage",
-        "type": "image",
-        "isPreviewImage": true
-      }
-    ]
-  }
-]
-```
-
-:::note
-Esta configuración asegura que el tipo de contenido de Front Matter coincida con el esquema de la colección de contenido de la plantilla de blog de Astro.
-:::
-
-:::tip
-Puedes encontraar más información sobre los tipos de contenido y los campos soportados en la [sección de documentación de creación de contenido](https://frontmatter.codes/docs/content-creation) de Front Matter CMS.
-:::
-
-### Previsualiza tus artículos en el editor
-
-Desde el panel de **Front Matter CMS**, haz clic en el botón **Start server**. Esta acción inicia el servidor de desarrollo local de Astro. Una vez en ejecución, puedes abrir el panel de contenido, seleccionar uno de los artículos y hacer clic en el botón **Open preview** para abrir el artículo en el editor.
-
-### Crea nuevos artículos
-
-Abre el **Front Matter CMS Dashboard**; puedes hacerlo de la siguiente manera:
-
-- Abre el panel de contenido de Front Matter CMS
-- Haz clic en el botón **Create new article**
-- Front Matter te preguntará por el título del artículo. Rellénalo y pulsa enter
-- Tu nuevo artículo será creado y abierto en el editor. Puedes empezar a escribir tu artículo.
-
-### Usando Markdoc con Front Matter CMS
-
-Para usar Markdoc con Front Matter CMS, debes configurarlo en `frontMatter.content.supportedFileTypes`. Esta configuración le permite al CMS saber qué tipos de archivos puede procesar.
-
-Puedes configurar la opción de la siguiente manera:
-
-```json title="frontmatter.json"
-"frontMatter.content.supportedFileTypes": [ "md", "markdown", "mdx", "mdoc" ]
-```
-
-Para permitir que el contenido se cree como Markdoc, especifica la propiedad `fileType` en el tipo de contenido.
-
-```json title="frontmatter.json" ins={7}
-"frontMatter.taxonomy.contentTypes": [
-  {
-    "name": "default",
-    "pageBundle": false,
-    "previewPath": "'blog'",
-    "filePrefix": null,
-    "fileType": "mdoc",
-    "fields": [
-      {
-        "title": "Title",
-        "name": "title",
-        "type": "string",
-        "single": true
-      },
-      {
-        "title": "Description",
-        "name": "description",
-        "type": "string"
-      },
-      {
-        "title": "Publishing date",
-        "name": "pubDate",
-        "type": "datetime",
-        "default": "{{now}}",
-        "isPublishDate": true
-      },
-      {
-        "title": "Content preview",
-        "name": "heroImage",
-        "type": "image",
-        "isPreviewImage": true
-      }
-    ]
-  }
-]
-```
-
-## Recursos oficiales
-
-- [Front Matter CMS](https://frontmatter.codes/)
-- [Front Matter CMS - Documentación](https://frontmatter.codes/docs/)
-- [Empezando con Astro y Front Matter CMS](https://youtu.be/xb6pZiier_E)
diff --git a/src/content/docs/es/guides/cms/ghost.mdx b/src/content/docs/es/guides/cms/ghost.mdx
deleted file mode 100644
index 31027842b1063..0000000000000
--- a/src/content/docs/es/guides/cms/ghost.mdx
+++ /dev/null
@@ -1,298 +0,0 @@
----
-title: Ghost y Astro
-description: Agrega contenido a tu proyecto Astro usando Ghost como CMS
-type: cms
-stub: false
-service: Ghost
-i18nReady: true
----
-
-import { FileTree } from '@astrojs/starlight/components';
-import PackageManagerTabs from '~/components/tabs/PackageManagerTabs.astro'
-
-[Ghost](https://github.com/TryGhost/Ghost) es un sistema de gestión de contenido de código abierto, headless y construido en Node.js.
-
-## Integración con Astro
-En esta sección, usaremos la [API de contenido de Ghost](https://ghost.org/docs/content-api/) para traer tus datos a tu proyecto Astro.
-
-### Prerrequisitos
-Para comenzar, necesitarás lo siguiente:
-
-1. **Un proyecto Astro** - Si aún no tienes un proyecto Astro, nuestra [guía de instalación](/es/install-and-setup/) te ayudará a comenzar en cuestión de minutos.
-
-2. **Un sitio Ghost** - Se supone que tienes un sitio configurado con Ghost. Si no, puedes configurar uno en un [entorno local.](https://ghost.org/docs/install/local/)
-
-3. **Llave API de contenido** - Puedes crear una integración en la sección `Configuración > Integraciones` de tu sitio. Desde allí puedes encontrar tu `Llave API de contenido`.
-
-
-### Configuración de credenciales
-
-Para agregar las credenciales de tu sitio a Astro, crea un archivo `.env` en la raíz de tu proyecto con la siguiente variable:
-
-
-```ini title=".env"
-CONTENT_API_KEY=TU_LLAVE_API
-```
-
-Ahora, deberías poder usar esta variable de entorno en tu proyecto.
-
-Si quisieras tener IntelliSense para tu variable de entorno, puedes crear un archivo `env.d.ts` en el directorio `src/` y configurar `ImportMetaEnv` de la siguiente manera:
-
-```ts title="src/env.d.ts"
-interface ImportMetaEnv {
-  readonly CONTENT_API_KEY: string;
-}
-```
-:::tip
-Lee más sobre [usar variables de entorno](/es/guides/environment-variables/) y archivos `.env` en Astro.
-:::
-
-Tu directorio raíz ahora debería incluir estos nuevos archivos:
-
-<FileTree title="Estructura del proyecto">
-- src/
-  - **env.d.ts**
-- **.env**
-- astro.config.mjs
-- package.json
-</FileTree>
-
-### Instalación de dependencias
-
-Para conectar con Ghost, instala el paquete oficial [`@tryghost/content-api`](https://www.npmjs.com/package/@tryghost/content-api) usando el comando de tu gestor de paquetes preferido y opcionalmente un paquete útil que contiene definiciones de tipo si estás usando TypeScript:
-
-<PackageManagerTabs>
-  <Fragment slot="npm">
-  ```shell
-  npm install @tryghost/content-api
-  npm install --save @types/tryghost__content-api
-  ```
-  </Fragment>
-  <Fragment slot="pnpm">
-  ```shell
-  pnpm add @tryghost/content-api
-  pnpm add --save-dev @types/tryghost__content-api
-  ```
-  </Fragment>
-  <Fragment slot="yarn">
-  ```shell
-  yarn add @tryghost/content-api
-  yarn add --dev @types/tryghost__content-api
-  ```
-  </Fragment>
-</PackageManagerTabs>
-
-## Creando un blog con Astro y Ghost
-
-Con la configuación de arriba, ahora puedes crear un blog que use Ghost como CMS.
-
-### Prerrequisitos
-
-1. Un blog Ghost.
-2. Un proyecto Astro integrado con la [API de contenido de Ghost](https://www.npmjs.com/package/@tryghost/content-api) - Consulta [integración con Astro](/es/guides/cms/ghost/#integración-con-astro) para obtener más detalles sobre cómo configurar un proyecto Astro con Ghost.
-
-Este ejemplo creará una página de índice que enumere las publicaciones con enlaces a páginas de publicaciones individuales generadas dinámicamente.
-
-### Obteniendo datos
-
-Puedes obtener los datos de tu sitio con el paquete de la API de contenido de Ghost.
-
-Primero, crea un archivo `ghost.ts` dentro de un directorio `lib`.
-
-<FileTree title="Estructura del proyecto">
-- src/
-  - lib/
-    - **ghost.ts**
-  - pages/
-    - index.astro
-- astro.config.mjs
-- package.json
-</FileTree>
-
-Inicializa una instancia de API con la API de Ghost usando la llave API de la página de Integraciones del panel de control de Ghost.
-
-```ts title="src/lib/ghost.ts"
-
-import GhostContentAPI from '@tryghost/content-api';
-
-// Crea una instancia de API con las credenciales del sitio
-export const ghostClient = new GhostContentAPI({
-    url: 'http://127.0.0.1:2368', // Esto es la URL predeterminada si tu sitio se está ejecutando en un entorno local
-    key: import.meta.env.CONTENT_API_KEY,
-    version: 'v5.0',
-});
-
-```
-
-
-### Mostrando una lista de publicaciones
-
-La página `src/pages/index.astro` mostrará una lista de publicaciones, cada una con una descripción y un enlace a su propia página.
-
-
-<FileTree title="Estructura del proyecto">
-- src/
- - lib/
-    - ghost.ts
-  - pages/
-    - **index.astro**
-- astro.config.mjs
-- package.json
-</FileTree>
-
-Impora `ghostClient()` en el frontmatter de Astro para usar el método `posts.browse()` para acceder a las publicaciones del blog de Ghost. Establece `limit: all` para recuperar todas las publicaciones.
-
-```astro title="src/pages/index.astro"
----
-import { ghostClient } from '../lib/ghost';
-const posts = await ghostClient.posts
-    .browse({
-        limit: 'all',
-    })
-    .catch((err) => {
-        console.error(err);
-    });
----
-```
-
-Obteniendo los datos a través de la API de contenido devuelve un arreglo de objetos que contiene las [propiedades de cada publicación](https://ghost.org/docs/content-api/#posts) como:
-- `title` - el título de la publicación
-- `html` - la representación HTML del contenido de la publicación
-- `feature_image` - la URL de origen de la imagen destacada de la publicación
-- `slug` - el slug de la publicación
-
-Usa el arreglo `posts` devuelto de la petición para mostrar una lista de publicaciones en la página.
-
-
-```astro title="src/pages/index.astro"
----
-import { ghostClient } from '../lib/ghost';
-const posts = await ghostClient.posts
-    .browse({
-        limit: 'all',
-    })
-    .catch((err) => {
-        console.error(err);
-    });
----
-
-<html lang="en">
-    <head>
-        <title>Astro + Ghost 👻</title>
-    </head>
-    <body>
-
-        {
-            posts.map((post) => (
-                <a href={`/post/${post.slug}`}>
-                    <h1> {post.title} </h1>
-                </a>
-            ))
-        }
-    </body>
-</html>
-```
-
-### Generando páginas
-
-La página `src/pages/post/[slug].astro` [genera dinámicamente una página](/es/guides/routing/#rutas-dinámicas) para cada publicación.
-
-<FileTree title="Estructura del proyecto">
-- src/
- - lib/
-    -  ghost.ts
-  - pages/
-    - index.astro
-    - post/
-      - **[slug].astro**
-- astro.config.mjs
-- package.json
-</FileTree>
-
-Importa `ghostClient()` para acceder a las publicaciones del blog usando `posts.browse()` y devuelve una publicación como props a cada una de tus rutas dinámicas.
-
-```astro title="src/pages/post/[slug].astro"
----
-import { ghostClient } from '../../lib/ghost';
-
-export async function getStaticPaths() {
-    const posts = await ghostClient.posts
-        .browse({
-            limit: 'all',
-        })
-        .catch((err) => {
-            console.error(err);
-        });
-
-    return posts.map((post) => {
-        return {
-            params: {
-                slug: post.slug,
-            },
-            props: {
-                post: post,
-            },
-        };
-    });
-}
-
-const { post } = Astro.props;
----
-```
-
-Crea la plantilla para cada página usando las propiedades de cada objeto `post`.
-
-```astro title="src/pages/post/[slug].astro" ins={24-37}
----
-import { ghostClient } from '../../lib/ghost';
-export async function getStaticPaths() {
-    const posts = await ghostClient.posts
-        .browse({
-            limit: 'all',
-        })
-        .catch((err) => {
-            console.error(err);
-        });
-    return posts.map((post) => {
-        return {
-            params: {
-                slug: post.slug,
-            },
-            props: {
-                post: post,
-            },
-        };
-    });
-}
-const { post } = Astro.props;
----
-<!DOCTYPE html>
-<html lang="en">
-    <head>
-        <title>{post.title}</title>
-    </head>
-    <body>
-        <img src={post.feature_image} alt={post.title} />
-
-        <h1>{post.title}</h1>
-        <p>{post.reading_time} min read</p>
-
-        <Fragment set:html={post.html} />
-    </body>
-</html>
-```
-:::note
-`<Fragment />` es un componente integrado de Astro que te permite evitar un elemento envoltorio innecesario. Esto puede ser especialmente útil al recuperar HTML de un CMS (por ejemplo, Ghost o [WordPress](/es/guides/cms/wordpress/)).
-:::
-
-### Publicando tu sitio
-Para desplegar tu sitio visita nuestra [guía de despliegue](/es/guides/deploy/) y sigue las instrucciones de tu proveedor de hosting preferido.
-
-## Recursos de la comunidad
-
-- [`astro-starter-ghost`](https://github.com/PhilDL/astro-starter-ghost) en GitHub
-- [`astro-ghostcms`](https://github.com/MatthiesenXYZ/astro-ghostcms) en GitHub
-- [Astro + Ghost + Tailwind CSS](https://andr.ec/posts/astro-ghost-blog/) por Andre Carrera
-- [Tutorial de Ghost CMS y Astro](https://matthiesen.xyz/blog/astro-ghostcms) por Adam Matthiesen
-
-
diff --git a/src/content/docs/es/guides/cms/hashnode.mdx b/src/content/docs/es/guides/cms/hashnode.mdx
deleted file mode 100644
index 48cde1308451b..0000000000000
--- a/src/content/docs/es/guides/cms/hashnode.mdx
+++ /dev/null
@@ -1,353 +0,0 @@
----
-title: Hashnode & Astro
-description: Agrega contenido a tu proyecto de Astro usando Hashnode como un CMS
-type: cms
-stub: false
-service: Hashnode
-i18nReady: true
----
-
-import { FileTree } from '@astrojs/starlight/components';
-import PackageManagerTabs from '~/components/tabs/PackageManagerTabs.astro'
-import { Steps } from '@astrojs/starlight/components';
-
-[Hashnode](https://hashnode.com/) es un CMS alojado que te permite crear un blog o publicación.
-
-## Integración con Astro
-La [API Pública de hashnode](https://apidocs.hashnode.com/) es una API GraphQL que te permite interactuar con Hashnode. Esta guía utiliza [`graphql-request`](https://github.com/jasonkuhrt/graphql-request), un cliente GraphQL minimalista que funciona bien con Astro, para traer tus datos de Hashnode a tu proyecto de Astro.
-
-### Prerrequisitos
-Para comenzar necesitarás tener lo siguiente:
-
-1. **Un proyecto de Astro** - Si aún no tienes un proyecto de Astro, nuestra [Guía de Instalación](/es/install-and-setup/) te ayudará a empezar en poco tiempo.
-
-2. **Un sitio en Hashnode** - Puedes crear un sitio personal gratuito visitando [Hashnode](https://hashnode.com/).
-
-### Instalando dependencias
-
-Instala el paquete `graphql-request` usando el gestor de paquetes de tu elección:
-
-<PackageManagerTabs>
-  <Fragment slot="npm">
-  ```shell
-  npm install graphql-request
-  ```
-  </Fragment>
-  <Fragment slot="pnpm">
-  ```shell
-  pnpm add graphql-request
-  ```
-  </Fragment>
-  <Fragment slot="yarn">
-  ```shell
-  yarn add graphql-request
-  ```
-  </Fragment>
-</PackageManagerTabs>
-
-## Haciendo un blog con Astro y Hashnode
-
-Esta guía usa [`graphql-request`](https://github.com/jasonkuhrt/graphql-request), un cliente GraphQL minimalista que funciona bien con Astro, para traer tus datos de Hashnode a tu proyecto de Astro.
-
-### Requisitos Previos
-
-1. Un blog de Hashnode. 
-2. Un proyecto de Astro integrado con el paquete [graphql-request](https://github.com/jasonkuhrt/graphql-request) instalado.
-
-Este ejemplo creará una página de índice que lista las publicaciones con enlaces a páginas individuales generadas dinámicamente.
-
-### Obteniendo Datos
-
-<Steps>
-1. Para obtener los datos de tu sitio con el paquete `graphql-request`, crea un directorio `src/lib` y crea dos archivos nuevos: `client.ts` & `schema.ts`:
-
-    <FileTree title="Project Structure">
-    - src/
-      - lib/
-        - **client.ts**
-        - **schema.ts**
-      - pages/
-        - index.astro
-    - astro.config.mjs
-    - package.json
-    </FileTree>
-
-2. Inicializa una instancia de API con GraphQLClient utilizando la URL de tu sitio web de Hashnode.
-
-    ```ts title="src/lib/client.ts" "astroplayground.hashnode.dev"
-
-    import { gql, GraphQLClient } from "graphql-request";
-    import type { AllPostsData, PostData } from "./schema";
-
-    export const getClient = () => { 
-      return new GraphQLClient("https://gql.hashnode.com") 
-    }
-
-    const myHashnodeURL = "astroplayground.hashnode.dev";
-
-    export const getAllPosts = async () => {
-      const client = getClient();
-
-      const allPosts = await client.request<AllPostsData>(
-        gql`
-          query allPosts {
-            publication(host: "${myHashnodeURL}") {
-              title
-              posts(first: 20) {
-                pageInfo{
-                  hasNextPage
-                  endCursor
-                }
-                edges {
-                  node {
-                    author{
-                      name
-                      profilePicture
-                    }
-                    title
-                    subtitle
-                    brief
-                    slug
-                    coverImage {
-                      url
-                    }
-                    tags {
-                      name
-                      slug
-                    }
-                    publishedAt
-                    readTimeInMinutes
-                  }
-                }
-              }
-            }
-          }
-        `
-      );
-
-      return allPosts;
-    };
-
-
-    export const getPost = async (slug: string) => {
-      const client = getClient();
-
-      const data = await client.request<PostData>(
-        gql`
-          query postDetails($slug: String!) {
-            publication(host: "${myHashnodeURL}") {
-              post(slug: $slug) {
-                author{
-                  name
-                  profilePicture
-                }
-                publishedAt
-                title
-                subtitle
-                readTimeInMinutes
-                content{
-                  html
-                }
-                tags {
-                  name
-                  slug
-                }
-                coverImage {
-                  url
-                }
-              }
-            }
-          }
-        `,
-        { slug: slug }
-      );
-          
-      return data.publication.post;
-    };
-
-    ```
-
-3. Configura un `schema.ts` para definir la estructura de los datos devueltos por la API de hashnode.
-
-    ```ts title="src/lib/schema.ts"
-
-    import { z } from "astro/zod";
-
-    export const PostSchema = z.object({
-        author: z.object({
-            name: z.string(),
-            profilePicture: z.string(),
-            }),
-        publishedAt: z.string(),
-        title: z.string(),
-        subtitle: z.string(),
-        brief: z.string(),
-        slug: z.string(),
-        readTimeInMinutes: z.number(),
-        content: z.object({
-            html: z.string(),
-        }),
-        tags: z.array(z.object({
-            name: z.string(),
-            slug: z.string(),
-        })),
-        coverImage: z.object({
-            url: z.string(),
-        }),
-    })
-
-    export const AllPostsDataSchema = z.object({
-        publication: z.object({
-            title: z.string(),
-            posts: z.object({
-                pageInfo: z.object({
-                    hasNextPage: z.boolean(),
-                    endCursor: z.string(),
-                }),
-                edges: z.array(z.object({
-                    node: PostSchema,
-                })),
-            }),
-        }),
-    })
-
-    export const PostDataSchema = z.object({
-        publication: z.object({
-            title: z.string(),
-            post: PostSchema,
-        }),
-    })
-
-    export type Post = z.infer<typeof PostSchema>
-    export type AllPostsData = z.infer<typeof AllPostsDataSchema>
-    export type PostData = z.infer<typeof PostDataSchema>
-
-    ```
-</Steps>
-
-### Mostrando una lista de publicaciones
-
-Obtener mediante `getAllPosts()` devuelve un array de objetos que contiene las propiedades de cada publicación, tales como:
-- `title` - El título de la publicación
-- `brief` - La representación HTML del contenido de la publicación
-- `coverImage.url` - La URL de origen de la imagen destacada de la publicación
-- `slug` - El slugh de la publicación
-
-Utiliza el array `posts` que devuelve la consulta para mostrar una lista de publicaciones de blog en la página.
-
-```astro title="src/pages/index.astro"
----
-import { getAllPosts } from '../lib/client';
-
-const data = await getAllPosts();
-const allPosts = data.publication.posts.edges;
-
----
-
-<html lang="en">
-    <head>
-        <title>Astro + Hashnode</title>
-    </head>
-    <body>
-
-        {
-            allPosts.map((post) => (
-                <div>
-                    <h2>{post.node.title}</h2>
-                    <p>{post.node.brief}</p>
-                    <img src={post.node.coverImage.url} alt={post.node.title} />
-                    <a href={`/post/${post.node.slug}`}>Read more</a>
-                </div>
-            ))
-        }
-    </body>
-</html>
-```
-
-### Generando páginas
-
-<Steps>
-1. Crea la página `src/pages/post/[slug].astro` para [generar dinámicamente una página](/es/guides/routing/#rutas-dinámicas) para cada publicación.
-
-    <FileTree title="Project Structure">
-    - src/
-    - lib/
-        - client.ts
-        - schema.ts
-      - pages/
-        - index.astro
-        - post/
-          - **[slug].astro**
-    - astro.config.mjs
-    - package.json
-    </FileTree>
-
-2. Importa y utliza `getAllPosts()` y `getPost()`para obtener los datos de Hashnode y generar rutas de página individuales para cada publicación.
-
-    ```astro title="src/pages/post/[slug].astro"
-    ---
-    import { getAllPosts, getPost } from '../../lib/client';
-
-
-    export async function getStaticPaths() {
-      const data = await getAllPosts();
-      const allPosts = data.publication.posts.edges;
-      return allPosts.map((post) => {
-        return {
-          params: { slug: post.node.slug },
-        }
-      })
-    }
-    const { slug } = Astro.params;
-    const post = await getPost(slug);
-
-    ---
-    ```
-
-3. Crea la plantilla para cada página usando las propiedades de cada objeto `post`. El ejemplo de abajo muestra el título de la publicación y tiempo de lectura, luego el contenido completo de la publicación:
-
-    ```astro title="src/pages/post/[slug].astro"
-    ---
-    import { getAllPosts, getPost } from '../../lib/client';
-
-
-    export async function getStaticPaths() {
-      const data = await getAllPosts();
-      const allPosts = data.publication.posts.edges;
-      return allPosts.map((post) => {
-        return {
-          params: { slug: post.node.slug },
-        }
-      })
-    }
-    const { slug } = Astro.params;
-    const post = await getPost(slug);
-
-    ---
-    <!DOCTYPE html>
-    <html lang="en">
-        <head>
-            <title>{post.title}</title>
-        </head>
-        <body>
-            <img src={post.coverImage.url} alt={post.title} />
-
-            <h1>{post.title}</h1>
-            <p>{post.readTimeInMinutes} min read</p>
-
-            <Fragment set:html={post.content.html} />
-        </body>
-    </html>
-    ```
-    :::note
-    `<Fragment />` Es un componente integrado de Astro que te permite evitar un elemento de contenedor innecesario. Puede ser especialmente útil cuando recuperas HTML de un CMS (e.g. Hashnode o [WordPress](/es/guides/cms/wordpress/)).
-    :::
-</Steps>
-
-### Publicando tu sitio
-Para desplegar tu sitio visita nuestra [guía de despliegue](/es/guides/deploy/) y sigue las instrucciones de tu proveedor de alojamiento preferido.
-
-## Recursos de la Comunidad
-
-- [`astro-hashnode`](https://github.com/matthiesenxyz/astro-hashnode) en GitHub
-
diff --git a/src/content/docs/es/guides/cms/hygraph.mdx b/src/content/docs/es/guides/cms/hygraph.mdx
deleted file mode 100644
index be044830cc12d..0000000000000
--- a/src/content/docs/es/guides/cms/hygraph.mdx
+++ /dev/null
@@ -1,126 +0,0 @@
----
-title: Hygraph y Astro
-description: Agrega contenido a tu proyecto de Astro usando Hygraph como CMS
-type: cms
-service: Hygraph
-i18nReady: true
----
-import { Steps } from '@astrojs/starlight/components';
-import { FileTree } from '@astrojs/starlight/components';
-
-[Hygraph](https://hygraph.com/) es un gestor de contenido federado. Expone un endpoint de GraphQL para obtener contenido.
-
-## Integración con Astro
-
-En esta sección, crearás un [Hygraph](https://hygraph.com/) de GraphQL para obtener contenido con Astro.
-
-### Prerrequisitos
-
-Para empezar, necesitarás lo siguiente:
-
-1. **Una cuenta y un proyecto de Hygraph**. Si no tienes una cuenta, puedes [registrarte gratis](https://app.hygraph.com/signup) y crear un nuevo proyecto.
-
-2. **Permisos de acceso a Hygraph** - En `Project Settings > API Access`, configura los permisos de la API de contenido público para permitir solicitudes de lectura sin autenticación. Si no has configurado ningún permiso, puedes hacer clic en **Yes, initialize defaults** para agregar los permisos necesarios para usar la "API de contenido de alto rendimiento".
-
-### Configurando el endpoint
-
-Para agregar tu endpoint de Hygraph a Astro, crea un archivo `.env` en la raíz de tu proyecto con la siguiente variable:
-
-```ini title=".env"
-HYGRAPH_ENDPOINT=TU_API_DE_ALTO_RENDIMIENTO
-```
-
-Ahora, deberías poder usar esta variable de entorno en tu proyecto.
-
-Si deseas tener IntelliSense para tus variables de entorno, puedes crear un archivo `env.d.ts` en el directorio `src/` y configurar `ImportMetaEnv` de esta manera:
-
-```ts title="src/env.d.ts"
-interface ImportMetaEnv {
-  readonly HYGRAPH_ENDPOINT: string;
-}
-```
-
-:::note
-Lee más sobre [el uso de variables de entorno](/es/guides/environment-variables/) y archivos `.env` en Astro.
-:::
-
-Tu directorio raíz ahora debería incluir estos nuevos archivos:
-
-<FileTree title="Estructura del proyecto">
-- src/
-  - **env.d.ts**
-- **.env**
-- astro.config.mjs
-- package.json
-</FileTree>
-
-### Obteniendo datos
- 
-Obtén los datos de tu proyecto de Hygraph usando `HYGRAPH_ENDPOINT`.
-
-Por ejemplo, para obtener las entradas de un tipo de contenido `blogPosts` que tiene un campo de tipo string `title`, crea una consulta GraphQL para obtener ese contenido. Luego, define el tipo de contenido y configúralo como el tipo de respuesta.
-
-```astro title="src/pages/index.astro"
----
-interface Post {
-	title: string;
-}
-
-const query = {
-	method: "POST",
-	headers: { "Content-Type": "application/json" },
-	body: JSON.stringify({
-		query: `
-      {
-        blogPosts {
-          title
-        }
-      }`,
-	}),
-};
-
-const response = await fetch(import.meta.env.HYGRAPH_ENDPOINT, query);
-const json = await response.json();
-const posts: Post[] = json.data.blogPosts;
----
-
-<html lang="en">
-	<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} />
-		<title>Astro</title>
-	</head>
-	<body>
-		<h1>Astro</h1>
-		{
-			posts.map((post) => (
-				<div>
-					<h2>{post.title}</h2>
-				</div>
-			))
-		}
-	</body>
-</html>
-```
-
-## Despliegue
-
-### Configurando el Webhook de Netlify
-
-Para configurar un webhook en Netlify:
-
-<Steps>
-1. Despliega tu sitio en Netlify con [esta guía](/es/guides/deploy/netlify/). Recuerda agregar tu `HYGRAPH_ENDPOINT` a las variables de entorno.
-
-2. Luego, ve al panel de control de tu proyecto de Hygraph y haz clic en **Apps**.
-
-3. Ve al marketplace y busca Netlify y sigue las instrucciones proporcionadas.
-
-4. Si todo salió bien, ahora puedes desplegar tu sitio web con un clic en la interfaz de Hygraph.
-</Steps>
-
-## Recursos de la comunidad
-
-- [Hygraph + ejemplo de Astro con `marked` para el análisis de Markdown](https://github.com/camunoz2/example-astrowithhygraph)
diff --git a/src/content/docs/es/guides/cms/index.mdx b/src/content/docs/es/guides/cms/index.mdx
deleted file mode 100644
index ee43e6046b41f..0000000000000
--- a/src/content/docs/es/guides/cms/index.mdx
+++ /dev/null
@@ -1,43 +0,0 @@
----
-title: Usa un CMS con Astro
-description: Cómo usar un CMS para agregar contenido a Astro
-i18nReady: true
----
-import CMSGuidesNav from '~/components/CMSGuidesNav.astro';
-import ReadMore from '~/components/ReadMore.astro';
-import Badge from "~/components/Badge.astro"
-
-**¿Listo para conectar un Headless CMS a tu proyecto Astro?** Sigue una de nuestras guías para integrar un CMS.
-
-:::tip
-Encuentra [integraciones mantenidas por la comunidad](https://astro.build/integrations/?search=cms) para conectar un CMS a tu proyecto en nuestro directorio de integraciones. 
-:::
-
-## Guías de CMS
-
-Ten en cuenta que muchas de estas páginas son **talones**: ¡Son colecciones de recursos esperando tu contribución!
-
-<CMSGuidesNav />
-
-## ¿Por qué usar un CMS?
-
-Un sistema de gestión de contenido te permite escribir contenido y administrar activos fuera de tu proyecto Astro.
-
-Esto desbloquea nuevas funciones para trabajar con contenido. La mayoría de los CMS te brindan un editor de contenido visual, la capacidad de especificar tipos de contenido estándar y una forma de colaborar con otros.
-
-Un CMS puede ser útil para el contenido que sigue una estructura particular, a menudo te brinda una experiencia de panel de control y herramientas de edición WYSIWYG (Lo que ves es lo que obtienes). Puedes usar un CMS para escribir publicaciones de blog usando el editor de texto enriquecido de un CMS en lugar de archivos Markdown. O puedes usar un CMS para mantener listados de productos para una tienda en línea, haciendo que ciertos campos sean obligatorios para evitar listados incompletos.
-
-Tu proyecto Astro luego puede obtener el contenido de tu CMS y mostrarlo, donde y como quieras en tu sitio.
-
-
-## ¿Qué CMSes funcionan bien con Astro?
-
-Debido a que Astro se ocupa de la _presentación_ de tu contenido, procura elegir un CMS _headless_, como los de la lista anterior. Esto significa que el CMS te ayuda a escribir tu contenido, pero no genera un sitio que lo muestre. En su lugar, obtiene los datos de tu contenido y los usa en tu proyecto Astro.
-
-Algunos CMSes headless, como Storyblok, proporcionan una [integración](/es/guides/integrations-guide/) de Astro que te ayuda a recuperar el contenido específicamente para un sitio Astro. Otros proporcionan un SDK de JavaScript, una biblioteca que instalas y usas para recuperar tu contenido remoto.
-
-<ReadMore> Explora una [lista de por lo menos 100 sistemas headless de manejo de contenido](https://jamstack.org/headless-cms/)<Badge text="Externo" /> donde puedes filtrar por tipo (por ejemplo basado en Git, manejado por API) y licencia (código abierto o código cerrado).</ReadMore>
-
-## ¿Puedo usar Astro sin un CMS?
-
-¡Sí! Astro proporciona formas integradas para crear contenido, incluyendo el soporte para páginas de Markdown.
diff --git a/src/content/docs/es/guides/cms/keystatic.mdx b/src/content/docs/es/guides/cms/keystatic.mdx
deleted file mode 100644
index 540fd8e3bb6d3..0000000000000
--- a/src/content/docs/es/guides/cms/keystatic.mdx
+++ /dev/null
@@ -1,237 +0,0 @@
----
-title: Keystatic y Astro
-description: Agrega contenido a tu proyecto Astro usando Keystatic como CMS
-type: cms
-service: Keystatic
-i18nReady: true
----
-import { Steps } from '@astrojs/starlight/components';
-import { FileTree } from '@astrojs/starlight/components';
-import PackageManagerTabs from '~/components/tabs/PackageManagerTabs.astro'
-
-[Keystatic](https://keystatic.com/) es un sistema de gestión de contenido de código abierto headless que te permite estructurar tu contenido y sincronizarlo con GitHub.
-
-:::tip
-Si estás comenzando un **nuevo proyecto Astro + Keystatic desde cero**, puedes usar la [CLI de Keystatic](https://keystatic.com/docs/quick-start#keystatic-cli) para generar un nuevo proyecto en segundos:
-
-<PackageManagerTabs>
-  <Fragment slot="npm">
-  ```shell
-  npm create @keystatic@latest
-  ```
-  </Fragment>
-  <Fragment slot="pnpm">
-  ```shell
-  pnpm create @keystatic@latest
-  ```
-  </Fragment>
-  <Fragment slot="yarn">
-  ```shell
-  yarn create @keystatic
-  ```
-  </Fragment>
-</PackageManagerTabs>
-
-¡Selecciona la plantilla de Astro y estarás listo para [desplegar](#despliegue-de-keystatic--astro)!
-:::
-
-## Prerrequisitos
-
-- Un proyecto existente de Astro [con renderizado del lado del servidor (SSR) y `output: 'hybrid'` o `output: 'server'` configurado](/es/guides/on-demand-rendering/).
-
-:::note
-Si tienes la intención de sincronizar los datos de Keystatic con GitHub, también necesitarás **una cuenta de GitHub con permisos de `escritura`** en el repositorio de este proyecto.
-:::
-
-## Instalación de dependencias
-
-Agrega tanto la integración de Markdoc (para las entradas de contenido) como la de React (para el panel de control de la interfaz de usuario de Keystatic) a tu proyecto Astro, usando el comando `astro add` para tu gestor de paquetes.
-
-<PackageManagerTabs>
-  <Fragment slot="npm">
-  ```shell
-  npx astro add react markdoc
-  ```
-  </Fragment>
-  <Fragment slot="pnpm">
-  ```shell
-  pnpm astro add react markdoc
-  ```
-  </Fragment>
-  <Fragment slot="yarn">
-  ```shell
-  yarn astro add react markdoc
-  ```
-  </Fragment>
-</PackageManagerTabs>
-
-También necesitarás dos paquetes de Keystatic:
-
-<PackageManagerTabs>
-  <Fragment slot="npm">
-  ```shell
-  npm install @keystatic/core @keystatic/astro
-  ```
-  </Fragment>
-  <Fragment slot="pnpm">
-  ```shell
-  pnpm add @keystatic/core @keystatic/astro
-  ```
-  </Fragment>
-  <Fragment slot="yarn">
-  ```shell
-  yarn add @keystatic/core @keystatic/astro
-  ```
-  </Fragment>
-</PackageManagerTabs>
-
-## Agregar la integración de Astro
-
-Agrega la integración de Astro desde `@keystatic/astro` en el archivo de configuración de Astro:
-
-```js  ins={6} ins=", keystatic()"
-// astro.config.mjs
-import { defineConfig } from 'astro/config'
-
-import react from '@astrojs/react'
-import markdoc from '@astrojs/markdoc'
-import keystatic from '@keystatic/astro'
-
-// https://astro.build/config
-export default defineConfig({
-  integrations: [react(), markdoc(), keystatic()],
-  output: 'hybrid',
-})
-```
-
-## Crear un archivo de configuración de Keystatic
-
-Un archivo de configuración de Keystatic es necesario para definir el esquema de tu contenido. Este archivo también te permitirá conectar un proyecto a un repositorio específico de GitHub (si decides hacerlo).
-
-Crea un archivo llamado `keystatic.config.ts` en la raíz del proyecto y agrega el siguiente código para definir tanto el tipo de almacenamiento (`local`) como una sola colección de contenido (`posts`):
-
-```ts {8-25}
-// keystatic.config.ts
-import { config, fields, collection } from '@keystatic/core';
-
-export default config({
-  storage: {
-    kind: 'local',
-  },
-
-  collections: {
-    posts: collection({
-      label: 'Posts',
-      slugField: 'title',
-      path: 'src/content/posts/*',
-      format: { contentField: 'content' },
-      schema: {
-        title: fields.slug({ name: { label: 'Title' } }),
-        content: fields.markdoc({
-          label: 'Content',
-        }),
-      },
-    }),
-  },
-});
-```
-
-:::note[¿Ya estás usando colecciones de contenido?]
-Si ya estás usando [colecciones de contenido](/es/guides/content-collections/#definiendo-colecciones) en tu proyecto Astro, actualiza el esquema anterior para que coincida exactamente con la(s) colección(es) definida(s) en tu esquema existente.
-:::
-
-Keystatic está ahora configurado para gestionar tu contenido basado en tu esquema.
-
-## Ejecutar Keystatic localmente
-
-Para iniciar el panel de control de UI de administrador de Keystatic, inicia el servidor dev de Astro:
-
-    ```bash
-    npm run dev
-    ```
-
-Visita `http://127.0.0.1:4321/keystatic` en el navegador para ver la UI de administrador de Keystatic corriendo.
-
-## Crear una nueva entrada
-
-<Steps>
-1. En el panel de control de administrador de Keystatic, haz clic en la colección "Posts".
-
-2. Usa el botón para crear una nueva entrada. Agrega el título "Mi primera entrada" y algo de contenido, luego guarda la entrada.
- 
-3. Este post debería ser visible desde tu colección "Posts". Puedes ver y editar tus posts individuales desde esta página del panel de control.
- 
-4. Regresa para ver tus archivos del proyecto Astro. Ahora encontrarás un nuevo archivo `.mdoc` dentro del directorio `src/content/posts` para esta nueva entrada:
-
-		<FileTree title="Estructura del proyecto">
-		- src/
-		  - content/
-		    - posts/
-		      - **my-first-post.mdoc**
-		</FileTree>
-
-5. Navega a ese archivo en tu editor de código y verifica que puedes ver el contenido Markdown que ingresaste. Por ejemplo:
-
-		```markdown
-		---
-		title: Mi Primera Entrada
-    title: Mi primer artículo
-		---
-		
-    Este es mi primer artículo. ¡Estoy **súper** emocionado!
-		```
-</Steps>
-
-## Renderizar contenido de Keystatic
-
-Usa la API de Colecciones de Contenido de Astro para [consultar y mostrar tus posts y colecciones](/es/guides/content-collections/#consultando-colecciones), tal como lo harías en cualquier proyecto de Astro.
-
-### Mostrar una lista de colecciones
-
-El siguiente ejemplo muestra una lista de cada título de post, con un enlace a una página de post individual.
-
-```tsx {4}
----
-import { getCollection } from 'astro:content'
-
-const posts = await getCollection('posts')
----
-<ul>
-  {posts.map(post => (
-    <li>
-      <a href={`/posts/${post.slug}`}>{post.data.title}</a>
-    </li>
-  ))}
-</ul>
-```
-
-### Mostrar una entrada individual
-
-Para mostrar contenido de una entrada individual, puedes importar y usar el componente `<Content />` para [renderizar tu contenido a HTML](/es/guides/content-collections/#renderizando-contenido-a-html):
-
-```tsx {4-5}
----
-import { getEntry } from 'astro:content'
-
-const post = await getEntry('posts', 'my-first-post')
-const { Content } = await post.render()
----
-
-<main>
-  <h1>{post.data.title}</h1>
-  <Content />
-</main>
-
-```
-
-Para mayor información sobre consultas, filtrado, visualización de tu contenido de colecciones y más, consulta la documentación completa de [colecciones de contenido](/es/guides/content-collections/).
-## Despliegue de Keystatic + Astro
-
-Para desplegar tu sitio web, visita nuestras [guías de despliegue](/es/guides/deploy/) y sigue las instrucciones para tu proveedor de alojamiento preferido.
-
-También probablemente querrás [conectar Keystatic a GitHub](https://keystatic.com/docs/connect-to-github) para que puedas gestionar el contenido en la instancia desplegada del proyecto.
-
-## Recursos oficiales
-
-- Checa [la guía oficial de Keystatic](https://keystatic.com/docs/installation-astro)
-- [La plantilla de inicio de Keystatic](https://github.com/Thinkmill/keystatic/tree/main/templates/astro)
diff --git a/src/content/docs/es/guides/cms/keystonejs.mdx b/src/content/docs/es/guides/cms/keystonejs.mdx
deleted file mode 100644
index 28d60e8248f41..0000000000000
--- a/src/content/docs/es/guides/cms/keystonejs.mdx
+++ /dev/null
@@ -1,10 +0,0 @@
----
-title: KeystoneJS y Astro
-description: Agrega contenido a tu proyecto Astro utilizando KeystoneJS como un CMS
-type: cms
-stub: true
-service: KeystoneJS
-i18nReady: true
----
-
-[KeystoneJS](https://keystonejs.com/) es un sistema de gestión de contenido headless de código abierto que te permite describir la estructura de tu esquema.
\ No newline at end of file
diff --git a/src/content/docs/es/guides/cms/kontent-ai.mdx b/src/content/docs/es/guides/cms/kontent-ai.mdx
deleted file mode 100644
index 660530139d4cd..0000000000000
--- a/src/content/docs/es/guides/cms/kontent-ai.mdx
+++ /dev/null
@@ -1,559 +0,0 @@
----
-title: Kontent.ai y Astro
-description: Agrega contenido a tu proyecto de Astro usando Kontent.ai como CMS
-type: cms
-service: Kontent.ai
-i18nReady: true
----
-import { Steps } from '@astrojs/starlight/components';
-import { FileTree } from '@astrojs/starlight/components';
-import PackageManagerTabs from '~/components/tabs/PackageManagerTabs.astro'
-
-[Kontent.ai](https://www.kontent.ai/) es un CMS headless que te permite administrar el contenido de una manera estructurada y modular, con el apoyo de capacidades de IA.
-
-## Integración con Astro
-
-En esta sección, usarás el [Kit de desarrollo de software (SDK) de Kontent.ai de TypeScript](https://github.com/kontent-ai/delivery-sdk-js) para conectar tu proyecto de Kontent.ai con tu aplicación de Astro.
-
-### Prerrequisitos
-
-Para empezar, necesitarás lo siguiente:
-
-1. **Un proyecto de Kontent.ai** - Si aún no tienes una cuenta de Kontent.ai, [regístrate gratis](https://app.kontent.ai/sign-up) y crea un nuevo proyecto.
-
-2. **Claves de API de entrega** - Necesitarás el ID de entorno para el contenido publicado y la clave de API de vista previa para obtener borradores (opcional). Ambas claves se encuentran en la pestaña **Environment Settings -> API keys** en Kontent.ai.
-
-### Configuración de credenciales
-
-Para agregar tus credenciales de Kontent.ai a Astro, crea un archivo `.env` en la raíz de tu proyecto con las siguientes variables:
-
-```ini title=".env"
-KONTENT_ENVIRONMENT_ID=TU_ID_DE_ENTORNO
-KONTENT_PREVIEW_API_KEY=TU_CLAVE_DE_API_DE_VISTA_PREVIA
-```
-
-Ahora, estas variables de entorno se pueden usar en tu proyecto de Astro.
-
-Si deseas obtener [IntelliSense de TypeScript para estas variables de entorno](/es/guides/environment-variables/#intellisense-para-typescript), puedes crear un nuevo archivo `env.d.ts` en el directorio `src/` y configurar `ImportMetaEnv` de esta manera:
-```ts title="src/env.d.ts"
-interface ImportMetaEnv {
-  readonly KONTENT_ENVIRONMENT_ID: string;
-  readonly KONTENT_PREVIEW_API_KEY: string;
-}
-```
-
-Tu directorio raíz ahora debería incluir estos nuevos archivos:
-
-<FileTree title="Estructura del proyecto">
-- src/
-  - **env.d.ts**
-- **.env**
-- astro.config.mjs
-- package.json
-</FileTree>
-
-
-### Instalación de dependencias
-
-Para conectar Astro con tu proyecto de Kontent.ai, instala el [Kit de desarrollo de software (SDK) de Kontent.ai de TypeScript](https://github.com/kontent-ai/delivery-sdk-js):
-
-<PackageManagerTabs>
-  <Fragment slot="npm">
-  ```shell
-    npm install @kontent-ai/delivery-sdk
-  ```
-  </Fragment>
-  <Fragment slot="pnpm">
-  ```shell
-    pnpm add @kontent-ai/delivery-sdk
-  ```
-  </Fragment>
-  <Fragment slot="yarn">
-  ```shell
-    yarn add @kontent-ai/delivery-sdk
-  ```
-  </Fragment>
-</PackageManagerTabs>
-
-Después, crea un nuevo archivo llamado `kontent.ts` en el directorio `src/lib/` de tu proyecto de Astro.
-
-```ts title="src/lib/kontent.ts"
-import { createDeliveryClient } from "@kontent-ai/delivery-sdk";
-
-export const deliveryClient = createDeliveryClient({
-    environmentId: import.meta.env.KONTENT_ENVIRONMENT_ID,
-    previewApiKey: import.meta.env.KONTENT_PREVIEW_API_KEY,
-});
-```
-
-:::note
-Lee más sobre [cómo obtener variables de entorno en Astro](/es/guides/environment-variables/#obteniendo-variables-de-entorno).
-:::
-
-Esta implementación crea un nuevo objeto `DeliveryClient` usando credenciales del archivo `.env`.
-
-:::note[Previsualizaciones]
-La `previewApiKey` es opcional. Cuando se usa, puedes [configurar cada consulta](https://github.com/kontent-ai/delivery-sdk-js#enable-preview-mode-per-query) al endpoint de la API de entrega para devolver las últimas versiones de los elementos de contenido independientemente de su estado en el flujo de trabajo. De lo contrario, solo se devuelven los elementos publicados.
-:::
-
-Finalmente, el directorio raíz de tu proyecto de Astro ahora debería incluir estos nuevos archivos:
-
-<FileTree title="Estructura del proyecto">
-- src/
-  - lib/
-    - **kontent.ts**
-  - env.d.ts
-- .env
-- astro.config.mjs
-- package.json
-</FileTree>
-
-### Obteniendo datos
-
-El `DeliveryClient` ahora está disponible para todos los componentes. Para obtener contenido, usa el `DeliveryClient` y el encadenamiento de métodos para definir los elementos deseados. Este ejemplo muestra una búsqueda básica de entradas de blog y renderiza sus títulos en una lista:
-
-```astro title="src/pages/index.astro" ins={2-7, 16-20}
----
-import { deliveryClient } from "../lib/kontent";
-
-const blogPosts = await deliveryClient
-    .items()
-    .type("blogPost")
-    .toPromise()
----
-<html lang="en">
-	<head>
-		<meta charset="utf-8" />
-		<meta name="viewport" content="width=device-width" />
-		<title>Astro</title>
-	</head>
-	<body>
-        <ul>
-        {blogPosts.data.items.map(blogPost => (
-            <li>{blogPost.elements.title.value}</li>
-        ))}
-        </ul>
-    </body>
-</html>
-```
-
-Puedes encontrar más opciones de consulta en la [documentación de Kontent.ai](https://kontent.ai/learn/develop/hello-world/get-content/javascript).
-
-## Creando un blog con Astro y Kontent.ai
-
-Con la configuración anterior, ahora puedes crear un blog que use Kontent.ai como fuente de contenido.
-
-### Prerrequisitos
-
-1. **Un proyecto de Kontent.ai** - Para este tutorial, se recomienda usar un proyecto en blanco. Si ya tienes algunos tipos de contenido en tu modelo de contenido, puedes usarlos, pero deberás modificar los fragmentos de código para que coincidan con tu modelo de contenido.
-
-2. **Un proyecto de Astro configurado para obtener contenido de Kontent.ai** - consulta arriba para obtener más detalles sobre cómo configurar un proyecto de Astro con Kontent.ai
-
-### Configurando el modelo de contenido
-
-En Kontent.ai, navega a **Content model** y crea un nuevo tipo de contenido con los siguientes campos y valores:
-
-* **Name:** Blog Post
-* Elements:
-	* Text field
-		* **Name:** Title
-		* **Element Required:** yes
-	* Rich text field
-		* **Name:** Teaser
-		* **Element Required:** yes
-		* **Allowed in this element:** only check Text
-	* Rich text field
-		* **Name:** Content
-		* **Element Required:** yes
-	* Date & time field
-		* **Name:** Date
-	* URL slug field
-		* **Name:** URL slug
-		* **Element Required:** yes
-		* **Auto-generate from:** select "Title"
-
-Luego, haz clic en **Save Changes**.
-
-### Creando contenido
-
-Ahora, navega a la pestaña **Content & assets** y crea un nuevo elemento de contenido de tipo **Blog Post**. Rellena los campos usando estos valores:
-
-* **Content item name:** Astro
-* **Title:** Astro es increíble
-* **Teaser:** Astro es un framework todo en uno para construir sitios web rápidos más rápido.
-* **Content:** Puedes usar JavaScript para implementar la funcionalidad del sitio web, pero no es necesario un paquete de cliente.
-* **Date & time:** selecciona hoy
-* **URL slug:** astro-es-increíble
-
-Cuando hayas terminado, publica la entrada del blog usando el botón **Publish** en la parte superior.
-
-*Nota: Siéntete libre de crear tantos posts de blog como quieras antes de pasar al siguiente paso.* 
-
-### Generando el modelo de contenido en TypeScript
-
-A continuación, generarás tipos de TypeScript a partir de tu modelo de contenido.
-
-:::note
-Este paso es opcional pero proporciona una experiencia de desarrollador mucho mejor y te permite descubrir posibles problemas en tiempo de compilación en lugar de en tiempo de ejecución.
-:::
-
-Primero, instala el [generador de modelos de Kontent.ai JS](https://github.com/kontent-ai/model-generator-js), [ts-node](https://github.com/TypeStrong/ts-node), y [dotenv](https://github.com/motdotla/dotenv):
-
-<PackageManagerTabs>
-  <Fragment slot="npm">
-  ```shell
-    npm install @kontent-ai/model-generator ts-node dotenv
-  ```
-  </Fragment>
-  <Fragment slot="pnpm">
-  ```shell
-    pnpm add @kontent-ai/model-generator ts-node dotenv
-  ```
-  </Fragment>
-  <Fragment slot="yarn">
-  ```shell
-    yarn add @kontent-ai/model-generator ts-node dotenv
-  ```
-  </Fragment>
-</PackageManagerTabs>
-
-Luego, agrega el siguiente script al package.json:
-
-```json title="package.json"
-{
-    ...
-    "scripts": {
-        ...
-        "regenerate:models": "ts-node --esm ./generate-models.ts"
-    },
-}
-```
-
-Porque los tipos requieren información estructural sobre tu proyecto que no está disponible en la API pública, también debes agregar una clave de API de administración al archivo `.env`. Puedes generar la clave en **Environment settings -> API keys -> Management API**.
-
-
-```ini title=".env" ins={3}
-KONTENT_ENVIRONMENT_ID=TU_ID_DE_ENTORNO
-KONTENT_PREVIEW_API_KEY=TU_CLAVE_DE_API_DE_VISTA_PREVIA
-KONTENT_MANAGEMENT_API_KEY=TU_CLAVE_DE_ADMINISTRACIÓN_DE_API
-```
-
-Finalmente, agrega el script `generate-models.ts` que configura el generador de modelos para generar los modelos:
-
-```ts title="generate-models.ts"
-import { generateModelsAsync, textHelper } from '@kontent-ai/model-generator'
-import { rmSync, mkdirSync } from 'fs'
-
-import * as dotenv from 'dotenv'
-dotenv.config()
-
-const runAsync = async () => {
-	rmSync('./src/models', { force: true, recursive: true })
-	mkdirSync('./src/models')
-
-  // cambia el directorio de trabajo a models
-	process.chdir('./src/models')
-
-	await generateModelsAsync({
-		sdkType: 'delivery',
-		apiKey: process.env.KONTENT_MANAGEMENT_API_KEY ?? '',
-		environmentId: process.env.KONTENT_ENVIRONMENT_ID ?? '',
-		addTimestamp: false,
-		isEnterpriseSubscription: false,
-	})
-}
-
-// auto invocación de función asíncrona
-;(async () => {
-	await runAsync()
-})().catch(err => {
-	console.error(err)
-	throw err
-})
-```
-
-Ahora, ejecútalo:
-
-<PackageManagerTabs>
-  <Fragment slot="npm">
-  ```shell
-    npm run regenerate:models
-  ```
-  </Fragment>
-  <Fragment slot="pnpm">
-  ```shell
-    pnpm run regenerate:models
-  ```
-  </Fragment>
-  <Fragment slot="yarn">
-  ```shell
-    yarn run regenerate:models
-  ```
-  </Fragment>
-</PackageManagerTabs>
-
-### Mostrando una lista de entradas de blog
-
-Ahora estás listo para obtener contenido. Ve a la página de Astro donde deseas mostrar una lista de todas las entradas de blog, por ejemplo, la página de inicio `index.astro` en `src/pages`.
-
-Obtén todas las entradas de blog en el frontmatter de la página de Astro:
-
-```astro title="src/pages/index.astro"
----
-import { deliveryClient } from '../lib/kontent';
-import type { BlogPost } from '../models';
-import { contentTypes } from '../models/project/contentTypes';
-
-const blogPosts = await deliveryClient
-    .items<BlogPost>
-    .type(contentTypes.blog_post.codename)
-    .toPromise()
----
-```
-
-Si omitiste la generación del modelo, también puedes usar un objeto sin tipo y un literal de cadena para definir el tipo:
-
-```ts
-const blogPosts = await deliveryClient
-    .items()
-    .type("blogPost")
-    .toPromise()
-```
-
-La llamada de recuperación devolverá un objeto `response` que contiene una lista de todas las entradas de blog en `data.items`. En la sección HTML de la página de Astro, puedes usar la función `map()` para enumerar las entradas de blog:
-
-```astro title="src/pages/index.astro" ins={11-29}
----
-import { deliveryClient } from '../lib/kontent';
-import type { BlogPost } from '../models';
-import { contentTypes } from '../models/project/contentTypes';
-
-const blogPosts = await deliveryClient
-    .items<BlogPost>
-    .type(contentTypes.blogPost.codename)
-    .toPromise()
----
-<html lang="en">
-    <head>
-        <meta charset="utf-8" />
-        <meta name="viewport" content="width=device-width" />
-        <title>Astro</title>
-    </head>
-    <body>
-        <h1>Artículos de Blog</h1>
-        <ul>
-            {blogPosts.data.items.map(blogPost => (
-                <li>
-                    <a href={`/blog/${blogPost.elements.url_slug.value}/`} title={blogPost.elements.title.value}>
-                        {blogPost.elements.title.value}
-                    </a>
-                </li>
-            ))}
-        </ul>
-    </body>
-</html>
-```
-
-### Generando entradas de blog individuales
-
-El último paso del tutorial es generar páginas detalladas de entradas de blog.
-
-#### Generación de sitios estáticos
-
-En esta sección, usarás el [modo estático (SSG)](/es/guides/routing/#modo-estático-ssg) con Astro.
-
-Primero, crea un archivo `[slug].astro` en `/src/pages/blog/` que necesita exportar una función `getStaticPaths` que recopila todos los datos del CMS:
-
-```astro title="src/pages/blog/[slug].astro"
----
-import { deliveryClient } from '../../lib/kontent';
-import type { BlogPost } from '../../models';
-import { contentTypes } from '../../models/project/contentTypes';
-
-export async function getStaticPaths() {
-    const blogPosts = await deliveryClient
-        .items<BlogPost>()
-        .type(contentTypes.blog_post.codename)
-        .toPromise()
----
-```
-
-Hasta ahora, la función obtiene todas las entradas de blog de Kontent.ai. El fragmento de código es exactamente el mismo que el que usaste en la página de inicio.
-
-A continuación, la función debe exportar rutas y datos para cada entrada de blog. Nombraste el archivo `[slug].astro`, por lo que el parámetro que representa el slug de URL se llama `slug`:
-
-```astro title="src/pages/blog/[slug].astro" ins={12-15}
----
-import { deliveryClient } from '../../lib/kontent';
-import type { BlogPost } from '../../models';
-import { contentTypes } from '../../models/project/contentTypes';
-
-export async function getStaticPaths() {
-    const blogPosts = await deliveryClient
-        .items<BlogPost>()
-        .type(contentTypes.blog_post.codename)
-        .toPromise()
-
-    return blogPosts.data.items.map(blogPost => ({
-        params: { slug: blogPost.elements.url_slug.value },
-        props: { blogPost }
-    }))
-}
----
-```
-
-La última parte es proporcionar la plantilla HTML y mostrar cada entrada de blog:
-
-```astro title="src/pages/blog/[slug].astro" ins={18-33}
----
-import { deliveryClient } from '../../lib/kontent';
-import type { BlogPost } from '../../models';
-import { contentTypes } from '../../models/project/contentTypes';
-
-export async function getStaticPaths() {
-    const blogPosts = await deliveryClient
-        .items<BlogPost>()
-        .type(contentTypes.blog_post.codename)
-        .toPromise()
-
-    return blogPosts.data.items.map(blogPost => ({
-        params: { slug: blogPost.elements.url_slug.value },
-        props: { blogPost }
-    }))
-}
-
-const blogPost: BlogPost = Astro.props.blogPost
----
-<html lang="en">
-    <head>
-        <meta charset="utf-8" />
-        <meta name="viewport" content="width=device-width" />
-        <title>{blogPost.elements.title.value}</title>
-    </head>
-    <body>
-        <article>
-            <h1>{blogPost.elements.title.value}</h1>
-            <Fragment set:html={blogPost.elements.teaser.value} />
-            <Fragment set:html={blogPost.elements.content.value} />
-            <time>{new Date(blogPost.elements.date.value ?? "")}</time>
-    </body>
-</html>
-```
-
-Navega a tu vista previa de Astro (http://localhost:4321/blog/astro-is-amazing/ de forma predeterminada) para ver la entrada de blog renderizada.
-
-#### Renderizado del lado del servidor
-
-Si has optado por el modo SSR, usarás rutas dinámicas para obtener los datos de la página de Kontent.ai.
-
-Crea un nuevo archivo `[slug].astro` en `/src/pages/blog/` y agrega el siguiente código. La recuperación de datos es muy similar a los casos de uso anteriores, pero agrega un `equalsFilter` que nos permite encontrar la entrada de blog correcta en función de la URL utilizada:
-
-```astro title="src/pages/blog/[slug].astro"
----
-import { deliveryClient } from '../../lib/kontent';
-import type { BlogPost } from '../../models';
-import { contentTypes } from '../../models/project/contentTypes';
-
-const { slug } = Astro.params
-let blogPost: BlogPost;
-try {
-    const data = await deliveryClient
-        .items<BlogPost>()
-        .equalsFilter(contentTypes.blog_post.elements.url_slug.codename, slug ?? '')
-        .type(contentTypes.blog_post.codename)
-        .limitParameter(1)
-        .toPromise()
-    blogPost = data.data.items[0]
-} catch (error) {
-    return Astro.redirect('/404')
-}
----
-```
-
-Si no estás usando tipos generados, puedes usar literales de string para definir el tipo de elemento de contenido y el codename del elemento filtrado:
-
-```ts
-const data = await deliveryClient
-        .items()
-        .equalsFilter("url_slug", slug ?? '')
-        .type("blog_post")
-        .limitParameter(1)
-        .toPromise()
-```
-
-Por último, agrega el código HTML para renderizar la entrada de blog. Esta parte es la misma que con la generación estática:
-
-```astro title="src/pages/blog/[slug].astro" ins={20-33}
----
-import { deliveryClient } from '../../lib/kontent';
-import type { BlogPost } from '../../models';
-import { contentTypes } from '../../models/project/contentTypes';
-
-const { slug } = Astro.params
-let blogPost: BlogPost;
-try {
-    const data = await deliveryClient
-        .items<BlogPost>()
-        .equalsFilter(contentTypes.blog_post.elements.url_slug.codename, slug ?? '')
-        .type(contentTypes.blog_post.codename)
-        .limitParameter(1)
-        .toPromise()
-    blogPost = data.data.items[0]
-} catch (error) {
-    return Astro.redirect('/404')
-}
----
-<html lang="en">
-    <head>
-        <meta charset="utf-8" />
-        <meta name="viewport" content="width=device-width" />
-        <title>{blogPost.elements.title.value}</title>
-    </head>
-    <body>
-        <article>
-            <h1>{blogPost.elements.title.value}</h1>
-            <Fragment set:html={blogPost.elements.teaser.value} />
-            <Fragment set:html={blogPost.elements.content.value} />
-            <time>{new Date(blogPost.elements.date.value ?? '')}</time>
-    </body>
-</html>
-```
-
-### Publicando tu sitio
-
-Para desplegar tu sitio web, visita las [guías de despliegue](/es/guides/deploy/) y sigue las instrucciones para tu proveedor de alojamiento preferido.
-
-#### Recompila cuando cambie Kontent.ai
-
-Si tu proyecto está usando el modo estático predeterminado de Astro, deberás configurar un webhook para iniciar una nueva compilación cuando cambie tu contenido. Si estás usando Netlify o Vercel como proveedor de alojamiento, puedes usar su función de webhook para iniciar una nueva compilación a partir de eventos de Kontent.ai.
-
-##### Netlify
-
-Para configurar un webhook en Netlify:
-
-<Steps>
-1. Ve al panel de control de tu sitio y haz clic en **Build & deploy**.
-
-2. En la pestaña **Continuous Deployment**, encuentra la sección **Build hooks** y haz clic en **Add build hook**.
-
-3. Proporciona un nombre para tu webhook y selecciona la rama en la que deseas iniciar la compilación. Haz clic en **Save** y copia la URL generada.
-</Steps>
-
-##### Vercel
-
-Para configurar un webhook en Vercel:
-
-<Steps>
-1. Ve al panel de control de tu proyecto y haz clic en **Settings**.
-
-2. En la pestaña **Git**, encuentra la sección **Deploy Hooks**.
-
-3. Proporciona un nombre para tu webhook y la rama en la que deseas iniciar la compilación. Haz clic en **Add** y copia la URL generada.
-</Steps>
-
-#### Agregando un webhook a Kontent.ai
-
-En la aplicación [Kontent.ai](https://kontent.ai/learn/docs/webhooks/javascript), ve a **Environment settings -> Webhooks**. Haz clic en **Create new webhook** y proporciona un nombre para tu nuevo webhook. Pega la URL que copiaste de Netlify o Vercel y selecciona qué eventos deben activar el webhook. De forma predeterminada, para reconstruir tu sitio cuando cambie el contenido publicado, solo necesitas los eventos **Publish** y **Unpublish** en **Delivery API triggers**. Cuando hayas terminado, haz clic en Save.
-
-Ahora, cada vez que publiques una nueva entrada de blog en Kontent.ai, se iniciará una nueva compilación y se actualizará tu blog.
-
diff --git a/src/content/docs/es/guides/cms/microcms.mdx b/src/content/docs/es/guides/cms/microcms.mdx
deleted file mode 100644
index a39c842f02947..0000000000000
--- a/src/content/docs/es/guides/cms/microcms.mdx
+++ /dev/null
@@ -1,15 +0,0 @@
----
-title: microCMS y Astro
-description: Añade contenido a tu proyecto Astro usando microCMS
-type: cms
-stub: true
-service: microCMS
-i18nReady: true
----
-
-[microCMS](https://microcms.io/) es un headless CMS basado en API que te permite definir contenido usando esquemas, y manejarlo usando el dashboard.
-
-## Recursos Oficiales
-
-- Echa un vistazo al [documento oficial de microCMS](https://document.microcms.io/tutorial/astro/astro-top)
-- Blog: [Construye un blog con microCMS](https://blog.microcms.io/astro-microcms-introduction/)
diff --git a/src/content/docs/es/guides/cms/payload.mdx b/src/content/docs/es/guides/cms/payload.mdx
deleted file mode 100644
index 583724d4de658..0000000000000
--- a/src/content/docs/es/guides/cms/payload.mdx
+++ /dev/null
@@ -1,222 +0,0 @@
----
-title: Payload CMS y Astro
-description: Agrega contenido a tu proyecto de Astro utilizando Payload como CMS
-type: cms
-stub: true
-service: Payload CMS
-i18nReady: true
----
-import { Steps } from '@astrojs/starlight/components';
-
-[PayloadCMS](https://payloadcms.com/) es un sistema de gestión de contenido headless de código abierto que se puede utilizar para proporcionar contenido para tu proyecto Astro.
-
-## Integración con Astro
-
-### Prerequisitos
-
-1. **Un proyecto de Astro** - Si aún no tienes un proyecto de Astro, nuestra [guía de instalación](/es/install-and-setup/) te pondrá en marcha en poco tiempo.
-2. **Una base de datos de MongoDB** - PayloadCMS te pedirá una cadena de conexión de MongoDB al crear un nuevo proyecto. Puede configurar uno localmente o usar [MongoDBAtlas](https://www.mongodb.com/) para alojar una base de datos en la web de forma gratuita.
-3. **Una API REST de PayloadCMS** - Crea un proyecto de [PayloadCMS](https://payloadcms.com/docs/getting-started/installation) y conéctalo a tu base de datos MongoDB durante la configuración.
-
-:::note[Escogiendo una plantilla]
-Durante la instalación de PayloadCMS, se te preguntará si deseas utilizar una plantilla.
-
-Escoger cualquiera de las plantillas disponibles en este paso (como 'blog') genera automáticamente colecciones adicionales para que las utilices. De lo contrario, deberás crear manualmente tus colecciones de PayloadCMS.
-:::
-
-### Configurando Astro para tu colección de PayloadCMS
-
-Tu proyecto de plantilla Payload contendrá un archivo llamado Posts.ts en `src/collections/`. Si no escogiste una plantilla durante la instalación que creara una colección de contenido para ti, puedes crear una nueva colección de PayloadCMS agregando este archivo de configuración manualmente. El siguiente ejemplo muestra este archivo para una colección llamada `posts` que requiere los campos `title`, `content` y `slug`:
-
-
-```ts title="src/collections/Posts.ts"
-import { CollectionConfig } from "payload/types";
-
-const Posts: CollectionConfig = {
-  slug: "posts",
-  admin: {
-    useAsTitle: "title",
-  },
-  access: {
-    read: () => true,
-  },
-
-  fields: [
-    {
-      name: "title",
-      type: "text",
-      required: true,
-    },
-    {
-      name: "content",
-      type: "text",
-      required: true,
-    },
-    {
-      name: "slug",
-      type: "text",
-      required: true,
-    },
-  ],
-};
-
-export default Posts;
-```
-
-<Steps>
-1. Importa y agrega tanto `Users` (disponible en todos los proyectos de PayloadCMS) como cualquier otra colección (por ejemplo, `Posts`) a las colecciones disponibles en el archivo `payload.config.ts`.
-
-    ```astro title="src/payload.config.ts" ins={4, 5, 12}
-    import { buildConfig } from "payload/config";
-    import path from "path";
-    import Users from "./collections/Users";
-    import Posts from "./collections/Posts";
-    export default buildConfig({
-      serverURL: "http://localhost:4321",
-      admin: {
-        user: Users.slug,
-      },
-      collections: [Users, Posts],
-      typescript: {
-        outputFile: path.resolve(__dirname, "payload-types.ts"),
-      },
-      graphQL: {
-        schemaOutputFile: path.resolve(__dirname, "generated-schema.graphql"),
-      },
-    });
-    ```
-
-    Esto hará que aparezca una nueva colección llamada "Posts" en tu panel de control de PayloadCMS junto a la colección "Users".
-
-2. Ingresa a la colección "Posts" y crea una nueva publicación. Después de guardarla, notarás que la URL de la API aparece en la esquina inferior derecha.
-
-3. Con el servidor de desarrollo en ejecución, abre `http://localhost:4321/api/posts` en tu navegador. Deberías ver un archivo JSON que contiene la publicación que has creado como un objeto.
-
-    ```json
-    {
-      "docs":[
-          {
-            "id":"64098b16483b0f06a7e20ed4",
-            "title":"Astro & PayloadCMS Title 🚀",
-            "content":"Astro & PayloadCMS Content",
-            "slug":"astro-payloadcms-slug",
-            "createdAt":"2023-03-09T07:30:30.837Z",
-            "updatedAt":"2023-03-09T07:30:30.837Z"
-          }
-      ],
-      "totalDocs":1,
-      "limit":10,
-      "totalPages":1,
-      "page":1,
-      "pagingCounter":1,
-      "hasPrevPage":false,
-      "hasNextPage":false,
-      "prevPage":null,
-      "nextPage":null
-    }
-    ```
-</Steps>
-
-:::tip
-Por defecto, tanto Astro como PayloadCMS utilizarán el puerto 4321. Es posible que desees cambiar el puerto de PayloadCMS en el archivo `src/server.ts`. No olvides actualizar el `serverURL` en `src/payload.config.ts` también.
-:::
-
-### Obteniendo los datos
-
-Obtén los datos de PayloadCMS a través de la URL única de la API REST de tu sitio y la ruta de tu contenido. (Por defecto, PayloadCMS montará todas las rutas a través de `/api`.) Luego, puedes renderizar las propiedades de tus datos utilizando la directiva `set:html=""` de Astro.
-
-Juntos con tu publicación, PayloadCMS devolverá algunos metadatos de nivel superior. Los documentos reales están anidados dentro del arreglo `docs`.
-
-Por ejemplo, para mostrar una lista de títulos de publicaciones y su contenido:
-
-```astro title="src/pages/index.astro"
----
-import HomeLayout from "../layouts/HomeLayout.astro";
-
-const res = await fetch("http://localhost:5000/api/posts") // http://localhost:4321/api/posts by default
-const posts = await res.json()
----
-
-<HomeLayout title='Astro Blog'>
-	{
-    posts.docs.map((post) => (
-        <h2 set:html={post.title} />
-        <p set:html={post.content} />
-    ))
-	}
-</HomeLayout>
-```
-
-## Construyendo un blog con PayloadCMS y Astro
-
-Crea una página índice de blog `src/pages/index.astro` para listar cada una de tus publicaciones con un enlace a su propia página.
-
-La búsqueda a través de la API devuelve un arreglo de objetos (publicaciones) que incluyen, entre otros, las siguientes propiedades:
-
-- `title`
-- `content`
-- `slug`
-
-```astro title="src/pages/index.astro"
----
-import HomeLayout from "../layouts/HomeLayout.astro";
-
-const res = await fetch("http://localhost:5000/api/posts") // http://localhost:4321/api/posts by default
-const posts = await res.json()
----
-
-<HomeLayout title='Astro Blog'>
-	<h1>Astro + PayloadCMS 🚀</h1>
-	<h2>Blog posts list:</h2>
-	<ul>
-		{
-			posts.docs.map((post) =>(
-				<li>
-					<a href={`posts/${post.slug}`} set:html={post.title} />
-				</li>
-			))
-		}
-	</ul>
-</HomeLayout>
-```
-
-### Usando la API de PayloadCMS para generar páginas
-
-Crea una página `src/pages/posts/[slug].astro` para [generar dinámicamente una página](/es/guides/routing/#rutas-dinámicas) para cada publicación.
-
-```astro title="src/pages/posts/[slug].astro"
----
-import PostLayout from "../../layouts/PostLayout.astro"
-
-const {title, content} = Astro.props
-
-// La función getStaticPaths() es necesaria para sitios estáticos de Astro.
-// Si estás usando SSR, no necesitarás esta función.
-export async function getStaticPaths() {
-    let data = await fetch("http://localhost:5000/api/posts")
-    let posts = await data.json()
-
-    return posts.docs.map((post) => {
-        return {
-            params: {slug: post.slug},
-            props: {title: post.title, content: post.content},
-        };
-    });
-} 
----
-<PostLayout title={title}>
-    <article>
-        <h1 set:html={title} />
-        <p set:html={content} />
-    </article>
-</PostLayout>
-```
-
-### Publicando tu sitio
-
-Para desplegar tu sitio visita nuestra [guía de despliegue](/es/guides/deploy/) y sigue las instrucciones para tu proveedor de alojamiento preferido.
-
-## Recursos de la comunidad
-
-- Prueba esta [Plantilla de Payload CMS y Astro](https://github.com/Lambdo-Labs/payloadcms-astro-template).
-- Echa un vistazo a [Astroad](https://github.com/mooxl/astroad) para un fácil desarrollo y despliegue en VPS con Docker.
diff --git a/src/content/docs/es/guides/cms/preprcms.mdx b/src/content/docs/es/guides/cms/preprcms.mdx
deleted file mode 100644
index f686d56e06a58..0000000000000
--- a/src/content/docs/es/guides/cms/preprcms.mdx
+++ /dev/null
@@ -1,240 +0,0 @@
----
-title: Prepr CMS y Astro
-description: Añade contenido a tu proyecto de Astro utilizando Prepr como CMS
-type: cms
-service: Prepr CMS
-stub: true
-i18nReady: true
----
-import { Steps } from '@astrojs/starlight/components';
-import { FileTree } from '@astrojs/starlight/components';
-import PackageManagerTabs from '~/components/tabs/PackageManagerTabs.astro'
-
-[Prepr CMD](https://www.prepr.io/) es un CMS headless con personalización integrada.
-
-## Integración con Astro
-
-Prepr CMS proporciona una [API GraphQL](https://docs.prepr.io/reference/graphql/v1/overview) para conectar tus datos a Astro.
-
-### Prerrequisitos
-
-Para empezar, necesitarás lo siguiente:
-
-- Un proyecto de Astro nuevo o existente configurado para [renderizado bajo demanda](/es/guides/on-demand-rendering/).
-- [Una cuenta Prepr gratis](https://signup.prepr.io/)
-- [Un entorno Prepr con publicaciones de blog existentes](https://docs.prepr.io/account/set-up-environments#create-an-envirntonment). Estas publicaciones deben incluir un `title` y `content`. Los otros campos son opcionales.
-
-### Configuración de credenciales
-
-Para agregar el endpoint de Prepr a tu proyecto de Astro, crea un archivo `.env` en la raíz de tu proyecto si no existe y agrega la siguiente variable:
-
-```ini title=".env"
-PREPR_ENDPOINT=YOUR_PREPR_API_URL
-```
-
-Encontrarás tu valor `YOUR_PREPR_API_URL` en la configuración de tu cuenta Prepr:
-
-<Steps>
-1. Ve a  **Settings > Access tokens** para ver tus tokens de acceso de vista previa y producción.
-
-2. Usa el valor **API URL** del token de acceso **GraphQL Production** para solo recuperar elementos de contenido publicados para tu sitio de Astro.
-</Steps>
-
-### Configuración del endpoint de Prepr
-
-Crea una nueva carpeta `src/lib/` y agrega un nuevo archivo llamado `prepr.js`. Aquí es donde configurarás el endpoint de Prepr. Agrega el siguiente código para obtener tus datos de Prepr CMS:
-
-```js title="src/lib/prepr.js"
-
-export async function Prepr(query, variables) {
-    const response = await fetch(import.meta.env.PREPR_ENDPOINT, {
-        method: 'POST',
-        headers: {
-            'Content-Type': 'application/json'
-        },
-        body: JSON.stringify({ query, variables }),
-    })
-    return response
-}
-```
-
-Tu directorio raíz ahora debería incluir estos archivos:
-
-<FileTree title="Estructura del Proyecto">
-- lib/
-    - **prepr.js**
-- src/
-- **.env**
-- astro.config.mjs
-- package.json
-
-</FileTree>
-
-### Obtención de datos
-
-Obtendrás tus datos de Prepr escribiendo consultas para interactuar con su API GraphQL.
-
-#### Crea una consulta GraphQL para recuperar tus artículos de blog:
-
-<Steps>
-1. Crea una nueva carpeta `src/queries/` y agrega un archivo llamado `get-articles.js`.
-
-2. Agrega la siguiente consulta a este archivo para recuperar todos los artículos:
-
-    ```js title="src/queries/get-articles.js"
-
-    const GetArticles = `
-    query {
-        Articles {
-          items {
-            _id
-            _slug
-            title
-        }
-      }
-    }
-    `
-    export default GetArticles
-    ```
-
-3. Para mostrar una lista enlazada de tus publicaciones de blog en una página, importa y ejecuta tu consulta, incluyendo el endpoint de Prepr. Luego tendrás acceso a todos los títulos de tus publicaciones y sus slugs para renderizar en la página. (En el siguiente paso, [crearás páginas individuales para tus publicaciones de blog](#creación-de-páginas-individuales-para-publicaciones-de-blog).)
-
-    ```astro title="src/pages/index.astro" ins={3-4, 6-8, 15-23}
-    ---
-    import Layout from '../layouts/Layout.astro';
-    import { Prepr } from '../lib/prepr.js';
-    import GetArticles from '../queries/get-articles.js';
-
-    const response = await Prepr(GetArticles)
-    const { data } = await response.json()
-    const articles = data.Articles
-    ---
-
-    <Layout title="Mi sitio blog">
-      <h1>
-        Mi sitio blog
-      </h1>
-      <ul>
-        {
-          articles.items.map((post) => (
-            <li>
-              <a href={post._slug}>{post.title}</a>
-            </li>
-          ))
-        }
-      </ul>
-    </Layout>
-    ```
-</Steps>
-
-Tu directorio raíz ahora debería incluir estos archivos:
-
-<FileTree title="Estructura del Proyecto">
-- lib/
-    - prepr.js
-    - **queries**/
-        - **get-articles.js**
-- src/
-- .env
-- astro.config.mjs
-- package.json
-</FileTree>
-
-#### Creación de páginas individuales para publicaciones de blog
-
-Para crear una página por cada publicación de blog, ejecutarás una nueva consulta GraphQL en una página `.astro` de [enrutamiento dinámico](/es/guides/routing/#modo-servidor-ssr). Esta consulta obtendrá un artículo específico por su slug y se creará una nueva página para cada publicación de blog individual.
-
-<Steps>
-1. Crea un archivo llamado `get-article-by-slug.js` en la carpeta `queries` y agrega lo siguiente para consultar un artículo específico por su slug y devolver datos como el `title` y `content` del artículo:
-
-    ```js title="src/lib/queries/get-article-by-slug.js"
-
-    const GetArticleBySlug = `
-    query ($slug: String) {
-       Article (slug: $slug) {
-         _id
-         title
-         content {
-           __typename
-           ... on Text {
-             body
-             text
-           }
-           ... on Assets {
-             items {
-               url
-             }
-           }
-         }
-       }
-    }`
-
-    export default GetArticleBySlug
-    ```
-
-    :::tip
-    Puedes crear y [probar consultas GraphQL](https://docs.prepr.io/reference/graphql/v1/test-queries) utilizando el [Apollo explorer](https://studio.apollographql.com/sandbox/explorer) en Prepr. Abre el API Explorer desde la página de elementos de contenido *Article* en Prepr.
-    El contenido del artículo se almacena en un *campo de contenido dinámico*. Consulta la documentación de GraphQL para obtener más detalles sobre [cómo obtener los datos dentro de este campo](https://docs.prepr.io/reference/graphql/v1/schema-field-types-dynamic-content-field).
-    :::
-
-2. Dentro de la carpeta `src/pages`, crea un archivo llamado `[…slug].astro`. Agrega el siguiente código para importar y ejecutar la consulta del paso anterior y mostrar el artículo recuperado:
-
-    ```astro title="src/pages/[...slug].astro"
-    ---
-    import Layout from '../layouts/Layout.astro';
-    import {Prepr} from '../lib/prepr.js';
-    import GetArticleBySlug from '../queries/get-article-by-slug.js';
-    const { slug } = Astro.params;
-    const response = await Prepr(GetArticleBySlug, {slug})
-    const { data } = await response.json()
-    const article = data.Article
-    ---
-    <Layout title={article.title}>
-      <main>
-        <h1>{article.title}</h1>
-        {
-          article.content.map((content) => (
-            <div>
-              {
-                content.__typename === "Assets" &&
-                <img src={content.items[0].url} width="300" height="250"/>
-              }
-              {
-                content.__typename === 'Text' &&
-                <div set:html={content.body}></div>
-              }
-            </div>
-          ))
-        }
-      </main>
-    </Layout>
-    ```
-</Steps>
-
-La carpeta raíz de tu proyecto ahora debería incluir estos archivos:
-
-<FileTree title="Estructura del Proyecto">
-- lib/
-    - prepr.js
-    - queries/
-        - get-articles.js
-        - **get-article-by-slug.js**
-- src/
-    - pages/
-      - index.astro
-      - **[…slug].astro**
-- .env
-- astro.config.mjs
-- package.json
-</FileTree>
-
-Ahora, cuando hagas clic en un enlace de artículo desde la lista principal de publicaciones de blog, se te llevará a una página con su contenido individual.
-
-### Publicar tu sitio
-
-Para desplegar tu blog de Prepr, visita nuestras [guías de despliegue](/es/guides/deploy/) y sigue las instrucciones para tu proveedor de alojamiento preferido.
-
-## Recursos oficiales
-
-- Sigue la [guía de inicio rápido de Prepr CMS Astro](https://github.com/preprio/astro-quick-start) para hacer un blog simple con Astro y Prepr CMS.
-- Consulta la guía [Conectar Prepr CMS a Astro](https://docs.prepr.io/connecting-front-end-apps/astro) para obtener una descripción general de los recursos de Astro y Prepr CMS.
diff --git a/src/content/docs/es/guides/cms/prismic.mdx b/src/content/docs/es/guides/cms/prismic.mdx
deleted file mode 100644
index 1c8e71232a77f..0000000000000
--- a/src/content/docs/es/guides/cms/prismic.mdx
+++ /dev/null
@@ -1,14 +0,0 @@
----
-title: Prismic y Astro
-description: Agrega contenido a tu proyecto de Astro utilizando Prismic como CMS
-type: cms
-stub: true
-service: Prismic
-i18nReady: true
----
-
-[Prismic](https://prismic.io/) es un sistema de gestión de contenido headless.
-
-## Recursos de la comunidad
-
-- [Construyendo con Astro y Prismic - con Nate Moore](https://www.youtube.com/watch?v=qFUfuDSLdxM) (transmisión en vivo) y el [repositorio del programa](https://github.com/natemoo-re/miles-of-code).
\ No newline at end of file
diff --git a/src/content/docs/es/guides/cms/sanity.mdx b/src/content/docs/es/guides/cms/sanity.mdx
deleted file mode 100644
index 7b8894796856f..0000000000000
--- a/src/content/docs/es/guides/cms/sanity.mdx
+++ /dev/null
@@ -1,27 +0,0 @@
----
-title: Sanity y Astro
-description: Agrega contenido a tu proyecto de Astro utilizando Sanity como CMS
-type: cms
-stub: true
-service: Sanity
-i18nReady: true
----
-
-import Grid from '~/components/FluidGrid.astro'
-import Card from '~/components/ShowcaseCard.astro'
-
-[Sanity](http://sanity.io) es un sistema de gestión de contenido headless que se centra en el [contenido estructurado](https://www.sanity.io/structured-content-platform).
-
-## Recursos oficiales
-
-- [Integración oficial de Sanity para Astro](https://www.sanity.io/plugins/sanity-astro)
-
-- [Crea tu blog con Astro y Sanity](https://www.sanity.io/guides/sanity-astro-blog)
-
-- [Una página minimalista con Astro y Sanity Studio](https://www.sanity.io/templates/astro-sanity-clean)
-
-## Temas
-
-<Grid>
-  <Card title="The Balanced Chef" href="https://astro.build/themes/details/the-balanced-chef/" thumbnail="astro-chef-project.png"/>
-</Grid>
diff --git a/src/content/docs/es/guides/cms/sitecore.mdx b/src/content/docs/es/guides/cms/sitecore.mdx
deleted file mode 100644
index 9c0dd9c98ee03..0000000000000
--- a/src/content/docs/es/guides/cms/sitecore.mdx
+++ /dev/null
@@ -1,31 +0,0 @@
----
-title: Sitecore Experience Manager y Astro
-description: Agrega contenido a tu proyecto utilizando Sitecore como tu CMS.
-type: cms
-stub: true
-service: Sitecore XM
-i18nReady: true
----
-import { Steps } from '@astrojs/starlight/components';
-
-[Sitecore Experience Manager (XM)](https://www.sitecore.com/products/experience-manager) es un sistema de gestión de contenidos de nivel empresarial construido sobre ASP.NET.
-
-## Cómo empezar
-
-<Steps>
-1. [Crea un sitio web Sitecore Headless](https://doc.sitecore.com/xp/en/developers/sxa/103/sitecore-experience-accelerator/create-a-headless-tenant-and-site.html) siguiendo la documentación oficial de Sitcore.
-
-2. Ejecuta el siguiente comando de inicialización del proyecto en tu terminal:
-   
-   ```shell
-   npx @astro-sitecore-jss/create-astro-sitecore-jss@latest
-   ```
-   
-3. Sigue las instrucciones en la terminal para crear tu proyecto.
-</Steps>
-
-## Recursos de la comunidad
-
-- [Kit de desarrollo de software JavaScript de Sitecore para Astro](https://github.com/exdst/jss-astro-public) en GitHub
-- [Introducción a Sitecore con Astro](https://exdst.com/posts/20231002-sitecore-astro)
-- [Comenzando tu primer proyecto de Astro con Sitecore](https://exdst.com/posts/20240103-first-sitecore-astro-project)
diff --git a/src/content/docs/es/guides/cms/spinal.mdx b/src/content/docs/es/guides/cms/spinal.mdx
deleted file mode 100644
index 2c28d70769531..0000000000000
--- a/src/content/docs/es/guides/cms/spinal.mdx
+++ /dev/null
@@ -1,29 +0,0 @@
----
-title: Spinal y Astro
-description: Agrega contenido a tu proyecto utilizando Spinal como tu CMS.
-type: cms
-stub: true
-service: Spinal
-i18nReady: true
----
-import { Steps } from '@astrojs/starlight/components';
-
-[Spinal](https://spinalcms.com/cms-for-astro/) es un CMS comercial basado en Git, enfocado en SaaS.
-
-## Comenzando
-
-<Steps>
-1. [Crea una cuenta en Spinal](https://spinalcms.com/signup/).
-2. Conecta tu cuenta de GitHub a Spinal.
-3. Selecciona tu repositorio de Astro cuando se te solicite.
-</Steps>
-
-Todo el contenido de Markdown de la carpeta seleccionada será importado a tu cuenta de Spinal y estará listo para ser editado.
-
-## Recursos oficiales
-- [Tema de documentación construido para Astro con Tailwind CSS](https://spinalcms.com/resources/astro-documentation-theme-with-tailwind-css/)
-## Sitios de producción
-
-Los siguientes sitios utilizan Astro + Spinal en producción:
-
-- [spinalcms.com](https://spinalcms.com/) (todos los artículos del blog, documentación, registro de cambios, páginas de características, etc.)
\ No newline at end of file
diff --git a/src/content/docs/es/guides/cms/statamic.mdx b/src/content/docs/es/guides/cms/statamic.mdx
deleted file mode 100644
index f5dd87ae8a1bc..0000000000000
--- a/src/content/docs/es/guides/cms/statamic.mdx
+++ /dev/null
@@ -1,123 +0,0 @@
----
-title: Headless Statamic y Astro
-description: Agrega contenido a tu proyecto de Astro usando Statamic como CMS
-type: cms
-stub: false
-service: Statamic
-i18nReady: true
----
-import Grid from '~/components/FluidGrid.astro'
-import Card from '~/components/ShowcaseCard.astro'
-
-[Statamic](https://statamic.com/) es un CMS moderno que utiliza archivos planos. Permite a los desarrolladores crear fácilmente sitios web y aplicaciones dinámicas, mientras que ofrece a los editores de contenido una interfaz intuitiva y fácil de usar para administrar el contenido.
-
-## Integración con Astro
-
-Statamic viene con una [API REST](https://statamic.dev/rest-api) y una [API GraphQL](https://statamic.dev/graphql) integradas para conectar tus datos a Astro.
-
-### Prerrequisitos
-
-Para empezar, necesitarás lo siguiente:
-
-1. Solo están disponibles las API REST y GraphQL API en la versión pro de Statamic. Puedes probar la versión Pro gratis en tu [máquina local](https://statamic.dev/tips/how-to-enable-statamic-pro#trial-mode).
-2. **Un proyecto Astro** - Si todavía necesitas un proyecto Astro, nuestra [guía de instalación](/es/install-and-setup/) te pondrá en marcha rápidamente.
-3. **Un sitio Statamic** - Si necesitas un sitio Statamic, [la guía de instalación de Statamic](https://statamic.dev/quick-start-guide) te ayudará a empezar.
-Recuerda [habilitar la API REST](https://statamic.dev/rest-api#enable-the-api) o la [API GraphQL](https://statamic.dev/graphql#enable-graphql) añadiendo `STATAMIC_API_ENABLED=true` o `STATAMIC_GRAPHQL_ENABLED=true` en el archivo `.env` y habilitando los recursos necesarios en el archivo de configuración de la API.
-
-:::caution
-Todos los ejemplos asumen que tu sitio web tiene una colección llamada `posts`, que tiene un blueprint llamado `post`, y este blueprint tiene un campo de título (tipo de campo texto) y contenido (tipo de campo markdown).
-:::
-
-### Obteniendo Datos
-:::caution
-Si estás usando Statamic y Astro en tu máquina local, recuerda usar `127.0.0.1` en lugar de `localhost` al solicitar los datos a la API.
-
-Cuando se solicita los datos desde el frontmatter de Astro, `localhost` no se resuelve correctamente como lo hace en el navegador y cualquier solicitud a cualquiera de las API fallará.
-:::
-
-#### REST API
-
-Obtén los datos de Statamic de la URL de la API REST de tu sitio. Por defecto, es `https://[YOUR-SITE]/api/`. A continuación, puedes renderizar las propiedades de tus datos utilizando la directiva `set:html={}` de Astro. 
-
-Por ejemplo, para mostrar una lista de títulos y su contenido de una [colección](https://statamic.dev/collections) seleccionada:
-
-```astro title="src/pages/index.astro
----
-const res = await fetch("https://[YOUR-SITE]/api/collections/posts/entries?sort=-date")
-const posts = await res.json()
----
-<h1>Astro + Statamic 🚀</h1>
-{
-  posts.map((post) => (
-      <h2 set:html={post.title} />
-      <p set:html={post.content} />
-  ))
-}
-```
-
-#### GraphQL
-
-Obtén los datos de Statamic de la URL de la API GraphQL de tu sitio. Por defecto, es `https://[YOUR-SITE]/graphql/`. A continuación, puedes renderizar las propiedades de tus datos utilizando la directiva `set:html={}` de Astro.
-
-Por ejemlo, para mostrar una lista de títulos y su contenido de una [colección](https://statamic.dev/collections) seleccionada:
-
-```astro title="src/pages/index.astro
----
-const graphqlQuery = {
-  query: `
-    query Entries($page: Int, $locale: String) {
-      entries(
-        collection: "posts"
-        sort: "date asc"
-        limit: 20
-        page: $page
-        filter: { locale: $locale }
-      ) {
-        current_page
-        has_more_pages
-        data {
-          title
-          ... on Entry_Posts_Post {
-              content
-            }
-      }
-    }
-  `,
-  variables: {
-    page: page,
-    locale: locale,
-  },
-};
-
-const res = await fetch("https://[YOUR-SITE]/graphql", {
-  method: "POST",
-  headers: { "Content-Type": "application/json" },
-  body: JSON.stringify(graphqlQuery),
-})
-
-const { data } = await res.json();
-const entries = data?.entries;
----
-<h1>Astro + Statamic 🚀</h1>
-{
-  entires.data.map((post) => (
-      <h2 set:html={post.title} />
-      <p set:html={post.content} />
-  ))
-}
-```
-
-### Publicando tu sitio
-
-Para desplegar tu sitio Astro, visita nuestras [guías de despliegue](/es/guides/deploy/) y sigue las instrucciones para tu proveedor de alojamiento preferido.
-
-## Recursos de la comunidad
-
-- [Como construir un sitio estático usando Statamic como CMS headless](https://buddy.works/guides/statamic-rest-api)
-- [Implementando previsualizaciones en vivo en Statamic headless usando Astro](https://maciekpalmowski.dev/implementing-live-previews-in-headless-statamic-when-using-astro/)
-
-## Temas
-
-<Grid>
-  <Card title="Creek" href="https://astro.build/themes/details/creek/" thumbnail="creek.png"/>
-</Grid>
diff --git a/src/content/docs/es/guides/cms/storyblok.mdx b/src/content/docs/es/guides/cms/storyblok.mdx
deleted file mode 100644
index 60919da291da1..0000000000000
--- a/src/content/docs/es/guides/cms/storyblok.mdx
+++ /dev/null
@@ -1,549 +0,0 @@
----
-title: Storyblok y Astro
-description: Agrega contenido a tu proyecto de Astro usando Storyblok como CMS
-type: cms
-service: Storyblok
-stub: false
-i18nReady: true
----
-import { FileTree } from '@astrojs/starlight/components';
-import PackageManagerTabs from '~/components/tabs/PackageManagerTabs.astro'
-import { Steps } from '@astrojs/starlight/components';
-
-
-[Storyblok](https://www.storyblok.com/) es un headless CMS basado en componentes que te permite gestionar tu contenido utilizando componentes reutilizables llamados Bloks.
-
-## Integración con Astro
-
-En esta sección, utilizarás la [integración de Storyblok](https://github.com/storyblok/storyblok-astro) para conectar Storyblok con Astro.
-
-### Prerrequisitos
-
-Para comenzar, necesitarás lo siguiente:
-
-1. **Un proyecto de Astro** - Si aún no tienes un proyecto de Astro, nuestra [guía de instalación](/es/install-and-setup/) te ayudará a poner en marcha en poco tiempo.
-
-2. **Una cuenta y espacio de Storyblok** - Si aún no tienes una cuenta, [regístrate gratis](https://app.storyblok.com/#/signup) y crea un nuevo espacio.
-
-3. **Token de vista previa de Storyblok** - Este token se utilizará para obtener borradores y versiones publicadas de tu contenido. Puedes encontrar y generar tu token de API en la pestaña "Access Tokens" de la configuración de tu espacio de Storyblok.
-
-### Configuración de credenciales
-
-Para agregar las credenciales de tu sitio a Astro, crea un archivo `.env` en la raíz de tu proyecto con la siguiente variable:
-
-```ini title=".env"
-STORYBLOK_TOKEN=TU_PREVIEW_TOKEN
-```
-
-Ahora, deberías poder usar esta variable de entorno en tu proyecto.
-
-Tu directorio raíz debería incluir este nuevo archivo ahora:
-
-<FileTree title="Estructura del proyecto">
-- src/
-- **.env**
-- astro.config.mjs
-- package.json
-</FileTree>
-
-### Instalación de dependencias
-
-
-
-Para conectar Astro con tu espacio de Storyblok, instala la [integración oficial de Storyblok](https://github.com/storyblok/storyblok-astro) utilizando el siguiente comando según tu gestor de paquetes preferido:
-
-<PackageManagerTabs>
-  <Fragment slot="npm">
-  ```shell
-  npm install @storyblok/astro vite
-  ```
-  </Fragment>
-  <Fragment slot="pnpm">
-  ```shell
-  pnpm add @storyblok/astro vite
-  ```
-  </Fragment>
-  <Fragment slot="yarn">
-  ```shell
-  yarn add @storyblok/astro vite
-  ```
-  </Fragment>
-</PackageManagerTabs>
-
-### Configurando Storyblok
-
-Modifica tu archivo de configuración de Astro para incluir la integración de Storyblok de la siguiente manera:
-
-```js title="astro.config.mjs"
-import { defineConfig } from 'astro/config';
-import storyblok from '@storyblok/astro';
-import { loadEnv } from 'vite';
-
-const env = loadEnv("", process.cwd(), 'STORYBLOK');
-
-export default defineConfig({
-  integrations: [
-    storyblok({
-      accessToken: env.STORYBLOK_TOKEN,
-      components: {
-        // Añade tus componentes aquí
-      },
-      apiOptions: {
-        // Elige la región de tu espacio de Storyblok.
-        region: 'us', // opcional,  o 'eu' (por defecto)
-      },
-    })
-  ],
-});
-```
-
-La integración de Storyblok requiere un objeto con las siguientes propiedades:
-
-1. `accessToken` - Esto hace referencia al token de la API de Storyblok que agregaste en el paso anterior.
-
-    :::tip
-    Dado que el archivo de configuración de Astro normalmente no admite variables de entorno, utiliza la función `loadEnv` de Vite para cargarlas.
-    :::
-
-2. `components` - Un objeto que mapea los nombres de los componentes de Storyblok a las rutas de tus componentes locales. Esto es necesario para renderizar tus Bloks de Storyblok en Astro.
-
-    :::note
-    Las rutas de los componentes son relativas al directorio `src`. Por ejemplo, si tu componente se encuentra en `src/storyblok/MyComponent.astro`,la ruta sería `storyblok/MyComponent` (sin la extensión `.astro`).
-    :::
-
-3. `apiOptions` - Un objeto conteniendo las [opciones de la API de Storyblok](https://github.com/storyblok/storyblok-astro#options). 
-
-    :::caution
-    Por defecto, la región es `eu`. Si tu espacio de Storyblok fue creado en la región de US, necesitarás establecer la región como `us`.
-    :::
-
-### Conectando Bloks a los componentes de Astro
-
-Para conectar tus Bloks a Astro, crea una nueva carpeta llamada `storyblok` dentro del directorio `src`. Esta carpeta contendrá todos los componentes de Astro que coincidirán con tus Bloks en tu biblioteca de Bloks de Storyblok.
-
-En este ejemplo, tienes un tipo de contenido de Blok llamado `blogPost` en tu biblioteca de Storyblok con los siguientes campos:
-
-- `title` - Un campo de texto
-- `description` - Un campo de texto
-- `content` - Un campo de texto enriquecido
-
-Nuestro objetivo es crear el equivalente del componente de Astro que utilizará estos campos para renderizar su contenido. Para hacer esto, crea un nuevo archivo llamado `BlogPost.astro` dentro de `src/storyblok` con el siguiente contenido:
-
-```astro title="src/storyblok/BlogPost.astro"
----
-import { storyblokEditable, renderRichText } from '@storyblok/astro'
-
-const { blok } = Astro.props
-const content = renderRichText(blok.content)
----
-
-<article {...storyblokEditable(blok)}>
-  <h1>{blok.title}</h1>
-  <p>{blok.description}</p>
-  <Fragment set:html={content} />
-</article>
-```
-
-La propiedad `blok` contiene los datos que recibirás de Storyblok. También contiene los campos que se definieron en el Blok de tipo de contenido `blogPost` en Storyblok.
-
-Para renderizar nuestro contenido, la integración proporciona funciones de utilidad como:
-
-- `storyblokEditable` - Agrega los atributos necesarios a los elementos para que puedas editarlos en Storyblok.
-- `renderRichText` - transforma el campo de texto enriquecido en HTML.
-
-Tu directorio raíz debería incluir este nuevo archivo:
-
-<FileTree title="Estructura del proyecto">
-- src/
-  - storyblok/
-    - **BlogPost.astro**
-- .env
-- astro.config.mjs
-- package.json
-</FileTree>
-
-Finalmente, para conectar el Blok `blogPost` al componente `BlogPost`, agrega una nueva propiedad a tu objeto `components` en el archivo de configuración de Astro.
-
-- La clave es el nombre del Blok en Storyblok. En este caso, es `blogPost`.
-- El valor es la ruta al componente. En este caso, es `storyblok/BlogPost`.
-
-:::caution
-  La `key` debe coincidir exactamente con el nombre del Blok en Storyblok para que se referencie correctamente. Si no coinciden, o estás intentando referenciar un componente que no existe en Storyblok, obtendrás un error.
-:::
-
-```js title="astro.config.mjs" ins={12}
-import { defineConfig } from 'astro/config';
-import storyblok from '@storyblok/astro';
-import { loadEnv } from 'vite';
-
-const env = loadEnv("", process.cwd(), 'STORYBLOK');
-
-export default defineConfig({
-  integrations: [
-    storyblok({
-      accessToken: env.STORYBLOK_TOKEN,
-      components: {
-        blogPost: 'storyblok/BlogPost',
-      },
-      apiOptions: { 
-        region: 'us',
-      },
-    })
-  ],
-});
-```
-
-### Obteniendo Datos
-
-Para probar la configuración, en Storyblok crea una nueva historia con el tipo de contenido `blogPost` llamada `test-post`.
-En Astro, crea una nueva página en el directorio `src/pages/` llamada `test-post.astro` con el siguiente contenido:
-
-```astro title="src/pages/test-post.astro"
----
-import { useStoryblokApi } from '@storyblok/astro'
-import StoryblokComponent from '@storyblok/astro/StoryblokComponent.astro'
-
-const storyblokApi = useStoryblokApi()
-
-const { data } = await storyblokApi.get("cdn/stories/test-post", {
-  version: import.meta.env.DEV ? "draft" : "published",
-});
-
-const content = data.story.content;
----
-<StoryblokComponent blok={content} />
-```
-
-Para consultar tus datos, utiliza el gancho `useStoryblokApi`. Esto inicializará una nueva instancia del cliente utilizando la configuración de integración que has establecido.
-
-Para renderizar tu contenido, pasa la propiedad `content` del Story al componente `StoryblokComponent` como una prop `blok`. Este componente renderizará los Bloks que están definidos dentro de la propiedad `content` property. En este caso, renderizará el componente `BlogPost`.
-
-## Creando un blog con Astro y Storyblok
-
-Con la configuración de integración establecida, ahora puedes crear un blog con Astro y Storyblok.
-
-### Prerrequisitos
-
-1. **Un espacio de Storyblok** - Para este tutorial, recomendamos utilizar un espacio nuevo. Si ya tienes un espacio con bloques (Bloks), siéntete libre de utilizarlos, pero deberás modificar el código para que coincida con los nombres de los bloques y los tipos de contenido.
-
-2. **Un proyecto de Astro integrado con Storyblok** - Consulta [la sección de integración con Astro](#integración-con-astro) para obtener instrucciones sobre cómo configurar la integración.
-
-### Creando una biblioteca blok
-
-Para crear bloques, ve a la aplicación de Storyblok y haz clic en la pestaña de **Block Library**. Haz clic en el botón <kbd>+ New blok</kbd> y crea los siguientes bloques:
-
-1. `blogPost` - Un tipo de contenido Blok con los siguientes campos:
-    - `title` - Un campo de texto
-    - `description` - Un campo de texto
-    - `content` - Un campo de texto enriquecido
-
-2. `blogPostList` - Un Blok anidado vacío
-
-3. `page` - Un tipo de contenido Blok con los siguientes campos:
-    - `body` - Un Blok anidado
-
-### Creando contenido
-
-Para agregar nuevo contenido, ve a la sección de contenido haciendo clic en la pestaña de **Content**. Utilizando la biblioteca de Bloks que creaste en el paso anterior, crea las siguientes historias:
-
-1. `home` - Un story de tipo de contenido con el Blok `page`. Dentro del campo `body`, agrega un Blok `blogPostList`.
-
-2. `blog/no-javascript` - Un story con el tipo de contenido `blogPost` dentro de la carpeta del blog.
-    ```yaml
-    title: No JavaScript
-    description: A sample blog post
-    content: Hi there! This blog post doesn't use JavaScript.
-    ```
-3. `blog/astro-is-amazing` - Un story con el tipo de contenido `blogPost` dentro de la carpeta del blog.
-    ```yaml
-    title: Astro is amazing
-    description: We love Astro
-    content: Hi there! This blog post was build with Astro.
-    ```
-
-Ahora que tienes tu contenido listo, regresa a tu proyecto de Astro y comienza a construir tu blog.
-
-### Conectando Bloks a componentes
-
-Para conectar los Bloks recién creados a los componentes de Astro, crea una nueva carpeta llamada `storyblok` en tu directorio `src` y agrega los siguientes archivos:
-
-`Page.astro` es un componente de tipo de contenido de Blok anidado que renderizará de forma recursiva todos los Bloks dentro de la propiedad `body` del Blok `page`. También agrega los atributos `storyblokEditable` al elemento padre, lo que nos permitirá editar la página en Storyblok.
-
-```astro title="src/storyblok/Page.astro"
----
-import { storyblokEditable } from '@storyblok/astro'
-import StoryblokComponent from "@storyblok/astro/StoryblokComponent.astro";
-const { blok } = Astro.props
----
-
-<main {...storyblokEditable(blok)}>
-  {
-    blok.body?.map((blok) => {
-      return <StoryblokComponent blok={blok} />
-    })
-  }
-</main>
-```
-
-`BlogPost.astro` renderizará las propiedades `title`, `description` y `content` del Blok `blogPost`.
-
-Para transformar la propiedad `content` de un campo de texto enriquecido a HTML, puedes utilizar la función auxiliar `renderRichText`.
-
-```astro title="src/storyblok/BlogPost.astro"
----
-import { storyblokEditable, renderRichText } from '@storyblok/astro'
-const { blok } = Astro.props
-const content = renderRichText(blok.content)
----
-<article {...storyblokEditable(blok)}>
-  <h1>{blok.title}</h1>
-  <p>{blok.description}</p>
-  <Fragment set:html={content} />
-</article>
-```
-
-`BlogPostList.astro` es un componente de tipo de contenido de Blok anidado que renderizará una lista de vistas previas de publicaciones de blog.
-
-Utiliza el hook `useStoryblokApi` para obtener todas los stories con el tipo de contenido `blogPost`. Utiliza el parámetro de consulta `version` para obtener las versiones en borrador de las historias cuando se encuentra en modo de desarrollo y las versiones publicadas al compilar para producción.
-
-`Astro.props` se utiliza para configurar el editor en Storyblok. Aquí también se pueden pasar propiedades adicionales a tu componente, si es necesario.
-```astro title="src/storyblok/BlogPostList.astro"
----
-import { storyblokEditable } from '@storyblok/astro'
-import { useStoryblokApi } from '@storyblok/astro'
-
-const storyblokApi = useStoryblokApi();
-
-const { data } = await storyblokApi.get('cdn/stories', {
-  version: import.meta.env.DEV ? "draft" : "published",
-  content_type: 'blogPost',
-})
-
-const posts = data.stories.map(story => {
-  return {
-    title: story.content.title,
-    date: new Date(story.published_at).toLocaleDateString("en-US", {dateStyle: "full"}),
-    description: story.content.description,
-    slug: story.full_slug,
-  }
-})
-
-const { blok } = Astro.props
----
-
-<ul {...storyblokEditable(blok)}>
-  {posts.map(post => (
-    <li>
-      <time>{post.date}</time>
-      <a href={post.slug}>{post.title}</a>
-      <p>{post.description}</p>
-    </li>
-  ))}
-</ul>
-```
-
-Finalmente, agrega tus componentes a la propiedad `components` del objeto de configuración `storyblok` en `astro.config.mjs`. La clave es el nombre del Blok en Storyblok y el valor es la ruta al componente relativa a `src`.
-
-```js title="astro.config.mjs" ins={12-14}
-import { defineConfig } from 'astro/config';
-import storyblok from '@storyblok/astro';
-import { loadEnv } from 'vite';
-
-const env = loadEnv("", process.cwd(), 'STORYBLOK');
-
-export default defineConfig({
-  integrations: [
-    storyblok({
-      accessToken: env.STORYBLOK_TOKEN,
-      components: {
-        blogPost: 'storyblok/BlogPost',
-        blogPostList: 'storyblok/BlogPostList',
-        page: 'storyblok/Page',
-      },
-      apiOptions: { 
-        region: 'us',
-      },
-    })
-  ],
-});
-```
-
-### Generando páginas
-
-Para crear una ruta para una `página` especifica, puedes obtener su contenido directamente desde la API de Storyblok y pasarlo al componente `StoryblokComponent`. Asegúrate de haber agregado el componente `Page` a tu archivo astro.config.mjs.
-
-Crea un archivo `index.astro` dentro de `src/pages/` para renderizar la página `home`:
-
-```astro title="src/pages/index.astro" {3,7,8,9,17} 
----
-import { useStoryblokApi } from '@storyblok/astro'
-import StoryblokComponent from '@storyblok/astro/StoryblokComponent.astro'
-import BaseLayout from '../layouts/BaseLayout.astro'
-
-const storyblokApi = useStoryblokApi();
-const { data } = await storyblokApi.get('cdn/stories/home', {
-  version: import.meta.env.DEV ? "draft" : "published",
-});
-const content = data.story.content;
----
-<html lang="en">
-  <head>
-    <title>Storyblok & Astro</title>
-  </head>
-  <body>
-    <StoryblokComponent blok={content} />
-  </body>
-</html>
-```
-
-Para generar páginas para todas tus publicaciones de blog, crea una página `.astro` que creará rutas dinámicas. Este enfoque varía dependiendo de si estás utilizando la **generación de sitios estáticos** (la opción predeterminada) o **el renderizado en el lado del servidor**.
-
-#### Generación de sitio estático
-
-If you are using Astro's default static site generation, you will use [dynamic routes](/es/guides/routing/#rutas-dinámicas) and the `getStaticPaths` function to generate your project pages.
-
-Crea un nuevo directorio `src/pages/blog/` y agrega un nuevo archivo llamado `[...slug].astro` con el siguiente código:
-
-```astro title="src/pages/blog/[...slug].astro"
----
-import { useStoryblokApi } from '@storyblok/astro'
-import StoryblokComponent from '@storyblok/astro/StoryblokComponent.astro'
-
-export async function getStaticPaths() {
-  const sbApi = useStoryblokApi();
-
-  const { data } = await sbApi.get("cdn/stories", {
-    content_type: "blogPost",
-    version: import.meta.env.DEV ? "draft" : "published",
-  });
-
-  const stories = Object.values(data.stories);
-
-  return stories.map((story) => {
-    return {
-      params: { slug: story.slug },
-    };
-  });
-}
-
-const sbApi = useStoryblokApi();
-const { slug } = Astro.params;
-const { data } = await sbApi.get(`cdn/stories/${slug}`, {
-  version: import.meta.env.DEV ? "draft" : "published",
-});
-
-const story = data.story;
----
-
-<html lang="en">
-  <head>
-    <title>Storyblok & Astro</title>
-  </head>
-  <body>
-    <StoryblokComponent blok={story.content} />
-  </body>
-</html>
-```
-
-Este archivo generará una página para cada historia, con el slug y contenido obtenidos de la API de Storyblok.
-
-:::note
-Cuando agregues carpetas dentro de Storyblok, inclúyelas en el slug al interactuar con la API de Storyblok. Por ejemplo, en la solicitud GET anterior, podemos usar **cdn/stories/blog**, con una carpeta blog adentro en lugar de usarlas en la raíz.
-:::
-
-#### Renderizado en el lado del servidor
-
-Si has [optado por el modo de SSR](/es/guides/on-demand-rendering/), utilizarás rutas dinámicas para obtener los datos de la página desde Storyblok.
-
-Crea un nuevo directorio `src/pages/blog/` y agrega un nuevo archivo llamado `[...slug].astro` con el siguiente código:
-
-```astro title="src/pages/blog/[...slug].astro"
----
-import { useStoryblokApi } from '@storyblok/astro'
-import StoryblokComponent from '@storyblok/astro/StoryblokComponent.astro'
-const storyblokApi = useStoryblokApi()
-const slug = Astro.params.slug;
-let content;
-try {
-  const { data } = await storyblokApi.get(`cdn/stories/${slug}`, {
-    version: import.meta.env.DEV ? "draft" : "published",
-  });
-  content = data.story.content
-} catch (error) {
-  return Astro.redirect('/404')
-}
----
-<html lang="es">
-  <head>
-    <title>Storyblok y Astro</title>
-  </head>
-  <body>
-    <StoryblokComponent blok={content} />
-  </body>
-</html>
-```
-
-Este archivo obtendrá y renderizará los datos de la página desde Storyblok que coincidan con el parámetro dinámico `slug`.
-
-Dado que estás utilizando una redirección a `/404`, crea una página de error 404 en `src/pages`: 
-
-```astro title="src/pages/404.astro"
-<html lang="es">
-  <head>
-    <title>No encontrado</title>
-  </head>
-  <body>
-    <p>Lo siento, esta página no existe</p>
-  </body>
-</html>
-```
-
-Si no se encuentra la story, la solicitud se redirigirá a la página 404.
-
-### Publicando tu sitio
-
-Para implementar tu sitio web, visita nuestras [guías de despliegue](/es/guides/deploy/) y sigue las instrucciones para tu proveedor de alojamiento preferido.
-
-#### Volver a compilar según los cambios en Storyblok
-
-Si tu proyecto utiliza el modo estático predeterminado de Astro, deberás configurar un webhook para desencadenar una nueva compilación cuando cambie tu contenido. Si estás utilizando Netlify o Vercel como proveedor de alojamiento, puedes utilizar su función de webhook para desencadenar una nueva compilación a partir de los eventos de Storyblok.
-
-##### Netlify
-
-Para configurar un webhook en Netlify:
-
-<Steps>
-1. Ve al panel de administración de tu sitio en Netlify y haz clic en**Build & deploy**. 
-
-2. Bajo la pestaña **Continuous Deployment**, encuentra la sección de **Build hooks** y haz clic en **Add build hook**. 
-
-3. Proporciona un nombre para tu webhook y selecciona la rama en la que deseas activar la compilación. Haz clic en **Save** y copia la URL generada.
-</Steps>
-
-##### Vercel
-
-Para configurar un webhook en Vercel:
-
-<Steps>
-1. Ve al panel de control de tu proyecto y haz clic en **Settings**. 
-
-2. Bajo la pestaña **Git**, encuentra la sección **Deploy Hooks**. 
-
-3. Proporciona un nombre para tu webhook y la rama en la que deseas activar la compilación. Haz clic en **Add** y copia la URL generada.
-</Steps>
-
-##### Añadiendo un webhook a Storyblok
-
-En la sección **Settings** de tu espacio de Storyblok, haz clic en la pestaña **Webhooks**. Pega la URL del webhook que copiaste en el campo **Story published & unpublished** y haz clic en <kbd>Save</kbd> para crear el webhook.
-
-Ahora, cada vez que publiques una nueva historia, se desencadenará una nueva compilación y tu blog se actualizará.
-
-## Recursos Oficiales
-
-- Storyblok ofrece una [integración de Astro](https://www.storyblok.com/mp/announcing-storyblok-astro) para agregar Storyblok a tu proyecto.
-
-## Oficiales de la comunidad 
-
-- [Conseguir que el Editor Visual funcione para Storyblok + Astro](https://dev.to/sandrarodgers/getting-the-visual-editor-to-work-for-storyblok-astro-2gja) por Sandra Rodgers
-- [Astro + Storyblok: previsualización SSR para una edición visual instantánea](https://dev.to/jgierer12/astro-storyblok-ssr-preview-for-instant-visual-editing-3g9m) por Jonas Gierer
-- [Astro-Storyblok previsualiza un sitio con la función Branch Deploys de Netlify](https://dev.to/sandrarodgers/astro-storyblok-previews-site-with-netlifys-branch-deploys-feature-44dh) por Sandra Rodgers
diff --git a/src/content/docs/es/guides/cms/strapi.mdx b/src/content/docs/es/guides/cms/strapi.mdx
deleted file mode 100644
index d781f9499f415..0000000000000
--- a/src/content/docs/es/guides/cms/strapi.mdx
+++ /dev/null
@@ -1,433 +0,0 @@
----
-title: Strapi y Astro
-description: Agrega contenido a tu proyecto de Astro utilizando el headless CMS de Strapi.
-type: cms
-service: Strapi
-stub: false
-i18nReady: true
----
-import { Steps } from '@astrojs/starlight/components';
-import { FileTree } from '@astrojs/starlight/components';
-import PackageManagerTabs from '~/components/tabs/PackageManagerTabs.astro';
-
-[Strapi](https://strapi.io/) es un headless CMS de código abierto y personalizable.
-
-## Integración con Astro
-
-Esta guía creará una función wrapper para conectar Strapi con Astro.
-
-### Prerrequisitos
-
-Para comenzar, necesitarás tener lo siguiente:
-
-1. **Un proyecto de Astro** - Si aún no tienes un proyecto de Astro, nuestra [guía de instalación](/es/install-and-setup/) te ayudará a poner en marcha en poco tiempo.
-2. **Un servidor de Strapi CMS** - Puedes [configurar un servidor de Strapi en un entorno local](https://docs.strapi.io/dev-docs/quick-start).
-
-### Agregando la URL de Strapi en el archivo `.env`.
-
-Para agregar la URL de Strapi a Astro, crea un archivo `.env` en la raíz de tu proyecto (si aún no existe) y agrega la siguiente variable:
-
-```ini title=".env"
-STRAPI_URL="http://127.0.0.1:1337" # o usa tu dirección IP
-```
-
-Reinicia el servidor de desarrollo para utilizar esta variable de entorno en tu proyecto Astro.
-
-Si deseas tener IntelliSense para tu variable de entorno, puedes crear un archivo `env.d.ts` en el directorio `src/` y configurar `ImportMetaEnv` de la siguiente manera:
-
-```ts title="src/env.d.ts"
-interface ImportMetaEnv {
-  readonly STRAPI_URL: string;
-}
-```
-
-Ahora tu directorio raíz debería incluir el/los nuevos archivo(s):
-
-<FileTree title="Estructura del proyecto">
-  - src/
-    - **env.d.ts**
-  - **.env**
-  - astro.config.mjs
-  - package.json
-</FileTree>
-
-### Creando el wrapper de la API
-
-Crea un nuevo archivo en `src/lib/strapi.ts` y agrega la siguiente función envolvente para interactuar con la API de Strapi:
-
-```ts title="src/lib/strapi.ts"
-interface Props {
-  endpoint: string;
-  query?: Record<string, string>;
-  wrappedByKey?: string;
-  wrappedByList?: boolean;
-}
-
-/**
- * Obtiene datos de la API de Strapi.
- * @param endpoint - El endpoint para realizar la consulta
- * @param query - Los parámetros de consulta para agregar a la URL
- * @param wrappedByKey - La clave para desempaquetar la respuesta
- * @param wrappedByList - Si la respuesta es una lista, desempaquétala.
- * @returns
- */
-export default async function fetchApi<T>({
-  endpoint,
-  query,
-  wrappedByKey,
-  wrappedByList,
-}: Props): Promise<T> {
-  if (endpoint.startsWith('/')) {
-    endpoint = endpoint.slice(1);
-  }
-
-  const url = new URL(`${import.meta.env.STRAPI_URL}/api/${endpoint}`);
-
-  if (query) {
-    Object.entries(query).forEach(([key, value]) => {
-      url.searchParams.append(key, value);
-    });
-  }
-  const res = await fetch(url.toString());
-  let data = await res.json();
-
-  if (wrappedByKey) {
-    data = data[wrappedByKey];
-  }
-
-  if (wrappedByList) {
-    data = data[0];
-  }
-
-  return data as T;
-}
-```
-
-Esta función requiere un objeto con las siguientes propiedades:
-
-1. `endpoint` - El endpoint desde el cual estás obteniendo datos.
-2. `query` - Los parámetros de consulta para agregar al final de la URL.
-3. `wrappedByKey` - La clave `data` en el objeto que envuelve tu `Response`.
-4. `wrappedByList` - Un parámetro para "desempaquetar" la lista devuelta por Strapi y devolver solo el primer elemento.
-
-### Opcional: Creando la interfaz Article
-
-Si estás utilizando TypeScript, crea la siguiente interfaz Article en el archivo `src/interfaces/article.ts` para que coincida con los tipos de contenido de Strapi:
-
-```ts title="src/interfaces/article.ts"
-export default interface Article {
-  id: number;
-  attributes: {
-    title: string;
-    description: string;
-    content: string;
-    slug: string;
-    createdAt: string;
-    updatedAt: string;
-    publishedAt: string;
-  };
-}
-```
-
-:::note
-Puedes modificar esta interfaz o crear múltiples interfaces para que se correspondan con los datos de tu propio proyecto.
-:::
-
-<FileTree title="Estructura del proyecto">
-  - src/
-    - interfaces/
-      - **article.ts**
-    - lib/
-      - strapi.ts
-    - env.d.ts
-  - .env
-  - astro.config.mjs
-  - package.json
-</FileTree>
-
-### Mostrando una lista de artículos
-
-<Steps>
-1. Actualiza tu página de inicio `src/pages/index.astro` para mostrar una lista de publicaciones de blog, cada una con una descripción y un enlace a su propia página.
-
-2. Importa la función wrapper y la interfaz. Agrega la siguiente llamada a la API para obtener tus artículos y devolver una lista:
-
-    ```astro title="src/pages/index.astro"
-    ---
-    import fetchApi from '../lib/strapi';
-    import type Article from '../interfaces/article';
-
-    const articles = await fetchApi<Article[]>({
-      endpoint: 'articles', // el tipo de contenido a obtener
-      wrappedByKey: 'data', // la clave para descomponer la respuesta
-    });
-    ---
-    ```
-
-    La llamada a la API solicita datos desde `http://localhost:1337/api/articles` y devuelve `articles`: un array de objetos JSON que representan tus datos:
-
-    ```json
-    [
-      {
-        id: 1,
-        attributes: {
-          title: "What's inside a Black Hole",
-          description: "Maybe the answer is in this article, or not...",
-          content: "Well, we don't know yet...",
-          slug: "what-s-inside-a-black-hole",
-          createdAt: "2023-05-28T13:19:46.421Z",
-          updatedAt: "2023-05-28T13:19:46.421Z",
-          publishedAt: "2023-05-28T13:19:45.826Z"
-        }
-      },
-      // ...
-    ]
-    ```
-
-3. Utilizando los datos del array `articles` devuelto por la API, muestra tus publicaciones de blog de Strapi en una lista. Estas publicaciones estarán vinculadas a sus propias páginas individuales, las cuales crearás en el siguiente paso.
-
-    ```astro title="src/pages/index.astro"
-    ---
-    import fetchApi from '../lib/strapi';
-    import type Article from '../interfaces/article';
-
-    const articles = await fetchApi<Article[]>({
-      endpoint: 'articles?populate=image',
-      wrappedByKey: 'data',
-    });
-    ---
-
-    <!DOCTYPE html>
-    <html lang="es">
-      <head>
-        <title>Strapi y Astro</title>
-      </head>
-
-      <body>
-        <main>
-          <ul>
-            {
-              articles.map((article) => (
-                <li>
-                  <a href={`/blog/${article.attributes.slug}/`}>
-                    {article.attributes.title}
-                  </a>
-                </li>
-              ))
-            }
-          </ul>
-        </main>
-      </body>
-    </html>
-    ```
-</Steps>
-
-### Generando páginas de artículos.
-
-Crea el archivo `src/pages/blog/[slug].astro` para [generar dinámicamente una página](/es/guides/routing/#rutas-dinámicas) para cada artículo.
-
-<FileTree title="Estructura del proyecto">
-  - src/
-    - interfaces/
-      - article.ts
-    - lib/
-      - strapi.ts
-    - pages/
-      - index.astro
-      - blog/
-        - **[slug].astro**
-    - env.d.ts
-  - .env
-  - astro.config.mjs
-  - package.json
-</FileTree>
-
-#### Generación de sitios estáticos
-
-En el modo estático predeterminado de Astro (SSG), utiliza [`getStaticPaths()`](/es/reference/api-reference/#getstaticpaths) para obtener tu lista de artículos desde Strapi.
-
-```astro title="src/pages/blog/[slug].astro
----
-import fetchApi from '../../lib/strapi';
-import type Article from '../../interfaces/article';
-
-export async function getStaticPaths() {
-  const articles = await fetchApi<Article[]>({
-    endpoint: 'articles',
-    wrappedByKey: 'data',
-  });
-
-  return articles.map((article) => ({
-    params: { slug: article.attributes.slug },
-    props: article,
-  }));
-}
-type Props = Article;
-
-const article = Astro.props;
----
-```
-
-Crea la plantilla para cada página utilizando las propiedades de cada objeto de publicación.
-
-
-```astro title="src/pages/blog/[slug].astro ins={21-43}
----
-import fetchApi from '../../lib/strapi';
-import type Article from '../../interfaces/article';
-
-export async function getStaticPaths() {
-  const articles = await fetchApi<Article[]>({
-    endpoint: 'articles',
-    wrappedByKey: 'data',
-  });
-
-  return articles.map((article) => ({
-    params: { slug: article.attributes.slug },
-    props: article,
-  }));
-}
-type Props = Article;
-
-const article = Astro.props;
----
-
-<!DOCTYPE html>
-<html lang="es">
-  <head>
-    <title>{article.attributes.title}</title>
-  </head>
-
-  <body>
-    <main>
-      <img src={import.meta.env.STRAPI_URL + article.attributes.image.data.attributes.url} />
-
-      <h1>{article.attributes.title}</h1>
-
-      <!-- Renderizar texto plano -->
-      <p>{article.attributes.content}</p>
-      <!-- Renderizar markdown -->
-      <MyMarkdownComponent>
-        {article.attributes.content}
-      </MyMarkdownComponent>
-      <!-- Renderizar html -->
-      <Fragment set:html={article.attributes.content} />
-    </main>
-  </body>
-</html>
-```
-:::tip
-Asegúrate de elegir el renderizado adecuado para tu contenido. Para Markdown, consulta nuestra [guía de Markdown](/es/guides/markdown-content/). Si estás representando HTML, consulta [esta guía](/es/reference/directives-reference/#sethtml) para asegurar la seguridad.
-:::
-
-#### Renderizado en el lado del servidor
-
-Si has [optado por el modo SSR](/es/guides/on-demand-rendering/) con `output: server` o `output: hybrid`, [genera tus rutas dinámicas](/es/guides/routing/#modo-servidor-ssr) utilizando el siguiente código:
-
-Crea el archivo `src/pages/blog/[slug].astro`:
-
-```astro title="src/pages/blog/[slug].astro"
----
-import fetchApi from '../../../lib/strapi';
-import type Article from '../../../interfaces/article';
-
-const { slug } = Astro.params;
-
-let article: Article;
-
-try {
-  article = await fetchApi<Article>({
-    endpoint: 'articles',
-    wrappedByKey: 'data',
-    wrappedByList: true,
-    query: {
-      'filters[slug][$eq]': slug || '',
-    },
-  });
-} catch (error) {
-  return Astro.redirect('/404');
-}
----
-
-<!DOCTYPE html>
-<html lang="es">
-  <head>
-    <title>{article.attributes.title}</title>
-  </head>
-
-  <body>
-    <main>
-      <img src={import.meta.env.STRAPI_URL + article.attributes.image.data.attributes.url} />
-
-      <h1>{article.attributes.title}</h1>
-
-      <!-- Renderizar texto plano -->
-      <p>{article.attributes.content}</p>
-      <!-- Renderizar markdown -->
-      <MyMarkdownComponent>
-        {article.attributes.content}
-      </MyMarkdownComponent>
-      <!-- Renderizar html -->
-      <Fragment set:html={article.attributes.content} />
-    </main>
-  </body>
-</html>
-```
-
-Este archivo obtendrá y representará los datos de la página desde Strapi que coinciden con el parámetro dinámico `slug`.
-
-Dado que estás utilizando una redirección a `/404`, crea una página 404 en `src/pages`:
-
-```astro title="src/pages/404.astro"
-<html lang="es">
-  <head>
-    <title>No encontrada</title>
-  </head>
-  <body>
-    <p>Lo siento, esta página no existe.</p>
-    <img src="https://http.cat/404" />
-  </body>
-</html>
-```
-
-Si el artículo no se encuentra, el usuario será redirigido a esta página de error 404 y será recibido por un encantador gato.
-
-### Publicando tu sitio
-
-Para desplegar tu sitio web, visita nuestras [guías de implementación](/es/guides/deploy/) y sigue las instrucciones para el proveedor de hosting que prefieras.
-
-#### Volver a compilar en caso de cambios
-
-Si tu proyecto está utilizando el modo estático predeterminado de Astro, deberás configurar un webhook para desencadenar una nueva compilación cuando tu contenido cambie. Si estás utilizando Netlify o Vercel como proveedor de hosting, puedes utilizar su función de webhook para desencadenar una nueva compilación desde Strapi.
-
-##### Netlify
-
-Para configurar un webhook en Netlify:
-
-<Steps>
-1. Ve al panel de control de tu sitio y haz clic en **Build & deploy**.
-
-2. En la pestaña **Continuous Deployment**, encuentra la sección **Build hooks** y haz clic en **Add build hook**.
-
-3. Proporciona un nombre para tu webhook y selecciona la rama en la que deseas desencadenar la compilación. Haz clic en **Save** y copia la URL generada.
-</Steps>
-
-##### Vercel
-
-Para configurar un webhook en Vercel:
-
-<Steps>
-1. Ve al panel de control de tu proyecto y haz clic en **Settings**.
-
-2. En la pestaña **Git**, busca la sección **Deploy Hooks**.
-
-3. Proporciona un nombre para tu webhook y la rama en la que deseas desencadenar la compilación. Haz clic en **Add** y copia la URL generada.
-</Steps>
-
-##### Agregando un webhook a Strapi
-
-Sigue [la guía de webhooks de Strapi](https://strapi.io/blog/webhooks) para crear un webhook en tu panel de administración de Strapi.
-
-## Recursos oficiales
-
-- [Guía de Blog de Strapi para React](https://strapi.io/blog/build-a-blog-with-next-react-js-strapi) por Strapi
diff --git a/src/content/docs/es/guides/cms/tina-cms.mdx b/src/content/docs/es/guides/cms/tina-cms.mdx
deleted file mode 100644
index 69888f29e905f..0000000000000
--- a/src/content/docs/es/guides/cms/tina-cms.mdx
+++ /dev/null
@@ -1,167 +0,0 @@
----
-title: Tina CMS & Astro
-description: Agrega contenido a tu proyecto Astro usando Tina como CMS
-type: cms
-stub: false
-service: Tina CMS
-i18nReady: true
----
-import PackageManagerTabs from '~/components/tabs/PackageManagerTabs.astro';
-import Grid from '~/components/FluidGrid.astro';
-import Card from '~/components/ShowcaseCard.astro';
-import { Steps } from '@astrojs/starlight/components';
-
-[Tina CMS](https://tina.io/) es un sistema de gestión de contenido sin servidor respaldado por Git.
-
-## Integración con Astro
- 
-Para empezar, necesitarás un proyecto Astro existente.
-
-<Steps>
-1. Ejecuta el siguiente comando para instalar Tina en tu proyecto Astro.
-
-    <PackageManagerTabs>
-      <Fragment slot="npm">
-      ```shell
-      npx @tinacms/cli@latest init
-      ```
-      </Fragment>
-      <Fragment slot="pnpm">
-      ```shell
-      pnpx @tinacms/cli@latest init
-      ```
-      </Fragment>
-      <Fragment slot="yarn">
-      ```shell
-      yarn dlx @tinacms/cli@latest init
-      ```
-      </Fragment>
-    </PackageManagerTabs>
-
-    - Cuando se te pregunte ingresar un Cloud ID, presione <kbd>Enter</kbd> para omitir. Generará uno más tarde si desea usar Tina Cloud.
-    - Cuando se te pregunte "¿Qué framework estás usando?", escoge **Otro**.
-    - Cuando se te pregunte donde se almacenan los archivos del directorio public, presione <kbd>Enter</kbd>.
-
-    Depués de haber terminado lo anterior, deberías tener una carpeta `.tina` en la raíz de tu proyecto y un archivo `hello-world.md` generado en `content/posts/hello-world.md`.
- 
-2. Cambia el script `dev` en `package.json`:
-
-    <PackageManagerTabs>
-      <Fragment slot="npm">
-      ```json del={4} ins={5}
-      // package.json
-      {
-          "scripts": {
-              "dev": "astro dev",
-              "dev": "tinacms dev -c \"astro dev\""
-          }
-      }
-      ```
-      </Fragment>
-      <Fragment slot="pnpm">
-      ```json del={4} ins={5}
-      // package.json
-      {
-          "scripts": {
-              "dev": "astro dev",
-              "dev": "tinacms dev -c \"astro dev\""
-          }
-      }
-      ```
-      </Fragment>
-      <Fragment slot="yarn">
-      ```json del={4} ins={5}
-      // package.json
-      {
-          "scripts": {
-              "dev": "astro dev",
-              "dev": "tinacms dev -c \"astro dev\""
-          }
-      }
-      ```
-      </Fragment>
-    </PackageManagerTabs>
-
-3. Ahora TinaCMS está configurado en modo local. Prueba esto ejecutando el script `dev`, luego navega a `/admin/index.html#/collections/post`.
-
-    Editando el archivo "Hello, World!" actualizará el archivo `content/posts/hello-world.md` en el directorio de tu proyecto.
-
-4. Configura tus colecciones Tina editando la propiedad `schema.collections` en `.tina/config.ts`.
-
-    Por ejemplo, puedes agregar una propiedad frontmatter requerida "date posted"(fecha de publicación) a nuestros posts:
-
-    ```js title=".tina/config.ts" ins={35-40}
-    import { defineConfig } from "tinacms";
-
-    // Tu proveedor de hosting probablemente exponga esto como una variable de entorno
-    const branch = process.env.HEAD || process.env.VERCEL_GIT_COMMIT_REF || "main";
-
-    export default defineConfig({
-      branch,
-      clientId: null, // Obtén esto de tina.io
-      token: null, // Obtén esto de tina.io
-      build: {
-        outputFolder: "admin",
-        publicFolder: "public",
-      },
-      media: {
-        tina: {
-          mediaRoot: "images",
-          publicFolder: "public",
-        },
-      },
-      schema: {
-        collections: [
-          {
-            name: "posts",
-            label: "Posts",
-            path: "src/content/posts",
-            format: 'mdx',
-            fields: [
-              {
-                type: "string",
-                name: "title",
-                label: "Title",
-                isTitle: true,
-                required: true,
-              },
-              {
-                type: "datetime",
-                name: "posted",
-                label: "Date Posted",
-                required: true,
-              },
-              {
-                type: "rich-text",
-                name: "body",
-                label: "Body",
-                isBody: true,
-              },
-            ],
-          },
-        ],
-      },
-    });
-    ```
-
-    Aprende más sobre las colecciones Tina [en la documentación de Tina](https://tina.io/docs/reference/collections/).
-
-5. En producción, TinaCMS puede hacer commit de los cambios directamente a tu repositorio de GitHub. Para configurar TinaCMS para producción, puedes elegir usar [Tina Cloud](https://tina.io/docs/tina-cloud/) o auto-hospedar la [Tina Data Layer](https://tina.io/docs/self-hosted/overview/). Puedes [leer más sobre el registro para Tina Cloud](https://app.tina.io/register) en la documentación de Tina.
-</Steps>
-
-## Recursos Oficiales
-
-- [Guía de integración de TinaCMS con Astro](https://tina.io/docs/frameworks/astro/).
-
-## Recursos de la comunidad 
-
-- [Plantilla de inicio de Tina y Astro con edición visual](https://github.com/dawaltconley/tina-astro) por Jeff See y Dylan Awalt-Conley
-- [Plantilla de inicio de Tina con Astro](https://github.com/tombennet/astro-tina-starter/tree/main) por Tom Bennet
-- [Utilizando la Optimización de Imágenes de Astro con Tina](https://joschua.io/posts/2023/08/16/how-to-use-astro-assets-with-tina-cms/)
-
-## Temas
-
-<Grid>
-  <Card title="Resume01" href="https://astro.build/themes/details/resume01/" thumbnail="resume01.png"/>
-  <Card title="Qurno Blog" href="https://astro.build/themes/details/qurno-astro/" thumbnail="qurno.png"/>
-</Grid>
diff --git a/src/content/docs/es/guides/cms/umbraco.mdx b/src/content/docs/es/guides/cms/umbraco.mdx
index fcf766f93e336..0beb112d552fc 100644
--- a/src/content/docs/es/guides/cms/umbraco.mdx
+++ b/src/content/docs/es/guides/cms/umbraco.mdx
@@ -152,7 +152,7 @@ const articles = await res.json();
 
 ### Generación de entradas de blog individuales
 
-Crea el archivo `[...slug].astro` en la raíz del directorio `/pages/`. Este archivo se utilizará para [generar las páginas de blog individuales dinámicamente](/es/guides/routing/#rutas-dinámicas).
+Crea el archivo `[...slug].astro` en la raíz del directorio `/pages/`. Este archivo se utilizará para [generar las páginas de blog individuales dinámicamente](/es/guides/routing/#dynamic-routes).
 
 Ten en cuenta que la propiedad `params`, que genera la ruta URL de la página, contiene `article.route.path` de la obtención de la API. De manera similar, la propiedad `props` debe incluir el `article` completo para que puedas acceder a toda la información en tu entrada del CMS.
 
diff --git a/src/content/docs/es/guides/cms/wordpress.mdx b/src/content/docs/es/guides/cms/wordpress.mdx
deleted file mode 100644
index f8a508886c0e9..0000000000000
--- a/src/content/docs/es/guides/cms/wordpress.mdx
+++ /dev/null
@@ -1,193 +0,0 @@
----
-title: Headless WordPress y Astro
-description: Agrega contenido a tu proyecto Astro usando WordPress como CMS
-type: cms
-stub: false
-service: WordPress
-i18nReady: true
----
-import { FileTree } from '@astrojs/starlight/components';
-import Grid from '~/components/FluidGrid.astro'
-import Card from '~/components/ShowcaseCard.astro'
-
-[WordPress](https://wordpress.org/) es una plataforma de gestión de contenidos que incluye su propio frontend, pero también puede ser usada como un CMS headless para proveer contenido a tu proyecto Astro.
-
-## Integración con Astro
-
-WordPress viene con una [API REST de WordPress](https://developer.wordpress.org/rest-api/) integrada para conectar tus datos de WordPress a Astro. Opcionalmente puedes instalar [WPGraphQL](https://wordpress.org/plugins/wp-graphql/) o [Gato GraphQL](https://wordpress.org/plugins/gatographql/) en tu sitio para usar GraphQL.
-
-### Prerrequisitos
-
-Para empezar, necesitarás lo siguiente:
-
-1. **Un proyecto Astro** - Si no tienes un proyecto Astro aún, nuestra [guía de instalación](/es/install-and-setup/) te ayudará a empezar en cuestión de minutos.
-2. **Un sitio WordPress** - La URL de la API REST es `[YOUR_SITE]/wp-json/wp/v2/` y está disponible por defecto con cualquier sitio WordPress. También es posible [configurar WordPress en un entorno local](https://wordpress.org/support/article/installing-wordpress-on-your-own-computer/).
-
-### Configurando Credenciales
-
-Tu API REST de WordPress está disponible para solicitudes externas de datos sin autenticación por defecto. Esto no permite a los usuarios modificar tus datos o configuraciones de tu sitio y te permite usar tus datos en tu proyecto Astro sin ninguna credencial.
-
-Puedes elegir [requerir autenticación](https://developer.wordpress.org/rest-api/frequently-asked-questions/#require-authentication-for-all-requests) si es necesario.
-
-### Obteniendo Datos
-
-Obtén tus datos de WordPress a través de la URL única de tu API REST y la ruta para tu contenido. (Para un blog, esto será comúnmente `posts`). Luego, puedes renderizar tus propiedades de datos usando la directiva `set:html={}` de Astro.
-
-Por ejemplo, para mostrar una lista de títulos de post y su contenido:
-
-```astro title="src/pages/index.astro"
----
-const res = await fetch("https://[YOUR-SITE]/wp-json/wp/v2/posts");
-const posts = await res.json();
----
-<h1>Astro + WordPress 🚀</h1>
-{
-  posts.map((post) => (
-      <h2 set:html={post.title.rendered} />
-      <p set:html={post.content.rendered} />
-  ))
-}
-```
-
-La API REST de WordPress incluye [parámetros globales](https://developer.wordpress.org/rest-api/using-the-rest-api/global-parameters/) como `_fields` y `embed`.
-
-Una gran cantidad de datos están disponible a través de esta API, por lo que puede que desees solo obtener ciertos campos. Puedes restringir tu respuesta agregando el parámetro [`_fields`](https://developer.wordpress.org/rest-api/using-the-rest-api/global-parameters/#_fields) a la URL de la API, por ejemplo: `[YOUR-SITE]/wp/v2/posts?_fields=author,id,excerpt,title,link`
-
-La API puede regresar contenido relacionado con tu artículo, como un link al artículo padre, o a los comentarios del artículo. Puedes agregar el parámetro [`_embed`](https://developer.wordpress.org/rest-api/using-the-rest-api/global-parameters/#_embed) a la URL de la API (por ejemplo: `[YOUR-SITE]/wp/v2/posts?_embed`) para indicarle al servidor que la respuesta debe incluir estos recursos embebidos.
-
-## Creando un blog con WordPress y Astro
-
-En este ejemplo obtendremos los datos de la API pública de WordPress de [https://norian.studio/dinosaurs/](https://norian.studio/dinosaurs/). Este sitio de WordPress almacena información sobre dinosaurios individuales bajo la ruta `dinos`, al igual que un blog almacenaría entradas individuales de blog bajo la ruta `posts`.
-
-Este ejemplo demuestra la estructura de sitio en Astro: una página índice que lista dinosaurios con enlaces a páginas de dinosaurios generadas dinámicamente.
-
-:::note
-Para usar [Tipos de Post Personalizados (CPT)](https://learn.wordpress.org/lesson-plan/custom-post-types/) en tu API de WordPress (no solo `post` y `page`), tendrás que [configurarlos en tu panel de WordPress](https://stackoverflow.com/questions/48536646/how-can-i-get-data-from-custom-post-type-using-wp-rest-api) o [agregar soporte REST API para tipos de contenido personalizados](https://developer.wordpress.org/rest-api/extending-the-rest-api/adding-rest-api-support-for-custom-content-types/) en WordPress.
-
-En este ejemplo los datos se obtienen de un sitio WordPress cuyos tipos de contenido ya han sido configurados y expuestos a la API REST.
-:::
-
-### Mostrando una lista de entradas de WordPress
-
-Esta página `src/pages/index.astro` enlista cada dinosaurio, con una descripción y un enlace a su propia página.
-
-<FileTree title="Estructura del proyecto">
-- src/
-  - pages/
-    - **index.astro**
-    - dinos/
-      - [slug].astro
-- astro.config.mjs
-- package.json
-</FileTree>
-
-Obteniendo los datos a través de la API devuelve un objeto que incluye las propiedades:
-
-- `title.rendered` - Contiene la representación HTML del título del post.
-- `content.rendered` - Contiene la representación HTML del contenido del post.
-- `slug` - Contiene el slug del post. (Esto proporciona el enlace a las páginas de dinosaurios generadas dinámicamente.)
-
-```astro title="/src/pages/index.astro"
----
-import Layout from "../layouts/Layout.astro";
-
-let res = await fetch("https://norian.studio/wp-json/wp/v2/dinos")
-let posts = await res.json();
----
-<Layout title="¡Dinos!">
-  <section>
-    <h1>Lista de Dinosaurios</h1>
-    {
-      posts.map((post) => (
-        <article>
-          <h2>
-            <a href={`/dinos/${post.slug}/`} set:html={post.title.rendered} />
-          </h2>
-          <Fragment set:html={post.content.rendered} />
-        </article>
-      ))
-    }
-  </section>
-</Layout>
-```
-
-### Usando la API de WordPress para generar páginas
-
-La página `src/pages/dinos/[slug].astro` [genera dinámicamente una página](/es/guides/routing/#rutas-dinámicas) para cada dinosaurio.
-
-```astro title="/src/pages/dinos/[slug].astro"
----
-import Layout from '../../layouts/Layout.astro';
-
-const { slug } = Astro.params;
-
-let res = await fetch(`https://norian.studio/wp-json/wp/v2/dinos?slug=${slug}`);
-let [post] = await res.json();
-
-// Se requiere la función getStaticPaths() para sitios estáticos en Astro.
-// Si estás utilizando SSR, no necesitarás esta función.
-export async function getStaticPaths() {
-  let data = await fetch("https://norian.studio/wp-json/wp/v2/dinos");
-  let posts = await data.json();
-
-  return posts.map((post) => ({
-    params: { slug: post.slug },
-    props: { post: post },
-  }));
-}
----
-<Layout title={post.title.rendered}>
-  <article>
-    <h1 set:html={post.title.rendered} />
-    <Fragment set:html={post.content.rendered} />
-  </article>
-</Layout>
-```
-
-### Devolviendo recursos embebidos
-
-Los parámetros de consulta `_embed` indican al servidor que devuelva recursos relacionados (incrustados).
-
-```astro title="src/pages/dinos/[slug].astro" /&_embed/
----
-const { slug } = Astro.params;
-
-let res = await fetch(`https://norian.studio/wp-json/wp/v2/dinos?slug=${slug}&_embed`);
-let [post] = await res.json();
----
-```
-
-La propiedad `_embedded['wp:featuredmedia']['0'].media_details.sizes.medium.source_url` devuelve una imagen destacada en cada página de dinosaurio. (Reemplaza `medium` con el tamaño de imagen deseado).
-
-```astro title="/src/pages/dinos/[slug].astro" {3}
-<Layout title={post.title.rendered}>
-  <article>
-    <img src={post._embedded['wp:featuredmedia']['0'].source_url} />
-    <h1 set:html={post.title.rendered} />
-    <Fragment set:html={post.content.rendered} />
-  </article>
-</Layout>
-```
-
-### Publicando tu sitio
-
-Para desplegar tu sitio visita nuestras [guías de despliegue](/es/guides/deploy/) y sigue las instrucciones de tu proveedor de hosting preferido.
-
-## Recursos de la Comunidad
-
-- [Construyendo un sitio web Astro con WordPress como CMS Headless](https://blog.openreplay.com/building-an-astro-website-with-wordpress-as-a-headless-cms/) por Chris Bongers.
-- [Construyendo con Astro x WordPress](https://www.youtube.com/watch?v=Jstqgklvfnc) en la transmisión de Ben Holmes.
-- [Construyendo un sitio WordPress Headless con Astro](https://developers.wpengine.com/blog/building-a-headless-wordpress-site-with-astro) por Jeff Everhart
-- [Astro y WordPress como API](https://darko.io/posts/wp-as-an-api/) por Darko Bozhinovski.
-
-## Sitios en Producción
-
-Los siguientes sitios usan Astro + WordPress en producción:
-
-- [Dinos!](https://wc-dinos.netlify.app/) por Anindo Neel Dutta — [código fuente en GitHub](https://github.com/leen-neel/astro-wordpress)
-
-## Temas
-
-<Grid>
-  <Card title="Astro WordPress Starter" href="https://astro.build/themes/details/astro-wordpress-starter/" thumbnail="astro-wordpress-starter.png"/>
-</Grid>
diff --git a/src/content/docs/es/guides/configuring-astro.mdx b/src/content/docs/es/guides/configuring-astro.mdx
deleted file mode 100644
index 847dc1de02930..0000000000000
--- a/src/content/docs/es/guides/configuring-astro.mdx
+++ /dev/null
@@ -1,171 +0,0 @@
----
-title: Configuración de Astro
-i18nReady: true
----
-import ReadMore from '~/components/ReadMore.astro'
-
-Personaliza cómo funciona Astro agregando un archivo `astro.config.mjs` en tu proyecto. Este es un archivo común en todos los proyectos de Astro; todos los ejemplos oficiales, sean plantillas o temas, cuentan con uno de forma predeterminada.
-
-<ReadMore>Lee la [referencia de configuración](/es/reference/configuration-reference/) de Astro para obtener una descripción general y completa de todas las opciones de configuración.</ReadMore>
-
-## Archivo de configuración de Astro
-
-Un archivo de configuración de Astro válido exporta la configuración usando la exportación `default`, además recomendamos usar `defineConfig` para definir la configuración de una manera más fácil.
-
-```js
-// astro.config.mjs
-import { defineConfig } from 'astro/config'
-
-export default defineConfig({
-  // tus opciones de configuración van aquí...
-  // https://docs.astro.build/es/reference/configuration-reference/
-})
-```
-
-Se recomienda usar `defineConfig()` para sugerencias de tipos automáticas en el IDE, pero también es opcional. Un archivo de configuración absolutamente mínimo y válido se vería así:
-
-```js title="astro.config.mjs"
-// Ejemplo: Archivo de configuración mínimo y vacío
-export default {}
-```
-
-## Tipos de archivo de configuración compatibles
-
-Astro es compatible con varios formatos de JavaScript para el archivo de configuración como: `astro.config.js`, `astro.config.mjs`, `astro.config.cjs` y `astro.config.ts`. Recomendamos usar `.mjs` en la mayoría de los casos o `.ts` si deseas escribir TypeScript en el archivo de configuración.
-
-La carga del archivo de configuración de TypeScript se maneja usando [`tsm`](https://github.com/lukeed/tsm) el cual respetará las opciones de tsconfig de su proyecto.
-
-## Resolución del archivo de configuración
-
-Astro intentará resolver automáticamente el archivo de configuración llamado `astro.config.mjs` dentro de la raíz del proyecto. Si no se encuentra ningún archivo de configuración en la raíz de su proyecto, se utilizarán las opciones predeterminadas de Astro.
-
-```bash
-# Ejemplo: Lee la configuración desde ./astro.config.mjs
-astro build
-```
-
-Puedes configurar explícitamente un archivo de configuración usando el indicador CLI `--config`. Este indicador CLI siempre se resuelve con relación a la carpeta de trabajo actual desde donde se ejecutó el comando CLI `astro`.
-
-```bash
-# Ejemplo: Lee la configuración de este archivo
-astro build --config my-config-file.js
-```
-
-## Configurar Intellisense
-
-Astro recomienda usar `defineConfig()` en el archivo de configuración. `defineConfig()` proporciona IntelliSense automático para tu IDE. Los editores como VSCode pueden leer las definiciones de tipo TypeScript y proporcionar sugerencias de tipos JSDoc automáticas, incluso si tu archivo de configuración no está escrito en TypeScript.
-
-```js
-// astro.config.mjs
-import { defineConfig } from 'astro/config'
-
-export default defineConfig({
-  // tus opciones de configuración van aquí...
-  // https://docs.astro.build/es/reference/configuration-reference/
-})
-```
-
-También puedes proporcionar definiciones de tipo manualmente a VSCode, utilizando la notación JSDoc:
-
-```js
-// astro.config.mjs
- export default /** @type {import('astro').AstroUserConfig} */ {
-  // tus opciones de configuración van aquí...
-  // https://docs.astro.build/es/reference/configuration-reference/
-}
-```
-
-## Referenciando archivos relativos
-
-Si proporcionas una ruta relativa a `root` o el indicador de CLI `--root`, Astro lo resolverá desde la carpeta de trabajo actual donde ejecutó el comando CLI `astro`.
-
-```js
-// astro.config.mjs
-import { defineConfig } from 'astro/config'
-
-export default defineConfig({
-    // Se resuelve a la carpeta "./foo" con relación a la carpeta de trabajo actual
-    root: 'foo'
-})
-```
-
-Astro resolverá todos los archivos y carpetas relativos a la carpeta raíz del proyecto especificada en el archivo de configuración.
-
-```js
-// astro.config.mjs
-import { defineConfig } from 'astro/config'
-
-export default defineConfig({
-    // Se resuelve a la carpeta "./foo" con relación a la carpeta de trabajo actual
-    root: 'foo',
-    // Se resuelve a la carpeta "./foo/public" con relación a la carpeta de trabajo actual
-    publicDir: 'public',
-})
-```
-
-Para hacer referencia a un archivo o carpeta relativo al archivo de configuración, use `import.meta.url` (a menos que esté escribiendo un archivo common.js `astro.config.cjs`).
-
-```js "import.meta.url"
-// astro.config.mjs
-import { defineConfig } from 'astro/config'
-
-export default defineConfig({
-    // Se resuelve a la carpeta "./foo" con relación a este archivo de configuración
-    root: new URL("./foo", import.meta.url).toString(),
-    // Se resuelve a la carpeta "./public" con relación a este archivo de configuración
-    publicDir: new URL("./public", import.meta.url).toString(),
-})
-```
-
-:::note 
-Las propiedades `import.meta` específicas de Vite, como `import.meta.env` o `import.meta.glob`, no son accesibles desde tu archivo de configuración. Recomendamos alternativas como [dotenv](https://github.com/motdotla/dotenv) o [fast-glob](https://github.com/mrmlnc/fast-glob) para estos casos de uso respectivos. Además, las [alias de ruta tsconfig](https://www.typescriptlang.org/tsconfig#paths) no se resolverán. Usa rutas relativas para las importaciones de módulos en este archivo.
-:::
-
-## Personalización de nombres de archivos compilados
-
-Para el código procesado por Astro, como archivos JavaScript o CSS importados, puedes personalizar los nombres de los archivos compilados usando [`entryFileNames`](https://rollupjs.org/configuration-options/#output-entryfilenames), [`chunkFileNames`](https://rollupjs.org/configuration-options/#output-chunkfilenames) y [`assetFileNames`](https://rollupjs.org/configuration-options/#output-assetfilenames) usando la configuración `vite.build.rollupOptions` en tu archivo `astro.config.*`.
-
-```js ins={9-11}
-// astro.config.mjs
-import { defineConfig } from 'astro/config'
-
-export default defineConfig({
-  vite: {
-    build: {
-      rollupOptions: {
-        output: {
-          entryFileNames: 'entry.[hash].mjs',
-          chunkFileNames: 'chunks/chunk.[hash].mjs',
-          assetFileNames: 'assets/asset.[hash][extname]',
-        }
-      },
-    },
-  },
-})
-```
-
-Esto puede ser útil si tienes scripts con nombres que podrían verse afectados por los bloqueadores de anuncios (por ejemplo, `ads.js` o `google-tag-manager.js`).
-
-## Variables de entorno
-
-Astro evalúa los archivos de configuración antes de cargar los demás archivos. Como tal, no puedes usar `import.meta.env` para acceder a las variables de entorno que se establecieron en los archivos `.env`.
-
-Puedes usar `process.env` en un archivo de configuración para acceder a otras variables de entorno, como las [establecidas por la CLI](/es/guides/environment-variables/#usando-la-cli).
-
-También puedes usar el [helper de Vite `loadEnv`](https://main.vite.dev/config/#using-environment-variables-in-config) para cargar los archivos `.env` manualmente.
-
-:::note
-`pnpm` no te permite importar módulos que no estén instalados directamente en tu proyecto. Si estás usando `pnpm`, deberás instalar `vite` para usar el helper `loadEnv`.
-```sh
-pnpm add vite --save-dev
-```
-:::
-
-```js title="astro.config.mjs"
-import { loadEnv } from "vite";
-const { SECRET_PASSWORD } = loadEnv(process.env.NODE_ENV, process.cwd(), "");
-```
-
-## Referencia de configuración
-
-<ReadMore>Lee la [referencia de configuración](/es/reference/configuration-reference/) de Astro para obtener una descripción general y completa de todas las opciones de configuración.</ReadMore>
diff --git a/src/content/docs/es/guides/content-collections.mdx b/src/content/docs/es/guides/content-collections.mdx
deleted file mode 100644
index 9830191aa9cf1..0000000000000
--- a/src/content/docs/es/guides/content-collections.mdx
+++ /dev/null
@@ -1,645 +0,0 @@
----
-title: Colecciones de Contenido
-description: >-
-  Las colecciones de contenido ayudan a organizar tu Markdown y a comprobar el tipo 
-  de sus datos de entrada.
-i18nReady: true
----
-import { FileTree } from '@astrojs/starlight/components';
-import Since from '~/components/Since.astro'
-import RecipeLinks from "~/components/RecipeLinks.astro"
-import Badge from "~/components/Badge.astro"
-
-<p><Since v="2.0.0" /></p>
-
-**Las Colecciones de contenido** son la mejor manera de administrar y crear contenido en cualquier proyecto de Astro. Las colecciones ayudan a organizar tus documentos, validar tu frontmatter y proporcionar una seguridad de tipo automática de TypeScript para todo tu contenido.
-
-
-## ¿Qué son las Colecciones de Contenido?
-
-Una **colección de contenido** es cualquier directorio de nivel superior dentro del directorio reservado `src/content` del proyecto, como `src/content/newsletter` y `src/content/authors`. Solo se permiten colecciones de contenido dentro del directorio `src/content`. Este directorio no se puede utilizar para nada más.
-
-Una **entrada de colección** es cualquier pieza de contenido dentro de tu directorio de colecciones de contenido. Las entradas pueden usar formatos de autoría de contenido que incluyen Markdown (`.md`) y MDX (`.mdx` usando la [integración MDX](/es/guides/integrations-guide/mdx/)) o como uno de los dos formatos de datos admitidos: YAML (`.yaml`) y JSON (`.json`). Recomendamos usar un esquema de nomenclatura consistente (minúsculas, guiones en lugar de espacios) para tus archivos para facilitar la búsqueda y organización de tu contenido, pero esto no es obligatorio. También puedes [excluir las entradas de ser construidas](/es/guides/routing/#excluyendo-páginas) prefijando el nombre de archivo con un guión bajo (_).
-
-<FileTree>
-- src/content/
-  - **newsletter/** la colección "newsletter"
-    - week-1.md una entrada de contenido
-    - week-2.md una entrada de contenido
-    - week-3.md una entrada de contenido
-</FileTree>
-
-Una vez que tengas una colección, puedes comenzar a [consultar tu contenido](#consultando-colecciones) utilizando las APIs de contenido integradas de Astro.
-
-### El directorio ".astro"
-
-Astro guarda metadatos importantes para las colecciones de contenido en un directorio `.astro` en tu proyecto. No es necesario que realices ninguna acción para mantener o actualizar este directorio. Se te recomienda que lo ignores por completo mientras trabajas en tu proyecto.
-
-El directorio `.astro` se actualizará automáticamente cada vez que ejecutes los comandos [`astro dev`](/es/reference/cli-reference/#astro-dev), [`astro build`](/es/reference/cli-reference/#astro-build). Puedes ejecutar [`astro sync`](/es/reference/cli-reference/#astro-sync) en cualquier momento para actualizar el directorio `.astro` manualmente.
-
-:::tip
-Si estás utilizando Git para el control de versiones, te recomendamos que ignores el directorio `.astro` añadiendo `.astro` a tu `.gitignore`. Esto le dice a Git que ignore este directorio y cualquier archivo dentro de él.
-
-```bash
-echo "\n.astro" >> .gitignore
-```
-:::
-
-
-
-### Organizando con múltiples colecciones
-
-Si dos archivos representan diferentes tipos de contenido (por ejemplo, una publicación de blog y un perfil de autor), probablemente pertenezcan a diferentes colecciones. Esto es importante porque muchas características (validación de frontmatter, seguridad de tipo automático de TypeScript) requieren que todas las entradas de una colección compartan una estructura similar.
-
-Si puedes trabajar con diferentes tipos de contenido, debes crear múltiples colecciones para representar cada tipo. Puedes crear tantas colecciones diferentes en tu proyecto como desees.
-
-<FileTree>
-- src/content/
-  - **newsletter/** 
-    - week-1.md
-    - week-2.md
-  - **blog/**
-    - post-1.md
-    - post-2.md
-  - **authors/**
-    - grace-hopper.json
-    - alan-turing.json
-</FileTree>
-
-
-### Organizando con subdirectorios
-
-Una colección de contenido siempre es una carpeta de nivel superior dentro del directorio `src/content/`. No puedes anidar una colección dentro de otra. Sin embargo, puedes usar subdirectorios para organizar tu contenido dentro de una colección.
-
-Por ejemplo, puedes usar la siguiente estructura de directorios para organizar las traducciones de i18n dentro de una sola colección `docs`. Cuando consultes esta colección, podrás filtrar el resultado por idioma utilizando la ruta del archivo.
-
-<FileTree>
-- src/content/
-  - docs/ esta colleción usa subdirectorios para organizar por idioma
-    - **en/**
-    - **es/**
-    - **de/**
-</FileTree>
-
-## Definiendo Colecciones
-
-:::note
-El archivo `src/content/config.ts` es opcional. Sin embargo, si eliges no definir tus colecciones, deshabilitarás algunas de sus mejores características como la validación del esquema del frontmatter o la generación automática de tipos de datos en TypeScript.
-:::
-
-Para aprovechar al máximo tus colecciones de contenido, crea un archivo `src/content/config.ts` en tu proyecto (también se admiten las extensiones `.js` y `.mjs`). Este es un archivo especial que Astro cargará y utilizará automáticamente para configurar tus colecciones de contenido.
-
-
-```ts
-// src/content/config.ts
-// 1. Importa las utilidades de `astro:content`
-import { defineCollection } from 'astro:content';
-// 2. Define tu colección(es)
-const blogCollection = defineCollection({ /* ... */ });
-// 3. Exporta un único objeto `collections` para registrar tu(s) colección(es)
-//    Esta clave debe coincidir con el nombre de tu directorio de colección en "src/content"
-export const collections = {
-  'blog': blogCollection,
-};
-```
-
-
-### Configurando TypeScript
-
-Si **no** extiendes las configuraciones recomendadas de TypeScript `strict` o `strictest` de Astro en tu archivo `tsconfig.json`, es posible que debas actualizar tu `tsconfig.json` para habilitar `strictNullChecks`.
-
-```json title="tsconfig.json" ins={5}
-{
-  // Nota: No se necesita ningún cambio si usas "astro/tsconfigs/strict" o "astro/tsconfigs/strictest"
-  "extends": "astro/tsconfigs/base",
-  "compilerOptions": {
-    "strictNullChecks": true
-  }
-}
-```
-
-Si usas archivos `.js` o `.mjs` en un proyecto de Astro, puedes habilitar IntelliSense y la comprobación de tipos en tu editor habilitando `allowJs` en tu `tsconfig.json`:
-```json title="tsconfig.json" ins={6}
-{
-  // Nota: No se necesita ningún cambio si usas "astro/tsconfigs/strict" o "astro/tsconfigs/strictest"
-  "extends": "astro/tsconfigs/base",
-  "compilerOptions": {
-    "strictNullChecks": true,
-    "allowJs": true
-  }
-}
-```
-
-### Definiendo un esquema de colección
-
-Los esquemas garantizan un frontmatter o datos de entrada consistentes dentro de una colección. Un esquema **garantiza** que estos datos existen en una forma predecible cuando necesitas hacer referencia o consultarlos. Si algún archivo viola su esquema de colección, Astro proporcionará un error útil para informarte. 
-
-Los esquemas también potencian las generación automática de tipos de TypeScript para tu contenido en Astro. Cuando defines un esquema para tu colección, Astro generará y aplicará automáticamente una interfaz de TypeScript. El resultado es un soporte completo de TypeScript cuando consultas tu colección, incluyendo el autocompletado de propiedades y la comprobación de tipos.
-
-Para definir tu primera colección, crea un archivo `src/content/config.ts` si no existe (las extensiones `.js` y `.mjs` también son compatibles). Este archivo debe:
-
-1. **Importar las utilidades adecuadas** de `astro:content`.
-2. **Definir cada colección que deseas validar.** Esto incluye un `type` (introducido en Astro v2.5.0) que especifica si la colección contiene formatos de autoría de contenido como Markdown (`type: 'content'`) o formatos de datos como JSON o YAML (`type: 'data'`). También incluye un `schema` que define la forma de tu frontmatter o datos de entrada.
-3. **Exportar un único objeto `collections`** para registrar tus colecciones. 
-
-```ts
-// src/content/config.ts
-// 1. Importar las utilidades de `astro:content`
-import { z, defineCollection } from 'astro:content';
-
-// 2. Definir un `type` y `schema` para cada colección
-const blogCollection = defineCollection({
-  type: 'content', // v2.5.0 y posteriores
-  schema: z.object({
-    title: z.string(),
-    tags: z.array(z.string()),
-    image: z.string().optional(),
-  }),
-});
-
-// 3. Exportar un único objeto `collections` para registrar tu(s) colección(es)
-export const collections = {
-  'blog': blogCollection,
-};
-```
-
-### Definiendo múltiples colecciones
-
-Puedes usar `defineCollection()` tantas veces como desees para crear múltiples esquemas. Todas las colecciones deben ser exportadas desde dentro del único objeto `collections`.
-
-```ts
-// src/content/config.ts
-const blogCollection = defineCollection({
-  type: 'content',
-  schema: z.object({ /* ... */ })
-});
-const newsletter = defineCollection({
-  type: 'content',
-  schema: z.object({ /* ... */ })
-});
-const authors = defineCollection({
-  type: 'data',
-  schema: z.object({ /* ... */ })
-});
-
-export const collections = {
-  'blog': blogCollection,
-  'newsletter': newsletter,
-  'authors': authors,
-};
-```
-
-A medida que tu proyecto crece, también eres libre de reorganizar tu base de código y mover la lógica fuera del archivo `src/content/config.ts`. Definir tus esquemas por separado puede ser útil para reutilizar esquemas en múltiples colecciones y compartir esquemas con otras partes de tu proyecto.
-
-```ts
-// src/content/config.ts
-// 1. Importar tus utilidades y esquemas
-import { defineCollection } from 'astro:content';
-import { blogSchema, authorSchema } from '../schemas';
-
-// 2. Definir tus colecciones
-const blogCollection = defineCollection({
-  type: 'content',
-  schema: blogSchema,
-});
-const authorCollection = defineCollection({
-  type: 'data',
-  schema: authorSchema,
-});
-
-// 3. Exportar múltiples colecciones para registrarlas
-export const collections = {
-  'blog': blogCollection,
-  'authors': authorCollection,
-};
-```
-
-### Usando esquemas de colección de terceros
-
-Puedes importar esquemas de colección desde cualquier lugar, incluyendo paquetes npm externos. Esto puede ser útil cuando trabajas con temas y bibliotecas que proporcionan sus propios esquemas de colección para que los uses.
-
-
-```ts
-// src/content/config.ts
-import { blogSchema } from 'my-blog-theme';
-const blogCollection = defineCollection({ type: 'content', schema: blogSchema });
-
-// Exportar la colección de blog, usando un esquema externo de 'my-blog-theme'
-export const collections = {
-  'blog': blogCollection,
-};
-```
-
-
-### Definiendo tipos de datos con Zod
-
-Astro usa [Zod](https://github.com/colinhacks/zod) para potenciar sus esquemas de contenido. Con Zod, Astro puede validar el frontmatter de cada archivo dentro de una colección *y* proporcionar tipos automáticos de TypeScript cuando consultas el contenido desde dentro de tu proyecto.
-
-Para usar Zod en Astro, importa la utilidad `z` de `"astro:content"`. Esta es una re-exportación de la biblioteca Zod, y admite todas las funciones de Zod. Consulta el [README de Zod](https://github.com/colinhacks/zod) para obtener documentación completa sobre cómo funciona Zod y qué funciones están disponibles.
-
-
-```ts
-// Ejemplo: Una hoja de trucos de muchos tipos de datos Zod comunes
-import { z, defineCollection } from 'astro:content';
-
-defineCollection({
-  schema: z.object({
-    isDraft: z.boolean(),
-    title: z.string(),
-    sortOrder: z.number(),
-    image: z.object({
-      src: z.string(),
-      alt: z.string(),
-    }),
-    author: z.string().default('Anonymous'),
-    language: z.enum(['en', 'es']),
-    tags: z.array(z.string()),
-    // Una propiedad opcional del frontmatter. ¡Muy común!
-    footnote: z.string().optional(),
-    // En el frontmatter, las fechas escritas sin comillas se interpretan como objetos Date
-    publishDate: z.date(),
-    // También puedes transformar un string de fecha (por ejemplo, "2022-07-08") a un objeto Date
-    // publishDate: z.string().transform((str) => new Date(str)),
-    // Avanzado: Valida que el string también sea un correo electrónico
-    authorContact: z.string().email(),
-    // Avanzado: Valida que el string también sea una URL
-    canonicalURL: z.string().url(),
-  })
-})
-```
-
-### Definiendo referencias de colección
-
-Las entradas de una colección pueden "referenciar" otras entradas relacionadas.
-
-Con la función `reference()` de la API de Colecciones, puedes definir una propiedad en un esquema de colección como una entrada de otra colección. Por ejemplo, puedes requerir que cada entrada `space-shuttle` incluya una propiedad `pilot` que utilice el propio esquema de la colección `pilot` para la comprobación de tipos, el autocompletado y la validación.
-
-Un ejemplo común es una publicación de blog que hace referencia a perfiles de autor reutilizables almacenados como JSON, o a URL de publicaciones relacionadas almacenadas en la misma colección:
-
-```ts
-import { defineCollection, reference, z } from 'astro:content';
-
-const blog = defineCollection({
-  type: 'content',
-  schema: z.object({
-    title: z.string(),
-    // Referencia a un único autor de la colección `authors` por `id`
-    author: reference('authors'),
-    // Referencia a un arreglo de publicaciones relacionadas de la colección `blog` por `slug`
-    relatedPosts: z.array(reference('blog')),
-  })
-});
-
-const authors = defineCollection({
-  type: 'data',
-  schema: z.object({
-    name: z.string(),
-    portfolio: z.string().url(),
-  })
-});
-
-export const collections = { blog, authors };
-```
-
-Este ejemplo de publicación de blog especifica los `slug` de las publicaciones relacionadas y el `id` del autor de la publicación:
-
-```yaml title="src/content/blog/welcome.md"
----
-title: "Bienvenido a mi Blog"
-author: ben-holmes # referencia `src/content/authors/ben-holmes.json`
-relatedPosts:
-- about-me # referencia `src/content/blog/about-me.md`
-- my-year-in-review # referencia `src/content/blog/my-year-in-review.md`
----
-```
-
-### Definiendo slugs personalizados
-
-Cuando usas `type: 'content'`, cada entrada de contenido genera una propiedad `slug` compatible con URL a partir de su [`id` de archivo](/es/reference/api-reference/#id). El slug se utiliza para consultar la entrada directamente desde tu colección. También es útil cuando creas nuevas páginas y URL a partir de tu contenido.
-
-Puedes anular el slug generado de una entrada añadiendo tu propia propiedad `slug` al frontmatter del archivo. Esto es similar a la función "permalink" de otros frameworks web. `"slug"` es un nombre de propiedad especial y reservado que no está permitido en tu `schema` de colección personalizado y no aparecerá en la propiedad `data` de tu entrada.
-
-```md {3}
----
-title: Mi Publicación de Blog
-slug: my-custom-slug/supports/slashes
----
-El contenido de tu publicación de blog aquí.
-```
-
-## Consultando Colecciones
-
-Astro proporciona dos funciones para consultar una colección y devolver una (o más) entradas de contenido: [`getCollection()`](/es/reference/api-reference/#getcollection) y [`getEntry()`](/es/reference/api-reference/#getentry).
-
-```js
-import { getCollection, getEntry } from 'astro:content';
-
-// Obtén todas las entradas de una colección.
-// Requiere el nombre de la colección como argumento.
-// Ejemplo: recupera `src/content/blog/**`
-const allBlogPosts = await getCollection('blog');
-
-// Obtén una única entrada de colleción.
-// Requiere el nombre de la colección y también
-// el `slug` de la entrada (colecciones de contenido) o `id` (colecciones de datos) 
-// Ejemplo: recupera `src/content/authors/grace-hopper.json`
-const graceHopperProfile = await getEntry('authors', 'grace-hopper');
-```
-
-Ambas funciones devuelven entradas de contenido tal como se definen en el tipo [`CollectionEntry`](/es/reference/api-reference/#tipo-de-entrada-de-la-colección).
-
-### Accediendo a los datos referenciados
-
-Cualquier [referencia definida en tu esquema](#definiendo-referencias-de-colección) debe consultarse por separado después de consultar por primera vez la entrada de tu colección. Puedes usar la función `getEntry()` de nuevo, o `getEntries()`, para recuperar la entrada referenciada del objeto `data` devuelto.
-
-```astro title="src/pages/blog/welcome.astro"
----
-import { getEntry, getEntries } from 'astro:content';
-
-const blogPost = await getEntry('blog', 'welcome');
-
-// Resuelve una referencia singular
-const author = await getEntry(blogPost.data.author);
-// Resuelve un arreglo de referencias
-const relatedPosts = await getEntries(blogPost.data.relatedPosts);
----
-
-<h1>{blogPost.data.title}</h1>
-<p>Autor: {author.data.name}</p>
-
-<!-- ... -->
-
-<h2>También te puede gustar:</h2>
-{relatedPosts.map(p => (
-  <a href={p.slug}>{p.data.title}</a>
-))}
-```
-
-### Filtrando consultas de colección
-
-`getCollection()` toma un callback opcional "filter" que te permite filtrar tu consulta en función de las propiedades `id` o `data` (frontmatter) de una entrada. Para las colecciones de `type: 'content'`, también puedes filtrar en función de `slug`.
-
-:::note
-La propiedad `slug` es específica de las colecciones de contenido y no estará disponible al filtrar colecciones de JSON o YAML.
-:::
-
-Puedes usar esto para filtrar por cualquier criterio de contenido que desees. Por ejemplo, puedes filtrar por propiedades como `draft` para evitar que se publiquen publicaciones de blog en borrador en tu blog:
-
-```js
-// Ejemplo: Filtra las entradas de contenido con `draft: true`
-import { getCollection } from 'astro:content';
-const publishedBlogEntries = await getCollection('blog', ({ data }) => {
-  return data.draft !== true;
-});
-```
-
-También puedes crear páginas en borrador que estarán disponibles cuando ejecutes el servidor de desarrollo, pero que no se construirán en producción:
-
-```js
-// Ejemplo: Filtrar las entradas de contenido con `draft: true` solo al construir para producción
-import { getCollection } from 'astro:content';
-const blogEntries = await getCollection('blog', ({ data }) => {
-  return import.meta.env.PROD ? data.draft !== true : true;
-});
-```
-
-Para filtrar argumentos también admite el filtrado por directorios anidados dentro de una colección. Dado que el `id` incluye la ruta anidada completa, puedes filtrar por el inicio de cada `id` para devolver solo los elementos de un directorio anidado específico:
-
-```js
-// Ejemplo: Filtra las entradas por subdirectorio en la colección
-import { getCollection } from 'astro:content';
-const englishDocsEntries = await getCollection('docs', ({ id }) => {
-  return id.startsWith('en/');
-});
-```
-
-### Usando contenido en plantillas de Astro
-
-Una vez que hayas consultado tus entradas de colección, puedes acceder a cada entrada directamente dentro de la plantilla de tu componente de Astro. Esto te permite renderizar HTML para cosas como enlaces a tu contenido (usando el `slug` de contenido) o información sobre tu contenido (usando la propiedad `data`).
-
-Para obtener información sobre cómo renderizar tu contenido a HTML, consulta [Renderizando contenido a HTML](#renderizando-contenido-a-html) a continuación.
-
-```astro
----
-// src/pages/index.astro
-import { getCollection } from 'astro:content';
-const blogEntries = await getCollection('blog');
----
-<ul>
-  {blogEntries.map(blogPostEntry => (
-    <li>
-      <a href={`/my-blog-url/${blogPostEntry.slug}`}>{blogPostEntry.data.title}</a>
-      <time datetime={blogPostEntry.data.publishedDate.toISOString()}>
-        {blogPostEntry.data.publishedDate.toDateString()}
-      </time>
-    </li>
-  ))}
-</ul>
-```
-
-### Pasando contenido como props
-
-Un componente también puede pasar un contenido completo como una prop.
-
-Si haces esto, puedes usar la utilidad [`CollectionEntry`](/es/reference/api-reference/#tipo-de-entrada-de-la-colección) para tipar correctamente las props de tu componente usando TypeScript. Esta utilidad toma un argumento de tipo string que coincide con el nombre del esquema de tu colección y heredará todas las propiedades de ese esquema de colección.
-
-```astro /CollectionEntry(?:<.+>)?/
----
-// src/components/BlogCard.astro
-import type { CollectionEntry } from 'astro:content';
-interface Props {
-  post: CollectionEntry<'blog'>;
-}
-
-// `post` coincidirá con el tipo de esquema de tu colección 'blog'
-const { post } = Astro.props;
----
-```
-
-### Renderizando contenido a HTML
-
-Una vez consultado, puedes renderizar las entradas de Markdown y MDX a HTML usando la propiedad de función `render()` de la entrada. Llamar a esta función te da acceso al contenido y metadatos renderizados, incluyendo tanto un componente `<Content />` como una lista de todos los encabezados renderizados.
-
-```astro {5}
----
-// src/pages/render-example.astro
-import { getEntry } from 'astro:content';
-const entry = await getEntry('blog', 'post-1');
-const { Content, headings } = await entry.render();
----
-<p>Publicado el: {entry.data.published.toDateString()}</p>
-<Content />
-```
-
-
-## Generando Rutas desde el Contenido
-
-Las Colecciones de contenido se almacenan fuera del directorio `src/pages/`. Esto significa que no se generan rutas para los elementos de tu colección de forma predeterminada. Deberás crear manualmente una nueva [ruta dinámica](/es/guides/routing/#rutas-dinámicas) para generar páginas HTML a partir de las entradas de tu colección. Tu ruta dinámica asignará el parámetro de solicitud entrante (por ejemplo, `Astro.params.slug` en `src/pages/blog/[...slug].astro`) para recuperar la entrada correcta dentro de una colección.
-
-El método exacto para generar rutas dependerá del modo de salida de tu compilación [`output`](/es/reference/configuration-reference/#output): 'static' (el valor predeterminado) o 'server' (para SSR).
-
-### Construyendo para salida estática (predeterminado)
-
-Si estás construyendo un sitio web estático (el comportamiento predeterminado de Astro), debes usar la función [`getStaticPaths()`](/es/reference/api-reference/#getstaticpaths) para crear múltiples páginas a partir de un solo componente `src/pages/` durante tu compilación.
-
-Llama `getCollection()` dentro de `getStaticPaths()` para [consultar tu contenido o tu colección de datos](/es/guides/content-collections/#consultando-colecciones). Luego, crea tus nuevas rutas URL usando la propiedad `slug` (colecciones de contenido) o la propiedad `id`(colecciones de datos) para cada entrada de contenido.
-
-```astro "{ slug: entry.slug }"
----
-// src/pages/posts/[...slug].astro
-import { getCollection } from 'astro:content';
-// 1. Genera una nueva ruta para cada entrada de colección
-export async function getStaticPaths() {
-  const blogEntries = await getCollection('blog');
-  return blogEntries.map(entry => ({
-    params: { slug: entry.slug }, props: { entry },
-  }));
-}
-// 2. Para tu plantilla, puedes obtener la entrada directamente de la prop
-const { entry } = Astro.props;
-const { Content } = await entry.render();
----
-<h1>{entry.data.title}</h1>
-<Content />
-```
-
-Esto generará una nueva página para cada entrada en la colección `blog`. Por ejemplo, una entrada en `src/content/blog/hello-world.md` tendrá un slug de `hello-world`, y por lo tanto su URL final será `/posts/hello-world/`.
-
-:::note
-Si tus slugs personalizados contienen el carácter `/` para producir URLs con múltiples segmentos de ruta, debes usar un [parámetro rest (`[...slug]`)](/es/guides/routing/#parámetros-rest) en el nombre de archivo `.astro` para esta página de enrutamiento dinámico.
-:::
-
-### Construyendo para salida del servidor (SSR)
-
-Si estás construyendo un sitio web dinámico (usando el soporte SSR de Astro), no se espera que generes ninguna ruta de antemano durante la compilación. En su lugar, tu página debe examinar la solicitud (usando `Astro.request` o `Astro.params`) para encontrar el `slug` bajo demanda, y luego recuperarlo usando [`getEntry()`](/es/reference/api-reference/#getentry).
-
-
-```astro
----
-// src/pages/posts/[...slug].astro
-import { getEntry } from "astro:content";
-// 1. Obtén el slug de la solicitud entrante del servidor
-const { slug } = Astro.params;
-if (slug === undefined) {
-	throw new Error("Slug es requerido");
-}
-// 2. Consulta la entrada directamente usando el slug de la solicitud
-const entry = await getEntry("blog", slug);
-// 3. Redirige si la entrada no existe
-if (entry === undefined) {
-	return Astro.redirect("/404");
-}
-// 4. (Opcional) Renderiza la entrada a HTML en la plantilla
-const { Content } = await entry.render();
----
-```
-
-:::tip
-¡Explora la carpeta `src/pages/` del [código de demostración del tutorial de blog en GitHub](https://github.com/withastro/blog-tutorial-demo/tree/content-collections/src/pages) o [abrelo en StackBlitz](https://stackblitz.com/github/withastro/blog-tutorial-demo/tree/content-collections?file=src/pages/blog.astro) para ver ejemplos completos de cómo crear páginas a partir de tus colecciones para funciones de blog como una lista de publicaciones de blog, páginas de etiquetas y más!
-:::
-
-## Migrando desde el Enrutamiento Basado en Archivos
-
-Si tienes un proyecto de Astro existente como un blog, que usa archivos Markdown o MDX en subcarpetas dentro de `src/pages/`, considera migrar los archivos de contenido o datos relacionados a las colecciones de contenido.
-
-Consulta cómo convertir un ejemplo básico de blog de `src/pages/posts/` a `src/content/posts` en nuestro [tutorial paso a paso](/es/tutorial/6-islands/4/) que utiliza la base de código del [proyecto terminado del tutorial Crear un Blog](https://github.com/withastro/blog-tutorial-demo).
-
-## Habilitando la Generación de Esquemas JSON
-
-<p><Since v="4.13.0" /></p>
-
-Si estás trabajando con colecciones de tipo `data`, Astro generará automáticamente archivos de esquema JSON para que tu editor obtenga IntelliSense y comprobación de tipos. Se creará un archivo separado para cada colección de datos en tu proyecto basado en las colecciones definidas en `src/content/config.ts` utilizando una biblioteca llamada [`zod-to-json-schema`](https://github.com/StefanTerdell/zod-to-json-schema#known-issues).
-
-Esta carácateristica requiere que establezcas manualmente la ruta del archivo de tu esquema como el valor de `$schema` en cada archivo de entrada de datos de la colección:
-
-```json title="src/content/authors/armand.json" ins={2}
-{
-  "$schema": "../../../.astro/collections/authors.schema.json",
-  "name": "Armand",
-  "skills": ["Astro", "Starlight"]
-}
-```
-
-Alternativamente, puedes establecer este valor en la configuración de tu editor. Por ejemplo, para establecer este valor en la [configuración `json.schemas` de VSCode](https://code.visualstudio.com/docs/languages/json#_json-schemas-and-settings), proporciona la ruta de los archivos a coincidir y la ubicación de tu esquema JSON:
-
-```json
-{
-  "json.schemas": [
-    {
-      "fileMatch": [
-        "/src/content/authors/**"
-      ],
-      "url": "./.astro/collections/authors.schema.json"
-    }
-  ]
-}
-```
-
-## Habilitando el Caché de Construcción
-
-<p><Since v="3.5.0" /><Badge class="neutral-badge" text="Experimental" /></p>
-
-Si estás trabajando con colecciones grandes, es posible que desees habilitar las compilaciones en caché con la bandera [`experimental.contentCollectionCache`](/es/reference/configuration-reference/#experimentalcontentcollectioncache). Esta característica experimental optimiza el proceso de compilación de Astro, permitiendo que las colecciones no modificadas se almacenen y reutilicen entre compilaciones.
-
-En muchos casos, esto puede conducir a mejoras significativas en el rendimiento de la compilación.
-
-Mientras esta característica se estabiliza, es posible que te encuentres con problemas con la caché almacenada. Siempre puedes restablecer tu caché de compilación ejecutando el siguiente comando:
-
-```
-npm run astro build -- --force
-```
-
-
-## Modificando el Frontmatter con Remark
-
-:::caution
-**No es recomendado.** Los plugins de remark y rehype acceden al frontmatter _raw_ del documento Markdown o MDX. Esto significa que el frontmatter `remarkPluginFrontmatter` se maneja por separado de tu `schema` de tipo seguro, y no reflejará ningún cambio o valor predeterminado aplicado a través de Astro. ¡Úsalo bajo tu propio riesgo!
-:::
-
-Astro admite los plugins remark o rehype que [modifican tu frontmatter directamente](/es/guides/markdown-content/#modificación-programática-del-frontmatter). Puedes acceder a este frontmatter modificado dentro de una entrada de contenido usando la propiedad `remarkPluginFrontmatter` devuelta de `render()`:
-
-```astro "{ remarkPluginFrontmatter }"
----
-import { getEntry } from 'astro:content';
-const blogPost = await getEntry('blog', 'post-1');
-const { remarkPluginFrontmatter } = await blogPost.render();
----
-<p>{blogPost.data.title} — {remarkPluginFrontmatter.readingTime}</p>
-```
-
-<RecipeLinks slugs={["es/recipes/reading-time" ]}/>
-
-Los pipelines de remark y rehype solo se ejecutan cuando se renderiza tu contenido, lo que explica por qué `remarkPluginFrontmatter` solo está disponible después de llamar a `render()` en tu entrada de contenido. En contraste, `getCollection()` y `getEntry()` no pueden devolver estos valores directamente porque no renderizan tu contenido.
-
-## Trabajando con fechas en el frontmatter
-
-Muchos formatos de fecha son admitidos en las colecciones de contenido, pero el esquema de tu colección debe coincidir con el formato utilizado en el frontmatter YAML de tu Markdown o MDX.
-
-YAML usa el estándar [ISO-8601](https://www.iso.org/iso-8601-date-and-time-format.html) para expresar fechas. Utiliza el formato `yyyy-mm-dd` (por ejemplo, `2021-07-28`) junto con un tipo de esquema de `z.date()`:
-
-```markdown title="src/pages/posts/example-post.md"
----
-title: Mi Publicación de Blog
-pubDate: 2021-07-08
----
-```
-
-El formato de fecha se especificará en UTC si no se proporciona una zona horaria. Si necesitas especificar una zona horaria, puedes usar el formato [ISO 8601](https://en.wikipedia.org/wiki/ISO_8601).
-
-```markdown title="src/pages/posts/example-post.md"
----
-title: Mi Publicación de Blog
-pubDate: 2021-07-08T12:00:00-04:00
----
-```
-
-Para renderizar solo `YYYY-MM-DD` de la marca de tiempo UTC completa, utiliza el método `slice` de JavaScript para eliminar la marca de tiempo:
-
-```astro title="src/layouts/ExampleLayout.astro"
----
-const { frontmatter } = Astro.props;
----
-<h1>{frontmatter.title}</h1>
-<p>{frontmatter.pubDate.toISOString().slice(0,10)}</p>
-```
-Para ver un ejemplo usando `toLocaleDateString` para formatear el día, mes y año, consulta el componente [`<FormattedDate />`](https://github.com/withastro/astro/blob/latest/examples/blog/src/components/FormattedDate.astro) en la plantilla oficial del blog de Astro.
diff --git a/src/content/docs/es/guides/data-fetching.mdx b/src/content/docs/es/guides/data-fetching.mdx
deleted file mode 100644
index 7fded92d5a3b7..0000000000000
--- a/src/content/docs/es/guides/data-fetching.mdx
+++ /dev/null
@@ -1,111 +0,0 @@
----
-title: Fetching de datos
-description: Aprenda como obtener datos remotos con Astro utilizando la API de fetch.
-i18nReady: true
----
-
-Los archivos `.astro` pueden obtener datos remotos para ayudarte a generar tus páginas.
-
-## `fetch()` en Astro
-
-Todos los [componentes de Astro](/es/basics/astro-components/) tienen acceso a la [función global `fetch()`](https://developer.mozilla.org/es/docs/Web/API/fetch) en su script de componente para hacer peticiones HTTP a APIs usando la URL completa (p.ej. https://example.com/api).
-Adicionalmente, puedes construir una URL a las páginas y endpoints de tu proyecto que se renderizan bajo demanda en el servidor utilizando `new URL("/api", Astro.url)`.
-
-Esta llamada a fetch será ejecutada en el momento de la compilación, y los datos estarán disponibles para la plantilla del componente para generar HTML dinámico. Si el modo [SSR](/es/guides/on-demand-rendering/) está habilitado, cualquier llamada a fetch será ejecutada en tiempo de ejecución.
-
-💡 Aprovecha el [**top-level await**](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/await#top_level_await) dentro del script del componente de Astro.
-
-💡 Puedes pasar los datos obtenidos a los componentes de Astro u otros UI frameworks como props.
-
-```astro /await fetch\\(.*?\\)/
----
-// src/components/User.astro
-import Contact from '../components/Contact.jsx';
-import Location from '../components/Location.astro';
-
-const response = await fetch('https://randomuser.me/api/');
-const data = await response.json();
-const randomUser = data.results[0]
----
-<!-- Los datos obtenidos en la compilación pueden ser usados en el HTML -->
-<h1>Usuario</h1>
-<h2>{randomUser.name.first} {randomUser.name.last}</h2>
-
-<!-- Los datos obtenidos en la compilación pueden ser pasados como props a otros componentes -->
-<Contact client:load email={randomUser.email} />
-<Location city={randomUser.location.city} />
-```
-
-:::note
-Recuerda, todos los datos en los componentes de Astro se obtienen cuando se renderiza el componente.
-
-Cuando tu proyecto de Astro es desplegado obtendrá los datos **una vez, en el momento de la compilación**. En desarrollo, verás el fetching de datos al actualizar los componentes. Si necesitas hacer fetching datos varias veces del lado del cliente, usa un [componente de framework](/es/guides/framework-components/) o un [script del lado del cliente](/es/guides/client-side-scripts/) en el componente de Astro.
-:::
-
-
-## `fetch()` en componentes de framework
-
-La función `fetch()` también está disponible globalmente para cualquier [componente de framework](/es/guides/framework-components/):
-
-```tsx title="src/components/Movies.tsx" /await fetch\\(.*?\\)/
-import type { FunctionalComponent } from 'preact';
-
-const data = await fetch('https://example.com/movies.json').then((response) =>
-  response.json()
-);
-
-// Los componentes que se procesan en la compilación se registran en la CLI.
-// Cuando se renderizan con una directiva client:*, se registran en la consola del navegador.
-console.log(data);
-
-const Movies: FunctionalComponent = () => {
-// Envía el resultado a la página.
-  return <div>{JSON.stringify(data)}</div>;
-};
-
-export default Movies;
-```
-
-
-### Consultas en GraphQL
-
-Astro también puede usar `fetch()` para consultar a un servidor GraphQL con cualquier query de GraphQL válida.
-
-```astro title="src/components/Film.astro" "await fetch"
----
-const response = await fetch("https://swapi-graphql.netlify.app/.netlify/functions/index",
-  {
-    method: 'POST',
-    headers: {'Content-Type':'application/json'},
-    body: JSON.stringify({
-      query: `
-        query getFilm ($id:ID!) {
-          film(id: $id) {
-            title
-            releaseDate
-          }
-        }
-      `,
-      variables: {
-        id: "ZmlsbXM6MQ==",
-      },
-    }),
-  });
-
-const json = await response.json();
-const { film } = json.data;
----
-<h1>Obteniendo información sobre Star Wars: A New Hope</h1>
-<h2>Título: {film.title}</h2>
-<p>Año: {film.releaseDate}</p>
-```
-
-## Fetching de datos desde un Headless CMS
-
-Los componentes de Astro pueden obtener datos desde tu CMS favorito y luego renderizarlos como contenido en tu página. Usando [rutas dinámicas](/es/guides/routing/#rutas-dinámicas), los componentes pueden generar páginas basadas en el contenido obtenido del CMS.
-
-Ve nuestras [guías de CMS](/es/guides/cms/) para obtener más detalles sobre cómo integrar Astro con un headless CMS incluyendo Stroyblok, Contentful y WordPress.
-
-## Recursos de la comunidad
-
-- [Creando una app fullstack con Astro + GraphQL](https://robkendal.co.uk/blog/how-to-build-astro-site-with-graphql/)
diff --git a/src/content/docs/es/guides/deploy/aws.mdx b/src/content/docs/es/guides/deploy/aws.mdx
deleted file mode 100644
index f43de68eddb06..0000000000000
--- a/src/content/docs/es/guides/deploy/aws.mdx
+++ /dev/null
@@ -1,230 +0,0 @@
----
-title: Despliega tu proyecto de Astro en AWS
-description: Cómo desplegar tu proyecto de Astro en AWS.
-type: deploy
-i18nReady: true
----
-import { Steps } from '@astrojs/starlight/components';
-import PackageManagerTabs from '~/components/tabs/PackageManagerTabs.astro';
-
-[AWS](https://aws.amazon.com/) es una plataforma integral de alojamiento, que puede ser usada para desplegar un proyecto de Astro.
-
-Desplegar tu proyecto en AWS requiere el uso de la [consola de AWS](https://aws.amazon.com/console/). (La mayoría de estas acciones también se pueden realizar mediante el [CLI de AWS](https://aws.amazon.com/cli/)). Esta guía te indicará los pasos a seguir para desplegar tu proyecto en AWS, usando [AWS Amplify](https://aws.amazon.com/amplify/), [S3 alojamiento de sitios web estáticos](https://aws.amazon.com/s3/) y [CloudFront](https://aws.amazon.com/cloudfront/).
-
-## AWS Amplify
-
-AWS Amplify es un conjunto de herramientas que permiten a los desarrolladores web y mobile crear aplicaciones completas en AWS de manera rápida y fácil.
-
-<Steps>
-1. Crea un nuevo proyecto en Amplify.
-2. Conecta tu repositorio a Amplify.
-3. Modifica los ajustes de compilación para adaptarlos al proceso de compilación de tu proyecto.
-
-    <PackageManagerTabs>
-    <Fragment slot="pnpm">
-    ```yaml
-    version: 1
-    frontend:
-      phases:
-        preBuild:
-          commands:
-            - npm i -g pnpm
-            - pnpm config set store-dir .pnpm-store
-            - pnpm i
-        build:
-          commands:
-            - pnpm run build
-      artifacts:
-        baseDirectory: /dist
-        files:
-          - '**/*'
-      cache:
-        paths:
-          - .pnpm-store/**/*
-    ```
-    </Fragment>
-    <Fragment slot="npm">
-    ```yaml
-    version: 1
-    frontend:
-      phases:
-        preBuild:
-          commands:
-            - npm ci
-        build:
-          commands:
-            - npm run build
-      artifacts:
-        baseDirectory: /dist
-        files:
-          - '**/*'
-      cache:
-        paths:
-          - node_modules/**/*
-
-    ```
-    </Fragment>
-    <Fragment slot="yarn">
-    ```yaml
-    version: 1
-    frontend:
-      phases:
-        preBuild:
-          commands:
-           - yarn install
-        build:
-          commands:
-            - yarn build
-      artifacts:
-        baseDirectory: /dist
-        files:
-          - '**/*'
-      cache:
-        paths:
-          - node_modules/**/*
-    ```
-    </Fragment>
-    </PackageManagerTabs>
-</Steps>
-
-Amplify desplegará automáticamente tu proyecto y lo actualizará al subir los cambios a tu repositorio.
-
-## Alojando contenido estático en S3
-
-S3 es el punto de partida de cualquier aplicación. Es donde se almacenan los archivos de tu proyecto. S3 cobra por el almacenamiento de archivos y la cantidad de solicitudes a estos archivos. Puedes encontrar más información sobre S3 en la [documentación de AWS](https://aws.amazon.com/s3/).
-
-<Steps>
-1. Crea un bucket en S3 con el nombre de tu proyecto.
-
-    :::tip
-    El nombre del bucket debe ser único globalmente. Recomendamos una combinación del nombre del proyecto y el dominio de tu proyecto.
-    :::
-
-2. Desactiva **"Block all public access"**. De forma predeterminada, AWS establece a todos los buckets como privados. Para hacerlo público, debes desmarcar la casilla de verificación "Block public access" en las propiedades del bucket.
-
-3. Carga los archivos construidos ubicados en `dist` a S3. Puedes hacerlo manualmente desde la consola o usar la CLI de AWS. Si usas la CLI utiliza el siguiente comando después de [autenticarte en AWS](https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-files.html):
-
-    ```
-    aws s3 cp dist/ s3://<BUCKET_NAME>/ --recursive
-    ```
-
-4. Actualiza la política del bucket para permitir acceso público. Puedes encontrar esta configuración en **Permissions > Bucket policy** del bucket.
-
-    ```json
-    {
-      "Version": "2012-10-17",
-      "Statement": [
-        {
-          "Sid": "PublicReadGetObject",
-          "Effect": "Allow",
-          "Principal": "*",
-          "Action": "s3:GetObject",
-          "Resource": "arn:aws:s3:::<BUCKET_NAME>/*"
-        }
-      ]
-    }
-    ```
-
-    :::caution
-    No olvides reemplazar `<BUCKET_NAME>` con el nombre de tu bucket.
-    :::
-
-5. Habilita el alojamiento de sitios web para tu bucket. Puedes encontrar esta configuración en **Properties > Static website hosting** del bucket. Establece el documento index a `index.html` y el documento error a `404.html`. Finalmente, puedes encontrar la URL de tu nuevo sitio web en **Properties > Static website hosting** del bucket.
-
-    :::note
-    Si estás desplegando una aplicación de una sola página (SPA), establece el documento de error a `index.html`.
-    :::
-</Steps>
-
-## S3 y CloudFront
-
-CloudFront es un servicio web que proporciona capacidades de red de entrega de contenido (CDN). Se utiliza para almacenar en caché el contenido de un servidor web y distribuirlo a los usuarios finales. CloudFront cobra por la cantidad de datos transferidos. Agregar CloudFront a tu bucket S3 es más rentable y proporciona una entrega más rápida.
-
-Para conectar S3 con CloudFront, crea una distribución de CloudFront con los siguientes valores:
-  - **Origin domain:** El endpint del sitio web estático de tu bucket de S3. Puedes encontrar tu endpint en **Properties > Static website hosting** de tu bucket de S3. Alternativamente, puedes seleccionar tu bucket de S3 y hacer clic en la llamada para reemplazar la dirección de tu bucket con el endpint estático de tu bucket.
-  - **Viewer protocol policy:** "Redirect to HTTPS"
-
-Esta configuración servirá tu sitio utilizando la red de CDN de CloudFront. Puedes encontrar la URL de distribución de CloudFront en la sección **Distributions > Domain name** del bucket.
-
-:::note
-Cuando conectas CloudFront a un endpoint de sitio web estático de S3, dependes de las políticas del bucket de S3 para el control de acceso. Consulta la sección de [Alojando contenido estático en S3](/es/guides/deploy/aws/#alojando-contenido-estático-en-s3) para obtener más información sobre las políticas del bucket.
-:::
-
-## Despliegue continuo con GitHub Actions
-
-Hay muchas formas de configurar despliegue continuo en AWS. Una posibilidad si el código está alojado en GitHub es usar [GitHub Actions](https://github.com/features/actions) que desplegará tu proyecto cada vez que hagas un push.
-
-<Steps>
-1. Crea una nueva política en tu cuenta de AWS utilizando [IAM](https://aws.amazon.com/iam/) con los siguientes permisos. Esta política te permitirá cargar los nuevos archivos en tu bucket de S3 e invalidar los archivos antiguos de la distribución de CloudFront al desplegar.
-
-    ```json
-    {
-      "Version": "2012-10-17",
-      "Statement": [
-          {
-              "Sid": "VisualEditor0",
-              "Effect": "Allow",
-              "Action": [
-                  "s3:PutObject",
-                  "s3:ListBucket",
-                  "s3:DeleteObject",
-                  "cloudfront:CreateInvalidation"
-              ],
-              "Resource": [
-                  "<DISTRIBUTION_ARN>",
-                  "arn:aws:s3:::<BUCKET_NAME>/*",
-                  "arn:aws:s3:::<BUCKET_NAME>"
-              ]
-          }
-      ]
-    }
-    ```
-
-    :::caution
-    No olvides reemplazar `<DISTRIBUTION_ARN>` y `<BUCKET_NAME>`. Puedes encontrar el DISTRIBUTION_ARN en **CloudFront > Distributions > Details**.
-    :::
-
-2. Crea un nuevo usuario de IAM y adjunta la política al usuario. Esto te proporcionará el `AWS_SECRET_ACCESS_KEY` y el `AWS_ACCESS_KEY_ID`.
-
-3. Agrega el siguiente workflow a tu repositorio en `.github/workflows/deploy.yml` y envíalo a GitHub. Deberás agregar `AWS_ACCESS_KEY_ID`, `AWS_SECRET_ACCESS_KEY`, `BUCKET_ID` y `DISTRIBUTION_ID` como "secrets" a tu repositorio en GitHub en **Settings** > **Secrets** > **Actions**. Haz clic en <kbd>New repository secret</kbd> para agregar cada uno.
-
-    ```yaml
-    name: Deploy Website
-
-    on:
-      push:
-        branches:
-          - main
-
-    jobs:
-      deploy:
-        runs-on: ubuntu-latest
-        steps:
-          - name: Checkout
-            uses: actions/checkout@v4
-          - name: Configure AWS Credentials
-            uses: aws-actions/configure-aws-credentials@v1
-            with:
-              aws-access-key-id: ${{ secrets.AWS_ACCESS_KEY_ID }}
-              aws-secret-access-key: ${{ secrets.AWS_SECRET_ACCESS_KEY }}
-              aws-region: us-east-1
-          - name: Install modules
-            run: npm ci
-          - name: Build application
-            run: npm run build
-          - name: Deploy to S3
-            run: aws s3 sync --delete ./dist/ s3://${{ secrets.BUCKET_ID }}
-          - name: Create CloudFront invalidation
-            run: aws cloudfront create-invalidation --distribution-id ${{ secrets.DISTRIBUTION_ID }} --paths "/*"
-    ```
-
-    :::note
-    El `BUCKET_ID` es el nombre del bucket de S3. El `DISTRIBUTION_ID` es el ID de la distribución de CloudFront. Puedes encontrar el ID de la distribución de CloudFront en **CloudFront > Distributions > ID**
-    :::
-</Steps>
-
-## Recursos de la comunidad
-
-- [Despliega Astro a AWS Amplify](https://www.launchfa.st/blog/deploy-astro-aws-amplify)
-- [Despliega Astro a AWS Elastic Beanstalk](https://www.launchfa.st/blog/deploy-astro-aws-elastic-beanstalk)
-- [Despliega Astro a Amazon ECS en AWS Fargate](https://www.launchfa.st/blog/deploy-astro-aws-fargate)
diff --git a/src/content/docs/es/guides/deploy/buddy.mdx b/src/content/docs/es/guides/deploy/buddy.mdx
deleted file mode 100644
index 426cf214fb9ed..0000000000000
--- a/src/content/docs/es/guides/deploy/buddy.mdx
+++ /dev/null
@@ -1,36 +0,0 @@
----
-title: Despliega tu proyecto de Astro con Buddy
-description: Cómo desplegar tu proyecto Astro usando Buddy.
-type: deploy
-i18nReady: true
----
-import { Steps } from '@astrojs/starlight/components';
-
-Puedes desplegar tu proyecto Astro usando [Buddy](https://buddy.works/), una solución de CI/CD que puede construir tu proyecto y enviarlo a muchos destinos de despliegue diferentes, incluidos servidores FTP y proveedores de alojamiento en la nube.
-
-:::note
-Buddy no alojará tu proyecto. Solo te ayudará a administrar el proceso de compilación y entregará el resultado a la plataforma de despliegue de tu elección.
-:::
-
-## Cómo desplegar
-
-<Steps>
-1. [Crea una cuenta en **Buddy**](https://buddy.works/sign-up).
-
-2. Crea un nuevo proyecto y conéctalo con un repositorio Git (GitHub, GitLab, BitBucket, cualquier repositorio Git privado o puedes usar Buddy Git Hosting).
-
-3. Agrega una nueva pipeline.
-
-4. En la pipeline recién creada, agrega una action para **[Node.js](https://buddy.works/actions/node-js)**.
-
-5. En esta action agrega:
-
-   ```bash
-   npm install
-   npm run build
-   ```
-
-6. Agrega una action de despliegue: hay muchas para elegir, puedes explorarlas en [el catálogo de acciones de Buddy](https://buddy.works/actions). Aunque tus configuraciones pueden diferir, recuerda configurar la **ruta de origen** en `dist`.
-
-7. Presiona el botón **Run**.
-</Steps>
diff --git a/src/content/docs/es/guides/deploy/cleavr.mdx b/src/content/docs/es/guides/deploy/cleavr.mdx
deleted file mode 100644
index c872aae501ba1..0000000000000
--- a/src/content/docs/es/guides/deploy/cleavr.mdx
+++ /dev/null
@@ -1,52 +0,0 @@
----
-title: Depliega tu proyecto Astro con Cleavr
-description: Cómo desplegar tu proyecto de Astro a tu servidor VPS usando Cleavr.
-type: deploy
-i18nReady: true
----
-import { Steps } from '@astrojs/starlight/components';
-
-Puedes desplegar tu proyecto Astro en tu propio Servidor Privado Virtual (VPS) usando [Cleavr](https://cleavr.io/), una herramienta de gestión de despliegues de servidores y aplicaciones.
-
-:::tip
-¡Revisa [la guía de Astro en la documentación de Cleavr](https://docs.cleavr.io/guides/astro)!
-:::
-
-## Prerrequisitos 
-
-Para comenzar, necesitarás:
-
-- Una cuenta de Cleavr
-- Un servidor en tu proveedor de VPS usando Cleavr
-
-## Agrega tu sitio
-
-<Steps>
-1. En Cleavr, navega al servidor al que quieres agregar tu proyecto Astro.
-
-2. Selecciona **Add Site** y completa los detalles de tu aplicación, como el nombre de dominio.
-
-3. En **App Type**, selecciona 'NodeJS Static' o 'NodeJS SSR' según cómo estés configurando tu aplicación de Astro.
-   
-4. Para las aplicaciones estáticas, establece **Artifact Folder** en `dist`.
-   
-5. Para las aplicaciones SSR:
-   - Establece **Entry Point** en `entry.mjs`.
-   - Establece **Artifact Folder** en `dist/server`.   
-
-6. Selecciona **Add** para agregar el sitio a tu servidor.
-</Steps>
-
-## Configuración y despliegue
-
-<Steps>
-1. Una vez que se haya agregado tu nuevo sitio, haz clic en **Setup and deploy**.
-   
-2. Selecciona el **VC Profile**, **Repo** y **Branch** para tu proyecto de Astro.
-   
-3. Realiza cualquier configuración adicional necesaria para tu proyecto.
-   
-4. Haz clic en la pestaña **Deployments** y luego haz clic en **Deploy**.
-</Steps>
-
-¡Felicitaciones, has desplegado tu aplicación de Astro!
diff --git a/src/content/docs/es/guides/deploy/cloudflare.mdx b/src/content/docs/es/guides/deploy/cloudflare.mdx
deleted file mode 100644
index c9bb7fd016553..0000000000000
--- a/src/content/docs/es/guides/deploy/cloudflare.mdx
+++ /dev/null
@@ -1,140 +0,0 @@
----
-title: Despliega tu proyecto de Astro en Cloudflare Pages
-description: Cómo desplegar tu proyecto de Astro usando Cloudflare Pages.
-type: deploy
-i18nReady: true
----
-import ReadMore from '~/components/ReadMore.astro';
-import { Steps } from '@astrojs/starlight/components';
-
-Puedes desplegar tu proyecto de Astro en [Cloudflare Pages](https://pages.cloudflare.com/), una plataforma para desarrolladores frontend para colaborar y desplegar sitios web estáticos (JAMstack) y con renderizado en el servidor (SSR).
-
-Esta guía incluye:
-
-- [Cómo desplegar a través del dashboard de Cloudflare Pages](#cómo-desplegar-un-proyecto-con-git)
-- [Cómo desplegar usando Wrangler, la CLI de Cloudflare](#cómo-desplegar-un-proyecto-usando-wrangler)
-- [Cómo desplegar un proyecto con SSR usando `@astrojs/cloudflare`](#cómo-desplegar-un-proyecto-con-ssr)
-
-## Prerrequisitos
-
-Para comenzar, necesitarás:
-
-- Una cuenta de Cloudflare. Si no tienes una, puedes crear una cuenta gratuita de Cloudflare durante el proceso.
-- Tu código alojado en un repositorio de [GitHub](https://github.com/) o [GitLab](https://about.gitlab.com/).
-
-## Cómo desplegar un proyecto con Git
-
-<Steps>
-1. Crea un nuevo proyecto en Cloudflare Pages.
-
-2. Sube tu código a un repositorio de git remoto (GitHub, GitLab).
-
-3. Inicia sesión en el dashboard de Cloudflare y selecciona tu cuenta en **Account Home** > **Workers & Pages** > **Overview**.
-
-4. Selecciona **Create application**, luego la pestaña **Pages** y después selecciona la opción **Connect to Git**.
-
-5. Selecciona el proyecto de git que quieres desplegar y haz clic en **Begin setup**
-
-6. Usa los siguientes ajustes de compilación:
-
-    - **Valor preestablecido del marco**: `Astro`
-    - **Comando de compilación:** `npm run build`
-    - **Crear directorio de salida:** `dist`
-
-7. Haz clic en el botón **Guardar e implementar**.
-</Steps>
-
-## Cómo desplegar un proyecto usando Wrangler
-
-<Steps>
-1. Instala [Wrangler CLI](https://developers.cloudflare.com/workers/wrangler/get-started/).
-
-2. Accede en Wrangler con tu cuenta de Cloudflare usando `wrangler login`.
-
-3. Ejecuta tu comando de compilación.
-
-4. Despliega usando `npx wrangler pages deploy dist`.
-</Steps>
-
-```bash
-# Instala Wrangler CLI
-npm install -g wrangler
-# Accede a tu cuenta de Cloudflare desde la CLI
-wrangler login
-# Ejecuta el comando de compilación
-npm run build
-# Crea un nuevo despliegue
-npx wrangler pages deploy dist
-```
-
-Una vez que tus archivos sean subidos, Wrangler te dará una preview URL para inspeccionar tu sitio. Cuando accedas al dashboard de Cloudflare Pages, verás tu nuevo proyecto.
-
-### Habilitando Preview localmente con Wrangler
-
-Para que preview funcione, debes instalar `wrangler`
-
-```bash
-pnpm add wrangler --save-dev
-```
-
-Entonces será posible actualizar el script preview para ejecutar `wrangler` en lugar del comando preview ya integrado en Astro:
-
-```json title="package.json"
-"preview": "wrangler pages dev ./dist"
-```
-
-## Cómo desplegar un proyecto con SSR
-
-Puedes construir un proyecto de Astro con SSR para desplegarlo en Cloudflare Pages usando el [adaptador `@astrojs/cloudflare`](/es/guides/integrations-guide/cloudflare/).
-
-Sigue los pasos a continuación para configurar el adaptador. Puedes desplegar usando cualquiera de las opciones mencionadas anteriormente.
-
-### Instalación rápida
-
-Añade el adaptador de Cloudflare que activa SSR en tu proyecto de Astro con el siguiente comando `astro add` que se muestra debajo. Este instalará el adaptador y hará los cambios apropiados a tu archivo `astro.config.mjs` en un solo paso.
-
-```bash
-npx astro add cloudflare
-```
-### Instalación manual
-
-Si prefieres instalar el adaptador manualmente, sigue los siguientes pasos:
-
-<Steps>
-1. Añadir el adaptador `@astrojs/cloudflare` a las dependencias de tu proyecto usando tu gestor de paquetes preferido. Si estás usando npm o no estás seguro, ejecuta esto en la terminal:
-
-
-    ```bash
-    npm install @astrojs/cloudflare
-    ```
-
-2. Añadir lo siguiente a tu archivo `astro.config.mjs`:
-
-    ```js title="astro.config.mjs" ins={2, 5-6}
-    import { defineConfig } from 'astro/config';
-    import cloudflare from '@astrojs/cloudflare';
-
-    export default defineConfig({
-      output: 'server',
-      adapter: cloudflare()
-    });
-    ```
-</Steps>
-
-<ReadMore>Aprende más sobre [SSR en Astro](/es/guides/on-demand-rendering/).</ReadMore>
-
-## Solución de problemas
-
-### Hidratación del lado del cliente
-
-La hidratación del lado del cliente puede fallar como resultado de la configuración de Auto Minify de Cloudflare. Si ves `Hydration completed but contains mismatches` en la consola, asegúrate de deshabilitar Auto Minify en la configuración de Cloudflare.
-
-### APIs de tiempo de ejecución de Node.js
-
-Si estás construyendo un proyecto que está usando renderizado bajo demanda con [el Adaptador de SSR de Cloudflare](/es/guides/integrations-guide/cloudflare/) y el servidor falla en construir con un mensaje de error como `[Error] Could not resolve "XXXX. The package "XXXX" wasn't found on the file system but is built into node.`:
-
-- Esto significa que un paquete o importación que estás utilizando en el entorno del lado del servidor no es compatible con las [APIs de tiempo de ejecución de Cloudflare](https://developers.cloudflare.com/workers/runtime-apis/nodejs/).
-
-- Si estás importando directamente una API de tiempo de ejecución de Node.js, por favor consulta la documentación de Astro en [compatibilidad con Node.js](/es/guides/integrations-guide/cloudflare/#compatibilidad-con-nodejs) de Cloudflare para conocer los pasos adicionales sobre como resolver esto.
-
-- Si estás importando un paquete que importa una API de tiempo de ejecución de Node.js, verifica con el autor del paquete si admiten la sintaxis de importación `node:*`. Si no lo hacen, es posible que necesites encontrar un paquete alternativo.
diff --git a/src/content/docs/es/guides/deploy/deno.mdx b/src/content/docs/es/guides/deploy/deno.mdx
deleted file mode 100644
index 1b9cb29897c96..0000000000000
--- a/src/content/docs/es/guides/deploy/deno.mdx
+++ /dev/null
@@ -1,184 +0,0 @@
----
-title: Despliega tu proyecto de Astro con Deno
-description: Cómo desplegar tu proyecto de Astro en la web utilizando Deno.
-type: deploy
-i18nReady: true
----
-import ReadMore from '~/components/ReadMore.astro';
-import { Steps } from '@astrojs/starlight/components';
-
-Puedes desplegar tu proyecto de Astro con renderizado en el servidor (SSR) en [Deno Deploy](https://deno.com/deploy), un sistema distribuido que ejecuta JavaScript, TypeScript y WebAssembly en el edge, alrededor del mundo.
-
-Esta guía incluye instrucciones para desplegar en Deno Deploy a través de GitHub Actions o de la CLI de Deno Deploy.
-
-## Requisitos
-
-Esta guía supone que ya tienes instalado [Deno](https://deno.com/).
-
-## Configuración del proyecto
-
-Esta página proporciona instrucciones para desplegar tu proyecto de Astro en [Deno Deploy](https://deno.com/deploy) como un sitio renderizado en el servidor (SSR).
-
-Para desplegar un sitio estático, consulta [el tutorial de Deno Deploy para sitios estáticos](https://docs.deno.com/deploy/tutorials/static-site).
-
-### Adaptador para SSR
-
-Para activar SSR en tu proyecto de Astro y desplegarlo en Deno Deploy:
-
-Añadir [el adaptador de Deno][Deno adapter] para activar SSR en tu proyecto de Astro con el siguiente comando `astro add` que se muestra debajo. Este instalará el adaptador y hará los cambios apropiados a tu archivo `astro.config.mjs` en un solo paso.
-
-
-```bash
-npx astro add deno
-```
-
-Si prefieres instalar el adaptador manualmente, sigue los siguientes dos pasos:
-
-<Steps>
-1. Añadir [el adaptador `@deno/astro-adapter`][Deno adapter] a las dependencias de tu proyecto usando tu gestor de paquetes preferido. Si estás usando npm o no estás seguro, ejecuta esto en la terminal:
-
-    ```bash
-      npm install @deno/astro-adapter
-    ```
-
-2. Actualiza el archivo de configuración del proyecto `astro.config.mjs` con los cambios a continuación.
-
-    ```js ins={3,6-7}
-    // astro.config.mjs
-    import { defineConfig } from 'astro/config';
-    import deno from '@deno/astro-adapter';
-
-    export default defineConfig({
-      output: 'server',
-      adapter: deno(),
-    });
-    ```
-
-    Luego, actualiza el script `preview` en `package.json` con el siguiente cambio.
-
-    ```json del={8} ins={9}
-    // package.json
-    {
-      // ...
-      "scripts": {
-        "dev": "astro dev",
-        "start": "astro dev",
-        "build": "astro build",
-        "preview": "astro preview"
-        "preview": "deno run --allow-net --allow-read --allow-env ./dist/server/entry.mjs"
-      }
-    }
-    ```
-
-    Ahora puedes utilizar este comando para previsualizar tu proyecto de Astro en producción localmente con Deno.
-
-    ```bash
-    npm run preview
-    ```
-</Steps>
-
-## Cómo desplegar un sitio de Astro SSR
-
-Puedes desplegar en Deno Deploy a través de GitHub Actions o utilizando la CLI (interfaz de línea de comandos) de Deno Deploy.
-
-### Despliegue con GitHub Actions
-
-Si tu proyecto está almacenado en GitHub, la [página web de Deno Deploy](https://dash.deno.com/) te guiará en la configuración de GitHub Actions para desplegar tu proyecto de Astro.
-
-<Steps>
-1. Sube tu código a un repositorio público o privado de GitHub.
-
-2. Inicia sesión en [Deno Deploy](https://dash.deno.com/) con tu cuenta de GitHub y haz clic en [New Project](https://dash.deno.com).
-
-3. Selecciona tu repositorio, la rama desde la que quieres desplegar, y selecciona el modo **GitHub Action**. (Tu proyecto de Astro requiere un paso de construcción, y no puede usar el modo Automático).
-
-4. En tu proyecto de Astro, crea un nuevo archivo en `.github/workflows/deploy.yml` y pega el YAML a continuación. Esto es similar al YAML dado por Deno Deploy, con los pasos adicionales necesarios para tu proyecto de Astro.
-
-    ```yaml
-    name: Deploy
-    on: [push]
-
-    jobs:
-      deploy:
-        name: Deploy
-        runs-on: ubuntu-latest
-        permissions:
-          id-token: write # Necesario para la autentificación con Deno Deploy
-          contents: read # Necesario para clonar el repositorio
-
-        steps:
-          - name: Clonar el repositorio
-            uses: actions/checkout@v4
-
-          # ¿No usas npm? Cambia `npm ci` por `yarn install` o `pnpm i`.
-          - name: Instalar las dependencias
-            run: npm ci
-
-          # ¿No usas npm? Cambia `npm run build` por `yarn build` o `pnpm run build`.
-          - name: Construir Astro
-            run: npm run build
-
-          - name: Subir a Deno Deploy
-            uses: denoland/deployctl@v1
-            with:
-              project: my-deno-project # TODO: sustituir por el nombre del proyecto Deno Deploy
-              entrypoint: server/entry.mjs
-              root: dist
-    ```
-
-5. Después de hacer commit de este archivo YAML, y de subir a GitHub en tu rama de despliegue configurada, ¡el despliegue comenzará automáticamente!
-
-   Puedes seguir el progreso utilizando la pestaña "Actions" de tu repositorio de GitHub, o en [Deno Deploy](https://dash.deno.com).
-</Steps>
-
-### Despliegue con la CLI
-
-<Steps>
-1. Instala la [Deno Deploy CLI](https://docs.deno.com/deploy/manual/deployctl).
-
-    ```bash
-    deno install --allow-read --allow-write --allow-env --allow-net --allow-run --no-check -r -f https://deno.land/x/deploy/deployctl.ts
-    ```
-
-2. Ejecuta el paso de construcción de tu proyecto de Astro.
-
-    ```bash
-    npm run build
-    ```
-
-3. ¡Ejecuta `deployctl` para desplegar!
-
-   En el siguiente comando, sustituye `<ACCESS-TOKEN>` por tu [Token de Acceso Personal](https://dash.deno.com/account#access-tokens) y `<MY-DENO-PROJECT>` por el nombre de tu proyecto en Deno Deploy.
-
-    ```bash
-    DENO_DEPLOY_TOKEN=<ACCESS-TOKEN> deployctl deploy --project=<MY-DENO-PROJECT> --no-static --include=./dist ./dist/server/entry.mjs
-    ```
-
-    Puedes seguir todos tus despliegues en [Deno Deploy](https://dash.deno.com).
-
-4. (Opcional) Para simplificar la construcción y el despliegue en un solo comando, añade un script `deploy-deno` en `package.json`.
-
-    ```json ins={9}
-    // package.json
-    {
-      // ...
-      "scripts": {
-        "dev": "astro dev",
-        "start": "astro dev",
-        "build": "astro build",
-        "preview": "deno run --allow-net --allow-read --allow-env ./dist/server/entry.mjs",
-        "deno-deploy": "npm run build && deployctl deploy --project=<MY-DENO-PROJECT> --no-static --include=./dist ./dist/server/entry.mjs"
-      }
-    }
-    ```
-
-    Entonces puedes usar este comando para construir y desplegar tu sitio Astro en un solo paso.
-
-    ```bash
-    DENO_DEPLOY_TOKEN=<ACCESS-TOKEN> npm run deno-deploy
-    ```
-</Steps>
-
-<ReadMore>Lee más sobre [SSR en Astro](/es/guides/on-demand-rendering/).</ReadMore>
-
-[Deno adapter]: https://github.com/denoland/deno-astro-adapter
diff --git a/src/content/docs/es/guides/deploy/flightcontrol.mdx b/src/content/docs/es/guides/deploy/flightcontrol.mdx
deleted file mode 100644
index de6125ac4cf7b..0000000000000
--- a/src/content/docs/es/guides/deploy/flightcontrol.mdx
+++ /dev/null
@@ -1,33 +0,0 @@
----
-title: Despliega tu proyecto de Astro en AWS con Flightcontrol
-description: Cómo desplegar tu proyecto de Astro en AWS con Flightcontrol
-type: deploy
-i18nReady: true
----
-import { Steps } from '@astrojs/starlight/components';
-
-Puedes desplegar tu proyecto de Astro utilizando [Flightcontrol](https://www.flightcontrol.dev?ref=astro), que proporciona despliegues totalmente automatizados en tu cuenta de AWS.
-
-Es compatible con sitios estáticos y SSR.
-
-# ¿Cómo desplegar?
-
-<Steps>
-1. Crea una cuenta de Flightcontrol en [app.flightcontrol.dev/signup](https://app.flightcontrol.dev/signup?ref=astro).
-
-2. Ve a [app.flightcontrol.dev/projects/new/1](https://app.flightcontrol.dev/projects/new/1).
-
-3. Conecta tu cuenta de GitHub y selecciona tu repositorio.
-
-4. Selecciona el "Tipo de configuración" deseado:
-    - `GUI` (toda la configuración administrada a través de flightcontrol dashboard) donde seleccionará el preajuste `Astro Static` o `Astro SSR`
-    - `flightcontrol.json` (opción "infraestructura como código" donde toda la configuración está alojada en tu repositorio) donde seleccionará una configuración ejemplo de Astro, luego la agregará al repositorio como `flightcontrol.json`.
-
-5. Ajusta cualquier configuración según sea necesario.
-
-6. Haz clic en "Crear proyecto" y completa los pasos necesarios, como vincular su cuenta de AWS.
-</Steps>
-
-### Configuración SSR
-
-Para desplegar tu proyecto como SSR, asegúrate de configurar primero el adaptador [`@astrojs/node`](/es/guides/integrations-guide/node/). Luego, siga los pasos anteriores para elegir las configuraciones apropiadas para Astro SSR.
diff --git a/src/content/docs/es/guides/deploy/flyio.mdx b/src/content/docs/es/guides/deploy/flyio.mdx
deleted file mode 100644
index b30729dbe6759..0000000000000
--- a/src/content/docs/es/guides/deploy/flyio.mdx
+++ /dev/null
@@ -1,48 +0,0 @@
----
-title: Despliega tu sitio de Astro en Fly.io
-description: Como desplegar tu sitio de Astro en la web utilizando Fly.io.
-type: deploy
-i18nReady: true
-stub: true
----
-import { Steps } from '@astrojs/starlight/components';
-
-Puedes desplegar tu proyecto de Astro en [Fly.io](https://fly.io/), una plataforma para ejecutar aplicaciones full stack y bases de datos cerca de tus usuarios.
-
-## Configuración del proyecto
-
-Tu proyecto de Astro puede ser desplegado en Fly.io como un sitio estático, o como un sitio renderizado en el servidor (SSR).
-
-### Sitio Estático
-
-Por defecto tu proyecto de Astro es un sitio estático. No necesitas ninguna configuración adicional para desplegar un sitio estático de Astro en Fly.io.
-
-### Adaptador para SSR
-
-Para habilitar el renderizado bajo demanda en tu proyecto de Astro y desplegarlo en Fly.io, agrega [el adaptador de Node.js](/es/guides/integrations-guide/node/).
-
-## ¿Cómo desplegar?
-
-<Steps>
-1. [Regístrate en Fly.io](https://fly.io/docs/getting-started/log-in-to-fly/#first-time-or-no-fly-account-sign-up-for-fly) si aún no lo has hecho.
-
-2. [Instala `flyctl`](https://fly.io/docs/hands-on/install-flyctl/), tu centro de comandos de aplicaciones Fly.io.
-
-3. Ejecuta el siguiente comando en tu terminal.
-
-    ```bash
-    fly launch
-    ```
-
-	`flyctl` detectará automáticamente Astro, configurará los ajustes correctos, construirá tu imagen y la desplegará en la plataforma Fly.io.
-</Steps>
-
-## Generando tu Dockerfile para Astro.
-
-Si aún no tienes un Dockerfile, `fly launch` lo generará por ti, además de preparar un archivo `fly.toml`. Para proyectos `server` o `hybrid`, este Dockerfile incluirá el comando de inicio apropiado y las variables de entorno.
-
-También puedes crear tu propio Dockerfile utilizando el [generador de Dockerfile](https://www.npmjs.com/package/@flydotio/dockerfile) y luego ejecutarlo usando el comando `npx dockerfile` para aplicaciones de Node o `bunx dockerfile` para aplicaciones de Bun.
-
-## Recursos oficiales
-
-- Echa un vistazo a [la documentación oficial de Fly.io](https://fly.io/docs/js/frameworks/astro/)
\ No newline at end of file
diff --git a/src/content/docs/es/guides/deploy/gitlab.mdx b/src/content/docs/es/guides/deploy/gitlab.mdx
deleted file mode 100644
index 7a817bbe505e3..0000000000000
--- a/src/content/docs/es/guides/deploy/gitlab.mdx
+++ /dev/null
@@ -1,120 +0,0 @@
----
-title: Despliega tu proyecto de Astro en GitLab Pages
-description: Cómo desplegar tu proyecto de Astro usando GitLab Pages.
-type: deploy
-i18nReady: true
----
-import { Steps } from '@astrojs/starlight/components';
-
-Puedes usar [GitLab Pages](https://docs.gitlab.com/ee/user/project/pages/) para alojar un proyecto de Astro para tu proyecto, grupo, o cuenta de usuario en [GitLab](https://about.gitlab.com/).
-
-:::tip[¿Buscas un ejemplo?]
-¡Revisa [el proyecto de ejemplo de Astro en GitLab Pages](https://gitlab.com/pages/astro)!
-:::
-
-## Cómo desplegar
-
-Puede desplegar un sitio de Astro en GitLab Pages usando GitLab CI/CD para construir y desplegar automáticamente tu sitio. Para hacer esto, tu código fuente debe estar alojado en GitLab y necesitas hacer los siguientes cambios en tu proyecto de Astro:
-
-<Steps>
-1. Establece las opciones [`site`](/es/reference/configuration-reference/#site) y [`base`](/es/reference/configuration-reference/#base) en `astro.config.mjs`.
-
-    ```js title="astro.config.mjs" ins={4-5}
-    import { defineConfig } from 'astro/config';
-
-    export default defineConfig({
-      site: 'https://<username>.gitlab.io',
-      base: '/<my-repo>',
-      outDir: 'public',
-      publicDir: 'static',
-    });
-    ```
-
-    `site`
-
-    El valor para `site` debe ser uno de los siguientes:
-
-    - El siguiente URL basado en el nombre de tu grupo: `https://<groupname>.gitlab.io`
-    - El siguiente URL basado en tu nombre de usuario: `https://<username>.gitlab.io`
-    - Tu dominio personalizado si lo tienes configurado en la configuración de tu proyecto de GitLab: `https://example.com`
-
-    Para instancias auto-alojadas de GitLab, reemplaza `gitlab.io` con el dominio de Pages de tu instancia.
-
-    `base`
-
-    Un valor para `base` puede ser requerido para que Astro trate el nombre de tu repositorio (por ejemplo, `/mi-repo`) como la raíz de tu sitio web.
-
-    :::note
-      No establezcas un parámetro `base` si tu página se sirve desde la carpeta raíz.
-    :::
-
-    El valor para `base` debe ser el nombre de tu repositorio comenzando con una barra diagonal, por ejemplo `/mi-blog`. Esto es para que Astro entienda que la raíz de tu sitio web es `/mi-repo`, en lugar de la raíz predeterminada `/`.
-
-    :::caution
-        Cuando este valor está configurado, todos los enlaces internos de tus páginas deben tener el prefijo de tu valor `base`:
-
-      ```astro ins="/my-repo"
-      <a href="/my-repo/about">Acerca</a>
-      ```
-
-    Ver más sobre [configurar un valor `base`](/es/reference/configuration-reference/#base)
-    :::
-
-2. Renombra el directorio `public/` a `static/`.
-
-3. Establece `outDir: 'public'` en `astro.config.mjs`. Esta configuración indica a Astro que coloque la salida de la compilación estática en una carpeta llamada `public`, que es la carpeta requerida por GitLab Pages para los archivos expuestos.
-
-   Si estás usando el [directorio `public/`](/es/basics/project-structure/#public) como fuente de archivos estáticos en tu proyecto de Astro, renombralo y usa ese nuevo nombre del directorio en `astro.config.mjs` para el valor de `publicDir`.
-
-   Por ejemplo, estos son los ajustes correctos de `astro.config.mjs` cuando el directorio `public/` es renombrado a `static/`:
-
-   ```js title="astro.config.mjs" ins={4-5}
-   import { defineConfig } from 'astro/config';
-
-   export default defineConfig({
-     outDir: 'public',
-     publicDir: 'static',
-   });
-   ```
-
-4. Cambia la salida de la compilación en `.gitignore`. En nuestro ejemplo necesitamos cambiar `dist/` a `public/`:
-
-    ```diff  title=".gitignore"
-    # build output
-    -dist/
-    +public/
-    ```
-
-5. Crea un archivo llamado `.gitlab-ci.yml` en la raíz de tu proyecto con el contenido a continuación. Esto construirá y desplegará tu sitio cada vez que hagas cambios en tu contenido:
-
-   ```yaml title=".gitlab-ci.yml"
-   pages:
-     # La imagen de Docker que se usará para construir tu app
-     image: node:lts
-
-     before_script:
-       - npm ci
-
-     script:
-       # Especifica los pasos involucrados para construir tu app aquí
-       - npm run build
-
-     artifacts:
-       paths:
-         # El directorio que contiene los archivos construidos para ser publicados.
-         # Debe llamarse "public".
-         - public
-
-     only:
-       # Activa una nueva compilación y despliega solo cuando haya un push a la
-       # rama(s) a continuación
-       - main
-   ```
-
-6. Haz un commit de tus cambios y súbelos a GitLab.
-
-7. En GitLab, ve al menú **Deploy** de tu repositorio y selecciona **Pages**. Aquí verás la URL completa de tu sitio web de GitLab Pages. Para asegurarte de que estás usando el formato de URL `https://username.gitlab.io/my-repo`, desmarca la configuración **Use unique domain** en esta página.
-
-</Steps>
-
-¡Tu sitio debería estar publicado! Cuando hagas cambios en tu repositorio de proyecto de Astro, el pipeline CI/CD de GitLab los desplegará automáticamente para ti. 
diff --git a/src/content/docs/es/guides/deploy/google-cloud.mdx b/src/content/docs/es/guides/deploy/google-cloud.mdx
deleted file mode 100644
index 8e01975e29758..0000000000000
--- a/src/content/docs/es/guides/deploy/google-cloud.mdx
+++ /dev/null
@@ -1,87 +0,0 @@
----
-title: Despliega tu proyecto de Astro en Google Cloud
-description: Cómo desplegar tu proyecto de Astro usando Google Cloud.
-type: deploy
-i18nReady: true
----
-import { Steps } from '@astrojs/starlight/components';
-
-[Google Cloud](https://cloud.google.com/?hl=es-419) es una plataforma integral de alojamiento, que puede ser usada para desplegar un proyecto de Astro.
-
-## Cómo desplegar
-
-### Cloud Storage (solo estático)
-
-<Steps>
-1. [Crea un nuevo proyecto GCP](https://console.cloud.google.com/projectcreate), o selecciona uno que ya tengas.
-
-2. Crea un nuevo bucket dentro de [Cloud Storage](https://cloud.google.com/storage?hl=es-419).
-
-3. Asígnale un nombre y completa otros ajustes requeridos.
-
-4. Sube tu directorio `dist` en él o súbelo usando [Cloud Build](https://cloud.google.com/build?hl=es-419).
-
-5. Habilita el acceso público añadiendo un nuevo permiso a `allUsers` llamado `Storage Object Viewer`.
-
-6. Edita la configuración de sitio y agrega el `ìndex.html` como punto de entrada y el `404.html` como página de error.
-</Steps>
-
-### Cloud Run (SSR y estático)
-
-Cloud Run es una plataforma sin servidor que te permite ejecutar un contenedor sin tener que administrar ninguna infraestructura. Puede ser usada para desplegar sitios estáticos y SSR.
-
-#### Prepara el servicio
-
-<Steps>
-1. [Crea un nuevo proyecto GCP](https://console.cloud.google.com/projectcreate), o selecciona uno que ya tengas.
-
-2. Asegúrate de que la [API de Cloud Run](https://console.cloud.google.com/apis/library/run.googleapis.com) esté habilitada.
-
-3. Crea un nuevo servicio.
-</Steps>
-
-#### Crea un Dockerfile y Compila el Contenedor
-
-Antes de que puedas desplegar tu sitio de Astro en Cloud Run, necesitas crear un Dockerfile que se usará para construir el contenedor. Encuentra más información sobre [cómo usar Docker con Astro](/es/recipes/docker/#creando-un-dockerfile) en nuestra sección de recetas.
-
-Una vez que el Dockerfile está creado, compílalo en una imagen y súbelo a Google Cloud. Hay varias formas de lograrlo:
-
-**Compila localmente usando Docker**:
-
-Usa el comando `docker build` para compilar la imagen, `docker tag` para darle una etiqueta, y `docker push` para subirla a un registro. En el caso de Google Cloud, [`Artifact Registry`](https://cloud.google.com/artifact-registry/docs/docker/pushing-and-pulling?hl=es-419) es la opción más fácil, pero también puedes usar [Docker Hub](https://hub.docker.com/).
-
-```bash
-# compila tu contenedor
-docker build .
-
-docker tag SOURCE_IMAGE HOSTNAME/PROJECT-ID/TARGET-IMAGE:TAG
-
-# Empuja tu imagen a un registro
-docker push HOSTNAME/PROJECT-ID/IMAGE:TAG
-```
-
-Cambia los valores siguientes en los comandos anteriores para que coincidan con tu proyecto:
-
-- `SOURCE_IMAGE`: el nombre de la imagen local o el ID de la imagen.
-- `HOSTNAME`: el host del registro (`gcr.io`, `eu.gcr.io`, `asia.gcr.io`, `us.gcr.io`).
-- `PROJECT`: el ID de tu proyecto de Google Cloud.
-- `TARGET-IMAGE`: el nombre para la imagen cuando se almacena en el registro.
-- `TAG` es la versión asociada con la imagen.
-
-[Lee más en la documentación de Google Cloud.](https://cloud.google.com/artifact-registry/docs/docker/pushing-and-pulling?hl=es-419)
-
-**Usando otra herramienta**:
-
-Puedes usar una herramienta de CI/CD que soporte Docker, como [GitHub Actions](https://github.com/marketplace/actions/push-to-gcr-github-action).
-
-**Compilar usando [Cloud Build](https://cloud.google.com/build?hl=es-419)**:
-
-En vez de compilar el Dockerfile localmente, puedes instruir a Google Cloud a compilar la imagen de forma remota. Consulta la [documentación de Google Cloud Build aquí](https://cloud.google.com/build/docs/build-push-docker-image).
-
-#### Desplegando el contenedor
-
-El despliegue puede ser manejado manualmente en tu terminal [usando `gcloud`](https://cloud.google.com/run/docs/deploying#service) o automáticamente usando [Cloud Build](https://cloud.google.com/build) o cualquier otro sistema de CI/CD.
-
-:::note[¿Necesitas acceso público?]
-¡No olvides agregar el permiso `Cloud Run Invoker` al grupo `allUsers` en la configuración de permisos de Cloud Run!
-:::
diff --git a/src/content/docs/es/guides/deploy/google-firebase.mdx b/src/content/docs/es/guides/deploy/google-firebase.mdx
deleted file mode 100644
index 02bbf7be8dfa5..0000000000000
--- a/src/content/docs/es/guides/deploy/google-firebase.mdx
+++ /dev/null
@@ -1,132 +0,0 @@
----
-title: Despliega tu proyecto de Astro usando Firebase Hosting de Google
-description: Cómo desplegar tu proyecto de Astro usando Firebase Hosting de Google.
-type: deploy
-i18nReady: true
----
-import { Steps } from '@astrojs/starlight/components';
-import PackageManagerTabs from '~/components/tabs/PackageManagerTabs.astro';
-
-[Firebase Hosting](https://firebase.google.com/products/hosting) es un servicio provisto por la plataforma de desarrollo de Google [Firebase](https://firebase.google.com/), el cual puede ser usado para desplegar un proyecto de Astro.
-
-Consulta nuestra guía para [desplegar en el servicio de Hosteo de Firebase](/es/guides/backend/google-firebase/).
-
-## Configuración de proyecto
-
-Tu proyecto de Astro puede ser desplegado en Firebase como un sitio estático o como un sitio renderizado del lado del servidor (SSR).
-
-### Sitio estático
-
-Tu proyecto de Astro es un sitio estático por defecto. No necesitas ninguna configuración extra para desplegar un sitio estático de Astro en Firebase.
-
-### Adaptador para SSR
-
-Para habilitar SSR en tu proyecto de Astro y desplegarlo en Firebase, agrega el [adaptador de Node.js](/es/guides/integrations-guide/node/).
-
-:::note
-Desplegar un sitio SSR de Astro en Firebase requiere el [plan Blaze](https://firebase.google.com/pricing) o superior.
-:::
-
-## ¿Cómo desplegar?
-
-<Steps>
-1. Instala la [CLI de Firebase](https://github.com/firebase/firebase-tools). Esta es una herramienta de línea de comandos que te permite interactuar con Firebase desde la terminal.
-
-    <PackageManagerTabs>
-      <Fragment slot="npm">
-      ```shell
-      npm install firebase-tools
-      ```
-      </Fragment>
-      <Fragment slot="pnpm">
-      ```shell
-      pnpm add firebase-tools
-      ```
-      </Fragment>
-      <Fragment slot="yarn">
-      ```shell
-      yarn add firebase-tools
-      ```
-      </Fragment>
-    </PackageManagerTabs>
-
-2. Autentica la CLI de Firebase con tu cuenta de Google. Esto abrirá una ventana de navegador donde puedes iniciar sesión con tu cuenta de Google.
-
-    <PackageManagerTabs>
-      <Fragment slot="npm">
-      ```shell
-      npx firebase login
-      ```
-      </Fragment>
-      <Fragment slot="pnpm">
-      ```shell
-      pnpm exec firebase login
-      ```
-      </Fragment>
-      <Fragment slot="yarn">
-      ```shell
-      yarn firebase login
-      ```
-      </Fragment>
-    </PackageManagerTabs>
-
-3. Habilita el soporte experimental para frameworks web. Esta es una característica experimental que permite a la CLI de Firebase detectar y configurar los ajustes de despliegue para Astro.
-
-    <PackageManagerTabs>
-      <Fragment slot="npm">
-      ```shell
-      npx firebase experiments:enable webframeworks
-      ```
-      </Fragment>
-      <Fragment slot="pnpm">
-      ```shell
-      pnpm exec firebase experiments:enable webframeworks
-      ```
-      </Fragment>
-      <Fragment slot="yarn">
-      ```shell
-      yarn firebase experiments:enable webframeworks
-      ```
-      </Fragment>
-    </PackageManagerTabs>
-
-4. Inicializa el servicio de Alojamiento de Firebase en tu proyecto. Esto creará un archivo `firebase.json` y `.firebaserc` en la raíz de tu proyecto.
-
-    <PackageManagerTabs>
-      <Fragment slot="npm">
-      ```shell
-      npx firebase init hosting
-      ```
-      </Fragment>
-      <Fragment slot="pnpm">
-      ```shell
-      pnpm exec firebase init hosting
-      ```
-      </Fragment>
-      <Fragment slot="yarn">
-      ```shell
-      yarn firebase init hosting
-      ```
-      </Fragment>
-    </PackageManagerTabs>
-
-5. Despliega tu sitio en el servicio de Alojamiento de Firebase. Esto construirá tu sitio de Astro y lo desplegará en Firebase.
-
-    <PackageManagerTabs>
-      <Fragment slot="npm">
-      ```shell
-      npx firebase deploy --only hosting
-      ```
-      </Fragment>
-      <Fragment slot="pnpm">
-      ```shell
-      pnpm exec firebase deploy --only hosting
-      ```
-      </Fragment>
-      <Fragment slot="yarn">
-      ```shell
-      yarn firebase deploy --only hosting
-      ```
-      </Fragment>
-    </PackageManagerTabs>
-</Steps>
\ No newline at end of file
diff --git a/src/content/docs/es/guides/deploy/heroku.mdx b/src/content/docs/es/guides/deploy/heroku.mdx
deleted file mode 100644
index 697dfcd5008b9..0000000000000
--- a/src/content/docs/es/guides/deploy/heroku.mdx
+++ /dev/null
@@ -1,62 +0,0 @@
----
-title: Despliega tu proyecto de Astro en Heroku
-description: Cómo desplegar tu proyecto de Astro usando Heroku.
-type: deploy
-i18nReady: true
----
-import { Steps } from '@astrojs/starlight/components';
-
-[Heroku](https://www.heroku.com/) es una platform-as-a-service para construir, ejecutar, y administrar aplicaciones modernas en la nube. Puedes desplegar un proyecto de Astro en Heroku usando esta guía.
-
-:::danger
-Las siguientes instrucciones usan [el paquete obsoleto `heroku-static-buildpack`](https://github.com/heroku/heroku-buildpack-static#warning-heroku-buildpack-static-is-deprecated). Por favor consulta la [documentación de Heroku para usar `heroku-buildpack-nginx`](https://github.com/dokku/heroku-buildpack-nginx) en su lugar.
-:::
-
-## ¿Cómo desplegar?
-
-<Steps>
-1. Instala la [CLI de Heroku](https://devcenter.heroku.com/articles/heroku-cli).
-
-2. Crea una cuenta en [Heroku](https://signup.heroku.com/).
-
-3. Ejecuta `heroku login` e ingresa tus credenciales de Heroku:
-
-   ```bash
-   $ heroku login
-   ```
-
-4. Crea un archivo llamado `static.json` en la raíz de tu proyecto con el siguiente contenido:
-
-   ```json title="static.json"
-   {
-     "root": "./dist"
-   }
-   ```
-
-   Esta es la configuración de tu proyecto; aprende más en [heroku-buildpack-static](https://github.com/heroku/heroku-buildpack-static).
-
-5. Configura tu repositorio remoto en Heroku:
-
-   ```bash
-   # cambio en la versión
-   $ git init
-   $ git add .
-   $ git commit -m "My site ready for deployment."
-
-   # crea una nueva app con un nombre en específico
-   $ heroku apps:create example
-
-   # establece buildpack para sitios estáticos
-   $ heroku buildpacks:set https://github.com/heroku/heroku-buildpack-static.git
-   ```
-
-6. Despliega tu proyecto:
-
-   ```bash
-   # publica el sitio
-   $ git push heroku master
-
-   # abre una ventana del navegador para ver el dashboard de la CLI de Heroku
-   $ heroku open
-   ```
-</Steps>
\ No newline at end of file
diff --git a/src/content/docs/es/guides/deploy/index.mdx b/src/content/docs/es/guides/deploy/index.mdx
deleted file mode 100644
index ab2a737d10801..0000000000000
--- a/src/content/docs/es/guides/deploy/index.mdx
+++ /dev/null
@@ -1,118 +0,0 @@
----
-title: Despliega tu sitio Astro
-description: Cómo desplegar tu sitio Astro en la web.
-i18nReady: true
----
-import DeployGuidesNav from '~/components/DeployGuidesNav.astro';
-import PackageManagerTabs from '~/components/tabs/PackageManagerTabs.astro'
-import { Steps } from '@astrojs/starlight/components'
-
-**¿Listo para construir y desplegar tu proyecto Astro?** Sigue una de nuestras guías para diferentes servicios de despliegue o desplázate hacia abajo para obtener orientación general sobre el despliegue de un proyecto de Astro.
-
-## Guías de despliegue
-
-<DeployGuidesNav />
-
-## Opciones de despliegue rápido
-
-Puedes crear y desplegar tu proyecto de Astro en varias plataformas rápidamente utilizando la interfaz de usuario (UI) en su página web o la interfaz de línea de comando (CLI).
-
-### Web UI
-
-Una forma rápida de desplegar tu página web es conectar un repositorio de Git remoto a tu proyecto de Astro (por ejemplo, GitHub, GitLab, Bitbucket) a un servicio de hosting y aprovechar continuous integration con Git.
-
-Estas plataformas de hosting detectan automáticamente los cambios en el repositorio de origen de tu proyecto de Astro, construyen tu proyecto y lo despliegan en una URL personalizada o en tu dominio personal. A menudo, configurar el despliegue en estas plataformas seguirá pasos como los siguientes:
-
-<Steps>
-1. Agrega tu repositorio a un repositorio remoto de Git (por ejemplo, en GitHub, GitLab, Bitbucket)
-
-2. Elige un host que admita **continuous integration** (por ejemplo, [Netlify](/es/guides/deploy/netlify/) o [Vercel](/es/guides/deploy/vercel/)) e importa tu repositorio Git como un nuevo sitio/proyecto.
-
-    Muchos hosts comunes reconocerán su proyecto como un sitio de Astro y elegirán los ajustes de configuración apropiados para construir y desplegar tu proyecto como se muestra a continuación. (De lo contrario, estos ajustes se pueden cambiar).
-
-    :::note[Configuración de implementación]
-    - **Comando de construcción:** `astro build` o `npm run build`
-    - **Directorio de publicación:** `dist`
-    :::
-
-3. Haz clic en "Desplegar" y tu nuevo sitio web se creará en una URL única para ese host (por ejemplo, `new-astro-site.netlify.app`).
-</Steps>
-
-El host se configurará automáticamente para observar la rama principal del repositorio de Git en busca de cambios, para reconstruir y volver a publicar tu proyecto en cada push. Estos ajustes normalmente se pueden configurar en la UI del panel de control de su proveedor de hosting.
-
-### Despliegue desde el CLI
-
-Algunos hosts tendrán su propia interfaz de línea de comandos (CLI) que puedes instalar globalmente en tu máquina usando npm. A menudo, el uso de una CLI para desplegar se parece a lo siguiente:
-
-<Steps>
-1. Instala la CLI del host globalmente, por ejemplo:
-
-    <PackageManagerTabs>
-        <Fragment slot="npm">
-        ```shell
-        npm install --global netlify-cli
-        ```
-        </Fragment>
-        <Fragment slot="pnpm">
-        ```shell
-        pnpm add --global netlify-cli
-        ```
-        </Fragment>
-        <Fragment slot="yarn">
-        ```shell
-        yarn global add netlify-cli
-        ```
-        </Fragment>
-    </PackageManagerTabs>
-
-2. Ejecuta la CLI y sigue las instrucciones de autorización, configuración, etc.
-
-3. Crea tu proyecto y despliégalo en el host
-
-    Muchos proveedores de hosting construirán y desplegarán tu proyecto por ti. Por lo general, reconocerán tu proyecto como un sitio de Astro y elegirán los ajustes de configuración apropiados para construir y desplegar como se muestra a continuación. (De lo contrario, estos ajustes se pueden cambiar).
-
-    :::note[Configuración de implementación]
-    - **Comando de construcción:** `astro build` o `npm run build`
-    - **Directorio de publicación:** `dist`
-    :::
-
-
-    Otros proveedores de hosting requerirán que [construyas tu sitio localmente](#construyendo-tu-proyecto-localmente) y realizes el despliegue usando la línea de comandos.
-</Steps>
-
-## Construyendo tu proyecto localmente
-
-Muchos hosts como Netlify y Vercel construirán tu proyecto por ti y lo publicarán en la web automáticamente. Sin embargo, algunos hosts requerirán que construyas tu proyecto localmente y luego ejecutes el comando de despliegue o subas el resultado de la compilación.
-
-También es posible que desees compilar tu proyecto localmente para obtener una vista previa o para detectar posibles errores y advertencias en el entorno.
-
-Ejecuta el comando `npm run build` para construir tu proyecto Astro.
-
-<PackageManagerTabs>
-    <Fragment slot="npm">
-    ```shell
-    npm run build
-    ```
-    </Fragment>
-    <Fragment slot="pnpm">
-    ```shell
-    pnpm run build
-    ```
-    </Fragment>
-    <Fragment slot="yarn">
-    ```shell
-    yarn run build
-    ```
-    </Fragment>
-  </PackageManagerTabs>
-
-De forma predeterminada, el resultado de compilación se colocará en `dist/`. Esta ubicación se puede cambiar usando la [opción de configuración `outDir`](/es/reference/configuration-reference/#outdir).
-
-## Adición de un adaptador para SSR
-
-:::note
-Antes de implementar tu proyecto de Astro con [SSR (renderizado en el servidor)](/es/guides/on-demand-rendering/) habilitado, asegúrate de tener:
-
-- Instalado el [adaptador apropiado](/es/guides/on-demand-rendering/) en tus dependencias (ya sea manualmente, o usando el comando `astro add`, p. ej. `npx astro add netlify`).
-- [Agregado el adaptador](/es/reference/configuration-reference/#adapter) a tu *import* y *default export* en tu archivo `astro.config.mjs` cuando es instalado manualmente. (¡El comando `astro add` se hará cargo de este paso por ti!)
-:::
diff --git a/src/content/docs/es/guides/deploy/kinsta.mdx b/src/content/docs/es/guides/deploy/kinsta.mdx
deleted file mode 100644
index 445e4d7fbe43e..0000000000000
--- a/src/content/docs/es/guides/deploy/kinsta.mdx
+++ /dev/null
@@ -1,107 +0,0 @@
----
-title: Despliega tu projecto de Astro en el hosting de aplicaciones de Kinsta
-description: Como desplegar tu projecto de Astro en el hosting de aplicaciones de Kinsta
-type: deploy
-i18nReady: true
----
-import { Steps } from '@astrojs/starlight/components';
-
-Puedes usar el [Hosting de aplicaciones Kinsta](https://kinsta.com/application-hosting/) para deplegar tu projecto Astro a la nube.
-
-## Configuración del proyecto Astro
-
-
-### Alojamiento estático
-
-:::tip[¿Buscas un ejemplo?]
-¡Mira [el proyecto oficial de Kinsta para Astro](https://github.com/kinsta/hello-world-astro)!
-:::
-
-Para desplegar tu proyecto en el **hosting de aplicaciones Kinsta**, debes:
-- Incluir un campo `name` en tu `package.json`. (Esto puede ser cualquier cosa y no afectará su despliegue).
-- Incluir un script `build` en tu `package.json`. (Tu proyecto de Astro ya incluye uno).
-- Instalar el paquete [`serve`](https://www.npmjs.com/package/serve) y configurar el script `start` en `serve dist/`.
-
-Aquí están las líneas necesarias en tu archivo `package.json`:
-
-```json title="package.json" {2,5,6} ins={12} "serv dist/"
-{
-  "name": "anything", // Esto es obligatorio, pero el valor no es importante.
-  "scripts": {
-    "dev": "astro dev",
-    "start": "serve dist/",
-    "build": "astro build",
-    "preview": "astro preview",
-    "astro": "astro"
-  },
-  "dependencies": {
-    "astro": "^2.2.0",
-    "serve": "^14.0.1"
-  },
-}
-```
-
-### SSR
-
-:::tip[¿Buscas un ejemplo?]
-¡Echa un vistazo [al proyecto oficial de Kinsta Application Hosting Starter para Astro SSR](https://github.com/kinsta/hello-world-astro-ssr)!
-:::
-
-Para alojar tu proyecto en **Kinsta Application Hosting**, debes:
-- Incluir un campo `name` en tu `package.json`. (Esto puede ser cualquier cosa y no afectará su despliegue.)
-- Incluir un script `build` en tu `package.json`. (Tu proyecto de Astro ya debería incluir esto).
-- Instalar el paquete [`@astrojs/node`](https://www.npmjs.com/package/@astrojs/node) y configura el script `start` en `node ./dist/server/entry.mjs`.
-- Configurar `astro.config.mjs` para usar `@astrojs/node` y para usar `host: true`.
-
-Aqui están las líneas necesarias para tu archivo `package.json`:
-```json title="package.json" {2,5,6} ins={12} "node ./dist/server/entry.mjs"
-{
-  "name": "anything", // Esto es obligatorio, pero el valor no es importante.
-  "scripts": {
-    "dev": "astro dev",
-    "start": "node ./dist/server/entry.mjs",
-    "build": "astro build",
-    "preview": "astro preview",
-    "astro": "astro"
-  },
-  "dependencies": {
-    "astro": "^2.2.0",
-    "@astrojs/node": "^5.1.1"
-  },
-}
-```
-
-Aqui están las líneas necesarias para tu archivo `astro.config.mjs`:
-```js title="astro.config.mjs"
-  import { defineConfig } from 'astro/config';
-  import node from "@astrojs/node";
-  export default defineConfig({
-    output: 'server',
-    adapter: node({
-      mode: "standalone"
-    }),
-    server: {
-      host: true
-    }
-  });
-```
-
-## ¿Cómo desplegar?
-
-Una vez que el repositorio de GitHub de tu proyecto esté conectado, puedes activar despliegues manuales en la aplicación de Kinsta en el **Panel de administración de MyKinsta**. También puedes configurar despliegues automáticos en el panel de administración.
-
-### Configurando una nueva aplicación en Kinsta
-
-<Steps>
-1. Dirigete al panel de administración de [Mi Kinsta](https://my.kinsta.com/).
-
-2. Vaya a la pestaña **Aplicaciones**.
-
-3. Conecta tu repositorio de GitHub.
-
-4. Presione el botón **Agregar servicio** > **Aplicación**.
-
-5. Siga los pasos del asistente.
-
-6. Tu aplicación está desplegada.
-</Steps>
\ No newline at end of file
diff --git a/src/content/docs/es/guides/deploy/microsoft-azure.mdx b/src/content/docs/es/guides/deploy/microsoft-azure.mdx
deleted file mode 100644
index ab3c933e84d86..0000000000000
--- a/src/content/docs/es/guides/deploy/microsoft-azure.mdx
+++ /dev/null
@@ -1,51 +0,0 @@
----
-title: Despliega tu proyecto de Astro en Microsoft Azure
-description: Cómo desplegar tu proyecto de Astro usando Microsoft Azure
-type: deploy
-i18nReady: true
----
-import { Steps } from '@astrojs/starlight/components';
-
-[Azure](https://azure.microsoft.com/) es una plataforma en la nube de Microsoft. Puedes desplegar tu proyecto de Astro con el servicio de [Aplicaciones Web Estáticas](https://aka.ms/staticwebapps) de Microsoft.
-
-Esta guía te llevará a través del despliegue de tu sitio de Astro almacenado en GitHub usando Visual Studio Code. Por favor, consulta las guías de Microsoft para usar una [Tarea de Azure Pipelines](https://learn.microsoft.com/en-us/azure/devops/pipelines/tasks/reference/azure-static-web-app-v0?view=azure-pipelines) para otras configuraciones.
-
-## Prerrequisitos
-
-Para seguir esta guía necesitarás:
-
-- Una cuenta de Azure y una clave de subscripción. Puedes crear una [cuenta gratuita de Azure aquí](https://azure.microsoft.com/free).
-- Subir el código de tu proyecto a [GitHub](https://github.com/).
-- La [Extensión de SWA](https://marketplace.visualstudio.com/items?itemName=ms-azuretools.vscode-azurestaticwebapps) en [Visual Studio Code](https://code.visualstudio.com/).
-
-## Cómo desplegar
-
-<Steps>
-1. Abre tu proyecto en VS Code.
-
-2. Abre la extensión de Aplicaciones Web Estáticas, inicia sesión en Azure, y haz clic en el botón de **+** para crear una nueva Aplicación Web Estática. Se te pedirá que designes la clave de subscripción a usar.
-
-3. Sigue el asistente iniciado por la extensión para darle a tu aplicación un nombre, seleccionar un framework preestablecido y designar la raíz de tu aplicación (usualmente `/`) y la ubicación de los archivos generados `/dist`. Astro no está enlistado en las plantillas integradas de Azure por lo que necesitarás elegir `custom`. El asistente creará y ejecutará una [GitHub Action](https://github.com/features/actions) en tu repositorio dentro del directorio `.github`.
-</Steps>
-
-La GitHub Action desplegará tu aplicación (puedes ver el progreso en la pestaña de Actions en GitHub). Cuando se complete con éxito, puedes ver tu aplicación en la dirección mostrada en la ventana de progreso de la Extensión de SWA haciendo clic en el botón de **Browse Website** (esto aparecerá después de que la GitHub Action se haya ejecutado).
-
-## Problemas Conocidos
-
-La acción yaml de GitHub que es creada automáticamente asume el uso de node 14. Esto significa que la compilación de Astro fallará. Para resolver esto actualiza el package.json de tus proyectos con este snippet.
-
-```
-  "engines": {
-    "node": ">=18.0.0"
-  },
-```
-
-## Recursos Oficiales
-
-- [Documentación de Microsoft Azure Static Web Apps](https://learn.microsoft.com/es-es/azure/static-web-apps/)
-
-## Recursos de la Comunidad
-
-- [Despliegue de un sitio web de Astro en Azure Static Web Apps](https://www.blueboxes.co.uk/deploying-an-astro-website-to-azure-static-web-apps)
-- [Despliegue de un Sitio de Astro Estático en Azure Static Web Apps usando GitHub Actions](https://agramont.net/blog/create-static-site-astro-azure-ssg/#automate-deployment-with-github-actions)
-
diff --git a/src/content/docs/es/guides/deploy/netlify.mdx b/src/content/docs/es/guides/deploy/netlify.mdx
deleted file mode 100644
index 8c97cc4f8fc9b..0000000000000
--- a/src/content/docs/es/guides/deploy/netlify.mdx
+++ /dev/null
@@ -1,141 +0,0 @@
----
-title: Despliega tu proyecto de Astro en Netlify
-description: Cómo desplegar tu proyecto de Astro usando Netlify.
-type: deploy
-i18nReady: true
----
-import ReadMore from '~/components/ReadMore.astro'
-
-[Netlify](https://netlify.com) ofrece servicios de alojamiento y servicios serverless para aplicaciones web y sitios estáticos. ¡Cualquier proyecto de Astro puede ser alojado en Netlify!
-
-Esta guía contiene instrucciones para hacer despliegues en Netlify a través de la interfaz web o la CLI de Netlify.
-
-## Configuración del Proyecto
-
-Tu proyecto de Astro puede ser desplegado en Netlify de tres maneras distintas: como un sitio estático, un sitio con renderizado en el servidor (SSR), o un sitio renderizado en _edge computing_.
-
-### Sitio Estático
-
-Tu proyecto de Astro es un sitio estático por defecto. No necesitas ninguna configuración adicional para desplegar un sitio estático de Astro en Netlify.
-
-### Adaptador para SSR
-
-Para habilitar SSR en tu proyecto de Astro y hacer un despliegue en Netlify, incluyendo el uso de funciones edge de Netlify:
-
-Añade [el adaptador de Netlify](/es/guides/integrations-guide/netlify/) a tu proyecto de Astro con el siguiente comando `astro add` que se muestra debajo. Este instalará el adaptador y hará los cambios apropiados a tu archivo `astro.config.mjs` en un solo paso.
-
-```bash
-npx astro add netlify
-```
-
-Si prefieres instalar el adaptador manualmente, sigue los siguientes dos pasos:
-
-1. Añade [el adaptador de `@astrojs/netlify`](https://github.com/withastro/astro/tree/main/packages/integrations/netlify) a las dependencias de tu proyecto usando tu gestor de paquetes preferido. Si estás usando npm o no estás seguro, ejecuta esto en la terminal:
-
-    ```bash
-      npm install @astrojs/netlify
-    ```
-
-2. Añade dos nuevas lineas a tu archivo de configuración del proyecto `astro.config.mjs`.
-
-    ```js title="astro.config.mjs" ins={2, 5-6}
-    import { defineConfig } from 'astro/config';
-    import netlify from '@astrojs/netlify';
-
-    export default defineConfig({
-      output: 'server',
-    adapter: netlify(),
-    });
-    ```
-
-    También puedes desplegar tu proyecto usando las funciones edge de Netlify añadiendo `edgeMiddleware: true` a la configuración del adaptador de Netlify:
-    
-    ```diff lang="js"
-      // astro.config.mjs
-      import { defineConfig } from 'astro/config';
-      import netlify from '@astrojs/netlify/functions';
-
-      export default defineConfig({
-        output: 'server',
-        adapter: netlify({
-    +     edgeMiddleware: true
-        }),
-      });
-    ```
-
-## Cómo desplegar
-
-Puedes hacer despliegues en Netlify a través de la interfaz web o usando la CLI de Netlify (interfaz de línea de comandos). El proceso es el mismo para ambos sitios estáticos y sitios con SSR.
-
-### Despliegue con la Interfaz Web
-
-Si tu proyecto está alojado en GitHub, GitLab, BitBucket, o Azure DevOps, puedes usar la interfaz web de Netlify para desplegar tu proyecto de Astro.
-
-1. Haz click en <kbd>Add a new site</kbd> en tu [Netlify dashboard](https://app.netlify.com/)
-
-2. Selecciona <kbd>Import an existing project</kbd>
-
-    Cuando importes tu proyecto de Astro desde tu proveedor de Git, Netlify debería detectarlo automáticamente y preconfigurar los ajustes correctos para ti.
-
-3. Asegúrate de que los siguientes ajustes sean ingresados, luego presiona el botón <kbd>Deploy</kbd>:
-
-    - **Build Command:** `astro build` o `npm run build`
-    - **Publish directory:** `dist`
-
- Una vez desplegado, serás redirigido a la página de vista general. Ahí, puedes editar los detalles de tu sitio.
-
-Cualquier cambio futuro al repositorio de tu proyecto provocará despliegues de vista previa y producción basados en tu configuración de despliegue.
-
-#### Archivo `netlify.toml`
-
-Opcionalmente, puedes crear el archivo `netlify.toml` en la raíz del repositorio de tu proyecto para configurar tu comando de build y el directorio a publicar, así como otros ajustes del sitio, incluyendo variables de entorno y redirecciones. Netlify leerá este archivo y configurará de manera automática tu despliegue.
-
-Para configurar los ajustes por defecto, crea un archivo `netlify.toml` con la siguiente configuración:
-
-```toml
-[build]
-  command = "npm run build"
-  publish = "dist"
-```
-
-<ReadMore>Más información en [“Deploying an existing Astro Git repository”](https://www.netlify.com/blog/how-to-deploy-astro/#deploy-an-existing-git-repository-to-netlify) en el blog de Netlify</ReadMore>
-
-### Despliegue con CLI
-
-También puedes crear un nuevo sitio en Netlify y vincularlo a tu repositorio de Git instalando y usando la [CLI de Netlify](https://cli.netlify.com/).
-
-1. Instala la CLI de Netlify de manera global
-
-    ```bash
-    npm install --global netlify-cli
-    ```
-
-2. Ejecuta `netlify login` y sigue las instrucciones para iniciar sesión y autorizar a Netlify
-3. Ejecuta `netlify init` y sigue las instrucciones
-4. Confirma tu comando de build (`astro build`)
-
-    La CLI detectará automáticamente la configuración de build (`astro build`) y el directorio a desplegar (`dist`), y ofrecerá generar automáticamente [un archivo `netlify.toml`](#archivo-netlifytoml) con esos ajustes.
-
-5. Genera tu sitio y despliega enviando tus cambios a Git
-
-    La CLI añadirá una deploy key al repositorio, lo que significa que tu sitio será generado automáticamente en Netlify cada vez que envíes tus cambios con `git push`.
-
-<ReadMore>Más detalles de Netlify en [Deploy an Astro site using the Netlify CLI](https://www.netlify.com/blog/how-to-deploy-astro/#link-your-astro-project-and-deploy-using-the-netlify-cli)</ReadMore>
-
-### Establece una Versión de Node.js
-
-Si estás usando una [build image](https://docs.netlify.com/configure-builds/get-started/#build-image-selection) antigua (Xenial) en Netlify, asegúrate que tu versión de Node.js esté configurada. Astro requiere `v18.17.1` o `v20.3.0` o mayor.
-
-Puedes [especificar tu versión de Node.js en Netlify](https://docs.netlify.com/configure-builds/manage-dependencies/#node-js-and-javascript) usando:
-- Un archivo [`.nvmrc`](https://github.com/nvm-sh/nvm#nvmrc) en tu directorio raíz.
-- Una variable de entorno `NODE_VERSION` en los ajustes de tu sitio utilizando el dashboard de Netlify.
-
-## Usando Netlify Functions
-
-No se necesita configuración adicional para usar Netlify Functions con Astro. ¡Añade un directorio `netlify/functions` a la raíz de tu proyecto y sigue [la documentación de Netlify Functions](https://docs.netlify.com/functions/overview/) para comenzar!
-
-## Ejemplos
-
-- [How to deploy an Astro site](https://www.netlify.com/blog/how-to-deploy-astro/) — Netlify Blog
-- [Deploy An Astro site with Forms, Serverless Functions, and Redirects](https://www.netlify.com/blog/deploy-an-astro-site-with-forms-serverless-functions-and-redirects/) — Netlify Blog
-- [Deployment Walkthrough Video](https://youtu.be/GrSLYq6ZTes) — Netlify YouTube channel
diff --git a/src/content/docs/es/guides/deploy/render.mdx b/src/content/docs/es/guides/deploy/render.mdx
deleted file mode 100644
index 90c0fae9ec628..0000000000000
--- a/src/content/docs/es/guides/deploy/render.mdx
+++ /dev/null
@@ -1,26 +0,0 @@
----
-title: Despliega tu proyecto de Astro en Render
-description: Cómo desplegar tu proyecto de Astro en Render
-type: deploy
-i18nReady: true
----
-import { Steps } from '@astrojs/starlight/components';
-
-Puedes desplegar tu proyecto de Astro en [Render](https://render.com/), un servicio para crear sitios web con certificados TLS gratuitos, una CDN global, protección DDoS, redes privadas y despliegues automáticos desde Git.
-
-## Cómo desplegar
-
-<Steps>
-1. Crea una [cuenta de render.com](https://dashboard.render.com/) e inicia sesión.
-
-2. Haz clic en el botón **New +** en el dashboard y selecciona **Static Site**
-
-3. Conecta tu repositorio de [GitHub](https://github.com/) o [GitLab](https://about.gitlab.com/) o, alternativamente, ingresa la URL pública del repositorio.
-
-4. Asigna un nombre a tu sitio web, selecciona la rama y especifica el comando de compilación y el directorio de publicación
-    - **build command:** `npm run build`
-    - **publish directory:** `dist`, para sitios estáticos; `dist/client` si estás usando los modos de renderizado `server` o `hybrid`.
-    - **Environment variables (advanced)**: Por defecto, Render usa Node.js 14.17.0, pero Astro [requiere una versión superior](/es/install-and-setup/#prerrequisitos). Añade una variable de entorno con una **Variable key** de `NODE_VERSION` y un **Value** de `v18.17.1` o `v20.3.0` o superior para indicarle a Render que use una versión compatible de Node.js. Alternativamente, añade un archivo [`.node-version`](https://render.com/docs/node-version) o [`.nvmrc`](https://render.com/docs/node-version) a tu proyecto para especificar una versión de Node.js.
-
-5. Haz clic en el botón **Create Static Site**.
-</Steps>
diff --git a/src/content/docs/es/guides/deploy/sst.mdx b/src/content/docs/es/guides/deploy/sst.mdx
deleted file mode 100644
index d095c1bac8450..0000000000000
--- a/src/content/docs/es/guides/deploy/sst.mdx
+++ /dev/null
@@ -1,55 +0,0 @@
----
-title: Despliega tu proyecto de Astro en AWS con SST
-description: Cómo desplegar tu sitio Astro en AWS con SST
-type: deploy
-i18nReady: true
----
-import { Steps } from '@astrojs/starlight/components';
-
-Puedes desplegar un proyecto de Astro usando [SST](https://sst.dev), un framework de código abierto para desplegar aplicaciones completamente serverless en AWS con soporte SSG y SSR.
-
-Además, puedes usar cualquier construcción SST adicional como Cron Jobs, Buckets, Queues, etc. mientras mantienes la seguridad de tipos.
-
-## Inicio rápido
-
-<Steps>
-1. Crea un proyecto de Astro.
-
-2. Ejecuta `npx create-sst`.
-
-3. Debería detectar que estás usando Astro y pedirte confirmación.
-
-4. Una vez que estés listo para el despliegue, puedes ejecutar `npx sst deploy --stage=production`.
-</Steps>
-
-También puedes ver [un vídeo tutorial de este proceso](https://www.youtube.com/watch?v=AFP3ZHxO7Gg) que te guiará a través de los pasos.
-
-### Constructs SST
-
-Para usar cualquier [construct SST](https://docs.sst.dev/) adicional, añádelos a tu `sst.config.ts`. 
-
-```ts {2} {4} title="sst.config.ts"
-app.stack(function Site(ctx) {
-  const bucket = new Bucket(ctx.stack, "public");
-  const site = new AstroSite(ctx.stack, "site", {
-    bind: [bucket],
-  });
-
-  ctx.stack.addOutputs({
-    url: site.url,
-  });
-});
-```
-
-Y después accede a ellos en tu archivo `.astro`.
-
-```astro
----
-import { Bucket } from "sst/node/bucket"
-console.log(Bucket.public.bucketName)
----
-```
-
-Consulta la [documentación de Enlace de Recursos de SST](https://docs.sst.dev/resource-binding) para aprender más.
-
-Si tienes cualquier pregunta, puedes hacerla en el [Discord de SST](https://discord.gg/sst).
diff --git a/src/content/docs/es/guides/deploy/stormkit.mdx b/src/content/docs/es/guides/deploy/stormkit.mdx
deleted file mode 100644
index f5f90f2f78e06..0000000000000
--- a/src/content/docs/es/guides/deploy/stormkit.mdx
+++ /dev/null
@@ -1,26 +0,0 @@
----
-title: Despliega tu sitio de Astro en Stormkit
-description: Despliega tu sitio de Astro en Stormkit
-type: deploy
-i18nReady: true
----
-import ReadMore from '~/components/ReadMore.astro';
-import { Steps } from '@astrojs/starlight/components';
-
-Puedes desplegar tu proyecto de Astro en [Stormkit](https://stormkit.io/), una plataforma de despliegues para sitios web estáticos, aplicaciones de una página (SPAs) y funciones serverless.
-
-## ¿Cómo desplegar?
-
-<Steps>
-1. [Inicia sesión en Stormkit](https://app.stormkit.io/auth).
-
-2. Utilizando la interfaz de usuario, importa tu proyecto de Astro desde uno de los tres proveedores de Git admitidos (GitHub, GitLab o Bitbucket).
-
-3. Navega hasta el entorno de producción del proyecto en Stormkit o crea un nuevo entorno si es necesario.
-
-4. Verifica el comando de construcción en tu [configuración de Stormkit](https://stormkit.io/docs/deployments/configuration). Por defecto, Stormkit CI ejecutará `npm run build` pero puedes especificar un comando de construcción personalizado en esta página.
-
-5. Haz clic en el botón "Deploy Now" para desplegar tu sitio.
-</Steps>
-
-<ReadMore>Lee más en la [Documentación de Stormkit](https://stormkit.io/docs).</ReadMore>
diff --git a/src/content/docs/es/guides/deploy/surge.mdx b/src/content/docs/es/guides/deploy/surge.mdx
deleted file mode 100644
index 5aba5504941a6..0000000000000
--- a/src/content/docs/es/guides/deploy/surge.mdx
+++ /dev/null
@@ -1,33 +0,0 @@
----
-title: Despliega tu proyecto de Astro en Surge
-description: Cómo desplegar tu proyecto de Astro usando surge.sh
-type: deploy
-i18nReady: true
----
-import { Steps } from '@astrojs/starlight/components';
-
-Puedes desplegar tu proyecto de Astro en [Surge](https://surge.sh/), una plataforma diseñada para desarrolladores front-end para publicar sitios web usando solo un comando.
-
-## ¿Cómo desplegar?
-
-<Steps>
-1. Instala [la CLI de Surge](https://www.npmjs.com/package/surge) de forma global desde la Terminal, si aún no lo has hecho.
-
-    ```shell
-    npm install -g surge
-    ```
-
-2. Construye tu sitio de Astro desde el directorio raíz de tu proyecto.
-
-    ```shell
-    npm run build
-    ```
-
-3. Despliega en Surge usando la CLI.
-
-    ```shell
-    surge dist
-    ```
-
-    Puedes usar un [dominio personalizado](http://surge.sh/help/adding-a-custom-domain) al hacer despliegues ejecutando `surge dist tudominio.com`.
-</Steps>
\ No newline at end of file
diff --git a/src/content/docs/es/guides/deploy/vercel.mdx b/src/content/docs/es/guides/deploy/vercel.mdx
deleted file mode 100644
index a2909c93b6ecb..0000000000000
--- a/src/content/docs/es/guides/deploy/vercel.mdx
+++ /dev/null
@@ -1,87 +0,0 @@
----
-title: Despliega tu proyecto de Astro en Vercel
-description: Cómo desplegar tu sitio de Astro en la web en Vercel.
-type: deploy
-i18nReady: true
----
-import ReadMore from '~/components/ReadMore.astro';
-
-Puedes usar [Vercel](http://vercel.com/) para desplegar tu proyecto de Astro a su red global edge sin configuración adicional.
-
-Esta guía incluye instrucciones para desplegar tu proyecto en Vercel a través de la interfaz web o la línea de comandos (CLI) de Vercel.
-
-## Configuración del Proyecto
-
-Tu proyecto de Astro puede ser desplegado en Vercel como un sitio estático, o como un sitio renderizado en el servidor (SSR).
-
-### Sitio Estático
-
-Tu proyecto de Astro es un sitio estático por defecto. No necesitas ninguna configuración adicional para desplegar un sitio estático de Astro en Vercel.
-
-### Adaptador para SSR
-
-Para habilitar SSR en tu proyecto de Astro y desplegar en Vercel:
-
-Añade [el adaptador de Vercel](/es/guides/integrations-guide/vercel/) a tu proyecto de Astro con el siguiente comando `astro add` que se muestra debajo. Este instalará el adaptador y hará los cambios apropiados a tu archivo `astro.config.mjs` en un solo paso.
-
-
-```bash
-npx astro add vercel
-```
-
-Si prefieres instalar el adaptador manualmente, sigue los siguientes dos pasos:
-
-1. Añade [el adaptador de `@astrojs/vercel`](/es/guides/integrations-guide/vercel/) a las dependencias de tu proyecto usando tu gestor de paquetes preferido. Si estás usando npm o no estás seguro, ejecuta esto en la terminal:
-
-
-    ```bash
-      npm install @astrojs/vercel
-    ```
-
-1. Añade dos líneas nuevas a tu archivo de configuración del proyecto `astro.config.mjs`.
-
-    ```js title="astro.config.mjs" ins={2, 5-6}
-    import { defineConfig } from 'astro/config';
-    import vercel from '@astrojs/vercel/serverless';
-
-    export default defineConfig({
-      output: 'server',
-      adapter: vercel(),
-    });
-    ```
-
-## Cómo Desplegar
-
-Puedes desplegar en Vercel a través de la interfaz web o utilizando la interfaz de línea de comandos (CLI) de Vercel. El proceso es el mismo para sitios de Astro estáticos y SSR.
-
-
-### Despliegue con Interfaz Web
-
-1. Envía tu código a un repositorio en remoto de Git (GitHub, GitLab, BitBucket).
-2. [Importa tu proyecto](https://vercel.com/new) en Vercel.
-3. Vercel detectará automáticamente Astro y establecerá la configuración necesaria.
-4. ¡Tu aplicación está desplegada! (p. ej. [astro.vercel.app](https://astro.vercel.app/))
-
-Una vez que tu proyecto ha sido importado y desplegado, todos los envíos subsecuentes en las ramas de git generarán [Preview Deployments](https://vercel.com/docs/concepts/deployments/preview--deployments), y todos los cambios hechos a la rama de producción (comúnmente “main”) resultarán en [Production Deployments](https://vercel.com/docs/concepts/deployments/environments#production).
-
-<ReadMore>Aprende más sobre la [integración de Git de Vercel](https://vercel.com/docs/concepts/git).</ReadMore>
-
-
-### Despliegue a través del CLI
-
-1. Instala la [CLI de Vercel](https://vercel.com/cli) y ejecuta `vercel` para desplegar.
-
-    ```bash
-    npm install -g vercel
-    vercel
-    ```
-
-2. Vercel detectará automáticamente Astro y establecerá la configuración necesaria.
-3. Cuando pregunte `Want to override the settings? [y/N]`, selecciona `N`.
-4. ¡Tu aplicación está desplegada! (p. ej. [astro.vercel.app](https://astro.vercel.app/))
-
-### Configuración con vercel.json
-
-Puedes usar `vercel.json` para sobrescribir el comportamiento predeterminado de Vercel y para configurar ajustes adicionales. Por ejemplo, es posible que desees adjuntar encabezados a las respuestas HTTP de tus despliegues.
-
-<ReadMore>Aprende más sobre la [configuración de Vercel](https://vercel.com/docs/configuration).</ReadMore>
\ No newline at end of file
diff --git a/src/content/docs/es/guides/deploy/zeabur.mdx b/src/content/docs/es/guides/deploy/zeabur.mdx
deleted file mode 100644
index 5a47fa1260253..0000000000000
--- a/src/content/docs/es/guides/deploy/zeabur.mdx
+++ /dev/null
@@ -1,60 +0,0 @@
----
-title: Despliega tu sitio de Astro en Zeabur
-description: Cómo desplegar tu sitio de Astro en la web en Zeabur.
-type: deploy
-i18nReady: true
----
-import { Steps } from '@astrojs/starlight/components';
-
-[Zeabur](https://zeabur.com) ofrece alojamiento para aplicaciones web full-stack. Los sitios Astro se pueden alojar tanto como SSR o salida estática.
-
-Esta guía incluye instrucciones para desplegar en Zeabur a través de la UI del sitio web.
-
-## Configuración de proyecto
-
-### Sitio estático
-
-Astro genera un sitio estático de forma predeterminada. No es necesario ninguna configuración adicional para desplegar un sitio Astro estático en Zeabur.
-
-### Adaptador para SSR
-
-Para habilitar SSR en tu proyecto de Astro y desplegar en Zeabur:
-
-<Steps>
-1. Instala [El adaptador `@zeabur/astro-adapter`](https://www.npmjs.com/package/@zeabur/astro-adapter) a las dependencias de tu proyecto utilizando tu gestor de paquetes preferido. Si estás utilizando npm o no estás seguro, ejecuta esto en la terminal:
-
-    ```bash
-      npm install @zeabur/astro-adapter
-    ```
-
-2. Agrega dos nuevas lineas en tu archivo de configuración de tu proyecto `astro.config.mjs`.
-
-    ```js title="astro.config.mjs" ins={2, 5-6}
-    import { defineConfig } from 'astro/config';
-    import zeabur from '@zeabur/astro-adapter/serverless';
-
-    export default defineConfig({
-      output: 'server',
-      adapter: zeabur(),
-    });
-    ```
-</Steps>
-
-## ¿Cómo desplegar?
-
-Puedes desplegar tu sitio Astro en Zeabur si el proyecto está almacenado en GitHub.
-
-<Steps>
-1. Haz clic en <kbd>Create new project</kbd> en el [panel de Zeabur](https://dash.zeabur.com).
-
-2. Configura la instalación de GitHub e importa el repositorio.
-
-3. Zeabur detectará automáticamente que tu proyecto es un proyecto de Astro y lo construirá usando el comando `astro build`.
-
-4. Una vez que se complete la compilación, puedes vincular un dominio a tu sitio y visitarlo.
-</Steps>
-
-Después de que tu proyecto haya sido importado y desplegado, todas las siguientes confirmaciones a las ramas generarán nuevas compilaciones.
-
-Aprende más sobre la [Guía de despliegue](https://zeabur.com/docs/get-started/) de Zeabur.
-
diff --git a/src/content/docs/es/guides/deploy/zerops.mdx b/src/content/docs/es/guides/deploy/zerops.mdx
deleted file mode 100644
index c1b07458fd75a..0000000000000
--- a/src/content/docs/es/guides/deploy/zerops.mdx
+++ /dev/null
@@ -1,233 +0,0 @@
----
-title: Despliega tu sitio de Astro en Zerops
-description: Cómo desplegar tu sitio de Astro en la web usando Zerops.
-type: deploy
-i18nReady: true
----
-import PackageManagerTabs from '~/components/tabs/PackageManagerTabs.astro'
-import { Steps } from '@astrojs/starlight/components';
-
-[Zerops](https://zerops.io/) es una plataforma en la nube centrada en el desarrollo que se puede utilizar para desplegar tanto un sitio Astro estático como SSR.
-
-Esta guía te guiará a través de la configuración y el despliegue de sitios Astro estáticos y SSR en Zerops.
-
-:::tip[Vista rápida de Astro x Zerops]
-
-¿Quieres probar Astro en Zerops sin instalar o configurar nada? Usando los repositorios [Zerops x Astro - Estático](https://github.com/zeropsio/recipe-astro-nodejs) o [Zerops x Astro - SSR en Node.js](https://github.com/zeropsio/recipe-astro-static) puedes desplegar un sitio de ejemplo de Astro con un solo clic.
-
-:::
-
-Ejecutar aplicaciones en Zerops requiere dos pasos:t
-1. Crear un proyecto
-2. Desencadenar el pipeline de compilación y despliegue
-
-:::note
-Un proyecto de Zerops puede contener muchos sitios Astro.
-:::
-
-## Sitio Astro estático en Zerops
-
-### Crear un proyecto y un servicio para Astro estático
-Los proyectos y servicios se pueden añadir a través del asistente [`Project add`](https://app.zerops.io/dashboard/project-add) o importando una estructura yaml:
-
-```yaml
-project:
-  name: recipe-astro
-services:
-  - hostname: app
-    type: static 
-```
-
-Esto creará un proyecto llamado `recipe-astro` con un servicio estático de Zerops llamado `app`.
-
-### Desplegar tu sitio Astro estático
-
-Para indicarle a Zerops cómo construir y ejecutar tu sitio, añade un archivo `zerops.yml` a tu repositorio:
-
-  <PackageManagerTabs>
-    <Fragment slot="npm">
-    ```yaml title="zerops.yml"
-    # consulta https://docs.zerops.io/zerops-yml/specification para obtener la referencia completa
-    zerops:
-      - setup: app
-        build:
-          base: nodejs@20
-          buildCommands:
-            - npm i
-            - npm build
-          deployFiles:
-            - dist/~
-        run:
-          base: static
-    ```
-    </Fragment>
-    <Fragment slot="pnpm">
-    ```yaml title="zerops.yml"
-    # consulta https://docs.zerops.io/zerops-yml/specification para obtener la referencia completa
-    zerops:
-      - setup: app
-        build:
-          base: nodejs@20
-          buildCommands:
-            - pnpm i
-            - pnpm build
-          deployFiles:
-            - dist/~
-        run:
-          base: static
-    ```
-    </Fragment>
-    <Fragment slot="yarn">
-    ```yaml title="zerops.yml"
-    # consulta https://docs.zerops.io/zerops-yml/specification para obtener la referencia completa
-    zerops:
-      - setup: app
-        build:
-          base: nodejs@20
-          buildCommands:
-            - yarn
-            - yarn build
-          deployFiles:
-            - dist/~
-        run:
-          base: static
-    ```
-    </Fragment>
-  </PackageManagerTabs>
-
-Ahora puedes [desencadenar el pipeline de construcción y despliegue usando la CLI de Zerops](#desencadenar-el-pipeline-usando-zerops-cli-zcli) o conectando el servicio `app` con tu repositorio de [GitHub](https://docs.zerops.io/references/github-integration/) / El repositorio de [GitLab](https://docs.zerops.io/references/gitlab-integration) desde dentro del detalle del servicio.
-
-## Sitio Astro SSR en Zerops
-
-### Crear un proyecto y un servicio para Astro SSR (Node.js)
-Los proyectos y servicios se pueden añadir a través del asistente [`Project add`](https://app.zerops.io/dashboard/project-add) o importando una estructura yaml:
-
-```yaml
-project:
-  name: recipe-astro
-services:
-  - hostname: app
-    type: nodejs@20
-```
-
-Esto creará un proyecto llamado `recipe-astro` con un servicio de Zerops Node.js llamado `app`.
-
-### Desplegar tu sitio Astro SSR
-
-Para indicarle a Zerops cómo construir y ejecutar tu sitio usando el [adaptador oficial de Astro Node.js](/es/guides/integrations-guide/node/) en modo `standalone`, añade un archivo `zerops.yml` a tu repositorio:
-
-  <PackageManagerTabs>
-    <Fragment slot="npm">
-    ```yaml title="zerops.yml"
-    # consulta https://docs.zerops.io/zerops-yml/specification para obtener la referencia completa
-    zerops:
-      - setup: app
-        build:
-          base: nodejs@20
-          buildCommands:
-            - npm i
-            - npm run build
-          deployFiles:
-            - dist
-            - package.json
-            - node_modules
-        run:
-          base: nodejs@20
-          ports:
-            - port: 3000
-              httpSupport: true
-          envVariables:
-            PORT: 3000
-            HOST: 0.0.0.0
-          start: npm start
-    ```
-    </Fragment>
-    <Fragment slot="pnpm">
-    ```yaml title="zerops.yml"
-      zerops:
-    # consulta https://docs.zerops.io/zerops-yml/specification para obtener la referencia completa
-    zerops:
-      - setup: app
-        build:
-          base: nodejs@20
-          buildCommands:
-            - pnpm i
-            - pnpm run build
-          deployFiles:
-            - dist
-            - package.json
-            - node_modules
-        run:
-          base: nodejs@20
-          ports:
-            - port: 3000
-              httpSupport: true
-          envVariables:
-            PORT: 3000
-            HOST: 0.0.0.0
-          start: pnpm start
-    ```
-    </Fragment>
-    <Fragment slot="yarn">
-    ```yaml title="zerops.yml"
-    # consulta https://docs.zerops.io/zerops-yml/specification para obtener la referencia completa
-    zerops:
-      - setup: app
-        build:
-          base: nodejs@20
-          buildCommands:
-            - yarn
-            - yarn build
-          deployFiles:
-            - dist
-            - package.json
-            - node_modules
-        run:
-          base: nodejs@20
-          ports:
-            - port: 3000
-              httpSupport: true
-          envVariables:
-            PORT: 3000
-            HOST: 0.0.0.0
-          start: yarn start
-    ```
-    </Fragment>
-  </PackageManagerTabs>
-
-Ahora puedes [desencadenar el pipeline de construcción y despliegue usando la CLI de Zerops](#desencadenar-el-pipeline-usando-zerops-cli-zcli) o conectando el servicio `app` con tu repositorio de [GitHub](https://docs.zerops.io/references/github-integration/) / El repositorio de [GitLab](https://docs.zerops.io/references/gitlab-integration) desde dentro del detalle del servicio.
-
-## Desencadenar el pipeline usando Zerops CLI (zcli)
-
-<Steps>
-1. Instala la CLI de Zerops.
-		```shell
-    # Para descargar el binario de zcli directamente,
-    # usa https://github.com/zeropsio/zcli/releases
-		npm i -g @zerops/zcli
-		```
-
-2. Abre [`Settings > Access Token Management`](https://app.zerops.io/settings/token-management) en la aplicación de Zerops y genera un nuevo token de acceso.
-
-3. Inicia sesión usando tu token de acceso con el siguiente comando:
-		```shell
-		zcli login <token>
-		```
-
-4. Navega a la raíz de tu aplicación (donde se encuentra `zerops.yml`) y ejecuta el siguiente comando para desencadenar el despliegue:
-		```shell
-		zcli push
-		```
-</Steps>
-
-## Recursos
-### Official
-
-- [Crear una cuenta de Zerops](https://app.zerops.io/registration)
-- [Documentación de Zerops](https://docs.zerops.io)
-- [Receta de Zerops Astro]https://app.zerops.io/recipe/astro)
-
-### Community
-- [Desplegando Astro a Zerops en 3 minutos](https://medium.com/@arjunaditya/how-to-deploy-astro-to-zerops-4230816a62b4)
-- [Desplegand Astro SSG con Node.js en Zerops con un solo clic](https://youtu.be/-4KTa4VWtBE)
-- [Desplegando Astro SSR con Node.js en Zerops con un solo clic](https://youtu.be/eR6b_JnDH6g)
diff --git a/src/content/docs/es/guides/dev-toolbar.mdx b/src/content/docs/es/guides/dev-toolbar.mdx
deleted file mode 100644
index c4ea4653b11ee..0000000000000
--- a/src/content/docs/es/guides/dev-toolbar.mdx
+++ /dev/null
@@ -1,86 +0,0 @@
----
-title: Barra de herramientas de desarrollo
-description: Una guía para usar la barra de herramientas de desarrollo en Astro
-i18nReady: true
----
-import RecipeLinks from "~/components/RecipeLinks.astro";
-
-Mientras el servidor de desarrollo está en ejecución, Astro incluye una barra de herramientas de desarrollo en la parte inferior de cada página en tu vista previa local del navegador.
-
-Esta barra de herramientas incluye una serie de herramientas útiles para depurar e inspeccionar tu sitio durante el desarrollo y se puede [extender con más aplicaciones de la barra de herramientas de desarrollo](#extendiendo-la-barra-de-herramientas-de-desarrollo) que se encuentran en el directorio de integraciones. ¡Incluso puedes [construir tus propias aplicaciones de barra de herramientas](/es/recipes/making-toolbar-apps/) utilizando la [API de la barra de herramientas de desarrollo](/es/reference/dev-toolbar-app-reference/)!
-
-Esta barra de herramientas está habilitada de forma predeterminada y aparece cuando pasas el cursor por la parte inferior de la página. Es una herramienta de desarrollo solamente y no aparecerá en tu sitio publicado.
-
-## Aplicaciones integradas
-
-### Astro Menu
-
-La aplicación de Astro Menu proporciona un acceso fácil a varios datos sobre el proyecto actual y enlaces a recursos adicionales. En particular, proporciona acceso con un solo clic a la documentación de Astro, al repositorio de GitHub y al servidor de Discord.
-
-Esta aplicación también incluye un botón "Copy debug info" que ejecutará el comando [`astro info`](/es/reference/cli-reference/#astro-info) y copiará la salida al portapapeles. Esto puede ser útil al solicitar ayuda o informar problemas.
-
-### Inspect
-
-La aplicación Inspect proporciona información sobre cualquier [isla](/es/concepts/islands/) en la página actual. Esto te mostrará las propiedades pasadas a cada isla y la directiva del cliente que se está utilizando para renderizarlas.
-
-### Audit
-
-La aplicación Audit ejecuta automáticamente una serie de auditorías en la página actual, comprobando los problemas de rendimiento y accesibilidad más comunes. Cuando se encuentra un problema, aparecerá un punto rojo en la barra de herramientas. Al hacer clic en la aplicación, se mostrará una lista de resultados de la auditoría y se resaltarán los elementos relacionados directamente en la página.
-
-:::note
-La auditoría básica de rendimiento y accesibilidad realizada por la barra de herramientas de desarrollo no reemplaza a herramientas dedicadas como [Pa11y](https://pa11y.org/) o [Lighthouse](https://developers.google.com/web/tools/lighthouse), o incluso mejor, ¡los humanos!
-
-La barra de herramientas de desarrollo tiene como objetivo proporcionar una forma rápida y sencilla de detectar problemas comunes durante el desarrollo, sin necesidad de cambiar de contexto a una herramienta diferente.
-:::
-
-### Settings
-
-La aplicación Settings te permite configurar opciones para la barra de herramientas de desarrollo, como el registro detallado, deshabilitar notifaciones y ajustar su ubicación en tu pantalla.
-
-## Extendiendo la barra de herramientas de desarrollo
-
-Las integraciones de Astro pueden agregar nuevas aplicaciones a la barra de herramientas de desarrollo, lo que te permite extenderla con herramientas personalizadas específicas para tu proyecto. Puedes encontrar [más aplicaciones de herramientas de desarrollo para instalar en el directorio de integraciones](https://astro.build/integrations/?search=&categories%5B%5D=toolbar) o utilizando el [Menú de Astro](#astro-menu).
-
-Instala aplicaciones adicionales de la barra de herramientas de desarrollo en tu proyecto de la misma manera que cualquier otra [integración de Astro](/es/guides/integrations-guide/) según sus propias instrucciones de instalación.
-
-<RecipeLinks slugs={["es/recipes/making-toolbar-apps"]} />
-
-## Deshabilitar la barra de herramientas de desarrollo
-
-La barra de herramientas de desarrollo está habilitada de forma predeterminada para todos los sitios. Puedes elegir deshabilitarla para proyectos y/o usuarios individuales según sea necesario.
-
-### Por proyecto
-
-Para deshabilitar la barra de herramientas de desarrollo para todos los que trabajan en un proyecto, establece `devToolbar: false` en el [archivo de configuración de Astro](/es/reference/configuration-reference/).
-
-```js title="astro.config.mjs" ins={4-6}
-import { defineConfig } from "astro/config";
-
-export default defineConfig({
-  devToolbar: {
-    enabled: false
-  }
-})
-```
-
-Para habilitar la barra de herramientas de desarrollo nuevamente, elimina estas líneas de tu configuración o establece `enabled:true`.
-
-### Por usuario
-
-Para deshabilitar la barra de herramientas de desarrollo para ti mismo en un proyecto específico, ejecuta el comando [`astro preferences`](/es/reference/cli-reference/#astro-preferences).
-
-```shell
-astro preferences disable devToolbar
-```
-
-Para deshabilitar la barra de herramientas de desarrollo en todos los proyectos de Astro para un usuario en la máquina actual, agrega la bandera `--global` al ejecutar `astro-preferences`:
-
-```shell
-astro preferences disable --global devToolbar
-```
-
-La barra de herramientas de desarrollo se puede habilitar más tarde con:
-
-```shell
-astro preferences enable devToolbar
-```
diff --git a/src/content/docs/es/guides/endpoints.mdx b/src/content/docs/es/guides/endpoints.mdx
deleted file mode 100644
index 8ad78cf2fdee8..0000000000000
--- a/src/content/docs/es/guides/endpoints.mdx
+++ /dev/null
@@ -1,224 +0,0 @@
----
-title: Endpoints
-description: Aprende cómo crear endpoints que sirven cualquier tipo de dato
-i18nReady: true
----
-import RecipeLinks from "~/components/RecipeLinks.astro";
-
-Astro te permite crear endpoints personalizados para servir cualquier tipo de dato. Puedes usar esto para generar imágenes, exponer un documento RSS o usarlo como rutas API para construir una API completa para tu proyecto.
-
-En los sitios generados estáticamente, tus endpoints personalizados son llamados al momento de compilación para producir archivos estáticos. Si optaste para modo [SSR](/es/guides/on-demand-rendering/), los endpoints personalizados se convierten en endpoints de servidor que son llamados a petición. Endpoints estáticos y de tipo SSR son definidos similarmente, pero endpoints SSR soportan características adicionales.
-
-## Endpoints de Archivos Estáticos
-
-Para crear un endpoint personalizado, agrega un archivo `.js` o `.ts` al directorio de `/pages`. La extensión `.js` o `.ts` se eliminará durante el proceso de compilación, por lo que el nombre del archivo debe incluir la extensión de los datos que se desea generar. Por ejemplo, `src/pages/data.json.ts` generará el endpoint `/data.json`.
-
-Los endpoints exportan una función `GET` (opcionalmente `async`) que recibe un [objeto de contexto](/es/reference/api-reference/#contexto-del-endpoint) con propiedades similares a las de `Astro` global. Aquí, retorna un objeto Response con un `name` y una `url`, y Astro va a llamarlo al momento de compilación y usar sus contenidos del body para generar un archivo.
-
-```ts
-// Ejemplo: src/pages/builtwith.json.ts
-// Salidas: /builtwith.json
-export async function GET({params, request}) {
-  return new Response(
-    JSON.stringify({
-       url: 'https://astro.build/'
-    })
-  )
-}
-```
-
-Desde Astro v3.0, el objeto `Response` devuelto ya no necesita incluir la propiedad `encoding`. Por ejemplo, para generar una imagen PNG binaria:
-
-```ts title="src/pages/astro-logo.png.ts" {3}
-export async function GET({ params, request }) {
-  const response = await fetch("https://docs.astro.build/assets/full-logo-light.png");
-  return new Response(await response.arrayBuffer());
-};
-```
-
-También puedes escribir tus funciones de endpoint usando el tipo de `APIRoute`:
-
-```ts
-import type { APIRoute } from 'astro';
-
-export const GET: APIRoute = async ({ params, request }) => {...}
-```
-
-### `params` y Enrutamiento Dinámico
-
-Los endpoints soportan las mismas características que hacen las páginas de [rutas dinámicas](/es/guides/routing/#rutas-dinámicas). Asigna un nombre a tu archivo con un nombre de parámetro entre corchetes y exporta una [función `getStaticPaths()`](/es/reference/api-reference/#getstaticpaths). Después, ya puedes acceder al parámetro usando la propiedad de `params` que fue pasado a la función del endpoint.
-
-```ts title="src/pages/api/[id].json.ts"
-import type { APIRoute } from 'astro';
-
-const usernames = ["Sarah", "Chris", "Dan", "Yan", "Elian"]
-
-export const GET: APIRoute = ({ params, request }) => {
-  const id = params.id;
-  return new Response(
-    JSON.stringify({
-      name: usernames[id]
-    })
-  )
-}
-
-export function getStaticPaths() {
-  return [ 
-    { params: { id: "0"} },
-    { params: { id: "1"} },
-    { params: { id: "2"} },
-    { params: { id: "3"} }
-  ]
-};
-```
-
-Esto te va a generar cuatro JSON endpoints al momento de compilación: `/api/0.json`, `/api/1.json`, `/api/2.json` y `/api/3.json`. El enrutamiento dinámico con endpoints funciona igual que con las páginas, pero debido a que el endpoint es una función y no un componente, las [props](/es/reference/api-reference/#transferencia-de-datos-con-props) no son compatibles.
-
-### `request`
-
-Todos los endpoints reciben una propiedad `request`, pero en el modo estático, solo tienes acceso a `request.url`. Esto retorna una URL completa del endpoint actual y funciona del mismo modo que [Astro.request.url](/es/reference/api-reference/#astrorequest) funciona con las páginas.
-
-```ts title="src/pages/request-path.json.ts"
-import type { APIRoute } from 'astro';
-
-export const GET: APIRoute = ({ params, request }) => {
-  return new Response(JSON.stringify({
-      path: new URL(request.url).pathname
-    })
-  )
-}
-```
-
-## Endpoints del Servidor (Rutas de API)
-
-Todo lo descrito en la sección de endpoints de archivos estáticos también se puede usar en modo SSR: los archivos pueden exportar una función `get` que recibe un [objeto de contexto](/es/reference/api-reference/#contexto-del-endpoint) con propiedades similares a las de `Astro` global.
-
-Pero, a diferencia del modo `static`, cuando configuras el modo `server`, los endpoints se construirán cuando se soliciten. Esto desbloquea nuevas funciones que no están disponibles al momento de la compilación y permite crear rutas de API que escuchan solicitudes y ejecutan código de forma segura en el servidor en tiempo de ejecución.
-
-Tus rutas se renderizarán bajo demanda de forma predeterminada en el modo `server`. En el modo `hybrid`, debes optar por no pre-renderizar para cada endpoint personalizado con `export const prerender = false`.
-
-<RecipeLinks slugs={["es/recipes/call-endpoints"]}/>
-
-:::note
-Asegúrate de [habilitar el modo de renderizado bajo demanda](/es/guides/on-demand-rendering/) antes de probar estos ejemplos y no optar por el prerenderizado en modo `hybrid`. 
-:::
-
-Los endpoints del servidor pueden acceder a `params` sin exportar `getStaticPaths`, y pueden retornar un objeto [`Response`](https://developer.mozilla.org/es/docs/Web/API/Response), lo que te permite establecer códigos de estado y encabezados:
-
-```js title="src/pages/[id].json.js"
-import { getProduct } from '../db';
-
-export async function GET({ params }) {
-  const id = params.id;
-  const product = await getProduct(id);
-
-  if (!product) {
-    return new Response(null, {
-      status: 404,
-      statusText: 'No Encontrado'
-    });
-  }
-
-  return new Response(
-    JSON.stringify(product), {
-      status: 200,
-      headers: {
-        "Content-Type": "application/json"
-      }
-    }
-  );
-};
-```
-
-Esto responderá a cualquier solicitud que coincida con la ruta dinámica. Por ejemplo, si navegamos a `/helmet.json`, `params.id` se establecerá en `helmet`. Si el `helmet` existe en la base de datos del producto simulado, el endpoint usará la creación del objeto `Response` para responder con JSON y devolver un [código de estado HTTP](https://developer.mozilla.org/es/docs/Web/API/Response/status) exitoso. Si no, utilizará un objeto `Response` para responder con un `404`.
-
-En modo SSR, ciertos proveedores requieren que el encabezado `Content-Type` devuelva una imagen. En este caso, usa un objeto `Response` para especificar una propiedad de `headers`. Por ejemplo, para producir una imagen binaria en formato `.png`:
-
-```ts title="src/pages/astro-logo.png.ts"
-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, {
-    headers: { "Content-Type": "image/png" },
-  });
-}
-```
-
-### Métodos HTTP
-
-Además de la función `GET`, puedes exportar una función con el nombre de cualquier [método HTTP](https://developer.mozilla.org/es/docs/Web/HTTP/Methods). Cuando llega una solicitud, Astro verificará el método y llamará a la función correspondiente.
-
-También puedes exportar una función `ALL` para coincidir con cualquier método que no tenga una función correspondiente exportada. Si hay una solicitud sin método coincidente, se redirigirá a la [página 404 personalizada](/es/basics/astro-pages/#página-de-error-404-personalizada) de tu sitio.
-
-```ts title="src/pages/methods.json.ts"
-export const GET: APIRoute = ({ params, request }) => {
-  return new Response(JSON.stringify({
-      message: "¡Esto es un GET!"
-    })
-  )
-}
-
-export const POST: APIRoute = ({ request }) => {
-  return new Response(JSON.stringify({
-      message: "¡Esto es un POST!"
-    })
-  )
-}
-
-export const DELETE: APIRoute = ({ request }) => {
-  return new Response(JSON.stringify({
-      message: "¡Esto es un DELETE!"
-    })
-  )
-}
-
-export const ALL: APIRoute = ({ request }) => {
-  return new Response(JSON.stringify({
-      message: `¡Esto fue un ${request.method}!`
-    })
-  )
-}
-```
-
-<RecipeLinks slugs={["es/recipes/captcha", "es/recipes/build-forms-api" ]}/>
-
-### `request`
-
-En modo SSR, la propiedad `request` retorna un objeto [`Request`](https://developer.mozilla.org/es/docs/Web/API/Request) totalmente utilizable que hace referencia a la solicitud actual. Esto permite aceptar datos y verificar encabezados:
-
-```ts title="src/pages/test-post.json.ts"
-export const POST: APIRoute = async ({ request }) => {
-  if (request.headers.get("Content-Type") === "application/json") {
-    const body = await request.json();
-    const nombre = body.nombre;
-    return new Response(JSON.stringify({
-      message: "Tu nombre fue: " + nombre
-    }), {
-      status: 200
-    })
-  }
-  return new Response(null, { status: 400 });
-};
-```
-
-### Redirecciones
-
-El contexto del endpoint exporta la utilidad `redirect()` similar a `Astro.redirect`:
-
-```js title="src/pages/links/[id].js" {14}
-import { getLinkUrl } from '../db';
-
-export async function GET({ params, redirect }) {
-  const { id } = params;
-  const link = await getLinkUrl(id);
-
-  if (!link) {
-    return new Response(null, {
-      status: 404,
-      statusText: 'No encontrado'
-    });
-  };
-
-  return redirect(link, 307);
-};
-```
diff --git a/src/content/docs/es/guides/environment-variables.mdx b/src/content/docs/es/guides/environment-variables.mdx
index e3f7fc0b90416..da01b123a45e8 100644
--- a/src/content/docs/es/guides/environment-variables.mdx
+++ b/src/content/docs/es/guides/environment-variables.mdx
@@ -27,7 +27,7 @@ PUBLIC_ANYBODY=ahí
 En este ejemplo, `PUBLIC_ANYBODY` (accesible mediante `import.meta.env.PUBLIC_ANYBODY`) estará disponible tanto en el servidor como el cliente, mientras que `SECRET_PASSWORD` (accesible mediante `import.meta.env.SECRET_PASSWORD`) estará disponible solo en el servidor.
 
 :::caution
-Los archivos `.env` no son cargados dentro de [archivos de configuración](/es/guides/configuring-astro/#variables-de-entorno).
+Los archivos `.env` no son cargados dentro de [archivos de configuración](#in-the-astro-config-file).
 :::
 
 ### IntelliSense para TypeScript
@@ -190,7 +190,7 @@ const data = await db(import.meta.env.DB_PASSWORD);
 const data = fetch(`${import.meta.env.PUBLIC_POKEAPI}/pokemon/squirtle`);
 ```
 
-Cuando se utiliza SSR, se puede acceder a las variables de entorno en tiempo de ejecución en función del adaptador SSR que se esté utilizando. Con la mayoría de los adaptadores puedes acceder a las variables de entorno con `process.env`, pero algunos adaptadores funcionan de forma diferente. Para el adaptador Deno, utilizará `Deno.env.get()`. Mira cómo [acceder al runtime de Cloudflare](/es/guides/integrations-guide/cloudflare/#tiempo-de-ejecución-de-cloudflare) para manejar las variables de entorno cuando utilices el adaptador de Cloudflare. Astro comprobará primero el entorno del servidor en busca de variables, y si no existen, Astro las buscará en los archivos .env.
+Cuando se utiliza SSR, se puede acceder a las variables de entorno en tiempo de ejecución en función del adaptador SSR que se esté utilizando. Con la mayoría de los adaptadores puedes acceder a las variables de entorno con `process.env`, pero algunos adaptadores funcionan de forma diferente. Para el adaptador Deno, utilizará `Deno.env.get()`. Mira cómo [acceder al runtime de Cloudflare](/es/guides/integrations-guide/cloudflare/#cloudflare-runtime) para manejar las variables de entorno cuando utilices el adaptador de Cloudflare. Astro comprobará primero el entorno del servidor en busca de variables, y si no existen, Astro las buscará en los archivos .env.
 
 ## Variables de entorno con seguridad de tipos
 
diff --git a/src/content/docs/es/guides/fonts.mdx b/src/content/docs/es/guides/fonts.mdx
deleted file mode 100644
index 23ad797c42d70..0000000000000
--- a/src/content/docs/es/guides/fonts.mdx
+++ /dev/null
@@ -1,142 +0,0 @@
----
-title: Usando fuentes personalizadas
-description: >-
-  ¿Buscas agregar tipografías personalizadas a un proyecto de Astro? Usa Google
-  Fonts con Fontsource o añade una fuente a elección.
-i18nReady: true
----
-import PackageManagerTabs from '~/components/tabs/PackageManagerTabs.astro';
-import { Steps } from '@astrojs/starlight/components'
-
-
-Esta guía te mostrará cómo añadir fuentes web a tu proyecto y usarlas en tus componentes.
-
-## Usando un archivo de fuente local
-
-Este ejemplo demostrará cómo añadir una fuente personalizada usando el archivo de fuente `DistantGalaxy.woff`.
-
-<Steps>
-1. Añade tu archivo de fuente a la carpeta `public/fonts/`.
-2. Agrega la siguiente declaración `@font-face` a tu CSS. Esto puede ser en un archivo `.css` global que importes, un bloque `<style is:global>` o un bloque `<style>` en un diseño o componente específico donde quieras usar esta fuente.
-
-    ```css
-    /* Registra tu font family personalizada y le indicamos al navegador dónde encontrarla. */
-    @font-face {
-      font-family: 'DistantGalaxy';
-      src: url('/fonts/DistantGalaxy.woff') format('woff');
-      font-weight: normal;
-      font-style: normal;
-      font-display: swap;
-    }
-    ```
-
-3. Usa el valor de `font-family` de la declaración `@font-face` para dar estilo a los elementos en tu componente o diseño. En este ejemplo, el encabezado `<h1>` tendrá la fuente personalizada aplicada, mientras que el párrafo `<p>` no.
-
-    ```astro title="src/pages/example.astro" {9-11}
-    ---
-    ---
-
-    <h1>En una galaxia muy, muy lejana...</h1>
-
-    <p>¡Las fuentes personalizadas hacen que mis títulos se vean mucho mejor!</p>
-
-    <style>
-    h1 {
-      font-family: 'DistantGalaxy', sans-serif;
-    }
-    </style>
-    ```
-</Steps>
-
-## Usando Fontsource
-
-El proyecto [Fontsource](https://fontsource.org/) simplifica el uso de Google Fonts y otras fuentes de código abierto. Provee módulos npm que puedes instalar para las fuentes que desees utilizar.
-
-<Steps>
-1. Encuentra la fuente que quieras usar en el [catálogo de Fontsource](https://fontsource.org/). Este ejemplo usará [Twinkle Star](https://fontsource.org/fonts/twinkle-star).
-2. Instala el paquete de la fuente que hayas elegido.
-
-    <PackageManagerTabs>
-      <Fragment slot="npm">
-      ```shell
-      npm install @fontsource/twinkle-star
-      ```
-      </Fragment>
-      <Fragment slot="pnpm">
-      ```shell
-      pnpm add @fontsource/twinkle-star
-      ```
-      </Fragment>
-      <Fragment slot="yarn">
-      ```shell
-      yarn add @fontsource/twinkle-star
-      ```
-      </Fragment>
-    </PackageManagerTabs>
-
-    :::tip
-    Puedes encontrar el nombre correcto del paquete en la sección “Quick Installation” en la página de cada fuente en el sitio de Fontsource. Comienza con `@fontsource/` o `@fontsource-variable/` seguido del nombre de la fuente.
-    :::
-
-3. Importa el paquete de la fuente en el componente donde quieras usar la fuente. Por lo general, querrás hacer esto en un componente de diseño común para asegurarte de que la fuente esté disponible en todo tu sitio.
-
-    La importación añadirá las reglas de `@font-face` necesarias para configurar la fuente.
-
-    ```astro title="src/layouts/BaseLayout.astro"
-    ---
-    import '@fontsource/twinkle-star';
-    ---
-    ```
-
-4. Usa el nombre de la fuente como se muestra en el ejemplo `body` en la página de Fontsource para el valor de `font-family`. Esto funcionará en cualquier lugar donde puedas escribir CSS en tu proyecto de Astro.
-
-    ```css
-    h1 {
-      font-family: "Twinkle Star", cursive;
-    }
-    ```
-</Steps>
-
-Para optimizar los tiempos de renderizado de tu sitio web, puede que quieras precargar las fuentes que son esenciales para la visualización inicial de la página.
-Consulta la [guía de Fontsource para precargar fuentes](https://fontsource.org/docs/getting-started/preload) para obtener más información y uso.
-
-## Registrando fuentes con Tailwind
-
-Si estás usando la [integración de Tailwind](/es/guides/integrations-guide/tailwind/), puedes usar cualquiera de los métodos anteriores en esta página para instalar tu fuente, con algunas modificaciones. Puedes añadir una [declaración`@font-face` para una fuente local](#usando-un-archivo-de-fuente-local) o usar [la estrategia `import` de Fontsource](#usando-fontsource) para instalar tu fuente.
-
-Para registrar tu fuente en Tailwind:
-
-<Steps>
-1. Sigue los pasos de las guías anteriores, pero deja sin completar el paso final sobre agregar una `font-family` en tu CSS.
-
-2. Agrega el nombre de la tipografía en `tailwind.config.mjs`.
-
-    Este ejemplo agrega `Inter` al conjunto de tipografías sans-serif, junto con fuentes de respaldo predeterminadas por Tailwind CSS.
-
-    ```js title="tailwind.config.mjs" ins={1,8-10}
-    import defaultTheme from 'tailwindcss/defaultTheme'
-
-    /** @type {import('tailwindcss').Config} */
-    export default {
-    	content: ['./src/**/*.{astro,html,js,jsx,md,mdx,svelte,ts,tsx,vue}'],
-    	theme: {
-    		extend: {
-    			fontFamily: {
-    				sans: ['Inter', ...defaultTheme.fontFamily.sans],
-    			},
-    		},
-    	},
-    	plugins: [],
-    }
-    ```
-
-    Ahora, todos los textos sans-serif (estilo por defecto en Tailwind) de tu proyecto utilizarán tu fuente elegida y la clase `font-sans` también aplicará la fuente Inter.
-</Steps>
-
-Revisa [la documentación de Tailwind para agregar fuentes personalizadas](https://tailwindcss.com/docs/font-family#using-custom-values) para más información.
-
-
-## Más recursos
-
-- Aprende como las fuentes web funcionan en la [guía de fuentes web de MDN](https://developer.mozilla.org/es/docs/Learn/CSS/Styling_text/Web_fonts).
-- Genera CSS para tu fuente con [el generador de fuentes web de Font Squirrel](https://www.fontsquirrel.com/tools/webfont-generator).
diff --git a/src/content/docs/es/guides/framework-components.mdx b/src/content/docs/es/guides/framework-components.mdx
deleted file mode 100644
index f373d7e696397..0000000000000
--- a/src/content/docs/es/guides/framework-components.mdx
+++ /dev/null
@@ -1,243 +0,0 @@
----
-title: Componentes de otros frameworks
-description: 'Aprenda a usar React, Svelte, etc.'
-i18nReady: true
----
-import IntegrationsNav from '~/components/IntegrationsNav.astro'
-import ReadMore from '~/components/ReadMore.astro'
-
-Crea tu página web en Astro sin sacrificar tus componentes de framework favoritos. Crea [islas](/es/concepts/islands/) con el framework UI de tu elección.
-
-## Integraciones oficiales de frameworks UI
-
-Astro admite una variedad de frameworks populares, incluidos [React](https://react.dev/), [Preact](https://preactjs.com/), [Svelte](https://svelte.dev/), [Vue](https://vuejs.org/), [SolidJS](https://www.solidjs.com/), [AlpineJS](https://alpinejs.dev/) y [Lit](https://lit.dev/) con integraciones oficiales.
-
-Encuentra aún más [integraciones de frameworks mantenidas por la comunidad](https://astro.build/integrations/?search=&categories%5B%5D=frameworks) (por ejemplo, Angular, Qwik, Elm) en nuestro directorio de integraciones.
-
-<IntegrationsNav category="renderer" />
-
-## Instalando integraciones
-
-Una o varias de estas integraciones de Astro se pueden instalar y configurar en tu proyecto.
-
-Consulta la [Guía de integraciones](/es/guides/integrations-guide/) para obtener más detalles sobre la instalación y configuración de las integraciones de Astro.
-
-:::tip
-¿Quieres ver un ejemplo para el framework de tu elección? Visita [astro.new](https://astro.new/latest/frameworks) y selecciona una de las plantillas de framework.
-:::
-
-## Usando componente de framework
-
-¡Usa los componentes de tu framework JavaScript en tus páginas de Astro, diseños y componentes al igual que los componentes de Astro! Todos sus componentes pueden vivir juntos en `/src/components`, o pueden organizarse de la manera que desee.
-
-Para usar un componente de framework, importalo desde su ruta relativa en el script de tu componente Astro. Luego, usa el componente junto con otros componentes, elementos HTML y expresiones JSX-like en la plantilla del componente.
-
-```astro title="src/pages/static-components.astro" ins={2,7}
----
-import MyReactComponent from '../components/MyReactComponent.jsx';
----
-<html>
-  <body>
-    <h1>¡Usa componentes de React directamente en Astro!</h1>
-    <MyReactComponent />
-  </body>
-</html>
-```
-
-Por defecto, tus componentes de framework solo se renderizarán en el servidor, como HTML estático. Esto es útil para crear componentes de maquetado que no son interactivos y evitar enviar código JavaScript innecesario al cliente.
-
-## Hidratando componentes interactivos
-
-Un componente de framework puede hacerse interactivo (hidratado) usando una de las [directivas `client:*`](/es/reference/directives-reference/#directivas-del-cliente). Estos son atributos del componente que derminan cuando tu componente de JavaScript debería ser enviado al navegador.
-
-Con todas las directivas de cliente excepto `client:only`, tu componente se renderizará primero en el servidor para generar el HTML estático. El código JavaScript se mandará al navegador de acuerdo con la directiva que hayas escogido. De esta forma el componente se hidratará y se volverá interactivo.
-
-```astro title="src/pages/interactive-components.astro" /client:\S+/
----
-// Ejemplo: hidratando los componentes de framework en el navegador.
-import InteractiveButton from '../components/InteractiveButton.jsx';
-import InteractiveCounter from '../components/InteractiveCounter.jsx';
-import InteractiveModal from '../components/InteractiveModal.svelte';
----
-<!-- Este componente de JavaScript comenzará a importarse cuando se cargue la página-->
-<InteractiveButton client:load />
-
-<!-- El JavaScript de este componente no se enviará al cliente hasta que
-el usuario se desplace hacia abajo y el componente sea visible en la página -->
-<InteractiveCounter client:visible />
-
-<!-- Este componente no se renderizará en el servidor, pero se renderizará en el 
-cliente cuando la página cargue -->
-<InteractiveModal client:only="svelte" />
-```
-
-:::caution
-El framework de JavaScript (React, Svelte, etc.) necesario para renderizar el componente será enviado al navegador junto con el código JavaScript del componente. Si dos o más componentes en una página usan el mismo framework, el framework solo se mandará una vez.
-:::
-
-:::note[Accesibilidad]
-La mayoría de los patrones de accesibilidad específicos de cada framework deberían funcionar cuando estos componentes se usan en Astro. ¡Asegúrate de elegir una directiva de cliente que asegure que cualquier JavaScript relacionado con la accesibilidad se cargue y ejecute correctamente en el momento adecuado!
-:::
-
-### Directivas de hidratación disponibles
-
-Hay varias directivas de hidratación disponibles para los componentes de framework: `client:load`, `client:idle`, `client:visible`, `client:media={QUERY}` y `client:only={FRAMEWORK}`.
-
-<ReadMore>Consulta nuestra página de [referencia de directivas](/es/reference/directives-reference/#directivas-del-cliente) para obtener una descripción completa de las directivas de hidratación y sus usos.</ReadMore>
-
-## Mezclando frameworks
-
-Puedes importar y renderizar componentes usando múltiples frameworks en el mismo componente de Astro.
-
-```astro title="src/pages/mixing-frameworks.astro"
----
-// Ejemplo: Mezclando múltiples componentes del framework en la misma página.
-import MyReactComponent from '../components/MyReactComponent.jsx';
-import MySvelteComponent from '../components/MySvelteComponent.svelte';
-import MyVueComponent from '../components/MyVueComponent.vue';
----
-<div>
-  <MySvelteComponent />
-  <MyReactComponent />
-  <MyVueComponent />
-</div>
-```
-
-:::caution
-Solo los componentes de **Astro** (`.astro`) pueden contener componentes de múltiples frameworks.
-:::
-
-## Pasando props al componente de framework
-
-Puedes pasar props desde componentes de Astro a tus componentes de framework:
-
-```astro title="src/pages/frameworks-props.astro"
----
-import TodoList from '../componentes/TodoList.jsx';
-import Counter from '../components/Counter.svelte';
----
-<div>
-  <TodoList initialTodos={["aprender Astro", "revisar PRs"]} />
-  <Counter startingCount={1} />
-</div>
-```
-
-:::caution[Pasando funciones como props]
-Puedes pasar una función como prop a un componente de framework, pero este solo funcionará al renderizar el componente en el servidor. Si intentas usar la función en un componente hidratado (por ejemplo, como un evento), se producirá un error.
-
-Esto es porque las funciones no pueden ser _serializadas_ (transferidas desde el servidor al cliente) por Astro.
-
-
-## Pasando children a componentes de framework
-
-Dentro de un componente de Astro, **puedes** pasar elementos children a los componentes del framework. Cada framework tiene sus propios patrones sobre cómo hacer referencia a estos elementos children: React, Preact y Solid usan una prop especial llamada `children`, mientras que Svelte y Vue usan el elemento `<slot />`.
-
-```astro title="src/pages/component-children.astro" {5}
----
-import MyReactSidebar from '../components/MyReactSidebar.jsx';
----
-<MyReactSidebar>
-  <p>Aquí hay una barra lateral con texto y un botón.</p>
-</MyReactSidebar>
-```
-
-Además, puedes usar [slots con nombre](/es/basics/astro-components/#slots-con-nombre) para agrupar hijos específicos.
-
-Para React, Preact y Solid, estos slots se convertirán en una prop de nivel superior. Los slots con nombres que usen `kebab-case` se convertirán a `camelCase`.
-
-```astro title="src/pages/named-slots.astro" /slot="(.*)"/
----
-import MySidebar from '../components/MySidebar.jsx';
----
-<MySidebar>
-  <h2 slot="title">Menu</h2>
-  <p>Aquí hay una barra lateral con texto y un botón.</p>
-  <ul slot="social-links">
-    <li><a href="https://twitter.com/astrodotbuild">Twitter</a></li>
-    <li><a href="https://github.com/withastro">GitHub</a></li>
-  </ul>
-</MySidebar>
-```
-
-```jsx /{props.(title|socialLinks)}/
-// src/components/MySidebar.jsx
-export default function MySidebar(props) {
-  return (
-    <aside>
-      <header>{props.title}</header>
-      <main>{props.children}</main>
-      <footer>{props.socialLinks}</footer>
-    </aside>
-  )
-}
-```
-
-Para Svelte y Vue, puedes hacer referencia a estos slots mediante un elemento `<slot>` con el atributo `name`. Se conservarán los nombres de los slots que usen `kebab-case`.
-
-```jsx /slot name="(.*)"/
-// src/components/MySidebar.svelte
-<aside>
-  <header><slot name="title" /></header>
-  <main><slot /></main>
-  <footer><slot name="social-links" /></footer>
-</aside>
-```
-
-## Anidando componentes de framework
-
-Dentro de un archivo Astro, los children de los componentes de framework también pueden ser componentes hidratados. Esto significa que puedes anidar recursivamente componentes en cualquiera de estos frameworks.
-
-```astro title="src/pages/nested-components.astro" {10-11}
----
-import MyReactSidebar from '../components/MyReactSidebar.jsx';
-import MyReactButton from '../components/MyReactButton.jsx';
-import MySvelteButton from '../components/MySvelteButton.svelte';
----
-
-<MyReactSidebar>
-  <p>Aquí hay una barra lateral con texto y un botón.</p>
-  <div slot="actions">
-    <MyReactButton client:idle />
-    <MySvelteButton client:load />
-  </div>
-
-</MyReactSidebar>
-```
-
-:::caution
-Recuerda: los propios archivos de los componentes de framework (por ejemplo, `.jsx`, `.svelte`) no pueden combinar varios frameworks.
-:::
-
-Esto te permite crear "aplicaciones" completas usando tu framework de JavaScript preferido y renderizarlas, a través de un componente principal, en una página de Astro.
-
-:::note
-Los componentes de Astro siempre se renderizan a HTML estático, incluso cuando incluyen componentes de framework que son hidratados. Esto significa que solo se pueden pasar props que no hacen ninguna renderización a HTML. Pasar "render props" de React a componentes del framework desde un componente de Astro no funcionará, porque los componentes de Astro no pueden proporcionar el renderizado que este patrón requiere. En su lugar, utiliza slots con nombre.
-:::
-
-## ¿Puedo usar componentes de Astro dentro de mis componentes de framework?
-
-Cualquier componente de framework se convierte en una "isla" de ese framework. Estos componentes deben escribirse en su totalidad como código válido para ese framework, utilizando solo sus propios imports y paquetes. No puedes importar componentes `.astro` en un componente de framework (por ejemplo, `.jsx` o `.svelte`).
-
-Sin embargo, puedes usar el patrón [Astro `<slot />`](/es/basics/astro-components/#slots) para pasar el contenido estático generado por los componentes de Astro como elementos secundarios a los componentes de framework **dentro de un Componente `.astro`**.
-
-```astro title="src/pages/astro-children.astro" {6}
----
-import MyReactComponent from  '../components/MyReactComponent.jsx';
-import MyAstroComponent from '../components/MyAstroComponent.astro';
----
-<MyReactComponent>
-  <MyAstroComponent slot="name" />
-</MyReactComponent>
-```
-
-## ¿Puedo hidratar los componentes de Astro?
-
-Si intentas hidratar un componente Astro con un modificador `client:`, obtendrás un error.
-
-Los [componentes de Astro](/es/basics/astro-components/) son componentes de maquetado únicamente en HTML sin ninguna ejecución del lado del cliente. Pero puedes usar una etiqueta `<script>` en el maquetado del componente de Astro para enviar JavaScript al navegador que se ejecutará en un ámbito global.
-
-<ReadMore>Obtenga más información sobre [`<scripts>` del lado del cliente en los componentes de Astro](/es/guides/client-side-scripts/)</ReadMore>
-
-[mdn-io]: https://developer.mozilla.org/es/docs/Web/API/Intersection_Observer_API
-[mdn-ric]: https://developer.mozilla.org/es/docs/Web/API/Window/requestIdleCallback
-[mdn-mm]: https://developer.mozilla.org/es/docs/Web/API/Window/matchMedia
diff --git a/src/content/docs/es/guides/images.mdx b/src/content/docs/es/guides/images.mdx
deleted file mode 100644
index 83703cca998a6..0000000000000
--- a/src/content/docs/es/guides/images.mdx
+++ /dev/null
@@ -1,960 +0,0 @@
----
-title: Imágenes
-description: Aprende cómo usar imágenes en Astro.
-i18nReady: true
----
-import Since from '~/components/Since.astro';
-import PackageManagerTabs from '~/components/tabs/PackageManagerTabs.astro';
-import RecipeLinks from "~/components/RecipeLinks.astro";
-import { Steps } from '@astrojs/starlight/components'
-
-¡Astro ofrece varias formas para que uses imágenes en tu sitio, ya sea que estén almacenadas localmente dentro de tu proyecto, enlazadas desde una URL externa o gestionadas en un CMS o CDN!
-
-## Dónde guardar las imágenes
-
-### `src/` vs. `public/`
-
-Recomendamos que las imágenes locales se mantengan en `src/` cuando sea posible, para que Astro pueda transformar, optimizar y empaquetarlas. Los archivos en el directorio `/public` siempre se sirven o copian tal como están en la carpeta de construcción, sin ningún procesamiento.
-
-Tus imágenes locales almacenadas en `src/` pueden ser utilizadas por todos los archivos en tu proyecto: `.astro`, `.md`, `.mdx`, `.mdoc` y otros frameworks UI. Las imágenes pueden almacenarse en cualquier carpeta, incluida junto a tu contenido.
-
-Almacena tus imágenes en la carpeta `public/` si deseas evitar cualquier tipo de procesamiento o para tener un enlace público directo a ellas.
-
-### Imágenes remotas
-
-También puedes optar por almacenar tus imágenes de forma remota, en un sistema de gestión de contenido (CMS) o en una plataforma de gestión de assets digitales (DAM).
-
-Para una protección adicional al tratar con fuentes externas, las imágenes remotas solo se procesarán desde [fuentes de imágenes autorizadas](#autorizando-imágenes-remotas) especificadas en tu configuración. Sin embargo, cualquier imagen remota puede ser mostrada.
-
-Astro puede obtener tus datos de forma remota utilizando APIs o mostrar imágenes desde su ruta completa de URL. Consulta nuestras [guías de CMS](/es/guides/cms/) para ejemplos de integración con servicios comunes.
-
-
-## Imágenes en archivos `.astro`
-
-En archivos `.astro`, **las imágenes locales deben ser importadas al archivo para poder ser utilizadas**. Las imágenes remotas y las imágenes en `public/` no requieren ser importadas
-
-Importa y utiliza el componente incorporado `<Image />` de Astro para imágenes optimizadas usando `astro:assets`. Alternativamente, la sintaxis de Astro admite escribir directamente una etiqueta HTML `<img>`, lo que omite el procesamiento de imágenes
-
-```astro title="src/pages/blog/my-images.astro"
----
-import { Image } from 'astro:assets';
-import localBirdImage from '../../images/subfolder/localBirdImage.png';
----
-<Image src={localBirdImage} alt="Un pájaro sentado sobre un nido de huevos."/>
-<Image src="/images/bird-in-public-folder.jpg" alt="Un pájaro." width="50" height="50" />
-<Image src="https://example.com/remote-bird.jpg" alt="Un pájaro." width="50" height="50" />
-
-<img src={localBirdImage.src} alt="Un pájaro sentado sobre un nido de huevos.">
-<img src="/images/bird-in-public-folder.jpg" alt="Un pájaro.">
-<img src="https://example.com/remote-bird.jpg" alt="Un pájaro.">
-```
-
-Para importar imágenes dinámicamente desde la carpeta `src/`, consulta la siguiente receta:
-
-<RecipeLinks slugs={["es/recipes/dynamically-importing-images" ]}/>
-
-### `<Image />` (`astro:assets`)
-
-Utiliza el componente integrado `<Image />` de Astro para mostrar versiones optimizadas de tus imágenes locales y [imágenes remotas configuradas](#autorizando-imágenes-remotas).
-
-Las imágenes en la carpeta `public/`, así como las imágenes remotas no configuradas específicamente en tu proyecto, también se pueden usar con el componente Image, pero no se procesarán.
-
-`<Image />` puede transformar las dimensiones, el tipo de archivo y la calidad de una imagen local o remota autorizada para un control sobre la imagen que se muestra. La etiqueta resultante `<img>` incluye atributos `alt`, `loading` y `decoding`, e infiere las dimensiones de la imagen para evitar el **Desplazamiento Acumulativo de Diseño (CLS)**.
-
-:::tip[¿Qué es el Desplazamiento Acumulativo de Diseño?]
-[Desplazamiento Acumulativo de Diseño (CLS)](https://web.dev/cls/) es una métrica de Core Web Vital para medir cuánto se ha desplazado el contenido de tu página durante la carga. El componente `<Image />` optimiza para el CLS al establecer automáticamente el `ancho` y el `alto` correctos para tus imágenes locales.
-:::
-
-```astro title="src/components/MyComponent.astro"
----
-// Importa el componente Image y la imagen 
-import { Image } from 'astro:assets';
-import myImage from '../assets/my_image.png'; // La imagen es 1600x900
----
-
-<!-- `alt` es obligatorio en el componente Imagen -->
-<Image src={myImage} alt="Una descripción de mi imagen." />
-```
-
-```html
-<!-- Salida -->
-<!-- La imagen está optimizada, se aplican los atributos adecuados-->
-<img
-  src="/_astro/my_image.hash.webp"
-  width="1600"
-  height="900"
-  decoding="async"
-  loading="lazy"
-  alt="Una descripción de mi imagen."
-/>
-```
-
-#### Propiedades
-
-##### src (requerido)
-
-El formato del valor `src` de tu archivo de imagen depende de dónde esté ubicado tu archivo de imagen:
-
-- **Imágenes locales en `src/`** - también debes **importar la imagen** utilizando una ruta de archivo relativa o configurar y usar un [alias de importación](/es/guides/imports/#alias). Luego usa el nombre de importación como valor de `src`:
-
-  ```astro title="src/pages/index.astro" "myImportedImage" "{myImportedImage}"
-  ---
-  import { Image } from 'astro:assets';
-  import myImportedImage from '../assets/my-local-image.png'
-  ---
-  <Image src={myImportedImage} alt="texto descriptivo" />
-  ```
-
-- **Imágenes en la carpeta `public/`** - utiliza la **ruta de archivo de la imagen relativa a la carpeta public**:
-
-  ```astro title="src/pages/index.astro" '"/images/my-public-image.png"'
-  ---
-  import { Image } from 'astro:assets';
-  ---
-  <Image
-    src="/images/my-public-image.png"
-    alt="texto descriptivo"
-    width="200"
-    height="150"
-  />
-  ```
-
-- **Imágenes remotas** - utiliza la **URL completa** de la imagen como valor de la propiedad:
-
-  ```astro title="src/pages/index.astro" '"https://example.com/remote-image.jpg"'
-  ---
-  import { Image } from 'astro:assets';
-  ---
-  <Image
-    src="https://example.com/remote-image.jpg"
-    alt="texto descriptivo"
-    width="200"
-    height="150" 
-   />
-  ```
-
-##### alt (requerido)
-
-Utiliza el atributo `alt` requerido para proporcionar un [texto alternativo descriptivo](https://www.w3.org/WAI/tutorials/images/) para las imágenes.
-
-Si una imagen es meramente decorativa (es decir, no contribuye a la comprensión de la página), establece `alt=""` para que los lectores de pantalla y otras tecnologías de asistencia sepan que deben ignorar la imagen.
-
-##### width y height (requerido para imágenes en `public/`)
-
-Estas propiedades definen las dimensiones a utilizar para la imagen.
-
-Cuando se utilizan imágenes en su relación de aspecto original, `width` y `height` son opcionales. Estas dimensiones pueden inferirse automáticamente de archivos de imagen ubicados en `src/` y de imágenes remotas con [`inferSize` establecido en `true`](#infersize).
-
-Sin embargo, ambas de estas propiedades son necesarias para imágenes almacenadas en tu carpeta `public/`, ya que Astro no puede analizar estos archivos.
-
-##### densities
-
-<p><Since v="3.3.0" /></p>
-
-Una lista de densidades de píxeles para generar la imagen.
-
-Si se proporciona, este valor se utilizará para generar un atributo `srcset` en la etiqueta `<img>`. No proporciones un valor para `widths` cuando utilices este valor.
-
-Las densidades que sean iguales a los anchos mayores que la imagen original se ignorarán para evitar el escalado de la imagen.
-
-```astro title="src/components/MyComponent.astro"
----
-import { Image } from 'astro:assets';
-import myImage from '../assets/my_image.png';
----
-<Image
-  src={myImage}
-  width={myImage.width / 2}
-  densities={[1.5, 2]}
-  alt="Una descripción de mi imagen."
-/>
-```
-
-```html
-<!-- Output -->
-<img
-  src="/_astro/my_image.hash.webp"
-  srcset="
-    /_astro/my_image.hash.webp 1.5x
-    /_astro/my_image.hash.webp 2x
-  "
-  alt="Una descripción de mi imagen"
-  width="800"
-  height="450"
-  loading="lazy"
-  decoding="async"
-/>
-```
-
-##### widths
-
-<p><Since v="3.3.0" /></p>
-
-Una lista de anchos para generar la imagen.
-
-Si se proporciona, este valor se utilizará para generar un atributo `srcset` en la etiqueta `<img>`. También se debe proporcionar una propiedad [`sizes`](https://developer.mozilla.org/en-US/docs/Web/API/HTMLImageElement/sizes).
-
-No proporciones un valor para `densities` cuando utilices este valor. Solo uno de estos dos valores se puede utilizar para generar un `srcset`.
-
-Los anchos que sean mayores que la imagen original se ignorarán para evitar el escalado de la imagen.
-
-```astro
----
-import { Image } from 'astro:assets';
-import myImage from ''../assets/my_image.png'; // La imagen es de 1600x900
----
-<Image 
-  src={myImage} 
-  widths={[240, 540, 720, myImage.width]} 
-  sizes={`(max-width: 360px) 240px, (max-width: 720px) 540px, (max-width: 1600px) 720px, ${myImage.width}px`} 
-  alt="Una descripción de mi imagen." 
-/>
-```
-
-```html
-<!-- Output -->
-<img
-  src="/_astro/my_image.hash.webp"
-  srcset="
-    /_astro/my_image.hash.webp 240w,
-    /_astro/my_image.hash.webp 540w,
-    /_astro/my_image.hash.webp 720w,
-		/_astro/my_image.hash.webp 1600w
-  "
-  sizes="
-    (max-width: 360px) 240px,
-    (max-width: 720px) 540px,
-    (max-width: 1600px) 720px,
-    1600px
-  "
-  alt="Una descripción de mi imagen."
-  width="1600"
-  height="900"
-  loading="lazy"
-  decoding="async"
-/>
-```
-
-##### format
-
-Puedes opcionalmente indicar el [tipo de archivo de imagen](https://developer.mozilla.org/en-US/docs/Web/Media/Formats/Image_types#common_image_file_types) de salida que se va a utilizar.
-
-Por defecto, el componente `<Image />` producirá un archivo `.webp`.
-
-##### quality
-
-`quality` es una propiedad opcional que puede ser:
-- un preajuste (`low`, `mid`, `high`, `max`) que se normaliza automáticamente entre los formatos.
-- un número del `0` al `100` (interpretado de manera diferente entre los formatos).
-
-##### inferSize
-
-<p><Since v="4.4.0" /></p>
-
-Te permite establecer automaticamente el `width` y `height` original de una imagen remota.
-
-Por defecto, este valor está establecido en `false` y debes especificar manualmente ambas dimensiones para tus imágenes remotas.
-
-Agrega `inferSize` al componente `<Image />` (o `inferSize: true` a `getImage()`) para inferir estos valores del contenido de la imágen cuando se obtiene. Esto es útil si no conoces las dimensiones de la imagen remota, o si éstas pueden cambiar:
-
-```astro mark="inferSize"
----
-import { Image } from 'astro:assets';
----
-<Image src="https://example.com/cat.png" inferSize alt="Un gato durmiendo al sol." />
-```
-
-`inferSize` puede obtener las dimensiones de una [imagen remota de un dominio que no ha sido autorizado](#autorizando-imágenes-remotas), sin embargo la imagen en sí permanecerá sin procesar.
-
-##### Propiedades adicionales
-
-Además de las propiedades mencionadas anteriormente, el componente `<Image />` acepta todas las propiedades aceptadas por la etiqueta HTML `<img>`.
-
-Por ejemplo, puedes proporcionar una propiedad `class` al elemento `<img>` final.
-
-```astro title="src/pages/index.astro"
----
-import { Image } from 'astro:assets';
-import myImage from '../assets/my_image.png';
----
-
-<!-- `alt` es obligatorio en el componente Imagen -->
-<Image src={myImage} alt="" class="mi-clase" />
-```
-
-```html
-<!-- Salida -->
-<img
-  src="/_astro/my_image.hash.webp"
-  width="1600"
-  height="900"
-  decoding="async"
-  loading="lazy"
-  class="mi-clase"
-  alt=""
-/>
-```
-
-#### Estableciendo valores por defecto
-
-Actualmente, no hay forma de especificar valores predeterminados para todos los componentes `<Image />`. Los atributos requeridos deben establecerse en cada componente individual.
-
-Como alternativa, puedes envolver estos componentes en otro componente de Astro para reutilizarlos. Por ejemplo, podrías crear un componente para las imágenes de tus entradas de blog:
-
-```astro title="src/components/BlogPostImage.astro"
----
-import { Image } from 'astro:assets';
-
-const { src, ...attrs } = Astro.props;
----
-<Image src={src} {...attrs} />
-
-<style>
-  img :global(img), svg {
-    margin-block: 2.5rem;
-    border-radius: 0.75rem;
-  }
-</style>
-```
-
-### `<Picture />`
-
-<p><Since v="3.3.0" /></p>
-
-Usa el componente `<Picture />` incorporado de Astro para mostrar una imagen receptiva con varios formatos y/o tamaños.
-
-```astro title="src/pages/index.astro"
----
-import { Picture } from 'astro:assets';
-import myImage from '../assets/my_image.png'; // La imagen es de 1600x900
----
-
-<!-- `alt` es obligatorio en el componente Picture -->
-<Picture src={myImage} formats={['avif', 'webp']} alt="Una descripción de mi imagen." />
-```
-
-```html
-<!-- Salida -->
-<picture>
-  <source srcset="/_astro/my_image.hash.avif" type="image/avif" />
-  <source srcset="/_astro/my_image.hash.webp" type="image/webp" />
-  <img
-    src="/_astro/my_image.hash.png"
-    width="1600"
-    height="900"
-    decoding="async"
-    loading="lazy"
-    alt="Una descripción de mi imagen."
-  />
-</picture>
-```
-
-#### Propiedades
-
-`<Picture />` acepta todas las propiedades del componente `<Image />`, más las siguientes:
-
-##### `formats`
-
-Un arreglo de formatos de imagen para usar en las etiquetas `<source>`. Las entradas se agregarán como elementos `<source>` en el orden en que se enumeran, y este orden determina qué formato se muestra. Para obtener el mejor rendimiento, enumera el formato más moderno primero (por ejemplo, `webp` o `avif`). Por defecto, esto se establece en `['webp']`.
-
-##### `fallbackFormat`
-
-Formato que se utilizará como valor de respaldo para la etiqueta `<img>`.
-
-El valor predeterminado es `.png` para imágenes estáticas (o `.jpg` si la imagen es un archivo JPG), `.gif` para imágenes animadas y `.svg` para archivos SVG.
-
-##### `pictureAttributes`
-
-Un objeto de atributos que se agregarán a la etiqueta `<picture>`.
-
-Usa esta propiedad para aplicar atributos al elemento `<picture>` externo. Los atributos aplicados al componente `<Picture />` directamente se aplicarán al elemento `<img>` interno, excepto aquellos utilizados para la transformación de imágenes.
-
-```astro title="src/components/MyComponent.astro"
----
-import { Picture } from "astro:assets";
-import myImage from "../my_image.png"; // La imagen es de 1600x900
----
-
-<Picture
-  src={myImage}
-  alt="Una descripción de mi imagen."
-  pictureAttributes={{ style: "background-color: red;" }}
-/>
-```
-
-```html
-<picture style="background-color: red;">
-  <source srcset="/_astro/my_image.hash.webp" type="image/webp" />
-  <img
-    src="/_astro/my_image.hash.png"
-    alt="Una descripción de mi imagen."
-    width="1600"
-    height="900"
-    loading="lazy"
-    decoding="async"
-  />
-</picture>
-```
-
-### `<img>`
-
-La [sintaxis de Astro](/es/reference/astro-syntax/) también admite escribir directamente una etiqueta `<img>`, con control total sobre su salida final. Estas imágenes no se procesarán ni optimizarán.
-
-Esta acepta todas las propiedades de la etiqueta HTML `<img>`, y la única propiedad requerida es `src`.
-
-#### Imágenes locales en `src/`
-
-Las imágenes locales deben ser **importadas desde la ruta relativa** al archivo `.astro` existente, o configurar y usar un [alias de importación](/es/guides/imports/#alias). Luego, puedes acceder a la propiedad `src` de la imagen y otras propiedades para usar en la etiqueta `<img>`.
-
-Por ejemplo, utiliza las propiedades `height` y `width` propias de la imagen para evitar CLS y mejorar los Core Web Vitals.
-
-```astro title="src/pages/posts/post-1.astro" "myDog.width" "myDog.height"
----
-// importar imágenes locales
-import myDog from '../../images/pets/local-dog.jpg'
----
-// acceder a las propiedades de la imagen
-<img src={myDog.src} width={myDog.width} height={myDog.height} alt="Un perro ladrando." />
-```
-
-Los activos de imagen importados coinciden con la siguiente firma:
-
-```ts
-interface ImageMetadata {
-  src: string;
-  width: number;
-  height: number;
-  format: string;
-}
-```
-
-#### Imágenes en `public/`
-
-Para las imágenes ubicadas dentro de `public/`, utiliza la **ruta de archivo relativa a la carpeta public** de la imagen como valor de `src`:
-
-```astro '"/images/public-cat.jpg"'
-<img src="/images/public-cat.jpg" alt="Un gato dormiendo." >
-```
-
-#### Imágenes remotas
-
-Para las imágenes remotas, utiliza la **URL completa** de la imagen como valor de `src`:
-
-```astro '"https://example.com/remote-cat.jpg"'
-<img src="https://example.com/remote-cat.jpg" alt="Un gato dormiendo." >
-```
-
-### Eligiendo `<Image />` vs `<img>`
-
-El componente `<Image />` optimiza tu imagen e infiere el ancho y el alto (en imágenes locales) en función de la relación de aspecto original para evitar CLS. Sin embargo, solo funciona con ciertos formatos y no proporciona un elemento `<picture>`, ni admite `srcset`.
-
-Utiliza el elemento HTML `<img>` cuando no puedas usar el componente `<Image />`, por ejemplo:
-  - para formatos de imagen no admitidos
-  - cuando no deseas que tu imagen se optimice mediante Astro
-  - para acceder y cambiar el atributo `src` dinámicamente en el lado del cliente
-
-### Autorizando imágenes remotas
-
-Puedes configurar listas de dominios y patrones de URL de origen de imágenes autorizados para la optimización de imágenes utilizando [`image.domains`](/es/reference/configuration-reference/#imagedomains) y [`image.remotePatterns`](/es/reference/configuration-reference/#imageremotepatterns). Esta configuración es una capa adicional de seguridad para proteger tu sitio al mostrar imágenes desde una fuente externa.
-
-Remote images from other sources will not be optimized, but using the `<Image />` component for these images will prevent Cumulative Layout Shift (CLS).
-
-For example, the following configuration will only allow remote images from `astro.build` to be optimized:
-
-```ts
-// astro.config.mjs
-export default defineConfig({
-  image: {
-    domains: ["astro.build"],
-  }
-});
-```
-
-La siguiente configuración solo permitirá que las imágenes remotas provengan de hosts HTTPS:
-
-```ts
-// astro.config.mjs
-export default defineConfig({
-  image: {
-    remotePatterns: [{ protocol: "https" }],
-  }
-});
-```
-
-## Utilizando imágenes de un CMS o CDN
-
-Los CDNs de imágenes funcionan con todas las opciones de imágenes de Astro. Utiliza la URL completa de la imagen como atributo `src` en el componente `<Image />`, una etiqueta `<img>` o en la notación Markdown. Para la optimización de imágenes con imágenes remotas, también [configura tus dominios autorizados o patrones de URL](#autorizando-imágenes-remotas).
-
-Alternativamente, si el CDN proporciona un SDK de Node.js, puedes utilizarlo en tu proyecto. Por ejemplo, el SDK de [Cloudinary](https://cloudinary.com/documentation/node_integration) puede generar una etiqueta `<img>` con el `src` adecuado por ti.
-
-## Imágenes en archivos Markdown
-
-Utiliza la sintaxis estándar de Markdown `![alt](src)` en tus archivos `.md`. Esta sintaxis funciona con la [API de servicio de imagenes](/es/reference/image-service-reference/) de Astro para optimizar tus imágenes locales almacenadas en `src/`. Las imágenes remotas y las imágenes almacenadas en la carpeta `public/` no son optimizadas.
-
-```md
-<!-- src/pages/post-1.md -->
-
-# Mi página Markdown
-
-<!-- Imagen local almacenada en src/assets/ -->
-<!-- Utiliza una ruta de archivo relativa o un alias de importación -->
-![Un cielo estrellado.](../assets/stars.png)
-
-<!-- Imagen almacenada en public/images/ -->
-<!-- Utiliza la ruta de archivo relativa a public/ -->
-![Un cielo estrellado.](/images/stars.png)
-
-<!-- Imagen remota en otro servidor -->
-<!-- Utiliza la URL completa de la imagen -->
-![Astro](https://example.com/images/remote-image.png)
-```
-
-La etiqueta `<img>` no es compatible para imágenes locales y el componente `<Image />` no está disponible en archivos `.md`.
-
-Si necesitas más control sobre los atributos de tus imágenes, te recomendamos utilizar el formato de archivo `.mdx`, que te permite incluir el componente `<Image />` de Astro o una etiqueta JSX `<img />` además de la sintaxis Markdown. Utiliza la [integración MDX](/es/guides/integrations-guide/mdx/) para agregar soporte para MDX en Astro.
-
-## Imágenes en archivos MDX
-
-Puedes utilizar el componente `<Image />` de Astro y las etiquetas JSX `<img />` en tus archivos `.mdx` importando tanto el componente como tu imagen. Úsalos tal como se [utilizan en archivos `.astro`](#imágenes-en-archivos-astro).
-
-Además, hay soporte para la [sintaxis estándar de Markdown `![alt](src)`](#imágenes-en-archivos-markdown) sin necesidad de importación.
-
-```mdx title="src/pages/post-1.mdx"
----
-title: Título de mi página
----
-import { Image } from 'astro:assets';
-import rocket from '../assets/rocket.png';
-
-# Mi Página MDX
-
-// Imagen local almacenada en la misma carpeta
-![Houston in the wild](houston.png)
-
-// Imagen local almacenada en src/assets/
-<Image src={rocket} alt="Un cohete en el espacio." />
-<img src={rocket.src} alt="Un cohete en el espacio." />
-![A rocketship in space](../assets/rocket.png)
-
-// Imagen almacenada en public/images/
-<Image src="/images/stars.png" alt="Un cielo estrellado." />
-<img src="/images/stars.png" alt="Un cielo estrellado." />
-![Un cielo estrellado.](/images/stars.png)
-
-// Imagen remota en otro servidor
-<Image src="https://example.com/images/remote-image.png" />
-<img src="https://example.com/images/remote-image.png" />
-![Astro](https://example.com/images/remote-image.png)
-
-```
-
-## Imágenes en colecciones de contenido
-
-Las imágenes en colecciones de contenido se procesarán de la misma manera que lo hacen en [Markdown](#imágenes-en-archivos-markdown) y [MDX](#imágenes-en-archivos-mdx) dependiendo del tipo de archivo que estés utilizando.
-
-Además, puedes declarar una imagen asociada para una entrada de colecciones de contenido, así como la imagen de portada de una publicación de un blog, en el encabezado utilizando su ruta relativa a la carpeta actual:
-
-```md title="src/content/blog/my-post.md" {3}
----
-title: "Mi primera entrada en el blog"
-cover: "./firstpostcover.jpeg" # se resolverá como "src/content/blog/firstblogcover.jpeg"
-coverAlt: "Una fotografía de una puesta de sol detrás de una cordillera."
----
-
-Esta es una entrada de blog
-```
-
-El helper `image` para el esquema de colecciones de contenido te permite validar los metadatos de la imagen utilizando Zod.
-
-```ts title="src/content/config.ts"
-import { defineCollection, z } from "astro:content";
-
-const blogCollection = defineCollection({
-	schema: ({ image }) => z.object({
-		title: z.string(),
-		cover: image().refine((img) => img.width >= 1080, {
-			message: "¡La imagen de portada debe tener al menos 1080 píxeles de ancho!",
-		}),
-		coverAlt: z.string(),
-	}),
-});
-
-export const collections = {
-	blog: blogCollection,
-};
-```
-
-La imagen se importará y transformará en metadatos, lo que te permitirá pasarlo como `src` a `<Image/>`, `<img>` o `getImage()`.
-
-El siguiente ejemplo muestra una página de índice de un blog que muestra la foto de portada y el título de cada entrada del blog a partir del esquema anterior:
-
-```astro title="src/pages/blog.astro" {10}
----
-import { Image } from "astro:assets";
-import { getCollection } from "astro:content";
-const allBlogPosts = await getCollection("blog");
----
-
-{
-	allBlogPosts.map((post) => (
-		<div>
-			<Image src={post.data.cover} alt={post.data.coverAlt} />
-			<h2>
-				<a href={"/blog/" + post.slug}>{post.data.title}</a>
-			</h2>
-		</div>
-	))
-}
-```
-
-## Imágenes en componentes de frameworks UI
-
-Cuando añadas imágenes en un componente de un framework UI, utiliza la sintaxis de imagen propia del framework para renderizar una imagen (p. ej. `<img/>` en JSX, `<img>` en Svelte).
-
-Las imágenes locales deben **ser importadas primero** para acceder a sus [propiedades de imagen](#imágenes-locales-en-src) como `src`.
-
-```jsx title="src/components/ReactImage.jsx"
-import stars from "../assets/stars.png";
-
-export default function ReactImage () {
-  return (
-    <img src={stars.src} alt="Un cielo estrellado." />
-  )
-}
-```
-
-```svelte title="src/components/SvelteImage.svelte"
-<script>
-  import stars from '../assets/stars.png';
-</script>
-
-<img src={stars.src} alt="Un cielo estrellado." />
-
-```
-
-#### Pasando el componente Image
-
-El componente `<Image />`, al igual que cualquier otro componente de Astro, **no está disponible para los componentes de frameworks UI**.
-
-Sin embargo, puedes pasar el contenido estático generado por `<Image />` a un componente de framework dentro de un archivo `.astro` como hijos o utilizando un [`<slot/>` nombrado](/es/guides/framework-components/#puedo-usar-componentes-de-astro-dentro-de-mis-componentes-de-framework):
-
-
-```astro title="ImageWrapper.astro"
----
-import ReactComponent from './ReactComponent.jsx';
-import { Image } from 'astro:assets';
-import stars from '~/stars/docline.png';
----
-
-<ReactComponent>
-  <Image src={stars} alt="Un cielo estrellado." />
-</ReactComponent>
-```
-
-## Generando imágenes con `getImage()`
-
-:::caution
-`getImage()` se basa en APIs solo para el servidor y provoca errores en la compilación cuando se utiliza en el lado del cliente.
-:::
-
-La función `getImage()` está destinada a generar imágenes que se utilizarán en otro lugar que no sea directamente en HTML, por ejemplo, en una [Ruta API](/es/guides/endpoints/#endpoints-del-servidor-rutas-de-api). También te permite crear tu propio componente `<Image />` personalizado.
-
-<RecipeLinks slugs={["es/recipes/build-custom-img-component" ]}/>
-
-`getImage()` recibe un objeto de opciones con las [mismas propiedades que el componente Image](#propiedades) (excepto `alt`).
-
-```astro
----
-import { getImage } from "astro:assets";
-import myBackground from "../background.png";
-
-const optimizedBackground = await getImage({src: myBackground, format: 'webp'});
----
-
-<div style={`background-image: url(${optimizedBackground.src});`}></div>
-```
-
-Devuelve un objeto con las siguientes propiedades:
-
-```js
-{
-  rawOptions: {...}, // Parámetros originales transmitidos
-  options: {...}, // Parámetros validados transmitidos
-  src: "...", // Ruta a la imagen generada
-  srcSet: {
-    values: [...], // Valores generados para srcset, cada entrada tiene una url y un descriptor de tamaño
-    attribute: "", // Atributo srcset generado a partir de los valores
-  }
-  attributes: {...} // Atributos HTML adicionales necesarios para representar la imagen (anchura, altura, estilo, etc.)
-}
-```
-
-## Texto Alt
-
-No todos los usuarios pueden ver las imágenes de la misma manera, por lo que la accesibilidad es una preocupación especialmente importante al utilizar imágenes. Utiliza el atributo `alt` para proporcionar [texto alternativo descriptivo](https://www.w3.org/WAI/tutorials/images/) para las imágenes.
-
-Este atributo es requerido tanto para los componentes `<Image />` como `<Picture />`. Si no se proporciona texto alternativo, se mostrará un mensaje de error útil recordándote incluir el atributo `alt`.
-
-Si la imagen es meramente decorativa (es decir, no contribuye a la comprensión de la página), establece `alt=""` para que los lectores de pantalla sepan que deben ignorar la imagen.
-
-## Servicio de imágenes por defecto
-
-[Sharp](https://github.com/lovell/sharp) es el servicio de imágenes por defecto utilizado para `astro:assets`. Puedes configurar aún más el servicio de imágenes utilizando la opción [`image.service`](/es/reference/configuration-reference/#imageservice).
-
-:::note
-Cuando se utiliza un [administrador de paquetes estricto](https://pnpm.io/pnpm-vs-npm#npms-flat-tree) como `pnpm`, es posible que debas instalar manualmente Sharp en tu proyecto, aunque sea una dependencia de Astro:
-
-```bash
-pnpm add sharp
-```
-:::
-
-### Configura Squoosh
-
-Si prefieres utilizar [Squoosh](https://github.com/GoogleChromeLabs/squoosh) para transformar tus imágenes, actualiza tu configuración con lo siguiente:
-
-```js title="astro.config.mjs" ins={4-6}
-import { defineConfig, squooshImageService } from 'astro/config';
-
-export default defineConfig({
-  image: {
-    service: squooshImageService(),
-  },
-});
-```
-
-### Configura el servicio no-op de paso
-
-Si tu [adaptador para el modo `server` o `hybrid`](https://astro.build/integrations/?search=&categories%5B%5D=adapters) no admite la optimización de imágenes integrada de Astro con Squoosh y Sharp (por ejemplo, Deno, Cloudflare), puedes configurar un servicio de imágenes sin acción para permitirte utilizar los componentes `<Image />` y `<Picture />`. Ten en cuenta que Astro no realiza ninguna transformación ni procesamiento de imágenes en estos entornos. Sin embargo, aún puedes disfrutar de otros beneficios de usar `astro:assets`, como la ausencia de Desplazamiento Acumulativo de Diseño (CLS), el atributo `alt` obligatorio y una experiencia de autoría coherente.
-
-Configura el servicio `passthroughImageService()` para evitar el procesamiento de imágenes de Squoosh y Sharp:
-
-```js title="astro.config.mjs" ins={4-6} "passthroughImageService"
-import { defineConfig, passthroughImageService } from 'astro/config';
-
-export default defineConfig({
-  image: {
-    service: passthroughImageService()
-  }
-});
-```
-
-## Integraciones comunitarias
-
-Existen varias [integraciones de imágenes de la comunidad](https://astro.build/integrations?search=images) de terceros para optimizar y trabajar con imágenes en tu proyecto de Astro.
-
-## Actualizar a v3.0 desde v2.x
-
-`astro:assets` ya no está detrás de una bandera experimental en Astro v3.0.
-
-`<Image />` es ahora un componente integrado y se ha eliminado la integración anterior `@astrojs/image`.
-
-Estos y otros cambios relacionados con el uso de imágenes en Astro pueden causar algunos cambios disruptivos al actualizar tu proyecto de Astro de una versión anterior.
-
-Sigue las instrucciones a continuación según corresponda para actualizar un proyecto de Astro v2.x a v3.0.
-
-### Actualizar desde `experimental.assets`
-
-Si habías habilitado previamente la bandera experimental para `astro:assets`, deberás actualizar tu proyecto para Astro v3.0, que ahora incluye las características de assets de forma predeterminada.
-
-#### Eliminar la bandera `experimental.assets`
-
-Elimina la bandera experimental:
-
-```js title="astro.config.mjs" del={4-6}
-import { defineConfig } from 'astro/config';
-
-export default defineConfig({
-  experimental: {
-    assets: true
-  }
-});
-```
-
-Si es necesario, también actualiza tu archivo `src/env.d.ts` para reemplazar la referencia `astro/client-image` por `astro/client`:
-
-```ts title="src/env.d.ts" del={1} ins={2}
-/// <reference types="astro/client-image" />
-/// <reference types="astro/client" />
-```
-
-#### Eliminar el alias de importación `~/assets`
-
-Este alias de importación ya no se incluye por defecto con `astro:assets`. Si estabas usando este alias con assets experimentales, debes convertirlos a rutas de archivo relativas o [crear tus propios alias de importación](/es/guides/imports/#alias).
-
-```astro title="src/pages/posts/post-1.astro" del={2} ins={3}
----
-import rocket from '~/assets/rocket.png';
-import rocket from '../../assets/rocket.png';
----
-```
-
-#### Agrega soporte sencillo para assets en Cloudflare, Deno, Vercel Edge y Netlify Edge
-
- Astro v3.0 permite que `astro:assets` funcione sin errores en Cloudflare, Deno, Vercel Edge y Netlify Edge, que no admiten la optimización de imágenes integrada de Astro con Squoosh y Sharp. Ten en cuenta que Astro no realiza ninguna transformación ni procesamiento de imágenes en estos entornos. Sin embargo, aún puedes disfrutar de otros beneficios de usar `astro:assets`, como la ausencia de Desplazamiento Acumulativo de Diseño (CLS), el atributo `alt` obligatorio y una experiencia de autoría coherente.
- 
- Si antes evitaste usar `astro:assets` debido a estas limitaciones, ahora puedes usarlo sin problemas. Puedes configurar el servicio de imágenes sin acción para optar explícitamente por este comportamiento:
-
-```js title="astro.config.mjs" ins={4-8}
-import { defineConfig } from 'astro/config';
-
-export default defineConfig({
-  image: {
-    service: {
-      entrypoint: 'astro/assets/services/noop'
-    }
-  }
-});
-```
-
-### Decide dónde almacenar tus imágenes
-
-Consulta la guía de Imágenes para ayudarte a decidir [dónde almacenar tus imágenes](#dónde-guardar-las-imágenes). Es posible que desees aprovechar las nuevas opciones para almacenar tus imágenes con la flexibilidad adicional que `astro:assets` ofrece. Por ejemplo, las imágenes relativas desde la carpeta `src/` de tu proyecto ahora pueden ser referenciadas en Markdown, MDX y Markdoc utilizando la sintaxis estándar de Markdown `![alt](src)`.
-
-### Actualiza las etiquetas existentes `<img>`
-
-Anteriormente, importar una imagen devolvía un `string` con la ruta de la imagen. Los assets de imagen importados coinciden con la siguiente firma:
-
-```ts
-interface ImageMetadata {
-  src: string;
-  width: number;
-  height: number;
-  format: string;
-}
-```
-
-Debes actualizar el atributo `src` de cualquier etiqueta `<img>` existente (incluyendo cualquier [imagen en componentes de frameworks UI](#imágenes-en-componentes-de-frameworks-ui)) y también puedes actualizar otros atributos que ahora están disponibles para ti a partir de la imagen importada.
-
-```astro title="src/components/MyComponent.astro" ".src" ".width" ".height" del={4} ins={6}
----
-import rocket from '../images/rocket.svg';
----
-<img src={rocket} width="250" height="250" alt="Un cohete en el espacio." />
-
-<img src={rocket.src} width={rocket.width} height={rocket.height} alt="Un cohete en el espacio." />
-```
-
-### Actualiza tus archivos Markdown, MDX y Markdoc
-
-Las imágenes relativas desde la carpeta `src/` de tu proyecto ahora pueden ser referenciadas en Markdown, MDX y Markdoc utilizando la sintaxis estándar de Markdown `![alt](src)`.
-
-Esto te permite mover tus imágenes desde el directorio `public/` a la carpeta `src/` de tu proyecto, donde ahora serán procesadas y optimizadas. Tus imágenes existentes en `public/` y las imágenes remotas siguen siendo válidas, pero no son optimizadas por el proceso de compilación de Astro.
-
-```md title="src/pages/posts/post-1.md" "/_astro" ".hash" "../../assets/"
-# Mi página Markdown
-
-<!-- ¡Imágenes locales ahora posibles! -->
-![Un cielo estrellado](../../images/stars.png)
-
-<!-- ¡Mantén tus imágenes junto a tu contenido! -->
-![Un cielo estrellado](./stars.png)
-```
-
-Si necesitas más control sobre los atributos de tu imagen, te recomendamos usar el formato de archivo `.mdx`, que te permite incluir el componente `<Image />` de Astro o una etiqueta JSX `<img />` además de la sintaxis Markdown. Utiliza la [integración de MDX](/es/guides/integrations-guide/mdx/) para agregar soporte para MDX a Astro.
-
-### Elimina `@astrojs/image`
-
-Si estabas utilizando la integración de imágenes en Astro v2.x, completa los siguientes pasos:
-<Steps>
-1. Elimina la integración `@astrojs/image`.
-
-    Debes [eliminar la integración](/es/guides/integrations-guide/#eliminando-una-integración) desinstalándola y luego eliminándola de tu archivo `astro.config.mjs`.
-
-    ```js del={3,7}
-    // astro.config.mjs
-    import { defineConfig } from 'astro/config';
-    import image from '@astrojs/image';
-
-    export default defineConfig({
-      integrations: [
-        image(),
-      ]
-    })
-    ```
-
-2. Actualiza los tipos (si es necesario).
-
-		Si tenías tipos especiales configurados para `@astrojs/image` en `src/env.d.ts`, es posible que necesites cambiarlos de nuevo a los tipos predeterminados de Astro si la actualización a la versión 3 no completó este paso por ti.
-
-		```ts title="src/env.d.ts" del={1} ins={2}
-		 /// <reference types="@astrojs/image/client" />
-		 /// <reference types="astro/client" />
-		```
-
-		Del mismo modo, actualiza `tsconfig.json` si es necesario:
-
-		```json title="tsconfig.json" del={3} ins={4}
-		{
-			"compilerOptions": {
-			  "types": ["@astrojs/image/client"]
-			  "types": ["astro/client"]
-			}
-		}
-		```
-
-3. Migra cualquier componente `<Imagen />` existente.
-
-    Cambia todas las declaraciones de `import` de `@astrojs/image/components` a `astro:assets` para poder usar el nuevo componente integrado `<Image />`.
-
-    Elimina cualquier atributo del componente que no sean [propiedades de assets de imagen actualmente admitidas](/es/guides/images/#propiedades).
-
-    Por ejemplo, `aspectRatio` ya no es compatible, ya que ahora se infiere automáticamente a partir de los atributos `width` y `height`.
-
-      ```astro title="src/components/MyComponent.astro" del= {2,11} ins={3}
-      ---
-      import { Image } from '@astrojs/image/components';
-      import { Image } from 'astro:assets';
-      import localImage from '../assets/logo.png';
-      const localAlt = 'El logo de Astro';
-      ---
-
-      <Image
-        src={localImage}
-        width={300}
-        aspectRatio="16:9"
-        alt={localAlt}
-      />
-      ```
-      
-4. Elige un servicio de imágenes predeterminado.
-
-   [Sharp](https://github.com/lovell/sharp) es ahora el servicio de imágenes predeterminado utilizado para `astro:assets`. Si deseas utilizar Sharp, no se requiere ninguna configuración.
-
-    Si prefieres utilizar [Squoosh](https://github.com/GoogleChromeLabs/squoosh) para transformar tus imágenes, actualiza tu configuración con la siguiente opción `image.service`:
-
-    ```js title="astro.config.mjs" ins={4-6}
-    import { defineConfig, squooshImageService } from 'astro/config';
-
-    export default defineConfig({
-      image: {
-        service: squooshImageService(),
-      },
-    });
-    ```
-</Steps>
-
-### Actualiza los esquemas de Colecciones de Contenido
-
-Ahora puedes declarar una imagen asociada para una entrada de colecciones de contenido, como la imagen de portada de una entrada de blog, en tu metadatos usando su ruta relativa a la carpeta actual.
-
-El nuevo helper `image` para colecciones de contenido te permite validar los metadatos de la imagen utilizando Zod. Aprende más sobre [cómo usar imágenes en colecciones de contenido](/es/guides/images/#imágenes-en-colecciones-de-contenido)
-
-### Navegando por las importaciones de imágenes en Astro v3.0
-
-En Astro v3.0, si tienes que conservar el antiguo comportamiento de importación para las imágenes y requieres una representación de tipo string de la URL de la imagen, añade `?url` al final de la ruta de la imagen al importarla. Por ejemplo:
-
-```astro title="src/pages/blog/MyImages.astro"
----
-import Sprite from '../assets/logo.svg?url';
----
-<svg>
-  <use xlink:href={Sprite + '#cart'} />
-</svg>
-```
-
-Este enfoque garantiza que obtengas el string URL. Ten en cuenta que durante el desarrollo, Astro utiliza una ruta `src/`, pero al compilar, genera rutas hash como `/_astro/cat.a6737dd3.png`.
-
-Si prefieres trabajar directamente con el objeto de imagen, puedes acceder a la propiedad `.src`. Este enfoque es el mejor para tareas como la gestión de las dimensiones de la imagen para las métricas de Core Web Vitals y la prevención de CLS.
-
-Si estás en transición al nuevo comportamiento de importación, combinar `?url` y `.src` puede ser el método adecuado para el manejo de imágenes sin problemas.
diff --git a/src/content/docs/es/guides/imports.mdx b/src/content/docs/es/guides/imports.mdx
deleted file mode 100644
index 4256f8073f358..0000000000000
--- a/src/content/docs/es/guides/imports.mdx
+++ /dev/null
@@ -1,285 +0,0 @@
----
-title: Recursos estáticos
-description: Aprende a importar diferentes tipos de contenido con Astro.
-i18nReady: true
----
-import ReadMore from '~/components/ReadMore.astro'
-import RecipeLinks from "~/components/RecipeLinks.astro";
-
-Astro es compatible con la mayoría de los recursos estáticos sin necesidad de configuración. Puedes usar `import` en cualquier lugar de tu proyecto (incluido el script de frontmatter de Astro) y Astro incluirá una copia optimizada de ese recurso estático en la compilación final. `@import` también es compatible dentro del CSS y `<style>`.
-
-## Tipos de archivos compatibles
-
-Los siguientes tipos de archivos son compatibles por defecto en Astro:
-
-- Componentes de Astro (`.astro`)
-- Markdown (`.md`, `.markdown`, etc.)
-- JavaScript (`.js`, `.mjs`)
-- TypeScript (`.ts`)
-- Paquetes NPM
-- JSON (`.json`)
-- CSS (`.css`)
-- Módulos CSS (`.module.css`)
-- Imágenes & otros archivos (`.svg`, `.jpg`, `.png`, etc.)
-
-Adicionalmente, puedes extender la lista de tipos de archivos soportados por los diferentes [UI Frameworks](/es/guides/framework-components/) que soporta Astro, como React, Svelte y Vue. También puedes instalar la [integración de Astro MDX](/es/guides/integrations-guide/mdx/) y usar archivos `.mdx` en tu proyecto.
-
-## Archivos en `public/`
-
-Puedes poner cualquier recurso estático en el [directorio `public/`](/es/basics/project-structure/#public) de tu proyecto, y Astro lo copiará directamente en la compilación final sin ningún cambio. Los archivos de `public/` no se construyen ni empaquetan con Astro, lo que significa que cualquier tipo de archivo es compatible. Puedes referenciar un archivo de `public/` por una ruta de URL directamente en tus plantillas HTML.
-
-## Declaraciones de importación
-
-Astro usa ESM, la misma sintaxis [`import`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/import#syntax) y [`export`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/export) soportada en el navegador.
-
-### JavaScript
-
-```js
-import { getUser } from './user.js';
-```
-
-Se puede importar JavaScript usando la sintaxis normal ESM `import` & `export`.
-
-:::note[Importando archivos JSX]
-
-Un [UI framework](/es/guides/framework-components/) apropiado ([React](/es/guides/integrations-guide/react/), [Preact](/es/guides/integrations-guide/preact/), o [Solid](/es/guides/integrations-guide/solid-js/)) es necesario para renderizar archivos JSX/TSX.
-Utiliza las extensiones `.jsx`/`.tsx` donde sea apropiado, ya que Astro no soporta JSX en archivos `.js`/`.ts`.
-
-:::
-
-### TypeScript
-
-```js
-import { getUser } from './user';
-import type { UserType } from './user';
-```
-
-Astro incluye compatibilidad con [TypeScript](https://www.typescriptlang.org/). Puedes importar archivos `.ts` y `.tsx` directamente a tu proyecto de Astro, e incluso escribir código TypeScript directamente dentro del [script del componente de Astro](/es/basics/astro-components/#script-de-un-componente) y en cualquier [etiqueta de script hoisted](/es/guides/client-side-scripts/).
-
-**Astro no realiza ninguna verificación de tipos por sí mismo.** La verificación de tipos debe realizarse al margen Astro, ya sea mediante el IDE o un script separado. Para chequeo de tipos en archivos Astro, puedes usar el [comando `astro check`](/es/reference/cli-reference/#astro-check).
-
-:::note[TypeScript y extensiones de archivos]
-Según las [reglas de resolución de módulos de TypeScript](https://www.typescriptlang.org/docs/handbook/module-resolution.html), las extensiones `.ts` y `.tsx` no deben utilizarse a la hora de importar archivos de TypeScript. En su lugar, utiliza las extensiones `.js`/`.jsx`, o bien puedes omitir la extensión del archivo completamente.
-
-```ts
-import { getUser } from './user.js'; // user.ts
-import MyComponent from "./MyComponent"; // MyComponent.tsx
-```
-
-:::
-
-<ReadMore>Lee más sobre la compatibilidad de [TypeScript en Astro.](/es/guides/typescript/)</ReadMore>
-
-### Paquetes NPM
-
-Si has instalado un paquete de NPM, puedes importarlo en Astro.
-
-```astro
----
-import { Icon } from 'astro-icon';
----
-```
-
-Si un paquete fue publicado usando un formato antiguo, Astro convertirá el paquete a ESM para que las declaraciones `import` funcionen. En algunos casos, necesitarás ajustar la [configuración de `vite`](/es/reference/configuration-reference/#vite) para que funcione.
-
-:::caution
-Algunos paquetes dependen de un entorno de navegador. Los componentes de Astro se ejecutan en el servidor, por lo que importar estos paquetes en el frontmatter puede [llevarte a errores](/es/guides/troubleshooting/#document-or-window-is-not-defined).
-:::
-
-### JSON
-
-```js
-// Importa el objeto JSON mediante el export por defecto
-import json from './data.json';
-```
-
-Astro puede importar archivos JSON directamente a su aplicación. Los archivos importados devuelven el objeto JSON completo mediante una importación por defecto.
-
-### CSS
-
-```js
-// Importa e inyecta 'style.css' en la página
-import './style.css';
-```
-
-Astro es compatible con la importación de CSS directamente en su aplicación. Los estilos importados no exponen exportaciones, pero importar uno agregará automáticamente esos estilos a la página. Esto funciona para todos los archivos CSS de forma predeterminada y es compatible con lenguajes de compilación a CSS como Sass & Less a través de plugins.
-
-### CSS Modules
-
-```jsx
-// 1. Convierte las clases de './style.module.css' en valores únicos con 
-//    alcance solo para este componente.
-// 2. Devuelve un objeto que mapea los nombres de clase originales a sus 
-//    valores finales, con alcance solo para este componente.
-import styles from './style.module.css';
-
-// Este ejemplo usa JSX, pero puedes usar módulos CSS con cualquier framework.
-return <div className={styles.error}>Tu mensaje de error</div>;
-```
-
-Astro es compatible con módulos CSS utilizando la nomenclatura `[nombre].module.css`. Como cualquier archivo CSS, al importar el archivo se aplicará automáticamente los estilos a la página. Sin embargo, los módulos CSS exportan un objeto `styles` que mapea los nombres de clase originales con los identificadores únicos generados.
-
-CSS Modules te ayuda a limitar el alcance de los estilos y aislarlos de otros mediante nombres de clase únicos que son generados para tus hojas de estilo.
-
-### Otros recursos
-
-```jsx
-import imgReference from './image.png'; // img === '/src/image.png'
-import svgReference from './image.svg'; // svg === '/src/image.svg'
-import txtReference from './words.txt'; // txt === '/src/words.txt'
-
-// Este ejemplo utiliza JSX, pero puedes usar módulos CSS con cualquier framework.
-<img src={imgReference.src} alt="descripción de la imagen"/>;
-```
-
-Todos los archivos que no se mencionan explícitamente en el ejemplo anterior, se pueden importar a través de ESM `import` y devolverán una URL con referencia al archivo creado. Esto puede ser útil para hacer referencia por URL a archivos que no son JS, como crear un elemento img con el atributo src que apunte a esa imagen.
-
-También puede ser útil colocar imágenes en la carpeta `public/` como se explica en la página de [estructura de proyecto](/es/basics/project-structure/#public).
-
-:::note
-¡Agrega **alt text** a las etiquetas `<img>` para mejorar la accesibilidad! No olvides agregar un atributo `alt="una buena descripción"` a tus elementos de imagen. Puedes dejar el atributo vacío si la imagen es puramente decorativa.
-:::
-
-## Alias
-
-Un **alias** es una forma de crear atajos para tus imports.
-
-Los alias ayudan a mejorar la experiencia de desarrollo en repositorios con muchas carpetas o importaciones relativas.
-
-```astro title="src/pages/about/company.astro" del="../../components" del="../../assets"
----
-import Button from '../../components/controls/Button.astro';
-import logoUrl from '../../assets/logo.png?url';
----
-```
-
-En este ejemplo, un desarrollador necesitaría comprender la relación de archivos entre `src/pages/about/company.astro`, `src/components/controls/Button.astro` y `src/assets/logo.png?url`. Y luego, si se moviera el archivo `company.astro`, estas importaciones también tendrían que actualizarse.
-
-Puedes agregar alias de importación en `tsconfig.json`.
-
-```json title="tsconfig.json" ins={5-6}
-{
-  "compilerOptions": {
-    "baseUrl": ".",
-    "paths": {
-      "@components/*": ["src/components/*"],
-      "@assets/*": ["src/assets/*"]
-    }
-  }
-}
-```
-
-:::note
-Asegúrate de que `compilerOptions.baseUrl` esté configurado para que las rutas con alias se puedan resolver.
-:::
-
-El servidor de desarrollo se reiniciará automáticamente tras este cambio de configuración. Ahora puedes importar usando los alias en cualquier parte de tu proyecto:
-
-```astro title="src/pages/about/company.astro" ins="@components" ins="@assets"
----
-import Button from '@components/Button';
-import logoUrl from '@assets/logo.png?url';
----
-```
-
-Estos alias también se integran automáticamente a [VSCode](https://code.visualstudio.com/docs/languages/jsconfig) y otros editores.
-
-## `Astro.glob()`
-
-[`Astro.glob()`](/es/reference/api-reference/#astroglob) es una forma de importar muchos archivos a la vez.
-
-`Astro.glob()` solo toma un parámetro: un [patrón de glob](/es/guides/imports/#patrones-glob) relativo que coincida con los archivos locales que desea importar. Es asíncrono y devuelve una array de las exportaciones de cada archivo que coincida.
-
-```astro title="src/components/my-component.astro"
----
-// importa todos los archivos que terminan en `.md` en `./src/pages/post/`
-const posts = await Astro.glob('../pages/post/*.md'); 
----
-<!-- Renderiza un <article> para los primeros 5 posts del blog -->
-<div>
-{posts.slice(0, 4).map((post) => (
-  <article>
-    <h2>{post.frontmatter.title}</h2>
-    <p>{post.frontmatter.description}</p>
-    <a href={post.url}>Leer más</a>
-  </article>
-))}
-</div>
-```
-
-Los componentes Astro importados usando `Astro.glob()` son de tipo [`AstroInstance`](/es/reference/api-reference/#archivos-astro). Puedes renderizar cada instancia del componente usando su propiedad `default`:
-
-```astro title="src/pages/component-library.astro" {8}
----
-// importa todos los archivos que terminan en `.astro` en `./src/components/`
-const components = await Astro.glob('../components/*.astro');
----
-<!-- Muestra todos tus componentes -->
-{components.map((component) => (
-  <div>
-    <component.default size={24} />
-  </div>
-))}
-```
-
-### Patrones Glob
-
-Un patrón de glob es una ruta de archivo que admite caracteres comodín especiales. Esto se usa para hacer referencia a varios archivos en su proyecto a la vez.
-
-Por ejemplo, el patrón de glob `./pages/**/*.{md,mdx}` comienza dentro del subdirectorio pages, busca en todos sus subdirectorios (`/**`) y coincide con cualquier nombre de archivo (`/*`) que termine en `.md` o `.mdx` (`.{md,mdx}`).
-
-#### Patrones Glob en Astro
-
-Para usar con `Astro.glob()`, el patrón de glob debe ser una cadena literal y no puede contener variables. Consulta [la guía de solución de problemas](/es/guides/troubleshooting/#astroglob---no-matches-found) para una solución alternativa.
-
-Además, los patrones glob deben comenzar con uno de los siguientes:
-- `./` (para comenzar en el directorio actual)
-- `../` (para comenzar en el directorio padre)
-- `/` (para comenzar en la raíz del proyecto)
-
-
-[Leer más sobre la sintaxis de patrones glob](https://github.com/mrmlnc/fast-glob#pattern-syntax).
-
-#### `Astro.glob()` vs `getCollection()`
-
-[Las colecciones de contenido](/es/guides/content-collections/) proporcionan una [API `getCollection()`](/es/reference/api-reference/#getcollection) para cargar varios archivos en lugar de `Astro.glob()`. Si tus archivos de contenido (p. ej. Markdown, MDX, Markdoc) se encuentran dentro del directorio `src/content/`, utiliza `getCollection()` para [consultar una colección](/es/guides/content-collections/#consultando-colecciones) y obtener las entradas de contenido.
-
-## WASM
-
-```js
-// Importa e inicializa el archivo WASM solicitado
-const wasm = await WebAssembly.instantiateStreaming(fetch('/example.wasm'));
-```
-
-Astro es compatible con la carga de archivos WASM directamente en tu aplicación mediante la API [`WebAssembly`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly) del navegador.
-
-## Módulos integrados de Node
-
-Recomendamos a los usuarios de Astro que eviten usar los módulos integrados de Node.js (`fs`, `path`, etc.) siempre que sea posible. Astro es compatible con múltiples motores de ejecución usando [adaptadores](/es/guides/on-demand-rendering/). Esto incluye [Deno](https://github.com/denoland/deno-astro-adapter) y [Cloudflare Workers](/es/guides/integrations-guide/cloudflare/) que no son compatibles con los módulos integrados de Node como `fs`.
-
-El objetivo de Astro es proporcionar alternativas a los módulos integrados comunes de Node.js. Sin embargo, estas alternativas aún no existen. Si _realmente_ necesitas utilizar estos módulos, no queremos detenerlo. Astro es compatible con los módulos integrados de Node.js utilizando el nuevo prefijo `node:`. Si por ejemplo quieres leer un archivo, puedes hacerlo así:
-
-```astro title="src/components/MyComponent.astro"
----
-// Ejemplo: importa el módulo "fs/promises" de Node.js
-
-import fs from 'node:fs/promises';
-
-const url = new URL('../../package.json', import.meta.url);
-const json = await fs.readFile(url, 'utf-8');
-const data = JSON.parse(json);
----
-
-<span>Version: {data.version}</span>
-```
-
-## Extendiendo el soporte de tipos de archivo
-
-Con **Vite** y los plugin **Rollup** compatibles, puedes importar tipos de archivo que no son compatibles nativamente con Astro. Aprende dónde encontrar los plugins que necesitas en la sección [Finding Plugins](https://vite.dev/guide/using-plugins.html#finding-plugins) de la documentación de Vite.
-
-
-:::note[Configuración de plugin]
-Consulta la documentación de tu plugin para las opciones de configuración y cómo instalarlo correctamente.
-:::
-
-<RecipeLinks slugs={["es/recipes/add-yaml-support"]} />
diff --git a/src/content/docs/es/guides/integrations-guide/alpinejs.mdx b/src/content/docs/es/guides/integrations-guide/alpinejs.mdx
deleted file mode 100644
index f048d4e195321..0000000000000
--- a/src/content/docs/es/guides/integrations-guide/alpinejs.mdx
+++ /dev/null
@@ -1,164 +0,0 @@
----
-type: integration
-title: '@astrojs/alpinejs'
-description: Aprenda a usar la integración de @astrojs/alpinejs para ampliar la compatibilidad de Alpinejs en tu proyecto de Astro.
-githubIntegrationURL: 'https://github.com/withastro/astro/tree/main/packages/integrations/alpinejs/'
-category: renderer
-i18nReady: true
----
-import PackageManagerTabs from '~/components/tabs/PackageManagerTabs.astro'
-
-
-Esta **[integración de Astro][astro-integration]** agrega [Alpine.js](https://alpinejs.dev/) a tu proyecto para que puedas usar Alpine.js en cualquier lugar de tu página.
-
-## Instalación
-
-Astro incluye un comando `astro add` para automatizar la configuración de las integraciones oficiales. Si lo prefieres, puedes [instalar las integraciones manualmente](#instalación-manual) en su lugar.
-
-Para instalar `@astrojs/alpinejs`, ejecuta lo siguiente desde el directorio de tu proyecto y sigue las instrucciones:
-
-<PackageManagerTabs>
-  <Fragment slot="npm">
-    ```sh
-    npx astro add alpinejs
-    ```
-  </Fragment>
-  <Fragment slot="pnpm">
-    ```sh
-    pnpm astro add alpinejs
-    ```
-  </Fragment>
-  <Fragment slot="yarn">
-    ```sh
-    yarn astro add alpinejs
-    ```
-  </Fragment>
-</PackageManagerTabs>
-
-Si tienes algún problema, [no dudes en informarnos en GitHub](https://github.com/withastro/astro/issues) y prueba los pasos de instalación manual a continuación.
-
-### Instalación manual
-
-Primero, instala el paquete `@astrojs/alpinejs`.
-
-<PackageManagerTabs>
-  <Fragment slot="npm">
-    ```sh
-    npm install @astrojs/alpinejs
-    ```
-  </Fragment>
-  <Fragment slot="pnpm">
-    ```sh
-    pnpm add @astrojs/alpinejs
-    ```
-  </Fragment>
-  <Fragment slot="yarn">
-    ```sh
-    yarn add @astrojs/alpinejs
-    ```
-  </Fragment>
-</PackageManagerTabs>
-
-La mayoría de los gestores de paquetes también instalarán las dependencias asociadas. Sin embargo, si ves un aviso "No se puede encontrar el paquete 'alpinejs'" (o similar) al iniciar Astro, deberás instalar manualmente Alpine.js:
-
-<PackageManagerTabs>
-  <Fragment slot="npm">
-  ```sh
-  npm install alpinejs @types/alpinejs
-  ```
-  </Fragment>
-  <Fragment slot="pnpm">
-  ```sh
-  pnpm add alpinejs @types/alpinejs
-  ```
-  </Fragment>
-  <Fragment slot="yarn">
-  ```sh
-  yarn add alpinejs @types/alpinejs
-  ```
-  </Fragment>
-</PackageManagerTabs>
-
-Luego, aplica la integración a tu archivo `astro.config.*` usando la propiedad `integrations`:
-
-```js ins="alpine()" title="astro.config.mjs" ins={2}
-import { defineConfig } from 'astro/config';
-import alpine from '@astrojs/alpinejs';
-
-export default defineConfig({
-  // ...
-  integrations: [alpine()],
-});
-```
-
-## Opciones de configuración
-
-### `entrypoint`
-
-Puedes extender Alpine estableciendo la opción `entrypoint` en un especificador de importación relativo a la raíz (por ejemplo, `entrypoint: "/src/entrypoint"`).
-
-El export por defecto de este archivo debe ser una función que acepte una instancia de Alpine antes de iniciar. Esto permite el uso de directivas personalizadas, complementos y otras personalizaciones para casos de uso avanzados.
-
-```js title="astro.config.mjs"
-import { defineConfig } from 'astro/config';
-import alpine from '@astrojs/alpinejs';
-
-export default defineConfig({
-  // ...
-  integrations: [alpine({ entrypoint: '/src/entrypoint' })],
-});
-```
-
-```js title="src/entrypoint.ts"
-import type { Alpine } from 'alpinejs'
-import intersect from '@alpinejs/intersect'
-
-export default (Alpine: Alpine) => {
-    Alpine.plugin(intersect)
-}
-```
-
-## Uso
-
-Una vez instalada la integración, puedes usar las directivas y la sintaxis de [Alpine.js](https://alpinejs.dev/) dentro de cualquier componente de Astro. El script de Alpine.js se agrega y habilita automáticamente en cada página de tu sitio web por lo que no se necesitan directivas del cliente. Agrega scripts de complementos a la etiqueta `<head>` de la página.
-
-El siguiente ejemplo agrega [el plugin Collapse de Alpine](https://alpinejs.dev/plugins/collapse) para expandir y contraer el texto del párrafo:
-
-```astro title="src/pages/index.astro" ins={6} ins="x-collapse"
----
----
-<html>
-	<head>
-		<!-- ... -->
-		<script defer src="https://cdn.jsdelivr.net/npm/@alpinejs/collapse@3.x.x/dist/cdn.min.js"></script>
-	</head>
-	<body>
-    <!-- ... -->
-		<div x-data="{ expanded: false }">
-			<button @click="expanded = ! expanded">Toggle Content</button>
-      
-			<p id="foo" x-show="expanded" x-collapse>
-        Lorem ipsum
-			</p>
-		</div>
-	</body>
-</html>
-```
-
-## Intellisense para TypeScript
-
-La integración `@astrojs/alpine` agrega `Alpine` al objeto global de la ventana. Para el autocompletado del IDE, agrega lo siguiente a tu `src/env.d.ts`:
-
-```ts title="src/env.d.ts"
-interface Window {
-  Alpine: import('alpinejs').Alpine;
-}
-```
-
-## Ejemplos
-
-* El [ejemplo Astro Alpine.js](https://github.com/withastro/astro/tree/latest/examples/framework-alpine) muestra como usar Alpine.js en un proyecto de Astro.
-
-[astro-integration]: /es/guides/integrations-guide/
-
-[astro-ui-frameworks]: /es/guides/framework-components/#usando-componente-de-framework
diff --git a/src/content/docs/es/guides/integrations-guide/cloudflare.mdx b/src/content/docs/es/guides/integrations-guide/cloudflare.mdx
deleted file mode 100644
index 1f3ca85ea44cc..0000000000000
--- a/src/content/docs/es/guides/integrations-guide/cloudflare.mdx
+++ /dev/null
@@ -1,417 +0,0 @@
----
-type: integration
-title: '@astrojs/cloudflare'
-description: Aprende cómo utilizar el adaptador SSR @astrojs/cloudflare para implementar tu proyecto de Astro.
-githubIntegrationURL: 'https://github.com/withastro/adapters/tree/main/packages/cloudflare'
-category: adapter
-i18nReady: true
----
-import PackageManagerTabs from '~/components/tabs/PackageManagerTabs.astro'
-
-Este adaptador permite a Astro desplegar tu [sitio renderizado de manera `hybrid` o `server`](/es/guides/on-demand-rendering/) en [Cloudflare](https://www.cloudflare.com/).
-
-Si estás utilizando Astro como un constructor de sitios estáticos, no necesitas un adaptador.
-
-Aprende como desplegar tu sitio en nuestra [guía de despliegue en Cloudflare Pages](/es/guides/deploy/cloudflare/).
-
-## Por qué Astro Cloudflare
-
-[Cloudflare](https://www.cloudflare.com/) porporciona CDNs, seguridad web y otros servicios. Este adaptador mejora el proceso de compilación de Astro para preparar tu proyecto para el despliegue a través de Cloudflare.
-
-## Instalación
-
-Astro incluye un comando `astro add` para automatizar la configuración de las integraciones oficiales. Si lo prefieres, puedes [instalar las integraciones manualmente](#instalación-manual) en su lugar.
-
-Añade el adaptador de Cloudflare para habilitar SSR en tu proyecto de Astro con el comando `astro add`. Esto instalará `@astrojs/cloudflare` y realizará los cambios correspondientes en tu archivo `astro.config.mjs` en un solo paso.
-
-<PackageManagerTabs>
-  <Fragment slot="npm">
-  ```sh
-  npx astro add cloudflare
-  ```
-  </Fragment>
-  <Fragment slot="pnpm">
-  ```sh
-  pnpm astro add cloudflare
-  ```
-  </Fragment>
-  <Fragment slot="yarn">
-  ```sh
-  yarn astro add cloudflare
-  ```
-  </Fragment>
-</PackageManagerTabs>
-
-### Instalación manual
-
-Primero, añade el adaptador `@astrojs/cloudflare` a las dependencias de tu proyecto utilizando tu gestor de paquetes preferido.
-
-<PackageManagerTabs>
-  <Fragment slot="npm">
-  ```sh
-  npm install @astrojs/cloudflare
-  ```
-  </Fragment>
-  <Fragment slot="pnpm">
-  ```sh
-  pnpm add @astrojs/cloudflare
-  ```
-  </Fragment>
-  <Fragment slot="yarn">
-  ```sh
-  yarn add @astrojs/cloudflare
-  ```
-  </Fragment>
-</PackageManagerTabs>
-
-Luego, añade el adaptador y el [modo de renderizado](/es/guides/on-demand-rendering/) deseado a tu archivo `astro.config.mjs`:
-
-```js title="astro.config.mjs" ins={2,5-6}
-import { defineConfig } from 'astro/config';
-import cloudflare from '@astrojs/cloudflare';
-
-export default defineConfig({
-  output: 'server',
-  adapter: cloudflare(),
-});
-```
-
-## Opciones
-
-### imageService
-
-<p>
-**Tipo:** `'passthrough' | 'cloudflare' | 'compile' | 'custom'`<br />
-**Por defecto:** `'compile'`
-</p>
-
-Determina que servicio de imágenes es utilizado por el adaptador. El adaptador utilizará el modo `compile` de forma predeterminada cuando se configure un servicio de imágenes incompatible. De lo contrario, utilizará el servicio de imágenes configurado globalmente:
-
- **`cloudflare`:** Usa el servicio de [Redimensionamiento de Imagen de Cloudflare](https://developers.cloudflare.com/images/image-resizing/).
-* **`passthrough`:** Usa el servicio existente [`noop`](/es/guides/images/#configura-el-servicio-no-op-de-paso).
-* **`compile`:** Usa el servicio predeterminado de Astro (sharp), pero solo en rutas pre-renderizadas durante el tiempo de compilación. Durante el SSR para páginas renderizadas según demanda, todas las características de `astro:assets` están desactivadas.
-* **`custom`:** Siempre usa el servicio de imágenes configurado en [Opciones de Imágenes](/es/reference/configuration-reference/#opciones-de-imagen). **Esta opción no comprobará si el servicio de imágenes configurado funciona en el tiempo de ejecución de `workerd` de Cloudflare.**
-
-```js title="astro.config.mjs" ins={6}
-import {defineConfig} from "astro/config";
-import cloudflare from '@astrojs/cloudflare';
-
-export default defineConfig({
-  adapter: cloudflare({
-     imageService: 'cloudflare'
-  }),
-  output: 'server'
-})
-```
-
-### platformProxy
-
-Determina si y como el tiempo de ejecución de Cloudflare es añadido a `astro dev`. Contiene proxies a los bindings locales de `workerd` y emulaciones de valores específicos de Cloudflare, permitiendo la emulación del tiempo de ejecución en el proceso de desarrollo de Node.js. Lee más sobre [el tiempo de ejecución de Cloudflare](#tiempo-de-ejecución-de-cloudflare).
-
-:::note
-Los proxies proporcionados por esto son una emulación del mejor esfuerzo de la producción real. Aunque están diseñados para ser lo más cercanos posible a la realidad, puede haber pequeñas diferencias e inconsistencias entre los dos.
-:::
-
-#### platformProxy.enabled
-<p>
-**Tipo:** `{ enabled?: boolean }`<br />
-**Por defecto:** `{ enabled: false }`
-</p>
-
-La propiedad `enabled` te permite habilitar el tiempo de ejecución de Cloudflare en `astro dev`.
-
-#### platformProxy.configPath
-<p>
-**Tipo:** `{ configPath?: string }`<br />
-**Por Defecto:** `{ configPath: 'wrangler.toml' }`
-</p>
-
-La propiedad `configPath` te permite definir tu archivo de configuración de Wrangler, relativo a la raíz de tu proyecto de Astro.
-
-#### platformProxy.experimentalJsonConfig
-<p>
-**Tipo:** `{ experimentalJsonConfig?: boolean }`<br />
-**Por Defecto:** `{ experimentalJsonConfig?: false }`
-</p>
-
-La propiedad `experimentalJsonConfig` define si la utilidad lee un archivo de configuración JSON (por ejemplo, `wrangler.json`).
-
-#### platformProxy.persist
-<p>
-**Tipo:** `{ persist?: boolean | { path: string } }`<br />
-**Por Defecto:** `{ persist: true }`
-</p>
-
-La propiedad `persists` define si y donde los datos de los bindings son persistentes. `true` se establece en la misma ubicación utilizada por Wrangler para que los datos puedan ser compartidos entre los dos. Si es `false`, los datos no persisten ni se leen del sistema de archivos.
-
-:::note
-La opción `--persist-to` de `wrangler` añade un subdirectorio llamado `v3` bajo el capó, mientras que la propiedad `persist` de `@astrojs/cloudflare` no lo hace. Por ejemplo, para reutilizar la misma ubicación que al ejecutar `wrangler dev --persist-to ./my-directory`, debes especificar: `persist: "./my-directory/v3"`.
-:::
-
-La siguiente configuración muestra un ejemplo de cómo habilitar el tiempo de ejecución de Cloudflare al ejecutar el servidor de desarrollo, así como el uso de un archivo de configuración `wrangler.json` (experimental). También especifica una ubicación personalizada para persistir los datos en el sistema de archivos:
-
-
-```js
-import cloudflare from '@astrojs/cloudflare';
-import { defineConfig } from 'astro/config';
-
-export default defineConfig({
-	adapter: cloudflare({
-		platformProxy: {
-			enabled: true,
-			configPath: 'wrangler.json',
-			experimentalJsonConfig: true,
-			persist: './.cache/wrangler/v3',
-		},
-	}),
-});
-```
-
-### routes.extend
-
-Esta opción te permite añadir o excluir patrones personalizados (por ejemplo, `/fonts/*`) al archivo `_routes.json` generado que determina qué rutas se generan bajo demanda. Esto puede ser útil si necesitas añadir patrones de rutas que no se pueden generar automáticamente, o excluir rutas pre-renderizadas.
-
-Para mayor información acerca de los patrones de rutas personalizados, puedes consultar la [documentación de enrutamiento de Cloudflare](https://developers.cloudflare.com/pages/functions/routing/#functions-invocation-routes). Cualquier ruta especificada no se deduplicará automáticamente y se añadirá a las rutas existentes tal cual.
-
-#### routes.extend.include
-
-<p>
-**Tipo:** `{ pattern: string }[]`<br />
-**Por defecto:** `undefined`
-</p>
-
-Configura rutas adicionales para ser generadas bajo demanda por el adaptador de Cloudflare en el array `routes.extend.include`.
-
-#### routes.extend.exclude
-
-<p>
-**Tipo:** `{ pattern: string }[]`<br />
-**Por defecto:** `undefined`
-</p>
-
-Configura rutas para ser excluidas de la generación bajo demanda en el array `routes.extend.exclude`. Estas rutas se prerenderizarán y se servirán estáticamente en su lugar, y no invocarán la función SSR. Además, puedes usar esta opción para servir cualquier archivo de activo estático (por ejemplo, imágenes, fuentes, css, js, html, txt, json, etc.) directamente sin enrutar la solicitud a través de la función SSR.
-
-```js title="astro.config.mjs"
-export default defineConfig({
-  adapter: cloudflare({
-    routes: {
-      extend: {
-        include: [{ pattern: '/static' }], // Enruta una página prerenderizada a la función SSR para renderizado bajo demanda
-        exclude: [{ pattern: '/pagefind/*' }], // Usa la búsqueda pagefind de Starlight, que se genera estáticamente en el tiempo de compilación
-      }
-    },
-  }),
-});
-```
-
-### `cloudflareModules`
-
-<p>
-**Tipo:** `true | false`<br />
-**Por defecto:** `true`
-</p>
-
-Habilita [importaciones de módulos `.wasm`, `.bin`, y `.txt`](#importaciones-de-módulos-cloudflare).
-
-Esta funcionalidad está habilitada de forma predeterminada. Si deseas deshabilitarla, establece `cloudflareModules: false`.
-
-## Tiempo de ejecución de Cloudflare
-
-El tiempo de ejecución de Cloudflare te da acceso a las variables de entorno y a los bindings de Cloudflare.
-El tiempo de ejecución de Cloudflare utiliza los bindings encontrados en los archivos de configuración `wrangler` y `.dev.vars`.
-
-### Uso 
-
-Por ejemplo, si tienes una configuración de [variables de entorno](https://developers.cloudflare.com/workers/configuration/environment-variables/#add-environment-variables-via-wrangler) en `wrangler.toml`:
-
-```toml title="wrangler.toml"
-[vars]
-MY_VARIABLE = "test"
-```
-
-Si también necesitas definir `secrets` además de las variables de entorno, necesitas añadir un archivo `.dev.vars` a la raíz del proyecto de Astro:
-
-```ini title=".dev.vars"
-DB_PASSWORD=myPassword
-```
-
-Puedes acceder a los bindings utilizando los locales de Astro de la siguiente manera:
-
-```astro title="src/pages/index.astro"
----
-const { env } = Astro.locals.runtime;
----
-```
-
-Puedes acceder al tiempo de ejecución desde los endpoints de la API a través de `context.locals`:
-
-```js title="src/pages/api/someFile.js"
-export function GET(context) {
-  const runtime = context.locals.runtime;
-
-  return new Response('Some body');
-}
-```
-
-Para acceder al valor del binding `MY_VARIABLE`, añade lo siguiente a tu código:
-
-```astro title="src/pages/index.astro"
----
-const { env } = Astro.locals.runtime;
-const myVariable = env.MY_VARIABLE;
----
-```
-
-Ve la [lista de todos los bindings soportados](https://developers.cloudflare.com/workers/wrangler/api/#supported-bindings) en la documentación de Cloudflare.
-
-### Tipado
-
-`wrangler` proporciona un comando `types` para generar tipos de TypeScript para los bindings. Esto te permite tipar los locales sin necesidad de hacerlo manualmente. Consulta la [documentación de Cloudflare](https://developers.cloudflare.com/workers/wrangler/commands/#types) para obtener más información.
-
-Cada vez que cambies tus archivos de configuración (por ejemplo, `wrangler.toml`, `.dev.vars`) necesitas ejecutar `wrangler types`.
-
-:::note
-Puedes crear un script de pnpm para ejecutar `wrangler types` automáticamente antes de otros comandos.
-
-```json title="package.json"
-{
-  "scripts": {
-    "dev": "wrangler types && astro dev",
-    "start": "wrangler types && astro dev",
-    "build": "wrangler types && astro check && astro build",
-    "preview": "wrangler types && astro preview",
-    "astro": "astro"
-  }
-}
-```
-:::
-
-Puedes tipar el objeto `runtime` utilizando `Runtime`:
-
-```ts title="src/env.d.ts"
-/// <reference types="astro/client" />
-
-type Runtime = import('@astrojs/cloudflare').Runtime<Env>;
-
-declare namespace App {
-  interface Locals extends Runtime {
-    otherLocals: {
-      test: string;
-    };
-  }
-}
-```
-
-## Plataforma Cloudflare
-
-### Encabezados
-
-Puedes añadir [encabezados personalizados](https://developers.cloudflare.com/pages/platform/headers/) a tus respuestas añadiendo un archivo `_headers` en la carpeta `public/` de tu proyecto de Astro. Este archivo se copiará al directorio de salida de tu compilación.
-
-### Assets
-Los assets construidos por Astro tienen todos un nombre con un hash y, por lo tanto, pueden recibir encabezados de caché largos. De forma predeterminada, Astro en Cloudflare añadirá un encabezado de este tipo para estos archivos.
-
-### Redirecciones
-
-Puedes declarar [redirecciones personalizadas](https://developers.cloudflare.com/pages/platform/redirects/) usando Cloudflare Pages. Esto te permite redirigir solicitudes a una URL diferente. Puedes añadir un archivo `_redirects` en la carpeta `public/` de tu proyecto de Astro. Este archivo se copiará al directorio de salida de tu compilación.
-
-### Rutas
-
-[El enrutamiento de Cloudflare](https://developers.cloudflare.com/pages/platform/functions/routing/#functions-invocation-routes) utiliza un archivo `_routes.json` para determinar qué solicitudes se enrutan a la función SSR y cuáles se sirven como activos estáticos. De forma predeterminada, se generará automáticamente un archivo `_routes.json` para tu proyecto basado en sus archivos y configuración.
-
-Puedes [especificar patrones de enrutamiento adicionales](#routesextend) en tu configuración de adaptador, o crear tu propio archivo `_routes.json` personalizado para anular completamente la generación automática.
-
-
-#### `_routes.json` personalizado
-
-Crear un archivo `_routes.json` personalizado en la carpeta `public/` de tu proyecto de Astro anulará la generación automática. Consulta la [documentación de Cloudflare](https://developers.cloudflare.com/pages/platform/functions/routing/#create-a-_routesjson-file) para obtener más detalles.
-
-## Importaciones de Módulos Cloudflare
-
-El tiempo de ejecución del worker de Cloudflare soporta importaciones de algunos [tipos de módulos no estándar](https://developers.cloudflare.com/pages/functions/module-support/). La mayoría de los tipos de archivos adicionales también están disponibles en astro:
-
-- `.wasm` o `.wasm?module`: exporta un [`WebAssembly.Module`](https://developer.mozilla.org/en-US/docs/WebAssembly/JavaScript_interface/Module) que luego puede ser instanciado
-- `.bin`: exporta un [`ArrayBuffer`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer) de los contenidos binarios crudos del archivo
-- `.txt`: Exporta un string con el contenido del archivo
-
-Todos los tipos de módulos exportan un único valor predeterminado. Los módulos pueden ser importados tanto desde páginas renderizadas en el servidor como desde páginas prerenderizadas para la generación de sitios estáticos.
-
-Lo siguiente es un ejemplo de importación de un módulo Wasm que responde a las solicitudes sumando los parámetros numéricos de la solicitud.
-
-```js title="pages/add/[a]/[b].js"
-// Importa el módulo WebAssembly
-import mod from '../util/add.wasm';
-
-// Instancia primero para poder usarlo
-const addModule: any = new WebAssembly.Instance(mod);
-
-export async function GET(context) {
-  const a = Number.parseInt(context.params.a);
-  const b = Number.parseInt(context.params.b);
-  return new Response(`${addModule.exports.add(a, b)}`);
-}
-```
-
-Mientras que este ejemplo es trivial, Wasm puede ser utilizado para acelerar operaciones computacionalmente intensivas que no involucran una E/S significativa, como incrustar una biblioteca de procesamiento de imágenes o una pequeña base de datos pre-indexada para la búsqueda en un conjunto de datos de solo lectura.
-
-## Compatibilidad con Node.js
-
-De forma predeterminada, Cloudflare no soporta las APIs de tiempo de ejecución de Node.js. Con alguna configuración, Cloudflare sí soporta un subconjunto de las APIs de tiempo de ejecución de Node.js. Puedes encontrar las APIs de tiempo de ejecución de Node.js soportadas en la [documentación de Cloudflare](https://developers.cloudflare.com/workers/runtime-apis/nodejs).
-
-Para usar estas APIs, tu página o endpoint debe ser renderizado en el servidor (no pre-renderizado) y debe usar la sintaxis de importación `import {} from 'node:*'`.
-
-```js title="pages/api/endpoint.js"
-export const prerender = false;
-import { Buffer } from 'node:buffer';
-```
-
-También necesitarás modificar la configuración de `vite` en tu archivo de configuración de Astro para permitir la sintaxis de importación `node:*`:
-
-```js title="astro.config.mjs" ins={7-11}
-import {defineConfig} from "astro/config";
-import cloudflare from '@astrojs/cloudflare';
-
-export default defineConfig({
-  adapter: cloudflare({}),
-  output: 'server',
-  vite: {
-		ssr: {
-			external: ['node:buffer'],
-		},
-	},
-})
-```
-
-Adicionalmente, necesitarás seguir la documentación de Cloudflare sobre cómo habilitar el soporte. Para obtener orientación detallada, consulta la [documentación de Cloudflare sobre cómo habilitar la compatibilidad con Node.js](https://developers.cloudflare.com/workers/runtime-apis/nodejs#enable-nodejs-with-pages-functions).
-
-:::note[Implicaciones de la compatibilidad de paquetes]
-Si un proyecto importa un paquete en el servidor que utiliza las APIs de tiempo de ejecución de Node.js, esto puede causar problemas al desplegar en Cloudflare. Este problema surge con los paquetes que no utilizan la sintaxis de importación `node:*`. Se recomienda que contactes a los autores del paquete para determinar si el paquete soporta la sintaxis de importación anterior. Si el paquete no soporta esto, es posible que necesites utilizar un paquete diferente.
-:::
-
-## Vista previa con Wrangler
-
-Para usar [`wrangler`](https://developers.cloudflare.com/workers/wrangler/) para ejecutar tu aplicación localmente, actualiza el script de vista previa:
-
-```json title="package.json"
-"preview": "wrangler pages dev ./dist"
-```
-
-[`wrangler`](https://developers.cloudflare.com/workers/wrangler/) te da acceso a [bindings de Cloudflare](https://developers.cloudflare.com/pages/platform/functions/bindings), [variables de entorno](https://developers.cloudflare.com/pages/platform/functions/bindings/#environment-variables), y al [objeto cf](https://developers.cloudflare.com/workers/runtime-apis/request/#incomingrequestcfproperties). Hacer que la recarga en caliente o que el servidor `astro dev` funcione con Wrangler podría requerir una configuración personalizada. Consulta [ejemplos de la comunidad](https://github.com/withastro/roadmap/discussions/590)
-
-### Mensajes de error significativos
-
-Por el momento, los errores durante la ejecución de tu aplicación en Wrangler no son muy útiles, debido a la minificación de tu código. Para una mejor depuración, puedes añadir la configuración `vite.build.minify = false` a tu `astro.config.mjs`.
-
-```js title="astro.config.mjs" ins={4-8}
-export default defineConfig({
-  adapter: cloudflare(),
-  output: 'server',
-  vite: {
-    build: {
-      minify: false,
-    },
-  },
-});
-```
-
-[astro-integration]: /es/guides/integrations-guide/
diff --git a/src/content/docs/es/guides/integrations-guide/db.mdx b/src/content/docs/es/guides/integrations-guide/db.mdx
deleted file mode 100644
index 3c447f2f2c3ae..0000000000000
--- a/src/content/docs/es/guides/integrations-guide/db.mdx
+++ /dev/null
@@ -1,256 +0,0 @@
----
-type: integration
-title: '@astrojs/db'
-description: Aprende a usar la integración @astrojs/db en tu proyecto de Astro.
-githubIntegrationURL: 'https://github.com/withastro/astro/tree/main/packages/db/'
-category: other
-i18nReady: true
----
-import { FileTree } from '@astrojs/starlight/components';
-import PackageManagerTabs from '~/components/tabs/PackageManagerTabs.astro';
-import ReadMore from '~/components/ReadMore.astro';
-
-
-Astro DB es una base de datos SQL completamente administrada diseñada para el ecosistema de Astro: desarrolla localmente en Astro y despliega desde tu [panel de Astro Studio](/es/guides/astro-db/#astro-studio).
-
-Con Astro DB tienes una herramienta potente, local y segura para consultar y modelar contenido como una base de datos relacional. Visualiza, administra y despliega tus datos remotos alojados a través de tu panel interactivo de Studio. 
-
-<ReadMore>Consulta la [guía de Astro DB](/es/guides/astro-db/) para obtener ejemplos y usos completos.</ReadMore>
-
-## Instalación
-
-Astro incluye un comando `astro add` para automatizar la configuración de integraciones oficiales. Si lo prefieres, puedes [instalar las integraciones manualmente](/es/guides/integrations-guide/mdx/#instalación-manual) en su lugar.
-
-Ejecuta uno de los siguientes comandos en una nueva ventana de terminal.
-
-<PackageManagerTabs>
-  <Fragment slot="npm">
-  ```sh
-  npx astro add db
-    ```
-  </Fragment>
-  <Fragment slot="pnpm">
-  ```sh
-  pnpm astro add db
-  ```
-  </Fragment>
-  <Fragment slot="yarn">
-  ```sh
-  yarn astro add db
-  ```
-  </Fragment>
- </PackageManagerTabs>
-
-#### Instalación manual
-
-Si prefieres configurar las cosas desde cero, omite `astro add` y sigue estas instrucciones para instalar Astro DB tú mismo.
-
-##### 1. Instala la integración desde npm a través de un gestor de paquetes
-
-   <PackageManagerTabs>
-     <Fragment slot="npm">
-     ```shell
-     npm install @astrojs/db
-     ```
-     </Fragment>
-     <Fragment slot="pnpm">
-     ```shell
-     pnpm add @astrojs/db
-     ```
-     </Fragment>
-     <Fragment slot="yarn">
-     ```shell
-     yarn add @astrojs/db
-     ```
-     </Fragment>
-   </PackageManagerTabs>
-
-##### 2. Agrega la integración a `astro.config.mjs`
-
-    ```js title="astro.config.mjs" ins={2,6}
-    import { defineConfig } from 'astro/config';
-    import db from '@astrojs/db';
-
-    export default defineConfig({
-      integrations: [
-       db()
-      ]
-    });
-    ```
-
-##### 3. Configura tu base de datos
-
-Crea un archivo `db/config.ts` en la raíz de tu proyecto. Este es un archivo especial que Astro cargará y utilizará automáticamente para configurar las tablas de tu base de datos.
-
-```ts
-// db/config.ts
-import { defineDb } from 'astro:db';
-
-export default defineDb({
-  tables: {},
-})
-```
-
-## Configuración de la tabla de referencia
-
-### `columns`
-
-Las columnas de la tabla se configuran utilizando el objeto `columns`:
-
-```ts
-import { defineTable, column, NOW } from 'astro:db';
-
-const Comment = defineTable({
-	columns: {
-		id: column.number({ primaryKey: true }),
-		author: column.text(),
-		content: column.text({ optional: true }),
-		published: column.date({ default: NOW }),
-	},
-});
-```
-
-Las columnas se configuran utilizando la utilidad `column`. `column` admite los siguientes tipos:
-
-- **`column.text(...)`** - guarda contenido de texto plano o enriquecido
-- **`column.number(...)`** - almacena valores enteros y de punto flotante
-- **`column.boolean(...)`** - almacena valores verdaderos / falsos
-- **`column.date(...)`** - almacena objetos `Date`, analizados como strings ISO para el almacenamiento de datos
-- **`column.json(...)`** - almacena bloques JSON arbitrarios, analizados como JSON serializado para el almacenamiento de datos
-
-Hay algunos valores de configuración compartidos en todas las columnas:
-
-- `primaryKey` - Establece una columna `number` o `text` como identificador único.
-- `optional` - Astro DB usa `NOT NULL` para todas las columnas de forma predeterminada. Establece `optional` en `true` para permitir valores nulos.
-- `default` - Establece el valor predeterminado para las entradas recién insertadas. Esto acepta un valor estático o un string de `sql` para valores generados como marcas de tiempo.
- `unique` - Marca una columna como única. Esto evita valores duplicados en las entradas de la tabla.
-- `references` - Hace referencia a una tabla relacionada por columna. Esto establece una restricción de clave externa, lo que significa que cada valor de columna debe tener un valor coincidente en la tabla referenciada.
-
-### `indexes`
-
-Los índices de tabla se utilizan para mejorar la velocidad de búsqueda en una columna o combinación de columnas. La propiedad `indexes` acepta un arreglo de objetos de configuración especificando las columnas a indexar:
-
-```ts title="db/config.ts" {9-11}
-import { defineTable, column } from 'astro:db';
-
-const Comment = defineTable({
-  columns: {
-    authorId: column.number(),
-    published: column.date(),
-    body: column.text(),
-  },
-  indexes: [
-    { on: ["authorId", "published"], unique: true },
-  ]
-});
-```
-
-Esto generará un índice único en las columnas `authorId` y `published` con el nombre `Comment_authorId_published_idx`.
-
-Las siguientes opciones de configuración están disponibles para cada índice:
-
-- `on`: `string | string[]` - Una sola columna o un array de nombres de columnas para indexar.
-- `unique`: `boolean` - Establece `true` para forzar valores únicos en las columnas indexadas.
-- `name`: `string` (opcional) - Un nombre personalizado para el índice único. Esto anulará el nombre generado por Astro basado en el nombre de la tabla y las columnas que se están indexando (por ejemplo, `Comment_authorId_published_idx`). Los nombres personalizados son globales, así que asegúrate de que los nombres de índice no entren en conflicto entre tablas.
-
-### `foreignKeys`
-
-:::tip
-
-`foreignKeys` es una API avanzada para relacionar múltiples columnas de tabla. Si solo necesitas hacer referencia a una columna, intenta usar [la propiedad `references` de la columna.](#columns)
-
-:::
-
-Las claves foráneas se utilizan para establecer una relación entre dos tablas. La propiedad `foreignKeys` acepta una matriz de objetos de configuración que pueden relacionar una o más columnas entre tablas:
-
-```ts title="db/config.ts" {12-20}
-import { defineTable, column } from 'astro:db';
-
-const Author = defineTable({
-  columns: {
-    firstName: column.text(),
-    lastName: column.text(),
-  },
-});
-
-const Comment = defineTable({
-  columns: {
-    authorFirstName: column.text(),
-    authorLastName: column.text(),
-    body: column.text(),
-  },
-  foreignKeys: [
-    {
-      columns: ["authorFirstName", "authorLastName"],
-      references: () => [Author.columns.firstName, Author.columns.lastName],
-    },
-  ],
-});
-```
-
-Cada objeto de configuración de clave foránea acepta las siguientes propiedades:
-
-- `columns`: `string[]` - Un array de nombres de columnas para relacionar con la tabla referenciada.
-- `references`: `() => Column[]` - Una función que devuelve un array de columnas de la tabla referenciada.
-
-## Referencia de la CLI de Astro DB
-
-Astro DB incluye un conjunto de comandos CLI para interactuar con tu base de datos de proyecto alojada y tu cuenta de [Astro Studio](/es/guides/astro-db/#astro-studio).
-
-Estos comandos se ejecutan automáticamente al usar una acción de GitHub CI, y se pueden llamar manualmente utilizando el CLI `astro db`.
-
-### `astro db push`
-
-**Banderas:**
-
-- `--force-reset` Reinicia todos los datos de producción si se requiere un cambio de esquema. 
-
-De forma segura envía cambios de configuración de la base de datos a la base de datos de tu proyecto. Esto comprobará cualquier riesgo de pérdida de datos y te guiará en cualquier paso de migración recomendado. Si se debe realizar un cambio de esquema que rompa, usa la bandera `--force-reset` para restablecer todos los datos de producción.
-
-### `astro db verify`
-
-Verifica si hay diferencias entre las configuraciones de tu base de datos local y remota. Esto se ejecuta automáticamente con `astro db push`. `verify` comparará tu archivo `db/config.ts` local con la base de datos remota y advertirá si se detectan cambios.
-
-### `astro db execute <file-path>`
-
-**Banderas:**
-
-- `--remote` Ejecuta contra la base de datos de tu proyecto de Studio. Omite para ejecutar contra tu servidor de desarrollo.
-
-Ejecuta un archivo `.ts` o `.js` para leer o escribir en tu base de datos. Esto acepta una ruta de archivo como argumento y admite el uso del módulo `astro:db` para escribir consultas seguras. Utiliza la bandera `--remote` para ejecutar contra la base de datos de tu proyecto de Studio, u omite la bandera para ejecutar contra tu servidor de desarrollo. Consulta cómo [sembrar datos de desarrollo](/es/guides/astro-db/#sembrar-tu-base-de-datos) para ver un archivo de ejemplo. 
-
-### `astro db shell --query <sql-string>`
-
-**Banderas:**
-
-- `--query` Consulta SQL sin procesar para ejecutar.
-- `--remote` Ejecuta contra la base de datos de tu proyecto de Studio. Omite para ejecutar contra tu servidor de desarrollo.
-
-Ejecuta una consulta SQL sin procesar contra tu base de datos. Utiliza la bandera `--remote` para ejecutar contra la base de datos de tu proyecto de Studio u omite la bandera para ejecutar contra tu servidor de desarrollo.
-
-## Referencia de utilidad de Astro DB
-
-### `isDbError()`
-
-La función `isDbError()` comprueba si un error es una excepción de base de datos libSQL. Esto puede incluir un error de restricción de clave foránea al utilizar referencias, o campos que faltan al insertar datos. Puedes combinar `isDbError()` con un bloque try / catch para manejar errores de base de datos de tu aplicación:
-
-```ts title="src/pages/api/comment/[id].ts" "idDbError"
-import { db, Comment, isDbError } from 'astro:db';
-import type { APIRoute } from 'astro';
-
-export const POST: APIRoute = (ctx) => {
-  try {
-    await db.insert(Comment).values({
-      id: ctx.params.id,
-      content: '¡Hola, mundo!'
-    });
-  } catch (e) {
-    if (isDbError(e)) {
-      return new Response(`No se puede insertar comentario con id ${id}\n\n${e.message}`, { status: 400 });
-    }
-    return new Response('Se ha producido un error inesperado', { status: 500 });
-  }
-
-  return new Response(null, { status: 201 });
-};
-```
diff --git a/src/content/docs/es/guides/integrations-guide/deno.mdx b/src/content/docs/es/guides/integrations-guide/deno.mdx
deleted file mode 100644
index 03ea9826f5722..0000000000000
--- a/src/content/docs/es/guides/integrations-guide/deno.mdx
+++ /dev/null
@@ -1,11 +0,0 @@
----
-title: '@deno/astro-adapter'
-description: El adaptador Deno para Astro
-i18nReady: true
----
-
-El adaptador Deno permite a Astro implementar tu sitio SSR en objetivos de Deno, incluyendo Deno Deploy.
-
-Anteriormente, el adaptador Deno era mantenido por Astro, pero ahora es mantenido directamente por Deno. El uso ahora está documentado en el [repositorio del adaptador Deno](https://github.com/denoland/deno-astro-adapter).
-
-Si actualmente estás utilizando este adaptador de Astro, deberás migrar a la nueva versión de Deno o [agregar otro adaptador](/es/guides/on-demand-rendering/) para seguir SSR en tu proyecto.
diff --git a/src/content/docs/es/guides/integrations-guide/index.mdx b/src/content/docs/es/guides/integrations-guide/index.mdx
deleted file mode 100644
index 4cb07e15769e7..0000000000000
--- a/src/content/docs/es/guides/integrations-guide/index.mdx
+++ /dev/null
@@ -1,265 +0,0 @@
----
-title: Agrega integraciones
-i18nReady: true
----
-import IntegrationsNav from '~/components/IntegrationsNav.astro';
-import PackageManagerTabs from '~/components/tabs/PackageManagerTabs.astro'
-import { Steps } from '@astrojs/starlight/components'
-
-Las **Integraciones de Astro** agregan nuevas funcionalidades a su proyecto con solo unas pocas líneas de código. Tú mismo puedes escribir una integración personalizada, utilizar una integración oficial utilizar [integraciones desarrolladas por la comunidad](#encontrar-más-integraciones) o también [Construir una integración personalizada por ti mismo](#construyendo-tu-propia-integración). 
-
-Usando integraciones puedes...
-
-- Desbloquear React, Vue, Svelte, Solid y otros populares frameworks de UI con un [renderizador](/es/guides/framework-components/).
-- Habilitar la renderización bajo demanda con un [adaptador SSR](/es/guides/on-demand-rendering/).
-- Integrar herramientas como Tailwind y Partytown con unas pocas líneas de código.
-- Agregar nuevas funcionalidades a tu proyecto, como la generación automática de sitemaps.
-- Escribir código personalizado que se conecte con el proceso de compilación, el entorno de desarrollo y más.
-
-:::tip[DIRECTORIO DE INTEGRACIONES]
-Navega o busca el conjunto completo de cientos de integraciones oficiales y de la comunidad en nuestro [directorio de integraciones](https://astro.build/integrations/). Encuentra paquetes para agregar a tu proyecto Astro para autenticación, análisis, rendimiento, SEO, accesibilidad, UI, herramientas para desarrolladores y más.
-:::
-
-## Integraciones oficiales
-
-Las siguientes integraciones son mantenidas por Astro.
-
-<IntegrationsNav />
-
-## Configuración de integración automática
-
-Astro incluye un comando `astro add` para automatizar la configuración de integraciones. Varios plugins de la comunidad también se pueden agregar utilizando este comando. Consulta la documentación de cada integración para ver si se admite `astro add`, o si debes [instalar manualmente](#instalación-manual).
-
-Puedes correr el comando `astro add` utilizando el gestor de paquetes de tu preferencia y nuestro asistente de integración automática actualizará tu archivo de configuración e instalará las dependencias necesarias.
-
-<PackageManagerTabs>
-  <Fragment slot="npm">
-  ```shell
-  npx astro add react
-  ```
-  </Fragment>
-  <Fragment slot="pnpm">
-  ```shell
-  pnpm astro add react
-  ```
-  </Fragment>
-  <Fragment slot="yarn">
-  ```shell
-  yarn astro add react
-  ```
-  </Fragment>
-</PackageManagerTabs>
-
-¡Incluso es posible agregar múltiples integraciones al mismo tiempo!
-
-<PackageManagerTabs>
-  <Fragment slot="npm">
-  ```shell
-  npx astro add react tailwind partytown
-  ```
-  </Fragment>
-  <Fragment slot="pnpm">
-  ```shell
-  pnpm astro add react tailwind partytown
-  ```
-  </Fragment>
-  <Fragment slot="yarn">
-  ```shell
-  yarn astro add react tailwind partytown
-  ```
-  </Fragment>
-</PackageManagerTabs>
-
-:::note[Manejando dependencias de integraciones]
-Si ves una advertencia con el texto `Cannot find package '[nombre-de-paquete]'` después de agregar una integración, probablemente tu gestor de paquetes no haya instalado las [peer dependencies](https://nodejs.org/en/blog/npm/peer-dependencies/) por ti. Para instalar los paquetes faltantes, ejecuta `npm install [nombre-de-paquete]` en la terminal.
-:::
-
-### Instalación manual
-
-Las integraciones de Astro siempre se agregan a través de la propiedad `integrations` en tu archivo `astro.config.mjs`.
-
-Hay tres formas comunes de importar una integración a tu proyecto Astro:
-1. [Instala una integración de paquete NPM](#instalando-un-paquete-npm).
-2. Importando tu propia integración desde un archivo local dentro de tu proyecto.
-3. Escribiendo tu integración en línea, directamente en tu archivo de configuración.
-
-    ```js
-    // astro.config.mjs
-    import { defineConfig } from 'astro/config';
-    import installedIntegration from '@astrojs/vue';
-    import localIntegration from './my-integration.js';
-
-    export default defineConfig({
-      integrations: [
-        // 1. Importado desde un paquete npm instalado
-        installedIntegration(),
-        // 2. Importado desde un archivo JS local
-        localIntegration(),
-        // 3. Un objeto en línea
-        {name: 'namespace:id', hooks: { /* ... */ }},
-      ]
-    });
-    ```
-
-Consulta la referencia de [API de integración](/es/reference/integrations-reference/) para conocer las diferentes formas en las que puedes escribir una integración.
-
-#### Instalando un paquete NPM
-
-Instala una integración de paquete NPM utilizando un gestor de paquetes, y luego actualiza `astro.config.mjs` manualmente.
-
-Por ejemplo, para instalar la integración `@astrojs/sitemap`:
-<Steps>
-1. Instala la integración en las dependencias de tu proyecto utilizando tu gestor de paquetes preferido:
-
-   <PackageManagerTabs>
-     <Fragment slot="npm">
-     ```shell
-     npm install @astrojs/sitemap
-     ```
-     </Fragment>
-     <Fragment slot="pnpm">
-     ```shell
-     pnpm add @astrojs/sitemap
-     ```
-     </Fragment>
-     <Fragment slot="yarn">
-     ```shell
-     yarn add @astrojs/sitemap
-     ```
-     </Fragment>
-   </PackageManagerTabs>
-
-2. Importa la integración a tu archivo `astro.config.mjs` y agrégala a tu array `integrations[]`, junto con cualquier opción de configuración:
-
-    ```js title="astro.config.mjs" ins={2} ins="sitemap()"
-    import { defineConfig } from 'astro/config';
-    import sitemap from '@astrojs/sitemap';
-
-    export default defineConfig({
-      // ...
-      integrations: [sitemap()],
-      // ...
-    });
-    ```
-
-    Nota que diferentes integraciones pueden tener diferentes configuraciones. Lee la documentación de cada integración y aplica cualquier configuración necesaria a la integración que hayas elegido en `astro.config.mjs`
-</Steps>
-
-### Opciones personalizadas
-
-Las integraciones casi siempre se crean como factory function que devuelven el objeto de integración real. Esto te permite pasar argumentos y opciones a la factory function que personaliza la integración para tu proyecto.
-
-```js
-integrations: [
-  // Ejemplo: personaliza tu integración con argumentos de función
-  sitemap({filter: true})
-]
-```
-
-### Activar una Integración
-
-Las integraciones _falsy_ (con valor falso) son ignoradas, de esta forma puedes activar o desactivar integraciones sin preocuparte por valores `undefined` o booleanos abandonados.
-
-```js
-integrations: [
-  // Ejemplo: Omitir la generación de un sitemap en Windows
-  process.platform !== 'win32' && sitemap()
-]
-```
-
-## Actualizando integraciones
-
-Para actualizar todas las integraciones oficiales a la vez, ejecuta el comando `@astrojs/upgrade`. Este actualizará tanto Astro como todas las integraciones oficiales a sus última versiones.
-
-### Actualización Automática
-
-<PackageManagerTabs>
-  <Fragment slot="npm">
-  ```shell
-  # Actualiza Astro y las integraciones oficiales a la última versión
-  npx @astrojs/upgrade
-  ```
-  </Fragment>
-  <Fragment slot="pnpm">
-  ```shell
-  # Actualiza Astro y las integraciones oficiales a la última versión
-  pnpm dlx @astrojs/upgrade
-  ```
-  </Fragment>
-  <Fragment slot="yarn">
-  ```shell
-  # Actualiza Astro y las integraciones oficiales a la última versión
-  yarn dlx @astrojs/upgrade
-  ```
-  </Fragment>
-</PackageManagerTabs>
-
-### Actualización Manual
-
-Para actualizar una o más integraciones manualmente, utiliza el comando apropiado para tu gestor de paquetes.
-
-<PackageManagerTabs>
-  <Fragment slot="npm">
-  ```shell
-  # Ejemplo: actualiza las integraciones de React y Tailwind
-  npm install @astrojs/react@latest @astrojs/tailwind@latest
-  ```
-  </Fragment>
-  <Fragment slot="pnpm">
-  ```shell
-  # Ejemplo: actualiza las integraciones de React y Tailwind
-  pnpm add @astrojs/react@latest @astrojs/tailwind@latest
-  ```
-  </Fragment>
-  <Fragment slot="yarn">
-  ```shell
-  # Ejemplo: actualiza las integraciones de React y Tailwind
-  yarn add @astrojs/react@latest @astrojs/tailwind@latest
-  ```
-  </Fragment>
-</PackageManagerTabs>
-
-## Eliminando una Integración
-
-Para eliminar una integración, primero desinstala la integración de tu proyecto
-
-<PackageManagerTabs>
-  <Fragment slot="npm">
-  ```shell
-  npm uninstall @astrojs/react
-  ```
-  </Fragment>
-  <Fragment slot="pnpm">
-  ```shell
-  pnpm remove @astrojs/react
-  ```
-  </Fragment>
-  <Fragment slot="yarn">
-  ```shell
-  yarn remove @astrojs/react
-  ```
-  </Fragment>
-</PackageManagerTabs>
-
-Después, elimina la integración de tu archivo `astro.config.*`:
-
-```js title="astro.config.mjs" del={3,7}
-import { defineConfig } from 'astro/config'
-import react from "@astrojs/react";
-
-export default defineConfig({
-  integrations: [
-    react()
-  ]
-});
-```
-
-## Encontrar más integraciones
-
-Puedes encontrar muchas integraciones desarrolladas por la comunidad en el [Directorio de Integraciones de Astro](https://astro.build/integrations/). Sigue los enlaces para obtener instrucciones detalladas de uso y configuración.
-
-## Construyendo tu propia integración
-
-La API de integración de Astro está inspirada en Rollup y Vite, y está diseñada para sentirse familiar para cualquiera que haya escrito antes un plugin de Rollup o Vite.
-
-Consulta la referencia [API de integración](/es/reference/integrations-reference/) para saber qué pueden hacer las integraciones y cómo escribir una tú mismo.
diff --git a/src/content/docs/es/guides/integrations-guide/lit.mdx b/src/content/docs/es/guides/integrations-guide/lit.mdx
deleted file mode 100644
index 5d15d4c4fd892..0000000000000
--- a/src/content/docs/es/guides/integrations-guide/lit.mdx
+++ /dev/null
@@ -1,219 +0,0 @@
----
-type: integration
-title: '@astrojs/lit'
-description: Aprende cómo utilizar la integración del framework @astrojs/lit para extender el soporte de componentes en tu proyecto Astro.
-githubIntegrationURL: 'https://github.com/withastro/astro/tree/main/packages/integrations/lit/'
-category: renderer
-i18nReady: true
----
-import PackageManagerTabs from '~/components/tabs/PackageManagerTabs.astro'
-
-
-Esta **[integración de Astro][astro-integration]** permite renderización en el servidor e hidratación en el cliente para tus elementos personalizados de [Lit](https://lit.dev/).
-
-## Instalación
-
-Astro incluye un comando `astro add` para automatizar la configuración de las integraciones oficiales. Si lo prefieres, puedes [instalar las integraciones manualmente](#instalación-manual) en su lugar.
-
-Para instalar `@astrojs/lit`,  ejecuta lo siguiente desde el directorio de tu proyecto y sigue las indicaciones:
-
-<PackageManagerTabs>
-  <Fragment slot="npm">
-    ```sh
-    npx astro add lit
-    ```
-  </Fragment>
-  <Fragment slot="pnpm">
-    ```sh
-    pnpm astro add lit
-    ```
-  </Fragment>
-  <Fragment slot="yarn">
-    ```sh
-    yarn astro add lit
-    ```
-  </Fragment>
-</PackageManagerTabs>
-
-Si tienes algún problema, [no dudes en informárnoslo en GitHub](https://github.com/withastro/astro/issues) y prueba los pasos de instalación manual a continuación.
-
-### Instalación manual
-
-Primero, instala el paquete `@astrojs/lit`:
-
-<PackageManagerTabs>
-  <Fragment slot="npm">
-  ```sh
-  npm install @astrojs/lit
-  ```
-  </Fragment>
-  <Fragment slot="pnpm">
-  ```sh
-  pnpm add @astrojs/lit
-  ```
-  </Fragment>
-  <Fragment slot="yarn">
-  ```sh
-  yarn add @astrojs/lit
-  ```
-  </Fragment>
-</PackageManagerTabs>
-
-La mayoría de los gestores de paquetes también instalarán las dependencias asociadas.  Sin embargo, si ves un aviso "No se puede encontrar el paquete 'lit'" (o similar) al iniciar Astro, tendrás que instalar `lit` y `@webcomponents/template-shadowroot`:
-
-<PackageManagerTabs>
-  <Fragment slot="npm">
-  ```sh
-  npm install lit @webcomponents/template-shadowroot
-  ```
-  </Fragment>
-  <Fragment slot="pnpm">
-  ```sh
-  pnpm add lit @webcomponents/template-shadowroot
-  ```
-  </Fragment>
-  <Fragment slot="yarn">
-  ```sh
-  yarn add lit @webcomponents/template-shadowroot
-  ```
-  </Fragment>
-</PackageManagerTabs>
-
-Luego, aplica la integración a tu archivo `astro.config.*` usando la propiedad `integrations`:
-
-```js ins={2} ins="lit()" title="astro.config.mjs"
-import { defineConfig } from 'astro/config';
-import lit from '@astrojs/lit';
-
-export default defineConfig({
-  // ...
-  integrations: [lit()],
-});
-```
-
-## Empezando
-
-Para usar tu primer componente React en Astro, dirígete a nuestra [documentación de frameworks UI][astro-ui-frameworks]. Explorarás:
-
-* 📦 como se cargan los componentes de framework,
-* 💧 opciones de hidratación del lado del cliente, y
-* 🤝 oportunidades para mezclar y anidar frameworks juntos
-
-Escribir e importar un componente de Lit en Astro se ve así:
-
-```js title="src/components/my-element.js"
-import { LitElement, html } from 'lit';
-
-export class MyElement extends LitElement {
-  render() {
-    return html`<p>Hello world! From my-element</p>`;
-  }
-}
-
-customElements.define('my-element', MyElement);
-```
-
-Ahora, el componente está listo para ser importado a través del frontmatter de Astro:
-
-```astro title="src/pages/index.astro"
----
-import { MyElement } from '../components/my-element.js';
----
-
-<MyElement />
-```
-
-:::note
-Lit requiere que los globales del navegador, como `HTMLElement` y `customElements`, estén presentes. Por esta razón, el renderizador de Lit simula estos globales en el servidor para que Lit pueda funcionar. Es *posible* que te encuentres con bibliotecas que funcionen incorrectamente debido a esto.
-:::
-
-### Decoradores Experimentales
-
-Para utilizar los [decoradores experimentales en Lit](https://lit.dev/docs/components/decorators/), agrega las siguientes lineas en tu archivo `tsconfig.json`:
-
-```json title="tsconfig.json" add={3}
-{
-  "compilerOptions": {
-    "experimentalDecorators": true,
-  }
-}
-```
-
-Esto te permite utilizar los decoradores experimentales como `@customElement` y `@state` para registrar un elemento personalizado y definir una propiedad de estado en tu componente Lit:
-
-```ts title="src/components/my-element.ts"
-import { LitElement, html } from "lit";
-import { customElement, state } from "lit/decorators.js";
-
-@customElement("my-element")
-export class MyElement extends LitElement {
-    @state() name = "my-element";
-
-    override render() {
-        return html`<p>¡Hola Mundo! Desde ${this.name}</p>`;
-    }
-}
-```
-
-### Polyfills y Hidratación
-
-El renderizador maneja automáticamente la adición de los polifills adecuados para brindar soporte en navegadores que no tienen Declarative Shadow DOM. El polifill tiene un tamaño aproximado de *1.5kB*. Si el navegador admite Declarative Shadow DOM, se cargan menos de 250 bytes (para detectar la compatibilidad con la función).
-
-La hidratación también se maneja automáticamente. Puedes usar las mismas directivas de hidratación, como `client:load`, `client:idle` y `client:visible`, como lo harías con otras bibliotecas compatibles con Astro.
-
-```astro
----
-import { MyElement } from '../components/my-element.js';
----
-
-<MyElement client:visible />
-```
-
-Lo anterior solo cargará el JavaScript del elemento cuando el usuario lo haya desplazado a la vista. Dado que se renderiza en el servidor, el usuario no verá ningún parpadeo; se cargará y se hidratará de manera transparente.
-
-## Solución de problemas
-
-Para obtener ayuda, consulta el canal `#support` en [Discord](https://astro.build/chat). ¡Nuestros amables miembros del Equipo de Soporte están aquí para ayudar!
-
-También puedes consultar nuestra [documentación de integración de Astro][astro-integration] para obtener más información sobre las integraciones.
-
-A continuación se enumeran algunos problemas comunes:
-
-### Globales del navegador
-
-La renderización del lado del servidor (SSR) de la integración de Lit funciona mediante la adición de algunas propiedades globales del navegador al entorno global. Algunas de las propiedades que se agregan incluyen `window`, `document` y `location`.
-
-Estos globales *pueden* interferir con otras bibliotecas que utilizan la existencia de estas variables para detectar que se están ejecutando en el navegador, cuando en realidad se están ejecutando en el servidor. Esto puede provocar errores en estas bibliotecas.
-
-Debido a esto, la integración de Lit puede no ser compatible con este tipo de bibliotecas. Una cosa que puede ayudar es cambiar el orden de las integraciones cuando Lit interfiere con otras integraciones:
-
-```js lang="js" title="astro.config.mjs" ins={7} del={6}
-  import { defineConfig } from 'astro/config';
-  import vue from '@astrojs/vue';
-  import lit from '@astrojs/lit';
-
-  export default defineConfig({
-    integrations: [vue(), lit()]
-    integrations: [lit(), vue()]
-  });
-```
-
-El orden correcto puede variar según la causa subyacente del problema. Sin embargo, no se garantiza que esto solucione todos los problemas, y algunas bibliotecas no se pueden utilizar si estás utilizando la integración de Lit debido a esto.
-
-### Gestores de paquetes estrictos
-
-Cuando utilizas un [gestor de paquetes estricto](https://pnpm.io/pnpm-vs-npm#npms-flat-tree) como `pnpm`, es posible que obtengas un error como `ReferenceError: module is not defined` al ejecutar tu sitio. Para solucionar esto, debes elevar las dependencias de Lit con un archivo `.npmrc`:
-
-```ini title=".npmrc"
-public-hoist-pattern[]=*lit*
-```
-
-### Limitaciones
-
-- La integración de Lit está impulsada por `@lit-labs/ssr`que tiene algunas limitaciones. Consulta su [documentación de limitaciones](https://www.npmjs.com/package/@lit-labs/ssr#notes-and-limitations) para obtener más información al respecto.
-
-- Astro no admite componentes IntelliSense para Lit.
-
-[astro-integration]: /es/guides/integrations-guide/
-
-[astro-ui-frameworks]: /es/guides/framework-components/#usando-componente-de-framework
diff --git a/src/content/docs/es/guides/integrations-guide/markdoc.mdx b/src/content/docs/es/guides/integrations-guide/markdoc.mdx
deleted file mode 100644
index d9fff65a73dd5..0000000000000
--- a/src/content/docs/es/guides/integrations-guide/markdoc.mdx
+++ /dev/null
@@ -1,652 +0,0 @@
----
-type: integration
-title: '@astrojs/markdoc'
-description: Aprende a usar la integración @astrojs/markdoc en tu proyecto Astro.
-sidebar:
-  label: Markdoc
-githubIntegrationURL: 'https://github.com/withastro/astro/tree/main/packages/integrations/markdoc/'
-category: other
-i18nReady: true
----
-import { FileTree } from '@astrojs/starlight/components';
-import PackageManagerTabs from '~/components/tabs/PackageManagerTabs.astro';
-import { Steps } from '@astrojs/starlight/components';
-import ReadMore from '~/components/ReadMore.astro';
-
-Esta **[integración de Astro][astro-integration]** permite el uso de [Markdoc](https://markdoc.dev/) para crear componentes, páginas y entradas de colecciones de contenido.
-
-## ¿Por qué Markdoc?
-
-Markdoc te permite mejorar tu Markdown con [componentes de Astro][astro-components]. Si tienes contenido existente escrito en Markdoc, esta integración te permite traer esos archivos a tu proyecto de Astro usando colecciones de contenido.
-
-## Instalación
-
-Astro incluye un comando `astro add` para automatizar la configuración de las integraciones oficiales. Si lo prefieres, puedes [instalar las integraciones manualmente](#instalación-manual) en su lugar.
-
-Ejecuta uno de los siguientes comandos en una nueva ventana de terminal.
-
-<PackageManagerTabs>
-  <Fragment slot="npm">
-  ```sh
-  npx astro add markdoc
-  ```
-  </Fragment>
-  <Fragment slot="pnpm">
-  ```sh
-  pnpm astro add markdoc
-  ```
-  </Fragment>
-  <Fragment slot="yarn">
-  ```sh
-  yarn astro add markdoc
-  ```
-  </Fragment>
-</PackageManagerTabs>
-
-Si tienes algún problema, [no dudes en reportarlo en GitHub](https://github.com/withastro/astro/issues) e intenta los pasos de instalación manual a continuación.
-
-### Instalación manual
-
-Primero, instala el paquete `@astrojs/markdoc`:
-
-<PackageManagerTabs>
-  <Fragment slot="npm">
-  ```sh
-  npm install @astrojs/markdoc
-  ```
-  </Fragment>
-  <Fragment slot="pnpm">
-  ```sh
-  pnpm add @astrojs/markdoc
-  ```
-  </Fragment>
-  <Fragment slot="yarn">
-  ```sh
-  yarn add @astrojs/markdoc
-  ```
-  </Fragment>
-</PackageManagerTabs>
-
-Luego, aplica la integración a tu archivo `astro.config.*` utilizando la propiedad `integrations`:
-
-```js ins="markdoc()" title="astro.config.mjs" ins={2}
-import { defineConfig } from 'astro/config';
-import markdoc from '@astrojs/markdoc';
-export default defineConfig({
-  // ...
-  integrations: [markdoc()],
-});
-```
-
-### Integración del editor VS Code
-
-Si estás usando VS Code, hay una [extensión de lenguaje Markdoc](https://marketplace.visualstudio.com/items?itemName=Stripe.markdoc-language-support) que incluye resaltado de sintaxis y autocompletado para etiquetas configuradas. [Consulta el servidor de lenguaje en GitHub](https://github.com/markdoc/language-server.git) para más información.
-
-Para configurar la extensión, crea un archivo `markdoc.config.json` en la raíz del proyecto con el siguiente contenido:
-
-```json title="markdoc.config.json"
-[
-  {
-    "id": "my-site",
-    "path": "src/content",
-    "schema": {
-      "path": "markdoc.config.mjs",
-      "type": "esm",
-      "property": "default",
-      "watch": true
-    }
-  }
-]
-```
-
-Establece el archivo `markdoc.config.mjs` como tu archivo de configuración con el objeto `schema` y define dónde se almacenan tus archivos Markdoc usando la propiedad `path`. Dado que Markdoc es específico para las colecciones de contenido, puedes usar `src/content`.
-
-## Uso
-
-Los archivos Markdoc solo se pueden usar dentro de las colecciones de contenido. Agrega entradas a cualquier colección de contenido usando la extensión `.mdoc`:
-
-<FileTree>
-- src/
-  - content/
-    - docs/
-      - why-markdoc.mdoc
-      - quick-start.mdoc
-</FileTree>
-
-Luego, consulta tu colección usando las [APIs de colecciones de contenido](/es/guides/content-collections/#consultando-colecciones):
-
-```astro title="src/pages/why-markdoc.astro"
----
-import { getEntryBySlug } from 'astro:content';
-
-const entry = await getEntryBySlug('docs', 'why-markdoc');
-const { Content } = await entry.render();
----
-
-<!--Accede a las propiedades del frontmatter con `data`-->
-<h1>{entry.data.title}</h1>
-<!--Renderiza el contenido Markdoc con el componente de contenido-->
-<Content />
-```
-
-<ReadMore>Consulta la [documentación de Astro sobre Colecciones de Contenido][astro-content-collections] para más información.</ReadMore>
-
-## Pasa variables de Markdoc
-
-Es posible que necesites pasar [variables][markdoc-variables] a tu contenido. Esto es útil cuando pasas parámetros SSR como pruebas A/B.
-
-Las variables pueden pasarse como props a través del componente `Content`:
-
-```astro title="src/pages/why-markdoc.astro"
----
-import { getEntryBySlug } from 'astro:content';
-const entry = await getEntryBySlug('docs', 'why-markdoc');
-const { Content } = await entry.render();
----
-<!--Pasa el parámetro `abTest` como una variable-->
-<Content abTestGroup={Astro.params.abTestGroup} />
-```
-
-Ahora, `abTestGroup` está disponible como una variable en `docs/why-markdoc.mdoc`:
-
-```md title="src/content/docs/why-markdoc.mdoc"
-{% if $abTestGroup === 'image-optimization-lover' %}
-
-Permite que te hable sobre la optimización de imágenes...
-
-{% /if %}
-```
-
-Para hacer una variable global para todos los archivos Markdoc, puedes usar el atributo `variables` de tu `markdoc.config.mjs|ts`:
-
-```js title="markdoc.config.mjs"
-import { defineMarkdocConfig } from '@astrojs/markdoc/config';
-
-export default defineMarkdocConfig({
-  variables: {
-    environment: process.env.IS_PROD ? 'prod' : 'dev',
-  },
-});
-```
-
-### Accede al frontmatter desde tu contenido Markdoc
-
-Para acceder al frontmatter, puedes pasar la propiedad de entrada `data` como una variable donde renderizas tu contenido:
-
-```astro title="src/pages/why-markdoc.astro"
----
-import { getEntry } from 'astro:content';
-const entry = await getEntry('docs', 'why-markdoc');
-const { Content } = await entry.render();
----
-<Content frontmatter={entry.data} />
-```
-
-Esto ahora puede ser accedido como `$frontmatter` en tu Markdoc.
-
-## Render components
-
-`@astrojs/markdoc` ofrece opciones de configuración para usar todas las características de Markdoc y conectar componentes de interfaz de usuario a tu contenido.
-
-### Usa componentes Astro como etiquetas Markdoc
-
-Puedes configurar [etiquetas Markdoc][markdoc-tags] que se asignan a componentes `.astro`. Puedes agregar una nueva etiqueta creando un archivo `markdoc.config.mjs|ts` en la raíz de tu proyecto y configurando el atributo `tag`.
-
-Este ejemplo renderiza un componente `Aside`, y permite que se pase una prop `type` como un string:
-
-```js title="markdoc.config.mjs"
-import { defineMarkdocConfig, component } from '@astrojs/markdoc/config';
-
-export default defineMarkdocConfig({
-  tags: {
-    aside: {
-      render: component('./src/components/Aside.astro'),
-      attributes: {
-        // Markdoc requiere definiciones de tipo para cada atributo.
-        // Estas deben reflejar el tipo `Props` del componente
-        // que vas a renderizar.
-        // Consulta la documetación de Markdoc sobre definir atributos
-        // https://markdoc.dev/docs/attributes#defining-attributes
-        type: { type: String },
-      },
-    },
-  },
-});
-```
-
-Este componente ahora se puede usar en tus archivos Markdoc con la etiqueta `{% aside %}`. Los elementos hijos serán enviados al espacio por defecto de tu componente:
-
-```md
-# Bienvenido a Markdoc 👋
-
-{% aside type="tip" %}
-
-Usa etiquetas como esta elegante "aside" para agregar un poco de _estilo_ a tus documentos.
-
-{% /aside %}
-```
-
-### Usa componentes de UI del lado del cliente
-
-Las etiquetas y nodos están restringidos a archivos `.astro`. Para incrustar componentes de interfaz de usuario del lado del cliente en Markdoc, [usa un componente `.astro` de envoltura que renderice un componente de framework](/es/guides/framework-components/#anidando-componentes-de-framework) con tu directiva `client:` deseada.
-
-Este ejemplo envuelve un componente React `Aside.tsx` con un componente `ClientAside.astro`:
-
-```astro title="src/components/ClientAside.astro"
----
-import Aside from './Aside';
----
-<Aside {...Astro.props} client:load />
-```
-
-Este componente de Astro ahora puede ser pasado a la propiedad `render` para cualquier [etiqueta][markdoc-tags] o [nodo][markdoc-nodes] en tu configuración:
-
-```js title="markdoc.config.mjs"
-import { defineMarkdocConfig, component } from '@astrojs/markdoc/config';
-
-export default defineMarkdocConfig({
-  tags: {
-    aside: {
-      render: component('./src/components/ClientAside.astro'),
-      attributes: {
-        type: { type: String },
-      },
-    },
-  },
-});
-```
-
-### Utiliza los componentes de Astro desde paquetes npm y archivos TypeScript
-
-Es posible que necesites utilizar los componentes de Astro expuestos como exportaciones nombradas desde archivos TypeScript o JavaScript. Esto es común cuando se utilizan paquetes npm y sistemas de diseño.
-
-Puedes pasar el nombre de importación como segundo argumento a la función `component()`:
-
-```js title="markdoc.config.mjs"
-import { defineMarkdocConfig, component } from '@astrojs/markdoc/config';
-
-export default defineMarkdocConfig({
-  tags: {
-    tabs: {
-      render: component('@astrojs/starlight/components', 'Tabs'),
-    },
-  },
-});
-```
-
-Esto genera la siguiente declaración de importación internamente:
-
-```ts
-import { Tabs } from '@astrojs/starlight/components';
-```
-
-## Partials de Markdoc
-
-La etiqueta `{% partial %}` te permite renderizar otros archivos `.mdoc` dentro de tu contenido Markdoc.
-
-Esto es útil para reutilizar contenido en varios documentos y te permite tener archivos de contenido `.mdoc` que no siguen tu esquema de colección.
-
-:::tip
-Usa un guion bajo `_` como prefijo para los archivos o directorios parciales. Esto excluye los parciales de las consultas de colección de contenido.
-:::
-
-Este ejemplo muestra un parcial de Markdoc para un pie de página que se usará dentro de las entradas de la colección de blogs:
-
-```md title="src/content/blog/_footer.mdoc"
-Social links:
-
-- [Twitter / X](https://twitter.com/astrodotbuild)
-- [Discord](https://astro.build/chat)
-- [GitHub](https://github.com/withastro/astro)
-```
-
-Usa la etiqueta `{% partial %}` con el atributo `file` para renderizar el pie de página al final de una entrada de blog. Aplica el atributo `file` con la ruta al archivo, usando una ruta relativa o un alias de importación:
-
-```md title="src/content/blog/post.mdoc" ins='file="_footer.mdoc"'
-# My Blog Post
-
-{% partial file="./_footer.mdoc" %}
-```
-
-## Resaltado de sintaxis
-
-`@astrojs/markdoc` proporciona extensiones de [Shiki](https://shiki.style) y [Prism](https://github.com/PrismJS) para resaltar tus bloques de código.
-
-### Shiki
-
-Aplica la extensión `shiki()` a tu configuración Markdoc usando la propiedad `extends`. Opcionalmente puedes pasar un objeto de configuración de shiki:
-
-```js title="markdoc.config.mjs"
-import { defineMarkdocConfig } from '@astrojs/markdoc/config';
-import shiki from '@astrojs/markdoc/shiki';
-
-export default defineMarkdocConfig({
-  extends: [
-    shiki({
-      // Escoge de los temas integrados de Shiki (o agrega el tuyo)
-      // Por defecto: 'github-dark'
-      // https://shiki.style/themes
-      theme: 'dracula',
-      // Habilita el ajuste de palabras para evitar el desplazamiento horizontal
-      // Por defecto: false
-      wrap: true,
-      // Pasa lenguajes personalizados
-      // Nota: Shiki tiene innumerables lenguajes integrados, ¡incluyendo `.astro`!
-      // https://shiki.style/languages
-      langs: [],
-    }),
-  ],
-});
-```
-
-### Prism
-
-Aplica la extensión `prism()` a tu configuración Markdoc usando la propiedad `extends`.
-
-```js title="markdoc.config.mjs" ins={5}
-import { defineMarkdocConfig } from '@astrojs/markdoc/config';
-import prism from '@astrojs/markdoc/prism';
-
-export default defineMarkdocConfig({
-  extends: [prism()],
-});
-```
-
-<ReadMore>Para aprender acerca de como configurar las hojas de estilo de Prism, [consulta nuestra guía de resaltado de sintaxis](/es/guides/markdown-content/#configuración-de-prism).</ReadMore>
-
-## Nodos personalizados de Markdoc / elementos
-
-Es posible que desees renderizar elementos Markdown estándar, como párrafos y texto en negrita, como componentes Astro. Para esto, puedes configurar un [nodo Markdoc][markdoc-nodes]. Si un nodo determinado recibe atributos, estarán disponibles como props del componente.
-
-Este ejemplo renderiza bloques de citas con un componente `Quote.astro` personalizado:
-
-```js title="markdoc.config.mjs"
-import { defineMarkdocConfig, nodes, component } from '@astrojs/markdoc/config';
-
-export default defineMarkdocConfig({
-  nodes: {
-    blockquote: {
-      ...nodes.blockquote, // Aplica los valores predeterminados de Markdoc para otras opciones
-      render: component('./src/components/Quote.astro'),
-    },
-  },
-});
-```
-
-<ReadMore>Consulta la [documentación de nodos de Markdoc](https://markdoc.dev/docs/nodes#built-in-nodes) para obtener información sobre todos los nodos y atributos incorporados.</ReadMore>
-
-### Encabezados personalizados
-
-`@astrojs/markdoc` agrega automáticamente enlaces de anclaje a tus encabezados y [genera una lista de `headings` a través de la API de colecciones de contenido](/es/guides/content-collections/#renderizando-contenido-a-html). Para personalizar aún más cómo se renderizan los encabezados, puedes aplicar un componente Astro [como un nodo de Markdoc][markdoc-nodes].
-
-Este ejemplo renderiza un componente `Heading.astro` usando la propiedad `render`:
-
-```js title="markdoc.config.mjs"
-import { defineMarkdocConfig, nodes, component } from '@astrojs/markdoc/config';
-
-export default defineMarkdocConfig({
-  nodes: {
-    heading: {
-      ...nodes.heading, // Preserva la generación predeterminada de enlaces de anclaje
-      render: component('./src/components/Heading.astro'),
-    },
-  },
-});
-```
-
-Todos los encabezados de Markdown renderizarán el componente `Heading.astro` y pasarán los siguientes `attributes` como props del componente:
-
-* `level: number` El nivel de encabezado 1 - 6
-* `id: string` Un `id` generado a partir del contenido de texto del encabezado. Esto corresponde al `slug` generado por la [función `render()` de contenido](/es/guides/content-collections/#renderizando-contenido-a-html).
-
-Por ejemplo, el encabezado `### Level 3 heading!` pasará `level: 3` e `id: 'level-3-heading'` como props del componente.
-
-### Componentes de imagen personalizados en Markdoc
-
-El componente `<Image />` de Astro no puede usarse directamente en Markdoc. Sin embargo, puedes configurar un componente de Astro para anular el nodo de imagen predeterminado cada vez que se use la sintaxis de imagen nativa `![]()`, o como una etiqueta personalizada de Markdoc para permitirte especificar atributos de imagen adicionales.
-
-#### Anular el nodo de imagen predeterminado de Markdoc
-
-Para anular el nodo de imagen predeterminado, puedes configurar un componente `.astro` para ser renderizado en lugar de un `<img>` estándar.
-
-<Steps>
-1. Construye un componente personalizado `MarkdocImage.astro` para pasar las propiedades `src` y `alt` requeridas de tu imagen al componente `<Image />`:
-
-    ```astro title="src/components/MarkdocImage.astro"
-    ---
-    import { Image } from "astro:assets";
-    interface Props {
-      src: ImageMetadata;
-      alt: string;
-    }
-    const { src, alt } = Astro.props;
-    ---
-    <Image src={src} alt={alt} />
-    ```
-
-2. El componente `<Image />` requiere un `width` y `height` para las imágenes remotas que no pueden ser proporcionadas usando la sintaxis `![]()`. Para evitar errores al usar imágenes remotas, actualiza tu componente para renderizar una etiqueta HTML `<img>` estándar cuando se encuentre una URL remota `src`:
-
-    ```astro title="src/components/MarkdocImage.astro" ins="| string" del={9} ins={10-12}
-    ---
-    import { Image } from "astro:assets";
-    interface Props {
-      src: ImageMetadata | string;
-      alt: string;
-    }
-    const { src, alt } = Astro.props;
-    ---
-    <Image src={src} alt={alt} />
-    {
-      typeof src === 'string' ? <img src={src} alt={alt} /> : <Image src={src} alt={alt} />
-    }
-    ```
-
-3. Configura Markdoc para anular el nodo de imagen predeterminado y renderizar `MarkdocImage.astro`:
-
-    ```js title="markdoc.config.mjs"
-    import { defineMarkdocConfig, nodes, component } from '@astrojs/markdoc/config';
-
-    export default defineMarkdocConfig({
-      nodes: {
-        image: {
-          ...nodes.image, // Aplica los valores predeterminados de Markdoc para otras opciones
-          render: component('./src/components/MarkdocImage.astro'),
-        },
-      },
-    });
-    ```
-
-4. La sintaxis de imagen nativa en cualquier archivo `.mdoc` ahora usará el componente `<Image />` para optimizar tus imágenes locales. Las imágenes remotas aún pueden ser usadas, pero no serán renderizadas por el componente `<Image />` de Astro.
-
-    ```md title="src/content/blog/post.mdoc"
-
-    <!-- Optimizado por <Image /> -->
-    ![Una foto de un gato](/cat.jpg)
-
-    <!-- <img> sin optimizar -->
-    ![Una foto de un perro](https://example.com/dog.jpg) 
-    ```
-</Steps>
-
-#### Crear una etiqueta de imagen personalizada de Markdoc
-
-Una etiqueta `image` de Markdoc te permite establecer atributos adicionales en tu imagen que no son posibles con la sintaxis `![]()`. Por ejemplo, las etiquetas de imagen personalizadas te permiten usar el componente `<Image />` de Astro para imágenes remotas que requieren un `width` y `height`.
-
-Los siguientes pasos crearán una etiqueta de imagen personalizada de Markdoc para mostrar un elemento `<figure>` con una leyenda, usando el componente `<Image />` de Astro para optimizar la imagen.
-
-<Steps>
-1. Crea un componente `MarkdocFigure.astro` para recibir las props necesarias y renderizar una imagen con una leyenda:
-
-    ```astro title="src/components/MarkdocFigure.astro"
-    ---
-    // src/components/MarkdocFigure.astro
-    import { Image } from "astro:assets";
-    interface Props {
-      src: ImageMetadata | string;
-      alt: string;
-      width: number;
-      height: number;
-      caption: string;
-    }
-    const { src, alt, width, height, caption } = Astro.props;
-    ---
-    <figure>
-        <Image {src} {alt} {width} {height}  />
-        {caption && <figcaption>{caption}</figcaption>}
-    </figure>
-    ```
-
-2. Configura tu etiqueta de imagen personalizada para renderizar tu componente de Astro:
-
-    ```ts title="markdoc.config.mjs"
-    import { component, defineMarkdocConfig, nodes } from '@astrojs/markdoc/config';
-
-    export default defineMarkdocConfig({
-      tags: {
-        image: {
-          attributes: {
-            width: {
-              type: String,
-            },
-            height: {
-              type: String,
-            },
-            caption: {
-              type: String,
-            },
-            ...nodes.image.attributes
-          },
-          render: component('./src/components/MarkdocFigure.astro'),
-        },
-      },
-    });
-    ```
-
-3. Usa la etiqueta `image` en archivos Markdoc para mostrar una figura con leyenda, proporcionando todos los atributos necesarios para tu componente:
-
-    ```md
-    {% image src="./astro-logo.png" alt="Logo de Astro" width="100" height="100" caption="a caption!" %}
-    ```
-</Steps>
-
-## Configuración avanzada de Markdoc
-
-El archivo `markdoc.config.mjs|ts` acepta [todas las opciones de configuración de Markdoc](https://markdoc.dev/docs/config), incluyendo [etiquetas](https://markdoc.dev/docs/tags) y [funciones](https://markdoc.dev/docs/functions).
-
-Puedes pasar estas opciones desde la exportación predeterminada en tu archivo `markdoc.config.mjs|ts`:
-
-```js title="markdoc.config.mjs"
-import { defineMarkdocConfig } from '@astrojs/markdoc/config';
-
-export default defineMarkdocConfig({
-  functions: {
-    getCountryEmoji: {
-      transform(parameters) {
-        const [country] = Object.values(parameters);
-        const countryToEmojiMap = {
-          japan: '🇯🇵',
-          spain: '🇪🇸',
-          france: '🇫🇷',
-        };
-        return countryToEmojiMap[country] ?? '🏳';
-      },
-    },
-  },
-});
-```
-
-Ahora, puedes llamar a esta función desde cualquier entrada de contenido de Markdoc:
-
-```md
-¡Hola {% getCountryEmoji("spain") %}!
-```
-
-<ReadMore>[Consulta la documentación de Markdoc](https://markdoc.dev/docs/functions#creating-a-custom-function) para más información sobre el uso de variables o funciones en tu contenido.</ReadMore>
-
-### Configura el elemento HTML raíz
-
-Markdoc envuelve los documentos con una etiqueta `<article>` de forma predeterminada. Esto se puede cambiar desde el nodo `document` de Markdoc. Esto acepta un nombre de elemento HTML o `null` si prefieres eliminar el elemento de envoltura:
-
-```js title="markdoc.config.mjs"
-import { defineMarkdocConfig, nodes } from '@astrojs/markdoc/config';
-
-export default defineMarkdocConfig({
-  nodes: {
-    document: {
-      ...nodes.document, // Aplica los valores predeterminados de Markdoc para otras opciones
-      render: null, // por defecto 'article'
-    },
-  },
-});
-```
-
-## Opciones de configuración de integración
-
-La integración de Astro con Markdoc se encarga de configurar opciones y capacidades de Markdoc que no están disponibles a través del archivo `markdoc.config.js`.
-
-### `allowHTML`
-
-Permite escribir marcas HTML junto con etiquetas y nodos de Markdoc.
-Por defecto, Markdoc no reconocerá las marcas HTML como contenido semántico.
-Para lograr una experiencia más similar a Markdown, donde los elementos HTML pueden incluirse junto con tu contenido, establece `allowHTML:true` como opción de integración de `markdoc`. Esto habilitará el análisis de HTML en las marcas de Markdoc.
-
-```js ins="allowHTML: true" title="astro.config.mjs" ins={6}
-  import { defineConfig } from 'astro/config';
-  import markdoc from '@astrojs/markdoc';
-
-  export default defineConfig({
-    // ...
-    integrations: [markdoc({ allowHTML: true })],
-  });
-```
-:::caution
-Cuando `allowHTML` está habilitado, el marcado HTML dentro de los documentos de Markdoc se representará como elementos HTML reales (incluyendo `<script>`), lo que hace posible vectores de ataque como XSS. Asegúrate de que cualquier marcado HTML provenga de fuentes confiables.
-:::
-
-### `ignoreIndentation`
-
-Por defecto, cualquier contenido que esté indentado por cuatro espacios se tratará como un bloque de código. Desafortunadamente, este comportamiento hace que sea difícil usar niveles arbitrarios de indentación para mejorar la legibilidad de los documentos con estructura compleja.
-
-Cuando uses etiquetas anidadas en Markdoc, puede ser útil indentar el contenido dentro de las etiquetas para que el nivel de profundidad sea claro. Para admitir la indentación arbitraria, tenemos que deshabilitar los bloques de código basados en la indentación y modificar varias otras reglas de análisis de markdown-it que tienen en cuenta los bloques de código basados en la indentación. Estos cambios se pueden aplicar habilitando la opción ignoreIndentation.
-
-```js "ignoreIndentation: true" title="astro.config.mjs" ins={6}
-  import { defineConfig } from 'astro/config';
-  import markdoc from '@astrojs/markdoc';
-
-  export default defineConfig({
-    // ...
-    integrations: [markdoc({ ignoreIndentation: true })],
-  });
-```
-
-```md
-# Bienvenido a Markdoc con etiquetas indentadas 👋
-
-# Nota: Puedes usar tanto espacios como tabulaciones para la identación
-
-{% custom-tag %}
-{% custom-tag %} ### Las etiquetas pueden ser indentadas para una mejor legibilidad
-
-    {% another-custom-tag %}
-      Esto es más fácil de seguir cuando hay mucho anidamiento
-    {% /another-custom-tag %}
-
-{% /custom-tag %}
-{% /custom-tag %}
-```
-
-## Ejemplos
-
-* La [plantilla de inicio Astro Markdoc](https://github.com/withastro/astro/tree/latest/examples/with-markdoc) muestra como usar archivos Markdoc en tu proyecto Astro.
-
-[astro-integration]: /es/guides/integrations-guide/
-
-[astro-components]: /es/basics/astro-components/
-
-[astro-content-collections]: /es/guides/content-collections/
-
-[markdoc-tags]: https://markdoc.dev/docs/tags
-
-[markdoc-nodes]: https://markdoc.dev/docs/nodes
-
-[markdoc-variables]: https://markdoc.dev/docs/variables
diff --git a/src/content/docs/es/guides/integrations-guide/mdx.mdx b/src/content/docs/es/guides/integrations-guide/mdx.mdx
deleted file mode 100644
index 9b55caf275d84..0000000000000
--- a/src/content/docs/es/guides/integrations-guide/mdx.mdx
+++ /dev/null
@@ -1,264 +0,0 @@
----
-type: integration
-title: '@astrojs/mdx'
-description: Aprende como usar la integración @astrojs/mdx en tu proyecto de Astro.
-githubIntegrationURL: 'https://github.com/withastro/astro/tree/main/packages/integrations/mdx/'
-category: other
-i18nReady: true
----
-import PackageManagerTabs from '~/components/tabs/PackageManagerTabs.astro'
-import ReadMore from '~/components/ReadMore.astro'
-import Since from '~/components/Since.astro'
-
-Esta **[integración de Astro][astro-integration]** permite el uso de componentes [MDX](https://mdxjs.com/) y te permite crear páginas como archivos `.mdx`.
-
-## ¿Por qué MDX?
-
-MDX te permite [usar variables, expresiones JSX y componentes dentro del contenido Markdown](/es/guides/markdown-content/#características-de-mdx-únicamente) en Astro. Si tienes contenido existente escrito en MDX, esta integración te permite traer esos archivos a tu proyecto de Astro.
-
-## Instalación
-
-Astro incluye un comando `astro add` para automatizar la configuración de las integraciones oficiales. Si lo prefieres, puedes [instalar las integraciones manualmente](#instalación-manual) en su lugar.
-
-Ejecuta uno de los siguientes comandos en una nueva ventana de terminal.
-
-<PackageManagerTabs>
-  <Fragment slot="npm">
-  ```sh
-  npx astro add mdx
-    ```
-  </Fragment>
-  <Fragment slot="pnpm">
-  ```sh
-  pnpm astro add mdx
-  ```
-  </Fragment>
-  <Fragment slot="yarn">
-  ```sh
-  yarn astro add mdx
-  ```
-  </Fragment>
- </PackageManagerTabs>
-
-### Instalación Manual
-
-Primero, instala el paquete `@astrojs/mdx`:
-
-<PackageManagerTabs>
-  <Fragment slot="npm">
-  ```sh
-  npm install @astrojs/mdx
-  ```
-  </Fragment>
-  <Fragment slot="pnpm">
-  ```sh
-  pnpm add @astrojs/mdx
-  ```
-  </Fragment>
-  <Fragment slot="yarn">
-  ```sh
-  yarn add @astrojs/mdx
-  ```
-  </Fragment>
-</PackageManagerTabs>
-
-Luego, aplica esta integración a tu archivo `astro.config.*` usando la propiedad `integrations`:
-
-```js title="astro.config.mjs" ins={2} ins="mdx()"
-import { defineConfig } from 'astro/config';
-import mdx from '@astrojs/mdx';
-
-export default defineConfig({
-  // ...
-  integrations: [mdx()],
-});
-```
-
-### Integración del Editor
-
-Para soporte en [VS Code](https://code.visualstudio.com/), instala la [extensión oficial de MDX](https://marketplace.visualstudio.com/items?itemName=unifiedjs.vscode-mdx).
-
-Para otros editores, usa el [servidor de lenguaje MDX](https://github.com/mdx-js/mdx-analyzer/tree/main/packages/language-server).
-
-## Uso
-
-Con la integración MDX de Astro, puedes [añadir páginas MDX a tu proyecto](/es/guides/markdown-content/#páginas-de-markdown-y-mdx) añadiendo archivos `.mdx` dentro de tu directorio `src/pages/`. También puedes [importar archivos `.mdx`](/es/guides/markdown-content/#importando-markdown) en archivos `.astro`.
-
-La integración MDX de Astro agrega características adicionales a MDX estándar, incluyendo el frontmatter estilo Markdown. Esto te permite utilizar la mayoría de las características de Markdown incorporadas en Astro, como una [propiedad especial de frontmatter `layout`](/es/guides/markdown-content/#layout-en-el-frontmatter).
-
-Consulta cómo funciona MDX en Astro con ejemplos en nuestra [guía de Markdown y MDX](/es/guides/markdown-content/).
-
-Visita la [documentación de MDX](https://mdxjs.com/docs/what-is-mdx/) para aprender sobre el uso de las características estándar de MDX.
-
-## Configuración
-
-Una vez que la integración MDX esté instalada, no es necesario ninguna configuración adicional para utilizar archivos `.mdx` en tu proyecto Astro.
-
-Puedes configurar cómo se renderiza tu MDX con las siguientes opciones:
-
-* [Opciones heredadas de la configuración de Markdown](#opciones-heredadas-de-la-configuración-de-markdown)
-* [`extendMarkdownConfig`](#extendmarkdownconfig)
-* [`recmaPlugins`](#recmaplugins)
-* [`optimize`](#optimize)
-
-### Opciones heredadas de la configuración de Markdown
-
-Todas las opciones de configuración [`markdown`](/es/reference/configuration-reference/#opciones-de-markdown) pueden configurarse por separado en la integración MDX. Esto incluye los plugins remark y rehype, resaltado de sintaxis y más. Las opciones serán por defecto las de tu configuración Markdown ([ver la opción `extendMarkdownConfig`](#extendmarkdownconfig) para modificar esto).
-
-```js title="astro.config.mjs"
-import { defineConfig } from 'astro/config';
-import mdx from '@astrojs/mdx';
-import remarkToc from 'remark-toc';
-import rehypeMinifyHtml from 'rehype-minify-html';
-
-export default defineConfig({
-  // ...
-  integrations: [
-    mdx({
-      syntaxHighlight: 'shiki',
-      shikiConfig: { theme: 'dracula' },
-      remarkPlugins: [remarkToc],
-      rehypePlugins: [rehypeMinifyHtml],
-      remarkRehype: { footnoteLabel: 'Footnotes' },
-      gfm: false,
-    }),
-  ],
-});
-```
-
-:::caution
-MDX no admite pasar plugins de remark y rehype como una cadena. En su lugar, debes instalar, importar y aplicar la función del plugin.
-:::
-
-<ReadMore>Consulta la [referencia de opciones de Markdown](/es/reference/configuration-reference/#opciones-de-markdown) para ver una lista completa de opciones.</ReadMore>
-
-### `extendMarkdownConfig`
-
-* **Tipo:** `boolean`
-* **Por defecto:** `true`
-
-Por defecto, MDX extenderá [la configuración de Markdown existente en tu proyecto](/es/reference/configuration-reference/#opciones-de-markdown). Para anular opciones individuales, puedes especificar su equivalente en la configuración de MDX.
-
-Por ejemplo, digamos que necesitas desactivar el Markdown con formato de GitHub y aplicar un conjunto diferente de plugins de remark para archivos MDX. Puedes aplicar estas opciones de la siguiente manera, con `extendMarkdownConfig` habilitado de forma predeterminada:
-
-```js title="astro.config.mjs"
-import { defineConfig } from 'astro/config';
-import mdx from '@astrojs/mdx';
-
-export default defineConfig({
-  // ...
-  markdown: {
-    syntaxHighlight: 'prism',
-    remarkPlugins: [remarkPlugin1],
-    gfm: true,
-  },
-  integrations: [
-    mdx({
-      // `syntaxHighlight` se hereda de Markdown
-
-      // Markdown `remarkPlugins` ignorados,
-      // Solo se aplicó `remarkPlugin2`.
-      remarkPlugins: [remarkPlugin2],
-      // `gfm` se anuló y se estableció en `false`
-      gfm: false,
-    }),
-  ],
-});
-```
-
-También es posible que necesites deshabilitar la extensión de configuración `markdown` en MDX. Para ello, establece `extendMarkdownConfig` en `false`:
-
-```js title="astro.config.mjs"
-import { defineConfig } from 'astro/config';
-import mdx from '@astrojs/mdx';
-
-export default defineConfig({
-  // ...
-  markdown: {
-    remarkPlugins: [remarkPlugin1],
-  },
-  integrations: [
-    mdx({
-      // La configuración de Markdown ahora se ignora
-      extendMarkdownConfig: false,
-      // No se aplicaron `remarkPlugins`
-    }),
-  ],
-});
-```
-
-### `recmaPlugins`
-
-Estos son plugins que modifican directamente la salida [estree](https://github.com/estree/estree). Esto es útil para modificar o inyectar variables JavaScript en tus archivos MDX.
-
-Sugerimos [utilizar AST Explorer](https://astexplorer.net/) para experimentar con las salidas de estree y probar [`estree-util-visit`](https://unifiedjs.com/explore/package/estree-util-visit/) para buscar entre nodos de JavaScript.
-
-### `optimize`
-
-* **Tipo:** `boolean | { ignoreElementNames?: string[] }`
-
-Esta es una configuración opcional para optimizar la salida de MDX y acelerar las compilaciones y el renderizado mediante un plugin interno de rehype. Esto puede ser útil si tienes muchos archivos MDX y notas que las compilaciones son lentas. Sin embargo, esta opción puede generar HTML no escapado, por lo que asegúrate de que las partes interactivas de tu sitio sigan funcionando correctamente después de habilitarla.
-
-Esto está desactivado de forma predeterminada. Para habilitar la optimización de MDX, agrega lo siguiente a la configuración de integración de MDX:
-
-```js title="astro.config.mjs"
-import { defineConfig } from 'astro/config';
-import mdx from '@astrojs/mdx';
-export default defineConfig({
-  // ...
-  integrations: [
-    mdx({
-      optimize: true,
-    }),
-  ],
-});
-```
-
-#### `ignoreElementNames`
-
-* **Tipo:** `string[]`
-
-<p><Since pkg="@astrojs/mdx" v="3.0.0" /></p>
-Anteriormente conocido como `customComponentNames`.
-
-Una propiedad opcional de `optimize` para prevenir que el optimizador MDX maneje ciertos nombres de elementos, como [componentes personalizados pasados al contenido MDX importado a través de la propiedad components](/es/guides/markdown-content/#configuración-de-markdown-y-mdx)
-
-Deberás excluir estos componentes de la optimización, ya que el optimizador convierte el contenido en una cadena estática de forma anticipada, lo cual romperá los componentes personalizados que necesitan ser renderizados de forma dinámica.
-
-Por ejemplo, la salida de MDX prevista para lo siguiente sería `<Heading>...</Heading>` en lugar de cada `"<h1>...</h1>"`:
-
-```astro
----
-import { Content, components } from '../content.mdx';
-import Heading from '../Heading.astro';
----
-<Content components={{ ...components, h1: Heading }} />
-```
-
-Para configurar la optimización de esto utilizando la propiedad `ignoreElementNames`, especifica un arreglo de nombres de elementos HTML que deben tratarse como componentes personalizados:
-
-```js title="astro.config.mjs"
-import { defineConfig } from 'astro/config';
-import mdx from '@astrojs/mdx';
-export default defineConfig({
-  // ...
-  integrations: [
-    mdx({
-      optimize: {
-        // Evita que el optimizador maneje los elementos `h1`
-        ignoreElementNames: ['h1'],
-      },
-    }),
-  ],
-});
-```
-
-Ten en cuenta que si tu archivo MDX [configura componentes personalizados usando `export const components = { ... }`](/es/guides/markdown-content/#asignando-componentes-personalizados-a-elementos-html), entonces no necesitas configurar esta opción manualmente. El optimizador los detectará automáticamente.
-
-## Ejemplos
-
-* La [plantilla de inicio Astro MDX](https://github.com/withastro/astro/tree/latest/examples/with-mdx) muestra cómo utilizar archivos MDX en tu proyecto Astro.
-
-[astro-integration]: /es/guides/integrations-guide/
-
-[astro-ui-frameworks]: /es/guides/framework-components/#usando-componente-de-framework
diff --git a/src/content/docs/es/guides/integrations-guide/netlify.mdx b/src/content/docs/es/guides/integrations-guide/netlify.mdx
deleted file mode 100644
index e3cf2e71c1932..0000000000000
--- a/src/content/docs/es/guides/integrations-guide/netlify.mdx
+++ /dev/null
@@ -1,254 +0,0 @@
----
-type: integration
-title: '@astrojs/netlify'
-description: Aprende como usar el adaptador SSR @astrojs/netlify para desplegar tu proyecto Astro.
-githubIntegrationURL: 'https://github.com/withastro/adapters/tree/main/packages/netlify/'
-category: adapter
-i18nReady: true
----
-import PackageManagerTabs from '~/components/tabs/PackageManagerTabs.astro'
-
-Este adaptador permite a Astro desplegar tu sitio [renderizado en modo `hybrid` o `server`](/es/guides/on-demand-rendering/) en [Netlify](https://www.netlify.com/).
-
-Aprende como desplegar tu sitio Astro en nuestra [guía de despliegue en Netlify](/es/guides/deploy/netlify/).
-
-## ¿Por qué Astro Netlify?
-
-[Netlify](https://www.netlify.com/) es una plataforma de despliegue que te permite alojar tu sitio conectándolo directamente a tu repositorio de GitHub. Este adaptador mejora el proceso de construcción de Astro para preparar tu proyecto para el despliegue a través de Netlify.
-
-## Instalación
-
-Astro incluye un comando `astro add` para automatizar la configuración de integraciones oficiales. Si lo prefieres, puedes [instalar las integraciones manualmente](#instalación-manual) en su lugar.
-
-Agrega el adaptador de Netlify para habilitar SSR en tu proyecto Astro con el comando `astro add`.
-Esto instalará `@astrojs/netlify` y hará los cambios apropiados en tu archivo `astro.config.mjs` en un solo paso.
-
-<PackageManagerTabs>
-  <Fragment slot="npm">
-  ```sh
-  npx astro add netlify
-  ```
-  </Fragment>
-  <Fragment slot="pnpm">
-  ```sh
-  pnpm astro add netlify
-  ```
-  </Fragment>
-  <Fragment slot="yarn">
-  ```sh
-  yarn astro add netlify
-  ```
-  </Fragment>
-</PackageManagerTabs>
-
-### Instalación manual
-
-Primero, instala el adaptador de Netlify en las dependencias de tu proyecto usando tu gestor de paquetes preferido:
-
-<PackageManagerTabs>
-  <Fragment slot="npm">
-  ```sh
-  npm install @astrojs/netlify
-  ```
-  </Fragment>
-  <Fragment slot="pnpm">
-  ```sh
-  pnpm add @astrojs/netlify
-  ```
-  </Fragment>
-  <Fragment slot="yarn">
-  ```sh
-  yarn add @astrojs/netlify
-  ```
-  </Fragment>
-</PackageManagerTabs>
-
-Luego, agrega el adaptador y tu modo de renderizado [bajo demanda](/es/guides/on-demand-rendering/) deseado a tu archivo `astro.config.*`:
-
-   ```js title="astro.config.mjs" ins={2, 6-7}
-    import { defineConfig } from 'astro/config';
-    import netlify from '@astrojs/netlify';
-
-    export default defineConfig({
-       // ...
-       output: 'server',
-       adapter: netlify(),
-    });
-   ```
-
-## Uso
-
-[Lee la guía completa de despliegue aquí.](/es/guides/deploy/netlify/)
-
-Sigue las instrucciones para [construir tu sitio localmente](/es/guides/deploy/#construyendo-tu-proyecto-localmente). Después de construir, tendrás una carpeta `.netlify/` que contiene tanto [Funciones Netlify](https://docs.netlify.com/functions/overview/) en la carpeta `.netlify/functions-internal/` como [Funciones Netlify Edge](https://docs.netlify.com/edge-functions/overview/) en la carpeta `.netlify/edge-functions/`.
-
-Para desplegar tu sitio, instala la [CLI de Netlify](https://docs.netlify.com/cli/get-started/) y ejecuta:
-
-```sh
-netlify deploy
-```
-
-El [artículo del blog de Netlify sobre Astro](https://www.netlify.com/blog/how-to-deploy-astro/) y la [documentación de Netlify](https://docs.netlify.com/integrations/frameworks/astro/) proporcionan más información sobre cómo usar esta integración para desplegar en Netlify.
-
-### Acceder al contexto edge desde tu sitio
-
-Las Funciones Edge de Netlify proporcionan un [objeto de contexto](https://docs.netlify.com/edge-functions/api/#netlify-specific-context-object) que incluye metadatos sobre la solicitud, como la IP de un usuario, datos de geolocalización y cookies.
-
-Se puede acceder a través del objeto `Astro.locals.netlify.context`:
-
-```astro
----
-const {
-  geo: { city },
-} = Astro.locals.netlify.context;
----
-
-<h1>Hola, amable visitante de {city}!</h1>
-```
-
-Si estás usando TypeScript, puedes obtener tipos adecuados actualizando `src/env.d.ts` para usar `NetlifyLocals`:
-
-```ts title="src/env.d.ts"
-/// <reference path="../.astro/types.d.ts" />
-/// <reference types="astro/client" />
-
-type NetlifyLocals = import('@astrojs/netlify').NetlifyLocals
-
-declare namespace App {
-  interface Locals extends NetlifyLocals {
-    // ...
-  }
-}
-```
-
-Esto no está disponible en las páginas prerenderizadas.
-
-### Ejecutar el middleware de Astro con Funciones Edge de Netlify
-
-Cualquier middleware de Astro se aplica a las páginas prerenderizadas en tiempo de construcción y a las páginas renderizadas bajo demanda en tiempo de ejecución. Si estás usando el adaptador de Netlify Edge, puedes ejecutar el middleware de Astro en las Funciones Edge de Netlify para que se aplique a las páginas prerenderizadas y renderizadas bajo demanda.
-
-Para implementar redirecciones, control de acceso o encabezados de respuesta personalizados para las páginas prerenderizadas, ejecuta tu middleware en las Funciones Edge de Netlify habilitando [la opción `edgeMiddleware`](/es/reference/adapter-reference/#edgemiddleware):
-
-```js title="astro.config.mjs" ins={8}
-import { defineConfig } from 'astro/config';
-import netlify from '@astrojs/netlify';
-
-export default defineConfig({
-  // ...
-  output: 'server',
-  adapter: netlify({
-   edgeMiddleware: true,
-  }),
-});
-```
-
-Cuando `edgeMiddleware` está habilitado, una función edge ejecutará tu código de middleware para todas las solicitudes, incluyendo activos estáticos, páginas prerenderizadas y páginas renderizadas bajo demanda.
-
-Para las páginas renderizadas bajo demanda, el objeto `context.locals` se serializa usando JSON y se envía en un encabezado para la función sin servidor, que realiza la renderización. Como medida de seguridad, la función sin servidor se negará a servir solicitudes con una respuesta `403 Forbidden` a menos que provengan de la función edge generada.
-
-### Soporte para Netlify Image CDN
-
-Este adaptador por defecto utiliza el [CDN de imágenes de Netlify](https://docs.netlify.com/image-cdn/) para transformar imágenes sobre la marcha sin afectar a los tiempos de construcción.
-Es implementado usando un [Servicio de Imágenes Astro](/es/reference/image-service-reference/) bajo el capó.
-
-Para optar por no utilizar la optimización de imágenes remotas de Netlify, usa la opción `imageCDN`:
-
-```js title="astro.config.mjs" ins={8}
-import { defineConfig } from 'astro/config';
-import netlify from '@astrojs/netlify';
-
-export default defineConfig({
-  // ...
-  output: 'server',
-  adapter: netlify({
-    imageCDN: false,
-  }),
-});
-```
-
-
-Si estás usando imagenes alojadas en otro dominio, debes autorizar los patrones de dominio o URL usando las opciones de configuración [`image.domains`](/es/reference/configuration-reference/#imagedomains) o [`image.remotePatterns`](/es/reference/configuration-reference/#imageremotepatterns):
-
-```js title="astro.config.mjs" ins={8-10}
-import { defineConfig } from 'astro/config';
-import netlify from '@astrojs/netlify';
-
-export default defineConfig({
-    // ...
-    output: 'server',
-    adapter: netlify(),
-    image: {
-      domains: ['example.com'],
-    },
-});
-```
-
-Para más información, consulta [la guía para autorizar imagenes remotas](/es/guides/images/#autorizando-imágenes-remotas). Esto no es requerido para imagenes alojadas en el mismo dominio que tu sitio.
-
-### Sitios estáticos con el adaptador de Netlify
-
-Para sitios estáticos (`output: 'static'`) alojados en Netlify, normalmente no se necesita un adaptador. Sin embargo, algunas características de despliegue solo están disponibles a través de un adaptador.
-
-Los sitios estáticos necesitarán instalar este adaptador para utilizar y configurar el [servicio de imágenes](#soporte-para-netlify-image-cdn) de Netlify.
-
-Si utilizas la configuración de `redirects` en tu archivo de configuración de Astro, puedes utilizar el adaptador de Netlify para traducirlo al formato adecuado de `_redirects`.
-
-```js title="astro.config.mjs"
-import { defineConfig } from 'astro/config';
-import netlify from '@astrojs/netlify/static';
-export default defineConfig({
-  // ...
-  adapter: netlify(),
-  redirects: {
-    '/blog/old-post': '/blog/new-post',
-  },
-});
-```
-
-Una vez que ejecutes `astro build`, se generará un archivo `dist/_redirects`. Netlify utilizará ese archivo para enrutamiento adecuado de las páginas en producción.
-
-:::note
-Todavía puedes incluir un archivo `public/_redirects` para redirecciones manuales. Cualquier redirección que especifiques en la configuración de redirecciones se añadirá al final de las redirecciones que hayas definido tú mismo.
-:::
-
-### Caché de páginas
-
-Las páginas renderizadas bajo demanda sin ningún contenido dinámico pueden ser almacenadas en caché para mejorar el rendimiento y reducir el uso de recursos.
-Habilitar la opción `cacheOnDemandPages` en el adaptador almacenará en caché todas las páginas renderizadas bajo demanda durante un año:
-
-```ts title="astro.config.mjs"
-export default defineConfig({
-  // ...
-  output: 'server',
-  adapter: netlify({
-    cacheOnDemandPages: true,
-  }),
-});
-```
-
-Esto se puede cambiar en cada página agregando encabezados de caché a tu respuesta:
-
-```astro title="pages/index.astro"
----
-import Layout from '../components/Layout.astro';
-
-Astro.response.headers.set('CDN-Cache-Control', 'public, max-age=45, must-revalidate');
----
-
-<Layout title="Astro on Netlify">
-  {new Date()}
-</Layout>
-```
-
-Con [control de caché de granularidad fina](https://www.netlify.com/blog/swr-and-fine-grained-cache-control/), Netlify soporta
-encabdezados de caché estándar como `CDN-Cache-Control` o `Vary`.
-
-Refiérete a la documentación para aprender a implementar, por ejemplo, el tiempo de vida (TTL) o el almacenamiento en caché obsoleto mientras se vuelve a validar (SWR): https://docs.netlify.com/platform/caching
-
-## Ejemplos
-
-* La [plantilla de inicio de Astro Netlify Edge](https://github.com/sarahetter/astro-netlify-edge-starter) proporciona un ejemplo y una guía en el archivo README.
-
-* ¡[Explora proyectos de Astro Netlify en GitHub](https://github.com/search?q=path%3A**%2Fastro.config.mjs+%40astrojs%2Fnetlify\&type=code) para más ejemplos!
-
-[astro-integration]: /es/guides/integrations-guide/
diff --git a/src/content/docs/es/guides/integrations-guide/node.mdx b/src/content/docs/es/guides/integrations-guide/node.mdx
deleted file mode 100644
index 32ed0d693bb28..0000000000000
--- a/src/content/docs/es/guides/integrations-guide/node.mdx
+++ /dev/null
@@ -1,224 +0,0 @@
----
-type: integration
-title: '@astrojs/node'
-description: Aprende como usar el adaptador SSR @astrojs/node para desplegar tu proyecto de Astro.
-githubIntegrationURL: 'https://github.com/withastro/astro/tree/main/packages/integrations/node/'
-category: adapter
-i18nReady: true
----
-
-import PackageManagerTabs from '~/components/tabs/PackageManagerTabs.astro'
-
-## Astro Node
-
-Este adaptador permite a Astro desplegar tu [sitio renderizado en modo `hybrid` o `server`](/es/guides/on-demand-rendering/) a objetivos de Node.
-
-Si estás usando Astro como un constructor de sitios estáticos, no necesitas un adaptador.
-
-Si deseas [usar renderizado del lado del servidor (SSR)](/es/guides/on-demand-rendering/), Astro requiere un adaptador que coincida con tu tiempo de ejecución de implementación.
-
-## Por qué Node.js
-
-[Node.js](https://nodejs.org/en/) es un tiempo de ejecución de JavaScript para código del lado del servidor. @astrojs/node puede ser usado en modo independiente o como middleware para otros servidores http, como [Express](https://expressjs.com/).
-
-## Instalación
-
-Astro incluye un comando `astro add` para automatizar la configuración de las integraciones oficiales. Si lo prefieres, puedes [instalar las integraciones manualmente](#instalación-manual) en su lugar.
-
-Agrega el adaptador de Node para habilitar SSR en tu proyecto Astro con el comando `astro add`.
-Esto instalará `@astrojs/node` y hará los cambios apropiados en tu archivo `astro.config.*` en un solo paso.
-
-<PackageManagerTabs>
-  <Fragment slot="npm">
-  ```sh
-  npx astro add node
-  ```
-  </Fragment>
-  <Fragment slot="pnpm">
-  ```sh
-  pnpm astro add node
-  ```
-  </Fragment>
-  <Fragment slot="yarn">
-  ```sh
-  yarn astro add node
-  ```
-  </Fragment>
-</PackageManagerTabs>
-
-### Instalación manual
-
-El adaptador de Node a las dependencias de tu proyecto usando tu gestor de paquetes preferido.
-Primero, agrega el adaptador de Node a las dependencias de tu proyecto usando tu gestor de paquetes preferido.
-
-<PackageManagerTabs>
-  <Fragment slot="npm">
-  ```sh
-  npm install @astrojs/node
-  ```
-  </Fragment>
-  <Fragment slot="pnpm">
-  ```sh
-  pnpm add @astrojs/node
-  ```
-  </Fragment>
-  <Fragment slot="yarn">
-  ```sh
-  yarn add @astrojs/node
-  ```
-  </Fragment>
-</PackageManagerTabs>
-
-Luego, agrega el adaptador y tu [modo de renderizado bajo de manda](/es/guides/on-demand-rendering/) deseado a tu archivo `astro.config.*`:
-
-```js title="astro.config.mjs" ins={2,5-8}
-import { defineConfig } from 'astro/config';
-import node from '@astrojs/node';
-
-export default defineConfig({
-  output: 'server',
-  adapter: node({
-    mode: 'standalone',
-  }),
-});
-```
-
-## Configuración
-
-@astrojs/node puede ser configurado pasando opciones al adaptador. Las siguientes opciones están disponibles:
-
-### Modo
-
-Controla si el adaptador construye en modo `middleware` o `standalone`.
-
-* El modo `middleware` permite que la salida generada se utilice como middleware para otro servidor de Node.js, como Express.js o Fastify.
-
-  ```js title="astro.config.mjs"
-  import { defineConfig } from 'astro/config';
-  import node from '@astrojs/node';
-
-  export default defineConfig({
-    output: 'server',
-    adapter: node({
-      mode: 'middleware',
-    }),
-  });
-  ```
-
-* El modo `standalone` permite construir un servidor se que inicia automáticamente cuando el módulo de entrada se ejecuta. Esto te permite desplegar tu construcción a un host sin ningún código adicional.
-
-## Uso
-
-Primero, [realiza una construcción](/es/guides/deploy/#construyendo-tu-proyecto-localmente). Dependiendo del `mode` seleccionado (ver arriba) sigue los pasos apropiados a continuación:
-
-### Middleware
-
-La entrada del servidor se construye a `./dist/server/entry.mjs` de forma predeterminada. Este módulo exporta una función `handler` que puede ser usada con cualquier framework que soporte los objetos `request` y `response` de Node.
-
-Por ejemplo, con Express:
-
-```js title="run-server.mjs"
-import express from 'express';
-import { handler as ssrHandler } from './dist/server/entry.mjs';
-
-const app = express();
-// Modifica esto en función de la opción `base` de tu archivo astro.config.mjs.
-// Deben coincidir. El valor predeterminado es "/".
-const base = '/'
-app.use(base, express.static('dist/client/'));
-app.use(ssrHandler);
-
-app.listen(8080);
-```
-
-O, con Fastify (>4):
-
-```js title="run-server.mjs"
-import Fastify from 'fastify';
-import fastifyMiddie from '@fastify/middie';
-import fastifyStatic from '@fastify/static';
-import { fileURLToPath } from 'node:url';
-import { handler as ssrHandler } from './dist/server/entry.mjs';
-
-const app = Fastify({ logger: true });
-
-await app
-  .register(fastifyStatic, {
-    root: fileURLToPath(new URL('./dist/client', import.meta.url)),
-  })
-  .register(fastifyMiddie);
-app.use(ssrHandler);
-
-app.listen({ port: 8080 });
-```
-
-Además, también puedes pasar un objeto para acceder a través de `Astro.locals` o en el middleware de Astro:
-
-```js title="run-server.mjs"
-import express from 'express';
-import { handler as ssrHandler } from './dist/server/entry.mjs';
-
-const app = express();
-app.use(express.static('dist/client/'));
-app.use((req, res, next) => {
-  const locals = {
-    title: 'Nuevo título',
-  };
-
-  ssrHandler(req, res, next, locals);
-});
-
-app.listen(8080);
-```
-
-Ten en cuenta que el modo middleware no sirve de archivos. Necesitarás configurar tu framework HTTP para que lo haga por ti. De forma predeterminada, los activos del cliente se escriben en `./dist/client/`.
-
-### Standalone
-
-En el modo standalone, un servidor se inicia cuando el punto de entrada del servidor se ejecuta. De forma predeterminada se construye a `./dist/server/entry.mjs`. Puedes ejecutarlo con:
-
-```sh
-node ./dist/server/entry.mjs
-```
-
-Para el modo standalone, el servidor se encarga de servir archivos además de las rutas de página y API.
-
-#### Host y puerto personalizados
-
-Puedes anular el host y el puerto en los que se ejecuta el servidor independiente pasándolos como variables de entorno en tiempo de ejecución:
-
-```sh
-HOST=0.0.0.0 PORT=4321 node ./dist/server/entry.mjs
-```
-
-#### HTTPS
-
-Por defecto el servidor standalone usa HTTP. Esto funciona bien si tienes un servidor proxy delante de él que hace HTTPS. Si necesitas que el servidor standalone ejecute HTTPS por sí mismo, necesitas proveer tu llave SSL y certificado.
-
-Puedes pasar la ruta a tu llave y certificado a través de las variables de entorno `SERVER_CERT_PATH` y `SERVER_KEY_PATH`. Así es como podrías pasarlas en bash:
-
-```bash
-SERVER_KEY_PATH=./private/key.pem SERVER_CERT_PATH=./private/cert.pem node ./dist/server/entry.mjs
-```
-
-#### Variables de entorno en tiempo de ejecución
-
-Si existe un archivo `.env` que contiene variables de entorno está presente cuando se ejecuta el proceso de construcción, estos valores se codificarán en la salida, al igual que al generar un sitio web estático.
-
-Durante la compilación, las variables de tiempo de ejecución deben estar ausentes del archivo `.env`, y debes proporcionar a Astro todas las variables de entorno que esperas en tiempo de ejecución: `VARIABLE_1=placeholder astro build`. Esto le indica a Astro que el valor real estará disponible cuando se ejecute la aplicación construida. El valor de marcador de posición será ignorado por el proceso de construcción, y Astro usará el valor proporcionado en tiempo de ejecución.
-
-En este caso de múltiples variables de tiempo de ejecución, almacénalas en un archivo separado (por ejemplo, `.env.runtime`) de `.env`. Inicia la construcción con el siguiente comando:
-
-```sh
-export $(cat .env.runtime) && astro build
-```
-
-#### Assets
-
-En modo autónomo, los activos de tu carpeta `dist/client/` se sirven a través del servidor autónomo. Es posible que despliegues estos activos en una CDN, en cuyo caso el servidor nunca los servirá realmente. Pero en algunos casos, como los sitios de intranet, está bien servir activos estáticos directamente desde el servidor de aplicaciones.
-
-Los assets en la carpeta `dist/client/_astro/` son los que Astro ha construido. Todos estos assets se nombran con un hash y, por lo tanto, se les pueden asignar cabeceras de caché largas. Internamente el adaptador añade esta cabecera para estos assets:
-
-```
-Cache-Control: public, max-age=31536000, immutable
-```
diff --git a/src/content/docs/es/guides/integrations-guide/partytown.mdx b/src/content/docs/es/guides/integrations-guide/partytown.mdx
deleted file mode 100644
index 5eb8b5fa5bf30..0000000000000
--- a/src/content/docs/es/guides/integrations-guide/partytown.mdx
+++ /dev/null
@@ -1,156 +0,0 @@
----
-type: integration
-title: '@astrojs/partytown'
-description: Aprende cómo utilizar la integración @astrojs/partytown en tu proyecto de Astro.
-githubIntegrationURL: 'https://github.com/withastro/astro/tree/main/packages/integrations/partytown/'
-category: other
-i18nReady: true
----
-import PackageManagerTabs from '~/components/tabs/PackageManagerTabs.astro';
-
-Esta **[integración de Astro][astro-integration]** permite [Partytown](https://partytown.builder.io/) en tu proyecto de Astro.
-
-## ¿Por qué Partytown?
-
-Partytown es una biblioteca cargada de forma diferida para ayudar a trasladar scripts intensivos en recursos a un [web worker](https://developer.mozilla.org/en-US/docs/Web/API/Web_Workers_API), y fuera del [hilo principal](https://developer.mozilla.org/en-US/docs/Glossary/Main_thread).
-
-Si estás utilizando scripts de terceros para cosas como análisis o anuncios, Partytown es una excelente manera de asegurarte de que no ralenticen tu sitio.
-
-La integración de Astro Partytown instala Partytown por ti y se asegura de que esté habilitado en todas tus páginas.
-
-## Instalación
-
-### Instalación rápida
-
-Astro incluye un comando `astro add` para automatizar la configuración de las integraciones oficiales. Si lo prefieres, puedes [instalar las integraciones manualmente](#instalación-manual) en su lugar.
-
-Ejecuta uno de los siguientes comandos en una nueva ventana terminal.
-
-<PackageManagerTabs>
-  <Fragment slot="npm">
-  ```sh
-  npx astro add partytown
-  ```
-  </Fragment>
-  <Fragment slot="pnpm">
-  ```sh
-  pnpm astro add partytown
-  ```
-  </Fragment>
-  <Fragment slot="yarn">
-  ```sh
-  yarn astro add partytown
-  ```
-  </Fragment>
-</PackageManagerTabs>
-
-Si tienes algún problema, [no dudes en informarnos en GitHub](https://github.com/withastro/astro/issues) y prueba los pasos de instalación manual a continuación.
-
-### Instalación manual
-
-Primero, instala el paquete `@astrojs/partytown`:
-
-<PackageManagerTabs>
-  <Fragment slot="npm">
-  ```sh
-  npm install @astrojs/partytown
-  ```
-  </Fragment>
-  <Fragment slot="pnpm">
-  ```sh
-  pnpm add @astrojs/partytown
-  ```
-  </Fragment>
-  <Fragment slot="yarn">
-  ```sh
-  yarn add @astrojs/partytown
-  ```
-  </Fragment>
-</PackageManagerTabs>
-
-Luego, aplica esta integración a tu archivo `astro.config.*` usando la propiedad `integrations`:
-
-```js title="astro.config.mjs" ins={2} ins="partytown()"
-import { defineConfig } from 'astro/config';
-import partytown from '@astrojs/partytown';
-
-export default defineConfig({
-  // ...
-  integrations: [partytown()],
-});
-```
-
-## Uso
-
-Partytown debería estar listo para funcionar sin configuración alguna. Si tienes un script de terceros existente en tu sitio, intenta agregar el atributo `type="text/partytown"`:
-
-```html ins="type="text/partytown""
-<script type="text/partytown" src="fancy-analytics.js"></script>
-```
-
-Si abres la pestaña "Red" de las [herramientas de desarrollador](https://developer.chrome.com/docs/devtools/open/), de tu navegador, deberías ver el proxy `partytown` interceptando esta solicitud.
-
-## Configuración
-
-Para configurar esta integración, pase un objeto 'config' a la llamada de función `partytown()` en `astro.config.mjs`.
-
-```js title="astro.config.mjs" {5-7}
-export default defineConfig({
-  // ..
-  integrations: [
-    partytown({
-      config: {
-        // opciones van aquí
-      },
-    }),
-  ],
-});
-```
-
-Esto refleja [el objeto de configuración de Partytown](https://partytown.builder.io/configuration).
-
-### config.debug
-
-Partytown viene con un modo de `debug`; actívalo o desactívalo pasando `true` o `false` a `config.debug`. Si se habilita el [modo de `debug`](https://partytown.builder.io/debugging) se imprimirán registros detallados en la consola del navegador.
-
-Si esta opción no se establece, el modo `debug` estará activado de forma predeterminada en el modo [dev](/es/reference/cli-reference/#astro-dev) o [preview](/es/reference/cli-reference/#astro-preview).
-
-```js title="astro.config.mjs" {6}
-export default defineConfig({
-  // ...
-  integrations: [
-    partytown({
-      // Example: Disable debug mode.
-      config: { debug: false },
-    }),
-  ],
-});
-```
-
-### config.forward
-
-Los scripts de terceros suelen agregar variables al objeto `window` para que puedas comunicarte con ellos en todo tu sitio. Pero cuando un script se carga en un web worker no tiene acceso a ese objeto `window` global.
-
-Para solucionar esto, Partytown puede "parchar" las variables al objeto global de ventana y reenviarlos al script correspondiente.
-
-Puedes especificar qué variables enviar hacia adelante con la opción `config.forward`. [Lee más en la documentación de Partytown.](https://partytown.builder.io/forwarding-events)
-
-```js title="astro.config.mjs" {7}
-export default defineConfig ({
-  // ...
-  integrations: [
-    partytown({
-      // Ejemplo: Agregar dataLayer.push como un evento de reenvío.
-      config: { 
-        forward: ["dataLayer.push"],
-      },
-    }),
-  ],
-});
-```
-
-## Ejemplos
-
-* ¡[Explora proyectos con Astro Partytown en GitHub](https://github.com/search?q=%22%40astrojs%2Fpartytown%22+path%3A**%2Fpackage.json\&type=code) para ver más ejemplos!
-
-[astro-integration]: /es/guides/integrations-guide/
diff --git a/src/content/docs/es/guides/integrations-guide/preact.mdx b/src/content/docs/es/guides/integrations-guide/preact.mdx
deleted file mode 100644
index 4aed4274bb14d..0000000000000
--- a/src/content/docs/es/guides/integrations-guide/preact.mdx
+++ /dev/null
@@ -1,227 +0,0 @@
----
-type: integration
-title: '@astrojs/preact'
-description: Aprende como usar la integración @astrojs/preact para ampliar la compatibilidad de Alpinejs en tu proyecto de Astro.
-githubIntegrationURL: 'https://github.com/withastro/astro/tree/main/packages/integrations/preact/'
-category: renderer
-i18nReady: true
----
-
-import PackageManagerTabs from '~/components/tabs/PackageManagerTabs.astro'
-import Since from '~/components/Since.astro';
-
-Esta **[integración de Astro][astro-integration]** habilita el renderizado del lado del servidor y la hidratación del lado del cliente para tus componentes de [Preact](https://preactjs.com/).
-
-## ¿Por qué Preact?
-
-Preact es una biblioteca que te permite construir componentes UI interactivos para la web. Si deseas crear características interactivas en tu sitio web utilizando JavaScript, es posible que prefieras usar su formato de componentes en lugar de usar directamente las API del navegador.
-
-Preact también es una gran opción si has utilizado anteriormente React. Preact proporciona la misma API que React, pero en un paquete mucho más pequeño de 3kB. Incluso admite la representación de muchos componentes de React mediante la opción de configuración `compat` (consulta a continuación).
-
-**¿Quieres aprender más sobre Preact antes de usar esta integración?**\
-Revisa [“Aprende Preact”](https://preactjs.com/tutorial), un tutorial interactivo en su sitio web.
-
-## Instalación
-
-Astro incluye un comando `astro add` para automatizar la configuración de las integraciones oficiales. Si lo prefieres, puedes [instalar las integraciones manualmente](#instalación-manual) en su lugar.
-
-Para instalar `@astrojs/preact`, ejecuta lo siguiente desde el directorio de tu proyecto y sigue las indicaciones:
-
-<PackageManagerTabs>
-  <Fragment slot="npm">
-  ```sh
-  npx astro add preact
-  ```
-  </Fragment>
-  <Fragment slot="pnpm">
-  ```sh
-  pnpm astro add preact
-  ```
-  </Fragment>
-  <Fragment slot="yarn">
-  ```sh
-  yarn astro add preact
-  ```
-  </Fragment>
-</PackageManagerTabs>
-
-Si tienes algún problema, [no dudes en informarnos en GitHub](https://github.com/withastro/astro/issues) y prueba los pasos de instalación manual a continuación.
-
-### Instalación manual
-
-Primero, instala el paquete `@astrojs/preact`:
-
-<PackageManagerTabs>
-  <Fragment slot="npm">
-  ```sh
-  npm install @astrojs/preact
-  ```
-  </Fragment>
-  <Fragment slot="pnpm">
-  ```sh
-  pnpm add @astrojs/preact
-  ```
-  </Fragment>
-  <Fragment slot="yarn">
-  ```sh
-  yarn add @astrojs/preact
-  ```
-  </Fragment>
-</PackageManagerTabs>
-
-La mayoría de los gestores de paquetes instalarán las dependencias asociadas también. Si ves un mensaje de advertencia "Cannot find package 'preact'" (o similar) cuando inicias Astro, deberás instalar Preact:
-
-<PackageManagerTabs>
-  <Fragment slot="npm">
-  ```sh
-  npm install preact
-  ```
-  </Fragment>
-  <Fragment slot="pnpm">
-  ```sh
-  pnpm add preact
-  ```
-  </Fragment>
-  <Fragment slot="yarn">
-  ```sh
-  yarn add preact
-  ```
-  </Fragment>
-</PackageManagerTabs>
-
-Luego, aplica la integración a tu archivo `astro.config.*` utilizando la propiedad `integrations`:
-
-```js title="astro.config.mjs" ins={2} ins="preact()"
-import { defineConfig } from 'astro/config';
-import preact from '@astrojs/preact';
-
-export default defineConfig({
-  // ...
-  integrations: [preact()],
-});
-```
-
-Y añade el siguiente código al archivo `tsconfig.json`.
-
-```json title="tsconfig.json" ins={5-8}
-{
-  "extends": "astro/tsconfigs/strict",
-  "include": [".astro/types.d.ts", "**/*"],
-  "exclude": ["dist"],
-  "compilerOptions": {
-    "jsx": "react-jsx",
-    "jsxImportSource": "preact"
-  }
-}
-```
-
-## Uso
-
-Para usar tu primer componente de Preact en Astro, dirígete a nuestra [documentación de frameworks UI][astro-ui-frameworks]. Allí explorarás:
-
-* 📦 cómo se cargan los componentes del framework,
-* 💧 opciones de hidratación en el lado del cliente, y
-* 🤝 oportunidades para mezclar y anidar diferentes frameworks juntos.
-
-También puedes revisar nuestra [Documentación de Integración de Astro][astro-integration] para obtener más información sobre las integraciones.
-
-## Configuración
-
-La integración de Astro con Preact se encarga de cómo se renderizan los componentes de Preact y tiene sus propias opciones. Puedes cambiar estas opciones en el archivo `astro.config.mjs` donde se encuentran las configuraciones de integración de tu proyecto.
-
-Para el uso básico, no es necesario configurar la integración de Preact en Astro.
-
-### compat
-
-Puedes habilitar `preact/compat`, la capa de compatibilidad de Preact para renderizar componentes de React sin necesidad de instalar o enviar las bibliotecas más grandes de React a los navegadores web de tus usuarios.
-
-Para hacerlo, pasa un objeto a la integración de Preact y establece `compat: true`.
-
-```js title="astro.config.mjs" "compat: true"
-import { defineConfig } from 'astro/config';
-import preact from '@astrojs/preact';
-
-export default defineConfig({
-  integrations: [preact({ compat: true })],
-});
-```
-
-Con la opción `compat` habilitada, la integración de Preact renderizará tanto los componentes de React como los componentes de Preact en tu proyecto y también te permitirá importar componentes de React dentro de componentes de Preact. Lee más en [“Cambiando a Preact (de React)”](https://preactjs.com/guide/v10/switching-to-preact) en el sitio web de Preact.
-
-Cuando se importan librerías de componentes de React, para reemplazar las dependencias `react` y `react-dom` como `preact/compat`, puedes utilizar [`overrides`](https://docs.npmjs.com/cli/v8/configuring-npm/package-json#overrides) para hacerlo.
-
-```json
-// package.json
-{
-  "overrides": {
-    "react": "npm:@preact/compat@latest",
-    "react-dom": "npm:@preact/compat@latest"
-  }
-}
-```
-
-Consulta las documentaciónes de [`pnpm` overrides](https://pnpm.io/package_json#pnpmoverrides) y [`yarn` resolutions](https://yarnpkg.com/configuration/manifest#resolutions) para conocer sus respectivas características de anulación de dependencias.
-
-:::note
-Actualmente, la opción `compat` solo funciona para las bibliotecas de React que exportan código como ESM. Si ocurre un error durante la compilación, intenta agregar la biblioteca a `vite.ssr.noExternal: ['the-react-library']` en tu archivo `astro.config.mjs`.
-:::
-
-### devtools
-
-<p><Since pkg="@astrojs/preact" v="3.3.0" /></p>
-
-Puedes habilitar las [herramientas de desarrollo de Preact](https://preactjs.github.io/preact-devtools/) en desarrollo pasando un objeto con `devtools: true` a la configuración de tu integración `preact()`:
-
-```js title="astro.config.mjs"
-import { defineConfig } from 'astro/config';
-import preact from '@astrojs/preact';
-
-export default defineConfig({
-  // ...
-  integrations: [preact({ devtools: true })],
-});
-```
-
-## Opciones
-
-### Combinando múltiples frameworks JSX
-
-Cuando estás utilizando múltiples frameworks JSX (React, Preact, Solid) en el mismo proyecto, Astro necesita determinar qué transformaciones específicas del framework JSX deben usarse para cada uno de tus componentes. Si solo has agregado una integración de framework JSX a tu proyecto, no se necesita configuración adicional.
-
-Utiliza las opciones de configuración `include` (obligatoria) y `exclude` (opcional) para especificar qué archivos pertenecen a qué framework. Proporciona un array de archivos y/o carpetas en `include` para cada framework que estés utilizando. Puedes utilizar comodines para incluir múltiples rutas de archivo.
-
-Recomendamos colocar los componentes comunes de los frameworks en la misma carpeta (p. ej. `/components/react/` y `/components/solid/`) para facilitar la especificación de tus inclusiones, pero esto no es obligatorio:
-
-```js title="astro.config.mjs"
-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({
-  // Habilita varios frameworks para admitir todo tipo de componentes diferentes.
-  // ¡No se necesita `include` si solo estás utilizando un solo framework JSX!
-  integrations: [
-    preact({
-      include: ['**/preact/*'],
-    }),
-    react({
-      include: ['**/react/*'],
-    }),
-    solid({
-      include: ['**/solid/*'],
-    }),
-  ],
-});
-```
-
-## Ejemplos
-
-* El [ejemplo Astro Preact](https://github.com/withastro/astro/tree/latest/examples/framework-preact) muestra cómo utilizar un componente interactivo de Preact en un proyecto de Astro.
-* El [ejemplo de Astro Nanostores](https://github.com/withastro/astro/tree/latest/examples/with-nanostores) muestra cómo compartir el estado entre diferentes componentes, e incluso diferentes frameworks, en un proyecto de Astro.
-
-[astro-integration]: /es/guides/integrations-guide/
-
-[astro-ui-frameworks]: /es/guides/framework-components/#usando-componente-de-framework
diff --git a/src/content/docs/es/guides/integrations-guide/prefetch.mdx b/src/content/docs/es/guides/integrations-guide/prefetch.mdx
deleted file mode 100644
index db5f32bd287f1..0000000000000
--- a/src/content/docs/es/guides/integrations-guide/prefetch.mdx
+++ /dev/null
@@ -1,11 +0,0 @@
----
-title: '@astrojs/prefetch'
-description: La integración de prefetch obsoleta.
-i18nReady: true
----
-
-:::caution[Eliminado]
-`@astrojs/prefetch` ha sido reemplazado por la [característica integrada `prefetch`](/es/guides/prefetch/) introducido en Astro 3.5. Consulta la [guía de migración](/es/guides/prefetch/#migrando-desde-astrojsprefetch) para obtener instrucciones sobre cómo actualizar un proyecto antiguo.
-
-Si aún estás utilizando esta integración en un proyecto de astro anterior a la v3.5, puedes leer una copia archivada del [README de `@astrojs/prefetch`](https://github.com/withastro/astro/blob/c47478bbf6b21973419f25234c68efb59466b368/packages%2Fintegrations%2Fprefetch%2FREADME.md) en GitHub.
-:::
\ No newline at end of file
diff --git a/src/content/docs/es/guides/integrations-guide/react.mdx b/src/content/docs/es/guides/integrations-guide/react.mdx
deleted file mode 100644
index 183f88a4b6003..0000000000000
--- a/src/content/docs/es/guides/integrations-guide/react.mdx
+++ /dev/null
@@ -1,207 +0,0 @@
----
-type: integration
-title: '@astrojs/react'
-description: Aprende cómo utilizar la integración del framework @astrojs/react para ampliar el soporte de componentes en tu proyecto Astro.
-githubIntegrationURL: 'https://github.com/withastro/astro/tree/main/packages/integrations/react/'
-category: renderer
-i18nReady: true
----
-import PackageManagerTabs from '~/components/tabs/PackageManagerTabs.astro'
-
-Esta **[integración de Astro][astro-integration]** habilita el renderizado del lado del servidor y la hidratación del lado del cliente para tus componentes [React](https://react.dev/).
-
-## Instalación
-
-Astro incluye un comando `astro add` para automatizar la configuración de las integraciones oficiales. Si lo prefieres, puedes [instalar las integraciones manualmente](#instalación-manual) en su lugar.
-
-Para instalar `@astrojs/react`, ejecuta lo siguiente desde el directorio de tu proyecto y siga las instrucciones:
-
-<PackageManagerTabs>
-  <Fragment slot="npm">
-  ```sh
-  npx astro add react
-  ```
-  </Fragment>
-  <Fragment slot="pnpm">
-  ```sh
-  pnpm astro add react
-  ```
-  </Fragment>
-  <Fragment slot="yarn">
-  ```sh
-  yarn astro add react
-  ```
-  </Fragment>
-</PackageManagerTabs>
-
-Si tienes algún problema, [no dudes en informárnoslo en GitHub](https://github.com/withastro/astro/issues) y prueba los pasos de instalación manual a continuación.
-
-### Instalación manual
-
-Primeron, instala el paquete `@astrojs/react`:
-
-<PackageManagerTabs>
-  <Fragment slot="npm">
-  ```sh
-  npm install @astrojs/react
-  ```
-  </Fragment>
-  <Fragment slot="pnpm">
-  ```sh
-  pnpm add @astrojs/react
-  ```
-  </Fragment>
-  <Fragment slot="yarn">
-  ```sh
-  yarn add @astrojs/react
-  ```
-  </Fragment>
-</PackageManagerTabs>
-
-La mayoría de los gestores de paquetes instalarán las dependencias asociadas también. Si ves un mensaje de advertencia "Cannot find package 'react'" (o similar) cuando inicias Astro, deberás instalar `react` y `react-dom`:
-
-<PackageManagerTabs>
-  <Fragment slot="npm">
-  ```sh
-  npm install react react-dom
-  ```
-  </Fragment>
-  <Fragment slot="pnpm">
-  ```sh
-  pnpm add react react-dom
-  ```
-  </Fragment>
-  <Fragment slot="yarn">
-  ```sh
-  yarn add react react-dom
-  ```
-  </Fragment>
-</PackageManagerTabs>
-
-Luego, aplica la integración a tu archivo `astro.config.*` usando la propiedad `integrations`:
-
-```js ins="react()" ins={2} title="astro.config.mjs"
-import { defineConfig } from 'astro/config';
-import react from '@astrojs/react';
-
-export default defineConfig({
-  // ...
-  integrations: [react()],
-});
-```
-
-Y añade el siguiente código al archivo `tsconfig.json`.
-
-```json title="tsconfig.json" ins={5-8}
-{
-  "extends": "astro/tsconfigs/strict",
-  "include": [".astro/types.d.ts", "**/*"],
-  "exclude": ["dist"],
-  "compilerOptions": {
-    "jsx": "react-jsx",
-    "jsxImportSource": "react"
-  }
-}
-```
-
-## Empezando
-
-Para usar tu primer componente React en Astro, dirígete a nuestra [documentación de frameworks UI][astro-ui-frameworks]. Explorarás:
-
-* 📦 como se cargan los componentes de framework,
-* 💧 opciones de hidratación del lado del cliente, y
-* 🤝 oportunidades para mezclar y anidar frameworks juntos
-
-## Opciones
-
-### Combinando múltiples frameworks JSX
-
-Cuando estás utilizando múltiples frameworks JSX (React, Preact, Solid) en el mismo proyecto, Astro necesita determinar qué transformaciones específicas del framework JSX deben usarse para cada uno de tus componentes. Si solo has agregado una integración de framework JSX a tu proyecto, no se necesita configuración adicional.
-
-Utiliza las opciones de configuración `include` (obligatoria) y `exclude` (opcional) para especificar qué archivos pertenecen a qué framework. Proporciona un array de archivos y/o carpetas en `include` para cada framework que estés utilizando. Puedes utilizar comodines para incluir múltiples rutas de archivo.
-
-Recomendamos colocar los componentes comunes de los frameworks en la misma carpeta (p. ej. `/components/react/` y `/components/solid/`) para facilitar la especificación de tus inclusiones, pero esto no es obligatorio:
-
-```js title="astro.config.mjs"
-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({
-  // Habilita varios frameworks para admitir todo tipo de componentes diferentes.
-  // ¡No se necesita `include` si solo estás utilizando un solo framework JSX!
-  integrations: [
-    preact({
-      include: ['**/preact/*'],
-    }),
-    react({
-      include: ['**/react/*'],
-    }),
-    solid({
-      include: ['**/solid/*'],
-    }),
-  ],
-});
-```
-
-### Análisis de los hijos
-
-Los hijos pasados a un componente de React desde un componente de Astro se analizan como strings simples, no como nodos de React.
-
-Por ejemplo, el `<ReactComponent />` a continuación solo recibirá un único elemento hijo:
-
-```astro
----
-import ReactComponent from './ReactComponent';
----
-<ReactComponent>
-  <div>uno</div>
-  <div>dos</div>
-</ReactComponent>
-```
-
-Si estás utilizando una biblioteca que *espera* que se pasen más de un elemento hijo, por ejemplo, para que pueda colocar ciertos elementos en diferentes lugares, es posible que encuentres esto como un bloqueador.
-
-Puedes establecer la bandera experimental `experimentalReactChildren` para indicarle a Astro que siempre pase los hijos a React como nodos virtuales del DOM de React. Esto tiene un costo de tiempo de ejecución, pero puede ayudar con la compatibilidad.
-
-Puedes habilitar esta opción en la configuración para la integración de React:
-
-```js title="astro.config.mjs" ins={8}
-import { defineConfig } from 'astro/config';
-import react from '@astrojs/react';
-
-export default defineConfig({
-  // ...
-  integrations: [
-    react({
-      experimentalReactChildren: true,
-    }),
-  ],
-});
-```
-
-### Desactivar streaming (experimental)
-
-Astro transmite la salida de los componentes React por defecto. Sin embargo, puedes desactivar este comportamiento activando la opción `experimentalDisableStreaming`. Esto es particularmente útil para soportar librerías que no funcionan bien con streaming, como algunas soluciones CSS-in-JS.
-
-Para deshabilitar el streaming para todos los componentes React de tu proyecto, configura `@astrojs/react` con `experimentalDisableStreaming: true`:
-
-```js title="astro.config.mjs" ins={8}
-import { defineConfig } from 'astro/config';
-import react from '@astrojs/react';
-export default defineConfig({
-  // ...
-  integrations: [
-    react({
-      experimentalDisableStreaming: true,
-    }),
-  ],
-});
-```
-
-[astro-integration]: /es/guides/integrations-guide/
-
-[astro-ui-frameworks]: /es/guides/framework-components/#usando-componente-de-framework
diff --git a/src/content/docs/es/guides/integrations-guide/sitemap.mdx b/src/content/docs/es/guides/integrations-guide/sitemap.mdx
deleted file mode 100644
index 270f6fd43120a..0000000000000
--- a/src/content/docs/es/guides/integrations-guide/sitemap.mdx
+++ /dev/null
@@ -1,401 +0,0 @@
----
-type: integration
-title: '@astrojs/sitemap'
-description: Aprende cómo utilizar la integración @astrojs/sitemap en tu proyecto Astro.
-githubIntegrationURL: 'https://github.com/withastro/astro/tree/main/packages/integrations/sitemap/'
-category: other
-i18nReady: true
----
-import PackageManagerTabs from '~/components/tabs/PackageManagerTabs.astro'
-
-Esta **[integración de Astro][astro-integration]** genera un Sitemap basado en tus páginas al construir tu proyecto de Astro.
-
-## ¿Por qué Astro Sitemap?
-
-Un Sitemap es un archivo XML que describe todas las páginas, videos y archivos de tu sitio. Los motores de búsqueda como Google leen este archivo para rastrear tu sitio de manera más eficiente. [Consulta el consejo de Google sobre los Sitemaps](https://developers.google.com/search/docs/advanced/sitemaps/overview) para obtener más información al respecto.
-
-Se recomienda utilizar un archivo Sitemap para sitios grandes con múltiples páginas. Si no utilizas un Sitemap, la mayoría de los motores de búsqueda aún podrán listar las páginas de tu sitio, pero un Sitemap es una excelente manera de asegurarte de que tu sitio sea lo más amigable posible para los motores de búsqueda.
-
-Con Astro Sitemap, no tienes que preocuparte por crear este archivo XML tú mismo: la integración Astro Sitemap rastreará tus rutas generadas estáticamente y creará el archivo sitemap, incluyendo [rutas dinámicas](/es/guides/routing/#rutas-dinámicas) como `[...slug]` o `src/pages/[lang]/[version]/info.astro` generado por `getStaticPaths()`.
-
-Esta integración no puede generar entradas de sitemap para rutas dinámicas en [modo SSR](/es/guides/on-demand-rendering/).
-
-## Instalación
-
-Astro incluye un comando `astro add` para automatizar la configuración de las integraciones oficiales. Si lo prefieres, puedes [instalar las integraciones manualmente](#instalación-manual) en su lugar.
-
-Ejecuta uno de los siguientes comandos en una nueva ventana de terminal.
-
-<PackageManagerTabs>
-  <Fragment slot="npm">
-  ```sh
-  npx astro add sitemap
-  ```
-  </Fragment>
-  <Fragment slot="pnpm">
-  ```sh
-  pnpm astro add sitemap
-  ```
-  </Fragment>
-  <Fragment slot="yarn">
-  ```sh
-  yarn astro add sitemap
-  ```
-  </Fragment>
-</PackageManagerTabs>
-
-Si tienes algún problema, [no dudes en informarnos en GitHub](https://github.com/withastro/astro/issues) y prueba los pasos de instalación manual a continuación.
-
-### Instalación manual
-
-Primero, instala el paquete `@astrojs/sitemap` utilizando tu gestor de paquetes.
-
-<PackageManagerTabs>
-  <Fragment slot="npm">
-  ```sh
-  npm install @astrojs/sitemap
-  ```
-  </Fragment>
-  <Fragment slot="pnpm">
-  ```sh
-  pnpm add @astrojs/sitemap
-  ```
-  </Fragment>
-  <Fragment slot="yarn">
-  ```sh
-  yarn add @astrojs/sitemap
-  ```
-  </Fragment>
-</PackageManagerTabs>
-
-Luego, aplica la integración a tu archivo `astro.config.*` utilizando la propiedad `integrations`:
-
-```js ins={2} ins="sitemap()"
-import { defineConfig } from 'astro/config';
-import sitemap from '@astrojs/sitemap';
-
-export default defineConfig({
-  // ...
-  integrations: [sitemap()],
-});
-```
-
-## Uso
-
-`@astrojs/sitemap` requiere una URL de despliegue o del sitio para su generación. Agrega la URL de tu sitio bajo `astro.config.*` utilizando la propiedad `site`. Esta URL debe comenzar con `http:` o `https:`.
-
-```js title="astro.config.mjs" "'https://stargazers.club'"
-import { defineConfig } from 'astro/config';
-import sitemap from '@astrojs/sitemap';
-
-export default defineConfig({
-  // ...
-  site: 'https://stargazers.club',
-  integrations: [sitemap()],
-})
-```
-
-Ten en cuenta que, a diferencia de otras opciones de configuración, `site` se establece en el objeto `defineConfig` raíz, en lugar de dentro de la llamada a `sitemap()`.
-
-Ahora, [construye tu sitio para producción](/es/reference/cli-reference/#astro-build) utilizando el comando `astro build`. Encontrarás `sitemap-index.xml` y `sitemap-0.xml` en la carpeta `dist/` (o tu [directorio de salida](/es/reference/configuration-reference/#outdir) personalizado si está configurado).
-
-:::caution
-Si olvidas agregar la propiedad `site`, recibirás una advertencia amigable al realizar la compilación y el archivo `sitemap-index.xml` no se generará.
-:::
-
-Después de verificar que los sitemaps se hayan construido, puedes agregarlos al elemento`<head>` de tu sitio y al archivo `robots.txt`  para que los rastreadores los detecten.
-
-```html title="src/layouts/Layout.astro" ins={2}
-<head>
-  <link rel="sitemap" href="/sitemap-index.xml" />
-</head>
-```
-
-
-
-```txt ins={5}
-# public/robots.txt
-User-agent: *
-Allow: /
-
-Sitemap: https://<TU SITIO>/sitemap-index.xml
-```
-
-Para generar de forma dinámica el archivo `robots.txt`, añade un archivo llamado `robots.txt.ts` con el siguiente código:
-
-```ts title="src/pages/robots.txt.ts"
-import type { APIRoute } from 'astro';
-
-const robotsTxt = `
-User-agent: *
-Allow: /
-Sitemap: ${new URL('sitemap-index.xml', import.meta.env.SITE).href}
-`.trim();
-
-export const GET: APIRoute = () => {
-  return new Response(robotsTxt, {
-    headers: {
-      'Content-Type': 'text/plain; charset=utf-8',
-    },
-  });
-};
-
-```
-
-### Ejemplo de archivos generados para un sitio web de dos páginas
-
-```xml title="sitemap-index.xml"
-<?xml version="1.0" encoding="UTF-8"?>
-  <sitemapindex xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
-  <sitemap>
-    <loc>https://stargazers.club/sitemap-0.xml</loc>
-  </sitemap>
-</sitemapindex>
-```
-
-```xml title="sitemap-0.xml"
-<?xml version="1.0" encoding="UTF-8"?>
-<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9" xmlns:news="http://www.google.com/schemas/sitemap-news/0.9" xmlns:xhtml="http://www.w3.org/1999/xhtml" xmlns:image="http://www.google.com/schemas/sitemap-image/1.1" xmlns:video="http://www.google.com/schemas/sitemap-video/1.1">
-  <url>
-    <loc>https://stargazers.club/</loc>
-  </url>
-  <url>
-    <loc>https://stargazers.club/second-page/</loc>
-  </url>
-</urlset>
-```
-
-## Configuración
-
-Para configurar esta integración, pasa un objeto a la función `sitemap()` en la configuración de `astro.config.mjs`.
-
-```js title="astro.config.mjs" {6-8}
-import { defineConfig } from 'astro/config';
-import sitemap from '@astrojs/sitemap';
-
-export default defineConfig({
-  integrations: [
-    sitemap({
-      // opciones de configuración
-    }),
-  ],
-});
-```
-
-### filter
-
-Por defecto, todas las páginas se incluyen en tu sitemap. Al agregar una función `filter` personalizada, puedes filtrar las páginas incluidas según su URL.
-
-```js title="astro.config.mjs" ins={8}
-import { defineConfig } from 'astro/config';
-import sitemap from '@astrojs/sitemap';
-
-export default defineConfig({
-  site: 'https://stargazers.club',
-  integrations: [
-    sitemap({
-      filter: (page) => page !== 'https://stargazers.club/secret-vip-lounge/',
-    }),
-  ],
-});
-```
-
-La función se llamará para cada página de tu sitio. El parámetro de función `page` es la URL completa de la página que se está considerando actualmente, incluido el dominio de tu `site`. Devuelve `true` para incluir la página en tu sitemap y `false` para omitirla.
-
-Para filtrar varias páginas, agrega argumentos con las URL de destino.
-
-```js title="astro.config.mjs" {8-12}
-import { defineConfig } from 'astro/config';
-import sitemap from '@astrojs/sitemap';
-
-export default defineConfig({
-  site: 'https://stargazers.club',
-  integrations: [
-    sitemap({
-      filter: (page) =>
-        page !== 'https://stargazers.club/secret-vip-lounge-1/' &&
-        page !== 'https://stargazers.club/secret-vip-lounge-2/' &&
-        page !== 'https://stargazers.club/secret-vip-lounge-3/' &&
-        page !== 'https://stargazers.club/secret-vip-lounge-4/',
-    }),
-  ],
-});
-```
-
-### customPages
-
-En algunos casos, una página podría formar parte de tu sitio implementado pero no ser parte de tu proyecto de Astro. Si deseas incluir una página en tu sitemap que *no* sea creada por Astro, puedes utilizar esta opción.
-
-```js title="astro.config.mjs" ins={8}
-import { defineConfig } from 'astro/config';
-import sitemap from '@astrojs/sitemap';
-
-export default defineConfig({
-  site: 'https://stargazers.club',
-  integrations: [
-    sitemap({
-      customPages: ['https://stargazers.club/external-page', 'https://stargazers.club/external-page2'],
-    }),
-  ],
-});
-```
-
-### entryLimit
-
-El número máximo de entradas por archivo de sitemap. El valor predeterminado es 45000. Se crea un índice de sitemap y múltiples sitemaps si tienes más entradas. Consulta esta [explicación sobre cómo dividir un sitemap grande](https://developers.google.com/search/docs/advanced/sitemaps/large-sitemaps).
-
-```js title="astro.config.mjs" ins={8}
-import { defineConfig } from 'astro/config';
-import sitemap from '@astrojs/sitemap';
-
-export default defineConfig({
-  site: 'https://stargazers.club',
-  integrations: [
-    sitemap({
-      entryLimit: 10000,
-    }),
-  ],
-});
-```
-
-### changefreq, lastmod, y priority
-
-Estas opciones corresponden a las etiquetas `<changefreq>`, `<lastmod>`, y `<priority>` en la [especificación XML del Sitemap.](https://www.sitemaps.org/protocol.html)
-
-Ten en cuenta que Google ignora las propiedades `changefreq` y `priority`.
-
-:::note
-Debido a las limitaciones de la [API de Integración](/es/reference/integrations-reference/) de Astro, esta integración no puede analizar el código fuente de una página específica. Esta opción de configuración puede establecer `changefreq`, `lastmod` y `priority` de manera *global* para todo el sitio; consulta la siguiente opción **serialize** para ver cómo puedes establecer estos valores de forma específica para cada página.
-:::
-
-```js title="astro.config.mjs" ins={8-10}
-import { defineConfig } from 'astro/config';
-import sitemap from '@astrojs/sitemap';
-
-export default defineConfig({
-  site: 'https://stargazers.club',
-  integrations: [
-    sitemap({
-      changefreq: 'weekly',
-      priority: 0.7,
-      lastmod: new Date('2022-02-24'),
-    }),
-  ],
-});
-```
-
-### serialize
-
-Una función que se llama para cada entrada del Sitemap justo antes de escribir en el disco. Esta función puede ser asíncrona.
-
-Recibe como parámetro un objeto `SitemapItem` que puede tener estas propiedades:
-
-* `url` (URL absoluta de la página). Esta es la única propiedad que se garantiza que estará presente en `SitemapItem`.
-* `changefreq`
-* `lastmod` (Fecha en formato ISO, tipo `String`)
-* `priority`
-* `links`.
-
-La propiedad `links` contiene una lista de `LinkItem` que representa las páginas alternativas, incluida la página principal.
-
-El tipo `LinkItem` tiene dos campos: `url` (la URL completamente calificada para la versión de esta página en el idioma especificado) y `lang` (un código de idioma compatible dirigido por esta versión de la página).
-
-La función `serialize` debe devolver un objeto `SitemapItem`, ya sea modificado o no.
-
-El siguiente ejemplo muestra la capacidad de agregar propiedades específicas del Sitemap individualmente.
-
-```js title="astro.config.mjs" ins={8-18}
-import { defineConfig } from 'astro/config';
-import sitemap from '@astrojs/sitemap';
-
-export default defineConfig({
-  site: 'https://stargazers.club',
-  integrations: [
-    sitemap({
-      serialize(item) {
-        if (/exclude-from-sitemap/.test(item.url)) {
-          return undefined;
-        }
-        if (/your-special-page/.test(item.url)) {
-          item.changefreq = 'daily';
-          item.lastmod = new Date();
-          item.priority = 0.9;
-        }
-        return item;
-      },
-    }),
-  ],
-});
-```
-
-### i18n
-
-Para localizar un Sitemap, pasa un objeto a la opción `i18n`.
-
-Este objeto tiene dos propiedades requeridas:
-
-* `defaultLocale`: `String`. Su valor debe existir como una de las claves de `locales`.
-* `locales`: `Record<String, String>`, pares clave/valor. La clave se utiliza para buscar la parte del idioma en una ruta de página. El valor es un atributo de idioma y solo se permiten letras del alfabeto inglés y guiones.
-
-[Lee más sobre los atributos de idioma](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/lang).
-
-[Lee más sobre la localización](https://developers.google.com/search/docs/advanced/crawling/localized-versions#all-method-guidelines).
-
-```js title="astro.config.mjs" ins={8-15}
-import { defineConfig } from 'astro/config';
-import sitemap from '@astrojs/sitemap';
-
-export default defineConfig({
-  site: 'https://stargazers.club',
-  integrations: [
-    sitemap({
-      i18n: {
-        defaultLocale: 'en', // Todas las URL que no contengan `es` o `fr` después de `https://stargazers.club/` se tratarán como el idioma predeterminado, es decir, `en`
-        locales: {
-          en: 'en-US', // El valor de `defaultLocale` debe estar presente en las claves de `locales`
-          es: 'es-ES',
-          fr: 'fr-CA',
-        },
-      },
-    }),
-  ],
-});
-```
-
-El sitemap resultante tiene el siguiente aspecto:
-
-```xml title="sitemap-0.xml"
-...
-  <url>
-    <loc>https://stargazers.club/</loc>
-    <xhtml:link rel="alternate" hreflang="en-US" href="https://stargazers.club/"/>
-    <xhtml:link rel="alternate" hreflang="es-ES" href="https://stargazers.club/es/"/>
-    <xhtml:link rel="alternate" hreflang="fr-CA" href="https://stargazers.club/fr/"/>
-  </url>
-  <url>
-    <loc>https://stargazers.club/es/</loc>
-    <xhtml:link rel="alternate" hreflang="en-US" href="https://stargazers.club/"/>
-    <xhtml:link rel="alternate" hreflang="es-ES" href="https://stargazers.club/es/"/>
-    <xhtml:link rel="alternate" hreflang="fr-CA" href="https://stargazers.club/fr/"/>
-  </url>
-  <url>
-    <loc>https://stargazers.club/fr/</loc>
-    <xhtml:link rel="alternate" hreflang="en-US" href="https://stargazers.club/"/>
-    <xhtml:link rel="alternate" hreflang="es-ES" href="https://stargazers.club/es/"/>
-    <xhtml:link rel="alternate" hreflang="fr-CA" href="https://stargazers.club/fr/"/>
-  </url>
-  <url>
-    <loc>https://stargazers.club/es/second-page/</loc>
-    <xhtml:link rel="alternate" hreflang="es-ES" href="https://stargazers.club/es/second-page/"/>
-    <xhtml:link rel="alternate" hreflang="fr-CA" href="https://stargazers.club/fr/second-page/"/>
-    <xhtml:link rel="alternate" hreflang="en-US" href="https://stargazers.club/second-page/"/>
-  </url>
-...
-```
-
-## Ejemplos
-
-* El sitio web oficial de Astro utiliza Astro Sitemap para generar [su sitemap](https://astro.build/sitemap-index.xml).
-* [¡Explora proyectos con Astro Sitemap en GitHub](https://github.com/search?q=%22%40astrojs%2Fsitemap%22+path%3Apackage.json\&type=Code) para más ejemplos!
-
-[astro-integration]: /es/guides/integrations-guide/
diff --git a/src/content/docs/es/guides/integrations-guide/solid-js.mdx b/src/content/docs/es/guides/integrations-guide/solid-js.mdx
deleted file mode 100644
index d0e4508a57f06..0000000000000
--- a/src/content/docs/es/guides/integrations-guide/solid-js.mdx
+++ /dev/null
@@ -1,230 +0,0 @@
----
-type: integration
-title: '@astrojs/solid-js'
-description: Aprende como usar la integración de @astrojs/solid-js para extender el soporte de Solidjs en tu proyecto de Astro.
-githubIntegrationURL: 'https://github.com/withastro/astro/tree/main/packages/integrations/solid/'
-category: renderer
-i18nReady: true
----
-import PackageManagerTabs from '~/components/tabs/PackageManagerTabs.astro';
-import Since from '~/components/Since.astro';
-
-Esta **[integración de Astro][astro-integration]** habilita el renderizado del lado del servidor y la hidratación del lado del cliente para sus componentes [SolidJS](https://www.solidjs.com/).
-
-
-## Instalación
-
-Astro incluye un comando `astro add` para automatizar la configuración de las integraciones oficiales. Si lo prefieres, puedes [instalar las integraciones manualmente](#instalación-manual) en su lugar.
-
-Para instalar `@astrojs/solid-js`, ejecuta lo siguiente desde el directorio raíz de tu proyecto y sigue las instrucciones:
-
-<PackageManagerTabs>
-  <Fragment slot="npm">
-  ```sh
-  npx astro add solid
-  ```
-  </Fragment>
-  <Fragment slot="pnpm">
-  ```sh
-  pnpm astro add solid
-  ```
-  </Fragment>
-  <Fragment slot="yarn">
-  ```sh
-  yarn astro add solid
-  ```
-  </Fragment>
-</PackageManagerTabs>
-
-Si tienes algún problema, [no dudes en informarnos en GitHub](https://github.com/withastro/astro/issues) o intenta los pasos de instalación manual a continuación.
-
-### Instalación manual
-
-Primero, instala el paquete `@astrojs/solid-js`:
-
-<PackageManagerTabs>
-  <Fragment slot="npm">
-  ```sh
-  npm install @astrojs/solid-js
-  ```
-  </Fragment>
-  <Fragment slot="pnpm">
-  ```sh
-  pnpm add @astrojs/solid-js
-  ```
-  </Fragment>
-  <Fragment slot="yarn">
-  ```sh
-  yarn add @astrojs/solid-js
-  ```
-  </Fragment>
-</PackageManagerTabs>
-
-La mayoría de los gestores de paquetes instalarán las dependencias asociadas también. Si ves un mensaje de advertencia `Cannot find package 'solid-js'` (o similar) cuando inicias Astro, necesitarás instalar SolidJS:
-
-<PackageManagerTabs>
-  <Fragment slot="npm">
-  ```sh
-  npm install solid-js
-  ```
-  </Fragment>
-  <Fragment slot="pnpm">
-  ```sh
-  pnpm add solid-js
-  ```
-  </Fragment>
-  <Fragment slot="yarn">
-  ```sh
-  yarn add solid-js
-  ```
-  </Fragment>
-</PackageManagerTabs>
-
-Luego, aplica la integración a tu archivo `astro.config.*` usando la propiedad `integrations`:
-
-```js title="astro.config.mjs" ins={2} ins="solid()"
-import { defineConfig } from 'astro/config';
-import solid from '@astrojs/solid-js';
-
-export default defineConfig({
-  // ...
-  integrations: [solid()],
-});
-```
-
-Y añade el siguiente código al archivo `tsconfig.json`.
-
-```json title="tsconfig.json" ins={5-8}
-{
-  "extends": "astro/tsconfigs/strict",
-  "include": [".astro/types.d.ts", "**/*"],
-  "exclude": ["dist"],
-  "compilerOptions": {
-    "jsx": "preserve",
-    "jsxImportSource": "solid-js"
-  }
-}
-```
-
-## Empezando
-
-Para usar tu primer componente con solidjs en Astro, dirígete a nuestra [documentación del interfaz de usuario][astro-ui-frameworks]. Explorarás:
-
-* 📦 como se cargan los componentes de framework,
-* 💧 opciones de hidratación del lado del cliente, y
-* 🤝 oportunidades para mezclar y anidar frameworks juntos
-
-## Configuración
-
-### devtools
-
-<p><Since pkg="@astrojs/solid-js" v="4.2.0" /></p>
-
-Puedes habilitar [las herramientas de desarrollo de Solid](https://github.com/thetarnav/solid-devtools) en desarrollo pasando un objeto con `devtools: true` a tu configuración de integración `solid()` y agregando `solid-devtools` a las dependencias de tu proyecto:
-
-<PackageManagerTabs>
-  <Fragment slot="npm">
-  ```sh
-  npm install solid-devtools
-  ```
-  </Fragment>
-  <Fragment slot="pnpm">
-  ```sh
-  pnpm add solid-devtools
-  ```
-  </Fragment>
-  <Fragment slot="yarn">
-  ```sh
-  yarn add solid-devtools
-  ```
-  </Fragment>
-</PackageManagerTabs>
-
-```js title="astro.config.mjs"
-import { defineConfig } from 'astro/config';
-import solid from '@astrojs/solid-js';
-
-export default defineConfig({
-  // ...
-  integrations: [solid({ devtools: true })],
-});
-```
-
-## Opciones
-
-### Combinando múltiples frameworks JSX
-
-Cuando estás utilizando múltiples frameworks JSX (React, Preact, Solid) en el mismo proyecto, Astro necesita determinar qué transformaciones específicas del framework JSX deben usarse para cada uno de tus componentes. Si solo has agregado una integración de framework JSX a tu proyecto, no se necesita configuración adicional.
-
-Utiliza las opciones de configuración `include` (obligatoria) y `exclude` (opcional) para especificar qué archivos pertenecen a qué framework. Proporciona un array de archivos y/o carpetas en `include` para cada framework que estés utilizando. Puedes utilizar comodines para incluir múltiples rutas de archivo.
-
-Recomendamos colocar los componentes comunes de los frameworks en la misma carpeta (p. ej. `/components/react/` y `/components/solid/`) para facilitar la especificación de tus inclusiones, pero esto no es obligatorio:
-
-```js title="astro.config.mjs"
-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({
-  // Habilita varios frameworks para admitir todo tipo de componentes diferentes.
-  // ¡No se necesita `include` si solo estás utilizando un solo framework JSX!
-  integrations: [
-    preact({
-      include: ['**/preact/*'],
-    }),
-    react({
-      include: ['**/react/*'],
-    }),
-    solid({
-      include: ['**/solid/*', '**/node_modules/@suid/material/**'],
-    }),
-  ],
-});
-```
-
-## Uso
-
-Usa un componente SolidJS como lo harías con cualquier [componente de framework UI](/es/guides/framework-components/).
-
-### Límites de Suspense
-
-Para admitir los recursos de Solid y los componentes Lazy sin una configuración excesiva, los componentes solo del servidor y de hidratación se envuelven automáticamente en límites de Suspense de nivel superior y se renderizan en el servidor utilizando la función [`renderToStringAsync`][solid-render-to-string-async]. Por lo tanto, no es necesario agregar un límite de Suspense de nivel superior alrededor de los componentes asíncronos.
-Por ejemplo, puedes usar [`createResource`][solid-create-resource] de Solid para obtener datos remotos asíncronos en el servidor. Los datos remotos se incluirán en el HTML inicial renderizado en el servidor desde Astro:
-
-```tsx
-// CharacterName.tsx
-function CharacterName() {
-  const [name] = createResource(() =>
-    fetch('https://swapi.dev/api/people/1')
-      .then((result) => result.json())
-      .then((data) => data.name)
-  );
-  return (
-    <>
-      <h2>Nombre:</h2>
-      {/* Luke Skywalker */}
-      <div>{name()}</div>
-    </>
-  );
-}
-```
-
-Similarmente, los [componentes Lazy][solid-lazy-components] de Solid también se resolverán y su HTML se incluirá en la página inicial renderizada en el servidor.
-Los componentes [`client:only`][astro-client-only] que no se hidratan no se envuelven automáticamente en límites de Suspense.
-
-Sientete libre de agregar límites de Suspense adicionales según tu preferencia.
-
-[astro-integration]: /es/guides/integrations-guide/
-
-[astro-ui-frameworks]: /es/guides/framework-components/#usando-componente-de-framework
-
-[astro-client-only]: /es/reference/directives-reference/#clientonly
-
-[solid-render-to-string-async]: https://www.solidjs.com/docs/latest/api#rendertostringasync
-
-[solid-create-resource]: https://www.solidjs.com/docs/latest/api#createresource
-
-[solid-lazy-components]: https://www.solidjs.com/docs/latest/api#lazy
diff --git a/src/content/docs/es/guides/integrations-guide/svelte.mdx b/src/content/docs/es/guides/integrations-guide/svelte.mdx
deleted file mode 100644
index 9799c49d4cfbe..0000000000000
--- a/src/content/docs/es/guides/integrations-guide/svelte.mdx
+++ /dev/null
@@ -1,157 +0,0 @@
----
-type: integration
-title: '@astrojs/svelte'
-description: Aprende a utilizar la integración del framework @astrojs/svelte para ampliar el soporte de componentes en tu proyecto de Astro.
-githubIntegrationURL: 'https://github.com/withastro/astro/tree/main/packages/integrations/svelte/'
-category: renderer
-i18nReady: true
----
-import PackageManagerTabs from '~/components/tabs/PackageManagerTabs.astro';
-import Since from '~/components/Since.astro';
-
-Esta **[integración de Astro][astro-integration]** permite el renderizado en el lado del servidor y la hidratación en el lado del cliente para tus componentes de [Svelte](https://svelte.dev/). Compatible con Svelte 3, 4, y 5 (experimental).
-
-## Instalación
-
-Astro incluye un comando `astro add` para automatizar la configuración de las integraciones oficiales. Si lo prefieres, puedes [instalar las integraciones manualmente](#instalación-manual) en su lugar.
-
-Para instalar `@astrojs/svelte`, ejecuta lo siguiente desde el directorio de tu proyecto y sigue las instrucciones:
-
-<PackageManagerTabs>
-  <Fragment slot="npm">
-  ```sh
-  npx astro add svelte
-  ```
-  </Fragment>
-  <Fragment slot="pnpm">
-  ```sh
-  pnpm astro add svelte
-  ```
-  </Fragment>
-  <Fragment slot="yarn">
-  ```sh
-  yarn astro add svelte
-  ```
-  </Fragment>
-</PackageManagerTabs>
-
-Si tienes algún problema, [no dudes en informárnoslo en GitHub](https://github.com/withastro/astro/issues) y prueba los pasos de instalación manual a continuación.
-
-### Instalación manual
-
-Primero, instala el paquete `@astrojs/svelte`:
-
-<PackageManagerTabs>
-  <Fragment slot="npm">
-  ```sh
-  npm install @astrojs/svelte
-  ```
-  </Fragment>
-  <Fragment slot="pnpm">
-  ```sh
-  pnpm add @astrojs/svelte
-  ```
-  </Fragment>
-  <Fragment slot="yarn">
-  ```sh
-  yarn add @astrojs/svelte
-  ```
-  </Fragment>
-</PackageManagerTabs>
-
-La mayoría de los gestores de paquetes instalarán también las dependencias asociadas. Si ves un mensaje de advertencia de "No se puede encontrar el paquete 'svelte'" (o similar) cuando inicias Astro, tendrás que instalar Svelte:
-
-<PackageManagerTabs>
-  <Fragment slot="npm">
-  ```sh
-  npm install svelte
-  ```
-  </Fragment>
-  <Fragment slot="pnpm">
-  ```sh
-  pnpm add svelte
-  ```
-  </Fragment>
-  <Fragment slot="yarn">
-  ```sh
-  yarn add svelte
-  ```
-  </Fragment>
-</PackageManagerTabs>
-
-Luego, aplica la integración a tu archivo `astro.config.*` usando la propiedad `integrations`:
-
-```js title="astro.config.mjs" ins={2} ins="svelte()"
-import { defineConfig } from 'astro/config';
-import svelte from '@astrojs/svelte';
-
-export default defineConfig({
-  // ...
-  integrations: [svelte()],
-});
-```
-
-## Empezando
-
-Para usar tu primer componente Svelte en Astro, dirígete a nuestra [documentación de frameworks UI][astro-ui-frameworks]. Explorarás:
-
-* 📦 como se cargan los componentes de framework,
-* 💧 opciones de hidratación del lado del cliente, y
-* 🤝 oportunidades para mezclar y anidar frameworks juntos
-
-## Opciones
-
-Esta integración está impulsada por `@sveltejs/vite-plugin-svelte`. Para personalizar el compilador de Svelte, se pueden proporcionar opciones a la integración. Consulta la [documentación de `@sveltejs/vite-plugin-svelte`](https://github.com/sveltejs/vite-plugin-svelte/blob/HEAD/docs/config.md) para obtener más detalles.
-
-### Opciones por defecto
-
-Esta integración pasa las siguientes opciones predeterminadas al compilador de Svelte:
-
-```js
-const defaultOptions = {
-  emitCss: true,
-  compilerOptions: { dev: isDev, hydratable: true },
-  preprocess: vitePreprocess(),
-};
-```
-
-Estos valores `emitCss`, `compilerOptions.dev`, y `compilerOptions.hydratable` son necesarios para construir correctamente para Astro y no pueden ser anulados.
-
-Proporcionar tus propias opciones de `preprocess` **sobrescribirá**  la configuración predeterminada de[`vitePreprocess()`](https://github.com/sveltejs/vite-plugin-svelte/blob/HEAD/docs/preprocess.md). Asegúrate de habilitar las banderas de preprocesamiento necesarias para tu proyecto.
-
-Puedes establecer opciones ya sea pasándolas a la integración `svelte` en `astro.config.mjs` o en `svelte.config.js`. Cualquiera de estos sobrescribiría la configuración predeterminada de `preprocess`:
-
-```js title="astro.config.mjs" "preprocess: []"
-import { defineConfig } from 'astro/config';
-import svelte from '@astrojs/svelte';
-
-export default defineConfig({
-  integrations: [svelte({ preprocess: [] })],
-});
-```
-
-```js title="svelte.config.js"
-export default {
-  preprocess: [],
-};
-```
-
-## Intellisense para TypeScript
-
-<Since v="2.0.0" pkg="@astrojs/svelte" />
-
-Si estás utilizando un preprocesador como TypeScript o SCSS en tus archivos Svelte, puedes crear un archivo `svelte.config.js` para que la extensión del IDE de Svelte pueda analizar correctamente los archivos Svelte.
-
-```js title="svelte.config.js"
-import { vitePreprocess } from '@astrojs/svelte';
-
-export default {
-  preprocess: vitePreprocess(),
-};
-```
-
-Este archivo de configuración se agregará automáticamente cuando ejecutes `astro add svelte`.
-
-[astro-integration]: /es/guides/integrations-guide/
-
-[astro-ui-frameworks]: /es/guides/framework-components/#usando-componente-de-framework
diff --git a/src/content/docs/es/guides/integrations-guide/tailwind.mdx b/src/content/docs/es/guides/integrations-guide/tailwind.mdx
deleted file mode 100644
index d49e94cdb1a5b..0000000000000
--- a/src/content/docs/es/guides/integrations-guide/tailwind.mdx
+++ /dev/null
@@ -1,271 +0,0 @@
----
-type: integration
-title: '@astrojs/tailwind'
-description: Aprende como usar la integración @astrojs/tailwind en tu proyecto de Astro.
-githubIntegrationURL: 'https://github.com/withastro/astro/tree/main/packages/integrations/tailwind/'
-category: other
-i18nReady: true
----
-
-import PackageManagerTabs from '~/components/tabs/PackageManagerTabs.astro';
-
-Esta **[integración de Astro][astro-integration]** trae las clases de CSS de utilidad de [Tailwind](https://tailwindcss.com/) a cada archivo `.astro` y [componente de framework](/es/guides/framework-components/) en tu proyecto, junto con el soporte para el archivo de configuración de Tailwind.
-
-## ¿Por qué Tailwind?
-
-Tailwind te permite usar clases de utilidad en lugar de escribir CSS. Estas clases de utilidad son en su mayoría uno a uno, con un cierto ajuste de propiedad CSS: por ejemplo, agregar el `text-lg` a un elemento es equivalente a establecer `font-size: 1.125rem` en CSS. ¡Es posible que te resulte más fácil escribir y mantener tus estilos usando estas clases de utilidad predefinidas!
-
-Si no te gusta esa configuración predeterminada, puedes [personalizar el archivo de configuración de Tailwind](https://tailwindcss.com/docs/configuration) según los requisitos de diseño de tu proyecto. Por ejemplo, si el "texto grande" en tu diseño es en realidad `2rem`, puedes [cambiar la configuración de `lg` fontSize](https://tailwindcss.com/docs/font-size#customizing-your-theme) a `2rem`.
-
-Tailwind es también una buena opción para agregar estilos a los componentes React, Preact o Solid, que no admiten una etiqueta `<style>` en el archivo del componente.
-
-Nota: generalmente no se aconseja usar Tailwind y otro método de estilado (por ejemplo, Styled Components) en el mismo archivo.
-
-### Instalación
-
-Astro incluye un comando `astro add` para automatizar la configuración de integraciones oficiales. Si lo prefieres, puedes [instalar integraciones manualmente](#instalación-manual) en su lugar.
-
-Ejecuta uno de los siguientes comandos en una nueva ventana de tu terminal.
-
-<PackageManagerTabs>
-  <Fragment slot="npm">
-  ```sh
-  npx astro add tailwind
-  ```
-  </Fragment>
-  <Fragment slot="pnpm">
-  ```sh
-  pnpm astro add tailwind
-  ```
-  </Fragment>
-  <Fragment slot="yarn">
-  ```sh
-  yarn astro add tailwind
-  ```
-  </Fragment>
-</PackageManagerTabs>
-
-Si tienes algún problema, [no dudes en informarnos en GitHub](https://github.com/withastro/astro/issues) y prueba los pasos de instalación manual a continuación.
-
-### Instalación Manual
-
-Primero, instala los paquetes `@astrojs/tailwind` y `tailwindcss` usando tu administrador de paquetes. Si estás usando npm o no estás seguro, ejecuta esto en la terminal:
-
-<PackageManagerTabs>
-  <Fragment slot="npm">
-  ```sh
-  npm install @astrojs/tailwind tailwindcss
-  ```
-  </Fragment>
-  <Fragment slot="pnpm">
-  ```sh
-  pnpm add @astrojs/tailwind tailwindcss
-  ```
-  </Fragment>
-  <Fragment slot="yarn">
-  ```sh
-  yarn add @astrojs/tailwind tailwindcss
-  ```
-  </Fragment>
-</PackageManagerTabs>
-
-Luego, aplica la integración a tu archivo `astro.config.*` usando la propiedad `integrations`:
-
-```js ins={2} ins="tailwind()" title="astro.config.mjs"
-import { defineConfig } from 'astro/config';
-import tailwind from '@astrojs/tailwind';
-
-export default defineConfig({
-  // ...
-  integrations: [tailwind()],
-});
-```
-
-Luego, crea un archivo `tailwind.config.mjs` en el directorio raíz de tu proyecto. Puedes usar el siguiente comando para generar un archivo de configuración básico para ti:
-
-<PackageManagerTabs>
-  <Fragment slot="npm">
-  ```sh
-  npx tailwindcss init
-  ```
-  </Fragment>
-  <Fragment slot="pnpm">
-  ```sh
-  pnpm dlx tailwindcss init
-  ```
-  </Fragment>
-  <Fragment slot="yarn">
-  ```sh
-  yarn dlx tailwindcss init
-  ```
-  </Fragment>
-</PackageManagerTabs>
-
-Finalmente, agrega esta configuración básica a tu archivo `tailwind.config.mjs`:
-
-```js ins={3} title="tailwind.config.mjs" "content: ['./src/**/*.{astro,html,js,jsx,md,mdx,svelte,ts,tsx,vue}']"
-/** @type {import('tailwindcss').Config} */
-module.exports = {
-  content: ['./src/**/*.{astro,html,js,jsx,md,mdx,svelte,ts,tsx,vue}'],
-  theme: {
-    extend: {},
-  },
-  plugins: [],
-};
-```
-
-## Uso
-
-Cuando instalas la integración, las clases de utilidad de Tailwind deberían estar listas para ser usadas de inmediato. Dirígete a la [documentación de Tailwind](https://tailwindcss.com/docs/utility-first) para aprender a usar Tailwind, y si ves una clase de utilidad que quieres probar, ¡agrégalas a cualquier elemento HTML de tu proyecto!
-
-Tambien [Autoprefixer](https://github.com/postcss/autoprefixer) es configurado automáticamente cuando se trabaja en modo desarrollo y para construcciones de producción, por lo que las clases de Tailwind funcionarán en navegadores antiguos.
-
-## Configuración
-
-### Configurando Tailwind
-
-Si has usado las instrucciones de instalación rápida y has dicho que sí a cada instrucción, verás un archivo `tailwind.config.mjs` en el directorio raíz de tu proyecto. Usa este archivo para cambiar la configuración de Tailwind. Puedes aprender a personalizar Tailwind usando este archivo en la [documentación de Tailwind](https://tailwindcss.com/docs/configuration).
-
-Si no está ahí, puedes agregar tu propio archivo `tailwind.config.(js|cjs|mjs|ts|mts|cts)` al directorio raíz y la integración usará sus configuraciones. Esto puede ser genial si ya tienes Tailwind configurado en otro proyecto y quieres traer esa configuración a este.
-
-### Configurando la Integración
-
-La integración de Astro Tailwind maneja la comunicación entre Astro y Tailwind y tiene sus propias opciones. Cambia estas opciones en el archivo `astro.config.mjs` (*no* el archivo de configuración de Tailwind) donde se encuentran los ajustes de integración de tu proyecto.
-
-#### configFile
-
-Previamente conocido como `config.path` en `@astrojs/tailwind` v3. Consulta el [registro de cambios de v4](https://github.com/withastro/astro/blob/main/packages/integrations/tailwind/CHANGELOG.md#400) para actualizar tu configuración.
-
-Si deseas usar una configuración diferente de Tailwind en lugar de la predeterminada `tailwind.config.(js|cjs|mjs|ts|mts|cts)`, especifica la ubicación de ese archivo usando la opción `configFile` de esta integración. Si `configFile` es relativo, se resolverá en relación con el directorio de trabajo actual.
-
-:::caution
-Cambiar esto no es recomendable ya que puede causar problemas con otras herramientas que se integran con Tailwind, como la extensión oficial de Tailwind VSCode.
-:::
-
-```js title="astro.config.mjs"
-import { defineConfig } from 'astro/config';
-import tailwind from '@astrojs/tailwind';
-
-export default defineConfig({
-  // ...
-  integrations: [
-    tailwind({
-    // Ejemplo: Proporciona una ruta personalizada a un archivo de configuración de Tailwind
-    configFile:'./custom-config.mjs',
-    }),
-  ],
-});
-```
-
-#### applyBaseStyles
-
-Previamente conocido como `config.applyBaseStyles` en `@astrojs/tailwind` v3. Consulta el [registro de cambios de v4](https://github.com/withastro/astro/blob/main/packages/integrations/tailwind/CHANGELOG.md#400) para actualizar tu configuración.
-
-Por defecto, la integración importa un archivo básico `base.css` en cada página de tu proyecto. Este archivo CSS básico incluye las tres directivas principales `@tailwind`:
-
-```css title="base.css"
-/* El archivo base.css inyectado por defecto de la integración */
-@tailwind base;
-@tailwind components;
-@tailwind utilities;
-```
-
-Para deshabilitar este comportamiento predeterminado, establece `applyBaseStyles` en `false`. Esto puede ser útil si necesitas definir tu propio archivo `base.css` (para incluir una [directiva `@layer`](https://tailwindcss.com/docs/functions-and-directives#layer), por ejemplo). Esto también puede ser útil si no deseas que `base.css` se importe en cada página de tu proyecto.
-
-```js title="astro.config.mjs"
-import { defineConfig } from 'astro/config';
-import tailwind from '@astrojs/tailwind';
-
-export default defineConfig({
-  // ...
-  integrations: [
-    tailwind({
-    // Ejemplo: Deshabilita la inyección de una importación básica de `base.css` en cada página.
-    // Muy útil si necesitas definir e/o importar tu propio `base.css` personalizado.
-    applyBaseStyles: false,
-    }),
-  ],
-});
-```
-
-Ahora puedes [importar tu propio `base.css` como una hoja de estilo local](/es/guides/styling/#importando-una-hoja-de-estilo-local).
-
-#### anidando
-
-Establece `true` para aplicar el [plugin de `tailwindcss/nesting` con PostCSS plugin](https://tailwindcss.com/docs/using-with-preprocessors#nesting) para que puedas escribir declaraciones CSS anidadas junto con la sintaxis de Tailwind. Esta opción es "falsa" por defecto.
-
-```js ins="nesting: true"
-// astro.config.mjs
-import { defineConfig } from 'astro/config';
-import tailwind from '@astrojs/tailwind';
-
-export default defineConfig({
-  // ...
-  integrations: [
-    tailwind({
-      // Example: Permite escribir declaraciones CSS anidadas
-      // junto con la sintaxis de Tailwind
-      nesting: true,
-    }),
-  ],
-});
-```
-
-## Ejemplos
-
-* El [Astro Tailwind Starter](https://github.com/withastro/astro/tree/latest/examples/with-tailwindcss?on=github) te ayuda a comenzar con una base para tu proyecto que usa Tailwind para el estilado
-* La página de Astro usa Tailwind. Consulta su [archivo de configuración de Tailwind](https://github.com/withastro/astro.build/blob/main/tailwind.config.ts) o un [componente de ejemplo](https://github.com/withastro/astro.build/blob/main/src/components/Checkbox.astro)
-* Los temas [Astro Ink](https://github.com/one-aalam/astro-ink), [Sarissa Blog](https://github.com/iozcelik/SarissaBlogAstroStarter), [Blog Tecnológico de Astro](https://github.com/nicdun/astro-tech-blog) y [Creek](https://github.com/robertguss/Astro-Theme-Creek) usan Tailwind para el estilado
-* ¡[Explora proyectos de Astro Tailwind en Github](https://github.com/search?q=%22%40astrojs%2Ftailwind%22%3A+path%3A%2Fpackage.json\&type=code) para más ejemplos!
-
-## Solución de problemas
-
-### Las clases no existen con las directivas `@apply`
-
-Cuando se usa la directiva `@apply` en una etiqueta `<style>` de integración de Astro, Vue, Svelte u otro componente, puede generar errores sobre la clase personalizada de Tailwind que no existe y causar que su compilación falle.
-
-```sh
-error   The `text-special` class does not exist. If `text-special` is a custom class, make sure it is defined within a `@layer` directive.
-```
-
-[En lugar de usar directivas `@layer` en una hoja de estilo global](https://tailwindcss.com/docs/functions-and-directives#using-apply-with-per-component-css), define tus estilos personalizados agregando un complemento a tu configuración de Tailwind para arreglarlo:
-
-```js title="tailwind.config.mjs"
-export default {
-  // ...
-  plugins: [
-    function ({ addComponents, theme }) {
-      addComponents({
-        '.btn': {
-          padding: theme('spacing.4'),
-          margin: 'auto',
-        },
-      });
-    },
-  ],
-};
-```
-
-### Los modificadores basados en clases no funcionan con las directivas `@apply`
-
-Ciertas clases de Tailwind con modificadores dependen de combinar clases en varios elementos. Por ejemplo, `group-hover:text-gray` se compila en `.group:hover .text-gray`. Cuando se usa con la directiva `@apply` en las etiquetas `<style>` de Astro, los estilos compilados se eliminan de la salida de compilación porque no coinciden con ningún marcado en el archivo `.astro`. También puede ocurrir el mismo problema en componentes de framework que admiten estilos con alcance local como Vue y Svelte.
-
-Para arreglar esto, puedes usar clases en línea en su lugar:
-
-```html "text-black group-hover:text-gray"
-<p class="text-black group-hover:text-gray">Astro</p>
-```
-
-### Otros
-
-* Si tu instalación no parece estar funcionando, intenta reiniciar el servidor de desarrollo.
-* Si editas y guardas un archivo y no ves que tu sitio se actualice en consecuencia, intenta actualizar la página.
-* Si al refrescar la página no se actualiza tu vista previa, o si una nueva instalación no parece estar funcionando, reinicia el servidor de desarrollo.
-
-Para obtener ayuda, consulta el canal `#support` en [Discord](https://astro.build/chat). ¡Nuestros amables miembros del Equipo de Soporte están aquí para ayudarte!
-
-También puedes consultar nuestra [Documentación de Integración de Astro][astro-integration] para obtener más información sobre las integraciones.
-
-[astro-integration]: /es/guides/integrations-guide/
-
-[astro-ui-frameworks]: /es/guides/framework-components/#usando-componente-de-framework
diff --git a/src/content/docs/es/guides/integrations-guide/vercel.mdx b/src/content/docs/es/guides/integrations-guide/vercel.mdx
deleted file mode 100644
index 4d5d68af7a146..0000000000000
--- a/src/content/docs/es/guides/integrations-guide/vercel.mdx
+++ /dev/null
@@ -1,439 +0,0 @@
----
-type: integration
-title: '@astrojs/vercel'
-description: Aprende como usar el adaptador SSR @astrojs/vercel para desplegar tu proyecto de Astro.
-githubIntegrationURL: 'https://github.com/withastro/astro/tree/main/packages/integrations/vercel/'
-category: adapter
-i18nReady: true
----
-import PackageManagerTabs from '~/components/tabs/PackageManagerTabs.astro';
-import Since from '~/components/Since.astro';
-import ReadMore from '~/components/ReadMore.astro'
-
-Este adaptador permite a Astro desplegar tu [sitio renderizado en modo `hybrid` o `server`](/es/guides/on-demand-rendering/) a [Vercel](https://www.vercel.com/).
-
-Si utilizas Astro como un generador de sitios estáticos, sólo necesitarás este adaptador si utilizas servicios adicionales de Vercel (por ejemplo, [Vercel Web Analytics](https://vercel.com/docs/analytics), [Vercel Image Optimization](https://vercel.com/docs/image-optimization)). De lo contrario, no necesita un adaptador para desplegar su sitio `static`.
-
-Aprende a desplegar tu sitio de Astro consultando nuestra [guía de despliegue en Vercel](/es/guides/deploy/vercel/).
-
-## ¿Por qué Astro Vercel?
-
-[Vercel](https://www.vercel.com/) es una plataforma de despliegue que te permite alojar tu proyecto conectándote directamente a tu repositorio de GitHub. Este adaptador ajusta el proceso de compilación de Astro para preparar tu proyecto para el despliegue a través de Vercel.
-
-## Instalación
-
-Astro incluye el comando `astro add` para automatizar la instalación de integraciones oficiales. Si lo prefieres, puedes [instalar las integraciones manualmente](#instalación-manual).
-
-Agrega el adaptador Vercel para habilitar SSR en tu proyecto de Astro con el siguiente comando `astro add`. Esto instalará `@astrojs/vercel` y hará los cambios apropiados en tu archivo `astro.config.mjs` en un solo paso.
-
-<PackageManagerTabs>
-  <Fragment slot="npm">
-    ```sh
-    npx astro add vercel
-    ```
-  </Fragment>
-  <Fragment slot="pnpm">
-    ```sh
-    pnpm astro add vercel
-    ```
-  </Fragment>
-  <Fragment slot="yarn">
-    ```sh
-    yarn astro add vercel
-    ```
-  </Fragment>
-</PackageManagerTabs>
-
-### Instalación manual
-
-En primer lugar, añade el adaptador `@astrojs/vercel` a las dependencias de tu proyecto utilizando tu gestor de paquetes preferido:
-
-<PackageManagerTabs>
-  <Fragment slot="npm">
-    ```sh
-    npm install @astrojs/vercel
-    ```
-  </Fragment>
-  <Fragment slot="pnpm">
-    ```sh
-    pnpm add @astrojs/vercel
-    ```
-  </Fragment>
-  <Fragment slot="yarn">
-    ```sh
-    yarn add @astrojs/vercel
-    ```
-  </Fragment>
-</PackageManagerTabs>
-
-A continuación, añade el adaptador y el [modo de renderizado bajo demanda](/es/guides/on-demand-rendering/) que deseas a tu archivo `astro.config.*`:
-
-```js title="astro.config.mjs" ins={2, 6-7}
-import { defineConfig } from 'astro/config';
-import vercel from '@astrojs/vercel/serverless';
-
-export default defineConfig({
-  // ...
-  output: 'server',
-  adapter: vercel(),
-});
-```
-
-### Objetivos
-
-Puedes desplegar en diferentes objetivos:
-
-* `serverless`: SSR dentro de una [función Node.js](https://vercel.com/docs/concepts/functions/serverless-functions).
-* `static`: genera un sitio estático siguiendo los formatos de salida, redirecciones, etc. de Vercel.
-
-Puedes cambiar el destino modificando la importación:
-
-```js "serverless" "static"
-import vercel from '@astrojs/vercel/serverless';
-import vercel from '@astrojs/vercel/static';
-```
-
-## Uso
-
-<ReadMore>[Lee la guía completa para despliegue aquí.](/es/guides/deploy/vercel/)</ReadMore>
-
-Puedes desplegar por CLI (`vercel deploy`) o conectando tu nuevo repositorio en el [Panel de Vercel](https://vercel.com/). Alternativamente, puedes crear un build de producción localmente:
-
-```sh
-astro build
-vercel deploy --prebuilt
-```
-
-## Configuración
-
-Para configurar este adaptador, pasa un objeto a la invocación de función `vercel()` en `astro.config.mjs`:
-
-### `webAnalytics`
-
-**Tipo:** `VercelWebAnalyticsConfig`<br/>
-**Disponible para:** Serverless, Static<br/>
-<Since v="3.8.0" pkg="@astrojs/vercel" />
-
-Puedes habilitar [Vercel Analytics](https://vercel.com/docs/analytics) (incluyendo Web Vitals y Audiences) configurando `webAnalytics: { enabled: true }`. Esto inyectará los scripts de seguimiento de Vercel en todas tus páginas.
-
-```js title="astro.config.mjs" ins={8-10}
-import { defineConfig } from 'astro/config';
-import vercel from '@astrojs/vercel/serverless';
-
-export default defineConfig({
-  // ...
-  output: 'server',
-  adapter: vercel({
-    webAnalytics: {
-      enabled: true,
-    },
-  }),
-});
-```
-
-### `imagesConfig`
-
-**Tipo:** `VercelImageConfig`<br/>
-**Disponible para:** Serverless, Static
-<Since v="3.3.0" pkg="@astrojs/vercel" />
-
-Opciones de configuración para la [API de Optimización de Imágenes de Vercel](https://vercel.com/docs/concepts/image-optimization). Consulta la [documentación de configuración de imágenes de Vercel](https://vercel.com/docs/build-output-api/v3/configuration#images) para obtener una lista completa de los parámetros admitidos.
-
-Las propiedades `domains` y `remotePatterns` se llenarán automáticamente utilizando [la configuración correspondiente de `image` en Astro](/es/reference/configuration-reference/#opciones-de-imagen).
-
-```js title="astro.config.mjs" ins={8-10}
-import { defineConfig } from 'astro/config';
-import vercel from '@astrojs/vercel/static';
-
-export default defineConfig({
-  // ...
-  output: 'static',
-  adapter: vercel({
-    imagesConfig: {
-      sizes: [320, 640, 1280],
-    },
-  }),
-});
-```
-
-### `imageService`
-
-**Tipo:** `boolean`<br/>
-**Disponible para:** Serverless y Static
-<Since v="3.3.0" pkg="@astrojs/vercel" />
-
-Cuando está habilitado, se configurará y utilizará automáticamente un [Servicio de Imágenes](/es/reference/image-service-reference/) impulsado por la API de Optimización de Imágenes de Vercel en producción. En desarrollo, el servicio de imágenes especificado por [`devImageService`](#devimageservice) se utilizará en su lugar.
-
-```js title="astro.config.mjs" ins={8}
-import { defineConfig } from 'astro/config';
-import vercel from '@astrojs/vercel/static';
-
-export default defineConfig({
-  // ...
-  output: 'static',
-  adapter: vercel({
-    imageService: true,
-  }),
-});
-```
-
-```astro
----
-import { Image } from 'astro:assets';
-import astroLogo from ''../assets/logo.png';
----
-<!-- Este componente -->
-<Image src={astroLogo} alt="My super logo!" />
-<!-- se convertirá en el siguiente elemento de HTML -->
-<img
-  src="/_vercel/image?url=_astro/logo.hash.png&w=...&q=..."
-  alt="Mi super logo!"
-  loading="lazy"
-  decoding="async"
-  width="..."
-  height="..."
-/>
-```
-
-### `devImageService`
-
-**Tipo:** `'sharp' | 'squoosh' | string`<br/>
-**Disponible para:** Serverless, Static
-<Since v="3.8.0" pkg="@astrojs/vercel" />
-**Por defecto**: `sharp`
-
-Te permite configurar qué servicio de imágenes usar en desarrollo cuando [imageService](#imageservice) está habilitado. Esto puede ser útil si no puedes instalar las dependencias de Sharp en tu máquina de desarrollo, pero usar otro servicio de imágenes como Squoosh te permitiría previsualizar imágenes en tu entorno de desarrollo. La compilación no se ve afectada y siempre usará la Optimización de Imágenes de Vercel.
-
-También puede establecerse en cualquier valor arbitrario para usar un servicio de imágenes personalizado en lugar de los integrados en Astro.
-
-```js title="astro.config.mjs" ins={8-9}
-import { defineConfig } from 'astro/config';
-import vercel from '@astrojs/vercel/serverless';
-
-export default defineConfig({
-  // ...
-  output: 'server',
-  adapter: vercel({
-    imageService: true,
-    devImageService: 'squoosh',
-  }),
-});
-```
-
-### `isr`
-
-**Tipo:** <code>boolean |   VercelISRConfig</code><br/>
-**Disponible para:** Serverless
-<Since v="7.2.0" pkg="@astrojs/vercel" />
-**Por defecto**: `false`
-
-Permite desplegar tu proyecto como una función de [ISR (Regeneración Estática Incremental)](https://vercel.com/docs/incremental-static-regeneration), que almacena en caché tus páginas renderizadas bajo demanda de la misma manera que las páginas prerenderizadas después de la primera solicitud.
-
-Para habilitar esta característica, establece `isr` en `true` en la configuración del adaptador de Vercel en `astro.config.mjs`:
-
-```js title="astro.config.mjs" ins={8}
-import { defineConfig } from 'astro/config';
-import vercel from '@astrojs/vercel/serverless';
-
-export default defineConfig({
-  // ...
-  output: 'server',
-  adapter: vercel({
-    isr: true,
-  }),
-});
-```
-
-Toma en cuenta que las solicitudes de funciones ISR no incluyen parámetros de búsqueda, similar a las [solicitudes](/es/reference/api-reference/#astrorequest) en modo estático.
-
-#### Invalidación de caché de ISR
-
-Por defecto, una función ISR se almacena en caché durante la duración de tu despliegue. Puedes controlar aún más el almacenamiento en caché configurando un tiempo de expiración, o excluyendo rutas particulares del almacenamiento en caché por completo.
-
-##### Invalidación basada en el tiempo
-
-Puedes cambiar la duración del tiempo para almacenar en caché rutas configurando un valor de `expiration` en segundos:
-
-```js title="astro.config.mjs" {8-11}
-import { defineConfig } from 'astro/config';
-import vercel from '@astrojs/vercel/serverless';
-
-export default defineConfig({
-  // ...
-  output: 'server',
-  adapter: vercel({
-    isr: {
-      // almacena todas las páginas en la primera solicitud y las guarda por 1 día
-      expiration: 60 * 60 * 24,
-    },
-  }),
-});
-```
-
-##### Excluir rutas del almacenamiento en caché
-
-Para implementar el [modo borrador](https://vercel.com/docs/build-output-api/v3/features#draft-mode) de Vercel, o [Regeneración Estática Incremental bajo demanda (ISR)](https://vercel.com/docs/build-output-api/v3/features#on-demand-incremental-static-regeneration-isr), puedes crear un token de bypass y proporcionarlo a la configuración `isr` junto con cualquier ruta para excluir del almacenamiento en caché:
-
-```js title="astro.config.mjs" {7-12}
-import { defineConfig } from 'astro/config';
-import vercel from '@astrojs/vercel/serverless';
-
-export default defineConfig({
-    output: "server",
-    adapter: vercel({
-        isr: {
-            // Un string aleatoria secreta que creas.
-            bypassToken: "005556d774a8",
-            // Rutas que siempre se servirán frescas.
-            exclude: [ "/api/invalidate", "/posts/[...slug]" ]
-        }
-    })
-})
-```
-
-### `includeFiles`
-
-**Tipo:** `string[]`<br/>
-**Disponible para:** Serverless
-
-Usa esta propiedad para forzar a que los archivos se incluyan en el empaquetado de tu función. Esto es útil cuando notas que faltan archivos.
-
-```js title="astro.config.mjs" ins={8}
-import { defineConfig } from 'astro/config';
-import vercel from '@astrojs/vercel/serverless';
-
-export default defineConfig({
-  // ...
-  output: 'server',
-  adapter: vercel({
-    includeFiles: ['./my-data.json'],
-  }),
-});
-```
-
-### `excludeFiles`
-
-**Tipo:** `string[]`<br/>
-**Disponible para:** Serverless
-
-Utiliza esta propiedad para excluir cualquier archivo del proceso de empaquetado que de otra manera se incluiría.
-
-```js title="astro.config.mjs" ins={8}
-import { defineConfig } from 'astro/config';
-import vercel from '@astrojs/vercel/serverless';
-
-export default defineConfig({
-  // ...
-  output: 'server',
-  adapter: vercel({
-    excludeFiles: ['./src/some_big_file.jpg'],
-  }),
-});
-```
-
-### `maxDuration`
-
-**Tipo:** `number`<br/>
-**Disponible para:** Serverless
-
-Usa esta propiedad para extender o limitar la duración máxima (en segundos) que pueden ejecutarse las funciones sin servidor antes de agotar el tiempo de espera. Consulta la [documentación de Vercel](https://vercel.com/docs/functions/serverless-functions/runtimes#maxduration) para conocer el límite predeterminado y máximo para el plan de tu cuenta.
-
-```js title="astro.config.mjs" ins={8}
-import { defineConfig } from 'astro/config';
-import vercel from '@astrojs/vercel/serverless';
-
-export default defineConfig({
-// ...
-  output: "server",
-  adapter: vercel({
-    maxDuration: 60
-  }),
-});
-```
-
-### `skewProtection`
-
-**Tipo:** `boolean`<br/>
-**Disponible para:** Serverless
-<Since pkg="@astrojs/vercel" v="7.6.0" />
-
-Usa esta propiedad para habilitar la [protección de sesgo de Vercel](https://vercel.com/docs/deployments/skew-protection) (disponible con cuentas Pro y Enterprise de Vercel).
-
-```js title="astro.config.mjs" ins={8}
-import { defineConfig } from 'astro/config';
-import vercel from '@astrojs/vercel/serverless';
-
-export default defineConfig({
-// ...
-  output: "server",
-  adapter: vercel({
-    skewProtection: true
-  }),
-});
-```
-
-### Configuración de agrupación de funciones
-
-El adaptador de Vercel combina todas tus rutas en una única función por defecto.
-
-También tienes la opción de dividir las compilaciones en una función separada para cada ruta usando la opción `functionPerRoute`. Esto reduce el tamaño de cada función, lo que significa que es menos probable que excedas el límite de tamaño para una función individual. Además, el código se inicia más rápido.
-
-Verifica que tu plan de Vercel incluya un número adecuado de funciones antes de habilitar `functionPerRoute`. Por ejemplo, el nivel gratuito de Vercel limita cada despliegue a no más de 12 funciones. Si tu plan de Vercel es insuficiente para el número de rutas en tu proyecto, recibirás un mensaje de error durante el despliegue.
-
-```js title="astro.config.mjs" ins={8}
-import { defineConfig } from 'astro/config';
-import vercel from '@astrojs/vercel/serverless';
-
-export default defineConfig({
-  // ...
-  output: 'server',
-  adapter: vercel({
-    functionPerRoute: true,
-  }),
-});
-```
-
-### Ejecutar el middleware de Astro en funciones de Vercel Edge
-
-El adaptador `@astrojs/vercel/serverless` puede crear una [función edge](https://vercel.com/docs/functions/edge-functions) a partir de un middleware de Astro en tu base de código. Cuando `edgeMiddleware` está habilitado, una función edge ejecutará tu código de middleware para todas las solicitudes, incluyendo activos estáticos, páginas prerrenderizadas y páginas renderizadas bajo demanda.
-
-Para páginas renderizadas bajo demanda, el objeto `context.locals` se serializa usando JSON y se envía en un encabezado para la función serverless, que realiza la renderización. Como medida de seguridad, la función serverless se negará a servir solicitudes con una respuesta `403 Forbidden` a menos que provengan de la función edge generada.
-
-Esta es una característica opcional. Para habilitarla, establece `edgeMiddleware` en `true`:
-
-```js title="astro.config.mjs" "edgeMiddleware: true"
-import { defineConfig } from 'astro/config';
-import vercel from '@astrojs/vercel/serverless';
-
-export default defineConfig({
-  // ...
-  output: 'server',
-  adapter: vercel({
-    edgeMiddleware: true,
-  }),
-});
-```
-
-El middleware edge tiene acceso al [`RequestContext`](https://vercel.com/docs/functions/edge-middleware/middleware-api#requestcontext) de Vercel como `ctx.locals.vercel.edge`. Si estás utilizando TypeScript, puedes obtener tipos adecuados actualizando `src/env.d.ts` para utilizar `EdgeLocals`:
-
-```ts
-/// <reference path="../.astro/types.d.ts" />
-/// <reference types="astro/client" />
-
-type EdgeLocals = import('@astrojs/vercel').EdgeLocals
-
-declare namespace App {
-  interface Locals extends EdgeLocals {
-    // ...
-  }
-}
-```
-
-### Soporte de versiones de Node.js
-
-El adaptador `@astrojs/vercel` admite versiones específicas de Node.js para desplegar tu proyecto de Astro en Vercel. Para ver las versiones de Node.js admitidas en Vercel, haz clic en la pestaña de configuración de un proyecto y desplázate hacia abajo hasta la sección "Versión de Node.js".
-
-Consulta la [documentación de Vercel](https://vercel.com/docs/functions/serverless-functions/runtimes/node-js#default-and-available-versions) para obtener más información.
-
-
-[astro-integration]: /es/guides/integrations-guide/
diff --git a/src/content/docs/es/guides/integrations-guide/vue.mdx b/src/content/docs/es/guides/integrations-guide/vue.mdx
deleted file mode 100644
index 490c81af204f6..0000000000000
--- a/src/content/docs/es/guides/integrations-guide/vue.mdx
+++ /dev/null
@@ -1,233 +0,0 @@
----
-type: integration
-title: '@astrojs/vue'
-description: Aprende a usar la integración de framework @astrojs/vue para extender el soporte de componentes en tu proyecto Astro.
-githubIntegrationURL: 'https://github.com/withastro/astro/tree/main/packages/integrations/vue/'
-category: renderer
-i18nReady: true
----
-import PackageManagerTabs from '~/components/tabs/PackageManagerTabs.astro';
-import Since from '~/components/Since.astro';
-
-Esta **[integración de Astro][astro-integration]** permite el renderizado del lado del servidor y la hidratación del lado del cliente para tus componentes [Vue 3](https://vuejs.org/).
-
-## Instalación
-
-Astro incluye un comando `astro add` para automatizar la configuración de las integraciones oficiales. Si lo prefieres, puedes [instalar las integraciones manualmente](#instalación-manual) en su lugar.
-
-Para instalar `@astrojs/vue`, ejecuta lo siguiente desde el directorio de proyecto y sigue las instrucciones:
-
-<PackageManagerTabs>
-  <Fragment slot="npm">
-  ```sh
-  npx astro add vue
-  ```
-  </Fragment>
-  <Fragment slot="pnpm">
-  ```sh
-  pnpm astro add vue
-  ```
-  </Fragment>
-  <Fragment slot="yarn">
-  ```sh
-  yarn astro add vue
-  ```
-  </Fragment>
-</PackageManagerTabs>
-
-Si tienes algún problema, [no dudes en informarnos en GitHub](https://github.com/withastro/astro/issues) e intenta los pasos de instalación manual a continuación.
-
-### Instalación manual
-
-Primero, instala el paquete `@astrojs/vue`:
-
-<PackageManagerTabs>
-  <Fragment slot="npm">
-  ```sh
-  npm install @astrojs/vue
-  ```
-  </Fragment>
-  <Fragment slot="pnpm">
-  ```sh
-  pnpm add @astrojs/vue
-  ```
-  </Fragment>
-  <Fragment slot="yarn">
-  ```sh
-  yarn add @astrojs/vue
-  ```
-  </Fragment>
-</PackageManagerTabs>
-
-
-La mayoría de los gestores de paquetes también instalarán las dependencias asociadas.  Sin embargo, si ves un aviso "No se puede encontrar el paquete 'vue'" (o similar) al iniciar Astro, tendrás que instalar Vue:
-
-<PackageManagerTabs>
-  <Fragment slot="npm">
-  ```sh
-  npm install vue
-  ```
-  </Fragment>
-  <Fragment slot="pnpm">
-  ```sh
-  pnpm add vue
-  ```
-  </Fragment>
-  <Fragment slot="yarn">
-  ```sh
-  yarn add vue
-  ```
-  </Fragment>
-</PackageManagerTabs>
-
-Luego, aplica la integración a tu archivo `astro.config.*` usando la propiedad `integrations`:
-
-```js ins={2} ins="vue()" title="astro.config.mjs"
-import { defineConfig } from 'astro/config';
-import vue from '@astrojs/vue';
-
-export default defineConfig({
-  // ...
-  integrations: [vue()],
-});
-```
-
-## Empezando
-
-Para usar tu primer componente Vue en Astro, dirígete a nuestra [documentación de frameworks UI][astro-ui-frameworks]. Explorarás:
-
-* 📦 como se cargan los componentes de framework,
-* 💧 opciones de hidratación del lado del cliente, y
-* 🤝 oportunidades para mezclar y anidar frameworks juntos
-
-## Solución de problemas
-
-Para obtener ayuda, consulta el canal `#support` en [Discord](https://astro.build/chat). ¡Nuestros amables miembros del Equipo de Soporte están aquí para ayudar!
-
-También puedes consultar nuestra [documentación de integración de Astro][astro-integration] para obtener más información sobre las integraciones.
-
-## Contribuyendo
-
-Este paquete es mantenido por el equipo central de Astro. ¡Estás invitado a enviar un problema o PR!
-
-[astro-integration]: /es/guides/integrations-guide/
-
-[astro-ui-frameworks]: /es/guides/framework-components/#usando-componente-de-framework
-
-## Opciones
-
-Esta integración está impulsada por `@vitejs/plugin-vue`. Para personalizar el compilador de Vue, se pueden proporcionar opciones a la integración. Consulta la [documentación](https://www.npmjs.com/package/@vitejs/plugin-vue) de `@vitejs/plugin-vue` para obtener más detalles.
-
-```js title="astro.config.mjs"
-import { defineConfig } from 'astro/config';
-import vue from '@astrojs/vue';
-
-export default defineConfig({
-  // ...
-  integrations: [
-    vue({
-    template: {
-      compilerOptions: {
-        // trata cualquier etiqueta que comience con ion- como elementos personalizados
-        isCustomElement: tag => tag.startsWith('ion-'),
-      },
-    },
-    // ...
-    }),
-  ],
-});
-```
-
-### appEntrypoint
-
-Puedes extender la instancia de Vue `app` configurando la opción `appEntrypoint` a un especificador de importación relativo a la raíz (por ejemplo, `appEntrypoint: "/src/pages/_app"`).
-
-La exportación predeterminada de este archivo debe ser una función que acepte una instancia de Vue `App` antes de la representación, lo que permite el uso de [plugins Vue personalizados](https://vuejs.org/guide/reusability/plugins.html), `app.use` y otras personalizaciones para casos de uso avanzados.
-
-```js title="astro.config.mjs"
-import { defineConfig } from 'astro/config';
-import vue from '@astrojs/vue';
-
-export default defineConfig({
-  integrations: [vue({ appEntrypoint: '/src/pages/_app' })],
-});
-```
-
-```ts title="src/pages/_app.ts"
-import type { App } from 'vue';
-import i18nPlugin from 'my-vue-i18n-plugin';
-
-export default (app: App) => {
-  app.use(i18nPlugin);
-};
-```
-
-### jsx
-
-Puedes usar Vue JSX configurando `jsx: true`.
-
-```js title="astro.config.mjs"
-import { defineConfig } from 'astro/config';
-import vue from '@astrojs/vue';
-
-export default defineConfig({
-  // ...
-  integrations: [vue({ jsx: true })],
-});
-```
-
-Esto habilitará el renderizado para componentes Vue y Vue JSX. Para personalizar el compilador Vue JSX, pase un objeto de opciones en lugar de un valor booleano. Consulta la [documentación](https://www.npmjs.com/package/@vitejs/plugin-vue-jsx) de `@vitejs/plugin-vue-jsx` para obtener más detalles.
-
-```js title="astro.config.mjs"
-import { defineConfig } from 'astro/config';
-import vue from '@astrojs/vue';
-
-export default defineConfig({
-  // ...
-  integrations: [
-    vue({
-      jsx: {
-        // trata cualquiere etiqueta que comience con ion- como elementos personalizados
-        isCustomElement: (tag) => tag.startsWith('ion-'),
-      },
-    }),
-  ],
-});
-```
-
-### devtools
-
-<p><Since pkg="@astrojs/vue" v="4.2.0" /></p>
-
-Puedes habilitar [Vue DevTools](https://devtools-next.vuejs.org/) en desarrollo pasando un objeto con `devtools: true` a la configuración de tu integración `vue()`:
-
-```js title="astro.config.mjs"
-import { defineConfig } from 'astro/config';
-import vue from '@astrojs/vue';
-export default defineConfig({
-  // ...
-  integrations: [vue({ devtools: true })],
-});
-```
-
-#### Personalizando Vue DevTools
-
-<p><Since pkg="@astrojs/vue" v="4.3.0" /></p>
-
-Para más personalización, puedes pasar opciones que soporta el [Vue DevTools Vite Plugin](https://devtools-next.vuejs.org/guide/vite-plugin#options). (Nota: `appendTo` no es soportado.)
-
-Por ejemplo, puedes establecer `launchEditor` a tu editor preferido si no estás usando Visual Studio Code:
-
-```js title="astro.config.mjs"
-import { defineConfig } from "astro/config";
-import vue from "@astrojs/vue";
-
-export default defineConfig({
-  // ...
-  integrations: [
-    vue({
-      devtools: { launchEditor: "webstorm" },
-    }),
-  ],
-});
-```
diff --git a/src/content/docs/es/guides/internationalization.mdx b/src/content/docs/es/guides/internationalization.mdx
deleted file mode 100644
index 7217fa1ddce44..0000000000000
--- a/src/content/docs/es/guides/internationalization.mdx
+++ /dev/null
@@ -1,363 +0,0 @@
----
-title: Enrutamiento con Internationalización (i18n)
-description: Aprende a usar el enrutamiento i18n en Astro.
-i18nReady: true
----
-
-import { FileTree } from '@astrojs/starlight/components';
-import Since from '~/components/Since.astro'
-
-La internacionalización (i18n) de Astro te permite adaptar tu proyecto para una audiencia internacional. Esta API de enrutamiento te ayuda a generar, usar y verificar las URL que produce tu sitio multilingüe.
-
-Las rutas de i18n de Astro te permiten llevar tu contenido multilingüe con soporte para configurar un idioma predeterminado, calcular las URL de las páginas relativas y aceptar los idiomas preferidos proporcionados por el navegador de tus usuarios. También puedes especificar idiomas por defecto en función de cada idioma para que tus usuarios siempre puedan ser dirigidos un determinado tipo de contenido existente en tu sitio.
-
-## Lógica de enrutamiento
-
-Astro utiliza un [middleware](/es/guides/middleware/) para implementar su lógica de enrutamiento. Esta función de middleware se coloca en la [primera posición](/es/guides/middleware/#encadenando-el-middleware) donde espera cada `Response` que proviene de cualquier middleware adicional y de cada ruta antes de ejecutar finalmente su propia lógica.
-
-Esto significa que las operaciones (por ejemplo, redirecciones) de tu propio middleware y tu lógica de página se ejecutan primero, tus rutas se renderizan y luego el middleware de i18n realiza sus propias acciones, como verificar que una URL localizada corresponda a una ruta válida.
-
-También puedes optar por [agregar tu propia lógica i18n además o en lugar del middleware i18n de Astro](#manual), lo que te da aún más control sobre tus rutas mientras sigues teniendo acceso a las funciones de ayuda `astro:i18n`.
-
-## Configuración de rutas i18n
-
-Se deben especificar tanto un idioma predeterminado ([`defaultLocale`](/es/reference/configuration-reference/#i18ndefaultlocale)) como una lista de todos los idiomas admitidos ([`locales`](/es/reference/configuration-reference/#i18nlocales)) dentro de un objeto de configuración i18n.  Además, puedes configurar un comportamiento más específico de rutas y por defecto para que coincida con las URLs deseadas.
-
-```js title="astro.config.mjs"
-import { defineConfig } from "astro/config"
-export default defineConfig({
-  i18n: {
-    defaultLocale: "en",
-    locales: ["es", "en", "pt-br"],
-  }
-})
-```
-
-### Crear carpetas localizadas
-
-Organiza tus carpetas de contenido con contenido localizado por idioma. Crea carpetas individuales `/[locale]/` en cualquier lugar dentro de `src/pages/` y el [enrutamiento basado en archivos](/es/guides/routing/) de Astro creará tus páginas en rutas de URL correspondientes.
-
-
-Tu carpeta debe coincidir con los elementos de `locales` exactamente. Incluye una carpeta localizada para tu `defaultLocale` solo si configuras `prefixDefaultLocale: true` para mostrar una ruta de URL localizada para tu idioma predeterminado (por ejemplo, /en/about/).
-
-<FileTree>
-- src
-  - pages
-    - about.astro
-    - index.astro
-    - es
-      - about.astro
-      - index.astro
-    - pt-br
-      - about.astro
-      - index.astro
-</FileTree>
-
-:::note
-Las carpetas localizadas no necesitan estar en la raíz de la carpeta `/pages/`.
-:::
-
-### Crear enlaces
-
-Con el enrutamiento i18n configurado, ahora puedes calcular enlaces a páginas dentro de tu sitio utilizando las funciones de ayuda como [`getRelativeLocaleUrl()`](/es/reference/api-reference/#getrelativelocaleurl) disponibles en el módulo [`astro:i18n`](/es/reference/api-reference/#internacionalización-astroi18n). Estos enlaces generados siempre proporcionarán la ruta localizada correcta y pueden ayudarte a usar o verificar correctamente las URL en tu sitio.
-
-
-También puedes seguir escribiendo los enlaces manualmente.
-
-```astro title="src/pages/es/index.astro"
----
-import { getRelativeLocaleUrl } from 'astro:i18n';
-
-// defaultLocale es "es"
-const aboutURL = getRelativeLocaleUrl("es", "about");
----
-
-<a href="/get-started/">¡Vamos!</a>
-<a href={getRelativeLocaleUrl('es', 'blog')}>Blog</a>
-<a href={aboutURL}>Acerca</a> 
-``` 
-
-## `enrutamiento`
-
-El sistema de enrutamiento basado en archivos de Astro crea automáticamente rutas de URL para ti en función de la estructura de archivos dentro de `src/pages/`.
-
-Cuando configuras el enrutamiento i18n, la información sobre esta estructura de archivos (y las rutas de URL correspondientes generadas) está disponible para las funciones de ayuda de i18n para que puedan generar, usar y verificar las rutas en tu proyecto. Muchas de estas opciones se pueden usar juntas para obtener aún más personalización y flexibilidad por idioma.
-
-Puedes incluso optar por [implementar tu propia lógica de enrutamiento manualmente](#manual) para tener un control aún mayor.
-
-### `prefixDefaultLocale`
-
-<p><Since v="3.5.0" /></p>
-
-Esta opción de enrutamiento define si las URL de tu idioma predeterminado deben usar un prefijo de idioma (por ejemplo, `/en/about/`).
-
-Todos los idiomas admitidos que no sean el predeterminado **sí** usarán un prefijo localizado (por ejemplo, `/fr/` o `/french/`) y los archivos de contenido deben estar ubicados en carpetas apropiadas. Esta opción de configuración te permite especificar si tu idioma predeterminado también debe seguir una estructura de URL localizada.
-
-Esta configuración también determina dónde deben existir los archivos de página para tu idioma predeterminado (por ejemplo, `src/pages/about/` o `src/pages/en/about`) ya que la estructura de archivos y la estructura de URL deben coincidir para todos los idiomas.
-
-- `"prefixDefaultLocale: false"`: (por defecto): Las URL en tu idioma predeterminado **no** tendrán un prefijo `/[locale]/`. Todos los demás idiomas sí lo tendrán.
-
-- `"prefixDefaultLocale: true"`: Todas las URL, incluido tu idioma predeterminado, tendrán un prefijo `/[locale]/`.
-
-#### `prefixDefaultLocale: false`
-
-```js title="astro.config.mjs" ins={7}
-import { defineConfig } from "astro/config"
-export default defineConfig({
-  i18n: {
-    defaultLocale: "en",
-    locales: ["es", "en", "fr"],
-    routing: {
-        prefixDefaultLocale: false
-    }
-  }
-})
-```
-
-Esta es la **opción predeterminada**. Establece esta opción cuando las URL en tu idioma predeterminado **no** tendrán un prefijo `/[locale]/` y los archivos en tu idioma predeterminado existen en la raíz de `src/pages/`:
-
-<FileTree>
-  - src
-    - pages
-      - about.astro
-      - index.astro
-      - es
-        - about.astro
-        - index.astro
-      - fr
-        - about.astro
-        - index.astro
-</FileTree>
-
-- `src/pages/about.astro` producirá la ruta `example.com/about/`
-- `src/pages/fr/about.astro` producirá la ruta `example.com/fr/about/`
-
-
-#### `prefixDefaultLocale: true`
-
-```js title="astro.config.mjs" ins={7}
-import { defineConfig } from "astro/config"
-export default defineConfig({
-  i18n: {
-    defaultLocale: "en",
-    locales: ["es", "en", "fr"],
-    routing: {
-        prefixDefaultLocale: true
-    }
-  }
-})
-```
-
-Establece esta opción cuando todas las rutas tendrán su prefijo `/locale/` en su URL y cuando todos los archivos de contenido de la página, incluidos los de tu `defaultLocale`, existen en una carpeta localizada:
-
-<FileTree>
-    - src
-      - pages
-        - **index.astro** // Nota: este archivo es obligatorio
-        - en
-          - index.astro
-          - about.astro
-        - es
-          - about.astro
-          - index.astro
-        - pt-br
-          - about.astro
-          - index.astro
-  </FileTree>
-
-- Las URLs sin un prefijo de idioma (por ejemplo, `example.com/about/`) devolverán un código de estado 404 (no encontrado) a menos que especifiques una [estrategia de respaldo](#fallback).
-
-### `redirectToDefaultLocale`
-
-<p><Since v="4.2.0" /></p>
-
-Establece si la URL de inicio (`/`) generada por `src/pages/index.astro` se redirigirá a `/<defaultLocale>`.
-
-Configurando `prefixDefaultLocale: true` también establecerá automáticamente `redirectToDefaultLocale: true` en tu objeto de configuración de `routing`. De forma predeterminada, el archivo `src/pages/index.astro` requerido se redirigirá automáticamente a la página de inicio de tu idioma predeterminado.
-
-Puedes optar por no tener este comportamiento [configurando `redirectToDefaultLocale: false`](/es/reference/configuration-reference/#i18nroutingredirecttodefaultlocale). Esto te permite tener una página de inicio del sitio que existe fuera de la estructura de carpetas de idioma configurada.
-
-### `manual`
-
-<p><Since v="4.6.0" /></p>
-
-Cuando esta opción está habilitada, Astro **deshabilitará** su middleware i18n para que puedas implementar tu propia lógica personalizada. No se pueden configurar otras opciones de `routing` (por ejemplo, `prefixDefaultLocale`) con `routing: "manual"`.
-
-Serás responsable de escribir tu propia lógica de enrutamiento, o [ejecutar el middleware i18n de Astro manualmente](#middleware-function) junto con el tuyo.
-
-```js title="astro.config.mjs"
-import { defineConfig } from "astro/config"
-export default defineConfig({
-  i18n: {
-    defaultLocale: "en",
-    locales: ["es", "en", "fr"],
-    routing: "manual"
-  }
-})
-```
-
-Astro proporciona funciones de ayuda para tu middleware para que puedas controlar tu propio enrutamiento predeterminado, excepciones, comportamiento de fallback, captura de errores, etc: [`redirectToDefaultLocale()`](/es/reference/api-reference/#redirecttodefaultlocale), [`notFound()`](/es/reference/api-reference/#notfound) y [`redirectToFallback()`](/es/reference/api-reference/#redirecttofallback):
-
-
-```js title="src/middleware.js"
-import { defineMiddleware } from "astro:middleware";
-import { redirectToDefaultLocale } from "astro:i18n"; // función disponible con enrutamiento `manual`
-export const onRequest = defineMiddleware(async (ctx, next) => {
-  if (ctx.url.startsWith("/about")) {
-    return next();
-  } else {
-    return redirectToDefaultLocale(302);
-  }
-})
-```
-
-#### middleware function
-
-La función [`middleware`](#middleware-function) crea manualmente el middleware i18n de Astro. Esto te permite extender el enrutamiento i18n de Astro en lugar de reemplazarlo por completo.
-
-Tú puedes ejecutar `middleware` con [opciones de enrutamiento](#enrutamiento) en combinación con tu propio middleware, utilizando la utilidad [`sequence`](/es/reference/api-reference/#sequence) para determinar el orden:
-
-```js title="src/middleware.js"
-import {defineMiddleware, sequence} from "astro:middleware";
-import { middleware } from "astro:i18n"; // El propio enrutamiento i18n de Astro
-
-export const userMiddleware = defineMiddleware(async (ctx, next) => {
-  // esta respuesta podría provenir del middleware i18n de Astro, y podría devolver un 404
-  const response = await next();
-  // la página /about es una excepción y queremos renderizarla
-  if (ctx.url.startsWith("/about")) {
-    return new Response("About page", {
-      status: 200
-    });
-  } else {
-    return response;
-  }
-});
-
-
-export const onRequest = sequence(
-  userMiddleware,
-  middleware({
-    redirectToDefaultLocale: false,
-    prefixDefaultLocale: true
-  })
-)
-```
-
-## `domains`
-
-<p><Since v="4.9.0" /></p>
-
-Esta opción de enrutamiento te permite personalizar tus dominios en función de cada idioma para proyectos renderizados en `server` utilizando el adaptador [`@astrojs/node`](/es/guides/integrations-guide/node/) o [`@astrojs/vercel`](/es/guides/integrations-guide/vercel/) con un `site` configurado.
-
-Esto es útil si admites múltiples variaciones de un idioma (por ejemplo, `"fr"`, `"fr-BR"` y `"fr-CA"`) y deseas tener todas estas variaciones mapeadas bajo la misma URL `/fr/`, o incluso personalizarla por completo (por ejemplo, `/french/`):
-
-Agrega `i18n.domains` para mapear cualquiera de tus `locales` admitidos a URLs personalizadas:
-
-```js title="astro.config.mjs" {3-7} ins={14-21}
-import { defineConfig } from "astro/config"
-export default defineConfig({
-  site: "https://example.com",
-  output: "server",  // obligatorio, cuando no hay páginas prerenderizadas
-  adapter: node({
-    mode: 'standalone',
-  }),
-  i18n: {
-    defaultLocale: "en",
-    locales: ["es", "en", "fr", "ja"],
-    routing: {
-      prefixDefaultLocale: false
-    },
-    domains: {
-        fr: "https://fr.example.com",
-        es: "https://example.es"
-    }
-  }
-})
-```
-
-Todos los `locales` no mapeados seguirán tu configuración de `prefixDefaultLocales`. Sin embargo, incluso si este valor es `false`, los archivos de página para tu `defaultLocale` también deben existir dentro de una carpeta localizada. Para la configuración anterior, se requiere una carpeta `/en/`.
-
-Con la configuración anterior:
-
-- El archivo `/fr/about.astro` creará la URL `https://fr.example.com/about`.
-- El archivo `es/about.astro` creará la URL `https://example.es/about`.
-- El archivo `/ja/about.astro` creará la URL `https://example.com/ja/about`.
-- El archivo `/en/about.astro` creará la URL `https://example.com/about`.
-
-Los URL anteriores también serán devueltos por las funciones `getAbsoluteLocaleUrl()` y `getAbsoluteLocaleUrlList()`.
-
-## `fallback`
-
-El sistema de rutas i18n de Astro permite configurar **una estrategia de respaldo**.  Cuando una página en un idioma no existe (por ejemplo, una página que aún no está traducida), en lugar de mostrar una página de error 404, puedes redirigir a un usuario de un idioma a otro según el idioma.  Esto es útil cuando aún no tienes una página para cada ruta, pero deseas seguir ofreciendo contenido a tus visitantes.
-
-Por ejemplo, la configuración a continuación establece `es` como el idioma de respaldo para cualquier ruta `fr` que falte. Esto significa que un usuario que visite `example.com/fr/mi-pagina/` será redirigido y se le mostrará el contenido de `example.com/es/mi-pagina/` en lugar de ser llevado a una página 404 cuando `src/pages/fr/mi-pagina.astro` no existe.
-
-```js title="astro.config.mjs" ins={6-8} 
-import { defineConfig } from "astro/config"
-export default defineConfig({
-  i18n: {
-    defaultLocale: "en",
-    locales: ["es", "en", "fr"],
-    fallback: {
-      fr: "es"  
-    }
-  }
-})
-```
-Astro se asegurará de que se cree una página en `src/pages/fr` para cada página que exista en `src/pages/es/`. Si la página no existe, se creará una página con una redirección a la ruta `es` correspondiente.
-
-## Rutas de idioma personalizadas
-
-Además de definir los `locales` admitidos por tu sitio como cadenas (por ejemplo, "en", "pt-br"), Astro también te permite mapear un número arbitrario de [códigos de idioma reconocidos por el navegador](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Accept-Language#syntax) a una `ruta` URL personalizada. Mientras que los `locales` pueden ser cadenas de cualquier formato siempre que correspondan a la estructura de carpetas de tu proyecto, los `códigos` deben seguir la sintaxis aceptada por el navegador.
-
-Pasa un objeto al array `locales` con una clave `path` para definir un prefijo de URL personalizado, y `codes` para indicar los idiomas mapeados a esta URL. En este caso, el nombre de la carpeta `/[locale]/` debe coincidir exactamente con el valor de `path` y tus URLs se generarán utilizando el valor de `path`.
-
-Esto es útil si admites múltiples variaciones de un idioma (por ejemplo, `"fr"`, `"fr-BR"` y `"fr-CA"`) y deseas tener todas estas variaciones mapeadas bajo la misma URL `/fr/`, o incluso personalizarla por completo (por ejemplo, `/french/`):
-
-```js title="astro.config.mjs" del={5} ins={6-9}
-import { defineConfig } from "astro/config"
-export default defineConfig({
-  i18n: {
-    defaultLocale: "en",
-    locales: ["es", "en", "fr"],
-    locales: ["es", "en", {
-        path: "french", // no slashes included
-        codes: ["fr", "fr-BR", "fr-CA"]
-    }],
-    routing: {
-        prefixDefaultLocale: true
-    }
-})
-```
-
-Cuando uses funciones del [módulo virtual `astro:i18n`](/es/reference/api-reference/#internacionalización-astroi18n) para computar rutas de URL válidas basadas en tu configuración (por ejemplo, `getRelativeLocaleUrl()`), [usa el `path` como valor para `locale`](/es/reference/api-reference/#getlocalebypath).
-
-#### Limitaciones
-
-Esta característica tiene algunas restricciones:
-- La opción `site` es obligatoria.
-- La opción `output` debe estar configurada en `"server"`.
-- No puede haber páginas prerenderizadas individuales.
-- La característica del adaptador [`functionPerRoute`](/es/reference/adapter-reference/#functionperroute) no es admitida.
-Astro depende de los siguientes encabezados para admitir la función:
-- [`X-Forwarded-Host`](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/X-Forwarded-Host) y [`Host`](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Host). Astro usará el primero, y si no está presente, intentará el segundo.
-- [`X-Forwarded-Proto`](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/X-Forwarded-Proto) y [`URL#protocol`](https://developer.mozilla.org/en-US/docs/Web/API/URL/protocol) de la solicitud del servidor.
-Asegúrate de que tu servidor proxy/plataforma de alojamiento pueda proporcionar esta información. Si no se pueden recuperar estos encabezados, se mostrará una página 404 (código de estado).
-
-## Detección de idioma del navegador
-
-El enrutamiento i18n de Astro te permite acceder a dos propiedades para la detección del idioma del navegador en las páginas renderizadas bajo demanda: `Astro.preferredLocale` y `Astro.preferredLocaleList`. Todas las páginas, incluidas las páginas prerenderizadas estáticamente, tienen acceso a `Astro.currentLocale`.
-
-Estas propiedades combinan el encabezado `Accept-Language` del navegador y tus `locales` (cadenas o `codes`) para respetar automáticamente los idiomas preferidos de tus visitantes.
-
-- [`Astro.preferredLocale`](/es/reference/api-reference/#astropreferredlocale):  Astro puede computar un **idioma preferido** para tu visitante si el idioma preferido de su navegador está incluido en tu array `locales`. Este valor es `undefined` si no existe tal coincidencia.
-
-- [`Astro.preferredLocaleList`](/es/reference/api-reference/#astropreferredlocalelist): Un array de todos los idiomas que son solicitados por el navegador y admitidos por tu sitio web. Esto produce una lista de todos los idiomas compatibles entre tu sitio y tu visitante. El valor es `[]` si ninguno de los idiomas solicitados por el navegador se encuentra en tu array `locales`. Si el navegador no especifica ningún idioma preferido, entonces este valor será [`i18n.locales`].
-
-- [`Astro.currentLocale`](/es/reference/api-reference/#astrocurrentlocale): El idioma computado a partir de la URL actual, utilizando la sintaxis especificada en tu configuración `locales`. Si la URL no contiene un prefijo `/[locale]/`, entonces el valor se establecerá en [`i18n.defaultLocale`](/es/reference/configuration-reference/#i18ndefaultlocale).
-
-Para que coincidan correctamente con las preferencias de tus visitantes, proporciona tus `codes` utilizando el mismo patrón [utilizado por el navegador](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Accept-Language#syntax).
-
-[`site`]: /es/reference/configuration-reference/#site
-[`i18n.locales`]: /es/reference/configuration-reference/#i18nlocales
diff --git a/src/content/docs/es/guides/markdown-content.mdx b/src/content/docs/es/guides/markdown-content.mdx
deleted file mode 100644
index 2551f9fa58306..0000000000000
--- a/src/content/docs/es/guides/markdown-content.mdx
+++ /dev/null
@@ -1,677 +0,0 @@
----
-title: Markdown y MDX
-description: Aprende a crear contenido usando Markdown o MDX en Astro
-i18nReady: true
----
-import { FileTree } from '@astrojs/starlight/components';
-import Since from '~/components/Since.astro';
-import RecipeLinks from "~/components/RecipeLinks.astro";
-import ReadMore from '~/components/ReadMore.astro'
-
-El [Markdown](https://daringfireball.net/projects/markdown/) se usa comúnmente para crear contenido con mucho texto, como artículos de blog y documentación. Astro incluye soporte integrado para archivos estándar de Markdown, que también pueden incluir [frontmatter YAML](https://dev.to/paulasantamaria/introduction-to-yaml-125f) para definir metadatos personalizados como un título, descripción y etiquetas.
-
-Con la [integración @astrojs/mdx](/es/guides/integrations-guide/mdx/) instalada, Astro también soporta archivos [MDX](https://mdxjs.com/) (`.mdx`) los cuales poseen algunas características adicionales como soporte para expresiones JavaScript y componentes en un contenido Markdown.
-
-¡Utiliza cualquiera de ambos (o ambos) para escribir tu contenido Markdown!
-
-## Páginas de Markdown y MDX
-
-### Colecciones de contenido
-
-Puedes gestionar tus archivos Markdown y MDX en Astro en una carpeta especial `src/content/`. [Las colecciones de contenido](/es/guides/content-collections/) te ayudan a organizar tu contenido, validar tu frontmatter y proporcionar seguridad de tipo TypeScript automática mientras trabajas con tu contenido.
-
-<FileTree>
-- src/content/
-  - **newsletter/** 
-    - week-1.md
-    - week-2.md
-  - **authors/**
-    - grace-hopper.md
-    - alan-turing.md
-</FileTree>
-
-
-
-Ver más sobre el uso de [colecciones de contenido en Astro](/es/guides/content-collections/).
-
-### Enrutamiento basado en archivos
-
-Astro trata cualquier archivo `.md` (u otra extensión alternativa soportada) o `.mdx` dentro de la carpeta `/src/pages` como una página.
-
-Al colocar un archivo en esta carpeta, o en cualquier subcarpeta, se creará automáticamente una ruta de página utilizando la ruta del archivo.
-
-```markdown
----
-# Ejemplo: src/pages/page-1.md
-title: Hola mundo
----
-
-# ¡Hola!
-
-Este archivo de Markdown crea una página en `tu-dominio.com/page-1/`
-
-No tiene muchos estilos pero Markdown soporta:
-- **negrita** y _cursiva._
-- listas
-- [hipervínculos](https://astro.build)
-- ¡y más!
-```
-
-<ReadMore>Lee más acerca del [enrutamiento basado en archivos](/es/guides/routing/) u opciones para crear [rutas dinámicas](/es/guides/routing/#rutas-dinámicas).</ReadMore>
-
-## Características de Markdown
-
-Astro provee algunas características adicionales incorporadas disponibles a la hora de usar Markdown y archivos MDX.
-
-### `layout` en el Frontmatter
-
-Astro provee a [las páginas de Markdown y MDX](/es/basics/astro-pages/#páginas-markdownmdx) (localizadas en `src/pages/`) una propiedad especial en el frontmatter para `layout` que define la ruta relativa (o un [alias](/es/guides/imports/#alias)) a un [componente plantilla](/es/basics/layouts/) de Astro.
-
-```markdown {3}
----
-# src/pages/posts/post-1.md
-layout: ../../layouts/BlogPostLayout.astro
-title: Astro en pocas palabras
-author: Agustin Mulet
-description: ¡Descubre por qué Astro es genial!
----
-Este es un artículo escrito en Markdown.
-```
-
-[Luego las propiedades especificas están disponibles para el componente plantilla](/es/basics/layouts/#props-de-plantillas-markdown) a través de `Astro.props`. Por ejemplo, puedes acceder a las propiedades del frontmatter a través de `Astro.props.frontmatter`:
-
-```astro /frontmatter(?:.\w+)?/
----
-// src/layouts/BlogPostLayout.astro
-const { frontmatter } = Astro.props;
----
-<html>
-  <!-- ... -->
-  <h1>{frontmatter.title}</h1>
-  <h2>Autor del artículo: {frontmatter.author}</h2>
-  <p>{frontmatter.description}</p>
-  <slot /> <!-- Aquí se inyecta el contenido Markdown -->
-   <!-- ... -->
-</html>
-```
-
-Puedes también [aplicar estilos al Markdown](/es/guides/styling/#estilando-markdown) en tu componente plantilla.
-
-<ReadMore>Aprende más acerca de [Plantillas de Markdown](/es/basics/layouts/#plantillas-de-markdown).</ReadMore>
-
-### IDs de Encabezado
-
-Usar títulos en Markdown y MDX generará automáticamente los hipervínculos anchor para vincular directamente a diferentes secciones de tu página.
-
-```markdown title="src/pages/page-1.md"
----
-title: Mi página de contenido
----
-## Introducción
-
-Puedo vincular internamente a [mi conclusión](#conclusión) en la misma página cuando escribo Markdown.
-
-## Conclusión
-
-Puedo usar la URL `https://ejemplo.com/page-1/#introducción` para navegar directamente a mi Introducción en la página.
-```
-
-Astro genera `id`s de encabezado basados en `github-slugger`. Puedes encontrar más ejemplos en [la documentación de github-slugger](https://github.com/Flet/github-slugger#usage).
-
-### Escapando caracteres especiales
-
-Ciertos caracteres tienen un significado especial en Markdown y MDX. Puedes necesitar usar una sintaxis diferente si deseas mostrarlos. Para hacer esto, puedes usar [entidades HTML](https://developer.mozilla.org/es/docs/Glossary/Entity) para esos caracteres en su lugar.
-
-Por ejemplo, para prevenir que `<` sea interpretado como el inicio de un elemento HTML, escribe `&lt;`. O, para prevenir que `{` sea interpretado como el inicio de una expesión de JavaScript en MDX, escribe `&lcub;`.
-
-## Características de MDX únicamente
-
-Añadiendo la [integración de MDX](/es/guides/integrations-guide/mdx/) de Astro vas a potenciar tu autoría de Markdown con variables JSX, expresiones y componentes.
-
-También añade características extra al MDX estándar, incluyendo soporte para [frontmatter del estilo Markdown en MDX](https://mdxjs.com/guides/frontmatter/). Esto te permite usar la mayoría de las características incorporadas en Astro de Markdown como la propiedad [`layout` en el frontmatter](#layout-en-el-frontmatter).
-
-Los archivos `.mdx` deben ser escritos usando [sintaxis de MDX](https://mdxjs.com/docs/what-is-mdx/#mdx-syntax) en vez de la sintaxis de tipo HTML de Astro.
-
-### Usando Variables Exportadas en MDX
-
-MDX admite usar declaraciones `export` para añadir variables a tu contenido MDX. Estas variables son accesibles tanto en el template como propiedades nombradas al momento de [importar el archivo](#importando-markdown) en algún otro lugar.
-
-Por ejemplo, puedes exportar un campo `title` desde una página o componente MDX para usar como título usando `{expresiones JSX}`:
-
-```mdx title="/src/pages/posts/post-1.mdx"
-export const title = 'Mi primer artículo MDX'
-
-# {title}
-```
-### Usando Variables de Frontmatter en MDX
-
-La integración con MDX de Astro incluye soporte para utilizar frontmatter en MDX de manera predeterminada. Puedes agregar propiedades de frontmatter de la misma manera que lo harías en archivos Markdown y esas variables son accesibles para usar en el template, en su [componente `layout`](#layout-en-el-frontmatter) y como propiedades nombradas al momento de [importar el archivo](#importando-markdown) en algún otro lugar.
-
-```mdx title="/src/pages/posts/post-1.mdx"
----
-layout: '../../layouts/BlogPostLayout.astro'
-title: 'Mi primer artículo MDX'
----
-
-# {frontmatter.title}
-```
-
-### Usando Componentes en MDX
-
-Luego de instalar la integración con MDX, puedes importar y utilizar ambos [componentes de Astro components](/es/basics/astro-components/#props-de-componentes) y [componentes de frameworks UI](/es/guides/framework-components/#usando-componente-de-framework) en archivos MDX (`.mdx`) de la misma manera que los usarías en cualquier otro componente de Astro.
-
-¡No olvides agregar una directiva `client:` en tus componentes de frameworks UI si es necesario!
-
-Puedes ver más ejemplos de declaraciones de import y export en la [documentación de MDX](https://mdxjs.com/docs/what-is-mdx/#esm).
-
-```mdx title="src/pages/about.mdx" {5-6} /<.+\/>/
----
-layout: ../layouts/BaseLayout.astro
-title: Acerca de mi
----
-import Button from '../components/Button.astro';
-import ReactCounter from '../components/ReactCounter.jsx';
-
-Yo vivo en **Marte** pero siéntete libre de <Button title="Contactarme" />.
-
-Aquí está mi componente contador, funcionando en MDX:
-
-<ReactCounter client:load />
-```
-
-#### Asignando Componentes Personalizados a elementos HTML
-
-Con MDX, puedes mapear sintaxis de Markdown a componentes personalizados en vez de sus elementos HTML estándar. Esto te permite escribir usando sintaxis común de Markdown pero aplicando estilo de componentes especiales a los elementos seleccionados.
-
-Importa tus componentes personalizados en tu archivo `.mdx`, luego exporta un objeto `components` que mapee el elemento HTML estándar a tu componente personalizado:
-
-```mdx title="src/pages/about.mdx"
-import Blockquote from '../components/Blockquote.astro';
-export const components = {blockquote: Blockquote}
-
-> Esta quote va a ser una Blockquote personalizada
-```
-
-
-```astro title="src/components/Blockquote.astro"
----
-const props = Astro.props;
----
-<blockquote {...props} class="bg-blue-50 p-4">
-  <span class="text-4xl text-blue-600 mb-2">“</span>
-  <slot /> <!-- ¡Asegúrate de agregar un `<slot/>` para contenido hijo! -->
-</blockquote>
-```
-Puedes visitar el [sitio de MDX](https://mdxjs.com/table-of-components/) para ver la lista completa de elementos HTML que pueden ser sobreescritos con componentes personalizados.
-
-## Importando Markdown
-
-Puedes importar archivos Markdown y MDX directamente en tus archivos Astro. Esto te da acceso a su contenido Markdown como así también otras propiedades como valores de frontmatter, que puedes utilizar en expresiones JSX-like de Astro.
-
-Puedes importar una página específica con una declaración `import`, o varias con [`Astro.glob()`](/es/guides/imports/#astroglob).
-
-```astro title="src/pages/index.astro"
----
-// Importa un solo archivo
-import * as greatPost from '../pages/post/great-post.md';
-
-// Importar múltiples archivos con Astro.glob
-const posts = await Astro.glob('../pages/post/*.md');
----
-```
-
-Cuando importas archivos Markdown y MDX en un componente Astro, puedes acceder a un objeto conteniendo sus [propiedades exportadas](#propiedades-exportadas).
-
-```md title="/src/pages/posts/great-post.md"
----
-title: 'El mejor artículo de todos los tiempos'
-author: 'Ben'
----
-
-¡Este es mi _gran_ artículo!
-```
-
-```astro title="src/pages/my-posts.astro"
----
-import * as greatPost from '../pages/post/great-post.md';
-
-const posts = await Astro.glob('../pages/post/*.md');
----
-
-<p>{greatPost.frontmatter.title}</p>
-<p>Escrito por: {greatPost.frontmatter.author}</p>
-
-<p>Archivo de Artículos:</p>
-<ul>
-  {posts.map(post => <li><a href={post.url}>{post.frontmatter.title}</a></li>)}
-</ul>
-```
-
-En archivos MDX, puedes acceder a propiedades tanto del frontmatter como de las declaraciones `export`:
-
-```mdx title="/src/pages/posts/mdx-post.mdx"
----
-title: 'El mejor artículo de todos los tiempos'
-author: 'Ben'
----
-export const description = '¡Acomódate! Vas a pasarla muy bien leyendo esto.'
-
-¡Este es mi _gran_ artículo!
-```
-
-```astro title="src/pages/my-posts.astro"
----
-import * as greatPost from '../pages/post/mdx-post.mdx';
----
-
-<p>{greatPost.frontmatter.title}</p>
-<p>Escrito por: {greatPost.frontmatter.author}</p>
-<p>{greatPost.description}</p>
-```
-
-Opcionalmente, puedes proporcionar un tipo para la variable `frontmatter` usando un genérico de TypeScript:
-
-```astro title="src/pages/index.astro" ins={2-5} ins="<Frontmatter>"
----
-interface Frontmatter {
-  title: string;
-  description?: string;
-}
-const posts = await Astro.glob<Frontmatter>('../pages/post/*.md');
----
-
-<ul>
-  {posts.map(post => <li>{post.frontmatter.title}</li>)}
-  <!-- ¡post.frontmatter.title será un `string`! -->
-</ul>
-```
-
-### Propiedades exportadas
-
-:::note[¿Usando una plantilla de Astro?]
-Puedes ver las [propiedades exportadas a un componente de plantilla de Astro](/es/basics/layouts/#props-de-plantillas-markdown) cuando usas el [layout en el Frontmatter](#layout-en-el-frontmatter) especial de Astro
-:::
-
-Estas propiedades están disponibles en un componente `.astro` cuando usas una declaración `import` o `Astro.glob()`:
-
-- **`file`** - La ruta absoluta de este archivo (por ejemplo, `/home/user/projects/.../file.md`).
-- **`url`** - Si es una página, su URL (por ejemplo, `/en/guides/markdown-content`).
-- **`frontmatter`** - Contiene la data especificada en el YAML del frontmatter del archivo.
-- **`getHeadings`** - Una función asincrónica que devuelte un array de todos los encabezados (`h1 -> h6`) en el archivo. Cada `slug` del encabezado corresponde al ID generado para cada encabezado y puede usarse para hipervínculos anchor. Esta lista tiene la siguiente forma de datos: `{ depth: number; slug: string; text: string }[]`.
-- **`content`** - Un componente que devuelve el contenido completo y renderizado del archivo.
-- **(Solamente Markdown) `rawContent()`** - Una función que devuelve el documento Markdown como string.
-- **(Solamente Markdown) `compiledContent()`** - Una función que devuelve el documento Markdown compilado a un string HTML. ¡Ten en cuenta que esto no incluye plantillas configuradas en tu frontmatter! Solamente el documento markdown va a ser devuelto como HTML.
-- **(Solamente MDX)** - Los archivos MDX también pueden exportar data con una declaración `export`.
-
-
-### El componente `Content`
-
-Importa `Content` para renderizar un componente que devuelve el contenido completo de un archivo Markdown o MDX:
-
-```astro title="src/pages/content.astro" "Content"
----
-import {Content as PromoBanner} from '../components/promoBanner.md';
----
-
-<h2>La promo de hoy</h2>
-<PromoBanner />
-```
-
-#### Ejemplo: Enrutamiento de página dinámico
-
-Si no deseas poner tus archivos Markdown/MDX en la carpeta `src/pages` para crear rutas de página, puedes [generar páginas dinámicamente](/es/guides/routing/#rutas-dinámicas).
-
-Para acceder al contenido Markdown, puedes pasar el componente `<Content/>` a través de las `props` de la página Astro. Luego, puedes obtener el componente desde `Astro.props` y renderizarlo en tu plantilla.
-
-```astro title="src/pages/[slug].astro" {9-11} "Content" "Astro.props.post"
----
-export async function getStaticPaths() {
-  const posts = await Astro.glob('../posts/**/*.md')
-
-  return posts.map(post => ({
-    params: {
-      slug: post.frontmatter.slug
-    },
-    props: {
-      post
-    },
-  }))
-}
-
-const { Content } = Astro.props.post
----
-<article>
-  <Content/>
-</article>
-```
-
-
-### Exportación en MDX únicamente
-
-Los archivos MDX también pueden exportar data declarando un `export`.
-
-Por ejemplo, puedes exportar un campo `title` desde un componente o página MDX.
-
-```mdx title="/src/pages/posts/post-1.mdx"
-export const title = 'Mi primer artículo MDX'
-```
-
-Este `title` será accesible desde una declaración `import` y [Astro.glob()](/es/reference/api-reference/#astroglob):
-
-```astro
----
-// src/pages/index.astro
-const posts = await Astro.glob('./*.mdx');
----
-
-{posts.map(post => <p>{post.title}</p>)}
-```
-
-### Componentes personalizados con MDX importado
-
-A la hora de renderizar contenido MDX importado, es posible pasar [componentes personalizados](#asignando-componentes-personalizados-a-elementos-html) por medio de la propiedad `components`.
-
-```astro title="src/pages/page.astro" "components={{...components, h1: Heading }}"
----
-import { Content, components } from '../content.mdx';
-import Heading from '../Heading.astro';
----
-<!-- Crea un <h1> personalizado para la sintaxis #, _y_ aplica cualquier componente personalizado que esté definido en `content.mdx` -->
-<Content components={{...components, h1: Heading }} />
-```
-
-:::note
-Los componentes personalizados definidos y exportados en un archivo MDX deben ser importados y pasados de vuelta al componente `<Content />` por medio de la propiedad `components`.
-:::
-
-## Configuración de Markdown y MDX
-
-El soporte de Markdown en Astro está basado en [remark](https://remark.js.org/), una potente herramienta de análisis sintáctico y procesamiento con un ecosistema activo. Otros analizadores de Markdown como Pandoc y markdown-it no están soportados actualmente.
-
-De forma predeterminada, Astro aplica los plugins [GitHub-flavored Markdown](https://github.com/remarkjs/remark-gfm) y [SmartyPants](https://github.com/silvenon/remark-smartypants). Esto trae algunas características útiles como la generación de links cliqueables desde el texto y formato para [citas y guiones largos](https://daringfireball.net/projects/smartypants/).
-
-Puedes personalizar cómo remark analiza tu Markdown en `astro.config.mjs`. Puedes ver la lista completa de [opciones de configuración de Markdown](/es/reference/configuration-reference/#opciones-de-markdown).
-
-### Plugins de Markdown
-
-Astro es compatible con plugins externos de [remark](https://github.com/remarkjs/remark) y [rehype](https://github.com/rehypejs/rehype) para Markdown y MDX. Estos plugins te permiten extender tu Markdown con nuevas características, como [generación automática de tabla de contenidos](https://github.com/remarkjs/remark-toc), [aplicar etiquetas accesibles a emojis](https://github.com/florianeckerstorfer/remark-a11y-emoji) y [aplicar estilos al Markdown](/es/guides/styling/#estilando-markdown).
-
-¡Te invitamos a darle un vistazo a las listas [awesome-remark](https://github.com/remarkjs/awesome-remark) y [awesome-rehype](https://github.com/rehypejs/awesome-rehype) para ver más plugins populares! Puedes leer sus README para seguir las instrucciones de instalación de cada uno.
-
-Este ejemplo aplica [`remark-toc`](https://github.com/remarkjs/remark-toc) y [`rehype-accesible-emojis`](https://www.npmjs.com/package/rehype-accessible-emojis) a ambos archivos Markdown y MDX:
-
-```js title="astro.config.mjs"
-import { defineConfig } from 'astro/config';
-import remarkToc from 'remark-toc';
-import { rehypeAccessibleEmojis } from 'rehype-accessible-emojis';
-
-export default defineConfig({
-  markdown: {
-    // Aplicado a archivos .md y .mdx
-   remarkPlugins: [remarkToc, { heading: 'toc', maxDepth: 3 }],
-   rehypePlugins: [rehypeAccessibleEmojis],
-  },
-});
-```
-
-### IDs de encabezados y plugins
-
-Astro inyecta un atributo `id` en todos los elementos de encabezado (`<h1>` a `<h6>`) en archivos Markdown y MDX y proporciona una utilidad `getHeadings()` para recuperar estos IDs en [propiedades exportadas de Markdown](#propiedades-exportadas).
-
-Puedes personalizar estos IDs de encabezado agregando un plugin de rehype que inyecte atributos `id` (por ejemplo, `rehype-slug`). Tus IDs personalizados, en lugar de los predeterminados de Astro, se reflejarán en la salida HTML y los elementos devueltos por `getHeadings()`.
-
-Por defecto, Astro inyecta atributos `id` después de que se ejecutan tus complementos de rehype. Si uno de tus complementos de rehype personalizados necesita acceder a los IDs inyectados por Astro, puedes importar y usar el complemento `rehypeHeadingIds` de Astro directamente. Asegúrate de agregar `rehypeHeadingIds` antes de cualquier complemento que lo requiera:
-
-```js title="astro.config.mjs" ins={2, 8}
-import { defineConfig } from 'astro/config';
-import { rehypeHeadingIds } from '@astrojs/markdown-remark';
-import { otherPluginThatReliesOnHeadingIDs } from 'some/plugin/source';
-
-export default defineConfig({
-  markdown: {
-    rehypePlugins: [
-      rehypeHeadingIds,
-      otherPluginThatReliesOnHeadingIDs,
-    ],
-  },
-});
-```
-
-:::note
-`getHeadings()` solo devuelve los encabezados escritos directamente en un archivo Markdown o MDX. Si un archivo MDX importa componentes que contienen sus propios encabezados, estos no serán devueltos por `getHeadings()`.
-:::
-
-#### Personalizando un plugin
-
-Para personalizar un plugin, proporciona un objeto de opciones después de él en un array anidado.
-
-En el ejemplo de abajo se agrega la [opción de encabezado al plugin `remarkToc`](https://github.com/remarkjs/remark-toc#options) para cambiar dónde es colocada la tabla de contenidos y la [opción `behavior` al plugin `rehype-autolink-headings`](https://github.com/rehypejs/rehype-autolink-headings#options) para agregar una etiqueta de ancla después del texto del encabezado.
-
-```js title="astro.config.mjs"
-import remarkToc from 'remark-toc';
-import rehypeSlug from 'rehype-slug';
-import rehypeAutolinkHeadings from 'rehype-autolink-headings';
-export default {
-  markdown: {
-    remarkPlugins: [ [remarkToc, { heading: "contents"} ] ],
-    rehypePlugins: [rehypeSlug, [rehypeAutolinkHeadings, { behavior: 'append' }]],
-  },
-}
-```
-
-#### Modificación programática del frontmatter
-
-:::note
-Si estás usando [colecciones de contenido](/es/guides/content-collections/), por favor ve ["Modificando el Frontmatter con Remark"](/es/guides/content-collections/#modificando-el-frontmatter-con-remark).
-:::
-
-Puedes agregar propiedades al frontmatter de todos tus archivos Markdown o MDX utilizando un [plugin de remark o rehype](#plugins-de-markdown).
-
-1. Agrega una `customProperty` a la propiedad `data.astro.frontmatter` del argumento `file` de tu plugin:
-
-    ```js title="example-remark-plugin.mjs"
-    export function exampleRemarkPlugin() {
-      // Todos los complementos remark y rehype devuelven una función
-      return function (tree, file) {
-        file.data.astro.frontmatter.customProperty = 'Propiedad generada';
-      }
-    }
-    ```
-
-    :::tip
-    <Since v="2.0.0" />
-
-    `data.astro.frontmatter` contiene todas las propiedades de un documento Markdown o MDX. Esto te permite modificar propiedades existentes del frontmatter, o calcular nuevas propiedades a partir de este frontmatter existente.
-    :::
-
-2. Aplica este plugin a tu configuración de integración `markdown` o `mdx`:
-
-    ```js title="astro.config.mjs" "import { exampleRemarkPlugin } from './example-remark-plugin.mjs';" "remarkPlugins: [exampleRemarkPlugin],"
-    import { defineConfig } from 'astro/config';
-    import { exampleRemarkPlugin } from './example-remark-plugin.mjs';
-
-    export default defineConfig({
-      markdown: {
-        remarkPlugins: [exampleRemarkPlugin]
-      },
-    });
-    ```
-
-    o bien
-
-    ```js title="astro.config.mjs" "import { exampleRemarkPlugin } from './example-remark-plugin.mjs';" "remarkPlugins: [exampleRemarkPlugin],"
-    import { defineConfig } from 'astro/config';
-    import { exampleRemarkPlugin } from './example-remark-plugin.mjs';
-
-    export default defineConfig({
-      integrations: [
-        mdx({
-          remarkPlugins: [exampleRemarkPlugin],
-        }),
-      ],
-    });
-    ```
-
-Ahora, cada archivo Markdown o MDX tendrá `customProperty` en su frontmatter, la cual estará disponible al [importar markdown](#importando-markdown) y en [la propiedad `Astro.props.frontmatter` en tus plantillas](#layout-en-el-frontmatter).
-
-<RecipeLinks slugs={["es/recipes/reading-time"]} />
-
-### Extendiendo la configuración de Markdown desde MDX
-
-La integración MDX de Astro extenderá [la configuración de Markdown existente de tu proyecto](/es/reference/configuration-reference/#opciones-de-markdown) por defecto. Para sobrescribir opciones individuales, puedes especificar su equivalente en tu configuración MDX.
-
-El siguiente ejemplo deshabilita el GitHub-Flavored Markdown y aplica un conjunto diferente de complementos remark para archivos MDX:
-
-```ts title="astro.config.mjs"
-import { defineConfig } from 'astro/config';
-import mdx from '@astrojs/mdx';
-export default defineConfig({
-  markdown: {
-    syntaxHighlight: 'prism',
-    remarkPlugins: [remarkPlugin1],
-    gfm: true,
-  },
-  integrations: [
-    mdx({
-      // `syntaxHighlight` heredado de Markdown
-      // Markdown `remarkPlugins` ignorados,
-      // solo `remarkPlugin2` aplicado.
-      remarkPlugins: [remarkPlugin2],
-      // `gfm` sobrescrito a `false`
-      gfm: false,
-    })
-  ]
-});
-```
-
-Para evitar extender la configuración de Markdown desde MDX, establece [la opción `extendMarkdownConfig`](/es/guides/integrations-guide/mdx/#extendmarkdownconfig) (habilitada por defecto) a `false`:
-
-```ts title="astro.config.mjs"
-import { defineConfig } from 'astro/config';
-import mdx from '@astrojs/mdx';
-export default defineConfig({
-  markdown: {
-    remarkPlugins: [remarkPlugin],
-  },
-  integrations: [
-    mdx({
-      // La config de Markdown ahora es ignorada
-      extendMarkdownConfig: false,
-      // `remarkPlugin` no aplicado
-    })
-  ]
-});
-```
-
-### Resaltado de sintaxis
-
-Astro viene con soporte integrado para [Shiki](https://shiki.style/) y [Prism](https://prismjs.com/). Esto proporciona un resaltado de sintaxis instantáneo para:
-
-- todas las vallas de código (\`\`\`) usadas en Markdown o archivos MDX.
-- el contenido dentro del [componente incorporado `<Code />`](/es/guides/syntax-highlighting/#code-) (con la tecnología de Shiki)
-- el contenido dentro del [componente `<Prism />`](/es/guides/syntax-highlighting/#prism-) (con la tecnología de Prism).
-
-Shiki está habilitado de forma predeterminada, preconfigurado con el tema `github-dark`. La salida compilada se limitará a estilos en línea sin clases CSS externas, hojas de estilo o JS del lado del cliente.
-
-#### Configuración de Shiki
-
-Shiki es nuestro resaltador de sintaxis predeterminado. Puedes configurar todas las opciones a través del objeto `shikiConfig` así:
-
-```js title="astro.config.mjs"
-import { defineConfig } from 'astro/config';
-
-export default defineConfig({
-  markdown: {
-    shikiConfig: {
-      // Escoge entre los temas integrados de Shiki (o agrega los tuyos propios)
-      // https://shiki.style/themes
-      theme: 'dracula',
-      // Alternativamente, proporciona múltiples temas.
-      // https://shiki.style/guide/dual-themes
-      themes: {
-        light: 'github-light',
-        dark: 'github-dark',
-      },
-
-      // Deshabilita los colores predeterminados
-      // https://shiki.style/guide/dual-themes#without-default-color
-      // (Agregado en v4.12.0)
-      defaultColor: false,
-      // Agrega lenguajes de programación personalizados
-      // Nota: Shiki tiene innumerables lenguajes de programación incorporados, ¡incluido .astro!
-      // https://shiki.style/languages
-      langs: [],
-      // Habilita word wrap para evitar el desplazamiento horizontal
-      wrap: true,
-      // Agrega transformadores personalizados: https://shiki.style/guide/transformers
-      // Encuentra transformadores comunes: https://shiki.style/packages/transformers
-      transformers: [],
-    },
-  },
-});
-```
-
-:::note[Personalizando temas de Shiki]
-Los bloques de código de Astro están estilizados usando la clase `.astro-code`. Al seguir la documentación de Shiki (por ejemplo, para [personalizar temas duales o múltiples claros/oscuros](https://shiki.style/guide/dual-themes#query-based-dark-mode)), asegúrate de reemplazar la clase `.shiki` en los ejemplos con `.astro-code`.
-:::
-
-#### Añadiendo tu propio tema
-
-En lugar de usar alguno de los temas predefinidos de Shiki, puedes importar un tema personalizado desde un archivo local.
-
-```js title="astro.config.mjs"
-import { defineConfig } from 'astro/config';
-import customTheme from './my-shiki-theme.json';
-
-export default defineConfig({
-  markdown: {
-    shikiConfig: { theme: customTheme },
-  },
-});
-```
-
-También sugerimos leer [la documentación de Shiki sobre sus temas](https://shiki.style/themes) para explorar la carga de temas personalizados, alternar entre modo claro y oscuro, o estilar utilizando variables de CSS.
-
-#### Cambia el resaltador de sintaxis predeterminado
-
-Si deseas cambiar a `'prism'` o deshabilitar el resaltado de sintaxis por completo, puedes usar el objeto de configuración `markdown.syntaxHighlight`:
-
-```js title="astro.config.mjs" ins={6}
-import { defineConfig } from 'astro/config';
-
-export default defineConfig({
-  markdown: {
-    // Puede ser 'shiki' (predeterminado), 'prism' o false para deshabilitar el resaltado
-    syntaxHighlight: 'prism',
-  },
-});
-```
-
-#### Configuración de Prism
-
-Si optas por usar Prism, se aplicarán las clases CSS de Prism en su lugar. ¡Ten en cuenta que **necesitas aportar tu propia hoja de estilo CSS** para que aparezca el resaltado de sintaxis!
-
-1. Escoge una hoja de estilos prediseñada de los [Temas de Prism](https://github.com/PrismJS/prism-themes) disponibles.
-2. Agrega esta hoja de estilos a la [carpeta `public/` de tu proyecto](/es/basics/project-structure/#public).
-3. Agrega esto en el `<head>` de tu página en un [componente de plantilla](/es/basics/layouts/) a través de una etiqueta `<link>`. (Lee sobre el [uso básico de Prism](https://prismjs.com/#basic-usage).)
-
-También puedes visitar la [lista de lenguajes soportados por Prism](https://prismjs.com/#supported-languages) para ver las opciones y su uso.
-
-## Fetching de Markdown Remoto
-
-Astro fue diseñado principalmente para archivos Markdown locales que podrían ser guardados dentro del directorio del proyecto. Sin embargo, pueden ocurrir casos donde necesites obtener Markdown de una fuente remota. Por ejemplo, puedes necesitar hacer fetching y renderizar Markdown de una API remota al estar construyendo un sitio web (o cuando el usuario ejecute una request a su página, al usar [SSR](/es/guides/on-demand-rendering/)).
-
-**¡Astro no incluye soporte para Markdown remoto!**. Para hacer fetching de Markdown remoto y renderizarlo a HTML, necesitarás instalar y configurar tu propio parser de Markdown desde npm. Este **no** heredará ajustes que hayas configurado del Markdown y MDX de Astro. Asegúrate de comprender estas limitaciones antes de implementar esto en tu proyecto.
-
-```astro title="src/pages/remote-example.astro"
----
-// Ejemplo: Fetching Markdown de una API remota
-// y renderizarlo a HTML al ser ejecutado
-// Usando "marked" (https://github.com/markedjs/marked)
-import { marked } from 'marked';
-const response = await fetch('https://raw.githubusercontent.com/wiki/adam-p/markdown-here/Markdown-Cheatsheet.md');
-const markdown = await response.text();
-const content = marked.parse(markdown);
----
-<article set:html={content} />
-```
diff --git a/src/content/docs/es/guides/media/cloudinary.mdx b/src/content/docs/es/guides/media/cloudinary.mdx
index f79b54a1be535..cfdc59827c996 100644
--- a/src/content/docs/es/guides/media/cloudinary.mdx
+++ b/src/content/docs/es/guides/media/cloudinary.mdx
@@ -134,7 +134,7 @@ export const collections = {
 }
 ```
 
-Luego puedes usar las [funciones de consulta `getCollection()` o `getEntry()`](/es/guides/content-collections/#consultando-colecciones) para seleccionar una o varias imágenes o vídeos de tu colección.
+Luego puedes usar las [funciones de consulta `getCollection()` o `getEntry()`](/es/guides/content-collections/#querying-collections) para seleccionar una o varias imágenes o vídeos de tu colección.
 
 Consulta la [documentación de `cldAssetsLoader` de Cloudinary](https://astro.cloudinary.dev/cldassetsloader/basic-usage) para más información.
 
diff --git a/src/content/docs/es/guides/media/index.mdx b/src/content/docs/es/guides/media/index.mdx
deleted file mode 100644
index 1e11a0bee7570..0000000000000
--- a/src/content/docs/es/guides/media/index.mdx
+++ /dev/null
@@ -1,40 +0,0 @@
----
-title: Usar un DAM con Astro
-description: Cómo usar un Gestor de Activos Digitales (DAM) para agregar imágenes y videos a Astro
-sidebar:
-  label: Descripción general de la gestión de activos digitales
-i18nReady: true
----
-import MediaGuidesNav from '~/components/MediaGuidesNav.astro';
-import ReadMore from '~/components/ReadMore.astro';
-import Badge from "~/components/Badge.astro"
-
-**¿Listo para conectar un Gestor de Activos Digitales (DAM) headless a tu proyecto Astro?** Sigue una de nuestras guías para integrar un sistema de medios alojado.
-
-:::tip
-Encuentra [integraciones mantenidas por la comunidad](https://astro.build/integrations/) para conectar un DAM o un sistema de medios alojado a tu proyecto en nuestro directorio de integraciones.
-:::
-
-## Guías de Medios Alojados
-
-Ten en cuenta que muchas de estas páginas son **esbozos**: ¡son colecciones de recursos que esperan tu contribución!
-
-<MediaGuidesNav />
-
-## ¿Por qué usar un DAM o medios alojados?
-
-Usar un DAM, o Gestor de Activos Digitales, ayuda a individuos, equipos y organizaciones a gestionar sus activos de imagen y video desde una ubicación central, de manera similar a un [CMS](/es/guides/cms/).
-
-La diferencia es el tipo de contenido que se gestiona: un DAM gestionaría principalmente imágenes, videos, otros activos multimedia como modelos 3D y cualquier metadato asociado con esos activos.
-
-Esto puede ser útil, especialmente cuando se utiliza una única fuente de verdad para tus activos entre múltiples propiedades web o móviles. Esto es importante si eres parte de una organización que requiere que varios equipos utilicen los mismos activos, o si te estás integrando con otros sistemas de contenido como un PIM (Gestor de Información de Productos) para conectar tus activos a los productos.
-
-## ¿Qué sistemas de medios alojados o DAMs funcionan bien con Astro?
-
-Al igual que cuando se usa un CMS, ya que Astro maneja la _presentación_ de tu contenido, querrás usar un DAM headless que te permita obtener e interactuar con tus activos a través de una API o SDK.
-
-Algunos DAMs headless, como Cloudinary, proporcionan una [integración](/es/guides/integrations-guide/) de Astro que te permite obtener fácilmente tus activos, así como mostrarlos en tu sitio web o aplicación.
-
-## ¿Puedo usar Astro sin un sistema de medios alojados o DAM?
-
-¡Sí! Astro proporciona formas integradas para [almacenar imágenes](/es/guides/images/#dónde-guardar-las-imágenes), incluido el soporte para hacer referencia a imágenes remotas.
diff --git a/src/content/docs/es/guides/middleware.mdx b/src/content/docs/es/guides/middleware.mdx
deleted file mode 100644
index d73617c7d3b25..0000000000000
--- a/src/content/docs/es/guides/middleware.mdx
+++ /dev/null
@@ -1,206 +0,0 @@
----
-title: Middleware
-description: Aprende cómo usar un middleware en Astro.
-i18nReady: true
----
-import PackageManagerTabs from '~/components/tabs/PackageManagerTabs.astro';
-import { Steps } from '@astrojs/starlight/components';
-
-Un **Middleware** te permite interceptar las solicitudes y respuestas e inyectar comportamientos dinámicamente cada vez que una página o endpoint está a punto de ser renderizado. Esta renderización se produce en tiempo de compilación para todas las páginas prerenderizadas, pero se produce cuando se solicita la ruta para las páginas renderizadas bajo demanda, lo que permite [características adicionales de SSR como cookies y encabezados](/es/guides/on-demand-rendering/) disponibles.
-
-El middleware también permite establecer y compartir información específica de la solicitud entre endpoints y páginas mutando un objeto `locals` que está disponible en todos los componentes Astro y endpoints API. Este objeto está disponible incluso cuando este middleware se ejecuta en tiempo de compilación.
-
-## Uso básico
-
-<Steps>
-1. Crea `src/middleware.js|ts` (Alternativamente, puedes crear `src/middleware/index.js|ts`.)
-
-2. Dentro de este archivo, exporta una función [`onRequest()`](/es/reference/api-reference/#onrequest) a la que se le pueda pasar un [objeto `context`](#el-objeto-context) y la función `next()`. Esta no debe ser una exportación por defecto.
-
-    ```js title="src/middleware.js"
-    export function onRequest (context, next) {
-        // interceptar los datos de una solicitud.
-        // opcionalmente, modifica las propiedades en `locals`.
-        context.locals.title = "Nuevo título";
-
-        // devuelve una respuesta o el resultado de llamar a `next()`.
-        return next();
-    };
-    ```
-
-3. Dentro de cualquier archivo `.astro`, puedes acceder a los datos de respuesta utilizando `Astro.locals`. 
-
-    ```astro title="src/components/Component.astro"
-    ---
-    const data = Astro.locals;
-    ---
-    <h1>{data.title}</h1>
-    <p>Este {data.property} proviene de un middleware.</p>
-
-    ```
-</Steps>
-
-### El objeto `context`
-
-El objeto [`context`](/es/reference/api-reference/#contexto-del-endpoint) incluye información que estará disponible para otros middlewares, rutas de la API y rutas `.astro` durante el proceso de renderizado.
-
-Esto es un argumento opcional pasado a `onRequest()` que puede contener el objeto `locals` así como cualquier propiedad adicional que se comparta durante el renderizado. Por ejemplo, el objeto `context` puede incluir cookies utilizadas en la autenticación.
-
-### Almacenando datos en `context.locals`
-
-`context.locals` es un objeto que se puede manipular dentro del middleware.
-
-Este objeto `locals` se reenvía a lo largo del proceso de manejo de la solicitud y está disponible como una propiedad de [`APIContext`](/es/reference/api-reference/#contexto-del-endpoint) y [`AstroGlobal`](/es/reference/api-reference/#astrolocals). Esto permite compartir datos entre middlewares, rutas de la API y páginas `.astro`. Esto es útil para almacenar datos específicos de la solicitud, como datos de usuario, durante el paso de renderizado.
-
-:::tip[Propiedades de la integración]
-Las [Integraciones](/es/guides/integrations-guide/) pueden establecer propiedades y proporcionar funcionalidad a través del objeto `locals`. Si estás utilizando una integración, comprueba su documentación para asegurarte de que no estás sobrescribiendo ninguna de sus propiedades o realizando trabajo innecesario.
-:::
-
-Puedes almacenar cualquier tipo de datos dentro de `locals`: cadenas de texto, números e incluso tipos de datos complejos como funciones y maps.
-
-
-```js title="src/middleware.js"
-export function onRequest (context, next) {
-    // interceptar los datos de una solicitud.
-    // opcionalmente, modifica las propiedades en `locals`.
-    context.locals.user.name = "John Wick";
-    context.locals.welcomeTitle = () => {
-        return "Bienvenido de nuevo  " + locals.user.name;
-    };
-
-  // devuelve una respuesta o el resultado de llamar a `next()`.
-  return next();
-};
-```
-Luego puedes utilizar esta información dentro de cualquier archivo `.astro` con `Astro.locals`.
-
-```astro title="src/pages/orders.astro"
----
-const title = Astro.locals.welcomeTitle();
-const orders = Array.from(Astro.locals.orders.entries());
----
-<h1>{title}</h1>
-<p>Este {data.property} proviene de un middleware.</p>
-<ul>
-    {orders.map(order => {
-        return <li>{/* haz algo con cada orden */}</li>
-    })}
-</ul>
-```
-
-`locals` es un objeto que existe y se destruye dentro de una sola ruta de Astro; cuando se renderiza la página de la ruta, `locals` dejará de existir y se creará uno nuevo. La información que necesita persistir a través de múltiples solicitudes de página debe almacenarse en otro lugar.
-
-:::note
-El valor de `locals` no se puede sobrescribir en tiempo de ejecución. Hacerlo podría eliminar toda la información almacenada por el usuario. En el modo `dev`, Astro realiza comprobaciones y lanzará un error si se intenta sobrescribir `locals`.
-:::
-
-### Ejemplo: Redactando información sensible
-
-El ejemplo a continuación utiliza un middleware para reemplazar "PRIVATE INFO" con la palabra "REDACTED" y así permitirte mostrar HTML modificado en tu página:
-
-```js title="src/middleware.js"
-export const onRequest = async (context, next) => {
-    const response = await next();
-    const html = await response.text();
-    const redactedHtml = html.replaceAll("PRIVATE INFO", "REDACTED");
-    
-    return new Response(redactedHtml, {
-        status: 200,
-        headers: response.headers
-    });
-};
-```
-
-## Tipos de middleware
-
-Puedes importar y usar la función de utilidad `defineMiddleware()` para aprovechar la seguridad de tipos:
-
-```ts
-// src/middleware.ts
-import { defineMiddleware } from "astro:middleware";
-
-// `context` y `next` son automáticamente tipados
-export const onRequest = defineMiddleware((context, next) => {
-
-});
-```
-
-En cambio, si estás utilizando JsDoc para aprovechar la seguridad de tipos, puedes utilizar `MiddlewareHandler`:
-
-```js
-// src/middleware.js
-/**
- * @type {import("astro").MiddlewareHandler}
- */
-// `context` y `next` son automáticamente tipados
-export const onRequest = (context, next) => {
-
-};
-```
-
-Para tipar la información dentro de `Astro.locals`, lo que te da autocompletado dentro de los archivos `.astro` y el código del middleware, declara un namespace global en el archivo `env.d.ts`:
-
-```ts title="src/env.d.ts"
-/// <reference types="astro/client" />
-declare namespace App {
-    interface Locals {
-        user: {
-            name: string
-        },
-        welcomeTitle: () => string,
-        orders: Map<string, object>
-    }
-}
-```
-
-Luego, dentro del archivo de middleware, puedes aprovechar el autocompletado y la seguridad de tipos.
-
-## Encadenando el middleware
-
-Múltiples middlewares pueden ser unidos en un orden específico utilizando [`sequence()`](/es/reference/api-reference/#sequence):
-
-```js title="src/middleware.js"
-import { sequence } from "astro:middleware";
-
-async function validation(_, next) {
-    console.log("solicitud de validación");
-    const response = await next();
-    console.log("respuesta de validación");
-    return response;
-}
-
-async function auth(_, next) {
-  console.log("solicitud de autenticación");
-  const response = await next();
-  console.log("respuesta de autenticación");
-  return response;
-
-}
-
-async function greeting(_, next) {
-  console.log("solicitud de saludo");
-  const response = await next();
-  console.log("respuesta de saludo");
-  return response;
-
-}
-
-export const onRequest = sequence(validation, auth, greeting);
-```
-
-Esto resultará en el siguiente orden en la consola:
-
-```sh
-solicitud de validación
-solicitud de autenticación
-solicitud de saludo
-respuesta de saludo
-respuesta de autenticación
-respuesta de validación
-```
-
-## Páginas de error
-
-El middleware intentará ejecutarse para todas las páginas renderizadas bajo demanda, incluso cuando no se pueda encontrar una ruta coincidente. Esto incluye la página 404 por defecto (en blanco) de Astro y cualquier página 404 personalizada. Sin embargo, depende del [adaptador](/es/guides/on-demand-rendering/) decidir si ese código se ejecuta. Algunos adaptadores pueden servir una página de error específica de la plataforma en su lugar.
-
-El middleware también intentará ejecutarse antes de servir una página de error 500, incluyendo una página 500 personalizada, a menos que el error del servidor se haya producido en la ejecución del propio middleware. Si tu middleware no se ejecuta correctamente, entonces no tendrás acceso a `Astro.locals` para renderizar tu página 500.
diff --git a/src/content/docs/es/guides/migrate-to-astro/from-create-react-app.mdx b/src/content/docs/es/guides/migrate-to-astro/from-create-react-app.mdx
deleted file mode 100644
index 4e8301926a21d..0000000000000
--- a/src/content/docs/es/guides/migrate-to-astro/from-create-react-app.mdx
+++ /dev/null
@@ -1,369 +0,0 @@
----
-title: Migrando desde Create React App (CRA)
-description: Consejos para migrar un proyecto existente de Create React App a Astro
-type: migration
-stub: true
-framework: Create React App
-i18nReady: true
----
-import AstroJSXTabs from '~/components/tabs/AstroJSXTabs.astro';
-import PackageManagerTabs from '~/components/tabs/PackageManagerTabs.astro';
-import { FileTree } from '@astrojs/starlight/components';
-import ReadMore from '~/components/ReadMore.astro';
-import Badge from "~/components/Badge.astro"
-
-La [integración de React](/es/guides/integrations-guide/react/) en Astro proporciona soporte para [utilizar componentes de React dentro de los componentes de Astro](/es/guides/framework-components/), ¡incluidas aplicaciones completas de React como Create React App (CRA)!
-
-```astro title="src/pages/index.astro"
----
-// Importa tu componente raíz App
-import App from '../cra-project/App.jsx';
----
-<!-- Utiliza una directiva del cliente para cargar tu aplicación -->
-<App client:load />
-```
-
-<ReadMore>Consulta cómo [crear una aplicación de una sola página (SPA) con Astro](https://logsnag.com/blog/react-spa-with-astro) <Badge text="Externo" />utilizando React Router.</ReadMore>
-
-Muchas aplicaciones "simplemente funcionarán" como aplicaciones completas de React cuando las agregues directamente a tu proyecto de Astro con la integración de React instalada. Esta es una excelente manera de poner en marcha tu proyecto de inmediato y mantener tu aplicación funcional mientras migras a Astro.
-
-Con el tiempo, puedes convertir tu estructura pieza por pieza en una combinación de componentes `.astro` y `.jsx`. ¡Probablemente descubrirás que necesitas menos componentes de React de lo que crees!
-
-Aquí tienes algunos conceptos clave y estrategias de migración para ayudarte a comenzar. ¡Utiliza el resto de nuestra documentación y únete a nuestra [comunidad de Discord](https://astro.build/chat) para continuar avanzando!
-
-## Principales similitudes entre CRA y Astro
-
-- La [sintaxis de los archivos `.astro` es similar a JSX](/es/reference/astro-syntax/#diferencias-entre-astro-y-jsx). Escribir en Astro debería sentirse familiar.
-
-- Astro utiliza enrutamiento basado en archivos y [permite que las páginas con nombres especiales creen rutas dinámicas](/es/guides/routing/#rutas-dinámicas).
-
-- Astro está [basado en componentes](/es/basics/astro-components/) y tu estructura de marcado será similar antes y después de tu migración.
-
-- Astro tiene [integraciones oficiales para React, Preact y Solid](/es/guides/integrations-guide/react/), lo que te permite utilizar tus componentes JSX existentes. Ten en cuenta que en Astro, estos archivos **deben** tener una extensión `.jsx` o `.tsx`.
-
-- Astro tiene soporte para [instalar paquetes de NPM](/es/guides/imports/#paquetes-npm), incluidas bibliotecas de React. Muchas de tus dependencias existentes funcionarán en Astro.
-
-## Principales diferencias entre CRA y Astro
-
-Cuando reconstruyas tu sitio de CRA en Astro, notarás algunas diferencias importantes:
-
-- CRA es una aplicación de una sola página que utiliza `index.js` como la raíz de tu proyecto. Astro es un sitio de múltiples páginas, y `index.astro` es tu página de inicio.
-
-- Los [componentes `.astro`](/es/basics/astro-components/) no se escriben como funciones exportadas que devuelven plantillas de página. En su lugar, dividirás tu código en una "valla de código" para tu JavaScript y un cuerpo exclusivo para el HTML que generas.
-
-- [Orientado al contenido](/es/concepts/why-astro/#orientado-al-contenido): Astro fue diseñado para resaltar tu contenido y permitirte optar por la interactividad solo cuando sea necesario. Una aplicación existente de CRA puede estar diseñada para una alta interactividad del lado del cliente y puede requerir técnicas avanzadas de Astro para incluir elementos que son más desafiantes de replicar utilizando componentes `.astro`, como paneles de control.
-
-## Agrega tu CRA a Astro
-
-Tu aplicación existente puede ser renderizada directamente dentro de un nuevo proyecto de Astro, muchas veces sin cambios en el código de tu aplicación.
-
-### Crear un nuevo proyecto de Astro
-
-Utiliza el comando `create astro` en tu gestor de paquetes para lanzar la CLI de Astro y seleccionar un nuevo proyecto de Astro "empty".
-
-<PackageManagerTabs>
-  <Fragment slot="npm">
-  ```shell
-  npm create astro@latest
-  ```
-  </Fragment>
-  <Fragment slot="pnpm">
-  ```shell
-  pnpm create astro@latest
-  ```
-  </Fragment>
-  <Fragment slot="yarn">
-  ```shell
-  yarn create astro@latest
-  ```
-  </Fragment>
-</PackageManagerTabs>
-
-### Agregar integraciones y dependencias
-
-Agrega la integración de React utilizando el comando `astro add` para tu gestor de paquetes. Si tu aplicación utiliza Tailwind o MDX, puedes agregar múltiples integraciones de Astro usando el mismo comando.
-
-<PackageManagerTabs>
-  <Fragment slot="npm">
-  ```shell
-  npx astro add react
-  npx astro add react tailwind mdx
-  ```
-  </Fragment>
-  <Fragment slot="pnpm">
-  ```shell
-  pnpm astro add react
-  pnpm astro add react tailwind mdx
-  ```
-  </Fragment>
-  <Fragment slot="yarn">
-  ```shell
-  yarn astro add react
-  yarn astro add react tailwind mdx
-  ```
-  </Fragment>
-</PackageManagerTabs>
-
-Si tu CRA requiere cualquier dependencia (p. ej. paquetes de NPM), debes instalarlos individualmente utilizando la línea de comandos o añadiéndolos manualmente al archivo `package.json` de tu nuevo proyecto de Astro, y luego ejecutando el comando de instalación. Ten en cuenta que muchas, pero no todas, las dependencias de React funcionarán en Astro.
-
-### Agrega los archivos de tu aplicación existente
-
-Copia los archivos y carpetas existentes de tu proyecto actual de Create React App (CRA) (p. ej. `components`, `hooks`, `styles`, etc.) en una nueva carpeta dentro de `src/`, manteniendo su estructura de archivos para que tu aplicación continúe funcionando. Ten en cuenta que todas las extensiones de archivo `.js` sean renombradas a `.jsx` o `.tsx`.
-
-No incluyas archivos de configuración. Utilizarás los archivos `astro.config.mjs`, `package.json` y `tsconfig.json` propios de Astro.
-
-Mueve el contenido de la carpeta `public/` de tu aplicación (p. ej. assets estáticos) dentro de la carpeta `public/` de Astro.
-
-<FileTree>
-- public/
-  - logo.png
-  - favicon.ico
-  - ...
-- src/
-  - cra-project/
-    - App.jsx
-    - ...
-  - pages/
-    - index.astro
-- astro.config.mjs
-- package.json
-- tsconfig.json
-</FileTree>
-
-### Renderizar tu app
-
-Importa el componente raíz de tu aplicación en la sección de frontmatter de `index.astro` y luego renderiza el componente `<App />` en la plantilla de tu página.
-
-```astro title="src/pages/index.astro"
----
-import App from '../cra-project/App.jsx';
----
-<App client:load />
-```
-
-:::note[Directivas del cliente]
-Tu aplicación necesita una [directiva del cliente](/es/reference/directives-reference/#directivas-del-cliente) para la interactividad. Astro renderizará tu aplicación React como HTML estático hasta que optes por utilizar JavaScript en el lado del cliente.
-
-Utiliza `client:load` para asegurarte de que tu aplicación se cargue inmediatamente desde el servidor, o `client:only="react"` para omitir el renderizado en el lado del servidor y ejecutar completamente tu aplicación solo en el lado del cliente.
-:::
-
-## Convierte tu CRA a Astro
-
-Después de [agregar tu aplicación existente a Astro](#agrega-tu-cra-a-astro), ¡probablemente querrás convertir la propia aplicación a Astro!
-
-Replicarás un diseño similar basado en componentes [utilizando componentes de plantillas HTML de Astro para tu estructura básica](/es/basics/astro-components/), mientras importas e incluyes componentes individuales de React (¡que pueden ser aplicaciones completas en sí mismas!) para islas de interactividad.
-
-Cada migración será diferente y se puede realizar de manera incremental sin interrumpir tu aplicación en funcionamiento. Convierte piezas individuales a tu propio ritmo, de modo que cada vez más de tu aplicación esté impulsada por componentes de Astro con el tiempo.
-
-A medida que conviertas tu aplicación de React, decidirás qué componentes de React r[eescribirás como componentes de Astro](#convirtiendo-archivos-jsx-a-archivos-astro). La única restricción es que los componentes de Astro pueden importar componentes de React, pero los componentes de React solo pueden importar otros componentes de React.
-
-```astro title="src/pages/static-components.astro" ins={2,7}
----
-import MiComponenteDeReact from '../components/MiComponenteDeReact.jsx';
----
-<html>
-  <body>
-    <h1>¡Utiliza componentes React directamente en Astro!</h1>
-    <MiComponenteDeReact />
-  </body>
-</html>
-```
-
-En lugar de importar componentes de Astro dentro de componentes de React, puedes anidar componentes de React dentro de un único componente de Astro:
-
-```astro title="src/pages/nested-components.astro" {2,3,5,8,10}
----
-import MiSidebarDeReact from '../components/MiSidebarDeReact.jsx';
-import MiBotonDeReact from '../components/MiBotonDeReact.jsx';
----
-<MiSidebarDeReact>
-  <p>Aquí hay una sidebar con algo de texto y un botón.</p>
-  <div slot="actions">
-    <MiBotonDeReact client:idle />
-  </div>
-</MiSidebarDeReact>
-```
-
-Puede ser útil que aprendas acerca de [las islas de Astro](/es/concepts/islands/) y [los componentes de Astro](/es/basics/astro-components/) antes de reestructurar tu proyecto CRA como un proyecto Astro.
-
-### Compara: JSX vs Astro
-
-Compare el siguiente componente CRA y el componente Astro correspondiente:
-
-<AstroJSXTabs>
-  <Fragment slot="jsx">
-    ```jsx title="StarCount.jsx"
-    import React, { useState, useEffect } from 'react';
-import Header from './Header';
-import Footer from './Footer';
-
-const Component = () => {
-    const [stars, setStars] = useState(0);
-    const [message, setMessage] = useState('');
-
-    useEffect(() => {
-        const fetchData = async () => {
-            const res = await fetch('https://api.github.com/repos/withastro/astro');
-            const json = await res.json();
-
-            setStars(json.stargazers_count || 0);
-            setMessage(json.message);
-        };
-
-        fetchData();
-    }, []);
-
-    return (
-        <>
-            <Header />
-            <p style={{
-                backgroundColor: `#f4f4f4`,
-                padding: `1em 1.5em`,
-                textAlign: `center`,
-                marginBottom: `1em`
-            }}>Astro tiene {stars} 🧑‍🚀</p>
-            <Footer />
-        </>
-    )
-};
-
-export default Component;
-    ```
-  </Fragment>
-  <Fragment slot="astro">
-    ```astro title="StarCount.astro"
-    ---
-    import Header from './Header.astro';
-    import Footer from './Footer.astro';
-    import './layout.css';
-    const res = await fetch('https://api.github.com/repos/withastro/astro')
-    const json = await res.json();
-    const message = json.message;
-    const stars = json.stargazers_count || 0;
-    ---
-    <Header />
-    <p class="banner">Astro tiene {stars} 🧑‍🚀</p>
-    <Footer />
-    <style>
-      .banner {
-        background-color: #f4f4f4; 
-        padding: 1em 1.5em;
-        text-align: center;
-        margin-bottom: 1em;
-      }
-    <style>
-    ```
-  </Fragment>
-</AstroJSXTabs>
-
-
-### Convirtiendo archivos JSX a archivos `.astro`
-
-Aquí tienes algunos consejos para convertir un componente de CRA `.js` a un componente `.astro`:
-
-1. Utiliza el JSX devuelto por la función del componente CRA existente como base para tu plantilla HTML.
-
-2. Convierte cualquier [sintaxis CRA o JSX a Astro](#referencia-convertir-sintaxis-de-cra-a-astro) o a los estándares web de HTML. Esto incluye `{children}` y `className`, por ejemplo.
-
-3. Mueve cualquier JavaScript necesario, incluyendo declaraciones de importación, dentro de una ["valla de código" (`---`)](/es/basics/astro-components/#script-de-un-componente). Nota: El JavaScript para [renderizar contenido condicional](/es/reference/astro-syntax/#html-dinamico) a menudo se escribe directamente dentro de la plantilla HTML en Astro.
-
-4. Utiliza [`Astro.props`](/es/reference/api-reference/#astroprops) para acceder a cualquier prop adicional que haya sido pasada previamente a tu función CRA.
-
-5. Decide si también es necesario convertir a Astro los componentes importados. Por el momento, puedes mantenerlos como componentes de React o hacerlo de forma permanente. Sin embargo, es posible que eventualmente desees convertirlos a componentes `.astro`, ¡especialmente si no necesitan ser interactivos!.
-
-6. Reemplaza `useEffect()` con declaraciones de importación o [`Astro.glob()`](/es/reference/api-reference/#astroglob) para consultar tus archivos locales. Utiliza `fetch()` para obtener datos externos.
-
-### Migrando Tests
-
-Como Astro genera HTML directamente, es posible escribir tests end-to-end utilizando la salida del paso de compilación. Cualquier test end-to-end escrito anteriormente podría funcionar de forma predeterminada si has podido igualar el marcado de tu sitio de CRA. Bibliotecas de pruebas como Jest y React Testing Library pueden ser importadas y utilizadas en Astro para probar tus componentes de React.
-
-Consulta la [guía de pruebas](/es/guides/testing/) de Astro para obtener más información.
-
-## Referencia: Convertir Sintaxis de CRA a Astro
-
-### Importaciones de CRA a Astro
-
-Actualiza todas las [importaciones de archivos](/es/guides/imports/) para hacer referencia a rutas de archivos relativas exactas. Esto puede hacerse utilizando un [alias de importación](/es/guides/typescript/#alias-de-importación) o escribiendo la ruta relativa completa.
-
-Ten en cuenta que los archivos `.astro` y varios otros tipos de archivos deben ser importados con su extensión de archivo completa.
-
-```astro title="src/pages/authors/Fred.astro"
----
-import Card from '../../components/Card.astro';
----
-<Card />
-```
-
-### Props Children de CRA a Astro
-
-Convierte cualquier instancia de `{children}` a un Astro `<slot />`. Astro no necesita recibir `{children}` como una propiedad de función y automáticamente renderizará el contenido del hijo en un `<slot />`.
-
-```astro title="src/components/MiComponent.astro" del={3-9} ins={11-13}
----
----
-export default function MiComponent(props) { 
-    return (
-      <div>
-        {props.children}
-      </div>
-    );  
-}
-
-<div>
-  <slot />
-</div>
-```
-
-Los componentes de React que pasan múltiples conjuntos de hijos pueden migrarse a un componente de Astro utilizando [slots con nombre](/es/basics/astro-components/#slots-con-nombre).
-
-Para obtener más información sobre el uso específico de `<slot />` en Astro, consulta [Slots](/es/basics/astro-components/#slots).
-
-### Data Fetching de CRA a Astro
-
-Obteniendo datos en un componente de Create React App es similar a Astro, con algunas pequeñas diferencias.
-
-Deberás eliminar cualquier instancia de un hook de efecto secundario (`useEffect`) tanto para `Astro.glob()` como para `getCollection()`/`getEntryBySlug()` para acceder a datos desde otros archivos en la fuente de tu proyecto.
-
-Para [obtener datos remotos](/es/guides/data-fetching/), utiliza `fetch()`.
-
-Estas solicitudes de datos se realizan en el frontmatter del componente de Astro y utilizan el await de nivel superior.
-
-```astro title="src/pages/index.astro"
----
-import { getCollection } from 'astro:content';
-
-// Obtener todas las entradas de `src/content/blog/`
-const allBlogPosts = await getCollection('blog');
-
-// Obtener todas las entradas de `src/pages/posts/`
-const allPosts = await Astro.glob('../pages/posts/*.md');
-
-// Obtener datos remotos
-const response = await fetch('https://randomuser.me/api/');
-const data = await response.json();
-const randomUser = data.results[0];
----
-```
-
-Mira más sobre [importaciones de archivos locales con `Astro.glob()`](/es/guides/imports/#astroglob), [consulta utilizando la API de Colecciones](/es/guides/content-collections/#consultando-colecciones) o [obtención de datos remotos](/es/guides/data-fetching/).
-
-### Estilando CRA a Astro
-
-Es posible que necesites reemplazar cualquier [biblioteca de CSS-in-JS](https://github.com/withastro/astro/issues/4432) (p. ej. styled-components) con otras opciones de CSS disponibles en Astro.
-
-Si es necesario, convierte cualquier objeto de estilo en línea (`style={{ fontWeight: "bold" }}`) en atributos de estilo HTML en línea (`style="font-weight:bold;"`). O bien, utiliza una [etiqueta `<style>` de Astro](/es/guides/styling/#estilando-en-astro) para estilos CSS con alcance local.
-
-```astro title="src/components/Card.astro" del={1} ins={2}
-<div style={{backgroundColor: `#f4f4f4`, padding: `1em`}}>{message}</div>
-<div style="background-color: #f4f4f4; padding: 1em;">{message}</div>
-```
-
-Tailwind es compatible después de instalar la [integración de Tailwind](/es/guides/integrations-guide/tailwind/). ¡No se requieren cambios en tu código existente de Tailwind!
-
-Mira más sobre [Estilando en Astro](/es/guides/styling/).
-
-## Solución de problemas
-
-¡Es posible que tu aplicación de Create React App funcione "tal cual"!, pero es probable que necesites hacer ajustes menores para duplicar la funcionalidad y/o estilos de tu aplicación existente.
-
-Si no encuentras respuestas en esta documentación, por favor visita el [Discord de Astro](https://astro.build/chat) y haz preguntas en nuestro foro de soporte. ¡Estaremos encantados de ayudarte!
diff --git a/src/content/docs/es/guides/migrate-to-astro/from-docusaurus.mdx b/src/content/docs/es/guides/migrate-to-astro/from-docusaurus.mdx
deleted file mode 100644
index b7650ad1945ff..0000000000000
--- a/src/content/docs/es/guides/migrate-to-astro/from-docusaurus.mdx
+++ /dev/null
@@ -1,73 +0,0 @@
----
-title: Migrando desde Docusaurus
-description: Consejos para migrar un proyecto existente de Docusaurus a Astro
-type: migration
-stub: true
-framework: Docusaurus
-i18nReady: true
----
-
-import PackageManagerTabs from '~/components/tabs/PackageManagerTabs.astro'
-
-[Docusaurus](https://Docusaurus.io) es un popular constructor de sitios web de documentación construido con React.
-
-## Principales similitudes entre Docusaurus y Astro
-
-Docusaurus y Astro comparten algunas similitudes que te ayudarán a migrar tu proyecto:
-
-- Astro y Docusaurus son constructores de sitios web modernos basados en JavaScript (Jamstack), [orientadas al contenido](/es/concepts/why-astro/#orientado-al-contenido), como sitios de documentación. 
-
-- Astro y Docusaurus admiten [páginas MDX](/es/guides/markdown-content/). Deberías poder utilizar tus archivos `.mdx` existentes en Astro.
-
-- Astro y Docusaurus usan el [enrutamiento basado en archivos](/es/guides/routing/) para generar rutas de de página automáticamente para cualquier archivo MDX ubicado en `src/pages`. El uso de la estructura de archivos de Astro para tu contenido existente y al agregar nuevas páginas debería ser familiar.
-
-- Astro tiene una [integración oficial para usar componentes de React](/es/guides/integrations-guide/react/). Ten en cuenta que en Astro, los archivos de React **deben** tener la extensión `.jsx` o `.tsx`.
-
-- Astro admite la [instalación de paquetes de NPM](/es/guides/imports/#paquetes-npm), incluyendo varios para React. Podrás conservar algunos o todos tus componentes y dependencias existentes de React.
-
-- [La sintaxis similar a JSX de Astro](/es/basics/astro-components/#maquetado-del-componente) debería resultarte familiar si estás acostumbrado a escribir en React.
-
-
-## Principales diferencias entre Docusaurus y Astro
-
-Cuando reconstruyas tu sitio de Docusaurus a Astro, notarás algunas diferencias importantes:
-
-- Docusaurus es una aplicación de una sola página (SPA) construida en React. Los sitios de Astro son aplicaciones de varias páginas construidas utilizando [componentes `.astro`](/es/basics/astro-components/), pero también puede admitir [React, Preact, Vue.js, Svelte, SolidJS, AlpineJS, Lit](/es/guides/framework-components/) y plantillas de HTML sin procesar.
-
-- Docusaurus fue diseñado para construir sitios web de documentación y tiene algunas características integradas, específicas para sitios web de documentación que tendrás que construir por ti mismo en Astro. En cambio, Astro ofrece algunas de estas características a través de un [Starlight: un tema oficial de documentación](https://starlight.astro.build). ¡Este sitio web fue la inspiración para Starlight y ahora se ejecuta en el ! También puedes encontrar más [temas de documentación de la comunidad](https://astro.build/themes?search=&categories%5B%5D=docs) con características integradas en nuestro mostrador de temas.
-
-- Los sitios de Docusaurus utilizan páginas MDX para el contenido. El tema de documentación de Astro utiliza archivos Markdown (`.md`) por defecto y no requiere que utilices MDX. Opcionalmente puedes [instalar la integración de MDX de Astro](/es/guides/integrations-guide/mdx/) (incluida en nuestro tema de Starlight por defecto) y usar archivos `.mdx` además de los archivos de Markdown estándar.
-
-
-## Migrar de Docusaurus a Astro
-
-Para convertir un sitio de documentación de Docusaurus a Astro, empieza con nuestra [plantilla oficial de inicio para documentación Starlight](https://starlight.astro.build), o explora más temas de la comunidad en nuestro [catálogo de temas](https://astro.build/themes?search=&categories%5B%5D=docs). 
-
-Puedes pasar el argumento `--template` al comando `create astro`  para empezar un nuevo proyecto de Astro con una de nuestras plantillas oficiales. O, puedes [comenzar un nuevo proyecto desde cualquier repositorio de Astro existente en GitHub](/es/install-and-setup/#usa-un-tema-o-una-plantilla-de-inicio).
-
-  <PackageManagerTabs>
-    <Fragment slot="npm">
-    ```shell
-    npm create astro@latest -- --template starlight
-    ```
-    </Fragment>
-    <Fragment slot="pnpm">
-    ```shell
-    pnpm create astro@latest --template starlight
-    ```
-    </Fragment>
-    <Fragment slot="yarn">
-    ```shell
-    yarn create astro --template starlight
-    ```
-    </Fragment>
-  </PackageManagerTabs>
-
-
-La integración de MDX de Astro está incluida por defecto, por lo que puedes [traer tus archivos de contenido existentes a Starlight](https://starlight.astro.build/es/getting-started/#add-content) de inmediato.
-
-Puedes encontrar la plantilla inicial de documentación de Astro, y otras plantillas oficiales, en [astro.new](https://astro.new). Encontrarás un enlace al repositorio de GitHub de cada proyecto, así como enlaces de un solo clic para abrir un proyecto de trabajo en los entornos de desarrollo en línea de StackBlitz, CodeSandbox y Gitpod.
-
-## Recursos de la comunidad
-
-- ¡Añade el tuyo propio!
diff --git a/src/content/docs/es/guides/migrate-to-astro/from-eleventy.mdx b/src/content/docs/es/guides/migrate-to-astro/from-eleventy.mdx
deleted file mode 100644
index 3c76766c1429f..0000000000000
--- a/src/content/docs/es/guides/migrate-to-astro/from-eleventy.mdx
+++ /dev/null
@@ -1,68 +0,0 @@
----
-title: Migrando desde Eleventy
-description: Consejos para migrar un proyecto existente de Eleventy a Astro
-type: migration
-stub: true
-framework: Eleventy
-i18nReady: true
----
-
-import PackageManagerTabs from '~/components/tabs/PackageManagerTabs.astro'
-
-[Eleventy](https://11ty.dev) es un generador de sitios estáticos de código abierto que funciona con varios lenguajes de plantillas.
-
-## Principales similitudes entre Eleventy (11ty) y Astro
-
-Eleventy (11ty) y Astro comparten algunas similitudes que te ayudarán a migrar tu proyecto:
-
-- Tanto Astro como Eleventy son generadores de sitios modernos basados en JavaScript (Jamstack).
-
-- Astro y Eleventy te permiten usar un [CMS headless, APIs o archivos Markdown para datos](/es/guides/data-fetching/). Puedes continuar usando tu sistema de autoría de contenido preferido, y podrás mantener tu contenido existente.
-
-- Astro y Eleventy construyen aplicaciones de múltiples páginas.
-
-## Principales diferencias entre Eleventy (11ty) y Astro
-
-Cuando reconstruyas tu sitio de Eleventy (11ty) en Astro, notarás algunas diferencias importantes:
-
-- Eleventy admite una variedad de lenguajes de plantillas. Astro admite [la inclusión de componentes de varios frameworks populares de JavaScript (por ejemplo, React, Svelte, Vue, Solid)](/es/guides/framework-components/), pero utiliza [diseños, páginas y componentes de Astro](/es/basics/astro-components/) para la mayoría de las plantillas de páginas.
-
-- Astro usa una [carpeta `src/`](/es/basics/project-structure/#src) para todos los archivos, incluidos los metadatos del sitio, que están disponibles para consultas y procesamiento durante la construcción del sitio. Dentro de este directorio se encuentra una [carpeta especial `src/pages/` para el enrutamiento basado en archivos](/es/basics/astro-pages/).
-
-- Astro usa una [carpeta `public/` para activos estáticos](/es/basics/project-structure/#public) que no necesitan ser procesados ni transformados durante la construcción.
-
-- En Eleventy, el empaquetado de CSS, JavaScript y otros activos debe configurarse manualmente. [Astro lo maneja por ti de forma predeterminada](/es/concepts/why-astro/#fácil-de-usar).
-
-## Migrar de Eleventy a Astro
-
-Para convertir un blog de Eleventy a Astro, comienza con nuestra plantilla de inicio de tema de blog, o explora más temas de blog de la comunidad en nuestro [mostrador de temas](https://astro.build/themes/).
-
-Puedes pasar el argumento `--template` al comando `create astro` para empezar un nuevo proyecto de Astro con una de nuestras plantillas oficiales. O, puedes [comenzar un nuevo proyecto desde cualquier repositorio de Astro existente en GitHub](/es/install-and-setup/#usa-un-tema-o-una-plantilla-de-inicio).
-
-  <PackageManagerTabs>
-    <Fragment slot="npm">
-    ```shell
-    npm create astro@latest -- --template blog
-    ```
-    </Fragment>
-    <Fragment slot="pnpm">
-    ```shell
-    pnpm create astro@latest --template blog
-    ```
-    </Fragment>
-    <Fragment slot="yarn">
-    ```shell
-    yarn create astro --template blog
-    ```
-    </Fragment>
-  </PackageManagerTabs>
-
-Trae tus archivos Markdown existentes (o MDX, con nuestra integración opcional) como contenido para [crear páginas Markdown o MDX](/es/guides/markdown-content/).
-
-Tu proyecto Eleventy te permitió usar una variedad de lenguajes plantilla para construir tu sitio. En un proyecto Astro, la plantilla de página se logrará principalmente con componentes de Astro, que se pueden usar como elementos de IU, diseños e incluso páginas completas. Puedes explorar [la sintaxis de componentes de Astro](/es/basics/astro-components/) para ver cómo plantillar en Astro usando componentes.
-
-Para convertir otros tipos de sitios, como un portafolio o un sitio de documentación, consulta más plantillas de inicio oficiales en [astro.new](https://astro.new). Encontrarás un enlace al repositorio de GitHub de cada proyecto, así como enlaces de un clic para abrir un proyecto de trabajo en los entornos de desarrollo en línea de StackBlitz, CodeSandbox y Gitpod.
-
-## Recursos de la Comunidad
-
-- ¡Añade el tuyo!
diff --git a/src/content/docs/es/guides/migrate-to-astro/from-gatsby.mdx b/src/content/docs/es/guides/migrate-to-astro/from-gatsby.mdx
deleted file mode 100644
index 1a570bc4f9765..0000000000000
--- a/src/content/docs/es/guides/migrate-to-astro/from-gatsby.mdx
+++ /dev/null
@@ -1,583 +0,0 @@
----
-title: Migrando desde Gatsby
-description: Consejos para migrar un proyecto existente de Gatsby a Astro
-type: migration
-stub: false
-framework: Gatsby
-i18nReady: true
----
-import { Steps } from '@astrojs/starlight/components';
-import AstroJSXTabs from '~/components/tabs/AstroJSXTabs.astro'
-import PackageManagerTabs from '~/components/tabs/PackageManagerTabs.astro'
-
-Aquí hay algunos conceptos clave y estrategias de migración para ayudarte a comenzar. ¡Utiliza el resto de nuestra documentación y nuestra [comunidad en Discord](https://astro.build/chat) para seguir adelante!
-
-## Principales similitudes entre Gatsby y Astro
-
-Gatsby y Astro comparten algunas similitudes que te ayudarán a migrar tu proyecto:
-
-- La [sintaxis de los archivos `.astro` es similar a JSX](/es/reference/astro-syntax/#expresiones-similares-a-jsx). Escribir en Astro debería sentirse familiar.
-
-- Astro tiene soporte integrado para [Markdown](/es/guides/markdown-content/) y una integración para utilizar archivos MDX. Además, puedes configurar y seguir utilizando muchos de tus plugins de Markdown existentes.
-
-- Astro también cuenta con una [integración oficial para usar componentes de React](/es/guides/integrations-guide/react/). Ten en cuenta que en Astro, los archivos de React **deben** tener una extensión `.jsx` o `.tsx`.
-
-- Astro tiene soporte para [instalar paquetes de NPM](/es/guides/imports/#paquetes-npm), incluyendo bibliotecas de React. Muchas de tus dependencias existentes funcionarán en Astro.
-
-- Al igual que en Gatsby, los proyectos de Astro pueden SSG o [SSR con prerrenderizado a nivel de página](/es/guides/on-demand-rendering/).
-
-## Principales diferencias entre Gatsby y Astro
-
-Cuando reconstruyes tu sitio de Gatsby en Astro, notarás algunas diferencias importantes:
-
-- Los proyectos de Gatsby son aplicaciones de una sola página (SPA) de React y utilizan `index.js` como raíz del proyecto. Los proyectos de Astro son sitios multipágina y `index.astro` es tu página de inicio.
-
-- [Componentes Astro](/es/basics/astro-components/) No se escriben como funciones exportadas que devuelven plantillas de páginas. En su lugar, dividirás tu código en un "bloque de codigo" para tu JavaScript y un cuerpo exclusivamente para el HTML que generes.
-
-- [Datos de archivos locales](/es/guides/imports/): Gatsby utiliza GraphQL para recuperar datos de los archivos de tu proyecto. Astro utiliza importaciones de ESM y funciones de espera en el nivel superior (p. ej. [`Astro.glob()`](/es/guides/imports/#astroglob), [`getCollection()`](/es/guides/content-collections/#consultando-colecciones)) para importar datos de los archivos de tu proyecto. Puedes agregar manualmente GraphQL a tu proyecto de Astro, pero no está incluido de forma predeterminada.
-
-## Convierte tu proyecto de Gatsby
-
-Cada migración de proyecto será diferente, pero hay algunas acciones comunes que realizarás al convertir de Gatsby a Astro.
-
-### Crear un nuevo proyecto de Astro
-Utiliza el comando `create astro` en tu gestor de paquetes para iniciar el asistente de línea de comandos de Astro o elige un tema de la comunidad desde el [Catálogo de Temas de Astro](https://astro.build/themes).
-
-Puedes pasar el argumento `--template` al comando `create astro` para iniciar un nuevo proyecto de Astro con uno de nuestros inicios oficiales (p. ej. `docs`, `blog`, `portfolio`). Alternativamente, puedes [iniciar un nuevo proyecto a partir de cualquier repositorio de Astro existente en GitHub](/es/install-and-setup/#usa-un-tema-o-una-plantilla-de-inicio).
-
-  <PackageManagerTabs>
-    <Fragment slot="npm">
-    ```shell
-    # Inicia el Asistente de la CLI de Astro 
-    npm create astro@latest
-
-    # Crea un nuevo proyecto con un ejemplo oficial
-    npm create astro@latest -- --template <nombre-del-ejemplo>
-    ```
-    </Fragment>
-    <Fragment slot="pnpm">
-    ```shell
-    # Inicia el Asistente de la CLI de Astro 
-    pnpm create astro@latest
-
-    # Crea un nuevo proyecto con un ejemplo oficial
-    pnpm create astro@latest --template <nombre-del-ejemplo>
-    ```
-    </Fragment>
-    <Fragment slot="yarn">
-    ```shell
-    # Inicia el Asistente de la CLI de Astro 
-    yarn create astro@latest
-
-    # Crea un nuevo proyecto con un ejemplo oficial
-    yarn create astro@latest --template <nombre-del-ejemplo>
-    ```
-    </Fragment>
-  </PackageManagerTabs>
-
-A continuación, copia los archivos de tu proyecto de Gatsby existente a tu nuevo proyecto de Astro en una carpeta separada fuera de `src`.
-
-:::tip
-Visita https://astro.new para obtener la lista completa de plantillas de inicio oficiales, y enlaces para abrir un nuevo proyecto en StackBlitz, CodeSandbox o Gitpod.
-:::
-
-### Instalar integraciones (opcional)
-
-Puede resultarte útil instalar algunas de las [integraciones opcionales de Astro](/es/guides/integrations-guide/) para utilizar durante la conversión de tu proyecto de Gatsby a Astro:
-
-- **@astrojs/react**: para reutilizar algunos componentes UI de React existentes en tu nuevo sitio Astro o seguir escribiendo con componentes de React.
-
-- **@astrojs/mdx**: para llevar los archivos MDX existentes de tu proyecto de Gatsby o utilizar MDX en tu nuevo sitio Astro.
-
-### Pon tu código en `src`
-
-Siguiendo la [estructura de proyecto de Astro](/es/basics/project-structure/):
-
-<Steps>
-1. **Elimina** la carpeta `public/` de Gatsby. 
-    
-    Gatsby utiliza el directorio `public/` dpara la salida de compilación, por lo que puedes descartar de forma segura esta carpeta. Ya no necesitarás una versión compilada de tu sitio de Gatsby. (Astro utiliza `dist/` de forma predeterminada para la salida de compilación)
-
-2. **Renombra** la carpeta `static/` de Gatsby a `public/`, y úsala como la carpeta `public/` de Astro. 
-
-    Astro utiliza una carpeta llamada `public/` para los activos estáticos. Como alternativa, puedes copiar el contenido de `static/` ien la carpeta `public/` existente de Astro.
-
-3. **Copia o mueve** los otros archivos y carpetas de Gatsby (p. ej. `components`, `pages`, etc.) según sea necesario en tu carpeta `src/` de Astro a medida que reconstruyes tu sitio, siguiendo la [estructura de proyecto de Astro](/es/basics/project-structure/).
-
-    La carpeta `src/pages/` de Astro es una carpeta especial utilizada para la creación de páginas y publicaciones de tu sitio mediante enrutamiento basado en archivos a partir de archivos `.astro`, `.md` y `.mdx`. No será necesario configurar ningún comportamiento de enrutamiento para tus archivos Astro, Markdown y MDX en Astro.
-
-    Todas las demás carpetas son opcionales y puedes organizar el contenido de tu carpeta `src/` de la forma que desees. Otras carpetas comunes en proyectos de Astro incluyen `src/layouts/`, `src/components`, `src/styles`, y `src/scripts`.
-</Steps>
-
-### Consejos: Convierte archivos JSX a archivos `.astro`
-
-Aquí tienes algunos consejos para convertir un componente de Gatsby con extensión `.js` a un componente `.astro`:
-
-1. Utiliza únicamente el bloque `return()` de la función del componente de Gatsby existente como tu plantilla HTML en Astro.
-
-2. Cambia cualquier [sintaxis de Gatsby o JSX a la sintaxis de Astro](#referencia-convertir-a-sintaxis-de-astro) o a los estándares web de HTML. Esto incluye `<Link to="">`, `{children}`, y `className`, por ejemplo.
-
-3. Mueve cualquier JavaScript necesario, incluyendo las declaraciones de importación, a un ["bloque de código" (`---`)](/es/basics/astro-components/#script-de-un-componente). Nota: JavaScript para [renderizar contenido condicionalmente](/es/reference/astro-syntax/#html-dinamico) a menudo se escribe directamente dentro de la plantilla HTML en Astro.
-
-4. Utiliza [`Astro.props`](/es/reference/api-reference/#astroprops) para acceder a cualquier prop adicional que se haya pasado previamente a tu función de Gatsby.
-
-5. Decide si también es necesario convertir a Astro los componentes importados. Con la integración oficial de React instalada, puedes utilizar los componentes de React existentes en tus archivos de Astro](/es/guides/framework-components/). Sin embargo, es posible que desees convertirlos en componentes `.astro`, ¡especialmente si no necesitan ser interactivos!
-
-6. Elimina cualquier consulta de GraphQL. En su lugar, utiliza declaraciones de importación y [`Astro.glob()`](/es/reference/api-reference/#astroglob) para realizar consultas en tus archivos locales.
-
-Consulta [un ejemplo de la plantilla de inicio del blog de Gatsby convertido paso a paso](#ejemplo-guiado-convertir-un-diseño-de-gatsby-a-astro)
-
-#### Comparación: `.jsx` vs `.astro`
-
-Compara el siguiente componente de Gatsby con su equivalente en Astro:
-
-<AstroJSXTabs>
-  <Fragment slot="jsx">
-    ```jsx title="component.jsx"
-    import * as React from "react"
-    import { useStaticQuery, graphql } from "gatsby"
-    import Header from "./header"
-    import Footer from "./footer"
-    import "./layout.css"
-
-    const Component = ({ message, children }) => {
-      const data = useStaticQuery(graphql`
-        query SiteTitleQuery {
-          site {
-            siteMetadata {
-              title
-            }
-          }
-        }
-      `)
-      return (
-        <>
-          <Header siteTitle={data.site.siteMetadata.title} />
-          <div style={{ margin: `0`, maxWidth: `960`}}>{message}</div>
-          <main>{children}</main>
-          <Footer siteTitle={data.site.siteMetadata} />
-        </>
-      )
-    }
-
-    export default Component
-    ```
-  </Fragment>
-
-  <Fragment slot="astro">
-    ```astro title="component.astro"
-    ---
-    import Header from "./Header.astro"
-    import Footer from "./Footer.astro"
-    import "../styles/stylesheet.css"
-    import { site } from "../data/siteMetaData.js"
-    const { message } = Astro.props
-    ---
-    <Header siteTitle={site.title} />
-      <div style="margin: 0; max-width: 960;">{message}</div>
-      <main>
-        <slot />
-      </main>
-    <Footer siteTitle={site.title} />
-    ```
-  </Fragment>
-</AstroJSXTabs>
-
-### Migrando archivos de diseño
-
-Puede resultarte útil comenzar convirtiendo tus diseños y plantillas de Gatsby en [componentes de diseño de Astro](/es/basics/layouts/).
-
-Cada página en Astro requiere explícitamente las etiquetas `<html>`, `<head>`, y `<body>` para estar presentes, por lo que es común reutilizar un archivo de diseño en varias páginas. Astro utiliza un elemento [`<slot />`](/es/basics/astro-components/#slots) en lugar de la prop `{children}` de React para el contenido de la página, y no se requiere ninguna declaración de importación. Tus archivos `layout.js` y plantillas de Gatsby no incluirán esto.
-
-Ten en cuenta la plantilla HTML estándar y el acceso directo a  `<head>`:  
-
-```astro title="src/layouts/Layout.astro" "slot"
-<html lang="en">
-  <head>
-    <meta charset="utf-8" />
-    <link rel="icon" type="image/svg+xml" href="/favicon.svg" />
-    <meta name="viewport" content="width=device-width" />
-    <title>Astro</title>
-  </head>
-  <body>
-    <!-- Envuelve el elemento de <slot> con tu plantilla de diseño existente -->
-    <slot />
-  </body>
-</html>
-```
-
-También puedes reutilizar el código del archivo `src/components/seo.js` de Gatsby para incluir metadatos adicionales del sitio. Observa que Astro no utiliza ni `<Helmet>` ni `<Header>` sino que crea `<head>` directamente. Puedes importar y utilizar componentes, incluso dentro de `<head>`, para separar y organizar el contenido de tu página.
-
-### Migrando páginas y publicaciones
-
-En Gatsby, tus [páginas y publicaciones](/es/basics/astro-pages/) pueden existir en `src/pages/` o fuera de `src` en otra carpeta, como `content`. En Astro, **todo el contenido de tu página debe estar dentro de `src/`**.
-
-#### Páginas de React
-
-Tus páginas existentes de Gatsby en formato JSX (`.js`) deberán ser [convertidas de archivos JSX a páginas `.astro`](#consejos-convierte-archivos-jsx-a-archivos-astro). No puedes utilizar un archivo de página JSX existente en Astro.
-
-Estas [páginas `.astro`](/es/basics/astro-pages/) deben estar ubicadas dentro de `src/pages/` y tendrán rutas de página generadas automáticamente en función de la ruta de su archivo.
-
-#### Páginas Markdown y MDX
-
-Astro tiene soporte integrado para Markdown y una integración opcional para archivos MDX. Tus archivos existentes de [Markdown y MDX](/es/guides/markdown-content/) pueden ser reutilizados, pero pueden requerir algunos ajustes en su frontmatter, como agregar [la propiedad especial de frontmatter de Astro `layout`](/es/basics/layouts/#plantillas-de-markdown). TTambién puedes colocarlos dentro de `src/pages/` para aprovechar el enrutamiento automático basado en archivos.
-
-Alternativamente, puedes utilizar [colecciones de contenido](/es/guides/content-collections/) en Astro para almacenar y gestionar tu contenido. Cuando forman parte de una colección, los archivos Markdown y MDX estarán ubicados en carpetas dentro de `src/content/`. Deberás recuperar el contenido tú mismo y [generar esas páginas dinámicamente](/es/guides/content-collections/#generando-rutas-desde-el-contenido).
-
-### Migrando Tests
-
-Astro genera HTML sin procesar, lo que permite escribir pruebas de extremo a extremo utilizando la salida del paso de construcción. Es posible que las pruebas de extremo a extremo escritas previamente funcionen sin problemas si has logrado igualar el marcado del sitio antiguo de Gatsby. Puedes importar y utilizar bibliotecas de pruebas como Jest y React Testing Library en Astro para probar tus componentes de React.
-
-Consulta la [guía de testing](/es/guides/testing/) de Astro para obtener más información.
-
-### Reutilizar archivos de configuración
-
-Gatsby tiene varios archivos de configuración de nivel superior que también incluyen metadatos del sitio y de las páginas, y se utilizan para el enrutamiento. No utilizarás ninguno de estos archivos `gatsby-*.js` en tu proyecto de Astro, pero es posible que haya algún contenido que puedas reutilizar a medida que construyas tu proyecto de Astro.
-
-- `gatsby-config.js`: Mueve tu `siteMetadata: {}` a `src/data/siteMetadata.js` (o `siteMetadata.json`) para importar datos sobre tu sitio (title, description, social accounts, etc.) en las plantillas de página.
-
-- `gatsby-browser.js`: Considera agregar cualquier cosa utilizada aquí directamente en la etiqueta `<head>` de tu [diseño principal](#migrando-archivos-de-diseño).
-
-- `gatsby-node.js`: No necesitarás crear tus propios nodos en Astro, pero ver el esquema en este archivo puede ayudarte a definir tipos en tu proyecto de Astro.
-
-- `gatsby-ssr.js`: Si decides utilizar SSR en Astro, deberás [añadir y configurar el adaptador SSR](/es/guides/on-demand-rendering/) de tu elección directamente en `astro.config.mjs`.
-
-## Referencia: Convertir a Sintaxis de Astro
-
-A continuación se presentan algunos ejemplos de sintaxis específica de Gatsby que deberás convertir a Astro. Consulta más [diferencias entre Astro y JSX](/es/reference/astro-syntax/#diferencias-entre-astro-y-jsx) en la guía para escribir componentes de Astro.
-
-### Links de Gatsby a Astro
-
-Convierte cualquier componente de Gatsby `<Link to="">`, `<NavLink>` u otros a etiquetas HTML `<a href="">`. 
-
-```astro del={1} ins={2}
-<Link to="/blog">Blog</Link>
-<a href="/blog">Blog</a>
-```
-
-Astro no utiliza ningún componente especial para los enlaces, aunque puedes construir tu propio componente `<Link>`. Luego puedes importarlo y usarlo como lo harías con cualquier otro componente.
-
-```astro title="src/components/Link.astro"
----
-const { to } = Astro.props
----
-<a href={to}><slot /></a>
-```
-
-### Importaciones de Gatsby a Astro
-
-Si es necesario, actualiza cualquier [importación de archivos](/es/guides/imports/) para que haga referencia a rutas de archivos relativas de manera exacta. Esto se puede hacer utilizando [alias de importación](/es/guides/typescript/#alias-de-importación), o escribiendo la ruta relativa completa.
-
-Ten en cuenta que los archivos `.astro` y varios otros tipos de archivo deben ser importados con su extensión de archivo completa.
-
-```astro title="src/pages/authors/Fred.astro" ".astro"
----
-import Card from `../../components/Card.astro`;
----
-<Card />
-```
-
-### Props Children de Gatsby a Astro
-
-Convierte cualquier instancia de `{children}` a un `<slot />` de Astro. Astro no necesita recibir `{children}` como una función de prop y automáticamente renderizará el contenido hijo en un `<slot />`.
-
-```astro title="src/components/MyComponent" del={3-9} ins={11-13}
----
----
-export default function MyComponent(props) { 
-    return (
-      <div>
-        {props.children}
-      </div>
-    );  
-}
-
-<div>
-  <slot />
-</div>
-```
-
-Los componentes de React que pasan múltiples conjuntos de hijos se pueden migrar a un componente Astro utilizando [slots con nombre](/es/basics/astro-components/#slots-con-nombre). 
-
-Puedes obtener más información sobre [el uso específico de `<slot />` uen Astro](/es/basics/astro-components/#slots).
-
-### Estilos de Gatsby a Astro
-
-Es posible que debas reemplazar cualquier biblioteca de [CSS-in-JS](https://github.com/withastro/astro/issues/4432) (p. ej. styled-components) con otras opciones de CSS disponibles en Astro.
-
-Si es necesario, convierte cualquier objeto de estilo en línea (`style={{ fontWeight: "bold" }}`) a atributos de estilo en línea de HTML (`style="font-weight:bold;"`). O bien, utiliza una etiqueta [`<style>` de Astro](/es/guides/styling/#estilando-en-astro) para estilos CSS con ámbito.
-
-```astro title="src/components/Card.astro" del={1} ins={2}
-<div style={{backgroundColor: `#f4f4f4`, padding: `1em`}}>{message}</div>
-<div style="background-color: #f4f4f4; padding: 1em;">{message}</div>
-```
-
-Tailwind es compatible después de instalar la [integración de Tailwind](/es/guides/integrations-guide/tailwind/). ¡No se requieren cambios en tu código de Tailwind existente!
-
-La estilización global se logra en Gatsby mediante la importación de archivos CSS en `gatsby-browser.js`. En Astro, importarás directamente archivos `.css` en un componente de diseño principal para lograr estilos globales.
-
-Ver más sobre [Estilizando en Astro](/es/guides/styling/).
-
-### Plugin de imágenes de Gatsby a Astro
-
-Convierte los componentes `<StaticImage />` y `<GatsbyImage />` de Gatsby a [los propios componentes de integración de imágenes de Astro](/es/guides/images/#image--astroassets), o a una etiqueta [estándar de HTML `<img>` / JSX `<img />`](/es/guides/images/#imágenes-en-componentes-de-frameworks-ui) según corresponda en tus componentes de React.
-
-```astro title="src/pages/index.astro"
----
-import { Image } from 'astro:assets';
-import rocket from '../assets/rocket.png';
----
-<Image src={rocket} alt="Un cohete en el espacio." />
-<img src={rocket.src} alt="Un cohete en el espacio.">
-```
-
-El componente `<Image />` de Astro funciona solo en archivos `.astro` y `.mdx`. Consulta una [lista completa de sus atributos de componente](/es/guides/images/#propiedades) y ten en cuenta que varios serán diferentes de los atributos de Gatsby.
-
-Para seguir utilizando [imágenes en archivos Markdown (`.md`)](/es/guides/images/#imágenes-en-archivos-markdown) utilizando la sintaxis estándar de Markdown (`![]()`), es posible que necesites actualizar el enlace. El uso de la etiqueta HTML `<img>` no es compatible en archivos `.md` para imágenes locales, y debe ser convertido a la sintaxis de Markdown.
-
-```md
-<!-- src/pages/post-1.md -->
-
-# Mi página Markdown
-
-<!-- Imagen local almacenada en src/assets/stars.png -->
-![Un cielo estrellado en la noche.](../assets/stars.png)
-```
-
-En componentes de React (`.jsx`), utiliza la sintaxis estándar de JSX para imágenes (`<img />`). Astro no optimizará estas imágenes, pero puedes instalar y utilizar paquetes de NPM para obtener más flexibilidad.
-
-Puedes obtener más información sobre [cómo usar imágenes en Astro](/es/guides/images/) en la Guía de Imágenes.
-
-### Gatsby GraphQL a Astro
-
-Eliminar todas las referencias a consultas de GraphQL y, en su lugar, utilizar [`Astro.glob()`](/es/guides/imports/#astroglob) para acceder a los datos de tus archivos locales.
-
-O, si estás utilizando colecciones de contenido, consulta tus archivos Markdown y MDX en `src/content/` utilizando [`getEntry()` y `getCollection()`](/es/guides/content-collections/#consultando-colecciones). 
-
-Estas solicitudes de datos se realizan en el frontmatter del componente Astro utilizando la variable data.
-
-```astro title="src/pages/index.astro" del={2,12-28}
----
-import { graphql } from "gatsby"
-import { getCollection } from 'astro:content';
-
-// Obtener todas las entradas de `src/content/blog/`
-const allBlogPosts = await getCollection('blog');
-
-// Obtener todas las entradas de `src/pages/posts/`
-const allPosts = await Astro.glob('../pages/posts/*.md');
----
-
-export const pageQuery = graphql`
-  {
-    allMarkdownRemark(sort: { frontmatter: { date: DESC } }) {
-      nodes {
-        excerpt
-        fields {
-          slug
-        }
-        frontmatter {
-          date(formatString: "MMMM DD, YYYY")
-          title
-          description
-        }
-      }
-    }
-  }
-`
-```
-
-## Ejemplo guiado: Convertir un diseño de Gatsby a Astro
-
-Este ejemplo convierte el diseño principal del proyecto (`layout.js`) del inicio de blog de Gatsby a `src/layouts/Layout.astro`.
-
-Este diseño de página muestra un encabezado cuando se visita la página de inicio y un encabezado diferente con un enlace de regreso a Home para todas las demás páginas.
-
-<Steps>
-1. Identifica el JSX de return().
-
-    ```jsx {21-29} title="layout.js"
-    import * as React from "react"
-    import { Link } from "gatsby"
-    const Layout = ({ location, title, children }) => {
-      const rootPath = `${__PATH_PREFIX__}/`
-      const isRootPath = location.pathname === rootPath
-      let header
-      if (isRootPath) {
-        header = (
-          <h1 className="main-heading">
-            <Link to="/">{title}</Link>
-          </h1>
-        )
-      } else {
-        header = (
-          <Link className="header-link-home" to="/">
-            Home
-          </Link>
-        )
-      }
-      return (
-        <div className="global-wrapper" data-is-root-path={isRootPath}>
-          <header className="global-header">{header}</header>
-          <main>{children}</main>
-          <footer>
-            © {new Date().getFullYear()}, Built with
-            {` `}
-            <a href="https://www.gatsbyjs.com">Gatsby</a>
-          </footer>
-        </div>
-      )
-    }
-    export default Layout
-    ```
-
-2. Crea `Layout.astro` y agrega este valor de `return`, [convertido a la sintaxis de Astro](#referencia-convertir-a-sintaxis-de-astro). 
-
-    Toma en cuenta que:
-
-    - `{new Date().getFullYear()}` funciona 🎉
-    - `{children}` se convierte en `<slot />` 🦥
-    - `className` se convierte en `class` 📛
-    - `Gatsby` se convierte en `Astro` 🚀
-
-    ```astro title="src/layouts/Layout.astro" "<slot />" "class" "Astro" "astro.build"
-    ---
-    ---
-    <div class="global-wrapper" data-is-root-path={isRootPath}>
-      <header class="global-header">{header}</header>
-      <main><slot /></main>
-      <footer>
-        © {new Date().getFullYear()}, Construido con
-        {` `}
-        <a href="https://www.astro.build">Astro</a>
-      </footer>
-    </div>
-    ```
-
-3. Agrega una estructura de página para que tu diseño proporcione a cada página las partes necesarias de un documento HTML:
-
-    ```astro title="src/layouts/Layout.astro" ins={3-10,22-23}
-    ---
-    ---
-    <html>
-      <head>
-        <meta charset="utf-8" />
-        <link rel="icon" type="image/svg+xml" href="/favicon.svg" />
-        <meta name="viewport" content="width=device-width" />
-        <title>Astro</title>
-      </head>
-      <body>
-        <div class="global-wrapper" data-is-root-path={isRootPath}>
-          <header class="global-header">{header}</header>
-          <main>
-            <slot />
-          </main>
-          <footer>
-            &#169; {new Date().getFullYear()}, Construido con
-            {` `}
-            <a href="https://www.astro.build">Astro</a>
-          </footer>
-        </div>
-      </body>
-    </html>
-    ```
-
-4. Agrega las importaciones, propiedades y código JavaScript necesarios
-  
-    Para renderizar condicionalmente un encabezado en Astro según la ruta de la página y el título:
-
-    - Proporciona las propiedades a través de `Astro.props`. (Recuerda: en Astro, las plantillas acceden a las propiedades desde sus metadatos, no se pasan a través de una función.)
-    - Utiliza el operador ternario para mostrar un encabezado si esta es la página de inicio y otro encabezado en caso contrario.
-    - Elimina las variables `{header}` y `{isRootPath}` ya que ya no son necesarias.
-    - Reemplaza las etiquetas `<Link/>` de Gatsby con etiquetas de anclaje `<a>`.
-    - Utiliza `class` en lugar de `className`. 
-    - Importa una hoja de estilo local de tu proyecto para que los nombres de clase tengan efecto.
-
-    ```astro title="src/layouts/Layout.astro" ins={2-3, 15, 16, 20, 24} "class" "<a" "</a>"
-    ---
-    import '../styles/style.css';
-    const { title, pathname } = Astro.props
-    ---
-    <html>
-      <head>
-        <meta charset="utf-8" />
-        <link rel="icon" type="image/svg+xml" href="/favicon.svg" />
-        <meta name="viewport" content="width=device-width" />
-        <title>Astro</title>
-      </head>
-      <body>
-        <div class="global-wrapper">
-          <header class="global-header">
-            { pathname === "/" 
-            ? 
-              <h1 class="main-heading">
-              <a href="/">{title}</a>
-              </h1>
-            : 
-              <h1 class="main-heading">
-              <a class="header-link-home" href="/">Inicio</a>
-              </h1>
-            }  
-          </header>
-          <main>
-            <slot />
-          </main>
-          <footer>
-            &#169; {new Date().getFullYear()}, Construido con
-            {` `}
-            <a href="https://www.astro.build">Astro</a>
-          </footer>
-        </div>
-      </body>
-    </html>
-    ```
-
-5. Actualiza `index.astro` para usar este nuevo diseño y pasarle las propiedades necesarias `title` y `pathname`:
-
-    ```astro title="src/pages/index.astro"
-    ---
-    import Layout from '../layouts/Layout.astro';
-    const pagePathname = Astro.url.pathname
-    ---
-    <Layout title="Página de inicio" pathname={pagePathname}>
-        <p>Astro</p>
-    </Layout>
-    ```
-    :::tip
-    Puedes [obtener la ruta de la página actual utilizando `Astro.url`](/es/reference/api-reference/#astrourl).
-    :::
-
-6. Para probar el encabezado condicional, crea una segunda página llamada `about.astro` utilizando el mismo patrón:
-
-    ```astro title="src/pages/about.astro"
-    ---
-    import Layout from '../layouts/Layout.astro';
-    const pagePathname = Astro.url.pathname
-    ---
-    <Layout title="Acerca de" pathname={pagePathname}>
-        <p>Acerca de</p>
-    </Layout>
-    ```
-
-    Sólo deberías ver un enlace a "Home" cuando visites la página About.
-</Steps>
-
-## Recursos de la comunidad 
-
-- Artículo de blog: [Migrando de Gatsby a Astro](https://loige.co/migrating-from-gatsby-to-astro/)
-
-- Artículo de blog: [Migrar a Astro fue muy fácil](https://joelhooks.com/migrating-to-astro-was-ez).
-
-- Artículo de blog: [Mi cambio de Gatsby a Astro](https://www.joshfinnie.com/blog/my-switch-from-gatsby-to-astro/).
-
-- Artículo de blog: [Por qué me cambié a Astro desde Gatsby](https://dev.to/askrodney/why-i-moved-to-astro-from-gatsby-3fck).
-
-- Artículo de blog: [Migrando mi sitio web de Gatsby a Astro](https://dev.to/flashblaze/migrating-my-website-from-gatsby-to-astro-2ej5).
-
-- Artículo de blog: [Otra migración: de Gatsby a Astro](https://logarithmicspirals.com/blog/migrating-from-gatsby-to-astro).
-
-- Artículo de blog: [Porqué y cómo moví mi blog de Gatsby con React a Astro y Preact](https://www.helmerdavila.com/blog/es/porque-y-como-movi-mi-blog-de-gatsby-con-react-a-astro-js-y-preact)
-
-:::note[¿Tienes algún recurso que compartir?] 
-Si encontraste (¡o hiciste!) un video o publicación de blog útil sobre cómo convertir un sitio de Gatsby a Astro, [edita esta página](https://github.com/withastro/docs/edit/main/src/content/docs/es/guides/migrate-to-astro/from-gatsby.mdx) y agrégalo aquí.
-:::
diff --git a/src/content/docs/es/guides/migrate-to-astro/from-gitbook.mdx b/src/content/docs/es/guides/migrate-to-astro/from-gitbook.mdx
deleted file mode 100644
index b4dd1b81f19f1..0000000000000
--- a/src/content/docs/es/guides/migrate-to-astro/from-gitbook.mdx
+++ /dev/null
@@ -1,76 +0,0 @@
----
-title: Migrando desde GitBook
-description: Consejos para migrar un proyecto existente de GitBook a Astro
-type: migration
-stub: true
-framework: GitBook
-i18nReady: true
----
-
-import PackageManagerTabs from '~/components/tabs/PackageManagerTabs.astro'
-
-[Gitbook](https://gitbook.com) es una plataforma basada en la web para crear, publicar documentación y libros de manera colaborativa, con integración de control de versiones y funciones personalizables.
-
-
-## Principales similitudes entre GitBook y Astro
-
-GitBook y Astro comparten algunas similitudes que te ayudarán a migrar tu proyecto:
-
-- Astro y GitBook admiten [Markdown](/es/guides/markdown-content/). Puedes migrar toda tu documentación existente utilizando la función Git Sync de GitBook.
-
-- Tanto Astro como Gitbook usan algún tipo de [enrutamiento basado en archivos](/es/guides/routing/). El uso de la estructura de archivos de Astro para tu contenido existente y al agregar nuevas páginas debería resultarte familiar.
-
-## Principales diferencias entre GitBook y Astro
-
-Cuando migres tu documentación de GitBook a Astro, notarás algunas diferencias importantes:
-
-- Un sitio de GitBook se edita usando un panel en línea. En Astro, usarás un [editor de código](/es/editor-setup/) y un entorno de desarrollo para mantener tu sitio. Puedes desarrollar localmente en tu máquina, o elegir un editor/entorno de desarrollo en la nube como StackBlitz, CodeSandbox o Gitpod.
-
-- GitBook guarda tu contenido en una base de datos. En Astro, tendrás archivos individuales (típicamente Markdown o MDX) en tu [directorio de proyecto](/es/basics/project-structure/) para el contenido de cada página. O puedes elegir usar un [CMS para tu contenido](/es/guides/cms/) y usar Astro para obtener y presentar los datos.
-
-- GitBook usa una sintaxis personalizada sobre Markdown para el contenido. Astro admite Markdoc a través de la [integración opcional de Markdoc](/es/guides/integrations-guide/markdoc/), que presenta una sintaxis similar a la que usarías en GitBook.
-
-
-## Migrar de GitBook a Astro
-
-Para migrar un sitio de documentación de GitBook a Astro, comienza con nuestra [plantilla oficial de inicio para documentación Starlight](https://starlight.astro.build) o explora más temas de documentación de la comunidad en nuestro [catálogo de temas](https://astro.build/themes?search=&categories%5B%5D=docs).
-
-Puedes pasar el argumento `--template` al comando `create astro` para empezar un nuevo proyecto de Astro con una de nuestras plantillas oficiales. O, puedes [comenzar un nuevo proyecto desde cualquier repositorio de Astro existente en GitHub](/es/install-and-setup/#usa-un-tema-o-una-plantilla-de-inicio).
-
-  <PackageManagerTabs>
-    <Fragment slot="npm">
-    ```shell
-    npm create astro@latest -- --template starlight
-    ```
-    </Fragment>
-    <Fragment slot="pnpm">
-    ```shell
-    pnpm create astro@latest --template starlight
-    ```
-    </Fragment>
-    <Fragment slot="yarn">
-    ```shell
-    yarn create astro --template starlight
-    ```
-    </Fragment>
-  </PackageManagerTabs>
-
-Una vez que tengas un nuevo proyecto de Astro, puedes sincronizar tu contenido de GitBook existente con tu nuevo proyecto de Astro. GitBook tiene una función de [Git Sync](https://docs.gitbook.com/product-tour/git-sync) que sincronizará automáticamente tu contenido de GitBook con un repositorio de GitHub/GitLab.
-
-Para sincronizar directamente con la colección de contenido de la plantilla de documentación, especifica `src/content/docs/en` o `src/content/docs` como el directorio del proyecto.
-
-:::caution
-Cuando habilites Git Sync, asegúrate de especificar "**GitBook a GitHub**" como prioridad. Esto asegurará que tu contenido de GitBook se sincronice con tu repositorio de GitHub. De lo contrario, sobrescribirás tu contenido de GitBook existente.
-:::
-
-Después de sincronizar el contenido, ahora tendrás una copia de tu contenido de GitBook en tu repositorio de Astro. Deshabilita la sincronización de git para evitar futuras sincronizaciones con GitBook.
-
-Ten en cuenta que aunque ahora tienes tu contenido migrado a tu proyecto de Astro, no será inmediatamente utilizable. Para usar este contenido en tu sitio de Astro, necesitarás pasar algo de tiempo cambiando manualmente la sintaxis de GitBook a un formato compatible con Astro. En particular:
-
-- La integración de [Markdoc de Astro](/es/guides/integrations-guide/markdoc/) requiere que la extensión del archivo sea `.mdoc`. Esto es para evitar conflictos con otras extensiones de Markdown como `.mdx` y `.md`.
-- La sintaxis de GitBook difiere de Markdoc donde el prefijo `/` que denota una etiqueta de cierre se reemplaza con `end` para los archivos de GitBook. Necesitarás actualizar esta notación en todos tus archivos.
-- Algunas características de GitBook dependen de componentes personalizados. Estos componentes no existirán en Astro y deben ser creados y agregados a tu proyecto a traves [del atributo `tags` de la configuración de Markdoc](/es/guides/integrations-guide/markdoc/#usa-componentes-astro-como-etiquetas-markdoc) o eliminados de tus archivos.
-
-## Recursos de la comunidad
-
-- ¡Añade el tuyo!
diff --git a/src/content/docs/es/guides/migrate-to-astro/from-gridsome.mdx b/src/content/docs/es/guides/migrate-to-astro/from-gridsome.mdx
deleted file mode 100644
index d991b389b2c56..0000000000000
--- a/src/content/docs/es/guides/migrate-to-astro/from-gridsome.mdx
+++ /dev/null
@@ -1,70 +0,0 @@
----
-title: Migrando desde Gridsome
-description: Consejos para migrar un proyecto existente de Gridsome a Astro
-type: migration
-stub: true
-framework: Gridsome
-i18nReady: true
----
-
-import PackageManagerTabs from '~/components/tabs/PackageManagerTabs.astro'
-
-[Gridsome](https://gridsome.org) es un generador de sitios estáticos de código abierto construido en Vue y GraphQL.
-
-## Principales similitudes entre Gridsome y Astro
-
-Gridsome y Astro comparten algunas similitudes que te ayudarán a migrar tu proyecto:
-
-- Gridsome y Astro son generadores de sitios estáticos modernos en JavaScript con [estructuras de archivos de proyectos similares](/es/basics/project-structure/#carpetas-y-archivos). 
-
-- Gridsome y Astro utilizan una carpeta `src/` para los archivos de tu proyecto y una [carpeta especial `src/pages/` para el enrutamiento basado en archivos](/es/basics/astro-pages/). La creación y gestión de páginas para tu sitio debería resultarte familiar.
-
-- Astro cuenta con [una integración oficial para usar componentes de Vue](/es/guides/integrations-guide/vue/) y admite [la instalación de paquetes NPM](/es/guides/imports/#paquetes-npm), incluyendo varios para Vue. Podrás escribir componentes de UI de Vue y es posible que puedas conservar algunos o todos tus componentes y dependencias de Vue de Gridsome existentes.
-
-- Astro y Gridsome te permiten utilizar un [headless CMS, APIs o archivos Markdown para los datos](/es/guides/data-fetching/). Puedes seguir usando tu sistema preferido de creación de contenido, y podrás mantener todo tu contenido existente.
-
-## Principales diferencias entre Gridsome y Astro
-
-Cuando reconstruyas tu sitio de Gridsome a Astro, notarás algunas diferencias importantes:
-
-- Gridsome es una aplicación de una sola página (SPA) construida en Vue. Los sitios de Astro son aplicaciones de varias páginas construidas utilizando [componentes `.astro`](/es/basics/astro-components/), pero también puede admitir [React, Preact, Vue.js, Svelte, SolidJS, AlpineJS, Lit](/es/guides/framework-components/) y plantillas de HTML sin procesar.
-
-- Como una SPA, Gridsome utiliza `vue-router` para el enrutamiento SPA, y `vue-meta` para gestionar la etiqueta `<head>`. En Astro, crearás páginas HTML separadas y controlarás la etiqueta `<head>` de cada página directamente, o a través de un [componente de diseño](/es/basics/layouts/).
-
-- [Datos de archivos locales](/es/guides/imports/): Gridsome utiliza GraphQL para recuperar los datos de tu proyecto. Astro usa importaciones ESM y el helper [`Astro.glob()`](/es/guides/imports/#astroglob) para importar los datos de archivos locales del proyecto. Los recursos remotos pueden cargarse utilizando el API estándar `fetch()`. GraphQL se puede añadir opcionalmente a tu proyecto, pero no está incluido por defecto.
-
-## Migrar desde Gridsome a Astro
-
-Para migrar un blog de Gridsome a Astro, empieza con nuestra plantilla inicial para blogs, o explora más temas de la comunidad para blogs en nuestro [catálogo de temas](https://astro.build/themes/).
-
-Puedes pasar el argumento `--template` al comando `create astro` para empezar un nuevo proyecto de Astro con una de nuestras plantillas oficiales. O, puedes [comenzar un nuevo proyecto desde cualquier repositorio de Astro existente en GitHub](/es/install-and-setup/#usa-un-tema-o-una-plantilla-de-inicio).
-
-  <PackageManagerTabs>
-    <Fragment slot="npm">
-    ```shell
-    npm create astro@latest -- --template blog
-    ```
-    </Fragment>
-    <Fragment slot="pnpm">
-    ```shell
-    pnpm create astro@latest --template blog
-    ```
-    </Fragment>
-    <Fragment slot="yarn">
-    ```shell
-    yarn create astro --template blog
-    ```
-    </Fragment>
-  </PackageManagerTabs>
-
-Lleva tus archivos Markdown (o MDX, con nuestra integración opcional) existentes como contenido para [crear páginas en Markdown o MDX](/es/guides/markdown-content/).
-
-Dado que la estructura del proyecto de Gridsome es similar a la de Astro, es posible que puedas copiar varios archivos existentes de tu proyecto a la misma ubicación en tu nuevo proyecto de Astro. Sin embargo, las dos estructuras de proyectos no son idénticas. Es posible que desees examinar [la estructura del proyecto de Astro](/es/basics/project-structure/) para ver cuáles son las diferencias.
-
-Ya que Astro consulta e importa tus archivos locales de manera diferente a Gridsome, es posible que desees leer acerca de cómo cargar archivos usando [`Astro.glob()`](/es/guides/imports/#astroglob) para entender cómo trabajar con tus archivos locales.
-
-Para convertir otros tipos de sitios, como un portafolio o sitio de documentación, mira más plantillas oficiales de inicio en [astro.new](https://astro.new). Encontrarás un enlace al repositorio de GitHub de cada proyecto, así como enlaces de un solo clic para abrir un proyecto de trabajo en los entornos de desarrollo en línea de StackBlitz, CodeSandbox y Gitpod.
-
-## Recursos de la comunidad
-
-- Artículo de blog: [Migración de Gridsome a Astro](https://fyodor.io/migration-from-gridsome-to-astro/).
diff --git a/src/content/docs/es/guides/migrate-to-astro/from-hugo.mdx b/src/content/docs/es/guides/migrate-to-astro/from-hugo.mdx
deleted file mode 100644
index 9434d29871dda..0000000000000
--- a/src/content/docs/es/guides/migrate-to-astro/from-hugo.mdx
+++ /dev/null
@@ -1,68 +0,0 @@
----
-title: Migrando desde Hugo
-description: Consejos para migrar un proyecto existente de Hugo a Astro
-type: migration
-stub: true
-framework: Hugo
-i18nReady: true
----
-
-import PackageManagerTabs from '~/components/tabs/PackageManagerTabs.astro'
-
-[Hugo](https://gohugo.io) es un generador de sitios estáticos de codigo abierto construido en Go.
-
-## Principales similitudes entre Hugo y Astro
-
-Hugo y Astro comparten algunas similitudes que te ayudarán a migrar tu proyecto:
-
-- Hugo y Astro son generadores modernos de sitios estáticos, idealmente adaptados para [sitios web orientados al contenido](/es/concepts/why-astro/#orientado-al-contenido), como los blogs.
-
-- Hugo y Astro permiten crear tu contenido en Markdown. Sin embargo, Hugo incluye varias propiedades especiales en el frontmatter y permite escribir este en YAML, TOML o JSON. Aunque muchas de las propiedades existentes de tu frontmatter de Hugo no serán "especiales" en Astro, puedes seguir utilizando tus archivos Markdown existentes y los valores del frontmatter en YAML.
-
-- Hugo y Astro permiten mejorar tu sitio con una variedad de [integraciones y paquetes externos](https://astro.build/integrations/).
-
-
-
-## Principales diferencias entre Hugo y Astro
-
-Cuando reconstruyas tu sitio de Hugo a Astro, notarás algunas diferencias importantes:
-
-- Hugo utiliza Go Templating para la generación de páginas. [La sintaxis de Astro](/es/basics/astro-components/) es un superset de HTML similar a JSX.
-
-- Astro no utiliza shortcodes para insertar contenido dinámico en archivos Markdown estándar, pero [la integración de MDX en Astro](/es/guides/integrations-guide/mdx/) te permite usar JSX e importar componentes en archivos MDX.
-
-- Mientras que en Hugo se pueden usar "parciales" para elementos reutilizables del diseño, [Astro está completamente basado en componentes](/es/basics/astro-components/). Cualquier archivo `.astro` puede ser un componente, diseño o una página completa, y puede importar y renderizar cualquier otro componente de Astro. Los componentes de Astro también pueden incluir [otros componentes de frameworks de UI (p. ej. React, Svelte, Vue, Solid)](/es/guides/framework-components/) así como contenido o metadatos de [otros archivos en tu proyecto](/es/guides/imports/), como Markdown o MDX.
-
-## Migrar de Hugo a Astro
-
-Para migrar un blog de Hugo a Astro, empieza con nuestra plantilla inicial para blogs, o explora más temas de la comunidad para blogs en nuestro [mostrador de temas](https://astro.build/themes/).
-
-Puedes pasar el argumento `--template` al comando `create astro` para empezar un nuevo proyecto de Astro con una de nuestras plantillas oficiales. O, puedes [comenzar un nuevo proyecto desde cualquier repositorio de Astro existente en GitHub](/es/install-and-setup/#usa-un-tema-o-una-plantilla-de-inicio).
-
-  <PackageManagerTabs>
-    <Fragment slot="npm">
-    ```shell
-    npm create astro@latest -- --template blog
-    ```
-    </Fragment>
-    <Fragment slot="pnpm">
-    ```shell
-    pnpm create astro@latest --template blog
-    ```
-    </Fragment>
-    <Fragment slot="yarn">
-    ```shell
-    yarn create astro --template blog
-    ```
-    </Fragment>
-  </PackageManagerTabs>
-
-Lleva tus archivos Markdown (o MDX, con nuestra integración opcional) existentes como contenido para [crear páginas en Markdown o MDX](/es/guides/markdown-content/). Es posible que necesites convertir tu frontmatter a YAML, ya que Astro solo permite YAML frontmatter en estos archivos.
-
-Para seguir utilizando contenido dinámico como variables, expresiones o componentes de la UI dentro del contenido de tu Markdown, añade la integración opcional MDX de Astro y convierte tus archivos Markdown existentes a [páginas MDX](/es/guides/markdown-content/). MDX soporta el frontmatter en YAML, para que puedas mantener las propiedades existentes de tu frontmatter. Pero, tienes que remplazar cualquier shortcode con [la propia sintaxis de MDX](https://mdxjs.com/docs/what-is-mdx/#mdx-syntax), lo que permite expresiones JSX y/o importaciones de componentes.
-
-Para convertir otros tipos de sitios, como un portafolio o sitio de documentatión, mira más plantillas oficiales de inicio en [astro.new](https://astro.new). Encontrarás un enlace al repositorio de GitHub de cada proyecto, así como enlaces de un solo clic para abrir un proyecto de trabajo en los entornos de desarrollo en línea de StackBlitz, CodeSandbox y Gitpod.
-
-## Recursos de la Comunidad
-
-- Artículo de blog: [Hugo Vs Astro - Qué generador de sitios estáticos elegir en 2023](https://onebite.dev/hugo-vs-astro-which-static-site-generator-to-choose-in-2023/).
diff --git a/src/content/docs/es/guides/migrate-to-astro/from-jekyll.mdx b/src/content/docs/es/guides/migrate-to-astro/from-jekyll.mdx
deleted file mode 100644
index 7228340a14745..0000000000000
--- a/src/content/docs/es/guides/migrate-to-astro/from-jekyll.mdx
+++ /dev/null
@@ -1,68 +0,0 @@
----
-title: Migrando desde Jekyll
-description: Consejos para migrar un proyecto existente de Jekyll project a Astro
-type: migration
-stub: true
-framework: Jekyll
-i18nReady: true
----
-
-import PackageManagerTabs from '~/components/tabs/PackageManagerTabs.astro'
-
-[Jekyll](https://jekyllrb.com) es un generador de sitios estáticos construido en Ruby.
-
-## Principales similitudes entre Jekyll y Astro
-
-Jekyll y Astro comparten algunas similitudes que te ayudarán a migrar tu proyecto:
-
-- Jekyll y Astro son generadores de sitios estáticos, comúnmente utilizados para crear blogs.
-
-- Jekyll y Astro te permiten escribir tu contenido en Markdown y HTML. Tanto Jekyll como Astro proporcionan algunas propiedades YAML especiales para el diseño de páginas y publicaciones de borrador no publicadas. Puedes continuar utilizando tus archivos Markdown existentes en Astro.
-
-- Jekyll y Astro utilizan [enrutamiento basado en archivos](/es/guides/routing/) para crear páginas a partir de tus publicaciones de blog. Astro proporciona un [directorio especial `src/pages/` para todas las páginas y publicaciones](/es/basics/project-structure/#srcpages). Jekyll utiliza una carpeta especial similar llamada `_posts/` para tus publicaciones de blog en Markdown, aunque tus páginas del sitio pueden estar en otros lugares. La creación de nuevas publicaciones de blog debería resultar familiar.
-
-
-## Principales diferencias entre Jekyll y Astro
-
-Cuando reconstruyas tu sitio de Jekyll a Astro, notarás algunas diferencias importantes:
-
-- Como Jekyll es principalmente una plataforma de blogs, incluye varias características de blog integradas que es posible que debas construir por tu cuenta en Astro. O bien, elige una [plantilla de inicio de tema de blog](https://astro.build/themes?search=&categories%5B%5D=blog) que incluya estas características. Por ejemplo, Jekyll tiene soporte integrado para etiquetas y categorías que encontrarás en varios temas de blog de Astro, pero no se incluye en un proyecto Astro básico.
-
-- Jekyll utiliza plantillas Liquid para elementos de diseño reutilizables y plantillas. Astro utiliza [archivos `.astro` similares a JSX para plantillas y componentes](/es/basics/astro-components/). Cualquier archivo `.astro` puede ser un componente, un diseño o una página completa, y puede importar y renderizar cualquier otro componente de Astro. También puedes construir utilizando [componentes de otros frameworks de UI (p. ej. React, Svelte, Vue, Solid)](/es/guides/framework-components/) así como contenido o metadatos de [otros archivos en tu proyecto](/es/guides/imports/), como Markdown o MDX.
-
-
-## Migrar de Jekyll a Astro
-
-Para migrar un blog de Jekyll a Astro, empieza con nuestra plantilla inicial para blogs, o explora más temas de la comunidad para blogs en nuestro [mostrador de temas](https://astro.build/themes/).
-
-Puedes pasar el argumento `--template` al comando `create astro` para empezar un nuevo proyecto de Astro con una de nuestras plantillas oficiales. O, puedes [comenzar un nuevo proyecto desde cualquier repositorio de Astro existente en GitHub](/es/install-and-setup/#usa-un-tema-o-una-plantilla-de-inicio).
-
-  <PackageManagerTabs>
-    <Fragment slot="npm">
-    ```shell
-    npm create astro@latest -- --template blog
-    ```
-    </Fragment>
-    <Fragment slot="pnpm">
-    ```shell
-    pnpm create astro@latest --template blog
-    ```
-    </Fragment>
-    <Fragment slot="yarn">
-    ```shell
-    yarn create astro --template blog
-    ```
-    </Fragment>
-  </PackageManagerTabs>
-
-Trae tus archivos Markdown existentes como contenido para [crear páginas en Markdown](/es/guides/markdown-content/), utilizando un [diseño de Markdown de Astro](/es/basics/layouts/#plantillas-de-markdown) en lugar de una plantilla Liquid template. 
-
-Gran parte de tu contenido de página HTML existente se puede convertir en  [páginas de Astro](/es/basics/astro-pages/), y además podrás [usar variables, expresiones similares a JSX e importaciones de componentes directamente en tu plantilla HTML](/es/reference/astro-syntax/#expresiones-similares-a-jsx).
-
-Astro no tiene una propiedad `permalink` que acepte marcadores de posición. Es posible que debas leer más acerca del [enrutamiento de página en Astro](/es/guides/routing/) si deseas mantener tu estructura de URL existente. O bien, considera [configurar redireccionamientos en un host como Netlify](https://docs.netlify.com/routing/redirects/).
-
-Para convertir otros tipos de sitios, como un portafolio o sitio de documentatión, mira más plantillas oficiales de inicio en [astro.new](https://astro.new). Encontrarás un enlace al repositorio de GitHub de cada proyecto, así como enlaces de un solo clic para abrir un proyecto de trabajo en los entornos de desarrollo en línea de StackBlitz, CodeSandbox y Gitpod.
-
-## Recursos de la Comunidad
-
-- Artículo de blog: [De regreso al futuro: La transición de nuestro blog de tecnología de Jekyll a Astro](https://alasco.tech/2023/09/06/migrating-to-astro/) (traducción al español).
diff --git a/src/content/docs/es/guides/migrate-to-astro/from-nextjs.mdx b/src/content/docs/es/guides/migrate-to-astro/from-nextjs.mdx
deleted file mode 100644
index 15afc28b90ed0..0000000000000
--- a/src/content/docs/es/guides/migrate-to-astro/from-nextjs.mdx
+++ /dev/null
@@ -1,580 +0,0 @@
----
-title: Migrando desde Next.js
-description: Consejos para migrar un proyecto existente de Next.js a Astro
-type: migration
-stub: false
-framework: Next.js
-i18nReady: true
----
-import { Steps } from '@astrojs/starlight/components';
-import AstroJSXTabs from '~/components/tabs/AstroJSXTabs.astro'
-import PackageManagerTabs from '~/components/tabs/PackageManagerTabs.astro'
-
-Aquí hay algunos conceptos clave y estrategias de migración para ayudarte a empezar. Utiliza el resto de nuestra documentación y nuestra [comunidad de Discord](https://astro.build/chat) para seguir adelante.
-
-## Principales similitudes entre Next.js y Astro
-
-Next.js y Astro comparten algunas similitudes que te ayudarán a migrar tu proyecto:
-
-- La [sintaxis de los archivos `.astro` es similar a la de JSX](/es/reference/astro-syntax/#diferencias-entre-astro-y-jsx). Escribir en Astro debería resultarte familiar.
-- Los proyectos de Astro también pueden ser SSG o [SSR con prerenderización a nivel de página](/es/guides/on-demand-rendering/).
-- Astro utiliza  el enrutamiento basado en archivos, y [permite que las páginas con nombre especiales creen rutas dinámicas](/es/guides/routing/#rutas-dinámicas).
-- Astro está [basado en componentes](/es/basics/astro-components/), y la estructura de tu marcado será similar antes y después de la migración.
-- Astro tiene [integraciones oficiales para React, Preact, y Solid](/es/guides/integrations-guide/react/) por lo que puedes utilizar tus componentes JSX existentes. Ten en cuenta que en Astro, estos archivos **deben** tener una extensión `.jsx` o `.tsx`.
-- Astro cuenta con soporte para [instalar paquetes NPM](/es/guides/imports/#paquetes-npm), incluyendo bibliotecas de React. Muchas de tus dependencias existentes funcionarán en Astro.
-
-## Principales diferencias entre Next.js y Astro
-
-Cuando reconstruyas tu sitio de Next.js a Astro, notarás algunas diferencias importantes:
-
-- Next.js es una aplicación de página única de React, y utiliza `index.js` como raíz de tu proyecto. Astro es un sitio multipágina, y `index.astro` es tu página de inicio.
-
-- [Los Componentes `.astro`](/es/basics/astro-components/) no se escriben como funciones exportadas que devuelven plantillas de página. En su lugar, dividirás tu código en "bloques de código" para tu JavaScript y un cuerpo exclusivamente para el HTML que generes.
-
-- [Orientado al contenido](/es/concepts/why-astro/#orientado-al-contenido): Astro fue diseñado para mostrar tu contenido y permitirte optar por la interactividad solo cuando sea necesario. Una aplicación existente de Next.js puede estar construida para una alta interactividad del lado del cliente y puede requerir técnicas avanzadas de Astro para incluir elementos que son más difíciles de replicar utilizando componentes `.astro`, como los paneles de control.
-
-## Migrar tu proyecto de Next.js
-
-Cada migración será diferente, pero hay algunas acciones comunes que realizarás al migrar de Next.js a Astro.
-
-### Crear un nuevo proyecto de Astro
-
-Utiliza el comando `create astro` en tu gestor de paquetes para lanzar el asistente de línea de comandos de Astro, o elige un tema de la comunidad desde el [catálogo de temas de Astro](https://astro.build/themes).
-
-Puedes pasar el argumento `--template` al comando `create astro` para iniciar un nuevo proyecto de Astro con una de nuestras plantillas oficiales (p. ej. `docs`, `blog`, `portafolio`). O, puedes [iniciar un nuevo proyecto a partir de cualquier repositorio de Astro existente en GitHub.](/es/install-and-setup/#usa-un-tema-o-una-plantilla-de-inicio).
-
-  <PackageManagerTabs>
-    <Fragment slot="npm">
-    ```shell
-    # Lanzar el Asistente de línea de comandos de Astro
-    npm create astro@latest
-
-    # Crear un nuevo proyecto con un ejemplo oficial.
-    npm create astro@latest -- --template <example-name>
-    ```
-    </Fragment>
-    <Fragment slot="pnpm">
-    ```shell
-    # Lanzar el Asistente de línea de comandos de Astro
-    pnpm create astro@latest
-
-    # Crear un nuevo proyecto con un ejemplo oficial.
-    pnpm create astro@latest --template <example-name>
-    ```
-    </Fragment>
-    <Fragment slot="yarn">
-    ```shell
-    # Lanzar el Asistente de línea de comandos de Astro
-    yarn create astro@latest
-
-    # Crear un nuevo proyecto con un ejemplo oficial.
-    yarn create astro@latest --template <example-name>
-    ```
-    </Fragment>
-  </PackageManagerTabs>
-
-Luego, copia los archivos de tu proyecto Next existente a tu nuevo proyecto Astro en una carpeta separada fuera de `src`.
-
-:::tip
-Visita https://astro.new para ver la lista completa de plantillas de inicio oficiales, así como los enlaces para abrir un nuevo proyecto en StackBlitz, CodeSandbox o Gitpod.
-:::
-
-### Instalar integraciones (opcional)
-
-Puede resultarte útil instalar algunas de las [integraciones opcionales de Astro](/es/guides/integrations-guide/) para usar mientras migras tu proyecto de Next a Astro:
-
-- **@astrojs/react**: Para reutilizar algunos de los componentes UI de React existentes en tu nuevo sitio de Astro, o seguir escribiendo con componentes de React.
-
-- **@astrojs/mdx**: Para traer archivos MDX existentes de tu proyecto Next, o para usar MDX en tu nuevo sitio Astro.
-
-### Coloca tu código fuente en `src`
-
-Siguiendo la [estructura de proyecto de Astro](/es/basics/project-structure/):
-
-<Steps>
-1. **Mantén** intacta la carpeta `public/` de Next. 
-   
-    Astro utiliza el directorio `public/` para almacenar activos estáticos, de la misma manera que lo hace Next. No es necesario realizar ningún cambio en esta carpeta, ni en su contenido.
-
-2. **Copia o mueve** los otros archivos de Next (p. ej. `pages`, `styles` etc.) en la carpeta `src/` de Astro mientras reconstruyes tu sitio, siguiendo la [estructura de proyecto de Astro](/es/basics/project-structure/).
-
-   Al igual que en Next, la carpeta `src/pages/`de Astro es una carpeta especial que se utiliza para el enrutamiento basado en archivos. Todas las demás carpetas son opcionales y puedes organizar el contenido de tu carpeta `src/` de la manera que desees. Otras carpetas comunes en proyectos de Astro incluyen `src/layouts/`, `src/components`, `src/styles` y `src/scripts`.
-</Steps>
-
-### El archivo de configuración de Astro
-
-Astro tiene un archivo de configuración en la raíz de tu proyecto llamado [`astro.config.mjs`](/es/guides/configuring-astro/). Esto se utiliza solo para configurar tu proyecto de Astro y cualquier integración instalada, incluidos los [adaptadores SSR](/es/guides/deploy/).
-
-### Consejos: Convertir archivos JSX a archivos `.astro`
-
-Aquí hay algunos consejos para convertir un componente `.js` de Next en un componente `.astro`:
-
-1. Usa el JSX devuelto por la función del componente existente de Next.js como base para tu plantilla HTML.
-
-2. Cambia cualquier [sintaxis de Next o JSX a Astro](#referencia-cómo-convertir-la-sintaxis-de-nextjs-a-astro) o a los estándares web HTML. Esto incluye `<Link>`, `<Script>`, `{children}`, y `className`, por ejemplo.
-
-3. Mueve cualquier JavaScript necesario, incluyendo las declaraciones de importación, a un ["bloque de código" (`---`)](/es/basics/astro-components/#script-de-un-componente). Nota: JavaScript para [renderizar contenido de forma condicional](/es/reference/astro-syntax/#html-dinamico) se escribe a menudo directamente dentro de la plantilla HTML en Astro.
-
-4. Usa [`Astro.props`](/es/reference/api-reference/#astroprops) para acceder a cualquier prop adicional que se haya pasado previamente a tu función de Next.
-
-5. Decide si también es necesario convertir a Astro cualquier componente importado. Con la integración oficial instalada, puedes [usar componentes de React existentes en tu archivo Astro](/es/guides/framework-components/). Pero es posible que desees convertirlos a componentes  `.astro`,  ¡especialmente si no necesitan ser interactivos!
-
-6. Reemplaza `getStaticProps()` con declaraciones de importación o [`Astro.glob()`](/es/reference/api-reference/#astroglob) para consultar tus archivos locales. Usa `fetch()` para obtener datos externos.
-
-Mira [un ejemplo de un archivo Next `.js` convertido paso a paso](#ejemplo-guiado-cómo-migrar-la-obtención-de-datos-en-next-a-astro).
-
-#### Comparación: JSX vs Astro
-
-Compara el siguiente componente de Next y su equivalente en Astro:
-
-<AstroJSXTabs>
-  <Fragment slot="jsx">
-    ```jsx title="StarCount.jsx"
-    import Header from "./header";
-    import Footer from "./footer";
-    import "./layout.css";
-
-    export async function getStaticProps() {
-        const res = await fetch("https://api.github.com/repos/withastro/astro")
-        const json = await res.json();
-        return {
-            props: { message: json.message, stars: json.stargazers_count || 0 },
-        }
-    }
-
-    const Component = ({ stars, message }) => {
-        
-        return (
-            <>
-                <Header />
-                <p style={{
-                    backgroundColor: `#f4f4f4`,
-                    padding: `1em 1.5em`,
-                    textAlign: `center`,
-                    marginBottom: `1em`
-                }}>Astro has {stars} 🧑‍🚀</p>
-                <Footer />
-            </>
-        )
-    }
-
-    export default Component;
-    ```
-  </Fragment>
-  <Fragment slot="astro">
-    ```astro title="StarCount.astro"
-    ---
-    import Header from "./header";
-    import Footer from "./footer";
-    import "./layout.css";
-
-    const res = await fetch("https://api.github.com/repos/withastro/astro")
-    const json = await res.json();
-    const message = json.message;
-    const stars = json.stargazers_count || 0;
-    ---
-    <Header />
-    <p class="banner">Astro has {stars} 🧑‍🚀</p>
-    <Footer />
-
-    <style>
-      .banner {
-        background-color: #f4f4f4; 
-        padding: 1em 1.5em;
-        text-align: center;
-        margin-bottom: 1em;
-      }
-    <style>
-    ```
-  </Fragment>
-</AstroJSXTabs>
-
-### Migrando archivos de diseño
-
-Puede resultarte útil comenzar convirtiendo tus diseños y plantillas de Next.js en [componentes de diseño de Astro](/es/basics/layouts/).
-
-Next tiene dos métodos diferentes para crear archivos de diseño, cada uno de los cuales maneja los diseños de manera diferente a Astro:
-
-- El directorio `pages`
-
-- [El directorio `/app`](https://nextjs.org/docs/app/building-your-application/routing/pages-and-layouts#layouts)
-
-Cada página de Astro requiere explícitamente que se incluyan las etiquetas `<html>`, `<head>`, y `<body>`, por lo que es común reutilizar un archivo de diseño en varias páginas. Astro utiliza [`<slot />`](/es/basics/astro-components/#slots) para el contenido de la página, sin necesidad de importar ninguna declaración. Observa la estructura estándar de templating de HTML y el acceso directo al elemento `<head>`:  
-
-```astro title="src/layouts/Layout.astro"
----
----
-<html lang="en">
-	<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} />
-		<title>Astro</title>
-	</head>
-	<body>
-    <!-- Envuelve el elemento slot con tu plantilla de diseño existente-->
-		<slot />
-	</body>
-</html>
-```
-
-#### Migrando desde el directorio `pages` de Next.js
-
-Tu proyecto de Next puede tener un archivo `pages/_document.jsx` que importa componentes de React, para personalizar el elemento `<head>` de tu aplicacion:
-
-```jsx title="pages/_document.jsx"
-import Document, { Html, Head, Main, NextScript } from "next/document";
-
-export default class MyDocument extends Document {
-  render() {
-    return (
-      <Html lang="en">
-        <Head>
-          <link rel="icon" href="/favicon.ico" />
-        </Head>
-        <body>
-          <Main />
-          <NextScript />
-        </body>
-      </Html>
-    );
-  }
-}
-```
-<Steps>
-1. Crea un nuevo archivo de diseño de Astro usando únicamente el JSX retornado.
-
-2. Reemplaza cualquier componente de React con las etiquetas estándar de HTML como  `<html>`, `<head>`, `<slot>`, y otras etiquetas HTML estándar
-
-    ```astro title="src/layouts/Document.astro"
-    <html lang="en">
-      <head>
-          <link rel="icon" href="/favicon.ico" />
-      </head>
-      <body>
-        <slot/>
-      </body>
-    </html>
-    ```
-</Steps>
-
-#### Migrando desde el directorio `/app` de Next.js
-
-Los archivos de diseño del directorio `app/` de Next.js se crean con dos archivos: un archivo `layout.jsx` para personalizar el contenido de los elementos `<html>` y `<body>`, y un archivo `head.jsx` para personalizar el contenido del elemento`<head>`.
-
-```jsx title="app/layout.jsx"
-export default function Layout({ children }) {
-  return (
-    <html lang="en">
-      <body>{children}</body>
-    </html>
-  );
-}
-```
-
-```jsx title="app/head.jsx"
-export default function Head() {
-  return (
-    <>
-      <title>My Page</title>
-    </>
-  );
-}
-```
-
-<Steps>
-1. Crea un nuevo archivo de diseño de Astro usando únicamente el JSX retornado.
-
-2. Reemplaza ambos archivos por un solo archivo de diseño de Astro que contenga una estructura básica de la página (`<html>`, `<head>`, y `<body>`) y un elemento `<slot/>`  en lugar de la propiedad `{children}` de React:
-
-    ```astro title="src/layouts/Layout.astro"
-    <html lang="en">
-      <head>
-          <title>My Page</title>
-      </head>
-      <body>
-        <slot/>
-      </body>
-    </html>
-    ```
-</Steps>
-
-### Migrando páginas y publicaciones
-
-En Next.js, tus publicaciones pueden encontrarse en `/pages` o en `/app/routeName/page.jsx`.
-
-En Astro, **todo el contenido de tus páginas debe encontrarse dentro de `src/`**, ya sea en `src/pages` o en `src/content`.
-
-#### Páginas de React
-
-Tus páginas JSX existentes (`.js`) de Next deberán [convertirse de archivos JSX a páginas `.astro`](#consejos-convertir-archivos-jsx-a-archivos-astro). No puedes usar un archivo de página JSX existente en Astro
-
-Estas [páginas `.astro`](/es/basics/astro-pages/) deben estar ubicadas dentro de `src/pages/`  sus rutas de página se generarán automáticamente en función de su ruta de archivo.
-
-#### Páginas de Markdown y MDX
-
-Astro tiene soporte incorporado para Markdown y una integración opcional para archivos MDX. Puedes reutilizar cualquier archivo [Markdown y MDX](/es/guides/markdown-content/) existente, pero pueden requerir algunos ajustes en su frontmatter, como agregar [la propiedad especial de frontmatter `layout`de Astro](/es/basics/layouts/#plantillas-de-markdown). Ya no necesitarás crear manualmente páginas para cada ruta generada por Markdown. Estos archivos se pueden colocar dentro de`src/pages/` para aprovechar el enrutamiento automático basado en archivos.
-
-Alternativamente, puedes usar [colecciones de contenido](/es/guides/content-collections/) en Astro para almacenar y administrar tu contenido. Cuando forman parte de una colección, los archivos Markdown y MDX vivirán en carpetas dentro de `src/content/`. Deberás recuperar el contenido tú mismo y [generar esas páginas dinámicamente](/es/guides/content-collections/#generando-rutas-desde-el-contenido).
-
-### Migrando Tests
-
-Como Astro produce HTML sin procesar, es posible escribir tests end-to-end utilizando la salida del paso de compilación. Cualquier test end-to-end escrito anteriormente podría funcionar sin problemas si has podido coincidir con el marcado de tu sitio de Next. Bibliotecas de testing como Jest y React Testing Library pueden ser importadas y utilizadas en Astro para poner a prueba tus componentes de React.
-
-Consulta la [guía de testing](/es/guides/testing/) de Astro para obtener más información.
-
-## Referencia: Cómo convertir la sintaxis de Next.js a Astro
-
-### Migrando los enlaces de Next a Astro
-
-Convierte cualquier componente de Next `<Link to="">`, `<NavLink>` etc. a etiquetas HTML `<a href="">`. 
-
-```astro del={1} ins={2}
-<Link to="/blog">Blog</Link>
-<a href="/blog">Blog</a>
-```
-
-Astro no utiliza ningún componente especial para los enlaces, aunque puedes crear tu propio componente `<Link>`. Luego puedes importar y usar este `<Link>` como lo harías con cualquier otro componente.
-
-```astro title="src/components/Link.astro"
----
-const { to } = Astro.props;
----
-<a href={to}><slot /></a>
-```
-
-### Migrando las importaciones de Next a Astro
-
-Actualiza cualquier [importación de archivos](/es/guides/imports/) para referencias rutas de archivo relativas de manera exacta. Esto puede hacerse utilizando un [alias de importación](/es/guides/typescript/#alias-de-importación), o escribiendo la ruta relativa completa. 
-
-Ten encuenta que `.astro` y varios otros tipos de archivos deben ser importados con su extensión de archivo completa.
-
-```astro title="src/pages/authors/Fred.astro"
----
-import Card from "../../components/Card.astro";
----
-<Card />
-```
-
-### Migrando las propiedades Children de Next a Astro
-
-Convierte cualquier instancia de `{children}` a un elemento `<slot />` de Astro. Astro no necesita recibir `{children}` como una función prop y automáticamente renderizará `<slot />`.
-
-```astro title="src/components/MyComponent.astro" del={3-9} ins={11-13}
----
----
-export default function MyComponent(props) { 
-    return (
-      <div>
-        {props.children}
-      </div>
-    );  
-}
-
-<div>
-  <slot />
-</div>
-```
-
-Los componentes de React que pasan múltiples conjuntos de hijos se pueden migrar a un un componente de Astro usando [slots con nombre](/es/basics/astro-components/#slots-con-nombre).
-
-Ver más acerca del [uso especifico de `<slot />` en Astro](/es/basics/astro-components/#slots).
-
-### Migrando la obtención de datos de Next a Astro
-
-Convierte cualquier instancia de `getStaticProps()` a `Astro.glob()` o `getCollection()`/`getEntryBySlug()` para acceder a los datos de otros archivos en la raíz de tu proyecto. Para [obtener datos remotos](/es/guides/data-fetching/), usa `fetch()`.
-
-Estas solicitudes de datos se realizan en el frontmatter del componente de Astro y utilizan el operador await a nivel superior.
-
-```astro title="src/pages/index.astro"
----
-import { getCollection } from 'astro:content';
-
-// Obtener todas las entradas `src/content/blog/`
-const allBlogPosts = await getCollection('blog');
-
-// Obtener todas las entradas `src/pages/posts/`
-const allPosts = await Astro.glob('../pages/posts/*.md');
-
-const response = await fetch('https://randomuser.me/api/');
-const data = await response.json();
-const randomUser = data.results[0];
----
-```
-
-Ver más acerca de [importaciones de archivos locales con `Astro.glob()`](/es/guides/imports/#astroglob), [consultas usando la API de colecciones](/es/guides/content-collections/#consultando-colecciones) o [obtención de datos remotos](/es/guides/data-fetching/).
-
-### Migrando el sistema de estilos de Next a Astro
-
-Es posible que debas reemplazar cualquier [biblioteca de CSS-in-JS](https://github.com/withastro/astro/issues/4432) (p. ej. styled-components) con otras opciones de CSS disponibles en Astro.
-
-Si es necesario, convierte cualquier objeto de estilo en línea (`style={{ fontWeight: "bold" }}`) a atributos de estilo HTML en línea (`style="font-weight:bold;"`). O, usa una [etiqueta `<style>` de Astro](/es/guides/styling/#estilando-en-astro) para estilos CSS con ámbito limitado.
-
-```astro title="src/components/Card.astro" del={1} ins={2}
-<div style={{backgroundColor: `#f4f4f4`, padding: `1em`}}>{message}</div>
-<div style="background-color: #f4f4f4; padding: 1em;">{message}</div>
-```
-
-Tailwind es compatible después de instalar la [integración de Tailwind](/es/guides/integrations-guide/tailwind/). ¡No se requieren cambios en tu código de Tailwind existente!
-
-Ver más acerca de [Estilos en Astro](/es/guides/styling/).
-
-### Plugin de Imagen de Next a Astro
-
-Convierte cualquier componente `<Image />` de Next a [el componente de imagen propio de Astro](/es/guides/images/#image--astroassets) en archivos `.astro` o `.mdx`, o a una etiqueta [estándar de HTML `<img>` / JSX `<img />`](/es/guides/images/#imágenes-en-componentes-de-frameworks-ui) según corresponda en tus componentes de React.
-
-El componente `<Image />` de Astro funciona solo en archivos `.astro` y `.mdx`. Consulta una [lista completa de sus atributos de componente](/es/guides/images/#propiedades) y ten en cuenta que varios serán diferentes de los atributos de Next.
-
-```astro title="src/pages/index.astro"
----
-import { Image } from 'astro:assets';
-import rocket from '../assets/rocket.png';
----
-<Image src={rocket} alt="Un cohete en el espacio." />
-<img src={rocket.src} alt="Un cohete en el espacio.">
-```
-
-En los componentes de React (`.jsx`), utiliza la sintaxis estándar de imagen (`<img />`). Astro no optimizará estas imágenes, pero puedes instalar y usar paquetes de NPM  para obtener más flexibilidad.
-
-Puedes aprender más sobre [cómo usar imágenes en Astro](/es/guides/images/) en la Guía de Imágenes.
-
-## Ejemplo guiado: Cómo migrar la obtención de datos en Next a Astro
-
-Aquí tienes un ejemplo de cómo obtener datos de una Pokédex en Next.js y cómo convertirlo a Astro.
-    
-`pages/index.js` obtiene y muestra una lista de los primeros 151 Pokémon utilizando [la REST PokéAPI](https://pokeapi.co/).
-
-Aquí te mostramos cómo recrear eso en `src/pages/index.astro`, remplazando `getStaticProps()` con `fetch()`.
-
-<Steps>
-1. Identifica el JSX de return().
-
-    ```jsx title="pages/index.js" {6-18}
-    import Link from 'next/link'
-    import styles from '../styles/poke-list.module.css';
-
-    export default function Home({ pokemons }) {
-        return (
-            <>
-                <ul className={`plain-list ${styles.pokeList}`}>
-                    {pokemons.map((pokemon) => (
-                        <li className={styles.pokemonListItem} key={pokemon.name}>
-                            <Link className={styles.pokemonContainer} as={`/pokemon/${pokemon.name}`} href="/pokemon/[name]">
-                                <p className={styles.pokemonId}>No. {pokemon.id}</p>
-                                <img className={styles.pokemonImage} src={`https://raw.githubusercontent.com/PokeAPI/sprites/master/sprites/pokemon/${pokemon.id}.png`} alt={`Foto de ${pokemon.name}`}></img>
-                                <h2 className={styles.pokemonName}>{pokemon.name}</h2>
-                            </Link>
-                        </li>
-                    ))}
-                </ul>
-            </>
-        )
-    }
-
-    export const getStaticProps = async () => {
-        const res = await fetch("https://pokeapi.co/api/v2/pokemon?limit=151")
-        const resJson = await res.json();
-        const pokemons = resJson.results.map(pokemon => {
-            const name = pokemon.name;
-            // https://pokeapi.co/api/v2/pokemon/1/
-            const url = pokemon.url;
-            const id = url.split("/")[url.split("/").length - 2];
-            return {
-                name,
-                url,
-                id
-            }
-        });
-        return {
-            props: {
-                pokemons,
-            },
-        }
-    }
-    ```
-
-2. Crea `src/pages/index.astro`
-
-    Utiliza el valor de retorno de la función Next. Convierte cualquier sintaxis de Next o React a Astro, incluyendo el cambio de mayúsculas y minúsculas de cualquier [atributo global de HTML](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes).
-
-    Nota que:
-
-    - `.map` ¡simplemente funciona!
-
-    - `className` se convierte en `class`.
-
-    - `<Link>` se convierte en `<a>`.
-
-    - El fragmento `<> </>` no es necesario en la plantilla de Astro.
-
-    - `key` es un atributo de React y no es un atributo de `li` en Astro.
-
-    ```astro title="src/pages/index.astro" "class" "</a>" "<a"
-    ---
-    ---
-    <ul class="plain-list pokeList">
-        {pokemons.map((pokemon) => (
-            <li class="pokemonListItem">
-                <a class="pokemonContainer" href={`/pokemon/${pokemon.name}`}>
-                    <p class="pokemonId">No. {pokemon.id}</p>
-                    <img class="pokemonImage" src={`https://raw.githubusercontent.com/PokeAPI/sprites/master/sprites/pokemon/${pokemon.id}.png`} alt={`Foto de ${pokemon.name}`}/>
-                    <h2 class="pokemonName">{pokemon.name}</h2>
-                </a>
-            </li>
-        ))}
-    </ul>
-    ```
-
-3. Agrega cualquier importación, propiedad y JavaScript necesario.
-
-    Nota que:
-
-    - La función `getStaticProps` ya no es necesaria. Los datos de la API se obtienen directamente en el bloque de código.
-    - Se importa un componente `<Layout>` y envuelve la plantilla de la página.
-
-    ```astro ins={2,4-16,19,31} title="src/pages/index.astro"
-    ---
-    import Layout from '../layouts/layout.astro';
-
-    const res = await fetch("https://pokeapi.co/api/v2/pokemon?limit=151");
-    const resJson = await res.json();
-    const pokemons = resJson.results.map(pokemon => {
-        const name = pokemon.name;
-        // https://pokeapi.co/api/v2/pokemon/1/
-        const url = pokemon.url;
-        const id = url.split("/")[url.split("/").length - 2];
-        return {
-            name,
-            url,
-            id
-        }
-    });
-    ---
-
-    <Layout>
-      <ul class="plain-list pokeList">
-          {pokemons.map((pokemon) => (
-              <li class="pokemonListItem" key={pokemon.name}>
-                  <a class="pokemonContainer" href={`/pokemon/${pokemon.name}`}>
-                      <p class="pokemonId">No. {pokemon.id}</p>
-                      <img class="pokemonImage" src={`https://raw.githubusercontent.com/PokeAPI/sprites/master/sprites/pokemon/${pokemon.id}.png`} alt={`Foto de ${pokemon.name}`}/>
-                      <h2 class="pokemonName">{pokemon.name}</h2>
-                  </a>
-              </li>
-          ))}
-      </ul>
-    </Layout>
-    ```
-</Steps>
-
-## Recursos de la comunidad
-
-- Video: [De NextJS a Astro: más control = sitios más rápidos](https://www.youtube.com/watch?v=PSzCtdM20Fc).
-
-- Video: [Cómo Astro hizo que mi sitio sea 100 veces más rápido](https://www.youtube.com/watch?v=cOxA3kMYtkM).
-
-- Artículo de blog: [Migrando de Next.js a Astro](https://johnzanussi.com/posts/nextjs-to-astro-migration).
-
-- Artículo de blog: [Desde NextJS a Astro](https://vanntile.com/blog/next-to-astro).
-- Artículo de blog: [Convirtiendo Next.js a Astro](https://ericclemmons.com/blog/converting-nextjs-to-astro).
diff --git a/src/content/docs/es/guides/migrate-to-astro/from-nuxtjs.mdx b/src/content/docs/es/guides/migrate-to-astro/from-nuxtjs.mdx
deleted file mode 100644
index 4f22727aaa5b4..0000000000000
--- a/src/content/docs/es/guides/migrate-to-astro/from-nuxtjs.mdx
+++ /dev/null
@@ -1,676 +0,0 @@
----
-title: Migrando desde NuxtJS
-description: Consejos para migrar un proyecto existente de NuxtJS a Astro
-type: migration
-stub: false
-framework: NuxtJS
-i18nReady: true
----
-import AstroVueTabs from '~/components/tabs/AstroVueTabs.astro'
-import PackageManagerTabs from '~/components/tabs/PackageManagerTabs.astro'
-import { FileTree } from '@astrojs/starlight/components';
-
-Aquí hay algunos conceptos clave y estragias de migración para ayudarte a comenzar. ¡Usa el resto de nuestra documentación y nuestra [comunidad de Discord](https://astro.build/chat) para continuar!
-
-> Esta guía se refiere a [Nuxt 2](https://nuxtjs.org/), no a la nueva versión Nuxt 3. Si bien algunos de los conceptos son similares, Nuxt 3 es una versión más nueva del framework y puede requerir estrategias diferentes para partes de tu migración.
-
-## Principales similitudes entre Nuxt y Astro
-
-Nuxt y Astro comparten algunas similitudes que te ayudarán a migrar tu proyecto:
-
-- Los proyectos de Astro también pueden ser SSG o [SSR con prerenderizado a nivel de página](/es/guides/on-demand-rendering/).
-- Astro usa un enrutamiento basado en archivos y [permite que las páginas con nombres creen rutas dinámicas](/es/guides/routing/#rutas-dinámicas)
-- Astro es [basado en componentes](/es/basics/astro-components/) y la estructura de tu marcado será similar antes y después de tu migración.
-- Astro tiene [una integración oficial para usar componentes de Vue](/es/guides/integrations-guide/vue/).
-- Astro tiene soporte para [instalar paquetes de NPM](/es/guides/imports/#paquetes-npm), incluyendo librerías de Vue. Puedes mantener algunos o todos tus componentes y dependencias de Vue existentes.
-
-## Principales diferencias entre Nuxt y Astro
-
-Cuando reconstruyas tu sitio Nuxt en Astro, notarás algunas diferencias importantes:
-
-- Nuxt es una SPA basada en Vue (aplicación de una sola página). Los sitios de Astro son aplicaciones multipágina construidas usando componentes `.astro`, pero también pueden admitir React, Preact, Vue.js, Svelte, SolidJS, AlpineJS, Lit y plantillas HTML sin procesar.
-
-- [Enrutamiento de Página](/es/basics/astro-pages/#enrutamiento-basado-en-archivos): Nuxt usa `vue-router` para el enrutamiento SPA, y `vue-meta` para administrar `<head>`. En Astro, crearás rutas de página HTML separadas y controlarás tu `<head>` directamente o en un componente plantilla.
-
-- [Orientado al contenido](/es/concepts/why-astro/#orientado-al-contenido): Astro fue diseñado para mostrar tu contenido y permitirte optar por la interactividad solo cuando sea necesario. Una aplicación Nuxt existente puede estar construida para una alta interactividad del lado del cliente. Astro tiene capacidades incorporadas para trabajar con tu contenido, como la generación de páginas, pero puede requerir técnicas avanzadas de Astro para incluir elementos que son más difíciles de replicar usando componentes `.astro`, como los paneles de control.
-
-## Migrar tu proyecto de NuxtJS
-
-Cada migración de proyecto se verá diferente, pero hay algunas acciones comunes que realizarás al convertir de Nuxt a Astro.
-
-### Crea un nuevo proyecto Astro
-Utiliza el comando `create astro` en tu gestor de paquetes para lanzar el asistente de linea de comandos de Astro o elige un tema de la comunidad del [catálogo de temas de Astro](https://astro.build/themes).
-
-Puedes pasar un argumento `--template` al comando `create astro` para iniciar un nuevo proyecto Astro con uno de nuestros ejemplos oficiales (por ejemplo, `docs`, `blog`, `portfolio`). O, puedes [iniciar un nuevo proyecto desde cualquier repositorio Astro existente en GitHub](/es/install-and-setup/#usa-un-tema-o-una-plantilla-de-inicio).
-
-  <PackageManagerTabs>
-    <Fragment slot="npm">
-    ```shell
-    # lanzar el Asistente de línea de comandos de Astro
-    npm create astro@latest
-
-    # crear un nuevo proyecto con un ejemplo oficial
-    npm create astro@latest -- --template <example-name>
-    ```
-    </Fragment>
-    <Fragment slot="pnpm">
-    ```shell
-    # lanzar el Asistente de línea de comandos de Astro
-    pnpm create astro@latest
-
-    # crear un nuevo proyecto con un ejemplo oficial
-    pnpm create astro@latest --template <example-name>
-    ```
-    </Fragment>
-    <Fragment slot="yarn">
-    ```shell
-    # lanzar el Asistente de línea de comandos de Astro
-    yarn create astro@latest
-
-    # crear un nuevo proyecto con un ejemplo oficial
-    yarn create astro@latest --template <example-name>
-    ```
-    </Fragment>
-  </PackageManagerTabs>
-
-Luego, copia tus archivos de proyecto Nuxt existentes a tu nuevo proyecto Astro en una carpeta separada fuera de `src`.
-
-:::tip
-Visita https://astro.new para ver la lista completa de plantillas de inicio oficiales y enlaces para abrir un nuevo proyecto en StackBlitz, CodeSandbox o Gitpod.
-:::
-
-### Instalar integraciones (opcional)
-
-Puede resultarte útil instalar algunas de las [integraciones opcionales de Astro](/es/guides/integrations-guide/) para usar mientras estes migrando tu proyecto de Nuxt a Astro:
-
-- **@astrojs/vue**: para reutilizar algunos componentes de interfaz de usuario Vue existentes en tu nuevo sitio Astro, o seguir escribiendo con componentes Vue.
-
-- **@astrojs/mdx**: para traer archivos MDX existentes de tu proyecto Nuxt, o para usar MDX en tu nuevo sitio Astro.
-
-### Coloca tu código fuente en `src`
-
-1. **Mueve** el contenido de la carpeta `static/` de Nuxt a `public/`.
-   
-    Astro usa el directorio `public/` para los activos estáticos, similar a la carpeta `static/` de Nuxt.
-
-2. **Copia o mueve** los otros archivos y carpetas de Nuxt (por ejemplo, `pages`, `layouts`, etc.) a la carpeta `src/` de Astro.
-
-    Como Nuxt, la carpeta `src/pages/` de Astro es una carpeta especial utilizada para el enrutamiento basado en archivos. Todas las demás carpetas son opcionales, y puedes organizar el contenido de tu carpeta `src/` de la forma que desees. Otras carpetas comunes en los proyectos Astro incluyen `src/layouts/`, `src/components`, `src/styles`, `src/scripts`.
-
-### Convertir páginas Vue SFC a archivos `.astro`
-
-Aqui hay algunos consejos para convertir un componente `.vue` de Nuxt en un componente `.astro`:
-
-1. Usa la etiqueta `<template>` de la función de componente NuxtJS existente como base para tu plantilla HTML.
-
-2. Cambia cualquier [sintaxis de Nuxt o Vue a Astro](#referencia-convertir-la-sintaxis-de-nuxtjs-a-astro) o a los estándares web de HTML. Esto incluye `<NuxtLink>`, `:class`, `{{variable}}`, y `v-if`, por ejemplo.
-
-3. Mueve la etiqueta `<script>` de JavaScript, a un "valla de código" (`---`). Convierte las propiedades de recuperación de datos de tu componente a JavaScript del lado del servidor - ver [la obtención de datos de Nuxt en Astro](#obtención-de-datos-de-nuxt-a-astro).
-
-4. Utiliza `Astro.props` para acceder a cualquier prop adicional que se pasaba anteriormente a tu componente Vue.
-
-5. Decide si algún componente importado también necesita ser convertido a Astro. Con la integración oficial instalada, puedes [usar componentes Vue existentes en tu archivo Astro](/es/guides/integrations-guide/vue/). Pero, es posible que desees convertirlos a Astro, ¡especialmente si no necesitan ser interactivos!
-
-Mira [un ejemplo de una aplicación Nuxt convertida paso a paso](#ejemplo-guiado-mira-los-pasos).
-
-#### Comparar: Vue vs Astro
-
-Compara el siguiente componente de Nuxt con un componente de Astro: 
-
-<AstroVueTabs>
-  <Fragment slot="vue">
-    ```vue title="Page.vue"
-    <template>
-      <div>
-        <p v-if="message === 'Not found'">
-          The repository you're looking up doesn't exist
-        </p>
-        <div v-else>
-          <Header/>
-          <p class="banner">Astro has {{stars}} 🧑‍🚀</p>
-          <Footer />
-        </div>
-      </div>
-    </template>
-
-    <script>
-    import Vue from 'vue'
-    
-    export default Vue.extend({
-      name: 'IndexPage',
-      async asyncData() {
-        const res = await fetch('https://api.github.com/repos/withastro/astro')
-        const json = await res.json();
-        return {
-          message: json.message,
-          stars: json.stargazers_count || 0,
-        };
-      }
-    });
-    </script>
-    
-    <style scoped>
-    .banner {
-      background-color: #f4f4f4;
-      padding: 1em 1.5em;
-      text-align: center;
-      margin-bottom: 1em;
-    }
-    <style>
-    ```
-  </Fragment>
-  <Fragment slot="astro">
-    ```astro title="Page.astro"
-    ---
-    import Header from "./header";
-    import Footer from './footer';
-    import "./layout.css";
-
-    const res = await fetch('https://api.github.com/repos/withastro/astro')
-    const json = await res.json()
-    const message = json.message;
-    const stars = json.stargazers_count || 0;
-    ---
-    
-    {message === "Not Found" ? 
-          <p>The repository you're looking up doesn't exist</p> :
-          <>
-                <Header />
-                <p class="banner">Astro has {stars} 🧑‍🚀</p>
-                <Footer />
-            </> 
-    }
-    
-    <style>
-      .banner {
-        background-color: #f4f4f4; 
-        padding: 1em 1.5em;
-        text-align: center;
-        margin-bottom: 1em;
-      }
-    <style>
-    ```
-  </Fragment>
-</AstroVueTabs>
-
-### Migrando Archivos de Diseño
-
-Puede resultarte útil comenzar convirtiendo tus diseños y plantillas de Nuxt en [componentes de diseño de Astro](/es/basics/layouts/).
-
-Cada página de Astro requiere explícitamente que las etiquetas `<html>`, `<head>` y `<body>` estén presentes. Tu `layout.vue` y plantillas de Nuxt no incluirán estas.
-
-Ten en cuenta la plantilla HTML estándar y el acceso directo a `<head>`:
-
-```astro title="src/layouts/Layout.astro"
-<html lang="en">
-  <head>
-    <meta charset="utf-8" />
-    <link rel="icon" type="image/svg+xml" href="/favicon.svg" />
-    <meta name="viewport" content="width=device-width" />
-    <title>Astro</title>
-  </head>
-  <body>
-    <!-- Envuelve el elemento slot con el diseño existente de plantilla -->
-    <slot />
-  </body>
-</html>
-```
-
-También puede que desees reutilizar el código de [la propiedad `head` de la página de Nuxt](https://nuxtjs.org/docs/configuration-glossary/configuration-head/#the-head-property) para incluir metadatos adicionales del sitio. Ten en cuenta que Astro no usa ni `vue-meta` ni la propiedad `head` de un componente, sino que crea `<head>` directamente. Puedes importar y usar componentes, incluso dentro de `<head>`, para separar y organizar el contenido de tu página.
-
-### Migrando Páginas y Publicaciones
-
-En NuxtJS, tus [páginas](/es/basics/astro-pages/) viven en `/pages`. En Astro, **todo el contenido de tu página debe vivir dentro de `src/pages` o `src/content`**.
-
-#### Páginas de Vue
-
-Tus páginas Vue existentes (`.vue`) de Nuxt deberán [convertirse de archivos Vue a páginas `.astro`](#convertir-páginas-vue-sfc-a-archivos-astro). No puedes usar un archivo de página Vue existente en Astro.
-
-Estas [páginas `.astro`](/es/basics/astro-pages/) deben estar ubicadas dentro de `src/pages/` y tendrán rutas de página generadas automáticamente en función de su ruta de archivo.
-
-##### Nombres de ruta de archivo dinámico
-
-En Nuxt, tus páginas dinámicas usan un guión bajo para representar una propiedad de página dinámica que luego se pasa a la generación de la página:
-
-<FileTree>
-- pages/
-  - pokemon/
-    - _name.vue
-  - index.vue
-- nuxt.config.js
-</FileTree>
-
-Para convertir a Astro, cambia esta propiedad de ruta dinámica subrayada (por ejemplo, `_name.vue`) para que esté envuelta en un par de corchetes (por ejemplo, `[name].astro`):
-
-<FileTree>
-- src/
-  - pages/
-    - pokemon/
-      - [name].astro
-    - index.astro
-- astro.config.mjs
-</FileTree>
-
-
-#### Páginas de Markdown y MDX
-
-Astro tiene soporte incorporado para Markdown y una integración opcional para archivos MDX. Puedes reutilizar cualquier página Markdown y MDX existente, pero puede que requieran algunos ajustes en tu frontmatter, como agregar [la propiedad especial `layout` del frontmatter de Astro](/es/basics/layouts/#plantillas-de-markdown).
-
-Ya no necesitarás crear manualmente páginas para cada ruta generada por Markdown o usar un paquete externo como `@nuxt/content`. Estos archivos se pueden colocar dentro de `src/pages/` para aprovechar el enrutamiento automático basado en archivos.
-
-Cuando forma parte de una [colección de contenido](/es/guides/content-collections/), los archivos Markdown y MDX vivirán en carpetas dentro de `src/content/` y [generarás esas páginas dinámicamente](/es/guides/content-collections/#generando-rutas-desde-el-contenido).
-
-### Migrando Tests
-
-Como Astro genera HTML sin procesar, es posible escribir tests end-to-end utilizando la salida del paso de compilación. Cualquier test end-to-end escrito anteriormente podría funcionar de inmediato, si has podido hacer coincidir el marcado de tu sitio Nuxt. Las bibliotecas de pruebas como Jest y Vue Testing Library se pueden importar y usar en Astro para probar tus componentes Vue.
-
-Ver más en la [guía de pruebas de Astro](/es/guides/testing/).
-
-## Referencia: Convertir la sintaxis de NuxtJS a Astro
-
-### Variables locales de Nuxt a Astro
-
-Para usar variables locales en un componente de Astro HTML, cambia el conjunto de dos llaves a un conjunto de llaves:
-
-```astro title="src/components/Component.astro" del={3} add={4}
----
-const message = "Hello!"
----
-<p>{{message}}</p>
-<p>{message}</p>
-```
-
-### Pasar propiedades de Nuxt a Astro
-
-Para vincular un atributo o una propiedad de componente en un componente de Astro, cambia la sintaxis a la siguiente:
-
-```astro title="src/components/Component.astro" del={3-7} ins={9-11}
----
----
-<p v-bind:aria-label="message">...</p>
-<!-- Or -->
-<p :aria-label="message">...</p>
-<!-- Also support component props -->
-<Header title="Page"/>
-
-<p aria-label={message}>...</p>
-<!-- Also support component props -->
-<Header title={"Page"}/>
-```
-
-### Enlaces de Nuxt a Astro
-
-Convierte cualquiere componente `<NuxtLink to="">` de Nuxt a etiquetas HTML `<a href="">`.
-
-```astro del={1} ins={2}
-<NuxtLink to="/blog">Blog</Link>
-<a href="/blog">Blog</a>
-```
-
-Astro no usa ningún componente especial para los enlaces, aunque puedes crear componentes de enlace personalizados. Luego puedes importar y usar este `<Link>` como lo harías con cualquier otro componente.
-
-```astro title="src/components/Link.astro"
----
-const { to } = Astro.props
----
-<a href={to}><slot /></a>
-```
-
-### Importaciones de Nuxt a Astro
-
-Si es necesario, actualiza cualquier [importación de archivo](/es/guides/imports/) para hacer referencia exacta a las rutas de archivo relativas. Esto se puede hacer usando [alias de importación](/es/guides/typescript/#alias-de-importación) o escribiendo una ruta relativa completa.
-
-Ten en cuenta que `.astro` y varios otros tipos de archivo deben importarse con su extensión de archivo completa.
-
-```astro title="src/pages/authors/Fred.astro" ".astro"
----
-import Card from `../../components/Card.astro`;
----
-<Card />
-```
-
-### Generación de páginas dinámicas de Nuxt a Astro
-
-En Nuxt, para generar una página dinámica, debes:
-
-- Usar renderizado del lado del servidor (SSR).
-- [Usar la función `generate` en `nuxt.config.js`](https://nuxtjs.org/docs/configuration-glossary/configuration-generate/) para definir todas las rutas estáticas posibles.
-
-En astro, similarmente tienes dos opciones: 
-- [Usar renderizado del lado del servidor (SSR)](/es/guides/on-demand-rendering/).
-- Exporta una función `getStaticPaths()` en el frontmatter de una página de Astro para indicarle al framework qué [rutas estáticas generar dinámicamente](/es/guides/routing/#rutas-dinámicas).
-
-#### Convertir una función `generate` en Nuxt a una función `getStaticPaths` en Astro.
-
-Para generar varias páginas, reemplaza la función para crear rutas en tu `nuxt.config.js` con `getStaticPaths()` directamente dentro de una página de enrutamiento dinámico:
-
-```javascript title="nuxt.config.js"
-{
-	// ...
-    generate: {
-        async routes() {
-          // Axios es requerido aquí a menos que estés usando Node 18
-          const res = await axios.get("https://pokeapi.co/api/v2/pokemon?limit=151")
-          const pokemons = res.data.results;
-          return pokemons.map(pokemon => {
-            return '/pokemon/' + pokemon.name
-          })
-        }
-      }
-}
-```
-
-```astro title="src/pages/pokemon/[name].astro"
----
-export const getStaticPaths = async () => {
-  const res = await fetch("https://pokeapi.co/api/v2/pokemon?limit=151")
-  const resJson = await res.json();
-  const pokemons = resJson.results;
-  return pokemons.map(({ name }) => ({
-      params: { name },
-    }))
-}
-// ...
----
-<!-- Tu plantilla aquí -->
-```
-
-### Obtención de datos de Nuxt a Astro
-
-Nuxt tiene dos métodos para obtener datos del lado del servidor:
-
-- [opciones API de `asyncData`](https://nuxtjs.org/docs/features/data-fetching/#async-data)
-- [gancho `fetch`](https://nuxtjs.org/docs/features/data-fetching/#the-fetch-hook)
-
-En Astro, obtén datos dentro de la valla de código de tu página.
-
-Migra lo siguiente:
-
-```vue title="pages/index.vue"
-{
-  // ...
-  async asyncData() {
-    const res = await fetch("https://pokeapi.co/api/v2/pokemon?limit=151")
-    const resJson = await res.json();
-    const pokemons = resJson.results;
-    return {
-      pokemons,
-    }
-  },
-}
-```
-
-Para una valla de código sin una función de envoltura:
-
-```astro title="src/pages/index.astro"
----
-const res = await fetch("https://pokeapi.co/api/v2/pokemon?limit=151")
-const resJson = await res.json();
-const pokemons = resJson.results;
----
-
-<!-- Tu plantilla va aqui -->
-```
-
-### Nuxt Styling to Astro
-
-Nuxt utiliza el estilo de los componentes de Vue para generar el estilo de una página.
-
-```vue title="pages/index.vue"
-<template>
-  <!-- Tu plantilla va aqui -->
-</template>
-
-<script>
-  // La lógica del servidor va aquí
-</script>
-
-<style scoped>
-    .class {
-        color: red;
-    }
-</style>
-```
-
- Similarmente, en Astro puedes poner en una etiqueta `<style>` en la plantilla de tu página para proporcionar estilos con alcance al componente.
-
-```astro title="src/pages/index.vue"
----
-// La lógica del servidor aquí
----
-
-<style>
-    .class {
-        color: red;
-    }
-</style>
-```
-
-#### Estilo global
-
-Las etiquetas `<style>` son `scoped` (delimitadas) de forma predeterminada en Astro. Para hacer que una etiqueta `<style>` sea global, márcala con el atributo `is:global`:
-
-```astro title="src/pages/index.vue"
-<style is:global> 
-	p {
-		color: red;
-	}
-</style>
-```
-
-
-
-#### Soporte de preprocesadores
-
-[Astro admite los preprocedaores de CSS más populares](/es/guides/styling/#preprocesadores-css) instalandolos como una dependencia de desarrollo. Por ejemplo, para usar SCSS:
-
-
-```shell
-npm install -D sass
-```
-
-Después de hacerlo, puedes usar estilos `.scss` o `.sass` sin modificación desde tus componentes Vue.
-
-```astro title="src/layouts/Layout.astro"
-<p>Hello, world</p>
-<style lang="scss">
-p {
-   color: black;
-   
-   &:hover {
-       color: red;
-   }
-}
-</style>
-```
-
-Ve más sobre [Estilos en Astro](/es/guides/styling/).
-
-### Plugin de imagen de Nuxt a Astro
-
-Convierte cualquier [componente `<nuxt-img/>` or `<nuxt-picture/>` de Nuxt](https://image.nuxtjs.org/components/nuxt-img) al [componente de imagen propio de Astro](/es/guides/images/#image--astroassets) en archivos `.astro` o `.mdx`, o al tag estándar [`<img>`](/es/guides/images/#imágenes-en-componentes-de-frameworks-ui) o `<picture>` de HTML según corresponda en tus componentes de Vue.
-
-El componente `<Image />` de Astro funciona solo en archivos `.astro` y `.mdx`. Consulta una [lista completa de sus atributos de componente](/es/guides/images/#propiedades) y ten en cuenta que varios serán diferentes de los atributos de Nuxt.
-
-```astro title="src/pages/index.astro"
----
-import { Image } from 'astro:assets';
-import rocket from '../assets/rocket.png';
----
-<Image src={rocket} alt="Un cohete en el espacio." />
-<img src={rocket.src} alt="Un cohete en el espacio.">
-```
-
-En los componentes Vue (`.vue`) dentro de tu aplicación Astro, usa la sintaxis de imagen JSX estándar (`<img />`). Astro no optimizará estas imágenes, pero puedes instalar y usar paquetes NPM para tener más flexibilidad.
-
-Puedes aprender más sobre [el uso de imágenes en Astro](/es/guides/images/) en la guía de imágenes.
-
-## Ejemplo guiado: ¡Mira los pasos!
-
-Aquí hay un ejemplo de la obtención de datos de un Pokédex hecho con Nuxt migrado a Astro.
-
-`pages/index.vue` obtiene y muestra una lista de los primeros 151 Pokémon usando [la REST PokéAPI](https://pokeapi.co/).
-
-
-Aquí está cómo recrearlo en `src/pages/index.astro`, reemplazando `asyncData()` con `fetch()`.
-
-1. Identifica las etiquetas `<template>` y `<style>` en el SFC de Vue.
-
-    ```jsx title="pages/index.vue" {2-13,47-55}
-    <template>
-      <ul class="plain-list pokeList">
-                <li v-for="pokemon of pokemons" class="pokemonListItem" :key="pokemon.name">
-                    <NuxtLink class="pokemonContainer" :to="`/pokemon/${pokemon.name}`">
-                        <p class="pokemonId">No. {{pokemon.id}}</p>
-                        <img
-                          class="pokemonImage"
-                          :src="`https://raw.githubusercontent.com/PokeAPI/sprites/master/sprites/pokemon/${pokemon.id}.png`" 
-                          :alt="`Foto de ${pokemon.name}`"/>
-                        <h2 class="pokemonName">{{pokemon.name}}</h2>
-                    </NuxtLink>
-                </li>
-        </ul>
-    </template>
-
-    <script>
-    import Vue from 'vue'
-    export default Vue.extend({
-      name: 'IndexPage',
-      layout: 'default',
-      async asyncData() {
-        const res = await fetch("https://pokeapi.co/api/v2/pokemon?limit=151")
-        const resJson = await res.json();
-        const pokemons = resJson.results.map(pokemon => {
-            const name = pokemon.name;
-            // https://pokeapi.co/api/v2/pokemon/1/
-            const url = pokemon.url;
-            const id = url.split("/")[url.split("/").length - 2];
-            return {
-                name,
-                url,
-                id
-            }
-        });
-        return {
-          pokemons,
-        }
-      },
-      head() {
-        return {
-          title: "Pokedex: Generation 1"
-        }
-      }
-    });
-    </script>
-
-    <style scoped>
-    .pokeList {
-      display: grid;
-      grid-template-columns: repeat( auto-fit, minmax(250px, 1fr) );
-      gap: 1rem;
-    }
-
-    /* ... */
-    </style>
-    ```
-
-2. Crea `src/pages/index.astro`
-
-    Usa las etiquetas `<template>` y `<style>` del SFC de Nuxt. Convierte cualquier sintaxis de Nuxt o Vue a Astro.
-
-    Ten en cuenta que:
-
-    - la etiqueta `<template>` es eliminada
-
-    - la etiqueta `<style>` tiene su atributo `scoped` eliminado
-
-    - `v-for` se convierte en `.map`.
-
-    - `:attr="val"` se convierte en `attr={val}`
-
-    - la etiqueta `<NuxtLink>` se convierte en `<a>`.
-
-    - El fragmento `<> </>` no es requerido en la plantilla de Astro.
-
-    ```astro title="src/pages/index.astro" ".map" "</a>" "<a" "key={" "}>" "href={" " {pokemon.id}" "} alt={" "src={" "}/>" ">{pokemon.name}<"
-    ---
-    ---
-    <ul class="plain-list pokeList">
-        {pokemons.map((pokemon) => (
-            <li class="pokemonListItem" key={pokemon.name}>
-                <a class="pokemonContainer" href={`/pokemon/${pokemon.name}`}>
-                    <p class="pokemonId">No. {pokemon.id}</p>
-                    <img class="pokemonImage" src={`https://raw.githubusercontent.com/PokeAPI/sprites/master/sprites/pokemon/${pokemon.id}.png`} alt={`Foto de ${pokemon.name}`}/>
-                    <h2 class="pokemonName">{pokemon.name}</h2>
-                </a>
-            </li>
-        ))}
-    </ul>
-
-    <style>
-    .pokeList {
-      display: grid;
-      grid-template-columns: repeat( auto-fit, minmax(250px, 1fr) );
-      gap: 1rem;
-    }
-
-    /* ... */
-    </style>
-    ```
-
-3. Agrega cualquier importación, propiedad y JavaScript necesario
-
-    Ten en cuenta que:
-
-    - La función `asyncData` no es necesaria. Los datos de la API se obtienen directamente en la valla de código.
-    - Un componente `<Layout>` es importado y envuelve la plantilla de la página.
-      - Nuestro método `head()` de Nuxt se pasa al componente `<Layout>`, que se pasa al elemento `<title>` como propiedad.
-
-    ```astro ins={2,4-16,19,31} title="src/pages/index.astro"
-    ---
-    import Layout from '../layouts/layout.astro';
-
-    const res = await fetch("https://pokeapi.co/api/v2/pokemon?limit=151");
-    const resJson = await res.json();
-    const pokemons = resJson.results.map(pokemon => {
-        const name = pokemon.name;
-        // https://pokeapi.co/api/v2/pokemon/1/
-        const url = pokemon.url;
-        const id = url.split("/")[url.split("/").length - 2];
-        return {
-            name,
-            url,
-            id
-        }
-    });
-    ---
-
-    <Layout title="Pokedex: Generation 1">
-      <ul class="plain-list pokeList">
-          {pokemons.map((pokemon) => (
-              <li class="pokemonListItem" key={pokemon.name}>
-                  <a class="pokemonContainer" href={`/pokemon/${pokemon.name}`}>
-                      <p class="pokemonId">No. {pokemon.id}</p>
-                      <img class="pokemonImage" src={`https://raw.githubusercontent.com/PokeAPI/sprites/master/sprites/pokemon/${pokemon.id}.png`} alt={`Foto de ${pokemon.name}`}/>
-                      <h2 class="pokemonName">{pokemon.name}</h2>
-                  </a>
-              </li>
-          ))}
-      </ul>
-    </Layout>
-
-    <style>
-    .pokeList {
-      display: grid;
-      grid-template-columns: repeat( auto-fit, minmax(250px, 1fr) );
-      gap: 1rem;
-    }
-
-    /* ... */
-    </style>
-    ```
-
-## Recursos de la comunidad
-
-- Artículo de Blog: [De Nuxt a Astro - reconstruyendo con Astro](https://dev.to/lindsaykwardell/from-nuxt-to-astro-rebuilding-with-astro-5ann)
-- Artículo de Blog: [Cambio de plataforma de Nuxt 2 a Astro 3 - de configuración a producción](https://stevenwoodson.com/blog/replatforming-from-nuxtjs-2-to-astro/)
diff --git a/src/content/docs/es/guides/migrate-to-astro/from-pelican.mdx b/src/content/docs/es/guides/migrate-to-astro/from-pelican.mdx
deleted file mode 100644
index 28085ccca8b73..0000000000000
--- a/src/content/docs/es/guides/migrate-to-astro/from-pelican.mdx
+++ /dev/null
@@ -1,64 +0,0 @@
----
-title: Migrando desde Pelican
-description: Consejos para migrar un proyecto existente de Pelican a Astro
-type: migration
-stub: true
-framework: Pelican
-i18nReady: true
----
-
-import PackageManagerTabs from '~/components/tabs/PackageManagerTabs.astro'
-
-[Pelican](https://getpelican.com) es un generador de sitios estáticos de código abierto construido en Python.
-
-## Principales similitudes entre Pelican y Astro
-
-Pelican y Astro comparten algunas similitudes que te ayudarán a migrar tu proyecto:
-
-- Pelican y Astro son generadores de sitios estáticos, idealmente adecuados para [sitios web orientados al contenido](/es/concepts/why-astro/#orientado-al-contenido) como blogs.
-
-- Pelican y Astro tienen soporte incorporado para escribir Markdown, incluyendo propiedades frontmatter YAML para metadatos de página. Sin embargo, Astro tiene muy pocas propiedades frontmatter reservadas en comparación con Pelican. Aunque muchas de tus propiedades frontmatter existentes en Pelican no serán "especiales" en Astro, puedes continuar usando tus archivos Markdown existentes y valores frontmatter.
-
-## Principales diferencias entre Pelican y Astro
-
-Cuando reconstruyas tu sitio Pelican a Astro, notarás algunas diferencias importantes:
-
-- Pelican admite escribir contenido en Markdown y reStructured Text (`.rst`). Astro admite crear páginas a partir de archivos Markdown y MDX, pero no admite reStructured Text.
-
-- Pelican usa archivos HTML y sintaxis Jinja para la plantilla. [La sintaxis de Astro](/es/basics/astro-components/) es un subconjunto de HTML similar a JSX. Todo el HTML válido es una sintaxis válida para `.astro`.
-
-- Pelican fue diseñado para construir sitios web ricos en contenido como blogs y tiene algunas características de blog integradas que tendrías que construir tú mismo en Astro. En su lugar, Astro ofrece algunas de estas características incluidas en un [tema de blog oficial](https://github.com/withastro/astro/tree/latest/examples/blog).
-
-## Migrar de Pelican a Astro
-
-Para convertir un sitio de documentación de Pelican a Astro, comienza con nuestra [plantilla oficial de inicio para documentación Starlight](https://starlight.astro.build) o explora más temas de blog de la comunidad en nuestro [catálogo de temas](https://astro.build/themes/).
-
-Puedes pasar el argumento `--template` al comando `create astro` para iniciar un nuevo proyecto Astro con uno de nuestros inicios oficiales. O, puedes [iniciar un nuevo proyecto desde cualquier repositorio Astro existente en GitHub](/es/install-and-setup/#usa-un-tema-o-una-plantilla-de-inicio).
-
-  <PackageManagerTabs>
-    <Fragment slot="npm">
-    ```shell
-    npm create astro@latest -- --template starlight
-    ```
-    </Fragment>
-    <Fragment slot="pnpm">
-    ```shell
-    pnpm create astro@latest --template starlight
-    ```
-    </Fragment>
-    <Fragment slot="yarn">
-    ```shell
-    yarn create astro --template starlight
-    ```
-    </Fragment>
-  </PackageManagerTabs>
-
-Lleva tus archivos existentes de contenido Markdown para [crear páginas Markdown](/es/guides/markdown-content/). Aún puedes tomar ventaja del [enrutamiento basado en archivos](/es/guides/routing/) copiando estos documentos de la carpeta `content/` de Pelican a `src/pages/` en Astro. Puede que desees leer sobre [la estructura del proyecto de Astro](/es/basics/project-structure/) para aprender dónde deben estar ubicados los archivos.
-
-Pelican puede haber manejado gran parte del diseño y los metadatos de tu sitio por ti. Puede que desees leer sobre [la construcción de diseños de Astro como envoltorios de páginas Markdown](/es/basics/layouts/#plantillas-de-markdown) para ver cómo administrar las plantillas tú mismo en Astro, incluido tu `<head>` de página.
-
-Para convertir otros tipos de sitios, como un portafolio o un blog, consulta más plantillas de inicio oficiales en [astro.new](https://astro.new). Encontrarás un enlace al repositorio de GitHub de cada proyecto, así como enlaces de un solo clic para abrir un proyecto de trabajo en los entornos de desarrollo en línea de StackBlitz, CodeSandbox y Gitpod.
-
-## Recursos de la comunidad
-
-- ¡Añade el tuyo!
diff --git a/src/content/docs/es/guides/migrate-to-astro/from-sveltekit.mdx b/src/content/docs/es/guides/migrate-to-astro/from-sveltekit.mdx
deleted file mode 100644
index 21ae2cff086fb..0000000000000
--- a/src/content/docs/es/guides/migrate-to-astro/from-sveltekit.mdx
+++ /dev/null
@@ -1,73 +0,0 @@
----
-title: Migrando desde SvelteKit
-description: Consejos para migrar un proyecto existente de SvelteKit a Astro
-type: migration
-stub: true
-framework: SvelteKit
-i18nReady: true
----
-
-import PackageManagerTabs from '~/components/tabs/PackageManagerTabs.astro'
-
-[SvelteKit](https://kit.svelte.dev) es un framework para construir aplicaciones web sobre Svelte.
-
-## Principales similitudes entre SvelteKit y Astro
-
-SvelteKit y Astro comparten algunas similitudes que te ayudarán a migrar tu proyecto:
-
-- SvelteKit y Astro son generadores de sitios estáticos y frameworks de renderizado del lado del servidor en JavaScript moderno. 
-
-- SvelteKit y Astro usan la [carpeta `src/` para los archivos de tu proyecto](/es/basics/project-structure/#src) y una [carpeta especial para enrutamiento basado en archivos](/es/basics/astro-pages/). Crear y administrar páginas para tu sitio debería ser familiar.
-
-- Astro tiene [una integración oficial para utilizar componentes de Svelte](/es/guides/integrations-guide/svelte/) y admite [la instalación de paquetes NPM](/es/guides/imports/#paquetes-npm), incluyendo varios para Svelte. Podrás escribir componentes de UI en Svelte, y tal vez podrás conservar algunos o todos tus componentes y dependencias existentes.
-
-- Astro y SvelteKit te permiten usar un [headless CMS, APIs or archivos Markdown para los datos](/es/guides/data-fetching/). Podrás seguir utilizando tu sistema preferido de creación de contenido, y conservar tu contenido existente.
-
-## Principales diferencias entre SvelteKit y Astro
-
-Cuando reconstruyas tu sitio de SvelteKit a Astro, notarás algunas diferencias importantes:
-
-- Los sitios de Astro son aplicaciones de varias páginas, mientras que en SvelteKit se enfoca en aplicaciones de una sola página (SPA) con renderizado en el lado del servidor, pero también puede crear aplicaciones de varias páginas (MPA), SPAs tradicionales, o mezclar y combinar estas técnicas dentro de una misma aplicación.
-
-- [Componentes](/es/basics/astro-components/): SvelteKit usa [Svelte](https://svelte.dev). Las páginas de Astro se construyen utilizando [componentes `.astro`](/es/basics/astro-components/), pero también puede admitir [React, Preact, Vue.js, Svelte, SolidJS, AlpineJS, Lit](/es/guides/framework-components/) y plantillas HTML sin procesar.
-
-- [Orientado al contenido](/es/concepts/why-astro/#orientado-al-contenido): Astro fue diseñado para mostrar tu contenido y permitirte optar por la interactividad solo cuando sea necesario. Una aplicación existente de SvelteKit puede estar construida para una alta interactividad del lado del cliente. Astro tiene capacidades integradas para trabajar con tu contenido, como la generación de páginas, pero puede requerir técnicas avanzadas de Astro para incluir elementos que son más difíciles de replicar utilizando componentes `.astro`, como los paneles de control.
-
-- [Preparado para Markdown](/es/guides/markdown-content/): Astro incluye soporte integrado para Markdown, y incluye una [propiedad especial `layout` de YAML frontmatter](/es/basics/layouts/#plantillas-de-markdown) utilizada por archivo para la plantilla de la página. Si estás convirtiendo un blog de SvelteKit basado en Markdown, no tendrás que instalar una integración de Markdown separada ni establecer una plantilla mediante un archivo de configuración. Puedes llevar tus archivos Markdown existentes, pero es posible que debas reorganizarlos ya que la navegación basada en archivos de Astro no requiere una carpeta para cada ruta de página.
-
-
-## Migrar desde SvelteKit a Astro
-
-Para migrar un blog de SvelteKit a Astro, empieza con nuestra plantilla inicial para blogs, o explora más temas de la comunidad para blogs en nuestro [catálogo de temas](https://astro.build/themes/).
-
-Puedes pasar el argumento `--template` al comando `create astro` para empezar un nuevo proyecto de Astro con una de nuestras plantillas oficiales. O, puedes [comenzar un nuevo proyecto desde cualquier repositorio de Astro existente en GitHub](/es/install-and-setup/#usa-un-tema-o-una-plantilla-de-inicio).
-
-  <PackageManagerTabs>
-    <Fragment slot="npm">
-    ```shell
-    npm create astro@latest -- --template blog
-    ```
-    </Fragment>
-    <Fragment slot="pnpm">
-    ```shell
-    pnpm create astro@latest --template blog
-    ```
-    </Fragment>
-    <Fragment slot="yarn">
-    ```shell
-    yarn create astro --template blog
-    ```
-    </Fragment>
-  </PackageManagerTabs>
-
-Lleva tus archivos Markdown (o MDX, con nuestra integración opcional) existentes como contenido para [crear páginas en Markdown o MDX](/es/guides/markdown-content/).
-
-Aunque el enrutamiento basado en archivos y los components de diseño son similares en Astro, es posible que desees leer acerca de la [estructura de proyectos de Astro](/es/basics/project-structure/) para aprender dónde deben ubicarse los archivos.
-
-Para convertir otros tipos de sitios, como un portafolio o sitio de documentación, mira más plantillas oficiales de inicio en [astro.new](https://astro.new). Encontrarás un enlace al repositorio de GitHub de cada proyecto, así como enlaces de un solo clic para abrir un proyecto de trabajo en los entornos de desarrollo en línea de StackBlitz, CodeSandbox y Gitpod.
-
-## Recursos de la Comunidad
-
-- Artículo de blog: [Reescribiendo mi blog de SvelteKit a Astro](https://kharann.com/blog/rewriting-my-blog/)
-
-- ¡Añade el tuyo!
diff --git a/src/content/docs/es/guides/migrate-to-astro/from-vuepress.mdx b/src/content/docs/es/guides/migrate-to-astro/from-vuepress.mdx
deleted file mode 100644
index 903d676cda8cd..0000000000000
--- a/src/content/docs/es/guides/migrate-to-astro/from-vuepress.mdx
+++ /dev/null
@@ -1,67 +0,0 @@
----
-title: Migrando desde VuePress
-description: Consejos para migrar un proyecto existente de VuePress a Astro
-type: migration
-stub: true
-framework: VuePress
-i18nReady: true
----
-import PackageManagerTabs from '~/components/tabs/PackageManagerTabs.astro'
-
-[VuePress](https://vuePress.vuejs.org) es un generador de sitios estáticos de código abierto construido sobre Vue.
-
-## Principales similitudes entre VuePress y Astro
-
-VuePress y Astro comparten algunas similitudes que te ayudarán a migrar tu proyecto:
-
-- Tanto VuePress como Astro son generadores de sitios estáticos de Javascript modernos con estructuras de archivos de proyectos similares. Ambos usan una [carpeta especial `src/pages/` para el enrutamiento basado en archivos](/es/basics/astro-pages/). Crear y administrar páginas para tu sitio debería resultarte familiar.
-
-- Astro y VuePress están diseñados para [sitios web orientados al contenido](/es/concepts/why-astro/#orientado-al-contenido), con un excelente soporte incorporado para archivos Markdown. Escribir en Markdown te resultará familiar, y podrás mantener tu contenido existente.
-
-- Astro tiene [una integración oficial para usar componentes Vue](/es/guides/integrations-guide/vue/) y admite [la instalación de paquetes NPM](/es/guides/imports/#paquetes-npm), incluyendo varios para Vue. Podrás escribir componentes de interfaz de usuario de Vue y es posible que puedas mantener algunos o todos tus componentes y dependencias de Vue existentes.
-
-
-## Principales diferencias entre VuePress y Astro
-
-Cuando reconstruyas tu sitio VuePress en Astro, notarás algunas diferencias importantes.
-
-- VuePress es una aplicación de página única (SPA) basada en Vue. Los sitios de Astro son aplicaciones de varias páginas construidas usando [componentes `.astro`](/es/basics/astro-components/), pero también pueden admitir [React, Preact, Vue.js, Svelte, SolidJS, AlpineJS, Lit](/es/guides/framework-components/) y plantillas HTML sin procesar.
-
-- [Plantillas de diseño](/es/basics/layouts/): los sitios de VuePress se crean usando archivos Markdown (`.md`) para el contenido de la página y plantillas HTML (`.html`) para el diseño. Astro está basado en componentes y usa componentes Astro, que incluyen plantillas HTML para páginas, diseños y elementos de interfaz de usuario individuales. Astro también puede crear [páginas a partir de archivos `.md` y `.mdx`](/es/guides/markdown-content/), usando un componente de diseño Astro para envolver el contenido Markdown en una plantilla de página.
-
-- VuePress fue diseñado para crear sitios centrados en Markdown, con mucho contenido y tiene algunas funciones web específicas para la documentación que tendrías que crear tú mismo en Astro. En cambio, Astro ofrece algunas funciones específicas para la documentación a través de un [tema oficial de documentación](https://starlight.astro.build). ¡Este sitio web fue la inspiración para esa plantilla! También puedes encontrar más [temas de documentación de la comunidad](https://astro.build/themes?search=&categories%5B%5D=docs) con funciones incorporadas en nuestro [catálogo de temas](https://astro.build/themes?search=&categories%5B%5D=docs).
-
-
-## Migrar de VuePress a Astro
-
-Para migrar un sitio de documentación de VuePress a Astro, comienza con nuestra [plantilla oficial de inicio para documentación Starlight](https://starlight.astro.build) o explora más temas de documentación de la comunidad en nuestro [catálogo de temas](https://astro.build/themes?search=&categories%5B%5D=docs).
-
-Puedes pasar el argumento `--template` al comando `create astro` para iniciar un nuevo proyecto Astro con una de nuestras plantillas oficiales. O, puedes [iniciar un nuevo proyecto desde cualquier repositorio Astro existente en GitHub](/es/install-and-setup/#usa-un-tema-o-una-plantilla-de-inicio).
-
-  <PackageManagerTabs>
-    <Fragment slot="npm">
-    ```shell
-    npm create astro@latest -- --template starlight
-    ```
-    </Fragment>
-    <Fragment slot="pnpm">
-    ```shell
-    pnpm create astro@latest --template starlight
-    ```
-    </Fragment>
-    <Fragment slot="yarn">
-    ```shell
-    yarn create astro --template starlight
-    ```
-    </Fragment>
-  </PackageManagerTabs>
-
-Lleva tus archivos de contenido Markdown existentes para [crear páginas Markdown](/es/guides/markdown-content/). Aún puedes aprovechar el [enrutamiento basado en archivos](/es/guides/routing/) moviendo estos documentos de `docs` en VuePress a `src/pages/` en Astro. Crea carpetas con nombres que correspondan a tu proyecto VuePress existente y deberías poder mantener tus URL existentes.
-
-VuePress o cualquier tema instalado, probablemente se encargó de gran parte del diseño y los metadatos de tu sitio. Es posible que desees leer sobre [la construcción de diseños de Astro como envoltorios de páginas Markdown](/es/basics/layouts/#plantillas-de-markdown) para ver cómo administrar las plantillas tú mismo en Astro, incluida la etiqueta `<head>` de tu página.
-
-Puedes encontrar una plantilla de inicio de Astro y otras plantillas en [astro.new](https://astro.new). Encontrarás un enlace al repositorio de GitHub de cada proyecto, así como enlaces de un clic para abrir un proyecto de trabajo en los entornos de desarrollo en línea StackBlitz, CodeSandbox y Gitpod.
-
-## Recursos de la comunidad
-
-- ¡Añade el tuyo!
diff --git a/src/content/docs/es/guides/migrate-to-astro/from-wordpress.mdx b/src/content/docs/es/guides/migrate-to-astro/from-wordpress.mdx
deleted file mode 100644
index 1b737328f8423..0000000000000
--- a/src/content/docs/es/guides/migrate-to-astro/from-wordpress.mdx
+++ /dev/null
@@ -1,71 +0,0 @@
----
-title: Migrando desde WordPress
-description: Consejos para migrar un proyecto existente de WordPress a Astro
-type: migration
-stub: true
-framework: WordPress
-i18nReady: true
----
-import PackageManagerTabs from '~/components/tabs/PackageManagerTabs.astro'
-
-[WordPress](https://wordpress.org) es un sistema de publicación personal de código abierto basado en PHP y MySQL.
-
-:::tip
-Puedes [utilizar WordPress como un headless CMS para tu proyecto de Astro](/es/guides/cms/wordpress/). Sigue nuestra guía para utilizar tu contenido existente de WordPress en un nuevo proyecto Astro.
-:::
-
-## Principales similitudes entre WordPress y Astro
-
-WordPress y Astro comparten algunas similitudes que te ayudarán a migrar tu proyecto:
-
-- WordPress y Astro son ideales para [sitios web orientados al contenido](/es/concepts/why-astro/#orientado-al-contenido) como blogs y te permiten escribir el contenido en Markdown (requiere un complemento en WordPress). Aunque el proceso para agregar nuevo contenido es diferente, [escribir en archivos Markdown](/es/guides/markdown-content/) para tu blog de Astro debería resultarte familiar si has utilizado la sintaxis Markdown en tu editor de WordPress.
-
-- WordPress y Astro te animan a [pensar en el diseño de tu sitio en "bloques"](/es/concepts/islands/) (componentes). En Astro es probable que [escribas más tu propio código para crear estos bloques](/es/basics/astro-components/) en lugar de depender de complementos preconstruidos. Pero pensar en las piezas individuales de tu sitio y cómo se presentan en la página debería resultarte familiar.
-
-## Principales diferencias entre WordPress y Astro
-
-Cuando reconstruyas tu sitio WordPress a Astro, notarás algunas diferencias importantes:
-
-- En WordPress, se edita un sitio a través de un panel de control en línea. En Astro, utilizarás un [editor de código](/es/editor-setup/) y un entorno de desarrollo para mantener tu sitio. Puedes desarrollar localmente en tu máquina, o elegir un editor/entorno de desarrollo en la nube como StackBlitz, CodeSandbox o Gitpod.
-
-- En WordPress, hay un amplio mercado de plugins y temas. En Astro, encontrarás algunos temas e [integraciones](https://astro.build/integrations/) disponibles, pero ahora es posible que tengas que construir muchas de tus funciones existentes tú mismo en lugar de buscar soluciones de terceros. ¡O puedes optar por comenzar con un [tema de Astro](https://astro.build/themes) con funciones incorporadas!
-
-- En WordPress, tu contenido se almacena en una base de datos. En Astro, tendrás archivos individuales (normalmente Markdown o MDX) en tu [directorio del proyecto](/es/basics/project-structure/) para el contenido de cada página. O puedes optar por usar un [CMS para tu contenido](/es/guides/cms/), incluso tu sitio WordPress existente, y usar Astro para recuperar y presentar los datos.
-
-## Migrar de WordPress a Astro
-
-Para migrar un blog de WordPress a Astro, empieza con nuestra plantilla inicial para blogs, o explora más temas de la comunidad para blogs en nuestro [mostrador de temas](https://astro.build/themes/).
-
-Puedes pasar el argumento `--template` al comando `create astro` para empezar un nuevo proyecto de Astro con una de nuestras plantillas oficiales. O, puedes [comenzar un nuevo proyecto desde cualquier repositorio de Astro existente en GitHub](/es/install-and-setup/#usa-un-tema-o-una-plantilla-de-inicio).
-
-  <PackageManagerTabs>
-    <Fragment slot="npm">
-    ```shell
-    npm create astro@latest -- --template blog
-    ```
-    </Fragment>
-    <Fragment slot="pnpm">
-    ```shell
-    pnpm create astro@latest --template blog
-    ```
-    </Fragment>
-    <Fragment slot="yarn">
-    ```shell
-    yarn create astro --template blog
-    ```
-    </Fragment>
-  </PackageManagerTabs>
-
-Puedes continuar [usando tu blog existente de WordPress como tu CMS para Astro](/es/guides/cms/wordpress/), lo que significa que seguirás utilizando el dashboard de WordPress para escribir tus publicaciones. Tu contenido será gestionado en WordPress, pero todos los demás aspectos de tu sitio Astro serán creados en tu entorno de edición de código, y deberás [desplegar tu sitio Astro](/es/guides/deploy/) por separado de tu sitio WordPress. (¡Asegúrate de actualizar tu dominio en tu host para mantener la misma URL de tu sitio web!)
-
-Si eres nuevo en el uso de un editor de código y GitHub para almacenar y implementar tu sitio, quizás quieras seguir el [tutorial de Astro para construir un blog](/es/tutorial/0-introduction/)  ¡Te guiará a través de todas las cuentas y configuraciones que necesitas! También aprenderás a [crear tus propios componentes en Astro](/es/tutorial/3-components/), y te mostrará cómo [agregar publicaciones de blog directamente en Astro](/es/tutorial/2-pages/2/) si decides no usar WordPress para escribir tu contenido.
-
-Si deseas trasladar todo tu contenido de publicaciones existente a Astro, puede resultarte útil esta [herramienta para exportar a Markdown desde WordPress](https://github.com/lonekorean/wordpress-export-to-markdown). Es posible que debas realizar algunos ajustes en el resultado si tienes que [migrar un sitio de WordPress grande o complicado a Markdown](https://swizec.com/blog/how-to-export-a-large-wordpress-site-to-markdown/).
-
-Para migrar otros tipos de sitios, como un portafolio o sitio de documentatión, mira más plantillas oficiales de inicio en [astro.new](https://astro.new). Encontrarás un enlace al repositorio de GitHub de cada proyecto, así como enlaces de un solo clic para abrir un proyecto de trabajo en los entornos de desarrollo en línea de StackBlitz, CodeSandbox y Gitpod.
-
-## Recursos de la comunidad
-
-- Artículo de blog: [Por qué cambié de WordPress a Astro](https://dev.to/fratzinger/why-i-switched-from-wordpress-to-astro-5ge) por fratzinger
-
-- ¡Añade el tuyo!
\ No newline at end of file
diff --git a/src/content/docs/es/guides/migrate-to-astro/index.mdx b/src/content/docs/es/guides/migrate-to-astro/index.mdx
deleted file mode 100644
index 090e63e192213..0000000000000
--- a/src/content/docs/es/guides/migrate-to-astro/index.mdx
+++ /dev/null
@@ -1,46 +0,0 @@
----
-title: Migra un proyecto existente a Astro
-description: Algunos consejos y trucos para convertir tu proyecto a Astro.
-i18nReady: true
----
-import MigrationGuidesNav from '~/components/MigrationGuidesNav.astro';
-
-**¿Listo para convertir tu proyecto a Astro?** Consulta una de nuestras guías para obtener consejos de migración.
-
-## Guías de migración
-
-<MigrationGuidesNav />
-
-Ten en cuenta que muchas de estas páginas son **colecciones**: ¡son colecciones de recursos que esperan tu contribución!
-
-## ¿Por qué migrar tu proyecto a Astro?
-
-Astro ofrece muchos beneficios: rendimiento, simplicidad y muchas de las funciones que deseas integrar directamente en el framework. Cuando necesites ampliar tu proyecto, Astro proporciona varias [integraciones comunitarias, oficiales y de terceros](https://astro.build/integrations).
-
-¡Migrar puede ser menos trabajo de lo que piensas!
-
-Dependiendo de tu proyecto, es posible que puedas reusar el existente:
-
-- [Componentes de framework](/es/guides/framework-components/) directamente en Astro.
-
-- [Hojas de estilo CSS o bibliotecas](/es/guides/styling/) incluyendo Tailwind.
-
-- [Archivos Markdown/MDX](/es/guides/markdown-content/), configurado usando tus [plugins de remark y rehype](/es/guides/markdown-content/#configuración-de-markdown-y-mdx).
-
-- [Contenido de una CMS](/es/guides/cms/) a través de una integración o API.
-
-## ¿Qué proyectos puedo convertir a Astro?
-
-[Muchos proyectos existentes se pueden construir con Astro](/es/concepts/why-astro/). Astro es ideal para tus proyectos basados en contenido, como blogs, páginas landing, sitios de marketing y portafolios. Astro se integra con varios headless CMSs populares y te permite conectar carritos de compras de eCommerce.
-
-Astro te permite elegir entre un proyecto generado estáticamente y [en el servidor (SSR)](/es/guides/on-demand-rendering/), lo que lo convierte en un excelente reemplazo para los SSG o para los proyectos que necesitan obtener algunos datos de la página al vuelo.
-
-## ¿Cómo cambiará el diseño de mi proyecto?
-
-Dependiendo de tu proyecto, es posible que debas pensar de manera diferente acerca de:
-
-- Diseño con [Islas de Astro](/es/concepts/islands/#qué-es-una-isla) para evitar enviar JavaScript innecesario al navegador.
-
-- Proporcionar interactividad del lado del cliente con [etiquetas `<script>`](/es/guides/client-side-scripts/) o [componentes de framework](/es/guides/framework-components/) .
-
-- Administrar el [estado compartido](/es/recipes/sharing-state-islands/) con Nano Stores o almacenamiento local en lugar de hooks o contextos para toda la aplicación.
diff --git a/src/content/docs/es/guides/on-demand-rendering.mdx b/src/content/docs/es/guides/on-demand-rendering.mdx
index a9dc488b750a6..3d5a7b0e0a8a6 100644
--- a/src/content/docs/es/guides/on-demand-rendering.mdx
+++ b/src/content/docs/es/guides/on-demand-rendering.mdx
@@ -29,7 +29,7 @@ Astro mantiene adaptadores oficiales para [Node.js](https://nodejs.org/), [Netli
 
 ### Agrega un adaptador
 
-Puedes agregar cualquiera de las [integraciones oficiales de adaptadores mantenidas por Astro](/es/guides/integrations-guide/#integraciones-oficiales) con el siguiente comando `astro add`. Esto instalará el adaptador y realizará los cambios correspondientes en tu archivo `astro.config.mjs` en un solo paso. 
+Puedes agregar cualquiera de las [integraciones oficiales de adaptadores mantenidas por Astro](/es/guides/integrations-guide/#official-integrations) con el siguiente comando `astro add`. Esto instalará el adaptador y realizará los cambios correspondientes en tu archivo `astro.config.mjs` en un solo paso. 
 
 Por ejemplo, para instalar el adaptador de Netlify, ejecuta:
 
@@ -51,7 +51,7 @@ Por ejemplo, para instalar el adaptador de Netlify, ejecuta:
   </Fragment>
 </PackageManagerTabs>
 
-También puedes [agregar un adaptador manualmente instalando el paquete de NPM](/es/guides/integrations-guide/#instalando-un-paquete-npm) (por ejemplo, `@astrojs/netlify`) y actualizando tu archivo `astro.config.mjs` por tu cuenta.
+También puedes [agregar un adaptador manualmente instalando el paquete de NPM](/es/guides/integrations-guide/#installing-an-npm-package) (por ejemplo, `@astrojs/netlify`) y actualizando tu archivo `astro.config.mjs` por tu cuenta.
 
 Ten en cuenta que los diferentes adaptadores pueden tener configuraciones distintas. Lee la documentación de cada adaptador y aplica las opciones de configuración necesarias en `astro.config.mjs`.
 
@@ -170,11 +170,11 @@ Astro.cookies.set('counter', String(counter))
 </html>
 ```
 
-<ReadMore>Consulta más detalles sobre [`Astro.cookies` y el tipo `AstroCookie`](/es/reference/api-reference/#astrocookies) en la referencia de la API.</ReadMore>
+<ReadMore>Consulta más detalles sobre [`Astro.cookies` y el tipo `AstroCookie`](/es/reference/api-reference/#cookies) en la referencia de la API.</ReadMore>
 
 ### `Response`
 
-[`Astro.response`](/es/reference/api-reference/#astroresponse) es un objeto estándar de [`ResponseInit`](https://developer.mozilla.org/es/docs/Web/API/Response/Response#opciones). Se puede utilizar para establecer el estado y las cabeceras de la respuesta.
+[`Astro.response`](/es/reference/api-reference/#response) es un objeto estándar de [`ResponseInit`](https://developer.mozilla.org/es/docs/Web/API/Response/Response#opciones). Se puede utilizar para establecer el estado y las cabeceras de la respuesta.
 
 El siguiente ejemplo establece un estado de respuesta y un texto de estado para una página de producto cuando el producto no existe:
 
@@ -214,7 +214,7 @@ Astro.response.headers.set('Cache-Control', 'public, max-age=3600');
 
 #### Devuelve un objeto `Response`
 
-También puedes devolver un objeto [Response](https://developer.mozilla.org/es/docs/Web/API/Response) directamente desde cualquier página utilizando la renderización bajo demanda, ya sea manualmente o con [`Astro.redirect`](/es/reference/api-reference/#astroredirect). 
+También puedes devolver un objeto [Response](https://developer.mozilla.org/es/docs/Web/API/Response) directamente desde cualquier página utilizando la renderización bajo demanda, ya sea manualmente o con [`Astro.redirect`](/es/reference/api-reference/#redirect). 
 
 El siguiente ejemplo busca un ID en la base de datos en una página dinámica y, o bien devuelve un error 404 si el producto no existe, o redirige al usuario a otra página si el producto ya no está disponible, o muestra el producto:
 
@@ -278,12 +278,12 @@ console.log(Astro.request.method) // GET (cuando se navega a esta ruta en el nav
 ---
 ```
 
-<ReadMore>Consulta más detalles sobre [`Astro.request`](/es/reference/api-reference/#astrorequest) en la referencia de la API.</ReadMore>
+<ReadMore>Consulta más detalles sobre [`Astro.request`](/es/reference/api-reference/#request) en la referencia de la API.</ReadMore>
 
 ### Endpoints del Servidor
 
 Un endpoint del servidor, también conocido como una **ruta API**, es una función especial exportada desde un archivo `.js` o `.ts` dentro de la carpeta `src/pages/`. Como una potente característica del renderizado en el servidor bajo demanda, las rutas de API pueden ejecutar código de forma segura en el servidor.
 
-La función recibe un [contexto de endpoint](/es/reference/api-reference/#contexto-del-endpoint) y devuelve una [Response](https://developer.mozilla.org/es/docs/Web/API/Response). 
+La función recibe un [contexto de endpoint](/es/reference/api-reference/) y devuelve una [Response](https://developer.mozilla.org/es/docs/Web/API/Response). 
 
-Para obtener más información, consulta nuestra [Guía de Endpoints](/es/guides/endpoints/#endpoints-del-servidor-rutas-de-api).
+Para obtener más información, consulta nuestra [Guía de Endpoints](/es/guides/endpoints/#server-endpoints-api-routes).
diff --git a/src/content/docs/es/guides/routing.mdx b/src/content/docs/es/guides/routing.mdx
deleted file mode 100644
index bd29fc03e4823..0000000000000
--- a/src/content/docs/es/guides/routing.mdx
+++ /dev/null
@@ -1,474 +0,0 @@
----
-title: Enrutamiento
-description: Introducción al enrutamiento en Astro.
-i18nReady: true
----
-import { FileTree } from '@astrojs/starlight/components';
-import RecipeLinks from "~/components/RecipeLinks.astro"
-import Since from '~/components/Since.astro'
-import ReadMore from '~/components/ReadMore.astro'
-
-Astro utiliza **enrutamiento basado en archivos** para generar las URLs finales según el contenido de la carpeta `src/pages/`. 
-
-## Navegando entre páginas
-
-Astro usa elementos HTML estándar [`<a>`](https://developer.mozilla.org/es/docs/Web/HTML/Element/a) para navegar entre rutas. No se proporciona ningún componente `<Link>` específico en Astro.
-
-```astro title="src/pages/index.astro"
-<p>¡Leer más <a href="/about/">sobre</a> Astro!</p>
-```
-
-## Rutas estáticas
-
-Los [componentes página](/es/basics/astro-pages/) `.astro` así como los archivos Markdown y MDX (`.md`, `.mdx`) dentro del directorio `src/pages/` **se convierten automáticamente en páginas de tu sitio web**. La ruta de cada página corresponde a su ruta y nombre de archivo dentro del directorio `src/pages/`.
-
-```diff
-# Ejemplo: Rutas estáticas
-src/pages/index.astro        -> mysite.com/
-src/pages/about.astro        -> mysite.com/about
-src/pages/about/index.astro  -> mysite.com/about
-src/pages/about/me.astro     -> mysite.com/about/me
-src/pages/posts/1.md         -> mysite.com/posts/1
-```
-
-:::tip
-¡No hay una "configuración de enrutamiento" separada para mantener en un proyecto Astro! Cuando se agrega un archivo al directorio `src/pages`, se crea automáticamente una nueva ruta. En compilaciones estáticas, puedes personalizar el formato de salida del archivo usando la opción de configuración [`build.format`](/es/reference/configuration-reference/#buildformat)
-:::
-
-## Rutas dinámicas
-
-Un archivo de página Astro puede especificar parámetros de ruta dinámicos en su nombre para generar múltiples páginas emparejadas. Por ejemplo, `src/pages/authors/[author].astro` que generará una página por cada autor en tu blog. `author` se convierte en un _parámetro_ al que puedes acceder dentro de la página.
-
-En el modo de generación estático por defecto de Astro, estas páginas serán generadas en tiempo de compilación, así que deberías definir previamente la lista de `author`s para ese archivo. En modo SSR, se generará una página bajo petición para cada ruta que coincida.
-
-### Modo Estático (SSG)
-
-Debido a que todas las rutas deben definirse en tiempo de compilación, una ruta dinámica debe exportar una función `getStaticPaths()` que devuelva un array de objetos con una propiedad `params`. Cada uno de estos objetos generará su ruta correspondiente.
-
-`[dogs].astro` define el parámetro dinámico `dog` en su nombre de archivo, así que los objetos devueltos por `getStaticPaths()` deben incluir `dog` en sus `params`. De esta manera la página puede acceder a este parámetro por medio de `Astro.params`.
-
-```astro title="src/pages/dogs/[dog].astro"
----
-export function getStaticPaths() {
-  return [
-    {params: {dog: 'clifford'}},
-    {params: {dog: 'rover'}},
-    {params: {dog: 'spot'}},
-  ];
-}
-
-const { dog } = Astro.params;
----
-<div>¡Buen chico, {dog}!</div>
-```
-
-Esto generará tres páginas: `/dogs/clifford`, `/dogs/rover` y `/dogs/spot`, cada una mostrando el nombre de perro correspondiente.
-
-El nombre de archivo puede incluir múltiples parámetros, los cuales deben estar todos incluidos en los objetos `params` de `getStaticPaths()`:
-
-```astro title="src/pages/[lang]-[version]/info.astro"
----
-export function getStaticPaths () {
- return [
-    {params: {lang: 'en', version: 'v1'}},
-    {params: {lang: 'fr', version: 'v2'}},
-  ];
-}
-
-const { lang, version } = Astro.params;
----
-...
-```
-
-Esto generará `/en-v1/info` y `/fr-v2/info`.
-
-Los parámetros pueden incluirse en distintas partes del path. Por ejemplo, el archivo `src/pages/[lang]/[version]/info.astro` con la misma `getStaticPaths()` arriba generará las rutas `/en/v1/info` y `/fr/v2/info`.
-
-<ReadMore>Lee más sobre [`getStaticPaths()`](/es/reference/api-reference/#getstaticpaths).</ReadMore>
-
-<RecipeLinks slugs={["es/recipes/i18n"]} />
-
-#### Parámetros Rest
-
-Si necesitas más flexibilidad en el enrutamiento de la URL, puedes usar un [parámetro rest](https://developer.mozilla.org/es/docs/Web/JavaScript/Reference/Functions/rest_parameters) (`[...param]`) en el nombre de archivo `.astro` para emparejar rutas de archivos de cualquier profundidad:
-
-```astro title="src/pages/sequences/[...path].astro"
----
-export function getStaticPaths() {
-  return [
-    {params: {path: 'uno/dos/tres'}},
-    {params: {path: 'cuatro'}},
-    {params: {path: undefined }}
-  ]
-}
-
-const { path } = Astro.params;
----
-...
-```
-
-Esto generará `/sequences/uno/dos/tres`, `/sequences/cuatro` y `/sequences`. (Definir el parámetro restante como `undefined` permite emparejar con la página del nivel más alto.)
-
-Los parámetros rest pueden usarse con **otros parámetros nombrados**. Por ejemplo, el visor de archivos de GitHub puede ser representado con la siguiente ruta dinámica:
-
-```
-/[org]/[repo]/tree/[branch]/[...file]
-```
-
-En este ejemplo, una solicitud a `/withastro/astro/tree/main/docs/public/favicon.svg` daría como resultado los siguientes parámetros con nombre:
-
-```js
-{
-	org: 'withastro',
-	repo: 'astro',
-	branch: 'main',
-	file: 'docs/public/favicon.svg'
-}
-```
-
-#### Ejemplo: Páginas dinámicas en múltiples niveles
-
-En el siguiente ejemplo, un parámetro rest (`[...slug]`) y la característica [`props`](/es/reference/api-reference/#transferencia-de-datos-con-props) de `getStaticPaths()` para generar páginas para _slugs_ de diversa profundidad.
-
-```astro title="src/pages/[...slug].astro"
----
-export async function getStaticPaths() {
-  const pages = [
-    {
-      slug: undefined,
-      title: "Tienda de Astro",
-      text: "¡Te damos la bienvenida a la tienda de Astro!",
-    },
-    {
-      slug: "products",
-      title: "Productos de Astro",
-      text: "Tenemos muchos productos para ti",
-    },
-    {
-      slug: "products/astro-handbook",
-      title: "El libro definitivo de Astro",
-      text: "Si quieres aprender sobre Astro, debes leer este libro.",
-    },
-  ];
-  return pages.map(({ slug, title, text }) => {
-    return {
-      params: { slug },
-      props: { title, text },
-    };
-  });
-}
-const { title, text } = Astro.props;
----
-<html>
-  <head>
-    <title>{title}</title>
-  </head>
-  <body>
-    <h1>{title}</h1>
-    <p>{text}</p>
-  </body>
-</html>
-```
-
-### Modo Servidor (SSR)
-En el [modo SSR](/es/guides/on-demand-rendering/), las rutas dinámicas se definen de la misma manera: incluyendo `[param]` o `[...path]` en corchetes a los nombres de tus archivos para emparejar con strings o paths arbitrarios. Pero, como esas rutas no se compilan con anticipación, la página va a servirse con cualquier ruta que coincida. Como estas no son rutas "estáticas", no debemos usar `getStaticPaths`.
-
-```astro title="src/pages/resources/[resource]/[id].astro"
----
-const { resource, id } = Astro.params;
----
-<h1>{resource}: {id}<h1>
-```
-Esta página será servida para cualquier valor de `resource` y `id`: `resources/users/1`, `resources/colors/blue`, etc.
-
-#### Modificando el ejemplo `[...slug]` para SSR
-
-Debido a que las páginas SSR no pueden usar `getStaticPaths`, no pueden recibir props. El [ejemplo anterior](#ejemplo-páginas-dinámicas-en-múltiples-niveles) puede ser adaptado para el modo SSR buscando el valor del parámetro `slug` en un objeto. Si la ruta está en la raíz ("/"), el parámetro slug va a ser `undefined`. Si el valor no existe en el objeto, redirigiremos a una página 404.
-
-```astro title="src/pages/[...slug].astro"
----
-const pages = [
-	{
-		slug: undefined,
-		title: 'Tienda de Astro',
-		text: '¡Te damos la bienvenida a la tienda de Astro!',
-	},
-	{
-		slug: 'products',
-		title: 'Productos de Astro',
-		text: 'Tenemos muchos productos para ti',
-	},
-	{
-		slug: 'products/astro-handbook',
-		title: 'El libro definitivo de Astro',
-		text: 'Si quieres aprender sobre Astro, debes leer este libro.',
-	}
-];
-
-const { slug } = Astro.params;
-const page = pages.find((page) => page.slug === slug);
-if (!page) return Astro.redirect("/404");
-const { title, text } = page;
----
-<html>
-<head>
-  <title>{title}</title>
-</head>
-<body>
-  <h1>{title}</h1>
-  <p>{text}</p>
-</body>
-</html>
-```
-
-## Redirecciones
-
-A veces necesitarás redirigir a tus lectores a una nueva página, ya sea de forma permanente debido a cambios en la estructura de tu sitio o como respuesta a una acción como iniciar sesión en una ruta autenticada.
-
-Puedes definir reglas para [redirigir a los usuarios a páginas movidas permanentemente](#redirecciones-configuradas) en tu configuración de Astro. O puedes redirigir a los [usuarios dinámicamente](#redirecciones-dinámicas) a medida que utilizan tu sitio.
-
-### Redirecciones configuradas
-
-
-<Since v="2.9.0" />
-
-Puedes especificar un mapeo de redirecciones permanentes en la configuración de Astro con el valor `redirects`. Para la mayoría de las redirecciones, esto es un mapeo de una ruta antigua a la nueva ruta:
-
-```js title="astro.config.mjs" {4-6}
-import { defineConfig } from 'astro/config';
-
-export default defineConfig({
-  redirects: {
-    '/old-page': '/new-page'
-  }
-});
-```
-
-Estas redirecciones siguen las mismas reglas que las rutas basadas en archivos. Se permiten rutas dinámicas siempre y cuando tanto las rutas nuevas como las antiguas contengan los mismos parámetros, por ejemplo:
-
-```js
-{
-  "/blog/[...slug]": "/articles/[...slug]"
-}
-```
-
-Usando SSR o un adaptador estático, también puedes proporcionar un objeto como valor, lo que te permite especificar el código de estado (`status`) además del nuevo destino (`destination`):
-
-```js title="astro.config.mjs" {5-8}
-import { defineConfig } from 'astro/config';
-
-export default defineConfig({
-  redirects: {
-    '/old-page': {
-      status: 302,
-      destination: '/new-page'
-    }
-  }
-});
-```
-
-Al ejecutar `astro build`, Astro generará archivos HTML con la etiqueta [meta refresh](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/meta#examples) de forma predeterminada. En cambio, los adaptadores compatibles escribirán el archivo de configuración del host con las redirecciones.
-
-Por defecto, el código de estado es `301`. Si estás generando archivos HTML estáticos, el servidor no utiliza el código de estado.
-
-### Redirecciones dinámicas
-
-En el objeto global `Astro`, el método `Astro.redirect` te permite redirigir a otra página de forma dinámica. Puedes hacer esto después de verificar si el usuario ha iniciado sesión obteniendo su sesión desde una cookie.
-
-```astro title="src/pages/account.astro" {8}
----
-import { isLoggedIn } from '../utils';
-
-const cookie = Astro.request.headers.get('cookie');
-
-// Si el usuario no ha iniciado sesión, redirígelos a la página de inicio de sesión
-if (!isLoggedIn(cookie)) {
-  return Astro.redirect('/login');
-}
----
-<html>
-  <!-- Aquí está la página... -->
-</html>
-```
-
-
-## Orden de prioridad de rutas
-
-Es posible que varias rutas definidas intenten construir la misma ruta de URL. Por ejemplo, todas estas rutas podrían construir `/posts/create`:
-
-<FileTree>
-- src/pages/
-  - [...slug].astro
-  - posts/
-    - create.astro
-    - [page].astro
-    - [pid].ts
-    - [...slug].astro
-</FileTree>
-
-Astro necesita saber qué ruta debe usarse para construir la página. Para ello, los ordena de acuerdo con las siguientes reglas en orden:
-
-- Las rutas con más segmentos de ruta tendrán prioridad sobre las rutas con menos parámetros. En el ejemplo anterior, todas las rutas bajo `/posts/` tienen prioridad sobre `/[...slug].astro` en la raíz.
-- Las rutas estáticas sin parámetros de ruta tendrán prioridad sobre las rutas dinámicas. Por ejemplo, `/posts/create.astro` tiene prioridad sobre todas las demás rutas del ejemplo.
-- Las rutas dinámicas que usan parámetros nombrados tienen prioridad sobre los parámetros restantes. Por ejemplo, `/posts/[page].astro` tiene prioridad sobre `/posts/[...slug].astro`.
-- Las rutas dinámicas pre-renderizadas tienen prioridad sobre las rutas dinámicas del servidor.
-- Los endpoints tienen prioridad sobre las páginas.
-- Si ninguna de las reglas anteriores decide el orden, las rutas se ordenan alfabéticamente según la configuración regional predeterminada de tu instalación de Node.
-
-Dado el ejemplo anterior, aquí hay algunos ejemplos de cómo las reglas harán coincidir una URL solicitada con la ruta utilizada al compilar el HTML:
-
-- `pages/posts/create.astro` - Solo construirá `/posts/create`
-- `pages/posts/[pid].ts` - Construirá `/posts/abc`, `/posts/xyz`, etc. Pero no `/posts/create`
-- `pages/posts/[page].astro` - Construirá `/posts/1`, `/posts/2`, etc. Pero no `/posts/create`, `/posts/abc` ni `/posts/xyz`
-- `pages/posts/[...slug].ts` - Construirá `/posts/1/2`, `/posts/a/b/c`, etc. Pero no `/posts/create`, `/posts/1`, `/posts/abc`, etc.
-- `pages/[...slug].astro` - Construirá `/abc`, `/xyz`, `/abc/xyz`, etc. Pero no `/posts/create`, `/posts/1`, `/posts/abc`, , etc.
-
-## Paginación
-
-Astro mantiene la paginación automática integrada para grandes colecciones de datos que deben dividirse en varias páginas. Astro incluirá automáticamente metadatos de paginación como la URL de la página anterior/siguiente, el número total de páginas y más.
-
-Los nombres de rutas paginadas deben usar la misma sintaxis `[corchete]` que una ruta dinámica estándar. Por ejemplo, el nombre de archivo `/astronautas/[page].astro` generará rutas para `/astronautas/1`, `/astronautas/2`, etc., donde `[page]` es el número de página generado.
-
-Puedes usar la función `paginate()` para generar estas páginas para un array de valores como este:
-
-```astro /{ (paginate) }/ /paginate\\(.*\\)/ /(?<=const.*)(page)/ /page\\.[a-zA-Z]+/
----
-// src/pages/astronauts/[page].astro
-export async function getStaticPaths({ paginate }) {
-  const astronautPages = [{
-    astronaut: 'Neil Armstrong',
-  }, {
-    astronaut: 'Buzz Aldrin',
-  }, {
-    astronaut: 'Sally Ride',
-  }, {
-    astronaut: 'John Glenn',
-  }];
-  // Genera páginas para nuestro array de astronautas, con 2 elementos por página
-  return paginate(astronautPages, { pageSize: 2 });
-}
-// Todos los datos paginados se pasan en la prop "page"
-const { page } = Astro.props;
----
-
-<!--Muestra el número de página actual. ¡También puedes utilizar Astro.params.page!-->
-<h1>Página {page.currentPage}</h1>
-<ul>
-  <!--Enumera el array con información sobre astronautas-->
-  {page.data.map(({ astronaut }) => <li>{astronaut}</li>)}
-</ul>
-```
-
-Esto genera las siguientes páginas, con 2 elementos por página:
-- `/astronauts/1` - Página 1: muestra "Neil Armstrong" y "Buzz Aldrin"
-- `/astronauts/2` - Página 2: Muestra "Sally Ride" y "John Glenn"
-
-### La prop `page`
-
-Cuando usas la función `paginate()`, a cada página se le pasarán los datos a través de una prop `page`. La prop `page` tiene muchas propiedades útiles, pero estas son las más destacadas:
-- **page.data** - array que contiene la porción de datos de página que introdujo a la función `paginate()`
-- **page.url.next** - enlace a la página siguiente del mismo conjunto de datos
-- **page.url.prev** - enlace a la página anterior del mismo conjunto de datos
-
-```astro /(?<=const.*)(page)/ /page\\.[a-zA-Z]+(?:\\.(?:prev|next))?/
----
-// src/pages/astronauts/[page].astro
-// Paginar la misma lista de objetos { astronaut } como en el ejemplo anterior
-export async function getStaticPaths({ paginate }) { /* ... */ }
-const { page } = Astro.props;
----
-<h1>Página {page.currentPage}</h1>
-<ul>
-  {page.data.map(({ astronaut }) => <li>{astronaut}</li>)}
-</ul>
-{page.url.prev ? <a href={page.url.prev}>Anterior</a> : null}
-{page.url.next ? <a href={page.url.next}>Siguiente</a> : null}
-```
-
-#### Referencia completa de la API
-
-```ts
-interface Page<T = any> {
-	/** resultado */
-	data: T[];
-	/** metadatos */
-	/** el recuento del primer elemento de la página, a partir de 0 */
-	start: number;
-	/** el recuento del último elemento de la página, a partir de 0 */
-	end: number;
-	/** el número total de resultados */
-	total: number;
-	/** el número de la página actual, a partir de 1 */
-	currentPage: number;
-	/** el número de elementos por página (predeterminado: 25) */
-	size: number;
-	/** el número de la última página */
-	lastPage: number;
-	url: {
-		/** la url de la página actual */
-		current: string;
-		/** la url de la página anterior (si hay alguna) */
-		prev: string | undefined;
-		/** la url de la página siguiente (si hay alguna) */
-		next: string | undefined;
-	};
-}
-```
-
-### Paginación anidada
-
-Un caso de uso más avanzado de la paginación es la **paginación anidada.** Aquí es cuando la paginación se combina con otros parámetros de rutas dinámicas. Puedes usar la paginación anidada para agrupar la colección paginada por alguna propiedad o etiqueta.
-
-Por ejemplo, si prefieres agrupar las publicaciones de Markdown paginadas por alguna etiqueta, usarás la paginación anidada creando una página `/src/pages/[tag]/[page].astro` que coincida con las siguientes URL:
-
-- `/red/1` (tag=red)
-- `/red/2` (tag=red)
-- `/blue/1` (tag=blue)
-- `/green/1` (tag=green)
-
-La paginación anidada funciona devolviendo un array de resultados `paginate()` de `getStaticPaths()`, uno para cada grupo.
-
-En el siguiente ejemplo, implementaremos la paginación anidada para crear las URL enumeradas anteriormente:
-
-```astro /(?:[(]|=== )(tag)/ "params: { tag }" /const [{ ]*(page|params)/
----
-// src/pages/[tag]/[page].astro
-export async function getStaticPaths({paginate}) {
-  const allTags = ['rojo', 'azul', 'verde'];
-  const allPosts = await Astro.glob('../../posts/*.md');
-  // Para cada etiqueta, devuelve un resultado de paginate().
-  // Asegúrate de pasar `{params: {tag}}` a `paginate()`
-  // Así Astro sabrá qué agrupación de etiquetas usar.
-  return allTags.flatMap((tag) => {
-    const filteredPosts = allPosts.filter((post) => post.frontmatter.tag === tag);
-    return paginate(filteredPosts, {
-      params: { tag },
-      pageSize: 10
-    });
-  });
-}
-const { page } = Astro.props;
-const params = Astro.params;
-```
-
-
-## Excluyendo páginas
-
-Puedes excluir la generación de páginas o directorios añadiendo el prefijo (`_`). Los archivos con el prefijo `_` no serán reconocidos por el router y no serán generados en el directorio `dist/`.
-
-Puedes usar esto para inhabilitar páginas temporalmente y también para poner tests, utilidades y componentes en la misma carpeta junto a sus páginas correspondientes.
-
-En este ejemplo, solo `src/pages/index.astro` y `src/pages/posts/post1.md` serán generados como rutas y archivos `.html`.
-
-<FileTree>
-- src/pages/
-  - _hidden-directory/
-    - page1.md
-    - page2.md
-  - _hidden-page.astro
-  - **index.astro**
-  - posts/
-    - _SomeComponent.astro
-    - _utils.js
-    - **post1.md**
-</FileTree>
diff --git a/src/content/docs/es/guides/server-islands.mdx b/src/content/docs/es/guides/server-islands.mdx
deleted file mode 100644
index 86115a5c9d687..0000000000000
--- a/src/content/docs/es/guides/server-islands.mdx
+++ /dev/null
@@ -1,116 +0,0 @@
----
-title: Islas de Servidor
-description: Combina HTML estático de alto rendimiento con contenido dinámico renderizado en el servidor.
-i18nReady: true
----
-
-Las islas de servidor te permiten renderizar "islas" dinámicas o personalizadas bajo demanda de forma individual, sin sacrificar el rendimiento del resto de la página.
-
-Esto significa que tus visitantes verán las partes más importantes de tu página antes y permite que tu contenido principal se guarde en caché de manera más agresiva, ofreciendo así un rendimiento más rápido.
-
-## Componentes de Islas de Servidor
-
-Una isla de servidor es un [componente de Astro](/es/basics/astro-components/) al que se le indica retrasar la renderización hasta que su contenido esté disponible.
-
-Tu página se renderizará de inmediato con cualquier [contenido por defecto que hayas definido](#contenido-por-defecto-para-islas-de-servidor). Luego, el contenido real del componente se obtiene en el cliente y se muestra cuando esté disponible.
-
-Con [un adaptador instalado](/es/guides/on-demand-rendering/#adaptadores-de-servidor) para realizar la renderización diferida, agrega la [directiva `server:defer`](/es/reference/directives-reference/#directivas-del-servidor) a cualquier componente de tu página para convertirlo en su propia isla:
-
-```astro title="src/pages/index.astro" "server:defer"
----
-import Avatar from '../components/Avatar.astro';
----
-<Avatar server:defer />
-```
-
-Estos componentes pueden hacer [todo lo que normalmente harías en una página renderizada bajo demanda](/es/guides/on-demand-rendering/#funciones-de-renderizado-bajo-demanda) usando un adaptador, como obtener contenido y acceder a cookies:
-
-```astro title="src/components/Avatar.astro"
----
-import { getUserAvatar } from '../sessions';
-const userSession = Astro.cookies.get('session');
-const avatarURL = await getUserAvatar(userSession);
----
-<img alt="User avatar" src={avatarURL} />
-```
-
-## Contenido por defecto para Islas de Servidor
-
-Cuando utilices el atributo `server:defer` en un componente para retrasar su renderizado, puedes colocar contenido por defecto mediante el slot con nombre "fallback".
-
-Este contenido por defecto se renderizará inicialmente junto con el resto de la página al cargarla y será reemplazado por el contenido real de tu componente en cuanto esté disponible.
-
-Para añadir contenido por defecto, agrega `slot="fallback"` a un elemento secundario (otros componentes o elementos HTML) que le pases a tu componente de isla de servidor:
-
-```astro
----
-import Avatar from '../components/Avatar.astro';
-import GenericAvatar from '../components/GenericAvatar.astro';
----
-<Avatar server:defer>
-  <GenericAvatar slot="fallback" />
-</Avatar>
-```
-
-Este contenido por defecto puede incluir, por ejemplo:
-
-- Un avatar genérico en lugar del avatar propio del usuario.
-- Una UI de tipo placeholder, como mensajes personalizados.
-- Indicadores de carga, por ejemplo spinners.
-
-
-## Como funciona
-
-La implementación de las islas de servidor se realiza principalmente en el proceso de compilación, donde el contenido del componente se reemplaza por un script ligero.
-
-Cada una de las islas marcadas con `server:defer` se separa en su propia ruta especial, que el script recupera en tiempo de ejecución. Cuando Astro compila tu sitio, omite el componente e inyecta en su lugar un script y cualquier contenido que hayas marcado con `slot="fallback"`.
-
-Cuando la página se carga en el navegador, estos componentes se solicitan a un endpoint especial que los renderiza y devuelve el HTML. Esto significa que los usuarios verán al instante las partes más críticas de la página, mientras que el contenido por defecto estará visible brevemente antes de que se carguen las islas dinámicas.
-
-Cada isla se carga de forma independiente de las demás. Esto implica que, si alguna tarda más en cargarse, no retrasará el resto del contenido personalizado.
-
-Este patrón de renderizado fue diseñado para ser portátil, ya que no depende de ninguna infraestructura de servidor en particular. Funcionará con cualquier servicio de hosting que utilices, desde un servidor de Node.js en un contenedor de Docker hasta el proveedor serverless de tu elección.
-
-## Caché
-
-Los datos para las islas de servidor se obtienen mediante una solicitud `GET`, pasando las props como una cadena encriptada en la query de la URL. Esto permite almacenar los datos en caché con la [cabecera HTTP `Cache-Control`](https://developer.mozilla.org/es/docs/Web/HTTP/Headers/Cache-Control), utilizando directivas estándar de `Cache-Control`.
-
-Sin embargo, [el navegador limita las URLs a una longitud máxima de 2048 bytes](https://chromium.googlesource.com/chromium/src/+/master/docs/security/url_display_guidelines/url_display_guidelines.md#url-length) por razones prácticas y para evitar problemas de denegación de servicio (DoS). Si tu cadena de consulta hace que la URL supere este límite, Astro enviará en su lugar una solicitud `POST` que contiene todas las props en el cuerpo. 
-
-Las solicitudes `POST` no se almacenan en caché en los navegadores porque se utilizan para enviar datos, lo que podría causar problemas de integridad o seguridad de la información. Por lo tanto, cualquier lógica de caché existente en tu proyecto dejará de funcionar. Siempre que sea posible, pasa únicamente las props necesarias a tus islas de servidor y evita enviar objetos de datos o arreglos completos para mantener tu query lo más pequeña posible. 
-
-## Acceder a la URL de la página en una Isla de Servidor
-
-En la mayoría de los casos, tu componente de isla de servidor puede obtener información sobre la página que lo está renderizando [pasando props](/es/basics/astro-components/#props-de-componentes), igual que en los componentes normales. 
-
-No obstante, las islas de servidor se ejecutan en su propio contexto aislado, independiente de la solicitud de la página. Tanto `Astro.url` como `Astro.request.url` en un componente de isla de servidor devolverán una URL con el formato `/_server-islands/Avatar`, en lugar de la URL actual de la página en el navegador. Además, si estás pre-renderizando la página, no tendrás acceso a información como los parámetros de la query para pasarlos como props.
-
-Para acceder a la información de la URL de la página, puedes revisar la cabecera [Referer](https://developer.mozilla.org/es/docs/Web/HTTP/Headers/Referer) que contendrá la dirección de la página que está cargando la island en el navegador:
-
-```astro
----
-const referer = Astro.request.headers.get('Referer');
-const url = new URL(referer);
-const productId = url.searchParams.get('product');
----
-```
-
-## Reutilizar la clave de cifrado
-
-Astro utiliza [criptografía](https://developer.mozilla.org/es/docs/Glossary/Cryptography) para cifrar las props que se pasan a las islas de servidor, evitando así la filtración accidental de secretos. Estas props se cifran usando una clave que se genera durante el proceso de compilación.
-
-En la mayoría de los proveedores de hosting, esto sucede de manera transparente y no necesitas hacer nada como desarrollador. Sin embargo, si estás usando rolling deployments en un entorno como Kubernetes, podrías tener problemas cuando el frontend y el backend estén temporalmente fuera de sincronización y las claves no coincidan.
-
-Para resolverlo, puedes crear una clave con la CLI de Astro y reutilizarla en todos tus despliegues. Esto garantiza que el frontend de cada usuario se comunique con un backend que tenga la clave correcta.
-
-Genera una clave usando `astro create-key`:
-
-```shell
-astro create-key
-```
-
-Esto creará una clave que puedes configurar como la variable de entorno ASTRO_KEY donde tu entorno de hosting lo requiera, por ejemplo, en un archivo .env:
-
-```ini title=".env"
-ASTRO_KEY=zyM5c0qec+1Sgi4K+AejFX9ufbig7/7wIZjxOjti9Po=
-```
diff --git a/src/content/docs/es/guides/syntax-highlighting.mdx b/src/content/docs/es/guides/syntax-highlighting.mdx
index 5313669fefda2..342895334054c 100644
--- a/src/content/docs/es/guides/syntax-highlighting.mdx
+++ b/src/content/docs/es/guides/syntax-highlighting.mdx
@@ -119,7 +119,7 @@ Los bloques de código en Astro están estilizados con la clase `.astro-code`, p
 
 Hay dos componentes de Astro disponibles para archivos `.astro` y `.mdx` que permiten renderizar bloques de código: [`<Code />`](#code-) y [`<Prism />`](#prism-).
 
-Puedes consultar las `Props` de estos componentes utilizando la utilidad de [tipo `ComponentProps`](/es/guides/typescript/#tipo-componentprops).
+Puedes consultar las `Props` de estos componentes utilizando la utilidad de [tipo `ComponentProps`](/es/guides/typescript/#componentprops-type).
 
 ### `<Code />`
 
diff --git a/src/content/docs/es/guides/testing.mdx b/src/content/docs/es/guides/testing.mdx
deleted file mode 100644
index b4078573030c0..0000000000000
--- a/src/content/docs/es/guides/testing.mdx
+++ /dev/null
@@ -1,355 +0,0 @@
----
-title: Testing
-description: Introducción al testing en Astro
-i18nReady: true
----
-import PackageManagerTabs from '~/components/tabs/PackageManagerTabs.astro'
-
-
-El testing te ayuda a escribir y mantener funcionando código de Astro. Astro soporta muchas herramientas populares para testing unitario, testing de componentes y testing end-to-end incluyendo Jest, Mocha, Jasmine, [Cypress](https://cypress.io) y [Playwright](https://playwright.dev). Puedes incluso instalar librerías de testing específicas para frameworks como React Testing Library para testear tus componentes de UI.
-
-Los frameworks de testing te permiten declarar **assertions** o **expectations** sobre cómo debería comportarse el código en situaciones específicas, y luego comparar estos con el comportamiento actual de tu código.
-
-## Vitest
-
-Es un framework de testing unitario nativo de Vite con soporte a ESM, TypeScript y JSX powered by esbuild.
-
-Utiliza el helper `getViteConfig()` de Astro en tu archivo de configuración [`vitest.config.ts`](https://vitest.dev/config/) para configurar Vitest con la configuración de tu proyecto de Astro:
-
-```js
-// vitest.config.ts
-import { getViteConfig } from 'astro/config';
-
-export default getViteConfig({
-  test: {
-    // Opciones de configuración de Vitest
-  },
-});
-```
-
-Mira [la plantilla de inicio Astro + Vitest](https://github.com/withastro/astro/tree/latest/examples/with-vitest) en GitHub.
-
-## Cypress
-
-Cypress es una herramienta front-end de testing hecha para la web moderna. Cypress te permite escribir tests end-to-end para tu sitio de Astro.
-
-### Instalación
-
-Puedes instalar Cypress utilizando el gestor de paquetes de tu elección.
-
-<PackageManagerTabs>
-  <Fragment slot="npm">
-  ```shell
-  npm install -D cypress
-  ```
-
-  Esto instalará Cypress localmente como una dependencia de desarrollo para tu proyecto.
-  </Fragment>
-  <Fragment slot="pnpm">
-  ```shell
-  pnpm add cypress --save-dev
-  ```
-  </Fragment>
-  <Fragment slot="yarn">
-  ```shell
-  yarn add cypress --dev
-  ```
-  </Fragment>
-</PackageManagerTabs>
-
-### Configuración
-
-En la raíz de tu proyecto, crea un archivo `cypress.config.js` con el siguiente contenido:
-
-```js title="cypress.config.js"
-import { defineConfig } from 'cypress'
-export default defineConfig({
-  e2e: {
-    supportFile: false
-  }
-})
-```
-
-### Crea tu primer test de Cypress
-
-1. Escoge una página para testear. Este ejemplo analizará la página de ejemplo `index.astro` de abajo.
-
-    ```html title="src/pages/index.astro"
-    ---
-    ---
-    <html lang="en">
-      <head>
-        <title>¡Astro es increíble!</title>
-        <meta name="description" content="Trae contenido desde donde quieras y sírvelo rápidamente con la moderna arquitectura de islas de Astro." />
-      </head>
-      <body>
-      <h1>Hola mundo desde Astro</h1>
-      </body>
-    </html>
-    ```
-
-2. Crea un archivo `index.cy.js` en la carpeta `cypress/e2e`. Usa el siguiente test en el archivo para verificar que el título de la página y el encabezado son correctos.
-
-    ```js title="cypress/e2e/index.cy.ts"
-    it('los titulos son correctos', () => {
-      const page = cy.visit('http://localhost:4321');
-
-      page.get('title').should('have.text', '¡Astro es increíble!')
-      page.get('h1').should('have.text', 'Hola mundo desde Astro');
-    });
-    ```
-
-    :::tip[Establecer una `baseUrl`]
-    Puedes establecer [`"baseUrl": "http://localhost:4321"`](https://docs.cypress.io/guides/end-to-end-testing/testing-your-app#Step-3-Configure-Cypress) en el archivo de configuración `cypress.config.ts` para usar `cy.visit("/")` en lugar de `cy.visit("http://localhost:4321/")` para una URL más conveniente.
-    :::
-
-### Ejecutando tus tests de Cypress
-
-Cypress se puede ejecutar desde la línea de comandos o desde la App de Cypress. La App proporciona una interfaz visual para ejecutar y depurar tus tests.
-
-Primero, inicia el servidor de desarrollo para que Cypress pueda acceder a tu sitio en vivo.
-
-Para ejecutar nuestro test del ejemplo anterior usando la línea de comandos, ejecuta el siguiente comando:
-
-```shell
-npx cypress run
-```
-
-Alternativamente, para ejecutar el test usando la App de Cypress, ejecuta el siguiente comando:
-
-```shell
-npx cypress open
-```
-
-Una vez iniciada la App de Cypress, elige **E2E Testing** y luego selecciona el navegador que se usará para ejecutar los tests.
-
-Una vez que se haya completado la ejecución del test, deberías ver marcas de verificación verdes en la salida que confirman que tu test pasó:
-
-```shell title="Output de npx cypress run"
-Running:  index.cy.ts                                                                     (1 of 1)
-✓ los titulos son correctos (107ms)
-1 passing (1s)
-```
-
-:::note[Falla el test]
-Para verificar que tu test realmente funciona, puedes cambiar la siguiente línea en el archivo `index.astro`:
-
- ```astro title="src/pages/index.astro" del={2} ins={3}
-  <body>
-    <h1>Hola mundo desde Astro</h1>
-    <h1>Hola desde Astro</h1>
-  </body>
-```
-
-Luego ejecuta el test de nuevo. Deberías ver una "x" roja en la salida que confirme que tu test falló.
-:::
-
-### Siguientes pasos
-
-Para más información sobre Cypress puedes visitar los siguientes enlaces:
-
-- [Introducción a Cypress](https://docs.cypress.io/guides/core-concepts/introduction-to-cypress)
-- [Probando tu aplicación](https://docs.cypress.io/guides/end-to-end-testing/testing-your-app)
-
-## NightwatchJS
-
-Nightwatch.js es un framework de automatización de tests con un conjunto poderoso de herramientas para escribir, ejecutar y depurar pruebas en la web con soporte integrado para todos los principales navegadores y sus equivalentes móviles, así como aplicaciones móviles nativas.
-
-### Instalación
-
-Puedes instalar NightwatchJS dentro de tu proyecto de Astro usando el gestor de paquetes de tu elección. Sigue los pasos de la CLI para elegir JavaScript/TypeScript, nombra tu carpeta de pruebas y selecciona si deseas incluir tests de componentes y pruebas en navegadores móviles.
-
-<PackageManagerTabs>
-  <Fragment slot="npm">
-  ```shell
-  npm init nightwatch@latest
-  ```
-  </Fragment>
-  <Fragment slot="pnpm">
-  ```shell
-  pnpm dlx create-nightwatch
-  ```
-  </Fragment>
-  <Fragment slot="yarn">
-  ```shell
-  yarn create nightwatch
-  ```
-  </Fragment>
-</PackageManagerTabs>
-
-### Crea tu primera prueba en Nightwatch
-
-1. Elige una página para testear. Este ejemplo testeará la página de ejemplo `index.astro` que se muestra a continuación.
-
-    ```html title="src/pages/index.astro"
-    ---
-    ---
-    <html lang="en">
-      <head>
-        <title>¡Astro es increíble!</title>
-        <meta name="description" content="Extrae contenidos de cualquier lugar y sírvelos rápidamente con la arquitectura de islas de última generación de Astro." />
-      </head>
-      <body></body>
-    </html>
-    ```
-
-2. Crea una nueva carpeta `src/test/` y agrega el siguiente archivo de test:
-
-		```js title="src/test/index.js"
-		describe('Tests de Astro con Nightwatch', function () {
-		    before(browser => browser.navigateTo('http://localhost:4321/'));
-
-		    it("Verifica que el título sea correcto", function (browser) {
-		        browser.assert.titleEquals('¡Astro es increíble!')
-		    });
-
-		    after(browser => browser.end());
-		});
-		```
-
-    :::tip[Configura un `baseUrl`]
-    Puedes configurar [`"baseURL": "http://localhost:4321"`](https://nightwatchjs.org/guide/reference/settings.html#setting-the-baseurl-property) en el archivo de configuración `nightwatch.conf.js` para utilizar `browser.navigateTo("/")` en lugar de `browser.navigateTo("http://localhost:4321/")` para una URL más conveniente.
-    :::
-
-### Ejecutando tus tests de NightwatchJS
-
-Puedes ejecutar un solo test o varios tests a la vez, probando en uno o varios navegadores. Por defecto, los resultados de tus tests se mostrarán en la terminal. Opcionalmente, puedes abrir el Reporte de Pruebas HTML para mostrar un informe completo y filtrar los resultados de los tests.
-
-Puedes ejecutar los tests con la [Extensión de Visual Studio Code para NightwatchJS](https://marketplace.visualstudio.com/items?itemName=browserstackcom.nightwatch) o siguiendo los pasos a continuación mediante la CLI:
-
-1. Para ejecutar todos los tests, ingresa el siguiente comando en la terminal. Opcionalmente, incluye el nombre del archivo para ejecutar solo el test individual:
-
-    ```sh
-    npx nightwatch test/index.js
-    ```
-
-2. Para ver el Informe de Test HTML completo, ábrelo utilizando el siguiente comando:
-
-    ```sh
-    npx nightwatch test/index.ts --open
-    ```
-
-3. Para ejecutar los tests en un navegador específico, utiliza el argumento de la CLI `--environment` o `-e`. Si no tienes el navegador relevante instalado, Nightwatch intentará configurarlo por ti utilizando [Selenium Manager](https://www.selenium.dev/blog/2022/introducing-selenium-manager/).
-    ```sh
-    npx nightwatch test/index.ts -e firefox
-    ```
-:::tip
-Ejecuta tus tests contra tu código de producción para que se asemejen más a tu sitio en vivo y desplegado.
-:::
-
-Más información sobre NightwatchJS se encuentra disponible en los siguientes enlaces:
-  - [Introducción a Nightwatch](https://nightwatchjs.org/guide/overview/what-is-nightwatch.html)
-  - [Testing con Nightwatch](https://nightwatchjs.org/guide/writing-tests/introduction.html)
-
-## Playwright
-
-Playwright es un framework de testing end-to-end para aplicaciones web modernas. Usa la API de Playwright en JavaScript o TypeScript para testear tu código de Astro en todos los motores de renderizado modernos incluyendo Chromium, Webkit y Firefox.
-
-### Instalación
-
-Puedes empezar y ejecutar tus tests usando la [Extensión de VS Code](https://playwright.dev/docs/getting-started-vscode).
-
-Alternativamente, puedes instalar Playwright dentro de tu proyecto de Astro usando el gestor de paquetes de tu elección. Sigue los pasos de la CLI para elegir JavaScript/TypeScript, el nombre de tu carpeta de tests y añadir un workflow opcional de GitHub Actions.
-
-<PackageManagerTabs>
-  <Fragment slot="npm">
-  ```shell
-  npm init playwright@latest
-  ```
-  </Fragment>
-  <Fragment slot="pnpm">
-  ```shell
-  pnpm dlx create-playwright
-  ```
-  </Fragment>
-  <Fragment slot="yarn">
-  ```shell
-  yarn create playwright
-  ```
-  </Fragment>
-</PackageManagerTabs>
-
-### Cree su primer test con Playwright
-
-1. Elige una página para testear. Este ejemplo probará la página de ejemplo `index.astro` a continuación.
-
-    ```html title="src/pages/index.astro"
-    ---
-    ---
-    <html lang="en">
-      <head>
-         <title>¡Astro es increíble!</title>
-        <meta name="description" content="Trae contenido desde donde quieras y sírvelo rápidamente con la moderna arquitectura de islas de Astro." />
-      </head>
-      <body></body>
-    </html>
-    ```
-
-2. Crea una nueva carpeta y añade el siguiente archivo de test en `src/test`. Copia y pega el siguiente test dentro del archivo para verificar que la meta información de la página es correcta. Actualiza el valor `<title>` de la página para que coincida con la página que se está testeando.
-
-    ```jsx title="src/test/index.spec.ts" "¡Astro es increíble!"
-    import { test, expect } from '@playwright/test';
-
-    test('el titulo es correcto', async ({ page }) => {
-      await page.goto("http://localhost:4321/");
-
-      await expect(page).toHaveTitle('¡Astro es increíble!');
-    });
-    ```
-
-    :::tip[Establecer una `baseUrl`]
-    Puedes establecer [`"baseURL": "http://localhost:4321"`](https://playwright.dev/docs/api/class-testoptions#test-options-base-url) en el archivo de configuración `playwright.config.ts` para usar `page.goto("/")` en lugar de `page.goto("http://localhost:4321/")` para una URL más conveniente.
-    :::
-
-### Ejecutar los tests con Playwright
-
-Puede ejecutar un solo test o varios tests a la vez, testeando en uno o en varios navegadores. Por defecto, los resultados de sus tests se muestran en la terminal. Si lo desea, puedes abrir el informe de tests HTML para visualizar un informe completo y filtrar los resultados de los tests.
-
-1. Para ejecutar el test del ejemplo anterior desde la línea de comando, utilice el comando `test`. Opcionalmente, incluya el nombre del archivo para ejecutar solo ese test.
-
-    ```sh
-    npx playwright test index.spec.ts
-    ```
-
-2. Para ver el informe completo HTML, puedes hacerlo usando el siguiente comando:
-
-    ```sh
-    npx playwright show-report
-    ```
-
-:::tip
-Ejecuta los tests con el código de producción para que se asemejen más a tu sitio activo.
-:::
-
-#### Avanzado: Lanzamiento de un servidor web de desarrollo durante los tests
-
-Puede también hacer que Playwright inicie su servidor cuando ejecute su script de testing utilizando la opción [`webServer`](https://playwright.dev/docs/test-advanced#launching-a-development-web-server-during-the-tests)  en el archivo de configuración de Playwright.
-
-Aquí un ejemplo de la configuración y los comandos necesarios cuando se utiliza npm:
-
-1. Añade un script de test en el archivo `package.json` en la raíz del proyecto, como `"test:e2e": "playwright test"`.
-
-2. En `playwright.config.ts`, añade el objeto `webServer` y actualiza el valor del comando `npm run preview`.
-
-```js title="playwright.config.ts" ins={4-9} "npm run preview"
- import { defineConfig } from '@playwright/test';
- 
- export default defineConfig({
-   webServer: {
-     command: 'npm run preview',
-     url: 'http://localhost:4321/',
-     timeout: 120 * 1000,
-     reuseExistingServer: !process.env.CI,
-   },
-   use: {
-     baseURL: 'http://localhost:4321/',
-   },
- });
-```
-
-3. Ejecuta `npm run build`, luego ejecuta `npm run test:e2e` para ejecutar los tests de Playwright.
-
-Más información sobre Playwright puedes encontrarla en los enlaces de abajo:
-
-- [Cómo empezar con Playwright](https://playwright.dev/docs/intro)
-- [Utilizar un servidor de desarrollo](https://playwright.dev/docs/test-advanced#launching-a-development-web-server-during-the-tests)
diff --git a/src/content/docs/es/guides/troubleshooting.mdx b/src/content/docs/es/guides/troubleshooting.mdx
deleted file mode 100644
index 931e87af0ef08..0000000000000
--- a/src/content/docs/es/guides/troubleshooting.mdx
+++ /dev/null
@@ -1,261 +0,0 @@
----
-title: Solución de problemas
-description: ¿Necesitas ayuda? ¿Estás atascado? Nosotros te ayudamos.
-i18nReady: true
----
-
-Astro provee muchas herramientas diferentes para ayudar a solucionar y debuggear los problemas en tu código.
-
-## Consejos y trucos
-
-### Depuración con `console.log()`
-
-`console.log()` es un método sencillo pero popular para depurar tu código de Astro. Donde escribas tu declaración `console.log()` determinará dónde se imprimirá la salida de depuración:
-
-```astro
----
-console.log('¡Hola! Soy el servidor. Esto se registra en la terminal donde se está ejecutando Astro.');
----
-<script>
-console.log('¡Hola! Soy el cliente. Esto se registra en la consola de desarrollo del navegador.');
-</script>
-```
-
-Una declaración `console.log()` en el frontmatter de Astro siempre enviará su salida a la **terminal** en la que se está ejecutando la CLI de Astro. Esto se debe a que Astro se ejecuta en el servidor y nunca en el navegador.
-
-El código que se escribe o importa dentro de una etiqueta `<script>` de Astro se ejecuta en el navegador. Cualquier declaración `console.log()` u otra salida de depuración se imprimirá en la **consola de tu navegador**.
-
-### Depurando componentes de frameworks
-
-[Componentes de framework](/es/guides/framework-components/) (como React y Svelte) son únicos: se renderizan en el lado del servidor de forma predeterminada, lo que significa que la salida de depuración de `console.log()` será visible en la terminal. Sin embargo, también pueden ser hidratados para el navegador, lo que puede hacer que tus registros de depuración también aparezcan en el navegador.
-
-Esto puede ser útil para depurar las diferencias entre la salida del SSR y los componentes hidratados en el navegador.
-
-### Componente `<Debug />` de Astro
-
-Para ayudarte a depurar tus componentes de Astro, Astro proporciona un componente incorporado `<Debug />` que renderiza cualquier valor directamente en la plantilla HTML de tu componente. Esto es útil para depuración rápida en el navegador sin tener que alternar entre tu terminal y tu navegador.
-
-```astro {2,7}
----
-import { Debug } from 'astro:components';
-const sum = (a, b) => a + b;
----
-<!-- Ejemplo: Muestra {answer: 6} en el navegador -->
-<Debug answer={sum(2, 4)} />
-```
-
-El componente Debug admite una variedad de opciones de sintaxis para una depuración aún más flexible y concisa:
-
-```astro {2,7-9}
----
-import { Debug } from 'astro:components';
-const sum = (a, b) => a + b;
-const answer = sum(2, 4);
----
-<!-- Ejemplo: Los tres ejemplos son equivalentes. -->
-<Debug answer={sum(2, 4)} />
-<Debug {{answer: sum(2, 4)}} />
-<Debug {answer} />
-```
-
-## Mensajes de error comunes
-
-Aquí veremos algunos mensajes de error comunes con los que te puedes llegar a cruzar en la terminal, su significado y qué hacer para solucionarlos. Consulta nuestra [guía de referencia de errores completa](/es/reference/error-reference/) para obtener una lista completa de los errores de Astro que puedes encontrar.
-
-### Cannot use import statement outside a module
-
-En componentes de Astro, las etiquetas `<script>` son elevadas (hoisted) y cargadas como [módulos JS](https://developer.mozilla.org/es/docs/Web/JavaScript/Guide/Modules) por defecto. Si has incluido la [directiva `is:inline`](/es/reference/directives-reference/#isinline) o cualquier otro atributo en tu tag, este comportamiento por defecto es eliminado.
-
-**Solución**: Si has añadido atributos a tu tag `script`, también debes agregar el atributo `type="module"` para poder usar declaraciones de importación.
-
-**Estado**: Comportamiento esperado de Astro.
-
-**¿No estás seguro de que este sea tu problema?**
-¡Puedes ver si alguien ya ha reportado [este error](https://github.com/withastro/astro/issues?q=is%3Aissue+is%3Aopen+Cannot+use+import+statement)!
-
-### `document` (or `window`) is not defined
-
-Este error ocurre cuando se intenta acceder a `document` o `window` en el lado del servidor.
-
-#### Causas comunes
-
-Los componentes de Astro se ejecutan en el servidor, por lo que no puedes acceder a estos objetos específicos del navegador dentro del frontmatter.
-
-Los componentes de framework se ejecutan en el servidor por defecto, por lo que este error puede ocurrir cuando se accede a `document` o `window` durante la renderización.
-
-**Solución**: Determina el código que llama a `document` o `window`. Si no estás usando `document` o `window` directamente y aún así recibes este error, revisa si algún paquete que estés importando está pensado para ejecutarse en el cliente.
-
-- Si el código está en un componente de Astro, muévelo a una etiqueta `<script>` fuera del frontmatter. Esto le dice a Astro que ejecute este código en el cliente, donde `document` y `window` están disponibles.
-
-- Si el código está en un componente de framework, intenta acceder a estos objetos después de la renderización usando métodos de ciclo de vida (por ejemplo, [`useEffect()`](https://react.dev/reference/react/useEffect) en React, [`onMounted()`](https://vuejs.org/api/composition-api-lifecycle.html#onmounted) en Vue, y [`onMount()`](https://svelte.dev/docs#run-time-svelte-onmount) en Svelte). También puedes evitar que el componente se renderice en el servidor agregando la directiva [`client:only`](/es/reference/directives-reference/#clientonly).
-
-**Estado**: Comportamiento esperado de Astro.
-
-### Expected a default export
-
-Este error puede ser lanzado cuando intentas importar o renderizar un componente inválido, o uno que no funciona de manera correcta. (Este mensaje particular ocurre por la forma en que funciona la importación de componentes de UI en Astro.)
-
-**Solución**: Intenta buscar errores en los componentes que estás intentando importar y renderizar, y asegúrate que están funcionando correctamente. Considera abrir una plantilla de inicio de Astro desde [astro.new](https://astro.new) para intentar solucionar el problema de tu componente en un entorno mas sencillo
-
-**Estado**: Comportamiento esperado de Astro.
-
-### Refused to execute inline script
-
-Es posible que veas el siguiente error en la consola del navegador:
-
-> Refused to execute inline script because it violates the following Content Security Policy directive: …
-
-Esto significa que la [política de seguridad de contenido](https://developer.mozilla.org/es/docs/Web/HTTP/CSP) (CSP) de tu sitio web no permite ejecutar etiquetas `<script>` en línea, las cuales Astro genera por defecto.
-
-**Solución:** Actualiza tu CSP para incluir `script-src: 'unsafe-inline'` para permitir que los scripts en línea se ejecuten. De forma alternativa, puedes usar integraciones de terceros tales como [`astro-shield`](https://github.com/KindSpells/astro-shield) para que generen las cabeceras CSP por ti.
-
-## Problemas comunes
-
-### Mi componente no se renderiza
-
-Primero, comprueba que has **importado el componente** en el [script del componente `.astro`](/es/basics/astro-components/#script-de-un-componente) o en el [frontmatter de `.md`](/es/guides/markdown-content/#usando-componentes-en-mdx).
-
-Luego chequea la declaración de importación:
-
-- Estás realizando la importación desde el lugar correcto? (Revisa la ruta de importación.)
-
-- Tu importación posee el mismo nombre que el del componente? (Chequea el nombre de tu componente y que [cumpla con la sintaxis de componentes `.astro`](/es/reference/astro-syntax/#diferencias-entre-astro-y-jsx).)
-
-- Has incluido la extensión en la importación? (Chequea que el archivo del cual importas contiene una extensión, ej.: `.astro`, `.md`, `.jsx`, `.vue`.)
-> Nota: la extensión no es necesaria **solo en los archivos `.js(x)` y `.ts(x)`**.
-
-### Mi componente no es interactivo
-
-Si tu componente se renderiza (ver arriba) pero no responde a la interacción del usuario, entonces puede que hayas olvidado utilizar una [directiva `client:*`](/es/reference/directives-reference/#directivas-del-cliente) para hidratar tu componente.
-
-Por defecto, un [componente de framework no es hidratado en el cliente](/es/guides/framework-components/#hidratando-componentes-interactivos). Si no se provee una directiva `client:*`, su HTML es renderizado en la página sin JavaScript.
-
-:::tip
-Los [componentes de Astro](/es/basics/astro-components/) son componentes de maquetado compuestos únicamente por HTML y sin ejecución del lado del cliente. Pero puedes utilizar una etiqueta `<script>` en el maquetado de tu componente y enviar JavaScript al navegador que será ejecutado en el ámbito global.
-:::
-
-### Cannot find package 'X'
-
-Si ves un aviso `"Cannot find package 'react'"` (o similar) cuando inicializas Astro, significa que necesitas instalar ese paquete en tu proyecto. No todos los gestores de paquetes instalarán las dependencias peer automáticamente. Si estás utilizando Node v16+ y npm, no deberías preocuparte por esta sección.
-
-React, por ejemplo, es una dependencia peer de la integración `@astrojs/react`. Esto significa que deberías instalar los paquetes oficiales de `react` y `react-dom` junto con tu integración. La integración luego utilizará esos paquetes automáticamente.
-
-```shell ins="react react-dom"
-# Ejemplo: Instala integraciones y frameworks a la vez
-npm install @astrojs/react react react-dom
-```
-Lee la [guía de integraciones de Astro](/es/guides/integrations-guide/) para instrucciones acerca de cómo agregar renderers de frameworks, herramientas de CSS y otros paquetes en Astro.
-
-### `Astro.glob()` - no matches found
-
-Cuando utilizas `Astro.glob()` para importar archivos, asegúrate de usar la sintaxis correcta de glob para que coincida con los archivos que necesitas utilizar.
-
-#### Rutas de archivos
-
-Por ejemplo, usa `../components/**/*.js` en `src/pages/index.astro` para importar ambos archivos:
-- `src/components/MiComponente.js`
-- `src/components/includes/MiOtroComponente.js`
-
-#### Valores compatibles
-
-`Astro.glob()` no es compatible con variables dinámicas ni interpolación de strings.
-
-Esto no es un bug en Astro. Esto se debe a una limitación de la [función `import.meta.glob()` de Vite](https://vite.dev/guide/features.html#glob-import) la cual solamente soporta strings estáticas.
-
-Una solución alternativa es importar un grupo de archivos que incluya todos los archivos que necesitemos utilizando `Astro.glob()` y luego filtrarlos:
-
-```astro {6-7}
----
-// src/components/destacado.astro
-const { postSlug } = Astro.props
-const rutaAMiArticuloDestacado = `src/pages/blog/${postSlug}.md`
-
-const articulos = await Astro.glob('../pages/blog/*.md');
-const miArticuloDestacado = articulos.find(articulo => articulo.file.includes(rutaAMiArticuloDestacado));
----
-
-<p>
-    ¡Mira mi artículo favorito, <a href={miArticuloDestacado.url}>{miArticuloDestacado.frontmatter.title}</a>!
-</p>
-```
-
-### Utilizando Astro con Yarn 2+ (Berry)
-
-Yarn 2+, también conocido como Berry, utiliza una técnica llamada [Plug'n'Play (PnP)](https://yarnpkg.com/features/pnp) para guardar y manipular módulos de Node, lo cual puede [causar problemas](https://github.com/withastro/astro/issues/3450) al inicializar un proyecto nuevo de Astro utilizando `create astro` o al trabajar con Astro. Una solución alternativa es configurar la [propiedad `nodeLinker`](https://yarnpkg.com/configuration/yarnrc#nodeLinker) en `.yarnrc.yml` con el valor `node-modules`:
-
-```yaml title=".yarnrc.yml"
-nodeLinker: "node-modules"
-```
-
-### Agregar dependencias a Astro en un monorepo
-
-Cuando trabajas con Astro en una configuración de monorepo, las dependencias del proyecto deben agregarse en el archivo `package.json` de cada proyecto por separado.
-
-Sin embargo, es posible que también desees utilizar Astro en la raíz del monorepo (p. ej. [los proyectos Nx recomiendan instalar las dependencias en la raíz](https://github.com/nrwl/nx/issues/3023#issuecomment-630558318)). En este caso, agrega manualmente las dependencias relacionadas con Astro (p. ej. `@astrojs/vue`, `astro-component-lib`) a la sección `vite.ssr.noExternal` de la configuración de Astro para asegurarte de que estas dependencias se instalen y se incluyan correctamente:
-
-```js
-// astro.config.mjs
-import { defineConfig } from 'astro/config'
-export default defineConfig({
-  vite: {
-    ssr: {
-      noExternal: [
-        '@astrojs/vue',
-        'astro-component-lib',
-      ]
-    }
-  }
-})
-```
-
-### Usando `<head>` en un componente
-
-En Astro, usar una etiqueta `<head>` funciona de igual manera que cualquier otra etiqueta HTML: no es movida a la parte superior de la página ni se fusiona con la etiqueta `<head>` existente. Por este motivo es que seguramente desees incluir una sola etiqueta `<head>` por página. Recomendamos escribir esta única etiqueta `<head>` y su contenido en un [componente de plantilla](/es/basics/layouts/).
-
-### An unexpected `<script>` or `<style>` is included
-
-Quizás observes que se importan las etiquetas `<script>` o `<style>` de un componente en tu código HTML incluso si dicho componente no aparece en el resultado final. Esto puede suceder, por ejemplo, cuando [componentes renderizados condicionalmente](/es/reference/astro-syntax/#html-dinamico) no son mostrados. 
-
-El proceso de construcción de Astro funciona en el gráfico de módulos: una vez que un componente se incluye en la plantilla, se procesan, optimizan y empaquetan sus etiquetas `<script>` y `<style>`, ya sea que aparezcan en el resultado final o no. Esto no se aplica a los scripts cuando se aplica la directiva `is:inline`.
-
-## Creando reproducciones mínimas
-
-Cuando estés resolviendo problemas en tu código, puede ser útil crear una **reproducción mínima** del problema que puedas compartir. Se trata de un proyecto de Astro más pequeño y simplificado que demuestra el problema que estás experimentando. Contar con una reproducción funcional en un nuevo proyecto ayuda a confirmar que se trata de un problema repetible y no causado por algo más en tu entorno personal o proyecto existente.
-
-Compartir una reproducción mínima es útil cuando solicitas ayuda en nuestros hilos de soporte y a menudo es necesario al presentar un informe de error a Astro.
-
-### Crea un StackBlitz a través de [astro.new](https://astro.new).
-
-Puedes utilizar [astro.new](https://astro.new) para crear un nuevo proyecto de Astro con un solo clic. Para reproducciones mínimas, recomendamos encarecidamente comenzar desde el ejemplo mínimo (vacío) que se ejecuta en [StackBlitz](https://stackblitz.com), con la menor cantidad de código adicional posible.
-
-StackBlitz ejecutará este proyecto de Astro en el navegador, fuera de tu entorno local. También te proporcionará un enlace compartible para que cualquier mantenedor de Astro o miembro del equipo de soporte pueda ver tu reproducción mínima fuera de su propio entorno local. Esto significa que todos están viendo el mismo proyecto, con la misma configuración y dependencias. Esto facilita que otra persona te ayude a solucionar problemas en tu código. Si el problema es reproducible, te permite verificar que el problema reside en el propio código de Astro y puedes sentirte seguro al enviar un informe de error.
-
-Ten en cuenta que no todos los problemas se pueden reproducir en StackBlitz. Por ejemplo, tu problema podría depender de un entorno o administrador de paquetes específicos, o podría involucrar la transmisión de HTML, que no está admitida en StackBlitz. En este caso, crea un nuevo proyecto de Astro mínimo (vacío) utilizando la CLI, reproduce el problema y cárgalo en un repositorio de GitHub. En lugar de compartir una URL de StackBlitz, proporciona un enlace al repositorio de GitHub de tu reproducción mínima.
-
-### Código mínimo
-
-Una vez que tu proyecto vacío esté configurado, sigue los pasos para reproducir el problema.
-
-Esto puede incluir la adición de paquetes, cambios en la configuración y la escritura de código.
-
-Solo debes agregar la cantidad mínima de código necesaria para reproducir el problema. No reproduzcas otros elementos de tu proyecto existente y elimina todo el código que no esté directamente relacionado con el problema.
-
-### Crea un issue
-
-Si puedes reproducir el problema, ¡entonces es el momento de crear un issue y presentar un informe de error!
-
-Ve al repositorio de Astro correspondiente en GitHub y abre un nuevo issue.
-
-La mayoría de los repositorios tienen una plantilla de issues que hará preguntas o requerirá información para poder presentar el informe. Es importante que sigas estas plantillas, ya que si no proporcionas la información que necesitamos, tendremos que pedírtela... ¡y nadie estará trabajando en tu issue!
-
-Incluye el enlace a tu reproducción mínima en StackBlitz (o al repositorio de GitHub, si es necesario).
-
-Comienza con una descripción del comportamiento esperado en comparación con el comportamiento actual para proporcionar contexto sobre el problema. Luego, incluye instrucciones claras y paso a paso sobre cómo replicar el problema en un proyecto de Astro.
-
-## ¿Necesitas más ayuda?
-
-Ven a conversar con nosotros en [Discord](https://astro.build/chat) y explícanos tu problema en el canal `#support`. ¡Estaremos felices de ayudarte!
-
-Visita los [Issues abiertos en Astro](https://github.com/withastro/astro/issues/) para ver si encuentras un problema conocido o para crear un reporte de bug.
-
-También puedes visitar las [Discusiones de RFC](https://github.com/withastro/rfcs/discussions/) para ver si has alcanzado una limitación conocida de Astro, y para chequear si existen propuestas relacionadas con tu caso de uso.
diff --git a/src/content/docs/es/guides/typescript.mdx b/src/content/docs/es/guides/typescript.mdx
deleted file mode 100644
index d7b76abcf28ff..0000000000000
--- a/src/content/docs/es/guides/typescript.mdx
+++ /dev/null
@@ -1,316 +0,0 @@
----
-title: TypeScript
-description: Aprende a usar TypeScript incorporado en Astro.
-i18nReady: true
----
-import Since from '~/components/Since.astro'
-import PackageManagerTabs from '~/components/tabs/PackageManagerTabs.astro'
-import ReadMore from '~/components/ReadMore.astro'
-
-Astro tiene compatibilidad integrada con [TypeScript](https://www.typescriptlang.org/). Puedes importar archivos `.ts` y `.tsx` en tu proyecto de Astro, escribir código TypeScript directamente dentro del [componente de Astro](/es/basics/astro-components/#script-de-un-componente), e incluso utilizar un archivo de configuración [`astro.config.ts`](/es/guides/configuring-astro/#archivo-de-configuración-de-astro)  si así lo deseas.
-
-Usando TypeScript, puedes prevenir errores en tiempo de ejecución al definir las formas de los objetos y componentes en tu código. Por ejemplo, si utilizas TypeScript para [tipar las props de tu componente](#props-de-componentes), obtendrás un error en tu editor si estableces una prop que tu componente no acepta.
-
-No necesitas escribir código de TypeScript en tus proyectos de Astro para obtener beneficios de este. Astro siempre trata el código de tu componente como TypeScript, y la [Extensión de Astro para VSCode](/es/editor-setup/) inferirá todo lo que pueda para proporcionar autocompletado, sugerencias, y errores en tu editor.
-
-El servidor de desarrollo de Astro no realizará ningún chequeo de tipado, pero puedes usar un [script aparte](#verificación-de-tipos) para verificar errores de tipado desde la línea de comandos.
-
-## Configuración
-
-Los *starter projects* de Astro incluyen un archivo `tsconfig.json` en tu proyecto. Incluso si no escribes código TypeScript, este archivo es importante para que herramientas como Astro y VS Code sepan cómo interpretar tu proyecto. Algunas características (como importaciones de paquetes npm) no están totalmente soportadas en el editor sin un archivo `tsconfig.json`. Si instalas Astro manualmente, asegúrate de crear este archivo por ti mismo.
-
-Tres plantillas extensibles del archivo `tsconfig.json` están incluidas con Astro: `base`, `strict` y `strictest`. La plantilla `base` habilita el soporte para características modernas de JavaScript y también es usada como base para las otras plantillas. Recomendamos usar las plantillas `strict` o `strictest` si planeas escribir TypeScript en tu proyecto. Puedes ver y comparar las tres plantillas en [astro/tsconfigs/](https://github.com/withastro/astro/blob/main/packages/astro/tsconfigs/).
-
-Para heredar una de las plantillas, usa [la opción `extends`](https://www.typescriptlang.org/tsconfig#extends):
-
-```json title="tsconfg.json"
-{
-  "extends": "astro/tsconfigs/base"
-}
-```
-
-Adicionalmente, nuestras plantillas incluyen un archivo `env.d.ts` dentro de la carpeta `src` para proveer [tipos del cliente de Vite](https://vite.dev/guide/features.html#client-types) en tu proyecto:
-
-```typescript title="env.d.ts"
-/// <reference types="astro/client" />
-```
-
-Si no estás utilizando VSCode, puedes instalar el [plugin de Astro TypeScript](https://www.npmjs.com/package/@astrojs/ts-plugin) para admitir la importación de archivos `.astro` desde archivos `.ts`  (lo cual puede ser útil para volver a exportar).
-
-<PackageManagerTabs>
-  <Fragment slot="npm">
-  ```shell
-  npm install @astrojs/ts-plugin
-  ```
-  </Fragment>
-  <Fragment slot="pnpm">
-  ```shell
-  pnpm add @astrojs/ts-plugin
-  ```
-  </Fragment>
-  <Fragment slot="yarn">
-  ```shell
-  yarn add @astrojs/ts-plugin
-  ```
-  </Fragment>
-</PackageManagerTabs>
-
-Luego, agrega lo siguiente a tu archivo `tsconfig.json`:
-
-```json title="tsconfig.json"
-  "compilerOptions": {
-    "plugins": [
-      {
-        "name": "@astrojs/ts-plugin"
-      },
-    ],
-  }
-```
-
-Para comprobar que el plugin está funcionando, crea un archivo `.ts` e importa un componente de Astro en él. No deberías tener mensajes de advertencia de tu editor.
-
-### Componentes de Frameworks
-
-Si tu proyecto utiliza [componentes de otros framework](/es/guides/framework-components/), es posible que se necesiten configuraciones adicionales dependiendo el framework utilizado. Por favor revisa la documentación de TypeScript de tu framework para más información. ([Vue](https://vuejs.org/guide/typescript/overview.html#using-vue-with-typescript), [React](https://react-typescript-cheatsheet.netlify.app/docs/basic/setup), [Preact](https://preactjs.com/guide/v10/typescript), [Solid](https://www.solidjs.com/guides/typescript))
-
-## Importación de tipos
-
-Usa importaciones y exportaciones explícitas de tipos siempre que sea posible.
-
-```js del={1} ins={2} ins="type"
-import { SomeType } from './script';
-import type { SomeType } from './script';
-```
-Esto te ayudará a evitar casos extremos en los que el empaquetador de Astro intente empaquetar incorrectamente sus tipos importados como si fueran JavaScript.
-
-Puedes configurar TypeScript para que obligue a realizar importaciones de tipos en tu archivo `tsconfig.json`. Configura [`verbatimModuleSyntax`](https://www.typescriptlang.org/tsconfig#verbatimModuleSyntax) a `true`. TypeScript verificará tus importaciones y te dirá cuando debes usar `import type`. Esta configuración está habilitada por defecto en todos nuestros presets.
-
-```json title="tsconfig.json" ins={3}
-  {
-    "compilerOptions": {
-      "verbatimModuleSyntax": true
-    }
-  }
-```
-
-## Alias de importación
-
-Astro es compatible con [alias de importación](/es/guides/imports/#alias) definidos en la configuración `tsconfig.json` o `jsconfig.json` usando `paths`.
-
-```astro title="src/pages/about/nate.astro" "@components" "@layouts"
----
-import HelloWorld from '@components/HelloWorld.astro';
-import Layout from '@layouts/Layout.astro';
----
-```
-
-```json title="tsconfig.json" {5-6}
-{
-  "compilerOptions": {
-    "baseUrl": ".",
-    "paths": {
-      "@components/*": ["src/components/*"],
-      "@layouts/*": ["src/layouts/*"]
-    }
-  }
-}
-```
-
-## Extender `window` y `globalThis`
-
-Es posible que desees agregar una propiedad al objeto global. Puedes hacer esto agregando declaraciones de nivel superior usando la palabra clave `declare` a tu archivo `env.d.ts`:
-
-```ts title="env.d.ts"
-declare const myString: string;
-declare function myFunction(): boolean;
-```
-
-Esto proporcionará tipado a `globalThis.myString` y `globalThis.myFunction`, así como a `window.myString` y `window.myFunction`.
-
-Ten en cuenta que `window` sólo está disponible en el código del lado del cliente. `globalThis` está disponible tanto en el lado del servidor como en el lado del cliente, pero su valor del lado del servidor no se compartirá con el cliente.
-
-Si sólo quieres tipar una propiedad en el objeto `window`, proporciona una interfaz `Window` en su lugar:
-
-```ts title="env.d.ts"
-interface Window {
-	myFunction(): boolean;
-}
-```
-
-## Props de componentes
-
-Astro soporta escribir los tipos de las propiedades de tus componentes usando TypeScript. Para habilitar esto, agrega una interfaz `Props` a tu componente en el frontmatter. Puedes usar una declaración `export`, pero no es necesaria. La [Extensión de Astro para VSCode](/es/editor-setup/) buscará automáticamente la interfaz `Props` y te dará soporte de TS cuando uses ese componente en otra plantilla.
-```astro title="src/components/HelloProps.astro" ins={2-5}
----
-interface Props {
-  name: string;
-  greeting?: string;
-}
-const { greeting = 'Hola', name } = Astro.props;
----
-<h2>{greeting}, {name}!</h2>
-```
-### Patrones comunes de tipos de prop
-
-- Si tu componente no recibe props ni slots, puedes utilizar `type Props = Record<string, never>`.
-- Si tu componente debe recibir children en el slot de forma predeterminada, puedes forzar esto usando `type Props = { children: any; };`.
-
-## Utilidades de Tipos
-
-<p><Since v="1.6.0" /></p>
-
-Astro tiene algunas utilidades de tipos integradas para patrones de tipos de props comunes. Estos están disponibles en la extensión `astro/types`.
-
-### Atributos HTML integrados
-
-Astro provee el tipo `HTMLAttributes` para verificar que las etiquetas estén usando atributos HTML válidos. Puedes usar estos tipos para ayudar a construir props en tus componentes.
-
-Por ejemplo, si estuvieras construyendo un componente `<Link>`, podrías hacer lo siguiente para reflejar los atributos HTML por defecto para las etiquetas `<a>` en los tipos de props de tu componente.
-
-```astro title="src/components/Link.astro" ins="HTMLAttributes" ins="HTMLAttributes<'a'>"
----
-import type { HTMLAttributes } from 'astro/types';
-// usa un `type`
-type Props = HTMLAttributes<'a'>;
-// o extiendelo con una `interface`
-interface Props extends HTMLAttributes<'a'> {
-  myProp?: boolean;
-}
-const { href, ...attrs } = Astro.props;
----
-<a href={href} {...attrs}>
-  <slot />
-</a>
-```
-
-También es posible extender las definiciones de JSX por defecto para agregar atributos no estándar, redeclarando el namespace `astroHTML.JSX` en un archivo `.d.ts`.
-
-```ts
-// src/custom-attributes.d.ts
-
-declare namespace astroHTML.JSX {
-  interface HTMLAttributes {
-    'data-count'?: number;
-    'data-label'?: string;
-  }
-
-  // Añade una propiedad personalizada de CSS al objeto de estilo.
-  interface CSSProperties {
-    '--theme-color'?: 'black' | 'white';
-  }
-}
-```
-
-:::note
-`astroHTML` es inyectado de manera global en los componentes `.astro`. Para usarlo en archivos de TypeScript, utiliza una [directiva de triple barra](https://www.typescriptlang.org/docs/handbook/triple-slash-directives.html):
-
-```ts
-/// <reference types="astro/astro-jsx" />
-
-type MyAttributes = astroHTML.JSX.ImgHTMLAttributes;
-```
-:::
-
-### Tipo `ComponentProps`
-
-<p><Since v="4.3.0" /></p>
-
-Esta exportación de tipos te permite hacer referencia a las `Props` aceptadas por otro componente, incluso si ese componente no exporta ese tipo de `Props` directamente.
-
-El siguiente ejemplo muestra el uso de la utilidad `ComponentProps` de `astro/types` para referenciar los tipos `Props` de un componente `<Button />`:
-
-```astro title="src/pages/index.astro"
----
-import type { ComponentProps } from 'astro/types';
-
-import Button from "./Button.astro";
-
-type ButtonProps = ComponentProps<typeof Button>;
----
-```
-
-### Tipo polimórfico
-
-<p><Since v="2.5.0" /></p>
-
-Astro incluye un helper para facilitar la construcción de componentes que pueden renderizarse como diferentes elementos HTML con total seguridad de tipos. Esto es útil para componentes como `<Link>` que pueden renderizarse como `<a>` o `<button>` dependiendo de las props que se le pasen.
-
-El ejemplo a continuación implementa un componente completamente tipado y polimórfico que puede representarse como cualquier elemento HTML. El tipo [`HTMLTag`](#atributos-html-integrados) se utiliza para garantizar que la propiedad `as` sea un elemento HTML válido.
-
-```astro
----
-import type { HTMLTag, Polymorphic } from 'astro/types';
-type Props<Tag extends HTMLTag> = Polymorphic<{ as: Tag }>;
-const { as: Tag, ...props } = Astro.props;
----
-<Tag {...props} />
-```
-
-### Inferir los tipos de `getStaticPaths()`
-
-<p><Since v="2.1.0" /></p>
-
-Astro incluye ayudantes para trabajar con los tipos devueltos por tu función [`getStaticPaths()`](/es/reference/api-reference/#getstaticpaths) para rutas dinámicas.
-
-Puedes obtener el tipo de [`Astro.params`](/es/reference/api-reference/#astroparams) con `InferGetStaticParamsType` y el tipo de [`Astro.props`](/es/reference/api-reference/#astroprops) con `InferGetStaticPropsType`:
-
-```astro title="src/pages/posts/[...slug].astro" {2,14-15}
----
-import type { InferGetStaticParamsType, InferGetStaticPropsType, GetStaticPaths } from 'astro';
-
-export const getStaticPaths = (async () => {
-  const posts = await getCollection('blog');
-  return posts.map((post) => {
-    return {
-      params: { slug: post.slug },
-      props: { draft: post.data.draft, title: post.data.title },
-    };
-  });
-}) satisfies GetStaticPaths;
-
-type Params = InferGetStaticParamsType<typeof getStaticPaths>;
-type Props = InferGetStaticPropsType<typeof getStaticPaths>;
-
-const { slug } = Astro.params as Params;
-//               			 ^? { slug: string; }
-const { title } = Astro.props;
-//                			^? { draft: boolean; title: string; }
----
-```
-
-## Verificación de tipos
-
-Para ver errores de tipos en tu editor, asegúrate de tener instalada la [extensión de Astro VS Code](/es/editor-setup/). Ten en cuenta que los comandos `astro start` y `astro build` transpilarán el código con esbuild, pero no ejecutarán ninguna verificación de tipos. Para evitar que tu código se compile si contiene errores de TypeScript, cambia tu script de "compilación" en `package.json` a lo siguiente:
-
-```json title="package.json" del={2} ins={3} ins="astro check &&"
-  "scripts": {
-    "build": "astro build",
-    "build": "astro check && astro build",
-  },
-```
-
-:::note
-`astro check` verifica todos los archivos incluidos en tu proyecto TypeScript. Para chequeo de tipos dentro de archivos de Svelte y Vue, puedes usar los paquetes [`svelte-check`](https://www.npmjs.com/package/svelte-check) y [`vue-tsc`](https://www.npmjs.com/package/vue-tsc) respectivamente.
-:::
-
-<ReadMore>Lee más sobre las [importaciones de archivos `.ts`](/es/guides/imports/#typescript) en Astro.</ReadMore>
-
-<ReadMore>Lee más sobre la [configuración de TypeScript](https://www.typescriptlang.org/tsconfig/).</ReadMore>
-
-## Solución de problemas
-
-### Errores usando múltiples frameworks JSX a la vez
-
-Puedes tener errores al utilizar múltiples frameworks JSX en el mismo proyecto, ya que cada framework requiere diferentes, y algunas veces, conflictivas configuraciones dentro del archivo `tsconfig.json.`
-
-**Solución**: Establece la [configuración `jsxImportSource`](https://www.typescriptlang.org/tsconfig#jsxImportSource) a `react` (por defecto), `preact` o `solid-js` dependiendo cuál sea el framework más utilizado. Luego, usa un [comentario pragma](https://www.typescriptlang.org/docs/handbook/jsx.html#configuring-jsx) dentro de cada archivo conflictivo de un framework distinto al establecido anteriormente.
-
-Para la configuración por defecto `jsxImportSource: react`, deberías hacer lo siguiente:
-
-```jsx
-// Para Preact
-/** @jsxImportSource preact */
-
-// Para Solid
-/** @jsxImportSource solid-js */
-```
diff --git a/src/content/docs/es/guides/upgrade-to/v2.mdx b/src/content/docs/es/guides/upgrade-to/v2.mdx
deleted file mode 100644
index 9dc6771f7c84e..0000000000000
--- a/src/content/docs/es/guides/upgrade-to/v2.mdx
+++ /dev/null
@@ -1,421 +0,0 @@
----
-title: Actualizando a la versión v2
-description: Como actualizar tu proyecto a la última versión de Astro.
-i18nReady: true
----
-import PackageManagerTabs from '~/components/tabs/PackageManagerTabs.astro'
-import { FileTree } from '@astrojs/starlight/components';
-
-Esta guía te ayudará a migrar de la versión Astro v1 a la Astro v2.
-
-¿Necesitas actualizar un proyecto más antiguo a la v1? Ve nuestra [guía de migración anterior](/es/guides/upgrade-to/v1/).
-
-## Actualiza Astro
-
-Actualiza la versión de tu proyecto Astro a la última versión usando el gestor de paquetes. Si estás utilizando alguna integración, también acutalizalas a la última versión.
-
-<PackageManagerTabs>
-  <Fragment slot="npm">
-  ```shell
-  # Actualiza a la versión Astro v2.x
-  npm install astro@latest
-  
-  # Ejemplo: actualiza las integraciones de React y Tailwind
-  npm install @astrojs/react@latest @astrojs/tailwind@latest
-  ```
-  </Fragment>
-  <Fragment slot="pnpm">
-  ```shell
-  # Actualiza a la versión Astro v2.x
-  pnpm add astro@latest
-
-  # Ejemplo: actualiza las integraciones de React y Tailwind
-  pnpm add @astrojs/react@latest @astrojs/tailwind@latest
-  ```
-  </Fragment>
-  <Fragment slot="yarn">
-  ```shell
-  # Actualiza a la versión Astro v2.x
-  yarn add astro@latest
-  
-  # Ejemplo: actualiza las integraciones de React y Tailwind
-  yarn add @astrojs/react@latest @astrojs/tailwind@latest
-  ```
-  </Fragment>
-</PackageManagerTabs>
-
-## Cambios importantes de Astro v2.0
-
-Astro v2.0 incluye algunos cambios importantes, así como la eliminación de algunas características previamente obsoletas. Si tu proyecto no funciona de forma esperada después de actualizarlo a la versión v2.0, consulta esta guía para obtener una descripción general de todos los cambios e instrucciones sobre cómo actualizar su base de código.
-
-Ve [el registro de cambios](https://github.com/withastro/astro/blob/main/packages/astro/CHANGELOG.md) para las notas de la versión completa.
-
-### Eliminado: Soporte para Node 14
-
-Node 14 está programado para llegar al final de su vida úitl en Abril de 2023.
-
-Astro v2.0 elimina completamente el soporte para Node 14, para que todos los usuarios de Astro puedan aprovechar las caraacterísticas más modernas de Node.
-
-#### ¿Qué debería hacer?
-
-Verifica que tanto tu entorno de desarrollo como tu entorno de producción estén usando **Node `16.12.0` o superior**.
-
-1. Verifica la versión local de Node usando:
-
-    ```sh
-    node -v
- 
-    ```
-    Si tu entorno de desarrollo necesita actualizarse, [instala Node](https://nodejs.org/es/download/).
-
-2. Verifica la propia documentación del [entorno de producción](/es/guides/deploy/) para verificar que ellos soportan Node 16.
-
-    Puedes especificar Node `16.12.0` para tu proyecto Astro en una opción de configuración del dashboard o en un archivo `.nvmrc`.
-
-
-### Reservado: `src/content/`
-
-Astro v2.0 ahora incluye la API de Colecciones para organizar tus archivos Markdown y MDX en [colecciones de contenido](/es/guides/content-collections/). Esta API reserva `src/content/` como una carpeta especial.
-
-#### ¿Qué debería hacer?
-
-Renombra la carpeta existente `src/content/` para evitar conflictos. Esta carpeta, si es que existe, ahora solo se puede usar para [colecciones de contenido](/es/guides/content-collections/).
-
-### Cambió: `Astro.site` barra lateral
-
-En la versión v1.x, Astro se aseguraba que el URL que se pasaba a `site` en `astro.config.mjs` siempre tuviera una barra lateral cuando fuese accesado usando `Astro.site`.
-
-Astro v2.0 ya no modifica el valor de `site`. `Astro.site` usará el valor exacto definido, y se debe especificar una barra lateral si se desea.
-
-#### ¿Qué debería hacer?
-
-En `astro.config.mjs`, agrega una barra lateral al URL definido en `site`.
-
-```js del={5} ins={6}
-// astro.config.mjs
-import { defineConfig } from 'astro/config';
-
-export default defineConfig({
-  site: 'https://ejemplo.com',
-  site: 'https://ejemplo.com/',
-});
-```
-
-### Cambió: `_astro/` carpeta para activos de compilación
-
-En la versión v1.x, los activos se compilaban en varias ubicaciones, incluyendo `assets/`, `chunks/`, y en la raíz de la carpeta de compilación.
-
-Astro v2.0 mueve y une la ubicación de todos los activos de compilación en una nueva carpeta `_astro/`.
-
-<FileTree>
-- dist/
-  - _astro
-    - client.9218e799.js
-    - index.df3f880e0.css
-</FileTree>
-
-Puedes controlar esta ubicación con la [nueva opción de configuración `build.assets`](/es/reference/configuration-reference/#buildassets).
-
-#### ¿Qué debería hacer?
-
-Actualiza la configuración de tu plataforma de despliegue si depende de la ubicación de estos activos.
-
-### Cambió: Configuración del plugin Markdown
-
-#### Eliminado: `extendDefaultPlugins`
-
-En la versión v1.x, Astro usaba `markdown.extendDefaultPlugins` para volver a habilitar los plugins predeterminados de Astro al agregar tus propios plugins de Markdown.
-
-Astro v2.0 elimina completamente esta opción de configuración porque ahora su comportamiento es el predeterminado.
-
-Aplicando plugins de remark y rehype en tu configuración de Markdown **ya no deshabilita los plugins predeterminados de Astro**. GitHub-Flavored Markdown y Smartypants ahora se aplican independientemente de si se configuran `remarkPlugins` o `rehypePlugins` personalizados.
-
-
-##### ¿Qué debería hacer?
-
-Elimina `extendDefaultPlugins` de tu configuración. Esto es ahora el comportamiento predeterminado de Astro en la v2.0 y puedes eliminar esta línea sin ningún reemplazo.
-
-```js del={6}
-// astro.config.mjs
-import { defineConfig } from 'astro/config';
-
-export default defineConfig({
-  markdown: {
-    extendDefaultPlugins,
-  }
-});
-```
-
-#### Agregado: `gfm` y `smartypants`
-
-En la versión v1.x, podías elegir deshabilitar ambos plugins predeterminados de Markdown de Astro (GitHub-Flavored Markdown y SmartyPants) configurando `markdown.extendDefaultPlugins: false`.
-
-Astro v2.0 remplaza `markdown.extendDefaultPlugins: false` con opciones booleanas separadas para controlar individualmente cada uno de los plugins predeterminados de Markdown de Astro. Estos están habilitados por defecto y se pueden configurar como `false` de forma independiente.
-
-##### ¿Qué debería hacer?
-
-Elimina `extendDefaultPlugins: false` y agrega las opciones para deshabilitar cada plugin individualmente en su lugar.
-
-- `markdown.gfm: false` deshabilita GitHub-Flavored Markdown
-- `markdown.smartypants: false` deshabilita SmartyPants
-
-```js del={6} ins={7-8}
-// astro.config.mjs
-import { defineConfig } from 'astro/config';
-
-export default defineConfig({
-  markdown: {
-    extendDefaultPlugins: false,
-    smartypants: false,
-    gfm: false,
-  }
-});
-```
-
-### Cambió: Configuración del plugin MDX
-
-#### Reemplazado: `extendPlugins` reemplazado por `extendMarkdownConfig`
-
-En la versión v1.x, la integración de MDX `extendPlugins` administraba cómo tus archivos MDX debían heredar tu configuración de Markdown: toda tu configuración de Markdown (`markdown`) o solo los plugins predeterminados de Astro (`default`).
-
-Astro v2.0 reemplaza el comportamiento controlado por `mdx.extendPlugins` con tres nuevas opciones configurables de forma independiente que están habilitadas por defecto:
-
-- **[`mdx.extendMarkdownConfig`](/es/guides/integrations-guide/mdx/#extendmarkdownconfig)** para heredar todas o ninguna de las opciones de configuración de Markdown
-- **`mdx.gfm`** para habilitar o deshabilitar GitHub-Flavored Markdown en MDX
-- **`mdx.smartypants`** para habilitar o deshabilitar SmartyPants en MDX
-
-##### ¿Qué debería hacer?
-
-Borra `extendPlugins: 'markdown'` de tu configuración. Este es ahora el comportamiento predeterminado.
-
-```js del={8}
-// astro.config.mjs
-import { defineConfig } from 'astro/config';
-import mdx from '@astrojs/mdx';
-
-export default defineConfig({
-  integrations: [
-    mdx({
-      extendPlugins: 'markdown',
-    }),
-  ],
-});
-```
-
-Reemplaza `extendPlugins: 'defaults'` con `extendMarkdownConfig: false` y agrega las opciones separadas para GitHub-Flavored Markdown y SmartyPants para habilitar estos plugins predeterminados individualmente en MDX.
-
-```js del={8} ins={9-11}
-// astro.config.mjs
-import { defineConfig } from 'astro/config';
-import mdx from '@astrojs/mdx';
-
-export default defineConfig({
-  integrations: [
-    mdx({
-      extendPlugins: 'defaults',
-      extendMarkdownConfig: false,
-      smartypants: true,
-      gfm: true,
-    }),
-  ],
-});
-```
-
-#### Agregado: Más opciones de configuración de MDX para que coincida con Markdown
-
-Astro v2.0 ahora te permite configurar individualmente [cada opción de configuración de Markdown disponible](/es/reference/configuration-reference/#opciones-de-markdown) (excepto `drafts`) por separado en tu configuración de integración MDX.
-
-```js
-// astro.config.mjs
-import { defineConfig } from 'astro/config';
-import mdx from '@astrojs/mdx';
-
-export default defineConfig({
-  markdown: {
-    remarkPlugins: [remarkPlugin1],
-    gfm: true,
-  },
-  integrations: [
-    mdx({
-      remarkPlugins: [remarkPlugin2],
-      gfm: false,
-    })
-  ]
-});
-```
-
-##### ¿Qué debería hacer?
-
-Revisa tu configuración de Markdown y MDX y compare tu configuración existente con las nuevas opciones disponibles.
-
-
-### Cambió: Plugin de acceso al frontmatter
-
-En la versión v1.x, los plugins de remark y rehype no tenían acceso al frontmatter del usuario. Astro fusionó el frontmatter del plugin con el frontmatter de tu archivo, sin pasar el frontmatter del archivo a tus plugins.
-
-Astro v2.0 da acceso a los plugins de remark y rehype al frontmatter del usuario a través de la inyección de frontmatter. Esto permite a los autores de plugins modificar el frontmatter existente del usuario o calcular nuevas propiedades en función de otras propiedades.
-
-
-#### ¿Qué debería hacer?
-
-Verifica cualquier plugin de remark y rehype que hayas escrito para ver si su comportamiento ha cambiado. Ten en cuenta que `data.astro.frontmatter` ahora es el frontmatter _completo_ del documento Markdown o MDX, en lugar de un objeto vacío.
-  
-### Cambió: Configuración de RSS
-
-En la versión v1.x, el paquete RSS de Astro te permitía usar `items: import.meta.glob(...)` para generar una lista de elementos de feed RSS. Ahora su uso es obsoleto y eventualmente se eliminará.
-
-Astro v2.0 introduce un wrapper `pagesGlobToRssItems()` para la propiedad `items`.
-
-
-#### ¿Qué debería hacer?
-
-Importa, luego envuelve tu función existente que contiene `import.meta.glob()` con el helper `pagesGlobToRssItems()`.
-
-```js ins={3, 8, 10}
-// src/pages/rss.xml.js
-import rss, {
-  pagesGlobToRssItems
-} from '@astrojs/rss';
-
-export async function get(context) {
-  return rss({
-    items: await pagesGlobToRssItems(
-      import.meta.glob('./blog/*.{md,mdx}'),
-    ),
-  });
-}
-```
-
-### Cambió: Soporte de IDE para Svelte
-
-Astro 2.0 requiere un archivo `svelte.config.js` en tu proyecto si estás usando [la integración `@astrojs/svelte`](/es/guides/integrations-guide/svelte/). Esto es necesario para proporcionar autocompletado de IDE.
-
-#### ¿Qué debería hacer?
-
-Agrega un archivo `svelte.config.js` en la raíz de tu proyecto:
-
-```js
-// svelte.config.js
-import { vitePreprocess } from '@astrojs/svelte';
-
-export default {
-  preprocess: vitePreprocess(),
-};
-```
-
-Para nuevos usuarios, este archivo se agregará automáticamente al ejecutar `astro add svelte`.
-
-### Eliminado: `legacy.astroFlavoredMarkdown`
-
-En la versión v1.0, Astro migró al antiguo Astro-Flavored Markdown (también conocido como Componentes en Markdown) a una característica obsoleta.
-
-Astro v2.0 elimina por completo la opción `legacy.astroFlavoredMarkdown`. La importación y el uso de componentes en archivos `.md` ya no funcionarán.
-
-#### ¿Qué debería hacer?
-
-Elimina esta flag obsoleta. Ya que no está disponible en Astro.
-
-```js del={3-5}
-// astro.config.mjs
-export default defineConfig({
-	legacy: {
-		astroFlavoredMarkdown: true,
-	},
-})
-
-```
-
-Si tu usabas esta característica en v1.x, recomendamos [usar la integración MDX](/es/guides/integrations-guide/mdx/) que te permite combinar componentes y expresiones JSX con la sintaxis de Markdown.
-
-### Eliminado: `Astro.resolve()`
-
-En la version v0.24, Astro marcó como obsoleto `Astro.resolve()` por obtener URLs resueltas a recursos que podrías querer referenciar en el navegador.
-
-Astro v2.0 elimina completamente esta opción. `Astro.resolve()` causará un error en tu código.
-
-#### ¿Qué debería hacer?
-
-Resuelve las rutas de los recursos usando `import` en su lugar. Por ejemplo:
-
-```astro
----
-// src/pages/index.astro
-import 'style.css';
-import imageUrl from './image.png';
----
-
-<img src={imageUrl} />
-```
-
-### Eliminado: `Astro.fetchContent()`
-
-En la versión v0.26, Astro marcó como obsoleto `Astro.fetchContent()` por obtener datos de tus archivos Markdown locales.
-
-Astro v2.0 elimina completamente esta opción. `Astro.fetchContent()` causará un error en tu código.
-
-#### ¿Qué debería hacer?
-
-Usa [`Astro.glob()`](/es/guides/imports/#astroglob) para obtener archivos Markdown o usa la característica [Colección de Contenido](/es/guides/content-collections/).
-
-```astro
----
-// src/pages/index.astro
-const allPosts = await Astro.glob('./posts/*.md');
----
-```
-
-### Eliminado: `Astro.canonicalURL`
-
-En la versión v1.0, Astro marcó como obsoleto `Astro.canonicalURL` por construir una URL canónica.
-
-
-Astro v2.0 elimina esta opción completamente. `Astro.canonicalURL` causará un error en tu código.
-
-#### ¿Qué debería hacer?
-
-Usa `Astro.url` para construir una URL canónica.
-
-```astro
----
-// src/pages/index.astro
-const canonicalURL = new URL(Astro.url.pathname, Astro.site);
----
-
-```
-
-### Actualizado: Vite 4
-
-Astro v2.0 actualiza de Vite 3 a [Vite 4](https://vite.dev/), lanzado en Diciembre de 2022.
-
-#### ¿Qué debería hacer?
-
-No deberías tener que hacer cambios en tu código. ¡Hemos manejado la mayoría de la actualización para ti dentro de Astro; sin embargo, algunos comportamientos sutiles de Vite aún pueden cambiar entre versiones.
-
-Refierete a la [guía oficial de migración de Vite](https://vite.dev/guide/migration.html) si tienes problemas.
-
-## Astro v2.0 Opciones Experimentales Eliminados
-
-Elimina las siguientes opciones experimentales de `astro.config.mjs`:
-
-```js del={5-9}
-// astro.config.mjs
-import { defineConfig } from 'astro/config';
-
-export default defineConfig({
-  experimental: {
-    contentCollections: true,
-    prerender: true,
-    errorOverlay: true,
-  },
-})
-```
-
-Estas características ahora están disponibles por defecto:
-
-- [Colecciones de Contenido](/es/guides/content-collections/) como una forma de administrar tus archivos Markdown y MDX con tipado.
-- [Prerenderizado individual de páginas a HTML estático](/es/guides/on-demand-rendering/) cuando se usa SSR para mejorar la velocidad y la caché.
-- Un overlay de mensajes de error rediseñado.
-
-## Problemas Identificados
-
-No hay problemas identificados actualmente.
diff --git a/src/content/docs/es/guides/upgrade-to/v3.mdx b/src/content/docs/es/guides/upgrade-to/v3.mdx
deleted file mode 100644
index 73fb1ca604626..0000000000000
--- a/src/content/docs/es/guides/upgrade-to/v3.mdx
+++ /dev/null
@@ -1,991 +0,0 @@
----
-title: Actualizar a Astro v3
-description: Cómo actualizar tu proyecto a la última versión de Astro (v3.0).
-i18nReady: true
----
-import { Steps } from '@astrojs/starlight/components';
-import PackageManagerTabs from '~/components/tabs/PackageManagerTabs.astro'
-
-Esta guía te ayudará a migrar de Astro v2 a Astro v3.
-
-¿Necesitas actualizar un proyecto más antiguo a la versión v2? Consulta nuestra [guía de migración anterior](/es/guides/upgrade-to/v2/) para obtener más información.
-
-## Actualizar Astro
-
-Actualiza la versión de Astro en tu proyecto a la última versión utilizando tu administrador de paquetes. Si estás utilizando integraciones de Astro, por favor también actualiza esas integraciones a la última versión.
-
-<PackageManagerTabs>
-  <Fragment slot="npm">
-  ```shell
-  # Actualizar a Astro v3.x
-  npm install astro@latest
-  
-  # Ejemplo: actualizar las integraciones de React y Tailwind
-  npm install @astrojs/react@latest @astrojs/tailwind@latest
-  ```
-  </Fragment>
-  <Fragment slot="pnpm">
-  ```shell
-  # Actualizar a Astro v3.x
-  pnpm add astro@latest
-
-  # Ejemplo: actualizar las integraciones de React y Tailwind
-  pnpm add @astrojs/react@latest @astrojs/tailwind@latest
-  ```
-  </Fragment>
-  <Fragment slot="yarn">
-  ```shell
-  # Actualizar a Astro v3.x
-  yarn add astro@latest
-  
-  # Ejemplo: actualizar las integraciones de React y Tailwind
-  yarn add @astrojs/react@latest @astrojs/tailwind@latest
-  ```
-  </Fragment>
-</PackageManagerTabs>
-
-:::note[¿Necesitas continuar?]
-¡Después de actualizar Astro a la última versión, es posible que no necesites realizar ningún cambio en tu proyecto en absoluto!
-
-Sin embargo, si notas errores o comportamientos inesperados, por favor revisa a continuación los cambios que se han realizado y que podrían requerir actualizaciones en tu proyecto.
-:::
-
-## Astro v3.0: Banderas Experimentales Eliminadas
-
-Elimina las siguientes banderas experimentales de `astro.config.mjs`:
-
-```js del={5-8}
-// astro.config.mjs
-import { defineConfig } from 'astro/config';
-
-export default defineConfig({
-  experimental: {
-    assets: true,
-    viewTransitions: true,
-  },
-})
-```
-
-Estas características ahora están disponibles por defecto:
-
-- View Transitions para transiciones de página animadas e islas persistentes. Consulta [cambios importantes en la API de View Transitions y consejos de actualización](#actualizar-view-transitions-a-la-versión-3) si estabas utilizando esta bandera experimental.
-- Una nueva API de servicios de imagen `astro:assets` para usar imágenes en Astro, incluyendo un nuevo componente `<Image />` y la función `getImage()`. Por favor, lee los detallados [consejos de actualización de imágenes](#actualización-de-imágenes-a-la-versión-3) **sin importar si estabas usando esta bandera experimental** para ver cómo esto podría afectar tu proyecto.
-
-¡Lee más sobre estas dos emocionantes características y más en la publicación del blog sobre la versión 3.0!
-
-## Cambios importantes en Astro v3.0
-
-Astro v3.0 incluye algunos cambios importantes, así como la eliminación de algunas características previamente deprecadas. Si tu proyecto no funciona como se esperaba después de actualizar a v3.0, consulta esta guía para obtener una visión general de todos los cambios importantes e instrucciones sobre cómo actualizar tu código base.
-
-Mira el [historial de cambios](https://github.com/withastro/astro/blob/main/packages/astro/CHANGELOG.md) para ver las notas completas de la versión.
-
-### Eliminado: Soporte para Node 16
-
-Node 16 tiene programado alcanzar su Fin de Vida en septiembre de 2023.
-
-Astro v3.0 elimina por completo el soporte para Node 16 para que todos los usuarios de Astro puedan aprovechar las características más modernas de Node.
-
-#### ¿Qué debo hacer?
-
- Asegúrate de que tanto tu entorno de desarrollo como tu entorno de implementación estén utilizando **Node `18.14.1` o una versión superior**.
-
-1. Verifica tu versión local de Node utilizando:
-
-    ```sh
-    node -v
-    ```
-
-2. Revisa la documentación de tu [entorno de despliegue](/es/guides/deploy/) para verificar que admita Node 18.
-
-    Puedes especificar Node `18.14.1` para tu proyecto de Astro ya sea en una configuración en el panel de control o en un archivo `.nvmrc`.
-
-    ```bash title=".nvmrc"
-    18.14.1
-    ```
-
-### Eliminado: Soporte para TypeScript 4
-
-En Astro v2.x, los ajustes preestablecidos de `tsconfig.json` incluyen soporte tanto para TypeScript 4.x como para 5.x.
-
-Astro v3.0 actualiza los ajustes preestablecidos de `tsconfig.json` para solo admitir TypeScript 5.x. Ahora Astro asume que estás utilizando TypeScript 5.0 (marzo de 2023) o que tu editor lo incluye (p. ej. VS Code 1.77).
-
-#### ¿Qué debo hacer?
-
-Si has instalado TypeScript localmente, actualiza al menos a la versión v5.0.
-
-```bash
-npm install typescript@latest --save-dev
-```
-
-### Eliminado: `@astrojs/image`
-
-En Astro v2.x, Astro ofrecía una integración oficial de imágenes que incluía los componentes `<Image />` y `<Picture />`.
-
-Astro v3.0 elimina por completo esta integración del código base. La nueva solución de Astro para imágenes es una API de servicios de imágenes integrada: `astro:assets`.
-
-#### ¿Qué debo hacer?
-
-Elimina la integración `@astrojs/image` de tu proyecto. Deberás no solo desinstalar la integración, sino también actualizar o eliminar cualquier declaración de importación y los componentes existentes `<Image />` y `<Picture />`. Es posible que también necesites configurar un servicio de procesamiento de imágenes preferido por defecto.
-
-Encontrarás [instrucciones completas y paso a paso para eliminar la antigua integración de imágenes](/es/guides/images/#elimina-astrojsimage) en nuestra guía de Imágenes.
-
-Migrar a `astro:assets` también traerá algunas nuevas opciones y características de imágenes que es posible que desees utilizar. ¡Por favor, consulta el [Consejo de Actualización de Imágenes v3.0](/es/guides/images/#actualizar-a-v30-desde-v2x) completo para obtener todos los detalles!
-
-```js del={3,7}
-// astro.config.mjs
-import { defineConfig } from 'astro/config';
-import image from '@astrojs/image';
-
-export default defineConfig({
-  integrations: [
-    image(),
-  ]
-})
-```
-
-### Eliminado: Componente `<Markdown />`
-
-En Astro v1.x, Astro marcó como obsoleto el componente `<Markdown />` y lo movió a un paquete externo.
-
-Astro v3.0 elimina por completo el paquete `@astrojs/markdown-component`. El componente `<Markdown />` de Astro ya no funcionará en tu proyecto.
-
-#### ¿Qué debo hacer?
-
-Elimina todas las instancias de `@astrojs/markdown-component`.
-
-```astro del={2} title="src/components/MyAstroComponent.astro"
----
-import Markdown from '@astrojs/markdown-component';
----
-```
-
-Para seguir utilizando un componente similar a `<Markdown />` en tu código, considera usar [integraciones de la comunidad](https://astro.build/integrations/) como [`astro-remote`](https://github.com/natemoo-re/astro-remote). Asegúrate de actualizar las importaciones y atributos de tu componente `<Markdown />` según sea necesario, de acuerdo con la documentación propia de la integración.
-
-De lo contrario, elimina todas las referencias a la importación del componente `<Markdown />` de Astro y el propio componente en tus archivos `.astro`. Tendrás que reescribir tu contenido directamente como HTML o [importar Markdown](/es/guides/markdown-content/#importando-markdown) desde un archivo `.md`.
-
-### Eliminado: APIs obsoletas de la versión 1.x
-
-En Astro v1.x, Astro marcó como obsoletas las opciones de configuración, así como los tipos de atributos `global` y `hoist` para script/estilos. Estos se mantuvieron para compatibilidad con versiones anteriores.
-
-Astro v3.0 elimina por completo estas API obsoletas. Ya no se pueden utilizar en tu proyecto de Astro.
-
-#### ¿Qué debo hacer?
-
-Si continúas utilizando las APIs de la versión v1.x, utiliza en su lugar las nuevas API para cada funcionalidad:
-
-- Opciones de configuración obsoletas: Consulta [la guía de migración 0.26](/es/guides/upgrade-to/v1/#new-configuration-api)
-- Tipos de atributos script/estilo obsoletos: Consulta [la guía de migración 0.26](/es/guides/upgrade-to/v1/#new-default-script-behavior)
-
-### Eliminado: Shims parciales para Web APIs en código de servidor
-
-En Astro v2.x, Astro proporcionaba shims parciales para las Web APIs como `document` o `localStorage` en el código de servidor. Estos shims a menudo eran incompletos y poco confiables.
-
-Astro v3.0 elimina por completo estos shims parciales. Las Web APIs ya no están disponibles en el código renderizado en el servidor.
-
-#### ¿Qué debo hacer?
-
-Si estás utilizando Web APIs en componentes renderizados en el servidor, deberás hacer que el uso de esas APIs sea condicional o utilizar [la directiva `client:only`](/es/reference/directives-reference/#clientonly).
-
-### Eliminado: `image` de `astro:content` en el esquema de colecciones de contenido
-
-En Astro v2.x, la API de colecciones de contenido marcó como obsoleta la exportación de `image` desde `astro:content` para su uso en los esquemas de colecciones de contenido.
-
-Astro v3.0 elimina por completo esta exportación.
-
-#### ¿Qué debo hacer?
-
-Si estás utilizando el `image()` obsoleto de `astro:content`, elimínalo ya que ya no existe. Valida las imágenes a través del [ayudante `image` del `esquema`](/es/guides/images/#actualiza-los-esquemas-de-colecciones-de-contenido) en su lugar:
-
- ```ts title="src/content/config.ts" 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(),
-    }),
-});
-```
-
-### Eliminado: Nombres de temas de Shiki pre-0.14
-
-En Astro v2.x, algunos nombres de temas de Shiki fueron cambiados, pero se mantuvieron los nombres originales para mantener la compatibilidad hacia atrás.
-
-Astro v3.0 elimina los nombres originales a favor de los nombres de temas renombrados.
-
-#### ¿Qué debo hacer?
-
-Si tu proyecto utiliza alguno de los temas a continuación, renómbralos con su nombre actualizado:
-
-- `material-darker` -> `material-theme-darker`
-- `material-default` -> `material-theme`
-- `material-lighter` -> `material-theme-lighter`
-- `material-ocean` -> `material-theme-ocean`
-- `material-palenight` -> `material-theme-palenight`
-
-### Eliminado: Características `class:list`
-
-En Astro v2.x, la directiva [`class:list`](/es/reference/directives-reference/#classlist) utilizaba una implementación personalizada inspirada en [`clsx`](https://github.com/lukeed/clsx), con algunas características adicionales como la eliminación de duplicados y el soporte para `Set`.
-
-Astro v3.0 ahora utiliza `clsx` directamente para `class:list`, lo cual no admite la eliminación de duplicados ni valores de tipo `Set`.
-
-#### ¿Qué debo hacer?
-
-Reemplaza cualquier elemento de tipo `Set` pasado a la directiva `class:list` con un simple `Array`.
-
-```astro title="src/components/MyAstroComponent.astro" del={4} ins={5}
-<Component class:list={[
-  'a',
-  'b',
-  new Set(['c', 'd'])
-  ['c', 'd']
-]} />
-```
-
-### Eliminado: pasando `class:list` como una propiedad
-
-En Astro v2.x, los [valores de `class:list`](/es/reference/directives-reference/#classlist) se enviaban a los componentes a través de [`Astro.props['class:list']`](/es/reference/api-reference/#astroprops).
-
-En Astro v3.0, los valores de `class:list` se normalizan a un string antes de ser enviados a los componentes a través de `Astro.props['class']`.
-
-#### ¿Qué debo hacer?
-
-Elimina cualquier código que espere recibir la propiedad `class:list`.
-
-```astro title="src/components/MyAstroComponent.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]}
-/>
-```
-
-### Eliminado: Transformación de kebab-case para variables CSS en camelCase
-
-En Astro v2.x, las [variables CSS](/es/guides/styling/#variables-de-css) en formato camelCase pasadas al atributo `style` eran representadas tanto en camelCase (como se escribían originalmente) como en kebab-case (mantenidas para compatibilidad hacia atrás).
-
-Astro v3.0 elimina la transformación a kebab-case para estos nombres de variables CSS en formato camelCase, y solo se representa la variable CSS camelCase original.
-
-```astro "my-value"
----
-// src/components/MyAstroComponent.astro
-const myValue = "red"
----
-<!-- entrada -->
-<div style={{ "--myValue": myValue }}></div>
-
-<!-- salida (Astro 2.x) -->
-<div style="--my-value:var(--myValue);--myValue:red"></div>
-<!-- salida (Astro 3.0) -->
-<div style="--myValue:red"></div>
-```
-
-#### ¿Qué debo hacer?
-
-Si estabas confiando en Astro para transformar kebab-case en tus estilos, actualiza tus estilos existentes a camelCase para evitar estilos faltantes. Por ejemplo:
-
-```astro del={3} ins={4} title="src/components/MyAstroComponent.astro"
-<style>
-  div {
-   color: var(--my-value);
-   color: var(--myValue);
-  }
-</style>
-```
-
-### Eliminado: Aplanamiento automático del valor de retorno de `getStaticPaths()`
-
-En Astro v2.x, el valor de retorno de [`getStaticPaths()`](/es/reference/api-reference/#getstaticpaths) se aplanaba automáticamente para permitirte devolver un arreglo de arreglos sin errores.
-
-Astro v3.0 elimina el aplanamiento automático del resultado de `getStaticPaths()`.
-
-#### ¿Qué debo hacer?
-
-Si estás devolviendo un arreglo de arreglos en lugar de un arreglo de _objetos_ (como se espera), ahora debes usar `.flatMap` y `.flat` para asegurarte de que estás devolviendo un array plano.
-
-Se proporcionará un [mensaje de error indicando que el valor de retorno de `getStaticPath()` debe ser un arreglo de objetos](/es/reference/errors/invalid-get-static-paths-entry/#qué-salió-mal) si necesitas actualizar tu código.
-
-### Movido: `astro check` ahora requiere un paquete externo
-
-En Astro v2.x, [`astro check`](/es/reference/cli-reference/#astro-check) estaba incluido en Astro por defecto, y sus dependencias estaban empaquetadas en Astro. Esto resultaba en un paquete más grande, independientemente de si usabas o no `astro check`. También evitaba que tuvieras control sobre la versión de TypeScript y el Servidor de Lenguaje de Astro que se utilizaba.
-
-Astro v3.0 mueve el comando `astro check` fuera del núcleo de Astro y ahora requiere un paquete externo `@astrojs/check`. Además, debes instalar `typescript` en tu proyecto para poder usar el comando `astro check`.
-
-#### ¿Qué debo hacer?
-
-Ejecuta el comando `astro check` después de actualizar a Astro v3.0 y sigue las indicaciones para instalar las dependencias requeridas, o bien, instala manualmente `@astrojs/check` y `typescript` en tu proyecto.
-
-### Obsoleto: `build.excludeMiddleware` y `build.split`
-
-En Astro v2.x, `build.excludeMiddleware` y `build.split` se utilizaban para cambiar la forma en que se emitían archivos específicos al usar un adaptador en modo SSR.
-
-Astro v3.0 reemplaza estas opciones de configuración de compilación con nuevas opciones de configuración [para adaptadores SSR](/es/guides/integrations-guide/#integraciones-oficiales) para realizar las mismas tareas: `edgeMiddleware` y `functionPerRoute`.
-
-#### ¿Qué debo hacer?
-
-Actualiza el archivo de configuración de Astro para usar las nuevas opciones **en la configuración del adaptador** directamente.
-
-```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
-     }),
-});
-```
-
-### Obsoleto: `markdown.drafts`
-
-En Astro v2.x, la configuración `markdown.drafts` permitía tener páginas en borrador disponibles cuando se ejecutaba el servidor de desarrollo, pero que no se construían en producción.
-
-Astro v3.0 desaconseja esta característica a favor del método de colecciones de contenido para manejar las páginas en borrador mediante filtrado manual, lo que proporciona un mayor control sobre la funcionalidad.
-
-#### ¿Qué debo hacer?
-
-Para seguir marcando algunas páginas en tu proyecto como borradores, [migra a las colecciones de contenido](/es/guides/content-collections/#migrando-desde-el-enrutamiento-basado-en-archivos) y [filtra manualmente las páginas](/es/guides/content-collections/#filtrando-consultas-de-colección) con la propiedad `draft: true` en el frontmatter en lugar de usar la configuración `markdown.drafts`.
-
-### Obsoleto: Retornando un objeto simple en los endpoints
-
-En Astro v2.x, los endpoints podían devolver un objeto simple, que se convertiría en una respuesta JSON.
-
-Astro v3.0 desecha este comportamiento en favor de devolver directamente un objeto `Response`.
-
-#### ¿Qué debo hacer?
-
-Actualiza tus endpoints para devolver directamente un objeto `Response`.
-
-```ts title="endpoint.json.ts" del={2} ins={3}
-export async function GET() {
-  return { body: { "title": "Blog de Bob" }};
-  return new Response(JSON.stringify({ "title": "Blog de Bob" }));
-}
-```
-
-Si realmente necesitas mantener el formato anterior, puedes usar el objeto `ResponseWithEncoding`, pero será obsoleto en el futuro.
-
-```ts title="endpoint.json.ts" del={2} ins={3}
-export async function GET() {
-  return { body: { "title": "Blog de Bob" } };
-  return new ResponseWithEncoding({ body: { "title": "Blog de Bob" }});
-}
-```
-
-### Cambiado por defecto: `verbatimModuleSyntax` en los ajustes preestablecidos de tsconfig.json
-
-En Astro v2.x, la configuración [`verbatimModuleSyntax`](https://www.typescriptlang.org/tsconfig#verbatimModuleSyntax) estaba desactivada de forma predeterminada, con su equivalente de TypeScript 4.x `importsNotUsedAsValues` habilitado en el ajuste preestablecido `strict`.
-
-En Astro v3.0, `verbatimModuleSyntax` está habilitado en todos los ajustes preestablecidos.
-
-#### ¿Qué debo hacer?
-
-Esta opción requiere que los tipos se importen utilizando la sintaxis `import type`.
-
-```astro title="src/components/MyAstroComponent.astro" "type"
----
-import { type CollectionEntry, getEntry } from "astro:content";
----
-```
-
-Si bien recomendamos mantenerlo activado y hacer correctamente tus importaciones de tipo con `type` (como se muestra arriba), puedes desactivarlo estableciendo `verbatimModuleSyntax: false` en tu archivo `tsconfig.json` si causa algún problema.
-
-```json title="tsconfig.json" "false"
-{
-  "compilerOptions": {
-    "verbatimModuleSyntax": false
-  }
-}
-```
-
-### Cambiado por defecto: Puerto `3000`
-
-En Astro v2.x, Astro se ejecutaba en el puerto `3000` por defecto.
-
-Astro v3.0 cambia el [puerto por defecto](/es/reference/cli-reference/#--port-number) a `4321`. 🚀
-
-#### ¿Qué debo hacer?
-
-Actualiza cualquier referencia existente a `localhost:3000`, por ejemplo en tests o en tu `README`, para reflejar el nuevo puerto `localhost:4321`.
-
-### Cambiado por defecto: import.meta.env.BASE_URL `trailingSlash`
-
-En Astro v2.x, `import.meta.env.BASE_URL` agregaba por defecto tu configuración [`base`](/es/reference/configuration-reference/#base) con una barra diagonal al final, llamada [trailingSlash](/es/reference/configuration-reference/#trailingslash). `trailingSlash: "ignore"` también agregaba una barra diagonal al final.
-
-En Astro v3.0, ya no se agrega una barra diagonal al final a `import.meta.env.BASE_URL` de forma predeterminada, ni cuando se establece `trailingSlash: "ignore"`. (El comportamiento existente de `base` en combinación con `trailingSlash: "always"` o `trailingSlash: "never"` no ha cambiado).
-
-#### ¿Qué debo hacer?
-
-Si tu configuración `base` ya tiene una barra diagonal al final, no es necesario realizar ningún cambio.
-
-Si tu configuración `base` no tiene una barra diagonal al final, agrega una si deseas preservar el comportamiento anterior por defecto (o `trailingSlash: "ignore"`):
-
-```js title="astro.config.mjs" del={4} ins={5}
-import { defineConfig } from "astro/config";
-
-export default defineConfig({
-  base: 'mi-base',
-  base: 'mi-base/',
-});
-```
-
-### Cambiado por defecto: `compressHTML`
-
-En Astro v2.x, Astro solamente comprimía tu HTML emitido cuando [`compressHTML`](/es/reference/configuration-reference/#compresshtml) se establecía explícitamente como `true`. El valor predeterminado era `false`.
-
-Astro v3.0 ahora comprime automáticamente el HTML emitido por defecto.
-
-#### ¿Qué debo hacer?
-
-Ahora puedes eliminar `compressHTML: true` de tu configuración, ya que este es el nuevo comportamiento predeterminado.
-
-```js title="astro.config.mjs" del={4}
-import { defineConfig } from "astro/config";
-
-export default defineConfig({
-  compressHTML: true
-})
-```
-
-Ahora debes establecer `compressHTML: false` para desactivar la compresión de HTML.
-
-### Cambiado por defecto: `scopedStyleStrategy`
-
-En Astro v2.x, el valor predeterminado de [`scopedStyleStrategy`](/es/reference/configuration-reference/#scopedstylestrategy) era `"where"`.
-
-Astro v3.0 introduce un nuevo valor por defecto: `"attribute"`. De manera predeterminada, los estilos ahora se aplican utilizando atributos `data-*`.
-
-#### ¿Qué debo hacer?
-
-Para mantener el [ámbito de estilo](/es/guides/styling/#estilos-locales) actual de tu proyecto, actualiza el archivo de configuración al valor predeterminado anterior:
-
-```js title="astro.config.mjs" ins={4}
-import { defineConfig } from "astro/config";
-
-export default defineConfig({
-  scopedStyleStrategy: "where"
-})
-```
-
-### Cambiado por defecto: `inlineStyleSheets`
-
-En Astro v2.x, todas las hojas de estilo del proyecto se enviaban por defecto como etiquetas de enlace. Podías elegir insertarlas siempre en etiquetas `<style>` con la opción `"always"`, o insertar en línea solo las hojas de estilo por debajo de un cierto tamaño con `"auto"`, configurando la propiedad [`build.inlineStylesheets`](/es/reference/configuration-reference/#buildinlinestylesheets). La configuración predeterminada era `"never"`.
-
-Astro v3.0 cambia el valor predeterminado de `inlineStylesheets` a `"auto"`. Las hojas de estilo con un tamaño menor que `ViteConfig.build.assetsInlineLimit` (predeterminado: 4 KB) se incluyen en línea de manera predeterminada. De lo contrario, los estilos del proyecto se envían en hojas de estilo externas.
-
-#### ¿Qué debo hacer?
-
-Si deseas mantener el comportamiento actual de tu proyecto, establece `build.inlineStylesheets` en el valor predeterminado anterior, que es `"never"`:
-
-```js title="astro.config.mjs" ins={4-6}
-import { defineConfig } from "astro/config";
-
-export default defineConfig({
-	 build: {
-    inlineStylesheets: "never"
-  }
-})
-```
-
-### Cambiado por defecto: Servicio image
-
-En Astro v2.x, Squoosh era el [servicio de procesamiento de imágenes predeterminado](/es/guides/images/#servicio-de-imágenes-por-defecto).
-
-Ahora Astro v3.0 incluye Sharp como el servicio de procesamiento de imágenes predeterminado y en su lugar se proporciona una opción de configuración para usar Squoosh.
-
-#### ¿Qué debo hacer?
-
-:::note
-Cuando uses un [administrador de paquetes estricto](https://pnpm.io/pnpm-vs-npm#npms-flat-tree) como `pnpm`, es posible que necesites instalar manualmente Sharp en tu proyecto, aunque sea una dependencia de Astro:
-
-```bash
-pnpm add sharp
-```
-:::
-
-Si prefieres seguir utilizando Squoosh para transformar tus imágenes, actualiza tu configuración con lo siguiente:
-
-```ts title="astro.config.mjs" ins={4-6}
-import { defineConfig, squooshImageService } from "astro/config";
-
-export default defineConfig({
-  image: {
-    service: squooshImageService(),
-  }
-})
-```
-
-### Cambiado: Mayúsculas en los métodos de solicitud HTTP
-
-En Astro v2.x, los [métodos de solicitud HTTP](/es/guides/endpoints/#métodos-http) se escribían utilizando nombres de funciones en minúsculas: `get`, `post`, `put`, `all` y `del`.
-
-Astro v3.0 utiliza nombres de funciones en mayúsculas, incluyendo `DELETE` en lugar de `del`.
-
-#### ¿Qué debo hacer?
-
-Cambia el nombre de todas las funciones a su equivalente en mayúsculas:
-
-- `get` a `GET`
-- `post` a `POST`
-- `put` a `PUT`
-- `all` a `ALL`
-- `del` a `DELETE`
-
-```js title="endpoint.ts" del={1} ins={2}
-export function get() {
-export function GET() {
-    return new Response(JSON.stringify({ "title": "Blog de Bob" }));
-}
-```
-
-### Cambiado: Configuración de múltiples frameworks JSX
-
-En Astro v2.x, podías utilizar [varias integraciones de frameworks JSX](/es/guides/integrations-guide/#integraciones-oficiales) (React, Solid, Preact) en el mismo proyecto sin necesidad de identificar a qué framework pertenecían los archivos.
-
-Ahora en Astro v3.0, es necesario especificar qué framework utilizar para tus archivos mediante las nuevas opciones de configuración de integración `include` y `exclude` cuando tienes instaladas múltiples integraciones de framework JSX. Esto permite que Astro admita de manera más eficiente el uso de un solo framework, así como características avanzadas como React Fast Refresh.
-
-#### ¿Qué debo hacer?
-
-Si estás utilizando múltiples frameworks JSX en el mismo proyecto, establece `include` (y opcionalmente `exclude`) en un arreglo de archivos y/o carpetas. Puedes utilizar comodines para incluir múltiples rutas de archivo.
-
-Recomendamos colocar los componentes comunes del framework en la misma carpeta (por ejemplo, `/components/react/` y `/components/solid/`) para facilitar la especificación de tus inclusiones, pero esto no es obligatorio:
-
-```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({
-  // Habilita varios frameworks para admitir todo tipo de componentes diferentes.
-  // ¡No se necesita `include` si solo estás utilizando un solo framework!
-  integrations: [
-    preact({
-      include: ['**/preact/*']
-    }),
-    react({
-      include: ['**/react/*']
-    }),
-    solid({
-      include: ['**/solid/*'],
-    }),
-  ]
-});
-```
-
-### Cambiado: `Astro.cookies.get(key)` puede retornar `undefined`
-
-En Astro v2.x, [`Astro.cookies.get(key)`](/es/reference/api-reference/#astrocookies) siempre devolvería un objeto [`AstroCookie`](/es/reference/api-reference/#astrocookie), incluso si la cookie no existiera. Para verificar su existencia, necesitabas usar `Astro.cookies.has(key)`.
-
-En Astro v3.0, `Astro.cookies.get(key)` devuelve `undefined` si la cookie no existe.
-
-#### ¿Qué debo hacer?
-
-Este cambio no romperá ningún código que verifique la existencia del objeto `Astro.cookie` antes de usar `Astro.cookies.get(key)`, pero ya no es necesario hacerlo.
-
-Puedes eliminar de manera segura cualquier código que utilice `has()` para verificar si el valor de `Astro.cookies` es `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) {
-}
-```
-
-### Cambiado: Ejecutando la CLI de Astro de manera programática.
-
-En Astro v2.x, el punto de entrada del paquete `"astro"` exportaba y ejecutaba directamente la CLI de Astro. No se recomienda ejecutar Astro de esta manera en la práctica.
-
-Astro v3.0 elimina la CLI del punto de entrada y exporta un nuevo conjunto de APIs experimentales en JavaScript, que incluyen `dev()`, `build()`, `preview()` y `sync()`.
-
-#### ¿Qué debo hacer?
-
-Para [ejecutar la CLI de Astro de manera programática](/es/reference/cli-reference/#apis-avanzadas-experimental), utiliza las nuevas APIs experimentales en JavaScript:
-
-```js
-import { dev, build } from "astro";
-
-// Inicia el servidor de desarrollo de Astro
-const devServer = await dev();
-await devServer.stop();
-
-// Construye tu proyecto de Astro
-await build();
-```
-
-### Cambiado: Rutas de exportación de puntos de entrada de la API interna de Astro
-
-En Astro v2.x, podías importar las APIs internas de Astro desde `astro/internal/*` y `astro/runtime/server/*`.
-
-Astro v3.0 elimina los dos puntos de entrada a favor del punto de entrada existente `astro/runtime/*`. Además, se ha agregado una nueva exportación `astro/compiler-runtime` para el código de runtime específico del compilador.
-
-#### ¿Qué debo hacer?
-
-Estos son puntos de entrada para la API interna de Astro y no deberían afectar tu proyecto. Pero si utilizas estos puntos de entrada, actualiza como se muestra a continuación:
-
-```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 result = await transform(source, {
-  internalURL: 'astro/runtime/server/index.js',
-  internalURL: 'astro/compiler-runtime',
-  // ...
-});
-```
-
-## Mejoras de funcionalidades
-
-### Actualización de imágenes a la versión 3
-
-`astro:assets` ya no está detrás de una bandera experimental en Astro v3.0.
-
-`<Image />` ahora es un componente incorporado y la integración anterior `@astrojs/image` ha sido eliminada.
-
-Estos y otros cambios relacionados con el uso de imágenes en Astro pueden provocar cambios incompatibles al actualizar tu proyecto Astro desde una versión anterior.
-
-Por favor, sigue las instrucciones a continuación según corresponda para actualizar un proyecto Astro v2.x a la versión 3.0.
-
-#### Actualización desde `experimental.assets`
-
-Si previamente habías activado la bandera experimental para `astro:assets`, deberás actualizar tu proyecto para Astro v3.0, que ahora incluye las funcionalidades de assets de forma predeterminada.
-
-##### Eliminar la bandera `experimental.assets`
-
-Elimina la bandera experimental:
-
-```js title="astro.config.mjs" del={4-6}
-import { defineConfig } from 'astro/config';
-
-export default defineConfig({
-  experimental: {
-    assets: true
-  }
-});
-```
-
-Si es necesario, actualiza también tu archivo `src/env.d.ts` para reemplazar la referencia a `astro/client-image` por `astro/client`:
-
-```ts title="src/env.d.ts" del={1} ins={2}
-/// <reference types="astro/client-image" />
-/// <reference types="astro/client" />
-```
-
-Este alias de importación ya no se incluye por defecto con `astro:assets`. Si estabas usando este alias con los assets experimentales, debes convertirlos a rutas de archivo relativas o [crear tus propios alias de importación](/es/guides/imports/#alias).
-
-```astro title="src/pages/posts/post-1.astro" del={2} ins={3}
----
-import rocket from '~/assets/rocket.png';
-import rocket from '../../assets/rocket.png';
----
-```
----
-
-##### Añadir soporte básico de assets para Cloudflare, Deno, Vercel Edge y Netlify Edge
-
-Astro v3.0 permite que `astro:assets` funcione sin errores en Cloudflare, Deno, Vercel Edge y Netlify Edge, los cuales no son compatibles con la optimización de imágenes integrada de Astro mediante Squoosh y Sharp. Ten en cuenta que Astro **no realiza ninguna transformación ni procesamiento de imágenes** en estos entornos. Sin embargo, aún puedes disfrutar de otros beneficios al usar `astro:assets`, incluyendo la ausencia de desplazamiento acumulativo de diseño (CLS), el atributo `alt` obligatorio y una experiencia de creación consistente.
-
-Si anteriormente evitaste usar `astro:assets` debido a estas limitaciones, ahora puedes utilizarlos sin problemas. Puedes configurar el servicio de imágenes sin operaciones (no-op image service) para activar este comportamiento explícitamente:
-
-```js title="astro.config.mjs" ins={4-8}
-import { defineConfig } from 'astro/config';
-
-export default defineConfig({
-  image: {
-    service: {
-      entrypoint: 'astro/assets/services/noop'
-    }
-  }
-});
-```
-
-#### Decide dónde almacenar tus imágenes
-
-Consulta la guía de Imágenes para ayudarte a [decidir dónde almacenar tus imágenes](/es/guides/images/#dónde-guardar-las-imágenes). Tal vez quieras aprovechar las nuevas opciones para almacenar tus imágenes gracias a la flexibilidad adicional que ofrece `astro:assets`. Por ejemplo, ahora se pueden referenciar imágenes relativas desde el directorio `src/` de tu proyecto en Markdown, MDX y Markdoc usando la sintaxis estándar de Markdown: `![alt](src)`.
-
-#### Actualiza las etiquetas `<img>` existentes
-
-Anteriormente, importar una imagen devolvía simplemente una `string` con la ruta de la imagen. Ahora, los assets de imagen importados tienen la siguiente firma:
-
-```ts
-interface ImageMetadata {
-  src: string;
-  width: number;
-  height: number;
-  format: string;
-}
-```
-
-Debes actualizar el atributo `src` de cualquier etiqueta `<img>` existente** (incluyendo [imágenes en componentes de frameworks de interfaz de usuario](/es/guides/images/#imágenes-en-componentes-de-frameworks-ui)), y también puedes actualizar otros atributos que ahora están disponibles a partir de la imagen importada.
-
-```astro title="src/components/MyComponent.astro" ".src" ".width" ".height" del={4} ins={6}
----
-import rocket from '../images/rocket.svg';
----
-<img src={rocket} width="250" height="250" alt="A rocketship in space." />
-
-<img src={rocket.src} width={rocket.width} height={rocket.height} alt="A rocketship in space." />
-```
-
-#### Actualiza tus archivos Markdown, MDX y Markdoc
-
-Ahora se pueden referenciar imágenes relativas desde el directorio `src/` de tu proyecto en archivos Markdown, MDX y Markdoc utilizando la sintaxis estándar de Markdown: `![alt](src)`.
-
-Esto te permite mover tus imágenes del directorio `public/` al directorio `src/` de tu proyecto, donde ahora serán procesadas y optimizadas. Las imágenes que ya tengas en `public/`, así como las imágenes remotas, siguen siendo válidas, pero **no serán optimizadas** por el proceso de compilación de Astro.
-
-```md title="src/pages/posts/post-1.md" "/_astro" ".hash" "../../assets/"
-# My Markdown Page
-
-<!-- Local images now possible! -->
-![A starry night sky.](../../images/stars.png)
-
-<!-- Keep your images next to your content! -->
-![A starry night sky.](./stars.png)
-```
-
-Si necesitas más control sobre los atributos de tus imágenes, te recomendamos usar el formato de archivo `.mdx`, que te permite incluir el componente `<Image />` de Astro o una etiqueta `<img />` en JSX, además de la sintaxis estándar de Markdown. Utiliza la [integración de MDX](/es/guides/integrations-guide/mdx/) para añadir soporte para MDX en Astro.
-
-#### Elimina `@astrojs/image`
-
-Si estabas utilizando la integración de imágenes en Astro v2.x, completa los siguientes pasos:
-
-<Steps>
-1. Elimina la integración `@astrojs/image`.
-  
-    Debes [eliminar la integración](/es/guides/integrations-guide/#eliminando-una-integración) desinstalándola y luego eliminándola de tu archivo `astro.config.mjs`.
-
-    ```js del={3,7}
-    // astro.config.mjs
-    import { defineConfig } from 'astro/config';
-    import image from '@astrojs/image';
-
-    export default defineConfig({
-      integrations: [
-        image(),
-      ]
-    })
-    ```
-2. Actualiza los tipos (si es necesario).
-
-    Si habías configurado tipos especiales para `@astrojs/image` en `src/env.d.ts`, es posible que necesites volver a los tipos predeterminados de Astro si tu actualización a la versión 3 no completó este paso automáticamente.
-
-    ```ts title="src/env.d.ts" del={1} ins={2}
-		 /// <reference types="@astrojs/image/client" />
-		 /// <reference types="astro/client" />
-		```
-    De manera similar, actualiza el archivo `tsconfig.json` si es necesario:
-
-    ```json title="tsconfig.json" del={3} ins={4}
-		{
-			"compilerOptions": {
-			  "types": ["@astrojs/image/client"]
-			  "types": ["astro/client"]
-			}
-		}
-		```
-
-3. Migra cualquier componente `<Imagen />` existente.
-
-    Cambia todas las declaraciones de `import` de `@astrojs/image/components` a `astro:assets` para poder usar el nuevo componente integrado `<Image />`.
-
-    Elimina cualquier atributo del componente que no sean [propiedades de assets de imagen actualmente admitidas](/es/guides/images/#propiedades).
-
-    Por ejemplo, `aspectRatio` ya no es compatible, ya que ahora se infiere automáticamente a partir de los atributos `width` y `height`.
-
-      ```astro title="src/components/MyComponent.astro" del= {2,11} ins={3}
-      ---
-      import { Image } from '@astrojs/image/components';
-      import { Image } from 'astro:assets';
-      import localImage from '../assets/logo.png';
-      const localAlt = 'El logo de Astro';
-      ---
-
-      <Image
-        src={localImage}
-        width={300}
-        aspectRatio="16:9"
-        alt={localAlt}
-      />
-      ```
-      
-4. Elige un servicio de imágenes predeterminado.
-
-   [Sharp](https://github.com/lovell/sharp) es ahora el servicio de imágenes predeterminado utilizado para `astro:assets`. Si deseas utilizar Sharp, no se requiere ninguna configuración.
-
-    Si prefieres utilizar [Squoosh](https://github.com/GoogleChromeLabs/squoosh) para transformar tus imágenes, actualiza tu configuración con la siguiente opción `image.service`:
-
-    ```js title="astro.config.mjs" ins={4-6}
-    import { defineConfig, squooshImageService } from 'astro/config';
-
-    export default defineConfig({
-      image: {
-        service: squooshImageService(),
-      },
-    });
-    ```
-</Steps>
-
-#### Actualiza los esquemas de *Content Collections* (colecciones de contenido).
-
-Ahora puedes declarar una imagen asociada a una entrada de *content collections*, como la imagen de portada de una publicación de blog, en el *frontmatter* utilizando su ruta relativa a la carpeta actual.
-
-El nuevo asistente `image` para *content collections* te permite validar los metadatos de la imagen usando Zod. Aprende más sobre [cómo usar imágenes en content collections](/es/guides/images/#imágenes-en-colecciones-de-contenido).
-
-#### Cómo manejar las importaciones de imágenes en Astro v3.0
-
-En Astro v3.0, si necesitas conservar el comportamiento anterior de las importaciones de imágenes y requieres una representación en forma de cadena (string) de la URL de la imagen, agrega `?url` al final de la ruta de la imagen al importarla. Por ejemplo:
-
-```astro title="src/pages/blog/MyImages.astro"
----
-import Sprite from '../assets/logo.svg?url';
----
-
-<svg>
-  <use xlink:href={Sprite + '#cart'} />
-</svg>
-```
-
-Este enfoque garantiza que obtendrás la URL como una cadena de texto. Ten en cuenta que, durante el desarrollo, Astro utiliza una ruta relativa desde `src/`, pero al compilar el proyecto, genera rutas con hash como `/_astro/cat.a6737dd3.png`.
-
-Si prefieres trabajar directamente con el objeto de la imagen, puedes acceder a la propiedad `.src`. Este método es ideal para tareas como gestionar las dimensiones de la imagen para métricas de Core Web Vitals y evitar el desplazamiento acumulativo del diseño (CLS).
-
-Si estás haciendo la transición al nuevo comportamiento de importación, combinar los métodos `?url` y `.src` podría ser la mejor manera de manejar las imágenes sin inconvenientes.
-
-### Actualizar view transitions a la versión 3
-
-Las transiciones de vista ya no están detrás de una bandera experimental en Astro v3.0.
-
-Si **no** habías activado esta bandera experimental en Astro 2.x, esto no causará ningún cambio incompatible en tu proyecto. La nueva API de transiciones de vista no afecta tu código existente.
-
-Si usabas previamente las transiciones de vista experimentales, puede haber algunos cambios incompatibles al actualizar tu proyecto Astro desde una versión anterior.
-
-Sigue las instrucciones a continuación, según corresponda, para actualizar **un proyecto Astro v2.x configurado con `experimental.viewTransitions: true`** a la versión 3.0.
-
-#### Actualización desde `experimental.viewTransitions`
-
-Si habías activado anteriormente la bandera experimental para las transiciones de vista, deberás actualizar tu proyecto para Astro v3.0, que ahora permite las transiciones de vista de forma predeterminada.
-
-##### Eliminar la bandera `experimental.viewTransitions`
-
-Elimina la bandera experimental:
-
-```js title="astro.config.mjs" del={4-6}
-import { defineConfig } from 'astro/config';
-
-export default defineConfig({
-  experimental: {
-   viewTransitions: true
-  }
-});
-```
-
-##### Actualiza la fuente de importación
-
-El componente `<ViewTransitions />` se ha movido de `astro:components` a `astro:transitions`. Actualiza la fuente de importación en todas las apariciones dentro de tu proyecto.
-
-```astro title="src/layouts/BaseLayout.astro" del="astro:components" ins="astro:transitions"
----
-import { ViewTransitions } from "astro:components astro:transitions"
----
-<html lang="en">
-  <head>
-    <title>My Homepage</title>
-    <ViewTransitions />
-  </head>
-  <body>
-    <h1>Welcome to my website!</h1>
-  </body>
-</html>
-```
-
-#### Actualizar directivas `transition:animate`
-
-**Cambiado:** El valor `morph` de la directiva `transition:animate` ha sido renombrado a `initial`. Además, esta ya no es la animación por defecto. Si no se especifica ninguna directiva `transition:animate`, tus animaciones ahora serán por defecto `fade`.
-
-1. Renombra cualquier animación `morph` a `initial`.
-    ```astro title="src/components/MyComponent.astro" del="morph" ins="initial"
-    <div transition:name="name" transition:animate="morph initial" />
-    ```
-2. Para mantener cualquier animación que previamente usara `morph` por defecto, añade explícitamente `transition:animate="initial"` a esas animaciones.
-
-    ```astro title="src/components/MyComponent.astro" ins='transition:animate="initial"'
-    <div transition:name="name" transition:animate="initial" />
-    ```
-3. Puedes eliminar de manera segura cualquier animación configurada explícitamente como `fade`. Esto es ahora el comportamiento por defecto:
-
-    ```astro title="src/components/MyComponent.astro" del="transition:animate=\"fade\""
-    <div transition:name="name" transition:animate="fade" />
-    ```
-
-**Añadido:** Astro también admite un nuevo valor para `transition:animate`, llamado `none`. Este valor puede ser utilizado en el elemento `<html>` de una página para desactivar las transiciones animadas de página completa en toda la página. Esto solo anulará el **comportamiento de animación predeterminado** en elementos de la página que no tengan una directiva de animación. Aún puedes establecer animaciones en elementos individuales y estas animaciones específicas ocurrirán.
-
-4. Ahora puedes desactivar todas las transiciones predeterminadas en una página individual, animando solamente los elementos que utilicen explícitamente una directiva `transition:animate`:
-
-    ```astro ins="transition:animate=\"none\""
-    <html transition:animate="none">
-      <head></head>
-      <body>
-        <h1>¡Hola Mundo!</h1>
-      </body>
-    </html>
-    ```
-
-#### Actualizar nombres de eventos
-
-El evento `astro:load` ha sido renombrado a `astro:page-load`. Renombra todas las instancias en tu proyecto.
-
-```astro title="src/components/MyComponent.astro" del="astro:load" ins="astro:page-load"
-<script>
-document.addEventListener('astro:load astro:page-load', runSetupLogic);
-</script>
-```
-
-El evento `astro:beforeload` ha sido renombrado como `astro:after-swap`. Renombra todas las instancias en tu proyecto.
-
-```astro title="src/components/MyComponent.astro" del="astro:beforeload" ins="astro:after-swap"
-<script>
-document.addEventListener('astro:beforeload astro:after-swap', setDarkMode);
-</script>
-```
-
-## Recursos de la comunidad
-
-¿Conoces un buen recurso para Astro v3.0? ¡[Edita esta página](https://github.com/withastro/docs/edit/main/src/content/docs/es/guides/upgrade-to/v3.mdx) y agrega un enlace a continuación!
-
-## Problemas conocidos
-
-Actualmente no hay problemas conocidos.
diff --git a/src/content/docs/es/guides/upgrade-to/v4.mdx b/src/content/docs/es/guides/upgrade-to/v4.mdx
deleted file mode 100644
index 8b5a029005222..0000000000000
--- a/src/content/docs/es/guides/upgrade-to/v4.mdx
+++ /dev/null
@@ -1,387 +0,0 @@
----
-title: Actualizar a Astro v4
-description: Cómo actualizar tu proyeccto a la última versión de Astro (v4.0).
-i18nReady: true
----
-import PackageManagerTabs from '~/components/tabs/PackageManagerTabs.astro'
-
-Esta guía te ayudará a migrar de Astro v3 a Astro v4.
-
-¿Necesitas actualizar un proyecto más antiguo a la v3? Consulta nuestra [guía de migración anterior](/es/guides/upgrade-to/v3/).
-
-¿Necesitar ver la documentation de la v3? Visita este [sitio de documentación anterior (spanshot no mantenida de la v3.6)](https://docs-git-v3-docs-unmaintained-astrodotbuild.vercel.app/).
-
-## Actualizar Astro
-
-Actualiza la versión de Astro y todas las integraciones oficiales en tu proyecto a la última versión utilizando tu administrador de paquetes.
-
-<PackageManagerTabs>
-  <Fragment slot="npm">
-  ```shell
-  # Actualiza Astro y las integraciones oficiales al mismo tiempo
-  npx @astrojs/upgrade
-  ```
-  </Fragment>
-  <Fragment slot="pnpm">
-  ```shell
-  # Actualiza Astro y las integraciones oficiales al mismo tiempo
-  pnpm dlx @astrojs/upgrade
-  ```
-  </Fragment>
-  <Fragment slot="yarn">
-  ```shell
-  # Actualiza Astro y las integraciones oficiales al mismo tiempo
-  yarn dlx @astrojs/upgrade
-  ```
-  </Fragment>
-</PackageManagerTabs>
-
-También puedes [actualizar tus integraciones de Astro manualmente](/es/guides/integrations-guide/#actualización-manual) si es necesario, y puede que también necesites actualizar otras dependencias en tu proyecto.
-
-:::note[¿Necesitas continuar?]
-¡Después de actualizar Astro a la última versión, es posible que no necesites realizar ningún cambio en tu proyecto en absoluto!
-
-Sin embargo, si notas errores o comportamientos inesperados, por favor revisa a continuación los cambios que se han realizado y que podrían requerir actualizaciones en tu proyecto.
-:::
-
-Astro v4.0 incluye [cambios potencialmente importantes](#cambios-importantes), así como la [eliminación de algunas funciones obsoletas](#características-previamente-obsoletas-ahora-eliminadas).
-
-Si tu proyecto no funciona como esperabas después de actualizar a la v4.0, consulta esta guía para una visión general de todos los cambios importantes e instrucciones sobre cómo actualizar tu base de código.
-
-Consulta [el registro de cambios](https://github.com/withastro/astro/blob/main/packages/astro/CHANGELOG.md) para ver todas las notas de la versión.
-
-## Astro v4.0 Banderas Experimentales Eliminadas
-
-Elimina la bandera experimental `devOverlay` y mueve cualquier configuración `i18n` al nivel superior en `astro.config.mjs`:
-
-```js del={5-9} ins={11-14} title="astro.config.mjs"
-import { defineConfig } from 'astro/config';
-
-export default defineConfig({
-  experimental: {
-    devOverlay: true,
-    i18n: {
-      defaultLocale: "en",
-      locales: ["en", "fr", "pt-br", "es"],
-    }
-  },
-  i18n: {
-    defaultLocale: "en",
-    locales: ["en", "fr", "pt-br", "es"],
-  },
-})
-```
-
-Estas configuraciones, `i18n` y la renombrada `devToolbar`, están ahora disponibles en Astro v4.0.
-
-¡Lee más acerca de estas dos emocionantes características y más en [la entrada del blog de la v4.0](https://astro.build/blog/astro-4/)!
-
-## Actualizaciones
-
-Cualquier actualización principal a las dependencias de Astro podría ocasionar cambios que afecten a la compatibilidad en tu proyecto.
-
-### Actualizado: Vite 5.0
-
-En Astro v3.0, Vite 4 se utilizó como servidor de desarrollo y empaquetador de producción.
-
-Astro v4.0 actualiza de Vite 4 a Vite 5.
-
-#### ¿Qué debo hacer?
-
-Si estás usando plugins específicos de Vite, configuraciones, o APIs, consulta la [guía de migración de Vite](https://es.vite.dev/guide/migration) para ver los cambios importantes y actualiza tu proyecto según sea necesario. No hay cambios importantes en Astro en sí mismo.
-
-### Actualizado: dependencias unified, remark y rehype
-
-En Astro v3.x, unified v10 y sus paquetes relacionados compatibles remark/rehype se utilizaban para procesar Markdown y MDX.
-
-Astro v4.0 actualiza [unified a la v11](https://github.com/unifiedjs/unified/releases/tag/11.0.0) y los demás paquetes remark/rehype a la última versión.
-
-#### ¿Qué debo hacer?
-
-Si utilizabas paquetes personalizados de remark/rehype, actualízalos todos a la última versión utilizando tu administrador de paquetes para asegurarte de que sean compatibles con unified v11. Puedes encontrar los paquetes que estás utilizando en `astro.config.mjs`.
-
-No debería haber cambios importantes significativos si utilizas paquetes que se actualizan activamente, pero algunos paquetes pueden no ser compatibles aún con unified v11.
-Inspecciona visualmente tus páginas Markdown/MDX antes de desplegar para asegurarte que tu sitio funciones según lo previsto.
-
-## Cambios importantes
-
-Los siguientes cambios son considerados importantes en Astro. Cambios importantes pueden o no porporcionar compatibilidad temporal con versiones anteriores, y toda la documentación es actualizada para referirse solo al código actual y compatible. 
-
-Si necesitas referirte a la documentacion para un proyecto v3.x, puedes consultar esta [(sin mantenimiento) spanshot de los documentos anteriores a la publicación de la v4.0](https://docs-git-v3-docs-unmaintained-astrodotbuild.vercel.app/).
-
-### Renombrado: `entrypoint` (API de integraciones)
-
-En Astro v3.x, la propiedad de la API de integraciones `injectRoute` que especificaba el punto de entrada de la ruta se llamaba `entryPoint`.
-
-Astro v4.0 renombra esta propiedad a `entrypoint` para ser consistente con otras APIs de Astro. La propiedad `entrypoint` es obsoleta pero continuará funcionando y mostrará un aviso pidiendote que actualizes tu código.
-
-#### ¿Qué debo hacer?
-
-Si tienes integraciones que usan la API `injectRoute`, renombra la propiedad `entryPoint` a `entrypoint`. Si eres un autor de librerias que quiere soportar tanto Astro 3 como 4, puedes especificar tanto `entryPoint` como `entrypoint`, en cuyo caso no se registrará un aviso.
-
-```js ins={4} del={3}
-injectRoute({
-  pattern: '/fancy-dashboard',
-  entryPoint: '@fancy/dashboard/dashboard.astro'
-  entrypoint: '@fancy/dashboard/dashboard.astro'
-});
-```
-
-### Cambiado: Firma `app.render` en la API de integraciones
-
-En Astro v3.0, el método `app.render()` aceptaba `routeData` y `locals` como argumentos separados y opcionales.
-
-Astro v4.0 cambia la firma de `app.render()`. Estas dos propiedades están ahora disponibles en un único objeto. Tanto el objeto como estas dos propiedades siguen siendo opcionales.
-
-#### ¿Qué debo hacer?
-
-Si estás manteniendo un adaptador, la firma actual seguirá funcionando hasta la siguiente versión principal. Para migrar a esta nueva firma, pasa `routeData` y `locals` como propiedades de un objeto en lugar de como múltiples argumentos independientes.
-
-```diff lang="js"
-- app.render(request, routeData, locals)
-+ app.render(request, { routeData, locals })
-```
-
-### Cambiado: Ahora los adaptadores deben especificar las caracteristicas compatibles
-
-En Astro v3.x, los adaptadores no debían especificar las caracteristicas que admitían.
-
-Astro v4.0 requiere que los adaptadores pasen la propiedad `supportedAstroFeatures{}` para especificar una lista de las caracteristicas que soportan. Esta propiedad ya no es opcional.
-
-#### ¿Qué debo hacer?
-
-Los autores de adaptadores necesitan pasar la opción `supportedAstroFeatures{}` para especificar una lista de caracteristicas que admiten.
-
-```js title="my-adapter.mjs" ins={9-11}
-export default function createIntegration() {
-  return {
-    name: '@matthewp/my-adapter',
-    hooks: {
-      'astro:config:done': ({ setAdapter }) => {
-        setAdapter({
-          name: '@matthewp/my-adapter',
-          serverEntrypoint: '@matthewp/my-adapter/server.js',
-          supportedAstroFeatures: {
-              staticOutput: 'stable'
-          }
-        });
-      },
-    },
-  };
-}
-```
-
-### Eliminado: Propiedad `path` del lenguaje Shiki
-
-En Astro v3.x, un lenguajes de Shiki que era pasado a `markdown.shikiConfig.langs` era automáticamente convertido a un lenguaje compatible con Shikiji. Shikiji es la herramienta interna utilizada por Astro para resaltar la sintaxis.
-
-Astro v4.0 elimina el soporte a la porpiedad `path` de un lenguaje Shiki, que era confusa de configurar. Se sustituye por una importación que se puede pasar a `langs` directamente.
-
-#### ¿Qué debo hacer?
-
-El archivo de lenguaje JSON debe importarse y pasarse a la opción en su lugar.
-
-```diff lang="js"
-// astro.config.js
-+ import customLang from './custom.tmLanguage.json'
-
-export default defineConfig({
-  markdown: {
-    shikiConfig: {
-      langs: [
--       { path: '../../custom.tmLanguage.json' },
-+       customLang,
-      ],
-    },
-  },
-})
-```
-
-## Obsoleto
-
-Las siguientes caracteristicas obsoletas ya no son compatibles y no está documentadas. Por favor actualiza tu proyecto en consecuencia. 
-
-Algunas caracteristicas obsoletas pueden continuar funcionando temporalmente hasta que sean completamente eliminadas. Otras pueden no tener ningún efecto, o arrojar un error que te pida que actualizes tu código.
-
-### Obsoleto: `handleForms` para eventos `submit` de View Transitions
-
-En Astro v3.x, los proyectos que utilizaban el componente `<ViewTransitions />` debían activar la gestión de eventos `submit` para los elementos `form`. Esto se lograba mediante la inclusión de la propiedad `handleForms`.
-
-Astro v4.0 gestiona los eventos `submit` para elementos `form` por defecto cuando se utiliza `<ViewTransitions />`. La propiedad `handleForms` ha quedado obsoleta y ya no tiene ningún efecto.
-
-#### ¿Qué debo hacer?
-
-Elimina la propiedad `handleForms` de tu componente `ViewTransitions`. Ya no es necesaria.
-
-```astro title="src/pages/index.astro" del="handleForms"
----
-import { ViewTransitions } from "astro:transitions";
----
-<html>
-  <head>
-    <ViewTransitions handleForms />
-  </head>
-  <body>
-    <!-- cosas aquí -->
-  </body>
-</html>
-```
-
-Para optar por no gestionar el evento `submit`, agrega el atributo `data-astro-reload` a los elementos `form` correspondientes.
-
-```astro title="src/components/Form.astro" ins="data-astro-reload"
-<form action="/contact" data-astro-reload>
-  <!-- -->
-</form>
-```
-
-## Características previamente obsoletas ahora eliminadas
-
-Las siguientes características obsoletas han sido completamente eliminadas del código base y ya no se pueden utilizar. Algunas de estas características pueden haber seguido funcionando en tu proyecto incluso después de su eliminación. Otras pueden haber tenido silenciosamente ningún efecto.
-
-Los proyectos que ahora contengan estas funciones eliminadas no se podrán compilar, y ya no habrá ninguna documentación de apoyo que te indique que elimines estas funciones.
-
-### Eliminado: Retornar objetos simples desde endpoints
-
-En Astro v3.x, retornar objetos simples desde endpoints se marcó como obsoleto, pero se conservó su soporte para mantener la compatibilidad con Astro v2. También se proporcionó una utilidad `ResponseWithEncoding` para facilitar la migración.
-
-Astro v4.0 elimina el soporte para objetos simples y requiere que los endpoints retornen siempre un `Response`. La utilidad `ResponseWithEncoding` también fué eliminada en favor de un tipo `Response` adecuado.
-
-#### ¿Qué debo hacer?
-
-Actualiza tus endpoints para retornar un objeto `Response` directamente.
-
-```diff lang="ts"
-  export async function GET() {
--   return { body: { "title": "Blog de Bob" }};
-+   return new Response(JSON.stringify({ "title": "Blog de Bob" }));
-  }
-```
-
-Para eliminar el uso de `ResponseWithEncoding`, refactoriza tu código para usar un `ArrayBuffer` en su lugar:
-
-```diff lang="ts"
-  export async function GET() {
-    const file = await fs.readFile('./bob.png');
--   return new ResponseWithEncoding(file.toString('binary'), undefined, 'binary');
-+   return new Response(file.buffer);
-  }
-```
-
-### Eliminado: `build.split` y `build.excludeMiddleware`
-
-En Astro v3.0, las opciones de configuración de construcción `build.split` y `build.excludeMiddleware` fueron marcadas como obsoletas y reemplazadas con [opciones de configuración de adaptadores](/es/reference/adapter-reference/#características-del-adaptador) para realizar las mismas tareas.
-
-Astro v4.0 elimina por completo estas propiedades.
-
-#### ¿Qué debo hacer?
-
-Si estás utilizando las funciones obsoletas `build.split` or `build.excludeMiddleware`, debes eliminarlas ahora debido a que ya no existen.
-
-Por favor consulta la guía de migración de la v3 para [actualizar estas propiedades de middleware obsoletas](/es/guides/upgrade-to/v3/#obsoleto-buildexcludemiddleware-y-buildsplit) con la configuración de adaptadores.
-
-### Eliminado: `Astro.request.params`
-
-En Astro v3.0, la API `Astro.request.params` quedó obsoleta, pero se conservó por compatibilidad con versiones anteriores.
-
-Astro v4.0 elimina por completo esta opción.
-
-#### ¿Qué debo hacer?
-
-Actualiza todas las ocurrencias a [`Astro.params`](/es/reference/api-reference/#astroparams), que es el reemplazo admitido.
-
-```astro del={1} ins={2}
-const { id } = Astro.request.params;
-const { id } = Astro.params;
-```
-
-### Eliminado: `markdown.drafts`
-
-En Astro v3.0, el uso de `markdown.drafts` para controlar la construcción de borradores de publicaciones quedó obsoleto.
-
-Astro v4.0 elimina por completo esta opción.
-
-#### ¿Qué debo hacer?
-
-Si estás utilizando la función obsoleta `markdown.drafts`, debes eliminarla ahora debido a que ya no existe.
-
-Para seguir marcando algunas página en tu proyecto como borradores, [migra a colecciones de contenido](/es/guides/content-collections/#migrando-desde-el-enrutamiento-basado-en-archivos) y [filtra manualmente las páginas](/es/guides/content-collections/#filtrando-consultas-de-colección) con la propiedad `draft: true` en el frontmatter en su lugar.
-
-### Eliminado: `getHeaders()`
-
-En Astro v3.0 la exportación Markdown `getHeaders()` quedó obsoleta y se reemplazó por `getHeadings()`. 
-
-Astro v4.0 elimina por completo esta opción.
-
-#### ¿Qué debo hacer?
-
-Si estás usando la función obsoleta `getHeaders()`, debes eliminarla ahora debido a que esta ya no existe. Reemplaza cualquier instancia con `getHeadings()`, que es el reemplazo admitido.
-
-```js del={2} ins={3}
-const posts = await Astro.glob('../content/blog/*.mdx');
-const firstPostHeadings = posts.at(0).getHeaders();
-const firstPostHeadings = posts.at(0).getHeadings();
-```
-
-### Eliminado: Usando `rss` en `getStaticPaths()`
-
-En Astro v3.0, utilizar el helper obsoleto `rss` en `getStaticPaths()` generaría un error.
-
-Astro v4.0 elimina por completo este helper.
-
-#### ¿Qué debo hacer?
-
-Si estás usando el método no soportado para generar feeds RSS, ahora debes usar la [integración `@astrojs/rss`](/es/recipes/rss/) para una configuración RSS completa.
-
-### Eliminado: Nombres de métodos HTTP en minúsculas
-
-En Astro v3.0, el uso de minúsculas en los nombres de métodos de solicitud HTTP (`get`, `post`, `put`, `all`, `del`) quedó obsoleto.
-
-Astro v4.0 elimina completamente el soporte para los nombres en minúsculas. Todos los metodos de solicitud HTTP deben de escribirse ahora en mayúsculas.
-
-#### ¿Qué debo hacer?
-
-Si estás utilizando los nombres obsoletos en minúsculas, ahora debes sustituirlos por sus equivalentes en mayúsculas.
-
-Por favor consulta la guía de migración de la v3 [para obtener orientación sobre el uso de métodos de solicitud HTTP en mayúsculas](/es/guides/upgrade-to/v3/#cambiado-mayúsculas-en-los-métodos-de-solicitud-http).
-
-### Eliminado: Redirecciones 301 cuando falta un prefijo `base`
-
-En Astro v3.x, el servidor de vista previa de Astro devolvía una redirección 301 al acceder a los assets del directorio public sin una ruta base.
-
-Astro v4.0 retorna un estado 404 sin un prefijo de ruta base para los assets del directorio public cuando el servidor de vista previa se está ejecutando, coincidiendo con el comportamiento del servidor de desarrollo.
- 
-#### ¿Qué debo hacer?
-
-Cuando utilizes el servidor de vista previa, todas tus importaciones de assets estáticos y URLs desde el directorio public deben de tener [el valor base](/es/reference/configuration-reference/#base) como prefijo en la ruta.
-
-El siguiente ejemplo muestra el atributo `src` necesario para mostrar una imagen desde la carpeta public cuando `base: '/docs'` está configurado:
-
-```astro title="src/pages/index.astro" ins="/docs"
-// Para acceder a public/images/my-image.png:
-
-<img src="/docs/images/my-image.png" alt="">
-```
-
-### Eliminado: Auto-conversión de `astro/client-image`
-
-En Astro v3.x, se eliminó el tipo `astro/client-image` (utilizado para la integración de imágenes obsoleta), pero se convirtió automáticamente al tipo predeterminado de Astro `astro/client` si se encontraba en tu archivo `env.d.ts`.
-
-Astro v4.0 ignora `astro/client-image` y no actualizará automáticamente `env.d.ts` por ti.
-
-#### ¿Qué debo hacer?
-
-Si tenías configurados tipos para `@astrojs/image` en `src/env.d.ts` y la actualización a la v3.0 no convirtió automáticamente los tipos por ti, reemplaza manualmente el tipo `astro/client-image` con `astro/client`.
-
-```ts title="src/env.d.ts" del={1} ins={2}
-  /// <reference types="astro/client-image" />
-  /// <reference types="astro/client" />
-```
-
-## Recursos de la comunidad
-
-¿Conoces un buen recurso para Astro v4.0? ¡[Edita esta página](https://github.com/withastro/docs/edit/main/src/content/docs/en/guides/upgrade-to/v4.mdx) y agrega un enlace a continuación!
-
-## Errores conocidos
-
-Por favor consulta los [issues de Astro en GitHub](https://github.com/withastro/astro/issues/) para cualquier errore reportado o para presentar un error tú mismo.
diff --git a/src/content/docs/es/install-and-setup.mdx b/src/content/docs/es/install-and-setup.mdx
index 2a6625c76a2b0..20d8c2caaaf00 100644
--- a/src/content/docs/es/install-and-setup.mdx
+++ b/src/content/docs/es/install-and-setup.mdx
@@ -263,7 +263,7 @@ Si prefieres no utilizar nuestra herramienta automática CLI `create astro`, pue
     /// <reference types="astro/client" />
     ```
 
-    Lee nuestra [guía para configurar TypeScript](/es/guides/typescript/#configuración) para más información.
+    Lee nuestra [guía para configurar TypeScript](/es/guides/typescript/#setup) para más información.
 
 7. Siguientes pasos
 
@@ -406,7 +406,7 @@ Aquí te dejamos algunas sugerencias para explorar a continuación. Puedes leerl
   <LinkCard
     title="Alias de importación"
     description="Crea accesos directos convenientes para tus importaciones de archivos."
-    href="/es/guides/imports/#alias"
+    href="/es/guides/imports/#aliases"
   />
   <LinkCard
     title="Variables de entorno"
diff --git a/src/content/docs/es/recipes/add-yaml-support.mdx b/src/content/docs/es/recipes/add-yaml-support.mdx
deleted file mode 100644
index ea86ca212b3bf..0000000000000
--- a/src/content/docs/es/recipes/add-yaml-support.mdx
+++ /dev/null
@@ -1,64 +0,0 @@
----
-title: Instalando un plugin de Vite o Rollup
-description: Aprende como puedes importar datos en YAML añadiendo un plugin de Rollup en tu proyecto.
-i18nReady: true
-type: recipe
----
-
-import PackageManagerTabs from '~/components/tabs/PackageManagerTabs.astro'
-
-Astro esta construido sobre Vite, y soporta plugins de Vite y Rollup. Esta receta usa un plugin de Rollup para añadir la habilidad de importar un archivo YAML (`.yml`) en Astro.
-
-## Receta
-
-1. Instala `@rollup/plugin-yaml`:
-
-    <PackageManagerTabs>
-        <Fragment slot="npm">
-        ```shell
-        npm install @rollup/plugin-yaml --save-dev
-        ```
-        </Fragment>
-        <Fragment slot="pnpm">
-        ```shell
-        pnpm add @rollup/plugin-yaml --save-dev
-        ```
-        </Fragment>
-        <Fragment slot="yarn">
-        ```shell
-        yarn add @rollup/plugin-yaml --save-dev
-        ```
-        </Fragment>
-    </PackageManagerTabs>
-
-2. Importa el plugin en tu `astro.config.mjs` y añade el arreglo de plugins de Vite:
-
-    ```js title="astro.config.mjs" ins={2,5-7}
-    import { defineConfig } from 'astro/config';
-    import yaml from '@rollup/plugin-yaml';
-
-    export default defineConfig({
-      vite: {
-        plugins: [yaml()]
-      }
-    });
-    ```
-
-
-3. Por último, puedes añadir datos YAML usando una declaración `import`:
-
-    ```js
-    import yml from './data.yml';
-    ```
-
-    :::note
-    Ahora que puedes importar datos YAML en tu proyecto de Astro, tu editor no va a añadir tipos para los datos importados. Para añadir tipos, crea o encuentra un archivo existente `*.d.ts` en la carpeta `src` de tu proyecto y añade lo siguiente:
-    ```ts title="src/files.d.ts"
-    // Especifica la extensión del archivo que quieres importar
-    declare module "*.yml" {
-      const value: any; // Agrega las definiciones de tipos aquí si así lo deseas.
-      export default value;
-    }
-    ```
-    Esto va permitir a tu editor sugerir pistas para tus tipos en tus datos YAML.
-    :::
diff --git a/src/content/docs/es/recipes/build-custom-img-component.mdx b/src/content/docs/es/recipes/build-custom-img-component.mdx
deleted file mode 100644
index 50fd17555d542..0000000000000
--- a/src/content/docs/es/recipes/build-custom-img-component.mdx
+++ /dev/null
@@ -1,128 +0,0 @@
----
-title: Construye un componente de imagen personalizado
-description: Aprende a construir un componente de imagen personalizado que admita media queries utilizando la función getImage.
-i18nReady: true
-type: recipe
----
-
-Astro proporciona dos componentes integrados que puedes utilizar para mostrar y optimizar tus imágenes. El componente `<Picture>` te permite mostrar imágenes responsivas y trabajar con diferentes formatos y tamaños. El componente `<Image>` optimizará tus imágenes y te permitirá pasar diferentes formatos y propiedades de calidad.
-
-Cuando necesitas opciones que los componentes `<Picture>` y `<Image>` no admiten actualmente, puedes utilizar la función `getImage()` para crear un componente personalizado.
-
-En esta receta, usarás la [función `getImage()`](/es/guides/images/#generando-imágenes-con-getimage) para crear tu propio componente de imagen personalizado que muestra diferentes imágenes de origen según los media queries.
-
-## Receta
-
-1. Crea un nuevo componente de Astro e importa la función `getImage()`.
-
-    ```astro title="src/components/MyCustomImageComponent.astro" 
-    ---
-     import { getImage } from "astro:assets";
-    ---
-
-    ```
-
-2. Crea un nuevo componente para tu imagen personalizada. `MyCustomComponent.astro` recibirá tres `props` de `Astro.props`. Las props `mobileImgUrl` y `desktopImgUrl` se utilizan para crear tu imagen en diferentes tamaños de pantalla. La prop `alt` se utiliza para el texto alternativo de la imagen. Estas props se pasarán siempre que renderices tus componentes de imagen personalizados. Añade las siguientes importaciones y define las props que utilizarás en tu componente. También puedes utilizar TypeScript para tipar las props.
-
-    ```astro title="src/components/MyCustomImageComponent.astro" ins={3, 11}
-    ---
-    import type { ImageMetadata } from "astro";
-    import { getImage } from "astro:assets";
-
-    interface Props {
-        mobileImgUrl: string | ImageMetadata;
-        desktopImgUrl: string | ImageMetadata;
-        alt: string;
-    }
-
-    const { mobileImgUrl, desktopImgUrl, alt } = Astro.props;
-    ---
-
-    ```
-
-3. Define cada una de tus imágenes responsivas llamando a la función `getImage()` con las propiedades deseadas.
-
-    ```astro title="src/components/MyCustomImageComponent.astro" ins={13-18, 20-25}
-    ---
-    import type { ImageMetadata } from "astro";
-    import { getImage } from "astro:assets";
-
-    interface Props {
-        mobileImgUrl: string | ImageMetadata;
-        desktopImgUrl: string | ImageMetadata;
-        alt: string;
-    }
-
-    const { mobileImgUrl, desktopImgUrl, alt } = Astro.props;
-
-    const mobileImg = await getImage({
-        src: mobileImgUrl,
-        format: "webp",
-        width: 200,
-        height: 200,
-    });
-
-    const desktopImg = await getImage({
-        src: desktopImgUrl,
-        format: "webp",
-        width: 800,
-        height: 200,
-    });
-    ---
-
-    ```
-
-4. Crea un elemento `<picture>` que genere un conjunto `srcset` con tus diferentes imágenes basado en los media queries deseadas.
-
-    ```astro title="src/components/MyCustomImageComponent.astro" ins={28-32}
-    ---
-    import type { ImageMetadata } from "astro";
-    import { getImage } from "astro:assets";
-
-    interface Props {
-        mobileImgUrl: string | ImageMetadata;
-        desktopImgUrl: string | ImageMetadata;
-        alt: string;
-    }
-
-    const { mobileImgUrl, desktopImgUrl, alt } = Astro.props;
-
-    const mobileImg = await getImage({
-        src: mobileImgUrl,
-        format: "webp",
-        width: 200,
-        height: 200,
-    });
-
-    const desktopImg = await getImage({
-        src: desktopImgUrl,
-        format: "webp",
-        width: 800,
-        height: 200,
-    });
-    ---
-
-    <picture>
-        <source media="(max-width: 799px)" srcset={mobileImg.src} />
-        <source media="(min-width: 800px)" srcset={desktopImg.src} />
-        <img src={desktopImg.src} alt={alt} />
-    </picture>
-
-    ```
-
-5. Importa y utiliza `<MyCustomImageComponent />` en cualquier archivo `.astro`. Asegúrate de pasar las props necesarias para generar dos imágenes diferentes en los diferentes tamaños de pantalla:
-
-    ```astro title="src/pages/index.astro" 
-    ---
-    import MyCustomImageComponent from "../components/MyCustomImageComponent.astro";
-    import mobileImage from "../images/mobile-profile-image.jpg";
-    import desktopImage from "../images/desktop-profile-image.jpg";
-    ---
-
-    <MyCustomImageComponent
-        mobileImgUrl={mobileImage}
-        desktopImgUrl={desktopImage}
-        alt="foto de perfil del usuario"
-    />
-
-    ```
diff --git a/src/content/docs/es/recipes/build-forms-api.mdx b/src/content/docs/es/recipes/build-forms-api.mdx
deleted file mode 100644
index 5b73bc37f575e..0000000000000
--- a/src/content/docs/es/recipes/build-forms-api.mdx
+++ /dev/null
@@ -1,450 +0,0 @@
----
-title: Construye formularios con rutas API
-description: Aprende como usar JavaScript para enviar formularios a una ruta API.
-i18nReady: true
-type: recipe
----
-import UIFrameworkTabs from "~/components/tabs/UIFrameworkTabs.astro";
-import PackageManagerTabs from "~/components/tabs/PackageManagerTabs.astro"
-
-Un formulario HTML hace que el navegador se actualice o navegue a una nueva página. Para enviar datos de formulario a un endpoint de API en su lugar, debes interceptar el envío del formulario usando JavaScript.
-
-Esta receta muestra como enviar datos de un formulario a un endpoint de API y manejar esos datos.
-
-## Prerrequisitos
-- Un proyecto con [SSR](/es/guides/on-demand-rendering/) (`output: 'server'` o `'hybrid'`) habilitado
-- Una [integración de Framework UI](/es/guides/framework-components/) instalada
-
-## Receta
-
-1. Crea un endpoint de API `POST` en `/api/feedback` que recibirá los datos del formulario. Usa `request.formData()` para procesarlos. Asegúrate de validar los valores del formularios antes de utilizarlos.
-
-  Este ejemplo manda un objeto JSON con un mensaje de vuelta al cliente.
-
-  ```ts title="src/pages/api/feedback.ts" "request.formData()" "post"
-      import type { APIRoute } from "astro";
-
-      export const POST: APIRoute = async ({ request }) => {
-        const data = await request.formData();
-        const name = data.get("name");
-        const email = data.get("email");
-        const message = data.get("message");
-        // Valida los datos - probablemente querrás hacer más que esto
-        if (!name || !email || !message) {
-          return new Response(
-            JSON.stringify({
-              message: "Faltan campos requeridos",
-            }),
-            { status: 400 }
-          );
-        }
-        // Haz algo con los datos, luego devuelve una respuesta de éxito
-        return new Response(
-          JSON.stringify({
-            message: "¡Éxito!"
-          }),
-          { status: 200 }
-        );
-      };
-      ```
-
-  2. Crea un componente de formulario usando tu framework UI. Cada entrada debe tener un atributo `name` que describa el valor de esa entrada.
-  
-  Asegúrate de incluir un elemento `<button>` o `<input type="submit">` para enviar el formulario.
-
-    <UIFrameworkTabs>
-      <Fragment slot="preact">
-        ```tsx title="src/components/FeedbackForm.tsx"
-        export default function Form() {
-          return (
-            <form>
-              <label>
-                Nombre
-                <input type="text" id="name" name="name" required />
-              </label>
-              <label>
-                Correo electrónico
-                <input type="email" id="email" name="email" required />
-              </label>
-              <label>
-                Mensaje
-                <textarea id="message" name="message" required />
-              </label>
-              <button>Enviar</button>
-            </form>
-          );
-        }
-        ```
-      </Fragment>
-      <Fragment slot="react">
-        ```tsx title="src/components/FeedbackForm.tsx"
-        export default function Form() {
-          return (
-            <form>
-              <label>
-                Nombre
-                <input type="text" id="name" name="name" required />
-              </label>
-              <label>
-                Correo electrónico
-                <input type="email" id="email" name="email" required />
-              </label>
-              <label>
-                Mensaje
-                <textarea id="message" name="message" required />
-              </label>
-              <button>Enviar</button>
-            </form>
-          );
-        }
-        ```
-      </Fragment>
-      <Fragment slot="solid">
-        ```tsx title="src/components/FeedbackForm.tsx"
-        export default function Form() {
-          return (
-            <form>
-              <label>
-                Nombre
-                <input type="text" id="name" name="name" required />
-              </label>
-              <label>
-                Correo electrónico
-                <input type="email" id="email" name="email" required />
-              </label>
-              <label>
-                Mensaje
-                <textarea id="message" name="message" required />
-              </label>
-              <button>Enviar</button>
-            </form>
-          );
-        }
-        ```
-      </Fragment>
-      <Fragment slot="svelte">
-        ```svelte title="src/components/FeedbackForm.svelte"
-        <form>
-          <label>
-            Nombre
-            <input type="text" id="name" name="name" required />
-          </label>
-          <label>
-            Correo electrónico
-            <input type="email" id="email" name="email" required />
-          </label>
-          <label>
-            Mensaje
-            <textarea id="message" name="message" required />
-          </label>
-          <button>Enviar</button>
-        </form>
-        ```
-      </Fragment>
-      <Fragment slot="vue">
-        ```vue title="src/components/FeedbackForm.vue"
-        <template>
-          <form>
-            <label>
-              Nombre
-              <input type="text" id="name" name="name" required />
-            </label>
-            <label>
-              Correo electrónico
-              <input type="email" id="email" name="email" required />
-            </label>
-            <label>
-              Mensaje
-              <textarea id="message" name="message" required />
-            </label>
-            <button>Enviar</button>
-          </form>
-        </template>
-        ```
-      </Fragment>
-
-    </UIFrameworkTabs>
-
-  3. Crea una función que acepte un evento de envío, luego pásala como un controlador `submit` a tu formulario.
-
-  En la función:
-	- Llama a `preventDefault()` en el evento para anular el proceso de envío predeterminado del navegador.
-	- Crea un objeto `FormData` y envíalo a tu endpoint como una solicitud `POST` usando `fetch()`.
-
-  <UIFrameworkTabs>
-    <Fragment slot="preact">
-      ```tsx title="src/components/FeedbackForm.tsx" "/api/feedback" add={1, 4-17, 34} add="onSubmit={submit}" "formData" "e.preventDefault();"
-      import { useState } from "preact/hooks";
-
-      export default function Form() {
-        const [responseMessage, setResponseMessage] = useState("");
-
-        async function submit(e: SubmitEvent) {
-          e.preventDefault();
-          const formData = new FormData(e.target as HTMLFormElement);
-          const response = await fetch("/api/feedback", {
-            method: "POST",
-            body: formData,
-          });
-          const data = await response.json();
-          if (data.message) {
-            setResponseMessage(data.message);
-          }
-        }
-
-        return (
-          <form onSubmit={submit}>
-            <label>
-              Nombre
-              <input type="text" id="name" name="name" required />
-            </label>
-            <label>
-              Correo electrónico
-              <input type="email" id="email" name="email" required />
-            </label>
-            <label>
-              Mensaje
-              <textarea id="message" name="message" required />
-            </label>
-            <button>Enviar</button>
-            {responseMessage && <p>{responseMessage}</p>}
-          </form>
-        );
-      }
-
-      ```
-    </Fragment>
-    <Fragment slot="react">
-      ```tsx title="src/components/FeedbackForm.tsx" "/api/feedback" add={1, 4-17, 34} add="onSubmit={submit}" "formData" "e.preventDefault();"
-      import { FormEvent, useState } from "react";
-
-      export default function Form() {
-        const [responseMessage, setResponseMessage] = useState("");
-
-        async function submit(e: FormEvent<HTMLFormElement>) {
-          e.preventDefault();
-          const formData = new FormData(e.target as HTMLFormElement);
-          const response = await fetch("/api/feedback", {
-            method: "POST",
-            body: formData,
-          });
-          const data = await response.json();
-          if (data.message) {
-            setResponseMessage(data.message);
-          }
-        }
-
-        return (
-          <form onSubmit={submit}>
-            <label htmlFor="name">
-              Nombre
-              <input type="text" id="name" name="name" autoComplete="name" required />
-            </label>
-            <label htmlFor="email">
-              Correo electrónico
-              <input type="email" id="email" name="email" autoComplete="email" required />
-            </label>
-            <label htmlFor="message">
-              Mensaje
-              <textarea id="message" name="message" autoComplete="off" required />
-            </label>
-            <button>Enviar</button>
-            {responseMessage && <p>{responseMessage}</p>}
-          </form>
-        );
-      }
-      ```
-    </Fragment>
-    <Fragment slot="solid">
-      ```tsx title="src/components/FeedbackForm.tsx" "/api/feedback" add={1, 3-9, 13-19, 36} add="onSubmit={submit}" "formData" "e.preventDefault();"
-      import { createSignal, createResource, Suspense } from "solid-js";
-
-      async function postFormData(formData: FormData) {
-        const response = await fetch("/api/feedback", {
-          method: "POST",
-          body: formData,
-        });
-        const data = await response.json();
-        return data;
-      }
-
-      export default function Form() {
-        const [formData, setFormData] = createSignal<FormData>();
-        const [response] = createResource(formData, postFormData);
-
-        function submit(e: SubmitEvent) {
-          e.preventDefault();
-          setFormData(new FormData(e.target as HTMLFormElement));
-        }
-
-        return (
-          <form onSubmit={submit}>
-            <label>
-              Nombre
-              <input type="text" id="name" name="name" required />
-            </label>
-            <label>
-              Correo electrónico
-              <input type="email" id="email" name="email" required />
-            </label>
-            <label>
-              Mensaje
-              <textarea id="message" name="message" required />
-            </label>
-            <button>Enviar</button>
-            <Suspense>{response() && <p>{response().message}</p>}</Suspense>
-          </form>
-        );
-      }
-
-      ```
-    </Fragment>
-    <Fragment slot="svelte">
-      ```svelte title="src/components/FeedbackForm.svelte" "/api/feedback" add={1-14, 30-32} add="on:submit={submit}" "formData" "e.preventDefault();"
-      <script lang="ts">
-        let responseMessage: string;
-
-        async function submit(e: SubmitEvent) {
-          e.preventDefault();
-          const formData = new FormData(e.currentTarget as HTMLFormElement);
-          const response = await fetch("/api/feedback", {
-            method: "POST",
-            body: formData,
-          });
-          const data = await response.json();
-          responseMessage = data.message;
-        }
-      </script>
-
-      <form on:submit={submit}>
-        <label>
-          Nombre
-          <input type="text" id="name" name="name" required />
-        </label>
-        <label>
-          Correo electrónico
-          <input type="email" id="email" name="email" required />
-        </label>
-        <label>
-          Mensaje
-          <textarea id="message" name="message" required />
-        </label>
-        <button>Enviar</button>
-        {#if responseMessage}
-          <p>{responseMessage}</p>
-        {/if}
-      </form>
-          ```
-    </Fragment>
-    <Fragment slot="vue">
-      ```vue title="src/components/FeedbackForm.vue" "/api/feedback" add={1-16, 33} "formData" "e.preventDefault();"
-      <script setup lang="ts">
-      import { ref } from "vue";
-
-      const responseMessage = ref<string>();
-
-      async function submit(e: Event) {
-        e.preventDefault();
-        const formData = new FormData(e.currentTarget as HTMLFormElement);
-        const response = await fetch("/api/feedback", {
-          method: "POST",
-          body: formData,
-        });
-        const data = await response.json();
-        responseMessage.value = data.message;
-      }
-      </script>
-
-      <template>
-        <form @submit="submit">
-          <label>
-            Nombre
-            <input type="text" id="name" name="name" required />
-          </label>
-          <label>
-            Correo electrónico
-            <input type="email" id="email" name="email" required />
-          </label>
-          <label>
-            Mensaje
-            <textarea id="message" name="message" required />
-          </label>
-          <button>Enviar</button>
-          <p v-if="responseMessage">{{ responseMessage }}</p>
-        </form>
-      </template>
-      ```
-    </Fragment>
-
-  </UIFrameworkTabs>
-
-  4. Importa y usa el componente `<FeedbackForm />` en la página. Asegúrate de utilizar una directiva `client:*` para garantizar que la lógica del formulario se hidrate cuando lo deseas.
-    
-  <UIFrameworkTabs>
-      <Fragment slot="preact">
-      ```astro title="src/pages/index.astro" "client:load"
-      ---
-      import FeedbackForm from "../components/FeedbackForm"
-      ---
-      <FeedbackForm client:load />
-      ```
-      </Fragment>
-      <Fragment slot="react">
-      ```astro title="src/pages/index.astro" "client:load"
-      ---
-      import FeedbackForm from "../components/FeedbackForm"
-      ---
-      <FeedbackForm client:load />
-      ```
-      </Fragment>
-      <Fragment slot="solid">
-      ```astro title="src/pages/index.astro" "client:load"
-      ---
-      import FeedbackForm from "../components/FeedbackForm"
-      ---
-      <FeedbackForm client:load />
-      ```
-      </Fragment>
-      <Fragment slot="svelte">
-      ```astro title="src/pages/index.astro" "client:load"
-      ---
-      import FeedbackForm from "../components/FeedbackForm.svelte"
-      ---
-      <FeedbackForm client:load />
-      ```
-      </Fragment>
-      <Fragment slot="vue">
-      ```astro title="src/pages/index.astro" "client:load"
-      ---
-      import FeedbackForm from "../components/FeedbackForm.vue"
-      ---
-      <FeedbackForm client:load />
-      ```
-      </Fragment>
-  </UIFrameworkTabs>
-
-{/* ## Extension: Use Zod to validate your form
-
-[Zod form data](https://www.npmjs.com/package/zod-form-data) builds on top of [Zod](https://github.com/colinhacks/zod) to validate your form using a schema. This simplifies your code, as it allows you to declare the fields and their requirements, and let Zod handle the validation.
-
-1. Install `zod` and `zod-form-data`.
-
-    <PackageManagerTabs>
-      <Fragment slot="npm">
-        ```shell
-          npm i zod zod-form-data
-        ```
-      </Fragment>
-      <Fragment slot="pnpm">
-        ```shell
-          pnpm i zod zod-form-data
-        ```
-      </Fragment>
-      <Fragment slot="yarn">
-        ```shell
-          yarn add zod zod-form-data
-        ```
-      </Fragment>
-    </PackageManagerTabs>
-
-2. In your API Route file, declare your schema using `zfd.formData` and export it. */}
diff --git a/src/content/docs/es/recipes/build-forms.mdx b/src/content/docs/es/recipes/build-forms.mdx
deleted file mode 100644
index 56b8dbf87bc32..0000000000000
--- a/src/content/docs/es/recipes/build-forms.mdx
+++ /dev/null
@@ -1,205 +0,0 @@
----
-title: Construye formularios HTML en páginas de Astro
-description: Aprende como construir formularios HTML y manejar envíos en tu frontmatter.
-i18nReady: true
-type: recipe
----
-
-En modo SSR, las páginas Astro pueden mostrar y manejar formularios. En esta receta, usarás un formulario HTML estándar para enviar datos al servidor. El script de tu frontmatter manejará los datos en el servidor, sin enviar JavaScript al cliente.
-
-
-## Prerrequisitos
-- Un proyecto con [SSR](/es/guides/on-demand-rendering/) (`output: 'server'`) habilitado
-
-## Receta
-
-1. Crea o identifica una página `.astro` que contenga tu formulario y tu código de manejo. Por ejemplo, podrías agregar una página de registro:
-
-    ```astro title="src/pages/register.astro"
-    ---
-    ---
-    <h1>Register</h1>
-    ```
-
-2. Agrega una etiqueta `<form>` con algunas entradas a la página. Cada entrada debe tener un atributo `name` que describa el valor de esa entrada.
-
-    Asegúrate de incluir un elemento `<button>` o `<input type="submit">` para enviar el formulario.
-
-    ```astro title="src/pages/register.astro"
-    ---
-    ---
-    <h1>Registro</h1>
-    <form>
-      <label>
-        Usuario:
-        <input type="text" name="username" />
-      </label>
-      <label>
-        Correo electrónico:
-        <input type="email" name="email" />
-      </label>
-      <label>
-        Contraseña:
-        <input type="password" name="password" />
-      </label>
-      <button>Enviar</button>
-    </form>
-    ```
-
-3. Usa [atributos de validación](https://developer.mozilla.org/es/docs/Learn/Forms/Form_validation#usar_la_validación_de_formulario_incorporada) para proveer validación básica del lado del cliente que funciona incluso si JavaScript está deshabilitado.
-
-    En este ejemplo,
-    - `required` previene el envío del formulario hasta que el campo esté lleno.
-    - `minlength` establece una longitud mínima requerida para el texto de entrada.
-    - `type="email"` también introduce validación que solo aceptará un formato de correo electrónico válido.
-
-    ```astro title="src/pages/register.astro"
-    ---
-    ---
-    <h1>Registro</h1>
-    <form>
-      <label>
-        Usuario:
-        <input type="text" name="username" required />
-      </label>
-      <label>
-        Correo electrónico:
-        <input type="email" name="email" required />
-      </label>
-      <label>
-        Contraseña:
-        <input type="password" name="password" required minlength="6" />
-      </label>
-      <button>Enviar</button>
-    </form>
-    ```
-    
-    :::tip
-    Puedes agregar lógica de validación personalizada que se refiera a múltiples campos usando una etiqueta `<script>` y la [API de validación de restricciones](https://developer.mozilla.org/en-US/docs/Web/HTML/Constraint_validation#complex_constraints_using_the_constraint_validation_api).
-
-    Para escribir validación de lógica compleja más fácilmente, puedes construir tu formulario usando un [framework de frontend](/es/guides/framework-components/) y elegir una librería de formularios como [React Hook Form](https://react-hook-form.com/) o [Felte](https://felte.dev/).
-    :::
-
-4. El envío del formulario causará que el navegador solicite la página nuevamente. Cambia el método de transferencia de datos del formulario a `POST` para enviar los datos del formulario como parte del cuerpo de la `Request`, en lugar de como parámetros de URL.
-
-    ```astro title="src/pages/register.astro" 'method="POST"'
-    ---
-    ---
-    <h1>Registro</h1>
-    <form method="POST">
-      <label>
-        Usuario:
-        <input type="text" name="username" required />
-      </label>
-      <label>
-        Correo electrónico:
-        <input type="email" name="email" required />
-      </label>
-      <label>
-        Contraseña:
-        <input type="password" name="password" required minlength="6" />
-      </label>
-      <button>Enviar</button>
-    </form>
-    ```
-
-5.  Comprueba el método `POST` en el frontmatter y accede a los datos del formulario usando `Astro.request.formData()`. Envuelve esto en un bloque `try ... catch` para manejar los casos en los que la solicitud `POST` no fue enviada por un formulario y el `formData` es inválido.
-
-    ```astro title="src/pages/register.astro" ins={2-14} "Astro.request.formData()"
-    ---
-    if (Astro.request.method === "POST") {
-      try {
-        const data = await Astro.request.formData();
-        const name = data.get("username");
-        const email = data.get("email");
-        const password = data.get("password");
-        // Do something with the data
-      } catch (error) {
-        if (error instanceof Error) {
-          console.error(error.message);
-        }
-      }
-    }
-    ---
-    <h1>Registro</h1>
-    <form method="POST">
-      <label>
-        Usuario:
-        <input type="text" name="username" required />
-      </label>
-      <label>
-        Correo electrónico:
-        <input type="email" name="email" required />
-      </label>
-      <label>
-        Contraseña:
-        <input type="password" name="password" required minlength="6" />
-      </label>
-      <button>Enviar</button>
-    </form>
-    ```
-
-5. Valida los datos del formulario en el servidor. Esto debería incluir la misma validación realizada en el cliente para evitar envíos maliciosos a tu endpoint y brindar soporte a los raros navegadores heredados que no tienen validación de formularios.
-
-    También puedes incluir validación que no se puede hacer en el cliente. Por ejemplo, este ejemplo verifica si el correo electrónico ya está en la base de datos.
-
-    Los mensajes de error pueden ser enviados al cliente almacenándolos en un objeto `errors` y accediendo a él en la plantilla.
-
-    ```astro title="src/pages/register.astro" ins={5, 12-22, 41, 46, 51}
-    ---
-    import { isRegistered, registerUser } from "../../data/users"
-    import { isValidEmail } from "../../utils/isValidEmail";
-
-    const errors = { username: "", email: "", password: "" };
-    if (Astro.request.method === "POST") {
-      try {
-        const data = await Astro.request.formData();
-        const name = data.get("username");
-        const email = data.get("email");
-        const password = data.get("password");
-        if (typeof name !== "string" || name.length < 1) {
-          errors.username += "Please enter a username. ";
-        }
-        if (typeof email !== "string" || !isValidEmail(email)) {
-          errors.email += "Email is not valid. ";
-        } else if (await isRegistered(email)) {
-          errors.email += "Email is already registered. ";
-        }
-        if (typeof password !== "string" || password.length < 6) {
-          errors.password += "Password must be at least 6 characters. ";
-        }
-        const hasErrors = Object.values(errors).some(msg => msg)
-        if (!hasErrors) {
-          await registerUser({name, email, password});
-          return Astro.redirect("/login");
-        }
-      } catch (error) {
-        if (error instanceof Error) {
-          console.error(error.message);
-        }
-      }
-    }
-    ---
-    <h1>Registro</h1>
-    <form method="POST">
-      <label>
-        Usuario:
-        <input type="text" name="username" />
-      </label>
-      {errors.username && <p>{errors.username}</p>}
-      <label>
-        Correo electrónico:
-        <input type="email" name="email" required />
-      </label>
-      {errors.email && <p>{errors.email}</p>}
-      <label>
-        Contraseña:
-        <input type="password" name="password" required minlength="6" />
-      </label>
-      {errors.password && <p>{errors.password}</p>}
-      <button>Registro</button>
-    </form>
-
-    ```
-
-
diff --git a/src/content/docs/es/recipes/bun.mdx b/src/content/docs/es/recipes/bun.mdx
deleted file mode 100644
index cbce8f3b96765..0000000000000
--- a/src/content/docs/es/recipes/bun.mdx
+++ /dev/null
@@ -1,138 +0,0 @@
----
-title: Usa Bun con Astro
-description: Aprende cómo usar Bun con tu sitio de Astro.
-type: recipe
-i18nReady: true
----
-
-[Bun](https://bun.sh/) es un entorno y conjunto de herramientas de JavaScript todo en uno. Consulta la [documentación de Bun](https://bun.sh/docs) para obtener más información.
-
-:::caution
-Bun lanzó recientemente su primera versión estable. Sin embargo, al usar Bun con Astro, pueden aparecer problemas inesperados. Algunas integraciones pueden no funcionar como se espera. Consulta la [documentación oficial de Bun para trabajar con Astro](https://bun.sh/guides/ecosystem/astro) para obtener detalles adicionales.
-
-Si tienes algún problema utilizando Bun, por favor [abre un problema en GitHub directamente en el repositorio de Bun](https://github.com/oven-sh/bun/issues/new/choose).
-:::
-
-## Prerrequisitos
-
-- Tener Bun instalado localmente en tu máquina. Consulta las [instrucciones de instalación](https://bun.sh/docs/installation) en la documentación oficial de Bun.
-
-## Crea un nuevo proyecto de Astro con Bun
-
-Crea un nuevo proyecto de Astro con Bun utilizando el siguiente comando `create-astro`:
-
-```bash
-bunx create-astro@latest my-astro-project-using-bun
-```
-
-:::tip
-También puedes [crear un nuevo proyecto de Astro a partir de cualquier repositorio de GitHub de Astro existente](/es/install-and-setup/#usa-un-tema-o-una-plantilla-de-inicio) utilizando la bandera `--template`:
-```bash
-bunx create-astro@latest my-astro-project-using-bun --template eliancodes/brutal
-```
-:::
-
-## Instalar dependencias
-
-Si estás comenzando un nuevo proyecto utilizando `bunx create-astro`, la CLI utilizará automáticamente Bun para instalar las dependencias y puedes omitir este paso.
-
-De lo contrario, deberás instalar tus dependencias con Bun:
-
-```bash
-bun install
-```
-
-## Agrega Tipos
-
-Bun publica el paquete [`@types/bun`](https://www.npmjs.com/package/@types/bun), que contiene los tipos en runtime para Bun.
-
-Instala `@types/bun` utilizando el siguiente comando:
-
-```sh
-bun add -d @types/bun
-```
-
-## Utilizando las integraciones de Astro
-
-También puedes utilizar cualquiera de las integraciones oficiales de Astro con el comando `astro add`:
-
-```bash
-bunx astro add react
-```
-
-## Ejecuta Astro con Bun
-
-:::note
-Utiliza la [bandera `--bun` en la CLI](https://bun.sh/docs/cli/bunx#shebangs) antes de cada comando `astro` para utilizar el propio entorno de ejecución de Bun en lugar de Node.
-:::
-
-### Ejecuta el servidor de desarrollo
-
-Para ejecutar el servidor de desarrollo utilizando Bun como el entorno de ejecución, utiliza el siguiente comando:
-
-```bash
-bunx --bun astro dev
-```
-
-### Construyendo tu sitio con Bun
-
-Para construir tu sitio utilizando Bun como el entorno de ejecución, utiliza el siguiente comando:
-
-```bash
-bunx --bun astro build
-```
-
-Astro generará la salida de tu sitio en el directorio `dist/`. Luego, puedes servir tu sitio utilizando el comando `preview`:
-
-```bash
-bunx --bun astro preview
-```
-
-## Agrega SSR con Bun
-
-Como Bun es [compatible con la API de Node.js](https://bun.sh/docs/runtime/nodejs-apis), puedes usar cualquier adaptador Astro para [server-side rendering](/es/guides/on-demand-rendering/) en tu proyecto Astro:
-
-```bash
-bunx astro add vercel
-```
-
-
-## Testing en Bun
-
-Bun incluye un ejecutor de tests rápido, integrado y compatible con Jest a través del comando `bun test`. Si quieres usarlo consulta la [documentación de `bun test`](https://bun.sh/docs/cli/test).
-
-Sin embargo, también es posible utilizar Cypress o Playwright para un enfoque moderno de los tests de aplicaciones web.
-
-### Cypress
-
-Cypress es una herramienta de tests front-end y tiene la misión de "hacer agradable la experiencia de los tests y generar felicidad en los desarrolladores". Esto le permite escribir tests de extremo a extremo para tu sitio Astro.
-
-Instala Cypress con el siguiente comando:
-
-```bash
-bun add cypress --dev
-```
-
-Para el resto de la configuración y para iniciar tu primer test, sigue el resto del proceso de Cypress en la [Guía de testing en Astro](/es/guides/testing/#configuración).
-
-### Playwright
-
-Playwright es un framework de tests de extremo a extremo que te permite probar tu código Astro en todos los motores de renderizado modernos, incluidos Chromium, WebKit y Firefox.
-
-Instala Playwright utilizando el siguiente comando:
-
-```bash
-bun create playwright
-```
-
-Para crear tu primer test en Playwright, sigue las instrucciones para el resto del proceso Playwright en la [Guía de testing en Astro](/es/guides/testing/#cree-su-primer-test-con-playwright).
-
-## Recursos Oficiales
-
-- [Construye una aplicación con Astro y Bun](https://bun.sh/guides/ecosystem/astro)
-
-## Recursos de la Comunidad
-
-¿Estás usando Bun con Astro? ¡Agrega tu entrada de blog o video a esta página!
-
-- [Construyendo un sitio de Cloudflare Pages con Bun](https://blog.otterlord.dev/posts/hello-from-bun/) - entrada de blog
diff --git a/src/content/docs/es/recipes/call-endpoints.mdx b/src/content/docs/es/recipes/call-endpoints.mdx
deleted file mode 100644
index 3a23ae9c39a38..0000000000000
--- a/src/content/docs/es/recipes/call-endpoints.mdx
+++ /dev/null
@@ -1,41 +0,0 @@
----
-title: Llama endpoints desde el servidor
-description: Aprende como llamar endpoints desde el servidor en Astro.
-i18nReady: true
-type: recipe
----
-
-Los endpoints pueden ser usados para servir cualquier tipo de dato. Esta receta llama un endpoints del servidor desde el script del componente de una página para mostrar un saludo, sin requerir una petición fetch adicional.  
-
-## Prerrequisitos
-
-- Un proyecto con [SSR](/es/guides/on-demand-rendering/) (output: 'server') habilitado
-
-## Receta
-
-1. Crea un endpoint en un archivo nuevo `src/pages/api/hello.ts` que retorne algo de data:
-
-```ts title="src/pages/api/hello.ts"
-import type { APIRoute } from 'astro'
-
-export const GET: APIRoute = () => {
-  return new Response(
-    JSON.stringify({
-      greeting: 'Hola',
-    }),
-  )
-}
-```
-
-2. En cualquier página de Astro, importa el método `GET()` desde el endpoint. Llámalo con [`Astro` global](/es/reference/api-reference/#astro-global) para dar el contexto de la petición, y usa la respuesta en la página:
-```astro title="src/pages/index.astro"
-
----
-import { GET } from './api/hello.ts'
-
-let response = await GET(Astro)
-const data = await response.json()
----
-
-<h1>{data.greeting} mundo!</h1>
-```
diff --git a/src/content/docs/es/recipes/captcha.mdx b/src/content/docs/es/recipes/captcha.mdx
deleted file mode 100644
index eddcfeaaa33bc..0000000000000
--- a/src/content/docs/es/recipes/captcha.mdx
+++ /dev/null
@@ -1,76 +0,0 @@
----
-title: Verificar un Captcha
-description: Aprende como crear una ruta de API y consultarla desde el cliente.
-i18nReady: true
-type: recipe
----
-
-Los [endpoints del servidor](/es/guides/endpoints/#endpoints-del-servidor-rutas-de-api) se pueden utilizar como endpoints de API REST para ejecutar funciones como autenticaciones, acceso a bases de datos y verificaciones sin exponer datos sensibles al cliente.
-
-En esta receta, se utiliza una ruta de API para verificar Google reCAPTCHA v3 sin exponer el secreto a los clientes.
-
-## Prerrequesitos
-- Un proyecto con [SSR](/es/guides/on-demand-rendering/) habilitado, con la opción `output: 'server'`.
-
-## Receta
-
-1. Crea un endpoint `POST` que acepte datos de reCAPTCHA y luego los verifique con la API de reCAPTCHA. Aquí puedes definir de manera segura valores secretos o leer variables de entorno.
-
-    ```js title="src/pages/recaptcha.js"
-    export async function POST({ request }) {
-      const data = await request.json();
-
-      const recaptchaURL = 'https://www.google.com/recaptcha/api/siteverify';
-      const requestHeaders = {
-        'Content-Type': 'application/x-www-form-urlencoded'
-      };
-      const requestBody = new URLSearchParams({
-        secret: "TU_CLAVE_SECRETA_DEL_SITIO",   // Esto puede ser una variable de entorno
-        response: data.recaptcha          // El token pasado desde el cliente
-      });
-
-      const response = await fetch(recaptchaURL, {
-        method: "POST",
-        headers: requestHeaders,
-        body: requestBody.toString()
-      });
-
-      const responseData = await response.json();
-
-      return new Response(JSON.stringify(responseData), { status: 200 });
-    }
-    ```
-
-2. Accede a tu endpoint utilizando `fetch` desde un script de cliente:
-
-    ```astro title="src/pages/index.astro"
-    <html>
-      <head>
-        <script is:inline src="https://www.google.com/recaptcha/api.js"></script>
-      </head>
-
-      <body>
-        <button class="g-recaptcha" 
-          data-sitekey="PUBLIC_SITE_KEY" 
-          data-callback="onSubmit" 
-          data-action="submit"> Click me to verify the captcha challenge! </button>
-
-        <script is:inline>
-          function onSubmit(token) {
-            fetch("/recaptcha", {
-              method: "POST",
-              body: JSON.stringify({ recaptcha: token })
-            })
-            .then((response) => response.json())
-            .then((gResponse) => {
-              if (gResponse.success) {
-                // Verificación del Captcha fue un éxito
-              } else {
-                // Falló la verificación del Captcha
-              }
-            })
-          }
-        </script>
-      </body>
-    </html>
-    ```
diff --git a/src/content/docs/es/recipes/docker.mdx b/src/content/docs/es/recipes/docker.mdx
deleted file mode 100644
index 96379d7544c8b..0000000000000
--- a/src/content/docs/es/recipes/docker.mdx
+++ /dev/null
@@ -1,183 +0,0 @@
----
-title: Construye tu sitio de Astro con Docker
-description: Aprende cómo construir tu sitio de Astro utilizando Docker.
-type: recipe
-i18nReady: true
----
-
-[Docker](https://docker.com) es una herramienta para construir, desplegar y ejecutar aplicaciones utilizando contenedores.
-
-Las imágenes y contenedores de Docker se pueden implementar en muchas plataformas diferentes, como AWS, Azure y [Google Cloud](/es/guides/deploy/google-cloud/#cloud-run-ssr-y-estático). Esta guía no cubrirá cómo implementar tu sitio en una plataforma específica, pero te mostrará cómo configurar Docker para tu proyecto.
-
-## Prerrequesitos
-
-- Docker está instalado en tu máquina local. Puedes encontrar las [instrucciones de instalación para tu sistema operativo aquí](https://docs.docker.com/get-docker/).
-- Un archivo Dockerfile en tu proyecto. Puedes [obtener más información sobre Dockerfiles aquí](https://docs.docker.com/engine/reference/builder/) y utilizar los Dockerfiles de la siguiente sección como punto de partida.
-
-## Creando un Dockerfile
-
-Crea un archivo llamado `Dockerfile` en el directorio raíz de tu proyecto. Este archivo contiene las instrucciones para construir tu sitio, las cuales variarán según tus necesidades. Esta guía no puede mostrar todas las opciones posibles, pero te proporcionará puntos de partida para los modos SSR y estático.
-
-Si estás usando otro gestor de paquetes que no sea npm, deberás ajustar los comandos en consecuencia.
-
-### SSR
-
-Este Dockerfile construirá tu sitio y lo servirá utilizando Node.js en el puerto `4321`, por lo tanto, requiere tener instalado el [adaptador de Node](/es/guides/integrations-guide/node/) en tu proyecto de Astro.
-
-```docker title="Dockerfile"
-FROM node:lts AS runtime
-WORKDIR /app
-
-COPY . .
-
-RUN npm install
-RUN npm run build
-
-ENV HOST=0.0.0.0
-ENV PORT=4321
-EXPOSE 4321
-CMD node ./dist/server/entry.mjs
-```
-
-:::tip[Tenlo en cuenta]
-Estos son solo ejemplos de Dockerfiles. Puedes personalizarlos según tus necesidades. Por ejemplo, podrías utilizar otra imagen, como `node:lts-alpine`:
-
-```docker title="Dockerfile" del={1} add={2}
-FROM node:lts as runtime
-FROM node:lts-alpine as runtime
-```
-:::
-
-### Agregar un .dockerignore
-
-Agregar un archivo `.dockerignore` a tu proyecto es una buena práctica. Este archivo describe qué archivos o carpetas deben ignorarse en los comandos `COPY` o `ADD` de Docker, muy similar a cómo funciona `.gitignore`. Esto acelera el proceso de construcción y reduce el tamaño de la imagen final.
-
-```docker title=".dockerignore"
-.DS_Store
-node_modules
-dist
-```
-
-Este archivo debe ir en el mismo directorio que el `Dockerfile` en sí. [Lee la documentación de `.dockerignore` para obtener información adicional](https://docs.docker.com/engine/reference/builder/#dockerignore-file).
-
-### Estático
-
-#### Apache (httpd)
-
-El siguiente Dockerfile construirá tu sitio y lo servirá utilizando Apache htppd en el puerto `80` con la configuración predeterminada.
-
-```docker title="Dockerfile"
-FROM node:lts AS build
-WORKDIR /app
-COPY . .
-RUN npm i
-RUN npm run build
-
-FROM httpd:2.4 AS runtime
-COPY --from=build /app/dist /usr/local/apache2/htdocs/
-EXPOSE 80
-```
-
-:::caution[Recomendación]
-Utiliza este enfoque para sitios web simples que no necesiten ninguna configuración especial. Para sitios web más complejos, se recomienda utilizar una configuración personalizada, ya sea en Apache o NGINX.
-:::
-
-#### NGINX
-
-```docker title="Dockerfile"
-FROM node:lts AS build
-WORKDIR /app
-COPY package*.json ./
-RUN npm install
-COPY . .
-RUN npm run build
-
-FROM nginx:alpine AS runtime
-COPY ./nginx/nginx.conf /etc/nginx/nginx.conf
-COPY --from=build /app/dist /usr/share/nginx/html
-EXPOSE 8080
-```
-
-Para construir el Dockerfile anterior, también necesitarás crear un archivo de configuración para NGINX. Crea una carpeta llamada `nginx` en el directorio raíz de tu proyecto y dentro de ella crea un archivo llamado `nginx.conf`.
-
-```nginx title="nginx.conf"
-worker_processes  1;
-
-events {
-  worker_connections  1024;
-}
-
-http {
-  server {
-    listen 8080;
-    server_name   _;
-
-    root   /usr/share/nginx/html;
-    index  index.html index.htm;
-    include /etc/nginx/mime.types;
-
-    gzip on;
-    gzip_min_length 1000;
-    gzip_proxied expired no-cache no-store private auth;
-    gzip_types text/plain text/css application/json application/javascript application/x-javascript text/xml application/xml application/xml+rss text/javascript;
-
-    error_page 404 /404.html;
-    location = /404.html {
-            root /usr/share/nginx/html;
-            internal;
-    }
-
-    location / {
-            try_files $uri $uri/index.html =404;
-    }
-  }
-}
-```
-
-### Construcción de múltiples etapas (usando SSR)
-
-Aquí hay un ejemplo de un Dockerfile más avanzado que, gracias a las [construcciones de varias etapas](https://docs.docker.com/build/building/multi-stage/) de Docker, optimiza el proceso de compilación de tu sitio al no reinstalar las dependencias de npm cuando solo cambia el código fuente. Esto puede reducir el tiempo de compilación incluso en minutos, dependiendo del tamaño de tus dependencias.
-
-```docker title="Dockerfile"
-FROM node:lts AS base
-WORKDIR /app
-# By copying only the package.json and package-lock.json here, we ensure that the following `-deps` steps are independent of the source code.
-# Therefore, the `-deps` steps will be skipped if only the source code changes.
-COPY package.json package-lock.json ./
-FROM base AS prod-deps
-RUN npm install --production
-FROM base AS build-deps
-RUN npm install --production=false
-FROM build-deps AS build
-COPY . .
-RUN npm run build
-FROM base AS runtime
-COPY --from=prod-deps /app/node_modules ./node_modules
-COPY --from=build /app/dist ./dist
-ENV HOST=0.0.0.0
-ENV PORT=4321
-EXPOSE 4321
-CMD node ./dist/server/entry.mjs
-```
-
-## Receta
-
-1. Para construir tu contenedor, ejecuta el siguiente comando en el directorio raíz de tu proyecto. Utiliza cualquier nombre para `<tu-nombre-de-imagen-de-astro>`:
-
-```bash
-docker build -t <tu-nombre-de-imagen-de-astro> .
-```
-
-Esto generará una imagen que podrás ejecutar localmente o implementar en una plataforma de tu elección.
-
-2. Para ejecutar tu imagen como un contenedor local, utiliza el siguiente comando. 
-
-Reemplaza `<puerto-local>` con un puerto abierto en tu máquina. Reemplaza `<puerto-de-contenedor>` con el puerto expuesto por tu contenedor Docker (`4321`, `80` o `8080` en los ejemplos anteriores).
-
-```bash
-docker run -p <puerto-local>:<puerto-de-contenedor> <tu-nombre-de-imagen-de-astro>
-```
-
-Deberías poder acceder a tu sitio en `http://localhost:<puerto-local>`.
-
-3. Ahora que tu sitio web se ha construido y empaquetado correctamente en un contenedor, puedes implementarlo en un proveedor de servicios en la nube. Consulta la guía de implementación en [Google Cloud](https://cloud.google.com) para obtener un ejemplo y la página [Deploy your app](https://docs.docker.com/language/nodejs/deploy/) en la documentación de Docker.
diff --git a/src/content/docs/es/recipes/external-links.mdx b/src/content/docs/es/recipes/external-links.mdx
deleted file mode 100644
index d7c28e2d89c30..0000000000000
--- a/src/content/docs/es/recipes/external-links.mdx
+++ /dev/null
@@ -1,65 +0,0 @@
----
-title: Agregar iconos a los enlaces externos
-description: Aprende cómo instalar un plugin de rehype para agregar iconos a los enlaces externos en tus archivos Markdown.
-i18nReady: true
-type: recipe
----
-
-import PackageManagerTabs from '~/components/tabs/PackageManagerTabs.astro'
-
-Usando un plugin de rehype, puedes identificar y modificar los enlaces en tus archivos Markdown que apuntan a sitios externos. Este ejemplo agrega iconos al final de cada enlace externo, para que los visitantes sepan que están saliendo de tu sitio.
-
-## Prerrequesitos
-- Un proyecto de Astro que utiliza Markdown para las páginas de contenido.
-
-## Receta
-
-1. Instala el plugin `rehype-external-links`.
-
-    <PackageManagerTabs>
-        <Fragment slot="npm">
-        ```shell
-        npm install rehype-external-links
-        ```
-        </Fragment>
-        <Fragment slot="pnpm">
-        ```shell
-        pnpm add rehype-external-links
-        ```
-        </Fragment>
-        <Fragment slot="yarn">
-        ```shell
-        yarn add rehype-external-links
-        ```
-        </Fragment>
-      </PackageManagerTabs>
-
-2. Importa el plugin en tu archivo `astro.config.mjs`.
-
-	Pasa `rehypeExternalLinks` al array `rehypePlugins`, junto con un objeto de opciones que incluya una propiedad `content`. Si deseas agregar texto sin formato al final del enlace, establece el `type` de esta propiedad como `text`. Para agregar HTML en lugar de texto al final del enlace, establece el `type` de la propiedad como `raw`.
-
-    ```ts
-    // ...
-    import rehypeExternalLinks from 'rehype-external-links';
-
-    export default defineConfig({
-      // ...
-      markdown: {
-        rehypePlugins: [
-          [
-            rehypeExternalLinks,
-            {
-              content: { type: 'text', value: ' 🔗' }
-            }
-          ],
-        ]
-      },
-    });
-    ```
-
-:::note
-  El valor de la propiedad `content` [no se representa en el árbol de accesibilidad](https://developer.mozilla.org/en-US/docs/Web/CSS/content#accessibility_concerns). Por lo tanto, es mejor dejar claro que el enlace es externo en el contenido que lo rodea en lugar de depender únicamente del icono.
-:::
-
-## Recursos
-- [rehype-external-links](https://www.npmjs.com/package/rehype-external-links)
\ No newline at end of file
diff --git a/src/content/docs/es/recipes/i18n.mdx b/src/content/docs/es/recipes/i18n.mdx
deleted file mode 100644
index f8698743f6e8a..0000000000000
--- a/src/content/docs/es/recipes/i18n.mdx
+++ /dev/null
@@ -1,512 +0,0 @@
----
-title: Agrega características i18n 
-description: Utiliza enrutamiento dinámico y colecciones de contenido para agregar soporte de internacionalización a tu sitio de Astro.
-type: recipe
-i18nReady: true
----
-import { FileTree } from '@astrojs/starlight/components';
-import ReadMore from '~/components/ReadMore.astro'
-import StaticSsrTabs from '~/components/tabs/StaticSsrTabs.astro'
-
-En esta receta, aprenderás a utilizar colecciones de contenido y enrutamiento dinámico para crear tu propia solución de internacionalización (i18n) y servir contenido en diferentes idiomas.
-
-:::tip
-En v4.0, Astro agregó soporte integrado para enrutamiento i18n que permite configurar los idiomas predeterminados y admitidos e incluye valiosas funciones auxiliares para ayudarte atender a una audiencia internacional. Si deseas utilizar esto, consulta nuestra [guía de internacionalización](/es/guides/internationalization/) para conocer estas funciones.
-:::
-Este ejemplo sirve para cada idioma en su propia subruta, p. ej. `example.com/en/blog` para inglés y `example.com/fr/blog` para francés.
-
-Si prefieres que el idioma predeterminado no sea visible en la URL, a diferencia de otros idiomas, hay [instrucciones para ocultar el idioma predeterminado](/es/recipes/i18n/#ocultar-el-idioma-predeterminado-en-la-url) a continuación.
-
-## Receta
-
-### Configura páginas para cada idioma
-
-1. Crea un directorio para cada idioma que desees soportar. Por ejemplo, `en/` y `fr/` si estás soportando inglés y francés:
-
-    <FileTree>
-    - src/
-      - pages/
-        - **en/**
-          - about.astro
-          - index.astro
-        - **fr/**
-          - about.astro
-          - index.astro
-        - index.astro
-    </FileTree>
-
-    
-2. Configura `src/pages/index.astro` para redirigir al idioma predeterminado.
-
-    <StaticSsrTabs>
-      <Fragment slot="static">
-        ```astro
-        ---
-        // src/pages/index.astro
-        ---
-        <meta http-equiv="refresh" content="0;url=/en/" />
-        ```
-
-        Este enfoque utiliza un método [meta refresh](https://en.wikipedia.org/wiki/Meta_refresh) y funcionará sin importar cómo se despliegue tu sitio. Algunos hosts estáticos también te permiten configurar redirecciones de servidor con un archivo de configuración personalizado. Consulta la documentación de tu plataforma de despliegue para obtener más detalles.
-      </Fragment>
-      
-      <Fragment slot="ssr">
-        Si estás utilizando un adaptador SSR, puedes utilizar [`Astro.redirect`](/es/guides/routing/#redirecciones-dinámicas) para redirigir al idioma predeterminado en el servidor.
-
-        ```astro
-        ---
-        // src/pages/index.astro
-        return Astro.redirect('/en/');
-        ---
-        ```
-      </Fragment>
-    </StaticSsrTabs>
-
-### Utiliza colecciones para el contenido traducido.
-
-1. Crea una carpeta en `src/content/` para cada tipo de contenido que desees incluir y agrega subdirectorios para cada idioma compatible. Por ejemplo, para soportar publicaciones de blog en inglés y francés:
-
-    <FileTree>
-    - src/
-      - content/
-          - blog/
-            - **en/** Artículos de blog en inglés
-                - post-1.md
-                - post-2.md
-            - **fr/** Artículos de blog en francés
-              - post-1.md
-              - post-2.md
-    </FileTree>
-
-2. Crea un archivo `src/content/config.ts` y exporta una colección para cada tipo de contenido.
-
-    ```ts
-    //src/content/config.ts
-    import { defineCollection, z } from 'astro:content';
-
-    const blogCollection = defineCollection({
-      schema: z.object({
-        title: z.string(),
-        author: z.string(),
-        date: z.date()
-      })
-    });
-
-    export const collections = {
-      'blog': blogCollection
-    };
-
-    ```
-    <ReadMore>Lee más sobre [Colecciones de Contenido](/es/guides/content-collections/).</ReadMore>
-
-3. Utiliza [rutas dinámicas](/es/guides/routing/#rutas-dinámicas) para obtener y mostrar contenido basado en los parámetros `lang` y `slug`.
-
-    <StaticSsrTabs>
-      <Fragment slot="static">
-        En el modo de renderizado estático, utiliza `getStaticPaths` para asignar cada entrada de contenido a una página:
-
-        ```astro
-        //src/pages/[lang]/blog/[...slug].astro
-        ---
-        import { getCollection } from 'astro:content';
-
-        export async function getStaticPaths() {
-          const pages = await getCollection('blog');
-
-          const paths = pages.map(page => {
-            const [lang, ...slug] = page.slug.split('/');
-            return { params: { lang, slug: slug.join('/') || undefined }, props: page };
-          });
-
-          return paths;
-        }
-
-        const { lang, slug } = Astro.params;
-        const page = Astro.props;
-        const formattedDate = page.data.date.toLocaleString(lang);
-
-        const { Content } = await page.render();
-        ---
-        <h1>{page.data.title}</h1>
-        <p>by {page.data.author} • {formattedDate}</p>
-        <Content/>
-        ```
-      </Fragment>
-
-      <Fragment slot="ssr">
-        En el [modo SSR](/es/guides/on-demand-rendering/), obtén directamente la entrada solicitada:
-
-        ```astro
-        //src/pages/[lang]/blog/[...slug].astro
-        ---
-        import { getEntry } from 'astro:content';
-
-        const { lang, slug } = Astro.params;
-        const page = await getEntry('blog', `${lang}/${slug}`);
-
-        if (!page) {
-          return Astro.redirect('/404');
-        }
-
-        const formattedDate = page.data.date.toLocaleString(lang);
-        const { Content, headings } = await page.render();
-        ---
-        <h1>{page.data.title}</h1>
-        <p>by {page.data.author} • {formattedDate}</p>
-        <Content/>
-        ```
-      </Fragment>
-    </StaticSsrTabs>
-
-    <ReadMore>Lee más sobre [enrutamiento dinámico](/es/guides/routing/#rutas-dinámicas).</ReadMore>
-
-    :::tip[Formateo de fechas]
-    El ejemplo anterior utiliza el método integrado [`toLocaleString()`](https://developer.mozilla.org/es/docs/Web/JavaScript/Reference/Global_Objects/Date/toLocaleString) de formateo de fechas para crear una cadena legible por humanos a partir de la fecha del encabezado.
-    Esto asegura que la fecha y la hora se formateen de acuerdo con el idioma del usuario.
-    :::
-
-### Traducir strings de la UI
-
-Crea diccionarios de términos para traducir las etiquetas de los elementos de la UI en tu sitio. Esto permitirá que tus visitantes experimenten tu sitio completamente en su idioma.
-
-1. Crea un archivo `src/i18n/ui.ts` para almacenar tus strings de traducción:
-
-    ```ts
-    // src/i18n/ui.ts
-    export const languages = {
-      en: 'English',
-      fr: 'Français',
-    };
-
-    export const defaultLang = 'en';
-    
-    export const ui = {
-      en: {
-        'nav.home': 'Home',
-        'nav.about': 'About',
-        'nav.twitter': 'Twitter',
-      },
-      fr: {
-        'nav.home': 'Accueil',
-        'nav.about': 'À propos',
-      },
-    } as const;
-    ```
-    
-2. Crea dos funciones auxiliares: una para detectar el idioma de la página según la URL actual y otra para obtener las cadenas de traducción de diferentes partes de la UI en `src/i18n/utils.ts`:
-
-    ```js
-    // src/i18n/utils.ts
-    import { ui, defaultLang } from './ui';
-    
-    export function getLangFromUrl(url: URL) {
-      const [, lang] = url.pathname.split('/');
-      if (lang in ui) return lang as keyof typeof ui;
-      return defaultLang;
-    }
-    
-    export function useTranslations(lang: keyof typeof ui) {
-      return function t(key: keyof typeof ui[typeof defaultLang]) {
-        return ui[lang][key] || ui[defaultLang][key];
-      }
-    }
-    ```
-
-    :::note[¿Te diste cuenta?]
-    En el paso 1, la cadena `nav.twitter` no se tradujo al francés. Es posible que no desees traducir cada término, como nombres propios o términos comunes de la industria. El helper `useTranslations` devolverá el valor del idioma predeterminado si una clave no está traducida. En este ejemplo, los usuarios franceses también verán "Twitter" en la barra de navegación.
-    :::
-    
-3. Importa los helpers donde sea necesario y úsalos para elegir el string de UI que corresponda al idioma actual. Por ejemplo, un componente de navegación podría lucir así:
-
-    ```astro 
-    ---
-    // src/components/Nav.astro
-    import { getLangFromUrl, useTranslations } from '../i18n/utils';
-    
-    const lang = getLangFromUrl(Astro.url);
-    const t = useTranslations(lang);
-    ---
-    <ul>
-        <li>
-            <a href={`/${lang}/home/`}>
-              {t('nav.home')}
-            </a>
-        </li>
-        <li>
-            <a href={`/${lang}/about/`}>
-              {t('nav.about')}
-            </a>
-        </li>
-        <li>
-            <a href="https://twitter.com/astrodotbuild">
-              {t('nav.twitter')}
-            </a>
-        </li>
-    </ul>
-    ```
-
-4. Cada página debe tener un atributo `lang` en el elemento `<html>` que coincida con el idioma de la página. En este ejemplo, un [diseño reutilizable](/es/basics/layouts/) extrae el idioma de la ruta actual:
-
-    ```astro
-    ---
-    // src/layouts/Base.astro
-    
-    import { getLangFromUrl } from '../i18n/utils';
-    
-    const lang = getLangFromUrl(Astro.url);
-    ---
-    <html lang={lang}>
-        <head>
-            <meta charset="utf-8" />
-            <link rel="icon" type="image/svg+xml" href="/favicon.svg" />
-            <meta name="viewport" content="width=device-width" />
-            <title>Astro</title>
-        </head>
-        <body>
-            <slot />
-        </body>
-    </html>
-    ```
-
-    Puedes utilizar este diseño base para asegurarte de que las páginas utilicen automáticamente el atributo `lang` correcto.
-    
-    ```astro
-    ---
-    // src/pages/en/about.astro
-    import Base from '../../layouts/Base.astro';
-    ---
-    <Base>
-        <h1>About me</h1>
-        ...
-    </Base>
-    ```
-
-### Permite a los usuarios cambiar entre idiomas.
-
-Crea enlaces a los diferentes idiomas que admites para que los usuarios puedan elegir el idioma en el que desean leer tu sitio.
-
-1. Crea un componente para mostrar un enlace por cada idioma:
-
-    ```astro
-    ---
-    // src/components/LanguagePicker.astro
-    import { languages } from '../i18n/ui';
-    ---
-    <ul>
-      {Object.entries(languages).map(([lang, label]) => (
-        <li>
-          <a href={`/${lang}/`}>{label}</a>
-        </li>
-      ))}
-    </ul>
-    ```
-
-2. Agrega `<LanguagePicker />` a tu sitio para que se muestre en todas las páginas. El ejemplo a continuación lo agrega al pie de página del diseño base:
-
-    ```astro ins={3,17-19}
-    ---
-    // src/layouts/Base.astro
-    import LanguagePicker from '../components/LanguagePicker.astro';
-    import { getLangFromUrl } from '../i18n/utils';
-    
-    const lang = getLangFromUrl(Astro.url);
-    ---
-    <html lang={lang}>
-        <head>
-            <meta charset="utf-8" />
-            <link rel="icon" type="image/svg+xml" href="/favicon.svg" />
-            <meta name="viewport" content="width=device-width" />
-            <title>Astro</title>
-        </head>
-        <body>
-            <slot />
-            <footer>
-              <LanguagePicker />
-            </footer>
-        </body>
-    </html>
-    ```
-
-### Ocultar el idioma predeterminado en la URL
-
-1. Crea un directorio para cada idioma, excepto el idioma predeterminado. Por ejemplo, guarda las páginas en tu idioma predeterminado directamente en `pages/`, y las páginas traducidas en `fr/`:
-
-    <FileTree>
-    - src/
-      - pages/
-        - about.astro
-        - index.astro
-        - **fr/**
-          - about.astro
-          - index.astro
-    </FileTree>
-
-2. Añade otra línea al archivo `src/i18n/ui.ts` para activar o desactivar la función:
-
-    ```ts
-    // src/i18n/ui.ts
-    export const showDefaultLang = false;
-    ```
-
-
-3. Agrega una función auxiliar al archivo `src/i18n/utils.ts` para traducir rutas según el idioma actual:
-
-   ```js
-   // src/i18n/utils.ts
-   import { ui, defaultLang, showDefaultLang } from './ui';
-
-   export function useTranslatedPath(lang: keyof typeof ui) {
-     return function translatePath(path: string, l: string = lang) {
-       return !showDefaultLang && l === defaultLang ? path : `/${l}${path}`
-     }
-   }
-   ```
-
-4. Importa la función auxiliar donde sea necesario. Por ejemplo, un componente `nav` podría verse así:
-
-    ```astro 
-    ---
-    // src/components/Nav.astro
-    import { getLangFromUrl, useTranslations, useTranslatedPath } from '../i18n/utils';
-    
-    const lang = getLangFromUrl(Astro.url);
-    const t = useTranslations(lang);
-    const translatePath = useTranslatedPath(lang);
-    ---
-    <ul>
-        <li>
-            <a href={translatePath('/home/')}>
-              {t('nav.home')}
-            </a>
-        </li>
-        <li>
-            <a href={translatePath('/about/')}>
-              {t('nav.about')}
-            </a>
-        </li>
-        <li>
-            <a href="https://twitter.com/astrodotbuild">
-              {t('nav.twitter')}
-            </a>
-        </li>
-    </ul>
-    ```
-
-5. La función auxiliar también puede utilizarse para traducir rutas para un idioma específico. Por ejemplo, cuando los usuarios cambian entre idiomas:
-
-    ```astro
-    ---
-    // src/components/LanguagePicker.astro
-    import { languages } from '../i18n/ui';
-    import { getLangFromUrl, useTranslatedPath } from '../i18n/utils';
-    
-    const lang = getLangFromUrl(Astro.url);
-    const translatePath = useTranslatedPath(lang);
-    ---
-    <ul>
-      {Object.entries(languages).map(([lang, label]) => (
-        <li>
-          <a href={translatePath('/', lang)}>{label}</a>
-        </li>
-      ))}
-    </ul>
-    ```
-
-### Traducir Rutas
-
-Traduce las rutas de tus páginas para cada idioma.
-
-1. Añade mappings de rutas al archivo `src/i18n/ui.ts`:
-
-    ```ts
-    // src/i18n/ui.ts
-    export const routes = {
-      de: {
-        'services': 'leistungen',
-      },
-      fr: {
-        'services': 'prestations-de-service',
-      },
-    }
-    ```
-
-2. Actualiza la función auxiliar `useTranslatedPath` en el archivo `src/i18n/utils.ts` para agregar la lógica de traducción de enrutamiento.
-    
-    ```js
-    // src/i18n/utils.ts
-    import { ui, defaultLang, showDefaultLang, routes } from './ui';
-
-    export function useTranslatedPath(lang: keyof typeof ui) {
-      return function translatePath(path: string, l: string = lang) {
-        const pathName = path.replaceAll('/', '');
-        const hasTranslation = defaultLang !== l && routes[l] !== undefined && routes[l][pathName] !== undefined
-        const translatedPath = hasTranslation ? '/' + routes[l][pathName] : path
-
-        return !showDefaultLang && l === defaultLang ? translatedPath : `/${l}${translatedPath}`
-      }
-    }
-    ```
-
-3. Crea una función auxiliar para obtener la ruta, si existe, basada en la URL actual en el archivo `src/i18n/utils.ts`:
-
-    ```js
-    // src/i18n/utils.ts
-    import { ui, defaultLang, showDefaultLang, routes } from './ui';
-
-    export function getRouteFromUrl(url: URL): string | undefined {
-      const pathname = new URL(url).pathname;
-      const parts = pathname?.split('/');
-      const path = parts.pop() || parts.pop();
-
-      if (path === undefined) {
-        return undefined;
-      }
-
-      const currentLang = getLangFromUrl(url);
-
-      if (defaultLang === currentLang) {
-        const route = Object.values(routes)[0];
-        return route[path] !== undefined ? route[path] : undefined;
-      }
-
-      const getKeyByValue = (obj: Record<string, string>, value: string): string | undefined  => {
-          return Object.keys(obj).find((key) => obj[key] === value);
-      }
-
-      const reversedKey = getKeyByValue(routes[currentLang], path);
-
-      if (reversedKey !== undefined) {
-        return reversedKey;
-      }
-
-      return undefined;
-    }
-    ```
-
-4. La función auxiliar se puede utilizar para obtener una ruta traducida. Por ejemplo, cuando no se define una ruta traducida, el usuario será redirigido a la página de inicio:
-
-    ```astro
-    ---
-    // src/components/LanguagePicker.astro
-    import { languages } from '../i18n/ui';
-    import { getRouteFromUrl } from '../i18n/utils';
-    const route = getRouteFromUrl(Astro.url);
-    ---
-    <ul>
-      {Object.entries(languages).map(([lang, label]) => (
-        <li>
-          <a href={translatePath(`/${route ? route : ''}`, lang)}>{label}</a>
-        </li>
-      ))}
-    </ul>
-    ```
-
-## Recursos
-- [Choosing a Language Tag](https://www.w3.org/International/questions/qa-choosing-language-tags)
-- [Right-to-left Styling 101](https://rtlstyling.com/)
-
-## Bibliotecas comunitarias
-- [astro-i18next](https://github.com/yassinedoghri/astro-i18next) — An Astro integration for i18next including some utility components.
-- [astro-i18n](https://github.com/alexandre-fernandez/astro-i18n) — A TypeScript-first internationalization library for Astro.
-- [astro-i18n-aut](https://github.com/jlarmstrongiv/astro-i18n-aut) — An Astro integration for i18n that supports the `defaultLocale` without page generation. The integration is adapter agnostic and UI framework agnostic.
-- [paraglide](https://inlang.com/c/astro) — Una biblioteca con seguridad de tipos completa para i18n, diseñada específicamente para patrones de hidratación parcial como las islas de Astro.
diff --git a/src/content/docs/es/recipes/making-toolbar-apps.mdx b/src/content/docs/es/recipes/making-toolbar-apps.mdx
index 8313089365bf3..bab05d6261af7 100644
--- a/src/content/docs/es/recipes/making-toolbar-apps.mdx
+++ b/src/content/docs/es/recipes/making-toolbar-apps.mdx
@@ -61,7 +61,7 @@ Las aplicaciones de barra de herramientas para desarrollo sólo pueden ser agreg
     </FileTree>
 
 
-2. En `my-integration.ts`, agrega el siguiente código para proveer el nombre de tu integración y la [función `addDevToolbarApp()`](/es/reference/dev-toolbar-app-reference/#agregando-apps) que añadirá tu aplicación de barra de herramientas con el hook `astro:config:setup`:
+2. En `my-integration.ts`, agrega el siguiente código para proveer el nombre de tu integración y la [función `addDevToolbarApp()`](/es/reference/dev-toolbar-app-reference/#adddevtoolbarapp) que añadirá tu aplicación de barra de herramientas con el hook `astro:config:setup`:
 
     ```ts title="my-toolbar-app/my-integration.ts" "'astro:config:setup'" "hooks" "addDevToolbarApp"
     import { fileURLToPath } from 'node:url';
diff --git a/src/content/docs/es/recipes/modified-time.mdx b/src/content/docs/es/recipes/modified-time.mdx
deleted file mode 100644
index 1b1bc76e11d4d..0000000000000
--- a/src/content/docs/es/recipes/modified-time.mdx
+++ /dev/null
@@ -1,144 +0,0 @@
----
-title: Agrega la hora de última modificación
-description: Crea un plugin de remark para agregar la hora de última modificación a tu Markdown y MDX
-i18nReady: true
-type: recipe
----
-
-import PackageManagerTabs from '~/components/tabs/PackageManagerTabs.astro'
-
-Aprende cómo construir un [plugin de remark](https://github.com/remarkjs/remark) que añade la hora de última modificación al frontmatter de tus archivos Markdown y MDX. Utiliza esta propiedad para mostrar la hora de modificación en tus páginas.
-
-## Receta
-
-1. Instala los paquetes auxiliares
-
-   Instala [`Day.js`](https://www.npmjs.com/package/dayjs) para modificar y formatear tiempos:
-
-   <PackageManagerTabs>
-     <Fragment slot="npm">
-       ```shell
-       npm install dayjs
-       ```
-     </Fragment>
-     <Fragment slot="pnpm">
-       ```shell
-       pnpm add dayjs
-       ```
-     </Fragment>
-     <Fragment slot="yarn">
-       ```shell
-       yarn add dayjs
-       ```
-     </Fragment>
-   </PackageManagerTabs>
-
-2. Crea un Plugin de Remark
-
-   Este plugin utiliza `execSync` para ejecutar un comando de Git que devuelve la marca de tiempo del último commit en formato ISO 8601. Luego, esta marca de tiempo se agrega al frontmatter del archivo.
-
-     ```js title="remark-modified-time.mjs"
-     import { execSync } from "child_process";
-
-     export function remarkModifiedTime() {
-       return function (tree, file) {
-         const filepath = file.history[0];
-         const result = execSync(`git log -1 --pretty="format:%cI" "${filepath}"`);
-         file.data.astro.frontmatter.lastModified = result.toString();
-       };
-     }
-     ```
-		<details>
-		<summary>Utilizando el sistema de archivos en lugar de Git</summary>
-
-      Aunque se recomienda utilizar Git para obtener la marca de tiempo de última modificación de un archivo, es posible utilizar el tiempo de modificación del sistema de archivos.
-     Este complemento utiliza `statSync` para obtener el `mtime` (tiempo de modificación) del archivo en formato ISO 8601. Luego, esta marca de tiempo se agrega al frontmatter del archivo.
-     
-     ```js title="remark-modified-time.mjs"
-     import { statSync } from "fs";
-
-     export function remarkModifiedTime() {
-       return function (tree, file) {
-         const filepath = file.history[0];
-         const result = statSync(filepath);
-         file.data.astro.frontmatter.lastModified = result.mtime.toISOString();
-       };
-     }
-     ```
-		</details>
-
-3. Añade el plugin a tu config
-
-   ```js title="astro.config.mjs"
-   import { defineConfig } from 'astro/config';
-   import { remarkModifiedTime } from './remark-modified-time.mjs';
-
-   export default defineConfig({
-     markdown: {
-       remarkPlugins: [remarkModifiedTime],
-     },
-   });
-   ```
-
-   Ahora, todos los documentos Markdown tendrán una propiedad `lastModified` en su frontmatter.
-
-4. Muestra la hora de última modificación
-
-   Si tu contenido está almacenado en una [colección de contenido](/es/guides/content-collections/), accede a `remarkPluginFrontmatter` desde la función `entry.render()`. Luego, renderiza `lastModified` en tu plantilla donde desees que aparezca.
-
-   ```astro title="src/pages/posts/[slug].astro" {3-4,6,17,19-21,28}
-   ---
-   import { CollectionEntry, getCollection } from 'astro:content';
-   import dayjs from "dayjs";
-   import utc from "dayjs/plugin/utc";
-
-   dayjs.extend(utc);
-
-   export async function getStaticPaths() {
-     const blog = await getCollection('blog');
-     return blog.map(entry => ({
-       params: { slug: entry.slug },
-       props: { entry },
-     }));
-   }
-
-   const { entry } = Astro.props;
-   const { Content, remarkPluginFrontmatter } = await entry.render();
-
-   const lastModified = dayjs(remarkPluginFrontmatter.lastModified)
-     .utc()
-     .format("HH:mm:ss DD MMMM YYYY UTC");
-   ---
-
-   <html>
-     <head>...</head>
-     <body>
-       ...
-       <p>Última modificación: {lastModified}</p>
-       ...
-     </body>
-   </html>
-   ```
-
-   Si estás utilizando una [plantilla de Markdown](/es/guides/markdown-content/#páginas-de-markdown-y-mdx), utiliza la propiedad `lastModified` del frontmatter desde `Astro.props` en tu plantilla de diseño.
-
-   ```astro title="src/layouts/BlogLayout.astro" {2-3,5,7-9,15}
-   ---
-   import dayjs from "dayjs";
-   import utc from "dayjs/plugin/utc";
-
-   dayjs.extend(utc);
-
-   const lastModified = dayjs()
-     .utc(Astro.props.frontmatter.lastModified)
-     .format("HH:mm:ss DD MMMM YYYY UTC");
-   ---
-
-   <html>
-     <head>...</head>
-     <body>
-       <p>{lastModified}</p>
-       <slot />
-     </body>
-   </html>
-   ```
diff --git a/src/content/docs/es/recipes/reading-time.mdx b/src/content/docs/es/recipes/reading-time.mdx
deleted file mode 100644
index a1a964f489044..0000000000000
--- a/src/content/docs/es/recipes/reading-time.mdx
+++ /dev/null
@@ -1,116 +0,0 @@
----
-title: Agregar tiempo de lectura
-description: Construye un plugin de remark para añadir tiempo de lectura a tus archivos Markdown o MDX.
-i18nReady: true
-type: recipe
----
-
-import PackageManagerTabs from '~/components/tabs/PackageManagerTabs.astro'
-
-Crea un plugin de [remark](https://github.com/remarkjs/remark) que añada una propiedad de tiempo de lectura al frontmatter de tus archivos Markdown o MDX. Utiliza esta propiedad para mostrar el tiempo de lectura de cada página.
-
-## Receta
-
-1. Instalar paquetes auxiliares
-
-  Instala estos dos paquetes auxiliares:
-  - [`reading-time`](https://www.npmjs.com/package/reading-time) para calcular el tiempo de lectura en minutos
-  - [`mdast-util-to-string`](https://www.npmjs.com/package/mdast-util-to-string) para extraer todo el texto de tu documento Markdown
-
-  <PackageManagerTabs>
-    <Fragment slot="npm">
-    ```shell
-  npm install reading-time mdast-util-to-string
-    ```
-    </Fragment>
-    <Fragment slot="pnpm">
-    ```shell
-  pnpm add reading-time mdast-util-to-string
-    ```
-    </Fragment>
-    <Fragment slot="yarn">
-    ```shell
-  yarn add reading-time mdast-util-to-string
-    ```
-    </Fragment>
-  </PackageManagerTabs>
-
-2. Crear un plugin de remark
-
-  Este plugin utiliza el paquete `mdast-util-to-string` para obtener el texto del archivo Markdown. Luego, este texto se pasa al paquete `reading-time` para calcular el tiempo de lectura en minutos.
-
-  ```js title="remark-reading-time.mjs"
-  import getReadingTime from 'reading-time';
-  import { toString } from 'mdast-util-to-string';
-
-  export function remarkReadingTime() {
-    return function (tree, { data }) {
-      const textOnPage = toString(tree);
-      const readingTime = getReadingTime(textOnPage);
-      // readingTime.text nos dará el tiempo de lectura en minutos como un  string legible,
-      // p. ej. "3 min read"
-      data.astro.frontmatter.minutesRead = readingTime.text;
-    };
-  }
-  ```
-
-3. Agrega el plugin a tu configuración de la siguiente manera:
-
-  ```js title="astro.config.mjs" "import { remarkReadingTime } from './remark-reading-time.mjs';" "remarkPlugins: [remarkReadingTime],"
-  import { defineConfig } from 'astro/config';
-  import { remarkReadingTime } from './remark-reading-time.mjs';
-
-  export default defineConfig({
-    markdown: {
-      remarkPlugins: [remarkReadingTime],
-    },
-  });
-  ```
-
-  Ahora todos los documentos Markdown tendrán una propiedad calculada `minutesRead` en su frontmatter.
-
-4. Mostrar tiempo de lectura
-
-Si tus publicaciones de blog están almacenadas en una [colección de contenido](/es/guides/content-collections/), accede a `remarkPluginFrontmatter` desde la función `entry.render()`. Luego, muestra `minutesRead` en tu plantilla donde desees que aparezca.
-
-  ```astro title="src/pages/posts/[slug].astro" "const { Content, remarkPluginFrontmatter } = await entry.render();" "<p>{remarkPluginFrontmatter.minutesRead}</p>"
-  ---
-  import { CollectionEntry, getCollection } from 'astro:content';
-
-  export async function getStaticPaths() {
-    const blog = await getCollection('blog');
-    return blog.map(entry => ({
-      params: { slug: entry.slug },
-      props: { entry },
-    }));
-  }
-
-  const { entry } = Astro.props;
-  const { Content, remarkPluginFrontmatter } = await entry.render();
-  ---
-
-  <html>
-    <head>...</head>
-    <body>
-      ...
-      <p>{remarkPluginFrontmatter.minutesRead}</p>
-      ...
-    </body>
-  </html>
-  ```
-
-  Si estás utilizando una [plantilla de Markdown](/es/guides/markdown-content/#páginas-de-markdown-y-mdx), utiliza la propiedad `minutesRead` del frontmatter desde `Astro.props` en tu plantilla de diseño.
-
-  ```astro title="src/layouts/BlogLayout.astro" "const { minutesRead } = Astro.props.frontmatter;" "<p>{minutesRead}</p>"
-  ---
-  const { minutesRead } = Astro.props.frontmatter;
-  ---
-
-  <html>
-    <head>...</head>
-    <body>
-      <p>{minutesRead}</p>
-      <slot />
-    </body>
-  </html>
-  ```
diff --git a/src/content/docs/es/recipes/rss.mdx b/src/content/docs/es/recipes/rss.mdx
deleted file mode 100644
index e54de1f5cd9bc..0000000000000
--- a/src/content/docs/es/recipes/rss.mdx
+++ /dev/null
@@ -1,278 +0,0 @@
----
-title: RSS
-description: Agrega un feed RSS a tu sitio Astro para permitir que los usuarios se suscriban a tu contenido.
-i18nReady: true
-type: recipe
----
-import Since from '~/components/Since.astro';
-import { Steps } from '@astrojs/starlight/components';
-import PackageManagerTabs from '~/components/tabs/PackageManagerTabs.astro';
-
-Astro proporciona una generación rápida y automática de feeds RSS para blogs u otros sitios web con mucho contenido. Los feeds RSS proporcionan una forma fácil para que los usuarios se suscriban a tu contenido.
-
-## Configurando `@astrojs/rss`
-
-El paquete [`@astrojs/rss`](https://github.com/withastro/astro/tree/main/packages/astro-rss) provee helpers para generar RSS feeds utilizando [API endpoints](/es/guides/endpoints/#endpoints-de-archivos-estáticos). Esto desbloquea la generación de RSS feeds para builds estáticos _y_ on-demand para cuando utilizamos un [adaptador SSR](/es/guides/on-demand-rendering/).
-
-<Steps>
-1. Instala `@astrojs/rss` utilizando tu gestor de paquetes favorito:
-
-    <PackageManagerTabs>
-      <Fragment slot="npm">
-      ```shell
-      npm install @astrojs/rss
-      ```
-      </Fragment>
-      <Fragment slot="pnpm">
-      ```shell
-      pnpm add @astrojs/rss
-      ```
-      </Fragment>
-      <Fragment slot="yarn">
-      ```shell
-      yarn add @astrojs/rss
-      ```
-      </Fragment>
-    </PackageManagerTabs>
-
-    :::tip
-    Asegurate de haber [configurado un `site`](/es/reference/configuration-reference/#site) en el `astro.config` de tu proyecto. Lo usarás para generar links a tus artículos RSS.
-    :::
-
-2. Crea un archivo en `src/pages/` con un nombre de tu elección y la extensión `.xml.js` para ser utilizado como la URL de salida de tu feed. Algunos nombres comunes de URL de feed RSS son `feed.xml` o `rss.xml`.
-
-    El archivo de ejemplo a continuación `src/pages/rss.xml.js` creará un feed RSS en `site/rss.xml`.
-
-3. Importa el helper `rss()` del paquete `@astrojs/rss` en tu archivo `.xml.js` y exporta una función que lo devuelve utilizando los siguientes parámetros:
-
-    ```js title="src/pages/rss.xml.js"
-    import rss from '@astrojs/rss';
-
-    export function GET(context) {
-      return rss({
-        // `<title>` campo en el xml generado
-        title: 'Blog de Buzz',
-        // `<description>` campo en el xml generado
-        description: 'Guía de un humilde astronauta a las estrellas',
-        // Usa el "site" desde el contexto del endpoint
-        // https://docs.astro.build/en/reference/api-reference/#contextsite
-        site: context.site,
-        // Array de `<item>`s en el xml generado
-        // Consulta la sección "Generando `items`" para ejemplos utilizando colecciones de contenido y glob imports
-        items: [],
-        // (opcional) inyecta xml personalizado
-        customData: `<language>es</language>`,
-      });
-    }
-    ```
-</Steps>
-
-## Generando `items`
-
-El campo `items` acepta una lista de objetos de feed RSS, que pueden ser generados a partir de las entradas de colecciones de contenido utilizando `getCollection()` o desde tus archivos de página utilizando `pagesGlobToRssItems()`.
-
-El formato estándar de RSS feed incluye los siguientes valores para cada item publicado:
-
-- `title`: El título de la entrada. Opcional solo si se establece una `description`. De lo contrario, requerido.
-- `description`: Un breve extracto de o describiendo la entrada. Opcional solo si se establece un `title`. De lo contrario, requerido.
-- `link`: Una URL a la fuente original de la entrada. (opcional)
-- `pubDate`: La fecha de publicación de la entrada. (opcional)
-- `content`: El contenido completo de tu post. (opcional)
-- `customData`: Un campo para incluir cualquier dato extra, como otras propiedades de frontmatter de tus posts de blog.
-
-### Usando colecciones de contenido
-
-Para crear un RSS feed de páginas manejadas en [colecciones de contenido](/es/guides/content-collections/), utiliza la función `getCollection()` para recuperar la lista de tus artículos. Necesitarás especificar los valores para cada propiedad deseada (ej. `title`, `description`) de los datos devueltos.
-
-```js title="src/pages/rss.xml.js" "items:" "const blog = await getCollection('blog');"
-export async function GET(context) {
-  const blog = await getCollection('blog');
-  return rss({
-    title: 'Blog de Buzz',
-    description: 'Guía de un humilde astronauta a las estrellas',
-    site: context.site,
-    items: blog.map((post) => ({
-      title: post.data.title,
-      pubDate: post.data.pubDate,
-      description: post.data.description,
-      customData: post.data.customData,
-      // Calcula el link RSS desde el `slug` del post 
-      // Este ejemplo asume que todos los posts son renderizados como rutas `/blog/[slug]`
-      link: `/blog/${post.slug}/`,
-    })),
-  });
-}
-```
-
-Opcional: reemplaza tu esquema de colección de blog existente para cumplir con las propiedades de RSS esperadas.
-
-Para asegurarte de que cada entrada de blog produzca un elemento de feed RSS válido, puedes importar y aplicar opcionalmente `rssSchema` en lugar de definir cada propiedad individual de tu esquema.
-
-```js title="src/content/config.ts" "rssSchema"
-import { rssSchema } from '@astrojs/rss';
-const blog = defineCollection({
-  schema: rssSchema,
-});
-
-export const collections = { blog };
-```
-
-### Usando glob imports
-
-<p><Since v="2.1.0" pkg="@astrojs/rss" /></p>
-
-Para crear un RSS feed de documentos en `src/pages/`, utiliza la función `pagesGlobToRssItems()`. Esta acepta un resultado de [`import.meta.glob`](https://vite.dev/guide/features.html#glob-import) y devuelve un array de items RSS válidos (consulta [más sobre escribir patrones glob](/es/guides/imports/#patrones-glob) para especificar qué páginas incluir).
-
-:::caution
-Esta función asume, pero no verifica, que todas las propiedades RSS necesarias están presentes en el frontmatter de cada documento. Si encuentras errores, verifica manualmente el frontmatter de cada página.
-:::
-
-```js title="src/pages/rss.xml.js" "pagesGlobToRssItems" "await pagesGlobToRssItems("
-import rss, { pagesGlobToRssItems } from '@astrojs/rss';
-export async function GET(context) {
-  return rss({
-    title: 'Blog de Buzz',
-    description: 'Guía de un humilde astronauta a las estrellas',
-    site: context.site,
-    items: await pagesGlobToRssItems(
-      import.meta.glob('./blog/*.{md,mdx}'),
-    ),
-  });
-}
-```
-
-:::note[¿Estás usando una versión anterior?]
-En versiones de `@astrojs/rss` anteriores a la v2.1.0, pasa tu resultado de glob directamente a `items` sin el wrapper `pagesGlobToRssItems()`:
-```js
-items: import.meta.glob('./blog/*.{md,mdx}'),
-```
-
-Este método es obsoleto para todas las versiones de Astro desde la v2.1.0 y no puede ser utilizado en proyectos modernos.
-:::
-
-### Incluyendo contenido completo de un artículo
-
-<p><Since v="1.6.14" /></p>
-
-La llave `content` contiene el contenido completo del post como HTML. Esto te permite hacer disponible todo el contenido del post a los lectores de RSS.
-
-:::tip
-Un paquete como [`sanitize-html`](https://www.npmjs.com/package/sanitize-html) se asegurará de que tu contenido esté correctamente sanitizado, escapado y codificado. En el proceso, este paquete podría remover algunos elementos y atributos inofensivos, así que asegurate de verificar la salida y configurar el paquete de acuerdo a tus necesidades.
-:::
-
-Cuando utilices colecciones de contenido, renderiza el `body` del post usando un parser de Markdown estándar como [`markdown-it`](https://github.com/markdown-it/markdown-it) y desinfecta el resultado, incluyendo cualquier etiqueta (e.g. `<img>`) necesaria para renderizar tu componente:
-
-```js title="src/pages/rss.xml.js" ins={2, 3, 4, 15}
-import rss from '@astrojs/rss';
-import sanitizeHtml from 'sanitize-html';
-import MarkdownIt from 'markdown-it';
-const parser = new MarkdownIt();
-
-export async function GET(context) {
-  const blog = await getCollection('blog');
-  return rss({
-    title: 'Blog de Buzz',
-    description: 'Guía de las estrellas para un humilde astronauta',
-    site: context.site,
-    items: blog.map((post) => ({
-      link: `/blog/${post.slug}/`,
-      // Nota: esto no procesará componentes ni expresiones JSX en archivos MDX.
-      content: sanitizeHtml(parser.render(post.body), {
-        allowedTags: sanitizeHtml.defaults.allowedTags.concat(['img'])
-      }),
-      ...post.data,
-    })),
-  });
-}
-```
-
-Cuando utilices imports glob con Markdown, puedes utilizar el helper `compiledContent()` para recuperar el HTML renderizado para desinfectarlo. Nota: esta función **no** es compatible con archivos MDX.
-
-```js title="src/pages/rss.xml.js" ins={2, 13}
-import rss from '@astrojs/rss';
-import sanitizeHtml from 'sanitize-html';
-
-export function GET(context) {
-  const postImportResult = import.meta.glob('../posts/**/*.md', { eager: true }); 
-  const posts = Object.values(postImportResult);
-  return rss({
-    title: 'Blog de Buzz',
-    description: 'Guía de un humilde astronauta a las estrellas',
-    site: context.site,
-    items: posts.map((post) => ({
-      link: post.url,
-      content: sanitizeHtml(post.compiledContent()),
-      ...post.frontmatter,
-    })),
-  });
-}
-```
-
-## Eliminando las barras diagonales finales
-
-El feed RSS de Astro produce enlaces con una barra diagonal al final por defecto, sin importar el valor que hayas configurado para `trailingSlash`. Esto significa que los enlaces de tu RSS pueden no coincidir exactamente con las URLs de tus posts.
-
-Si has configurado `trailingSlash: "never"` en tu `astro.config.mjs`, establece `trailingSlash: false` en el helper `rss()` para que tu feed coincida con la configuración de tu proyecto.
-
-```ts title="src/pages/rss.xml.js" ins={9}
-import rss from '@astrojs/rss';
-
-export function GET(context) {
-  const posts = Object.values(postImportResult);
-  return rss({
-    title: 'Blog de Buzz',
-    description: 'Guía de un humilde astronauta a las estrellas',
-    site: context.site,
-    trailingSlash: false,
-    items: posts.map((post) => ({
-      link: post.url,
-      ...post.frontmatter,
-    })),
-  });
-}
-```
-
-
-## Añadiendo una hoja de estilos
-
-Puedes estilar tu RSS feed para proveer una experiencia de usuario más placentera a la hora de ver el archivo en el navegador.
-
-Utiliza la opción `stylesheet` de la helper function `rss` para especificar un path absoluto a tu hoja de estilos.
-
-```js
-rss({
-  // ej. utiliza tus estilos de "public/rss/styles.xsl"
-  stylesheet: '/rss/styles.xsl',
-  // ...
-});
-```
-
-:::tip
-Si prefieres no crear tu propia hoja de estilos, puedes utilizar una hoja de estilos predefinida como la [hoja de estilos predeterminada de Pretty Feed v3](https://github.com/genmon/aboutfeeds/blob/main/tools/pretty-feed-v3.xsl). Descarga la hoja de estilos desde GitHub y guárdala en el directorio `public/` de tu proyecto.
-:::
-
-## Detección automática de fuentes RSS
-
-[RSS autodiscovery](https://www.rssboard.org/rss-autodiscovery) permite a los navegadores y otros programas encontrar automáticamente el canal RSS de un sitio a partir de la URL principal.
-
-Para habilitarlo, agregue una etiqueta `<link>` con los siguientes atributos al elemento `head` de su sitio.
-
-```jsx
-<link
-    rel="alternate"
-    type="application/rss+xml"
-    title="Título de su sitio web"
-    href={`${Astro.site}rss.xml`}
-/>
-```
-
-Con esta etiqueta, los lectores de tu blog pueden introducir la URL base de tu sitio en su lector RSS para suscribirse a tus entradas sin necesidad de la URL específica de tu canal RSS.
-
-## Siguientes pasos
-
-Después de visitar tu feed en el navegador en `your-domain.com/rss.xml` y confirmar que puedes ver datos para cada una de tus publicaciones, ahora puedes [promocionar tu feed en tu sitio web](https://medium.com/samsung-internet-dev/add-rss-feeds-to-your-website-to-keep-your-core-readers-engaged-3179dca9c91e#:~:text=com/~deno%2Drss-,Advertising%20your%20RSS%20feed,-Now%20you%20have). Agregar el icono estándar de RSS a tu sitio informa a tus lectores que pueden suscribirse a tus publicaciones en su propio lector de feeds.
-
-
-## Recursos
-
-- [Feeds RSS](https://aboutfeeds.com/)
diff --git a/src/content/docs/es/recipes/sharing-state-islands.mdx b/src/content/docs/es/recipes/sharing-state-islands.mdx
deleted file mode 100644
index f04fe56371363..0000000000000
--- a/src/content/docs/es/recipes/sharing-state-islands.mdx
+++ /dev/null
@@ -1,822 +0,0 @@
----
-title: Comparte el estado entre Islas
-description: Aprende a compartir estado entre componentes de framework con Nano Stores.
-i18nReady: true
-type: recipe
----
-
-import UIFrameworkTabs from '~/components/tabs/UIFrameworkTabs.astro'
-import LoopingVideo from '~/components/LoopingVideo.astro'
-import JavascriptFlavorTabs from '~/components/tabs/JavascriptFlavorTabs.astro'
-import RecipeLinks from "~/components/RecipeLinks.astro"
-
-Al construir tu proyecto usando la [arquitectura de islas / hidratación parcial](/es/concepts/islands/), puede que te hayas topado con este problema: **Quiero compartir estado entre mis componentes.**
-
-Frameworks tales como React o Vue pueden alentar a usar [proveedores de "contexto"](https://react.dev/learn/passing-data-deeply-with-context) ("context" providers) para que sea consumido por otros componentes. Pero al [hidratar componentes parcialmente](/es/guides/framework-components/#hidratando-componentes-interactivos) dentro de Astro o en Markdown, no puedes usar esos contextos envolventes.
-
-Astro recomienda una solución diferente para el almacenamiento compartido en el lado del cliente: [**Nano Stores**](https://github.com/nanostores/nanostores).
-
-<RecipeLinks slugs={["es/recipes/sharing-state"]} />
-
-## ¿Por qué Nano Stores?
-
-La librería [Nano Stores](https://github.com/nanostores/nanostores) te permite crear _stores_ con las que cualquier componente puede interactuar. Recomendamos Nano Stores porque:
-- **Son livianas.** Nano Stores tiene la cantidad mínima de JS que puedas llegar a requerir (menos de 1 KB) con cero dependencias.
-- **Son framework-agnósticas.** ¡Esto significa que puedes compartir estado entre _frameworks_ sin contratiempos! Astro está construido para ser flexible, así que amamos las soluciones que ofrecen una experiencia de desarrollo similar, sin importar tu preferencia.
-
-Aun así, hay otras alternativas a explorar. Entre ellas puedes encontrar:
-- [Svelte stores incorporadas](https://svelte.dev/tutorial/writable-stores)
-- [Solid signals](https://www.solidjs.com/docs/latest) fuera de un elemento de contexto
-- [API de reactividad de Vue](https://vuejs.org/guide/scaling-up/state-management.html#simple-state-management-with-reactivity-api)
-- [Enviar eventos personalizados del navegador](https://developer.mozilla.org/es/docs/Web/Events/Creating_and_triggering_events) entre componentes
-
-:::note[FAQ]
-
-<details>
-<summary>**🙋 ¿Puedo usar Nano Stores en archivos `.astro` u otros archivos del lado del servidor?**</summary>
-
-Las Nano Stores _pueden_ ser importadas, escritas y leídas desde componentes del lado del servidor, **¡aunque no lo recomendamos!**. Esto se debe a ciertas restricciones:
-- Escribir en un store desde un archivo `.astro` o un [componente no-hidratado](/es/guides/framework-components/#hidratando-componentes-interactivos) _no_ afectará el valor recibido por un [componente del lado del cliente](/es/reference/directives-reference/#directivas-del-cliente).
-- No puedes pasar una Nano Store como "prop" a componentes del lado del cliente.
-- No puedes suscribirte a cambios en la store desde un archivo `.astro`, ya que los componentes de Astro no se re-renderizan.
-
-¡Si entiendes estas restricciones y aun así encuentras un caso de uso, puedes darle una oportunidad a Nano Stores! Solamente recuerda que Nano Stores fue creado específicamente para reaccionar a cambios en el **cliente**.
-
-</details>
-
-<details>
-<summary>**🙋 ¿Cómo se comparan las Svelte stores a Nano Stores?**</summary>
-
-**¡Nano Stores y [Svelte stores](https://svelte.dev/tutorial/writable-stores) son muy similares!** De hecho, [nanostores te permite usar el mismo atajo `$`](https://github.com/nanostores/nanostores#svelte) para suscripciones que puedes utilizar con las Svelte stores.
-
-Si quieres evitar usar una librería de terceros, [Svelte stores](https://svelte.dev/tutorial/writable-stores) es una gran herramienta para la comunicación entre islas. Aun así, puedes llegar a preferir Nano Stores si a) te gustaría añadir add-ons para ["objetos"](https://github.com/nanostores/nanostores#maps) y [estado asíncrono](https://github.com/nanostores/nanostores#lazy-stores), o b) quieres comunicarte entre Svelte y otros frameworks como Preact o Vue.
-</details>
-
-<details>
-<summary>**🙋 ¿Cómo se comparan las Solid signals a Nano Stores?**</summary>
-
-Si has usado Solid anteriormente, habrás intentado mover [signals](https://www.solidjs.com/docs/latest#createsignal) o [stores](https://www.solidjs.com/docs/latest#createstore) fuera de tus componentes. ¡Esta es una muy buena manera de compartir estado entre islas de Solid! Intenta exportar signals desde un archivo compartido:
-
-```js
-// sharedStore.js
-import { createSignal } from 'solid-js';
-
-export const sharedCount = createSignal(0);
-```
-...y todos los componentes que importen `sharedCount` compartirán el mismo estado. Aunque esto funciones bien, puedes llegar a preferir Nano Stores si a) te gustaría añadir add-ons para ["objetos"](https://github.com/nanostores/nanostores#maps) y [estado asíncrono](https://github.com/nanostores/nanostores#lazy-stores), o b) quieres comunicarte entre Solid y otros frameworks como Preact or Vue.
-</details>
-:::
-
-## Instalando Nano Stores
-
-Para empezar, instala Nano Stores junto al paquete helper para tu framework favorito:
-
-<UIFrameworkTabs>
-  <Fragment slot="preact">
-  ```shell
-  npm install nanostores @nanostores/preact
-  ```
-  </Fragment>
-  <Fragment slot="react">
-  ```shell
-  npm install nanostores @nanostores/react
-  ```
-  </Fragment>
-  <Fragment slot="solid">
-  ```shell
-  npm install nanostores @nanostores/solid
-  ```
-  </Fragment>
-  <Fragment slot="svelte">
-  ```shell
-  npm install nanostores
-  ```
-  :::note
-  ¡No se necesita paquete helper aquí! Nano Stores puede ser usado como una Svelte store estándar.
-  :::
-  </Fragment>
-  <Fragment slot="vue">
-  ```shell
-  npm install nanostores @nanostores/vue
-  ```
-  </Fragment>
-  <Fragment slot="lit">
-  ```shell
-  npm install nanostores @nanostores/lit
-  ```
-  </Fragment>
-</UIFrameworkTabs>
-
-¡Desde aquí, puedes saltar directamente a la [guía de uso de Nano Stores](https://github.com/nanostores/nanostores#guide), o seguir nuestra guía con ejemplos!
-
-## Ejemplo de uso - menú desplegable con carrito de ecommerce
-
-Digamos que queremos construir una interfaz de ecommerce simple con tres elementos interactivos:
-- Un formulario para "agregar al carrito"
-- Un menú desplegable con carrito para mostrar esos ítems agregados
-- Un botón para desplegar el menú con carrito
-
-<LoopingVideo sources={[{ src: '/videos/stores-example.mp4', type: 'video/mp4' }]} />
-
-_[**Prueba el ejemplo terminado**](https://github.com/withastro/astro/tree/main/examples/with-nanostores) en tu máquina u online vía StackBlitz._
-
-Tu archivo base de Astro podría verse así:
-
-```astro
----
-// src/pages/index.astro
-import CartFlyoutToggle from '../components/CartFlyoutToggle';
-import CartFlyout from '../components/CartFlyout';
-import AddToCartForm from '../components/AddToCartForm';
----
-
-<!DOCTYPE html>
-<html lang="en">
-<head>...</head>
-<body>
-  <header>
-    <nav>
-      <a href="/">Tienda de Astro</a>
-      <CartFlyoutToggle client:load />
-    </nav>
-  </header>
-  <main>
-    <AddToCartForm client:load>
-    <!-- ... -->
-    </AddToCartForm>
-  </main>
-  <CartFlyout client:load />
-</body>
-</html>
-```
-
-### Usando "atoms"
-
-Empecemos por abrir nuestro `CartFlyout` cada vez que cliqueamos en `CartFlyoutToggle`.
-
-Primero, crea un nuevo archivo JS o TS para nuestro store. Usaremos un ["atom"](https://github.com/nanostores/nanostores#atoms) para esto:
-
-```js
-// src/cartStore.js
-import { atom } from 'nanostores';
-
-export const isCartOpen = atom(false);
-```
-
-Ahora, podemos importar este store dentro de cualquier archivo que necesite leer o escribir en ella. Comenzaremos conectando nuestro `CartFlyoutToggle`:
-
-<UIFrameworkTabs>
-<Fragment slot="preact">
-```jsx
-// src/components/CartFlyoutToggle.jsx
-import { useStore } from '@nanostores/preact';
-import { isCartOpen } from '../cartStore';
-
-export default function CartButton() {
-  // lee el valor del store con el hook `useStore`
-  const $isCartOpen = useStore(isCartOpen);
-  // escribe en el store importado usando `.set`
-  return (
-    <button onClick={() => isCartOpen.set(!$isCartOpen)}>Cart</button>
-  )
-}
-```
-</Fragment>
-<Fragment slot="react">
-```jsx
-// src/components/CartFlyoutToggle.jsx
-import { useStore } from '@nanostores/react';
-import { isCartOpen } from '../cartStore';
-
-export default function CartButton() {
-  // lee el valor del store con el hook `useStore`
-  const $isCartOpen = useStore(isCartOpen);
-  // escribe en el store importado usando `.set`
-  return (
-    <button onClick={() => isCartOpen.set(!$isCartOpen)}>Cart</button>
-  )
-}
-```
-</Fragment>
-<Fragment slot="solid">
-```jsx
-// src/components/CartFlyoutToggle.jsx
-import { useStore } from '@nanostores/solid';
-import { isCartOpen } from '../cartStore';
-
-export default function CartButton() {
-  // lee el valor del store con el hook `useStore`
-  const $isCartOpen = useStore(isCartOpen);
-  // escribe en el store importado usando `.set`
-  return (
-    <button onClick={() => isCartOpen.set(!$isCartOpen())}>Cart</button>
-  )
-}
-```
-</Fragment>
-<Fragment slot="svelte">
-```svelte
-<!--src/components/CartFlyoutToggle.svelte-->
-<script>
-  import { isCartOpen } from '../cartStore';
-</script>
-
-<!--usa "$" para leer el valor del store-->
-<button on:click={() => isCartOpen.set(!$isCartOpen)}>Cart</button>
-```
-</Fragment>
-<Fragment slot="vue">
-```vue
-<!--src/components/CartFlyoutToggle.vue-->
-<template>
-  <!--escribe en el store importado usando `.set`-->
-  <button @click="isCartOpen.set(!$isCartOpen)">Cart</button>
-</template>
-
-<script setup>
-  import { isCartOpen } from '../cartStore';
-  import { useStore } from '@nanostores/vue';
-
-  // lee el valor del store con el hook `useStore`
-  const $isCartOpen = useStore(isCartOpen);
-</script>
-```
-</Fragment>
-<Fragment slot="lit">
-```ts
-// src/components/CartFlyoutToggle.ts
-import { LitElement, html } from 'lit';
-import { isCartOpen } from '../cartStore';
-
-export class CartFlyoutToggle extends LitElement {
-  handleClick() {
-    isCartOpen.set(!isCartOpen.get());
-  }
-
-  render() {
-    return html`
-      <button @click="${this.handleClick}">Cart</button>
-    `;
-  }
-}
-
-customElements.define('cart-flyout-toggle', CartFlyoutToggle);
-```
-</Fragment>
-</UIFrameworkTabs>
-
-Luego, podemos leer el valor de `isCartOpen` en nuestro componente `CartFlyout`:
-
-<UIFrameworkTabs>
-<Fragment slot="preact">
-```jsx
-// src/components/CartFlyout.jsx
-import { useStore } from '@nanostores/preact';
-import { isCartOpen } from '../cartStore';
-
-export default function CartFlyout() {
-  const $isCartOpen = useStore(isCartOpen);
-
-  return $isCartOpen ? <aside>...</aside> : null;
-}
-```
-</Fragment>
-<Fragment slot="react">
-```jsx
-// src/components/CartFlyout.jsx
-import { useStore } from '@nanostores/react';
-import { isCartOpen } from '../cartStore';
-
-export default function CartFlyout() {
-  const $isCartOpen = useStore(isCartOpen);
-
-  return $isCartOpen ? <aside>...</aside> : null;
-}
-```
-</Fragment>
-<Fragment slot="solid">
-```jsx
-// src/components/CartFlyout.jsx
-import { useStore } from '@nanostores/solid';
-import { isCartOpen } from '../cartStore';
-
-export default function CartFlyout() {
-  const $isCartOpen = useStore(isCartOpen);
-
-  return $isCartOpen() ? <aside>...</aside> : null;
-}
-```
-</Fragment>
-<Fragment slot="svelte">
-```svelte
-<!--src/components/CartFlyout.svelte-->
-<script>
-  import { isCartOpen } from '../cartStore';
-</script>
-
-{#if $isCartOpen}
-<aside>...</aside>
-{/if}
-```
-</Fragment>
-<Fragment slot="vue">
-```vue
-<!--src/components/CartFlyout.vue-->
-<template>
-  <aside v-if="$isCartOpen">...</aside>
-</template>
-
-<script setup>
-  import { isCartOpen } from '../cartStore';
-  import { useStore } from '@nanostores/vue';
-
-  const $isCartOpen = useStore(isCartOpen);
-</script>
-```
-</Fragment>
-<Fragment slot="lit">
-```ts
-// src/components/CartFlyout.ts
-import { isCartOpen } from '../cartStore';
-import { LitElement, html } from 'lit';
-import { StoreController } from '@nanostores/lit';
-
-export class CartFlyout extends LitElement {
-  private cartOpen = new StoreController(this, isCartOpen);
-
-  render() {
-    return this.cartOpen.value ? html`<aside>...</aside>` : null;
-  }
-}
-
-customElements.define('cart-flyout', CartFlyout);
-
-```
-</Fragment>
-</UIFrameworkTabs>
-
-### Usando "maps"
-
-:::tip
-**¡Los [Maps](https://github.com/nanostores/nanostores#maps) son una muy buena opción para objetos que son escritos regularmente!** Junto a los helpers `get()` y `set()` estándar que provee un `atom`, también tendrás una función `.setKey()` para actualizar keys individuales en objetos.
-:::
-
-Ahora, llevemos la cuenta de los ítems que hay dentro de tu carrito. Para evitar duplicados y llevar el registro de la "cantidad", puedes guardar tu carrito como un objeto con el ID del ítem como key. Usaremos un [Map](https://github.com/nanostores/nanostores#maps) para lograr esto.
-
-Agreguemos un store `cartItem` a nuestro `cartStore.js` anterior. También puedes utilizar un archivo TypeScript si deseas definir el tipo de dato.
-
-<JavascriptFlavorTabs>
-  <Fragment slot="js">
-  ```js
-  // src/cartStore.js
-  import { atom, map } from 'nanostores';
-
-  export const isCartOpen = atom(false);
-
-  /**
-  * @typedef {Object} CartItem
-  * @property {string} id
-  * @property {string} name
-  * @property {string} imageSrc
-  * @property {number} quantity
-  */
-
-  /** @type {import('nanostores').MapStore<Record<string, CartItem>>} */
-  export const cartItems = map({});
-
-  ```
-  </Fragment>
-  <Fragment slot="ts">
-  ```ts
-  // src/cartStore.ts
-  import { atom, map } from 'nanostores';
-
-  export const isCartOpen = atom(false);
-
-  export type CartItem = {
-    id: string;
-    name: string;
-    imageSrc: string;
-    quantity: number;
-  }
-
-  export const cartItems = map<Record<string, CartItem>>({});
-  ```
-  </Fragment>
-</JavascriptFlavorTabs>
-
-Ahora, exportemos una función helper `addCartItem` para que usen nuestros componentes.
-- **Si el ítem no existe en el carrito**, añade el carrito con una cantidad inicial de 1.
-- **Si el ítem _ya existe_**, aumenta la cantidad en 1.
-
-<JavascriptFlavorTabs>
-  <Fragment slot="js">
-  ```js
-  // src/cartStore.js
-  ...
-  export function addCartItem({ id, name, imageSrc }) {
-    const existingEntry = cartItems.get()[id];
-    if (existingEntry) {
-      cartItems.setKey(id, {
-        ...existingEntry,
-        quantity: existingEntry.quantity + 1,
-      })
-    } else {
-      cartItems.setKey(
-        id,
-        { id, name, imageSrc, quantity: 1 }
-      );
-    }
-  }
-  ```
-  </Fragment>
-  <Fragment slot="ts">
-  ```ts
-  // src/cartStore.ts
-  ...
-  type ItemDisplayInfo = Pick<CartItem, 'id' | 'name' | 'imageSrc'>;
-  export function addCartItem({ id, name, imageSrc }: ItemDisplayInfo) {
-    const existingEntry = cartItems.get()[id];
-    if (existingEntry) {
-      cartItems.setKey(id, {
-        ...existingEntry,
-        quantity: existingEntry.quantity + 1,
-      });
-    } else {
-      cartItems.setKey(
-        id,
-        { id, name, imageSrc, quantity: 1 }
-      );
-    }
-  }
-  ```
-  </Fragment>
-</JavascriptFlavorTabs>
-
-:::note
-<details>
-
-<summary>**🙋 ¿Por qué usamos `.get()` aquí en vez de un helper `useStore`?**</summary>
-
-Habrás notado que estamos llamando a `cartItems.get()` aquí, en vez de usar el helper `useStore` de nuestros ejemplos de React / Preact / Solid / Vue. Esto es porque **useStore genera re-renderizados.** En otras palabras, `useStore` debe usarse cada vez que el valor del store se renderice en la UI. Como estamos leyendo este valor cuando un **evento** es accionado (`addToCart` en este caso), y no estamos intentando renderizar ese valor, en este caso no necesitamos `useStore`.
-</details>
-:::
-
-Con la store en su lugar, ahora podemos llamar esta función dentro de `AddToCartForm` cada vez que el formulario es enviado. También desplegaremos el menú con carrito para poder ver un resumen de lo que hay dentro.
-
-<UIFrameworkTabs>
-<Fragment slot="preact">
-```jsx
-// src/components/AddToCartForm.jsx
-import { addCartItem, isCartOpen } from '../cartStore';
-
-export default function AddToCartForm({ children }) {
-  // ¡usaremos valores fijos por simplicidad!
-  const hardcodedItemInfo = {
-    id: 'astronaut-figurine',
-    name: 'Astronaut Figurine',
-    imageSrc: '/images/astronaut-figurine.png',
-  }
-
-  function addToCart(e) {
-    e.preventDefault();
-    isCartOpen.set(true);
-    addCartItem(hardcodedItemInfo);
-  }
-
-  return (
-    <form onSubmit={addToCart}>
-      {children}
-    </form>
-  )
-}
-```
-</Fragment>
-<Fragment slot="react">
-```jsx
-// src/components/AddToCartForm.jsx
-import { addCartItem, isCartOpen } from '../cartStore';
-
-export default function AddToCartForm({ children }) {
-  // ¡usaremos valores fijos por simplicidad!
-  const hardcodedItemInfo = {
-    id: 'astronaut-figurine',
-    name: 'Astronaut Figurine',
-    imageSrc: '/images/astronaut-figurine.png',
-  }
-
-  function addToCart(e) {
-    e.preventDefault();
-    isCartOpen.set(true);
-    addCartItem(hardcodedItemInfo);
-  }
-
-  return (
-    <form onSubmit={addToCart}>
-      {children}
-    </form>
-  )
-}
-```
-</Fragment>
-<Fragment slot="solid">
-```jsx
-// src/components/AddToCartForm.jsx
-import { addCartItem, isCartOpen } from '../cartStore';
-
-export default function AddToCartForm({ children }) {
-  // ¡usaremos valores fijos por simplicidad!
-  const hardcodedItemInfo = {
-    id: 'astronaut-figurine',
-    name: 'Astronaut Figurine',
-    imageSrc: '/images/astronaut-figurine.png',
-  }
-
-  function addToCart(e) {
-    e.preventDefault();
-    isCartOpen.set(true);
-    addCartItem(hardcodedItemInfo);
-  }
-
-  return (
-    <form onSubmit={addToCart}>
-      {children}
-    </form>
-  )
-}
-```
-</Fragment>
-<Fragment slot="svelte">
-```svelte
-<!--src/components/AddToCartForm.svelte-->
-<form on:submit|preventDefault={addToCart}>
-  <slot></slot>
-</form>
-
-<script>
-  import { addCartItem, isCartOpen } from '../cartStore';
-
-  // ¡usaremos valores fijos por simplicidad!
-  const hardcodedItemInfo = {
-    id: 'astronaut-figurine',
-    name: 'Astronaut Figurine',
-    imageSrc: '/images/astronaut-figurine.png',
-  }
-
-  function addToCart() {
-    isCartOpen.set(true);
-    addCartItem(hardcodedItemInfo);
-  }
-</script>
-```
-</Fragment>
-<Fragment slot="vue">
-```vue
-<!--src/components/AddToCartForm.vue-->
-<template>
-  <form @submit="addToCart">
-    <slot></slot>
-  </form>
-</template>
-
-<script setup>
-  import { addCartItem, isCartOpen } from '../cartStore';
-
-  // ¡usaremos valores fijos por simplicidad!
-  const hardcodedItemInfo = {
-    id: 'astronaut-figurine',
-    name: 'Astronaut Figurine',
-    imageSrc: '/images/astronaut-figurine.png',
-  }
-
-  function addToCart(e) {
-    e.preventDefault();
-    isCartOpen.set(true);
-    addCartItem(hardcodedItemInfo);
-  }
-</script>
-```
-</Fragment>
-<Fragment slot="lit">
-```ts
-// src/components/AddToCartForm.ts
-import { LitElement, html } from 'lit';
-import { isCartOpen, addCartItem } from '../cartStore';
-
-export class AddToCartForm extends LitElement {
-  static get properties() {
-    return {
-      item: { type: Object },
-    };
-  }
-
-  constructor() {
-    super();
-    this.item = {};
-  }
-
-  addToCart(e) {
-    e.preventDefault();
-    isCartOpen.set(true);
-    addCartItem(this.item);
-  }
-
-  render() {
-    return html`
-      <form @submit="${this.addToCart}">
-        <slot></slot>
-      </form>
-    `;
-  }
-}
-customElements.define('add-to-cart-form', AddToCartForm);
-```
-</Fragment>
-</UIFrameworkTabs>
-
-Finalmente, renderizamos los ítems dentro del carrito en nuestro componente `CartFlyout`:
-
-<UIFrameworkTabs>
-<Fragment slot="preact">
-```jsx
-// src/components/CartFlyout.jsx
-import { useStore } from '@nanostores/preact';
-import { isCartOpen, cartItems } from '../cartStore';
-
-export default function CartFlyout() {
-  const $isCartOpen = useStore(isCartOpen);
-  const $cartItems = useStore(cartItems);
-
-  return $isCartOpen ? (
-    <aside>
-      {Object.values($cartItems).length ? (
-        <ul>
-          {Object.values($cartItems).map(cartItem => (
-            <li>
-              <img src={cartItem.imageSrc} alt={cartItem.name} />
-              <h3>{cartItem.name}</h3>
-              <p>Cantidad: {cartItem.quantity}</p>
-            </li>
-          ))}
-        </ul>
-      ) : <p>¡Tu carrito está vacío!</p>}
-    </aside>
-  ) : null;
-}
-```
-</Fragment>
-<Fragment slot="react">
-```jsx
-// src/components/CartFlyout.jsx
-import { useStore } from '@nanostores/react';
-import { isCartOpen, cartItems } from '../cartStore';
-
-export default function CartFlyout() {
-  const $isCartOpen = useStore(isCartOpen);
-  const $cartItems = useStore(cartItems);
-
-  return $isCartOpen ? (
-    <aside>
-      {Object.values($cartItems).length ? (
-        <ul>
-          {Object.values($cartItems).map(cartItem => (
-            <li>
-              <img src={cartItem.imageSrc} alt={cartItem.name} />
-              <h3>{cartItem.name}</h3>
-              <p>Cantidad: {cartItem.quantity}</p>
-            </li>
-          ))}
-        </ul>
-      ) : <p>¡Tu carrito está vacío!</p>}
-    </aside>
-  ) : null;
-}
-```
-</Fragment>
-<Fragment slot="solid">
-```jsx
-// src/components/CartFlyout.jsx
-import { useStore } from '@nanostores/solid';
-import { isCartOpen, cartItems } from '../cartStore';
-
-export default function CartFlyout() {
-  const $isCartOpen = useStore(isCartOpen);
-  const $cartItems = useStore(cartItems);
-
-  return $isCartOpen() ? (
-    <aside>
-      {Object.values($cartItems()).length ? (
-        <ul>
-          {Object.values($cartItems()).map(cartItem => (
-            <li>
-              <img src={cartItem.imageSrc} alt={cartItem.name} />
-              <h3>{cartItem.name}</h3>
-              <p>Cantidad: {cartItem.quantity}</p>
-            </li>
-          ))}
-        </ul>
-      ) : <p>¡Tu carrito está vacío!</p>}
-    </aside>
-  ) : null;
-}
-```
-</Fragment>
-<Fragment slot="svelte">
-```svelte
-<!--src/components/CartFlyout.svelte-->
-<script>
-  import { isCartOpen, cartItems } from '../cartStore';
-</script>
-
-{#if $isCartOpen}
-  {#if Object.values($cartItems).length}
-    <aside>
-      {#each Object.values($cartItems) as cartItem}
-      <li>
-        <img src={cartItem.imageSrc} alt={cartItem.name} />
-        <h3>{cartItem.name}</h3>
-        <p>Cantidad: {cartItem.quantity}</p>
-      </li>
-      {/each}
-    </aside>
-  {:else}
-    <p>¡Tu carrito está vacío!</p>
-  {/if}
-{/if}
-```
-</Fragment>
-<Fragment slot="vue">
-```vue
-<!--src/components/CartFlyout.vue-->
-<template>
-  <aside v-if="$isCartOpen">
-    <ul v-if="Object.values($cartItems).length">
-      <li v-for="cartItem in Object.values($cartItems)" v-bind:key="cartItem.name">
-        <img :src=cartItem.imageSrc :alt=cartItem.name />
-        <h3>{{cartItem.name}}</h3>
-        <p>Cantidad: {{cartItem.quantity}}</p>
-      </li>
-    </ul>
-    <p v-else>¡Tu carrito está vacío!</p>
-  </aside>
-</template>
-
-<script setup>
-  import { cartItems, isCartOpen } from '../cartStore';
-  import { useStore } from '@nanostores/vue';
-
-  const $isCartOpen = useStore(isCartOpen);
-  const $cartItems = useStore(cartItems);
-</script>
-```
-</Fragment>
-<Fragment slot="lit">
-```ts
-// src/components/CartFlyout.ts
-import { LitElement, html } from 'lit';
-import { isCartOpen, cartItems } from '../cartStore';
-import { StoreController } from '@nanostores/lit';
-
-export class CartFlyoutLit extends LitElement {
-  private cartOpen = new StoreController(this, isCartOpen);
-  private getCartItems = new StoreController(this, cartItems);
-
-  renderCartItem(cartItem) {
-    return html`
-      <li>
-        <img src="${cartItem.imageSrc}" alt="${cartItem.name}" />
-        <h3>${cartItem.name}</h3>
-        <p>Cantidad: ${cartItem.quantity}</p>
-      </li>
-    `;
-  }
-
-  render() {
-    return this.cartOpen.value
-      ? html`
-          <aside>
-            ${
-              Object.values(this.getCartItems.value).length
-                ? html`
-                  <ul>
-                    ${Object.values(this.getCartItems.value).map((cartItem) =>
-                      this.renderCartItem(cartItem)
-                    )}
-                  </ul>
-                `
-                : html`<p>¡Su carro está vacío!</p>`
-            }
-          </aside>
-        `
-      : null;
-  }
-}
-
-customElements.define('cart-flyout', CartFlyoutLit);
-```
-</Fragment>
-</UIFrameworkTabs>
-
-Ya deberías tener un ejemplo de ecommerce totalmente interactivo con el menor paquete de JS de la galaxia 🚀
-
-¡[**Prueba el ejemplo terminado**](https://github.com/withastro/astro/tree/main/examples/with-nanostores) en tu máquina u online vía StackBlitz!
diff --git a/src/content/docs/es/recipes/sharing-state.mdx b/src/content/docs/es/recipes/sharing-state.mdx
deleted file mode 100644
index c5cf119afa2ac..0000000000000
--- a/src/content/docs/es/recipes/sharing-state.mdx
+++ /dev/null
@@ -1,86 +0,0 @@
----
-title: Comparte el estado entre componentes de Astro
-description: Aprende como compartir el estado entre componentes de Astro con Nano Stores.
-i18nReady: true
-type: recipe
----
-
-import PackageManagerTabs from '~/components/tabs/PackageManagerTabs.astro'
-
-:::tip
-¿Estás usando componentes de framework? Mira [como compartir el estado entre Islas](/es/recipes/sharing-state-islands/)!
-:::
-
-Cuando construyes un sitio web con Astro, es posible que necesites compartir el estado entre componentes. Astro recomienda el uso de [Nano Stores](https://github.com/nanostores/nanostores) para el almacenamiento compartido del cliente.
-
-## Receta
-
-1. Instala Nano Stores:
-
-  <PackageManagerTabs>
-    <Fragment slot="npm">
-    ```shell
-    npm install nanostores
-    ```
-    </Fragment>
-    <Fragment slot="pnpm">
-    ```shell
-    pnpm add nanostores
-    ```
-    </Fragment>
-    <Fragment slot="yarn">
-    ```shell
-    yarn add nanostores
-    ```
-    </Fragment>
-  </PackageManagerTabs>
-
-2. Crea un store. En este ejemplo, el store rastrea si un diálogo está abierto o no:
-
-  ```ts title="src/store.js"
-  import { atom } from 'nanostores';
-
-  export const isOpen = atom(false);
-  ```
-
-3. Importa y utiliza el store en una etiqueta `<script>` en los componentes que compartirán el estado.
-
-Los siguientes componentes `Button` y `Dialog`  utilizan el estado compartido `isOpen` para controlar si un `<div>` en particular está oculto o mostrado:
-
-  ```astro title="src/components/Button.astro"
-  <button id="openDialog">Open</button>
-
-  <script>
-    import { isOpen } from '../store.js';
-    
-    // Configura el store a true cuando se hace clic en el botón
-    function openDialog() {
-      isOpen.set(true);
-    }
-
-    // Agrega un escuchador de eventos al botón
-    document.getElementById('openDialog').addEventListener('click', openDialog);
-  </script>
-  ```
-
-  ```astro title="src/components/Dialog.astro"
-  <div id="dialog" style="display: hidden">¡Hola Mundo!</div>
-
-  <script>
-    import { isOpen } from '../store.js';
-
-    // Escucha los cambios en el store y muestra/oculta el diálogo en consecuencia
-    isOpen.subscribe(open => {
-      if (open) {
-        document.getElementById('dialog').style.display = 'block';
-      } else {
-        document.getElementById('dialog').style.display = 'none';
-      }
-    })
-  </script>
-  ```
-
-## Recursos 
-
-- [Nano Stores en NPM](https://www.npmjs.com/package/nanostores)
-- [Documentación de Nano Stores para Vanilla JS](https://github.com/nanostores/nanostores#vanilla-js)
diff --git a/src/content/docs/es/recipes/streaming-improve-page-performance.mdx b/src/content/docs/es/recipes/streaming-improve-page-performance.mdx
deleted file mode 100644
index fe1190c116f2b..0000000000000
--- a/src/content/docs/es/recipes/streaming-improve-page-performance.mdx
+++ /dev/null
@@ -1,101 +0,0 @@
----
-title: "Utilizando transmisión para mejorar el rendimiento de la página"
-description: "Aprende cómo utilizar la transmisión para mejorar el rendimiento de la página."
-type: recipe
-i18nReady: true
----
-
-El SSR de Astro utiliza la transmisión de HTML para enviar cada componente al navegador cuando está disponible, lo que acelera la carga de la página. Para mejorar aún más el rendimiento de tu página, puedes construir estratégicamente tus componentes para optimizar su carga, evitando bloqueos durante la recuperación de datos.
-
-El siguiente ejemplo de refactorización demuestra cómo mejorar el rendimiento de la página al trasladar las llamadas de recuperación de datos a otros componentes, sacándolas de un componente donde bloquean el rendimiento de la página.
-
-La siguiente página realiza `await`s para la recuperación de algunos datos en su frontmatter. Astro esperará a que todas las llamadas `fetch` se resuelvan antes de enviar cualquier HTML al navegador.
-
-```astro title="src/pages/index.astro"
----
-const personResponse = await fetch('https://randomuser.me/api/');
-const personData = await personResponse.json();
-const randomPerson = personData.results[0];
-const factResponse = await fetch('https://catfact.ninja/fact');
-const factData = await factResponse.json();
----
-<html>
-  <head>
-    <title>Un nombre y un hecho</title>
-  </head>
-  <body>
-    <h2>Un nombre</h2>
-    <p>{randomPerson.name.first}</p>
-    <h2>Un hecho</h2>
-    <p>{factData.fact}</p>
-  </body>
-</html>
-```
-
-Al trasladar las llamadas `await` a componentes más pequeños, puedes aprovechar la transmisión de Astro. Al utilizar los siguientes componentes para realizar las recuperaciones de datos, Astro puede renderizar parte del HTML primero, como el título, y luego los párrafos cuando los datos estén listos.
-
-```astro title="src/components/RandomName.astro"
----
-const personResponse = await fetch('https://randomuser.me/api/');
-const personData = await personResponse.json();
-const randomPerson = personData.results[0];
----
-<p>{randomPerson.name.first}</p>
-```
-
-```astro title="src/components/RandomFact.astro"
----
-const factResponse = await fetch('https://catfact.ninja/fact');
-const factData = await factResponse.json();
----
-<p>{factData.fact}</p>
-```
-
-La página de Astro que se muestra a continuación, utilizando estos componentes, puede renderizar partes de la página más pronto. Las etiquetas `<head>`, `<body>`, y `<h2>` ya no están bloqueadas por las recuperaciones de datos. El servidor luego recuperará datos para `RandomName` y `RandomFact` en paralelo y transmitirá el HTML resultante al navegador.
-
-```astro title="src/pages/index.astro"
----
-import RandomName from '../components/RandomName.astro';
-import RandomFact from '../components/RandomFact.astro';
----
-<html>
-  <head>
-    <title>Un nombre y un hecho</title>
-  </head>
-  <body>
-    <h2>Un nombre</h2>
-    <RandomName />
-    <h2>Un hecho</h2>
-    <RandomFact />
-  </body>
-</html>
-```
-
-#### Incluyendo Promesas directamente
-
-También puedes incluir promesas directamente en la plantilla. En lugar de bloquear todo el componente, resolverá la promesa en paralelo y solo bloqueará el marcado que viene después de ella.
-
-```astro title="src/pages/index.astro"
----
-const personPromise = fetch('https://randomuser.me/api/')
-  .then(response => response.json())
-  .then(arr => arr[0].name.first);
-const factPromise = fetch('https://catfact.ninja/fact')
-  .then(response => response.json())
-  .then(factData => factData.fact);
----
-<html>
-  <head>
-    <title>Un nombre y un hecho</title>
-  </head>
-  <body>
-    <h2>Un nombre</h2>
-    <p>{personPromise}</p>
-    <h2>Un hecho</h2>
-    <p>{factPromise}</p>
-  </body>
-</html>
-```
-
-En este ejemplo, `Un nombre` se renderizará mientras se están cargando `personPromise` y `factPromise`. 
-Una vez que `personPromise` se haya resuelto, aparecerá `Un hecho` y `factPromise` se renderizará cuando haya terminado de cargarse.
\ No newline at end of file
diff --git a/src/content/docs/es/recipes/tailwind-rendered-markdown.mdx b/src/content/docs/es/recipes/tailwind-rendered-markdown.mdx
deleted file mode 100644
index 6d9ad029a4214..0000000000000
--- a/src/content/docs/es/recipes/tailwind-rendered-markdown.mdx
+++ /dev/null
@@ -1,106 +0,0 @@
----
-title: Estilo de Markdown renderizado con Tailwind Typography
-description: Aprende a usar @tailwind/typography para dar estilo a tu Markdown renderizado.
-i18nReady: true
-type: recipe
----
-
-import PackageManagerTabs from '~/components/tabs/PackageManagerTabs.astro';
-
-Puedes utilizar el plugin de tipografía de [Tailwind](https://tailwindcss.com) para estilar el Markdown renderizado de fuentes como las [**colecciones de contenido**](/es/guides/content-collections/) de Astro.
-
-Esta receta te enseñará a crear un componente de Astro reutilizable para estilar tu contenido Markdown usando las clases de utilidad de Tailwind.
-
-## Prerrequisitos
-
-Un proyecto de Astro que:
-
-  - tiene [la integración de Tailwind de Astro](/es/guides/integrations-guide/tailwind/) instalada.
-  - usa [las colecciones de contenido](/es/guides/content-collections/) de Astro.
-
-## Configuración de `@tailwindcss/typography`
-
-Primero, instala `@tailwindcss/typography` usando tu gestor de paquetes preferido.
-
-<PackageManagerTabs>
- 	<Fragment slot="npm">
-	```shell 
-	npm install -D @tailwindcss/typography
-	```
-	</Fragment>
-  	<Fragment slot="pnpm">
-	```shell 
-	pnpm add -D @tailwindcss/typography
-	```
-	</Fragment>
-  	<Fragment slot="yarn">
-	```shell
-	yarn add --dev @tailwindcss/typography
-	```
-	</Fragment>
-</PackageManagerTabs>
-
-Luego, añade el paquete como un plugin en tu archivo de configuración de Tailwind.
-
-```diff lang="js"
-// tailwind.config.js
-/** @type {import('tailwindcss').Config} */
-export default {
-  theme: {
-    // ...
-  },
-  plugins: [
-+   require('@tailwindcss/typography'),
-    // ...
-  ],
-}
-```
-
-## Receta
-
-1. Crea un componente `<Prose />` para proporcionar un `<div>` de envoltura con un `<slot />` para tu Markdown renderizado. Añade la clase de estilo `prose` junto con cualquier [modificador de elemento de Tailwind](https://tailwindcss.com/docs/typography-plugin#element-modifiers) deseado en el elemento padre.
-
-    ```astro title="src/components/Prose.astro"
-    ---
-    ---
-    <div 
-      class="prose dark:prose-invert 
-      prose-h1:font-bold prose-h1:text-xl 
-      prose-a:text-blue-600 prose-p:text-justify prose-img:rounded-xl 
-      prose-headings:underline">
-      <slot />
-    </div>
-    ```
-    :::tip
-    El plugin `@tailwindcss/typography` utiliza [**modificadores de elementos**](https://tailwindcss.com/docs/typography-plugin#element-modifiers) para estilar los componentes hijos de un contenedor con la clase `prose`.
-
-    Estos modificadores siguen la siguiente sintaxis general:
-
-      ```
-      prose-[element]:class-to-apply
-      ``` 
-
-    Por ejemplo, `prose-h1:font-bold` da a todas las etiquetas `<h1>` la clase Tailwind `font-bold`.
-    :::
-
-2. Consulta tu entrada de colección en la página en la que quieras renderizar tu Markdown. Pasa el componente `<Content />` de `await entry.render()` a `<Prose />` como hijo para envolver tu contenido Markdown en los estilos de Tailwind.
-
-    ```astro title="src/pages/index.astro"
-    ---
-    import Prose from '../components/Prose.astro';
-    import Layout from '../layouts/Layout.astro';
-    import { getEntry } from 'astro:content';
-
-    const entry = await getEntry('collection', 'entry');
-    const { Content } = await entry.render();
-    ---
-    <Layout>
-      <Prose>
-        <Content />
-      </Prose>
-    </Layout>
-    ```
-
-## Recursos
-
-- [Documentación del plugin de tipografía de Tailwind](https://tailwindcss.com/docs/typography-plugin)
diff --git a/src/content/docs/es/reference/adapter-reference.mdx b/src/content/docs/es/reference/adapter-reference.mdx
deleted file mode 100644
index 2e41cf3cdcac1..0000000000000
--- a/src/content/docs/es/reference/adapter-reference.mdx
+++ /dev/null
@@ -1,479 +0,0 @@
----
-title: API de adaptadores de Astro
-i18nReady: true
----
-import Since from '~/components/Since.astro';
-import { FileTree } from '@astrojs/starlight/components';
-
-Astro está diseñado para que sea fácil de desplegar a cualquier proveedor de la nube que soporte SSR (server side rendering). Esta capacidad la proporcionan los __adaptadores__, que son [integraciones](/es/reference/integrations-reference/). Lee la [guía de SSR](/es/guides/on-demand-rendering/) para aprender cómo añadir un adaptador.
-
-## ¿Qué es un adaptador?
-
-Un adaptador es un tipo especial de [integración](/es/reference/integrations-reference/) que proporciona un punto de entrada para el renderizado en el servidor. Un adaptador hace dos cosas:
-
-- Implementa API específicas del host para manejar solicitudes.
-- Configura la compilación de acuerdo con las convenciones del host.
-
-## Construyendo un adaptador
-
-Un adaptador es una [integración](/es/reference/integrations-reference/) y puede hacer todo lo que puede hacer una integración.
-
-Un adaptador __debe__ llamar a la API `setAdapter` en el hook `astro:config:done` así:
-
-```js title="my-adapter.mjs" ins={9}
-export default function createIntegration() {
-  return {
-    name: '@matthewp/my-adapter',
-    hooks: {
-      'astro:config:done': ({ setAdapter }) => {
-        setAdapter({
-          name: '@matthewp/my-adapter',
-          serverEntrypoint: '@matthewp/my-adapter/server.js',
-          supportedAstroFeatures: {
-            staticOutput: 'stable'
-          }
-        });
-      },
-    },
-  };
-}
-```
-
-El objeto pasado a `setAdapter` se define como:
-
-```ts
-interface AstroAdapter {
-	name: string;
-	serverEntrypoint?: string;
-	previewEntrypoint?: string;
-	exports?: string[];
-	args?: any;
-	adapterFeatures?: AstroAdapterFeatures;
-	supportedAstroFeatures?: AstroFeatureMap;
-}
-
-export interface AstroAdapterFeatures {
-	/**
-	 * Crea una función edge que se comunicará con el middleware de Astro
-	 */
-	edgeMiddleware: boolean;
-	/**
-	 * Solo SSR. Cada ruta se convierte en su propia función/archivo
-	 */
-	functionPerRoute: boolean;
-}
-
-export type SupportsKind = 'unsupported' | 'stable' | 'experimental' | 'deprecated';
-
-export type AstroFeatureMap = {
-  /**
-   * El adaptador puede servir páginas estáticas
-   */
-  staticOutput?: SupportsKind;
-  /**
-   * El adaptador es capaz de servir páginas que son estáticas o renderizadas a través del servidor
-   */
-  hybridOutput?: SupportsKind;
-  /**
-   * El adaptador es capaz de servir páginas SSR
-   */
-  serverOutput?: SupportsKind;
-  /**
-   * El adaptador puede emitir assets estáticos
-   */
-  assets?: AstroAssetsFeature;
-};
-
-export interface AstroAssetsFeature {
-  supportKind?: SupportsKind;
-  /**
-   * Si este adaptador implementa archivos en un entorno compatible con la biblioteca `sharp`
-   */
-  isSharpCompatible?: boolean;
-  /**
-   * Si este adaptador implementa archivos en un entorno compatible con la biblioteca `squoosh`
-   */
-  isSquooshCompatible?: boolean;
-}
-```
-
-Las propiedades son:
-
-* __name__: Un nombre único para tu adaptador, usado para iniciar sesión.
-* __serverEntrypoint__: el punto de entrada para el renderizado en el servidor.
-* __exports__: un array de exportaciones con nombre cuando se usa junto con `createExports` (explicado a continuación).
-* __adapterFeatures__: Un objeto que habilita características específicas que deben ser compatibles con el adaptador. 
-  Estas características cambiarán la salida generada, y el adaptador debe implementar la lógica adecuada para manejar las diferentes salidas.
-* __supportedAstroFeatures__: Un mapa de las características integradas en Astro. Esto permite que Astro determine qué características un adaptador no puede o no está dispuesto a admitir, para que se puedan proporcionar mensajes de error adecuados.
-
-### Server Entrypoint
-
-La API del adaptador de Astro intenta funcionar con cualquier tipo de host y ofrece una forma flexible de ajustarse a las API del host.
-
-#### Exports
-
-Algunos hosts serverless esperan que exportes una función, como `handler`:
-
-```js
-export function handler(event, context) {
-  // ...
-}
-```
-
-Con la API del adaptador, logras esto implementando `createExports` en tu `serverEntrypoint`:
-
-```js
-import { App } from 'astro/app';
-
-export function createExports(manifest) {
-  const app = new App(manifest);
-
-  const handler = (event, context) => {
-    // ...
-  };
-
-  return { handler };
-}
-```
-
-Y luego en la integración, donde llamas a `setAdapter`, proporciona este nombre en `exports`:
-
-```js title="my-adapter.mjs" ins={9}
-export default function createIntegration() {
-  return {
-    name: '@matthewp/my-adapter',
-    hooks: {
-      'astro:config:done': ({ setAdapter }) => {
-        setAdapter({
-          name: '@matthewp/my-adapter',
-          serverEntrypoint: '@matthewp/my-adapter/server.js',
-          exports: ['handler'],
-        });
-      },
-    },
-  };
-}
-```
-
-#### Start
-
-Algunos hosts esperan que ustedes mismos *inicien* el servidor, por ejemplo, escuchando un puerto. Para estos tipos de hosts, la API del adaptador te permite exportar una función `start` que se llamará cuando se ejecute el script del paquete.
-
-```js
-import { App } from 'astro/app';
-
-export function start(manifest) {
-  const app = new App(manifest);
-
-  addEventListener('fetch', event => {
-    // ...
-  });
-}
-```
-
-#### `astro/app`
-
-Este módulo se utiliza para renderizar páginas que se han compilado previamente a través de `astro build`. Astro usa los objetos estándar [Request](https://developer.mozilla.org/es/docs/Web/API/Request) y [Response](https://developer.mozilla.org/es/docs/Web/API/Response). Los hosts que tienen una API diferente para request/response deben convertirse a estos tipos en su adaptador.
-
-```js
-import { App } from 'astro/app';
-import http from 'http';
-
-export function start(manifest) {
-  const app = new App(manifest);
-
-  addEventListener('fetch', event => {
-    event.respondWith(
-      app.render(event.request)
-    );
-  });
-}
-```
-
-Se proporcionan los siguientes métodos:
-
-##### `app.render(request: Request, options?: RenderOptions)`
-
-Este método llama a la página de Astro que coincide con la solicitud, la renderiza y devuelve una Promise a un objeto [Response](https://developer.mozilla.org/es/docs/Web/API/Response). Esto también funciona para las rutas API que no procesan páginas.
-
-```js
-const response = await app.render(request);
-```
-
-##### `RenderOptions`
-
-El método `app.render()` acepta un argumento obligatorio `request`, y un objeto `RenderOptions` opcional para [`addCookieHeader`](#addcookieheader), [`clientAddress`](#clientaddress), [`locals`](#locals), y [`routeData`](#routedata).
-
-Cuando es usado, `locals` debe ser el tercer argumento pasado. Puedes pasar `undefined` para `routeData` si no estás apuntando a una ruta específica.
-
-###### `addCookieHeader`
-
-Si se agregan o no automáticamente todas las cookies escritas por `Astro.cookie.set()` a los encabezados de respuesta.
-
-Cuando se establece en `true`, se agregarán al encabezado `Set-Cookie` de la respuesta como pares clave-valor separados por comas. Puedes usar la API estándar `response.headers.getSetCookie()` para leerlos individualmente.
-Cuando se establece en `false (predeterminado)`, las cookies solo estarán disponibles desde `App.getSetCookieFromResponse(response)`.
-
-```js
-const response = await app.render(request, { addCookieHeader: true });
-```
-
-###### `clientAddress`
-
-La dirección IP del cliente que estará disponible como [`Astro.clientAddress`](/es/reference/api-reference/#astroclientaddress) en las páginas y como `ctx.clientAddress` en las rutas API y el middleware.
-
-El ejemplo a continuación lee el encabezado `x-forwarded-for` y lo pasa como `clientAddress`. Este valor está disponible para el usuario como `Astro.clientAddress`.
-
-```js "clientAddress"
-const clientAddress = request.headers.get("x-forwarded-for");
-const response = await app.render(request, { clientAddress });
-```
-
-###### `locals`
-
-El [objeto `context.locals`](/es/reference/api-reference/#contextlocals) se usa para almacenar y acceder a la información durante el ciclo de vida de una solicitud.
-
-El ejemplo a continuación lee un encabezado llamado `x-private-header`, intenta analizarlo como un objeto y pasarlo a `locals`, que luego se puede pasar a cualquier [función middleware](/es/guides/middleware/).
-
-```js "locals"
-const privateHeader = request.headers.get("x-private-header");
-let locals = {};
-try {
-    if (privateHeader) {
-        locals = JSON.parse(privateHeader);
-    }
-} finally {
-    const response = await app.render(request, { locals });
-}
-```
-
-###### `routeData`
-
-Proporciona un valor para [`routeData`](/es/reference/integrations-reference/#referencia-del-tipo-routedata) si ya conoces la ruta a renderizar. Al hacerlo, se omitirá la llamada interna a [`app.match`](#appmatchrequest) para determinar la ruta a renderizar.
-
-```js "routeData"
-const routeData = app.match(request);
-if (routeData) {
-    return app.render(request, { routeData });
-} else {
-    /* respuesta 404 específica del adaptador */
-    return new Response(..., { status: 404 });
-}
-```
-
-##### `app.match(request)`
-
-Este método se usa para determinar si una solicitud coincide con las reglas de enrutamiento de la aplicación Astro.
-
-```js
-if(app.match(request)) {
-  const response = await app.render(request);
-}
-```
-
-Por lo general, puedes llamar a `app.render(request)` sin usar `.match` porque Astro maneja 404 si se proporciona un archivo `404.astro`. Usa `app.match(request)` si quieres manejar los 404 de una manera diferente.
-
-## Permitir la instalación vía `astro add`
-
-[El comando `astro add`](/es/reference/cli-reference/#astro-add) permite a los usuarios agregar integraciones y adaptadores a su proyecto fácilmente. Si quieres que _tu_ adaptador sea instalable mediante esta herramienta, **agrega `astro-adapter` al campo `keywords` en tu `package.json`**:
-
-```json
-{
-  "name": "example",
-  "keywords": ["astro-adapter"],
-}
-```
-
-Una vez que [publiques tu adaptador a npm](https://docs.npmjs.com/cli/v8/commands/npm-publish), correr `astro add example` instalará tu paquete con cualquier otra dependencia peer especificada en tu `package.json`. También indicaremos a los usuarios a actualizar la configuración de su proyecto manualmente.
-
-## Características de Astro
-
-<p><Since v="3.0.0" /></p>
-
-Las características de Astro son una forma en que un adaptador le indica a Astro si puede admitir una característica, así como el nivel de soporte del adaptador para esa característica.
-
-Cuando se utilizan estas propiedades, Astro realizará lo siguiente:
-- ejecutará validaciones específicas;
-- emitirá información contextual en los registros;
-
-Estas operaciones se ejecutan en función de las características admitidas o no admitidas, su nivel de soporte y la configuración que utiliza el usuario.
-
-La siguiente configuración le indica a Astro que este adaptador tiene soporte experimental para assets, pero el adaptador no es compatible con los servicios integrados Sharp y Squoosh:
-
-```js title="my-adapter.mjs" ins={9-15}
-export default function createIntegration() {
-  return {
-    name: '@matthewp/my-adapter',
-    hooks: {
-      'astro:config:done': ({ setAdapter }) => {
-        setAdapter({
-          name: '@matthewp/my-adapter',
-          serverEntrypoint: '@matthewp/my-adapter/server.js',
-          supportedAstroFeatures: {
-            assets: {
-              supportKind: "experimental",
-              isSharpCompatible: false,
-              isSquooshCompatible: false
-            }
-          }  
-        });
-      },
-    },
-  };
-}
-```
-
-Astro registrará una **advertencia** en la terminal:
-
-```
-[@matthewp/my-adapter] The feature is experimental and subject to issues or changes.
-```
-
-y un error si el servicio utilizado para activos no es compatible con el adaptador:
-
-```
-[@matthewp/my-adapter] The currently selected adapter `@matthewp/my-adapter` is not compatible with the service "Sharp". Your project will NOT be able to build.
-```
-
-## Características del adaptador
-
-Un conjunto de características que cambian la salida de los archivos emitidos. Cuando un adaptador elige habilitar estas características, recibirá información adicional dentro de hooks específicos.
-
-### `functionPerRoute`
-
-Esta es una característica que se habilita al usar solo SSR. Por defecto, Astro emite un único archivo `entry.mjs`, que se encarga de emitir la página renderizada en cada solicitud.
-
-Cuando `functionPerRoute` está en `true`, Astro en su lugar creará un archivo separado para cada ruta definida en el proyecto. 
-
-Cada archivo emitido solo renderizará una página. Las páginas se emitirán dentro de un directorio `dist/pages/`, y los archivos emitidos mantendrán las mismas rutas de archivo del directorio `src/pages/`.
-
-Los archivos dentro del directorio `pages/` de la compilación reflejarán la estructura de directorios de los archivos de página en `src/pages/`, por ejemplo:
-
-<FileTree>
-- dist/
-    - pages/
-        - blog/
-            - entry.\_slug\_.astro.mjs
-            - entry.about.astro.mjs
-        - entry.index.astro.mjs
-</FileTree>
-
-Habilita la característica pasando `true` al adaptador.
-
-```js title="my-adapter.mjs" ins={9-11}
-export default function createIntegration() {
-  return {
-    name: '@matthewp/my-adapter',
-    hooks: {
-      'astro:config:done': ({ setAdapter }) => {
-        setAdapter({
-          name: '@matthewp/my-adapter',
-          serverEntrypoint: '@matthewp/my-adapter/server.js',
-          adapterFeatures: {
-              functionPerRoute: true
-          } 
-        });
-      },
-    },
-  };
-}
-```
-
-Luego, utiliza el hook [`astro:build:ssr`](/es/reference/integrations-reference/#astrobuildssr), que te proporcionará un objeto `entryPoints` que mapea una ruta de página al archivo físico emitido después de la compilación.
-
-```js title="my-adapter.mjs" ins={15-19}
-export default function createIntegration() {
-  return {
-    name: '@matthewp/my-adapter',
-    hooks: {
-      'astro:config:done': ({ setAdapter }) => {
-        setAdapter({
-          name: '@matthewp/my-adapter',
-          serverEntrypoint: '@matthewp/my-adapter/server.js',
-          adapterFeatures: {
-              functionPerRoute: true
-          } 
-        });
-      },
-
-      'astro:build:ssr': ({ entryPoints }) => {
-          for (const [route, entryFile] of entryPoints) {
-              // haz algo con route y entryFile
-          }
-      }  
-    },
-  };
-}
-```
-
-:::caution
-`entryFile` es de tipo `URL` y representa la ruta física del archivo en el sistema de archivos. Esto significa que las rutas cambian según el sistema operativo en el que se ejecute el código.
-:::
-
-#### Entornos serverless
-
-Establecer `functionPerRoute: true` en un entorno serverless crea un archivo JavaScript (controlador) para cada ruta. El nombre de un controlador puede variar según la plataforma de alojamiento que estés utilizando: lambda, función, página, etc.
-
-Cada una de estas rutas está sujeta a un [arranque en frío](https://azure.microsoft.com/en-us/blog/understanding-serverless-cold-start/) cuando se ejecuta el controlador, lo que puede causar cierto retraso. Este retraso está influenciado por diferentes factores.
-
-Con `functionPerRoute: false`, solo hay un controlador único encargado de renderizar todas tus rutas. Cuando se activa este controlador por primera vez, estarás sujeto a un arranque en frío. Después de eso, todas las demás rutas deberían funcionar sin retraso. Sin embargo, perderás el beneficio de la división de código que proporciona `functionPerRoute: true`.
-
-:::note
-Es importante que comprendas tu plataforma de alojamiento y cómo funciona para elegir la configuración adecuada de `functionPerRoute` para tu proyecto.
-:::
-
-### `edgeMiddleware`
-
-Define si se incluirá el código de middleware SSR al realizar la compilación.
-
-Cuando está habilitado, esto evita que el código de middleware se empaquete e importe en todas las páginas durante la compilación:
-
-```js title="my-adapter.mjs" ins={9-11}
-export default function createIntegration() {
-  return {
-    name: '@matthewp/my-adapter',
-    hooks: {
-      'astro:config:done': ({ setAdapter }) => {
-        setAdapter({
-          name: '@matthewp/my-adapter',
-          serverEntrypoint: '@matthewp/my-adapter/server.js',
-          adapterFeatures: {
-              edgeMiddleware: true
-          } 
-        });
-      },
-    },
-  };
-}
-```
-
-Luego, utiliza el hook [`astro:build:ssr`](/es/reference/integrations-reference/#astrobuildssr), que te proporcionará un `middlewareEntryPoint`, que es una `URL` que apunta al archivo físico en el sistema de archivos.
-
-```js title="my-adapter.mjs" ins={15-19}
-export default function createIntegration() {
-  return {
-    name: '@matthewp/my-adapter',
-    hooks: {
-      'astro:config:done': ({ setAdapter }) => {
-        setAdapter({
-          name: '@matthewp/my-adapter',
-          serverEntrypoint: '@matthewp/my-adapter/server.js',
-          adapterFeatures: {
-              edgeMiddleware: true
-          } 
-        });
-      },
-
-      'astro:build:ssr': ({ middlewareEntryPoint }) => {
-          // recuerda verificar si esta propiedad existe, será `undefined` isi el adaptador no opta por habilitar la característica.
-          if (middlewareEntryPoint) {
-             createEdgeMiddleware(middlewareEntryPoint)
-          }
-      }  
-    },
-  };
-}
-
-function createEdgeMiddleware(middlewareEntryPoint) {
-    // emite un nuevo archivo físico utilizando tu sistema de empaquetado.
-}
-```
diff --git a/src/content/docs/es/reference/api-reference.mdx b/src/content/docs/es/reference/api-reference.mdx
deleted file mode 100644
index c48429b6ca288..0000000000000
--- a/src/content/docs/es/reference/api-reference.mdx
+++ /dev/null
@@ -1,1864 +0,0 @@
----
-title: Referencia de la API
-i18nReady: true
----
-import Since from '~/components/Since.astro';
-import PackageManagerTabs from '~/components/tabs/PackageManagerTabs.astro';
-import ReadMore from '~/components/ReadMore.astro';
-
-## `Astro` global
-
-El objeto global `Astro` está disponible en todos los contextos en los archivos `.astro`. Tiene las siguientes funciones:
-
-### `Astro.glob()`
-
-`Astro.glob()` es una forma de cargar archivos locales en la configuración de su página estática.
-
-```astro
----
-// src/components/my-component.astro
-const posts = await Astro.glob('../pages/post/*.md'); // devuelve un array de artículos encontrados en ./src/pages/post/*.md
----
-
-<div>
-{posts.slice(0, 3).map((post) => (
-  <article>
-    <h2>{post.frontmatter.title}</h2>
-    <p>{post.frontmatter.description}</p>
-    <a href={post.url}>Read more</a>
-  </article>
-))}
-</div>
-```
-
-`.glob()` solo toma un parámetro: la URL relativa de los archivos locales que te gustaría importar. Es asíncrono y devuelve un array con las exportaciones de los archivos coincidentes.
-
-`.glob()` no puede tomar variables o strings que las interpolen, ya que no son analizables de manera estática. (Consulta la [guía de solución de problemas](/es/guides/troubleshooting/#valores-compatibles) para una solución alternativa.) Esto se debe a que `Astro.glob()` es un wrapper de la función [`import.meta.glob()`](https://vite.dev/guide/features.html#glob-import) de Vite.
-
-:::note
-También puedes utilizar `import.meta.glob()` directamente en tu proyecto de Astro. Es posible que quieras hacer esto cuando:
-
-- Necesitas esta característica en un archivo que no sea `.astro`, como una ruta API. `Astro.glob()` solamente está disponible en archivos `.astro`, mientras que `import.meta.glob()` es accesible en todo el proyecto.
-- No necesitas cargar cada archivo de inmediato. `import.meta.glob()` puede devolver funciones que importan el contenido del archivo, en vez de devolver el contenido en sí. Ten en cuenta que esta importación incluye todos los estilos y scripts de cualquier archivo importado. Estos serán agrupados y agregados a la página, ya sea que un archivo sea utilizado realmente o no. Esta decisión se toma mediante análisis estático, no en tiempo de ejecución.
-- Quieres acceder a la ruta de cada archivo. `import.meta.glob()` devuelve un map de la ruta del archivo a su contenido, mientras que `Astro.glob()` devuelve una lista de contenido.
-- Quieres pasar múltiples patrones; por ejemplo, quieres añadir un "patrón negativo" que filtra ciertos archivos. `import.meta.glob()` opcionalmente puede tomar un array de strings globales en vez de un solo string.
-
-Lee más en la [documentación de Vite](https://vite.dev/guide/features.html#glob-import).
-:::
-
-#### Archivos Markdown
-
-Los archivos Markdown tienen la siguiente interfaz:
-
-```ts
-export interface MarkdownInstance<T extends Record<string, any>> {
-  /* Cualquier dato especificado en el frontmatter de YAML del archivo */
-  frontmatter: T;
-  /* La ruta del archivo */
-  file: string;
-  /* La ruta en donde se renderizará este archivo */
-  url: string | undefined;
-  /* Componente de Astro que renderizará el contenido del archivo */
-  Content: AstroComponent;
-  /* Función que devuelve un array de elementos h1...h6 del archivo */
-  getHeadings(): Promise<{ depth: number; slug: string; text: string }[]>;
-}
-```
-
-Opcionalmente, puedes proporcionar un tipo para la variable de `frontmatter` usando un tipo genérico de TypeScript.
-
-```astro
----
-interface Frontmatter {
-  title: string;
-  description?: string;
-}
-const posts = await Astro.glob<Frontmatter>('../pages/post/*.md');
----
-
-<ul>
-  {posts.map(post => <li>{post.frontmatter.title}</li>)}
-</ul>
-```
-
-#### Archivos Astro
-
-Los archivos Astro tienen la siguiente interfaz:
-
-```ts
-export interface AstroInstance {
-  default: AstroComponent;
-}
-```
-
-#### Otros archivos
-
-Otros archivos pueden tener varias interfaces diferentes, pero `Astro.glob()` acepta un genérico de TypeScript si sabes exactamente qué tipo contiene un archivo no reconocido.
-
-```ts
----
-interface CustomDataFile {
-  default: Record<string, any>;
-}
-const data = await Astro.glob<CustomDataFile>('../data/**/*.js');
----
-```
-
-### `Astro.props`
-
-`Astro.props` es un objeto que contiene cualquier valor que haya sido pasado como [atributo de componente](/es/basics/astro-components/#props-de-componentes). Los componentes de plantilla para archivos `.md` y `.mdx` reciben valores de frontmatter como props.
-
-```astro {3}
----
-// src/components/Heading.astro
-const { title, date } = Astro.props;
----
-<div>
-  <h1>{title}</h1>
-  <p>{date}</p>
-</div>
-```
-
-```astro /title=".+"/ /date=".+"/
----
-// src/pages/index.astro
-import Heading from '../components/Heading.astro';
----
-<Heading title="Mi Primer Artículo" date="09 Ago 2022" />
-```
-
-<ReadMore>Aprende acerca de cómo se manejan las props en las [Plantillas de Markdown y MDX](/es/guides/markdown-content/#layout-en-el-frontmatter).</ReadMore>
-
-<ReadMore>Aprende cómo añadir [definiciones de tipos de TypeScript para tus props](/es/guides/typescript/#props-de-componentes).</ReadMore>
-
-### `Astro.params`
-
-`Astro.params` es un objeto que contiene los valores de segmentos de ruta dinámica que coincidan con esta petición.
-
-En builds estáticos, esto serán los `params` devueltos por `getStaticPaths()` usados para prerrenderizar [rutas dinámicas](/es/guides/routing/#rutas-dinámicas).
-
-En builds SSR, esto puede ser cualquier valor que coincida con los segmentos de la ruta en el patrón de la ruta dinámica.
-
-```astro title="src/pages/posts/[id].astro"
----
-export function getStaticPaths() {
-  return [
-    { params: { id: '1' } },
-    { params: { id: '2' } },
-    { params: { id: '3' } }
-  ];
-}
-
-const { id } = Astro.params;
----
-<h1>{id}</h1>
-```
-
-Ver también: [`params`](#params)
-
-### `Astro.request`
-
-`Astro.request` es un objeto [Request](https://developer.mozilla.org/es/docs/Web/API/Request) estándar. Se puede utilizar para obtener la `url`, `headers`, `method` e incluso el cuerpo de la solicitud.
-
-```astro
-<p>Recibí una solicitud {Astro.request.method} en "{Astro.request.url}".</p>
-<p>Encabezados de solicitud recibidos:<code>{JSON.stringify(Object.fromEntries(Astro.request.headers))}</code>
-```
-
-Ver también: [`Astro.url`](#astrourl)
-
-:::note
-Con la opción por defecto `output: 'static'`, El objeto `Astro.request.url` no contiene parámetros de búsqueda, tales como `?foo=bar`, ya que no es posible determinarlos por adelantado durante la compilación final de los archivos en builds estáticos. Sin embargo, en el modo `output: 'server'`, el objeto `Astro.request.url` contiene los parámetros de búsqueda debido a que pueden ser determinados desde una petición al servidor.
-:::
-
-### `Astro.response`
-
-`Astro.response`  es un objeto estándar `ResponseInit`. Tiene la siguiente estructura.
-
- - `status`: El código numérico de estado de la respuesta, p. ej. `200`.
- - `statusText`: El mensaje de estado asociado con el código de estado, p. ej. `'OK'`.
- - `headers`: Una instancia de [`Headers`](https://developer.mozilla.org/en-US/docs/Web/API/Headers) que puedes usar para establecer las cabeceras HTTP de la respuesta.
-
-`Astro.response` se utiliza para establecer el `status`, `statusText` y `headers` de la respuesta de una página.
-
-```astro
----
-if(condition) {
-  Astro.response.status = 404;
-  Astro.response.statusText = 'Not found';
-}
----
-```
-
-O para establecer un header:
-
-```astro
----
-Astro.response.headers.set('Set-Cookie', 'a=b; Path=/;');
----
-```
-
-### `Astro.cookies`
-
-<p><Since v="1.4.0" /></p>
-
-`Astro.cookies` contiene utilidades para leer y manipular cookies.
-
-<p>
-**Tipo:** `(key: string, options?: CookieGetOptions) => AstroCookie`
-</p>
-
-Consigue la cookie como un objeto [`AstroCookie`](#astrocookie), que contiene el `value` y funciones de utilidad para convertir la cookie a tipos no string.
-
-##### `has`
-
-<p>
-**Tipo:** `(key: string) => boolean`
-</p>
-
-Si esta cookie existe. Si la cookie ha sido establecida a través de `Astro.cookies.set()` esto devolverá `true`, de lo contrario revisará las cookies en `Astro.request`.
-
-##### `set`
-
-<p>
-**Tipo:** `(key: string, value: string | number | boolean | object, options?: CookieSetOptions) => void`
-</p>
-
-Configura la cookie `key` al valor dado. Esto intentará convertir el valor de la cookie a un string. Las opciones proveen maneras de establecer [características de la cookie](https://www.npmjs.com/package/cookie#options-1), como `maxAge` o `httpOnly`.
-
-##### `delete`
-
-<p>
-**Tipo:** `(key: string, options?: CookieDeleteOptions) => void`
-</p>
-
-Marca la cookie como eliminada. Una vez que una cookie es eliminada, `Astro.cookies.has()` devolverá `false` y `Astro.cookies.get()` devolverá un [`AstroCookie`](#astrocookie) con un `value` de `undefined`. Las opciones permiten establecer el `domain` y `path` de la cookie a eliminar.
-
-##### `headers`
-
-<p>
-**Tipo:** `() => Iterator<string>`
-</p>
-
-Consigue los valores de cabecera para `Set-Cookie` que serán enviados con la respuesta.
-
-#### `AstroCookie`
-
-Obtener una cookie mediante `Astro.cookies.get()` retorna un tipo `AstroCookie`. Posee la siguiente estructura.
-
-##### `value`
-
-<p>
-**Tipo:** `string | undefined`
-</p>
-
-El valor de la string sin procesar de la cookie.
-
-##### `json`
-
-<p>
-**Tipo:** `() => Record<string, any>`
-</p>
-
-Analiza el valor de la cookie a través de `JSON.parse()`, devolviendo un objeto. Lanza un error si el valor de la cookie no es un JSON válido.
-
-##### `number`
-
-<p>
-**Tipo:** `() => number`
-</p>
-
-Analiza el valor de la cookie como un número. Devuelve NaN si no es un número válido.
-
-##### `boolean`
-
-<p>
-**Tipo:** `() => boolean`
-</p>
-
-Convierte el valor de la cookie a un booleano.
-
-#### `CookieGetOptions`
-
-<p><Since v="4.1.0"/></p>
-
-Conseguir una cookie también permite especificar opciones a través de la interfaz `CookieGetOptions`:
-
-##### `decode`
-
-<p>
-**Tipo:** `(value: string) => string`
-</p>
-
-Permite personalizar cómo se deserializa una cookie en un valor.
-
-#### `CookieSetOptions`
-
-<p><Since v="4.1.0"/></p>
-
-Configurar una cookie a través de `Astro.cookies.set()` permite pasar un `CookieSetOptions` para personalizar cómo se serializa la cookie.
-
-##### `domain`
-
-<p>
-**Tipo:** `string`
-</p>
-
- Especifica el dominio. Si no se establece un dominio, la mayoría de los clientes interpretarán que se aplica al dominio actual.
-
- ##### `expires`
-
- <p>
- **Tipo:** `Date`
- </p>
-
-Especia la fecha en la que la cookie expirará.
-
-##### `httpOnly`
-
-<p>
-**Tipo:** `boolean`
-</p>
-
-Si es verdadero, la cookie no será accesible del lado del cliente.
-
-##### `maxAge`
-
-<p>
-**Tipo:** `number`
-</p>
-
-Especifica un número, en segundos, para el cual la cookie es válida.
-
-##### `path`
-
-<p>
-**Tipo:** `string`
-</p>
-
-Especifica una subruta del dominio en la que se aplica la cookie.
-
-##### `sameSite`
-
-<p>
-**Tipo:** `boolean | 'lax' | 'none' | 'strict'`
-</p>
-
-Especifica el valor de la cabecera de cookie [SameSite](https://datatracker.ietf.org/doc/html/draft-ietf-httpbis-rfc6265bis-09#section-5.4.7).
-
-##### `secure`
-
-<p>
-**Tipo:** `boolean`
-</p>
-
-Si es verdadero, la cookie solo se establece en sitios https.
-
-##### `encode`
-
-<p>
-**Tipo:** `(value: string) => string`
-</p>
-
-Permite personalizar cómo se serializa una cookie.
-
-### `Astro.redirect()`
-`Astro.redirect()` te permite redireccionar a otra página.
-Una página (no un componente hijo) debe `return` (devolver) el resultado de `Astro.redirect()` para que la redirección ocurra.
-
-```astro title="src/pages/account.astro" {8}
----
-import { isLoggedIn } from '../utils';
-const cookie = Astro.request.headers.get('cookie');
-// Si el usuario no está logueado, redirígelo a la página de login
-if (!isLoggedIn(cookie)) {
-  return Astro.redirect('/login');
-}
----
-```
-
-### `Astro.canonicalURL`
-
-:::caution[Obsoleto]
-Utiliza [`Astro.url`](#astrourl) para construir tu propia URL canónica.
-:::
-
-La [URL canónica][canonical] de la página actual.
-
-### `Astro.url`
-
-<Since v="1.0.0-rc" />
-
-Un objeto [URL](https://developer.mozilla.org/es/docs/Web/API/URL) construido a partir del valor actual de la string URL `Astro.request.url`. Útil para interactuar con propiedades individuales de la URL de la solicitud, como la ruta o el origen.
-
-Equivalente a hacer `new URL (Astro.request.url)`.
-
-```astro
-<h1>La URL actual es: {Astro.url}</h1>
-<h1>El nombre de la ruta URL actual es: {Astro.url.pathname}</h1>
-<h1>El origen de la URL actual es: {Astro.url.origin}</h1>
-```
-
-También puedes usar `Astro.url` para crear nuevas URL pasándola como argumento a [`new URL()`](https://developer.mozilla.org/es/docs/Web/API/URL/URL).
-
-```astro title="src/pages/index.astro"
----
-// Ejemplo: construye una URL canónica usando tu dominio de producción
-const canonicalURL = new URL(Astro.url.pathname, Astro.site);
-// Ejemplo: construye una URL para metaetiquetas SEO usando tu dominio actual
-const socialImageURL = new URL('/images/preview.png', Astro.url);
----
-<link rel="canonical" href={canonicalURL} />
-<meta property="og:image" content={socialImageURL} />
-```
-
-### `Astro.clientAddress`
-
-<p><Since v="1.0.0-rc" /></p>
-
-Especifica la [dirección IP](https://es.wikipedia.org/wiki/Direcci%C3%B3n_IP) de la solicitud. Esta propiedad solo está disponible cuando se compila para SSR (renderizado en el servidor) y no debe usarse para sitios estáticos.
-
-```astro
----
-const ip = Astro.clientAddress;
----
-
-<div>Tu dirección IP es: <span class="address">{ ip }</span></div>
-```
-
-### `Astro.site`
-
-`Astro.site` devuelve una `URL` generada desde `site` en su configuración de Astro. Si `site`no esta definido en tu configuración Astro, `Astro.site` no estará definido.
-
-### `Astro.generator`
-
-<p><Since v="1.0.0" /></p>
-
-`Astro.generator` es una manera conveniente de agregar una etiqueta [`<meta name="generator">`](https://html.spec.whatwg.org/multipage/semantics.html#meta-generator) con tu versión actual de Astro. Responde al formato `"Astro v1.x.x"`.
-
-```astro mark="Astro.generator"
-<html>
-  <head>
-    <meta name="generator" content={Astro.generator} />
-  </head>
-  <body>
-    <footer>
-      <p>Built with <a href="https://astro.build">{Astro.generator}</a></p>
-    </footer>
-  </body>
-</html>
-```
-
-### `Astro.slots`
-
-`Astro.slots` contiene funciones de utilidad para modificar los hijos en slots de un componente Astro.
-
-#### `Astro.slots.has()`
-
-**Tipo:** `(slotName: string) => boolean`
-
-Puedes verificar si el contenido para un slot específico existe usando `Astro.slots.has()`. Esto puede ser útil cuando quieres envolver el contenido del slot, pero solo quieres renderizar los elementos envueltos cuando se esté usando el slot.
-
-```astro title="src/pages/index.astro"
----
----
-<slot />
-
-{Astro.slots.has('more') && (
-  <aside>
-    <h2>More</h2>
-    <slot name="more" />
-  </aside>
-)}
-```
-
-#### `Astro.slots.render()`
-
-**Tipo:** `(slotName: string, args?: any[]) => Promise<string>`
-
-Puedes renderizar de forma asíncrona el contenido de un slot a un string de HTML usando `Astro.slots.render()`.
-
-```astro
----
-const html = await Astro.slots.render('default');
----
-<Fragment set:html={html} />
-```
-
-:::note
-¡Esta nota es para casos de uso avanzados! En la mayoría de los casos, es más simple renderizar el contenido del slot con [el elemento `<slot />`](/es/basics/astro-components/#slots).
-:::
-
-`Astro.slots.render()` opcionalmente acepta un segundo argumento: un array de parámetros que se enviarán a cualquier función hija. Esto puede ser útil para componentes de utilidad personalizados.
-
-Por ejemplo, este componente `<Shout />` convierte su prop `message` en mayúsculas y la pasa al slot predeterminado:
-
-```astro title="src/components/Shout.astro" "await Astro.slots.render('default', [message])"
----
-const message = Astro.props.message.toUpperCase();
-let html = '';
-if (Astro.slots.has('default')) {
-  html = await Astro.slots.render('default', [message]);
-}
----
-<Fragment set:html={html} />
-```
-
-Una función callback pasada como hijo de `<Shout />` recibirá el parámetro `message` en mayúsculas:
-
-```astro title="src/pages/index.astro"
----
-import Shout from "../components/Shout.astro";
----
-<Shout message="slots!">
-  {(message) => <div>{message}</div>}
-</Shout>
-
-<!-- renderiza como <div>SLOTS!</div> -->
-```
-
-### `Astro.self`
-
-`Astro.self` permite llamar recursivamente a los componentes de Astro. Este comportamiento te permite renderizar un componente de Astro desde dentro de sí mismo utilizando `<Astro.self>` en la plantilla del componente. Esto puede ser útil para iterar sobre grandes data stores y estructuras de datos anidadas.
-
-```astro
----
-// NestedList.astro
-const { items } = Astro.props;
----
-<ul class="nested-list">
-  {items.map((item) => (
-    <li>
-      <!-- Si hay una estructura de datos anidada renderizamos `<Astro.self>` -->
-      <!-- y podemos pasar props a través de la llamada recursiva -->
-      {Array.isArray(item) ? (
-        <Astro.self items={item} />
-      ) : (
-        item
-      )}
-    </li>
-  ))}
-</ul>
-```
-
-Este componente podría usarse así:
-
-```astro
----
-import NestedList from './NestedList.astro';
----
-<NestedList items={['A', ['B', 'C'], 'D']} />
-```
-
-Y renderizaría este HTML:
-
-```html
-<ul class="nested-list">
-  <li>A</li>
-  <li>
-    <ul class="nested-list">
-      <li>B</li>
-      <li>C</li>
-    </ul>
-  </li>
-  <li>D</li>
-</ul>
-```
-
-### `Astro.locals`
-
-`Astro.locals` es un objeto que contiene cualquier valor del objeto [`context.locals`](#contextlocals) de un middleware. Utiliza esto para acceder a los datos devueltos por el middleware en tus archivos `.astro`.
-
-```astro title="src/pages/Orders.astro"
----
-const title = Astro.locals.welcomeTitle();
-const orders = Array.from(Astro.locals.orders.entries());
----
-<h1>{title}</h1>
-<ul>
-    {orders.map(order => {
-        return <li>{/* hacer algo con cada pedido */}</li>
-    })}
-</ul>
-```
-
-### `Astro.preferredLocale`
-
-`Astro.preferredLocale` es un valor computado que representa el idioma preferido del usuario.
-
-Es calculado verificando los idiomas configurados en tu array `i18n.locales` y los idiomas soportados por el navegador del usuario a través de la cabecera `Accept-Language`. Este valor es `undefined` si no existe tal coincidencia.
-
-Esta propiedad solo está disponible cuando se compila para SSR (renderizado en el servidor) y no debe usarse para sitios estáticos.
-
-### `Astro.preferredLocaleList`
-
-`Astro.preferredLocaleList` representa el array de todos los idiomas que son solicitados por el navegador y soportados por tu sitio web. Esto produce una lista de todos los idiomas compatibles entre tu sitio y tu usuario.
-
-Si la petición del navegador no especifica ningún idioma preferido, entonces este valor será `[]`: no admites ninguno de los idiomas preferidos de un usuario sin preferencias.
-
-Si el navegador no especifica ningún idioma preferido, entonces este valor será [`i18n.locales`](/es/reference/configuration-reference/#i18nlocales): todos tus idiomas soportados serán considerados igualmente preferidos por un visitante sin preferencias.
-
-Esta propiedad solo está disponible cuando se compila para SSR (renderizado en el servidor) y no debe usarse para sitios estáticos.
-
-### `Astro.currentLocale`
-
-La localización computada a partir de la URL actual, utilizando la sintaxis especificada en tu configuración `locales`. Si la URL no contiene un prefijo `/[locale]/`, entonces el valor por defecto será `i18n.defaultLocale`.
-
-
-## Contexto del Endpoint
-
-[Las funciones de Endpoint](/es/guides/endpoints/) reciben un objeto de contexto como primer parámetro. Posee muchas de las propiedades del objeto global `Astro`.
-
-```ts title="endpoint.json.ts"
-import type { APIContext } from 'astro';
-
-export function GET(context: APIContext) {
-  // ...
-}
-```
-
-### `context.locals`
-
-`context.locals` es un objeto utilizado para almacenar y acceder a información arbitraria durante el ciclo de vida de una petición.
-
-Las funciones de middleware pueden leer y escribir los valores de `context.locals`:
-
-```ts title="src/middleware.ts"
-import type { MiddlewareResponseHandler } from 'astro';
-export const onRequest: MiddlewareResponseHandler = ({ locals }, next) => {
-  if (!locals.title) {
-    locals.title = "Título por defecto";
-  }
-  return next();
-}
-```
-
-Los endpoints de la API sólo pueden leer información de `context.locals`.:
-
-```ts title="src/pages/hello.ts"
-import type { APIContext } from 'astro';
-
-export function GET({ locals }: APIContext) {
-  return {
-    body: locals.title // "Título por defecto"
-  }
-}
-```
-
-Ver también: [`Astro.locals`](#astrolocals)
-
-### `context.params`
-
-`context.params` es un objeto que contiene los valores de los segmentos de la ruta dinámica que coincidan con esta petición.
-
-En builds estáticos, esto serán los `params` devueltos por `getStaticPaths()` usados para prerrenderizar [rutas dinámicas](/es/guides/routing/#rutas-dinámicas).
-
-En builds SSR, esto puede ser cualquier valor que coincida con los segmentos de la ruta en el patrón de la ruta dinámica.
-
-```ts title="src/pages/posts/[id].json.ts"
-import type { APIContext } from 'astro';
-
-export function getStaticPaths() {
-  return [
-    { params: { id: '1' } },
-    { params: { id: '2' } },
-    { params: { id: '3' } }
-  ];
-}
-
-export function GET({ params }: APIContext) {
-  return {
-    body: JSON.stringify({ id: params.id }),
-  };
-}
-```
-
-Ver también: [`params`](#params)
-
-### `context.props`
-
-`context.props` es un objeto que contiene las `props` pasadas desde `getStaticPaths()`. Como `getStaticPaths()` no se utiliza durante la generación en SSR (server-side rendering), `context.props` solamente está disponible en builds estáticos.
-
-```ts title="src/pages/posts/[id].json.ts"
-import type { APIContext } from 'astro';
-
-export function getStaticPaths() {
-  return [
-    { params: { id: '1' }, props: { author: 'Blu' } },
-    { params: { id: '2' }, props: { author: 'Erika' } },
-    { params: { id: '3' }, props: { author: 'Matthew' } },
-  ];
-}
-
-export function GET({ props }: APIContext) {
-  return {
-    body: JSON.stringify({ author: props.author }),
-  };
-}
-```
-
-Ver también: [Transferencia de datos con `props`](#transferencia-de-datos-con-props)
-
-### `context.request`
-
-Un objeto [Request](https://developer.mozilla.org/es/docs/Web/API/Request) estándar. Puede ser usado para obtener la `url`, `headers`, `method` y también el body de la petición.
-
-```ts
-import type { APIContext } from 'astro';
-
-export function GET({ request }: APIContext) {
-  return {
-    body: `Hola ${request.url}`,
-  };
-}
-```
-
-Ver también: [Astro.request](#astrorequest)
-
-### `context.cookies`
-
-`context.cookies` contiene utilidades para leer y manipular cookies.
-
-Ver también: [Astro.cookies](#astrocookies)
-
-### `context.url`
-
-Un objeto [URL](https://developer.mozilla.org/es/docs/Web/API/URL) generado desde el valor actual de la string URL `context.request.url`.
-
-Ver también: [Astro.url](#astrourl)
-
-### `context.clientAddress`
-
-Especifica la [dirección IP](https://es.wikipedia.org/wiki/Dirección_IP) de la petición. Esta propiedad solamente está disponible durante la generación en SSR (server-side rendering) y no debe ser utilizado en sitios estáticos.
-
-```ts
-import type { APIContext } from 'astro';
-
-export function GET({ clientAddress }: APIContext) {
-  return {
-    body: `Tu dirección IP es: ${clientAddress}`,
-  };
-}
-```
-
-Ver también: [Astro.clientAddress](#astroclientaddress)
-
-### `context.site`
-
-`context.site` devuelve una `URL` generada desde el `site` en tu configuración de Astro. Si no está definido, devolverá una URL generada desde `localhost`.
-
-Ver también: [Astro.site](#astrosite)
-
-### `context.generator`
-
-`context.generator` es una manera conveniente de indicar la versión de Astro que esté corriendo tu proyecto. Posee el formato `"Astro v1.x.x"`.
-
-```ts title="src/pages/site-info.json.ts"
-import type { APIContext } from 'astro';
-
-export function GET({ generator, site }: APIContext) {
-  const body = JSON.stringify({ generator, site });
-  return new Response(body);
-}
-```
-
-Ver también: [Astro.generator](#astrogenerator)
-
-### `context.redirect()`
-
-`context.redirect()` devuelve un objeto [Response](https://developer.mozilla.org/es/docs/Web/API/Response) que te permite redirigir al usuario a otra página. Esta función solamente está disponible durante la generación en SSR (server-side rendering) y no debe ser utilizado en sitios estáticos.
-
-```ts
-import type { APIContext } from 'astro';
-
-export function GET({ redirect }: APIContext) {
-  return redirect('/login', 302);
-}
-```
-
-Ver también: [`Astro.redirect()`](#astroredirect)
-
-## `getStaticPaths()`
-
-Si una página usa parámetros dinámicos en el nombre del archivo, ese componente necesitará exportar una función `getStaticPaths()`.
-
-Esta función es necesaria porque Astro es un creador de sitios estáticos. Eso significa que todo su sitio se construye con anticipación. Si Astro no sabe generar una página en el momento de la creación, sus usuarios no la verán cuando visiten tu sitio.
-
-```astro
----
-export async function getStaticPaths() {
-  return [
-    { params: { /* requerido */ }, props: { /* opcional */ } },
-    { params: { ... } },
-    { params: { ... } },
-    // ...
-  ];
-}
----
-<!-- Tu maquetado HTML aquí. -->
-```
-
-La función `getStaticPaths()` debe devolver un array de objetos para determinar qué rutas serán prerenderizadas por Astro.
-
-También puede ser usado en endpoints de archivo estáticos para [enrutamiento dinámico](/es/guides/endpoints/#params-y-enrutamiento-dinámico).
-
-:::caution
-La función `getStaticPaths()` se ejecuta en su propio ámbito aislado una vez, antes de que se cargue cualquier página. Por lo tanto, no puede hacer referencia a nada desde el ámbito principal, aparte de las importaciones de archivos. El compilador le advertirá si incumple este requisito.
-:::
-
-### `params`
-
-La key `params` de cada objeto devuelto le dice a Astro qué rutas construir. Los parámetros devueltos deben corresponder con los parámetros dinámicos y los parámetros comodín definidos en la ruta de archivo de su componente.
-
-Los `params` están codificados en la URL, por lo que solo se admiten strings como valores. El valor de cada objeto `params` debe coincidir con los parámetros utilizados en el nombre de la página.
-
-Por ejemplo, supongamos que tienes una página en `src/pages/posts/[id].astro`. Si exportas `getStaticPaths` desde esta página y devuelves lo siguiente para las rutas:
-
-```astro
----
-export async function getStaticPaths() {
-  return [
-    { params: { id: '1' } },
-    { params: { id: '2' } },
-    { params: { id: '3' } }
-  ];
-}
-
-const { id } = Astro.params;
----
-<h1>{id}</h1>
-```
-
-Luego, Astro generará estáticamente `posts/1`, `posts/2` y `posts/3` en el momento de la compilación.
-
-### Transferencia de datos con `props`
-
-Para pasar datos adicionales a cada página generada, también puedes establecer un valor `props` en cada objeto de ruta devuelto. A diferencia de `params`, `props` no están codificados en la URL y, por lo tanto, no están limitados a solamente strings.
-
-Por ejemplo, suponiendo que generas páginas basadas en datos obtenidos de una API remota. Puedes pasar el objeto de datos completo al componente de página dentro de `getStaticPaths`:
-
-```astro
----
-export async function getStaticPaths() {
-  const data = await fetch('...').then(response => response.json());
-
-  return data.map((post) => {
-    return {
-      params: { id: post.id },
-      props: { post },
-    };
-  });
-}
-
-const { id } = Astro.params;
-const { post } = Astro.props;
----
-<h1>{id}: {post.name}</h1>
-```
-
-También puedes pasar un array regular, que puede ser útil al generar o agregar una lista conocida de rutas.
-
-```astro
----
-export async function getStaticPaths() {
-  const posts = [
-    {id: '1', category: "astro", title: "API Reference"},
-    {id: '2', category: "react", title: "Creating a React Counter!"}
-  ];
-  return posts.map((post) => {
-    return {
-      params: { id: post.id },
-      props: { post }
-    };
-  });
-}
-const {id} = Astro.params;
-const {post} = Astro.props;
----
-<body>
-  <h1>{id}: {post.title}</h1>
-  <h2>Categoría: {post.category}</h2>
-</body>
-```
-
-Luego, Astro generará estáticamente `posts/1` y `posts/2` en el momento de la compilación usando el componente de página en `pages/posts/[id].astro`. La página puede hacer referencia a estos datos usando `Astro.props`:
-
-### `paginate()`
-
-La paginación es un caso de uso común para los sitios web que Astro admite de forma nativa a través de la función `paginate()`. `paginate()` generará automáticamente un array para devolver desde `getStaticPaths()` que creará una URL para cada página de la colección paginada. El número de página se pasará como un parámetro, y los datos de la página se pasarán como una prop `page`.
-
-```js
-export async function getStaticPaths({ paginate }) {
-  // Carga tus datos con fetch(), Astro.glob(), etc.
-  const response = await fetch(`https://pokeapi.co/api/v2/pokemon?limit=150`);
-  const result = await response.json();
-  const allPokemon = result.results;
-
-  // Devuelve una colección paginada de rutas para todos los artículos.
-  return paginate(allPokemon, { pageSize: 10 });
-}
-
-// Si se configuró correctamente, La prop de la página ahora tiene todo lo que
-// necesita para renderizar una página (mira la siguiente sección).
-const { page } = Astro.props;
-```
-
-`paginate()` asume un nombre de archivo `[page].astro` o `[...page].astro`. El parámetro `page` se convierte en el número de página en la URL:
-
-- `/posts/[page].astro` generaría las URL `/posts/1`, `/posts/2`, `/posts/3`, etc.
-- `/posts/[...page].astro` generaría las URL `/posts`, `/posts/2`, `/posts/3`, etc.
-
-`paginate()` tiene los siguientes argumentos:
-- `pageSize` - El numero de artículos mostrados por página
-- `params` - Envía parámetros adicionales para la creación rutas dinámicas
-- `props` - Envía props adicionales para que estén disponibles en cada página
-
-#### La prop de paginación `page`
-
-La paginación pasará una prop `page` a cada página renderizada que represente una sola página de datos en la colección paginada. Esto incluye los datos que ha paginado (`page.data`), así como los metadatos de la página (`page.url`, `page.start`, `page.end`, `page.total`, etc.). Estos metadatos son útiles para cosas como un botón "Página siguiente" o un mensaje "Mostrando 1-10 de 100".
-
-##### `page.data`
-
-<p>
-**Tipo:** `Array`
-</p>
-
-Array de datos devueltos de `data()` para la página actual.
-
-##### `page.start`
-
-<p>
-**Tipo:** `number`
-</p>
-
-Índice del primer elemento en la página actual, comenzando en `0`. (p. ej. si `pageSize: 25`, esto sería `0` en la página 1, `25` en la página 2, etc.)
-
-##### `page.end`
-
-<p>
-**Tipo:** `number`
-</p>
-
-Índice del último elemento en la página actual.
-
-##### `page.size`
-
-<p>
-**Tipo:** `number`
-</p>
-
-Indica cuantos hay elementos por página.
-
-##### `page.total`
-
-<p>
-**Tipo:** `number`
-</p>
-
-El número total de elementos en todas las páginas.
-
-##### `page.currentPage`
-
-<p>
-**Tipo:** `number`
-</p>
-
-El número de página actual, comenzando en `1`.
-
-##### `page.lastPage`
-
-<p>
-**Tipo:** `number`
-</p>
-
-El número total de páginas.
-
-##### `page.url.current`
-
-<p>
-**Tipo:** `string`
-</p>
-
-Consigue la URL de la página actual (útil para URLs canónicas).
-
-##### `page.url.prev`
-
-<p>
-**Tipo:** `string | undefined`
-</p>
-
-Consigue la URL de la página anterior (será `undefined` si está en la página 1).
-
-##### `page.url.next`
-
-<p>
-**Tipo:** `string | undefined`
-</p>
-
-Consigue la URL de la página siguiente (será `undefined` si no hay más páginas).
-
-## `import.meta`
-
-Todos los módulos ESM incluyen una propiedad `import.meta`. Astro agrega `import.meta.env` a través de [Vite](https://vite.dev/guide/env-and-mode.html).
-
-**`import.meta.env.SSR`** se puede usar para saber cuándo se renderiza en el servidor. A veces, es posible que desees una lógica diferente, por ejemplo, un componente que solo debe representarse en el cliente:
-
-```jsx
-export default function () {
-  return import.meta.env.SSR ? <div class="spinner"></div> : <FancyComponent />;
-}
-```
-
-##  Imágenes (`astro:assets`)
-
-### getImage()
-
-:::caution
-`getImage()` depende de APIs exclusivas del servidor y provoca errores en la compilación cuando se utiliza en el cliente.
-:::
-
-La función `getImage()` está diseñada para generar imágenes destinadas a ser utilizadas en algún lugar que no sea directamente en HTML, por ejemplo, en una [Ruta de API](/es/guides/endpoints/#endpoints-del-servidor-rutas-de-api). También te permite crear tu propio componente `<Image />` personalizado.
-
-`getImage()` recibe un objeto de opciones con las [mismas propiedades que el componente Image](#propiedades) (excepto `alt`).
-
-```astro
----
-import { getImage } from "astro:assets";
-import myBackground from "../background.png"
-const optimizedBackground = await getImage({src: myBackground, format: 'avif'})
----
-<div style={`background-image: url(${optimizedBackground.src});`}></div>
-```
-
-Devuelve un objeto con las siguientes propiedades:
-
-```js
-{
-  options: {...} // Parámetros originales pasados
-  src: "https//..." // Ruta de la imagen generada
-  attributes: {...} // Atributos HTML adicionales necesarios para renderizar la imagen (width, height, style, etc..)
-}
-```
-
-## Colecciones de Contenido (`astro:content`)
-
-<p><Since v="2.0.0" /></p>
-
-Las colecciones de contenido ofrecen APIs para configurar y consultar tus documentos Markdown o MDX en `src/content/`. Para obtener características y ejemplos de uso, [consulta nuestra guía de colecciones de contenido](/es/guides/content-collections/).
-
-### `defineCollection()`
-
-`defineCollection()` es una utilidad para configurar una colección en un archivo `src/content/config.*`.
-
-```ts
-// src/content/config.ts
-import { z, defineCollection } from 'astro:content';
-const blog = defineCollection({
-  type: 'content',
-  schema: z.object({
-    title: z.string(),
-    permalink: z.string().optional(),
-  }),
-});
-// Expone tu colección definida a Astro
-// con el export `collections`
-export const collections = { blog };
-```
-
-Esta función acepta las siguientes propiedades:
-
-#### `type`
-
-<p><Since v="2.5.0" /></p>
-
-**Tipo:** `'content' | 'data'`  
-**Por defecto:** `'content'`
-
-`type` es un string que define el tipo de entradas almacenadas dentro de una colección:
-
-- `'content'` - para formatos de creación de contenido como Markdown (`.md`), MDX (`.mdx`) o Markdoc (`.mdoc`)
-- `'data'` - para formatos de datos únicamente como JSON (`.json`) o YAML (`.yaml`)
-
-:::tip
-Esto significa que las colecciones **no pueden** almacenar una mezcla de formatos de contenido y datos. Debes dividir estas entradas en colecciones separadas por tipo.
-:::
-
-#### `schema`
-
-**Type:** `TSchema extends ZodType`
-
-El `schema` es un objeto de Zod opcional para configurar el tipo y la forma del frontmatter del documento para una colección. Cada valor debe usar [un validador de Zod](https://github.com/colinhacks/zod).
-
-[Consulta la guía de `Colección de Contenido`](/es/guides/content-collections/#definiendo-un-esquema-de-colección) para ejemplos de uso.
-
-### `reference()`
-
-**Tipo:** `(collection: string) => ZodEffects<ZodString, { collection, id: string } | { collection, slug: string }>`
-
-La función `reference()` se utiliza en la configuración del contenido para definir una relación, o "referencia" de una colección a otra. Esta función acepta el nombre de la colección y valida el identificador/es de entrada especificados en el frontmatter o archivo de datos del contenido.
-
-Este ejemplo define referencias desde un autor de blog a la colección `authors` y a un arreglo de publicaciones relacionadas en la misma colección `blog`:
-
-```ts
-import { defineCollection, reference, z } from 'astro:content';
-const blog = defineCollection({
-  type: 'content',
-  schema: z.object({
-    // Hace referencia a un único autor de la colección `authors` mediante el campo `id`.
-    author: reference('authors'),
-    // Hace referencia a un arreglo de publicaciones relacionadas de la colección `blog` mediante el campo `slug`.
-    relatedPosts: z.array(reference('blog')),
-  })
-});
-const authors = defineCollection({
-  type: 'data',
-  schema: z.object({ /* ... */ })
-});
-export const collections = { blog, authors };
-```
-
-[Consulta la guía de `Content Collection`](/es/guides/content-collections/#definiendo-referencias-de-colección) para ver un ejemplo de uso.
-
-### `getCollection()`
-
-**Type:** `(collection: string, filter?: (entry: CollectionEntry<collection>) => boolean) => CollectionEntry<collection>[]`
-
-`getCollections()` es una función que recupera una lista de entradas de colección de contenido por nombre de colección.
-
-Regresa todos los elementos en la colección por defecto, y acepta una función opcional `filter` para reducir por propiedades de entrada. Esto te permite consultar solo algunos elementos en una colección basándose en `id`, `slug`, o valores de frontmatter a través del objeto `data`.
-
-```astro
----
-import { getCollection } from 'astro:content';
-// Obtiene todas las entradas de `src/content/blog/`
-const allBlogPosts = await getCollection('blog');
-// Solo regresa artīculos con `draft: true` en el frontmatter
-const draftBlogPosts = await getCollection('blog', ({ data }) => {
-  return data.draft === true;
-});
----
-```
-
-[Consulta la sección de guía de `getCollection()`](/es/guides/content-collections/#consultando-colecciones) para ejemplos de uso completo.
-
-### `getEntry()`
-
-<p><Since v="2.5.0" /></p>
-
-**Tipos:**
-
-- `(collection: string, contentSlugOrDataId: string) => CollectionEntry<collection>`
-- `({ collection: string, id: string }) => CollectionEntry<collection>`
-- `({ collection: string, slug: string }) => CollectionEntry<collection>`
-
-`getEntry()` es una función que recupera una única entrada de una colección mediante el nombre de la colección y ya sea el `id` de la entrada (para colecciones `type: 'data'`) o el `slug` de la entrada (para colecciones `type: 'content'`). `getEntry()` también se puede utilizar para obtener las entradas referenciadas y acceder a las propiedades `data`, `body` o `render()`:
-
-```astro
----
-import { getEntry } from 'astro:content';
-
-// Obtiene `src/content/blog/enterprise.md`
-const enterprisePost = await getEntry('blog', 'enterprise');
-
-// Obtiene `src/content/captains/picard.yaml`
-const picardProfile = await getEntry('captains', 'picard');
-
-// Obtener el perfil referenciado por `data.captain`
-const enterpriseCaptainProfile = await getEntry(enterprisePost.data.captain);
----
-```
-
-Consulta la guía de "Colecciones de Contenido" para ver ejemplos de [consulta de entradas de colecciones](/es/guides/content-collections/#consultando-colecciones).
-
-### `getEntries()`
-
-<p><Since v="2.5.0" /></p>
-
-**Tipos:**
-
-- `(Array<{ collection: string, id: string }>) => Array<CollectionEntry<collection>>`
-- `(Array<{ collection: string, slug: string }>) => Array<CollectionEntry<collection>>`
-
-`getEntries()` es una función que recupera múltiples entradas de una misma colección. Esto es útil para [devolver un arreglo de entradas referenciadas](/es/guides/content-collections/#definiendo-referencias-de-colección) para acceder a sus propiedades asociadas `data`, `body` y `render()`.
-
-```astro
----
-import { getEntries } from 'astro:content';
-const enterprisePost = await getEntry('blog', 'enterprise');
-// Obtener las publicaciones relacionadas referenciadas por `data.relatedPosts`
-const enterpriseRelatedPosts = await getEntries(enterprisePost.data.relatedPosts);
----
-```
-
-### `getEntryBySlug()`
-
-**Tipo:** `(collection: string, slug: string) => CollectionEntry<collection>`
-
-:::caution[Obsoleto]
-Utiliza la [función `getEntry()`](#getentry) para consultar las entradas de contenido. Esta función acepta los mismos argumentos que `getEntryBySlug()`, y admite la consulta por `id` para colecciones JSON o YAML.
-:::
-
-`getEntryBySlug()` is a function that retrieves a single collection entry by collection name and entry `slug`.
-
-
-```astro
----
-import { getEntryBySlug } from 'astro:content';
-const enterprise = await getEntryBySlug('blog', 'enterprise');
----
-```
-[Consulta la guía `Content Collection`](/es/guides/content-collections/#consultando-colecciones) para ver un ejemplo de uso.
-
-### Tipo de Entrada de la Colección
-
-Las funciones de consulta, incluyendo [`getCollection()`](#getcollection), [`getEntry()`](#getentry) y [`getEntries()`](#getentries), devuelven entradas con el tipo `CollectionEntry`. Este tipo está disponible como una utilidad desde `astro:content`:
-
-```ts
-import type { CollectionEntry } from 'astro:content';
-
-// Ejemplo: Recibe una entrada de `src/content/blog/` como props
-type Props = CollectionEntry<'blog'>;
-```
-
-Una `CollectionEntry<TCollectionName>` es un objeto con los siguientes valores:
-
-#### `id`
-
-**Disponible para:** `type: 'content'` and `type: 'data'` collections  
-**Tipos de ejemplo:**
-  - colecciones de contenido: `'entry-1.md' | 'entry-2.md' | ...`
-  - colecciones de datos: `'author-1' | 'author-2' | ...`
-
-Un identificador único que usa la ruta de archivo relativa a `src/content/[collection]`. Enumera todos los posibles valores de cadena basados en las rutas de archivo de entrada de colección. Ten en cuenta que las colecciones [definidas como `type: 'content'`](#type) incluyen la extensión de archivo en su ID, mientras que las colecciones definidas como `type: 'data'` no lo hacen.
-
-#### `collection`
-
-**Disponible para:** `type: 'content'` and `type: 'data'` collections  
-**Tipo de ejemplo:** `'blog' | 'authors' | ...`
-
-El nombre de una carpeta de nivel superior en `src/content/` en la cual se encuentran las entradas. Este es el nombre utilizado para hacer referencia a la colección en tu esquema y en las funciones de consulta.
-
-#### `data`
-
-**Disponible para:** `tipo: 'content'` y `tipo: collecciones 'data'`  
-**Tipo:** `CollectionSchema<TCollectionName>`
-
-Un objeto de propiedades de frontmatter inferidas de su esquema de colección ([ver referencia de `defineCollection()`](#definecollection)). Por defecto es `any` si no es configurado un esquema.
-
-#### `slug`
-
-**Disponible para:** `type: 'content'` collections only  
-**Tipo de ejemplo:** `'entry-1' | 'entry-2' | ...`
-
-Un slug listo para ser utilizado en una URL para documentos Markdown o MDX. Por defecto, se genera a partir del `id` sin la extensión de archivo, pero se puede modificar estableciendo [la propiedad `slug`](/es/guides/content-collections/#definiendo-slugs-personalizados) en el frontmatter del archivo.
-
-#### `body`
-
-**Disponible para:** `tipo: 'content'` solo colecciones
-**Tipo:** `string`
-
-Un string que contiene el cuerpo sin compilar del documento Markdown o MDX.
-
-#### `render()`
-
-**Disponible para:** `type: 'content'` solo colecciones
-**Tipo:** `() => Promise<RenderedEntry>`
-
-Una función para compilar un documento Markdown o MDX dado para su renderizado. Regresa las siguientes propiedades:
-
-- `<Content />` - Un componente usado para renderizar el contenido del documento en un archivo Astro.
-- `headings` - Una lista generada de encabezados, [que refleja la utilidad `getHeadings()` de Astro](/es/guides/markdown-content/#propiedades-exportadas) en las importaciones de Markdown y MDX.
-- `remarkPluginFrontmatter` - El objeto frontmatter es moficado después de aplicar los [plugins de remark o rehype ha sido aplicado](/es/guides/markdown-content/#modificación-programática-del-frontmatter). Configurado para el tipo `any`.
-
-```astro
----
-import { getEntry } from 'astro:content';
-const entry = await getEntry('blog', 'entry-1.md');
-const {Content, headings, remarkPluginFrontmatter} = await entry.render();
----
-```
-
-Ver [la guía de renderizado de contenido de entrada](/es/guides/content-collections/) para ejemplos de uso completo.
-
-### Otros tipos de colecciones de contenido
-
-El módulo `astro:content` también exporta los siguientes tipos para su uso en tu proyecto Astro:
-
-#### `CollectionKey`
-
-Una unión de strings de todos los nombres de colecciones definidos en tu archivo `src/content/config.*`. Este tipo puede ser útil al definir una función genérica que acepta cualquier nombre de colección.
-
-```ts
-import type { CollectionKey, getCollection } from 'astro:content';
-
-async function getCollection(collection: CollectionKey) {
-  return getCollection(collection);
-}
-```
-
-#### `ContentCollectionKey`
-
-Una unión de strings de todos los nombres de colecciones con `type: 'content'` definidos en tu archivo `src/content/config.*`.
-
-#### `DataCollectionKey`
-
-Una unión de strings de todos los nombres de colecciones con `type: 'data'` definidos en tu archivo `src/content/config.*`.
-
-#### `SchemaContext`
-
-El objeto `context` que `defineCollection` utiliza para dar forma a la función de `schema`. Este tipo puede ser útil al construir esquemas reutilizables para múltiples colecciones.
-
-Incluye la siguiente propiedad:
-
-- `image` - El helper de esquema `image()` que te permite [utilizar imágenes locales en colecciones de contenido](/es/guides/images/#imágenes-en-colecciones-de-contenido).
-
-```ts
-import type { SchemaContext } from 'astro:content';
-
-export const imageSchema = ({ image }: SchemaContext) =>
-    z.object({
-        image: image(),
-        description: z.string().optional(),
-    });
-
-const blog = defineCollection({
-  type: 'content',
-  schema: ({ image }) => z.object({
-    title: z.string(),
-    permalink: z.string().optional(),
-    image: imageSchema({ image })
-  }),
-});
-```
-
-## Middleware (`astro:middleware`)
-
-<p><Since v="2.6.0" /></p>
-
-El middleware te permite interceptar las peticiones y respuestas e inyectar comportamientos dinámicos cada vez que una página o un endpoint está a punto de ser renderizado. Para obtener características y ejemplos de uso, [consulta nuestra guía de middleware](/es/guides/middleware/).
-
-### `onRequest()`
-
-Una función exportada requerida de `src/middleware.js` que se llamará antes de renderizar cada página o ruta de API. Acepta dos argumentos opcionales: [context](#contextlocals) y [next()](#next). `onRequest()` debe devolver una `Response`: ya sea directamente, o llamando a `next()`.
-
-    ```js title="src/middleware.js"
-    export function onRequest (context, next) {
-        // intercepta los datos de respuesta de una petición
-        // opcionalmente, transforma la respuesta
-        // regresa una respuesta directamente o el resultado de llamar a `next()`
-        return next();
-    };
-    ```
-
-### `next()`
-
-Una función que intercepta (lee y modifica) la `Response` de una `Request` o llama al siguiente middleware en la cadena y devuelve una `Response`. Por ejemplo, esta función podría modificar el cuerpo HTML de una respuesta.
-
-Esto es un argumento opcional de `onRequest()`, y puede proporcionar la `Response` requerida devuelta por el middleware.
-
-
-### `sequence()`
-
-Una función que acepta funciones de middleware como argumentos y las ejecutará en el orden en que se pasan.
-
-```js title="src/middleware.js"
-import { sequence } from "astro:middleware";
-
-async function validation(_, next) {...}
-async function auth(_, next) {...}
-async function greeting(_, next) {...}
-
-export const onRequest = sequence(validation, auth, greeting);
-```
-
-### `createContext()`
-
-Una API de bajo nivel para crear un [`APIContext`](#contexto-del-endpoint) para ser pasado a una función `onRequest()` de middleware de Astro.
-
-Esta función puede ser utilizada por integraciones/adaptadores para ejecutar programáticamente el middleware de Astro.
-
-### `trySerializeLocals()`
-
-Una API de bajo nivel que toma cualquier valor y trata de devolver una versión serializada (un string) de él. Si el valor no se puede serializar, la función lanzará un error en tiempo de ejecución.
-
-## Internacionalización (`astro:i18n`)
-
-<p><Since v="3.5.0" /></p>
-
-Este módulo proporciona funciones para ayudarte a crear URLs utilizando los locales configurados en tu proyecto.
-
-Crear rutas para tu proyecto con el enrutador i18n dependerá de ciertos valores de configuración que hayas establecido y que afectan a las rutas de tus páginas. Al crear rutas con estas funciones, asegúrate de tener en cuenta tus ajustes individuales para:
-
-- [`base`](/es/reference/configuration-reference/#base)
-- [`trailingSlash`](/es/reference/configuration-reference/#trailingslash)
-- [`build.format`](/es/reference/configuration-reference/#buildformat)
-- [`site`](/es/reference/configuration-reference/#site)
-
-También, ten en cuenta que las URLs devueltas por estas funciones para tu `defaultLocale` reflejarán tu configuración de `i18n.routing`.
-
-Para obtener características y ejemplos de uso, [consulta nuestra guía de enrutamiento i18n](/es/guides/internationalization/).
-
-### `getRelativeLocaleUrl()` 
-
-`getRelativeLocaleUrl(locale: string, path?: string,  options?: GetLocaleOptions): string`
- 
-Usa esta función para obtener una ruta relativa para un idioma. Si el idioma no existe, Astro lanzará un error.
-
-```astro
----
-getRelativeLocaleUrl("fr");
-// devuelve /fr
-getRelativeLocaleUrl("fr", "");
-// devuelve /fr
-getRelativeLocaleUrl("fr", "getting-started");
-// devuelve /fr/getting-started
-getRelativeLocaleUrl("fr_CA", "getting-started", {
-  prependWith: "blog"
-}); 
-// devuelve /blog/fr-ca/getting-started
-getRelativeLocaleUrl("fr_CA", "getting-started", {
-  prependWith: "blog",
-  normalizeLocale: false
-}); 
-// devuelve /blog/fr_CA/getting-started
----
-```
-
-### `getAbsoluteLocaleUrl()` 
-
-`getAbsoluteLocaleUrl(locale: string, path: string, options?: GetLocaleOptions): string` 
-
-Usa esta función para obtener una ruta absoluta para un idioma cuando [`site`] tiene un valor. Si [`site`] no está configurado, la función devolverá una URL relativa. Si el idioma no existe, Astro lanzará un error.
-
-
-```astro title="src/pages/index.astro"
----
-// Si `site` está configurado como `https://example.com`
-getAbsoluteLocaleUrl("fr"); 
-// devuelve https://example.com/fr
-getAbsoluteLocaleUrl("fr", ""); 
-// devuelve https://example.com/fr
-getAbsoluteLocaleUrl("fr", "getting-started"); 
-// devuelve https://example.com/fr/getting-started
-getAbsoluteLocaleUrl("fr_CA", "getting-started", {
-  prependWith: "blog"
-}); 
-// devuelve https://example.com/blog/fr-ca/getting-started
-getAbsoluteLocaleUrl("fr_CA", "getting-started", {
-  prependWith: "blog",
-  normalizeLocale: false
-}); 
-// devuelve https://example.com/blog/fr_CA/getting-started
----
-```
-
-### `getRelativeLocaleUrlList()` 
-
-`getRelativeLocaleUrlList(path?: string, options?: GetLocaleOptions): string[]`
-
-Usa esto como [`getRelativeLocaleUrl`](#getrelativelocaleurl) para devolver una lista de rutas relativas para todos los idiomas.
-
-
-### `getAbsoluteLocaleUrlList()` 
-
-`getAbsoluteLocaleUrlList(path?: string, options?: GetLocaleOptions): string[]`
-
-Usa esto como [`getAbsoluteLocaleUrl`](/es/guides/internationalization/#rutas-de-idioma-personalizadas) para devolver una lista de rutas absolutas para todos los idiomas.
-
-### `getPathByLocale()` 
-
-`getPathByLocale(locale: string): string`
-
-Una función que devuelve el `path` asociado a uno o más `codes` cuando se configuran [rutas de idioma personalizadas](/es/guides/internationalization/#rutas-de-idioma-personalizadas).
-
-```js title="astro.config.mjs"
-export default defineConfig({
-  i18n: {
-    locales: ["es", "en", {
-      path: "french",
-      codes: ["fr", "fr-BR", "fr-CA"]
-    }]
-  }
-})
-```
-
-```astro title="src/pages/index.astro"
----
-getPathByLocale("fr"); // devuelve "french"
-getPathByLocale("fr-CA"); // devuelve "french"
----
-```
-
-### `getLocaleByPath`
-
- `getLocaleByPath(path: string): string`
-
-Una función que devuelve el `code` asociado a un `path` de idioma.
-
-```js title="astro.config.mjs"
-export default defineConfig({
-  i18n: {
-    locales: ["es", "en", {
-      path: "french",
-      codes: ["fr", "fr-BR", "fr-CA"]
-    }]
-  }
-})
-```
-
-```astro title="src/pages/index.astro"
----
-getLocaleByPath("french"); // devuelve "fr" porque es el primer código configurado
----
-```
-
-### `redirectToDefaultLocale()`
-
-`redirectToDefaultLocale(context: APIContext, statusCode?: ValidRedirectStatus): Promise<Response>`
-
-<p><Since v="4.6.0" /></p>
-
-:::note
-Disponible solo cuando `i18n.routing` está configurado en `"manual"`
-:::
-
-Una función que devuelve una `Response` que redirige al `defaultLocale` configurado. Acepta un código de estado de redirección válido opcional.
-
-```js title="middleware.js"
-import { defineMiddleware } from "astro:middleware";
-import { redirectToDefaultLocale } from "astro:i18n";
-
-export const onRequest = defineMiddleware((context, next) => {
-  if (context.url.pathname.startsWith("/about")) {
-    return next();
-  } else {
-    return redirectToDefaultLocale(context, 302);
-  }
-})
-```
-
-### `redirectToFallback()`
-
-`redirectToFallback(context: APIContext, response: Response): Promise<Response>`
-
-<p><Since v="4.6.0" /></p>
-
-:::note
-Disponible solo cuando `i18n.routing` está configurado en `"manual"`
-:::
-
-Una función que te permite usar tu configuración de [`i18n.fallback`](/es/reference/configuration-reference/#i18nfallback) en tu propio middleware.
-
-```js title="middleware.js"
-import { defineMiddleware } from "astro:middleware";
-import { redirectToFallback } from "astro:i18n";
-
-export const onRequest = defineMiddleware(async (context, next) => {
-  const response = await next();
-  if (response.status >= 300) {
-    return redirectToFallback(context, response)
-  }
-  return response;
-})
-```
-
-### `notFound()`
-
-`notFound(context: APIContext, response: Response): Promise<Response>`
-
-<p><Since v="4.6.0" /></p>
-
-:::note
-Disponible solo cuando `i18n.routing` está configurado en `"manual"`
-:::
-
-Usa esta función en tu middleware de enrutamiento para devolver un 404 cuando:
-- la ruta actual no es una raíz. por ejemplo, `/` o `/<base>`
-- la URL no contiene un idioma configurado
-
-Cuando se pasa una `Response`, la nueva `Response` emitida por esta función contendrá los mismos encabezados de la respuesta original.
-
-```js title="middleware.js"
-import { defineMiddleware } from "astro:middleware";
-import { notFound } from "astro:i18n";
-
-export const onRequest = defineMiddleware((context, next) => {
-  const pathNotFound = notFound(context);
-  if (pathNotFound) {
-    return pathNotFound;
-  }
-  return next();
-})
-```
-
-### `middleware()`
-
-`middleware(options: { prefixDefaultLocale: boolean, redirectToDefaultLocale: boolean })`
-
-<p><Since v="4.6.0" /></p>
-
-:::note
-Disponible solo cuando `i18n.routing` está configurado en `"manual"`
-:::
-
-Una función que te permite crear programáticamente el middleware de Astro i18n.
-
-Esto es útil cuando aún deseas utilizar la lógica i18n predeterminada, pero solo agregar algunas excepciones a tu sitio web.
-
-```js title="middleware.js"
-import { middleware } from "astro:i18n";
-import { sequence, defineMiddleware } from "astro:middleware";
-
-const customLogic = defineMiddleware(async (context, next) => {
-  const response = await next();
-
-  // Lógica personalizada después de resolver la respuesta.
-  // Es posible capturar la respuesta que proviene del middleware de Astro i18n.
-
-  return response;
-});
-
-export const onRequest = sequence(customLogic, middleware({
-	prefixDefaultLocale: true,
-	redirectToDefaultLocale: false
-}))
-```
-
-### `requestHasLocale()`
-
-`requestHasLocale(context: APIContext): boolean`
-
-<p><Since v="4.6.0" /></p>
-
-:::note
-Disponible solo cuando `i18n.routing` está configurado en `"manual"`
-:::
-
-Verifica si la URL actual contiene un idioma configurado. Internamente, esta función usará `APIContext#url.pathname`.
-
-```js title="middleware.js"
-import { defineMiddleware } from "astro:middleware";
-import { requestHasLocale } from "astro:i18n";
-
-export const onRequest = defineMiddleware(async (context, next) => {
-  if (requestHasLocale(context)) {
-    return next();
-  }
-  return new Response("Not found", { status: 404 });
-})
-```
-
-## Componentes incorporados
-
-Astro incluye varios componentes integrados que puedes usar en tus proyectos. Todos los componentes integrados están disponibles en archivos `.astro` a través de `import {} from 'astro:components';`.
-
-### `<Code />`
-
-```astro 'theme="dark-plus"' /wrap\b/ /(inline) \/>/
----
-import { Code } from 'astro:components';
----
-<!-- Resaltado de sintaxis de algún código JavaScript. -->
-<Code code={`const foo = 'bar';`} lang="js" />
-<!-- Opcional: personaliza tu tema. -->
-<Code code={`const foo = 'bar';`} lang="js" theme="dark-plus" />
-<!-- Opcional: habilita css wrap -->
-<Code code={`const foo = 'bar';`} lang="js" wrap />
-<!-- Opcional: salida de código en línea -->
-<p>
-  <Code code={`const foo = 'bar';`} lang="js" inline />
-  will be rendered inline.
-</p>
-```
-
-Este componente proporciona resaltado de sintaxis para bloques de código en el momento de la compilación (no incluye JavaScript del lado del cliente). El componente funciona internamente con Shiki y es compatible con todos los [temas populares](https://shiki.style/themes) y [lenguajes de programación](https://shiki.style/languages). Además, puedes agregar temas y lenguajes de programación personalizados modificando `theme` y `lang` respectivamente.
-
-### `<Fragment />`
-
-Un componente utilizado con las [directivas `set:*`](/es/reference/directives-reference/#sethtml) para representar contenido HTML sin elementos de envoltura adicionales:
-
-```astro title="src/components/SetHtml.astro" "Fragment"
----
-const htmlString = '<p>Contenido HTML en bruto</p>';
----
-<Fragment set:html={htmlString} />
-```
-
-Consulta más información sobre [el uso de fragmentos](/es/reference/astro-syntax/#fragmentos) en la sintaxis de Astro.
-
-### `<Prism />`
-
-Para usar el componente resaltador `Prism`, primero **instala** el paquete `@astrojs/prism`:
-
-<PackageManagerTabs>
-  <Fragment slot="npm">
-  ```shell
-  npm install @astrojs/prism
-  ```
-  </Fragment>
-  <Fragment slot="pnpm">
-  ```shell
-  pnpm add @astrojs/prism
-  ```
-  </Fragment>
-  <Fragment slot="yarn">
-  ```shell
-  yarn add @astrojs/prism
-  ```
-  </Fragment>
-</PackageManagerTabs>
-
-```astro
----
-import { Prism } from '@astrojs/prism';
----
-<Prism lang="js" code={`const foo = 'bar';`} />
-```
-
-Este componente proporciona resaltado de sintaxis específico con el lenguaje de programación para bloques de código al aplicar las clases CSS de Prism. Ten en cuenta que **debes proporcionar una hoja de estilo Prism CSS** (o traer la tuya propia) para que aparezca el resaltado de sintaxis. Consulta la [sección de configuración de Prism](/es/guides/markdown-content/#configuración-de-prism) para obtener más detalles.
-
-Consulta la [lista de idiomas admitidos por Prism](https://prismjs.com/#supported-languages) donde puedes encontrar el alias correspondiente de un idioma. ¡Y también puedes mostrar tus bloques de código Astro con `lang="astro"`!
-
-### `<Image />`
-
-```astro title="src/components/MyComponent.astro"
----
-// Importa el componente Image y la imagen
-import { Image } from 'astro:assets';
-import myImage from "../assets/my_image.png"; // La imagen es 1600x900
----
-<!-- `alt` es obligatorio en el componente Image -->
-<Image src={myImage} alt="Una descripción de mi imagen." />
-```
-
-```html
-<!-- Salida -->
-<!-- La imagen está optimizada y se aplican atributos adecuados -->
-<img
-  src="/_astro/my_image.hash.webp"
-  width="1600"
-  height="900"
-  decoding="async"
-  loading="lazy"
-  alt="Una descripción de mi imagen."
-/>
-```
-#### Propiedades
-
-- src (requerido)
-- alt (requerido)
-- width y height (requerido para imágenes `public/` y remotas)
-- format
-- quality
-- densities
-- widths
-
-Además de las propiedades mencionadas anteriormente, el componente `<Image />` acepta todas las propiedades aceptadas por la etiqueta HTML `<img>`.
-
-Mira más en la [guía de imágenes](/es/guides/images/#image--astroassets).
-
-### `<Picture />`
-
-<p><Since v="3.3.0" /></p>
-
-Utiliza el componente integrado `<Picture />` de Astro para mostrar una imagen responsiva con varios formatos y/o tamaños.
-
-```astro title="src/pages/index.astro"
----
-import { Picture } from 'astro:assets';
-import myImage from "../assets/my_image.png"; // La imagen es 1600x900
----
-<!-- `alt` es obligatorio en el componente Image -->
-<Picture src={myImage} formats={['avif', 'webp']} alt="Una descripción de mi imagen." />
-```
-
-```html
-<!-- Salida -->
-<picture>
-  <source srcset="/_astro/my_image.hash.avif" type="image/avif" />
-  <source srcset="/_astro/my_image.hash.webp" type="image/webp" />
-  <img
-    src="/_astro/my_image.hash.png"
-    width="1600"
-    height="900"
-    decoding="async"
-    loading="lazy"
-    alt="Una descripción de mi imagen."
-  />
-</picture>
-```
-
-Mira más en la [guía de imágenes](/es/guides/images/#picture-).
-
-#### Propiedades
-
-`<Picture />` acepta todas las propiedades del componente `<Image />`, además de las siguientes:
-
-##### `formats`
-
-Un array de formatos de imagen para usar en las etiquetas `<source>`. De forma predeterminada, esto está configurado como `['webp']`.
-
-##### `fallbackFormat`
-
-Formato que se utilizará como valor de respaldo para la etiqueta `<img>`. De forma predeterminada, se establece en `.png` para imágenes estáticas, `.gif` para imágenes animadas y `.svg` para archivos SVG.
-
-##### `pictureAttributes`
-
-Un objeto de atributos que se agregarán a la etiqueta `<picture>`. Utiliza esta propiedad para aplicar atributos al propio elemento `<picture>`. Los atributos aplicados directamente al componente `<Picture />` se aplicarán al elemento `<img>` interno, excepto aquellos utilizados para la transformación de la imagen.
-
-### `<Content />`
-
-Un componente genérico utilizado para representar el contenido de una [entrada de colección de contenido](/es/guides/content-collections/#qué-son-las-colecciones-de-contenido).
-
-Primero, consulta una o varias entradas utilizando `getCollection()` o `getEntry()`. Entonces, la función `entry.render()` puede devolver el componente `<Content />` para utilizarlo en una plantilla de archivo `.astro`.
-
-```astro title="src/pages/render-example.astro" {4, 7}
----
-import { getEntry } from 'astro:content';
-const entry = await getEntry('blog', 'post-1');
-const { Content } = await entry.render();
----
-<p>Publicado el: {entry.data.published.toDateString()}</p>
-<Content />
-```
-
-### `<ViewTransitions />`
-
-Opta por utilizar view transitions en páginas individuales importando y agregando el componente de enrutamiento `<ViewTransitions />` en la etiqueta `<head>` de cada página deseada.
-
-```astro title="src/pages/index.astro" ins={2,7}
----
-import { ViewTransitions } from 'astro:transitions';
----
-<html lang="es">
-  <head>
-    <title>Mi página de inicio</title>
-    <ViewTransitions />
-  </head>
-  <body>
-    <h1>¡Bienvenido a mi página web!</h1>
-  </body>
-</html>
-```
-
-Mira más acerca de cómo [controlar el enrutador](/es/guides/view-transitions/#controlar-el-enrutador) y [añadir directivas de transición](/es/guides/view-transitions/#directivas-de-transición) a elementos de página y componentes.
-
-### `<Debug />`
-
-```astro
----
-import { Debug } from 'astro:components';
-const serverObject = {
-  a: 0,
-  b: "string",
-  c: {
-    nested: "object"
-  }
-}
----
-<Debug {serverObject} />
-```
-
-Este componente proporciona una forma de inspeccionar valores en el lado del cliente, sin JavaScript.
-
-[canonical]: https://en.wikipedia.org/wiki/Canonical_link_element
diff --git a/src/content/docs/es/reference/astro-syntax.mdx b/src/content/docs/es/reference/astro-syntax.mdx
index bdfdbb725af6c..2db03e6944137 100644
--- a/src/content/docs/es/reference/astro-syntax.mdx
+++ b/src/content/docs/es/reference/astro-syntax.mdx
@@ -118,7 +118,7 @@ Al utilizar etiquetas dinámicas:
 
 - **Los nombres de las variables deben ir en mayúsculas.** Por ejemplo, usa `Elemento`, no `elemento`. De lo contrario, Astro intentará representar el nombre de la variable como una etiqueta HTML literal.
 
-- **No se admiten directivas de hidratación.** Cuando se usan las [directivas `client:*` de hidratación](/es/guides/framework-components/#hidratando-componentes-interactivos), Astro necesita saber qué componentes empaquetar para producción, y el patrón de etiquetas dinámicas impide que esto funcione.
+- **No se admiten directivas de hidratación.** Cuando se usan las [directivas `client:*` de hidratación](/es/guides/framework-components/#hydrating-interactive-components), Astro necesita saber qué componentes empaquetar para producción, y el patrón de etiquetas dinámicas impide que esto funcione.
 
 - **La [directiva define:vars](/es/reference/directives-reference/#definevars) no está soportada.** Si no puedes envolver los hijos con un elemento adicional (por ejemplo, `<div>`), entonces puedes añadir manualmente un ``style={`--myVar:${value}`}`` a tu Elemento.
 
diff --git a/src/content/docs/es/reference/cli-reference.mdx b/src/content/docs/es/reference/cli-reference.mdx
deleted file mode 100644
index 2b9918cabbf34..0000000000000
--- a/src/content/docs/es/reference/cli-reference.mdx
+++ /dev/null
@@ -1,541 +0,0 @@
----
-title: Comandos del CLI
-i18nReady: true 
----
-import Since from '~/components/Since.astro';
-import PackageManagerTabs from '~/components/tabs/PackageManagerTabs.astro'
-import ReadMore from '~/components/ReadMore.astro'
-
-Puedes usar la Interfaz de Línea de Comandos (CLI) proporcionada por Astro para desarrollar, construir y previsualizar tu proyecto desde una ventana de la terminal.
-
-### Comandos `astro`
-
-Usa el CLI ejecutando alguno de los **comandos** documentados en esta página con tu gestor de paquetes preferido, opcionalmente seguido por alguna **flag**. Las banderas personalizan el comportamiento de un comando.
-
-Uno de los comandos que usarás con mayor frecuencia es `astro dev`. Este comando inicia el servidor de desarrollo y te da una vista previa en vivo y actualizada de tu sitio en un navegador mientras trabajas:
-
-<PackageManagerTabs>
-  <Fragment slot="npm">
-  ```shell
-  # empieza el servidor de desarrollo
-  npx astro dev
-  ```
-  </Fragment>
-  <Fragment slot="pnpm">
-  ```shell
-  # empieza el servidor de desarrollo
-  pnpm astro dev
-  ```
-  </Fragment>
-  <Fragment slot="yarn">
-  ```shell
-  # empieza el servidor de desarrollo
-  yarn astro dev
-  ```
-  </Fragment>
-</PackageManagerTabs>
-
-Puedes escribir `astro --help` en tu terminal para mostrar una lista de todos los comandos disponibles:
-
-<PackageManagerTabs>
-  <Fragment slot="npm">
-  ```shell
-  npx astro --help
-  ```
-  </Fragment>
-  <Fragment slot="pnpm">
-  ```shell
-  pnpm astro --help
-  ```
-  </Fragment>
-  <Fragment slot="yarn">
-  ```shell
-  yarn astro --help
-  ```
-  </Fragment>
-</PackageManagerTabs>
-
-El siguiente mensaje se mostrará en tu terminal:
-
-```bash
-astro [command] [...flags]
-Commands
-              add  Add an integration.
-            build  Build your project and write it to disk.
-            check  Check your project for errors.
-              dev  Start the development server.
-             docs  Open documentation in your web browser.
-             info  List info about your current Astro setup.
-          preview  Preview your build locally.
-             sync  Generate content collection types.
-        telemetry  Configure telemetry settings.
-Global Flags
-  --config <path>  Specify your config file.
-    --root <path>  Specify your project root folder.
-     --site <url>  Specify your project site.
---base <pathname>  Specify your project base.
-        --verbose  Enable verbose logging.
-         --silent  Disable all logging.
-        --version  Show the version number and exit.
-           --open  Abre la aplicación en el navegador al iniciar el servidor.
-           --help  Show this help message.
-```
-
-:::note
-El doble guion `--` adicional antes de cualquier bandera es necesario para que `npm` pase tus banderas al comando `astro`.
-:::
-
-### Scripts `package.json` 
-
-También puedes usar scripts en el `package.json` para versiones más cortas de estos comandos. Usar un script te permite usar los mismos comandos que podrías estar familiarizado de otros proyectos, como `npm run build`.
-
-El siguiente script para los comandos más comunes de `astro` (`astro dev`, `astro build` y `astro preview`) se agrega automáticamente cuando creas un proyecto usando [el asistente `create astro`](/es/install-and-setup/).
-
-Cuando sigues las instrucciones para [instalar Astro manualmente](/es/install-and-setup/#configuración-manual), se te indica que agregues estos scripts tú mismo. También puedes agregar más scripts a esta lista manualmente para cualquier comando que uses con frecuencia.
-
-```json title="package.json"
-{
-  "scripts": {
-    "dev": "astro dev",
-    "start": "astro dev",
-    "build": "astro build",
-    "preview": "astro preview"
-  }
-}
-```
-
-Seguido usarás estos comandos `astro` o los scripts que los ejecutan, sin ninguna flag. Agrega las banderas al comando cuando quieras personalizar el comportamiento del comando. Por ejemplo, es posible que desees iniciar el servidor de desarrollo en un puerto diferente, o construir tu sitio 
-con registros detallados para la depuración.
-
-<PackageManagerTabs>
-  <Fragment slot="npm">
-  ```shell
-  # ejecuta el servidor de desarrollo en el puerto 8080 usando el script `start` en `package.json`
-  npm run start -- --port 8080
-  # compila tu sitio con registros detallados usando el script `build` en `package.json`
-  npm run build -- --verbose
-  ```
-  </Fragment>
-  <Fragment slot="pnpm">
-  ```shell
-  # ejecuta el servidor de desarrollo en el puerto 8080 usando el script `start` en `package.json`
-  pnpm start --port 8080
-  # compila tu sitio con registros detallados usando el script `build` en `package.json`
-  pnpm build --verbose
-  ```
-  </Fragment>
-  <Fragment slot="yarn">
-  ```shell
-  # ejecuta el servidor de desarrollo en el puerto 8080 usando el script `start` en `package.json`
-  yarn start --port 8080
-  # compila tu sitio con registros detallados usando el script `build` en `package.json`
-  yarn build --verbose
-  ```
-  </Fragment>
-</PackageManagerTabs>
-
-{/*
-
-CONTENIDO ORIGINAL Que siempre podemos revertir si el nuevo contenido es demasiado amigable
-
-Usa la CLI corriendo algún **comando** documentado en esta página, seguido opcionalmente por una o más **flags**. Las flags indican el comportamiento de un comando. Por ejemplo, para iniciar el servidor de desarrollo en el puerto `8080`, deberías combinar el comando `astro dev` con la flag `--port`: `astro dev --port 8080`.
-
-En la mayoría de los casos utilizarás la CLI por medio de tu gestor de paquetes:
-
-<PackageManagerTabs>
-  <Fragment slot="npm">
-  ```shell
-  npx astro dev --port 8080
-  ```
-  </Fragment>
-  <Fragment slot="pnpm">
-  ```shell
-  pnpm astro dev --port 8080
-  ```
-  </Fragment>
-  <Fragment slot="yarn">
-  ```shell
-  yarn astro dev --port 8080
-  ```
-  </Fragment>
-</PackageManagerTabs>
-
-Si has inicializado tu proyecto usando [el asistente `create astro`](/es/install=), también puedes usar los scripts en `package.json` para usar una versión más corta de esos comandos. Puedes ver el `README.md` de tu proyecto para ver detalles de qué comandos están disponibles.
-
-<PackageManagerTabs>
-  <Fragment slot="npm">
-  ```shell
-  # corre el servidor de desarrollo en el puerto 8080 usando el script `start` en `package.json`
-  npm run start -- --port 8080
-  ```
-  </Fragment>
-  <Fragment slot="pnpm">
-  ```shell
-  # corre el servidor de desarrollo en el puerto 8080 usando el script `start` en `package.json`
-  pnpm start --port 8080
-  ```
-  </Fragment>
-  <Fragment slot="yarn">
-  ```shell
-  # corre el servidor de desarrollo en el puerto 8080 usando el script `start` en `package.json`
-  yarn start --port 8080
-  ```
-  </Fragment>
-</PackageManagerTabs>
-
-*/}
-
-## `astro dev`
-
-Corre el servidor de desarrollo de Astro. Es un servidor HTTP local que no empaqueta recursos. Usa Hot Module Replacement (HMR) para actualizar tu navegador a medida que guardas los cambios en tu editor.
-
-## `astro build`
-
-Construye tu proyecto para producción. Por defecto, Astro generará archivos estáticos y los colocará en el directorio `dist/`. Si [SSR está habilitado](/es/guides/on-demand-rendering/), Astro generará los archivos necesarios para que el servidor renderice tu proyecto.
-
-Se puede combinar con la [bandera común](#banderas-comunes) documentada a continuación.
-
-## `astro preview`
-
-Inicia un servidor local para servir el contenido de su directorio estático (`dist/` por defecto) creado al ejecutar `astro build`.
-
-Este comando es útil para obtener una vista previa de tu proyecto usando los archivos generados en la compilación final, antes de ser desplegado. Este comando no está diseñado para ejecutarse en producción. Para obtener ayuda con el despliegue a producción, consulta nuestra guía de [despliegue de un sitio web de Astro](/es/guides/deploy/).
-
-Desde Astro 1.5.0, `astro preview` también funciona para compilaciones con SSR si usas un adaptador que lo soporte. Actualmente, solo el [adaptador de Node](/es/guides/integrations-guide/node/) soporta `astro preview`.
-
-Puede combinarse con las [banderas comunes](#banderas-comunes) documentadas más abajo.
-
-## `astro check`
-
-Ejecuta diagnósticos (como verificación de tipos dentro de archivos `.astro`) en tu proyecto y reporta errores en la consola. Si se encuentran errores, el proceso finalizará con el código **1**.
-
-Este comando está diseñado para usarse en workflows de CI.
-
-<h3>Flags</h3>
-
-Utilice estas flags para personalizar el comportamiento del comando.
-
-#### `--watch`
-
-El comando observará cualquier cambio en su proyecto e informará cualquier error.
-
-<ReadMore>Leer más sobre [verificación de tipos en Astro](/es/guides/typescript/#verificación-de-tipos).</ReadMore>
-
-## `astro sync`
-
-<p><Since v="2.0.0" /></p>
-
-:::tip
-Ejecutar `astro dev` o `astro build` ejecutará el comando `sync` también.
-:::
-
-Genera tipos de TypeScript para todos los módulos de Astro. Esto establece un [archivo `src/env.d.ts`](/es/guides/typescript/#configuración) para inferencia de tipos y define los módulos para características que dependen de tipos generados:
-- El módulo `astro:content` para la [API de Colecciones de Contenido](/es/guides/content-collections/).
-- El módulo `astro:db` para [Astro DB](/es/guides/astro-db/).
-
-## `astro add`
-
-Agrega una integración a tu configuración. Lee más en la [guía de integraciones](/es/guides/integrations-guide/#configuración-de-integración-automática).
-
-## `astro docs`
-
-Inicia el sitio web de la documentación de Astro directamente desde la terminal.
-
-## `astro info`
-
-Proporciona información útil sobre tu entorno de Astro actual. Útil para proporcionar información al abrir un issue.
-
-```shell
-astro info
-```
-
-Ejemplo de salida:
-
-```
-Astro                    v3.0.12
-Node                     v20.5.1
-System                   macOS (arm64)
-Package Manager          pnpm
-Output                   server
-Adapter                  @astrojs/vercel/serverless
-Integrations             none
-```
-
-## `astro preferences`
-
-Gestiona las preferencias de usuario con el comando `astro preferences`. Las preferencias de usuario son específicas para los usuarios individuales de Astro, a diferencia del archivo `astro.config.mjs` que cambia el comportamiento de todos los que trabajan en un proyecto.
-
-Por defecto, las preferencias del usuario se limitan al proyecto actual y se almacenan en un archivo local `.astro/settings.json`.
-
-Usando el indicador `--global`, las preferencias del usuario también se pueden aplicar a cada proyecto de Astro en la máquina actual. Las preferencias globales del usuario se almacenan en una ubicación específica del sistema operativo.
-
-Por ejemplo, para desactivar la devToolbar en un proyecto Astro específico:
-
-```shell
-astro preferences disable devToolbar
-```
-
-Para desactivar la devToolbar en todos los proyectos Astro en la máquina actual:
-
-```shell
-astro preferences disable --global devToolbar
-```
-
-La devToolbar se puede activar más tarde con:
-
-```shell
-astro preferences enable devToolbar
-```
-
-El comando `reset` restablece una preferencia a su valor por defecto:
-
-```shell
-astro preferences reset devToolbar
-```
-
-El comando `list` imprime la configuración actual de todas las preferencias de usuario configurables. También admite una salida `--json` legible por máquina.
-
-```shell
-astro preferences list
-```
-
-## `astro telemetry`
-
-Establece la configuración de telemetría para el usuario de la CLI actual. La telemetría son datos anónimos que proporcionan información al equipo de Astro sobre qué características de Astro se utilizan con más frecuencia. Para obtener más información, consulta la [página de telemetría de Astro](https://astro.build/telemetry/).
-
-La telemetría se puede desactivar con este comando:
-
-```shell
-astro telemetry disable
-```
-
-La telemetría se puede volver a habilitar con:
-
-```shell
-astro telemetry enable
-```
-
-El comando `reset` restablece los datos de telemetría:
-
-```shell
-astro telemetry reset
-```
-
-:::tip[¿Quieres deshabilitar la telemetría en entornos CI?]
-Asegúrate de agregar el comando `astro telemetry disabled` a tus scripts de CI o establezca la variable de entorno `ASTRO_TELEMETRY_DISABLED`.
-:::
-
-## Banderas Comunes
-
-### `--root path`
-
-Especifica la ruta a la raíz del proyecto. Si no se especifica, se asume que la carpeta de trabajo actual es la raíz.
-
-La raíz se utiliza para encontrar el archivo de configuración de Astro.
-
-```shell
-astro --root miCarpetaRaiz/miCarpetaDeProyecto dev
-```
-
-### `--config <path>`
-
-Especifica la ruta relativa al archivo de configuración desde la raíz del directorio. El valor predeterminado es `astro.config.mjs`. Usa esta opción si usas un nombre diferente en el archivo de configuración o si tienes tu archivo de configuración en otra carpeta.
-
-```shell
-astro --config config/astro.config.mjs dev
-```
-
-### `--outDir <path>`
-
-<p><Since v="3.3.0" /></p>
-
-Configura el [`outDir`](/es/reference/configuration-reference/#outdir) para tu proyecto. Pasar esta bandera anulará el valor de `outDir` en tu archivo `astro.config.mjs`, si existe.
-
-### `--site <url>`
-
-Configura el valor de [`site`](/es/reference/configuration-reference/#site) para tu proyecto. Usando este flag sobreescribirá el valor actual de `site` en tu archivo `astro.config.mjs`, si es que existe.
-
-### `--base <pathname>`
-
-<p><Since v="1.4.1" /></p>
-
-Configura el valor de [`base`](/es/reference/configuration-reference/#base) para tu proyecto. Usando este flag sobreescribirá el valor actual de `base` en tu archivo `astro.config.mjs`, si es que existe.
-
-#### `--port <number>`
-
-Especifica en qué puerto se ejecuta el servidor. El valor predeterminado es `4321`.
-
-#### `--host [dirección de host opcional]`
-
-Establece qué direcciones IP de red debe escuchar el servidor de desarrollo (es decir, direcciones IP que no son de localhost). Esto puede ser útil para probar tu proyecto en dispositivos locales tales como un teléfono durante el desarrollo.
-
-- `--host` - escucha todas las direcciones, incluidas LAN y direcciones públicas
-- `--host <dirección-personalizada>` - expone la dirección IP especificada en `<dirección-personalizada>`
-
-:::caution
-No uses la flag `--host` para exponer el servidor de desarrollo en un entorno de producción. El servidor de desarrollo está diseñado únicamente para uso local mientras desarrollas tu proyecto.
-:::
-
-### `--verbose`
-
-Habilita el registro detallado, que es útil al debuggear un problema.
-
-### `--silent`
-
-Habilita el registro silencioso, que correrá el servidor sin ninguna salida en la consola.
-
-## Banderas Globales
-
-Usa estas banderas para obtener información sobre la CLI de `astro`.
-
-### `--version`
-
-Imprime el número de versión de Astro y finaliza el proceso.
-
-### `--open`
-
-Abre automáticamente la aplicación en el navegador al iniciar el servidor. Se le puede pasar un string de URL completo (p. ej. `--open http://example.com`) o una ruta (p. ej. `--open /about`) para especificar la URL a abrir.
-
-### `--help`
-
-Imprime un mensaje de ayuda.
-
-## APIs avanzadas (Experimental)
-
-Si necesitas más control al ejecutar Astro, el paquete `"astro"` también exporta APIs para ejecutar los comandos de la CLI de manera programática.
-
-Estas APIs son experimentales y su firma de API puede cambiar. Cualquier actualización se mencionará en el [registro de cambios de Astro](https://github.com/withastro/astro/blob/main/packages/astro/CHANGELOG.md) y la información a continuación siempre mostrará la información actual y actualizada.
-
-### `AstroInlineConfig`
-
-El tipo `AstroInlineConfig` es utilizado por todas las APIs de comandos que se detallan a continuación. Este extiende de la [configuración de Astro del usuario](/es/reference/configuration-reference/):
-
-```ts
-interface AstroInlineConfig extends AstroUserConfig {
-	configFile?: string | false;
-	mode?: "development" | "production";
-	logLevel?: "debug" | "info" | "warn" | "error" | "silent";
-}
-```
-
-#### `configFile`
-
-<p>
-
-**Tipo:** `string | false`<br />
-**Por defecto:** `undefined`
-</p>
-
-Una ruta personalizada al archivo de configuración de Astro.
-
-Si este valor es `undefined` (predeterminado) o no se establece, Astro buscará un archivo `astro.config.(js,mjs,ts)` en relación con la `root` y cargará el archivo de configuración si se encuentra.
-
-Si se establece una ruta relativa, se resolverá en función del directorio de trabajo actual.
-
-Establece a `false` para deshabilitar la carga de cualquier archivo de configuración.
-
-La configuración en línea proporcionada en este objeto tendrá la mayor prioridad al fusionarse con la configuración de usuario cargada.
-
-#### `mode`
-
-<p>
-
-**Tipo:** `"development" | "production"`<br />
-**Por defecto:** `"development"` cuando se ejecuta `astro dev`, `"production"` cuando se ejecuta `astro build`
-</p>
-
-El modo utilizado al compilar tu sitio para generar código "development" o "production".
-
-#### `logLevel`
-
-<p>
-
-**Tipo:** `"debug" | "info" | "warn" | "error" | "silent"`<br />
-**Por defecto:** `"info"`
-</p>
-
-El nivel de registro para filtrar los mensajes registrados por Astro.
-
-- `"debug"`: Registrar todo, incluyendo diagnósticos ruidosos de depuración.
-- `"info"`: Registrar mensajes informativos, advertencias y errores.
-- `"warn"`: Registrar advertencias y errores.
-- `"error"`: Registrar solo errores.
-- `"silent"`: Sin registros.
-
-### `dev()`
-
-**Tipo:** `(inlineConfig: AstroInlineConfig) => AstroDevServer`
-
-Similar a [`astro dev`](#astro-dev), ejecuta el servidor de desarrollo de Astro.
-
-```js
-import { dev } from "astro";
-
-const devServer = await dev({
-  root: "./my-project",
-});
-
-// Detén el servidor si es necesario
-await devServer.stop();
-```
-
-### `build()`
-
-**Tipo:** `(inlineConfig: AstroInlineConfig) => void`
-
-Similar a [`astro build`](#astro-build), compila tu sitio para el despliegue.
-
-```js
-import { build } from "astro";
-
-await build({
-  root: "./my-project",
-});
-```
-
-### `preview()`
-
-**Tipo:** `(inlineConfig: AstroInlineConfig) => AstroPreviewServer`
-
-Similar a [`astro preview`](#astro-preview), inicia un servidor local para servir el directorio estático `dist/`.
-
-```js
-import { preview } from "astro";
-
-const previewServer = await preview({
-  root: "./my-project",
-});
-
-// Detén el servidor si es necesario
-await previewServer.stop();
-```
-
-### `sync()`
-
-**Tipo:** `(inlineConfig: AstroInlineConfig) => number`
-
-Similar a [`astro sync`](#astro-sync), genera tipos de TypeScript para todos los módulos de Astro.
-
-```js
-import { sync } from "astro";
-
-const exitCode = await sync({
-  root: "./my-project",
-});
-
-process.exit(exitCode)
-```
-
-## CLI de Astro Studio
-
-### `astro login`
-
-Autenticarse con Astro Studio. Esto es necesario para ejecutar todos los comandos de gestión de bases de datos, incluido [`astro link`](#astro-link).
-
-### `astro link`
-
-Enlaza tu base de datos alojada en Studio. Esto es necesario para ejecutar [comandos de Astro DB](/es/guides/integrations-guide/db/#referencia-de-la-cli-de-astro-db) para la gestión de bases de datos. Para enlazar una base de datos, se te pedirá que selecciones una base de datos existente o que crees una nueva.
-
-### `astro logout`
-
-Cierra la sesión de Astro Studio y elimina cualquier clave de autenticación almacenada localmente.
diff --git a/src/content/docs/es/reference/configuration-reference.mdx b/src/content/docs/es/reference/configuration-reference.mdx
deleted file mode 100644
index 813a99b970d5f..0000000000000
--- a/src/content/docs/es/reference/configuration-reference.mdx
+++ /dev/null
@@ -1,1576 +0,0 @@
----
-title: Referencia de configuración
-i18nReady: true
----
-import Since from '~/components/Since.astro';
-
-La siguiente referencia cubre todas las opciones de configuración compatibles en Astro.
-
-```js
-// astro.config.mjs
-import { defineConfig } from 'astro/config'
-
-export default defineConfig({
-  // tus opciones de configuración aquí...
-})
-```
-## Opciones de nivel superior
-
-
-### site
-
-<p>
-**Tipo:** `string`
-</p>
-
-La URL final donde se desplegará. Astro usa esta URL completa para generar el sitemap y las URL canónicas en la compilación final. Se recomienda establecer esta configuración para aprovechar al máximo Astro.
-
-```js
-{
-  site: 'https://www.my-site.dev',
-}
-```
-
-### base
-
-<p>
-**Tipo:** `string`
-</p>
-
-La ruta base en la que se desplegará. Astro usará esta ruta como la raíz para tus páginas y activos en desarrollo y producción.
-
-En el ejemplo de abajo, `astro dev` empezará tu servidor en `/docs`.
-
-```js
-{
-  base: '/docs',
-}
-```
-
-Cuando utilices esta opción, todas tus importaciones de activos estáticos y URL deben agregar la base como prefijo. Puedes acceder a este valor a través de `import.meta.env.BASE_URL`.
-
-El valor de `import.meta.env.BASE_URL` se determinará según la configuración de `trailingSlash`, sin importar el valor que hayas establecido para `base`.
-
-Se incluirá una barra diagonal al final siempre que se establezca `trailingSlash: "always"`. Si se establece `trailingSlash: "never"`, `BASE_URL` no incluirá una barra diagonal al final, incluso si `base` la incluye.
-
-Además, Astro manipulará internamente el valor configurado de `config.base` antes de ponerlo a disposición de las integraciones. El valor de `config.base` tal como lo leen las integraciones también se determinará según la configuración de `trailingSlash` de la misma manera.
-
-En el siguiente ejemplo, los valores de `import.meta.env.BASE_URL` y `config.base`, al ser procesados, serán ambos `/docs`:
-```js
-{
-	 base: '/docs/',
-	 trailingSlash: "never"
-}
-```
-
-En el siguiente ejemplo, los valores de `import.meta.env.BASE_URL` y `config.base`, al ser procesados, serán ambos `/docs/`:
-```js
-{
-	 base: '/docs',
-	 trailingSlash: "always"
-}
-```
-
-### trailingSlash
-
-<p>
-**Tipo:** `'always' | 'never' | 'ignore'`<br />
-**Por defecto:** `'ignore'`
-</p>
-
-Establece el comportamiento de coincidencia de rutas del servidor de desarrollo. Elige entre las siguientes opciones:
-   - `'always'`: solo coincide con las URL que incluyen una barra inclinada al final (por ejemplo: "/foo/")
-   - `'never'`: nunca haga coincidir las URL que incluyen una barra inclinada al final (por ejemplo: "/foo")
-   - `'ignore'`: coincide con las URL independientemente de si existe un "/" final
-
-Utiliza esta opción de configuración si tu host de producción tiene un manejo estricto de cómo funcionan o no las barras inclinadas finales.
-
-También puedes configurar esto si prefieres ser más estricto, de modo que las URL con o sin barras diagonales finales no funcionen durante el desarrollo.
-
-```js
-{
-  // Ejemplo: Requiera una barra inclinada final durante el desarrollo
-  trailingSlash: 'always',
-}
-```
-**Ver también:**
-- build.format
-
-### redirects
-
-<p>
-
-**Tipo:** `Record.<string, RedirectConfig>`<br />
-**Por defecto:** `{}`<br />
-<Since v="2.9.0" />
-</p>
-
-Especifica un mapeo de redirecciones donde la clave es la ruta a coincidir y el valor es la ruta a la que se redirige.
-
-Puedes redirigir tanto rutas estáticas como dinámicas, pero solo a un tipo de ruta similar.
-Por ejemplo, no puedes tener una redirección `'/article': '/blog/[...slug]'`.
-
-
-```js
-{
-  redirects: {
-    '/old': '/new',
-    '/blog/[...slug]': '/articles/[...slug]',
-  }
-}
-```
-
-Para sitios generados estáticamente sin un adaptador instalado, esto producirá una redirección del cliente utilizando una [etiqueta `<meta http-equiv="refresh">`](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/meta#http-equiv) y no admitirá códigos de estado.
-
-Cuando se utiliza SSR o un adaptador estático en el modo `output: static`, se admiten los códigos de estado.
-Astro servirá las solicitudes GET redirigidas con un estado `301` y utilizará un estado `308` para cualquier otro método de solicitud.
-
-Puedes personalizar el [código de estado de redirección](https://developer.mozilla.org/en-US/docs/Web/HTTP/Status#redirection_messages) utilizando un objeto en la configuración de redirección:
-
-```js
-{
-  redirects: {
-    '/other': {
-      status: 302,
-      destination: '/place',
-    },
-  }
-}
-```
-
-### output
-
-<p>
-**Tipo:** `'static' | 'server' | 'hybrid'`<br />
-**Por defecto:** `'static'`
-</p>
-
-Especifica el tipo de la compilación.
-
-- `'static'`: Construye un sitio estático para ser implementado en cualquier host estático.
-- `'server'`: Construye una aplicación que se implementará en un host compatible con SSR (renderizado en el servidor).
-- `'hybrid'` : Construye un sitio estático con algunas páginas renderizadas en el lado del servidor.
-
-```js
-import { defineConfig } from 'astro/config';
-
-export default defineConfig({
-  output: 'static',
-})
-```
-**Ver también:**
-- adapter
-
-### adapter
-
-<p>
-**Tipo:** `AstroIntegration`
-</p>
-
-Despliega a tu servidor favorito, serverless o edge host con adaptadores de compilación. Importa uno de nuestros adaptadores propios para [Netlify](/es/guides/deploy/netlify/#adaptador-para-ssr), [Vercel](/es/guides/deploy/vercel/#adaptador-para-ssr), y más para incluir a Astro SSR.
-
-[Consulta nuestra guía de renderizado en el servidor](/es/guides/on-demand-rendering/) para obtener más información sobre SSR, y [nuestras guías de despliegue](/es/guides/deploy/) para obtener una lista completa de hosts.
-
-```js
-import netlify from '@astrojs/netlify';
-{
- // Ejemplo: Compila para desplegar en Netlify serverless
- adapter: netlify(),
-}
-```
-
-**Ver también:**
-- output
-
-### integraciones
-
-<p>
-**Tipo:** `AstroIntegration[]`
-</p>
-
-Extiende Astro con integraciones personalizadas. Las integraciones sirven para agregar soporte a frameworks (como Solid.js), nuevas funcionalidades (sitemaps) y nuevas bibliotecas (como Partytown).
-
-Consulta nuestra [guía de integraciones](/es/guides/integrations-guide/) para obtener ayuda para comenzar con integraciones de Astro.
-
-```js
-import react from '@astrojs/react';
-import tailwind from '@astrojs/tailwind';
-{
-  // Ejemplo: Agrega compatibilidad con React + Tailwind a Astro
-  integrations: [react(), tailwind()],
-}
-```
-
-### root
-
-<p>
-**Tipo:** `string`<br />
-**CLI:** `--root`<br />
-**Por defecto:** `"."` (carpeta de trabajo actual)
-</p>
-
-Solo debes proporcionar esta opción si ejecutas los comandos CLI `astro` en una carpeta que no sea la carpeta raíz del proyecto. Por lo general, esta opción se proporciona a través de la CLI en lugar del [archivo de configuración de Astro](/es/guides/configuring-astro/#tipos-de-archivo-de-configuración-compatibles), ya que Astro necesita conocer la raíz de tu proyecto antes de que pueda localizar su archivo de configuración.
-
-Si proporcionas una ruta relativa (p. ej., `--root: './my-project'`), Astro la resolverá en tu directorio de trabajo actual.
-
-#### Ejemplos
-
-```js
-{
-  root: './my-project-directory',
-}
-```
-```bash
-$ astro build --root ./my-project-directory
-```
-
-### srcDir
-
-<p>
-**Tipo:** `string`<br />
-**Por defecto:** `"./src"`
-</p>
-
-Establece la carpeta desde el cual Astro leerá tu proyecto.
-
-El valor puede ser una ruta absoluta del sistema de archivos o una ruta relativa a la raíz del proyecto.
-
-```js
-{
-  srcDir: './www',
-}
-```
-
-### publicDir
-
-<p>
-**Tipo:** `string`<br />
-**Por defecto:** `"./public"`
-</p>
-
-Establece la carpeta para los activos estáticos. Los archivos en esta carpeta se sirven desde `/` durante el desarrollo y se copian en la carpeta de compilación durante la compilación. Estos archivos siempre se sirven o se copian tal cual, sin transformación ni empaquetamiento.
-
-El valor puede ser una ruta absoluta del sistema de archivos o una ruta relativa a la raíz del proyecto.
-
-```js
-{
-  publicDir: './my-custom-publicDir-directory',
-}
-```
-
-### outDir
-
-<p>
-**Tipo:** `string`<br />
-**Por defecto:** `"./dist"`
-</p>
-
-Establece la carpeta en la que `astro build` escribe la compilación final.
-
-El valor puede ser una ruta absoluta del sistema de archivos o una ruta relativa a la raíz del proyecto.
-
-```js
-{
-  outDir: './my-custom-build-directory',
-}
-```
-**Ver también:**
-- build.server
-
-### cacheDir
-
-<p>
-**Tipo:** `string`<br />
-**Por defecto:** `"./node_modules/.astro"`
-</p>
-
-Establece el directorio para almacenar en caché los artefactos de compilación. Los archivos de este directorio se utilizarán en compilaciones posteriores para acelerar el tiempo de compilación.
-
-El valor puede ser una ruta absoluta del sistema de archivos o una ruta relativa a la raíz del proyecto.
-
-```js
-{
-  cacheDir: './my-custom-cache-directory'
-}
-```
-
-### compressHTML
-
-<p>
-**Tipo:** `boolean`<br />
-**Por defecto:** `true`
-</p>
-
-Esta es una opción para minificar tu salida HTML y reducir el tamaño de tus archivos HTML. Por defecto, Astro elimina todos los espacios en blanco de tu HTML, incluyendo los saltos de línea, en los componentes `.astro`. Esto ocurre tanto en el modo de desarrollo como en la compilación final.
-Para desactivar la compresión del HTML, establece el parámetro `compressHTML` en `false`.
-
-```js
-{
-  compressHTML: false
-}
-```
-
-### scopedStyleStrategy
-
-<p>
-**Tipo:** `'where' | 'class' | 'attribute'`<br />
-**Por defecto:** `'attribute'`<br />
-<Since v="2.4.0" />
-</p>
-
-Especifica la estrategia utilizada para delimitar los estilos dentro de los componentes de Astro. Elige entre:
-  - `'where'` 		- Utilizar selectores `:where`, sin que aumente la especificidad.
-  - `'class'` 		- Utilizar selectores basados en clases, lo que provoca un aumento de la especificidad de +1.
-  - `'attribute'` - Utilizar atributos `data-`, sin aumentar la especificidad a +1.
-
-Utilizar `'class'` es útil cuando quieres asegurar que los selectores de elementos dentro de un componente de Astro anulan los valores predeterminados de estilo global (p. ej. de una hoja de estilos global).
-Utilizar `'where'` te brinda más control sobre la especificidad, pero requiere que utilices selectores de mayor especificidad, capas y otras herramientas para controlar qué selectores se aplican.
-Utilizar `'attribute'` es útil cuando estás manipulando el atributo `class` de elementos y necesitas evitar conflictos entre tu lógica de estilo y la aplicación de estilos de Astro.
-
-### security
-
-<p>
-**Tipo:** `boolean`<br />
-**Por defecto:** `{}`<br />
-<Since v="4.9.0" />
-</p>
-
-Activa medidas de seguridad para un sitio web Astro.
-
-Estas funciones solo existen para páginas renderizadas bajo demanda (SSR) usando el modo `server` o páginas que optan por no prerrenderizarse en modo `hybrid`.
-
-```js
-// astro.config.mjs
-export default defineConfig({
-  output: "server",
-  security: {
-    checkOrigin: true
-  }
-})
-```
-
-#### security.checkOrigin
-
-<p>
-**Tipo:** `boolean`<br />
-**Por defecto:** 'false'<br />
-<Since v="4.9.0" />
-</p>
-
-Cuando está habilitado, realiza una verificación para asegurar que el encabezado "origin", que es automáticamente proporcionado por todos los navegadores modernos, coincida con la URL enviada por cada `Request`. Esto se utiliza para proporcionar protección contra Cross-Site Request Forgery (CSRF).
-La verificación del encabezado "origin" se ejecuta únicamente para páginas renderizadas bajo demanda, y solo para las solicitudes `POST`, `PATCH`, `DELETE` y `PUT` que 
-utilicen uno de los siguientes encabezados `content-type`: `'application/x-www-form-urlencoded'`, `'multipart/form-data'`, `'text/plain'`.
-
-Si el encabezado "origin" no coincide con el `pathname` de la solicitud, Astro devolverá un código de estado 403 y no renderizará la página.
-
-### vite
-
-<p>
-**Tipo:** `ViteUserConfig`
-</p>
-
-Pasa opciones de configuración adicionales a Vite. Útil cuando Astro no admite alguna configuración avanzada que pueda necesitar.
-
-Consulta la documentación completa del objeto de configuración `vite` en [vite.dev](https://vite.dev/config/).
-
-#### Ejemplos
-
-```js
-{
-  vite: {
-    ssr: {
-      // Ejemplo: Obliga a un paquete roto a omitir el procesamiento de SSR, si es necesario
-      external: ['broken-npm-package'],
-    }
-  }
-}
-```
-
-```js
-{
-  vite: {
-    // Ejemplo: Agrega plugins de vite personalizados directamente a tu proyecto de Astro
-    plugins: [myPlugin()],
-  }
-}
-```
-
-## Opciones de Build
-
-
-### build.format
-
-<p>
-**Tipo:** `('file' | 'directory' | 'preserve')`<br />
-**Por defecto:** `'directory'`
-</p>
-
-Controla el formato del archivo compilado de cada página. Este valor puede ser establecido por un adaptador para ti.
-  - `'file'`: Astro generará un archivo HTML con el nombre de cada ruta de página. (p. ej. `src/pages/about.astro` y `src/pages/about/index.astro` generan el archivo `/about.html`)
-  - `'directory'`: Astro generará un directorio con un archivo `index.html` anidado para cada página. (p. ej. `src/pages/about.astro` y `src/pages/about/index.astro` generan el archivo `/about/index.html`)
-  - `'preserve'`: Astro generará archivos HTML exactamente como aparecen en tu carpeta de origen. (p. ej. `src/pages/about.astro` genera `/about.html` y `src/pages/about/index.astro` genera el archivo `/about/index.html`)
-
-```js
-{
-  build: {
-    // Ejemplo: Genera `page.html` en lugar de `page/index.html` durante la compilación.
-    format: 'file',
-  }
-}
-```
-
-
-### Efecto en Astro.url
-La opción `build.format` indica el valor que `Astro.url` obtendrá durante la compilación. Si es:
-- `directory` - `Astro.url.pathname` incluirá una barra final para imitar el comportamiento de carpetas. Ej.: `/foo/`.
-- `file` - `Astro.url.pathname` incluirá `.hmtl`. Ej.: `/foo.html`.
-
-Esto significa que cuando crees URLs relativas usando `new URL('./relativa', Astro.url)`, tendrás un comportamiento consistente entre desarrollo y compilación.
-
-Para evitar inconsistencias con el comportamiento de la barra diagonal final en desarrollo, puedes restringir la opción [`trailingSlash`](#trailingslash) a `'always'` o `'never'` dependiendo del formato de compilación:
-- `directory` - Establece `trailingSlash: 'always'`
-- `file` - Establece `trailingSlash: 'never'`
-
-### build.client
-
-<p>
-**Tipo:** `string`<br />
-**Por defecto:** `'./dist/client'`
-</p>
-
-Controla el directorio de salida del CSS y JavaScript del lado del cliente solamente cuando esté configurado `output: 'server'` o `output: 'hybrid'`.
-`outDir` controla dónde se compila el código.
-
-Este valor es relativo al `outDir`.
-
-```js
-{
-  output: 'server', // o 'hybrid'
-  build: {
-    client: './client'
-  }
-}
-```
-
-### build.server
-
-<p>
-**Tipo:** `string`<br />
-**Por defecto:** `'./dist/server'`
-</p>
-
-Controla el directorio de salida del JavaScript del servidor cuando compila a SSR.
-
-Este valor es relativo al `outDir`.
-
-```js
-{
-  build: {
-    server: './server'
-  }
-}
-```
-
-### build.assets
-
-<p>
-**Tipo:** `string`<br />
-**Por defecto:** `'_astro'`<br />
-<Since v="2.0.0" />
-</p>
-
-Especifica el directorio en la salida de compilación donde los activos generados por Astro (por ejemplo, JS y CSS empaquetados) deben ir.
-
-```js
-{
-  build: {
-    assets: '_custom'
-  }
-}
-```
-**Ver también:**
-- outDir
-
-### build.assetsPrefix
-
-<p>
-**Tipo:** `string | Record.<string, string>`<br />
-**Por defecto:** `undefined`<br />
-<Since v="2.2.0" />
-</p>
-
-Especifica el prefijo para los enlaces de activos generados por Astro. Esto se puede usar si los activos se sirven desde un dominio diferente al del sitio actual.
-
-Para ello, es necesario cargar los activos de la carpeta local `./dist/_astro` en la carpeta correspondiente `/_astro/` del dominio remoto.
-
-Para cambiar el nombre de la ruta `_astro`, especifique un nuevo directorio en `build.assets`.
-
-Para recuperar todos los assets cargados en el mismo dominio (por ejemplo, `https://cdn.example.com/_astro/...`), establece `assetsPrefix` en el dominio raíz como un string (independientemente de tu configuración `base`):
-
-```js
-{
-  build: {
-    assetsPrefix: 'https://cdn.example.com'
-  }
-}
-```
-
-**Añadido en:** `astro@4.5.0`
-
-También puedes pasar un objeto a `assetsPrefix` para especificar un dominio diferente para cada tipo de fichero.
-En este caso, se requiere una propiedad `fallback` que se utilizará por defecto para cualquier otro archivo.
-
-```js
-{
-  build: {
-    assetsPrefix: {
-      'js': 'https://js.cdn.example.com',
-      'mjs': 'https://js.cdn.example.com',
-      'css': 'https://css.cdn.example.com',
-      'fallback': 'https://cdn.example.com'
-    }
-  }
-}
-```
-
-### build.serverEntry
-
-<p>
-**Tipo:** `string`<br />
-**Por defecto:** `'entry.mjs'`
-</p>
-
-Especifica el nombre de archivo del punto de entrada al servidor cuando compila a SSR.
-Este punto de entrada suele depender del host al que estés desplegando y
-será configurado por el adaptador que estés utilizando.
-
-Ten en cuenta que se recomienda que este archivo tenga la extensión `.mjs` así el runtime
-detecta que el archivo es un módulo de JavaScript.
-
-```js
-{
-  build: {
-    serverEntry: 'main.mjs'
-  }
-}
-```
-
-### build.redirects
-
-<p>
-
-**Tipo:** `boolean`<br />
-**Por defecto:** `true`<br />
-<Since v="2.6.0" />
-</p>
-
-Especifica si las redirecciones se generarán en HTML durante la compilación. Esta opción solo se aplica al modo `output: 'static'`; en SSR, las redirecciones se tratan de la misma manera que todas las respuestas.
-
-Esta opción está destinada principalmente a ser utilizada por adaptadores que tienen archivos de configuración especiales para redirecciones y no necesitan/desean redirecciones basadas en HTML.
-
-```js
-{
-  build: {
-    redirects: false
-  }
-}
-```
-
-### build.inlineStylesheets
-
-<p>
-
-**Tipo:** `'always' | 'auto' | 'never'`<br />
-**Por defecto:** `auto`<br />
-<Since v="2.6.0" />
-</p>
-
-Controla si los estilos del proyecto se envían al navegador en un archivo CSS separado o se incrustan en etiquetas `<style>`. Elige entre las siguientes opciones:
- - `'always'` - los estilos del proyecto se incrustan en etiquetas `<style>`.
- - `'auto'` - solo las hojas de estilo más pequeñas que ViteConfig.build.assetsInlineLimit (por defecto: 4 kB) se incrustan. De lo contrario, los estilos se envían en hojas de estilo externas.
- - `'never'` - los estilos del proyecto se envían en hojas de estilo externas.
-
-```js
-{
-	build: {
-		inlineStylesheets: `never`,
-	},
-}
-```
-
-## Opciones del Servidor
-
-Personaliza el entorno de desarrollo de Astro, utilizado por `astro dev` y `astro preview`.
-
-```js
-{
-  server: { port: 1234, host: true},
-}
-```
-
-Para establecer una configuración diferente basada en el comando ejecutar ("dev", "preview"), también puedes pasar una función a esta opción de configuración.
-
-```js
-{
-  // Ejemplo: Usa una función para personalizar según el comando
-  server: ({ command }) => ({ port: command === 'dev' ? 4321 : 4000 }),
-}
-```
-
-### server.host
-
-<p>
-**Tipo:** `string | boolean`<br />
-**Por defecto:** `false`<br />
-<Since v="0.24.0" />
-</p>
-
-Establece en qué direcciones de IP el servidor debe escuchar (es decir, direcciones IP no locales).
-- `false` - no exponer una dirección IP
-- `true` - escuchar todas las direcciones, incluidas LAN y direcciones públicas
-- `[dirección personalizada]` - exponer una dirección IP en `[dirección personalizada]` (por ejemplo, `192.168.0.1`)
-
-### server.port
-
-<p>
-**Tipo:** `number`<br />
-**Por defecto:** `4321`
-</p>
-
-Establece en qué puerto debe escuchar el servidor.
-
-Si el puerto dado ya está en uso, Astro probará automáticamente el siguiente puerto disponible.
-
-```js
-{
-  server: { port: 8080 },
-}
-```
-
-### server.open
-
-<p>
-
-**Tipo:** `string | boolean`<br />
-**Por defecto:** `false`<br />
-<Since v="4.1.0" />
-</p>
-
-Controla si el servidor de desarrollo debe abrirse en la ventana de tu navegador al iniciar.
-
-Pasa un string de URL completo (p. ej. "http://example.com") o una ruta (p. ej. "/about") para especificar el URL a abrir.
-
-```js
-{
-  server: { open: "/about" }
-}
-```
-
-### server.headers
-
-<p>
-**Tipo:** `OutgoingHttpHeaders`<br />
-**Por defecto:** `{}`<br />
-<Since v="1.7.0" />
-</p>
-
-Establece encabezados de respuesta HTTP personalizados para enviar en `astro dev` y `astro preview`.
-
-## Opciones de la barra de herramientas de desarrollo
-
-### devToolbar.enabled
-
-<p>
-**Tipo:** `boolean`<br />
-**Por defecto:** `true`
-</p>
-
-Si deseas activar la barra de herramientas de Astro Dev. Esta barra de herramientas te permite inspeccionar las islas de tu página, ver auditorías útiles sobre rendimiento y accesibilidad, y mucho más.
-
-Esta opción se aplica a todo el proyecto, para desactivar la barra de herramientas sólo para ti, ejecuta `npm run astro preferences disable devToolbar`. Para desactivar la barra de herramientas para todos tus proyectos de Astro, ejecuta `npm run astro preferences disable devToolbar --global`.
-
-### Opciones de Precarga
-
-<p>
-
-**Tipo:** `boolean | object`
-</p>
-
-Habilita la precarga de enlaces en tu sitio para proporcionar transiciones de página más rápidas.
-(Activado de forma predeterminada en las páginas que utilizan el router `<ViewTransitions />`. Establece `prefetch: false` para optar por no utilizar este comportamiento.)
-
-Esta configuración agrega automáticamente un script de precarga a cada página del proyecto
-dandote acceso al atributo `data-astro-prefetch`.
-Agrega este atributo a cualquier enlace `<a />` en tu página para habilitar el prefetching para esa página.
-
-```html
-<a href="/about" data-astro-prefetch>Acerca</a>
-```
-Para personalizar aún más el comportamiento predeterminado de precarga puedes usar las opciones [`prefetch.defaultStrategy`](#prefetchdefaultstrategy) y [`prefetch.prefetchAll`](#prefetchprefetchall).
-
-Consulta la [guía de Prefetch](/es/guides/prefetch/) para obtener más información.
-
-
-### prefetch.prefetchAll
-
-<p>
-
-**Tipo:** `boolean`
-</p>
-
-Habilita la precarga para todos los enlaces, incluidos aquellos sin el atributo `data-astro-prefetch`.
-El valor predeterminado es `true` cuando se utiliza el router `<ViewTransitions />`. De lo contrario, el valor predeterminado es `false`.
-
-```js
-prefetch: {
-	prefetchAll: true
-}
-```
-
-Cuando se establece en `true`, puedes deshabilitar el prefetching individualmente estableciendo `data-astro-prefetch="false"` en cualquier enlace individual.
-
-```html
-<a href="/about" data-astro-prefetch="false">About</a>
-```
-
-
-### prefetch.defaultStrategy
-
-<p>
-
-**Tipo:** `'tap' | 'hover' | 'viewport' | 'load'`<br />
-**Por defecto:** `'hover'`
-</p>
-
-La estrategia de precarga predeterminada para utilizar cuando el atributo `data-astro-prefetch` está establecido en un enlace sin valor.
-
-- `'tap'`: Precarga justo antes de hacer clic en el enlace.
-- `'hover'`: Precarga cuando pasas el cursor o te enfocas en el enlace. (predeterminada)
-- `'viewport'`: Precarga cuando los enlaces entran en el viewport.
-- `'load'`: Precarga todos los enlaces en la página después de que la página se ha cargado.
-
-Puedes reemplazar este valor predeterminado y seleccionar una estrategia diferente para cualquier enlace individual estableciendo un valor en el atributo.
-
-```html
-<a href="/about" data-astro-prefetch="viewport">Acerca de</a>
-```
-
-## Opciones de Imagen
-
-
-### image.endpoint
-
-<p>
-
-**Tipo:** `string`<br />
-**Por defecto:** `undefined`<br />
-<Since v="3.1.0" />
-</p>
-
-Configura el endpoint a utilizar para la optimización de imágenes en desarrollo y SSR. Establece `undefined` para utilizar el endpoint por defecto.
-
-El endpoint siempre se inyectará en `/_image`.
-
-```js
-{
-  image: {
-    // Ejemplo: Usa un endpoint de imagen personalizado
-    endpoint: './src/image-endpoint.ts',
-  },
-}
-```
-
-### image.service 
-
-<p>
-**Tipo:** `Object`<br />
-**Por defecto:** `{entrypoint: 'astro/assets/services/sharp', config?: {}}`<br />
-<Since v="2.1.0" />
-</p>
-
-Establece qué servicio de imágenes se utiliza para el soporte de assets de Astro.
-
-El valor debe ser un objeto con un punto de entrada para el servicio de imagen a utilizar y, opcionalmente, un objeto configuración para pasar al servicio.
-
-El punto de entrada del servicio puede ser uno de los servicios incluidos o un paquete de terceros.
-
-```js
-{
-  image: {
-    // Example: Habilita el servicio de imágenes basado en Sharp con una configuración personalizada
-    service: {
-			 entrypoint: 'astro/assets/services/sharp',
-			 config: {
-				 limitInputPixels: false,
-      },
-		 },
-  },
-}
-```
-
-#### image.service.config.limitInputPixels
-
-<p>
-
-**Tipo:** `number | boolean`<br />
-**Por defecto:** `true`<br />
-<Since v="4.1.0" />
-</p>
-
-Limitar o no el tamaño de las imágenes que procesará el servicio de imágenes Sharp.
-
-Establece `false` para omitir el límite de tamaño de imagen por defecto para el servicio de imágenes Sharp y procesar imágenes grandes.
-
-### image.domains
-
-<p>
-
-**Tipo:** `Array.<string>`<br />
-**Por defecto:** `{domains: []}`<br />
-<Since v="2.10.10" />
-</p>
-
-Define una lista de dominios de origen de imágenes permitidos para la optimización de imágenes remotas. No se optimizarán otras imágenes remotas por Astro.
-
-Esta opción require un arreglo de nombres de dominio individuales como strings. Los comodines no están permitidos. En su lugar, usa [`image.remotePatterns`](#imageremotepatterns) para definir una lista de patrones de URL de origen permitidos.
-
-```js
-// astro.config.mjs
-{
-  image: {
-    // Ejemplo: Permite la optimización de imágenes remotas desde un solo dominio
-    domains: ['astro.build'],
-  },
-}
-```
-
-### image.remotePatterns
-
-<p>
-
-**Tipo:** `Array.<RemotePattern>`<br />
-**Por defecto:** `{remotePatterns: []}`<br />
-<Since v="2.10.10" />
-</p>
-
-Define una lista de patrones de URL de origen permitidos para la optimización de imágenes remotas.
-
-`remotePatterns` pueden ser configurados con cuatro propiedades:
-1. protocol
-2. hostname
-3. port
-4. pathname
-
-```js
-{
-  image: {
-    // Ejemplo: permite el procesamiento de todas las imágenes de tu bucket de aws s3
-    remotePatterns: [{
-      protocol: 'https',
-      hostname: '**.amazonaws.com',
-    }],
-  },
-}
-```
-
-Puedes usar comodines para definir los valores `hostname` y `pathname` permitidos como se describe a continuación. De lo contrario, solo se configurarán los valores exactos proporcionados:
-`hostname`:
-  - Empiezar con '**.' para permitir todos los subdominios ('endsWith').
-  - Empiezar con '*.' para permitir solo un nivel de subdominio.
-
-`pathname`:
-  - Terminar con '/**' para permitir todas las sub-rutas ('startsWith').
-  - Terminar con '/*' para permitir solo un nivel de sub-ruta.
-
-## Opciones de Markdown
-
-### markdown.shikiConfig
-
-<p>
-**Tipo:** `Partial<ShikiConfig>`
-</p>
-
-Opciones de configuración de Shiki. Consulta [la documentación de configuración de Markdown](/es/guides/markdown-content/#configuración-de-shiki) para conocer su uso.
-
-### markdown.syntaxHighlight
-
-<p>
-**Tipo:** `'shiki' | 'prism' | false`<br />
-**Por defecto:** `shiki`
-</p>
-
-Qué resaltador de sintaxis usar, si lo hay.
-- `shiki` - usa el resaltador [Shiki](https://shiki.style)
-- `prism` - usa el resaltador [Prism](https://prismjs.com/)
-- `false` - no aplicar resaltado de sintaxis.
-
-```js
-{
-  markdown: {
-    // Ejemplo: Cambia el resaltado de sintaxis a prism en Markdown
-    syntaxHighlight: 'prism',
-  }
-}
-```
-
-### markdown.remarkPlugins
-
-<p>
-**Tipo:** `RemarkPlugins`
-</p>
-
-Pasa [plugins de remark](https://github.com/remarkjs/remark) para personalizar la construcción del Markdown. Puedes importar y aplicar la función del plugin (recomendado), o pasar el nombre del plugin como string.
-
-```js
-import remarkToc from 'remark-toc';
-{
-  markdown: {
-    remarkPlugins: [remarkToc],
-  }
-}
-```
-
-### markdown.rehypePlugins
-
-<p>
-**Tipo:** `RehypePlugins`
-</p>
-
-Pasa [plugins de rehype](https://github.com/remarkjs/remark-rehype) para personalizar cómo el HTML generado en compilación es procesado. Puedes importar y aplicar la función del plugin (recomendado), o pasar el nombre del plugin como string.
-
-```js
-import { rehypeAccessibleEmojis } from 'rehype-accessible-emojis';
-{
-  markdown: {
-    rehypePlugins: [rehypeAccessibleEmojis]
-  }
-}
-```
-
-### markdown.gfm
-
-<p>
-**Tipo:** `boolean`<br />
-**Por defecto:** `true`<br />
-<Since v="2.0.0" />
-</p>
-
-Astro usa [GitHub-flavored Markdown](https://github.com/remarkjs/remark-gfm) por defecto. Para deshabilitarlo, establece la flag `gfm` a `false`:
-
-```js
-{
-  markdown: {
-    gfm: false,
-  }
-}
-```
-
-### markdown.smartypants
-
-<p>
-**Tipo:** `boolean`<br />
-**Por defecto:** `true`<br />
-<Since v="2.0.0" />
-</p>
-
-Astro usa el formateador [SmartyPants](https://daringfireball.net/projects/smartypants/) por defecto. Para deshabilitarlo, establezca la propiedad `smartypants` a `false`:
-
-```js
-{
-  markdown: {
-    smartypants: false,
-  }
-}
-```
-
-### markdown.remarkRehype
-
-<p>
-**Tipo:** `RemarkRehype`
-</p>
-
-Puedes pasar opciones a [remark-rehype](https://github.com/remarkjs/remark-rehype#api).
-
-```js
-{
-  markdown: {
-    // Ejemplo: Traduce el texto de las notas de pie a otro idioma, por ejemplo, aquí están en español
-    remarkRehype: { footnoteLabel: "Notas de pie", footnoteBackLabel: "Volver a la referencia 1"},
-  }
-}
-```
-
-## i18n
-
-<p>
-
-**Tipo:** `object`<br />
-<Since v="3.5.0" />
-</p>
-
-Configura el enrutamiento i18n y te permite especificar algunas opciones de personalización.
-
-Consulta nuestra guía para obtener más información sobre [la internacionalización en Astro](/es/guides/internationalization/)
-
-### i18n.defaultLocale
-
-<p>
-
-**Tipo:** `string`<br />
-<Since v="3.5.0" />
-</p>
-
-El idioma predeterminado de tu sitio/aplicación. Este es un campo obligatorio.
-
-Ningún formato o sintaxis de idioma en particular está obligado, pero sugerimos usar minúsculas y guiones según sea necesario (por ejemplo, "es", "pt-br") para una mayor compatibilidad.
-
-### i18n.locales
-
-<p>
-
-**Tipo:** `Locales`<br />
-<Since v="3.5.0" />
-</p>
-
-Una lista de todos los idiomas admitidos por el sitio web, incluyendo el `defaultLocale`. Este es un campo obligatorio.
-
-Los idiomas pueden enumerarse como códigos individuales (por ejemplo, `['en', 'es', 'pt-br']`) o asignarse a una `ruta` compartida de códigos (por ejemplo, `{ path: "english", code: ["en", "en-US"]}`). Estos códigos se utilizarán para determinar la estructura de URL de tu sitio desplegado.
-
-
-No se impone ningún formato o sintaxis de código de idioma en particular, pero las carpetas de tu proyecto que contengan tus archivos de contenido deben coincidir exactamente con los elementos `locales` de la lista. En caso de que varios `códigos` apunten a un prefijo de ruta URL personalizado, almacena los archivos de contenido en una carpeta con el mismo nombre que la `ruta` configurada.
-
-### i18n.fallback
-
-<p>
-
-**Tipo:** `Record.<string, string>`<br />
-<Since v="3.5.0" />
-</p>
-
-La estrategia de reserva cuando se navega a páginas que no existen (por ejemplo, no se ha creado una página traducida).
-
-Usa este objeto para declarar una ruta de `locale` de reserva para cada idioma que admitas. Si no se especifica una reserva, las páginas no disponibles devolverán un 404.
-
-##### Ejemplo
-
-El siguiente ejemplo configura tu estrategia de reserva de contenido para redirigir las páginas no disponibles en `/pt-br/` a su versión `es`, y las páginas no disponibles en `/fr/` a su versión `en`. Las páginas no disponibles en `/es/` devolverán un 404.
-
-```js
-export default defineConfig({
-	experimental: {
-    i18n: {
-      defaultLocale: "en",
-      locales: ["en", "fr", "pt-br", "es"],
-      fallback: {
-        pt: "es",
-        fr: "en"
-      }
-	  }
-  }
-})
-```
-
-### i18n.routing
-
-<p>
-
-**Tipo:** `Routing`<br />
-<Since v="3.7.0" />
-</p>
-
-Controla la estrategia de enrutamiento para determinar las URLs de tu sitio. Establécelo en función de la configuración de la ruta de la carpeta/URL para tu idioma predeterminado.
-
-#### i18n.routing.prefixDefaultLocale
-
-<p>
-
-**Tipo:** `boolean`<br />
-**Por defecto:** `false`<br />
-<Since v="3.7.0" />
-</p>
-
-Cuando es `false`, sólo los idiomas no predeterminados mostrarán un prefijo de idioma.
-El `defaultLocale` no mostrará un prefijo de idioma y los archivos de contenido no existen en una carpeta localizada.
- Las URLs tendrán la forma `example.com/[lang]/content/` para todos los idiomas no predeterminados, pero `example.com/content/` para la configuración regional predeterminada.
-
-Cuando es `true`, todas las URLs mostrarán un prefijo de idioma.
-Las URLs serán de la forma `example.com/[lang]/content/` para cada ruta, incluyendo el idioma por defecto.
-Se utilizan carpetas localizadas para cada idioma, incluido el predeterminado.
-
-#### i18n.routing.redirectToDefaultLocale
-
-<p>
-
-**Tipo:** `boolean`<br />
-**Por defecto:** `true`<br />
-<Since v="4.2.0" />
-</p>
-
-Configura si la URL de inicio (`/`) generada por `src/pages/index.astro`
-se redireccionará a `/[defaultLocale]` cuando `prefixDefaultLocale: true` está configurado.
-
-Establece `redirectToDefaultLocale: false` para desactivar esta redirección automática en la raíz de tu sitio:
-```js
-// astro.config.mjs
-export default defineConfig({
-  i18n:{
-    defaultLocale: "en",
-		locales: ["en", "fr"],
-    routing: {
-      prefixDefaultLocale: true,
-      redirectToDefaultLocale: false
-    }
-  }
-})
-```
-
-#### i18n.routing.manual
-
-<p>
-
-**Tipo:** `string`<br />
-<Since v="4.6.0" />
-</p>
-
-Cuando esta opción está habilitada, Astro **desactivará** su  middleware de internacionalización (i18n) para que puedas implementar tu propia lógica. No se pueden configurar otras opciones de `routing` (Ejemplo: `prefixDefaultLocale`) cuando se utiliza `routing: "manual"`.
-
-Serás responsable de escribir tu propia lógica de enrutamiento o ejecutar manualmente el middleware de internacionalización (i18n) de Astro junto con tu propia implementación.
-
-```js
-export default defineConfig({
-	i18n: {
-		defaultLocale: "en",
-		locales: ["en", "fr", "pt-br", "es"],
-		routing: {
-			prefixDefaultLocale: true,
-		}
-	}
-})
-```
-
-## Banderas legacy
-
-Para ayudar a algunos usuarios a migrar entre versiones de Astro, ocasionalmente introducimos banderas `legacy`.
-Estas banderas te permiten optar por algunos comportamientos desactualizados u obsoletos de Astro
-en la última versión, para que puedas continuar actualizando y aprovechar los nuevos lanzamientos de Astro.
-
-## Banderas Experimentales
-
-Astro ofrece banderas experimentales para dar a los usuarios acceso temprano a nuevas características.
-No se garantiza que estas banderas sean estables.
-
-### experimental.directRenderScript
-
-<p>
-
-**Tipo:** `boolean`<br />
-**Por defecto:** `false`<br />
-<Since v="4.5.0" />
-</p>
-
-Permite una estrategia más fiable para evitar que los scripts se ejecuten en páginas en las que no se utilizan.
-
-Los scripts se renderizarán directamente como se declaren en los archivos Astro (incluyendo características existentes como TypeScript, importación de `node_modules`,
-y la deduplicación de scripts). Ahora también puedes renderizar scripts condicionalmente en tu archivo Astro.
-Sin embargo, esto significa que los scripts ya no se colocan en el `<head>` y que varios scripts de una página ya no se empaquetan juntos.
-Si activas esta opción, comprueba que todas las etiquetas `<script>` se comportan como es debido.
-
-Esta opción se activará por defecto en Astro 5.0.
-
-```js
-{
-  experimental: {
-    directRenderScript: true,
-  },
-}
-```
-
-### experimental.actions
-
-<p>
-
-**Tipo:** `boolean`<br />
-**Por defecto:** `false`<br />
-<Since v="4.8.0" />
-</p>
-
-Las Acciones te ayudan a escribir funciones de backend seguras que puedes llamar desde cualquier lugar. Habilita el renderizado en servidor [usando la propiedad `output`](/es/guides/on-demand-rendering/) y añade la bandera `actions` al objeto `experimental`:
-
-```js
-{
-  output: 'hybrid', // or 'server'
-  experimental: {
-    actions: true,
-  },
-}
-```
-
-Declara todas tus acciones en `src/actions/index.ts`. Este archivo es el manejador global de acciones.
-
-Declara una acción utilizando `defineAction()` del módulo `astro:actions`. Una acción acepta la propiedad `handler` para definir tu manejador en el lado del servidor. Si tu acción acepta argumentos, aplica la propiedad `input` para validar los parámetros con Zod.
-
-Este ejemplo define dos acciones: `like` y `comment`. La acción `like` acepta un objeto JSON con una cadena `postId`, mientras que la acción `comment` acepta un objeto [FormData](https://developer.mozilla.org/en-US/docs/Web/API/XMLHttpRequest_API/Using_FormData_Objects) con las cadenas `postId`, `author`, y `body`. Cada `handler` actualiza tu base de datos y devuelve una respuesta de tipo segura.
-
-```ts
-// src/actions/index.ts
-import { defineAction, z } from "astro:actions";
-
-export const server = {
-  like: defineAction({
-    input: z.object({ postId: z.string() }),
-    handler: async ({ postId }) => {
-      // actualiza likes en la base de datos
-
-      return likes;
-    },
-  }),
-  comment: defineAction({
-    accept: 'form',
-    input: z.object({
-      postId: z.string(),
-      author: z.string(),
-      body: z.string(),
-    }),
-    handler: async ({ postId }) => {
-      // añade comentarios en la base de datos
-
-      return comment;
-    },
-  }),
-};
-```
-
-Luego, llama a una acción desde los componentes cliente usando el objeto `actions` del módulo `astro:actions`. Puedes pasar un objeto de tipo seguro cuando uses JSON,o un objeto [FormData](https://developer.mozilla.org/en-US/docs/Web/API/XMLHttpRequest_API/Using_FormData_Objects) cuando uses `accept: 'form'` en la definición de tu acción.
-
-Este ejemplo llama a las acciones `like` y `comment`desde un componente de React:
-
-```tsx "actions"
-// src/components/blog.tsx
-import { actions } from "astro:actions";
-import { useState } from "react";
-
-export function Like({ postId }: { postId: string }) {
-  const [likes, setLikes] = useState(0);
-  return (
-    <button
-      onClick={async () => {
-        const newLikes = await actions.like({ postId });
-        setLikes(newLikes);
-      }}
-    >
-      {likes} likes
-    </button>
-  );
-}
-
-export function Comment({ postId }: { postId: string }) {
-  return (
-    <form
-      onSubmit={async (e) => {
-        e.preventDefault();
-        const formData = new FormData(e.target as HTMLFormElement);
-        const result = await actions.blog.comment(formData);
-        // manejar el resultado
-      }}
-    >
-      <input type="hidden" name="postId" value={postId} />
-      <label htmlFor="author">Author</label>
-      <input id="author" type="text" name="author" />
-      <textarea rows={10} name="body"></textarea>
-      <button type="submit">Post</button>
-    </form>
-  );
-}
-```
-
-Para obtener una visión completa, y proporcionar comentarios sobre esta API experimental, consulta [Actions RFC](https://github.com/withastro/roadmap/blob/actions/proposals/0046-actions.md).
-
-### experimental.contentCollectionCache
-
-<p>
-
-**Tipo:** `boolean`<br />
-**Default:** `false`<br />
-<Since v="3.5.0" />
-</p>
-
-Habilita un caché persistente para las colecciones de contenido cuando se compila en modo estático.
-
-```js
-{
-	experimental: {
-		contentCollectionCache: true,
-	},
-}
-```
-
-### experimental.contentCollectionJsonSchema
-
-<p>
-
-**Tipo:** `boolean`<br />
-**Por defecto:** `false`<br />
-<Since v="4.5.0" />
-</p>
-
-Esta característica auto-generará un esquema JSON para colecciones de contenido de `type: 'data'` que puede ser usado como el valor `$schema` para autocompletar/consejos al estilo TypeScript en herramientas como VSCode.
-
-Para activar esta función, añada el indicador experimental:
-
-```diff
-import { defineConfig } from 'astro/config';
-export default defineConfig({
-	experimental: {
-+		contentCollectionJsonSchema: true
-	}
-});
-```
-
-Esta implementación experimental requiere referenciar manualmente el esquema en cada fichero de entrada de datos de la colección:
-
-```diff
-// src/content/test/entry.json
-{
-+  "$schema": "../../../.astro/collections/test.schema.json",
-	"test": "test"
-}
-```
-
-Alternativamente, puedes establecer esto en tu [configuración de VSCode `json.schemas`](https://code.visualstudio.com/docs/languages/json#_json-schemas-and-settings):
-
-```diff
-"json.schemas": [
-	{
-		"fileMatch": [
-			"/src/content/test/**"
-		],
-		"url": "./.astro/collections/test.schema.json"
-	}
-]
-```
-
-Ten en cuenta que esta implementación inicial utiliza una biblioteca con [problemas conocidos para esquemas Zod avanzados](https://github.com/StefanTerdell/zod-to-json-schema#known-issues), por lo que puede que desees consultar estas limitaciones antes de activar la bandera experimental.
-
-### experimental.clientPrerender
-
-<p>
-
-**Tipo:** `boolean`<br />
-**Por defecto:** `false`<br />
-<Since v="4.2.0" />
-</p>
-
-Permite la pre-renderización de tus páginas precargadas en el cliente en navegadores compatibles.
-
-Esta característica utiliza la [API experimental de Reglas de Especulación Web](https://developer.mozilla.org/en-US/docs/Web/API/Speculation_Rules_API) y mejora el comportamiento predeterminado de `prefetch` a nivel global para pre-renderizar enlaces en el cliente.
-Puede que desees revisar los [posibles riesgos al pre-renderizar en el cliente](https://developer.mozilla.org/en-US/docs/Web/API/Speculation_Rules_API#unsafe_prefetching) antes de habilitar esta característica.
-
-Habilita la pre-renderización en el lado del cliente en tu archivo `astro.config.mjs`, junto con cualquier opción de configuración de `prefetch` deseada:
-
-```js
-// astro.config.mjs
-{
-  prefetch: {
-    prefetchAll: true,
-    defaultStrategy: 'viewport',
-  },
-	experimental: {
-		clientPrerender: true,
-	},
-}
-```
-
-Continua utilizando el atributo `data-astro-prefetch` en cualquier enlace `<a />` en tu sitio para optar por la precarga.
-En lugar de añadir una etiqueta `<link>` a la cabecera del documento o recuperar la página con JavaScript, se agregará una etiqueta `<script>` con las reglas de especulación correspondientes.
-
-La pre-renderización en el lado del cliente requiere el soporte del navegador. Si la API de Reglas de Especulación no es compatible, `prefetch` volverá a la estrategia compatible.
-
-Consulta la [Guía de Precargar] para más opciones y uso de `prefetch`.
-
-### experimental.globalRoutePriority
-
-<p>
-
-**Tipo:** `boolean`<br />
-**Por defecto:** `false`<br />
-<Since v="4.2.0" />
-</p>
-
-Da la misma prioridad a las redirecciones y las rutas inyectadas junto con las rutas del proyecto basadas en archivos, siguiendo las mismas [reglas de orden de prioridad de rutas](/es/guides/routing/#orden-de-prioridad-de-rutas) para todas las rutas.
-
-Esto permite más control sobre el enrutamiento en tu proyecto al no priorizar automáticamente ciertos tipos de rutas, y estandariza el orden de prioridad para todas las rutas.
-
-El siguiente ejemplo muestra que ruta construirá ciertas URLs de páginas cuando se combinan rutas basadas en archivos, rutas inyectadas y redirecciones como se muestra a continuación:
-- Ruta basada en archivos: `/blog/post/[pid]`
-- Ruta basada en archivos: `/[page]`
-- Ruta inyectada: `/blog/[...slug]`
-- Redirección: `/blog/tags/[tag]` -> `/[tag]`
-- Redirección: `/posts` -> `/blog`
-
-Con `experimental.globalRoutingPriority` habilitado (en lugar del orden de prioridad de rutas por defecto de Astro 4.0):
-
-- `/blog/tags/astro` se construye mediante la redirección a `/tags/[tag]` (en lugar de la ruta inyectada `/blog/[...slug]`)
-- `/blog/post/0` se construye mediante la ruta basada en archivos `/blog/post/[pid]` (en lugar de la ruta inyectada `/blog/[...slug]`)
-- `/posts` se construye mediante la redirección a `/blog` (en lugar de la ruta basada en archivos `/[page]`)
-
-
-En caso de colisión de rutas, cuando dos rutas con la misma prioridad intentan construir la misma URL, Astro registrará una advertencia identificando las rutas en conflicto.
-
-### experimental.rewriting
-
-<p>
-
-**Tipo:** `boolean`<br />
-**Por defecto:** `false`<br />
-<Since v="4.8.0" />
-</p>
-
-Habilita una característica de enrutamiento para reescribir solicitudes en páginas de Astro, puntos finales y middleware de Astro, brindándote control programático sobre tus rutas.
-
-```js
-{
-  experimental: {
-    rewriting: true,
-  },
-}
-```
-
-Usa `Astro.rewrite` en tus archivos `.astro` para redireccionar a una página diferente:
-
-```astro "rewrite"
----
-// src/pages/dashboard.astro
-if (!Astro.props.allowed) {
-	return Astro.rewrite("/")
-}
----
-```
-
-Usa `context.rewrite` en tus archivos de puntos finales para redirigir a una página diferente:
-
-```js
-// src/pages/api.js
-export function GET(ctx) {
-	if (!ctx.locals.allowed) {
-		return ctx.rewrite("/")
-	}
-}
-```
-
-Usa `next("/")` en tus archivos de middleware para redirigir a una página diferente, y luego llama a la siguiente función de middleware:
-
-```js
-// src/middleware.js
-export function onRequest(ctx, next) {
-	if (!ctx.cookies.get("allowed")) {
-		return next("/") // new signature
-	}
-	return next();
-}
-```
-
-Para obtener una visión completa, y proporcionar comentarios sobre esta API experimental, consulta [Rerouting RFC](https://github.com/withastro/roadmap/blob/feat/reroute/proposals/0047-rerouting.md).
-
-### experimental.env
-
-<p>
-
-**Tipo:** `object`<br />
-**Por defecto:** `undefined`<br />
-<Since v="4.10.0" />
-</p>
-
-Habilita las características experimentales de `astro:env`.
-
-La API `astro:env` te permite configurar un esquema seguro para tus variables de entorno, y especificar si deben estar disponibles en el servidor o en el cliente. Importa y utiliza sus variables definidas desde el módulo `/client` o `/server` correspondiente:
-
-```astro
----
-import { APP_ID } from "astro:env/client"
-import { API_URL, API_TOKEN, getSecret } from "astro:env/server"
-const NODE_ENV = getSecret("NODE_ENV")
-
-const data = await fetch(`${API_URL}/users`, {
-	method: "POST",
-	headers: {
-		"Content-Type": "application/json",
-		"Authorization": `Bearer ${API_TOKEN}`
-	},
-	body: JSON.stringify({ appId: APP_ID, nodeEnv: NODE_ENV })
-})
----
-```
-
-Para definir el tipo de datos y las propiedades de tus variables de entorno, declara un esquema en la configuración de Astro en `experimental.env.schema`. El ayudante `envField` te permite definir tu variable como una cadena (string), número (number), o booleano (boolean) y pasar propiedades en un objeto:
-
-```js
-// astro.config.mjs
-import { defineConfig, envField } from "astro/config"
-
-export default defineConfig({
-    experimental: {
-        env: {
-            schema: {
-                API_URL: envField.string({ context: "client", access: "public", optional: true }),
-                PORT: envField.number({ context: "server", access: "public", default: 4321 }),
-                API_SECRET: envField.string({ context: "server", access: "secret" }),
-            }
-        }
-    }
-})
-```
-
-Actualmente, hay cuatro tipos de datos compatibles: cadenas (strings), números (numbers), booleanos (booleans) y enumeraciones (enums).
-
-Hay tres tipos de variables de entorno, determinadas por la combinación de las configuraciones `context` (cliente o servidor) y `access` (secreto o público) definidas en tu [`env.schema`](#experimentalenvschema):
-
-- **Variables públicas del cliente**: Estas variables terminan en los paquetes finales tanto del cliente como del servidor, y pueden ser accedidas desde ambos a través del módulo `astro:env/client`:
-
-    ```js
-    import { API_URL } from "astro:env/client"
-    ```
-
-- **Variables públicas del servidor**: Estas variables terminan en tu paquete final del servidor y pueden ser accedidas en el servidor a través del módulo `astro:env/server`:
-
-    ```js
-    import { PORT } from "astro:env/server"
-    ```
-
-- **Variables secretas del servidor**: Estas variables no forman parte de tu paquete final y pueden ser accedidas en el servidor a través del módulo `astro:env/server`. La función auxiliar `getSecret()` puede ser utilizada para recuperar secretos que no están especificados en el esquema:
-
-    ```js
-    import { API_SECRET, getSecret } from "astro:env/server"
-
-    const SECRET_NOT_IN_SCHEMA = getSecret("SECRET_NOT_IN_SCHEMA") // string | undefined
-    ```
-
-**Nota:** Las variables secretas del cliente no son compatibles porque no hay una manera segura de enviar estos datos al cliente. Por lo tanto, no es posible configurar tanto `context: "client"` como `access: "secret"` en tu esquema.
-
-Para obtener una visión completa y proporcionar comentarios sobre esta API experimental, consulta [Astro Env RFC](https://github.com/withastro/roadmap/blob/main/proposals/0049-astro-env.md).
-
-#### experimental.env.schema
-
-<p>
-
-**Tipo:** `EnvSchema`<br />
-**Por defecto:** `undefined`<br />
-<Since v="4.10.0" />
-</p>
-
-Un objeto que usa `envField` para definir el tipo de datos (`string`, `number`, or `boolean`) y las propiedades de tus variables de entorno: `context` (cliente o servidor), `access` (pública o secreta), un valor `default` a  utilizar, y si esta variable de entorno es `optional` (opcional) o no (por defecto es `false`).
-```js
-// astro.config.mjs
-import { defineConfig, envField } from "astro/config"
-
-export default defineConfig({
-  experimental: {
-    env: {
-      schema: {
-        API_URL: envField.string({ context: "client", access: "public", optional: true }),
-        PORT: envField.number({ context: "server", access: "public", default: 4321 }),
-        API_SECRET: envField.string({ context: "server", access: "secret" }),
-      }
-    }
-  }
-})
-```
diff --git a/src/content/docs/es/reference/dev-toolbar-app-reference.mdx b/src/content/docs/es/reference/dev-toolbar-app-reference.mdx
deleted file mode 100644
index 03e32f5a4046d..0000000000000
--- a/src/content/docs/es/reference/dev-toolbar-app-reference.mdx
+++ /dev/null
@@ -1,489 +0,0 @@
----
-title: API de la App de la Barra de Herramientas de Desarrollo
-i18nReady: true
----
-
-La API de la App de la Barra de Herramientas de Desarrollo te permite crear apps que pueden ser usadas para extender la Barra de Herramientas de Desarrollo. Esto te permite añadir nuevas funciones e integraciones con servicios de terceros.
-
-## Agregando apps
-
-Las [Integraciones de Astro](/es/reference/configuration-reference/#integraciones) pueden agregar apps en [el hook `astro:config:setup`](/es/reference/integrations-reference/#astroconfigsetup) utilizando el método `addDevToolbarApp`.
-
-```ts title="integrations.js" {7-9}
-/**
- * @type {() => import('astro').AstroIntegration}
- */
-export default () => ({
-  name: "my-integration",
-  hooks: {
-    "astro:config:setup": ({ addDevToolbarApp }) => {
-      addDevToolbarApp("./my-app.js");
-    },
-  },
-});
-```
-
-## Estructura de la App de la Barra de Herramientas de Desarrollo
-
-Una app de la Barra de Herramientas de Desarrollo es un archivo `.js` o `.ts` que exporta por defecto un objeto con las siguientes propiedades obligatorias:
-
-```ts title="src/my-app.js"
-export default {
-	id: 'super-app',
-	name: 'Mi Super App',
-	icon: '<svg>...</svg>',
-	init(canvas, eventTarget) {
-    eventTarget.dispatchEvent(
-      new CustomEvent('toggle-notification', {
-        detail: {
-          state: true,
-        },
-      })
-    );
-  }
-}
-```
-
-
-### `id: string`
-
-Un identificador único para la app. Esto se utilizará para identificar de manera única la aplicación en hooks y eventos.
-
-```ts title="src/my-app.js" {2}
-export default {
-  id: 'my-app',
-  // ...
-}
-```
-
-### `name: string`
-
-El nombre de la aplicación. Esto se mostrará a los usuarios siempre que sea necesario hacer referencia a la aplicación mediante un nombre legible para los humanos.
-
-```ts title="src/my-app.js" {3}
-export default {
-  // ...
-  name: 'Mi App',
-  // ...
-}
-```
-
-### `icon: Icon`
-
-El ícono de la aplicación. Esto se utilizará para mostrar la aplicación en la UI. Puede ser un ícono de [la lista de íconos](#iconos), o un string que contenga el marcado SVG del ícono.
-
-```ts title="src/my-app.js" {3}
-export default {
-  // ...
-  icon: '<svg>...</svg>', // o 'astro:logo'
-  // ...
-}
-```
-
-### `init: (canvas: ShadowRoot, eventTarget: EventTarget) => void`
-
-Esta es la parte central de la aplicación. Esta función se llamará cuando se cargue la aplicación, ya sea cuando el navegador esté inactivo o cuando el usuario haga clic en la aplicación en la UI.
-
-La función recibe dos argumentos:
-
-#### `canvas`
-
-Un ShadowRoot que la aplicación puede utilizar para renderizar su UI. Cada aplicación recibe su propio ShadowRoot dedicado para renderizar su UI. Además, el elemento padre se posiciona utilizando `position: absolute;` y, como tal, la UI de la aplicación no afectará automáticamente el diseño de la página.
-
-```ts title="src/my-app.js" {3-5}
-export default {
-	// ...
-	init(canvas) {
-    canvas.appendChild(document.createTextNode('¡Hola Mundo!'))
-  }
-}
-```
-
-#### `eventTarget`
-
-Un [`EventTarget`](https://developer.mozilla.org/es/docs/Web/API/EventTarget) que puede ser usado para enviar y recibir eventos de la Barra de Herramientas de Desarrollo. 
-
-### `beforeTogglingOff`
-
-Esta función opcional se llamará cuando el usuario haga clic en el icono de la aplicación en la UI para desactivar la aplicación. Esta función se puede utilizar, por ejemplo, para realizar operaciones de limpieza, realizar una animación o pedir al usuario confirmación antes de desactivar la aplicación.
-
-Si se devuelve un valor falso, la desactivación se cancelará y la aplicación permanecerá habilitada.
-
-```ts title="src/my-app.js" {3-6}
-export default {
-  // ...
-  beforeTogglingOff() {
-    const confirmation = window.confirm('¿Estás seguro de que quieres desactivar esta app?');
-    return confirmation;
-  }
-}
-```
-
-#### canvas
-
-El ShadowRoot de la app se puede utilizar para renderizar cualquier UI necesaria.
-
-## Eventos del lado del cliente
-
-Utilizando el argumento [`eventTarget`](#eventtarget) en el hook [`init`](#init-canvas-shadowroot-eventtarget-eventtarget--void), las aplicaciones pueden enviar y recibir eventos desde la Barra de Herramientas de Desarrollo. Los siguientes eventos están disponibles:
-
-### `app-toggled`
-
-Este evento es disparado cuando el usuario hace clic en el icono de la aplicación en la Barra de Herramientas de Desarrollo.
-
-```ts title="src/my-app.js" {4-8}
-  export default {
-    // ...
-    init(canvas, eventTarget) {
-      eventTarget.addEventListener('app-toggled', (event) => {
-        if (event.detail.state === true) {
-          console.log("¡La app ya está habilitada!")
-        }
-      })
-    }
-  }
-```
-
-### `placement-updated`
-
-Este evento se dispara cuando el usuario cambia la ubicación de la Barra de Herramientas de Desarrollo.
-
-```ts title="src/my-app.js" {4-6}
-  export default {
-    // ...
-    init(canvas, eventTarget) {
-      eventTarget.addEventListener('placement-updated', (event) => {
-        console.log(`Placement set to ${event.detail.placement}`);
-      })
-    }
-  }
-```
-
-#### `state: boolean`
-
-Indica si la aplicación está habilitada o no después del clic del usuario.
-
-### `toggle-notification`
-
-Este evento puede enviarse para informar al usuario que la aplicación requiere atención.
-
-```ts title="src/my-app.js" {4-10}
-  export default {
-    // ...
-    init(canvas, eventTarget) {
-      eventTarget.dispatchEvent(
-        new CustomEvent('toggle-notification', {
-          detail: {
-            state: true,
-          },
-        })
-      );
-    }
-  }
-```
-
-#### `state: boolean`
-
-Indica si la aplicación tiene o no una notificación para el usuario. Si es `true`, el icono de la aplicación se resaltará con un punto rojo. Por el contrario, si es `false`, se eliminará el resaltado. Si no se especifica esta propiedad, se asumirá `true`.
-
-#### `level: 'error' | 'warning' | 'info'`
-
-Indica el nivel de la notificación. Se utilizará para determinar el color y la forma (círculo rosa oscuro, triángulo dorado o cuadrado azul) del resalte en el icono de la aplicación. Si no se especifica esta propiedad, se asumirá `'error'`.
-
-```ts
-eventTarget.dispatchEvent(
-  new CustomEvent("toggle-notification", {
-    detail: {
-      level: "warning",
-    },
-  })
-);
-```
-
-### `toggle-app`
-
-Este evento puede ser enviado desde tu aplicación para cambiar el estado de la misma. Puede ser útil, por ejemplo, para implementar un botón "Cerrar" en la UI de tu app.
-
-```ts title="src/my-app.js" {4-10}
-  export default {
-    // ...
-    init(canvas, eventTarget) {
-      eventTarget.dispatchEvent(
-        new CustomEvent('toggle-app', {
-          detail: {
-            state: false,
-          },
-        })
-      );
-    }
-  }
-```
-
-#### `state: boolean`
-
-Indica si la aplicación debe estar habilitada o no. Si es `true`, la aplicación estará habilitada. Por el contrario, si es `false`, la aplicación estará deshabilitada. Si no se especifica esta propiedad, se asumirá `true`.
-
-## Comunicación Cliente-Servidor
-
-Utilizando [los métodos de Vite para la comunicación cliente-servidor](https://vite.dev/guide/api-plugin.html#client-server-communication), las aplicaciones de la Barra de Herramientas de Desarrollo pueden comunicarse con el servidor.
-
-Además de poder enviar y recibir mensajes personalizados, la Barra de Herramientas de Desarrollo también envía los siguientes mensajes, donde `APP_ID` es el [ID de la app](#id-string):
-
-### `astro-dev-toolbar:APP_ID:initialized`
-
-Este mensaje se envía cuando se inicializa la aplicación. Los datos de este mensaje están vacíos.
-
-```ts title="integration.ts" {4-6}
-{
-  // ...
-  "astro:server:setup": ({ server }) => {
-    server.ws.on("astro-dev-toolbar:super-app:initialized", () => {
-      console.log("¡Mi app se ha inicializado!");
-    });
-  },
-  // ...
-}
-```
-
-### `astro-dev-toolbar:APP_ID:toggled`
-
-Este mensaje se envía cuando el usuario hace clic en el icono de la aplicación en la UI. Los datos de este mensaje son un booleano que indica si la aplicación está activada o no.
-
-```ts title="integration.ts" {4-6}
-{
-  // ...
-  "astro:server:setup": ({ server }) => {
-    server.ws.on("astro-dev-toolbar:super-app:toggled", (data) => {
-      console.log(`¡Mi app está ahora ${data.state ? "activada" : "desactivada"}!`);
-    });
-  },
-  // ...
-}
-```
-
-:::note
-El evento integrado `connection` de Vite se dispara **antes** de que se inicialicen las aplicaciones de la Barra de Herramientas de Desarrollo y, por tanto, no puede ser utilizado directamente por las aplicaciones. En su lugar, utiliza el evento `astro-dev-toolbar:APP_ID:initialized`.
-:::
-
-## Herramientas de la UI
-
-La Barra de Herramientas de Desarrollo incluye un conjuento de componentes web que pueden utilizarse para construir apps con un aspecto coherente.
-
-### `astro-dev-toolbar-window`
-
-Muestra una ventana.
-
-El slot del componente que se utilizará como contenido de la ventana.
-
-```html
-<astro-dev-toolbar-window>
-  <p>Mi contenido</p>
-</astro-dev-toolbar-window>
-```
-
-Cuando se construye una ventana utilizando JavaScript, el contenido asignado debe ir dentro del light DOM del componente.
-
-```js
-const myWindow = document.createElement('astro-dev-toolbar-window');
-const myContent = document.createElement('p');
-myContent.textContent = 'Mi contenido';
-
-// usar appendChild directamente en la ventana
-myWindow.appendChild(myContent);
-```
-
-### `astro-dev-toolbar-button`
-
-Muestra un botón.
-
-El slot del componente que se utilizará como contenido del botón.
-
-```js
-const myButton = document.createElement('astro-dev-toolbar-button');
-myButton.textContent = '¡Hazme clic!';
-myButton.buttonStyle = "purple";
-myButton.size = "medium";
-
-myButton.addEventListener('click', () => {
-  console.log('¡Clickeado!');
-});
-```
-
-#### `size`
-
-El tamaño del botón (`small`, `medium`, `large`).
-
-#### `button-style`
-
-El estilo del botón (`ghost`, `outline`, `purple`, `gray`, `red`, `green`, `yellow`, `blue`). Cuando se utiliza `ghost`, el botón es invisible y sólo se muestra su contenido.
-
-En JavaScript, establece esta propiedad utilizando la propiedad `buttonStyle` para evitar conflictos con la propiedad nativa `style`.
-
-### `astro-dev-toolbar-badge`
-
-Muestra una insignia.
-
-El slot del componente se utilizará como contenido de la insignia.
-
-```html
-<astro-dev-toolbar-badge>Mi insignia</astro-dev-toolbar-badge>
-```
-
-#### `size`
-
-El tamaño de la insignia (`small`, `large`).
-
-#### `badge-style`
-
-El estilo (color) de la insignia (`purple`, `gray`, `red`, `green`, `yellow`, `blue`).
-
-En JavaScript, establece esta propiedad usando la propiedad `badgeStyle` para evitar conflictos con la propiedad nativa `style`.
-
-### `astro-dev-toolbar-card`
-
-Muestra una tarjeta. Especifica un atributo opcional `link` para que la tarjeta actúe como un elemento `<a>`.
-
-Al crear una tarjeta mediante JavaScript, se puede especificar una propiedad `clickAction` para que la tarjeta actúe como un elemento `<button>`.
-
-El contenido de la tarjeta se tomará del slot del componente.
-
-```html
-<astro-dev-toolbar-card icon="astro:logo" link="https://github.com/withastro/astro/issues/new/choose">Informar de un problema</astro-dev-toolbar-card>
-```
-
-#### `card-style`
-
-El estilo de la tarjeta (`purple`, `gray`, `red`, `green`, `yellow`, `blue`). El color sólo se aplica al borde de la tarjeta al pasar el ratón por encima.
-
-En JavaScript, establece esta propiedad usando `cardStyle`.
-
-### `astro-dev-toolbar-toggle`
-
-Muestra un elemento toggle, que actúa como una checkbox. Este elemento internamente es una simple envoltura alrededor de un elemento nativo `<input type="checkbox">`. Se puede acceder al elemento checkbox utilizando la propiedad `input`.
-
-```ts
-const toggle = document.createElement('astro-dev-toolbar-toggle');
-
-toggle.input.addEventListener('change', (evt) => {
-  console.log(`¡Ahora el interruptor está ${evt.currentTarget.checked ? 'activado' : 'desactivado'}!`);
-});
-```
-
-#### `toggle-style`
-
-El estilo del toggle (`purple`, `gray`, `red`, `green`, `yellow`, `blue`).
-
-En JavaScript, establece esta propiedad utilizando la propiedad `toggleStyle`.
-
-### `astro-dev-toolbar-highlight`
-
-Puede utilizarse para resaltar un elemento de la página. En la mayoría de los casos, querrás posicionar y redimensionar este elemento usando las propiedades CSS `top`, `left`, `width` y `height` para que coincida con el elemento que quieres resaltar.
-
-```html
-<!-- Resaltar toda la página -->
-<astro-dev-toolbar-highlight style="top: 0; left: 0; width: 100%; height: 100%;"></astro-dev-toolbar-highlight>
-```
-
-```ts
-const elementToHighlight = document.querySelector('h1');
-const rect = elementToHighlight.getBoundingClientRect();
-
-const highlight = document.createElement('astro-dev-toolbar-highlight');
-
-highlight.style.top = `${Math.max(rect.top + window.scrollY - 10, 0)}px`;
-highlight.style.left = `${Math.max(rect.left + window.scrollX - 10, 0)}px`;
-highlight.style.width = `${rect.width + 15}px`;
-highlight.style.height = `${rect.height + 15}px`;
-highlight.icon = 'astro:logo';
-```
-
-#### `style`
-
-El estilo del resaltado (`purple`, `gray`, `red`, `green`, `yellow`, `blue`).
-
-#### `icon`
-
-Un [icono](#iconos) para mostrar en la esquina superior derecha del resaltado.
-
-### `astro-dev-toolbar-tooltip`
-
-Muestra un tooltip con diferentes secciones. Este componente se establece en `display: none;` de forma predeterminada y puede hacerse visible mediante un atributo `data-show="true"`.
-
-Las secciones se definen utilizando la propiedad `sections`. Esta propiedad es un array de objetos con la siguiente estructura:
-
-```ts
-{
-	title?: string; // Título de la sección
-	inlineTitle?: string; // Título de la sección, mostrado en línea junto al título
-	icon?: Icon; // Icono de la sección
-	content?: string; // Contenido de la sección
-	clickAction?: () => void | Promise<void>; // Acción a realizar al pulsar sobre la sección
-	clickDescription?: string; // Descripción de la acción a realizar al pulsar sobre la sección
-}
-```
-
-```ts
-const tooltip = document.createElement('astro-dev-toolbar-tooltip');
-
-tooltip.sections = [{
-  title: 'Mi seccion',
-  icon: 'astro:logo',
-  content: 'Mi contenido',
-  clickAction: () => {
-    console.log('¡Clickeado!')
-  },
-  clickDescription: '¡Hazme clic!'
-}]
-```
-
-Este componente suele combinarse con el componente `astro-dev-toolbar-highlight` para mostrar un tooltip al pasar el ratón sobre un elemento resaltado:
-
-```ts
-const highlight = document.createElement('astro-dev-toolbar-highlight');
-
-// Posicionar el resaltado...
-
-const tooltip = document.createElement('astro-dev-toolbar-tooltip');
-
-// Añadir secciones al tooltip...
-
-highlight.addEventListener('mouseover', () => {
-  tooltip.dataset.show = 'true';
-});
-
-highlight.addEventListener('mouseout', () => {
-  tooltip.dataset.show = 'false';
-});
-```
-
-### `astro-dev-toolbar-icon`
-
-Muestra un icono. Se puede especificar un icono de [la lista de iconos](#iconos) utilizando el atributo `icon`, o se puede pasar el marcado SVG de un icono como un slot.
-
-```html
-<astro-dev-toolbar-icon icon="astro:logo" />
-```
-
-```html
-<astro-dev-toolbar-icon>
-  <svg>...</svg>
-</astro-dev-toolbar-icon>
-```
-
-#### Iconos
-
-Actualmente, los siguientes iconos están disponibles y pueden ser usando en cualquier componente que acepte un icono:
-
-- `astro:logo`
-- `warning`
-- `arrow-down`
-- `bug`
-- `file-search`
-- `check-circle`
-- `gear`
-- `lightbulb`
-- `checkmark`
-- `dots-three`
-- `copy`
-
-Todos los iconos anteriores tienen `fill="currentColor"` establecido por defecto y heredarán su color del elemento padre.
diff --git a/src/content/docs/es/reference/directives-reference.mdx b/src/content/docs/es/reference/directives-reference.mdx
index 78d7d22b61b55..bf8232d65fe62 100644
--- a/src/content/docs/es/reference/directives-reference.mdx
+++ b/src/content/docs/es/reference/directives-reference.mdx
@@ -115,7 +115,7 @@ Estas directivas controlan cómo se hidratan los [componentes de framework](/es/
 
 De forma predeterminada, un componente de framework no está hidratado en el cliente. Si no se proporciona la directiva `client:*`, su HTML se representa en la página sin JavaScript.
 
-Una directiva de cliente puede ser usada solamente en un componente de framework UI que sea directamente importado en un componente `.astro`. Las directivas de hidratación no son compatibles cuando se usan [etiquetas dinámicas](/es/reference/astro-syntax/#etiquetas-dinámicas) y [componentes personalizados pasados a través de la propiedad `components`](/es/guides/markdown-content/#componentes-personalizados-con-mdx-importado).
+Una directiva de cliente puede ser usada solamente en un componente de framework UI que sea directamente importado en un componente `.astro`. Las directivas de hidratación no son compatibles cuando se usan [etiquetas dinámicas](/es/reference/astro-syntax/#etiquetas-dinámicas) y [componentes personalizados pasados a través de la propiedad `components`](/es/guides/integrations-guide/mdx/#custom-components-with-imported-mdx).
 
 ### `client:load`
 
@@ -217,7 +217,7 @@ Para los componentes que se renderizan solo en el cliente, también es posible m
 
 Desde Astro 2.6.0, las integraciones también pueden agregar directivas `client:*` personalizadas para cambiar cómo y cuándo se deben hidratar los componentes.
 
-Consulta la [API `addClientDirective`](/es/reference/integrations-reference/#opción-addclientdirective) para saber más sobre cómo crear una directiva de cliente personalizada.
+Consulta la [API `addClientDirective`](/es/reference/integrations-reference/#addclientdirective-option) para saber más sobre cómo crear una directiva de cliente personalizada.
 
 ## Directivas del Servidor
 
diff --git a/src/content/docs/es/reference/error-reference.mdx b/src/content/docs/es/reference/error-reference.mdx
deleted file mode 100644
index 2099ec4c74ff8..0000000000000
--- a/src/content/docs/es/reference/error-reference.mdx
+++ /dev/null
@@ -1,104 +0,0 @@
----
-title: Referencia de errores
-i18nReady: true
-githubURL: https://github.com/withastro/astro/blob/main/packages/astro/src/core/errors/errors-data.ts
----
-
-La siguiente referencia es una lista completa de los errores que puedes encontrar al usar Astro. Para obtener asistencia adicional, incluyendo las preguntas frequentes, consulta nuestra [Guía de solución de problemas](/es/guides/troubleshooting/).
-
-## Errores de Astro
-- [**UnknownCompilerError**](/es/reference/errors/unknown-compiler-error/)<br/>Unknown compiler error.
-- [**StaticRedirectNotAvailable**](/es/reference/errors/static-redirect-not-available/)<br/>`Astro.redirect` is not available in static mode.
-- [**ClientAddressNotAvailable**](/es/reference/errors/client-address-not-available/)<br/>`Astro.clientAddress` is not available in current adapter.
-- [**StaticClientAddressNotAvailable**](/es/reference/errors/static-client-address-not-available/)<br/>`Astro.clientAddress` is not available in static mode.
-- [**NoMatchingStaticPathFound**](/es/reference/errors/no-matching-static-path-found/)<br/>No static path found for requested path.
-- [**OnlyResponseCanBeReturned**](/es/reference/errors/only-response-can-be-returned/)<br/>Invalid type returned by Astro page.
-- [**MissingMediaQueryDirective**](/es/reference/errors/missing-media-query-directive/)<br/>Missing value for `client:media` directive.
-- [**NoMatchingRenderer**](/es/reference/errors/no-matching-renderer/)<br/>No matching renderer found.
-- [**NoClientEntrypoint**](/es/reference/errors/no-client-entrypoint/)<br/>No client entrypoint specified in renderer.
-- [**NoClientOnlyHint**](/es/reference/errors/no-client-only-hint/)<br/>Missing hint on `client:only` directive.
-- [**InvalidGetStaticPathParam**](/es/reference/errors/invalid-get-static-path-param/)<br/>Invalid value returned by a `getStaticPaths` path.
-- [**InvalidGetStaticPathsEntry**](/es/reference/errors/invalid-get-static-paths-entry/)<br/>Invalid entry inside getStaticPath's return value
-- [**InvalidGetStaticPathsReturn**](/es/reference/errors/invalid-get-static-paths-return/)<br/>Invalid value returned by getStaticPaths.
-- [**GetStaticPathsRemovedRSSHelper**](/es/reference/errors/get-static-paths-removed-rsshelper/)<br/>getStaticPaths RSS helper is not available anymore.
-- [**GetStaticPathsExpectedParams**](/es/reference/errors/get-static-paths-expected-params/)<br/>Missing params property on `getStaticPaths` route.
-- [**GetStaticPathsInvalidRouteParam**](/es/reference/errors/get-static-paths-invalid-route-param/)<br/>Invalid value for `getStaticPaths` route parameter.
-- [**GetStaticPathsRequired**](/es/reference/errors/get-static-paths-required/)<br/>`getStaticPaths()` function required for dynamic routes.
-- [**ReservedSlotName**](/es/reference/errors/reserved-slot-name/)<br/>Invalid slot name.
-- [**NoAdapterInstalled**](/es/reference/errors/no-adapter-installed/)<br/>Cannot use Server-side Rendering without an adapter.
-- [**NoMatchingImport**](/es/reference/errors/no-matching-import/)<br/>No import found for component.
-- [**InvalidPrerenderExport**](/es/reference/errors/invalid-prerender-export/)<br/>Invalid prerender export.
-- [**InvalidComponentArgs**](/es/reference/errors/invalid-component-args/)<br/>Invalid component arguments.
-- [**PageNumberParamNotFound**](/es/reference/errors/page-number-param-not-found/)<br/>Page number param not found.
-- [**ImageMissingAlt**](/es/reference/errors/image-missing-alt/)<br/>Missing alt property.
-- [**InvalidImageService**](/es/reference/errors/invalid-image-service/)<br/>Error while loading image service.
-- [**MissingImageDimension**](/es/reference/errors/missing-image-dimension/)<br/>Missing image dimensions
-- [**FailedToFetchRemoteImageDimensions**](/es/reference/errors/failed-to-fetch-remote-image-dimensions/)<br/>Failed to retrieve remote image dimensions
-- [**UnsupportedImageFormat**](/es/reference/errors/unsupported-image-format/)<br/>Unsupported image format
-- [**UnsupportedImageConversion**](/es/reference/errors/unsupported-image-conversion/)<br/>Unsupported image conversion
-- [**PrerenderDynamicEndpointPathCollide**](/es/reference/errors/prerender-dynamic-endpoint-path-collide/)<br/>Prerendered dynamic endpoint has path collision.
-- [**ExpectedImage**](/es/reference/errors/expected-image/)<br/>Expected src to be an image.
-- [**ExpectedImageOptions**](/es/reference/errors/expected-image-options/)<br/>Expected image options.
-- [**IncompatibleDescriptorOptions**](/es/reference/errors/incompatible-descriptor-options/)<br/>Cannot set both `densities` and `widths`
-- [**ImageNotFound**](/es/reference/errors/image-not-found/)<br/>Image not found.
-- [**NoImageMetadata**](/es/reference/errors/no-image-metadata/)<br/>Could not process image metadata.
-- [**MarkdownImageNotFound**](/es/reference/errors/markdown-image-not-found/)<br/>Image not found.
-- [**CouldNotTransformImage**](/es/reference/errors/could-not-transform-image/)<br/>Could not transform image.
-- [**ResponseSentError**](/es/reference/errors/response-sent-error/)<br/>Unable to set response.
-- [**MiddlewareNoDataOrNextCalled**](/es/reference/errors/middleware-no-data-or-next-called/)<br/>The middleware didn't return a `Response`.
-- [**MiddlewareNotAResponse**](/es/reference/errors/middleware-not-aresponse/)<br/>The middleware returned something that is not a `Response` object.
-- [**EndpointDidNotReturnAResponse**](/es/reference/errors/endpoint-did-not-return-aresponse/)<br/>The endpoint did not return a `Response`.
-- [**LocalsNotAnObject**](/es/reference/errors/locals-not-an-object/)<br/>Value assigned to `locals` is not accepted.
-- [**AstroResponseHeadersReassigned**](/es/reference/errors/astro-response-headers-reassigned/)<br/>`Astro.response.headers` must not be reassigned.
-- [**MiddlewareCantBeLoaded**](/es/reference/errors/middleware-cant-be-loaded/)<br/>Can't load the middleware.
-- [**LocalImageUsedWrongly**](/es/reference/errors/local-image-used-wrongly/)<br/>Local images must be imported.
-- [**AstroGlobUsedOutside**](/es/reference/errors/astro-glob-used-outside/)<br/>Astro.glob() used outside of an Astro file.
-- [**AstroGlobNoMatch**](/es/reference/errors/astro-glob-no-match/)<br/>Astro.glob() did not match any files.
-- [**RedirectWithNoLocation**](/es/reference/errors/redirect-with-no-location/)<br/>A redirect must be given a location with the `Location` header.
-- [**InvalidDynamicRoute**](/es/reference/errors/invalid-dynamic-route/)<br/>Invalid dynamic route.
-- [**MissingSharp**](/es/reference/errors/missing-sharp/)<br/>Could not find Sharp.
-- [**UnknownViteError**](/es/reference/errors/unknown-vite-error/)<br/>Unknown Vite Error.
-- [**FailedToLoadModuleSSR**](/es/reference/errors/failed-to-load-module-ssr/)<br/>Could not import file.
-- [**InvalidGlob**](/es/reference/errors/invalid-glob/)<br/>Invalid glob pattern.
-- [**FailedToFindPageMapSSR**](/es/reference/errors/failed-to-find-page-map-ssr/)<br/>Astro couldn't find the correct page to render
-- [**MissingLocale**](/es/reference/errors/missing-locale/)<br/>The provided locale does not exist.
-- [**MissingIndexForInternationalization**](/es/reference/errors/missing-index-for-internationalization/)<br/>Index page not found.
-- [**IncorrectStrategyForI18n**](/es/reference/errors/incorrect-strategy-for-i18n/)<br/> You can't use the current function with the current strategy
-- [**NoPrerenderedRoutesWithDomains**](/es/reference/errors/no-prerendered-routes-with-domains/)<br/>Prerendered routes aren't supported when internationalization domains are enabled.
-- [**MissingMiddlewareForInternationalization**](/es/reference/errors/missing-middleware-for-internationalization/)<br/>Enabled manual internationalization routing without having a middleware.
-- [**CantRenderPage**](/es/reference/errors/cant-render-page/)<br/>Astro can't render the route.
-- [**UnhandledRejection**](/es/reference/errors/unhandled-rejection/)<br/>Unhandled rejection
-- [**i18nNotEnabled**](/es/reference/errors/i18n-not-enabled/)<br/>i18n Not Enabled
-
-## Errores de CSS
-
-- [**UnknownCSSError**](/es/reference/errors/unknown-csserror/)<br/>Unknown CSS Error.
-- [**CSSSyntaxError**](/es/reference/errors/csssyntax-error/)<br/>CSS Syntax Error.
-
-## Errores de Markdown
-
-- [**UnknownMarkdownError**](/es/reference/errors/unknown-markdown-error/)<br/>Unknown Markdown Error.
-- [**MarkdownFrontmatterParseError**](/es/reference/errors/markdown-frontmatter-parse-error/)<br/>Failed to parse Markdown frontmatter.
-- [**InvalidFrontmatterInjectionError**](/es/reference/errors/invalid-frontmatter-injection-error/)<br/>Invalid frontmatter injection.
-- [**MdxIntegrationMissingError**](/es/reference/errors/mdx-integration-missing-error/)<br/>MDX integration missing.
-- [**UnknownConfigError**](/es/reference/errors/unknown-config-error/)<br/>Unknown configuration error.
-- [**ConfigNotFound**](/es/reference/errors/config-not-found/)<br/>Specified configuration file not found.
-- [**ConfigLegacyKey**](/es/reference/errors/config-legacy-key/)<br/>Legacy configuration detected.
-
-## Errores de CLI
-
-- [**UnknownCLIError**](/es/reference/errors/unknown-clierror/)<br/>Unknown CLI Error.
-- [**GenerateContentTypesError**](/es/reference/errors/generate-content-types-error/)<br/>Failed to generate content types.
-
-## Errores de Colección de Contenido
-
-- [**UnknownContentCollectionError**](/es/reference/errors/unknown-content-collection-error/)<br/>Unknown Content Collection Error.
-- [**InvalidContentEntryFrontmatterError**](/es/reference/errors/invalid-content-entry-frontmatter-error/)<br/>Content entry frontmatter does not match schema.
-- [**InvalidContentEntrySlugError**](/es/reference/errors/invalid-content-entry-slug-error/)<br/>Invalid content entry slug.
-- [**ContentSchemaContainsSlugError**](/es/reference/errors/content-schema-contains-slug-error/)<br/>Content Schema should not contain `slug`.
-- [**CollectionDoesNotExistError**](/es/reference/errors/collection-does-not-exist-error/)<br/>Collection does not exist
-- [**MixedContentDataCollectionError**](/es/reference/errors/mixed-content-data-collection-error/)<br/>Content and data cannot be in same collection.
-- [**ContentCollectionTypeMismatchError**](/es/reference/errors/content-collection-type-mismatch-error/)<br/>Collection contains entries of a different type.
-- [**DataCollectionEntryParseError**](/es/reference/errors/data-collection-entry-parse-error/)<br/>Data collection entry failed to parse.
-- [**DuplicateContentEntrySlugError**](/es/reference/errors/duplicate-content-entry-slug-error/)<br/>Duplicate content entry slug.
-- [**UnsupportedConfigTransformError**](/es/reference/errors/unsupported-config-transform-error/)<br/>Unsupported transform in content config.
diff --git a/src/content/docs/es/reference/errors/client-address-not-available.mdx b/src/content/docs/es/reference/errors/client-address-not-available.mdx
index e822eaefdddd4..b99b90eefc350 100644
--- a/src/content/docs/es/reference/errors/client-address-not-available.mdx
+++ b/src/content/docs/es/reference/errors/client-address-not-available.mdx
@@ -15,5 +15,5 @@ githubURL: https://github.com/withastro/astro/blob/main/packages/astro/src/core/
 Lamentablemente, el adaptador que estás utilizando no es compatible con `Astro.clientAddress`.
 
 **Ver también:**
--  [Integraciones oficiales](/es/guides/integrations-guide/#integraciones-oficiales)
--  [Astro.clientAddress](/es/reference/api-reference/#astroclientaddress)
+-  [Integraciones oficiales](/es/guides/integrations-guide/#official-integrations)
+-  [Astro.clientAddress](/es/reference/api-reference/#clientaddress)
diff --git a/src/content/docs/es/reference/errors/content-collection-type-mismatch-error.mdx b/src/content/docs/es/reference/errors/content-collection-type-mismatch-error.mdx
index b3d907d252c02..15d16e3f9e83d 100644
--- a/src/content/docs/es/reference/errors/content-collection-type-mismatch-error.mdx
+++ b/src/content/docs/es/reference/errors/content-collection-type-mismatch-error.mdx
@@ -10,4 +10,4 @@ githubURL: https://github.com/withastro/astro/blob/main/packages/astro/src/core/
 Las colecciones de contenido deben contener entradas del tipo configurado. Por defecto, las colecciones tienen `type: 'content'`. Intenta agregar `type: 'data'` a la configuración de tu colección para las colecciones de datos.
 
 **Ver también:**
--  [Definiendo colecciones de contenido](/es/guides/content-collections/#definiendo-colecciones)
+-  [Definiendo colecciones de contenido](/es/guides/upgrade-to/v5/#updating-existing-collections)
diff --git a/src/content/docs/es/reference/errors/content-schema-contains-slug-error.mdx b/src/content/docs/es/reference/errors/content-schema-contains-slug-error.mdx
index 91c7fc6956a2c..13b6c6ecbbee9 100644
--- a/src/content/docs/es/reference/errors/content-schema-contains-slug-error.mdx
+++ b/src/content/docs/es/reference/errors/content-schema-contains-slug-error.mdx
@@ -10,4 +10,4 @@ githubURL: https://github.com/withastro/astro/blob/main/packages/astro/src/core/
 Un esquema de colección de contenido no debe contener la propiedad `slug`. Esto está reservado por Astro para generar slugs. Elimina `slug` de tu esquema. Aún puedes usar slugs personalizados en tu frontmatter.
 
 **Ver también:**
--  [La propiedad reservada `slug`](/es/guides/content-collections/#definiendo-slugs-personalizados)
+-  [La propiedad reservada `slug`](/es/guides/upgrade-to/v5/#updating-existing-collections)
diff --git a/src/content/docs/es/reference/errors/failed-to-load-module-ssr.mdx b/src/content/docs/es/reference/errors/failed-to-load-module-ssr.mdx
index 156731185c874..28c070ae66dd0 100644
--- a/src/content/docs/es/reference/errors/failed-to-load-module-ssr.mdx
+++ b/src/content/docs/es/reference/errors/failed-to-load-module-ssr.mdx
@@ -15,8 +15,8 @@ githubURL: https://github.com/withastro/astro/blob/main/packages/astro/src/core/
 
 Astro no pudo importar el archivo solicitado. A menudo, esto se debe a que la ruta de importación es incorrecta (ya sea porque el archivo no existe o hay un error ortográficos en la ruta)
 
-Este mensaje también puede aparecer cuando se importa un tipo sin especificar que se trata de una [importación de tipo](/es/guides/typescript/#importación-de-tipos).
+Este mensaje también puede aparecer cuando se importa un tipo sin especificar que se trata de una [importación de tipo](/es/guides/typescript/#type-imports).
 
 **Ver también:**
 
--  [Importación de tipos](/es/guides/typescript/#importación-de-tipos)
+-  [Importación de tipos](/es/guides/typescript/#type-imports)
diff --git a/src/content/docs/es/reference/errors/get-static-paths-expected-params.mdx b/src/content/docs/es/reference/errors/get-static-paths-expected-params.mdx
index a584e17f643f2..51f2d7c792f4c 100644
--- a/src/content/docs/es/reference/errors/get-static-paths-expected-params.mdx
+++ b/src/content/docs/es/reference/errors/get-static-paths-expected-params.mdx
@@ -30,5 +30,5 @@ Creará la siguiente ruta: `site.com/blog/1`.
 
 **Ver también:**
 
--  [`getStaticPaths()`](/es/reference/api-reference/#getstaticpaths)
+-  [`getStaticPaths()`](/es/reference/routing-reference/#getstaticpaths)
 -  [`params`](/es/reference/api-reference/#params)
diff --git a/src/content/docs/es/reference/errors/get-static-paths-invalid-route-param.mdx b/src/content/docs/es/reference/errors/get-static-paths-invalid-route-param.mdx
index 6f75af90d7ba1..525bd673e8e61 100644
--- a/src/content/docs/es/reference/errors/get-static-paths-invalid-route-param.mdx
+++ b/src/content/docs/es/reference/errors/get-static-paths-invalid-route-param.mdx
@@ -27,7 +27,7 @@ export async function getStaticPaths() {
 ---
 ```
 
-En las rutas que usan [parámetros rest](/es/guides/routing/#parámetros-rest), `undefined` se puede usar para representar una ruta sin parámetros pasados en la URL:
+En las rutas que usan [parámetros rest](/es/guides/routing/#rest-parameters), `undefined` se puede usar para representar una ruta sin parámetros pasados en la URL:
 
 ```astro title="/route/[...id].astro"
 ---
@@ -43,5 +43,5 @@ export async function getStaticPaths() {
 
 **Ver también:**
 
--  [`getStaticPaths()`](/es/reference/api-reference/#getstaticpaths)
+-  [`getStaticPaths()`](/es/reference/routing-reference/#getstaticpaths)
 -  [`params`](/es/reference/api-reference/#params)
diff --git a/src/content/docs/es/reference/errors/get-static-paths-removed-rsshelper.mdx b/src/content/docs/es/reference/errors/get-static-paths-removed-rsshelper.mdx
index 71741e1c745f7..032ae4c80e8ff 100644
--- a/src/content/docs/es/reference/errors/get-static-paths-removed-rsshelper.mdx
+++ b/src/content/docs/es/reference/errors/get-static-paths-removed-rsshelper.mdx
@@ -12,7 +12,7 @@ Obsoleto desde Astro 4.0. El helper de RSS ya no existe con un error de respaldo
 
 ## ¿Qué salió mal?
 
-`getStaticPaths` ya no expone un helper para generar un RSS feed. Recomendamos migrar a la integración [@astrojs/rss](/es/recipes/rss/#configurando-astrojsrss) en su lugar.
+`getStaticPaths` ya no expone un helper para generar un RSS feed. Recomendamos migrar a la integración [@astrojs/rss](/es/recipes/rss/#setting-up-astrojsrss) en su lugar.
 
 **Ver también:**
 -  [Guía RSS](/es/recipes/rss/)
diff --git a/src/content/docs/es/reference/errors/get-static-paths-required.mdx b/src/content/docs/es/reference/errors/get-static-paths-required.mdx
index 3beb6595817df..fa9e7cc0dbe11 100644
--- a/src/content/docs/es/reference/errors/get-static-paths-required.mdx
+++ b/src/content/docs/es/reference/errors/get-static-paths-required.mdx
@@ -13,9 +13,9 @@ githubURL: https://github.com/withastro/astro/blob/main/packages/astro/src/core/
 
 ## ¿Qué salió mal?
 
-En [modo estático](/es/guides/routing/#modo-estático-ssg), todas las rutas deben determinarse en el momento de la compilación. Como tal, las rutas dinámicas deben `exportar` una función `getStaticPaths` que devuelva las diferentes rutas para generar.
+En [modo estático](/es/guides/routing/#static-ssg-mode), todas las rutas deben determinarse en el momento de la compilación. Como tal, las rutas dinámicas deben `exportar` una función `getStaticPaths` que devuelva las diferentes rutas para generar.
 
 **Ver también:**
--  [Rutas Dinámicas](/es/guides/routing/#rutas-dinámicas)
--  [`getStaticPaths()`](/es/reference/api-reference/#getstaticpaths)
+-  [Rutas Dinámicas](/es/guides/routing/#dynamic-routes)
+-  [`getStaticPaths()`](/es/reference/routing-reference/#getstaticpaths)
 -  [Renderizado en el servidor](/es/guides/on-demand-rendering/)
diff --git a/src/content/docs/es/reference/errors/image-missing-alt.mdx b/src/content/docs/es/reference/errors/image-missing-alt.mdx
index 4ed2c270aca9b..2550992e8e9f7 100644
--- a/src/content/docs/es/reference/errors/image-missing-alt.mdx
+++ b/src/content/docs/es/reference/errors/image-missing-alt.mdx
@@ -18,5 +18,5 @@ Si la imagen es meramente decorativa (es decir, no contribuye a la comprensión
 
 **Ver también:**
 -  [Images](/es/guides/images/)
--  [Componente Imagen](/es/guides/images/#image--astroassets)
--  [Componente Imagen#alt](/es/guides/images/#alt-requerido)
+-  [Componente Imagen](/es/reference/modules/astro-assets/#image-)
+-  [Componente Imagen#alt](/es/reference/modules/astro-assets/#alt-required)
diff --git a/src/content/docs/es/reference/errors/incorrect-strategy-for-i18n.mdx b/src/content/docs/es/reference/errors/incorrect-strategy-for-i18n.mdx
index aeffd063950fe..08ac689928e02 100644
--- a/src/content/docs/es/reference/errors/incorrect-strategy-for-i18n.mdx
+++ b/src/content/docs/es/reference/errors/incorrect-strategy-for-i18n.mdx
@@ -10,4 +10,4 @@ githubURL: https://github.com/withastro/astro/blob/main/packages/astro/src/core/
 Algunas funciones de internacionalización sólo están disponibles cuando el enrutamiento de Astro está deshabilitado por la configuración `i18n.routing: "manual"`.
 
 **Ver también:**
--  [Enrutamiento con `i18n`](/es/guides/internationalization/#enrutamiento)
+-  [Enrutamiento con `i18n`](/es/guides/internationalization/#routing)
diff --git a/src/content/docs/es/reference/errors/invalid-dynamic-route.mdx b/src/content/docs/es/reference/errors/invalid-dynamic-route.mdx
index 79fea269a1e0f..ddefe1eeb616a 100644
--- a/src/content/docs/es/reference/errors/invalid-dynamic-route.mdx
+++ b/src/content/docs/es/reference/errors/invalid-dynamic-route.mdx
@@ -7,7 +7,7 @@ githubURL: https://github.com/withastro/astro/blob/main/packages/astro/src/core/
 > **InvalidDynamicRoute**: El parámetro INVALID_PARAM para la ruta ROUTE es inválido. Recibido **RECEIVED**. (E03038)
 
 ## ¿Qué salió mal?
-Un parámetro de ruta dinámica es inválido. Esto es a menudo causado por un parámetro `undefined` o un [parámetro rest](/es/guides/routing/#parámetros-rest) faltante.
+Un parámetro de ruta dinámica es inválido. Esto es a menudo causado por un parámetro `undefined` o un [parámetro rest](/es/guides/routing/#rest-parameters) faltante.
 
 **Ver también:**
--  [Rutas dinámicas](/es/guides/routing/#rutas-dinámicas)
\ No newline at end of file
+-  [Rutas dinámicas](/es/guides/routing/#dynamic-routes)
\ No newline at end of file
diff --git a/src/content/docs/es/reference/errors/invalid-frontmatter-injection-error.mdx b/src/content/docs/es/reference/errors/invalid-frontmatter-injection-error.mdx
index 6a6215f693fa5..7a2cf3a103c42 100644
--- a/src/content/docs/es/reference/errors/invalid-frontmatter-injection-error.mdx
+++ b/src/content/docs/es/reference/errors/invalid-frontmatter-injection-error.mdx
@@ -17,4 +17,4 @@ Un plugin de remark o rehype intentó inyectar frontmatter inválido. Esto ocurr
 
 **Ver también:**
 
--  [Modificación programática del frontmatter](/es/guides/markdown-content/#modificación-programática-del-frontmatter)
+-  [Modificación programática del frontmatter](/es/guides/markdown-content/#modifying-frontmatter-programmatically)
diff --git a/src/content/docs/es/reference/errors/invalid-get-static-path-param.mdx b/src/content/docs/es/reference/errors/invalid-get-static-path-param.mdx
index 6a4ef13fcc3f9..2568bb2046082 100644
--- a/src/content/docs/es/reference/errors/invalid-get-static-path-param.mdx
+++ b/src/content/docs/es/reference/errors/invalid-get-static-path-param.mdx
@@ -28,5 +28,5 @@ export async function getStaticPaths() {
 
 **Ver también:**
 
--  [`getStaticPaths()`](/es/reference/api-reference/#getstaticpaths)
+-  [`getStaticPaths()`](/es/reference/routing-reference/#getstaticpaths)
 -  [`params`](/es/reference/api-reference/#params)
diff --git a/src/content/docs/es/reference/errors/invalid-get-static-paths-entry.mdx b/src/content/docs/es/reference/errors/invalid-get-static-paths-entry.mdx
index 28d956d40d3d0..b422eac9ecf1e 100644
--- a/src/content/docs/es/reference/errors/invalid-get-static-paths-entry.mdx
+++ b/src/content/docs/es/reference/errors/invalid-get-static-paths-entry.mdx
@@ -20,4 +20,4 @@ export async function getStaticPaths() {
 ```
 
 **Ver también:**
--  [`getStaticPaths()`](/es/reference/api-reference/#getstaticpaths)
+-  [`getStaticPaths()`](/es/reference/routing-reference/#getstaticpaths)
diff --git a/src/content/docs/es/reference/errors/invalid-get-static-paths-return.mdx b/src/content/docs/es/reference/errors/invalid-get-static-paths-return.mdx
index c7023d6a0713d..05574714328ba 100644
--- a/src/content/docs/es/reference/errors/invalid-get-static-paths-return.mdx
+++ b/src/content/docs/es/reference/errors/invalid-get-static-paths-return.mdx
@@ -26,5 +26,5 @@ export async function getStaticPaths() {
 
 **Ver también:**
 
--  [`getStaticPaths()`](/es/reference/api-reference/#getstaticpaths)
+-  [`getStaticPaths()`](/es/reference/routing-reference/#getstaticpaths)
 -  [`params`](/es/reference/api-reference/#params)
diff --git a/src/content/docs/es/reference/errors/invalid-glob.mdx b/src/content/docs/es/reference/errors/invalid-glob.mdx
index 73d975cac31de..42278606900a0 100644
--- a/src/content/docs/es/reference/errors/invalid-glob.mdx
+++ b/src/content/docs/es/reference/errors/invalid-glob.mdx
@@ -17,4 +17,4 @@ Astro encontró un patrón glob inválido. Esto se debe a que el patrón glob no
 
 **Ver también:**
 
--  [Patrónes glob](/es/guides/imports/#patrones-glob)
+-  [Patrónes glob](/es/guides/imports/#glob-patterns)
diff --git a/src/content/docs/es/reference/errors/local-image-used-wrongly.mdx b/src/content/docs/es/reference/errors/local-image-used-wrongly.mdx
index 78e1f1fab14f2..b38f3aed693f9 100644
--- a/src/content/docs/es/reference/errors/local-image-used-wrongly.mdx
+++ b/src/content/docs/es/reference/errors/local-image-used-wrongly.mdx
@@ -9,7 +9,7 @@ githubURL: https://github.com/withastro/astro/blob/main/packages/astro/src/core/
 ## ¿Qué salió mal?
 Cuando se utilizan los servicios de imagen predeterminados, el parámetro `src` de `Image` y `getImage` debe ser una imagen importada o una URL, no puede ser una cadena de caracteres con una ruta de archivo.
 
-Para imágenes locales de colecciones de contenido, puedes usar el [helper de esquema image()](/es/guides/images/#imágenes-en-colecciones-de-contenido) para resolver las imágenes.
+Para imágenes locales de colecciones de contenido, puedes usar el [helper de esquema image()](/es/guides/images/#images-in-content-collections) para resolver las imágenes.
 
 ```astro
 ---
diff --git a/src/content/docs/es/reference/errors/missing-image-dimension.mdx b/src/content/docs/es/reference/errors/missing-image-dimension.mdx
index b6198271a3b1f..bdf5b05c22bd2 100644
--- a/src/content/docs/es/reference/errors/missing-image-dimension.mdx
+++ b/src/content/docs/es/reference/errors/missing-image-dimension.mdx
@@ -7,10 +7,10 @@ githubURL: https://github.com/withastro/astro/blob/main/packages/astro/src/core/
 > Falta el atributo de ancho y alto para `IMAGE_URL`. Cuando se usan imágenes remotas, ambas dimensiones son necesarias para evitar el desplazamiento acumulativo de la capa (CLS).
 
 ## ¿Qué salió mal?
-Para imágenes remotas, no se pueden inferir automaticamente el `width` y `height` del archivo original. Para evitar el Desplazamiento del Acumulativo del Diseño (CLS), especifica estas dos propiedades o establece [`inferSize`](/es/guides/images/#infersize) en `true` para obtener las dimensiones originales de una imagen remota.
+Para imágenes remotas, no se pueden inferir automaticamente el `width` y `height` del archivo original. Para evitar el Desplazamiento del Acumulativo del Diseño (CLS), especifica estas dos propiedades o establece [`inferSize`](/es/reference/modules/astro-assets/#infersize) en `true` para obtener las dimensiones originales de una imagen remota.
 
-Si tu imagen está dentro de tu carpeta `src`, probablemente quieras importarla en su lugar. Consulta [la guía de importaciones para obtener más información](/es/guides/imports/#otros-recursos).
+Si tu imagen está dentro de tu carpeta `src`, probablemente quieras importarla en su lugar. Consulta [la guía de importaciones para obtener más información](/es/guides/imports/#other-assets).
 
 **Ver también:**
 -  [Images](/es/guides/images/)
--  [Componente Imagen#width-y-height-requerido](/es/guides/images/#width-y-height-requerido-para-imágenes-en-public)
+-  [Componente Imagen#width-y-height-requerido](/es/reference/modules/astro-assets/#width-and-height-required-for-images-in-public)
diff --git a/src/content/docs/es/reference/errors/missing-index-for-internationalization.mdx b/src/content/docs/es/reference/errors/missing-index-for-internationalization.mdx
index 41fbb9edc8838..97502aad5097b 100644
--- a/src/content/docs/es/reference/errors/missing-index-for-internationalization.mdx
+++ b/src/content/docs/es/reference/errors/missing-index-for-internationalization.mdx
@@ -11,7 +11,7 @@ githubURL: https://github.com/withastro/astro/blob/main/packages/astro/src/core/
 Astro no pudo encontrar la URL de índice de tu sitio web. Se requiere una página de índice para que Astro pueda crear una redirección desde la página de índice principal a la página de índice localizada del idioma predeterminado cuando se usa [`i18n.routing.prefixDefaultLocale`](/es/reference/configuration-reference/#i18nroutingprefixdefaultlocale).
 
 **Ver también:**
--  [Internacionalización](/es/guides/internationalization/#enrutamiento)
+-  [Internacionalización](/es/guides/internationalization/#routing)
 -  [Referencia de configuración `i18n.locales`](/es/reference/configuration-reference/#i18nlocales)
 
 
diff --git a/src/content/docs/es/reference/errors/missing-sharp.mdx b/src/content/docs/es/reference/errors/missing-sharp.mdx
index 36c6c1200d674..f9891c689fbc2 100644
--- a/src/content/docs/es/reference/errors/missing-sharp.mdx
+++ b/src/content/docs/es/reference/errors/missing-sharp.mdx
@@ -22,6 +22,6 @@ export default defineConfig({
 ```
 
 **Ver también:**
--  [Servicio de Imágenes Predeterminado](/es/guides/images/#servicio-de-imágenes-por-defecto)
--  [Componente Image](/es/guides/images/#image--astroassets)
+-  [Servicio de Imágenes Predeterminado](/es/guides/images/#default-image-service)
+-  [Componente Image](/es/reference/modules/astro-assets/#image-)
 -  [API de Servicios de Imágenes](/es/reference/image-service-reference/)
diff --git a/src/content/docs/es/reference/errors/mixed-content-data-collection-error.mdx b/src/content/docs/es/reference/errors/mixed-content-data-collection-error.mdx
index caa108458ad61..9181a69157d3c 100644
--- a/src/content/docs/es/reference/errors/mixed-content-data-collection-error.mdx
+++ b/src/content/docs/es/reference/errors/mixed-content-data-collection-error.mdx
@@ -10,4 +10,4 @@ githubURL: https://github.com/withastro/astro/blob/main/packages/astro/src/core/
 Una colección de contenido no puede contener una combinación de entradas de contenido y datos. Debes almacenar las entradas en colecciones separadas según su tipo.
 
 **Ver también:**
--  [Definiendo colecciones de contenido](/es/guides/content-collections/#definiendo-colecciones)
+-  [Definiendo colecciones de contenido](/es/guides/upgrade-to/v5/#updating-existing-collections)
diff --git a/src/content/docs/es/reference/errors/no-client-entrypoint.mdx b/src/content/docs/es/reference/errors/no-client-entrypoint.mdx
index feaf5d1ac83e0..9be65d979f4f7 100644
--- a/src/content/docs/es/reference/errors/no-client-entrypoint.mdx
+++ b/src/content/docs/es/reference/errors/no-client-entrypoint.mdx
@@ -17,5 +17,5 @@ Astro intentó hidratar un componente en el cliente, pero el renderizador utiliz
 
 **Ver también:**
 
--  [Opción addRenderer](/es/reference/integrations-reference/#opción-addrenderer)
--  [Hidratando componentes de framework](/es/guides/framework-components/#hidratando-componentes-interactivos)
+-  [Opción addRenderer](/es/reference/integrations-reference/#addrenderer-option)
+-  [Hidratando componentes de framework](/es/guides/framework-components/#hydrating-interactive-components)
diff --git a/src/content/docs/es/reference/errors/no-matching-renderer.mdx b/src/content/docs/es/reference/errors/no-matching-renderer.mdx
index b811840581a30..a9d39a005eab9 100644
--- a/src/content/docs/es/reference/errors/no-matching-renderer.mdx
+++ b/src/content/docs/es/reference/errors/no-matching-renderer.mdx
@@ -20,4 +20,4 @@ Para archivos JSX/TSX, [@astrojs/react](/es/guides/integrations-guide/react/), [
 **Ver también:**
 
 -  [Componentes de framework](/es/guides/framework-components/)
--  [Frameworks officiales](/es/guides/integrations-guide/#integraciones-oficiales)
+-  [Frameworks officiales](/es/guides/integrations-guide/#official-integrations)
diff --git a/src/content/docs/es/reference/errors/no-matching-static-path-found.mdx b/src/content/docs/es/reference/errors/no-matching-static-path-found.mdx
index c468abfbe1a74..055edcccdc606 100644
--- a/src/content/docs/es/reference/errors/no-matching-static-path-found.mdx
+++ b/src/content/docs/es/reference/errors/no-matching-static-path-found.mdx
@@ -13,8 +13,8 @@ githubURL: https://github.com/withastro/astro/blob/main/packages/astro/src/core/
 
 ## ¿Qué salió mal?
 
-Se encontró una [ruta dinámica](/es/guides/routing/#rutas-dinámicas), pero no se encontró la ruta correspondiente para los parámetros solicitados. Esto a menudo es causado por un error tipográfico en la ruta generada o solicitada.
+Se encontró una [ruta dinámica](/es/guides/routing/#dynamic-routes), pero no se encontró la ruta correspondiente para los parámetros solicitados. Esto a menudo es causado por un error tipográfico en la ruta generada o solicitada.
 
 **Ver también:**
 
--  [getStaticPaths()](/es/reference/api-reference/#getstaticpaths)
+-  [getStaticPaths()](/es/reference/routing-reference/#getstaticpaths)
diff --git a/src/content/docs/es/reference/errors/page-number-param-not-found.mdx b/src/content/docs/es/reference/errors/page-number-param-not-found.mdx
index a818355ad252b..fe90ca8cb45eb 100644
--- a/src/content/docs/es/reference/errors/page-number-param-not-found.mdx
+++ b/src/content/docs/es/reference/errors/page-number-param-not-found.mdx
@@ -15,4 +15,4 @@ githubURL: https://github.com/withastro/astro/blob/main/packages/astro/src/core/
 El parámetro número de página no fue encontrado en su ruta de archivo.
 
 **Ver también**
--  [Paginación](/es/guides/routing/#paginación)
+-  [Paginación](/es/guides/routing/#pagination)
diff --git a/src/content/docs/es/reference/errors/prerender-client-address-not-available.mdx b/src/content/docs/es/reference/errors/prerender-client-address-not-available.mdx
index b8f05fa57d66a..7cd5183bc4868 100644
--- a/src/content/docs/es/reference/errors/prerender-client-address-not-available.mdx
+++ b/src/content/docs/es/reference/errors/prerender-client-address-not-available.mdx
@@ -13,6 +13,6 @@ La propiedad `Astro.clientAddress` no se puede usar dentro de rutas prerrenderiz
 
 **Ver también:**
 -  [Optando por la prerrenderización](/es/guides/on-demand-rendering/)
--  [Astro.clientAddress](/es/reference/api-reference/#astroclientaddress)
+-  [Astro.clientAddress](/es/reference/api-reference/#clientaddress)
 
 
diff --git a/src/content/docs/es/reference/errors/prerender-dynamic-endpoint-path-collide.mdx b/src/content/docs/es/reference/errors/prerender-dynamic-endpoint-path-collide.mdx
index 38f09b9126833..b933afc3c793b 100644
--- a/src/content/docs/es/reference/errors/prerender-dynamic-endpoint-path-collide.mdx
+++ b/src/content/docs/es/reference/errors/prerender-dynamic-endpoint-path-collide.mdx
@@ -12,5 +12,5 @@ El endpoint se prerrenderiza con un parámetro `undefined`, por lo que la ruta g
 Si no puedes evitar pasar `undefined`, entonces se puede agregar una extensión adicional al nombre del archivo endpoint para generar el archivo con un nombre diferente. Por ejemplo, renombrar `pages/api/[slug].ts` a `pages/api/[slug].json.ts`.
 
 **Ver también:**
--  [`getStaticPaths()`](/es/reference/api-reference/#getstaticpaths)
+-  [`getStaticPaths()`](/es/reference/routing-reference/#getstaticpaths)
 -  [`params`](/es/reference/api-reference/#params)
diff --git a/src/content/docs/es/reference/errors/redirect-with-no-location.mdx b/src/content/docs/es/reference/errors/redirect-with-no-location.mdx
index 6627ee43d93d0..f2fbc3a76496d 100644
--- a/src/content/docs/es/reference/errors/redirect-with-no-location.mdx
+++ b/src/content/docs/es/reference/errors/redirect-with-no-location.mdx
@@ -9,6 +9,6 @@ githubURL: https://github.com/withastro/astro/blob/main/packages/astro/src/core/
 Un redireccionamiento debe tener una ubicación con el encabezado `Location`.
 
 **Ver también:**
--  [Astro.redirect](/es/reference/api-reference/#astroredirect)
+-  [Astro.redirect](/es/reference/api-reference/#redirect)
 
 
diff --git a/src/content/docs/es/reference/errors/session-without-supported-adapter-output-error.mdx b/src/content/docs/es/reference/errors/session-without-supported-adapter-output-error.mdx
index 4360fd559e8b5..09ead7309615d 100644
--- a/src/content/docs/es/reference/errors/session-without-supported-adapter-output-error.mdx
+++ b/src/content/docs/es/reference/errors/session-without-supported-adapter-output-error.mdx
@@ -10,4 +10,4 @@ githubURL: https://github.com/withastro/astro/blob/main/packages/astro/src/core/
 Tu adaptador debe admitir la salida del servidor para usar sesiones.
 
 **See Also:**
--  [Característica del adaptador de salida del servidor](/es/reference/adapter-reference/#construyendo-un-adaptador)
\ No newline at end of file
+-  [Característica del adaptador de salida del servidor](/es/reference/adapter-reference/#building-an-adapter)
\ No newline at end of file
diff --git a/src/content/docs/es/reference/errors/static-client-address-not-available.mdx b/src/content/docs/es/reference/errors/static-client-address-not-available.mdx
index d67fb845a6c0c..f539f1e27a7d2 100644
--- a/src/content/docs/es/reference/errors/static-client-address-not-available.mdx
+++ b/src/content/docs/es/reference/errors/static-client-address-not-available.mdx
@@ -20,4 +20,4 @@ Para obtener la dirección IP del usuario en modo estático, se pueden usar dife
 **Ver también:**
 
 -  [Habilitando SSR en tu proyecto](/es/guides/on-demand-rendering/)
--  [Astro.clientAddress](/es/reference/api-reference/#astroclientaddress)
+-  [Astro.clientAddress](/es/reference/api-reference/#clientaddress)
diff --git a/src/content/docs/es/reference/errors/static-redirect-not-available.mdx b/src/content/docs/es/reference/errors/static-redirect-not-available.mdx
index cd27ed434f255..605b51b712db3 100644
--- a/src/content/docs/es/reference/errors/static-redirect-not-available.mdx
+++ b/src/content/docs/es/reference/errors/static-redirect-not-available.mdx
@@ -18,4 +18,4 @@ Para redirigir en un sitio web estático, se puede usar el [atributo meta de act
 
 **Ver también:**
 -  [Habilitando SSR en tu proyecto](/es/guides/on-demand-rendering/)
--  [Astro.redirect](/es/reference/api-reference/#astroredirect)
+-  [Astro.redirect](/es/reference/api-reference/#redirect)
diff --git a/src/content/docs/es/reference/experimental-flags/heading-id-compat.mdx b/src/content/docs/es/reference/experimental-flags/heading-id-compat.mdx
index 01f25422a4a2c..fd22af56b257f 100644
--- a/src/content/docs/es/reference/experimental-flags/heading-id-compat.mdx
+++ b/src/content/docs/es/reference/experimental-flags/heading-id-compat.mdx
@@ -53,7 +53,7 @@ En una futura versión principal, Astro cambiará para usar el estilo de ID comp
 
 ## Uso con el plugin `rehypeHeadingIds`
 
-Si estás [usando el plugin `rehypeHeadingIds` directamente](/es/guides/markdown-content/#ids-de-encabezados-y-plugins), opta por el modo de compatibilidad al pasar el plugin en tu configuración de Astro:
+Si estás [usando el plugin `rehypeHeadingIds` directamente](/es/guides/markdown-content/#heading-ids-and-plugins), opta por el modo de compatibilidad al pasar el plugin en tu configuración de Astro:
 
 ```js title="astro.config.mjs" {8}
 import { defineConfig } from 'astro/config';
diff --git a/src/content/docs/es/reference/image-service-reference.mdx b/src/content/docs/es/reference/image-service-reference.mdx
deleted file mode 100644
index b50fac6c3a4a6..0000000000000
--- a/src/content/docs/es/reference/image-service-reference.mdx
+++ /dev/null
@@ -1,257 +0,0 @@
----
-title: API de Servicio de Imágenes
-i18nReady: true
----
-import Since from '~/components/Since.astro';
-
-`astro:assets` fue diseñado para facilitar que cualquier servicio de optimización de imágenes construya un servicio sobre Astro.
-
-## ¿Qué es un Servicio de Imágenes?
-
-Astro proporciona dos tipos de servicios de imágenes: locales y externos.
-
-- **Los servicios locales** se encargan de las transformaciones de imágenes directamente en la compilación para sitios estáticos, o en tiempo de ejecución tanto en el modo de desarrollo como en SSR. Estos son a menudo envoltorios alrededor de bibliotecas como Sharp, ImageMagick o Squoosh. En el modo de desarrollo y en SSR, los servicios locales utilizan un endpoint de API para realizar la transformación.
-- **Los servicios externos** apuntan a URLs y pueden agregar soporte para servicios como Cloudinary, Vercel o cualquier servidor compatible con [RIAPI](https://github.com/riapi/riapi).
-
-## Construyendo con la API de Servicios de Imágenes
-
-Las definiciones de servicio toman la forma de un objeto exportado por defecto con varios métodos requeridos ("hooks")
-
-Los servicios externos proporcionan un `getURL()` que apunta al `src` de la etiqueta `<img>` de salida.
-
-Los servicios locales proporcionan un método `transform()` para realizar transformaciones en su imagen, y los métodos `getURL()` y `parseURL()` para utilizar un endpoint para el modo de desarrollo y SSR.
-
-Ambos tipos de serivicios pueden proporcionar `getHTMLAttributes()` para determinar los otros atributos de la salida `<img>` y `validateOptions()` para validar y aumentar las opciones pasadas.
-
-### Servicios Externos
-
-Un servicio externo apunta a una URL remota para ser usada como el atributo `src` de la etiqueta `<img>`. Esta URL remota es responsable de descargar, transformar y devolver la imagen.
-
-```js
-import type { ExternalImageService, ImageTransform, AstroConfig } from "astro";
-
-const service: ExternalImageService = {
-  validateOptions(options: ImageTransform, imageConfig: AstroConfig['image']) {
-    const serviceConfig = imageConfig.service.config;
-    // Aplica el ancho máximo establecido por el usuario.
-    if (options.width > serviceConfig.maxWidth) {
-      console.warn(`El ancho de la imagen ${options.width} excede el ancho máximo ${serviceConfig.maxWidth}. Se utilizará el ancho máximo como alternativa.`);
-      options.width = serviceConfig.maxWidth;
-    }
-
-    return options;
-  },
-  getURL(options, imageConfig) {
-    return `https://mysupercdn.com/${options.src}?q=${options.quality}&w=${options.width}&h=${options.height}`;
-  },
-  getHTMLAttributes(options, imageConfig) {
-    const { src, format, quality, ...attributes } = options;
-		return {
-			...attributes,
-			loading: options.loading ?? 'lazy',
-			decoding: options.decoding ?? 'async',
-		};
-	}
-};
-
-
-export default service;
-```
-
-### Servicios Locales
-
-Para crear tu propio servicio local, puedes apuntar al [endpoint integrado](https://github.com/withastro/astro/blob/main/packages/astro/src/assets/endpoint/generic.ts) (`/_image`) o puedes crear tu propio endpoint que pueda llamar a los métodos del servicio.
-
-```js
-import type { LocalImageService, AstroConfig } from "astro";
-
-const service: LocalImageService = {
-  getURL(options: ImageTransform, imageConfig: AstroConfig['image']) {
-    const searchParams = new URLSearchParams();
-		searchParams.append('href', typeof options.src === "string" ? options.src : options.src.src);
-		options.width && searchParams.append('w', options.width.toString());
-		options.height && searchParams.append('h', options.height.toString());
-		options.quality && searchParams.append('q', options.quality.toString());
-		options.format && searchParams.append('f', options.format);
-    return `/my_custom_endpoint_that_transforms_images?${searchParams}`;
-    // O usa el endpoint integrado, el cual llamará a tus funciones parseURL y transform:
-    // return `/_image?${searchParams}`;
-  },
-  parseURL(url: URL, imageConfig) {
-    return {
-      src: params.get('href')!,
-      width: params.has('w') ? parseInt(params.get('w')!) : undefined,
-      height: params.has('h') ? parseInt(params.get('h')!) : undefined,
-			format: params.get('f'),
-      quality: params.get('q'),
-    };
-  },
-  transform(buffer: Uint8Array, options: { src: string, [key: string]: any }, imageConfig): { data: Uint8Array, format: OutputFormat } {
-    const { buffer } = mySuperLibraryThatEncodesImages(options);
-    return {
-      data: buffer,
-      format: options.format,
-    };
-  },
-  getHTMLAttributes(options, imageConfig) {
-		let targetWidth = options.width;
-		let targetHeight = options.height;
-		if (typeof options.src === "object") {
-			const aspectRatio = options.src.width / options.src.height;
-
-			if (targetHeight && !targetWidth) {
-				targetWidth = Math.round(targetHeight * aspectRatio);
-			} else if (targetWidth && !targetHeight) {
-				targetHeight = Math.round(targetWidth / aspectRatio);
-			}
-		}
-
-		const { src, width, height, format, quality, ...attributes } = options;
-
-		return {
-			...attributes,
-			width: targetWidth,
-			height: targetHeight,
-			loading: attributes.loading ?? 'lazy',
-			decoding: attributes.decoding ?? 'async',
-		};
-	}
-};
-export default service;
-```
-
-En el tiempo de compilación para sitios estáticos y rutas pre-renderizadas, tanto `<Image />` como `getImage(options)` llaman a la función `transform()`. Pasan las opciones a través de los atributos del componente o un argumento `options`, respectivamente. Las imágenes transformadas se construirán en una carpeta `dist/_astro`.
-
-En el modo de desarrollo y el modo SSR, Astro no sabe de antemano qué imágenes deben ser optimizadas. Astro usa un endpoint GET (por defecto, `/_image`) para procesar las imágenes en tiempo de ejecución. `<Image />` y `getImage()` pasan sus opciones a `getURL()`, que devolverá la URL del endpoint. Luego, el endpoint llama a `parseURL()` y pasa las propiedades resultantes a `transform()`.
-
-#### getConfiguredImageService & imageConfig
-
-Si implementas tu propio endpoint como un endpoint de Astro, puedes usar `getConfiguredImageService` y `imageConfg` para llamar a los métodos `parseURL` y `transform` de tu servicio y proporcionar la configuración de la imagen.
-
-Para acceder a la configuración del servicio de imágenes ([`image.service.config`](/es/reference/configuration-reference/#imageservice)), puedes usar `imageConfig.service.config`.
-
-```ts title="src/api/my_custom_endpoint_that_transforms_images.ts"
-import type { APIRoute } from "astro";
-import { getConfiguredImageService, imageConfig } from 'astro:assets';
-
-export const GET: APIRoute = async ({ request }) => {
-  const imageService = await getConfiguredImageService();
-
-  const imageTransform = imageService.parseURL(new URL(request.url), imageConfig);
-  // ... busca la imagen de imageTransform.src y guárdala en inputBuffer
-  const { data, format } = await imageService.transform(inputBuffer, imageTransform, imageConfig);
-  return new Response(data, {
-			status: 200,
-			headers: {
-				'Content-Type': mime.getType(format) || ''
-      }
-    }
-  );
-}
-```
-
-[Mira el endpoint integrado](https://github.com/withastro/astro/blob/main/packages/astro/src/assets/endpoint/generic.ts) para un ejemplo completo.
-
-
-## Hooks
-
-### `getURL()`
-
-**Requerido para servicios locales y externos**
-
-`getURL(options: ImageTransform, imageConfig: AstroConfig['image']): string`
-
-Para servicios locales, este hook devuelve la URL del endpoint que genera tu imagen (en SSR y modo de desarrollo). No se usa durante la compilación. El endpoint local al que apunta `getURL()` puede llamar tanto a `parseURL()` como a `transform()`.
-
-Para servicios externos, este hook devuelve la URL final de la imagen.
-
-Para ambos tipos de servicios, `options` son las propiedades pasadas por el usuario como atributos del componente `<Image />` o como opciones a `getImage()`. Son del siguiente tipo:
-
-```ts
-export type ImageTransform = {
-    // Imágenes importadas ESM | rutas de imágenes remotas/públicas
-    src: ImageMetadata | string;
-    width?: number;
-    height?: number;
-    widths?: number[] | undefined;
-	  densities?: (number | `${number}x`)[] | undefined;
-    quality?: ImageQuality;
-    format?: OutputFormat;
-    alt?: string;
-    [key: string]: any;
-};
-```
-
-
-### `parseURL()`
-
-**Requerido para servicios locales; no disponible para servicios externos**
-
-`parseURL(url: URL, imageConfig: AstroConfig['image']): { src: string, [key: string]: any}`
-
-Este hook analiza las URL generadas por `getURL()` en un objeto con las diferentes propiedades que se utilizarán en `transform` (en SSR y modo de desarrollo). No se usa durante la compilación.
-
-### `transform()`
-
-**Requerido para servicios locales; no disponible para servicios externos**
-
-`transform(buffer: Uint8Array, options: { src: string, [key: string]: any }, imageConfig: AstroConfig['image']): { data: Uint8Array, format: OutputFormat }`
-
-Este hook transforma y devuelve la imagen y se llama durante la compilación para crear los archivos de activos finales.
-
-Debes devolver un `format` para asegurarte de que se sirve el tipo MIME adecuado a los usuarios en el modo SSR y de desarrollo.
-
-### `getHTMLAttributes()`
-
-**Opcional para ambos servicios locales y externos**
-
-`getHTMLAttributes(options: ImageTransform, imageConfig: AstroConfig['image']): Record<string, any>`
-
-Este hook devuelve todos los atributos adicionales utilizados para renderizar la imagen como HTML, basados en los parámetros pasados por el usuario (`options`).
-
-### `getSrcSet()`
-<p><Since v="3.3.0" /></p>
-
-**Opcional tanto para servicios locales como externos.**
-
-`getSrcSet?: (options: ImageTransform, imageConfig: AstroConfig['image']): SrcSetValue[] | Promise<SrcSetValue[]>;`
-
-Este hook genera múltiples variantes de la imagen especificada, por ejemplo, para crear un atributo `srcset` en un elemento `<img>` o el `source` de un `<picture>`.
-Este hook devuelve un array de objetos con las siguientes propiedades:
-```ts
-export type SrcSetValue = {
-	transform: ImageTransform;
-	descriptor?: string;
-	attributes?: Record<string, any>;
-};
-```
-
-### `validateOptions()`
-
-**Opcional para ambos servicios locales y externos**
-
-`validateOptions(options: ImageTransform, imageConfig: AstroConfig['image']): ImageTransform`
-
-Este hook te permite validar y aumentar las opciones pasadas por el usuario. Esto es útil para establecer opciones predeterminadas, o para decirle al usuario que un parámetro es obligatorio.
-
-[Mira como `validateOptions()` se usa en los servicios integrados de Astro](https://github.com/withastro/astro/blob/0ab6bad7dffd413c975ab00e545f8bc150f6a92f/packages/astro/src/assets/services/service.ts#L124).
-
-## Configuración de usuario
-
-Configura el servicio de imágenes que se utilizará en `astro.config.mjs`. La configuración toma la siguiente forma:
-
-
-```js title="astro.config.mjs"
-import { defineConfig } from "astro/config";
-
-export default defineConfig({
-  image: {
-    service: {
-      entrypoint: "tu-punto-de-entrada", // 'astro/assets/services/squoosh' | 'astro/assets/services/sharp' | string,
-      config: {
-        // ... servicio específico de configuración. Opcional.
-      }
-    }
-  },
-});
-```
diff --git a/src/content/docs/es/reference/integrations-reference.mdx b/src/content/docs/es/reference/integrations-reference.mdx
deleted file mode 100644
index c9eeeef4f4601..0000000000000
--- a/src/content/docs/es/reference/integrations-reference.mdx
+++ /dev/null
@@ -1,726 +0,0 @@
----
-title: APIs de integraciones de Astro
-i18nReady: true
----
-import Since from '~/components/Since.astro'
-
-Las **integraciones de Astro** agregan nuevas funcionalidades y comportamientos para tu proyecto con unas pocas líneas de código.
-
-Esta página de referencia es para cualquiera que escriba una integración. Para aprender a usar una integración en tu proyecto, consulta nuestra guía de [uso de integraciones](/es/guides/integrations-guide/).
-
-## Ejemplos
-
-Las integraciones oficiales de Astro pueden actuar como referencia para ti a medida que avanzas para crear tus propias integraciones.
-
-- **Renderizadores:** [`lit`](/es/guides/integrations-guide/lit/), [`svelte`](/es/guides/integrations-guide/svelte/), [`react`](/es/guides/integrations-guide/react/), [`preact`](/es/guides/integrations-guide/preact/), [`vue`](/es/guides/integrations-guide/vue/), [`solid`](/es/guides/integrations-guide/solid-js/)
-- **Librerías:** [`tailwind`](/es/guides/integrations-guide/tailwind/), [`partytown`](/es/guides/integrations-guide/partytown/)
-- **Funcionalidades:** [`sitemap`](/es/guides/integrations-guide/sitemap/)
-
-## Referencia rápida de la API
-
-```ts
-interface AstroIntegration {
-  name: string;
-  hooks: {
-    'astro:config:setup'?: (options: {
-      config: AstroConfig;
-      command: 'dev' | 'build' | 'preview';
-      isRestart: boolean;
-      updateConfig: (newConfig: Record<string, any>) => void;
-      addRenderer: (renderer: AstroRenderer) => void;
-      addWatchFile: (path: URL | string) => void;
-      addClientDirective: (directive: ClientDirectiveConfig) => void;
-      addMiddleware: (middleware: AstroIntegrationMiddleware) => void;
-      addDevToolbarApp: (pluginEntrypoint: string) => void;
-      injectScript: (stage: InjectedScriptStage, content: string) => void;
-      injectRoute: ({ pattern: string, entrypoint: string }) => void;
-      logger: AstroIntegrationLogger;
-    }) => void;
-    'astro:config:done'?: (options: { config: AstroConfig; setAdapter: (adapter: AstroAdapter) => void; logger: AstroIntegrationLogger; }) => void | Promise<void>;
-    'astro:server:setup'?: (options: { server: vite.ViteDevServer; logger: AstroIntegrationLogger; }) => void | Promise<void>;
-    'astro:server:start'?: (options: { address: AddressInfo; logger: AstroIntegrationLogger; }) => void | Promise<void>;
-    'astro:server:done'?: (options: { logger: AstroIntegrationLogger; }) => void | Promise<void>;
-    'astro:build:start'?: (options: { logger: AstroIntegrationLogger; }) => void | Promise<void>;
-    'astro:build:setup'?: (options: {
-      vite: ViteConfigWithSSR;
-      pages: Map<string, PageBuildData>;
-      target: 'client' | 'server';
-      logger: AstroIntegrationLogger;
-    }) => void | Promise<void>;
-    'astro:build:generated'?: (options: { dir: URL; logger: AstroIntegrationLogger; }) => void | Promise<void>;
-    'astro:build:ssr'?: (options: {
-        manifest: SerializedSSRManifestm;
-        entryPoints: Map<RouteData, URL>;
-        logger: AstroIntegrationLogger;
-    }) => void | Promise<void>;
-    'astro:build:done'?: (options: { dir: URL; routes: RouteData[]; logger: AstroIntegrationLogger; }) => void | Promise<void>;
-  };
-}
-```
-
-## Hooks
-
-### `astro:config:setup`
-
-**Siguiente hook:** [`astro:config:done`](#astroconfigdone)
-
-**Cuando:** En la inicialización, antes de que [Vite](https://vite.dev/config/) o [Astro config](/es/reference/configuration-reference/) se hayan resuelto.
-
-**Por qué:** Para ampliar la configuración del proyecto. Esto incluye actualizar [Astro config](/es/reference/configuration-reference/), aplicar [plugins de Vite](https://vite.dev/guide/api-plugin.html), agregar renderizadores de componentes e inyectar scripts en la página.
-
-```ts
-'astro:config:setup'?: (options: {
-  config: AstroConfig;
-  command: 'dev' | 'build' | 'preview';
-  isRestart: boolean;
-  updateConfig: (newConfig: Record<string, any>) => void;
-  addRenderer: (renderer: AstroRenderer) => void;
-  addClientDirective: (directive: ClientDirectiveConfig) => void;
-  addMiddleware: (middleware: AstroIntegrationMiddleware) => void;
-  addDevToolbarApp: (pluginEntrypoint: string) => void;
-  addWatchFile: (path: URL | string) => void;
-  injectScript: (stage: InjectedScriptStage, content: string) => void;
-  injectRoute: ({ pattern: string, entrypoint: string }) => void;
-  logger: AstroIntegrationLogger;
-}) => void;
-```
-
-#### Opción `config`
-
-**Tipo:** `AstroConfig`
-
-Una copia de solo lectura de la [Astro config](/es/reference/configuration-reference/) proporcionada por el usuario. Esto se resuelve _antes_ de que se haya ejecutado cualquier otra integración. Si necesitas una copia de la configuración luego de que todas las integraciones hayan completado sus actualizaciones de configuración, puedes ver [el hook `astro:config:done`](#astroconfigdone).
-
-#### Opción `command`
-
-**Tipo:** `'dev' | 'build' | 'preview'`
-
-- `dev` - El proyecto se ejecuta con `astro dev`
-- `build` - El proyecto se ejecuta con `astro build`
-- `preview` - El proyecto se ejecuta con `astro preview`
-
-#### Opción `isRestart`
-
-**Tipo:** `boolean`
-
-`false` cuando se inicia el servidor de desarrollo, `true` cuando se provoca una recarga. Es útil para detectar si se llama a esta función más de una vez.
-
-#### Opción `updateConfig`
-
-**Tipo:** `(newConfig: Record<string, any>) => void;`
-
-Una función callback para actualizar la [Astro config](/es/reference/configuration-reference/) proporcionada por el usuario. Cualquier configuración que proporciones **se fusionará con la configuración de usuario + otras actualizaciones de configuración de integración,** ¡así que puedes omitir claves!
-
-Por ejemplo, supongamos que necesitas proporcionar un plugin de [Vite](https://vite.dev/) al proyecto del usuario:
-
-```js
-import bananaCSS from '@vitejs/official-banana-css-plugin';
-
-export default {
-  name: 'banana-css-integration',
-  hooks: {
-    'astro:config:setup': ({ updateConfig }) => {
-      updateConfig({
-        vite: {
-          plugins: [bananaCSS()],
-        }
-      })
-    }
-  }
-}
-```
-
-#### Opción `addRenderer`
-
-**Tipo:** `(renderer:` [`AstroRenderer`](https://github.com/withastro/astro/blob/fdd607c5755034edf262e7b275732519328a33b2/packages/astro/src/%40types/astro.ts#L872-L883) `) => void;`
-**Ejemplos:** [`lit`](https://github.com/withastro/astro/blob/main/packages/integrations/lit/src/index.ts), [`svelte`](https://github.com/withastro/astro/blob/main/packages/integrations/svelte/src/index.ts), [`react`](https://github.com/withastro/astro/blob/main/packages/integrations/react/src/index.ts), [`preact`](https://github.com/withastro/astro/blob/main/packages/integrations/preact/src/index.ts), [`vue`](https://github.com/withastro/astro/blob/main/packages/integrations/vue/src/index.ts), [`solid`](https://github.com/withastro/astro/blob/main/packages/integrations/solid/src/index.ts)
-
-Una función callback para agregar un renderizador de framework (como React, Vue, Svelte, etc.). Puedes explorar los ejemplos y definiciones anteriores para obtener opciones más avanzadas, pero las 2 opciones principales que debes tener en cuenta son:
-
-- `clientEntrypoint` - ruta a un archivo que se ejecuta en el cliente cada vez que el componente es usado. Esto es principalmente para renderizar o hidratar tu componente con JS.
-- `serverEntrypoint` - ruta a un archivo que se ejecuta durante las solicitudes al servidor o las compilaciones estáticas cada vez que el componente es usado. Estos deben renderizar componentes a un marcado estático, con hooks para la hidratarlos cuando corresponda. [`renderToString` de React](https://react.dev/reference/react-dom/server/renderToString) es un ejemplo clásico.
-
-#### Opción `addWatchFile`
-
-**Tipo:** `URL | string`
-
-Si tu integración depende de un archivo de configuración que no es vigilado por Vite y/o necesita un reinicio total de servidor para surtir efecto, agrégalo en `addWatchFile`. Cada vez que haya cambios en ese archivo, el servidor de desarrollo de Astro se reiniciará (puedes comprobar cuando ocurre un reinicio con `isRestart`).
-
-Ejemplo de uso:
-
-```js
-// ¡Debe ser una ruta absoluta!
-addWatchFile('/home/user/.../my-config.json');
-addWatchFile(new URL('./tailwind.config.js', config.root));
-```
-
-#### Opción `addClientDirective`
-
-<Since v="2.6.0" />
-
-**Tipo:** `(directive:` [`ClientDirectiveConfig`](https://github.com/withastro/astro/blob/00327c213f74627ac9ca1dec774efa5bf71e9375/packages/astro/src/%40types/astro.ts#L1872-L1875) `) => void;`
-
-Añade una [directiva de cliente personalizada](/es/reference/directives-reference/#directivas-de-cliente-personalizadas) para utilizarla en los archivos `.astro`.
-
-Ten en cuenta que los puntos de entrada de las directivas solo se incluyen en el paquete a través de esbuild y se deben mantener pequeños para no ralentizar la hidratación del componente.
-
-Ejemplo de uso:
-
-```js title="astro.config.mjs"
-import { defineConfig } from 'astro/config';
-import clickDirective from './astro-click-directive/register.js'
-
-// https://astro.build/config
-export default defineConfig({
-  integrations: [
-    clickDirective()
-  ],
-});
-```
-
-```js title="astro-click-directive/register.js"
-/**
- * @type {() => import('astro').AstroIntegration}
- */
-export default () => ({
-  name: "client:click",
-  hooks: {
-    "astro:config:setup": ({ addClientDirective }) => {
-      addClientDirective({
-        name: "click",
-        entrypoint: "./astro-click-directive/click.js",
-      });
-    },
-  },
-});
-```
-
-```js title="directiva-clic-de-astro/clic.js"
-/**
- * Hidratar al hacer el primer click en la ventana
- * @type {import('astro').ClientDirective}
- */
-export default (load, opts, el) => {
-  window.addEventListener('click', async () => {
-    const hydrate = await load()
-    await hydrate()
-  }, { once: true })
-}
-```
-
-También puedes añadir tipos para las directivas en el archivo de definición de tipos de tu biblioteca:
-
-```ts title="directiva-clic-de-astro/index.d.ts"
-declare module 'astro' {
-  interface AstroClientDirectives {
-    'client:click'?: boolean
-  }
-}
-```
-
-#### Opción `addDevToolbarApp`
-
-<p><Since v="3.4.0" /></p>
-
-**Tipo:** `(pluginEntrypoint: string) => void;`
-
-Agrega una [app personalizada de barra de herramientas para desarrolladores](/es/reference/dev-toolbar-app-reference/).
-
-Ejemplo de uso:
-
-```js title="astro.config.mjs"
-import { defineConfig } from 'astro/config';
-import devToolbarIntegration from './astro-dev-toolbar-app/integration.js'
-
-// https://astro.build/config
-export default defineConfig({
-  integrations: [
-    devToolbarIntegration()
-  ],
-});
-```
-
-```js title="astro-dev-toolbar-app/integration.js"
-/**
- * @type {() => import('astro').AstroIntegration}
- */
-export default () => ({
-  name: "dev-toolbar-app",
-  hooks: {
-    "astro:config:setup": ({ addDevToolbarApp }) => {
-      addDevToolbarApp("./astro-dev-toolbar-app/plugin.js");
-    },
-  },
-});
-```
-
-```js title="astro-dev-toolbar-app/plugin.js"
-
-/**
- * @type {import('astro').DevToolbarApp}
- */
-export default {
-  id: "my-plugin",
-  name: "My Plugin",
-  icon: "<svg>...</svg>",
-  init() {
-    console.log("¡Soy una app de barra de herramientas para desarrolladores!")
-  },
-};
-```
-
-#### Opción `addMiddleware`
-
-<p><Since v="3.5.0" /></p>
-
-**Tipo:** `(middleware:` [`AstroIntegrationMiddleware`](https://github.com/withastro/astro/blob/852ac0f75dfca1b2602e9cdbfa0447d9998e2449/packages/astro/src/%40types/astro.ts#L2124-L2127) `) => void;`
-
-Agrega un [middleware](/es/guides/middleware/) para ejecutar en cada solicitud. Toma el módulo `entrypoint` que contiene el middleware, y un `order` para especificar si debe ejecutarse antes (`pre`) de otro middleware o después (`post`).
-
-```js title="@my-package/integration.js"
-/**
- * @type {() => import('astro').AstroIntegration}
- */
-export default () => ({
-  name: "my-middleware-package",
-  hooks: {
-    "astro:config:setup": ({ addMiddleware }) => {
-        addMiddleware({
-          entrypoint: '@my-package/middleware',
-          order: 'pre'
-        });
-    },
-  },
-});
-```
-
-Un middleware es definido en un paquete con una función `onRequest`, como con el middleware definido por el usuario.
-
-```js title="@my-package/middleware.js"
-import { defineMiddleware } from 'astro:middleware';
-
-export const onRequest = defineMiddleware(async (context, request) => {
-  if(context.url.pathname === '/some-test-path') {
-    return Response.json({
-      ok: true
-    });
-  }
-});
-```
-
-#### Opción `injectRoute`
-
-**Tipo:** `({ pattern: string, entrypoint: string }) => void;`
-
-Una función callback para inyectar rutas a un proyecto de Astro. Las rutas inyectadas pueden ser [páginas `.astro`](/es/basics/astro-pages/) o [controladores de ruta `.js` y `.ts`](/es/guides/endpoints/#endpoints-de-archivos-estáticos).
-
-`injectRoute` toma un objeto con un `pattern` y un `entrypoint`.
-
-- `pattern` - es la ruta en el navegador, por ejemplo `/foo/bar`. Un `pattern` puede usar la sintaxis de ruta de archivo de Astro para indicar rutas dinámicas, por ejemplo `/foo/[bar]` o `/foo/[...bar]`. Ten en cuenta que **no** se necesita una extensión de archivo en el `patrón`.
-- `entrypoint` - un especificador de módulo simple que apunta hacia la página `.astro` o el controlador de ruta `.js`/`.ts` que maneja la ruta indicada en el `pattern`.
-
-##### Ejemplo de uso
-
-```js
-injectRoute({
-  // Utiliza la sintaxis de patrón de Astro para rutas dinámicas.
-  pattern: '/subfolder/[dynamic]',
-  // Utiliza la sintaxis de ruta relativa para una ruta local.
-  entrypoint: './src/dynamic-page.astro'
-});
-```
-
-Para una integración diseñada para ser instalada en otros proyectos, utiliza su nombre de paquete para referirse al punto de entrada de la ruta.
-El siguiente ejemplo muestra un paquete publicado en npm como `@fancy/dashboard` inyectando una ruta de panel:
-
-```js
-injectRoute({
-  pattern: '/fancy-dashboard',
-  entrypoint: '@fancy/dashboard/dashboard.astro'
-});
-```
-
-Cuando publiques tu paquete (`@fancy/dashboard`, en este caso) en npm, debes exportar `dashboard.astro` en tu `package.json`:
-
-```json title="package.json" "exports"
-{
-  "name": "@fancy/dashboard",
-  // ...
-  "exports": { "./dashboard.astro": "./dashboard.astro" }`
-}
-```
-
-#### Opción `injectScript`
-
-**Tipo:** `(stage: InjectedScriptStage, content: string) => void;`
-
-Una función de callback para inyectar una cadena de contenido de JavaScript en cada página.
-
-El **`stage`** indica cómo debe insertarse este script (el `content`). Algunas etapas permiten insertar scripts sin modificaciones, mientras que otras permiten la optimización durante [el paso de empaquetado de Vite](https://vite.dev/guide/build.html):
-
-- `"head-inline"`: Inyectado en una etiqueta de script en el `<head>` de cada página. **No** optimizado o resuelto por Vite.
-- `"before-hydration"`: Importado del lado del cliente, antes de que se ejecute el script de hidratación. Optimizado y resuelto por Vite.
-- `"page"`: Similar a `head-inline`, excepto que Vite maneja el fragmento inyectado y lo incluye con cualquier otra etiqueta `<script>` definida dentro de los componentes de Astro en la página. El script se cargará con `<script type="module">` en la salida de la página final, optimizado y resuelto por Vite.
-- `"page-ssr"`: Importado como un módulo separado en el frontmatter de cada componente de página de Astro. Debido a que esta etapa importa el script, el objeto global `Astro` no está disponible y el script solo se ejecutará una vez, cuando el `import` se evalúe por primera vez.
-
-    El uso principal de la etapa `page-ssr` es inyectar un `import` de CSS en cada página para que Vite la optimice y la resuelva:
-     ```js
-     injectScript('page-ssr', 'import "global-styles.css";');
-     ```
-
-### `astro:config:done`
-
-**Hook anterior:** [`astro:config:setup`](#astroconfigsetup)
-
-**Siguiente hook:** [`astro:server:setup`](#astroserversetup) cuando se ejecuta en modo "dev", y [`astro:build:start`](#astrobuildstart) durante las compilaciones de producción
-
-**Cuándo:** Después que la configuración de Astro se haya resuelto y otras integraciones hayan ejecutado sus hooks `astro:config:setup`.
-
-**Por qué:** Obtener la configuración final para usarla en otros hooks.
-
-```js
-'astro:config:done'?: (options: { config: AstroConfig }) => void | Promise<void>;
-```
-
-#### Opción `config`
-
-**Tipo:** `AstroConfig`
-
-Una copia de solo lectura de [Astro config](/es/reference/configuration-reference/) proporcionada por el usuario. Esto se resuelve _después_ de que se hayan ejecutado otras integraciones.
-
-### `astro:server:setup`
-
-**Hook anterior:** [`astro:config:done`](#astroconfigdone)
-
-**Siguiente hook:** [`astro:server:start`](#astroserverstart)
-
-**Cuándo:** Justo después de que se crea el servidor Vite en modo "dev", pero antes de que se dispare el evento `listen()`. [Consulta la API createServer de Vite](https://vite.dev/guide/api-javascript.html#createserver) para obtener más información.
-
-**Por qué:** Para actualizar las opciones del servidor de Vite y el middleware.
-
-```js
-'astro:server:setup'?: (options: { server: vite.ViteDevServer }) => void | Promise<void>;
-```
-
-#### Opción `server`
-
-**Tipo:** [`ViteDevServer`](https://vite.dev/guide/api-javascript.html#vitedevserver)
-
-Una instancia mutable del servidor de Vite utilizada en modo "dev". Por ejemplo, esto es [utilizado por nuestra integración Partytown](/es/guides/integrations-guide/partytown/) para inyectar el servidor Partytown como middleware:
-
-```js
-export default {
-  name: 'partytown',
-  hooks: {
-    'astro:server:setup': ({ server }) => {
-      server.middlewares.use(
-        function middleware(req, res, next) {
-          // procesa aquí las requests
-        }
-      );
-    }
-  }
-}
-```
-
-### `astro:server:start`
-
-**Hook anterior:** [`astro:server:setup`](#astroserversetup)
-
-**Siguiente hook:** [`astro:servidor:hecho`](#astroserverdone)
-
-**Cuándo:** Justo después de que se haya disparado el evento `listen()` del servidor.
-
-**Por qué:** Para interceptar solicitudes de red en la dirección especificada. Si tienes la intención de usar esta dirección para el middleware, considera usar `astro:server:setup` en su lugar.
-
-```js
-'astro:server:start'?: (options: { address: AddressInfo }) => void | Promise<void>;
-```
-
-#### Opción `address`
-
-**Tipo:** [`AddressInfo`](https://microsoft.github.io/PowerBI-JavaScript/interfaces/_node_modules__types_node_net_d_._net_.addressinfo.html)
-
-La dirección, familia y número de puerto proporcionados por el [módulo Node.js Net](https://nodejs.org/api/net.html).
-
-### `astro:server:done`
-
-**Hook anterior:** [`astro:server:start`](#astroserverstart)
-
-**Cuándo:** Justo después de que se cierre el servidor de desarrollo.
-
-**Por qué:** Para ejecutar cualquier evento de limpieza, ejecutados durante los hooks `astro:server:setup` o `astro:server:start`.
-
-```js
-'astro:server:done'?: () => void | Promise<void>;
-```
-
-### `astro:build:start`
-
-**Hook anterior:** [`astro:config:done`](#astroconfigdone)
-
-**Siguiente hook:** [`astro:build:setup`](#astrobuildsetup)
-
-**Cuándo:** Después del evento `astro:config:done`, pero antes de que comience la compilación de producción.
-
-**Por qué:** Para configurar cualquier objeto global o cliente necesario durante la compilación a producción. Esto también puede ampliar las opciones de configuración de compilación de la [API del adaptador](/es/reference/adapter-reference/).
-
-```js
-'astro:build:start'?: () => void | Promise<void>;
-```
-
-### `astro:build:setup`
-
-**Hook anterior:** [`astro:build:start`](#astrobuildstart)
-
-**Siguiente hook:** [`astro:build:ssr`](#astrobuildssr)
-
-**Cuando:** Después del hook `astro:build:start`, se ejecuta inmediatamente antes de la compilación.
-
-**Por qué:** En este punto, la configuración de Vite para la compilación se ha construido por completo, esta es tu última oportunidad para modificarla. Esto puede ser útil, por ejemplo, para sobreescribir algunos valores predeterminados. Si no estás seguro de si debes usar este hook o `astro:build:start`, usa `astro:build:start` en su lugar.
-
-```js
-'astro:build:setup'?: (options: {
-  vite: ViteConfigWithSSR;
-  pages: Map<string, PageBuildData>;
-  target: 'client' | 'server';
-}) => void | Promise<void>;
-
-```
-
-### `astro:build:generated`
-
-**Hook anterior** [`astro:build:setup`](#astrobuildsetup)
-
-**Cuándo:** Después de que la compilación a producción haya terminado de generar las rutas y los demás recursos.
-
-**Por qué:** Para acceder a rutas y recursos generados **antes** que los artefactos de la compilación sean limpiados. Este es un caso muy poco común. Recomendamos usar [`astro:build:done`](#astrobuilddone) a menos que realmente necesites acceder a los archivos generados antes de que éstos sean limpiados.
-
-```js
-'astro:build:generated'?: (options: { dir: URL }) => void | Promise<void>;
-```
-
-### `astro:build:ssr`
-
-**Hook anterior:** [`astro:build:setup`](#astrobuildsetup)
-
-**Cuándo:** después que se completa la compilación de producción SSR.
-
-**Por qué:** Para acceder al manifiesto SSR y al mapeo de los puntos de entrada emitidos. Esto es útil al crear compilaciones SSR personalizadas en plugins o integraciones.
-
-- `entryPoints` mapea una ruta de página al archivo físico emitido después de la compilación;
-- `middlewareEntryPoint` es la ruta del sistema de archivos del archivo de middleware;
-
-```js
-'astro:build:ssr'?: (options: {
-    manifest: SerializedSSRManifest,
-    entryPoints: Map<RouteData, URL>,
-    middlewareEntryPoint: URL
-}) => void | Promise<void>;
-```
-
-### `astro:build:done`
-
-**Hook anterior:** [`astro:build:ssr`](#astrobuildssr)
-
-**Cuándo:** después de que se haya completado la compilación a producción (SSG o SSR).
-
-**Por qué:** Para acceder a rutas y recursos generados para extensión (por ejemplo, copiar contenido en la carpeta `/assets` generado). Si planeas transformar los recursos generados, te recomendamos explorar la [API de plugin de Vite](https://vite.dev/guide/api-plugin.html) y [la configuración a través de `astro:config:setup`](#opción-updateconfig) en su lugar.
-
-```js
-'astro:build:done'?: (options: { dir: URL; routes: RouteData[], pages: { pathname: string }[] }) => void | Promise<void>;
-```
-
-#### Opción `dir`
-
-**Tipo:** [`URL`](https://developer.mozilla.org/en-US/docs/Web/API/URL)
-
-La ruta URL a la carpeta de compilación. Ten en cuenta que si necesitas una ruta absoluta válida como string, debes usar la utilidad [`fileURLToPath`](https://nodejs.org/api/url.html#urlfileurltopathurl) integrada de Node.
-
-```js
-import { writeFile } from 'node:fs/promises';
-import { fileURLToPath } from 'node:url';
-
-export default function myIntegration() {
-  return {
-    hooks: {
-      'astro:build:done': async ({ dir }) => {
-        const metadata = await getIntegrationMetadata();
-        // Usa fileURLToPath para obtener una ruta absoluta multiplataforma válida como string
-        const outFile = fileURLToPath(new URL('./my-integration.json', dir));
-        await fs.writeFile(outFile, JSON.stringify(metadata));
-      }
-    }
-  }
-}
-```
-
-#### Opción `routes`
-
-**Tipo:** [`RouteData[]`](#referencia-del-tipo-routedata)
-
-Una lista de todas las rutas generadas junto con sus metadatos asociados.
-
-Puedes consultar la referencia completa del tipo `RouteData` a continuación, pero las propiedades más comunes son:
-
-- `component` - la ruta del archivo de entrada relativa a la raíz del proyecto
-- `pathname` - la URL del archivo de salida (indefinido para rutas que usan parámetros `[dynamic]` y `[...spread]`)
-
-##### Referencia del tipo `RouteData`
-
-```ts
-interface RouteData {
-  /** Si una ruta es una página HTML o un endpoint no HTML */
-  type: 'page' | 'endpoint';
-  /** URL del componente */
-  component: string;
-  /**
-    * URL donde se servirá esta ruta
-    * nota: será undefined para las rutas [dynamic] y [...spread]
-   */
-  pathname?: string;
-  /**
-    * Expresión regular utilizada para hacer coincidir una URL de entrada con una ruta solicitada
-    * Por ejemplo, "[fruit]/about.astro" generará el pattern: /^\/([^/]+?)\/about\/?$/
-    * donde pattern.test("banana/about") es "true"
-   */
-  pattern: RegExp;
-  /**
-    * Parámetros de rutas dinámicas y spread
-    * Por ejemplo, "/pages/[lang]/[..slug].astro" generará los parámetros ['lang', '...slug']
-   */
-  params: string[];
-  /**
-   * Similar al campo "params", pero con más metadatos asociados
-    * Por ejemplo, "/pages/[lang]/index.astro" generará los segmentos
-    * [[ { content: 'lang', dynamic: true, spread: false } ]]
-   */
-  segments: { content: string; dynamic: boolean; spread: boolean; }[][];
-  /**
-    * Función para renderizar un componente en un lugar a partir de un conjunto de inputs.
-    * Esto es típicamente para uso interno, ¡así que úsalo con precaución!
-   */
-  generate: (data?: any) => string;
-}
-```
-
-#### Opción `pages`
-
-**Tipo:** `{ pathname: string }[]`
-
-Una lista de todas las páginas generadas. Es un objeto con una propiedad.
-
-- `pathname` - la ruta final de la página.
-
-
-## Permitir la instalación con `astro add`
-
-[El comando `astro add`](/es/reference/cli-reference/#astro-add) permite a los usuarios agregar fácilmente integraciones y adaptadores a su proyecto. Si deseas que _tu_ integración se pueda instalar con esta herramienta, **agrega `astro-integration` al campo `keywords` en el `package.json` de la integración**:
-
-```json
-{
-  "name": "example",
-  "keywords": ["astro-integration"],
-}
-```
-
-Una vez que [publiques tu integración en npm](https://docs.npmjs.com/cli/v8/commands/npm-publish), ejecutar `astro add example` instalará tu paquete con cualquier dependencia peer especificada en tu `package .json`. Esto también aplicará tu integración al `astro.config` del usuario así:
-
-```diff
-// astro.config.mjs
-import { defineConfig } from 'astro/config';
-+ import example from 'example';
-
-export default defineConfig({
-+  integrations: [example()],
-})
-```
-
-:::caution
-Esto supone que la definición de la integración es 1) una exportación `default` y 2) una función. ¡Asegúrate de que esto sea cierto antes de agregar la palabra clave `astro-integration`!
-:::
-
-## `AstroIntegrationLogger`
-
-Una instancia del logger de Astro, útil para escribir registros. Este logger utiliza el mismo [nivel de registro](/es/reference/cli-reference/#--verbose)
-configurado a través de la CLI.
-
-**Métodos disponibles** para escribir en la terminal:
-- `logger.info("Mensaje")`;
-- `logger.warn("Mensaje")`;
-- `logger.error("Mensaje")`;
-- `logger.debug("Mensaje")`;
-
-Todos los mensajes son precedidos por una etiqueta que tiene el mismo valor de la integración.
-
-```ts title="integration.ts" {8}
-import type { AstroIntegration } from "astro";
-export function formatIntegration(): AstroIntegration {
-    return {
-        name: "astro-format",
-        hooks: {
-            "astro:build:done": ({ logger }) => {
-                // hacer algo
-                logger.info("Integration ready.");
-            }
-        }
-    }
-}
-```
-
-El ejemplo anterior registrará un mensaje que incluye el mensaje `info` proporcionado:
-
-```shell
-[astro-format] Integration ready.
-```
-
-Para registrar algunos mensajes con una etiqueta diferente, utiliza el método `.fork` para especificar una alternativa al `nombre` predeterminado:
-
-```ts title="integration.ts" ".fork"
-import type { AstroIntegration } from "astro";
-export function formatIntegration(): AstroIntegration {
-    return {
-        name: "astro-format",
-        hooks: {
-            "astro:config:done": ({ logger }) => {
-                // hacer algo
-                logger.info("Integration ready.");
-            },
-            "astro:build:done": ({ logger }) => {
-                const buildLogger = logger.fork("astro-format/build");
-                // hacer algo
-                buildLogger.info("Build finished.")
-            }
-        }
-    }
-}
-```
-
-El ejemplo anterior generará registros con `[astro-format]` de forma predeterminada, y con `[astro-format/build]` cuando se especifique:
-
-```shell
-[astro-format] Integration ready.
-[astro-format/build] Build finished.
-```
-
-## Orden de integración
-
-Todas las integraciones se ejecutan en el orden en que están configuradas. Por ejemplo, para el array `[react(), svelte()]` en `astro.config.*` de un usuario, `react` se ejecutará antes que `svelte`.
-
-Idealmente, la integración debería ejecutarse en cualquier orden. Si esto no es posible, recomendamos documentar que su integración debe ser la primera o la última en el array `integrations` de la configuración del usuario.
-
-## Combinar integraciones en presets
-
-Una integración también puede ser escrita como una colección de múltiples integraciones más pequeñas. Llamamos a estas colecciones **presets.** En lugar de crear una función que devuelve un solo objeto de integración, un preset devuelve una _array_ de objetos de integración. Esto es útil para crear características complejas a partir de múltiples integraciones.
-
-```js
-integrations: [
-  // Ejemplo: donde examplePreset() devuelve: [integrationOne, integrationTwo, ...etc]
-  examplePreset()
-]
-```
-
-## Recursos de la Comunidad
-
-- [Crea tus propias integraciones de Astro](https://www.freecodecamp.org/news/how-to-use-the-astro-ui-framework/#chapter-8-build-your-own-astro-integrations-1) - por Emmanuel Ohans en FreeCodeCamp
-- [Plantilla de Integración de Astro](https://github.com/florian-lefebvre/astro-integration-template) - por Florian Lefebvre en GitHub
diff --git a/src/content/docs/es/reference/modules/astro-assets.mdx b/src/content/docs/es/reference/modules/astro-assets.mdx
index db62c206f7800..9a67c67447b6a 100644
--- a/src/content/docs/es/reference/modules/astro-assets.mdx
+++ b/src/content/docs/es/reference/modules/astro-assets.mdx
@@ -69,7 +69,7 @@ El componente `<Image />` acepta las siguientes propiedades listadas y las [prop
 
 El formato del valor `src` de tu archivo de imagen depende de dónde se encuentre tu archivo de imagen:
 
-- **Imágenes locales en `src/`**: debes **importar también la imagen** usando una ruta relativa del archivo o configurar y usar un [alias de importación](/es/guides/imports/#alias). Luego, utiliza el nombre del import como valor de `src`:
+- **Imágenes locales en `src/`**: debes **importar también la imagen** usando una ruta relativa del archivo o configurar y usar un [alias de importación](/es/guides/imports/#aliases). Luego, utiliza el nombre del import como valor de `src`:
 
   ```astro title="src/pages/index.astro" "myImportedImage" "{myImportedImage}"
   ---
@@ -291,7 +291,7 @@ import { Image } from 'astro:assets';
 <Image src="https://example.com/cat.png" inferSize alt="Un gato durmiendo al sol." />
 ```
 
-`inferSize` puede obtener las dimensiones de una [imagen remota desde un dominio que no ha sido autorizado](/es/guides/images/#autorizando-imágenes-remotas), sin embargo, la imagen en sí permanecerá sin procesar.
+`inferSize` puede obtener las dimensiones de una [imagen remota desde un dominio que no ha sido autorizado](/es/guides/images/#authorizing-remote-images), sin embargo, la imagen en sí permanecerá sin procesar.
 
 ##### priority
 
@@ -551,7 +551,7 @@ Los valores coinciden con los de `object-position` en CSS. El valor predetermina
 `getImage()` depende de APIs que solo funcionan en el servidor y falla al compilar cuando se usa en el cliente.
 :::
 
-La función `getImage()` está pensada para generar imágenes destinadas a ser usadas en otro lugar que no sea directamente en HTML, por ejemplo, en una [ruta de API](/es/guides/endpoints/#endpoints-del-servidor-rutas-de-api). También te permite crear tu propio componente `<Image />`.
+La función `getImage()` está pensada para generar imágenes destinadas a ser usadas en otro lugar que no sea directamente en HTML, por ejemplo, en una [ruta de API](/es/guides/endpoints/#server-endpoints-api-routes). También te permite crear tu propio componente `<Image />`.
 
 `getImage()` recibe un objeto de opciones con [las mismas propiedades que el componente Image](#propiedades-de-la-imagen) (excepto `alt`).
 
diff --git a/src/content/docs/es/reference/modules/astro-i18n.mdx b/src/content/docs/es/reference/modules/astro-i18n.mdx
index 94a49ae143407..58642c79e0b49 100644
--- a/src/content/docs/es/reference/modules/astro-i18n.mdx
+++ b/src/content/docs/es/reference/modules/astro-i18n.mdx
@@ -128,7 +128,7 @@ Utiliza esto como [`getRelativeLocaleUrl`](#getrelativelocaleurl) para devolver
 **Tipo:** `(path?: string, options?: GetLocaleOptions) => string[]`
 </p>
 
-Utiliza esto como [`getAbsoluteLocaleUrl`](/es/guides/internationalization/#rutas-de-idioma-personalizadas) para devolver una lista de rutas absolutas para todas las configuraciones regionales.
+Utiliza esto como [`getAbsoluteLocaleUrl`](/es/guides/internationalization/#custom-locale-paths) para devolver una lista de rutas absolutas para todas las configuraciones regionales.
 
 ### `getPathByLocale()`
 
@@ -136,7 +136,7 @@ Utiliza esto como [`getAbsoluteLocaleUrl`](/es/guides/internationalization/#ruta
 **Tipo:** `(locale: string) => string`
 </p>
 
-Una función que devuelve el `path` asociado a uno o más `codes` cuando se configuran [rutas de configuración regional personalizadas](/es/guides/internationalization/#rutas-de-idioma-personalizadas).
+Una función que devuelve el `path` asociado a uno o más `codes` cuando se configuran [rutas de configuración regional personalizadas](/es/guides/internationalization/#custom-locale-paths).
 
 ```js title="astro.config.mjs"
 export default defineConfig({
diff --git a/src/content/docs/es/tutorial/4-layouts/2.mdx b/src/content/docs/es/tutorial/4-layouts/2.mdx
index 92436d60eafd8..2a6a1e61adff5 100644
--- a/src/content/docs/es/tutorial/4-layouts/2.mdx
+++ b/src/content/docs/es/tutorial/4-layouts/2.mdx
@@ -175,7 +175,7 @@ const { frontmatter } = Astro.props;
 
 ### Recursos
 
-- [Plantillas de Markdown en Astro](/es/guides/markdown-content/#layout-en-el-frontmatter)
+- [Plantillas de Markdown en Astro](/es/guides/markdown-content/#frontmatter-layout-property)
 
 - [Props de plantilla para Markdown](/es/basics/layouts/#props-de-plantillas-markdown)
 
diff --git a/src/content/docs/es/tutorial/5-astro-api/2.mdx b/src/content/docs/es/tutorial/5-astro-api/2.mdx
index 5c7bce342bb92..858b7ca98f9cb 100644
--- a/src/content/docs/es/tutorial/5-astro-api/2.mdx
+++ b/src/content/docs/es/tutorial/5-astro-api/2.mdx
@@ -325,6 +325,6 @@ Elije el término que corresponda a la descripción.
 
 ### Recursos
 
-- [Enrutamiento dinámico de páginas en Astro](/es/guides/routing/#rutas-dinámicas)
+- [Enrutamiento dinámico de páginas en Astro](/es/guides/routing/#dynamic-routes)
 
-- [documentación de la API `getStaticPaths()`](/es/reference/api-reference/#getstaticpaths)
+- [documentación de la API `getStaticPaths()`](/es/reference/routing-reference/#getstaticpaths)
diff --git a/src/content/docs/es/tutorial/5-astro-api/3.mdx b/src/content/docs/es/tutorial/5-astro-api/3.mdx
index def48a1459678..419a25f4a3abc 100644
--- a/src/content/docs/es/tutorial/5-astro-api/3.mdx
+++ b/src/content/docs/es/tutorial/5-astro-api/3.mdx
@@ -439,4 +439,4 @@ Coincide cada ruta de archivo con una segunda ruta de archivo que creará una p
 
 ### Recursos
 
-- [Enrutamiento estático en Astro](/es/guides/routing/#rutas-estáticas)
+- [Enrutamiento estático en Astro](/es/guides/routing/#static-routes)
diff --git a/src/content/docs/es/tutorial/5-astro-api/4.mdx b/src/content/docs/es/tutorial/5-astro-api/4.mdx
index 7fd9063ca9923..970a15aa95c90 100644
--- a/src/content/docs/es/tutorial/5-astro-api/4.mdx
+++ b/src/content/docs/es/tutorial/5-astro-api/4.mdx
@@ -148,4 +148,4 @@ Las personas pueden suscribirse a tu feed en un lector de feeds y recibir una no
 
 ### Recursos
 
-- [Generación de elementos RSS en Astro](/es/recipes/rss/#usando-glob-imports)
+- [Generación de elementos RSS en Astro](/es/recipes/rss/#using-glob-imports)
diff --git a/src/content/docs/es/tutorial/6-islands/1.mdx b/src/content/docs/es/tutorial/6-islands/1.mdx
index 6cf198b932a5d..3c7c20a488d77 100644
--- a/src/content/docs/es/tutorial/6-islands/1.mdx
+++ b/src/content/docs/es/tutorial/6-islands/1.mdx
@@ -222,6 +222,6 @@ Para cada uno de los siguientes componentes, identifica lo que se enviará al na
 
 - [Guía de integraciones Astro](/es/guides/integrations-guide/)
 
-- [Uso de componentes de UI Framework en Astro](/es/guides/framework-components/#usando-componente-de-framework)
+- [Uso de componentes de UI Framework en Astro](/es/guides/framework-components/#using-framework-components)
 
 - [Referencia de las directivas del cliente Astro](/es/reference/directives-reference/#directivas-del-cliente)
diff --git a/src/content/docs/es/tutorial/6-islands/4.mdx b/src/content/docs/es/tutorial/6-islands/4.mdx
index 241da47e92bd3..332658a62fa65 100644
--- a/src/content/docs/es/tutorial/6-islands/4.mdx
+++ b/src/content/docs/es/tutorial/6-islands/4.mdx
@@ -14,7 +14,7 @@ import PreCheck from '~/components/tutorial/PreCheck.astro';
 import Option from '~/components/tutorial/Option.astro';
 import { Steps } from '@astrojs/starlight/components';
 
-Ahora que tienes un blog usando el [enrutamiento basado en archivos incorporado de Astro](/es/guides/routing/#rutas-estáticas), lo actualizarás para usar una [colección de contenido](/es/guides/content-collections/). Las colecciones de contenido son una forma poderosa de administrar grupos de contenido similar, como publicaciones de blog.
+Ahora que tienes un blog usando el [enrutamiento basado en archivos incorporado de Astro](/es/guides/routing/#static-routes), lo actualizarás para usar una [colección de contenido](/es/guides/content-collections/). Las colecciones de contenido son una forma poderosa de administrar grupos de contenido similar, como publicaciones de blog.
 
 <PreCheck>
   - Mueve tu carpeta de publicaciones de blog a `src/blog/`
@@ -26,7 +26,7 @@ Ahora que tienes un blog usando el [enrutamiento basado en archivos incorporado
 
 Incluso al usar colecciones de contenido, seguirás utilizando la carpeta `src/pages/` para páginas individuales, como tu página "Sobre mí". Pero, mover tus publicaciones de blog fuera de esta carpeta especial te permitirá usar APIs más poderosas y de mejor rendimiento para generar el índice de tus publicaciones de blog y mostrar tus publicaciones de blog individuales.
 
-Al mismo tiempo, recibirás una mejor guía y autocompletado en tu editor de código porque tendrás un **[esquema](/es/guides/content-collections/#definiendo-un-esquema-de-colección)** para definir una estructura común para cada publicación que Astro te ayudará a aplicar a través de [Zod](https://zod.dev/), una biblioteca de declaración y validación de esquemas para TypeScript. En tu esquema, puedes especificar cuándo las propiedades del frontmatter son obligatorias, como una descripción o un autor, y qué tipo de datos debe tener cada propiedad, como una cadena o una matriz. Esto lleva a detectar muchos errores antes, con mensajes de error descriptivos que te indican exactamente cuál es el problema.
+Al mismo tiempo, recibirás una mejor guía y autocompletado en tu editor de código porque tendrás un **[esquema](/es/guides/content-collections/#defining-the-collection-schema)** para definir una estructura común para cada publicación que Astro te ayudará a aplicar a través de [Zod](https://zod.dev/), una biblioteca de declaración y validación de esquemas para TypeScript. En tu esquema, puedes especificar cuándo las propiedades del frontmatter son obligatorias, como una descripción o un autor, y qué tipo de datos debe tener cada propiedad, como una cadena o una matriz. Esto lleva a detectar muchos errores antes, con mensajes de error descriptivos que te indican exactamente cuál es el problema.
 
 Lee más sobre las [colecciones de contenido de Astro](/es/guides/content-collections/) en nuestra guía, o comienza con las instrucciones a continuación para convertir un blog básico de `src/pages/posts/` a `src/blog/`.
 
@@ -110,7 +110,7 @@ Actualiza a la última versión de Astro y actualiza todas las integraciones a s
 
 2. Mueve todas tus publicaciones de blog existentes (archivos `.md`) de `src/pages/posts/` a esta nueva colección.
 
-3. Crea un archivo `src/content.config.ts` para [definir un esquema](/es/guides/content-collections/#definiendo-un-esquema-de-colección) para tu `postsCollection`. Para el código del tutorial de blog existente, agrega el siguiente contenido al archivo para definir todas las propiedades del frontmatter utilizadas en sus publicaciones de blog:
+3. Crea un archivo `src/content.config.ts` para [definir un esquema](/es/guides/content-collections/#defining-the-collection-schema) para tu `postsCollection`. Para el código del tutorial de blog existente, agrega el siguiente contenido al archivo para definir todas las propiedades del frontmatter utilizadas en sus publicaciones de blog:
 
     ```ts title="src/content.config.ts"
     // Importa el cargador glob
@@ -145,7 +145,7 @@ Actualiza a la última versión de Astro y actualiza todas las integraciones a s
 <Steps>
 1. Crea un archivo de página llamado `src/pages/posts/[...slug].astro`. Tus archivos Markdown y MDX ya no se convierten automáticamente en páginas usando el enrutamiento basado en archivos de Astro cuando están dentro de una colección, por lo que debes crear una página responsable de generar cada publicación de blog individual.
 
-2.  Agrega el siguiente código para [consultar tu colección](/es/guides/content-collections/#consultando-colecciones) para que el slug de cada publicación de blog y el contenido de la página estén disponibles para cada página que generará:
+2.  Agrega el siguiente código para [consultar tu colección](/es/guides/content-collections/#querying-collections) para que el slug de cada publicación de blog y el contenido de la página estén disponibles para cada página que generará:
 
     ```astro title="src/pages/posts/[...slug].astro"
     ---