@ox-content/vite-plugin 2.8.0 → 2.9.0

package/dist/index.mjs

@@ -1,59 +1,22 @@
-import { n as transformMermaidStatic, r as importNapiModule, t as mermaidClientScript } from "./mermaid.mjs";
-import { n as resetTabGroupCounter, r as transformTabs, t as generateTabsCSS } from "./tabs2.mjs";
-import { n as transformYouTube, t as extractVideoId } from "./youtube2.mjs";
-import { a as transformGitHub, i as prefetchGitHubRepos, n as fetchRepoData, t as collectGitHubRepos } from "./github2.mjs";
-import { a as transformOgp, i as prefetchOgpData, n as fetchOgpData, t as collectOgpUrls } from "./ogp2.mjs";
+import { a as importNapiModuleSync, c as __exportAll, d as __toESM, i as importNapiModule, l as __require, o as __commonJSMin, r as transformMermaidStatic, s as __esmMin, t as mermaidClientScript, u as __toCommonJS } from "./mermaid.mjs";
+import { i as transformTabs, n as resetTabGroupCounter, t as generateTabsCSS } from "./tabs.mjs";
+import { n as transformYouTube, t as extractVideoId } from "./youtube.mjs";
+import { a as transformGitHub, i as prefetchGitHubRepos, n as fetchRepoData, t as collectGitHubRepos } from "./github.mjs";
+import { a as transformOgp, i as prefetchOgpData, n as fetchOgpData, t as collectOgpUrls } from "./ogp.mjs";
 import { createRequire } from "node:module";
-import * as path$2 from "path";
-import path from "path";
+import * as path$1 from "path";
 import { unified } from "unified";
 import rehypeParse from "rehype-parse";
 import rehypeStringify from "rehype-stringify";
 import { createHighlighter } from "shiki";
-import * as path$1 from "node:path";
+import * as path from "node:path";
 import { dirname, join } from "node:path";
 import * as fs$2 from "fs";
-import { createHash } from "node:crypto";
 import * as fs$1 from "fs/promises";
 import { glob } from "glob";
 import * as crypto from "crypto";
 import * as fs from "node:fs/promises";
 import { mkdir, writeFile } from "node:fs/promises";
-//#region \0rolldown/runtime.js
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __esmMin = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
-var __commonJSMin = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
-var __exportAll = (all, no_symbols) => {
-	let target = {};
-	for (var name in all) __defProp(target, name, {
-		get: all[name],
-		enumerable: true
-	});
-	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
-	return target;
-};
-var __copyProps = (to, from, except, desc) => {
-	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
-		key = keys[i];
-		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
-			get: ((k) => from[k]).bind(null, key),
-			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
-		});
-	}
-	return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
-	value: mod,
-	enumerable: true
-}) : target, mod));
-var __toCommonJS = (mod) => __hasOwnProp.call(mod, "module.exports") ? mod["module.exports"] : __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var __require = /* @__PURE__ */ createRequire(import.meta.url);
-//#endregion
 //#region src/environment.ts
 /**
 * Creates the Markdown processing environment configuration.
@@ -7112,241 +7075,11 @@ if (import.meta.hot) {
 }
 //#endregion
 //#region src/nav-generator.ts
-/**
-* Navigation Metadata Generator for API Documentation
-*
-* This module provides utilities for generating sidebar navigation structures
-* from extracted documentation. It automatically:
-*
-* - **Extracts file information**: Gets display names and file paths
-* - **Formats names**: Converts technical names to readable titles
-* - **Generates TypeScript**: Creates importable nav.ts files
-* - **Maintains hierarchy**: Supports nested navigation structures
-*
-* ## Generated Navigation Format
-*
-* The generated navigation is TypeScript-based for type safety and IDE support:
-*
-* ```typescript
-* export const apiNav: NavItem[] = [
-*   { title: 'Overview', path: '/api/index' },
-*   { title: 'Transform', path: '/api/transform' },
-*   { title: 'Types', path: '/api/types' },
-*   // ... auto-generated from documentation
-* ] as const;
-* ```
-*
-* ## Integration
-*
-* The generated nav.ts file can be imported directly:
-*
-* ```typescript
-* // In your Vue/React component
-* import { apiNav } from '../api/nav';
-*
-* const apiItems = apiNav.map(item => ({
-*   ...item,
-*   file: () => import(`../api/${item.path.split('/').pop()}.md`)
-* }));
-* ```
-*
-* @example
-* ```typescript
-* import { generateNavMetadata, generateNavCode } from './nav-generator';
-*
-* const extracted = [
-*   { file: 'transform.ts', entries: [...] },
-*   { file: 'types.ts', entries: [...] },
-* ];
-*
-* const navItems = generateNavMetadata(extracted);
-* // => [
-* //   { title: 'Transform', path: '/api/transform' },
-* //   { title: 'Types', path: '/api/types' },
-* // ]
-*
-* const code = generateNavCode(navItems);
-* // => TypeScript code ready to write to nav.ts
-* ```
-*/
-/**
-* Generates sidebar navigation metadata from extracted documentation.
-*
-* Takes an array of extracted documentation and produces a flat navigation
-* structure suitable for sidebar menus. Items are:
-* - Sorted alphabetically by display name
-* - Formatted with readable titles
-* - Prefixed with the specified base path
-*
-* ## Naming Conventions
-*
-* - `transform.ts` → `{ title: 'Transform', path: '/api/transform' }`
-* - `nav-generator.ts` → `{ title: 'Nav Generator', path: '/api/nav-generator' }`
-* - `index.ts` or `index-module.ts` → `{ title: 'Overview', path: '/api/index' }`
-* - `types.ts` → `{ title: 'Types', path: '/api/types' }`
-*
-* ## Sorting
-*
-* Items are sorted alphabetically by display title for consistent ordering.
-* Special item 'Overview' sorts naturally with others (O comes after most letters).
-*
-* ## Path Generation
-*
-* The generated paths are used to import corresponding Markdown files:
-* - Path `/api/transform` → Import from `../api/transform.md`
-* - Path `/api/index` → Import from `../api/index.md`
-*
-* @param docs - Array of extracted documentation (file + entries)
-* @param basePath - Base path prefix for navigation URLs (default: '/api')
-*                   Use '/api' for main API docs, '/helpers' for utilities, etc.
-*
-* @returns Array of navigation items ready to use or export to TypeScript
-*
-* @example
-* ```typescript
-* const navItems = generateNavMetadata(
-*   [
-*     { file: 'transform.ts', entries: [...] },
-*     { file: 'docs.ts', entries: [...] },
-*     { file: 'types.ts', entries: [...] },
-*   ],
-*   '/api'
-* );
-*
-* // Returns:
-* // [
-* //   { title: 'Docs', path: '/api/docs' },
-* //   { title: 'Transform', path: '/api/transform' },
-* //   { title: 'Types', path: '/api/types' },
-* // ]
-* ```
-*
-* @see generateNavCode For converting these items to TypeScript code
-*/
 function generateNavMetadata(docs, basePath = "/api") {
-	return [...docs].sort((a, b) => {
-		const aName = getDocDisplayName(a.file);
-		const bName = getDocDisplayName(b.file);
-		return aName.localeCompare(bName);
-	}).map((doc) => ({
-		title: getDocDisplayName(doc.file),
-		path: `${basePath}/${getDocFileName(doc.file)}`
-	}));
-}
-/**
-* Gets the human-readable display name for a documentation file.
-*
-* Transforms file paths and names into proper title case:
-* - Extracts base name (e.g., 'transform.ts' → 'transform')
-* - Converts kebab-case to Title Case (e.g., 'nav-generator' → 'Nav Generator')
-* - Converts camelCase to Title Case (e.g., 'transformMarkdown' → 'Transform Markdown')
-* - Handles special cases (index → 'Overview')
-*
-* ## Examples
-*
-* - `'/path/to/transform.ts'` → `'Transform'`
-* - `'nav-generator.ts'` → `'Nav Generator'`
-* - `'index.ts'` → `'Overview'`
-* - `'index-module.ts'` → `'Overview'`
-* - `'myFunction.ts'` → `'My Function'` (with camelCase handling)
-*
-* @param filePath - Full or relative file path
-* @returns Formatted display name suitable for UI labels
-*
-* @internal
-*/
-function getDocDisplayName(filePath) {
-	const fileName = path.basename(filePath, path.extname(filePath));
-	if (fileName === "index" || fileName === "index-module") return "Overview";
-	return fileName.replace(/[-_]([a-z])/g, (_, char) => " " + char.toUpperCase()).replace(/^[a-z]/, (char) => char.toUpperCase());
+	return importNapiModuleSync().generateDocsNavMetadata(docs.map((doc) => doc.file), basePath);
 }
-/**
-* Gets the file name (without extension) for use in navigation paths.
-*
-* This handles filename conflicts that may occur during generation:
-* - Preserves most names as-is
-* - Special handling for index files to maintain consistency
-*
-* @param filePath - Source file path
-* @returns File name without extension, ready for URL paths
-*
-* @internal
-*/
-function getDocFileName(filePath) {
-	const fileName = path.basename(filePath, path.extname(filePath));
-	if (fileName === "index") return "index";
-	return fileName;
-}
-/**
-* Generates TypeScript code for navigation metadata export.
-*
-* Creates a complete, self-contained TypeScript file that:
-* - Defines the NavItem interface
-* - Exports navigation items as a const
-* - Uses `as const` for type-safe literal types
-* - Includes auto-generation notice
-*
-* The generated code is production-ready and suitable for direct import
-* in Vue, React, or vanilla TypeScript applications.
-*
-* ## Generated Code Example
-*
-* ```typescript
-* export interface NavItem {
-*   title: string;
-*   path: string;
-*   children?: NavItem[];
-* }
-*
-* export const apiNav: NavItem[] = [
-*   { "title": "Docs", "path": "/api/docs" },
-*   { "title": "Transform", "path": "/api/transform" },
-*   // ...
-* ] as const;
-* ```
-*
-* ## Features
-*
-* - **Type Safety**: Includes NavItem interface definition
-* - **Readonly**: Uses `as const` to ensure immutability
-* - **IDE Support**: Full IntelliSense and autocomplete
-* - **Self-Documenting**: Includes notice that file is auto-generated
-*
-* @param navItems - Array of navigation items to export
-* @param exportName - Name of the exported const (default: 'apiNav')
-*                     Use custom names for different navigation sections
-*
-* @returns Complete TypeScript source code as string,
-*          ready to write to a .ts file
-*
-* @example
-* ```typescript
-* const navItems = [
-*   { title: 'Home', path: '/api/index' },
-*   { title: 'Transform', path: '/api/transform' },
-* ];
-*
-* const code = generateNavCode(navItems, 'apiNav');
-* await fs.promises.writeFile('docs/api/nav.ts', code, 'utf-8');
-* ```
-*
-* @see generateNavMetadata For generating NavItem arrays from extracted docs
-*/
 function generateNavCode(navItems, exportName = "apiNav") {
-	return `/**
- * Auto-generated API documentation navigation.
- * This file is automatically generated by the docs plugin.
- * Do not edit manually.
- */
-
-export interface NavItem {
-  title: string;
-  path: string;
-  children?: NavItem[];
-}
-
-export const ${exportName}: NavItem[] = ${JSON.stringify(navItems, null, 2)} as const;
-`;
+	return importNapiModuleSync().generateDocsNavCode(navItems, exportName);
 }
 //#endregion
 //#region src/docs.ts
@@ -7673,86 +7406,6 @@ function buildDocsData(docs) {
 		}))
 	};
 }
-function consumeJSDocType(value) {
-	const trimmed = value.trimStart();
-	if (!trimmed.startsWith("{")) return { rest: trimmed };
-	let depth = 0;
-	for (let index = 0; index < trimmed.length; index++) {
-		const char = trimmed[index];
-		if (char === "{") depth++;
-		else if (char === "}") {
-			depth--;
-			if (depth === 0) return {
-				type: trimmed.slice(1, index).trim() || void 0,
-				rest: trimmed.slice(index + 1).trimStart()
-			};
-		}
-	}
-	return { rest: trimmed };
-}
-function cleanTagDescription(value) {
-	return value.trim().replace(/^-\s*/, "").trim();
-}
-function splitTagNameAndDescription(value) {
-	const trimmed = value.trimStart();
-	if (trimmed.startsWith("[")) {
-		const closeIndex = trimmed.indexOf("]");
-		if (closeIndex >= 0) return {
-			name: trimmed.slice(0, closeIndex + 1),
-			description: trimmed.slice(closeIndex + 1).trimStart()
-		};
-	}
-	const match = /^(\S+)(?:\s+([\s\S]*))?$/u.exec(trimmed);
-	return {
-		name: match?.[1] ?? "",
-		description: match?.[2] ?? ""
-	};
-}
-function parseParamTagValue(value) {
-	const { type, rest } = consumeJSDocType(value);
-	const { name: rawName, description } = splitTagNameAndDescription(rest);
-	let name = rawName.trim();
-	if (!name) return null;
-	let optional = false;
-	let defaultValue;
-	const optionalMatch = /^\[(.*)\]$/u.exec(name);
-	if (optionalMatch) {
-		optional = true;
-		const [innerName, innerDefault] = optionalMatch[1].split(/=(.*)/su);
-		name = innerName.trim();
-		defaultValue = innerDefault?.trim() || void 0;
-	}
-	if (!name) return null;
-	return {
-		name,
-		type: type || "unknown",
-		description: cleanTagDescription(description),
-		optional: optional || void 0,
-		default: defaultValue
-	};
-}
-function parseReturnsTagValue(value) {
-	const { type, rest } = consumeJSDocType(value);
-	return {
-		type: type || "unknown",
-		description: cleanTagDescription(rest)
-	};
-}
-function normalizeReturnType(value) {
-	const parsed = parseReturnsTagValue(value);
-	return parsed.type === "unknown" ? value : parsed.type;
-}
-function mergeParam(params, next) {
-	const existing = params.find((param) => param.name === next.name);
-	if (!existing) {
-		params.push(next);
-		return;
-	}
-	if (next.type && (existing.type === "unknown" || next.type !== "unknown")) existing.type = next.type;
-	if (next.description) existing.description = next.description;
-	if (next.optional) existing.optional = true;
-	if (next.default) existing.default = next.default;
-}
 /**
 * Extracts JSDoc documentation from source files in specified directories.
 *
@@ -7819,13 +7472,13 @@ function mergeParam(params, next) {
 * ```
 */
 async function extractDocs(srcDirs, options) {
-	const extractFileDocs = (await importNapiModule()).extractFileDocs;
-	if (!extractFileDocs) throw new Error("[ox-content] extractFileDocs is not available from @ox-content/napi.");
+	const extractFileDocEntries = (await importNapiModule()).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 = await findFiles(srcDir, options);
 		for (const file of files) {
-			const entries = extractFileDocs(file, options.private).map(parseNapiDocItem).filter((entry) => Boolean(entry));
+			const entries = extractFileDocEntries(file, options.private);
 			if (entries.length > 0) results.push({
 				file,
 				entries
@@ -7849,7 +7502,7 @@ async function findFiles(dir, options) {
 			return;
 		}
 		for (const entry of entries) {
-			const fullPath = path$2.join(currentDir, entry.name);
+			const fullPath = path$1.join(currentDir, entry.name);
 			if (entry.isDirectory()) {
 				if (!isExcluded(fullPath, options.exclude)) await walk(fullPath);
 			} else if (entry.isFile()) {
@@ -7876,132 +7529,6 @@ function isExcluded(file, patterns) {
 		return false;
 	});
 }
-function parseNapiDocItem(item) {
-	const kind = normalizeNapiKind(item.kind);
-	if (!kind) return null;
-	const params = [];
-	const examples = [];
-	const tags = {};
-	let description = "";
-	let returns;
-	let isPrivate = false;
-	const rawLines = (item.jsdoc ?? "").split("\n").map((line) => {
-		const trimmedStart = line.trimStart();
-		const withoutStar = trimmedStart.startsWith("*") ? trimmedStart.slice(1) : trimmedStart;
-		return withoutStar.startsWith(" ") ? withoutStar.slice(1) : withoutStar;
-	});
-	const cleanedLines = rawLines.map((line) => line.trim()).filter(Boolean);
-	let currentExample = "";
-	let inExample = false;
-	let rawLineIndex = 0;
-	for (const lineText of cleanedLines) {
-		while (rawLineIndex < rawLines.length && rawLines[rawLineIndex].trim() !== lineText) rawLineIndex++;
-		const rawLine = rawLineIndex < rawLines.length ? rawLines[rawLineIndex] : lineText;
-		rawLineIndex++;
-		if (lineText.startsWith("@")) {
-			if (inExample) {
-				examples.push(currentExample.trim());
-				currentExample = "";
-				inExample = false;
-			}
-			const tagMatch = /^@(\S+)\s*([\s\S]*)$/u.exec(lineText);
-			if (tagMatch) {
-				const [, tagName, tagValue = ""] = tagMatch;
-				switch (tagName) {
-					case "param":
-					case "arg":
-					case "argument": {
-						const param = parseParamTagValue(tagValue);
-						if (param) mergeParam(params, param);
-						break;
-					}
-					case "returns":
-					case "return":
-						returns = parseReturnsTagValue(tagValue);
-						break;
-					case "example":
-						inExample = true;
-						currentExample = tagValue.trim() ? `${tagValue.trim()}\n` : "";
-						break;
-					case "private":
-						isPrivate = true;
-						break;
-					default: tags[tagName] = tagValue.trim();
-				}
-			}
-		} else if (inExample) currentExample += rawLine + "\n";
-		else if (!description) description = lineText;
-		else description += "\n" + lineText;
-	}
-	if (inExample && currentExample) examples.push(currentExample.trim());
-	for (const param of item.params) {
-		if (params.length > 0 && param.name === "param" && !param.typeAnnotation && !param.description && !param.defaultValue) continue;
-		mergeParam(params, {
-			name: param.name,
-			type: param.typeAnnotation ?? "unknown",
-			description: param.description ?? "",
-			optional: param.optional || void 0,
-			default: param.defaultValue
-		});
-	}
-	if (!returns && item.returnType) returns = {
-		type: normalizeReturnType(item.returnType),
-		description: ""
-	};
-	else if (returns && item.returnType) returns.type = normalizeReturnType(item.returnType);
-	if (!description) description = item.doc ?? "";
-	for (const tag of item.tags) {
-		if (tag.tag === "param" || tag.tag === "arg" || tag.tag === "argument" || tag.tag === "returns" || tag.tag === "return") {
-			if (tag.tag === "param" || tag.tag === "arg" || tag.tag === "argument") {
-				const param = parseParamTagValue(tag.value);
-				if (param) mergeParam(params, param);
-			} else {
-				const parsedReturns = parseReturnsTagValue(tag.value);
-				if (!returns) returns = parsedReturns;
-				else {
-					returns.type = returns.type === "unknown" ? parsedReturns.type : returns.type;
-					returns.description ||= parsedReturns.description;
-				}
-			}
-			continue;
-		}
-		if (tag.tag === "example") {
-			if (tag.value && !examples.includes(tag.value)) examples.push(tag.value);
-			continue;
-		}
-		if (tag.tag === "private") {
-			isPrivate = true;
-			continue;
-		}
-		if (!tags[tag.tag]) tags[tag.tag] = tag.value;
-	}
-	return {
-		name: item.name,
-		kind,
-		description,
-		params: params.length > 0 ? params : void 0,
-		returns,
-		examples: examples.length > 0 ? examples : void 0,
-		tags: Object.keys(tags).length > 0 ? tags : void 0,
-		private: isPrivate,
-		file: item.sourcePath,
-		line: item.line,
-		endLine: item.endLine,
-		signature: item.signature
-	};
-}
-function normalizeNapiKind(kind) {
-	switch (kind) {
-		case "function":
-		case "class":
-		case "interface":
-		case "type":
-		case "variable":
-		case "module": return kind;
-		case "enum": return "type";
-		default: return null;
-	}
-}
 /**
 * Generates Markdown documentation from extracted docs.
 */
@@ -8012,7 +7539,7 @@ function generateMarkdown(docs, options) {
 	if (options.groupBy === "file") {
 		const docToFile = /* @__PURE__ */ new Map();
 		for (const doc of sortedDocs) {
-			let fileName = path$2.basename(doc.file, path$2.extname(doc.file));
+			let fileName = path$1.basename(doc.file, path$1.extname(doc.file));
 			if (fileName === "index") fileName = "index-module";
 			docToFile.set(doc, fileName);
 			const markdown = generateFileMarkdown(doc, options, fileName, symbolMap);
@@ -8045,10 +7572,10 @@ function sortExtractedDocs(docs) {
 	return [...docs].map((doc) => ({
 		...doc,
 		entries: [...doc.entries].sort(compareEntriesByName)
-	})).sort((a, b) => compareStrings(path$2.basename(a.file), path$2.basename(b.file)));
+	})).sort((a, b) => compareStrings(path$1.basename(a.file), path$1.basename(b.file)));
 }
 function generateFileMarkdown(doc, options, currentFileName, symbolMap) {
-	let md = `# ${path$2.basename(doc.file)}\n\n`;
+	let md = `# ${path$1.basename(doc.file)}\n\n`;
 	if (options.githubUrl) {
 		const sourceLink = generateSourceLink(doc.file, options.githubUrl);
 		if (sourceLink) md += sourceLink + "\n\n";
@@ -8200,7 +7727,7 @@ function generateIndex(docs, docToFile) {
 	md += "## Modules\n\n";
 	if (docs.length > 1) md += renderDetailsControlsHtml(".ox-api-module") + "\n\n";
 	for (const doc of docs) {
-		const displayName = path$2.basename(doc.file, path$2.extname(doc.file));
+		const displayName = path$1.basename(doc.file, path$1.extname(doc.file));
 		let fileName = displayName;
 		if (docToFile && docToFile.has(doc)) fileName = docToFile.get(doc);
 		else if (fileName === "index") fileName = "index-module";
@@ -8283,7 +7810,7 @@ function convertSymbolLinks(text, currentFileName, symbolMap) {
 function buildSymbolMap(docs) {
 	const map = /* @__PURE__ */ new Map();
 	for (const doc of docs) {
-		let fileName = path$2.basename(doc.file, path$2.extname(doc.file));
+		let fileName = path$1.basename(doc.file, path$1.extname(doc.file));
 		if (fileName === "index") fileName = "index-module";
 		for (const entry of doc.entries) map.set(entry.name, {
 			name: entry.name,
@@ -8301,7 +7828,7 @@ async function writeDocs(docs, outDir, extractedDocs, options) {
 	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$2.join(outDir, DOCS_MANIFEST_FILE);
+	const manifestPath = path$1.join(outDir, DOCS_MANIFEST_FILE);
 	let previousFiles = [];
 	try {
 		previousFiles = JSON.parse(await fs$2.promises.readFile(manifestPath, "utf-8"));
@@ -8310,18 +7837,18 @@ async function writeDocs(docs, outDir, extractedDocs, options) {
 	}
 	for (const staleFile of previousFiles) {
 		if (generatedFiles.has(staleFile)) continue;
-		await fs$2.promises.rm(path$2.join(outDir, staleFile), { force: true });
+		await fs$2.promises.rm(path$1.join(outDir, staleFile), { force: true });
 	}
 	for (const [fileName, content] of Object.entries(docs)) {
-		const filePath = path$2.join(outDir, fileName);
+		const filePath = path$1.join(outDir, fileName);
 		await fs$2.promises.writeFile(filePath, content, "utf-8");
 	}
 	if (extractedDocs && options?.generateNav && options.groupBy === "file") {
 		const navCode = generateNavCode(generateNavMetadata(extractedDocs, "/api"), "apiNav");
-		const navFilePath = path$2.join(outDir, "nav.ts");
+		const navFilePath = path$1.join(outDir, "nav.ts");
 		await fs$2.promises.writeFile(navFilePath, navCode, "utf-8");
 	}
-	if (extractedDocs) await fs$2.promises.writeFile(path$2.join(outDir, DOCS_DATA_FILE), JSON.stringify(buildDocsData(extractedDocs), null, 2), "utf-8");
+	if (extractedDocs) await fs$2.promises.writeFile(path$1.join(outDir, DOCS_DATA_FILE), JSON.stringify(buildDocsData(extractedDocs), null, 2), "utf-8");
 	await fs$2.promises.writeFile(manifestPath, JSON.stringify([...generatedFiles].sort(), null, 2), "utf-8");
 }
 /**
@@ -8407,10 +7934,10 @@ async function renderHtmlToPng(page, html, width, height, publicDir) {
 				await route.continue();
 				return;
 			}
-			const filePath = path$2.join(publicDir, url.pathname);
+			const filePath = path$1.join(publicDir, url.pathname);
 			try {
 				const body = await fs.readFile(filePath);
-				const ext = path$2.extname(filePath).toLowerCase();
+				const ext = path$1.extname(filePath).toLowerCase();
 				await route.fulfill({
 					body,
 					contentType: {
@@ -8595,7 +8122,7 @@ function computeCacheKey(templateSource, props, width, height) {
 * Returns the cached file path if found, null otherwise.
 */
 async function getCached(cacheDir, key) {
-	const filePath = path$2.join(cacheDir, `${key}.png`);
+	const filePath = path$1.join(cacheDir, `${key}.png`);
 	try {
 		return await fs$1.readFile(filePath);
 	} catch {
@@ -8607,7 +8134,7 @@ async function getCached(cacheDir, key) {
 */
 async function writeCache(cacheDir, key, png) {
 	await fs$1.mkdir(cacheDir, { recursive: true });
-	const filePath = path$2.join(cacheDir, `${key}.png`);
+	const filePath = path$1.join(cacheDir, `${key}.png`);
 	await fs$1.writeFile(filePath, png);
 }
 //#endregion
@@ -8698,14 +8225,14 @@ function resolveOgImageOptions(options) {
 */
 async function resolveTemplate(options, root) {
 	if (!options.template) return getDefaultTemplate();
-	const templatePath = path$2.resolve(root, options.template);
+	const templatePath = path$1.resolve(root, options.template);
 	const fs = await import("fs/promises");
 	try {
 		await fs.access(templatePath);
 	} catch {
 		throw new Error(`[ox-content:og-image] Template file not found: ${templatePath}`);
 	}
-	switch (path$2.extname(templatePath).toLowerCase()) {
+	switch (path$1.extname(templatePath).toLowerCase()) {
 		case ".vue": return resolveVueTemplate(templatePath, options, root);
 		case ".svelte": return resolveSvelteTemplate(templatePath, root);
 		case ".tsx":
@@ -8719,9 +8246,9 @@ async function resolveTemplate(options, root) {
 async function resolveTsTemplate(templatePath, options, root) {
 	const fs = await import("fs/promises");
 	const { rolldown } = await import("rolldown");
-	const cacheDir = path$2.join(root, ".cache", "og-images");
+	const cacheDir = path$1.join(root, ".cache", "og-images");
 	await fs.mkdir(cacheDir, { recursive: true });
-	const outfile = path$2.join(cacheDir, "_template.mjs");
+	const outfile = path$1.join(cacheDir, "_template.mjs");
 	const bundle = await rolldown({
 		input: templatePath,
 		platform: "node"
@@ -8744,9 +8271,9 @@ async function resolveTsTemplate(templatePath, options, root) {
 async function resolveVueTemplate(templatePath, options, root) {
 	const fs = await import("fs/promises");
 	const { rolldown } = await import("rolldown");
-	const cacheDir = path$2.join(root, ".cache", "og-images");
+	const cacheDir = path$1.join(root, ".cache", "og-images");
 	await fs.mkdir(cacheDir, { recursive: true });
-	const outfile = path$2.join(cacheDir, "_template_vue.mjs");
+	const outfile = path$1.join(cacheDir, "_template_vue.mjs");
 	const bundle = await rolldown({
 		input: templatePath,
 		platform: "node",
@@ -8842,9 +8369,9 @@ async function getVizejsPlugin() {
 async function resolveSvelteTemplate(templatePath, root) {
 	const fs = await import("fs/promises");
 	const { rolldown } = await import("rolldown");
-	const cacheDir = path$2.join(root, ".cache", "og-images");
+	const cacheDir = path$1.join(root, ".cache", "og-images");
 	await fs.mkdir(cacheDir, { recursive: true });
-	const outfile = path$2.join(cacheDir, "_template_svelte.mjs");
+	const outfile = path$1.join(cacheDir, "_template_svelte.mjs");
 	const bundle = await rolldown({
 		input: templatePath,
 		platform: "node",
@@ -8900,9 +8427,9 @@ function createSvelteCompilerPlugin() {
 async function resolveReactTemplate(templatePath, root) {
 	const fs = await import("fs/promises");
 	const { rolldown } = await import("rolldown");
-	const cacheDir = path$2.join(root, ".cache", "og-images");
+	const cacheDir = path$1.join(root, ".cache", "og-images");
 	await fs.mkdir(cacheDir, { recursive: true });
-	const outfile = path$2.join(cacheDir, "_template_react.mjs");
+	const outfile = path$1.join(cacheDir, "_template_react.mjs");
 	const bundle = await rolldown({
 		input: templatePath,
 		platform: "node",
@@ -8952,7 +8479,7 @@ async function resolveReactTemplate(templatePath, root) {
 async function computeTemplateSource(options, root) {
 	if (!options.template) return "__default__";
 	const fs = await import("fs/promises");
-	const templatePath = path$2.resolve(root, options.template);
+	const templatePath = path$1.resolve(root, options.template);
 	const content = await fs.readFile(templatePath, "utf-8");
 	return crypto.createHash("sha256").update(content).digest("hex");
 }
@@ -8970,7 +8497,7 @@ async function generateOgImages(pages, options, root) {
 		if (pages.length === 0) return [];
 		const templateFn = await resolveTemplate(options, root);
 		const templateSource = await computeTemplateSource(options, root);
-		const cacheDir = path$2.join(root, ".cache", "og-images");
+		const cacheDir = path$1.join(root, ".cache", "og-images");
 		if (options.cache) {
 			const allCached = await tryServeAllFromCache(pages, templateSource, options, cacheDir);
 			if (allCached) return allCached;
@@ -8982,7 +8509,7 @@ async function generateOgImages(pages, options, root) {
 			error: "Chromium not available"
 		}));
 		const results = [];
-		const publicDir = path$2.join(root, "public");
+		const publicDir = path$1.join(root, "public");
 		const concurrency = Math.max(1, options.concurrency);
 		for (let i = 0; i < pages.length; i += concurrency) {
 			const batch = pages.slice(i, i + concurrency);
@@ -9006,7 +8533,7 @@ async function tryServeAllFromCache(pages, templateSource, options, cacheDir) {
 	for (const entry of pages) {
 		const cached = await getCached(cacheDir, computeCacheKey(templateSource, entry.props, options.width, options.height));
 		if (!cached) return null;
-		await fs.mkdir(path$2.dirname(entry.outputPath), { recursive: true });
+		await fs.mkdir(path$1.dirname(entry.outputPath), { recursive: true });
 		await fs.writeFile(entry.outputPath, cached);
 		results.push({
 			outputPath: entry.outputPath,
@@ -9024,7 +8551,7 @@ async function renderSinglePage(entry, templateFn, templateSource, options, cach
 		if (options.cache) {
 			const cached = await getCached(cacheDir, computeCacheKey(templateSource, entry.props, options.width, options.height));
 			if (cached) {
-				await fs.mkdir(path$2.dirname(entry.outputPath), { recursive: true });
+				await fs.mkdir(path$1.dirname(entry.outputPath), { recursive: true });
 				await fs.writeFile(entry.outputPath, cached);
 				return {
 					outputPath: entry.outputPath,
@@ -9034,7 +8561,7 @@ async function renderSinglePage(entry, templateFn, templateSource, options, cach
 		}
 		const html = await templateFn(entry.props);
 		const png = await session.renderPage(html, options.width, options.height, publicDir);
-		await fs.mkdir(path$2.dirname(entry.outputPath), { recursive: true });
+		await fs.mkdir(path$1.dirname(entry.outputPath), { recursive: true });
 		await fs.writeFile(entry.outputPath, png);
 		if (options.cache) await writeCache(cacheDir, computeCacheKey(templateSource, entry.props, options.width, options.height), png);
 		return {
@@ -9058,23 +8585,23 @@ async function transformAllPlugins(html, options = {}) {
 	const { tabs = true, youtube = true, github = true, ogp = true, mermaid = true, githubToken } = options;
 	let result = html;
 	if (tabs) {
-		const { transformTabs } = await import("./tabs.mjs");
+		const { transformTabs } = await import("./tabs.mjs").then((n) => n.r);
 		result = await transformTabs(result);
 	}
 	if (youtube) {
-		const { transformYouTube } = await import("./youtube.mjs");
+		const { transformYouTube } = await import("./youtube.mjs").then((n) => n.r);
 		result = await transformYouTube(result);
 	}
 	if (github) {
-		const { transformGitHub } = await import("./github.mjs");
+		const { transformGitHub } = await import("./github.mjs").then((n) => n.r);
 		result = await transformGitHub(result, void 0, { token: githubToken });
 	}
 	if (ogp) {
-		const { transformOgp } = await import("./ogp.mjs");
+		const { transformOgp } = await import("./ogp.mjs").then((n) => n.r);
 		result = await transformOgp(result);
 	}
 	if (mermaid) {
-		const { transformMermaidStatic } = await import("./mermaid2.mjs");
+		const { transformMermaidStatic } = await import("./mermaid.mjs").then((n) => n.n);
 		result = await transformMermaidStatic(result);
 	}
 	return result;
@@ -10882,10 +10409,7 @@ function renderTemplate(template, data) {
 * Extracts title from content or frontmatter.
 */
 function extractTitle$1(content, frontmatter) {
-	if (frontmatter.title && typeof frontmatter.title === "string") return frontmatter.title;
-	const h1Match = content.match(/<h1[^>]*>([^<]+)<\/h1>/i);
-	if (h1Match) return h1Match[1].trim();
-	return "Untitled";
+	return importNapiModuleSync().extractSsgTitle(content, typeof frontmatter.title === "string" ? frontmatter.title : void 0);
 }
 /**
 * Generates bare HTML page (no navigation, no styles).
@@ -10971,229 +10495,41 @@ async function generateHtmlPage(pageData, navGroups, siteName, base, ogImage, th
 		}))
 	});
 }
-const SSG_STYLE_BLOCK_RE = /[ \t]*<!-- ox-content:styles:start -->\s*<style>([\s\S]*?)<\/style>\s*<!-- ox-content:styles:end -->/;
-const SSG_SCRIPT_BLOCK_RE = /[ \t]*<!-- ox-content:scripts:start -->\s*<script>([\s\S]*?)<\/script>\s*<!-- ox-content:scripts:end -->/;
-const FIRST_INLINE_STYLE_RE = /[ \t]*<style>([\s\S]*?)<\/style>/;
-const LAST_INLINE_BODY_SCRIPT_RE = /[ \t]*<script>([\s\S]*?)<\/script>\s*<\/body>/;
-const CSS_SECTION_RE = /\/\* ox-content:css:([a-z0-9-]+):start \*\/\s*([\s\S]*?)\s*\/\* ox-content:css:\1:end \*\//g;
-const SEARCH_CHUNK_RE = /\/\/ ox-content:search:start\s*([\s\S]*?)\s*\/\/ ox-content:search:end/;
-const SEARCH_CHUNK_PLACEHOLDER = "__OX_CONTENT_SEARCH_CHUNK__";
-const CORE_CSS_SECTION_NAMES = new Set(["base", "footer"]);
-const THEME_INLINE_CSS_MAX_BYTES = 2048;
-function createContentHash(content) {
-	return createHash("sha256").update(content).digest("hex").slice(0, 10);
-}
-function sanitizeChunkLabel(label) {
-	return label.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "") || "asset";
-}
-function toPublicAssetPath(base, fileName) {
-	return `${base.endsWith("/") ? base : `${base}/`}assets/${fileName}`;
-}
-function hasRelativeCssUrls(css) {
-	let cursor = 0;
-	while (cursor < css.length) {
-		const urlIndex = css.indexOf("url(", cursor);
-		if (urlIndex === -1) return false;
-		let valueStart = urlIndex + 4;
-		while (valueStart < css.length && /\s/.test(css[valueStart])) valueStart++;
-		const quote = css[valueStart] === "\"" || css[valueStart] === "'" ? css[valueStart] : "";
-		if (quote) valueStart++;
-		let valueEnd = valueStart;
-		while (valueEnd < css.length) {
-			const char = css[valueEnd];
-			if (quote) {
-				if (char === "\\") {
-					valueEnd += 2;
-					continue;
-				}
-				if (char === quote) break;
-			} else if (char === ")") break;
-			valueEnd++;
-		}
-		const value = css.slice(valueStart, valueEnd).trim();
-		if (value && !value.startsWith("data:") && !value.startsWith("http:") && !value.startsWith("https:") && !value.startsWith("//") && !value.startsWith("/") && !value.startsWith("#") && !value.startsWith("blob:") && !value.startsWith("var(")) return true;
-		cursor = valueEnd + 1;
-	}
-	return false;
-}
-function createSharedAssetChunk(type, label, content, outDir, base) {
-	const hash = createContentHash(content);
-	const fileName = `ox-content-${sanitizeChunkLabel(label)}-${hash}.${type}`;
-	return {
-		outputPath: path$2.join(outDir, "assets", fileName),
-		publicPath: toPublicAssetPath(base, fileName),
-		content
-	};
-}
-function extractCssSections(cssContent) {
-	return Array.from(cssContent.matchAll(CSS_SECTION_RE)).map(([, name, content]) => ({
-		name,
-		content: content.trim()
-	})).filter((section) => section.content.length > 0);
-}
-function getOrCreateSharedChunk(chunks, type, label, content, outDir, base) {
-	let chunk = chunks.get(content);
-	if (!chunk) {
-		chunk = createSharedAssetChunk(type, label, content, outDir, base);
-		chunks.set(content, chunk);
-	}
-	return chunk;
-}
-function buildStyleReplacement(cssContent, cssChunks, outDir, base) {
-	const sections = extractCssSections(cssContent);
-	const effectiveSections = sections.length > 0 ? sections : [{
-		name: "css",
-		content: cssContent.trim()
-	}];
-	const coreContent = effectiveSections.filter((section) => CORE_CSS_SECTION_NAMES.has(section.name)).map((section) => section.content).join("\n").trim();
-	const fragments = [];
-	if (coreContent) {
-		const coreChunk = getOrCreateSharedChunk(cssChunks, "css", "core", coreContent, outDir, base);
-		fragments.push(`  <link rel="stylesheet" href="${coreChunk.publicPath}">`);
-	}
-	for (const section of effectiveSections) {
-		if (CORE_CSS_SECTION_NAMES.has(section.name)) continue;
-		if (section.name === "theme" && (hasRelativeCssUrls(section.content) || section.content.length <= THEME_INLINE_CSS_MAX_BYTES) || hasRelativeCssUrls(section.content)) {
-			fragments.push(`  <style>${section.content}</style>`);
-			continue;
-		}
-		const chunk = getOrCreateSharedChunk(cssChunks, "css", section.name, section.content, outDir, base);
-		fragments.push(`  <link rel="stylesheet" href="${chunk.publicPath}">`);
-	}
-	return fragments.join("\n");
-}
-function buildScriptReplacement(jsContent, jsChunks, outDir, base) {
-	const searchMatch = jsContent.match(SEARCH_CHUNK_RE);
-	if (searchMatch && jsContent.includes(SEARCH_CHUNK_PLACEHOLDER)) {
-		const searchContent = searchMatch[1].trim();
-		if (searchContent) {
-			const searchChunk = getOrCreateSharedChunk(jsChunks, "js", "search", searchContent, outDir, base);
-			const coreContent = jsContent.replace(SEARCH_CHUNK_RE, "").replaceAll(SEARCH_CHUNK_PLACEHOLDER, searchChunk.publicPath).trim();
-			if (coreContent) return `  <script defer src="${getOrCreateSharedChunk(jsChunks, "js", "core", coreContent, outDir, base).publicPath}"><\/script>`;
-		}
-	}
-	const fallbackContent = jsContent.trim();
-	if (!fallbackContent) return "";
-	return `  <script defer src="${getOrCreateSharedChunk(jsChunks, "js", "js", fallbackContent, outDir, base).publicPath}"><\/script>`;
-}
 async function externalizeSharedPageAssets(pages, outDir, base) {
-	const cssChunks = /* @__PURE__ */ new Map();
-	const jsChunks = /* @__PURE__ */ new Map();
-	const optimizedPages = pages.map((page) => {
-		let html = page.html;
-		const styleMatch = html.match(SSG_STYLE_BLOCK_RE);
-		if (styleMatch) {
-			const replacement = buildStyleReplacement(styleMatch[1], cssChunks, outDir, base);
-			html = html.replace(SSG_STYLE_BLOCK_RE, replacement);
-		} else {
-			const inlineStyleMatch = html.match(FIRST_INLINE_STYLE_RE);
-			if (inlineStyleMatch) {
-				const replacement = buildStyleReplacement(inlineStyleMatch[1], cssChunks, outDir, base);
-				html = html.replace(FIRST_INLINE_STYLE_RE, replacement);
-			}
-		}
-		const scriptMatch = html.match(SSG_SCRIPT_BLOCK_RE);
-		if (scriptMatch) {
-			const replacement = buildScriptReplacement(scriptMatch[1], jsChunks, outDir, base);
-			html = html.replace(SSG_SCRIPT_BLOCK_RE, replacement);
-		} else {
-			const inlineScriptMatch = html.match(LAST_INLINE_BODY_SCRIPT_RE);
-			if (inlineScriptMatch) {
-				const replacement = buildScriptReplacement(inlineScriptMatch[1], jsChunks, outDir, base);
-				html = html.replace(LAST_INLINE_BODY_SCRIPT_RE, replacement ? `${replacement}\n</body>` : "</body>");
-			}
-		}
-		return {
-			...page,
-			html
-		};
-	});
-	const chunks = [...cssChunks.values(), ...jsChunks.values()];
-	await Promise.all(chunks.map(async (chunk) => {
-		await fs$1.mkdir(path$2.dirname(chunk.outputPath), { recursive: true });
-		await fs$1.writeFile(chunk.outputPath, chunk.content, "utf-8");
+	const optimized = (await importNapiModule()).externalizeSsgAssets(pages, outDir, base);
+	await Promise.all(optimized.assets.map(async (asset) => {
+		await fs$1.mkdir(path$1.dirname(asset.outputPath), { recursive: true });
+		await fs$1.writeFile(asset.outputPath, asset.content, "utf-8");
 	}));
 	return {
-		pages: optimizedPages,
-		assets: chunks.map((chunk) => chunk.outputPath)
+		pages: optimized.pages,
+		assets: optimized.assets.map((asset) => asset.outputPath)
 	};
 }
 /**
-* Converts a markdown file path to its corresponding HTML output path.
-*/
-function getOutputPath(inputPath, srcDir, outDir, extension) {
-	const baseName = path$2.relative(srcDir, inputPath).replace(/\.(?:md|markdown)$/i, extension);
-	if (baseName.endsWith(`index${extension}`)) return path$2.join(outDir, baseName);
-	const dirName = baseName.replace(new RegExp(`\\${extension}$`), "");
-	return path$2.join(outDir, dirName, `index${extension}`);
-}
-/**
 * Converts a markdown file path to a relative URL path.
 */
 function getUrlPath$1(inputPath, srcDir) {
-	const baseName = path$2.relative(srcDir, inputPath).replace(/\.(?:md|markdown)$/i, "");
-	if (baseName === "index" || baseName.endsWith("/index")) return baseName.replace(/\/?index$/, "") || "/";
-	return baseName;
-}
-/**
-* Converts a markdown file path to an href.
-*/
-function getHref(inputPath, srcDir, base, extension) {
-	const urlPath = getUrlPath$1(inputPath, srcDir);
-	if (urlPath === "/" || urlPath === "") return `${base}index${extension}`;
-	return `${base}${urlPath}/index${extension}`;
+	return importNapiModuleSync().getSsgUrlPath(inputPath, srcDir);
 }
 function getPageLocale(urlPath, i18n) {
 	if (!i18n) return void 0;
-	const firstSegment = urlPath.split("/").filter(Boolean)[0];
-	return i18n.locales.some((l) => l.code === firstSegment) ? firstSegment : i18n.defaultLocale;
-}
-/**
-* Gets the OG image output path for a given markdown file.
-*/
-function getOgImagePath(inputPath, srcDir, outDir) {
-	const baseName = path$2.relative(srcDir, inputPath).replace(/\.(?:md|markdown)$/i, "");
-	if (baseName === "index" || baseName.endsWith("/index")) {
-		const dirPath = baseName.replace(/\/?index$/, "") || "";
-		return path$2.join(outDir, dirPath, "og-image.png");
-	}
-	return path$2.join(outDir, baseName, "og-image.png");
-}
-/**
-* Gets the OG image URL for use in meta tags.
-* If siteUrl is provided, returns an absolute URL (required for SNS sharing).
-*/
-function getOgImageUrl(inputPath, srcDir, base, siteUrl) {
-	const urlPath = getUrlPath$1(inputPath, srcDir);
-	let relativePath;
-	if (urlPath === "/" || urlPath === "") relativePath = `${base}og-image.png`;
-	else relativePath = `${base}${urlPath}/og-image.png`;
-	if (siteUrl) return `${siteUrl.replace(/\/$/, "")}${relativePath}`;
-	return relativePath;
+	return importNapiModuleSync().getSsgPageLocale(urlPath, i18n.defaultLocale, i18n.locales.map((locale) => locale.code)) ?? void 0;
 }
-/**
-* Gets display title from file path.
-*/
-function getDisplayTitle(filePath) {
-	const fileName = path$2.basename(filePath, path$2.extname(filePath));
-	if (fileName === "index") {
-		const dirName = path$2.basename(path$2.dirname(filePath));
-		if (dirName && dirName !== ".") return formatTitle(dirName);
-		return "Home";
-	}
-	return formatTitle(fileName);
+function getRoutePaths(inputPath, srcDir, outDir, base, extension, siteUrl) {
+	return importNapiModuleSync().resolveSsgRoutePaths(inputPath, srcDir, outDir, base, extension, siteUrl);
 }
 /**
 * Formats a file/dir name as a title.
 */
 function formatTitle(name) {
-	return name.replace(/[-_]([a-z])/g, (_, char) => " " + char.toUpperCase()).replace(/^[a-z]/, (char) => char.toUpperCase());
+	return importNapiModuleSync().formatSsgTitle(name);
 }
 /**
 * Collects all markdown files from the source directory.
 */
 async function collectMarkdownFiles$1(srcDir) {
-	return (await glob(path$2.join(srcDir, "**/*.{md,markdown}"), {
+	return (await glob(path$1.join(srcDir, "**/*.{md,markdown}"), {
 		nodir: true,
 		ignore: [
 			"**/node_modules/**",
@@ -11206,110 +10542,13 @@ async function collectMarkdownFiles$1(srcDir) {
 * Builds navigation items from markdown files, grouped by directory.
 */
 function buildNavItems(markdownFiles, srcDir, base, extension) {
-	const groups = /* @__PURE__ */ new Map();
-	const groupOrder = [
-		"",
-		"examples",
-		"packages",
-		"api"
-	];
-	for (const file of markdownFiles) {
-		const parts = path$2.relative(srcDir, file).split(path$2.sep);
-		let groupKey = "";
-		if (parts.length > 1) groupKey = parts[0];
-		if (!groups.has(groupKey)) groups.set(groupKey, []);
-		const urlPath = getUrlPath$1(file, srcDir);
-		let title;
-		if (urlPath === "/" || urlPath === "") title = "Overview";
-		else title = getDisplayTitle(file);
-		groups.get(groupKey).push({
-			title,
-			path: urlPath,
-			href: getHref(file, srcDir, base, extension)
-		});
-	}
-	const sortItems = (items) => {
-		return items.sort((a, b) => {
-			const aIsRoot = a.path === "/" || a.path === "";
-			const bIsRoot = b.path === "/" || b.path === "";
-			if (aIsRoot && !bIsRoot) return -1;
-			if (!aIsRoot && bIsRoot) return 1;
-			return a.title.localeCompare(b.title);
-		});
-	};
-	const result = [];
-	for (const key of groupOrder) {
-		const items = groups.get(key);
-		if (items && items.length > 0) {
-			result.push({
-				title: key === "" ? "Guide" : formatTitle(key),
-				items: sortItems(items)
-			});
-			groups.delete(key);
-		}
-	}
-	for (const [key, items] of groups) if (items.length > 0) result.push({
-		title: formatTitle(key),
-		items: sortItems(items)
-	});
-	return result;
-}
-function isSafeSidebarLink(link) {
-	const trimmed = link.trim();
-	if (trimmed.startsWith("//")) return false;
-	return !/^[a-z][a-z0-9+.-]*:/i.test(trimmed) || /^(https?:|mailto:)/i.test(trimmed);
-}
-function sidebarPath(link) {
-	if (!link || !isSafeSidebarLink(link)) return "";
-	if (/^(https?:|mailto:|#)/i.test(link.trim())) return "";
-	const bare = link.trim().split("#", 1)[0].split("?", 1)[0].replace(/^\/+/, "").replace(/\/$/, "").replace(/\.(md|markdown)$/i, "");
-	if (!bare || bare === "index") return "/";
-	return bare.replace(/\/index$/, "");
-}
-function sidebarHref(link, base, extension) {
-	if (!link) return "#";
-	const trimmed = link.trim();
-	if (!isSafeSidebarLink(trimmed)) return "#";
-	if (/^(https?:|mailto:|#)/i.test(trimmed)) return trimmed;
-	const hash = trimmed.includes("#") ? `#${trimmed.split("#").slice(1).join("#")}` : "";
-	const withoutExt = trimmed.split("#", 1)[0].replace(/^\/+/, "").replace(/\/$/, "").replace(/\.(md|markdown)$/i, "");
-	return `${base}${!withoutExt || withoutExt === "index" ? "index" : `${withoutExt.replace(/\/index$/, "")}/index`}${extension}${hash}`;
+	return importNapiModuleSync().buildSsgNavItems(markdownFiles, srcDir, base, extension);
 }
 /**
 * Builds navigation items from an explicit theme sidebar tree.
 */
 function buildThemeNavItems(sidebar, base, extension) {
-	const toNavItem = (item) => {
-		const navItem = {
-			title: item.text ?? item.link ?? "Untitled",
-			path: sidebarPath(item.link),
-			href: sidebarHref(item.link, base, extension)
-		};
-		if (item.items?.length) navItem.children = item.items.map(toNavItem);
-		if (item.collapsed !== void 0) navItem.collapsed = item.collapsed;
-		return navItem;
-	};
-	const groups = [];
-	let looseItems = [];
-	const flushLooseItems = () => {
-		if (looseItems.length > 0) {
-			groups.push({
-				title: "Guide",
-				items: looseItems
-			});
-			looseItems = [];
-		}
-	};
-	for (const item of sidebar) if (item.items?.length && !item.link) {
-		flushLooseItems();
-		groups.push({
-			title: item.text ?? "Guide",
-			items: item.items.map(toNavItem),
-			collapsed: item.collapsed
-		});
-	} else looseItems.push(toNavItem(item));
-	flushLooseItems();
-	return groups;
+	return importNapiModuleSync().buildSsgThemeNavItems(sidebar, base, extension);
 }
 /**
 * Builds all markdown files to static HTML.
@@ -11320,8 +10559,8 @@ async function buildSsg(options, root) {
 		files: [],
 		errors: []
 	};
-	const srcDir = path$2.resolve(root, options.srcDir);
-	const outDir = path$2.resolve(root, options.outDir);
+	const srcDir = path$1.resolve(root, options.srcDir);
+	const outDir = path$1.resolve(root, options.outDir);
 	const base = options.base.endsWith("/") ? options.base : options.base + "/";
 	const generatedFiles = [];
 	const generatedPages = [];
@@ -11336,7 +10575,7 @@ async function buildSsg(options, root) {
 	const navItems = 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 {
-		const pkgPath = path$2.join(root, "package.json");
+		const pkgPath = path$1.join(root, "package.json");
 		const pkg = JSON.parse(await fs$1.readFile(pkgPath, "utf-8"));
 		if (pkg.name) siteName = formatTitle(pkg.name);
 	} catch {}
@@ -11368,8 +10607,10 @@ async function buildSsg(options, root) {
 		transformedHtml = restoreMermaidSvgs(transformedHtml, mermaidSvgs);
 		const title = extractTitle$1(transformedHtml, result.frontmatter);
 		const description = result.frontmatter.description;
+		const routePaths = getRoutePaths(inputPath, srcDir, outDir, base, ssgOptions.extension, ssgOptions.siteUrl);
 		pageResults.push({
 			inputPath,
+			routePaths,
 			transformedHtml,
 			title,
 			description,
@@ -11378,7 +10619,6 @@ async function buildSsg(options, root) {
 			toc: result.toc
 		});
 		if (shouldGenerateOgImages) {
-			const ogImageOutputPath = getOgImagePath(inputPath, srcDir, outDir);
 			const { layout: _layout, ...frontmatterRest } = result.frontmatter;
 			ogImageEntries.push({
 				props: {
@@ -11387,10 +10627,10 @@ async function buildSsg(options, root) {
 					description,
 					siteName
 				},
-				outputPath: ogImageOutputPath
+				outputPath: routePaths.ogImagePath
 			});
 			ogImageInputPaths.push(inputPath);
-			ogImageUrlMap.set(inputPath, getOgImageUrl(inputPath, srcDir, base, ssgOptions.siteUrl));
+			ogImageUrlMap.set(inputPath, routePaths.ogImageUrl);
 		}
 	} catch (err) {
 		const errorMessage = err instanceof Error ? err.message : String(err);
@@ -11419,7 +10659,7 @@ async function buildSsg(options, root) {
 		ogImageUrlMap.clear();
 	}
 	for (const pageResult of pageResults) try {
-		const { inputPath, transformedHtml, title, description, lastUpdated, frontmatter, toc } = pageResult;
+		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;
@@ -11437,16 +10677,15 @@ async function buildSsg(options, root) {
 				toc,
 				lastUpdated,
 				frontmatter,
-				path: getUrlPath$1(inputPath, srcDir),
-				href: getHref(inputPath, srcDir, base, ssgOptions.extension),
+				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);
 		}
-		const outputPath = getOutputPath(inputPath, srcDir, outDir, ssgOptions.extension);
 		generatedPages.push({
 			inputPath,
-			outputPath,
+			outputPath: routePaths.outputPath,
 			html
 		});
 	} catch (err) {
@@ -11456,7 +10695,7 @@ async function buildSsg(options, root) {
 	const optimizedOutput = await externalizeSharedPageAssets(generatedPages, outDir, base);
 	generatedFiles.push(...optimizedOutput.assets);
 	for (const page of optimizedOutput.pages) {
-		await fs$1.mkdir(path$2.dirname(page.outputPath), { recursive: true });
+		await fs$1.mkdir(path$1.dirname(page.outputPath), { recursive: true });
 		await fs$1.writeFile(page.outputPath, page.html, "utf-8");
 		generatedFiles.push(page.outputPath);
 	}
@@ -11511,7 +10750,7 @@ async function collectMarkdownFiles(dir) {
 		try {
 			const entries = await fs$1.readdir(currentDir, { withFileTypes: true });
 			for (const entry of entries) {
-				const fullPath = path$2.join(currentDir, entry.name);
+				const fullPath = path$1.join(currentDir, entry.name);
 				if (entry.isDirectory() && !entry.name.startsWith(".") && entry.name !== "node_modules") await walk(fullPath);
 				else if (entry.isFile() && entry.name.endsWith(".md")) files.push(fullPath);
 			}
@@ -11536,7 +10775,7 @@ async function buildSearchIndex(srcDir, base) {
 	const documents = [];
 	for (const file of files) try {
 		const content = await fs$1.readFile(file, "utf-8");
-		const relativePath = path$2.relative(srcDir, file);
+		const relativePath = path$1.relative(srcDir, file);
 		const url = base + relativePath.replace(/\.md$/, "").replace(/\\/g, "/");
 		const id = relativePath.replace(/\.md$/, "").replace(/\\/g, "/");
 		const extractSearchContent = napi.extractSearchContent;
@@ -11565,7 +10804,7 @@ async function buildSearchIndex(srcDir, base) {
 * Writes the search index to a file.
 */
 async function writeSearchIndex(indexJson, outDir) {
-	const indexPath = path$2.join(outDir, "search-index.json");
+	const indexPath = path$1.join(outDir, "search-index.json");
 	await fs$1.mkdir(outDir, { recursive: true });
 	await fs$1.writeFile(indexPath, indexJson, "utf-8");
 }
@@ -11574,234 +10813,7 @@ async function writeSearchIndex(indexJson, outDir) {
 * This is injected into the bundle as a virtual module.
 */
 function generateSearchModule(options, indexPath) {
-	return `
-// Search module generated by ox-content
-const searchOptions = ${JSON.stringify(options)};
-
-let searchIndex = null;
-let indexPromise = null;
-
-function parseScopedQuery(query) {
-  const scopes = [];
-  const terms = [];
-
-  for (const part of query.trim().split(/\\s+/).filter(Boolean)) {
-    if (part.startsWith('@') && part.length > 1) {
-      scopes.push(part.slice(1).toLowerCase());
-    } else {
-      terms.push(part);
-    }
-  }
-
-  return {
-    text: terms.join(' ').trim(),
-    scopes: [...new Set(scopes)],
-  };
-}
-
-function getScopesForDoc(doc) {
-  const source = (doc.id || doc.url || '').replace(/^\\/+/, '').toLowerCase();
-  const segments = source.split('/').filter(Boolean);
-
-  if (segments.length <= 1) {
-    return [];
-  }
-
-  const scopes = [];
-  let current = '';
-  for (const segment of segments.slice(0, -1)) {
-    current = current ? current + '/' + segment : segment;
-    scopes.push(current);
-  }
-
-  return scopes;
-}
-
-function matchesScopes(doc, scopes) {
-  if (!scopes.length) {
-    return true;
-  }
-
-  const docScopes = new Set(getScopesForDoc(doc));
-  return scopes.some(scope => docScopes.has(scope));
-}
-
-// Tokenizer for queries
-function tokenizeQuery(text) {
-  const tokens = [];
-  let current = '';
-
-  for (const char of text) {
-    const isCjk = /[\\u4E00-\\u9FFF\\u3400-\\u4DBF\\u3040-\\u309F\\u30A0-\\u30FF\\uAC00-\\uD7AF]/.test(char);
-
-    if (isCjk) {
-      if (current) {
-        tokens.push(current.toLowerCase());
-        current = '';
-      }
-      tokens.push(char);
-    } else if (/[a-zA-Z0-9_]/.test(char)) {
-      current += char;
-    } else if (current) {
-      tokens.push(current.toLowerCase());
-      current = '';
-    }
-  }
-
-  if (current) {
-    tokens.push(current.toLowerCase());
-  }
-
-  return tokens;
-}
-
-// BM25 scoring
-function computeIdf(df, docCount) {
-  return Math.log((docCount - df + 0.5) / (df + 0.5) + 1.0);
-}
-
-function getFieldBoost(field) {
-  switch (field) {
-    case 'Title': return 10.0;
-    case 'Heading': return 5.0;
-    case 'Body': return 1.0;
-    case 'Code': return 0.5;
-    default: return 1.0;
-  }
-}
-
-// Load the index
-async function loadIndex() {
-  if (searchIndex) return searchIndex;
-  if (indexPromise) return indexPromise;
-
-  indexPromise = fetch('${indexPath}')
-    .then(res => res.json())
-    .then(data => {
-      searchIndex = data;
-      return data;
-    })
-    .catch(err => {
-      console.error('[ox-content] Failed to load search index:', err);
-      return null;
-    });
-
-  return indexPromise;
-}
-
-// Search function
-export async function search(query, options = {}) {
-  const index = await loadIndex();
-
-  if (!index) {
-    return [];
-  }
-
-  const parsedQuery = parseScopedQuery(query);
-
-  if (!parsedQuery.text && parsedQuery.scopes.length === 0) {
-    return [];
-  }
-
-  const limit = options.limit ?? searchOptions.limit;
-  const prefix = options.prefix ?? searchOptions.prefix;
-  const tokens = tokenizeQuery(parsedQuery.text);
-
-  const k1 = 1.2;
-  const b = 0.75;
-  const docScores = new Map();
-
-  if (tokens.length === 0) {
-    index.documents.forEach((doc, docIdx) => {
-      if (matchesScopes(doc, parsedQuery.scopes)) {
-        docScores.set(docIdx, { score: 0, matches: new Set() });
-      }
-    });
-  }
-
-  for (let i = 0; i < tokens.length; i++) {
-    const token = tokens[i];
-    const isLast = i === tokens.length - 1;
-
-    // Find matching terms
-    let matchingTerms = [];
-    if (prefix && isLast && token.length >= 2) {
-      matchingTerms = Object.keys(index.index).filter(term => term.startsWith(token));
-    } else if (index.index[token]) {
-      matchingTerms = [token];
-    }
-
-    for (const term of matchingTerms) {
-      const postings = index.index[term] || [];
-      const df = index.df[term] || 1;
-      const idf = computeIdf(df, index.doc_count);
-
-      for (const posting of postings) {
-        const doc = index.documents[posting.doc_idx];
-        if (!doc) continue;
-        if (!matchesScopes(doc, parsedQuery.scopes)) continue;
-
-        const docLen = doc.body.length;
-        const tf = posting.tf;
-        const boost = getFieldBoost(posting.field);
-
-        const score = idf * ((tf * (k1 + 1.0)) / (tf + k1 * (1.0 - b + b * docLen / index.avg_dl))) * boost;
-
-        if (!docScores.has(posting.doc_idx)) {
-          docScores.set(posting.doc_idx, { score: 0, matches: new Set() });
-        }
-        const entry = docScores.get(posting.doc_idx);
-        entry.score += score;
-        entry.matches.add(term);
-      }
-    }
-  }
-
-  // Convert to results
-  const results = Array.from(docScores.entries())
-    .map(([docIdx, data]) => {
-      const doc = index.documents[docIdx];
-      const matches = Array.from(data.matches);
-      const scopes = getScopesForDoc(doc);
-
-      // Generate snippet
-      let snippet = '';
-      if (doc.body) {
-        const bodyLower = doc.body.toLowerCase();
-        let firstPos = -1;
-        for (const match of matches) {
-          const pos = bodyLower.indexOf(match);
-          if (pos !== -1 && (firstPos === -1 || pos < firstPos)) {
-            firstPos = pos;
-          }
-        }
-
-        const start = firstPos === -1 ? 0 : Math.max(0, firstPos - 50);
-        const end = Math.min(doc.body.length, start + 150);
-        snippet = doc.body.slice(start, end);
-        if (start > 0) snippet = '...' + snippet;
-        if (end < doc.body.length) snippet = snippet + '...';
-      }
-
-      return {
-        id: doc.id,
-        title: doc.title,
-        url: doc.url,
-        score: data.score,
-        matches,
-        snippet,
-        scopes,
-      };
-    })
-    .sort((a, b) => b.score - a.score || a.title.localeCompare(b.title))
-    .slice(0, limit);
-
-  return results;
-}
-
-export { searchOptions };
-export default { search, searchOptions, loadIndex };
-`;
+	return importNapiModuleSync().generateSearchModule(JSON.stringify(options), indexPath);
 }
 //#endregion
 //#region src/dev-server.ts
@@ -11867,12 +10879,12 @@ async function resolveMarkdownFile(url, srcDir) {
 	let relativePath;
 	if (pathname === "/") relativePath = "index.md";
 	else relativePath = pathname.slice(1) + ".md";
-	const filePath = path$2.join(srcDir, relativePath);
+	const filePath = path$1.join(srcDir, relativePath);
 	try {
 		await fs$1.access(filePath);
 		return filePath;
 	} catch {
-		const indexPath = path$2.join(srcDir, pathname === "/" ? "" : pathname.slice(1), "index.md");
+		const indexPath = path$1.join(srcDir, pathname === "/" ? "" : pathname.slice(1), "index.md");
 		try {
 			await fs$1.access(indexPath);
 			return indexPath;
@@ -11916,7 +10928,7 @@ function invalidatePageCache(cache, filePath) {
 async function resolveSiteName(options, root) {
 	if (options.ssg.siteName) return options.ssg.siteName;
 	try {
-		const pkgPath = path$2.join(root, "package.json");
+		const pkgPath = path$1.join(root, "package.json");
 		const pkg = JSON.parse(await fs$1.readFile(pkgPath, "utf-8"));
 		if (pkg.name) return formatTitle(pkg.name);
 	} catch {}
@@ -11926,7 +10938,7 @@ async function resolveSiteName(options, root) {
 * Render a single markdown page to full HTML.
 */
 async function renderPage$1(filePath, options, navGroups, siteName, base, root) {
-	const srcDir = path$2.resolve(root, options.srcDir);
+	const srcDir = path$1.resolve(root, options.srcDir);
 	resetTabGroupCounter();
 	resetIslandCounter();
 	const result = await transformMarkdown(await fs$1.readFile(filePath, "utf-8"), filePath, options, {
@@ -11971,7 +10983,7 @@ async function renderPage$1(filePath, options, navGroups, siteName, base, root)
 * Create the dev server middleware for SSG page serving.
 */
 function createDevServerMiddleware(options, root, cache) {
-	const srcDir = path$2.resolve(root, options.srcDir);
+	const srcDir = path$1.resolve(root, options.srcDir);
 	const base = options.base.endsWith("/") ? options.base : options.base + "/";
 	return async (req, res, next) => {
 		const url = req.url;
@@ -12036,7 +11048,7 @@ function extractTitle(content, frontmatter) {
 	return match ? match[1].trim() : "";
 }
 function getUrlPath(filePath, srcDir) {
-	let rel = path$2.relative(srcDir, filePath).replace(/\\/g, "/");
+	let rel = path$1.relative(srcDir, filePath).replace(/\\/g, "/");
 	rel = rel.replace(/\.md$/, "");
 	if (rel === "index") return "/";
 	if (rel.endsWith("/index")) rel = rel.slice(0, -6);
@@ -12076,7 +11088,7 @@ function validatePage(page, options) {
 	return warnings;
 }
 async function collectPages(options, root) {
-	const srcDir = path$2.resolve(root, options.srcDir);
+	const srcDir = path$1.resolve(root, options.srcDir);
 	const files = await glob("**/*.md", {
 		cwd: srcDir,
 		absolute: true
@@ -12094,7 +11106,7 @@ async function collectPages(options, root) {
 		const urlPath = getUrlPath(file, srcDir);
 		const ogImageUrl = computeOgImageUrl(urlPath, options.base, options.ssg.siteUrl, generateOgImage, options.ssg.ogImage);
 		const page = {
-			path: path$2.relative(srcDir, file),
+			path: path$1.relative(srcDir, file),
 			urlPath,
 			title,
 			description,
@@ -12407,7 +11419,7 @@ function createI18nPlugin(resolvedOptions) {
 		},
 		async buildStart() {
 			if (!i18nOptions || !i18nOptions.check) return;
-			const dictDir = path$2.resolve(root, i18nOptions.dir);
+			const dictDir = path$1.resolve(root, i18nOptions.dir);
 			if (!fs$2.existsSync(dictDir)) {
 				console.warn(`[ox-content:i18n] Dictionary directory not found: ${dictDir}`);
 				return;
@@ -12429,7 +11441,7 @@ function createI18nPlugin(resolvedOptions) {
 		},
 		configureServer(server) {
 			if (!i18nOptions) return;
-			const dictDir = path$2.resolve(root, i18nOptions.dir);
+			const dictDir = path$1.resolve(root, i18nOptions.dir);
 			if (fs$2.existsSync(dictDir)) {
 				server.watcher.add(dictDir);
 				server.watcher.on("change", (filePath) => {
@@ -12456,206 +11468,31 @@ function createI18nPlugin(resolvedOptions) {
 * Generates the virtual module for i18n configuration.
 */
 function generateI18nModule(options, root) {
-	const dictDir = path$2.resolve(root, options.dir);
-	const localesJson = JSON.stringify(options.locales);
-	const defaultLocale = JSON.stringify(options.defaultLocale);
-	let dictionariesCode = "{}";
+	const dictDir = path$1.resolve(root, options.dir);
+	const config = {
+		defaultLocale: options.defaultLocale,
+		locales: options.locales,
+		hideDefaultLocale: options.hideDefaultLocale
+	};
 	try {
 		const napi = __require("@ox-content/napi");
-		if (napi.loadDictionariesFlat) {
-			const dictData = napi.loadDictionariesFlat(dictDir);
-			dictionariesCode = JSON.stringify(dictData);
-		} else dictionariesCode = JSON.stringify(loadDictionariesFallback(options, dictDir));
-	} catch {
-		try {
-			dictionariesCode = JSON.stringify(loadDictionariesFallback(options, dictDir));
-		} catch {}
-	}
-	return `
-export const i18nConfig = {
-  enabled: true,
-  defaultLocale: ${defaultLocale},
-  locales: ${localesJson},
-  hideDefaultLocale: ${JSON.stringify(options.hideDefaultLocale)},
-};
-
-export const dictionaries = ${dictionariesCode};
-
-export function t(key, params, locale) {
-  const dict = dictionaries[locale || i18nConfig.defaultLocale] || {};
-  let message = dict[key];
-  if (!message) {
-    const fallback = dictionaries[i18nConfig.defaultLocale] || {};
-    message = fallback[key] || key;
-  }
-  if (params) {
-    for (const [k, v] of Object.entries(params)) {
-      message = message.split('{$' + k + '}').join(String(v));
-    }
-  }
-  return message;
-}
-
-export function getLocaleFromPath(pathname) {
-  const match = pathname.match(new RegExp('^/([A-Za-z]{2,3}(?:-[A-Za-z0-9]+)*)(/|$)'));
-  if (match) {
-    const code = match[1];
-    if (i18nConfig.locales.some(l => l.code === code)) {
-      return code;
-    }
-  }
-  return i18nConfig.defaultLocale;
-}
-
-export function localePath(pathname, locale) {
-  const current = getLocaleFromPath(pathname);
-  let clean = pathname;
-  if (current !== i18nConfig.defaultLocale || !i18nConfig.hideDefaultLocale) {
-    const prefix = '/' + current;
-    if (clean === prefix) clean = '/';
-    else if (clean.startsWith(prefix + '/')) clean = clean.slice(prefix.length);
-  }
-  if (locale === i18nConfig.defaultLocale && i18nConfig.hideDefaultLocale) {
-    return clean || '/';
-  }
-  return '/' + locale + (clean.startsWith('/') ? clean : '/' + clean);
-}
-
-const formatterCache = new Map();
-
-function getFormatter(kind, locale, options) {
-  const key = kind + ':' + locale + ':' + JSON.stringify(options || {});
-  if (!formatterCache.has(key)) {
-    formatterCache.set(key, new Intl[kind](locale, options));
-  }
-  return formatterCache.get(key);
-}
-
-export function getLocaleMeta(locale) {
-  const code = locale || i18nConfig.defaultLocale;
-  return i18nConfig.locales.find(l => l.code === code) || { code, name: code, dir: 'ltr' };
-}
-
-export function formatDate(value, options, locale) {
-  return getFormatter('DateTimeFormat', locale || i18nConfig.defaultLocale, options).format(
-    value instanceof Date ? value : new Date(value),
-  );
-}
-
-export function formatDateParts(value, options, locale) {
-  return getFormatter('DateTimeFormat', locale || i18nConfig.defaultLocale, options).formatToParts(
-    value instanceof Date ? value : new Date(value),
-  );
-}
-
-export function formatNumber(value, options, locale) {
-  return getFormatter('NumberFormat', locale || i18nConfig.defaultLocale, options).format(value);
-}
-
-export function formatNumberParts(value, options, locale) {
-  return getFormatter('NumberFormat', locale || i18nConfig.defaultLocale, options).formatToParts(value);
-}
-
-export function formatRelativeTime(value, unit, options, locale) {
-  return getFormatter('RelativeTimeFormat', locale || i18nConfig.defaultLocale, options).format(value, unit);
-}
-
-export function formatList(values, options, locale) {
-  return getFormatter('ListFormat', locale || i18nConfig.defaultLocale, options).format(values);
-}
-
-export function formatListParts(values, options, locale) {
-  return getFormatter('ListFormat', locale || i18nConfig.defaultLocale, options).formatToParts(values);
-}
-
-export function formatDisplayName(value, type, options, locale) {
-  if (!Intl.DisplayNames) return String(value);
-  const displayType = type || 'language';
-  return getFormatter('DisplayNames', locale || i18nConfig.defaultLocale, { type: displayType, ...options }).of(value) || String(value);
-}
-
-export function createIntl(locale, defaults = {}) {
-  const meta = getLocaleMeta(locale);
-  const code = meta.code;
-  return {
-    locale: code,
-    meta,
-    dir: meta.dir || 'ltr',
-    date: (value, options) => formatDate(value, { ...defaults.date, ...options }, code),
-    dateParts: (value, options) => formatDateParts(value, { ...defaults.date, ...options }, code),
-    number: (value, options) => formatNumber(value, { ...defaults.number, ...options }, code),
-    numberParts: (value, options) => formatNumberParts(value, { ...defaults.number, ...options }, code),
-    relativeTime: (value, unit, options) => formatRelativeTime(value, unit, { ...defaults.relativeTime, ...options }, code),
-    list: (values, options) => formatList(values, { ...defaults.list, ...options }, code),
-    listParts: (values, options) => formatListParts(values, { ...defaults.list, ...options }, code),
-    displayName: (value, type, options) => formatDisplayName(value, type, { ...defaults.displayName, ...options }, code),
-  };
-}
-
-export default {
-  i18nConfig,
-  dictionaries,
-  t,
-  getLocaleFromPath,
-  localePath,
-  getLocaleMeta,
-  createIntl,
-  formatDate,
-  formatDateParts,
-  formatNumber,
-  formatNumberParts,
-  formatRelativeTime,
-  formatList,
-  formatListParts,
-  formatDisplayName,
-};
-  `;
-}
-/**
-* Flattens a nested object into dot-separated keys.
-*/
-function flattenObject(obj, prefix, result) {
-	for (const [key, value] of Object.entries(obj)) {
-		const fullKey = `${prefix}.${key}`;
-		if (typeof value === "string") result[fullKey] = value;
-		else if (typeof value === "object" && value !== null && !Array.isArray(value)) flattenObject(value, fullKey, result);
-		else result[fullKey] = String(value);
-	}
-}
-/**
-* Fallback dictionary loading using TS-based JSON file reading.
-*/
-function loadDictionariesFallback(options, dictDir) {
-	const dictData = {};
-	for (const locale of options.locales) {
-		const localeDir = path$2.join(dictDir, locale.code);
-		if (!fs$2.existsSync(localeDir)) continue;
-		const files = fs$2.readdirSync(localeDir);
-		const localeDict = {};
-		for (const file of files) {
-			if (!file.endsWith(".json")) continue;
-			const filePath = path$2.join(localeDir, file);
-			const content = fs$2.readFileSync(filePath, "utf-8");
-			const namespace = path$2.basename(file, ".json");
-			try {
-				flattenObject(JSON.parse(content), namespace, localeDict);
-			} catch {}
-		}
-		dictData[locale.code] = localeDict;
+		if (typeof napi.generateI18nModule === "function") return napi.generateI18nModule(dictDir, config);
+	} catch (error) {
+		throw new Error(`[ox-content:i18n] Failed to load @ox-content/napi for i18n module generation: ${String(error)}`);
 	}
-	return dictData;
+	throw new Error("[ox-content:i18n] @ox-content/napi does not expose generateI18nModule. Please rebuild the NAPI package.");
 }
 /**
 * Collects translation keys from source files using NAPI extractTranslationKeys.
 */
 function collectKeysFromSource(root, extractTranslationKeys, options) {
-	const srcDir = path$2.resolve(root, "src");
+	const srcDir = path$1.resolve(root, "src");
 	const keys = /* @__PURE__ */ new Set();
 	if (fs$2.existsSync(srcDir)) walkDir(srcDir, /\.(ts|tsx|js|jsx)$/, (filePath) => {
 		const usages = extractTranslationKeys(fs$2.readFileSync(filePath, "utf-8"), filePath, options.functionNames);
 		for (const usage of usages) keys.add(usage.key);
 	});
-	const contentDir = path$2.resolve(root, "content");
+	const contentDir = path$1.resolve(root, "content");
 	if (fs$2.existsSync(contentDir)) {
 		const tPattern = /\{\{t\(['"]([^'"]+)['"]\)\}\}/g;
 		walkDir(contentDir, /\.(md|mdx)$/, (filePath) => {
@@ -12673,7 +11510,7 @@ function collectKeysFromSource(root, extractTranslationKeys, options) {
 function walkDir(dir, pattern, callback) {
 	const entries = fs$2.readdirSync(dir, { withFileTypes: true });
 	for (const entry of entries) {
-		const fullPath = path$2.join(dir, entry.name);
+		const fullPath = path$1.join(dir, entry.name);
 		if (entry.isDirectory()) {
 			if (entry.name === "node_modules" || entry.name === ".git") continue;
 			walkDir(fullPath, pattern, callback);
@@ -12926,7 +11763,7 @@ const DEFAULT_LINT_FILE_EXCLUDE = [
 */
 function shouldLintMarkdownFile(filePath, options = {}) {
 	const resolvedOptions = resolveMarkdownLintFileOptions(options);
-	return shouldLintAbsoluteFile(path$1.resolve(resolvedOptions.cwd, filePath), resolvedOptions);
+	return shouldLintAbsoluteFile(path.resolve(resolvedOptions.cwd, filePath), resolvedOptions);
 }
 /**
 * Lints a single Markdown file using project-style include/exclude settings.
@@ -12936,7 +11773,7 @@ function shouldLintMarkdownFile(filePath, options = {}) {
 */
 async function lintMarkdownFile(filePath, options = {}) {
 	const resolvedOptions = resolveMarkdownLintFileOptions(options);
-	return lintMarkdownFileWithResolvedOptions(path$1.resolve(resolvedOptions.cwd, filePath), resolvedOptions);
+	return lintMarkdownFileWithResolvedOptions(path.resolve(resolvedOptions.cwd, filePath), resolvedOptions);
 }
 /**
 * Lints all Markdown files matched by the configured include/exclude patterns.
@@ -12967,7 +11804,7 @@ async function lintMarkdownFiles(options = {}) {
 }
 function resolveMarkdownLintFileOptions(options) {
 	return {
-		cwd: path$1.resolve(options.cwd ?? process.cwd()),
+		cwd: path.resolve(options.cwd ?? process.cwd()),
 		exclude: [...new Set([...options.exclude ?? DEFAULT_LINT_FILE_EXCLUDE, ...options.ignore ?? []])],
 		include: [...new Set(options.include ?? DEFAULT_LINT_FILE_INCLUDE)],
 		lintOptions: {
@@ -12978,8 +11815,8 @@ function resolveMarkdownLintFileOptions(options) {
 	};
 }
 async function lintMarkdownFileWithResolvedOptions(filePath, options) {
-	const absoluteFilePath = path$1.resolve(filePath);
-	const relativePath = normalizePath(path$1.relative(options.cwd, absoluteFilePath));
+	const absoluteFilePath = path.resolve(filePath);
+	const relativePath = normalizePath(path.relative(options.cwd, absoluteFilePath));
 	if (!shouldLintAbsoluteFile(absoluteFilePath, options)) return {
 		...createEmptyLintResult(),
 		filePath: absoluteFilePath,
@@ -13003,26 +11840,26 @@ async function collectMarkdownLintFileEntries(options) {
 			nodir: true
 		});
 		for (const filePath of matches) {
-			const absoluteFilePath = path$1.resolve(filePath);
+			const absoluteFilePath = path.resolve(filePath);
 			if (shouldLintAbsoluteFile(absoluteFilePath, options)) files.set(absoluteFilePath, {
 				filePath: absoluteFilePath,
-				relativePath: normalizePath(path$1.relative(options.cwd, absoluteFilePath))
+				relativePath: normalizePath(path.relative(options.cwd, absoluteFilePath))
 			});
 		}
 	}
 	return [...files.values()].sort((left, right) => left.filePath.localeCompare(right.filePath));
 }
 function shouldLintAbsoluteFile(filePath, options) {
-	const absolutePath = normalizePath(path$1.resolve(filePath));
-	const relativePath = normalizePath(path$1.relative(options.cwd, absolutePath));
+	const absolutePath = normalizePath(path.resolve(filePath));
+	const relativePath = normalizePath(path.relative(options.cwd, absolutePath));
 	const matches = (patterns) => patterns.some((pattern) => {
 		const normalizedPattern = normalizePath(pattern);
-		return path$1.matchesGlob(relativePath, normalizedPattern) || path$1.matchesGlob(absolutePath, normalizedPattern);
+		return path.matchesGlob(relativePath, normalizedPattern) || path.matchesGlob(absolutePath, normalizedPattern);
 	});
 	return matches(options.include) && !matches(options.exclude);
 }
 function normalizePath(value) {
-	return value.split(path$1.sep).join("/");
+	return value.split(path.sep).join("/");
 }
 function createEmptyLintResult() {
 	return {
@@ -13607,8 +12444,8 @@ function oxContent(options = {}) {
 	async function regenerateDocs(root) {
 		const docsOptions = resolvedOptions.docs;
 		if (!docsOptions || !docsOptions.enabled) return 0;
-		const srcDirs = docsOptions.src.map((src) => path$2.resolve(root, src));
-		const outDir = path$2.resolve(root, docsOptions.out);
+		const srcDirs = docsOptions.src.map((src) => path$1.resolve(root, src));
+		const outDir = path$1.resolve(root, docsOptions.out);
 		const extracted = await extractDocs(srcDirs, docsOptions);
 		const generated = generateMarkdown(extracted, docsOptions);
 		await writeDocs(generated, outDir, extracted, docsOptions);
@@ -13677,7 +12514,7 @@ function oxContent(options = {}) {
 			const docsOptions = resolvedOptions.docs;
 			if (!docsOptions || !docsOptions.enabled) return;
 			const root = config?.root || process.cwd();
-			const srcDirs = docsOptions.src.map((src) => path$2.resolve(root, src));
+			const srcDirs = docsOptions.src.map((src) => path$1.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;
@@ -13693,7 +12530,7 @@ function oxContent(options = {}) {
 		configureServer(devServer) {
 			if (!resolvedOptions.ssg.enabled) return;
 			const root = config?.root || process.cwd();
-			const srcDir = path$2.resolve(root, resolvedOptions.srcDir);
+			const srcDir = path$1.resolve(root, resolvedOptions.srcDir);
 			devServer.middlewares.use(createDevServerMiddleware(resolvedOptions, root, ssgDevCache));
 			devServer.watcher.on("add", (file) => {
 				if (file.startsWith(srcDir) && file.endsWith(".md")) {
@@ -13760,7 +12597,7 @@ function oxContent(options = {}) {
 			async buildStart() {
 				if (!resolvedOptions.search.enabled) return;
 				const root = config?.root || process.cwd();
-				const srcDir = path$2.resolve(root, resolvedOptions.srcDir);
+				const srcDir = path$1.resolve(root, resolvedOptions.srcDir);
 				try {
 					searchIndexJson = await buildSearchIndex(srcDir, resolvedOptions.base);
 					console.log("[ox-content] Search index built");
@@ -13771,10 +12608,10 @@ function oxContent(options = {}) {
 			async closeBundle() {
 				if (!resolvedOptions.search.enabled || !searchIndexJson) return;
 				const root = config?.root || process.cwd();
-				const outDir = path$2.resolve(root, resolvedOptions.outDir);
+				const outDir = path$1.resolve(root, resolvedOptions.outDir);
 				try {
 					await writeSearchIndex(searchIndexJson, outDir);
-					console.log("[ox-content] Search index written to", path$2.join(outDir, "search-index.json"));
+					console.log("[ox-content] Search index written to", path$1.join(outDir, "search-index.json"));
 				} catch (err) {
 					console.warn("[ox-content] Failed to write search index:", err);
 				}