@elia97/officina 0.7.0 → 0.8.0

package/README.md

@@ -40,12 +40,16 @@ 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`.
+
 Il motore è uguale per tutti; ciò che cambia da un progetto all'altro sta in un file solo, `officina.config.ts` nella radice:
 
 ```ts
@@ -110,8 +114,8 @@ 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/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/lighthouse` | build equivalente alla produzione e `pnpm run lhci` | trigger, etichetta, `continue-on-error` |
 
@@ -132,6 +136,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/lib/action-manifests.js

@@ -1,3 +1,4 @@
+import { LineCounter, parseDocument } from 'yaml';
 import { readLines } from './cli.js';
 import { isLive } from './workflows.js';
 const EXPRESSION = /\$\{\{[^}]*\}\}/g;
@@ -16,10 +17,20 @@ function lineFindings(text) {
         return context === undefined ? [] : [`\`${context}\` non è un contesto di una composite action: passalo come input`];
     });
 }
+function syntaxFindings(source) {
+    const lineCounter = new LineCounter();
+    return parseDocument(source, { lineCounter, prettyErrors: false }).errors.map(({ message, pos }) => ({
+        line: lineCounter.linePos(pos[0]).line,
+        message: `non è YAML valido: ${message}`,
+    }));
+}
 // Il runner valuta le espressioni del manifesto prima di eseguire qualunque passo: un contesto che una
 // composite action non conosce non è un valore vuoto, è un'action che non si carica.
 export function manifestFindings(manifests) {
-    return manifests.flatMap(({ path, source }) => readLines(source)
-        .filter(({ text }) => isLive(text))
-        .flatMap(({ n, text }) => lineFindings(text).map((message) => ({ path, line: n, message }))));
+    return manifests.flatMap(({ path, source }) => [
+        ...syntaxFindings(source).map((hit) => ({ path, ...hit })),
+        ...readLines(source)
+            .filter(({ text }) => isLive(text))
+            .flatMap(({ n, text }) => lineFindings(text).map((message) => ({ path, line: n, message }))),
+    ]);
 }

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/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/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.0",
+  "version": "0.8.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",
@@ -54,7 +54,7 @@
     "test:pack": "bash scripts/pack-test.sh"
   },
   "devDependencies": {
-    "@biomejs/biome": "2.5.10",
+    "@biomejs/biome": "2.5.14",
     "@types/node": "^26.5.1",
     "@vitest/coverage-v8": "^4.1.11",
     "fallow": "^3.26.0",