@elia97/officina 0.7.1 → 0.9.0

package/README.md

@@ -40,12 +40,18 @@ 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` |
+| `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 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 [--local]` | Lighthouse CI sul `.lighthouserc.json` del progetto; `--local` fa build, server e Chrome da sé | `src/pages` |
+| `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.
+
+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`.
+
+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.
+
 Il motore è uguale per tutti; ciò che cambia da un progetto all'altro sta in un file solo, `officina.config.ts` nella radice:
 
 ```ts
@@ -62,7 +68,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 },
+  features: { analytics: 'required', roadmap: false, botId: 'required' },
   routes: { representatives: { '/blog/[slug]': '/blog/ciao-mondo' } },
 })
 ```
@@ -75,14 +81,16 @@ La radice del pacchetto esporta `defineConfig` e i tipi; i pezzi del motore stan
 | `@elia97/officina/bundle` | `CSS_BUDGET_GZIP` |
 | `@elia97/officina/icons` | `ICON_SPECS` |
 
-`siteUrl` serve a `check smoke` e `icons.background` a `gen icons`. I budget del progetto vengono prima del default di 20 KB, nell'ordine in cui sono scritti; `smoke.checks` sostituisce la lista del pacchetto, quindi chi non ha BotID la ricompone senza `checkBotIdChallenge`; `smoke.securityHeaders` e `smoke.nonHtmlRoutes` sostituiscono `SECURITY_HEADERS` e `NON_HTML_ROUTES`.
+`siteUrl` serve a `check smoke` e `icons.background` a `gen icons`. I budget del progetto vengono prima del default di 20 KB, nell'ordine in cui sono scritti; `smoke.checks` sostituisce la lista del pacchetto, quindi chi ne toglie un controllo la ricompone da `DEFAULT_CHECKS`; `smoke.securityHeaders` e `smoke.nonHtmlRoutes` sostituiscono `SECURITY_HEADERS` e `NON_HTML_ROUTES`.
 
-`features` dice quali controlli il progetto pretende: `'required'` fa fallire il gate quando ciò che deve guardare non c'è, `false` lo spegne dicendolo. 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.
+`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.
 
-`features.generators` ha un valore in più delle altre due, 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.
+`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.
 
+Nel deploy `check placeholders` gira due volte sui file di Vercel. Con `--env .vercel/.env.production.local`, dopo `vercel pull`, distingue una chiave che su Vercel non esiste, una vuota e una che porta un segnaposto del template, tutte e tre errori, da una variabile **Sensitive**: `vercel pull` non ne scarica il valore e scrive al suo posto `[SENSITIVE]`, quindi il check lo dice con un avviso, che non ferma il deploy, invece di darla per verificata. Il segnaposto però diventa un problema se la build legge la variabile, per esempio una variabile di `astro:env` con `access: 'public'`, che Astro incorpora nel codice: con `--output .vercel/output`, dopo `vercel build`, il check cerca `[SENSITIVE]` nei file della build e ferma il deploy nominandoli. Una variabile che la build legge va tenuta Encrypted su Vercel, o letta a runtime.
+
 Il file lo carica Node, che fuori da `node_modules` toglie i tipi da sé: niente `enum`, niente alias `@/`. Due file `officina.config.*` insieme sono un errore, come un file senza default export; il resto lo valida `loadConfig` a runtime, nominando il percorso della voce sbagliata — `bundle.cssMaxGzip: atteso un numero, ricevuto una stringa` — e una voce sconosciuta, perché `sitUrl` al posto di `siteUrl` non deve passare in silenzio.
 
 `sharp` è una dipendenza facoltativa del progetto, non del pacchetto: serve solo a `gen icons`, che senza lo dice ed esce 1. Un ingresso che manca — il favicon, `.lighthouserc.json`, `src/pages`, la build in `dist/client` — è sempre una riga che nomina il file e dice a cosa serve, mai uno stack trace. `@biomejs/biome` invece è una peer dependency con l'intervallo che il preset regge, e `doctor` confronta la versione del progetto con quello.
@@ -110,9 +118,9 @@ 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, `pnpm run ci`, build, `perf:bundle`; con `e2e: 'true'` anche Playwright | trigger, permessi, il job `ci` |
-| `actions/review` | `fallow review` sul diff contro il merge-base | il job informativo |
-| `actions/deploy` | risoluzione del tag, gate, `vercel pull`, `build`, `deploy`, smoke; espone `url` | trigger, `environment`, i tre segreti Vercel passati in `with:`, il job che controlla se i segreti ci sono |
+| `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/lighthouse` | build equivalente alla produzione e `pnpm run lhci` | trigger, etichetta, `continue-on-error` |
 
 ```yaml
@@ -132,6 +140,8 @@ jobs:
           vercel-project-id: ${{ secrets.VERCEL_PROJECT_ID }}
 ```
 
+`astro sync` genera i tipi di `.astro/`, che fallow pretende e un checkout pulito non ha; se fallisce il passo lo segnala con un avviso e il job prosegue.
+
 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.
 
 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`.

package/dist/checks/bundle.js

@@ -5,6 +5,7 @@ import { join } 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 { 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';
@@ -25,12 +26,17 @@ function readChunks() {
     }
     return chunks;
 }
-function measurePages(chunks, budgets) {
+function htmlPages() {
+    return filesWithExtension(DIST, '.html').map((htmlPath) => ({
+        route: routeOf(htmlPath, DIST),
+        entries: htmlEntries(readFileSync(htmlPath, 'utf8')),
+    }));
+}
+function measurePages(pages, chunks, budgets) {
     const total = (names) => [...names].reduce((sum, name) => sum + (chunks.get(name)?.gzip ?? 0), 0);
-    return filesWithExtension(DIST, '.html')
-        .map((htmlPath) => {
-        const route = routeOf(htmlPath, DIST);
-        const { reached, unknown } = staticClosure(htmlEntries(readFileSync(htmlPath, 'utf8')), chunks);
+    return pages
+        .map(({ route, entries }) => {
+        const { reached, unknown } = staticClosure(entries, chunks);
         return {
             route,
             gzip: total(reached),
@@ -74,8 +80,10 @@ function printStylesheets(stylesheets, cssMaxGzip, failed, width) {
         console.log(`  ${sheet.file.padEnd(width - 2)}   ${gz(sheet.gzip).padStart(9)}   ${gz(cssMaxGzip).padStart(9)}${mark}`);
     }
 }
-function printSsrNote(expected) {
-    if (expected.ssr.length === 0)
+function printSsrNote(expected, ssr) {
+    for (const note of ssr.notes)
+        console.log(`\nNOTA  ${note}`);
+    if (ssr.measured || expected.ssr.length === 0)
         return;
     console.log(`\nNOTA  ${expected.ssr.length} pagina/e con \`export const prerender = false\`, fuori da questo budget:`);
     for (const file of expected.ssr)
@@ -88,10 +96,13 @@ export async function main() {
     if (missingInput(PAGES, 'le rotte attese si derivano da lì'))
         return 1;
     const cssMaxGzip = bundle.cssMaxGzip ?? CSS_BUDGET_GZIP;
-    const pages = measurePages(readChunks(), bundle.budgets ?? []);
+    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 failures = missingRouteFailures(expected, pages.map((page) => page.route), DIST);
-    failures.push(...unknownChunkFailures(pages), ...overBudgetFailures(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();
@@ -99,12 +110,14 @@ export async function main() {
     if (cssFailure)
         failures.push(cssFailure);
     printStylesheets(stylesheets, cssMaxGzip, cssFailure !== null, width);
-    printSsrNote(expected);
+    printSsrNote(expected, ssr);
     if (failures.length > 0) {
         console.error(`\n✗ Budget di bundle:\n${failures.map((f) => `  - ${f}`).join('\n')}\n`);
         return 1;
     }
-    console.log('\n✓ Budget di bundle rispettato su ogni rotta attesa.\n');
+    console.log(ssr.comparesExpectedRoutes
+        ? '\n✓ Budget di bundle rispettato su ogni rotta attesa.\n'
+        : '\n✓ Budget del CSS rispettato; le rotte non sono state misurate.\n');
     return 0;
 }
 if (import.meta.main)

package/dist/checks/lighthouse.js

@@ -7,7 +7,7 @@ import process from 'node:process';
 import { fileURLToPath } from 'node:url';
 import { missingInput } from '../lib/cli.js';
 import { loadConfig } from '../lib/config.js';
-import { lighthouseConfig } from '../lib/lighthouse.js';
+import { baseUrlArg, lighthouseConfig } from '../lib/lighthouse.js';
 import { auditRoutes, expectedRoutes, readPageFiles } from '../lib/routes.js';
 const PAGES_DIR = 'src/pages';
 const RC_FILE = '.lighthouserc.json';
@@ -18,21 +18,24 @@ function runLocal() {
     const env = { ...process.env, OFFICINA_BIN: process.argv[1] };
     return spawnSync('bash', [script], { stdio: 'inherit', env }).status ?? 1;
 }
-export async function main(args = []) {
-    if (args.includes('--local'))
-        return runLocal();
+async function resolveConfig(url) {
     const { routes: configured = {} } = await loadConfig(process.cwd());
     if (missingInput(RC_FILE, 'è la configurazione di Lighthouse CI'))
-        return 1;
+        return null;
     if (missingInput(PAGES_DIR, 'le rotte da visitare si derivano da lì'))
-        return 1;
+        return null;
     const rc = JSON.parse(readFileSync(RC_FILE, 'utf8'));
     const routes = auditRoutes(expectedRoutes(readPageFiles(PAGES_DIR), PAGES_DIR), configured.representatives);
-    const resolved = lighthouseConfig(rc, routes, process.env);
-    console.log(`\nLighthouse CI — ${routes.length} rotta/e derivate da ${PAGES_DIR}\n`);
-    for (const url of resolved.ci.collect.url ?? [])
-        console.log(`  ${url}`);
+    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}`);
     console.log();
+    return resolved;
+}
+function autorun(resolved) {
     const dir = mkdtempSync(join(tmpdir(), 'lhci-'));
     const config = join(dir, 'lighthouserc.json');
     writeFileSync(config, JSON.stringify(resolved, null, 2));
@@ -42,5 +45,16 @@ export async function main(args = []) {
     rmSync(dir, { recursive: true, force: true });
     return status ?? 1;
 }
+export async function main(args = []) {
+    if (args.includes('--local'))
+        return runLocal();
+    const { url, error } = baseUrlArg(args);
+    if (error !== undefined) {
+        console.error(`\n✗ ${error}\n`);
+        return 1;
+    }
+    const resolved = await resolveConfig(url);
+    return resolved === null ? 1 : autorun(resolved);
+}
 if (import.meta.main)
     process.exit(await main(process.argv.slice(2)));

package/dist/checks/placeholders.js

@@ -2,7 +2,7 @@
 import { existsSync, readFileSync } from 'node:fs';
 import process from 'node:process';
 import { parseArgs } from 'node:util';
-import { contactEnvKeys, envFindings, placeholderSources, sourceFindings } from '../lib/check-placeholders.js';
+import { contactEnvKeys, envFindings, outputFindings, placeholderSources, sourceFindings, } from '../lib/check-placeholders.js';
 import { cliOptions, exitCode, printFindings } from '../lib/cli.js';
 import { loadConfig } from '../lib/config.js';
 const MISSING_SOURCE = 'sorgente assente: `placeholders.sources` in officina.config.ts dice quali file guardare';
@@ -16,30 +16,47 @@ function sourceScan(paths) {
 function envScan(path, keys) {
     if (!existsSync(path))
         return [{ path, message: "file dell'ambiente assente: lo scrive vercel pull", severity: 'error' }];
-    return envFindings(readFileSync(path, 'utf8'), keys).map((hit) => ({ path, ...hit, severity: 'error' }));
+    return envFindings(readFileSync(path, 'utf8'), keys).map((hit) => ({ path, ...hit }));
 }
-function scan(env, config) {
+function outputScan(dir) {
+    if (!existsSync(dir))
+        return [{ path: dir, message: 'cartella della build assente: la scrive vercel build', severity: 'error' }];
+    return outputFindings(dir);
+}
+function scan(env, output, config) {
+    if (output !== undefined) {
+        return {
+            scope: `build in ${output}`,
+            findings: outputScan(output),
+            clean: 'Nessuna variabile Sensitive entrata nella build.',
+            advice: 'Una variabile che la build legge non può essere Sensitive su Vercel: portala a Encrypted, o leggila a runtime',
+        };
+    }
     if (env !== undefined) {
         return {
             scope: `ambiente in ${env}`,
             findings: envScan(env, contactEnvKeys(config)),
-            fix: 'docs/guides/deploy-ops.md § Checklist per il go-live',
+            clean: 'Nessun segnaposto del template.',
+            advice: 'Da sostituire prima del deploy: docs/guides/deploy-ops.md § Checklist per il go-live',
         };
     }
     const paths = placeholderSources(config);
-    return { scope: `${paths.length} sorgenti`, findings: sourceScan(paths), fix: 'README.md § Cosa tocca il rebranding' };
+    return {
+        scope: `${paths.length} sorgenti`,
+        findings: sourceScan(paths),
+        clean: 'Nessun segnaposto del template.',
+        advice: 'Da sostituire prima del deploy: README.md § Cosa tocca il rebranding',
+    };
 }
 export async function main(args = process.argv.slice(2)) {
-    const { env } = parseArgs({ args, options: { env: { type: 'string' } } }).values;
-    const { scope, findings, fix } = scan(env, await loadConfig(process.cwd()));
+    const { env, output } = parseArgs({ args, options: { env: { type: 'string' }, output: { type: 'string' } } }).values;
+    const { scope, findings, clean, advice } = scan(env, output, await loadConfig(process.cwd()));
     console.log(`\ncheck:placeholders — ${scope}\n`);
     printFindings(findings, cliOptions([]).format);
-    if (findings.length === 0) {
-        console.log('  Nessun segnaposto del template.\n');
-    }
-    else {
-        console.log(`\n  Da sostituire prima del deploy: ${fix}.\n`);
-    }
+    if (findings.length === 0)
+        console.log(`  ${clean}\n`);
+    else if (findings.some(({ severity }) => severity === 'error'))
+        console.log(`\n  ${advice}.\n`);
     return exitCode(findings, false);
 }
 if (import.meta.main)

package/dist/checks/smoke.js

@@ -2,7 +2,7 @@
 // L'unico controllo che vede cosa serve davvero il bordo: i test del progetto fissano solo vercel.json.
 import process from 'node:process';
 import { missingInput } from '../lib/cli.js';
-import { loadConfig } from '../lib/config.js';
+import { isRequired, loadConfig } from '../lib/config.js';
 import { expectedRoutes, readPageFiles, smokeRoutes } from '../lib/routes.js';
 import { runChecks, SECURITY_HEADERS, waitForAlias, } from '../lib/smoke-production.js';
 const PAGES_DIR = 'src/pages';
@@ -23,7 +23,8 @@ function printFailures(failures) {
     console.error('Deployments → l’ultimo deployment di produzione sano → Promote to Production.\n');
 }
 export async function main(args = []) {
-    const { siteUrl, smoke = {}, routes = {} } = await loadConfig(process.cwd());
+    const config = await loadConfig(process.cwd());
+    const { siteUrl, smoke = {}, routes = {} } = config;
     const [url] = args;
     if (siteUrl === undefined) {
         console.error('\n✗ officina.config.ts non dichiara siteUrl: il controllo dell’host canonico non ha con cosa confrontarsi.\n');
@@ -40,6 +41,7 @@ export async function main(args = []) {
         baseUrl,
         siteUrl,
         securityHeaders: smoke.securityHeaders ?? SECURITY_HEADERS,
+        botIdRequired: isRequired(config, 'botId'),
     };
     if (missingInput(PAGES_DIR, 'le rotte da visitare si derivano da lì'))
         return 1;

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

@@ -0,0 +1,13 @@
+export type PageEntries = {
+    route: string;
+    entries: string[];
+};
+export type SsrReading = {
+    pages: PageEntries[];
+    failures: string[];
+    notes: string[];
+    comparesExpectedRoutes: boolean;
+    measured: boolean;
+};
+/** Le rotte renderizzate a richiesta non emettono HTML: le dà il manifest che Astro scrive nella build Vercel. */
+export declare function readSsr(hasHtml: boolean): SsrReading;

package/dist/lib/bundle-ssr.js

@@ -0,0 +1,37 @@
+import { existsSync, readdirSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { ssrRoutes } from './vercel-build.js';
+const FUNCTIONS = '.vercel/output/_functions';
+const SERVER_OUTPUT = 'dist/server';
+function readServerFiles() {
+    const read = (path) => ({ path, source: readFileSync(join(FUNCTIONS, path), 'utf8') });
+    const chunks = existsSync(join(FUNCTIONS, 'chunks')) ? readdirSync(join(FUNCTIONS, 'chunks')) : [];
+    const entry = existsSync(join(FUNCTIONS, 'entry.mjs')) ? ['entry.mjs'] : [];
+    return [...entry, ...chunks.filter((name) => name.endsWith('.mjs')).map((name) => `chunks/${name}`)].map(read);
+}
+/** Le rotte renderizzate a richiesta non emettono HTML: le dà il manifest che Astro scrive nella build Vercel. */
+export function readSsr(hasHtml) {
+    const none = { pages: [], failures: [], notes: [], comparesExpectedRoutes: true, measured: false };
+    if (!existsSync(FUNCTIONS)) {
+        if (hasHtml || !existsSync(SERVER_OUTPUT))
+            return none;
+        const note = `build SSR senza l'adapter Vercel: le rotte non si misurano, resta il budget del CSS`;
+        return { ...none, notes: [note], comparesExpectedRoutes: false };
+    }
+    const routes = ssrRoutes(readServerFiles());
+    if (routes === null) {
+        const problem = `${FUNCTIONS}: il manifest di Astro non è in una forma riconosciuta`;
+        return hasHtml
+            ? { ...none, notes: [`${problem}, le rotte renderizzate a richiesta restano fuori dal budget`] }
+            : { ...none, failures: [`${problem}, quindi non c'è nessuna rotta da misurare`], comparesExpectedRoutes: false };
+    }
+    return {
+        ...none,
+        pages: routes.map(({ route, entries }) => ({ route, entries })),
+        failures: routes.flatMap(({ route, unmapped, unknownIslands }) => [
+            ...(unmapped ? [`${route}: nessun chunk server in ${FUNCTIONS}, la misura non coprirebbe le isole`] : []),
+            ...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.d.ts

@@ -1,8 +1,9 @@
 import { type Finding, type Hit } from './cli.ts';
 import type { OfficinaConfig } from './config.ts';
-type EnvHit = Omit<Finding, 'path' | 'severity'>;
+type EnvHit = Omit<Finding, 'path'>;
 export declare function placeholderSources(config?: OfficinaConfig): string[];
 export declare const contactEnvKeys: (config?: OfficinaConfig) => readonly string[];
 export declare function sourceFindings(source: string): Hit[];
 export declare function envFindings(content: string, keys: readonly string[]): EnvHit[];
+export declare const outputFindings: (dir: string) => Finding[];
 export {};

package/dist/lib/check-placeholders.js

@@ -1,4 +1,4 @@
-import { existsSync, readdirSync } from 'node:fs';
+import { existsSync, readdirSync, readFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { parseEnv } from 'node:util';
 import { readLines } from './cli.js';
@@ -11,6 +11,8 @@ const STRING_LITERAL = /'(?:[^'\\]|\\.)*'|"(?:[^"\\]|\\.)*"/g;
 const COMMENT_ONLY = /^\s*(?:\/\/|\/\*|\*)/;
 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 dictionaries = () => existsSync(DICTIONARIES)
     ? readdirSync(DICTIONARIES)
         .filter((name) => name.endsWith('.ts'))
@@ -51,13 +53,35 @@ export function envFindings(content, keys) {
     const env = parseEnv(content);
     const lines = readLines(content);
     return keys.flatMap((key) => {
-        const value = env[key]?.trim() ?? '';
-        const declaration = lines.find(({ text }) => new RegExp(`^\\s*${key}\\s*=`).test(text));
-        const at = declaration ? { line: declaration.n } : {};
+        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`;
+            return [{ severity: 'error', message }];
+        }
+        const hit = (severity, message) => [
+            { line: declaration.n, severity, message: `${key} ${message}` },
+        ];
+        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 [{ ...at, message: `${key} non è impostata: vale il default di astro.config.mjs` }];
+            return hit('error', 'è vuota: vale il default di astro.config.mjs');
         if (TOKEN.test(value) || DOMAIN.test(value))
-            return [{ ...at, message: `${key} porta un segnaposto del template` }];
+            return hit('error', 'porta un segnaposto del template');
         return [];
     });
 }
+const filesUnder = (dir) => readdirSync(dir, { withFileTypes: true }).flatMap((entry) => {
+    const path = join(dir, entry.name);
+    if (entry.isDirectory())
+        return filesUnder(path);
+    return entry.isFile() ? [path] : [];
+});
+export const outputFindings = (dir) => filesUnder(dir)
+    .filter((path) => readFileSync(path).includes(SENSITIVE))
+    .sort()
+    .map((path) => ({
+    path,
+    severity: 'error',
+    message: `contiene ${SENSITIVE}, il segnaposto che vercel pull scrive per una variabile Sensitive: la build l'ha incorporato al posto del valore`,
+}));

package/dist/lib/config.d.ts

@@ -27,6 +27,7 @@ export interface OfficinaConfig {
         analytics?: FeatureSetting;
         roadmap?: FeatureSetting;
         generators?: GeneratorsSetting;
+        botId?: FeatureSetting;
     };
     placeholders?: {
         sources?: readonly string[];
@@ -37,7 +38,7 @@ export interface OfficinaConfig {
         representatives?: Representatives;
     };
 }
-export declare const FEATURES: readonly ['analytics', 'roadmap', 'generators'];
+export declare const FEATURES: readonly ['analytics', 'roadmap', 'generators', 'botId'];
 export type FeatureName = (typeof FEATURES)[number];
 /** Un controllo si spegne solo scrivendolo: il silenzio vale `'required'`. */
 export declare const isRequired: (config: OfficinaConfig, name: FeatureName) => boolean;

package/dist/lib/config.js

@@ -10,7 +10,7 @@ import { existsSync } from 'node:fs';
 import { basename, join } from 'node:path';
 import { pathToFileURL } from 'node:url';
 import { aFunction, aNumber, anArrayOf, aRecordOf, aShape, aString, aStringOrNull, oneOf } from './validate.js';
-export const FEATURES = ['analytics', 'roadmap', 'generators'];
+export const FEATURES = ['analytics', 'roadmap', 'generators', 'botId'];
 /** Un controllo si spegne solo scrivendolo: il silenzio vale `'required'`. */
 export const isRequired = (config, name) => (config.features?.[name] ?? 'required') === 'required';
 export const generatorsSetting = (config) => config.features?.generators ?? 'required';
@@ -28,7 +28,7 @@ const SHAPE = aShape({
         checks: anArrayOf(aFunction),
     }),
     analytics: aShape({ linkTracking: aString }),
-    features: aShape({ analytics: feature, roadmap: feature, generators }),
+    features: aShape({ analytics: feature, roadmap: feature, generators, botId: feature }),
     placeholders: aShape({ sources: anArrayOf(aString), contactEnvKeys: anArrayOf(aString) }),
     routes: aShape({ representatives: aRecordOf(aString) }),
 });

package/dist/lib/lighthouse.d.ts

@@ -12,6 +12,11 @@ export interface LighthouseRc {
         [section: string]: unknown;
     };
 }
-export type LighthouseEnv = Partial<Record<'LH_PORT' | 'LH_RUNS' | 'LH_EXTERNAL_SERVER' | 'LH_CHROME_FLAGS' | 'LH_OUT', string>>;
+export type LighthouseEnv = Partial<Record<'LH_PORT' | 'LH_RUNS' | 'LH_EXTERNAL_SERVER' | 'LH_BASE_URL' | 'LH_CHROME_FLAGS' | 'LH_OUT', string>>;
+export type BaseUrlArg = {
+    url?: string;
+    error?: string;
+};
+export declare function baseUrlArg(args: readonly string[]): BaseUrlArg;
 /** Le rotte arrivano da src/pages, il resto dal `.lighthouserc.json` del progetto; l'ambiente lo piega al giro locale. */
 export declare function lighthouseConfig(rc: LighthouseRc, routes: readonly string[], env: LighthouseEnv): LighthouseRc;

package/dist/lib/lighthouse.js

@@ -1,18 +1,29 @@
 const DEFAULT_PORT = '4321';
+const SERVER_PORT = /(--listen|--port)([ =])\d+/;
+export function baseUrlArg(args) {
+    const url = args.find((arg) => !arg.startsWith('--'));
+    if (url === undefined)
+        return {};
+    const protocol = URL.parse(url)?.protocol;
+    if (protocol === 'http:' || protocol === 'https:')
+        return { url: url.replace(/\/+$/, '') };
+    return { error: `${url} non è un URL http(s): passa l'indirizzo di un sito già servito, per esempio https://…` };
+}
 /** Le rotte arrivano da src/pages, il resto dal `.lighthouserc.json` del progetto; l'ambiente lo piega al giro locale. */
 export function lighthouseConfig(rc, routes, env) {
     const port = env.LH_PORT ?? DEFAULT_PORT;
-    const collect = { ...rc.ci.collect, url: routes.map((route) => `http://localhost:${port}${route}`) };
+    const base = env.LH_BASE_URL ?? `http://localhost:${port}`;
+    const collect = { ...rc.ci.collect, url: routes.map((route) => `${base}${route}`) };
     if (env.LH_RUNS)
         collect.numberOfRuns = Number(env.LH_RUNS);
-    // Il server è già in ascolto: lo avvia lhci-local.sh, per servire una directory diversa.
-    if (env.LH_EXTERNAL_SERVER) {
+    // Il server è già in ascolto: lo avvia lhci-local.sh, per servire una directory diversa, oppure è il sito dell'URL.
+    if (env.LH_EXTERNAL_SERVER || env.LH_BASE_URL) {
         delete collect.startServerCommand;
         delete collect.startServerReadyPattern;
         delete collect.startServerReadyTimeout;
     }
     else if (collect.startServerCommand !== undefined) {
-        collect.startServerCommand = collect.startServerCommand.replace(/--listen \d+/, `--listen ${port}`);
+        collect.startServerCommand = collect.startServerCommand.replace(SERVER_PORT, `$1$2${port}`);
     }
     if (env.LH_CHROME_FLAGS)
         collect.settings = { ...collect.settings, chromeFlags: env.LH_CHROME_FLAGS };

package/dist/lib/smoke-production.d.ts

@@ -12,6 +12,7 @@ export interface SmokeContext {
     baseUrl: string;
     siteUrl: string;
     securityHeaders: Record<string, string | null>;
+    botIdRequired: boolean;
 }
 export type SmokeCheck = (context: SmokeContext, pages: readonly VerifiedRoute[]) => Promise<CheckResult[]>;
 export interface CheckResult {
@@ -26,7 +27,7 @@ export declare const BOTID_CHALLENGE = "/149e9513-01fa-4fb0-aad4-566afd725d1b/2d
 export declare function waitForAlias({ get, baseUrl }: SmokeContext, sleep: (ms: number) => Promise<void>, attempts?: number): Promise<void>;
 export declare function checkPages({ get, baseUrl }: SmokeContext, pages: readonly VerifiedRoute[]): Promise<CheckResult[]>;
 export declare function checkSecurityHeaders({ get, baseUrl, securityHeaders }: SmokeContext): Promise<CheckResult[]>;
-export declare function checkBotIdChallenge({ get, baseUrl }: SmokeContext): Promise<CheckResult[]>;
+export declare function checkBotIdChallenge({ get, baseUrl, botIdRequired }: SmokeContext): Promise<CheckResult[]>;
 /** Il 308 da www all'apice, da vercel.json: dipende dal DNS e dal dominio del progetto Vercel, non dal deployment. */
 export declare function checkCanonicalHost({ get, baseUrl, siteUrl }: SmokeContext): Promise<CheckResult[]>;
 export declare function checkTrailingSlash({ get, baseUrl }: SmokeContext, pages: readonly VerifiedRoute[]): Promise<CheckResult[]>;

package/dist/lib/smoke-production.js

@@ -13,11 +13,14 @@ export const SECURITY_HEADERS = {
 };
 /** Deve corrispondere al `source` del rewrite in vercel.json. */
 export const BOTID_CHALLENGE = '/149e9513-01fa-4fb0-aad4-566afd725d1b/2d206a39-8ed7-437e-a3be-862e0f06eea3/a-4-a/c.js';
+const isRedirect = (status) => status >= 300 && status < 400;
+const MAX_REDIRECTS = 5;
 /** L'alias di produzione di Vercel impiega un attimo a puntare al deployment appena caricato. */
 export async function waitForAlias({ get, baseUrl }, sleep, attempts = 5) {
     for (let attempt = 1; attempt <= attempts; attempt++) {
         try {
-            if ((await get(baseUrl)).ok)
+            const response = await get(baseUrl);
+            if (response.ok || isRedirect(response.status))
                 return;
         }
         catch { }
@@ -25,6 +28,25 @@ export async function waitForAlias({ get, baseUrl }, sleep, attempts = 5) {
             await sleep(attempt * 2000);
     }
 }
+/** La radice può essere un redirect, come il 302 di lingua di Astro, che non porta la CSP delle pagine renderizzate. */
+async function landingPage(get, baseUrl) {
+    const { origin } = new URL(baseUrl);
+    let url = baseUrl;
+    for (let hops = 0;; hops++) {
+        const response = await get(url);
+        if (!isRedirect(response.status))
+            return { url, response };
+        if (hops === MAX_REDIRECTS)
+            throw new Error(`più di ${MAX_REDIRECTS} redirect a partire da ${baseUrl}`);
+        const location = response.headers.get('location');
+        if (location === null)
+            throw new Error(`${url} risponde ${response.status} senza location`);
+        const next = new URL(location, url);
+        if (next.origin !== origin)
+            throw new Error(`${url} rimanda a ${next.href}, fuori da ${origin}`);
+        url = next.href;
+    }
+}
 export async function checkPages({ get, baseUrl }, pages) {
     const results = [];
     for (const { path, type } of pages) {
@@ -46,15 +68,17 @@ export async function checkPages({ get, baseUrl }, pages) {
     return results;
 }
 export async function checkSecurityHeaders({ get, baseUrl, securityHeaders }) {
-    let response;
+    let landing;
     try {
-        response = await get(baseUrl);
+        landing = await landingPage(get, baseUrl);
     }
     catch (error) {
         return [fail('header di sicurezza', messageOf(error))];
     }
+    const { url, response } = landing;
+    const where = url === baseUrl ? '' : ` su ${new URL(url).pathname}`;
     const results = Object.entries(securityHeaders).map(([header, expected]) => {
-        const check = `header ${header}`;
+        const check = `header ${header}${where}`;
         const value = response.headers.get(header);
         if (value === null)
             return fail(check, 'assente');
@@ -65,11 +89,13 @@ export async function checkSecurityHeaders({ get, baseUrl, securityHeaders }) {
     // Il noindex `has: host = *.vercel.app` di vercel.json applicato al dominio vero farebbe sparire il sito da ogni indice.
     const check = 'nessun x-robots-tag sull’host di produzione';
     const robots = response.headers.get('x-robots-tag');
-    results.push(robots === null ? pass(check) : fail(check, `presente su ${baseUrl}: "${robots}"`));
+    results.push(robots === null ? pass(check) : fail(check, `presente su ${url}: "${robots}"`));
     return results;
 }
-export async function checkBotIdChallenge({ get, baseUrl }) {
+export async function checkBotIdChallenge({ get, baseUrl, botIdRequired }) {
     const check = 'challenge di BotID servita dalla stessa origine';
+    if (!botIdRequired)
+        return [skip(check, 'spento da `features.botId: false`')];
     try {
         const response = await get(`${baseUrl}${BOTID_CHALLENGE}`);
         if (response.status !== 200)

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

@@ -0,0 +1,11 @@
+export type ServerFile = {
+    path: string;
+    source: string;
+};
+export type SsrRoute = {
+    route: string;
+    entries: string[];
+    unmapped: boolean;
+    unknownIslands: string[];
+};
+export declare function ssrRoutes(files: readonly ServerFile[]): SsrRoute[] | null;

package/dist/lib/vercel-build.js

@@ -0,0 +1,118 @@
+import { posix } from 'node:path';
+const MANIFEST_CALL = 'deserializeManifest({';
+const ASSET = /^_astro\/([^/]+\.js)$/;
+const RENDERER_RUNTIME = /^@astrojs\/[\w-]+\/client\.js$/;
+const COMPONENT_SCRIPT = '?astro&type=script';
+const PAGE_ROUTE = /\["(src\/pages\/[^"]+)", (_page\d+)\]/g;
+const PAGE_IMPORT = /(?:var|const|let) (_page\d+) = \(\) => import\("(\.{1,2}\/[^"]+\.mjs)"\)/g;
+const ISLAND_PATH = /"client:component-path":\s*"([^"]+)"/g;
+const SERVER_IMPORT = /(?<![\w$.])(?:from|import)\s*"(\.{1,2}\/[^"]+\.mjs)"/g;
+const resolve = (from, specifier) => posix.join(posix.dirname(from), specifier);
+function objectLiteralAt(source, start) {
+    let depth = 0;
+    let quoted = false;
+    for (let i = start; i < source.length; i++) {
+        const char = source[i];
+        if (quoted) {
+            if (char === '\\')
+                i++;
+            else if (char === '"')
+                quoted = false;
+        }
+        else if (char === '"')
+            quoted = true;
+        else if (char === '{')
+            depth++;
+        else if (char === '}' && --depth === 0)
+            return source.slice(start, i + 1);
+    }
+    return null;
+}
+function parseManifest(source) {
+    const call = source.indexOf(MANIFEST_CALL);
+    const literal = call === -1 ? null : objectLiteralAt(source, call + MANIFEST_CALL.length - 1);
+    if (literal === null)
+        return null;
+    try {
+        return JSON.parse(literal);
+    }
+    catch {
+        return null;
+    }
+}
+function pageChunks(file) {
+    const chunkOf = new Map([...file.source.matchAll(PAGE_IMPORT)].map(([, name, path]) => [name, resolve(file.path, path)]));
+    const pages = new Map();
+    for (const [, component, name] of file.source.matchAll(PAGE_ROUTE)) {
+        const chunk = chunkOf.get(name);
+        if (chunk !== undefined)
+            pages.set(component, chunk);
+    }
+    return pages;
+}
+// Il file del manifest nomina ogni modulo del sito: seguirlo attribuirebbe a ogni pagina tutte le isole.
+function serverClosure(start, files, manifestFile) {
+    const reached = new Map();
+    const queue = [start];
+    while (queue.length > 0) {
+        const path = queue.pop();
+        const source = files.get(path);
+        if (path === manifestFile || reached.has(path) || source === undefined)
+            continue;
+        reached.set(path, source);
+        for (const [, specifier] of source.matchAll(SERVER_IMPORT))
+            queue.push(resolve(path, specifier));
+    }
+    return [...reached.values()];
+}
+const assetOf = (value) => value?.match(ASSET)?.[1];
+function clientModules(manifest) {
+    const inlined = new Set((manifest.inlinedScripts ?? []).map(([specifier]) => specifier));
+    const modules = new Map();
+    for (const [specifier, value] of Object.entries(manifest.entryModules ?? {})) {
+        const asset = assetOf(value);
+        if (asset !== undefined && !inlined.has(specifier))
+            modules.set(specifier, asset);
+    }
+    return modules;
+}
+function routeEntries(page, texts, modules) {
+    const used = [...modules].filter(([specifier]) => !RENDERER_RUNTIME.test(specifier) && texts.some((text) => text.includes(`"${specifier}"`)));
+    const hasIsland = used.some(([specifier]) => !specifier.includes(COMPONENT_SCRIPT));
+    const runtimes = hasIsland ? [...modules].filter(([specifier]) => RENDERER_RUNTIME.test(specifier)) : [];
+    const scripts = page.scripts.filter((script) => script.type === 'external').map((script) => assetOf(script.value));
+    const names = [...scripts, ...[...used, ...runtimes].map(([, asset]) => asset)];
+    return [...new Set(names.filter((name) => name !== undefined))].sort();
+}
+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 }) {
+    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 }] : [];
+}
+export function ssrRoutes(files) {
+    for (const file of files) {
+        const manifest = parseManifest(file.source);
+        if (manifest !== null)
+            return routesOf(file, manifest, files);
+    }
+    return null;
+}
+function routesOf(host, manifest, files) {
+    const sources = new Map(files.map((file) => [file.path, file.source]));
+    const chunks = pageChunks(host);
+    const modules = clientModules(manifest);
+    return (manifest.routes ?? []).flatMap(ssrPage).map((page) => {
+        const chunk = chunks.get(page.component);
+        const texts = chunk === undefined ? [] : serverClosure(chunk, sources, host.path);
+        return {
+            route: page.route,
+            entries: routeEntries(page, texts, modules),
+            unmapped: chunk === undefined,
+            unknownIslands: unknownIslands(texts, modules),
+        };
+    });
+}

package/dist/sh/lhci-local.sh

@@ -47,6 +47,13 @@ trap cleanup EXIT
 echo "→ build equivalente alla produzione in ${OUT_DIR}"
 VERCEL_ENV=production pnpm build --outDir "${OUT_DIR}"
 
+if [[ -z "$(find "${OUT_DIR}/client" -name '*.html' -print -quit 2>/dev/null)" ]]; then
+  echo "✗ ${OUT_DIR}/client non contiene HTML: il sito è renderizzato a richiesta (output: 'server')," >&2
+  echo "  e un server statico risponderebbe 404 su ogni rotta. Misura un sito già servito:" >&2
+  echo "  pnpm run lhci https://…   (produzione o anteprima)" >&2
+  exit 1
+fi
+
 if ! grep -qx 'Allow: /' "${OUT_DIR}/client/robots.txt"; then
   echo "✗ ${OUT_DIR}/client/robots.txt non ha 'Allow: /': la build non equivale alla produzione." >&2
   head -3 "${OUT_DIR}/client/robots.txt" >&2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@elia97/officina",
-  "version": "0.7.1",
+  "version": "0.9.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",