gazetta 0.4.0 → 0.6.0

package/dist/cli/index.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { resolve, join, dirname } from 'node:path';
+import { resolve, join, dirname, relative } from 'node:path';
 import { watch, existsSync, readFileSync } from 'node:fs';
 import { serve } from '@hono/node-server';
 import { serveStatic } from '@hono/node-server/serve-static';
@@ -11,18 +11,19 @@ import { resolvePage } from '../resolver.js';
 import { renderPage } from '../renderer.js';
 import { createFilesystemProvider } from '../providers/filesystem.js';
 import { invalidateTemplate, invalidateAllTemplates } from '../template-loader.js';
+import { getEnvironment, getType, isEditable } from '../types.js';
 import { createAdminApp } from '../admin-api/index.js';
 // ANSI color helpers — no dependency, suppressed when NO_COLOR or CI
 const noColor = !!process.env.NO_COLOR || !process.stdout.isTTY;
 const c = {
-    bold: (s) => noColor ? s : `\x1b[1m${s}\x1b[22m`,
-    dim: (s) => noColor ? s : `\x1b[2m${s}\x1b[22m`,
-    cyan: (s) => noColor ? s : `\x1b[36m${s}\x1b[39m`,
-    green: (s) => noColor ? s : `\x1b[32m${s}\x1b[39m`,
-    yellow: (s) => noColor ? s : `\x1b[33m${s}\x1b[39m`,
-    red: (s) => noColor ? s : `\x1b[31m${s}\x1b[39m`,
-    magenta: (s) => noColor ? s : `\x1b[35m${s}\x1b[39m`,
-    bgGreen: (s) => noColor ? s : `\x1b[42m\x1b[30m${s}\x1b[39m\x1b[49m`,
+    bold: (s) => (noColor ? s : `\x1b[1m${s}\x1b[22m`),
+    dim: (s) => (noColor ? s : `\x1b[2m${s}\x1b[22m`),
+    cyan: (s) => (noColor ? s : `\x1b[36m${s}\x1b[39m`),
+    green: (s) => (noColor ? s : `\x1b[32m${s}\x1b[39m`),
+    yellow: (s) => (noColor ? s : `\x1b[33m${s}\x1b[39m`),
+    red: (s) => (noColor ? s : `\x1b[31m${s}\x1b[39m`),
+    magenta: (s) => (noColor ? s : `\x1b[35m${s}\x1b[39m`),
+    bgGreen: (s) => (noColor ? s : `\x1b[42m\x1b[30m${s}\x1b[39m\x1b[49m`),
 };
 const args = process.argv.slice(2);
 const command = args[0];
@@ -134,10 +135,20 @@ function printHelp() {
     gazetta serve [target] [site]   Serve published pages from target storage
     gazetta deploy [target] [site]  Deploy worker to hosting (one-time setup)
     gazetta validate [site]         Check site for broken references
+    gazetta translate <item> --to <locale> [target]
+                                    Create a locale copy of a page or fragment
+    gazetta history [target] [site] List revisions on a target
+    gazetta undo [target] [site]    Restore the previous revision (soft undo)
+    gazetta rollback <rev> [target] [site]
+                                    Restore an arbitrary revision by id
     gazetta help                    Show this help message
 
   Options:
     --port, -p <port>               Server port (default: 3000)
+    --force, -f                     Publish all items (skip unchanged check)
+    --yes, -y                       Skip confirmation prompt (required in CI
+                                    for undo/rollback on production targets)
+    --limit <n>                     Max revisions to list (default: 50)
 
   Auto-detection:
     Site is auto-detected from sites/ directory. If multiple sites exist,
@@ -154,20 +165,41 @@ function printHelp() {
     gazetta publish production my-site  # publish specific site to production
     gazetta serve production -p 8080    # serve production on port 8080
     gazetta validate                    # check site for errors
+    gazetta history                     # list revisions on default target
+    gazetta undo production --yes       # undo last write on production (CI-safe)
+    gazetta rollback rev-1776337441608  # roll back to a specific revision
 `);
 }
 function parseArgs(input) {
     const positional = [];
     let port;
+    let force = false;
+    let yes = false;
+    let limit;
     for (let i = 0; i < input.length; i++) {
         if (input[i] === '--port' || input[i] === '-p') {
             port = parseInt(input[++i], 10);
         }
+        else if (input[i] === '--force' || input[i] === '-f') {
+            force = true;
+        }
+        else if (input[i] === '--yes' || input[i] === '-y') {
+            yes = true;
+        }
+        else if (input[i] === '--limit') {
+            limit = parseInt(input[++i], 10);
+        }
+        else if (input[i] === '--to') {
+            i++; // consume the locale value — translate command reads it from raw args
+        }
+        else if (input[i].startsWith('--to=')) {
+            // consumed by translate command directly
+        }
         else if (!input[i].startsWith('-')) {
             positional.push(input[i]);
         }
     }
-    return { positional, port };
+    return { positional, port, force, yes, limit };
 }
 /**
  * Resolve the site directory from positional args or auto-detection.
@@ -198,8 +230,7 @@ async function resolveSiteDir(positionalSite) {
     const sitesDir = resolve('sites');
     if (existsSync(sitesDir)) {
         const { readdirSync, statSync } = await import('node:fs');
-        const sites = readdirSync(sitesDir)
-            .filter(name => {
+        const sites = readdirSync(sitesDir).filter(name => {
             const dir = join(sitesDir, name);
             return statSync(dir).isDirectory() && existsSync(join(dir, 'site.yaml'));
         });
@@ -262,7 +293,7 @@ async function runInit(dir) {
     }
     const name = target.split('/').pop() ?? 'my-site';
     const files = {
-        'sites/main/site.yaml': `name: ${name}\nversion: 1.0.0\nsystemPages:\n  - "404"\ntargets:\n  local:\n    storage:\n      type: filesystem\n      path: ./dist/local\n`,
+        'sites/main/site.yaml': `name: ${name}\nversion: 1.0.0\nsystemPages:\n  - "404"\ntargets:\n  local:\n    storage:\n      type: filesystem\n    # environment=local, editable=true (defaults); path=./targets/local (default)\n`,
         'templates/page-layout/index.ts': `import { z } from 'zod'
 import type { TemplateFunction } from 'gazetta'
 
@@ -351,20 +382,28 @@ const template: TemplateFunction = ({ content = {} }) => {
 
 export default template
 `,
-        'sites/main/fragments/header/fragment.json': JSON.stringify({
+        'sites/main/targets/local/fragments/header/fragment.json': JSON.stringify({
             template: 'nav',
             content: { brand: name, links: [{ label: 'Home', href: '/' }] },
         }, null, 2) + '\n',
-        'sites/main/pages/home/page.json': JSON.stringify({
+        'sites/main/targets/local/pages/home/page.json': JSON.stringify({
             template: 'page-layout',
             content: { title: name, description: 'A site built with Gazetta' },
             components: [
                 '@header',
-                { name: 'hero', template: 'hero', content: { title: `Welcome to ${name}`, subtitle: 'A site built with Gazetta' } },
-                { name: 'intro', template: 'text-block', content: { body: '<p>Edit this content in the CMS at <a href="/admin">/admin</a>.</p>' } },
+                {
+                    name: 'hero',
+                    template: 'hero',
+                    content: { title: `Welcome to ${name}`, subtitle: 'A site built with Gazetta' },
+                },
+                {
+                    name: 'intro',
+                    template: 'text-block',
+                    content: { body: '<p>Edit this content in the CMS at <a href="/admin">/admin</a>.</p>' },
+                },
             ],
         }, null, 2) + '\n',
-        'sites/main/pages/404/page.json': JSON.stringify({
+        'sites/main/targets/local/pages/404/page.json': JSON.stringify({
             template: 'page-layout',
             content: { title: 'Page Not Found', description: "The page you're looking for doesn't exist." },
         }, null, 2) + '\n',
@@ -408,24 +447,25 @@ export default template
     const cdStep = dir !== '.' ? `cd ${dir} && ` : '';
     outro(`Done! Run: ${c.cyan(`${cdStep}npx gazetta dev`)}`);
 }
-async function runPublish(siteDir, targetName) {
-    const storage = createFilesystemProvider();
+async function runPublish(siteDir, targetName, opts = {}) {
     const projectRoot = detectProjectRoot(siteDir);
     const templatesDir = join(projectRoot, 'templates');
-    const site = await loadSite({ siteDir, storage, templatesDir });
-    // Load target configs from site.yaml
-    const siteYamlPath = join(siteDir, 'site.yaml');
-    if (!existsSync(siteYamlPath)) {
-        console.error(`\n  ${c.red('Error:')} No site.yaml found at ${siteDir}\n`);
+    // Source comes from the default editable target in site.yaml.
+    const { buildSourceContext } = await import('./bootstrap.js');
+    let source, manifest, targetConfigs;
+    try {
+        ;
+        ({ source, manifest, targetConfigs } = await buildSourceContext({ projectSiteDir: siteDir }));
+    }
+    catch (err) {
+        console.error(`\n  ${c.red('Error:')} ${err.message}\n`);
         process.exit(1);
     }
-    const siteYaml = yaml.load(readFileSync(siteYamlPath, 'utf-8'));
+    const storage = source.storage;
+    const site = await loadSite({ contentRoot: source.contentRoot, templatesDir, manifest });
+    const siteYaml = manifest;
     if (!siteYaml.targets || Object.keys(siteYaml.targets).length === 0) {
-        console.error(`\n  Error: no targets configured in ${siteYamlPath}`);
-        console.error(`\n  Add a target to site.yaml:\n`);
-        console.error(`    targets:`);
-        console.error(`      staging:`);
-        console.error(`        storage: { type: filesystem, path: ./dist/staging }\n`);
+        console.error(`\n  Error: no targets configured in site.yaml`);
         process.exit(1);
     }
     // Determine which targets to publish to
@@ -440,6 +480,7 @@ async function runPublish(siteDir, targetName) {
     const { createTargetRegistry } = await import('../targets.js');
     const targets = await createTargetRegistry(Object.fromEntries(targetNames.map(n => [n, siteYaml.targets[n]])), siteDir);
     const { publishPageRendered, publishPageStatic, publishFragmentRendered, publishSiteManifest, publishFragmentIndex } = await import('../publish-rendered.js');
+    const { publishPageAllLocales, publishFragmentAllLocales } = await import('../publish-locale.js');
     const { scanTemplates, templateHashesFrom, reportTemplateErrors } = await import('../templates-scan.js');
     const { hashManifest } = await import('../hash.js');
     // Validate + hash templates once for this publish run
@@ -464,42 +505,233 @@ async function runPublish(siteDir, targetName) {
             continue;
         }
         const targetConfig = siteYaml.targets[name];
-        const { getPublishMode } = await import('../types.js');
-        const publishMode = targetConfig ? getPublishMode(targetConfig) : 'static';
-        const isStatic = publishMode === 'static';
-        console.log(`  ${c.bold(name)} ${c.dim(`(${publishMode})`)}`);
+        const { getType } = await import('../types.js');
+        const targetType = targetConfig ? getType(targetConfig) : 'static';
+        const isStatic = targetType === 'static';
+        console.log(`  ${c.bold(name)} ${c.dim(`(${targetType})`)}`);
         let totalFiles = 0;
         let totalRemoved = 0;
+        // Incremental: compare source hashes against target sidecars, skip
+        // items whose hash already matches the target. --force bypasses.
+        const unchanged = new Set();
+        if (!opts.force) {
+            const { compareTargets } = await import('../compare.js');
+            const cmp = await compareTargets({
+                sourceRoot: source.contentRoot,
+                target: targetStorage,
+                templatesDir,
+                projectRoot,
+                type: targetType,
+                scanTemplates: async () => templateInfos,
+                manifest,
+            });
+            for (const item of cmp.unchanged)
+                unchanged.add(item);
+        }
+        let skipped = 0;
+        const sourceRoot = source.contentRoot;
+        // SEO context for this target — built once, shared across all page renders.
+        const seo = {
+            siteName: site.manifest.name,
+            siteUrl: targetConfig?.siteUrl,
+            locale: site.manifest.locale,
+            defaultOgImage: site.manifest.defaultOgImage,
+        };
         if (isStatic) {
-            // Static mode — fully assembled HTML, no fragments needed separately
+            // Static mode — fully assembled HTML, no fragments needed separately.
+            // Page hash must include fragment hashes so a fragment change
+            // invalidates every page that bakes it in (compareTargets uses the
+            // same combination on the local side).
+            const fragmentHashes = new Map();
+            for (const [fragName, frag] of site.fragments) {
+                fragmentHashes.set(fragName, hashManifest(frag, { templateHashes }));
+            }
             for (const [pageName, page] of site.pages) {
-                const manifestHash = hashManifest(page, { templateHashes });
-                const { files } = await publishPageStatic(pageName, storage, siteDir, targetStorage, templatesDir, manifestHash);
+                if (unchanged.has(`pages/${pageName}`)) {
+                    skipped++;
+                    continue;
+                }
+                const manifestHash = hashManifest(page, { templateHashes, fragmentHashes });
+                const { files } = await publishPageStatic(pageName, sourceRoot, targetStorage, templatesDir, manifestHash, site, seo);
                 totalFiles += files;
                 console.log(`    ${c.green('✓')} ${pageName}`);
             }
         }
         else {
             // ESI mode — fragments separate, pages with placeholders
-            for (const [fragName, frag] of site.fragments) {
-                const manifestHash = hashManifest(frag, { templateHashes });
-                const { files, removed } = await publishFragmentRendered(fragName, storage, siteDir, targetStorage, templatesDir, manifestHash);
+            for (const [fragName] of site.fragments) {
+                // Build per-locale unchanged set: null = default, 'fr' = French
+                const fragUnchanged = new Set();
+                if (unchanged.has(`fragments/${fragName}`))
+                    fragUnchanged.add(null);
+                const fragLocales = site.fragmentLocales.get(fragName);
+                if (fragLocales) {
+                    for (const loc of fragLocales.locales.keys()) {
+                        if (unchanged.has(`fragments/${fragName}:${loc}`))
+                            fragUnchanged.add(loc);
+                    }
+                }
+                // Skip entirely if all locales unchanged
+                const totalFragLocales = 1 + (fragLocales?.locales.size ?? 0);
+                if (fragUnchanged.size >= totalFragLocales) {
+                    skipped++;
+                    continue;
+                }
+                const { files, removed } = await publishFragmentAllLocales(fragName, sourceRoot, targetStorage, site, { templateHashes }, { templatesDir, targetLocales: targetConfig?.locales, unchangedLocales: fragUnchanged });
                 totalFiles += files;
                 totalRemoved += removed;
-                console.log(`    ${c.green('✓')} @${fragName}`);
+                const skippedCount = fragUnchanged.size > 0 ? ` (${fragUnchanged.size} locale${fragUnchanged.size > 1 ? 's' : ''} skipped)` : '';
+                console.log(`    ${c.green('✓')} @${fragName}${skippedCount}`);
             }
-            for (const [pageName, page] of site.pages) {
-                const manifestHash = hashManifest(page, { templateHashes });
-                const { files, removed } = await publishPageRendered(pageName, storage, siteDir, targetStorage, targetConfig?.cache, templatesDir, manifestHash);
+            for (const [pageName] of site.pages) {
+                // Build per-locale unchanged set
+                const pageUnchanged = new Set();
+                if (unchanged.has(`pages/${pageName}`))
+                    pageUnchanged.add(null);
+                const pageLocales = site.pageLocales.get(pageName);
+                if (pageLocales) {
+                    for (const loc of pageLocales.locales.keys()) {
+                        if (unchanged.has(`pages/${pageName}:${loc}`))
+                            pageUnchanged.add(loc);
+                    }
+                }
+                const totalPageLocales = 1 + (pageLocales?.locales.size ?? 0);
+                if (pageUnchanged.size >= totalPageLocales) {
+                    skipped++;
+                    continue;
+                }
+                const { files, removed } = await publishPageAllLocales(pageName, sourceRoot, targetStorage, site, { templateHashes }, {
+                    cache: targetConfig?.cache,
+                    templatesDir,
+                    seo,
+                    targetLocales: targetConfig?.locales,
+                    unchangedLocales: pageUnchanged,
+                });
                 totalFiles += files;
                 totalRemoved += removed;
-                console.log(`    ${c.green('✓')} ${pageName}`);
+                const skippedCount = pageUnchanged.size > 0 ? ` (${pageUnchanged.size} locale${pageUnchanged.size > 1 ? 's' : ''} skipped)` : '';
+                console.log(`    ${c.green('✓')} ${pageName}${skippedCount}`);
             }
         }
+        if (skipped > 0)
+            console.log(`    ${c.dim(`· ${skipped} unchanged (skipped)`)}`);
         // Site manifest + fragment index
-        await publishSiteManifest(storage, siteDir, targetStorage);
-        await publishFragmentIndex(storage, siteDir, targetStorage);
+        await publishSiteManifest(sourceRoot, targetStorage, site);
+        await publishFragmentIndex(sourceRoot, targetStorage, site);
         totalFiles += 2;
+        // Sitemap + robots.txt — generated from target sidecars
+        const siteUrl = targetConfig?.siteUrl;
+        if (siteUrl) {
+            const { listSidecars } = await import('../sidecars.js');
+            const { generateSitemap } = await import('../sitemap.js');
+            const { generateRobotsTxt } = await import('../robots.js');
+            const targetPageSidecars = await listSidecars(targetStorage, 'pages');
+            // Merge source-side knowledge — listSidecars may miss just-written
+            // entries on R2 due to eventual list-after-write consistency. Every
+            // page we just published gets an entry even if the listing missed it.
+            const now = new Date().toISOString();
+            for (const [pageName, page] of site.pages) {
+                if (!targetPageSidecars.has(pageName)) {
+                    targetPageSidecars.set(pageName, {
+                        hash: '',
+                        uses: [],
+                        template: page.template,
+                        pub: { lastPublished: now, noindex: !!page.metadata?.robots?.includes('noindex') },
+                    });
+                }
+            }
+            for (const [pageName, localeEntry] of site.pageLocales) {
+                for (const [loc, localePage] of localeEntry.locales) {
+                    const key = `${pageName}:${loc}`;
+                    if (!targetPageSidecars.has(key)) {
+                        targetPageSidecars.set(key, {
+                            hash: '',
+                            uses: [],
+                            template: localePage.template,
+                            pub: { lastPublished: now, noindex: !!localePage.metadata?.robots?.includes('noindex') },
+                        });
+                    }
+                }
+            }
+            const { resolveSiteLocales, defaultLocaleFor } = await import('../locale.js');
+            // Build hreflang groups — two strategies:
+            // 1. Subpath: same siteUrl, multiple locales → locale-prefixed routes
+            // 2. Cross-domain: other targets with different siteUrl → cross-link
+            const resolvedLoc = resolveSiteLocales(manifest);
+            const defLoc = defaultLocaleFor(manifest);
+            const hreflangGroups = new Map();
+            if (resolvedLoc) {
+                const { localeRoutePrefix } = await import('../locale.js');
+                const thisTargetLocales = targetConfig?.locales ?? resolvedLoc.supported;
+                const thisTargetDefault = targetConfig?.locale ?? defLoc;
+                for (const [pageName, page] of site.pages) {
+                    if (pageName.includes('['))
+                        continue;
+                    const alternates = [];
+                    // Subpath alternates on this target
+                    if (thisTargetLocales.length > 1) {
+                        for (const loc of thisTargetLocales) {
+                            const prefix = localeRoutePrefix(loc, { ...resolvedLoc, default: thisTargetDefault });
+                            const route = page.route === '/' ? prefix || '/' : `${prefix}${page.route}`;
+                            alternates.push({ locale: loc, url: `${siteUrl}${route}` });
+                        }
+                    }
+                    else {
+                        // Single-locale target — add self
+                        alternates.push({ locale: thisTargetLocales[0] ?? defLoc, url: `${siteUrl}${page.route}` });
+                    }
+                    // Cross-domain alternates from other targets
+                    for (const [otherName, otherConfig] of Object.entries(siteYaml.targets ?? {})) {
+                        if (otherName === name)
+                            continue; // skip self
+                        if (!otherConfig.siteUrl)
+                            continue;
+                        const otherLocales = otherConfig.locales ?? resolvedLoc.supported;
+                        const otherDefault = otherConfig.locale ?? defLoc;
+                        for (const loc of otherLocales) {
+                            // Skip locales already covered by this target
+                            if (alternates.some(a => a.locale === loc))
+                                continue;
+                            const otherResolved = { ...resolvedLoc, default: otherDefault };
+                            const prefix = localeRoutePrefix(loc, otherResolved);
+                            const route = page.route === '/' ? prefix || '/' : `${prefix}${page.route}`;
+                            alternates.push({ locale: loc, url: `${otherConfig.siteUrl}${route}` });
+                        }
+                    }
+                    if (alternates.length > 1) {
+                        hreflangGroups.set(pageName, alternates);
+                    }
+                }
+            }
+            const sitemapXml = generateSitemap({
+                siteUrl,
+                pages: targetPageSidecars,
+                systemPages: site.manifest.systemPages,
+                hreflangGroups: hreflangGroups.size > 0 ? hreflangGroups : undefined,
+                defaultLocale: defLoc,
+            });
+            if (sitemapXml) {
+                await targetStorage.writeFile('sitemap.xml', sitemapXml);
+                totalFiles++;
+                console.log(`    ${c.dim('· sitemap.xml')}`);
+            }
+            // robots.txt: only at the domain root — Google ignores robots.txt at
+            // subpaths. If siteUrl has a path component, the domain root belongs
+            // to someone else (host, reverse proxy, another app).
+            const isRootDeploy = !new URL(siteUrl).pathname.replace(/\/+$/, '');
+            if (isRootDeploy) {
+                let robotsTxt;
+                try {
+                    robotsTxt = await source.contentRoot.storage.readFile(source.contentRoot.path('robots.txt'));
+                }
+                catch {
+                    robotsTxt = generateRobotsTxt({ siteUrl });
+                }
+                await targetStorage.writeFile('robots.txt', robotsTxt);
+                totalFiles++;
+                console.log(`    ${c.dim('· robots.txt')}`);
+            }
+        }
         const removedMsg = totalRemoved > 0 ? c.dim(` (${totalRemoved} old files cleaned)`) : '';
         console.log(`\n  ${c.green('✓')} ${c.bold(name)}: ${totalFiles} files published${removedMsg}\n`);
     }
@@ -517,7 +749,8 @@ async function runPublish(siteDir, targetName) {
             }
             try {
                 const { lookupCloudflareZoneId } = await import('../publish-rendered.js');
-                const zoneId = resolveEnvVars(purge.zoneId) ?? (config.siteUrl ? await lookupCloudflareZoneId(config.siteUrl, apiToken) : null);
+                const zoneId = resolveEnvVars(purge.zoneId) ??
+                    (config.siteUrl ? await lookupCloudflareZoneId(config.siteUrl, apiToken) : null);
                 if (!zoneId) {
                     console.log(`  ${name}: zone not found, set purge.zoneId or siteUrl`);
                     continue;
@@ -603,8 +836,10 @@ async function runBuild(siteDir) {
     const editorsDir = join(adminDir, 'editors');
     const fieldsDir = join(adminDir, 'fields');
     const entryExtensions = ['.ts', '.tsx', '.jsx'];
-    const hasEditors = existsSync(editorsDir) && (await import('node:fs')).readdirSync(editorsDir).some(f => entryExtensions.some(ext => f.endsWith(ext)));
-    const hasFields = existsSync(fieldsDir) && (await import('node:fs')).readdirSync(fieldsDir).some(f => entryExtensions.some(ext => f.endsWith(ext)));
+    const hasEditors = existsSync(editorsDir) &&
+        (await import('node:fs')).readdirSync(editorsDir).some(f => entryExtensions.some(ext => f.endsWith(ext)));
+    const hasFields = existsSync(fieldsDir) &&
+        (await import('node:fs')).readdirSync(fieldsDir).some(f => entryExtensions.some(ext => f.endsWith(ext)));
     if (hasEditors || hasFields) {
         const { build: esbuild } = await import('esbuild');
         const { writeFile: writeFileAsync, mkdir: mkdirAsync } = await import('node:fs/promises');
@@ -612,7 +847,7 @@ async function runBuild(siteDir) {
         await mkdirAsync(sharedDir, { recursive: true });
         // Build shared dependency bundles (one copy of React, etc.)
         const sharedDeps = {
-            'react': 'export * from "react"; import React from "react"; export default React;',
+            react: 'export * from "react"; import React from "react"; export default React;',
             'react-dom/client': 'export * from "react-dom/client";',
             'react/jsx-runtime': 'export * from "react/jsx-runtime";',
             'gazetta/editor': 'export * from "gazetta/editor";',
@@ -638,14 +873,19 @@ async function runBuild(siteDir) {
                 });
                 importMap[specifier] = `/admin/_shared/${safeName}.js`;
             }
-            catch { /* skip — dep may not be installed */ }
+            catch {
+                /* skip — dep may not be installed */
+            }
             await import('node:fs/promises').then(fs => fs.rm(stubFile, { force: true }));
         }
         console.log(`  ${c.green('✓')} Shared deps: ${Object.keys(importMap).join(', ')}`);
         // Bundle each custom editor/field with shared deps externalized
         const externals = Object.keys(importMap);
         let bundledCount = 0;
-        for (const [kind, srcDir] of [['editors', editorsDir], ['fields', fieldsDir]]) {
+        for (const [kind, srcDir] of [
+            ['editors', editorsDir],
+            ['fields', fieldsDir],
+        ]) {
             if (!existsSync(srcDir))
                 continue;
             const { readdirSync } = await import('node:fs');
@@ -694,11 +934,12 @@ async function runAdmin(siteDir, port) {
         process.exit(1);
     }
     const app = new Hono();
-    app.get('/__reload', (ctx) => ctx.body(null, 204));
-    const fsStorage = createFilesystemProvider();
-    await setupProductionMode(app, siteDir, fsStorage, builtAdminDir, templatesDir, adminDir);
+    app.get('/__reload', ctx => ctx.body(null, 204));
+    const { buildSourceContext } = await import('./bootstrap.js');
+    const { source, targetConfigs } = await buildSourceContext({ projectSiteDir: siteDir });
+    await setupProductionMode(app, source, siteDir, builtAdminDir, templatesDir, adminDir, targetConfigs);
     // SPA fallback for non-API admin routes
-    app.get('*', (ctx) => {
+    app.get('*', ctx => {
         const indexPath = join(builtAdminDir, 'index.html');
         if (existsSync(indexPath))
             return ctx.html(readFileSync(indexPath, 'utf-8'));
@@ -713,7 +954,10 @@ async function runAdmin(siteDir, port) {
         console.log();
     });
     for (const signal of ['SIGINT', 'SIGTERM']) {
-        process.on(signal, () => { console.log(`\n  Shutting down...`); server.close(() => process.exit(0)); });
+        process.on(signal, () => {
+            console.log(`\n  Shutting down...`);
+            server.close(() => process.exit(0));
+        });
     }
 }
 async function runServe(siteDir, port, targetName) {
@@ -734,10 +978,11 @@ async function runServe(siteDir, port, targetName) {
         process.exit(1);
     }
     const { createStorageProvider } = await import('../targets.js');
-    const storage = await createStorageProvider(config.storage, siteDir);
-    const { getPublishMode } = await import('../types.js');
+    // Pass targetName so filesystem path defaults to ./targets/<name> when unset.
+    const storage = await createStorageProvider(config.storage, siteDir, name);
+    const { getType } = await import('../types.js');
     const { createServer } = await import('../serve.js');
-    const app = createServer({ storage, mode: getPublishMode(config) });
+    const app = createServer({ storage, type: getType(config) });
     const server = serve({ fetch: app.fetch, port }, () => {
         console.log();
         console.log(`  ${c.bgGreen(c.bold(' gazetta '))} ${c.green('serve')} ${c.dim(siteYaml.name)} ${c.dim(`(${name})`)}`);
@@ -827,16 +1072,17 @@ async function runDeploy(siteDir, targetName) {
     console.log(`\n  ${c.green('✓')} Worker deployed. Now publish content:\n    ${c.cyan(`gazetta publish ${targetName}`)}\n`);
 }
 async function runValidate(siteDir) {
-    const storage = createFilesystemProvider();
     const projectRoot = detectProjectRoot(siteDir);
     const templatesDir = join(projectRoot, 'templates');
     console.log();
     console.log(`  ${c.bgGreen(c.bold(' gazetta '))} ${c.green('validate')} ${c.dim(siteDir)}`);
     console.log();
-    // 1. Check site.yaml
+    // 1. Check site.yaml + load default editable target's content
     let site;
     try {
-        site = await loadSite({ siteDir, storage, templatesDir });
+        const { buildSourceContext } = await import('./bootstrap.js');
+        const { source, manifest } = await buildSourceContext({ projectSiteDir: siteDir });
+        site = await loadSite({ contentRoot: source.contentRoot, templatesDir, manifest });
         console.log(`  ${c.green('✓')} site.yaml ${c.dim(`— ${site.manifest.name}`)}`);
     }
     catch (err) {
@@ -871,11 +1117,12 @@ async function runValidate(siteDir) {
             errors++;
         }
     }
-    // 4. List templates
+    // 4. List templates (project-level filesystem, not target content)
+    const projectStorage = createFilesystemProvider();
     let templateNames = [];
     try {
-        const entries = await storage.readDir(templatesDir);
-        templateNames = entries.filter(e => e.isDirectory).map(e => e.name);
+        const entries = await projectStorage.readDir(templatesDir);
+        templateNames = entries.filter(e => e.isDirectory).map((e) => e.name);
         console.log(`  ${c.green('✓')} ${c.dim(`${templateNames.length} templates`)}`);
     }
     catch {
@@ -885,7 +1132,9 @@ async function runValidate(siteDir) {
     const adminDir = join(projectRoot, 'admin');
     const editorsDir = join(adminDir, 'editors');
     if (existsSync(editorsDir)) {
-        const editorFiles = (await import('node:fs')).readdirSync(editorsDir).filter(f => f.endsWith('.ts') || f.endsWith('.tsx'));
+        const editorFiles = (await import('node:fs'))
+            .readdirSync(editorsDir)
+            .filter(f => f.endsWith('.ts') || f.endsWith('.tsx'));
         for (const file of editorFiles) {
             const editorName = file.replace(/\.(ts|tsx)$/, '');
             if (!templateNames.includes(editorName)) {
@@ -895,12 +1144,17 @@ async function runValidate(siteDir) {
     }
     // 6. Check for missing custom fields (schema references field but file doesn't exist)
     const fieldsDir = join(adminDir, 'fields');
-    const fieldFiles = existsSync(fieldsDir) ? (await import('node:fs')).readdirSync(fieldsDir).filter(f => f.endsWith('.ts') || f.endsWith('.tsx')).map(f => f.replace(/\.(ts|tsx)$/, '')) : [];
+    const fieldFiles = existsSync(fieldsDir)
+        ? (await import('node:fs'))
+            .readdirSync(fieldsDir)
+            .filter(f => f.endsWith('.ts') || f.endsWith('.tsx'))
+            .map(f => f.replace(/\.(ts|tsx)$/, ''))
+        : [];
     const { loadTemplate } = await import('../template-loader.js');
     const zod = await import('zod');
     for (const tplName of templateNames) {
         try {
-            const loaded = await loadTemplate(storage, templatesDir, tplName);
+            const loaded = await loadTemplate(projectStorage, templatesDir, tplName);
             const jsonSchema = zod.z.toJSONSchema(loaded.schema);
             const props = jsonSchema.properties;
             if (!props)
@@ -913,7 +1167,70 @@ async function runValidate(siteDir) {
                 }
             }
         }
-        catch { /* template load errors already caught above */ }
+        catch {
+            /* template load errors already caught above */
+        }
+    }
+    // 7. Locale validation
+    const { defaultLocaleFor } = await import('../locale.js');
+    const defLoc = defaultLocaleFor(site.manifest);
+    const hasI18n = !!site.manifest.locales?.supported?.length;
+    // 7a. Warn about orphaned locale files when i18n is disabled
+    if (!hasI18n && (site.pageLocales.size > 0 || site.fragmentLocales.size > 0)) {
+        const orphanCount = site.pageLocales.size + site.fragmentLocales.size;
+        console.log(`  ${c.yellow('⚠')} ${orphanCount} locale file${orphanCount > 1 ? 's' : ''} found but i18n is disabled ${c.dim('— add locales.supported to site.yaml or remove *.locale.json files')}`);
+    }
+    // 7b. Warn about ambiguous page.en.json when en is default
+    if (hasI18n) {
+        for (const [name, entry] of site.pageLocales) {
+            if (entry.locales.has(defLoc)) {
+                console.log(`  ${c.yellow('⚠')} page.${defLoc}.json in ${name} is ambiguous ${c.dim(`— "${defLoc}" is the default locale, use page.json instead`)}`);
+            }
+        }
+        for (const [name, entry] of site.fragmentLocales) {
+            if (entry.locales.has(defLoc)) {
+                console.log(`  ${c.yellow('⚠')} fragment.${defLoc}.json in ${name} is ambiguous ${c.dim(`— "${defLoc}" is the default locale, use fragment.json instead`)}`);
+            }
+        }
+    }
+    // 7c. Validate locale variant template/fragment refs
+    if (hasI18n) {
+        for (const [pageName, entry] of site.pageLocales) {
+            for (const [locale] of entry.locales) {
+                try {
+                    await resolvePage(pageName, site, locale);
+                }
+                catch (err) {
+                    console.error(`  ${c.red('✗')} ${pageName} (${locale}) ${c.dim(`— ${err.message}`)}`);
+                    errors++;
+                }
+            }
+        }
+    }
+    // 8. Cross-domain hreflang bidirectional check
+    // For per-domain targets (each with siteUrl + single locale), verify that
+    // all targets serving the same page cross-link to each other.
+    if (hasI18n && site.manifest.targets) {
+        const targetsWithSiteUrl = Object.entries(site.manifest.targets).filter(([, cfg]) => cfg.siteUrl && cfg.locales?.length === 1);
+        if (targetsWithSiteUrl.length > 1) {
+            const localeToUrl = new Map();
+            for (const [, cfg] of targetsWithSiteUrl) {
+                localeToUrl.set(cfg.locales[0], cfg.siteUrl);
+            }
+            const missingPairs = [];
+            for (const [locA, urlA] of localeToUrl) {
+                for (const [locB, urlB] of localeToUrl) {
+                    if (locA === locB)
+                        continue;
+                    // Each target's sitemap should cross-link to the other
+                    // We can't check the actual sitemaps here (would need network),
+                    // but we can verify the config is consistent
+                }
+            }
+            if (localeToUrl.size > 1) {
+                console.log(`  ${c.green('✓')} cross-domain hreflang: ${[...localeToUrl.entries()].map(([l, u]) => `${l} → ${u}`).join(', ')}`);
+            }
+        }
     }
     console.log();
     if (errors > 0) {
@@ -970,19 +1287,26 @@ function renderErrorOverlay(err) {
 </html>`;
 }
 async function runDev(siteDir, port) {
-    const storage = createFilesystemProvider();
     const projectRoot = detectProjectRoot(siteDir);
     const templatesDir = join(projectRoot, 'templates');
     const adminDir = join(projectRoot, 'admin');
-    const site = await loadSite({ siteDir, storage, templatesDir });
+    // Build the source context from the default editable target in site.yaml.
+    // Cloud targets aren't init'd — admin API handles them lazily.
+    const { buildSourceContext } = await import('./bootstrap.js');
+    const { source, manifest, targetConfigs } = await buildSourceContext({ projectSiteDir: siteDir });
+    const site = await loadSite({ contentRoot: source.contentRoot, templatesDir, manifest });
+    const storage = source.storage;
     const app = new Hono();
     // ---- Live reload (SSE) ----
     let reloadId = 0;
     const reloadListeners = new Set();
-    function notifyReload() { reloadId++; for (const l of reloadListeners)
-        l(); }
+    function notifyReload() {
+        reloadId++;
+        for (const l of reloadListeners)
+            l();
+    }
     const RELOAD_SCRIPT = `<script>new EventSource('/__reload').onmessage = () => location.reload()</script>`;
-    app.get('/__reload', (c) => {
+    app.get('/__reload', c => {
         return streamSSE(c, async (stream) => {
             let lastId = reloadId;
             const check = async () => {
@@ -992,20 +1316,47 @@ async function runDev(siteDir, port) {
                 }
             };
             reloadListeners.add(check);
-            stream.onAbort(() => { reloadListeners.delete(check); });
+            stream.onAbort(() => {
+                reloadListeners.delete(check);
+            });
             while (true) {
                 await stream.sleep(500);
                 await check();
             }
         });
     });
-    // ---- Site page routes ----
-    for (const [pageName, page] of site.pages) {
+    // ---- Trailing slash normalization ----
+    // Strip trailing slashes so /fr/ resolves as /fr and /fr/about/ as
+    // /fr/about. Re-dispatches through the Hono router with the clean URL.
+    // No redirect — preserves POST body and avoids round-trips.
+    app.use(async (c, next) => {
+        const url = new URL(c.req.url);
+        if (url.pathname !== '/' && url.pathname.endsWith('/')) {
+            url.pathname = url.pathname.slice(0, -1);
+            return app.fetch(new Request(url, c.req.raw), c.env);
+        }
+        return next();
+    });
+    // ---- Site page routes (default + locale variants) ----
+    const { allPageEntries } = await import('../site-loader.js');
+    for (const { name: pageName, page, locale: pageLocale } of allPageEntries(site)) {
         app.get(page.route, async (c) => {
             try {
-                const freshSite = await loadSite({ siteDir, storage, templatesDir });
-                const resolved = await resolvePage(pageName, freshSite);
-                const html = await renderPage(resolved, c.req.param());
+                const freshSite = await loadSite({ contentRoot: source.contentRoot, templatesDir, manifest });
+                const resolved = await resolvePage(pageName, freshSite, pageLocale);
+                const freshPage = pageLocale
+                    ? freshSite.pageLocales.get(pageName)?.locales.get(pageLocale)
+                    : freshSite.pages.get(pageName);
+                const html = await renderPage(resolved, {
+                    routeParams: c.req.param(),
+                    metadata: freshPage?.metadata ?? page.metadata,
+                    route: freshPage?.route ?? page.route,
+                    seo: {
+                        siteName: freshSite.manifest.name,
+                        locale: pageLocale ?? freshSite.manifest.locale,
+                        defaultOgImage: freshSite.manifest.defaultOgImage,
+                    },
+                });
                 return c.html(html.replace('</body>', `${RELOAD_SCRIPT}\n</body>`));
             }
             catch (err) {
@@ -1013,20 +1364,61 @@ async function runDev(siteDir, port) {
             }
         });
     }
+    // ---- Locale fallback routes for pages without locale variants ----
+    // When a page exists in the default locale but has no page.fr.json,
+    // register /fr{route} that renders the default content with FR locale context.
+    // This prevents 404s on locale-prefixed URLs for untranslated pages.
+    const { resolveSiteLocales } = await import('../locale.js');
+    const resolvedLocales = resolveSiteLocales(manifest);
+    if (resolvedLocales) {
+        const nonDefaultLocales = resolvedLocales.supported.filter(l => l !== resolvedLocales.default);
+        for (const loc of nonDefaultLocales) {
+            for (const [pageName, page] of site.pages) {
+                const hasLocaleVariant = site.pageLocales.get(pageName)?.locales.has(loc);
+                if (hasLocaleVariant)
+                    continue; // already registered by allPageEntries
+                const localeRoute = `/${loc}${page.route === '/' ? '' : page.route}`;
+                app.get(localeRoute, async (c) => {
+                    try {
+                        const freshSite = await loadSite({ contentRoot: source.contentRoot, templatesDir, manifest });
+                        const resolved = await resolvePage(pageName, freshSite, loc);
+                        const freshPage = freshSite.pages.get(pageName);
+                        const html = await renderPage(resolved, {
+                            routeParams: c.req.param(),
+                            metadata: freshPage?.metadata,
+                            route: freshPage?.route,
+                            seo: {
+                                siteName: freshSite.manifest.name,
+                                locale: loc,
+                                defaultOgImage: freshSite.manifest.defaultOgImage,
+                            },
+                        });
+                        return c.html(html.replace('</body>', `${RELOAD_SCRIPT}\n</body>`));
+                    }
+                    catch (err) {
+                        return c.html(renderErrorOverlay(err), 500);
+                    }
+                });
+            }
+        }
+    }
     // ---- Detect mode: dev (monorepo with apps/admin source) vs production (pre-built) ----
     const cmsWebDir = findCmsDir();
     const cmsStaticDir = findCmsStaticDir();
     const isDevMode = cmsWebDir !== null;
+    // Admin Hono instance — captured so the template file watcher can
+    // invalidate its memoized template-scan cache on .ts/.tsx changes.
+    let cmsApp = null;
     if (isDevMode) {
         // Dev mode: mount CMS API inline (same process = shared template cache)
-        await setupCmsApi(app, siteDir, storage, templatesDir, adminDir);
+        cmsApp = await setupCmsApi(app, source, siteDir, templatesDir, adminDir, targetConfigs);
     }
     else if (cmsStaticDir) {
         // Production mode: inline CMS API + static files
-        await setupProductionMode(app, siteDir, storage, cmsStaticDir, templatesDir, adminDir);
+        cmsApp = await setupProductionMode(app, source, siteDir, cmsStaticDir, templatesDir, adminDir, targetConfigs);
     }
     // ---- 404 ----
-    app.notFound((c) => {
+    app.notFound(c => {
         const routes = [...site.pages.entries()].map(([n, p]) => `  ${p.route} → ${n}`).join('\n');
         return c.html(`<pre style="padding:2rem">Page not found: ${c.req.path}\n\nAvailable:\n${routes}\n  /admin → CMS editor</pre>`, 404);
     });
@@ -1045,6 +1437,37 @@ async function runDev(siteDir, port) {
         console.log();
         console.log(`  ${c.dim('┃')} Pages    ${[...site.pages.entries()].map(([n, p]) => `${c.dim(p.route)} ${c.dim('→')} ${n}`).join(c.dim(', '))}`);
         console.log(`  ${c.dim('┃')} Frags    ${c.dim([...site.fragments.keys()].join(', ') || '(none)')}`);
+        // ---- Settings banner ----
+        // Prints resolved configuration at startup so path / target / site
+        // issues are diagnosed immediately instead of via empty API responses.
+        // Opt-in via GAZETTA_QUIET=1 for scripted callers that don't want it.
+        if (!process.env.GAZETTA_QUIET) {
+            const relProject = relative(process.cwd(), projectRoot) || '.';
+            const relSite = relative(projectRoot, siteDir) || '.';
+            const relTemplates = relative(projectRoot, templatesDir) || '.';
+            const sourceName = source.targetName ?? '(none)';
+            const sourceCfg = targetConfigs[sourceName];
+            const sourceEnv = sourceCfg ? getEnvironment(sourceCfg) : 'unknown';
+            const sourceType = sourceCfg ? getType(sourceCfg) : 'unknown';
+            const sourceEditable = sourceCfg ? isEditable(sourceCfg) : false;
+            const sourceRoot = source.contentRoot.rootPath || '.';
+            const targetsCount = Object.keys(targetConfigs).length;
+            console.log();
+            console.log(`  ${c.dim('┃')} ${c.bold('Settings')}`);
+            console.log(`  ${c.dim('┃')}   Project      ${c.dim(relProject)}`);
+            console.log(`  ${c.dim('┃')}   Site         ${c.dim(relSite)}`);
+            console.log(`  ${c.dim('┃')}   Templates    ${c.dim(relTemplates)}`);
+            console.log(`  ${c.dim('┃')}   Source       ${sourceName} ${c.dim(`(${sourceEnv}, ${sourceEditable ? 'editable' : 'read-only'}, ${sourceType})`)}`);
+            console.log(`  ${c.dim('┃')}   Content root ${c.dim(sourceRoot)}`);
+            console.log(`  ${c.dim('┃')}   Targets (${targetsCount})`);
+            for (const [name, cfg] of Object.entries(targetConfigs)) {
+                const env = getEnvironment(cfg);
+                const type = getType(cfg);
+                const ed = isEditable(cfg) ? 'editable ' : 'read-only';
+                const storagePath = cfg.storage?.type === 'filesystem' ? (cfg.storage.path ?? `targets/${name}`) : `${cfg.storage?.type ?? '?'}`;
+                console.log(`  ${c.dim('┃')}     ${c.dim('•')} ${name.padEnd(14)} ${c.dim(env.padEnd(11))} ${c.dim(ed)} ${c.dim(type.padEnd(8))} ${c.dim('→ ' + storagePath)}`);
+            }
+        }
         if (isDevMode && cmsWebDir) {
             // While Vite is spinning up (compiling, scanning deps, attaching
             // middleware), any /admin/* request falls through to the site's 404
@@ -1062,7 +1485,11 @@ async function runDev(siteDir, port) {
                     return true;
                 }
                 if (url === '/admin' || url.startsWith('/admin/') || url.startsWith('/@')) {
-                    res.writeHead(503, { 'Content-Type': 'text/html; charset=utf-8', 'Cache-Control': 'no-store', 'Retry-After': '2' });
+                    res.writeHead(503, {
+                        'Content-Type': 'text/html; charset=utf-8',
+                        'Cache-Control': 'no-store',
+                        'Retry-After': '2',
+                    });
                     res.end(LOADER_HTML);
                     return true;
                 }
@@ -1075,6 +1502,7 @@ async function runDev(siteDir, port) {
                 if (loaderHandler(req, res))
                     return;
                 for (const l of originalListeners) {
+                    ;
                     l(req, res);
                 }
             });
@@ -1102,7 +1530,9 @@ async function runDev(siteDir, port) {
                                 }
                             }
                         }
-                        catch { /* ignore */ }
+                        catch {
+                            /* ignore */
+                        }
                     }
                 }
                 const vite = await createViteServer({
@@ -1131,6 +1561,7 @@ async function runDev(siteDir, port) {
                 });
                 const honoHandler = (req, res) => {
                     for (const listener of originalListeners) {
+                        ;
                         listener(req, res);
                     }
                 };
@@ -1144,7 +1575,10 @@ async function runDev(siteDir, port) {
                         res.end(JSON.stringify({ ready: true }));
                         return;
                     }
-                    if (url.startsWith('/admin/api') || url.startsWith('/admin/preview') || url === '/admin/theme.css' || url.startsWith('/admin/theme.css?')) {
+                    if (url.startsWith('/admin/api') ||
+                        url.startsWith('/admin/preview') ||
+                        url === '/admin/theme.css' ||
+                        url.startsWith('/admin/theme.css?')) {
                         honoHandler(req, res);
                     }
                     else if (url.startsWith('/admin') || url.startsWith('/@')) {
@@ -1154,6 +1588,26 @@ async function runDev(siteDir, port) {
                         honoHandler(req, res);
                     }
                 });
+                // Force Vite to scan deps + complete initial optimization BEFORE we
+                // mark the CMS ready. Without this, `cmsReady = true` fires the
+                // moment Vite is created — loader page reloads, browser starts
+                // fetching the SPA, and Vite's still building the dep bundle in the
+                // background. The first round of imports arrives, Vite finds new
+                // transitive deps, and fires `optimized dependencies changed.
+                // reloading` mid-page-load. That reload cancels in-flight
+                // `/admin/api/*` requests — silently breaking any component that
+                // doesn't retry (FragmentBlastRadius, for one).
+                //
+                // Warm the SPA's main entry module (not index.html — Vite's
+                // import-analysis plugin treats warmupRequest urls as JS modules
+                // and chokes on HTML). The entry's transitive imports are exactly
+                // what the browser will request on first load, so settling them
+                // here means the browser gets a stable bundle. waitForRequestsIdle
+                // blocks until Vite finishes processing the static-import chain,
+                // which includes dep optimization.
+                const ENTRY = '/src/client/main.ts';
+                await vite.warmupRequest(ENTRY);
+                await vite.waitForRequestsIdle(ENTRY);
                 cmsReady = true;
             }
             catch (err) {
@@ -1171,13 +1625,30 @@ async function runDev(siteDir, port) {
     const siteWatcher = watch(siteDir, { recursive: true }, (_event, filename) => {
         if (!filename)
             return;
+        // .gazetta/ is a reserved namespace (history, source-sidecars, etc.) that
+        // the runtime never reads at request time. Writes there are extremely
+        // frequent (one per save/publish × per-target) — treating them as
+        // content changes would flood SSE reloads and reset preview iframe
+        // scroll state mid-test. Filter them out at the watcher boundary.
+        const norm = filename.replace(/\\/g, '/');
+        if (norm.includes('/.gazetta/') || norm.startsWith('.gazetta/'))
+            return;
         if (filename.endsWith('.json') || filename.endsWith('.yaml')) {
             console.log(`  Manifest changed: ${filename}`);
             invalidateAllTemplates();
+            // Refresh source sidecars for external edits (git pull, direct file
+            // edit). PUT routes already handle their own writes — this catches
+            // everything outside the admin UI.
+            const pageMatch = /^pages\/(.+)\/page\.json$/.exec(norm);
+            const fragMatch = /^fragments\/(.+)\/fragment\.json$/.exec(norm);
+            if (pageMatch)
+                cmsApp?.writeSourceSidecar('page', pageMatch[1]).catch(() => { });
+            else if (fragMatch)
+                cmsApp?.writeSourceSidecar('fragment', fragMatch[1]).catch(() => { });
             notifyReload();
         }
     });
-    siteWatcher.on('error', (err) => console.warn(`  File watcher warning (site): ${err.message}`));
+    siteWatcher.on('error', err => console.warn(`  File watcher warning (site): ${err.message}`));
     // Watch templates dir for template source changes
     if (existsSync(templatesDir)) {
         const tplWatcher = watch(templatesDir, { recursive: true }, (_event, filename) => {
@@ -1188,11 +1659,15 @@ async function runDev(siteDir, port) {
                 if (parts.length >= 1) {
                     console.log(`  Template changed: ${parts[0]}`);
                     invalidateTemplate(parts[0]);
+                    // Drop the admin-api's cached scan so next compare/publish
+                    // rehashes. Cheap (the scan is what's slow, not invalidation).
+                    cmsApp?.invalidateTemplatesCache();
+                    cmsApp?.invalidateSourceSidecars();
                     notifyReload();
                 }
             }
         });
-        tplWatcher.on('error', (err) => console.warn(`  File watcher warning (templates): ${err.message}`));
+        tplWatcher.on('error', err => console.warn(`  File watcher warning (templates): ${err.message}`));
     }
 }
 // ---- Mount CMS API on the main Hono app (shared process = shared template cache) ----
@@ -1204,7 +1679,7 @@ async function runDev(siteDir, port) {
  * so user declarations win the cascade. See #134 and css-theming.md.
  */
 function mountUserThemeRoute(cmsApp, adminDir) {
-    cmsApp.get('/theme.css', (c) => {
+    cmsApp.get('/theme.css', c => {
         const themePath = join(adminDir, 'theme.css');
         c.header('Content-Type', 'text/css; charset=utf-8');
         c.header('Cache-Control', 'no-cache');
@@ -1217,34 +1692,22 @@ function mountUserThemeRoute(cmsApp, adminDir) {
         return c.body(readFileSync(themePath, 'utf-8'));
     });
 }
-async function setupCmsApi(app, siteDir, storage, templatesDir, adminDir) {
-    const siteYamlPath = join(siteDir, 'site.yaml');
-    let targetConfigs;
-    if (existsSync(siteYamlPath)) {
-        const siteYaml = yaml.load(readFileSync(siteYamlPath, 'utf-8'));
-        targetConfigs = siteYaml.targets;
-    }
-    const cmsApp = createAdminApp({ siteDir, storage, templatesDir, adminDir, targetConfigs });
+async function setupCmsApi(app, source, siteDir, templatesDir, adminDir, targetConfigs) {
+    const cmsApp = createAdminApp({ source, siteDir, templatesDir, adminDir, targetConfigs });
     mountUserThemeRoute(cmsApp, adminDir);
     app.route('/admin', cmsApp);
+    return cmsApp;
 }
 // ---- Production mode: inline CMS API + static files from admin-dist/ ----
-async function setupProductionMode(app, siteDir, storage, cmsStaticDir, templatesDir, adminDir) {
-    // Read target configs from site.yaml — targets are initialized lazily on first publish/fetch
-    const siteYamlPath = join(siteDir, 'site.yaml');
-    let targetConfigs;
-    if (existsSync(siteYamlPath)) {
-        const siteYaml = yaml.load(readFileSync(siteYamlPath, 'utf-8'));
-        targetConfigs = siteYaml.targets;
-    }
+async function setupProductionMode(app, source, siteDir, cmsStaticDir, templatesDir, adminDir, targetConfigs) {
     // Mount CMS API inline at /admin (production mode — bundled editors/fields)
-    const cmsApp = createAdminApp({ siteDir, storage, templatesDir, adminDir, production: true, targetConfigs });
+    const cmsApp = createAdminApp({ source, siteDir, templatesDir, adminDir, production: true, targetConfigs });
     mountUserThemeRoute(cmsApp, adminDir);
     app.route('/admin', cmsApp);
     // Serve pre-built CMS static files (includes bundled editors/fields)
     app.use('/admin/*', serveStatic({
         root: cmsStaticDir,
-        rewriteRequestPath: (path) => path.replace(/^\/admin/, ''),
+        rewriteRequestPath: path => path.replace(/^\/admin/, ''),
     }));
     // SPA fallback: serve index.html for /admin and unmatched /admin/* routes
     const serveIndex = (c) => {
@@ -1256,6 +1719,7 @@ async function setupProductionMode(app, siteDir, storage, cmsStaticDir, template
     };
     app.get('/admin/*', serveIndex);
     app.get('/admin', serveIndex);
+    return cmsApp;
 }
 /** Find apps/admin source dir (monorepo dev mode) */
 function findCmsDir() {
@@ -1289,11 +1753,15 @@ async function main() {
     }
     const parsed = parseArgs(args.slice(1));
     // Commands that take [target] [site] positional args
-    const targetFirstCommands = new Set(['publish', 'serve', 'deploy']);
+    const targetFirstCommands = new Set(['publish', 'serve', 'deploy', 'history', 'undo']);
     // Commands that take [site] positional arg
     const siteOnlyCommands = new Set(['dev', 'validate', 'admin']);
     let siteDir;
     let targetName;
+    // rollback: positional layout is `<rev> [target] [site]`. We stash
+    // the revision id here because the shared positional parser uses
+    // index 0 for target/site; rollback just consumes index 0 first.
+    let rollbackRevisionId;
     if (command === 'init') {
         await runInit(parsed.positional[0] ?? '.');
         return;
@@ -1303,6 +1771,25 @@ async function main() {
         await runBuild(siteDir);
         return;
     }
+    else if (command === 'rollback') {
+        // gazetta rollback <rev> [target] [site]
+        const [rev, second, third] = parsed.positional;
+        if (!rev || !rev.startsWith('rev-')) {
+            console.error(`\n  Error: rollback requires a revision id as the first argument (e.g. gazetta rollback rev-1776337441608 [target])\n`);
+            process.exit(1);
+            return;
+        }
+        rollbackRevisionId = rev;
+        const secondIsSite = second && (second.includes('/') || existsSync(join(resolve(second), 'site.yaml')));
+        if (secondIsSite) {
+            siteDir = await resolveSiteDir(second);
+            targetName = await resolveTarget(undefined, siteDir);
+        }
+        else {
+            siteDir = await resolveSiteDir(third);
+            targetName = await resolveTarget(second, siteDir);
+        }
+    }
     else if (targetFirstCommands.has(command)) {
         // gazetta publish [target] [site]
         const [first, second] = parsed.positional;
@@ -1320,6 +1807,15 @@ async function main() {
     else if (siteOnlyCommands.has(command)) {
         siteDir = await resolveSiteDir(parsed.positional[0]);
     }
+    else if (command === 'translate') {
+        // gazetta translate <item> --to <locale> [target]
+        // positional args after the item are the optional target name
+        siteDir = await resolveSiteDir(undefined);
+        // Find the target arg — skip the item (pages/... or fragments/...) and --to/locale flags
+        const translatePositionals = parsed.positional.filter(p => !p.startsWith('pages/') && !p.startsWith('fragments/'));
+        if (translatePositionals.length > 0)
+            targetName = translatePositionals[0];
+    }
     else {
         console.error(`  Unknown command: ${command}\n`);
         printHelp();
@@ -1345,7 +1841,7 @@ async function main() {
     }
     switch (command) {
         case 'publish':
-            await runPublish(siteDir, targetName);
+            await runPublish(siteDir, targetName, { force: parsed.force });
             break;
         case 'serve':
             await runServe(siteDir, parsed.port ?? 3000, targetName);
@@ -1362,9 +1858,91 @@ async function main() {
         case 'admin':
             await runAdmin(siteDir, parsed.port ?? 3000);
             break;
+        case 'translate': {
+            const itemArg = args[1];
+            const localeArg = args.find(a => a.startsWith('--to='))?.slice(5) ?? args[args.indexOf('--to') + 1];
+            if (!itemArg || !localeArg) {
+                console.error('  Usage: gazetta translate <pages/name|fragments/name> --to <locale>');
+                console.error('  Example: gazetta translate pages/about --to fr');
+                process.exit(1);
+            }
+            const { normalizeLocale, localeFilename, isValidLocale } = await import('../locale.js');
+            if (!isValidLocale(localeArg)) {
+                console.error(`  Error: invalid locale code "${localeArg}". Use BCP 47 format (e.g. fr, en-gb, pt-br)`);
+                process.exit(1);
+            }
+            const locale = normalizeLocale(localeArg);
+            const isPage = itemArg.startsWith('pages/');
+            const isFragment = itemArg.startsWith('fragments/');
+            if (!isPage && !isFragment) {
+                console.error(`  Error: item must start with pages/ or fragments/ (got "${itemArg}")`);
+                process.exit(1);
+            }
+            // Resolve the content directory — translate operates on a target's filesystem.
+            // Uses the specified target or falls back to the first editable target.
+            const siteYaml = yaml.load(readFileSync(join(siteDir, 'site.yaml'), 'utf-8'));
+            const { isEditable } = await import('../types.js');
+            const resolvedTarget = targetName ?? Object.entries(siteYaml.targets ?? {}).find(([, cfg]) => isEditable(cfg))?.[0];
+            if (!resolvedTarget) {
+                console.error('  Error: no editable target found');
+                process.exit(1);
+            }
+            const targetConfig = siteYaml.targets[resolvedTarget];
+            if (!targetConfig) {
+                console.error(`  Error: target "${resolvedTarget}" not found in site.yaml`);
+                process.exit(1);
+            }
+            const storagePath = targetConfig.storage.path ?? join('targets', resolvedTarget);
+            const contentDir = resolve(siteDir, storagePath);
+            const baseName = isPage ? 'page' : 'fragment';
+            const dir = join(contentDir, itemArg);
+            const sourceFile = join(dir, `${baseName}.json`);
+            const destFile = join(dir, localeFilename(baseName, locale));
+            const fs = await import('node:fs/promises');
+            if (!existsSync(sourceFile)) {
+                console.error(`  Error: ${sourceFile} not found`);
+                process.exit(1);
+            }
+            if (existsSync(destFile)) {
+                console.error(`  Error: ${destFile} already exists`);
+                process.exit(1);
+            }
+            await fs.copyFile(sourceFile, destFile);
+            console.log(`  ${c.green('✓')} Created ${relative(process.cwd(), destFile)}`);
+            console.log(`  Edit the file to translate the content.`);
+            break;
+        }
+        case 'history':
+        case 'undo':
+        case 'rollback': {
+            const { runHistoryList, runHistoryUndo, runHistoryRollback } = await import('./history.js');
+            const ctx = await resolveHistoryContext(siteDir, targetName);
+            if (command === 'history')
+                await runHistoryList(ctx, { limit: parsed.limit });
+            else if (command === 'undo')
+                await runHistoryUndo(ctx, { yes: parsed.yes });
+            else
+                await runHistoryRollback(ctx, rollbackRevisionId, { yes: parsed.yes });
+            break;
+        }
+    }
+}
+/**
+ * Resolve site + target + config into the shape HistoryCommandContext
+ * expects. Lives here rather than in cli/history.ts so the target-
+ * resolution logic (site.yaml parsing, CI env handling) stays with
+ * the other CLI commands that already do it the same way.
+ */
+async function resolveHistoryContext(siteDir, targetName) {
+    const { bootstrapFromSiteYaml } = await import('./bootstrap.js');
+    const { targetConfigs } = await bootstrapFromSiteYaml(siteDir);
+    const config = targetConfigs[targetName];
+    if (!config) {
+        throw new Error(`Unknown target "${targetName}". Available: ${Object.keys(targetConfigs).join(', ')}`);
     }
+    return { siteDir, targetName, config };
 }
-main().catch((err) => {
+main().catch(err => {
     console.error(`\n  Error: ${err.message}\n`);
     process.exit(1);
 });