@ox-content/vite-plugin 2.16.0 → 2.25.0

package/dist/index.cjs

@@ -1,5 +1,6 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const require_chunk = require("./chunk.cjs");
+const require_napi = require("./napi.cjs");
 const require_mermaid = require("./mermaid.cjs");
 const require_tabs = require("./tabs.cjs");
 const require_youtube = require("./youtube.cjs");
@@ -17,12 +18,12 @@ let shiki = require("shiki");
 let node_module = require("node:module");
 let node_path = require("node:path");
 node_path = require_chunk.__toESM(node_path, 1);
-let fs = require("fs");
-fs = require_chunk.__toESM(fs, 1);
 let fs_promises = require("fs/promises");
 fs_promises = require_chunk.__toESM(fs_promises, 1);
 let crypto = require("crypto");
 crypto = require_chunk.__toESM(crypto, 1);
+let fs = require("fs");
+fs = require_chunk.__toESM(fs, 1);
 let glob = require("glob");
 let node_fs_promises = require("node:fs/promises");
 node_fs_promises = require_chunk.__toESM(node_fs_promises, 1);
@@ -432,7 +433,7 @@ async function loadNapiBindings() {
 	if (napiLoadAttempted) return napiBindings ?? null;
 	napiLoadAttempted = true;
 	try {
-		const mod = await require_mermaid.importNapiModule();
+		const mod = await require_napi.importNapiModule();
 		napiBindings = mod;
 		return mod;
 	} catch (error) {
@@ -545,67 +546,7 @@ if (import.meta.hot) {
 `;
 }
 //#endregion
-//#region src/nav-generator.ts
-function generateNavMetadata(docs, basePath = "/api") {
-	return require_mermaid.importNapiModuleSync().generateDocsNavMetadata(docs.map((doc) => doc.file), basePath);
-}
-function generateNavCode(navItems, exportName = "apiNav") {
-	return require_mermaid.importNapiModuleSync().generateDocsNavCode(navItems, exportName);
-}
-//#endregion
 //#region src/docs.ts
-/**
-* Source Documentation Extraction and Generation
-*
-* This module provides comprehensive tools for extracting JSDoc/TSDoc comments
-* from TypeScript/JavaScript source files and automatically generating Markdown
-* documentation.
-*
-* ## Features
-*
-* - **Automatic Extraction**: Parses JSDoc comments from functions, classes, interfaces, and types
-* - **Flexible Filtering**: Include/exclude patterns for selective documentation
-* - **Markdown Generation**: Converts extracted docs to organized Markdown files
-* - **Navigation Generation**: Auto-generates sidebar navigation metadata
-* - **GitHub Links**: Includes clickable links to source code on GitHub
-*
-* ## Supported JSDoc Tags
-*
-* - `@param {type} name - description` - Function parameter documentation
-* - `@returns {type} description` - Return value documentation
-* - `@example` - Code examples (multi-line blocks)
-* - `@private` - Mark item as private (excluded from docs if private=false)
-* - `@default value` - Default parameter value
-* - Custom tags are preserved in the `tags` field
-*
-* ## Usage Flow
-*
-* 1. Call `extractDocs()` to parse source files
-* 2. Call `generateMarkdown()` to create Markdown content
-* 3. Call `writeDocs()` to write files to output directory
-* 4. Generated nav.ts can be imported for sidebar navigation
-*
-* @example
-* ```typescript
-* import { extractDocs, generateMarkdown, writeDocs } from './docs';
-*
-* const docsOptions = {
-*   enabled: true,
-*   src: ['./src'],
-*   out: './docs/api',
-*   include: ['**\/*.ts'],
-*   exclude: ['**\/*.test.ts'],
-*   groupBy: 'file',
-*   githubUrl: 'https://github.com/user/project',
-* };
-*
-* const extracted = await extractDocs(['./src'], docsOptions);
-* const markdown = generateMarkdown(extracted, docsOptions);
-* await writeDocs(markdown, './docs/api', extracted, docsOptions);
-* ```
-*/
-const DOCS_MANIFEST_FILE = ".ox-content-docs-manifest.json";
-const DOCS_DATA_FILE = "docs.json";
 const DEFAULT_DOCS_INCLUDE = [
 	"**/*.ts",
 	"**/*.tsx",
@@ -682,7 +623,7 @@ const DEFAULT_DOCS_INCLUDE = [
 * ```
 */
 async function extractDocs(srcDirs, options) {
-	const napi = await require_mermaid.importNapiModule();
+	const napi = await require_napi.importNapiModule();
 	if (options.entryPoints?.length) {
 		const extractDocsFromEntryPoints = napi.extractDocsFromEntryPoints;
 		if (!extractDocsFromEntryPoints) throw new Error("[ox-content] extractDocsFromEntryPoints is not available from @ox-content/napi.");
@@ -695,65 +636,40 @@ async function extractDocs(srcDirs, options) {
 			entries: doc.entries
 		}));
 	}
-	const extractFileDocEntries = napi.extractFileDocEntries;
-	if (!extractFileDocEntries) throw new Error("[ox-content] extractFileDocEntries is not available from @ox-content/napi.");
-	const results = [];
-	for (const srcDir of srcDirs) {
-		const files = napi.collectDocsSourceFiles(srcDir, options.include, options.exclude);
-		for (const file of files) {
-			const entries = extractFileDocEntries(file, options.private, options.internal);
-			if (entries.length > 0) results.push({
-				file,
-				entries
-			});
-		}
-	}
-	return results;
+	const extractDocsFromDirectories = napi.extractDocsFromDirectories;
+	if (!extractDocsFromDirectories) throw new Error("[ox-content] extractDocsFromDirectories is not available from @ox-content/napi.");
+	return extractDocsFromDirectories(srcDirs, options.include, options.exclude, options.private, options.internal).map((doc) => ({
+		file: doc.file,
+		entries: doc.entries
+	}));
 }
 /**
 * Generates Markdown documentation from extracted docs.
 */
 function generateMarkdown(docs, options) {
-	const napi = require_mermaid.importNapiModuleSync();
+	const napi = require_napi.importNapiModuleSync();
 	if (typeof napi.generateDocsMarkdown !== "function") throw new Error("[ox-content] generateDocsMarkdown is not available from @ox-content/napi. Please rebuild the NAPI package.");
 	return napi.generateDocsMarkdown(toRustDocsModules(docs), {
 		groupBy: options.groupBy,
-		githubUrl: options.githubUrl
+		githubUrl: options.githubUrl,
+		linkStyle: options.linkStyle,
+		basePath: options.basePath,
+		pathStrategy: options.pathStrategy
 	});
 }
 /**
 * Writes generated documentation to the output directory.
 */
 async function writeDocs(docs, outDir, extractedDocs, options) {
-	await fs.promises.mkdir(outDir, { recursive: true });
-	const generatedFiles = new Set(Object.keys(docs));
-	if (extractedDocs && options?.generateNav && options.groupBy === "file") generatedFiles.add("nav.ts");
-	if (extractedDocs) generatedFiles.add(DOCS_DATA_FILE);
-	const manifestPath = path.join(outDir, DOCS_MANIFEST_FILE);
-	let previousFiles = [];
-	try {
-		previousFiles = JSON.parse(await fs.promises.readFile(manifestPath, "utf-8"));
-	} catch {
-		previousFiles = [];
-	}
-	for (const staleFile of previousFiles) {
-		if (generatedFiles.has(staleFile)) continue;
-		await fs.promises.rm(path.join(outDir, staleFile), { force: true });
-	}
-	for (const [fileName, content] of Object.entries(docs)) {
-		const filePath = path.join(outDir, fileName);
-		await fs.promises.writeFile(filePath, content, "utf-8");
-	}
-	if (extractedDocs && options?.generateNav && options.groupBy === "file") {
-		const navCode = generateNavCode(generateNavMetadata(extractedDocs, "/api"), "apiNav");
-		const navFilePath = path.join(outDir, "nav.ts");
-		await fs.promises.writeFile(navFilePath, navCode, "utf-8");
-	}
-	if (extractedDocs) {
-		const napi = require_mermaid.importNapiModuleSync();
-		await fs.promises.writeFile(path.join(outDir, DOCS_DATA_FILE), napi.generateDocsDataJson(toRustDocsModules(extractedDocs), (/* @__PURE__ */ new Date()).toISOString()), "utf-8");
-	}
-	await fs.promises.writeFile(manifestPath, JSON.stringify([...generatedFiles].sort(), null, 2), "utf-8");
+	const napi = require_napi.importNapiModuleSync();
+	if (typeof napi.writeGeneratedDocs !== "function") throw new Error("[ox-content] writeGeneratedDocs is not available from @ox-content/napi. Please rebuild the NAPI package.");
+	napi.writeGeneratedDocs(docs, outDir, extractedDocs ? toRustDocsModules(extractedDocs) : void 0, {
+		generateNav: options?.generateNav ?? false,
+		groupBy: options?.groupBy ?? "file",
+		generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+		basePath: options?.basePath,
+		pathStrategy: options?.pathStrategy
+	});
 }
 function toRustDocsModules(docs) {
 	return docs.map((doc) => ({
@@ -778,9 +694,6 @@ function toRustDocsModules(docs) {
 		}))
 	}));
 }
-/**
-* Resolves docs options with defaults.
-*/
 function resolveDocsOptions(options) {
 	if (options === false) return false;
 	const opts = options || {};
@@ -801,6 +714,9 @@ function resolveDocsOptions(options) {
 		toc: false,
 		groupBy: opts.groupBy ?? "file",
 		githubUrl: opts.githubUrl,
+		linkStyle: opts.linkStyle ?? "markdown",
+		basePath: opts.basePath,
+		pathStrategy: opts.pathStrategy ?? "flat",
 		generateNav: opts.generateNav ?? true
 	};
 }
@@ -888,6 +804,8 @@ async function renderHtmlToPng(page, html, width, height, publicDir) {
 }
 //#endregion
 //#region src/og-image/browser.ts
+const PLAYWRIGHT_BROWSER_INSTALL_HINT = "Install Playwright browsers with `npx playwright install chromium` to enable OG image generation.";
+let chromiumUnavailableWarned = false;
 /**
 * Opens a Chromium browser and returns a session for rendering OG images.
 * Returns null if Playwright/Chromium is not available.
@@ -927,10 +845,20 @@ async function openBrowser() {
 			}
 		};
 	} catch (err) {
-		console.warn("[ox-content:og-image] Chromium not available, skipping OG image generation.", err instanceof Error ? err.message : err);
+		warnChromiumUnavailableOnce(err);
 		return null;
 	}
 }
+function warnChromiumUnavailableOnce(err) {
+	if (chromiumUnavailableWarned) return;
+	chromiumUnavailableWarned = true;
+	console.warn(`[ox-content:og-image] Chromium not available, skipping OG image generation. ${formatChromiumUnavailableDetail(err)}`);
+}
+function formatChromiumUnavailableDetail(err) {
+	const message = err instanceof Error ? err.message : String(err);
+	if (message.includes("Executable doesn't exist") || message.includes("Please run the following command to download new browsers")) return PLAYWRIGHT_BROWSER_INSTALL_HINT;
+	return message.split(/\r?\n/).find((line) => line.trim())?.trim() ?? "Unknown launch error.";
+}
 //#endregion
 //#region src/og-image/template.ts
 /**
@@ -1732,19 +1660,19 @@ function resolveSsgOptions(ssg) {
 * Extracts title from content or frontmatter.
 */
 function extractTitle$1(content, frontmatter) {
-	return require_mermaid.importNapiModuleSync().extractSsgTitle(content, typeof frontmatter.title === "string" ? frontmatter.title : void 0);
+	return require_napi.importNapiModuleSync().extractSsgTitle(content, typeof frontmatter.title === "string" ? frontmatter.title : void 0);
 }
 /**
 * Generates bare HTML page (no navigation, no styles).
 */
 function generateBareHtmlPage(content, title) {
-	return require_mermaid.importNapiModuleSync().generateSsgBareHtml(content, title);
+	return require_napi.importNapiModuleSync().generateSsgBareHtml(content, title);
 }
 /**
 * Generates HTML page with navigation using Rust NAPI bindings.
 */
 async function generateHtmlPage(pageData, navGroups, siteName, base, ogImage, theme, locale, availableLocales) {
-	const mod = await require_mermaid.importNapiModule();
+	const mod = await require_napi.importNapiModule();
 	const toRustTocEntry = (entry) => ({
 		depth: entry.depth,
 		text: entry.text,
@@ -1818,7 +1746,7 @@ async function generateHtmlPage(pageData, navGroups, siteName, base, ogImage, th
 	});
 }
 async function externalizeSharedPageAssets(pages, outDir, base) {
-	const optimized = (await require_mermaid.importNapiModule()).externalizeSsgAssets(pages, outDir, base);
+	const optimized = (await require_napi.importNapiModule()).externalizeSsgAssets(pages, outDir, base);
 	await Promise.all(optimized.assets.map(async (asset) => {
 		await fs_promises.mkdir(path.dirname(asset.outputPath), { recursive: true });
 		await fs_promises.writeFile(asset.outputPath, asset.content, "utf-8");
@@ -1832,45 +1760,45 @@ async function externalizeSharedPageAssets(pages, outDir, base) {
 * Converts a markdown file path to a relative URL path.
 */
 function getUrlPath$1(inputPath, srcDir) {
-	return require_mermaid.importNapiModuleSync().getSsgUrlPath(inputPath, srcDir);
+	return require_napi.importNapiModuleSync().getSsgUrlPath(inputPath, srcDir);
 }
 /**
 * Resolves manual navigation config to the format used by the built-in SSG renderer.
 */
 function resolveNavigationGroups(navigation, base, extension) {
 	if (!navigation) return;
-	return require_mermaid.importNapiModuleSync().resolveSsgNavigationGroups(navigation, base, extension);
+	return require_napi.importNapiModuleSync().resolveSsgNavigationGroups(navigation, base, extension);
 }
 function getPageLocale(urlPath, i18n) {
 	if (!i18n) return void 0;
-	return require_mermaid.importNapiModuleSync().getSsgPageLocale(urlPath, i18n.defaultLocale, i18n.locales.map((locale) => locale.code)) ?? void 0;
+	return require_napi.importNapiModuleSync().getSsgPageLocale(urlPath, i18n.defaultLocale, i18n.locales.map((locale) => locale.code)) ?? void 0;
 }
 function getRoutePaths(inputPath, srcDir, outDir, base, extension, siteUrl) {
-	return require_mermaid.importNapiModuleSync().resolveSsgRoutePaths(inputPath, srcDir, outDir, base, extension, siteUrl);
+	return require_napi.importNapiModuleSync().resolveSsgRoutePaths(inputPath, srcDir, outDir, base, extension, siteUrl);
 }
 /**
 * Formats a file/dir name as a title.
 */
 function formatTitle(name) {
-	return require_mermaid.importNapiModuleSync().formatSsgTitle(name);
+	return require_napi.importNapiModuleSync().formatSsgTitle(name);
 }
 /**
 * Collects all markdown files from the source directory.
 */
 async function collectMarkdownFiles(srcDir, extensions = DEFAULT_MARKDOWN_EXTENSIONS) {
-	return require_mermaid.importNapiModuleSync().collectSsgMarkdownFiles(srcDir, [...extensions]);
+	return require_napi.importNapiModuleSync().collectSsgMarkdownFiles(srcDir, [...extensions]);
 }
 /**
 * Builds navigation items from markdown files, grouped by directory.
 */
 function buildNavItems(markdownFiles, srcDir, base, extension) {
-	return require_mermaid.importNapiModuleSync().buildSsgNavItems(markdownFiles, srcDir, base, extension);
+	return require_napi.importNapiModuleSync().buildSsgNavItems(markdownFiles, srcDir, base, extension);
 }
 /**
 * Builds navigation items from an explicit theme sidebar tree.
 */
 function buildThemeNavItems(sidebar, base, extension) {
-	return require_mermaid.importNapiModuleSync().buildSsgThemeNavItems(sidebar, base, extension);
+	return require_napi.importNapiModuleSync().buildSsgThemeNavItems(sidebar, base, extension);
 }
 /**
 * Builds all markdown files to static HTML.
@@ -1883,149 +1811,201 @@ async function buildSsg(options, root) {
 	};
 	const srcDir = path.resolve(root, options.srcDir);
 	const outDir = path.resolve(root, options.outDir);
-	const base = options.base.endsWith("/") ? options.base : options.base + "/";
 	const generatedFiles = [];
-	const generatedPages = [];
 	const errors = [];
-	if (ssgOptions.clean) try {
+	await cleanOutputDirectory(ssgOptions, outDir);
+	const markdownFiles = await collectMarkdownFiles(srcDir, options.extensions);
+	const context = await createBuildSsgContext(options, root, srcDir, outDir, markdownFiles);
+	const collected = await collectPageResults(context, markdownFiles);
+	errors.push(...collected.errors);
+	await generateOgImageAssets(context, collected, generatedFiles, errors);
+	await writeGeneratedPages(await generateHtmlPages(context, collected.pageResults, collected, errors), context, generatedFiles);
+	return {
+		files: generatedFiles,
+		errors
+	};
+}
+async function cleanOutputDirectory(ssgOptions, outDir) {
+	if (!ssgOptions.clean) return;
+	try {
 		await fs_promises.rm(outDir, {
 			recursive: true,
 			force: true
 		});
 	} catch {}
-	const markdownFiles = await collectMarkdownFiles(srcDir, options.extensions);
-	const navItems = resolveNavigationGroups(ssgOptions.navigation, base, ssgOptions.extension) ?? (ssgOptions.theme?.sidebar.length ? buildThemeNavItems(ssgOptions.theme.sidebar, base, ssgOptions.extension) : buildNavItems(markdownFiles, srcDir, base, ssgOptions.extension));
-	let siteName = ssgOptions.siteName ?? "Documentation";
-	if (!ssgOptions.siteName) try {
+}
+async function createBuildSsgContext(options, root, srcDir, outDir, markdownFiles) {
+	const ssgOptions = options.ssg;
+	const base = options.base.endsWith("/") ? options.base : options.base + "/";
+	return {
+		options,
+		ssgOptions,
+		root,
+		srcDir,
+		outDir,
+		base,
+		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: (options.ogImage || ssgOptions.generateOgImage) && !ssgOptions.bare,
+		napi: ssgOptions.lastUpdated ? await require_napi.importNapiModule() : void 0
+	};
+}
+async function resolveSiteName$1(root, ssgOptions) {
+	if (ssgOptions.siteName) return ssgOptions.siteName;
+	try {
 		const pkgPath = path.join(root, "package.json");
 		const pkg = JSON.parse(await fs_promises.readFile(pkgPath, "utf-8"));
-		if (pkg.name) siteName = formatTitle(pkg.name);
-	} catch {}
-	const ogImageEntries = [];
-	const ogImageInputPaths = [];
-	const ogImageUrlMap = /* @__PURE__ */ new Map();
-	const shouldGenerateOgImages = (options.ogImage || ssgOptions.generateOgImage) && !ssgOptions.bare;
-	const pageResults = [];
-	const napi = ssgOptions.lastUpdated ? await require_mermaid.importNapiModule() : void 0;
+		return pkg.name ? formatTitle(pkg.name) : "Documentation";
+	} catch {
+		return "Documentation";
+	}
+}
+async function collectPageResults(context, markdownFiles) {
+	const collected = {
+		pageResults: [],
+		ogImageEntries: [],
+		ogImageInputPaths: [],
+		ogImageUrlMap: /* @__PURE__ */ new Map(),
+		errors: []
+	};
 	for (const inputPath of markdownFiles) try {
-		const result = await transformMarkdown(await fs_promises.readFile(inputPath, "utf-8"), inputPath, options, {
-			convertMdLinks: true,
-			baseUrl: base,
-			sourcePath: inputPath
-		});
-		const frontmatter = require_vitepress.normalizeVitePressFrontmatter(result.frontmatter);
-		let transformedHtml = result.html;
-		const { html: protectedHtml, svgs: mermaidSvgs } = protectMermaidSvgs(transformedHtml);
-		transformedHtml = protectedHtml;
-		const pluginOptions = {
-			tabs: true,
-			youtube: true,
-			github: options.embeds.github,
-			openGraph: options.embeds.openGraph,
-			mermaid: true,
-			githubToken: process.env.GITHUB_TOKEN
-		};
-		transformedHtml = await transformAllPlugins(transformedHtml, pluginOptions);
-		if (hasIslands(transformedHtml)) transformedHtml = (await transformIslands(transformedHtml)).html;
-		transformedHtml = restoreMermaidSvgs(transformedHtml, mermaidSvgs);
-		const title = extractTitle$1(transformedHtml, frontmatter);
-		const description = frontmatter.description;
-		const routePaths = getRoutePaths(inputPath, srcDir, outDir, base, ssgOptions.extension, ssgOptions.siteUrl);
-		pageResults.push({
-			inputPath,
-			routePaths,
-			transformedHtml,
-			title,
-			description,
-			lastUpdated: napi?.getGitLastUpdated(inputPath, root) ?? void 0,
-			frontmatter,
-			toc: result.toc
-		});
-		if (shouldGenerateOgImages) {
-			const { layout: _layout, ...frontmatterRest } = frontmatter;
-			ogImageEntries.push({
-				props: {
-					...frontmatterRest,
-					title,
-					description,
-					siteName
-				},
-				outputPath: routePaths.ogImagePath
-			});
-			ogImageInputPaths.push(inputPath);
-			ogImageUrlMap.set(inputPath, routePaths.ogImageUrl);
-		}
+		const pageResult = await transformSsgPage(context, inputPath);
+		collected.pageResults.push(pageResult);
+		collectOgImageEntry(context, pageResult, collected);
 	} catch (err) {
 		const errorMessage = err instanceof Error ? err.message : String(err);
-		errors.push(`Failed to process ${inputPath}: ${errorMessage}`);
+		collected.errors.push(`Failed to process ${inputPath}: ${errorMessage}`);
 	}
-	if (shouldGenerateOgImages && ogImageEntries.length > 0) try {
-		const ogResults = await generateOgImages(ogImageEntries, options.ogImageOptions, root);
-		let ogSuccessCount = 0;
-		for (let i = 0; i < ogResults.length; i++) {
-			const result = ogResults[i];
-			if (result.error) {
-				errors.push(`OG image failed for ${result.outputPath}: ${result.error}`);
-				ogImageUrlMap.delete(ogImageInputPaths[i]);
-			} else {
-				generatedFiles.push(result.outputPath);
-				ogSuccessCount++;
-			}
-		}
-		if (ogSuccessCount > 0) {
-			const cachedCount = ogResults.filter((r) => r.cached && !r.error).length;
-			console.log(`[ox-content:og-image] Generated ${ogSuccessCount} OG images` + (cachedCount > 0 ? ` (${cachedCount} from cache)` : ""));
-		}
+	return collected;
+}
+async function transformSsgPage(context, inputPath) {
+	const result = await transformMarkdown(await fs_promises.readFile(inputPath, "utf-8"), inputPath, context.options, {
+		convertMdLinks: true,
+		baseUrl: context.base,
+		sourcePath: inputPath
+	});
+	const frontmatter = require_vitepress.normalizeVitePressFrontmatter(result.frontmatter);
+	const transformedHtml = await transformSsgHtml(result.html, context.options);
+	const title = extractTitle$1(transformedHtml, frontmatter);
+	return {
+		inputPath,
+		routePaths: getRoutePaths(inputPath, context.srcDir, context.outDir, context.base, context.ssgOptions.extension, context.ssgOptions.siteUrl),
+		transformedHtml,
+		title,
+		description: frontmatter.description,
+		lastUpdated: context.napi?.getGitLastUpdated(inputPath, context.root) ?? void 0,
+		frontmatter,
+		toc: result.toc
+	};
+}
+async function transformSsgHtml(html, options) {
+	const { html: protectedHtml, svgs: mermaidSvgs } = protectMermaidSvgs(html);
+	let transformedHtml = await transformAllPlugins(protectedHtml, {
+		tabs: true,
+		youtube: true,
+		github: options.embeds.github,
+		openGraph: options.embeds.openGraph,
+		mermaid: true,
+		githubToken: process.env.GITHUB_TOKEN
+	});
+	if (hasIslands(transformedHtml)) transformedHtml = (await transformIslands(transformedHtml)).html;
+	return restoreMermaidSvgs(transformedHtml, mermaidSvgs);
+}
+function collectOgImageEntry(context, pageResult, collected) {
+	if (!context.shouldGenerateOgImages) return;
+	const { layout: _layout, ...frontmatterRest } = pageResult.frontmatter;
+	collected.ogImageEntries.push({
+		props: {
+			...frontmatterRest,
+			title: pageResult.title,
+			description: pageResult.description,
+			siteName: context.siteName
+		},
+		outputPath: pageResult.routePaths.ogImagePath
+	});
+	collected.ogImageInputPaths.push(pageResult.inputPath);
+	collected.ogImageUrlMap.set(pageResult.inputPath, pageResult.routePaths.ogImageUrl);
+}
+async function generateOgImageAssets(context, collected, generatedFiles, errors) {
+	if (!context.shouldGenerateOgImages || collected.ogImageEntries.length === 0) return;
+	try {
+		const ogResults = await generateOgImages(collected.ogImageEntries, context.options.ogImageOptions, context.root);
+		if (clearMissingBrowserOgImages(ogResults, collected)) return;
+		reportOgImageResults(ogResults, collected, generatedFiles, errors);
 	} catch (err) {
 		const errorMessage = err instanceof Error ? err.message : String(err);
 		console.warn(`[ox-content:og-image] Batch generation failed: ${errorMessage}`);
-		ogImageUrlMap.clear();
+		collected.ogImageUrlMap.clear();
 	}
-	for (const pageResult of pageResults) try {
-		const { inputPath, routePaths, transformedHtml, title, description, lastUpdated, frontmatter, toc } = pageResult;
-		let pageOgImage = ssgOptions.ogImage;
-		if (shouldGenerateOgImages && ogImageUrlMap.has(inputPath)) pageOgImage = ogImageUrlMap.get(inputPath);
-		let entryPage;
-		if (frontmatter.layout === "entry") entryPage = {
-			hero: frontmatter.hero,
-			features: frontmatter.features
-		};
-		let html;
-		if (ssgOptions.bare) html = generateBareHtmlPage(transformedHtml, title);
-		else {
-			const pageData = {
-				title,
-				description,
-				content: transformedHtml,
-				toc,
-				lastUpdated,
-				frontmatter,
-				path: routePaths.urlPath,
-				href: routePaths.href,
-				entryPage
-			};
-			html = await generateHtmlPage(pageData, navItems, siteName, base, pageOgImage, ssgOptions.theme, getPageLocale(pageData.path, options.i18n), options.i18n ? options.i18n.locales : void 0);
+}
+function clearMissingBrowserOgImages(ogResults, collected) {
+	if (!(ogResults.length > 0 && ogResults.every((result) => result.error === "Chromium not available"))) return false;
+	for (const inputPath of collected.ogImageInputPaths) collected.ogImageUrlMap.delete(inputPath);
+	return true;
+}
+function reportOgImageResults(ogResults, collected, generatedFiles, errors) {
+	let ogSuccessCount = 0;
+	for (let i = 0; i < ogResults.length; i++) {
+		const result = ogResults[i];
+		if (result.error) {
+			errors.push(`OG image failed for ${result.outputPath}: ${result.error}`);
+			collected.ogImageUrlMap.delete(collected.ogImageInputPaths[i]);
+		} else {
+			generatedFiles.push(result.outputPath);
+			ogSuccessCount++;
 		}
+	}
+	if (ogSuccessCount > 0) {
+		const cachedCount = ogResults.filter((result) => result.cached && !result.error).length;
+		console.log(`[ox-content:og-image] Generated ${ogSuccessCount} OG images` + (cachedCount > 0 ? ` (${cachedCount} from cache)` : ""));
+	}
+}
+async function generateHtmlPages(context, pageResults, collected, errors) {
+	const generatedPages = [];
+	for (const pageResult of pageResults) try {
 		generatedPages.push({
-			inputPath,
-			outputPath: routePaths.outputPath,
-			html
+			inputPath: pageResult.inputPath,
+			outputPath: pageResult.routePaths.outputPath,
+			html: await renderSsgPage(context, pageResult, collected.ogImageUrlMap)
 		});
 	} catch (err) {
 		const errorMessage = err instanceof Error ? err.message : String(err);
 		errors.push(`Failed to generate HTML for ${pageResult.inputPath}: ${errorMessage}`);
 	}
-	const optimizedOutput = await externalizeSharedPageAssets(generatedPages, outDir, base);
+	return generatedPages;
+}
+async function renderSsgPage(context, pageResult, ogImageUrlMap) {
+	if (context.ssgOptions.bare) return generateBareHtmlPage(pageResult.transformedHtml, pageResult.title);
+	const pageData = createSsgPageData(pageResult);
+	const pageOgImage = context.shouldGenerateOgImages && ogImageUrlMap.has(pageResult.inputPath) ? ogImageUrlMap.get(pageResult.inputPath) : context.ssgOptions.ogImage;
+	return generateHtmlPage(pageData, context.navItems, context.siteName, context.base, pageOgImage, context.ssgOptions.theme, getPageLocale(pageData.path, context.options.i18n), context.options.i18n ? context.options.i18n.locales : void 0);
+}
+function createSsgPageData(pageResult) {
+	const { frontmatter } = pageResult;
+	const entryPage = frontmatter.layout === "entry" ? {
+		hero: frontmatter.hero,
+		features: frontmatter.features
+	} : void 0;
+	return {
+		title: pageResult.title,
+		description: pageResult.description,
+		content: pageResult.transformedHtml,
+		toc: pageResult.toc,
+		lastUpdated: pageResult.lastUpdated,
+		frontmatter,
+		path: pageResult.routePaths.urlPath,
+		href: pageResult.routePaths.href,
+		entryPage
+	};
+}
+async function writeGeneratedPages(generatedPages, context, generatedFiles) {
+	const optimizedOutput = await externalizeSharedPageAssets(generatedPages, context.outDir, context.base);
 	generatedFiles.push(...optimizedOutput.assets);
 	for (const page of optimizedOutput.pages) {
 		await fs_promises.mkdir(path.dirname(page.outputPath), { recursive: true });
 		await fs_promises.writeFile(page.outputPath, page.html, "utf-8");
 		generatedFiles.push(page.outputPath);
 	}
-	return {
-		files: generatedFiles,
-		errors
-	};
 }
 //#endregion
 //#region src/search.ts
@@ -2037,7 +2017,7 @@ async function buildSsg(options, root) {
 let oxContent$1 = null;
 async function getOxContent() {
 	if (!oxContent$1) try {
-		oxContent$1 = await require_mermaid.importNapiModule();
+		oxContent$1 = await require_napi.importNapiModule();
 	} catch {
 		console.warn("[ox-content] Native bindings not available, search disabled");
 		return null;
@@ -2091,7 +2071,7 @@ async function writeSearchIndex(indexJson, outDir) {
 * This is injected into the bundle as a virtual module.
 */
 function generateSearchModule(options, indexPath) {
-	return require_mermaid.importNapiModuleSync().generateSearchModuleFromOptions(options, indexPath);
+	return require_napi.importNapiModuleSync().generateSearchModuleFromOptions(options, indexPath);
 }
 //#endregion
 //#region src/dev-server.ts
@@ -2705,7 +2685,7 @@ function createI18nPlugin(resolvedOptions) {
 				return;
 			}
 			try {
-				const { checkI18nProject } = await require_mermaid.importNapiModule();
+				const { checkI18nProject } = await require_napi.importNapiModule();
 				const checkResult = checkI18nProject(dictDir, [path.resolve(root, "src"), path.resolve(root, "content")], i18nOptions.functionNames, i18nOptions.defaultLocale);
 				if (checkResult.errorCount > 0 || checkResult.warningCount > 0) {
 					for (const diag of checkResult.diagnostics) if (diag.severity === "error") console.error(`[ox-content:i18n] ${diag.message}`);
@@ -2859,7 +2839,10 @@ function stripMaskedDocument(result) {
 	};
 }
 function normalizeLintOptions(options) {
-	const languages = options.languages?.filter((language) => SUPPORTED_MARKDOWN_LINT_LANGUAGES.includes(language)) ?? options.dictionary?.standard?.languages?.filter((language) => SUPPORTED_MARKDOWN_LINT_LANGUAGES.includes(language)) ?? [...DEFAULT_LANGUAGES];
+	const standardDictionary = options.dictionary?.standard && typeof options.dictionary.standard === "object" ? options.dictionary.standard : void 0;
+	const optionLanguages = options.languages?.filter((language) => SUPPORTED_MARKDOWN_LINT_LANGUAGES.includes(language));
+	const standardLanguages = standardDictionary?.languages?.filter((language) => SUPPORTED_MARKDOWN_LINT_LANGUAGES.includes(language));
+	const languages = optionLanguages ?? standardLanguages ?? [...DEFAULT_LANGUAGES];
 	const standard = normalizeStandardDictionaryOptions(options.dictionary?.standard, languages);
 	return {
 		dictionary: {
@@ -2900,6 +2883,12 @@ async function runStandardSpellcheckDocuments(maskedDocuments, options) {
 		const { spellCheckDocument } = await loadCspellLib();
 		const locale = standard.languages.join(",");
 		const settings = createStandardSpellcheckSettings(options, locale);
+		const spellCheckOptions = {
+			generateSuggestions: true,
+			noConfigSearch: true,
+			numSuggestions: 3,
+			resolveImportsRelativeTo: standard.resolveImportsRelativeTo
+		};
 		return Promise.all(maskedDocuments.map(async (maskedDocument, index) => {
 			if (maskedDocument.trim().length === 0) return [];
 			return (await spellCheckDocument({
@@ -2907,12 +2896,7 @@ async function runStandardSpellcheckDocuments(maskedDocuments, options) {
 				locale,
 				text: maskedDocument,
 				uri: `file:///ox-content-lint-${index}.md`
-			}, {
-				generateSuggestions: true,
-				noConfigSearch: true,
-				numSuggestions: 3,
-				resolveImportsRelativeTo: standard.resolveImportsRelativeTo
-			}, settings)).issues.map((issue) => mapStandardIssueToDiagnostic(issue, standard.languages));
+			}, spellCheckOptions, settings)).issues.map((issue) => mapStandardIssueToDiagnostic(issue, standard.languages, maskedDocument));
 		}));
 	} catch (error) {
 		const imports = standard.imports.join(", ");
@@ -2933,8 +2917,8 @@ async function loadCspellLib() {
 	cspellLibPromise ??= import("cspell-lib");
 	return cspellLibPromise;
 }
-function mapStandardIssueToDiagnostic(issue, languages) {
-	const line = issue.line.position.line + 1;
+function mapStandardIssueToDiagnostic(issue, languages, documentText) {
+	const line = getLineNumberAtOffset(documentText, issue.line.offset);
 	const column = issue.offset - issue.line.offset + 1;
 	return {
 		column,
@@ -2948,6 +2932,11 @@ function mapStandardIssueToDiagnostic(issue, languages) {
 		suggestions: issue.suggestions?.slice(0, 3)
 	};
 }
+function getLineNumberAtOffset(text, offset) {
+	let line = 1;
+	for (let index = 0; index < offset && index < text.length; index++) if (text.charCodeAt(index) === 10) line++;
+	return line;
+}
 function inferStandardIssueLanguage(word, languages) {
 	if (/[\p{Script=Hiragana}\p{Script=Katakana}]/u.test(word) && languages.includes("ja")) return "ja";
 	if (/[\p{Script=Han}]/u.test(word)) {
@@ -3684,21 +3673,35 @@ init_page_context();
 function oxContent(options = {}) {
 	const resolvedOptions = resolveOptions(options);
 	let config;
-	async function regenerateDocs(root) {
-		const docsOptions = resolvedOptions.docs;
-		if (!docsOptions || !docsOptions.enabled) return 0;
-		const srcDirs = docsOptions.src.map((src) => path.resolve(root, src));
-		const outDir = path.resolve(root, docsOptions.out);
-		const extracted = await extractDocs(srcDirs, docsOptions);
-		const generated = generateMarkdown(extracted, docsOptions);
-		await writeDocs(generated, outDir, extracted, docsOptions);
-		return Object.keys(generated).length;
-	}
-	const mainPlugin = {
-		name: "ox-content",
-		configResolved(resolvedConfig) {
+	const getRoot = () => config?.root || process.cwd();
+	const ssgDevCache = createDevServerCache();
+	const plugins = [
+		createMainPlugin(resolvedOptions, (resolvedConfig) => {
 			config = resolvedConfig;
-		},
+		}),
+		createEnvironmentPlugin(resolvedOptions),
+		createDocsPlugin(resolvedOptions, getRoot),
+		createSsgPlugin(resolvedOptions, getRoot, ssgDevCache),
+		createSearchPlugin(resolvedOptions, getRoot)
+	];
+	if (resolvedOptions.i18n) plugins.push(createI18nPlugin(resolvedOptions));
+	if (resolvedOptions.ogViewer) plugins.push(createOgViewerPlugin(resolvedOptions));
+	return plugins;
+}
+async function regenerateDocs(resolvedOptions, root) {
+	const docsOptions = resolvedOptions.docs;
+	if (!docsOptions || !docsOptions.enabled) return 0;
+	const srcDirs = docsOptions.src.map((src) => path.resolve(root, src));
+	const outDir = path.resolve(root, docsOptions.out);
+	const extracted = await extractDocs(srcDirs, docsOptions);
+	const generated = generateMarkdown(extracted, docsOptions);
+	await writeDocs(generated, outDir, extracted, docsOptions);
+	return Object.keys(generated).length;
+}
+function createMainPlugin(resolvedOptions, setConfig) {
+	return {
+		name: "ox-content",
+		configResolved: setConfig,
 		configureServer(devServer) {
 			devServer.middlewares.use(async (req, res, next) => {
 				const url = req.url;
@@ -3723,31 +3726,33 @@ function oxContent(options = {}) {
 			};
 		},
 		async handleHotUpdate({ file, server }) {
-			if (isMarkdownFilePath(file, resolvedOptions.extensions)) {
-				server.ws.send({
-					type: "custom",
-					event: "ox-content:update",
-					data: { file }
-				});
-				const modules = server.moduleGraph.getModulesByFile(file);
-				return modules ? Array.from(modules) : [];
-			}
+			if (!isMarkdownFilePath(file, resolvedOptions.extensions)) return;
+			server.ws.send({
+				type: "custom",
+				event: "ox-content:update",
+				data: { file }
+			});
+			const modules = server.moduleGraph.getModulesByFile(file);
+			return modules ? Array.from(modules) : [];
 		}
 	};
-	const environmentPlugin = {
+}
+function createEnvironmentPlugin(resolvedOptions) {
+	return {
 		name: "ox-content:environment",
 		config() {
 			return { environments: { markdown: createMarkdownEnvironment(resolvedOptions) } };
 		}
 	};
-	const docsPlugin = {
+}
+function createDocsPlugin(resolvedOptions, getRoot) {
+	return {
 		name: "ox-content:docs",
 		async buildStart() {
 			const docsOptions = resolvedOptions.docs;
 			if (!docsOptions || !docsOptions.enabled) return;
-			const root = config?.root || process.cwd();
 			try {
-				const count = await regenerateDocs(root);
+				const count = await regenerateDocs(resolvedOptions, getRoot());
 				console.log(`[ox-content] Generated ${count} documentation files to ${docsOptions.out}`);
 			} catch (err) {
 				console.warn("[ox-content] Failed to generate documentation:", err);
@@ -3756,50 +3761,32 @@ function oxContent(options = {}) {
 		configureServer(devServer) {
 			const docsOptions = resolvedOptions.docs;
 			if (!docsOptions || !docsOptions.enabled) return;
-			const root = config?.root || process.cwd();
+			const root = getRoot();
 			const srcDirs = docsOptions.src.map((src) => path.resolve(root, src));
 			for (const srcDir of srcDirs) devServer.watcher.add(srcDir);
 			devServer.watcher.on("all", async (event, file) => {
 				if (event !== "add" && event !== "change" && event !== "unlink") return;
-				if (srcDirs.some((srcDir) => file.startsWith(srcDir) && (file.endsWith(".ts") || file.endsWith(".tsx")))) try {
-					await regenerateDocs(root);
+				if (!srcDirs.some((srcDir) => file.startsWith(srcDir) && (file.endsWith(".ts") || file.endsWith(".tsx")))) return;
+				try {
+					await regenerateDocs(resolvedOptions, root);
 				} catch {}
 			});
 		}
 	};
-	const ssgDevCache = createDevServerCache();
-	const ssgPlugin = {
+}
+function createSsgPlugin(resolvedOptions, getRoot, ssgDevCache) {
+	return {
 		name: "ox-content:ssg",
 		configureServer(devServer) {
 			if (!resolvedOptions.ssg.enabled) return;
-			const root = config?.root || process.cwd();
+			const root = getRoot();
 			const srcDir = path.resolve(root, resolvedOptions.srcDir);
 			devServer.middlewares.use(createDevServerMiddleware(resolvedOptions, root, ssgDevCache));
 			devServer.watcher.on("add", (file) => {
-				if (file.startsWith(srcDir) && isMarkdownFilePath(file, resolvedOptions.extensions)) {
-					invalidateNavCache(ssgDevCache);
-					devServer.ws.send({
-						type: "custom",
-						event: "ox-content:update",
-						data: {
-							file,
-							type: "add"
-						}
-					});
-				}
+				notifySsgFileAddedOrRemoved(devServer, resolvedOptions, ssgDevCache, srcDir, file, "add");
 			});
 			devServer.watcher.on("unlink", (file) => {
-				if (file.startsWith(srcDir) && isMarkdownFilePath(file, resolvedOptions.extensions)) {
-					invalidateNavCache(ssgDevCache);
-					devServer.ws.send({
-						type: "custom",
-						event: "ox-content:update",
-						data: {
-							file,
-							type: "unlink"
-						}
-					});
-				}
+				notifySsgFileAddedOrRemoved(devServer, resolvedOptions, ssgDevCache, srcDir, file, "unlink");
 			});
 			devServer.watcher.on("change", (file) => {
 				if (file.startsWith(srcDir) && isMarkdownFilePath(file, resolvedOptions.extensions)) invalidatePageCache(ssgDevCache, file);
@@ -3807,63 +3794,63 @@ function oxContent(options = {}) {
 		},
 		async closeBundle() {
 			if (!resolvedOptions.ssg.enabled) return;
-			const root = config?.root || process.cwd();
 			try {
-				const result = await buildSsg(resolvedOptions, root);
+				const result = await buildSsg(resolvedOptions, getRoot());
 				if (result.files.length > 0) console.log(`[ox-content] Generated ${result.files.length} output files`);
-				if (result.errors.length > 0) for (const error of result.errors) console.warn(`[ox-content] ${error}`);
+				for (const error of result.errors) console.warn(`[ox-content] ${error}`);
 			} catch (err) {
 				console.error("[ox-content] SSG build failed:", err);
 			}
 		}
 	};
+}
+function notifySsgFileAddedOrRemoved(devServer, resolvedOptions, ssgDevCache, srcDir, file, type) {
+	if (!file.startsWith(srcDir) || !isMarkdownFilePath(file, resolvedOptions.extensions)) return;
+	invalidateNavCache(ssgDevCache);
+	devServer.ws.send({
+		type: "custom",
+		event: "ox-content:update",
+		data: {
+			file,
+			type
+		}
+	});
+}
+function createSearchPlugin(resolvedOptions, getRoot) {
 	let searchIndexJson = "";
-	const plugins = [
-		mainPlugin,
-		environmentPlugin,
-		docsPlugin,
-		ssgPlugin,
-		{
-			name: "ox-content:search",
-			resolveId(id) {
-				if (id === "virtual:ox-content/search") return "\0virtual:ox-content/search";
-				return null;
-			},
-			async load(id) {
-				if (id === "\0virtual:ox-content/search") {
-					const searchOptions = resolvedOptions.search;
-					if (!searchOptions.enabled) return "export const search = () => []; export const searchOptions = { enabled: false }; export default { search, searchOptions };";
-					return generateSearchModule(searchOptions, resolvedOptions.base + "search-index.json");
-				}
-				return null;
-			},
-			async buildStart() {
-				if (!resolvedOptions.search.enabled) return;
-				const root = config?.root || process.cwd();
-				const srcDir = path.resolve(root, resolvedOptions.srcDir);
-				try {
-					searchIndexJson = await buildSearchIndex(srcDir, resolvedOptions.base, resolvedOptions.extensions);
-					console.log("[ox-content] Search index built");
-				} catch (err) {
-					console.warn("[ox-content] Failed to build search index:", err);
-				}
-			},
-			async closeBundle() {
-				if (!resolvedOptions.search.enabled || !searchIndexJson) return;
-				const root = config?.root || process.cwd();
-				const outDir = path.resolve(root, resolvedOptions.outDir);
-				try {
-					await writeSearchIndex(searchIndexJson, outDir);
-					console.log("[ox-content] Search index written to", path.join(outDir, "search-index.json"));
-				} catch (err) {
-					console.warn("[ox-content] Failed to write search index:", err);
-				}
+	return {
+		name: "ox-content:search",
+		resolveId(id) {
+			if (id === "virtual:ox-content/search") return "\0virtual:ox-content/search";
+			return null;
+		},
+		async load(id) {
+			if (id !== "\0virtual:ox-content/search") return null;
+			const searchOptions = resolvedOptions.search;
+			if (!searchOptions.enabled) return "export const search = () => []; export const searchOptions = { enabled: false }; export default { search, searchOptions };";
+			return generateSearchModule(searchOptions, resolvedOptions.base + "search-index.json");
+		},
+		async buildStart() {
+			if (!resolvedOptions.search.enabled) return;
+			const srcDir = path.resolve(getRoot(), resolvedOptions.srcDir);
+			try {
+				searchIndexJson = await buildSearchIndex(srcDir, resolvedOptions.base, resolvedOptions.extensions);
+				console.log("[ox-content] Search index built");
+			} catch (err) {
+				console.warn("[ox-content] Failed to build search index:", err);
+			}
+		},
+		async closeBundle() {
+			if (!resolvedOptions.search.enabled || !searchIndexJson) return;
+			const outDir = path.resolve(getRoot(), resolvedOptions.outDir);
+			try {
+				await writeSearchIndex(searchIndexJson, outDir);
+				console.log("[ox-content] Search index written to", path.join(outDir, "search-index.json"));
+			} catch (err) {
+				console.warn("[ox-content] Failed to write search index:", err);
 			}
 		}
-	];
-	if (resolvedOptions.i18n) plugins.push(createI18nPlugin(resolvedOptions));
-	if (resolvedOptions.ogViewer) plugins.push(createOgViewerPlugin(resolvedOptions));
-	return plugins;
+	};
 }
 /**
 * Resolves plugin options with defaults.