@askrjs/cli 0.0.16 → 0.0.18

package/dist/{runner-CEt07ieG.js → runner-DzWc9R4G.js}

@@ -1,6 +1,6 @@
 import { t as inspectBundledSkills } from "./skills-CSGdAZHN.js";
 import { discoverWorkspaceProject } from "./discovery-DUDrZCIC.js";
-import { analysisHasBlockingFindings, runAnalysis } from "./runner-42nqhW9u.js";
+import { analysisHasBlockingFindings, runAnalysis } from "./runner-CYvonJ0C.js";
 import fs from "node:fs/promises";
 import path from "node:path";
 import { spawn } from "node:child_process";

package/dist/ssg-config.d.ts

@@ -15,6 +15,8 @@ interface SitemapRouteContext {
   path: string;
   filePath: string;
   status: string;
+  /** Resolved rendered canonical URL, when the document declares one. */
+  canonical?: string;
 }
 interface SitemapConfig {
   /** Site-wide values inherited by included routes. */
@@ -38,4 +40,69 @@ interface SitemapConfig {
   resolverConcurrency?: number;
 }
 //#endregion
-export type { SitemapChangeFrequency, SitemapConfig, SitemapRouteConfig, SitemapRouteContext };
+//#region src/ssg/output-report.d.ts
+interface SsgByteBudget {
+  raw?: number;
+  gzip?: number;
+}
+interface SsgOutputBudgets {
+  /** Default raw/gzip HTML limits for every route. */
+  routes?: SsgByteBudget;
+  /** Exact route overrides merged with defaults; false exempts a route. */
+  routeOverrides?: Readonly<Record<string, SsgByteBudget | false>>;
+  hydration?: {
+    /** Maximum hydration bytes as a 0..1 share of raw HTML. */
+    share?: number;
+    /** Exact share overrides; false exempts a route. */
+    routes?: Readonly<Record<string, number | false>>;
+  };
+  /** Exact emitted asset raw/gzip limits; false exempts an asset. */
+  assets?: Readonly<Record<string, SsgByteBudget | false>>;
+  aggregate?: {
+    javascript?: SsgByteBudget;
+    css?: SsgByteBudget;
+  };
+}
+interface SsgOutputReportConfig {
+  budgets?: SsgOutputBudgets;
+  /** Number of largest pages retained in the summary. Defaults to 20. */
+  largestPages?: number;
+  /** Number of largest assets retained in the summary. Defaults to 20. */
+  largestAssets?: number;
+}
+interface SsgOutputSize {
+  raw: number;
+  gzip: number;
+}
+interface SsgOutputAsset extends SsgOutputSize {
+  path: string;
+  type: "javascript" | "css" | "other";
+}
+interface SsgOutputRoute {
+  route: string;
+  filePath: string;
+  html: SsgOutputSize;
+  hydration: {
+    raw: number;
+    share: number;
+  };
+  initial: {
+    javascript: SsgOutputAsset[];
+    css: SsgOutputAsset[];
+  };
+}
+interface SsgOutputReport {
+  version: 1;
+  routes: SsgOutputRoute[];
+  assets: SsgOutputAsset[];
+  aggregate: {
+    javascript: SsgOutputSize;
+    css: SsgOutputSize;
+  };
+  largest: {
+    pages: SsgOutputRoute[];
+    assets: SsgOutputAsset[];
+  };
+}
+//#endregion
+export type { SitemapChangeFrequency, SitemapConfig, SitemapRouteConfig, SitemapRouteContext, SsgByteBudget, SsgOutputAsset, SsgOutputBudgets, SsgOutputReport, SsgOutputReportConfig, SsgOutputRoute, SsgOutputSize };

package/dist/ssg.js

@@ -2,12 +2,14 @@
 import { t as isDirectExecution } from "./is-direct-execution-Cdlr-ZUl.js";
 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 fs, { 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";
+import { gzipSync } from "node:zlib";
+import { parse } from "parse5";
 //#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})*)$/;
@@ -58,6 +60,17 @@ function resolveLocation(value, siteUrl) {
 	if (resolved.hash) throw new Error(`Sitemap URLs must not contain fragments: ${value}`);
 	return resolved.href;
 }
+function resolveDocumentCanonical(value, siteUrl, label = "rendered canonical") {
+	let resolved;
+	try {
+		resolved = new URL(value, siteUrl);
+	} catch {
+		throw new Error(`Invalid ${label} URL: ${value}`);
+	}
+	if (resolved.protocol !== "http:" && resolved.protocol !== "https:") throw new Error(`${label} URLs must use HTTP or HTTPS: ${value}`);
+	if (resolved.hash) throw new Error(`${label} 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");
@@ -209,13 +222,21 @@ async function generateSitemap(outputDir, siteUrl, routes, config = {}) {
 	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);
+		const canonical = route.canonical ? resolveDocumentCanonical(route.canonical, baseUrl) : void 0;
+		const resolved = await config.resolve?.({
+			...route,
+			...canonical ? { canonical } : {}
+		});
 		if (resolved === false) return void 0;
 		const merged = {
 			...config.defaults,
 			...exact,
 			...resolved
 		};
+		for (const [source, value] of [["sitemap.routes", exact?.url], ["sitemap.resolve", resolved?.url]]) {
+			const explicitUrl = value ? resolveDocumentCanonical(value, baseUrl, `${source} override`) : void 0;
+			if (canonical && explicitUrl && explicitUrl !== canonical) throw new Error(`Sitemap URL mismatch for ${route.path}: rendered canonical ${canonical} disagrees with ${source} URL ${explicitUrl}`);
+		}
 		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}`);
@@ -225,7 +246,7 @@ async function generateSitemap(outputDir, siteUrl, routes, config = {}) {
 			});
 		}
 		return {
-			location: resolveLocation(merged.url ?? route.path, baseUrl),
+			location: canonical ?? 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) } : {},
@@ -267,6 +288,254 @@ async function generateSitemap(outputDir, siteUrl, routes, config = {}) {
 	return destination;
 }
 //#endregion
+//#region src/ssg/documents.ts
+function attribute(element, name) {
+	return element.attrs.find((candidate) => candidate.name.toLowerCase() === name)?.value;
+}
+function relTokens(element) {
+	return new Set((attribute(element, "rel") ?? "").toLowerCase().split(/\s+/).filter(Boolean));
+}
+function textContent(node) {
+	if ("value" in node) return node.value;
+	if (!("childNodes" in node)) return "";
+	return node.childNodes.map(textContent).join("");
+}
+function walk(node, visit) {
+	if ("tagName" in node) visit(node);
+	if ("childNodes" in node) for (const child of node.childNodes) walk(child, visit);
+	if ("content" in node) walk(node.content, visit);
+}
+function inspectHtml(route, html) {
+	const canonicals = [];
+	const javascript = /* @__PURE__ */ new Set();
+	const css = /* @__PURE__ */ new Set();
+	let hydrationBytes = 0;
+	walk(parse(html), (element) => {
+		if (element.tagName === "link") {
+			const rel = relTokens(element);
+			const href = attribute(element, "href");
+			if (rel.has("canonical")) {
+				if (!href?.trim()) throw new Error(`Generated route ${route.path} contains a canonical link without href`);
+				canonicals.push(href.trim());
+			}
+			if (href && rel.has("stylesheet")) css.add(href);
+			if (href && rel.has("modulepreload")) javascript.add(href);
+			if (href && rel.has("preload")) {
+				const as = attribute(element, "as")?.toLowerCase();
+				if (as === "script") javascript.add(href);
+				if (as === "style") css.add(href);
+			}
+		}
+		if (element.tagName === "script") {
+			const src = attribute(element, "src");
+			if (src) javascript.add(src);
+			if (attribute(element, "data-askr-render-data") === "true") hydrationBytes += Buffer.byteLength(textContent(element));
+		}
+	});
+	if (canonicals.length > 1) throw new Error(`Generated route ${route.path} contains multiple canonical links: ${canonicals.join(", ")}`);
+	return {
+		route: route.path,
+		filePath: route.filePath,
+		html: {
+			raw: Buffer.byteLength(html),
+			gzip: gzipSync(html, { level: 9 }).byteLength
+		},
+		...canonicals[0] ? { canonical: canonicals[0] } : {},
+		hydrationBytes,
+		javascript: [...javascript].sort(),
+		css: [...css].sort()
+	};
+}
+function documentPath(outputDir, route) {
+	const root = path.resolve(outputDir);
+	const resolved = path.resolve(root, route.filePath);
+	const relative = path.relative(root, resolved);
+	if (!relative || relative.startsWith("..") || path.isAbsolute(relative)) throw new Error(`Generated route ${route.path} has an invalid output path: ${route.filePath}`);
+	return resolved;
+}
+async function inspectSsgDocuments(outputDir, routes) {
+	const inspections = /* @__PURE__ */ new Map();
+	const included = routes.filter((route) => (route.status === "success" || route.status === "skipped") && !route.path.includes("*")).sort((left, right) => left.path.localeCompare(right.path));
+	for (const route of included) {
+		let html;
+		try {
+			html = await fs.readFile(documentPath(outputDir, route), "utf8");
+		} catch (error) {
+			throw new Error(`Unable to inspect generated document for ${route.path}: ${route.filePath}`, { cause: error });
+		}
+		inspections.set(route.path, inspectHtml(route, html));
+	}
+	return inspections;
+}
+//#endregion
+//#region src/ssg/output-report.ts
+const REPORT_PATH = ".askr/ssg-output.json";
+const INTERNAL_OUTPUTS = /* @__PURE__ */ new Set([
+	"metadata.json",
+	".askr/sitemap-manifest.json",
+	REPORT_PATH
+]);
+function outputType(filePath) {
+	const extension = path.extname(filePath).toLowerCase();
+	if (extension === ".js" || extension === ".mjs" || extension === ".cjs") return "javascript";
+	return extension === ".css" ? "css" : "other";
+}
+function size(value) {
+	const buffer = typeof value === "string" ? Buffer.from(value) : value;
+	return {
+		raw: buffer.byteLength,
+		gzip: gzipSync(buffer, { level: 9 }).byteLength
+	};
+}
+async function emittedFiles(directory, prefix = "") {
+	const entries = await fs.readdir(path.join(directory, prefix), { withFileTypes: true });
+	const files = [];
+	for (const entry of entries.sort((left, right) => left.name.localeCompare(right.name))) {
+		const relative = prefix ? `${prefix}/${entry.name}` : entry.name;
+		if (entry.isDirectory()) files.push(...await emittedFiles(directory, relative));
+		else if (entry.isFile()) files.push(relative);
+	}
+	return files;
+}
+function isReportableAsset(filePath) {
+	return !filePath.toLowerCase().endsWith(".html") && !INTERNAL_OUTPUTS.has(filePath);
+}
+async function removeSsgOutputReport(outputDir) {
+	await fs.rm(path.join(outputDir, REPORT_PATH), { force: true });
+}
+function localReference(reference, documentPath) {
+	let resolved;
+	try {
+		const portableDocumentPath = documentPath.replaceAll("\\", "/");
+		const base = new URL(path.posix.dirname(`/${portableDocumentPath}`) + "/", "https://askr.invalid");
+		resolved = new URL(reference, base);
+	} catch {
+		return;
+	}
+	if (resolved.origin !== "https://askr.invalid") return void 0;
+	try {
+		return decodeURIComponent(resolved.pathname).replace(/^\/+/, "");
+	} catch {
+		return;
+	}
+}
+function positiveCount(value, fallback, label) {
+	const resolved = value ?? fallback;
+	if (!Number.isSafeInteger(resolved) || resolved < 1) throw new Error(`${label} must be a positive integer`);
+	return resolved;
+}
+function validateByteBudget(budget, label) {
+	for (const [measurement, limit] of Object.entries(budget ?? {})) {
+		if (measurement !== "raw" && measurement !== "gzip") throw new Error(`${label}.${measurement} is not supported; use raw or gzip`);
+		if (!Number.isSafeInteger(limit) || Number(limit) < 0) throw new Error(`${label}.${measurement} must be a non-negative integer byte limit`);
+	}
+}
+function validateConfig(config) {
+	const budgets = config.budgets;
+	validateByteBudget(budgets?.routes, "outputReport.budgets.routes");
+	for (const [route, budget] of Object.entries(budgets?.routeOverrides ?? {})) if (budget !== false) validateByteBudget(budget, `route override ${route}`);
+	for (const [asset, budget] of Object.entries(budgets?.assets ?? {})) if (budget !== false) validateByteBudget(budget, `asset budget ${asset}`);
+	validateByteBudget(budgets?.aggregate?.javascript, "aggregate javascript budget");
+	validateByteBudget(budgets?.aggregate?.css, "aggregate css budget");
+	const hydrationShares = [["*", budgets?.hydration?.share], ...Object.entries(budgets?.hydration?.routes ?? {})];
+	for (const [route, share] of hydrationShares) if (share !== void 0 && share !== false && (!Number.isFinite(share) || share < 0 || share > 1)) throw new Error(`hydration share for ${route} must be from 0 through 1`);
+	positiveCount(config.largestPages, 20, "outputReport.largestPages");
+	positiveCount(config.largestAssets, 20, "outputReport.largestAssets");
+}
+function budgetViolations(report, budgets = {}) {
+	const violations = [];
+	const check = (subject, measured, budget, remediation) => {
+		for (const measurement of ["raw", "gzip"]) {
+			const limit = budget?.[measurement];
+			if (limit !== void 0 && measured[measurement] > limit) violations.push(`${subject} ${measurement}: ${measured[measurement]} B > ${limit} B. ${remediation}`);
+		}
+	};
+	for (const route of report.routes) {
+		const override = budgets.routeOverrides?.[route.route];
+		if (override !== false) check(`route ${route.route} HTML`, route.html, {
+			...budgets.routes,
+			...override
+		}, "Reduce rendered markup/data or raise the exact route budget.");
+		const shareOverride = budgets.hydration?.routes?.[route.route];
+		const shareLimit = shareOverride === false ? void 0 : shareOverride ?? budgets.hydration?.share;
+		if (shareLimit !== void 0 && route.hydration.share > shareLimit) violations.push(`route ${route.route} hydration share: ${route.hydration.share} > ${shareLimit}. Use route dehydrate() to omit server-only data or raise the exact route limit.`);
+	}
+	const assets = new Map(report.assets.map((asset) => [asset.path, asset]));
+	for (const [assetPath, budget] of Object.entries(budgets.assets ?? {}).sort(([a], [b]) => a.localeCompare(b))) {
+		if (budget === false) continue;
+		const asset = assets.get(assetPath);
+		if (!asset) continue;
+		check(`asset ${assetPath}`, asset, budget, "Split, compress, or lazy-load the asset, or raise its exact budget.");
+	}
+	check("aggregate JavaScript", report.aggregate.javascript, budgets.aggregate?.javascript, "Code-split initial JavaScript or raise the aggregate budget.");
+	check("aggregate CSS", report.aggregate.css, budgets.aggregate?.css, "Remove or split unused CSS, or raise the aggregate budget.");
+	return violations;
+}
+async function writeSsgOutputReport(outputDir, routes, inspections, config = {}) {
+	validateConfig(config);
+	const assets = [];
+	for (const filePath of (await emittedFiles(outputDir)).filter(isReportableAsset)) {
+		const measured = size(await fs.readFile(path.join(outputDir, filePath)));
+		assets.push({
+			path: filePath,
+			type: outputType(filePath),
+			...measured
+		});
+	}
+	assets.sort((left, right) => left.path.localeCompare(right.path));
+	const assetMap = new Map(assets.map((asset) => [asset.path, asset]));
+	const outputRoutes = [];
+	for (const route of [...routes].sort((left, right) => left.path.localeCompare(right.path))) {
+		const inspection = inspections.get(route.path);
+		if (!inspection) continue;
+		const html = inspection.html;
+		const referenced = (references, type) => references.map((reference) => localReference(reference, inspection.filePath)).filter((reference) => Boolean(reference)).map((reference) => assetMap.get(reference)).filter((asset) => asset?.type === type).sort((left, right) => left.path.localeCompare(right.path));
+		outputRoutes.push({
+			route: route.path,
+			filePath: inspection.filePath,
+			html,
+			hydration: {
+				raw: inspection.hydrationBytes,
+				share: html.raw === 0 ? 0 : Number((inspection.hydrationBytes / html.raw).toFixed(6))
+			},
+			initial: {
+				javascript: referenced(inspection.javascript, "javascript"),
+				css: referenced(inspection.css, "css")
+			}
+		});
+	}
+	const total = (type) => assets.filter((asset) => asset.type === type).reduce((sum, asset) => ({
+		raw: sum.raw + asset.raw,
+		gzip: sum.gzip + asset.gzip
+	}), {
+		raw: 0,
+		gzip: 0
+	});
+	const byLargest = (values, count, name) => [...values].sort((left, right) => right.raw - left.raw || name(left).localeCompare(name(right))).slice(0, count);
+	const report = {
+		version: 1,
+		routes: outputRoutes,
+		assets,
+		aggregate: {
+			javascript: total("javascript"),
+			css: total("css")
+		},
+		largest: {
+			pages: byLargest(outputRoutes.map((route) => ({
+				...route,
+				raw: route.html.raw
+			})), positiveCount(config.largestPages, 20, "outputReport.largestPages"), (route) => route.route).map(({ raw: _raw, ...route }) => route),
+			assets: byLargest(assets, positiveCount(config.largestAssets, 20, "outputReport.largestAssets"), (asset) => asset.path)
+		}
+	};
+	const violations = budgetViolations(report, config.budgets);
+	if (violations.length > 0) throw new Error(`SSG output budgets exceeded:\n${violations.map((item) => `- ${item}`).join("\n")}`);
+	const destination = path.join(outputDir, REPORT_PATH);
+	await fs.mkdir(path.dirname(destination), { recursive: true });
+	await fs.writeFile(destination, `${JSON.stringify(report, null, 2)}\n`, "utf8");
+	return destination;
+}
+//#endregion
 //#region src/bin/ssg.ts
 const helpText = `
 askr ssg - Static Site Generation for Askr
@@ -319,6 +588,31 @@ async function loadCreateStaticGen() {
 	if (typeof mod.createStaticGen !== "function") throw new Error("Failed to load createStaticGen from @askrjs/askr/ssg");
 	return mod.createStaticGen;
 }
+async function loadRouteAdapter() {
+	const mod = await import("@askrjs/askr/router");
+	if (typeof mod.createRouteRegistry !== "function" || typeof mod.route !== "function") throw new Error("Failed to load route registry APIs from @askrjs/askr/router");
+	return mod;
+}
+function registryFromLegacyRoutes(routes, adapter) {
+	return adapter.createRouteRegistry(() => {
+		for (const [index, value] of routes.entries()) {
+			if (!value || typeof value !== "object" || Array.isArray(value)) throw new TypeError(`SSG route at index ${index} must be an object`);
+			const { path: routePath, handler, component, props, params, ...options } = value;
+			const implementation = handler ?? component;
+			if (typeof routePath !== "string" || typeof implementation !== "function") throw new TypeError(`SSG route at index ${index} must provide a string path and a handler or component function`);
+			const implementationFunction = implementation;
+			const routeComponent = props && typeof props === "object" && !Array.isArray(props) ? (routeParams, context) => implementationFunction({
+				...props,
+				...routeParams
+			}, context) : implementationFunction;
+			const routeOptions = {
+				...options,
+				...params !== void 0 && options.entries === void 0 ? { entries: () => [params] } : {}
+			};
+			adapter.route(routePath, routeComponent, routeOptions);
+		}
+	});
+}
 function parseCliArgs(args) {
 	const parsed = {
 		configPath: "",
@@ -388,7 +682,7 @@ function toGenerateOptions(args) {
 		forceFull: args.forceFull
 	};
 }
-function printSummary(io, outputDir, durationSeconds, result, sitemapPath) {
+function printSummary(io, outputDir, durationSeconds, result, sitemapPath, reportPath) {
 	io.log("");
 	io.log(`Generation complete in ${durationSeconds}s`);
 	io.log(`   Mode:      ${result.mode}`);
@@ -401,6 +695,7 @@ function printSummary(io, outputDir, durationSeconds, result, sitemapPath) {
 	io.log(`   Output:    ${outputDir}`);
 	io.log(`   Metadata:  ${outputDir}/metadata.json`);
 	if (sitemapPath) io.log(`   Sitemap:   ${sitemapPath}`);
+	if (reportPath) io.log(`   Report:    ${reportPath}`);
 	io.log("");
 }
 async function runSsgCli(args = process.argv.slice(2), deps = {}, io = console) {
@@ -470,6 +765,7 @@ async function runSsgCli(args = process.argv.slice(2), deps = {}, io = console)
 		}
 		io.log(hasRoutes ? `Generating ${config.routes?.length ?? 0} routes...` : "Generating registered routes...");
 		const createStaticGen = typeof resolvedDeps.createStaticGen === "function" ? resolvedDeps.createStaticGen : await loadCreateStaticGen();
+		const routeSource = hasRoutes && typeof resolvedDeps.createStaticGen !== "function" ? { registry: registryFromLegacyRoutes(config.routes ?? [], await loadRouteAdapter()) } : hasRoutes ? { routes: config.routes } : { registry: config.registry };
 		cliStagingDir = await createSiblingStage(resolvedOutputDir, "askr-ssg");
 		if (parsed.incremental && !parsed.forceFull && await pathExists(resolvedOutputDir)) await fs$1.cp(resolvedOutputDir, cliStagingDir, {
 			recursive: true,
@@ -477,7 +773,7 @@ async function runSsgCli(args = process.argv.slice(2), deps = {}, io = console)
 		});
 		const generationOutputDir = cliStagingDir;
 		const ssg = createStaticGen({
-			...hasRoutes ? { routes: config.routes } : { registry: config.registry },
+			...routeSource,
 			outputDir: generationOutputDir,
 			seed: config.seed,
 			dataOverrides: config.dataOverrides,
@@ -488,13 +784,20 @@ async function runSsgCli(args = process.argv.slice(2), deps = {}, io = console)
 		});
 		const startTime = resolvedDeps.now();
 		const result = await ssg.generate(toGenerateOptions(parsed));
-		const sitemapPath = result.failed === 0 && config.sitemap !== false && config.siteUrl ? await generateSitemap(generationOutputDir, config.siteUrl, result.routes, config.sitemap) : void 0;
+		const inspections = result.failed === 0 ? await inspectSsgDocuments(generationOutputDir, result.routes) : /* @__PURE__ */ new Map();
+		const inspectedRoutes = result.routes.map((route) => ({
+			...route,
+			...inspections.get(route.path)?.canonical ? { canonical: inspections.get(route.path)?.canonical } : {}
+		}));
+		const sitemapPath = result.failed === 0 && config.sitemap !== false && config.siteUrl ? await generateSitemap(generationOutputDir, config.siteUrl, inspectedRoutes, config.sitemap) : void 0;
 		if (result.failed === 0 && config.sitemap === false) await removeGeneratedSitemap(generationOutputDir);
+		const reportPath = result.failed === 0 && config.outputReport !== false ? await writeSsgOutputReport(generationOutputDir, result.routes, inspections, config.outputReport) : void 0;
+		if (result.failed === 0 && config.outputReport === false) await removeSsgOutputReport(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);
+		printSummary(io, resolvedOutputDir, ((resolvedDeps.now() - startTime) / 1e3).toFixed(2), result, sitemapPath ? path$1.join(resolvedOutputDir, path$1.relative(generationOutputDir, sitemapPath)) : void 0, reportPath ? path$1.join(resolvedOutputDir, path$1.relative(generationOutputDir, reportPath)) : 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}`);

package/dist/templates/ssr/src/pages/example.tsx

@@ -92,7 +92,7 @@ export default function Example() {
         <p class="text-muted">
           Reactive state driving UI updates in real time.
         </p>
-        <div style="display: flex; align-items: center; gap: var(--ak-space-md); margin-bottom: var(--ak-space-md);">
+        <div class="showcase-controls">
           <Toggle pressed={bold()} onPress={() => setBold((b) => !b)}>
             Bold
           </Toggle>

package/dist/templates/ssr/src/styles.css

@@ -127,6 +127,13 @@ code {
   margin-bottom: var(--ak-space-md);
 }
 
+.showcase-controls {
+  display: flex;
+  align-items: center;
+  gap: var(--ak-space-md);
+  margin-bottom: var(--ak-space-md);
+}
+
 /* Hero buttons */
 .hero-actions {
   display: flex;

package/dist/templates/startkit/src/components/app-header.tsx

@@ -24,9 +24,9 @@ export default function AppHeader() {
   return (
     <header class="app-header">
       <Inline
+        class="app-header-content"
         align="center"
         justify="between"
-        gap="var(--ak-space-lg)"
         wrap="wrap"
       >
         <div class="breadcrumbs">

package/dist/templates/startkit/src/components/page-header.tsx

@@ -6,13 +6,7 @@ export default function PageHeader(props: {
   actions?: unknown;
 }) {
   return (
-    <Inline
-      class="page-header"
-      align="center"
-      justify="between"
-      gap="var(--ak-space-lg)"
-      wrap="wrap"
-    >
+    <Inline class="page-header" align="center" justify="between" wrap="wrap">
       <div class="page-header-copy">
         <h1>{props.title}</h1>
         <p>{props.description}</p>

package/dist/templates/startkit/src/pages/workspace/accounts/index.tsx

@@ -147,7 +147,7 @@ export default function AccountsPage() {
           errorText={accountsResource.error?.message ?? null}
         />
 
-        <Inline align="center" gap="var(--ak-space-lg)" wrap="wrap">
+        <Inline class="account-bulk-actions" align="center" wrap="wrap">
           <span class="muted">{selectedIdsState().length} selected</span>
 
           <AlertDialog>

package/dist/templates/startkit/src/pages/workspace/settings.tsx

@@ -172,7 +172,7 @@ export default function SettingsPage() {
             </Select>
           </Field>
 
-          <Inline align="center" gap="var(--ak-space-sm)" wrap="wrap">
+          <Inline class="settings-example-actions" align="center" wrap="wrap">
             <Button class="button-secondary" disabled>
               Disabled action example
             </Button>

package/dist/templates/startkit/src/styles/components.css

@@ -124,6 +124,16 @@
     max-inline-size: var(--starter-content-max-ch);
   }
 
+  .page-header,
+  .app-header-content,
+  .account-bulk-actions {
+    gap: var(--ak-space-lg);
+  }
+
+  .settings-example-actions {
+    gap: var(--ak-space-sm);
+  }
+
   .stat-card {
     display: grid;
     gap: var(--ak-space-sm);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@askrjs/cli",
-  "version": "0.0.16",
+  "version": "0.0.18",
   "description": "Unified CLI for the Askr platform",
   "homepage": "https://github.com/askrjs/askr-cli#readme",
   "bugs": {
@@ -41,21 +41,24 @@
     "fmt": "vp fmt .",
     "lint": "vp lint src tests benchmarks vite.config.ts vitest.config.ts vitest.bench.config.ts",
     "typecheck": "tsc -p tsconfig.json --noEmit",
+    "test:changelog": "node scripts/verify-changelog.mjs",
+    "test:peer-floor": "node scripts/verify-peer-floor.mjs",
     "test:publint": "publint",
     "pack:check": "npm pack --ignore-scripts --dry-run --json",
     "test:templates": "node scripts/verify-packed-templates.mjs",
     "bench": "npm run build --silent && npm run bench:analyze && node --import tsx benchmarks/cli.mjs --gate",
     "bench:analyze": "vp test bench --run -c vitest.bench.config.ts",
     "bench:json": "npm run build --silent && node --import tsx benchmarks/cli.mjs --gate --json",
-    "check": "npm run lint && npm run typecheck && npm run test:coverage && npm run build && npm run test:publint && npm run pack:check",
+    "check": "npm run lint && npm run typecheck && npm run test:coverage && npm run test:changelog && npm run build && npm run test:publint && npm run pack:check",
     "prepack": "npm run build",
-    "prepublishOnly": "npm run check && npm run test:templates"
+    "prepublishOnly": "npm run check && npm run test:templates && npm run test:peer-floor"
   },
   "dependencies": {
     "@npmcli/config": "^10.12.0",
-    "js-yaml": "^5.2.1",
-    "minimatch": "^10.2.5",
+    "js-yaml": "^5.2.2",
+    "minimatch": "^10.2.6",
     "npm-registry-fetch": "^19.1.1",
+    "parse5": "^8.0.1",
     "semver": "^7.8.5",
     "tsx": "^4.23.1",
     "typescript": "^6.0.3"
@@ -73,7 +76,7 @@
     "@types/semver": "^7.7.1",
     "@vitest/coverage-v8": "^4.1.10",
     "publint": "^0.3.21",
-    "vite-plus": "^0.2.4",
+    "vite-plus": "0.2.5",
     "vitest": "^4.1.10"
   },
   "peerDependencies": {