
Blockstudio 7.2 amplía el marco de trabajo en dos direcciones a la vez.

La primera se centra en la **visibilidad y el flujo de trabajo** dentro de un mismo proyecto: una nueva vista general del área de administración, un explorador de bases de datos, un explorador del registro de administración y preámbulos SCSS para compartir la configuración de Sass.

La segunda abarca **el ecosistema en torno a Blockstudio**: un registro CLI para distribuir bloques (como shadcn para WordPress) y una extensión PHPStan que aporta seguridad de tipos al estilo de TypeScript a las plantillas, las etiquetas de bloque, `db.php`, `rpc.php`, `cron.php` y los archivos de esquema relacionados.

Ambas direcciones persiguen lo mismo: facilitar la comprensión, ampliación y distribución de proyectos Blockstudio de mayor tamaño.

## Experiencia de administración

Dos novedades facilitan la navegación por proyectos grandes desde wp-admin.

### Vista general del área de administración

Blockstudio ahora incluye una pantalla de administración en Herramientas > **Blockstudio**. Te ofrece un lugar único para revisar lo que el sistema ha registrado a partir del sistema de archivos.

La vista general incluye pestañas específicas para:

- Bloques
- Extensiones
- Campos
- Páginas
- Esquemas

Además de esa vista general, el área de administración ahora incluye una sección específica de **Bases de datos**. Muestra todos los esquemas `Blockstudio\Db` registrados y permite inspeccionar los registros reales directamente en wp-admin.

En vez de crear una cuadrícula personalizada de paneles, la pantalla usa las tablas DataViews nativas de WordPress. Así, la interfaz UI mantiene la coherencia con wp-admin y sigue siendo práctica cuando un proyecto tiene decenas o cientos de elementos registrados.

En una instalación pequeña, puedes tener presente el estado del sistema. En una base de código más grande, eso deja de ser viable. Empiezas a hacerte preguntas como estas:

- ¿Qué bloques están registrados ahora mismo?
- ¿Qué extensiones se aplican a `core/*` y cuáles a bloques individuales?
- ¿Qué páginas están sincronizadas y a qué tipos de contenido pertenecen?
- ¿Qué campos reutilizables existen en este proyecto?
- ¿Qué esquemas están registrados y qué backend de almacenamiento utilizan?

Hasta ahora, la respuesta consistía en combinar la revisión de carpetas, la apertura de archivos JSON y el análisis paso a paso de PHP. La vista general convierte todo eso en una verdadera interfaz de administración.

Cada pestaña está diseñada para responder distintas preguntas:

- **Bloques** muestra los tipos de bloque registrados, el modo de representación, la versión de API y el número de atributos
- **Extensiones** muestra a qué bloques se aplican, además de la prioridad y los detalles de representación
- **Campos** ofrece un inventario rápido de las definiciones de campos personalizados reutilizables
- **Páginas** muestra las páginas sincronizadas basadas en archivos, con el tipo de contenido, el estado, el motor de plantillas y el estado de sincronización
- **Esquemas** muestra los esquemas de almacenamiento registrados, con el backend, el número de campos y el ámbito de permisos

El explorador de bases de datos se mantiene intencionadamente separado de la carga inicial del resumen. En lugar de serializar cada fila al cargar la página, solo localiza de antemano los esquemas disponibles y obtiene los registros a petición cuando abres una pestaña de base de datos. Así, el área de administración sigue siendo útil incluso cuando el proyecto contiene conjuntos de datos más grandes detrás de `db.php`.

Esta primera versión se centra intencionadamente en los registros definidos por esquemas. No es una página de ajustes. Es una página de inspección.

Si no lo quieres en absoluto, desactívalo por completo:

```php
add_filter('blockstudio/admin/enabled', '__return_false');
```

### Explorador del registro de administración

Junto al resumen hay una segunda pestaña: **Registro**. Es un explorador de registros remotos de bloques configurados en el `blocks.json` de tu tema, y te permite importar bloques directamente desde el panel de administración de WordPress sin tocar un CLI.

```json title="blocks.json"
{
  "directory": "blockstudio",
  "registries": {
    "ui": "https://blocks.example.com/registry.json",
    "private": {
      "url": "https://api.example.com/registry.json",
      "headers": {
        "Authorization": "Bearer ${REGISTRY_TOKEN}"
      }
    }
  }
}
```

El explorador consulta cada registro configurado, muestra todos los bloques disponibles e indica si ya están instalados localmente o se pueden importar. Cada fila tiene un botón Importar que descarga los archivos del bloque en el directorio configurado de tu tema. Los bloques que ya están instalados muestran el botón Volver a importar.

Se admiten registros autenticados mediante el formato de objeto con `headers`, incluida la interpolación de `${ENV_VAR}` para que los tokens nunca acaben en el control de versiones.

Así, explorar y usar registros se convierte en una experiencia integrada en el panel de administración, en lugar de ser solo un flujo de trabajo de CLI.

## Registro CLI

La otra parte de la historia del registro es una CLI independiente: `blockstudio/registry`.

Es una herramienta al estilo de shadcn para bloques WordPress. Sin paquete de npm ni paso de compilación. Ejecutas un comando, el código fuente del bloque se copia en tu proyecto y pasa a ser completamente tuyo.

```bash
npx blockstudio init
npx blockstudio add ui/tabs
```

CLI funciona con cualquier tipo de bloque: bloques Blockstudio, salida de `@wordpress/create-block` y bloques PHP simples. Al registro no le importa qué hay dentro de la carpeta. Lee el manifiesto de archivos de `registry.json` y copia exactamente esos archivos.

Quienes crean bloques publican un `registry.json` en cualquier URL (contenido sin procesar de GitHub, S3 o un servidor personalizado) que enumera los bloques disponibles, junto con sus metadatos, dependencias y listas de archivos. Los usuarios añaden el URL a su `blocks.json` y obtienen bloques por nombre.

CLI admite:

- **Resolución de dependencias**: los bloques pueden declarar dependencias de otros bloques, que se resuelven automáticamente con detección de ciclos
- **Gestión de conflictos entre varios registros**: si el mismo nombre de bloque existe en varios registros, CLI te pide que elijas uno
- **Registros autenticados**: tokens de portador, autenticación básica y encabezados personalizados con interpolación de variables de entorno
- **TUI interactiva**: creada con Ink, con indicadores de actividad, solicitudes de selección e indicadores de progreso
- **Modo no interactivo**: indicador `--yes` y alternativa automática para CI y flujos mediante tuberías
- **Búsqueda y listado**: explora registros desde la línea de comandos

El paquete incluye pruebas de 130 que cubren esquemas, resolución de dependencias, obtención de HTTP, escritura de archivos, todos los flujos de comandos y la UI interactiva de Ink.

Documentación completa en [blockstudio.dev/registry](https://blockstudio.dev/es/registry/).

## Extensión de PHPStan

La otra gran novedad es `blockstudio/phpstan`: una extensión de PHPStan que ofrece a los usuarios de Blockstudio la seguridad de tipos que esperan quienes desarrollan con TypeScript.

```bash
composer require --dev blockstudio/phpstan
```

La extensión lee los esquemas reales de tu proyecto durante el análisis y proporciona los tipos resultantes a PHPStan. Ahora cubre plantillas de PHP, Twig, Blade, etiquetas de bloques, registros de bases de datos tipados, rutas de ajustes, nombres de hooks y validación de esquemas en `block.json`, `field.json`, JSON de extensión, `page.json`, `db.php`, `rpc.php`, `cron.php` y `blockstudio.json`.

### Plantillas de bloques con seguridad de tipos

Los accesos a campos en `$a` se validan con el `block.json` asociado:

```php title="blockstudio/hero/index.php"
<?php
/** @var array<string, mixed> $a */

echo $a['title'];     // OK
echo $a['cta']['href']; // OK
echo $a['typo'];      // ERROR: Field "typo" does not exist in block.json (block: hero). Did you mean "title"?
```

### Registros de bases de datos con seguridad de tipos

`Db::get()` devuelve una instancia tipada según tu esquema de `db.php`. La estructura del registro se construye a partir de los campos reales:

```php title="db.php"
return [
  'storage' => 'table',
  'fields' => [
    'email' => ['type' => 'string', 'required' => true],
    'name'  => ['type' => 'string'],
  ],
];
```

```php
$db = Db::get('mytheme/subscribers');
$record = $db->create(['email' => 'a@b.com']);

echo $record['email']; // PHPStan: string
echo $record['name'];  // PHPStan: string|null
echo $record['typo'];  // ERROR: Offset 'typo' does not exist on array{id: int, email: string, name: string|null}
```

### Validación de esquemas

Los archivos de esquema no válidos se detectan durante el análisis: `block.json`, `field.json`, JSON de extensión, `page.json`, `db.php`, `rpc.php`, `cron.php` y `blockstudio.json`. Los nombres que faltan, los tipos de campo incorrectos, las definiciones mal formadas y los valores booleanos abreviados obsoletos (`"tailwind": true` en lugar del objeto anidado) se notifican con la línea exacta del archivo de origen.

### Validación de rutas de ajustes

Las llamadas a `Settings::get()` se validan con el esquema de ajustes conocido:

```php
Settings::get('tailwind/enabled');  // OK, returns bool
Settings::get('tailwind/enabld');   // ERROR: Settings path "tailwind/enabld" is not a known Blockstudio setting. Did you mean "tailwind/enabled"?
```

### Validación de nombres de hooks

Lo mismo ocurre con los nombres de hooks de filtros y acciones:

```php
add_filter('blockstudio/render', $cb);  // OK
add_filter('blockstudio/rendrr', $cb);  // ERROR: Unknown Blockstudio hook "blockstudio/rendrr". Did you mean "blockstudio/render"?
```

La extensión también incluye stubs para toda la Blockstudio API pública de `Db`, `Settings`, `Field_Registry`, `Build` y las funciones auxiliares globales. Obtienes autocompletado y comprobación de tipos para todas las API de Blockstudio sin necesidad de tener el código fuente del plugin en tu equipo de desarrollo.

## Comodidades para la creación

Dos pequeñas comodidades para la creación completan esta versión.

### Preludios globales de SCSS

Blockstudio ya admitía la compilación de SCSS, pero había un punto de fricción molesto: la configuración compartida de Sass.

Si querías acceder a un conjunto común de variables, funciones o mixins, tenías que importarlos en cada archivo de SCSS. Eso se vuelve repetitivo enseguida, sobre todo con sistemas de diseño grandes o kits de herramientas de Sass como Bootstrap.

La versión 7.2 añade un hook de preludio para eso:

```php
add_filter('blockstudio/assets/process/scss/prelude', function($prelude, $path, $scss) {
  return '@import "functions";' . "\n"
    . '@import "variables";' . "\n"
    . '@import "mixins";';
}, 10, 3);
```

Combinado con el filtro de `blockstudio/assets/process/scss/import_paths` existente, defines una interfaz compartida de Sass una sola vez y queda disponible en todos los archivos compilados.

La hoja de estilos de un bloque puede centrarse en los estilos que realmente necesita:

```scss title="style.scss"
.hero {
  @include media-breakpoint-up(lg) {
    padding: 4rem;
  }
}
```

Se acabaron las importaciones repetidas en cada recurso del bloque. No es un «modo de compatibilidad con Bootstrap» especial. Es un hook genérico para compartir Sass en todo el proyecto, ya provengan de Bootstrap o de tu propio kit de herramientas interno.

### Definiciones de API de bloques nativas de PHP

La versión 7.2 también añade una sintaxis opcional nativa de PHP para las API de bloques de pila completa. Los arrays siguen siendo la opción predeterminada y cuentan con compatibilidad total. No se ha reemplazado nada. Pero si prefieres argumentos con nombre, enumeraciones y atributos en lugar de arrays de configuración anidados, ahora puedes optar por ese estilo.

Para `rpc.php`, devuelve un objeto con métodos anotados:

```php title="rpc.php"
<?php
use Blockstudio\Attributes\Rpc;
use Blockstudio\Rpc\Access;
use Blockstudio\Rpc\Method;

return new class {
    #[Rpc(access: Access::Session)]
    public function subscribe(array $params): array {
        return ['success' => true];
    }

    #[Rpc(name: 'status', methods: [Method::Get, Method::Post])]
    public function getStatus(array $params): array {
        return ['status' => 'ok'];
    }
};
```

Para `cron.php`, la misma idea funciona con `#[Cron]`:

```php title="cron.php"
<?php
use Blockstudio\Attributes\Cron;
use Blockstudio\Cron\Schedule;

return new class {
    #[Cron(schedule: Schedule::Hourly)]
    public function heartbeat(): void {
    }
};
```

Y para `db.php`, ahora hay una pequeña capa de construcción:

```php title="db.php"
<?php
use Blockstudio\Db\Field;
use Blockstudio\Db\Schema;
use Blockstudio\Db\Storage;

return Schema::make(
    storage: Storage::Table,
    fields: [
        'email' => Field::string(required: true, format: 'email'),
        'active' => Field::boolean(default: false),
    ],
);
```

Esto ofrece un mejor equilibrio para bases de código grandes. Conservas la sencillez del formato de array cuando lo necesitas y puedes cambiar a una interfaz de PHP más fácil de explorar cuando un bloque supera un puñado de campos o endpoints.

## Por qué se publican todas estas novedades juntas

El resumen del panel de administración, el explorador de registros, el CLI de registros y la extensión de PHPStan responden a la misma pregunta: ¿cómo mantener comprensible un proyecto de Blockstudio a medida que crece?

Las herramientas de administración responden a nivel de proyecto: visibilidad de lo que está registrado, capacidad de incorporar bloques de registros y menos conjeturas.

CLI responde a nivel del ecosistema: una forma de compartir bloques entre proyectos y equipos sin incluirlos en paquetes de npm ni tener problemas con los sistemas de compilación.

La extensión de PHPStan responde a nivel del código: detecta accesos a campos incorrectos, errores tipográficos en esquemas y callbacks de hooks defectuosos antes de que lleguen al tiempo de ejecución.

Ese es, en general, el rumbo de la versión 7.2: menos conjeturas, menos repeticiones, más visibilidad y, ahora, seguridad real de tipos.

## Correcciones de errores

- **Campo Classes**: los nombres de clase personalizados introducidos por el usuario se descartaban silenciosamente al perder el foco porque el validador solo aceptaba clases de la lista predefinida de Tailwind/ajustes. Ahora acepta cualquier cadena no vacía.
- **Campo Attributes**: al eliminar un par de atributos quedaban entradas `null` en los datos guardados. Se cambió lodash `unset()` (que convierte los elementos del array en valores nulos) por `splice()` (que los elimina).
- **Minificador de CSS**: el minificador de TailwindPHP eliminaba los espacios en blanco alrededor de `+` dentro de `calc()` y `clamp()`, lo que generaba CSS no válido, como `calc(1rem+0.5vw)`. Se corrigió en TailwindPHP v1.3.1 mediante un recorrido de caracteres que tiene en cuenta la profundidad y solo elimina los espacios alrededor de los combinadores de selectores cuando la profundidad de los paréntesis es 0.
- **Vista previa del insertador de bloques**: `$isPreview` siempre aparecía como `false` en la vista previa del insertador de bloques porque la clave hash de la caché de renderizado no incluía el modo de renderizado. Ahora, las representaciones del editor y de la vista previa generan entradas de caché distintas.
- **Plantilla anidada de InnerBlocks**: el componente `<InnerBlocks template="..."/>` descartaba el tercer elemento (los elementos secundarios) de tuplas de plantilla como `['core/group', {}, [['core/paragraph']]]`, lo que generaba bloques contenedores vacíos. Ahora conserva los elementos secundarios anidados.
