@elia97/officina 0.1.0 → 0.2.0

package/README.md

@@ -18,7 +18,13 @@ 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"
+    "check:vercel-cli": "officina check vercel-cli",
+    "gen": "officina gen",
+    "gen:section": "officina gen section",
+    "gen:page": "officina gen page",
+    "gen:component": "officina gen component",
+    "gen:collection": "officina gen collection",
+    "doctor": "officina doctor"
   }
 }
 ```
@@ -43,6 +49,16 @@ pnpm version <patch|minor|major>
 pnpm publish     # prepublishOnly lancia typecheck, test e build
 ```
 
+## Generatori
+
+`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.
+
+Un progetto aggiunge i propri generatori con un file `officina.generators.mjs` nella radice, con la firma di un plopfile: `export default function (plop)`.
+
+I test dei generatori girano sui punti di aggancio del progetto di prova, copiati da `vetrina`. Che un progetto vero li abbia ancora lo verifica `doctor`, non i test.
+
 ## Cosa arriverà
 
-I generatori (`officina gen …`) con i loro template, poi bundle budget, smoke di produzione, lighthouse, verifica analytics e icone.
+Bundle budget, smoke di produzione, lighthouse, verifica analytics e icone. Poi i preset di `ecommerce` e `monorepo`.

package/dist/bin.js

@@ -2,7 +2,7 @@
 import process from 'node:process';
 // Un modulo per gate, caricato solo quando serve: `officina check routes` non paga il costo
 // degli altri cinque.
-const CHECKS = {
+export const CHECKS = {
     comments: () => import('./checks/comments.js'),
     language: () => import('./checks/language.js'),
     placeholders: () => import('./checks/placeholders.js'),
@@ -10,16 +10,29 @@ const CHECKS = {
     routes: () => import('./checks/routes.js'),
     'vercel-cli': () => import('./checks/vercel-cli.js'),
 };
-const USAGE = `Uso: officina check <gate> [opzioni]\n\nGate: ${Object.keys(CHECKS).join(', ')}\nOpzioni comuni: --diff, --base <ref>, --head <ref>, --strict, --format text|github\n`;
+const USAGE = `Uso:
+  officina check <gate> [opzioni]   gate: ${Object.keys(CHECKS).join(', ')}
+  officina gen [generatore]         section, page, component, collection, più quelli del progetto
+  officina doctor                   cosa manca al progetto perché i generatori funzionino
+
+Opzioni dei gate: --diff, --base <ref>, --head <ref>, --strict, --format text|github
+`;
+// 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 }),
+    doctor: (args) => ({ load: () => import('./checks/doctor.js'), args }),
+};
 export async function run(argv) {
-    const [group, name, ...rest] = argv;
-    const load = group === 'check' && name !== undefined ? CHECKS[name] : undefined;
+    const [group = '', ...rest] = argv;
+    const { load, args } = GROUPS[group]?.(rest) ?? { load: undefined, args: [] };
     if (!load) {
         console.error(USAGE);
         return 2;
     }
     const { main } = await load();
-    return main(rest);
+    return main(args);
 }
+/* v8 ignore next -- eseguito solo quando il file è il punto d'ingresso del processo */
 if (import.meta.main)
     process.exit(await run(process.argv.slice(2)));

package/dist/checks/doctor.js

@@ -0,0 +1,15 @@
+#!/usr/bin/env node
+import process from 'node:process';
+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);
+    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`);
+    return exitCode(findings, false);
+}
+if (import.meta.main)
+    process.exit(main());

package/dist/gen/collection.mjs

@@ -0,0 +1,76 @@
+import { isValidIdentifier } from './identifier.mjs';
+import { assertInjectable, injectCollection } from './inject-config.mjs';
+import { postGenAction } from './post-gen.mjs';
+import { sectionedCollectionActions, sectionedCollectionPrompts } from './sectioned-collection.mjs';
+function flatCollectionActions(root, answers) {
+    const tpl = 'templates/collection';
+    return [
+        (a, _config, api) => {
+            assertInjectable({
+                root,
+                camel: api.getHelper('camelCase')(a.name),
+                kebab: api.getHelper('dashCase')(a.name),
+            });
+            return 'content.config.ts contract checks passed';
+        },
+        {
+            type: 'add',
+            path: 'src/lib/schemas/{{dashCase name}}.ts',
+            templateFile: `${tpl}/schema.ts.hbs`,
+        },
+        {
+            type: 'add',
+            path: answers.document ? 'src/content/{{dashCase name}}/example.md' : 'src/content/{{dashCase name}}/example.yml',
+            templateFile: answers.document ? `${tpl}/doc.md.hbs` : `${tpl}/data.yml.hbs`,
+        },
+        (a, _config, api) => {
+            injectCollection({
+                root,
+                camel: api.getHelper('camelCase')(a.name),
+                kebab: api.getHelper('dashCase')(a.name),
+                document: a.document,
+            });
+            return `injected collection in content.config.ts: ${a.name}`;
+        },
+        postGenAction(root),
+    ];
+}
+export default function collectionGenerator(plop) {
+    const root = process.cwd();
+    plop.setGenerator('collection', {
+        description: 'New content collection (YAML data, MD documents, or a page built from sections)',
+        prompts: [
+            {
+                type: 'input',
+                name: 'name',
+                message: 'Collection name (e.g. services, blog):',
+                validate: (value) => {
+                    const camel = plop.getHelper('camelCase')(String(value));
+                    if (!camel)
+                        return 'Collection name is required';
+                    if (!isValidIdentifier(camel)) {
+                        return `"${value}" would generate an invalid identifier (const ${camel}) — use ASCII letters/digits, starting with a letter, not a JS reserved word`;
+                    }
+                    return true;
+                },
+            },
+            {
+                type: 'confirm',
+                name: 'sections',
+                message: 'A page built from sections, like the homepage?',
+                default: false,
+            },
+            {
+                type: 'confirm',
+                name: 'document',
+                message: 'MD documents with a renderable body? (No = YAML data)',
+                default: false,
+                when: (answers) => answers.sections !== true,
+            },
+            ...sectionedCollectionPrompts(plop),
+        ],
+        actions: (answers) => answers.sections === true
+            ? sectionedCollectionActions(plop, answers, root)
+            : flatCollectionActions(root, answers),
+    });
+}

package/dist/gen/component.mjs

@@ -0,0 +1,41 @@
+import { postGenAction } from './post-gen.mjs';
+const IDENTIFIER = /^[A-Za-z_$][A-Za-z0-9_$]*$/;
+export default function componentGenerator(plop) {
+    const root = process.cwd();
+    const tpl = 'templates/component';
+    plop.setGenerator('component', {
+        description: 'New native Astro component (cva + cn recipe)',
+        prompts: [
+            {
+                type: 'input',
+                name: 'name',
+                message: 'Component name (e.g. PriceCard):',
+                validate: (value) => {
+                    const camel = plop.getHelper('camelCase')(String(value));
+                    if (!camel)
+                        return 'Component name is required';
+                    if (!IDENTIFIER.test(camel)) {
+                        return `"${value}" would generate an invalid identifier (${camel}Variants) — use ASCII letters/digits, starting with a letter`;
+                    }
+                    return true;
+                },
+            },
+            {
+                type: 'input',
+                name: 'area',
+                message: 'Folder under src/components/ (e.g. ui, marketing):',
+                default: 'ui',
+                validate: (value) => plop.getHelper('dashCase')(String(value)) !== '' ||
+                    'Area folder must contain at least one letter or digit (e.g. ui)',
+            },
+        ],
+        actions: [
+            {
+                type: 'add',
+                path: 'src/components/{{dashCase area}}/{{dashCase name}}.astro',
+                templateFile: `${tpl}/component.astro.hbs`,
+            },
+            postGenAction(root),
+        ],
+    });
+}

package/dist/gen/identifier.mjs

@@ -0,0 +1,52 @@
+const IDENTIFIER = /^[A-Za-z_$][A-Za-z0-9_$]*$/;
+const RESERVED = new Set([
+    'await',
+    'break',
+    'case',
+    'catch',
+    'class',
+    'const',
+    'continue',
+    'debugger',
+    'default',
+    'delete',
+    'do',
+    'else',
+    'enum',
+    'export',
+    'extends',
+    'false',
+    'finally',
+    'for',
+    'function',
+    'if',
+    'implements',
+    'import',
+    'in',
+    'instanceof',
+    'interface',
+    'let',
+    'new',
+    'null',
+    'package',
+    'private',
+    'protected',
+    'public',
+    'return',
+    'static',
+    'super',
+    'switch',
+    'this',
+    'throw',
+    'true',
+    'try',
+    'typeof',
+    'var',
+    'void',
+    'while',
+    'with',
+    'yield',
+]);
+export function isValidIdentifier(camel) {
+    return IDENTIFIER.test(camel) && !RESERVED.has(camel);
+}

package/dist/gen/inject-config.mjs

@@ -0,0 +1,73 @@
+import { Project, SyntaxKind } from 'ts-morph';
+import { isNameTaken } from './ts-morph-utils.mjs';
+const CONFIG_PATH = 'src/content.config.ts';
+function loadConfig(root) {
+    const project = new Project();
+    return project.addSourceFileAtPath(`${root}/${CONFIG_PATH}`);
+}
+function locateContract(cfg, { camel, kebab }) {
+    const statement = cfg.getVariableStatement((s) => s.getDeclarations().some((d) => d.getName() === 'collections'));
+    if (!statement) {
+        throw new Error(`gen:collection injection failed: no \`collections\` variable in ${CONFIG_PATH}. ` +
+            `The contract expects \`export const collections = { … }\` — if it was renamed, ` +
+            `restore it or update scripts/gen/inject-config.mjs (see docs/guides/content-collections.md).`);
+    }
+    if (!statement.hasExportKeyword()) {
+        throw new Error(`gen:collection injection failed: \`collections\` in ${CONFIG_PATH} is not exported. ` +
+            `Astro silently ignores a non-exported collections object — restore \`export const collections\`.`);
+    }
+    const object = cfg
+        .getVariableDeclarationOrThrow('collections')
+        .getInitializerIfKind(SyntaxKind.ObjectLiteralExpression);
+    if (!object) {
+        throw new Error(`gen:collection injection failed: \`collections\` in ${CONFIG_PATH} is not initialized ` +
+            `with an object literal, so there is no place to register the new collection.`);
+    }
+    if (object.getProperty(camel) || object.getProperty(`'${kebab}'`)) {
+        throw new Error(`gen:collection injection failed: a collection named "${kebab}" is already registered ` +
+            `in ${CONFIG_PATH}. Pick another name, or remove the existing entry first.`);
+    }
+    if (isNameTaken(cfg, camel)) {
+        throw new Error(`gen:collection injection failed: the identifier \`${camel}\` is already taken in ` +
+            `${CONFIG_PATH} (import or variable) — the injected const would shadow it. Pick another name.`);
+    }
+    return { statement, object };
+}
+export function assertInjectable({ root, camel, kebab }) {
+    locateContract(loadConfig(root), { camel, kebab });
+}
+export function injectCollection({ root, camel, kebab, document, sections = false }) {
+    const cfg = loadConfig(root);
+    const { statement, object } = locateContract(cfg, { camel, kebab });
+    const schema = sections ? `${camel}CollectionSchema` : `${camel}Schema`;
+    if (!cfg.getImportDeclaration((d) => d.getModuleSpecifierValue() === `@/lib/schemas/${kebab}`)) {
+        cfg.addImportDeclaration({
+            moduleSpecifier: `@/lib/schemas/${kebab}`,
+            namedImports: [schema],
+        });
+    }
+    const pattern = document ? '**/*.md' : '**/*.{yaml,yml}';
+    const loaderId = document
+        ? `    // Default generateId on purpose: this id becomes the route slug, so it\n` +
+            `    // should slugify segments and honor a frontmatter \`slug\`.\n`
+        : `    // Raw relative path minus extension, like the homepage collection: the\n` +
+            `    // default generateId slugifies segments (en-US → en-us), honors a top-level\n` +
+            `    // \`slug\` key before zod strips it, and drops a trailing /index — all three\n` +
+            `    // break reading entries back by locale folder.\n` +
+            `    generateId: ({ entry }) => entry.replace(/\\.(yaml|yml)$/, ''),\n`;
+    cfg.insertStatements(statement.getChildIndex(), `const ${camel} = defineCollection({\n` +
+        `  loader: glob({\n` +
+        `    pattern: '${pattern}',\n` +
+        `    base: './src/content/${kebab}',\n` +
+        loaderId +
+        `  }),\n` +
+        `  schema: ${schema},\n` +
+        `})\n`);
+    if (kebab.includes('-')) {
+        object.addPropertyAssignment({ name: `'${kebab}'`, initializer: camel });
+    }
+    else {
+        object.addShorthandPropertyAssignment({ name: camel });
+    }
+    cfg.saveSync();
+}

package/dist/gen/inject-section.mjs

@@ -0,0 +1,140 @@
+// L'inserimento va SOPRA ogni marcatore: sotto, l'organizeImports di Biome adotta il marcatore come
+// trivia iniziale del nuovo import e lo sposta nel blocco ordinato. (.astro non è leggibile da ts-morph.)
+import { existsSync, readFileSync, writeFileSync } from 'node:fs';
+import { Node, Project, SyntaxKind } from 'ts-morph';
+import { findSectionedPages, sectionFiles, sectionTargets } from './section-targets.mjs';
+import { isNameTaken } from './ts-morph-utils.mjs';
+const GUIDE = 'docs/guides/content-collections.md';
+function fail(where, problem) {
+    throw new Error(`gen:section injection failed in ${where}: ${problem} (contract: ${GUIDE})`);
+}
+function addSource(project, root, path, missing) {
+    if (!existsSync(`${root}/${path}`))
+        fail(path, missing);
+    return project.addSourceFileAtPath(`${root}/${path}`);
+}
+function locateUnionArray(project, root, targets, collection) {
+    const created = 'a sectioned collection is created by `pnpm gen:collection`';
+    const barrel = addSource(project, root, targets.barrel, `the "${collection}" collection has no schema barrel — ${created}`);
+    const fn = barrel.getFunction(targets.schemaFunction);
+    if (!fn) {
+        fail(targets.barrel, `no \`${targets.schemaFunction}\` function — was it renamed?`);
+    }
+    const call = fn
+        .getDescendantsOfKind(SyntaxKind.CallExpression)
+        .find((c) => c.getExpression().getText() === 'z.discriminatedUnion');
+    if (!call) {
+        fail(targets.barrel, `no \`z.discriminatedUnion(…)\` call inside ${targets.schemaFunction}`);
+    }
+    const union = call.getArguments()[1]?.asKind(SyntaxKind.ArrayLiteralExpression);
+    if (!union) {
+        fail(targets.barrel, 'the second argument of z.discriminatedUnion is not an array literal');
+    }
+    return { barrel, fn, union };
+}
+const inUnion = (union, camel) => union.getElements().some((element) => element.getText().startsWith(`${camel}SectionSchema(`));
+function locateReturnObject(project, root, targets, collection) {
+    const created = 'a sectioned collection is created by `pnpm gen:collection`';
+    const layer = addSource(project, root, targets.dataLayer, `the "${collection}" collection has no data layer — ${created}`);
+    const fn = layer.getFunction(targets.dataFunction);
+    if (!fn) {
+        fail(targets.dataLayer, `no \`${targets.dataFunction}\` function — was it renamed?`);
+    }
+    const ret = fn
+        .getBody()
+        ?.getStatements()
+        .findLast((s) => s.isKind(SyntaxKind.ReturnStatement));
+    const obj = ret?.getExpression()?.asKind(SyntaxKind.ObjectLiteralExpression);
+    if (!obj) {
+        fail(targets.dataLayer, `${targets.dataFunction} has no top-level \`return { … }\` object literal to register the pick() in`);
+    }
+    return obj;
+}
+function readSectionedPage(root, targets) {
+    const pages = findSectionedPages(root, targets.sectionsMarker);
+    if (pages.length === 0) {
+        fail('src/pages/', `no page carries the \`${targets.sectionsMarker}\` marker — the component has no anchor`);
+    }
+    if (pages.length > 1) {
+        fail('src/pages/', `${pages.join(' and ')} all carry the \`${targets.sectionsMarker}\` marker — keep it on one page`);
+    }
+    const [page] = pages;
+    const src = readFileSync(`${root}/${page}`, 'utf8');
+    if (!src.includes(targets.importsMarker)) {
+        fail(page, `the \`${targets.importsMarker}\` marker is missing — the import has no anchor`);
+    }
+    return { page, src };
+}
+function assertContextForwardable(fn, targets) {
+    const [first] = fn.getParameters();
+    if (first && !Node.isIdentifier(first.getNameNode())) {
+        fail(targets.barrel, `${targets.schemaFunction} destructures its parameter — name it \`context: SchemaContext\`, so an image section can receive it`);
+    }
+}
+export function assertSectionInjectable({ root, collection, camel, kebab, pascal, image = false }) {
+    const targets = sectionTargets(collection);
+    const project = new Project();
+    const { barrel, fn, union } = locateUnionArray(project, root, targets, collection.kebab);
+    if (inUnion(union, camel)) {
+        fail(targets.barrel, `section "${camel}" is already in the union — pick another name`);
+    }
+    if (image)
+        assertContextForwardable(fn, targets);
+    if (isNameTaken(barrel, `${camel}SectionSchema`)) {
+        fail(targets.barrel, `the identifier \`${camel}SectionSchema\` is already taken — the injected import would collide. Pick another name`);
+    }
+    const obj = locateReturnObject(project, root, targets, collection.kebab);
+    if (obj.getProperty(camel)) {
+        fail(targets.dataLayer, `section "${camel}" is already picked in ${targets.dataFunction}`);
+    }
+    const { page, src } = readSectionedPage(root, targets);
+    const frontmatter = src.split('---')[1] ?? '';
+    if (new RegExp(`\\b${pascal}\\b`).test(frontmatter)) {
+        fail(page, `the identifier \`${pascal}\` is already used in the frontmatter — the component import would collide. Pick another name`);
+    }
+    for (const target of sectionFiles(targets, kebab)) {
+        if (existsSync(`${root}/${target}`)) {
+            fail(target, 'the file already exists — remove it first or pick another name');
+        }
+    }
+}
+function contextArgument(barrel, fn) {
+    const [first] = fn.getParameters();
+    if (first)
+        return first.getName();
+    fn.addParameter({ name: 'context', type: 'SchemaContext' });
+    if (!isNameTaken(barrel, 'SchemaContext')) {
+        barrel.addImportDeclaration({ moduleSpecifier: 'astro:content', namedImports: ['SchemaContext'], isTypeOnly: true });
+    }
+    return 'context';
+}
+export function injectSection({ root, collection, camel, kebab, pascal, image = false }) {
+    const targets = sectionTargets(collection);
+    const project = new Project();
+    const { barrel, fn, union } = locateUnionArray(project, root, targets, collection.kebab);
+    if (!barrel.getImportDeclaration((d) => d.getModuleSpecifierValue() === `./${kebab}`)) {
+        barrel.addImportDeclaration({
+            moduleSpecifier: `./${kebab}`,
+            namedImports: [`${camel}SectionSchema`],
+        });
+    }
+    if (!inUnion(union, camel)) {
+        union.addElement(`${camel}SectionSchema(${image ? contextArgument(barrel, fn) : ''})`);
+    }
+    const obj = locateReturnObject(project, root, targets, collection.kebab);
+    if (!obj.getProperty(camel)) {
+        obj.addPropertyAssignment({ name: camel, initializer: `pick('${camel}')` });
+    }
+    project.saveSync();
+    const { page, src: original } = readSectionedPage(root, targets);
+    let src = original;
+    const imp = `import ${pascal} from '@/components/${collection.kebab}/${kebab}.astro'`;
+    if (!src.includes(imp)) {
+        src = src.replace(targets.importsMarker, `${imp}\n${targets.importsMarker}`);
+    }
+    const use = `<${pascal} {...content.${camel}} />`;
+    if (!src.includes(use)) {
+        src = src.replace(targets.sectionsMarker, `${use}\n  ${targets.sectionsMarker}`);
+    }
+    writeFileSync(`${root}/${page}`, src);
+}

package/dist/gen/inject-strings.mjs

@@ -0,0 +1,56 @@
+import { readdirSync } from 'node:fs';
+import { join } from 'node:path';
+import { Project, SyntaxKind } from 'ts-morph';
+const DICTIONARIES = 'src/i18n/strings';
+const GUIDE = 'docs/guides/content-collections.md';
+function fail(where, problem) {
+    throw new Error(`gen:page injection failed in ${where}: ${problem} (contract: ${GUIDE})`);
+}
+function locateObject(file, path, locale) {
+    const declaration = file.getVariableDeclaration(locale);
+    if (!declaration) {
+        fail(path, `no \`${locale}\` constant — the dictionary must export \`const ${locale} = { … } as const\``);
+    }
+    if (!declaration.isExported()) {
+        fail(path, `\`${locale}\` is not exported, so src/i18n/ui.ts cannot register it`);
+    }
+    const object = declaration
+        .getInitializerIfKind(SyntaxKind.AsExpression)
+        ?.getExpression()
+        .asKind(SyntaxKind.ObjectLiteralExpression);
+    if (!object) {
+        fail(path, `\`${locale}\` is not an object literal with \`as const\`, so there is no place for the new keys`);
+    }
+    return object;
+}
+function loadDictionaries(root) {
+    const names = readdirSync(join(root, DICTIONARIES))
+        .filter((name) => name.endsWith('.ts'))
+        .sort();
+    if (names.length === 0)
+        fail(DICTIONARIES, 'no dictionary to register the page strings in');
+    const project = new Project();
+    const dictionaries = names.map((name) => {
+        const path = `${DICTIONARIES}/${name}`;
+        const file = project.addSourceFileAtPath(join(root, path));
+        return { path, object: locateObject(file, path, name.slice(0, -3)) };
+    });
+    return { project, dictionaries };
+}
+export function assertStringsInjectable({ root, keys }) {
+    for (const { path, object } of loadDictionaries(root).dictionaries) {
+        for (const key of keys) {
+            if (object.getProperty(`'${key}'`))
+                fail(path, `the key '${key}' is already there — pick another page path`);
+        }
+    }
+}
+export function injectStrings({ root, entries }) {
+    const { project, dictionaries } = loadDictionaries(root);
+    for (const { object } of dictionaries) {
+        for (const { key, value } of entries) {
+            object.addPropertyAssignment({ name: `'${key}'`, initializer: `'${value}'` });
+        }
+    }
+    project.saveSync();
+}

package/dist/gen/page.mjs

@@ -0,0 +1,68 @@
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { assertStringsInjectable, injectStrings } from './inject-strings.mjs';
+import { postGenAction } from './post-gen.mjs';
+const ROLLBACK_HINT = 'gen:page also MODIFIED every dictionary in src/i18n/strings/. Review them with `git diff`, then discard ONLY ' +
+    'the injected page.* keys with `git checkout -p` on those paths, and delete the generated page. A re-run ' +
+    'without rollback fails pre-flight with "is already there".';
+export function pathSegments(plop, value) {
+    const dash = plop.getHelper('dashCase');
+    return String(value)
+        .split('/')
+        .map((segment) => dash(segment.trim()))
+        .filter(Boolean);
+}
+export function pageStrings({ pageKey, pageTitle, dynamic }) {
+    const title = { key: `page.${pageKey}.title`, value: pageTitle };
+    return dynamic ? [title] : [title, { key: `page.${pageKey}.description`, value: '<PAGE_DESCRIPTION>' }];
+}
+export default function pageGenerator(plop) {
+    const root = process.cwd();
+    const tpl = 'templates/page';
+    plop.setGenerator('page', {
+        description: 'New Astro page (static, or dynamic [slug] with getStaticPaths)',
+        prompts: [
+            {
+                type: 'input',
+                name: 'name',
+                message: 'Page path (e.g. about-us, or nested like legal/privacy):',
+                // change-case toglie la punteggiatura, quindi '...' non è vuoto ma in dash-case diventa ''.
+                validate: (value) => pathSegments(plop, value).length > 0 || 'Page path must contain at least one letter or digit',
+            },
+            {
+                type: 'confirm',
+                name: 'dynamic',
+                message: 'Dynamic [slug] route with getStaticPaths?',
+                default: false,
+            },
+        ],
+        actions: (answers) => {
+            const segments = pathSegments(plop, answers.name);
+            const pagePath = segments.join('/');
+            answers.pagePath = pagePath;
+            answers.pageTitle = plop.getHelper('sentenceCase')(segments.at(-1));
+            answers.pageKey = plop.getHelper('camelCase')(pagePath);
+            const target = answers.dynamic ? `src/pages/${pagePath}/[slug].astro` : `src/pages/${pagePath}.astro`;
+            const strings = pageStrings(answers);
+            return [
+                () => {
+                    if (existsSync(join(root, target))) {
+                        throw new Error(`gen:page pre-flight failed: ${target} already exists — remove it or pick another path`);
+                    }
+                    assertStringsInjectable({ root, keys: strings.map(({ key }) => key) });
+                    return 'page path and dictionary contract checks passed';
+                },
+                {
+                    type: 'add',
+                    path: target,
+                    templateFile: answers.dynamic ? `${tpl}/dynamic.astro.hbs` : `${tpl}/static.astro.hbs`,
+                },
+                () => {
+                    injectStrings({ root, entries: strings });
+                    return `injected ${strings.map(({ key }) => key).join(', ')}`;
+                },
+                postGenAction(root, ROLLBACK_HINT),
+            ];
+        },
+    });
+}

package/dist/gen/plopfile.mjs

@@ -0,0 +1,30 @@
+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 process from 'node:process';
+import { pathToFileURL } from 'node:url';
+import collectionGenerator from './collection.mjs';
+import componentGenerator from './component.mjs';
+import pageGenerator from './page.mjs';
+import sectionGenerator from './section.mjs';
+// I generatori propri di un progetto stanno qui, nella sua radice, e si aggiungono a quelli del
+// pacchetto: stessa firma di un plopfile, `export default function (plop)`.
+export const PROJECT_GENERATORS = 'officina.generators.mjs';
+export default async function (plop) {
+    sectionGenerator(plop);
+    pageGenerator(plop);
+    componentGenerator(plop);
+    collectionGenerator(plop);
+    const extension = join(process.cwd(), PROJECT_GENERATORS);
+    if (!existsSync(extension))
+        return;
+    const { default: projectGenerators } = await import(__rewriteRelativeImportExtension(pathToFileURL(extension).href));
+    await projectGenerators(plop);
+}

package/dist/gen/post-gen.mjs

@@ -0,0 +1,16 @@
+// `pnpm run check` è un `biome check --write .` su tutto il repo, quindi riformatta anche file sporchi
+// che non c'entrano: i suggerimenti di recupero non devono mai ricorrere a un `git checkout` di file intero.
+import { execSync } from 'node:child_process';
+export function postGenAction(root, recoveryHint) {
+    return () => {
+        try {
+            execSync('pnpm exec astro sync', { cwd: root, stdio: 'inherit' });
+            execSync('pnpm run check', { cwd: root, stdio: 'inherit' });
+        }
+        catch (error) {
+            throw new Error(`Post-generation checks failed. ${recoveryHint ??
+                'The generated files were left on disk — inspect, then fix or delete them before re-running (a re-run against leftovers fails with "File already exists").'}`, { cause: error });
+        }
+        return 'astro sync + biome check passed';
+    };
+}

package/dist/gen/run.js

@@ -0,0 +1,17 @@
+import { spawnSync } from 'node:child_process';
+import { createRequire } from 'node:module';
+import { dirname, join } from 'node:path';
+import process from 'node:process';
+import { fileURLToPath } from 'node:url';
+// plop risolve i template dalla cartella del plopfile e scrive in `--dest`: il plopfile sta nel
+// pacchetto, la destinazione è il progetto da cui si lancia il comando.
+export function plopCommand(args, cwd) {
+    const require = createRequire(import.meta.url);
+    const plopBin = join(dirname(require.resolve('plop/package.json')), 'bin', 'plop.js');
+    const plopfile = fileURLToPath(new URL('./plopfile.mjs', import.meta.url));
+    return [plopBin, '--plopfile', plopfile, '--dest', cwd, ...args];
+}
+export function main(args = []) {
+    const result = spawnSync(process.execPath, plopCommand(args, process.cwd()), { stdio: 'inherit' });
+    return result.status ?? 1;
+}

package/dist/gen/section-targets.mjs

@@ -0,0 +1,46 @@
+import { readdirSync, readFileSync } from 'node:fs';
+import { join, relative } from 'node:path';
+import { isValidIdentifier } from './identifier.mjs';
+export function casings(plop, value) {
+    return {
+        camel: plop.getHelper('camelCase')(value),
+        kebab: plop.getHelper('dashCase')(value),
+        pascal: plop.getHelper('pascalCase')(value),
+    };
+}
+export function sectionTargets({ camel, kebab, pascal }) {
+    return {
+        barrel: `src/lib/schemas/${kebab}/index.ts`,
+        schemaFunction: `${camel}CollectionSchema`,
+        dataLayer: `src/lib/${kebab}.ts`,
+        dataFunction: `get${pascal}Sections`,
+        schemaDir: `src/lib/schemas/${kebab}`,
+        contentDir: `src/content/${kebab}`,
+        componentDir: `src/components/${kebab}`,
+        importsMarker: `// @gen:${kebab}-imports`,
+        sectionsMarker: `{/* @gen:${kebab}-sections */}`,
+    };
+}
+export const sectionFiles = (targets, kebab) => [
+    `${targets.schemaDir}/${kebab}.ts`,
+    `${targets.contentDir}/${kebab}.yml`,
+    `${targets.componentDir}/${kebab}.astro`,
+];
+export function findSectionedPages(root, marker) {
+    return readdirSync(join(root, 'src/pages'), { recursive: true, withFileTypes: true })
+        .filter((entry) => entry.isFile() && entry.name.endsWith('.astro'))
+        .map((entry) => relative(root, join(entry.parentPath, entry.name)))
+        .filter((page) => readFileSync(join(root, page), 'utf8').includes(marker))
+        .sort();
+}
+export function validateSectionName(plop) {
+    return (value) => {
+        const camel = plop.getHelper('camelCase')(String(value));
+        if (!camel)
+            return 'Section name is required';
+        if (!isValidIdentifier(camel)) {
+            return `"${value}" would generate an invalid identifier (${camel}SectionSchema) — use ASCII letters/digits, starting with a letter, not a JS reserved word`;
+        }
+        return true;
+    };
+}

package/dist/gen/section.mjs

@@ -0,0 +1,68 @@
+import { isValidIdentifier } from './identifier.mjs';
+import { assertSectionInjectable, injectSection } from './inject-section.mjs';
+import { postGenAction } from './post-gen.mjs';
+import { casings, sectionFiles, sectionTargets, validateSectionName } from './section-targets.mjs';
+function rollbackHint(targets) {
+    return (`gen:section also MODIFIED three existing files: ${targets.barrel}, ${targets.dataLayer} and the page ` +
+        `that carries ${targets.sectionsMarker}. Review them with \`git diff\`, then discard ONLY the injected hunks ` +
+        'with `git checkout -p` on those paths. Then delete the generated schema/yml/component files. A re-run ' +
+        'without rollback fails pre-flight with "already in the union".');
+}
+export default function sectionGenerator(plop) {
+    const root = process.cwd();
+    const tpl = 'templates/section';
+    plop.setGenerator('section', {
+        description: 'New section of a sectioned page (Zod schema + YAML + component + injection)',
+        prompts: [
+            {
+                type: 'input',
+                name: 'collection',
+                message: 'Sectioned collection (e.g. homepage):',
+                default: 'homepage',
+                validate: (value) => {
+                    const camel = plop.getHelper('camelCase')(String(value));
+                    if (!camel)
+                        return 'Collection name is required';
+                    if (!isValidIdentifier(camel)) {
+                        return `"${value}" would generate an invalid identifier (${camel}CollectionSchema) — use ASCII letters/digits, starting with a letter, not a JS reserved word`;
+                    }
+                    return true;
+                },
+            },
+            {
+                type: 'input',
+                name: 'name',
+                message: 'Section name (e.g. features):',
+                validate: validateSectionName(plop),
+            },
+            {
+                type: 'confirm',
+                name: 'image',
+                message: 'Does the section carry an image? (its content starts on src/assets/placeholder.jpg)',
+                default: false,
+            },
+        ],
+        actions: (answers) => {
+            const collection = casings(plop, answers.collection);
+            const section = casings(plop, answers.name);
+            const targets = sectionTargets(collection);
+            const request = { root, collection, ...section, image: answers.image === true };
+            const [schema, content, component] = sectionFiles(targets, section.kebab);
+            const data = { section: answers.name };
+            return [
+                () => {
+                    assertSectionInjectable(request);
+                    return 'hook-point contract checks passed';
+                },
+                { type: 'add', path: schema, templateFile: `${tpl}/schema.ts.hbs`, data },
+                { type: 'add', path: content, templateFile: `${tpl}/content.yml.hbs`, data },
+                { type: 'add', path: component, templateFile: `${tpl}/component.astro.hbs`, data },
+                () => {
+                    injectSection(request);
+                    return `injected union + pick + page: ${section.pascal}`;
+                },
+                postGenAction(root, rollbackHint(targets)),
+            ];
+        },
+    });
+}

package/dist/gen/sectioned-collection.mjs

@@ -0,0 +1,81 @@
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { assertInjectable, injectCollection } from './inject-config.mjs';
+import { assertStringsInjectable, injectStrings } from './inject-strings.mjs';
+import { pageStrings, pathSegments } from './page.mjs';
+import { postGenAction } from './post-gen.mjs';
+import { casings, findSectionedPages, sectionFiles, sectionTargets, validateSectionName } from './section-targets.mjs';
+const SECTIONS = 'templates/sections';
+const SECTION = 'templates/section';
+const ROLLBACK_HINT = 'gen:collection also MODIFIED src/content.config.ts and every dictionary in src/i18n/strings/. Review them ' +
+    'with `git diff`, then discard ONLY the injected hunks with `git checkout -p` on those paths, and delete the ' +
+    'generated barrel, data layer, page and section files. A re-run without rollback fails pre-flight with ' +
+    '"already exists".';
+const forSections = (answers) => answers.sections === true;
+export function sectionedCollectionPrompts(plop) {
+    return [
+        {
+            type: 'input',
+            name: 'page',
+            message: 'Page path of the sectioned page (e.g. about-us):',
+            when: forSections,
+            validate: (value) => pathSegments(plop, value).length > 0 || 'Page path must contain at least one letter or digit',
+        },
+        {
+            type: 'input',
+            name: 'section',
+            message: 'First section name (e.g. intro):',
+            when: forSections,
+            validate: validateSectionName(plop),
+        },
+        {
+            type: 'confirm',
+            name: 'image',
+            message: 'Does the first section carry an image?',
+            default: false,
+            when: forSections,
+        },
+    ];
+}
+function assertCreatable({ root, targets, page, section, strings }) {
+    for (const path of [page, targets.barrel, targets.dataLayer, ...sectionFiles(targets, section.kebab)]) {
+        if (existsSync(join(root, path))) {
+            throw new Error(`gen:collection pre-flight failed: ${path} already exists — remove it or pick another name`);
+        }
+    }
+    const carriers = findSectionedPages(root, targets.sectionsMarker);
+    if (carriers.length > 0) {
+        throw new Error(`gen:collection pre-flight failed: ${carriers.join(', ')} already carries ${targets.sectionsMarker}`);
+    }
+    assertStringsInjectable({ root, keys: strings.map(({ key }) => key) });
+}
+export function sectionedCollectionActions(plop, answers, root) {
+    const collection = casings(plop, answers.name);
+    const section = casings(plop, answers.section);
+    const targets = sectionTargets(collection);
+    const segments = pathSegments(plop, answers.page);
+    const pageKey = plop.getHelper('camelCase')(segments.join('/'));
+    const page = `src/pages/${segments.join('/')}.astro`;
+    const strings = pageStrings({ pageKey, pageTitle: plop.getHelper('sentenceCase')(segments.at(-1)), dynamic: false });
+    const data = { collection: answers.name, pageKey };
+    const [schema, content, component] = sectionFiles(targets, section.kebab);
+    return [
+        () => {
+            assertInjectable({ root, camel: collection.camel, kebab: collection.kebab });
+            assertCreatable({ root, targets, page, section, strings });
+            return 'content.config.ts, page and dictionary contract checks passed';
+        },
+        { type: 'add', path: targets.barrel, templateFile: `${SECTIONS}/index.ts.hbs`, data },
+        { type: 'add', path: targets.dataLayer, templateFile: `${SECTIONS}/data-layer.ts.hbs`, data },
+        { type: 'add', path: page, templateFile: `${SECTIONS}/page.astro.hbs`, data },
+        { type: 'add', path: schema, templateFile: `${SECTION}/schema.ts.hbs`, data },
+        { type: 'add', path: content, templateFile: `${SECTION}/content.yml.hbs`, data },
+        { type: 'add', path: component, templateFile: `${SECTION}/component.astro.hbs`, data },
+        () => {
+            injectCollection({ root, camel: collection.camel, kebab: collection.kebab, sections: true });
+            injectStrings({ root, entries: strings });
+            return `injected sectioned collection ${collection.kebab} and ${strings.map(({ key }) => key).join(', ')}`;
+        },
+        postGenAction(root, ROLLBACK_HINT),
+    ];
+}

package/dist/gen/templates/collection/data.yml.hbs

@@ -0,0 +1,2 @@
+title: Esempio
+description: Voce di esempio della collection {{dashCase name}}. Sostituiscila col contenuto reale.

package/dist/gen/templates/collection/doc.md.hbs

@@ -0,0 +1,8 @@
+---
+title: Esempio
+description: Voce di esempio della collection {{dashCase name}}.
+pubDate: 2026-01-01
+draft: true
+---
+
+Corpo di esempio della collection **{{dashCase name}}**. Sostituiscilo col contenuto reale.

package/dist/gen/templates/collection/schema.ts.hbs

@@ -0,0 +1,11 @@
+import { z } from 'astro/zod'
+
+export const {{camelCase name}}Schema = z.strictObject({
+  title: z.string().min(1),
+  description: z.string().optional(),
+  {{#if document}}
+  pubDate: z.coerce.date(),
+  draft: z.boolean().default(false),
+  {{/if}}
+})
+export type {{pascalCase name}}Entry = z.infer<typeof {{camelCase name}}Schema>

package/dist/gen/templates/component/component.astro.hbs

@@ -0,0 +1,21 @@
+---
+import type { HTMLAttributes } from 'astro/types'
+import { cva, type VariantProps } from 'class-variance-authority'
+
+import { cn } from '@/lib/utils'
+
+export const {{camelCase name}}Variants = cva('', {
+  variants: {
+    variant: {
+      default: '',
+    },
+  },
+  defaultVariants: { variant: 'default' },
+})
+
+interface Props extends HTMLAttributes<'div'>, VariantProps<typeof {{camelCase name}}Variants> {}
+
+const { variant, class: className, ...rest } = Astro.props
+---
+
+<div class={cn({{camelCase name}}Variants({ variant }), className)} {...rest}><slot /></div>

package/dist/gen/templates/page/dynamic.astro.hbs

@@ -0,0 +1,24 @@
+---
+import Container from '@/components/ui/container.astro'
+import Heading from '@/components/ui/heading.astro'
+import Section from '@/components/ui/section.astro'
+import MainLayout from '@/layouts/main.astro'
+
+import { useTranslations } from '@/i18n/translate'
+
+export function getStaticPaths() {
+  // TODO: ricava i percorsi da una collection, come nel blueprint content-section del plugin metodo.
+  return [{ params: { slug: 'example' } }]
+}
+
+const t = useTranslations(Astro.currentLocale)
+const { slug } = Astro.params
+---
+
+<MainLayout title={slug ?? t('page.{{pageKey}}.title')}>
+  <Section>
+    <Container>
+      <Heading as="h1" size="h1">{slug}</Heading>
+    </Container>
+  </Section>
+</MainLayout>

package/dist/gen/templates/page/static.astro.hbs

@@ -0,0 +1,20 @@
+---
+import Container from '@/components/ui/container.astro'
+import Heading from '@/components/ui/heading.astro'
+import Section from '@/components/ui/section.astro'
+import MainLayout from '@/layouts/main.astro'
+
+import { useTranslations } from '@/i18n/translate'
+
+const t = useTranslations(Astro.currentLocale)
+const title = t('page.{{pageKey}}.title')
+const description = t('page.{{pageKey}}.description')
+---
+
+<MainLayout {title} {description}>
+  <Section>
+    <Container>
+      <Heading as="h1" size="h1">{title}</Heading>
+    </Container>
+  </Section>
+</MainLayout>

package/dist/gen/templates/section/component.astro.hbs

@@ -0,0 +1,45 @@
+---
+{{#if image}}
+import { Image } from 'astro:assets'
+
+{{/if}}
+import Button from '@/components/ui/button.astro'
+import Container from '@/components/ui/container.astro'
+import Heading from '@/components/ui/heading.astro'
+import Section from '@/components/ui/section.astro'
+import type { {{pascalCase collection}}Sections } from '@/lib/{{dashCase collection}}'
+
+import { ctaHref } from '@/i18n/href'
+
+type Props = {{pascalCase collection}}Sections['{{camelCase section}}']
+
+const { title, body, {{#if image}}image, {{/if}}buttons } = Astro.props
+const href = (url: string) => ctaHref(Astro.currentLocale, url)
+---
+
+<Section class="border-b border-border bg-background">
+  <Container>
+    <Heading as="h2">{title}</Heading>
+    {body && <p class="mt-4 max-w-2xl text-pretty text-muted-foreground">{body}</p>}
+    {{#if image}}
+    <Image
+      src={image.src}
+      alt={image.alt}
+      widths={[640, 960, 1280, 1920]}
+      sizes="(min-width: 96rem) 96rem, 100vw"
+      class="mt-8 h-auto w-full rounded-lg"
+    />
+    {{/if}}
+    {
+      buttons.length > 0 && (
+        <div class="mt-8 flex flex-wrap gap-4">
+          {buttons.map((button, index) => (
+            <Button as="a" href={href(button.url)} variant={index === 0 ? 'default' : 'outline'}>
+              {button.label}
+            </Button>
+          ))}
+        </div>
+      )
+    }
+  </Container>
+</Section>

package/dist/gen/templates/section/content.yml.hbs

@@ -0,0 +1,10 @@
+section: {{camelCase section}}
+title: Titolo della sezione
+body: >-
+  Contenuto placeholder della sezione. Sostituiscilo col copy reale del progetto.
+{{#if image}}
+image:
+  src: ../../assets/placeholder.jpg
+  alt: Descrizione dell'immagine
+{{/if}}
+buttons: []

package/dist/gen/templates/section/schema.ts.hbs

@@ -0,0 +1,20 @@
+{{#if image}}
+import type { SchemaContext } from 'astro:content'
+{{/if}}
+import { z } from 'astro/zod'
+
+import { ctaSchema{{#if image}}, imageSchema{{/if}} } from '../common'
+
+export function {{camelCase section}}SectionSchema({{#if image}}{ image }: SchemaContext{{/if}}) {
+  return z.strictObject({
+    section: z.literal('{{camelCase section}}'),
+    title: z.string().min(1),
+    body: z.string().optional(),
+    {{#if image}}
+    image: imageSchema(image),
+    {{/if}}
+    buttons: z.array(ctaSchema).default([]),
+  })
+}
+
+export type {{pascalCase section}}Section = z.infer<ReturnType<typeof {{camelCase section}}SectionSchema>>

package/dist/gen/templates/sections/data-layer.ts.hbs

@@ -0,0 +1,13 @@
+import { loadLocalizedSections, type SectionedPage } from '@/lib/content/localized-sections'
+
+export type {{pascalCase collection}}Sections = SectionedPage<'{{dashCase collection}}'>
+
+export async function get{{pascalCase collection}}Sections(locale?: string): Promise<{{pascalCase collection}}Sections> {
+  const { pick } = await loadLocalizedSections('{{dashCase collection}}', locale)
+
+  // INJECTION POINT per `pnpm gen:section` (ts-morph): le sezioni nuove aggiungono qui il
+  // loro pick() — il generatore verifica questo letterale di ritorno.
+  return {
+    {{camelCase section}}: pick('{{camelCase section}}'),
+  }
+}

package/dist/gen/templates/sections/index.ts.hbs

@@ -0,0 +1,12 @@
+{{#if image}}
+import type { SchemaContext } from 'astro:content'
+{{/if}}
+import { z } from 'astro/zod'
+
+import { {{camelCase section}}SectionSchema } from './{{dashCase section}}'
+
+// INJECTION POINT per `pnpm gen:section` (ts-morph): il generatore verifica questa funzione
+// e la sua chiamata a z.discriminatedUnion.
+export function {{camelCase collection}}CollectionSchema({{#if image}}context: SchemaContext{{/if}}) {
+  return z.discriminatedUnion('section', [{{camelCase section}}SectionSchema({{#if image}}context{{/if}})])
+}

package/dist/gen/templates/sections/page.astro.hbs

@@ -0,0 +1,30 @@
+---
+import {{pascalCase section}} from '@/components/{{dashCase collection}}/{{dashCase section}}.astro'
+import Container from '@/components/ui/container.astro'
+import Heading from '@/components/ui/heading.astro'
+import Section from '@/components/ui/section.astro'
+
+import MainLayout from '@/layouts/main.astro'
+
+import { get{{pascalCase collection}}Sections } from '@/lib/{{dashCase collection}}'
+
+import { useTranslations } from '@/i18n/translate'
+
+// @gen:{{dashCase collection}}-imports (i generatori inseriscono i nuovi import SOPRA questa riga)
+
+const t = useTranslations(Astro.currentLocale)
+const title = t('page.{{pageKey}}.title')
+const description = t('page.{{pageKey}}.description')
+const content = await get{{pascalCase collection}}Sections(Astro.currentLocale)
+---
+
+<MainLayout {title} {description}>
+  <Section>
+    <Container>
+      <Heading as="h1" size="h1">{title}</Heading>
+    </Container>
+  </Section>
+  {{!-- Handlebars legge "}}}" come chiusura di un'espressione non escapata: il tilde chiude il mustache prima della graffa di Astro. --}}
+  <{{pascalCase section}} {...content.{{camelCase section~}}} />
+  {/* @gen:{{dashCase collection}}-sections */}
+</MainLayout>

package/dist/gen/ts-morph-utils.mjs

@@ -0,0 +1,8 @@
+export function isNameTaken(sourceFile, name) {
+    if (sourceFile.getVariableDeclaration(name) || sourceFile.getFunction(name))
+        return true;
+    return sourceFile
+        .getImportDeclarations()
+        .some((d) => d.getNamedImports().some((n) => (n.getAliasNode()?.getText() ?? n.getName()) === name) ||
+        d.getDefaultImport()?.getText() === name);
+}

package/dist/lib/contract.js

@@ -0,0 +1,59 @@
+import { existsSync, readdirSync, readFileSync, statSync } from 'node:fs';
+import { join } from 'node:path';
+export const CONTRACT = [
+    { kind: 'file', path: 'src/components/ui/section.astro', reason: 'le sezioni generate la importano' },
+    { kind: 'file', path: 'src/components/ui/container.astro', reason: 'le sezioni e le pagine generate lo importano' },
+    { kind: 'file', path: 'src/components/ui/heading.astro', reason: 'le sezioni e le pagine generate lo importano' },
+    { kind: 'file', path: 'src/components/ui/button.astro', reason: 'le sezioni generate lo importano' },
+    { kind: 'file', path: 'src/layouts/main.astro', reason: 'le pagine generate lo usano come layout' },
+    { kind: 'file', path: 'src/i18n/translate.ts', reason: 'le pagine generate traducono titolo e descrizione' },
+    { kind: 'file', path: 'src/i18n/href.ts', reason: 'le sezioni generate localizzano i link delle CTA' },
+    { kind: 'file', path: 'src/i18n/ui.ts', reason: 'gen:page registra lì le chiavi della pagina' },
+    {
+        kind: 'directory',
+        path: 'src/i18n/strings',
+        extension: '.ts',
+        reason: 'gen:page scrive le stringhe in ogni dizionario',
+    },
+    { kind: 'file', path: 'src/lib/utils.ts', reason: 'i componenti generati usano cn()' },
+    {
+        kind: 'file',
+        path: 'src/lib/content/localized-sections.ts',
+        reason: 'lo strato dati di una pagina a sezioni lo usa',
+    },
+    {
+        kind: 'directory',
+        path: 'src/lib/schemas',
+        extension: '.ts',
+        reason: 'gen:collection e gen:section scrivono lì gli schemi',
+    },
+    {
+        kind: 'anchor',
+        path: 'src/content.config.ts',
+        text: 'export const collections',
+        reason: 'gen:collection e gen:section registrano lì la collection',
+    },
+];
+function hasFileWith(directory, extension) {
+    if (!existsSync(directory) || !statSync(directory).isDirectory())
+        return false;
+    return readdirSync(directory, { recursive: true }).some((entry) => String(entry).endsWith(extension));
+}
+function gapFor(root, requirement) {
+    const target = join(root, requirement.path);
+    if (requirement.kind === 'directory') {
+        return hasFileWith(target, requirement.extension) ? undefined : `manca, o è vuota: ${requirement.reason}`;
+    }
+    if (!existsSync(target))
+        return `manca: ${requirement.reason}`;
+    if (requirement.kind === 'anchor' && !readFileSync(target, 'utf8').includes(requirement.text)) {
+        return `manca l'ancoraggio \`${requirement.text}\`: ${requirement.reason}`;
+    }
+    return undefined;
+}
+export function contractGaps(root) {
+    return CONTRACT.flatMap((requirement) => {
+        const message = gapFor(root, requirement);
+        return message === undefined ? [] : [{ path: requirement.path, message }];
+    });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@elia97/officina",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "Gli strumenti dei progetti nati dai template di Elia: gate di qualità e, più avanti, generatori.",
   "type": "module",
   "license": "MIT",
@@ -29,8 +29,12 @@
     "typescript": "^7.0.2",
     "vitest": "^4.1.11"
   },
+  "dependencies": {
+    "plop": "^4.0.5",
+    "ts-morph": "^28.0.0"
+  },
   "scripts": {
-    "build": "tsc -p tsconfig.build.json",
+    "build": "rm -rf dist && tsc -p tsconfig.build.json && cp -r src/gen/templates dist/gen/templates",
     "typecheck": "tsc --noEmit",
     "test": "vitest run --coverage",
     "format": "biome check --write .",