
Blockstudio 7.2 utökar ramverket i två riktningar samtidigt.

Den första handlar om **överblick och arbetsflöde** i ett enskilt projekt: en ny adminöversikt, en databasbläddrare, en registerbläddrare för admin och SCSS-preludier för gemensam Sass-konfiguration.

Den andra handlar om **ekosystemet kring Blockstudio**: ett register-CLI för distribution av block (som shadcn för WordPress) och ett tillägg PHPStan som ger typsäkerhet av TypeScript-typ till mallar, blocktaggar, `db.php`, `rpc.php`, `cron.php` och tillhörande schemafiler.

Båda riktningarna handlar om samma sak: att göra större Blockstudio-projekt lättare att förstå, bygga vidare på och dela.

## Adminupplevelse

Två tillägg gör det lättare att navigera i större projekt i wp-admin.

### Adminöversikt

Blockstudio levereras nu med en adminskärm under **Verktyg > Blockstudio**. Där får du en samlad plats för att granska vad systemet har registrerat från filsystemet.

Översikten har särskilda flikar för:

- Block
- Tillägg
- Fält
- Sidor
- Scheman

Utöver översikten har adminområdet nu ett särskilt avsnitt för **Databaser**. Det listar alla registrerade `Blockstudio\Db`-scheman och låter dig granska faktiska poster direkt i wp-admin.

I stället för att bygga ett eget rutnät av paneler använder skärmen inbyggda WordPress DataViews-tabeller. Det håller UI i linje med wp-admin och gör lösningen praktisk även när ett projekt har dussintals eller hundratals registreringar.

På en liten installation kan du hålla reda på körningstillståndet i huvudet. I en större kodbas fungerar det inte längre. Då börjar du ställa frågor som:

- Vilka block är faktiskt registrerade just nu?
- Vilka tillägg riktar sig till `core/*` och vilka till enskilda block?
- Vilka sidor är synkroniserade och vilka inläggstyper tillhör de?
- Vilka återanvändbara fält finns i projektet?
- Vilka scheman är registrerade och vilken lagringsbackend använder de?

Hittills har svaret varit en kombination av att läsa mappar, öppna JSON-filer och följa PHP steg för steg. Översikten gör detta till en faktisk adminvy.

Varje flik är utformad för att besvara olika frågor:

- **Block** visar registrerade blocktyper, renderingsläge, version av API och antal attribut
- **Tillägg** visar vilka block de riktar sig till samt prioritet och renderingsinformation
- **Fält** ger en snabb översikt över återanvändbara definitioner av anpassade fält
- **Sidor** visar synkroniserade filbaserade sidor med inläggstyp, status, mallmotor och synkroniseringstillstånd
- **Scheman** visar registrerade lagringsscheman med backend, antal fält och behörighetsomfattning

Databasbläddraren hålls avsiktligt separat från den inledande översiktens nyttolast. I stället för att serialisera varje rad vid sidinläsning lokaliserar den bara de tillgängliga schemana i förväg och hämtar poster vid behov när du öppnar en databask flik. Det gör att administrationsvyn förblir användbar även när ett projekt har större datamängder bakom `db.php`.

Den här första versionen fokuserar avsiktligt på schemabaserade registreringar. Det är ingen inställningssida. Det är en inspektionssida.

Om du inte vill ha den alls kan du inaktivera den helt:

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

### Bläddrare för adminregister

Bredvid översikten finns en andra flik: **Register**. Det är en bläddrare för fjärrregister för block som konfigurerats i ditt temas `blocks.json`, och den låter dig importera block direkt från WordPress-administrationen utan att röra 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}"
      }
    }
  }
}
```

Bläddraren hämtar varje konfigurerat register, listar alla tillgängliga block och visar om de redan är installerade lokalt eller kan importeras. Varje rad har en Importera-knapp som hämtar blockfilerna till den katalog som konfigurerats för ditt tema. Block som redan är installerade får i stället en Importera igen-knapp.

Autentiserade register stöds via objektformatet med `headers`, inklusive interpolation av `${ENV_VAR}` så att token aldrig hamnar i versionshanteringen.

Det gör bläddring bland och användning av register till en förstklassig upplevelse i administrationen, inte bara ett arbetsflöde i CLI.

## Register-CLI

Den andra delen av registerlösningen är ett fristående CLI: `blockstudio/registry`.

Det är ett verktyg i shadcn-stil för WordPress-block. Inget npm-paket, inget byggsteg. Du kör ett kommando, blockets källkod kopieras till ditt projekt och du äger det helt.

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

CLI fungerar med alla typer av block: Blockstudio-block, `@wordpress/create-block`-utdata och vanliga PHP-block. Registret bryr sig inte om vad mappen innehåller. Det läser fillistan från `registry.json` och kopierar exakt de filerna.

Blockförfattare publicerar en `registry.json` på valfri URL (GitHub-råinnehåll, S3 eller en anpassad server) med en lista över tillgängliga block, metadata, beroenden och fillistor. Användare lägger till URL i sin `blocks.json` och hämtar block efter namn.

CLI har stöd för:

- **Beroendehantering**: block kan ange beroenden till andra block, som löses automatiskt med cykeldetektering
- **Hantering av konflikter mellan flera register**: när samma blocknamn finns i flera register uppmanar CLI dig att välja ett
- **Autentiserade register**: bearer-token, grundläggande autentisering och anpassade headers med interpolation av miljövariabler
- **Interaktivt TUI**: byggt med Ink, med laddningsindikatorer, valfrågor och förloppsindikatorer
- **Icke-interaktivt läge**: flaggan `--yes` och automatisk reservlösning för CI och pipade kommandon
- **Sökning och listning**: bläddra bland register från kommandoraden

Paketet innehåller 130 tester som täcker scheman, beroendehantering, hämtning av HTTP, filskrivning, alla kommandoflöden och det interaktiva Ink-UI.

Fullständig dokumentation finns i [blockstudio.dev/registry](https://blockstudio.dev/sv/registry/).

## Tillägg för PHPStan

Det andra stora tillskottet är `blockstudio/phpstan`: ett PHPStan-tillägg som ger Blockstudio-användare den typsäkerhet som TypeScript-utvecklare förväntar sig.

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

Tillägget läser projektets faktiska scheman vid analys och för in de resulterande typerna i PHPStan. Det omfattar nu PHP-mallar, Twig, Blade, blocktaggar, typade databasposter, inställningssökvägar, hooknamn och schemavalidering för `block.json`, `field.json`, tilläggs-JSON, `page.json`, `db.php`, `rpc.php`, `cron.php` och `blockstudio.json`.

### Typsäkra blockmallar

Fältåtkomst på `$a` valideras mot tillhörande `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"?
```

### Typsäkra databasposter

`Db::get()` returnerar en typad instans baserad på ditt `db.php`-schema. Postens struktur byggs från de faktiska fälten:

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

### Schemavalidering

Ogiltiga schemafiler upptäcks vid analys: `block.json`, `field.json`, tilläggs-JSON, `page.json`, `db.php`, `rpc.php`, `cron.php` och `blockstudio.json`. Saknade namn, felaktiga fälttyper, felaktigt formaterade definitioner och föråldrade booleska kortformer (`"tailwind": true` i stället för det nästlade objektet) rapporteras alla med exakt radnummer i källfilen.

### Validering av inställningssökvägar

Anrop till `Settings::get()` valideras mot det kända inställningsschemat:

```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 av hooknamn

Samma sak gäller filter- och action-hooknamn:

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

Tillägget innehåller också stubbar för hela Blockstudio:s offentliga API: `Db`, `Settings`, `Field_Registry`, `Build` och globala hjälpfunktioner. Du får komplettering och typkontroll för alla Blockstudio-API:er utan att behöva ha pluginets källkod på din utvecklingsdator.

## Smidigare utveckling

Två mindre förbättringar för utvecklare kompletterar versionen.

### Globala SCSS-preludier

Blockstudio hade redan stöd för kompilering av SCSS, men det fanns en irriterande friktionspunkt: delad konfiguration av Sass.

Om du ville komma åt en gemensam uppsättning variabler, funktioner eller mixiner var du tvungen att importera dem i varje SCSS-fil. Det blir snabbt upprepande, särskilt med större designsystem eller verktygssatser för Sass som Bootstrap.

7.2 lägger till en prelude-hook för just det:

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

I kombination med det befintliga filtret `blockstudio/assets/process/scss/import_paths` definierar du ett gemensamt Sass-gränssnitt en gång, så blir det tillgängligt för varje kompilerad fil.

En blockformatmall kan fokusera på de faktiska stilar den behöver:

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

Inga upprepade importer i varje blockresurs. Det är inte "Bootstrap-stöd" som ett specialläge. Det är en generell hook för delad Sass i ett projekt, oavsett om den kommer från Bootstrap eller din egen interna verktygssats.

### Blockdefinitioner med inbyggt PHP för API

7.2 lägger också till en valfri syntax med inbyggt PHP för API:er till fullstackblock. Arrayer förblir standard och stöds fullt ut. Inget har ersatts. Men om du föredrar namngivna argument, enum-typer och attribut framför nästlade konfigurationsarrayer kan du nu välja den stilen.

För `rpc.php` returnerar du ett objekt med metoder försedda med attribut:

```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` fungerar samma 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 {
    }
};
```

Och för `db.php` finns nu ett litet byggarlager:

```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 ger en bättre balans i större kodbaser. Du behåller enkelheten i arrayformatet när du vill, och kan byta till ett mer lättupptäckt PHP-gränssnitt när ett block växer förbi en handfull fält eller endpoints.

## Därför hör de här funktionerna ihop

Adminöversikten, registerbläddraren, register-CLI och PHPStan-tillägget är alla svar på samma fråga: hur gör man ett Blockstudio-projekt begripligt när det växer?

Adminverktygen svarar på projektnivå: insyn i vad som är registrerat, möjlighet att hämta block från register och mindre gissningsarbete.

CLI svarar på ekosystemnivå: ett sätt att dela block mellan projekt och team utan att paketera dem som npm-paket eller kämpa mot byggsystem.

Tillägget PHPStan svarar på kodnivå: upptäck felaktig fältåtkomst, stavfel i scheman och trasiga hook-callbacks innan de når körning.

Det är den allmänna riktningen för 7.2: mindre gissningsarbete, mindre upprepning, bättre insyn och nu även faktisk typsäkerhet.

## Felkorrigeringar

- **Fältet Classes**: anpassade klassnamn som användaren skrev in försvann tyst vid fokusförlust eftersom valideraren bara godtog klasser från den fördefinierade listan Tailwind/settings. Nu godtas alla icke-tomma strängar.
- **Fältet Attributes**: när ett attributpar togs bort blev `null`-poster kvar i sparade data. Bytte från lodash `unset()` (som nullifierar arrayelement) till `splice()` (som tar bort dem).
- **CSS-minifierare**: TailwindPHP-minifieraren tog bort blanksteg runt `+` inuti `calc()` och `clamp()`, vilket gav ogiltig CSS som `calc(1rem+0.5vw)`. Åtgärdat uppströms i TailwindPHP v1.3.1 med en teckengenomgång som tar hänsyn till nästlingsdjup och bara tar bort blanksteg runt väljarkombinatorer på parentesdjup 0.
- **Förhandsvisning i Block Inserter**: `$isPreview` var alltid `false` i förhandsvisningen i Block Inserter eftersom renderingscachen inte inkluderade renderingsläget i hashnyckeln. Renderingar i redigeraren och förhandsvisningen får nu separata cacheposter.
- **Nästad mall för InnerBlocks**: komponenten `<InnerBlocks template="..."/>` tog bort det tredje elementet (barn) från malltupler som `['core/group', {}, [['core/paragraph']]]`, vilket skapade tomma behållarblock. Nu bevaras nästlade barn.
