
Blockstudio 7.6 gör projekt läsbara och renderbara från PHP och flyttar standardinställningarna för frontend i produktion till `blockstudio.json`: en inventering API, fristående rendering, mallhjälpare för media och Tailwind, prestandaprofiler, en gemensam cachekatalog, statisk förhandsrendering med tidig leverans, striktare analysförinställningar och genererade projektverktyg för kodningsagenter.

Två anrop utgör huvuddelen av versionen. `Canvas::inventory()` returnerar alla sidor, block, mönster, Site Editor-mallar, malldelar och paketerade UI-exempel som ett projekt registrerar. `Render::document()` returnerar färdig HTML för var och en av dem, med exakt de resurser som renderingen använde.

> **7.6.2-uppdatering:** Fillagrade sidor stäms inte längre av vid vanliga WordPress-begäranden. Kör `wp bs pages sync` eller anropa `Blockstudio\Pages::reconcile()` när källändringar ska tillämpas. Samlingsrutter och standardinställningar för `templateFor` använder sparad körmiljökonfiguration, och uttrycklig avstämning undviker den tidigare stora OR-meta-frågan för flera språk. Alternativet `themeDefaults.syncPagesInDevelopment` med kort livslängd har tagits bort eftersom synkronisering av sidor inte längre körs från begärandehookar. `Pages::init()` används nu endast vid initiering; integreringar som skickade `force` måste använda `Pages::reconcile()` eller CLI. När Canvas öppnas görs fortfarande en enda autentiserad och uttrycklig avstämning av innehållsförteckningen för redigering.

> **7.6.12 uppdatering:** Redigerarens stilmallar prefixas nu i en enda
> omskrivningsomgång i stället för en SASS-kompilering per tillgång, så en kall
> redigerarbygge på en webbplats med många block riskerar inte längre att
> överskrida en begränsad minnesgräns. En cachelagrad för-renderad sida vars
> innehållshashade Tailwind-stilmall har rensats ur cachen återges på nytt i stället för
> att skickas utan stilar, både via PHP-cachen
> och Early Serve drop-in. Blockattribut som skrivs på toppnivån
> läses vid rendering i stället för att ignoreras, så schemats Blockstudio
> registrering på `WP_Block_Type` respekteras av programmässiga skrivare.

> **7.6.11 uppdatering:** Installation av grafartefakter ersätter nu en ruttens
> dokument atomärt när butikskopian har ändrats under samma nyckel, lämnar
> identiska dokument orörda och rapporterar uppflyttade, ersatta, överhoppade och
> bevarade rutter via `Static_Prerender_Early_Serve::last_promotion()`.

> **7.6.10 uppdatering:** Träffar i runtime-cachen upptäcker nu borttagna kompilerade tillgångar även
> under bevakningens debounce-period, och platta runtime-cachar från före 7.6 sätts atomärt i karantän och
> tas bort i begränsade cron-batcher. Bundlade UI-globaler skrivs ut en gång
> per sida. Early Serve i graf-läge kan leverera live-renderade rutter utanför den
> driftsatta rutkartan från identitetscachen. Tailwind kan valfritt skriva sin
> innehållshashade cachefil med `tailwind.output: "link"`; inline-utdata är
> standard.

Kortversionen:

- **Projektinventering**: `Canvas::inventory()` returnerar alla registrerade poster
  med deras källor och en stabil visningsordning.
- **Riktat urval**: genom att ange block och sidor begränsas upptäckt, synkning,
  rendering och kompilering till dessa poster.
- **Fristående rendering**: `Blockstudio\Render` returnerar färdig HTML för ett
  block, en komposition eller ett komplett dokument.
- **UI-komponentfamiljer**: `Blockstudio\Ui` grupperar det bundlade biblioteket i
  en offentlig familj per komponent, med ett exempel vardera.
- **Stabila bildmått**: `bs_media_image()` återger temats tillgångar med verkliga
  mått från en genererad `assets/media.json`.
- **Tailwind-klasshjälpare**: `bs_tw_merge()` och `bs_tw_variants()` sätter samman
  klasser i PHP med konfliktmedveten sammanslagning.
- **Prestandaprofiler**: `performance.profile` aktiverar standardvärden för produktionsfrontend
  på en gång; underordnade värden åsidosätter profilen.
- **Typad inställningsåtkomst**: `Settings::get_bool()` och dess syskon läser
  `blockstudio.json` med riktiga typer och visar parsningsfel.
- **En cachekatalog**: alla genererade filer lagras under `cache.path`, sorterade
  efter en runtime-identitet.
- **Statisk för-rendering**: anonyma HTML kan cachelagras, ogiltigförklaras via en
  beroendegraf och levereras innan WordPress startar.
- **Analysförinställningar**: `theme`, `extreme-theme` och `wordpress-render` utökar
  `blockstudio/phpstan` bortom blockmallar.
- **Hanterad commit-hook**: `blockstudio-githooks sync` skriver och äger en
  pre-commit-hook som kör den konfigurerade förinställningen.
- **Projektkontrakt**: `blockstudio-agents` skriver ett `AGENTS.md` som beskriver
  vad ett projekt skapar, vilka funktioner det aktiverar och vad dess förinställning
  tillämpar.
- **Dokumentationsindex**: AI-kontextfilen är nu ett index över varje
  dokument, dess syfte och de identifierare det ansvarar för.
- **Kanoniska blocktaggar**: ett fristående kommando skriver om prefix- och aliasförkortningar
  till `<bs:namespace-slug>`, med en provkörning.
- **Kompatibilitet som standard**: inget ovanstående ändrar en webbplats förrän det anges i
  `blockstudio.json`.

## Läsa och återge ett projekt

### Projektinventering

`Canvas::inventory()` returnerar allt som ett projekt registrerar som en enkel array,
utan att återge något.

```php
use Blockstudio\Canvas;

$result = Canvas::inventory();

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

Poster grupperas efter typ: `pages`, `blocks`, `patterns`, `templates`,
`parts` och `ui`. `order` är den stabila visningsordningen för alla typer,
`sources` kopplar varje post till dess källsökvägar och `warnings` och `errors`
samlar problem som strukturerade poster.

Blockposter innehåller `id`, `name`, `title`, `source`, `path`, `provenance` och en
`declaration` som är redo att återges. Sidposter behåller `source` som stabil identitet
och `path` som mallen för rendering.

### Riktat urval

Genom att ange poster begränsas arbetet i stället för att filtrera i efterhand.

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

Det returnerar ett block och en sida. `patterns`, `templates`, `parts` och `ui`
blir tomma, och deras källor läses, synkas, återges eller kompileras aldrig.

Reglerna är exakta:

- Om inga typnycklar anges läses alla typer in.
- `true`, `null` eller `"*"` läser in alla poster av den typen.
- En sträng eller lista matchar exakt på ID, namn, slug, sökväg eller källsökväg.
- En tom sträng, en tom lista eller `false` läser inte in några poster av den typen.
- När en typnyckel anges förblir utelämnade typer orörda.

Identifierare som inte längre finns returneras under `deleted` i stället för att orsaka ett fel,
och Canvas-slutpunkten REST för uppdatering tillämpar samma regel på sina `blocks`- och
`pages`-parametrar.

`Canvas::documents()` använder samma urval och lägger till ett renderat dokument
per post. Valda sidor återges i en återställd frontend-kontext, så frågevillkor,
body-klasser, kortkoder, layouter, omdirigeringar och enqueue-callbacks ser den sidan,
inte begäran som efterfrågade den.

### Fristående rendering

`Blockstudio\Render` returnerar renderad HTML som en sträng, genom samma
pipeline som frontend använder.

```php
use Blockstudio\Render;

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

En deklarationsform ligger till grund, med fyra nycklar: `name`, `attributes`,
`content` och `children`. `root`, `data`, `inner`, `innerBlocks`, `layers` och
`example` är indataförenklingar som `Render::normalize()` sammanför i den.
Underordnade block återges rekursivt, och felaktig indata kastar ett undantag som namnger
blocket det gäller.

`Render::document()` omsluter utdata i ett komplett fristående HTML-dokument.

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

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

`body` är enbart blockutdata, `html` det sammansatta dokumentet, `blocks` de
blocknamn som bidrog och `assets` delar upp markupen i `head`,
`footer`, `styles`, `scripts`, `modules`, `interactivity`, `ui` och `tailwind`.
Tillgångar begränsas till det som återgavs, så tillgångar enbart för redigeraren visas aldrig.

`Render::document_from_html()` omsluter HTML som återgetts någon annanstans, och
`Render::content()` återger serialiserat blockinnehåll utan ett dokument. Anropa
`Blockstudio\Batch_Render::reset()` mellan dokument i samma PHP-process;
`Canvas::documents()` gör det redan.

### UI-komponentfamiljer

`Blockstudio\Ui` visar det bundlade UI-biblioteket med en post per offentlig
komponent i stället för en lista över interna delar.

`Ui::inventory()` returnerar en post per familj med dess rotblock, titel och
implementationsblocken den behöver. `Ui::examples()` lägger till en deterministisk
deklaration per familj: standardvärden bevaras, obligatoriska underordnade lager bäddas in under
deras föräldrar och stabil exempeltext används där ett fält annars vore tomt. Den
deklarationen är kanonisk och kan därför läggas direkt i `Render::document()`.

Canvas grupperar på samma sätt. Bundlade UI visas under typen `ui` med ett
exempel per familj, och implementationsregistreringar utelämnas från `blocks`.

Familjerna är byggda för att sättas samman: en väljare öppnas inuti en dialog med sin
listbox över utlösaren, menyer och kombinationsrutor fäster med fasta vyportkoordinater
som består vid rullning, modaler staplas och stängs ned med ett Escape i taget,
och varje sidfot kombinerar samma stängningskontroll med en variant. Hur
kopplingarna fungerar och vilka invariabler som håller dem fungerande beskrivs i
[kapitlet om komposition](https://blockstudio.dev/sv/ui/composition/); [/ui/examples](https://blockstudio.dev/sv/ui/examples/) visar kompositionerna i praktiken.

## Mallhjälpare

### Stabila bildmått

`bs_media_image()` återger temats tillgångar med verklig bredd, höjd och ett reserverat
bildförhållande, så bilder utanför mediebiblioteket inte längre får layouten att hoppa.

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

Utdata är en `figure.blockstudio-media` med en inline-`aspect-ratio` runt
en `img` som innehåller verkliga `width`, `height`, `loading` och `decoding`. Måtten
hämtas från en genererad `assets/media.json`, som skrivs av
`Blockstudio\Media_Metadata_Builder` i ett byggsteg eller för hand.

`src` tar en temarelativ sökväg, en absolut sökväg eller en fullständig URL, och
`attachmentId` hanterar bilder från mediebiblioteket. `eager` väljer bort lazy loading
ovanför vecket, och `sources` skriver ut en `<picture>`.

När `performance.media.lazy` är aktiverat flyttas den verkliga URL till `data-src` bakom en
platshållare med rätt storlek.

### Tailwind-klasshjälpare

`bs_tw_merge()` och `bs_tw_variants()` sätter samman Tailwind-klasser i PHP-
mallar med motorn som Blockstudio redan bundlar.

`bs_tw_merge('px-2 text-sm', 'px-4')` returnerar `text-sm px-4`: den motstridiga
`px-2` tas bort och det senare värdet gäller. Nästlade arrayer med klassvärden
accepteras.

`bs_tw_variants()` returnerar en liten anropsbar funktion för 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 skriver ut `inline-flex items-center h-12 px-6 rounded`. Basklasser,
varianter, standardvarianter, sammansatta varianter och ett `class` eller
`className` per anrop stöds alla.

## Produktionskonfiguration

### Prestandaprofiler

`performance.profile` aktiverar standardvärden för produktionsfrontend på ett ställe.

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

`compat` är standard och ändrar ingenting. `speed` och `strict` aktiverar
samma uppsättning: generator-, emoji-, flödes-, upptäckts- och relaterade inläggsdata tas bort ur head; oEmbed-upptäckt och värdskript tas bort; XML–RPC, pingbacks
och fjärrupptäckt av redigeraren inaktiveras; generiska frontend-tillgångar från kärnan tas bort;
standardvärden för bildutdata tillämpas; Heartbeat begränsas utanför redigerare; dokument
från samma ursprung förhämtas vid hovring eller avsikt att fokusera; och Blockstudios bildladdare
används.

Varje underordnat värde åsidosätter profilen, precis som `preload.links` gör ovan. Att ta bort
tillgångar för kärnans frontend är det första att testa, eftersom en sida som är beroende av
dem då går sönder synligt. `Runtime_Settings::current()` visar den upplösta profilen.

`themeDefaults` täcker två saker som teman annars implementerar själva: `titleTag` och
`suppressDirectoryUpdates` för att dölja det aktiva barn- och överordnade temat från uppdateringsresultaten.

### Typad inställningsåtkomst

`Blockstudio\Settings` läser konfiguration med riktiga typer i stället för att returnera
vad JSON innehöll.

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

Felaktig JSON rapporteras via `Settings::errors()` i stället för att falla tillbaka på
standardvärden. `Settings::get_raw()` returnerar bara det som den aktiva källan deklarerat,
vilket skiljer ett värde som satts till `false` från ett värde som aldrig satts.

`Settings::fingerprint()` returnerar en stabil identitet för de gällande inställningarna,
och åtkomsten läser in på nytt när `blockstudio.json` ändras.

### En cachekatalog

Alla genererade filer lagras nu under `cache.path`, som som standard är
`wp-content/blockstudio/cache`.

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

Byggnyttolaster, blockregistreringsdata, redigeringstillgångar, kompilerad Tailwind CSS,
renderingsdokument, öfragment, statiska HTML, grafindex, uppvärmningsköer och
diagnostik lagras alla under den roten. En relativ sökväg utgår från
`WP_CONTENT_DIR`, medan en absolut sökväg pekar den mot en särskild volym.

Objekt lagras under det aktuella nätverket och den aktuella webbplatsen, och därefter under en runtime-identitet: ett fingeravtryck av versionerna för Blockstudio, WordPress och PHP,
gällande inställningar, aktivt tema och aktiva tillägg, upptäcktskällor och de källfiler
som används. Ändras en indata skapas nya objekt för det som påverkas; de gamla rensas bort.

Kalla byggen körs som single-flight: en begäran bygger och publicerar resultatet atomärt medan
övriga väntar. En misslyckad uppdatering fortsätter att leverera det senaste fungerande objektet
samtidigt som felet förblir synligt, och
`Blockstudio\Runtime_Cache::purge('tailwind')` rensar ett omfång.

## Statisk för-rendering

Statisk för-rendering cachelagrar kompletta anonyma HTML-dokument och kan leverera dem
innan WordPress startar. Funktionen är avstängd som standard.

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

### Behörighet

Endast kompletta anonyma HTML-dokument är behöriga. Andra anrop än GET, frågesträngar,
administration, REST, Ajax, cron, flöden, sökningar, förhandsvisningar, anrop med nonce,
personliga cookies och alla sökvägar under `dynamicPaths` hoppas över.
Ett svar kan helt avstå med en `<!-- blockstudio:no-cache -->`-markör.

Sökvägsmatchning respekterar gränser, så `/account` omfattar `/account/orders` men
inte `/accounting`.

### Signatur- och graflägen

`invalidate` avgör hur poster upphör att gälla. Standardläget `signature` fyller ett
identitetsnycklat svar vid en anonym cachemiss och roterar efter ändringar på webbplatsnivå,
vilket passar för en vanlig webbplats.

Läget `graph` är avsett för uttryckliga bygg- och driftsättningsverktyg. Det registrerar varje sidas
egna källberoenden, så en plan bygger bara om de URL:er som påverkas.

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

### Tidig leverans

När `earlyServe` är aktiverat hanterar Blockstudio en liten rutkarta per webbplats och en
`advanced-cache.php`-drop-in som strömmar en behörig träff innan WordPress,
tillägg eller temat startar.

Den skriver aldrig över en extern karta, drop-in eller `WP_CACHE`-deklaration. En grafartefakt
validerar varje refererad HTML-fil innan kartan byts ut, så en ofullständigt renderad driftsättning
lämnar den föregående grafen aktiv. Poster i Multisite hålls åtskilda efter värd, hemsökväg och webbplats-ID.

### Uppvärmning och status

Tre WP-CLI-kommandon täcker den dagliga användningen:

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

`status` rapporterar aktiv identitet, antal filer och byte, grafposter, köstatus och räknare per omfång för träffar, missar, byggen och fel.

## Analys och agentverktyg

### Analysförinställningar

`blockstudio/phpstan` får tre lager ovanpå sin blockanalys, plus ett
kommando som kör det lager ett projekt har valt.

| Förinställning | Vad den lägger till |
| --- | --- |
| `base` | Den befintliga analysen av scheman, mallar, hooks, inställningar och API. |
| `theme` | Temarötter, stilmallshuvuden, tillgångar, väljarskopning, standardvärden för fält och gränser för upprepningsfält. |
| `extreme-theme` | PHPStan `max`, osäker PHP, escaping, Tailwind, JavaScript och kontroller av Interactivity. |
| `wordpress-render` | En anroparstyrd live-renderingskontroll ovanpå `extreme-theme`. |

Standardvärden hämtas från `blockstudio.json`, så interaktiva körningar, CI och commit-hooks
delar en konfiguration:

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

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

Avslutningskoderna är `0` vid godkänt, `1` för diagnostik och `2` vid ogiltig användning. Omslaget bygger ihop sin konfiguration i systemets tillfälliga katalog, så ingen genererad konfiguration, baslinje eller cache hamnar i projektet, och det höjer PHPStans minnesgräns till `1G`.

Det bundlar också en BC Math-leverantör, så JavaScript-kontrollerna behöver inte längre
`ext-bcmath`.

### Hanterad commit-hook

En inställning och ett kommando gör den konfigurerade förinställningen till ett krav vid commit.

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

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

Synkningen skriver hooken och en ägarpost i Gits gemensamma katalog,
pekar `core.hooksPath` mot den hanterade katalogen och kedjar vidare den pre-commit-hook
som tidigare var konfigurerad. Hooken hittar repositoryt och projektroten vid
commit, så länkade checkouts och sökvägar med blanksteg fungerar.

Hooken kör `vendor/bin/blockstudio-phpstan` och inget annat; den formaterar eller skriver aldrig om filer. Om du sätter `commit` till `false` och synkar igen, eller kör `blockstudio-githooks remove`, återställs den registrerade hook-sökvägen och endast filer som ägs av Blockstudio tas bort.

### Projektkontrakt

`blockstudio-agents` skriver ett `AGENTS.md` som anger var block lagras, vad en
sida innebär i projektet, vilka funktioner som är aktiverade och vad analysverktyget kommer att
avvisa.

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

Dokumentet härleds från projektet, det utgår inte från en mall. Ett tema med en `style.css`-header,
block och filbaserade sidor får ett annat kontrakt än ett tillägg som bara registrerar block. Kontraktet innehåller antalen, katalogerna, namnområdena och mallspråken som genomsökningen hittade. `blockstudio.json` avgör vilka funktioner som visas,
så ett projekt utan statisk för-rendering nämner aldrig den funktionen.

Avsnittet om korrekthet läses lager för lager från regel-filerna för den valda förinställningen, så om en förinställning får en regel ändras alla genererade kontrakt.

Ägarskapet fungerar som för commit-hooken. En fil utan den genererade markören
ersätts inte, om inte `--force` anger något annat. Ett anteckningsområde i slutet
bevaras vid återskapande, `--check` avslutas med `1` när kontraktet är inaktuellt och
`--stdout` skriver ut det utan att röra filsystemet.

### Dokumentationsindex

`blockstudio-llm.txt` är nu ett index i stället för en sammanfogning. Varje
publicerat dokument förekommer en gång, under sitt avsnitt och underavsnitt, med sin rutt,
källfil, ett syfte på en rad och de identifierare det ansvarar för: inställningssökvägar,
hooknamn, PHP-funktioner och -klasser samt kommandon.

```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 indexet, hittar det enda dokument som äger identifieraren den behöver och öppnar det dokumentet. Den tidigare sammanfogningen på en halv megabyte genereras och publiceras fortfarande på `/blockstudio-llm-full.txt`; den är inte längre det första någon får tillgång till.

## Kanoniska blocktaggar

Ett fristående kommando skriver om prefix- och aliasförkortningar till den kanoniska stavningen `<bs:namespace-slug>`, som anger det verkliga blocknamnet och löses upp utan att något projektfilter har lästs in.

Med prefixet `brand` för `theme-components` och prefixet `ui` för `bsui` innebär den här förkortningen:

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

betyder samma sak som:

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

Prefix och exakta alias fungerar fortfarande och är inte föråldrade. Kommandot läser inte in WordPress och skriver ingenting utan `--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` mappar varje prefix till sina namnrymder och `--known-blocks` listar registrerade blocknamn. Rapporten dokumenterar mappningar från äldre till kanoniska namn med förekomstantal, hashvärden per fil och separata listor över okända taggar, tvetydiga alias och dynamiska taggar. `--apply` vägrar att skriva medan något av detta återstår, såvida inte `--allow-unresolved` skickas med.

Parvis, nästlad och självstängande markup hanteras, även bokstavliga taggar i strängar med PHP. Endast taggnamnen ändras, en andra körning ger inga ändringar och exempel i kommentarer, kodblock, `<pre>` eller `<code>` rapporteras enbart.

## Standardbeteende

Att installera 7.6 ändrar ingenting i sig.

**Prestandaprofilen är som standard `compat`.** Utdata i head, oEmbed, XML-RPC, Heartbeat, bildstandarder, förhämtning av länkar, lazy loading och frontendens `<title>` förblir som WordPress och temat lämnade dem.

**Följande är avstängt tills det aktiveras:** alla nycklar för `performance.staticPrerender`, `performance.measurement`, `performance.media` och `themeDefaults`, samt `githooks.commit`, `dev.canvas.enabled`, `ui.enabled`, `tailwind.enabled` och `blockTags.enabled`. Statisk förhandsrendering skapar inga filer och installerar ingen drop-in när den är avstängd.

**Canvas och Render är passiva.** De läser befintliga register och renderar endast det som efterfrågas av den som anropar dem; ingen av dem kopplar in sig i frontend-utdata eller registrerar rutter. Canvas adminskärm kräver fortfarande `dev.canvas.enabled` och `edit_posts`.

**Strängare analys måste anges uttryckligen.** Om `blockstudio/phpstan` installeras aktiveras endast bastillägget, och det kanoniska kommandot kör `base` om inget preset anges i projektet.

**Genererade filer kräver att deras kommando körs.** `githooks.commit` gör ingenting förrän `blockstudio-githooks sync` körs, och `AGENTS.md` gör ingenting förrän `blockstudio-agents` körs.

## Uppgradering från 7.5

Kraven är oförändrade: PHP 8.2 eller senare, WordPress 6.7 eller senare.

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

**Cacheminnen byggs om en gång.** Körtidsidentiteten omfattar versionen av Blockstudio, så den första begäran efter uppgraderingen blir en kallstart och gamla objekt rensas bort. Den gamla Tailwind-cachen i `wp-content/uploads/blockstudio/tailwind/cache` kan tas bort; ett kodavsnitt som använde glob på den ska i stället anropa `Blockstudio\Runtime_Cache::purge('tailwind')`.

Den platta katalogen `wp-content/blockstudio/cache/runtime` från före 7.6 byter automatiskt namn så att den flyttas bort från den aktiva sökvägen och tas sedan bort i avgränsade WP-Cron-omgångar. Därför behöver stora äldre träd med låsfiler inte tas bort under en distributionsbegäran.

**Genererade filer har ägare.** `assets/media.json` hör hemma i versionshantering eller ett byggsteg. Ruttkartan, drop-in-filen `advanced-cache.php` och deklarationen `WP_CACHE` finns endast när `earlyServe` är aktiverat, och den förvalda commithaken endast när den är synkroniserad. Allt annat som genereras finns under `cache.path` och kan tas bort utan risk.

**Inget har tagits bort eller bytt namn.** `bs_render_block()`, `bs_block()`, `Blockstudio\Pages` och `Blockstudio\Patterns` är fortfarande de kanoniska innehållsytorna som är filbaserade.

**Återställning sker per funktion.** Tillbaka från `performance.profile` till `compat`, från `staticPrerender.enabled` till `false`, från `githooks.commit` till `false` plus en `sync` och från `cache.enabled` till `false` återställer vart och ett ett lager.

En rimlig ordning för införandet:

1. Ställ in `performance.profile` på `speed` och kontrollera sedan utdata i head, flöden och eventuella tillägg som är beroende av oEmbed eller XML-RPC.
2. Generera `assets/media.json`, flytta mallar till `bs_media_image()` och aktivera sedan `performance.media.lazy`.
3. Aktivera `performance.staticPrerender` med `earlyServe` avstängt, verifiera träffar med `wp bs prerender status` och aktivera sedan `earlyServe`.
4. Kör `blockstudio-phpstan --preset theme` tills allt är felfritt innan något preset läggs bakom `githooks.commit`.

## Var detaljerna finns

- [Canvas](https://blockstudio.dev/sv/docs/dev/canvas/) och dess [inventering och dokument API](https://blockstudio.dev/sv/docs/dev/canvas/#public-inventory-and-document-api)
- [Rendering](https://blockstudio.dev/sv/docs/blocks/rendering/#structured-compositions-and-complete-documents), [UI Components](https://blockstudio.dev/sv/ui/#public-inventory-and-examples) och [UI Composition](https://blockstudio.dev/sv/ui/composition/)
- [Settings](https://blockstudio.dev/sv/docs/general/settings/) och [prestanda](https://blockstudio.dev/sv/docs/general/settings/#performance)
- [Performance](https://blockstudio.dev/sv/docs/production/performance/), [Caching](https://blockstudio.dev/sv/docs/production/caching/) och [Static Prerendering](https://blockstudio.dev/sv/docs/production/static-prerendering/)
- [Tailwind CSS](https://blockstudio.dev/sv/docs/tailwind/#template-composition-helpers)
- [PHPStan](https://blockstudio.dev/sv/docs/dev/phpstan/): [förinställningar](https://blockstudio.dev/sv/docs/dev/phpstan/#analysis-presets), [kanoniskt kommando](https://blockstudio.dev/sv/docs/dev/phpstan/#canonical-command), [hanterad commithake](https://blockstudio.dev/sv/docs/dev/phpstan/#managed-commit-hook) och [projektkontrakt](https://blockstudio.dev/sv/docs/dev/phpstan/#project-contract-for-coding-agents)
- [AI Integration](https://blockstudio.dev/sv/docs/dev/ai/): dokumentationsindexet och hela texten
- [Migration](https://blockstudio.dev/sv/docs/dev/migration/v7/#canonical-block-tags) och [PHP Hooks](https://blockstudio.dev/sv/docs/blocks/hooks/php/)
