
Blockstudio 7.2 breidt het framework tegelijk in twee richtingen uit.

De eerste is **zichtbaarheid en workflow** binnen één project: een nieuw beheeroverzicht, een databaseverkenner, een beheerregisterverkenner en SCSS-voorinstellingen voor een gedeelde Sass-configuratie.

De tweede betreft **het ecosysteem rond Blockstudio**: een register-CLI voor het verspreiden van blokken (zoals shadcn voor WordPress) en een extensie PHPStan die typeveiligheid in de stijl van TypeScript toevoegt aan sjablonen, bloktags, `db.php`, `rpc.php`, `cron.php` en de bijbehorende schemabestanden.

Beide richtingen hebben hetzelfde doel: grotere projecten met Blockstudio eenvoudiger te begrijpen, uit te breiden en te delen maken.

## Beheerervaring

Twee toevoegingen maken grotere projecten makkelijker te navigeren in wp-admin.

### Beheeroverzicht

Blockstudio wordt nu geleverd met een beheerscherm onder **Tools > Blockstudio**. Het biedt één plek om te bekijken wat het systeem vanuit het bestandssysteem heeft geregistreerd.

Het overzicht bevat aparte tabbladen voor:

- Blokken
- Extensies
- Velden
- Pagina's
- Schema's

Naast dat overzicht bevat het beheergedeelte nu een aparte sectie **Databases**. Die toont elk geregistreerd `Blockstudio\Db`-schema en laat je records rechtstreeks in wp-admin bekijken.

In plaats van een eigen raster met panelen te bouwen, gebruikt het scherm native WordPress-DataViews-tabellen. Zo blijft het UI in lijn met wp-admin en blijft het praktisch wanneer een project tientallen of honderden registraties bevat.

Bij een kleine installatie kun je de runtime-status in je hoofd bijhouden. Bij een grotere codebase lukt dat niet meer. Dan ga je vragen stellen zoals:

- Welke blokken zijn op dit moment daadwerkelijk geregistreerd?
- Op welke doelen richten extensies zich: `core/*` of afzonderlijke blokken?
- Welke pagina's zijn gesynchroniseerd en bij welke berichttypen horen ze?
- Welke herbruikbare velden bestaan er in dit project?
- Welke schema's zijn geregistreerd en welke opslagbackend gebruiken ze?

Tot nu toe vond je het antwoord door mappen te lezen, bestanden JSON te openen en door PHP te lopen. Het overzicht maakt hiervan een echt beheerscherm.

Elk tabblad is ontworpen om andere vragen te beantwoorden:

- **Blokken** toont geregistreerde bloktypen, de rendermodus, de API-versie en het aantal attributen
- **Extensies** toont op welke blokken ze gericht zijn, samen met prioriteit en rendergegevens
- **Velden** geeft een snel overzicht van herbruikbare definities van aangepaste velden
- **Pagina's** toont gesynchroniseerde pagina's op basis van bestanden, met berichttype, status, sjabloonengine en synchronisatiestatus
- **Schema's** toont geregistreerde opslagschema's met backend, aantal velden en capabilitybereik

De databasebrowser wordt bewust gescheiden gehouden van de initiële overzichtspayload. In plaats van elke rij bij het laden van de pagina te serialiseren, worden alleen de beschikbare schema's vooraf gelokaliseerd en records opgehaald wanneer u een databasetabblad opent. Zo blijft het beheergedeelte bruikbaar, ook wanneer een project grotere datasets achter `db.php` heeft.

Deze eerste versie is bewust gericht op registraties die op schema's zijn gebaseerd. Het is geen instellingenpagina. Het is een inspectiepagina.

Als u dit helemaal niet wilt, schakelt u het volledig uit:

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

### Browser voor beheerregisters

Naast het overzicht staat een tweede tabblad: **Register**. Dit is een browser voor externe blokregisters die zijn ingesteld in `blocks.json` van uw thema. U kunt er blokken rechtstreeks mee importeren vanuit de beheeromgeving van WordPress, zonder een CLI aan te raken.

```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}"
      }
    }
  }
}
```

De browser haalt elk ingesteld register op, geeft alle beschikbare blokken weer en laat zien of ze lokaal al zijn geïnstalleerd of kunnen worden geïmporteerd. Elke rij heeft een knop Importeren die de blokbestanden naar de ingestelde map van uw thema downloadt. Voor reeds geïnstalleerde blokken staat er in plaats daarvan een knop Opnieuw importeren.

Registers waarvoor verificatie nodig is, worden ondersteund via de objectindeling met `headers`, inclusief interpolatie van `${ENV_VAR}`, zodat tokens nooit in versiebeheer terechtkomen.

Zo wordt bladeren door registers en ze gebruiken een volwaardige beheerervaring, in plaats van alleen een CLI-workflow.

## Register CLI

De andere helft van het registerverhaal is een zelfstandige CLI: `blockstudio/registry`.

Het is een tool in shadcn-stijl voor blokken van WordPress. Geen npm-pakket en geen buildstap. U voert een opdracht uit, de broncode van het blok wordt naar uw project gekopieerd en u bent er volledig eigenaar van.

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

De CLI werkt met elk bloktype: Blockstudio-blokken, `@wordpress/create-block`-uitvoer en gewone PHP-blokken. Het register maakt niet uit wat er in de map staat. Het leest het bestandsmanifest uit `registry.json` en kopieert precies die bestanden.

Auteurs van blokken publiceren een `registry.json` op een willekeurige URL (ruwe inhoud van GitHub, S3 of een eigen server) met een lijst van beschikbare blokken, inclusief metadata, afhankelijkheden en bestandenlijsten. Gebruikers voegen het URL toe aan hun `blocks.json` en halen blokken op naam op.

De CLI ondersteunt:

- **Afhankelijkheden oplossen**: blokken kunnen afhankelijk zijn van andere blokken; deze worden automatisch opgelost, met detectie van cycli
- **Conflicten tussen meerdere registers afhandelen**: als een bloknaam in meerdere registers voorkomt, vraagt de CLI u er een te kiezen
- **Registers waarvoor verificatie nodig is**: tokens voor bearer-authenticatie, basisverificatie en aangepaste headers met interpolatie van omgevingsvariabelen
- **Interactieve TUI**: gebouwd met Ink, met laadanimaties, keuzemenu's en voortgangsindicatoren
- **Niet-interactieve modus**: de vlag `--yes` en automatische terugval voor CI en gepipete invoer
- **Zoeken en weergeven**: registers doorzoeken vanaf de opdrachtregel

Het pakket bevat 130 tests voor schema's, het oplossen van afhankelijkheden, het ophalen van HTTP, het schrijven van bestanden, alle opdrachtstromen en de interactieve Ink-UI.

Volledige documentatie: [blockstudio.dev/registry](https://blockstudio.dev/nl/registry/).

## Extensie voor PHPStan

De andere grote toevoeging is `blockstudio/phpstan`: een extensie voor PHPStan die gebruikers van Blockstudio de typeveiligheid biedt die ontwikkelaars van TypeScript verwachten.

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

De extensie leest tijdens de analyse de daadwerkelijke schema's van uw project en geeft de resulterende typen door aan PHPStan. Dit omvat nu PHP-templates, Twig, Blade, bloktags, getypeerde databaserecords, paden naar instellingen, hooknamen en schemavalidatie voor `block.json`, `field.json`, extensie-JSON, `page.json`, `db.php`, `rpc.php`, `cron.php` en `blockstudio.json`.

### Typeveilige bloktemplates

Veldtoegang via `$a` wordt gevalideerd aan de hand van de bijbehorende `block.json`:

```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"?
```

### Typeveilige databaserecords

`Db::get()` retourneert een getypeerde instantie op basis van uw `db.php`-schema. De recordstructuur wordt opgebouwd uit de daadwerkelijke velden:

```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}
```

### Schemavalidatie

Ongeldige schemabestanden worden tijdens de analyse opgespoord: `block.json`, `field.json`, extensie-JSON, `page.json`, `db.php`, `rpc.php`, `cron.php` en `blockstudio.json`. Ontbrekende namen, onjuiste veldtypen, verkeerd opgemaakte definities en verouderde verkorte booleans (`"tailwind": true` in plaats van het geneste object) worden allemaal gemeld met de exacte regel in het bronbestand.

### Validatie van paden naar instellingen

Aanroepen van `Settings::get()` worden gevalideerd aan de hand van het bekende instellingenschema:

```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"?
```

### Validatie van hooknamen

Hetzelfde geldt voor filter- en actiehooknamen:

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

De extensie bevat ook stubs voor de volledige openbare API van Blockstudio: `Db`, `Settings`, `Field_Registry`, `Build` en globale helpers. U krijgt automatisch aanvullen en typecontrole voor alle Blockstudio-API's, zonder dat de broncode van de plug-in op uw ontwikkelmachine nodig is.

## Handige functies voor auteurs

Twee kleinere verbeteringen voor auteurs maken de release compleet.

### Globale SCSS-preludes

Blockstudio ondersteunde compilatie van SCSS al, maar er was een vervelend knelpunt: gedeelde instellingen van Sass.

Als u toegang wilde tot een gemeenschappelijke set variabelen, functies of mixins, moest u ze in elk SCSS-bestand importeren. Dat wordt al snel repetitief, vooral bij grotere ontwerpsystemen of Sass-toolkits zoals Bootstrap.

Versie 7.2 voegt hiervoor een prelude-hook toe:

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

In combinatie met het bestaande `blockstudio/assets/process/scss/import_paths`-filter definieert u één keer een gedeelde Sass-interface die beschikbaar is in elk gecompileerd bestand.

Zo kan een blokstylesheet zich richten op de stijlen die het blok daadwerkelijk nodig heeft:

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

Geen herhaalde imports in elk blokbestand. Dit is geen speciale modus voor ondersteuning van "Bootstrap". Het is een algemene hook voor gedeelde Sass in een project, afkomstig van Bootstrap of van uw eigen interne toolkit.

### PHP-native definities van blok-API

Versie 7.2 voegt ook een optionele PHP-native syntaxis toe voor de full-stack-API's voor blokken. Arrays blijven de standaard en worden volledig ondersteund. Er is niets vervangen. Maar als u de voorkeur geeft aan benoemde argumenten, enums en attributen in plaats van geneste configuratiearrays, kunt u nu voor die stijl kiezen.

Geef voor `rpc.php` een object met methoden die attributen hebben terug:

```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'];
    }
};
```

Voor `cron.php` werkt hetzelfde idee met `#[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 {
    }
};
```

En voor `db.php` is er nu een kleine builderlaag:

```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),
    ],
);
```

Dit biedt een betere balans voor grotere codebases. U behoudt de eenvoud van de array-indeling wanneer u die wilt en kunt overstappen op een beter verkenbare PHP-interface wanneer een blok meer dan een handvol velden of eindpunten krijgt.

## Waarom deze functies samen worden uitgebracht

Het beheeroverzicht, de registerbrowser, de register-CLI en de extensie PHPStan beantwoorden allemaal dezelfde vraag: hoe houdt u een Blockstudio-project begrijpelijk naarmate het groeit?

De beheerhulpmiddelen bieden inzicht op projectniveau: zicht op wat er is geregistreerd, de mogelijkheid om blokken uit registers op te halen en minder giswerk.

De CLI biedt een oplossing op ecosysteemniveau: een manier om blokken te delen tussen projecten en teams, zonder ze in npm-pakketten op te nemen of met buildsysteemproblemen te worstelen.

De extensie PHPStan biedt een oplossing op codeniveau: detecteer onjuiste veldtoegang, typefouten in schema's en gebroken hook-callbacks voordat ze tijdens runtime problemen veroorzaken.

Dat is in grote lijnen de richting van versie 7.2: minder giswerk, minder herhaling, beter inzicht en nu ook echte typeveiligheid.

## Opgeloste bugs

- **Veld Classes**: door de gebruiker ingevoerde aangepaste klassennamen verdwenen ongemerkt bij het verlaten van het veld, omdat de validator alleen klassen uit de vooraf gedefinieerde lijst Tailwind/instellingen accepteerde. Accepteert nu elke niet-lege tekenreeks.
- **Veld Attributes**: na het verwijderen van een attribuutpaar bleven `null`-items achter in de opgeslagen gegevens. Overgestapt van lodash `unset()` (dat array-elementen op null zet) naar `splice()` (dat ze verwijdert).
- **CSS-minifier**: de TailwindPHP-minifier verwijderde witruimte rond `+` binnen `calc()` en `clamp()`, wat ongeldige CSS opleverde, zoals `calc(1rem+0.5vw)`. Dit is upstream opgelost in TailwindPHP v1.3.1 met een teken-voor-teken doorloop die rekening houdt met de nestingdiepte en alleen witruimte rond selectorcombinatoren op haakjesdiepte 0 verwijdert.
- **Voorbeeld in Block Inserter**: `$isPreview` was altijd `false` in het voorbeeld in Block Inserter, omdat de weergavemodus niet was opgenomen in de hash-sleutel van de rendercache. Weergaven in de editor en in het voorbeeld krijgen nu afzonderlijke cache-items.
- **Geneste InnerBlocks-template**: de component `<InnerBlocks template="..."/>` liet het derde element (kinderen) weg uit template-tuples zoals `['core/group', {}, [['core/paragraph']]]`, waardoor lege containerblokken ontstonden. Geneste kinderen blijven nu behouden.
