@askrjs/cli 0.0.2 → 0.0.4

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/AGENTS.md

@@ -9,4 +9,3 @@ This project is the progressive full-stack stage of an Askr application.
 - Keep `index.html` as the only document source. Preserve exactly one `<!--askr-head-->` and one `<!--askr-app-->` marker.
 - Use native forms first; enhanced submission must preserve the same validation and authorization behavior.
 - Never log cookies, authorization values, tokens, form fields, request bodies, or personal data.
-

package/dist/templates/full-stack/README.md

@@ -15,4 +15,3 @@ npm run preview
 Use `askr add action <name> --route <path>` to generate a browser-safe descriptor, server handler, composition-root registration, route authorization, and focused test.
 
 `index.html` owns the static document. `@askrjs/vite/server` injects only Askr-owned head nodes and composes the streamed app response at `<!--askr-app-->`.
-

package/dist/templates/full-stack/index.html

@@ -11,4 +11,3 @@
     <script type="module" src="/src/main.tsx"></script>
   </body>
 </html>
-

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

@@ -14,8 +14,8 @@
     "check": "npm run lint && npm run typecheck && npm test && npm run build"
   },
   "dependencies": {
-    "@askrjs/auth": ">=0.0.1 <0.1.0",
     "@askrjs/askr": ">=0.0.53 <0.1.0",
+    "@askrjs/auth": ">=0.0.1 <0.1.0",
     "@askrjs/i18n": ">=0.0.1 <0.1.0",
     "@askrjs/node": ">=0.0.1 <0.1.0",
     "@askrjs/otel": ">=0.0.1 <0.1.0",
@@ -27,11 +27,13 @@
   },
   "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",
     "vitest": "^4.1.10"
   },
-  "engines": { "node": "^20.19.0 || >=22.12.0" }
+  "engines": {
+    "node": "^20.19.0 || >=22.12.0"
+  }
 }

package/dist/templates/full-stack/server.ts

@@ -1,13 +1,9 @@
-import { listen } from '@askrjs/node';
-import app from 'virtual:askr-server';
+import { serve } from "@askrjs/node";
+import app from "virtual:askr-server";
 
 const port = Number(process.env.PORT ?? 3000);
-const server = await listen(app, {
-  host: process.env.HOST ?? '127.0.0.1',
+await serve(app, {
+  host: process.env.HOST ?? "127.0.0.1",
   port,
+  assets: { root: new URL("./dist", import.meta.url).pathname },
 });
-
-const shutdown = () => server.close();
-process.once('SIGINT', shutdown);
-process.once('SIGTERM', shutdown);
-

package/dist/templates/full-stack/src/action-authorizations.ts

@@ -1,5 +1,5 @@
-import type { ActionDescriptor } from '@askrjs/askr/actions';
-import { createMessageAction } from './actions/create-message';
+import type { ActionDescriptor } from "@askrjs/askr/actions";
+import { createMessageAction } from "./actions/create-message";
 
 const actionsByRoute: Readonly<Record<string, readonly ActionDescriptor[]>> = Object.freeze({
   "/": [createMessageAction],

package/dist/templates/full-stack/src/actions/create-message.ts

@@ -1,10 +1,10 @@
-import { defineAction } from '@askrjs/askr/actions';
-import { MessageInput } from '../schemas';
+import { defineAction } from "@askrjs/askr/actions";
+import { MessageInput } from "../schemas";
 
-export const createMessageActionRoute = '/';
+export const createMessageActionRoute = "/";
 
 export const createMessageAction = defineAction({
-  id: 'create-message',
+  id: "create-message",
   input: MessageInput,
-  invalidates: ['messages'],
+  invalidates: ["messages"],
 });

package/dist/templates/full-stack/src/i18n.ts

@@ -1,8 +1,8 @@
-import { createI18n } from '@askrjs/i18n';
+import { createI18n } from "@askrjs/i18n";
 
-export const messages = createI18n('en', {
+export const messages = createI18n("en", {
   en: {
-    title: () => '{{appName}}',
-    intro: () => 'A progressive full-stack Askr application.',
+    title: () => "{{appName}}",
+    intro: () => "A progressive full-stack Askr application.",
   },
 });

package/dist/templates/full-stack/src/main.tsx

@@ -1,12 +1,11 @@
-import { createSPA, hydrateSPA } from '@askrjs/askr/boot';
-import { pageRegistry } from './routes';
+import { createSPA, hydrateSPA } from "@askrjs/askr/boot";
+import { pageRegistry } from "./routes";
 
-const root = document.getElementById('app');
-if (!root) throw new Error('Missing #app root element.');
+const root = document.getElementById("app");
+if (!root) throw new Error("Missing #app root element.");
 
 if (root.hasChildNodes()) {
   await hydrateSPA({ root, registry: pageRegistry });
 } else {
   await createSPA({ root, registry: pageRegistry });
 }
-

package/dist/templates/full-stack/src/pages/home.tsx

@@ -1,12 +1,12 @@
-import { ActionForm } from '@askrjs/askr/actions';
-import { createMessageAction } from '../actions/create-message';
-import { messages } from '../i18n';
+import { ActionForm } from "@askrjs/askr/actions";
+import { createMessageAction } from "../actions/create-message";
+import { messages } from "../i18n";
 
 export function HomePage() {
   return (
     <main>
-      <h1>{messages.text('title')}</h1>
-      <p>{messages.text('intro')}</p>
+      <h1>{messages.text("title")}</h1>
+      <p>{messages.text("intro")}</p>
       <form method="post" action="/api/session">
         <button type="submit">Start demo session</button>
       </form>

package/dist/templates/full-stack/src/pages/layout.tsx

@@ -1,7 +1,15 @@
-import { Link } from '@askrjs/askr/router';
-import { Block, Container, Header, Navbar, NavBrand, NavGroup, NavLink } from '@askrjs/themes/components';
-import { ThemeScope, ThemeToggle } from '@askrjs/themes/theme';
-import { messages } from '../i18n';
+import { Link } from "@askrjs/askr/router";
+import {
+  Block,
+  Container,
+  Header,
+  Navbar,
+  NavBrand,
+  NavGroup,
+  NavLink,
+} from "@askrjs/themes/components";
+import { ThemeScope, ThemeToggle } from "@askrjs/themes/theme";
+import { messages } from "../i18n";
 
 function ScopedLayout({ children }: { children?: unknown }) {
   return (
@@ -10,7 +18,9 @@ function ScopedLayout({ children }: { children?: unknown }) {
         <Header sticky>
           <Container paddingY="sm">
             <Navbar aria-label="Primary navigation" width="full">
-              <NavBrand><Link href="/">{messages.text('title')}</Link></NavBrand>
+              <NavBrand>
+                <Link href="/">{messages.text("title")}</Link>
+              </NavBrand>
               <NavGroup align="end">
                 <NavLink href="/">Home</NavLink>
                 <ThemeToggle aria-label="Toggle theme" />

package/dist/templates/full-stack/src/pages/not-found.tsx

@@ -1,4 +1,7 @@
 export function NotFoundPage() {
-  return <main><h1>Not found</h1></main>;
+  return (
+    <main>
+      <h1>Not found</h1>
+    </main>
+  );
 }
-