@elia97/officina 0.8.0 → 0.9.0

package/README.md

@@ -50,6 +50,8 @@ Una rotta renderizzata a richiesta non emette HTML. Con l'adapter Vercel, `check
 
 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
@@ -66,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' } },
 })
 ```
@@ -79,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.
@@ -116,7 +120,7 @@ I passi dei workflow stanno in `actions/` di questo repository, come composite a
 |---|---|---|
 | `actions/ci` | checkout, node, install, `astro sync`, `pnpm run ci`, build, `perf:bundle`; con `e2e: 'true'` anche Playwright | trigger, permessi, il job `ci` |
 | `actions/review` | `astro sync`, poi `fallow review` sul diff contro il merge-base | il job informativo |
-| `actions/deploy` | risoluzione del tag, gate, `vercel pull`, `build`, `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, 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

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/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/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/package.json

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