
Blockstudio 7.6 face proiectele ușor de inspectat și redat din PHP și mută valorile implicite ale frontend-ului de producție în `blockstudio.json`: un inventar API, redare independentă, ajutoare de șablon pentru media și Tailwind, profiluri de performanță, un singur director cache, prerandare statică cu servire timpurie, presetări de analiză mai stricte și instrumente generate pentru proiecte, destinate agenților de programare.

Două apeluri susțin cea mai mare parte a acestei versiuni. `Canvas::inventory()` returnează fiecare pagină, bloc, model, șablon și parte de șablon ai editorului site-ului, precum și fiecare exemplu UI inclus pe care îl înregistrează un proiect. `Render::document()` returnează HTML finalizat pentru oricare dintre acestea, împreună cu exact activele folosite la redare.

> **Actualizare 7.6.2:** Paginile bazate pe fișiere nu se mai reconciliază în timpul cererilor obișnuite WordPress. Rulați `wp bs pages sync` sau apelați `Blockstudio\Pages::reconcile()` când aplicați modificări ale sursei. Rutarea colecțiilor și valorile implicite `templateFor` folosesc configurația persistentă a mediului de execuție, iar reconcilierea explicită evită interogarea OR-meta multilingvă, mare, folosită anterior. Opțiunea `themeDefaults.syncPagesInDevelopment` cu durată scurtă a fost eliminată, deoarece sincronizarea paginilor nu mai rulează din hook-urile cererii. `Pages::init()` este acum folosit doar la inițializare; integrările care transmiteau `force` trebuie să folosească `Pages::reconcile()` sau CLI. Deschiderea Canvas efectuează în continuare o reconciliere explicită, autentificată, pentru inventarul de creare.

> **7.6.12 actualizare:** Foaile de stil ale editorului sunt acum prefixate printr-o singură
> trecere de rescriere, în locul unei compilări SASS pentru fiecare resursă, astfel încât compilarea rece a editorului pe
> un site cu multe blocuri nu mai riscă să epuizeze o limită modestă de memorie. O
> pagină prerandată din cache, al cărei foaie de stil cu hash de conținut Tailwind a fost
> eliminată, este randată din nou în loc să fie servită fără stiluri, atât prin cache-ul PHP,
> cât și prin modulul Early Serve. Atributele blocurilor scrise la nivel superior sunt
> citite la randare în loc să fie eliminate, astfel încât schema Blockstudio
> înregistrează pe `WP_Block_Type` este respectată de scriitorii programatici.

> **7.6.11 actualizare:** Instalarea artefactelor Graph înlocuiește acum atomic documentul unei rute
> când copia din magazin s-a schimbat sub aceeași cheie, păstrează documentele
> identice nemodificate și raportează rutele promovate, înlocuite, omise și
> păstrate prin `Static_Prerender_Early_Serve::last_promotion()`.

> **7.6.10 actualizare:** Accesările din cache-ul de rulare detectează acum resursele compilate eliminate chiar
> și în intervalul de debounce al monitorizării, iar cache-urile plate de rulare anterioare versiunii 7.6 sunt puse în carantină atomic și șterse în loturi cron limitate. Globalele UI incluse în pachet sunt emise o singură dată
> per pagină. Early Serve în modul Graph poate servi rute randate live din afara
> hărții rutelor implementate, folosind cache-ul de identitate. Tailwind poate emite opțional fișierul cache cu hash de conținut folosind `tailwind.output: "link"`; ieșirea inline rămâne
> implicită.

Pe scurt:

- **Inventarul proiectului**: `Canvas::inventory()` returnează fiecare înregistrare
  înregistrată, împreună cu sursele și o ordine stabilă de afișare.
- **Selecție țintită**: numirea blocurilor și paginilor restrânge descoperirea, sincronizarea,
  randarea și compilarea la acele înregistrări.
- **Randare autonomă**: `Blockstudio\Render` returnează HTML finalizat pentru un
  bloc, o compoziție sau un document complet.
- **UI familii de componente**: `Blockstudio\Ui` grupează biblioteca inclusă în pachet în
  câte o familie publică pentru fiecare componentă, cu câte un exemplu.
- **Dimensiuni stabile ale imaginilor**: `bs_media_image()` randează resursele temei cu
  dimensiuni reale dintr-un `assets/media.json` generat.
- **Tailwind utilitare pentru clase**: `bs_tw_merge()` și `bs_tw_variants()` compun
  clase în PHP cu îmbinare care ține cont de conflicte.
- **Profiluri de performanță**: `performance.profile` activează dintr-o dată valorile implicite pentru frontend-ul de producție; valorile copiilor au prioritate.
- **Acces tipizat la setări**: `Settings::get_bool()` și funcțiile sale surori citesc
  `blockstudio.json` cu tipuri reale și semnalează erorile de analiză.
- **Un singur director cache**: fiecare fișier generat este stocat sub `cache.path`, identificat
  printr-o identitate de rulare.
- **Prerandare statică**: HTML anonime pot fi stocate în cache, invalidate printr-un
  graf de dependențe și servite înainte ca WordPress să pornească.
- **Presetări de analiză**: `theme`, `extreme-theme` și `wordpress-render` extind
  `blockstudio/phpstan` dincolo de șabloanele blocurilor.
- **Hook de commit gestionat**: `blockstudio-githooks sync` scrie și gestionează un
  hook pre-commit care rulează presetarea configurată.
- **Contractul proiectului**: `blockstudio-agents` scrie un `AGENTS.md` care descrie
  ce creează autorii proiectului, ce funcționalități activează și ce impune presetarea.
- **Indexul documentației**: fișierul de context pentru AI este acum un index al fiecărui
  document, al scopului său și al identificatorilor pe care îi deține.
- **Etichete canonice pentru blocuri**: o comandă independentă rescrie prescurtările de prefix și alias în `<bs:namespace-slug>`, cu o rulare de probă.
- **Compatibilitate implicită**: nimic din cele de mai sus nu schimbă un site până când nu este numit în
  `blockstudio.json`.

## Citirea și randarea unui proiect

### Inventarul proiectului

`Canvas::inventory()` returnează tot ce înregistrează un proiect sub forma unui singur tablou simplu,
fără să randeze nimic.

```php
use Blockstudio\Canvas;

$result = Canvas::inventory();

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

Înregistrările sunt grupate după tip: `pages`, `blocks`, `patterns`, `templates`,
`parts` și `ui`. `order` este ordinea stabilă de afișare pentru toate tipurile,
`sources` asociază fiecărei înregistrări căile surselor, iar `warnings` și `errors`
colectează problemele ca intrări structurate.

Înregistrările blocurilor includ `id`, `name`, `title`, `source`, `path`, `provenance` și un `declaration` gata de randare. Înregistrările paginilor păstrează `source` drept identitate stabilă și `path` drept șablonul care randează.

### Selecție țintită

Numirea înregistrărilor restrânge activitatea, în loc să filtreze rezultatele ulterior.

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

Aceasta returnează un bloc și o pagină. `patterns`, `templates`, `parts` și `ui`
sunt returnate goale, iar sursele lor nu sunt niciodată citite, sincronizate, randate sau
compilate.

Regulile sunt exacte:

- Fără chei de tip, se încarcă toate tipurile.
- `true`, `null` sau `"*"` încarcă toate înregistrările de acel tip.
- Un șir sau o listă se potrivește exact după ID, nume, slug, cale sau cale sursă.
- Un șir gol, o listă goală sau `false` nu încarcă nimic pentru acel tip.
- După ce este prezentă o cheie de tip, tipurile omise rămân neatinse.

Identificatorii care nu mai există sunt returnați sub `deleted` în loc să provoace o eroare,
iar endpointul de reîmprospătare Canvas REST aplică aceeași regulă parametrilor săi `blocks` și
`pages`.

`Canvas::documents()` folosește aceeași selecție și adaugă câte un document randat
pentru fiecare înregistrare. Paginile selectate sunt randate într-un context frontend restaurat, astfel încât condiționalele de interogare, clasele body, shortcode-urile, aspectele, redirecționările și callback-urile enqueue văd pagina respectivă, nu cererea care a solicitat-o.

### Randare autonomă

`Blockstudio\Render` returnează HTML randat ca șir, prin aceeași
conductă folosită de frontend.

```php
use Blockstudio\Render;

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

La bază există o singură formă de declarație, cu patru chei: `name`, `attributes`,
`content` și `children`. `root`, `data`, `inner`, `innerBlocks`, `layers` și
`example` sunt forme de intrare convenabile pe care `Render::normalize()` le integrează în aceasta.
Copiii sunt randați recursiv, iar datele de intrare malformate generează o excepție care numește blocul
cu probleme.

`Render::document()` învelește ieșirea într-un document HTML autonom complet.

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

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

`body` este doar ieșirea blocului, `html` este documentul asamblat, `blocks` sunt
numele blocurilor care au contribuit, iar `assets` împarte marcajul în `head`,
`footer`, `styles`, `scripts`, `modules`, `interactivity`, `ui` și `tailwind`.
Resursele sunt limitate la ceea ce s-a randat, astfel încât resursele exclusiv pentru editor nu apar.

`Render::document_from_html()` învelește HTML randat în altă parte, iar
`Render::content()` randează conținutul blocurilor serializat fără un document. Apelați
`Blockstudio\Batch_Render::reset()` între documente în cadrul aceluiași proces PHP;
`Canvas::documents()` o face deja.

### UI familii de componente

`Blockstudio\Ui` expune biblioteca UI inclusă în pachet cu o intrare pentru fiecare componentă publică, în locul unei liste de părți interne.

`Ui::inventory()` returnează câte o intrare pentru fiecare familie, cu blocul rădăcină, titlul și
blocurile de implementare necesare. `Ui::examples()` adaugă câte o
declarație deterministă pentru fiecare familie: valorile implicite sunt păstrate, straturile copil obligatorii sunt imbricate sub
părinții lor, iar textul ilustrativ stabil este folosit când un câmp ar fi gol. Această
declarație este canonică, așa că poate fi introdusă direct în `Render::document()`.

Canvas le grupează în același mod. Elementele UI incluse în pachet apar sub tipul `ui`, câte un
exemplu pentru fiecare familie, iar înregistrările de implementare nu apar în `blocks`.

Familiile sunt concepute pentru asamblare: un selector se deschide într-un dialog, cu lista sa suprapusă peste declanșator; meniurile și casetele combinate se ancorează folosind coordonate fixe în fereastra de vizualizare, care rezistă derulării; modalele se suprapun și se închid pe rând, câte una la fiecare apăsare pe Escape; iar fiecare subsol combină același control de închidere cu o variantă. Modul în care funcționează aceste îmbinări și invariantele care le mențin funcționale sunt prezentate în capitolul despre [compoziție](https://blockstudio.dev/ro/ui/composition/); [/ui/examples](https://blockstudio.dev/ro/ui/examples/) arată compozițiile în funcțiune.

## Utilitare pentru șabloane

### Dimensiuni stabile ale imaginilor

`bs_media_image()` randează resursele temei cu lățimea și înălțimea reale și un
raport de aspect rezervat, astfel încât imaginile din afara bibliotecii media să nu mai deplaseze aspectul.

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

Rezultatul este un `figure.blockstudio-media` cu un `aspect-ratio` inline în jurul
unui `img` care conține `width`, `height`, `loading` și `decoding` reale. Dimensiunile
provin dintr-un `assets/media.json` generat, scris de
`Blockstudio\Media_Metadata_Builder` într-o etapă de compilare sau manual.

`src` acceptă o cale relativă la temă, o cale absolută sau un URL complet, iar
`attachmentId` se ocupă de imaginile din biblioteca media. `eager` dezactivează încărcarea leneșă
pentru conținutul de deasupra pliului, iar `sources` emite un `<picture>`.

Când `performance.media.lazy` este activat, URL real se mută în `data-src`, în spatele unui
substituent dimensionat corect.

### Tailwind utilitare pentru clase

`bs_tw_merge()` și `bs_tw_variants()` compun clase Tailwind în șabloane PHP,
folosind motorul Blockstudio pe care îl include deja.

`bs_tw_merge('px-2 text-sm', 'px-4')` returnează `text-sm px-4`: elementul conflictual
`px-2` este eliminat, iar valoarea ulterioară câștigă. Sunt acceptate tablouri imbricate cu valori de clase.

`bs_tw_variants()` returnează o funcție mică pentru variantele componentelor:

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

Aceasta afișează `inline-flex items-center h-12 px-6 rounded`. Sunt acceptate clasele de bază,
variantele, variantele implicite, variantele compuse și un `class` sau `className` pentru fiecare apel.

## Configurare pentru producție

### Profiluri de performanță

`performance.profile` activează dintr-un singur loc valorile implicite pentru frontend-ul de producție.

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

`compat` este implicit și nu schimbă nimic. `speed` și `strict` activează același set: elimină din head generatorul, emoji-urile, fluxul, descoperirea și ieșirea pentru articolele adiacente; elimină descoperirea oEmbed și scripturile gazdă; dezactivează XML-RPC, pingback-urile și descoperirea editorului la distanță; elimină resursele frontend generice ale nucleului; aplică valorile implicite pentru ieșirea imaginilor; limitează Heartbeat în afara editorilor; preîncarcă documentele de aceeași origine la intenția de trecere cu mouse-ul sau de focalizare; și folosește încărcătorul de imagini al Blockstudio.

Fiecare valoare copil suprascrie profilul, așa cum face `preload.links` mai sus. Eliminarea resurselor frontend ale nucleului este primul lucru de testat, deoarece o pagină care depinde de ele se strică vizibil. `Runtime_Settings::current()` expune profilul rezolvat.

`themeDefaults` acoperă două lucruri pe care temele le implementează de obicei manual: `titleTag` și `suppressDirectoryUpdates` pentru a ascunde tema copil activă și tema părinte din rezultatele actualizărilor.

### Acces tipizat la setări

`Blockstudio\Settings` citește configurația cu tipuri reale, în loc să returneze
orice conținea JSON.

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

JSON malformat este raportat prin `Settings::errors()` în loc să fie rezolvat la
valorile implicite. `Settings::get_raw()` returnează doar ceea ce a declarat sursa activă,
ceea ce diferențiază o valoare setată la `false` de una care nu a fost setată niciodată.

`Settings::fingerprint()` returnează o identitate stabilă pentru setările efective,
iar accesul reîncarcă datele când se schimbă `blockstudio.json`.

### Un singur director cache

Fiecare fișier generat se află acum sub `cache.path`, care implicit este
`wp-content/blockstudio/cache`.

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

Datele de compilare, datele de înregistrare a blocurilor, resursele editorului, Tailwind CSS compilate,
documentele randate, fragmentele de insulă, HTML statice, indexurile graph, cozile de încălzire și
diagnosticările se află toate sub acel director rădăcină. O cale relativă se rezolvă pornind din
`WP_CONTENT_DIR`, iar o cale absolută indică un volum dedicat.

Obiectele sunt stocate sub rețeaua și site-ul curente, apoi sub o identitate de rulare: o amprentă a versiunilor Blockstudio, WordPress și PHP, a setărilor efective, a temei și pluginurilor active, a surselor de descoperire și a fișierelor sursă implicate. Dacă se schimbă o intrare, obiectele afectate devin obiecte noi; cele vechi sunt eliminate.

Compilările reci sunt cu execuție unică: o cerere construiește și publică atomic rezultatul, în timp ce celelalte așteaptă. O reîmprospătare eșuată continuă să servească ultimul obiect valid, iar eșecul rămâne vizibil și
`Blockstudio\Runtime_Cache::purge('tailwind')` șterge un domeniu.

## Prerandare statică

Prerandarea statică stochează în cache documente HTML anonime complete și le poate servi
înainte ca WordPress să pornească. Este dezactivată implicit.

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

### Eligibilitate

Sunt eligibile numai documentele HTML anonime complete. Cererile non-GET, șirurile
query, zona de administrare, REST, Ajax, cron, fluxurile, căutările, previzualizările, cererile care conțin nonce, cookie-urile personalizate și orice cale de sub `dynamicPaths` sunt ocolite.
Un răspuns se poate exclude complet cu un marcaj `<!-- blockstudio:no-cache -->`.

Potrivirea căilor respectă limitele, astfel încât `/account` acoperă `/account/orders`, dar
nu și `/accounting`.

### Moduri de semnătură și graph

`invalidate` alege modul în care expiră intrările. Modul implicit `signature` completează un răspuns identificat prin cheie de identitate la o solicitare anonimă fără rezultat în cache și îl rotește după modificări la nivelul site-ului, ceea ce se potrivește unui site obișnuit.

Modul `graph` este destinat instrumentelor explicite de compilare și implementare. Înregistrează dependențele sursă proprii fiecărei pagini, astfel încât un plan să recompileze numai URL-urile afectate.

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

### Servire timpurie

Când `earlyServe` este activat, Blockstudio gestionează o mică hartă de rute pentru fiecare site și un modul `advanced-cache.php` care transmite un rezultat eligibil din cache înainte ca WordPress, pluginurile sau tema să pornească.

Nu suprascrie niciodată o hartă, un modul sau o declarație `WP_CACHE` care aparține altcuiva. Un artefact graph validează fiecare fișier HTML referit înainte ca harta să fie înlocuită, astfel încât o implementare randată doar parțial lasă graful anterior activ. Intrările multisite rămân izolate după gazdă, calea principală și ID-ul site-ului.

### Încălzire și stare

Trei comenzi WP-CLI acoperă utilizarea zilnică:

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

`status` raportează identitatea activă, numărul de fișiere și octeți, înregistrările graph, starea cozii și contoarele de accesări, ratări, compilări și eșecuri pentru fiecare domeniu.

## Analiză și instrumente pentru agenți

### Presetări de analiză

`blockstudio/phpstan` adaugă trei niveluri peste analiza blocurilor și o comandă
care rulează nivelul ales de un proiect.

| Presetare | Ce adaugă |
| --- | --- |
| `base` | Analiza existentă a schemei, șabloanelor, hook-urilor, setărilor și API. |
| `theme` | Rădăcinile temei, antetele stilurilor, resursele, limitarea selectorilor, valorile implicite ale câmpurilor și limitele repetoarelor. |
| `extreme-theme` | PHPStan `max`, PHP nesigur, escaparea, Tailwind, JavaScript și verificările Interactivity. |
| `wordpress-render` | O sondă de randare live furnizată de apelant, peste `extreme-theme`. |

Valorile implicite provin din `blockstudio.json`, astfel încât rulările interactive, CI și hook-urile de commit
folosesc aceeași configurație:

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

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

Codurile de ieșire sunt `0` pentru succes, `1` pentru diagnosticări și `2` pentru utilizare nevalidă. Wrapper-ul își compune configurația în directorul temporar al sistemului, astfel încât niciun fișier de configurare, punct de referință sau cache generat nu ajunge în proiect, și ridică limita de memorie a PHPStan la `1G`.

De asemenea, include un furnizor BC Math, astfel încât verificările JavaScript nu mai au nevoie de
`ext-bcmath`.

### Hook de commit gestionat

O setare și o comandă transformă presetarea configurată într-un prag pentru commit.

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

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

Sincronizarea scrie hook-ul și o înregistrare de proprietate în directorul comun al Git,
indică `core.hooksPath` către directorul gestionat și înlănțuiește orice hook pre-commit
configurat anterior. Hook-ul identifică depozitul și rădăcina proiectului în momentul commitului, astfel încât checkout-urile legate și căile care conțin spații funcționează.

Hook-ul rulează `vendor/bin/blockstudio-phpstan` și nimic altceva; nu formatează și nu rescrie niciodată fișiere. Setarea `commit` la `false` și sincronizarea din nou sau rularea `blockstudio-githooks remove` restabilește calea hook-ului înregistrată și șterge numai fișierele deținute de Blockstudio.

### Contractul proiectului

`blockstudio-agents` scrie un `AGENTS.md` care precizează unde se află blocurile, ce înseamnă o pagină în acest proiect, ce funcționalități sunt activate și ce va respinge analizorul.

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

Documentul este derivat, nu bazat pe un șablon. O temă cu un antet `style.css`,
blocuri și pagini bazate pe fișiere primește un contract diferit de cel al unui plugin care doar
înregistrează blocuri; contractul include numărul, directoarele, spațiile de nume și limbajele de șablon găsite de scaner. `blockstudio.json` stabilește ce funcționalități apar,
așa că un proiect fără prerandare statică nu va menționa niciodată această funcționalitate.

Secțiunea despre corectitudine este citită din fișierele de reguli proprii presetării selectate, nivel cu nivel, astfel încât adăugarea unei reguli la o presetare modifică fiecare contract generat odată cu ea.

Gestionarea proprietății funcționează ca pentru hook-ul de commit. Un fișier fără marcajul generat este refuzat în loc să fie înlocuit, cu excepția cazului în care `--force` indică altfel; o zonă de note de la final este păstrată la regenerare; `--check` se încheie cu `1` când contractul nu este actualizat; iar `--stdout` îl afișează fără să atingă sistemul de fișiere.

### Indexul documentației

`blockstudio-llm.txt` este acum un index în locul unei concatenări. Fiecare
 document publicat apare o singură dată, în secțiunea și subsecțiunea sa, împreună cu ruta,
fișierul sursă, o descriere de un rând a scopului și identificatorii pe care îi deține: căi
 de setări, nume de hook-uri, funcții și clase PHP și comenzi.

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

Un agent citește indexul, găsește documentul care conține identificatorul de care are nevoie și deschide documentul respectiv. Concatenarea anterioară de jumătate de megabyte este în continuare generată și publicată la `/blockstudio-llm-full.txt`; nu mai este primul lucru oferit cuiva.

## Etichete canonice de bloc

O comandă de sine stătătoare rescrie prescurtările de prefix și alias în forma canonică `<bs:namespace-slug>`, care înregistrează numele real al blocului și se rezolvă fără un filtru de proiect încărcat.

Cu prefixul `brand` pentru `theme-components` și prefixul `ui` pentru `bsui`, această prescurtare:

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

înseamnă același lucru ca:

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

Prefixele și aliasurile exacte funcționează în continuare și nu sunt depreciate. Comanda nu încarcă WordPress și nu scrie nimic fără `--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` asociază fiecare prefix cu spațiile sale de nume, iar `--known-blocks` listează numele blocurilor înregistrate. Raportul înregistrează asocierile de la forma veche la cea canonică, cu numărul de apariții, hashuri per fișier și liste separate pentru etichete necunoscute, aliasuri ambigue și etichete dinamice. `--apply` refuză să scrie cât timp există oricare dintre acestea, cu excepția cazului în care se transmite `--allow-unresolved`.

Marcajele pereche, imbricate și cu închidere automată sunt gestionate, inclusiv etichetele literale din șirurile PHP. Se schimbă doar numele etichetelor, o a doua rulare nu produce nicio modificare, iar exemplele din comentarii, blocuri de cod, `<pre>` sau `<code>` sunt doar raportate.

## Comportamentul implicit

Instalarea versiunii 7.6 nu schimbă nimic de la sine.

**Profilul de performanță este dezactivat implicit: `compat`.** Ieșirea head, oEmbed, XML-RPC, Heartbeat, valorile implicite pentru imagini, preîncărcarea linkurilor, încărcarea leneșă și `<title>` din interfața publică rămân așa cum WordPress și tema le-au lăsat.

**Acestea rămân dezactivate până la activare:** fiecare cheie `performance.staticPrerender`, `performance.measurement`, `performance.media` și `themeDefaults`, precum și `githooks.commit`, `dev.canvas.enabled`, `ui.enabled`, `tailwind.enabled` și `blockTags.enabled`. Prerandarea statică nu scrie fișiere și nu instalează o componentă drop-in cât timp este dezactivată.

**Canvas și Render sunt pasive.** Citesc registrele existente și redau doar ceea ce solicită apelantul; niciuna nu se conectează la ieșirea interfeței publice și nu înregistrează rute. Ecranul Canvas din administrare necesită în continuare `dev.canvas.enabled` și `edit_posts`.

**Analiza mai strictă trebuie activată explicit.** Instalarea `blockstudio/phpstan` activează doar extensia de bază, iar comanda canonică rulează `base` dacă proiectul nu specifică o presetare.

**Fișierele generate necesită rularea comenzii aferente.** `githooks.commit` nu face nimic până când rulează `blockstudio-githooks sync`, iar `AGENTS.md` nu face nimic până când rulează `blockstudio-agents`.

## Actualizarea de la 7.5

Cerințele rămân neschimbate: PHP 8.2 sau o versiune mai nouă, WordPress 6.7 sau o versiune mai nouă.

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

**Cache-urile se reconstruiesc o singură dată.** Identitatea runtime-ului include versiunea Blockstudio, așadar prima solicitare după actualizare pornește fără cache, iar obiectele vechi sunt eliminate. Cache-ul Tailwind vechi din `wp-content/uploads/blockstudio/tailwind/cache` poate fi șters; un fragment de cod care îl căuta cu un glob ar trebui să apeleze `Blockstudio\Runtime_Cache::purge('tailwind')` în schimb.

Directorul `wp-content/blockstudio/cache/runtime` plat anterior versiunii 7.6 este redenumit automat în afara căii active și eliminat prin treceri WP-Cron limitate. Prin urmare, arborii mari de fișiere de blocare vechi nu trebuie șterși în timpul unei solicitări de implementare.

**Fișierele generate au proprietari.** `assets/media.json` trebuie inclus în controlul versiunilor sau într-un pas de compilare. Harta rutelor, componenta drop-in `advanced-cache.php` și declarația `WP_CACHE` există doar cât timp `earlyServe` este activată, iar hook-ul de pre-commit doar cât timp este sincronizat. Tot ce este generat în rest se află sub `cache.path` și poate fi șters în siguranță.

**Nimic nu a fost eliminat sau redenumit.** `bs_render_block()`, `bs_block()`, `Blockstudio\Pages` și `Blockstudio\Patterns` rămân suprafețele canonice de conținut bazate pe fișiere.

**Revenirea la o versiune anterioară se face per funcționalitate.** `performance.profile` înapoi la `compat`, `staticPrerender.enabled` la `false`, `githooks.commit` la `false` plus un `sync` și `cache.enabled` la `false` anulează fiecare câte un nivel.

O ordine rezonabilă de adoptare:

1. Setați `performance.profile` la `speed`, apoi verificați ieșirea head, fluxurile și orice modul care se bazează pe oEmbed sau XML-RPC.
2. Generați `assets/media.json`, mutați șabloanele în `bs_media_image()`, apoi activați `performance.media.lazy`.
3. Activați `performance.staticPrerender` cu `earlyServe` dezactivat, verificați accesările cu `wp bs prerender status`, apoi activați `earlyServe`.
4. Rulați `blockstudio-phpstan --preset theme` până când nu mai raportează probleme, înainte de a pune orice presetare în spatele `githooks.commit`.

## Unde găsiți detaliile

- [Canvas](https://blockstudio.dev/ro/docs/dev/canvas/) și [inventarulAPI documentelor ](https://blockstudio.dev/ro/docs/dev/canvas/#public-inventory-and-document-api)
- [Redarea](https://blockstudio.dev/ro/docs/blocks/rendering/#structured-compositions-and-complete-documents), [ComponenteleUI ](https://blockstudio.dev/ro/ui/#public-inventory-and-examples) și [CompozițiaUI ](https://blockstudio.dev/ro/ui/composition/)
- [Setările](https://blockstudio.dev/ro/docs/general/settings/) și [performanța](https://blockstudio.dev/ro/docs/general/settings/#performance)
- [Performanța](https://blockstudio.dev/ro/docs/production/performance/), [Cache-ul](https://blockstudio.dev/ro/docs/production/caching/) și [Prerandarea statică](https://blockstudio.dev/ro/docs/production/static-prerendering/)
- [DocumentațiaTailwind CSS ](https://blockstudio.dev/ro/docs/tailwind/#template-composition-helpers)
- [DezvoltareaPHPStan ](https://blockstudio.dev/ro/docs/dev/phpstan/): [presetări](https://blockstudio.dev/ro/docs/dev/phpstan/#analysis-presets), [comanda canonică](https://blockstudio.dev/ro/docs/dev/phpstan/#canonical-command), [hook-ul de commit gestionat](https://blockstudio.dev/ro/docs/dev/phpstan/#managed-commit-hook) și [contractul proiectului](https://blockstudio.dev/ro/docs/dev/phpstan/#project-contract-for-coding-agents)
- [Integrarea AI](https://blockstudio.dev/ro/docs/dev/ai/): indexul documentației și textul complet
- [Migrarea](https://blockstudio.dev/ro/docs/dev/migration/v7/#canonical-block-tags) și [hook-urilePHP ](https://blockstudio.dev/ro/docs/blocks/hooks/php/)
