@elia97/officina 0.2.0 → 0.3.0

package/dist/lib/bundle-budget.js

@@ -0,0 +1,50 @@
+// 20 KB è ~1,5× la rotta più pesante misurata nello starter (/contatti, 13,4 KB gz).
+const DEFAULT_BUDGET = { label: 'default', matches: () => true, maxGzip: 20 * 1024 };
+/** Le classi del progetto vengono prima, nell'ordine in cui `officina.config.ts` le dichiara. */
+export function budgetFor(route, budgets = []) {
+    /* v8 ignore next -- DEFAULT_BUDGET accetta ogni rotta, quindi find() non torna mai undefined */
+    return [...budgets, DEFAULT_BUDGET].find((budget) => budget.matches(route)) ?? DEFAULT_BUDGET;
+}
+const captured = (source, pattern, group) => new Set([...source.matchAll(pattern)].map((match) => match[group]).filter((name) => name !== undefined));
+/** Rollup racchiude gli specificatori statici con `"` e i dinamici in un template literal. */
+export function parseEdges(source) {
+    return {
+        static: captured(source, /(?:from|import)\s*(["'`])\.\/([^"'`]+\.js)\1/g, 2),
+        dynamic: captured(source, /import\(\s*(["'`])\.\/([^"'`]+\.js)\1\s*\)/g, 2),
+    };
+}
+export function htmlEntries(html) {
+    return [...captured(html, /(?:src|href)="\/_astro\/([^"]+\.js)"/g, 1)];
+}
+export function staticClosure(entries, chunks) {
+    const seen = new Set();
+    const queue = [...entries];
+    while (queue.length > 0) {
+        const name = queue.pop();
+        if (name === undefined || seen.has(name))
+            continue;
+        const chunk = chunks.get(name);
+        if (chunk === undefined)
+            continue;
+        seen.add(name);
+        queue.push(...chunk.static);
+    }
+    return seen;
+}
+export function deferredClosure(reached, chunks) {
+    const entries = [...reached].flatMap((name) => [...(chunks.get(name)?.dynamic ?? [])]);
+    return new Set([...staticClosure(entries, chunks)].filter((name) => !reached.has(name)));
+}
+export const CSS_BUDGET_GZIP = 12 * 1024;
+export function heaviestStylesheet(sheets) {
+    return sheets.reduce((worst, sheet) => (worst && worst.gzip >= sheet.gzip ? worst : sheet), null);
+}
+// Astro emette un foglio di stile per gruppo di pagine e una rotta ne collega esattamente uno,
+// quindi la loro somma è fatta di byte che nessun visitatore scarica mai insieme.
+export function cssBudgetFailure(sheets, maxGzip = CSS_BUDGET_GZIP) {
+    const heaviest = heaviestStylesheet(sheets);
+    if (heaviest === null || heaviest.gzip <= maxGzip)
+        return null;
+    const over = heaviest.gzip - maxGzip;
+    return `CSS ${(heaviest.gzip / 1024).toFixed(1)} KB gz > ${(maxGzip / 1024).toFixed(1)} KB (+${(over / 1024).toFixed(1)} KB) in ${heaviest.file}`;
+}

package/dist/lib/check-comments.d.ts

@@ -0,0 +1,10 @@
+import type { Hit } from './cli.ts';
+import { type Line } from './comment-syntax.ts';
+export interface FileReport {
+    findings: Hit[];
+    comments: number;
+    total: number;
+}
+export declare const SCANNED: RegExp;
+export declare function report(file: string, lines: Line[]): FileReport;
+export declare function isNoisy({ comments, total }: FileReport): boolean;

package/dist/lib/check-language.d.ts

@@ -0,0 +1,11 @@
+import type { Hit } from './cli.ts';
+export declare function isScanned(path: string): boolean;
+export interface Tally {
+    italian: number;
+    english: number;
+}
+export declare function tally(prose: string): Tally;
+export type Verdict = 'english' | 'italian' | 'undecided';
+export declare function classify({ italian, english }: Tally, minHits?: number): Verdict;
+/** In un sorgente la prosa sta solo nei commenti: il codice è inglese per costruzione. */
+export declare function findingsFor(path: string, source: string): Hit[];

package/dist/lib/check-placeholders.d.ts

@@ -0,0 +1,6 @@
+import { type Finding, type Hit } from './cli.ts';
+type EnvHit = Omit<Finding, 'path' | 'severity'>;
+export declare function placeholderSources(): string[];
+export declare function sourceFindings(source: string): Hit[];
+export declare function envFindings(content: string): EnvHit[];
+export {};

package/dist/lib/check-roadmap.d.ts

@@ -0,0 +1,30 @@
+import type { Hit } from './cli.ts';
+export interface Row {
+    line: number;
+    number: number;
+    name: string;
+    phase: number;
+    days: number;
+}
+export interface Subtotal {
+    line: number;
+    label: string;
+    phase: number | null;
+    days: number;
+}
+export interface Section {
+    line: number;
+    number: number;
+    name: string;
+    phase: number;
+    days: number;
+}
+/** «1,5» è una giornata e mezza. Una cella vuota non è zero giornate: `Number('')` sarebbe 0. */
+export declare function parseDays(raw: string): number;
+/** Le righe numerate della tabella Status: una per milestone. */
+export declare function statusRows(source: string): Row[];
+/** Le righe di somma: un subtotale per fase, più il totale. */
+export declare function subtotals(source: string): Subtotal[];
+/** Le sezioni `## Milestone N`, con la fase e le giornate della loro testata. */
+export declare function sections(source: string): Section[];
+export declare function findingsFor(source: string): Hit[];

package/dist/lib/check-routes.d.ts

@@ -0,0 +1,6 @@
+import type { Hit } from './cli.ts';
+export declare const isScanned: (path: string) => boolean;
+export declare function normalizeTitle(raw: string): string;
+export declare function headings(source: string): string[];
+export declare function resolveTarget(from: string, cited: string): string;
+export declare function findingsFor(path: string, source: string): Hit[];

package/dist/lib/cli.d.ts

@@ -0,0 +1,26 @@
+export interface Hit {
+    line: number;
+    message: string;
+}
+export type Finding = {
+    path: string;
+    line?: number;
+    message: string;
+    severity: 'error' | 'warning';
+};
+export declare function cliOptions(args?: string[]): {
+    base?: string;
+    head?: string;
+    strict: boolean;
+    format: string;
+    diff: boolean;
+};
+export type CliOptions = ReturnType<typeof cliOptions>;
+export declare const isGenerated: (path: string) => boolean;
+export declare function scopedPaths(options: CliOptions, isScanned: (path: string) => boolean): string[];
+export declare function printFindings(findings: Finding[], format: string): void;
+export declare function exitCode(findings: Finding[], strict: boolean): number;
+export declare const readLines: (text: string) => {
+    n: number;
+    text: string;
+}[];

package/dist/lib/comment-syntax.d.ts

@@ -0,0 +1,11 @@
+export interface Line {
+    n: number;
+    text: string;
+}
+export interface CommentBlock {
+    lines: Line[];
+    trailing: boolean;
+}
+export type CommentStyle = 'hash' | 'css' | 'slash' | 'astro';
+export declare function styleOf(file: string): CommentStyle;
+export declare function commentBlocks(lines: Line[], style: CommentStyle): CommentBlock[];

package/dist/lib/config.d.ts

@@ -0,0 +1,24 @@
+import type { Budget } from './bundle-budget.ts';
+import type { VerifiedRoute } from './routes.ts';
+import type { SmokeCheck } from './smoke-production.ts';
+export interface OfficinaConfig {
+    /** L'apice di produzione, senza barra finale: lo usa `check smoke` quando non riceve un URL. */
+    siteUrl?: string;
+    icons?: {
+        background: string;
+    };
+    bundle?: {
+        budgets?: readonly Budget[];
+        cssMaxGzip?: number;
+    };
+    smoke?: {
+        securityHeaders?: Record<string, string | null>;
+        nonHtmlRoutes?: readonly VerifiedRoute[];
+        checks?: readonly SmokeCheck[];
+    };
+    analytics?: {
+        linkTracking?: string;
+    };
+}
+export declare const defineConfig: (config: OfficinaConfig) => OfficinaConfig;
+export declare function loadConfig(root: string): Promise<OfficinaConfig>;

package/dist/lib/config.js

@@ -0,0 +1,21 @@
+var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExtension) || function (path, preserveJsx) {
+    if (typeof path === "string" && /^\.\.?\//.test(path)) {
+        return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
+            return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
+        });
+    }
+    return path;
+};
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { pathToFileURL } from 'node:url';
+const CONFIG_FILES = ['officina.config.ts', 'officina.config.mjs', 'officina.config.js'];
+export const defineConfig = (config) => config;
+// Fuori da node_modules Node toglie i tipi da solo: il file del progetto può essere TypeScript.
+export async function loadConfig(root) {
+    const file = CONFIG_FILES.map((name) => join(root, name)).find((path) => existsSync(path));
+    if (file === undefined)
+        return {};
+    const module = await import(__rewriteRelativeImportExtension(pathToFileURL(file).href));
+    return module.default ?? {};
+}

package/dist/lib/contract.d.ts

@@ -0,0 +1,22 @@
+type Requirement = {
+    kind: 'file';
+    path: string;
+    reason: string;
+} | {
+    kind: 'directory';
+    path: string;
+    extension: string;
+    reason: string;
+} | {
+    kind: 'anchor';
+    path: string;
+    text: string;
+    reason: string;
+};
+export declare const CONTRACT: Requirement[];
+export interface ContractGap {
+    path: string;
+    message: string;
+}
+export declare function contractGaps(root: string): ContractGap[];
+export {};

package/dist/lib/git.d.ts

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

package/dist/lib/gtm-container.d.ts

@@ -0,0 +1,41 @@
+export type Macro = {
+    function?: unknown;
+    vtp_name?: unknown;
+};
+export type Tag = {
+    function?: unknown;
+    vtp_eventName?: unknown;
+    vtp_tagId?: unknown;
+};
+export type Predicate = {
+    function?: unknown;
+    arg0?: unknown;
+    arg1?: unknown;
+};
+export type ContainerResource = {
+    macros: Macro[];
+    tags: Tag[];
+    predicates: Predicate[];
+    rules: unknown[][];
+};
+/** Un tag evento GA4 e le condizioni che lo fanno scattare. `unsupported` porta quello che
+ *  il lettore non sa interpretare, così un trigger saltato a metà non risulta mai compreso. */
+export type Trigger = {
+    eventName: string;
+    firesOn: string[];
+    selectors: string[];
+    urlContains: string[];
+    unsupported: string[];
+};
+/** Il container arriva come un solo file JS che contiene un unico letterale `var data = {…}`,
+ *  e a isolarlo è solo un conteggio di graffe che conosce le stringhe: i valori ne contengono. */
+export declare function parseContainerData(source: string): ContainerResource;
+/** L'id del container come lo serve la produzione, incorporato con `define:vars`. Pubblico per
+ *  costruzione, ed è l'unica risposta a "quale container gira su questo host". */
+export declare function extractGtmId(html: string): string;
+/** Le proprietà GA4 che il container configura. Senza nemmeno una, ogni tag evento scatta nel
+ *  vuoto: un elenco vuoto è un fallimento, non una nota. */
+export declare function googleTagIds(container: ContainerResource): string[];
+/** GTM tiene separati tag e condizioni: una regola elenca clausole, con `if` e `unless` che
+ *  nominano predicati e `add` e `block` che nominano tag. Un trigger per regola che aggiunge il tag. */
+export declare function extractTriggers(container: ContainerResource): Trigger[];

package/dist/lib/gtm-container.js

@@ -0,0 +1,145 @@
+// Lettore del gtm.js pubblico di un container GTM. Dati dentro, dati fuori: la fetch, il
+// rapporto e il codice di uscita restano in scripts/verify-analytics-coverage.mjs.
+// Tag evento GA4. Il tag Google vero e proprio (`__googtag`) configura la proprietà e scatta
+// all'inizializzazione: non traccia nessuna superficie, quindi qui non è un trigger.
+const GA4_EVENT_TAG = '__gaawe';
+// Contabilità interna di GTM: ogni listener nativo scrive gli id dei trigger per cui è
+// scattato, e il tag li rilegge con un `_re`. Da parte nostra non c'è niente da verificare.
+const INTERNAL_VARIABLE = 'gtm.triggers';
+const isRecord = (value) => typeof value === 'object' && value !== null && !Array.isArray(value);
+const records = (value) => (Array.isArray(value) ? value.filter(isRecord) : []);
+const arrays = (value) => (Array.isArray(value) ? value.filter(Array.isArray) : []);
+function matchingBrace(source, start) {
+    let depth = 0;
+    let inString = false;
+    let escaped = false;
+    for (let index = start; index < source.length; index++) {
+        const char = source[index];
+        if (inString) {
+            if (escaped)
+                escaped = false;
+            else if (char === '\\')
+                escaped = true;
+            else if (char === '"')
+                inString = false;
+            continue;
+        }
+        if (char === '"')
+            inString = true;
+        else if (char === '{')
+            depth++;
+        else if (char === '}' && --depth === 0)
+            return index + 1;
+    }
+    throw new Error('the container literal never closes — truncated download?');
+}
+/** Il container arriva come un solo file JS che contiene un unico letterale `var data = {…}`,
+ *  e a isolarlo è solo un conteggio di graffe che conosce le stringhe: i valori ne contengono. */
+export function parseContainerData(source) {
+    const marker = source.indexOf('var data = {');
+    if (marker === -1)
+        throw new Error('no `var data = {` in the container — the reader is broken, not the container');
+    const start = source.indexOf('{', marker);
+    // La fetta comincia con una `{`, quindi JSON.parse o solleva un errore o restituisce un oggetto.
+    const parsed = JSON.parse(source.slice(start, matchingBrace(source, start)));
+    if (!isRecord(parsed.resource))
+        throw new Error('the container literal carries no `resource` — the reader is broken');
+    const resource = parsed.resource;
+    return {
+        macros: records(resource.macros),
+        tags: records(resource.tags),
+        predicates: records(resource.predicates),
+        rules: arrays(resource.rules),
+    };
+}
+/** L'id del container come lo serve la produzione, incorporato con `define:vars`. Pubblico per
+ *  costruzione, ed è l'unica risposta a "quale container gira su questo host". */
+export function extractGtmId(html) {
+    const at = html.indexOf('__rsAnalyticsConfig');
+    const block = at === -1 ? '' : html.slice(Math.max(0, html.lastIndexOf('<script', at)), at);
+    const id = /gtmId\s*=\s*"([^"]+)"/.exec(block)?.[1];
+    if (id === undefined)
+        throw new Error('no GTM id in the served markup — tracking is off on this host');
+    return id;
+}
+/** Le proprietà GA4 che il container configura. Senza nemmeno una, ogni tag evento scatta nel
+ *  vuoto: un elenco vuoto è un fallimento, non una nota. */
+export function googleTagIds(container) {
+    const ids = container.tags.filter((tag) => tag.function === '__googtag').map((tag) => tag.vtp_tagId);
+    return [...new Set(ids.filter((id) => typeof id === 'string'))];
+}
+const macroIndex = (arg) => {
+    if (!Array.isArray(arg) || arg[0] !== 'macro')
+        return null;
+    const index = arg[1];
+    return typeof index === 'number' ? index : null;
+};
+/** Cosa legge un predicato: `event` per il nome dell'evento dataLayer (`__e`), altrimenti il
+ *  nome della variabile stessa (`gtm.element`, `gtm.elementUrl`, `gtm.triggers`). */
+function macroKind(macros, index) {
+    const macro = index === null ? undefined : macros[index];
+    if (macro === undefined)
+        return null;
+    if (macro.function === '__e')
+        return 'event';
+    const name = macro.vtp_name;
+    return typeof name === 'string' ? name : null;
+}
+function applyPredicate(trigger, container, index) {
+    const predicate = typeof index === 'number' ? container.predicates[index] : undefined;
+    if (predicate === undefined) {
+        trigger.unsupported.push(`predicate #${String(index)} does not exist`);
+        return;
+    }
+    const fn = predicate.function;
+    const kind = macroKind(container.macros, macroIndex(predicate.arg0));
+    const value = predicate.arg1;
+    if (kind === INTERNAL_VARIABLE)
+        return;
+    const label = `${String(fn)} on ${kind ?? 'an unreadable variable'}`;
+    if (fn === '_eq' && kind === 'event' && typeof value === 'string')
+        trigger.firesOn.push(value);
+    else if (fn === '_css' && kind === 'gtm.element' && typeof value === 'string')
+        trigger.selectors.push(value);
+    else if (fn === '_cn' && kind === 'gtm.elementUrl' && typeof value === 'string')
+        trigger.urlContains.push(value);
+    else
+        trigger.unsupported.push(`${label} = ${JSON.stringify(value)}`);
+}
+const clausesOf = (rule) => rule.filter(Array.isArray).map((clause) => ({ op: clause[0], args: clause.slice(1) }));
+const targets = (clauses, op, tag) => clauses.some((clause) => clause.op === op && clause.args.includes(tag));
+function conditionsOf(clauses, container, trigger) {
+    for (const clause of clauses) {
+        if (clause.op === 'add' || clause.op === 'block')
+            continue;
+        // `unless` nega i suoi predicati; leggerli come requisiti invertirebbe il senso del
+        // trigger, quindi l'intera clausola si dichiara illeggibile.
+        if (clause.op !== 'if') {
+            trigger.unsupported.push(`\`${String(clause.op)}\` clause`);
+            continue;
+        }
+        for (const index of clause.args)
+            applyPredicate(trigger, container, index);
+    }
+}
+/** GTM tiene separati tag e condizioni: una regola elenca clausole, con `if` e `unless` che
+ *  nominano predicati e `add` e `block` che nominano tag. Un trigger per regola che aggiunge il tag. */
+export function extractTriggers(container) {
+    const triggers = [];
+    for (const [tag, definition] of container.tags.entries()) {
+        if (definition.function !== GA4_EVENT_TAG)
+            continue;
+        const name = definition.vtp_eventName;
+        const eventName = typeof name === 'string' ? name : `tag #${String(tag)}`;
+        const rules = container.rules.map(clausesOf);
+        const blocked = rules.some((clauses) => targets(clauses, 'block', tag));
+        for (const clauses of rules.filter((clauses) => targets(clauses, 'add', tag))) {
+            const trigger = { eventName, firesOn: [], selectors: [], urlContains: [], unsupported: [] };
+            if (blocked)
+                trigger.unsupported.push('a `block` rule targets this tag');
+            conditionsOf(clauses, container, trigger);
+            triggers.push(trigger);
+        }
+    }
+    return triggers;
+}

package/dist/lib/icon-specs.d.ts

@@ -0,0 +1,6 @@
+export interface IconSpec {
+    file: string;
+    size: number;
+    purpose: 'any' | 'maskable';
+}
+export declare const ICON_SPECS: readonly IconSpec[];

package/dist/lib/icon-specs.js

@@ -0,0 +1,6 @@
+// Senza sharp: il manifest del sito le confronta con le proprie icone senza caricare il disegnatore.
+export const ICON_SPECS = [
+    { file: 'icon-192.png', size: 192, purpose: 'any' },
+    { file: 'icon-512.png', size: 512, purpose: 'any' },
+    { file: 'icon-maskable-512.png', size: 512, purpose: 'maskable' },
+];

package/dist/lib/icons.d.ts

@@ -0,0 +1,6 @@
+import { type IconSpec } from './icon-specs.ts';
+export declare function renderIcon(svg: Buffer, spec: IconSpec, background: string): Promise<Buffer>;
+export declare function writeIcons(root: string, background: string): Promise<{
+    path: string;
+    bytes: number;
+}[]>;

package/dist/lib/icons.js

@@ -0,0 +1,32 @@
+import { readFileSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import sharp from 'sharp';
+import { ICON_SPECS } from './icon-specs.js';
+// Il launcher ritaglia la maskable: resta intatto solo il cerchio centrale di diametro pari all'80%
+// del lato (W3C Web App Manifest, `purpose`), e il glifo sta nel quadrato inscritto in quel cerchio.
+const MASKABLE_GLYPH_SCALE = 0.8 / Math.SQRT2;
+async function rasterize(svg, side) {
+    const { width } = await sharp(svg).metadata();
+    return sharp(svg, { density: (72 * side) / width })
+        .resize(side, side, { fit: 'contain', background: { r: 0, g: 0, b: 0, alpha: 0 } })
+        .png()
+        .toBuffer();
+}
+export async function renderIcon(svg, spec, background) {
+    const glyphSide = Math.round(spec.purpose === 'maskable' ? spec.size * MASKABLE_GLYPH_SCALE : spec.size);
+    return sharp({ create: { width: spec.size, height: spec.size, channels: 4, background } })
+        .composite([{ input: await rasterize(svg, glyphSide), gravity: 'centre' }])
+        .png()
+        .toBuffer();
+}
+export async function writeIcons(root, background) {
+    const svg = readFileSync(join(root, 'public', 'favicon.svg'));
+    const written = [];
+    for (const spec of ICON_SPECS) {
+        const path = `public/${spec.file}`;
+        const png = await renderIcon(svg, spec, background);
+        writeFileSync(join(root, path), png);
+        written.push({ path, bytes: png.length });
+    }
+    return written;
+}

package/dist/lib/language-words.d.ts

@@ -0,0 +1,2 @@
+export declare const ITALIAN: RegExp;
+export declare const ENGLISH: RegExp;

package/dist/lib/lighthouse.d.ts

@@ -0,0 +1,17 @@
+export interface LighthouseRc {
+    ci: {
+        collect: {
+            url?: string[];
+            numberOfRuns?: number;
+            startServerCommand?: string;
+            startServerReadyPattern?: string;
+            startServerReadyTimeout?: number;
+            settings?: Record<string, unknown>;
+        };
+        upload?: Record<string, unknown>;
+        [section: string]: unknown;
+    };
+}
+export type LighthouseEnv = Partial<Record<'LH_PORT' | 'LH_RUNS' | 'LH_EXTERNAL_SERVER' | 'LH_CHROME_FLAGS' | 'LH_OUT', string>>;
+/** 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

@@ -0,0 +1,23 @@
+const DEFAULT_PORT = '4321';
+/** 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}`) };
+    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) {
+        delete collect.startServerCommand;
+        delete collect.startServerReadyPattern;
+        delete collect.startServerReadyTimeout;
+    }
+    else if (collect.startServerCommand !== undefined) {
+        collect.startServerCommand = collect.startServerCommand.replace(/--listen \d+/, `--listen ${port}`);
+    }
+    if (env.LH_CHROME_FLAGS)
+        collect.settings = { ...collect.settings, chromeFlags: env.LH_CHROME_FLAGS };
+    const ci = { ...rc.ci, collect };
+    if (env.LH_OUT)
+        ci.upload = { target: 'filesystem', outputDir: env.LH_OUT };
+    return { ci };
+}

package/dist/lib/past-tense.d.ts

@@ -0,0 +1 @@
+export declare const PAST_TENSE: RegExp[];

package/dist/lib/routes.d.ts

@@ -0,0 +1,31 @@
+export type PageFile = {
+    file: string;
+    source: string;
+};
+export type Expectations = {
+    exact: {
+        route: string;
+        file: string;
+    }[];
+    patterns: {
+        pattern: RegExp;
+        label: string;
+        file: string;
+    }[];
+    ssr: string[];
+};
+export type VerifiedRoute = {
+    path: string;
+    type: string;
+};
+export declare const ERROR_PAGES: readonly string[];
+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;
+/** [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 auditRoutes(expected: Expectations): string[];
+export declare function smokeRoutes(expected: Expectations, nonHtmlRoutes?: readonly VerifiedRoute[]): VerifiedRoute[];
+export declare function orphanExceptions(expected: Expectations): string[];