
Blockstudio maakt in versie 7.6 een project leesbaar en weergeefbaar vanuit PHP en verplaatst de standaardinstellingen voor productiefrontends naar `blockstudio.json`: een inventaris-API, zelfstandige weergave, templatehelpers voor media en Tailwind, prestatieprofielen, één cachemap, statische prerendering met vroege servering, strengere analysepresets en gegenereerde projecttools voor codeeragenten.

Twee aanroepen vormen de kern van de release. `Canvas::inventory()` retourneert elke pagina, elk blok, elk patroon, elke Site Editor-template, elk template-onderdeel en elk voorbeeld van gebundelde UI dat een project registreert. `Render::document()` retourneert voor elk daarvan afgewerkte HTML, met precies de assets die bij het weergeven zijn gebruikt.

> **7.6.2-update:** Bestandspagina's worden niet langer verwerkt tijdens gewone WordPress-verzoeken. Voer `wp bs pages sync` uit of roep `Blockstudio\Pages::reconcile()` aan om bronwijzigingen toe te passen. Routering van verzamelingen en standaardinstellingen van `templateFor` gebruiken persistente runtimeconfiguratie, en expliciete reconciliatie vermijdt de eerdere omvangrijke meertalige OR-metaquery. De kortlevende optie `themeDefaults.syncPagesInDevelopment` is verwijderd omdat paginasynchronisatie niet langer via verzoekhooks wordt uitgevoerd. `Pages::init()` is nu alleen voor de bootstrap; integraties die `force` doorgaven, moeten `Pages::reconcile()` of de CLI gebruiken. Bij het openen van Canvas vindt nog steeds één expliciete, geauthenticeerde reconciliatie plaats voor de auteursinventaris.

> **7.6.12-update:** Stylesheets van de editor krijgen nu een prefix in één
> herschrijfronde, in plaats van een SASS-compilatie per asset. Daardoor loopt
> een koude editorbuild op een site met veel blokken niet langer het risico een
> bescheiden geheugenlimiet te overschrijden. Een gecachte prerenderde pagina
> waarvan de content-hashed Tailwind-stylesheet is verwijderd, wordt opnieuw
> gerenderd in plaats van ongestyled aangeboden, zowel via de PHP-cache
> als via de Early Serve-drop-in. Blokattributen die op het hoogste niveau zijn
> geschreven, worden bij het renderen gelezen in plaats van genegeerd, zodat het
> schema Blockstudio dat op de `WP_Block_Type` is geregistreerd, wordt gerespecteerd door
> programmatische schrijvers.

> **7.6.11-update:** Bij de installatie van grafiekartefacten wordt het
> document van een route nu atomair vervangen wanneer de kopie in de store onder
> dezelfde sleutel is gewijzigd. Identieke documenten blijven ongemoeid en via
> `Static_Prerender_Early_Serve::last_promotion()` wordt gemeld welke routes zijn gepromoveerd, vervangen, overgeslagen en
> behouden.

> **7.6.10-update:** Cachetreffers tijdens runtime detecteren nu verwijderde
> gecompileerde assets, ook binnen de watch-debounce. Vlakke runtimecaches van
> vóór versie 7.6 worden atomair in quarantaine geplaatst en in begrensde
> cron-batches verwijderd. Gebundelde UI-globals worden één keer per
> pagina uitgegeven. Early Serve in grafiekmodus kan routes buiten de
> gedeployde routemap aanbieden die live zijn gerenderd vanuit de identiteitscache.
> Tailwind kan optioneel het content-hashed cachebestand met `tailwind.output: "link"` uitgeven;
> inline output blijft de standaard.

In het kort:

- **Projectinventaris**: `Canvas::inventory()` retourneert elk geregistreerd record,
  met de bronnen en een stabiele weergavevolgorde.
- **Gerichte selectie**: door blokken en pagina's te benoemen, wordt het
  ontdekken, synchroniseren, renderen en compileren beperkt tot die records.
- **Zelfstandig renderen**: `Blockstudio\Render` retourneert voltooide HTML voor een
  blok, een compositie of een volledig document.
- **UI-componentfamilies**: `Blockstudio\Ui` groepeert de gebundelde bibliotheek in
  één openbare familie per component, elk met een voorbeeld.
- **Stabiele afbeeldingsafmetingen**: `bs_media_image()` rendert thema-assets met echte
  afmetingen uit een gegenereerde `assets/media.json`.
- **Tailwind-klassehelpers**: `bs_tw_merge()` en `bs_tw_variants()` combineren
  klassen in PHP met samenvoeging die rekening houdt met conflicten.
- **Prestatieprofielen**: `performance.profile` schakelt in één keer de standaardinstellingen
  voor de productiefrontend in; waarden van onderliggende items hebben voorrang.
- **Toegang tot getypeerde instellingen**: `Settings::get_bool()` en verwante functies lezen
  `blockstudio.json` met echte typen en tonen parseerfouten.
- **Eén cachemap**: elk gegenereerd bestand staat onder `cache.path`, met een
  runtime-identiteit als sleutel.
- **Statisch prerenderen**: anonieme HTML kunnen worden gecachet, via een
  afhankelijkheidsgrafiek ongeldig worden gemaakt en worden aangeboden voordat
  WordPress opstart.
- **Analysepresets**: `theme`, `extreme-theme` en `wordpress-render` breiden
  `blockstudio/phpstan` uit tot voorbij bloktemplates.
- **Beheerde commit-hook**: `blockstudio-githooks sync` schrijft een pre-commit-hook die de
  geconfigureerde preset uitvoert en beheert.
- **Projectcontract**: `blockstudio-agents` schrijft een `AGENTS.md` met een beschrijving
  van wat een projectauteur maakt, welke functies zijn ingeschakeld en wat de
  preset afdwingt.
- **Documentatie-index**: het AI-contextbestand is nu een index van elk
  document, het doel ervan en de identifiers die erbij horen.
- **Canonieke bloktags**: een zelfstandig commando herschrijft afkortingen van
  prefixes en aliassen naar `<bs:namespace-slug>`, met een proefuitvoering.
- **Compatibel als standaard**: niets hierboven verandert iets aan een site
  totdat het wordt vermeld in `blockstudio.json`.

## Een project lezen en renderen

### Projectinventaris

`Canvas::inventory()` retourneert alles wat een project registreert in één gewone array,
zonder iets te renderen.

```php
use Blockstudio\Canvas;

$result = Canvas::inventory();

foreach ($result['inventory']['blocks'] as $block) {
    echo $block['name'] . "\n";
}
```

Records zijn gegroepeerd per type: `pages`, `blocks`, `patterns`, `templates`,
`parts` en `ui`. `order` is de stabiele weergavevolgorde voor alle typen,
`sources` koppelt elk record aan de bijbehorende bronpaden en `warnings` en `errors`
verzamelen problemen als gestructureerde items.

Blokrecords bevatten `id`, `name`, `title`, `source`, `path`, `provenance` en een
klaar-om-te-renderen `declaration`. Paginarecords behouden `source` als stabiele identiteit
en `path` als de template die rendert.

### Gerichte selectie

Door records te benoemen, wordt het werk beperkt, in plaats van achteraf te filteren.

```php
$changed = Canvas::inventory([
    'blocks' => ['mytheme/hero'],
    'pages' => ['about'],
]);
```

Dat retourneert één blok en één pagina. `patterns`, `templates`, `parts` en `ui`
blijven leeg en hun bronnen worden nooit gelezen, gesynchroniseerd, gerenderd of
gecompileerd.

De regels zijn exact:

- Zonder typekeys worden alle typen geladen.
- Met `true`, `null` of `"*"` worden alle records van dat type geladen.
- Een tekenreeks of lijst komt exact overeen met ID, naam, slug, pad of bronpad.
- Met een lege tekenreeks, een lege lijst of `false` wordt niets van dat type geladen.
- Zodra er een typekey aanwezig is, blijven de niet-opgegeven typen ongemoeid.

Identifiers die niet meer bestaan, worden geretourneerd onder `deleted` in plaats
van een fout te veroorzaken. Het verversingsendpoint REST van Canvas past
hetzelfde toe op de parameters `blocks` en `pages`.

`Canvas::documents()` gebruikt dezelfde selectie en voegt voor elk record één gerenderd
 document toe. Geselecteerde pagina's worden gerenderd in een herstelde frontendcontext,
waardoor query-voorwaarden, bodyklassen, shortcodes, layouts, redirects en
enqueue-callbacks die pagina zien, niet het verzoek waarmee erom is gevraagd.

### Zelfstandig renderen

`Blockstudio\Render` retourneert gerenderde HTML als tekenreeks, via dezelfde
pipeline die de frontend gebruikt.

```php
use Blockstudio\Render;

$html = Render::composition([
    'root' => 'mytheme/card',
    'data' => ['heading' => 'Example card'],
    'layers' => [
        ['name' => 'mytheme/button', 'data' => ['label' => 'Continue']],
    ],
]);
```

Er ligt één declaratievorm met vier sleutels aan ten grondslag: `name`, `attributes`,
`content` en `children`. `root`, `data`, `inner`, `innerBlocks`, `layers` en
`example` zijn handige invoervormen die `Render::normalize()` daarin omzet.
Onderliggende elementen worden recursief gerenderd en bij ongeldige invoer volgt
een exception met de naam van het betreffende blok.

`Render::document()` verpakt de output in een volledig zelfstandig HTML-document.

```php
$document = Render::document('mytheme/hero', [
    'title' => 'Hero preview',
]);

echo $document['html'];
```

`body` is alleen de blokoutput, `html` het samengestelde document, `blocks` de
bloknamen die hebben bijgedragen en `assets` splitst de markup op in `head`,
`footer`, `styles`, `scripts`, `modules`, `interactivity`, `ui` en `tailwind`.
Assets worden beperkt tot wat er is gerenderd, dus editor-only-assets verschijnen niet.

`Render::document_from_html()` verpakt elders gerenderde HTML, en
`Render::content()` rendert geserialiseerde blokinhoud zonder document. Roep
`Blockstudio\Batch_Render::reset()` aan tussen documenten binnen één PHP-proces;
`Canvas::documents()` doet dat al.

### UI-componentfamilies

`Blockstudio\Ui` biedt de gebundelde UI-bibliotheek aan met één item per openbaar
component, in plaats van een lijst met interne onderdelen.

`Ui::inventory()` retourneert één item per familie, met het rootblok, de titel en
de benodigde implementatieblokken. `Ui::examples()` voegt een deterministische
declaratie per familie toe: standaardwaarden blijven behouden, verplichte
onderliggende lagen worden onder hun ouders genest en lege velden krijgen stabiele
voorbeeldtekst. Die declaratie is canoniek en gaat dus rechtstreeks naar `Render::document()`.

Canvas groepeert ze op dezelfde manier. Gebundelde UI verschijnt onder het type
`ui` als één voorbeeld per familie; implementatieregistraties blijven buiten
`blocks`.

De families zijn ontworpen om te worden samengesteld: een keuzelijst opent in een dialoogvenster, met de [compositiegids](https://blockstudio.dev/nl/ui/composition/); de lijst zweeft over de trigger heen, menu's en comboboxen zijn verankerd aan vaste viewportcoördinaten die blijven kloppen tijdens het scrollen, modals stapelen zich op en sluiten één voor één met Escape, en elke footer combineert dezelfde sluitknop met een variant. Zo werken die verbindingen en de invarianten die ze betrouwbaar houden, zie je in de composities live op [/ui/examples](https://blockstudio.dev/nl/ui/examples/).

## Templatehelpers

### Stabiele afbeeldingsafmetingen

`bs_media_image()` rendert thema-assets met echte breedte en hoogte en een gereserveerde
beeldverhouding, zodat afbeeldingen buiten de mediabibliotheek de lay-out niet meer verschuiven.

```php
<?php
echo bs_media_image([
    'src' => 'assets/images/hero.webp',
    'alt' => 'Hero',
]);
```

De output is een `figure.blockstudio-media` met een inline `aspect-ratio` rond een
`img` met echte `width`, `height`, `loading` en `decoding`. De afmetingen
komen uit een gegenereerde `assets/media.json`, aangemaakt door
`Blockstudio\Media_Metadata_Builder` tijdens een buildstap of handmatig.

`src` accepteert een pad relatief aan het thema, een absoluut pad of een volledige URL; voor afbeeldingen uit de mediabibliotheek is er `attachmentId`. Met `eager` wordt lazy loading boven de vouw uitgeschakeld en met `sources` wordt een `<picture>` uitgegeven.

Als `performance.media.lazy` is ingeschakeld, wordt de echte URL verplaatst naar `data-src` achter een placeholder met de juiste afmetingen.

### Tailwind-klassehelpers

`bs_tw_merge()` en `bs_tw_variants()` combineren Tailwind-klassen in PHP-templates met de engine die Blockstudio al bundelt.

`bs_tw_merge('px-2 text-sm', 'px-4')` retourneert `text-sm px-4`: het conflicterende
`px-2` wordt verwijderd en de latere waarde krijgt voorrang. Geneste arrays met klassewaarden
zijn toegestaan.

`bs_tw_variants()` retourneert een kleine aanroepbare functie voor componentvarianten:

```php
$button = bs_tw_variants([
    'base' => 'inline-flex items-center',
    'variants' => [
        'size' => ['sm' => 'h-8 px-3', 'lg' => 'h-12 px-6'],
    ],
    'defaultVariants' => ['size' => 'sm'],
]);

echo $button(['size' => 'lg', 'class' => 'rounded']);
```

Dat geeft `inline-flex items-center h-12 px-6 rounded` weer. Basisklassen,
varianten, standaardvarianten, samengestelde varianten en een `class` of
`className` per aanroep worden allemaal ondersteund.

## Productieconfiguratie

### Prestatieprofielen

`performance.profile` schakelt op één plek de standaardinstellingen voor de productiefrontend in.

```json title="blockstudio.json"
{
  "performance": {
    "profile": "speed",
    "preload": {
      "links": "off"
    }
  }
}
```

`compat` is de standaard en verandert niets. `speed` en `strict` schakelen
hetzelfde in: generator-, emoji-, feed-, discovery- en berichten-van-dezelfde-auteur-output wordt uit de head verwijderd; oEmbed-discovery en hostscripts worden weggelaten; XML-RPC, pingbacks en remote editor discovery worden uitgeschakeld; generieke corefrontend-assets worden verwijderd; afbeeldingsoutput krijgt standaardinstellingen; Heartbeat wordt buiten editors beperkt; documenten van dezelfde oorsprong worden vooraf opgehaald bij aanwijzen met de muis of focusintentie; en de afbeeldingslader van Blockstudio wordt gebruikt.

Elke onderliggende waarde overschrijft het profiel, zoals `preload.links` hierboven doet. Het verwijderen van corefrontend-assets is het eerste dat u moet testen, omdat een pagina die daarvan afhankelijk is zichtbaar stukgaat. `Runtime_Settings::current()` toont het opgeloste profiel.

`themeDefaults` regelt twee dingen die thema's anders zelf zouden moeten maken: `titleTag` en
`suppressDirectoryUpdates` om het actieve child- en parentthema uit update-resultaten te verbergen.

### Toegang tot getypeerde instellingen

`Blockstudio\Settings` leest configuratie met echte typen, in plaats van terug te geven
wat er in JSON stond.

```php
use Blockstudio\Settings;

$lazy = Settings::get_bool('performance/media/lazy');
$margin = Settings::get_string('performance/media/rootMargin', '300px');
$ttl = Settings::get_int('performance/staticPrerender/ttl', 86400);
$roles = Settings::get_array('users/roles');

foreach (Settings::errors() as $error) {
    error_log($error);
}
```

Ongeldige JSON wordt gemeld via `Settings::errors()`, in plaats van terug te vallen op
standaardwaarden. `Settings::get_raw()` retourneert alleen wat de actieve bron heeft gedeclareerd,
zodat een waarde die op `false` is ingesteld, te onderscheiden is van een waarde die nooit is ingesteld.

`Settings::fingerprint()` retourneert een stabiele identiteit voor de effectieve instellingen
en bij het openen wordt opnieuw geladen als `blockstudio.json` verandert.

### Eén cachemap

Elk gegenereerd bestand staat nu onder `cache.path`, die standaard is ingesteld op
`wp-content/blockstudio/cache`.

```json title="blockstudio.json"
{
  "cache": {
    "enabled": true,
    "path": "cache/blockstudio"
  }
}
```

Buildpayloads, blokregistratiegegevens, editor-assets, gecompileerde Tailwind CSS,
renderdocumenten, eilandfragmenten, statische HTML, grafiekindexen, wachtrijen voor opwarming en diagnoses staan allemaal onder die hoofdmap. Een relatief pad wordt opgelost vanaf
`WP_CONTENT_DIR`; met een absoluut pad wordt de map naar een speciaal volume verplaatst.

Objecten worden opgeslagen onder het huidige netwerk en de huidige site, en vervolgens onder een runtime-identiteit: een vingerafdruk van de versies van Blockstudio, WordPress en PHP, de effectieve instellingen, het actieve thema en de actieve plugins, de ontdekkingsbronnen en de betrokken bronbestanden. Als een invoer verandert, worden de betrokken objecten vervangen door nieuwe; de oude worden opgeschoond.

Koude builds worden single-flight uitgevoerd: één verzoek bouwt en publiceert het resultaat atomair, terwijl andere wachten. Bij een mislukte verversing blijft het laatst goede object aangeboden en blijft de fout zichtbaar, en met
`Blockstudio\Runtime_Cache::purge('tailwind')` wordt één scope gewist.

## Statisch prerenderen

Statisch prerenderen cachet volledige anonieme HTML-documenten en kan deze aanbieden voordat WordPress opstart. Standaard is dit uitgeschakeld.

```json title="blockstudio.json"
{
  "performance": {
    "staticPrerender": {
      "enabled": true,
      "ttl": 3600,
      "earlyServe": true,
      "dynamicPaths": ["/account", "/checkout"]
    }
  }
}
```

### Geschiktheid

Alleen volledige anonieme HTML-documenten komen in aanmerking. Niet-GET-verzoeken, queryreeksen, de beheeromgeving, REST, Ajax, cron, feeds, zoeken, previews, verzoeken met een nonce, gepersonaliseerde cookies en elk pad onder `dynamicPaths` worden overgeslagen.
Een respons kan volledig afzien van caching met een `<!-- blockstudio:no-cache -->`-markering.

Bij padmatching wordt rekening gehouden met grenzen: `/account` omvat `/account/orders`, maar
niet `/accounting`.

### Handtekening- en grafiekmodi

`invalidate` bepaalt hoe items verlopen. In de standaardmodus `signature` wordt bij een anonieme cachemiss een respons met een identiteitssleutel gevuld en na wijzigingen op siteniveau vernieuwd. Dit is geschikt voor een gewone site.

De modus `graph` is bedoeld voor expliciete build- en deploytools. Deze registreert de eigen bronafhankelijkheden van elke pagina, zodat een plan alleen de betrokken URL's opnieuw opbouwt.

```php
use Blockstudio\Static_Prerender_Runtime;

$plan = Static_Prerender_Runtime::build_plan($sourceUrls);

foreach ($plan['affectedUrls'] as $url) {
    $result = render_with_dependencies($url);

    Static_Prerender_Runtime::persist_built_response(
        $url,
        $result['html'],
        $result['files'],
        $result['virtualHashes']
    );
}

Static_Prerender_Runtime::garbage_collect(array_keys($plan['live']));
```

### Vroegtijdig aanbieden

Als `earlyServe` is ingeschakeld, beheert Blockstudio een kleine routemap per site en een `advanced-cache.php`-drop-in die een geschikte cachetreffer streamt voordat WordPress, plugins of het thema worden gestart.

Het overschrijft nooit een externe map, drop-in of `WP_CACHE`-declaratie. Een grafiekartefact valideert elk bestand waarnaar HTML verwijst voordat de map wordt omgewisseld, zodat een gedeeltelijk gerenderde deploy de vorige grafiek actief laat. Multisite-items blijven gescheiden op basis van host, homepad en site-ID.

### Opwarmen en status

Drie WP-CLI-commando's zijn voldoende voor dagelijks gebruik:

```bash
wp bs prerender warm
wp bs prerender status
wp bs prerender purge
```

`status` toont de actieve identiteit, het aantal bestanden en bytes, grafiekrecords, de wachtrijstatus en tellers per scope voor treffers, missers, builds en fouten.

## Analyse- en agenttools

### Analysepresets

`blockstudio/phpstan` krijgt drie lagen boven op de blokanalyse, plus één
commando dat de laag uitvoert die een project heeft geselecteerd.

| Preset | Wat wordt toegevoegd |
| --- | --- |
| `base` | De bestaande analyse van schema's, templates, hooks, instellingen en API. |
| `theme` | Themahoofdmap, stijlheaders, assets, bereik van selectors, standaardwaarden voor velden en grenzen voor herhalingen. |
| `extreme-theme` | PHPStan `max`, onveilige PHP, escaping, Tailwind, JavaScript en Interactivity-controles. |
| `wordpress-render` | Een live renderprobe die de aanroeper aanlevert, boven op `extreme-theme`. |

Standaardwaarden komen uit `blockstudio.json`, zodat interactieve uitvoeringen, CI en commit-hooks dezelfde configuratie delen:

```json title="blockstudio.json"
{
  "phpstan": {
    "preset": "theme",
    "roots": ["."],
    "excludePaths": ["fixtures/**"],
    "maxFiles": 10000
  }
}
```

```bash
vendor/bin/blockstudio-phpstan --root . -- --no-progress
```

De exitcodes zijn `0` bij een geslaagde uitvoering, `1` bij diagnostiek en `2` bij ongeldig gebruik. De wrapper stelt de configuratie samen in de tijdelijke systeemmap, zodat er geen gegenereerde configuratie, baseline of cache in het project terechtkomt, en verhoogt de geheugenlimiet van PHPStan naar `1G`.

Er wordt ook een BC Math-provider meegeleverd, zodat voor de JavaScript-controles `ext-bcmath` niet langer nodig is.

### Beheerde commit-hook

Met één instelling en één commando wordt de geconfigureerde preset een controle bij commits.

```json title="blockstudio.json"
{
  "githooks": {
    "commit": true
  }
}
```

```bash
vendor/bin/blockstudio-githooks sync
```

Synchroniseren schrijft de hook en een eigendomsrecord in de gemeenschappelijke map van Git, laat `core.hooksPath` naar de beheerde map verwijzen en roept daarna de eerder geconfigureerde pre-commit-hook aan. De hook bepaalt de repository en de projecthoofdmap op het moment van committen, zodat gekoppelde checkouts en paden met spaties werken.

De hook voert uitsluitend `vendor/bin/blockstudio-phpstan` uit; bestanden worden nooit opgemaakt of herschreven. Door `commit` op `false` in te stellen en opnieuw te synchroniseren, of door `blockstudio-githooks remove` uit te voeren, wordt het vastgelegde hookpad hersteld en worden alleen bestanden die eigendom zijn van Blockstudio verwijderd.

### Projectcontract

`blockstudio-agents` schrijft een `AGENTS.md` waarin staat waar blokken staan, wat in dit project als een pagina geldt, welke functies zijn ingeschakeld en wat de analyser afwijst.

```bash
vendor/bin/blockstudio-agents
```

Het document wordt afgeleid, niet op basis van een template gemaakt. Een thema met een `style.css`-header, blokken en pagina's op basis van bestanden krijgt een ander contract dan een plugin die alleen blokken registreert, met daarin de aantallen, mappen, naamruimten en templatelanguages die de scanner heeft gevonden. `blockstudio.json` bepaalt welke functies worden vermeld, zodat een project zonder statisch prerenderen daar niets over ziet staan.

Het gedeelte over correctheid wordt laag voor laag gelezen uit de eigen regelbestanden van de geselecteerde preset. Als een preset een regel krijgt, verandert die dus in elk gegenereerd contract.

Het eigendomsbeheer werkt net als bij de commit-hook. Een bestand zonder de gegenereerde markering wordt geweigerd in plaats van vervangen, tenzij `--force` anders bepaalt. Een notitiegedeelte aan het einde blijft behouden na het opnieuw genereren, `--check` retourneert `1` als het contract verouderd is en `--stdout` toont het zonder het bestandssysteem aan te passen.

### Documentatie-index

`blockstudio-llm.txt` is nu een index in plaats van een aaneenschakeling. Elk gepubliceerd document staat er één keer in, onder de bijbehorende sectie en subsectie, met de route, het bronbestand, een omschrijving van één regel en de identifiers die erbij horen: instellingenpaden, hooknamen, functies en klassen van PHP en commando's.

```text
## Docs / Dev / Inspection Tools

### Canvas
route: /docs/dev/canvas
file: docs/docs/dev/canvas.md
purpose: A visual workspace and public inventory API for Blockstudio content.
settings: dev/canvas/enabled, ui
hooks: blockstudio/settings/dev/canvas/admin_bar, blockstudio/settings/dev/canvas/enabled
php: Blockstudio\Canvas, Canvas::documents(), Canvas::inventory()
```

Een agent leest de index, vindt het ene document waarin de identifier staat die hij nodig heeft en opent dat document. De eerdere samenvoeging van een halve megabyte wordt nog steeds gegenereerd en gepubliceerd op `/blockstudio-llm-full.txt`; die wordt niet langer als eerste aan iedereen aangeboden.

## Canonieke blocktags

Een zelfstandige opdracht herschrijft voorvoegsel- en aliasshorthands naar de canonieke spelling `<bs:namespace-slug>`, die de echte blocknaam vastlegt en wordt opgelost zonder dat er een projectfilter is geladen.

Met een voorvoegsel `brand` voor `theme-components` en een voorvoegsel `ui` voor `bsui`, deze shorthand:

```html
<brand-card>
  <ui-input />
</brand-card>
```

betekent hetzelfde als:

```html
<bs:theme-components-card>
  <bs:bsui-input />
</bs:theme-components-card>
```

Voorvoegsels en exacte aliassen werken nog steeds en zijn niet verouderd verklaard. De opdracht laadt WordPress niet en schrijft niets zonder `--apply`:

```bash
php vendor/blockstudio/blockstudio/bin/migrate-block-tags.php \
  --root="$PWD" \
  --prefix-map=/tmp/prefixes.json \
  --known-blocks=/tmp/blocks.json \
  --report=/tmp/tag-migration.json \
  --dry-run
```

`--prefix-map` koppelt elk voorvoegsel aan de bijbehorende namespaces en `--known-blocks` geeft geregistreerde blocknamen weer. Het rapport legt koppelingen van legacy naar canoniek vast, met aantallen voorkomens, hashes per bestand en afzonderlijke lijsten voor onbekende tags, ambigue aliassen en dynamische tags. `--apply` weigert te schrijven zolang er nog items zijn, tenzij `--allow-unresolved` wordt meegegeven.

Gekoppelde, geneste en zelfsluitende markup wordt verwerkt, inclusief letterlijke tags in strings van PHP. Alleen tagnamen veranderen; een tweede uitvoering brengt geen wijzigingen aan. Voorbeelden in opmerkingen, codeblokken, `<pre>` of `<code>` worden alleen gerapporteerd.

## Standaardgedrag

Installatie van 7.6 verandert op zichzelf niets.

**Het prestatieprofiel is standaard ingesteld op `compat`.** Head-uitvoer, oEmbed, XML-RPC, Heartbeat, standaardinstellingen voor afbeeldingen, vooraf laden van links, lazy loading en de frontend-`<title>` blijven zoals WordPress en het thema ze hebben ingesteld.

**Deze blijven uitgeschakeld tenzij ze worden ingeschakeld:** elke `performance.staticPrerender`-, `performance.measurement`-, `performance.media`- en `themeDefaults`-sleutel, plus `githooks.commit`, `dev.canvas.enabled`, `ui.enabled`, `tailwind.enabled` en `blockTags.enabled`. Statische prerendering schrijft geen bestanden en installeert geen drop-in zolang deze is uitgeschakeld.

**Canvas en Render werken passief.** Ze lezen bestaande registers en renderen alleen wat een aanroeper vraagt; geen van beide haakt in op frontend-uitvoer of registreert routes. Voor het Canvas-beheerscherm zijn `dev.canvas.enabled` en `edit_posts` nog steeds vereist.

**Strengere analyse moet expliciet worden aangevraagd.** Installatie van `blockstudio/phpstan` schakelt alleen de basisextensie in, en de canonieke opdracht voert `base` uit tenzij een project een preset opgeeft.

**Gegenereerde bestanden vereisen uitvoering van hun opdracht.** `githooks.commit` doet niets totdat `blockstudio-githooks sync` wordt uitgevoerd, en `AGENTS.md` doet niets totdat `blockstudio-agents` dat doet.

## Upgraden vanaf 7.5

De vereisten zijn ongewijzigd: PHP 8.2 of nieuwer, WordPress 6.7 of nieuwer.

```bash
composer require blockstudio/blockstudio
```

**Caches worden één keer opnieuw opgebouwd.** De runtime-identiteit bevat de versie van Blockstudio, dus het eerste verzoek na de upgrade start met een lege cache en oude objecten worden opgeschoond. De oude cache van Tailwind onder `wp-content/uploads/blockstudio/tailwind/cache` kan worden verwijderd; een snippet die deze met glob doorzocht, moet in plaats daarvan `Blockstudio\Runtime_Cache::purge('tailwind')` aanroepen.

De platte `wp-content/blockstudio/cache/runtime`-map van vóór 7.6 wordt automatisch buiten het actieve pad hernoemd en in begrensde WP-Cron-stappen verwijderd. Grote legacy-lockfilebomen hoeven daarom niet tijdens een deploymentverzoek te worden verwijderd.

**Gegenereerde bestanden hebben eigenaren.** `assets/media.json` hoort in versiebeheer of in een buildstap. De routemap, de drop-in `advanced-cache.php` en de declaratie van `WP_CACHE` bestaan alleen wanneer `earlyServe` is ingeschakeld, en de pre-commithook alleen zolang deze is gesynchroniseerd. Al het overige gegenereerde materiaal staat onder `cache.path` en kan veilig worden verwijderd.

**Er is niets verwijderd of hernoemd.** `bs_render_block()`, `bs_block()`, `Blockstudio\Pages` en `Blockstudio\Patterns` blijven de canonieke bestandsgebaseerde contentoppervlakken.

**Terugdraaien gebeurt per functie.** `performance.profile` terug naar `compat`, `staticPrerender.enabled` naar `false`, `githooks.commit` naar `false` plus een `sync`, en `cache.enabled` naar `false` draaien elk één laag terug.

Een logische volgorde voor invoering:

1. Stel `performance.profile` in op `speed` en controleer vervolgens de head-uitvoer, feeds en plugins die afhankelijk zijn van oEmbed of XML-RPC.
2. Genereer `assets/media.json`, verplaats templates naar `bs_media_image()` en schakel vervolgens `performance.media.lazy` in.
3. Schakel `performance.staticPrerender` in met `earlyServe` uitgeschakeld, controleer hits met `wp bs prerender status` en schakel daarna `earlyServe` in.
4. Voer `blockstudio-phpstan --preset theme` uit totdat er geen problemen meer zijn, voordat je een preset achter `githooks.commit` plaatst.

## Waar de details staan

- [Canvas](https://blockstudio.dev/nl/docs/dev/canvas/) en de [inventaris en documentatieAPI](https://blockstudio.dev/nl/docs/dev/canvas/#public-inventory-and-document-api)
- [Renderen](https://blockstudio.dev/nl/docs/blocks/rendering/#structured-compositions-and-complete-documents), [UI-componenten](https://blockstudio.dev/nl/ui/#public-inventory-and-examples) en [UI-compositie](https://blockstudio.dev/nl/ui/composition/)
- [Instellingen](https://blockstudio.dev/nl/docs/general/settings/) en [prestaties](https://blockstudio.dev/nl/docs/general/settings/#performance)
- [Prestaties](https://blockstudio.dev/nl/docs/production/performance/), [caching](https://blockstudio.dev/nl/docs/production/caching/) en [statische prerendering](https://blockstudio.dev/nl/docs/production/static-prerendering/)
- [Tailwind CSS](https://blockstudio.dev/nl/docs/tailwind/#template-composition-helpers)
- [PHPStan](https://blockstudio.dev/nl/docs/dev/phpstan/): [presets](https://blockstudio.dev/nl/docs/dev/phpstan/#analysis-presets), [canonieke opdracht](https://blockstudio.dev/nl/docs/dev/phpstan/#canonical-command), [beheerde commit-hook](https://blockstudio.dev/nl/docs/dev/phpstan/#managed-commit-hook) en het [projectcontract](https://blockstudio.dev/nl/docs/dev/phpstan/#project-contract-for-coding-agents)
- [AI-integratie](https://blockstudio.dev/nl/docs/dev/ai/): de documentatie-index en de volledige tekst
- [Migratie](https://blockstudio.dev/nl/docs/dev/migration/v7/#canonical-block-tags) en [PHP-hooks](https://blockstudio.dev/nl/docs/blocks/hooks/php/)
