@elia97/officina 0.9.1 → 0.11.0

package/dist/lib/bundle-css.js

@@ -0,0 +1,33 @@
+const kb = (bytes) => `${(bytes / 1024).toFixed(1)} KB`;
+export const routeCount = (count) => (count === 1 ? '1 rotta' : `${count} rotte`);
+function overBudget({ stylesheets, gzip, routes }, maxGzip) {
+    const weight = `CSS ${kb(gzip)} > ${kb(maxGzip)} (+${kb(gzip - maxGzip)})`;
+    if (routes.length === 0)
+        return `${stylesheets.join(' + ')}: ${weight}, pesato da solo: nessuna rotta misurata lo collega`;
+    const [first] = [...routes].sort();
+    return `${first}: ${weight} — ${stylesheets.join(' + ')}, su ${routeCount(routes.length)}`;
+}
+export function measureCss(routes, sheets, maxGzip, assets) {
+    const weights = new Map(sheets.map(({ file, gzip }) => [file, gzip]));
+    const groups = new Map();
+    const failures = [];
+    for (const { route, stylesheets } of routes) {
+        const linked = [...new Set(stylesheets)].sort();
+        for (const name of linked.filter((sheet) => !weights.has(sheet)))
+            failures.push(`${route}: il foglio ${name} non è in ${assets}, e il CSS della rotta non si misura per intero`);
+        if (linked.length === 0)
+            continue;
+        const key = linked.join(' + ');
+        const gzip = linked.reduce((sum, sheet) => sum + (weights.get(sheet) ?? 0), 0);
+        const group = groups.get(key) ?? { stylesheets: linked, gzip, routes: [] };
+        group.routes.push(route);
+        groups.set(key, group);
+    }
+    const linkedAnywhere = new Set(routes.flatMap(({ stylesheets }) => stylesheets));
+    for (const { file, gzip } of sheets)
+        if (!linkedAnywhere.has(file))
+            groups.set(file, { stylesheets: [file], gzip, routes: [] });
+    const measured = [...groups.values()].sort((a, b) => b.gzip - a.gzip);
+    failures.push(...measured.filter((group) => group.gzip > maxGzip).map((group) => overBudget(group, maxGzip)));
+    return { groups: measured, failures };
+}

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

@@ -1,6 +1,8 @@
+import { type ServerFile } from './vercel-build.ts';
 export type PageEntries = {
     route: string;
     entries: string[];
+    stylesheets: string[];
 };
 export type SsrReading = {
     pages: PageEntries[];
@@ -9,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'] : [];
@@ -27,9 +27,10 @@ export function readSsr(hasHtml) {
     }
     return {
         ...none,
-        pages: routes.map(({ route, entries }) => ({ route, entries })),
-        failures: routes.flatMap(({ route, unmapped, unknownIslands }) => [
+        pages: routes.map(({ route, entries, stylesheets }) => ({ route, entries, stylesheets: stylesheets ?? [] })),
+        failures: routes.flatMap(({ route, unmapped, unknownIslands, stylesheets }) => [
             ...(unmapped ? [`${route}: nessun chunk server in ${FUNCTIONS}, la misura non coprirebbe le isole`] : []),
+            ...(stylesheets === null ? [`${route}: il manifest non dice quali fogli di stile collega la rotta`] : []),
             ...unknownIslands.map((island) => `${route}: l'isola ${island} non ha un chunk in dist/client/_astro fra quelli del manifest`),
         ]),
         measured: true,

package/dist/lib/check-placeholders.js

@@ -11,8 +11,9 @@ 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)
     ? readdirSync(DICTIONARIES)
         .filter((name) => name.endsWith('.ts'))
@@ -56,7 +57,7 @@ export function envFindings(content, keys) {
         const value = env[key]?.trim();
         const declaration = lines.find(({ text }) => new RegExp(`^\\s*(?:export\\s+)?${key}\\s*=`).test(text));
         if (value === undefined || declaration === undefined) {
-            const message = `${key} non c'è fra le variabili di produzione su Vercel: vale il default di astro.config.mjs`;
+            const message = `${key} non c'è fra le variabili di produzione su Vercel: ${WITHOUT_VALUE}`;
             return [{ severity: 'error', message }];
         }
         const hit = (severity, message) => [
@@ -65,7 +66,7 @@ export function envFindings(content, keys) {
         if (value === SENSITIVE)
             return hit('warning', 'è Sensitive su Vercel: vercel pull non ne scarica il valore, e il deploy non lo può verificare');
         if (value === '')
-            return hit('error', 'è vuota: vale il default di astro.config.mjs');
+            return hit('error', `è vuota: ${WITHOUT_VALUE}`);
         if (TOKEN.test(value) || DOMAIN.test(value))
             return hit('error', 'porta un segnaposto del template');
         return [];

package/dist/lib/check-routes.js

@@ -1,5 +1,8 @@
 import { existsSync, readFileSync } from 'node:fs';
+import { posix } from 'node:path';
+import { blankFences, blankSpans, linkDestinations } from './markdown.js';
 const SCANNED = /\.md$/;
+const ROADMAP = 'docs/ROADMAP.md';
 const IGNORED = [
     // Scritti a runtime dai comandi, gitignored per costruzione.
     /^\.claude\/plans\//,
@@ -7,9 +10,39 @@ const IGNORED = [
     /\.pdf$/,
     /^docs\/sources\//,
 ];
-const PATH_REFERENCE = /`((?:docs|src|scripts|test|public|\.claude|\.github)\/[A-Za-z0-9._/-]+\.[a-z]+)`/g;
+const PATH_REFERENCE = /`((?:docs|src|scripts|test|e2e|public|\.claude|\.github)\/[A-Za-z0-9._/-]+\.[a-z]+)`/g;
+const NAME_REFERENCE = /`([A-Za-z0-9._-]+)`/g;
 // La virgola non delimita: i titoli la contengono.
 const SECTION_REFERENCE = /`([A-Za-z0-9._/-]+\.md)`\s*§\s*([^.·|)§]{1,80})/g;
+const LINK_TEXT = /\[[^[\]]*\]\(/g;
+const ROOT_DOCUMENT = /^[A-Z][A-Z0-9_-]*\.md$/;
+// I file tracciati alla radice di template/vetrina (git ls-files), Markdown esclusi.
+const ROOT_CONFIG = new Set([
+    '.editorconfig',
+    '.env.example',
+    '.fallowrc.jsonc',
+    '.gitignore',
+    '.lighthouserc.json',
+    '.npmrc',
+    '.nvmrc',
+    '.release-please-manifest.json',
+    'astro.config.mjs',
+    'biome.json',
+    'commitlint.config.js',
+    'lefthook.yml',
+    'officina.config.ts',
+    'package.json',
+    'playwright.config.ts',
+    'pnpm-lock.yaml',
+    'pnpm-workspace.yaml',
+    'release-please-config.json',
+    'tsconfig.json',
+    'vercel.json',
+    'vitest.config.ts',
+]);
+const CHANGELOG = /(?:^|\/)CHANGELOG\.md$/;
+const SITE_CONTENT = /^src\/content\//;
+const EXTERNAL = /^(?:[a-z][a-z0-9+.-]*:|#|\/)/i;
 const isIgnored = (path) => IGNORED.some((re) => re.test(path));
 export const isScanned = (path) => SCANNED.test(path) && !isIgnored(path);
 export function normalizeTitle(raw) {
@@ -32,23 +65,37 @@ const resolves = (titles, cited) => titles.some((title) => cited === title || (c
 export function resolveTarget(from, cited) {
     if (cited.includes('/'))
         return cited;
-    const sibling = `${from.slice(0, from.lastIndexOf('/') + 1)}${cited}`;
-    return existsSync(sibling) ? sibling : cited;
+    const candidates = [`${from.slice(0, from.lastIndexOf('/') + 1)}${cited}`, cited, `docs/${cited}`];
+    return candidates.find((candidate) => existsSync(candidate)) ?? cited;
 }
-export function findingsFor(path, source) {
+const references = (text, pattern) => [...text.matchAll(pattern)]
+    .map((match) => ({ index: match.index, target: match[1] }))
+    .filter((reference) => reference.target !== undefined);
+const pathReferences = (flat) => references(flat, PATH_REFERENCE).filter(({ target }) => !target.includes('*'));
+function nameReferences(path, flat) {
+    if (path === ROADMAP || CHANGELOG.test(path) || SITE_CONTENT.test(path))
+        return [];
+    const labels = [...flat.matchAll(LINK_TEXT)].map(({ index, 0: text }) => ({ start: index, end: index + text.length }));
+    const inLabel = (index) => labels.some(({ start, end }) => index > start && index < end);
+    return references(flat, NAME_REFERENCE)
+        .filter(({ index, target }) => (ROOT_DOCUMENT.test(target) || ROOT_CONFIG.has(target)) && !inLabel(index))
+        .map(({ index, target }) => ({ index, target: resolveTarget(path, target) }));
+}
+const linkTarget = (from, destination) => EXTERNAL.test(destination)
+    ? undefined
+    : posix.normalize(posix.join(posix.dirname(from), destination.replace(/[#?].*$/, '')));
+function linkReferences(path, code) {
+    if (SITE_CONTENT.test(path))
+        return [];
+    return linkDestinations(code).flatMap(({ index, destination }) => {
+        const target = linkTarget(path, destination);
+        return target === undefined ? [] : [{ index, target }];
+    });
+}
+const escapes = (target) => target === '..' || target.startsWith('../');
+const isMissing = (target) => !isIgnored(target) && (escapes(target) || !existsSync(target));
+function sectionFindings(path, flat, lineOf, missing) {
     const findings = [];
-    // Un titolo va a capo come qualunque prosa: si cerca su testo continuo. La sostituzione è uno a
-    // uno, quindi gli offset restano quelli del sorgente e la riga si conta da lì.
-    const flat = source.replace(/\n/g, ' ');
-    const lineOf = (index) => source.slice(0, index).split('\n').length;
-    const missingTargets = new Set();
-    for (const match of flat.matchAll(PATH_REFERENCE)) {
-        const target = match[1];
-        if (!target || isIgnored(target) || target.includes('*') || existsSync(target))
-            continue;
-        missingTargets.add(target);
-        findings.push({ line: lineOf(match.index), message: `percorso che non esiste: ${target}` });
-    }
     for (const match of flat.matchAll(SECTION_REFERENCE)) {
         const [, file, title] = match;
         /* v8 ignore next -- i due gruppi sono obbligatori nella regex, ma noUncheckedIndexedAccess pretende la guardia */
@@ -56,7 +103,7 @@ export function findingsFor(path, source) {
             continue;
         const line = lineOf(match.index);
         const target = resolveTarget(path, file);
-        if (isIgnored(target) || missingTargets.has(target))
+        if (isIgnored(target) || missing.has(`${line}:${target}`))
             continue;
         if (!existsSync(target)) {
             findings.push({ line, message: `sezione in un file che non esiste: ${target}` });
@@ -66,5 +113,27 @@ export function findingsFor(path, source) {
         if (!resolves(headings(readFileSync(target, 'utf8')), cited))
             findings.push({ line, message: `sezione che non esiste: ${target} § ${cited}` });
     }
-    return findings.sort((a, b) => a.line - b.line);
+    return findings;
+}
+export function findingsFor(path, source) {
+    const fenced = blankFences(source);
+    // Un titolo va a capo come qualunque prosa: si cerca su testo continuo. La sostituzione è uno a
+    // uno, quindi gli offset restano quelli del sorgente e la riga si conta da lì.
+    const flat = fenced.replace(/\n/g, ' ');
+    const lineOf = (index) => source.slice(0, index).split('\n').length;
+    const missing = new Map();
+    for (const { index, target } of [
+        ...pathReferences(flat),
+        ...nameReferences(path, flat),
+        ...linkReferences(path, blankSpans(fenced)),
+    ]) {
+        const line = lineOf(index);
+        if (isMissing(target))
+            missing.set(`${line}:${target}`, { line, target });
+    }
+    const paths = [...missing.values()].map(({ line, target }) => ({
+        line,
+        message: `percorso che non esiste: ${target}`,
+    }));
+    return [...paths, ...sectionFindings(path, flat, lineOf, new Set(missing.keys()))].sort((a, b) => a.line - b.line);
 }

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/contract.d.ts

@@ -25,6 +25,7 @@ export declare const CONTRACT: Requirement[];
 export interface ContractGap {
     path: string;
     message: string;
+    severity?: 'warning';
 }
 export declare function contractGaps(root: string): ContractGap[];
 export {};

package/dist/lib/dependabot.js

@@ -1,7 +1,8 @@
 import { parse } from 'yaml';
 const DEPENDABOT = '.github/dependabot.yml';
 const PACKAGE = '@elia97/officina';
-const ACTIONS = 'Elia97/officina/*';
+const ACTIONS = 'Elia97/officina';
+const PATH_FILTER = `${ACTIONS}/*`;
 const GROUP_ONLY = ['commit-message', 'open-pull-requests-limit'];
 const gap = (message) => ({ path: DEPENDABOT, message });
 const isRecord = (value) => typeof value === 'object' && value !== null && !Array.isArray(value);
@@ -32,6 +33,16 @@ const coverageGaps = (updates) => [
 ]
     .filter(({ ecosystem, needle }) => !inGroup(updates).some((u) => u['package-ecosystem'] === ecosystem && covers(u, needle)))
     .map(({ needle, reason }) => gap(`nessuna voce del gruppo copre \`${needle}\`: ${reason}`));
+const strings = (value) => {
+    if (typeof value === 'string')
+        return [value];
+    return typeof value === 'object' && value !== null ? Object.values(value).flatMap(strings) : [];
+};
+const pathFilterGaps = (document) => strings(document).includes(PATH_FILTER)
+    ? [
+        gap(`\`${PATH_FILTER}\` non corrisponde a nessuna dipendenza: Dependabot chiama le action \`${ACTIONS}\`, senza la sottocartella, e il filtro va corretto ovunque compaia`),
+    ]
+    : [];
 // `patterns` restringe l'intera voce: il resto dell'ecosistema smette di aggiornarsi e nessun check diventa rosso.
 function restGaps(updates) {
     const restrained = inGroup(updates).filter((update) => (update.patterns ?? []).length > 0);
@@ -55,5 +66,11 @@ export function dependabotGaps({ read: readFile }) {
     if (typeof document === 'string')
         return [gap(document)];
     const updates = document.updates ?? [];
-    return [...groupGaps(document, updates), ...misplacedGaps(updates), ...coverageGaps(updates), ...restGaps(updates)];
+    return [
+        ...groupGaps(document, updates),
+        ...misplacedGaps(updates),
+        ...coverageGaps(updates),
+        ...pathFilterGaps(document),
+        ...restGaps(updates),
+    ];
 }

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/markdown.d.ts

@@ -0,0 +1,7 @@
+export interface Destination {
+    index: number;
+    destination: string;
+}
+export declare function blankFences(source: string): string;
+export declare const blankSpans: (text: string) => string;
+export declare const linkDestinations: (text: string) => Destination[];

package/dist/lib/markdown.js

@@ -0,0 +1,41 @@
+// CommonMark § 4.5: recinto di tre o più ` o ~ (rientro fino a 3 spazi), chiuso da una riga dello stesso carattere,
+// lunga almeno quanto l'apertura.
+const FENCE = /^ {0,3}(`{3,}|~{3,})/;
+// CommonMark § 6.1: lo span si chiude alla prima stringa di apici inversi di pari lunghezza; una riga vuota lo interrompe.
+const SPAN = /(?<!`)(`+)(?!`)((?:(?!\n[ \t]*\n)[\s\S])*?)(?<!`)\1(?!`)/g;
+// CommonMark § 6.3: destinazione fra <> o senza spazi (parentesi bilanciate, qui un solo livello); titolo fra "", '' o ().
+const INLINE = /\]\(\s*(?:<([^>\n]*)>|((?:[^()\s\\]|\\.|\([^()\s]*\))*))(?:\s+(?:"[^"]*"|'[^']*'|\([^()]*\)))?\s*\)/g;
+const DEFINITION = /^ {0,3}\[[^\]\n]+\]:[ \t]*(?:<([^>\n]*)>|(\S+))/gm;
+const spaces = (text) => text.replace(/[^\n]/g, ' ');
+export function blankFences(source) {
+    let fence;
+    return source
+        .split('\n')
+        .map((line) => {
+        const run = FENCE.exec(line)?.[1];
+        if (fence === undefined) {
+            if (run === undefined)
+                return line;
+            fence = run;
+        }
+        else if (run !== undefined && run[0] === fence[0] && run.length >= fence.length && line.trim() === run) {
+            fence = undefined;
+        }
+        return spaces(line);
+    })
+        .join('\n');
+}
+export const blankSpans = (text) => text.replace(SPAN, spaces);
+const unescaped = (text) => text.replace(/\\(.)/g, '$1');
+function decoded(text) {
+    try {
+        return decodeURIComponent(text);
+    }
+    catch {
+        return text;
+    }
+}
+export const linkDestinations = (text) => [...text.matchAll(INLINE), ...text.matchAll(DEFINITION)].map((match) => ({
+    index: match.index,
+    destination: decoded(unescaped((match[1] ?? match[2]))),
+}));

package/dist/lib/past-tense.js

@@ -13,7 +13,7 @@ export const PAST_TENSE = [
     // "non più di 3" è una quantità, non un cambiamento.
     phrase(['non (?:è |viene |serve )?più(?! di)']),
     phrase(["ora (?:è|invece|lo|la|il|si|c'è|non)", 'adesso', 'per ora', 'temporaneamente']),
-    phrase(['sostituisce', 'al posto di', 'vecchi[oa]']),
+    phrase(['sostituisce', 'vecchi[oa]']),
     phrase(['used to', 'previously', 'no longer', 'replaces the', 'replaced by', 'removed in', 'for now', 'temporarily']),
     /#\d{1,3}(?!\d)/,
 ];

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 {};