@ox-content/vite-plugin 0.0.1-alpha.0

package/dist/index.js

@@ -0,0 +1,2468 @@
+// src/index.ts
+import * as path5 from "path";
+
+// src/environment.ts
+function createMarkdownEnvironment(options) {
+  return {
+    // Consumer type for this environment
+    consumer: "server",
+    // Build configuration
+    build: {
+      // Output to a separate directory
+      outDir: `${options.outDir}/.markdown`,
+      // Emit assets for SSG
+      emitAssets: true,
+      // Create manifest for asset tracking
+      manifest: true,
+      // SSR-like externalization
+      rollupOptions: {
+        external: [
+          // Externalize Node.js built-ins
+          /^node:/,
+          // Externalize native modules
+          /\.node$/
+        ]
+      }
+    },
+    // Resolve configuration
+    resolve: {
+      // Handle .md files
+      extensions: [".md", ".markdown"],
+      // Conditions for module resolution
+      conditions: ["markdown", "node", "import"],
+      // Don't dedupe - each environment gets its own modules
+      dedupe: []
+    },
+    // Optimize dependencies
+    optimizeDeps: {
+      // Include ox-content dependencies
+      include: [],
+      // Exclude native modules
+      exclude: ["@ox-content/napi"]
+    }
+  };
+}
+
+// src/highlight.ts
+import { unified } from "unified";
+import rehypeParse from "rehype-parse";
+import rehypeStringify from "rehype-stringify";
+import { createHighlighter } from "shiki";
+var highlighterPromise = null;
+async function getHighlighter(theme) {
+  if (!highlighterPromise) {
+    highlighterPromise = createHighlighter({
+      themes: [theme],
+      langs: [
+        "javascript",
+        "typescript",
+        "jsx",
+        "tsx",
+        "vue",
+        "svelte",
+        "html",
+        "css",
+        "scss",
+        "json",
+        "yaml",
+        "markdown",
+        "bash",
+        "shell",
+        "rust",
+        "python",
+        "go",
+        "java",
+        "c",
+        "cpp",
+        "sql",
+        "graphql",
+        "diff",
+        "toml"
+      ]
+    });
+  }
+  return highlighterPromise;
+}
+function rehypeShikiHighlight(options) {
+  const { theme } = options;
+  return async (tree) => {
+    const highlighter = await getHighlighter(theme);
+    const visit = async (node) => {
+      if ("children" in node) {
+        for (let i = 0; i < node.children.length; i++) {
+          const child = node.children[i];
+          if (child.type === "element" && child.tagName === "pre") {
+            const codeElement = child.children.find(
+              (c) => c.type === "element" && c.tagName === "code"
+            );
+            if (codeElement) {
+              const className = codeElement.properties?.className;
+              let lang = "text";
+              if (Array.isArray(className)) {
+                const langClass = className.find(
+                  (c) => typeof c === "string" && c.startsWith("language-")
+                );
+                if (langClass && typeof langClass === "string") {
+                  lang = langClass.replace("language-", "");
+                }
+              }
+              const codeText = getTextContent(codeElement);
+              try {
+                const highlighted = highlighter.codeToHtml(codeText, {
+                  lang,
+                  theme
+                });
+                const parsed = unified().use(rehypeParse, { fragment: true }).parse(highlighted);
+                if (parsed.children[0]) {
+                  node.children[i] = parsed.children[0];
+                }
+              } catch {
+              }
+            }
+          } else if (child.type === "element") {
+            await visit(child);
+          }
+        }
+      }
+    };
+    await visit(tree);
+  };
+}
+function getTextContent(node) {
+  let text = "";
+  if ("children" in node) {
+    for (const child of node.children) {
+      if (child.type === "text") {
+        text += child.value;
+      } else if (child.type === "element") {
+        text += getTextContent(child);
+      }
+    }
+  }
+  return text;
+}
+async function highlightCode(html, theme = "github-dark") {
+  const result = await unified().use(rehypeParse, { fragment: true }).use(rehypeShikiHighlight, { theme }).use(rehypeStringify).process(html);
+  return String(result);
+}
+
+// src/mermaid.ts
+import { unified as unified2 } from "unified";
+import rehypeParse2 from "rehype-parse";
+import rehypeStringify2 from "rehype-stringify";
+function getTextContent2(node) {
+  let text = "";
+  if ("children" in node) {
+    for (const child of node.children) {
+      if (child.type === "text") {
+        text += child.value;
+      } else if (child.type === "element") {
+        text += getTextContent2(child);
+      }
+    }
+  }
+  return text;
+}
+function rehypeMermaid() {
+  return (tree) => {
+    const visit = (node) => {
+      if ("children" in node) {
+        for (let i = 0; i < node.children.length; i++) {
+          const child = node.children[i];
+          if (child.type === "element" && child.tagName === "pre") {
+            const codeElement = child.children.find(
+              (c) => c.type === "element" && c.tagName === "code"
+            );
+            if (codeElement) {
+              const className = codeElement.properties?.className;
+              let isMermaid = false;
+              if (Array.isArray(className)) {
+                isMermaid = className.some(
+                  (c) => typeof c === "string" && c.includes("mermaid")
+                );
+              }
+              if (isMermaid) {
+                const mermaidCode = getTextContent2(codeElement);
+                const wrapper = {
+                  type: "element",
+                  tagName: "div",
+                  properties: {
+                    className: ["ox-mermaid"],
+                    "data-mermaid": mermaidCode
+                  },
+                  children: [
+                    {
+                      type: "element",
+                      tagName: "pre",
+                      properties: {
+                        className: ["ox-mermaid-source"]
+                      },
+                      children: [
+                        {
+                          type: "text",
+                          value: mermaidCode
+                        }
+                      ]
+                    }
+                  ]
+                };
+                node.children[i] = wrapper;
+              }
+            }
+          } else if (child.type === "element") {
+            visit(child);
+          }
+        }
+      }
+    };
+    visit(tree);
+  };
+}
+async function transformMermaid(html) {
+  const result = await unified2().use(rehypeParse2, { fragment: true }).use(rehypeMermaid).use(rehypeStringify2).process(html);
+  return String(result);
+}
+
+// src/transform.ts
+var napiBindings;
+var napiLoadAttempted = false;
+async function loadNapiBindings() {
+  if (napiLoadAttempted) {
+    return napiBindings ?? null;
+  }
+  napiLoadAttempted = true;
+  try {
+    const mod = await import("@ox-content/napi");
+    napiBindings = mod;
+    return mod;
+  } catch (error) {
+    if (process.env.DEBUG) {
+      console.debug("[ox-content] NAPI bindings load failed:", error);
+    }
+    napiBindings = null;
+    return null;
+  }
+}
+async function transformMarkdown(source, filePath, options, ssgOptions) {
+  const napi = await loadNapiBindings();
+  if (!napi) {
+    throw new Error("[ox-content] NAPI bindings not available. Please ensure @ox-content/napi is built.");
+  }
+  const result = napi.transform(source, {
+    gfm: options.gfm,
+    footnotes: options.footnotes,
+    taskLists: options.taskLists,
+    tables: options.tables,
+    strikethrough: options.strikethrough,
+    tocMaxDepth: options.tocMaxDepth,
+    convertMdLinks: ssgOptions?.convertMdLinks,
+    baseUrl: ssgOptions?.baseUrl
+  });
+  if (result.errors.length > 0) {
+    console.warn("[ox-content] Transform warnings:", result.errors);
+  }
+  let html = result.html;
+  let frontmatter;
+  try {
+    frontmatter = JSON.parse(result.frontmatter);
+  } catch {
+    frontmatter = {};
+  }
+  const flatToc = result.toc.map((item) => ({
+    ...item,
+    children: []
+  }));
+  const toc = options.toc ? buildTocTree(flatToc) : [];
+  if (options.highlight) {
+    html = await highlightCode(html, options.highlightTheme);
+  }
+  if (options.mermaid) {
+    html = await transformMermaid(html);
+  }
+  const code = generateModuleCode(html, frontmatter, toc, filePath, options);
+  return {
+    code,
+    html,
+    frontmatter,
+    toc
+  };
+}
+function buildTocTree(entries) {
+  const root = [];
+  const stack = [];
+  for (const entry of entries) {
+    while (stack.length > 0 && stack[stack.length - 1].depth >= entry.depth) {
+      stack.pop();
+    }
+    if (stack.length === 0) {
+      root.push(entry);
+    } else {
+      stack[stack.length - 1].children.push(entry);
+    }
+    stack.push(entry);
+  }
+  return root;
+}
+function generateModuleCode(html, frontmatter, toc, filePath, _options) {
+  const htmlJson = JSON.stringify(html);
+  const frontmatterJson = JSON.stringify(frontmatter);
+  const tocJson = JSON.stringify(toc);
+  return `
+// Generated by vite-plugin-ox-content
+// Source: ${filePath}
+
+/**
+ * Rendered HTML content.
+ */
+export const html = ${htmlJson};
+
+/**
+ * Parsed frontmatter.
+ */
+export const frontmatter = ${frontmatterJson};
+
+/**
+ * Table of contents.
+ */
+export const toc = ${tocJson};
+
+/**
+ * Default export with all data.
+ */
+export default {
+  html,
+  frontmatter,
+  toc,
+};
+
+// HMR support
+if (import.meta.hot) {
+  import.meta.hot.accept((newModule) => {
+    if (newModule) {
+      // Trigger re-render with new content
+      import.meta.hot.invalidate();
+    }
+  });
+}
+`;
+}
+async function generateOgImageSvg(data, config) {
+  const napi = await loadNapiBindings();
+  if (!napi) {
+    return null;
+  }
+  const napiConfig = config ? {
+    width: config.width,
+    height: config.height,
+    backgroundColor: config.backgroundColor,
+    textColor: config.textColor,
+    titleFontSize: config.titleFontSize,
+    descriptionFontSize: config.descriptionFontSize
+  } : void 0;
+  return napi.generateOgImageSvg(data, napiConfig);
+}
+
+// src/docs.ts
+import * as fs from "fs";
+import * as path2 from "path";
+
+// src/nav-generator.ts
+import path from "path";
+function generateNavMetadata(docs, basePath = "/api") {
+  const sortedDocs = [...docs].sort((a, b) => {
+    const aName = getDocDisplayName(a.file);
+    const bName = getDocDisplayName(b.file);
+    return aName.localeCompare(bName);
+  });
+  return sortedDocs.map((doc) => ({
+    title: getDocDisplayName(doc.file),
+    path: `${basePath}/${getDocFileName(doc.file)}`
+  }));
+}
+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());
+}
+function getDocFileName(filePath) {
+  const fileName = path.basename(filePath, path.extname(filePath));
+  if (fileName === "index") {
+    return "index";
+  }
+  return fileName;
+}
+function generateNavCode(navItems, exportName = "apiNav") {
+  const json = JSON.stringify(navItems, null, 2);
+  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} as const;
+`;
+}
+
+// src/docs.ts
+var JSDOC_BLOCK = /^[ \t]*\/\*\*\s*([\s\S]*?)\s*\*\//gm;
+async function extractDocs(srcDirs, options) {
+  const results = [];
+  for (const srcDir of srcDirs) {
+    const files = await findFiles(srcDir, options);
+    for (const file of files) {
+      const content = await fs.promises.readFile(file, "utf-8");
+      const entries = extractFromContent(content, file, options);
+      if (entries.length > 0) {
+        results.push({ file, entries });
+      }
+    }
+  }
+  return results;
+}
+async function findFiles(dir, options) {
+  const files = [];
+  async function walk(currentDir) {
+    let entries;
+    try {
+      entries = await fs.promises.readdir(currentDir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      const fullPath = path2.join(currentDir, entry.name);
+      if (entry.isDirectory()) {
+        if (!isExcluded(fullPath, options.exclude)) {
+          await walk(fullPath);
+        }
+      } else if (entry.isFile()) {
+        if (isIncluded(fullPath, options.include) && !isExcluded(fullPath, options.exclude)) {
+          files.push(fullPath);
+        }
+      }
+    }
+  }
+  await walk(dir);
+  return files;
+}
+function isIncluded(file, patterns) {
+  return patterns.some((pattern) => {
+    if (pattern.includes("**")) {
+      const ext = pattern.split(".").pop();
+      return file.endsWith(`.${ext}`);
+    }
+    return file.endsWith(pattern.replace("*", ""));
+  });
+}
+function isExcluded(file, patterns) {
+  return patterns.some((pattern) => {
+    if (pattern.includes("node_modules")) {
+      return file.includes("node_modules");
+    }
+    if (pattern.includes(".test.") || pattern.includes(".spec.")) {
+      return file.includes(".test.") || file.includes(".spec.");
+    }
+    return false;
+  });
+}
+function extractFromContent(content, file, options) {
+  const entries = [];
+  let match;
+  JSDOC_BLOCK.lastIndex = 0;
+  while ((match = JSDOC_BLOCK.exec(content)) !== null) {
+    const jsdocContent = match[1];
+    const jsdocEnd = match.index + match[0].length;
+    const afterJsdoc = content.slice(jsdocEnd).trim();
+    const lineNumber = content.slice(0, match.index).split("\n").length;
+    const entry = parseJsdocBlock(jsdocContent, afterJsdoc, file, lineNumber);
+    if (entry && (options.private || !entry.private)) {
+      entries.push(entry);
+    }
+  }
+  return entries;
+}
+function extractFunctionSignature(signature) {
+  const match = signature.match(
+    /(?:export\s+)?(?:async\s+)?(?:function\s+\w+|\w+\s*=\s*(?:async\s*)?\()\([^{]*?\)(?:\s*:\s*[^{;]+)?/s
+  );
+  if (match) {
+    let sig = match[0].trim();
+    sig = sig.split("\n").map((line) => line.trim()).filter((line) => line).join("\n  ");
+    return sig;
+  }
+  return void 0;
+}
+function extractTypesFromSignature(signature, params) {
+  const paramTypes = [];
+  const paramListMatch = signature.match(/\(([^)]*)\)(?:\s*:\s*([^{=>]+))?/s);
+  if (paramListMatch && paramListMatch[1]) {
+    const paramListStr = paramListMatch[1];
+    const paramParts = splitParameters(paramListStr);
+    for (const part of paramParts) {
+      const trimmed = part.trim();
+      if (!trimmed) continue;
+      const typeMatch = /:\s*(.+?)(?:\s*=|$)/.exec(trimmed);
+      if (typeMatch) {
+        let typeStr = typeMatch[1].trim();
+        if (typeStr.includes("=")) {
+          typeStr = typeStr.split("=")[0].trim();
+        }
+        paramTypes.push(typeStr);
+      }
+    }
+  }
+  let returnType;
+  const returnTypeMatch = signature.match(/\)\s*:\s*(.+?)(?={|$)/);
+  if (returnTypeMatch) {
+    returnType = returnTypeMatch[1].trim();
+  }
+  return {
+    paramTypes,
+    returnType
+  };
+}
+function splitParameters(paramListStr) {
+  const parts = [];
+  let current = "";
+  let depth = 0;
+  for (const char of paramListStr) {
+    if (char === "<") {
+      depth++;
+      current += char;
+    } else if (char === ">") {
+      depth--;
+      current += char;
+    } else if (char === "," && depth === 0) {
+      parts.push(current);
+      current = "";
+    } else {
+      current += char;
+    }
+  }
+  if (current) {
+    parts.push(current);
+  }
+  return parts;
+}
+function parseJsdocBlock(jsdoc, declaration, file, line) {
+  const params = [];
+  const examples = [];
+  const tags = {};
+  let description = "";
+  let returns;
+  let isPrivate = false;
+  const rawLines = jsdoc.split("\n").map((l) => l.replace(/^\s*\*\s?/, ""));
+  const cleanedLines = rawLines.map((l) => l.trim()).filter((l) => l);
+  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 = /@(\w+)\s*(?:\{([^}]*)\})?(.*)/.exec(lineText);
+      if (tagMatch) {
+        const [, tagName, tagType, tagRest] = tagMatch;
+        switch (tagName) {
+          case "param":
+            const paramMatch = /(\w+)\s*-?\s*(.*)/.exec(tagRest.trim());
+            if (paramMatch) {
+              params.push({
+                name: paramMatch[1],
+                type: tagType || "unknown",
+                description: paramMatch[2]
+              });
+            }
+            break;
+          case "returns":
+          case "return":
+            returns = {
+              type: tagType || "unknown",
+              description: tagRest.trim()
+            };
+            break;
+          case "example":
+            inExample = true;
+            break;
+          case "private":
+            isPrivate = true;
+            break;
+          default:
+            tags[tagName] = tagRest.trim();
+        }
+      }
+    } else if (inExample) {
+      currentExample += rawLine + "\n";
+    } else if (!description) {
+      description = lineText;
+    } else {
+      description += "\n" + lineText;
+    }
+  }
+  if (inExample && currentExample) {
+    examples.push(currentExample.trim());
+  }
+  const firstFewLines = declaration.split("\n").slice(0, 5).join("\n");
+  let name = "";
+  let kind = "function";
+  const ANCHORED_FUNCTION = /^(?:export\s+)?(?:async\s+)?function\s+(\w+)/;
+  const ANCHORED_CONST_FUNC = /^(?:export\s+)?const\s+(\w+)\s*=\s*(?:async\s*)?\(/;
+  const ANCHORED_CLASS = /^(?:export\s+)?class\s+(\w+)/;
+  const ANCHORED_INTERFACE = /^(?:export\s+)?interface\s+(\w+)/;
+  const ANCHORED_TYPE = /^(?:export\s+)?type\s+(\w+)/;
+  let declMatch;
+  if (declMatch = ANCHORED_FUNCTION.exec(firstFewLines)) {
+    name = declMatch[1];
+    kind = "function";
+  } else if (declMatch = ANCHORED_CONST_FUNC.exec(firstFewLines)) {
+    name = declMatch[1];
+    kind = "function";
+  } else if (declMatch = ANCHORED_CLASS.exec(firstFewLines)) {
+    name = declMatch[1];
+    kind = "class";
+  } else if (declMatch = ANCHORED_INTERFACE.exec(firstFewLines)) {
+    name = declMatch[1];
+    kind = "interface";
+  } else if (declMatch = ANCHORED_TYPE.exec(firstFewLines)) {
+    name = declMatch[1];
+    kind = "type";
+  }
+  if (!name) return null;
+  let signature;
+  if (kind === "function") {
+    const signatureTypes = extractTypesFromSignature(firstFewLines, params);
+    if (signatureTypes.paramTypes.length > 0) {
+      for (let i = 0; i < params.length && i < signatureTypes.paramTypes.length; i++) {
+        if (params[i].type === "unknown") {
+          params[i].type = signatureTypes.paramTypes[i];
+        }
+      }
+    }
+    if (signatureTypes.returnType && (!returns || returns.type === "unknown")) {
+      if (returns) {
+        returns.type = signatureTypes.returnType;
+      } else {
+        returns = {
+          type: signatureTypes.returnType,
+          description: ""
+        };
+      }
+    }
+    signature = extractFunctionSignature(firstFewLines);
+  }
+  return {
+    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,
+    line,
+    signature
+  };
+}
+function generateMarkdown(docs, options) {
+  const result = {};
+  const symbolMap = buildSymbolMap(docs);
+  if (options.groupBy === "file") {
+    const docToFile = /* @__PURE__ */ new Map();
+    for (const doc of docs) {
+      let fileName = path2.basename(doc.file, path2.extname(doc.file));
+      if (fileName === "index") {
+        fileName = "index-module";
+      }
+      docToFile.set(doc, fileName);
+      const markdown = generateFileMarkdown(doc, options, fileName, symbolMap);
+      result[`${fileName}.md`] = markdown;
+    }
+    result["index.md"] = generateIndex(docs, docToFile);
+  } else {
+    const byKind = /* @__PURE__ */ new Map();
+    for (const doc of docs) {
+      for (const entry of doc.entries) {
+        const existing = byKind.get(entry.kind) || [];
+        existing.push(entry);
+        byKind.set(entry.kind, existing);
+      }
+    }
+    for (const [kind, entries] of byKind) {
+      result[`${kind}s.md`] = generateCategoryMarkdown(kind, entries, options, symbolMap);
+    }
+    result["index.md"] = generateCategoryIndex(byKind);
+  }
+  return result;
+}
+function generateFileMarkdown(doc, options, currentFileName, symbolMap) {
+  const displayName = path2.basename(doc.file);
+  let md = `# ${displayName}
+
+`;
+  if (options.githubUrl) {
+    const sourceLink = generateSourceLink(doc.file, options.githubUrl);
+    if (sourceLink) {
+      md += sourceLink + "\n\n";
+    }
+  }
+  for (const entry of doc.entries) {
+    md += generateEntryMarkdown(entry, options, currentFileName, symbolMap);
+  }
+  return md;
+}
+function generateEntryMarkdown(entry, options, currentFileName, symbolMap) {
+  let md = `## ${entry.name}
+
+`;
+  md += `\`${entry.kind}\`
+
+`;
+  if (entry.description) {
+    const processedDescription = currentFileName && symbolMap ? convertSymbolLinks(entry.description, currentFileName, symbolMap) : entry.description;
+    md += `${processedDescription}
+
+`;
+  }
+  if (options?.githubUrl) {
+    const sourceLink = generateSourceLink(entry.file, options.githubUrl, entry.line);
+    if (sourceLink) {
+      md += sourceLink + "\n\n";
+    }
+  }
+  if (entry.signature && entry.kind === "function") {
+    md += "```typescript\n";
+    md += entry.signature + "\n";
+    md += "```\n\n";
+  }
+  if (entry.params && entry.params.length > 0) {
+    md += "### Parameters\n\n";
+    md += "| Name | Type | Description |\n";
+    md += "|------|------|-------------|\n";
+    for (const param of entry.params) {
+      md += `| \`${param.name}\` | \`${param.type}\` | ${param.description} |
+`;
+    }
+    md += "\n";
+  }
+  if (entry.returns) {
+    md += "### Returns\n\n";
+    md += `\`${entry.returns.type}\` - ${entry.returns.description}
+
+`;
+  }
+  if (entry.examples && entry.examples.length > 0) {
+    md += "### Examples\n\n";
+    for (const example of entry.examples) {
+      md += "```ts\n";
+      md += example.replace(/^```\w*\n?/, "").replace(/\n?```$/, "");
+      md += "\n```\n\n";
+    }
+  }
+  md += "---\n\n";
+  return md;
+}
+function generateIndex(docs, docToFile) {
+  let md = "# API Documentation\n\n";
+  md += "Generated by [Ox Content](https://github.com/ubugeeei/ox-content)\n\n";
+  md += "## Modules\n\n";
+  for (const doc of docs) {
+    const displayName = path2.basename(doc.file, path2.extname(doc.file));
+    let fileName = displayName;
+    if (docToFile && docToFile.has(doc)) {
+      fileName = docToFile.get(doc);
+    } else if (fileName === "index") {
+      fileName = "index-module";
+    }
+    md += `### [${displayName}](./${fileName}.md)
+
+`;
+    for (const entry of doc.entries) {
+      const desc = entry.description?.slice(0, 80) || "";
+      const ellipsis = entry.description && entry.description.length > 80 ? "..." : "";
+      md += `- \`${entry.kind}\` **${entry.name}** - ${desc}${ellipsis}
+`;
+    }
+    md += "\n";
+  }
+  return md;
+}
+function generateCategoryMarkdown(kind, entries, options, symbolMap) {
+  const categoryFileName = `${kind}s`;
+  let md = `# ${kind.charAt(0).toUpperCase() + kind.slice(1)}s
+
+`;
+  for (const entry of entries) {
+    md += generateEntryMarkdown(entry, options, categoryFileName, symbolMap);
+  }
+  return md;
+}
+function generateCategoryIndex(byKind) {
+  let md = "# API Documentation\n\n";
+  md += "Generated by [Ox Content](https://github.com/ubugeeei/ox-content)\n\n";
+  for (const [kind, entries] of byKind) {
+    const kindTitle = kind.charAt(0).toUpperCase() + kind.slice(1) + "s";
+    md += `## [${kindTitle}](./${kind}s.md)
+
+`;
+    for (const entry of entries) {
+      const desc = entry.description?.slice(0, 60) || "";
+      md += `- **${entry.name}** - ${desc}...
+`;
+    }
+    md += "\n";
+  }
+  return md;
+}
+function convertSymbolLinks(text, currentFileName, symbolMap) {
+  return text.replace(/\[([A-Z_]\w*)\](?!\()/g, (match, symbolName) => {
+    const location = symbolMap.get(symbolName);
+    if (!location) {
+      return match;
+    }
+    if (location.fileName === currentFileName) {
+      return `[${symbolName}](#${symbolName.toLowerCase()})`;
+    } else {
+      return `[${symbolName}](./${location.fileName}.md#${symbolName.toLowerCase()})`;
+    }
+  });
+}
+function buildSymbolMap(docs) {
+  const map = /* @__PURE__ */ new Map();
+  for (const doc of docs) {
+    let fileName = path2.basename(doc.file, path2.extname(doc.file));
+    if (fileName === "index") {
+      fileName = "index-module";
+    }
+    for (const entry of doc.entries) {
+      map.set(entry.name, {
+        name: entry.name,
+        file: doc.file,
+        fileName
+      });
+    }
+  }
+  return map;
+}
+async function writeDocs(docs, outDir, extractedDocs, options) {
+  await fs.promises.mkdir(outDir, { recursive: true });
+  for (const [fileName, content] of Object.entries(docs)) {
+    const filePath = path2.join(outDir, fileName);
+    await fs.promises.writeFile(filePath, content, "utf-8");
+  }
+  if (extractedDocs && options?.generateNav && options.groupBy === "file") {
+    const navItems = generateNavMetadata(extractedDocs, "/api");
+    const navCode = generateNavCode(navItems, "apiNav");
+    const navFilePath = path2.join(outDir, "nav.ts");
+    await fs.promises.writeFile(navFilePath, navCode, "utf-8");
+  }
+}
+function generateSourceLink(filePath, githubUrl, lineNumber) {
+  const relativePath = filePath.replace(/^.*?\/(npm|packages|crates|src)\//, "$1/");
+  const fragment = lineNumber ? `#L${lineNumber}` : "";
+  const link = `${githubUrl}/blob/main/${relativePath}${fragment}`;
+  return `**[Source](${link})**`;
+}
+function resolveDocsOptions(options) {
+  if (options === false) {
+    return false;
+  }
+  const opts = options || {};
+  return {
+    enabled: opts.enabled ?? true,
+    src: opts.src ?? ["./src"],
+    out: opts.out ?? "docs/api",
+    include: opts.include ?? ["**/*.ts", "**/*.tsx"],
+    exclude: opts.exclude ?? ["**/*.test.*", "**/*.spec.*", "node_modules"],
+    format: opts.format ?? "markdown",
+    private: opts.private ?? false,
+    toc: false,
+    groupBy: opts.groupBy ?? "file",
+    githubUrl: opts.githubUrl,
+    generateNav: opts.generateNav ?? true
+  };
+}
+
+// src/ssg.ts
+import * as fs2 from "fs/promises";
+import * as path3 from "path";
+import { glob } from "glob";
+var DEFAULT_HTML_TEMPLATE = `<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>{{title}}{{#siteName}} - {{siteName}}{{/siteName}}</title>
+  {{#description}}<meta name="description" content="{{description}}">{{/description}}
+  <!-- Open Graph -->
+  <meta property="og:type" content="website">
+  <meta property="og:title" content="{{title}}{{#siteName}} - {{siteName}}{{/siteName}}">
+  {{#description}}<meta property="og:description" content="{{description}}">{{/description}}
+  {{#ogImage}}<meta property="og:image" content="{{ogImage}}">{{/ogImage}}
+  <!-- Twitter Card -->
+  <meta name="twitter:card" content="summary_large_image">
+  <meta name="twitter:title" content="{{title}}{{#siteName}} - {{siteName}}{{/siteName}}">
+  {{#description}}<meta name="twitter:description" content="{{description}}">{{/description}}
+  {{#ogImage}}<meta name="twitter:image" content="{{ogImage}}">{{/ogImage}}
+  <style>
+    :root {
+      --sidebar-width: 260px;
+      --header-height: 60px;
+      --max-content-width: 960px;
+      --font-sans: system-ui, -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
+      --font-mono: ui-monospace, SFMono-Regular, 'SF Mono', Menlo, Consolas, monospace;
+      --color-bg: #ffffff;
+      --color-bg-alt: #f8f9fa;
+      --color-text: #1a1a1a;
+      --color-text-muted: #666666;
+      --color-border: #e5e7eb;
+      --color-primary: #b7410e;
+      --color-primary-hover: #ce5937;
+      --color-code-bg: #1e293b;
+      --color-code-text: #e2e8f0;
+    }
+    [data-theme="dark"] {
+      --color-bg: #0f172a;
+      --color-bg-alt: #1e293b;
+      --color-text: #e2e8f0;
+      --color-text-muted: #94a3b8;
+      --color-border: #334155;
+      --color-primary: #e67e4d;
+      --color-primary-hover: #f4a07a;
+      --color-code-bg: #0f172a;
+      --color-code-text: #e2e8f0;
+    }
+    @media (prefers-color-scheme: dark) {
+      :root:not([data-theme="light"]) {
+        --color-bg: #0f172a;
+        --color-bg-alt: #1e293b;
+        --color-text: #e2e8f0;
+        --color-text-muted: #94a3b8;
+        --color-border: #334155;
+        --color-primary: #e67e4d;
+        --color-primary-hover: #f4a07a;
+        --color-code-bg: #0f172a;
+        --color-code-text: #e2e8f0;
+      }
+    }
+    * { box-sizing: border-box; margin: 0; padding: 0; }
+    html { scroll-behavior: smooth; }
+    body {
+      font-family: var(--font-sans);
+      line-height: 1.7;
+      color: var(--color-text);
+      background: var(--color-bg);
+    }
+    a { color: var(--color-primary); text-decoration: none; }
+    a:hover { color: var(--color-primary-hover); text-decoration: underline; }
+
+    /* Header */
+    .header {
+      position: fixed;
+      top: 0;
+      left: 0;
+      right: 0;
+      height: var(--header-height);
+      background: var(--color-bg);
+      border-bottom: 1px solid var(--color-border);
+      display: flex;
+      align-items: center;
+      padding: 0 1.5rem;
+      z-index: 100;
+    }
+    .header-title {
+      font-size: 1.25rem;
+      font-weight: 600;
+      color: var(--color-text);
+    }
+    .header-title:hover { text-decoration: none; }
+    .menu-toggle {
+      display: none;
+      background: none;
+      border: none;
+      cursor: pointer;
+      padding: 0.5rem;
+      margin-right: 0.75rem;
+    }
+    .menu-toggle svg { display: block; }
+    .menu-toggle path { stroke: var(--color-text); }
+    .header-actions { margin-left: auto; display: flex; align-items: center; gap: 0.5rem; }
+    .search-button {
+      display: flex;
+      align-items: center;
+      gap: 0.5rem;
+      padding: 0.5rem 0.75rem;
+      background: var(--color-bg-alt);
+      border: 1px solid var(--color-border);
+      border-radius: 6px;
+      color: var(--color-text-muted);
+      cursor: pointer;
+      font-size: 0.875rem;
+      transition: border-color 0.15s, color 0.15s;
+    }
+    .search-button:hover { border-color: var(--color-primary); color: var(--color-text); }
+    .search-button svg { width: 16px; height: 16px; }
+    .search-button kbd {
+      padding: 0.125rem 0.375rem;
+      background: var(--color-bg);
+      border: 1px solid var(--color-border);
+      border-radius: 4px;
+      font-family: var(--font-mono);
+      font-size: 0.75rem;
+    }
+    @media (max-width: 640px) {
+      .search-button span, .search-button kbd { display: none; }
+      .search-button { padding: 0.5rem; }
+    }
+    .search-modal-overlay {
+      display: none;
+      position: fixed;
+      inset: 0;
+      z-index: 200;
+      background: rgba(0,0,0,0.6);
+      backdrop-filter: blur(4px);
+      justify-content: center;
+      padding-top: 10vh;
+    }
+    .search-modal-overlay.open { display: flex; }
+    .search-modal {
+      width: 100%;
+      max-width: 560px;
+      margin: 0 1rem;
+      background: var(--color-bg);
+      border: 1px solid var(--color-border);
+      border-radius: 12px;
+      overflow: hidden;
+      box-shadow: 0 25px 50px -12px rgba(0,0,0,0.4);
+      max-height: 70vh;
+      display: flex;
+      flex-direction: column;
+    }
+    .search-header {
+      display: flex;
+      align-items: center;
+      gap: 0.75rem;
+      padding: 1rem;
+      border-bottom: 1px solid var(--color-border);
+    }
+    .search-header svg { flex-shrink: 0; color: var(--color-text-muted); }
+    .search-input {
+      flex: 1;
+      background: none;
+      border: none;
+      outline: none;
+      font-size: 1rem;
+      color: var(--color-text);
+    }
+    .search-input::placeholder { color: var(--color-text-muted); }
+    .search-close {
+      padding: 0.25rem 0.5rem;
+      background: var(--color-bg-alt);
+      border: 1px solid var(--color-border);
+      border-radius: 4px;
+      color: var(--color-text-muted);
+      font-family: var(--font-mono);
+      font-size: 0.75rem;
+      cursor: pointer;
+    }
+    .search-results {
+      flex: 1;
+      overflow-y: auto;
+      padding: 0.5rem;
+    }
+    .search-result {
+      display: block;
+      padding: 0.75rem 1rem;
+      border-radius: 8px;
+      color: var(--color-text);
+      text-decoration: none;
+    }
+    .search-result:hover, .search-result.selected { background: var(--color-bg-alt); text-decoration: none; }
+    .search-result-title { font-weight: 600; font-size: 0.875rem; margin-bottom: 0.25rem; }
+    .search-result-snippet { font-size: 0.8125rem; color: var(--color-text-muted); }
+    .search-empty { padding: 2rem 1rem; text-align: center; color: var(--color-text-muted); }
+    .search-footer {
+      display: flex;
+      align-items: center;
+      justify-content: center;
+      gap: 1rem;
+      padding: 0.75rem 1rem;
+      border-top: 1px solid var(--color-border);
+      background: var(--color-bg-alt);
+      font-size: 0.75rem;
+      color: var(--color-text-muted);
+    }
+    .search-footer kbd {
+      padding: 0.125rem 0.375rem;
+      background: var(--color-bg);
+      border: 1px solid var(--color-border);
+      border-radius: 4px;
+      font-family: var(--font-mono);
+    }
+    .theme-toggle {
+      background: none;
+      border: none;
+      cursor: pointer;
+      padding: 0.5rem;
+      border-radius: 6px;
+      color: var(--color-text-muted);
+      transition: background 0.15s, color 0.15s;
+    }
+    .theme-toggle:hover { background: var(--color-bg-alt); color: var(--color-text); }
+    .theme-toggle svg { display: block; width: 20px; height: 20px; }
+    .theme-toggle .icon-sun { display: none; }
+    .theme-toggle .icon-moon { display: block; }
+    [data-theme="dark"] .theme-toggle .icon-sun { display: block; }
+    [data-theme="dark"] .theme-toggle .icon-moon { display: none; }
+    @media (prefers-color-scheme: dark) {
+      :root:not([data-theme="light"]) .theme-toggle .icon-sun { display: block; }
+      :root:not([data-theme="light"]) .theme-toggle .icon-moon { display: none; }
+    }
+
+    /* Layout */
+    .layout {
+      display: flex;
+      padding-top: var(--header-height);
+      min-height: 100vh;
+    }
+
+    /* Sidebar */
+    .sidebar {
+      position: fixed;
+      top: var(--header-height);
+      left: 0;
+      bottom: 0;
+      width: var(--sidebar-width);
+      background: var(--color-bg-alt);
+      border-right: 1px solid var(--color-border);
+      overflow-y: auto;
+      padding: 1.5rem 1rem;
+    }
+    .nav-section { margin-bottom: 1.5rem; }
+    .nav-title {
+      font-size: 0.75rem;
+      font-weight: 600;
+      text-transform: uppercase;
+      letter-spacing: 0.05em;
+      color: var(--color-text-muted);
+      margin-bottom: 0.5rem;
+      padding: 0 0.75rem;
+    }
+    .nav-list { list-style: none; }
+    .nav-item { margin: 0.125rem 0; }
+    .nav-link {
+      display: block;
+      padding: 0.5rem 0.75rem;
+      border-radius: 6px;
+      color: var(--color-text);
+      font-size: 0.875rem;
+      transition: background 0.15s;
+    }
+    .nav-link:hover {
+      background: var(--color-border);
+      text-decoration: none;
+    }
+    .nav-link.active {
+      background: var(--color-primary);
+      color: white;
+    }
+
+    /* Main content */
+    .main {
+      flex: 1;
+      margin-left: var(--sidebar-width);
+      padding: 2rem;
+      min-width: 0;
+      overflow-x: hidden;
+    }
+    .content {
+      max-width: var(--max-content-width);
+      margin: 0 auto;
+      overflow-wrap: break-word;
+      word-wrap: break-word;
+      word-break: break-word;
+    }
+
+    /* TOC (right sidebar) */
+    .toc {
+      position: fixed;
+      top: calc(var(--header-height) + 2rem);
+      right: 2rem;
+      width: 200px;
+      font-size: 0.8125rem;
+    }
+    .toc-title {
+      font-weight: 600;
+      margin-bottom: 0.75rem;
+      color: var(--color-text-muted);
+    }
+    .toc-list { list-style: none; }
+    .toc-item { margin: 0.375rem 0; }
+    .toc-link {
+      color: var(--color-text-muted);
+      display: block;
+      padding-left: calc((var(--depth, 1) - 1) * 0.75rem);
+    }
+    .toc-link:hover { color: var(--color-primary); }
+    @media (max-width: 1200px) { .toc { display: none; } }
+
+    /* Typography */
+    .content h1 { font-size: 2.25rem; margin-bottom: 1rem; line-height: 1.2; }
+    .content h2 { font-size: 1.5rem; margin-top: 2.5rem; margin-bottom: 1rem; padding-bottom: 0.5rem; border-bottom: 1px solid var(--color-border); }
+    .content h3 { font-size: 1.25rem; margin-top: 2rem; margin-bottom: 0.75rem; }
+    .content h4 { font-size: 1rem; margin-top: 1.5rem; margin-bottom: 0.5rem; }
+    .content p { margin-bottom: 1rem; }
+    .content ul, .content ol { margin: 1rem 0; padding-left: 1.5rem; }
+    .content li { margin: 0.375rem 0; }
+    .content blockquote {
+      border-left: 4px solid var(--color-primary);
+      padding: 0.5rem 1rem;
+      margin: 1rem 0;
+      background: var(--color-bg-alt);
+      border-radius: 0 6px 6px 0;
+    }
+    .content code {
+      font-family: var(--font-mono);
+      font-size: 0.875em;
+      background: var(--color-bg-alt);
+      padding: 0.2em 0.4em;
+      border-radius: 4px;
+      word-break: break-all;
+    }
+    .content pre {
+      background: var(--color-code-bg);
+      color: var(--color-code-text);
+      padding: 1rem 1.25rem;
+      border-radius: 8px;
+      overflow-x: auto;
+      margin: 1.5rem 0;
+      line-height: 1.5;
+    }
+    .content pre code {
+      background: transparent;
+      padding: 0;
+      font-size: 0.8125rem;
+    }
+    .content table {
+      width: 100%;
+      border-collapse: collapse;
+      margin: 1.5rem 0;
+      font-size: 0.875rem;
+    }
+    .content th, .content td {
+      border: 1px solid var(--color-border);
+      padding: 0.75rem 1rem;
+      text-align: left;
+    }
+    .content th { background: var(--color-bg-alt); font-weight: 600; }
+    .content img { max-width: 100%; height: auto; border-radius: 8px; display: block; }
+    .content img[alt*="Logo"] { max-width: 200px; display: block; margin: 1rem 0; }
+    .content img[alt*="Architecture"] { max-width: 600px; }
+    .content img[alt*="Benchmark"] { max-width: 680px; }
+    .content hr { border: none; border-top: 1px solid var(--color-border); margin: 2rem 0; }
+
+    /* Responsive */
+    @media (max-width: 768px) {
+      .menu-toggle { display: block; }
+      .sidebar {
+        transform: translateX(-100%);
+        transition: transform 0.3s ease;
+        z-index: 99;
+        width: 280px;
+      }
+      .sidebar.open { transform: translateX(0); }
+      .main { margin-left: 0; padding: 1rem 0.75rem; }
+      .content { padding: 0 0.25rem; }
+      .content h1 { font-size: 1.5rem; line-height: 1.3; margin-bottom: 0.75rem; }
+      .content h2 { font-size: 1.2rem; margin-top: 2rem; }
+      .content h3 { font-size: 1.1rem; }
+      .content p { font-size: 0.9375rem; margin-bottom: 0.875rem; }
+      .content ul, .content ol { padding-left: 1.25rem; font-size: 0.9375rem; }
+      .content pre {
+        padding: 0.75rem;
+        font-size: 0.75rem;
+        margin: 1rem -0.75rem;
+        border-radius: 0;
+        overflow-x: auto;
+        -webkit-overflow-scrolling: touch;
+      }
+      .content code { font-size: 0.8125em; }
+      .content table {
+        display: block;
+        overflow-x: auto;
+        -webkit-overflow-scrolling: touch;
+        font-size: 0.8125rem;
+        margin: 1rem -0.75rem;
+        width: calc(100% + 1.5rem);
+      }
+      .content th, .content td { padding: 0.5rem 0.75rem; white-space: nowrap; }
+      .content img { margin: 1rem 0; }
+      .content img[alt*="Logo"] { max-width: 150px; }
+      .content img[alt*="Architecture"] { max-width: 100%; }
+      .content img[alt*="Benchmark"] { max-width: 100%; }
+      .content blockquote { padding: 0.5rem 0.75rem; margin: 1rem 0; font-size: 0.9375rem; }
+      .header { padding: 0 1rem; }
+      .header-title { font-size: 1rem; }
+      .header-title img { width: 24px; height: 24px; }
+      .overlay {
+        display: none;
+        position: fixed;
+        inset: 0;
+        background: rgba(0,0,0,0.5);
+        z-index: 98;
+      }
+      .overlay.open { display: block; }
+    }
+
+    /* Extra small devices */
+    @media (max-width: 480px) {
+      .main { padding: 0.75rem 0.5rem; }
+      .content h1 { font-size: 1.35rem; }
+      .content pre { font-size: 0.6875rem; padding: 0.625rem; }
+      .content table { font-size: 0.75rem; }
+      .content th, .content td { padding: 0.375rem 0.5rem; }
+    }
+  </style>
+</head>
+<body>
+  <header class="header">
+    <button class="menu-toggle" aria-label="Toggle menu">
+      <svg width="24" height="24" viewBox="0 0 24 24" fill="none" stroke-width="2" stroke-linecap="round">
+        <path d="M3 12h18M3 6h18M3 18h18"/>
+      </svg>
+    </button>
+    <a href="{{base}}index.html" class="header-title">
+      <img src="{{base}}logo.svg" alt="" width="28" height="28" style="margin-right: 8px; vertical-align: middle;" />
+      {{siteName}}
+    </a>
+    <div class="header-actions">
+      <button class="search-button" aria-label="Search">
+        <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round">
+          <circle cx="11" cy="11" r="8"/><path d="m21 21-4.3-4.3"/>
+        </svg>
+        <span>Search</span>
+        <kbd>/</kbd>
+      </button>
+      <button class="theme-toggle" aria-label="Toggle theme">
+        <svg class="icon-sun" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round">
+          <circle cx="12" cy="12" r="5"/><path d="M12 1v2M12 21v2M4.22 4.22l1.42 1.42M18.36 18.36l1.42 1.42M1 12h2M21 12h2M4.22 19.78l1.42-1.42M18.36 5.64l1.42-1.42"/>
+        </svg>
+        <svg class="icon-moon" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round">
+          <path d="M21 12.79A9 9 0 1 1 11.21 3 7 7 0 0 0 21 12.79z"/>
+        </svg>
+      </button>
+    </div>
+  </header>
+  <div class="search-modal-overlay">
+    <div class="search-modal">
+      <div class="search-header">
+        <svg width="20" height="20" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round">
+          <circle cx="11" cy="11" r="8"/><path d="m21 21-4.3-4.3"/>
+        </svg>
+        <input type="text" class="search-input" placeholder="Search documentation..." />
+        <button class="search-close">Esc</button>
+      </div>
+      <div class="search-results"></div>
+      <div class="search-footer">
+        <span><kbd>\u2191</kbd><kbd>\u2193</kbd> to navigate</span>
+        <span><kbd>Enter</kbd> to select</span>
+        <span><kbd>Esc</kbd> to close</span>
+      </div>
+    </div>
+  </div>
+  <div class="overlay"></div>
+  <div class="layout">
+    <aside class="sidebar">
+      <nav>
+{{navigation}}
+      </nav>
+    </aside>
+    <main class="main">
+      <article class="content">
+{{content}}
+      </article>
+    </main>
+{{#hasToc}}
+    <aside class="toc">
+      <div class="toc-title">On this page</div>
+      <ul class="toc-list">
+{{toc}}
+      </ul>
+    </aside>
+{{/hasToc}}
+  </div>
+  <script>
+    // Menu toggle
+    const toggle = document.querySelector('.menu-toggle');
+    const sidebar = document.querySelector('.sidebar');
+    const overlay = document.querySelector('.overlay');
+    if (toggle && sidebar && overlay) {
+      const close = () => { sidebar.classList.remove('open'); overlay.classList.remove('open'); };
+      toggle.addEventListener('click', () => {
+        sidebar.classList.toggle('open');
+        overlay.classList.toggle('open');
+      });
+      overlay.addEventListener('click', close);
+      sidebar.querySelectorAll('a').forEach(a => a.addEventListener('click', close));
+    }
+
+    // Theme toggle
+    const themeToggle = document.querySelector('.theme-toggle');
+    const getPreferredTheme = () => {
+      const stored = localStorage.getItem('theme');
+      if (stored) return stored;
+      return window.matchMedia('(prefers-color-scheme: dark)').matches ? 'dark' : 'light';
+    };
+    const setTheme = (theme) => {
+      document.documentElement.setAttribute('data-theme', theme);
+      localStorage.setItem('theme', theme);
+    };
+    // Initialize theme
+    setTheme(getPreferredTheme());
+    if (themeToggle) {
+      themeToggle.addEventListener('click', () => {
+        const current = document.documentElement.getAttribute('data-theme') || getPreferredTheme();
+        setTheme(current === 'dark' ? 'light' : 'dark');
+      });
+    }
+
+    // Search functionality
+    const searchButton = document.querySelector('.search-button');
+    const searchOverlay = document.querySelector('.search-modal-overlay');
+    const searchInput = document.querySelector('.search-input');
+    const searchResults = document.querySelector('.search-results');
+    const searchClose = document.querySelector('.search-close');
+    let searchIndex = null;
+    let selectedIndex = 0;
+    let results = [];
+
+    const openSearch = () => {
+      searchOverlay.classList.add('open');
+      searchInput.focus();
+    };
+    const closeSearch = () => {
+      searchOverlay.classList.remove('open');
+      searchInput.value = '';
+      searchResults.innerHTML = '';
+      selectedIndex = 0;
+      results = [];
+    };
+
+    // Load search index
+    const loadSearchIndex = async () => {
+      if (searchIndex) return;
+      try {
+        const res = await fetch('{{base}}search-index.json');
+        searchIndex = await res.json();
+      } catch (e) {
+        console.warn('Failed to load search index:', e);
+      }
+    };
+
+    // Tokenize query
+    const tokenize = (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;
+    };
+
+    // Perform search
+    const performSearch = async (query) => {
+      if (!query.trim()) {
+        searchResults.innerHTML = '';
+        results = [];
+        return;
+      }
+      await loadSearchIndex();
+      if (!searchIndex) {
+        searchResults.innerHTML = '<div class="search-empty">Search index not available</div>';
+        return;
+      }
+
+      const tokens = tokenize(query);
+      if (!tokens.length) {
+        searchResults.innerHTML = '';
+        results = [];
+        return;
+      }
+
+      const k1 = 1.2, b = 0.75;
+      const docScores = new Map();
+
+      for (let i = 0; i < tokens.length; i++) {
+        const token = tokens[i];
+        const isLast = i === tokens.length - 1;
+        let matchingTerms = [];
+        if (isLast && token.length >= 2) {
+          matchingTerms = Object.keys(searchIndex.index).filter(t => t.startsWith(token));
+        } else if (searchIndex.index[token]) {
+          matchingTerms = [token];
+        }
+
+        for (const term of matchingTerms) {
+          const postings = searchIndex.index[term] || [];
+          const df = searchIndex.df[term] || 1;
+          const idf = Math.log((searchIndex.doc_count - df + 0.5) / (df + 0.5) + 1.0);
+
+          for (const posting of postings) {
+            const doc = searchIndex.documents[posting.doc_idx];
+            if (!doc) continue;
+            const boost = posting.field === 'Title' ? 10 : posting.field === 'Heading' ? 5 : 1;
+            const tf = posting.tf;
+            const docLen = doc.body.length;
+            const score = idf * ((tf * (k1 + 1)) / (tf + k1 * (1 - b + b * docLen / searchIndex.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);
+          }
+        }
+      }
+
+      results = Array.from(docScores.entries())
+        .map(([docIdx, data]) => {
+          const doc = searchIndex.documents[docIdx];
+          let snippet = '';
+          if (doc.body) {
+            const bodyLower = doc.body.toLowerCase();
+            let firstPos = -1;
+            for (const match of data.matches) {
+              const pos = bodyLower.indexOf(match);
+              if (pos !== -1 && (firstPos === -1 || pos < firstPos)) firstPos = pos;
+            }
+            const start = 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 += '...';
+          }
+          return { ...doc, score: data.score, snippet };
+        })
+        .sort((a, b) => b.score - a.score)
+        .slice(0, 10);
+
+      selectedIndex = 0;
+      renderResults();
+    };
+
+    const renderResults = () => {
+      if (!results.length) {
+        searchResults.innerHTML = '<div class="search-empty">No results found</div>';
+        return;
+      }
+      searchResults.innerHTML = results.map((r, i) =>
+        '<a href="' + r.url + '" class="search-result' + (i === selectedIndex ? ' selected' : '') + '">' +
+        '<div class="search-result-title">' + r.title + '</div>' +
+        (r.snippet ? '<div class="search-result-snippet">' + r.snippet + '</div>' : '') +
+        '</a>'
+      ).join('');
+    };
+
+    // Event listeners
+    if (searchButton) searchButton.addEventListener('click', openSearch);
+    if (searchClose) searchClose.addEventListener('click', closeSearch);
+    if (searchOverlay) searchOverlay.addEventListener('click', (e) => { if (e.target === searchOverlay) closeSearch(); });
+
+    let searchTimeout = null;
+    if (searchInput) {
+      searchInput.addEventListener('input', () => {
+        if (searchTimeout) clearTimeout(searchTimeout);
+        searchTimeout = setTimeout(() => performSearch(searchInput.value), 150);
+      });
+      searchInput.addEventListener('keydown', (e) => {
+        if (e.key === 'Escape') closeSearch();
+        else if (e.key === 'ArrowDown') {
+          e.preventDefault();
+          if (selectedIndex < results.length - 1) { selectedIndex++; renderResults(); }
+        } else if (e.key === 'ArrowUp') {
+          e.preventDefault();
+          if (selectedIndex > 0) { selectedIndex--; renderResults(); }
+        } else if (e.key === 'Enter' && results[selectedIndex]) {
+          e.preventDefault();
+          window.location.href = results[selectedIndex].url;
+        }
+      });
+    }
+
+    // Global keyboard shortcut (/ or Cmd+K)
+    document.addEventListener('keydown', (e) => {
+      if ((e.key === '/' && !(e.target instanceof HTMLInputElement)) ||
+          ((e.metaKey || e.ctrlKey) && e.key.toLowerCase() === 'k')) {
+        e.preventDefault();
+        openSearch();
+      }
+    });
+  </script>
+</body>
+</html>`;
+var BARE_HTML_TEMPLATE = `<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>{{title}}</title>
+</head>
+<body>
+{{content}}
+</body>
+</html>`;
+function resolveSsgOptions(ssg) {
+  if (ssg === false) {
+    return {
+      enabled: false,
+      extension: ".html",
+      clean: false,
+      bare: false,
+      generateOgImage: false
+    };
+  }
+  if (ssg === true || ssg === void 0) {
+    return {
+      enabled: true,
+      extension: ".html",
+      clean: false,
+      bare: false,
+      generateOgImage: false
+    };
+  }
+  return {
+    enabled: ssg.enabled ?? true,
+    extension: ssg.extension ?? ".html",
+    clean: ssg.clean ?? false,
+    bare: ssg.bare ?? false,
+    siteName: ssg.siteName,
+    ogImage: ssg.ogImage,
+    generateOgImage: ssg.generateOgImage ?? false,
+    siteUrl: ssg.siteUrl
+  };
+}
+function renderTemplate(template, data) {
+  let result = template;
+  result = result.replace(/\{\{#(\w+)\}\}([\s\S]*?)\{\{\/\1\}\}/g, (_, key, content) => {
+    return data[key] ? content : "";
+  });
+  result = result.replace(/\{\{(\w+)\}\}/g, (_, key) => {
+    const value = data[key];
+    return value !== void 0 && value !== null ? String(value) : "";
+  });
+  return result;
+}
+function extractTitle(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";
+}
+function generateBareHtmlPage(content, title) {
+  return renderTemplate(BARE_HTML_TEMPLATE, {
+    title,
+    content
+  });
+}
+async function generateHtmlPage(pageData, navGroups, siteName, base, ogImage) {
+  const mod = await import("@ox-content/napi");
+  const tocForRust = pageData.toc.map((entry) => ({
+    depth: entry.depth,
+    text: entry.text,
+    slug: entry.slug
+  }));
+  const navGroupsForRust = navGroups.map((group) => ({
+    title: group.title,
+    items: group.items.map((item) => ({
+      title: item.title,
+      path: item.path,
+      href: item.href
+    }))
+  }));
+  return mod.generateSsgHtml(
+    {
+      title: pageData.title,
+      description: pageData.description,
+      content: pageData.content,
+      toc: tocForRust,
+      path: pageData.path
+    },
+    navGroupsForRust,
+    {
+      siteName,
+      base,
+      ogImage
+    }
+  );
+}
+function getOutputPath(inputPath, srcDir, outDir, extension) {
+  const relativePath = path3.relative(srcDir, inputPath);
+  const baseName = relativePath.replace(/\.(?:md|markdown)$/i, extension);
+  if (baseName.endsWith(`index${extension}`)) {
+    return path3.join(outDir, baseName);
+  }
+  const dirName = baseName.replace(new RegExp(`\\${extension}$`), "");
+  return path3.join(outDir, dirName, `index${extension}`);
+}
+function getUrlPath(inputPath, srcDir) {
+  const relativePath = path3.relative(srcDir, inputPath);
+  const baseName = relativePath.replace(/\.(?:md|markdown)$/i, "");
+  if (baseName === "index" || baseName.endsWith("/index")) {
+    return baseName.replace(/\/?index$/, "") || "/";
+  }
+  return baseName;
+}
+function getHref(inputPath, srcDir, base, extension) {
+  const urlPath = getUrlPath(inputPath, srcDir);
+  if (urlPath === "/" || urlPath === "") {
+    return `${base}index${extension}`;
+  }
+  return `${base}${urlPath}/index${extension}`;
+}
+function getOgImagePath(inputPath, srcDir, outDir) {
+  const relativePath = path3.relative(srcDir, inputPath);
+  const baseName = relativePath.replace(/\.(?:md|markdown)$/i, "");
+  if (baseName === "index" || baseName.endsWith("/index")) {
+    const dirPath = baseName.replace(/\/?index$/, "") || "";
+    return path3.join(outDir, dirPath, "og-image.svg");
+  }
+  return path3.join(outDir, baseName, "og-image.svg");
+}
+function getOgImageUrl(inputPath, srcDir, base, siteUrl) {
+  const urlPath = getUrlPath(inputPath, srcDir);
+  let relativePath;
+  if (urlPath === "/" || urlPath === "") {
+    relativePath = `${base}og-image.svg`;
+  } else {
+    relativePath = `${base}${urlPath}/og-image.svg`;
+  }
+  if (siteUrl) {
+    const cleanSiteUrl = siteUrl.replace(/\/$/, "");
+    return `${cleanSiteUrl}${relativePath}`;
+  }
+  return relativePath;
+}
+function getDisplayTitle(filePath) {
+  const fileName = path3.basename(filePath, path3.extname(filePath));
+  if (fileName === "index") {
+    const dirName = path3.basename(path3.dirname(filePath));
+    if (dirName && dirName !== ".") {
+      return formatTitle(dirName);
+    }
+    return "Home";
+  }
+  return formatTitle(fileName);
+}
+function formatTitle(name) {
+  return name.replace(/[-_]([a-z])/g, (_, char) => " " + char.toUpperCase()).replace(/^[a-z]/, (char) => char.toUpperCase());
+}
+async function collectMarkdownFiles(srcDir) {
+  const pattern = path3.join(srcDir, "**/*.{md,markdown}");
+  const files = await glob(pattern, {
+    nodir: true,
+    ignore: ["**/node_modules/**", "**/dist/**", "**/.git/**"]
+  });
+  return files.sort();
+}
+function buildNavItems(markdownFiles, srcDir, base, extension) {
+  const groups = /* @__PURE__ */ new Map();
+  const groupOrder = ["", "examples", "packages", "api"];
+  for (const file of markdownFiles) {
+    const relativePath = path3.relative(srcDir, file);
+    const parts = relativePath.split(path3.sep);
+    let groupKey = "";
+    if (parts.length > 1) {
+      groupKey = parts[0];
+    }
+    if (!groups.has(groupKey)) {
+      groups.set(groupKey, []);
+    }
+    const urlPath = getUrlPath(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;
+}
+async function buildSsg(options, root) {
+  const ssgOptions = options.ssg;
+  if (!ssgOptions.enabled) {
+    return { files: [], errors: [] };
+  }
+  const srcDir = path3.resolve(root, options.srcDir);
+  const outDir = path3.resolve(root, options.outDir);
+  const base = options.base.endsWith("/") ? options.base : options.base + "/";
+  const generatedFiles = [];
+  const errors = [];
+  if (ssgOptions.clean) {
+    try {
+      await fs2.rm(outDir, { recursive: true, force: true });
+    } catch {
+    }
+  }
+  const markdownFiles = await collectMarkdownFiles(srcDir);
+  const navItems = buildNavItems(markdownFiles, srcDir, base, ssgOptions.extension);
+  let siteName = ssgOptions.siteName ?? "Documentation";
+  if (!ssgOptions.siteName) {
+    try {
+      const pkgPath = path3.join(root, "package.json");
+      const pkg = JSON.parse(await fs2.readFile(pkgPath, "utf-8"));
+      if (pkg.name) {
+        siteName = formatTitle(pkg.name);
+      }
+    } catch {
+    }
+  }
+  for (const inputPath of markdownFiles) {
+    try {
+      const content = await fs2.readFile(inputPath, "utf-8");
+      const result = await transformMarkdown(content, inputPath, options, {
+        convertMdLinks: true,
+        baseUrl: base
+      });
+      const title = extractTitle(result.html, result.frontmatter);
+      const description = result.frontmatter.description;
+      let pageOgImage = ssgOptions.ogImage;
+      if (ssgOptions.generateOgImage && !ssgOptions.bare) {
+        const ogImageData = {
+          title,
+          description,
+          siteName,
+          author: result.frontmatter.author
+        };
+        const ogImageConfig = options.ogImageOptions ? {
+          width: options.ogImageOptions.width,
+          height: options.ogImageOptions.height,
+          backgroundColor: options.ogImageOptions.background,
+          textColor: options.ogImageOptions.textColor
+        } : void 0;
+        const svg = await generateOgImageSvg(ogImageData, ogImageConfig);
+        if (svg) {
+          const ogImageOutputPath = getOgImagePath(inputPath, srcDir, outDir);
+          await fs2.mkdir(path3.dirname(ogImageOutputPath), { recursive: true });
+          await fs2.writeFile(ogImageOutputPath, svg, "utf-8");
+          generatedFiles.push(ogImageOutputPath);
+          pageOgImage = getOgImageUrl(inputPath, srcDir, base, ssgOptions.siteUrl);
+        }
+      }
+      let html;
+      if (ssgOptions.bare) {
+        html = generateBareHtmlPage(result.html, title);
+      } else {
+        const pageData = {
+          title,
+          description,
+          content: result.html,
+          toc: result.toc,
+          frontmatter: result.frontmatter,
+          path: getUrlPath(inputPath, srcDir),
+          href: getHref(inputPath, srcDir, base, ssgOptions.extension)
+        };
+        html = await generateHtmlPage(pageData, navItems, siteName, base, pageOgImage);
+      }
+      const outputPath = getOutputPath(
+        inputPath,
+        srcDir,
+        outDir,
+        ssgOptions.extension
+      );
+      await fs2.mkdir(path3.dirname(outputPath), { recursive: true });
+      await fs2.writeFile(outputPath, html, "utf-8");
+      generatedFiles.push(outputPath);
+    } catch (err) {
+      const errorMessage = err instanceof Error ? err.message : String(err);
+      errors.push(`Failed to process ${inputPath}: ${errorMessage}`);
+    }
+  }
+  return { files: generatedFiles, errors };
+}
+
+// src/search.ts
+import * as fs3 from "fs/promises";
+import * as path4 from "path";
+var oxContent = null;
+async function getOxContent() {
+  if (!oxContent) {
+    try {
+      oxContent = await import("@ox-content/napi");
+    } catch {
+      console.warn("[ox-content] Native bindings not available, search disabled");
+      return null;
+    }
+  }
+  return oxContent;
+}
+function resolveSearchOptions(options) {
+  if (options === false) {
+    return {
+      enabled: false,
+      limit: 10,
+      prefix: true,
+      placeholder: "Search documentation...",
+      hotkey: "/"
+    };
+  }
+  const opts = typeof options === "object" ? options : {};
+  return {
+    enabled: opts.enabled ?? true,
+    limit: opts.limit ?? 10,
+    prefix: opts.prefix ?? true,
+    placeholder: opts.placeholder ?? "Search documentation...",
+    hotkey: opts.hotkey ?? "/"
+  };
+}
+async function collectMarkdownFiles2(dir) {
+  const files = [];
+  async function walk(currentDir) {
+    try {
+      const entries = await fs3.readdir(currentDir, { withFileTypes: true });
+      for (const entry of entries) {
+        const fullPath = path4.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);
+        }
+      }
+    } catch {
+    }
+  }
+  await walk(dir);
+  return files;
+}
+async function buildSearchIndex(srcDir, base) {
+  const napi = await getOxContent();
+  if (!napi) {
+    return JSON.stringify({ documents: [], index: {}, df: {}, avg_dl: 0, doc_count: 0 });
+  }
+  const files = await collectMarkdownFiles2(srcDir);
+  const documents = [];
+  for (const file of files) {
+    try {
+      const content = await fs3.readFile(file, "utf-8");
+      const relativePath = path4.relative(srcDir, file);
+      const url = base + relativePath.replace(/\.md$/, "").replace(/\\/g, "/");
+      const id = relativePath.replace(/\.md$/, "").replace(/\\/g, "/");
+      const extractSearchContent = napi.extractSearchContent;
+      if (!extractSearchContent) {
+        console.warn("[ox-content] Search not available: extractSearchContent not implemented");
+        return "[]";
+      }
+      const doc = extractSearchContent(content, id, url, { gfm: true });
+      documents.push({
+        id: doc.id,
+        title: doc.title,
+        url: doc.url,
+        body: doc.body,
+        headings: doc.headings,
+        code: doc.code
+      });
+    } catch {
+    }
+  }
+  const buildSearchIndex2 = napi.buildSearchIndex;
+  if (!buildSearchIndex2) {
+    console.warn("[ox-content] Search not available: buildSearchIndex not implemented");
+    return JSON.stringify(documents);
+  }
+  return buildSearchIndex2(documents);
+}
+async function writeSearchIndex(indexJson, outDir) {
+  const indexPath = path4.join(outDir, "search-index.json");
+  await fs3.mkdir(outDir, { recursive: true });
+  await fs3.writeFile(indexPath, indexJson, "utf-8");
+}
+function generateSearchModule(options, indexPath) {
+  return `
+// Search module generated by ox-content
+const searchOptions = ${JSON.stringify(options)};
+
+let searchIndex = null;
+let indexPromise = null;
+
+// 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 || !query.trim()) {
+    return [];
+  }
+
+  const limit = options.limit ?? searchOptions.limit;
+  const prefix = options.prefix ?? searchOptions.prefix;
+  const tokens = tokenizeQuery(query);
+
+  if (tokens.length === 0) {
+    return [];
+  }
+
+  const k1 = 1.2;
+  const b = 0.75;
+  const docScores = new Map();
+
+  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;
+
+        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);
+
+      // 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 = 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,
+      };
+    })
+    .sort((a, b) => b.score - a.score)
+    .slice(0, limit);
+
+  return results;
+}
+
+export { searchOptions };
+export default { search, searchOptions, loadIndex };
+`;
+}
+
+// src/index.ts
+function oxContent2(options = {}) {
+  const resolvedOptions = resolveOptions(options);
+  let config;
+  let _server;
+  const mainPlugin = {
+    name: "ox-content",
+    configResolved(resolvedConfig) {
+      config = resolvedConfig;
+    },
+    configureServer(devServer) {
+      _server = devServer;
+      devServer.middlewares.use(async (req, res, next) => {
+        const url = req.url;
+        if (!url || !url.endsWith(".md")) {
+          return next();
+        }
+        next();
+      });
+    },
+    resolveId(id) {
+      if (id.startsWith("virtual:ox-content/")) {
+        return "\0" + id;
+      }
+      if (id.endsWith(".md")) {
+        return id;
+      }
+      return null;
+    },
+    async load(id) {
+      if (id.startsWith("\0virtual:ox-content/")) {
+        const path6 = id.slice("\0virtual:ox-content/".length);
+        return generateVirtualModule(path6, resolvedOptions);
+      }
+      return null;
+    },
+    async transform(code, id) {
+      if (!id.endsWith(".md")) {
+        return null;
+      }
+      const result = await transformMarkdown(code, id, resolvedOptions);
+      return {
+        code: result.code,
+        map: null
+      };
+    },
+    // Hot Module Replacement support
+    async handleHotUpdate({ file, server }) {
+      if (file.endsWith(".md")) {
+        server.ws.send({
+          type: "custom",
+          event: "ox-content:update",
+          data: { file }
+        });
+        const modules = server.moduleGraph.getModulesByFile(file);
+        return modules ? Array.from(modules) : [];
+      }
+    }
+  };
+  const environmentPlugin = {
+    name: "ox-content:environment",
+    config() {
+      return {
+        environments: {
+          // Markdown processing environment
+          markdown: createMarkdownEnvironment(resolvedOptions)
+        }
+      };
+    }
+  };
+  const docsPlugin = {
+    name: "ox-content:docs",
+    async buildStart() {
+      const docsOptions = resolvedOptions.docs;
+      if (!docsOptions || !docsOptions.enabled) {
+        return;
+      }
+      const root = config?.root || process.cwd();
+      const srcDirs = docsOptions.src.map((src) => path5.resolve(root, src));
+      const outDir = path5.resolve(root, docsOptions.out);
+      try {
+        const extracted = await extractDocs(srcDirs, docsOptions);
+        if (extracted.length > 0) {
+          const generated = generateMarkdown(extracted, docsOptions);
+          await writeDocs(generated, outDir, extracted, docsOptions);
+          console.log(
+            `[ox-content] Generated ${Object.keys(generated).length} documentation files to ${docsOptions.out}`
+          );
+        }
+      } catch (err) {
+        console.warn("[ox-content] Failed to generate documentation:", err);
+      }
+    },
+    configureServer(devServer) {
+      const docsOptions = resolvedOptions.docs;
+      if (!docsOptions || !docsOptions.enabled) {
+        return;
+      }
+      const root = config?.root || process.cwd();
+      const srcDirs = docsOptions.src.map((src) => path5.resolve(root, src));
+      for (const srcDir of srcDirs) {
+        devServer.watcher.add(srcDir);
+      }
+      devServer.watcher.on("change", async (file) => {
+        const isSourceFile = srcDirs.some(
+          (srcDir) => file.startsWith(srcDir) && (file.endsWith(".ts") || file.endsWith(".tsx"))
+        );
+        if (isSourceFile) {
+          const outDir = path5.resolve(root, docsOptions.out);
+          try {
+            const extracted = await extractDocs(srcDirs, docsOptions);
+            if (extracted.length > 0) {
+              const generated = generateMarkdown(extracted, docsOptions);
+              await writeDocs(generated, outDir, extracted, docsOptions);
+            }
+          } catch {
+          }
+        }
+      });
+    }
+  };
+  const ssgPlugin = {
+    name: "ox-content:ssg",
+    async closeBundle() {
+      const ssgOptions = resolvedOptions.ssg;
+      if (!ssgOptions.enabled) {
+        return;
+      }
+      const root = config?.root || process.cwd();
+      try {
+        const result = await buildSsg(resolvedOptions, root);
+        if (result.files.length > 0) {
+          console.log(
+            `[ox-content] Generated ${result.files.length} HTML files`
+          );
+        }
+        if (result.errors.length > 0) {
+          for (const error of result.errors) {
+            console.warn(`[ox-content] ${error}`);
+          }
+        }
+      } catch (err) {
+        console.error("[ox-content] SSG build failed:", err);
+      }
+    }
+  };
+  let searchIndexJson = "";
+  const searchPlugin = {
+    name: "ox-content:search",
+    resolveId(id) {
+      if (id === "virtual:ox-content/search") {
+        return "\0virtual:ox-content/search";
+      }
+      return null;
+    },
+    async load(id) {
+      if (id === "\0virtual:ox-content/search") {
+        const searchOptions = resolvedOptions.search;
+        if (!searchOptions.enabled) {
+          return "export const search = () => []; export const searchOptions = { enabled: false }; export default { search, searchOptions };";
+        }
+        const indexPath = resolvedOptions.base + "search-index.json";
+        return generateSearchModule(searchOptions, indexPath);
+      }
+      return null;
+    },
+    async buildStart() {
+      const searchOptions = resolvedOptions.search;
+      if (!searchOptions.enabled) {
+        return;
+      }
+      const root = config?.root || process.cwd();
+      const srcDir = path5.resolve(root, resolvedOptions.srcDir);
+      try {
+        searchIndexJson = await buildSearchIndex(srcDir, resolvedOptions.base);
+        console.log("[ox-content] Search index built");
+      } catch (err) {
+        console.warn("[ox-content] Failed to build search index:", err);
+      }
+    },
+    async closeBundle() {
+      const searchOptions = resolvedOptions.search;
+      if (!searchOptions.enabled || !searchIndexJson) {
+        return;
+      }
+      const root = config?.root || process.cwd();
+      const outDir = path5.resolve(root, resolvedOptions.outDir);
+      try {
+        await writeSearchIndex(searchIndexJson, outDir);
+        console.log("[ox-content] Search index written to", path5.join(outDir, "search-index.json"));
+      } catch (err) {
+        console.warn("[ox-content] Failed to write search index:", err);
+      }
+    }
+  };
+  return [mainPlugin, environmentPlugin, docsPlugin, ssgPlugin, searchPlugin];
+}
+function resolveOptions(options) {
+  return {
+    srcDir: options.srcDir ?? "docs",
+    outDir: options.outDir ?? "dist",
+    base: options.base ?? "/",
+    ssg: resolveSsgOptions(options.ssg),
+    gfm: options.gfm ?? true,
+    footnotes: options.footnotes ?? true,
+    tables: options.tables ?? true,
+    taskLists: options.taskLists ?? true,
+    strikethrough: options.strikethrough ?? true,
+    highlight: options.highlight ?? false,
+    highlightTheme: options.highlightTheme ?? "github-dark",
+    mermaid: options.mermaid ?? false,
+    frontmatter: options.frontmatter ?? true,
+    toc: options.toc ?? true,
+    tocMaxDepth: options.tocMaxDepth ?? 3,
+    ogImage: options.ogImage ?? false,
+    ogImageOptions: options.ogImageOptions ?? {},
+    transformers: options.transformers ?? [],
+    docs: resolveDocsOptions(options.docs),
+    search: resolveSearchOptions(options.search)
+  };
+}
+function generateVirtualModule(path6, options) {
+  if (path6 === "config") {
+    return `export default ${JSON.stringify(options)};`;
+  }
+  if (path6 === "runtime") {
+    return `
+      export function useMarkdown() {
+        return {
+          render: (content) => {
+            // Client-side rendering if needed
+            return content;
+          },
+        };
+      }
+    `;
+  }
+  return "export default {};";
+}
+export {
+  DEFAULT_HTML_TEMPLATE,
+  buildSearchIndex,
+  buildSsg,
+  createMarkdownEnvironment,
+  extractDocs,
+  generateMarkdown,
+  oxContent2 as oxContent,
+  resolveDocsOptions,
+  resolveSearchOptions,
+  resolveSsgOptions,
+  transformMarkdown,
+  writeDocs,
+  writeSearchIndex
+};
+//# sourceMappingURL=index.js.map