@elia97/officina 0.10.0 → 0.11.0

package/README.md

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

package/dist/bin.js

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

package/dist/checks/bundle.js

@@ -9,7 +9,7 @@ import { measureCss, routeCount } from '../lib/bundle-css.js';
 import { readSsr } from '../lib/bundle-ssr.js';
 import { missingInput } from '../lib/cli.js';
 import { loadConfig } from '../lib/config.js';
-import { expectedRoutes, filesWithExtension, missingRouteFailures, readPageFiles, routeOf, } from '../lib/routes.js';
+import { disabledRouteFailures, expectedRoutes, filesWithExtension, missingRouteFailures, readPageFiles, routeOf, } from '../lib/routes.js';
 const DIST = 'dist/client';
 const ASSETS = join(DIST, '_astro');
 const PAGES = 'src/pages';
@@ -98,8 +98,15 @@ function printSsrNote(expected, ssr) {
     for (const file of expected.ssr)
         console.log(`      - ${file}`);
 }
+function printDisabled({ disabled }) {
+    if (disabled.length === 0)
+        return;
+    console.log('\nSPENTE  da `routes.disabled`, nessuna pagina attesa:');
+    for (const { label, file } of disabled)
+        console.log(`      - ${label} (${file})`);
+}
 export async function main() {
-    const { bundle = {} } = await loadConfig(process.cwd());
+    const { bundle = {}, routes: { disabled } = {} } = await loadConfig(process.cwd());
     if (missingInput(ASSETS, 'è la build da misurare: prima `pnpm build`'))
         return 1;
     if (missingInput(PAGES, 'le rotte attese si derivano da lì'))
@@ -109,14 +116,17 @@ export async function main() {
     const ssr = readSsr(html.length > 0);
     const routes = [...html, ...ssr.pages];
     const pages = measurePages(routes, readChunks(), bundle.budgets ?? []);
-    const expected = expectedRoutes(readPageFiles(PAGES), PAGES);
-    const measured = pages.map((page) => page.route);
-    const failures = ssr.comparesExpectedRoutes ? missingRouteFailures(expected, measured, DIST) : [];
+    const expected = expectedRoutes(readPageFiles(PAGES), PAGES, disabled);
+    const emitted = { html: html.map((page) => page.route), ssr: ssr.pages.map((page) => page.route) };
+    const failures = ssr.comparesExpectedRoutes
+        ? [...missingRouteFailures(expected, emitted, DIST), ...disabledRouteFailures(expected, emitted)]
+        : [];
     failures.push(...ssr.failures, ...unknownChunkFailures(pages), ...overBudgetFailures(pages));
     const width = Math.max('ROTTA'.length, ...pages.map((p) => p.route.length));
     printPages(pages, width);
     failures.push(...checkCss(routes, cssMaxGzip, width));
     printSsrNote(expected, ssr);
+    printDisabled(expected);
     if (failures.length > 0) {
         console.error(`\n✗ Budget di bundle:\n${failures.map((f) => `  - ${f}`).join('\n')}\n`);
         return 1;

package/dist/checks/doctor.js

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

package/dist/checks/lighthouse.js

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

package/dist/checks/links.d.ts

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

package/dist/checks/links.js

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

package/dist/checks/smoke.js

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

package/dist/lib/alignment.js

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

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

@@ -1,3 +1,4 @@
+import { type ServerFile } from './vercel-build.ts';
 export type PageEntries = {
     route: string;
     entries: string[];
@@ -10,5 +11,6 @@ export type SsrReading = {
     comparesExpectedRoutes: boolean;
     measured: boolean;
 };
+export declare function readServerFiles(): ServerFile[];
 /** 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

@@ -3,7 +3,7 @@ import { join } from 'node:path';
 import { ssrRoutes } from './vercel-build.js';
 const FUNCTIONS = '.vercel/output/_functions';
 const SERVER_OUTPUT = 'dist/server';
-function readServerFiles() {
+export 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'] : [];

package/dist/lib/check-placeholders.js

@@ -11,7 +11,7 @@ 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.
+// `SENSITIVE_ENV_VALUE_PLACEHOLDER` di vercel@62.2.0: `vercel pull` lo scrive al posto del valore di una Sensitive.
 const SENSITIVE = '[SENSITIVE]';
 const WITHOUT_VALUE = 'il deploy andrebbe online senza il suo valore';
 const dictionaries = () => existsSync(DICTIONARIES)

package/dist/lib/config-gaps.d.ts

@@ -1,7 +1,7 @@
 import { type OfficinaConfig } from './config.ts';
 import type { ContractGap } from './contract.ts';
-/**
- * `loaded` è la configurazione letta, l'errore che il suo caricamento ha sollevato, o `undefined` se
- * il file non c'è; `patterns` i pattern dinamici di `src/pages` rimasti senza rappresentante.
- */
-export declare function configGaps(loaded: OfficinaConfig | Error | undefined, patterns?: readonly string[]): ContractGap[];
+export type RouteGaps = {
+    missingRepresentatives?: readonly string[];
+    unknownDisabled?: readonly string[];
+};
+export declare function configGaps(loaded: OfficinaConfig | Error | undefined, { missingRepresentatives, unknownDisabled }?: RouteGaps): ContractGap[];

package/dist/lib/config-gaps.js

@@ -1,5 +1,6 @@
 import { FEATURES } from './config.js';
 const CONFIG = 'officina.config.ts';
+const asGap = (message) => ({ path: CONFIG, message });
 function siteUrlGap(siteUrl) {
     if (siteUrl === undefined)
         return '`siteUrl` assente: `check smoke` non ha un host canonico';
@@ -7,14 +8,16 @@ function siteUrlGap(siteUrl) {
         return `\`siteUrl\` non è un URL: \`${siteUrl}\``;
     return siteUrl.endsWith('/') ? `\`siteUrl\` finisce con una barra: \`${siteUrl}\`` : undefined;
 }
+// TODO: dalla 0.12.0 `links` è un errore di doctor: toglila da NEW_FEATURES.
+const NEW_FEATURES = new Set(['links']);
 // Il silenzio vale `'required'`: un controllo si spegne dichiarandolo, non dimenticandolo.
-const featureGaps = (config) => FEATURES.filter((name) => config.features?.[name] === undefined).map((name) => `\`features.${name}\` non dichiarata: vale \`'required'\`, e il gate fallisce se non trova cosa controllare`);
+const featureGaps = (config) => FEATURES.filter((name) => config.features?.[name] === undefined).map((name) => ({
+    ...asGap(`\`features.${name}\` non dichiarata: vale \`'required'\`, e il gate fallisce se non trova cosa controllare`),
+    ...(NEW_FEATURES.has(name) ? { severity: 'warning' } : {}),
+}));
 const representativeGaps = (patterns) => patterns.map((label) => `\`routes.representatives\` non ha un percorso per \`${label}\`: smoke e Lighthouse non guardano quella pagina`);
-/**
- * `loaded` è la configurazione letta, l'errore che il suo caricamento ha sollevato, o `undefined` se
- * il file non c'è; `patterns` i pattern dinamici di `src/pages` rimasti senza rappresentante.
- */
-export function configGaps(loaded, patterns = []) {
+const disabledGaps = (labels) => labels.map((label) => `\`routes.disabled\` nomina \`${label}\`, che non è una pagina dinamica prerenderizzata di \`src/pages\`: non spegne niente`);
+export function configGaps(loaded, { missingRepresentatives = [], unknownDisabled = [] } = {}) {
     if (loaded === undefined)
         return [{ path: CONFIG, message: 'manca: i valori del progetto per officina stanno qui' }];
     if (loaded instanceof Error)
@@ -22,8 +25,11 @@ export function configGaps(loaded, patterns = []) {
     const messages = [
         siteUrlGap(loaded.siteUrl),
         loaded.icons === undefined ? '`icons.background` assente: `gen icons` non ha un colore di fondo' : undefined,
+    ].filter((message) => message !== undefined);
+    return [
+        ...messages.map(asGap),
         ...featureGaps(loaded),
-        ...representativeGaps(patterns),
+        ...representativeGaps(missingRepresentatives).map(asGap),
+        ...disabledGaps(unknownDisabled).map(asGap),
     ];
-    return messages.filter((message) => message !== undefined).map((message) => ({ path: CONFIG, message }));
 }

package/dist/lib/config.d.ts

@@ -28,17 +28,20 @@ export interface OfficinaConfig {
         roadmap?: FeatureSetting;
         generators?: GeneratorsSetting;
         botId?: FeatureSetting;
+        links?: FeatureSetting;
     };
     placeholders?: {
         sources?: readonly string[];
         contactEnvKeys?: readonly string[];
     };
-    /** Per ogni pattern dinamico di `src/pages`, un percorso vero che smoke e Lighthouse visitano. */
     routes?: {
+        /** Per ogni pattern dinamico di `src/pages`, un percorso vero che smoke e Lighthouse visitano. */
         representatives?: Representatives;
+        /** I pattern dinamici di `src/pages` spenti per scelta: non emettono pagine, e nessun gate le pretende. */
+        disabled?: readonly string[];
     };
 }
-export declare const FEATURES: readonly ['analytics', 'roadmap', 'generators', 'botId'];
+export declare const FEATURES: readonly ['analytics', 'roadmap', 'generators', 'botId', 'links'];
 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', 'botId'];
+export const FEATURES = ['analytics', 'roadmap', 'generators', 'botId', 'links'];
 /** 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,9 +28,9 @@ const SHAPE = aShape({
         checks: anArrayOf(aFunction),
     }),
     analytics: aShape({ linkTracking: aString }),
-    features: aShape({ analytics: feature, roadmap: feature, generators, botId: feature }),
+    features: aShape({ analytics: feature, roadmap: feature, generators, botId: feature, links: feature }),
     placeholders: aShape({ sources: anArrayOf(aString), contactEnvKeys: anArrayOf(aString) }),
-    routes: aShape({ representatives: aRecordOf(aString) }),
+    routes: aShape({ representatives: aRecordOf(aString), disabled: anArrayOf(aString) }),
 });
 const CONFIG_FILES = ['officina.config.ts', 'officina.config.mjs', 'officina.config.js'];
 export const defineConfig = (config) => config;

package/dist/lib/links.d.ts

@@ -0,0 +1,30 @@
+export type LinkTarget = {
+    kind: 'placeholder' | 'anchor' | 'scheme' | 'external';
+} | {
+    kind: 'internal';
+    path: string;
+};
+export type PageLinks = {
+    route: string;
+    hrefs: readonly string[];
+};
+export type LinkReport = {
+    broken: {
+        destination: string;
+        pages: string[];
+    }[];
+    internal: number;
+    onDemand: number;
+    outside: {
+        external: number;
+        scheme: number;
+        anchor: number;
+    };
+};
+export declare function htmlLinks(html: string): string[];
+export declare const siteOrigin: (siteUrl: string | undefined) => string;
+export declare function linkTarget(href: string, page: URL): LinkTarget;
+export declare function servedPaths(files: readonly string[]): Set<string>;
+export declare function servedBy(path: string, served: ReadonlySet<string>, onDemand: readonly RegExp[]): 'build' | 'on-demand' | undefined;
+export declare function linkReport(pages: readonly PageLinks[], origin: string, served: ReadonlySet<string>, onDemand: readonly RegExp[]): LinkReport;
+export declare const brokenLines: ({ broken }: LinkReport) => string[];

package/dist/lib/links.js

@@ -0,0 +1,101 @@
+import { listed } from './routes.js';
+const VALUE = String.raw `(?:"[^"]*"|'[^']*'|[^\s"'>]+)`;
+const ATTRIBUTES = String.raw `(?:\s+[^\s"'>/=]+(?:\s*=\s*${VALUE})?)*`;
+// Astro conserva i commenti HTML, e nei valori dinamici degli attributi scappa solo `&` e `"`.
+const MARKUP = new RegExp(String.raw `<!--[\s\S]*?-->|<(script|style)\b${ATTRIBUTES}\s*\/?>[\s\S]*?<\/\1\s*>|<a(${ATTRIBUTES})\s*\/?>|<[a-z][^\s/>]*${ATTRIBUTES}\s*\/?>`, 'gi');
+const ATTRIBUTE = /\s+([^\s"'>/=]+)(?:\s*=\s*(?:"([^"]*)"|'([^']*)'|([^\s"'>]+)))?/g;
+const ENTITY = /&(?:#(\d{1,6})|#x([\da-f]{1,5})|(amp|lt|gt|quot|apos));/gi;
+const NAMED = { amp: '&', lt: '<', gt: '>', quot: '"', apos: "'" };
+const SCHEME = /^[a-z][a-z\d+.-]*:/i;
+const WEB = /^https?:/i;
+const NO_SITE = 'https://officina.invalid';
+const decodeEntities = (value) => value.replace(ENTITY, (_, decimal, hex, name) => {
+    if (decimal !== undefined)
+        return String.fromCodePoint(Number(decimal));
+    if (hex !== undefined)
+        return String.fromCodePoint(Number.parseInt(hex, 16));
+    return NAMED[name.toLowerCase()];
+});
+function hrefOf(attributes) {
+    for (const [, name, double, single, bare] of attributes.matchAll(ATTRIBUTE)) {
+        if (name.toLowerCase() === 'href')
+            return decodeEntities(double ?? single ?? bare ?? '');
+    }
+    return undefined;
+}
+export function htmlLinks(html) {
+    return [...html.matchAll(MARKUP)]
+        .map(([, , attributes]) => (attributes === undefined ? undefined : hrefOf(attributes)))
+        .filter((href) => href !== undefined);
+}
+export const siteOrigin = (siteUrl) => siteUrl !== undefined && URL.canParse(siteUrl) ? new URL(siteUrl).origin : NO_SITE;
+function decoded(path) {
+    try {
+        return decodeURIComponent(path);
+    }
+    catch {
+        return path;
+    }
+}
+export function linkTarget(href, page) {
+    const value = href.trim();
+    if (value === '' || value === '#')
+        return { kind: 'placeholder' };
+    if (value.startsWith('#'))
+        return { kind: 'anchor' };
+    if (SCHEME.test(value) && !WEB.test(value))
+        return { kind: 'scheme' };
+    if (!URL.canParse(value, page))
+        return { kind: 'internal', path: value };
+    const url = new URL(value, page);
+    return url.origin === page.origin ? { kind: 'internal', path: decoded(url.pathname) } : { kind: 'external' };
+}
+export function servedPaths(files) {
+    const served = new Set();
+    for (const file of files) {
+        served.add(file);
+        if (file.endsWith('/index.html'))
+            served.add(file.slice(0, -'/index.html'.length) || '/');
+        else if (file.endsWith('.html'))
+            served.add(file.slice(0, -'.html'.length));
+    }
+    return served;
+}
+const withoutTrailingSlash = (path) => (path.length > 1 ? path.replace(/\/+$/, '') : path);
+export function servedBy(path, served, onDemand) {
+    const bare = withoutTrailingSlash(path);
+    if (served.has(path) || served.has(bare))
+        return 'build';
+    return onDemand.some((pattern) => pattern.test(bare)) ? 'on-demand' : undefined;
+}
+const placeholderLabel = (href) => `segnaposto href="${href.trim()}"`;
+export function linkReport(pages, origin, served, onDemand) {
+    const citing = new Map();
+    const report = { broken: [], internal: 0, onDemand: 0, outside: { external: 0, scheme: 0, anchor: 0 } };
+    const cite = (destination, route) => citing.set(destination, (citing.get(destination) ?? new Set()).add(route));
+    const checkInternal = (path, route) => {
+        report.internal++;
+        const by = servedBy(path, served, onDemand);
+        if (by === undefined)
+            cite(withoutTrailingSlash(path), route);
+        if (by === 'on-demand')
+            report.onDemand++;
+    };
+    for (const { route, hrefs } of pages) {
+        const page = new URL(route, origin);
+        for (const href of hrefs) {
+            const target = linkTarget(href, page);
+            if (target.kind === 'placeholder')
+                cite(placeholderLabel(href), route);
+            else if (target.kind === 'internal')
+                checkInternal(target.path, route);
+            else
+                report.outside[target.kind]++;
+        }
+    }
+    report.broken = [...citing]
+        .sort(([a], [b]) => (a < b ? -1 : 1))
+        .map(([destination, routes]) => ({ destination, pages: [...routes].sort() }));
+    return report;
+}
+export const brokenLines = ({ broken }) => broken.map(({ destination, pages }) => `${destination} ← ${listed(pages)}`);

package/dist/lib/routes.d.ts

@@ -2,16 +2,18 @@ export type PageFile = {
     file: string;
     source: string;
 };
+type DynamicRoute = {
+    pattern: RegExp;
+    label: string;
+    file: string;
+};
 export type Expectations = {
     exact: {
         route: string;
         file: string;
     }[];
-    patterns: {
-        pattern: RegExp;
-        label: string;
-        file: string;
-    }[];
+    patterns: DynamicRoute[];
+    disabled: DynamicRoute[];
     ssr: string[];
 };
 export type VerifiedRoute = {
@@ -25,11 +27,21 @@ export declare const NON_HTML_ROUTES: readonly VerifiedRoute[];
 export declare function filesWithExtension(dir: string, extension: string): string[];
 export declare function readPageFiles(pagesDir: string): PageFile[];
 export declare function routeOf(htmlPath: string, dist: string): string;
-export declare function expectedRoutes(pages: readonly PageFile[], pagesDir: string): Expectations;
+export declare function pageRouteOf(file: string, pagesDir: string): string;
+export declare function routePattern(route: string): RegExp;
+export declare function expectedRoutes(pages: readonly PageFile[], pagesDir: string, disabled?: readonly string[]): Expectations;
+export type EmittedRoutes = {
+    html: readonly string[];
+    ssr: readonly string[];
+};
 /** [HARD] Guardia fail-open: ogni asserzione per rotta itera sulle pagine emesse, quindi una dist vuota non asserisce niente. */
-export declare function missingRouteFailures(expected: Expectations, emitted: readonly string[], dist: string): string[];
+export declare function missingRouteFailures(expected: Expectations, emitted: EmittedRoutes, dist: string): string[];
+export declare const listed: (routes: readonly string[]) => string;
+export declare function disabledRouteFailures(expected: Expectations, { html, ssr }: EmittedRoutes): string[];
+export declare function unknownDisabled(expected: Expectations, disabled?: readonly string[]): string[];
 /** I pattern dinamici che `officina.config.ts` non ha ancora mandato nessuno a visitare. */
 export declare function missingRepresentatives(expected: Expectations, representatives?: Representatives): string[];
 export declare function auditRoutes(expected: Expectations, representatives?: Representatives): string[];
 export declare function smokeRoutes(expected: Expectations, nonHtmlRoutes?: readonly VerifiedRoute[], representatives?: Representatives): VerifiedRoute[];
 export declare function orphanExceptions(expected: Expectations): string[];
+export {};

package/dist/lib/routes.js

@@ -28,7 +28,7 @@ export function routeOf(htmlPath, dist) {
     return route.replace(/\.html$/, '') || '/';
 }
 const SSR_OPT_OUT = /^\s*export\s+const\s+prerender\s*=\s*false\b/m;
-function pageRouteOf(file, pagesDir) {
+export function pageRouteOf(file, pagesDir) {
     return (toPosix(file, pagesDir)
         .replace(/\.astro$/, '')
         .replace(/\/index$/, '') || '/');
@@ -41,14 +41,14 @@ function segmentPattern(segment) {
 const TRAILING_REST_SEGMENT = /\/\[\.\.\.[^/]*\]$/;
 // Anche un segmento rest finale fa match col vuoto: `paginate()` emette la prima pagina come
 // percorso nudo (`/news`, mai `/news/1`), quindi esigere un segmento boccia un archivio di una pagina.
-function routePattern(route) {
+export function routePattern(route) {
     const body = (path) => path.split('/').map(segmentPattern).join('/');
     if (!TRAILING_REST_SEGMENT.test(route))
         return new RegExp(`^${body(route)}$`);
     return new RegExp(`^${body(route.replace(TRAILING_REST_SEGMENT, ''))}(?:/.*)?$`);
 }
-export function expectedRoutes(pages, pagesDir) {
-    const expectations = { exact: [], patterns: [], ssr: [] };
+export function expectedRoutes(pages, pagesDir, disabled = []) {
+    const expectations = { exact: [], patterns: [], disabled: [], ssr: [] };
     for (const { file, source } of pages) {
         if (SSR_OPT_OUT.test(source)) {
             expectations.ssr.push(file);
@@ -59,28 +59,52 @@ export function expectedRoutes(pages, pagesDir) {
             expectations.exact.push({ route, file });
             continue;
         }
-        expectations.patterns.push({ pattern: routePattern(route), label: route, file });
+        const target = disabled.includes(route) ? expectations.disabled : expectations.patterns;
+        target.push({ pattern: routePattern(route), label: route, file });
     }
     return expectations;
 }
+// Il manifest di Astro nomina una rotta resa a richiesta col suo pattern (`/blog/[slug]`), non coi percorsi che serve.
+const emits = ({ pattern, label }, { html, ssr }) => html.some((route) => pattern.test(route)) || ssr.includes(label);
 /** [HARD] Guardia fail-open: ogni asserzione per rotta itera sulle pagine emesse, quindi una dist vuota non asserisce niente. */
 export function missingRouteFailures(expected, emitted, dist) {
-    if (emitted.length === 0) {
+    if (emitted.html.length + emitted.ssr.length === 0) {
         return [`${dist} non contiene nessun .html: nessuna rotta misurata, quindi i budget per rotta non affermano niente`];
     }
     const failures = [];
-    const routes = new Set(emitted);
+    const routes = new Set([...emitted.html, ...emitted.ssr]);
     for (const { route, file } of expected.exact) {
         if (!routes.has(route))
             failures.push(`rotta mancante ${route}: ${file} è prerenderizzata ma non ha emesso HTML`);
     }
-    for (const { pattern, label, file } of expected.patterns) {
-        if (emitted.some((route) => pattern.test(route)))
+    for (const page of expected.patterns) {
+        if (emits(page, emitted))
             continue;
-        failures.push(`rotta mancante ${label}: ${file} è prerenderizzata ma getStaticPaths non ha emesso niente`);
+        failures.push(`rotta mancante ${page.label}: ${page.file} è prerenderizzata ma getStaticPaths non ha emesso niente`);
     }
     return failures;
 }
+const SHOWN = 3;
+export const listed = (routes) => routes.length <= SHOWN ? routes.join(', ') : `${routes.slice(0, SHOWN).join(', ')} e altre ${routes.length - SHOWN}`;
+export function disabledRouteFailures(expected, { html, ssr }) {
+    const exact = new Set(expected.exact.map(({ route }) => route));
+    const unexplained = html.filter((route) => !exact.has(route) && !expected.patterns.some(({ pattern }) => pattern.test(route)));
+    return expected.disabled.flatMap(({ pattern, label }) => {
+        if (ssr.includes(label)) {
+            return [
+                `rotta spenta ${label}: è in \`routes.disabled\`, ma la build la rende a richiesta, e si spegne solo una pagina prerenderizzata`,
+            ];
+        }
+        const routes = unexplained.filter((route) => pattern.test(route)).sort();
+        if (routes.length === 0)
+            return [];
+        return [`rotta spenta ${label}: è in \`routes.disabled\`, ma la build ha emesso ${listed(routes)}`];
+    });
+}
+export function unknownDisabled(expected, disabled = []) {
+    const known = new Set(expected.disabled.map(({ label }) => label));
+    return disabled.filter((label) => !known.has(label));
+}
 /** I pattern dinamici che `officina.config.ts` non ha ancora mandato nessuno a visitare. */
 export function missingRepresentatives(expected, representatives = {}) {
     return expected.patterns

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

@@ -10,3 +10,4 @@ export type SsrRoute = {
     unknownIslands: string[];
 };
 export declare function ssrRoutes(files: readonly ServerFile[]): SsrRoute[] | null;
+export declare function onDemandPatterns(files: readonly ServerFile[]): RegExp[] | null;

package/dist/lib/vercel-build.js

@@ -1,4 +1,5 @@
 import { posix } from 'node:path';
+import { routePattern } from './routes.js';
 const MANIFEST_CALL = 'deserializeManifest({';
 const ASSET = /^(?:.*\/)?_astro\/([^/?#]+\.js)(?:[?#].*)?$/;
 const STYLESHEET = /^(?:.*\/)?_astro\/([^?#]+\.css)(?:[?#].*)?$/;
@@ -102,14 +103,36 @@ function ssrPage({ scripts = [], styles, routeData }) {
     const { route, component } = routeData;
     return typeof route === 'string' && typeof component === 'string' ? [{ scripts, styles, route, component }] : [];
 }
-export function ssrRoutes(files) {
-    for (const file of files) {
-        const manifest = parseManifest(file.source);
+function firstManifest(files) {
+    for (const host of files) {
+        const manifest = parseManifest(host.source);
         if (manifest !== null)
-            return routesOf(file, manifest, files);
+            return { host, manifest };
     }
     return null;
 }
+export function ssrRoutes(files) {
+    const found = firstManifest(files);
+    return found === null ? null : routesOf(found.host, found.manifest, files);
+}
+// `routePattern` non legge i segmenti misti (`[slug].md`, `post-[id]`), che il pattern del manifest di Astro sì.
+function astroPattern(route, pattern) {
+    if (typeof pattern === 'string') {
+        try {
+            return new RegExp(pattern);
+        }
+        catch { }
+    }
+    return routePattern(route);
+}
+export function onDemandPatterns(files) {
+    const found = firstManifest(files);
+    if (found === null)
+        return null;
+    return (found.manifest.routes ?? []).flatMap(({ routeData }) => routeData?.prerender === false && typeof routeData.route === 'string'
+        ? [astroPattern(routeData.route, routeData.pattern)]
+        : []);
+}
 function routesOf(host, manifest, files) {
     const sources = new Map(files.map((file) => [file.path, file.source]));
     const chunks = pageChunks(host);

package/package.json

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