@elia97/officina 0.2.0 → 0.4.0

package/README.md

@@ -18,18 +18,107 @@ pnpm add -D @elia97/officina
     "check:routes": "officina check routes",
     "check:roadmap": "officina check roadmap",
     "check:placeholders": "officina check placeholders",
-    "check:vercel-cli": "officina check vercel-cli",
+    "perf:bundle": "officina check bundle",
+    "smoke:prod": "officina check smoke",
+    "analytics:verify": "officina check analytics",
+    "lhci": "officina check lighthouse",
+    "lhci:local": "officina check lighthouse --local",
     "gen": "officina gen",
     "gen:section": "officina gen section",
     "gen:page": "officina gen page",
     "gen:component": "officina gen component",
     "gen:collection": "officina gen collection",
+    "gen:icons": "officina gen icons",
     "doctor": "officina doctor"
   }
 }
 ```
 
-I gate leggono dalla cartella corrente, che deve essere la radice del repository. Opzioni comuni: `--diff`, `--base <ref>`, `--head <ref>`, `--strict`, `--format text|github`.
+I gate leggono dalla cartella corrente, che deve essere la radice del repository. Opzioni comuni dei gate sui sorgenti: `--diff`, `--base <ref>`, `--head <ref>`, `--strict`, `--format text|github`.
+
+## Verifiche di build e di produzione
+
+| 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 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` |
+| `gen icons` | le icone del manifest, disegnate dal favicon SVG in `public/` del progetto | — |
+
+Il motore è uguale per tutti; ciò che cambia da un progetto all'altro sta in un file solo, `officina.config.ts` nella radice:
+
+```ts
+import { type Budget, DEFAULT_CHECKS, defineConfig, type SmokeCheck } from '@elia97/officina'
+
+import { SITE } from './src/lib/site.ts'
+
+const motion: Budget = { label: 'motion', matches: (route) => route === '/', maxGzip: 72 * 1024 }
+const checkLanguageRedirect: SmokeCheck = async ({ get, baseUrl }) => []
+
+export default defineConfig({
+  siteUrl: SITE.url,
+  icons: { background: SITE.themeColor.light },
+  bundle: { budgets: [motion], cssMaxGzip: 14 * 1024 },
+  smoke: { checks: [...DEFAULT_CHECKS, checkLanguageRedirect] },
+})
+```
+
+Ogni voce è facoltativa, tranne `siteUrl` per `check smoke` e `icons.background` per `gen icons`. I budget del progetto vengono prima del default di 20 KB, nell'ordine in cui sono scritti; `smoke.checks` sostituisce la lista del pacchetto, quindi chi non ha BotID la ricompone senza `checkBotIdChallenge`; `smoke.securityHeaders` e `smoke.nonHtmlRoutes` sostituiscono `SECURITY_HEADERS` e `NON_HTML_ROUTES`. Il file lo carica Node, che fuori da `node_modules` toglie i tipi da sé: niente `enum`, niente alias `@/`.
+
+`sharp` è una dipendenza facoltativa del progetto, non del pacchetto: serve solo a `gen icons`, che senza lo dice ed esce 1. `ICON_SPECS` si importa senza caricarlo, per il test che confronta le icone con il manifest del sito.
+
+## Preset di configurazione
+
+Le regole che valgono per tutti i progetti stanno nel pacchetto; il progetto estende e tiene solo le proprie eccezioni.
+
+```json
+{
+  "$schema": "https://biomejs.dev/schemas/2.5.10/schema.json",
+  "extends": ["@elia97/officina/biome"]
+}
+```
+
+```yaml
+# lefthook.yml
+extends:
+  - node_modules/@elia97/officina/presets/lefthook.yml
+```
+
+## Action per i workflow
+
+I passi dei workflow stanno in `actions/` di questo repository, come composite action: girano dentro il job di chi le chiama, quindi il nome del check, l'`environment` e i segreti restano del progetto. Il riferimento va fissato a un tag di versione o a uno SHA, mai a `@main`.
+
+| 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/deploy` | risoluzione del tag, gate, `vercel pull`, `build`, `deploy`, smoke; espone `url` | trigger, `environment`, i tre segreti Vercel nell'`env` del job, il job che controlla se i segreti ci sono |
+| `actions/lighthouse` | build equivalente alla produzione e `pnpm run lhci` | trigger, etichetta, `continue-on-error` |
+
+```yaml
+jobs:
+  deploy:
+    runs-on: ubuntu-latest
+    environment:
+      name: production
+      url: ${{ steps.deploy.outputs.url }}
+    env:
+      VERCEL_TOKEN: ${{ secrets.VERCEL_TOKEN }}
+      VERCEL_ORG_ID: ${{ secrets.VERCEL_ORG_ID }}
+      VERCEL_PROJECT_ID: ${{ secrets.VERCEL_PROJECT_ID }}
+    steps:
+      - uses: Elia97/officina/actions/deploy@v0.4.0
+        id: deploy
+        with:
+          ref: ${{ inputs.ref }}
+```
+
+Il pin `vercel@<major>` sta in un posto solo, `actions/deploy/action.yml`: lo guarda ogni lunedì `.github/workflows/vercel-cli.yml` di questo repository, con `officina check vercel-cli actions/deploy/action.yml`.
+
+## doctor
+
+`officina doctor` dice, in qualunque repository, cosa manca perché il progetto prenda tutto da fuori: i punti di aggancio dei generatori, gli script e le dipendenze di `package.json`, i residui di ciò che è uscito (copia del metodo, script, documenti commerciali), i preset, i workflow con il riferimento fissato, `officina.config.ts`. Sta dentro `ci`, quindi un progetto allineato non torna indietro senza che il gate lo dica.
 
 ## Sviluppo
 
@@ -53,7 +142,7 @@ pnpm publish     # prepublishOnly lancia typecheck, test e build
 
 `officina gen` avvolge plop con i generatori e i template del pacchetto, e scrive nel progetto da cui lo lanci: `section`, `page`, `component`, `collection`. `plop` e `ts-morph` sono dipendenze del pacchetto, non del progetto.
 
-I generatori scrivono codice che deve incastrarsi nello scaffold, quindi il progetto deve avere i punti di aggancio che si aspettano: i moduli che il codice generato importa e i file in cui iniettano. L'elenco è `src/lib/contract.ts`, e `officina doctor` dice, in qualunque repository, cosa manca. Finché manca qualcosa il pre-volo del generatore si ferma prima di scrivere un solo file.
+I generatori scrivono codice che deve incastrarsi nello scaffold, quindi il progetto deve avere i punti di aggancio che si aspettano: i moduli che il codice generato importa e i file in cui iniettano. L'elenco è `src/lib/contract.ts`, ed è la prima sezione di `officina doctor`. Finché manca qualcosa il pre-volo del generatore si ferma prima di scrivere un solo file.
 
 Un progetto aggiunge i propri generatori con un file `officina.generators.mjs` nella radice, con la firma di un plopfile: `export default function (plop)`.
 
@@ -61,4 +150,4 @@ I test dei generatori girano sui punti di aggancio del progetto di prova, copiat
 
 ## Cosa arriverà
 
-Bundle budget, smoke di produzione, lighthouse, verifica analytics e icone. Poi i preset di `ecommerce` e `monorepo`.
+I preset di `ecommerce` e `monorepo`.

package/dist/bin.d.ts

@@ -0,0 +1,8 @@
+#!/usr/bin/env node
+type Main = (args?: string[]) => number | Promise<number>;
+type Loader = () => Promise<{
+    main: Main;
+}>;
+export declare const CHECKS: Record<string, Loader>;
+export declare function run(argv: string[]): Promise<number>;
+export {};

package/dist/bin.js

@@ -1,26 +1,35 @@
 #!/usr/bin/env node
 import process from 'node:process';
 // Un modulo per gate, caricato solo quando serve: `officina check routes` non paga il costo
-// degli altri cinque.
+// degli altri.
 export const CHECKS = {
+    analytics: () => import('./checks/analytics.js'),
+    bundle: () => import('./checks/bundle.js'),
     comments: () => import('./checks/comments.js'),
     language: () => import('./checks/language.js'),
+    lighthouse: () => import('./checks/lighthouse.js'),
     placeholders: () => import('./checks/placeholders.js'),
     roadmap: () => import('./checks/roadmap.js'),
     routes: () => import('./checks/routes.js'),
+    smoke: () => import('./checks/smoke.js'),
     'vercel-cli': () => import('./checks/vercel-cli.js'),
 };
 const USAGE = `Uso:
   officina check <gate> [opzioni]   gate: ${Object.keys(CHECKS).join(', ')}
   officina gen [generatore]         section, page, component, collection, più quelli del progetto
+  officina gen icons                le icone del manifest da public/favicon.svg
   officina doctor                   cosa manca al progetto perché i generatori funzionino
 
-Opzioni dei gate: --diff, --base <ref>, --head <ref>, --strict, --format text|github
+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]
+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.
 const GROUPS = {
     check: ([name = '', ...rest]) => ({ load: CHECKS[name], args: rest }),
-    gen: (args) => ({ load: () => import('./gen/run.js'), args }),
+    gen: (args) => args[0] === 'icons'
+        ? { load: () => import('./gen/icons.js'), args: args.slice(1) }
+        : { load: () => import('./gen/run.js'), args },
     doctor: (args) => ({ load: () => import('./checks/doctor.js'), args }),
 };
 export async function run(argv) {

package/dist/checks/analytics.d.ts

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

package/dist/checks/analytics.js

@@ -0,0 +1,48 @@
+#!/usr/bin/env node
+// Il container GTM vivo scatta sugli eventi che questo sito emette? Legge il gtm.js pubblico
+// del container: nessuna credenziale, niente da scrivere.
+import { readFileSync } from 'node:fs';
+import process from 'node:process';
+import { coverageOf, extractLinkEvents } from '../lib/analytics-coverage.js';
+import { loadConfig } from '../lib/config.js';
+import { extractTriggers, googleTagIds, parseContainerData } from '../lib/gtm-container.js';
+const LINK_TRACKING = 'src/lib/analytics/link-tracking.ts';
+const TIMEOUT_MS = 15_000;
+function resolveGtmId(args) {
+    const gtmId = args[0] ?? process.env.PUBLIC_GTM_ID ?? '';
+    return /^GTM-[A-Z0-9]+$/.test(gtmId) ? gtmId : null;
+}
+function reportCoverage(coverage) {
+    for (const { event, prefix, covered } of coverage) {
+        console.log(`  ${covered ? '✓' : '✗'} ${event.padEnd(16)} (${prefix})`);
+    }
+    const missing = coverage.filter(({ covered }) => !covered);
+    if (missing.length > 0) {
+        console.error(`\n✗ ${missing.length} evento/i che il sito emette e nessun trigger ascolta.`);
+        return 1;
+    }
+    console.log('\n✓ Ogni evento che il sito emette ha un trigger.');
+    return 0;
+}
+export async function main(args = []) {
+    const { analytics = {} } = await loadConfig(process.cwd());
+    const gtmId = resolveGtmId(args);
+    if (gtmId === null) {
+        console.log('Nessun container GTM da controllare: passane uno come argomento o imposta PUBLIC_GTM_ID.');
+        return 0;
+    }
+    const response = await fetch(`https://www.googletagmanager.com/gtm.js?id=${gtmId}`, {
+        signal: AbortSignal.timeout(TIMEOUT_MS),
+    });
+    if (!response.ok) {
+        console.error(`✗ container ${gtmId} illeggibile: HTTP ${response.status}`);
+        return 1;
+    }
+    const container = parseContainerData(await response.text());
+    const source = readFileSync(analytics.linkTracking ?? LINK_TRACKING, 'utf8');
+    const coverage = coverageOf(extractLinkEvents(source), extractTriggers(container));
+    console.log(`\nGTM ${gtmId} — ID di misurazione: ${googleTagIds(container).join(', ') || '—'}\n`);
+    return reportCoverage(coverage);
+}
+if (import.meta.main)
+    process.exit(await main(process.argv.slice(2)));

package/dist/checks/bundle.d.ts

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

package/dist/checks/bundle.js

@@ -0,0 +1,98 @@
+#!/usr/bin/env node
+// Gate del budget di bundle su dist/client — richiede un `astro build` completato.
+import { readdirSync, readFileSync } from 'node:fs';
+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 { loadConfig } from '../lib/config.js';
+import { expectedRoutes, filesWithExtension, missingRouteFailures, readPageFiles, routeOf, } from '../lib/routes.js';
+const DIST = 'dist/client';
+const ASSETS = join(DIST, '_astro');
+const PAGES = 'src/pages';
+const gz = (bytes) => `${(bytes / 1024).toFixed(1)} KB`;
+function readStylesheets() {
+    return readdirSync(ASSETS)
+        .filter((f) => f.endsWith('.css'))
+        .map((file) => ({ file, gzip: gzipSync(readFileSync(join(ASSETS, file))).length }));
+}
+function readChunks() {
+    const chunks = new Map();
+    for (const name of readdirSync(ASSETS).filter((f) => f.endsWith('.js'))) {
+        const raw = readFileSync(join(ASSETS, name));
+        chunks.set(name, { gzip: gzipSync(raw).length, ...parseEdges(raw.toString('utf8')) });
+    }
+    return chunks;
+}
+function measurePages(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 = staticClosure(htmlEntries(readFileSync(htmlPath, 'utf8')), chunks);
+        return {
+            route,
+            gzip: total(reached),
+            deferredGzip: total(deferredClosure(reached, chunks)),
+            budget: budgetFor(route, budgets),
+        };
+    })
+        .sort((a, b) => b.gzip - a.gzip);
+}
+function overBudgetFailures(pages) {
+    return pages
+        .filter((page) => page.gzip > page.budget.maxGzip)
+        .map((page) => {
+        const over = page.gzip - page.budget.maxGzip;
+        return `${page.route}: ${gz(page.gzip)} > ${gz(page.budget.maxGzip)} (+${gz(over)})`;
+    });
+}
+function printPages(pages, width) {
+    console.log('\nBudget di bundle — JS del client per rotta (gzip, chiusura statica)\n');
+    console.log(`${'ROTTA'.padEnd(width)}   ${'STATICO'.padStart(9)}   ${'BUDGET'.padStart(9)}   ${'DIFFERITO'.padStart(9)}`);
+    for (const page of pages) {
+        const deferred = page.deferredGzip > 0 ? gz(page.deferredGzip) : '—';
+        const line = `${page.route.padEnd(width)}   ${gz(page.gzip).padStart(9)}   ${gz(page.budget.maxGzip).padStart(9)}   ${deferred.padStart(9)}`;
+        console.log(page.gzip > page.budget.maxGzip ? `${line}  ✗` : line);
+    }
+    console.log('\nDIFFERITO = raggiungibile solo da `await import()` (caricato dopo il primo paint, dietro una guardia a runtime).');
+}
+function printStylesheets(stylesheets, cssMaxGzip, failed, width) {
+    const worst = heaviestStylesheet(stylesheets);
+    console.log(`\nCSS (blocca il rendering: il foglio più pesante che una rotta collega)`);
+    for (const sheet of [...stylesheets].sort((a, b) => b.gzip - a.gzip)) {
+        const mark = sheet === worst && failed ? '  ✗' : '';
+        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)
+        return;
+    console.log(`\nNOTA  ${expected.ssr.length} pagina/e con \`export const prerender = false\`, fuori da questo budget:`);
+    for (const file of expected.ssr)
+        console.log(`      - ${file}`);
+}
+export async function main() {
+    const { bundle = {} } = await loadConfig(process.cwd());
+    const cssMaxGzip = bundle.cssMaxGzip ?? CSS_BUDGET_GZIP;
+    const pages = measurePages(readChunks(), bundle.budgets ?? []);
+    const expected = expectedRoutes(readPageFiles(PAGES), PAGES);
+    const failures = missingRouteFailures(expected, pages.map((page) => page.route), DIST);
+    failures.push(...overBudgetFailures(pages));
+    const width = Math.max('ROTTA'.length, ...pages.map((p) => p.route.length));
+    printPages(pages, width);
+    const stylesheets = readStylesheets();
+    const cssFailure = cssBudgetFailure(stylesheets, cssMaxGzip);
+    if (cssFailure)
+        failures.push(cssFailure);
+    printStylesheets(stylesheets, cssMaxGzip, cssFailure !== null, width);
+    printSsrNote(expected);
+    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');
+    return 0;
+}
+if (import.meta.main)
+    process.exit(await main());

package/dist/checks/comments.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export declare function main(args?: string[]): number;

package/dist/checks/doctor.d.ts

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

package/dist/checks/doctor.js

@@ -1,15 +1,52 @@
 #!/usr/bin/env node
+import { existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
 import process from 'node:process';
+import { configGaps, dependencyGaps, leftoverGaps, presetGaps, scriptGaps, workflowGaps, } from '../lib/alignment.js';
 import { cliOptions, exitCode, printFindings } from '../lib/cli.js';
-import { CONTRACT, contractGaps } from '../lib/contract.js';
-export function main() {
-    const findings = contractGaps(process.cwd()).map((gap) => ({ ...gap, severity: 'error' }));
-    console.log(`\nofficina doctor — ${CONTRACT.length} punti di aggancio dei generatori\n`);
-    printFindings(findings, cliOptions([]).format);
+import { findConfigFile, loadConfig } from '../lib/config.js';
+import { contractGaps } from '../lib/contract.js';
+import { trackedAndUntracked } from '../lib/git.js';
+function projectFiles(root) {
+    return {
+        paths: trackedAndUntracked(),
+        read: (path) => (existsSync(join(root, path)) ? readFileSync(join(root, path), 'utf8') : undefined),
+    };
+}
+async function loadedConfig(root) {
+    if (findConfigFile(root) === undefined)
+        return undefined;
+    try {
+        return await loadConfig(root);
+    }
+    catch (error) {
+        return error instanceof Error ? error : new Error(String(error));
+    }
+}
+export async function main() {
+    const root = process.cwd();
+    const files = projectFiles(root);
+    const manifest = JSON.parse(files.read('package.json') ?? '{}');
+    const sections = [
+        ['punti di aggancio dei generatori', contractGaps(root)],
+        ['script e dipendenze di package.json', [...scriptGaps(manifest), ...dependencyGaps(manifest)]],
+        ['residui di ciò che è uscito dal repository', leftoverGaps(files)],
+        ['preset di configurazione', presetGaps(files)],
+        ['workflow di GitHub', workflowGaps(files)],
+        ['officina.config.ts', configGaps(await loadedConfig(root))],
+    ];
+    console.log('\nofficina doctor — cosa manca al progetto per prendere tutto da fuori\n');
+    const findings = [];
+    for (const [title, gaps] of sections) {
+        console.log(gaps.length === 0 ? `  ✓ ${title}` : `  ${title}: ${gaps.length}`);
+        const sectionFindings = gaps.map((gap) => ({ ...gap, severity: 'error' }));
+        printFindings(sectionFindings, cliOptions([]).format);
+        findings.push(...sectionFindings);
+    }
     console.log(findings.length === 0
-        ? '  Il progetto ha tutto quello che i generatori si aspettano.\n'
-        : `\n  ${findings.length} su ${CONTRACT.length} da sistemare prima che \`officina gen\` scriva codice che compila.\n`);
+        ? '\n  Il progetto è allineato: metodo, gate, generatori e verifiche arrivano da fuori.\n'
+        : `\n  ${findings.length} da sistemare.\n`);
     return exitCode(findings, false);
 }
 if (import.meta.main)
-    process.exit(main());
+    process.exit(await main());

package/dist/checks/language.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export declare function main(args?: string[]): number;

package/dist/checks/lighthouse.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export declare function main(args?: string[]): number;

package/dist/checks/lighthouse.js

@@ -0,0 +1,37 @@
+#!/usr/bin/env node
+import { spawnSync } from 'node:child_process';
+import { mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import process from 'node:process';
+import { fileURLToPath } from 'node:url';
+import { lighthouseConfig } from '../lib/lighthouse.js';
+import { auditRoutes, expectedRoutes, readPageFiles } from '../lib/routes.js';
+const PAGES_DIR = 'src/pages';
+const RC_FILE = '.lighthouserc.json';
+// Build equivalente alla produzione, server statico e Chrome di Linux: lo script chiama di nuovo
+// questo comando, senza `--local`, quando il server risponde.
+function runLocal() {
+    const script = fileURLToPath(new URL('../sh/lhci-local.sh', import.meta.url));
+    const env = { ...process.env, OFFICINA_BIN: process.argv[1] };
+    return spawnSync('bash', [script], { stdio: 'inherit', env }).status ?? 1;
+}
+export function main(args = []) {
+    if (args.includes('--local'))
+        return runLocal();
+    const rc = JSON.parse(readFileSync(RC_FILE, 'utf8'));
+    const routes = auditRoutes(expectedRoutes(readPageFiles(PAGES_DIR), PAGES_DIR));
+    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}`);
+    console.log();
+    const dir = mkdtempSync(join(tmpdir(), 'lhci-'));
+    const config = join(dir, 'lighthouserc.json');
+    writeFileSync(config, JSON.stringify(resolved, null, 2));
+    const { status } = spawnSync('pnpm', ['dlx', '@lhci/cli', 'autorun', `--config=${config}`], { stdio: 'inherit' });
+    rmSync(dir, { recursive: true, force: true });
+    return status ?? 1;
+}
+if (import.meta.main)
+    process.exit(main(process.argv.slice(2)));

package/dist/checks/placeholders.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export declare function main(args?: string[]): number;

package/dist/checks/roadmap.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export declare function main(args?: string[]): number;

package/dist/checks/routes.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export declare function main(args?: string[]): number;

package/dist/checks/smoke.d.ts

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

package/dist/checks/smoke.js

@@ -0,0 +1,57 @@
+#!/usr/bin/env node
+// L'unico controllo che vede cosa serve davvero il bordo: i test del progetto fissano solo vercel.json.
+import process from 'node:process';
+import { loadConfig } from '../lib/config.js';
+import { expectedRoutes, readPageFiles, smokeRoutes } from '../lib/routes.js';
+import { runChecks, SECURITY_HEADERS, waitForAlias, } from '../lib/smoke-production.js';
+const PAGES_DIR = 'src/pages';
+function printResults(results) {
+    for (const { check, status, detail } of results) {
+        if (status === 'pass')
+            console.log(`✓ ${check}`);
+        else if (status === 'skip')
+            console.log(`- ${check} (saltato: ${detail})`);
+        else
+            console.error(`✗ ${check} — ${detail}`);
+    }
+}
+function printFailures(failures) {
+    console.error(`\n✗ ${failures.length} controllo/i falliti:`);
+    console.error(`${failures.map(({ check, detail }) => `  - ${check} — ${detail}`).join('\n')}\n`);
+    console.error('La produzione è online e rotta. Torna indietro dalla dashboard di Vercel:');
+    console.error('Deployments → l’ultimo deployment di produzione sano → Promote to Production.\n');
+}
+export async function main(args = []) {
+    const { siteUrl, smoke = {} } = await loadConfig(process.cwd());
+    const [url] = args;
+    if (siteUrl === undefined) {
+        console.error('\n✗ officina.config.ts non dichiara siteUrl: il controllo dell’host canonico non ha con cosa confrontarsi.\n');
+        return 1;
+    }
+    if (url === undefined && new URL(siteUrl).host === 'example.com') {
+        console.error('\n✗ siteUrl è ancora il segnaposto del template: passa un URL, pnpm smoke:prod https://…\n');
+        return 1;
+    }
+    // L'apice, non l'URL *.vercel.app che stampa `vercel deploy`: lì la regola `has: host` di vercel.json mette noindex.
+    const baseUrl = (url ?? siteUrl).replace(/\/+$/, '');
+    const context = {
+        get: (target) => fetch(target, { redirect: 'manual' }),
+        baseUrl,
+        siteUrl,
+        securityHeaders: smoke.securityHeaders ?? SECURITY_HEADERS,
+    };
+    const pages = smokeRoutes(expectedRoutes(readPageFiles(PAGES_DIR), PAGES_DIR), smoke.nonHtmlRoutes);
+    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);
+    const failures = results.filter(({ status }) => status === 'fail');
+    if (failures.length > 0) {
+        printFailures(failures);
+        return 1;
+    }
+    console.log(`\n✓ Tutti i controlli passati su ${baseUrl}.\n`);
+    return 0;
+}
+if (import.meta.main)
+    process.exit(await main(process.argv.slice(2)));

package/dist/checks/vercel-cli.d.ts

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

package/dist/checks/vercel-cli.js

@@ -3,19 +3,21 @@ import { readFileSync } from 'node:fs';
 import process from 'node:process';
 import { cliOptions, exitCode, printFindings } from '../lib/cli.js';
 import { pinFindings } from '../lib/vercel-cli-pin.js';
-const WORKFLOW = '.github/workflows/deploy.yml';
+const DEFAULT_WORKFLOW = '.github/workflows/deploy.yml';
 // Il documento `latest` porta la sola versione pubblicata; quello del pacchetto intero pesa 8 MB.
 const REGISTRY = 'https://registry.npmjs.org/vercel/latest';
 const TIMEOUT_MS = 15_000;
-export async function main() {
+// Il file è un argomento perché officina controlla il pin della propria action di deploy.
+export async function main(args = []) {
+    const workflow = args[0] ?? DEFAULT_WORKFLOW;
     const response = await fetch(REGISTRY, { signal: AbortSignal.timeout(TIMEOUT_MS) });
     if (!response.ok) {
         console.error(`✗ registry npm illeggibile: HTTP ${response.status}`);
         return 1;
     }
     const { version } = (await response.json());
-    const findings = pinFindings(readFileSync(WORKFLOW, 'utf8'), version).map((hit) => ({
-        path: WORKFLOW,
+    const findings = pinFindings(readFileSync(workflow, 'utf8'), version).map((hit) => ({
+        path: workflow,
         ...hit,
         severity: 'error',
     }));
@@ -23,8 +25,8 @@ export async function main() {
     printFindings(findings, cliOptions([]).format);
     console.log(findings.length === 0
         ? '  Il pin è sulla major pubblicata.\n'
-        : `\n  Alza il pin in ${WORKFLOW} e allinea la CLI locale alla stessa major.\n`);
+        : `\n  Alza il pin in ${workflow} e allinea la CLI locale alla stessa major.\n`);
     return exitCode(findings, false);
 }
 if (import.meta.main)
-    process.exit(await main());
+    process.exit(await main(process.argv.slice(2)));

package/dist/gen/collection.d.mts

@@ -0,0 +1 @@
+export default function collectionGenerator(plop: any): void;

package/dist/gen/component.d.mts

@@ -0,0 +1 @@
+export default function componentGenerator(plop: any): void;

package/dist/gen/icons.d.ts

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

package/dist/gen/icons.js

@@ -0,0 +1,27 @@
+#!/usr/bin/env node
+import process from 'node:process';
+import { loadConfig } from '../lib/config.js';
+const isMissingSharp = (error) => error instanceof Error && 'code' in error && error.code === 'ERR_MODULE_NOT_FOUND' && error.message.includes('sharp');
+export async function main() {
+    const { icons } = await loadConfig(process.cwd());
+    if (icons === undefined) {
+        console.error('\n✗ officina.config.ts non dichiara icons.background: è il colore di fondo delle icone.\n');
+        return 1;
+    }
+    try {
+        // Caricato qui e non in testa: sharp è del progetto, e chi non genera icone non lo deve avere.
+        const { writeIcons } = await import('../lib/icons.js');
+        for (const { path, bytes } of await writeIcons(process.cwd(), icons.background)) {
+            console.log(`${path}  ${(bytes / 1024).toFixed(1)} KB`);
+        }
+        return 0;
+    }
+    catch (error) {
+        if (!isMissingSharp(error))
+            throw error;
+        console.error('\n✗ sharp non è fra le dipendenze del progetto: `officina gen icons` lo usa per disegnare i PNG.\n');
+        return 1;
+    }
+}
+if (import.meta.main)
+    process.exit(await main());

package/dist/gen/identifier.d.mts

@@ -0,0 +1 @@
+export declare function isValidIdentifier(camel: any): boolean;

package/dist/gen/inject-config.d.mts

@@ -0,0 +1,12 @@
+export declare function assertInjectable({ root, camel, kebab }: {
+    camel: any;
+    kebab: any;
+    root: any;
+}): void;
+export declare function injectCollection({ root, camel, kebab, document, sections }: {
+    camel: any;
+    document: any;
+    kebab: any;
+    root: any;
+    sections?: boolean | undefined;
+}): void;

package/dist/gen/inject-section.d.mts

@@ -0,0 +1,16 @@
+export declare function assertSectionInjectable({ root, collection, camel, kebab, pascal, image }: {
+    camel: any;
+    collection: any;
+    image?: boolean | undefined;
+    kebab: any;
+    pascal: any;
+    root: any;
+}): void;
+export declare function injectSection({ root, collection, camel, kebab, pascal, image }: {
+    camel: any;
+    collection: any;
+    image?: boolean | undefined;
+    kebab: any;
+    pascal: any;
+    root: any;
+}): void;

package/dist/gen/inject-strings.d.mts

@@ -0,0 +1,8 @@
+export declare function assertStringsInjectable({ root, keys }: {
+    keys: any;
+    root: any;
+}): void;
+export declare function injectStrings({ root, entries }: {
+    entries: any;
+    root: any;
+}): void;