@askrjs/cli 0.0.3 → 0.0.5

package/dist/generate.js

@@ -1,5 +1,5 @@
-import { mkdir, mkdtemp, readFile, readdir, rename, rm, writeFile } from "node:fs/promises";
-import { basename, dirname, join, resolve } from "node:path";
+import { mkdir, mkdtemp, readFile, readdir, rename, rm, stat, writeFile } from "node:fs/promises";
+import { basename, dirname, isAbsolute, join, relative, resolve } from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
 import { load } from "js-yaml";
 //#region src/generate/generator.ts
@@ -29,25 +29,38 @@ const pascal = (name) => {
 	const result = name.replace(/(^|[^A-Za-z0-9]+)([A-Za-z0-9])/g, (_, _s, c) => c.toUpperCase()).replace(/[^A-Za-z0-9_$]/g, "");
 	return /^\d/.test(result) ? `_${result}` : result;
 };
-function schemaType(schema, at, direction = "response") {
+function schemaType(schema, at, direction = "response", references) {
 	if (schema.$ref) {
 		const name = decodeURIComponent(String(schema.$ref).split("/").at(-1));
-		return pascal(name);
+		const typeName = pascal(name);
+		references?.add(typeName);
+		return typeName;
+	}
+	if (Array.isArray(schema.type)) {
+		const includesNull = schema.type.includes("null");
+		const rendered = [...new Set(schema.type.filter((value) => value !== "null"))].map((variant) => schemaType({
+			...schema,
+			type: variant,
+			nullable: false
+		}, at, direction, references));
+		if (includesNull) rendered.push("null");
+		if (rendered.length === 0) fail("Schema type array must not be empty", at);
+		return [...new Set(rendered)].join(" | ");
 	}
 	if (schema.const !== void 0) return JSON.stringify(schema.const);
 	if (schema.enum) return schema.enum.map((value) => JSON.stringify(value)).join(" | ") || "never";
-	if (schema.oneOf || schema.anyOf) return (schema.oneOf ?? schema.anyOf).map((item, i) => schemaType(item, `${at}/${schema.oneOf ? "oneOf" : "anyOf"}/${i}`, direction)).join(" | ");
-	if (schema.allOf) return schema.allOf.map((item, i) => schemaType(item, `${at}/allOf/${i}`, direction)).join(" & ");
+	if (schema.oneOf || schema.anyOf) return (schema.oneOf ?? schema.anyOf).map((item, i) => schemaType(item, `${at}/${schema.oneOf ? "oneOf" : "anyOf"}/${i}`, direction, references)).join(" | ");
+	if (schema.allOf) return schema.allOf.map((item, i) => schemaType(item, `${at}/allOf/${i}`, direction, references)).join(" & ");
 	let type = "never";
 	if (schema.type === "string") type = "string";
 	else if (schema.type === "number" || schema.type === "integer") type = "number";
 	else if (schema.type === "boolean") type = "boolean";
 	else if (schema.type === "null") type = "null";
-	else if (schema.type === "array" || schema.items) type = `Array<${schemaType(schema.items ?? {}, `${at}/items`, direction)}>`;
+	else if (schema.type === "array" || schema.items) type = `Array<${schemaType(schema.items ?? {}, `${at}/items`, direction, references)}>`;
 	else if (schema.type === "object" || schema.properties || schema.additionalProperties !== void 0) {
 		const required = new Set(schema.required ?? []);
-		const properties = Object.entries(schema.properties ?? {}).filter(([, value]) => !(direction === "request" ? value.readOnly : value.writeOnly)).map(([key, value]) => `  ${JSON.stringify(key)}${required.has(key) ? "" : "?"}: ${schemaType(value, `${at}/properties/${key}`, direction)};`);
-		if (schema.additionalProperties && typeof schema.additionalProperties === "object") properties.push(`  [key: string]: ${schemaType(schema.additionalProperties, `${at}/additionalProperties`, direction)};`);
+		const properties = Object.entries(schema.properties ?? {}).filter(([, value]) => !(direction === "request" ? value.readOnly : value.writeOnly)).map(([key, value]) => `  ${JSON.stringify(key)}${required.has(key) ? "" : "?"}: ${schemaType(value, `${at}/properties/${key}`, direction, references)};`);
+		if (schema.additionalProperties && typeof schema.additionalProperties === "object") properties.push(`  [key: string]: ${schemaType(schema.additionalProperties, `${at}/additionalProperties`, direction, references)};`);
 		type = `{\n${properties.join("\n")}\n}`;
 	} else if (!schema.type) fail("Unsupported schema without a type", at);
 	else fail(`Unsupported schema type ${schema.type}`, at);
@@ -56,7 +69,7 @@ function schemaType(schema, at, direction = "response") {
 function responseSchema(operation, at, success) {
 	return Object.entries(operation.responses ?? {}).filter(([status]) => status === "default" ? !success : success === /^2\d\d$/.test(status)).sort(([a], [b]) => a.localeCompare(b, void 0, { numeric: true }));
 }
-function pickContent(content, at, direction) {
+function pickContent(content, at, direction, references) {
 	const entries = Object.entries(content ?? {}).sort(([a], [b]) => a.localeCompare(b));
 	if (!entries.length) return {
 		type: "undefined",
@@ -65,7 +78,7 @@ function pickContent(content, at, direction) {
 	};
 	const types = entries.map(([mediaType, value]) => ({
 		mediaType,
-		type: schemaType(value.schema ?? {}, `${at}/content/${mediaType.replace(/~/g, "~0").replace(/\//g, "~1")}/schema`, direction)
+		type: schemaType(value.schema ?? {}, `${at}/content/${mediaType.replace(/~/g, "~0").replace(/\//g, "~1")}/schema`, direction, references)
 	}));
 	const union = [...new Set(types.map((v) => v.type))].join(" | ");
 	return {
@@ -218,6 +231,13 @@ function generateFiles(document) {
 		names.set(safe, name);
 	}
 	const schemaLines = [...names].map(([safe, original]) => `export type ${safe} = ${schemaType(schemas[original], pointer("components", "schemas", original))};`);
+	const operationSchemaReferences = /* @__PURE__ */ new Set();
+	const apiSchemaReferences = /* @__PURE__ */ new Set();
+	const apiOperationReferences = /* @__PURE__ */ new Set();
+	const contentSchemaReferences = { add(name) {
+		operationSchemaReferences.add(name);
+		apiSchemaReferences.add(name);
+	} };
 	const operationTypes = [];
 	const descriptors = [];
 	const seen = /* @__PURE__ */ new Set();
@@ -230,24 +250,38 @@ function generateFiles(document) {
 		if (seen.has(id)) fail("Duplicate operationId", `${at}/operationId`, id);
 		seen.add(id);
 		if (operation.callbacks) fail("Callbacks are unsupported", `${at}/callbacks`, id);
-		const parameters = [...document.paths[path].parameters ?? [], ...operation.parameters ?? []];
+		const parametersByIdentity = /* @__PURE__ */ new Map();
+		for (const parameter of [...document.paths[path].parameters ?? [], ...operation.parameters ?? []]) {
+			if (parameter.$ref) fail("Parameter references must be bundled", `${at}/parameters`, id);
+			if (typeof parameter.name !== "string" || typeof parameter.in !== "string") fail("Parameters require string name and in fields", `${at}/parameters`, id);
+			parametersByIdentity.set(`${parameter.in}\0${parameter.name}`, parameter);
+		}
+		const parameters = [...parametersByIdentity.values()];
 		const byLocation = {
 			path: [],
 			query: [],
 			header: []
 		};
 		for (const parameter of parameters) {
-			if (parameter.$ref) fail("Parameter references must be bundled", `${at}/parameters`, id);
 			if (parameter.in === "cookie") fail("Cookie parameters are unsupported", `${at}/parameters`, id);
 			if (!byLocation[parameter.in]) fail(`Unsupported parameter location ${parameter.in}`, `${at}/parameters`, id);
 			byLocation[parameter.in].push(parameter);
 		}
+		const templateParameters = new Set([...path.matchAll(/\{([^{}]+)\}/g)].map((match) => match[1]));
+		const declaredPathParameters = new Set(byLocation.path.map((parameter) => parameter.name));
+		for (const name of templateParameters) {
+			const parameter = byLocation.path.find((candidate) => candidate.name === name);
+			if (!parameter) fail(`Path template parameter ${name} is not declared`, `${at}/parameters`, id);
+			if (!parameter || parameter.required !== true) fail(`Path parameter ${name} must be required`, `${at}/parameters`, id);
+		}
+		for (const name of declaredPathParameters) if (!templateParameters.has(name)) fail(`Path parameter ${name} is not present in the path template`, `${at}/parameters`, id);
 		const prefix = pascal(id);
 		const renderParameters = (location) => {
 			const list = byLocation[location].sort((a, b) => a.name.localeCompare(b.name));
 			if (!list.length) return void 0;
 			const name = `${prefix}${pascal(location)}`;
-			operationTypes.push(`export type ${name} = {\n${list.map((p) => `  ${JSON.stringify(p.name)}${p.required || location === "path" ? "" : "?"}: ${schemaType(p.schema ?? {}, `${at}/parameters`, "request")};`).join("\n")}\n};`);
+			apiOperationReferences.add(name);
+			operationTypes.push(`export type ${name} = {\n${list.map((p) => `  ${JSON.stringify(p.name)}${p.required || location === "path" ? "" : "?"}: ${schemaType(p.schema ?? {}, `${at}/parameters`, "request", operationSchemaReferences)};`).join("\n")}\n};`);
 			const defaultStyle = location === "query" ? "form" : "simple";
 			return {
 				name,
@@ -259,7 +293,7 @@ function generateFiles(document) {
 			};
 		};
 		const params = renderParameters("path"), query = renderParameters("query"), headers = renderParameters("header");
-		const body = operation.requestBody ? pickContent(operation.requestBody.content, `${at}/requestBody`, "request") : void 0;
+		const body = operation.requestBody ? pickContent(operation.requestBody.content, `${at}/requestBody`, "request", contentSchemaReferences) : void 0;
 		if (body) operationTypes.push(`export type ${prefix}Body = ${body.type};`);
 		const successes = responseSchema(operation, at, true);
 		if (!successes.length) fail("At least one 2xx response is required", `${at}/responses`, id);
@@ -271,7 +305,7 @@ function generateFiles(document) {
 		if (body) chain.push(`body(${body.codec})`);
 		for (const [status, response] of successes) {
 			if (response.links) fail("Response links are unsupported", `${at}/responses/${status}/links`, id);
-			const value = pickContent(response.content, `${at}/responses/${status}`, "response");
+			const value = pickContent(response.content, `${at}/responses/${status}`, "response", contentSchemaReferences);
 			const typeName = `${prefix}Response${status}`;
 			operationTypes.push(`export type ${typeName} = ${value.type};`);
 			chain.push(`returns(${status === "200" ? "" : `${status}, `}${value.codec})`);
@@ -279,7 +313,7 @@ function generateFiles(document) {
 		if (errors.length) {
 			const rendered = errors.map(([status, response]) => {
 				if (response.links) fail("Response links are unsupported", `${at}/responses/${status}/links`, id);
-				const value = pickContent(response.content, `${at}/responses/${status}`, "response");
+				const value = pickContent(response.content, `${at}/responses/${status}`, "response", contentSchemaReferences);
 				const typeName = `${prefix}Error${pascal(status)}`;
 				operationTypes.push(`export type ${typeName} = ${value.type};`);
 				return `${JSON.stringify(status)}: ${value.codec}`;
@@ -292,12 +326,12 @@ function generateFiles(document) {
 	const imports = [...new Set(descriptors.join(" ").match(/\b(get|post|put|patch|del|head|options|json|text|urlEncoded|multipart|arrayBuffer|empty|content)\b/g) ?? [])].sort();
 	const files = {
 		"schemas.ts": `${schemaLines.join("\n\n")}\n`,
-		"operations.ts": `${names.size ? `import type { ${[...names.keys()].join(", ")} } from "./schemas";\n\n` : ""}${operationTypes.join("\n\n")}\n`,
+		"operations.ts": `${operationSchemaReferences.size ? `import type { ${[...operationSchemaReferences].sort().join(", ")} } from "./schemas";\n\n` : ""}${operationTypes.join("\n\n")}\n`,
 		"api.ts": `import { ${[
 			"defineApi",
 			"createClient",
 			...imports
-		].join(", ")} } from "@askrjs/fetch";\nimport type { ClientOptions } from "@askrjs/fetch";\nimport type { ${operationTypes.map((line) => line.match(/^export type (\w+)/)?.[1]).filter(Boolean).join(", ")} } from "./operations";\n\nexport const api = defineApi({\n${descriptors.join("\n")}\n}, ${JSON.stringify({
+		].join(", ")} } from "@askrjs/fetch";\nimport type { ClientOptions } from "@askrjs/fetch";\n${apiSchemaReferences.size ? `import type { ${[...apiSchemaReferences].sort().join(", ")} } from "./schemas";\n` : ""}${apiOperationReferences.size ? `import type { ${[...apiOperationReferences].sort().join(", ")} } from "./operations";\n` : ""}\nexport const api = defineApi({\n${descriptors.join("\n")}\n}, ${JSON.stringify({
 			servers: (document.servers ?? []).map((s) => s.url),
 			securitySchemes: document.components?.securitySchemes ?? {}
 		}, null, 2)});\n\nexport const createApiClient = (options?: ClientOptions) => createClient(api, options);\n`,
@@ -319,6 +353,8 @@ async function existingFiles(directory) {
 }
 async function writeGenerated(directory, files, check) {
 	const output = resolve(directory);
+	const outputStat = await stat(output).catch(() => null);
+	if (outputStat && !outputStat.isDirectory()) throw new GenerationError(`Generated output must be a directory: ${output}`);
 	const entries = await existingFiles(output);
 	if (check) {
 		if (!entries.length) throw new GenerationError(`Generated directory is missing: ${output}`);
@@ -357,6 +393,11 @@ async function writeGenerated(directory, files, check) {
 	}
 }
 async function generate(input, output, check = false) {
+	if (!/^https?:\/\//.test(input)) {
+		const resolvedInput = resolve(input);
+		const inputWithinOutput = relative(resolve(output), resolvedInput);
+		if (!inputWithinOutput.startsWith("..") && !isAbsolute(inputWithinOutput)) throw new GenerationError("Generated output must not contain its OpenAPI input document");
+	}
 	const files = generateFiles(await loadOpenApi(input));
 	await mkdir(dirname(resolve(output)), { recursive: true });
 	await writeGenerated(output, files, check);
@@ -364,33 +405,67 @@ async function generate(input, output, check = false) {
 //#endregion
 //#region src/bin/generate.ts
 async function runGenerateCli(args, io = console) {
+	const wantsJson = args.includes("--json");
 	let output;
 	let check = false;
+	let json = false;
+	let help = false;
 	const inputs = [];
 	for (let i = 0; i < args.length; i++) {
 		const arg = args[i];
 		if (arg === "--check") check = true;
-		else if (arg === "-o" || arg === "--output") output = args[++i];
-		else if (arg.startsWith("--output=")) output = arg.slice(9);
+		else if (arg === "--json") json = true;
+		else if (arg === "--help" || arg === "-h") help = true;
+		else if (arg === "-o" || arg === "--output") {
+			const value = args[i + 1];
+			if (!value || value.startsWith("-")) {
+				const message = `${arg} requires a path`;
+				io.error(wantsJson ? JSON.stringify({
+					status: "error",
+					error: message
+				}) : message);
+				return 1;
+			}
+			output = value;
+			i += 1;
+		} else if (arg.startsWith("--output=")) output = arg.slice(9);
 		else if (arg.startsWith("-")) {
-			io.error(`Unknown option: ${arg}`);
+			const message = `Unknown option: ${arg}`;
+			io.error(wantsJson ? JSON.stringify({
+				status: "error",
+				error: message
+			}) : message);
 			return 1;
 		} else inputs.push(arg);
 	}
+	const usage = "Usage: askr generate <input> -o <output-directory> [--check] [--json]";
+	if (help) {
+		io.log(usage);
+		return 0;
+	}
 	if (inputs.length !== 1 || !output) {
-		io.error("Usage: askr generate <input> -o <output-directory> [--check]");
+		io.error(json ? JSON.stringify({
+			status: "error",
+			error: usage
+		}) : usage);
 		return 1;
 	}
 	try {
 		await generate(inputs[0], output, check);
-		io.log(check ? "Generated client is current." : `Generated client in ${output}.`);
+		io.log(json ? JSON.stringify({
+			status: "ok",
+			action: check ? "checked" : "generated",
+			output
+		}) : check ? "Generated client is current." : `Generated client in ${output}.`);
 		return 0;
 	} catch (error) {
-		io.error(error instanceof Error ? error.message : String(error));
+		const message = error instanceof Error ? error.message : String(error);
+		io.error(json ? JSON.stringify({
+			status: "error",
+			error: message
+		}) : message);
 		return 1;
 	}
 }
 //#endregion
 export { runGenerateCli };
-
-//# sourceMappingURL=generate.js.map

package/dist/is-direct-execution-Cdlr-ZUl.js

@@ -16,5 +16,3 @@ function isDirectExecution(moduleUrl, argvPath = process.argv[1]) {
 }
 //#endregion
 export { isDirectExecution as t };
-
-//# sourceMappingURL=is-direct-execution-Cdlr-ZUl.js.map

package/dist/openapi.d.ts

@@ -0,0 +1,25 @@
+//#region src/bin/openapi.d.ts
+type CliIo = Pick<Console, "error" | "log">;
+interface ParsedArgs {
+  entry: string;
+  output: string;
+  check: boolean;
+  help: boolean;
+  json: boolean;
+}
+interface OpenApiDeps {
+  cwd(): string;
+  importModule(filePath: string): Promise<unknown>;
+  readFile(filePath: string): Promise<string>;
+  mkdir(directory: string): Promise<void>;
+  writeFile(filePath: string, contents: string): Promise<void>;
+  rename(from: string, to: string): Promise<void>;
+  rm(filePath: string): Promise<void>;
+  temporarySuffix(): string;
+}
+declare function parseOpenApiArgs(args: readonly string[]): ParsedArgs;
+declare function serializeOpenApi(document: unknown): string;
+declare function validateOpenApiDocument(document: unknown): asserts document is Record<string, unknown>;
+declare function runOpenApiCli(args?: string[], io?: CliIo, overrides?: Partial<OpenApiDeps>): Promise<number>;
+//#endregion
+export { parseOpenApiArgs, runOpenApiCli, serializeOpenApi, validateOpenApiDocument };

package/dist/openapi.js

@@ -15,6 +15,7 @@ Options:
   --entry <path>   TypeScript API module (default: ./src/api.ts)
   --output <path>  YAML artifact (default: ./openapi.yml)
   --check          Fail when the artifact is missing or byte-stale; never write
+  --json           Print machine-readable command results
   --help, -h       Show help
 `;
 const defaultDeps = {
@@ -32,17 +33,19 @@ function parseOpenApiArgs(args) {
 		entry: "./src/api.ts",
 		output: "./openapi.yml",
 		check: false,
-		help: false
+		help: false,
+		json: false
 	};
 	for (let index = 0; index < args.length; index += 1) {
 		const value = args[index];
 		if (value === "--entry" || value === "--output") {
 			const next = args[index + 1];
-			if (!next) throw new Error(`${value} requires a path`);
+			if (!next || next.startsWith("-")) throw new Error(`${value} requires a path`);
 			if (value === "--entry") parsed.entry = next;
 			else parsed.output = next;
 			index += 1;
 		} else if (value === "--check") parsed.check = true;
+		else if (value === "--json") parsed.json = true;
 		else if (value === "--help" || value === "-h") parsed.help = true;
 		else throw new Error(`Unknown option: ${value}`);
 	}
@@ -62,9 +65,18 @@ function serializeOpenApi(document) {
 		noRefs: true
 	}).replace(/\n+$/, "")}\n`;
 }
-async function generate(entry, deps) {
-	const document = exporterFrom(await deps.importModule(entry)).toOpenApiDocument();
+function validateOpenApiDocument(document) {
 	if (!document || typeof document !== "object" || Array.isArray(document)) throw new Error("toOpenApiDocument() must return an OpenAPI document object");
+	const candidate = document;
+	if (typeof candidate.openapi !== "string" || !/^3\.(?:0|1)\.\d+(?:[-+].+)?$/.test(candidate.openapi)) throw new Error("OpenAPI document must declare a supported openapi 3.0.x or 3.1.x version");
+	if (!candidate.info || typeof candidate.info !== "object" || Array.isArray(candidate.info)) throw new Error("OpenAPI document must contain an info object");
+	const info = candidate.info;
+	if (typeof info.title !== "string" || !info.title.trim() || typeof info.version !== "string" || !info.version.trim()) throw new Error("OpenAPI info must contain non-empty title and version strings");
+	if (!candidate.paths || typeof candidate.paths !== "object" || Array.isArray(candidate.paths)) throw new Error("OpenAPI document must contain a paths object");
+}
+async function generate(entry, deps) {
+	const document = await exporterFrom(await deps.importModule(entry)).toOpenApiDocument();
+	validateOpenApiDocument(document);
 	return serializeOpenApi(document);
 }
 async function atomicWrite(output, contents, deps) {
@@ -83,6 +95,7 @@ async function runOpenApiCli(args = process.argv.slice(2), io = console, overrid
 		...defaultDeps,
 		...overrides
 	};
+	const wantsJson = args.includes("--json");
 	try {
 		const parsed = parseOpenApiArgs(args);
 		if (parsed.help) {
@@ -91,6 +104,7 @@ async function runOpenApiCli(args = process.argv.slice(2), io = console, overrid
 		}
 		const entry = path.resolve(deps.cwd(), parsed.entry);
 		const output = path.resolve(deps.cwd(), parsed.output);
+		if (entry === output) throw new Error("OpenAPI output must not overwrite its source entry");
 		const expected = await generate(entry, deps);
 		if (parsed.check) {
 			let actual;
@@ -98,23 +112,43 @@ async function runOpenApiCli(args = process.argv.slice(2), io = console, overrid
 				actual = await deps.readFile(output);
 			} catch (error) {
 				if (error.code === "ENOENT") {
-					io.error(`OpenAPI artifact is missing: ${output}`);
+					io.error(parsed.json ? JSON.stringify({
+						status: "error",
+						reason: "missing",
+						output
+					}) : `OpenAPI artifact is missing: ${output}`);
 					return 1;
 				}
 				throw error;
 			}
 			if (actual !== expected) {
-				io.error(`OpenAPI artifact is stale: ${output}`);
+				io.error(parsed.json ? JSON.stringify({
+					status: "error",
+					reason: "stale",
+					output
+				}) : `OpenAPI artifact is stale: ${output}`);
 				return 1;
 			}
-			io.log(`OpenAPI artifact is current: ${output}`);
+			io.log(parsed.json ? JSON.stringify({
+				status: "ok",
+				action: "checked",
+				output
+			}) : `OpenAPI artifact is current: ${output}`);
 			return 0;
 		}
 		await atomicWrite(output, expected, deps);
-		io.log(`Generated OpenAPI artifact: ${output}`);
+		io.log(parsed.json ? JSON.stringify({
+			status: "ok",
+			action: "generated",
+			output
+		}) : `Generated OpenAPI artifact: ${output}`);
 		return 0;
 	} catch (error) {
-		io.error(error instanceof Error ? error.message : String(error));
+		const message = error instanceof Error ? error.message : String(error);
+		io.error(wantsJson ? JSON.stringify({
+			status: "error",
+			error: message
+		}) : message);
 		return 1;
 	}
 }
@@ -123,6 +157,4 @@ async function main() {
 }
 if (isDirectExecution(import.meta.url)) main();
 //#endregion
-export { parseOpenApiArgs, runOpenApiCli, serializeOpenApi };
-
-//# sourceMappingURL=openapi.js.map
+export { parseOpenApiArgs, runOpenApiCli, serializeOpenApi, validateOpenApiDocument };

package/dist/planner-VAj7qlxr.js

@@ -283,5 +283,3 @@ function planUpdates(options) {
 }
 //#endregion
 export { planUpdates };
-
-//# sourceMappingURL=planner-VAj7qlxr.js.map

package/dist/range-YUs9eimn.js

@@ -123,5 +123,3 @@ function rewriteRange(shape, target, forcedBreaking) {
 }
 //#endregion
 export { isBreakingChange as n, rewriteRange as r, analyzeRange as t };
-
-//# sourceMappingURL=range-YUs9eimn.js.map

package/dist/registry-CyrRHRG5.js

@@ -207,5 +207,3 @@ async function fetchPackuments(packageNames, configuration, options = {}) {
 }
 //#endregion
 export { fetchPackuments, loadNpmConfiguration };
-
-//# sourceMappingURL=registry-CyrRHRG5.js.map

package/dist/skills/askr-ssr-ssg/SKILL.md

@@ -28,7 +28,8 @@ Use this when the app renders outside the browser or produces static output. The
 2. Register routes at module load before boot or render.
 3. Keep render paths deterministic and environment-safe.
 4. Use route `entries` or the template's static config for parameterized SSG paths.
-5. Build and preview after changes that cross the render boundary.
+5. Set the canonical `siteUrl` and explicitly exclude non-indexable routes in `sitemap.routes`.
+6. Build and preview after changes that cross the render boundary.
 
 ## Copy This Shape
 
@@ -61,6 +62,7 @@ npx @askrjs/cli ssg --config ./ssg.config.ts --output ./dist/static
 - SSR or SSG build output is deterministic for the same inputs.
 - Hydration has no structural mismatch warnings.
 - Generated static routes cover expected params.
+- `sitemap.xml` contains every intended canonical route and excludes runtime-only or non-indexable routes.
 - Browser preview still navigates correctly after hydration.
 
 ## Done When