fumadocs-mdx 13.0.8 → 14.0.1

package/dist/next/index.cjs

@@ -5,9 +5,6 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __esm = (fn, res) => function __init() {
-  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
-};
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
@@ -30,11 +27,22 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
-// src/loaders/mdx/preset.ts
-var preset_exports = {};
-__export(preset_exports, {
-  getDefaultMDXOptions: () => getDefaultMDXOptions
+// src/next/index.ts
+var next_exports = {};
+__export(next_exports, {
+  createMDX: () => createMDX,
+  postInstall: () => postInstall
 });
+module.exports = __toCommonJS(next_exports);
+var path5 = __toESM(require("path"), 1);
+
+// src/config/load-from-file.ts
+var import_node_url = require("url");
+
+// src/config/build.ts
+var import_picomatch = __toESM(require("picomatch"), 1);
+
+// src/config/preset.ts
 function pluginOption(def, options = []) {
   const list = def(Array.isArray(options) ? options : []).filter(
     Boolean
@@ -44,94 +52,80 @@ function pluginOption(def, options = []) {
   }
   return list;
 }
-function getDefaultMDXOptions({
-  valueToExport = [],
-  rehypeCodeOptions,
-  remarkImageOptions,
-  remarkHeadingOptions,
-  remarkStructureOptions,
-  remarkCodeTabOptions,
-  remarkNpmOptions,
-  _withoutBundler = false,
-  ...mdxOptions
-}) {
-  const remarkPlugins = pluginOption(
-    (v) => [
-      plugins.remarkGfm,
-      [
-        plugins.remarkHeading,
-        {
-          generateToc: false,
-          ...remarkHeadingOptions
-        }
-      ],
-      remarkImageOptions !== false && [
-        plugins.remarkImage,
-        {
-          ...remarkImageOptions,
-          useImport: _withoutBundler ? false : remarkImageOptions?.useImport
-        }
-      ],
-      "remarkCodeTab" in plugins && remarkCodeTabOptions !== false && [
-        plugins.remarkCodeTab,
-        remarkCodeTabOptions
+function applyMdxPreset(options = {}) {
+  return async (environment = "bundler") => {
+    if (options.preset === "minimal") return options;
+    const plugins = await import("fumadocs-core/mdx-plugins");
+    const {
+      valueToExport = [],
+      rehypeCodeOptions,
+      remarkImageOptions,
+      remarkHeadingOptions,
+      remarkStructureOptions,
+      remarkCodeTabOptions,
+      remarkNpmOptions,
+      ...mdxOptions
+    } = options;
+    const remarkPlugins = pluginOption(
+      (v) => [
+        plugins.remarkGfm,
+        [
+          plugins.remarkHeading,
+          {
+            generateToc: false,
+            ...remarkHeadingOptions
+          }
+        ],
+        remarkImageOptions !== false && [
+          plugins.remarkImage,
+          {
+            ...remarkImageOptions,
+            useImport: remarkImageOptions?.useImport ?? environment === "bundler"
+          }
+        ],
+        "remarkCodeTab" in plugins && remarkCodeTabOptions !== false && [
+          plugins.remarkCodeTab,
+          remarkCodeTabOptions
+        ],
+        "remarkNpm" in plugins && remarkNpmOptions !== false && [plugins.remarkNpm, remarkNpmOptions],
+        ...v,
+        remarkStructureOptions !== false && [
+          plugins.remarkStructure,
+          remarkStructureOptions
+        ],
+        valueToExport.length > 0 && (() => {
+          return (_, file) => {
+            file.data["mdx-export"] ??= [];
+            for (const name of valueToExport) {
+              if (!(name in file.data)) continue;
+              file.data["mdx-export"].push({
+                name,
+                value: file.data[name]
+              });
+            }
+          };
+        })
       ],
-      "remarkNpm" in plugins && remarkNpmOptions !== false && [plugins.remarkNpm, remarkNpmOptions],
-      ...v,
-      remarkStructureOptions !== false && [
-        plugins.remarkStructure,
-        remarkStructureOptions
+      mdxOptions.remarkPlugins
+    );
+    const rehypePlugins = pluginOption(
+      (v) => [
+        rehypeCodeOptions !== false && [plugins.rehypeCode, rehypeCodeOptions],
+        ...v,
+        plugins.rehypeToc
       ],
-      () => {
-        return (_, file) => {
-          file.data["mdx-export"] ??= [];
-          for (const name of valueToExport) {
-            if (name in file.data)
-              file.data["mdx-export"].push({ name, value: file.data[name] });
-          }
-        };
-      }
-    ],
-    mdxOptions.remarkPlugins
-  );
-  const rehypePlugins = pluginOption(
-    (v) => [
-      rehypeCodeOptions !== false && [plugins.rehypeCode, rehypeCodeOptions],
-      ...v,
-      plugins.rehypeToc
-    ],
-    mdxOptions.rehypePlugins
-  );
-  return {
-    ...mdxOptions,
-    outputFormat: _withoutBundler ? "function-body" : mdxOptions.outputFormat,
-    remarkPlugins,
-    rehypePlugins
+      mdxOptions.rehypePlugins
+    );
+    return {
+      ...mdxOptions,
+      outputFormat: environment === "runtime" ? "function-body" : mdxOptions.outputFormat,
+      remarkPlugins,
+      rehypePlugins
+    };
   };
 }
-var plugins;
-var init_preset = __esm({
-  "src/loaders/mdx/preset.ts"() {
-    "use strict";
-    plugins = __toESM(require("fumadocs-core/mdx-plugins"), 1);
-  }
-});
-
-// src/next/index.ts
-var next_exports = {};
-__export(next_exports, {
-  createMDX: () => createMDX,
-  postInstall: () => postInstall
-});
-module.exports = __toCommonJS(next_exports);
-var path7 = __toESM(require("path"), 1);
-
-// src/config/load-from-file.ts
-var path = __toESM(require("path"), 1);
-var import_node_url = require("url");
 
 // src/config/build.ts
-var import_picomatch = __toESM(require("picomatch"), 1);
 var SupportedFormats = {
   doc: ["mdx", "md"],
   meta: ["json", "yaml"]
@@ -142,7 +136,10 @@ function buildCollection(name, config) {
       ...config,
       name,
       meta: buildPrimitiveCollection(name, config.meta),
-      docs: buildPrimitiveCollection(name, config.docs)
+      docs: buildPrimitiveCollection(name, config.docs),
+      hasFile(filePath) {
+        return this.docs.hasFile(filePath) || this.meta.hasFile(filePath);
+      }
     };
   }
   return buildPrimitiveCollection(name, config);
@@ -196,11 +193,6 @@ function buildConfig(config) {
       `Unknown export "${k}", you can only export collections from source configuration file.`
     );
   }
-  if (loaded.collections) {
-    for (const [k, v] of Object.entries(loaded.collections)) {
-      collections.set(k, buildCollection(k, v));
-    }
-  }
   const mdxOptionsCache = /* @__PURE__ */ new Map();
   return {
     global: loaded,
@@ -208,29 +200,31 @@ function buildConfig(config) {
     getCollection(name) {
       return collections.get(name);
     },
-    async getDefaultMDXOptions(mode = "default") {
-      const cached = mdxOptionsCache.get(mode);
+    getMDXOptions(collection, environment = "bundler") {
+      const key = collection ? `${environment}:${collection.name}` : environment;
+      const cached = mdxOptionsCache.get(key);
       if (cached) return cached;
-      const input = this.global.mdxOptions;
-      async function uncached() {
-        const options = typeof input === "function" ? await input() : input;
-        const { getDefaultMDXOptions: getDefaultMDXOptions2 } = await Promise.resolve().then(() => (init_preset(), preset_exports));
-        if (options?.preset === "minimal") return options;
-        return getDefaultMDXOptions2({
-          ...options,
-          _withoutBundler: mode === "remote"
-        });
+      let result;
+      if (collection?.mdxOptions) {
+        const optionsFn = collection.mdxOptions;
+        result = typeof optionsFn === "function" ? optionsFn(environment) : optionsFn;
+      } else {
+        result = (async () => {
+          const optionsFn = this.global.mdxOptions;
+          const options = typeof optionsFn === "function" ? await optionsFn() : optionsFn;
+          return applyMdxPreset(options)(environment);
+        })();
       }
-      const result = uncached();
-      mdxOptionsCache.set(mode, result);
+      mdxOptionsCache.set(key, result);
       return result;
     }
   };
 }
 
 // src/config/load-from-file.ts
-async function compileConfig(configPath, outDir) {
+async function compileConfig(core) {
   const { build } = await import("esbuild");
+  const { configPath, outDir } = core.getOptions();
   const transformed = await build({
     entryPoints: [{ in: configPath, out: "source.config" }],
     bundle: true,
@@ -249,9 +243,9 @@ async function compileConfig(configPath, outDir) {
     throw new Error("failed to compile configuration file");
   }
 }
-async function loadConfig(configPath, outDir, build = false) {
-  if (build) await compileConfig(configPath, outDir);
-  const url = (0, import_node_url.pathToFileURL)(path.resolve(outDir, "source.config.mjs"));
+async function loadConfig(core, build = false) {
+  if (build) await compileConfig(core);
+  const url = (0, import_node_url.pathToFileURL)(core.getCompiledConfigPath());
   url.searchParams.set("hash", Date.now().toString());
   const config = import(url.href).then(
     (loaded) => buildConfig(loaded)
@@ -259,33 +253,7 @@ async function loadConfig(configPath, outDir, build = false) {
   return await config;
 }
 
-// src/next/file-cache.ts
-var import_lru_cache = require("lru-cache");
-var import_promises = __toESM(require("fs/promises"), 1);
-var import_node_path = __toESM(require("path"), 1);
-var map = new import_lru_cache.LRUCache({
-  max: 100
-});
-function toFullPath(file) {
-  if (import_node_path.default.isAbsolute(file)) {
-    return import_node_path.default.relative(process.cwd(), file);
-  }
-  return file;
-}
-async function readFileWithCache(file) {
-  const fullPath = toFullPath(file);
-  const cached = map.get(fullPath);
-  if (cached) return cached;
-  const read = import_promises.default.readFile(fullPath).then((s) => s.toString());
-  map.set(fullPath, read);
-  return read;
-}
-function removeFileCache(file) {
-  map.delete(toFullPath(file));
-}
-
 // src/utils/validation.ts
-var import_picocolors = __toESM(require("picocolors"), 1);
 var ValidationError = class extends Error {
   constructor(message, issues) {
     super(
@@ -295,12 +263,13 @@ ${issues.map((issue) => `  ${issue.path}: ${issue.message}`).join("\n")}`
     this.title = message;
     this.issues = issues;
   }
-  toStringFormatted() {
+  async toStringFormatted() {
+    const picocolors = await import("picocolors");
     return [
-      import_picocolors.default.bold(`[MDX] ${this.title}:`),
+      picocolors.bold(`[MDX] ${this.title}:`),
       ...this.issues.map(
-        (issue) => import_picocolors.default.redBright(
-          `- ${import_picocolors.default.bold(issue.path?.join(".") ?? "*")}: ${issue.message}`
+        (issue) => picocolors.redBright(
+          `- ${picocolors.bold(issue.path?.join(".") ?? "*")}: ${issue.message}`
         )
       )
     ].join("\n");
@@ -322,32 +291,342 @@ async function validate(schema, data, context, errorMessage) {
   return data;
 }
 
-// src/plugins/next.ts
-var path5 = __toESM(require("path"), 1);
-var import_node_crypto = require("crypto");
-
-// src/utils/git-timestamp.ts
+// src/core.ts
 var import_node_path2 = __toESM(require("path"), 1);
-var import_tinyexec = require("tinyexec");
-var cache = /* @__PURE__ */ new Map();
-async function getGitTimestamp(file) {
-  const cached = cache.get(file);
-  if (cached) return cached;
-  try {
-    const out = await (0, import_tinyexec.x)(
-      "git",
-      ["log", "-1", '--pretty="%ai"', import_node_path2.default.relative(process.cwd(), file)],
-      {
-        throwOnError: true
+var import_promises = __toESM(require("fs/promises"), 1);
+
+// src/utils/codegen.ts
+var import_node_path = __toESM(require("path"), 1);
+var import_tinyglobby = require("tinyglobby");
+function createCodegen({
+  target = "default",
+  outDir = "",
+  jsExtension = false,
+  globCache = /* @__PURE__ */ new Map()
+}) {
+  let eagerImportId = 0;
+  const banner = ["// @ts-nocheck"];
+  if (target === "vite") {
+    banner.push('/// <reference types="vite/client" />');
+  }
+  return {
+    options: {
+      target,
+      outDir
+    },
+    lines: [],
+    addImport(statement) {
+      this.lines.unshift(statement);
+    },
+    async pushAsync(insert) {
+      for (const line of await Promise.all(insert)) {
+        if (line === void 0) continue;
+        this.lines.push(line);
       }
-    );
-    const time = new Date(out.stdout);
-    cache.set(file, time);
-    return time;
-  } catch {
-    return;
+    },
+    async generateGlobImport(patterns, options) {
+      if (target === "vite") {
+        return this.generateViteGlobImport(patterns, options);
+      }
+      return this.generateNodeGlobImport(patterns, options);
+    },
+    generateViteGlobImport(patterns, { base, ...rest }) {
+      patterns = (typeof patterns === "string" ? [patterns] : patterns).map(
+        normalizeViteGlobPath
+      );
+      return `import.meta.glob(${JSON.stringify(patterns)}, ${JSON.stringify(
+        {
+          base: normalizeViteGlobPath(import_node_path.default.relative(outDir, base)),
+          ...rest
+        },
+        null,
+        2
+      )})`;
+    },
+    async generateNodeGlobImport(patterns, {
+      base,
+      eager = false,
+      query = {},
+      import: importName
+    }) {
+      const cacheKey = JSON.stringify({ patterns, base });
+      let files = globCache.get(cacheKey);
+      if (!files) {
+        files = (0, import_tinyglobby.glob)(patterns, {
+          cwd: base
+        });
+        globCache.set(cacheKey, files);
+      }
+      let code = "{";
+      for (const item of await files) {
+        const fullPath = import_node_path.default.join(base, item);
+        const searchParams = new URLSearchParams();
+        for (const [k, v] of Object.entries(query)) {
+          searchParams.set(k, v);
+        }
+        const importPath = this.formatImportPath(fullPath) + "?" + searchParams.toString();
+        if (eager) {
+          const name = `__fd_glob_${eagerImportId++}`;
+          this.lines.unshift(
+            importName ? `import { ${importName} as ${name} } from ${JSON.stringify(importPath)}` : `import * as ${name} from ${JSON.stringify(importPath)}`
+          );
+          code += `${JSON.stringify(item)}: ${name}, `;
+        } else {
+          let line = `${JSON.stringify(item)}: () => import(${JSON.stringify(importPath)})`;
+          if (importName) {
+            line += `.then(mod => mod.${importName})`;
+          }
+          code += `${line}, `;
+        }
+      }
+      code += "}";
+      return code;
+    },
+    formatImportPath(file) {
+      const ext = import_node_path.default.extname(file);
+      let filename;
+      if (ext === ".ts" && jsExtension) {
+        filename = file.substring(0, file.length - ext.length) + ".js";
+      } else if (ext === ".ts") {
+        filename = file.substring(0, file.length - ext.length);
+      } else {
+        filename = file;
+      }
+      const importPath = slash(import_node_path.default.relative(outDir, filename));
+      return importPath.startsWith(".") ? importPath : `./${importPath}`;
+    },
+    toString() {
+      return [...banner, ...this.lines].join("\n");
+    }
+  };
+}
+function normalizeViteGlobPath(file) {
+  file = slash(file);
+  if (file.startsWith("./")) return file;
+  if (file.startsWith("/")) return `.${file}`;
+  return `./${file}`;
+}
+function slash(path6) {
+  const isExtendedLengthPath = path6.startsWith("\\\\?\\");
+  if (isExtendedLengthPath) {
+    return path6;
+  }
+  return path6.replaceAll("\\", "/");
+}
+function ident(code, tab = 1) {
+  return code.split("\n").map((v) => "  ".repeat(tab) + v).join("\n");
+}
+
+// src/core.ts
+var _Defaults = {
+  configPath: "source.config.ts",
+  outDir: ".source"
+};
+async function getPlugins(pluginOptions) {
+  const plugins = [];
+  for await (const option of pluginOptions) {
+    if (!option) continue;
+    if (Array.isArray(option)) plugins.push(...await getPlugins(option));
+    else plugins.push(option);
+  }
+  return plugins;
+}
+function createCore(options, defaultPlugins = []) {
+  let config;
+  let plugins;
+  async function transformMetadata({
+    collection,
+    filePath,
+    source
+  }, data) {
+    if (collection.schema) {
+      data = await validate(
+        collection.schema,
+        data,
+        { path: filePath, source },
+        collection.type === "doc" ? `invalid frontmatter in ${filePath}` : `invalid data in ${filePath}`
+      );
+    }
+    return data;
+  }
+  const core = {
+    /**
+     * Convenient cache store, reset when config changes
+     */
+    cache: /* @__PURE__ */ new Map(),
+    async init({ config: newConfig }) {
+      config = await newConfig;
+      this.cache.clear();
+      plugins = await getPlugins([
+        postprocessPlugin(),
+        ...defaultPlugins,
+        ...config.global.plugins ?? []
+      ]);
+      for (const plugin of plugins) {
+        const out = await plugin.config?.call(pluginContext, config);
+        if (out) config = out;
+      }
+    },
+    getOptions() {
+      return options;
+    },
+    getConfig() {
+      return config;
+    },
+    /**
+     * The file path of compiled config file, the file may not exist (e.g. on Vite, or still compiling)
+     */
+    getCompiledConfigPath() {
+      return import_node_path2.default.join(options.outDir, "source.config.mjs");
+    },
+    getPlugins() {
+      return plugins;
+    },
+    getPluginContext() {
+      return pluginContext;
+    },
+    async initServer(server) {
+      for (const plugin of plugins) {
+        await plugin.configureServer?.call(pluginContext, server);
+      }
+    },
+    async emit({ filterPlugin = () => true } = {}) {
+      return (await Promise.all(
+        plugins.map((plugin) => {
+          if (!filterPlugin(plugin) || !plugin.emit) return [];
+          return plugin.emit.call(pluginContext);
+        })
+      )).flat();
+    },
+    async emitAndWrite(emitOptions) {
+      const start = performance.now();
+      const out = await this.emit(emitOptions);
+      await Promise.all(
+        out.map(async (entry) => {
+          const file = import_node_path2.default.join(options.outDir, entry.path);
+          await import_promises.default.mkdir(import_node_path2.default.dirname(file), { recursive: true });
+          await import_promises.default.writeFile(file, entry.content);
+        })
+      );
+      console.log(`[MDX] generated files in ${performance.now() - start}ms`);
+    },
+    async transformMeta(options2, data) {
+      const ctx = {
+        ...pluginContext,
+        ...options2
+      };
+      data = await transformMetadata(options2, data);
+      for (const plugin of plugins) {
+        if (plugin.meta?.transform)
+          data = await plugin.meta.transform.call(ctx, data) ?? data;
+      }
+      return data;
+    },
+    async transformFrontmatter(options2, data) {
+      const ctx = {
+        ...pluginContext,
+        ...options2
+      };
+      data = await transformMetadata(options2, data);
+      for (const plugin of plugins) {
+        if (plugin.doc?.frontmatter)
+          data = await plugin.doc.frontmatter.call(ctx, data) ?? data;
+      }
+      return data;
+    },
+    async transformVFile(options2, file) {
+      const ctx = {
+        ...pluginContext,
+        ...options2
+      };
+      for (const plugin of plugins) {
+        if (plugin.doc?.vfile)
+          file = await plugin.doc.vfile.call(ctx, file) ?? file;
+      }
+      return file;
+    }
+  };
+  const pluginContext = {
+    core,
+    ...options
+  };
+  return core;
+}
+function postprocessPlugin() {
+  const LinkReferenceTypes = `{
+  /**
+   * extracted references (e.g. hrefs, paths), useful for analyzing relationships between pages.
+   */
+  extractedReferences?: import('fumadocs-mdx').ExtractedReference[];
+}`;
+  return {
+    "index-file": {
+      generateTypeConfig() {
+        const lines = [];
+        lines.push("{");
+        lines.push("  DocData: {");
+        for (const collection of this.core.getConfig().collectionList) {
+          let postprocessOptions;
+          switch (collection.type) {
+            case "doc":
+              postprocessOptions = collection.postprocess;
+              break;
+            case "docs":
+              postprocessOptions = collection.docs.postprocess;
+              break;
+          }
+          if (postprocessOptions?.extractLinkReferences) {
+            lines.push(ident(`${collection.name}: ${LinkReferenceTypes},`, 2));
+          }
+        }
+        lines.push("  }");
+        lines.push("}");
+        return lines.join("\n");
+      },
+      serverOptions(options) {
+        options.doc ??= {};
+        options.doc.passthroughs ??= [];
+        options.doc.passthroughs.push("extractedReferences");
+      }
+    }
+  };
+}
+
+// src/loaders/index.ts
+var metaLoaderGlob = /\.(json|yaml)(\?.+?)?$/;
+var mdxLoaderGlob = /\.mdx?(\?.+?)?$/;
+
+// src/plugins/index-file.ts
+var import_path = __toESM(require("path"), 1);
+var import_tinyglobby2 = require("tinyglobby");
+
+// src/utils/fs-cache.ts
+var import_lru_cache = require("lru-cache");
+var import_promises2 = __toESM(require("fs/promises"), 1);
+var import_node_path3 = __toESM(require("path"), 1);
+var map = new import_lru_cache.LRUCache({
+  max: 100
+});
+function toFullPath(file) {
+  if (import_node_path3.default.isAbsolute(file)) {
+    return import_node_path3.default.relative(process.cwd(), file);
   }
+  return file;
 }
+function readFileWithCache(file) {
+  const fullPath = toFullPath(file);
+  const cached = map.get(fullPath);
+  if (cached) return cached;
+  const read = import_promises2.default.readFile(fullPath).then((s) => s.toString());
+  map.set(fullPath, read);
+  return read;
+}
+function removeFileCache(file) {
+  map.delete(toFullPath(file));
+}
+
+// src/plugins/index-file.ts
+var import_crypto = require("crypto");
 
 // src/utils/fuma-matter.ts
 var import_js_yaml = require("js-yaml");
@@ -365,323 +644,309 @@ function fumaMatter(input) {
   return output;
 }
 
-// src/utils/import-formatter.ts
-var import_node_path3 = __toESM(require("path"), 1);
-function getImportCode(info) {
-  const specifier = JSON.stringify(info.specifier);
-  if (info.type === "default") return `import ${info.name} from ${specifier}`;
-  if (info.type === "namespace")
-    return `import * as ${info.name} from ${specifier}`;
-  if (info.type === "named") {
-    const names = info.names.map(
-      (name) => Array.isArray(name) ? `${name[0]} as ${name[1]}` : name
-    );
-    return `import { ${names.join(", ")} } from ${specifier}`;
-  }
-  return `import ${specifier}`;
-}
-function toImportPath(file, config) {
-  const ext = import_node_path3.default.extname(file);
-  let filename;
-  if (ext === ".ts" && config.jsExtension) {
-    filename = file.substring(0, file.length - ext.length) + ".js";
-  } else if (ext === ".ts") {
-    filename = file.substring(0, file.length - ext.length);
-  } else {
-    filename = file;
+// src/plugins/index-file.ts
+function indexFile(options = {}) {
+  const {
+    target = "default",
+    addJsExtension,
+    browser = true,
+    dynamic = true
+  } = options;
+  let config;
+  let dynamicCollections;
+  function isDynamic(collection) {
+    return collection.type === "docs" && collection.docs.dynamic || collection.type === "doc" && collection.dynamic;
   }
-  let importPath;
-  if ("relativeTo" in config) {
-    importPath = import_node_path3.default.relative(config.relativeTo, filename);
-    if (!import_node_path3.default.isAbsolute(importPath) && !importPath.startsWith(".")) {
-      importPath = `./${importPath}`;
+  function generateConfigs(core) {
+    const serverOptions = {};
+    const typeConfigs = [];
+    const ctx = core.getPluginContext();
+    for (const plugin of core.getPlugins()) {
+      const indexFilePlugin = plugin["index-file"];
+      if (!indexFilePlugin) continue;
+      indexFilePlugin.serverOptions?.call(ctx, serverOptions);
+      const config2 = indexFilePlugin.generateTypeConfig?.call(ctx);
+      if (config2) typeConfigs.push(config2);
     }
-  } else {
-    importPath = import_node_path3.default.resolve(filename);
+    if (typeConfigs.length === 0) {
+      typeConfigs.push("{ DocData: {} }");
+    }
+    return {
+      serverOptions,
+      tc: typeConfigs.join(" & ")
+    };
   }
-  return importPath.replaceAll(import_node_path3.default.sep, "/");
-}
-
-// src/plugins/next.ts
-var import_js_yaml2 = require("js-yaml");
-function next() {
-  let config;
-  let shouldEmitOnChange = false;
   return {
-    name: "next",
+    name: "index-file",
     config(v) {
       config = v;
-      shouldEmitOnChange = config.collectionList.some((collection) => {
-        return collection.type === "doc" && collection.async || collection.type === "docs" || collection.type === "meta";
-      });
+      dynamicCollections = config.collectionList.filter(isDynamic);
     },
     configureServer(server) {
       if (!server.watcher) return;
-      server.watcher.on("all", async (event) => {
-        if (event === "change" && !shouldEmitOnChange) return;
+      server.watcher.on("all", async (event, file) => {
+        removeFileCache(file);
+        if (dynamicCollections.length === 0) {
+          if (target === "vite") return;
+          if (target === "default" && event === "change") return;
+        }
+        const updatedCollection = config.collectionList.find(
+          (collection) => collection.hasFile(file)
+        );
+        if (!updatedCollection) return;
+        if (!isDynamic(updatedCollection)) {
+          if (target === "vite") return;
+          if (target === "default" && event === "change") return;
+        }
         await this.core.emitAndWrite({
-          filterPlugin: (plugin) => plugin.name === "next"
+          filterPlugin: (plugin) => plugin.name === "index-file"
         });
       });
     },
     async emit() {
-      return [
-        {
-          path: "index.ts",
-          content: await indexFile(this.configPath, config, {
-            relativeTo: this.outDir
-          })
-        }
+      const globCache = /* @__PURE__ */ new Map();
+      const { serverOptions, tc } = generateConfigs(this.core);
+      const toEmitEntry = async (path6, content) => {
+        const codegen = createCodegen({
+          target,
+          outDir: this.outDir,
+          jsExtension: addJsExtension,
+          globCache
+        });
+        await content({
+          core: this.core,
+          codegen,
+          serverOptions,
+          tc
+        });
+        return {
+          path: path6,
+          content: codegen.toString()
+        };
+      };
+      const out = [
+        toEmitEntry("server.ts", generateServerIndexFile)
       ];
+      if (dynamic)
+        out.push(toEmitEntry("dynamic.ts", generateDynamicIndexFile));
+      if (browser)
+        out.push(toEmitEntry("browser.ts", generateBrowserIndexFile));
+      return await Promise.all(out);
     }
   };
 }
-async function indexFile(configPath, config, importPath) {
-  let asyncInit = false;
-  const lines = [
-    getImportCode({
-      type: "named",
-      names: ["_runtime"],
-      specifier: "fumadocs-mdx/runtime/next"
-    }),
-    getImportCode({
-      type: "namespace",
-      specifier: toImportPath(configPath, importPath),
-      name: "_source"
-    })
-  ];
-  function getDocEntries(collection, files) {
-    return files.map((file, i) => {
-      const importId = `d_${collection.name}_${i}`;
-      const params = [`collection=${collection.name}`];
-      lines.unshift(
-        getImportCode({
-          type: "namespace",
-          name: importId,
-          specifier: `${toImportPath(file.fullPath, importPath)}?${params.join("&")}`
-        })
-      );
-      return `{ info: ${JSON.stringify(file)}, data: ${importId} }`;
-    });
-  }
-  async function getMetaEntries(collection, files) {
-    const items = files.map(async (file) => {
-      const source = await readFileWithCache(file.fullPath).catch(() => "");
-      let data = source.length === 0 ? {} : parseMetaEntry(file.fullPath, source);
-      if (collection?.schema) {
-        data = await validate(
-          collection.schema,
-          data,
-          {
-            source,
-            path: file.fullPath
-          },
-          `invalid data in ${file.fullPath}`
-        );
+async function generateServerIndexFile({
+  core,
+  codegen,
+  serverOptions,
+  tc
+}) {
+  codegen.lines.push(
+    `import { server } from 'fumadocs-mdx/runtime/server';`,
+    `import type * as Config from '${codegen.formatImportPath(core.getOptions().configPath)}';`,
+    "",
+    `const create = server<typeof Config, ${tc}>(${JSON.stringify(serverOptions)});`
+  );
+  async function generateCollectionObject(collection) {
+    switch (collection.type) {
+      case "docs": {
+        if (collection.docs.dynamic) return;
+        if (collection.docs.async) {
+          const [metaGlob2, headGlob, bodyGlob] = await Promise.all([
+            generateMetaCollectionGlob(codegen, collection.meta, true),
+            generateDocCollectionFrontmatterGlob(
+              codegen,
+              collection.docs,
+              true
+            ),
+            generateDocCollectionGlob(codegen, collection.docs)
+          ]);
+          return `await create.docsLazy("${collection.name}", "${collection.dir}", ${metaGlob2}, ${headGlob}, ${bodyGlob})`;
+        }
+        const [metaGlob, docGlob] = await Promise.all([
+          generateMetaCollectionGlob(codegen, collection.meta, true),
+          generateDocCollectionGlob(codegen, collection.docs, true)
+        ]);
+        return `await create.docs("${collection.name}", "${collection.dir}", ${metaGlob}, ${docGlob})`;
       }
-      return JSON.stringify({
-        info: file,
-        data
-      });
-    });
-    return Promise.all(items);
+      case "doc":
+        if (collection.dynamic) return;
+        if (collection.async) {
+          const [headGlob, bodyGlob] = await Promise.all([
+            generateDocCollectionFrontmatterGlob(codegen, collection, true),
+            generateDocCollectionGlob(codegen, collection)
+          ]);
+          return `await create.docLazy("${collection.name}", "${collection.dir}", ${headGlob}, ${bodyGlob})`;
+        }
+        return `await create.doc("${collection.name}", "${collection.dir}", ${await generateDocCollectionGlob(
+          codegen,
+          collection,
+          true
+        )})`;
+      case "meta":
+        return `await create.meta("${collection.name}", "${collection.dir}", ${await generateMetaCollectionGlob(
+          codegen,
+          collection,
+          true
+        )})`;
+    }
   }
-  async function getAsyncEntries(collection, files) {
-    if (!asyncInit) {
-      lines.unshift(
-        getImportCode({
-          type: "named",
-          specifier: "fumadocs-mdx/runtime/async",
-          names: ["_runtimeAsync", "buildConfig"]
-        }),
-        "const _sourceConfig = buildConfig(_source)",
-        getImportCode({
-          type: "default",
-          name: "path",
-          specifier: "node:path"
-        })
-      );
-      asyncInit = true;
+  await codegen.pushAsync(
+    core.getConfig().collectionList.map(async (collection) => {
+      const obj = await generateCollectionObject(collection);
+      if (!obj) return;
+      return `
+export const ${collection.name} = ${obj};`;
+    })
+  );
+}
+async function generateDynamicIndexFile({
+  core,
+  codegen,
+  serverOptions,
+  tc
+}) {
+  const { configPath } = core.getOptions();
+  codegen.lines.push(
+    `import { dynamic } from 'fumadocs-mdx/runtime/dynamic';`,
+    `import * as Config from '${codegen.formatImportPath(configPath)}';`,
+    "",
+    `const create = await dynamic<typeof Config, ${tc}>(Config, ${JSON.stringify(core.getOptions())}, ${JSON.stringify(serverOptions)});`
+  );
+  async function generateCollectionObjectEntry(collection, file) {
+    const fullPath = import_path.default.join(collection.dir, file);
+    const content = await readFileWithCache(fullPath).catch(() => "");
+    const parsed = fumaMatter(content);
+    const data = await core.transformFrontmatter(
+      {
+        collection,
+        filePath: fullPath,
+        source: content
+      },
+      parsed.data
+    );
+    const hash = (0, import_crypto.createHash)("md5").update(content).digest("hex");
+    const infoStr = [
+      // make sure it's included in vercel/nft
+      `absolutePath: path.resolve(${JSON.stringify(fullPath)})`
+    ];
+    for (const [k, v] of Object.entries({
+      info: {
+        fullPath,
+        path: file
+      },
+      data,
+      hash
+    })) {
+      infoStr.push(`${k}: ${JSON.stringify(v)}`);
     }
-    const entries = files.map(async (file) => {
-      const content = await readFileWithCache(file.fullPath).catch(() => "");
-      const parsed = fumaMatter(content);
-      let data = parsed.data;
-      if (collection.schema) {
-        data = await validate(
-          collection.schema,
-          parsed.data,
-          { path: file.fullPath, source: parsed.content },
-          `invalid frontmatter in ${file.fullPath}`
-        );
-      }
-      let lastModified;
-      if (config.global?.lastModifiedTime === "git") {
-        lastModified = await getGitTimestamp(file.fullPath);
-      }
-      const hash = (0, import_node_crypto.createHash)("md5").update(content).digest("hex");
-      const infoStr = [];
-      for (const [k, v] of Object.entries({ ...file, hash })) {
-        infoStr.push(`${k}: ${JSON.stringify(v)}`);
-      }
-      infoStr.push(
-        `absolutePath: path.resolve(${JSON.stringify(file.fullPath)})`
-      );
-      return `{ info: { ${infoStr.join(", ")} }, lastModified: ${JSON.stringify(lastModified)}, data: ${JSON.stringify(data)} }`;
-    });
-    return Promise.all(entries);
+    return `{ ${infoStr.join(", ")} }`;
   }
-  const declares = config.collectionList.map(async (collection) => {
-    const k = collection.name;
-    if (collection.type === "docs") {
-      const docs = await globCollectionFiles(collection.docs);
-      const metas = await globCollectionFiles(collection.meta);
-      const metaEntries = (await getMetaEntries(collection.meta, metas)).join(
-        ", "
-      );
-      if (collection.docs.async) {
-        const docsEntries2 = (await getAsyncEntries(collection.docs, docs)).join(
-          ", "
+  async function generateCollectionObject(parent) {
+    let collection;
+    if (parent.type === "doc") collection = parent;
+    else if (parent.type === "docs") collection = parent.docs;
+    if (!collection || !collection.dynamic) return;
+    const files = await (0, import_tinyglobby2.glob)(collection.patterns, {
+      cwd: collection.dir
+    });
+    const entries = await Promise.all(
+      files.map((file) => generateCollectionObjectEntry(collection, file))
+    );
+    switch (parent.type) {
+      case "docs": {
+        const metaGlob = await generateMetaCollectionGlob(
+          codegen,
+          parent.meta,
+          true
         );
-        return `export const ${k} = _runtimeAsync.docs<typeof _source.${k}>([${docsEntries2}], [${metaEntries}], "${k}", _sourceConfig)`;
+        return `await create.docs("${parent.name}", "${parent.dir}", ${metaGlob}, ${entries.join(", ")})`;
       }
-      const docsEntries = getDocEntries(collection.docs, docs).join(", ");
-      return `export const ${k} = _runtime.docs<typeof _source.${k}>([${docsEntries}], [${metaEntries}])`;
-    }
-    const files = await globCollectionFiles(collection);
-    if (collection.type === "meta") {
-      return `export const ${k} = _runtime.meta<typeof _source.${k}>([${(await getMetaEntries(collection, files)).join(", ")}]);`;
+      case "doc":
+        return `await create.doc("${collection.name}", "${collection.dir}", ${entries.join(", ")})`;
     }
-    if (collection.async) {
-      return `export const ${k} = _runtimeAsync.doc<typeof _source.${k}>([${(await getAsyncEntries(collection, files)).join(", ")}], "${k}", _sourceConfig)`;
-    }
-    return `export const ${k} = _runtime.doc<typeof _source.${k}>([${getDocEntries(collection, files).join(", ")}]);`;
-  });
-  const resolvedDeclares = await Promise.all(declares);
-  return [
-    `// @ts-nocheck -- skip type checking`,
-    ...lines,
-    ...resolvedDeclares
-  ].join("\n");
-}
-function parseMetaEntry(file, content) {
-  const extname2 = path5.extname(file);
-  try {
-    if (extname2 === ".json") return JSON.parse(content);
-    if (extname2 === ".yaml") return (0, import_js_yaml2.load)(content);
-  } catch (e) {
-    throw new Error(`Failed to parse meta file: ${file}.`, {
-      cause: e
-    });
   }
-  throw new Error(`Unknown meta file format: ${extname2}, in ${file}.`);
+  await codegen.pushAsync(
+    core.getConfig().collectionList.map(async (collection) => {
+      const obj = await generateCollectionObject(collection);
+      if (!obj) return;
+      return `
+export const ${collection.name} = ${obj};`;
+    })
+  );
 }
-async function globCollectionFiles(collection) {
-  const { glob } = await import("tinyglobby");
-  const files = /* @__PURE__ */ new Map();
-  const dirs = Array.isArray(collection.dir) ? collection.dir : [collection.dir];
-  await Promise.all(
-    dirs.map(async (dir) => {
-      const result = await glob(collection.patterns, {
-        cwd: path5.resolve(dir)
-      });
-      for (const item of result) {
-        if (!collection.isFileSupported(item)) continue;
-        const fullPath = path5.join(dir, item);
-        files.set(fullPath, {
-          path: item,
-          fullPath
-        });
+async function generateBrowserIndexFile({ core, codegen, tc }) {
+  codegen.lines.push(
+    `import { browser } from 'fumadocs-mdx/runtime/browser';`,
+    `import type * as Config from '${codegen.formatImportPath(core.getOptions().configPath)}';`,
+    "",
+    `const create = browser<typeof Config, ${tc}>();`
+  );
+  async function generateCollectionObject(collection) {
+    switch (collection.type) {
+      case "docs": {
+        if (collection.docs.dynamic) return;
+        return generateCollectionObject(collection.docs);
       }
+      case "doc":
+        if (collection.dynamic) return;
+        return `create.doc("${collection.name}", ${await generateDocCollectionGlob(codegen, collection)})`;
+    }
+  }
+  codegen.lines.push("const browserCollections = {");
+  await codegen.pushAsync(
+    core.getConfig().collectionList.map(async (collection) => {
+      const obj = await generateCollectionObject(collection);
+      if (!obj) return;
+      return ident(`${collection.name}: ${obj},`);
     })
   );
-  return Array.from(files.values());
-}
-
-// src/core.ts
-var import_node_path4 = __toESM(require("path"), 1);
-var import_promises2 = __toESM(require("fs/promises"), 1);
-function findConfigFile() {
-  return import_node_path4.default.resolve("source.config.ts");
+  codegen.lines.push("};", "export default browserCollections;");
 }
-function createCore(options, defaultPlugins = []) {
-  let config;
-  let plugins2;
-  return {
-    _options: options,
-    getPluginContext() {
-      return {
-        core: this,
-        ...options
-      };
+function generateDocCollectionFrontmatterGlob(codegen, collection, eager = false) {
+  return codegen.generateGlobImport(collection.patterns, {
+    query: {
+      collection: collection.name,
+      only: "frontmatter"
     },
-    /**
-     * Convenient cache store, reset when config changes
-     */
-    cache: /* @__PURE__ */ new Map(),
-    async init({ config: newConfig }) {
-      config = await newConfig;
-      this.cache.clear();
-      plugins2 = [];
-      for await (const option of [
-        ...defaultPlugins,
-        ...config.global.plugins ?? []
-      ]) {
-        if (!option) continue;
-        if (Array.isArray(option)) plugins2.push(...option);
-        else plugins2.push(option);
-      }
-      for (const plugin of plugins2) {
-        const out = await plugin.config?.call(this.getPluginContext(), config);
-        if (out) config = out;
-      }
-      return this;
-    },
-    getConfig() {
-      return config;
+    import: "frontmatter",
+    base: collection.dir,
+    eager
+  });
+}
+function generateDocCollectionGlob(codegen, collection, eager = false) {
+  return codegen.generateGlobImport(collection.patterns, {
+    query: {
+      collection: collection.name
     },
-    async initServer(server) {
-      for (const plugin of plugins2) {
-        await plugin.configureServer?.call(this.getPluginContext(), server);
-      }
+    base: collection.dir,
+    eager
+  });
+}
+function generateMetaCollectionGlob(codegen, collection, eager = false) {
+  return codegen.generateGlobImport(collection.patterns, {
+    query: {
+      collection: collection.name
     },
-    async emitAndWrite({
-      filterPlugin = () => true
-    } = {}) {
-      const start = performance.now();
-      const out = await Promise.all(
-        plugins2.map((plugin) => {
-          if (!filterPlugin(plugin) || !plugin.emit) return [];
-          return plugin.emit.call(this.getPluginContext());
-        })
-      );
-      await Promise.all(
-        out.flat().map(async (entry) => {
-          const file = import_node_path4.default.join(options.outDir, entry.path);
-          await import_promises2.default.mkdir(import_node_path4.default.dirname(file), { recursive: true });
-          await import_promises2.default.writeFile(file, entry.content);
-        })
-      );
-      console.log(`[MDX] generated files in ${performance.now() - start}ms`);
-    }
-  };
+    import: "default",
+    base: collection.dir,
+    eager
+  });
 }
 
-// src/loaders/index.ts
-var mdxLoaderGlob = /\.mdx?(\?.+?)?$/;
-
 // src/next/index.ts
 var defaultPageExtensions = ["mdx", "md", "jsx", "js", "tsx", "ts"];
 function createMDX(createOptions = {}) {
-  const options = applyDefaults(createOptions);
+  const core = createNextCore(applyDefaults(createOptions));
   const isDev = process.env.NODE_ENV === "development";
   if (process.env._FUMADOCS_MDX !== "1") {
     process.env._FUMADOCS_MDX = "1";
-    void init(isDev, options);
+    void init(isDev, core);
   }
   return (nextConfig = {}) => {
     const loaderOptions = {
-      ...options,
+      ...core.getOptions(),
+      compiledConfigPath: core.getCompiledConfigPath(),
       isDev
     };
     const turbopack = {
@@ -696,6 +961,24 @@ function createMDX(createOptions = {}) {
             }
           ],
           as: "*.js"
+        },
+        "*.json": {
+          loaders: [
+            {
+              loader: "fumadocs-mdx/loader-meta",
+              options: loaderOptions
+            }
+          ],
+          as: "*.json"
+        },
+        "*.yaml": {
+          loaders: [
+            {
+              loader: "fumadocs-mdx/loader-meta",
+              options: loaderOptions
+            }
+          ],
+          as: "*.js"
         }
       }
     };
@@ -703,42 +986,54 @@ function createMDX(createOptions = {}) {
       ...nextConfig,
       turbopack,
       pageExtensions: nextConfig.pageExtensions ?? defaultPageExtensions,
-      webpack: (config, options2) => {
+      webpack: (config, options) => {
         config.resolve ||= {};
         config.module ||= {};
         config.module.rules ||= [];
-        config.module.rules.push({
-          test: mdxLoaderGlob,
-          use: [
-            options2.defaultLoaders.babel,
-            {
-              loader: "fumadocs-mdx/loader-mdx",
-              options: loaderOptions
-            }
-          ]
-        });
+        config.module.rules.push(
+          {
+            test: mdxLoaderGlob,
+            use: [
+              options.defaultLoaders.babel,
+              {
+                loader: "fumadocs-mdx/loader-mdx",
+                options: loaderOptions
+              }
+            ]
+          },
+          {
+            test: metaLoaderGlob,
+            use: [
+              options.defaultLoaders.babel,
+              {
+                loader: "fumadocs-mdx/loader-meta",
+                options: loaderOptions
+              }
+            ]
+          }
+        );
         config.plugins ||= [];
-        return nextConfig.webpack?.(config, options2) ?? config;
+        return nextConfig.webpack?.(config, options) ?? config;
       }
     };
   };
 }
-async function init(dev, options) {
-  const core = createNextCore(options);
+async function init(dev, core) {
   async function initOrReload() {
     await core.init({
-      config: loadConfig(options.configPath, options.outDir, true)
+      config: loadConfig(core, true)
     });
     await core.emitAndWrite();
   }
   async function devServer() {
     const { FSWatcher } = await import("chokidar");
+    const { configPath, outDir } = core.getOptions();
     const watcher = new FSWatcher({
       ignoreInitial: true,
       persistent: true,
-      ignored: [options.outDir]
+      ignored: [outDir]
     });
-    watcher.add(options.configPath);
+    watcher.add(configPath);
     for (const collection of core.getConfig().collectionList) {
       if (collection.type === "docs") {
         watcher.add(collection.docs.dir);
@@ -750,10 +1045,9 @@ async function init(dev, options) {
     watcher.on("ready", () => {
       console.log("[MDX] started dev server");
     });
-    watcher.on("all", async (event, file) => {
-      const absolutePath = path7.resolve(file);
-      if (event === "change") removeFileCache(absolutePath);
-      if (absolutePath === path7.resolve(options.configPath)) {
+    const absoluteConfigPath = path5.resolve(configPath);
+    watcher.on("all", async (_event, file) => {
+      if (path5.resolve(file) === absoluteConfigPath) {
         watcher.removeAllListeners();
         await watcher.close();
         await initOrReload();
@@ -773,32 +1067,28 @@ async function init(dev, options) {
     await devServer();
   }
 }
-async function postInstall(configPath = findConfigFile(), outDir = ".source") {
-  const core = await createNextCore({
-    outDir,
-    configPath
-  }).init({
-    config: loadConfig(configPath, outDir, true)
+async function postInstall(options) {
+  const core = createNextCore(applyDefaults(options));
+  await core.init({
+    config: loadConfig(core, true)
   });
   await core.emitAndWrite();
 }
 function applyDefaults(options) {
   return {
-    outDir: options.outDir ?? ".source",
-    configPath: options.configPath ?? findConfigFile()
+    index: {},
+    outDir: options.outDir ?? _Defaults.outDir,
+    configPath: options.configPath ?? _Defaults.configPath
   };
 }
-function createNextCore({
-  outDir,
-  configPath
-}) {
+function createNextCore(options) {
   const core = createCore(
     {
       environment: "next",
-      outDir,
-      configPath
+      outDir: options.outDir,
+      configPath: options.configPath
     },
-    [next()]
+    [options.index && indexFile(options.index)]
   );
   return {
     ...core,
@@ -807,7 +1097,7 @@ function createNextCore({
         await core.emitAndWrite(...args);
       } catch (err) {
         if (err instanceof ValidationError) {
-          console.error(err.toStringFormatted());
+          console.error(await err.toStringFormatted());
         } else {
           console.error(err);
         }