
Blockstudio 7.6 gør et projekt læsbart og muligt at gengive fra PHP og flytter standardindstillinger for frontend i produktion til `blockstudio.json`: en oversigt API, selvstændig gengivelse, skabelonhjælpere til medier og Tailwind, ydelsesprofiler, én cachemappe, statisk forhåndsgengivelse med tidlig levering, strengere analyseforudindstillinger og genererede projektværktøjer til kodningsagenter.

To kald dækker det meste af udgivelsen. `Canvas::inventory()` returnerer alle sider, blokke, mønstre, skabeloner til Webstedseditoren, skabelondele og medfølgende UI-eksempler, som et projekt registrerer. `Render::document()` returnerer færdig HTML for dem alle med præcis de ressourcer, der blev brugt til gengivelsen.

> **7.6.2-opdatering:** Filbaserede sider synkroniseres ikke længere under almindelige WordPress-anmodninger. Kør `wp bs pages sync` eller kald `Blockstudio\Pages::reconcile()`, når kildeændringer skal anvendes. Rutesætning for samlinger og standardindstillinger for `templateFor` bruger gemt runtime-konfiguration, og eksplicit synkronisering undgår den tidligere store flersprogede OR-metaforespørgsel. Indstillingen `themeDefaults.syncPagesInDevelopment`, som kun virkede i kort tid, er fjernet, fordi sidesynkronisering ikke længere køres fra request-hooks. `Pages::init()` bruges nu kun ved opstart; integrationer, der sendte `force`, skal bruge `Pages::reconcile()` eller CLI. Åbning af Canvas udfører stadig én autentificeret, eksplicit synkronisering af forfatterens indhold.

> **7.6.12-opdatering:** Editor-stylesheets får nu præfikser i én enkelt
> omskrivningsrunde i stedet for en SASS-kompilering pr. aktiv, så et koldt editor-build på
> et websted med mange blokke ikke længere risikerer at overskride en beskeden hukommelsesgrænse. En
> cachelagret prerenderet side, hvis content-hash-baserede Tailwind stylesheet er blevet
> fjernet, gengives igen i stedet for at blive vist ustylet, både via PHP-cachen
> og Early Serve drop-in. Blokattributter, der skrives på øverste niveau, læses ved rendering i stedet for at blive kasseret, så skemaet Blockstudio
> registreres på `WP_Block_Type` og respekteres af programmatisk skrivning.

> **7.6.11-opdatering:** Installation af Graph-artefakter erstatter nu et dokuments rute atomisk, når kopien i lageret er ændret under samme nøgle, lader identiske dokumenter være urørte og rapporterer promoverede, erstattede, udeladte og bevarede ruter via `Static_Prerender_Early_Serve::last_promotion()`.

> **7.6.10-opdatering:** Træffere i runtime-cachen opdager nu fjernede kompilerede aktiver, også under watch-debounce, og flade runtime-caches fra før 7.6 sættes atomisk i karantæne og slettes i afgrænsede cron-partier. Bundtede UI-globals udsendes én gang pr. side. Early Serve i Graph-tilstand kan vise live-renderede ruter uden for det udrullede rutekort fra identitetscachen. Tailwind kan valgfrit udsende sin content-hash-baserede cachefil med `tailwind.output: "link"`; inline-output er stadig standard.

Kort fortalt:

- **Projektoversigt**: `Canvas::inventory()` returnerer alle registrerede poster med deres kilder og en stabil visningsrækkefølge.
- **Målrettet valg**: Når blokke og sider angives, begrænses registrering, synkronisering, rendering og kompilering til disse poster.
- **Selvstændig rendering**: `Blockstudio\Render` returnerer færdig HTML for en blok, en komposition eller et komplet dokument.
- **UI-komponentfamilier**: `Blockstudio\Ui` grupperer det bundtede bibliotek i én offentlig familie pr. komponent med et eksempel til hver.
- **Stabile billeddimensioner**: `bs_media_image()` renderer temaaktiver med faktiske dimensioner fra en genereret `assets/media.json`.
- **Tailwind-klassehjælpere**: `bs_tw_merge()` og `bs_tw_variants()` sammensætter klasser i PHP med konflikthåndterende sammenfletning.
- **Ydelsesprofiler**: `performance.profile` aktiverer alle produktionsstandarder for frontend på én gang; værdier på underordnede niveauer tilsidesætter dem.
- **Typet adgang til indstillinger**: `Settings::get_bool()` og dets sidestykker læser `blockstudio.json` med reelle typer og viser parsefejl.
- **Én cachemappe**: Alle genererede filer ligger under `cache.path`, sorteret efter en runtime-identitet.
- **Statisk prerendering**: Anonyme HTML kan caches, ugyldiggøres via en afhængighedsgraf og vises, før WordPress starter.
- **Analyseforudindstillinger**: `theme`, `extreme-theme` og `wordpress-render` udvider `blockstudio/phpstan` ud over blokskabeloner.
- **Administreret commit-hook**: `blockstudio-githooks sync` skriver og ejer en pre-commit-hook, der kører den konfigurerede forudindstilling.
- **Projektkontrakt**: `blockstudio-agents` skriver en `AGENTS.md`, der beskriver, hvad et projekt opretter, hvilke funktioner det aktiverer, og hvad dets forudindstilling håndhæver.
- **Dokumentationsindeks**: AI-kontekstfilen er nu et indeks over alle dokumenter, deres formål og de identifikatorer, de ejer.
- **Kanoniske bloktags**: En selvstændig kommando omskriver præfiks- og aliasgenveje til `<bs:namespace-slug>` med en prøvekørsel.
- **Kompatibilitet som standard**: Intet af ovenstående ændrer et websted, før det angives i `blockstudio.json`.

## Læsning og rendering af et projekt

### Projektoversigt

`Canvas::inventory()` returnerer alt, hvad et projekt registrerer, som ét almindeligt array uden at rendere noget.

```php
use Blockstudio\Canvas;

$result = Canvas::inventory();

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

Poster grupperes efter type: `pages`, `blocks`, `patterns`, `templates`, `parts` og `ui`. `order` er den stabile visningsrækkefølge på tværs af alle typer, `sources` knytter hver post til dens kildeplaceringer, og `warnings` og `errors` samler problemer som strukturerede poster.

Blokposter indeholder `id`, `name`, `title`, `source`, `path`, `provenance` og en `declaration`, der er klar til rendering. Sideposter bruger `source` som stabil identitet og `path` som den skabelon, der renderer siden.

### Målrettet valg

Når du angiver poster, begrænses arbejdet fra starten i stedet for at filtrere bagefter.

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

Det returnerer én blok og én side. `patterns`, `templates`, `parts` og `ui` returnerer tomme resultater, og deres kilder læses, synkroniseres, renderes eller kompileres aldrig.

Reglerne er præcise:

- Uden type-nøgler indlæses alle typer.
- `true`, `null` eller `"*"` indlæser alle poster af den pågældende type.
- En streng eller en liste matcher præcist på ID, navn, slug, sti eller kildesti.
- En tom streng, en tom liste eller `false` indlæser ingen poster af den pågældende type.
- Når mindst én type-nøgle er angivet, forbliver de udeladte typer urørte.

Identifikatorer, der ikke længere findes, returneres under `deleted` i stedet for at udløse en fejl, og Canvas-REST-opdateringsendpunktet anvender samme regel på parametrene `blocks` og `pages`.

`Canvas::documents()` bruger samme udvalg og tilføjer et renderet dokument pr. post. Valgte sider renderes i en genskabt frontend-kontekst, så query-betingelser, body-klasser, shortcodes, layouts, redirects og enqueue-callbacks ser den pågældende side, ikke anmodningen, der bad om den.

### Selvstændig rendering

`Blockstudio\Render` returnerer renderet HTML som en streng gennem den samme pipeline, som frontenden bruger.

```php
use Blockstudio\Render;

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

Der ligger én deklarationsform med fire nøgler til grund: `name`, `attributes`, `content` og `children`. `root`, `data`, `inner`, `innerBlocks`, `layers` og `example` er inputgenveje, som `Render::normalize()` samler i den. Underordnede elementer renderes rekursivt, og ugyldigt input udløser en undtagelse, der navngiver den pågældende blok.

`Render::document()` omslutter outputtet i et komplet, selvstændigt HTML-dokument.

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

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

`body` er alene outputtet fra blokken, `html` det sammensatte dokument, `blocks` navnene på de blokke, der bidrog, og `assets` opdeler markup i `head`, `footer`, `styles`, `scripts`, `modules`, `interactivity`, `ui` og `tailwind`. Aktiver begrænses til det, der blev renderet, så editorens aktiver aldrig kommer med.

`Render::document_from_html()` omslutter HTML, der er renderet et andet sted, og `Render::content()` renderer serialiseret blokindhold uden et dokument. Kald `Blockstudio\Batch_Render::reset()` mellem dokumenter i én PHP-proces; `Canvas::documents()` gør det allerede.

### UI-komponentfamilier

`Blockstudio\Ui` eksponerer det bundtede UI-bibliotek med én post pr. offentlig komponent i stedet for en liste over interne dele.

`Ui::inventory()` returnerer én post pr. familie med dens rodblok, titel og de implementeringsblokke, den har brug for. `Ui::examples()` tilføjer en deterministisk deklaration pr. familie: standardværdier bevares, krævede underordnede lag indlejres under deres forældre, og tomme felter får stabil eksempeltekst. Denne deklaration er kanonisk, så den kan indsættes direkte i `Render::document()`.

Canvas grupperer på samme måde. Bundtet UI vises under typen `ui` med ét eksempel pr. familie, og implementeringsregistreringer vises ikke i `blocks`.

Familierne er designet til at blive sat sammen: En select åbner i en dialog med sin listbox oven på udløseren, menuer og comboboxes forankres med faste viewport-koordinater, der ikke påvirkes af rulning, modaler stables og lukkes én ad gangen med Escape, og hver footer sammensætter den samme lukkekontrol med en variant. Se, hvordan disse samlinger fungerer, og hvilke invariants der holder dem i gang, i [kompositionskapitlet](https://blockstudio.dev/da/ui/composition/); [/ui/examples](https://blockstudio.dev/da/ui/examples/) viser kompositionerne i praksis.

## Skabelonhjælpere

### Stabile billeddimensioner

`bs_media_image()` renderer temaaktiver med faktisk bredde og højde samt et reserveret højde-bredde-forhold, så billeder uden for mediebiblioteket ikke længere får layoutet til at flytte sig.

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

Outputtet er en `figure.blockstudio-media` med en inline-`aspect-ratio` omkring en `img`, der indeholder de faktiske `width`, `height`, `loading` og `decoding`. Dimensionerne kommer fra en genereret `assets/media.json`, som skrives af `Blockstudio\Media_Metadata_Builder` i et build-trin eller manuelt.

`src` tager en temarelativ sti, en absolut sti eller en fuld URL, og `attachmentId` håndterer billeder fra mediebiblioteket. `eager` fravælger lazy loading over folden, og `sources` udsender en `<picture>`.

Når `performance.media.lazy` er aktiveret, flyttes det faktiske URL til `data-src` bag en pladsholder med korrekte dimensioner.

### Tailwind-klassehjælpere

`bs_tw_merge()` og `bs_tw_variants()` sammensætter Tailwind-klasser i PHP-skabeloner ved hjælp af den motor, som Blockstudio allerede bundter.

`bs_tw_merge('px-2 text-sm', 'px-4')` returnerer `text-sm px-4`: den modstridende `px-2` fjernes, og den senere værdi vinder. Indlejrede arrays af klasseværdier accepteres.

`bs_tw_variants()` returnerer en lille funktion, der kan kaldes, til komponentvarianter:

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

Det udskriver `inline-flex items-center h-12 px-6 rounded`. Basisklasser, varianter, standardvarianter, sammensatte varianter og `class` eller `className` pr. kald understøttes alle.

## Produktionskonfiguration

### Ydelsesprofiler

`performance.profile` aktiverer standardindstillingerne for produktionsfrontend ét sted.

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

`compat` er standarden og ændrer intet. `speed` og `strict` aktiverer det samme sæt: generator-, emoji-, feed-, discovery- og indlæg-ved-siden-af-output fjernes fra head; oEmbed-discovery og host-scripts fjernes; XML-RPC, pingbacks og remote editor-discovery deaktiveres; generiske frontend-aktiver fra core fjernes; standardindstillinger for billedoutput anvendes; Heartbeat begrænses uden for editorer; dokumenter fra samme origin forudindlæses ved hensigt om at holde markøren over eller fokusere; og Blockstudios billedindlæser bruges.

Hver underordnet værdi tilsidesætter profilen, som `preload.links` gør ovenfor. Fjernelse af frontend-aktiver fra core er det første, du bør teste, fordi sider, der afhænger af dem, får synlige fejl. `Runtime_Settings::current()` viser den løste profil.

`themeDefaults` dækker to ting, som temaer ellers implementerer manuelt: `titleTag` og `suppressDirectoryUpdates`, der skjuler det aktive undertema og overordnede tema fra opdateringsresultaterne.

### Typet adgang til indstillinger

`Blockstudio\Settings` læser konfiguration med reelle typer i stedet for at returnere, hvad end JSON indeholdt.

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

Ugyldig JSON rapporteres via `Settings::errors()` i stedet for at blive løst til standardværdier. `Settings::get_raw()` returnerer kun det, den aktive kilde har deklareret, så en værdi sat til `false` kan skelnes fra en værdi, der aldrig er blevet sat.

`Settings::fingerprint()` returnerer en stabil identitet for de effektive indstillinger, og adgang genindlæser, når `blockstudio.json` ændres.

### Én cachemappe

Alle genererede filer ligger nu under `cache.path`, som som standard er `wp-content/blockstudio/cache`.

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

Build-nyttelaster, blokregistreringsdata, editoraktiver, kompilerede Tailwind CSS, renderdokumenter, ø-fragmenter, statiske HTML, Graph-indekser, opvarmningskøer og diagnosticering ligger alle under denne rod. En relativ sti løses ud fra `WP_CONTENT_DIR`, mens en absolut sti peger på en dedikeret diskenhed.

Objekter gemmes under det aktuelle netværk og websted og derefter under en runtime-identitet: et fingeraftryk af versionerne af Blockstudio, WordPress og PHP, effektive indstillinger, aktivt tema og aktive plugins, registreringskilder samt de involverede kildefiler. Når et input ændres, bliver de berørte objekter erstattet af nye, og de gamle ryddes op.

Kolde builds håndteres som single-flight: Én anmodning bygger og udgiver resultatet atomisk, mens de øvrige venter. Hvis en opdatering mislykkes, fortsætter den seneste gode version med at blive vist, mens fejlen stadig kan observeres, og `Blockstudio\Runtime_Cache::purge('tailwind')` rydder ét scope.

## Statisk prerendering

Statisk prerendering cacher komplette anonyme HTML-dokumenter og kan vise dem, før WordPress starter. Funktionen er som standard slået fra.

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

### Kriterier for brug

Kun komplette anonyme HTML-dokumenter er kvalificerede. Ikke-GET-anmodninger, query-strenge, admin, REST, Ajax, cron, feeds, søgninger, forhåndsvisninger, anmodninger med nonce, personaliserede cookies og alle stier under `dynamicPaths` springes over. Et svar kan helt fravælge funktionen med en `<!-- blockstudio:no-cache -->`-markør.

Stisammenligning respekterer grænser, så `/account` dækker `/account/orders`, men ikke `/accounting`.

### Signatur- og Graph-tilstande

`invalidate` vælger, hvordan poster udløber. Standardtilstanden `signature` udfylder et identitetsnøglet svar ved en anonym cachemiss og roterer efter ændringer på webstedsniveau, hvilket passer til et almindeligt websted.

Tilstanden `graph` er beregnet til eksplicitte build- og udrulningsværktøjer. Den registrerer hver sides egne kildeafhængigheder, så en plan kun genopbygger de berørte URL'er.

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

### Tidlig levering

Når `earlyServe` er aktiveret, administrerer Blockstudio et lille rutekort pr. websted og en `advanced-cache.php`-drop-in, der sender et kvalificeret cachehit, før WordPress, plugins eller temaet starter.

Den overskriver aldrig et fremmed rutekort, en drop-in eller en `WP_CACHE`-deklaration. Et Graph-artefakt validerer hver refereret HTML-fil, før rutekortet udskiftes, så en delvist renderet udrulning lader den tidligere Graph være aktiv. Multisite-poster holdes adskilt efter vært, home-sti og websteds-ID.

### Opvarmning og status

Tre WP-CLI-kommandoer dækker den daglige brug:

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

`status` rapporterer den aktive identitet, antal filer og bytes, Graph-poster, køtilstand samt tællere for hits, misses, builds og fejl pr. scope.

## Analyse- og agentværktøjer

### Analyseforudindstillinger

`blockstudio/phpstan` får tre lag ud over sin blokanalyse samt én kommando, der kører det lag, projektet har valgt.

| Forudindstilling | Hvad den tilføjer |
| --- | --- |
| `base` | Den eksisterende analyse af skemaer, skabeloner, hooks, indstillinger og API. |
| `theme` | Temarødder, stilheaders, aktiver, selectorscoping, standardværdier for felter og repeatergrænser. |
| `extreme-theme` | PHPStan `max`, usikker PHP, escaping, Tailwind, JavaScript og Interactivity-kontroller. |
| `wordpress-render` | En live-render-probe leveret af kalderen oven på `extreme-theme`. |

Standardværdierne kommer fra `blockstudio.json`, så interaktive kørsler, CI og commit-hooks deler én konfiguration:

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

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

Afslutningskoderne er `0` ved succes, `1` ved diagnosticering og `2` ved ugyldig brug. Wrapperen sammensætter sin konfiguration i systemets midlertidige mappe, så ingen genereret konfiguration, baseline eller cache havner i projektet, og den hæver PHPStans hukommelsesgrænse til `1G`.

Den bundter også en BC Math-udbyder, så JavaScript-kontrollerne ikke længere kræver `ext-bcmath`.

### Administreret commit-hook

Én indstilling og én kommando gør den konfigurerede forudindstilling til en gate ved commit.

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

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

Synkronisering skriver hooken og en ejerskabspost i Gits fællesmappe, peger `core.hooksPath` på den administrerede mappe og kæder den pre-commit-hook, der var konfigureret i forvejen, videre. Hooken finder repositoryet og projektroden ved commit-tid, så tilknyttede checkouts og stier med mellemrum fungerer.

Hooken kører `vendor/bin/blockstudio-phpstan` og intet andet; den formaterer eller omskriver aldrig filer. Hvis `commit` sættes til `false` og synkroniseres igen, eller hvis `blockstudio-githooks remove` køres, gendannes den registrerede hooksti, og kun filer, der ejes af Blockstudio, slettes.

### Projektkontrakt

`blockstudio-agents` skriver en `AGENTS.md`, der angiver, hvor blokkene ligger, hvad en side er i dette projekt, hvilke funktioner der er aktiveret, og hvad analysatoren vil afvise.

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

Dokumentet genereres ud fra projektet; det bygger ikke på en skabelon. Et tema med et `style.css`-header, blokke og filbaserede sider får en anden kontrakt end et plugin, der kun registrerer blokke. Kontrakten indeholder de antal, mapper, navnerum og skabelonsprog, som scanneren fandt. `blockstudio.json` afgør, hvilke funktioner der vises, så et projekt uden statisk prerendering aldrig får den nævnt.

Afsnittet om korrekthed læses lag for lag fra regel-filerne for den valgte forudindstilling, så når en forudindstilling får en ny regel, ændres alle genererede kontrakter.

Ejerskabet fungerer som for commit-hooken. En fil uden den genererede markør afvises i stedet for at blive erstattet, medmindre `--force` siger andet; et noteområde til sidst bevares ved regenerering; `--check` afsluttes med koden `1`, hvis kontrakten er forældet; og `--stdout` udskriver den uden at ændre filsystemet.

### Dokumentationsindeks

`blockstudio-llm.txt` er nu et indeks i stedet for en sammenkædning. Hvert offentliggjort dokument vises én gang under sin sektion og undersektion sammen med sin rute, kildefil, formål i én linje og de identifikatorer, det ejer: indstillingsstier, hooknavne, PHP-funktioner og -klasser samt kommandoer.

```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()
```

En agent læser indekset, finder det ene dokument, der indeholder den identifikator, vedkommende har brug for, og åbner dokumentet. Den tidligere sammenkædning på en halv megabyte genereres og offentliggøres stadig ved `/blockstudio-llm-full.txt`; den er bare ikke længere det første, nogen får udleveret.

## Kanoniske bloktags

En selvstændig kommando omskriver præfiks- og aliasforkortelser til den kanoniske stavemåde `<bs:namespace-slug>`, som angiver det faktiske bloknavn og kan opløses uden indlæst projektfilter.

Med præfikset `brand` over `theme-components` og præfikset `ui` over `bsui` betyder denne forkortelse:

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

det samme som:

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

Præfikser og eksakte aliaser fungerer stadig og er ikke forældede. Kommandoen indlæser ikke WordPress og skriver intet uden `--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` knytter hvert præfiks til dets namespaces, og `--known-blocks` viser registrerede bloknavne. Rapporten registrerer tilknytninger fra ældre til kanoniske navne med antal forekomster, hashværdier pr. fil og separate lister over ukendte tags, tvetydige aliaser og dynamiske tags. `--apply` nægter at skrive, så længe nogen af dem stadig findes, medmindre `--allow-unresolved` er angivet.

Parret, indlejret og selvafsluttende markup håndteres, også bogstavelige tags i PHP-strenge. Kun tagnavne ændres, en ny kørsel foretager ingen ændringer, og eksempler i kommentarer, kodeblokke, `<pre>` eller `<code>` vises kun i rapporten.

## Standardadfærd

Installation af 7.6 ændrer ikke noget i sig selv.

**Ydelsesprofilen er som standard `compat`.** Head-output, oEmbed, XML-RPC, Heartbeat, billedstandarder, forhåndshentning af links, lazy loading og frontend-`<title>` forbliver, som WordPress og temaet efterlod dem.

**Disse er slået fra, medmindre de aktiveres:** alle `performance.staticPrerender`-, `performance.measurement`-, `performance.media`- og `themeDefaults`-nøgler samt `githooks.commit`, `dev.canvas.enabled`, `ui.enabled`, `tailwind.enabled` og `blockTags.enabled`. Statisk forhåndsgenerering skriver ingen filer og installerer ingen drop-in, mens funktionen er slået fra.

**Canvas og Render er passive.** De læser eksisterende registre og gengiver kun det, en kalder beder om; ingen af dem kobler sig på frontend-output eller registrerer ruter. Canvas-administrationsskærmen kræver stadig `dev.canvas.enabled` og `edit_posts`.

**Strengere analyse kræver, at den navngives.** Installation af `blockstudio/phpstan` aktiverer kun grundudvidelsen, og den kanoniske kommando kører `base`, medmindre projektet angiver en forudindstilling.

**Genererede filer kræver, at deres kommando køres.** `githooks.commit` gør intet, før `blockstudio-githooks sync` køres, og `AGENTS.md` gør intet, før `blockstudio-agents` køres.

## Opgradering fra 7.5

Kravene er uændrede: PHP 8.2 eller nyere, WordPress 6.7 eller nyere.

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

**Cacher genopbygges én gang.** Runtime-identiteten omfatter Blockstudio-versionen, så den første anmodning efter opgraderingen starter uden cache, og gamle objekter ryddes op. Den gamle Tailwind-cache under `wp-content/uploads/blockstudio/tailwind/cache` kan slettes; et snippet, der brugte glob, bør kalde `Blockstudio\Runtime_Cache::purge('tailwind')` i stedet.

Den flade `wp-content/blockstudio/cache/runtime`-mappe fra før 7.6 omdøbes automatisk, så den flyttes ud af den aktive sti, og fjernes i afgrænsede WP-Cron-gennemløb. Store træer af ældre låsefiler behøver derfor ikke blive slettet under en implementeringsanmodning.

**Genererede filer har ejere.** `assets/media.json` hører hjemme i versionsstyring eller et byggetrin. Rutekortet, `advanced-cache.php`-drop-in-filen og `WP_CACHE`-deklarationen findes kun, mens `earlyServe` er aktiveret, og pre-commit-hooken findes kun, mens der er synkroniseret. Alt andet genereret indhold ligger under `cache.path` og kan slettes uden risiko.

**Intet er fjernet eller omdøbt.** `bs_render_block()`, `bs_block()`, `Blockstudio\Pages` og `Blockstudio\Patterns` er stadig de kanoniske filbaserede indholdsoverflader.

**Tilbagerulning sker pr. funktion.** `performance.profile` tilbage til `compat`, `staticPrerender.enabled` til `false`, `githooks.commit` til `false` plus en `sync` og `cache.enabled` til `false` ruller hver ét lag tilbage.

En fornuftig rækkefølge for indførelsen:

1. Indstil `performance.profile` til `speed`, og kontrollér derefter head-output, feeds og eventuelle plugins, der bruger oEmbed eller XML-RPC.
2. Generér `assets/media.json`, flyt skabeloner til `bs_media_image()`, og slå derefter `performance.media.lazy` til.
3. Aktivér `performance.staticPrerender` med `earlyServe` slået fra, verificér træffere med `wp bs prerender status`, og slå derefter `earlyServe` til.
4. Kør `blockstudio-phpstan --preset theme`, indtil alt er rent, før en forudindstilling placeres bag `githooks.commit`.

## Her findes detaljerne

- [Canvas](https://blockstudio.dev/da/docs/dev/canvas/) og dens [oversigt og dokument-API](https://blockstudio.dev/da/docs/dev/canvas/#public-inventory-and-document-api)
- [Rendering](https://blockstudio.dev/da/docs/blocks/rendering/#structured-compositions-and-complete-documents), [UI-komponenter](https://blockstudio.dev/da/ui/#public-inventory-and-examples) og [UI-komposition](https://blockstudio.dev/da/ui/composition/)
- [Indstillinger](https://blockstudio.dev/da/docs/general/settings/) og [ydelse](https://blockstudio.dev/da/docs/general/settings/#performance)
- [Ydelse](https://blockstudio.dev/da/docs/production/performance/), [Caching](https://blockstudio.dev/da/docs/production/caching/) og [Statisk forhåndsgenerering](https://blockstudio.dev/da/docs/production/static-prerendering/)
- [Tailwind CSS](https://blockstudio.dev/da/docs/tailwind/#template-composition-helpers)
- [PHPStan](https://blockstudio.dev/da/docs/dev/phpstan/): [forudindstillinger](https://blockstudio.dev/da/docs/dev/phpstan/#analysis-presets), [kanonisk kommando](https://blockstudio.dev/da/docs/dev/phpstan/#canonical-command), [administreret commit-hook](https://blockstudio.dev/da/docs/dev/phpstan/#managed-commit-hook) og [projektkontrakten](https://blockstudio.dev/da/docs/dev/phpstan/#project-contract-for-coding-agents)
- [AI-integration](https://blockstudio.dev/da/docs/dev/ai/): dokumentationsindekset og den fulde tekst
- [Migrering](https://blockstudio.dev/da/docs/dev/migration/v7/#canonical-block-tags) og [PHP-hooks](https://blockstudio.dev/da/docs/blocks/hooks/php/)
