@elia97/officina 0.9.1 → 0.10.0

package/README.md

@@ -38,6 +38,8 @@ I gate leggono dalla cartella corrente, che deve essere la radice del repository
 
 `check language` vuole in italiano i commenti del codice e i Markdown di documentazione. Lascia fuori per intero ciò che non è documentazione del progetto: i dizionari di `src/i18n/strings/` e i Markdown sotto `src/content/`, che sono copy nelle lingue del sito; le fonti del cliente in `docs/sources/`; i `CHANGELOG.md`, generati in inglese. Un file YAML di `src/content/` invece è codice, e i suoi commenti si controllano come altrove.
 
+`check routes` segue i rimandi dei Markdown del progetto: i percorsi fra apici inversi dentro `docs`, `src`, `scripts`, `test`, `e2e`, `public`, `.claude` e `.github`; i rimandi a una sezione, nella forma `file.md` § Titolo; i link e le immagini con una destinazione relativa, anche a riferimento e verso una cartella; e due tipi di nomi senza cartella, i documenti in maiuscolo come `HOW_TO_USE.md`, cercati accanto a chi cita, alla radice e in `docs/`, e i file di configurazione che vetrina tiene alla radice, come `vercel.json`. Un link che esce dal repository è un rimando morto, perché in CI la cartella sopra non c'è. Restano fuori gli altri nomi senza cartella, come `head.astro`, gli URL, le ancore, il codice negli span e nei blocchi recintati, un nome che fa da testo a un link, dove conta la destinazione, i link e i nomi dei Markdown di `src/content/`, che sono copy del sito, e i nomi citati in `docs/ROADMAP.md` e nei `CHANGELOG.md`, che raccontano documenti usciti o da scrivere. Un blocco rientrato di quattro spazi non si riconosce come codice: un esempio va in un blocco recintato.
+
 ## Verifiche di build e di produzione
 
 | Comando | Cosa guarda | Da dove prende le rotte |
@@ -48,7 +50,9 @@ I gate leggono dalla cartella corrente, che deve essere la radice del repository
 | `check lighthouse [url] [--local]` | Lighthouse CI sul `.lighthouserc.json` del progetto; con `url` misura un sito già servito, `--local` fa build, server statico e Chrome da sé | `src/pages` |
 | `gen icons` | le icone del manifest, disegnate da `public/favicon.svg`, che è il suo ingresso obbligatorio | — |
 
-Una rotta renderizzata a richiesta non emette HTML. Con l'adapter Vercel, `check bundle` la legge dal manifest che Astro scrive in `.vercel/output/_functions` e la misura con gli stessi budget delle pagine statiche: gli script della rotta, le isole e gli script dei componenti che i chunk server della pagina nominano, e il runtime del framework quando c'è un'isola. Il JavaScript che Astro incorpora nell'HTML non si conta, né qui né per le pagine statiche. Due limiti: le isole raggiungibili solo attraverso un `import()` dinamico del server — un'isola dentro un contenuto MDX, per esempio — restano fuori, perché seguire quegli import attribuirebbe a ogni pagina il contenuto di tutto il sito; e un'isola si attribuisce per chunk, quindi una pagina eredita le isole dei componenti che condividono un chunk con quelli che usa. Il manifest è un formato interno di Astro, già cambiato una volta sotto i piedi del misuratore che c'era prima: quando non lo riconosce il check lo dice, e fallisce se non gli resta nessuna rotta da misurare; un'isola che non sa collegare al client è un fallimento, non una misura più bassa. Con un altro adapter le rotte SSR restano fuori, dichiarate, e il check misura soltanto il CSS.
+Gli script di una pagina statica si leggono dal suo HTML, anche sotto una `base`, da un `assetsPrefix` o con una query. Una rotta renderizzata a richiesta non emette HTML. Con l'adapter Vercel, `check bundle` la legge dal manifest che Astro scrive in `.vercel/output/_functions` e la misura con gli stessi budget delle pagine statiche: gli script della rotta, le isole e gli script dei componenti che i chunk server della pagina nominano, e il runtime del framework quando c'è un'isola. Il JavaScript che Astro incorpora nell'HTML non si conta, né qui né per le pagine statiche. Due limiti: le isole raggiungibili solo attraverso un `import()` dinamico del server — un'isola dentro un contenuto MDX, per esempio — restano fuori, perché seguire quegli import attribuirebbe a ogni pagina il contenuto di tutto il sito; e un'isola si attribuisce per chunk, quindi una pagina eredita le isole dei componenti che condividono un chunk con quelli che usa. Il manifest è un formato interno di Astro, già cambiato una volta sotto i piedi del misuratore che c'era prima: quando non lo riconosce il check lo dice, e fallisce se non gli resta nessuna rotta da misurare; un'isola che non sa collegare al client è un fallimento, non una misura più bassa. Con un altro adapter, o con un manifest che non riconosce, le rotte SSR restano fuori, dichiarate: si misurano le pagine statiche, e il CSS come dice il paragrafo che segue.
+
+Il CSS di una rotta è la somma dei fogli di `dist/client/_astro` che collega, ognuno contato una volta: per una pagina statica i `<link rel="stylesheet">` del suo HTML, anche sotto una `base`, da un `assetsPrefix` o con una query; per una rotta renderizzata a richiesta i fogli esterni che il manifest le assegna, e una rotta per cui il manifest non li dice è un fallimento. Il tetto è `bundle.cssMaxGzip`, e il rapporto ha una riga per ogni combinazione di fogli, perché le rotte che collegano gli stessi fogli pesano uguale. Non si contano il CSS dentro l'HTML, nei `<style>`, come il JavaScript incorporato, i link che non bloccano il rendering (`preload`, `prefetch`) e i fogli fuori da `_astro`, da `public/` o da un CDN. Un foglio citato che in `_astro` non c'è è un fallimento. Un foglio che nessuna rotta misurata collega si pesa da solo contro lo stesso tetto, e nel rapporto porta «da solo»: il CSS di un `import()` dinamico, quello dei componenti dentro un contenuto MDX reso a richiesta, che il manifest non assegna alla pagina, o tutti i fogli di una build le cui rotte non si leggono. Da solo pesa meno del vero, ma nessun foglio oltre il tetto passa in silenzio.
 
 Per Lighthouse un sito SSR si misura con `check lighthouse <url>`, sulla produzione o su un'anteprima: al posto del server del progetto visita quell'indirizzo, ed è l'unico modo di avere numeri di produzione. `--local` serve i file statici della build, quindi su un sito renderizzato a richiesta si ferma e lo dice, invece di misurare dei 404. Un'anteprima Vercel con la Deployment Protection risponde con la pagina di accesso, e il check non la può misurare: serve la produzione o un'anteprima non protetta. La porta del server locale segue `LH_PORT` sia con `--listen` sia con `--port`.
 
@@ -103,7 +107,7 @@ Le regole che valgono per tutti i progetti stanno nel pacchetto; il progetto est
 
 ```json
 {
-  "$schema": "https://biomejs.dev/schemas/2.5.10/schema.json",
+  "$schema": "./node_modules/@biomejs/biome/configuration_schema.json",
   "extends": ["@elia97/officina/biome"]
 }
 ```
@@ -114,6 +118,8 @@ extends:
   - node_modules/@elia97/officina/presets/lefthook.yml
 ```
 
+`$schema` punta allo schema che il pacchetto di Biome installa, che è sempre quello della CLI. L'URL di biomejs.dev porta invece la versione, che Dependabot non aggiorna quando alza `@biomejs/biome`, e da lì Biome segnala lo scarto a ogni esecuzione: `doctor` lo segnala come errore.
+
 ## Action per i workflow
 
 I passi dei workflow stanno in `actions/` di questo repository, come composite action: girano dentro il job di chi le chiama, quindi il nome del check e l'`environment` restano del progetto. Il riferimento va fissato a un tag di versione o a uno SHA, mai a `@main`, e deve essere la stessa versione del pacchetto installato — `doctor` lo verifica.
@@ -122,7 +128,7 @@ I passi dei workflow stanno in `actions/` di questo repository, come composite a
 |---|---|---|
 | `actions/ci` | checkout, node, install, `astro sync`, `pnpm run ci`, build, `perf:bundle`; con `e2e: 'true'` anche Playwright | trigger, permessi, il job `ci` |
 | `actions/review` | `astro sync`, poi `fallow review` sul diff contro il merge-base | il job informativo |
-| `actions/deploy` | risoluzione del tag, gate, `vercel pull`, `build`, controllo della build, `deploy`, smoke; espone `url` | trigger, `environment`, i tre segreti Vercel passati in `with:`, il job che controlla se i segreti ci sono |
+| `actions/deploy` | risoluzione del tag, stessa versione di officina, gate, `vercel pull`, `build`, controllo della build, `deploy`, smoke; espone `url` | trigger, `environment`, i tre segreti Vercel passati in `with:`, il job che controlla se i segreti ci sono |
 | `actions/lighthouse` | build equivalente alla produzione e `pnpm run lhci` | trigger, etichetta, `continue-on-error` |
 
 ```yaml
@@ -133,7 +139,7 @@ jobs:
       name: production
       url: ${{ steps.deploy.outputs.url }}
     steps:
-      - uses: Elia97/officina/actions/deploy@v0.4.0
+      - uses: Elia97/officina/actions/deploy@vX.Y.Z
         id: deploy
         with:
           ref: ${{ inputs.ref }}
@@ -146,6 +152,8 @@ jobs:
 
 I tre segreti sono input obbligatori e l'action li mette nell'`env` dei soli tre passi che chiamano `vercel`. Nell'`env` del job li vedrebbero anche `pnpm install` e gli script di installazione di ogni dipendenza, che girano codice di terzi con in mano un token di deploy.
 
+**Il deploy lanciato a mano.** Con `workflow_dispatch` il workflow viene dal ramo scelto in «Use workflow from», e il pacchetto dal lockfile del tag che si deploya: le due metà possono avere due versioni di officina diverse, e un passo dell'action più nuova può chiamare un'opzione che gli script del tag non conoscono. `actions/deploy` confronta le due versioni subito dopo l'install, prima di ogni script del progetto e di `vercel pull`, e si ferma dicendole se non coincidono o se il tag non installa officina. Un tag più vecchio si deploya lanciando Deploy da quel tag: il suo `deploy.yml` dichiara l'action della sua versione, con i gate di allora. Perché si possa, l'environment `production` del progetto deve ammettere i tag fra i ref da cui si deploya.
+
 Quello che si scarica al volo è fissato a una versione esatta, in un posto solo: la CLI di Vercel in `actions/deploy/action.yml`, `@lhci/cli` in `src/checks/lighthouse.ts`, `serve` in `src/sh/lhci-local.sh`. Che i primi due siano esatti, uguali ovunque e non indietro di una major su npm lo guarda ogni lunedì `.github/workflows/vercel-cli.yml`, con `officina check vercel-cli`.
 
 Perché le action non restino ferme per sempre, Dependabot di questo repository copre l'ecosistema `github-actions` anche dentro `/actions/*`, dove le action di terze parti sono fissate allo SHA intero con la versione nel commento.
@@ -154,7 +162,7 @@ Perché le action non restino ferme per sempre, Dependabot di questo repository
 
 `officina doctor` dice, in qualunque repository, cosa manca perché il progetto prenda tutto da fuori: i punti di aggancio dei generatori, gli ancoraggi delle pagine a sezioni e dei dizionari, gli script, le dipendenze e gli strumenti di `package.json`, i residui di ciò che è uscito (copia del metodo, script, documenti commerciali), i preset, i workflow di GitHub e Dependabot, `officina.config.ts`. Sta dentro `ci`, quindi un progetto allineato non torna indietro senza che il gate lo dica.
 
-Di `.github/dependabot.yml` guarda la **forma**, non la presenza delle chiavi: lo legge come YAML e pretende che le chiavi del gruppo stiano sul gruppo — Dependabot rifiuta l'intero file se `commit-message` o `open-pull-requests-limit` stanno su una voce che dichiara `multi-ecosystem-group` — e che ogni ecosistema del gruppo abbia una seconda voce per il resto. Senza quella, `patterns` restringe l'intera voce e tutto il resto smette di aggiornarsi senza che niente diventi rosso.
+Di `.github/dependabot.yml` guarda la **forma**, non la presenza delle chiavi: lo legge come YAML e pretende che le chiavi del gruppo stiano sul gruppo — Dependabot rifiuta l'intero file se `commit-message` o `open-pull-requests-limit` stanno su una voce che dichiara `multi-ecosystem-group` — e che ogni ecosistema del gruppo abbia una seconda voce per il resto. Senza quella, `patterns` restringe l'intera voce e tutto il resto smette di aggiornarsi senza che niente diventi rosso. Le action le cerca con il nome che dà loro Dependabot, quello del repository senza la sottocartella: `Elia97/officina`. `Elia97/officina/*` non corrisponde a nessuna dipendenza, in `patterns` come in `ignore` o in `exclude-patterns`, e `doctor` lo segnala ovunque compaia.
 
 Le prime due sezioni rispondono a due domande diverse. I punti di aggancio sono l'elenco di `src/lib/contract.ts`, e chiedono che una cosa esista: i moduli che il codice generato importa, le cartelle in cui i generatori scrivono, `class-variance-authority` fra le dipendenze, lo script `check` che il post-gen lancia. Gli ancoraggi guardano dentro quei file, e chiedono che abbiano ancora la forma su cui l'iniezione conta:
 
@@ -166,12 +174,12 @@ Sono gli stessi controlli del pre-volo dei generatori, non una copia: `doctor` c
 Le altre sezioni misurano che il progetto e il pacchetto si muovano insieme:
 
 - **stessa versione**: il riferimento delle action nei workflow — `@v<x.y.z>`, oppure uno SHA con `# v<x.y.z>` nel commento — deve essere la versione del pacchetto installato. Un progetto col pacchetto alla 0.8 e le action alla 0.6 non è un progetto allineato;
-- **una PR sola**: il `.github/dependabot.yml` del progetto deve avere un gruppo `multi-ecosystem-groups` che prende `@elia97/officina` da npm e `Elia97/officina/*` da `github-actions`. Senza, Dependabot ne apre due e il controllo qui sopra le boccia entrambe;
+- **una PR sola**: il `.github/dependabot.yml` del progetto deve avere un gruppo `multi-ecosystem-groups` che prende `@elia97/officina` da npm e `Elia97/officina` da `github-actions`. Senza, Dependabot ne apre due e il controllo qui sopra le boccia entrambe;
 - **gli strumenti che preset e action danno per scontati**: `@biomejs/biome`, `lefthook`, `@commitlint/cli`, `@commitlint/config-conventional` e `fallow` fra le `devDependencies`, con la versione di Biome dentro l'intervallo che il preset dichiara di reggere.
 
 `package.json`, `.claude/settings.json`, `biome.json` e `.mcp.json` si leggono come JSON, non cercandoci dentro delle stringhe: `"hooks"` in un valore qualunque non è un blocco `hooks`. I workflow restano una ricerca testuale — non c'è un parser YAML nel pacchetto — ma una riga commentata non soddisfa nessun controllo.
 
-**Un requisito nuovo nasce come avviso.** Quando `doctor` impara a chiedere una cosa nuova, la mancanza è un `warning` nella versione che la introduce e diventa un `error` dalla successiva. `doctor` gira dentro `pnpm run ci` senza `--strict`, quindi la PR di Dependabot che porta la versione nuova passa, e il progetto ha una versione di tempo per adeguarsi.
+**Un requisito nuovo nasce come avviso.** Quando `doctor` impara a chiedere una cosa nuova, la mancanza è un `warning` nella versione che la introduce e diventa un `error` dalla successiva. `doctor` gira dentro `pnpm run ci` senza `--strict`, quindi la PR di Dependabot che porta la versione nuova passa, e il progetto ha una versione di tempo per adeguarsi. L'avviso serve a far passare quella PR, e dove non può passare comunque il requisito nasce come errore: con il filtro `Elia97/officina/*` l'aggiornamento arriva diviso in due PR, e nessuna delle due passa il controllo sulla stessa versione.
 
 ## Sviluppo
 

package/dist/checks/bundle.js

@@ -1,10 +1,11 @@
 #!/usr/bin/env node
 // Gate del budget di bundle su dist/client — richiede un `astro build` completato.
 import { readdirSync, readFileSync } from 'node:fs';
-import { join } from 'node:path';
+import { join, relative } from 'node:path';
 import process from 'node:process';
 import { gzipSync } from 'node:zlib';
-import { budgetFor, CSS_BUDGET_GZIP, cssBudgetFailure, deferredClosure, heaviestStylesheet, htmlEntries, parseEdges, staticClosure, } from '../lib/bundle-budget.js';
+import { budgetFor, CSS_BUDGET_GZIP, deferredClosure, htmlEntries, htmlStylesheets, parseEdges, staticClosure, } from '../lib/bundle-budget.js';
+import { measureCss, routeCount } from '../lib/bundle-css.js';
 import { readSsr } from '../lib/bundle-ssr.js';
 import { missingInput } from '../lib/cli.js';
 import { loadConfig } from '../lib/config.js';
@@ -14,9 +15,10 @@ const ASSETS = join(DIST, '_astro');
 const PAGES = 'src/pages';
 const gz = (bytes) => `${(bytes / 1024).toFixed(1)} KB`;
 function readStylesheets() {
-    return readdirSync(ASSETS)
-        .filter((f) => f.endsWith('.css'))
-        .map((file) => ({ file, gzip: gzipSync(readFileSync(join(ASSETS, file))).length }));
+    return filesWithExtension(ASSETS, '.css').map((path) => ({
+        file: relative(ASSETS, path),
+        gzip: gzipSync(readFileSync(path)).length,
+    }));
 }
 function readChunks() {
     const chunks = new Map();
@@ -27,10 +29,10 @@ function readChunks() {
     return chunks;
 }
 function htmlPages() {
-    return filesWithExtension(DIST, '.html').map((htmlPath) => ({
-        route: routeOf(htmlPath, DIST),
-        entries: htmlEntries(readFileSync(htmlPath, 'utf8')),
-    }));
+    return filesWithExtension(DIST, '.html').map((htmlPath) => {
+        const html = readFileSync(htmlPath, 'utf8');
+        return { route: routeOf(htmlPath, DIST), entries: htmlEntries(html), stylesheets: htmlStylesheets(html) };
+    });
 }
 function measurePages(pages, chunks, budgets) {
     const total = (names) => [...names].reduce((sum, name) => sum + (chunks.get(name)?.gzip ?? 0), 0);
@@ -72,13 +74,20 @@ function printPages(pages, width) {
     }
     console.log('\nDIFFERITO = raggiungibile solo da `await import()` (caricato dopo il primo paint, dietro una guardia a runtime).');
 }
-function printStylesheets(stylesheets, cssMaxGzip, failed, width) {
-    const worst = heaviestStylesheet(stylesheets);
-    console.log(`\nCSS (blocca il rendering: il foglio più pesante che una rotta collega)`);
-    for (const sheet of [...stylesheets].sort((a, b) => b.gzip - a.gzip)) {
-        const mark = sheet === worst && failed ? '  ✗' : '';
-        console.log(`  ${sheet.file.padEnd(width - 2)}   ${gz(sheet.gzip).padStart(9)}   ${gz(cssMaxGzip).padStart(9)}${mark}`);
+function printCss({ groups }, cssMaxGzip, width) {
+    console.log('\nCSS per rotta (blocca il rendering: gzip dei fogli che la rotta collega)');
+    for (const { stylesheets, gzip, routes } of groups) {
+        const count = routes.length === 0 ? 'da solo' : routeCount(routes.length);
+        const line = `  ${stylesheets.join(' + ').padEnd(width - 2)}   ${gz(gzip).padStart(9)}   ${gz(cssMaxGzip).padStart(9)}   ${count}`;
+        console.log(gzip > cssMaxGzip ? `${line}  ✗` : line);
     }
+    if (groups.some(({ routes }) => routes.length === 0))
+        console.log('\nda solo = nessuna rotta misurata collega il foglio: si pesa contro il tetto per conto suo.');
+}
+function checkCss(pages, cssMaxGzip, width) {
+    const css = measureCss(pages, readStylesheets(), cssMaxGzip, ASSETS);
+    printCss(css, cssMaxGzip, width);
+    return css.failures;
 }
 function printSsrNote(expected, ssr) {
     for (const note of ssr.notes)
@@ -98,18 +107,15 @@ export async function main() {
     const cssMaxGzip = bundle.cssMaxGzip ?? CSS_BUDGET_GZIP;
     const html = htmlPages();
     const ssr = readSsr(html.length > 0);
-    const pages = measurePages([...html, ...ssr.pages], readChunks(), bundle.budgets ?? []);
+    const routes = [...html, ...ssr.pages];
+    const pages = measurePages(routes, readChunks(), bundle.budgets ?? []);
     const expected = expectedRoutes(readPageFiles(PAGES), PAGES);
     const measured = pages.map((page) => page.route);
     const failures = ssr.comparesExpectedRoutes ? missingRouteFailures(expected, measured, DIST) : [];
     failures.push(...ssr.failures, ...unknownChunkFailures(pages), ...overBudgetFailures(pages));
     const width = Math.max('ROTTA'.length, ...pages.map((p) => p.route.length));
     printPages(pages, width);
-    const stylesheets = readStylesheets();
-    const cssFailure = cssBudgetFailure(stylesheets, cssMaxGzip);
-    if (cssFailure)
-        failures.push(cssFailure);
-    printStylesheets(stylesheets, cssMaxGzip, cssFailure !== null, width);
+    failures.push(...checkCss(routes, cssMaxGzip, width));
     printSsrNote(expected, ssr);
     if (failures.length > 0) {
         console.error(`\n✗ Budget di bundle:\n${failures.map((f) => `  - ${f}`).join('\n')}\n`);

package/dist/checks/doctor.js

@@ -99,7 +99,7 @@ export async function main() {
         }
         const { title, gaps } = section;
         console.log(gaps.length === 0 ? `  ✓ ${title}` : `  ${title}: ${gaps.length}`);
-        const sectionFindings = gaps.map((gap) => ({ ...gap, severity: 'error' }));
+        const sectionFindings = gaps.map((gap) => ({ ...gap, severity: gap.severity ?? 'error' }));
         printFindings(sectionFindings, cliOptions([]).format);
         findings.push(...sectionFindings);
     }

package/dist/checks/placeholders.js

@@ -37,7 +37,7 @@ function scan(env, output, config) {
             scope: `ambiente in ${env}`,
             findings: envScan(env, contactEnvKeys(config)),
             clean: 'Nessun segnaposto del template.',
-            advice: 'Da sostituire prima del deploy: docs/guides/deploy-ops.md § Checklist per il go-live',
+            advice: 'Da impostare su Vercel, fra le variabili di produzione, prima del deploy: quali pretendere lo dice `placeholders.contactEnvKeys` in officina.config.ts',
         };
     }
     const paths = placeholderSources(config);
@@ -45,7 +45,7 @@ function scan(env, output, config) {
         scope: `${paths.length} sorgenti`,
         findings: sourceScan(paths),
         clean: 'Nessun segnaposto del template.',
-        advice: 'Da sostituire prima del deploy: README.md § Cosa tocca il rebranding',
+        advice: 'Da sostituire con i dati del progetto prima del deploy: i file da guardare li dice `placeholders.sources` in officina.config.ts',
     };
 }
 export async function main(args = process.argv.slice(2)) {

package/dist/gen/hook-points.mjs

@@ -1,6 +1,3 @@
-// Un ancoraggio rotto ha un percorso e un problema. Il pre-volo li impagina nel messaggio che
-// ferma il generatore; `doctor`, che gli stessi controlli li lancia senza generare niente, li
-// rimette in un ritrovamento.
 export class HookPointError extends Error {
     constructor(message, path, problem) {
         super(message);

package/dist/lib/alignment.d.ts

@@ -15,5 +15,6 @@ export declare function scriptGaps({ scripts }: Manifest): ContractGap[];
 export declare function dependencyGaps({ dependencies, devDependencies }: Manifest): ContractGap[];
 export declare function leftoverGaps(files: ProjectFiles): ContractGap[];
 export declare const BIOME_PRESET = "@elia97/officina/biome";
+export declare const BIOME_SCHEMA = "./node_modules/@biomejs/biome/configuration_schema.json";
 export declare const LEFTHOOK_PRESET = "node_modules/@elia97/officina/presets/lefthook.yml";
 export declare function presetGaps(files: ProjectFiles): ContractGap[];

package/dist/lib/alignment.js

@@ -125,13 +125,25 @@ export function leftoverGaps(files) {
     return gaps;
 }
 export const BIOME_PRESET = '@elia97/officina/biome';
+export const BIOME_SCHEMA = './node_modules/@biomejs/biome/configuration_schema.json';
 export const LEFTHOOK_PRESET = 'node_modules/@elia97/officina/presets/lefthook.yml';
+// Dependabot aggiorna @biomejs/biome ma non questo URL: con lo schema versionato `biome ci` stampa
+// «The configuration schema version does not match the CLI version»; con quello del pacchetto no.
+const VERSIONED_SCHEMA = /^https:\/\/biomejs\.dev\/schemas\/[^/]+\/schema\.json$/;
 export function presetGaps(files) {
     const gaps = [];
-    const extended = readJson(files, 'biome.json')?.extends;
+    const biome = readJson(files, 'biome.json');
+    const extended = biome?.extends;
     if (!(Array.isArray(extended) && extended.includes(BIOME_PRESET))) {
         gaps.push({ path: 'biome.json', message: `non estende \`${BIOME_PRESET}\`` });
     }
+    const schema = biome?.$schema;
+    if (typeof schema === 'string' && VERSIONED_SCHEMA.test(schema)) {
+        gaps.push({
+            path: 'biome.json',
+            message: `\`$schema\` porta la versione di Biome, che Dependabot non aggiorna: va su \`${BIOME_SCHEMA}\``,
+        });
+    }
     if (!mentions(files.read('lefthook.yml'), LEFTHOOK_PRESET)) {
         gaps.push({ path: 'lefthook.yml', message: `non estende \`${LEFTHOOK_PRESET}\`` });
     }

package/dist/lib/bundle-budget.d.ts

@@ -13,6 +13,7 @@ export declare function budgetFor(route: string, budgets?: readonly Budget[]): B
 /** Rollup racchiude gli specificatori statici con `"` e i dinamici in un template literal. */
 export declare function parseEdges(source: string): Pick<Chunk, 'static' | 'dynamic'>;
 export declare function htmlEntries(html: string): string[];
+export declare function htmlStylesheets(html: string): string[];
 /** `unknown`: i nomi citati che in `dist/client/_astro` non ci sono — saltarli vorrebbe dire misurare meno del vero. */
 export type Closure = {
     reached: Set<string>;
@@ -25,5 +26,3 @@ export type Stylesheet = {
     file: string;
     gzip: number;
 };
-export declare function heaviestStylesheet(sheets: readonly Stylesheet[]): Stylesheet | null;
-export declare function cssBudgetFailure(sheets: readonly Stylesheet[], maxGzip?: number): string | null;

package/dist/lib/bundle-budget.js

@@ -14,7 +14,14 @@ export function parseEdges(source) {
     };
 }
 export function htmlEntries(html) {
-    return [...captured(html, /(?:src|href)="\/_astro\/([^"]+\.js)"/g, 1)];
+    return [...captured(html, /\b(?:src|href)=["']?[^"'\s>]*?\/_astro\/([^"'\s>?#]+\.js)/g, 1)];
+}
+const LINK_TAG = /<link\b[^>]*>/gi;
+const STYLESHEET_REL = /\brel=["']?stylesheet\b/i;
+const LOCAL_STYLESHEET = /\bhref=["']?[^"'\s>]*?\/_astro\/([^"'\s>?#]+\.css)/i;
+export function htmlStylesheets(html) {
+    const links = [...html.matchAll(LINK_TAG)].map(([tag]) => tag).filter((tag) => STYLESHEET_REL.test(tag));
+    return [...new Set(links.map((tag) => tag.match(LOCAL_STYLESHEET)?.[1]).filter((name) => name !== undefined))];
 }
 export function staticClosure(entries, chunks) {
     const reached = new Set();
@@ -39,15 +46,3 @@ export function deferredClosure(reached, chunks) {
     return new Set([...staticClosure(entries, chunks).reached].filter((name) => !reached.has(name)));
 }
 export const CSS_BUDGET_GZIP = 12 * 1024;
-export function heaviestStylesheet(sheets) {
-    return sheets.reduce((worst, sheet) => (worst && worst.gzip >= sheet.gzip ? worst : sheet), null);
-}
-// Astro emette un foglio di stile per gruppo di pagine e una rotta ne collega esattamente uno,
-// quindi la loro somma è fatta di byte che nessun visitatore scarica mai insieme.
-export function cssBudgetFailure(sheets, maxGzip = CSS_BUDGET_GZIP) {
-    const heaviest = heaviestStylesheet(sheets);
-    if (heaviest === null || heaviest.gzip <= maxGzip)
-        return null;
-    const over = heaviest.gzip - maxGzip;
-    return `CSS ${(heaviest.gzip / 1024).toFixed(1)} KB gz > ${(maxGzip / 1024).toFixed(1)} KB (+${(over / 1024).toFixed(1)} KB) in ${heaviest.file}`;
-}

package/dist/lib/bundle-css.d.ts

@@ -0,0 +1,16 @@
+import type { Stylesheet } from './bundle-budget.ts';
+export type RouteStylesheets = {
+    route: string;
+    stylesheets: readonly string[];
+};
+export type CssGroup = {
+    stylesheets: string[];
+    gzip: number;
+    routes: string[];
+};
+export type CssMeasure = {
+    groups: CssGroup[];
+    failures: string[];
+};
+export declare const routeCount: (count: number) => string;
+export declare function measureCss(routes: readonly RouteStylesheets[], sheets: readonly Stylesheet[], maxGzip: number, assets: string): CssMeasure;

package/dist/lib/bundle-css.js

@@ -0,0 +1,33 @@
+const kb = (bytes) => `${(bytes / 1024).toFixed(1)} KB`;
+export const routeCount = (count) => (count === 1 ? '1 rotta' : `${count} rotte`);
+function overBudget({ stylesheets, gzip, routes }, maxGzip) {
+    const weight = `CSS ${kb(gzip)} > ${kb(maxGzip)} (+${kb(gzip - maxGzip)})`;
+    if (routes.length === 0)
+        return `${stylesheets.join(' + ')}: ${weight}, pesato da solo: nessuna rotta misurata lo collega`;
+    const [first] = [...routes].sort();
+    return `${first}: ${weight} — ${stylesheets.join(' + ')}, su ${routeCount(routes.length)}`;
+}
+export function measureCss(routes, sheets, maxGzip, assets) {
+    const weights = new Map(sheets.map(({ file, gzip }) => [file, gzip]));
+    const groups = new Map();
+    const failures = [];
+    for (const { route, stylesheets } of routes) {
+        const linked = [...new Set(stylesheets)].sort();
+        for (const name of linked.filter((sheet) => !weights.has(sheet)))
+            failures.push(`${route}: il foglio ${name} non è in ${assets}, e il CSS della rotta non si misura per intero`);
+        if (linked.length === 0)
+            continue;
+        const key = linked.join(' + ');
+        const gzip = linked.reduce((sum, sheet) => sum + (weights.get(sheet) ?? 0), 0);
+        const group = groups.get(key) ?? { stylesheets: linked, gzip, routes: [] };
+        group.routes.push(route);
+        groups.set(key, group);
+    }
+    const linkedAnywhere = new Set(routes.flatMap(({ stylesheets }) => stylesheets));
+    for (const { file, gzip } of sheets)
+        if (!linkedAnywhere.has(file))
+            groups.set(file, { stylesheets: [file], gzip, routes: [] });
+    const measured = [...groups.values()].sort((a, b) => b.gzip - a.gzip);
+    failures.push(...measured.filter((group) => group.gzip > maxGzip).map((group) => overBudget(group, maxGzip)));
+    return { groups: measured, failures };
+}

package/dist/lib/bundle-ssr.d.ts

@@ -1,6 +1,7 @@
 export type PageEntries = {
     route: string;
     entries: string[];
+    stylesheets: string[];
 };
 export type SsrReading = {
     pages: PageEntries[];

package/dist/lib/bundle-ssr.js

@@ -27,9 +27,10 @@ export function readSsr(hasHtml) {
     }
     return {
         ...none,
-        pages: routes.map(({ route, entries }) => ({ route, entries })),
-        failures: routes.flatMap(({ route, unmapped, unknownIslands }) => [
+        pages: routes.map(({ route, entries, stylesheets }) => ({ route, entries, stylesheets: stylesheets ?? [] })),
+        failures: routes.flatMap(({ route, unmapped, unknownIslands, stylesheets }) => [
             ...(unmapped ? [`${route}: nessun chunk server in ${FUNCTIONS}, la misura non coprirebbe le isole`] : []),
+            ...(stylesheets === null ? [`${route}: il manifest non dice quali fogli di stile collega la rotta`] : []),
             ...unknownIslands.map((island) => `${route}: l'isola ${island} non ha un chunk in dist/client/_astro fra quelli del manifest`),
         ]),
         measured: true,

package/dist/lib/check-placeholders.js

@@ -13,6 +13,7 @@ const ZERO_POSTAL_CODE = /\bpostalCode:\s*(['"])00000\1/;
 const EMPTY_HREF = /\bhref:\s*(['"])#\1/;
 // `SENSITIVE_ENV_VALUE_PLACEHOLDER` di vercel@59.22.0: `vercel pull` lo scrive al posto del valore di una Sensitive.
 const SENSITIVE = '[SENSITIVE]';
+const WITHOUT_VALUE = 'il deploy andrebbe online senza il suo valore';
 const dictionaries = () => existsSync(DICTIONARIES)
     ? readdirSync(DICTIONARIES)
         .filter((name) => name.endsWith('.ts'))
@@ -56,7 +57,7 @@ export function envFindings(content, keys) {
         const value = env[key]?.trim();
         const declaration = lines.find(({ text }) => new RegExp(`^\\s*(?:export\\s+)?${key}\\s*=`).test(text));
         if (value === undefined || declaration === undefined) {
-            const message = `${key} non c'è fra le variabili di produzione su Vercel: vale il default di astro.config.mjs`;
+            const message = `${key} non c'è fra le variabili di produzione su Vercel: ${WITHOUT_VALUE}`;
             return [{ severity: 'error', message }];
         }
         const hit = (severity, message) => [
@@ -65,7 +66,7 @@ export function envFindings(content, keys) {
         if (value === SENSITIVE)
             return hit('warning', 'è Sensitive su Vercel: vercel pull non ne scarica il valore, e il deploy non lo può verificare');
         if (value === '')
-            return hit('error', 'è vuota: vale il default di astro.config.mjs');
+            return hit('error', `è vuota: ${WITHOUT_VALUE}`);
         if (TOKEN.test(value) || DOMAIN.test(value))
             return hit('error', 'porta un segnaposto del template');
         return [];

package/dist/lib/check-routes.js

@@ -1,5 +1,8 @@
 import { existsSync, readFileSync } from 'node:fs';
+import { posix } from 'node:path';
+import { blankFences, blankSpans, linkDestinations } from './markdown.js';
 const SCANNED = /\.md$/;
+const ROADMAP = 'docs/ROADMAP.md';
 const IGNORED = [
     // Scritti a runtime dai comandi, gitignored per costruzione.
     /^\.claude\/plans\//,
@@ -7,9 +10,39 @@ const IGNORED = [
     /\.pdf$/,
     /^docs\/sources\//,
 ];
-const PATH_REFERENCE = /`((?:docs|src|scripts|test|public|\.claude|\.github)\/[A-Za-z0-9._/-]+\.[a-z]+)`/g;
+const PATH_REFERENCE = /`((?:docs|src|scripts|test|e2e|public|\.claude|\.github)\/[A-Za-z0-9._/-]+\.[a-z]+)`/g;
+const NAME_REFERENCE = /`([A-Za-z0-9._-]+)`/g;
 // La virgola non delimita: i titoli la contengono.
 const SECTION_REFERENCE = /`([A-Za-z0-9._/-]+\.md)`\s*§\s*([^.·|)§]{1,80})/g;
+const LINK_TEXT = /\[[^[\]]*\]\(/g;
+const ROOT_DOCUMENT = /^[A-Z][A-Z0-9_-]*\.md$/;
+// I file tracciati alla radice di template/vetrina (git ls-files), Markdown esclusi.
+const ROOT_CONFIG = new Set([
+    '.editorconfig',
+    '.env.example',
+    '.fallowrc.jsonc',
+    '.gitignore',
+    '.lighthouserc.json',
+    '.npmrc',
+    '.nvmrc',
+    '.release-please-manifest.json',
+    'astro.config.mjs',
+    'biome.json',
+    'commitlint.config.js',
+    'lefthook.yml',
+    'officina.config.ts',
+    'package.json',
+    'playwright.config.ts',
+    'pnpm-lock.yaml',
+    'pnpm-workspace.yaml',
+    'release-please-config.json',
+    'tsconfig.json',
+    'vercel.json',
+    'vitest.config.ts',
+]);
+const CHANGELOG = /(?:^|\/)CHANGELOG\.md$/;
+const SITE_CONTENT = /^src\/content\//;
+const EXTERNAL = /^(?:[a-z][a-z0-9+.-]*:|#|\/)/i;
 const isIgnored = (path) => IGNORED.some((re) => re.test(path));
 export const isScanned = (path) => SCANNED.test(path) && !isIgnored(path);
 export function normalizeTitle(raw) {
@@ -32,23 +65,37 @@ const resolves = (titles, cited) => titles.some((title) => cited === title || (c
 export function resolveTarget(from, cited) {
     if (cited.includes('/'))
         return cited;
-    const sibling = `${from.slice(0, from.lastIndexOf('/') + 1)}${cited}`;
-    return existsSync(sibling) ? sibling : cited;
+    const candidates = [`${from.slice(0, from.lastIndexOf('/') + 1)}${cited}`, cited, `docs/${cited}`];
+    return candidates.find((candidate) => existsSync(candidate)) ?? cited;
 }
-export function findingsFor(path, source) {
+const references = (text, pattern) => [...text.matchAll(pattern)]
+    .map((match) => ({ index: match.index, target: match[1] }))
+    .filter((reference) => reference.target !== undefined);
+const pathReferences = (flat) => references(flat, PATH_REFERENCE).filter(({ target }) => !target.includes('*'));
+function nameReferences(path, flat) {
+    if (path === ROADMAP || CHANGELOG.test(path) || SITE_CONTENT.test(path))
+        return [];
+    const labels = [...flat.matchAll(LINK_TEXT)].map(({ index, 0: text }) => ({ start: index, end: index + text.length }));
+    const inLabel = (index) => labels.some(({ start, end }) => index > start && index < end);
+    return references(flat, NAME_REFERENCE)
+        .filter(({ index, target }) => (ROOT_DOCUMENT.test(target) || ROOT_CONFIG.has(target)) && !inLabel(index))
+        .map(({ index, target }) => ({ index, target: resolveTarget(path, target) }));
+}
+const linkTarget = (from, destination) => EXTERNAL.test(destination)
+    ? undefined
+    : posix.normalize(posix.join(posix.dirname(from), destination.replace(/[#?].*$/, '')));
+function linkReferences(path, code) {
+    if (SITE_CONTENT.test(path))
+        return [];
+    return linkDestinations(code).flatMap(({ index, destination }) => {
+        const target = linkTarget(path, destination);
+        return target === undefined ? [] : [{ index, target }];
+    });
+}
+const escapes = (target) => target === '..' || target.startsWith('../');
+const isMissing = (target) => !isIgnored(target) && (escapes(target) || !existsSync(target));
+function sectionFindings(path, flat, lineOf, missing) {
     const findings = [];
-    // Un titolo va a capo come qualunque prosa: si cerca su testo continuo. La sostituzione è uno a
-    // uno, quindi gli offset restano quelli del sorgente e la riga si conta da lì.
-    const flat = source.replace(/\n/g, ' ');
-    const lineOf = (index) => source.slice(0, index).split('\n').length;
-    const missingTargets = new Set();
-    for (const match of flat.matchAll(PATH_REFERENCE)) {
-        const target = match[1];
-        if (!target || isIgnored(target) || target.includes('*') || existsSync(target))
-            continue;
-        missingTargets.add(target);
-        findings.push({ line: lineOf(match.index), message: `percorso che non esiste: ${target}` });
-    }
     for (const match of flat.matchAll(SECTION_REFERENCE)) {
         const [, file, title] = match;
         /* v8 ignore next -- i due gruppi sono obbligatori nella regex, ma noUncheckedIndexedAccess pretende la guardia */
@@ -56,7 +103,7 @@ export function findingsFor(path, source) {
             continue;
         const line = lineOf(match.index);
         const target = resolveTarget(path, file);
-        if (isIgnored(target) || missingTargets.has(target))
+        if (isIgnored(target) || missing.has(`${line}:${target}`))
             continue;
         if (!existsSync(target)) {
             findings.push({ line, message: `sezione in un file che non esiste: ${target}` });
@@ -66,5 +113,27 @@ export function findingsFor(path, source) {
         if (!resolves(headings(readFileSync(target, 'utf8')), cited))
             findings.push({ line, message: `sezione che non esiste: ${target} § ${cited}` });
     }
-    return findings.sort((a, b) => a.line - b.line);
+    return findings;
+}
+export function findingsFor(path, source) {
+    const fenced = blankFences(source);
+    // Un titolo va a capo come qualunque prosa: si cerca su testo continuo. La sostituzione è uno a
+    // uno, quindi gli offset restano quelli del sorgente e la riga si conta da lì.
+    const flat = fenced.replace(/\n/g, ' ');
+    const lineOf = (index) => source.slice(0, index).split('\n').length;
+    const missing = new Map();
+    for (const { index, target } of [
+        ...pathReferences(flat),
+        ...nameReferences(path, flat),
+        ...linkReferences(path, blankSpans(fenced)),
+    ]) {
+        const line = lineOf(index);
+        if (isMissing(target))
+            missing.set(`${line}:${target}`, { line, target });
+    }
+    const paths = [...missing.values()].map(({ line, target }) => ({
+        line,
+        message: `percorso che non esiste: ${target}`,
+    }));
+    return [...paths, ...sectionFindings(path, flat, lineOf, new Set(missing.keys()))].sort((a, b) => a.line - b.line);
 }

package/dist/lib/contract.d.ts

@@ -25,6 +25,7 @@ export declare const CONTRACT: Requirement[];
 export interface ContractGap {
     path: string;
     message: string;
+    severity?: 'warning';
 }
 export declare function contractGaps(root: string): ContractGap[];
 export {};

package/dist/lib/dependabot.js

@@ -1,7 +1,8 @@
 import { parse } from 'yaml';
 const DEPENDABOT = '.github/dependabot.yml';
 const PACKAGE = '@elia97/officina';
-const ACTIONS = 'Elia97/officina/*';
+const ACTIONS = 'Elia97/officina';
+const PATH_FILTER = `${ACTIONS}/*`;
 const GROUP_ONLY = ['commit-message', 'open-pull-requests-limit'];
 const gap = (message) => ({ path: DEPENDABOT, message });
 const isRecord = (value) => typeof value === 'object' && value !== null && !Array.isArray(value);
@@ -32,6 +33,16 @@ const coverageGaps = (updates) => [
 ]
     .filter(({ ecosystem, needle }) => !inGroup(updates).some((u) => u['package-ecosystem'] === ecosystem && covers(u, needle)))
     .map(({ needle, reason }) => gap(`nessuna voce del gruppo copre \`${needle}\`: ${reason}`));
+const strings = (value) => {
+    if (typeof value === 'string')
+        return [value];
+    return typeof value === 'object' && value !== null ? Object.values(value).flatMap(strings) : [];
+};
+const pathFilterGaps = (document) => strings(document).includes(PATH_FILTER)
+    ? [
+        gap(`\`${PATH_FILTER}\` non corrisponde a nessuna dipendenza: Dependabot chiama le action \`${ACTIONS}\`, senza la sottocartella, e il filtro va corretto ovunque compaia`),
+    ]
+    : [];
 // `patterns` restringe l'intera voce: il resto dell'ecosistema smette di aggiornarsi e nessun check diventa rosso.
 function restGaps(updates) {
     const restrained = inGroup(updates).filter((update) => (update.patterns ?? []).length > 0);
@@ -55,5 +66,11 @@ export function dependabotGaps({ read: readFile }) {
     if (typeof document === 'string')
         return [gap(document)];
     const updates = document.updates ?? [];
-    return [...groupGaps(document, updates), ...misplacedGaps(updates), ...coverageGaps(updates), ...restGaps(updates)];
+    return [
+        ...groupGaps(document, updates),
+        ...misplacedGaps(updates),
+        ...coverageGaps(updates),
+        ...pathFilterGaps(document),
+        ...restGaps(updates),
+    ];
 }

package/dist/lib/markdown.d.ts

@@ -0,0 +1,7 @@
+export interface Destination {
+    index: number;
+    destination: string;
+}
+export declare function blankFences(source: string): string;
+export declare const blankSpans: (text: string) => string;
+export declare const linkDestinations: (text: string) => Destination[];

package/dist/lib/markdown.js

@@ -0,0 +1,41 @@
+// CommonMark § 4.5: recinto di tre o più ` o ~ (rientro fino a 3 spazi), chiuso da una riga dello stesso carattere,
+// lunga almeno quanto l'apertura.
+const FENCE = /^ {0,3}(`{3,}|~{3,})/;
+// CommonMark § 6.1: lo span si chiude alla prima stringa di apici inversi di pari lunghezza; una riga vuota lo interrompe.
+const SPAN = /(?<!`)(`+)(?!`)((?:(?!\n[ \t]*\n)[\s\S])*?)(?<!`)\1(?!`)/g;
+// CommonMark § 6.3: destinazione fra <> o senza spazi (parentesi bilanciate, qui un solo livello); titolo fra "", '' o ().
+const INLINE = /\]\(\s*(?:<([^>\n]*)>|((?:[^()\s\\]|\\.|\([^()\s]*\))*))(?:\s+(?:"[^"]*"|'[^']*'|\([^()]*\)))?\s*\)/g;
+const DEFINITION = /^ {0,3}\[[^\]\n]+\]:[ \t]*(?:<([^>\n]*)>|(\S+))/gm;
+const spaces = (text) => text.replace(/[^\n]/g, ' ');
+export function blankFences(source) {
+    let fence;
+    return source
+        .split('\n')
+        .map((line) => {
+        const run = FENCE.exec(line)?.[1];
+        if (fence === undefined) {
+            if (run === undefined)
+                return line;
+            fence = run;
+        }
+        else if (run !== undefined && run[0] === fence[0] && run.length >= fence.length && line.trim() === run) {
+            fence = undefined;
+        }
+        return spaces(line);
+    })
+        .join('\n');
+}
+export const blankSpans = (text) => text.replace(SPAN, spaces);
+const unescaped = (text) => text.replace(/\\(.)/g, '$1');
+function decoded(text) {
+    try {
+        return decodeURIComponent(text);
+    }
+    catch {
+        return text;
+    }
+}
+export const linkDestinations = (text) => [...text.matchAll(INLINE), ...text.matchAll(DEFINITION)].map((match) => ({
+    index: match.index,
+    destination: decoded(unescaped((match[1] ?? match[2]))),
+}));

package/dist/lib/past-tense.js

@@ -13,7 +13,7 @@ export const PAST_TENSE = [
     // "non più di 3" è una quantità, non un cambiamento.
     phrase(['non (?:è |viene |serve )?più(?! di)']),
     phrase(["ora (?:è|invece|lo|la|il|si|c'è|non)", 'adesso', 'per ora', 'temporaneamente']),
-    phrase(['sostituisce', 'al posto di', 'vecchi[oa]']),
+    phrase(['sostituisce', 'vecchi[oa]']),
     phrase(['used to', 'previously', 'no longer', 'replaces the', 'replaced by', 'removed in', 'for now', 'temporarily']),
     /#\d{1,3}(?!\d)/,
 ];

package/dist/lib/validate.js

@@ -25,8 +25,6 @@ export const aRecordOf = (item) => (value, path) => isRecord(value)
     ? Object.entries(value).flatMap(([key, entry]) => item(entry, `${path}.${key}`))
     : [problem(path, 'un oggetto', value)];
 export const oneOf = (expected, allowed) => (value, path) => allowed.includes(value) ? [] : [problem(path, expected, value)];
-// Una voce non dichiarata è un errore: `sitUrl` al posto di `siteUrl` non deve passare in
-// silenzio, che è il modo esatto in cui una configurazione smette di dire qualcosa.
 export const aShape = (fields) => (value, path) => {
     if (!isRecord(value))
         return [problem(path, 'un oggetto', value)];

package/dist/lib/vercel-build.d.ts

@@ -5,6 +5,7 @@ export type ServerFile = {
 export type SsrRoute = {
     route: string;
     entries: string[];
+    stylesheets: string[] | null;
     unmapped: boolean;
     unknownIslands: string[];
 };

package/dist/lib/vercel-build.js

@@ -1,6 +1,7 @@
 import { posix } from 'node:path';
 const MANIFEST_CALL = 'deserializeManifest({';
-const ASSET = /^_astro\/([^/]+\.js)$/;
+const ASSET = /^(?:.*\/)?_astro\/([^/?#]+\.js)(?:[?#].*)?$/;
+const STYLESHEET = /^(?:.*\/)?_astro\/([^?#]+\.css)(?:[?#].*)?$/;
 const RENDERER_RUNTIME = /^@astrojs\/[\w-]+\/client\.js$/;
 const COMPONENT_SCRIPT = '?astro&type=script';
 const PAGE_ROUTE = /\["(src\/pages\/[^"]+)", (_page\d+)\]/g;
@@ -65,7 +66,7 @@ function serverClosure(start, files, manifestFile) {
     }
     return [...reached.values()];
 }
-const assetOf = (value) => value?.match(ASSET)?.[1];
+const assetOf = (value, pattern = ASSET) => value?.match(pattern)?.[1];
 function clientModules(manifest) {
     const inlined = new Set((manifest.inlinedScripts ?? []).map(([specifier]) => specifier));
     const modules = new Map();
@@ -87,11 +88,19 @@ function routeEntries(page, texts, modules) {
 const unknownIslands = (texts, modules) => [...new Set(texts.flatMap((text) => [...text.matchAll(ISLAND_PATH)].map(([, path]) => path)))]
     .filter((path) => !modules.has(path))
     .sort();
-function ssrPage({ scripts = [], routeData }) {
+const routeStylesheets = (styles) => !Array.isArray(styles)
+    ? null
+    : [
+        ...new Set(styles
+            .filter((style) => style.type === 'external')
+            .map((style) => assetOf(style.src, STYLESHEET))
+            .filter((name) => name !== undefined)),
+    ].sort();
+function ssrPage({ scripts = [], styles, routeData }) {
     if (routeData?.type !== 'page' || routeData.origin !== 'project' || routeData.prerender !== false)
         return [];
     const { route, component } = routeData;
-    return typeof route === 'string' && typeof component === 'string' ? [{ scripts, route, component }] : [];
+    return typeof route === 'string' && typeof component === 'string' ? [{ scripts, styles, route, component }] : [];
 }
 export function ssrRoutes(files) {
     for (const file of files) {
@@ -111,6 +120,7 @@ function routesOf(host, manifest, files) {
         return {
             route: page.route,
             entries: routeEntries(page, texts, modules),
+            stylesheets: routeStylesheets(page.styles),
             unmapped: chunk === undefined,
             unknownIslands: unknownIslands(texts, modules),
         };

package/dist/smoke.js

@@ -1,4 +1,2 @@
-// I pezzi con cui un progetto compone i propri controlli di smoke: `smoke.checks` sostituisce la
-// lista del pacchetto, quindi chi ne toglie uno ricompone la lista da qui.
 export { NON_HTML_ROUTES } from './lib/routes.js';
 export { checkBotIdChallenge, checkCanonicalHost, checkPages, checkSecurityHeaders, checkTrailingSlash, DEFAULT_CHECKS, SECURITY_HEADERS, } from './lib/smoke-production.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@elia97/officina",
-  "version": "0.9.1",
+  "version": "0.10.0",
   "description": "Gli strumenti dei progetti nati dai template di Elia: gate di qualità, generatori e verifiche di build e di produzione.",
   "type": "module",
   "license": "MIT",
@@ -48,9 +48,10 @@
     "typecheck": "tsc --noEmit",
     "test": "vitest run --coverage",
     "format": "biome check --write .",
+    "check:comments": "node src/bin.ts check comments --strict",
     "check:deadcode": "fallow dead-code",
     "check:health": "fallow health --complexity --coverage coverage/coverage-final.json",
-    "ci": "biome ci --error-on-warnings . && pnpm run typecheck && pnpm run check:deadcode && pnpm run test && pnpm run check:health",
+    "ci": "biome ci --error-on-warnings . && pnpm run typecheck && pnpm run check:deadcode && pnpm run check:comments && pnpm run test && pnpm run check:health",
     "test:pack": "bash scripts/pack-test.sh"
   },
   "devDependencies": {