
Blockstudio 7.6 permet de lire et de rendre un projet depuis PHP, et transfère les paramètres par défaut du frontend de production vers `blockstudio.json` : un inventaire API, le rendu autonome, des aides de modèle pour les médias et Tailwind, des profils de performance, un répertoire de cache unique, le pré-rendu statique avec diffusion anticipée, des préréglages d’analyse plus stricts et des outils de projet générés pour les agents de programmation.

Deux appels couvrent l’essentiel de cette version. `Canvas::inventory()` renvoie chaque page, bloc, composition, modèle de l’éditeur de site, partie de modèle et exemple UI groupé enregistré par un projet. `Render::document()` renvoie le HTML final pour chacun d’eux, avec exactement les ressources utilisées pour le rendu.

> **Mise à jour de 7.6.2 :** les pages issues de fichiers ne sont plus réconciliées lors des requêtes WordPress ordinaires. Exécutez `wp bs pages sync` ou appelez `Blockstudio\Pages::reconcile()` lors de l’application des modifications des sources. Le routage des collections et les paramètres par défaut de `templateFor` utilisent la configuration d’exécution persistée, et la réconciliation explicite évite désormais l’ancienne grande requête OR-meta multilingue. L’option `themeDefaults.syncPagesInDevelopment`, qui avait une courte durée de vie, a été supprimée, car la synchronisation des pages ne s’exécute plus depuis les hooks de requête. `Pages::init()` est désormais réservé à l’initialisation ; les intégrations qui transmettaient `force` doivent utiliser `Pages::reconcile()` ou CLI. L’ouverture de Canvas effectue toujours une réconciliation explicite, authentifiée et unique pour l’inventaire de création.

> **7.6.12 mise à jour :** Les feuilles de style de l’éditeur sont désormais préfixées en une seule passe de réécriture, au lieu d’une compilation SASS par ressource. Ainsi, une compilation à froid de l’éditeur sur un site comportant de nombreux blocs ne risque plus d’épuiser une limite de mémoire modeste. Lorsqu’une feuille de style Tailwind dont le nom contient un hachage de contenu a été évincée, la page pré-rendue en cache est de nouveau rendue au lieu d’être servie sans style, aussi bien via le cache PHP que via le drop-in Early Serve. Les attributs de bloc écrits à la racine sont lus au rendu au lieu d’être ignorés : le schéma Blockstudio enregistré sur `WP_Block_Type` est donc respecté par les outils d’écriture programmatiques.

> **7.6.11 mise à jour :** L’installation des artefacts du graphe remplace désormais atomiquement le document d’une route lorsque la copie du magasin a changé sous la même clé, laisse intacts les documents identiques et indique les routes promues, remplacées, ignorées et conservées via `Static_Prerender_Early_Serve::last_promotion()`.

> **7.6.10 mise à jour :** Les accès au cache d’exécution détectent désormais les ressources compilées supprimées, même pendant le délai de temporisation de la surveillance. Les anciens caches d’exécution plats, antérieurs à la version 7.6, sont mis en quarantaine atomiquement puis supprimés par lots cron de taille limitée. Les variables globales UI intégrées ne sont émises qu’une fois par page. En mode graphe, Early Serve peut servir depuis le cache d’identité des routes rendues à la volée qui ne figurent pas dans la carte des routes déployée. Tailwind peut, en option, émettre son fichier de cache dont le nom contient un hachage de contenu avec `tailwind.output: "link"` ; la sortie en ligne reste le comportement par défaut.

En bref :

- **Inventaire du projet** : `Canvas::inventory()` renvoie chaque enregistrement inscrit, avec ses sources et un ordre d’affichage stable.
- **Sélection ciblée** : nommer des blocs et des pages limite la découverte, la synchronisation, le rendu et la compilation à ces enregistrements.
- **Rendu autonome** : `Blockstudio\Render` renvoie du HTML finalisé pour un bloc, une composition ou un document complet.
- **Familles de composants UI** : `Blockstudio\Ui` regroupe la bibliothèque intégrée en une famille publique par composant, avec un exemple pour chacune.
- **Dimensions d’image stables** : `bs_media_image()` rend les ressources du thème avec leurs dimensions réelles, issues d’un `assets/media.json` généré.
- **Assistants de classes Tailwind** : `bs_tw_merge()` et `bs_tw_variants()` composent des classes dans PHP en fusionnant celles qui entrent en conflit.
- **Profils de performance** : `performance.profile` active d’un coup les paramètres par défaut de production côté frontend ; les valeurs enfants les remplacent.
- **Accès typé aux réglages** : `Settings::get_bool()` et ses fonctions associées lisent `blockstudio.json` avec des types réels et signalent les erreurs d’analyse.
- **Répertoire de cache unique** : chaque fichier généré se trouve sous `cache.path` et est indexé par une identité d’exécution.
- **Pré-rendu statique** : les documents HTML anonymes peuvent être mis en cache, invalidés via un graphe de dépendances et servis avant le démarrage de WordPress.
- **Préréglages d’analyse** : `theme`, `extreme-theme` et `wordpress-render` étendent `blockstudio/phpstan` au-delà des modèles de blocs.
- **Hook de commit géré** : `blockstudio-githooks sync` écrit et gère un hook pre-commit qui exécute le préréglage configuré.
- **Contrat de projet** : `blockstudio-agents` écrit un `AGENTS.md` qui décrit ce que les auteurs du projet créent, les fonctionnalités activées et les règles imposées par le préréglage.
- **Index de documentation** : le fichier de contexte de l’IA est désormais un index de chaque document, de son objectif et des identifiants qui lui appartiennent.
- **Balises de bloc canoniques** : une commande autonome réécrit les formes abrégées des préfixes et des alias en `<bs:namespace-slug>`, avec une simulation préalable.
- **Compatibilité par défaut** : aucun des éléments ci-dessus ne modifie un site tant qu’il n’est pas nommé dans `blockstudio.json`.

## Lecture et rendu d’un projet

### Inventaire du projet

`Canvas::inventory()` renvoie dans un tableau simple tout ce qu’un projet a enregistré, sans rien rendre.

```php
use Blockstudio\Canvas;

$result = Canvas::inventory();

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

Les enregistrements sont regroupés par type : `pages`, `blocks`, `patterns`, `templates`, `parts` et `ui`. `order` définit l’ordre d’affichage stable de tous les types, `sources` associe chaque enregistrement à ses chemins source, et `warnings` et `errors` regroupent les problèmes dans des entrées structurées.

Les enregistrements de bloc contiennent `id`, `name`, `title`, `source`, `path`, `provenance` et un `declaration` prêt à être rendu. Les enregistrements de page conservent `source` comme identité stable et `path` comme modèle de rendu.

### Sélection ciblée

Nommer les enregistrements limite le travail au lieu de filtrer après coup.

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

Cela renvoie un bloc et une page. `patterns`, `templates`, `parts` et `ui` sont vides, et leurs sources ne sont jamais lues, synchronisées, rendues ni compilées.

Les règles sont précises :

- En l’absence de clés de type, tous les types sont chargés.
- `true`, `null` ou `"*"` charge tous les enregistrements de ce type.
- Une chaîne ou une liste correspond exactement à l’ID, au nom, au slug, au chemin ou au chemin source.
- Une chaîne vide, une liste vide ou `false` ne charge aucun enregistrement de ce type.
- Dès qu’une clé de type est présente, les types omis restent intacts.

Les identifiants qui n’existent plus sont renvoyés sous `deleted` au lieu de provoquer une erreur. Le point de terminaison d’actualisation REST de Canvas applique la même règle à ses paramètres `blocks` et `pages`.

`Canvas::documents()` reprend la même sélection et ajoute un document rendu par enregistrement. Les pages sélectionnées sont rendues dans un contexte frontend restauré : les conditions de requête, les classes du corps, les shortcodes, les mises en page, les redirections et les rappels d’ajout de ressources tiennent ainsi compte de cette page, et non de la requête qui l’a demandée.

### Rendu autonome

`Blockstudio\Render` renvoie HTML rendu sous forme de chaîne, via le même pipeline que le frontend.

```php
use Blockstudio\Render;

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

Une seule forme de déclaration sous-jacente comporte quatre clés : `name`, `attributes`, `content` et `children`. `root`, `data`, `inner`, `innerBlocks`, `layers` et `example` sont des raccourcis d’entrée que `Render::normalize()` intègre à cette forme. Les enfants sont rendus récursivement et toute entrée mal formée déclenche une exception qui nomme le bloc concerné.

`Render::document()` enveloppe la sortie dans un document HTML autonome complet.

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

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

`body` correspond uniquement à la sortie du bloc, `html` au document assemblé, `blocks` aux noms des blocs qui ont contribué et `assets` répartit le balisage entre `head`, `footer`, `styles`, `scripts`, `modules`, `interactivity`, `ui` et `tailwind`. Les ressources sont limitées à celles utilisées pour le rendu ; les ressources réservées à l’éditeur n’apparaissent donc jamais.

`Render::document_from_html()` enveloppe le rendu de HTML effectué ailleurs, et `Render::content()` rend le contenu de bloc sérialisé sans document. Appelez `Blockstudio\Batch_Render::reset()` entre les documents d’un même processus PHP ; `Canvas::documents()` le fait déjà.

### Familles de composants UI

`Blockstudio\Ui` expose la bibliothèque UI intégrée avec une entrée par composant public, plutôt qu’une liste de composants internes.

`Ui::inventory()` renvoie une entrée par famille, avec son bloc racine, son titre et les blocs d’implémentation requis. `Ui::examples()` ajoute une déclaration déterministe pour chaque famille : valeurs par défaut conservées, couches enfants requises imbriquées sous leurs parents et texte d’illustration stable lorsqu’un champ serait vide. Cette déclaration est canonique et peut donc être directement intégrée à `Render::document()`.

Canvas procède de la même façon. Les UI intégrés apparaissent sous le type `ui`, avec un exemple par famille, et les enregistrements d’implémentation sont exclus de `blocks`.

Les familles sont conçues pour être assemblées : un sélecteur s’ouvre dans une boîte de dialogue dont la liste se superpose au déclencheur ; les menus et les sélecteurs avec saisie se positionnent à l’aide de coordonnées fixes dans la fenêtre, qui restent valides pendant le défilement ; les fenêtres modales s’empilent et se ferment une à une avec Échap ; et chaque pied de page compose le même contrôle de fermeture avec une variante. Le [chapitre sur la composition](https://blockstudio.dev/fr/ui/composition/) explique le fonctionnement de ces interfaces et les invariants qui les préservent ; [/ui/examples](https://blockstudio.dev/fr/ui/examples/) présente les compositions en action.

## Assistants de modèles

### Dimensions d’image stables

`bs_media_image()` rend les ressources du thème avec leur largeur et leur hauteur réelles, ainsi qu’un rapport hauteur/largeur réservé, pour que les images hors de la médiathèque ne décalent plus la mise en page.

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

La sortie est un `figure.blockstudio-media` avec un `aspect-ratio` en ligne autour d’un `img` contenant les valeurs réelles de `width`, `height`, `loading` et `decoding`. Les dimensions proviennent d’un `assets/media.json` généré, écrit par `Blockstudio\Media_Metadata_Builder` lors d’une étape de compilation ou manuellement.

`src` accepte un chemin relatif au thème, un chemin absolu ou un URL complet, et
`attachmentId` prend en charge les images de la médiathèque. `eager` désactive le chargement différé au-dessus de la ligne de flottaison, et `sources` génère un `<picture>`.

Lorsque `performance.media.lazy` est activé, le véritable URL est déplacé vers `data-src` derrière un espace réservé aux dimensions correctes.

### Assistants de classes Tailwind

`bs_tw_merge()` et `bs_tw_variants()` composent des classes Tailwind dans des modèles PHP, à l’aide du moteur déjà intégré par Blockstudio.

`bs_tw_merge('px-2 text-sm', 'px-4')` renvoie `text-sm px-4` : la classe `px-2` en conflit est supprimée et la valeur ultérieure l’emporte. Les tableaux imbriqués de valeurs de classe sont acceptés.

`bs_tw_variants()` renvoie une petite fonction appelable pour les variantes de composants :

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

Cela affiche `inline-flex items-center h-12 px-6 rounded`. Les classes de base, variantes, variantes par défaut, variantes composées et les options `class` ou `className` fournies à chaque appel sont toutes prises en charge.

## Configuration de production

### Profils de performance

`performance.profile` active en un seul endroit les paramètres frontend par défaut de la production.

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

`compat` est le profil par défaut et ne change rien. `speed` et `strict` activent le même ensemble : suppression de la tête des sorties du générateur, des émojis, du flux, de la découverte et des articles adjacents ; suppression de la découverte oEmbed et des scripts de l’hôte ; désactivation de XML-RPC, des rétroliens et de la découverte distante de l’éditeur ; suppression des ressources frontend génériques du cœur ; application des paramètres par défaut pour les images ; limitation de Heartbeat hors des éditeurs ; préchargement des documents de même origine au survol ou à la prise de focus ; et utilisation du chargeur d’images de Blockstudio.

Chaque valeur enfant remplace celle du profil, comme le fait `preload.links` ci-dessus. La suppression des ressources frontend du cœur est la première chose à tester, car une page qui en dépend présentera des problèmes visibles. `Runtime_Settings::current()` expose le profil résolu.

`themeDefaults` couvre deux tâches que les thèmes implémentent autrement eux-mêmes : `titleTag` et `suppressDirectoryUpdates` pour masquer le thème enfant actif et son thème parent des résultats de mise à jour.

### Accès typé aux réglages

`Blockstudio\Settings` lit la configuration avec des types réels au lieu de renvoyer ce que contenait 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);
}
```

Les JSON mal formés sont signalés via `Settings::errors()` au lieu de prendre les valeurs par défaut. `Settings::get_raw()` ne renvoie que ce que la source active a déclaré, ce qui distingue une valeur définie sur `false` d’une valeur jamais définie.

`Settings::fingerprint()` renvoie une identité stable pour les réglages effectifs, et l’accès recharge les données lorsque `blockstudio.json` change.

### Répertoire de cache unique

Chaque fichier généré se trouve désormais sous `cache.path`, qui correspond par défaut à `wp-content/blockstudio/cache`.

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

Les charges utiles de compilation, les données d’enregistrement des blocs, les ressources de l’éditeur, les Tailwind CSS compilés, les documents de rendu, les fragments d’îlots, les HTML statiques, les index de graphe, les files d’attente de préchauffage et les diagnostics se trouvent tous sous cette racine. Un chemin relatif est résolu depuis `WP_CONTENT_DIR` ; un chemin absolu le place sur un volume dédié.

Les objets sont classés sous le réseau et le site actifs, puis sous une identité d’exécution : une empreinte des versions de Blockstudio, WordPress et PHP, des réglages effectifs, du thème et des extensions actifs, des sources de découverte et des fichiers source concernés. Lorsqu’une entrée change, les objets concernés sont remplacés ; les anciens sont purgés.

Les compilations à froid sont exécutées une seule fois à la fois : une requête compile et publie le résultat atomiquement pendant que les autres attendent. En cas d’échec de l’actualisation, le dernier objet valide continue d’être servi et l’échec reste visible. `Blockstudio\Runtime_Cache::purge('tailwind')` efface une portée.

## Pré-rendu statique

Le pré-rendu statique met en cache les documents HTML anonymes complets et peut les servir avant le démarrage de WordPress. Cette fonctionnalité est désactivée par défaut.

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

### Conditions d’éligibilité

Seuls les documents HTML anonymes complets sont admissibles. Les requêtes autres que GET, les chaînes de requête, l’administration, REST, Ajax, cron, les flux, la recherche, les aperçus, les requêtes comportant un nonce, les cookies de personnalisation et tout chemin sous `dynamicPaths` sont ignorés. Une réponse peut se désinscrire entièrement à l’aide d’un marqueur `<!-- blockstudio:no-cache -->`.

La correspondance des chemins respecte les limites des segments : `/account` couvre `/account/orders`, mais pas `/accounting`.

### Modes de signature et de graphe

`invalidate` détermine l’expiration des entrées. Le mode par défaut `signature` remplit une réponse indexée par identité lors d’un accès anonyme sans correspondance et la renouvelle après les changements à l’échelle du site ; il convient aux sites ordinaires.

Le mode `graph` est destiné aux outils explicites de compilation et de déploiement. Il enregistre les dépendances propres aux sources de chaque page, afin qu’un plan ne reconstruise que les URL concernées.

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

### Service anticipé

Lorsque `earlyServe` est activé, Blockstudio gère une petite carte des routes par site et un drop-in `advanced-cache.php` qui diffuse une réponse admissible du cache avant le démarrage de WordPress, des extensions ou du thème.

Il ne remplace jamais une carte, un drop-in ou une déclaration `WP_CACHE` provenant d’un tiers. Un artefact de graphe valide chaque fichier HTML référencé avant de remplacer la carte ; ainsi, un déploiement rendu partiellement laisse le graphe précédent actif. Les entrées multisites restent isolées par hôte, chemin d’accueil et ID de site.

### Préchauffage et état

Trois commandes WP-CLI couvrent les usages quotidiens :

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

`status` indique l’identité active, le nombre de fichiers et d’octets, les enregistrements du graphe, l’état de la file et, pour chaque portée, les compteurs d’accès au cache, d’absence, de compilation et d’échec.

## Outils d’analyse et d’agent

### Préréglages d’analyse

`blockstudio/phpstan` ajoute trois couches à son analyse des blocs, ainsi qu’une commande qui exécute la couche choisie par un projet.

| Préréglage | Ajouts |
| --- | --- |
| `base` | Analyses existantes du schéma, des modèles, des hooks, des réglages et de API. |
| `theme` | Racines du thème, en-têtes de style, ressources, portée des sélecteurs, valeurs par défaut des champs et limites des répétiteurs. |
| `extreme-theme` | Contrôles de PHPStan `max`, de PHP non sécurisés, de l’échappement, de Tailwind, de JavaScript et de l’interactivité. |
| `wordpress-render` | Une sonde de rendu dynamique fournie par l’appelant, ajoutée à `extreme-theme`. |

Les valeurs par défaut proviennent de `blockstudio.json` ; les exécutions interactives, l’intégration continue et les hooks de commit partagent ainsi une même configuration :

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

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

Les codes de sortie sont `0` en cas de réussite, `1` en présence de diagnostics et `2` en cas d’utilisation non valide. L’enveloppe compose sa configuration dans le répertoire temporaire du système : aucun fichier de configuration, de référence ou de cache généré n’est placé dans le projet. Elle augmente également la limite de mémoire de PHPStan à `1G`.

Il intègre aussi un fournisseur BC Math ; les contrôles JavaScript n’ont donc plus besoin de `ext-bcmath`.

### Hook de commit géré

Un réglage et une commande suffisent pour faire du préréglage configuré un contrôle bloquant des commits.

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

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

La synchronisation écrit le hook et un enregistrement de propriété dans le répertoire commun de Git, pointe `core.hooksPath` vers le répertoire géré et enchaîne avec le hook pre-commit configuré auparavant. Au moment du commit, le hook résout le dépôt et la racine du projet ; les espaces de travail liés et les chemins contenant des espaces sont donc pris en charge.

Le hook exécute `vendor/bin/blockstudio-phpstan` et rien d’autre ; il ne formate ni ne réécrit jamais les fichiers. En définissant `commit` sur `false` puis en relançant la synchronisation, ou en exécutant `blockstudio-githooks remove`, le chemin de hook enregistré est restauré et seuls les fichiers gérés par Blockstudio sont supprimés.

### Contrat de projet

`blockstudio-agents` écrit un `AGENTS.md` qui indique où se trouvent les blocs, ce qu’est une page dans ce projet, quelles fonctionnalités sont activées et ce que l’analyseur rejettera.

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

Le document est dérivé des données, et non basé sur un modèle. Un thème avec un en-tête `style.css`, des blocs et des pages stockées dans des fichiers obtient un contrat différent de celui d’une extension qui enregistre uniquement des blocs ; le contrat reprend les nombres, répertoires, espaces de noms et langages de modèles détectés par l’analyseur. `blockstudio.json` détermine les fonctionnalités affichées : un projet sans pré-rendu statique n’en fait donc jamais mention.

La section sur la conformité est lue couche par couche dans les fichiers de règles propres au préréglage sélectionné. Ainsi, lorsqu’un préréglage gagne une règle, tous les contrats générés en tiennent compte.

La gestion de propriété fonctionne comme pour le hook de commit. Un fichier dépourvu du marqueur de génération n’est pas remplacé, sauf indication contraire de `--force` ; une section de notes à la fin est conservée lors de la régénération ; `--check` renvoie le code de sortie `1` lorsque le contrat n’est plus à jour ; et `--stdout` l’affiche sans toucher au système de fichiers.

### Index de documentation

`blockstudio-llm.txt` est désormais un index et non une concaténation. Chaque document publié apparaît une fois, dans sa section et sa sous-section, avec sa route, son fichier source, une brève description et les identifiants dont il est propriétaire : chemins de réglages, noms de hooks, fonctions et classes PHP, et commandes.

```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 lit l’index, trouve le document qui contient l’identifiant recherché et ouvre ce document. La concaténation précédente d’un demi-mégaoctet est toujours générée et publiée à `/blockstudio-llm-full.txt` ; ce n’est simplement plus le premier élément remis à qui que ce soit.

## Balises de bloc canoniques

Une commande autonome réécrit les raccourcis de préfixe et d’alias sous leur forme canonique `<bs:namespace-slug>`, qui indique le véritable nom du bloc et se résout sans filtre de projet chargé.

Avec un préfixe `brand` sur `theme-components` et un préfixe `ui` sur `bsui`,
ce raccourci :

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

équivaut à :

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

Les préfixes et les alias exacts fonctionnent toujours et ne sont pas dépréciés. La commande ne charge pas WordPress et n’écrit rien sans `--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` associe chaque préfixe à ses espaces de noms et `--known-blocks` répertorie les noms de blocs enregistrés. Le rapport consigne les correspondances entre les anciennes formes et les formes canoniques, avec le nombre d’occurrences, les empreintes par fichier et des listes distinctes pour les balises inconnues, les alias ambigus et les balises dynamiques. `--apply` refuse toute écriture tant qu’il en reste, sauf si `--allow-unresolved` est transmis.

Les balises appariées, imbriquées et autofermantes sont prises en charge, y compris les balises littérales dans les chaînes PHP. Seuls les noms de balises changent ; une deuxième exécution n’apporte aucune modification. Les exemples dans les commentaires, les blocs de code, `<pre>` ou `<code>` sont uniquement signalés dans le rapport.

## Comportement par défaut

L’installation de 7.6 ne change rien à elle seule.

**Le profil de performances est défini par défaut sur `compat`.** La sortie de l’en-tête, oEmbed, XML-RPC,
Heartbeat, les valeurs par défaut des images, le préchargement des liens, le chargement différé et le `<title>` de l’interface publique restent tels que WordPress et le thème les ont définis.

**Ces options restent désactivées sauf activation :** chaque clé `performance.staticPrerender`,
`performance.measurement`, `performance.media` et `themeDefaults`, ainsi que
`githooks.commit`, `dev.canvas.enabled`, `ui.enabled`, `tailwind.enabled` et
`blockTags.enabled`. Tant que le prérendu statique est désactivé, aucun fichier n’est écrit et aucun module complémentaire n’est installé.

**Canvas et Render sont passifs.** Ils lisent les registres existants et n’effectuent le rendu que sur demande de l’appelant ; aucun des deux ne s’accroche à la sortie de l’interface publique ni n’enregistre de routes. L’écran d’administration de Canvas nécessite toujours `dev.canvas.enabled` et `edit_posts`.

**Une analyse plus stricte doit être explicitement nommée.** L’installation de `blockstudio/phpstan` n’active que l’extension de base, et la commande canonique exécute `base`, sauf si le projet nomme un préréglage.

**Les fichiers générés nécessitent l’exécution de leur commande.** `githooks.commit` ne fait rien tant que `blockstudio-githooks sync` n’est pas exécuté, et `AGENTS.md` ne fait rien tant que `blockstudio-agents` ne l’est pas.

## Mise à niveau depuis 7.5

Les exigences restent inchangées : PHP 8.2 ou version ultérieure, WordPress 6.7 ou version ultérieure.

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

**Les caches sont reconstruits une fois.** L’identité d’exécution inclut la version de Blockstudio ; la première requête après la mise à niveau part donc d’un cache froid et les anciens objets sont purgés. L’ancien cache Tailwind sous `wp-content/uploads/blockstudio/tailwind/cache` peut être supprimé ; un extrait de code qui utilisait une recherche par motif doit appeler `Blockstudio\Runtime_Cache::purge('tailwind')` à la place.

L’ancien répertoire `wp-content/blockstudio/cache/runtime` plat des versions antérieures à 7.6 est automatiquement déplacé hors du chemin actif, puis supprimé lors de passages limités de WP-Cron. Il n’est donc pas nécessaire de supprimer les grandes arborescences d’anciens fichiers de verrouillage pendant une requête de déploiement.

**Les fichiers générés ont un propriétaire.** `assets/media.json` doit être placé sous contrôle de version ou généré lors d’une étape de compilation. La table de routes, le module complémentaire `advanced-cache.php` et la déclaration `WP_CACHE` n’existent que lorsque `earlyServe` est activé ; le hook de prévalidation n’existe que lorsque la synchronisation est activée. Tous les autres fichiers générés se trouvent sous `cache.path` et peuvent être supprimés sans risque.

**Rien n’a été supprimé ni renommé.** `bs_render_block()`, `bs_block()`,
`Blockstudio\Pages` et `Blockstudio\Patterns` restent les surfaces de contenu canoniques stockées dans des fichiers.

**Le retour arrière s’effectue fonctionnalité par fonctionnalité.** `performance.profile` vers `compat`,
`staticPrerender.enabled` vers `false`, `githooks.commit` vers `false` avec un
`sync`, et `cache.enabled` vers `false` annulent chacun une couche.

Un ordre d’adoption raisonnable :

1. Définissez `performance.profile` sur `speed`, puis vérifiez la sortie de l’en-tête, les flux et tout
   plugin dépendant d’oEmbed ou de XML-RPC.
2. Générez `assets/media.json`, déplacez les modèles vers `bs_media_image()`, puis activez
   `performance.media.lazy`.
3. Activez `performance.staticPrerender` en laissant `earlyServe` désactivé, vérifiez les correspondances avec
   `wp bs prerender status`, puis activez `earlyServe`.
4. Exécutez `blockstudio-phpstan --preset theme` jusqu’à ce que tout soit propre, avant de placer un préréglage
   derrière `githooks.commit`.

## Où trouver les détails

- [Canvas](https://blockstudio.dev/fr/docs/dev/canvas/) et son
  [inventaire et document API](https://blockstudio.dev/fr/docs/dev/canvas/#public-inventory-and-document-api)
- [Rendu](https://blockstudio.dev/fr/docs/blocks/rendering/#structured-compositions-and-complete-documents),
  [Composants UI](https://blockstudio.dev/fr/ui/#public-inventory-and-examples) et
  [Composition UI](https://blockstudio.dev/fr/ui/composition/)
- [Paramètres](https://blockstudio.dev/fr/docs/general/settings/) et
  [performances](https://blockstudio.dev/fr/docs/general/settings/#performance)
- [Performances](https://blockstudio.dev/fr/docs/production/performance/),
  [Mise en cache](https://blockstudio.dev/fr/docs/production/caching/) et
  [Prérendu statique](https://blockstudio.dev/fr/docs/production/static-prerendering/)
- [Tailwind CSS](https://blockstudio.dev/fr/docs/tailwind/#template-composition-helpers)
- [PHPStan](https://blockstudio.dev/fr/docs/dev/phpstan/) : [préréglages](https://blockstudio.dev/fr/docs/dev/phpstan/#analysis-presets),
  [commande canonique](https://blockstudio.dev/fr/docs/dev/phpstan/#canonical-command),
  [hook de validation géré](https://blockstudio.dev/fr/docs/dev/phpstan/#managed-commit-hook) et le
  [contrat du projet](https://blockstudio.dev/fr/docs/dev/phpstan/#project-contract-for-coding-agents)
- [Intégration de l’IA](https://blockstudio.dev/fr/docs/dev/ai/) : l’index de documentation et le texte intégral
- [Migration](https://blockstudio.dev/fr/docs/dev/migration/v7/#canonical-block-tags) et
  [HooksPHP](https://blockstudio.dev/fr/docs/blocks/hooks/php/)
