@askrjs/cli 0.0.3 → 0.0.4

package/dist/ssg.d.ts

@@ -0,0 +1,61 @@
+import { existsSync } from "node:fs";
+//#region src/bin/ssg.d.ts
+type CliIo = Pick<Console, "error" | "log">;
+interface ParsedSsgArgs {
+  configPath: string;
+  outputDir: string;
+  workers: number | "auto";
+  incremental: boolean;
+  changedKeys: string[];
+  changedRoutes: string[];
+  forceFull: boolean;
+  help: boolean;
+  errors: string[];
+}
+interface RouteResult {
+  path: string;
+  filePath: string;
+  status: string;
+  error?: string;
+}
+interface GenerateResult {
+  mode: string;
+  successful: number;
+  totalRoutes: number;
+  failed: number;
+  rebuilt: number;
+  skipped: number;
+  removed: number;
+  cacheHits: number;
+  routes: RouteResult[];
+}
+interface StaticGen {
+  generate(options: ReturnType<typeof toGenerateOptions>): Promise<GenerateResult>;
+}
+interface SsgDeps {
+  cwd?: () => string;
+  now?: () => number;
+  existsSync?: typeof existsSync;
+  importConfig?: (filePath: string) => Promise<unknown>;
+  createStaticGen?: (options: {
+    routes?: unknown[];
+    registry?: unknown;
+    outputDir: string;
+    seed?: unknown;
+    dataOverrides?: unknown;
+    concurrency?: number;
+    parallelism: number | "auto";
+    document?: unknown;
+    assets?: unknown[];
+  }) => StaticGen;
+}
+declare function parseCliArgs(args: string[]): ParsedSsgArgs;
+declare function toGenerateOptions(args: ParsedSsgArgs): {
+  mode: string;
+  changedKeys: string[];
+  changedRoutes: string[];
+  forceFull: boolean;
+};
+declare function runSsgCli(args?: string[], deps?: SsgDeps, io?: CliIo): Promise<number>;
+//#endregion
+export { parseCliArgs, runSsgCli };

package/dist/ssg.js

@@ -1,9 +1,272 @@
 #!/usr/bin/env node
 import { t as isDirectExecution } from "./is-direct-execution-Cdlr-ZUl.js";
-import { dirname, resolve } from "node:path";
-import { existsSync } from "node:fs";
+import { n as publishStagedDirectory, t as createSiblingStage } from "./directory-swap-DWoHtx7C.js";
+import * as fs$1 from "node:fs/promises";
+import { mkdir, readFile, rename, rm, writeFile } from "node:fs/promises";
+import * as path$1 from "node:path";
+import path, { dirname, resolve } from "node:path";
+import { constants, existsSync } from "node:fs";
 import { pathToFileURL } from "node:url";
 import { register } from "tsx/esm/api";
+//#region src/ssg/sitemap.ts
+const datePattern = /^(\d{4})-(\d{2})-(\d{2})(?:T(\d{2}):(\d{2}):(\d{2})(?:\.\d+)?(Z|[+-](\d{2}):(\d{2})))?$/;
+const languagePattern = /^(?:x-default|[A-Za-z]{2,8}(?:-[A-Za-z0-9]{1,8})*)$/;
+const changeFrequencies = /* @__PURE__ */ new Set([
+	"always",
+	"hourly",
+	"daily",
+	"weekly",
+	"monthly",
+	"yearly",
+	"never"
+]);
+const MAX_URLS_PER_SITEMAP = 5e4;
+const MAX_SITEMAP_BYTES = 50 * 1024 * 1024;
+const MANIFEST_PATH = ".askr/sitemap-manifest.json";
+function escapeXml(value) {
+	return value.replace(/[&<>"']/g, (character) => {
+		return {
+			"&": "&amp;",
+			"<": "&lt;",
+			">": "&gt;",
+			"\"": "&quot;",
+			"'": "&apos;"
+		}[character];
+	});
+}
+function resolveSiteUrl(siteUrl) {
+	let parsed;
+	try {
+		parsed = new URL(siteUrl);
+	} catch {
+		throw new Error(`SSG siteUrl must be an absolute HTTP(S) URL: ${siteUrl}`);
+	}
+	if (parsed.protocol !== "http:" && parsed.protocol !== "https:") throw new Error(`SSG siteUrl must use HTTP or HTTPS: ${siteUrl}`);
+	if (parsed.search || parsed.hash) throw new Error("SSG siteUrl must not contain a query string or fragment");
+	if (parsed.username || parsed.password) throw new Error("SSG siteUrl must not contain credentials");
+	if (!parsed.pathname.endsWith("/")) parsed.pathname += "/";
+	return parsed;
+}
+function resolveLocation(value, siteUrl) {
+	let resolved;
+	try {
+		resolved = new URL(value.replace(/^\//, ""), siteUrl);
+	} catch {
+		throw new Error(`Invalid sitemap URL: ${value}`);
+	}
+	if (resolved.protocol !== "http:" && resolved.protocol !== "https:") throw new Error(`Sitemap URLs must use HTTP or HTTPS: ${value}`);
+	if (resolved.hash) throw new Error(`Sitemap URLs must not contain fragments: ${value}`);
+	return resolved.href;
+}
+function formatLastModified(value) {
+	if (value instanceof Date) {
+		if (Number.isNaN(value.getTime())) throw new Error("Invalid sitemap lastModified Date");
+		return value.toISOString();
+	}
+	const match = datePattern.exec(value);
+	if (!match) throw new Error(`Invalid sitemap lastModified value: ${value}`);
+	const [, yearText, monthText, dayText, hourText, minuteText, secondText, zone, offsetHour, offsetMinute] = match;
+	const year = Number(yearText);
+	const month = Number(monthText);
+	const day = Number(dayText);
+	const daysInMonth = new Date(Date.UTC(year, month, 0)).getUTCDate();
+	const invalidTime = hourText !== void 0 && (Number(hourText) > 23 || Number(minuteText) > 59 || Number(secondText) > 59 || zone !== "Z" && (Number(offsetHour) > 14 || Number(offsetMinute) > 59 || Number(offsetHour) === 14 && Number(offsetMinute) !== 0));
+	if (month < 1 || month > 12 || day < 1 || day > daysInMonth || invalidTime || Number.isNaN(Date.parse(value))) throw new Error(`Invalid sitemap lastModified value: ${value}`);
+	return value;
+}
+function validateChangeFrequency(value) {
+	if (!changeFrequencies.has(value)) throw new Error(`Invalid sitemap changeFrequency value: ${value}`);
+	return value;
+}
+function validatePriority(value) {
+	if (!Number.isFinite(value) || value < 0 || value > 1) throw new Error(`Sitemap priority must be between 0 and 1: ${value}`);
+	return value;
+}
+function outputPath(outputDir, configuredPath) {
+	const relativePath = configuredPath ?? "sitemap.xml";
+	if (path.isAbsolute(relativePath)) throw new Error(`Sitemap output must be relative to the SSG output directory: ${relativePath}`);
+	const resolved = path.resolve(outputDir, relativePath);
+	const relative = path.relative(path.resolve(outputDir), resolved);
+	if (relative === "" || relative.startsWith("..") || path.isAbsolute(relative)) throw new Error(`Sitemap output must stay inside the SSG output directory: ${relativePath}`);
+	return resolved;
+}
+function relativeOutputPath(outputDir, absolutePath) {
+	return path.relative(path.resolve(outputDir), absolutePath).replace(/\\/g, "/");
+}
+function validateLimit(value, maximum, label) {
+	const resolved = value ?? maximum;
+	if (!Number.isSafeInteger(resolved) || resolved < 1 || resolved > maximum) throw new Error(`${label} must be an integer from 1 through ${maximum}`);
+	return resolved;
+}
+async function atomicWrite(destination, contents) {
+	await mkdir(path.dirname(destination), { recursive: true });
+	const temporary = `${destination}.tmp-${process.pid}-${Date.now()}-${Math.random().toString(16).slice(2)}`;
+	try {
+		await writeFile(temporary, contents, "utf8");
+		await rename(temporary, destination);
+	} catch (error) {
+		await rm(temporary, { force: true });
+		throw error;
+	}
+}
+function renderUrlSet(routes) {
+	return `<?xml version="1.0" encoding="UTF-8"?>\n<urlset${routes.some((route) => route.alternates.length > 0) ? " xmlns=\"http://www.sitemaps.org/schemas/sitemap/0.9\" xmlns:xhtml=\"http://www.w3.org/1999/xhtml\"" : " xmlns=\"http://www.sitemaps.org/schemas/sitemap/0.9\""}>\n${routes.map(renderRoute).join("\n")}\n</urlset>\n`;
+}
+function partitionRoutes(routes, urlsPerFile, bytesPerFile) {
+	if (routes.length === 0) return [[]];
+	const chunks = [];
+	let current = [];
+	let currentEntryBytes = 0;
+	let currentHasAlternates = false;
+	const envelopeBytes = {
+		plain: Buffer.byteLength(renderUrlSet([])),
+		alternates: Buffer.byteLength("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<urlset xmlns=\"http://www.sitemaps.org/schemas/sitemap/0.9\" xmlns:xhtml=\"http://www.w3.org/1999/xhtml\">\n\n</urlset>\n")
+	};
+	const envelope = (hasAlternates) => hasAlternates ? envelopeBytes.alternates : envelopeBytes.plain;
+	for (const route of routes) {
+		const routeBytes = Buffer.byteLength(renderRoute(route));
+		const nextHasAlternates = currentHasAlternates || route.alternates.length > 0;
+		const separatorBytes = current.length > 0 ? 1 : 0;
+		const nextBytes = envelope(nextHasAlternates) + currentEntryBytes + separatorBytes + routeBytes;
+		if (current.length > 0 && (current.length + 1 > urlsPerFile || nextBytes > bytesPerFile)) {
+			chunks.push(current);
+			current = [route];
+			currentEntryBytes = routeBytes;
+			currentHasAlternates = route.alternates.length > 0;
+		} else {
+			current.push(route);
+			currentEntryBytes += separatorBytes + routeBytes;
+			currentHasAlternates = nextHasAlternates;
+		}
+		if (envelope(currentHasAlternates) + currentEntryBytes > bytesPerFile) throw new Error(`A sitemap URL entry exceeds the configured ${bytesPerFile}-byte limit`);
+	}
+	chunks.push(current);
+	return chunks;
+}
+function sitemapIndex(locations) {
+	return `<?xml version="1.0" encoding="UTF-8"?>\n<sitemapindex xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">\n${locations.map((location) => `  <sitemap>\n    <loc>${escapeXml(location)}</loc>\n  </sitemap>`).join("\n")}\n</sitemapindex>\n`;
+}
+async function mapConcurrent(values, concurrency, mapper) {
+	const results = Array.from({ length: values.length });
+	let cursor = 0;
+	const workers = Array.from({ length: Math.min(concurrency, values.length) }, async () => {
+		while (cursor < values.length) {
+			const index = cursor;
+			cursor += 1;
+			results[index] = await mapper(values[index], index);
+		}
+	});
+	await Promise.all(workers);
+	return results;
+}
+async function readManifest(outputDir) {
+	try {
+		const parsed = JSON.parse(await readFile(outputPath(outputDir, MANIFEST_PATH), "utf8"));
+		return {
+			files: Array.isArray(parsed.files) ? parsed.files.filter((value) => typeof value === "string") : [],
+			...typeof parsed.robots === "string" ? { robots: parsed.robots } : {}
+		};
+	} catch {
+		return { files: [] };
+	}
+}
+function withoutSitemapDirective(contents) {
+	return contents.split(/\r?\n/).filter((line) => !/^\s*Sitemap\s*:/i.test(line)).join("\n").replace(/\n+$/, "");
+}
+async function updateRobots(outputDir, previousPath, configured, sitemapUrl) {
+	const nextPath = configured === false ? void 0 : configured && typeof configured === "object" ? configured.output ?? "robots.txt" : "robots.txt";
+	const paths = new Set([previousPath, nextPath].filter((value) => Boolean(value)));
+	for (const relativePath of paths) {
+		const destination = outputPath(outputDir, relativePath);
+		let contents = withoutSitemapDirective(await readFile(destination, "utf8").catch(() => ""));
+		if (relativePath === nextPath) {
+			if (!contents) contents = "User-agent: *\nAllow: /";
+			contents = `${contents}\nSitemap: ${sitemapUrl}`;
+		}
+		if (contents) await atomicWrite(destination, `${contents}\n`);
+		else await rm(destination, { force: true });
+	}
+	return nextPath;
+}
+async function removeGeneratedSitemap(outputDir) {
+	const previous = await readManifest(outputDir);
+	await mapConcurrent(previous.files, 32, async (file) => rm(outputPath(outputDir, file), { force: true }));
+	await updateRobots(outputDir, previous.robots, false, "");
+	await rm(outputPath(outputDir, MANIFEST_PATH), { force: true });
+}
+function renderRoute(route) {
+	const lines = ["  <url>", `    <loc>${escapeXml(route.location)}</loc>`];
+	if (route.lastModified) lines.push(`    <lastmod>${escapeXml(route.lastModified)}</lastmod>`);
+	if (route.changeFrequency) lines.push(`    <changefreq>${route.changeFrequency}</changefreq>`);
+	if (route.priority !== void 0) lines.push(`    <priority>${route.priority}</priority>`);
+	for (const alternate of route.alternates) lines.push(`    <xhtml:link rel="alternate" hreflang="${escapeXml(alternate.language)}" href="${escapeXml(alternate.location)}" />`);
+	lines.push("  </url>");
+	return lines.join("\n");
+}
+async function generateSitemap(outputDir, siteUrl, routes, config = {}) {
+	const baseUrl = resolveSiteUrl(siteUrl);
+	const resolverConcurrency = validateLimit(config.resolverConcurrency ?? 16, 128, "Sitemap resolver concurrency");
+	const generated = (await mapConcurrent(routes.filter((route) => (route.status === "success" || route.status === "skipped") && !route.path.includes("*")), resolverConcurrency, async (route) => {
+		const exact = config.routes?.[route.path];
+		if (exact === false) return void 0;
+		const resolved = await config.resolve?.(route);
+		if (resolved === false) return void 0;
+		const merged = {
+			...config.defaults,
+			...exact,
+			...resolved
+		};
+		const alternates = [];
+		for (const [language, location] of Object.entries(merged.alternates ?? {}).sort(([a], [b]) => a.localeCompare(b))) {
+			if (!languagePattern.test(language)) throw new Error(`Invalid sitemap hreflang value: ${language}`);
+			alternates.push({
+				language,
+				location: resolveLocation(location, baseUrl)
+			});
+		}
+		return {
+			location: resolveLocation(merged.url ?? route.path, baseUrl),
+			...merged.lastModified !== void 0 ? { lastModified: formatLastModified(merged.lastModified) } : {},
+			...merged.changeFrequency ? { changeFrequency: validateChangeFrequency(merged.changeFrequency) } : {},
+			...merged.priority !== void 0 ? { priority: validatePriority(merged.priority) } : {},
+			alternates
+		};
+	})).filter((route) => Boolean(route));
+	generated.sort((a, b) => a.location.localeCompare(b.location));
+	const locations = /* @__PURE__ */ new Set();
+	for (const route of generated) {
+		if (locations.has(route.location)) throw new Error(`Sitemap contains a duplicate canonical URL: ${route.location}`);
+		locations.add(route.location);
+	}
+	const destination = outputPath(outputDir, config.output);
+	const chunks = partitionRoutes(generated, validateLimit(config.limits?.urlsPerFile, MAX_URLS_PER_SITEMAP, "Sitemap URL limit"), validateLimit(config.limits?.bytesPerFile, MAX_SITEMAP_BYTES, "Sitemap byte limit"));
+	if (chunks.length > MAX_URLS_PER_SITEMAP) throw new Error(`Sitemap index exceeds ${MAX_URLS_PER_SITEMAP} sitemap entries`);
+	const generatedFiles = [];
+	if (chunks.length === 1) {
+		await atomicWrite(destination, renderUrlSet(chunks[0]));
+		generatedFiles.push(relativeOutputPath(outputDir, destination));
+	} else {
+		const extension = path.extname(destination);
+		const base = destination.slice(0, extension ? -extension.length : void 0);
+		const chunkDestinations = chunks.map((_, index) => `${base}-${index + 1}.xml`);
+		await mapConcurrent(chunks, 16, async (chunk, index) => atomicWrite(chunkDestinations[index], renderUrlSet(chunk)));
+		const indexXml = sitemapIndex(chunkDestinations.map((chunkPath) => resolveLocation(relativeOutputPath(outputDir, chunkPath), baseUrl)));
+		if (Buffer.byteLength(indexXml) > MAX_SITEMAP_BYTES) throw new Error(`Sitemap index exceeds ${MAX_SITEMAP_BYTES} bytes`);
+		await atomicWrite(destination, indexXml);
+		generatedFiles.push(relativeOutputPath(outputDir, destination), ...chunkDestinations.map((chunkPath) => relativeOutputPath(outputDir, chunkPath)));
+	}
+	const previous = await readManifest(outputDir);
+	const current = new Set(generatedFiles);
+	await mapConcurrent(previous.files.filter((file) => !current.has(file)), 32, async (file) => rm(outputPath(outputDir, file), { force: true }));
+	const sitemapUrl = resolveLocation(relativeOutputPath(outputDir, destination), baseUrl);
+	const robots = await updateRobots(outputDir, previous.robots, config.robots, sitemapUrl);
+	await atomicWrite(outputPath(outputDir, MANIFEST_PATH), `${JSON.stringify({
+		files: generatedFiles,
+		...robots ? { robots } : {}
+	}, null, 2)}\n`);
+	return destination;
+}
+//#endregion
 //#region src/bin/ssg.ts
 const helpText = `
 askr ssg - Static Site Generation for Askr
@@ -30,6 +293,14 @@ const defaultDeps = {
 	now: () => Date.now(),
 	existsSync
 };
+async function pathExists(filePath) {
+	try {
+		await fs$1.access(filePath);
+		return true;
+	} catch {
+		return false;
+	}
+}
 async function importProjectConfig(filePath) {
 	const tsconfig = resolve(dirname(filePath), "tsconfig.json");
 	const unregister = register(existsSync(tsconfig) ? { tsconfig } : void 0);
@@ -57,26 +328,56 @@ function parseCliArgs(args) {
 		changedKeys: [],
 		changedRoutes: [],
 		forceFull: false,
-		help: false
+		help: false,
+		errors: []
+	};
+	const valueFor = (index, option) => {
+		const value = args[index + 1];
+		if (!value || value.startsWith("-")) {
+			parsed.errors.push(`Missing value for ${option}`);
+			return;
+		}
+		return value;
 	};
-	for (let i = 0; i < args.length; i += 1) if (args[i] === "--config" && i + 1 < args.length) {
-		parsed.configPath = args[i + 1];
-		i += 1;
-	} else if (args[i] === "--output" && i + 1 < args.length) {
-		parsed.outputDir = args[i + 1];
-		i += 1;
-	} else if (args[i] === "--workers" && i + 1 < args.length) {
-		parsed.workers = args[i + 1] === "auto" ? "auto" : Number(args[i + 1]);
-		i += 1;
-	} else if (args[i] === "--changed-key" && i + 1 < args.length) {
-		parsed.changedKeys.push(args[i + 1]);
-		i += 1;
-	} else if (args[i] === "--changed-route" && i + 1 < args.length) {
-		parsed.changedRoutes.push(args[i + 1]);
-		i += 1;
+	for (let i = 0; i < args.length; i += 1) if (args[i] === "--config") {
+		const value = valueFor(i, "--config");
+		if (value) {
+			parsed.configPath = value;
+			i += 1;
+		}
+	} else if (args[i] === "--output") {
+		const value = valueFor(i, "--output");
+		if (value) {
+			parsed.outputDir = value;
+			i += 1;
+		}
+	} else if (args[i] === "--workers") {
+		const value = valueFor(i, "--workers");
+		if (value) {
+			if (value === "auto") parsed.workers = "auto";
+			else {
+				const workers = Number(value);
+				if (!Number.isSafeInteger(workers) || workers < 1) parsed.errors.push("--workers must be 'auto' or a positive integer");
+				else parsed.workers = workers;
+			}
+			i += 1;
+		}
+	} else if (args[i] === "--changed-key") {
+		const value = valueFor(i, "--changed-key");
+		if (value) {
+			parsed.changedKeys.push(value);
+			i += 1;
+		}
+	} else if (args[i] === "--changed-route") {
+		const value = valueFor(i, "--changed-route");
+		if (value) {
+			parsed.changedRoutes.push(value);
+			i += 1;
+		}
 	} else if (args[i] === "--incremental") parsed.incremental = true;
 	else if (args[i] === "--force-full") parsed.forceFull = true;
 	else if (args[i] === "--help" || args[i] === "-h") parsed.help = true;
+	else parsed.errors.push(`Unknown option: ${args[i]}`);
 	return parsed;
 }
 function toGenerateOptions(args) {
@@ -87,7 +388,7 @@ function toGenerateOptions(args) {
 		forceFull: args.forceFull
 	};
 }
-function printSummary(io, outputDir, durationSeconds, result) {
+function printSummary(io, outputDir, durationSeconds, result, sitemapPath) {
 	io.log("");
 	io.log(`Generation complete in ${durationSeconds}s`);
 	io.log(`   Mode:      ${result.mode}`);
@@ -99,6 +400,7 @@ function printSummary(io, outputDir, durationSeconds, result) {
 	io.log(`   CacheHit:  ${result.cacheHits} routes`);
 	io.log(`   Output:    ${outputDir}`);
 	io.log(`   Metadata:  ${outputDir}/metadata.json`);
+	if (sitemapPath) io.log(`   Sitemap:   ${sitemapPath}`);
 	io.log("");
 }
 async function runSsgCli(args = process.argv.slice(2), deps = {}, io = console) {
@@ -107,6 +409,10 @@ async function runSsgCli(args = process.argv.slice(2), deps = {}, io = console)
 		io.log(helpText);
 		return 0;
 	}
+	if (parsed.errors.length > 0) {
+		for (const error of parsed.errors) io.error(`Error: ${error}`);
+		return 1;
+	}
 	if (!parsed.configPath) {
 		io.error("Error: --config argument is required");
 		return 1;
@@ -125,11 +431,22 @@ async function runSsgCli(args = process.argv.slice(2), deps = {}, io = console)
 	};
 	const resolvedConfigPath = resolve(resolvedDeps.cwd(), parsed.configPath);
 	const resolvedOutputDir = resolve(resolvedDeps.cwd(), parsed.outputDir);
+	const outputStat = await fs$1.stat(resolvedOutputDir).catch(() => null);
+	if (outputStat && !outputStat.isDirectory()) {
+		io.error(`Error: SSG output exists and is not a directory: ${resolvedOutputDir}`);
+		return 1;
+	}
+	const configWithinOutput = path$1.relative(resolvedOutputDir, resolvedConfigPath);
+	if (resolvedOutputDir === path$1.resolve(resolvedDeps.cwd()) || !configWithinOutput.startsWith("..") && !path$1.isAbsolute(configWithinOutput)) {
+		io.error("Error: --output must not contain the project or SSG config file");
+		return 1;
+	}
 	if (!resolvedDeps.existsSync(resolvedConfigPath)) {
 		io.error(`Error: Config file not found: ${resolvedConfigPath}`);
 		return 1;
 	}
 	let unregisterProjectLoader;
+	let cliStagingDir;
 	try {
 		io.log(`Loading config: ${resolvedConfigPath}`);
 		let imported;
@@ -147,10 +464,21 @@ async function runSsgCli(args = process.argv.slice(2), deps = {}, io = console)
 			return 1;
 		}
 		const config = candidate;
+		if (config.sitemap !== false && !config.siteUrl) {
+			io.error("Error: Config must provide siteUrl to generate sitemap.xml, or set sitemap: false");
+			return 1;
+		}
 		io.log(hasRoutes ? `Generating ${config.routes?.length ?? 0} routes...` : "Generating registered routes...");
-		const ssg = (typeof resolvedDeps.createStaticGen === "function" ? resolvedDeps.createStaticGen : await loadCreateStaticGen())({
+		const createStaticGen = typeof resolvedDeps.createStaticGen === "function" ? resolvedDeps.createStaticGen : await loadCreateStaticGen();
+		cliStagingDir = await createSiblingStage(resolvedOutputDir, "askr-ssg");
+		if (parsed.incremental && !parsed.forceFull && await pathExists(resolvedOutputDir)) await fs$1.cp(resolvedOutputDir, cliStagingDir, {
+			recursive: true,
+			mode: constants.COPYFILE_FICLONE
+		});
+		const generationOutputDir = cliStagingDir;
+		const ssg = createStaticGen({
 			...hasRoutes ? { routes: config.routes } : { registry: config.registry },
-			outputDir: resolvedOutputDir,
+			outputDir: generationOutputDir,
 			seed: config.seed,
 			dataOverrides: config.dataOverrides,
 			concurrency: config.concurrency,
@@ -160,7 +488,13 @@ async function runSsgCli(args = process.argv.slice(2), deps = {}, io = console)
 		});
 		const startTime = resolvedDeps.now();
 		const result = await ssg.generate(toGenerateOptions(parsed));
-		printSummary(io, resolvedOutputDir, ((resolvedDeps.now() - startTime) / 1e3).toFixed(2), result);
+		const sitemapPath = result.failed === 0 && config.sitemap !== false && config.siteUrl ? await generateSitemap(generationOutputDir, config.siteUrl, result.routes, config.sitemap) : void 0;
+		if (result.failed === 0 && config.sitemap === false) await removeGeneratedSitemap(generationOutputDir);
+		if (result.failed === 0 && cliStagingDir) {
+			await publishStagedDirectory(cliStagingDir, resolvedOutputDir);
+			cliStagingDir = void 0;
+		}
+		printSummary(io, resolvedOutputDir, ((resolvedDeps.now() - startTime) / 1e3).toFixed(2), result, sitemapPath ? path$1.join(resolvedOutputDir, path$1.relative(generationOutputDir, sitemapPath)) : void 0);
 		if (result.failed > 0) {
 			io.log("Errors encountered:");
 			for (const route of result.routes) if (route.status === "error") io.log(`   ${route.path}: ${route.error}`);
@@ -174,6 +508,10 @@ async function runSsgCli(args = process.argv.slice(2), deps = {}, io = console)
 		if (error instanceof Error && error.stack) io.error(error.stack);
 		return 1;
 	} finally {
+		if (cliStagingDir) await fs$1.rm(cliStagingDir, {
+			recursive: true,
+			force: true
+		});
 		await unregisterProjectLoader?.();
 	}
 }
@@ -184,5 +522,3 @@ async function main() {
 if (isDirectExecution(import.meta.url)) main();
 //#endregion
 export { parseCliArgs, runSsgCli };
-
-//# sourceMappingURL=ssg.js.map

package/dist/templates/full-stack/package.json

@@ -27,7 +27,7 @@
   },
   "devDependencies": {
     "@askrjs/vite": ">=0.0.6 <0.1.0",
-    "@types/node": "^26.0.0",
+    "@types/node": "^20.19.0",
     "jsdom": "^29.1.1",
     "typescript": "^6.0.3",
     "vite-plus": "^0.2.4",

package/dist/templates/full-stack/src/server/action-registry.ts

@@ -1,7 +1,6 @@
 import { handleAction } from "@askrjs/server/askr";
 import { createMessageAction } from "../actions/create-message";
 import { createMessage } from "./actions/create-message";
-import type { AppDependencies } from "./dependencies";
 
 export function createActionHandlers() {
   return [handleAction(createMessageAction, createMessage)] as const;

package/dist/templates/full-stack/tsconfig.json

@@ -9,7 +9,7 @@
     "noEmit": true,
     "jsx": "preserve",
     "jsxImportSource": "@askrjs/askr",
-    "types": ["vite/client", "node"]
+    "types": ["vite/client", "node", "@askrjs/themes"]
   },
   "include": ["src", "tests", "server.ts", "vite.config.ts"]
 }

package/dist/templates/spa/package.json

@@ -7,7 +7,7 @@
     "dev": "vp dev",
     "build": "vp build",
     "preview": "vp preview",
-    "test": "vp test run",
+    "test": "vp test run -c ./vitest.config.ts",
     "typecheck": "tsc --noEmit",
     "lint": "vp lint .",
     "lint:fix": "npm run lint -- --fix",
@@ -17,14 +17,13 @@
   "dependencies": {
     "@askrjs/askr": ">=0.0.53 <0.1.0",
     "@askrjs/charts": ">=0.1.0 <0.2.0",
-    "@askrjs/logos": ">=0.0.3 <0.1.0",
     "@askrjs/lucide": ">=0.0.3 <0.1.0",
     "@askrjs/themes": ">=0.0.12 <0.1.0",
     "@askrjs/ui": ">=0.0.13 <0.1.0"
   },
   "devDependencies": {
     "@askrjs/vite": ">=0.0.6 <0.1.0",
-    "@types/node": "^26.0.0",
+    "@types/node": "^20.19.0",
     "jsdom": "^29.1.1",
     "typescript": "^6.0.3",
     "vite-plus": "^0.2.4"

package/dist/templates/spa/src/pages/app/_routes.tsx

@@ -2,8 +2,10 @@ import { route } from '@askrjs/askr/router';
 import AgentRunsPage from './agent-runs';
 import AdminHomePage from './admin-home';
 import SettingsPage from './settings';
+// askr:imports
 
 export function registerAppRoutes(): void {
+  // askr:routes
   route('/app', AdminHomePage);
   route('/app/agents', AgentRunsPage);
   route('/app/settings', SettingsPage);

package/dist/templates/spa/src/pages/public/_routes.tsx

@@ -1,6 +1,8 @@
 import { route } from '@askrjs/askr/router';
 import HomePage from './home';
+// askr:imports
 
 export function registerPublicRoutes(): void {
+  // askr:routes
   route('/', HomePage);
 }

package/dist/templates/spa/tsconfig.json

@@ -13,7 +13,8 @@
     "isolatedModules": true,
     "noEmit": true,
     "jsx": "preserve",
-    "jsxImportSource": "@askrjs/askr"
+    "jsxImportSource": "@askrjs/askr",
+    "types": ["@askrjs/themes"]
   },
   "include": ["src", "tests"],
   "references": [{ "path": "./tsconfig.node.json" }]

package/dist/templates/spa/vitest.config.ts

@@ -3,10 +3,6 @@ import { askr } from '@askrjs/vite';
 
 export default defineConfig({
   plugins: [askr()],
-  esbuild: {
-    jsx: 'automatic',
-    jsxImportSource: '@askrjs/askr',
-  },
   test: {
     environment: 'jsdom',
     globals: true,

package/dist/templates/ssg/README.md

@@ -34,6 +34,6 @@ npm run typecheck  # Type check
 
 ## Static generation
 
-Run `npm run build` to compile browser assets and pre-render every route into `dist/`. The `askr ssg` command owns both full and incremental generation, and publishes routes, metadata, the incremental manifest, and browser assets together.
+Run `npm run build` to compile browser assets and pre-render every route into `dist/`. The `askr ssg` command owns both full and incremental generation, and publishes routes, metadata, the incremental manifest, browser assets, `sitemap.xml`, and the managed `robots.txt` sitemap directive together.
 
 `ssg.config.ts` passes the same immutable route registry used in dev mode, so the shell and leaf pages stay in sync.

package/dist/templates/ssg/package.json

@@ -24,7 +24,7 @@
   "devDependencies": {
     "@askrjs/cli": ">=0.0.2 <0.1.0",
     "@askrjs/vite": ">=0.0.6 <0.1.0",
-    "@types/node": "^26.0.0",
+    "@types/node": "^20.19.0",
     "jsdom": "^29.1.1",
     "typescript": "^6.0.3",
     "vite-plus": "^0.2.4"

package/dist/templates/ssg/ssg.config.ts

@@ -4,6 +4,7 @@ import type { DocumentRenderArgs } from '@askrjs/askr/ssg';
 import { pageRegistry } from './src/routes';
 
 export const outputDir = './dist';
+export const siteUrl = 'https://example.com';
 
 let clientTemplate: string | undefined;
 
@@ -24,6 +25,12 @@ function renderDocument({ appHtml }: DocumentRenderArgs) {
 export const staticConfig = {
   registry: pageRegistry,
   outputDir,
+  siteUrl,
+  sitemap: {
+    routes: {
+      '/preview': false,
+    },
+  },
   document: renderDocument,
   assets: [
     {