@ox-content/vite-plugin 2.8.0 → 2.9.0

package/dist/index.cjs

@@ -17,7 +17,6 @@ let node_path = require("node:path");
 node_path = require_chunk.__toESM(node_path);
 let fs = require("fs");
 fs = require_chunk.__toESM(fs);
-let node_crypto = require("node:crypto");
 let fs_promises = require("fs/promises");
 fs_promises = require_chunk.__toESM(fs_promises);
 let glob = require("glob");
@@ -7087,241 +7086,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)}`
-	}));
+	return require_mermaid.importNapiModuleSync().generateDocsNavMetadata(docs.map((doc) => doc.file), basePath);
 }
-/**
-* 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.default.basename(filePath, path.default.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());
-}
-/**
-* 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.default.basename(filePath, path.default.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 require_mermaid.importNapiModuleSync().generateDocsNavCode(navItems, exportName);
 }
 //#endregion
 //#region src/docs.ts
@@ -7648,86 +7417,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.
 *
@@ -7794,13 +7483,13 @@ function mergeParam(params, next) {
 * ```
 */
 async function extractDocs(srcDirs, options) {
-	const extractFileDocs = (await require_mermaid.importNapiModule()).extractFileDocs;
-	if (!extractFileDocs) throw new Error("[ox-content] extractFileDocs is not available from @ox-content/napi.");
+	const extractFileDocEntries = (await require_mermaid.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
@@ -7851,132 +7540,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.
 */
@@ -10857,10 +10420,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 require_mermaid.importNapiModuleSync().extractSsgTitle(content, typeof frontmatter.title === "string" ? frontmatter.title : void 0);
 }
 /**
 * Generates bare HTML page (no navigation, no styles).
@@ -10946,223 +10506,35 @@ 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 (0, node_crypto.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.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_promises.mkdir(path.dirname(chunk.outputPath), { recursive: true });
-		await fs_promises.writeFile(chunk.outputPath, chunk.content, "utf-8");
+	const optimized = (await require_mermaid.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");
 	}));
 	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.relative(srcDir, inputPath).replace(/\.(?:md|markdown)$/i, extension);
-	if (baseName.endsWith(`index${extension}`)) return path.join(outDir, baseName);
-	const dirName = baseName.replace(new RegExp(`\\${extension}$`), "");
-	return path.join(outDir, dirName, `index${extension}`);
-}
-/**
 * Converts a markdown file path to a relative URL path.
 */
 function getUrlPath$1(inputPath, srcDir) {
-	const baseName = path.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 require_mermaid.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.relative(srcDir, inputPath).replace(/\.(?:md|markdown)$/i, "");
-	if (baseName === "index" || baseName.endsWith("/index")) {
-		const dirPath = baseName.replace(/\/?index$/, "") || "";
-		return path.join(outDir, dirPath, "og-image.png");
-	}
-	return path.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 require_mermaid.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.basename(filePath, path.extname(filePath));
-	if (fileName === "index") {
-		const dirName = path.basename(path.dirname(filePath));
-		if (dirName && dirName !== ".") return formatTitle(dirName);
-		return "Home";
-	}
-	return formatTitle(fileName);
+function getRoutePaths(inputPath, srcDir, outDir, base, extension, siteUrl) {
+	return require_mermaid.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 require_mermaid.importNapiModuleSync().formatSsgTitle(name);
 }
 /**
 * Collects all markdown files from the source directory.
@@ -11181,110 +10553,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.relative(srcDir, file).split(path.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 require_mermaid.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 require_mermaid.importNapiModuleSync().buildSsgThemeNavItems(sidebar, base, extension);
 }
 /**
 * Builds all markdown files to static HTML.
@@ -11343,8 +10618,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,
@@ -11353,7 +10630,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: {
@@ -11362,10 +10638,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);
@@ -11394,7 +10670,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;
@@ -11412,16 +10688,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) {
@@ -11549,234 +10824,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 require_mermaid.importNapiModuleSync().generateSearchModule(JSON.stringify(options), indexPath);
 }
 //#endregion
 //#region src/dev-server.ts
@@ -12432,193 +11480,18 @@ function createI18nPlugin(resolvedOptions) {
 */
 function generateI18nModule(options, root) {
 	const dictDir = path.resolve(root, options.dir);
-	const localesJson = JSON.stringify(options.locales);
-	const defaultLocale = JSON.stringify(options.defaultLocale);
-	let dictionariesCode = "{}";
+	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.join(dictDir, locale.code);
-		if (!fs.existsSync(localeDir)) continue;
-		const files = fs.readdirSync(localeDir);
-		const localeDict = {};
-		for (const file of files) {
-			if (!file.endsWith(".json")) continue;
-			const filePath = path.join(localeDir, file);
-			const content = fs.readFileSync(filePath, "utf-8");
-			const namespace = path.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.
@@ -13814,9 +12687,9 @@ function resolveCodeAnnotationsOptions(options) {
 /**
 * Generates virtual module content.
 */
-function generateVirtualModule(path$2, options) {
-	if (path$2 === "config") return `export default ${JSON.stringify(options)};`;
-	if (path$2 === "runtime") {
+function generateVirtualModule(path$1, options) {
+	if (path$1 === "config") return `export default ${JSON.stringify(options)};`;
+	if (path$1 === "runtime") {
 		const base = normalizeRuntimeBase(options.base);
 		return `
       export const base = ${JSON.stringify(base)};