
Blockstudio 7.2 udvider frameworket i to retninger på én gang.

Den første retning handler om **overblik og arbejdsgange** i et enkelt projekt: et nyt adminoverblik, en databasebrowser, en adminbrowser til registre og SCSS-forudindstillinger til fælles Sass-opsætning.

Den anden retning handler om **økosystemet omkring Blockstudio**: en register-CLI til distribution af blokke (som shadcn til WordPress) og en PHPStan-udvidelse, der giver skabeloner, bloktags, `db.php`, `rpc.php`, `cron.php` og de tilhørende skemafiler typesikkerhed i TypeScript-stil.

Begge retninger handler om det samme: at gøre større Blockstudio-projekter lettere at forstå, videreudvikle og dele.

## Adminoplevelse

To tilføjelser gør det lettere at navigere i større projekter i wp-admin.

### Adminoverblik

Blockstudio leveres nu med en administrationsskærm under **Værktøjer > Blockstudio**. Her kan du ét sted undersøge, hvad systemet har registreret fra filsystemet.

Overblikket har dedikerede faner for:

- Blokke
- Udvidelser
- Felter
- Sider
- Skemaer

Ud over dette overblik indeholder adminområdet nu også en dedikeret sektion for **databaser**. Den viser alle registrerede `Blockstudio\Db`-skemaer og lader dig undersøge faktiske poster direkte i wp-admin.

I stedet for at bygge et brugerdefineret gitter af paneler bruger skærmen de indbyggede WordPress DataViews-tabeller. Det holder UI på linje med wp-admin og gør løsningen praktisk, når et projekt har snesevis eller hundredvis af registreringer.

På en lille installation kan du holde styr på runtime-tilstanden i hovedet. I en større kodebase fungerer det ikke længere. Du begynder at stille spørgsmål som:

- Hvilke blokke er faktisk registreret lige nu?
- Hvilke udvidelser er målrettet mod `core/*`, og hvilke er målrettet mod enkelte blokke?
- Hvilke sider er synkroniseret, og hvilke indlægstyper hører de til?
- Hvilke genbrugelige felter findes i projektet?
- Hvilke skemaer er registreret, og hvilken lagerbackend bruger de?

Indtil nu fandt man svaret ved at læse mapper, åbne JSON-filer og gennemgå PHP. Overblikket gør det til en rigtig administrationsflade.

Hver fane er udformet til at besvare forskellige spørgsmål:

- **Blokke** viser registrerede bloktyper, rendertilstand, API-version og antal attributter
- **Udvidelser** viser, hvilke blokke de er målrettet mod, samt prioritet og renderdetaljer
- **Felter** giver et hurtigt overblik over genbrugelige definitioner af brugerdefinerede felter
- **Sider** viser synkroniserede filbaserede sider med indlægstype, status, skabelonmotor og synkroniseringstilstand
- **Skemaer** viser registrerede lagerskemaer med backend, antal felter og capability-omfang

Databasebrowseren holdes bevidst adskilt fra den indledende oversigtspayload. I stedet for at serialisere hver række ved sideindlæsning lokaliserer den kun de tilgængelige skemaer på forhånd og henter poster efter behov, når du åbner en databasetab. Det holder administrationsfladen nyttig, selv når et projekt har større datasæt bag `db.php`.

Denne første version fokuserer bevidst på skemabaserede registreringer. Det er ikke en indstillingsside. Det er en inspektionsside.

Hvis du slet ikke ønsker den, kan du deaktivere den helt:

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

### Browser til administrationsregistre

Ved siden af oversigten findes en anden fane: **Registry**. Det er en browser til eksterne blokregistre, der er konfigureret i dit temas `blocks.json`, og den lader dig importere blokke direkte fra WordPress-administrationen uden at røre en 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}"
      }
    }
  }
}
```

Browseren henter hvert konfigureret register, viser alle tilgængelige blokke og angiver, om de allerede er installeret lokalt eller kan importeres. Hver række har en Import-knap, der downloader blokkens filer til den konfigurerede mappe i dit tema. Blokke, der allerede er installeret, får i stedet en Reimport-knap.

Registre med godkendelse understøttes via objektformatet med `headers`, herunder interpolation af `${ENV_VAR}`, så tokens aldrig ender i versionsstyring.

Det gør browsing og brug af registre til en førsteklasses oplevelse i administrationen, ikke blot et CLI-workflow.

## Registry CLI

Den anden del af registerhistorien er en selvstændig CLI: `blockstudio/registry`.

Det er et shadcn-lignende værktøj til WordPress-blokke. Ingen npm-pakke, intet byggetrin. Du kører en kommando, blokkens kildekode kopieres ind i dit projekt, og du ejer den fuldt ud.

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

CLI fungerer med alle bloktyper: Blockstudio-blokke, `@wordpress/create-block`-output, almindelige PHP-blokke. Registret er ligeglad med, hvad mappen indeholder. Det læser fillisten fra `registry.json` og kopierer præcis de filer.

Blokforfattere udgiver en `registry.json` på en vilkårlig URL (GitHub råt indhold, S3, en brugerdefineret server), der angiver deres tilgængelige blokke med metadata, afhængigheder og fillister. Brugere føjer URL til deres `blocks.json` og henter blokke efter navn.

CLI understøtter:

- **Afhængighedsopløsning**: Blokke kan angive afhængigheder til andre blokke, som løses automatisk med registrering af cyklusser
- **Håndtering af konflikter på tværs af registre**: Når samme bloknavn findes i flere registre, beder CLI dig om at vælge et
- **Registre med godkendelse**: Bearer-tokens, basisgodkendelse og brugerdefinerede headere med interpolation af miljøvariabler
- **Interaktiv TUI**: Bygget med Ink med statusindikatorer, valgprompter og statusvisninger
- **Ikke-interaktiv tilstand**: Flaget `--yes` og automatisk reservefunktion til CI/pipes
- **Søgning og oversigt**: Gennemse registre fra kommandolinjen

Pakken indeholder 130 tests, der dækker skemaer, afhængighedsopløsning, hentning af HTTP, filskrivning, alle kommandoforløb og den interaktive Ink-UI.

Se den fulde dokumentation på [blockstudio.dev/registry](https://blockstudio.dev/da/registry/).

## Udvidelse til PHPStan

Den anden store tilføjelse er `blockstudio/phpstan`: en PHPStan-udvidelse, der giver Blockstudio-brugere den typesikkerhed, TypeScript-udviklere forventer.

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

Udvidelsen læser dit projekts faktiske skemaer under analysen og sender de resulterende typer tilbage til PHPStan. Nu dækkes PHP-skabeloner, Twig, Blade, bloktags, typede databaseposter, indstillingsstier, hooknavne og skemavalidering på tværs af `block.json`, `field.json`, udvidelses-JSON, `page.json`, `db.php`, `rpc.php`, `cron.php` og `blockstudio.json`.

### Typesikre blokskabeloner

Feltadgange på `$a` valideres mod det tilhørende `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"?
```

### Typesikre databaseposter

`Db::get()` returnerer en typet instans baseret på dit `db.php`-skema. Postens form opbygges ud fra de faktiske felter:

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

### Skemavalidering

Ugyldige skemafiler fanges under analysen: `block.json`, `field.json`, udvidelses-JSON, `page.json`, `db.php`, `rpc.php`, `cron.php` og `blockstudio.json`. Manglende navne, forkerte felttyper, fejlformede definitioner og forældede booleske kortformer (`"tailwind": true` i stedet for det indlejrede objekt) rapporteres alle med den præcise linje i kildefilen.

### Validering af indstillingsstier

`Settings::get()`-kald valideres mod det kendte indstillingsskema:

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

### Validering af hooknavne

Det samme gælder filter- og action-hooknavne:

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

Udvidelsen indeholder også stubs til hele Blockstudios offentlige API: `Db`, `Settings`, `Field_Registry`, `Build` og globale hjælpefunktioner. Du får autofuldførelse og typekontrol for alle Blockstudio-API'er uden at skulle have pluginets kildekode på din udviklingsmaskine.

## Hjælp til udvikling

To mindre forbedringer til udviklingen fuldender udgivelsen.

### Globale SCSS-forudindstillinger

Blockstudio understøttede allerede kompilering af SCSS, men der var ét irriterende friktionspunkt: fælles opsætning af Sass.

Hvis du ville have adgang til et fælles sæt variabler, funktioner eller mixins, skulle du importere dem i hver SCSS-fil. Det bliver hurtigt gentagende, især med større designsystemer eller Sass-værktøjssæt som Bootstrap.

7.2 tilføjer en forudindstillingshook til netop det:

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

Sammen med det eksisterende `blockstudio/assets/process/scss/import_paths`-filter definerer du én gang en fælles Sass-overflade, som derefter er tilgængelig i alle kompilerede filer.

Et blokstilark kan fokusere på de konkrete typografier, det har brug for:

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

Ingen gentagne importer i hvert blokasset. Det er ikke "Bootstrap-understøttelse" som en særlig tilstand. Det er en generisk hook til fælles Sass på tværs af et projekt, uanset om det kommer fra Bootstrap eller dit eget interne værktøjssæt.

### PHP-native definitioner af blok-API

7.2 tilføjer også en valgfri PHP-native syntaks til API'erne for full-stack-blokke. Arrayer er fortsat standard og fuldt understøttet. Intet er blevet erstattet. Men hvis du foretrækker navngivne argumenter, enums og attributter frem for indlejrede konfigurationsarrayer, kan du nu vælge den stil.

For `rpc.php` skal du returnere et objekt med metoder forsynet med attributter:

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

For `cron.php` fungerer samme idé med `#[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 {
    }
};
```

Og for `db.php` findes der nu et lille builderlag:

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

Det giver en bedre balance i større kodebaser. Du beholder enkelheden ved arrayformatet, når du ønsker det, og kan skifte til en mere overskuelig PHP-overflade, når en blok vokser ud over en håndfuld felter eller endepunkter.

## Hvorfor disse ting udgives sammen

Administrationsoversigten, registerbrowseren, registry-CLI og PHPStan-udvidelsen besvarer alle det samme spørgsmål: Hvordan holder man et Blockstudio-projekt overskueligt, efterhånden som det vokser?

Administrationsværktøjerne besvarer det på projektniveau: overblik over, hvad der er registreret, mulighed for at hente blokke fra registre og mindre gætværk.

CLI besvarer det på økosystemniveau: en måde at dele blokke mellem projekter og teams på uden at samle dem i npm-pakker eller kæmpe med byggesystemer.

Udvidelsen til PHPStan besvarer det på kodeniveau: Den fanger forkerte feltadgange, skemafejl og ødelagte hook-callbacks, før de rammer kørslen.

Det er den generelle retning for 7.2: mindre gætværk, mindre gentagelse, bedre overblik og nu også reel typesikkerhed.

## Fejlrettelser

- **Feltet Classes**: Brugerdefinerede klassenavne, som brugeren indtastede, blev lydløst fjernet ved fokusændring, fordi validatoren kun accepterede klasser fra den foruddefinerede liste over Tailwind/indstillinger. Accepterer nu alle ikke-tomme strenge.
- **Feltet Attributes**: Fjernelse af et attributpar efterlod `null`-poster i de gemte data. Skiftede fra Lodash `unset()` (som sætter arrayelementer til null) til `splice()` (som fjerner dem).
- **CSS-minificering**: Minificeringen af TailwindPHP fjernede mellemrum omkring `+` i `calc()` og `clamp()` og skabte ugyldig CSS som `calc(1rem+0.5vw)`. Rettet upstream i TailwindPHP v1.3.1 med en dybdebevidst tegngennemgang, der kun fjerner mellemrum omkring selektorkombinatorer ved parentesdybde 0.
- **Forhåndsvisning i Block Inserter**: `$isPreview` var altid `false` i forhåndsvisningen i Block Inserter, fordi rendercachen ikke inkluderede renderingstilstanden i sin hashnøgle. Editor- og forhåndsvisningsrenderinger har nu separate cacheposter.
- **Indlejret InnerBlocks-skabelon**: Komponenten `<InnerBlocks template="..."/>` fjernede det tredje element (børn) fra skabelontupler som `['core/group', {}, [['core/paragraph']]]` og oprettede tomme containerblokke. Bevarer nu indlejrede børn.
