@tenphi/docs 0.13.0 → 0.16.0

package/dist/content-Btz1o52C.js

@@ -0,0 +1,1340 @@
+import { i as normalizeDocsConfig } from "./config-CmoSqvii.js";
+import { cloneAst, parseMarkdown, removeRenderedTitle, serializeMarkdown, stripLeadingBadgeBlock } from "./markdown/index.js";
+import { lstat, mkdir, mkdtemp, readFile, readdir, rename, rm, stat, writeFile } from "node:fs/promises";
+import { basename, dirname, extname, isAbsolute, join, relative, resolve, sep } from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { createHash } from "node:crypto";
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import { glob } from "tinyglobby";
+import { visit } from "unist-util-visit";
+import { parse } from "yaml";
+import { fromHtml } from "hast-util-from-html";
+import { defaultSchema, sanitize } from "hast-util-sanitize";
+import { toHtml } from "hast-util-to-html";
+import { homedir } from "node:os";
+import npa from "npm-package-arg";
+import pacote from "pacote";
+//#region src/html/index.ts
+const schema = {
+	...defaultSchema,
+	strip: [
+		"script",
+		"style",
+		"iframe",
+		"object",
+		"embed",
+		"template"
+	],
+	protocols: {
+		...defaultSchema.protocols,
+		href: [...defaultSchema.protocols?.href ?? [], "source"]
+	},
+	attributes: {
+		...defaultSchema.attributes,
+		"*": defaultSchema.attributes?.["*"]?.filter((attribute) => typeof attribute !== "string" || ![
+			"color",
+			"bgColor",
+			"align",
+			"border",
+			"cellPadding",
+			"cellSpacing"
+		].includes(attribute)) ?? []
+	}
+};
+/** Sanitize raw Markdown HTML while preserving separate inline opening/closing tags. */
+async function sanitizeMarkup(html, rewrite) {
+	const closing = /^<\/([a-z][a-z\d-]*)\s*>$/i.exec(html.trim());
+	if (closing) {
+		const tag = closing[1]?.toLowerCase() ?? "";
+		return schema.tagNames?.includes(tag) ? `</${tag}>` : "";
+	}
+	const tree = sanitize(fromHtml(html, { fragment: true }), schema);
+	const tasks = [];
+	visit(tree, "element", (element) => {
+		for (const [property, kind] of [["href", "link"], ["src", "image"]]) {
+			const value = element.properties[property];
+			if (typeof value !== "string") continue;
+			tasks.push(rewrite(value, kind).then((resolved) => {
+				element.properties[property] = resolved;
+			}));
+		}
+	});
+	await Promise.all(tasks);
+	let result = toHtml(tree);
+	const opening = /^<([a-z][a-z\d-]*)(?:\s+(?:[^<>"']|"[^"]*"|'[^']*')*)?\s*>$/i.exec(html.trim());
+	const first = tree.children[0];
+	if (opening && tree.children.length === 1 && first?.type === "element" && first.tagName === opening[1]?.toLowerCase() && first.children.length === 0) result = result.replace(new RegExp(`</${first.tagName}>$`), "");
+	return result;
+}
+//#endregion
+//#region src/npm/index.ts
+const DEFAULT_REGISTRY = "https://registry.npmjs.org/";
+const LOCK_FILE = "cookbook.lock.json";
+async function resolvePackageLock(requested, options = {}) {
+	const parsed = npa(requested);
+	if (![
+		"tag",
+		"version",
+		"range"
+	].includes(parsed.type)) throw new Error(`Only npm registry package specifiers are supported (received ${parsed.type}).`);
+	const registry = options.registry ?? DEFAULT_REGISTRY;
+	const manifest = await pacote.manifest(requested, {
+		registry,
+		...options.cacheDir ? { cache: options.cacheDir } : {},
+		fullMetadata: true
+	});
+	if (!manifest.name || !manifest.version || !manifest._integrity) throw new Error(`Registry metadata for ${requested} did not include version and integrity.`);
+	return {
+		requested,
+		resolved: `${manifest.name}@${manifest.version}`,
+		registry,
+		integrity: manifest._integrity
+	};
+}
+async function readDocsLock(root) {
+	try {
+		const value = JSON.parse(await readFile(join(root, LOCK_FILE), "utf8"));
+		validateLock(value);
+		return value;
+	} catch (error) {
+		if (isMissing(error)) return void 0;
+		throw error;
+	}
+}
+async function writeDocsLock(root, lock) {
+	validateLock(lock);
+	const temporary = await mkdtemp(join(root, ".cookbook-lock-"));
+	try {
+		await writeFile(join(temporary, LOCK_FILE), `${JSON.stringify(lock, null, 2)}\n`, "utf8");
+		await rename(join(temporary, LOCK_FILE), join(root, LOCK_FILE));
+	} finally {
+		await rm(temporary, {
+			recursive: true,
+			force: true
+		});
+	}
+}
+/** Reconcile declarations, including the first lock and removed sources. */
+async function reconcileDocsLock(config, existing, options = {}) {
+	const configured = (config.content?.sources ?? []).filter((source) => "package" in source);
+	const unique = /* @__PURE__ */ new Map();
+	for (const declaration of configured) {
+		const previous = unique.get(declaration.package);
+		if (previous?.registry && declaration.registry && previous.registry !== declaration.registry) throw new Error(`Package source ${declaration.package} declares conflicting registries.`);
+		unique.set(declaration.package, {
+			...declaration,
+			...previous?.registry ? { registry: previous.registry } : {}
+		});
+	}
+	const declarations = [...unique.values()];
+	const selectors = options.packages ?? [];
+	for (const selector of selectors) if (!declarations.some((source) => source.package === selector || packageNameFromSpecifier(source.package) === selector)) throw new Error(`No configured package source matches "${selector}".`);
+	const sources = [];
+	for (const declaration of declarations) {
+		const current = existing?.sources.find((source) => source.requested === declaration.package);
+		const selected = selectors.length === 0 || selectors.some((selector) => selector === declaration.package || selector === packageNameFromSpecifier(declaration.package));
+		if (!selected && current && (!declaration.registry || declaration.registry === current.registry)) {
+			sources.push(current);
+			continue;
+		}
+		if (!selected) throw new Error(`Package source ${declaration.package} is not locked. Run "cookbook update" without a package selector.`);
+		const previous = current ?? existing?.sources.find((source) => packageNameFromSpecifier(source.requested) === packageNameFromSpecifier(declaration.package));
+		const registry = declaration.registry ?? previous?.registry;
+		const next = await (options.resolve ?? resolvePackageLock)(declaration.package, registry ? { registry } : {});
+		if (previous?.vendored) next.vendored = next.integrity === previous.integrity ? previous.vendored : `.cookbook/vendor/${createHash("sha256").update(next.integrity).digest("hex")}`;
+		sources.push(next);
+	}
+	return defaultLock(sources);
+}
+function validateLock(lock) {
+	if (lock.schemaVersion !== 1 || !Array.isArray(lock.sources)) throw new Error("Unsupported or invalid cookbook.lock.json.");
+	for (const source of lock.sources) {
+		if (!source.requested || !source.resolved || !source.registry || !source.integrity) throw new Error("Every lock source requires requested, resolved, registry, and integrity.");
+		if (npa(source.resolved).type !== "version") throw new Error(`Locked source must use an exact version: ${source.resolved}.`);
+		if (source.vendored && (source.vendored.startsWith("/") || source.vendored.split(/[\\/]/).includes(".."))) throw new Error(`Vendored package path must stay within the project: ${source.vendored}.`);
+	}
+}
+async function materializePackage(source, config, projectRoot) {
+	if (source.vendored) {
+		if (!projectRoot) throw new Error(`Vendored source ${source.resolved} requires a project root.`);
+		const vendored = resolve(projectRoot, source.vendored);
+		if (!inside$1(projectRoot, vendored)) throw new Error(`Vendored package path escapes the project root: ${source.vendored}.`);
+		if ((await readFile(join(vendored, ".cookbook-integrity"), "utf8")).trim() !== source.integrity) throw new Error(`Vendored package integrity marker does not match ${source.resolved}.`);
+		await validateExtractedTree(vendored, config);
+		return vendored;
+	}
+	const cacheRoot = resolve(config.cacheDir || join(homedir(), ".cache", "cookbook"), "artifacts");
+	const key = createHash("sha256").update(source.integrity).digest("hex");
+	const destination = join(cacheRoot, key);
+	const marker = join(destination, ".cookbook-integrity");
+	try {
+		if ((await readFile(marker, "utf8")).trim() === source.integrity) {
+			await validateExtractedTree(destination, config);
+			return destination;
+		}
+	} catch (error) {
+		if (!isMissing(error)) throw error;
+	}
+	await mkdir(cacheRoot, { recursive: true });
+	const temporary = await mkdtemp(join(cacheRoot, ".extract-"));
+	try {
+		const tarball = await pacote.tarball(source.resolved, {
+			registry: source.registry,
+			integrity: source.integrity,
+			cache: join(cacheRoot, "_cacache")
+		});
+		if (tarball.byteLength > config.maxArtifactBytes) throw new Error(`Package artifact is ${tarball.byteLength} bytes; limit is ${config.maxArtifactBytes}.`);
+		await pacote.extract(source.resolved, temporary, {
+			registry: source.registry,
+			integrity: source.integrity,
+			cache: join(cacheRoot, "_cacache")
+		});
+		await validateExtractedTree(temporary, config);
+		await writeFile(join(temporary, ".cookbook-integrity"), `${source.integrity}\n`);
+		await rm(destination, {
+			recursive: true,
+			force: true
+		});
+		await rename(temporary, destination);
+		return destination;
+	} catch (error) {
+		await rm(temporary, {
+			recursive: true,
+			force: true
+		});
+		throw error;
+	}
+}
+async function validateExtractedTree(root, config) {
+	let files = 0;
+	let bytes = 0;
+	const pending = [root];
+	while (pending.length > 0) {
+		const directory = pending.pop();
+		if (!directory) break;
+		for (const name of await readdir(directory)) {
+			if (name === ".cookbook-integrity") continue;
+			const path = join(directory, name);
+			const info = await lstat(path);
+			const rel = relative(root, path);
+			if (rel.startsWith(`..${sep}`) || rel === "..") throw new Error(`Package path escapes artifact root: ${rel}.`);
+			if (rel.split(sep).length > config.maxPathDepth) throw new Error(`Package path exceeds maximum depth: ${rel}.`);
+			if (info.isSymbolicLink()) throw new Error(`Package symlinks are not allowed: ${rel}.`);
+			if (info.isDirectory()) pending.push(path);
+			else if (info.isFile()) {
+				files += 1;
+				bytes += info.size;
+				if (info.size > config.maxAssetBytes) throw new Error(`Package file exceeds maximum size: ${rel}.`);
+				if (files > config.maxFiles || bytes > config.maxUnpackedBytes) throw new Error("Package exceeds configured file-count or unpacked-size limit.");
+			} else throw new Error(`Unsupported package entry type: ${rel}.`);
+		}
+	}
+}
+async function discoverPackage(root) {
+	const manifest = JSON.parse(await readFile(join(root, "package.json"), "utf8"));
+	const hints = manifest.cookbook;
+	const homeCandidates = [
+		hints?.index,
+		"README.md",
+		"readme.md"
+	].filter((candidate) => Boolean(candidate));
+	let home;
+	for (const candidate of homeCandidates) {
+		assertSafePackagePath(candidate, "cookbook.index");
+		try {
+			const path = resolve(root, candidate);
+			if (!inside$1(root, path)) throw new Error(`cookbook.index escapes the package root: ${candidate}.`);
+			if ((await stat(path)).isFile()) {
+				home = candidate;
+				break;
+			}
+		} catch (error) {
+			if (!isMissing(error)) throw error;
+		}
+	}
+	const patterns = hints?.include?.length ? hints.include : ["docs/**/*.{md,mdx}", "docs/**/*.{png,jpg,jpeg,gif,webp,avif,svg,pdf,txt,zip}"];
+	for (const pattern of patterns) assertSafePackagePath(pattern, "cookbook.include");
+	for (const pattern of hints?.exclude ?? []) assertSafePackagePath(pattern, "cookbook.exclude");
+	const discovered = await glob(patterns, {
+		cwd: root,
+		onlyFiles: true,
+		dot: false,
+		ignore: hints?.exclude ?? []
+	});
+	for (const path of discovered) {
+		assertSafePackagePath(path, "discovered package path");
+		if (!inside$1(root, resolve(root, path))) throw new Error(`Discovered path escapes the package root: ${path}.`);
+	}
+	const pages = discovered.filter((path) => /\.mdx?$/i.test(path));
+	if (home && !pages.includes(home)) pages.unshift(home);
+	const assets = discovered.filter((path) => !/\.mdx?$/i.test(path));
+	return {
+		root,
+		manifest,
+		...home ? { home } : {},
+		pages,
+		assets
+	};
+}
+function packageNameFromSpecifier(specifier) {
+	const parsed = npa(specifier);
+	if (!parsed.name) throw new Error(`Invalid npm package specifier: ${specifier}.`);
+	return parsed.name;
+}
+function lockForSource(lock, requested) {
+	const exact = lock?.sources.find((source) => source.requested === requested);
+	if (exact) return exact;
+	throw new Error(`Package source ${requested} is not locked. Run "cookbook update" to reconcile ${LOCK_FILE} with docs.config.ts.`);
+}
+/** Reject paths and glob patterns that could address files outside a package. */
+function assertSafePackagePath(path, field) {
+	const normalized = path.replaceAll("\\", "/");
+	if (path.trim() === "" || path.includes("\0") || isAbsolute(path) || normalized.startsWith("/") || /^[a-z]:\//i.test(normalized) || normalized.includes("..")) throw new Error(`${field} must stay within the package root: ${path}.`);
+}
+function defaultLock(sources) {
+	return {
+		schemaVersion: 1,
+		sources
+	};
+}
+function isMissing(error) {
+	return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
+}
+function inside$1(root, path) {
+	const rel = relative(resolve(root), resolve(path));
+	return rel === "" || !rel.startsWith(`..${sep}`) && rel !== ".." && !isAbsolute(rel);
+}
+//#endregion
+//#region src/graph/index.ts
+const MARKDOWN_EXTENSIONS = [".md", ".mdx"];
+const execFileAsync = promisify(execFile);
+const FRONTMATTER_KEYS = /* @__PURE__ */ new Set([
+	"aliases",
+	"title",
+	"description",
+	"slug",
+	"draft",
+	"sidebar",
+	"tableOfContents",
+	"editUrl",
+	"template",
+	"hero",
+	"lastUpdated",
+	"prev",
+	"next",
+	"banner",
+	"pagefind",
+	"head"
+]);
+async function createDocsGraph(options = {}) {
+	const root = resolve(options.root ?? process.cwd());
+	const normalized = normalizeDocsConfig(options.config);
+	const config = options.base ? {
+		...normalized,
+		build: {
+			...normalized.build,
+			base: options.base
+		}
+	} : normalized;
+	const diagnostics = [];
+	const collected = await collectSources(root, config, options.lock ?? await readDocsLock(root), diagnostics);
+	const entries = [];
+	const routeMap = /* @__PURE__ */ new Map();
+	const absoluteMap = /* @__PURE__ */ new Map();
+	const sourceMap = /* @__PURE__ */ new Map();
+	const repositoryMap = /* @__PURE__ */ new Map();
+	for (const source of collected) {
+		const entry = await readEntry(source, config, diagnostics);
+		if (!entry) continue;
+		const existing = routeMap.get(entry.route);
+		if (existing) {
+			diagnostics.push({
+				code: "DOCS_DUPLICATE_ROUTE",
+				severity: "error",
+				message: `Route ${entry.route} is owned by both ${existing.sourcePath} and ${entry.sourcePath}.`,
+				file: entry.sourcePath,
+				related: [{
+					file: existing.sourcePath,
+					message: "First route owner."
+				}]
+			});
+			continue;
+		}
+		routeMap.set(entry.route, entry);
+		const absolute = normalizeFs(entry.absolutePath);
+		absoluteMap.set(absolute, [...absoluteMap.get(absolute) ?? [], entry]);
+		sourceMap.set(entry.sourcePath, [...sourceMap.get(entry.sourcePath) ?? [], entry]);
+		sourceMap.set(entry.id, [entry]);
+		if (source.repository) repositoryMap.set(entry.id, source.repository);
+		entries.push(entry);
+	}
+	if (entries.length === 0) diagnostics.push({
+		code: "DOCS_NO_PAGES",
+		severity: "error",
+		message: "No documentation pages were found. Add README.md, docs/**/*.md, or configure content.sources."
+	});
+	const redirects = resolveRedirects(config.redirects, entries, routeMap, diagnostics);
+	for (const [alias, target] of Object.entries(redirects)) {
+		const entry = routeMap.get(target);
+		if (entry) routeMap.set(alias, entry);
+	}
+	for (const entry of entries) await transformEntry(entry, absoluteMap, routeMap, repositoryMap, config, diagnostics);
+	validateNavigation(config.navigation.items ?? [], routeMap, diagnostics);
+	for (const tab of config.navigation.tabs ?? []) {
+		validateNavigation([{
+			label: tab.label,
+			link: tab.link
+		}], routeMap, diagnostics);
+		validateNavigation(tab.items ?? [], routeMap, diagnostics);
+	}
+	entries.sort((left, right) => left.route.localeCompare(right.route));
+	return {
+		redirects,
+		root,
+		config,
+		entries,
+		routes: entries.map((entry) => ({
+			route: entry.route,
+			entryId: entry.id,
+			sourcePath: entry.sourcePath,
+			title: entry.title,
+			...entry.frontmatter.sidebar !== void 0 ? { sidebar: entry.frontmatter.sidebar } : {}
+		})),
+		assets: Array.from(new Map(entries.flatMap((entry) => entry.assets).map((asset) => [asset.publicPath ?? `${asset.original}:${asset.line ?? ""}`, asset])).values()),
+		diagnostics,
+		entryByRoute(route) {
+			return routeMap.get(normalizeRoute(route));
+		},
+		entryBySource(sourcePath, sourceId) {
+			const matches = sourceMap.get(sourcePath) ?? [];
+			return sourceId ? matches.find((entry) => entry.sourceId === sourceId) : matches.length === 1 ? matches[0] : void 0;
+		}
+	};
+}
+function resolveRedirects(configured, entries, routes, diagnostics) {
+	const requested = /* @__PURE__ */ new Map();
+	const error = (message) => diagnostics.push({
+		code: "DOCS_REDIRECT_INVALID",
+		severity: "error",
+		message
+	});
+	const add = (from, to) => {
+		try {
+			const alias = normalizeRoute(from);
+			const target = normalizeRoute(to);
+			if (routes.has(alias) || requested.has(alias)) error(`Redirect ${alias} conflicts with an existing page or redirect.`);
+			else requested.set(alias, target);
+		} catch (cause) {
+			error(errorMessage(cause));
+		}
+	};
+	for (const [from, to] of Object.entries(configured)) add(from, to);
+	for (const entry of entries) for (const alias of entry.frontmatter.aliases ?? []) add(`${entry.routeBase}/${alias}`, entry.route);
+	const result = {};
+	for (const [alias, target] of requested) {
+		const seen = /* @__PURE__ */ new Set([alias]);
+		let current = target;
+		while (requested.has(current) && !seen.has(current)) {
+			seen.add(current);
+			current = requested.get(current);
+		}
+		if (seen.has(current)) error(`Redirect cycle includes ${alias}.`);
+		else if (!routes.has(current)) error(`Redirect ${alias} points to missing document ${current}.`);
+		else result[alias] = current;
+	}
+	return result;
+}
+async function collectSources(root, config, lock, diagnostics) {
+	const declarations = config.content.sources ?? await conventionSources(root);
+	const results = [];
+	const identities = /* @__PURE__ */ new Set();
+	const sourceIds = /* @__PURE__ */ new Set();
+	for (const [index, declaration] of declarations.entries()) {
+		const sourceId = declaration.id ?? `source-${index + 1}`;
+		if (sourceIds.has(sourceId)) {
+			diagnostics.push({
+				code: "DOCS_DUPLICATE_SOURCE",
+				severity: "error",
+				message: `Source id ${sourceId} is declared more than once.`
+			});
+			continue;
+		}
+		sourceIds.add(sourceId);
+		try {
+			const found = await collectDeclaration(root, declaration, config, lock, sourceId);
+			if (found.length === 0) diagnostics.push({
+				code: "DOCS_SOURCE_NOT_FOUND",
+				severity: "error",
+				message: `Source did not match any files: ${sourceLabel(declaration)}.`
+			});
+			for (const source of found) {
+				const identity = `${sourceId}:${normalizeFs(source.absolutePath)}`;
+				if (identities.has(identity)) continue;
+				identities.add(identity);
+				results.push(source);
+			}
+		} catch (error) {
+			diagnostics.push({
+				code: error instanceof OutsideRootError ? "DOCS_SOURCE_OUTSIDE_ROOT" : "DOCS_SOURCE_NOT_FOUND",
+				severity: "error",
+				message: errorMessage(error)
+			});
+		}
+	}
+	return results;
+}
+async function conventionSources(root) {
+	const sources = [];
+	if (await isFile(resolve(root, "README.md"))) sources.push({
+		file: "README.md",
+		route: "/"
+	});
+	if (await isDirectory(resolve(root, "docs"))) sources.push({
+		glob: "docs/**/*.{md,mdx}",
+		base: "docs"
+	});
+	return sources;
+}
+async function collectDeclaration(root, declaration, config, lock, sourceId) {
+	if ("package" in declaration) {
+		const packageLock = lockForSource(lock, declaration.package);
+		if (declaration.registry && packageLock.registry !== declaration.registry) throw new Error(`Registry changed for ${declaration.package}. Run "cookbook update".`);
+		const sourceRoot = await materializePackage(packageLock, config.build, root);
+		const discovery = await discoverPackage(sourceRoot);
+		const repository = config.content.localizeRepositoryLinks ? repositoryMetadata(discovery.manifest.repository) : void 0;
+		const patterns = declaration.include?.length ? declaration.include : discovery.pages;
+		for (const pattern of patterns) assertSafePackagePath(pattern, "Package source include");
+		for (const pattern of declaration.exclude ?? []) assertSafePackagePath(pattern, "Package source exclude");
+		if (declaration.index) assertSafePackagePath(declaration.index, "Package source index");
+		const files = await glob(patterns, {
+			cwd: sourceRoot,
+			onlyFiles: true,
+			ignore: declaration.exclude ?? []
+		});
+		const index = declaration.index ?? discovery.home;
+		return files.filter((path) => MARKDOWN_EXTENSIONS.includes(extname(path).toLowerCase())).map((path) => {
+			assertSafePackagePath(path, "Discovered package source");
+			const absolutePath = resolve(sourceRoot, path);
+			if (!inside(sourceRoot, absolutePath)) throw new OutsideRootError(path);
+			return {
+				sourceId,
+				...declaration.routeBase ? { routeBase: declaration.routeBase } : {},
+				absolutePath,
+				sourcePath: path,
+				sourceRoot,
+				route: path === index ? normalizeRoute(declaration.routeBase ?? "/") : routeForPath(path, "docs", declaration.routeBase),
+				trust: declaration.trust ?? "markdown",
+				packageLock,
+				...repository ? { repository } : {}
+			};
+		});
+	}
+	const sourceRoot = resolve(root, declaration.root ?? ".");
+	const repository = config.content.localizeRepositoryLinks ? repositoryMetadata(config.site.repository) : void 0;
+	if ("file" in declaration) {
+		const absolutePath = resolveSourcePath(sourceRoot, declaration.file, config.content.allowOutsideRoot);
+		if (!await isFile(absolutePath)) return [];
+		return [{
+			sourceId,
+			...declaration.routeBase ? { routeBase: declaration.routeBase } : {},
+			absolutePath,
+			sourcePath: toPosix(relative(sourceRoot, absolutePath)),
+			editPath: toPosix(relative(inside(root, absolutePath) ? root : sourceRoot, absolutePath)),
+			sourceRoot,
+			route: declaration.route ? normalizeRoute(`${declaration.routeBase ?? ""}/${declaration.route}`) : routeForPath(declaration.file, void 0, declaration.routeBase),
+			...declaration.title ? { title: declaration.title } : {},
+			...declaration.description ? { description: declaration.description } : {},
+			...declaration.navigation !== void 0 ? { navigation: declaration.navigation } : {},
+			trust: "mdx",
+			...repository ? { repository } : {}
+		}];
+	}
+	const patterns = Array.isArray(declaration.glob) ? declaration.glob : [declaration.glob];
+	return (await glob(patterns, {
+		cwd: sourceRoot,
+		onlyFiles: true,
+		dot: false,
+		ignore: [
+			"**/_*/**",
+			"**/_*",
+			...declaration.exclude ?? []
+		]
+	})).map((path) => {
+		const absolutePath = resolveSourcePath(sourceRoot, path, config.content.allowOutsideRoot);
+		return {
+			sourceId,
+			...declaration.routeBase ? { routeBase: declaration.routeBase } : {},
+			absolutePath,
+			sourcePath: toPosix(relative(sourceRoot, absolutePath)),
+			editPath: toPosix(relative(inside(root, absolutePath) ? root : sourceRoot, absolutePath)),
+			sourceRoot,
+			route: routeForPath(path, declaration.base, declaration.routeBase),
+			...declaration.navigation === false ? { navigation: false } : {},
+			trust: "mdx",
+			...repository ? { repository } : {}
+		};
+	});
+}
+async function readEntry(source, config, diagnostics) {
+	if (extname(source.sourcePath).toLowerCase() === ".mdx" && source.trust !== "mdx") {
+		diagnostics.push({
+			code: "DOCS_UNTRUSTED_MDX",
+			severity: "error",
+			message: `Package MDX requires trust: 'mdx': ${source.sourcePath}.`,
+			file: source.sourcePath,
+			hint: "Keep package sources in Markdown-safe mode or explicitly trust this locked artifact."
+		});
+		return;
+	}
+	const original = await readFile(source.absolutePath, "utf8");
+	let parsedMatter;
+	try {
+		parsedMatter = parseFrontmatter(original);
+	} catch (error) {
+		diagnostics.push({
+			code: "DOCS_FRONTMATTER_INVALID",
+			severity: "error",
+			message: `Could not parse frontmatter: ${errorMessage(error)}.`,
+			file: source.sourcePath
+		});
+		return;
+	}
+	const frontmatter = parsedMatter.data;
+	if (frontmatter.sidebar === void 0 && source.navigation !== void 0) frontmatter.sidebar = source.navigation;
+	const diagnosticCount = diagnostics.length;
+	const metadata = {};
+	for (const key of Object.keys(frontmatter)) if (!FRONTMATTER_KEYS.has(key)) {
+		if (config.content.frontmatter !== "reject") {
+			metadata[key] = frontmatter[key];
+			delete frontmatter[key];
+			continue;
+		}
+		diagnostics.push({
+			code: "DOCS_FRONTMATTER_INVALID",
+			severity: "error",
+			message: `Unknown frontmatter key "${key}".`,
+			file: source.sourcePath
+		});
+	}
+	validateFrontmatter(frontmatter, source.sourcePath, diagnostics);
+	if (diagnostics.length > diagnosticCount) return void 0;
+	const mdx = extname(source.sourcePath).toLowerCase() === ".mdx";
+	const parsed = parseMarkdown(parsedMatter.content, { mdx });
+	const route = normalizeRoute(frontmatter.slug !== void 0 ? `${source.routeBase ?? ""}/${frontmatter.slug}` : source.route ?? routeForPath(source.sourcePath));
+	const title = frontmatter.title ?? source.title ?? parsed.firstHeading ?? titleFromFile(source.sourcePath);
+	const description = frontmatter.description ?? source.description ?? parsed.description;
+	await resolvePageMetadata(frontmatter, source, config);
+	const duplicateTitles = /* @__PURE__ */ new Map();
+	for (const heading of parsed.headings) {
+		const count = (duplicateTitles.get(heading.text) ?? 0) + 1;
+		duplicateTitles.set(heading.text, count);
+		if (count > 1) diagnostics.push({
+			code: "DOCS_HEADING_DUPLICATE",
+			severity: "warning",
+			message: `Repeated heading "${heading.text}" receives the generated ID "${heading.slug}".`,
+			file: source.sourcePath,
+			...heading.line ? { line: heading.line } : {}
+		});
+	}
+	return {
+		id: `${source.sourceId}:${source.sourcePath}`,
+		sourceId: source.sourceId,
+		routeBase: source.routeBase ?? "/",
+		metadata,
+		sourcePath: source.sourcePath,
+		absolutePath: source.absolutePath,
+		sourceRoot: source.sourceRoot,
+		route,
+		title,
+		...description ? { description } : {},
+		frontmatter,
+		headings: parsed.headings,
+		body: parsedMatter.content,
+		transformedBody: parsedMatter.content,
+		ast: parsed.ast,
+		links: [],
+		assets: [],
+		trust: source.trust,
+		...source.packageLock ? { package: {
+			requested: source.packageLock.requested,
+			resolved: source.packageLock.resolved
+		} } : {}
+	};
+}
+async function resolvePageMetadata(frontmatter, source, config) {
+	if (frontmatter.editUrl === void 0 && config.editLink) frontmatter.editUrl = `${config.editLink.baseUrl.endsWith("/") ? config.editLink.baseUrl : `${config.editLink.baseUrl}/`}${(source.editPath ?? source.sourcePath).replace(/^\/+/, "")}`;
+	if (frontmatter.lastUpdated === false) return;
+	if (frontmatter.lastUpdated === void 0 && config.lastUpdated === false) return;
+	if (frontmatter.lastUpdated instanceof Date) return;
+	try {
+		const { stdout } = await execFileAsync("git", [
+			"log",
+			"-1",
+			"--format=%ct",
+			"--",
+			source.absolutePath
+		], { cwd: source.sourceRoot });
+		const timestamp = Number(stdout.trim());
+		if (Number.isFinite(timestamp) && timestamp > 0) frontmatter.lastUpdated = /* @__PURE__ */ new Date(timestamp * 1e3);
+	} catch {}
+}
+async function transformEntry(entry, absoluteMap, routeMap, repositoryMap, config, diagnostics) {
+	sanitizeUntrustedFrontmatter(entry, config, diagnostics);
+	const ast = cloneAst(entry.ast);
+	if (config.markdown.stripLeadingBadges) stripLeadingBadgeBlock(ast);
+	removeRenderedTitle(ast, entry.title);
+	const htmlTasks = [];
+	visit(ast, "html", (node) => {
+		const policy = rawHtmlPolicy(entry, config);
+		if (policy === "allow") return;
+		if (policy === "sanitize") {
+			htmlTasks.push(sanitizeMarkup(node.value, async (url, kind) => {
+				const reference = {
+					type: "link",
+					url,
+					children: [],
+					...node.position ? { position: node.position } : {}
+				};
+				if (kind === "link") await rewriteLink(reference, entry, absoluteMap, routeMap, repositoryMap, config, diagnostics);
+				else {
+					const image = {
+						type: "image",
+						url,
+						alt: "",
+						...node.position ? { position: node.position } : {}
+					};
+					await rewriteAsset(image, entry, config, diagnostics);
+					reference.url = image.url;
+				}
+				return reference.url;
+			}).then((html) => {
+				node.value = html;
+			}));
+			return;
+		}
+		diagnostics.push({
+			code: policy === "reject" ? "DOCS_RAW_HTML_REJECTED" : "DOCS_RAW_HTML_STRIPPED",
+			severity: policy === "reject" ? "error" : "warning",
+			message: `Raw HTML was ${policy === "reject" ? "rejected" : "removed"}: ${entry.sourcePath}.`,
+			file: entry.sourcePath,
+			...lineData(node)
+		});
+		node.value = "";
+	});
+	await Promise.all(htmlTasks);
+	const referenceKinds = /* @__PURE__ */ new Map();
+	visit(ast, (node) => {
+		if (node.type !== "linkReference" && node.type !== "imageReference") return;
+		const key = node.identifier.toLowerCase();
+		const kind = node.type === "imageReference" ? "image" : "link";
+		const previous = referenceKinds.get(key);
+		referenceKinds.set(key, previous && previous !== kind ? "mixed" : kind);
+	});
+	const linkTasks = [];
+	visit(ast, (node) => {
+		if (node.type === "link") linkTasks.push(rewriteLink(node, entry, absoluteMap, routeMap, repositoryMap, config, diagnostics));
+		else if (node.type === "image") linkTasks.push(rewriteAsset(node, entry, config, diagnostics));
+		else if (node.type === "definition") {
+			const kind = referenceKinds.get(node.identifier.toLowerCase());
+			if (kind === "image") linkTasks.push(rewriteAsset(node, entry, config, diagnostics));
+			else if (kind === "link") linkTasks.push(rewriteLink(node, entry, absoluteMap, routeMap, repositoryMap, config, diagnostics));
+			else if (kind === "mixed") linkTasks.push(rewriteDefinition(node, entry, absoluteMap, routeMap, repositoryMap, config, diagnostics));
+		}
+	});
+	await Promise.all(linkTasks);
+	await rewriteFrontmatterReferences(entry, absoluteMap, routeMap, repositoryMap, config, diagnostics);
+	entry.ast = ast;
+	entry.transformedBody = serializeMarkdown(ast, { mdx: extname(entry.sourcePath).toLowerCase() === ".mdx" });
+}
+function sanitizeUntrustedFrontmatter(entry, config, diagnostics) {
+	if (entry.trust !== "markdown") return;
+	let removed = false;
+	const plainText = (value) => {
+		const sanitized = value.replace(/<!--[\s\S]*?-->|<[^>]*>/g, "");
+		if (sanitized !== value) removed = true;
+		return sanitized;
+	};
+	entry.title = plainText(entry.title);
+	if (entry.frontmatter.title !== void 0) entry.frontmatter.title = plainText(entry.frontmatter.title);
+	const hero = entry.frontmatter.hero;
+	if (hero?.title !== void 0) hero.title = plainText(hero.title);
+	if (hero?.tagline !== void 0) hero.tagline = plainText(hero.tagline);
+	if (hero?.image && "html" in hero.image) {
+		delete hero.image;
+		removed = true;
+	}
+	if (entry.frontmatter.banner) entry.frontmatter.banner.content = plainText(entry.frontmatter.banner.content);
+	if (entry.frontmatter.head) {
+		delete entry.frontmatter.head;
+		removed = true;
+	}
+	if (removed) diagnostics.push({
+		code: config.markdown.rawHtml === "reject" ? "DOCS_RAW_HTML_REJECTED" : "DOCS_UNTRUSTED_HTML",
+		severity: config.markdown.rawHtml === "reject" ? "error" : "warning",
+		message: config.markdown.rawHtml === "reject" ? `HTML-capable frontmatter is not allowed by markdown.rawHtml: ${entry.sourcePath}.` : "HTML-capable frontmatter was sanitized in package Markdown. Use trust: 'mdx' only for packages you trust.",
+		file: entry.sourcePath
+	});
+}
+function rawHtmlPolicy(entry, config) {
+	if (config.markdown.rawHtml === "reject") return "reject";
+	if (config.markdown.rawHtml === "strip") return "strip";
+	return entry.trust === "markdown" ? "sanitize" : config.markdown.rawHtml;
+}
+async function rewriteFrontmatterReferences(entry, absoluteMap, routeMap, repositoryMap, config, diagnostics) {
+	for (const action of entry.frontmatter.hero?.actions ?? []) {
+		const node = {
+			type: "link",
+			url: action.link,
+			children: []
+		};
+		await rewriteLink(node, entry, absoluteMap, routeMap, repositoryMap, config, diagnostics);
+		action.link = node.url;
+	}
+	const image = entry.frontmatter.hero?.image;
+	if (!image || "html" in image) return;
+	if ("file" in image) {
+		image.file = await rewriteFrontmatterAsset(image.file, entry, config, diagnostics);
+		return;
+	}
+	const [dark, light] = await Promise.all([rewriteFrontmatterAsset(image.dark, entry, config, diagnostics), rewriteFrontmatterAsset(image.light, entry, config, diagnostics)]);
+	image.dark = dark;
+	image.light = light;
+}
+async function rewriteFrontmatterAsset(url, entry, config, diagnostics) {
+	const asset = await materializeAsset(url, entry, config, diagnostics, {});
+	entry.assets.push(asset);
+	return asset.resolved ?? url;
+}
+async function rewriteLink(node, entry, absoluteMap, routeMap, repositoryMap, config, diagnostics) {
+	const reference = {
+		original: node.url,
+		...lineData(node)
+	};
+	entry.links.push(reference);
+	if (node.url.startsWith("source:")) {
+		const { pathname, query, fragment } = splitReference(node.url.slice(7));
+		const slash = pathname.indexOf("/");
+		const sourceId = slash < 0 ? pathname : pathname.slice(0, slash);
+		const sourcePath = safeDecode(pathname.slice(slash + 1));
+		const target = [...absoluteMap.values()].flat().find((candidate) => candidate.sourceId === sourceId && candidate.sourcePath === sourcePath);
+		if (!target || slash < 0) missingLink(diagnostics, entry, node, node.url, config);
+		else {
+			node.url = `${withBase(target.route, config.build.base)}${query}${fragment ? `#${fragment}` : ""}`;
+			reference.resolved = node.url;
+			reference.targetSource = target.sourcePath;
+			validateFragment(fragment, target, entry, node, diagnostics, config);
+		}
+		return;
+	}
+	if (unsafeProtocol(node.url)) {
+		diagnostic(diagnostics, "DOCS_LINK_UNSAFE", `Unsafe URL protocol: ${node.url}.`, entry, node);
+		return;
+	}
+	if (isExternal(node.url)) {
+		const target = config.content.localizeRepositoryLinks ? localizedRepositoryTarget(node.url, entry, absoluteMap, repositoryMap.get(entry.id)) : void 0;
+		if (!target) return;
+		const { query, fragment } = splitReference(node.url);
+		node.url = `${withBase(target.route, config.build.base)}${query}${fragment ? `#${fragment}` : ""}`;
+		reference.resolved = node.url;
+		reference.targetSource = target.sourcePath;
+		if (fragment) reference.fragment = fragment;
+		validateFragment(fragment, target, entry, node, diagnostics, config);
+		return;
+	}
+	if (node.url.startsWith("#")) return;
+	const { pathname, query, fragment } = splitReference(node.url);
+	if (pathname.startsWith("/")) {
+		const target = routeMap.get(normalizeRoute(pathname));
+		if (!target) missingLink(diagnostics, entry, node, node.url, config);
+		else {
+			node.url = `${withBase(target.route, config.build.base)}${query}${fragment ? `#${fragment}` : ""}`;
+			reference.resolved = node.url;
+			reference.targetSource = target.sourcePath;
+			if (fragment) reference.fragment = fragment;
+			validateFragment(fragment, target, entry, node, diagnostics, config);
+		}
+		return;
+	}
+	const decoded = safeDecode(pathname);
+	const targetPath = resolve(dirname(entry.absolutePath), decoded);
+	if (!inside(entry.sourceRoot, targetPath)) {
+		diagnostic(diagnostics, "DOCS_SOURCE_OUTSIDE_ROOT", `Link escapes its allowed source root: ${node.url}.`, entry, node);
+		return;
+	}
+	const target = findDocument(targetPath, absoluteMap, entry.sourceId);
+	if (!target) {
+		if (documentMatches(targetPath, absoluteMap).length > 1) {
+			diagnostic(diagnostics, "DOCS_AMBIGUOUS_LINK", `Link matches multiple source mounts: ${node.url}. Use source:<id>/<path> to choose a source.`, entry, node);
+			return;
+		}
+		if (await isFile(targetPath)) {
+			const asset = await materializeAsset(node.url, entry, config, diagnostics, node);
+			if (asset.resolved) {
+				node.url = asset.resolved;
+				reference.resolved = asset.resolved;
+			}
+			entry.assets.push(asset);
+			return;
+		}
+		missingLink(diagnostics, entry, node, node.url, config);
+		return;
+	}
+	node.url = `${withBase(target.route, config.build.base)}${query}${fragment ? `#${fragment}` : ""}`;
+	reference.resolved = node.url;
+	reference.targetSource = target.sourcePath;
+	if (fragment) reference.fragment = fragment;
+	validateFragment(fragment, target, entry, node, diagnostics, config);
+}
+async function rewriteAsset(node, entry, config, diagnostics) {
+	const asset = await materializeAsset(node.url, entry, config, diagnostics, node);
+	entry.assets.push(asset);
+	if (asset.resolved) node.url = asset.resolved;
+}
+async function materializeAsset(url, entry, config, diagnostics, node) {
+	const asset = {
+		original: url,
+		...lineData(node)
+	};
+	if (unsafeProtocol(url)) {
+		diagnostic(diagnostics, "DOCS_ASSET_UNSAFE", `Unsafe asset URL: ${url}.`, entry, node);
+		return asset;
+	}
+	if (isExternal(url) || url.startsWith("#")) return asset;
+	const { pathname, query, fragment } = splitReference(url);
+	const absolute = resolve(dirname(entry.absolutePath), safeDecode(pathname));
+	if (!inside(entry.sourceRoot, absolute)) {
+		diagnostic(diagnostics, "DOCS_SOURCE_OUTSIDE_ROOT", `Asset escapes its allowed source root: ${url}.`, entry, node);
+		return asset;
+	}
+	try {
+		const info = await stat(absolute);
+		if (!info.isFile()) throw new Error("not a file");
+		if (info.size > config.build.maxAssetBytes) throw new Error(`asset exceeds ${config.build.maxAssetBytes} bytes`);
+		const hash = createHash("sha256").update(await readFile(absolute)).digest("hex").slice(0, 12);
+		const publicPath = withBase(`/_tasty-assets/${hash}-${basename(absolute)}`, config.build.base);
+		const resolved = `${publicPath}${query}${fragment ? `#${fragment}` : ""}`;
+		Object.assign(asset, {
+			resolved,
+			sourcePath: absolute,
+			publicPath,
+			hash,
+			bytes: info.size
+		});
+	} catch (error) {
+		diagnostic(diagnostics, "DOCS_ASSET_NOT_FOUND", `Asset not found or invalid: ${url} (${errorMessage(error)}).`, entry, node);
+	}
+	return asset;
+}
+async function rewriteDefinition(node, entry, absoluteMap, routeMap, repositoryMap, config, diagnostics) {
+	const { pathname } = splitReference(node.url);
+	if (documentMatches(resolve(dirname(entry.absolutePath), safeDecode(pathname)), absoluteMap).length > 0 || node.url.startsWith("source:") || pathname.startsWith("/")) await rewriteLink(node, entry, absoluteMap, routeMap, repositoryMap, config, diagnostics);
+	else await rewriteAsset(node, entry, config, diagnostics);
+}
+function findDocument(path, absoluteMap, sourceId) {
+	const matches = documentMatches(path, absoluteMap);
+	return matches.find((item) => item.sourceId === sourceId) ?? (matches.length === 1 ? matches[0] : void 0);
+}
+function documentMatches(path, absoluteMap) {
+	const candidates = [
+		path,
+		...MARKDOWN_EXTENSIONS.map((extension) => `${path}${extension}`),
+		...MARKDOWN_EXTENSIONS.map((extension) => resolve(path, `README${extension}`)),
+		...MARKDOWN_EXTENSIONS.map((extension) => resolve(path, `index${extension}`))
+	];
+	for (const candidate of candidates) {
+		const matches = absoluteMap.get(normalizeFs(candidate)) ?? [];
+		if (matches.length) return matches;
+	}
+	return [];
+}
+function validateFragment(fragment, target, source, node, diagnostics, config) {
+	if (!fragment) return;
+	const decoded = safeDecode(fragment);
+	if (!target.headings.some((heading) => heading.slug === decoded)) diagnostics.push({
+		code: "DOCS_FRAGMENT_NOT_FOUND",
+		severity: config.build.ci ? "error" : "warning",
+		message: `Heading fragment #${fragment} does not exist on ${target.route}.`,
+		file: source.sourcePath,
+		...lineData(node),
+		hint: `Known headings: ${target.headings.map((heading) => `#${heading.slug}`).join(", ") || "(none)"}.`
+	});
+}
+function missingLink(diagnostics, entry, node, url, config) {
+	diagnostics.push({
+		code: "DOCS_LINK_NOT_FOUND",
+		severity: config.build.strict ? "error" : "warning",
+		message: `Internal link target not found: ${url}.`,
+		file: entry.sourcePath,
+		...lineData(node)
+	});
+}
+function validateNavigation(items, routes, diagnostics) {
+	for (const item of items) {
+		if (typeof item === "string") {
+			if (!routes.has(normalizeRoute(item))) diagnostics.push({
+				code: "DOCS_NAV_TARGET_NOT_FOUND",
+				severity: "error",
+				message: `Navigation target does not exist: ${item}.`
+			});
+		} else if (item.link?.startsWith("/") && !routes.has(normalizeRoute(item.link))) diagnostics.push({
+			code: "DOCS_NAV_TARGET_NOT_FOUND",
+			severity: "error",
+			message: `Navigation target does not exist: ${item.link}.`
+		});
+		if (typeof item !== "string" && "items" in item) validateNavigation(item.items, routes, diagnostics);
+	}
+}
+function normalizeRoute(route) {
+	const segments = (route.split(/[?#]/, 1)[0]?.replace(/\\/g, "/").replace(/\/{2,}/g, "/") ?? "/").split("/").filter(Boolean);
+	if (segments.some((segment) => segment === "..")) throw new Error(`Route may not contain "..": ${route}.`);
+	const normalized = `/${segments.join("/")}`;
+	return normalized === "/" ? "/" : normalized.replace(/\/$/, "");
+}
+function routeForPath(path, base, routeBase) {
+	let relativePath = toPosix(path);
+	if (base) {
+		const normalizedBase = toPosix(base).replace(/^\.\//, "").replace(/\/$/, "");
+		if (relativePath === normalizedBase) relativePath = "";
+		else if (relativePath.startsWith(`${normalizedBase}/`)) relativePath = relativePath.slice(normalizedBase.length + 1);
+	}
+	relativePath = relativePath.replace(/\.(md|mdx)$/i, "");
+	relativePath = relativePath.replace(/(^|\/)README$/i, "$1").replace(/(^|\/)index$/i, "$1");
+	return normalizeRoute(`${routeBase ?? ""}/${relativePath}`);
+}
+function resolveSourcePath(root, path, allowOutsideRoot) {
+	const absolute = isAbsolute(path) ? resolve(path) : resolve(root, path);
+	if (!allowOutsideRoot && !inside(root, absolute)) throw new OutsideRootError(path);
+	return absolute;
+}
+function inside(root, path) {
+	const rel = relative(resolve(root), resolve(path));
+	return rel === "" || !rel.startsWith(`..${sep}`) && rel !== ".." && !isAbsolute(rel);
+}
+function splitReference(url) {
+	const hashIndex = url.indexOf("#");
+	const fragment = hashIndex >= 0 ? url.slice(hashIndex + 1) : "";
+	const withoutHash = hashIndex >= 0 ? url.slice(0, hashIndex) : url;
+	const queryIndex = withoutHash.indexOf("?");
+	return {
+		pathname: queryIndex >= 0 ? withoutHash.slice(0, queryIndex) : withoutHash,
+		query: queryIndex >= 0 ? withoutHash.slice(queryIndex) : "",
+		fragment
+	};
+}
+function isExternal(url) {
+	return /^(?:[a-z][a-z\d+.-]*:|\/\/)/i.test(url);
+}
+function localizedRepositoryTarget(value, entry, entries, metadata) {
+	if (!metadata) return void 0;
+	let link;
+	let repository;
+	try {
+		link = new URL(value);
+		repository = new URL(metadata.url);
+	} catch {
+		return;
+	}
+	const repositoryPath = repository.pathname.replace(/\/+$/, "");
+	if (link.origin !== repository.origin || !link.pathname.startsWith(`${repositoryPath}/`)) return;
+	const repositoryRelative = safeDecode(link.pathname.slice(repositoryPath.length + 1));
+	if (!/^(?:-\/(?:blob|tree|raw)|blob|tree|raw|src)\//.test(repositoryRelative)) return;
+	const directory = metadata.directory?.replace(/^\/+|\/+$/g, "");
+	return [...entries.values()].flat().filter((candidate) => candidate.sourceRoot === entry.sourceRoot).flatMap((candidate) => {
+		const sourcePath = candidate.sourcePath.replace(/^\/+/, "");
+		const paths = [sourcePath];
+		if (/(?:^|\/)(?:README|index)\.mdx?$/i.test(sourcePath)) paths.push(sourcePath.replace(/(?:^|\/)(?:README|index)\.mdx?$/i, ""));
+		const matched = paths.flatMap((path) => [path, ...directory ? [`${directory}/${path}`] : []]).map((path) => path.replace(/\/+$/, "")).filter(Boolean).find((path) => repositoryRelative === path || repositoryRelative.endsWith(`/${path}`));
+		return matched ? [{
+			candidate,
+			length: matched.length
+		}] : [];
+	}).sort((left, right) => Number(right.candidate.sourceId === entry.sourceId) - Number(left.candidate.sourceId === entry.sourceId) || right.length - left.length)[0]?.candidate;
+}
+function repositoryMetadata(repository) {
+	let raw = typeof repository === "string" ? repository : repository?.url;
+	if (!raw) return void 0;
+	raw = raw.replace(/^git\+/, "");
+	const scp = /^git@([^:]+):(.+)$/.exec(raw);
+	if (scp) raw = `https://${scp[1]}/${scp[2]}`;
+	try {
+		let url = new URL(raw);
+		if (url.protocol !== "http:" && url.protocol !== "https:") {
+			if (!url.hostname || !["git:", "ssh:"].includes(url.protocol)) return;
+			url = new URL(`https://${url.hostname}${url.pathname}`);
+		}
+		url.search = "";
+		url.hash = "";
+		url.pathname = url.pathname.replace(/\.git\/?$/, "").replace(/\/+$/, "");
+		const directory = typeof repository === "object" ? repository.directory?.replaceAll("\\", "/").replace(/^\/+|\/+$/g, "") : void 0;
+		return {
+			url: url.href.replace(/\/$/, ""),
+			...directory ? { directory } : {}
+		};
+	} catch {
+		return;
+	}
+}
+function unsafeProtocol(url) {
+	return /^(?:javascript|vbscript|data):/i.test(url.trim());
+}
+function withBase(route, base) {
+	return `${base === "/" ? "" : `/${base.replace(/^\/+|\/+$/g, "")}`}${normalizeRoute(route)}` || "/";
+}
+function titleFromFile(path) {
+	return basename(path, extname(path)).replace(/^README$/i, basename(dirname(path)) || "Documentation").replace(/[-_]+/g, " ").replace(/\b\w/g, (letter) => letter.toUpperCase());
+}
+function diagnostic(diagnostics, code, message, entry, node) {
+	diagnostics.push({
+		code,
+		severity: "error",
+		message,
+		file: entry.sourcePath,
+		...lineData(node)
+	});
+}
+function lineOf(node) {
+	return node.position?.start.line;
+}
+function lineData(node) {
+	const line = lineOf(node);
+	return line === void 0 ? {} : { line };
+}
+function safeDecode(value) {
+	try {
+		return decodeURIComponent(value);
+	} catch {
+		return value;
+	}
+}
+function sourceLabel(source) {
+	if ("file" in source) return source.file;
+	if ("glob" in source) return Array.isArray(source.glob) ? source.glob.join(", ") : source.glob;
+	return source.package;
+}
+function normalizeFs(path) {
+	return resolve(path);
+}
+function toPosix(path) {
+	return path.split(sep).join("/");
+}
+async function isFile(path) {
+	try {
+		return (await stat(path)).isFile();
+	} catch {
+		return false;
+	}
+}
+async function isDirectory(path) {
+	try {
+		return (await stat(path)).isDirectory();
+	} catch {
+		return false;
+	}
+}
+function errorMessage(error) {
+	return error instanceof Error ? error.message : String(error);
+}
+var OutsideRootError = class extends Error {
+	constructor(path) {
+		super(`Source path is outside the repository root: ${path}.`);
+		this.name = "OutsideRootError";
+	}
+};
+function parseFrontmatter(source) {
+	const match = /^(?:\uFEFF)?---[\t ]*\r?\n([\s\S]*?)\r?\n(?:---|\.\.\.)[\t ]*(?:\r?\n|$)/.exec(source);
+	if (!match) return {
+		data: {},
+		content: source
+	};
+	const value = parse(match[1] ?? "");
+	if (value !== null && !isPlainRecord(value)) throw new Error("Markdown frontmatter must be a YAML object.");
+	const data = value ?? {};
+	if (typeof data.lastUpdated === "string" && !Number.isNaN(Date.parse(data.lastUpdated))) data.lastUpdated = new Date(data.lastUpdated);
+	return {
+		data,
+		content: source.slice(match[0].length)
+	};
+}
+function isPlainRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function validateFrontmatter(value, file, diagnostics) {
+	const record = value;
+	const error = (message) => diagnostics.push({
+		code: "DOCS_FRONTMATTER_INVALID",
+		severity: "error",
+		message,
+		file
+	});
+	if (value.aliases !== void 0 && (!Array.isArray(value.aliases) || value.aliases.some((alias) => typeof alias !== "string"))) error("aliases must be an array of route strings.");
+	for (const key of [
+		"title",
+		"description",
+		"slug"
+	]) if (record[key] !== void 0 && typeof record[key] !== "string") error(`${key} must be a string.`);
+	for (const key of ["draft", "pagefind"]) if (record[key] !== void 0 && typeof record[key] !== "boolean") error(`${key} must be a boolean.`);
+	if (record.template !== void 0 && record.template !== "doc" && record.template !== "splash") error("template must be \"doc\" or \"splash\".");
+	for (const key of ["sidebar", "tableOfContents"]) {
+		const entry = record[key];
+		if (entry !== void 0 && entry !== false && !isPlainRecord(entry)) error(`${key} must be false or an object.`);
+	}
+	if (isPlainRecord(record.sidebar)) {
+		validateOptionalStrings(record.sidebar, ["label", "group"], "sidebar", error);
+		if (record.sidebar.order !== void 0 && typeof record.sidebar.order !== "number") error("sidebar.order must be a number.");
+	}
+	if (isPlainRecord(record.tableOfContents)) for (const key of ["minHeadingLevel", "maxHeadingLevel"]) {
+		const level = record.tableOfContents[key];
+		if (level !== void 0 && (!Number.isInteger(level) || Number(level) < 1 || Number(level) > 6)) error(`tableOfContents.${key} must be an integer from 1 to 6.`);
+	}
+	if (record.editUrl !== void 0 && record.editUrl !== false && typeof record.editUrl !== "string") error("editUrl must be false or a string.");
+	if (record.lastUpdated !== void 0 && typeof record.lastUpdated !== "boolean" && !(record.lastUpdated instanceof Date)) error("lastUpdated must be a date or boolean.");
+	if (record.hero !== void 0) {
+		if (!isPlainRecord(record.hero)) error("hero must be an object.");
+		else validateHero(record.hero, error);
+	}
+	if (record.banner !== void 0) {
+		if (!isPlainRecord(record.banner)) error("banner must be an object.");
+		else if (typeof record.banner.content !== "string") error("banner.content must be a string.");
+	}
+	for (const key of ["prev", "next"]) {
+		const adjacent = record[key];
+		if (adjacent !== void 0 && adjacent !== false && typeof adjacent !== "string" && !isPlainRecord(adjacent)) error(`${key} must be false, a string, or an object.`);
+		else if (isPlainRecord(adjacent)) validateOptionalStrings(adjacent, ["link", "label"], key, error);
+	}
+	if (record.head !== void 0 && (!Array.isArray(record.head) || !record.head.every(isPlainRecord))) error("head must be an array of objects.");
+}
+function validateHero(hero, error) {
+	validateOptionalStrings(hero, ["title", "tagline"], "hero", error);
+	if (hero.image !== void 0) {
+		if (!isPlainRecord(hero.image)) error("hero.image must be an object.");
+		else {
+			const image = hero.image;
+			if ([
+				"html",
+				"file",
+				"dark"
+			].filter((key) => image[key] !== void 0).length !== 1) error("hero.image must define exactly one of html, file, or dark/light.");
+			for (const key of [
+				"html",
+				"file",
+				"dark",
+				"light",
+				"alt"
+			]) if (image[key] !== void 0 && typeof image[key] !== "string") error(`hero.image.${key} must be a string.`);
+			if (image.dark !== void 0 && typeof image.light !== "string") error("hero.image.light must accompany hero.image.dark.");
+			if (image.light !== void 0 && typeof image.dark !== "string") error("hero.image.dark must accompany hero.image.light.");
+		}
+	}
+	if (hero.actions !== void 0) {
+		if (!Array.isArray(hero.actions)) error("hero.actions must be an array.");
+		else for (const [index, action] of hero.actions.entries()) {
+			if (!isPlainRecord(action)) {
+				error(`hero.actions[${index}] must be an object.`);
+				continue;
+			}
+			for (const key of ["text", "link"]) if (typeof action[key] !== "string") error(`hero.actions[${index}].${key} must be a string.`);
+			if (action.variant !== void 0 && ![
+				"primary",
+				"secondary",
+				"minimal"
+			].includes(String(action.variant))) error(`hero.actions[${index}].variant must be primary, secondary, or minimal.`);
+		}
+	}
+}
+function validateOptionalStrings(record, keys, prefix, error) {
+	for (const key of keys) if (record[key] !== void 0 && typeof record[key] !== "string") error(`${prefix}.${key} must be a string.`);
+}
+//#endregion
+//#region src/validation/index.ts
+var DocsValidationError = class extends Error {
+	diagnostics;
+	constructor(diagnostics) {
+		super(formatDiagnostics(diagnostics));
+		this.name = "DocsValidationError";
+		this.diagnostics = diagnostics;
+	}
+};
+function validateDocs(graph) {
+	return [...graph.diagnostics];
+}
+function assertValidDocs(graph) {
+	const errors = graph.diagnostics.filter((diagnostic) => diagnostic.severity === "error");
+	if (errors.length > 0) throw new DocsValidationError(errors);
+}
+function formatDiagnostics(diagnostics, json = false) {
+	if (json) return JSON.stringify(diagnostics, null, 2);
+	return diagnostics.map((diagnostic) => {
+		const location = diagnostic.file ? `${diagnostic.file}${diagnostic.line ? `:${diagnostic.line}` : ""}: ` : "";
+		const hint = diagnostic.hint ? `\n  hint: ${diagnostic.hint}` : "";
+		return `${diagnostic.severity.toUpperCase()} ${diagnostic.code} ${location}${diagnostic.message}${hint}`;
+	}).join("\n");
+}
+//#endregion
+//#region src/content/index.ts
+function createDocsLoader(config, options = {}) {
+	return {
+		name: "@tenphi/docs",
+		async load(context) {
+			const graph = await createDocsGraph({
+				...options,
+				...config ? { config } : {}
+			});
+			assertValidDocs(graph);
+			context.store.clear();
+			for (const entry of graph.entries) {
+				const loaderEntry = toLoaderEntry(entry);
+				const filePath = starlightFilePath(entry, context.config);
+				const data = context.parseData ? await context.parseData({
+					id: loaderEntry.id,
+					data: loaderEntry.data,
+					filePath
+				}) : loaderEntry.data;
+				const rendered = await context.renderMarkdown?.(entry.transformedBody, { fileURL: pathToFileURL(entry.absolutePath) });
+				context.store.set({
+					...loaderEntry,
+					data,
+					filePath,
+					...context.generateDigest ? { digest: context.generateDigest(entry.transformedBody) } : {},
+					...rendered ? {
+						rendered,
+						assetImports: rendered.metadata?.imagePaths ?? []
+					} : {}
+				});
+			}
+			context.logger?.info(`Loaded ${graph.entries.length} Cookbook pages.`);
+		}
+	};
+}
+function starlightFilePath(entry, config) {
+	const id = entry.route === "/" ? "index" : entry.route.slice(1);
+	const extension = extname(entry.sourcePath).toLowerCase() === ".mdx" ? ".mdx" : ".md";
+	if (!config) return `src/content/docs/${id}${extension}`;
+	const root = toPath(config.root);
+	const srcDir = toPath(config.srcDir);
+	return relative(root, join(srcDir, "content", "docs", `${id}${extension}`)).split(sep).join("/");
+}
+function toPath(value) {
+	return typeof value === "string" ? value : fileURLToPath(value);
+}
+function toLoaderEntry(entry) {
+	return {
+		id: entry.route === "/" ? "index" : entry.route.slice(1),
+		data: {
+			title: entry.title,
+			draft: entry.frontmatter.draft ?? false,
+			...entry.description ? { description: entry.description } : {},
+			...entry.frontmatter,
+			cookbook: {
+				sourcePath: entry.sourcePath,
+				route: entry.route,
+				headings: entry.headings
+			}
+		},
+		body: entry.transformedBody
+	};
+}
+//#endregion
+export { resolvePackageLock as _, validateDocs as a, routeForPath as c, discoverPackage as d, lockForSource as f, reconcileDocsLock as g, readDocsLock as h, formatDiagnostics as i, assertSafePackagePath as l, packageNameFromSpecifier as m, DocsValidationError as n, createDocsGraph as o, materializePackage as p, assertValidDocs as r, normalizeRoute as s, createDocsLoader as t, defaultLock as u, validateLock as v, writeDocsLock as y };
+
+//# sourceMappingURL=content-Btz1o52C.js.map