
Blockstudio A versão 7.6 permite consultar e renderizar um projeto a partir de PHP e transfere os padrões do frontend de produção para `blockstudio.json`: um inventário API, renderização independente, helpers de template para mídia e Tailwind, perfis de desempenho, um diretório de cache, pré-renderização estática com disponibilização antecipada, configurações predefinidas de análise mais rigorosas e ferramentas de projeto geradas para agentes de programação.

Duas chamadas abrangem a maior parte da versão. `Canvas::inventory()` retorna todas as páginas, blocos, padrões, templates do Editor do site, partes de template e exemplos de UI incluídos que um projeto registra. `Render::document()` retorna HTML finalizado para qualquer um deles, com exatamente os assets usados na renderização.

> **Atualização de 7.6.2:** páginas baseadas em arquivos não são mais reconciliadas durante solicitações comuns de WordPress. Execute `wp bs pages sync` ou chame `Blockstudio\Pages::reconcile()` ao aplicar alterações na origem. O roteamento de coleções e os padrões de `templateFor` usam configuração persistida do runtime, e a reconciliação explícita evita a consulta OR-meta multilíngue extensa anterior. A opção `themeDefaults.syncPagesInDevelopment`, de curta duração, foi removida porque a sincronização de páginas não é mais executada por hooks de solicitação. `Pages::init()` agora serve apenas para inicialização; integrações que passavam `force` devem usar `Pages::reconcile()` ou o CLI. Abrir o Canvas ainda executa uma reconciliação explícita e autenticada para obter o inventário de conteúdo do autor.

> **7.6.12 atualização:** as folhas de estilo do editor agora recebem prefixos em uma única
> etapa de reescrita, em vez de uma compilação SASS por recurso, evitando que uma
> compilação fria do editor em um site com muitos blocos exceda um limite de memória
> modesto. Uma página pré-renderizada em cache cuja folha de estilo Tailwind com hash
> de conteúdo foi removida do cache é renderizada novamente, em vez de ser servida sem
> estilos, tanto pelo cache PHP quanto pelo drop-in Early Serve. Atributos de blocos
> gravados no nível superior são lidos durante a renderização, em vez de descartados,
> portanto, o esquema Blockstudio registrado em `WP_Block_Type` é respeitado por gravadores programáticos.

> **7.6.11 atualização:** a instalação de artefatos do Graph agora substitui atomicamente
> o documento de uma rota quando a cópia no armazenamento muda sob a mesma chave,
> mantém intactos os documentos idênticos e informa as rotas promovidas, substituídas,
> ignoradas e mantidas por meio de `Static_Prerender_Early_Serve::last_promotion()`.

> **7.6.10 atualização:** acertos no cache de tempo de execução agora detectam recursos compilados
> removidos, inclusive durante o debounce de observação, e caches planos de tempo de execução
> anteriores à versão 7.6 são colocados em quarentena e excluídos atomicamente em lotes
> limitados de cron. Os globais de UI incluídos no pacote são emitidos uma vez
> por página. O Early Serve no modo Graph pode servir rotas renderizadas ao vivo que
> estejam fora do mapa de rotas implantado, usando o cache de identidade. Tailwind pode
> emitir opcionalmente seu arquivo de cache com hash de conteúdo usando `tailwind.output: "link"`; a saída
> inline continua sendo o padrão.

Em resumo:

- **Inventário do projeto**: `Canvas::inventory()` retorna todos os registros cadastrados,
  com suas fontes e uma ordem de exibição estável.
- **Seleção direcionada**: nomear blocos e páginas restringe a descoberta, a sincronização,
  a renderização e a compilação a esses registros.
- **Renderização independente**: `Blockstudio\Render` retorna HTML finalizado para um
  bloco, uma composição ou um documento completo.
- **Famílias de componentes UI**: `Blockstudio\Ui` agrupa a biblioteca incluída no pacote em
  uma família pública por componente, cada uma com um exemplo.
- **Dimensões de imagem estáveis**: `bs_media_image()` renderiza recursos do tema com dimensões reais
  de um `assets/media.json` gerado.
- **Auxiliares de classe Tailwind**: `bs_tw_merge()` e `bs_tw_variants()` compõem
  classes em PHP com mesclagem que considera conflitos.
- **Perfis de desempenho**: `performance.profile` ativa de uma só vez os padrões de produção do frontend;
  os valores filhos têm precedência.
- **Acesso tipado às configurações**: `Settings::get_bool()` e seus equivalentes leem
  `blockstudio.json` com tipos reais e expõem erros de análise.
- **Um diretório de cache**: cada arquivo gerado fica em `cache.path`, indexado
  por uma identidade de tempo de execução.
- **Pré-renderização estática**: HTML anônimas podem ser armazenadas em cache,
  invalidadas por um grafo de dependências e servidas antes da inicialização de WordPress.
- **Predefinições de análise**: `theme`, `extreme-theme` e `wordpress-render` ampliam
  `blockstudio/phpstan` para além dos modelos de blocos.
- **Gancho de commit gerenciado**: `blockstudio-githooks sync` grava e gerencia um gancho
  pre-commit que executa a predefinição configurada.
- **Contrato do projeto**: `blockstudio-agents` grava um `AGENTS.md` que descreve
  o que o projeto cria, quais recursos ativa e o que sua predefinição exige.
- **Índice da documentação**: o arquivo de contexto da IA agora é um índice de cada
  documento, sua finalidade e os identificadores que ele possui.
- **Tags canônicas de bloco**: um comando independente reescreve abreviações de prefixo e
  alias como `<bs:namespace-slug>`, com uma simulação.
- **Compatibilidade por padrão**: nada do que foi descrito acima altera um site até ser
  especificado em `blockstudio.json`.

## Leitura e renderização de um projeto

### Inventário do projeto

`Canvas::inventory()` retorna tudo o que um projeto registra em um único array simples,
sem renderizar nada.

```php
use Blockstudio\Canvas;

$result = Canvas::inventory();

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

Os registros são agrupados por tipo: `pages`, `blocks`, `patterns`, `templates`,
`parts` e `ui`. `order` define a ordem de exibição estável entre todos os tipos,
`sources` associa cada registro aos caminhos de origem, e `warnings` e `errors`
reúnem problemas em entradas estruturadas.

Os registros de bloco contêm `id`, `name`, `title`, `source`, `path`, `provenance` e um
`declaration` pronto para renderização. Os registros de página mantêm `source` como identidade
estável e `path` como o modelo que faz a renderização.

### Seleção direcionada

Nomear registros restringe o trabalho, em vez de filtrá-lo posteriormente.

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

Isso retorna um bloco e uma página. `patterns`, `templates`, `parts` e `ui`
retornam vazios, e suas fontes nunca são lidas, sincronizadas, renderizadas ou
compiladas.

As regras são exatas:

- Sem nenhuma chave de tipo, todos os tipos são carregados.
- `true`, `null` ou `"*"` carrega todos os registros daquele tipo.
- Uma string ou lista corresponde exatamente ao ID, nome, slug, caminho ou caminho de origem.
- Uma string vazia, uma lista vazia ou `false` não carrega nenhum registro daquele tipo.
- Depois que qualquer chave de tipo é fornecida, os tipos omitidos permanecem intactos.

Identificadores que já não existem são retornados em `deleted`, em vez de causar uma falha,
e o endpoint de atualização REST do Canvas aplica a mesma regra aos parâmetros
`blocks` e `pages`.

`Canvas::documents()` usa a mesma seleção e adiciona um documento renderizado
por registro. As páginas selecionadas são renderizadas em um contexto de frontend restaurado,
para que condicionais de consulta, classes do body, shortcodes, layouts, redirecionamentos e
callbacks de enqueue vejam essa página, e não a solicitação que a pediu.

### Renderização independente

`Blockstudio\Render` retorna HTML renderizado como uma string, pelo mesmo
pipeline usado pelo frontend.

```php
use Blockstudio\Render;

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

Há uma única estrutura de declaração subjacente, com quatro chaves: `name`, `attributes`,
`content` e `children`. `root`, `data`, `inner`, `innerBlocks`, `layers` e
`example` são conveniências de entrada que `Render::normalize()` incorpora a ela.
Os elementos filhos são renderizados recursivamente, e entradas malformadas lançam uma exceção
que identifica o bloco problemático.

`Render::document()` envolve a saída em um documento HTML independente completo.

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

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

`body` é apenas a saída do bloco, `html` é o documento montado, `blocks` são os
nomes dos blocos que contribuíram, e `assets` divide a marcação em `head`,
`footer`, `styles`, `scripts`, `modules`, `interactivity`, `ui` e `tailwind`.
Os recursos são limitados ao que foi renderizado, então recursos exclusivos do editor nunca aparecem.

`Render::document_from_html()` envolve HTML renderizado em outro lugar, e
`Render::content()` renderiza conteúdo de bloco serializado sem um documento. Chame
`Blockstudio\Batch_Render::reset()` entre documentos em um processo PHP;
`Canvas::documents()` já faz isso.

### Famílias de componentes UI

`Blockstudio\Ui` expõe a biblioteca UI incluída no pacote como uma entrada por componente
público, em vez de uma lista de partes internas.

`Ui::inventory()` retorna uma entrada por família com seu bloco raiz, título e
os blocos de implementação necessários. `Ui::examples()` adiciona uma declaração determinística
por família: preserva os padrões, aninha as camadas filhas obrigatórias sob os respectivos pais
e inclui texto ilustrativo estável quando um campo ficaria vazio. Essa declaração é canônica,
portanto, vai diretamente para `Render::document()`.

O Canvas agrupa da mesma forma. UI incluído no pacote aparece sob o tipo `ui` como um
exemplo por família, e os registros de implementação não aparecem em `blocks`.

As famílias foram criadas para serem combinadas: um seletor abre dentro de um diálogo, com sua
lista sobreposta ao acionador; menus e caixas de combinação se ancoram em coordenadas fixas da
janela de visualização que permanecem corretas durante a rolagem; modais se empilham e são
fechados um por vez com Escape; e cada rodapé combina o mesmo controle de fechamento com uma
variante. A explicação de como essas conexões funcionam e dos invariantes que as mantêm está no
[capítulo sobre composição](https://blockstudio.dev/pt/ui/composition/); [/ui/examples](https://blockstudio.dev/pt/ui/examples/) mostra as
composições em funcionamento.

## Auxiliares de modelo

### Dimensões de imagem estáveis

`bs_media_image()` renderiza recursos do tema com largura, altura e proporção reservada reais,
para que imagens fora da biblioteca de mídia parem de deslocar o layout.

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

A saída é um `figure.blockstudio-media` com um `aspect-ratio` inline em torno
 de um `img` que contém `width`, `height`, `loading` e `decoding` reais. As dimensões
vêm de um `assets/media.json` gerado, gravado por
`Blockstudio\Media_Metadata_Builder` em uma etapa da compilação ou manualmente.

`src` aceita um caminho relativo ao tema, um caminho absoluto ou um URL completo, e
`attachmentId` cobre imagens da biblioteca de mídia. `eager` desativa o carregamento lento
acima da dobra, e `sources` emite um `<picture>`.

Com `performance.media.lazy` ativado, o URL real passa para `data-src` atrás de um
espaço reservado dimensionado corretamente.

### Auxiliares de classe Tailwind

`bs_tw_merge()` e `bs_tw_variants()` compõem classes Tailwind em modelos PHP,
usando o mecanismo que Blockstudio já inclui no pacote.

`bs_tw_merge('px-2 text-sm', 'px-4')` retorna `text-sm px-4`: a classe `px-2` conflitante
é removida, e o valor posterior prevalece. Matrizes aninhadas de valores de classe são aceitas.

`bs_tw_variants()` retorna uma pequena função invocável para variantes de componentes:

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

Isso exibe `inline-flex items-center h-12 px-6 rounded`. São aceitas classes base,
variantes, variantes padrão, variantes compostas e `class` ou `className` por chamada.

## Configuração de produção

### Perfis de desempenho

`performance.profile` ativa em um só lugar os padrões de produção do frontend.

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

`compat` é o padrão e não altera nada. `speed` e `strict` ativam o
mesmo conjunto: removem do head a saída de gerador, emoji, feed, descoberta e posts adjacentes;
descartam a descoberta oEmbed e scripts do host; desativam XML-RPC, pingbacks
e a descoberta remota do editor; removem recursos genéricos do frontend do core;
aplicam padrões à saída de imagens; limitam o Heartbeat fora dos editores; pré-carregam
por hover ou intenção de foco documentos da mesma origem; e usam o carregador de imagens de
Blockstudio.

Cada valor filho substitui o perfil, como faz `preload.links` acima. A remoção
 de recursos do frontend do core é o primeiro ponto a testar, pois uma página que dependa deles
apresentará problemas visíveis. `Runtime_Settings::current()` expõe o perfil resolvido.

`themeDefaults` cobre dois aspectos que os temas normalmente implementam por conta própria: `titleTag` e
`suppressDirectoryUpdates` para ocultar o tema filho ativo e o tema pai dos resultados de atualização.

### Acesso tipado às configurações

`Blockstudio\Settings` lê a configuração com tipos reais, em vez de retornar
qualquer valor que JSON contivesse.

```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 malformado é informado por meio de `Settings::errors()`, em vez de ser resolvido
com valores padrão. `Settings::get_raw()` retorna somente o que a fonte ativa declarou,
o que diferencia um valor definido como `false` de um valor nunca definido.

`Settings::fingerprint()` retorna uma identidade estável para as configurações efetivas,
e o acesso recarrega quando `blockstudio.json` muda.

### Um diretório de cache

Agora, todos os arquivos gerados ficam em `cache.path`, cujo padrão é
`wp-content/blockstudio/cache`.

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

Pacotes de compilação, dados de registro de blocos, recursos do editor, Tailwind CSS compilado,
documentos renderizados, fragmentos de ilhas, HTML estático, índices de grafos, filas de
pré-aquecimento e diagnósticos ficam todos sob essa raiz. Um caminho relativo é resolvido a
partir de `WP_CONTENT_DIR`; um caminho absoluto o direciona para um volume dedicado.

Os objetos são organizados pela rede e pelo site atuais e, em seguida, por uma identidade de
tempo de execução: uma impressão digital das versões de Blockstudio, WordPress e PHP,
das configurações efetivas, do tema e dos plugins ativos, das fontes de descoberta e dos arquivos
de origem envolvidos. Quando uma entrada muda, os objetos afetados são substituídos por novos;
os antigos são removidos.

Compilações a frio são executadas uma única vez: uma solicitação compila e publica o resultado
atomicamente enquanto as outras aguardam. Se uma atualização falhar, o último objeto válido
continua sendo servido e a falha permanece visível, e
`Blockstudio\Runtime_Cache::purge('tailwind')` limpa um escopo.

## Pré-renderização estática

A pré-renderização estática armazena em cache documentos completos e anônimos de HTML e pode
servi-los antes da inicialização de WordPress. Por padrão, ela fica desativada.

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

### Elegibilidade

Somente documentos completos e anônimos de HTML são elegíveis. Solicitações que não sejam GET,
strings de consulta, área administrativa, REST, Ajax, cron, feeds, pesquisa, pré-visualizações,
solicitações com nonce, cookies personalizados e qualquer caminho sob `dynamicPaths` são ignorados.
Uma resposta pode optar por não participar usando o marcador `<!-- blockstudio:no-cache -->`.

A correspondência de caminhos respeita os limites, então `/account` abrange `/account/orders`, mas
não `/accounting`.

### Modos de assinatura e grafo

`invalidate` determina como as entradas expiram. O modo padrão `signature` preenche uma
resposta identificada por chave de identidade quando há uma solicitação anônima sem correspondência
e a renova após mudanças no nível do site, o que atende bem a um site comum.

O modo `graph` é voltado a ferramentas explícitas de compilação e implantação. Ele registra as
dependências de origem de cada página, para que um plano reconstrua somente os URLs afetados.

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

### Serviço antecipado

Com `earlyServe` ativado, Blockstudio gerencia um pequeno mapa de rotas por site e um
arquivo drop-in `advanced-cache.php` que transmite uma resposta elegível do cache antes da inicialização de
WordPress, dos plugins ou do tema.

Ele nunca sobrescreve um mapa, arquivo drop-in ou declaração `WP_CACHE` de terceiros. Um artefato
de grafo valida cada arquivo HTML referenciado antes de substituir o mapa, portanto uma
implantação renderizada pela metade mantém o grafo anterior ativo. As entradas Multisite permanecem
isoladas por host, caminho inicial e ID do site.

### Pré-aquecimento e status

Três comandos WP-CLI cobrem o uso diário:

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

`status` informa a identidade ativa, as contagens de arquivos e bytes, os registros do grafo, o
estado da fila e os contadores de acertos, falhas de cache, compilações e erros por escopo.

## Análise e ferramentas para agentes

### Predefinições de análise

`blockstudio/phpstan` ganha três camadas além da análise de blocos, mais um
comando que executa a camada selecionada pelo projeto.

| Predefinição | O que ela adiciona |
| --- | --- |
| `base` | As análises existentes de esquema, modelo, gancho, configurações e API. |
| `theme` | Raízes do tema, cabeçalhos de estilo, recursos, escopo de seletores, padrões de campos e limites de repetidores. |
| `extreme-theme` | PHPStan `max`, PHP inseguro, escape, Tailwind, JavaScript e verificações de Interactivity. |
| `wordpress-render` | Uma verificação de renderização ao vivo fornecida pelo chamador, além de `extreme-theme`. |

Os padrões vêm de `blockstudio.json`, para que execuções interativas, CI e ganchos de commit
compartilhem uma única configuração:

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

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

Os códigos de saída são `0` em caso de sucesso, `1` para diagnósticos e `2` para uso
inválido. O wrapper compõe a configuração no diretório temporário do sistema, sem deixar
configurações geradas, linhas de base ou cache no projeto, e aumenta o limite de memória de
PHPStan para `1G`.

Ele também inclui um provedor de BC Math, então as verificações de JavaScript não precisam mais de
`ext-bcmath`.

### Gancho de commit gerenciado

Uma configuração e um comando transformam a predefinição configurada em uma barreira de commit.

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

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

A sincronização grava o gancho e um registro de propriedade no diretório comum de Git,
define `core.hooksPath` como diretório gerenciado e encadeia qualquer gancho pre-commit que tenha sido
configurado antes. O gancho resolve o repositório e a raiz do projeto no momento do commit, para
que checkouts vinculados e caminhos com espaços funcionem.

O gancho executa `vendor/bin/blockstudio-phpstan` e nada mais; nunca formata nem reescreve arquivos. Definir `commit` como
`false` e sincronizar novamente, ou executar `blockstudio-githooks remove`, restaura o caminho registrado do gancho e
exclui somente os arquivos pertencentes a Blockstudio.

### Contrato do projeto

`blockstudio-agents` grava um `AGENTS.md` que especifica onde ficam os blocos, o que é uma
página neste projeto, quais recursos estão ativados e o que o analisador rejeitará.

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

O documento é derivado, não baseado em um modelo. Um tema com um cabeçalho `style.css`,
blocos e páginas baseadas em arquivos recebe um contrato diferente do de um plugin que apenas
registra blocos, incluindo as contagens, os diretórios, os namespaces e as linguagens de modelo
identificados pelo scanner. `blockstudio.json` determina quais recursos aparecem,
portanto, um projeto sem pré-renderização estática nunca verá esse recurso ser mencionado.

A seção de correção é lida diretamente dos próprios arquivos de regras da predefinição
selecionada, camada por camada, portanto, quando uma regra é adicionada à predefinição, todos os
contratos gerados também são atualizados.

A propriedade funciona como no gancho de commit. Se um arquivo não tiver o marcador de
conteúdo gerado, ele não será substituído, a menos que `--force` indique o contrário; uma região de
anotações no fim permanece após a regeneração; `--check` retorna o código de saída `1` se o
contrato estiver desatualizado; e `--stdout` o exibe sem tocar no sistema de arquivos.

### Índice da documentação

`blockstudio-llm.txt` agora é um índice, em vez de uma concatenação. Cada documento
publicado aparece uma vez, em sua seção e subseção, com sua rota, seu arquivo de origem, uma
frase sobre sua finalidade e os identificadores que possui: caminhos de configuração, nomes de
ganchos, funções e classes PHP e comandos.

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

Um agente lê o índice, encontra o único documento que contém o identificador de que precisa e abre esse documento. A concatenação anterior, de meio megabyte, continua sendo gerada e publicada em `/blockstudio-llm-full.txt`; ela deixou de ser a primeira coisa entregue a alguém.

## Tags canônicas de bloco

Um comando independente reescreve abreviações de prefixo e alias na grafia canônica `<bs:namespace-slug>`, que registra o nome real do bloco e é resolvida sem carregar um filtro de projeto.

Com o prefixo `brand` sobre `theme-components` e o prefixo `ui` sobre `bsui`,
essa abreviação:

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

significa o mesmo que:

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

Os prefixos e aliases exatos continuam funcionando e não foram descontinuados. O comando não carrega WordPress e não grava nada sem `--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` associa cada prefixo aos seus namespaces e `--known-blocks` lista os nomes de bloco registrados. O relatório registra os mapeamentos de nomes legados para canônicos com contagens de ocorrências, hashes por arquivo e listas separadas para tags desconhecidas, aliases ambíguos e tags dinâmicas. `--apply` se recusa a gravar enquanto houver algum deles, a menos que `--allow-unresolved` seja passado.

O tratamento inclui marcação pareada, aninhada e autocontida, além de tags literais em strings PHP. Apenas os nomes das tags mudam; uma segunda execução não produz alterações, e exemplos em comentários, blocos de código, `<pre>` ou `<code>` aparecem apenas no relatório.

## Comportamento padrão

A instalação da versão 7.6 não altera nada por si só.

**O perfil de desempenho é definido por padrão como `compat`.** A saída do cabeçalho, oEmbed, XML-RPC,
Heartbeat, os padrões de imagem, a pré-busca de links, o carregamento lento e o `<title>` do frontend permanecem como WordPress e o tema os deixaram.

**Estes recursos permanecem desativados até serem habilitados:** cada chave `performance.staticPrerender`,
`performance.measurement`, `performance.media` e `themeDefaults`, além de `githooks.commit`, `dev.canvas.enabled`, `ui.enabled`, `tailwind.enabled` e `blockTags.enabled`. Enquanto a pré-renderização estática está desativada, nenhum arquivo é gravado nem nenhum drop-in é instalado.

**Canvas e Render são passivos.** Eles leem registros existentes e renderizam apenas o que um chamador solicita; nenhum deles se conecta à saída do frontend ou registra rotas. A tela de administração do Canvas ainda requer `dev.canvas.enabled` e `edit_posts`.

**Uma análise mais rigorosa exige que seja nomeada.** Instalar `blockstudio/phpstan` habilita apenas a extensão base, e o comando canônico executa `base`, a menos que um preset seja nomeado no projeto.

**Os arquivos gerados exigem a execução do comando correspondente.** `githooks.commit` não faz nada até que `blockstudio-githooks sync` seja executado, e `AGENTS.md` não faz nada até que `blockstudio-agents` seja executado.

## Atualização da versão 7.5

Os requisitos não mudaram: PHP 8.2 ou mais recente, WordPress 6.7 ou mais recente.

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

**Os caches são reconstruídos uma vez.** A identidade do runtime inclui a versão de Blockstudio, então a primeira solicitação após a atualização começa com o cache frio e os objetos antigos são removidos. O antigo cache Tailwind em `wp-content/uploads/blockstudio/tailwind/cache` pode ser excluído; um snippet que o consultava com glob deve chamar `Blockstudio\Runtime_Cache::purge('tailwind')`.

O diretório plano `wp-content/blockstudio/cache/runtime` anterior à versão 7.6 é renomeado automaticamente para fora do caminho ativo e removido por etapas limitadas de WP-Cron. Assim, árvores grandes de arquivos de lock legados não precisam ser excluídas durante uma solicitação de implantação.

**Os arquivos gerados têm responsáveis.** `assets/media.json` deve estar no controle de versão ou em uma etapa de build. O mapa de rotas, o drop-in `advanced-cache.php` e a declaração `WP_CACHE` só existem enquanto `earlyServe` estiver habilitado, e o hook de pre-commit só existe enquanto estiver sincronizado. Todo o restante do conteúdo gerado fica em `cache.path` e pode ser excluído com segurança.

**Nada foi removido ou renomeado.** `bs_render_block()`, `bs_block()`, `Blockstudio\Pages` e `Blockstudio\Patterns` continuam sendo as superfícies canônicas de conteúdo baseadas em arquivos.

**A reversão é feita por recurso.** Reverter `performance.profile` para `compat`, `staticPrerender.enabled` para `false`, `githooks.commit` para `false` junto com um `sync`, e `cache.enabled` para `false` desfaz uma camada em cada caso.

Uma ordem razoável para adoção:

1. Defina `performance.profile` como `speed` e depois verifique a saída do cabeçalho, os feeds e qualquer plugin que dependa de oEmbed ou XML-RPC.
2. Gere `assets/media.json`, mova os templates para `bs_media_image()` e então habilite `performance.media.lazy`.
3. Habilite `performance.staticPrerender` com `earlyServe` desativado, verifique as ocorrências com `wp bs prerender status` e então habilite `earlyServe`.
4. Execute `blockstudio-phpstan --preset theme` até que não haja problemas antes de colocar qualquer preset atrás de `githooks.commit`.

## Onde encontrar os detalhes

- [Canvas](https://blockstudio.dev/pt/docs/dev/canvas/) e seu [inventário e documentaçãoAPI](https://blockstudio.dev/pt/docs/dev/canvas/#public-inventory-and-document-api)
- [Renderização](https://blockstudio.dev/pt/docs/blocks/rendering/#structured-compositions-and-complete-documents), [UIComponentes](https://blockstudio.dev/pt/ui/#public-inventory-and-examples) e [UIComposição](https://blockstudio.dev/pt/ui/composition/)
- [Configurações](https://blockstudio.dev/pt/docs/general/settings/) e [desempenho](https://blockstudio.dev/pt/docs/general/settings/#performance)
- [Desempenho](https://blockstudio.dev/pt/docs/production/performance/), [Cache](https://blockstudio.dev/pt/docs/production/caching/) e [Pré-renderização estática](https://blockstudio.dev/pt/docs/production/static-prerendering/)
- [Tailwind CSS](https://blockstudio.dev/pt/docs/tailwind/#template-composition-helpers)
- [PHPStan](https://blockstudio.dev/pt/docs/dev/phpstan/): [presets](https://blockstudio.dev/pt/docs/dev/phpstan/#analysis-presets), [comando canônico](https://blockstudio.dev/pt/docs/dev/phpstan/#canonical-command), [hook de commit gerenciado](https://blockstudio.dev/pt/docs/dev/phpstan/#managed-commit-hook) e o [contrato do projeto](https://blockstudio.dev/pt/docs/dev/phpstan/#project-contract-for-coding-agents)
- [Integração com IA](https://blockstudio.dev/pt/docs/dev/ai/): o índice da documentação e o texto completo
- [Migração](https://blockstudio.dev/pt/docs/dev/migration/v7/#canonical-block-tags) e [PHPHooks](https://blockstudio.dev/pt/docs/blocks/hooks/php/)
