Hoppa till innehåll

Dennis · 27 juli 2026

Blockstudio 7.6

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

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

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

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

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

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

Kortversionen:

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

Läsa och återge ett projekt

Projektinventering

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

PHP
use Blockstudio\Canvas;

$result = Canvas::inventory();

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

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

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

Riktat urval

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

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

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

Reglerna är exakta:

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

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

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

Fristående rendering

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

PHP
use Blockstudio\Render;

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

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

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

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

echo $document['html'];

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

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

UI-komponentfamiljer

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

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

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

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

Mallhjälpare

Stabila bildmått

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

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

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

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

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

Tailwind-klasshjälpare

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

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

bs_tw_variants() returnerar en liten anropsbar funktion för komponentvarianter:

PHP
$button = bs_tw_variants([
    'base' => 'inline-flex items-center',
    'variants' => [
        'size' => ['sm' => 'h-8 px-3', 'lg' => 'h-12 px-6'],
    ],
    'defaultVariants' => ['size' => 'sm'],
]);

echo $button(['size' => 'lg', 'class' => 'rounded']);

Det skriver ut inline-flex items-center h-12 px-6 rounded. Basklasser, varianter, standardvarianter, sammansatta varianter och ett class eller className per anrop stöds alla.

Produktionskonfiguration

Prestandaprofiler

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

JSON
{
  "performance": {
    "profile": "speed",
    "preload": {
      "links": "off"
    }
  }
}

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

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

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

Typad inställningsåtkomst

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

PHP
use Blockstudio\Settings;

$lazy = Settings::get_bool('performance/media/lazy');
$margin = Settings::get_string('performance/media/rootMargin', '300px');
$ttl = Settings::get_int('performance/staticPrerender/ttl', 86400);
$roles = Settings::get_array('users/roles');

foreach (Settings::errors() as $error) {
    error_log($error);
}

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

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

En cachekatalog

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

JSON
{
  "cache": {
    "enabled": true,
    "path": "cache/blockstudio"
  }
}

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

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

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

Statisk för-rendering

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

JSON
{
  "performance": {
    "staticPrerender": {
      "enabled": true,
      "ttl": 3600,
      "earlyServe": true,
      "dynamicPaths": ["/account", "/checkout"]
    }
  }
}

Behörighet

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

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

Signatur- och graflägen

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

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

PHP
use Blockstudio\Static_Prerender_Runtime;

$plan = Static_Prerender_Runtime::build_plan($sourceUrls);

foreach ($plan['affectedUrls'] as $url) {
    $result = render_with_dependencies($url);

    Static_Prerender_Runtime::persist_built_response(
        $url,
        $result['html'],
        $result['files'],
        $result['virtualHashes']
    );
}

Static_Prerender_Runtime::garbage_collect(array_keys($plan['live']));

Tidig leverans

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

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

Uppvärmning och status

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

Shell
wp bs prerender warm
wp bs prerender status
wp bs prerender purge

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

Analys och agentverktyg

Analysförinställningar

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

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

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

JSON
{
  "phpstan": {
    "preset": "theme",
    "roots": ["."],
    "excludePaths": ["fixtures/**"],
    "maxFiles": 10000
  }
}
Shell
vendor/bin/blockstudio-phpstan --root . -- --no-progress

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

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

Hanterad commit-hook

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

JSON
{
  "githooks": {
    "commit": true
  }
}
Shell
vendor/bin/blockstudio-githooks sync

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

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

Projektkontrakt

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

Shell
vendor/bin/blockstudio-agents

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

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

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

Dokumentationsindex

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

Text
## Docs / Dev / Inspection Tools

### Canvas
route: /docs/dev/canvas
file: docs/docs/dev/canvas.md
purpose: A visual workspace and public inventory API for Blockstudio content.
settings: dev/canvas/enabled, ui
hooks: blockstudio/settings/dev/canvas/admin_bar, blockstudio/settings/dev/canvas/enabled
php: Blockstudio\Canvas, Canvas::documents(), Canvas::inventory()

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

Kanoniska blocktaggar

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

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

HTML
<brand-card>
  <ui-input />
</brand-card>

betyder samma sak som:

HTML
<bs:theme-components-card>
  <bs:bsui-input />
</bs:theme-components-card>

Prefix och exakta alias fungerar fortfarande och är inte föråldrade. Kommandot läser inte in WordPress och skriver ingenting utan --apply:

Shell
php vendor/blockstudio/blockstudio/bin/migrate-block-tags.php \
  --root="$PWD" \
  --prefix-map=/tmp/prefixes.json \
  --known-blocks=/tmp/blocks.json \
  --report=/tmp/tag-migration.json \
  --dry-run

--prefix-map mappar varje prefix till sina namnrymder och --known-blocks listar registrerade blocknamn. Rapporten dokumenterar mappningar från äldre till kanoniska namn med förekomstantal, hashvärden per fil och separata listor över okända taggar, tvetydiga alias och dynamiska taggar. --apply vägrar att skriva medan något av detta återstår, såvida inte --allow-unresolved skickas med.

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

Standardbeteende

Att installera 7.6 ändrar ingenting i sig.

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

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

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

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

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

Uppgradering från 7.5

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

Shell
composer require blockstudio/blockstudio

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

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

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

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

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

En rimlig ordning för införandet:

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

Var detaljerna finns