@askrjs/cli 0.0.17 → 0.0.18

package/dist/analyze.js

@@ -71,7 +71,7 @@ async function runAnalyzeCli(args = process.argv.slice(2), io = console, runtime
 			io.log(helpText.trimEnd());
 			return 0;
 		}
-		const report = await (runtime.analyze ?? (await import("./runner-SJnfoNvK.js")).runAnalysis)({
+		const report = await (runtime.analyze ?? (await import("./runner-CYvonJ0C.js")).runAnalysis)({
 			cwd: parsed.cwd,
 			workspacePatterns: parsed.workspacePatterns,
 			check: parsed.check

package/dist/cli.js

@@ -96,7 +96,7 @@ async function runCli(args = process.argv.slice(2), io = console) {
 		return runAnalyzeCli(args.slice(1), io);
 	}
 	if (command === "check" || command === "doctor" || command === "repair") {
-		const { runGuardrailCli } = await import("./guardrails-Dq4-Rglh.js");
+		const { runGuardrailCli } = await import("./guardrails-L60OAzIp.js");
 		return runGuardrailCli(command, args.slice(1), io);
 	}
 	if (command === "generate") {

package/dist/{guardrails-Dq4-Rglh.js → guardrails-L60OAzIp.js}

@@ -98,7 +98,7 @@ async function runGuardrailCli(command, args = process.argv.slice(2), io = conso
 			cwd: parsed.cwd,
 			workspacePatterns: parsed.workspacePatterns
 		};
-		const { runCheck, runDoctor, runRepair } = await import("./runner-H-TW4lHZ.js");
+		const { runCheck, runDoctor, runRepair } = await import("./runner-DzWc9R4G.js");
 		const report = command === "doctor" ? await runDoctor(options, runtime) : command === "repair" ? await runRepair(options) : await runCheck(options, runtime);
 		if (parsed.json) io.log(JSON.stringify(report));
 		else if (report.command === "doctor") printDoctor(report, io);

package/dist/{runner-SJnfoNvK.js → runner-CYvonJ0C.js}

@@ -336,6 +336,10 @@ function visit(sourceFile, callback) {
 	};
 	walk(sourceFile);
 }
+function runtimeLiteralText(node) {
+	if (ts.isStringLiteral(node) || ts.isNoSubstitutionTemplateLiteral(node) || ts.isTemplateHead(node) || ts.isTemplateMiddle(node) || ts.isTemplateTail(node)) return node.text;
+	return null;
+}
 function containingFunction(node) {
 	for (let current = node.parent; current; current = current.parent) if (ts.isFunctionLike(current)) return current;
 	return null;
@@ -651,6 +655,89 @@ function resolvedFunction(expression, context) {
 	if (declaration && ts.isVariableDeclaration(declaration) && declaration.initializer && (ts.isArrowFunction(declaration.initializer) || ts.isFunctionExpression(declaration.initializer))) return declaration.initializer;
 	return null;
 }
+function routeDefinitionCallback(call, name, context) {
+	return resolvedFunction(name === "group" ? call.arguments[1] : call.arguments.at(-1), context);
+}
+function normalizeRoutePrefix(pathname) {
+	if (!pathname.startsWith("/")) return null;
+	if (pathname === "/") return pathname;
+	return pathname.replace(/\/+$/, "") || "/";
+}
+function analyzedPagePrefix(pathname) {
+	if (!pathname) return null;
+	return normalizeRoutePrefix(pathname.startsWith("/") ? pathname : `/${pathname}`);
+}
+function joinAnalyzedRoutePath(prefix, pathname) {
+	const child = pathname.replace(/^\/+|\/+$/g, "");
+	if (!child) return prefix;
+	return prefix === "/" ? `/${child}` : `${prefix}/${child}`;
+}
+function analyzedRoutePath(call, name, scope) {
+	if (name !== "route" && name !== "page") return null;
+	const literal = call.arguments[0];
+	if (!literal || !ts.isStringLiteral(literal)) return null;
+	if (name === "page") return scope.page ? null : analyzedPagePrefix(literal.text);
+	if (literal.text.startsWith("/")) return scope.page ? null : normalizeRoutePrefix(literal.text);
+	return scope.page?.pathPrefix ? joinAnalyzedRoutePath(scope.page.pathPrefix, literal.text) : null;
+}
+const ROUTE_DEFINITION_CALLS = /* @__PURE__ */ new Set([
+	"route",
+	"page",
+	"index",
+	"group",
+	"fallback"
+]);
+function walkRouteDefinition(context, definition, scope, visitor, active = /* @__PURE__ */ new Set()) {
+	if (active.has(definition)) return;
+	active.add(definition);
+	const bindings = sourceBindings(definition.getSourceFile());
+	const body = ts.isArrowFunction(definition) || ts.isFunctionExpression(definition) || ts.isFunctionDeclaration(definition) ? definition.body : void 0;
+	if (body) {
+		const walkNode = (node) => {
+			if (node !== body && ts.isFunctionLike(node)) return;
+			if (ts.isCallExpression(node)) {
+				const name = canonicalCallName(node.expression, bindings);
+				if (name && ROUTE_DEFINITION_CALLS.has(name)) {
+					visitor(node, name, scope);
+					if (name === "group") {
+						const callback = routeDefinitionCallback(node, "group", context);
+						if (callback) walkRouteDefinition(context, callback, scope, visitor, active);
+					} else if (name === "page" && !scope.page) {
+						const callback = routeDefinitionCallback(node, "page", context);
+						const pathname = node.arguments[0];
+						const pathPrefix = pathname && ts.isStringLiteral(pathname) ? analyzedPagePrefix(pathname.text) : null;
+						if (callback) walkRouteDefinition(context, callback, { page: {
+							pathPrefix,
+							indexCount: 0
+						} }, visitor, active);
+					}
+					return;
+				}
+				const called = resolvedFunction(node.expression, context);
+				if (called) {
+					walkRouteDefinition(context, called, scope, visitor, active);
+					return;
+				}
+			}
+			ts.forEachChild(node, walkNode);
+		};
+		walkNode(body);
+	}
+	active.delete(definition);
+}
+function walkRouteDefinitions(context, visitor) {
+	const entrypoints = [];
+	for (const sourceFile of context.sourceFiles) {
+		const bindings = sourceBindings(sourceFile);
+		visit(sourceFile, (node) => {
+			if (ts.isCallExpression(node) && canonicalCallName(node.expression, bindings) === "createRouteRegistry") {
+				const definition = resolvedFunction(node.arguments[0], context);
+				if (definition) entrypoints.push(definition);
+			}
+		});
+	}
+	for (const definition of entrypoints) walkRouteDefinition(context, definition, { page: null }, visitor);
+}
 const asyncComponentRule = {
 	id: "askr/no-async-component",
 	category: "correctness",
@@ -744,27 +831,99 @@ const routePathRule = {
 	id: "askr/route-path-syntax",
 	category: "correctness",
 	severity: "error",
-	description: "Askr route parameters use {name} segments.",
+	description: "Static route paths must satisfy the runtime authoring contract.",
 	analyze(context) {
 		const diagnostics = [];
-		const pathCalls = /* @__PURE__ */ new Set(["route", "page"]);
-		for (const sourceFile of context.sourceFiles) {
-			const bindings = sourceBindings(sourceFile);
-			visit(sourceFile, (node) => {
-				if (!ts.isCallExpression(node)) return;
-				const name = canonicalCallName(node.expression, bindings);
-				const first = node.arguments[0];
-				if (!name || !pathCalls.has(name) || !first || !ts.isStringLiteral(first)) return;
-				if (!/:([^/{}]+)/.test(first.text)) return;
-				const replacement = first.text.replace(/:([^/{}]+)/g, "{$1}");
-				diagnostics.push(diagnostic(context, first, this, `Route path '${first.text}' uses colon parameters instead of {name} segments.`, `Use '${replacement}'.`, {
+		const seen = /* @__PURE__ */ new Set();
+		const inspect = (call, name, scope) => {
+			if (name !== "route" && name !== "page") return;
+			const literal = call.arguments[0];
+			if (!literal || !ts.isStringLiteral(literal)) return;
+			const sourceFile = literal.getSourceFile();
+			const key = `${sourceFile.fileName}:${literal.getStart(sourceFile)}`;
+			if (seen.has(key)) return;
+			seen.add(key);
+			if (name === "page" && literal.text.length === 0) {
+				diagnostics.push(diagnostic(context, literal, this, "page() requires a non-empty path.", "Pass a non-empty path to page()."));
+				return;
+			}
+			if (scope.page && name === "page") return;
+			if (scope.page && literal.text.startsWith("/")) return;
+			let pathname = literal.text;
+			if (!pathname.startsWith("/")) {
+				if (name === "route" && !scope.page) {
+					const replacement = `/${pathname}`;
+					diagnostics.push(diagnostic(context, literal, this, `Route path '${pathname}' must begin with "/" outside a page scope.`, `Use '${replacement}'.`, {
+						description: "Add the required leading slash to the root route path",
+						filePath: sourceFile.fileName,
+						start: literal.getStart(sourceFile),
+						end: literal.getEnd(),
+						replacement: JSON.stringify(replacement)
+					}));
+					return;
+				}
+				pathname = scope.page?.pathPrefix ? joinAnalyzedRoutePath(scope.page.pathPrefix, pathname) : `/${pathname.replace(/^\/+/, "")}`;
+			}
+			if (/\/{2,}/.test(pathname)) {
+				const replacement = literal.text.replace(/\/{2,}/g, "/");
+				diagnostics.push(diagnostic(context, literal, this, `Route path '${literal.text}' contains consecutive slashes.`, `Use '${replacement}'.`, {
+					description: "Collapse consecutive slashes in the route path",
+					filePath: sourceFile.fileName,
+					start: literal.getStart(sourceFile),
+					end: literal.getEnd(),
+					replacement: JSON.stringify(replacement)
+				}));
+				return;
+			}
+			if (/:([^/{}]+)/.test(pathname)) {
+				const replacement = literal.text.replace(/:([^/{}]+)/g, "{$1}");
+				diagnostics.push(diagnostic(context, literal, this, `Route path '${literal.text}' uses colon parameters instead of {name} segments.`, `Use '${replacement}'.`, {
 					description: "Convert colon route parameters to Askr {name} segments",
 					filePath: sourceFile.fileName,
-					start: first.getStart(sourceFile),
-					end: first.getEnd(),
+					start: literal.getStart(sourceFile),
+					end: literal.getEnd(),
 					replacement: JSON.stringify(replacement)
 				}));
-			});
+				return;
+			}
+			const segments = pathname.split("/").filter(Boolean);
+			const seenParameters = /* @__PURE__ */ new Set();
+			for (let index = 0; index < segments.length; index += 1) {
+				const segment = segments[index];
+				if (segment === "*") continue;
+				const hasOpenBrace = segment.includes("{");
+				const hasCloseBrace = segment.includes("}");
+				if (!hasOpenBrace && !hasCloseBrace) continue;
+				if (!(segment.startsWith("{") && segment.endsWith("}"))) {
+					diagnostics.push(diagnostic(context, literal, this, "Route parameter segments must use complete {name} interpolation.", "Make the entire path segment a {name} or {*name} interpolation."));
+					return;
+				}
+				const rawParameter = segment.slice(1, -1).trim();
+				const splat = rawParameter.startsWith("*");
+				const parameter = (splat ? rawParameter.slice(1) : rawParameter).trim();
+				if (!parameter) {
+					diagnostics.push(diagnostic(context, literal, this, splat ? "Route splat parameter name cannot be empty." : "Route parameter name cannot be empty.", "Give every route parameter a non-empty name."));
+					return;
+				}
+				if (splat && parameter === "*") {
+					diagnostics.push(diagnostic(context, literal, this, "Route named splat parameter name cannot be \"*\".", "Use a descriptive named splat such as {*path}."));
+					return;
+				}
+				if (splat && index !== segments.length - 1) {
+					diagnostics.push(diagnostic(context, literal, this, "Route named splat parameters must be the final segment.", "Move the named splat to the end of the route path."));
+					return;
+				}
+				if (seenParameters.has(parameter)) {
+					diagnostics.push(diagnostic(context, literal, this, `Route path cannot reuse duplicate parameter name "${parameter}".`, "Use a unique name for each route parameter."));
+					return;
+				}
+				seenParameters.add(parameter);
+			}
+		};
+		walkRouteDefinitions(context, inspect);
+		for (const sourceFile of context.sourceFiles) for (const { node, name } of sourceFacts(sourceFile).calls) {
+			if (name !== "route" && name !== "page") continue;
+			inspect(node, name, { page: null });
 		}
 		return diagnostics;
 	}
@@ -1400,6 +1559,45 @@ const forRowClosureCaptureRule = {
 		return diagnostics;
 	}
 };
+const RENDER_REQUIRED_CONCEPTS = /* @__PURE__ */ new Set([
+	"readScope",
+	"getSignal",
+	"routeData",
+	"ErrorBoundary"
+]);
+const NON_RENDER_SCHEDULERS = /* @__PURE__ */ new Set([
+	"setTimeout",
+	"setInterval",
+	"queueMicrotask",
+	"requestAnimationFrame"
+]);
+const PROMISE_CONTINUATIONS = /* @__PURE__ */ new Set([
+	"then",
+	"catch",
+	"finally"
+]);
+function nonRenderCallbackOwner(callback, bindings) {
+	const parent = callback.parent;
+	if (ts.isJsxExpression(parent) && ts.isJsxAttribute(parent.parent)) {
+		const attribute = parent.parent;
+		return ts.isIdentifier(attribute.name) && /^on[A-Z]/.test(attribute.name.text);
+	}
+	if (ts.isCallExpression(parent) && parent.arguments.some((argument) => argument === callback)) {
+		if (canonicalCallName(parent.expression, bindings) === "task") return true;
+		if (ts.isIdentifier(parent.expression)) return NON_RENDER_SCHEDULERS.has(parent.expression.text);
+		if (ts.isPropertyAccessExpression(parent.expression)) return PROMISE_CONTINUATIONS.has(parent.expression.name.text);
+	}
+	if (ts.isPropertyAssignment(parent) && parent.name.getText() === "body") {
+		const options = parent.parent;
+		const call = options.parent;
+		return ts.isObjectLiteralExpression(options) && ts.isCallExpression(call) && call.arguments.some((argument) => argument === options) && canonicalCallName(call.expression, bindings) === "task";
+	}
+	return false;
+}
+function isResourceLoader(callback, bindings) {
+	const parent = callback.parent;
+	return ts.isCallExpression(parent) && parent.arguments[0] === callback && canonicalCallName(parent.expression, bindings) === "resource";
+}
 const renderScopeRequiredRule = {
 	id: "askr/render-scope-required",
 	category: "correctness",
@@ -1407,28 +1605,28 @@ const renderScopeRequiredRule = {
 	description: "Render-scoped APIs cannot be created in callbacks that execute outside rendering.",
 	analyze(context) {
 		const diagnostics = [];
-		const callbackCalls = /* @__PURE__ */ new Set([
-			"setTimeout",
-			"setInterval",
-			"queueMicrotask",
-			"then",
-			"catch",
-			"finally"
-		]);
 		for (const sourceFile of context.sourceFiles) {
 			const bindings = sourceBindings(sourceFile);
-			if (!sourceFacts(sourceFile).calls.some((fact) => RENDER_SCOPED_CONCEPTS.has(fact.name))) continue;
+			if (!sourceFacts(sourceFile).calls.some((fact) => RENDER_REQUIRED_CONCEPTS.has(fact.name) || RENDER_SCOPED_CONCEPTS.has(fact.name))) continue;
 			visit(sourceFile, (node) => {
 				if (!ts.isCallExpression(node)) return;
 				const name = canonicalCallName(node.expression, bindings);
-				if (!name || !RENDER_SCOPED_CONCEPTS.has(name) || name === "readScope") return;
-				for (let current = node.parent; current; current = current.parent) {
-					if (!ts.isFunctionLike(current)) continue;
-					const parent = current.parent;
-					if (!(ts.isCallExpression(parent) && (ts.isIdentifier(parent.expression) && callbackCalls.has(parent.expression.text) || ts.isPropertyAccessExpression(parent.expression) && callbackCalls.has(parent.expression.name.text)) || ts.isJsxExpression(parent) && ts.isJsxAttribute(parent.parent) || ts.isPropertyAssignment(parent) && parent.name.getText() === "body")) continue;
-					diagnostics.push(diagnostic(context, node.expression, this, `${name}() is created in a callback that is statically outside component rendering.`, `Create ${name}() at component render scope and use its value from the callback.`));
+				if (!name || !RENDER_REQUIRED_CONCEPTS.has(name) && !RENDER_SCOPED_CONCEPTS.has(name)) return;
+				const required = RENDER_REQUIRED_CONCEPTS.has(name);
+				const owner = containingFunction(node);
+				if (!owner) {
+					if (!required) return;
+					diagnostics.push(diagnostic(context, node.expression, this, `${name}() requires an active render scope and cannot be called at module scope.`, `Move ${name}() into component rendering.`));
 					return;
 				}
+				for (let current = owner; current; current = current.parent) {
+					if (!ts.isFunctionLike(current)) continue;
+					if (nonRenderCallbackOwner(current, bindings)) {
+						diagnostics.push(diagnostic(context, node.expression, this, `${name}() is called in a callback that is statically outside component rendering.`, `Read ${name}() during component render and use its value from the callback.`));
+						return;
+					}
+					if (name === "readScope" && isResourceLoader(current, bindings)) return;
+				}
 			});
 		}
 		return diagnostics;
@@ -1498,44 +1696,50 @@ const routeScopeStructureRule = {
 	description: "Nested page route scopes must have one index and relative child routes.",
 	analyze(context) {
 		const diagnostics = [];
-		for (const sourceFile of context.sourceFiles) {
-			const bindings = sourceBindings(sourceFile);
-			if (!sourceFacts(sourceFile).calls.some((fact) => fact.name === "page")) continue;
-			const inspectBody = (body) => {
-				let indexes = 0;
-				const walk = (node) => {
-					if (node !== body && ts.isFunctionLike(node)) return;
-					if (!ts.isCallExpression(node)) {
-						ts.forEachChild(node, walk);
-						return;
-					}
-					const name = canonicalCallName(node.expression, bindings);
-					if (name === "index") {
-						indexes += 1;
-						if (indexes > 1) diagnostics.push(diagnostic(context, node.expression, this, "A page scope declares more than one index route.", "Keep exactly one index() declaration in a page scope."));
-					}
-					if (name === "route") {
-						const routePath = node.arguments[0];
-						if (routePath && ts.isStringLiteral(routePath) && routePath.text.startsWith("/") && routePath.text.length > 1) {
-							const replacement = routePath.text.replace(/^\/+/, "");
-							diagnostics.push(diagnostic(context, routePath, this, `Child route '${routePath.text}' is absolute inside a page scope.`, `Use the relative child path '${replacement}'.`, {
-								description: "Strip the leading slash from a proven child route",
-								filePath: sourceFile.fileName,
-								start: routePath.getStart(sourceFile),
-								end: routePath.getEnd(),
-								replacement: JSON.stringify(replacement)
-							}));
-						}
-					}
-					ts.forEachChild(node, walk);
-				};
-				walk(body);
-			};
-			for (const { node, name } of sourceFacts(sourceFile).calls) {
-				if (name !== "page") continue;
-				const callback = node.arguments.find((argument) => ts.isArrowFunction(argument) || ts.isFunctionExpression(argument));
-				if (callback) inspectBody(callback.body);
+		const seen = /* @__PURE__ */ new Set();
+		const visitedCalls = /* @__PURE__ */ new Set();
+		const reportOnce = (node, kind, create) => {
+			const sourceFile = node.getSourceFile();
+			const key = `${sourceFile.fileName}:${node.getStart(sourceFile)}:${kind}`;
+			if (seen.has(key)) return;
+			seen.add(key);
+			diagnostics.push(create());
+		};
+		const inspect = (call, name, scope) => {
+			visitedCalls.add(call);
+			if (!scope.page) return;
+			if (name === "page") {
+				reportOnce(call, "nested-page", () => diagnostic(context, call.expression, this, "page() cannot be nested inside another page().", "Use route() for child leaves or group() for inherited behavior in the page scope."));
+				return;
 			}
+			if (name === "index") {
+				scope.page.indexCount += 1;
+				if (scope.page.indexCount > 1) reportOnce(call, "multiple-index", () => diagnostic(context, call.expression, this, "A page scope declares more than one index route.", "Keep exactly one index() declaration in a page scope."));
+				return;
+			}
+			if (name !== "route") return;
+			const routePath = call.arguments[0];
+			if (!routePath || !ts.isStringLiteral(routePath) || !routePath.text.startsWith("/") || routePath.text.length <= 1) return;
+			const sourceFile = routePath.getSourceFile();
+			const replacement = routePath.text.replace(/^\/+/, "");
+			reportOnce(routePath, "absolute-child", () => diagnostic(context, routePath, this, `Child route '${routePath.text}' is absolute inside a page scope.`, `Use the relative child path '${replacement}'.`, {
+				description: "Strip the leading slash from a proven child route",
+				filePath: sourceFile.fileName,
+				start: routePath.getStart(sourceFile),
+				end: routePath.getEnd(),
+				replacement: JSON.stringify(replacement)
+			}));
+		};
+		walkRouteDefinitions(context, inspect);
+		for (const sourceFile of context.sourceFiles) for (const { node, name } of sourceFacts(sourceFile).calls) {
+			if (name !== "page" || visitedCalls.has(node)) continue;
+			const callback = routeDefinitionCallback(node, "page", context);
+			if (!callback) continue;
+			const literal = node.arguments[0];
+			walkRouteDefinition(context, callback, { page: {
+				pathPrefix: literal && ts.isStringLiteral(literal) ? analyzedPagePrefix(literal.text) : null,
+				indexCount: 0
+			} }, inspect);
 		}
 		return diagnostics;
 	}
@@ -1612,6 +1816,71 @@ function literalJsxString(attribute) {
 	const expression = jsxExpression(attribute);
 	return expression && ts.isStringLiteralLike(expression) ? expression.text : null;
 }
+function unwrapStaticExpression(expression) {
+	let current = expression;
+	while (ts.isParenthesizedExpression(current) || ts.isAsExpression(current) || ts.isTypeAssertionExpression(current) || ts.isNonNullExpression(current) || ts.isSatisfiesExpression(current)) current = current.expression;
+	return current;
+}
+function routeReferencePath(expression, context, routePaths) {
+	const candidate = unwrapStaticExpression(expression);
+	if (ts.isCallExpression(candidate)) return routePaths.get(candidate) ?? null;
+	if (!ts.isIdentifier(candidate) && !ts.isPropertyAccessExpression(candidate)) return null;
+	const symbolNode = ts.isPropertyAccessExpression(candidate) ? candidate.name : candidate;
+	const localSymbol = context.checker.getSymbolAtLocation(symbolNode);
+	let symbol = localSymbol;
+	if (symbol && (symbol.flags & ts.SymbolFlags.Alias) !== 0) symbol = context.checker.getAliasedSymbol(symbol);
+	const declaration = symbol?.valueDeclaration ?? symbol?.declarations?.[0];
+	if (declaration && ts.isVariableDeclaration(declaration) && declaration.initializer) {
+		const initializer = unwrapStaticExpression(declaration.initializer);
+		if (ts.isCallExpression(initializer)) return routePaths.get(initializer) ?? null;
+	}
+	if (!ts.isIdentifier(candidate)) return null;
+	const importSpecifier = localSymbol?.declarations?.find(ts.isImportSpecifier);
+	if (!importSpecifier) return null;
+	let importDeclaration = importSpecifier;
+	while (importDeclaration.parent && !ts.isImportDeclaration(importDeclaration)) importDeclaration = importDeclaration.parent;
+	if (!ts.isImportDeclaration(importDeclaration) || !ts.isStringLiteral(importDeclaration.moduleSpecifier) || !importDeclaration.moduleSpecifier.text.startsWith(".")) return null;
+	const modulePath = path.resolve(path.dirname(importDeclaration.getSourceFile().fileName), importDeclaration.moduleSpecifier.text);
+	const sourceStem = (filePath) => {
+		const stem = filePath.replace(/\\/g, "/").replace(/\.[cm]?[jt]sx?$/, "");
+		return process.platform === "win32" ? stem.toLowerCase() : stem;
+	};
+	const target = context.sourceFiles.find((sourceFile) => {
+		const stem = sourceStem(sourceFile.fileName);
+		const expected = sourceStem(modulePath);
+		return stem === expected || stem === `${expected}/index`;
+	});
+	if (!target) return null;
+	const importedName = importSpecifier.propertyName?.text ?? importSpecifier.name.text;
+	let pathname = null;
+	visit(target, (node) => {
+		if (pathname !== null || !ts.isVariableDeclaration(node) || !ts.isIdentifier(node.name) || node.name.text !== importedName || !node.initializer || containingFunction(node)) return;
+		const initializer = unwrapStaticExpression(node.initializer);
+		if (ts.isCallExpression(initializer)) pathname = routePaths.get(initializer) ?? null;
+	});
+	return pathname;
+}
+function staticObjectKeys(object) {
+	const keys = /* @__PURE__ */ new Set();
+	for (const property of object.properties) {
+		if (ts.isSpreadAssignment(property)) return null;
+		if (!ts.isPropertyAssignment(property) && !ts.isShorthandPropertyAssignment(property) && !ts.isMethodDeclaration(property)) return null;
+		if (ts.isComputedPropertyName(property.name)) return null;
+		if (!ts.isIdentifier(property.name) && !ts.isStringLiteralLike(property.name) && !ts.isNumericLiteral(property.name)) return null;
+		keys.add(property.name.text);
+	}
+	return keys;
+}
+function routeParameterNames(pathname) {
+	const names = /* @__PURE__ */ new Set();
+	for (const segment of pathname.split("/")) {
+		if (!segment.startsWith("{") || !segment.endsWith("}")) continue;
+		const raw = segment.slice(1, -1).trim();
+		const name = (raw.startsWith("*") ? raw.slice(1) : raw).trim();
+		if (name) names.add(name);
+	}
+	return [...names];
+}
 const linkContractRule = {
 	id: "askr/link-contract",
 	category: "correctness",
@@ -1620,6 +1889,18 @@ const linkContractRule = {
 	analyze(context) {
 		const diagnostics = [];
 		const unsafe = /^(?:javascript|data|vbscript):/i;
+		const routePaths = /* @__PURE__ */ new Map();
+		for (const sourceFile of context.sourceFiles) for (const { node, name } of sourceFacts(sourceFile).calls) {
+			if (name !== "route" && name !== "page") continue;
+			const literal = node.arguments[0];
+			if (!literal || !ts.isStringLiteral(literal)) continue;
+			const pathname = literal.text.startsWith("/") ? normalizeRoutePrefix(literal.text) : name === "page" ? analyzedPagePrefix(literal.text) : null;
+			if (pathname) routePaths.set(node, pathname);
+		}
+		walkRouteDefinitions(context, (call, name, scope) => {
+			const pathname = analyzedRoutePath(call, name, scope);
+			if (pathname) routePaths.set(call, pathname);
+		});
 		for (const sourceFile of context.sourceFiles) {
 			const bindings = sourceBindings(sourceFile);
 			if (!sourceFacts(sourceFile).jsx.some((fact) => fact.name === "Link")) continue;
@@ -1634,6 +1915,25 @@ const linkContractRule = {
 				else if (to && href) diagnostics.push(diagnostic(context, node.tagName, this, "<Link> cannot specify both to and href."));
 				const destination = literalJsxString(href ?? to);
 				if (destination && unsafe.test(destination.trim())) diagnostics.push(diagnostic(context, href ?? to ?? node.tagName, this, `<Link> uses the unsafe '${destination.split(":")[0]}:' URL scheme.`, "Use http, https, mailto, tel, sms, a relative URL, or a route reference."));
+				const rawToExpression = jsxExpression(to);
+				if (!rawToExpression) return;
+				const toExpression = unwrapStaticExpression(rawToExpression);
+				if (!ts.isCallExpression(toExpression)) return;
+				if (canonicalCallName(toExpression.expression, bindings) !== "to") return;
+				const rawParams = toExpression.arguments[1];
+				if (!rawParams) return;
+				const params = unwrapStaticExpression(rawParams);
+				if (!ts.isObjectLiteralExpression(params)) return;
+				const keys = staticObjectKeys(params);
+				if (!keys) return;
+				const routeExpression = toExpression.arguments[0];
+				if (!routeExpression) return;
+				const pathname = routeReferencePath(routeExpression, context, routePaths);
+				if (!pathname) return;
+				for (const parameter of routeParameterNames(pathname)) {
+					if (keys.has(parameter)) continue;
+					diagnostics.push(diagnostic(context, params, this, `Link destination is missing route parameter "${parameter}".`, `Pass '${parameter}' in the static to() parameter object.`));
+				}
 			});
 		}
 		return diagnostics;
@@ -1679,16 +1979,22 @@ const ANALYZE_RULES = [
 		id: "askr/no-hardcoded-theme-token",
 		category: "correctness",
 		severity: "warning",
-		description: "Runtime UI literals should use semantic theme tokens.",
+		description: "Runtime UI literals should use semantic theme styling.",
 		analyze(context) {
-			if (["@askrjs/askr", "@askrjs/themes"].includes(packageName(context.workspace.manifest))) return [];
+			const workspacePackage = packageName(context.workspace.manifest);
+			const ownsThemeTokens = workspacePackage === "@askrjs/themes";
+			const mayHardcodeColors = ["@askrjs/askr", "@askrjs/themes"].includes(workspacePackage);
 			const diagnostics = [];
 			const color = /(?:#[0-9a-f]{3,8}\b|\brgba?\s*\(|\bhsla?\s*\()/i;
 			for (const sourceFile of context.sourceFiles) {
-				if (/(?:^|[./_-])(?:test|spec)\.[cm]?[jt]sx?$/.test(sourceFile.fileName)) continue;
-				if (!color.test(sourceFile.text)) continue;
+				const checkColors = !mayHardcodeColors && !/(?:^|[./_-])(?:test|spec)\.[cm]?[jt]sx?$/.test(sourceFile.fileName) && color.test(sourceFile.text);
+				const checkTokens = !ownsThemeTokens && sourceFile.text.includes("--ak-");
+				if (!checkColors && !checkTokens) continue;
 				visit(sourceFile, (node) => {
-					if ((ts.isStringLiteralLike(node) || ts.isNoSubstitutionTemplateLiteral(node)) && color.test(node.text)) diagnostics.push(diagnostic(context, node, this, `Runtime UI literal '${node.text}' hardcodes a color instead of a theme token.`, "Use a semantic prop, theme variable, or design-system class."));
+					const text = runtimeLiteralText(node);
+					if (text === null) return;
+					if (checkTokens && text.includes("--ak-")) diagnostics.push(diagnostic(context, node, this, "Runtime code names an Askr theme token directly; use a semantic class or data-* attribute instead.", "Move the token mapping to theme CSS and select it through a semantic class or data-* attribute."));
+					else if (checkColors && color.test(text)) diagnostics.push(diagnostic(context, node, this, `Runtime UI literal '${text}' hardcodes a color instead of a theme token.`, "Use a semantic prop, theme variable, or design-system class."));
 				});
 			}
 			return diagnostics;

package/dist/{runner-H-TW4lHZ.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-SJnfoNvK.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.17",
+  "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.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": {