
Blockstudio 7.2 erweitert das Framework in zwei Richtungen zugleich.

Die erste betrifft **Transparenz und Arbeitsabläufe** innerhalb eines einzelnen Projekts: eine neue Admin-Übersicht, einen Datenbank-Browser, einen Registry-Browser für Admins und SCSS-Preludes für ein gemeinsames Sass-Setup.

Die zweite betrifft **das Ökosystem rund um Blockstudio**: einen Registry CLI zum Verteilen von Blöcken (wie shadcn für WordPress) und eine PHPStan-Erweiterung, die Typsicherheit nach dem Vorbild von TypeScript für Vorlagen, Block-Tags, `db.php`, `rpc.php`, `cron.php` und die zugehörigen Schema-Dateien ermöglicht.

Beide Richtungen verfolgen dasselbe Ziel: größere Blockstudio-Projekte verständlicher zu machen, ihre Weiterentwicklung zu erleichtern und das Teilen zu ermöglichen.

## Admin-Erfahrung

Zwei Neuerungen erleichtern die Navigation in größeren Projekten innerhalb von wp-admin.

### Admin-Übersicht

Blockstudio enthält jetzt einen Admin-Bildschirm unter **Werkzeuge > Blockstudio**. Dort kannst du zentral prüfen, was das System im Dateisystem registriert hat.

Die Übersicht bietet eigene Tabs für:

- Blöcke
- Erweiterungen
- Felder
- Seiten
- Schemas

Zusätzlich zur Übersicht gibt es im Admin-Bereich jetzt einen eigenen Abschnitt **Datenbanken**. Er listet alle registrierten `Blockstudio\Db`-Schemas auf und ermöglicht es dir, Datensätze direkt in wp-admin einzusehen.

Statt ein eigenes Raster aus Bedienfeldern zu erstellen, verwendet die Ansicht die nativen WordPress-DataViews-Tabellen. So ist die UI an wp-admin angepasst und bleibt auch bei Dutzenden oder Hunderten von Registrierungen praxistauglich.

Bei einer kleinen Installation kannst du den Laufzeitzustand im Kopf behalten. Bei einer größeren Codebasis funktioniert das nicht mehr. Dann stellst du dir Fragen wie:

- Welche Blöcke sind gerade tatsächlich registriert?
- Welche Erweiterungen zielen auf `core/*` und welche auf einzelne Blöcke?
- Welche Seiten sind synchronisiert und zu welchen Beitragstypen gehören sie?
- Welche wiederverwendbaren Felder gibt es in diesem Projekt?
- Welche Schemas sind registriert und welches Speicher-Backend verwenden sie?

Bisher musstest du dafür Ordner durchsuchen, JSON-Dateien öffnen und dich durch PHP arbeiten. Mit der Übersicht erhältst du dafür eine eigene Admin-Oberfläche.

Jeder Tab beantwortet andere Fragen:

- **Blöcke** zeigen registrierte Blocktypen, den Render-Modus, die API-Version und die Anzahl der Attribute
- **Erweiterungen** zeigen, auf welche Blöcke sie zielen, sowie Priorität und Rendering-Details
- **Felder** bieten eine Übersicht über wiederverwendbare Definitionen benutzerdefinierter Felder
- **Seiten** zeigen synchronisierte dateibasierte Seiten mit Beitragstyp, Status, Vorlagen-Engine und Synchronisierungsstatus
- **Schemas** zeigen registrierte Speicher-Schemas mit Backend, Feldanzahl und Berechtigungsumfang

Der Datenbank-Browser wird bewusst getrennt von der anfänglichen Übersichts-Payload gehalten. Statt beim Laden der Seite jede Zeile zu serialisieren, ermittelt er zunächst nur die verfügbaren Schemas und ruft Datensätze bei Bedarf ab, wenn du einen Datenbank-Tab öffnest. So bleibt die Admin-Oberfläche auch bei größeren Datensätzen hinter `db.php` nützlich.

Diese erste Version konzentriert sich bewusst auf schema-basierte Registrierungen. Sie ist keine Einstellungsseite, sondern eine Inspektionsseite.

Wenn du sie gar nicht möchtest, deaktiviere sie vollständig:

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

### Admin-Registry-Browser

Neben der Übersicht gibt es einen zweiten Tab: **Registry**. Er dient zum Durchsuchen entfernter Block-Registries, die in `blocks.json` deines Themes konfiguriert sind, und ermöglicht dir, Blöcke direkt aus dem Admin von WordPress zu importieren, ohne eine CLI anzufassen.

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

Der Browser ruft jede konfigurierte Registry ab, listet alle verfügbaren Blöcke auf und zeigt, ob sie bereits lokal installiert oder zum Import verfügbar sind. Jede Zeile enthält eine Schaltfläche „Importieren“, die die Blockdateien in das konfigurierte Verzeichnis deines Themes herunterlädt. Für bereits installierte Blöcke gibt es stattdessen die Schaltfläche „Erneut importieren“.

Authentifizierte Registries werden über das Objektformat mit `headers` unterstützt, einschließlich `${ENV_VAR}`-Interpolation, damit Tokens niemals in die Versionskontrolle gelangen.

So wird das Durchsuchen und Verwenden von Registries zu einem erstklassigen Admin-Erlebnis und bleibt nicht nur ein CLI-Workflow.

## Registry CLI

Die andere Seite der Registry-Geschichte ist ein eigenständiges CLI: `blockstudio/registry`.

Es ist ein Tool im Stil von shadcn für WordPress-Blöcke. Kein npm-Paket, kein Build-Schritt. Du führst einen Befehl aus, der Block-Quellcode wird in dein Projekt kopiert und gehört vollständig dir.

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

Das CLI funktioniert mit jedem Blocktyp: Blockstudio-Blöcken, `@wordpress/create-block`-Ausgabe und einfachen PHP-Blöcken. Der Registry ist egal, was sich im Ordner befindet. Sie liest das Dateimanifest aus `registry.json` und kopiert genau diese Dateien.

Block-Autoren veröffentlichen ein `registry.json` unter einer beliebigen URL (GitHub-Rohinhalt, S3 oder ein eigener Server), das verfügbare Blöcke samt Metadaten, Abhängigkeiten und Dateilisten aufführt. Nutzer fügen das URL zu ihrem `blocks.json` hinzu und rufen Blöcke anhand ihres Namens ab.

Das CLI unterstützt:

- **Abhängigkeitsauflösung**: Blöcke können Abhängigkeiten von anderen Blöcken angeben, die automatisch und mit Zyklenerkennung aufgelöst werden
- **Konfliktbehandlung bei mehreren Registries**: Wenn derselbe Blockname in mehreren Registries vorkommt, fordert dich das CLI auf, eine auszuwählen
- **Authentifizierte Registries**: Bearer-Tokens, Basic Auth und benutzerdefinierte Header mit Interpolation von Umgebungsvariablen
- **Interaktive TUI**: mit Ink erstellt, mit Ladeanzeigen, Auswahlaufforderungen und Fortschrittsanzeigen
- **Nicht-interaktiver Modus**: `--yes`-Flag und automatischer Fallback für CI und weitergeleitete Eingaben
- **Suchen und Auflisten**: Registries über die Befehlszeile durchsuchen

Das Paket enthält 130 Tests für Schemas, Abhängigkeitsauflösung, HTTP-Abrufe, das Schreiben von Dateien, alle Befehlsabläufe und die interaktive Ink-UI.

Die vollständige Dokumentation findest du unter [blockstudio.dev/registry](https://blockstudio.dev/de/registry/).

## PHPStan-Erweiterung

Die andere große Neuerung ist `blockstudio/phpstan`: eine PHPStan-Erweiterung, die Blockstudio-Nutzern die Art von Typsicherheit bietet, die TypeScript-Entwickler erwarten.

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

Die Erweiterung liest die tatsächlichen Schemas deines Projekts während der Analyse ein und übergibt die daraus abgeleiteten Typen an PHPStan. Abgedeckt werden jetzt PHP-Templates, Twig, Blade, Block-Tags, typisierte Datenbankdatensätze, Einstellungspfade, Hook-Namen und die Schema-Validierung für `block.json`, `field.json`, Erweiterungs-JSON, `page.json`, `db.php`, `rpc.php`, `cron.php` und `blockstudio.json`.

### Typsichere Block-Templates

Feldzugriffe auf `$a` werden anhand des zugehörigen `block.json` validiert:

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

### Typsichere Datenbankdatensätze

`Db::get()` gibt eine typisierte Instanz zurück, die auf deinem `db.php`-Schema basiert. Die Form des Datensatzes wird aus den tatsächlichen Feldern erstellt:

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

### Schema-Validierung

Ungültige Schema-Dateien werden während der Analyse erkannt: `block.json`, `field.json`, Erweiterungs-JSON, `page.json`, `db.php`, `rpc.php`, `cron.php` und `blockstudio.json`. Fehlende Namen, falsche Feldtypen, fehlerhafte Definitionen und veraltete Kurzschreibweisen für boolesche Werte (`"tailwind": true` statt des verschachtelten Objekts) werden alle mit der genauen Zeile in der Quelldatei gemeldet.

### Validierung von Einstellungspfaden

`Settings::get()`-Aufrufe werden anhand des bekannten Einstellungsschemas validiert:

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

### Validierung von Hook-Namen

Dasselbe gilt für die Namen von Filter- und Action-Hooks:

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

Die Erweiterung enthält außerdem Stubs für die gesamte öffentliche Blockstudio-API: `Db`, `Settings`, `Field_Registry`, `Build` und globale Hilfsfunktionen. Du erhältst Autovervollständigung und Typprüfung für alle Blockstudio-APIs, ohne den Plugin-Quellcode auf deinem Entwicklungsrechner zu benötigen.

## Erleichterungen beim Entwickeln

Zwei kleinere Erleichterungen beim Entwickeln runden die Veröffentlichung ab.

### Globale SCSS-Preludes

Blockstudio unterstützte bereits die SCSS-Kompilierung, doch es gab einen lästigen Reibungspunkt: gemeinsame Sass-Konfiguration.

Wenn du auf gemeinsame Variablen, Funktionen oder Mixins zugreifen wolltest, musstest du sie in jede SCSS-Datei importieren. Das wird schnell repetitiv, besonders bei größeren Designsystemen oder Sass-Toolkits wie Bootstrap.

7.2 ergänzt genau dafür einen Prelude-Hook:

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

Zusammen mit dem bestehenden `blockstudio/assets/process/scss/import_paths`-Filter definierst du eine gemeinsame Sass-Oberfläche einmal und stellst sie jeder kompilierten Datei zur Verfügung.

Ein Block-Stylesheet kann sich auf die tatsächlich benötigten Stile konzentrieren:

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

Keine wiederholten Importe in jedem Block-Asset. Das ist kein spezieller „Bootstrap-Support-Modus“, sondern ein allgemeiner Hook für gemeinsames Sass im ganzen Projekt – egal, ob es von Bootstrap oder deinem eigenen internen Toolkit stammt.

### PHP-native Block-API-Definitionen

7.2 ergänzt außerdem eine optionale PHP-native Syntax für die Full-Stack-Block-APIs. Arrays bleiben der Standard und werden weiterhin vollständig unterstützt. Es wurde nichts ersetzt. Wenn du aber benannte Argumente, Enums und Attribute verschachtelten Konfigurations-Arrays vorziehst, kannst du jetzt diesen Stil wählen.

Für `rpc.php` gib ein Objekt mit attributierten Methoden zurück:

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

Für `cron.php` funktioniert dasselbe Prinzip mit `#[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 {
    }
};
```

Und für `db.php` gibt es jetzt eine kleine Builder-Schicht:

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

Das schafft eine bessere Balance für größere Codebasen. Du behältst die Einfachheit des Array-Formats, wenn du möchtest, und kannst zu einer besser erschließbaren PHP-Oberfläche wechseln, sobald ein Block mehr als eine Handvoll Felder oder Endpunkte umfasst.

## Warum diese Neuerungen zusammen veröffentlicht werden

Die Admin-Übersicht, der Registry-Browser, das Registry-CLI und die PHPStan-Erweiterung beantworten alle dieselbe Frage: Wie bleibt ein Blockstudio-Projekt verständlich, während es wächst?

Die Admin-Tools beantworten sie auf Projektebene: Sie zeigen, was registriert ist, ermöglichen das Abrufen von Blöcken aus Registries und verringern den Interpretationsspielraum.

Das CLI beantwortet sie auf Ökosystemebene: Es bietet eine Möglichkeit, Blöcke zwischen Projekten und Teams zu teilen, ohne sie in npm-Pakete zu bündeln oder mit Build-Systemen zu kämpfen.

Die PHPStan-Erweiterung beantwortet sie auf Codeebene: Sie erkennt falsche Feldzugriffe, Schema-Tippfehler und fehlerhafte Hook-Callbacks, bevor sie zur Laufzeit auftreten.

Das ist allgemein die Richtung von 7.2: weniger Interpretationsspielraum, weniger Wiederholungen, bessere Übersicht und jetzt echte Typsicherheit.

## Fehlerbehebungen

- **Klassenfeld**: Vom Nutzer eingegebene benutzerdefinierte Klassennamen wurden beim Verlassen des Felds unbemerkt verworfen, weil der Validator nur Klassen aus der vordefinierten Tailwind-/Einstellungsliste akzeptierte. Akzeptiert jetzt jede nicht leere Zeichenfolge.
- **Attributfeld**: Beim Entfernen eines Attributpaars blieben `null`-Einträge in den gespeicherten Daten zurück. Der lodash-Operator `unset()` (der Array-Elemente auf null setzt) wurde durch `splice()` ersetzt (der sie entfernt).
- **CSS-Minimierer**: Der TailwindPHP-Minimierer entfernte Leerzeichen um `+` innerhalb von `calc()` und `clamp()` und erzeugte dadurch ungültiges CSS wie `calc(1rem+0.5vw)`. Im Upstream in TailwindPHP v1.3.1 behoben: Ein zeichenweiser Durchlauf mit Tiefenerkennung entfernt Leerzeichen nur bei Selektor-Kombinatoren auf Klammerungstiefe 0.
- **Vorschau im Block-Inserter**: `$isPreview` war in der Vorschau des Block-Inserters immer `false`, weil der Render-Cache den Rendering-Modus nicht in seinem Hash-Schlüssel berücksichtigte. Editor- und Vorschau-Renderings erhalten jetzt getrennte Cache-Einträge.
- **Verschachteltes InnerBlocks-Template**: Die Komponente `<InnerBlocks template="..."/>` ließ bei Template-Tupeln wie `['core/group', {}, [['core/paragraph']]]` das 3. Element (Kinder) weg und erzeugte dadurch leere Container-Blöcke. Verschachtelte Kinder bleiben jetzt erhalten.
