
Blockstudio 7.6 permite consultar y renderizar un proyecto desde PHP, y traslada los valores predeterminados del frontend de producción a `blockstudio.json`: un inventario API, renderizado independiente, funciones auxiliares de plantilla para medios y Tailwind, perfiles de rendimiento, un directorio de caché, prerenderizado estático con servicio anticipado, ajustes preestablecidos de análisis más estrictos y herramientas de proyecto generadas para agentes de programación.

Dos llamadas concentran la mayor parte de las novedades. `Canvas::inventory()` devuelve todas las páginas, bloques, patrones, plantillas del Editor del sitio, partes de plantillas y ejemplos UI agrupados que registra un proyecto. `Render::document()` devuelve el HTML finalizado de cualquiera de ellos, con exactamente los recursos que usó el renderizado.

> **Actualización de 7.6.2:** Las páginas basadas en archivos ya no se concilian durante las solicitudes normales de WordPress. Ejecute `wp bs pages sync` o llame a `Blockstudio\Pages::reconcile()` al aplicar cambios de origen. El enrutamiento de colecciones y los valores predeterminados de `templateFor` usan la configuración persistente del entorno de ejecución, y la conciliación explícita evita la consulta OR-meta multilingüe extensa anterior. Se ha eliminado la opción `themeDefaults.syncPagesInDevelopment` de corta duración porque la sincronización de páginas ya no se ejecuta desde los hooks de solicitud. `Pages::init()` ahora solo se ejecuta durante el inicio; las integraciones que pasaban `force` deben usar `Pages::reconcile()` o CLI. Al abrir Canvas se sigue realizando una conciliación explícita y autenticada del inventario de creación de contenido.

> **7.6.12 actualización:** Las hojas de estilo del editor ahora se prefijan en una sola
> pasada de reescritura, en lugar de compilar SASS por cada recurso, así que una
> compilación en frío del editor en un sitio con muchos bloques ya no corre el
> riesgo de agotar un límite de memoria modesto. Si se ha expulsado la hoja de
> estilo Tailwind con hash de contenido de una página prerenderizada en caché, la
> página se vuelve a renderizar en vez de servirse sin estilos, tanto mediante
> la caché PHP como con el complemento Early Serve. Los atributos de bloque
> escritos en el nivel superior se leen durante el renderizado en vez de
> descartarse, por lo que los escritores programáticos respetan el esquema
> Blockstudio registrado en `WP_Block_Type`.

> **7.6.11 actualización:** La instalación de artefactos Graph ahora reemplaza
> atómicamente el documento de una ruta cuando cambia la copia de la tienda con
> la misma clave, conserva intactos los documentos idénticos e informa de las
> rutas promocionadas, reemplazadas, omitidas y conservadas mediante `Static_Prerender_Early_Serve::last_promotion()`.

> **7.6.10 actualización:** Los aciertos de la caché de ejecución ahora detectan los
> recursos compilados eliminados incluso durante el debounce de vigilancia, y
> las cachés de ejecución planas anteriores a la versión 7.6 se ponen en
> cuarentena atómicamente y se eliminan en lotes limitados de cron. Los
> globales de UI incluidos se emiten una sola vez por página. Early Serve en
> modo Graph puede servir rutas renderizadas en vivo que no están en el mapa de
> rutas desplegado desde la caché de identidad. Tailwind puede emitir opcionalmente
> su archivo de caché con hash de contenido con `tailwind.output: "link"`; la salida en línea sigue
> siendo la opción predeterminada.

En resumen:

- **Inventario del proyecto**: `Canvas::inventory()` devuelve todos los registros registrados,
  con sus fuentes y un orden de visualización estable.
- **Selección específica**: indicar bloques y páginas limita el descubrimiento,
  la sincronización, el renderizado y la compilación a esos registros.
- **Renderizado independiente**: `Blockstudio\Render` devuelve HTML terminados para un
  bloque, una composición o un documento completo.
- **Familias de componentes de UI**: `Blockstudio\Ui` agrupa la biblioteca incluida en
  una familia pública por componente, cada una con un ejemplo.
- **Dimensiones de imagen estables**: `bs_media_image()` renderiza recursos del tema con
  dimensiones reales a partir de un `assets/media.json` generado.
- **Ayudantes de clases de Tailwind**: `bs_tw_merge()` y `bs_tw_variants()` componen clases en
  PHP con una combinación que tiene en cuenta los conflictos.
- **Perfiles de rendimiento**: `performance.profile` activa de una vez los valores
  predeterminados de producción del frontend; los valores secundarios los
  sobrescriben.
- **Acceso tipado a la configuración**: `Settings::get_bool()` y sus funciones relacionadas
  leen `blockstudio.json` con tipos reales y notifican los errores de análisis.
- **Un directorio de caché**: todos los archivos generados se guardan bajo
  `cache.path`, identificados por una identidad de ejecución.
- **Prerenderizado estático**: HTML anónimos se pueden almacenar en caché,
  invalidar mediante un grafo de dependencias y servir antes de que se inicie
  WordPress.
- **Ajustes preestablecidos de análisis**: `theme`, `extreme-theme` y `wordpress-render` amplían
  `blockstudio/phpstan` más allá de las plantillas de bloque.
- **Hook de commit administrado**: `blockstudio-githooks sync` escribe y administra un hook
  pre-commit que ejecuta el ajuste preestablecido configurado.
- **Contrato del proyecto**: `blockstudio-agents` escribe un `AGENTS.md` que describe qué crea
  el proyecto, qué funciones habilita y qué exige su ajuste preestablecido.
- **Índice de documentación**: el archivo de contexto para IA ahora es un índice
  de todos los documentos, su propósito y los identificadores que les
  corresponden.
- **Etiquetas canónicas de bloque**: un comando independiente reescribe las
  abreviaturas de prefijos y alias como `<bs:namespace-slug>`, con una ejecución de prueba.
- **Compatibilidad de forma predeterminada**: nada de lo anterior modifica un
  sitio hasta que se indique en `blockstudio.json`.

## Lectura y renderizado de un proyecto

### Inventario del proyecto

`Canvas::inventory()` devuelve todo lo que registra un proyecto en forma de un único array simple,
sin renderizar nada.

```php
use Blockstudio\Canvas;

$result = Canvas::inventory();

foreach ($result['inventory']['blocks'] as $block) {
    echo $block['name'] . "\n";
}
```

Los registros se agrupan por tipo: `pages`, `blocks`, `patterns`, `templates`,
`parts` y `ui`. `order` establece el orden de visualización estable para todos los tipos,
`sources` asigna a cada registro sus rutas de origen, y `warnings` y `errors`
recopilan los problemas como entradas estructuradas.

Los registros de bloque incluyen `id`, `name`, `title`, `source`, `path`, `provenance` y un `declaration` listo para renderizar. Los registros de página conservan `source` como identidad estable y `path` como plantilla de renderizado.

### Selección específica

Indicar los registros limita el trabajo desde el principio, en lugar de filtrarlos después.

```php
$changed = Canvas::inventory([
    'blocks' => ['mytheme/hero'],
    'pages' => ['about'],
]);
```

Eso devuelve un bloque y una página. `patterns`, `templates`, `parts` y `ui`
se devuelven vacíos, y sus fuentes nunca se leen, sincronizan, renderizan ni
compilan.

Las reglas son exactas:

- Sin claves de tipo, se cargan todos los tipos.
- `true`, `null` o `"*"` carga todos los registros de ese tipo.
- Una cadena o una lista busca coincidencias exactas por ID, nombre, slug, ruta o ruta de origen.
- Una cadena vacía, una lista vacía o `false` no carga ningún registro de ese tipo.
- En cuanto se incluye una clave de tipo, los tipos omitidos no se modifican.

Los identificadores que ya no existen se devuelven en `deleted` en vez de provocar
un error, y el endpoint de actualización de REST de Canvas aplica la misma
regla a sus parámetros `blocks` y `pages`.

`Canvas::documents()` acepta la misma selección y añade un documento renderizado por cada
registro. Las páginas seleccionadas se renderizan en un contexto de frontend
restaurado, así que las condiciones de consulta, las clases del cuerpo, los
shortcodes, los diseños, las redirecciones y las funciones de encolado usan esa
página, no la solicitud que pidió renderizarla.

### Renderizado independiente

`Blockstudio\Render` devuelve HTML renderizado como una cadena mediante el mismo
proceso que usa el frontend.

```php
use Blockstudio\Render;

$html = Render::composition([
    'root' => 'mytheme/card',
    'data' => ['heading' => 'Example card'],
    'layers' => [
        ['name' => 'mytheme/button', 'data' => ['label' => 'Continue']],
    ],
]);
```

Todas las declaraciones parten de una misma estructura con cuatro claves: `name`, `attributes`,
`content` y `children`. `root`, `data`, `inner`, `innerBlocks`, `layers` y
`example` son formas prácticas de introducir datos que `Render::normalize()` integra en ella.
Los elementos secundarios se renderizan de forma recursiva, y las entradas no
válidas generan una excepción que identifica el bloque problemático.

`Render::document()` envuelve la salida en un documento HTML independiente completo.

```php
$document = Render::document('mytheme/hero', [
    'title' => 'Hero preview',
]);

echo $document['html'];
```

`body` es solo la salida del bloque, `html` es el documento ensamblado,
`blocks` son los nombres de los bloques que contribuyeron y `assets` divide el
marcado en `head`, `footer`, `styles`, `scripts`, `modules`, `interactivity`, `ui` y `tailwind`.
Los recursos se limitan a lo que se ha renderizado, así que nunca se incluyen
los recursos exclusivos del editor.

`Render::document_from_html()` envuelve HTML renderizado en otro sitio, y
`Render::content()` renderiza el contenido de bloques serializado sin un documento. Llame a
`Blockstudio\Batch_Render::reset()` entre documentos en un mismo proceso PHP; `Canvas::documents()` ya lo hace.

### Familias de componentes de UI

`Blockstudio\Ui` expone la biblioteca UI incluida con una entrada por cada
componente público, en vez de una lista de piezas internas.

`Ui::inventory()` devuelve una entrada por familia con su bloque raíz, título y los
bloques de implementación que necesita. `Ui::examples()` añade una declaración
predeterminada para cada familia: conserva los valores predeterminados, anida
las capas secundarias obligatorias bajo sus elementos principales e incluye
texto ilustrativo estable cuando un campo está vacío. Esa declaración es
canónica, así que se incorpora directamente a `Render::document()`.

Canvas agrupa los componentes del mismo modo. UI incluido aparece bajo el
tipo `ui` con un ejemplo por familia, y los registros de implementación no se
incluyen en `blocks`.

Las familias están diseñadas para combinarse: un selector se abre dentro de un diálogo, con su lista superpuesta al activador; los menús y los cuadros combinados se anclan con coordenadas fijas de la ventana gráfica que se mantienen al desplazarse; los modales se apilan y se cierran de uno en uno al pulsar Escape; y todos los pies de página combinan el mismo control de cierre con una variante. En el [capítulo sobre composición](https://blockstudio.dev/es/ui/composition/) se explica cómo funcionan estas conexiones y qué invariantes las mantienen; [/ui/examples](https://blockstudio.dev/es/ui/examples/) muestra las composiciones en funcionamiento.

## Ayudantes de plantillas

### Dimensiones de imagen estables

`bs_media_image()` renderiza los recursos del tema con el ancho y la altura reales, y reserva
la proporción de aspecto, para que las imágenes ajenas a la biblioteca de medios
dejan de desplazar el diseño.

```php
<?php
echo bs_media_image([
    'src' => 'assets/images/hero.webp',
    'alt' => 'Hero',
]);
```

La salida es un `figure.blockstudio-media` con un `aspect-ratio` en línea alrededor de un
`img` que incluye valores reales de `width`, `height`, `loading` y `decoding`. Las
 dimensiones proceden de un `assets/media.json` generado, escrito por `Blockstudio\Media_Metadata_Builder` durante un
paso de compilación o manualmente.

`src` acepta una ruta relativa al tema, una ruta absoluta o una URL completa,
y `attachmentId` se ocupa de las imágenes de la biblioteca de medios. `eager` desactiva
la carga diferida en la parte superior de la página, y `sources` genera un `<picture>`.

Con `performance.media.lazy` activado, el URL real se mueve a `data-src` detrás de un
marcador de posición con el tamaño correcto.

### Ayudantes de clases de Tailwind

`bs_tw_merge()` y `bs_tw_variants()` componen clases de Tailwind en las plantillas de
PHP mediante el motor que Blockstudio ya incluye.

`bs_tw_merge('px-2 text-sm', 'px-4')` devuelve `text-sm px-4`: se elimina el `px-2` que entra en conflicto y prevalece
el valor posterior. Se aceptan matrices anidadas de valores de clase.

`bs_tw_variants()` devuelve una pequeña función invocable para las variantes de componentes:

```php
$button = bs_tw_variants([
    'base' => 'inline-flex items-center',
    'variants' => [
        'size' => ['sm' => 'h-8 px-3', 'lg' => 'h-12 px-6'],
    ],
    'defaultVariants' => ['size' => 'sm'],
]);

echo $button(['size' => 'lg', 'class' => 'rounded']);
```

Eso imprime `inline-flex items-center h-12 px-6 rounded`. Admite clases base, variantes, variantes predeterminadas,
variantes compuestas y un `class` o `className` por llamada.

## Configuración de producción

### Perfiles de rendimiento

`performance.profile` activa en un solo lugar los valores predeterminados de producción del frontend.

```json title="blockstudio.json"
{
  "performance": {
    "profile": "speed",
    "preload": {
      "links": "off"
    }
  }
}
```

`compat` es la opción predeterminada y no cambia nada. `speed` y `strict` habilitan
el mismo conjunto: eliminan del encabezado la salida de generador, emoji, feed,
descubrimiento y entradas adyacentes; eliminan el descubrimiento de oEmbed y los
scripts del host; desactivan XML-RPC, los pingbacks y el descubrimiento
remoto del editor; eliminan recursos genéricos del frontend de core; aplican
valores predeterminados a la salida de imágenes; limitan Heartbeat fuera de los
editores; precargan documentos del mismo origen al detectar intención de pasar
o hacer foco; y usan el cargador de imágenes de Blockstudio.

Cada valor secundario sobrescribe el perfil, como `preload.links` en el ejemplo
anterior. Lo primero que se debe probar es la eliminación de recursos del
frontend de core, porque las páginas que dependen de ellos dejan de funcionar de
forma visible. `Runtime_Settings::current()` muestra el perfil resuelto.

`themeDefaults` cubre dos tareas que los temas suelen implementar por su cuenta: `titleTag` y
`suppressDirectoryUpdates` para ocultar el tema hijo activo y el tema padre en los resultados de actualización.

### Acceso tipado a la configuración

`Blockstudio\Settings` lee la configuración con tipos reales, en vez de devolver lo que
contenía JSON.

```php
use Blockstudio\Settings;

$lazy = Settings::get_bool('performance/media/lazy');
$margin = Settings::get_string('performance/media/rootMargin', '300px');
$ttl = Settings::get_int('performance/staticPrerender/ttl', 86400);
$roles = Settings::get_array('users/roles');

foreach (Settings::errors() as $error) {
    error_log($error);
}
```

Los errores de JSON se notifican mediante `Settings::errors()` en vez de resolverse con
valores predeterminados. `Settings::get_raw()` devuelve solo lo que declaró la fuente activa,
lo que permite distinguir entre un valor establecido en `false` y uno que nunca
se estableció.

`Settings::fingerprint()` devuelve una identidad estable para la configuración efectiva, y el
acceso se recarga cuando cambia `blockstudio.json`.

### Un directorio de caché

Ahora, todos los archivos generados se guardan bajo `cache.path`, que de forma
predeterminada es `wp-content/blockstudio/cache`.

```json title="blockstudio.json"
{
  "cache": {
    "enabled": true,
    "path": "cache/blockstudio"
  }
}
```

Las cargas de compilación, los datos de registro de bloques, los recursos del
editor, los Tailwind CSS compilados, los documentos de renderizado, los fragmentos de
islas, los HTML estáticos, los índices de Graph, las colas de calentamiento y
los diagnósticos se guardan bajo esa raíz. Una ruta relativa se resuelve desde
`WP_CONTENT_DIR`; una ruta absoluta apunta a un volumen dedicado.

Los objetos se archivan bajo la red y el sitio actuales, y después bajo una
identidad de ejecución: una huella digital de las versiones de Blockstudio, WordPress y
PHP, la configuración efectiva, el tema y los plugins activos, las fuentes
de descubrimiento y los archivos de origen implicados. Cuando cambia una
entrada, los objetos afectados se convierten en objetos nuevos; los anteriores
se depuran.

Las compilaciones en frío se ejecutan una sola vez: una solicitud compila y
publica el resultado atómicamente mientras las demás esperan. Si falla una
actualización, se sigue sirviendo el último objeto válido y el fallo sigue
siendo observable; `Blockstudio\Runtime_Cache::purge('tailwind')` borra un ámbito.

## Prerenderizado estático

El prerenderizado estático almacena en caché documentos HTML anónimos completos
y puede servirlos antes de que se inicie WordPress. Está desactivado de forma
predeterminada.

```json title="blockstudio.json"
{
  "performance": {
    "staticPrerender": {
      "enabled": true,
      "ttl": 3600,
      "earlyServe": true,
      "dynamicPaths": ["/account", "/checkout"]
    }
  }
}
```

### Elegibilidad

Solo pueden almacenarse en caché documentos HTML anónimos completos. Se omiten
las solicitudes que no sean GET, las cadenas de consulta, el área de
administración, REST, Ajax, cron, los feeds, las búsquedas, las vistas
previas, las solicitudes con nonce, las cookies personalizadas y cualquier
ruta bajo `dynamicPaths`. Una respuesta puede excluirse por completo mediante un marcador
`<!-- blockstudio:no-cache -->`.

La coincidencia de rutas respeta los límites, así que `/account` incluye `/account/orders`,
pero no `/accounting`.

### Modos de firma y de grafo

`invalidate` determina cómo caducan las entradas. El modo predeterminado `signature`
completa una respuesta con clave de identidad cuando hay un fallo de caché
anónimo y la rota tras cambios en el sitio, lo que resulta adecuado para un
sitio corriente.

El modo `graph` está pensado para herramientas explícitas de compilación y
despliegue. Registra las dependencias de origen de cada página para que un plan
recompile solo las URL afectadas.

```php
use Blockstudio\Static_Prerender_Runtime;

$plan = Static_Prerender_Runtime::build_plan($sourceUrls);

foreach ($plan['affectedUrls'] as $url) {
    $result = render_with_dependencies($url);

    Static_Prerender_Runtime::persist_built_response(
        $url,
        $result['html'],
        $result['files'],
        $result['virtualHashes']
    );
}

Static_Prerender_Runtime::garbage_collect(array_keys($plan['live']));
```

### Servicio anticipado

Con `earlyServe` activado, Blockstudio administra un pequeño mapa de rutas por sitio y un
complemento `advanced-cache.php` que transmite las respuestas válidas de la caché antes de que
se inicien WordPress, los plugins o el tema.

Nunca sobrescribe un mapa, un complemento o una declaración `WP_CACHE` de terceros.
Antes de intercambiar el mapa, un artefacto Graph valida cada archivo HTML al
que se hace referencia, así que un despliegue a medio renderizar deja activo el
grafo anterior. Las entradas de instalaciones multisitio se mantienen aisladas
por host, ruta de inicio e ID del sitio.

### Calentamiento y estado

Tres comandos de WP-CLI cubren las tareas cotidianas:

```bash
wp bs prerender warm
wp bs prerender status
wp bs prerender purge
```

`status` informa de la identidad activa, el recuento de archivos y bytes, los
registros de Graph, el estado de la cola y los contadores de aciertos, fallos de
caché, compilaciones y errores por ámbito.

## Análisis y herramientas para agentes

### Ajustes preestablecidos de análisis

`blockstudio/phpstan` añade tres capas a su análisis de bloques y un comando que ejecuta la
capa seleccionada por el proyecto.

| Ajuste preestablecido | Qué añade |
| --- | --- |
| `base` | Los análisis existentes de esquemas, plantillas, hooks, configuración y API. |
| `theme` | Raíces del tema, encabezados de estilo, recursos, delimitación de selectores, valores predeterminados de campos y límites de repetidores. |
| `extreme-theme` | Comprobaciones de PHPStan `max`, PHP no seguro, escape, Tailwind, JavaScript e Interactivity. |
| `wordpress-render` | Una prueba de renderizado en vivo proporcionada por quien llama, además de `extreme-theme`. |

Los valores predeterminados proceden de `blockstudio.json`, para que las ejecuciones
interactivas, la integración continua y los hooks de commit compartan una misma
configuración:

```json title="blockstudio.json"
{
  "phpstan": {
    "preset": "theme",
    "roots": ["."],
    "excludePaths": ["fixtures/**"],
    "maxFiles": 10000
  }
}
```

```bash
vendor/bin/blockstudio-phpstan --root . -- --no-progress
```

Los códigos de salida son `0` si se supera la comprobación, `1` si hay diagnósticos
y `2` si el uso no es válido. El contenedor compone su configuración en el
directorio temporal del sistema, así que no deja ninguna configuración,
referencia ni caché generada en el proyecto, y aumenta el límite de memoria de
PHPStan a `1G`.

También incluye un proveedor de BC Math, por lo que las comprobaciones de
JavaScript ya no necesitan `ext-bcmath`.

### Hook de commit administrado

Un ajuste y un comando convierten el ajuste preestablecido configurado en una
condición para hacer commit.

```json title="blockstudio.json"
{
  "githooks": {
    "commit": true
  }
}
```

```bash
vendor/bin/blockstudio-githooks sync
```

La sincronización escribe el hook y un registro de propiedad en el directorio
común de Git, apunta `core.hooksPath` al directorio administrado y encadena el hook
pre-commit que ya estuviera configurado. El hook resuelve el repositorio y la
raíz del proyecto al hacer commit, así que funcionan los checkouts vinculados y
las rutas que contienen espacios.

El hook ejecuta `vendor/bin/blockstudio-phpstan` y nada más; nunca formatea ni reescribe archivos. Si se
establece `commit` en `false` y se vuelve a sincronizar, o se ejecuta `blockstudio-githooks remove`,
se restablece la ruta de hook registrada y se eliminan solo los archivos
administrados por Blockstudio.

### Contrato del proyecto

`blockstudio-agents` escribe un `AGENTS.md` que especifica dónde se encuentran los bloques, qué es
una página en este proyecto, qué funciones están habilitadas y qué rechazará
el analizador.

```bash
vendor/bin/blockstudio-agents
```

El documento se genera a partir del proyecto, no de una plantilla. Un tema con
un encabezado `style.css`, bloques y páginas respaldadas por archivos obtiene un
contrato distinto al de un plugin que solo registra bloques, con las
cantidades, los directorios, los espacios de nombres y los lenguajes de
plantilla que detectó el analizador. `blockstudio.json` determina qué funciones aparecen,
así que nunca se menciona el prerenderizado estático en un proyecto que no lo
usa.

La sección de corrección se lee capa por capa de los propios archivos de reglas
del ajuste preestablecido seleccionado, así que cuando se añade una regla a un
ajuste, cambia en todos los contratos generados.

La propiedad funciona igual que con el hook de commit. Si un archivo no tiene
el marcador de generado, se rechaza en vez de reemplazarse, salvo que `--force`
indique lo contrario. Una sección de notas al final se conserva tras la
regeneración, `--check` devuelve `1` si el contrato está desactualizado y `--stdout`
lo muestra sin modificar el sistema de archivos.

### Índice de documentación

`blockstudio-llm.txt` ahora es un índice, no una concatenación. Cada documento publicado
aparece una sola vez, en su sección y subsección, con su ruta, su archivo de
origen, una descripción breve y los identificadores que le corresponden: rutas
de configuración, nombres de hooks, funciones y clases de PHP, y comandos.

```text
## Docs / Dev / Inspection Tools

### Canvas
route: /docs/dev/canvas
file: docs/docs/dev/canvas.md
purpose: A visual workspace and public inventory API for Blockstudio content.
settings: dev/canvas/enabled, ui
hooks: blockstudio/settings/dev/canvas/admin_bar, blockstudio/settings/dev/canvas/enabled
php: Blockstudio\Canvas, Canvas::documents(), Canvas::inventory()
```

Un agente lee el índice, encuentra el único documento que contiene el identificador que busca y abre ese documento. La concatenación anterior de medio megabyte sigue generándose y publicándose en `/blockstudio-llm-full.txt`; ya no es lo primero que se entrega a nadie.

## Etiquetas canónicas de bloques

Un comando independiente reescribe las abreviaturas de prefijos y alias con la forma canónica `<bs:namespace-slug>`, que registra el nombre real del bloque y se resuelve sin cargar ningún filtro del proyecto.

Con un prefijo `brand` sobre `theme-components` y un prefijo `ui` sobre `bsui`, esta abreviatura:

```html
<brand-card>
  <ui-input />
</brand-card>
```

significa lo mismo que:

```html
<bs:theme-components-card>
  <bs:bsui-input />
</bs:theme-components-card>
```

Los prefijos y los alias exactos siguen funcionando y no están obsoletos. El comando no carga WordPress y no escribe nada sin `--apply`:

```bash
php vendor/blockstudio/blockstudio/bin/migrate-block-tags.php \
  --root="$PWD" \
  --prefix-map=/tmp/prefixes.json \
  --known-blocks=/tmp/blocks.json \
  --report=/tmp/tag-migration.json \
  --dry-run
```

`--prefix-map` asigna cada prefijo a sus espacios de nombres y `--known-blocks` enumera los nombres de bloques registrados. El informe registra las correspondencias de formas antiguas a canónicas con el número de apariciones, los hashes de cada archivo y listas separadas de etiquetas desconocidas, alias ambiguos y etiquetas dinámicas. `--apply` se niega a escribir mientras quede alguna, a menos que se pase `--allow-unresolved`.

Se admiten etiquetas emparejadas, anidadas y de cierre automático, incluidas las etiquetas literales en cadenas PHP. Solo cambian los nombres de las etiquetas; una segunda ejecución no produce cambios y los ejemplos en comentarios, bloques de código, `<pre>` o `<code>` solo se incluyen en el informe.

## Comportamiento predeterminado

Instalar la versión 7.6 no cambia nada por sí solo.

**El perfil de rendimiento está desactivado de forma predeterminada: `compat`.** La salida del encabezado, oEmbed, XML-RPC, Heartbeat, los valores predeterminados de imágenes, la precarga de enlaces, la carga diferida y `<title>` de la interfaz pública se mantienen tal como los dejaron WordPress y el tema.

**Estos elementos permanecen desactivados hasta que se habilitan:** cada clave `performance.staticPrerender`, `performance.measurement`, `performance.media` y `themeDefaults`, además de `githooks.commit`, `dev.canvas.enabled`, `ui.enabled`, `tailwind.enabled` y `blockTags.enabled`. Mientras la generación estática previa esté desactivada, no escribe archivos ni instala complementos auxiliares.

**Canvas y Render son pasivos.** Leen los registros existentes y solo muestran lo que solicita quien los llama; ninguno se conecta a la salida de la interfaz pública ni registra rutas. La pantalla de administración de Canvas sigue requiriendo `dev.canvas.enabled` y `edit_posts`.

**Para un análisis más estricto, hay que especificarlo.** Instalar `blockstudio/phpstan` solo habilita la extensión base, y el comando canónico ejecuta `base`, salvo que el proyecto especifique un ajuste preestablecido.

**Los archivos generados requieren ejecutar el comando correspondiente.** `githooks.commit` no hace nada hasta que se ejecuta `blockstudio-githooks sync`, y `AGENTS.md`, hasta que se ejecuta `blockstudio-agents`.

## Actualizar desde la versión 7.5

Los requisitos no cambian: PHP 8.2 o posterior, WordPress 6.7 o posterior.

```bash
composer require blockstudio/blockstudio
```

**Las cachés se reconstruyen una vez.** La identidad del entorno de ejecución incluye la versión de Blockstudio, así que la primera solicitud tras la actualización empieza con la caché vacía y se eliminan los objetos antiguos. La caché antigua de Tailwind en `wp-content/uploads/blockstudio/tailwind/cache` se puede eliminar; los fragmentos que la recorrían con glob deben llamar a `Blockstudio\Runtime_Cache::purge('tailwind')` en su lugar.

El directorio plano `wp-content/blockstudio/cache/runtime` anterior a la versión 7.6 se renombra automáticamente para sacarlo de la ruta activa y se elimina en pasadas limitadas de WP-Cron. Por eso, no hace falta borrar los árboles grandes de archivos de bloqueo antiguos durante una solicitud de despliegue.

**Los archivos generados tienen responsables.** `assets/media.json` debe estar en el control de versiones o en un paso de compilación. El mapa de rutas, el complemento auxiliar `advanced-cache.php` y la declaración `WP_CACHE` solo existen mientras `earlyServe` esté habilitado, y el hook de preconfirmación solo mientras esté sincronizado. Todo lo demás que se genere se guarda bajo `cache.path` y se puede eliminar sin problema.

**No se ha eliminado ni renombrado nada.** `bs_render_block()`, `bs_block()`, `Blockstudio\Pages` y `Blockstudio\Patterns` siguen siendo las superficies de contenido canónicas basadas en archivos.

**La reversión se hace por función.** Volver `performance.profile` a `compat`, `staticPrerender.enabled` a `false`, `githooks.commit` a `false` junto con un `sync`, y `cache.enabled` a `false` revierte una capa en cada caso.

Un orden de adopción razonable:

1. Establezca `performance.profile` en `speed` y compruebe la salida del encabezado, los feeds y los plugins que dependan de oEmbed o de XML-RPC.
2. Genere `assets/media.json`, mueva las plantillas a `bs_media_image()` y luego habilite `performance.media.lazy`.
3. Habilite `performance.staticPrerender` con `earlyServe` desactivado, verifique las solicitudes con `wp bs prerender status` y luego active `earlyServe`.
4. Ejecute `blockstudio-phpstan --preset theme` hasta que no haya problemas, antes de poner cualquier ajuste preestablecido detrás de `githooks.commit`.

## Dónde encontrar los detalles

- [Canvas](https://blockstudio.dev/es/docs/dev/canvas/) y su [inventario y documentación del documento API](https://blockstudio.dev/es/docs/dev/canvas/#public-inventory-and-document-api)
- [Renderizado](https://blockstudio.dev/es/docs/blocks/rendering/#structured-compositions-and-complete-documents), [UI Componentes](https://blockstudio.dev/es/ui/#public-inventory-and-examples) y [UI Composición](https://blockstudio.dev/es/ui/composition/)
- [Configuración](https://blockstudio.dev/es/docs/general/settings/) y [rendimiento](https://blockstudio.dev/es/docs/general/settings/#performance)
- [Rendimiento](https://blockstudio.dev/es/docs/production/performance/), [Almacenamiento en caché](https://blockstudio.dev/es/docs/production/caching/) y [Prerenderizado estático](https://blockstudio.dev/es/docs/production/static-prerendering/)
- [Tailwind CSS](https://blockstudio.dev/es/docs/tailwind/#template-composition-helpers)
- [PHPStan](https://blockstudio.dev/es/docs/dev/phpstan/): [ajustes preestablecidos](https://blockstudio.dev/es/docs/dev/phpstan/#analysis-presets), [comando canónico](https://blockstudio.dev/es/docs/dev/phpstan/#canonical-command), [hook de commit gestionado](https://blockstudio.dev/es/docs/dev/phpstan/#managed-commit-hook) y el [contrato del proyecto](https://blockstudio.dev/es/docs/dev/phpstan/#project-contract-for-coding-agents)
- [Integración con IA](https://blockstudio.dev/es/docs/dev/ai/): el índice de documentación y el texto completo
- [Migración](https://blockstudio.dev/es/docs/dev/migration/v7/#canonical-block-tags) y [PHP Hooks](https://blockstudio.dev/es/docs/blocks/hooks/php/)
