@evertondgn/solid-tooling 0.5.0 → 0.6.0

package/dist/publication-CRUTOB0B.mjs

@@ -0,0 +1,885 @@
+import { a as LLMS_PATH, d as PUBLICATION_PHASE_ENV, f as PUBLICATION_PRERENDER_PHASE, g as SITEMAP_MANIFEST_MAX_BYTES, h as SITEMAP_MANIFEST_FILE, i as LLMS_MAX_BYTES, m as SITEMAP_IDENTITIES_MAX_BYTES, n as LLMS_FULL_MAX_BYTES, o as MARKDOWN_PRERENDER_PATH, p as SITEMAP_IDENTITIES_FILE, r as LLMS_FULL_PATH, t as LLMS_DESCRIBEDBY_LINK, u as PUBLICATION_ARTIFACT_DIR } from "./protocol-DSNNUYja.mjs";
+import { t as readLlmsIndex } from "./readLlmsIndex-Gj4iTxAk.mjs";
+import path from "node:path";
+import { env } from "node:process";
+import { lstat, mkdir, mkdtemp, open, readFile, readdir, realpath, rename, rm, writeFile } from "node:fs/promises";
+import { constants } from "node:fs";
+import * as v from "valibot";
+import { createHash, randomUUID } from "node:crypto";
+// src/publication/assertDisabledArtifacts/index.ts
+async function assertDisabledArtifacts({ publicDir, hasLlms, hasLlmsFull }) {
+	const forbidden = [...hasLlms ? [] : [LLMS_PATH], ...hasLlmsFull ? [] : [LLMS_FULL_PATH]];
+	for (const name of forbidden) {
+		try {
+			await lstat(path.join(publicDir, name));
+		} catch (error) {
+			if (error instanceof Error && "code" in error && error.code === "ENOENT") continue;
+			throw error;
+		}
+		throw new Error(`Disabled publication artifact exists: ${name}`);
+	}
+}
+// src/publication/publicationArtifacts/constants.ts
+const SITEMAP_INVENTORY_PATH = "/sitemaps/static.json";
+// src/publication/markdownPrerender/helpers/artifactDigest/index.ts
+const CHUNK_BYTES$1 = 65536;
+const HASH = "sha256";
+const READ_FLAGS$1 = constants.O_RDONLY | constants.O_NOFOLLOW;
+function readRouteBytes(route) {
+	if (route.data) return new Uint8Array(route.data);
+	return new TextEncoder().encode(route.contents ?? "");
+}
+function digestBytes(bytes) {
+	return {
+		size: bytes.byteLength,
+		hash: createHash(HASH).update(bytes).digest("hex")
+	};
+}
+async function digestFile(file) {
+	const handle = await open(file, READ_FLAGS$1);
+	try {
+		const hash = createHash(HASH);
+		const buffer = new Uint8Array(CHUNK_BYTES$1);
+		let size = 0;
+		let read = await handle.read(buffer, 0, CHUNK_BYTES$1, null);
+		while (read.bytesRead > 0) {
+			size += read.bytesRead;
+			hash.update(buffer.subarray(0, read.bytesRead));
+			read = await handle.read(buffer, 0, CHUNK_BYTES$1, null);
+		}
+		return {
+			size,
+			hash: hash.digest("hex")
+		};
+	} finally {
+		await handle.close();
+	}
+}
+// src/publication/publicationArtifacts/helpers/assertPublishedArtifacts/index.ts
+const SITEMAP_DIR = "sitemaps";
+const SITEMAP_ROOT$1 = "/sitemap.xml";
+function isMissing$1(error) {
+	return error instanceof Error && "code" in error && error.code === "ENOENT";
+}
+async function scanSitemapFiles(publicDir) {
+	const scan = {
+		files: [],
+		irregular: []
+	};
+	try {
+		const entries = await readdir(path.join(publicDir, SITEMAP_DIR), {
+			recursive: true,
+			withFileTypes: true
+		});
+		for (const entry of entries) {
+			const path$4 = `/${path.relative(publicDir, path.join(entry.parentPath, entry.name)).split(path.sep).join("/")}`;
+			if (entry.isDirectory()) continue;
+			(entry.isFile() ? scan.files : scan.irregular).push(path$4);
+		}
+	} catch (error) {
+		if (!isMissing$1(error)) throw error;
+	}
+	try {
+		((await lstat(path.join(publicDir, SITEMAP_ROOT$1))).isFile() ? scan.files : scan.irregular).push(SITEMAP_ROOT$1);
+	} catch (error) {
+		if (!isMissing$1(error)) throw error;
+	}
+	return scan;
+}
+async function findChangedFiles$1({ publicDir, approved }) {
+	const problems = [];
+	for (const [path$5, digest] of approved) try {
+		const actual = await digestFile(path.join(publicDir, path$5));
+		if (actual.size !== digest.size || actual.hash !== digest.hash) problems.push(`${path$5} (content differs from the approved artifact)`);
+	} catch (error) {
+		if (!isMissing$1(error)) throw error;
+		problems.push(`${path$5} (missing from the static output)`);
+	}
+	return problems;
+}
+async function assertPublishedArtifacts({ publicDir, prerenderedRoutes, xmlPaths, approved }) {
+	const written = new Map(prerenderedRoutes.map((route) => [route.route, route]));
+	const { files, irregular } = await scanSitemapFiles(publicDir);
+	const found = new Set(files);
+	const problems = [
+		...irregular.map((path) => `${path} (not a regular file)`),
+		...files.filter((path) => !xmlPaths.has(path)).map((path) => `${path} (would shadow a dynamic sitemap route)`),
+		...[...xmlPaths].filter((path) => !found.has(path) || written.get(path)?.fileName !== path).map((path) => `${path} (not generated by the prerender)`),
+		...await findChangedFiles$1({
+			publicDir,
+			approved
+		})
+	];
+	if (problems.length > 0) throw new Error(`Invalid publication output: ${problems.join(", ")}`);
+}
+// src/publication/publicationArtifacts/helpers/writeServerArtifacts/index.ts
+const encoder$2 = new TextEncoder();
+function buildManifest({ inventory, identities, partDigests }) {
+	const { buildId, siteUrl, byteBudget, hasArraySources, hasPartitionSources } = inventory;
+	const identityDigest = identities && digestBytes(identities);
+	const generation = createHash("sha256").update(JSON.stringify({
+		version: 1,
+		buildId,
+		siteUrl,
+		byteBudget,
+		hasArraySources,
+		hasPartitionSources,
+		parts: partDigests.map(({ hash }) => hash),
+		identities: identityDigest?.hash
+	})).digest("hex");
+	return JSON.stringify({
+		version: 1,
+		buildId,
+		generation,
+		siteUrl,
+		byteBudget,
+		pagePartCount: partDigests.length,
+		partBytes: partDigests.map(({ size }) => size),
+		isRootStatic: !hasArraySources && !hasPartitionSources && partDigests.length > 0,
+		hasArraySources,
+		hasPartitionSources,
+		identities: identityDigest ? {
+			file: SITEMAP_IDENTITIES_FILE,
+			bytes: identityDigest.size,
+			sha256: identityDigest.hash
+		} : null
+	});
+}
+async function publishFile({ directory, name, bytes }) {
+	const workDir = await mkdtemp(path.join(directory, ".artifact-"));
+	try {
+		const temporary = path.join(workDir, name);
+		await writeFile(temporary, bytes, { flag: "wx" });
+		await rename(temporary, path.join(directory, name));
+	} finally {
+		await rm(workDir, {
+			recursive: true,
+			force: true
+		});
+	}
+	const expected = digestBytes(bytes);
+	const actual = await digestFile(path.join(directory, name));
+	if (actual.size !== expected.size || actual.hash !== expected.hash) throw new Error(`Server artifact differs after writing: ${name}`);
+}
+async function writeServerArtifacts({ serverDir, ...options }) {
+	const manifest = encoder$2.encode(buildManifest(options));
+	if (manifest.byteLength > 1048576) throw new Error(`Sitemap manifest has ${manifest.byteLength} bytes, above the ${SITEMAP_MANIFEST_MAX_BYTES} byte budget`);
+	const directory = path.join(serverDir, PUBLICATION_ARTIFACT_DIR);
+	await mkdir(directory, { recursive: true });
+	const { identities } = options;
+	if (identities) await publishFile({
+		directory,
+		name: SITEMAP_IDENTITIES_FILE,
+		bytes: identities
+	});
+	await publishFile({
+		directory,
+		name: SITEMAP_MANIFEST_FILE,
+		bytes: manifest
+	});
+}
+// src/publication/publicationArtifacts/index.ts
+const SITEMAP_ROOT = "/sitemap.xml";
+const XML_TYPE = "application/xml";
+const XML_START = "<?xml";
+const encoder$1 = new TextEncoder();
+const CountSchema = v.pipe(v.number(), v.integer(), v.minValue(0));
+const EntrySchema = v.object({
+	path: v.string(),
+	lastmod: v.optional(v.string())
+});
+const IdentityListSchema = v.object({
+	urls: v.array(v.string()),
+	entries: v.array(EntrySchema)
+});
+const InventorySchema = v.object({
+	version: v.literal(1),
+	buildId: v.pipe(v.string(), v.nonEmpty()),
+	siteUrl: v.pipe(v.string(), v.url()),
+	byteBudget: v.pipe(CountSchema, v.minValue(1)),
+	pagePartCount: CountSchema,
+	hasArraySources: v.boolean(),
+	hasPartitionSources: v.boolean(),
+	identities: v.nullable(IdentityListSchema)
+});
+function partPath(index) {
+	return `/sitemaps/pages/${index}.xml`;
+}
+function readInventory$1(contents) {
+	try {
+		const inventory = v.parse(InventorySchema, JSON.parse(contents ?? ""));
+		return inventory.hasArraySources === (inventory.identities !== null) ? inventory : void 0;
+	} catch {
+		return;
+	}
+}
+function findXmlProblem({ route, byteBudget }) {
+	const bytes = readRouteBytes(route);
+	if (route.fileName !== route.route) return `written as ${route.fileName}`;
+	if (!route.contentType?.startsWith(XML_TYPE)) return `content type ${route.contentType}`;
+	if (bytes.byteLength > byteBudget) return `${bytes.byteLength} bytes, above the ${byteBudget} byte budget`;
+	return route.contents?.startsWith(XML_START) ? void 0 : "not an XML document";
+}
+function publicationArtifacts({ buildId, hasSitemap = true }) {
+	const approved = /* @__PURE__ */ new Map();
+	const xmlPaths = /* @__PURE__ */ new Set();
+	let inventory;
+	let identities;
+	let isVerified = false;
+	function readSitemapInventory({ route, queue }) {
+		route.skip = true;
+		if (route.error) return;
+		inventory = readInventory$1(route.contents);
+		if (!queue || !inventory) {
+			route.error = /* @__PURE__ */ new Error("Invalid sitemap inventory");
+			return;
+		}
+		if (inventory.buildId !== buildId) {
+			route.error = /* @__PURE__ */ new Error("Sitemap inventory belongs to another build");
+			return;
+		}
+		if (inventory.identities) {
+			identities = encoder$1.encode(JSON.stringify(inventory.identities));
+			if (identities.byteLength > 33554432) {
+				route.error = /* @__PURE__ */ new Error(`Sitemap identities have ${identities.byteLength} bytes, above the ${SITEMAP_IDENTITIES_MAX_BYTES} byte budget`);
+				return;
+			}
+		}
+		const { pagePartCount, hasArraySources, hasPartitionSources } = inventory;
+		for (let index = 1; index <= pagePartCount; index += 1) xmlPaths.add(partPath(index));
+		if (pagePartCount > 0 && !hasArraySources && !hasPartitionSources) xmlPaths.add(SITEMAP_ROOT);
+		for (const path of xmlPaths) queue.add(path);
+	}
+	function approveXml(options) {
+		const { route } = options;
+		if (route.error) return;
+		const problem = findXmlProblem(options);
+		if (problem) {
+			route.error = /* @__PURE__ */ new Error(`Invalid sitemap ${route.route}: ${problem}`);
+			return;
+		}
+		approved.set(route.route, digestBytes(readRouteBytes(route)));
+	}
+	return {
+		inspect(options) {
+			const { route } = options;
+			if (hasSitemap && route.route === "/sitemaps/static.json") {
+				readSitemapInventory(options);
+				return true;
+			}
+			if (!inventory || !xmlPaths.has(route.route)) return false;
+			approveXml({
+				route,
+				byteBudget: inventory.byteBudget
+			});
+			return true;
+		},
+		approve({ route, maxBytes }) {
+			const digest = digestBytes(readRouteBytes(route));
+			if (maxBytes !== void 0 && digest.size > maxBytes) {
+				route.error = /* @__PURE__ */ new Error(`${route.route} has ${digest.size} bytes, above the ${maxBytes} byte budget`);
+				return;
+			}
+			approved.set(route.route, digest);
+		},
+		async assertPublished(options) {
+			if (hasSitemap && !inventory) throw new Error("Sitemap inventory was not prerendered");
+			await assertPublishedArtifacts({
+				...options,
+				xmlPaths,
+				approved
+			});
+			isVerified = true;
+		},
+		async writeServer(serverDir) {
+			if (!inventory || !isVerified) return;
+			const partDigests = Array.from({ length: inventory.pagePartCount }, (_, index) => {
+				const digest = approved.get(partPath(index + 1));
+				if (!digest) throw new Error(`Unverified sitemap part ${index + 1}`);
+				return digest;
+			});
+			await writeServerArtifacts({
+				serverDir,
+				inventory,
+				identities,
+				partDigests
+			});
+		}
+	};
+}
+// src/publication/markdownPrerender/helpers/findMarkdownFiles/index.ts
+const MARKDOWN_EXTENSION = ".md";
+const HTML_ALIAS_EXTENSION = ".md.html";
+async function findMarkdownFiles(publicDir) {
+	const result = {
+		files: [],
+		htmlAliases: [],
+		irregular: []
+	};
+	const entries = await readdir(publicDir, {
+		recursive: true,
+		withFileTypes: true
+	});
+	for (const entry of entries) {
+		const isAlias = entry.name.endsWith(HTML_ALIAS_EXTENSION);
+		if (!isAlias && !entry.name.endsWith(MARKDOWN_EXTENSION)) continue;
+		const path$3 = `/${path.relative(publicDir, path.join(entry.parentPath, entry.name)).split(path.sep).join("/")}`;
+		if (isAlias) {
+			result.htmlAliases.push(path$3);
+			continue;
+		}
+		if (entry.isFile() && !entry.isSymbolicLink()) result.files.push(path$3);
+		else result.irregular.push(path$3);
+	}
+	return result;
+}
+// src/publication/markdownPrerender/helpers/assertStaticOutput/index.ts
+async function findChangedFiles({ publicDir, expected, approved }) {
+	const problems = [];
+	for (const path$2 of expected.keys()) {
+		const digest = approved.get(path$2);
+		if (!digest) {
+			problems.push(`${path$2} (not validated by the prerender)`);
+			continue;
+		}
+		const actual = await digestFile(path.join(publicDir, path$2));
+		if (actual.size !== digest.size || actual.hash !== digest.hash) problems.push(`${path$2} (content differs from the approved artifact)`);
+	}
+	return problems;
+}
+async function assertStaticOutput(options) {
+	const { publicDir, expected } = options;
+	const { files, htmlAliases, irregular } = await findMarkdownFiles(publicDir);
+	const found = new Set(files);
+	const problems = [
+		...htmlAliases.map((path) => `${path} (HTML written for a .md URL)`),
+		...irregular.map((path) => `${path} (not a regular file)`),
+		...files.filter((path) => !expected.has(path)).map((path) => `${path} (not in the static Markdown list)`),
+		...[...expected.keys()].filter((path) => !found.has(path)).map((path) => `${path} (missing from the static output)`)
+	];
+	if (problems.length === 0) problems.push(...await findChangedFiles(options));
+	if (problems.length > 0) throw new Error(`Invalid static Markdown output: ${problems.join(", ")}`);
+}
+// src/publication/markdownPrerender/helpers/inspectMarkdownArtifact/index.ts
+const HTML_DOCUMENT_START = /^\s*(?:<!doctype\s+html\b|<html[\s>])/iu;
+const HTML_DOCUMENT_END = /<\/html>\s*$/iu;
+const MARKDOWN_TYPE = "text/markdown";
+const UTF8_CHARSET = "charset=utf-8";
+function isMarkdownUtf8(contentType) {
+	const [type, ...parameters] = (contentType ?? "").split(";").map((part) => part.trim().toLowerCase().replaceAll("\"", ""));
+	return type === MARKDOWN_TYPE && parameters.includes(UTF8_CHARSET);
+}
+function inspectMarkdownArtifact(route) {
+	if (route.fileName !== route.route) return `written as ${route.fileName ?? "no file"}`;
+	if (!route.contentType) return "served as no content type";
+	if (!isMarkdownUtf8(route.contentType)) return `served as ${route.contentType}`;
+	let text;
+	try {
+		text = new TextDecoder("utf-8", { fatal: true }).decode(readRouteBytes(route));
+	} catch {
+		return "invalid UTF-8 body";
+	}
+	if (!text.trim()) return "empty body";
+	if (HTML_DOCUMENT_START.test(text) && HTML_DOCUMENT_END.test(text)) return "HTML document body";
+}
+// src/publication/markdownPrerender/helpers/selectLlmsFullDocuments/index.ts
+function classify({ href, origin, inventory, baseLocalePaths, ownPaths }) {
+	let url;
+	let path;
+	try {
+		url = new URL(href);
+		path = decodeURI(url.pathname);
+	} catch {
+		return { reason: "invalid URL" };
+	}
+	if (url.origin !== origin) return { reason: "external link" };
+	if (ownPaths.has(path)) return void 0;
+	if (url.search) return { reason: "URL with query, served on request" };
+	if (!path.endsWith(".md")) return { reason: "HTML page without Markdown" };
+	if (!inventory.has(path)) return { reason: "Markdown generated on request" };
+	if (!baseLocalePaths.has(path)) return { reason: "page in another language" };
+	url.hash = "";
+	return { document: {
+		url: url.href,
+		path
+	} };
+}
+function selectLlmsFullDocuments({ links, siteUrl, inventory, baseLocalePaths, ownPaths }) {
+	const { origin } = new URL(siteUrl);
+	const documents = /* @__PURE__ */ new Map();
+	const omitted = /* @__PURE__ */ new Map();
+	for (const { href } of links) {
+		const result = classify({
+			href,
+			origin,
+			inventory,
+			baseLocalePaths,
+			ownPaths
+		});
+		if (!result) continue;
+		if ("document" in result) {
+			const { document } = result;
+			if (!documents.has(document.path)) documents.set(document.path, document);
+			continue;
+		}
+		if (!omitted.has(href)) omitted.set(href, {
+			url: href,
+			reason: result.reason
+		});
+	}
+	return {
+		documents: [...documents.values()],
+		omitted: [...omitted.values()]
+	};
+}
+// src/publication/markdownPrerender/helpers/writeAll/index.ts
+async function writeAll({ output, bytes, signal }) {
+	let offset = 0;
+	while (offset < bytes.byteLength) {
+		signal?.throwIfAborted();
+		const { bytesWritten } = await output.write(bytes.subarray(offset));
+		if (bytesWritten <= 0) throw new Error("File write made no progress");
+		offset += bytesWritten;
+	}
+}
+// src/publication/markdownPrerender/helpers/writeLlmsFull/index.ts
+const CHUNK_BYTES = 65536;
+const FILE_NAME = LLMS_FULL_PATH.slice(1);
+const READ_FLAGS = constants.O_RDONLY | constants.O_NOFOLLOW;
+const encoder = new TextEncoder();
+const SEPARATOR = encoder.encode("\n");
+function isMissing(error) {
+	return error instanceof Error && "code" in error && error.code === "ENOENT";
+}
+async function exists(file) {
+	try {
+		await lstat(file);
+		return true;
+	} catch (error) {
+		if (isMissing(error)) return false;
+		throw error;
+	}
+}
+async function resolveArtifact({ root, path: path$1 }) {
+	const segments = path$1.slice(1).split("/");
+	if (!path$1.startsWith("/") || path$1.includes("\0") || segments.some((segment) => segment === "" || segment === "." || segment === ".." || segment.includes("\\"))) throw new Error(`Static Markdown path escapes the output: ${path$1}`);
+	const file = path.join(root, ...segments);
+	let real;
+	try {
+		real = await realpath(file);
+	} catch (error) {
+		if (isMissing(error)) throw new Error(`Static Markdown missing: ${path$1}`, { cause: error });
+		throw error;
+	}
+	const stats = await lstat(file);
+	if (real !== file || !stats.isFile()) throw new Error(`Static Markdown is not a regular file: ${path$1}`);
+	return {
+		file,
+		size: stats.size
+	};
+}
+function formatHeader({ index, baseLocale, documents, omitted }) {
+	const noun = documents.length === 1 ? "page" : "pages";
+	const lines = [`# ${index.title}`, ""];
+	if (index.description) lines.push(`> ${index.description}`, "");
+	lines.push(`Complete Markdown of ${documents.length} static ${noun} linked from ${index.url}, in the base language (${baseLocale}) and in index order. Each document starts with a Source line, the URL of its Markdown file, and a Bytes line with the exact UTF-8 length of the body that follows.`, "", "## Documents", "", ...documents.map(({ url }) => `- ${url}`), "");
+	if (omitted.length > 0) lines.push("## Not included", "", "Linked from the index, but outside this file:", "", ...omitted.map(({ url, reason }) => `- ${url}: ${reason}`), "");
+	return lines.join("\n");
+}
+function formatSource({ url, size }) {
+	return `\nSource: ${url}\nBytes: ${size}\n\n`;
+}
+async function copyArtifact({ artifact, output, signal }) {
+	const changed = /* @__PURE__ */ new Error(`Static Markdown changed while reading: ${artifact.path}`);
+	const source = await open(artifact.file, READ_FLAGS);
+	try {
+		const stats = await source.stat();
+		if (!stats.isFile() || stats.size !== artifact.size) throw changed;
+		const decoder = new TextDecoder("utf-8", { fatal: true });
+		const buffer = new Uint8Array(CHUNK_BYTES);
+		let total = 0;
+		let read = await source.read(buffer, 0, CHUNK_BYTES, null);
+		while (read.bytesRead > 0) {
+			total += read.bytesRead;
+			if (total > artifact.size) throw changed;
+			const chunk = buffer.subarray(0, read.bytesRead);
+			decoder.decode(chunk, { stream: true });
+			await writeAll({
+				output,
+				bytes: chunk,
+				signal
+			});
+			read = await source.read(buffer, 0, CHUNK_BYTES, null);
+		}
+		decoder.decode();
+		if (total !== artifact.size) throw changed;
+	} finally {
+		await source.close();
+	}
+}
+async function assemble({ output, header, artifacts, signal }) {
+	await writeAll({
+		output,
+		bytes: header,
+		signal
+	});
+	for (const artifact of artifacts) {
+		await writeAll({
+			output,
+			bytes: encoder.encode(formatSource(artifact)),
+			signal
+		});
+		await copyArtifact({
+			artifact,
+			output,
+			signal
+		});
+		await writeAll({
+			output,
+			bytes: SEPARATOR,
+			signal
+		});
+	}
+}
+async function writeLlmsFull(options) {
+	const { outputDir, publicDir, maxBytes, documents, signal } = options;
+	signal?.throwIfAborted();
+	const root = await realpath(publicDir);
+	const target = path.join(root, FILE_NAME);
+	if (await exists(target)) throw new Error(`${LLMS_FULL_PATH} already exists in the static output`);
+	if (documents.length === 0) return;
+	const artifacts = [];
+	for (const document of documents) artifacts.push({
+		...document,
+		...await resolveArtifact({
+			root,
+			path: document.path
+		})
+	});
+	const header = encoder.encode(formatHeader(options));
+	const total = artifacts.reduce((sum, artifact) => sum + encoder.encode(formatSource(artifact)).byteLength + artifact.size + SEPARATOR.byteLength, header.byteLength);
+	if (total > maxBytes) throw new Error(`${LLMS_FULL_PATH} would have ${total} bytes, above the ${maxBytes} byte budget`);
+	const workDir = await mkdtemp(path.join(outputDir, ".llms-full-"));
+	try {
+		const temporary = path.join(workDir, FILE_NAME);
+		const output = await open(temporary, "wx");
+		try {
+			await assemble({
+				output,
+				header,
+				artifacts,
+				signal
+			});
+			await output.sync();
+			const { size } = await output.stat();
+			if (size !== total) throw new Error(`${LLMS_FULL_PATH} has ${size} bytes instead of the expected ${total}`);
+		} finally {
+			await output.close();
+		}
+		signal?.throwIfAborted();
+		await rename(temporary, target);
+	} finally {
+		await rm(workDir, {
+			recursive: true,
+			force: true
+		});
+	}
+}
+// src/publication/markdownPrerender/helpers/writeVercelRoutes/index.ts
+const INDEX_FILE = "/index.md";
+const NOT_FOUND = -1;
+const VERCEL_CONFIG_VERSION = 3;
+const JSON_INDENT = 2;
+const LLMS_TYPE = "text/markdown; charset=utf-8";
+const REGEX_SPECIALS = /[.*+?^${}()|[\]\\]/gu;
+const RouteSchema = v.looseObject({
+	src: v.optional(v.string()),
+	handle: v.optional(v.string())
+});
+const OverridesSchema = v.record(v.string(), v.looseObject({}));
+const BuildConfigSchema = v.looseObject({
+	version: v.literal(VERCEL_CONFIG_VERSION),
+	routes: v.array(RouteSchema),
+	overrides: v.optional(OverridesSchema)
+});
+function escapeRegex(text) {
+	return text.replaceAll(REGEX_SPECIALS, String.raw`\$&`);
+}
+function assertInitialRoutes({ routes, directories }) {
+	const pages = directories.flatMap((directory) => directory ? [directory, `${directory}/`] : ["/"]);
+	for (const route of routes) {
+		if (route.src === void 0 || route.continue === true || route.dest !== void 0 || route.status !== void 0) continue;
+		const pattern = new RegExp(`^(?:${route.src})$`, route.caseSensitive === true ? "u" : "iu");
+		if (pages.some((page) => pattern.test(page))) throw new Error(`Vercel route ends before Markdown page protection: ${route.src}`);
+	}
+}
+function guardDirectoryPages({ routes, directories }) {
+	if (directories.length === 0) return [];
+	const prefix = `^(?=(?:${directories.map((directory) => directory ? `${escapeRegex(directory)}/?` : "/").join("|")})$)`;
+	let phase;
+	const guards = routes.flatMap((route) => {
+		if (route.handle !== void 0) {
+			phase = route.handle;
+			return [];
+		}
+		if (phase !== "filesystem" || route.src === void 0) return [];
+		return [{
+			...route,
+			src: `${prefix}(?:${route.src})$`
+		}];
+	});
+	const boundary = routes.findIndex((route) => "handle" in route);
+	if (boundary === NOT_FOUND || guards.length === 0) throw new Error("Vercel output has no filesystem routes for Markdown pages");
+	assertInitialRoutes({
+		routes: routes.slice(0, boundary),
+		directories
+	});
+	return guards;
+}
+function describedbyRoute(hasLlmsFull) {
+	return {
+		src: `^/(?:${hasLlmsFull ? `.+\\.md|${escapeRegex(LLMS_FULL_PATH.slice(1))}` : String.raw`.+\.md`})$`,
+		headers: { link: LLMS_DESCRIBEDBY_LINK },
+		continue: true
+	};
+}
+function markdownRoutes({ routes, paths, hasLlmsFull, hasLlms }) {
+	const guards = guardDirectoryPages({
+		routes,
+		directories: paths.filter((path) => path.endsWith(INDEX_FILE)).map((path) => path.slice(0, -9))
+	});
+	if (!routes.some((route) => route.handle === "filesystem")) throw new Error("Vercel output has no filesystem phase for static Markdown");
+	return [...hasLlms ? [describedbyRoute(hasLlmsFull)] : [], ...guards];
+}
+async function writeVercelRoutes({ outputDir, paths, hasLlmsFull, hasLlmsIndex, hasLlms }) {
+	const hasMarkdown = paths.length > 0 || hasLlmsFull;
+	if (!hasMarkdown && !hasLlmsIndex) return;
+	const file = path.join(outputDir, "config.json");
+	const config = v.parse(BuildConfigSchema, JSON.parse(await readFile(file, "utf8")));
+	if (hasMarkdown) {
+		const { routes } = config;
+		const initial = routes.findIndex((route) => "handle" in route);
+		routes.splice(initial, 0, ...markdownRoutes({
+			routes,
+			paths,
+			hasLlmsFull,
+			hasLlmsIndex,
+			hasLlms
+		}));
+	}
+	const textFiles = [...hasLlmsIndex ? [LLMS_PATH] : [], ...hasLlmsFull ? [LLMS_FULL_PATH] : []];
+	for (const textFile of textFiles) {
+		const name = textFile.slice(1);
+		config.overrides = {
+			...config.overrides,
+			[name]: {
+				...config.overrides?.[name],
+				contentType: LLMS_TYPE
+			}
+		};
+	}
+	await writeFile(file, `${JSON.stringify(config, null, JSON_INDENT)}\n`);
+}
+// src/publication/markdownPrerender/index.ts
+const MarkdownPathSchema = v.pipe(v.string(), v.regex(/^\/[^?#]+\.md$/u));
+const ManifestSchema = v.object({
+	buildId: v.optional(v.string()),
+	siteUrl: v.pipe(v.string(), v.url()),
+	baseLocale: v.pipe(v.string(), v.nonEmpty()),
+	paths: v.array(MarkdownPathSchema),
+	baseLocalePaths: v.array(MarkdownPathSchema),
+	mismatches: v.array(v.string())
+});
+function readInventory(contents) {
+	try {
+		const manifest = v.parse(ManifestSchema, JSON.parse(contents ?? ""));
+		const expected = new Map(manifest.paths.map((path) => [decodeURI(path), path]));
+		const baseLocalePaths = new Set(manifest.baseLocalePaths.map((path) => decodeURI(path)));
+		return expected.size === manifest.paths.length && [...baseLocalePaths].every((path) => expected.has(path)) ? {
+			manifest,
+			expected,
+			baseLocalePaths
+		} : void 0;
+	} catch {
+		return;
+	}
+}
+function isMarkdownArtifact(route) {
+	return route.route.endsWith(".md") || route.fileName?.endsWith(".md") === true;
+}
+function assertRegistered({ prerenderedRoutes, expected }) {
+	const written = new Map(prerenderedRoutes.map((route) => [route.route, route]));
+	const missing = [...expected].filter(([path]) => written.get(path)?.fileName !== path).map(([, published]) => published);
+	if (missing.length > 0) throw new Error(`Static Markdown not generated: ${missing.join(", ")}`);
+	const extra = prerenderedRoutes.filter((route) => isMarkdownArtifact(route) && !expected.has(route.route)).map((route) => route.route);
+	if (extra.length > 0) throw new Error(`Static Markdown outside the list: ${extra.join(", ")}`);
+}
+async function publishLlmsFull({ inventory, llmsText, outputDir, publicDir, maxBytes }) {
+	const { manifest, expected, baseLocalePaths } = inventory;
+	const index = readLlmsIndex(llmsText);
+	const { documents, omitted } = selectLlmsFullDocuments({
+		links: index.links,
+		siteUrl: manifest.siteUrl,
+		inventory: new Set(expected.keys()),
+		baseLocalePaths,
+		ownPaths: /* @__PURE__ */ new Set([LLMS_PATH, LLMS_FULL_PATH])
+	});
+	const fullUrl = new URL(LLMS_FULL_PATH, manifest.siteUrl).href;
+	const isAnnounced = index.links.some(({ href }) => href === fullUrl);
+	if (isAnnounced !== documents.length > 0) throw new Error(isAnnounced ? `llms.txt announces ${LLMS_FULL_PATH} without static Markdown pages` : `llms.txt does not announce ${LLMS_FULL_PATH} for its static Markdown pages`);
+	await writeLlmsFull({
+		outputDir,
+		publicDir,
+		maxBytes,
+		index: {
+			title: index.title,
+			description: index.description,
+			url: new URL(LLMS_PATH, manifest.siteUrl).href
+		},
+		baseLocale: manifest.baseLocale,
+		documents,
+		omitted
+	});
+	return documents.length > 0;
+}
+function markdownPrerender({ buildId, hasMarkdown = true, hasSitemap = true, hasLlms = true, hasLlmsFull: shouldBuildLlmsFull = true, llmsMaxBytes = LLMS_MAX_BYTES, llmsFullMaxBytes = LLMS_FULL_MAX_BYTES }) {
+	return (nitro) => {
+		let queue;
+		let inventory;
+		let llmsText;
+		let hasLlmsFull = false;
+		const approved = /* @__PURE__ */ new Map();
+		const publication = publicationArtifacts({
+			buildId,
+			hasSitemap
+		});
+		nitro.options.prerender.failOnError = true;
+		nitro.options.prerender.routes = [.../* @__PURE__ */ new Set([
+			...nitro.options.prerender.routes ?? [],
+			...hasMarkdown ? [MARKDOWN_PRERENDER_PATH] : [],
+			...hasSitemap ? [SITEMAP_INVENTORY_PATH] : [],
+			...hasLlms ? [LLMS_PATH] : []
+		])];
+		nitro.hooks.hook("prerender:init", () => {
+			env[PUBLICATION_PHASE_ENV] = PUBLICATION_PRERENDER_PHASE;
+		});
+		nitro.hooks.hook("prerender:routes", (initial) => {
+			queue = initial;
+		});
+		nitro.hooks.hook("prerender:generate", (route) => {
+			if (publication.inspect({
+				route,
+				queue
+			})) return;
+			if (hasMarkdown && route.route === "/_markdown/static.json") {
+				if (route.error) return;
+				inventory = readInventory(route.contents);
+				if (!queue || !inventory) {
+					route.error = /* @__PURE__ */ new Error("Invalid static Markdown list");
+					return;
+				}
+				if (!inventory.manifest.buildId || inventory.manifest.buildId !== buildId) {
+					route.error = /* @__PURE__ */ new Error("Static Markdown build identity does not match SSR");
+					inventory = void 0;
+					return;
+				}
+				const { mismatches, paths } = inventory.manifest;
+				if (mismatches.length > 0) {
+					route.error = /* @__PURE__ */ new Error(`Static Markdown pages resolve to another route: ${mismatches.join(", ")}`);
+					return;
+				}
+				for (const path of paths) queue.add(path);
+				publication.approve({ route });
+				return;
+			}
+			if (hasLlms && route.route === "/llms.txt") {
+				if (route.error) return;
+				llmsText = route.contents;
+				publication.approve({
+					route,
+					maxBytes: llmsMaxBytes
+				});
+				return;
+			}
+			if (!isMarkdownArtifact(route) || route.error) return;
+			const problem = inspectMarkdownArtifact(route);
+			if (problem) {
+				route.error = /* @__PURE__ */ new Error(`Invalid static Markdown ${route.route}: ${problem}`);
+				return;
+			}
+			approved.set(route.route, digestBytes(readRouteBytes(route)));
+		});
+		nitro.hooks.hook("prerender:done", async ({ prerenderedRoutes, failedRoutes }) => {
+			Reflect.deleteProperty(env, PUBLICATION_PHASE_ENV);
+			if (failedRoutes.length > 0 && nitro.options.prerender.failOnError) return;
+			if (hasMarkdown && !inventory) throw new Error("Static Markdown list was not prerendered");
+			const expected = inventory?.expected ?? /* @__PURE__ */ new Map();
+			assertRegistered({
+				prerenderedRoutes,
+				expected
+			});
+			const { dir: outputDir, publicDir } = nitro.options.output;
+			await assertStaticOutput({
+				publicDir,
+				expected,
+				approved
+			});
+			if (hasLlms && llmsText === void 0) throw new Error("llms.txt was not prerendered");
+			await publication.assertPublished({
+				publicDir,
+				prerenderedRoutes
+			});
+			await assertDisabledArtifacts({
+				publicDir,
+				hasLlms,
+				hasLlmsFull: shouldBuildLlmsFull
+			});
+			if (shouldBuildLlmsFull && inventory && llmsText !== void 0) hasLlmsFull = await publishLlmsFull({
+				inventory,
+				llmsText,
+				outputDir,
+				publicDir,
+				maxBytes: llmsFullMaxBytes
+			});
+		});
+		nitro.hooks.hook("compiled", async () => {
+			await writeVercelRoutes({
+				outputDir: nitro.options.output.dir,
+				paths: inventory?.manifest.paths ?? [],
+				hasLlmsFull,
+				hasLlms,
+				hasLlmsIndex: llmsText !== void 0
+			});
+			await publication.writeServer(nitro.options.output.serverDir);
+		});
+	};
+}
+// src/publication/publicationArtifacts/helpers/createPublicationBuild/index.ts
+const BUILD_ID_DEFINE = "import.meta.env.PUBLICATION_BUILD_ID";
+function createPublicationBuild() {
+	const buildId = randomUUID();
+	return {
+		buildId,
+		plugin: {
+			name: "project:publication-build",
+			config: () => ({ define: { [BUILD_ID_DEFINE]: JSON.stringify(buildId) } })
+		}
+	};
+}
+// src/publication/index.ts
+function publicationBuild(features) {
+	const publication = createPublicationBuild();
+	return {
+		plugin: publication.plugin,
+		module: markdownPrerender({
+			buildId: publication.buildId,
+			hasMarkdown: typeof features.markdown === "object" && features.markdown.static === true,
+			hasSitemap: typeof features.sitemap === "object",
+			hasLlms: Boolean(features.llms),
+			hasLlmsFull: Boolean(features.llmsFull),
+			llmsMaxBytes: typeof features.llms === "object" ? features.llms.maxBytes : void 0,
+			llmsFullMaxBytes: typeof features.llmsFull === "object" ? features.llmsFull.maxBytes : void 0
+		})
+	};
+}
+export { publicationBuild };