@elia97/officina 0.9.1 → 0.11.0

package/README.md

@@ -19,6 +19,7 @@ pnpm add -D @elia97/officina
     "check:roadmap": "officina check roadmap",
     "check:placeholders": "officina check placeholders",
     "perf:bundle": "officina check bundle",
+    "check:links": "officina check links",
     "smoke:prod": "officina check smoke",
     "analytics:verify": "officina check analytics",
     "lhci": "officina check lighthouse",
@@ -38,17 +39,24 @@ 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 |
 |---|---|---|
 | `check bundle` | il JavaScript e il CSS di `dist/client`, gzip, contro un budget per rotta | `src/pages`; sotto SSR, il manifest della build Vercel |
+| `check links` | gli `<a href>` di `dist/client`: ogni link interno porta a qualcosa che la build serve, e nessuno a `#` | i file di `dist/client` e le rotte a richiesta del manifest della build Vercel |
 | `check smoke [url]` | la produzione viva: pagine, header di sicurezza, BotID, host canonico, barra finale | `src/pages`, più le rotte non HTML |
 | `check analytics [GTM-…]` | il container GTM pubblico contro gli eventi del modulo di link-tracking del progetto (`analytics.linkTracking`) | — |
 | `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.
+
+`check links` legge gli `<a href>` di ogni HTML di `dist/client`, fuori dai commenti, dagli `<script>`, dagli `<style>` e dai valori degli attributi, dove Astro lascia `<` e `>` come sono. È interno un link relativo, uno che comincia con `/` o uno assoluto verso l'origine di `siteUrl`, e se ne confronta il percorso, senza query né ancora, con o senza barra finale; un link relativo si risolve come con `trailingSlash: 'never'`, che è quello dei template. Vale se porta a un file della build, pagina o altro file, o a una rotta che il manifest della build Vercel rende a richiesta, endpoint e `/` di lingua compresi, confrontata con il pattern che Astro scrive lì; senza manifest, o con un altro adapter, a una pagina `.astro` con `prerender = false`, e il rapporto lo dice. Che la pagina dietro una rotta a richiesta esista lo sa solo il server, e una rotta come `/[...slug]` accetta ogni percorso: il rapporto conta i link che passano così. `href="#"`, `href=""` e un `href` senza valore sono segnaposto, e falliscono come un link rotto. Il rapporto raggruppa per destinazione e nomina le pagine che la citano: un link rotto nel footer è un problema solo, non uno per pagina. Restano fuori, e il rapporto li conta, i link esterni, che chiederebbero la rete, `mailto:`, `tel:` e gli altri schemi, e l'id a cui punta un'ancora. Una `dist/client` senza HTML è un fallimento, perché il controllo non affermerebbe niente: un progetto che rende ogni pagina a richiesta lo spegne con `features.links: false`. Due limiti: con una `base` i link non si risolvono, e un redirect di `vercel.json` non è una pagina, quindi un link che ci porta passa per rotto, e si corregge puntando alla destinazione.
 
 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`.
 
@@ -70,7 +78,7 @@ export default defineConfig({
   icons: { background: SITE.themeColor.light },
   bundle: { budgets: [motion], cssMaxGzip: 14 * 1024 },
   smoke: { checks: [...DEFAULT_CHECKS, checkLanguageRedirect] },
-  features: { analytics: 'required', roadmap: false, botId: 'required' },
+  features: { analytics: 'required', roadmap: false, botId: 'required', links: 'required' },
   routes: { representatives: { '/blog/[slug]': '/blog/ciao-mondo' } },
 })
 ```
@@ -87,6 +95,8 @@ La radice del pacchetto esporta `defineConfig` e i tipi; i pezzi del motore stan
 
 `features` dice quali controlli il progetto pretende: `'required'` fa fallire il gate quando ciò che deve guardare non c'è, `false` lo spegne dicendolo. Per BotID è `features.botId`: con `false` lo smoke salta la challenge e lo scrive nell'uscita, anche dentro una lista di `smoke.checks` che la contiene. Una voce non dichiarata vale `'required'`, e `doctor` la segnala: un gate che esce 0 su un container GTM che non esiste non afferma niente. `routes.representatives` dà a ogni pattern dinamico di `src/pages` un percorso vero, e da lì smoke e Lighthouse guardano anche quelle pagine.
 
+`routes.disabled` elenca i pattern dinamici che il progetto spegne per scelta, scritti come le chiavi di `routes.representatives`: le news tenute spente finché non ci sono articoli veri, con un `getStaticPaths` che non emette niente. Come per `features`, una pagina si spegne scrivendolo, non dimenticandola: un pattern dinamico che non emette niente senza essere dichiarato resta un fallimento di `check bundle`. Su un pattern spento `check bundle` non pretende pagine e lo elenca come spento, `doctor` non chiede il rappresentante e lo elenca fra le spente, smoke e Lighthouse non lo visitano, anche se il rappresentante c'è ancora, e lo scrivono nell'uscita: quando il progetto riaccende la pagina, qui basta togliere la voce. Il contrario è un fallimento di `check bundle`, perché dichiarazione e build non coincidono: una rotta emessa che soltanto un pattern spento spiega, o una pagina spenta che la build rende a richiesta, come una pagina senza `prerender` con `output: 'server'`. Si spegne solo una pagina prerenderizzata. `doctor` legge il sorgente, e una voce che lì non è una pagina dinamica prerenderizzata di `src/pages` è un suo errore: una pagina statica Astro la genera sempre, e un nome sbagliato non spegne niente. `check bundle` conosce solo le pagine `.astro`: una pagina Markdown di `src/pages`, o un `.html` di `public/`, che cade sotto un pattern spento passa per emessa da quello.
+
 `features.generators` ha un valore in più delle altre, perché non tutti i siti in produzione nascono dallo scaffold: `'required'` è il comportamento di sempre; `false` spegne i generatori del pacchetto, e `doctor` smette di chiedere i punti di aggancio e gli ancoraggi invece di pretendere file che nessun codice di quel sito userebbe; `'project'` fa lo stesso ma lascia vivi i generatori che il progetto scrive in `officina.generators.mjs`, che a quel punto `doctor` pretende. Con `false` o `'project'`, `officina gen section|page|component|collection` si ferma dicendolo, mentre gli script `gen` e `gen:*` restano attesi in `package.json`: meglio un comando che spiega di uno script che manca. `gen icons` non c'entra con i generatori di codice e non cambia.
 
 `placeholders` dice a `check placeholders` cosa guardare: `sources` sono i file da scandire, `contactEnvKeys` le variabili che `--env` pretende. Una lista dichiarata **sostituisce** quella del pacchetto, dizionari compresi: senza dichiarazione i sorgenti sono `src/lib/site.ts`, `src/lib/company.ts` e i dizionari di `src/i18n/strings`, quando la cartella esiste. Serve ai progetti che non nascono dallo scaffold: se partita IVA, recapiti e destinatario dei form stanno nel contenuto invece che in un modulo, i sorgenti del template non sono i suoi, e crearli per far passare il gate terrebbe gli stessi dati in due sedi. Un sorgente elencato che non esiste è un ritrovamento con il suo percorso, non un errore che ferma il comando.
@@ -103,7 +113,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,15 +124,17 @@ 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.
 
 | Action | Passi | Cosa resta nel workflow del progetto |
 |---|---|---|
-| `actions/ci` | checkout, node, install, `astro sync`, `pnpm run ci`, build, `perf:bundle`; con `e2e: 'true'` anche Playwright | trigger, permessi, il job `ci` |
+| `actions/ci` | checkout, node, install, `astro sync`, `pnpm run ci`, build, `perf:bundle`, `check:links`; 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 +145,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 +158,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 +168,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 +180,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/bin.js

@@ -8,6 +8,7 @@ export const CHECKS = {
     comments: () => import('./checks/comments.js'),
     language: () => import('./checks/language.js'),
     lighthouse: () => import('./checks/lighthouse.js'),
+    links: () => import('./checks/links.js'),
     placeholders: () => import('./checks/placeholders.js'),
     roadmap: () => import('./checks/roadmap.js'),
     routes: () => import('./checks/routes.js'),
@@ -21,7 +22,7 @@ const USAGE = `Uso:
   officina doctor                   cosa manca al progetto perché i generatori funzionino
 
 Opzioni dei gate sui sorgenti: --diff, --base <ref>, --head <ref>, --strict, --format text|github
-bundle legge dist/client; smoke [url] e analytics [GTM-…] vanno in rete; lighthouse [--local]
+bundle e links leggono dist/client; smoke [url] e analytics [GTM-…] vanno in rete; lighthouse [--local]
 I valori del progetto (URL, budget, header, controlli propri) stanno in officina.config.ts
 `;
 // Ogni gruppo dice quale modulo carica e quali argomenti gli passa.

package/dist/checks/bundle.js

@@ -1,22 +1,24 @@
 #!/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';
-import { expectedRoutes, filesWithExtension, missingRouteFailures, readPageFiles, routeOf, } from '../lib/routes.js';
+import { disabledRouteFailures, expectedRoutes, filesWithExtension, missingRouteFailures, readPageFiles, routeOf, } from '../lib/routes.js';
 const DIST = 'dist/client';
 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)
@@ -89,8 +98,15 @@ function printSsrNote(expected, ssr) {
     for (const file of expected.ssr)
         console.log(`      - ${file}`);
 }
+function printDisabled({ disabled }) {
+    if (disabled.length === 0)
+        return;
+    console.log('\nSPENTE  da `routes.disabled`, nessuna pagina attesa:');
+    for (const { label, file } of disabled)
+        console.log(`      - ${label} (${file})`);
+}
 export async function main() {
-    const { bundle = {} } = await loadConfig(process.cwd());
+    const { bundle = {}, routes: { disabled } = {} } = await loadConfig(process.cwd());
     if (missingInput(ASSETS, 'è la build da misurare: prima `pnpm build`'))
         return 1;
     if (missingInput(PAGES, 'le rotte attese si derivano da lì'))
@@ -98,19 +114,19 @@ 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 expected = expectedRoutes(readPageFiles(PAGES), PAGES);
-    const measured = pages.map((page) => page.route);
-    const failures = ssr.comparesExpectedRoutes ? missingRouteFailures(expected, measured, DIST) : [];
+    const routes = [...html, ...ssr.pages];
+    const pages = measurePages(routes, readChunks(), bundle.budgets ?? []);
+    const expected = expectedRoutes(readPageFiles(PAGES), PAGES, disabled);
+    const emitted = { html: html.map((page) => page.route), ssr: ssr.pages.map((page) => page.route) };
+    const failures = ssr.comparesExpectedRoutes
+        ? [...missingRouteFailures(expected, emitted, DIST), ...disabledRouteFailures(expected, emitted)]
+        : [];
     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);
+    printDisabled(expected);
     if (failures.length > 0) {
         console.error(`\n✗ Budget di bundle:\n${failures.map((f) => `  - ${f}`).join('\n')}\n`);
         return 1;

package/dist/checks/doctor.js

@@ -11,7 +11,7 @@ import { configGaps } from '../lib/config-gaps.js';
 import { contractGaps } from '../lib/contract.js';
 import { dependabotGaps } from '../lib/dependabot.js';
 import { trackedAndUntracked } from '../lib/git.js';
-import { expectedRoutes, missingRepresentatives, readPageFiles } from '../lib/routes.js';
+import { expectedRoutes, missingRepresentatives, readPageFiles, unknownDisabled } from '../lib/routes.js';
 import { toolingGaps } from '../lib/tooling.js';
 import { packageVersion } from '../lib/versions.js';
 import { workflowGaps } from '../lib/workflows.js';
@@ -64,11 +64,22 @@ function generatorSections(root, setting) {
         { title: ANCHORS, off },
     ];
 }
-function orphanPatterns(root, config) {
+function routeGaps(root, config) {
+    if (config === undefined || config instanceof Error)
+        return { disabled: [] };
     const pages = join(root, PAGES);
-    if (!existsSync(pages) || config === undefined || config instanceof Error)
-        return [];
-    return missingRepresentatives(expectedRoutes(readPageFiles(pages), pages), config.routes?.representatives);
+    const { representatives, disabled: declared } = config.routes ?? {};
+    const expected = expectedRoutes(existsSync(pages) ? readPageFiles(pages) : [], pages, declared);
+    return {
+        missingRepresentatives: missingRepresentatives(expected, representatives),
+        unknownDisabled: unknownDisabled(expected, declared),
+        disabled: expected.disabled.map(({ label }) => label),
+    };
+}
+function configSection(root, config) {
+    const { disabled, ...gaps } = routeGaps(root, config);
+    const notes = disabled.length === 0 ? [] : [`spente da \`routes.disabled\`: ${disabled.join(', ')}`];
+    return { title: 'officina.config.ts', gaps: configGaps(config, gaps), notes };
 }
 export async function main() {
     const root = process.cwd();
@@ -88,7 +99,7 @@ export async function main() {
             title: 'workflow di GitHub e Dependabot',
             gaps: [...workflowGaps(files, version), ...dependabotGaps(files)],
         },
-        { title: 'officina.config.ts', gaps: configGaps(config, orphanPatterns(root, config)) },
+        configSection(root, config),
     ];
     console.log(`\nofficina doctor ${version} — cosa manca al progetto per prendere tutto da fuori\n`);
     const findings = [];
@@ -99,8 +110,10 @@ 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);
+        for (const note of section.notes ?? [])
+            console.log(`    · ${note}`);
         findings.push(...sectionFindings);
     }
     console.log(findings.length === 0

package/dist/checks/lighthouse.js

@@ -25,13 +25,16 @@ async function resolveConfig(url) {
     if (missingInput(PAGES_DIR, 'le rotte da visitare si derivano da lì'))
         return null;
     const rc = JSON.parse(readFileSync(RC_FILE, 'utf8'));
-    const routes = auditRoutes(expectedRoutes(readPageFiles(PAGES_DIR), PAGES_DIR), configured.representatives);
+    const expected = expectedRoutes(readPageFiles(PAGES_DIR), PAGES_DIR, configured.disabled);
+    const routes = auditRoutes(expected, configured.representatives);
     const env = url === undefined ? process.env : { ...process.env, LH_BASE_URL: url };
     const resolved = lighthouseConfig(rc, routes, env);
     const where = url === undefined ? '' : ` su ${url}`;
     console.log(`\nLighthouse CI — ${routes.length} rotta/e derivate da ${PAGES_DIR}${where}\n`);
     for (const page of resolved.ci.collect.url ?? [])
         console.log(`  ${page}`);
+    for (const { label } of expected.disabled)
+        console.log(`  ${label} — spenta da \`routes.disabled\`, non misurata`);
     console.log();
     return resolved;
 }

package/dist/checks/links.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export declare function main(): Promise<number>;

package/dist/checks/links.js

@@ -0,0 +1,69 @@
+#!/usr/bin/env node
+import { existsSync, readFileSync } from 'node:fs';
+import { join, relative, sep } from 'node:path';
+import process from 'node:process';
+import { readServerFiles } from '../lib/bundle-ssr.js';
+import { missingInput } from '../lib/cli.js';
+import { isRequired, loadConfig } from '../lib/config.js';
+import { brokenLines, htmlLinks, linkReport, servedPaths, siteOrigin } from '../lib/links.js';
+import { expectedRoutes, filesWithExtension, pageRouteOf, readPageFiles, routeOf, routePattern } from '../lib/routes.js';
+import { onDemandPatterns } from '../lib/vercel-build.js';
+const DIST = 'dist/client';
+const PAGES = 'src/pages';
+const SERVER_OUTPUT = 'dist/server';
+const FROM_SOURCE = 'valgono le pagine `.astro` con `prerender = false`';
+const servedPath = (file) => `/${relative(DIST, file).split(sep).join('/')}`;
+function onDemand() {
+    const files = readServerFiles();
+    const fromBuild = files.length === 0 ? null : onDemandPatterns(files);
+    if (fromBuild !== null)
+        return { patterns: fromBuild };
+    const ssr = existsSync(PAGES) ? expectedRoutes(readPageFiles(PAGES), PAGES).ssr : [];
+    const patterns = ssr.map((file) => routePattern(pageRouteOf(file, PAGES)));
+    if (files.length > 0)
+        return { patterns, note: `il manifest della build Vercel non si riconosce: ${FROM_SOURCE}` };
+    if (existsSync(SERVER_OUTPUT))
+        return { patterns, note: `build SSR senza l'adapter Vercel: ${FROM_SOURCE}` };
+    return { patterns };
+}
+function printReport(report, pages, note) {
+    console.log(`\ncheck:links — ${report.internal} link interni su ${pages} pagine di ${DIST}\n`);
+    const { external, scheme, anchor } = report.outside;
+    console.log(`Restano fuori: ${external} link esterni, ${scheme} con un altro schema (mailto:, tel:, …), ${anchor} ancore, di cui l'id non si verifica.`);
+    if (report.onDemand > 0) {
+        console.log(`${report.onDemand} link portano a una rotta resa a richiesta: che la pagina esista lo sa solo il server.`);
+    }
+    if (note !== undefined)
+        console.log(`\nNOTA  ${note}`);
+}
+export async function main() {
+    const config = await loadConfig(process.cwd());
+    if (!isRequired(config, 'links')) {
+        console.log('\ncheck:links — spento da `features.links: false`\n');
+        return 0;
+    }
+    if (missingInput(DIST, 'è la build di cui si controllano i link: prima `pnpm build`'))
+        return 1;
+    const files = filesWithExtension(DIST, '').map(servedPath);
+    const html = files.filter((file) => file.endsWith('.html'));
+    if (html.length === 0) {
+        console.error(`\n✗ ${DIST} non contiene nessun .html: senza pagine il controllo dei link non afferma niente.\n`);
+        return 1;
+    }
+    const pages = html.map((file) => ({
+        route: routeOf(file, ''),
+        hrefs: htmlLinks(readFileSync(join(DIST, file), 'utf8')),
+    }));
+    const { patterns, note } = onDemand();
+    const report = linkReport(pages, siteOrigin(config.siteUrl), servedPaths(files), patterns);
+    printReport(report, pages.length, note);
+    if (report.broken.length > 0) {
+        const lines = brokenLines(report).map((line) => `  - ${line}`);
+        console.error(`\n✗ Link interni rotti:\n${lines.join('\n')}\n`);
+        return 1;
+    }
+    console.log('\n✓ Ogni link interno porta a qualcosa che la build serve.\n');
+    return 0;
+}
+if (import.meta.main)
+    process.exit(await main());

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/checks/smoke.js

@@ -16,6 +16,7 @@ function printResults(results) {
             console.error(`✗ ${check} — ${detail}`);
     }
 }
+const disabledResults = ({ disabled }) => disabled.map(({ label }) => ({ check: `pagina ${label}`, status: 'skip', detail: 'spenta da `routes.disabled`' }));
 function printFailures(failures) {
     console.error(`\n✗ ${failures.length} controllo/i falliti:`);
     console.error(`${failures.map(({ check, detail }) => `  - ${check} — ${detail}`).join('\n')}\n`);
@@ -45,12 +46,12 @@ export async function main(args = []) {
     };
     if (missingInput(PAGES_DIR, 'le rotte da visitare si derivano da lì'))
         return 1;
-    const expected = expectedRoutes(readPageFiles(PAGES_DIR), PAGES_DIR);
+    const expected = expectedRoutes(readPageFiles(PAGES_DIR), PAGES_DIR, routes.disabled);
     const pages = smokeRoutes(expected, smoke.nonHtmlRoutes, routes.representatives);
     console.log(`\nSmoke di produzione — ${baseUrl}\n`);
     await waitForAlias(context, (ms) => new Promise((resolve) => setTimeout(resolve, ms)));
     const results = await runChecks(context, pages, smoke.checks);
-    printResults(results);
+    printResults([...results, ...disabledResults(expected)]);
     const failures = results.filter(({ status }) => status === 'fail');
     if (failures.length > 0) {
         printFailures(failures);

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

@@ -6,6 +6,7 @@ export const EXPECTED_SCRIPTS = {
     'check:roadmap': 'officina check roadmap',
     'check:placeholders': 'officina check placeholders',
     'perf:bundle': 'officina check bundle',
+    'check:links': 'officina check links',
     'smoke:prod': 'officina check smoke',
     'analytics:verify': 'officina check analytics',
     lhci: 'officina check lighthouse',
@@ -26,14 +27,17 @@ export const CI_STEPS = [
     'doctor',
 ];
 const MANIFEST = 'package.json';
+// TODO: dalla 0.12.0 `check:links` è un errore di doctor: toglilo da NEW_SCRIPTS.
+const NEW_SCRIPTS = new Set(['check:links']);
 export function scriptGaps({ scripts = {} }) {
     const gaps = [];
     for (const [name, expected] of Object.entries(EXPECTED_SCRIPTS)) {
         const actual = scripts[name];
+        const severity = NEW_SCRIPTS.has(name) ? { severity: 'warning' } : {};
         if (actual === undefined)
-            gaps.push({ path: MANIFEST, message: `script \`${name}\` assente: atteso \`${expected}\`` });
+            gaps.push({ path: MANIFEST, message: `script \`${name}\` assente: atteso \`${expected}\``, ...severity });
         else if (!actual.startsWith(expected))
-            gaps.push({ path: MANIFEST, message: `script \`${name}\` è \`${actual}\`: atteso \`${expected}\`` });
+            gaps.push({ path: MANIFEST, message: `script \`${name}\` è \`${actual}\`: atteso \`${expected}\``, ...severity });
     }
     const ci = scripts.ci ?? '';
     for (const step of CI_STEPS) {
@@ -125,13 +129,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;