@tenphi/renderer 0.19.0

package/dist/index.js

@@ -0,0 +1,1648 @@
+import { navigationPath, resolveNavigationLayout } from "./navigation.js";
+import { localeAlternates } from "./localization.js";
+import { DEFAULT_THEME_TOKENS, DEFAULT_TYPOGRAPHY_PRESETS, resolveThemeTokens, resolveTypographyPresets } from "./theme/defaults.js";
+import { configureCodeHighlighting, cookbookShikiConfig } from "./theme/shiki-theme.js";
+import { TASTY_UNITS, tastyTokens } from "./theme/tasty-config.js";
+import { a as resolveLegacyAnatomyStyles, n as cookbookStates, o as unusedCustomStyleNames, r as configureComponentStyles } from "./tasty-states-BDKIbfw2.js";
+import { agentPagePath } from "./page-metadata.js";
+import { createRequire } from "node:module";
+import { cp, mkdir, readFile, readdir, rename, stat, unlink, writeFile } from "node:fs/promises";
+import { dirname, extname, isAbsolute, join, resolve } from "node:path";
+import sharp from "sharp";
+import { DOCS_FRONTMATTER_KEYS, assertValidDocs, createDocsGraph, renderAgentMarkdown, resolveColorTheme, resolveDocsProject } from "@tenphi/docs";
+import { createHash, randomUUID } from "node:crypto";
+import { fromHtml } from "hast-util-from-html";
+import { existsSync } from "node:fs";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import mdx from "@astrojs/mdx";
+import * as pagefind from "pagefind";
+import sitemap from "@astrojs/sitemap";
+import { configure } from "@tenphi/tasty/core";
+import { tastyIntegration } from "@tenphi/tasty/ssr/astro";
+import { renderMermaidSVG } from "beautiful-mermaid";
+//#region src/hero-image.ts
+const metadataCache = /* @__PURE__ */ new Map();
+async function resolveHeroMetadata(entry) {
+	const hero = entry.frontmatter.hero;
+	const image = hero?.image;
+	if (!hero || !image || "html" in image) return hero;
+	const read = async (src) => {
+		const asset = entry.assets.find((asset) => asset.resolved === src || asset.publicPath === src);
+		let dimensions;
+		if (asset?.sourcePath) {
+			const file = await stat(asset.sourcePath);
+			const key = `${asset.sourcePath}:${file.mtimeMs}:${file.size}`;
+			if (!metadataCache.has(key)) metadataCache.set(key, sharp(asset.sourcePath).metadata().then((meta) => {
+				const { width, height } = meta.autoOrient ?? meta;
+				if (!width || !height || !meta.format) throw Error(`Cannot determine hero image dimensions for ${entry.sourcePath}.`);
+				return {
+					width,
+					height,
+					format: meta.format
+				};
+			}));
+			dimensions = await metadataCache.get(key);
+		} else if (image.width && image.height) dimensions = {
+			width: image.width,
+			height: image.height,
+			format: extname(src.split(/[?#]/, 1)[0] ?? src).slice(1).replace("jpg", "jpeg") || "png"
+		};
+		else throw Error(`Hero image ${src} in ${entry.sourcePath} needs width and height, or a relative local file whose dimensions can be read.`);
+		if (image.width && image.height && Math.abs(image.width / image.height - dimensions.width / dimensions.height) > .01) throw Error(`hero.image width/height in ${entry.sourcePath} must preserve the source aspect ratio.`);
+		return {
+			src,
+			...dimensions
+		};
+	};
+	if ("file" in image) return {
+		...hero,
+		image: {
+			...image,
+			file: await read(image.file)
+		}
+	};
+	const [dark, light] = await Promise.all([read(image.dark), read(image.light)]);
+	if (Math.abs(dark.width / dark.height - light.width / light.height) > .01) throw Error(`Hero light/dark images in ${entry.sourcePath} must have the same aspect ratio.`);
+	return {
+		...hero,
+		image: {
+			...image,
+			dark,
+			light
+		}
+	};
+}
+//#endregion
+//#region src/plugin-contract.ts
+async function validatePluginFrontmatter(entries, schema) {
+	if (!schema) return;
+	for (const entry of entries) try {
+		const parsed = "parseAsync" in schema ? await schema.parseAsync(structuredClone(entry.metadata)) : schema.parse(structuredClone(entry.metadata));
+		if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) throw new Error("The schema must return a frontmatter object.");
+		for (const key of Object.keys(parsed)) if (DOCS_FRONTMATTER_KEYS.has(key)) throw new Error(`Custom schemas cannot set reserved field "${key}". Set it in source frontmatter instead.`);
+		assertJsonMetadata(parsed);
+		entry.metadata = {
+			...entry.metadata,
+			...parsed
+		};
+	} catch (error) {
+		throw new Error(`Invalid plugin frontmatter in ${entry.sourcePath}: ${error instanceof Error ? error.message : String(error)}`);
+	}
+}
+function assertJsonMetadata(value, ancestors = /* @__PURE__ */ new Set()) {
+	if (value === null || typeof value === "string" || typeof value === "boolean") return;
+	if (typeof value === "number" && Number.isFinite(value)) return;
+	if (typeof value !== "object" || value === null || ancestors.has(value) || !Array.isArray(value) && Object.getPrototypeOf(value) !== Object.prototype) throw new Error("Custom metadata must contain only JSON values (no dates, functions, cycles, or undefined).");
+	ancestors.add(value);
+	for (const item of Object.values(value)) assertJsonMetadata(item, ancestors);
+	ancestors.delete(value);
+}
+//#endregion
+//#region src/site-logo.ts
+async function resolveSiteLogo(root, base, site = {}) {
+	if (site.logo === void 0 || site.logo === false) return {
+		logo: site.logo,
+		sourcePaths: [],
+		assets: []
+	};
+	const config = typeof site.logo === "string" ? { src: site.logo } : site.logo;
+	const assets = [];
+	const sourcePaths = [];
+	const image = async (source, role) => {
+		const path = resolve(root, source);
+		const body = await readFile(path).catch(() => {
+			throw new Error(`site.logo.${role}: cannot read local image ${path}.`);
+		});
+		const metadata = await sharp(body, { animated: false }).metadata().catch(() => {
+			throw new Error(`site.logo.${role}: ${path} is not a supported image.`);
+		});
+		const format = metadata.format;
+		if (!format || ![
+			"svg",
+			"png",
+			"jpeg",
+			"webp",
+			"avif",
+			"gif"
+		].includes(format)) throw new Error(`site.logo.${role}: use an SVG, PNG, JPEG, WebP, AVIF, or GIF image.`);
+		const width = config.width ?? (config.height && metadata.width && metadata.height ? config.height * metadata.width / metadata.height : metadata.width);
+		const height = config.height ?? (config.width && metadata.width && metadata.height ? config.width * metadata.height / metadata.width : metadata.height);
+		if (!width || !height) throw new Error(`site.logo.${role}: provide intrinsic width and height for ${path}.`);
+		const outputPath = `_cookbook/logos/${createHash("sha256").update(body).digest("hex").slice(0, 20)}.${format === "jpeg" ? "jpg" : format}`;
+		const publicPath = `${base.replace(/\/$/, "")}/${outputPath}`;
+		sourcePaths.push(path);
+		if (!assets.some((asset) => asset.outputPath === outputPath)) assets.push({
+			body,
+			outputPath,
+			publicPath,
+			contentType: format === "svg" ? "image/svg+xml" : `image/${format}`
+		});
+		return {
+			src: publicPath,
+			width,
+			height
+		};
+	};
+	const light = await image(config.src ?? config.light, config.src ? "src" : "light");
+	const dark = config.dark ? await image(config.dark, "dark") : void 0;
+	if (dark && Math.abs(light.width / light.height - dark.width / dark.height) > .01) throw new Error("site.logo: light and dark variants must have the same aspect ratio to prevent layout shifts. Set matching intrinsic dimensions or use matching artwork.");
+	return {
+		logo: {
+			light,
+			...dark ? { dark } : {},
+			alt: config.alt || site.title || "Documentation",
+			decorative: config.decorative ?? true,
+			...config.href ? { href: config.href } : {}
+		},
+		assets,
+		sourcePaths
+	};
+}
+//#endregion
+//#region src/output-styles.ts
+/** Parse attributes rather than matching text in code, scripts or escaped srcdoc. */
+function assertTastyOutput(html, path) {
+	const tree = fromHtml(html);
+	const visit = (node) => {
+		const props = node.properties ?? {};
+		const stylesheet = node.tagName === "link" && Array.isArray(props.rel) && props.rel.includes("stylesheet");
+		if (node.tagName === "style" || Object.hasOwn(props, "style") || stylesheet && !Object.hasOwn(props, "dataTastySsr")) throw new Error(`Non-Tasty CSS found in ${path}: <${node.tagName}${Object.hasOwn(props, "style") ? " style=…" : ""}>. Use theme.styles or Tasty components; isolate example CSS in a sandboxed Preview.`);
+		if (typeof props.srcDoc === "string" && (!Array.isArray(props.sandbox) || props.sandbox.includes("allow-same-origin"))) assertTastyOutput(props.srcDoc, `${path} (unsandboxed iframe)`);
+		node.children?.forEach((child) => visit(child));
+		if (node.content) visit(node.content);
+	};
+	visit(tree);
+}
+//#endregion
+//#region src/markdown/rehype-mermaid.ts
+const sourceStyleDirective = /^\s*(?:classDef|style|linkStyle)\s+.*$/gim;
+const accessibilityDirective = /^\s*acc(?:Title|Descr):\s*.*$/gim;
+const svgStyleBlock = /\s*<style>[\s\S]*?<\/style>\s*/gi;
+const supportedDiagram = /^(?:(?:flowchart|graph)(?:\s+(?:TB|TD|BT|RL|LR))?|stateDiagram(?:-v2)?|sequenceDiagram|classDiagram|erDiagram)\b/i;
+/** Render supported Mermaid fences to theme-responsive SVG at build time. */
+function rehypeMermaid() {
+	return (tree) => {
+		replaceMermaidCodeBlocks(tree);
+	};
+}
+/** Sätteri adapter for Astro's default Markdown processor. */
+const satteriMermaid = {
+	name: "cookbook:mermaid",
+	element: {
+		filter: ["pre"],
+		visit(node, context) {
+			if (!isMermaidCodeBlock(node)) return;
+			try {
+				context.replaceNode(node, {
+					type: "raw",
+					value: renderMermaidElement(context.textContent(node))
+				});
+			} catch {
+				context.setProperty(node, "data-mermaid-state", "error");
+			}
+		}
+	}
+};
+function replaceMermaidCodeBlocks(parent) {
+	if (!parent.children) return;
+	for (const [index, child] of parent.children.entries()) {
+		if (isMermaidCodeBlock(child)) {
+			const source = textContent(child);
+			try {
+				parent.children[index] = {
+					type: "raw",
+					value: renderMermaidElement(source)
+				};
+			} catch {
+				child.properties = {
+					...child.properties,
+					"data-mermaid-state": "error"
+				};
+			}
+			continue;
+		}
+		replaceMermaidCodeBlocks(child);
+	}
+}
+function renderMermaidElement(source) {
+	return `<div class="td-mermaid" data-mermaid-state="ready">${accessibleSvg(render(source), source)}</div>`;
+}
+function isMermaidCodeBlock(node) {
+	if (node.type !== "element" || node.tagName !== "pre") return false;
+	return node.properties?.dataLanguage === "mermaid" || node.properties?.["data-language"] === "mermaid";
+}
+function render(source) {
+	const header = source.split("\n").map((line) => line.trim()).find((line) => line && !line.startsWith("%%") && !/^acc(?:Title|Descr):/i.test(line));
+	if (!header || !supportedDiagram.test(header)) throw new Error("Unsupported Mermaid diagram type");
+	const safeSource = source.replace(sourceStyleDirective, "").replace(accessibilityDirective, "");
+	return renderMermaidSVG(safeSource, {
+		bg: "var(--surface-2-color)",
+		fg: "var(--text-color)",
+		line: "var(--text-soft-color)",
+		accent: "var(--accent-text-color)",
+		muted: "var(--text-soft-color)",
+		surface: "var(--surface-color)",
+		border: "var(--border-strong-color)",
+		font: "var(--body-font-family)",
+		transparent: true
+	}).replace(svgStyleBlock, "").replace(/(<svg\b[^>]*?)\sstyle="[^"]*"/, "$1");
+}
+function accessibleSvg(svg, source) {
+	const title = directive(source, "accTitle") ?? "Diagram";
+	const description = directive(source, "accDescr") ?? "Rendered from a Mermaid code block.";
+	return svg.replace("<svg ", `<svg role="img" aria-label="${escapeAttribute(title)}" `).replace(/(<svg\b[^>]*>)/, `$1<title>${escapeText(title)}</title><desc>${escapeText(description)}</desc>`);
+}
+function directive(source, name) {
+	return source.match(new RegExp(`^\\s*${name}:\\s*(.+)$`, "im"))?.[1]?.trim();
+}
+function textContent(node) {
+	if (node.type === "text") return node.value ?? "";
+	return node.children?.map(textContent).join("") ?? "";
+}
+function escapeAttribute(value) {
+	return escapeText(value).replaceAll("\"", "&quot;").replaceAll("'", "&#39;");
+}
+function escapeText(value) {
+	return value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;");
+}
+//#endregion
+//#region src/markdown/rehype-alerts.ts
+const alerts = {
+	NOTE: {
+		kind: "note",
+		title: "Note"
+	},
+	TIP: {
+		kind: "tip",
+		title: "Tip"
+	},
+	IMPORTANT: {
+		kind: "tip",
+		title: "Important"
+	},
+	WARNING: {
+		kind: "caution",
+		title: "Warning"
+	},
+	CAUTION: {
+		kind: "danger",
+		title: "Caution"
+	}
+};
+/** Keep GitHub alert syntax useful in repository Markdown and MDX. */
+function rehypeAlerts() {
+	return (tree) => visit(tree);
+}
+const satteriAlerts = {
+	name: "cookbook:alerts",
+	element: {
+		filter: ["blockquote"],
+		visit(node, context) {
+			const replacement = alert(node);
+			if (replacement) context.replaceNode(node, replacement);
+		}
+	}
+};
+function visit(parent) {
+	if (!parent.children) return;
+	for (const [index, child] of parent.children.entries()) {
+		const replacement = alert(child);
+		if (replacement) parent.children[index] = replacement;
+		else visit(child);
+	}
+}
+function alert(blockquote) {
+	if (blockquote.type !== "element" || blockquote.tagName !== "blockquote") return;
+	const first = blockquote.children?.find((child) => child.type === "element");
+	if (first?.tagName !== "p") return;
+	const marker = first.children?.find((child) => child.type === "text");
+	if (!marker?.value) return;
+	const match = /^\s*\[!(NOTE|TIP|IMPORTANT|WARNING|CAUTION)\](?:\s|$)/i.exec(marker.value);
+	if (!match) return;
+	const { kind, title } = alerts[match[1].toUpperCase()];
+	const updatedFirst = {
+		...first,
+		children: first.children.map((child) => child === marker ? {
+			...child,
+			value: child.value.slice(match[0].length).trimStart()
+		} : child)
+	};
+	const body = blockquote.children?.map((child) => child === first ? updatedFirst : child).filter((child) => child !== updatedFirst || updatedFirst.children?.some((part) => part.type !== "text" || Boolean(part.value?.trim()))) ?? [];
+	return {
+		type: "element",
+		tagName: "aside",
+		properties: {
+			className: ["cookbook-alert", `cookbook-alert--${kind}`],
+			ariaLabel: title
+		},
+		children: [{
+			type: "element",
+			tagName: "p",
+			properties: { className: ["cookbook-alert__title"] },
+			children: [{
+				type: "text",
+				value: title
+			}]
+		}, {
+			type: "element",
+			tagName: "div",
+			properties: { className: ["cookbook-alert__content"] },
+			children: body
+		}]
+	};
+}
+//#endregion
+//#region src/markdown/rehype-table-scroll.ts
+const containerClass = "td-table-scroll";
+/** Wrap Markdown tables in a dedicated horizontal scroll container. */
+function rehypeTableScroll() {
+	return (tree) => {
+		wrapTables(tree);
+	};
+}
+/** Sätteri adapter for Astro's default Markdown processor. */
+const satteriTableScroll = {
+	name: "cookbook:table-scroll",
+	element: {
+		filter: ["table"],
+		visit(node, context) {
+			context.replaceNode(node, scrollContainer(node));
+		}
+	}
+};
+function wrapTables(parent) {
+	if (!parent.children || isScrollContainer(parent)) return;
+	for (const [index, child] of parent.children.entries()) {
+		if (child.type === "element" && child.tagName === "table") {
+			parent.children[index] = scrollContainer(child);
+			continue;
+		}
+		wrapTables(child);
+	}
+}
+function scrollContainer(table) {
+	return {
+		type: "element",
+		tagName: "div",
+		properties: { className: [containerClass] },
+		children: [table]
+	};
+}
+function isScrollContainer(node) {
+	const className = node.properties?.className;
+	return node.type === "element" && node.tagName === "div" && Array.isArray(className) && className.includes(containerClass);
+}
+//#endregion
+//#region src/markdown/rehype-page-affordances.ts
+/** Add copy controls to rendered Markdown code blocks. */
+function rehypePageAffordances() {
+	return (tree) => addPageAffordances(tree);
+}
+/** Sätteri adapter for Astro's default Markdown processor. */
+const satteriPageAffordances = {
+	name: "cookbook:page-affordances",
+	element: {
+		filter: ["pre"],
+		visit(node, context) {
+			const replacement = pageAffordance(node);
+			if (replacement !== node) context.replaceNode(node, replacement);
+		}
+	}
+};
+function addPageAffordances(parent) {
+	if (!parent.children) return;
+	for (const [index, child] of parent.children.entries()) {
+		const replacement = pageAffordance(child);
+		if (replacement !== child) {
+			parent.children[index] = replacement;
+			continue;
+		}
+		addPageAffordances(child);
+	}
+}
+function pageAffordance(node) {
+	if (isOrdinaryCodeBlock(node)) return codeBlockWithCopy(node);
+	return node;
+}
+function isOrdinaryCodeBlock(node) {
+	if (node.type !== "element" || node.tagName !== "pre") return false;
+	return (node.properties?.dataLanguage ?? node.properties?.["data-language"]) !== "mermaid" && node.children?.[0]?.tagName === "code";
+}
+function codeBlockWithCopy(pre) {
+	return element("cookbook-code-block", {
+		className: ["td-code-block"],
+		dataTastyAnatomy: "MarkdownCodeBlock"
+	}, [pre, element("button", {
+		type: "button",
+		dataCopyCode: "",
+		ariaLabel: "Copy code",
+		title: "Copy code"
+	}, [element("span", {
+		dataCopyIcon: "",
+		ariaHidden: "true"
+	}, [])])]);
+}
+function element(tagName, properties, children) {
+	return {
+		type: "element",
+		tagName,
+		properties,
+		children
+	};
+}
+//#endregion
+//#region src/theme/fonts.ts
+const sharedFonts = globalThis;
+const fallback = {
+	body: "system-ui, sans-serif",
+	heading: "system-ui, sans-serif",
+	code: "ui-monospace, monospace"
+};
+function fontFamilies(fonts = {}) {
+	return Object.fromEntries(Object.entries(fonts).filter(([, font]) => font !== void 0).map(([role, font]) => [role, `'${typeof font === "string" ? font : "google" in font ? font.google : font.family}', ${fallback[role]}`]));
+}
+function configureFontFaces(faces, defaults) {
+	sharedFonts.__tenphiCookbookFontFaces = faces;
+	sharedFonts.__tenphiCookbookDefaultFontUsage = defaults;
+}
+//#endregion
+//#region src/theme/index.ts
+function resolveDocsTheme(theme = {}) {
+	return {
+		...resolveColorTheme(theme),
+		tokens: resolveThemeTokens(theme.tokens),
+		presets: resolveTypographyPresets(theme.presets, fontFamilies(theme.fonts))
+	};
+}
+//#endregion
+//#region src/theme/font-cache.ts
+const fontHash = (bytes) => createHash("sha256").update(bytes).digest("hex");
+const userAgent = "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36";
+/** Content-verified, atomic cache entries. Cache keys include the fixed browser profile. */
+function createFontFetcher(directory, mode = "reuse", fetchFont = fetch) {
+	const pending = /* @__PURE__ */ new Map();
+	return (url) => {
+		const load = async () => {
+			const key = fontHash(`${userAgent}\n${url}`);
+			const path = directory ? join(directory, `${key}.json`) : void 0;
+			if (path && mode !== "refresh") try {
+				const cached = JSON.parse(await readFile(path, "utf8"));
+				const body = Buffer.from(cached.body, "base64");
+				if (![200, 400].includes(cached.status) || cached.url !== url || fontHash(body) !== cached.sha256) throw new Error("Invalid font cache entry");
+				return {
+					status: cached.status,
+					body
+				};
+			} catch {}
+			if (mode === "offline") throw new Error(`Google font cache is missing or corrupt for ${url}. Run once with theme.fontLoading.cache: "reuse" and preserve the Astro cache directory.`);
+			let response;
+			try {
+				response = await fetchFont(url, {
+					headers: { "User-Agent": userAgent },
+					signal: AbortSignal.timeout(15e3)
+				});
+			} catch (error) {
+				throw new Error(`Could not download Google font resource ${url}: ${String(error)}. Preserve the Astro cache for offline builds, or use local font files.`);
+			}
+			const body = Buffer.from(await response.arrayBuffer());
+			if (![200, 400].includes(response.status)) throw new Error(`Google font request failed (${response.status}): ${url}.`);
+			if (path) {
+				await mkdir(directory, { recursive: true });
+				const temporary = `${path}.${randomUUID()}.tmp`;
+				await writeFile(temporary, JSON.stringify({
+					url,
+					status: response.status,
+					sha256: fontHash(body),
+					body: body.toString("base64")
+				}));
+				await rename(temporary, path);
+			}
+			return {
+				status: response.status,
+				body
+			};
+		};
+		if (!pending.has(url)) pending.set(url, load());
+		return pending.get(url);
+	};
+}
+//#endregion
+//#region src/theme/font-loading.ts
+/** Merge overlapping/touching ranges, as required by the Google CSS2 API. */
+function fontWeightSpans(weights) {
+	return weights.map((weight) => typeof weight === "number" ? [weight, weight] : weight.split(" ").map(Number)).sort((a, b) => a[0] - b[0]).reduce((result, span) => {
+		const previous = result.at(-1);
+		if (previous && span[0] <= previous[1]) previous[1] = Math.max(previous[1], span[1]);
+		else result.push([...span]);
+		return result;
+	}, []);
+}
+function presetWeights(family, presets) {
+	const resolveValue = (value, seen = /* @__PURE__ */ new Set()) => {
+		if (typeof value !== "string") return value;
+		const ref = /^var\(--(.+)-(font-family|bold-font-weight|font-weight)\)$/.exec(value);
+		if (!ref || seen.has(value)) return value;
+		seen.add(value);
+		const key = ref[2] === "font-family" ? "fontFamily" : ref[2] === "font-weight" ? "fontWeight" : "boldFontWeight";
+		return resolveValue(presets[ref[1]]?.[key], seen);
+	};
+	const values = Object.values(presets).flatMap((preset) => {
+		const resolvedFamily = resolveValue(preset.fontFamily);
+		if (typeof resolvedFamily !== "string" || resolvedFamily.split(",")[0]?.trim().replace(/^['"]|['"]$/g, "") !== family) return [];
+		return [resolveValue(preset.fontWeight), resolveValue(preset.boldFontWeight)];
+	}).map((value) => value === "bold" ? 700 : value === "normal" ? 400 : Number(value)).filter((value) => Number.isInteger(value) && value >= 1 && value <= 1e3);
+	return [...new Set(values.length ? values : [400, 700])];
+}
+/** Resolve CSS and optional font assets before rendering; all faces are emitted by Tasty. */
+async function resolveThemeFonts(fonts = {}, options = {}) {
+	const base = (options.base ?? "/").replace(/\/$/, "");
+	const loading = options.loading ?? {};
+	const download = createFontFetcher(options.cacheDir, loading.cache, options.fetch);
+	const presets = options.presets ?? resolveTypographyPresets({}, fontFamilies(fonts));
+	const faces = [];
+	const assets = /* @__PURE__ */ new Map();
+	const google = /* @__PURE__ */ new Map();
+	for (const font of Object.values(fonts).filter((font) => font !== void 0)) if (typeof font === "string" || "google" in font) {
+		const family = typeof font === "string" ? font : font.google;
+		const requested = google.get(family) ?? {
+			explicit: /* @__PURE__ */ new Map(),
+			inferred: /* @__PURE__ */ new Map()
+		};
+		const weights = typeof font === "string" ? void 0 : font.weights;
+		const styles = typeof font === "string" ? ["normal", "italic"] : font.styles ?? ["normal", "italic"];
+		for (const style of styles) if (weights) requested.explicit.set(style, [...requested.explicit.get(style) ?? [], ...weights]);
+		else requested.inferred.set(style, [...requested.inferred.get(style) ?? [], ...presetWeights(family, presets)]);
+		google.set(family, requested);
+	} else for (const file of font.files) {
+		const extension = file.src.split(".").at(-1);
+		const format = extension === "ttf" ? "truetype" : extension === "otf" ? "opentype" : extension;
+		faces.push({
+			family: font.family,
+			descriptors: {
+				src: `url("${base}${file.src}") format("${format}")`,
+				fontWeight: file.weight ?? 400,
+				fontStyle: file.style ?? "normal",
+				fontDisplay: loading.display ?? "swap"
+			}
+		});
+	}
+	for (const [family, request] of google) {
+		const fetchFaces = async (byStyle, strict) => {
+			if (!byStyle.size) return [];
+			const tuples = [...byStyle].sort(([a], [b]) => (a === "normal" ? 0 : 1) - (b === "normal" ? 0 : 1)).flatMap(([style, weights]) => fontWeightSpans(weights).map(([min, max]) => `${style === "italic" ? 1 : 0},${min === max ? min : `${min}..${max}`}`));
+			const url = `https://fonts.googleapis.com/css2?family=${encodeURIComponent(family).replaceAll("%20", "+")}:ital,wght@${tuples.join(";")}&display=${loading.display ?? "swap"}`;
+			const response = await download(url);
+			if (response.status === 400) {
+				if (!strict) return [];
+				throw new Error(`Google Fonts rejected "${family}" (400). Check theme.fonts weights/ranges/styles against the family's supported axes.`);
+			}
+			const parsed = parseGoogleFontCss(response.body.toString("utf8"), family, loading.display ?? "swap");
+			if (!parsed.length) throw new Error(`Google Fonts returned no usable font files for "${family}".`);
+			if (strict) {
+				for (const [style, weights] of byStyle) for (const [lo, hi] of fontWeightSpans(weights)) if (!fontWeightSpans(parsed.filter((face) => face.descriptors.fontStyle === style).map((face) => String(face.descriptors.fontWeight).includes(" ") ? String(face.descriptors.fontWeight) : Number(face.descriptors.fontWeight))).some(([min, max]) => min <= lo && max >= hi)) throw new Error(`Google Fonts did not provide ${family} ${style} weight ${lo === hi ? lo : `${lo} ${hi}`}. Choose supported theme.fonts weights/styles or use local font files.`);
+			}
+			return parsed;
+		};
+		const familyFaces = await fetchFaces(request.explicit, true);
+		if (request.inferred.size) {
+			let inferred = await fetchFaces(new Map([...request.inferred].map(([style, weights]) => [style, [Math.min(...weights) === Math.max(...weights) ? weights[0] : `${Math.min(...weights)} ${Math.max(...weights)}`]])), false);
+			if (!inferred.length) {
+				inferred = await fetchFaces(new Map([...request.inferred].map(([style, weights]) => [style, [...new Set(weights.flatMap((weight) => [
+					weight,
+					Math.max(100, Math.floor(weight / 100) * 100),
+					Math.min(900, Math.ceil(weight / 100) * 100)
+				]))]])), false);
+				if (!inferred.length) throw new Error(`Google Fonts rejected "${family}". Check the family name or provide explicit supported theme.fonts weights/styles.`);
+			}
+			for (const style of request.inferred.keys()) if (!inferred.some((face) => face.descriptors.fontStyle === style)) options.warn?.(`Google Font "${family}" has no ${style} face for these presets. Choose a family with that style, or set theme.fonts styles explicitly.`);
+			familyFaces.push(...inferred);
+		}
+		for (const face of familyFaces) {
+			if (loading.google !== "remote") {
+				const source = /url\("([^"]+)"\) format\("([^"]+)"\)/.exec(String(face.descriptors.src));
+				const response = await download(source[1]);
+				if (response.status !== 200 || response.body.length < 12 || ![
+					"wOF2",
+					"wOFF",
+					"OTTO",
+					"ttcf",
+					"\0
\0\0"
+				].includes(response.body.subarray(0, 4).toString("binary"))) throw new Error(`Could not download Google Font "${family}" from ${source[1]}.`);
+				const extension = source[2] === "truetype" ? "ttf" : source[2] === "opentype" ? "otf" : source[2];
+				const outputPath = `_cookbook/fonts/${fontHash(response.body)}.${extension}`;
+				const publicPath = `${base}/${outputPath}`;
+				assets.set(outputPath, {
+					outputPath,
+					publicPath,
+					body: response.body,
+					contentType: `font/${extension}`
+				});
+				face.descriptors.src = `url("${publicPath}") format("${source[2]}")`;
+			}
+			faces.push(face);
+		}
+	}
+	return {
+		faces: [...new Map(faces.map((face) => [JSON.stringify(face), face])).values()],
+		assets: [...assets.values()]
+	};
+}
+function parseGoogleFontCss(css, family, display) {
+	const faces = [];
+	for (const block of css.matchAll(/@font-face\s*\{([^}]*)\}/g)) {
+		const declarations = Object.fromEntries([...(block[1] ?? "").matchAll(/([\w-]+)\s*:\s*([^;]+);/g)].map((match) => [match[1], match[2].trim()]));
+		const source = declarations.src?.match(/url\(['"]?(https:\/\/fonts\.gstatic\.com\/[^'"()\s]+)['"]?\)\s*format\(['"]?(woff2?|truetype|opentype)['"]?\)/);
+		if (!source || declarations["font-family"]?.replaceAll(/["']/g, "").toLowerCase() !== family.toLowerCase()) continue;
+		faces.push({
+			family,
+			descriptors: {
+				src: `url("${source[1]}") format("${source[2]}")`,
+				fontWeight: declarations["font-weight"] ?? 400,
+				fontStyle: declarations["font-style"] ?? "normal",
+				fontDisplay: display,
+				...declarations["unicode-range"] ? { unicodeRange: declarations["unicode-range"] } : {}
+			}
+		});
+	}
+	return faces;
+}
+//#endregion
+//#region src/component-overrides.ts
+function resolveComponentOverrides(defaults, overrides, disabledFooterPath) {
+	const resolved = { ...defaults };
+	for (const [name, override] of Object.entries(overrides ?? {})) if (name === "Footer" && override === false) resolved.Footer = disabledFooterPath;
+	else if (typeof override === "string") resolved[name] = override;
+	return resolved;
+}
+//#endregion
+//#region src/site-icons.ts
+const ICON_DIRECTORY = "_cookbook/icons";
+const DEFAULT_ICON_BACKGROUND = "#4b6dc3";
+const SUPPORTED_SOURCE_FORMATS = /* @__PURE__ */ new Set([
+	"avif",
+	"gif",
+	"heif",
+	"jpeg",
+	"jpg",
+	"png",
+	"svg",
+	"webp"
+]);
+async function createSiteIcons({ base, root, site = {}, themeColors }) {
+	const configured = site.favicon;
+	const source = typeof configured === "string" ? configured : configured?.source;
+	const sourcePath = source ? resolveSourcePath(source, root) : fileURLToPath(new URL("./icons/favicon.svg", import.meta.url));
+	const background = typeof configured === "object" && configured?.background ? configured.background : DEFAULT_ICON_BACKGROUND;
+	const input = await readFile(sourcePath).catch((error) => {
+		throw new Error(`Unable to read site.favicon source at ${sourcePath}: ${errorMessage$1(error)}`);
+	});
+	const format = (await sharp(input, { animated: false }).metadata()).format?.toLowerCase();
+	if (!format || !SUPPORTED_SOURCE_FORMATS.has(format)) throw new Error("site.favicon must point to an SVG, PNG, JPEG, WebP, AVIF, or GIF image.");
+	const definitions = [
+		await pngAsset(input, base, "favicon-32x32.png", 32),
+		await safePngAsset(input, base, "apple-touch-icon.png", 180, background),
+		await pngAsset(input, base, "icon-192x192.png", 192),
+		await pngAsset(input, base, "icon-512x512.png", 512),
+		await safePngAsset(input, base, "icon-192x192-maskable.png", 192, background),
+		await safePngAsset(input, base, "icon-512x512-maskable.png", 512, background)
+	];
+	const scalable = format === "svg" ? asset(base, "favicon.svg", input, "image/svg+xml") : void 0;
+	const faviconPath = `/${ICON_DIRECTORY}/${scalable ? "favicon.svg" : "favicon-32x32.png"}`;
+	const iconEntries = [
+		{
+			src: pathWithBase(base, `/${ICON_DIRECTORY}/icon-192x192.png`),
+			sizes: "192x192",
+			type: "image/png",
+			purpose: "any"
+		},
+		{
+			src: pathWithBase(base, `/${ICON_DIRECTORY}/icon-512x512.png`),
+			sizes: "512x512",
+			type: "image/png",
+			purpose: "any"
+		},
+		{
+			src: pathWithBase(base, `/${ICON_DIRECTORY}/icon-192x192-maskable.png`),
+			sizes: "192x192",
+			type: "image/png",
+			purpose: "maskable"
+		},
+		{
+			src: pathWithBase(base, `/${ICON_DIRECTORY}/icon-512x512-maskable.png`),
+			sizes: "512x512",
+			type: "image/png",
+			purpose: "maskable"
+		},
+		...scalable ? [{
+			src: scalable.publicPath,
+			sizes: "any",
+			type: "image/svg+xml",
+			purpose: "any"
+		}] : []
+	];
+	const manifest = asset(base, "site.webmanifest", Buffer.from(`${JSON.stringify({
+		name: site.title ?? "Documentation",
+		short_name: site.title ?? "Documentation",
+		...site.description ? { description: site.description } : {},
+		id: normalizedBase(base),
+		start_url: normalizedBase(base),
+		scope: normalizedBase(base),
+		display: "standalone",
+		background_color: background,
+		theme_color: themeColors.light,
+		icons: iconEntries
+	}, null, 2)}\n`), "application/manifest+json");
+	const favicon32 = definitions[0];
+	const appleTouchIcon = definitions[1];
+	if (!favicon32 || !appleTouchIcon) throw new Error("Cookbook failed to generate the required site icons.");
+	return {
+		assets: [
+			...definitions,
+			...scalable ? [scalable] : [],
+			manifest
+		],
+		faviconPath,
+		head: [
+			{
+				tag: "link",
+				attrs: {
+					rel: "icon",
+					href: favicon32.publicPath,
+					sizes: "32x32",
+					type: favicon32.contentType
+				}
+			},
+			...scalable ? [{
+				tag: "link",
+				attrs: {
+					rel: "icon",
+					href: scalable.publicPath,
+					sizes: "any",
+					type: scalable.contentType
+				}
+			}] : [],
+			{
+				tag: "link",
+				attrs: {
+					rel: "apple-touch-icon",
+					href: appleTouchIcon.publicPath,
+					sizes: "180x180"
+				}
+			},
+			{
+				tag: "link",
+				attrs: {
+					rel: "manifest",
+					href: manifest.publicPath
+				}
+			},
+			{
+				tag: "meta",
+				attrs: {
+					name: "theme-color",
+					content: themeColors.light,
+					media: "(prefers-color-scheme: light)"
+				}
+			},
+			{
+				tag: "meta",
+				attrs: {
+					name: "theme-color",
+					content: themeColors.dark,
+					media: "(prefers-color-scheme: dark)"
+				}
+			}
+		],
+		sourcePath
+	};
+}
+async function pngAsset(input, base, name, size) {
+	return asset(base, name, await sharp(input, {
+		animated: false,
+		density: 512
+	}).resize(size, size, {
+		fit: "contain",
+		background: {
+			r: 0,
+			g: 0,
+			b: 0,
+			alpha: 0
+		}
+	}).png().toBuffer(), "image/png");
+}
+async function safePngAsset(input, base, name, size, background) {
+	const safeSize = Math.round(size * .8);
+	const foreground = await sharp(input, {
+		animated: false,
+		density: 512
+	}).resize(safeSize, safeSize, {
+		fit: "contain",
+		background: {
+			r: 0,
+			g: 0,
+			b: 0,
+			alpha: 0
+		}
+	}).png().toBuffer();
+	return asset(base, name, await sharp({ create: {
+		width: size,
+		height: size,
+		channels: 4,
+		background
+	} }).composite([{
+		input: foreground,
+		gravity: "center"
+	}]).png().toBuffer().catch((error) => {
+		throw new Error(`Unable to use site.favicon.background ${JSON.stringify(background)}: ${errorMessage$1(error)}`);
+	}), "image/png");
+}
+function asset(base, name, body, contentType) {
+	const outputPath = `${ICON_DIRECTORY}/${name}`;
+	return {
+		body,
+		contentType,
+		outputPath,
+		publicPath: pathWithBase(base, `/${outputPath}`)
+	};
+}
+function resolveSourcePath(source, root) {
+	if (/^[a-z][a-z\d+.-]*:/i.test(source)) throw new Error("site.favicon must reference a local image path.");
+	return isAbsolute(source) ? source : resolve(root, source);
+}
+function pathWithBase(base, pathname) {
+	const prefix = normalizedBase(base);
+	return `${prefix === "/" ? "" : prefix.replace(/\/$/, "")}${pathname}`;
+}
+function normalizedBase(base) {
+	const value = base.replace(/^\/+|\/+$/g, "");
+	return value ? `/${value}/` : "/";
+}
+function errorMessage$1(error) {
+	return error instanceof Error ? error.message : String(error);
+}
+//#endregion
+//#region src/output-path.ts
+function normalizedBasePath(base) {
+	const path = base.replace(/^\/+|\/+$/g, "");
+	return path ? `/${path}/` : "/";
+}
+function outputPathForPublicAsset(publicPath, base) {
+	const normalizedPublicPath = `/${publicPath.replace(/^\/+/, "")}`;
+	const prefix = normalizedBasePath(base);
+	if (!normalizedPublicPath.startsWith(prefix)) throw new Error(`Cookbook asset path ${publicPath} is outside the configured base ${base}.`);
+	const outputPath = normalizedPublicPath.slice(prefix.length);
+	if (!outputPath || outputPath.split("/").some((segment) => segment === "." || segment === "..")) throw new Error(`Cookbook asset path ${publicPath} is not safe to emit.`);
+	return outputPath;
+}
+//#endregion
+//#region src/agent-discovery.ts
+function sitePath(base, route) {
+	return `${base === "/" ? "" : `/${base.replace(/^\/+|\/+$/g, "")}`}${route === "/" ? "/" : `${route}/`}`;
+}
+function pageUrl(site, path) {
+	return site ? new URL(path, site).href : path;
+}
+function singleLine(value) {
+	return value.replace(/\s+/g, " ").trim();
+}
+function markdownLabel(value) {
+	return singleLine(value).replace(/[\\[\]]/g, "\\$&");
+}
+function renderLlmsTxt(graph) {
+	const { site, build } = graph.config;
+	const lines = [`# ${singleLine(site.title ?? "Documentation")}`, ""];
+	if (site.description) lines.push(`> ${singleLine(site.description)}`, "");
+	lines.push("## Documentation", "");
+	const discoverable = new Set(graph.routes.filter((route) => route.discoverable !== false && route.sitemap !== false).map((route) => route.route));
+	for (const entry of graph.entries) {
+		if (!discoverable.has(entry.route)) continue;
+		const url = pageUrl(site.url, sitePath(build.base, entry.route));
+		lines.push(`- [${markdownLabel(entry.title)}](${url})${entry.description ? `: ${singleLine(entry.description)}` : ""}${site.seo?.copyPage === false ? "" : ` ([Markdown](${pageUrl(site.url, agentPagePath(entry.route, build.base))}))`}`);
+	}
+	return `${lines.join("\n")}\n`;
+}
+function renderRobotsTxt(site, sitemap = true) {
+	return `User-agent: *\nAllow: /\n${sitemap ? `Sitemap: ${new URL("/sitemap-index.xml", site).href}\n` : ""}`;
+}
+async function writeUnlessPresent(path, body) {
+	try {
+		await writeFile(path, body, { flag: "wx" });
+	} catch (error) {
+		if (error && typeof error === "object" && "code" in error && error.code === "EEXIST") return;
+		throw error;
+	}
+}
+async function writeAgentDiscovery(output, graph) {
+	await writeUnlessPresent(join(output, "llms.txt"), renderLlmsTxt(graph));
+	await mkdir(join(output, "_cookbook/pages"), { recursive: true });
+	const pages = [];
+	for (const entry of graph.entries) {
+		if (entry.frontmatter.draft) continue;
+		const route = graph.routes.find((route) => route.route === entry.route);
+		const markdown = !entry.frontmatter.draft && graph.config.site.seo?.copyPage !== false ? agentPagePath(entry.route, graph.config.build.base) : void 0;
+		if (markdown) await writeFile(join(output, outputPathForPublicAsset(markdown, graph.config.build.base)), renderAgentMarkdown(entry, graph.config));
+		pages.push({
+			route: entry.route,
+			url: pageUrl(graph.config.site.url, sitePath(graph.config.build.base, entry.route)),
+			canonical: route.canonical,
+			index: route.indexable !== false,
+			discoverable: route.discoverable !== false,
+			sitemap: route.sitemap !== false,
+			...markdown ? { markdown } : {}
+		});
+	}
+	await writeFile(join(output, "_cookbook/publishing.json"), JSON.stringify({
+		base: graph.config.build.base,
+		site: graph.config.site.url,
+		pages
+	}, null, 2) + "\n");
+	if (graph.config.build.base === "/" && graph.config.site.url) await writeUnlessPresent(join(output, "robots.txt"), renderRobotsTxt(graph.config.site.url, graph.routes.some((route) => route.sitemap !== false)));
+}
+//#endregion
+//#region src/integration.ts
+const stylingRuntimeError = "Cookbook styles are build/server-only. Do not import @tenphi/cookbook/styling, Tasty, or Glaze in browser scripts or client:* islands. Render styled markup on the server and attach a small client script for interactions.";
+function isStylingRuntime(id) {
+	const path = id.replaceAll("\\", "/");
+	return /^@tenphi\/(?:tasty|glaze)(?:\/|$)/.test(path) || /^@tenphi\/(?:cookbook|renderer)\/styling$/.test(path) || /(?:^|\/)node_modules\/@tenphi\/(?:tasty|glaze)(?:\/|$)/.test(path);
+}
+const packageRequire = createRequire(import.meta.url);
+const tastyStaticMiddleware = packageRequire.resolve("@tenphi/tasty/ssr/astro-middleware-static");
+const tastyExtractStaticMiddleware = packageRequire.resolve("@tenphi/tasty/ssr/astro-middleware-extract-static");
+const astroReactServer = packageRequire.resolve("@astrojs/react/server.js");
+const astroReactClient = packageRequire.resolve("@astrojs/react/client.js");
+const astroReactIntegration = packageRequire.resolve("@astrojs/react");
+const importNative = new Function("specifier", "return import(specifier)");
+function cookbook(options = {}) {
+	let integration;
+	return {
+		name: "cookbook",
+		hooks: {
+			"astro:config:setup": async (context) => {
+				const project = await resolveDocsProject({
+					...options,
+					root: options.root ?? fileURLToPath(context.config.root)
+				});
+				if (project.configFile) context.addWatchFile(project.configFile);
+				integration = configuredCookbook({
+					config: project.config,
+					root: project.root,
+					...options.frontmatterSchema ? { frontmatterSchema: options.frontmatterSchema } : {}
+				});
+				await callInner([integration], "astro:config:setup", context);
+			},
+			"astro:config:done": async (context) => {
+				if (integration) await callInner([integration], "astro:config:done", context);
+			},
+			"astro:server:setup": async (context) => {
+				if (integration) await callInner([integration], "astro:server:setup", context);
+			},
+			"astro:build:start": async (context) => {
+				if (integration) await callInner([integration], "astro:build:start", context);
+			},
+			"astro:build:done": async (context) => {
+				if (integration) await callInner([integration], "astro:build:done", context);
+			}
+		}
+	};
+}
+function configuredCookbook(options) {
+	const docsTheme = resolveDocsTheme(options.config?.theme);
+	if (docsTheme.diagnostics.some((diagnostic) => diagnostic.severity === "error")) throw new Error(docsTheme.diagnostics.map((diagnostic) => diagnostic.message).join("\n"));
+	configureTastyTheme(options.config?.theme, docsTheme);
+	configureComponentStyles({
+		...options.config?.theme?.customStyles,
+		...options.config?.theme?.styles
+	});
+	const headerPath = fileURLToPath(new URL("./overrides/Header.astro", import.meta.url));
+	const footerPath = fileURLToPath(new URL("./overrides/Footer.astro", import.meta.url));
+	const heroPath = fileURLToPath(new URL("./overrides/Hero.astro", import.meta.url));
+	const emptyFooterPath = fileURLToPath(new URL("./overrides/EmptyFooter.astro", import.meta.url));
+	const sidebarPath = fileURLToPath(new URL("./overrides/Sidebar.astro", import.meta.url));
+	const mobileMenuFooterPath = fileURLToPath(new URL("./overrides/MobileMenuFooter.astro", import.meta.url));
+	const mobileMenuTogglePath = fileURLToPath(new URL("./overrides/MobileMenuToggle.astro", import.meta.url));
+	const markdownContentPath = fileURLToPath(new URL("./overrides/MarkdownContent.astro", import.meta.url));
+	const themeSelectPath = fileURLToPath(new URL("./overrides/ThemeSelect.astro", import.meta.url));
+	const components = resolveComponentOverrides({
+		DraftContentNotice: fileURLToPath(new URL("./overrides/DraftContentNotice.astro", import.meta.url)),
+		Search: fileURLToPath(new URL("./overrides/Search.astro", import.meta.url)),
+		Head: fileURLToPath(new URL("./overrides/Head.astro", import.meta.url)),
+		LanguageSelect: fileURLToPath(new URL("./overrides/LanguageSelect.astro", import.meta.url)),
+		PageFrame: fileURLToPath(new URL("./overrides/PageFrame.astro", import.meta.url)),
+		MobileTableOfContents: fileURLToPath(new URL("./overrides/MobileTableOfContents.astro", import.meta.url)),
+		Footer: footerPath,
+		Header: headerPath,
+		Hero: heroPath,
+		MarkdownContent: markdownContentPath,
+		Sidebar: sidebarPath,
+		MobileMenuFooter: mobileMenuFooterPath,
+		MobileMenuToggle: mobileMenuTogglePath,
+		ThemeSelect: themeSelectPath,
+		SocialIcons: fileURLToPath(new URL("./overrides/SocialIcons.astro", import.meta.url)),
+		SiteTitle: fileURLToPath(new URL("./components/SiteTitle.astro", import.meta.url)),
+		EditLink: fileURLToPath(new URL("./components/EditLink.astro", import.meta.url)),
+		LastUpdated: fileURLToPath(new URL("./components/LastUpdated.astro", import.meta.url)),
+		Pagination: fileURLToPath(new URL("./components/Pagination.astro", import.meta.url)),
+		TableOfContents: fileURLToPath(new URL("./components/TableOfContents.astro", import.meta.url))
+	}, options.config?.components?.overrides, emptyFooterPath);
+	const navigation = resolveNavigationLayout(options.config?.navigation);
+	const tasty = tastyIntegration({
+		islands: false,
+		css: { mode: "extract" }
+	});
+	let inner = [tasty];
+	let projectRoot = options.root;
+	let graphConfig = options.config;
+	let graphBase = "/";
+	let graph;
+	let siteIconBase = "/";
+	let siteIcons;
+	let fontAssets = [];
+	let siteLogo;
+	async function loadGraph(refresh = false) {
+		if (!graph || refresh) {
+			graph = await createDocsGraph({
+				...projectRoot ? { root: projectRoot } : {},
+				...graphConfig ? { config: graphConfig } : {},
+				base: graphBase
+			});
+			assertValidDocs(graph);
+			await validatePluginFrontmatter(graph.entries, options.frontmatterSchema);
+		}
+		return graph;
+	}
+	async function loadSiteIcons() {
+		if (!projectRoot) throw new Error("Cookbook cannot generate site icons without a project root.");
+		return createSiteIcons({
+			base: siteIconBase,
+			root: projectRoot,
+			...options.config?.site ? { site: options.config.site } : {},
+			themeColors: {
+				light: docsTheme.colors.surface.light ?? "#ffffff",
+				dark: docsTheme.colors.surface.dark ?? "#20232a"
+			}
+		});
+	}
+	return {
+		name: "cookbook",
+		hooks: {
+			"astro:config:setup": async (context) => {
+				const react = (await importNative(pathToFileURL(astroReactIntegration).href)).default();
+				projectRoot ??= fileURLToPath(context.config.root);
+				const base = context.config.base;
+				for (const [role, font] of Object.entries(options.config?.theme?.fonts ?? {})) {
+					if (!font || typeof font === "string" || "google" in font) continue;
+					for (const file of font.files) {
+						const path = join(fileURLToPath(context.config.publicDir), file.src.slice(1));
+						let isFile = false;
+						try {
+							isFile = (await stat(path)).isFile();
+						} catch {}
+						if (!isFile) throw new Error(`theme.fonts.${role}: ${file.src} must be a readable file in the site's public directory.`);
+					}
+				}
+				const resolvedFonts = await resolveThemeFonts(options.config?.theme?.fonts, {
+					base,
+					cacheDir: join(fileURLToPath(context.config.cacheDir), "cookbook-fonts"),
+					loading: options.config?.theme?.fontLoading ?? {},
+					presets: docsTheme.presets,
+					warn: (message) => context.logger.warn(message)
+				});
+				const fontFaces = resolvedFonts.faces;
+				fontAssets = resolvedFonts.assets;
+				const usedFamilies = Object.values(docsTheme.presets).map((preset) => preset.fontFamily ?? "");
+				configureFontFaces(fontFaces, {
+					display: options.config?.theme?.fontLoading?.display ?? "swap",
+					onest: usedFamilies.some((family) => family.includes("Onest Variable")),
+					mono: usedFamilies.some((family) => family.includes("JetBrains Mono Variable"))
+				});
+				const configuredSite = options.config?.site?.url;
+				const astroSite = context.config.site ? new URL(context.config.site).href : void 0;
+				if (configuredSite && astroSite && astroSite !== new URL(configuredSite).href) throw new Error(`Cookbook site.url (${configuredSite}) conflicts with Astro site (${astroSite}).`);
+				if (configuredSite || astroSite) graphConfig = {
+					...graphConfig,
+					site: {
+						...graphConfig?.site,
+						url: configuredSite ?? astroSite
+					}
+				};
+				siteIconBase = base;
+				graphBase = base;
+				context.config.integrations.push(sitemap({
+					serialize: (item) => {
+						if (!graph?.config.locales) return item;
+						const route = navigationPath(decodeURI(new URL(item.url).pathname), graphBase);
+						return {
+							...item,
+							links: localeAlternates(route, graph.routes.filter((route) => route.sitemap !== false), graph.config).map(({ lang, route }) => ({
+								lang,
+								url: new URL(`${graphBase.replace(/\/$/, "")}${route === "/" ? "/" : `${route}/`}`, item.url).href
+							}))
+						};
+					},
+					filter: (url) => {
+						const pathname = decodeURI(new URL(url).pathname);
+						const route = navigationPath(pathname, graphBase);
+						return graph?.routes.some((entry) => entry.route === route && entry.discoverable !== false && entry.sitemap !== false) ?? false;
+					}
+				}));
+				siteIcons = await loadSiteIcons();
+				siteLogo = await resolveSiteLogo(projectRoot, base, options.config?.site);
+				registerCookbookMarkdownPlugins(context.config.markdown.processor);
+				inner = [
+					react,
+					tasty,
+					mdx()
+				];
+				let markdownRuntime = {
+					image: context.config.image,
+					markdown: {
+						...context.config.markdown,
+						syntaxHighlight: "shiki",
+						shikiConfig: cookbookShikiConfig(context.config.markdown.shikiConfig)
+					},
+					srcDir: context.config.srcDir
+				};
+				let markdownRenderer;
+				context.updateConfig({
+					...configuredSite && !context.config.site ? { site: configuredSite } : {},
+					base,
+					output: "static",
+					markdown: {
+						syntaxHighlight: "shiki",
+						shikiConfig: cookbookShikiConfig(context.config.markdown.shikiConfig)
+					},
+					vite: {
+						ssr: { external: [
+							"@tenphi/docs",
+							"react",
+							"react-dom"
+						] },
+						plugins: [
+							{
+								name: "cookbook-server-only-styling",
+								enforce: "pre",
+								resolveId(id, _importer, settings) {
+									if (settings?.ssr || this.environment.config.consumer === "server") return;
+									if (isStylingRuntime(id)) this.error(stylingRuntimeError);
+								},
+								generateBundle() {
+									if (this.environment.config.consumer === "server") return;
+									for (const id of this.getModuleIds()) if (isStylingRuntime(id)) this.error(stylingRuntimeError);
+								}
+							},
+							{
+								name: "cookbook-react-runtime",
+								enforce: "post",
+								configResolved(config) {
+									for (const environment of Object.values(config.environments)) {
+										if (environment.consumer === "server") environment.resolve.dedupe = environment.resolve.dedupe.filter((id) => id !== "react" && id !== "react-dom");
+										if (environment.consumer === "client") environment.optimizeDeps.include = environment.optimizeDeps.include?.map((id) => /^react(?:-dom)?(?:\/|$)/.test(id) ? packageRequire.resolve(id) : id) ?? [];
+									}
+								},
+								resolveId(id, _importer, settings) {
+									if (!settings?.ssr && this.environment.config.consumer !== "server" && /^react(?:-dom)?(?:\/|$)/.test(id)) return packageRequire.resolve(id);
+								}
+							},
+							componentOverridesPlugin(components, fileURLToPath(context.config.root)),
+							virtualDocsPlugin(async () => {
+								const loaded = await loadGraph(true);
+								return {
+									entries: await Promise.all(loaded.entries.map(async (entry) => {
+										const hero = await resolveHeroMetadata(entry);
+										if (entry.trust === "mdx" && entry.sourcePath.toLowerCase().endsWith(".mdx")) return {
+											...entry,
+											hero,
+											mdx: true
+										};
+										const { image, markdown, srcDir } = markdownRuntime;
+										markdownRenderer ??= markdown.processor.createRenderer({
+											image,
+											syntaxHighlight: markdown.syntaxHighlight,
+											shikiConfig: markdown.shikiConfig,
+											gfm: markdown.gfm,
+											smartypants: markdown.smartypants
+										});
+										const rendered = await (await markdownRenderer).render(entry.transformedBody, {
+											frontmatter: entry.frontmatter,
+											fileURL: docsContentUrl(entry.route, srcDir)
+										});
+										return {
+											...entry,
+											hero,
+											rendered: {
+												html: rendered.code,
+												headings: rendered.metadata.headings
+											}
+										};
+									})),
+									routes: loaded.routes,
+									redirects: loaded.redirects,
+									tableOfContents: loaded.config.tableOfContents,
+									site: documentedSite(loaded),
+									base: loaded.config.build.base,
+									search: loaded.config.search.enabled || typeof options.config?.components?.overrides?.Search === "string",
+									logo: siteLogo?.logo,
+									locales: loaded.config.locales,
+									defaultLocale: loaded.config.defaultLocale,
+									translations: loaded.config.translations,
+									head: [...siteIcons?.head ?? [], ...options.config?.head ?? []]
+								};
+							}, navigation, () => [
+								projectRoot,
+								...(graphConfig?.content?.sources ?? []).flatMap((source) => "package" in source ? [] : [resolve(projectRoot, source.root ?? ".")]),
+								...graph?.entries.map((entry) => entry.sourceRoot) ?? []
+							])
+						],
+						resolve: { alias: [
+							{
+								find: "@tenphi/tasty/ssr/astro-middleware-static",
+								replacement: tastyStaticMiddleware
+							},
+							{
+								find: "@tenphi/tasty/ssr/astro-middleware-extract-static",
+								replacement: tastyExtractStaticMiddleware
+							},
+							{
+								find: "@astrojs/react/server.js",
+								replacement: astroReactServer
+							},
+							{
+								find: "@astrojs/react/client.js",
+								replacement: astroReactClient
+							}
+						] }
+					}
+				});
+				await callInner(inner, "astro:config:setup", context);
+				graph = await createDocsGraph({
+					root: projectRoot,
+					...graphConfig ? { config: graphConfig } : {},
+					base: graphBase
+				});
+				assertValidDocs(graph);
+				context.injectRoute({
+					pattern: "[...route]",
+					entrypoint: new URL("./routes/DocsPage.astro", import.meta.url),
+					prerender: true
+				});
+				if (!graph.entryByRoute("/404")) context.injectRoute({
+					pattern: "404",
+					entrypoint: new URL("./routes/NotFound.astro", import.meta.url),
+					prerender: true
+				});
+				context.config.integrations.push({
+					name: "cookbook-markdown-renderer",
+					hooks: { "astro:config:setup": ({ config }) => {
+						markdownRuntime = {
+							image: config.image,
+							markdown: {
+								...config.markdown,
+								syntaxHighlight: "shiki",
+								shikiConfig: cookbookShikiConfig(config.markdown.shikiConfig)
+							},
+							srcDir: config.srcDir
+						};
+					} }
+				});
+			},
+			"astro:config:done": async (context) => {
+				configureCodeHighlighting(cookbookShikiConfig(context.config.markdown.shikiConfig));
+				await callInner(inner, "astro:config:done", context);
+			},
+			"astro:server:setup": async ({ server, logger }) => {
+				let assets = docsAssetMap(await loadGraph());
+				if (siteLogo?.sourcePaths.length) {
+					server.watcher.add(siteLogo.sourcePaths);
+					server.watcher.on("change", (path) => {
+						if (siteLogo?.sourcePaths.includes(path)) server.restart();
+					});
+				}
+				if (options.config?.site?.favicon && siteIcons) {
+					server.watcher.add(siteIcons.sourcePath);
+					server.watcher.on("change", async (changedPath) => {
+						if (changedPath !== siteIcons?.sourcePath) return;
+						try {
+							siteIcons = await loadSiteIcons();
+							server.ws.send({ type: "full-reload" });
+						} catch (error) {
+							logger.error(errorMessage(error));
+						}
+					});
+				}
+				server.middlewares.use(async (request, response, next) => {
+					if (request.method !== "GET" && request.method !== "HEAD") {
+						next();
+						return;
+					}
+					const requestPathname = requestPath(request.url);
+					const pathname = graphBase !== "/" && !requestPathname.startsWith(graphBase) ? `${graphBase.replace(/\/$/, "")}${requestPathname}` : requestPathname;
+					if (pathname.includes("/_cookbook/pages/")) try {
+						const current = await loadGraph(true);
+						const entry = current.entries.find((entry) => !entry.frontmatter.draft && agentPagePath(entry.route, current.config.build.base) === pathname);
+						if (entry && current.config.site.seo?.copyPage !== false) {
+							response.statusCode = 200;
+							response.setHeader("Content-Type", "text/markdown; charset=utf-8");
+							response.setHeader("X-Robots-Tag", "noindex");
+							response.end(request.method === "HEAD" ? void 0 : renderAgentMarkdown(entry, current.config));
+							return;
+						}
+					} catch (error) {
+						logger.error(errorMessage(error));
+					}
+					const fontAsset = [...fontAssets, ...siteLogo?.assets ?? []].find((asset) => asset.publicPath === pathname);
+					if (fontAsset) {
+						response.statusCode = 200;
+						response.setHeader("Content-Type", fontAsset.contentType);
+						response.setHeader("Content-Length", fontAsset.body.byteLength);
+						response.setHeader("Cache-Control", "public, max-age=31536000, immutable");
+						response.end(request.method === "HEAD" ? void 0 : fontAsset.body);
+						return;
+					}
+					const siteIcon = siteIcons?.assets.find((asset) => asset.publicPath === pathname);
+					if (siteIcon) {
+						response.statusCode = 200;
+						response.setHeader("Content-Type", siteIcon.contentType);
+						response.setHeader("Content-Length", siteIcon.body.byteLength);
+						response.setHeader("Cache-Control", "no-cache");
+						response.end(request.method === "HEAD" ? void 0 : siteIcon.body);
+						return;
+					}
+					if (!pathname.includes("/_tasty-assets/")) {
+						next();
+						return;
+					}
+					let asset = assets.get(pathname);
+					if (!asset) {
+						try {
+							assets = docsAssetMap(await loadGraph(true));
+						} catch {
+							next();
+							return;
+						}
+						asset = assets.get(pathname);
+					}
+					if (!asset?.sourcePath) {
+						next();
+						return;
+					}
+					try {
+						const body = await readFile(asset.sourcePath);
+						response.statusCode = 200;
+						response.setHeader("Content-Type", assetContentType(pathname));
+						response.setHeader("Content-Length", body.byteLength);
+						response.setHeader("Cache-Control", "no-cache");
+						response.end(request.method === "HEAD" ? void 0 : body);
+					} catch {
+						next();
+					}
+				});
+			},
+			"astro:build:start": async (context) => {
+				siteIcons = await loadSiteIcons();
+				await loadGraph();
+				await callInner(inner, "astro:build:start", context);
+			},
+			"astro:build:done": async (context) => {
+				await callInner(inner, "astro:build:done", context);
+				const output = fileURLToPath(context.dir);
+				const anatomyNames = /* @__PURE__ */ new Set();
+				for (const relativePath of await readdir(output, { recursive: true })) {
+					if (extname(relativePath) !== ".html") continue;
+					const path = join(output, relativePath);
+					const html = await readFile(path, "utf8");
+					for (const match of html.matchAll(/\bdata-tasty-anatomy="([^"]+)"/g)) anatomyNames.add(match[1]);
+					const sanitized = html.replace(/\s*<link\b(?=[^>]*rel="stylesheet")(?=[^>]*href="data:text\/css,")[^>]*>/g, "").replace(/\s*<style>\s*<\/style>/g, "").replace(/<style>astro-island,astro-slot,astro-static-slot\{display:contents\}<\/style>/g, "");
+					assertTastyOutput(sanitized, relativePath);
+					if (sanitized !== html) await writeFile(path, sanitized);
+				}
+				for (const name of unusedCustomStyleNames(options.config?.theme?.customStyles, anatomyNames)) context.logger.warn(`theme.customStyles.${name} did not match a component style resolver or rendered data-tasty-anatomy attribute. Check that its name matches defineComponent() or resolveComponentStyles().`);
+				if (graph?.config.search.enabled !== false) try {
+					const { index, errors } = await pagefind.createIndex();
+					if (errors.length || !index) throw new Error(errors.join("\n") || "Pagefind did not create an index.");
+					const added = await index.addDirectory({ path: output });
+					if (added.errors.length) throw new Error(added.errors.join("\n"));
+					const written = await index.writeFiles({ outputPath: join(output, "pagefind") });
+					if (written.errors.length) throw new Error(written.errors.join("\n"));
+				} finally {
+					await pagefind.close();
+				}
+				const pagefindOutput = join(output, "pagefind");
+				if (existsSync(pagefindOutput)) {
+					for (const name of await readdir(pagefindOutput)) if (extname(name) === ".css") await unlink(join(pagefindOutput, name));
+				}
+				for (const relativePath of await readdir(output, { recursive: true })) if (extname(relativePath) === ".css" && !/^tasty\.[^/]+\.css$/.test(relativePath.split(/[/\\]/).at(-1) ?? "")) throw new Error(`Non-Tasty stylesheet found in ${relativePath}. Use theme.styles or Tasty components for visual changes.`);
+				for (const asset of [
+					...siteIcons?.assets ?? [],
+					...fontAssets,
+					...siteLogo?.assets ?? []
+				]) {
+					const target = join(output, asset.outputPath);
+					await mkdir(dirname(target), { recursive: true });
+					await writeFile(target, asset.body);
+				}
+				if (!graph) return;
+				for (const asset of graph.assets) {
+					if (!asset.sourcePath || !asset.publicPath) continue;
+					const target = join(output, outputPathForPublicAsset(asset.publicPath, graph.config.build.base));
+					await mkdir(dirname(target), { recursive: true });
+					await cp(asset.sourcePath, target);
+				}
+				await writeAgentDiscovery(output, graph);
+			}
+		}
+	};
+}
+function registerCookbookMarkdownPlugins(processor) {
+	if (processor.name === "unified") {
+		const options = processor.options;
+		const plugins = Array.isArray(options.rehypePlugins) ? options.rehypePlugins : [];
+		if (!plugins.includes(rehypeMermaid)) plugins.push(rehypeMermaid);
+		if (!plugins.includes(rehypeAlerts)) plugins.push(rehypeAlerts);
+		if (!plugins.includes(rehypeTableScroll)) plugins.push(rehypeTableScroll);
+		if (!plugins.includes(rehypePageAffordances)) plugins.push(rehypePageAffordances);
+		options.rehypePlugins = plugins;
+	} else if (processor.name === "satteri") {
+		const options = processor.options;
+		const plugins = Array.isArray(options.hastPlugins) ? options.hastPlugins : [];
+		if (!plugins.includes(satteriMermaid)) plugins.push(satteriMermaid);
+		if (!plugins.includes(satteriAlerts)) plugins.push(satteriAlerts);
+		if (!plugins.includes(satteriTableScroll)) plugins.push(satteriTableScroll);
+		if (!plugins.includes(satteriPageAffordances)) plugins.push(satteriPageAffordances);
+		options.hastPlugins = plugins;
+	}
+}
+function docsContentUrl(route, srcDir) {
+	const slug = route === "/" ? "index" : route.replace(/^\/+|\/+$/g, "");
+	return new URL(`content/docs/${slug}.md`, srcDir);
+}
+function componentOverridesPlugin(components, astroRoot) {
+	const prefix = "virtual:cookbook/components/";
+	return {
+		name: "cookbook-component-overrides",
+		resolveId(id) {
+			const name = id.startsWith(prefix) ? id.slice(28) : void 0;
+			return name && components[name] ? `\0${id}` : void 0;
+		},
+		load(id) {
+			const name = id.startsWith(`\0${prefix}`) ? id.slice(29) : void 0;
+			if (!name || !components[name]) return void 0;
+			const configured = components[name];
+			const target = configured.startsWith(".") ? resolve(astroRoot, configured) : configured;
+			return `export { default } from ${JSON.stringify(target)};`;
+		}
+	};
+}
+function docsAssetMap(graph) {
+	return new Map(graph.assets.flatMap((asset) => asset.publicPath && asset.sourcePath ? [[asset.publicPath, asset]] : []));
+}
+function documentedSite(graph) {
+	if (graph.config.site.version) return graph.config.site;
+	const packages = new Set(graph.entries.flatMap((entry) => entry.package?.resolved ? [entry.package.resolved] : []));
+	if (packages.size !== 1) return graph.config.site;
+	const resolved = packages.values().next().value;
+	if (!resolved) return graph.config.site;
+	const separator = resolved.lastIndexOf("@");
+	if (separator <= 0 || separator === resolved.length - 1) return graph.config.site;
+	return {
+		...graph.config.site,
+		version: resolved.slice(separator + 1)
+	};
+}
+function requestPath(url) {
+	try {
+		return decodeURIComponent(new URL(url ?? "/", "http://localhost").pathname);
+	} catch {
+		return "";
+	}
+}
+function assetContentType(pathname) {
+	switch (extname(pathname).toLowerCase()) {
+		case ".avif": return "image/avif";
+		case ".gif": return "image/gif";
+		case ".jpeg":
+		case ".jpg": return "image/jpeg";
+		case ".png": return "image/png";
+		case ".svg": return "image/svg+xml";
+		case ".webp": return "image/webp";
+		default: return "application/octet-stream";
+	}
+}
+function errorMessage(error) {
+	return error instanceof Error ? error.message : String(error);
+}
+function configureTastyTheme(theme, resolved) {
+	const tokens = tastyTokens(resolved);
+	const globalStyles = resolveLegacyAnatomyStyles(theme?.customStyles);
+	globalThis.__tenphiCookbookTastyRuntime = {
+		units: {
+			...TASTY_UNITS,
+			...theme?.units
+		},
+		recipes: theme?.recipes ?? {},
+		states: theme?.states ?? {},
+		presets: resolved.presets,
+		tokens
+	};
+	configure({
+		states: {
+			...cookbookStates,
+			...theme?.states
+		},
+		units: {
+			...TASTY_UNITS,
+			...theme?.units
+		},
+		recipes: theme?.recipes ?? {},
+		tokens,
+		presets: resolved.presets,
+		...globalStyles ? { globalStyles } : {}
+	});
+}
+async function callInner(integrations, hook, context) {
+	for (const integration of integrations) {
+		const handler = integration.hooks[hook];
+		if (typeof handler === "function") await handler(context);
+	}
+}
+function virtualDocsPlugin(getContent, layout, getWatchRoots) {
+	const configId = "\0virtual:cookbook/config";
+	const layoutId = "\0virtual:cookbook/layout";
+	const mdxPrefix = "virtual:cookbook/mdx/";
+	let contentPromise;
+	let mdxRecords = [];
+	const watchedPaths = /* @__PURE__ */ new Set();
+	async function loadContent() {
+		contentPromise ??= Promise.resolve(getContent());
+		let content;
+		try {
+			content = await contentPromise;
+		} catch (error) {
+			contentPromise = void 0;
+			throw error;
+		}
+		mdxRecords = content.entries.flatMap((entry, index) => entry.mdx ? [{
+			entry,
+			sourceId: entry.absolutePath.replace(/\.mdx$/i, `.cookbook-${index}.mdx`),
+			virtualId: `${mdxPrefix}${index}`
+		}] : []);
+		return content;
+	}
+	return {
+		name: "cookbook-data",
+		enforce: "pre",
+		configureServer(server) {
+			const roots = [...new Set(getWatchRoots())];
+			server.watcher.add(roots);
+			const changed = (_event, path) => {
+				const owned = roots.some((root) => path === root || path.startsWith(`${root}/`));
+				if (!watchedPaths.has(path) && !(owned && (/\.mdx?$/i.test(path) || path.endsWith("/cookbook.lock.json")))) return;
+				contentPromise = void 0;
+				mdxRecords = [];
+				for (const environment of Object.values(server.environments)) environment.moduleGraph.invalidateAll();
+				server.ws.send({ type: "full-reload" });
+			};
+			server.watcher.on("all", changed);
+			server.httpServer?.once("close", () => server.watcher.off("all", changed));
+		},
+		async resolveId(id, _importer, resolveOptions) {
+			if (id === "virtual:cookbook/config") {
+				if (resolveOptions.ssr === false) throw new Error("Cookbook content queries are build-time only. Pass selected public data to a client component as props instead.");
+				return configId;
+			}
+			if (id === "virtual:cookbook/layout") return layoutId;
+			if (id.startsWith(mdxPrefix)) {
+				await loadContent();
+				return mdxRecords.find((record) => record.virtualId === id)?.sourceId;
+			}
+		},
+		async load(id) {
+			if (id === configId) {
+				const content = await loadContent();
+				watchedPaths.clear();
+				for (const entry of content.entries) {
+					watchedPaths.add(entry.absolutePath);
+					this.addWatchFile(entry.absolutePath);
+					for (const asset of entry.assets ?? []) {
+						if (!asset.sourcePath) continue;
+						watchedPaths.add(asset.sourcePath);
+						this.addWatchFile(asset.sourcePath);
+					}
+				}
+				const loaders = mdxRecords.map(({ entry, virtualId }) => `${JSON.stringify(entry.route)}: () => import(${JSON.stringify(virtualId)})`).join(",\n");
+				return `export const content = ${JSON.stringify(content)};\nexport const mdxLoaders = {${loaders}};`;
+			}
+			if (id === layoutId) return `export const layout = ${JSON.stringify(layout)};`;
+			const mdx = mdxRecords.find((record) => record.sourceId === id);
+			if (mdx) return mdx.entry.transformedBody;
+		},
+		watchChange(id) {
+			if (!watchedPaths.has(id)) return;
+			contentPromise = void 0;
+			mdxRecords = [];
+		}
+	};
+}
+//#endregion
+export { DEFAULT_THEME_TOKENS, DEFAULT_TYPOGRAPHY_PRESETS, cookbook as default, resolveDocsTheme };
+
+//# sourceMappingURL=index.js.map