@ox-content/vite-plugin 3.0.0-alpha.1 → 3.0.0-alpha.2

package/dist/index.mjs

@@ -7,18 +7,20 @@ import * as path$2 from "path";
 import { unified } from "unified";
 import rehypeParsePlugin from "rehype-parse";
 import rehypeStringifyPlugin from "rehype-stringify";
-import { existsSync, readFileSync } from "node:fs";
+import fs, { createReadStream, existsSync, readFileSync } from "node:fs";
 import * as path$1 from "node:path";
-import path, { dirname, join } from "node:path";
-import * as fs$1 from "node:fs/promises";
-import { access, mkdir, mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
+import path, { dirname, extname, join, relative, resolve, sep } from "node:path";
+import * as fs$2 from "node:fs/promises";
+import { access, copyFile, cp, mkdir, mkdtemp, readFile, rm, stat, writeFile } from "node:fs/promises";
 import { Buffer as Buffer$1 } from "node:buffer";
 import { tmpdir } from "node:os";
 import { promisify } from "node:util";
 import { execFile, spawn } from "node:child_process";
-import * as fs$2 from "fs/promises";
+import * as fs$3 from "fs/promises";
 import * as crypto from "crypto";
-import * as fs from "fs";
+import { createHash } from "node:crypto";
+import { deflateSync, inflateSync } from "node:zlib";
+import * as fs$1 from "fs";
 import { glob } from "glob";
 //#region src/markdown.ts
 const DEFAULT_MARKDOWN_EXTENSIONS = [
@@ -245,6 +247,15 @@ async function highlightCode(html) {
 	const result = await unified().use(rehypeParse$3, { fragment: true }).use(rehypeNativeHighlight).use(rehypeStringify$3).process(html);
 	return String(result);
 }
+/**
+* Highlight every code block in a rendered page, preserving original classes
+* and per-line metadata when the native document pass cannot read the markup.
+*/
+async function highlightPageHtml(html, mergeHighlightedCodeBlocks) {
+	const native = await highlightDocumentNatively(html);
+	if (native && native.skipped.length === 0) return native.html;
+	return mergeHighlightedCodeBlocks(html, await highlightCode(html));
+}
 //#endregion
 //#region src/plugins/mermaid.ts
 /**
@@ -336,6 +347,69 @@ function warnMissingMmdcOnce() {
 */
 const mermaidClientScript = "";
 //#endregion
+//#region src/plugins/math.ts
+/**
+* Build-time KaTeX rendering for opt-in `$…$` / `$$…$$` math.
+*
+* KaTeX is an optional peer. Sites that never enable `math` do not install it,
+* and the published plugin does not bundle or depend on it.
+*/
+const KATEX_ASSET_DIR = "__ox_katex__";
+const MATH_TAG = /<(span|div) class="ox-math ox-math-(inline|block)" data-ox-tex="([^"]*)">[\s\S]*?<\/\1>/g;
+let missingWarned = false;
+/**
+* Replaces rust `ox-math` placeholders with static KaTeX HTML.
+* Leaves the escaped TeX fallback when `katex` is not installed.
+*/
+async function renderKatexMath(html) {
+	if (!html.includes("data-ox-tex")) return html;
+	const katex = loadKatex();
+	if (!katex) {
+		warnMissingKatexOnce();
+		return html;
+	}
+	return html.replace(MATH_TAG, (_match, tag, kind, encoded) => {
+		return `<${tag} class="ox-math ox-math-${kind}">${katex.renderToString(decodeHtmlAttr$2(encoded), {
+			displayMode: kind === "block",
+			throwOnError: false,
+			trust: false,
+			output: "htmlAndMathml"
+		})}</${tag}>`;
+	});
+}
+/** Directory that contains `katex.min.css` and `fonts/`, or `null`. */
+function resolveKatexDist() {
+	for (const resolver of createKatexResolvers()) try {
+		return join(dirname(resolver.resolve("katex/package.json")), "dist");
+	} catch {}
+	return null;
+}
+function loadKatex() {
+	for (const resolver of createKatexResolvers()) try {
+		const loaded = resolver(resolver.resolve("katex"));
+		if (typeof loaded.renderToString === "function") return loaded;
+		if (loaded.default && typeof loaded.default.renderToString === "function") return loaded.default;
+	} catch {}
+	return null;
+}
+function createKatexResolvers() {
+	const consumerRequire = createRequire(join(process.cwd(), "noop.js"));
+	const resolvers = [consumerRequire];
+	try {
+		resolvers.push(createRequire(consumerRequire.resolve("@ox-content/vite-plugin")));
+	} catch {}
+	resolvers.push(createRequire(import.meta.url));
+	return resolvers;
+}
+function decodeHtmlAttr$2(value) {
+	return value.replaceAll("&quot;", "\"").replaceAll("&#39;", "'").replaceAll("&lt;", "<").replaceAll("&gt;", ">").replaceAll("&amp;", "&");
+}
+function warnMissingKatexOnce() {
+	if (missingWarned) return;
+	missingWarned = true;
+	console.warn("[ox-content] math is enabled but `katex` was not found. Install it with `npm i -D katex` to render LaTeX; escaped TeX placeholders are left as-is.");
+}
+//#endregion
 //#region src/plugins/pm.ts
 /**
 * Package Manager Tabs Plugin
@@ -553,15 +627,15 @@ function assetRecord(src, media) {
 //#region src/plugins/twitter/render.ts
 function renderFetchedTweet(permalink, data, assets, options) {
 	const profile = `https://x.com/${encodeURIComponent(data.user.screen_name)}`;
-	const author = escapeHtml$5(data.user.name);
-	const handle = escapeHtml$5(data.user.screen_name);
-	const avatar = assets.avatar ? `<img class="ox-tweet__avatar" src="${escapeAttribute(assets.avatar)}" alt="" width="48" height="48" loading="lazy" decoding="async">` : "";
+	const author = escapeHtml$6(data.user.name);
+	const handle = escapeHtml$6(data.user.screen_name);
+	const avatar = assets.avatar ? `<img class="ox-tweet__avatar" src="${escapeAttribute$2(assets.avatar)}" alt="" width="48" height="48" loading="lazy" decoding="async">` : "";
 	const media = renderMedia(assets);
 	const footer = renderFooter(permalink, data.created_at, options.lang);
 	return [
 		"<figure class=\"ox-tweet ox-tweet--fetched\">",
 		"<header class=\"ox-tweet__header\">",
-		`<a class="ox-tweet__profile" href="${escapeAttribute(profile)}" target="_blank" rel="noopener noreferrer">`,
+		`<a class="ox-tweet__profile" href="${escapeAttribute$2(profile)}" target="_blank" rel="noopener noreferrer">`,
 		avatar,
 		`<span class="ox-tweet__author-name">${author}</span>`,
 		`<span class="ox-tweet__author-handle">@${handle}</span>`,
@@ -584,7 +658,7 @@ function renderTweetText(data) {
 		if (entity.kind === "url") {
 			const href = entity.expanded_url ?? entity.url;
 			const label = entity.display_url ?? href;
-			output += `<a href="${escapeAttribute(href)}" target="_blank" rel="noopener noreferrer">${escapeHtml$5(label)}</a>`;
+			output += `<a href="${escapeAttribute$2(href)}" target="_blank" rel="noopener noreferrer">${escapeHtml$6(label)}</a>`;
 		}
 		cursor = entityEnd;
 	}
@@ -607,12 +681,12 @@ function renderMedia(assets) {
 	if (assets.media.length === 0) return "";
 	const images = assets.media.map((item) => {
 		const size = [item.width ? ` width="${item.width}"` : "", item.height ? ` height="${item.height}"` : ""].join("");
-		return `<img class="ox-tweet__media-item" src="${escapeAttribute(item.src)}" alt="${escapeAttribute(item.alt ?? "")}"${size} loading="lazy" decoding="async">`;
+		return `<img class="ox-tweet__media-item" src="${escapeAttribute$2(item.src)}" alt="${escapeAttribute$2(item.alt ?? "")}"${size} loading="lazy" decoding="async">`;
 	}).join("");
 	return `<div class="ox-tweet__media" data-count="${assets.media.length}">${images}</div>`;
 }
 function renderFooter(permalink, createdAt, lang) {
-	if (!createdAt) return `<footer class="ox-tweet__footer"><a class="ox-tweet__permalink" href="${escapeAttribute(permalink)}" target="_blank" rel="noopener noreferrer">View on X</a></footer>`;
+	if (!createdAt) return `<footer class="ox-tweet__footer"><a class="ox-tweet__permalink" href="${escapeAttribute$2(permalink)}" target="_blank" rel="noopener noreferrer">View on X</a></footer>`;
 	const date = new Date(createdAt);
 	if (Number.isNaN(date.valueOf())) return renderFooter(permalink, void 0, lang);
 	const iso = date.toISOString();
@@ -628,15 +702,15 @@ function renderFooter(permalink, createdAt, lang) {
 			timeZone: "UTC"
 		}).format(date);
 	}
-	return `<footer class="ox-tweet__footer"><a class="ox-tweet__permalink" href="${escapeAttribute(permalink)}" target="_blank" rel="noopener noreferrer"><time datetime="${iso}">${escapeHtml$5(label)}</time></a></footer>`;
+	return `<footer class="ox-tweet__footer"><a class="ox-tweet__permalink" href="${escapeAttribute$2(permalink)}" target="_blank" rel="noopener noreferrer"><time datetime="${iso}">${escapeHtml$6(label)}</time></a></footer>`;
 }
 function escapeText(value) {
-	return escapeHtml$5(value).replaceAll("\n", "<br>");
+	return escapeHtml$6(value).replaceAll("\n", "<br>");
 }
-function escapeAttribute(value) {
-	return escapeHtml$5(value).replaceAll("`", "&#96;");
+function escapeAttribute$2(value) {
+	return escapeHtml$6(value).replaceAll("`", "&#96;");
 }
-function escapeHtml$5(value) {
+function escapeHtml$6(value) {
 	return value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll("\"", "&quot;").replaceAll("'", "&#39;");
 }
 //#endregion
@@ -757,6 +831,11 @@ function sourceKey(source) {
 function formatLineRange(lines) {
 	return lines.start === lines.end ? `L${lines.start}` : `L${lines.start}-L${lines.end}`;
 }
+function summarizeCommitMessage(message) {
+	const firstLine = message.split(/\r?\n/, 1)[0]?.replace(/\s+/g, " ").trim() ?? "";
+	if (firstLine.length <= 120) return firstLine;
+	return `${firstLine.slice(0, 119)}…`;
+}
 function parseGitHubLineRange(value) {
 	if (!value) return void 0;
 	const match = value.trim().match(/^#?L?(\d+)(?:-L?(\d+))?$/i);
@@ -831,6 +910,24 @@ function githubHeaders(options) {
 	if (options.token) headers.Authorization = `Bearer ${options.token}`;
 	return headers;
 }
+async function fetchSourceCommit(source, options) {
+	try {
+		const apiUrl = `https://api.github.com/repos/${source.repo}/commits?path=${encodeURIComponent(source.path)}&sha=${encodeURIComponent(source.ref)}&per_page=1`;
+		const response = await fetch(apiUrl, { headers: githubHeaders(options) });
+		if (!response.ok) return;
+		const item = (await response.json())[0];
+		const sha = item?.sha;
+		const message = item?.commit?.message ? summarizeCommitMessage(item.commit.message) : "";
+		if (!sha || !message) return;
+		return {
+			sha,
+			message,
+			html_url: item.html_url ?? `https://github.com/${source.repo}/commit/${sha}`
+		};
+	} catch {
+		return;
+	}
+}
 /**
 * Fetch repository data from GitHub API.
 */
@@ -869,7 +966,7 @@ async function fetchGitHubSource(source, options) {
 	}
 	try {
 		const apiUrl = `https://api.github.com/repos/${source.repo}/contents/${encodePath(source.path)}?ref=${encodeURIComponent(source.ref)}`;
-		const response = await fetch(apiUrl, { headers: githubHeaders(options) });
+		const [response, commit] = await Promise.all([fetch(apiUrl, { headers: githubHeaders(options) }), fetchSourceCommit(source, options)]);
 		if (!response.ok) {
 			console.warn(`Failed to fetch GitHub source ${source.permalink}: ${response.status}`);
 			return null;
@@ -886,7 +983,8 @@ async function fetchGitHubSource(source, options) {
 			content,
 			size: data.size ?? Buffer$1.byteLength(content),
 			html_url: data.html_url ?? source.permalink,
-			language: inferLanguage(source.path)
+			language: inferLanguage(source.path),
+			...commit ? { commit } : {}
 		};
 		if (options.cache) sourceCache.set(key, {
 			data: sourceData,
@@ -1180,19 +1278,76 @@ function normalizeSourceLines(content) {
 	if (lines.length > 1 && lines.at(-1) === "") lines.pop();
 	return lines.length > 0 ? lines : [""];
 }
+function text(value) {
+	return {
+		type: "text",
+		value
+	};
+}
+function createSourceLines(lines, start) {
+	return lines.flatMap((line, index) => {
+		const lineNumber = start + index;
+		const span = {
+			type: "element",
+			tagName: "span",
+			properties: {
+				className: ["line"],
+				"data-line": String(lineNumber),
+				"data-line-number": String(lineNumber)
+			},
+			children: [text(line)]
+		};
+		return index === 0 ? [span] : [text("\n"), span];
+	});
+}
+function createCommitMeta(commit) {
+	return {
+		type: "element",
+		tagName: "a",
+		properties: {
+			className: ["ox-github-code-commit"],
+			href: commit.html_url,
+			target: "_blank",
+			rel: "noopener noreferrer",
+			title: commit.message
+		},
+		children: [{
+			type: "element",
+			tagName: "span",
+			properties: { className: ["ox-github-code-sha"] },
+			children: [text(commit.sha.slice(0, 7))]
+		}, {
+			type: "element",
+			tagName: "span",
+			properties: { className: ["ox-github-code-commit-message"] },
+			children: [text(commit.message)]
+		}]
+	};
+}
 function createGitHubSourceCard(source, lines, options) {
 	const allLines = normalizeSourceLines(source.content);
 	const start = Math.min(lines?.start ?? 1, allLines.length);
 	const end = lines ? Math.min(lines.end, allLines.length) : Math.min(allLines.length, options.maxSourceLines);
 	const selectedLines = allLines.slice(start - 1, end);
-	const lineRange = {
+	const loc = selectedLines.length;
+	const rangeLabel = formatLineRange({
 		start,
 		end
-	};
-	const loc = selectedLines.length;
-	const rangeLabel = formatLineRange(lineRange);
-	const locLabel = !lines && end < allLines.length ? `${rangeLabel} of ${allLines.length} LOC` : `${rangeLabel} - ${loc} LOC`;
+	});
+	const locLabel = !lines && end < allLines.length ? `${rangeLabel} of ${allLines.length} LOC` : `${rangeLabel} · ${loc} LOC`;
 	const languageClass = source.language ? [`language-${source.language}`] : [];
+	const heading = [{
+		type: "element",
+		tagName: "a",
+		properties: {
+			className: ["ox-github-code-title"],
+			href: source.permalink,
+			target: "_blank",
+			rel: "noopener noreferrer"
+		},
+		children: [text(`${source.repo}/${source.path}`)]
+	}];
+	if (source.commit) heading.push(createCommitMeta(source.commit));
 	return {
 		type: "element",
 		tagName: "figure",
@@ -1207,65 +1362,34 @@ function createGitHubSourceCard(source, lines, options) {
 			properties: { className: ["ox-github-code-header"] },
 			children: [{
 				type: "element",
-				tagName: "a",
-				properties: {
-					className: ["ox-github-code-title"],
-					href: source.permalink,
-					target: "_blank",
-					rel: "noopener noreferrer"
-				},
-				children: [{
-					type: "text",
-					value: `${source.repo}/${source.path}`
-				}]
+				tagName: "div",
+				properties: { className: ["ox-github-code-heading"] },
+				children: heading
 			}, {
 				type: "element",
 				tagName: "span",
 				properties: { className: ["ox-github-code-loc"] },
-				children: [{
-					type: "text",
-					value: locLabel
-				}]
+				children: [text(locLabel)]
 			}]
 		}, {
 			type: "element",
 			tagName: "pre",
 			properties: {
-				className: ["ox-github-code-block", ...languageClass],
+				className: [
+					"ox-github-code-block",
+					"ox-code-block",
+					"line-numbers-mode",
+					...languageClass
+				],
+				"data-line-numbers": "true",
+				"data-line-number-start": String(start),
 				...source.language ? { "data-language": source.language } : {}
 			},
 			children: [{
 				type: "element",
 				tagName: "code",
 				properties: { className: languageClass },
-				children: selectedLines.map((line, index) => {
-					const lineNumber = start + index;
-					return {
-						type: "element",
-						tagName: "span",
-						properties: {
-							className: ["line", "ox-github-code-line"],
-							"data-line": String(lineNumber)
-						},
-						children: [{
-							type: "element",
-							tagName: "span",
-							properties: { className: ["ox-github-code-line-number"] },
-							children: [{
-								type: "text",
-								value: String(lineNumber)
-							}]
-						}, {
-							type: "element",
-							tagName: "span",
-							properties: { className: ["ox-github-code-line-content"] },
-							children: [{
-								type: "text",
-								value: line || " "
-							}]
-						}]
-					};
-				})
+				children: createSourceLines(selectedLines, start)
 			}]
 		}]
 	};
@@ -1864,6 +1988,368 @@ function normalizeDiagnostic(diagnostic) {
 	};
 }
 //#endregion
+//#region src/typed-hover-generate.ts
+async function loadTsgoApi() {
+	try {
+		return await import("./api.mjs");
+	} catch {
+		return;
+	}
+}
+async function generateTypedHoverAttachments(fences, tsgoCommand) {
+	if (fences.length === 0) return [];
+	const apiMod = await loadTsgoApi();
+	if (!apiMod) return fences.map((fence) => ({
+		code: fence.code,
+		hovers: []
+	}));
+	const temp = await mkdtemp(join(tmpdir(), "ox-content-typed-hover-"));
+	const api = new apiMod.API({
+		cwd: temp,
+		...tsgoCommand ? { tsserverPath: tsgoCommand } : {}
+	});
+	try {
+		const files = await Promise.all(fences.map(async (fence, index) => {
+			const extension = fence.language.toLowerCase() === "tsx" ? "tsx" : "ts";
+			const file = join(temp, `snippet-${index}.${extension}`);
+			await writeFile(file, fence.code);
+			return {
+				fence,
+				file
+			};
+		}));
+		const snapshot = api.updateSnapshot({ openFiles: files.map((item) => item.file) });
+		return files.map(({ fence, file }) => {
+			const project = snapshot.getDefaultProjectForFile(file);
+			if (!project) return {
+				code: fence.code,
+				hovers: []
+			};
+			const hovers = [];
+			for (const ident of collectIdentifierRanges(fence.code)) {
+				const type = project.checker.getTypeAtPosition(file, ident.start);
+				if (!type || type.isErrorType?.()) continue;
+				const widened = project.checker.getBaseTypeOfLiteralType(type) ?? type;
+				const text = project.checker.typeToString(widened);
+				if (text) hovers.push({
+					start: ident.start,
+					end: ident.end,
+					type: text
+				});
+			}
+			return {
+				code: fence.code,
+				hovers
+			};
+		});
+	} finally {
+		api.close();
+		await rm(temp, {
+			recursive: true,
+			force: true
+		});
+	}
+}
+const IDENTIFIER_KEYWORDS = /* @__PURE__ */ new Set([
+	"abstract",
+	"any",
+	"as",
+	"asserts",
+	"async",
+	"await",
+	"bigint",
+	"boolean",
+	"break",
+	"case",
+	"catch",
+	"class",
+	"const",
+	"continue",
+	"debugger",
+	"declare",
+	"default",
+	"delete",
+	"do",
+	"else",
+	"enum",
+	"export",
+	"extends",
+	"false",
+	"finally",
+	"for",
+	"from",
+	"function",
+	"if",
+	"implements",
+	"import",
+	"in",
+	"infer",
+	"instanceof",
+	"interface",
+	"is",
+	"keyof",
+	"let",
+	"never",
+	"new",
+	"null",
+	"number",
+	"object",
+	"of",
+	"package",
+	"private",
+	"protected",
+	"public",
+	"readonly",
+	"return",
+	"satisfies",
+	"static",
+	"string",
+	"super",
+	"switch",
+	"symbol",
+	"this",
+	"throw",
+	"true",
+	"try",
+	"type",
+	"typeof",
+	"undefined",
+	"unique",
+	"unknown",
+	"using",
+	"var",
+	"void",
+	"while",
+	"with",
+	"yield"
+]);
+function collectIdentifierRanges(code) {
+	const ranges = [];
+	let index = 0;
+	while (index < code.length) {
+		const char = code[index];
+		if (char === "/" && code[index + 1] === "/") {
+			index = code.indexOf("\n", index);
+			if (index === -1) break;
+			continue;
+		}
+		if (char === "/" && code[index + 1] === "*") {
+			const close = code.indexOf("*/", index + 2);
+			index = close === -1 ? code.length : close + 2;
+			continue;
+		}
+		if (char === "\"" || char === "'" || char === "`") {
+			index = skipQuoted(code, index, char);
+			continue;
+		}
+		if (/[A-Za-z_$]/.test(char)) {
+			const start = index;
+			index += 1;
+			while (index < code.length && /[\w$]/.test(code[index])) index += 1;
+			const name = code.slice(start, index);
+			if (!IDENTIFIER_KEYWORDS.has(name)) ranges.push({
+				start,
+				end: index
+			});
+			continue;
+		}
+		index += 1;
+	}
+	return ranges;
+}
+function skipQuoted(code, start, quote) {
+	let index = start + 1;
+	while (index < code.length) {
+		if (code[index] === "\\") {
+			index += 2;
+			continue;
+		}
+		if (code[index] === quote) return index + 1;
+		index += 1;
+	}
+	return code.length;
+}
+//#endregion
+//#region src/typed-hover.ts
+const DEFAULT_LANGUAGES$1 = ["ts", "tsx"];
+function resolveTypedHoverOptions(options) {
+	if (!options) return {
+		enabled: false,
+		languages: [...DEFAULT_LANGUAGES$1]
+	};
+	if (options === true) return {
+		enabled: true,
+		languages: [...DEFAULT_LANGUAGES$1]
+	};
+	return {
+		enabled: options.enabled ?? true,
+		languages: options.languages ?? [...DEFAULT_LANGUAGES$1],
+		tsgoCommand: options.tsgoCommand
+	};
+}
+function hasTypedHoverMeta(meta) {
+	return meta.split(/\s+/).some((token) => token === "twoslash");
+}
+function serializeTypedHoverPayload(payload) {
+	return JSON.stringify(payload).replace(/</g, "\\u003c").replace(/>/g, "\\u003e");
+}
+async function applyTypedHover(source, html, options) {
+	if (!options?.enabled || !source.includes("```")) return html;
+	const languages = new Set(options.languages.map((language) => language.toLowerCase()));
+	const fences = (await extractCodeBlocks(source)).filter((block) => {
+		return languages.has(block.language.toLowerCase()) && hasTypedHoverMeta(block.meta);
+	});
+	if (fences.length === 0) return html;
+	try {
+		return attachTypedHoverPayloads(html, await generateTypedHoverAttachments(fences, options.tsgoCommand));
+	} catch {
+		return html;
+	}
+}
+function attachTypedHoverPayloads(html, attachments) {
+	const unused = attachments.filter((item) => item.hovers.length > 0);
+	if (unused.length === 0) return html;
+	let attached = 0;
+	const next = html.replace(/<pre(\b[^>]*)><code(\b[^>]*)>([\s\S]*?)<\/code><\/pre>/g, (full, preAttrs, codeAttrs, inner) => {
+		if (unused.length === 0) return full;
+		if (!isTypeScriptFence(codeAttrs)) return full;
+		const text = decodeHtmlEntities(inner.replace(/<[^>]+>/g, ""));
+		const index = unused.findIndex((item) => normalizeFenceText(item.code) === normalizeFenceText(text));
+		if (index === -1) return full;
+		const item = unused.splice(index, 1)[0];
+		if (!item) return full;
+		attached += 1;
+		const wrapped = wrapHoverRanges(inner, item.hovers);
+		return `${withTypedHoverClass(`<pre${preAttrs}`)}><code${codeAttrs}>${wrapped}</code></pre>\n<script type="application/json" class="ox-typed-hover-data">${serializeTypedHoverPayload({ hovers: item.hovers })}<\/script>`;
+	});
+	if (attached === 0) return html;
+	return `${next}${TYPED_HOVER_STYLE}${TYPED_HOVER_CLIENT}`;
+}
+function isTypeScriptFence(codeAttrs) {
+	const match = codeAttrs.match(/class="([^"]*)"/);
+	if (!match?.[1]) return false;
+	return match[1].split(/\s+/).some((token) => {
+		const language = token.replace(/^language-/, "").toLowerCase();
+		return language === "ts" || language === "tsx" || language === "typescript" || language === "typescriptreact";
+	});
+}
+function withTypedHoverClass(openPre) {
+	if (/\bclass="/.test(openPre)) return openPre.replace(/\bclass="([^"]*)"/, (_, classes) => {
+		return `class="${classes} ox-typed-hover"`;
+	});
+	return `${openPre} class="ox-typed-hover"`;
+}
+function wrapHoverRanges(inner, hovers) {
+	const ranges = [...hovers].sort((a, b) => a.start - b.start || b.end - a.end);
+	let output = "";
+	let htmlIndex = 0;
+	let sourceOffset = 0;
+	let rangeIndex = 0;
+	let openUntil = -1;
+	let openHoverIndex = -1;
+	const startRange = () => {
+		while (rangeIndex < ranges.length && ranges[rangeIndex].start < sourceOffset) rangeIndex += 1;
+		const range = ranges[rangeIndex];
+		if (!range || range.start !== sourceOffset || openUntil !== -1) return;
+		output += `<span class="ox-typed-hover-token" tabindex="0" data-ox-typed-hover="${rangeIndex}">`;
+		openUntil = range.end;
+		openHoverIndex = rangeIndex;
+		rangeIndex += 1;
+	};
+	const endRange = () => {
+		if (openUntil === sourceOffset && openHoverIndex !== -1) {
+			output += "</span>";
+			openUntil = -1;
+			openHoverIndex = -1;
+		}
+	};
+	while (htmlIndex < inner.length) {
+		const char = inner[htmlIndex];
+		if (char === "<") {
+			const close = inner.indexOf(">", htmlIndex);
+			const tag = close === -1 ? inner.slice(htmlIndex) : inner.slice(htmlIndex, close + 1);
+			output += tag;
+			htmlIndex += tag.length;
+			continue;
+		}
+		startRange();
+		if (char === "&") {
+			const semi = inner.indexOf(";", htmlIndex);
+			const entity = semi === -1 ? inner.slice(htmlIndex) : inner.slice(htmlIndex, semi + 1);
+			output += entity;
+			htmlIndex += entity.length;
+			sourceOffset += 1;
+			endRange();
+			continue;
+		}
+		output += char;
+		htmlIndex += 1;
+		sourceOffset += 1;
+		endRange();
+	}
+	if (openHoverIndex !== -1) output += "</span>";
+	return output;
+}
+function normalizeFenceText(value) {
+	return decodeHtmlEntities(value).replace(/\r\n/g, "\n").trim();
+}
+function decodeHtmlEntities(value) {
+	return value.replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&amp;/g, "&").replace(/&quot;/g, "\"").replace(/&#39;/g, "'");
+}
+const TYPED_HOVER_STYLE = `<style data-ox-typed-hover-style>.ox-typed-hover-token{cursor:help;text-decoration:underline dotted}.ox-typed-hover-overlay{position:fixed;z-index:50;max-width:36rem;padding:.35rem .55rem;border:1px solid #444;border-radius:4px;background:#1e1e1e;color:#d4d4d4;font:12px/1.4 ui-monospace,SFMono-Regular,Menlo,monospace;white-space:pre-wrap;pointer-events:none}</style>`;
+const TYPED_HOVER_CLIENT = `<script data-ox-typed-hover-runtime>(function(){if(window.__oxTypedHover)return;window.__oxTypedHover=1;var tip=document.createElement("div");tip.className="ox-typed-hover-overlay";tip.setAttribute("role","tooltip");tip.hidden=true;document.body.appendChild(tip);function payload(token){var pre=token.closest(".ox-typed-hover");var data=pre&&pre.nextElementSibling;if(!data||!data.classList.contains("ox-typed-hover-data"))return null;try{return JSON.parse(data.textContent||"")}catch(e){return null}}function show(token){var data=payload(token);var item=data&&data.hovers[Number(token.getAttribute("data-ox-typed-hover"))];if(!item)return;tip.textContent=item.type;tip.hidden=false;var box=token.getBoundingClientRect();tip.style.left=Math.max(8,box.left)+"px";tip.style.top=Math.max(8,box.top-tip.offsetHeight-8)+"px"}function hide(){tip.hidden=true}document.addEventListener("mouseover",function(e){var t=e.target.closest(".ox-typed-hover-token");if(t)show(t)});document.addEventListener("mouseout",function(e){var t=e.target.closest(".ox-typed-hover-token");if(t&&!t.contains(e.relatedTarget))hide()});document.addEventListener("focusin",function(e){var t=e.target.closest(".ox-typed-hover-token");if(t)show(t)});document.addEventListener("focusout",function(e){if(!e.relatedTarget||!e.relatedTarget.closest(".ox-typed-hover-token"))hide()});document.addEventListener("keydown",function(e){if(e.key==="Escape")hide()})})();<\/script>`;
+//#endregion
+//#region src/file-tree-options.ts
+const disabled = {
+	enabled: false,
+	defaultOpen: true,
+	icons: true
+};
+function resolveFileTreeOptions(options) {
+	if (!options) return { ...disabled };
+	if (options === true) return enabledDefaults();
+	if (options.enabled === false) return {
+		...enabledDefaults(),
+		enabled: false,
+		...resolveIcons(options.icons)
+	};
+	return {
+		enabled: options.enabled ?? true,
+		defaultOpen: options.defaultOpen ?? true,
+		...resolveIcons(options.icons)
+	};
+}
+function toJsFileTreeOptions(options) {
+	if (!options?.enabled) return void 0;
+	return {
+		enabled: true,
+		defaultOpen: options.defaultOpen,
+		icons: options.icons,
+		iconFolder: options.iconFolder,
+		iconFolderOpen: options.iconFolderOpen,
+		iconFile: options.iconFile,
+		iconFiles: options.iconFiles
+	};
+}
+function enabledDefaults() {
+	return {
+		enabled: true,
+		defaultOpen: true,
+		icons: true
+	};
+}
+function resolveIcons(icons) {
+	if (icons === false) return { icons: false };
+	if (icons === true || icons == null) return { icons: true };
+	return {
+		icons: true,
+		iconFolder: icons.folder,
+		iconFolderOpen: icons.folderOpen,
+		iconFile: icons.file,
+		iconFiles: icons.files
+	};
+}
+//#endregion
 //#region src/transform.ts
 /**
 * The NAPI load, cached as the promise rather than as its result.
@@ -1974,7 +2460,7 @@ async function transformMarkdown(source, filePath, options, ssgOptions) {
 		} : void 0,
 		cards: options.cards?.enabled ? { enabled: true } : void 0,
 		steps: options.steps?.enabled ? { enabled: true } : void 0,
-		fileTree: options.fileTree?.enabled ? { enabled: true } : void 0,
+		fileTree: toJsFileTreeOptions(options.fileTree),
 		sanitize: void 0,
 		editThisPage: options.editThisPage?.enabled ? {
 			enabled: true,
@@ -1992,26 +2478,27 @@ async function transformMarkdown(source, filePath, options, ssgOptions) {
 	if (options.mermaid) html = await transformMermaidStatic(html);
 	const { html: protectedHtml, svgs } = protectMermaidSvgs(html);
 	html = protectedHtml;
-	if (options.highlight) {
-		const native = await highlightDocumentNatively(html);
-		if (native && native.skipped.length === 0) html = native.html;
-		else {
-			const originalHtml = html;
-			const highlightedHtml = await highlightCode(html);
-			html = napi.mergeHighlightedCodeBlocks(originalHtml, highlightedHtml);
-		}
-	}
+	if (options.highlight) html = await highlightPageHtml(html, napi.mergeHighlightedCodeBlocks);
 	html = await transformBuiltinEmbeds(html, options.embeds ?? {
 		github: {},
 		openGraph: {}
 	});
+	if (options.highlight && html.includes("ox-github-code-block")) html = await highlightPageHtml(html, napi.mergeHighlightedCodeBlocks);
 	html = restoreMermaidSvgs(html, svgs);
 	if (options.sanitize?.enabled) html = napi.sanitizeHtml(html, toJsSanitizeOptions(options.sanitize));
+	if (isMathEnabled(options.math)) html = await renderKatexMath(html);
+	const imports = result.imports ?? [];
+	const exports = result.exports ?? [];
+	const components = result.components ?? [];
+	html = await applyTypedHover(source, html, options.typedHover);
 	return {
-		code: generateModuleCode(html, frontmatter, toc, filePath, options),
+		code: generateModuleCode(html, frontmatter, toc, imports, exports, components, filePath),
 		html,
 		frontmatter,
-		toc
+		toc,
+		imports,
+		exports,
+		components
 	};
 }
 async function runCodeBlockTypecheck(source, options) {
@@ -2070,8 +2557,11 @@ function normalizeTocEntry(entry) {
 }
 /**
 * Generates the JavaScript module code.
+*
+* MDX metadata is serialized as JSON. User `import` / `export` source is never
+* emitted as live JavaScript, so transform does not execute module side effects.
 */
-function generateModuleCode(html, frontmatter, toc, filePath, _options) {
+function generateModuleCode(html, frontmatter, toc, imports, exports, components, filePath) {
 	return `
 // Generated by @ox-content/vite-plugin
 // Source: ${filePath}
@@ -2091,6 +2581,21 @@ export const frontmatter = ${JSON.stringify(frontmatter)};
  */
 export const toc = ${JSON.stringify(toc)};
 
+/**
+ * MDX import statements collected from the AST.
+ */
+export const imports = ${JSON.stringify(imports)};
+
+/**
+ * MDX export names collected from the AST.
+ */
+export const exports = ${JSON.stringify(exports)};
+
+/**
+ * Unique JSX component names collected from the AST.
+ */
+export const components = ${JSON.stringify(components)};
+
 /**
  * Default export with all data.
  */
@@ -2098,6 +2603,9 @@ export default {
   html,
   frontmatter,
   toc,
+  imports,
+  exports,
+  components,
 };
 
 // HMR support
@@ -2548,7 +3056,7 @@ function formatChromiumUnavailableDetail(err) {
 /**
 * Escapes HTML special characters.
 */
-function escapeHtml$4(str) {
+function escapeHtml$5(str) {
 	return str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
 }
 function normalizeBrandValue(str) {
@@ -2611,12 +3119,12 @@ function getDefaultTemplate() {
 		const isBrandCard = normalizeBrandValue(title) === normalizeBrandValue(rawBrand);
 		const heroTitle = isBrandCard ? "High-performance Markdown toolkit" : title;
 		const heroDescription = isBrandCard ? "Rust-powered docs and high-performance Markdown tooling." : description && description.trim().length > 0 ? description : "Rust-powered docs and Markdown tooling.";
-		const descriptionHtml = heroDescription.trim().length > 0 ? `<p style="max-width:760px;font-size:28px;color:#93a4c3;line-height:1.45;margin:0;overflow:hidden;display:-webkit-box;-webkit-line-clamp:2;-webkit-box-orient:vertical;">${escapeHtml$4(heroDescription)}</p>` : "";
+		const descriptionHtml = heroDescription.trim().length > 0 ? `<p style="max-width:760px;font-size:28px;color:#93a4c3;line-height:1.45;margin:0;overflow:hidden;display:-webkit-box;-webkit-line-clamp:2;-webkit-box-orient:vertical;">${escapeHtml$5(heroDescription)}</p>` : "";
 		return `<div style="width:100%;height:100%;position:relative;overflow:hidden;box-sizing:border-box;padding:56px 64px 52px;background:#0b1220;font-family:'IBM Plex Sans','Avenir Next','Segoe UI',system-ui,sans-serif;color:#eff6ff;border:1px solid #223252;border-top:4px solid #4f6fae;">
   <div style="position:relative;z-index:1;display:flex;flex-direction:column;height:100%;">
     <div style="display:flex;align-items:flex-start;">${renderWordmarkSvg()}</div>
     <div style="display:flex;flex-direction:column;justify-content:center;gap:24px;max-width:860px;flex:1;padding:22px 0 0;">
-      <h1 style="font-size:78px;font-weight:700;color:#eff6ff;line-height:1.02;letter-spacing:-0.055em;margin:0;overflow:hidden;display:-webkit-box;-webkit-line-clamp:2;-webkit-box-orient:vertical;">${escapeHtml$4(heroTitle)}</h1>
+      <h1 style="font-size:78px;font-weight:700;color:#eff6ff;line-height:1.02;letter-spacing:-0.055em;margin:0;overflow:hidden;display:-webkit-box;-webkit-line-clamp:2;-webkit-box-orient:vertical;">${escapeHtml$5(heroTitle)}</h1>
       ${descriptionHtml}
     </div>
   </div>
@@ -2650,7 +3158,7 @@ function computeCacheKey(templateSource, props, width, height) {
 async function getCached(cacheDir, key) {
 	const filePath = path$2.join(cacheDir, `${key}.png`);
 	try {
-		return await fs$2.readFile(filePath);
+		return await fs$3.readFile(filePath);
 	} catch {
 		return null;
 	}
@@ -2659,9 +3167,9 @@ async function getCached(cacheDir, key) {
 * Writes a PNG buffer to the cache.
 */
 async function writeCache(cacheDir, key, png) {
-	await fs$2.mkdir(cacheDir, { recursive: true });
+	await fs$3.mkdir(cacheDir, { recursive: true });
 	const filePath = path$2.join(cacheDir, `${key}.png`);
-	await fs$2.writeFile(filePath, png);
+	await fs$3.writeFile(filePath, png);
 }
 //#endregion
 //#region \0@oxc-project+runtime@0.143.0/helpers/esm/usingCtx.js
@@ -3147,6 +3655,80 @@ async function renderSinglePage(entry, templateFn, templateSource, options, cach
 	}
 }
 //#endregion
+//#region src/plugins/math-assets.ts
+/**
+* Serve and copy KaTeX CSS/fonts only when the optional `katex` package exists.
+*/
+/**
+* Copies `katex.min.css` and `fonts/` into the SSG output.
+* Returns an empty list when KaTeX is not installed.
+*/
+async function copyKatexAssets(outDir) {
+	const dist = resolveKatexDist();
+	if (!dist) return [];
+	const dest = join(outDir, KATEX_ASSET_DIR);
+	await mkdir(join(dest, "fonts"), { recursive: true });
+	const cssDest = join(dest, "katex.min.css");
+	await copyFile(join(dist, "katex.min.css"), cssDest);
+	await cp(join(dist, "fonts"), join(dest, "fonts"), { recursive: true });
+	return [cssDest];
+}
+/** Dev-server middleware that serves `/__ox_katex__/*` from `katex/dist`. */
+function createKatexAssetsPlugin() {
+	return {
+		name: "ox-content:katex-assets",
+		configureServer(server) {
+			const dist = resolveKatexDist();
+			if (!dist) return;
+			server.middlewares.use((req, res, next) => {
+				const url = req.url ?? "";
+				const marker = `/${KATEX_ASSET_DIR}/`;
+				const index = url.indexOf(marker);
+				if (index === -1) {
+					next();
+					return;
+				}
+				const rel = decodeURIComponent(url.slice(index + marker.length).split("?")[0] ?? "");
+				const file = safeKatexFile(dist, rel);
+				if (!file) {
+					res.statusCode = 404;
+					res.end();
+					return;
+				}
+				stat(file).then((info) => {
+					if (!info.isFile()) {
+						res.statusCode = 404;
+						res.end();
+						return;
+					}
+					res.setHeader("Content-Type", katexContentType(file));
+					createReadStream(file).pipe(res);
+				}).catch(() => {
+					res.statusCode = 404;
+					res.end();
+				});
+			});
+		}
+	};
+}
+function safeKatexFile(dist, rel) {
+	if (!rel || rel.includes("\0") || rel.split(/[\\/]/).includes("..")) return null;
+	const full = resolve(dist, rel);
+	const root = resolve(dist) + sep;
+	if (full !== resolve(dist) && !full.startsWith(root)) return null;
+	const inside = relative(dist, full);
+	if (inside.startsWith("..") || inside.includes(`..${sep}`)) return null;
+	return full;
+}
+function katexContentType(file) {
+	const ext = extname(file);
+	if (ext === ".css") return "text/css; charset=utf-8";
+	if (ext === ".woff2") return "font/woff2";
+	if (ext === ".woff") return "font/woff";
+	if (ext === ".ttf") return "font/ttf";
+	return "application/octet-stream";
+}
+//#endregion
 //#region src/island/parse.ts
 /**
 * Island Parser
@@ -3755,6 +4337,7 @@ function renderPage(page, options) {
 			html: page.html,
 			toc: page.toc,
 			lastUpdated: page.lastUpdated,
+			contributors: page.contributors,
 			path: page.path,
 			url: page.url,
 			frontmatter: page.frontmatter,
@@ -3770,6 +4353,7 @@ function renderPage(page, options) {
 				html: p.html,
 				toc: p.toc,
 				lastUpdated: p.lastUpdated,
+				contributors: p.contributors,
 				path: p.path,
 				url: p.url,
 				frontmatter: p.frontmatter,
@@ -3830,8 +4414,8 @@ function DefaultTheme({ children }) {
 <head>
   <meta charset="UTF-8">
   <meta name="viewport" content="width=device-width, initial-scale=1.0">
-  <title>${escapeHtml$3(page.title)} - ${escapeHtml$3(site.name)}</title>
-  ${page.description ? `<meta name="description" content="${escapeHtml$3(page.description)}">` : ""}
+  <title>${escapeHtml$4(page.title)} - ${escapeHtml$4(site.name)}</title>
+  ${page.description ? `<meta name="description" content="${escapeHtml$4(page.description)}">` : ""}
   <style>
     :root {
       --octc-color-primary: #4f6fae;
@@ -3855,7 +4439,7 @@ function DefaultTheme({ children }) {
 </head>
 <body>
   <header>
-    <h1>${escapeHtml$3(site.name)}</h1>
+    <h1>${escapeHtml$4(site.name)}</h1>
   </header>
   <main>
     ${children.__html}
@@ -3863,7 +4447,7 @@ function DefaultTheme({ children }) {
 </body>
 </html>` };
 }
-function escapeHtml$3(str) {
+function escapeHtml$4(str) {
 	return str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
 }
 /**
@@ -3900,7 +4484,7 @@ function createTheme(config) {
 * String bodies follow `ox_content_ssg::generate_site_maps`. The Vite plugin
 * writes those files during SSG without adding a NAPI surface.
 */
-const MISSING_SITE_URL$1 = "[ox-content] siteMaps is enabled but ssg.siteUrl is not set; sitemap.xml, robots.txt, and llms.txt were not written";
+const MISSING_SITE_URL$2 = "[ox-content] siteMaps is enabled but ssg.siteUrl is not set; sitemap.xml, robots.txt, and llms.txt were not written";
 /**
 * Resolves `siteMaps` with defaults.
 *
@@ -3927,7 +4511,7 @@ function resolveSiteMapsOptions(value) {
 /** Builds sitemap / robots / llms bodies without writing files. */
 function generateSiteMaps(input) {
 	if (!input.options?.enabled) return {};
-	if (!hasSiteUrl$1(input.siteUrl)) return { warning: MISSING_SITE_URL$1 };
+	if (!hasSiteUrl$2(input.siteUrl)) return { warning: MISSING_SITE_URL$2 };
 	const published = input.pages.filter((page) => !page.draft && !page.unlisted && page.loc.length > 0).slice().sort((left, right) => left.loc < right.loc ? -1 : left.loc > right.loc ? 1 : 0);
 	const result = { sitemapXml: generateSitemapXml(published) };
 	if (input.options.robots) result.robotsTxt = generateRobotsTxt(input.sitemapLoc ?? "");
@@ -3954,20 +4538,20 @@ async function writeSiteMapFiles(input) {
 		[generated.llmsTxt, "llms.txt"]
 	].filter((entry) => entry[0] != null);
 	if (outputs.length === 0) return { files: [] };
-	await fs$1.mkdir(input.outDir, { recursive: true });
+	await fs$2.mkdir(input.outDir, { recursive: true });
 	const files = [];
 	for (const [body, name] of outputs) {
 		const outputPath = path$1.join(input.outDir, name);
-		await fs$1.writeFile(outputPath, body, "utf8");
+		await fs$2.writeFile(outputPath, body, "utf8");
 		files.push(outputPath);
 	}
 	return { files };
 }
-function hasSiteUrl$1(siteUrl) {
+function hasSiteUrl$2(siteUrl) {
 	return Boolean(siteUrl && siteUrl.trim());
 }
 function absoluteSitemapUrl(siteUrl, base) {
-	if (!hasSiteUrl$1(siteUrl)) return "";
+	if (!hasSiteUrl$2(siteUrl)) return "";
 	return `${(siteUrl ?? "").trim().replace(/\/+$/, "")}${!base || base === "/" ? "/" : base.endsWith("/") ? base : `${base}/`}sitemap.xml`;
 }
 function generateSitemapXml(pages) {
@@ -4153,7 +4737,7 @@ function resolvePageRoutes(input) {
 	if (!input.permalinks?.enabled) return {
 		pages: cascaded.map((page) => ({
 			source: page.source,
-			urlPath: normalizeUrlPath(page.fileUrl),
+			urlPath: normalizeUrlPath$1(page.fileUrl),
 			frontmatter: page.frontmatter
 		})),
 		errors: []
@@ -4181,7 +4765,7 @@ function resolvePageRoutes(input) {
 		errors
 	};
 }
-function normalizeUrlPath(value) {
+function normalizeUrlPath$1(value) {
 	const segments = pathSegments(value);
 	return segments.length === 0 ? "/" : segments.join("/");
 }
@@ -4215,10 +4799,10 @@ function applyCascade(pages, options) {
 	});
 }
 function resolveOne(page) {
-	const fileUrl = normalizeUrlPath(page.fileUrl);
+	const fileUrl = normalizeUrlPath$1(page.fileUrl);
 	const permalink = readString(page.frontmatter.permalink);
 	if (permalink !== void 0) {
-		const url = isSafePermalink(permalink) ? normalizeUrlPath(permalink) : void 0;
+		const url = isSafePermalink(permalink) ? normalizeUrlPath$1(permalink) : void 0;
 		return url ? { urlPath: url } : {
 			urlPath: fileUrl,
 			error: `[ox-content] rejected permalink ${JSON.stringify(permalink)} on ${page.source} (path escape); using the file-tree URL`
@@ -4237,7 +4821,7 @@ function resolveOne(page) {
 function rewriteSlug(fileUrl, slug) {
 	const trimmed = slug.trim();
 	if (trimmed.includes("/") || !isSafePermalink(trimmed)) return;
-	const normalized = normalizeUrlPath(trimmed);
+	const normalized = normalizeUrlPath$1(trimmed);
 	if (normalized === "/") return;
 	if (fileUrl === "/") return normalized;
 	const segments = fileUrl.split("/").filter(Boolean);
@@ -4354,8 +4938,8 @@ function applyCollectionRoutes(manifest, permalinks, cascade) {
 }
 /** Updates auto-nav hrefs after permalinks change a page URL. */
 function remapNavGroups(nav, kept, skippedFileUrls) {
-	const skipped = new Set(skippedFileUrls.map(normalizeUrlPath));
-	const byFile = new Map(kept.map((page) => [normalizeUrlPath(page.fileUrl), page]));
+	const skipped = new Set(skippedFileUrls.map(normalizeUrlPath$1));
+	const byFile = new Map(kept.map((page) => [normalizeUrlPath$1(page.fileUrl), page]));
 	return nav.map((group) => ({
 		...group,
 		items: remapNavItems(group.items, byFile, skipped)
@@ -4367,7 +4951,7 @@ function routePathsFromUrl(urlPath, srcDir, outDir, base, extension, siteUrl) {
 }
 function remapNavItems(items, byFile, skipped) {
 	return items.flatMap((item) => {
-		const key = normalizeUrlPath(item.path);
+		const key = normalizeUrlPath$1(item.path);
 		if (skipped.has(key)) return [];
 		const hit = byFile.get(key);
 		const children = item.children ? remapNavItems(item.children, byFile, skipped) : void 0;
@@ -4484,16 +5068,16 @@ function planRedirectFiles(input) {
 async function writeRedirectFiles(input) {
 	const plan = planRedirectFiles(input);
 	if (plan.files.length === 0 && !plan.netlify && !plan.headers && !plan.json) return { files: [] };
-	await fs$1.mkdir(input.outDir, { recursive: true });
+	await fs$2.mkdir(input.outDir, { recursive: true });
 	const files = [];
 	for (const entry of plan.files) {
 		const outputPath = path$1.join(input.outDir, entry.relativePath);
 		try {
-			await fs$1.access(outputPath);
+			await fs$2.access(outputPath);
 			continue;
 		} catch {
-			await fs$1.mkdir(path$1.dirname(outputPath), { recursive: true });
-			await fs$1.writeFile(outputPath, entry.html, "utf8");
+			await fs$2.mkdir(path$1.dirname(outputPath), { recursive: true });
+			await fs$2.writeFile(outputPath, entry.html, "utf8");
 			files.push(outputPath);
 		}
 	}
@@ -4504,14 +5088,14 @@ async function writeRedirectFiles(input) {
 	]) {
 		if (!body) continue;
 		const outputPath = path$1.join(input.outDir, name);
-		await fs$1.writeFile(outputPath, body, "utf8");
+		await fs$2.writeFile(outputPath, body, "utf8");
 		files.push(outputPath);
 	}
 	return { files };
 }
 /** Static HTML redirect body. `dest` is escaped. */
 function generateRedirectHtml(dest) {
-	const escaped = escapeHtml$2(dest);
+	const escaped = escapeHtml$3(dest);
 	return `\
 <!DOCTYPE html>
 <html lang="en">
@@ -4596,7 +5180,7 @@ function upsert(files, index, occupied, from, to, base) {
 		html
 	});
 }
-function escapeHtml$2(value) {
+function escapeHtml$3(value) {
 	return value.replace(/[&<>"']/g, (ch) => {
 		switch (ch) {
 			case "&": return "&amp;";
@@ -4994,7 +5578,7 @@ function createNativeTransformOptions(options) {
 		} : void 0,
 		cards: options.cards?.enabled ? { enabled: true } : void 0,
 		steps: options.steps?.enabled ? { enabled: true } : void 0,
-		fileTree: options.fileTree?.enabled ? { enabled: true } : void 0,
+		fileTree: toJsFileTreeOptions(options.fileTree),
 		editThisPage: options.editThisPage?.enabled ? {
 			enabled: true,
 			repoUrl: options.editThisPage.repoUrl,
@@ -5272,8 +5856,8 @@ function weekdayUtc(year, month, day) {
 * String bodies follow `ox_content_ssg::generate_feeds`. The Vite plugin
 * writes those files during SSG without adding a NAPI surface.
 */
-const MISSING_SITE_URL = "[ox-content] feeds is enabled but ssg.siteUrl is not set; RSS, Atom, and JSON feeds were not written";
-const DEFAULT_FORMATS = [
+const MISSING_SITE_URL$1 = "[ox-content] feeds is enabled but ssg.siteUrl is not set; RSS, Atom, and JSON feeds were not written";
+const DEFAULT_FORMATS$1 = [
 	"rss",
 	"atom",
 	"json"
@@ -5290,19 +5874,19 @@ const DEFAULT_PATH = "/";
 function resolveFeedsOptions(value) {
 	if (!value) return {
 		enabled: false,
-		formats: [...DEFAULT_FORMATS],
+		formats: [...DEFAULT_FORMATS$1],
 		limit: DEFAULT_LIMIT,
 		path: DEFAULT_PATH
 	};
 	if (value === true) return {
 		enabled: true,
-		formats: [...DEFAULT_FORMATS],
+		formats: [...DEFAULT_FORMATS$1],
 		limit: DEFAULT_LIMIT,
 		path: DEFAULT_PATH
 	};
 	return {
 		enabled: true,
-		formats: normalizeFormats(value.formats),
+		formats: normalizeFormats$1(value.formats),
 		collection: value.collection,
 		limit: value.limit ?? DEFAULT_LIMIT,
 		path: value.path ?? DEFAULT_PATH
@@ -5317,7 +5901,7 @@ function resolveFeedCollectionName(requested, collectionNames) {
 /** Builds RSS / Atom / JSON Feed bodies without writing files. */
 function generateFeeds(input) {
 	if (!input.options?.enabled) return {};
-	if (!hasSiteUrl(input.siteUrl)) return { warning: MISSING_SITE_URL };
+	if (!hasSiteUrl$1(input.siteUrl)) return { warning: MISSING_SITE_URL$1 };
 	const published = publishedItems(input);
 	const doc = feedDocument(input);
 	const result = {};
@@ -5340,17 +5924,17 @@ async function writeFeedFiles(input) {
 	].filter((entry) => entry[0] != null);
 	if (outputs.length === 0) return { files: [] };
 	const dest = outputDir(input.outDir, input.options?.path ?? DEFAULT_PATH);
-	await fs$1.mkdir(dest, { recursive: true });
+	await fs$2.mkdir(dest, { recursive: true });
 	const files = [];
 	for (const [body, name] of outputs) {
 		const outputPath = path$1.join(dest, name);
-		await fs$1.writeFile(outputPath, body, "utf8");
+		await fs$2.writeFile(outputPath, body, "utf8");
 		files.push(outputPath);
 	}
 	return { files };
 }
-function normalizeFormats(formats) {
-	if (!formats) return [...DEFAULT_FORMATS];
+function normalizeFormats$1(formats) {
+	if (!formats) return [...DEFAULT_FORMATS$1];
 	const seen = /* @__PURE__ */ new Set();
 	const resolved = [];
 	for (const format of formats) if ((format === "rss" || format === "atom" || format === "json") && !seen.has(format)) {
@@ -5359,7 +5943,7 @@ function normalizeFormats(formats) {
 	}
 	return resolved;
 }
-function hasSiteUrl(siteUrl) {
+function hasSiteUrl$1(siteUrl) {
 	return Boolean(siteUrl && siteUrl.trim());
 }
 function homePageUrl(siteUrl, base = "/") {
@@ -5411,7 +5995,7 @@ function normalizeItem(item, input) {
 		title: item.title ?? "",
 		description: typeof item.description === "string" ? item.description : void 0,
 		loc: item.loc || itemLoc(input, item),
-		date: parseDate(dateField(item.date ?? item.frontmatter?.date)) ?? parseDate(dateField(item.lastUpdated ?? item.frontmatter?.lastUpdated))
+		date: parseDate(dateField$1(item.date ?? item.frontmatter?.date)) ?? parseDate(dateField$1(item.lastUpdated ?? item.frontmatter?.lastUpdated))
 	};
 }
 function itemLoc(input, item) {
@@ -5419,49 +6003,254 @@ function itemLoc(input, item) {
 	const urlPath = (item.path ?? "").replace(/^\/+|\/+$/g, "");
 	return urlPath ? `${home}${urlPath}/` : home;
 }
-function dateField(value) {
+function dateField$1(value) {
 	if (typeof value === "string" && value.trim()) return value.trim();
 	if (typeof value === "number" && Number.isFinite(value)) return String(value);
 	if (value instanceof Date && !Number.isNaN(value.getTime())) return value.toISOString();
 }
 //#endregion
-//#region src/taxonomies-html.ts
+//#region src/pwa.ts
 /**
-* Escaped taxonomy HTML and confined output paths.
+* Opt-in web app manifest and conservative service worker.
+*
+* The Vite plugin writes those files during SSG without adding a NAPI surface.
+* Enabling `offline` injects a tiny client script that registers `sw.js`.
 */
-function relatedMarkup(pages) {
-	return `<nav class="ox-related" aria-label="Related pages"><h2>Related pages</h2><ul>${pages.map((page) => listItem(page.routePaths.href, page.title)).join("")}</ul></nav>`;
+const MISSING_SITE_URL = "[ox-content] pwa is enabled but ssg.siteUrl is not set; manifest.webmanifest and sw.js were not written";
+const DEFAULT_THEME_COLOR = "#000000";
+const DEFAULT_BACKGROUND_COLOR = "#ffffff";
+const MANIFEST_NAME = "manifest.webmanifest";
+const SERVICE_WORKER_NAME = "sw.js";
+/**
+* Resolves `pwa` with defaults.
+*
+* `false` / omitted stays off. `true` enables the manifest and offline
+* service worker. An object enables the feature and overrides only the
+* fields the site set.
+*/
+function resolvePwaOptions(value) {
+	if (!value) return {
+		enabled: false,
+		offline: true
+	};
+	if (value === true) return {
+		enabled: true,
+		offline: true
+	};
+	return {
+		enabled: true,
+		offline: value.offline ?? true,
+		name: value.name,
+		shortName: value.shortName,
+		themeColor: value.themeColor,
+		backgroundColor: value.backgroundColor,
+		startUrl: value.startUrl
+	};
 }
-function listPageContent(terms, base, urlName) {
-	const items = terms.map((term) => listItem(siteHref$2(base, urlName, term.slug), term.label)).join("");
-	return `<h1>${escapeHtml$1(displayTaxonomyName(urlName))}</h1><ul class="ox-taxonomy">${items}</ul>`;
+/** Builds manifest / service-worker bodies without writing files. */
+function generatePwa(input) {
+	if (!input.options?.enabled) return {};
+	if (!hasSiteUrl(input.siteUrl)) return { warning: MISSING_SITE_URL };
+	const base = normalizeBase(input.base);
+	const name = sanitizeManifestText(input.options.name ?? input.siteName ?? "");
+	const shortName = sanitizeManifestText(input.options.shortName ?? name);
+	const startUrl = sanitizeStartUrl(input.options.startUrl, base);
+	const themeColor = sanitizeColor(input.options.themeColor, DEFAULT_THEME_COLOR);
+	const backgroundColor = sanitizeColor(input.options.backgroundColor, DEFAULT_BACKGROUND_COLOR);
+	const result = { manifest: `${escapeJsonScript(JSON.stringify({
+		name,
+		short_name: shortName,
+		start_url: startUrl,
+		scope: base,
+		display: "standalone",
+		background_color: backgroundColor,
+		theme_color: themeColor
+	}, null, 2))}\n` };
+	if (input.options.offline) result.serviceWorker = generateServiceWorker(base);
+	return result;
 }
-function termPageContent(term) {
+/** Writes enabled PWA files into `outDir`. */
+async function writePwaFiles(input) {
+	const generated = generatePwa(input);
+	if (generated.warning) return {
+		files: [],
+		warning: generated.warning
+	};
+	const outputs = [[generated.manifest, MANIFEST_NAME], [generated.serviceWorker, SERVICE_WORKER_NAME]].filter((entry) => entry[0] != null);
+	if (outputs.length === 0) return { files: [] };
+	await fs$2.mkdir(input.outDir, { recursive: true });
+	const files = [];
+	for (const [body, name] of outputs) {
+		const outputPath = path$1.join(input.outDir, name);
+		await fs$2.writeFile(outputPath, body, "utf8");
+		files.push(outputPath);
+	}
+	return { files };
+}
+/**
+* Injects `rel=manifest` (and the service-worker register script when offline)
+* into a themed HTML document. Bare / fragment HTML is left unchanged.
+*/
+function injectPwaPageTags(html, input) {
+	if (!input.options?.enabled || !isThemedDocument(html)) return html;
+	const base = normalizeBase(input.base);
+	const manifestHref = escapeAttribute$1(`${base}${MANIFEST_NAME}`);
+	const themeColor = sanitizeColor(input.options.themeColor, DEFAULT_THEME_COLOR);
+	let next = insertBeforeTag(html, "</head>", `  ${[`<link rel="manifest" href="${manifestHref}">`, `<meta name="theme-color" content="${escapeAttribute$1(themeColor)}">`].join("\n  ")}\n`);
+	if (input.options.offline) {
+		const script = `<script>if("serviceWorker"in navigator)navigator.serviceWorker.register(${JSON.stringify(`${base}${SERVICE_WORKER_NAME}`)})<\/script>`;
+		next = insertBeforeTag(next, "</body>", `  ${script}\n`);
+	}
+	return next;
+}
+function generateServiceWorker(base) {
+	return `/* ox-content PWA service worker */
+const CACHE = "ox-content-pwa-v1";
+const ASSET_PREFIX = ${JSON.stringify(`${base}assets/`)};
+
+self.addEventListener("install", (event) => {
+  event.waitUntil(self.skipWaiting());
+});
+
+self.addEventListener("activate", (event) => {
+  event.waitUntil(self.clients.claim());
+});
+
+self.addEventListener("fetch", (event) => {
+  const request = event.request;
+  if (request.method !== "GET") return;
+  const url = new URL(request.url);
+  if (url.origin !== self.location.origin) return;
+
+  if (isHashedAsset(url.pathname)) {
+    event.respondWith(cacheFirst(request));
+    return;
+  }
+
+  if (isHtmlPage(request)) {
+    event.respondWith(networkFirst(request));
+  }
+});
+
+function isHashedAsset(pathname) {
+  if (!pathname.startsWith(ASSET_PREFIX)) return false;
+  return /-[0-9a-f]{8,}\\.[a-z0-9]+$/i.test(pathname);
+}
+
+function isHtmlPage(request) {
+  if (request.mode === "navigate") return true;
+  const accept = request.headers.get("accept") || "";
+  return accept.includes("text/html");
+}
+
+async function cacheFirst(request) {
+  const cache = await caches.open(CACHE);
+  const cached = await cache.match(request);
+  if (cached) return cached;
+  const response = await fetch(request);
+  if (response.ok) cache.put(request, response.clone());
+  return response;
+}
+
+async function networkFirst(request) {
+  const cache = await caches.open(CACHE);
+  try {
+    const response = await fetch(request);
+    if (response.ok) cache.put(request, response.clone());
+    return response;
+  } catch (error) {
+    const cached = await cache.match(request);
+    if (cached) return cached;
+    throw error;
+  }
+}
+`;
+}
+function hasSiteUrl(siteUrl) {
+	return Boolean(siteUrl && siteUrl.trim());
+}
+function normalizeBase(base) {
+	if (!base || base === "/") return "/";
+	return base.endsWith("/") ? base : `${base}/`;
+}
+function sanitizeManifestText(value) {
+	return value.split(/\s+/u).filter(Boolean).join(" ");
+}
+function sanitizeColor(value, fallback) {
+	if (!value) return fallback;
+	const trimmed = value.trim();
+	if (/^#[0-9A-Fa-f]{3,8}$/.test(trimmed)) return trimmed;
+	if (/^[a-zA-Z][a-zA-Z0-9-]{0,31}$/.test(trimmed)) return trimmed;
+	return fallback;
+}
+function sanitizeStartUrl(value, base) {
+	if (!value) return base;
+	const trimmed = value.trim();
+	if (!trimmed.startsWith("/") || trimmed.startsWith("//")) return base;
+	if (/[\n\r\t<>"'`]/.test(trimmed)) return base;
+	if (/^[a-zA-Z][a-zA-Z0-9+.-]*:/.test(trimmed)) return base;
+	return trimmed;
+}
+function isThemedDocument(html) {
+	return /<\/head>/i.test(html) && /<\/body>/i.test(html);
+}
+function insertBeforeTag(html, tag, snippet) {
+	const index = html.toLowerCase().lastIndexOf(tag.toLowerCase());
+	if (index === -1) return html;
+	return `${html.slice(0, index)}${snippet}${html.slice(index)}`;
+}
+function escapeJsonScript(value) {
+	return value.replace(/[<>]/g, (ch) => ch === "<" ? "\\u003c" : "\\u003e");
+}
+function escapeAttribute$1(value) {
+	return value.replace(/[&<>"']/g, (ch) => {
+		switch (ch) {
+			case "&": return "&amp;";
+			case "<": return "&lt;";
+			case ">": return "&gt;";
+			case "\"": return "&quot;";
+			default: return "&#39;";
+		}
+	});
+}
+//#endregion
+//#region src/taxonomies-html.ts
+/**
+* Escaped taxonomy HTML and confined output paths.
+*/
+function relatedMarkup(pages) {
+	return `<nav class="ox-related" aria-label="Related pages"><h2>Related pages</h2><ul>${pages.map((page) => listItem$1(page.routePaths.href, page.title)).join("")}</ul></nav>`;
+}
+function listPageContent(terms, base, urlName) {
+	const items = terms.map((term) => listItem$1(siteHref$3(base, urlName, term.slug), term.label)).join("");
+	return `<h1>${escapeHtml$2(displayTaxonomyName(urlName))}</h1><ul class="ox-taxonomy">${items}</ul>`;
+}
+function termPageContent(term) {
 	const items = [...term.pages].sort((left, right) => {
 		const titleCmp = left.title.localeCompare(right.title);
 		return titleCmp !== 0 ? titleCmp : left.routePaths.href.localeCompare(right.routePaths.href);
-	}).map((page) => listItem(page.routePaths.href, page.title)).join("");
-	return `<h1>${escapeHtml$1(term.label)}</h1><ul class="ox-taxonomy-term">${items}</ul>`;
+	}).map((page) => listItem$1(page.routePaths.href, page.title)).join("");
+	return `<h1>${escapeHtml$2(term.label)}</h1><ul class="ox-taxonomy-term">${items}</ul>`;
 }
 function displayTaxonomyName(name) {
 	return name.charAt(0).toUpperCase() + name.slice(1);
 }
-function siteHref$2(base, ...segments) {
+function siteHref$3(base, ...segments) {
 	const prefix = !base || base === "/" ? "/" : base.endsWith("/") ? base : `${base}/`;
 	const rest = segments.filter(Boolean).join("/");
 	return rest ? `${prefix}${rest}/` : prefix;
 }
-function containedPath(outDir, ...segments) {
+function containedPath$2(outDir, ...segments) {
 	const root = path$1.resolve(outDir);
 	const resolved = path$1.resolve(root, ...segments);
 	const prefix = root.endsWith(path$1.sep) ? root : `${root}${path$1.sep}`;
 	if (resolved === root || !resolved.startsWith(prefix)) return;
 	return resolved;
 }
-function listItem(href, label) {
-	return `<li><a href="${escapeHtml$1(href)}">${escapeHtml$1(label)}</a></li>`;
+function listItem$1(href, label) {
+	return `<li><a href="${escapeHtml$2(href)}">${escapeHtml$2(label)}</a></li>`;
 }
-function escapeHtml$1(value) {
+function escapeHtml$2(value) {
 	return value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll("\"", "&quot;").replaceAll("'", "&#39;");
 }
 //#endregion
@@ -5474,7 +6263,7 @@ function escapeHtml$1(value) {
 */
 const DEFAULT_TAXONOMIES = ["tags", "categories"];
 const DEFAULT_RELATED_LIMIT = 5;
-const HOSTILE_TERM = /^(?:javascript|data):/i;
+const HOSTILE_TERM$1 = /^(?:javascript|data):/i;
 /**
 * Resolves `taxonomies` with defaults.
 *
@@ -5505,7 +6294,7 @@ function resolveTaxonomiesOptions(value) {
 */
 function termSlug(term) {
 	const trimmed = term.trim();
-	if (!trimmed || HOSTILE_TERM.test(trimmed) || trimmed.includes("..") || trimmed.includes("//")) return;
+	if (!trimmed || HOSTILE_TERM$1.test(trimmed) || trimmed.includes("..") || trimmed.includes("//")) return;
 	return trimmed.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "") || void 0;
 }
 /** Appends related-page HTML to source pages that share a listed term. */
@@ -5563,8 +6352,8 @@ function taxonomyPageSpecs(listed, options, outDir, base) {
 	for (const taxonomy of options.taxonomies) {
 		const urlName = taxonomy.toLowerCase();
 		const terms = collectTerms(listed, taxonomy);
-		const listHref = siteHref$2(base, urlName);
-		const listOutput = containedPath(outDir, urlName, "index.html");
+		const listHref = siteHref$3(base, urlName);
+		const listOutput = containedPath$2(outDir, urlName, "index.html");
 		if (listOutput) pages.push({
 			title: displayTaxonomyName(urlName),
 			content: listPageContent(terms, base, urlName),
@@ -5573,14 +6362,14 @@ function taxonomyPageSpecs(listed, options, outDir, base) {
 			href: listHref
 		});
 		for (const term of terms) {
-			const outputPath = containedPath(outDir, urlName, term.slug, "index.html");
+			const outputPath = containedPath$2(outDir, urlName, term.slug, "index.html");
 			if (!outputPath) continue;
 			pages.push({
 				title: term.label,
 				content: termPageContent(term),
 				outputPath,
 				urlPath: `${urlName}/${term.slug}`,
-				href: siteHref$2(base, urlName, term.slug)
+				href: siteHref$3(base, urlName, term.slug)
 			});
 		}
 	}
@@ -5588,7 +6377,7 @@ function taxonomyPageSpecs(listed, options, outDir, base) {
 }
 function collectTerms(listed, taxonomy) {
 	const buckets = /* @__PURE__ */ new Map();
-	for (const page of listed) for (const label of termsFromValue(page.frontmatter[taxonomy])) {
+	for (const page of listed) for (const label of termsFromValue$1(page.frontmatter[taxonomy])) {
 		const slug = termSlug(label);
 		if (!slug) continue;
 		const existing = buckets.get(slug);
@@ -5603,13 +6392,13 @@ function collectTerms(listed, taxonomy) {
 }
 function pageTermKeys(page, taxonomies) {
 	const keys = /* @__PURE__ */ new Set();
-	for (const taxonomy of taxonomies) for (const label of termsFromValue(page.frontmatter[taxonomy])) {
+	for (const taxonomy of taxonomies) for (const label of termsFromValue$1(page.frontmatter[taxonomy])) {
 		const slug = termSlug(label);
 		if (slug) keys.add(`${taxonomy.toLowerCase()}\0${slug}`);
 	}
 	return keys;
 }
-function termsFromValue(value) {
+function termsFromValue$1(value) {
 	if (typeof value === "string") return value.trim() ? [value.trim()] : [];
 	if (!Array.isArray(value)) return [];
 	return value.flatMap((item) => typeof item === "string" && item.trim() ? [item.trim()] : []);
@@ -5633,55 +6422,840 @@ function normalizeRelatedLimit(value) {
 	if (typeof value === "number" && Number.isFinite(value) && value >= 0) return Math.floor(value);
 	return DEFAULT_RELATED_LIMIT;
 }
-function samePage(left, right) {
-	if (left.inputPath && right.inputPath) return left.inputPath === right.inputPath;
-	return left.routePaths.href === right.routePaths.href;
+function samePage(left, right) {
+	if (left.inputPath && right.inputPath) return left.inputPath === right.inputPath;
+	return left.routePaths.href === right.routePaths.href;
+}
+function sharedCount(left, right) {
+	let count = 0;
+	for (const key of left) if (right.has(key)) count += 1;
+	return count;
+}
+//#endregion
+//#region src/team.ts
+/**
+* Resolves `ssg.team` with defaults.
+*
+* `false` / omitted stays off. `true` enables an empty member list.
+* An object enables the feature and keeps the members the site set.
+*/
+function resolveTeamOptions(value) {
+	if (!value) return {
+		enabled: false,
+		members: []
+	};
+	if (value === true) return {
+		enabled: true,
+		members: []
+	};
+	return {
+		enabled: true,
+		members: normalizeMembers(value.members)
+	};
+}
+function normalizeMembers(members) {
+	if (!Array.isArray(members)) return [];
+	return members.flatMap((member) => {
+		if (!member || typeof member.name !== "string") return [];
+		const links = Array.isArray(member.links) ? member.links.flatMap((link) => {
+			if (!link || typeof link.label !== "string" || typeof link.href !== "string") return [];
+			return [{
+				label: link.label,
+				href: link.href
+			}];
+		}) : void 0;
+		return [{
+			name: member.name,
+			role: typeof member.role === "string" ? member.role : void 0,
+			avatar: typeof member.avatar === "string" ? member.avatar : void 0,
+			links
+		}];
+	});
+}
+//#endregion
+//#region src/contributors.ts
+/**
+* Opt-in git contributor list helpers.
+*
+* Resolution and ignore filtering live here. `git log` is read in Rust
+* (`getGitContributors`) and names are rendered from `PageData.contributors`.
+*/
+/**
+* Resolves `ssg.contributors` with defaults.
+*
+* `false` / omitted stays off. `true` enables names only.
+* An object enables the feature and keeps `ignore` / `avatars`.
+*/
+function resolveContributorsOption(value) {
+	if (!value) return false;
+	if (value === true) return {
+		ignore: [],
+		avatars: false
+	};
+	return {
+		ignore: Array.isArray(value.ignore) ? value.ignore.filter((entry) => typeof entry === "string") : [],
+		avatars: value.avatars === true
+	};
+}
+function filterGitContributors(contributors, ignore) {
+	if (ignore.length === 0) return contributors.filter((contributor) => contributor.name.trim());
+	const needles = new Set(ignore.map((entry) => entry.toLowerCase()));
+	return contributors.filter((contributor) => {
+		const name = contributor.name.trim();
+		if (!name) return false;
+		if (needles.has(name.toLowerCase())) return false;
+		const email = contributor.email?.trim().toLowerCase();
+		return !email || !needles.has(email);
+	});
+}
+function gravatarAvatar(email) {
+	return `https://www.gravatar.com/avatar/${createHash("md5").update(email.trim().toLowerCase()).digest("hex")}?d=mp&s=40`;
+}
+function applyContributorOptions(raw, option) {
+	return filterGitContributors(raw, option.ignore).map((contributor) => ({
+		name: contributor.name.trim(),
+		avatar: option.avatars && contributor.email?.trim() ? gravatarAvatar(contributor.email) : void 0
+	}));
+}
+//#endregion
+//#region src/blog-options.ts
+const DEFAULT_PAGE_SIZE = 10;
+function resolveBlogOptions(value) {
+	if (!value) return {
+		enabled: false,
+		authors: {},
+		pageSize: DEFAULT_PAGE_SIZE
+	};
+	if (value === true) return {
+		enabled: true,
+		authors: {},
+		pageSize: DEFAULT_PAGE_SIZE
+	};
+	return {
+		enabled: true,
+		collection: value.collection,
+		authors: normalizeAuthors(value.authors),
+		pageSize: normalizePageSize(value.pageSize)
+	};
+}
+/**
+* Picks a collection named `blog`, else the only configured collection.
+*
+* An explicit name always wins. Several collections and no `blog` name
+* require `blog.collection`.
+*/
+function resolveBlogCollectionName(requested, collectionNames) {
+	if (requested) return requested;
+	if (collectionNames.includes("blog")) return "blog";
+	if (collectionNames.length === 1) return collectionNames[0];
+}
+function normalizeAuthors(authors) {
+	if (!authors || typeof authors !== "object") return {};
+	const resolved = {};
+	for (const [key, value] of Object.entries(authors)) {
+		if (!value || typeof value.name !== "string") continue;
+		resolved[key] = {
+			name: value.name,
+			bio: typeof value.bio === "string" ? value.bio : void 0,
+			url: typeof value.url === "string" ? value.url : void 0
+		};
+	}
+	return resolved;
+}
+function normalizePageSize(value) {
+	if (typeof value === "number" && Number.isFinite(value) && value >= 1) return Math.floor(value);
+	return DEFAULT_PAGE_SIZE;
+}
+//#endregion
+//#region src/blog-reading.ts
+/**
+* Deterministic blog reading-time estimates.
+*/
+const LATIN_WORDS_PER_MINUTE = 200;
+const CJK_CHARS_PER_MINUTE = 500;
+function readingTimeMinutes(markdown) {
+	const body = stripInlineCode(stripFences(stripFrontmatter(markdown)));
+	let latin = 0;
+	let cjk = 0;
+	let latinRun = false;
+	for (const char of body) {
+		const code = char.codePointAt(0) ?? 0;
+		if (isCjkCodePoint(code)) {
+			cjk += 1;
+			latinRun = false;
+			continue;
+		}
+		if (isLatinWordChar(code)) {
+			if (!latinRun) {
+				latin += 1;
+				latinRun = true;
+			}
+			continue;
+		}
+		if (char === "'" || char === "’") continue;
+		latinRun = false;
+	}
+	if (latin === 0 && cjk === 0) return 0;
+	return Math.max(1, Math.ceil(latin / LATIN_WORDS_PER_MINUTE + cjk / CJK_CHARS_PER_MINUTE));
+}
+function stripFrontmatter(markdown) {
+	if (!markdown.startsWith("---")) return markdown;
+	const match = markdown.match(/^---\r?\n[\s\S]*?\r?\n---\r?\n?/);
+	return match ? markdown.slice(match[0].length) : markdown;
+}
+function stripFences(text) {
+	return text.replace(/```[\s\S]*?(?:```|$)/g, " ");
+}
+function stripInlineCode(text) {
+	return text.replace(/`[^`\n]*`/g, " ");
+}
+function isCjkCodePoint(code) {
+	return code >= 12352 && code <= 12543 || code >= 12784 && code <= 12799 || code >= 13312 && code <= 19903 || code >= 19968 && code <= 40959 || code >= 63744 && code <= 64255 || code >= 44032 && code <= 55215 || code >= 4352 && code <= 4607;
+}
+function isLatinWordChar(code) {
+	return code >= 48 && code <= 57 || code >= 65 && code <= 90 || code >= 97 && code <= 122;
+}
+//#endregion
+//#region src/blog-html.ts
+/**
+* Escaped blog index, tag, archive, and post-meta HTML.
+*/
+/** `https:` or a same-origin path starting with `/` but not `//`. */
+function isSafeBlogUrl(value) {
+	const trimmed = value.trim();
+	if (trimmed.length === 0 || trimmed.split("").some((ch) => ch === "\n" || ch === "\r" || ch === "\0" || ch === "	")) return false;
+	if (trimmed.startsWith("//")) return false;
+	if (trimmed.startsWith("/")) return true;
+	return trimmed.toLowerCase().startsWith("https:");
+}
+function postMetaMarkup(meta) {
+	const parts = [`<p class="ox-blog-meta__reading-time">${escapeHtml$1(String(meta.minutes))} min read</p>`];
+	if (meta.authors.length > 0) {
+		const items = meta.authors.map((author) => authorMarkup(author)).join("");
+		parts.push(`<ul class="ox-blog-meta__authors">${items}</ul>`);
+	}
+	if (meta.tags.length > 0) {
+		const items = meta.tags.map((tag) => `<li><a href="${escapeHtml$1(tag.href)}">${escapeHtml$1(tag.label)}</a></li>`).join("");
+		parts.push(`<ul class="ox-blog-meta__tags">${items}</ul>`);
+	}
+	return `<aside class="ox-blog-meta">${parts.join("")}</aside>\n`;
+}
+function indexPageContent(items, pager) {
+	const list = items.map((item) => listItem(item)).join("");
+	const links = [];
+	if (pager.newerHref) links.push(`<a href="${escapeHtml$1(pager.newerHref)}" rel="prev">Newer</a>`);
+	if (pager.olderHref) links.push(`<a href="${escapeHtml$1(pager.olderHref)}" rel="next">Older</a>`);
+	return `<h1>Blog</h1><ul class="ox-blog">${list}</ul>${links.length > 0 ? `<nav class="ox-blog-pager">${links.join("")}</nav>` : ""}`;
+}
+function tagPageContent(label, items) {
+	const list = items.map((item) => listItem(item)).join("");
+	return `<h1>${escapeHtml$1(label)}</h1><ul class="ox-blog-tag">${list}</ul>`;
+}
+function archiveIndexContent(years) {
+	return `<h1>Archive</h1><ul class="ox-blog-archive">${years.map((entry) => `<li><a href="${escapeHtml$1(entry.href)}">${escapeHtml$1(entry.year)}</a></li>`).join("")}</ul>`;
+}
+function archiveYearContent(year, months, items) {
+	const monthList = months.map((entry) => `<li><a href="${escapeHtml$1(entry.href)}">${escapeHtml$1(entry.month)}</a></li>`).join("");
+	const posts = items.map((item) => listItem(item)).join("");
+	return `<h1>${escapeHtml$1(year)}</h1><ul class="ox-blog-archive-months">${monthList}</ul><ul class="ox-blog">${posts}</ul>`;
+}
+function archiveMonthContent(label, items) {
+	const list = items.map((item) => listItem(item)).join("");
+	return `<h1>${escapeHtml$1(label)}</h1><ul class="ox-blog">${list}</ul>`;
+}
+function siteHref$2(base, ...segments) {
+	const prefix = !base || base === "/" ? "/" : base.endsWith("/") ? base : `${base}/`;
+	const rest = segments.filter(Boolean).join("/");
+	return rest ? `${prefix}${rest}/` : prefix;
+}
+function containedPath$1(outDir, ...segments) {
+	const root = path$1.resolve(outDir);
+	const resolved = path$1.resolve(root, ...segments);
+	const prefix = root.endsWith(path$1.sep) ? root : `${root}${path$1.sep}`;
+	if (resolved === root || !resolved.startsWith(prefix)) return;
+	return resolved;
+}
+function escapeHtml$1(value) {
+	return value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll("\"", "&quot;").replaceAll("'", "&#39;");
+}
+function authorMarkup(author) {
+	const name = escapeHtml$1(author.name);
+	const url = author.url?.trim();
+	return `<li>${url && isSafeBlogUrl(url) ? `<a class="ox-blog-meta__name" href="${escapeHtml$1(url)}">${name}</a>` : `<span class="ox-blog-meta__name">${name}</span>`}${author.bio && author.bio.length > 0 ? `<p class="ox-blog-meta__bio">${escapeHtml$1(author.bio)}</p>` : ""}</li>`;
+}
+function listItem(item) {
+	const time = item.dateLabel ? ` <time datetime="${escapeHtml$1(item.dateLabel)}">${escapeHtml$1(item.dateLabel)}</time>` : "";
+	return `<li><a href="${escapeHtml$1(item.href)}">${escapeHtml$1(item.title)}</a>${time}</li>`;
+}
+//#endregion
+//#region src/blog-posts.ts
+/**
+* Blog post selection, tags, authors, and dates.
+*/
+const HOSTILE_TERM = /^(?:javascript|data):/i;
+function selectBlogPosts(listed, options, srcDir, collections) {
+	if (isAmbiguousCollection(options, collections)) return;
+	const names = collectionNames(collections);
+	const name = resolveBlogCollectionName(options.collection, names);
+	const sources = name && collections?.enabled ? collections.collections[name]?.source : void 0;
+	return listed.filter((page) => {
+		if (isExcludedPost(page.frontmatter)) return false;
+		if (!sources) return true;
+		return pageMatchesSources(page.inputPath, srcDir, sources);
+	});
+}
+function isAmbiguousCollection(options, collections) {
+	if (options.collection) return false;
+	const names = collectionNames(collections);
+	return names.length > 1 && !names.includes("blog");
+}
+function collectionNames(collections) {
+	if (!collections?.enabled) return [];
+	return Object.keys(collections.collections);
+}
+function pageMatchesSources(inputPath, srcDir, sources) {
+	const relative = path$1.relative(srcDir, inputPath).split(path$1.sep).join("/");
+	return sources.some((source) => matchGlob(relative, source));
+}
+function matchGlob(relative, pattern) {
+	const normalized = pattern.replace(/^\/+/, "");
+	let out = "^";
+	for (let i = 0; i < normalized.length; i += 1) {
+		if (normalized.startsWith("**/", i)) {
+			out += "(?:.*/)?";
+			i += 2;
+			continue;
+		}
+		const ch = normalized[i] ?? "";
+		if (ch === "*") {
+			out += "[^/]*";
+			continue;
+		}
+		if (ch === "?") {
+			out += "[^/]";
+			continue;
+		}
+		if (/[.+^${}()|[\]\\]/.test(ch)) {
+			out += `\\${ch}`;
+			continue;
+		}
+		out += ch;
+	}
+	out += "$";
+	return new RegExp(out).test(relative);
+}
+function sortPosts(posts) {
+	return [...posts].sort((left, right) => {
+		const dateCmp = (pageUnix(right.frontmatter) ?? Number.NEGATIVE_INFINITY) - (pageUnix(left.frontmatter) ?? Number.NEGATIVE_INFINITY);
+		if (dateCmp !== 0) return dateCmp;
+		return left.routePaths.href < right.routePaths.href ? -1 : left.routePaths.href > right.routePaths.href ? 1 : 0;
+	});
+}
+function collectTags(posts) {
+	const buckets = /* @__PURE__ */ new Map();
+	for (const page of posts) for (const label of termsFromValue(page.frontmatter.tags)) {
+		const slug = tagSlug(label);
+		if (!slug) continue;
+		const existing = buckets.get(slug);
+		if (existing) existing.pages.push(page);
+		else buckets.set(slug, {
+			label,
+			slug,
+			pages: [page]
+		});
+	}
+	return [...buckets.values()].sort((left, right) => left.label.localeCompare(right.label));
+}
+function datedPosts(posts) {
+	const dated = [];
+	for (const page of posts) {
+		const parsed = pageDate(page.frontmatter);
+		if (!parsed) continue;
+		dated.push({
+			page,
+			year: String(parsed.year).padStart(4, "0"),
+			month: String(parsed.month).padStart(2, "0"),
+			label: `${String(parsed.year).padStart(4, "0")}-${String(parsed.month).padStart(2, "0")}-${String(parsed.day).padStart(2, "0")}`
+		});
+	}
+	return dated;
+}
+function uniqueYears(dated) {
+	return [...new Set(dated.map((entry) => entry.year))].sort((left, right) => right.localeCompare(left));
+}
+function uniqueMonths(dated) {
+	return [...new Set(dated.map((entry) => entry.month))].sort((left, right) => left.localeCompare(right));
+}
+function toListItem(page) {
+	const parsed = pageDate(page.frontmatter);
+	return {
+		title: page.title,
+		href: page.routePaths.href,
+		dateLabel: parsed ? `${String(parsed.year).padStart(4, "0")}-${String(parsed.month).padStart(2, "0")}-${String(parsed.day).padStart(2, "0")}` : void 0
+	};
+}
+function resolvePostAuthors(frontmatter, map) {
+	const seen = /* @__PURE__ */ new Set();
+	const authors = [];
+	for (const key of authorKeys(frontmatter)) {
+		if (seen.has(key)) continue;
+		seen.add(key);
+		authors.push(map[key] ?? { name: key });
+	}
+	return authors;
+}
+function authorKeys(frontmatter) {
+	return [...keysFromValue(frontmatter.author), ...keysFromValue(frontmatter.authors)];
+}
+function keysFromValue(value) {
+	if (typeof value === "string") return value.trim() ? [value.trim()] : [];
+	if (!Array.isArray(value)) return [];
+	return value.flatMap((item) => typeof item === "string" && item.trim() ? [item.trim()] : []);
+}
+function postTagLinks(frontmatter, base) {
+	const links = [];
+	const seen = /* @__PURE__ */ new Set();
+	for (const label of termsFromValue(frontmatter.tags)) {
+		const slug = tagSlug(label);
+		if (!slug || seen.has(slug)) continue;
+		seen.add(slug);
+		links.push({
+			label,
+			href: siteHref$2(base, "blog", "tags", slug)
+		});
+	}
+	return links;
+}
+function tagSlug(term) {
+	const trimmed = term.trim();
+	if (!trimmed || HOSTILE_TERM.test(trimmed) || trimmed.includes("..") || trimmed.includes("//")) return;
+	return trimmed.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "") || void 0;
+}
+function termsFromValue(value) {
+	if (typeof value === "string") return value.trim() ? [value.trim()] : [];
+	if (!Array.isArray(value)) return [];
+	return value.flatMap((item) => typeof item === "string" && item.trim() ? [item.trim()] : []);
+}
+function isExcludedPost(frontmatter) {
+	return frontmatter.draft === true || frontmatter.unlisted === true;
+}
+function pageDate(frontmatter) {
+	return parseDate(dateField(frontmatter.date));
+}
+function pageUnix(frontmatter) {
+	return pageDate(frontmatter)?.unix;
+}
+function dateField(value) {
+	if (typeof value === "string" && value.trim()) return value.trim();
+	if (typeof value === "number" && Number.isFinite(value)) return String(value);
+	if (value instanceof Date && !Number.isNaN(value.getTime())) return value.toISOString();
+}
+//#endregion
+//#region src/blog-pages.ts
+/**
+* Generated blog index, tag, and archive pages.
+*/
+const AMBIGUOUS_COLLECTION = "[ox-content] blog is enabled but multiple collections are configured; set blog.collection";
+async function injectBlogPostMeta(input) {
+	if (!input.options?.enabled) return;
+	const posts = selectBlogPosts(input.listed, input.options, input.srcDir, input.collections);
+	if (posts === void 0) return;
+	const listedPaths = new Set(posts.map((page) => page.inputPath));
+	for (const page of input.pages) {
+		if (!listedPaths.has(page.inputPath)) continue;
+		const markdown = await readMarkdown(page.inputPath);
+		page.transformedHtml = postMetaMarkup({
+			authors: resolvePostAuthors(page.frontmatter, input.options.authors),
+			minutes: readingTimeMinutes(markdown),
+			tags: postTagLinks(page.frontmatter, input.base)
+		}) + page.transformedHtml;
+	}
+}
+/** Maps a generated blog page onto the SSG render shape. */
+function toBlogProcessResult(page) {
+	return {
+		inputPath: page.outputPath,
+		routePaths: {
+			outputPath: page.outputPath,
+			urlPath: page.urlPath,
+			href: page.href,
+			ogImagePath: "",
+			ogImageUrl: ""
+		},
+		transformedHtml: page.content,
+		title: page.title,
+		frontmatter: {},
+		toc: []
+	};
+}
+/** Renders index, tag, and archive pages and appends them to the build. */
+async function appendBlogPages(input) {
+	if (!input.options?.enabled) return;
+	if (isAmbiguousCollection(input.options, input.collections)) {
+		input.errors.push(AMBIGUOUS_COLLECTION);
+		return;
+	}
+	const posts = selectBlogPosts(input.listedPages, input.options, input.srcDir, input.collections);
+	if (posts === void 0) return;
+	for (const spec of blogPageSpecs(posts, input.options, input.outDir, input.base)) try {
+		input.generatedPages.push({
+			inputPath: spec.outputPath,
+			outputPath: spec.outputPath,
+			html: await input.render(spec)
+		});
+	} catch (err) {
+		const message = err instanceof Error ? err.message : String(err);
+		input.errors.push(`Failed to generate blog page ${spec.href}: ${message}`);
+	}
+}
+function blogPageSpecs(posts, options, outDir, base) {
+	const sorted = sortPosts(posts);
+	const pages = [];
+	const pageSize = options.pageSize;
+	const pageCount = Math.max(1, Math.ceil(sorted.length / pageSize) || 1);
+	const totalPages = sorted.length === 0 ? 1 : pageCount;
+	for (let pageNumber = 1; pageNumber <= totalPages; pageNumber += 1) {
+		const slice = sorted.slice((pageNumber - 1) * pageSize, pageNumber * pageSize);
+		const isFirst = pageNumber === 1;
+		const urlPath = isFirst ? "blog" : `blog/page/${pageNumber}`;
+		const outputPath = isFirst ? containedPath$1(outDir, "blog", "index.html") : containedPath$1(outDir, "blog", "page", String(pageNumber), "index.html");
+		if (!outputPath) continue;
+		pages.push({
+			title: isFirst ? "Blog" : `Blog · page ${pageNumber}`,
+			content: indexPageContent(slice.map(toListItem), {
+				newerHref: isFirst ? void 0 : siteHref$2(base, ...pageNumber === 2 ? ["blog"] : [
+					"blog",
+					"page",
+					String(pageNumber - 1)
+				]),
+				olderHref: pageNumber < totalPages ? siteHref$2(base, "blog", "page", String(pageNumber + 1)) : void 0
+			}),
+			outputPath,
+			urlPath,
+			href: siteHref$2(base, ...urlPath.split("/"))
+		});
+	}
+	const tags = collectTags(sorted);
+	for (const tag of tags) {
+		const outputPath = containedPath$1(outDir, "blog", "tags", tag.slug, "index.html");
+		if (!outputPath) continue;
+		pages.push({
+			title: tag.label,
+			content: tagPageContent(tag.label, tag.pages.map(toListItem)),
+			outputPath,
+			urlPath: `blog/tags/${tag.slug}`,
+			href: siteHref$2(base, "blog", "tags", tag.slug)
+		});
+	}
+	const dated = datedPosts(sorted);
+	if (dated.length > 0) {
+		const years = uniqueYears(dated);
+		const archiveIndex = containedPath$1(outDir, "blog", "archive", "index.html");
+		if (archiveIndex) pages.push({
+			title: "Archive",
+			content: archiveIndexContent(years.map((year) => ({
+				year,
+				href: siteHref$2(base, "blog", "archive", year)
+			}))),
+			outputPath: archiveIndex,
+			urlPath: "blog/archive",
+			href: siteHref$2(base, "blog", "archive")
+		});
+		for (const year of years) {
+			const yearPosts = dated.filter((entry) => entry.year === year);
+			const months = uniqueMonths(yearPosts);
+			const yearPath = containedPath$1(outDir, "blog", "archive", year, "index.html");
+			if (yearPath) pages.push({
+				title: year,
+				content: archiveYearContent(year, months.map((month) => ({
+					month: `${year}-${month}`,
+					href: siteHref$2(base, "blog", "archive", year, month)
+				})), yearPosts.map((entry) => toListItem(entry.page))),
+				outputPath: yearPath,
+				urlPath: `blog/archive/${year}`,
+				href: siteHref$2(base, "blog", "archive", year)
+			});
+			for (const month of months) {
+				const monthPosts = yearPosts.filter((entry) => entry.month === month);
+				const monthPath = containedPath$1(outDir, "blog", "archive", year, month, "index.html");
+				if (!monthPath) continue;
+				pages.push({
+					title: `${year}-${month}`,
+					content: archiveMonthContent(`${year}-${month}`, monthPosts.map((entry) => toListItem(entry.page))),
+					outputPath: monthPath,
+					urlPath: `blog/archive/${year}/${month}`,
+					href: siteHref$2(base, "blog", "archive", year, month)
+				});
+			}
+		}
+	}
+	return pages;
+}
+async function readMarkdown(inputPath) {
+	try {
+		return await fs$2.readFile(inputPath, "utf8");
+	} catch {
+		return "";
+	}
+}
+//#endregion
+//#region src/section-index-html.ts
+/**
+* Section-index listing HTML and href safety.
+*
+* Titles are escaped. `javascript:` / `data:` / `vbscript:` / `file:` hrefs
+* are dropped. The NAPI helper is preferred when present.
+*/
+const HOSTILE_SCHEME = /^(?:javascript|data|vbscript|file):/i;
+/** `https:`-free, same-origin or relative href. `javascript:` is rejected. */
+function isSafeSectionHref(value) {
+	const trimmed = value.trim();
+	if (!trimmed || /[\n\r\0\t]/.test(trimmed) || trimmed.startsWith("//")) return false;
+	if (trimmed.startsWith("/")) return true;
+	if (trimmed.match(/^([a-zA-Z][a-zA-Z0-9+.-]*):/)) return false;
+	return !HOSTILE_SCHEME.test(trimmed);
+}
+/** Escapes text and attribute values in generated listing markup. */
+function escapeSectionIndexHtml(value) {
+	return value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll("\"", "&quot;").replaceAll("'", "&#39;");
+}
+/** Renders the listing body. Titles are escaped; hostile hrefs are dropped. */
+function renderSectionIndexHtml(title, items, style) {
+	try {
+		const napi = importNapiModuleSync();
+		if (typeof napi.renderSsgSectionIndex === "function") return napi.renderSsgSectionIndex(title, items.map((item) => ({
+			title: item.title,
+			href: item.href,
+			description: item.description
+		})), style);
+	} catch {}
+	return renderSectionIndexHtmlLocal(title, items, style);
+}
+function renderSectionIndexHtmlLocal(title, items, style) {
+	const safe = items.filter((item) => isSafeSectionHref(item.href));
+	const modifier = style === "list" ? "list" : "cards";
+	const listClass = style === "list" ? "ox-section-index__list" : "ox-section-index__cards";
+	const body = safe.map((item) => renderItem(item, style)).join("");
+	return `<nav class="ox-section-index ox-section-index--${modifier}" aria-label="Section pages"><h1>${escapeSectionIndexHtml(title)}</h1><ul class="${listClass}">${body}</ul></nav>`;
+}
+function renderItem(item, style) {
+	const href = escapeSectionIndexHtml(item.href.trim());
+	const label = escapeSectionIndexHtml(item.title);
+	if (style === "list") return `<li><a href="${href}">${label}</a></li>`;
+	return `<li class="ox-section-index__card"><a href="${href}"><span class="ox-section-index__title">${label}</span>${typeof item.description === "string" && item.description.trim() ? `<span class="ox-section-index__desc">${escapeSectionIndexHtml(item.description)}</span>` : ""}</a></li>`;
+}
+//#endregion
+//#region src/section-index-paths.ts
+/**
+* Section-index URL, title, and output-path helpers.
+*/
+function pageTitle(page) {
+	if (page.title.trim()) return page.title;
+	return formatSectionTitle(path$1.basename(page.inputPath ?? page.routePaths.urlPath).replace(/\.[^.]+$/, "") || page.routePaths.urlPath);
+}
+function sectionTitle(dir) {
+	if (!dir) return "Home";
+	return formatSectionTitle(dir.slice(dir.lastIndexOf("/") + 1));
+}
+function formatSectionTitle(name) {
+	try {
+		return importNapiModuleSync().formatSsgTitle(name);
+	} catch {
+		if (!name) return "Untitled";
+		return name.charAt(0).toUpperCase() + name.slice(1).replace(/[-_]+/g, " ");
+	}
+}
+function normalizeUrlPath(urlPath) {
+	if (!urlPath || urlPath === "/") return "";
+	return urlPath.replace(/^\/+|\/+$/g, "");
+}
+function parentDir(urlPath) {
+	const normalized = normalizeUrlPath(urlPath);
+	if (!normalized) return null;
+	const index = normalized.lastIndexOf("/");
+	return index === -1 ? "" : normalized.slice(0, index);
+}
+function firstChildDir(urlPath, parent) {
+	const normalized = normalizeUrlPath(urlPath);
+	if (!normalized) return;
+	if (!parent) {
+		const slash = normalized.indexOf("/");
+		return slash === -1 ? void 0 : normalized.slice(0, slash);
+	}
+	const prefix = `${parent}/`;
+	if (!normalized.startsWith(prefix) || normalized === parent) return;
+	const rest = normalized.slice(prefix.length);
+	const slash = rest.indexOf("/");
+	return slash === -1 ? void 0 : `${parent}/${rest.slice(0, slash)}`;
+}
+function sectionHref(base, dir, extension) {
+	const prefix = !base || base === "/" ? "/" : base.endsWith("/") ? base : `${base}/`;
+	const ext = extension.startsWith(".") ? extension : `.${extension}`;
+	return dir ? `${prefix}${dir}/index${ext}` : `${prefix}index${ext}`;
+}
+function sectionOutputPath(outDir, dir, extension) {
+	const ext = extension.startsWith(".") ? extension : `.${extension}`;
+	return containedPath(outDir, ...dir ? [...dir.split("/").filter(Boolean), `index${ext}`] : [`index${ext}`]);
+}
+function dirFromOutputPath(outputPath, outDir) {
+	return path$1.relative(path$1.resolve(outDir), path$1.resolve(outputPath)).replaceAll(path$1.sep, "/").replace(/\/index\.[^/]+$/u, "").replace(/^index\.[^/]+$/u, "").replace(/^\/+|\/+$/g, "");
+}
+function containedPath(outDir, ...segments) {
+	const root = path$1.resolve(outDir);
+	const resolved = path$1.resolve(root, ...segments);
+	const prefix = root.endsWith(path$1.sep) ? root : `${root}${path$1.sep}`;
+	if (resolved !== root && !resolved.startsWith(prefix)) return;
+	if (segments.some((segment) => segment === ".." || segment.includes("\0"))) return;
+	return resolved;
+}
+//#endregion
+//#region src/section-index.ts
+/**
+* Opt-in generated section index pages.
+*
+* Resolution and directory walking live here. Listing HTML is rendered in
+* Rust (`ox_content_ssg::render_section_index`) when the NAPI helper is
+* available; a matching TypeScript renderer covers the same escape / href
+* rules so the SSG path stays safe either way. The Vite plugin appends
+* themed HTML during SSG and never overwrites an existing index page.
+*/
+/**
+* Resolves `ssg.sectionIndex` with defaults.
+*
+* `false` / omitted stays off. `true` enables card listings. An object
+* enables the feature and overrides only the fields the site set.
+*/
+function resolveSectionIndexOptions(value) {
+	if (!value) return {
+		enabled: false,
+		style: "cards"
+	};
+	if (value === true) return {
+		enabled: true,
+		style: "cards"
+	};
+	return {
+		enabled: true,
+		style: value.style === "list" ? "list" : "cards"
+	};
+}
+/** Maps a generated section index onto the SSG render shape. */
+function toSectionIndexProcessResult(page) {
+	return {
+		inputPath: page.outputPath,
+		routePaths: {
+			outputPath: page.outputPath,
+			urlPath: page.urlPath,
+			href: page.href,
+			ogImagePath: "",
+			ogImageUrl: ""
+		},
+		transformedHtml: page.content,
+		title: page.title,
+		frontmatter: {},
+		toc: []
+	};
+}
+/** Appends generated section indexes for directories that have no real index. */
+async function appendSectionIndexPages(input) {
+	if (!input.options?.enabled) return;
+	const existingOutputs = new Set(input.generatedPages.map((page) => path$1.normalize(page.outputPath)));
+	for (const spec of sectionIndexSpecs(input.collectedPages, input.listedPages, input.options, input.outDir, input.base, input.extension)) {
+		if (existingOutputs.has(path$1.normalize(spec.outputPath))) continue;
+		try {
+			const html = await input.render(spec);
+			input.generatedPages.push({
+				inputPath: spec.outputPath,
+				outputPath: spec.outputPath,
+				html
+			});
+			existingOutputs.add(path$1.normalize(spec.outputPath));
+		} catch (err) {
+			const message = err instanceof Error ? err.message : String(err);
+			input.errors.push(`Failed to generate section index ${spec.href}: ${message}`);
+		}
+	}
+}
+function sectionIndexSpecs(collected, listed, options, outDir, base, extension) {
+	const occupied = /* @__PURE__ */ new Set();
+	for (const page of collected) occupied.add(normalizeUrlPath(page.routePaths.urlPath));
+	for (const page of collected) {
+		const output = page.routePaths.outputPath;
+		if (output) occupied.add(dirFromOutputPath(output, outDir));
+	}
+	const visible = listed.filter((page) => !isHiddenByFlags(page.frontmatter));
+	const childrenByDir = /* @__PURE__ */ new Map();
+	for (const page of visible) {
+		const urlPath = normalizeUrlPath(page.routePaths.urlPath);
+		const parent = parentDir(urlPath);
+		if (parent === null) continue;
+		pushChild(childrenByDir, parent, {
+			title: pageTitle(page),
+			href: page.routePaths.href,
+			description: page.description
+		});
+		let ancestor = parent;
+		while (ancestor !== "") {
+			const grand = parentDir(ancestor);
+			if (grand === null) break;
+			const nested = firstChildDir(urlPath, grand);
+			if (nested) pushUniqueDir(childrenByDir, grand, nested, visible, base, extension);
+			ancestor = grand;
+		}
+	}
+	const pages = [];
+	const dirs = [...childrenByDir.keys()].sort();
+	for (const dir of dirs) {
+		if (occupied.has(dir)) continue;
+		const children = uniqueItems(childrenByDir.get(dir) ?? []).filter((item) => isSafeSectionHref(item.href));
+		if (children.length === 0) continue;
+		children.sort((left, right) => {
+			const titleCmp = left.title.localeCompare(right.title);
+			return titleCmp !== 0 ? titleCmp : left.href.localeCompare(right.href);
+		});
+		const outputPath = sectionOutputPath(outDir, dir, extension);
+		if (!outputPath) continue;
+		const title = sectionTitle(dir);
+		pages.push({
+			title,
+			content: renderSectionIndexHtml(title, children, options.style),
+			outputPath,
+			urlPath: dir || "/",
+			href: sectionHref(base, dir, extension)
+		});
+	}
+	return pages;
+}
+function pushChild(map, dir, item) {
+	const list = map.get(dir);
+	if (list) {
+		list.push(item);
+		return;
+	}
+	map.set(dir, [item]);
 }
-function sharedCount(left, right) {
-	let count = 0;
-	for (const key of left) if (right.has(key)) count += 1;
-	return count;
+function pushUniqueDir(map, parent, childDir, visible, base, extension) {
+	const href = sectionHref(base, childDir, extension);
+	if (map.get(parent)?.some((item) => item.href === href)) return;
+	const indexPage = visible.find((page) => normalizeUrlPath(page.routePaths.urlPath) === childDir);
+	pushChild(map, parent, {
+		title: indexPage ? pageTitle(indexPage) : sectionTitle(childDir),
+		href: indexPage?.routePaths.href ?? href,
+		description: indexPage?.description
+	});
 }
-//#endregion
-//#region src/team.ts
-/**
-* Resolves `ssg.team` with defaults.
-*
-* `false` / omitted stays off. `true` enables an empty member list.
-* An object enables the feature and keeps the members the site set.
-*/
-function resolveTeamOptions(value) {
-	if (!value) return {
-		enabled: false,
-		members: []
-	};
-	if (value === true) return {
-		enabled: true,
-		members: []
-	};
-	return {
-		enabled: true,
-		members: normalizeMembers(value.members)
-	};
+function uniqueItems(items) {
+	const seen = /* @__PURE__ */ new Set();
+	const unique = [];
+	for (const item of items) {
+		if (seen.has(item.href)) continue;
+		seen.add(item.href);
+		unique.push(item);
+	}
+	return unique;
 }
-function normalizeMembers(members) {
-	if (!Array.isArray(members)) return [];
-	return members.flatMap((member) => {
-		if (!member || typeof member.name !== "string") return [];
-		const links = Array.isArray(member.links) ? member.links.flatMap((link) => {
-			if (!link || typeof link.label !== "string" || typeof link.href !== "string") return [];
-			return [{
-				label: link.label,
-				href: link.href
-			}];
-		}) : void 0;
-		return [{
-			name: member.name,
-			role: typeof member.role === "string" ? member.role : void 0,
-			avatar: typeof member.avatar === "string" ? member.avatar : void 0,
-			links
-		}];
-	});
+function isHiddenByFlags(frontmatter) {
+	return frontmatter.draft === true || frontmatter.unlisted === true;
 }
 //#endregion
 //#region src/search-provider.ts
@@ -6077,93 +7651,1419 @@ function versionLocation(outputPath, outDir, options) {
 		};
 	}
 	return {
-		id: options.current,
-		sibling: normalized
+		id: options.current,
+		sibling: normalized
+	};
+}
+function outputToHref(outputPath, outDir, base) {
+	return siteHref$1(base, "", relativeUrl(outputPath, outDir));
+}
+/** Applies switcher / banner / search rewrite after every version tree is generated. */
+function decorateVersionedPages(pages, options, outDir, base) {
+	if (!options.enabled) return;
+	const existingHrefs = new Set(pages.map((page) => outputToHref(page.outputPath, outDir, base)));
+	for (const page of pages) {
+		const { id, sibling } = versionLocation(page.outputPath, outDir, options);
+		page.html = applyVersionChrome(page.html, options, id, sibling, base, existingHrefs);
+	}
+}
+async function writeSnapshotSearchIndex(input) {
+	const prefix = sanitizePrefix(input.prefix);
+	if (!prefix) return;
+	const destDir = path$1.join(input.outDir, prefix);
+	const prefixBase = searchIndexUrl(input.base, prefix).replace(/search-index\.json$/, "");
+	const json = await buildSearchIndex(input.srcDir, prefixBase, input.extensions, input.publishState, [], input.mdx);
+	await fs$2.mkdir(destDir, { recursive: true });
+	await writeSearchIndex(json, destDir);
+	const dest = path$1.join(destDir, "search-index.json");
+	try {
+		await fs$2.access(dest);
+	} catch {
+		await fs$2.writeFile(dest, json, "utf8");
+	}
+	return dest;
+}
+function applyVersionChrome(html, options, activeId, siblingPath, base, existingHrefs) {
+	if (!options.enabled) return html;
+	const active = options.entries.find((entry) => entry.id === activeId);
+	return injectVersionChrome(html, options.switcher ? versionSwitcherMarkup(versionLinks(options, activeId, siblingPath, base, existingHrefs), options.badge) : "", versionBannerMarkup(active?.banner), searchIndexUrl(base, currentVersionPrefix(options)), searchIndexUrl(base, active?.prefix ?? ""));
+}
+function sanitizePrefix(prefix) {
+	const trimmed = prefix.trim().replace(/^\/+|\/+$/g, "");
+	if (!trimmed) return "";
+	return PREFIX_RE.test(trimmed) && !trimmed.includes("..") ? trimmed : "";
+}
+function defaultCurrentEntry() {
+	return {
+		id: DEFAULT_CURRENT_ID,
+		label: "Latest",
+		prefix: "",
+		banner: false
+	};
+}
+function normalizeEntries(entries) {
+	if (!entries) return [];
+	const seen = /* @__PURE__ */ new Set();
+	const resolved = [];
+	for (const entry of entries) {
+		if (!entry || typeof entry.id !== "string" || typeof entry.label !== "string") continue;
+		const id = entry.id.trim();
+		const label = entry.label.trim();
+		if (!id || !label || seen.has(id)) continue;
+		const prefix = sanitizePrefix(typeof entry.prefix === "string" ? entry.prefix : "");
+		if (entry.prefix && !prefix) continue;
+		const dir = typeof entry.dir === "string" && entry.dir.trim() ? entry.dir.trim() : void 0;
+		if (dir && (dir.includes("\0") || dir.includes(".."))) continue;
+		seen.add(id);
+		resolved.push({
+			id,
+			label,
+			prefix,
+			dir,
+			banner: normalizeBanner(entry.banner)
+		});
+	}
+	return resolved;
+}
+function normalizeBanner(value) {
+	return value === "unreleased" || value === "unmaintained" ? value : false;
+}
+function siteHref$1(base, prefix, rest) {
+	const root = !base || base === "/" ? "/" : base.endsWith("/") ? base : `${base}/`;
+	const parts = [prefix, rest].filter((part) => part && part !== "/");
+	return parts.length === 0 ? root : `${root}${parts.join("/")}/`;
+}
+function relativeUrl(outputPath, outDir) {
+	const rel = path$1.posix.normalize(path$1.relative(path$1.resolve(outDir), path$1.resolve(outputPath)).replaceAll(path$1.sep, "/"));
+	if (rel.startsWith("..")) return "";
+	const dir = rel.endsWith("/index.html") ? rel.slice(0, -11) : rel.replace(/\.html$/, "");
+	return dir === "." ? "" : dir;
+}
+//#endregion
+//#region src/resources-jpeg.ts
+function encodeJpeg(image, quality = 80) {
+	const yQuant = scaleQuant(LUM_QUANT, quality);
+	const cQuant = scaleQuant(CHR_QUANT, quality);
+	const width = image.width;
+	const height = image.height;
+	const duY = /* @__PURE__ */ new Int32Array(64);
+	const duCb = /* @__PURE__ */ new Int32Array(64);
+	const duCr = /* @__PURE__ */ new Int32Array(64);
+	const bits = new BitWriter();
+	let dcY = 0;
+	let dcCb = 0;
+	let dcCr = 0;
+	for (let y = 0; y < height; y += 8) for (let x = 0; x < width; x += 8) {
+		sampleBlock(image, x, y, duY, duCb, duCr);
+		dcY = encodeBlock(bits, duY, yQuant, dcY, YDC, YAC);
+		dcCb = encodeBlock(bits, duCb, cQuant, dcCb, CDC, CAC);
+		dcCr = encodeBlock(bits, duCr, cQuant, dcCr, CDC, CAC);
+	}
+	bits.flush();
+	return Buffer.concat([
+		jpegHeader(width, height, yQuant, cQuant),
+		bits.toBuffer(),
+		Buffer.from([255, 217])
+	]);
+}
+function sampleBlock(image, left, top, yOut, cbOut, crOut) {
+	for (let j = 0; j < 8; j++) {
+		const y = Math.min(image.height - 1, top + j);
+		for (let i = 0; i < 8; i++) {
+			const x = Math.min(image.width - 1, left + i);
+			const p = (y * image.width + x) * 4;
+			const r = image.data[p] ?? 0;
+			const g = image.data[p + 1] ?? 0;
+			const b = image.data[p + 2] ?? 0;
+			const idx = j * 8 + i;
+			yOut[idx] = (66 * r + 129 * g + 25 * b + 128 >> 8) - 128;
+			cbOut[idx] = -38 * r - 74 * g + 112 * b + 128 >> 8;
+			crOut[idx] = 112 * r - 94 * g - 18 * b + 128 >> 8;
+		}
+	}
+}
+function encodeBlock(bits, block, quant, lastDc, dcTable, acTable) {
+	const dct = forwardDct(block);
+	const zz = /* @__PURE__ */ new Int32Array(64);
+	for (let i = 0; i < 64; i++) zz[i] = Math.round(dct[ZIGZAG[i]] / quant[i]);
+	const dc = zz[0] ?? 0;
+	writeCoeff(bits, dc - lastDc, dcTable);
+	let zeroRun = 0;
+	for (let i = 1; i < 64; i++) {
+		const value = zz[i] ?? 0;
+		if (value === 0) {
+			zeroRun++;
+			continue;
+		}
+		while (zeroRun > 15) {
+			writeCode(bits, acTable, 240);
+			zeroRun -= 16;
+		}
+		writeCoeff(bits, value, acTable, zeroRun);
+		zeroRun = 0;
+	}
+	if (zeroRun > 0) writeCode(bits, acTable, 0);
+	return dc;
+}
+function writeCoeff(bits, value, table, run = 0) {
+	const category = bitCategory(value);
+	writeCode(bits, table, run << 4 | category);
+	if (category > 0) bits.writeBits(value < 0 ? value + ((1 << category) - 1) : value, category);
+}
+function writeCode(bits, table, symbol) {
+	const entry = table.get(symbol);
+	if (!entry) throw new Error("missing Huffman code");
+	bits.writeBits(entry.code, entry.len);
+}
+function bitCategory(value) {
+	const abs = Math.abs(value);
+	if (!Number.isFinite(abs) || abs === 0) return 0;
+	return Math.min(11, Math.ceil(Math.log2(abs + 1)));
+}
+function forwardDct(block) {
+	const out = /* @__PURE__ */ new Float64Array(64);
+	for (let v = 0; v < 8; v++) for (let u = 0; u < 8; u++) {
+		let sum = 0;
+		for (let y = 0; y < 8; y++) for (let x = 0; x < 8; x++) sum += (block[y * 8 + x] ?? 0) * Math.cos((2 * x + 1) * u * Math.PI / 16) * Math.cos((2 * y + 1) * v * Math.PI / 16);
+		const cu = u === 0 ? Math.SQRT1_2 : 1;
+		const cv = v === 0 ? Math.SQRT1_2 : 1;
+		out[v * 8 + u] = .25 * cu * cv * sum;
+	}
+	return out;
+}
+function scaleQuant(base, quality) {
+	const q = Math.max(1, Math.min(100, quality));
+	const scale = q < 50 ? Math.floor(5e3 / q) : Math.floor(200 - q * 2);
+	return base.map((value) => Math.max(1, Math.min(255, Math.floor((value * scale + 50) / 100))));
+}
+function jpegHeader(width, height, yQuant, cQuant) {
+	const chunks = [
+		Buffer.from([255, 216]),
+		jfifApp0(),
+		dqt(0, yQuant),
+		dqt(1, cQuant),
+		sof(width, height),
+		dht(0, 0, STD_DC_LUM_NCODES, STD_DC_LUM_VALUES),
+		dht(0, 1, STD_DC_CHR_NCODES, STD_DC_CHR_VALUES),
+		dht(1, 0, STD_AC_LUM_NCODES, STD_AC_LUM_VALUES),
+		dht(1, 1, STD_AC_CHR_NCODES, STD_AC_CHR_VALUES),
+		sos()
+	];
+	return Buffer.concat(chunks);
+}
+function jfifApp0() {
+	return Buffer.from([
+		255,
+		224,
+		0,
+		16,
+		74,
+		70,
+		73,
+		70,
+		0,
+		1,
+		1,
+		0,
+		0,
+		1,
+		0,
+		1,
+		0,
+		0
+	]);
+}
+function dqt(id, table) {
+	const out = Buffer.alloc(69);
+	out[0] = 255;
+	out[1] = 219;
+	out.writeUInt16BE(67, 2);
+	out[4] = id;
+	for (let i = 0; i < 64; i++) out[5 + i] = table[i] ?? 1;
+	return out;
+}
+function sof(width, height) {
+	const out = Buffer.from([
+		255,
+		192,
+		0,
+		17,
+		8,
+		0,
+		0,
+		0,
+		0,
+		3,
+		1,
+		17,
+		0,
+		2,
+		17,
+		1,
+		3,
+		17,
+		1
+	]);
+	out.writeUInt16BE(height, 5);
+	out.writeUInt16BE(width, 7);
+	return out;
+}
+function dht(cls, id, ncodes, values) {
+	const out = Buffer.alloc(21 + values.length);
+	out[0] = 255;
+	out[1] = 196;
+	out.writeUInt16BE(19 + values.length, 2);
+	out[4] = cls << 4 | id;
+	Buffer.from(ncodes).copy(out, 5);
+	Buffer.from(values).copy(out, 21);
+	return out;
+}
+function sos() {
+	return Buffer.from([
+		255,
+		218,
+		0,
+		12,
+		3,
+		1,
+		0,
+		2,
+		17,
+		3,
+		17,
+		0,
+		63,
+		0
+	]);
+}
+var BitWriter = class {
+	bytes = [];
+	bits = 0;
+	length = 0;
+	writeBits(value, count) {
+		for (let i = count - 1; i >= 0; i--) {
+			this.bits = this.bits << 1 | value >> i & 1;
+			this.length++;
+			if (this.length === 8) this.pushByte();
+		}
+	}
+	flush() {
+		if (this.length > 0) {
+			this.bits <<= 8 - this.length;
+			this.pushByte();
+		}
+	}
+	toBuffer() {
+		return Buffer.from(this.bytes);
+	}
+	pushByte() {
+		this.bytes.push(this.bits & 255);
+		if ((this.bits & 255) === 255) this.bytes.push(0);
+		this.bits = 0;
+		this.length = 0;
+	}
+};
+function buildHuffman(ncodes, values) {
+	const table = /* @__PURE__ */ new Map();
+	let code = 0;
+	let index = 0;
+	for (let len = 1; len <= 16; len++) {
+		const count = ncodes[len - 1] ?? 0;
+		for (let i = 0; i < count; i++) {
+			table.set(values[index++] ?? 0, {
+				code,
+				len
+			});
+			code++;
+		}
+		code <<= 1;
+	}
+	return table;
+}
+const ZIGZAG = [
+	0,
+	1,
+	8,
+	16,
+	9,
+	2,
+	3,
+	10,
+	17,
+	24,
+	32,
+	25,
+	18,
+	11,
+	4,
+	5,
+	12,
+	19,
+	26,
+	33,
+	40,
+	48,
+	41,
+	34,
+	27,
+	20,
+	13,
+	6,
+	7,
+	14,
+	21,
+	28,
+	35,
+	42,
+	49,
+	56,
+	57,
+	50,
+	43,
+	36,
+	29,
+	22,
+	15,
+	23,
+	30,
+	37,
+	44,
+	51,
+	58,
+	59,
+	52,
+	45,
+	38,
+	31,
+	39,
+	46,
+	53,
+	60,
+	61,
+	54,
+	47,
+	55,
+	62,
+	63
+];
+const LUM_QUANT = [
+	16,
+	11,
+	10,
+	16,
+	24,
+	40,
+	51,
+	61,
+	12,
+	12,
+	14,
+	19,
+	26,
+	58,
+	60,
+	55,
+	14,
+	13,
+	16,
+	24,
+	40,
+	57,
+	69,
+	56,
+	14,
+	17,
+	22,
+	29,
+	51,
+	87,
+	80,
+	62,
+	18,
+	22,
+	37,
+	56,
+	68,
+	109,
+	103,
+	77,
+	24,
+	35,
+	55,
+	64,
+	81,
+	104,
+	113,
+	92,
+	49,
+	64,
+	78,
+	87,
+	103,
+	121,
+	120,
+	101,
+	72,
+	92,
+	95,
+	98,
+	112,
+	100,
+	103,
+	99
+];
+const CHR_QUANT = [
+	17,
+	18,
+	24,
+	47,
+	99,
+	99,
+	99,
+	99,
+	18,
+	21,
+	26,
+	66,
+	99,
+	99,
+	99,
+	99,
+	24,
+	26,
+	56,
+	99,
+	99,
+	99,
+	99,
+	99,
+	47,
+	66,
+	99,
+	99,
+	99,
+	99,
+	99,
+	99,
+	99,
+	99,
+	99,
+	99,
+	99,
+	99,
+	99,
+	99,
+	99,
+	99,
+	99,
+	99,
+	99,
+	99,
+	99,
+	99,
+	99,
+	99,
+	99,
+	99,
+	99,
+	99,
+	99,
+	99,
+	99,
+	99,
+	99,
+	99,
+	99,
+	99,
+	99,
+	99
+];
+const STD_DC_LUM_NCODES = [
+	0,
+	1,
+	5,
+	1,
+	1,
+	1,
+	1,
+	1,
+	1,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0
+];
+const STD_DC_LUM_VALUES = [
+	0,
+	1,
+	2,
+	3,
+	4,
+	5,
+	6,
+	7,
+	8,
+	9,
+	10,
+	11
+];
+const STD_DC_CHR_NCODES = [
+	0,
+	3,
+	1,
+	1,
+	1,
+	1,
+	1,
+	1,
+	1,
+	1,
+	1,
+	0,
+	0,
+	0,
+	0,
+	0
+];
+const STD_DC_CHR_VALUES = [
+	0,
+	1,
+	2,
+	3,
+	4,
+	5,
+	6,
+	7,
+	8,
+	9,
+	10,
+	11
+];
+const STD_AC_LUM_NCODES = [
+	0,
+	2,
+	1,
+	3,
+	3,
+	2,
+	4,
+	3,
+	5,
+	5,
+	4,
+	4,
+	0,
+	0,
+	1,
+	125
+];
+const STD_AC_LUM_VALUES = [
+	1,
+	2,
+	3,
+	0,
+	4,
+	17,
+	5,
+	18,
+	33,
+	49,
+	65,
+	6,
+	19,
+	81,
+	97,
+	7,
+	34,
+	113,
+	20,
+	50,
+	129,
+	145,
+	161,
+	8,
+	35,
+	66,
+	177,
+	193,
+	21,
+	82,
+	209,
+	240,
+	36,
+	51,
+	98,
+	114,
+	130,
+	9,
+	10,
+	22,
+	23,
+	24,
+	25,
+	26,
+	37,
+	38,
+	39,
+	40,
+	41,
+	42,
+	52,
+	53,
+	54,
+	55,
+	56,
+	57,
+	58,
+	67,
+	68,
+	69,
+	70,
+	71,
+	72,
+	73,
+	74,
+	83,
+	84,
+	85,
+	86,
+	87,
+	88,
+	89,
+	90,
+	99,
+	100,
+	101,
+	102,
+	103,
+	104,
+	105,
+	106,
+	115,
+	116,
+	117,
+	118,
+	119,
+	120,
+	121,
+	122,
+	131,
+	132,
+	133,
+	134,
+	135,
+	136,
+	137,
+	138,
+	146,
+	147,
+	148,
+	149,
+	150,
+	151,
+	152,
+	153,
+	154,
+	162,
+	163,
+	164,
+	165,
+	166,
+	167,
+	168,
+	169,
+	170,
+	178,
+	179,
+	180,
+	181,
+	182,
+	183,
+	184,
+	185,
+	186,
+	194,
+	195,
+	196,
+	197,
+	198,
+	199,
+	200,
+	201,
+	202,
+	210,
+	211,
+	212,
+	213,
+	214,
+	215,
+	216,
+	217,
+	218,
+	225,
+	226,
+	227,
+	228,
+	229,
+	230,
+	231,
+	232,
+	233,
+	234,
+	241,
+	242,
+	243,
+	244,
+	245,
+	246,
+	247,
+	248,
+	249,
+	250
+];
+const STD_AC_CHR_NCODES = [
+	0,
+	2,
+	1,
+	2,
+	4,
+	4,
+	3,
+	4,
+	7,
+	5,
+	4,
+	4,
+	0,
+	1,
+	2,
+	119
+];
+const STD_AC_CHR_VALUES = [
+	0,
+	1,
+	2,
+	3,
+	17,
+	4,
+	5,
+	33,
+	49,
+	6,
+	18,
+	65,
+	81,
+	7,
+	97,
+	113,
+	19,
+	34,
+	50,
+	129,
+	8,
+	20,
+	66,
+	145,
+	161,
+	177,
+	193,
+	9,
+	35,
+	51,
+	82,
+	240,
+	21,
+	98,
+	114,
+	209,
+	10,
+	22,
+	36,
+	52,
+	225,
+	37,
+	241,
+	23,
+	24,
+	25,
+	26,
+	38,
+	39,
+	40,
+	41,
+	42,
+	53,
+	54,
+	55,
+	56,
+	57,
+	58,
+	67,
+	68,
+	69,
+	70,
+	71,
+	72,
+	73,
+	74,
+	83,
+	84,
+	85,
+	86,
+	87,
+	88,
+	89,
+	90,
+	99,
+	100,
+	101,
+	102,
+	103,
+	104,
+	105,
+	106,
+	115,
+	116,
+	117,
+	118,
+	119,
+	120,
+	121,
+	122,
+	130,
+	131,
+	132,
+	133,
+	134,
+	135,
+	136,
+	137,
+	138,
+	146,
+	147,
+	148,
+	149,
+	150,
+	151,
+	152,
+	153,
+	154,
+	162,
+	163,
+	164,
+	165,
+	166,
+	167,
+	168,
+	169,
+	170,
+	178,
+	179,
+	180,
+	181,
+	182,
+	183,
+	184,
+	185,
+	186,
+	194,
+	195,
+	196,
+	197,
+	198,
+	199,
+	200,
+	201,
+	202,
+	210,
+	211,
+	212,
+	213,
+	214,
+	215,
+	216,
+	217,
+	218,
+	226,
+	227,
+	228,
+	229,
+	230,
+	231,
+	232,
+	233,
+	234,
+	242,
+	243,
+	244,
+	245,
+	246,
+	247,
+	248,
+	249,
+	250
+];
+const YDC = buildHuffman(STD_DC_LUM_NCODES, STD_DC_LUM_VALUES);
+const CDC = buildHuffman(STD_DC_CHR_NCODES, STD_DC_CHR_VALUES);
+const YAC = buildHuffman(STD_AC_LUM_NCODES, STD_AC_LUM_VALUES);
+const CAC = buildHuffman(STD_AC_CHR_NCODES, STD_AC_CHR_VALUES);
+//#endregion
+//#region src/resources-image.ts
+/**
+* Build-time PNG/JPEG pixel helpers for page resources.
+*
+* PNG is decoded and re-encoded for resize/crop. JPEG is encode-only so a
+* `format=jpeg` transform can change the container after the pixel pass.
+*/
+const PNG_SIGNATURE = Buffer.from([
+	137,
+	80,
+	78,
+	71,
+	13,
+	10,
+	26,
+	10
+]);
+function isPng(buffer) {
+	return buffer.length >= 8 && PNG_SIGNATURE.equals(buffer.subarray(0, 8));
+}
+function decodePng(buffer) {
+	if (!isPng(buffer)) throw new Error("not a PNG");
+	let width = 0;
+	let height = 0;
+	let bitDepth = 0;
+	let colorType = 0;
+	const idat = [];
+	let offset = 8;
+	while (offset + 12 <= buffer.length) {
+		const length = buffer.readUInt32BE(offset);
+		const type = buffer.toString("ascii", offset + 4, offset + 8);
+		const start = offset + 8;
+		const end = start + length;
+		if (end + 4 > buffer.length) break;
+		const chunk = buffer.subarray(start, end);
+		if (type === "IHDR") {
+			width = chunk.readUInt32BE(0);
+			height = chunk.readUInt32BE(4);
+			bitDepth = chunk[8] ?? 0;
+			colorType = chunk[9] ?? 0;
+		} else if (type === "IDAT") idat.push(Buffer.from(chunk));
+		else if (type === "IEND") break;
+		offset = end + 4;
+	}
+	if (bitDepth !== 8 || colorType !== 2 && colorType !== 6) throw new Error("unsupported PNG");
+	const channels = colorType === 6 ? 4 : 3;
+	const raw = inflateSync(Buffer.concat(idat));
+	const stride = width * channels;
+	const data = new Uint8Array(width * height * 4);
+	let src = 0;
+	const prior = new Uint8Array(stride);
+	const recon = new Uint8Array(stride);
+	for (let y = 0; y < height; y++) {
+		const filter = raw[src++] ?? 0;
+		for (let x = 0; x < stride; x++) {
+			const sample = raw[src++] ?? 0;
+			const a = x >= channels ? recon[x - channels] : 0;
+			const b = prior[x] ?? 0;
+			const c = x >= channels ? prior[x - channels] : 0;
+			recon[x] = sample + paethPredict(filter, a, b, c) & 255;
+		}
+		for (let x = 0; x < width; x++) {
+			const i = x * channels;
+			const o = (y * width + x) * 4;
+			data[o] = recon[i] ?? 0;
+			data[o + 1] = recon[i + 1] ?? 0;
+			data[o + 2] = recon[i + 2] ?? 0;
+			data[o + 3] = channels === 4 ? recon[i + 3] ?? 255 : 255;
+		}
+		prior.set(recon);
+	}
+	return {
+		width,
+		height,
+		data
+	};
+}
+function paethPredict(filter, a, b, c) {
+	switch (filter) {
+		case 0: return 0;
+		case 1: return a;
+		case 2: return b;
+		case 3: return a + b >> 1;
+		case 4: {
+			const p = a + b - c;
+			const pa = Math.abs(p - a);
+			const pb = Math.abs(p - b);
+			const pc = Math.abs(p - c);
+			if (pa <= pb && pa <= pc) return a;
+			if (pb <= pc) return b;
+			return c;
+		}
+		default: throw new Error("unsupported PNG filter");
+	}
+}
+function encodePng(image) {
+	const { width, height, data } = image;
+	const raw = Buffer.alloc((width * 4 + 1) * height);
+	let offset = 0;
+	for (let y = 0; y < height; y++) {
+		raw[offset++] = 0;
+		raw.set(data.subarray(y * width * 4, (y + 1) * width * 4), offset);
+		offset += width * 4;
+	}
+	const ihdr = Buffer.alloc(13);
+	ihdr.writeUInt32BE(width, 0);
+	ihdr.writeUInt32BE(height, 4);
+	ihdr[8] = 8;
+	ihdr[9] = 6;
+	return Buffer.concat([
+		PNG_SIGNATURE,
+		pngChunk("IHDR", ihdr),
+		pngChunk("IDAT", deflateSync(raw)),
+		pngChunk("IEND", Buffer.alloc(0))
+	]);
+}
+function pngChunk(type, data) {
+	const body = Buffer.concat([Buffer.from(type, "ascii"), data]);
+	const chunk = Buffer.alloc(12 + data.length);
+	chunk.writeUInt32BE(data.length, 0);
+	body.copy(chunk, 4);
+	chunk.writeUInt32BE(crc32(body), 8 + data.length);
+	return chunk;
+}
+function crc32(data) {
+	let crc = 4294967295;
+	for (const byte of data) {
+		crc ^= byte;
+		for (let i = 0; i < 8; i++) crc = crc & 1 ? crc >>> 1 ^ 3988292384 : crc >>> 1;
+	}
+	return (crc ^ 4294967295) >>> 0;
+}
+function resizeNearest(image, width, height) {
+	const data = new Uint8Array(width * height * 4);
+	for (let y = 0; y < height; y++) {
+		const sy = Math.min(image.height - 1, Math.floor(y * image.height / height));
+		for (let x = 0; x < width; x++) {
+			const sx = Math.min(image.width - 1, Math.floor(x * image.width / width));
+			data.set(image.data.subarray((sy * image.width + sx) * 4, (sy * image.width + sx) * 4 + 4), (y * width + x) * 4);
+		}
+	}
+	return {
+		width,
+		height,
+		data
+	};
+}
+function cropImage(image, x, y, width, height) {
+	const left = Math.max(0, Math.min(image.width, Math.floor(x)));
+	const top = Math.max(0, Math.min(image.height, Math.floor(y)));
+	const cropW = Math.max(1, Math.min(image.width - left, Math.floor(width)));
+	const cropH = Math.max(1, Math.min(image.height - top, Math.floor(height)));
+	const data = new Uint8Array(cropW * cropH * 4);
+	for (let row = 0; row < cropH; row++) {
+		const src = ((top + row) * image.width + left) * 4;
+		data.set(image.data.subarray(src, src + cropW * 4), row * cropW * 4);
+	}
+	return {
+		width: cropW,
+		height: cropH,
+		data
+	};
+}
+function coverCrop(image, width, height) {
+	const scale = Math.max(width / image.width, height / image.height);
+	const scaled = resizeNearest(image, Math.max(width, Math.round(image.width * scale)), Math.max(height, Math.round(image.height * scale)));
+	return cropImage(scaled, Math.max(0, Math.floor((scaled.width - width) / 2)), Math.max(0, Math.floor((scaled.height - height) / 2)), width, height);
+}
+//#endregion
+//#region src/resources-process.ts
+/**
+* Page-resource HTML rewriting and transform writes.
+*/
+const IMG_TAG = /<img\b[^>]*>/gi;
+const SRC_ATTR = /\bsrc\s*=\s*(?:"([^"]*)"|'([^']*)')/i;
+async function processPageResources(input) {
+	if (!input.options.enabled) return {
+		html: input.html,
+		files: [],
+		errors: [],
+		fatal: []
+	};
+	const bundleRoot = path$1.dirname(input.inputPath);
+	const outputDir = path$1.dirname(input.outputPath);
+	const files = [];
+	const errors = [];
+	const fatal = [];
+	let html = input.html;
+	const tags = input.html.match(IMG_TAG) ?? [];
+	for (const tag of tags) {
+		const srcMatch = tag.match(SRC_ATTR);
+		const rawSrc = srcMatch?.[1] ?? srcMatch?.[2];
+		if (!rawSrc) continue;
+		const src = unescapeHtml(rawSrc);
+		const parsed = parseResourceSrc(src);
+		if (!parsed) continue;
+		const resolved = resolveBundlePath(parsed.pathname, bundleRoot, input.srcDir);
+		if (!resolved.ok) {
+			const message = `[ox-content] page resource ${JSON.stringify(src)} on ${input.inputPath} is outside the page bundle`;
+			errors.push(message);
+			fatal.push(message);
+			continue;
+		}
+		let stat;
+		try {
+			stat = await fs$2.stat(resolved.absolute);
+		} catch {
+			const message = `[ox-content] missing page resource ${JSON.stringify(parsed.pathname)} on ${input.inputPath}`;
+			errors.push(message);
+			if (input.options.missing === "error") fatal.push(message);
+			continue;
+		}
+		const transformError = validateTransform(parsed.transform, input.options);
+		if (transformError) {
+			const message = `[ox-content] ${transformError} for ${JSON.stringify(src)} on ${input.inputPath}`;
+			errors.push(message);
+			fatal.push(message);
+			continue;
+		}
+		const hasTransform = hasPixelOrFormatTransform(parsed.transform);
+		const outputName = hasTransform ? transformedFileName(parsed.pathname, parsed.transform, resourceCacheKey(resolved.absolute, stat.mtimeMs, parsed.transform)) : path$1.basename(resolved.absolute);
+		const outputFile = path$1.join(outputDir, outputName);
+		try {
+			if (hasTransform) await writeTransformedResource({
+				sourcePath: resolved.absolute,
+				outputFile,
+				cacheDir: input.cacheDir,
+				mtimeMs: stat.mtimeMs,
+				transform: parsed.transform
+			});
+			else {
+				await fs$2.mkdir(outputDir, { recursive: true });
+				await fs$2.copyFile(resolved.absolute, outputFile);
+			}
+			files.push(outputFile);
+			const rewritten = tag.replace(rawSrc, escapeAttribute(outputName));
+			html = html.replace(tag, rewritten);
+		} catch (error) {
+			const detail = error instanceof Error ? error.message : String(error);
+			const message = `[ox-content] failed to process page resource ${JSON.stringify(src)} on ${input.inputPath}: ${detail}`;
+			errors.push(message);
+			fatal.push(message);
+		}
+	}
+	return {
+		html,
+		files,
+		errors,
+		fatal
+	};
+}
+function resolveBundlePath(pathname, bundleRoot, contentRoot) {
+	if (path$1.isAbsolute(pathname) || pathname.includes("\0")) return { ok: false };
+	const absolute = path$1.resolve(bundleRoot, pathname);
+	if (!isInsideRoot$1(bundleRoot, absolute) || !isInsideRoot$1(contentRoot, absolute)) return { ok: false };
+	return {
+		ok: true,
+		absolute
 	};
 }
-function outputToHref(outputPath, outDir, base) {
-	return siteHref$1(base, "", relativeUrl(outputPath, outDir));
+function validateTransform(transform, options) {
+	if (transform.width && options.widths.length > 0 && !options.widths.includes(transform.width)) return `width ${transform.width} is not in resources.widths`;
+	if (transform.format && !options.formats.includes(transform.format)) return `format ${transform.format} is not in resources.formats`;
 }
-/** Applies switcher / banner / search rewrite after every version tree is generated. */
-function decorateVersionedPages(pages, options, outDir, base) {
-	if (!options.enabled) return;
-	const existingHrefs = new Set(pages.map((page) => outputToHref(page.outputPath, outDir, base)));
-	for (const page of pages) {
-		const { id, sibling } = versionLocation(page.outputPath, outDir, options);
-		page.html = applyVersionChrome(page.html, options, id, sibling, base, existingHrefs);
-	}
+function hasPixelOrFormatTransform(transform) {
+	return Boolean(transform.width || transform.height || transform.crop || transform.format);
 }
-async function writeSnapshotSearchIndex(input) {
-	const prefix = sanitizePrefix(input.prefix);
-	if (!prefix) return;
-	const destDir = path$1.join(input.outDir, prefix);
-	const prefixBase = searchIndexUrl(input.base, prefix).replace(/search-index\.json$/, "");
-	const json = await buildSearchIndex(input.srcDir, prefixBase, input.extensions, input.publishState, [], input.mdx);
-	await fs$1.mkdir(destDir, { recursive: true });
-	await writeSearchIndex(json, destDir);
-	const dest = path$1.join(destDir, "search-index.json");
+function transformedFileName(pathname, transform, cacheKey) {
+	const stem = path$1.basename(pathname).replace(/\.[^.]+$/, "") || "resource";
+	const ext = outputExtension(pathname, transform.format);
+	return `${stem}.${cacheKey.slice(0, 12)}.${ext}`;
+}
+function outputExtension(pathname, format) {
+	if (format === "jpeg") return "jpg";
+	if (format) return format;
+	const ext = path$1.extname(pathname).slice(1).toLowerCase();
+	return ext === "jpeg" ? "jpg" : ext || "png";
+}
+async function writeTransformedResource(input) {
+	const key = resourceCacheKey(input.sourcePath, input.mtimeMs, input.transform);
+	const ext = path$1.extname(input.outputFile);
+	const cacheFile = path$1.join(input.cacheDir, `${key}${ext}`);
 	try {
-		await fs$1.access(dest);
-	} catch {
-		await fs$1.writeFile(dest, json, "utf8");
+		await fs$2.copyFile(cacheFile, input.outputFile);
+		return;
+	} catch {}
+	const output = transformResourceBuffer(await fs$2.readFile(input.sourcePath), input.sourcePath, input.transform);
+	if (output.length > 8388608) throw new Error("transform produced an oversized file");
+	await fs$2.mkdir(path$1.dirname(input.outputFile), { recursive: true });
+	await fs$2.mkdir(input.cacheDir, { recursive: true });
+	await fs$2.writeFile(cacheFile, output);
+	await fs$2.writeFile(input.outputFile, output);
+}
+function transformResourceBuffer(source, sourcePath, transform) {
+	const needsPixels = Boolean(transform.width || transform.height || transform.crop);
+	if (!needsPixels && !transform.format) return source;
+	if (!needsPixels && transform.format) {
+		if (!isPng(source)) {
+			if (transform.format === formatFromPath(sourcePath)) return source;
+			throw new Error(`cannot convert ${path$1.extname(sourcePath) || "source"} to ${transform.format}`);
+		}
+		return encodeFormat(decodePng(source), transform.format);
+	}
+	if (!isPng(source)) throw new Error("resize/crop requires a PNG source");
+	return encodeFormat(applyPixelTransform(decodePng(source), transform), transform.format ?? "png");
+}
+function applyPixelTransform(image, transform) {
+	const crop = transform.crop;
+	if (crop && crop !== "center") {
+		const parts = crop.split(",").map((part) => Number(part.trim()));
+		if (parts.length === 4 && parts.every((part) => Number.isFinite(part))) return cropImage(image, parts[0], parts[1], parts[2], parts[3]);
+		throw new Error(`invalid crop ${crop}`);
+	}
+	const width = transform.width;
+	const height = transform.height;
+	if (crop === "center") {
+		if (!width || !height) throw new Error("crop=center requires width and height");
+		return coverCrop(image, width, height);
+	}
+	if (width && height) return resizeNearest(image, width, height);
+	if (width) return resizeNearest(image, width, Math.max(1, Math.round(image.height * width / image.width)));
+	if (height) return resizeNearest(image, Math.max(1, Math.round(image.width * height / image.height)), height);
+	return image;
+}
+function encodeFormat(image, format) {
+	if (format === "jpeg") return encodeJpeg(image);
+	if (format === "png") return encodePng(image);
+	if (format === "webp") throw new Error("webp encoding requires a webp source without pixel transforms");
+	throw new Error(`unsupported format ${format}`);
+}
+function formatFromPath(filePath) {
+	const ext = path$1.extname(filePath).slice(1).toLowerCase();
+	return ext === "jpg" ? "jpeg" : ext;
+}
+function unescapeHtml(value) {
+	return value.replaceAll("&amp;", "&").replaceAll("&quot;", "\"").replaceAll("&#39;", "'").replaceAll("&lt;", "<").replaceAll("&gt;", ">");
+}
+function escapeAttribute(value) {
+	return value.replaceAll("&", "&amp;").replaceAll("\"", "&quot;").replaceAll("'", "&#39;").replaceAll("<", "&lt;").replaceAll(">", "&gt;");
+}
+//#endregion
+//#region src/resources.ts
+/**
+* Opt-in page-bundle resources and build-time image processing.
+*
+* A page directory is the bundle root. Sibling images are addressable with
+* relative URLs. Resize/crop/format query transforms run at build time and
+* are cached by source mtime plus transform params. Paths that leave the
+* bundle or `srcDir` are never processed.
+*/
+const DEFAULT_FORMATS = [
+	"png",
+	"jpeg",
+	"webp"
+];
+const HOSTILE_SRC = /^(?:javascript|data|vbscript):/i;
+var PageResourceError = class extends Error {
+	issues;
+	constructor(issues) {
+		super(issues.join("\n"));
+		this.name = "PageResourceError";
+		this.issues = issues;
 	}
-	return dest;
+};
+/**
+* Resolves `resources`. Omitted / `false` stay off. `true` or `{}` enables
+* defaults. An object enables the feature and overrides only set fields.
+*/
+function resolveResourcesOptions(value) {
+	if (!value) return {
+		enabled: false,
+		formats: [...DEFAULT_FORMATS],
+		widths: [],
+		missing: "error"
+	};
+	if (value === true) return {
+		enabled: true,
+		formats: [...DEFAULT_FORMATS],
+		widths: [],
+		missing: "error"
+	};
+	return {
+		enabled: true,
+		formats: normalizeFormats(value.formats),
+		widths: normalizeWidths(value.widths),
+		missing: value.missing === "warn" ? "warn" : "error"
+	};
 }
-function applyVersionChrome(html, options, activeId, siblingPath, base, existingHrefs) {
-	if (!options.enabled) return html;
-	const active = options.entries.find((entry) => entry.id === activeId);
-	return injectVersionChrome(html, options.switcher ? versionSwitcherMarkup(versionLinks(options, activeId, siblingPath, base, existingHrefs), options.badge) : "", versionBannerMarkup(active?.banner), searchIndexUrl(base, currentVersionPrefix(options)), searchIndexUrl(base, active?.prefix ?? ""));
+/**
+* Cache key for a source file plus transform. Changing mtime or params
+* produces a different key so stale derivatives are not reused.
+*/
+function resourceCacheKey(sourcePath, mtimeMs, transform) {
+	return createHash("sha256").update(sourcePath).update("\0").update(String(mtimeMs)).update("\0").update(JSON.stringify(normalizeTransform(transform))).digest("hex");
 }
-function sanitizePrefix(prefix) {
-	const trimmed = prefix.trim().replace(/^\/+|\/+$/g, "");
-	if (!trimmed) return "";
-	return PREFIX_RE.test(trimmed) && !trimmed.includes("..") ? trimmed : "";
+/** True when `candidate` stays inside `root` after resolve. */
+function isInsideRoot$1(root, candidate) {
+	const resolvedRoot = path$1.resolve(root);
+	const resolved = path$1.resolve(candidate);
+	const relative = path$1.relative(resolvedRoot, resolved);
+	return relative === "" || !relative.startsWith("..") && !path$1.isAbsolute(relative);
 }
-function defaultCurrentEntry() {
+function parseResourceSrc(src) {
+	const trimmed = src.trim();
+	if (!trimmed || isRemoteOrAbsolute(trimmed) || HOSTILE_SRC.test(trimmed.replace(/\s+/g, ""))) return;
+	const withoutHash = trimmed.split("#")[0] ?? trimmed;
+	const queryIndex = withoutHash.indexOf("?");
+	const pathname = queryIndex === -1 ? withoutHash : withoutHash.slice(0, queryIndex);
+	const query = queryIndex === -1 ? "" : withoutHash.slice(queryIndex + 1);
+	if (!pathname || pathname.includes("\0")) return;
+	const params = new URLSearchParams(query);
 	return {
-		id: DEFAULT_CURRENT_ID,
-		label: "Latest",
-		prefix: "",
-		banner: false
+		pathname,
+		transform: {
+			width: parsePositiveInt(params.get("width") ?? params.get("w")),
+			height: parsePositiveInt(params.get("height") ?? params.get("h")),
+			crop: params.get("crop")?.trim() || void 0,
+			format: normalizeFormat(params.get("format") ?? void 0)
+		}
 	};
 }
-function normalizeEntries(entries) {
-	if (!entries) return [];
-	const seen = /* @__PURE__ */ new Set();
-	const resolved = [];
-	for (const entry of entries) {
-		if (!entry || typeof entry.id !== "string" || typeof entry.label !== "string") continue;
-		const id = entry.id.trim();
-		const label = entry.label.trim();
-		if (!id || !label || seen.has(id)) continue;
-		const prefix = sanitizePrefix(typeof entry.prefix === "string" ? entry.prefix : "");
-		if (entry.prefix && !prefix) continue;
-		const dir = typeof entry.dir === "string" && entry.dir.trim() ? entry.dir.trim() : void 0;
-		if (dir && (dir.includes("\0") || dir.includes(".."))) continue;
-		seen.add(id);
-		resolved.push({
-			id,
-			label,
-			prefix,
-			dir,
-			banner: normalizeBanner(entry.banner)
-		});
-	}
-	return resolved;
+function isRemoteOrAbsolute(src) {
+	const compact = src.replace(/\s+/g, "");
+	return /^[a-z][a-z0-9+.-]*:/i.test(compact) || compact.startsWith("//") || compact.startsWith("/");
 }
-function normalizeBanner(value) {
-	return value === "unreleased" || value === "unmaintained" ? value : false;
+function parsePositiveInt(raw) {
+	if (!raw) return;
+	if (!/^[0-9]+$/.test(raw)) return;
+	const value = Number(raw);
+	return value > 0 ? value : void 0;
 }
-function siteHref$1(base, prefix, rest) {
-	const root = !base || base === "/" ? "/" : base.endsWith("/") ? base : `${base}/`;
-	const parts = [prefix, rest].filter((part) => part && part !== "/");
-	return parts.length === 0 ? root : `${root}${parts.join("/")}/`;
+function normalizeFormats(formats) {
+	if (!formats?.length) return [...DEFAULT_FORMATS];
+	const normalized = formats.map((format) => normalizeFormat(format)).filter((format) => Boolean(format));
+	return normalized.length > 0 ? [...new Set(normalized)] : [...DEFAULT_FORMATS];
 }
-function relativeUrl(outputPath, outDir) {
-	const rel = path$1.posix.normalize(path$1.relative(path$1.resolve(outDir), path$1.resolve(outputPath)).replaceAll(path$1.sep, "/"));
-	if (rel.startsWith("..")) return "";
-	const dir = rel.endsWith("/index.html") ? rel.slice(0, -11) : rel.replace(/\.html$/, "");
-	return dir === "." ? "" : dir;
+function normalizeWidths(widths) {
+	if (!widths?.length) return [];
+	return [...new Set(widths.filter((width) => Number.isInteger(width) && width > 0))];
+}
+function normalizeFormat(format) {
+	if (!format) return;
+	const value = format.trim().toLowerCase();
+	if (value === "jpg") return "jpeg";
+	return value || void 0;
+}
+function normalizeTransform(transform) {
+	return {
+		width: transform.width,
+		height: transform.height,
+		crop: transform.crop,
+		format: transform.format
+	};
 }
 //#endregion
 //#region src/version-navigation.ts
@@ -6338,14 +9238,18 @@ function resolveSsgOptions(ssg) {
 		bare: false,
 		generateOgImage: false,
 		lastUpdated: false,
+		contributors: resolveContributorsOption(void 0),
 		pagination: false,
 		breadcrumbs: false,
+		jsonLd: false,
 		readerChrome: false,
 		localeSwitcher: false,
 		a11y: false,
 		pageChrome: false,
 		notFound: resolveNotFoundOptions(void 0),
-		team: resolveTeamOptions(void 0)
+		team: resolveTeamOptions(void 0),
+		blog: resolveBlogOptions(void 0),
+		sectionIndex: resolveSectionIndexOptions(void 0)
 	};
 	if (ssg === true || ssg === void 0) return {
 		enabled: true,
@@ -6354,14 +9258,18 @@ function resolveSsgOptions(ssg) {
 		bare: false,
 		generateOgImage: false,
 		lastUpdated: false,
+		contributors: resolveContributorsOption(void 0),
 		pagination: false,
 		breadcrumbs: false,
+		jsonLd: false,
 		readerChrome: false,
 		localeSwitcher: false,
 		a11y: false,
 		pageChrome: false,
 		notFound: resolveNotFoundOptions(void 0),
 		team: resolveTeamOptions(void 0),
+		blog: resolveBlogOptions(void 0),
+		sectionIndex: resolveSectionIndexOptions(void 0),
 		theme: resolveTheme(void 0)
 	};
 	return {
@@ -6378,22 +9286,56 @@ function resolveSsgOptions(ssg) {
 		ogImage: ssg.ogImage,
 		generateOgImage: ssg.generateOgImage ?? false,
 		lastUpdated: ssg.lastUpdated ?? false,
+		contributors: resolveContributorsOption(ssg.contributors),
 		pagination: resolvePaginationOption(ssg.pagination),
 		breadcrumbs: resolvePaginationOption(ssg.breadcrumbs),
+		jsonLd: resolveJsonLdOption(ssg.jsonLd),
 		readerChrome: resolveReaderChromeOption(ssg.readerChrome),
 		localeSwitcher: resolveLocaleSwitcherOption(ssg.localeSwitcher),
 		a11y: resolveA11yOption(ssg.a11y),
 		pageChrome: resolvePageChromeOption(ssg.pageChrome),
 		notFound: resolveNotFoundOptions(ssg.notFound),
 		team: resolveTeamOptions(ssg.team),
+		blog: resolveBlogOptions(ssg.blog),
+		sectionIndex: resolveSectionIndexOptions(ssg.sectionIndex),
 		siteUrl: ssg.siteUrl,
 		theme: resolveTheme(ssg.theme),
 		navigation: ssg.navigation
 	};
 }
+function contributorsForPage(context, inputPath) {
+	const option = context.ssgOptions.contributors;
+	if (!option) return;
+	try {
+		return applyContributorOptions(context.napi?.getGitContributors(inputPath, context.root) ?? [], option);
+	} catch {
+		return [];
+	}
+}
 function resolvePaginationOption(value) {
 	return value === true || typeof value === "object" && value !== null;
 }
+function resolveJsonLdOption(value) {
+	if (value === true) return { breadcrumbs: true };
+	if (value && typeof value === "object") {
+		const publisher = resolveJsonLdPublisher(value.publisher);
+		return {
+			breadcrumbs: value.breadcrumbs !== false,
+			...publisher ? { publisher } : {}
+		};
+	}
+	return false;
+}
+function resolveJsonLdPublisher(publisher) {
+	if (!publisher || typeof publisher !== "object") return;
+	const name = publisher.name?.trim();
+	const url = publisher.url?.trim();
+	if (!name && !url) return;
+	return {
+		...name ? { name } : {},
+		...url ? { url } : {}
+	};
+}
 function resolveReaderChromeOption(value) {
 	if (value === true) return {
 		copy: true,
@@ -6522,7 +9464,7 @@ function localeCodesFor(locales) {
 async function generateHtmlPage(pageData, navGroups, siteName, base, ogImage, theme, locale, availableLocales, pagination = false, readerChrome = false, breadcrumbs = false, localeSwitcher = false, localePaths, a11y = false, team = {
 	enabled: false,
 	members: []
-}, pageChrome = false, breadcrumbRootHref) {
+}, pageChrome = false, breadcrumbRootHref, jsonLd = false, siteUrl) {
 	const mod = await importNapiModule();
 	const tocForRust = pageData.toc.map(toRustTocEntry);
 	const navGroupsForRust = convertNavGroupsForRust(navGroups);
@@ -6564,6 +9506,7 @@ async function generateHtmlPage(pageData, navGroups, siteName, base, ogImage, th
 		content: pageData.content,
 		toc: tocForRust,
 		lastUpdated: pageData.lastUpdated,
+		contributors: pageData.contributors,
 		path: pageData.path,
 		entryPage: entryPageForRust,
 		prev: pageData.prev,
@@ -6590,14 +9533,19 @@ async function generateHtmlPage(pageData, navGroups, siteName, base, ogImage, th
 		localePaths,
 		a11y: a11y ? { skipLinkLabel: a11y.skipLinkLabel } : void 0,
 		team,
-		pageChrome
+		pageChrome,
+		jsonLd: jsonLd ? {
+			breadcrumbs: jsonLd.breadcrumbs,
+			publisher: jsonLd.publisher,
+			siteUrl
+		} : void 0
 	});
 }
 async function externalizeSharedPageAssets(pages, outDir, base) {
 	const optimized = (await importNapiModule()).externalizeSsgAssets(pages, outDir, base);
 	await Promise.all(optimized.assets.map(async (asset) => {
-		await fs$2.mkdir(path$2.dirname(asset.outputPath), { recursive: true });
-		await fs$2.writeFile(asset.outputPath, asset.content, "utf-8");
+		await fs$3.mkdir(path$2.dirname(asset.outputPath), { recursive: true });
+		await fs$3.writeFile(asset.outputPath, asset.content, "utf-8");
 	}));
 	return {
 		pages: optimized.pages,
@@ -6677,10 +9625,31 @@ async function buildSsg(options, root) {
 	errors.push(...collected.errors);
 	const { outputPages, listedPages } = applyPublishState(context, collected);
 	remapPermalinkNav(context, listedPages);
+	await applyPageResources(context, outputPages, generatedFiles, errors);
 	await generateOgImageAssets(context, collected, generatedFiles, errors);
 	injectRelatedPages(outputPages, listedPages, context.options.taxonomies);
+	const blog = context.options.blog ?? context.ssgOptions.blog;
+	await injectBlogPostMeta({
+		pages: outputPages,
+		listed: listedPages,
+		options: blog,
+		srcDir: context.srcDir,
+		collections: context.options.collections,
+		base: context.base
+	});
 	const generatedPages = await generateHtmlPages(context, outputPages, collected, errors);
 	await appendNotFoundPage(generatedPages, context, collected, errors);
+	await appendSectionIndexPages({
+		generatedPages,
+		collectedPages: collected.pageResults,
+		listedPages,
+		options: context.ssgOptions.sectionIndex,
+		outDir: context.outDir,
+		base: context.base,
+		extension: context.ssgOptions.extension,
+		errors,
+		render: (page) => renderSsgPage(context, toSectionIndexProcessResult(page), collected, listedPages)
+	});
 	await appendTaxonomyPages({
 		generatedPages,
 		listedPages,
@@ -6690,8 +9659,20 @@ async function buildSsg(options, root) {
 		errors,
 		render: (page) => renderSsgPage(context, toTaxonomyProcessResult(page), collected, listedPages)
 	});
+	await appendBlogPages({
+		generatedPages,
+		listedPages,
+		options: blog,
+		collections: context.options.collections,
+		srcDir: context.srcDir,
+		outDir: context.outDir,
+		base: context.base,
+		errors,
+		render: (page) => renderSsgPage(context, toBlogProcessResult(page), collected, listedPages)
+	});
 	await applyDocumentationVersions(generatedPages, context, errors);
 	await writeGeneratedPages(generatedPages, context, generatedFiles, listedPages, outputPages, errors);
+	if (options.math?.enabled) generatedFiles.push(...await copyKatexAssets(outDir));
 	return {
 		files: generatedFiles,
 		errors,
@@ -6701,7 +9682,7 @@ async function buildSsg(options, root) {
 async function cleanOutputDirectory(ssgOptions, outDir) {
 	if (!ssgOptions.clean) return;
 	try {
-		await fs$2.rm(outDir, {
+		await fs$3.rm(outDir, {
 			recursive: true,
 			force: true
 		});
@@ -6720,7 +9701,7 @@ async function createBuildSsgContext(options, root, srcDir, outDir, markdownFile
 		navItems: resolveNavigationGroups(ssgOptions.navigation, base, ssgOptions.extension) ?? (ssgOptions.theme?.sidebar.length ? buildThemeNavItems(ssgOptions.theme.sidebar, base, ssgOptions.extension) : buildNavItems(markdownFiles, srcDir, base, ssgOptions.extension)),
 		siteName: await resolveSiteName$1(root, ssgOptions),
 		shouldGenerateOgImages: shouldGenerateOgImages(options),
-		napi: ssgOptions.lastUpdated ? await importNapiModule() : void 0
+		napi: ssgOptions.lastUpdated || ssgOptions.contributors ? await importNapiModule() : void 0
 	};
 }
 /**
@@ -6739,12 +9720,33 @@ async function resolveSiteName$1(root, ssgOptions) {
 	if (ssgOptions.siteName) return ssgOptions.siteName;
 	try {
 		const pkgPath = path$2.join(root, "package.json");
-		const pkg = JSON.parse(await fs$2.readFile(pkgPath, "utf-8"));
+		const pkg = JSON.parse(await fs$3.readFile(pkgPath, "utf-8"));
 		return pkg.name ? formatTitle(pkg.name) : "Documentation";
 	} catch {
 		return "Documentation";
 	}
 }
+async function applyPageResources(context, pages, generatedFiles, errors) {
+	const options = context.options.resources;
+	if (!options?.enabled) return;
+	const cacheDir = path$2.join(context.root, ".cache", "ox-content-resources");
+	const fatal = [];
+	for (const page of pages) {
+		const processed = await processPageResources({
+			html: page.transformedHtml,
+			inputPath: page.inputPath,
+			outputPath: page.routePaths.outputPath,
+			srcDir: context.srcDir,
+			options,
+			cacheDir
+		});
+		page.transformedHtml = processed.html;
+		generatedFiles.push(...processed.files);
+		errors.push(...processed.errors);
+		fatal.push(...processed.fatal);
+	}
+	if (fatal.length > 0) throw new PageResourceError(fatal);
+}
 function applyPermalinkRoutes(context, collected) {
 	if (!context.options.permalinks?.enabled && !context.options.cascade?.enabled) return;
 	const routed = applySsgPageRoutes({
@@ -6810,7 +9812,7 @@ function applyPublishState(context, collected) {
 	};
 }
 async function transformSsgPage(context, inputPath) {
-	const result = await transformMarkdown(await fs$2.readFile(inputPath, "utf-8"), inputPath, context.options, {
+	const result = await transformMarkdown(await fs$3.readFile(inputPath, "utf-8"), inputPath, context.options, {
 		convertMdLinks: true,
 		baseUrl: context.base,
 		sourcePath: inputPath
@@ -6824,7 +9826,8 @@ async function transformSsgPage(context, inputPath) {
 		transformedHtml,
 		title,
 		description: frontmatter.description,
-		lastUpdated: context.napi?.getGitLastUpdated(inputPath, context.root) ?? void 0,
+		lastUpdated: context.ssgOptions.lastUpdated ? context.napi?.getGitLastUpdated(inputPath, context.root) ?? void 0 : void 0,
+		contributors: contributorsForPage(context, inputPath),
 		frontmatter,
 		toc: result.toc
 	};
@@ -6979,7 +9982,7 @@ async function renderSsgPage(context, pageResult, collected, allPageResults) {
 	return generateHtmlPage(pageData, navItems, context.siteName, context.base, pageOgImage, theme, locale, i18n ? i18n.locales : void 0, context.ssgOptions.pagination, context.ssgOptions.readerChrome, context.ssgOptions.breadcrumbs, context.ssgOptions.localeSwitcher, localePaths, context.ssgOptions.a11y, context.ssgOptions.team ?? {
 		enabled: false,
 		members: []
-	}, context.ssgOptions.pageChrome, versionNavigation?.root.href);
+	}, context.ssgOptions.pageChrome, versionNavigation?.root.href, context.ssgOptions.jsonLd, context.ssgOptions.siteUrl);
 }
 function rewritePagerOverride(pager, context) {
 	return pager?.href ? {
@@ -6995,6 +9998,7 @@ function toThemePageData(pageResult) {
 		html: pageResult.transformedHtml,
 		toc: pageResult.toc,
 		lastUpdated: pageResult.lastUpdated,
+		contributors: pageResult.contributors,
 		path: pageResult.inputPath,
 		url: pageResult.routePaths.href,
 		frontmatter: pageResult.frontmatter,
@@ -7025,6 +10029,7 @@ function createSsgPageData(pageResult) {
 		content: pageResult.transformedHtml,
 		toc: pageResult.toc,
 		lastUpdated: pageResult.lastUpdated,
+		contributors: pageResult.contributors,
 		frontmatter,
 		path: pageResult.routePaths.urlPath,
 		href: pageResult.routePaths.href,
@@ -7041,7 +10046,7 @@ async function appendNotFoundPage(generatedPages, context, collected, errors) {
 	const sourcePath = resolveNotFoundSourcePath(context.srcDir, notFound.source);
 	const outputPath = resolveNotFoundOutputPath(context.outDir, notFound.output);
 	try {
-		const pageResult = await transformNotFoundMarkdown(context, sourcePath, await fileExists(sourcePath) ? await fs$2.readFile(sourcePath, "utf8") : FALLBACK_NOT_FOUND_MARKDOWN);
+		const pageResult = await transformNotFoundMarkdown(context, sourcePath, await fileExists(sourcePath) ? await fs$3.readFile(sourcePath, "utf8") : FALLBACK_NOT_FOUND_MARKDOWN);
 		pageResult.routePaths = {
 			...pageResult.routePaths,
 			outputPath,
@@ -7059,7 +10064,7 @@ async function appendNotFoundPage(generatedPages, context, collected, errors) {
 }
 async function fileExists(filePath) {
 	try {
-		await fs$2.access(filePath);
+		await fs$3.access(filePath);
 		return true;
 	} catch {
 		return false;
@@ -7124,6 +10129,17 @@ async function applyDocumentationVersions(generatedPages, context, errors) {
 			redirects: snapContext.options.redirects?.map
 		});
 		const snapPages = await generateHtmlPages(snapContext, outputPages, snapCollected, errors);
+		await appendSectionIndexPages({
+			generatedPages: snapPages,
+			collectedPages: snapCollected.pageResults,
+			listedPages,
+			options: snapContext.ssgOptions.sectionIndex,
+			outDir: snapContext.outDir,
+			base: snapContext.base,
+			extension: snapContext.ssgOptions.extension,
+			errors,
+			render: (page) => renderSsgPage(snapContext, toSectionIndexProcessResult(page), snapCollected, listedPages)
+		});
 		generatedPages.push(...snapPages);
 		if (context.options.search?.enabled) try {
 			await writeSnapshotSearchIndex({
@@ -7150,9 +10166,24 @@ function pageAliases(frontmatter) {
 async function writeGeneratedPages(generatedPages, context, generatedFiles, listedPages, outputPages, errors) {
 	const optimizedOutput = await externalizeSharedPageAssets(generatedPages, context.outDir, context.base);
 	generatedFiles.push(...optimizedOutput.assets);
+	const pwa = await writePwaFiles({
+		outDir: context.outDir,
+		siteUrl: context.ssgOptions.siteUrl,
+		base: context.base,
+		siteName: context.siteName,
+		options: context.options.pwa
+	});
+	generatedFiles.push(...pwa.files);
+	if (pwa.warning) {
+		errors.push(pwa.warning);
+		console.warn(pwa.warning);
+	} else if (!context.ssgOptions.bare && context.options.pwa?.enabled) for (const page of optimizedOutput.pages) page.html = injectPwaPageTags(page.html, {
+		options: context.options.pwa,
+		base: context.base
+	});
 	for (const page of optimizedOutput.pages) {
-		await fs$2.mkdir(path$2.dirname(page.outputPath), { recursive: true });
-		await fs$2.writeFile(page.outputPath, page.html, "utf-8");
+		await fs$3.mkdir(path$2.dirname(page.outputPath), { recursive: true });
+		await fs$3.writeFile(page.outputPath, page.html, "utf-8");
 		generatedFiles.push(page.outputPath);
 	}
 	const siteMaps = await writeSiteMapFiles({
@@ -7277,14 +10308,14 @@ async function resolveMarkdownFile(url, srcDir, extensions) {
 	for (const relativePath of directCandidates) {
 		const filePath = path$2.join(srcDir, relativePath);
 		try {
-			await fs$2.access(filePath);
+			await fs$3.access(filePath);
 			return filePath;
 		} catch {}
 	}
 	for (const extension of extensions) {
 		const indexPath = path$2.join(srcDir, routePath, `index${extension}`);
 		try {
-			await fs$2.access(indexPath);
+			await fs$3.access(indexPath);
 			return indexPath;
 		} catch {}
 	}
@@ -7328,7 +10359,7 @@ async function resolveSiteName(options, root) {
 	if (options.ssg.siteName) return options.ssg.siteName;
 	try {
 		const pkgPath = path$2.join(root, "package.json");
-		const pkg = JSON.parse(await fs$2.readFile(pkgPath, "utf-8"));
+		const pkg = JSON.parse(await fs$3.readFile(pkgPath, "utf-8"));
 		if (pkg.name) return formatTitle(pkg.name);
 	} catch {}
 	return "Documentation";
@@ -7340,7 +10371,7 @@ async function renderPage$1(filePath, options, navGroups, siteName, base, root,
 	const srcDir = path$2.resolve(root, options.srcDir);
 	resetTabGroupCounter();
 	resetIslandCounter();
-	const result = await transformMarkdown(await fs$2.readFile(filePath, "utf-8"), filePath, options, {
+	const result = await transformMarkdown(await fs$3.readFile(filePath, "utf-8"), filePath, options, {
 		convertMdLinks: true,
 		baseUrl: base,
 		sourcePath: filePath
@@ -7412,7 +10443,7 @@ async function renderPage$1(filePath, options, navGroups, siteName, base, root,
 	let html = await generateHtmlPage(pageData, localizedNav, siteName, base, options.ssg.ogImage, theme, locale, i18n ? i18n.locales : void 0, options.ssg.pagination, options.ssg.readerChrome, options.ssg.breadcrumbs, options.ssg.localeSwitcher, localePaths, options.ssg.a11y, options.ssg.team ?? {
 		enabled: false,
 		members: []
-	}, options.ssg.pageChrome);
+	}, options.ssg.pageChrome, void 0, options.ssg.jsonLd, options.ssg.siteUrl);
 	html = injectViteHmrClient(html);
 	return html;
 }
@@ -7540,7 +10571,7 @@ async function collectPages(options, root) {
 	const pages = [];
 	const generateOgImage = options.ogImage || options.ssg.generateOgImage;
 	for (const file of files.sort()) {
-		const content = fs.readFileSync(file, "utf-8");
+		const content = fs$1.readFileSync(file, "utf-8");
 		const frontmatter = normalizeVitePressFrontmatter(parseFrontmatter(content));
 		if (frontmatter.layout === "entry") continue;
 		const title = extractTitle(content, frontmatter);
@@ -7864,7 +10895,7 @@ function createI18nPlugin(resolvedOptions) {
 		async buildStart() {
 			if (!i18nOptions || !i18nOptions.check) return;
 			const dictDir = path$2.resolve(root, i18nOptions.dir);
-			if (!fs.existsSync(dictDir)) {
+			if (!fs$1.existsSync(dictDir)) {
 				console.warn(`[ox-content:i18n] Dictionary directory not found: ${dictDir}`);
 				return;
 			}
@@ -7880,7 +10911,7 @@ function createI18nPlugin(resolvedOptions) {
 		configureServer(server) {
 			if (!i18nOptions) return;
 			const dictDir = path$2.resolve(root, i18nOptions.dir);
-			if (fs.existsSync(dictDir)) {
+			if (fs$1.existsSync(dictDir)) {
 				server.watcher.add(dictDir);
 				server.watcher.on("change", (filePath) => {
 					if (!filePath.startsWith(dictDir)) return;
@@ -7944,13 +10975,6 @@ function resolveCardOptions(options) {
 	return { enabled: options.enabled ?? true };
 }
 //#endregion
-//#region src/file-tree-options.ts
-function resolveFileTreeOptions(options) {
-	if (!options) return { enabled: false };
-	if (options === true) return { enabled: true };
-	return { enabled: options.enabled ?? true };
-}
-//#endregion
 //#region src/include-options.ts
 function resolveIncludeOptions(options) {
 	if (!options) return { enabled: false };
@@ -8071,6 +11095,353 @@ async function* renderMarkdownStream(chunks, options = {}) {
 	yield renderer.finish();
 }
 //#endregion
+//#region src/mdx-islands.ts
+/**
+* Discover registered MDX islands from the mdast tree or rendered HTML.
+*
+* Framework plugins use this instead of a source regex when MDX is on, so
+* nested JSX, expression attributes, and fragments stay visible. Names that
+* are not in the global `components` map and are not document-local import
+* bindings are left as static HTML.
+*/
+const OX_ISLAND_NAME = /data-ox-island="([^"]+)"/g;
+/**
+* Collect named MDX JSX tags from a parsed mdast tree (JSON from NAPI `parse()`).
+* Fragments (`name: null`) and non-JSX nodes are ignored. Walks nested children
+* so inner islands are found.
+*/
+function collectMdxJsxNamesFromAst(ast) {
+	const names = /* @__PURE__ */ new Set();
+	walkMdast(ast, names);
+	return [...names];
+}
+/**
+* Collect `data-ox-island` names from Rust-rendered HTML.
+* Used when an AST walk is unavailable.
+*/
+function collectMdxIslandNamesFromHtml(html) {
+	const names = /* @__PURE__ */ new Set();
+	OX_ISLAND_NAME.lastIndex = 0;
+	let match;
+	while ((match = OX_ISLAND_NAME.exec(html)) !== null) {
+		const name = match[1];
+		if (name) names.add(decodeHtmlAttr$1(name));
+	}
+	return [...names];
+}
+/** Keep names that exist on the global component map, in first-seen order. */
+function intersectRegisteredComponentNames(names, components) {
+	return intersectHydratableComponentNames(names, components);
+}
+/**
+* Keep names that are either globally registered or document-local bindings.
+*/
+function intersectHydratableComponentNames(names, components, localNames) {
+	const local = localNames ? new Set(localNames) : null;
+	const used = [];
+	for (const name of names) if ((local?.has(name) || isRegisteredComponent(name, components)) && !used.includes(name)) used.push(name);
+	return used;
+}
+/**
+* Resolve registered island names for an MDX document.
+*
+* Prefers a NAPI `parse()` AST walk. Falls back to rendered `data-ox-island`
+* names so plugins still hydrate if #659 metadata is not present.
+*/
+async function discoverRegisteredMdxComponents(input) {
+	return intersectHydratableComponentNames(await tryCollectNamesFromParse(input.source) ?? (input.html !== void 0 ? collectMdxIslandNamesFromHtml(input.html) : []), input.components, input.localNames);
+}
+function isRegisteredComponent(name, components) {
+	if (isMapRegistry$1(components)) return components.has(name);
+	if (isPlainObjectRegistry(components)) return Object.prototype.hasOwnProperty.call(components, name);
+	for (const entry of components) if (entry === name) return true;
+	return false;
+}
+async function tryCollectNamesFromParse(source) {
+	try {
+		const parsed = (await importNapiModule()).parse(source, {
+			mdx: true,
+			gfm: true
+		});
+		if (!parsed.ast) return null;
+		return collectMdxJsxNamesFromAst(JSON.parse(parsed.ast));
+	} catch {
+		return null;
+	}
+}
+function walkMdast(node, names) {
+	if (!node || typeof node !== "object") return;
+	const record = node;
+	if ((record.type === "mdxJsxFlowElement" || record.type === "mdxJsxTextElement") && typeof record.name === "string" && record.name) names.add(record.name);
+	if (Array.isArray(record.children)) for (const child of record.children) walkMdast(child, names);
+}
+function isMapRegistry$1(value) {
+	return typeof value === "object" && value !== null && typeof value.has === "function" && typeof value.get === "function";
+}
+function isPlainObjectRegistry(value) {
+	return Object.prototype.toString.call(value) === "[object Object]";
+}
+function decodeHtmlAttr$1(value) {
+	return value.replaceAll("&quot;", "\"").replaceAll("&#39;", "'").replaceAll("&lt;", "<").replaceAll("&gt;", ">").replaceAll("&amp;", "&");
+}
+//#endregion
+//#region src/document-imports.ts
+/**
+* Resolve MDX component imports relative to the document that declared them.
+*
+* Only `./` and `../` specifiers become island bindings. Bare, package, and
+* remote specifiers are reported and ignored. A specifier that leaves the
+* configured content root is rejected with a diagnostic.
+*/
+function resolveContentRootPath(input) {
+	if (input.contentRoot) return path.resolve(input.contentRoot);
+	const root = input.root ?? process.cwd();
+	return path.resolve(root, input.srcDir ?? ".");
+}
+function stripViteQuery(id) {
+	return id.split("?")[0].split("#")[0];
+}
+function resolveDocumentComponentImports(input) {
+	const documentPath = stripViteQuery(input.documentPath);
+	const documentDir = path.dirname(documentPath);
+	const contentRoot = resolveContentRootPath(input);
+	const diagnostics = [];
+	const candidates = [];
+	for (const statement of input.imports) {
+		const specifier = statement.source;
+		if (!isRelativeSpecifier(specifier)) {
+			diagnostics.push({
+				code: "not-relative",
+				message: `Document component import "${specifier}" is not relative and was ignored.`,
+				specifier
+			});
+			continue;
+		}
+		for (const spec of statement.specifiers) {
+			if (spec.kind === "namespace") continue;
+			const resolvedPath = resolveExistingPath(path.resolve(documentDir, specifier));
+			if (!isInsideRoot(resolvedPath, contentRoot)) {
+				diagnostics.push({
+					code: "escapes-root",
+					message: `Document component import "${specifier}" escapes the content root.`,
+					specifier,
+					localName: spec.local
+				});
+				continue;
+			}
+			candidates.push({
+				localName: spec.local,
+				specifier,
+				resolvedPath,
+				importPathRelativeToDocument: toDocumentRelativeImport(documentDir, resolvedPath),
+				imported: spec.imported,
+				kind: spec.kind
+			});
+		}
+	}
+	const counts = /* @__PURE__ */ new Map();
+	for (const binding of candidates) counts.set(binding.localName, (counts.get(binding.localName) ?? 0) + 1);
+	const bindings = [];
+	const reportedDuplicates = /* @__PURE__ */ new Set();
+	for (const binding of candidates) {
+		if ((counts.get(binding.localName) ?? 0) > 1) {
+			if (!reportedDuplicates.has(binding.localName)) {
+				reportedDuplicates.add(binding.localName);
+				diagnostics.push({
+					code: "duplicate-binding",
+					message: `Document component name "${binding.localName}" is imported more than once.`,
+					specifier: binding.specifier,
+					localName: binding.localName
+				});
+			}
+			continue;
+		}
+		bindings.push(binding);
+	}
+	return {
+		bindings,
+		diagnostics
+	};
+}
+function isRelativeSpecifier(source) {
+	return source.startsWith("./") || source.startsWith("../");
+}
+function resolveExistingPath(filePath) {
+	try {
+		return fs.realpathSync(filePath);
+	} catch {
+		return path.normalize(filePath);
+	}
+}
+function isInsideRoot(resolvedPath, root) {
+	const relative = path.relative(resolveExistingPath(root), resolvedPath);
+	return relative === "" || !relative.startsWith(`..${path.sep}`) && relative !== ".." && !path.isAbsolute(relative);
+}
+function toDocumentRelativeImport(documentDir, resolvedPath) {
+	const relative = path.relative(documentDir, resolvedPath).replace(/\\/g, "/");
+	return relative.startsWith(".") ? relative : `./${relative}`;
+}
+//#endregion
+//#region src/document-islands.ts
+/**
+* Combine document-local import resolution with MDX island discovery.
+*/
+async function discoverDocumentMdxIslands(input) {
+	const resolved = resolveDocumentComponentImports({
+		imports: input.imports,
+		documentPath: input.documentPath,
+		contentRoot: input.contentRoot ?? resolveContentRootPath(input),
+		srcDir: input.srcDir
+	});
+	const localBindings = new Map(resolved.bindings.map((binding) => [binding.localName, binding]));
+	return {
+		usedComponents: await discoverRegisteredMdxComponents({
+			source: input.source,
+			html: input.html,
+			components: input.components,
+			localNames: localBindings.keys()
+		}),
+		localBindings,
+		diagnostics: resolved.diagnostics
+	};
+}
+//#endregion
+//#region src/island-codegen.ts
+/**
+* Emit static component imports for framework Markdown modules.
+*
+* Document-local bindings win over the global `components` map for that file
+* only. Two documents that bind the same local name therefore emit different
+* specifiers and do not share one module id.
+*/
+function renderIslandComponentImports(usedComponents, input) {
+	const documentDir = path.dirname(stripViteQuery(input.documentPath));
+	const root = input.root || process.cwd();
+	return usedComponents.map((name) => {
+		const local = input.localBindings?.get(name);
+		if (local) return renderLocalImport(local);
+		const componentPath = getGlobalComponentPath(input.globalComponents, name);
+		if (!componentPath) return "";
+		return renderGlobalImport(name, componentPath, documentDir, root);
+	}).filter(Boolean).join("\n");
+}
+function renderLocalImport(binding) {
+	const specifier = binding.importPathRelativeToDocument.replace(/\\/g, "/");
+	if (binding.kind === "default") return `import ${binding.localName} from '${specifier}';`;
+	if (binding.imported === binding.localName) return `import { ${binding.imported} } from '${specifier}';`;
+	return `import { ${binding.imported} as ${binding.localName} } from '${specifier}';`;
+}
+function renderGlobalImport(name, componentPath, documentDir, root) {
+	const absolutePath = path.resolve(root, componentPath.replace(/^\.\//, ""));
+	const relativePath = path.relative(documentDir, absolutePath).replace(/\\/g, "/");
+	return `import ${name} from '${relativePath.startsWith(".") ? relativePath : `./${relativePath}`}';`;
+}
+function getGlobalComponentPath(components, name) {
+	if (isMapRegistry(components)) return components.get(name);
+	return Object.prototype.hasOwnProperty.call(components, name) ? components[name] : void 0;
+}
+function isMapRegistry(value) {
+	return typeof value === "object" && value !== null && typeof value.has === "function" && typeof value.get === "function";
+}
+//#endregion
+//#region src/island-ssr.ts
+const RUST_PAYLOAD_KEYS = /* @__PURE__ */ new Set([
+	"props",
+	"expressions",
+	"spreads"
+]);
+const PAYLOAD_SCRIPT = /^\s*<script type="application\/json">[\s\S]*?<\/script>/;
+async function applyIslandSsrHtml(html, renderIsland, filePath, names) {
+	const allowed = names ? new Set(names) : null;
+	const islands = findIslandRanges(html);
+	let output = html;
+	for (const island of islands.toReversed()) {
+		if (allowed && !allowed.has(island.name)) continue;
+		const script = output.slice(island.innerStart, island.closeStart).match(PAYLOAD_SCRIPT)?.[0] ?? "";
+		const props = parseIslandProps(island.propsAttr, script);
+		const ssrHtml = await renderIsland(island.name, props, filePath);
+		output = output.slice(0, island.innerStart) + script + ssrHtml + output.slice(island.closeStart);
+	}
+	return output;
+}
+function findIslandRanges(html) {
+	const ranges = [];
+	const openRe = /<(div|span)\b([^>]*\bdata-ox-island="([^"]+)"[^>]*)>/gi;
+	let match;
+	while ((match = openRe.exec(html)) !== null) {
+		const tag = match[1];
+		const name = decodeHtmlAttr(match[3] ?? "");
+		if (!tag || !name) continue;
+		const innerStart = match.index + match[0].length;
+		const closeStart = findMatchingClose(html, innerStart, tag);
+		ranges.push({
+			name,
+			innerStart,
+			closeStart,
+			propsAttr: matchAttr(match[2] ?? "", "data-ox-props")
+		});
+	}
+	return ranges;
+}
+function findMatchingClose(html, from, tag) {
+	const openNeedle = `<${tag}`;
+	const closeNeedle = `</${tag}>`;
+	let depth = 1;
+	let cursor = from;
+	while (cursor < html.length) {
+		const nextOpen = indexOfTagOpen(html, openNeedle, cursor);
+		const nextClose = html.indexOf(closeNeedle, cursor);
+		if (nextClose === -1) return html.length;
+		if (nextOpen !== -1 && nextOpen < nextClose) {
+			depth += 1;
+			cursor = nextOpen + openNeedle.length;
+		} else {
+			depth -= 1;
+			if (depth === 0) return nextClose;
+			cursor = nextClose + closeNeedle.length;
+		}
+	}
+	return html.length;
+}
+function indexOfTagOpen(html, openNeedle, from) {
+	let cursor = from;
+	while (cursor < html.length) {
+		const index = html.indexOf(openNeedle, cursor);
+		if (index === -1) return -1;
+		const next = html[index + openNeedle.length];
+		if (next === " " || next === ">" || next === "	" || next === "\n" || next === "/") return index;
+		cursor = index + openNeedle.length;
+	}
+	return -1;
+}
+function matchAttr(attrs, name) {
+	const match = new RegExp(`\\b${name}="([^"]*)"`, "i").exec(attrs);
+	return match?.[1] === void 0 ? void 0 : decodeHtmlAttr(match[1]);
+}
+function parseIslandProps(propsAttr, script) {
+	const fromAttr = propsAttr ? tryParseJson(propsAttr) : void 0;
+	if (fromAttr) return unwrapIslandProps(fromAttr);
+	const scriptBody = script.match(/<script type="application\/json">([\s\S]*?)<\/script>/i)?.[1];
+	return scriptBody ? unwrapIslandProps(tryParseJson(scriptBody) ?? {}) : {};
+}
+function tryParseJson(value) {
+	try {
+		return JSON.parse(value);
+	} catch {
+		return;
+	}
+}
+function unwrapIslandProps(parsed) {
+	if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return {};
+	const record = parsed;
+	const keys = Object.keys(record);
+	if (keys.length > 0 && keys.every((key) => RUST_PAYLOAD_KEYS.has(key)) && record.props && typeof record.props === "object" && !Array.isArray(record.props)) return record.props;
+	return record;
+}
+function decodeHtmlAttr(value) {
+	return value.replaceAll("&quot;", "\"").replaceAll("&#39;", "'").replaceAll("&lt;", "<").replaceAll("&gt;", ">").replaceAll("&amp;", "&");
+}
+//#endregion
 //#region src/framework.ts
 function createFrameworkMarkdownOptions(options) {
 	return {
@@ -8087,6 +11458,7 @@ function createFrameworkMarkdownOptions(options) {
 			lastUpdated: false,
 			pagination: false,
 			breadcrumbs: false,
+			jsonLd: false,
 			readerChrome: false,
 			localeSwitcher: false,
 			a11y: false,
@@ -8097,6 +11469,10 @@ function createFrameworkMarkdownOptions(options) {
 			robots: true,
 			llms: true
 		},
+		pwa: {
+			enabled: false,
+			offline: true
+		},
 		publishState: {
 			enabled: false,
 			includeDrafts: false
@@ -8112,6 +11488,7 @@ function createFrameworkMarkdownOptions(options) {
 			allowExternal: false
 		},
 		gfm: options.gfm,
+		mdx: options.mdx,
 		frontmatter: options.frontmatter ?? false,
 		toc: options.toc,
 		tocMaxDepth: options.tocMaxDepth,
@@ -8184,7 +11561,11 @@ function createFrameworkMarkdownOptions(options) {
 		includes: { enabled: false },
 		cards: { enabled: false },
 		steps: { enabled: false },
-		fileTree: { enabled: false },
+		fileTree: {
+			enabled: false,
+			defaultOpen: true,
+			icons: true
+		},
 		sanitize: { enabled: false },
 		editThisPage: {
 			enabled: false,
@@ -8282,7 +11663,7 @@ async function collectMarkdownDocsTests(options, cwd) {
 	const blocks = [];
 	let index = 0;
 	for (const [sourcePath, relativePath] of [...files.entries()].sort((left, right) => left[0].localeCompare(right[0]))) {
-		const extracted = await extractDocsTests(await fs$1.readFile(sourcePath, "utf-8"), {
+		const extracted = await extractDocsTests(await fs$2.readFile(sourcePath, "utf-8"), {
 			languages: options.languages,
 			requireMeta: options.requireMeta
 		});
@@ -8368,18 +11749,18 @@ async function writeDocsTestFiles(options) {
 		...options,
 		cwd
 	});
-	if (clean) await fs$1.rm(generatedDir, {
+	if (clean) await fs$2.rm(generatedDir, {
 		recursive: true,
 		force: true
 	});
-	await fs$1.mkdir(generatedDir, { recursive: true });
+	await fs$2.mkdir(generatedDir, { recursive: true });
 	return {
 		cwd,
 		generatedDir,
 		blocks,
 		files: await Promise.all(blocks.map(async (block) => {
 			const filePath = path$1.join(generatedDir, docsTestFileName(block));
-			await fs$1.writeFile(filePath, renderDocsTestFile(block, options), "utf-8");
+			await fs$2.writeFile(filePath, renderDocsTestFile(block, options), "utf-8");
 			return {
 				filePath,
 				sourcePath: block.sourcePath,
@@ -8864,7 +12245,7 @@ async function lintMarkdownFile(filePath, options = {}) {
 async function lintMarkdownFiles(options = {}) {
 	const resolvedOptions = resolveMarkdownLintFileOptions(options);
 	const matchedFiles = await collectMarkdownLintFileEntries(resolvedOptions);
-	const results = await lintMatchedMarkdownFiles(matchedFiles, await Promise.all(matchedFiles.map((file) => fs$1.readFile(file.filePath, "utf-8"))), resolvedOptions.lintOptions);
+	const results = await lintMatchedMarkdownFiles(matchedFiles, await Promise.all(matchedFiles.map((file) => fs$2.readFile(file.filePath, "utf-8"))), resolvedOptions.lintOptions);
 	const files = matchedFiles.map((file, index) => ({
 		...results[index] ?? createEmptyLintResult(),
 		filePath: file.filePath,
@@ -8908,7 +12289,7 @@ async function lintMarkdownFileWithResolvedOptions(filePath, options) {
 		skipped: true
 	};
 	return {
-		...await lintMarkdownAsync(await fs$1.readFile(absoluteFilePath, "utf-8"), {
+		...await lintMarkdownAsync(await fs$2.readFile(absoluteFilePath, "utf-8"), {
 			...options.lintOptions,
 			mdx: resolveMdxForFilePath(absoluteFilePath, options.lintOptions.mdx)
 		}),
@@ -9019,6 +12400,7 @@ function oxContent(options = {}) {
 		createCollectionsPlugin(resolvedOptions, getRoot),
 		createSearchPlugin(resolvedOptions, getRoot)
 	];
+	if (resolvedOptions.math.enabled) plugins.push(createKatexAssetsPlugin());
 	if (resolvedOptions.i18n) plugins.push(createI18nPlugin(resolvedOptions));
 	if (resolvedOptions.ogViewer) plugins.push(createOgViewerPlugin(resolvedOptions));
 	return plugins;
@@ -9166,6 +12548,7 @@ function createSsgPlugin(resolvedOptions, getRoot, ssgDevCache) {
 				for (const error of result.errors) console.warn(`[ox-content] ${error}`);
 			} catch (err) {
 				console.error("[ox-content] SSG build failed:", err);
+				if (err instanceof PageResourceError) throw err;
 			}
 		}
 	};
@@ -9271,9 +12654,12 @@ function resolveOptions(options) {
 		permalinks: resolvePermalinksOptions(options.permalinks),
 		cascade: resolveCascadeOptions(options.cascade),
 		redirects: resolveRedirectsOptions(options.redirects),
+		blog: resolveBlogOptions(options.blog ?? (typeof options.ssg === "object" && options.ssg ? options.ssg.blog : void 0)),
 		feeds: resolveFeedsOptions(options.feeds),
+		pwa: resolvePwaOptions(options.pwa),
 		taxonomies: resolveTaxonomiesOptions(options.taxonomies),
 		versions: resolveVersionsOptions(options.versions),
+		resources: resolveResourcesOptions(options.resources),
 		gfm: options.gfm ?? true,
 		mdx: options.mdx,
 		footnotes: options.footnotes ?? true,
@@ -9299,6 +12685,7 @@ function resolveOptions(options) {
 		cjkEmphasis: options.cjkEmphasis ?? false,
 		codeBlockLint: resolveCodeBlockLintOptions(options.codeBlockLint),
 		codeBlockTypecheck: resolveCodeBlockTypecheckOptions(options.codeBlockTypecheck),
+		typedHover: resolveTypedHoverOptions(options.typedHover),
 		docsTests: resolveDocsTestOptions(options.docsTests),
 		mermaid: options.mermaid ?? false,
 		math: resolveMathOptions(options.math),
@@ -9595,6 +12982,6 @@ function normalizeRuntimeBase(base) {
 	return withLeading.endsWith("/") ? withLeading : `${withLeading}/`;
 }
 //#endregion
-export { DEFAULT_HTML_TEMPLATE, DEFAULT_MARKDOWN_EXTENSIONS, DefaultTheme, DocsTestRunError, Fragment, IncrementalMarkdownParser, IncrementalMarkdownRenderer, buildCollectionManifest, buildSearchIndex, buildSsg, classifyPublishState, clearRenderContext, collectDocsTests, collectGitHubRepos, collectGitHubSources, collectOgpUrls, convertVitePressNav, convertVitePressSidebar, createFrameworkMarkdownOptions, createI18nPlugin, createIncrementalMarkdownParser, createIncrementalMarkdownRenderer, createMarkdownEnvironment, createTheme, defaultTheme, defineCollection, defineCollections, defineTheme, each, escapeSvelteMarkup, extractCodeBlocks, extractDocs, extractDocsTests, extractIslandInfo, extractVideoId, fetchGitHubSource, fetchOgpData, fetchRepoData, fromVitePressConfig, generateCollectionsVirtualModule, generateFrontmatterTypes, generateHydrationScript, generateMarkdown, generateOgImages, generateTabsCSS, generateTypes, generateVirtualModule, generateVitePressMigrationConfig, hasIslands, inferType, isMarkdownFilePath, jsx, jsxs, lintCodeBlocks, lintMarkdown, lintMarkdownAsync, lintMarkdownFile, lintMarkdownFiles, mergeThemes, mermaidClientScript, normalizeMarkdownExtensions, normalizeVitePressFrontmatter, oxContent, parseGitHubLineRange, parseGitHubPermalink, parsePageChromeFlags, partitionPublishedPages, prefetchGitHubRepos, prefetchGitHubSources, prefetchOgpData, raw, renderAllPages, renderHtmlToFrameworkCode, renderHtmlToReactComponent, renderHtmlToReactCreateElement, renderHtmlToSvelteComponent, renderHtmlToVueComponent, renderHtmlToVueH, renderMarkdownStream, renderPage, renderToString, resolveBadgeOptions, resolveBuiltinEmbedOptions, resolveCardOptions, resolveCascadeOptions, resolveCollectionsOptions, resolveDocsOptions, resolveFeedsOptions, resolveFileTreeOptions, resolveHeaderNavItems, resolveI18nOptions, resolveImageOptions, resolveIncludeOptions, resolveLocaleLabel, resolveMathOptions, resolveNotFoundOptions, resolveOgImageOptions, resolvePageChromeOption, resolvePermalinksOptions, resolvePublishStateOptions, resolveRedirectsOptions, resolveSearchOptions, resolveSiteMapsOptions, resolveSsgOptions, resolveStepsOptions, resolveTaxonomiesOptions, resolveTeamOptions, resolveTheme, resolveVersionsOptions, runDocsTests, setRenderContext, shouldLintMarkdownFile, stripMarkdownExtension, transformAllPlugins, transformGitHub, transformIslands, transformMarkdown, transformMermaidStatic, transformOgp, transformTabs, transformYouTube, typecheckCodeBlocks, useIsActive, useNav, usePageProps, useRenderContext, useSiteConfig, when, writeDocs, writeDocsTestFiles, writeSearchIndex };
+export { DEFAULT_HTML_TEMPLATE, DEFAULT_MARKDOWN_EXTENSIONS, DefaultTheme, DocsTestRunError, Fragment, IncrementalMarkdownParser, IncrementalMarkdownRenderer, PageResourceError, applyIslandSsrHtml, buildCollectionManifest, buildSearchIndex, buildSsg, classifyPublishState, clearRenderContext, collectDocsTests, collectGitHubRepos, collectGitHubSources, collectMdxIslandNamesFromHtml, collectMdxJsxNamesFromAst, collectOgpUrls, convertVitePressNav, convertVitePressSidebar, createFrameworkMarkdownOptions, createI18nPlugin, createIncrementalMarkdownParser, createIncrementalMarkdownRenderer, createMarkdownEnvironment, createTheme, defaultTheme, defineCollection, defineCollections, defineTheme, discoverDocumentMdxIslands, discoverRegisteredMdxComponents, each, escapeSvelteMarkup, extractCodeBlocks, extractDocs, extractDocsTests, extractIslandInfo, extractVideoId, fetchGitHubSource, fetchOgpData, fetchRepoData, fromVitePressConfig, generateCollectionsVirtualModule, generateFrontmatterTypes, generateHydrationScript, generateMarkdown, generateOgImages, generateTabsCSS, generateTypes, generateVirtualModule, generateVitePressMigrationConfig, hasIslands, inferType, intersectHydratableComponentNames, intersectRegisteredComponentNames, isMarkdownFilePath, isMdxFilePath, isRegisteredComponent, jsx, jsxs, lintCodeBlocks, lintMarkdown, lintMarkdownAsync, lintMarkdownFile, lintMarkdownFiles, mergeThemes, mermaidClientScript, normalizeMarkdownExtensions, normalizeVitePressFrontmatter, oxContent, parseGitHubLineRange, parseGitHubPermalink, parsePageChromeFlags, partitionPublishedPages, prefetchGitHubRepos, prefetchGitHubSources, prefetchOgpData, raw, readingTimeMinutes, renderAllPages, renderHtmlToFrameworkCode, renderHtmlToReactComponent, renderHtmlToReactCreateElement, renderHtmlToSvelteComponent, renderHtmlToVueComponent, renderHtmlToVueH, renderIslandComponentImports, renderMarkdownStream, renderPage, renderToString, resolveBadgeOptions, resolveBlogCollectionName, resolveBlogOptions, resolveBuiltinEmbedOptions, resolveCardOptions, resolveCascadeOptions, resolveCollectionsOptions, resolveContentRootPath, resolveDocsOptions, resolveDocumentComponentImports, resolveFeedsOptions, resolveFileTreeOptions, resolveHeaderNavItems, resolveI18nOptions, resolveImageOptions, resolveIncludeOptions, resolveLocaleLabel, resolveMathOptions, resolveMdxForFilePath, resolveNotFoundOptions, resolveOgImageOptions, resolvePageChromeOption, resolvePermalinksOptions, resolvePublishStateOptions, resolvePwaOptions, resolveRedirectsOptions, resolveResourcesOptions, resolveSearchOptions, resolveSectionIndexOptions, resolveSiteMapsOptions, resolveSsgOptions, resolveStepsOptions, resolveTaxonomiesOptions, resolveTeamOptions, resolveTheme, resolveTypedHoverOptions, resolveVersionsOptions, runDocsTests, setRenderContext, shouldLintMarkdownFile, stripMarkdownExtension, stripViteQuery, transformAllPlugins, transformGitHub, transformIslands, transformMarkdown, transformMermaidStatic, transformOgp, transformTabs, transformYouTube, typecheckCodeBlocks, useIsActive, useNav, usePageProps, useRenderContext, useSiteConfig, when, writeDocs, writeDocsTestFiles, writeSearchIndex };
 
 //# sourceMappingURL=index.mjs.map