@elia97/officina 0.12.0 → 0.14.0

package/README.md

@@ -46,7 +46,7 @@ I gate leggono dalla cartella corrente, che deve essere la radice del repository
 
 | 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 bundle` | il JavaScript e il CSS di `dist/client`, gzip, contro un budget per rotta; nel CSS, le media query in sintassi di intervallo | `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 secrets [--canaries]` | i file di `dist/client`: nessuno contiene il valore o il canary di una chiave server e secret di `env.schema` | — |
 | `check smoke [url]` | la produzione viva: pagine, pagine rese a richiesta, header di sicurezza, BotID, host canonico, barra finale | `src/pages`, più le rotte non HTML |
@@ -58,6 +58,16 @@ Gli script di una pagina statica si leggono dal suo HTML, anche sotto una `base`
 
 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.
 
+Il CSS costruito non deve contenere media query in sintassi di intervallo, come `@media (width>=40rem)`. Safari le legge solo dalla 16.4, e un Safari più vecchio ignora la regola intera: un sito scritto mobile-first si impagina come su un telefono. Le lascia Lightning CSS, che minifica il CSS della build, quando non sa per quali browser scrive: Astro 7 costruisce con `build.target: 'esnext'`, Vite 8 ne ricava `cssTarget`, e il minificatore non abbassa la sintassi e toglie anche i prefissi, come `-webkit-backdrop-filter`. Nessun browser recente mostra il difetto, e `astro dev` non minifica: si vede solo nel CSS costruito. `check bundle` legge i fogli di `dist/client/_astro` e i `<style>` dell'HTML delle pagine, dove Astro mette i fogli piccoli, e fallisce su ogni media query con un confronto nel preludio, `<`, `>` o `=`, i segni che soltanto la sintassi di intervallo usa; i commenti non contano, e il rapporto nomina il file e le query. Restano fuori le query di `@container`, i fogli fuori da `_astro`, i `<style>` delle pagine rese a richiesta, che nella build non hanno HTML, e i prefissi tolti, che il controllo non vede.
+
+Il controllo non si spegne, e fallisce dalla versione che lo porta, senza un giro di avvisi: un progetto senza `cssTarget` ha già il difetto, e la correzione è una riga in `astro.config.mjs`, con i browser che il progetto sostiene. `min-width` e `max-width` sono la stessa query in ogni browser, quindi abbassare non costa niente.
+
+```js
+export default defineConfig({
+  vite: { build: { cssTarget: ['chrome111', 'edge111', 'firefox114', 'safari15.4', 'ios15.4'] } },
+})
+```
+
 `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.
 
 `check secrets` legge le chiavi di `env.schema` con `context: 'server'` e `access: 'secret'`, dal sorgente di `astro.config.mjs` come `doctor`, e le cerca in ogni file di `dist/client`: un import sbagliato basta a portare un segreto nel browser. Per ogni chiave cerca il valore che ha nell'ambiente, anche nelle forme in cui Astro lo scrive nel markup e negli script, e il suo canary, `officina-<CHIAVE>-canary`, che `--canaries` stampa come righe `CHIAVE=valore` da mettere nell'ambiente della build. `actions/ci` lo fa dopo `pnpm run ci`, così i test che `ci` lancia non vedono i canary e la build sì. Il canary si dà solo ai campi `envField.string` senza validazioni (`max`, `min`, `length`, `url`, `includes`, `startsWith`, `endsWith`), perché Astro valida ogni variabile sul suo tipo e su quelle, e un canary che non le rispetta fermerebbe la build: una chiave così, in CI, resta da verificare. Una chiave che compare in un file è un fallimento che nomina la chiave e il file. Una chiave senza valore né canary nell'ambiente, o con un valore di meno di 8 caratteri, che cercato darebbe falsi positivi, non si verifica: il rapporto la dice con un avviso, invece di contarla fra le verificate. Uno schema senza chiavi segrete non ha niente da verificare, e una `dist/client` vuota è un fallimento.
@@ -66,7 +76,7 @@ Per Lighthouse un sito SSR si misura con `check lighthouse <url>`, sulla produzi
 
 Lo smoke legge gli header di sicurezza sulla pagina a cui arriva la radice. Se `/` è un redirect sulla stessa origine — il 302 di lingua che Astro emette con `i18n.routing.redirectToDefaultLocale`, per esempio — li cerca sulla destinazione, perché il redirect non porta la CSP delle pagine renderizzate, e il nome del controllo dice dove li ha letti: `header content-security-policy su /it`. Un redirect verso un'altra origine, o senza `location`, è un fallimento. Anche l'attesa che l'alias di produzione punti al deployment nuovo conta un 3xx come una risposta.
 
-Lo smoke visita anche le pagine rese a richiesta, quelle di `src/pages` con `export const prerender = false`. Ognuna risponde 200, oppure con un redirect sulla stessa origine, come una pagina protetta che rimanda all'accesso; un 200 è HTML e porta il meta `Content-Security-Policy` con la direttiva `script-src`, quello che il middleware dei template scrive nelle pagine rese a richiesta. Una pagina dinamica si visita col suo rappresentante di `routes.representatives`, altrimenti si salta dicendolo. Queste pagine non entrano nel controllo della barra finale né in Lighthouse. Nella 0.12.0 un'anomalia è un avviso, che lo smoke stampa con `·` senza fallire; dalla 0.13.0 sarà un fallimento. officina riconosce una pagina resa a richiesta dalla dichiarazione: con `output: 'server'`, una pagina senza `prerender = false` resta per tutti i gate una pagina prerenderizzata, e lo smoke la visita come le altre, senza cercarne la CSP.
+Lo smoke visita anche le pagine rese a richiesta, quelle di `src/pages` con `export const prerender = false`. Ognuna risponde 200, oppure con un redirect sulla stessa origine, come una pagina protetta che rimanda all'accesso; un 200 è HTML e porta il meta `Content-Security-Policy` con la direttiva `script-src`, quello che il middleware dei template scrive nelle pagine rese a richiesta. Una pagina dinamica si visita col suo rappresentante di `routes.representatives`, altrimenti si salta dicendolo. Queste pagine non entrano nel controllo della barra finale né in Lighthouse. Un'anomalia fa fallire lo smoke. officina riconosce una pagina resa a richiesta dalla dichiarazione: con `output: 'server'`, una pagina senza `prerender = false` resta per tutti i gate una pagina prerenderizzata, e lo smoke la visita come le altre, senza cercarne la CSP.
 
 Quando fallisce, lo smoke dice che la produzione è online e rotta, e consiglia di tornare indietro dalla dashboard di Vercel promuovendo l'ultimo deployment di produzione sano. Con `features.database` accesa aggiunge che lo schema non torna indietro: le migrazioni già applicate restano, e il deployment promosso regge solo se sono compatibili con il suo codice, la regola di «Migrazioni compatibili con la produzione» in § Action per i workflow.
 
@@ -142,7 +152,7 @@ I passi dei workflow stanno in `actions/` di questo repository, come composite a
 
 | Action | Passi | Cosa resta nel workflow del progetto |
 |---|---|---|
-| `actions/ci` | checkout, node, install, `astro sync`, con `migrate` le migrazioni del database della corsa, `pnpm run ci`, i canary di `check secrets`, build, `perf:bundle`, `check:links`, `check:secrets`; con `e2e: 'true'` anche Playwright | trigger, permessi, il job `ci`; con un database, il branch Neon della corsa, creato e cancellato intorno all'action, e lo script delle migrazioni e il suo indirizzo passati in `with:` |
+| `actions/ci` | checkout, node, install, `astro sync`, con `migrate` le migrazioni del database della corsa, `pnpm run ci`, i canary di `check secrets`, build, `perf:bundle`, `check:links`, `check:secrets`; con `e2e: 'true'` anche Playwright; se la PR o il push toccano solo documenti, dopo l'install soltanto `check:language`, `check:routes`, `check:roadmap` e `doctor` | trigger, permessi, il job `ci`; con un database, il branch Neon della corsa, creato e cancellato intorno all'action, e lo script delle migrazioni e il suo indirizzo passati in `with:` |
 | `actions/review` | `astro sync`, poi `fallow review` sul diff contro il merge-base | il job informativo |
 | `actions/deploy` | risoluzione del tag, stessa versione di officina, gate, `vercel pull`, con `migrate` le migrazioni, `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; con un database, lo script delle migrazioni e il segreto `PRODUCTION_DATABASE_URL` passati in `with:` |
 | `actions/lighthouse` | build equivalente alla produzione e `pnpm run lhci` | trigger, etichetta, `continue-on-error` |
@@ -173,6 +183,8 @@ jobs:
 
 I tre segreti sono input obbligatori e l'action li mette nell'`env` dei soli tre passi che chiamano `vercel`, come `database-url` in quello delle migrazioni. 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 o il database di produzione.
 
+**Il percorso veloce dei documenti.** Dopo l'install `actions/ci` lancia `officina scope`, che confronta l'`HEAD` del checkout con la base dell'evento: per una PR la sua base, mentre l'`HEAD` è il merge commit di GitHub; per un push il commit `before`. Se ogni file cambiato è un documento, cioè un `.md` alla radice, sotto `docs/`, sotto `.github/` o sotto `.claude/`, l'action lancia soltanto `check:language`, `check:routes`, `check:roadmap` e `doctor`, e salta il resto: `astro sync`, le migrazioni, `pnpm run ci`, la build, `perf:bundle`, `check:links`, `check:secrets` e gli e2e. `doctor` resta perché alcuni Markdown, come gli agenti in `.claude/agents/` o `docs/DECISIONS.md`, sono residui che vieta. Un'immagine o uno snippet in `docs/`, e `src/content/` anche quando è Markdown, fanno il percorso completo. Il job parte comunque, perché `ci` è un check obbligatorio e un `paths-ignore` sulla PR lo lascerebbe appeso. Nel dubbio il percorso è completo: un evento senza base, come il primo push di un branch, un diff che non riesce, nessun file cambiato, un file che non è un documento, che il log del passo nomina, o `officina scope` che fallisce, e allora il passo lo dice con un avviso. Il confronto è fra due alberi e scarica la sola base, senza la storia: il percorso veloce vuol dire che, fuori dai documenti, l'albero da provare è identico a quello della base, e una base andata avanti nel frattempo aggiunge file al diff e riporta il percorso completo. Uno spostamento conta come cancellazione più aggiunta, quindi un file di codice spostato in `docs/` non passa per documento. Su un push il percorso veloce non riprova il codice di `before`, come un `paths-ignore`.
+
 **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.
 
 **Il database di test.** Ogni corsa della CI migra un database suo: un branch Neon che il `ci.yml` del progetto crea prima di `actions/ci`, figlio di un branch vuoto, e cancella alla fine. Così due corse in parallelo, come la CI di una PR e quella di `main`, non vedono l'una le migrazioni dell'altra. Il genitore resta vuoto perché il migratore di drizzle-orm 0.45 applica una migrazione solo se è più recente dell'ultima applicata: ogni corsa le applica tutte, da zero, e nessuna si salta.
@@ -207,7 +219,7 @@ I tre segreti sono input obbligatori e l'action li mette nell'`env` dei soli tre
           api_key: ${{ secrets.NEON_API_KEY }}
 ```
 
-Il genitore, `test` nell'esempio, è il branch di test di prima. Si svuota una volta con `DROP SCHEMA public CASCADE; CREATE SCHEMA public; DROP SCHEMA IF EXISTS drizzle CASCADE;`, e da lì nessuno lo migra. Il primo passo legge la chiave dal proprio `env`, non da quello del job, dove la vedrebbero anche le dipendenze. `expires_at` cancella il branch anche quando il passo finale non arriva. La chiave dell'API di Neon crea e cancella i branch del progetto, quindi va limitata al progetto dove Neon lo permette, e non va data a Dependabot, che la passerebbe al codice di ogni aggiornamento. `doctor` avvisa quando `ci.yml` passa ancora un branch condiviso, `TEST_DATABASE_URL`.
+Il genitore, `test` nell'esempio, è il branch di test di prima. Si svuota una volta con `DROP SCHEMA public CASCADE; CREATE SCHEMA public; DROP SCHEMA IF EXISTS drizzle CASCADE;`, e da lì nessuno lo migra. Il primo passo legge la chiave dal proprio `env`, non da quello del job, dove la vedrebbero anche le dipendenze. `expires_at` cancella il branch anche quando il passo finale non arriva. La chiave dell'API di Neon crea e cancella i branch del progetto, quindi va limitata al progetto dove Neon lo permette, e non va data a Dependabot, che la passerebbe al codice di ogni aggiornamento. `doctor` fallisce quando `ci.yml` passa ancora un branch condiviso, `TEST_DATABASE_URL`.
 
 Prima di `pnpm run ci` l'action lancia `officina migrate --script <migrate>`, che legge `database.migrationUrlKey` da `officina.config.ts` e dà l'indirizzo allo script sotto quella chiave, e solo sotto quella. `pnpm run ci` lo riceve come `TEST_DATABASE_URL`, per i test di integrazione. La build e `check:secrets` lo ricevono come `DATABASE_URL`, al posto del canary: una pagina prerenderizzata dal database lo legge davvero, e `check secrets` cerca il valore che la build ha ricevuto. Gli altri passi non lo vedono, e senza `database-url` i comandi ricevono l'ambiente del job com'è. Le PR di Dependabot e quelle da un fork non ricevono `NEON_API_KEY`: il branch non nasce, `database-url` arriva vuoto, e con `migrate` l'action non migra, lo dice con un `::notice::` e prosegue. I test di integrazione si saltano da soli, e la build riceve il canary, quindi una pagina prerenderizzata dal database non ha un database da leggere, e la build si ferma.
 
@@ -220,7 +232,7 @@ Prima di `pnpm run ci` l'action lancia `officina migrate --script <migrate>`, ch
           database-url: ${{ secrets.PRODUCTION_DATABASE_URL }}
 ```
 
-Dopo `vercel pull` e `check:placeholders --env`, subito prima di `vercel build`, l'action lancia `officina migrate --production --script <migrate>`, che dà l'indirizzo allo script sotto `database.migrationUrlKey`, e solo sotto quella. `PRODUCTION_DATABASE_URL` è un segreto dell'environment `production` del repository, che il job di deploy dichiara: lo leggono solo i job di quell'environment, e solo dai ref che le sue regole ammettono, da restringere a `main` e ai tag di release, perché senza regole lo legge un job su qualunque branch. È l'indirizzo diretto al database, senza pooler, come `DATABASE_URL_UNPOOLED` su Neon. Senza `database-url` il passo delle migrazioni si ferma, e il deploy con lui. `doctor` avvisa anche quando il deploy riceve `TEST_DATABASE_URL`, o la CI `PRODUCTION_DATABASE_URL`: le migrazioni andrebbero sul database sbagliato, uscendo 0. Il runner maschera il segreto intero, ma non la password da sola: il comando registra con `::add-mask::` l'indirizzo e la sua password, com'è e decodificata, su stdout e su stderr, e lancia lo script quando le maschere sono scritte.
+Dopo `vercel pull` e `check:placeholders --env`, subito prima di `vercel build`, l'action lancia `officina migrate --production --script <migrate>`, che dà l'indirizzo allo script sotto `database.migrationUrlKey`, e solo sotto quella. `PRODUCTION_DATABASE_URL` è un segreto dell'environment `production` del repository, che il job di deploy dichiara: lo leggono solo i job di quell'environment, e solo dai ref che le sue regole ammettono, da restringere a `main` e ai tag di release, perché senza regole lo legge un job su qualunque branch. È l'indirizzo diretto al database, senza pooler, come `DATABASE_URL_UNPOOLED` su Neon. Senza `database-url` il passo delle migrazioni si ferma, e il deploy con lui. `doctor` fallisce anche quando il deploy riceve `TEST_DATABASE_URL`, o la CI `PRODUCTION_DATABASE_URL`: le migrazioni andrebbero sul database sbagliato, uscendo 0. Il runner maschera il segreto intero, ma non la password da sola: il comando registra con `::add-mask::` l'indirizzo e la sua password, com'è e decodificata, su stdout e su stderr, e lancia lo script quando le maschere sono scritte.
 
 **Il segreto delle migrazioni.** Su Vercel la chiave delle migrazioni non serve, e se l'applicazione la usa a runtime può restare Secret. Una risorsa del Marketplace impostata su «Production only», che protegge le sue credenziali come Secret, non ferma più le migrazioni. Rende però Secret anche `DATABASE_URL`, e una build che legge il database la riceve come `[SENSITIVE]` e si ferma, a migrazioni già applicate. Il prezzo è un secondo posto da tenere allineato: quando cambia l'indirizzo, che sia la password, l'host o il database, il segreto va aggiornato anche su GitHub. Con una password vecchia il deploy si ferma al passo delle migrazioni. Se invece il database vecchio risponde ancora, le migrazioni vanno lì, e il deploy non se ne accorge.
 

package/dist/bin.js

@@ -22,6 +22,7 @@ const USAGE = `Uso:
   officina gen icons                le icone del manifest da public/favicon.svg
   officina doctor                   cosa manca al progetto perché i generatori funzionino
   officina migrate --script <nome>  le migrazioni sotto database.migrationUrlKey: da TEST_DATABASE_URL, o con --production da PRODUCTION_DATABASE_URL
+  officina scope                    in actions/ci, docs-only=true se la PR o il push toccano solo documenti
 
 Opzioni dei gate sui sorgenti: --diff, --base <ref>, --head <ref>, --strict, --format text|github
 bundle, links e secrets leggono dist/client; smoke [url] e analytics [GTM-…] vanno in rete; lighthouse [--local]
@@ -35,6 +36,7 @@ const GROUPS = {
         : { load: () => import('./gen/run.js'), args },
     doctor: (args) => ({ load: () => import('./checks/doctor.js'), args }),
     migrate: (args) => ({ load: () => import('./checks/migrate.js'), args }),
+    scope: (args) => ({ load: () => import('./checks/scope.js'), args }),
 };
 export async function run(argv) {
     const [group = '', ...rest] = argv;

package/dist/checks/bundle.js

@@ -5,7 +5,7 @@ import { join, relative } from 'node:path';
 import process from 'node:process';
 import { gzipSync } from 'node:zlib';
 import { budgetFor, CSS_BUDGET_GZIP, deferredClosure, htmlEntries, htmlStylesheets, parseEdges, staticClosure, } from '../lib/bundle-budget.js';
-import { measureCss, routeCount } from '../lib/bundle-css.js';
+import { inlineStyles, measureCss, rangeQueryFailures, 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';
@@ -89,6 +89,17 @@ function checkCss(pages, cssMaxGzip, width) {
     printCss(css, cssMaxGzip, width);
     return css.failures;
 }
+function checkRangeSyntax() {
+    const sheets = filesWithExtension(ASSETS, '.css').map((file) => ({ file, css: readFileSync(file, 'utf8') }));
+    const pages = filesWithExtension(DIST, '.html').map((file) => ({
+        file,
+        css: inlineStyles(readFileSync(file, 'utf8')),
+    }));
+    const failures = rangeQueryFailures([...sheets, ...pages]);
+    if (failures.length === 0)
+        console.log('\nMedia query in sintassi di intervallo: nessuna.');
+    return failures;
+}
 function printSsrNote(expected, ssr) {
     for (const note of ssr.notes)
         console.log(`\nNOTA  ${note}`);
@@ -124,7 +135,7 @@ export async function main() {
     failures.push(...ssr.failures, ...unknownChunkFailures(pages), ...overBudgetFailures(pages));
     const width = Math.max('ROTTA'.length, ...pages.map((p) => p.route.length));
     printPages(pages, width);
-    failures.push(...checkCss(routes, cssMaxGzip, width));
+    failures.push(...checkCss(routes, cssMaxGzip, width), ...checkRangeSyntax());
     printSsrNote(expected, ssr);
     printDisabled(expected);
     if (failures.length > 0) {

package/dist/checks/scope.d.ts

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

package/dist/checks/scope.js

@@ -0,0 +1,13 @@
+#!/usr/bin/env node
+// actions/ci/action.yml appende lo stdout a $GITHUB_OUTPUT: lì va solo `docs-only=…`, la ragione va su stderr.
+import process from 'node:process';
+import { ciScope } from '../lib/ci-scope.js';
+import { changedSince, eventBase } from '../lib/git.js';
+export function main() {
+    const { docsOnly, reason } = ciScope(eventBase(), changedSince);
+    console.error(reason);
+    console.log(`docs-only=${docsOnly}`);
+    return 0;
+}
+if (import.meta.main)
+    process.exit(main());

package/dist/checks/smoke.js

@@ -69,10 +69,6 @@ export async function main(args = []) {
         printFailures(failures, isOn(config, readManifest({ read: projectFile }), 'database'));
         return 1;
     }
-    const warnings = results.filter(({ status }) => status === 'warn').length;
-    // TODO: dalla 0.13.0 le anomalie a richiesta sono `fail` (smoke-on-demand.ts): togli il log degli avvisi qui sotto.
-    if (warnings > 0)
-        console.log(`\n· ${warnings} avviso/i: dalla 0.13.0 fanno fallire lo smoke.`);
     console.log(`\n✓ Tutti i controlli passati su ${baseUrl}.\n`);
     return 0;
 }

package/dist/lib/alignment.js

@@ -28,17 +28,14 @@ export const CI_STEPS = [
     'doctor',
 ];
 const MANIFEST = 'package.json';
-// TODO: dalla 0.13.0 `check:secrets` è un errore di doctor: toglilo da NEW_SCRIPTS.
-const NEW_SCRIPTS = new Set(['check:secrets']);
 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}\``, ...severity });
+            gaps.push({ path: MANIFEST, message: `script \`${name}\` assente: atteso \`${expected}\`` });
         else if (!actual.startsWith(expected))
-            gaps.push({ path: MANIFEST, message: `script \`${name}\` è \`${actual}\`: atteso \`${expected}\``, ...severity });
+            gaps.push({ path: MANIFEST, message: `script \`${name}\` è \`${actual}\`: atteso \`${expected}\`` });
     }
     const ci = scripts.ci ?? '';
     for (const step of CI_STEPS) {

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

@@ -12,5 +12,12 @@ export type CssMeasure = {
     groups: CssGroup[];
     failures: string[];
 };
+export type CssSource = {
+    file: string;
+    css: string;
+};
 export declare const routeCount: (count: number) => string;
 export declare function measureCss(routes: readonly RouteStylesheets[], sheets: readonly Stylesheet[], maxGzip: number, assets: string): CssMeasure;
+export declare function rangeMediaQueries(css: string): string[];
+export declare const inlineStyles: (html: string) => string;
+export declare function rangeQueryFailures(sources: readonly CssSource[]): string[];

package/dist/lib/bundle-css.js

@@ -1,3 +1,7 @@
+const CSS_COMMENT = /\/\*[\s\S]*?\*\//g;
+const MEDIA_PRELUDE = /(?<=@media\b)[^{;]*/gi;
+const RANGE_COMPARISON = /[<>=]/;
+const STYLE_ELEMENT = /<style\b[^>]*>([\s\S]*?)<\/style>/gi;
 const kb = (bytes) => `${(bytes / 1024).toFixed(1)} KB`;
 export const routeCount = (count) => (count === 1 ? '1 rotta' : `${count} rotte`);
 function overBudget({ stylesheets, gzip, routes }, maxGzip) {
@@ -31,3 +35,18 @@ export function measureCss(routes, sheets, maxGzip, assets) {
     failures.push(...measured.filter((group) => group.gzip > maxGzip).map((group) => overBudget(group, maxGzip)));
     return { groups: measured, failures };
 }
+export function rangeMediaQueries(css) {
+    const preludes = [...css.replace(CSS_COMMENT, ' ').matchAll(MEDIA_PRELUDE)].map(([prelude]) => prelude.trim());
+    return [...new Set(preludes.filter((prelude) => RANGE_COMPARISON.test(prelude)))];
+}
+export const inlineStyles = (html) => [...html.matchAll(STYLE_ELEMENT)].map(([, css]) => css).join('\n');
+export function rangeQueryFailures(sources) {
+    return sources.flatMap(({ file, css }) => {
+        const queries = rangeMediaQueries(css);
+        if (queries.length === 0)
+            return [];
+        return [
+            `${file}: media query in sintassi di intervallo, che Safari legge solo dalla 16.4 — ${queries.join(', ')}; si abbassano con \`vite.build.cssTarget\``,
+        ];
+    });
+}

package/dist/lib/ci-scope.d.ts

@@ -0,0 +1,6 @@
+export type CiScope = {
+    docsOnly: boolean;
+    reason: string;
+};
+export declare const isDocument: (path: string) => boolean;
+export declare function ciScope(base: string | undefined, changed: (base: string) => string[]): CiScope;

package/dist/lib/ci-scope.js

@@ -0,0 +1,20 @@
+const DOCUMENTS = [/^[^/]+\.md$/, /^(?:docs|\.github|\.claude)\/.+\.md$/];
+export const isDocument = (path) => DOCUMENTS.some((pattern) => pattern.test(path));
+const fullRun = (reason) => ({ docsOnly: false, reason: `percorso completo: ${reason}` });
+export function ciScope(base, changed) {
+    if (base === undefined)
+        return fullRun("l'evento non ha una base con cui confrontarsi");
+    let paths;
+    try {
+        paths = changed(base);
+    }
+    catch (error) {
+        return fullRun(`il diff da ${base} non è riuscito: ${error.message}`);
+    }
+    if (paths.length === 0)
+        return fullRun(`nessun file cambiato da ${base}`);
+    const code = paths.find((path) => !isDocument(path));
+    if (code !== undefined)
+        return fullRun(`${code} non è un documento`);
+    return { docsOnly: true, reason: `percorso veloce: solo documenti (${paths.length} file)` };
+}

package/dist/lib/database-auth.js

@@ -72,10 +72,8 @@ function secretGaps(source, keys) {
         return message === undefined ? [] : [{ path: ASTRO_CONFIG, message }];
     });
 }
-// TODO: dalla 0.13.0 i requisiti del database e dell'autenticazione sono errori di doctor: togli `severity`.
-const asWarning = (gap) => ({ ...gap, severity: 'warning' });
 export function databaseAuthGaps(files, manifest, on) {
     const database = on.includes('database') ? databaseGaps(files, manifest) : [];
     const secrets = secretGaps(files.read(ASTRO_CONFIG), on.map((name) => DEPENDENCY_FEATURES[name].secret));
-    return [...database, ...secrets].map(asWarning);
+    return [...database, ...secrets];
 }

package/dist/lib/git.d.ts

@@ -1,4 +1,6 @@
 export declare const trackedAndUntracked: () => string[];
+export declare const eventBase: () => string | undefined;
+export declare function changedSince(base: string): string[];
 export type DiffScope = {
     base?: string | undefined;
     head?: string | undefined;

package/dist/lib/git.js

@@ -19,14 +19,14 @@ export const trackedAndUntracked = () => [
     ...gitPaths('ls-files', []),
     ...gitPaths('ls-files', ['--others', '--exclude-standard']),
 ];
-function ensureCommit(ref) {
+function ensureCommit(ref, { shallow = false } = {}) {
     const exists = spawnSync('git', ['cat-file', '-e', `${ref}^{commit}`], {
         stdio: 'ignore',
     });
     if (exists.status === 0)
         return;
     // Checkout shallow in CI: la base della PR spesso non c'è in locale.
-    git(['fetch', '--no-tags', 'origin', ref]);
+    git(['fetch', '--no-tags', ...(shallow ? ['--depth=1'] : []), 'origin', ref]);
 }
 function defaultBase() {
     const originHead = git(['symbolic-ref', '--quiet', '--short', 'refs/remotes/origin/HEAD'], {
@@ -42,14 +42,29 @@ function defaultBase() {
     }
     throw new Error('nessuna base trovata: passa --base <ref>');
 }
-// Sulle PR GitHub il diff va fatto tra gli SHA dell'evento, non tra branch locali.
-function pullRequestShas() {
+const eventPayload = (name) => {
     const { GITHUB_EVENT_NAME, GITHUB_EVENT_PATH } = process.env;
-    if (GITHUB_EVENT_NAME !== 'pull_request' || !GITHUB_EVENT_PATH || !existsSync(GITHUB_EVENT_PATH))
+    if (GITHUB_EVENT_NAME !== name || !GITHUB_EVENT_PATH || !existsSync(GITHUB_EVENT_PATH))
         return undefined;
-    const { pull_request: pr } = JSON.parse(readFileSync(GITHUB_EVENT_PATH, 'utf8'));
+    return JSON.parse(readFileSync(GITHUB_EVENT_PATH, 'utf8'));
+};
+// Sulle PR GitHub il diff va fatto tra gli SHA dell'evento, non tra branch locali.
+function pullRequestShas() {
+    const pr = eventPayload('pull_request')?.pull_request;
     return pr?.base?.sha && pr?.head?.sha ? { base: pr.base.sha, head: pr.head.sha } : undefined;
 }
+// Il primo push di un branch porta come `before` uno SHA tutto zeri, che non è un commit.
+function pushBefore() {
+    const before = eventPayload('push')?.before;
+    return typeof before === 'string' && !/^0+$/.test(before) ? before : undefined;
+}
+export const eventBase = () => pullRequestShas()?.base ?? pushBefore();
+export function changedSince(base) {
+    ensureCommit(base, { shallow: true });
+    // Con il rilevamento delle rinomine, attivo di default, `--name-only` elenca solo il percorso nuovo;
+    // `submodule.<nome>.ignore = all` in .gitmodules toglie dal diff anche un sottomodulo aggiornato.
+    return gitPaths('diff', ['--name-only', '--no-renames', '--ignore-submodules=none', base, 'HEAD']);
+}
 export function changedFiles({ base, head }) {
     const pr = base ? undefined : pullRequestShas();
     const from = base ?? pr?.base ?? defaultBase();

package/dist/lib/smoke-on-demand.js

@@ -18,16 +18,15 @@ const attributeValue = (tag, attribute) => {
 };
 const hasCspMeta = (html) => [...html.matchAll(META)].some(([tag]) => attributeValue(tag, HTTP_EQUIV).toLowerCase() === 'content-security-policy' &&
     SCRIPT_SRC.test(attributeValue(tag, CONTENT)));
-// TODO: dalla 0.13.0 un'anomalia di una pagina resa a richiesta fa fallire lo smoke: qui `warn` diventa `fail`.
-const warn = (check, detail) => ({ check, status: 'warn', detail });
+const fail = (check, detail) => ({ check, status: 'fail', detail });
 function redirect(check, response, url) {
     const location = response.headers.get('location');
     if (location === null)
-        return warn(check, `risponde ${response.status} senza location`);
+        return fail(check, `risponde ${response.status} senza location`);
     const target = new URL(location, url);
     const { origin } = new URL(url);
     if (target.origin !== origin)
-        return warn(check, `rimanda a ${target.href}, fuori da ${origin}`);
+        return fail(check, `rimanda a ${target.href}, fuori da ${origin}`);
     return { check, status: 'pass' };
 }
 async function visit({ get, baseUrl }, path) {
@@ -38,17 +37,17 @@ async function visit({ get, baseUrl }, path) {
         if (response.status >= 300 && response.status < 400)
             return redirect(check, response, url);
         if (response.status !== 200) {
-            return warn(check, `atteso 200 o un redirect sulla stessa origine, ricevuto ${response.status}`);
+            return fail(check, `atteso 200 o un redirect sulla stessa origine, ricevuto ${response.status}`);
         }
         const contentType = response.headers.get('content-type') ?? '';
         if (!contentType.includes('text/html'))
-            return warn(check, `atteso un content-type text/html, ricevuto "${contentType}"`);
+            return fail(check, `atteso un content-type text/html, ricevuto "${contentType}"`);
         if (!hasCspMeta((await response.text?.()) ?? ''))
-            return warn(check, 'manca il meta Content-Security-Policy con script-src');
+            return fail(check, 'manca il meta Content-Security-Policy con script-src');
         return { check, status: 'pass' };
     }
     catch (error) {
-        return warn(check, error instanceof Error ? error.message : String(error));
+        return fail(check, error instanceof Error ? error.message : String(error));
     }
 }
 export async function checkOnDemandPages(context) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@elia97/officina",
-  "version": "0.12.0",
+  "version": "0.14.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",
@@ -55,7 +55,7 @@
     "test:pack": "bash scripts/pack-test.sh"
   },
   "devDependencies": {
-    "@biomejs/biome": "2.5.14",
+    "@biomejs/biome": "2.5.15",
     "@types/node": "^26.5.1",
     "@vitest/coverage-v8": "^4.1.11",
     "fallow": "^3.26.0",